/*
 * author: pavveu
 * task: Potyczki Algorytmiczne 2020 Runda 5 - Krolewski Bal [B]
*/

#include <bits/stdc++.h>

using namespace std;

using ll = long long;
using vi = vector<int>;
using vll = vector<ll>;

#define FOR(iter, val) for(int iter = 0; iter < (val); iter++)
#define all(x) begin(x), end(x)

template<typename T>
void initialize_matrix(vector<vector<T>>& matrix, int rows, int cols, T val) {
	assert(matrix.empty());
	FOR(row, rows) 
		matrix.emplace_back(cols, val);
}


struct hopcroft_karp_matcher {
	static const int INF = 2e9 + 10;
	static const int MAXV = 2010;

	int PV[MAXV], PU[MAXV], D[MAXV];
	vector<int> G[MAXV];

	int U,V;

	bool bfs() {
		queue<int> Q;

		for(int u = 1; u <= U; u++) {
			if(PU[u])	D[u] = INF;
			else {
				D[u] = 0;
				Q.push(u);
			}
		}	

		D[0] = INF;
		while(Q.size()) {
			int u = Q.front();	Q.pop();
			
			if(D[u] < D[0]) {
				for(int v : G[u])	{
					if(D[PV[v]] != INF) continue;
					
					D[PV[v]] = D[u]+1;	
					Q.push(PV[v]);
				}
			}
		}
		return (D[0] != INF);
	}

	bool dfs(int u) {
		if(!u) return true;

		for(int v : G[u]) {
			if(D[PV[v]] == D[u]+1 && dfs(PV[v]) == true) {
					PV[v] = u;
					PU[u] = v;
					return true;
			}
		}

		D[u] = INF;
		return false;
	}


	void init(vector<pair<int,int>>& edges) {

		

		set<int> u_vertices;
		set<int> v_vertices;


		for (auto p : edges) {
			auto[u, v] = p;
			u_vertices.insert(u);
			v_vertices.insert(v);
		}

		U = u_vertices.size();
		V = v_vertices.size();

		vector<int> id(U + V + 10, 0);

		FOR(i, U + V + 9) {
			PU[i] = 0;
			PV[i] = 0;
			G[i].clear();
		}


		int ids = 1;
		for (int x : u_vertices) {
			id[x] = ids++;
		}

		for (int x : v_vertices) {
			id[x] = ids++;
		}


		for (auto p : edges) {
			auto[u, v] = p;
			G[id[u]].push_back(id[v]);
			G[id[v]].push_back(id[u]);
		}
	}

	int get_matching() {
		int match = 0;
		while(bfs()) {
			for(int u = 1; u <= U; u++) {
				if(!PU[u] && dfs(u))	
						match++;
			}			
		}
		return match;
	}
};

vector<pair<int,int>> get_bipartite_edges(vector<vector<int>>& board) {
	int n = board.size();

	vector<pair<int,int>> edges;

	FOR(i, n) {
		FOR(j, n) {
			if ( board[i][j] == 1 ) 
				continue;

			int u { i * n + j + 1 };

			FOR(k, n) {
				if ( board[i][k] ) edges.emplace_back(u, i * n + k + 1);
				if ( board[k][j] ) edges.emplace_back(u, k * n + j + 1);
			}
		}
	}
	return edges;
}

void go() {
	int n, m, q;
	cin >> n >> m >> q;

	vector<vector<int>> summary;
	initialize_matrix(summary, n, n, 0);

	while ( m-- ) {
		int a, b, c, d;
		cin >> a >> b >> c >> d;

		for (int i = a - 1; i < c; i++) {
			// (b, d) cols
			//
			summary[i][b - 1]++;
			if ( d < n ) summary[i][d]--;
		}
	}

	FOR(r, n) {
		for (int c = 1; c < n; c++) {
			summary[r][c] = summary[r][c] + summary[r][c - 1];
		}
	}

	FOR(r, n) FOR(c, n) summary[r][c] %= 2;

	hopcroft_karp_matcher hkm;	

	int a, b; 
	do {

		auto edges { get_bipartite_edges(summary) };
		hkm.init(edges);
		cout << hkm.get_matching() << endl;

		if ( q == 0 ) break;
		q--;

		cin >> a >> b;
		summary[a - 1][b - 1] ^= 1;
	}

	while ( true );
}

int main() {
	ios::sync_with_stdio(false);
	cin.tie(0);

	go();

	return 0;
}