#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for (int i = 0; i< (n); ++i)
#define repi(i, a, b) for (int i = (a); i < (b); ++i)
#define all(x) (x).begin(), (x).end()
#define fore(i, a) for(auto &i:a)
using ll = long long;
#include<atcoder/lazysegtree>
using namespace atcoder;
#include<atcoder/modint>
using mint = modint1000000007;
class HLdecomposition{
	private:
		int V;
		vector<vector<int> > G;
		vector<int> stsize, parent, pathtop, in, out;
		int root;
		void BuildStsize(int u, int p){
			stsize[u] = 1, parent[u] = p;
			for(int& v : G[u]){
				if(v == p){
					if(v == G[u].back()) break;
					else swap(v, G[u].back());
				}
				BuildStsize(v, u);
				stsize[u] += stsize[v];
				if(stsize[v] > stsize[G[u][0]]){
					swap(v, G[u][0]);
				}
			}
		}
		void BuildPath(int u, int p, int& tm){
			in[u] = tm++;
			for(int v : G[u]){
				if(v == p) continue;
				pathtop[v] = (v == G[u][0] ? pathtop[u] : v);
				BuildPath(v, u, tm);
			}
			out[u] = tm;
		}

	public:
		int getter(int u){
			return in[u];
		}
		void add_edge(int u, int v){
			G[u].push_back(v), G[v].push_back(u);
		}
		void build(int _root=0){
			root = _root;
			int tm = 0;
			BuildStsize(root, -1);
			pathtop[root] = root;
			BuildPath(root, -1, tm);
		}
		//元の頂点のインデックスの配列上でのidを返す
		inline int get(int a){
			return in[a];
		}
		int lca(int a, int b){
			int pa = pathtop[a], pb = pathtop[b];
			while(pathtop[a] != pathtop[b]){
				if(in[pa] > in[pb]){
					a = parent[pa], pa = pathtop[a];
				}else{
					b = parent[pb], pb = pathtop[b];
				}
			}
			if(in[a] > in[b]) swap(a, b);
			return a;
		}
		void subtree_query(int a, const function< void(int, int) > &func){
			func(in[a], out[a]);
		}
		// 例: hl.path_query(q, r, [&](int l, int r){ seg.range(l, r, s); })
		// 例: hl.query(q, r, [&](int l, int r){ ans += seg.query(l, r); })
		void path_query(int a, int b, const function< void(int, int) > &func){
			int pa = pathtop[a], pb = pathtop[b];
			while(pathtop[a] != pathtop[b]){
				if(in[pa] > in[pb]){
					func(in[pa], in[a] + 1);
					a = parent[pa], pa = pathtop[a];
				}else{
					func(in[pb], in[b] + 1);
					b = parent[pb], pb = pathtop[b];
				}
			}
			if(in[a] > in[b]) swap(a, b);
			func(in[a], in[b] + 1);
		}
		HLdecomposition(int node_size) : V(node_size), G(V), stsize(V, 0), parent(V, -1),
		pathtop(V, -1), in(V, -1), out(V, -1){}
};
struct D{
	mint value;
	mint sum;
};
D op(D a, D b){
	return D{a.value+b.value, a.sum+b.sum};
}
D e(){
	return D{0, 0};
}
struct F{
	mint value;
};
D mapping(F f,D x){
	return D{x.value+x.sum*f.value, x.sum};
}
F composition(F f,F g){
	return F{f.value+g.value};
}
F id(){
	return F{0};
}
int main() {
	ll n;
	cin >> n;
	vector<mint> S(n), C(n);
	rep(i, n){
		ll ss; cin >> ss;
		S[i] = ss;
	}
	rep(i, n){
		ll cc; cin >> cc;
		C[i] = cc;
	}
	HLdecomposition tree(n);
	rep(i, n-1){
		ll a, b;cin >> a >> b;
		a--;b--;
		tree.add_edge(a, b);
	}
	tree.build();
	ll q; cin >> q;
	vector<tuple<ll,ll,ll,ll>> qs(q);
	rep(i, q){
		ll t, x, y, z;
		cin >> t;
		if(t == 0){
			cin >> x >> y >> z;
		}
		else{
			cin >> x >> y;
			z = -1;
		}
		x--;y--;
		qs[i] = {t, x, y, z};
	}
	vector<D> vec(2*n);
	rep(i, n){
		vec[tree.get(i)] = D{S[i], C[i]};
	}
  lazy_segtree<D,op,e,F,mapping,composition,id> seg(vec);
	rep(i, q){
		auto[t, x, y, z] = qs[i];
		if(t == 0){
      auto ff = [&](int l, int r){
				seg.apply(l, r, F{(mint)z});
			};
			tree.path_query(x, y, ff);
		}
		else{
			mint ans=0;
			auto ff = [&](int l, int r){
				ans += seg.prod(l, r).value;
			};

			tree.path_query(x, y, ff);
			cout << ans.val() << endl;
		}

	}


	
}