#include <bits/stdc++.h>
#include <math.h>
using namespace std;
#define endl "\n"
#define mp make_pair
#define st first
#define nd second
#define pii pair<int, int>
#define pb push_back
#define _upgrade ios_base::sync_with_stdio(0), cout.setf(ios::fixed), cout.precision(10), cin.tie(0), cout.tie(0);
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define FWD(i, a, b) for (int i = (a); i < (b); ++i)
#define rep(i, n) for (int32_t i = 0; i < (n); ++i)
#define fwd(i, a, b) for (int i = (a); i < (b); ++i)
#define all(c) (c).begin(), (c).end()
#define sz(X) (int)((X).size())
#define what(x) cerr << #x << " is " << x << endl;

ostream &operator<<(ostream &out, string str) {
   for (char c : str)
      out << c;
   return out;
}
template <class L, class R> ostream &operator<<(ostream &out, pair<L, R> p) { return out << "(" << p.st << ", " << p.nd << ")"; }
template <class T> auto operator<<(ostream &out, T a) -> decltype(a.begin(), out) {
   out << '{';
   for (auto it = a.begin(); it != a.end(); it = next(it))
      out << (it != a.begin() ? ", " : "") << *it;
   return out << '}';
}
void dump() { cerr << "\n"; }
template <class T, class... Ts> void dump(T a, Ts... x) {
   cerr << a << ", ";
   dump(x...);
}
#define DEBUG false
#define debug(...)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     \
   if (DEBUG)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          \
   cerr << "[" #__VA_ARGS__ "]: ", dump(__VA_ARGS__)

// USUNAC
#define ZERO 0ll
//#define int long long

/////////////////////////////////////////////////////////////////////////////////

long long N, m, q;

struct drzewo_przedzialowe // drzewo przedzial-przedzial dodaj-dodaj
{
   int rozmiar;
   vector<int> jedynki, zera, L, P, do_swap;

   int pot(int n) {
      int x = 1;
      while (n > x)
         x = x * 2;
      return x;
   }

   drzewo_przedzialowe(int x) // x-rozmiar drzewa
   {
      rozmiar = pot(x);
      jedynki.resize(2 * rozmiar, 0);
      zera.resize(2 * rozmiar, 0);
      do_swap.resize(2 * rozmiar, 0);
      L.resize(2 * rozmiar);
      P = L;

      for (int i = rozmiar; i < 2 * rozmiar; i++)
         L[i] = P[i] = i - rozmiar;
      for (int i = rozmiar; i < rozmiar + x; i++)
         zera[i] = 1;
      for (int i = rozmiar - 1; i > 0; i--) {
         L[i] = L[2 * i];
         P[i] = P[2 * i + 1];
         zera[i] = zera[2 * i + 1] + zera[2 * i];
      }
   }

   void uzgodnij(int wezel) {
      swap(zera[wezel], jedynki[wezel]);
      do_swap[wezel] ^= 1;
   }

   void zmien(int p, int q, int wezel = 1) // dodaje o_ile_zmienic na przedziale [p,q]
   {
      if (p > q)
         return;
      // debug(p, q);
      if (p == L[wezel] && q == P[wezel]) {
         uzgodnij(wezel);
         return;
      }

      if (do_swap[wezel]) {
         uzgodnij(2 * wezel + 1);
         uzgodnij(2 * wezel);
         do_swap[wezel] = 0;
      }

      zmien(p, min(P[2 * wezel], q), 2 * wezel);
      zmien(max(L[2 * wezel + 1], p), q, 2 * wezel + 1);

      zera[wezel] = zera[2 * wezel + 1] + zera[2 * wezel];
      jedynki[wezel] = jedynki[2 * wezel + 1] + jedynki[2 * wezel];
   }

   int get_all_one() { return jedynki[1]; }
   int get_all_zero() { return zera[1]; }
   int get_one(int x) {
      zmien(x, x);
      zmien(x, x);
      return jedynki[x + rozmiar];
   }

   void wypisz() { debug(zera, jedynki, rozmiar); }
};

map<pii, int> M;

#define ADD 0
#define GET 1

