#include <bits/stdc++.h>
#define MOD 1000000007LL
using namespace std;
typedef long long ll;
typedef pair<int,int> P;

ll extgcd(ll a,ll b,ll& x,ll& y){
	ll d=a;
	if(b!=0LL){
		d=extgcd(b,a%b,y,x);
		y-=(a/b)*x;
	}else{
		x=1;
		y=0;
	}
	return d;
}

ll mod_inverse(ll a,ll m){
	ll x,y;
	extgcd(a,m,x,y);
	return (m+x%m)%m;
}

typedef vector<ll> vec;
typedef vector<vec> mat;

mat mul(mat A,mat B){
	mat C(A.size(),vec(B[0].size()));
	for(int i=0;i<A.size();i++){
		for(int k=0;k<B.size();k++){
			for(int j=0;j<B[0].size();j++){
				C[i][j]=(C[i][j]+(A[i][k]*B[k][j]%MOD))%MOD;
			}
		}
	}
	return C;
}
int N;

class segtree{
public:
	vector<mat> dp;
	mat ta;
	segtree(){
		ta.push_back(vec());
		ta.push_back(vec());
		ta[0].resize(2);
		ta[1].resize(2);
		ta[0][0]=1;
		ta[0][1]=0;
		ta[1][0]=0;
		ta[1][1]=1;
	}
	void init(int n){
		dp.clear();
		N=1;
		while(N<n){
			N*=2;
		}
		for(int i=0;i<N*2;i++){
			dp.push_back(mat());
			dp[i].push_back(vec());
			dp[i].push_back(vec());
			dp[i][0].resize(2);
			dp[i][1].resize(2);
			dp[i][0][0]=1;
			dp[i][0][1]=0;
			dp[i][1][0]=0;
			dp[i][1][1]=1;
		}
	}
	void update(int k,mat v){
		k+=N-1;
		dp[k]=v;
		while(k>0){
			k=(k-1)/2;
			dp[k]=mul(dp[k*2+1],dp[k*2+2]);
		}
	}

	mat query(int a,int b,int k=0,int l=0,int r=N){
		if(b<=l || r<=a)return ta;
		if(a<=l && r<=b)return dp[k];
		int mid=(l+r)/2;
		mat vl=query(a,b,k*2+1,l,mid);
		mat vr=query(a,b,k*2+2,mid,r);
		return mul(vl,vr);
	}
};

int n,q;

mat val[100001];
mat sum[100001];
vector<int> G[100001];
int depth[100001];
int siz[100001];
int hlsize=0;
vector<int> hls[100001];
int which[100001][2];
int parent[100001];
segtree seg[100001];

int dfs(int v,int p,int c){
	depth[v]=c;
	sum[v]=mul(sum[v],val[v]);
	int cnt=1;
	for(int i=0;i<G[v].size();i++){
		if(G[v][i]!=p){
			cnt+=dfs(G[v][i],v,c+1);
		}
	}
	return (siz[v]=cnt);
}

void constr(int v,int p,int id){
	which[v][0]=id;
	which[v][1]=hls[id].size();
	hls[id].push_back(v);

	int b=-1;
	for(int i=0;i<G[v].size();i++){
		if(G[v][i]!=p){
			if(b==-1){
				b=G[v][i];
			}else if(siz[G[v][i]]>siz[b]){
				b=G[v][i];
			}
		}
	}
	for(int i=0;i<G[v].size();i++){
		if(G[v][i]!=p){
			if(b==G[v][i]){
				constr(G[v][i],v,id);
			}else{
				parent[hlsize]=v;
				constr(G[v][i],v,hlsize++);
			}
		}
	}
}

int main(void){
	//printf("done\n");
	scanf("%d",&n);
	for(int i=0;i<n;i++){
		val[i].push_back(vec());
		val[i].push_back(vec());
		val[i][0].resize(2);
		val[i][1].resize(2);
		val[i][0][0]=1;
		val[i][0][1]=0;
		val[i][1][0]=0;
		val[i][1][1]=1;
		sum[i].push_back(vec());
		sum[i].push_back(vec());
		sum[i][0].resize(2);
		sum[i][1].resize(2);
		sum[i][0][0]=1;
		sum[i][0][1]=0;
		sum[i][1][0]=0;
		sum[i][1][1]=1;
	}
	for(int i=0;i<n-1;i++){
		int a,b;
		scanf("%d%d%*c",&a,&b);
		G[a].push_back(b);
		G[b].push_back(a);
	}
	scanf("%d%*c",&q);
	dfs(0,-1,0);
	hlsize++;
	constr(0,-1,0);
	//printf("done\n");
	for(int i=0;i<hlsize;i++){
		seg[i].init(hls[i].size());
	}
	
	for(int i=0;i<q;i++){
		char t;
		scanf("%c",&t);
		if(t=='x'){
			mat C(2,vec(2));
			int v;
			scanf("%d%d%d%d%d%*c",&v,&C[0][0],&C[0][1],&C[1][0],&C[1][1]);
			seg[which[v][0]].update(which[v][1],C);
		}else{
			int f,t;
			scanf("%d%d%*c",&f,&t);
			mat ans(2,vec(2));
			ans[0][0]=1;
			ans[0][1]=0;
			ans[1][0]=0;
			ans[1][1]=1;
			while(which[f][0]!=which[t][0]){
				ans=mul(seg[which[t][0]].query(0,which[t][1]+1),ans);
				t=parent[which[t][0]];
				//printf("%d ",t);
				//printf("%lld %lld %lld %lld\n",ans[0][0],ans[0][1],ans[1][0],ans[1][1]);
			}
			//sprintf("end\n");
			ans=mul(seg[which[f][0]].query(which[f][1],which[t][1]+1),ans);
			printf("%lld %lld %lld %lld\n",ans[0][0],ans[0][1],ans[1][0],ans[1][1]);
		}

	}
	return 0;
}