output_description: 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.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      N M
      A_{11} A_{12} ... A_{1M}
      :
      A_{N1} A_{N2} ... A_{NM}
attempt: from collections import defaultdict
  
  
  def solve(n, m, aaa):
      def find(si, used, matched):
          for ti in targets[si]:
              if ti in used:
                  continue
              used.add(ti)
              if matched[ti] == -1 or find(matched[ti], used, matched):
                  matched[ti] = si
                  return True
          return False
  
      targets = [set() for _ in range(n)]
      numbers = defaultdict(set)
      for si, row in enumerate(aaa):
          for a in row:
              ti = (a - 1) // m
              targets[si].add(ti)
              numbers[si, ti].add(a)
  
      bbb = [[0] * m for _ in range(n)]
      ccc = [[0] * m for _ in range(n)]
  
      for j in range(m):
          matched = [-1] * n
          assert all(find(si, set(), matched) for si in range(n))
          for si, ti in enumerate(matched):
              a = numbers[si, ti].pop()
              bbb[si][j] = a
              ccc[ti][j] = a
              if len(numbers[si, ti]) == 0:
                  targets[si].remove(ti)
                  del numbers[si, ti]
  
      print("\n".join(" ".join(map(str, row)) for row in bbb))
      print("\n".join(" ".join(map(str, row)) for row in ccc))
  
  
  n, m = map(int, input().split())
  aaa = [list(map(int, input().split())) for _ in range(n)]
  solve(n, m, aaa)
  
problem_description: 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:
  
    1. First, for each of the N rows, rearrange the numbers written in it as you like.
    2. Second, for each of the M columns, rearrange the numbers written in it as you like.
    3. 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.
samples: [{"input": "3 2\n    2 6\n    4 3\n    1 5", "output": "2 6 \n    4 3 \n    5 1 \n    2 1 \n    4 3 \n    5 6 \n    \n\n* * *"}, {"input": "3 4\n    1 4 7 10\n    2 5 8 11\n    3 6 9 12", "output": "1 4 7 10 \n    5 8 11 2 \n    9 12 3 6 \n    1 4 3 2 \n    5 8 7 6 \n    9 12 11 10"}]