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 Rust (1.15.1) (judge verdict: Accepted)

macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
    ($($r:tt)*) => {
        let mut s = {
            use std::io::Read;
            let mut s = String::new();
            std::io::stdin().read_to_string(&mut s).unwrap();
            s
        };
        let mut iter = s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
}

macro_rules! input_inner {
    ($iter:expr) => {};
    ($iter:expr, ) => {};

    ($iter:expr, $var:ident : $t:tt $($r:tt)*) => {
        let $var = read_value!($iter, $t);
        input_inner!{$iter $($r)*}
    };
}

macro_rules! read_value {
    ($iter:expr, ( $($t:tt),* )) => {
        ( $(read_value!($iter, $t)),* )
    };

    ($iter:expr, [ $t:tt ; $len:expr ]) => {
        (0..$len).map(|_| read_value!($iter, $t)).collect::<Vec<_>>()
    };

    ($iter:expr, chars) => {
        read_value!($iter, String).chars().collect::<Vec<char>>()
    };

    ($iter:expr, usize1) => {
        read_value!($iter, usize) - 1
    };

    ($iter:expr, $t:ty) => {
        $iter.next().unwrap().parse::<$t>().expect("Parse error")
    };
}

use std::collections::{HashMap, VecDeque};
fn corners_around(h: i64, w: i64, n: &(i64, i64)) -> Vec<(i64, i64)> {
    let mut res = Vec::new();
    let &(c_y, c_x) = n;
    for diff_x in -3..0 {
        for diff_y in -3..0 {
            let sx = c_x + diff_x;
            let sy = c_y + diff_y;
            let ex = sx + 3;
            let ey = sy + 3;
            if sx >= 0 && ex <= w && sy >= 0 && ey <= h {
                res.push((sy, sx));
            }
        }
    }
    res
}

fn solve(h: i64, w: i64, ns: &[(i64, i64)]) -> VecDeque<u64> {
    let mut res_map = HashMap::new();
    for n in ns {
        let corners = corners_around(h, w, n);
        for c in corners {
            *res_map.entry(c).or_insert(0) += 1;
        }
    }

    let mut res = VecDeque::new();
    for i in 1..10 {
        let n = res_map
            .values()
            .fold(0, |acc, x| if *x == i { acc + 1 } else { acc });

        res.push_back(n as u64)
    }
    let total_rect = (h - 2) * (w - 2);
    let remain = total_rect - res.iter().fold(0, |acc, n| acc + n) as i64;
    res.push_front(remain as u64);
    res
}

fn main() {
    input! {h: i64, w: i64, n:usize, ns: [(i64, i64); n]};
    let result = solve(h, w, &ns);
    for i in result {
        println!("{}", i);
    }
}