// cf bits/extc++.h nonsense
#ifdef ONLINE_JUDGE
#define _EXT_CODECVT_SPECIALIZATIONS_H 1
#define _EXT_ENC_FILEBUF_H 1
#endif
#include "bits/extc++.h"

using namespace std;

template <typename T, typename... U>
void dbgh(const T& t, const U&... u) {
    cerr << t;
    ((cerr << " | " << u), ...);
    cerr << endl;
}

#ifdef DEBUG
#define dbg(...)                                              \
    cerr << "L" << __LINE__ << " [" << #__VA_ARGS__ << "]: "; \
    dbgh(__VA_ARGS__)
#else
#define dbg(...)
#define cerr   \
    if (false) \
    cerr
#endif

using ll = long long;

#define endl "\n"
#define long int64_t
#define sz(x) int(std::size(x))

inline void init_io() {
    cin.tie(nullptr);
    cin.exceptions(ios::failbit);
    ios_base::sync_with_stdio(false);
}

template <typename T>
vector<T> iota(int n, const T& x) {
    vector<T> arr(n);
    iota(begin(arr), end(arr), x);
    return arr;
}

template <typename T>
ostream& operator<<(ostream& out, const vector<T>& arr) {
    out << "[";
    for (int i = 0; i < sz(arr); i++) {
        if (i) {
            out << ", ";
        }
        out << arr[i];
    }
    return out << "]";
}

template <typename T>
int c_lb(const vector<T>& arr, const T& x) {
    return int(lower_bound(begin(arr), end(arr), x) - begin(arr));
}

template <typename T>
int c_ub(const vector<T>& arr, const T& x) {
    return int(upper_bound(begin(arr), end(arr), x) - begin(arr));
}

template <typename T>
T reversed(T arr) {
    reverse(begin(arr), end(arr));
    return arr;
}

template <typename T>
T sorted(T arr) {
    sort(begin(arr), end(arr));
    return arr;
}

template <typename T>
bool on(T mask, int bit) {
    return (mask >> bit) & 1;
}

template <typename A, typename B>
ostream& operator<<(ostream& out, const pair<A, B>& p) {
    return out << "(" << p.first << ", " << p.second << ")";
}

vector<vector<pair<int, int>>> graph;

struct Solver {
    int m;
    vector<bool> ans, edge_vis;

    Solver(const vector<pair<int, int>>& edges)
        : m(sz(edges)), ans(m), edge_vis(m) {
        for (auto& [u, v] : edges) {
            graph[u].clear();
            graph[v].clear();
        }

        for (int i = 0; i < m; i++) {
            auto& [u, v] = edges[i];
            graph[u].emplace_back(v, i);
            graph[v].emplace_back(u, ~i);
        }

        map<int, int> mp;
        for (auto& [u, v] : edges) {
            mp[u]++;
            mp[v]++;
        }
        vector<int> odd_v;
        for (auto& [k, v] : mp) {
            if (v % 2 == 0) {
                continue;
            }
            odd_v.push_back(k);
        }

        auto new_edge = [&]() -> int {
            ans.push_back(false);
            edge_vis.push_back(false);
            return sz(ans) - 1;
        };
        for (int i = 0; i < sz(odd_v); i += 2) {
            int u = odd_v[i], v = odd_v[i + 1], ei = new_edge();

            graph[u].emplace_back(v, ei);
            graph[v].emplace_back(u, ei);
        }

        for (auto& [u, v] : edges) {
            for (auto& ch : {u, v}) {
                if (sz(graph[ch]) % 2 == 1) {
                    dfs(ch);
                }
            }
        }
        for (auto& [u, v] : edges) {
            for (auto& ch : {u, v}) {
                dfs(ch);
            }
        }

        ans.resize(m);
    }

    void dfs(int u) {
        while (sz(graph[u])) {
            auto [v, sei] = graph[u].back();
            graph[u].pop_back();

            int ei = sei < 0 ? ~sei : sei;

            if (edge_vis[ei]) {
                continue;
            }
            edge_vis[ei] = true;

            ans[ei] = sei < 0;
            dfs(v);
        }
    }
};

void solve(vector<vector<int>>& arr, int yl, int yr) {
    if (yr - yl == 1) {
        return;
    }

    int ym = (yl + yr) / 2;

    vector<pair<int*, int*>> edge_ptrs;
    vector<pair<int, int>> edges;

    for (auto& a : arr) {
        for (int i = 0; i < ym - yl; i++) {
            int *ca = &a[yl + i], *cb = &a[ym + i];

            edge_ptrs.emplace_back(ca, cb);
            edges.emplace_back(*ca, *cb);
        }
    }

    auto e_ans = Solver(edges).ans;

    for (int i = 0; i < sz(e_ans); i++) {
        if (e_ans[i]) {
            auto& [u, v] = edge_ptrs[i];
            swap(*u, *v);
        }
    }

    solve(arr, yl, ym);
    solve(arr, ym, yr);
}

void grade(const vector<vector<int>>& arr, int nt) {
    int n = sz(arr), m = sz(arr[0]);

    vector<vector<int>> inds(nt);

    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            inds[arr[i][j]].push_back(j);
        }
    }

    for (auto& a : inds) {
        int cnt[m] {};

        for (auto& b : a) {
            cnt[b]++;
        }

        assert(*max_element(cnt, cnt + m) - *min_element(cnt, cnt + m) <= 1);
    }
}

void solve() {
    int n, m, nt;
    cin >> n >> m >> nt;

    graph.resize(nt);

    vector arr(n, vector(m, 0));
    for (auto& a : arr) {
        for (auto& b : a) {
            cin >> b;
            b--;
        }
    }

    solve(arr, 0, m);

    for (auto& a : arr) {
        for (int i = 0; i < m; i++) {
            cout << a[i] + 1 << " \n"[i == m - 1];
        }
    }

    cout.flush();

    grade(arr, nt);
}

int main() {
    init_io();
    solve();
}