#include <iostream>
#include <vector>
#include <algorithm>

// using https://robert1003.github.io/2020/01/27/fenwick-tree.html

using namespace std;

vector<vector<int>> A;
vector<vector<vector<int>>> B;
vector<vector<int>> HH;
vector<int> HHRowSum;
vector<int> HHColumnSum;
int n, m, q;

int lowbit(int x)
{
    return x & (-x);
}

void upd(int x, int y, int v) {
    for (int i = x; i <= n; i += lowbit(i)) {
        for (int j = y; j <= n; j += lowbit(j)) {
            B[i][j][0] += v;
            B[i][j][1] += x * v;
            B[i][j][2] += y * v;
            B[i][j][3] += x * y * v;
        }
    }
}

int qry(int x, int y) {
    int ans = 0;
    for (int i = x; i > 0; i -= lowbit(i)) {
        for (int j = y; j > 0; j -= lowbit(j)) {
            ans += (x + 1) * (y + 1) * B[i][j][0] - (y + 1) * B[i][j][1] - (x + 1) * B[i][j][2] + B[i][j][3];
        }
    }
    return ans;
}

void update(int x1, int y1, int x2, int y2, int v) {
    upd(x1, y1, v);
    upd(x1, y2 + 1, -v);
    upd(x2 + 1, y1, -v);
    upd(x2 + 1, y2 + 1, v);
}

int query(int x1, int y1, int x2, int y2) {
    return qry(x2, y2) - qry(x1 - 1, y2) - qry(x2, y1 - 1) + qry(x1 - 1, y1 - 1);
}

void printHH()
{
    for (int i = 1; i <= n; i++)
    {
        for (int j = 1; j <= n; j++)
        {
            cout << HH[n - i + 1][j];
        }

        cout << endl;
    }
}

void updateHH()
{
    for (int i = 1; i <= n; i++)
    {
        for (int j = 1; j <= n; j++)
        {
            HH[i][j] = query(i, j, i, j) % 2;
        }
    }
}

void printSums()
{
    int rowCount = 0;
    int ColumnCount = 0;
    
    for (int i = 1; i <= n; i++)
    {
        cout << HHRowSum[i] << " ";
        rowCount += HHRowSum[i];
    }

    cout << rowCount << endl;

    for (int i = 1; i <= n; i++)
    {
        cout << HHColumnSum[i] << " ";
        ColumnCount += HHColumnSum[i];
    }

    cout << ColumnCount << endl;
}

int main()
{
    ios::sync_with_stdio(false);
    bool LOCAL = false;

    cin >> n >> m >> q;

    A.resize(n + 1, vector<int>(n + 2));
    B.resize(n + 1, vector<vector<int>>(n + 2, vector<int>(4)));
    HH.resize(n + 1, vector<int>(n + 1));

    int x1, y1, x2, y2;

    for (int i = 0; i < m; i++)
    {
        cin >> y1 >> x1 >> y2 >> x2;
        update(x1, y1, x2, y2, 1);
    }

    updateHH();
    
    //if (LOCAL)
    //{
    //    printHH();
    //}
    
    HHRowSum.resize(n + 1);
    HHColumnSum.resize(n + 1);

    long long int HHGuys = 0;
    long long int allGuys = (long long int)n * n;

    for (int i = 1; i <= n; i++)
    {
        for (int j = 1; j <= n; j++)
        {
            HHRowSum[i] += HH[i][j];
            HHColumnSum[i] += HH[j][i];
            HHGuys += HH[i][j];
        }  
    }

    int blockedColumns = 0;
    int blockedRows = 0;
    int emptyColumns = 0;
    int emptyRows = 0;

    for (int i = 1; i <= n; i++)
    {
        if (HHRowSum[i] == n)
        {
            blockedRows++;
        }

        if (HHColumnSum[i] == n)
        {
            blockedColumns++;
        }        
        
        if (HHRowSum[i] == 0)
        {
            emptyRows++;
        }

        if (HHColumnSum[i] == 0)
        {
            emptyColumns++;
        }
    }

    
    //if (LOCAL)
    //{
    //    cout << allGuys << endl;
    //    cout << HHGuys << endl;
    //    cout << (long long int)blockedRows * blockedColumns << endl;

    //    cout << blockedRows << " " << blockedColumns << endl;
    //    cout << emptyRows << " " << emptyColumns << endl;

    //    printSums();
    //}

    cout << max((long long int)0, min(allGuys - HHGuys - ((long long int)emptyRows * emptyColumns),
            HHGuys - ((long long int)blockedRows * blockedColumns))) << endl;
    
    for (int x = 0; x < q; x++)
    {
        cin >> y1 >> x1;
        HH[x1][y1] ^= 1;
        
        if (HH[x1][y1] == 0)
        {
            HHRowSum[x1]--;
            HHColumnSum[y1]--;

            if (HHRowSum[x1] == n - 1)
            {
                blockedRows--;
            }

            if (HHColumnSum[y1] == n - 1)
            {
                blockedColumns--;
            }

            if (HHRowSum[x1] == 0)
            {
                emptyRows++;
            }

            if (HHColumnSum[y1] == 0)
            {
                emptyColumns++;
            }

            HHGuys--;
        }
        else
        {
            HHRowSum[x1]++;
            HHColumnSum[y1]++;

            if (HHRowSum[x1] == n)
            {
                blockedRows++;
            }

            if (HHColumnSum[y1] == n)
            {
                blockedColumns++;
            }

            if (HHRowSum[x1] == 1)
            {
                emptyRows--;
            }

            if (HHColumnSum[y1] == 1)
            {
                emptyColumns--;
            }

            HHGuys++;
        }

        //if (LOCAL)
        //{
        //    printHH();
        //    printSums();
        //    cout << blockedRows << " " << blockedColumns << endl;

        //    cout << HHGuys << endl;
        //}

        cout << max((long long int)0, min(allGuys - HHGuys - ((long long int)emptyRows * emptyColumns),
            HHGuys - ((long long int)blockedRows * blockedColumns))) << endl;
    }
}