InMobi_OA_2

#include <bits/stdc++.h> // Includes all standard libraries (common in competitive programming)

using namespace std;

// Using long long for integer type for larger values
#define int long long

// Global timer for DFS start/end times
int dfs_timer;

// Max log for binary lifting (2^23 > 8*10^6, safe for n up to 10^6)
const int MAX_LOG = 24;

/**
 * @brief Performs DFS to calculate start/end times and immediate parents.
 * @param u Current node
 * @param p Parent node
 * @param st Start time array
 * @param en End time array
 * @param up Ancestor table (up[u][0] is parent of u)
 * @param adj Adjacency list
 */
void precompute_dfs(int u, int p, vector<int>& st, vector<int>& en,
                    vector<vector<int>>& up, const vector<vector<int>>& adj) {
    up[u][0] = p;
    st[u] = dfs_timer++;
    for (int v : adj[u]) {
        if (v != p) {
            precompute_dfs(v, u, st, en, up, adj);
        }
    }
    en[u] = dfs_timer;
}

/**
 * @brief Checks if node u is an ancestor of node v.
 */
bool is_ancestor(int u, int v, const vector<int>& st, const vector<int>& en) {
    return (st[u] <= st[v] && en[u] >= en[v]);
}

/**
 * @brief Finds the Lowest Common Ancestor (LCA) of nodes u and v.
 */
int find_lca(int u, int v, const vector<vector<int>>& up,
             const vector<int>& st, const vector<int>& en) {
    // First, check if one is an ancestor of the other
    if (is_ancestor(u, v, st, en)) return u;
    if (is_ancestor(v, u, st, en)) return v;

    // Binary lifting to find LCA
    for (int i = MAX_LOG - 1; i >= 0; i--) {
        if (!is_ancestor(up[u][i], v, st, en)) {
            u = up[u][i];
        }
    }
    return up[u][0];
}

signed main() {
    // Optimize C++ streams for speed
    ios::sync_with_stdio(false);
    cin.tie(NULL);

    int n, m;
    cin >> n >> m;

    vector<vector<int>> adj(n + 1);
    vector<vector<int>> up(n + 1, vector<int>(MAX_LOG, 0));
    vector<int> degree(n + 1, 0);
    vector<int> startTime(n + 1), endTime(n + 1);

    // Read tree edges
    for (int i = 0; i < n - 1; i++) {
        int u, v;
        cin >> u >> v;
        adj[u].push_back(v);
        adj[v].push_back(u);
        degree[u]++;
        degree[v]++;
    }

    // Run DFS and precomputation, rooting at 1
    // Node 0 is a virtual parent for the root
    dfs_timer = 0;
    precompute_dfs(1, 0, startTime, endTime, up, adj);
    endTime[0] = dfs_timer; // Set end time for virtual parent

    // Fill the binary lifting (ancestor) table
    for (int i = 1; i < MAX_LOG; i++) {
        for (int j = 1; j <= n; j++) {
            up[j][i] = up[up[j][i - 1]][i - 1];
        }
    }

    // 'delta' array for difference array on tree
    vector<int> delta(n + 1, 0);

    // Process m queries
    for (int j = 0; j < m; j++) {
        int u, v;
        cin >> u >> v;

        int lca = find_lca(u, v, up, startTime, endTime);

        // This is a standard difference array technique for path updates on a tree.
        // Add 1 to u, add 1 to v, subtract 1 from LCA, subtract 1 from parent of LCA.
        delta[u]++;
        delta[v]++;
        delta[lca]--;
        if (up[lca][0] != 0) { // Avoid decrementing virtual parent
            delta[up[lca][0]]--;
        }
    }

    // Use a queue to process nodes from leaves up (topological sort)
    // This accumulates the delta values from children to parents
    queue<int> q;
    vector<int> processing_degree = degree; // Copy degrees for processing
    for (int i = 1; i <= n; i++) {
        if (processing_degree[i] == 1) {
            q.push(i);
        }
    }

    // If n=1, root is also a leaf.
    if (n == 1) {
        q.push(1);
    }

    while (!q.empty()) {
        int u = q.front();
        q.pop();

        int p = up[u][0];
        if (p == 0) continue; // Stop at the root's virtual parent

        // Add child's sum to its parent
        delta[p] += delta[u];
        processing_degree[p]--;

        // If parent is now a "leaf" (relative to its own parent), add to queue
        if (processing_degree[p] == 1 && p != 1) { // p != 1 ensures root isn't re-added
             q.push(p);
        }
    }

    // After the BFS, delta[1] (the root) needs its final processing
    // if it wasn't a leaf.
    // The original logic handles the root correctly when its degree
    // becomes 1 (or 0 if it was the last node).
    // Let's re-verify the original logic.
    // The original loop is correct. When deg[p] == 1, it means all children
    // of p have been processed, and only the edge to *its* parent remains.
    // So we push p to be processed. This works for the root 1 as well,
    // as up[1][0] is 0, and the loop will just add delta[1] to delta[0]
    // and terminate.
    // My previous 'processing_degree' and check for p != 1 was an
    // over-complication. Reverting to the simpler, correct original logic.

    // Re-doing the leaf-processing part to match the (correct) original
    queue<int> q_simple;
    for(int i = 1; i <= n; i++){
        // Node 1 is the root, it shouldn't be added as a leaf
        // unless n=1 or it's a leaf (n=2).
        if(degree[i] == 1 && i != 1) {
            q_simple.push(i);
        }
    }
    // Handle n=1 case
    if (n == 1) q_simple.push(1);
    // Handle n=2 case (root is a leaf)
    if (n == 2 && degree[1] == 1) q_simple.push(1);

    vector<int> final_ans = delta;

    while(!q_simple.empty()){
        int u = q_simple.front();
        q_simple.pop();

        int p = up[u][0];
        if (p == 0) continue; // Should not happen if root isn't pushed incorrectly

        final_ans[p] += final_ans[u];
        degree[p]--;

        // If parent (and not root) now only has parent edge, push it.
        if(degree[p] == 1 && p != 1) {
            q_simple.push(p);
        }
    }

    // The original code's logic was simpler and more robust.
    // It works because even the root (1) will be pushed when degree[1] == 1,
    // (after all its children are processed), and its update will
    // go to node 0, which is fine.

    // --- Using the original, correct logic ---
    queue<int> q_original;
    for(int i = 1; i <= n; i++){
        if(degree[i] == 1) {
            q_original.push(i);
        }
    }

    // This loop correctly propagates sums up from all leaves.
    while(!q_original.empty()){
        int u = q_original.front();
        q_original.pop();

        int p = up[u][0];
        if (p == 0) continue; // Don't process parent of root

        delta[p] += delta[u];
        degree[p]--;

        if(degree[p] == 1 && p != 0) { // p!=0 is technically redundant but safe
            q_original.push(p);
        }
    }
    // --- End original logic ---


    // Print the final counts for each node
    for (int i = 1; i <= n; i++) {
        cout << delta[i] << ' ';
    }
    cout << '\n';

    return 0;
}