Problem:
Score : 1100 points

Problem Statement

We have a grid with N rows and M columns of squares.
Each integer from 1 to NM is written in this grid once.
The number written in the square at the i-th row from the top and the j-th column from the left is A_{ij}.

You need to rearrange these numbers as follows:

First, for each of the N rows, rearrange the numbers written in it as you like.

Second, for each of the M columns, rearrange the numbers written in it as you like.

Finally, for each of the N rows, rearrange the numbers written in it as you like.

After rearranging the numbers, you want the number written in the square at the i-th row from the top and the j-th column from the left to be M\times (i-1)+j.
Construct one such way to rearrange the numbers. The constraints guarantee that it is always possible to achieve the objective.

Constraints

1 \leq N,M \leq 100

1 \leq A_{ij} \leq NM

A_{ij} are distinct.

Input

Input is given from Standard Input in the following format:

N M
A_{11} A_{12} ... A_{1M}
:
A_{N1} A_{N2} ... A_{NM}

Output

Print one way to rearrange the numbers in the following format:

B_{11} B_{12} ... B_{1M}
:
B_{N1} B_{N2} ... B_{NM}
C_{11} C_{12} ... C_{1M}
:
C_{N1} C_{N2} ... C_{NM}

Here B_{ij} is the number written in the square at the i-th row from the top and the j-th column from the left after Step 1, and C_{ij} is the number written in that square after Step 2.

Sample Input 1

3 2
2 6
4 3
1 5

Sample Output 1

2 6
4 3
5 1
2 1
4 3
5 6

Sample Input 2

3 4
1 4 7 10
2 5 8 11
3 6 9 12

Sample Output 2

1 4 7 10
5 8 11 2
9 12 3 6
1 4 3 2
5 8 7 6
9 12 11 10

Solution in C++14 (GCC 5.4.1) (judge verdict: Accepted)

// Dmitry _kun_ Sayutin (2019)

#include <bits/stdc++.h>

using std::cin;
using std::cout;
using std::cerr;

using std::vector;
using std::map;
using std::array;
using std::set;
using std::string;

using std::pair;
using std::make_pair;

using std::tuple;
using std::make_tuple;
using std::get;

using std::min;
using std::abs;
using std::max;
using std::swap;

using std::unique;
using std::sort;
using std::generate;
using std::reverse;
using std::min_element;
using std::max_element;

#ifdef LOCAL
#define LASSERT(X) assert(X)
#else
#define LASSERT(X) {}
#endif

template <typename T>
T input() {
    T res;
    cin >> res;
    LASSERT(cin);
    return res;
}

template <typename IT>
void input_seq(IT b, IT e) {
    std::generate(b, e, input<typename std::remove_reference<decltype(*b)>::type>);
}

#define SZ(vec)         int((vec).size())
#define ALL(data)       data.begin(),data.end()
#define RALL(data)      data.rbegin(),data.rend()
#define TYPEMAX(type)   std::numeric_limits<type>::max()
#define TYPEMIN(type)   std::numeric_limits<type>::min()

bool dfs(int v, vector<vector<int>>& mat, vector<char>& used, vector<int>& rpair) {
    used[v] = 1;
    
    for (int u = 0; u != SZ(mat); ++u)
        if (mat[v][u] != -1 and rpair[u] == -1) {
            rpair[u] = v;
            return true;
        }

    for (int u = 0; u != SZ(mat); ++u)
        if (mat[v][u] != -1 and not used[rpair[u]] and dfs(rpair[u], mat, used, rpair)) {
            rpair[u] = v;
            return true;
        }

    return false;
}

int main() {
    std::iostream::sync_with_stdio(false);
    cin.tie(nullptr);
    cout.tie(nullptr);

    // code here
    int n, m;
    cin >> n >> m;

    vector<vector<int>> field(n, vector<int>(m));

    for (int i = 0; i != n; ++i)
        for (int j = 0; j != m; ++j)
            cin >> field[i][j];

    for (int iter = 0; iter != m; ++iter) {
        vector<vector<int>> mat(n, vector<int>(n, -1));
        
        for (int i = 0; i != n; ++i)
            for (int j = iter; j != m; ++j) {
                int tp = (field[i][j] - 1) / m;

                mat[i][tp] = j;
            }

        vector<int> rpair(n, -1);

        for (int i = 0; i != n; ++i) {
            vector<char> used(n);
            assert(dfs(i, mat, used, rpair));
        }

        for (int j = 0; j != n; ++j) {
            int i = rpair[j];

            swap(field[i][iter], field[i][mat[i][j]]);
        }
    }

    for (int i = 0; i != n; ++i)
        for (int j = 0; j != m; ++j)
            cout << field[i][j] << " \n"[j + 1 == m];

    for (int j = 0; j != m; ++j) {
        vector<int> arr;
        for (int i = 0; i != n; ++i)
            arr.push_back(field[i][j]);
        sort(ALL(arr));
        
        for (int i = 0; i != n; ++i)
            field[i][j] = arr[i];
    }

    for (int i = 0; i != n; ++i)
        for (int j = 0; j != m; ++j)
            cout << field[i][j] << " \n"[j + 1 == m];

    
    return 0;
}