#include<bits/stdc++.h>
using namespace std;
using LL=long long;
#define FOR(i,l,r)for(int i=(l);i<=(r);++i)
#define REP(i,n)FOR(i,0,(n)-1)
#define ssize(x)int(x.size())
#ifdef DEBUG
auto operator<<(auto&o,auto x)->decltype(x.end(),o);
auto&operator<<(auto&o,pair<auto,auto>p){return o<<"("<<p.first<<", "<<p.second<<")";}
auto&operator<<(auto&o,tuple<auto,auto,auto>t){return o<<"("<<get<0>(t)<<", "<<get<1>(t)<<", "<<get<2>(t)<<")";}
auto&operator<<(auto&o,tuple<auto,auto,auto,auto>t){return o<<"("<<get<0>(t)<<", "<<get<1>(t)<<", "<<get<2>(t)<<", "<<get<3>(t)<<")";}
auto operator<<(auto&o,auto x)->decltype(x.end(),o){o<<"{";int i=0;for(auto e:x)o<<","+!i++<<e;return o<<"}";}
#define debug(X...)cerr<<"["#X"]: ",[](auto...$){((cerr<<$<<"; "),...)<<endl;}(X)
#else
#define debug(...){}
#endif

const int INF = 1e9;

using T = pair<int, int>; // {min, cnt_min}
const T neutral = {INF, 0};
T merge(T a, T b) {
	auto [a_min, a_cnt] = a;
	auto [b_min, b_cnt] = b;
	if (a_min < b_min)
		return a;
	if (b_min < a_min)
		return b;
	return {a_min, a_cnt + b_cnt};
}
int sz = 1;
struct Node {
	T value = {0, sz};
	int lazy = 0;
	int l = -1, r = -1;
};
vector<Node> nodes;
int get_Node() {
	int ret = ssize(nodes);
	nodes.emplace_back(Node{});
	return ret;
}
struct Tree {
	int root;
	Tree() : root(get_Node()) {}
	Tree(const Tree&) = delete;
	Tree(Tree&&) = default;
	void add_children(int w, int child_size) {
		if (nodes[w].l == -1) {
			auto left = get_Node();
			auto right = get_Node();
			nodes[w].l = left;
			nodes[w].r = right;
			nodes[left].value.second = child_size;
			nodes[right].value.second = child_size;
		}
	}
	void push(int w, int child_size) {
		add_children(w, child_size);
		const int lazy = nodes[w].lazy;
		if (lazy) {
			nodes[w].lazy = 0;
			for (int x : {nodes[w].l, nodes[w].r}) {
				nodes[x].value.first += lazy;
				nodes[x].lazy += lazy;
			}
		}
	}
	T que(int w, int a, int b, int l, int r) {
		if (a > r or b < l)
			return neutral;
		if (a >= l and b <= r)
			return nodes[w].value;
		const int middle = (a + b) / 2;
		push(w, b - middle);
		return merge(
				que(nodes[w].l, a, middle, l, r),
				que(nodes[w].r, middle + 1, b, l, r)
				);
	}
	void upd(int w, int a, int b, int l, int r, int value) {
		if (a > r or b < l)
			return;
		if (a >= l and b <= r) {
			nodes[w].value.first += value;
			nodes[w].lazy += value;
			return;
		}
		const int middle = (a + b) / 2;
		push(w, b - middle);
		upd(nodes[w].l, a, middle, l, r, value);
		upd(nodes[w].r, middle + 1, b, l, r, value);
		nodes[w].value = merge(nodes[nodes[w].l].value, nodes[nodes[w].r].value);
	}
	T query(int l, int r) {
		return que(root, 0, sz - 1, l, r);
	}
	void update(int l, int r, int value) {
		upd(root, 0, sz - 1, l, r, value);
	}
};

using P = pair<int, int>;

struct pair_hash {
    inline std::size_t operator()(const std::pair<int,int> & v) const {
        return v.first * size_t(1e6) + v.second;
    }
};

