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

#define rep(i, a, b) for (int i = (a); i < (b); i++)
#define all(x) begin(x), end(x)
#define sz(x) int((x).size())
using ll = long long;
using pii = pair<int, int>;
using vi = vector<int>;

#ifdef LOCAL
auto operator<<(auto& o, auto x) -> decltype(x.first, o);
auto operator<<(auto& o, auto x) -> decltype(x.end(), o) {
  o << "{";
  for (int i = 0; auto y : x) o << ", " + !i++ * 2 << y;
  return o << "}"; }
auto operator<<(auto& o, auto x) -> decltype(x.first, o) {
  return o << "(" << x.first << ", " << x.second << ")"; }
void __print(auto... x) { ((cerr << x << " "), ...) << endl; }
#define debug(x...) __print("[" #x "]:", x)
#else
#define debug(...) 2137
#endif

const int inf = 1e9;
int ans = 0;

struct seg {
  int diag, l, r;
  auto operator<=>(const seg&) const = default;
};
ostream& operator<<(ostream& o, const seg& a) {
  return o << "(" << a.diag << ", " << a.l << ", " << a.r << ")";
}

struct DS {
  int n, m;
  set<seg> st;
  set<pair<int, int>> grid;
  DS(int n = 0, int m = 0) : n(n), m(m) {}
  void insert(int i, int j) {
    int my_d = i + j;
    for(int d : array<int, 2>{my_d, my_d + 1}) {
      if(d < 0 || d >= n + m) continue;
      int ind = get_ind(d, {i, j});
      pair<int, int> prv = at(d, ind - 1);
      pair<int, int> nxt = at(d, ind + 1);
      int lt = ind, rt = ind;
      if(grid.contains(prv)) {
        auto it = st.lower_bound({d, ind, ind});
        if(it == st.begin()) {
          lt = ind - 1;
        } else {
          it--;
          if(it->diag == d && it->r == ind - 1) {
            lt = it->l;
            pair<int, int> other = {i + (d == my_d), j - (d != my_d)};
            if(grid.contains(other)) {
              if(ind - lt - 4 > 0) {
                if(grid.contains(at(d, lt - 1))) {
                  ans -= ind - lt - 4;
                }
              }
              lt = ind - 1;
            } else {
              st.erase(it);
            }
          } else {
            lt = ind - 1;
          }
        }
      }
      if(grid.contains(nxt)) {
        auto it = st.upper_bound({d, ind, ind});
        if(it != st.end() && it->diag == d && it->l == ind + 1) {
          rt = it->r;
          pair<int, int> other = {i - (d != my_d), j + (d == my_d)};
          if(grid.contains(other)) {
            if(rt - ind - 4 > 0) {
              if(grid.contains(at(d, rt + 1))) {
                ans -= rt - ind - 4;
              }
            }
            rt = ind + 1;
          } else {
            st.erase(it);
          }
        } else {
          rt = ind + 1;
        }
      }
      if(lt < ind && ind < rt) {
        pair<int, int> other = {i + 1, j + 1};
        if(d == my_d) {
          other.first -= 2;
          other.second -= 2;
        }
        if(!grid.contains(other)) {
          ind = rt;
        }
      }
      if(lt < ind) {
        st.insert({d, lt, ind});
        if(ind - lt - 3 > 0) {
          if(grid.contains(at(d, lt - 1)) && grid.contains(at(d, ind + 1))) {
            ans -= ind - lt - 3;
          }
        }
      }
      if(ind < rt) {
        st.insert({d, ind, rt});
        if(rt - ind - 3 > 0) {
          if(grid.contains(at(d, ind - 1)) && grid.contains(at(d, rt + 1))) {
            ans -= rt - ind - 3;
          }
        }
      }
    }
    for(int d : array<int, 2>{my_d - 1, my_d + 2}) {
      if(d < 0 || d >= n + m) continue;
      pair<int, int> other = {i + 1, j + 1};
      if(d == my_d - 1) {
        other.first -= 2;
        other.second -= 2;
      }
      int ind = get_ind(d, other);
      auto it = st.lower_bound({d, ind, ind});
      if(it != st.begin()) {
        it--;
        if(it->diag == d && it->r > ind) {
          int lt = it->l;
          int rt = it->r;
          st.erase(it);
          bool block_lt = grid.contains(at(d, lt - 1));
          bool block_rt = grid.contains(at(d, rt + 1));
          if(block_lt && block_rt) {
            ans += max(rt - lt - 3, 0);
          }
          st.insert({d, lt, ind});
          if(block_lt) {
            ans -= max(ind - lt - 3, 0);
          }
          st.insert({d, ind, rt});
          if(block_rt) {
            ans -= max(rt - ind - 3, 0);
          }
        }
      }
    }
    grid.insert({i, j});
  }
  void erase(int i, int j) {
    int my_d = i + j;
    for(int d : array<int, 2>{my_d, my_d + 1}) {
      if(d < 0 || d >= n + m) continue;
      int ind = get_ind(d, {i, j});
      pair<int, int> prv = at(d, ind - 1);
      pair<int, int> nxt = at(d, ind + 1);
      int lt = ind, rt = ind;
      if(grid.contains(prv)) {
        auto it = st.lower_bound({d, ind - 1, ind - 1});
        if(it != st.begin()) {
          it--;
          if(it->diag == d && it->r == ind - 1) {
            lt = it->l;
            if(ind - lt - 4 > 0) {
              if(grid.contains(at(d, lt - 1))) {
                ans += ind - lt - 4;
              }
            }
          }
        }
      }
      if(grid.contains(nxt)) {
        auto it = st.lower_bound({d, ind + 1, ind + 1});
        if(it != st.end() && it->diag == d && it->l == ind + 1) {
          rt = it->r;
          if(rt - ind - 4 > 0) {
            if(grid.contains(at(d, rt + 1))) {
              ans += rt - ind - 4;
            }
          }
        }
      }
      lt = ind, rt = ind;
      bool two = 0;
      auto it = st.lower_bound({d, ind, ind});
      if(it != st.end()) {
        if(it->diag == d && it->l == ind) {
          rt = it->r;
          two = 1;
        }
      }
      if(it != st.begin()) {
        it--;
        if(it->diag == d && it->r >= ind) {
          lt = it->l;
          if(!two) rt = it->r;
        }
      }
      if(lt < ind - 1) st.insert({d, lt, ind - 1});
      if(ind + 1 < rt) st.insert({d, ind + 1, rt});
      if(!two) ind = rt;
      st.erase({d, lt, ind});
      if(ind - lt - 3 > 0) {
        if(grid.contains(at(d, lt - 1)) && grid.contains(at(d, ind + 1))) {
          ans += ind - lt - 3;
        }
      }
      st.erase({d, ind, rt});
      if(rt - ind - 3 > 0) {
        if(grid.contains(at(d, ind - 1)) && grid.contains(at(d, rt + 1))) {
          ans += rt - ind - 3;
        }
      }
    }
    for(int d : array<int, 2>{my_d - 1, my_d + 2}) {
      if(d < 0 || d >= n + m) continue;
      pair<int, int> other = {i + 1, j + 1};
      if(d == my_d - 1) {
        other.first -= 2;
        other.second -= 2;
      }
      int ind = get_ind(d, other);
      auto it = st.lower_bound({d, ind, ind});
      if(it != st.end() && it->diag == d && it->l == ind) {
        int rt = it->r;
        if(it != st.begin()) {
          auto it2 = it;
          it--;
          if(it->diag == d && it->r == ind) {
            int lt = it->l;
            st.erase(it);
            st.erase(it2);
            st.insert({d, lt, rt});
            bool block_lt = grid.contains(at(d, lt - 1));
            bool block_rt = grid.contains(at(d, rt + 1));
            if(block_lt) {
              ans += max(ind - lt - 3, 0);
            }
            if(block_rt) {
              ans += max(rt - ind - 3, 0);
            }
            if(block_lt && block_rt) {
              ans -= max(rt - lt - 3, 0);
            }
          }
        }
      }
    }
    grid.erase({i, j});
  }
  inline pair<int, int> at(int d, int ind) {
    if(ind == -1) return {d, -1};
    int y = ind / 2;
    int x = d - y;
    if(ind & 1) x--;
    return {x, y};
  }
  inline int get_ind(int d, pair<int, int> p) {
    int ind = 2 * p.second;
    if((d & 1) != ((p.first + p.second) & 1)) ind++;
    return ind;
  }
};
DS lt, rt;