vector<int> getopis(vector<vector<int>> &zapytania, vector<pii> Q, bool ones = true) {
   drzewo_przedzialowe D(N);
   vector<vector<pair<int, pii>>> W(N + 1);
   vector<int> res(N);

   for (auto &q : zapytania) {
      W[q[0]].push_back({ADD, {q[1], q[3]}});
      W[q[2] + 1].push_back({ADD, {q[1], q[3]}});
   }
   for (auto &q : Q) {
      W[q.st].push_back({GET, q});
   }

   //   debug(W);

   rep(i, N) {
      for (auto &q : W[i]) {
         if (q.st == ADD)
            D.zmien(q.nd.st, q.nd.nd);
         else
            M[q.nd] = D.get_one(q.nd.nd);
      }
      res[i] = ones ? D.get_all_one() : D.get_all_zero();
      //  debug(i);
      // D.wypisz();
   }
   // debug(res);
   return res;
}

//////////////////////////////////////////

// long long get_maks_brut(vector<int> X, vector<int> Y) {
//    // debug(X, Y);
//    long long res = 0;
//    sort(all(X), greater<int>());
//    sort(all(Y), greater<int>());
//    for (int y : Y) {
//       // debug(X, Y);
//       while (!X.empty() && X.back() == 0)
//          X.pop_back();
//       res += min(y, sz(X));
//       for (int i = 0; i < min(y, sz(X)); i++)
//          X[i]--;
//       sort(all(X), greater<int>());
//    }
//    // debug(res);
//    return res;
// }

long long get_maks_heura(const vector<int> &X, const vector<int> &Y) {
   long long res = 0;

   // cerr << X << " " << Y << endl;
   int cnt = 0;
   long long ile = 0;
   int j = 0;
   for (int i = sz(Y) - 1; i >= 0; i--) {
      while (j != sz(X) && X[j] <= cnt)
         j++;
      long long y = Y[i];
      //    cerr << y << " " << X << endl;
      ile += sz(X) - j;
      res += min(ile, y);
      cnt++;
      ile = max(0ll, ile - y);
   }
   return res;
}

///////////////////////////////

vector<vector<int>> zap;
vector<pii> Q;

void pre() {
   cin >> N >> m >> q;
   rep(i, m) {
      vector<int> temp(4);
      rep(j, 4) {
         cin >> temp[j];
         temp[j]--;
      }
      zap.push_back(temp);
   }
   rep(i, q) {
      int a, b;
      cin >> a >> b;
      Q.emplace_back(--a, --b);
   }
}

int zmniejsz(int x, vector<int> &X) {
   auto i = lower_bound(all(X), x) - X.begin();
   X[i]--;
   return i;
}

int zwieksz(int x, vector<int> &X) {
   int i = upper_bound(all(X), x) - X.begin();
   X[i - 1]++;
   return i - 1;
}

void experimental(vector<int> X, vector<int> Y, vector<int> OX, vector<int> OY);

void solve() {

   // debug(zap, Q);

   auto OX = getopis(zap, Q, true);

   for (auto &q : zap) {
      swap(q[0], q[1]);
      swap(q[2], q[3]);
   }

   auto OY = getopis(zap, {}, false);
   auto X = OX;
   auto Y = OY;
   sort(all(X));
   sort(all(Y));

   if ((q + 1) * N > (int)3e8) {

      cerr << "EXP" << endl;
      experimental(X, Y, OX, OY);
      return;
   }

   cout << get_maks_heura(X, Y) << endl;

   for (auto qq : Q) {
      if (M[qq]) {
         zmniejsz(OX[qq.st]--, X);
         zwieksz(OY[qq.nd]++, Y);
      } else {
         zwieksz(OX[qq.st]++, X);
         zmniejsz(OY[qq.nd]--, Y);
      }
      //  debug(X, Y, OY, OX);
      cout << get_maks_heura(X, Y) << endl;
      //  cout << get_maks_brut(X, Y) << endl;
      /// TO MAM BYC ODKOMENTOWANE
      M[qq] ^= 1;
   }
   return;
}

int32_t main() {
   pre();
   solve();
}

/////////////////////////////////////////////////////////////////
const int MAXN = 3e5 + 99;
const int WIELKOSC_KUBELKA = 201; // wielkosc paczki
int LICZBA_KUBELKOW;
long long expr_res = 0;

