import std.stdio, std.string, std.conv;
import std.range, std.algorithm, std.array, std.typecons, std.container;
import std.math, std.numeric, core.bitop;

enum inf3 = 1_001_001_001;
enum inf6 = 1_001_001_001_001_001_001L;
enum mod = 1_000_000_007L;

int[] di = [-1, 0, 1, -1, 0, 1, -1, 0, 1];
int[] dj = [-1, -1, -1, 0, 0, 0, 1, 1, 1];
alias Block = Tuple!(int, "i", int, "j");

void main() {
    int h, w, n;
    scan(h, w, n);

    //int[Block] cnt;
    Block[] bs;

    foreach (i ; 0 .. n) {
        int ai, bi;
        scan(ai, bi);
        ai--, bi--;

        foreach (k ; 0 .. 9) {
            int ni = ai + di[k];
            int nj = bi + dj[k];
            if (ni < 1 || nj < 1 || ni >= h - 1 || nj >= w - 1) continue;
            //cnt[Block(ni, nj)]++;
            bs ~= Block(ni, nj);
        }
    }

    auto gs = bs.sort().group.map!(i => i[1]);

    debug {
        //writeln(cnt);
    }

    auto ans = new long[](10);
    long t;

    foreach (g; gs) {
        ans[g]++;
        t++;
    }

    ans[0] = 1L * (h - 2) * (w - 2) - t;

    writefln("%(%d\n%)", ans);
}





void yes(bool b) {writeln(b ? "Yes" : "No");}
void YES(bool b) {writeln(b ? "YES" : "NO");}
T[] readArr(T)() {return readln.split.to!(T[]);}

void scan(T...)(ref T args) {
    import std.stdio : readln;
    import std.algorithm : splitter;
    import std.conv : to;
    import std.range.primitives;

    auto line = readln().splitter();
    foreach (ref arg; args) {
        arg = line.front.to!(typeof(arg));
        line.popFront();
    }
    assert(line.empty);
}

void fillAll(R, T)(ref R arr, T value) {
    static if (is(typeof(arr[] = value))) {
        arr[] = value;
    }
    else {
        foreach (ref e; arr) {
            fillAll(e, value);
        }
    }
}
