// uzywam kodu https://github.com/Skedar1994/Kody/blob/master/kody/matching.cpp
// while (clock()<=69*CLOCKS_PER_SEC)
// #pragma comment(linker, "/stack:200000000")
// #pragma GCC optimize("O3")
// #pragma GCC optimize("Ofast")
// #pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
// #pragma GCC optimize("unroll-loops")
#include<bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>

#define pb push_back
#define SZ(x) ((int)(x).size())
#define ALL(x) x.begin(),x.end()
#define all(x) x.begin(),x.end()
#define fi first
#define se second
#define _upgrade ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define erase_duplicates(x) sort(all(x)); (x).resize(distance((x).begin(), unique(all(x))));


using namespace std;
using namespace __gnu_pbds;
template<typename T>
using ordered_set = tree<
T,
null_type,
less<T>,
rb_tree_tag,
tree_order_statistics_node_update>;

//X.find_by_order(k); - zwraca iterator na k-ty element (numeracja od zerowego)
//X.order_of_key(k); - zwraca liczbę elementów ostro mniejszych niż k

typedef long long LL;
typedef pair<int,int> PII;
typedef pair<LL,LL> PLL;
typedef vector<PII> VPII;
typedef vector<PLL> VPLL;
typedef vector<LL> VLL;
typedef vector<int> VI;
typedef vector<string> VS;
typedef vector<char> VC;
typedef long double LD;
typedef pair<LD,LD> PLD;
typedef vector<LD> VLD;
typedef vector<PLD> VPLD;

template<class TH> void _dbg(const char *sdbg, TH h){ cerr<<sdbg<<" = "<<h<<endl; }
template<class TH, class... TA> void _dbg(const char *sdbg, TH h, TA... a) {
  while(*sdbg!=',')cerr<<*sdbg++;
  cerr<<" = "<<h<<", "; _dbg(sdbg+1, a...);
}

#ifdef LOCAL
#define dbg(...) _dbg(#__VA_ARGS__, __VA_ARGS__)
#else
#define dbg(...)
#define cerr if(0)cout
#endif

const int maxk = 20;
const int inf = (1e9)+7;
const LL LLinf = ((LL)1e18)+7LL;
const LD eps = 1e-9;
const LL mod = 1e9+7;

// ***************************** CODE ***************************** //

int n, m, q;

