#include <iostream>
#include <type_traits>
#include <vector>

constexpr int next_pow2(int v)
{
  --v;
  v |= v >> 1;
  v |= v >> 2;
  v |= v >> 4;
  v |= v >> 8;
  v |= v >> 16;
  ++v;
  return v;
}

struct FlipSumSegTree1D
{
  std::vector<int> tree_;
  std::vector<bool> lazy_;
  int N_;

  FlipSumSegTree1D(int num_nodes)
    : N_(next_pow2(num_nodes))
    , tree_(2 * next_pow2(num_nodes), 0)
    , lazy_(2 * next_pow2(num_nodes), false)
  {}

  constexpr inline int _L(int x) { return x * 2; }
  constexpr inline int _R(int x) { return x * 2 + 1; }

  void _flip_impl(int node, int l, int r, int ql, int qr)
  {
    if (lazy_[node]) {
      tree_[node] = (r - l + 1) - tree_[node];
      if (l != r) {
        lazy_[_L(node)] = !lazy_[_L(node)];
        lazy_[_R(node)] = !lazy_[_R(node)];
      }
      lazy_[node] = false;
    }

    if (ql <= l && r <= qr) {
      tree_[node] = (r - l + 1) - tree_[node];
      if (l != r) {
        lazy_[_L(node)] = !lazy_[_L(node)];
        lazy_[_R(node)] = !lazy_[_R(node)];
      }
    } else if (ql <= r && l <= qr) {
      int mid = (l + r) / 2;
      _flip_impl(_L(node), l, mid, ql, qr);
      _flip_impl(_R(node), mid + 1, r, ql, qr);
      tree_[node] = tree_[_L(node)] + tree_[_R(node)];
    }
  }

  void flip(int ql, int qr) { _flip_impl(1, 1, N_, ql, qr); }

  int _count_impl(int node, int l, int r, int ql, int qr)
  {
    if (lazy_[node]) {
      tree_[node] = (r - l + 1) - tree_[node];
      if (l != r) {
        lazy_[_L(node)] = !lazy_[_L(node)];
        lazy_[_R(node)] = !lazy_[_R(node)];
      }
      lazy_[node] = false;
    }

    if (ql <= l && r <= qr) {
      return tree_[node];
    } else if (ql <= r && l <= qr) {
      int mid = (l + r) / 2;
      return _count_impl(_L(node), l, mid, ql, qr) +
             _count_impl(_R(node), mid + 1, r, ql, qr);
    }
    return 0;
  }

  int count(int ql, int qr) { return _count_impl(1, 1, N_, ql, qr); }
};

struct FlipSumSegTree2D
{
  std::vector<int> tree_;
  std::vector<bool> lazy_;
  std::vector<int> all_xs_;
  std::vector<int> all_ys_;
  FlipSumSegTree1D tree_max_xs_;
  FlipSumSegTree1D tree_max_ys_;
  FlipSumSegTree1D tree_min_xs_;
  FlipSumSegTree1D tree_min_ys_;

  int N_;
  int num_nodes_;

  FlipSumSegTree2D(int num_nodes)
    : num_nodes_(num_nodes)
    , N_(next_pow2(num_nodes))
    , tree_(2 * next_pow2(num_nodes) * 2 * next_pow2(num_nodes), 0)
    , lazy_(2 * next_pow2(num_nodes) * 2 * next_pow2(num_nodes), false)
    , all_xs_(num_nodes + 1, 0)
    , all_ys_(num_nodes + 1, 0)
    , tree_max_xs_(num_nodes)
    , tree_max_ys_(num_nodes)
    , tree_min_xs_(num_nodes)
    , tree_min_ys_(num_nodes)
  {}

  constexpr inline int _LL(int n) { return n * 4 + 0; }
  constexpr inline int _LR(int n) { return n * 4 + 1; }
  constexpr inline int _RL(int n) { return n * 4 + 2; }
  constexpr inline int _RR(int n) { return n * 4 + 3; }

  void _flip_impl(int node,
                  int xl,
                  int xr,
                  int yl,
                  int yr,
                  int qxl,
                  int qxr,
                  int qyl,
                  int qyr)
  {
    if (lazy_[node]) {
      tree_[node] = (xr - xl + 1) * (yr - yl + 1) - tree_[node];
      if (xl != xr || yl != yr) {
        lazy_[_LL(node)] = !lazy_[_LL(node)];
        lazy_[_LR(node)] = !lazy_[_LR(node)];
        lazy_[_RL(node)] = !lazy_[_RL(node)];
        lazy_[_RR(node)] = !lazy_[_RR(node)];
      }
      lazy_[node] = false;
    }

    if (qxl <= xl && xr <= qxr && qyl <= yl && yr <= qyr) {
      tree_[node] = (xr - xl + 1) * (yr - yl + 1) - tree_[node];
      if (xl != xr || yl != yr) {
        lazy_[_LL(node)] = !lazy_[_LL(node)];
        lazy_[_LR(node)] = !lazy_[_LR(node)];
        lazy_[_RL(node)] = !lazy_[_RL(node)];
        lazy_[_RR(node)] = !lazy_[_RR(node)];
      }
    } else if (qxl <= xr && xl <= qxr && qyl <= yr && yl <= qyr) {
      int mx = (xl + xr) / 2;
      int my = (yl + yr) / 2;
      _flip_impl(_LL(node), xl, mx, yl, my, qxl, qxr, qyl, qyr);
      _flip_impl(_LR(node), xl, mx, my + 1, yr, qxl, qxr, qyl, qyr);
      _flip_impl(_RL(node), mx + 1, xr, yl, my, qxl, qxr, qyl, qyr);
      _flip_impl(_RR(node), mx + 1, xr, my + 1, yr, qxl, qxr, qyl, qyr);
      tree_[node] = tree_[_LL(node)] + tree_[_LR(node)] + tree_[_RL(node)] +
                    tree_[_RR(node)];
    }
  }

