#ifdef LOCAL
#include "pch.hpp"
#else
#include <bits/stdc++.h>
#endif

//#define ACL_included
#ifdef ACL_included
#include <atcoder/all>
using namespace atcoder;
#endif

# pragma GCC optimize("O3,unroll-loops")
# pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,tune=native")

using namespace std;
using ll = long long;
using ull = unsigned long long;
using gll = greater<ll>;
template <typename T>
using vec = vector<T>;
template <typename T>
using vvec = vector<vector<T>>;
template <typename T>
using uset = unordered_set<T>;
template <typename T, typename U>
using umap = unordered_map<T, U>;
template <typename T>
using pque = priority_queue<T>;
template <typename T>
using rpque = priority_queue<T,vec<T>,greater<T>>;
template <typename T>
using deq = deque<T>;
using vll = vec<ll>;
using vbool = vec<bool>;
using vstr = vec<string>;
using vchar = vec<char>;
using vvll = vvec<ll>;
using vvbool = vvec<bool>;
using vvstr = vvec<string>;
using vvchar = vvec<char>;
template <typename T, typename U>
using vpair = vec<pair<T, U>>;
using pll = pair<ll,ll>;
using usll = uset<ll>;
using umll = umap<ll,ll>;
using dqll = deq<ll>;
using pqll = pque<ll>;
using rpqll = rpque<ll>;
using qll = queue<ll>;
using vpll = vpair<ll,ll>;

#ifdef ACL_included
using namespace atcoder;
using mint = modint;
using vmint = vec<mint>;
using vvmint = vvec<mint>;
#endif

#define segt segtree
#define fwt fenwick_tree

#define rep(i,n) for(ll i=0;i<(ll)(n);i++)
#define rep1(i,n) for(ll i=1;i<=(ll)(n);i++)
#define repab(i,a,b) for(ll i=(ll)(a);i<=(ll)(b);i++)
#define rrep(i,a,b) for(ll i=(ll)(a);i>=(ll)(b);i--)
#define repv(e,v) for(auto& e: v)

#define all(x) x.begin(), x.end()
#define rall(x) x.rbegin(), x.rend()

#define Yes cout << "Yes" << endl
#define No cout << "No" << endl

#define YorN(x) if(x){Yes;}else{No;} 


const ll INF = 1ll<<62;

const vll DX = {1,0,-1,0,1,-1,-1,1};
const vll DY = {0,1,0,-1,1,1,-1,-1};

const char spc = ' ';



template<typename T> size_t HashCombine(const size_t seed,const T &v){
    return seed^(std::hash<T>()(v)+0x9e3779b9+(seed<<6)+(seed>>2));
}

template<typename T, typename S> struct std::hash<std::pair<T,S>>{
    size_t operator()(const std::pair<T,S> &keyval) const noexcept {
        return HashCombine(std::hash<T>()(keyval.first), keyval.second);
    }
};


template <typename T>
bool chmax(T& a, const T& b){
    if(a < b){ a = b; return true; }
    return false;
}

template <typename T>
bool chmin(T& a, const T& b){
    if(a > b){ a = b; return true; }
    return false;
}


template <typename T>
inline istream& operator>>(istream& is, vector<T>& v) {
    rep(i, v.size()) is >> v[i];
    return is;
}

template <typename T>
inline istream& operator>>(istream& is, vector<vector<T>>& v) {
    rep(i, v.size()) is >> v[i];
    return is;
}


template <typename T>
inline ostream& operator<<(ostream& os, vector<T>& v) {
    rep(i, v.size()) os << v[i] << (i+1==v.size() ? "" : " ");
    return os;
}

template <typename T>
inline ostream& operator<<(ostream& os, vector<vector<T>>& v) {
    rep(i, v.size()){
        os << v[i];
        if(i+1 != v.size()) os << endl;
    }
    return os;
}


#ifdef ACL_included
inline istream& operator>>(istream& is, modint& n) {
    int N; is >> N; n = N;
    return is;
}

inline ostream& operator<<(ostream& os, modint& n) {
    os << n.val();
    return os;
}
#endif

template <typename T>
T min(){ return INF; };
template <typename T, typename... Args>
T min(const T a, const Args... args){
    T b = min(args...);
    return a < b ? a : b;
}

