#include <bits/stdc++.h>
using namespace std;
using ll = long long;
signed main() {
  ios_base::sync_with_stdio(0);
  cin.tie(0);
  int n, m, q;
  while (cin >> n >> m >> q) {
    vector<set<int>> lt(n), rb(n);
    queue<pair<int, int>> que;
    struct SegmentTree {
      int n;
      int init_val;
      vector<int> tree;
      function<int(int, int)> f;
      SegmentTree(int n, int init_val, function<int(int, int)> f)
          : n(n), init_val(init_val), tree(4 * n, init_val), f(f) {}
      int get(int l, int r) { return get(l, r, 1, 0, n - 1); }
      int get(int l, int r, int tv, int tl, int tr) {
        if (l <= tl && tr <= r) return tree[tv];
        if (tr < l || r < tl) return init_val;
        int tm = (tl + tr) / 2;
        return f(get(l, r, 2 * tv, tl, tm), get(l, r, 2 * tv + 1, tm + 1, tr));
      }
      void set(int idx, int val) { set(idx, val, 1, 0, n - 1); }
      void set(int idx, int val, int tv, int tl, int tr) {
        if (tl == tr) {
          tree[tv] = val;
        } else {
          int tm = (tl + tr) / 2;
          if (idx <= tm)
            set(idx, val, 2 * tv, tl, tm);
          else
            set(idx, val, 2 * tv + 1, tm + 1, tr);
          tree[tv] = f(tree[2 * tv], tree[2 * tv + 1]);
        }
      }
    };
    SegmentTree min_tree(n, m + 1, [](int a, int b) { return min(a, b); });
    SegmentTree max_tree(n, -1, [](int a, int b) { return max(a, b); });
    auto check = [&](int ii, int jj) {
      int i = ii / 2;
      int j = jj / 2;
      if (ii % 2) {
        if (!lt[i].count(j)) return true;
        auto mi = min_tree.get(0, i);
        return mi > j;
      } else {
        if (!rb[i].count(j)) return true;
        auto ma = max_tree.get(i, n - 1);
        return j > ma;
      }
    };
    while (q--) {
      int ii, jj;
      cin >> ii >> jj;
      --ii, --jj;
      int i = ii / 2;
      int j = jj / 2;
      if (ii % 2) {
        if (lt[i].count(j)) {
          lt[i].erase(j);
          int val = lt[i].empty() ? -1 : *lt[i].rbegin();
          max_tree.set(i, val);
        } else {
          lt[i].insert(j);
          max_tree.set(i, *lt[i].rbegin());
        }
      } else {
        if (rb[i].count(j)) {
          rb[i].erase(j);
          int val = rb[i].empty() ? m + 1 : *rb[i].begin();
          min_tree.set(i, val);
        } else {
          rb[i].insert(j);
          min_tree.set(i, *rb[i].begin());
        }
      }
      que.emplace(ii, jj);
      while (!que.empty()) {
        auto [ii, jj] = que.front();
        if (!check(ii, jj)) {
          break;
        }
        que.pop();
      }
      cout << (que.empty() ? "YES" : "NO") << "\n";
    }
  }
}
