#include <bits/stdc++.h>

using u32 = unsigned;
using i64 = long long;
using u64 = unsigned long long;

constexpr int V = 300001;

int f[V], siz[V];
int find(int x) {
    while (x != f[x]) {
        x = f[x];
    }
    return x;
}

std::vector<int> his;

bool merge(int a, int b) {
    a = find(a);
    b = find(b);
    if (a == b) {
        return false;
    }
    if (siz[a] < siz[b]) {
        std::swap(a, b);
    }
    his.push_back(b);
    f[b] = a;
    siz[a] += siz[b];
    return true;
}

void revert(int t) {
    while (his.size() > t) {
        int b = his.back();
        his.pop_back();
        int a = f[b];
        siz[a] -= siz[b];
        f[b] = b;
    }
}

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    
    int n, m, k;
    std::cin >> n >> m >> k;
    
    std::vector<int> r(k), c(k);
    for (int i = 0; i < k; i++) {
        std::cin >> r[i] >> c[i];
        r[i]--;
        c[i]--;
    }
    
    const int N = n * m;
    std::vector<int> col(N);
    
    std::iota(f, f + N + 1, 0);
    std::fill(siz, siz + N + 1, 1);
    
    int M = 1;
    while (M < k) {
        M *= 2;
    }
    M *= 2;
    
    std::vector<std::vector<int>> vec(M);
    auto add = [&](auto self, int p, int l, int r, int x, int y, int cell) {
        if (l >= y || r <= x) {
            return;
        }
        if (l >= x && r <= y) {
            vec[p].push_back(cell);
            return;
        }
        int m = (l + r) / 2;
        self(self, 2 * p, l, m, x, y, cell);
        self(self, 2 * p + 1, m, r, x, y, cell);
    };
    
    auto valid = [&](int x, int y) {
        return 0 <= x && x < n && 0 <= y && y < m;
    };
    
    std::vector<int> lst(N);
    for (int i = 0; i < k; i++) {
        int cell = r[i] * m + c[i];
        add(add, 1, 0, k, lst[cell], i, cell);
        lst[cell] = i + 1;
    }
    for (int cell = 0; cell < N; cell++) {
        add(add, 1, 0, k, lst[cell], k, cell);
    }
    
    int comp = 1;
    std::vector<bool> ans(k);
    std::vector<bool> vis(N);
    auto dfs = [&](auto self, int p, int L, int R) -> void {
        const int t = his.size();
        const int oldcomp = comp;
        for (auto cell : vec[p]) {
            vis[cell] = true;
            if (col[cell] == 1) {
                continue;
            }
            int x = cell / m;
            int y = cell % m;
            comp++;
            for (int dx = -1; dx <= 1; dx++) {
                for (int dy = -1; dy <= 1; dy++) {
                    int nx = x + dx;
                    int ny = y + dy;
                    int v = nx * m + ny;
                    if (valid(nx, ny) && vis[v] && col[v] == 0) {
                        comp -= merge(cell, v);
                    }
                }
            }
            if (x == 0 || x == n - 1 || y == 0 || y == m - 1) {
                comp -= merge(cell, N);
            }
        }
        if (R - L == 1) {
            int cell = r[L] * m + c[L];
            bool ok = true;
            if (comp > 1) {
                ok = false;
            }
            for (int dx = -1; dx <= 1; dx++) {
                for (int dy = -1; dy <= 1; dy++) {
                    int x = r[L] + dx;
                    int y = c[L] + dy;
                    int u = x * m + y;
                    if (!valid(x, y) || col[u] == 0 || !vis[u]) {
                        continue;
                    }
                    const int t = his.size();
                    const int oldcomp = comp;
                    comp++;
                    for (int dx = -1; dx <= 1; dx++) {
                        for (int dy = -1; dy <= 1; dy++) {
                            int nx = x + dx;
                            int ny = y + dy;
                            int v = nx * m + ny;
                            if (valid(nx, ny) && vis[v] && col[v] == 0) {
                                comp -= merge(cell, v);
                            }
                        }
                    }
                    if (x == 0 || x == n - 1 || y == 0 || y == m - 1) {
                        comp -= merge(cell, N);
                    }
                    if (comp > 1) {
                        ok = false;
                    }
                    revert(t);
                    comp = oldcomp;
                    if (!ok) {
                        break;
                    }
                }
                if (!ok) {
                    break;
                }
            }
            if (ok) {
                col[cell] = 1;
                ans[L] = true;
            }
        } else {
            int m = (L + R) / 2;
            self(self, 2 * p, L, m);
            self(self, 2 * p + 1, m, R);
        }
        revert(t);
        comp = oldcomp;
        for (auto cell : vec[p]) {
            vis[cell] = false;
        }
    };
    dfs(dfs, 1, 0, k);
    
    for (int i = 0; i < k; i++) {
        std::cout << ans[i];
    }
    std::cout << "\n";
    
    return 0;
}