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 Go (1.6) (judge verdict: Accepted)

package main

import (
	"fmt"
	"sort"
)

func calc(W int, A []int, p [][]int) {
	w := 0
	v := 0
	q := []int{0, 0, 0}
	for w = 0; w < 2; w++ {
		for i := 0; i < 3; i++ {
			if len(p[i]) > 0 && w == p[i][0] {
				q[w+1]++
				p[i] = p[i][1:]
			}
		}
	}
	for {
		q[0], q[1], q[2] = q[1], q[2], 0
		if q[0]+q[1]+q[2] == 0 {
			w = W
			for i := 0; i < 3; i++ {
				if len(p[i]) > 0 && p[i][0] < w {
					w = p[i][0]
				}
			}
		}
		if w >= W {
			break
		}
		for i := 0; i < 3; i++ {
			if len(p[i]) > 0 && w == p[i][0] {
				q[2]++
				p[i] = p[i][1:]
			}
		}
		A[q[0]+q[1]+q[2]]++
		w++
		v++
	}
	A[0] += w - 2 - v
}

func main() {
	var H, W, N int
	fmt.Scan(&H, &W, &N)
	M := map[int][]int{}
	for i := 0; i < N; i++ {
		var a, b int
		fmt.Scan(&a, &b)
		M[a-1] = append(M[a-1], b-1)
	}
	r := make([]int, 0, len(M))
	for i, c := range M {
		sort.Ints(c)
		r = append(r, i)
	}
	sort.Ints(r)
	A := make([]int, 10)
	h := 0
	v := 0
	q := make([][]int, 3)
	for h = 0; h < 2; h++ {
		if len(r) > 0 && h == r[0] {
			q[h+1] = M[h]
			r = r[1:]
		}
	}
	for {
		q[0], q[1], q[2] = q[1], q[2], nil
		if q[0] == nil && q[1] == nil && q[2] == nil {
			h = H
			if len(r) > 0 {
				h = r[0]
			}
		}
		if h >= H {
			break
		}
		if len(r) > 0 && h == r[0] {
			q[2] = M[h]
			r = r[1:]
		}
		calc(W, A, [][]int{q[0], q[1], q[2]})
		h++
		v++
	}
	A[0] += (H - 2 - v) * (W - 2)
	for _, a := range A {
		fmt.Println(a)
	}
}