#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("Ofast")

// hloya template v26

// ░░░░░░░▄▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▄░░░░░░
// ░░░░░░█░░▄▀▀▀▀▀▀▀▀▀▀▀▀▀▄░░█░░░░░
// ░░░░░░█░█░▀░░░░░▀░░▀░░░░█░█░░░░░
// ░░░░░░█░█░░░░░░░░▄▀▀▄░▀░█░█▄▀▀▄░
// █▀▀█▄░█░█░░▀░░░░░█░░░▀▄▄█▄▀░░░█░
// ▀▄▄░▀██░█▄░▀░░░▄▄▀░░░░░░░░░░░░▀▄
// ░░▀█▄▄█░█░░░░▄░░█░░░▄█░░░▄░▄█░░█
// ░░░░░▀█░▀▄▀░░░░░█░██░▄░░▄░░▄░███
// ░░░░░▄█▄░░▀▀▀▀▀▀▀▀▄░░▀▀▀▀▀▀▀░▄▀░
// ░░░░█░░▄█▀█▀▀█▀▀▀▀▀▀█▀▀█▀█▀▀█░░░
// ░░░░▀▀▀▀░░▀▀▀░░░░░░░░▀▀▀░░▀▀░░░░

#include <bits/stdc++.h>
using namespace std;

bool dbg = 0;

clock_t start_time = clock();
#define current_time                                                           \
  fixed << setprecision(6) << (ld)(clock() - start_time) / CLOCKS_PER_SEC

#define f first
#define s second
#define mp make_pair
#define mt make_tuple
#define pb push_back
#define eb emplace_back
#define all(v) (v).begin(), (v).end()
#define sz(v) ((int)(v).size())
#define sqr(x) ((x) * (x))

#define ull unsigned long long
#define ll long long
#define ld long double
#define pii pair<int, int>
#define umap unordered_map<int, int>

#define files1 freopen("input.txt", "r", stdin)
#define files2 freopen("output.txt", "w", stdout)
#define files                                                                  \
  files1;                                                                      \
  files2
#define fast_io                                                                \
  ios_base::sync_with_stdio(0);                                                \
  cin.tie(0)

// #define endl '\n'
#define ln(i, n) " \n"[(i) == (n)-1]

void bad(string mes = "NO") {
  cout << mes;
  exit(0);
}
void bad(int mes) {
  cout << mes;
  exit(0);
}

template <typename T> string bin(T x, int st = 2) {
  string ans = "";
  while (x > 0) {
    ans += char('0' + x % st);
    x /= st;
  }
  reverse(ans.begin(), ans.end());
  return ans.empty() ? "0" : ans;
}

mt19937_64 mt_rand(228 // chrono::system_clock::now().time_since_epoch().count()
);

template <typename T1, typename T2> inline bool upmax(T1 &a, T2 b) {
  return (a < b ? (a = b, true) : false);
}
template <typename T1, typename T2> inline bool upmin(T1 &a, T2 b) {
  return (b < a ? (a = b, true) : false);
}

// inline int popcount(int x){
//     int count = 0;
//     __asm__ volatile("POPCNT %1, %0;":"=r"(count):"r"(x):);
//     return count;
// }

template <typename T> T input() {
  T ans = 0, m = 1;
  char c = ' ';

  while (!((c >= '0' && c <= '9') || c == '-')) {
    c = getchar();
  }

  if (c == '-')
    m = -1, c = getchar();
  while (c >= '0' && c <= '9') {
    ans = ans * 10 + (c - '0'), c = getchar();
  }
  return ans * m;
}

template <typename T> T gcd(T a, T b) {
  while (b) {
    a %= b;
    swap(a, b);
  }
  return a;
}

template <typename T> void read(T &a) { a = input<T>(); }
template <typename T> void read(T &a, T &b) { read(a), read(b); }
template <typename T> void read(T &a, T &b, T &c) { read(a, b), read(c); }
template <typename T> void read(T &a, T &b, T &c, T &d) {
  read(a, b), read(c, d);
}