namespace BRUT {

const int maxn = (200)+7;

//po usunieciu zmiennej zostalo jest zazwyczaj szybciej (moze nawet jakies 1.5 raza)
//ale nie moge wtedy obiecac, ze na 100% bedzie zlozonosc O(msqrt(n))


//1. W str[i] kazdy wierzcholek powinien miec nr 0 lub 1 -> w zaleznosci od tego, po ktorej stronie grafu dwudzielnego jest
//2. Wierzcholki numerujemy od 1!
//3. n na wejściu to liczba wierzchołków, nie trzeba (a jak szukamy maksymalnego
//podzbioru niezaleznego to nie wolno) dawac n+1 na wejsciu

//Matching m(..); m.matching() znajduje wynik
//mozna dodac! m.mpn() i to zwraca maksymalny podzbior niezalezny

struct Matching
{
	int n, wynik;
	vector < int > odl, str, para, odw;
	const vector < vector < int > >& V;
	Matching(int N, const vector < vector < int > >& M, const vector < int >& s) : n(N), odl(n+1), str(s), para(n+1), odw(n+1), V(M)
	{
	}
	bool DFS(int v, int ojciec, int zostalo)
	{
		if (zostalo < 0)
			return false;
		odw[v] = 1;
		if (!str[v])
		{
			if (!para[v])
				return (para[v] = ojciec);
			if (DFS(para[v], v, zostalo-1))
				return (para[v] = ojciec);
			return false;
		}
		for(int i=0; i<SZ(V[v]); i++)
			if (odl[ V[v][i] ] == odl[v] + 1 && !odw[ V[v][i] ] && DFS(V[v][i], v, zostalo-1))
				return (para[v] = V[v][i]);
		return false;
	}
	int sciezki()
	{
		memset(&odl[0], 0, 4*(n+1));
		memset(&odw[0], 0, 4*(n+1));
		int minodl = 2*n+5, ilezmian = 0;
		queue < pair <int, int> > Q;
		for(int i=1; i<=n; i++)
			if (str[i] && !para[i])
			{
				Q.push(make_pair(i, 1));
				odl[i] = 1;
			}
		while(!Q.empty())
		{
			int akt = Q.front().first, od=Q.front().second; Q.pop();
			if (!str[akt])
			{
				if (para[akt])
				{
					Q.push(make_pair(para[akt], od+1));
					odl[ para[akt] ] = od+1;
				}
				else
					minodl = min(minodl, od);
				continue;
			}
			for(int i=0; i<SZ(V[akt]); i++)
				if (odl[ V[akt][i] ] == 0)
				{
					Q.push(make_pair(V[akt][i], od+1));
					odl[ V[akt][i] ] = od+1;
				}
		}
		for(int i=1; i<=n; i++)
			if (!odw[i] && str[i] && !para[i])
				ilezmian += DFS(i, -1, minodl-1);
		return ilezmian;
	}
	int matching()
	{
		int ile = 0, akt;
		while( (akt = sciezki()) )
			ile+=akt;
		return wynik = ile;
	}
	//to ponizej przepisujemy tylko gdy chcemy znalezc maksymalny podzbior niezalezny
	//zwraca maksymalny podzbior niezalezny z wierzcholkow od 1 do n
	vector < int > mpn()
	{
		vector < int > stan(n+1, 0);//0 - nieprzetworzony, 1 - wziety, -1 - nie moge wziac
		queue < int > Q;
		for(int i=1; i<=n; i++)
		{
			if(!para[i])
			{
				stan[i] = 1;
				Q.push(i);
			}
		}
		while(!Q.empty())
		{
			int x = Q.front();
			Q.pop();
			for(auto el : V[x])
			{
				if (stan[el]==0)
				{
					stan[el] = -1;
					stan[ para[el] ] = 1;
					Q.push(para[el]);
				}
			}
		}
		vector < int > odp;
		for(int i=1; i<=n; i++)
			if (stan[i] == 1 || (!stan[i] && str[i]))
				odp.pb(i);
		return odp;
	}

};

int tab[maxn][maxn];

int number(int a, int b) {
  return a + n * (b - 1);
}

void answer() {
  vector<int> s;
  s.resize(number(n, n) + 2);
  s[0] = 0;
  vector<vector<int> > graf;
  graf.resize(number(n, n) + 2);
  for(int i = 1;i <= n;i++) {
    for(int j = 1;j <= n;j++) {
      s[number(i, j)] = tab[i][j];
    }
  }
  for(int i = 1;i <= n;i++) {
    for(int j = 1;j <= n;j++) {
      for(int k = 1;k <= n;k++) {
        if(tab[i][j] != tab[i][k]) {
          graf[number(i, j)].pb(number(i, k));
        }
        if(tab[i][j] != tab[k][j]) {
          graf[number(i, j)].pb(number(k, j));
        }
      }
    }
  }
  auto match = Matching(number(n, n) + 1, graf, s);
  cout<<match.matching()<<"\n";
}

void brut() {
  for(int i = 0;i < m;i++) {
    int x1, y1, x2, y2;
    cin>>x1>>y1>>x2>>y2;
    tab[x1][y1] ^= 1;
    tab[x2 + 1][y1] ^= 1;
    tab[x1][y2 + 1] ^= 1;
    tab[x2 + 1][y2 + 1] ^= 1;
  }
  for(int i = 1;i <= n;i++) {
    for(int j = 1;j <= n;j++) {
      tab[i][j] ^= (tab[i - 1][j] ^ tab[i][j - 1] ^ tab[i - 1][j - 1]);
    }
  }
  answer();
  for(int i = 1;i <= q;i++) {
    int a, b;
    cin>>a>>b;
    tab[a][b] ^= 1;
    answer();
  }
  return;
}

}


namespace FAST {

const int maxn = (1e6)+7;

int row[maxn], col[maxn];
int qx[maxn], qy[maxn];

VPII dodaj[maxn], usun[maxn];
VPII dodaj2[maxn];
VI query[maxn];
map<PII, int> currentValue;

const int pot = 1<<20;
LL sumOfAll = 0LL;

struct xorSuma {

  int drze[2 * pot + 7];
  int suma[2 * pot + 7];
  xorSuma() {
    clear();
  }

  void xoruj(int l, int p, int lewo = 0, int prawo = pot - 1, int cur = 1) {
    if(l <= lewo and prawo <= p) {
      drze[cur] ^= 1;
      suma[cur] = prawo - lewo + 1 - suma[cur];
      return;
    }
    if(p < lewo or prawo < l) {
      return;
    }
    int sr = (lewo + prawo) / 2;
    xoruj(l, p, lewo, sr, 2 * cur);
    xoruj(l, p, sr + 1, prawo, 2 * cur + 1);
    suma[cur] = suma[2 * cur] + suma[2 * cur + 1];
    if(drze[cur]) {
      suma[cur] = prawo - lewo + 1 - suma[cur];
    }
    return;
  }

  int sum(int l, int p, int lewo = 0, int prawo = pot - 1, int cur = 1) {
    if(l <= lewo and prawo <= p) {
      return suma[cur];
    }
    if(p < lewo or prawo < l) {
      return 0;
    }
    int sr = (lewo + prawo) / 2;
    int val = sum(l, p, lewo, sr, 2 * cur) + sum(l, p, sr + 1, prawo, 2 * cur + 1);
    if(drze[cur]) {
      val = p - l + 1 - val;
    }
    return val;
  }

