Problem:
Score : 400 points

Problem 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?

Constraints

3 \leq H \leq 10^9

3 \leq W \leq 10^9

0 \leq N \leq min(10^5,H×W)

1 \leq a_i \leq H (1 \leq i \leq N)

1 \leq b_i \leq W (1 \leq i \leq N)

(a_i, b_i) \neq (a_j, b_j) (i \neq j)

Input

The input is given from Standard Input in the following format:

H W N
a_1 b_1
:
a_N b_N

Output

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.

Sample Input 1

4 5 8
1 1
1 4
1 5
2 3
3 1
3 2
3 4
4 4

Sample Output 1

0
0
0
2
4
0
0
0
0
0

There are six subrectangles of size 3×3. Two of them contain three black cells each, and the remaining four contain four black cells each.

Sample Input 2

10 10 20
1 1
1 4
1 9
2 5
3 10
4 2
4 7
5 9
6 4
6 6
6 7
7 1
7 3
7 7
8 1
8 5
8 10
9 2
10 4
10 9

Sample Output 2

4
26
22
10
2
0
0
0
0
0

Sample Input 3

1000000000 1000000000 0

Sample Output 3

999999996000000004
0
0
0
0
0
0
0
0
0

Solution in C# (Mono 4.6.2.0) (judge verdict: Accepted)

using System;
using System.Collections.Generic;

namespace ABC045_D_SnukesColoring
{
    class ABC045_D_Review
    {
        static void Main(string[] args)
        {
            Reader.Debugging = false;

            string[] first = Reader.ReadLine().Split(' ');
            int H = int.Parse(first[0]);
            int W = int.Parse(first[1]);
            int N = int.Parse(first[2]);

            // (y, x) -> count

            var yToXAndCount = new Dictionary<int, Dictionary<int, int>>();

            var pointToCount = new Dictionary<KeyValuePair<int, int>, int>();

            for (int i = 0; i < N; i++)
            {
                string[] split = Reader.ReadLine().Split(' ');
                int y = int.Parse(split[0]) - 1;
                int x = int.Parse(split[1]) - 1;

                for (int n = -2; n <= 0; n++)
                {
                    int Y = y + n;

                    if (Y < 0 || H - 2 < Y)
                    {
                        continue;
                    }

                    if (!yToXAndCount.ContainsKey(Y))
                    {
                        yToXAndCount[Y] = new Dictionary<int, int>();
                    }

                    for (int m = -2; m <= 0; m++)
                    {
                        int X = x + m;

                        if (X < 0 || W - 2 < X)
                        {
                            continue;
                        }

                        if (!yToXAndCount[Y].ContainsKey(X))
                        {
                            yToXAndCount[Y].Add(X, 0);
                        }

                        yToXAndCount[Y][X]++;
                    }

                }

                //for (int n = -2; n <= 0; n++)
                //{
                //    for (int m = -2; m <= 0; m++)
                //    {
                //        // 3x3の個数が数えられるのは[0, 0]～[H - 2, W - 2]の範囲内
                //        if (y + n < 0 || H - 2 < y + n ||
                //            x + m < 0 || W - 2 < x + m)
                //        {
                //            continue;
                //        }

                //        var p = new KeyValuePair<int, int>(y + n, x + m);
                //        if (!pointToCount.ContainsKey(p))
                //        {
                //            pointToCount.Add(p, 0);
                //        }

                //        pointToCount[p]++;
                //    }
                //}
            }

            ulong[] counts = new ulong[10];
            foreach (var yxc in yToXAndCount)
            {
                foreach (var xc in yxc.Value)
                {
                    if (yxc.Key < H - 2 && xc.Key < W - 2)
                    {
                        counts[xc.Value]++;
                    }
                }
            }

            // 0のマスは(H - 2) * (W - 2) - （1以上のマスの数）
            counts[0] = ((ulong)H - 2) * ((ulong)W - 2);
            for (int i = 1; i < counts.Length; i++)
            {
                counts[0] -= counts[i];
            }

            for (int i = 0; i < counts.Length; i++)
            {
                Console.WriteLine(counts[i]);
            }

            Console.ReadKey();
        }
    }

    public static class Reader
    {
        public static bool Debugging = true;
        private static System.IO.StringReader _sr = null;

        public static string ReadLine()
        {
            if (Debugging)
            {
                if (_sr == null)
                {
                    _sr = new System.IO.StringReader(_input.Trim());
                }

                return _sr.ReadLine();
            }

            return Console.ReadLine();
        }

        /// <summary>
        /// デバッグ用入力文字列
        /// </summary>
        private static string _input = @"
10 10 20
1 1
1 4
1 9
2 5
3 10
4 2
4 7
5 9
6 4
6 6
6 7
7 1
7 3
7 7
8 1
8 5
8 10
9 2
10 4
10 9";

    }
}