// Slower C++ solution:
#include <cmath>

#include <cstdio>

#include <cstring>

#include <algorithm>

#include <set>

using std::min; using std::max;

using std::swap; using std::sort;

using std::set;

typedef long long ll;

typedef std::pair<int, int> pii;



template<typename T>

void read(T &x) {

	int flag = 1; x = 0; char ch = getchar();

	while(ch < '0' || ch > '9') { if(ch == '-') flag = -flag; ch = getchar(); }

	while(ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();

	x *= flag;

}



const int _ = 1e5 + 10;

const int dx[30] = {0,

					-2, -1, 0, 1, 2,

					-2, -1, 0, 1, 2,

					-2, -1, 0, 1, 2,

					-2, -1, 0, 1, 2,

					-2, -1, 0, 1, 2};

const int dy[30] = {0,

					2, 2, 2, 2, 2,

					1, 1, 1, 1, 1,

					0, 0, 0, 0, 0,

					-1, -1, -1, -1, -1,

					-2, -2, -2, -2, -2};

ll h, w, n; int now; int v[30];

struct node { int x, y; } p[_];

ll r[10];

set<pii> S;



bool f(int dx, int dy) {

	int x = p[now].x + dx, y = p[now].y + dy;

	return S.find((pii){x, y}) != S.end();

}



bool chk(int x, int y) {

	return x >= 1 && y >= 1 && x <= h && y <= w;

}



int main () {

	read(h), read(w), read(n);

	for(int i = 1; i <= n; ++i) {

		read(p[i].x), read(p[i].y);

		S.insert((pii){p[i].x, p[i].y});

	}

	for(int i = 1; i <= n; ++i) {

		now = i;

		for(int j = 1; j <= 25; ++j) v[j] = f(dx[j], dy[j]);

		if(chk(p[now].x - 2, p[now].y + 2) && chk(p[now].x, p[now].y))

		++r[v[1] + v[2] + v[3] + v[6] + v[7] + v[8] + v[11] + v[12] + v[13]];

		

		if(chk(p[now].x - 1, p[now].y + 2) && chk(p[now].x + 1, p[now].y))

		++r[v[2] + v[3] + v[4] + v[7] + v[8] + v[9] + v[12] + v[13] + v[14]];

		

		if(chk(p[now].x, p[now].y + 2) && chk(p[now].x + 2, p[now].y))

		++r[v[3] + v[4] + v[5] + v[8] + v[9] + v[10] + v[13] + v[14] + v[15]];

		

		if(chk(p[now].x - 2, p[now].y + 1) && chk(p[now].x, p[now].y - 1))

		++r[v[6] + v[7] + v[8] + v[11] + v[12] + v[13] + v[16] + v[17] + v[18]];

		

		if(chk(p[now].x - 1, p[now].y + 1) && chk(p[now].x + 1, p[now].y - 1))

		++r[v[7] + v[8] + v[9] + v[12] + v[13] + v[14] + v[17] + v[18] + v[19]];

		

		if(chk(p[now].x, p[now].y + 1) && chk(p[now].x + 2, p[now].y - 1))

		++r[v[8] + v[9] + v[10] + v[13] + v[14] + v[15] + v[18] + v[19] + v[20]];

		

		if(chk(p[now].x - 2, p[now].y) && chk(p[now].x, p[now].y - 2))

		++r[v[11] + v[12] + v[13] + v[16] + v[17] + v[18] + v[21] + v[22] + v[23]];

		

		if(chk(p[now].x - 1, p[now].y) && chk(p[now].x + 1, p[now].y - 2))

		++r[v[12] + v[13] + v[14] + v[17] + v[18] + v[19] + v[22] + v[23] + v[24]];

		

		if(chk(p[now].x, p[now].y) && chk(p[now].x + 2, p[now].y - 2))

		++r[v[13] + v[14] + v[15] + v[18] + v[19] + v[20] + v[23] + v[24] + v[25]];

	}

	r[0] = (h - 2) * (w - 2);

	for(int i = 1; i <= 9; ++i) r[i] /= i, r[0] -= r[i];

	for(int i = 0; i <= 9; ++i) printf("%lld\n", r[i]);

	return 0;

} 


// Faster C++ solution for the same problem (measured speedup: 4.70921933381484x):
#include<stdio.h>

#include<stdlib.h>

#include<string.h>

#include<algorithm>

using namespace std;

#define INF (int(1e9)+7)//1e9+7进制

#define maxn (int(1e6)+5)

typedef long long ll;

ll node[maxn];

ll res[15];

int main(void)

{

	ll H, W, N;

	scanf("%lld %lld %lld", &H, &W, &N);

	int cnt = 0;

	while (N--)

	{

		ll a, b;

		scanf("%lld %lld", &a, &b);

		for (int i = -1; i <= 1; i++)

			for (int j = -1; j <= 1; j++)

				if (a + i >= 2 && a + i <= H - 1 && b + j >= 2 && b + j <= W - 1)

					node[cnt++] = (a + i) * INF + (b + j);

	}

	sort(node, node + cnt);

	ll temp = node[0];

	ll sum = 1;

	for (int i = 1; i < cnt; i++) {

		if (node[i] == temp)

			sum++;

		else

			res[sum]++, sum = 1, temp = node[i];

	}

	if(cnt)res[sum]++;

	res[0] = (H - 2) * (W - 2);

	for (int i = 1; i <= 9; i++)

		res[0] -= res[i];

	for (int i = 0; i <= 9; i++)

		printf("%lld\n", res[i]);

	return 0;

}