long long ILE[MAXN];
long long EXPER_RES[MAXN];
int CNT[MAXN];
int MOD[MAXN];
long long MINI[MAXN];

inline void change_mod(int kubelek, int mod) {
   MOD[kubelek] += mod;
   MINI[kubelek] += mod;
}

inline long long get_ile(int p) {
   if (p >= N)
      return 0;
   return max(ILE[p] + MOD[p / WIELKOSC_KUBELKA], ZERO);
}

inline int ile_wiekszych(int x, vector<int> &X) { return X.end() - upper_bound(all(X), x); }

long long change(vector<int> &X, vector<int> &Y, int kubelek) {

   expr_res -= EXPER_RES[kubelek];
   int pierwszy = min(ZERO + WIELKOSC_KUBELKA * (kubelek + 1) - 1, ZERO + N - 1);
   int ostatni = WIELKOSC_KUBELKA * (kubelek);
   long long poprzednie_ile = max(ZERO, ILE[ostatni] + MOD[kubelek]); // ile jest w ostatnim
   MOD[kubelek] = 0;
   MINI[kubelek] = 1e9;

   //   debug(pierwszy, ostatni);

   long long res = 0;
   int obecny = ile_wiekszych(N - pierwszy - 2, X);
   for (int i = pierwszy; i >= ostatni; i--) {
      ILE[i] = i == pierwszy ? get_ile(i + 1) : max(ILE[i + 1], ZERO);
      obecny -= CNT[N - i - 1];
      ILE[i] += obecny;
      res += min(ILE[i], (long long)Y[i]);
      ILE[i] -= Y[i];
      MINI[kubelek] = min(MINI[kubelek], ILE[i]);
   }

   // debug(EXPER_RES[kubelek], res);
   EXPER_RES[kubelek] = res;
   // debug(kubelek, res);

   expr_res += EXPER_RES[kubelek];

   return max(ZERO, ILE[ostatni]) - poprzednie_ile;
}

void update(vector<int> &X, vector<int> &Y, int kubelek_startowy) {
   int mod = change(X, Y, kubelek_startowy);
   // debug(kubelek_startowy, mod, DEBUG_CNT++);
   if (abs(mod) > 1)
      exit(0);
   if (mod == 0)
      return;

   for (int k = kubelek_startowy - 1; k >= 0; k--) {
      if (mod > 0) {
         if (MINI[k] < 0) {
            mod = change(X, Y, k);
            if (mod != 0) {
               continue;
            }
            return;
         } else {
            change_mod(k, mod);
         }
      } else {
         if (MINI[k] <= 0) {
            mod = change(X, Y, k);
            if (mod != 0) {
               continue;
            }
            return;
         } else {
            change_mod(k, mod);
         }
      }
   }
}

void experimental(vector<int> X, vector<int> Y, vector<int> OX, vector<int> OY) {
   LICZBA_KUBELKOW = ceil((long double)N / WIELKOSC_KUBELKA - 0.000000001);

   for (int a : X)
      CNT[a]++;

   for (int i = LICZBA_KUBELKOW - 1; i >= 0; i--)
      change(X, Y, i);

   cout << expr_res << endl;

   for (auto qq : Q) {
      if (M[qq]) {

         CNT[OX[qq.st]]--;
         int a = zmniejsz(OX[qq.st]--, X);
         CNT[OX[qq.st]]++;

         update(X, Y, (N - X[a] - 1) / WIELKOSC_KUBELKA);
         int b = zwieksz(OY[qq.nd]++, Y);
         update(X, Y, b / WIELKOSC_KUBELKA);
      } else {

         CNT[OX[qq.st]]--;
         int a = zwieksz(OX[qq.st]++, X);
         CNT[OX[qq.st]]++;

         update(X, Y, (N - X[a]) / WIELKOSC_KUBELKA);
         int b = zmniejsz(OY[qq.nd]--, Y);
         update(X, Y, b / WIELKOSC_KUBELKA);
      }
      //   for (int i = LICZBA_KUBELKOW - 1; i >= 0; i--)
      //      change(X, Y, i);
      //  debug(X, Y, OY, OX);
      cout << expr_res << endl;
      //  cout << get_maks_brut(X, Y) << endl;
      /// TO MAM BYC ODKOMENTOWANE
      M[qq] ^= 1;
   }
   return;
}