#include <bits/stdc++.h>
using namespace std;
bool stB;
namespace SOL {

void debug(const char *msg, ...) {
#ifdef CLESIP
    va_list arg;
    static char pbString[512];
    va_start(arg,msg);
    vsprintf(pbString,msg,arg);
    cerr << "[DEBUG] " << pbString << "\n";
    va_end(arg);
#endif    
}

#define PASSED cerr << "PASSED " << __FUNCTION__ << " #" << __LINE__ << "\n";

using i64 = long long;
using i128 = __int128_t;
template <typename T, typename L> void chkmax(T &x, L y) { if (x < y) x = y; }
template <typename T, typename L> void chkmin(T &x, L y) { if (y < x) x = y; }

const int N = 2e5 + 10;
const i64 P = 1e9 + 7;
const i64 INV2 = (P + 1) / 2;
vector<int> G[N];
int n, dep[N], sze[N], top[N], son[N], dfn[N], cnt, fa[N], id[N];

namespace LazySegmentTree {
	const int SEG_SIZE = N * 4;
	template<typename Node, typename Tag>
	struct LazyTagSegTree {
		#define lc (x * 2)
		#define rc (x * 2 + 1)
		#define mid ((l + r) >> 1)

		Node dat[SEG_SIZE];
		Tag tag[SEG_SIZE];

		void pull(int x) {
			dat[x] = dat[lc] + dat[rc];
		}

		void apply(int x, const Tag &t, int sze) {
			dat[x].apply(t, sze);
			tag[x].apply(t);
		}

		void push(int x, int l, int r) {
			if (tag[x]) {
				apply(lc, tag[x], mid - l + 1);
				apply(rc, tag[x], r - mid);
				tag[x].clear();
			}
		}

		void build(int x, int l, int r) {
			tag[x].clear();
			if (l == r) {
				dat[x].init(l);
				return;
			}
			build(lc, l, mid);
			build(rc, mid + 1, r);
			pull(x);
		}

		Node query(int x, int l, int r, int ql, int qr) {
			if (ql <= l && r <= qr) 
				return dat[x];
			push(x, l, r);
			if (ql <= mid && mid < qr)
				return query(lc, l, mid, ql, qr) + query(rc, mid + 1, r, ql, qr);
			else if (ql <= mid)
				return query(lc, l, mid, ql, qr);
			else
				return query(rc, mid + 1, r, ql, qr);
		}

		void modify(int x, int l, int r, int ql, int qr, const Tag &t) {
			if (ql > qr)
				return;
			if (ql <= l && r <= qr) 
				return apply(x, t, r - l + 1);
			push(x, l, r);
			if (ql <= mid)
				modify(lc, l, mid, ql, qr, t);
			if (mid < qr)
				modify(rc, mid + 1, r, ql, qr, t);
			pull(x);
		}

		void change(int x, int l, int r, int pos, const Node &k) {
			if (l == r)
				return dat[x] = k, void();
			push(x, l, r);
			if (pos <= mid)
				change(lc, l, mid, pos, k);
			else
				change(rc, mid + 1, r, pos, k);
			pull(x);
		} 

		#undef lc
		#undef rc
		#undef mid
	};
}

struct Tag {
	array<i64, 2> info;

	void clear() {
		info = { 1, 1 };
	}

	void apply(const Tag &o) {
		for (int i = 0; i < 2; i ++)
			(info[i] *= o.info[i]) %= P;
	}

	operator bool () const {
		return info[0] != 1 || info[1] != 1;
	}
};

struct Node {
	array<i64, 2> info;

	void apply(const Tag &o, int sze) {
		for (int i = 0; i < 2; i ++)
			(info[i] *= o.info[i]) %= P;
	}

	void init(int p) {
		info = { 1, 1 };
	}
};

Node operator + (const Node &lhs, const Node &rhs) {
	return { { (lhs.info[0] + rhs.info[0]) % P, (lhs.info[1] + rhs.info[1]) % P } };
}

LazySegmentTree::LazyTagSegTree<Node, Tag> segt;

char op[1000];

void add(int x, int y) {
	G[x].push_back(y);
	G[y].push_back(x);
}

void dfs1(int x, int _fa) {
	sze[x] = 1, fa[x] = _fa;
	for (int y : G[x]) if (y != _fa) {
		dep[y] = dep[x] + 1;
		dfs1(y, x);
		sze[x] += sze[y];
		if (!son[x] || sze[son[x]] < sze[y])
			son[x] = y;
	}
}

void dfs2(int x, int tp) {
	top[x] = tp, dfn[x] = ++ cnt, id[cnt] = x;
	if (son[x])
		dfs2(son[x], tp);
	for (int y : G[x]) if (fa[x] != y && y != son[x])
		dfs2(y, y);
}

int get_lca(int x, int y) {
	while (top[x] != top[y]) {
		if (dep[top[x]] < dep[top[y]])
			swap(x, y);
		x = fa[top[x]];
	}
	return dep[x] < dep[y] ? x : y;
}

int kth(int x, int to) {
	while (dep[top[x]] > to) {
		x = fa[top[x]];
	}
	return id[dfn[x] - dep[x] + to];
}

void update(int x, const array<i64, 2> &info) {
	while (x) {
		segt.modify(1, 1, n, dfn[top[x]], dfn[x], { info });
		x = fa[top[x]];
	}
}

void solve() {
	cin >> n;
	for (int i = 1, x, y; i < n; i ++) {
		cin >> x >> y;
		add(x, y);
	}
	dep[1] = 1;
	dfs1(1, 0);
	dfs2(1, 1);
	segt.build(1, 1, n);
	int q; cin >> q;
	while (q --) {
		int x, y; 
		cin >> op >> x >> y;
		i64 val = 2, ival = INV2;
		if (op[0] == '-')
			swap(val, ival);
		int lca = get_lca(x, y);
		update(x, { val, val });
		update(y, { val, val });
		update(lca, { ival, ival * ival % P });
		update(fa[lca], { ival, 1 });
		cout << (segt.dat[1].info[0] - segt.dat[1].info[1] + P) % P << "\n";
	}
}

}
bool edB;
signed main() {
	// cerr << "Memory: " << (&stB - &edB) / 1024.0 / 1024.0 << "MB\n";
	ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
	SOL::solve();
	return 0;
}