import java.io.*;
import java.util.*;

public class network_mb {
    static class Graph {
        final int[] data;
        final boolean[] color;
        final long[] crossCosts;
        final long[] subtreeCosts;

        long weighedCostAcc;
        long bestCostAcc;
        int bestVertex;

        Graph(int n) {
            data = new int[n * 4];
            color = new boolean[n];
            crossCosts = new long[n];
            subtreeCosts = new long[n];
        }

        void addEdge(int v1, int v2) {
            int offset = v1 << 2;
            int newSize = ++data[offset];
            data[offset + newSize] = v2;
        }

        void removeEdge(int v1, int v2) {
            int offset = v1 << 2;
            int oldSize = data[offset]--;
            for (int i = 1, j = 0; i <= oldSize; ++i) {
                int next = data[offset + i];
                if (next != v2) {
                    data[offset + ++j] = next;
                }
            }
        }

        void dfsColor(int v) {
            color[v] = true;
            int offset = v << 2;
            int size = data[offset];
            for (int i = 1; i <= size; ++i) {
                int next = data[offset + i];
                if (!color[next]) {
                    dfsColor(next);
                }
            }
        }

        void color() {
            Arrays.fill(color, false);
            dfsColor(0);
        }

        void fillCosts(int[] src, int[] dst, int[] costs) {
            Arrays.fill(crossCosts, 0);
            Arrays.fill(subtreeCosts, 0);
            for (int i = 0; i < src.length; ++i) {
                int v1 = src[i];
                int v2 = dst[i];
                int c = costs[i];
                if (color[v1] != color[v2]) {
                    crossCosts[v1] += c;
                    crossCosts[v2] += c;
                }
            }
        }

        long dfsSubtreeCosts(int v, int p) {
            long mySubtree = 0;
            int offset = v << 2;
            int size = data[offset];
            for (int i = 1; i <= size; ++i) {
                int next = data[offset + i];
                if (next != p) {
                    long call = dfsSubtreeCosts(next, v);
                    weighedCostAcc += call;
                    mySubtree += call;
                }
            }
            weighedCostAcc += mySubtree; // not including myself
            return subtreeCosts[v] = mySubtree + crossCosts[v];
        }

        void dfsFindBest(int v, int p, long outerCost) {
            int offset = v << 2;
            int size = data[offset];

            if (size < 3) { // update only if can add an edge here
                if (weighedCostAcc < bestCostAcc || weighedCostAcc == bestCostAcc && v < bestVertex) {
                    bestVertex = v;
                    bestCostAcc = weighedCostAcc;
                }
            }

            for (int i = 1; i <= size; ++i) {
                int next = data[offset + i];
                if (next != p) {
                    // when moving down the edge v--next:
                    //   cost decreases by subtree[next]
                    //   cost increases by outerCost                    | these two are new outerCost
                    //   cost increases by subtree[v] - subtree[next]   |
                    long newOuterCost = outerCost + subtreeCosts[v] - subtreeCosts[next];
                    long change = newOuterCost - subtreeCosts[next];
                    weighedCostAcc += change;
                    dfsFindBest(next, v, newOuterCost);
                    weighedCostAcc -= change;
                }
            }
        }

        int findBestFor(int v) {
            weighedCostAcc = 0;
            dfsSubtreeCosts(v, -1);
            bestCostAcc = weighedCostAcc;
            bestVertex = v;

            dfsFindBest(v, -1, 0);

            return bestVertex;
        }
    }

    public static void main(String[] args) throws IOException {
        try (IntReader in = new IntReader();
             PrintWriter out = new PrintWriter(System.out)) {
            int n = in.nextInt();
            int[] v1s = new int[n];
            int[] v2s = new int[n];
            Graph g = new Graph(n);
            for (int i = 0; i + 1 < n; ++i) {
                int v1 = v1s[i] = in.nextInt() - 1;
                int v2 = v2s[i] = in.nextInt() - 1;
                g.addEdge(v1, v2);
                g.addEdge(v2, v1);
            }

            int d = in.nextInt();
            int[] src = new int[d];
            int[] dst = new int[d];
            int[] cost = new int[d];
            for (int i = 0; i < d; ++i) {
                src[i] = in.nextInt() - 1;
                dst[i] = in.nextInt() - 1;
                cost[i] = in.nextInt();
            }

            for (int i = 0; i + 1 < n; ++i) {
                int v1 = v1s[i], v2 = v2s[i];
                g.removeEdge(v1, v2);
                g.removeEdge(v2, v1);
                g.color();
                g.fillCosts(src, dst, cost);

                int u1 = g.findBestFor(v1);
                int u2 = g.findBestFor(v2);
                g.addEdge(u1, u2);
                g.addEdge(u2, u1);

                if (u1 < u2) {
                    out.println((u1 + 1) + " " + (u2 + 1));
                } else {
                    out.println((u2 + 1) + " " + (u1 + 1));
                }
            }
        }
    }

    private static class IntReader implements Closeable {
        BufferedReader in;
        StringTokenizer st;

        IntReader() throws IOException {
            in = new BufferedReader(new InputStreamReader(System.in));
            st = new StringTokenizer(in.readLine());
        }

        int nextInt() {
            try {
                while (!st.hasMoreTokens()) {
                    st = new StringTokenizer(in.readLine());
                }
                return Integer.parseInt(st.nextToken());
            } catch (IOException ex) {
                throw new RuntimeException(ex);
            }
        }

        @Override
        public void close() throws IOException {
            in.close();
            in = null;
            st = null;
        }
    }
}