#ifndef TS_DEBUG
#define NDEBUG
#endif

#ifdef _WIN32
#include <io.h>
#include <fcntl.h>
#endif

#include <algorithm>
#include <assert.h>
#include <iostream>
#include <stdint.h>

typedef int64_t slong;
typedef uint32_t uint;

typedef struct pole {
    struct pole *HashNext;
    struct pole *QueueNext;
    struct pole *Gora;   // y-1
    struct pole *Dol;    // y+1
    struct pole *Lewo;   // x-1
    struct pole *Prawo;  // x+1
    int X;
    int Y;
    int Klocek;
} pole_t;

const int KlocekMax = INT32_MAX;

const int MaxK = 75000;
const int MaxQ = 75000;
const int MaxPol = MaxK + MaxQ;

const int HashSize = 524287;  // 7th Mersenne prime ?

struct plansza {
    pole_t Pola[MaxPol];
    pole_t *HashTable[HashSize];
    int Cnt;
    int Kolizje;
    int Zdejmowalne;
} Plansza = { 0 };


int N;
int M;
int K;
int Q;

int plansza_hash(int X, int Y)
{
    slong a = (slong) X + (slong) 21701 * (slong) Y;    
    return (int)(a % HashSize);
}

pole_t* plansza_znajdz_x(int X, int Y, int Hash)
{
    assert(0 <= Hash);
    assert(Hash < HashSize);
    pole_t *Pole = Plansza.HashTable[Hash];
    while (Pole && (Pole->X != X || Pole->Y != Y)) {
        Pole = Pole->HashNext;
    }
    return Pole;
}

pole_t* plansza_znajdz(int X, int Y)
{
    int Hash = plansza_hash(X, Y);
    return plansza_znajdz_x(X, Y, Hash);
}

pole_t* plansza_znajdz_lub_dodaj(int X, int Y)
{
    int Hash = plansza_hash(X, Y);
    pole_t *Pole = plansza_znajdz_x(X, Y, Hash);
    if (Pole) {
        return Pole;
    }

    Pole = &Plansza.Pola[Plansza.Cnt];
    Plansza.Cnt++;
    if (Plansza.HashTable[Hash]) {
        Plansza.Kolizje++;
    }
    Pole->HashNext = Plansza.HashTable[Hash];
    Plansza.HashTable[Hash] = Pole;
    Pole->QueueNext = nullptr;
    Pole->Gora = plansza_znajdz(X, Y-1);
    if (Pole->Gora) { Pole->Gora->Dol = Pole; }
    Pole->Dol = plansza_znajdz(X, Y+1);
    if (Pole->Dol) { Pole->Dol->Gora = Pole; }
    Pole->Lewo = plansza_znajdz(X-1, Y);
    if (Pole->Lewo) { Pole->Lewo->Prawo = Pole; }
    Pole->Prawo = plansza_znajdz(X+1, Y);
    if (Pole->Prawo) { Pole->Prawo->Lewo = Pole; }
    Pole->X = X;
    Pole->Y = Y;
    Pole->Klocek = 0;
    return Pole;
}

void przelicz_wszystko()
{
    pole_t *Queue = nullptr;
    pole_t *Queue2 = nullptr;
    Plansza.Zdejmowalne = 0;
    for (int i = 0; i < Plansza.Cnt; i++) {
        auto Pole = &Plansza.Pola[i];
        if (Pole->Klocek) {
            Pole->Klocek = KlocekMax;
            Pole->QueueNext = Queue;
            Queue = Pole;
        }
    }

    int Poziom = 0;
    int ZdejmowalneNaPoziom;
    do {        
        Poziom++;
        ZdejmowalneNaPoziom = 0;
        while (Queue) {
            auto Pole = Queue;
            Queue = Pole->QueueNext;
            Pole->QueueNext = nullptr;
            assert(Pole->Klocek == KlocekMax);
            bool ZdejmowalnyGD = (!Pole->Gora || Pole->Gora->Klocek < Poziom) && 
                                (!Pole->Dol  || Pole->Dol->Klocek < Poziom);
            bool ZdejmowalnyLP = (!Pole->Lewo  || Pole->Lewo->Klocek < Poziom) && 
                                (!Pole->Prawo || Pole->Prawo->Klocek < Poziom);
            if (ZdejmowalnyGD || ZdejmowalnyLP) {
                Pole->Klocek = Poziom;
                ZdejmowalneNaPoziom++;
            } else {
                Pole->QueueNext = Queue2;
                Queue2 = Pole;
            }
        }
        Plansza.Zdejmowalne += ZdejmowalneNaPoziom;
        Queue = Queue2;
        Queue2 = nullptr;
    } while (ZdejmowalneNaPoziom != 0);

    assert(!Queue2);
    while (Queue) {
        auto Pole = Queue;
        Queue = Pole->QueueNext;
        Pole->QueueNext = nullptr;
    }

    for (int i = 0; i < Plansza.Cnt; i++) {
        assert(Plansza.Pola[i].QueueNext == nullptr);
    }
}

