#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
//#pragma GCC target("sse,sse2,sse3,ssse3,abm,mmx,tune=native")
//#pragma clang diagnostic ignored "-Wunused-const-variable"
#include<vector>
#include<iostream>
#include<stack>
#include<cmath>
#include<algorithm>
#include<set>
#include<map>
#include<string>
#include<tuple>
#include<bitset>
#include<queue>
#include<unordered_map>
#include<unordered_set>
#include<random>
#include<assert.h>
#include<ctime>
#include <cassert>
#include <thread>
#include <mutex>
#include <semaphore>
#include <chrono>
#include <hash_map>
//#define int long long
#define all(a) a.begin(), a.end()
typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
using namespace std;
ll gcd(ll i, ll j) {
	if (i < j)swap(i, j);
	if (j == 0)return i;
	else return gcd(j, i % j);
}
#ifdef _MY
ll __builtin_popcount(ll x) { return x ? (__builtin_popcount(x >> 1) + (x & 1)) : 0; }
#endif
template<typename T> inline T getint() {
	T val = 0;
	char c;

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

	do {
		val = (val * 10) + c - '0';
	} while ((c = getchar()) && (c >= '0' && c <= '9'));

	return val * (neg ? -1 : 1);
}
const ll INF = 1e7 + 100;
const int mod = 998244353, mod1 = 1000000007;
const ld eps = 1e-7, pi = acos(-1);
const int maxT = 503, maxN = 5'010, A = 311;
ll bp(ll et, ll b) {
	ll res = 1;
	for (int i = 30; i >= 0; --i) {
		res = (res * res) % mod;
		if ((b & (1 << i)) != 0)res = (res * et) % mod;
	}
	return res;
}
mt19937 mt_rand(time(0));
void panic() {
	cout << "No\n";
	exit(0);
}
ld get_time() {
	ll tmr = clock();
	return (ld)tmr / CLOCKS_PER_SEC;
}
int pl(int a, int b) {
	a += b;
	if (a >= mod)
		a -= mod;
	return a;
}
int mul(ll a, ll b) {
	return a * b % mod;
}
const ll sz = 1 << 19;
ll t[sz * 2];
ll mx_ans = 0;
ll get(int ps) {
	return t[ps];
}
//stdext::hash_map<ll, int>mp;
unordered_map<ll, int>mp;
const ll BASE = 1 << 20;
const vector<ll>goo = {
	-BASE,
	BASE,
	-1,
	1,
};
ll get_code(int x, int y) {
	return (ll)x * BASE + y;
}
ll curr_ans = -1;
bool can_delete_code_init(const ll code) {
	if ((!mp.count(code + BASE) && !mp.count(code - BASE))
		|| (!mp.count(code + 1) && !mp.count(code - 1))) {
		return true;
	}
	return false;
}

int get_or_else(const ll code, const int el) {
	auto it = mp.find(code);
	if (it != mp.end()) {
		return it->second;
	}
	return el;
}
bool can_delete_code_on_iter(const ll code) {
	if ((get_or_else(code + BASE, 1) && get_or_else(code - BASE, 1))
		|| (get_or_else(code + 1, 1) && get_or_else(code - 1, 1))) {
		return true;
	}
	return false;
}
ll m_q[1 << 21];
ll m_ql = -1, m_qr = -1;
void add_to_q(ll cd) {
	m_q[m_qr++] = cd;
}
bool q_not_empty() {
	return m_qr != m_ql;
}
ll get_from_q_front() {
	return m_q[m_ql++];
}
void reset_q() {
	m_ql = m_qr = 0;
}
void run_bfs() {
	while (q_not_empty()) {
		const ll cd = get_from_q_front();
		++curr_ans;
		for (auto delCD : goo) {
			const ll ncd = cd + delCD;
			auto nit = mp.find(ncd);
			if (nit != mp.end() && nit->second == 0) {
				if (can_delete_code_on_iter(ncd)) {
					add_to_q(ncd);
					nit->second = 1;
				}
			}
		}
	}
}
void hard_recalc() {
	reset_q();
	curr_ans = 0;
	for (auto& vert : mp) {
		vert.second = 0;
		if (can_delete_code_init(vert.first)) {
			vert.second = 1;
			add_to_q(vert.first);
		}
	}
	run_bfs();
}
//google::dense_hash_map
void solve() {
	int n, m, k, q;
	cin >> n >> m >> k >> q;
	for (int i = 0; i < k; ++i) {
		int x, y;
		cin >> x >> y;
		ll code = get_code(x, y);
		auto aa = mp.emplace(code, 0);
		if (!aa.second) {
			mp.erase(aa.first);
		}
	}
	hard_recalc();
	cout << curr_ans << "\n";
	while (q--) {
		int x, y;
		//x = rand() % 100 + 1 + 1e5, y = rand() % 100 + 1 + 1e5;
		cin >> x >> y;
		const ll code = get_code(x, y);
		auto aa = mp.emplace(code, 0);
		if (aa.second) {
			//insert code
			if (can_delete_code_init(code)) {
				++curr_ans;
				aa.first->second = 1;
			}
			else {
				vector<ll>nqq;
				reset_q();
				add_to_q(code);
				while (q_not_empty()) {
					const ll cd = get_from_q_front();
					nqq.push_back(cd);
					for (auto delCD : goo) {
						const ll ncd = cd + delCD;
						auto nit = mp.find(ncd);
						if (nit != mp.end() && nit->second == 1
							&& !can_delete_code_init(ncd)
							) {
							add_to_q(ncd);
							nit->second = 0;
							--curr_ans;
						}
					}
				}
				if (!nqq.empty()) {
					reset_q();
					for (auto x : nqq) {
						if (can_delete_code_on_iter(x)) {
							add_to_q(x);
							auto it = mp.find(x);
							it->second = 1;
						}
					}
					run_bfs();
				}
			}
		}
		else {
			//delete code
			if (aa.first->second) {
				--curr_ans;
				mp.erase(aa.first);
			}
			else {
				mp.erase(aa.first);
				//hard_recalc();
				reset_q();
				for (auto dcd : goo) {
					const ll ncd = code + dcd;
					auto nit = mp.find(ncd);
					if (nit != mp.end() && nit->second == 0) {
						if (can_delete_code_on_iter(ncd)) {
							add_to_q(ncd);
							nit->second = 1;
						}
					}
				}
				run_bfs();
			}
		}
//#ifdef _DEBUG
		//ll cmm_ans = curr_ans;
		//hard_recalc();
		//assert(cmm_ans == curr_ans);
//#endif // _DEBUG

		cout << curr_ans << "\n";
	}
}
int32_t main()
{
	ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
	cout.precision(14);
#ifdef _MY
	freopen("input.txt", "r", stdin);
	freopen("output.txt", "w", stdout);


	/*time_t start, end;
	time(&start);*/
#else
	//freopen("epic.in", "r", stdin); freopen("epic.out", "w", stdout);
#endif
	//init();
	int t = 1;
	//cin >> t;
	while (t--) {
		solve();
	}
#ifdef _MY
	cout << "Time taken is : " << fixed << get_time() << " sec " << "\n";
#endif
	return 0;
}