const int inf = 1e9 + 20;
const short short_inf = 3e4 + 20;
const long double eps = 1e-12;
const int maxn = (int)2e5 + 3, base = 998244353;
const ll llinf = 2e18 + 5;
const int mod = 1e9 + 7;

// int solveBrute(set<pii> pts) {
//   set<pii> s = pts;
//   bool hap = false;
//   do {
//     hap = false;
//     auto s_new = s;
//     for (auto p : s) {
//       pii top = mp(p.f + 1, p.s);
//       pii bot = mp(p.f - 1, p.s);
//       pii left = mp(p.f, p.s - 1);
//       pii right = mp(p.f, p.s + 1);
//       bool can_remove = false;
//       if (!s.count(top) && !s.count(bot)) {
//         can_remove = true;
//       }
//       if (!s.count(left) && !s.count(right)) {
//         can_remove = true;
//       }
//       if (can_remove) {
//         s_new.erase(p);
//         hap = true;
//       }
//     }
//     s = s_new;
//   } while (hap);
//   return pts.size() - s.size();
// }

const int MAXD = 200005;
set<tuple<int, int, bool>> ranges_d1[MAXD * 2],
    ranges_d2[MAXD * 2]; // x, y, is_banned (banned_ranges)

// time, insert/remove, value, diag_id
vector<tuple<int, bool, tuple<int, int, bool>, int>> events_rd1, events_rd2;

vector<pair<int, pii>> events_add, events_ban;

struct hash_pii {
  size_t operator()(const pii &p) const {
    return hash<size_t>()(((size_t)p.first) << 32 | p.second);
  }
};

using SetType = unordered_set<pii, hash_pii>; // Faster?
// using SetType = set<pii>;

bool has_square(const SetType &added, int x, int y) {
  return added.count(mp(x, y)) && added.count(mp(x + 1, y)) &&
         added.count(mp(x, y + 1)) && added.count(mp(x + 1, y + 1));
}

bool in_square(const SetType &added, int x, int y) {
  bool sq1 = has_square(added, x - 1, y - 1);
  bool sq2 = has_square(added, x - 1, y);
  bool sq3 = has_square(added, x, y - 1);
  bool sq4 = has_square(added, x, y);

  bool in_square = sq1 || sq2 || sq3 || sq4;
  return in_square;
}

SetType added;
SetType banned;
int banned_ranges_sum = 0;

