#include <bits/stdc++.h>

using namespace std;

#define int long long

const int MAXN = 2e5 + 228;
const int MOD = 1e9 + 7;

int n;
vector<int> gr[MAXN];
int sz[MAXN], heavy[MAXN], par[MAXN], depth[MAXN], pos[MAXN], root[MAXN];

void dfs(int v, int p) {
    sz[v] = 1;
    for (int u: gr[v]) {
        if (u == p) 
            continue;
        par[u] = v;
        depth[u] = depth[v] + 1;
        dfs(u, v);
        if (sz[heavy[v]] < sz[u])
            heavy[v] = u;
        sz[v] += sz[u];
    }
}

struct segment_tree {
    int tree[4 * MAXN], e[4 * MAXN], lazy_v[4 * MAXN], lazy_e[4 * MAXN];

    void build(int v, int tl, int tr) {
        lazy_v[v] = lazy_e[v] = 1;
        if (tl == tr) {
            tree[v] = 1;
            if (tl == 0)
                e[v] = 0;
            else 
                e[v] = MOD - 1;
            return;
        }
        int tm = (tl + tr) / 2;
        build(v * 2, tl, tm), build(v * 2 + 1, tm + 1, tr);
        tree[v] = (tree[v * 2] + tree[v * 2 + 1]) % MOD;
        e[v] = (e[v * 2] + e[v * 2 + 1]) % MOD;
    }

    void push(int v, int x, int y) {
        tree[v] = (tree[v] * x) % MOD;
        lazy_v[v] = (lazy_v[v] * x) % MOD;
        e[v] = (e[v] * y) % MOD;
        lazy_e[v] = (lazy_e[v] * y) % MOD;
    }

    void push_all(int v, int l, int r) {
        if (l != r) {
            push(v * 2, lazy_v[v], lazy_e[v]);
            push(v * 2 + 1, lazy_v[v], lazy_e[v]);
        }
        lazy_v[v] = lazy_e[v] = 1;
    }

    void upd(int v, int tl, int tr, int l, int r, int x, int y) {
        if (tr < l || r < tl)
            return;
        if (l <= tl && tr <= r) {
            push(v, x, y);
            return;
        }
        int tm = (tl + tr) / 2;
        push_all(v, tl, tr);
        upd(v * 2, tl, tm, l, r, x, y);
        upd(v * 2 + 1, tm + 1, tr, l, r, x, y);
        tree[v] = (tree[v * 2] + tree[v * 2 + 1]) % MOD;
        e[v] = (e[v * 2] + e[v * 2 + 1]) % MOD;
    }

    void upd(int l, int r, int x, int y) {
        upd(1, 0, n - 1, l, r, x, y);
    }
} tree;

void upd(int v, int u, int k) {
    while (root[v] != root[u]) {
        if (depth[root[v]] < depth[root[u]])
            swap(v, u);
        tree.upd(pos[root[v]], pos[v], k, k);
        v = par[root[v]];
    }
    if (pos[v] > pos[u])
        swap(v, u);
    tree.upd(pos[v], pos[u], k, 1);
    tree.upd(pos[v] + 1, pos[u], 1, k);
}

signed main() {
    cin.tie(nullptr)->sync_with_stdio(false);
    cin >> n;
    for (int i = 1, x, y; i < n; ++i) {
        cin >> x >> y;
        gr[x].push_back(y);
        gr[y].push_back(x);
    }
    dfs(1, -1);
    int cnt = 0;
    for (int i = 1; i <= n; ++i) {
        if (heavy[par[i]] != i) {
            int x = i;
            while (x > 0) {
                pos[x] = ++cnt;
                root[x] = i;
                x = heavy[x];
            }
        }
    }
    tree.build(1, 0, n - 1);
    int q;
    cin >> q;
    while (q--) {
        char c;
        cin >> c;
        int x, y;
        cin >> x >> y;
        int k;
        if (c == '+')
            k = 2;
        else
            k = (MOD + 1) / 2;
        upd(x, y, k);
        cout << (tree.tree[1] + tree.e[1] - 1 + MOD) % MOD << "\n";
    }
}