#include <iostream>
#include <algorithm>
#include <vector>
#include <map>
#include <tuple>

using namespace std;

struct TreeNode {
    bool val = false;
    int sum = 0;
};

struct RnageQuery {
    int x1, x2, y1, y2;

};

struct RangeQueryEnd {
    int x, y1, y2;
    bool operator<(RangeQueryEnd& a) {
        return this->x < a.x;
    }
};

struct ElementQuery {
    int x, y;
    bool val;
};

vector<TreeNode> tree;
vector<RnageQuery> rqs;
vector<int> eqis;
vector<ElementQuery> eqs;
vector<int> met[2];
vector<RangeQueryEnd> rqes;
int count_col[2][2] = { 0 };
int sum = 0;

int n, m, q, n2;

void swap_rqs() {
    int t;
    for (int i = 0;i < m;i++) {
        t = rqs[i].x1;
        rqs[i].x1 = rqs[i].y1;
        rqs[i].y1 = t;

        t = rqs[i].x2;
        rqs[i].x2 = rqs[i].y2;
        rqs[i].y2 = t;
    }
}

void set_rqes() {
    for (int i = 0;i < m;i++) {
        rqes[i * 2].x = rqs[i].x1;
        rqes[i * 2].y1 = rqs[i].y1;
        rqes[i * 2].y2 = rqs[i].y2;

        rqes[i * 2 + 1].x = rqs[i].x2 + 1;
        rqes[i * 2 + 1].y1 = rqs[i].y1;
        rqes[i * 2 + 1].y2 = rqs[i].y2;
    }
}

void set_n2() {
    n2 = 1;
    while (n2 < n) {
        n2 *= 2;
    }
}

void clear_tree() {
    tree.clear();
    tree.resize(n2 * 2);
}

bool sort_eqis_comp(int a, int b) {
    return eqs[a].x < eqs[b].x;
}

void sort_eqis() {
    sort(eqis.begin(), eqis.end(), sort_eqis_comp);
}

void read_input() {
    cin >> n >> m >> q;
    rqes.resize(m * 2);
    rqs.resize(m);
    eqs.resize(q);
    eqis.resize(q);
    met[0].resize(n);
    met[1].resize(n);
    for (int i = 0;i < m;i++) {
        cin >> rqs[i].x1 >> rqs[i].y1 >> rqs[i].x2 >> rqs[i].y2;
        rqs[i].x1--;
        rqs[i].y1--;
        rqs[i].x2--;
        rqs[i].y2--;
    }
    for (int i = 0;i < q;i++) {
        cin >> eqs[i].x >> eqs[i].y;
        eqs[i].x--;
        eqs[i].y--;
        eqis[i] = i;
    }

}

void set_range(int x, int y) {
    x += n2;
    y += n2;

    tree[x].val = !tree[x].val;
    if(x != y) tree[y].val = !tree[y].val;

    if (tree[x].val) {
        tree[x].sum = 1;
    }
    else {
        tree[x].sum = 0;
    }

    if(x != y)
        if (tree[y].val) {
            tree[y].sum = 1;
        }
        else {
            tree[y].sum = 0;
        }

    int gs = 1;
    if(x != y)
        while (x / 2 != y / 2) {
            if (x % 2 == 0) {
                tree[x + 1].val = !tree[x + 1].val;
                tree[x + 1].sum = gs - tree[x + 1].sum;
            }

            if (y % 2 == 1) {
                tree[y - 1].val = !tree[y - 1].val;
                tree[y - 1].sum = gs - tree[y - 1].sum;
            }

            tree[x/2].sum = tree[(x / 2) * 2].sum + tree[(x / 2) * 2 + 1].sum;
            if (tree[x / 2].val) tree[x / 2].sum = gs * 2 - tree[x / 2].sum;

            tree[y / 2].sum = tree[(y / 2) * 2].sum + tree[(y / 2) * 2 + 1].sum;
            if (tree[y / 2].val) tree[y / 2].sum = gs * 2 - tree[y / 2].sum;

            x /= 2;
            y /= 2;
            gs *= 2;
        }

    while (x != 1) {
        x /= 2;

        tree[x].sum = tree[x * 2].sum + tree[x * 2 + 1].sum;
        if (tree[x].val) tree[x].sum = gs * 2 - tree[x].sum;

        gs *= 2;
    }
}

bool get_tree_val(int x) {
    x += n;
    bool v = tree[x].val;
    while (x != 1)
    {
        x /= 2;
        if (tree[x].val) v = !v;
    }
    return v;
}

int get_tree_sum() {
    return tree[1].sum;
}

void swep_col(int t) {
    clear_tree();
    set_rqes();
    sort(rqes.begin(), rqes.end());
    vector<RangeQueryEnd>::iterator it = rqes.begin();
    for (int i = 0;i < n;i++) {
        while (it != rqes.end() && it->x == i) {
            set_range(it->y1, it->y2);
            it++;
        }
        int s = get_tree_sum();
        met[t][i] = s;
        if (s == 0) count_col[t][0]++;
        if (s == n) count_col[t][1]++;
    }
}

void swep_co2() {
    clear_tree();
    sort_eqis();
    vector<RangeQueryEnd>::iterator it = rqes.begin();
    vector<int>::iterator it_el = eqis.begin();
    for (int i = 0;i < n;i++) {
        while (it != rqes.end() && it->x == i) {
            set_range(it->y1, it->y2);
            it++;
        }
        while (it_el != eqis.end() && eqs[*it_el].x == i)
        {
            eqs[*it_el].val = get_tree_val(eqs[*it_el].y);
            it_el++;
        }
    }
}

void element_query_reappear() {
    map<tuple<int, int>, bool> rapp;
    for (vector<ElementQuery>::iterator it = eqs.begin();it != eqs.end();it++) {
        map<tuple<int, int>, bool>::iterator f = rapp.find({it->x, it->y});
        if (f == rapp.end())
            rapp[{it->x, it->y}] = it->val;
        else {
            f->second = !f->second;
            it->val = f->second;
        }
    }
}

void sum_gen() {
    for (int i = 0;i < n;i++)
        sum += met[0][i];
}

void print_sol() {
    int sol = min(sum, n*n - sum);
    sol -= count_col[0][0] * count_col[1][0];
    sol -= count_col[1][1] * count_col[0][1];
    cout << sol << "\n";
}

void update(ElementQuery& e) {
    if (e.val) {
        sum--;
        met[0][e.x]--;
        met[1][e.y]--;

        if (met[0][e.x] == n - 1) count_col[0][1]--;
        if (met[0][e.x] == 0) count_col[0][0]++;
        if (met[1][e.y] == n - 1) count_col[1][1]--;
        if (met[1][e.y] == 0) count_col[1][0]++;
    }
    else {
        sum++;
        met[0][e.x]++;
        met[1][e.y]++;

        if (met[0][e.x] == n) count_col[0][1]++;
        if (met[0][e.x] == 1) count_col[0][0]--;
        if (met[1][e.y] == n) count_col[1][1]++;
        if (met[1][e.y] == 1) count_col[1][0]--;
    }
}

void print_sols() {
    print_sol();
    for (vector<ElementQuery>::iterator it = eqs.begin(); it != eqs.end();it++) {
        update(*it);
        print_sol();
    }
}

int main()
{
    read_input();
    set_n2();
    swep_col(0);
    swep_co2();
    swap_rqs();
    swep_col(1);
    element_query_reappear();
    sum_gen();
    print_sols();
    return 0;
}