  void flip(int qxl, int qxr, int qyl, int qyr)
  {
    _flip_impl(1, 1, N_, 1, N_, qxl, qxr, qyl, qyr);
  }

  int _count_impl(int node,
                  int xl,
                  int xr,
                  int yl,
                  int yr,
                  int qxl,
                  int qxr,
                  int qyl,
                  int qyr)
  {
    if (lazy_[node]) {
      tree_[node] = (xr - xl + 1) * (yr - yl + 1) - tree_[node];
      if (xl != xr || yl != yr) {
        lazy_[_LL(node)] = !lazy_[_LL(node)];
        lazy_[_LR(node)] = !lazy_[_LR(node)];
        lazy_[_RL(node)] = !lazy_[_RL(node)];
        lazy_[_RR(node)] = !lazy_[_RR(node)];
      }
      lazy_[node] = false;
    }
    if (qxl <= xl && xr <= qxr && qyl <= yl && yr <= qyr) {
      return tree_[node];
    } else if (qxl <= xr && xl <= qxr && qyl <= yr && yl <= qyr) {
      int mx = (xl + xr) / 2;
      int my = (yl + yr) / 2;
      return _count_impl(_LL(node), xl, mx, yl, my, qxl, qxr, qyl, qyr) +
             _count_impl(_LR(node), xl, mx, my + 1, yr, qxl, qxr, qyl, qyr) +
             _count_impl(_RL(node), mx + 1, xr, yl, my, qxl, qxr, qyl, qyr) +
             _count_impl(_RR(node), mx + 1, xr, my + 1, yr, qxl, qxr, qyl, qyr);
    }
    return 0;
  }

  int count(int qxl, int qxr, int qyl, int qyr)
  {
    return _count_impl(1, 1, N_, 1, N_, qxl, qxr, qyl, qyr);
  }

  void prepare()
  {
    for (int i = 1; i <= num_nodes_; ++i) {
      all_xs_[i] = count(i, i, 1, N_);
      all_ys_[i] = count(1, N_, i, i);

      if (all_xs_[i] == num_nodes_) {
        tree_max_xs_.flip(i, i);
      }
      if (all_ys_[i] == num_nodes_) {
        tree_max_ys_.flip(i, i);
      }
      if (all_xs_[i] == 0) {
        tree_min_xs_.flip(i, i);
      }
      if (all_ys_[i] == 0) {
        tree_min_ys_.flip(i, i);
      }
    }
  }

  void flip_single(int qx, int qy)
  {
    _flip_impl(1, 1, N_, 1, N_, qx, qx, qy, qy);

    int new_all_xs = count(qx, qx, 1, N_);
    int new_all_ys = count(1, N_, qy, qy);

    if (new_all_xs != all_xs_[qx]) {
      if (all_xs_[qx] == num_nodes_ || new_all_xs == num_nodes_) {
        // was maximum and now it's not or wasn't maximum and now it is
        tree_max_xs_.flip(qx, qx);
      }
      if (all_xs_[qx] == 0 || new_all_xs == 0) {
        tree_min_xs_.flip(qx, qx);
      }
      all_xs_[qx] = new_all_xs;
    }

    if (new_all_ys != all_ys_[qy]) {
      if (all_ys_[qy] == num_nodes_ || new_all_ys == num_nodes_) {
        // was maximum and now it's not or wasn't maximum and now it is
        tree_max_ys_.flip(qy, qy);
      }
      if (all_ys_[qy] == 0 || new_all_ys == 0) {
        tree_min_ys_.flip(qy, qy);
      }
      all_ys_[qy] = new_all_ys;
    }
  }

  int current_ans()
  {
    int num_of_xn = tree_max_xs_.count(1, num_nodes_);
    int num_of_yn = tree_max_ys_.count(1, num_nodes_);
    int num_of_x0 = tree_min_xs_.count(1, num_nodes_);
    int num_of_y0 = tree_min_ys_.count(1, num_nodes_);

    int unreachable = num_of_x0 * num_of_y0;
    int cant_throw = num_of_xn * num_of_yn;

    int spaces = num_nodes_ * num_nodes_ - unreachable;
    int possible = count(1, num_nodes_, 1, num_nodes_) - cant_throw;
    return std::min(spaces - possible, possible);
  }
};

int main()
{
  std::ios::sync_with_stdio(false);

  int n, m, q;
  std::cin >> n >> m >> q;

  FlipSumSegTree2D tree(n);

  for (int i = 0; i < m; ++i) {
    int x1, y1, x2, y2;
    std::cin >> x1 >> y1 >> x2 >> y2;
    tree.flip(x1, x2, y1, y2);
  }
  tree.prepare();
  std::cout << tree.current_ans() << std::endl;
  for (int i = 0; i < q; ++i) {
    int x, y;
    std::cin >> x >> y;
    tree.flip_single(x, y);
    std::cout << tree.current_ans() << std::endl;
  }

  return 0;
}