void add_point(const pii &p, int cur_time) {
  // bool dbg = p == mp(3, 4);
  bool dbg = false;
  // Ads one point (unbanned)
  // Expects to not be on banned range, looks correct because impossible to add
  // near banned range
  auto insert_carefully =
      [&](set<tuple<int, int, bool>> &s, int x,
          vector<tuple<int, bool, tuple<int, int, bool>, int>> &events, int d) {
        auto it = s.insert({x, x + 1, false}).first;
        events.pb({cur_time, true, *it, d});
        if (it != s.begin()) {
          auto it2 = it;
          it2--;
          if (get<1>(*it2) == get<0>(*it)) {
            auto un = mt(get<0>(*it2), get<1>(*it), false);
            events.pb({cur_time, false, *it2, d});
            s.erase(it2);
            events.pb({cur_time, false, *it, d});
            s.erase(it);
            it = s.insert(un).first;
            events.pb({cur_time, true, *it, d});
          }
        }
        auto it2 = it;
        ++it2;
        if (it2 != s.end()) {
          if (get<0>(*it2) == get<1>(*it)) {
            auto un = mt(get<0>(*it), get<1>(*it2), false);
            events.pb({cur_time, false, *it, d});
            s.erase(it);
            events.pb({cur_time, false, *it2, d});
            s.erase(it2);
            it = s.insert(un).first;
            events.pb({cur_time, true, *it, d});
          }
        }
      };

  // Expects point to be in range
  // Doesn't change ban status
  auto remove_carefully =
      [&](set<tuple<int, int, bool>> &s, int x,
          vector<tuple<int, bool, tuple<int, int, bool>, int>> &events, int d) {
        auto it = s.upper_bound({x, inf, false});
        assert(it != s.begin());
        it--;
        assert(get<0>(*it) <= x && get<1>(*it) >= x);

        auto un = *it;
        s.erase(it);
        events.pb({cur_time, false, un, d});

        if (get<2>(un)) {
          banned_ranges_sum -= 1; // Removed one point from banned range
        }

        auto l = mt(get<0>(un), x, get<2>(un));
        auto r = mt(x + 1, get<1>(un), get<2>(un));

        if (get<0>(l) != get<1>(l)) {
          s.insert(l);
          events.pb({cur_time, true, l, d});
        }
        if (get<0>(r) != get<1>(r)) {
          s.insert(r);
          events.pb({cur_time, true, r, d});
        }
      };

  auto add_to_ranges = [&](pii p) {
    assert(!added.count(p));
    added.insert(p);
    events_add.pb({cur_time, p});

    int d1 = p.f - p.s + MAXD;
    int d2 = p.f + p.s;

    insert_carefully(ranges_d1[d1], p.f, events_rd1, d1);
    insert_carefully(ranges_d2[d2], p.f, events_rd2, d2);
  };

  auto ban = [&](pii p) {
    assert(!banned.count(p));
    banned.insert(p);
    events_ban.pb({cur_time, p});

    int d1 = p.f - p.s + MAXD;
    int d2 = p.f + p.s;
    // remove from ranges
    remove_carefully(ranges_d1[d1], p.f, events_rd1, d1);
    remove_carefully(ranges_d2[d2], p.f, events_rd2, d2);
  };

  auto ban_the_square = [&](pii p, set<pii> &to_check_diags) {
    // assert(has_square(added, p.f, p.s));
    pii a = p;
    pii b = mp(p.f + 1, p.s);
    pii c = mp(p.f, p.s + 1);
    pii d = mp(p.f + 1, p.s + 1);
    bool need_check_diags = false;
    if (!banned.count(a)) {
      ban(a);
      need_check_diags = true;
    }
    if (!banned.count(b)) {
      ban(b);
      need_check_diags = true;
    }
    if (!banned.count(c)) {
      ban(c);
      need_check_diags = true;
    }
    if (!banned.count(d)) {
      ban(d);
      need_check_diags = true;
    }
    if (need_check_diags) {
      // 8 diags to check
      for (int dx = -1; dx <= 2; ++dx) {
        for (int dy = -1; dy <= 2; ++dy) {
          auto pt_check = mp(p.f + dx, p.s + dy);
          if (added.count(pt_check)) {
            to_check_diags.insert(pt_check);
          }
        }
      }
    }
  };

  auto find_range_d1 = [&](pii p) {
    int d1 = p.f - p.s + MAXD;
    auto range_d1 = ranges_d1[d1].upper_bound({p.f, inf, false});
    assert(range_d1 != ranges_d1[d1].begin());
    range_d1--;
    assert(get<0>(*range_d1) <= p.f && get<1>(*range_d1) >= p.f);
    return range_d1;
  };

  auto find_range_d2 = [&](pii p) {
    int d2 = p.f + p.s;
    auto range_d2 = ranges_d2[d2].upper_bound({p.f, inf, false});
    assert(range_d2 != ranges_d2[d2].begin());
    range_d2--;
    assert(get<0>(*range_d2) <= p.f && get<1>(*range_d2) >= p.f);
    return range_d2;
  };

  auto ban_range =
      [&](set<tuple<int, int, bool>> &s,
          vector<tuple<int, bool, tuple<int, int, bool>, int>> &events,
          set<tuple<int, int, bool>>::iterator range, int d) {
        auto val = *range;
        assert(get<2>(val) == false);
        events.pb({cur_time, false, val, d});
        s.erase(range); // same as val?
        get<2>(val) = true;
        banned_ranges_sum += get<1>(val) - get<0>(val);
        events.pb({cur_time, true, val, d});
        s.insert(val);
      };

  auto check_banned_after_range =
      [&](set<tuple<int, int, bool>>::iterator range, int dx, int dy,
          int d) -> bool {
    int xl = get<0>(*range);
    int xr = get<1>(*range);
    // dy unused?

    int x_check, y_check;
    if (dx > 0) {
      // checking right (xr)
      x_check = xr;
    } else {
      x_check = xl - 1;
    }

    if (dx == dy) {
      // d1 x-y+MAXD=d
      y_check = x_check - d + MAXD;
    } else {
      // d2 x+y=d
      y_check = d - x_check;
    }

    return banned.count(mp(x_check, y_check));
  };

  // Expects to be on ranges, to be not banned, can be already on banned range
  auto check_ban_diags = [&](pii p) {
    int d1 = p.f - p.s + MAXD;
    int d2 = p.f + p.s;

    auto range_d1 = find_range_d1(p);
    if (get<2>(*range_d1)) {
      // banned range
      return;
    }
    auto range_d2 = find_range_d2(p);
    if (get<2>(*range_d2)) {
      // banned range
      return;
    }

    // Need to check both sides, but only one will be banned

    pii left = mp(p.f, p.s - 1);
    pii right = mp(p.f, p.s + 1);
    pii top = mp(p.f - 1, p.s);
    pii bot = mp(p.f + 1, p.s);

    // if (dbg) {
    //   cout << "check_ban_diags " << p.f << " " << p.s << endl;
    //   cout << check_banned_after_range(range_d1, +1, +1, d1) << endl;
    //   exit(0);
    // }

    if (check_banned_after_range(range_d1, +1, +1, d1) &&
        check_banned_after_range(range_d1, -1, -1, d1)) {
      // together with us can be banned top or bot (only one, otherwise it is a
      // square)

      // checking d1+1
      if (added.count(left) && added.count(bot)) {
        bool ban_left = banned.count(left);
        bool ban_bot = banned.count(bot);
        optional<set<tuple<int, int, bool>>::iterator> pair_range_to_check =
            nullopt;
        bool to_ban = false;
        if (!ban_left) {
          pair_range_to_check = find_range_d1(left);
        } else if (!ban_bot) {
          pair_range_to_check = find_range_d1(bot);
        }
        if (pair_range_to_check.has_value()) {
          if (check_banned_after_range(*pair_range_to_check, +1, +1, d1 + 1) &&
              check_banned_after_range(*pair_range_to_check, -1, -1, d1 + 1)) {
            to_ban = true;
          }
        } else {
          to_ban = true; // both already banned
        }
        if (to_ban) {
          ban_range(ranges_d1[d1], events_rd1, range_d1, d1);
          if (pair_range_to_check.has_value()) {
            ban_range(ranges_d1[d1 + 1], events_rd1, *pair_range_to_check,
                      d1 + 1);
          }
          return;
        }
      }

      // checking d1-1
      if (added.count(right) && added.count(top)) {
        bool ban_right = banned.count(right);
        bool ban_top = banned.count(top);
        optional<set<tuple<int, int, bool>>::iterator> pair_range_to_check =
            nullopt;


        bool to_ban = false;
        if (!ban_right) {
          pair_range_to_check = find_range_d1(right);
        } else if (!ban_top) {
          pair_range_to_check = find_range_d1(top);
        }
        if (pair_range_to_check.has_value()) {
          if (check_banned_after_range(*pair_range_to_check, +1, +1, d1 - 1) &&
              check_banned_after_range(*pair_range_to_check, -1, -1, d1 - 1)) {
            to_ban = true;
          }
        } else {
          to_ban = true; // both already banned
        }

        // if (dbg) {
        //   cout << "to ban " << to_ban << endl;
        //   cout << "pair range to check " << pair_range_to_check.has_value()
        //        << endl;
        //   if (pair_range_to_check.has_value()) {
        //     cout << "pair range " << get<0>(**pair_range_to_check) << " "
        //          << get<1>(**pair_range_to_check) << endl;
        //   }
        // }

        if (to_ban) {
          ban_range(ranges_d1[d1], events_rd1, range_d1, d1);
          if (pair_range_to_check.has_value()) {
            ban_range(ranges_d1[d1 - 1], events_rd1, *pair_range_to_check,
                      d1 - 1);
          }
          return;
        }
      }
    }
    if (check_banned_after_range(range_d2, +1, -1, d2) &&
        check_banned_after_range(range_d2, -1, +1, d2)) {
      // solving d2 (x+y=d)

      // checking d2+1
      if (added.count(right) && added.count(bot)) {
        bool ban_right = banned.count(right);
        bool ban_bot = banned.count(bot);
        optional<set<tuple<int, int, bool>>::iterator> pair_range_to_check =
            nullopt;
        bool to_ban = false;
        if (!ban_right) {
          pair_range_to_check = find_range_d2(right);
        } else if (!ban_bot) {
          pair_range_to_check = find_range_d2(bot);
        }
        if (pair_range_to_check.has_value()) {
          if (check_banned_after_range(*pair_range_to_check, +1, -1, d2 + 1) &&
              check_banned_after_range(*pair_range_to_check, -1, +1, d2 + 1)) {
            to_ban = true;
          }
        } else {
          to_ban = true; // both already banned
        }

        if (to_ban) {
          ban_range(ranges_d2[d2], events_rd2, range_d2, d2);
          if (pair_range_to_check.has_value()) {
            ban_range(ranges_d2[d2 + 1], events_rd2, *pair_range_to_check,
                      d2 + 1);
          }
          return;
        }
      }

      // checking d2-1
      if (added.count(left) && added.count(top)) {
        bool ban_left = banned.count(left);
        bool ban_top = banned.count(top);
        optional<set<tuple<int, int, bool>>::iterator> pair_range_to_check =
            nullopt;
        bool to_ban = false;
        if (!ban_left) {
          pair_range_to_check = find_range_d2(left);
        } else if (!ban_top) {
          pair_range_to_check = find_range_d2(top);
        }
        if (pair_range_to_check.has_value()) {
          if (check_banned_after_range(*pair_range_to_check, +1, -1, d2 - 1) &&
              check_banned_after_range(*pair_range_to_check, -1, +1, d2 - 1)) {
            to_ban = true;
          }
        } else {
          to_ban = true; // both already banned
        }


        if (to_ban) {
          ban_range(ranges_d2[d2], events_rd2, range_d2, d2);
          if (pair_range_to_check.has_value()) {
            ban_range(ranges_d2[d2 - 1], events_rd2, *pair_range_to_check,
                      d2 - 1);
          }
          return;
        }
      }
    }
  };

  add_to_ranges(p);

  set<pii> to_check_diags;
  to_check_diags.insert(p);

  if (in_square(added, p.f, p.s)) {
    // Coloring a square
    for (int dx = -1; dx <= 0; dx++) {
      for (int dy = -1; dy <= 0; dy++) {
        auto pt_neig = mp(p.f + dx, p.s + dy);
        if (has_square(added, pt_neig.f, pt_neig.s)) {
          assert(added.count(pt_neig));
          ban_the_square(pt_neig, to_check_diags);
        }
      }
    }
  }

  for (auto p_check : to_check_diags) {
    if (!banned.count(p_check)) {
      check_ban_diags(p_check);
      // if (dbg) {
      //   cout << "checking " << p_check.f << " " << p_check.s << endl;
      //   cout << "added " << added.size() << " banned " << banned.size()
      //        << " banned_ranges_sum " << banned_ranges_sum << endl;
      // }
    }
  }
}

