#include <cassert>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

using namespace std;

using Int = long long;

template <class T1, class T2> ostream &operator<<(ostream &os, const pair<T1, T2> &a) { return os << "(" << a.first << ", " << a.second << ")"; };
template <class T> ostream &operator<<(ostream &os, const vector<T> &as) { const int sz = as.size(); os << "["; for (int i = 0; i < sz; ++i) { if (i >= 256) { os << ", ..."; break; } if (i > 0) { os << ", "; } os << as[i]; } return os << "]"; }
template <class T> void pv(T a, T b) { for (T i = a; i != b; ++i) cerr << *i << " "; cerr << endl; }
template <class T> bool chmin(T &t, const T &f) { if (t > f) { t = f; return true; } return false; }
template <class T> bool chmax(T &t, const T &f) { if (t < f) { t = f; return true; } return false; }
#define COLOR(s) ("\x1b[" s "m")


// rollback
vector<int> uf;
vector<pair<int, int>> his;
void init(int n) {
  uf.assign(n, -1);
  his.clear();
}
void update(int u, int p) {
  his.emplace_back(u, uf[u]);
  uf[u] = p;
}
int snapshot() {
  return his.size();
}
void rollback(int stamp) {
  for (; (int)his.size() > stamp; his.pop_back()) uf[his.back().first] = his.back().second;
}
int root(int u) {
  for (; ; u = uf[u]) {
    if (uf[u] < 0) {
      return u;
    }
  }
}
bool connect(int u, int v) {
  u = root(u);
  v = root(v);
  if (u == v) return false;
  if (uf[u] > uf[v]) swap(u, v);
  update(u, uf[u] + uf[v]);
  update(v, u);
  return true;
}


constexpr int DX[4] = {+1, 0, -1, 0};
constexpr int DY[4] = {0, +1, 0, -1};

int M, N, Q;
vector<int> X, Y;

int id(int x, int y) {
  return x * (N + 2) + y;
}

int main() {
  for (; ~scanf("%d%d%d", &M, &N, &Q); ) {
    X.resize(Q);
    Y.resize(Q);
    for (int q = 0; q < Q; ++q) {
      scanf("%d%d", &X[q], &Y[q]);
    }
    
    string ans(Q, '?');
    
    int n = 0, m = 0, c = 0, s2 = 0, s3 = 0;
    vector<vector<int>> on(M + 2, vector<int>(N + 2, 0));
    init((M + 2) * (N + 2));
    for (int q = 0; q < Q; ++q) {
      const int n0 = n, m0 = m, c0 = c, s20 = s2, s30 = s3;
      const auto snap = snapshot();
      
      ++n;
      ++c;
      on[X[q]][Y[q]] = 1;
      for (int dir = 0; dir < 4; ++dir) {
        const int xx = X[q] + DX[dir];
        const int yy = Y[q] + DY[dir];
        if (on[xx][yy]) {
          ++m;
          if (connect(id(X[q], Y[q]), id(xx, yy))) {
            --c;
          }
        }
      }
      for (int x = X[q] - 1; x <= X[q]; ++x) for (int y = Y[q] - 1; y <= Y[q]; ++y) {
        bool ok = true;
        for (int xx = x; xx < x + 2; ++xx) for (int yy = y; yy < y + 2; ++yy) {
          ok = ok && on[xx][yy];
        }
        if (ok) ++s2;
      }
      for (int x = max(X[q] - 2, 0); x <= min(X[q], M - 1); ++x) for (int y = max(Y[q] - 2, 0); y <= min(Y[q], N - 1); ++y) {
        bool ok = true;
        for (int xx = x; xx < x + 3; ++xx) for (int yy = y; yy < y + 3; ++yy) {
          ok = ok && on[xx][yy];
        }
        if (ok) ++s3;
      }
// cerr<<n<<" "<<m<<" "<<c<<" "<<s2<<" "<<s3<<endl;
      if (c - n + m > s2 || s3 > 0) {
        ans[q] = '0';
        n = n0;
        m = m0;
        c = c0;
        s2 = s20;
        s3 = s30;
        on[X[q]][Y[q]] = 0;
        rollback(snap);
      } else {
        ans[q] = '1';
      }
    }
    
    puts(ans.c_str());
  }
  return 0;
}