#include <bits/stdc++.h>
template <class T>
inline bool chmax(T& a, T b) {
  if (a < b) {
    a = b;
    return 1;
  }
  return 0;
}
template <class T>
inline bool chmin(T& a, T b) {
  if (a > b) {
    a = b;
    return 1;
  }
  return 0;
}
constexpr long long MAX = 5100000;
constexpr long long INF = 1LL << 60;
constexpr int inf = 1000000007;
constexpr long long mod = 1000000007LL;
const long double PI = acos((long double)(-1));
using namespace std;
int f(int a, int b) { return max(a, b); }
int g(int a, int b) { return a + b; }
int h(int a, int b) { return a + b; }
template <typename Monoid, typename OperatorMonoid = Monoid>
struct LazySegmentTree {
  int sz, height;
  vector<Monoid> data;
  vector<OperatorMonoid> lazy;
  const Monoid M1;
  const OperatorMonoid OM0;
  LazySegmentTree(int n, const Monoid& M1, const OperatorMonoid OM0)
      : M1(M1), OM0(OM0) {
    sz = 1;
    height = 0;
    while (sz < n) sz <<= 1, height++;
    data.assign(2 * sz, M1);
    lazy.assign(2 * sz, OM0);
  }
  void set(int k, const Monoid& x) { data[k + sz] = x; }
  void build() {
    for (int k = sz - 1; k > 0; k--) {
      data[k] = f(data[2 * k + 0], data[2 * k + 1]);
    }
  }
  inline void propagate(int k) {
    if (lazy[k] != OM0) {
      lazy[2 * k + 0] = h(lazy[2 * k + 0], lazy[k]);
      lazy[2 * k + 1] = h(lazy[2 * k + 1], lazy[k]);
      data[k] = reflect(k);
      lazy[k] = OM0;
    }
  }
  inline Monoid reflect(int k) {
    return lazy[k] == OM0 ? data[k] : g(data[k], lazy[k]);
  }
  inline void recalc(int k) {
    while (k >>= 1) data[k] = f(reflect(2 * k + 0), reflect(2 * k + 1));
  }
  inline void thrust(int k) {
    for (int i = height; i > 0; i--) propagate(k >> i);
  }
  void update(int a, int b, const OperatorMonoid& x) {
    if (a >= b) return;
    thrust(a += sz);
    thrust(b += sz - 1);
    for (int l = a, r = b + 1; l < r; l >>= 1, r >>= 1) {
      if (l & 1) lazy[l] = h(lazy[l], x), ++l;
      if (r & 1) --r, lazy[r] = h(lazy[r], x);
    }
    recalc(a);
    recalc(b);
  }
  Monoid query(int a, int b) {
    if (a >= b) return M1;
    thrust(a += sz);
    thrust(b += sz - 1);
    Monoid L = M1, R = M1;
    for (int l = a, r = b + 1; l < r; l >>= 1, r >>= 1) {
      if (l & 1) L = f(L, reflect(l++));
      if (r & 1) R = f(reflect(--r), R);
    }
    return f(L, R);
  }
  Monoid operator[](const int& k) { return query(k, k + 1); }
};
int main() {
  constexpr int lm = 450000;
  int n, k, kkt;
  scanf("%d %d %d", &n, &k, &kkt);
  LazySegmentTree<int, int> lsg(lm, -inf, 0);
  for (int i = 0; i < lm; i++) lsg.set(i, i - 1);
  lsg.build();
  set<pair<int, int>> sp;
  multiset<int> ms;
  while (kkt--) {
    int x, y;
    scanf("%d %d", &x, &y);
    int t = abs(x - k) + y;
    if (sp.find({x, y}) == sp.end()) {
      sp.emplace(x, y);
      lsg.update(0, t + 1, 1);
      ms.emplace(t);
    } else {
      sp.erase(sp.find({x, y}));
      lsg.update(0, t + 1, -1);
      ms.erase(ms.find(t));
    }
    if (ms.empty())
      puts("0");
    else {
      int mx = lsg.query(0, *ms.rbegin() + 1);
      printf("%d\n", max(n, mx) - n);
    }
  }
  return 0;
}
