#include <bits/stdc++.h>
using namespace std;
#define sz(x) ((int) (x).size())
typedef long long ll;
typedef pair<int,int> pii;
template<class T> void print(T & x){ cout << x; }
template<class T,class U> void print(pair<T,U> & p){cout << "("; print(p.first); cout << ", "; print(p.second); cout << ")"; }
template<class T> void print(vector<T> & v) {
  cout << "{";
  if (sz(v)) print(v[0]);
  for (int i = 1; i < sz(v); i++) cout << ", ", print(v[i]);
  cout << "}\n";
}

const ll MOD = 1e9 + 7;
const int NNN = 1e5;
ll pwp[NNN], pwn[NNN];

ll power(ll a, ll b){
  if(b == 0)
    return 1;
  if(b == 1)
    return a;
  ll x = power(a*a%MOD, b/2);
  return x * (b%2 ? a : 1) % MOD;
}

ll pw(ll e){
  if(e >= 0)
    return pwp[e];
  else
    return pwn[-e];
}

struct segment_tree {
  struct data{
    ll v = 0;
  };
  struct operation{
    ll add = 0;
  };
  static data combine(data dl, data dr){
    //cout << dl.v << " + " << dr.v << endl;
    return {dl.v + dr.v};
  };
  static data calculate(operation o, data d){
    data newd = d;
    (newd.v *= pw(o.add)) %= MOD;
    //cout << d.v << " x " << o.add << " -> " << pw(o.add) << ", " << newd.v << endl;
    return newd;
  };
  static operation merge(operation ot, operation ob){
    operation res = {ot.add + ob.add};
    return res;
  };
  int n, h;
  vector<data> t;
  vector<operation> o;
  segment_tree(int n = 0) : n(n), h(32 - __builtin_clz(n)), t(2 * n), o(n) {}
  segment_tree(vector<data> & a) : segment_tree(a.size()) {
    for (int i = 0; i < n; i++)
      t[i + n] = a[i];
    for (int x = n - 1; x > 0; x--)
      t[x] = combine(t[x << 1], t[x << 1 | 1]);
  }
  void apply(int x, operation op) {
    t[x] = calculate(op, t[x]);
    if (x < n)
      o[x] = merge(op, o[x]);
  }
  void push(int x) {
    for (int s = h; s > 0; s--) {
      int c = x >> s;
      apply(c << 1, o[c]);
      apply(c << 1 | 1, o[c]);
      o[c] = { 0 };
    }
  }
  void build(int x) {
    while (x >>= 1)
      t[x] = calculate(o[x], combine(t[x << 1], t[x << 1 | 1]));
  }
  // set the data at the position i
  void setValue(int i, data d) {
    i += n;
    push(i);
    t[i] = d;
    build(i);
  }
  // query the data on the range [l, r[
  data query(int l, int r) {
    l += n; r += n;
    push(l); push(r - 1);
    data dl = {0}, dr = {0};
    for (; l < r; l >>= 1, r >>= 1) {
      if (l & 1)
        dl = combine(dl, t[l++]);
      if (r & 1)
        dr = combine(t[--r], dr);
    }
    return combine(dl, dr);
  }
  // apply an operation on the range [l, r[
  void apply(int l, int r, operation op) {
    l += n; r += n;
    push(l); push(r - 1);
    int xl = l, xr = r;
    for (; l < r; l >>= 1, r >>= 1) {
      if (l & 1)
        apply(l++, op);
      if (r & 1)
        apply(--r, op);
    }
    build(xl); build(xr - 1);
  }
};

struct HLD {
  vector<int> par, depth, root, heavy, pos;
  vector<vector<int>>& e;

  HLD(int n, vector<vector<int>> & e) : e(e), par(n+1), depth(n+1), root(n+1), heavy(n+1), pos(n+1) {
    fill(heavy.begin(), heavy.end(), -1);
    par[1] = -1, depth[1] = 0;
    dfs(1);
    for (int i = 1, cur = 0; i <= n; i++)
      if (par[i] == -1 || heavy[par[i]] != i)
        for (int j = i; j != -1; j = heavy[j])
          root[j] = i, pos[j] = cur++;
  }
  int dfs(int u) {
    int sz = 1, mx = 0;
    for (int v: e[u]) if (v != par[u]) {
      par[v] = u;
      depth[v] = depth[u] + 1;
      int sub = dfs(v);
      if (sub > mx)
        mx = sub, heavy[u] = v;
      sz += sub;
    }
    return sz;
  }
  template<class T> void work(int u, int v, T op) {
    for (; root[u] != root[v]; v = par[root[v]]) {
      if (depth[root[u]] > depth[root[v]])
        swap(u, v);
      op(root[v], pos[root[v]], pos[v]);
    }
    if (depth[u] > depth[v]) swap(u, v);
    op(root[u], pos[u], pos[v]);
  }
  int dist(int u, int v) {
    int ret = -1;
    work(u, v, [this, &ret](int x, int l, int r) { 
      ret += r - l + 1;
    });
    return ret;
  }
};


int main(){
  ios_base::sync_with_stdio(false);
  cin.tie(0);
  int N;
  cin >> N;
  vector<vector<int>> G(N + N-1);
  for(int i=0; i<N-1; i++){
    int a, b;
    cin >> a >> b;
    a--; b--;
    G[N+i].push_back(a);
    G[N+i].push_back(b);
    G[a].push_back(N+i);
    G[b].push_back(N+i);
  }
  pwp[0] = pwn[0] = 1;
  pwp[1] = 2;
  pwn[1] = power(2, MOD-2);
  for(int i=2; i<NNN; i++){
    pwp[i] = pwp[i-1] * pwp[1] % MOD;
    pwn[i] = pwn[i-1] * pwn[1] % MOD;
  }

  HLD hld(sz(G), G);
  vector<segment_tree::data> D(N + N-1);
  for(int i=0; i<N; i++){
    D[hld.pos[i]].v = 1;
  }
  for(int i=0; i<N-1; i++){
    D[hld.pos[N+i]].v = -1;
  }
  //for(int i=0; i<N+N-1; i++)
  //  cout << "new pos " << i << " -> " << hld.pos[i] << endl;
  segment_tree S(D);
  int Q;
  cin >> Q;
  auto print_s = [&](){
    for(int i=0; i<N+N-1; i++){
      cout << S.query(i, i+1).v << " ";
    }
    cout << endl;
  };
  //S.apply(0, {1});
  //print_s();
  for(int q=0; q<Q; q++){
    char op;
    int a, b;
    cin >> op >> a >> b;
    a--; b--;
    segment_tree::operation upd_op = { op=='+' ? 1 : -1 } ;
    auto upd_f = [&](int x, int l, int r){
      r++;
      //cout << "upd " << l << " " << r << ": " << upd_op.add << endl;
      S.apply(l, r, upd_op); // TODO exclusive?
    };
    hld.work(a, b, upd_f);
    //print_s();
    ll res = S.query(0, N+N-1).v;
    cout << res-1 << "\n";
  }
}