void solve() {
	int n, m, k, q;
	cin >> n >> m >> k >> q;
	map<P, int> s;
	REP(i, k) {
		int x, y;
		cin >> x >> y;
		--x, --y;
		s[pair(x, y)] = 0;
	}
	sz = 1;
	while (sz < n)
		sz *= 2;
	int sz_dfs = 1;
	while (sz_dfs < q + 1) {
		sz_dfs *= 2;
	}
	using Event = tuple<int, int, P>; // {l, r, value}
	vector<Event> events;
	REP(i, q) {
		int x, y;
		cin >> x >> y;
		--x, --y;
		P p = pair(x, y);
		if (s.contains(p)) {
			events.emplace_back(s[p], i, p);
			s.erase(p);
		}
		else {
			s[p] = i + 1;
		}
	}
	for (auto [p, l] : s) {
		events.emplace_back(l, sz_dfs - 1, p);
	}

	vector<vector<P>> dfs_tree(2 * sz_dfs);


	auto add_event = [&](auto&& self, int w, int a, int b, int l, int r, P p) {
		if (a > r or b < l)
			return;
		if (a >= l and b <= r) {
			dfs_tree[w].emplace_back(p);
			return;
		}
		const int middle = (a + b) / 2;
		self(self, 2 * w, a, middle, l, r, p);
		self(self, 2 * w + 1, middle + 1, b, l, r, p);
	};
	for (auto [l, r, p] : events) {
		add_event(add_event, 1, 0, sz_dfs - 1, l, r, p);
	}

	const auto rev = [&](P p) -> P {
		auto [x, y] = p;
		return {n - 1 - x, y};
	};
	const auto get_diag = [](P p) -> int {
		auto [x, y] = p;
		return x + y;
	};

	const int diags = n + m - 1;

	using I = pair<int, int>;

	int blocked_points = 0;
	vector points(2, unordered_set<P, pair_hash>{});
	const int initial_reserve = 3e6;
	REP(id, 2)
		points[id].reserve(initial_reserve);
	vector squares(2, vector (diags, set<int>{})); // has xs
	vector intervals(2, vector (diags, set<I>{}));
	vector<vector<Tree>> tree(2);
	REP(id, 2)
		tree[id].resize(diags);

	auto dfs = [&](auto&& self, int w, int a, int b) -> void {
		if (a > q)
			return;
		auto v = dfs_tree[w];
		vector<tuple<int, int, int>> revert_squares; // {id, diag, x}
		vector<tuple<int, int, I, bool>> revert_intervals; // {id, diag, x, true is add}
		vector<tuple<int, int, int, int>> revert_tree; // {id, diag, l, r}
		const auto add_square = [&](int id, P p) {
			auto [x, y] = p;
			const int diag = x + y;
			squares[id][diag].emplace(x);
			revert_squares.emplace_back(id, diag, x);
		};
		const auto add_interval = [&](int id, int diag, I i) {
			intervals[id][diag].emplace(i);
			revert_intervals.emplace_back(id, diag, i, false);
		};
		const auto remove_interval = [&](int id, int diag, I i) {
			intervals[id][diag].erase(i);
			revert_intervals.emplace_back(id, diag, i, true);
		};
		const auto add_point_to_intervals = [&](int id, P p) {
			auto [x, y] = p;
			const int diag = x + y;
			auto it = intervals[id][diag].lower_bound(I(x, y));
			if (it == intervals[id][diag].end() or it->first > x + 1) {
				if (it == intervals[id][diag].begin() or prev(it)->second < x - 1) {
					add_interval(id, diag, I(x, x));
				}
				else {
					const auto before = *prev(it);
					remove_interval(id, diag, before);
					add_interval(id, diag, I(before.first, x));
				}
			}
			else {
				if (it == intervals[id][diag].begin() or prev(it)->second < x - 1) {
					const auto after = *it;
					remove_interval(id, diag, after);
					add_interval(id, diag, I(x, after.second));
				}
				else {
					const auto before = *prev(it);
					const auto after = *it;
					remove_interval(id, diag, before);
					remove_interval(id, diag, after);
					add_interval(id, diag, I(before.first, after.second));
				}
			}
		};
		const auto get_my_interval = [&](int id, P p) -> I {
			const auto [x, y] = p;
			const int diag = x + y;
			auto it = intervals[id][diag].lower_bound(I(x + 1, -1));
			return *prev(it);
		};
		const auto is_part_of_square = [&](int id, P p) -> bool {
			const auto [x, y] = p;
			const int diag = x + y;
			return squares[id][diag].contains(x);
		};
		const auto ret_false = pair(false, I{-1, -1});
		// a good interval end with squares on both ends
		const auto get_good_interval = [&](int id, P p, bool to_right) -> pair<bool, I> { // {found, interval}
			auto [l, r] = get_my_interval(id, p);
			const auto [x, y] = p;
			const int diag = x + y;
			auto expand_left = [&](auto it) -> int {
				while (it != squares[id][diag].begin() and *it >= x and *prev(it) >= l)
					--it;
				return *it;
			};
			auto expand_right = [&](auto it) -> int {
				while (next(it) != squares[id][diag].end() and *it <= x and *next(it) <= r)
					++it;
				return *it;
			};
			auto it = squares[id][diag].lower_bound(x);
			if (it == squares[id][diag].end())
				return ret_false;
			int left = x, right = x;
			if (*it == x) {
				if (to_right)
					right = expand_right(it);
				else
					left = expand_left(it);
			}
			else {
				if (to_right) {
					right = expand_right(it);
					left = expand_left(it);
				}
				else {
					return ret_false;
				}
			}
			bool found = left <= x and right <= r;
			if (not found)
				return ret_false;
			const pair<bool, I> ret_true = {true, {left, right}};
			const P below = x == left ? P(x, y - 1) : P(x - 1, y);
			if (points[id].contains(below)) {
				auto [l2, r2] = get_my_interval(id, below);
				if (l2 <= left and r2 >= right - 1)
					return ret_true;
			}
			const P above = x == right ? P(x, y + 1) : P(x + 1, y);
			if (points[id].contains(above)) {
				auto [l2, r2] = get_my_interval(id, above);
				if (l2 <= left + 1 and r2 >= right)
					return ret_true;
			}
			return ret_false;
		};
		const auto update_interval = [&](int id, int diag, int l, int r, bool inc_blocked = true) {
			auto [minimum, cnt_min] = tree[id][diag].query(l, r);
			if (minimum > 0)
				return;
			if (inc_blocked) {
				blocked_points += cnt_min;
			}
			tree[id][diag].update(l, r, 1);
			revert_tree.emplace_back(id, diag, l, r);
		};
		const auto mark_as_square = [&](P p) {
			if (is_part_of_square(0, p))
				return;
			add_square(0, p);
			add_square(1, rev(p));
			const auto [x, y] = p;
			const int diag = x + y;
			const int min_0 = tree[0][diag].query(x, x).first;
			const auto [x_rev, y_rev] = rev(p);
			const int diag_rev = x_rev + y_rev;
			const int min_1 = tree[1][diag_rev].query(x_rev, x_rev).first;
			if (min_0 == 0 and min_1 == 0) {
				++blocked_points;
			}
			if (min_0 == 0) {
				update_interval(0, diag, x, x, false);
			}
			if (min_1 == 0) {
				update_interval(1, diag_rev, x_rev, x_rev, false);
			}
		};
		const auto work = [&](int id, P p, const vector<int>& vec) {
			if (not points[id].contains(p))
				return false;
			bool ret = false;
			for (bool to_right : vec) {
				auto [found, interval] = get_good_interval(id, p, to_right);
				if (found) {
					auto [l, r] = interval;
					update_interval(id, get_diag(p), l, r);
					ret = true;
				}
			}
			return ret;
		};

		const int previous_blocked_points = blocked_points;

		for (auto p : v) {
			REP(id, 2) {
				points[id].emplace(p);
				add_point_to_intervals(id, p);
				p = rev(p);
			}
			{
				const auto [x, y] = p;
				for (auto [dx, dy] : {pair<int, int>{1, 1}, {1, -1}, {-1, 1}, {-1, -1}}) {
					P p1 = {x + dx, y};
					P p2 = {x, y + dy};
					P p3 = {x + dx, y + dy};
					if (points[0].contains(p1) and points[0].contains(p2) and points[0].contains(p3)) {
						mark_as_square(p);
						mark_as_square(p1);
						mark_as_square(p2);
						mark_as_square(p3);
					}
				}
			}
			REP(id, 2) {
				const auto [x, y] = p;
				work(id, P(x + 1, y + 1), {true, false});

				{
					auto val = work(id, P(x, y + 1), {false});
					if (val)
						work(id, P(x + 1, y), {true});
					else
						work(id, P(x + 1, y), {true, false});
				}

				{
					auto val = work(id, P(x - 1, y + 1), {false});
					if (val)
						work(id, P(x, y), {true});
					else
						work(id, P(x, y), {true, false});
					work(id, P(x + 1, y - 1), {true});
				}

				{
					auto val = work(id, P(x - 1, y), {false});
					if (val)
						work(id, P(x, y - 1), {true});
					else
						work(id, P(x, y - 1), {true, false});
				}

				work(id, P(x - 1, y - 1), {true, false});

				p = rev(p);
			}
		}

		if (a == b) {
			const int answer = ssize(points[0]) - blocked_points;
			cout << answer << '\n';
		}
		else {
			const int middle = (a + b) / 2;
			self(self, w * 2, a, middle);
			self(self, w * 2 + 1, middle + 1, b);
		}

		blocked_points = previous_blocked_points;
		reverse(revert_intervals.begin(), revert_intervals.end());
		for (auto p : v) {
			REP(id, 2) {
				points[id].erase(p);
				p = rev(p);
			}
		}
		for (auto [id, diag, x] : revert_squares) {
			squares[id][diag].erase(x);
		}
		for (auto [id, diag, i, add] : revert_intervals) {
			if (add) {
				intervals[id][diag].emplace(i);
			}
			else {
				intervals[id][diag].erase(i);
			}
		}
		for (auto [id, diag, l, r] : revert_tree) {
			tree[id][diag].update(l, r, -1);
		}
	};
	dfs(dfs, 1, 0, sz_dfs - 1);
}

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

	const int limit_nodes = 1e7;
	nodes.reserve(limit_nodes);

	solve();
}