int ans[maxn];

vector<pii> pts_seg_tree[4 * maxn];

void add_on_range(int v, int tl, int tr, int l, int r, pii p) {
  if (l > r) {
    return;
  }
  if (l == tl && r == tr) {
    pts_seg_tree[v].push_back(p);
    return;
  }
  int tm = (tl + tr) / 2;
  add_on_range(v * 2, tl, tm, l, min(r, tm), p);
  add_on_range(v * 2 + 1, tm + 1, tr, max(l, tm + 1), r, p);
}

void revert(int cur_time, int banned_ranges_sum_before) {
  banned_ranges_sum = banned_ranges_sum_before;
  while (events_add.size() > 0) {
    auto [time, p] = events_add.back();
    if (time != cur_time) {
      break;
    }
    events_add.pop_back();
    added.erase(p);
  }
  while (events_ban.size() > 0) {
    auto [time, p] = events_ban.back();
    if (time != cur_time) {
      break;
    }
    events_ban.pop_back();
    banned.erase(p);
  }
  while (events_rd1.size() > 0) {
    auto [time, insert, p, d] = events_rd1.back();
    if (time != cur_time) {
      break;
    }
    events_rd1.pop_back();
    if (insert) {
      ranges_d1[d].erase(p);
    } else {
      ranges_d1[d].insert(p);
    }
  }
  while (events_rd2.size() > 0) {
    auto [time, insert, p, d] = events_rd2.back();
    if (time != cur_time) {
      break;
    }
    events_rd2.pop_back();
    if (insert) {
      ranges_d2[d].erase(p);
    } else {
      ranges_d2[d].insert(p);
    }
  }
}