void enqueue_jesli_zdejmowalny_klocek(pole_t **Queue, pole_t *Pole) {
    if (Pole && Pole->Klocek && Pole->Klocek != KlocekMax) {
        Pole->Klocek = KlocekMax;
        Pole->QueueNext = *Queue;
        *Queue = Pole;
        Plansza.Zdejmowalne--;
    }
}

void dodaj_klocek_i_przelicz(pole_t *NowePole)
{
    NowePole->Klocek = KlocekMax;
    pole_t *Queue = NowePole;
    pole_t *Queue2 = nullptr;

    while (Queue) {
        pole_t *Pole = Queue;
        Queue = Pole->QueueNext;
        Pole->QueueNext = nullptr;

        enqueue_jesli_zdejmowalny_klocek(&Queue, Pole->Gora);
        enqueue_jesli_zdejmowalny_klocek(&Queue, Pole->Dol);
        enqueue_jesli_zdejmowalny_klocek(&Queue, Pole->Lewo);
        enqueue_jesli_zdejmowalny_klocek(&Queue, Pole->Prawo);

        Pole->QueueNext = Queue2;
        Queue2 = Pole;
    }

    Queue = Queue2;
    Queue2 = nullptr;

    int Poziom = 0;
    int ZdejmowalneNaPoziom;
    do {
        Poziom++;
        ZdejmowalneNaPoziom = 0;
        while (Queue) {
            auto Pole = Queue;
            Queue = Pole->QueueNext;
            Pole->QueueNext = nullptr;
            assert(Pole->Klocek == KlocekMax);
            bool ZdejmowalnyGD = (!Pole->Gora || Pole->Gora->Klocek < Poziom) && 
                                (!Pole->Dol  || Pole->Dol->Klocek < Poziom);
            bool ZdejmowalnyLP = (!Pole->Lewo  || Pole->Lewo->Klocek < Poziom) && 
                                (!Pole->Prawo || Pole->Prawo->Klocek < Poziom);
            if (ZdejmowalnyGD || ZdejmowalnyLP) {
                Pole->Klocek = Poziom;
                ZdejmowalneNaPoziom++;
            } else {
                Pole->QueueNext = Queue2;
                Queue2 = Pole;
            }
        }
        Plansza.Zdejmowalne += ZdejmowalneNaPoziom;
        Queue = Queue2;
        Queue2 = nullptr;
    } while (ZdejmowalneNaPoziom != 0);

    assert(!Queue2);
    while (Queue) {
        auto Pole = Queue;
        Queue = Pole->QueueNext;
        Pole->QueueNext = nullptr;
    }
}


int main()
{
    std::ios_base::sync_with_stdio(false);
    std::cin.tie(NULL);

#ifdef _WIN32
    _setmode( _fileno( stdout ),  _O_BINARY );
#endif

    std::cin >> N >> M >> K >> Q;
    for (int i = 0; i < K; i++) {
        int X, Y;
        std::cin >> X >> Y;
        auto Pole = plansza_znajdz_lub_dodaj(X, Y);
        assert(Pole->Klocek == 0);
        Pole->Klocek = KlocekMax;
    }

    przelicz_wszystko();
    std::cout << Plansza.Zdejmowalne << '\n';

    for (int i = 0; i < Q; i++) {
        int X, Y;
        std::cin >> X >> Y;
        auto Pole = plansza_znajdz_lub_dodaj(X, Y);
        if (Pole->Klocek) {
            Pole->Klocek = 0;
            przelicz_wszystko();
        } else {
            dodaj_klocek_i_przelicz(Pole);
        }
        std::cout << Plansza.Zdejmowalne << '\n';
    }

    std::cout.flush();

#ifdef TS_DEBUG
    if (Plansza.Kolizje) {
        std::cerr << "Liczba kolizji: " << Plansza.Kolizje << '/' << Plansza.Cnt << std::endl;
    }
#endif

    return 0;
}