/*
    author:  Maksim1744
    created: 11.11.2023 14:02:30
*/

#include "bits/stdc++.h"

using namespace std;

using ll = long long;
using ld = long double;

#define mp   make_pair
#define pb   push_back
#define eb   emplace_back

#define sum(a)     ( accumulate ((a).begin(), (a).end(), 0ll))
#define mine(a)    (*min_element((a).begin(), (a).end()))
#define maxe(a)    (*max_element((a).begin(), (a).end()))
#define mini(a)    ( min_element((a).begin(), (a).end()) - (a).begin())
#define maxi(a)    ( max_element((a).begin(), (a).end()) - (a).begin())
#define lowb(a, x) ( lower_bound((a).begin(), (a).end(), (x)) - (a).begin())
#define uppb(a, x) ( upper_bound((a).begin(), (a).end(), (x)) - (a).begin())

template<typename T>             vector<T>& operator--            (vector<T> &v){for (auto& i : v) --i;            return  v;}
template<typename T>             vector<T>& operator++            (vector<T> &v){for (auto& i : v) ++i;            return  v;}
template<typename T>             istream& operator>>(istream& is,  vector<T> &v){for (auto& i : v) is >> i;        return is;}
template<typename T>             ostream& operator<<(ostream& os,  vector<T>  v){for (auto& i : v) os << i << ' '; return os;}
template<typename T, typename U> pair<T,U>& operator--           (pair<T, U> &p){--p.first; --p.second;            return  p;}
template<typename T, typename U> pair<T,U>& operator++           (pair<T, U> &p){++p.first; ++p.second;            return  p;}
template<typename T, typename U> istream& operator>>(istream& is, pair<T, U> &p){is >> p.first >> p.second;        return is;}
template<typename T, typename U> ostream& operator<<(ostream& os, pair<T, U>  p){os << p.first << ' ' << p.second; return os;}
template<typename T, typename U> pair<T,U> operator-(pair<T,U> a, pair<T,U> b){return mp(a.first-b.first, a.second-b.second);}
template<typename T, typename U> pair<T,U> operator+(pair<T,U> a, pair<T,U> b){return mp(a.first+b.first, a.second+b.second);}
template<typename T, typename U> void umin(T& a, U b){if (a > b) a = b;}
template<typename T, typename U> void umax(T& a, U b){if (a < b) a = b;}

#ifdef HOME
#define SHOW_COLORS
#include "/mnt/c/Libs/tools/print.cpp"
#else
#define show(...) void(0)
#define debugf(fun)   fun
#define debugv(var)   var
#define mclock    void(0)
#define shows     void(0)
#define debug  if (false)
#define OSTREAM(...)    ;
#define OSTREAM0(...)   ;
#endif

template<class Fun>
class y_combinator_result {
    Fun fun_;
public:
    template<class T>
    explicit y_combinator_result(T &&fun): fun_(std::forward<T>(fun)) {}

    template<class ...Args>
    decltype(auto) operator()(Args &&...args) {
        return fun_(std::ref(*this), std::forward<Args>(args)...);
    }
};
template<class Fun>
decltype(auto) y_combinator(Fun &&fun) {
    return y_combinator_result<std::decay_t<Fun>>(std::forward<Fun>(fun));
}
// auto gcd = std::y_combinator([](auto gcd, int a, int b) -> int {
//     return b == 0 ? a : gcd(b, a % b);
// });

mt19937_64 rng;
ll rnd (ll l, ll r) { return (ll)(rng() % (r - l + 1)) + l; }
ll rnd (ll r)       { return rng() % r; }
ll rnd ()           { return rng(); }
ld rndf()           { return (ld)rng() / (ld)ULLONG_MAX; }
ld rndf(ld l, ld r) { return rndf() * (r - l) + l; }

namespace grid_iterator_ns {
const array<pair<int, int>, 8> dirs = {{{0, 1}, {1, 0}, {0, -1}, {-1, 0}, {1, 1}, {-1, -1}, {1, -1}, {-1, 1}}};
struct GridIterator {
    int n, m;
    GridIterator(int n, int m) : n(n), m(m) {}

    template<size_t N>
    struct NeighbourIteratorContainer {
        int i, j, n, m;
        NeighbourIteratorContainer(int i, int j, int n, int m) : i(i), j(j), n(n), m(m) {}

