// clang-format off
#include <bits/stdc++.h>

using namespace std;

#define ALL(x) (x).begin(), (x).end()

template<class C> void mini(C &a5, C b5) { a5 = min(a5, b5); }
template<class C> void maxi(C &a5, C b5) { a5 = max(a5, b5); }

#ifdef LOCAL
const bool debug = true;
#else
const bool debug = false;
#define cerr if (true) {} else cout
#endif
// clang-format on

#define int long long
#define double long double

const int INF = 1e18;
const int mod = 1e9 + 7;
const int base = 1 << 19;

struct Node {
    Node *left, *right;
    int prefix, suffix; // INF -> None
    int res;
    bool all_connected;

    Node()
        : left(nullptr), right(nullptr), prefix(INF), suffix(INF), res(0),
          all_connected(false) {}

    void touch() {
        if (left == nullptr) {
            left = new Node();
            right = new Node();
        }
    }

    void update(int len) {
        prefix = left->prefix;
        if (left->all_connected)
            mini(prefix, len / 2 + right->prefix);
        suffix = right->suffix;
        if (right->all_connected)
            mini(suffix, left->suffix + len / 2);

        res = left->res + right->res;
        if (left->suffix < INF && right->prefix < INF)
            res += left->suffix + right->prefix;

        all_connected = left->all_connected && right->all_connected;
    }

    void set(int pos, bool val, bool from_squeare, int pocz = 0,
             int kon = base) {
        if (kon - pocz == 1) {
            if (val) {
                prefix = suffix = (!from_squeare) * INF;
                res = from_squeare;
                all_connected = true;
            } else {
                prefix = suffix = INF;
                res = 0;
                all_connected = false;
            }
            return;
        }

        int sr = (pocz + kon) / 2;
        touch();
        if (pos < sr)
            left->set(pos, val, from_squeare, pocz, sr);
        else
            right->set(pos, val, from_squeare, sr, kon);
        update(kon - pocz);
    }

    void print() {
        cout << "res=" << res << " prefix=" << prefix << " suffix=" << suffix
             << " all_connected=" << all_connected << endl;
    }
};

Node _diag1[2 * base], _diag2[2 * base];
Node *diag1 = &_diag1[base];
Node *diag2 = &_diag2[0];

map<pair<int, int>, bool> mapa;
set<pair<int, int>> squares;

int result;

void update_square(int x, int y) {
    if (!mapa[{x, y}]) {
        squares.erase({x, y});
        return;
    }

    bool from_square = false;
    for (int dx = -1; dx <= 1; dx += 2) {
        for (int dy = -1; dy <= 1; dy += 2) {
            int x2 = x + dx, y2 = y + dy;
            if (mapa[{x2, y}] & mapa[{x, y2}] & mapa[{x2, y2}])
                from_square = true;
        }
    }

    vector<pair<Node *, int>> iter = {{&diag1[x - y], 2 * x},
                                      {&diag1[x - y - 1], 2 * x - 1},
                                      {&diag2[x + y], 2 * x},
                                      {&diag2[x + y + 1], 2 * x + 1}};
    for (auto [node, pos] : iter) {
        result -= node->res;
        node->set(pos, true, from_square);
        result += node->res;
    }

    if (from_square)
        squares.insert({x, y});
    else
        squares.erase({x, y});
}

int update(int x, int y) {
    bool new_val = (mapa[{x, y}] ^= 1);

    vector<pair<Node *, int>> iter = {{&diag1[x - y], 2 * x},
                                      {&diag1[x - y - 1], 2 * x - 1},
                                      {&diag2[x + y], 2 * x},
                                      {&diag2[x + y + 1], 2 * x + 1}};
    for (auto [node, pos] : iter) {
        result -= node->res;
        node->set(pos, new_val, false);
        result += node->res;
    }

    for (int dx = -1; dx <= 1; dx++)
        for (int dy = -1; dy <= 1; dy++)
            update_square(x + dx, y + dy);

    return 2 * new_val - 1;
}

void print_debug() {
    for (int i = -100; i <= 100; i++) {
        if (diag1[i].res) {
            cout << "diag1[" << i << "]:\t";
            diag1[i].print();
        }
    }
    for (int i = 0; i <= 100; i++) {
        if (diag2[i].res) {
            cout << "diag2[" << i << "]:\t";
            diag2[i].print();
        }
    }
}

void print_mapa(int n, int m) {
    char tab[n + 1][m + 1];
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= m; j++)
            tab[i][j] = '.';
    for (auto [pos, val] : mapa)
        if (val)
            tab[pos.first][pos.second] = 'x';
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= m; j++)
            cout << tab[i][j];
        cout << endl;
    }
}

void dummy() {
    int k = 2 * 75000;
    for (int i = 200000;; i--) {
        for (int j = 200000; j > 200000 - 1000; j++) {
            update(i, j);
            cout << result << "\n";
            if (--k == 0)
                return;
        }
    }
}

int32_t main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0);

    int count = 0;
    int n, m, k, q;
    cin >> n >> m >> k >> q;
    if (n == -1) {
        dummy();
        return 0;
    }

    for (int i = 0; i < k; i++) {
        int x, y;
        cin >> x >> y;
        count += update(x, y);
    }

    cout << count - result + 3 * (int)squares.size() << "\n";
    while (q--) {
        int x, y;
        cin >> x >> y;
        count += update(x, y);
        cout << count - result + 3 * (int)squares.size() << "\n";
    }

    // cout << result << " " << squares.size() << endl;
    // print_mapa(n, m);
    // print_debug();

    return 0;
} /*

 */