void process(int v, int tl, int tr) {
  int banned_ranges_sum_before = banned_ranges_sum;
  for (auto p : pts_seg_tree[v]) {
    add_point(p, v);
  }
  if (tl == tr) {
    ans[tl] = added.size() - banned.size() - banned_ranges_sum;
  } else {
    int tm = (tl + tr) / 2;
    process(v * 2, tl, tm);
    process(v * 2 + 1, tm + 1, tr);
  }
  revert(v, banned_ranges_sum_before);
}

int solveBruteBfsOneRun(set<pii> pts) {
  queue<pii> q;
  int old_size = pts.size();

  auto old_pts = pts;

  for (auto p : pts) {
    q.push(p);
  }

  int iters = 0;
  while (!q.empty()) {
    auto p = q.front();
    q.pop();
    ++iters;

    if (!pts.count(p)) {
      continue;
    }

    pii top = mp(p.f + 1, p.s);
    pii bot = mp(p.f - 1, p.s);
    pii left = mp(p.f, p.s - 1);
    pii right = mp(p.f, p.s + 1);
    bool can_remove = false;
    if (!pts.count(top) && !pts.count(bot)) {
      can_remove = true;
    }
    if (!pts.count(left) && !pts.count(right)) {
      can_remove = true;
    }
    if (can_remove) {
      pts.erase(p);
      if (pts.count(top)) {
        q.push(top);
      }
      if (pts.count(bot)) {
        q.push(bot);
      }
      if (pts.count(left)) {
        q.push(left);
      }
      if (pts.count(right)) {
        q.push(right);
      }
    }
  }
  assert(iters <= 5 * old_size);
  return old_size - pts.size();
}