  void clear() {
    for(int i = 0;i < 2 * pot;i++) {
      drze[i] = suma[i] = 0;
    }
  }

} xorSuma;

struct drzewo {

  PII mini[2 * pot + 7];
  PII maxi[2 * pot + 7];

  drzewo() {
    for(int i = 0;i < 2 * pot;i++) {
      maxi[i] = {-1, 1};
      mini[i] = {inf, 1};
    }
    for(int i = pot - 1;i > 0;i--) {
      update(i);
    }
  }

  void update(int x) {
    mini[x].fi = min(mini[2 * x].fi, mini[2 * x + 1].fi);
    mini[x].se = 0;
    if(mini[2 * x].fi == mini[x].fi) {
      mini[x].se += mini[2 * x].se;
    }
    if(mini[2 * x + 1].fi == mini[x].fi) {
      mini[x].se += mini[2 * x + 1].se;
    }

    maxi[x].fi = max(maxi[2 * x].fi, maxi[2 * x + 1].fi);
    maxi[x].se = 0;
    if(maxi[2 * x].fi == maxi[x].fi) {
      maxi[x].se += maxi[2 * x].se;
    }
    if(maxi[2 * x + 1].fi == maxi[x].fi) {
      maxi[x].se += maxi[2 * x + 1].se;
    }
  }

  void updateRek(int x) {
    while(x > 0) {
      update(x);
      x /= 2;
    }
    return;
  }

  void ust(int x, int val) {
    x += pot;
    mini[x] = maxi[x] = {val, 1};
    updateRek(x / 2);
  }

  void add(int x, int val) {
    ust(x, mini[x].fi + val);
  }

};

drzewo rows, columns;

void sweep() {
  for(int i = 1;i <= n;i++) {
    for(auto s : dodaj[i]) {
      xorSuma.xoruj(s.fi, s.se);
    }
    for(auto s : query[i]) {
      currentValue[{i, s}] = xorSuma.sum(s, s);
    }
    col[i] = xorSuma.sum(1, n);
    sumOfAll += (LL)col[i];
    columns.ust(i, col[i]);
    for(auto s : usun[i]) {
      xorSuma.xoruj(s.fi, s.se);
    }
  }
  xorSuma.clear();
  for(int i = 1;i <= n;i++) {
    for(auto s : dodaj2[i]) {
      xorSuma.xoruj(s.fi, s.se);
    }
    row[i] = xorSuma.sum(1, n);
    rows.ust(i, row[i]);
  }
}

void answer() {
  int rowMini = 0;
  int rowMaxi = n;
  int colMini = 0;
  int colMaxi = n;
  if(rows.mini[1].fi == 0 and rows.maxi[1].fi == n) {
    colMini = min(rows.mini[1].se, rows.maxi[1].se);
    colMaxi = n - colMini;
  }
  if(columns.mini[1].fi == 0 and columns.maxi[1].fi == n) {
    rowMini = min(columns.mini[1].se, columns.maxi[1].se);
    rowMaxi = n - rowMini;
  }
  LL res = min(sumOfAll, n * (LL) n - sumOfAll);
  if(colMaxi == columns.maxi[1].fi and rowMaxi == rows.maxi[1].fi) {
    res = min(res, sumOfAll - columns.maxi[1].se * (LL) rows.maxi[1].se);
  }
  if(colMini == columns.mini[1].fi and rowMini == rows.mini[1].fi) {
    res = min(res, n * (LL) n - sumOfAll - columns.mini[1].se * (LL) rows.mini[1].se);
  }
  cout<<res<<"\n";
}

void fast() {
  for(int i = 0;i < m;i++) {
    int x1, y1, x2, y2;
    cin>>x1>>y1>>x2>>y2;
    dodaj[x1].pb({y1, y2});
    usun[x2].pb({y1, y2});
    dodaj2[y1].pb({x1, x2});
    dodaj2[y2 + 1].pb({x1, x2});
  }
  for(int i = 1;i <= q;i++) {
    cin>>qx[i]>>qy[i];
    query[qx[i]].pb(qy[i]);
  }
  sweep();
  answer();
  for(int i = 1;i <= q;i++) {
    if(currentValue[{qx[i], qy[i]}] == 0) {
      rows.add(qx[i], 1);
      columns.add(qy[i], 1);
      row[qx[i]]++;
      col[qy[i]]++;
      sumOfAll++;
    } else {
      sumOfAll--;
      rows.add(qx[i], -1);
      columns.add(qy[i], -1);
    }
    currentValue[{qx[i], qy[i]}] ^= 1;
    answer();
  }
  return;
}

}

int main()
{
	_upgrade
  cin>>n>>m>>q;
  if(n <= 200 and q <= 10) {
    BRUT::brut();
    return 0;
  }
  FAST::fast();
	return 0;
}