template <typename T>
T min(const vector<T>& v){
    T ans = INF;
    for(const T& e : v) chmin(ans, e);
    return ans;
}

template <typename T>
T max(){ return -INF; };
template <typename T, typename... Args>
T max(const T a, const Args... args){
    T b = max(args...);
    return a > b ? a : b;
}

template <typename T>
T max(const vector<T>& v){
    T ans = -INF;
    for(const T& e : v) chmax(ans, e);
    return ans;
}

template <typename T>
T sum(){ return 0; };
template <typename T, typename... Args>
T sum(const T a, const Args... args){
    T b = sum(args...);
    return a + b;
}

template <typename T>
T sum(const vector<T>& v){
    T ans = 0;
    for(const T& e : v) ans += e;
    return ans;
}

template <typename T>
T product(){ return 1; };
template <typename T, typename... Args>
T product(const T a, const Args... args){
    T b = product(args...);
    return a * b;
}

template <typename T>
T product(const vector<T>& v){
    T ans = 1;
    for(const T& e : v) ans *= e;
    return ans;
}

template <typename T>
T Xor() { return 0; };
template <typename T, typename... Args>
T Xor(const T a, const Args... args){
    T b = Xor(args...);
    return a ^ b;
}

template <typename T>
T Xor(const vector<T>& v){
    T ans = 0;
    for(const T& e : v) ans ^= e;
    return ans;
}


struct Edge{
    long long from;
    long long to;
    long long w;
    Edge(long long from, long long to, long long w) : from(from), to(to), w(w) {}
    bool operator>(Edge* other) const {
        return this->w > other->w;
    }
    bool operator<(Edge* other) const {
        return other > this;
    }
};



class UnionFind {
private:
    vector<long long> par;
    vector<long long> siz;
    vector<long long> rnk;
public:
    UnionFind(long long n) {
        par.resize(n, -1);
        siz.resize(n, 1);
        rnk.resize(n, 0);
    }

    long long root(long long x) {
        if (par[x] == -1) {
            return x;
        } else {
            return par[x] = root(par[x]);
        }
    }

    bool issame(long long x, long long y) {
        return root(x) == root(y);
    }

    long long size(long long x) {
        return siz[root(x)];
    }

    void unite(long long x, long long y) {
        long long rx = root(x);
        long long ry = root(y);

        if (rx != ry) {
            if (rnk[rx] < rnk[ry]) {
                swap(rx, ry);
            }
            par[ry] = rx;
            siz[rx] += siz[ry];
            if (rnk[rx] == rnk[ry]) {
                rnk[rx]++;
            }
        }
    }
};


using Graph = vec<vec<Edge>>;


void G_in(vector<vector<long long>>& G, const long long m){
    for(int i=0;i<m;i++){
        long long u, v;
        cin >> u >> v;
        u--; v--;
        G[u].emplace_back(v);
        G[v].emplace_back(u);
    }
}

void G_in1(vector<vector<long long>>& G, const long long m){
    for(int i=0;i<m;i++){
        long long u, v;
        cin >> u >> v;
        u--; v--;
        G[u].emplace_back(v);
    }
}

void w_G_in(Graph& G, const long long m){
    for(int i=0;i<m;i++){
        long long u, v, w;
        cin >> u >> v >> w;
        u--; v--;
        G[u].emplace_back(Edge{u, v, w});
        G[v].emplace_back(Edge{v, u, w});
    }
}

void w_G_in1(Graph& G, const long long m){
    for(int i=0;i<m;i++){
        long long u, v, w;
        cin >> u >> v >> w;
        u--; v--;
        G[u].emplace_back(Edge{u, v, w});
    }
}



void dfs(const long long u, const vector<vector<long long>>& G, vector<bool>& visited){
    visited[u] = true;
    for (long long v : G[u]) {
        if (!visited[v]) {
            dfs(v, G, visited);
        }
    }
    visited[u] = false;
    return;
}

void bfs(const vector<vector<long long>>& G, const long long start){
    vector<bool> visited(G.size(), false);
    queue<long long> Q;
    Q.push(start);
    visited[start] = true;
    while(!Q.empty()){
        long long u = Q.front();
        Q.pop();
        for (long long v : G[u]) {
            if (!visited[v]) {
                visited[v] = true;
                Q.push(v);
            }
        }
    }
}

