output_description: Print one way to paint the squares that satisfies the conditions. Output in
  the following format:
  
      
      
      c_{1 1} ... c_{1 W}
      :
      c_{H 1} ... c_{H W}
      
  
  Here, c_{i j} is the color of the square at the i-th row from the top and j-th
  column from the left.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      H W
      N
      a_1 a_2 ... a_N
attempt: import sys
  from sys import exit
  from collections import deque
  from bisect import bisect_left, bisect_right, insort_left, insort_right
  from heapq import heapify, heappop, heappush
  from itertools import product, permutations, combinations, combinations_with_replacement
  from functools import reduce
  from math import gcd, sin, cos, tan, asin, acos, atan, degrees, radians
  
  sys.setrecursionlimit(10**6)
  INF = 10**20
  eps = 1.0e-20
  MOD = 10**9 + 7
  
  
  def lcm(x, y):
      return x * y // gcd(x, y)
  
  
  def lgcd(l):
      return reduce(gcd, l)
  
  
  def llcm(l):
      return reduce(lcm, l)
  
  
  def powmod(n, i, mod):
      return pow(n, mod - 1 + i, mod) if i < 0 else pow(n, i, mod)
  
  
  def div2(x):
      return x.bit_length()
  
  
  def div10(x):
      return len(str(x)) - (x == 0)
  
  
  def perm(n, mod=None):
      ans = 1
      for i in range(1, n + 1):
          ans *= i
          if mod != None:
              ans %= mod
      return ans
  
  
  def intput():
      return int(input())
  
  
  def mint():
      return map(int, input().split())
  
  
  def lint():
      return list(map(int, input().split()))
  
  
  def ilint():
      return int(input()), list(map(int, input().split()))
  
  
  def judge(x, l=["Yes", "No"]):
      print(l[0] if x else l[1])
  
  
  def lprint(l, sep="\n"):
      for x in l:
          print(x, end=sep)
  
  
  def ston(c, c0="a"):
      return ord(c) - ord(c0)
  
  
  def ntos(x, c0="a"):
      return chr(x + ord(c0))
  
  
  class counter(dict):
      def __init__(self, *args):
          super().__init__(args)
  
      def add(self, x, d=1):
          self.setdefault(x, 0)
          self[x] += d
  
      def list(self):
          l = []
          for k in self:
              l.extend([k] * self[k])
          return l
  
  
  class comb:
      def __init__(self, n, mod=None):
          self.l = [1]
          self.n = n
          self.mod = mod
  
      def get(self, k):
          l, n, mod = self.l, self.n, self.mod
          k = n - k if k > n // 2 else k
          while len(l) <= k:
              i = len(l)
              l.append(
                  l[i - 1] * (n + 1 - i) // i
                  if mod == None
                  else (l[i - 1] * (n + 1 - i) * powmod(i, -1, mod)) % mod
              )
          return l[k]
  
  
  def pf(x):
      C = counter()
      p = 2
      while x > 1:
          k = 0
          while x % p == 0:
              x //= p
              k += 1
          if k > 0:
              C.add(p, k)
          p = p + 2 - (p == 2) if p * p < x else x
      return C
  
  
  H, W = mint()
  N = intput()
  A = [0] + lint()
  C = [[0] * W for _ in range(H)]
  k = 1
  a = 0
  for i in range(H):
      tmp = range(W) if i % 2 == 0 else range(W - 1, -1, -1)
      for j in tmp:
          C[i][j] = k
          a += 1
          if a == A[k]:
              k += 1
              a = 0
  for c in C:
      lprint(c, " ")
      print("")
  
problem_description: Statement
  
  We have a grid with H rows and W columns of squares. Snuke is painting these
  squares in colors 1, 2, ..., N. Here, the following conditions should be
  satisfied:
  
    * For each i (1 ≤ i ≤ N), there are exactly a_i squares painted in Color i. Here, a_1 + a_2 + ... + a_N = H W.
    * For each i (1 ≤ i ≤ N), the squares painted in Color i are _4-connected_. That is, every square painted in Color i can be reached from every square painted in Color i by repeatedly traveling to a horizontally or vertically adjacent square painted in Color i.
  
  Find a way to paint the squares so that the conditions are satisfied. It can
  be shown that a solution always exists.
samples: [{"input": "2 2\n    3\n    2 1 1", "output": "1 1\n    2 3\n    \n\nBelow is an example of an invalid solution:\n\n    \n    \n    1 2\n    3 1\n    \n\nThis is because the squares painted in Color 1 are not 4-connected.\n\n* * *"}, {"input": "3 5\n    5\n    1 2 3 4 5", "output": "1 4 4 4 3\n    2 5 4 5 3\n    2 5 5 5 3\n    \n\n* * *"}, {"input": "1 1\n    1\n    1", "output": "1"}]