int solveFaster(vector<pii> pts) {
  for (auto p : pts) {
    add_point(p, 0);
    // cout << "Adding " << p.f << " " << p.s << endl;
    // cout << "added " << added.size() << " banned " << banned.size()
    //      << " banned_ranges_sum " << banned_ranges_sum << endl;
  }
  int ans = added.size() - banned.size() - banned_ranges_sum;
  revert(0, 0);
  return ans;
}

// если создался квадрат -> banned всех проверить вокруг все диагонали (ranges)
// в обычной ситуации просто проверить 4 диагонали (ranges)
// в ситуации если диагонали упираются в banned ->
// переложить из ranges в banned_ranges (?? нахрена нужны banned ranges)
// banned ranges нужны чтобы дважды не учитывать banned
// обычный range никогда не пересекается с banned_ranges
// чтобы было меньше багов и проверок, при ban() вручную квадрата, удалить его
// из banned_ranges

// ответ это sum(banned_ranges) + sum(banned)

int main() {
  // files1;
  fast_io;

  // {
  //   int tests = 1000000;
  //   for (int i = 19989; i <= tests; ++i) {
  //     srand(i);

  //     int n, m;
  //     n = rand() % 100 + 5;
  //     m = rand() % 100 + 5;

  //     vector<vector<int>> field(n, vector<int>(m, 0));
  //     set<pii> pts;
  //     for (int i = 0; i < n; ++i) {
  //       for (int j = 0; j < m; ++j) {
  //         if (rand() % 7) {
  //           field[i][j] = 1;
  //           pts.insert(mp(i, j));
  //         }
  //       }
  //     }

  //     vector<pii> pts_vec(all(pts));
  //     random_shuffle(all(pts_vec));
  //     int brute = solveBruteBfsOneRun(pts);
  //     int faster = solveFaster(pts_vec);
  //     if (brute != faster) {
  //       cout << "WA" << endl;
  //       cout << brute << " " << faster << endl;

  //       cout << "Test " << i << endl;
  //       cout << n << " " << m << endl;

  //       for (int i = 0; i < n; ++i) {
  //         for (int j = 0; j < m; ++j) {
  //           cout << field[i][j] << " ";
  //         }
  //         cout << endl;
  //       }

  //       exit(0);
  //     }

  //     if (i % 100 == 0) {
  //       cout << "Tests " << i << " ok" << endl;
  //     }
  //   }
  //   cout << "Tests ok" << endl;
  //   return 0;
  // }

  {
    int n, m, k, q;
    cin >> n >> m >> k >> q;

    // q + 1 events
    vector<pii> before;
    vector<pii> queries;

    for (int i = 0; i < k; i++) {
      int x, y;
      cin >> x >> y;
      before.pb(mp(x, y));
    }

    for (int i = 0; i < q; i++) {
      int x, y;
      cin >> x >> y;
      queries.pb(mp(x, y));
    }

    // for (auto p : before) {
    //   add_point(p, 0);
    // }

    // cout << added.size() << ' ' << banned.size() << ' ' << banned_ranges_sum;
    // return 0;

    vector<pii> all_points = before;
    all_points.insert(all_points.end(), queries.begin(), queries.end());

    sort(all(all_points));
    all_points.resize(unique(all(all_points)) - all_points.begin());

    vector<int> last_added(all_points.size(), -1);
    for (auto p : before) {
      last_added[lower_bound(all(all_points), p) - all_points.begin()] = 0;
    }

    for (int i = 1; i <= q; ++i) {
      auto p = queries[i - 1];
      int id = lower_bound(all(all_points), p) - all_points.begin();
      if (last_added[id] == -1) {
        last_added[id] = i;
      } else {
        add_on_range(1, 0, q, last_added[id], i - 1, p);
        last_added[id] = -1;
      }
    }

    for (int i = 0; i < all_points.size(); ++i) {
      if (last_added[i] != -1) {
        add_on_range(1, 0, q, last_added[i], q, all_points[i]);
      }
    }

    process(1, 0, q);
    // cout << ans[0] << ' ' << ans[1] << endl;
    // exit(0);
    for (int i = 0; i <= q; ++i) {
      cout << ans[i] << "\n";
    }
  }

  // {
  //   int n = 2e5, m = 2e5;
  //   int k = 75000;

  //   srand(228);

  //   set<pii> pts;
  //   pts.insert(mp(0, 0));
  //   pts.insert(mp(0, 1));
  //   pts.insert(mp(1, 0));
  //   pts.insert(mp(1, 1));
  //   for (int i = 0; i < k; ++i) {
  //     pts.insert(mp(1 + i, 2 + i));
  //     pts.insert(mp(2 + i, 2 + i));
  //     if (i == k - 1) {
  //       // pts.insert(mp(2 + i, 1 + i));
  //     }
  //   }
  //   cout << solveBruteBfsOneRun(pts) << endl;
  //   cout << solveFaster(pts) << endl;
  // }
  return 0;
}