        struct NeighbourIterator {
            int cur;
            int i, j, n, m;
            NeighbourIterator(int cur, int i, int j, int n, int m) : cur(cur), i(i), j(j), n(n), m(m) {
                skip_to_first_allowed();
            }

            void skip_to_first_allowed() {
                while (cur < N &&
                    (i + dirs[cur].first  < 0 || i + dirs[cur].first  >= n ||
                     j + dirs[cur].second < 0 || j + dirs[cur].second >= m)) {
                    ++cur;
                }
            }

            NeighbourIterator& operator ++ () {
                ++cur;
                skip_to_first_allowed();
                return *this;
            }

            pair<int, int> operator * () const { return {i + dirs[cur].first, j + dirs[cur].second}; }

            bool operator == (const NeighbourIterator& other) const { return cur == other.cur; }
        };

        auto begin() const { return NeighbourIterator(0, i, j, n, m); }
        auto end()   const { return NeighbourIterator(N, i, j, n, m); }

        auto collect() const {
            vector<pair<int, int>> result;
            for (auto it = begin(); it != end(); ++it) result.push_back(*it);
            return result;
        }
    };

    template<size_t N>
    auto iterate(int i, int j) const {
        static_assert(N == 4 || N == 8, "you can remove this, but make sure you understand what you are doing");
        return NeighbourIteratorContainer<N>(i, j, n, m);
    }
};
}
using grid_iterator_ns::GridIterator;

