#include <bits/stdc++.h>
using namespace std;

#pragma GCC optimize("O3,unroll-loops")
// #pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt")
// Ofast, O0, O1, O2, O3, unroll-loops, fast-math, trapv

typedef long long ll;
typedef pair<ll, ll> pll;
typedef pair<int, int> pii;

#define Mp          make_pair
#define sep         ' '
#define endl        '\n'
#define F	        first
#define S	        second
#define pb          push_back
#define all(x)      (x).begin(),(x).end()
#define kill(res)	cout << res << '\n', exit(0);
#define set_dec(x)	cout << fixed << setprecision(x);
#define fast_io     ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
#define file_io     freopen("input.txt", "r", stdin) ; freopen("output.txt", "w", stdout);

#define lid (id*2)
#define rid (id*2+1)
#define mid ((l+r)/2)

mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());

const ll N = 2e5 + 50;
const ll Mod = 1e9 + 7;

int n, q, par[N], sz[N], head[N], st[N], timer, inv2;

vector<int> adj[N];

ll mod(ll a, ll b = Mod){
    while(a >= b) a -= b;
    return a;
}

ll power(ll a, ll b, ll md = Mod){
    ll ans = 1;
    for(; b; b /= 2, a = a * a % md){
        if(b % 2) ans = ans * a % md;
    }
    return ans;
}

void pre(int v){
    if(par[v]) adj[v].erase(find(all(adj[v]), par[v]));
    sz[v] = 1;
    for(int u: adj[v]){
        par[u] = v; pre(u); sz[v] += sz[u];
    }
    for(int i = 1; i < adj[v].size(); i++) if(sz[adj[v][0]] < sz[adj[v][i]]) swap(adj[v][0], adj[v][i]);
}

void hld(int v){
    st[v] = timer++;
    for(int u: adj[v]){
        if(u == adj[v][0]) head[u] = head[v];
        else head[u] = u;
        hld(u);
    }
}

ll seg1[N*4], lz1[N*4];

void quex1(int id, ll x){
    seg1[id] = mod(seg1[id] * x);
    lz1[id] = mod(lz1[id] * x);
}

void relax1(int id){
    quex1(lid, lz1[id]);
    quex1(rid, lz1[id]);
    lz1[id] = 1;
}

void build1(int l = 0, int r = n, int id = 1){
    if(l+1 == r){
        lz1[id] = 1; seg1[id] = 1; return;
    }
    build1(l, mid, lid);
    build1(mid, r, rid);
    seg1[id] = r-l; lz1[id] = 1;
}

void upd1(int ql, int qr, ll x, int l = 0, int r = n, int id = 1){
    if(ql <= l && r <= qr){
        quex1(id, x); return;
    }
    if(qr <= l || r <= ql) return;

    relax1(id);
    upd1(ql, qr, x, l, mid, lid);
    upd1(ql, qr, x, mid, r, rid);
    seg1[id] = mod(seg1[lid] + seg1[rid]);
}

ll get1(int ql, int qr, int l = 0, int r = n, int id = 1){
    if(ql <= l && r <= qr) return seg1[id];
    if(qr <= l || r <= ql) return 0;
    relax1(id);
    return mod(get1(ql, qr, l, mid, lid) + get1(ql, qr, mid, r, rid));
}


ll seg2[N*4], lz2[N*4];

void quex2(int id, ll x){
    seg2[id] = mod(seg2[id] * x);
    lz2[id] = mod(lz2[id] * x);
}

void relax2(int id){
    quex2(lid, lz2[id]);
    quex2(rid, lz2[id]);
    lz2[id] = 1;
}

void build2(int l = 0, int r = n, int id = 1){
    if(l+1 == r){
        lz2[id] = 1; seg2[id] = 1; return;
    }
    build2(l, mid, lid);
    build2(mid, r, rid);
    seg2[id] = r-l; lz2[id] = 1;
}

void upd2(int ql, int qr, ll x, int l = 0, int r = n, int id = 1){
    if(ql <= l && r <= qr){
        quex2(id, x); return;
    }
    if(qr <= l || r <= ql) return;

    relax2(id);
    upd2(ql, qr, x, l, mid, lid);
    upd2(ql, qr, x, mid, r, rid);
    seg2[id] = mod(seg2[lid] + seg2[rid]);
}

ll get2(int ql, int qr, int l = 0, int r = n, int id = 1){
    if(ql <= l && r <= qr) return seg2[id];
    if(qr <= l || r <= ql) return 0;
    relax2(id);
    return mod(get2(ql, qr, l, mid, lid) + get2(ql, qr, mid, r, rid));
}

void upd(int ql, int qr, ll x, int l = 0, int r = n, int id = 1){
    if(ql <= l && r <= qr){
        quex1(id, x); quex2(id, x); return;
    }
    if(qr <= l || r <= ql) return;

    relax1(id); relax2(id);
    upd(ql, qr, x, l, mid, lid);
    upd(ql, qr, x, mid, r, rid);
    seg1[id] = mod(seg1[lid] + seg1[rid]);
    seg2[id] = mod(seg2[lid] + seg2[rid]);
}

void upd_path(int u, int v, int x){
    while(head[u] != head[v]){
        if(st[u] < st[v]) swap(u, v);
        upd(st[head[u]], st[u]+1, x);
        u = par[head[u]];
    }
    if(st[u] < st[v]) swap(u, v);
    upd1(st[v], st[u]+1, x);
    upd2(st[v]+1, st[u]+1, x);
}

int main(){
    fast_io;

    inv2 = power(2, Mod-2);

    cin >> n;

    int u, v;
    for(int i = 1; i < n; i++){
        cin >> u >> v;
        adj[u].pb(v);
        adj[v].pb(u);
    }

    pre(1); head[1] = 1; hld(1);

    cin >> q;

    build1(); build2();

    while(q--){
        char t;
        cin >> t >> u >> v;

        if(t == '+') upd_path(u, v, 2);
        else upd_path(u, v, inv2);

        ll res = mod(get1(0, n) - get2(0, n) + Mod);
        cout << res << endl;
    }

}