output_description: Print 10 lines. The (j+1)-th ( 0 \leq j \leq 9 ) line should contain the
  number of the subrectangles of size 3×3 of the grid that contains exactly j
  black cells.
  
  * * *
input_description: The input is given from Standard Input in the following format:
  
      
      
      H W N
      a_1 b_1
      :
      a_N b_N
attempt: H, W, N = map(int, input().split())
  li = []
  for i in range(N):
      li.append(tuple(map(int, input().split())))
  t = tuple(li)
  st = set(t)
  # print(t)
  
  Js = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
  
  for a, b in t:
      if a > H - 2 or b > W - 2:
          pass
      else:
          t_p1 = (
              (a, b),
              (a, b + 1),
              (a, b + 2),
              (a + 1, b),
              (a + 1, b + 1),
              (a + 1, b + 2),
              (a + 2, b),
              (a + 2, b + 1),
              (a + 2, b + 2),
          )
          s1 = st & set(t_p1)
          ls1 = len(s1)
          Js[ls1] += 1
  
      if a > H - 2 or b > W - 1 or b < 2:
          pass
      else:
          t_p2 = (
              (a, b - 1),
              (a, b),
              (a, b + 1),
              (a + 1, b - 1),
              (a + 1, b),
              (a + 1, b + 1),
              (a + 2, b - 1),
              (a + 2, b),
              (a + 2, b + 1),
          )
          s2 = st & set(t_p2)
          ls2 = len(s2)
          Js[ls2] += 1
  
      if a > H - 2 or b < 3:
          pass
      else:
          t_p3 = (
              (a, b - 2),
              (a, b - 1),
              (a, b),
              (a + 1, b - 2),
              (a + 1, b - 1),
              (a + 1, b),
              (a + 2, b - 2),
              (a + 2, b - 1),
              (a + 2, b),
          )
          s3 = st & set(t_p3)
          ls3 = len(s3)
          Js[ls3] += 1
  
      if a > H - 1 or a < 2 or b > W - 2:
          pass
      else:
          t_p4 = (
              (a - 1, b),
              (a - 1, b + 1),
              (a - 1, b + 2),
              (a, b),
              (a, b + 1),
              (a, b + 2),
              (a + 1, b),
              (a + 1, b + 1),
              (a + 1, b + 2),
          )
          s4 = st & set(t_p4)
          ls4 = len(s4)
          Js[ls4] += 1
  
      if a > H - 1 or a < 2 or b > W - 1 or b < 2:
          pass
      else:
          t_p5 = (
              (a - 1, b - 1),
              (a - 1, b),
              (a - 1, b + 1),
              (a, b - 1),
              (a, b),
              (a, b + 1),
              (a + 1, b - 1),
              (a + 1, b),
              (a + 1, b + 1),
          )
          s5 = st & set(t_p5)
          ls5 = len(s5)
          Js[ls5] += 1
  
      if a > H - 1 or a < 2 or b < 3:
          pass
      else:
          t_p6 = (
              (a - 1, b - 2),
              (a - 1, b - 1),
              (a - 1, b),
              (a, b - 2),
              (a, b - 1),
              (a, b),
              (a + 1, b - 2),
              (a + 1, b - 1),
              (a + 1, b),
          )
          s6 = st & set(t_p6)
          ls6 = len(s6)
          Js[ls6] += 1
  
      if a < 3 or b > W - 2:
          pass
      else:
          t_p7 = (
              (a - 2, b),
              (a - 2, b + 1),
              (a - 2, b + 2),
              (a - 1, b),
              (a - 1, b + 1),
              (a - 1, b + 2),
              (a, b),
              (a, b + 1),
              (a, b + 2),
          )
          s7 = st & set(t_p7)
          ls7 = len(s7)
          Js[ls7] += 1
  
      if a < 3 or b > W - 1 or b < 2:
          pass
      else:
          t_p8 = (
              (a - 2, b - 1),
              (a - 2, b),
              (a - 2, b + 1),
              (a - 1, b - 1),
              (a - 1, b),
              (a - 1, b + 1),
              (a, b - 1),
              (a, b),
              (a, b + 1),
          )
          s8 = st & set(t_p8)
          ls8 = len(s8)
          Js[ls8] += 1
  
      if a < 3 or b < 3:
          pass
      else:
          t_p9 = (
              (a - 2, b - 2),
              (a - 2, b - 1),
              (a - 2, b),
              (a - 1, b - 2),
              (a - 1, b - 1),
              (a - 1, b),
              (a, b - 2),
              (a, b - 1),
              (a, b),
          )
          s9 = st & set(t_p9)
          ls9 = len(s9)
          Js[ls9] += 1
  
  for i in range(1, 10):
      Js[i] = Js[i] // i
  
  all = (H - 2) * (W - 2)
  Js[0] = all - sum(Js)
  
  for i in range(10):
      print(Js[i])
  
problem_description: Statement
  
  We have a grid with H rows and W columns. At first, all cells were painted
  white.
  
  Snuke painted N of these cells. The i-th ( 1 \leq i \leq N ) cell he painted
  is the cell at the a_i-th row and b_i-th column.
  
  Compute the following:
  
    * For each integer j ( 0 \leq j \leq 9 ), how many subrectangles of size 3×3 of the grid contains exactly j black cells, after Snuke painted N cells?
samples: [{"input": "4 5 8\n    1 1\n    1 4\n    1 5\n    2 3\n    3 1\n    3 2\n    3 4\n    4 4", "output": "0\n    0\n    0\n    2\n    4\n    0\n    0\n    0\n    0\n    0\n    \n\n![](https://atcoder.jp/img/arc061/30326702be007759dce81231012a8353.png)\n\nThere are six subrectangles of size 3\u00d73. Two of them contain three black cells\neach, and the remaining four contain four black cells each.\n\n* * *"}, {"input": "10 10 20\n    1 1\n    1 4\n    1 9\n    2 5\n    3 10\n    4 2\n    4 7\n    5 9\n    6 4\n    6 6\n    6 7\n    7 1\n    7 3\n    7 7\n    8 1\n    8 5\n    8 10\n    9 2\n    10 4\n    10 9", "output": "4\n    26\n    22\n    10\n    2\n    0\n    0\n    0\n    0\n    0\n    \n\n* * *"}, {"input": "1000000000 1000000000 0", "output": "999999996000000004\n    0\n    0\n    0\n    0\n    0\n    0\n    0\n    0\n    0"}]