int main() {
    ios_base::sync_with_stdio(false); cin.tie(NULL);

    uint64_t seed = chrono::steady_clock::now().time_since_epoch().count();
    seed = 13905694550644;
    // cerr << "seed: " << seed << endl;
    // 13905694550644
    rng.seed(seed);

    int n = 2000;
    cin >> n;
    if (n <= 2) {
        cout << "Yes\n";
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < n; ++j) {
                cout << 0 << " \n"[j + 1 == n];
            }
        }
        return 0;
    }
    auto trans = [&](const vector<vector<int>>& v) {
        vector<vector<int>> res(v[0].size(), vector<int>(v.size()));
        for (int i = 0; i < v.size(); ++i) {
            for (int j = 0; j < v[i].size(); ++j) {
                res[j][i] = v[i][j];
            }
        }
        return res;
    };
    int best = 0;
    vector<vector<pair<int, int>>> seq;
    vector<vector<int>> st;
    auto gen = y_combinator([&](auto gen, vector<vector<int>> cur, int bit) -> bool {
        if (cur.size() > cur[0].size()) {
            cur = trans(cur);
        }
        for (int i = 0; i < cur.size(); ++i) {
            for (int j = 0; j < cur[i].size(); ++j) {
                if (i && (cur[i][j] & cur[i - 1][j])) return false;
                if (j && (cur[i][j] & cur[i][j - 1])) return false;
            }
        }
        int mx = 0;
        for (auto& a : cur)
            for (auto b : a)
                mx = max(mx, b);
        if (cur.size() == cur[0].size() && mx >= (cur.size() / 2 + 2) * (cur.size() / 2 + 2) * 4) return false;
        vector<int> cnt(mx + 1, 0);
        for (auto& a : cur)
            for (auto b : a)
                cnt[b]++;
        if (maxe(cnt) > 5) return false;
        if (cur.size() == cur[0].size()) {
            if (cur.size() > best) {
                best = cur.size();
                // cout << "found new best: " << best << endl;
                // cout << "st: " << st << endl;
                // cout << "seq: " << seq << endl;
                // cerr << "found new best: " << best << " with max " << mx << endl;
                show(cur);
                if (best >= n) {
                    cout << "Yes\n";
                    for (int i = 0; i < n; ++i) {
                        for (int j = 0; j < n; ++j) {
                            if (cur[i][j] >= n * n * 4) {
                                cerr << endl;
                                cerr << cur[i][j] << ' ' << n * n * 4 << endl;
                                assert(false);
                            }
                            cout << cur[i][j] << " \n"[j + 1 == n];
                        }
                    }
                    exit(0);
                    return true;
                }
            }
        }
        int sz = cur.size();
        for (int i = sz - 2; i >= 0; --i)
            cur.pb(cur[i]);
        vector<pair<int, int>> other;
        for (int i = 0; i < cur[0].size(); ++i) {
            other.eb(sz, i);
            other.eb(sz - 1, i);
            other.eb(sz - 2, i);
        }
        for (int i = 0; i < 3; ++i) {
            auto nx = cur;
            int b = rnd(2);
            shuffle(other.begin(), other.end(), rng);
            for (int i = 0; i + 2 < sz; ++i) {
                for (int j = 0; j < nx[i].size(); ++j) {
                    if ((i + j) % 2 == b) nx[i][j] |= bit;
                }
            }
            for (int i = sz + 1; i < nx.size(); ++i) {
                for (int j = 0; j < nx[i].size(); ++j) {
                    if ((i + j) % 2 != b) nx[i][j] |= bit;
                }
            }
            bool ok = true;
            GridIterator gi(nx.size(), nx[0].size());
            for (auto [u, v] : other) {
                int ne = 0;
                for (auto [x, y] : gi.iterate<4>(u, v)) {
                    ne |= nx[x][y];
                }
                if (nx[u][v] & ne) {
                    ok = false;
                    break;
                }
                if ((nx[u][v] | bit) & ne) continue;
                nx[u][v] |= bit;
            }
            if (!ok) continue;
            seq.pb(other);
            seq.back().eb(-1, b);
            bool res = gen(std::move(nx), bit * 2);
            seq.pop_back();
            if (res) return true;
        }
        return false;

        // vector<int> rots(cur.size());
        // iota(rots.begin(), rots.end(), 0);
        // shuffle(rots.begin(), rots.end(), rng);
        // int totsz = cur.size() * cur[0].size();
        // assert((totsz & (totsz - 1)) == 0);
        // for (int r : rots) {
        //     for (int b = 0; b <= 2; ++b) {
        //         auto nx = cur;
        //         rotate(nx.begin(), nx.begin() + r, nx.end());
        //         int sz = nx.size();
        //         for (int i = 0; i < sz; ++i) {
        //             nx.pb(nx[i]);
        //         }
        //         if (b >= 2) {
        //             for (int i = 0; i < nx.size(); ++i) {
        //                 for (int j = 0; j < nx[i].size(); ++j) {
        //                     if ((i + j) % 2 != b % 2) {
        //                         nx[i][j] += totsz;
        //                     }
        //                 }
        //             }
        //         } else {
        //             for (int i = 1; i + 1 < sz; ++i) {
        //                 for (int j = 0; j < nx[i].size(); ++j) {
        //                     if ((i + j) % 2 == b % 2) {
        //                         nx[i][j] += totsz;
        //                     }
        //                 }
        //             }
        //             for (int i = sz; i < nx.size(); ++i) {
        //                 for (int j = 0; j < nx[i].size(); ++j) {
        //                     if ((i + j) % 2 != b % 2) {
        //                         nx[i][j] += totsz;
        //                     }
        //                 }
        //             }
        //         }
        //         vector<int> cnt(totsz * 2);
        //         for (auto& a : nx)
        //             for (int b : a)
        //                 cnt[b]++;
        //         // show(nx);
        //         if (maxe(cnt) > 5) {
        //             continue;
        //         }
        //         seq.pb(r * 100000 + b);
        //         bool res = gen(std::move(nx));
        //         seq.pop_back();
        //         if (res) return true;
        //     }
        // }
        // return false;
    });

    int it = 0;
    while (true) {
        ++it;
        if (it % 10000000 == 0)
            cerr << "it: " << it << endl;
        int sz = rnd(2) ? 3 : 5;
        vector<vector<int>> v(sz, vector<int>(sz));
        int lim = sz * sz;
        while ((lim & (lim - 1))) --lim;
        int x = __lg(lim);
        lim = (1 << rnd(0, x + 1));
        for (int i = 0; i < sz; ++i) {
            for (int j = 0; j < sz; ++j) {
                v[i][j] = rnd(lim);
            }
        }
        st = v;
        if (gen(st, lim)) break;
    }

    // for (int i = 0; i < (1 << 8); ++i) {
    //     vector<vector<int>> s(2, vector<int>(2));
    //     for (int k = 0; k < 2; ++k) {
    //         for (int j = 0; j < 2; ++j) {
    //             s[k][j] = ((i >> ((k * 2 + j) * 2)) & 3);
    //         }
    //     }
    //     if (s[0][0] & s[0][1]) continue;
    //     if (s[1][0] & s[1][1]) continue;
    //     if (s[0][0] & s[1][0]) continue;
    //     if (s[0][1] & s[1][1]) continue;
    //     show(s);
    //     gen(s);
    // }

    return 0;
}