vector<long long> bellman_ford(const Graph& G, const long long n, const long long start, bool& negative_cycle){
    negative_cycle = false;
    vector<long long> D(n, INF);
    D[start] = 0;
    for(int i=0;i<n;i++){
        bool update = false;
        for(int v=0;v<n;v++){
            if(D[v] == INF) continue;
            for (const Edge& e : G[v]) {
                if(D[e.to] > D[v] + e.w){
                    update = true;
                    D[e.to] = D[v] + e.w;
                }
            }
        }
        if(!update) return D;
        if(i == n-1 && update) negative_cycle = true;
    }
    return D;
}

vector<long long> dijkstra_dense(const Graph& G, const long long n, const long long start){
    vector<bool> used(n, false);
    vector<long long> D(n, INF);
    D[start] = 0;
    for(int _=0;_<n;_++){
        long long min_d = INF;
        long long min_v = -1;
        for(int v=0;v<n;v++){
            if(!used[v] && D[v] < min_d){
                min_d = D[v];
                min_v = v;
            }
        }
        if(min_v == -1) return D;
        for (const Edge& e : G[min_v]) {
            D[e.to] = min(D[e.to], D[min_v] + e.w);
        }
        used[min_v] = true;
    }
    return D;
}

vector<long long> dijkstra(const Graph& G, const long long n, const long long start){
    vector<long long> D(n, INF);
    D[start] = 0;
    priority_queue<pair<long long,long long>, vector<pair<long long,long long>>, greater<pair<long long,long long>>> Q;
    Q.push({D[start], start});
    while(!Q.empty()){
        long long v = Q.top().second;
        long long d = Q.top().first;
        Q.pop();
        if(d > D[v]) continue;
        for (const Edge& e : G[v]) {
            if(D[e.to] > D[v] + e.w){
                D[e.to] = D[v] + e.w;
                Q.push({D[e.to], e.to});
            }
        }
    }
    return D;
}

vector<vector<long long>> Warshall_Floyd(const Graph& G, const long long n, bool& negative_cycle){
    vector<vector<long long>> Dp(n, vector<long long>(n, INF));
    for(int v=0;v<n;v++){
        Dp[v][v] = 0;
        for (const Edge& e : G[v]) {
            Dp[v][e.to] = e.w;
        }
    }
    for(int k=0;k<n;k++){
        for(int i=0;i<n;i++){
            for(int j=0;j<n;j++){
                Dp[i][j] = min(Dp[i][j], Dp[i][k] + Dp[k][j]);
            }
        }
    }
    negative_cycle = false;
    for(int v=0;v<n;v++){
        if(Dp[v][v] < 0){
            negative_cycle = true;
            break;
        }
    }
    return Dp;
}

vector<vector<Edge>> Kruskal(const vector<vector<Edge>>& G){
    priority_queue<pair<long long,pll>, vector<pair<long long,pll>>, greater<pair<long long,pll>>> Q;
    const long long n = G.size();
    for(int i=0;i<n;i++){
        for(int j=0;j<G[i].size();j++){
            Q.push({G[i][j].w,{i,j}});
        }
    }
    UnionFind uf(n);
    vector<vector<Edge>> F(n);
    while(!Q.empty()){
        long long w; pll idx;
        tie(w,idx) = Q.top();
        Q.pop();
        long long i,j; tie(i,j) = idx;
        const Edge e = G[i][j];
        const long long u = e.from, v = e.to;
        if(!uf.issame(u, v)){
            F[u].emplace_back(e);
            uf.unite(u, v);
        }
    }
    return F;
}


bool is_prime(long long n){
    if(n % 2 == 0) return false;
    if(n % 3 == 0) return false;
    for(long long i = 1; (6*i-1)*(6*i-1) <= n; i++){
        long long k = 6*i-1;
        if(n % k == 0){
            return false;
        }
        k = 6*i+1;
        if(n % k == 0){
            return false;
        }
    }
    return true;
}

