def dfs(node, par, depth, graph, signal_speed):
    global cnt
    if depth % signal_speed == 0 and depth != 0:
        cnt += 1
    for neighbor, weight in graph[node]:
        if neighbor == par:
            continue
        dfs(neighbor, node, depth + weight, graph, signal_speed)

def getNumPairs(server_nodes, server_from, server_to, server_weight, signal_speed):
    graph = {}
    for i in range(server_nodes - 1):
        if server_from[i] not in graph:
            graph[server_from[i]] = []
        if server_to[i] not in graph:
            graph[server_to[i]] = []
        graph[server_from[i]].append((server_to[i], server_weight[i]))
        graph[server_to[i]].append((server_from[i], server_weight[i]))
    result = []
    for i in range(1, server_nodes + 1):
        global cnt
        cnt = 0
        dfs(i, i, 0, graph, signal_speed)
        result.append(cnt * (cnt - 1))
    return result

def split_text_to_sms(text, limit):
    def suffix_length(x, y):
        return len(f"<{x}/{y}>")
    for y in range(1, len(text) + 1):
        max_content_length = limit - suffix_length(1, y)
        if max_content_length <= 0:
            continue
        
        messages = []
        current_start = 0
        
        while current_start < len(text):
            if current_start + max_content_length > len(text):
                end = len(text)
            else:
                end = current_start + max_content_length
            
            message_content = text[current_start:end]
            message_suffix = f"<{len(messages) + 1}/{y}>"
            
            if len(message_content) + len(message_suffix) > limit:
                break
            
            messages.append(message_content + message_suffix)
            current_start = end
        
        if len(messages) == y:
            return messages
    
    return []

#include <bits/stdc++.h>
#define int long long 
using namespace std;
class Tracker {
private:
    int n;
    vector<int> rowXor;
    vector<int> colXor;
    vector<vector<int>> grid;

    void updateXor(int r, int c, int s, bool add) {
        if (add) {
            rowXor[r] ^= s;
            colXor[c] ^= s;
        } else {
            rowXor[r] ^= s;
            colXor[c] ^= s;
        }
    }
    
    int countAttackable() {
        int count = 0;
        for (int r = 1; r <= n; ++r) {
            for (int c = 1; c <= n; ++c) {
                if ((rowXor[r] ^ colXor[c]) > 0) {
                    ++count;
                }
            }
        }
        return count;
    }

public:
    Tracker(int N) : n(N), rowXor(N + 1, 0), colXor(N + 1, 0), grid(N + 1, vector<int>(N + 1, 0)) {}

    void addPanda(int r, int c, int s) {
        if (grid[r][c] > 0) {
            updateXor(r, c, grid[r][c], false);
        }
        grid[r][c] = s;
        updateXor(r, c, s, true);
    }

    void movePanda(int r1, int c1, int r2, int c2) {
        if (grid[r1][c1] > 0) {
            updateXor(r1, c1, grid[r1][c1], false);
            addPanda(r2, c2, grid[r1][c1]);
            grid[r1][c1] = 0;
        }
    }

    void processMove(int r1, int c1, int r2, int c2) {
        movePanda(r1, c1, r2, c2);
        cout << countAttackable() << endl;
    }
};

void gameEngine(int N, int P, int M, int arr1[][3], int arr2[][4]) {
    Tracker trk(N);

    for (int i = 0; i < P; ++i) {
        int r = arr1[i][0];
        int c = arr1[i][1];
        int s = arr1[i][2];
        trk.addPanda(r, c, s);
    }

    for (int i = 0; i < M; ++i) {
        int r1 = arr2[i][0];
        int c1 = arr2[i][1];
        int r2 = arr2[i][2];
        int c2 = arr2[i][3];
        trk.processMove(r1, c1, r2, c2);
    }
}

int32_t main() {
    int n, p, m;
    cin >> n >> p >> m;
    
    int arr1[p][3];
    for (int i = 0; i < p; ++i) {
        for (int j = 0; j < 3; ++j) {
            cin >> arr1[i][j];
        }
    }

    int arr2[m][4];
    for (int i = 0; i < m; ++i) {
        for (int j = 0; j < 4; ++j) {
            cin >> arr2[i][j];
        }
    }

    gameEngine(n, p, m, arr1, arr2);

    return 0;
}

#include <bits/stdc++.h>
using namespace std;
void generateresult(const string& s) {
    regex zero_regex("0+");
    sregex_token_iterator it(s.begin(), s.end(), zero_regex, -1);
    sregex_token_iterator end;
    vector<string> ans;
    
    for (; it != end; ++it) {
        ans.push_back(*it);
    }
    
    for (const auto& substr : ans) {
        cout << substr << endl;
    }
}

int main() {
    string s;
    getline(cin, s);
    generateresult(s);
    return 0;
}