map<pair<int, int>, int> st_sq;
int n, m;
void add(int x, int y) {
  ans++;
  lt.insert(x, y);
  rt.insert(x, m - 1 - y);
  array<array<int, 3>, 3> a;
  a[1][1] = 1;
  for(int i = -1; i <= 1; i++) {
    for(int j = -1; j <= 1; j++) {
      if(!i && !j) continue;
      a[i + 1][j + 1] = lt.grid.contains({x + i, y + j});
    }
  }
  for(int i = 0; i < 2; i++) {
    for(int j = 0; j < 2; j++) {
      int s = 0;
      for(int c = 0; c < 2; c++) {
        for(int d = 0; d < 2; d++) {
          s += a[i + c][j + d];
        }
      }
      if(s == 4) {
        for(int c = 0; c < 2; c++) {
          for(int d = 0; d < 2; d++) {
            pair<int, int> p = {x - 1 + i + c, y - 1 + j + d};
            if(!st_sq[p]) ans--;
            st_sq[p]++;
          }
        }
      }
    }
  }
}

void rem(int x, int y) {
  ans--;
  lt.erase(x, y);
  rt.erase(x, m - 1 - y);
  array<array<int, 3>, 3> a;
  a[1][1] = 1;
  for(int i = -1; i <= 1; i++) {
    for(int j = -1; j <= 1; j++) {
      if(!i && !j) continue;
      a[i + 1][j + 1] = lt.grid.contains({x + i, y + j});
    }
  }
  for(int i = 0; i < 2; i++) {
    for(int j = 0; j < 2; j++) {
      int s = 0;
      for(int c = 0; c < 2; c++) {
        for(int d = 0; d < 2; d++) {
          s += a[i + c][j + d];
        }
      }
      if(s == 4) {
        for(int c = 0; c < 2; c++) {
          for(int d = 0; d < 2; d++) {
            pair<int, int> p = {x - 1 + i + c, y - 1 + j + d};
            st_sq[p]--;
            if(!st_sq[p]) {
              st_sq.erase(p);
              ans++;
            }
          }
        }
      }
    }
  }
}

int main() {
  cin.tie(0)->sync_with_stdio(0);

  int k, q;
  cin >> n >> m >> k >> q;
  set<pair<int, int>> st;
  lt = DS(n, m);
  rt = DS(n, m);
  for(int i = 0; i < k; i++) {
    int x, y;
    cin >> x >> y;
    x--;
    y--;
    st.insert({x, y});
    add(x, y);
  }
  cout << ans << '\n';
  for(int i = 0; i < q; i++) {
    int x, y;
    cin >> x >> y;
    x--;
    y--;
    if(st.contains({x, y})) {
      st.erase({x, y});
      rem(x, y);
    } else {
      st.insert({x, y});
      add(x, y);
    }
    cout << ans << '\n';
  }
}