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;
}

#include <iostream>
#include <vector>
#include <algorithm>
#include <cmath>
using namespace std;
bool helper(const vector<int>& serverLoad, int maxOperations, int K) {
    vector<int> loads = serverLoad;
    int n = loads.size();

    for (int op = 0; op < maxOperations; ++op) {
        if (loads.empty()) return true; 
        int maxLoad = *max_element(loads.begin(), loads.end());
        int threshold = maxLoad / 2;
        vector<int> newLoads;
        for (int load : loads) {
            if (load <= threshold) {
                newLoads.push_back(load);
            }
        }

        loads = newLoads;
    }
    return loads.size() <= K;
}

int getMinToolRuns(const vector<int>& serverLoad, int K) {
    int left = 0;
    int right = serverLoad.size();

    int result = right;

    while (left <= right) {
        int mid = left + (right - left) / 2;

        if (helper(serverLoad, mid, K)) {
            result = mid;
            right = mid - 1;
        } else {
            left = mid + 1;
        }
    }

    return result;
}

#include <iostream>
#include <vector>
#include <string>
using namespace std;
const int MOD = 1000000007;
int solve(const string& s2, int n, int x, int y) {
    int s_length = s2.length();
    vector<char> s(s_length);
        for (int i = 0; i < s_length; i++) {
        s[i] = s2[i];
    }
    
    vector<int> prevSame(s_length, -1);
    int idxL = -1;
    int idxR = -1;
    
    for (int i = 0; i < s_length; i++) {
        if (s[i] == 'l') {
            prevSame[i] = idxL;
            idxL = i;
        } else {
            prevSame[i] = idxR;
            idxR = i;
        }
    }

    vector<vector<long>> dp(s_length + 1, vector<long>(n + 1, 0));
    dp[0][x] = 1;
    
    for (int i = 1; i <= s_length; i++) {
        for (int j = 0; j <= n; j++) {
            dp[i][j] = dp[i - 1][j];
            if (s[i - 1] == 'l') {
                if (j + 1 <= n) dp[i][j] += dp[i - 1][j + 1];
                if (j + 1 <= n && prevSame[i - 1] >= 0) dp[i][j] -= dp[prevSame[i - 1] + 1 - 1][j + 1];
            } else {
                if (j - 1 >= 0) dp[i][j] += dp[i - 1][j - 1];
                if (j - 1 >= 0 && prevSame[i - 1] >= 0) dp[i][j] -= dp[prevSame[i - 1] + 1 - 1][j - 1];
            }
            dp[i][j] = (dp[i][j] + MOD) % MOD;
        }
    }
    
    return static_cast<int>(dp[s_length][y]);
}

#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;

int main() {
    int N;
    cin >> N;
    vector<int> A(N);
    for (int i = 0; i < N; i++) {
        cin >> A[i];
    }

    int maxA = *max_element(A.begin(), A.end());
    vector<long long> dp(maxA + 1, 0);
    vector<long long> count(maxA + 1, 0);

    for (int i = 0; i < N; i++) {
        count[A[i]]++;
    }
    for (int g = maxA; g >= 1; g--) {
        long long cnt = 0;
        for (int mul = g; mul <= maxA; mul += g) {
            cnt = (cnt + dp[mul]) % MOD;
        }
        cnt = (cnt + (1LL << count[g]) - 1) % MOD;
        dp[g] = cnt;
    }

    for (int i = 0; i < N; i++) {
        cout << dp[A[i]] << " ";
    }
    cout << endl;

    return 0;
}

#include <iostream>
#include <vector>
#include <cmath>
using namespace std;
vector<int> solve(int T, vector<long long>& test_cases) {
    vector<int> results;
    results.reserve(T);
    
    for (const auto& N : test_cases) {
        results.push_back(static_cast<int>(sqrt(N)));
    }
    
    return results;
}