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 Haskell (GHC 7.10.3) (judge verdict: Time Limit Exceeded)

import Data.Set( member, insert, empty, foldl', elems)
import qualified Data.Set as S
import Control.Monad( replicateM, foldM)
import Data.Maybe( fromJust)
import Data.List( foldl')
import qualified Data.List as L
import Data.Array.IO( IOArray, newArray, writeArray
		    ,	readArray, getElems, freeze)
import Data.Array(Array, elems)
main = do
    let getElements = return . map read . words =<< getLine
	getPos = do
	    [r,c] <- getElements
	    return (r,c)
    [h,w,n] <- getElements
    poss <- replicateM n getPos
    let table = L.foldl' (\st pos->insert pos st) empty poss
	searchingFlames (baseR,baseC) = do
	    let left = max 1 (baseC-2)
		right = min (w-2) baseC
		top = max 1 (baseR-2)
		bottom = min (h-2) baseR
	    (ro,co) <- [(r,c) | r <- [top..bottom]  ,
				c <- [left..right]  ]
	    return [(r,c) | r <- [ro..ro+2], c <- [co..co+2]]
	count::[(Int,Int)]->(Int,Int)->Maybe Int
	count box base = do
	    let check ij
		  | member ij table = if ij<base
					then Nothing
					else Just 1
		  | otherwise = Just 0
	    return . sum =<< mapM check box
	countArround p = map fromJust . filter (Nothing/=) .
			    map (`count` p) . searchingFlames $ p
    inicArray <- newArray (0,9) 0
    let countIncl carr ix = do
	    v <- readArray carr ix
	    writeArray carr ix (succ v)
	    return carr
	rec::IOArray Int Integer->(Int,Int)->IO (IOArray Int Integer)
	rec carr = foldM countIncl carr . countArround
    answer <- foldM rec inicArray $ S.elems table
    except0 <- return . sum =<< getElems answer
    let numFlames = (fromIntegral h-2)*(fromIntegral w-2)
    writeArray answer 0 $ numFlames - except0
    mapM_ print . Data.Array.elems =<< freeze answer