vector<pair<long long, long long>> factor(long long n){
    vector<pair<long long, long long>> F;
    if(n % 2 == 0){
        long long cnt = 0;
        while(!(n&1)){
            cnt++;
            n>>=1;
        }
        if(cnt > 0) F.emplace_back(pll{2, cnt});
    }
    if(n % 3 == 0){
        long long cnt = 0;
        while(n % 3 == 0){
            cnt++;
            n /= 3;
        }
        if(cnt > 0) F.emplace_back(pll{3, cnt});
    }
    for(long long i = 1; (6*i-1)*(6*i-1) <= n; i++){
        long long k = 6*i-1;
        if(n % k == 0){
            long long cnt = 0;
            while(n % k == 0){
                cnt++;
                n /= k;
            }
            F.emplace_back(pll{k, cnt});
        }
        k = 6*i+1;
        if(n % k == 0){
            long long cnt = 0;
            while(n % k == 0){
                cnt++;
                n /= k;
            }
            F.emplace_back(pll{k, cnt});
        }
    }
    if(n != 1) F.emplace_back(pll{n, 1});
    return F;
}

vector<long long> divisor(long long n){
    vector<long long> D;
    for(long long i = 1; i*i <= n; i++){
        if(n % i == 0){
            D.emplace_back(i);
            if(i != n/i) D.emplace_back(n/i);
        }
    }
    return D;
}

template <typename T>
T power(const T a, const long long b){
    T ans = 1;
    T p = a;
    for(int i=0;i<63;i++){
        if((b>>i)&1) ans *= p;
        p *= p;
    }
    return ans;
}


template <typename T>
vector<vector<T>> operator*(vector<vector<T>>& V, vector<vector<T>>& W){
    vector<vector<T>> R(V.size(), vector<T>(W[0].size()));
    for(int i=0;i<V.size();i++){
        for(int k=0;k<W.size();k++){
            for(int j=0;j<W[0].size();j++){
                R[i][j] += V[i][k] * W[k][j];
            }
        }
    }
    return R;
}

template <typename T>
vector<vector<T>> powmat(const vector<vector<T>>& A, const long long b){
    const long long n = A.size();
    vector<vector<T>> ans(n, vector<T>(n, 0));
    for(int i=0;i<n;i++) ans[i][i] = 1;
    vector<vector<T>> p = A;
    for(int i=0;i<63;i++){
        if((b>>i)&1) ans = ans * p;
        p = p * p;
    }
    return ans;
}


#ifdef ACL_included
const long long facMax = 0;//1e6;
vector<modint> Fac(facMax);
void nCrInit(void){
    Fac[0] = Fac[1] = 1;
    for(int i=2;i<facMax;i++){
        Fac[i] = Fac[i-1] * i;
    }
}
mint nCr(long long n, long long r){
    if(n < r) return 0;
    else return Fac[n] / Fac[r] / Fac[n-r];
}

modint powmod(const modint a, const long long b) { return power(a, b); }
vector<vector<modint>> powmatmod(const vector<vector<modint>>& A, const long long b) { return powmat(A, b); }
#endif


ll sqrtll(ll n){
    ll ng = 0, ok = n;
    while(abs(ok-ng) > 1){
        ll mid = (ok+ng)/2;
        if(mid*mid >= n) ok = mid;
        else ng = mid;
    }
    return ok;
}

int main(void){
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    cout << fixed << setprecision(15);
    #ifdef ACL_included
    modint::set_mod(998244353);
    #endif
    
    ll n,m,k; cin >> n >> m >> k;
    ll sm = sqrtll(m);
    vvll G(n,vll(n,0));
    vll Cnt(m,0);
    rep(i,n){
        rep(j,n){
            ll val = (i%sm)*sm+j%sm;
            if(val < m){
                G[i][j] = val+1;
                Cnt[val]++;
            }
        }
    }
    //cout << G << endl << endl;
    ll idx = 0;
    rep(i,n){
        rep(j,n){
            if(G[i][j]) cout << G[i][j] << spc;
            else{
                while(Cnt[idx] >= n*n/m) idx++;
                cout << idx+1 << spc;
                Cnt[idx]++;
            }
        }
        cout << endl;
    }
    //cout << Cnt << endl;
    
    return 0;
}