#include<bits/stdc++.h>
using namespace std;
using ll = long long;
#define all(x) begin(x), end(x)
const int mod = 1e9 + 7;
int add(int a, int b) {
    return a + b >= mod ? a + b - mod : a + b;
}
struct Node {
    ll sm = 1, lazy = 1;
    void apply(ll x) {
        lazy = lazy * x % mod;
        sm = sm * x % mod;
    }
    friend Node operator+(const Node &a, const Node &b) {
        return Node{add(a.sm, b.sm)};
    }
};

struct ST {
    int n;
    vector<Node> tree;
    ST(int N) : n(N), tree(4*N + 4) { init(1, 0, n - 1); }
    void init(int v, int l, int r) {
        if(l == r) {
            tree[v].sm = 1;
        } else {
            int m = (l + r) / 2;
            init(2 * v, l, m);
            init(2* v + 1, m + 1, r);
            tree[v] = tree[2*v]+tree[2*v+1];
        }
    }
    void push(int v) {
        if(tree[v].lazy) {
            tree[2*v].apply(tree[v].lazy);
            tree[2*v + 1].apply(tree[v].lazy);
            tree[v].lazy = 1;
        }
    }
    void update(int v, int l, int r, int ql, int qr, int d) {
        if(qr < l || r < ql) return;
        if(ql <= l && r <= qr) {
            tree[v].apply(d);
            return;
        }
        push(v);
        int m = (l + r) / 2;
        update(2 * v, l, m, ql, qr, d);
        update(2 * v + 1, m + 1, r, ql, qr, d);
        tree[v] = tree[2*v] + tree[2*v+1];
    }
    void update(int ql, int qr, int d) {
        update(1, 0, n - 1, ql, qr, d);
    }
    int get() {
        return tree[1].sm;
    }
    void dfs(int v, int l, int r) {
        if(l == r) {
            cout << tree[v].sm << " ";
        } else {
            int m = (l + r) / 2;
            push(v);
            dfs(2*v, l, m);
            dfs(2*v+1, m + 1, r);
        }
    }
};

int main() {
    cin.tie(0)->sync_with_stdio(0);
    // ST s(10);
    // s.dfs(1, 0, 9); cout << " | " << s.get() << endl;
    // s.update(0, 9, 2); 
    // s.dfs(1, 0, 9); cout << " | " << s.get() << endl;
    // s.update(4, 4, 2); 
    // s.dfs(1, 0, 9); cout << " | " << s.get() << endl;
    // return 0;
    int n, m;
    cin >> n;
    vector<vector<int>> g(n);
    for(int f, t, i = 1; i < n; i++) {
        cin >> f >> t;
        g[--f].push_back(--t);
        g[t].push_back(f);
    }

    vector<int> sz(n), par(n);
    auto sizes = [&](auto self, int v) -> void {
        sz[v] = 1;
        for(auto &i : g[v]) {
            g[i].erase(find(all(g[i]), v));
            par[i] = v;
            self(self, i);
            sz[v] += sz[i];
            if(sz[i] > sz[g[v][0]])
                swap(g[v][0], i);
        }
    };
    sizes(sizes, 0);

    int timer = 0;
    vector<int> tin(n), tout(n), head(n);
    auto hld = [&](auto self, int v) -> void {
        tin[v] = timer++;
        for(auto i : g[v]) {
            head[i] = i == g[v][0] ? head[v] : i;
            self(self, i);
        }
        tout[v] = timer;
    };
    hld(hld, 0);

    ST V(n), E(n);
    auto is_ancestor = [&](int u, int v) {
        return tin[u] <= tin[v] && tin[v] < tout[u];
    };
    auto up = [&](int &a, int &b, int d, ST &st) {
        while(!is_ancestor(head[a], b)) {
            // cout << head[a] << " to " << a << endl;
            st.update(tin[head[a]], tin[a], d);
            a = par[head[a]];
        }
    };
    auto update = [&](int u, int v, int d, ST &st, int touch_lca) {
        up(u, v, d, st);
        up(v, u, d, st);
        if(!is_ancestor(u, v)) swap(v, u);
        // cout << u << " to " << v << endl;
        st.update(tin[u] + !touch_lca, tin[v], d);
    };
    int u, v;
    char c;
    cin >> m;
    while(m--) {
        cin >> c >> u >> v;
        --u, --v;
        int d = c == '+' ? 2 : (mod + 1) / 2;
        update(u, v, d, V, 1);
        update(u, v, d, E, 0);

        // V.dfs(1, 0, n - 1);cout << endl;
        // E.dfs(1, 0, n - 1);cout << endl;
        cout << V.get() - E.get() << '\n';
        // cout << endl;
    }
}