#include <algorithm>
#include <cassert>
#include <iostream>
#include <numeric>
#include <vector>

std::vector<std::pair<int, int>> edges;
std::vector<std::vector<int>> graph, best_graph;
std::vector<int> w, p;

int n, max_w, min_ans;

void calc(int i) {
	if (i == (int) edges.size()) {
		int cur_max_w = 0;
		for (int j = 0; j < i; ++j) {
			auto [u, v] = edges[j];
			graph[u][v] = graph[v][u] = w[j];
			if (w[j] >= min_ans) return;
			cur_max_w = std::max(cur_max_w, w[j]);
		}
		assert(cur_max_w < min_ans);
		for (int j = 0; j < n; ++j) {
			graph[j][j] = 0;
		}
		std::iota(p.begin(), p.end(), 0);
		bool has_bad = false;
		do {
			bool ok = true;
			int last = graph[p[0]][p[1]];
			for (int j = 2; j < n; ++j) {
				int next = graph[p[j - 1]][p[j]];
				if (next < last) {
					ok = false;
					break;
				}
				last = next;
			}
			if (ok) {
				has_bad = true;
				break;
			}
		}
		while (std::next_permutation(p.begin(), p.end()));
		if (!has_bad) {
			min_ans = cur_max_w;
			best_graph = graph;
		}
		return;
	}
	for (w[i] = 1; w[i] < min_ans; ++w[i]) {
		calc(i + 1);
	}
}

int main() {
	std::cin >> n;
	max_w = n - 1;
	min_ans = max_w + 1;

	edges.clear();
	for (int i = 0; i < n; ++i) {
		for (int j = i + 1; j < n; ++j) {
			edges.emplace_back(i, j);
		}
	}

	w.resize(edges.size());
	graph.assign(n, std::vector<int>(n));
	p.resize(n);

	calc(0);

	if (min_ans > max_w) {
		std::cout << "No" << '\n';
	}
	else {
		std::cout << "Yes" << '\n';
		for (int i = 0; i < n; ++i) {
			for (int j = i + 1; j < n; ++j) {
				std::cout << best_graph[i][j] << ' ';
			}
			std::cout << '\n';
		}
	}

	return 0;
}