#pragma comment(linker, "/STACK:1024000000,1024000000")
#include <cstdio>
#include <memory>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <vector>
#include <cassert>
#include <string>
#include <ctime>
#include <map>
#include <queue>
#include <algorithm>
#include <iostream>
#include <cassert>
#include <set>
using namespace std;
#define REP(i,n) for(int i=0;i<n;i++)
#define rep(i,a,b) for(int i=a;i<=b;i++)
#define req(i,a,b) for(int i=a;i>=b;i--)
#define rp(i,a) for(int i=head[a];i+1;i=edge[i].next)
#define cl(a,b) memset(a,b,sizeof a);
#define ll long long
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1
#define mod 10007
const int inf = ~0u >> 2;
const ll INF = (1LL << 62) - 1;
double eps = 1e-12;
const int N = 300005 + 5;
const int M = 300005;
int n, m, d;
class Lct {
public:
Lct() {}
~Lct() {}
struct Node {
int value, size, add, reverse, mx;
Node *parent, *child[2];
}_nil, *node[N];
public:
void Init() {
nil = new Node;
nil->child[0] = nil->child[1] = nil;
nil->size = 0;
nil->parent = nil;
nil->mx = -(inf << 1) - 2;
nil->add = 0;
nil->value = -(inf << 1) - 2;
nil->reverse = 0;
Root = nil;
//nil->
//Insert(-(inf<<1)-2);
//Insert((inf<<1)+1);
//Insert(0);
//Insert(n + 1);
}
bool IsRoot(Node *x) {
if (x == nil)
return true;
if (x->parent->child[0] == x || x->parent->child[1] == x)
return false;
return true;
}
void update(Node *x) {
/*if (x == nil)
return;*/
x->mx = max(x->value, max(x->child[0]->mx, x->child[1]->mx));
//x->size = x->child[0]->size + x->child[1]->size + 1;
}
void down(Node *x) {
if (x == nil)return;
if (x->reverse) {
if (x->child[0] != nil) {
x->child[0]->reverse ^= 1;
}
if (x->child[1] != nil) {
x->child[1]->reverse ^= 1;
}
swap(x->child[0], x->child[1]);
x->reverse = 0;
}
if (x->add) {
if (x->child[0] != nil) {
x->child[0]->value += x->add;
x->child[0]->mx += x->add;
x->child[0]->add += x->add;
}
if (x->child[1] != nil) {
x->child[1]->value += x->add;
x->child[1]->mx += x->add;
x->child[1]->add += x->add;
}
x->add = 0;
}
}
void Rotate(Node *x, int dir) {
if (IsRoot(x))return;
Node * p = x->parent;
if (p->parent->child[0] == p)
{
p->parent->child[0] = x;
}
else if (p->parent->child[1] == p) {
p->parent->child[1] = x;
}
x->parent = p->parent;
p->child[dir ^ 1] = x->child[dir];
p->child[dir ^ 1]->parent = p;
x->child[dir] = p;
p->parent = x;
update(p);
update(x);
/*if (Root == p) {
Root = x;
}*/
}
void Splay(Node *x) {
static Node *sta[N];
int top = 0;
sta[top++] = x;
for (Node *y = x; !IsRoot(y); y = y->parent)
sta[top++] = y->parent;
while (top)down(sta[--top]);
while (!IsRoot(x)) {
if (IsRoot(x->parent)) {
if (x->parent->child[0] == x) {
Rotate(x, 1);
}
else {
Rotate(x, 0);
}
}
else if (x->parent->parent->child[0] == x->parent) {
if (x->parent->child[0] == x) {
Rotate(x->parent, 1);
Rotate(x, 1);
}
else {
Rotate(x, 0);
Rotate(x, 1);
}
}
else {
if (x->parent->child[1] == x) {
Rotate(x->parent, 0);
Rotate(x, 0);
}
else {
Rotate(x, 1);
Rotate(x, 0);
}
}
update(x);
}
}
Node *NewNode(Node *x, int val) {
x = new Node;
x->parent = nil;
x->value = val;
x->size = 1;
x->add = 0;
x->mx = val;
x->reverse = 0;
x->child[0] = x->child[1] = nil;
return x;
}
void dfs(Node *u) {
if (u->child[0] != nil)
dfs(u->child[0]);
printf(" %d", u->value);
if (u->child[1] != nil)
dfs(u->child[1]);
}
//void Insert(int u,int val){
// if (Root == nil) {
// Root = NewNode(nil, val);
// return;
// }
// Node *x=Root;
// while (x->child[val>=x->value]!=nil) {
// x = x->child[val>=x->value];
// }
// Node *t = NewNode(x,val);
// node[u] = t;
// x->child[val >= x->value] = t;
// update(x);
// Splay(t, nil);
///* printf("dfs:");
// dfs(Root);
// printf("\n");*/
//}
//void Remove(int val) {
// int rnk = FindValRank(val);
// FindRankTo(rnk - 1, nil);
// FindRankTo(rnk + 1, Root);
// Root->child[1]->child[0] = nil;
// update(Root->child[1]);
// update(Root);
//}
//int FindValRank(int val) {
// Node *x = Root;
// int sum = 0;
// while (x->child[val >= x->value]!=nil) {
// if (x->value == val)
// return sum + 1 + x->child[0]->size;
// if (val >= x->value) {
// sum += x->child[0]->size+1;
// }
// x = x->child[val >= x->value];
// }
// return sum+1+x->child[0]->size;
//}
//void FindRankTo(int rnk, Node *y) {
// Node *x = Root;
// while (x!=nil) {
// if (rnk == x->child[0]->size+1)
// {
// Splay(x, y);
// return;
// }
// if (rnk > x->child[0]->size) {
// rnk -= x->child[0]->size + 1;
// x = x->child[1];
// }
// else
// x = x->child[0];
// }
//}
//int FindRoot(int x) {
//}
/*int FindRankVal(int k) {
FindRankTo(k, nil);
return Root->value;
}*/
Node *Access(Node *x) {
Node *y = x;
x = nil;
while (y != nil) {
Splay(y);
//y->child[1]->parent = y;
y->child[1] = x;
x->parent = y;
update(y);
x = y;
y = y->parent;
}
return x;
}
//Node *FindRoot(Node *x) {
// Access(x);
// Splay(x);
// while (x->child[0] != nil)x = x->child[0];
// Splay(x);
// return x;
//}
void Cut(Node *x) {
//ChangeRoot(x->parent);
/*Access(x);
Splay(x);
x->reverse ^= 1;*/
ChangeRoot(x);
x->child[0]->parent = nil;
x->child[0] = nil;
update(x);
}
void Link(Node *x, Node *y) {
//printf("%d %d#\n", x->value, y->value);
/*Access(x);
Splay(x);
x->reverse ^= 1;*/
ChangeRoot(x);
x->parent = y;
//Access(x);
//
}
void ChangeRoot(Node *x) {
Access(x);
Splay(x);
x->reverse ^= 1;
}
void AddVal(Node *x, Node *y, int val) {
ChangeRoot(y);
ChangeRoot(x);
//Node *u = Access(x);
//Node *u = BecomeRoot(x);
/*Cut(y->child[1]);
while (y->child[0] != x)y = y->child[0];
Cut(x->child[0]);*/
//Access(x);
x->value += val;
x->add += val;
x->mx += val;
}
int QueryMaxVal(Node *x, Node *y) {
ChangeRoot(y);
ChangeRoot(x);
//Node *u = Access(x);
//BecomeRoot(x);
return x->mx;
/*Cut(y->child[1]);
while(y->child[0])*/
}
bool IsSameTree(Node *u, Node *v) {
while (u->parent != nil)u = u->parent;
while (v->parent != nil)v = v->parent;
return u == v;
}
public:
int w[N];
Node *Root, *nil;
};
struct Seg {
int l, r, k, index;
bool operator < (const Seg & rhs)const {
return r < rhs.r;
}
}seg[M];
Lct lct;
//SplayTree spt;
int ans[M];
void printErr() {
printf("-1\n");
}
int nd1[N], nd2[N];
int main() {
int n;
while (scanf("%d",&n)!=-1) {
lct.Init();
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
//g[u].push_back(v);
nd1[i] = u;
nd2[i] = v;
}
for (int i = 1; i <= n; i++) {
scanf("%d", &lct.w[i]);
lct.node[i] = lct.NewNode(lct.node[i], lct.w[i]);
}
for (int i = 1; i < n; i++)
lct.Link(lct.node[nd1[i]], lct.node[nd2[i]]);
/*for (int i = 1; i <= n; i++)
for (int j = 0; j < g[i].size(); j++)
lct.Link(lct.node[i], lct.node[g[i][j]]);*/
//for (int i = 1; i <= n; i++) {
// if (lct.IsRoot(lct.node[i])) {
// printf("Root :%d", i);
// lct.dfs(lct.node[i]);
// printf("\n");
// }
//}
scanf("%d", &m);
while (m--) {
int op;
scanf("%d", &op);
if (op == 1) {
int x, y;
scanf("%d%d", &x, &y);
if (lct.IsSameTree(lct.node[x], lct.node[y])) {
printErr();
continue;
}
lct.Link(lct.node[x], lct.node[y]);
}
if (op == 2) {
int x, y;
scanf("%d%d", &x, &y);
if (x==y||!lct.IsSameTree(lct.node[x], lct.node[y])) {
printErr();
continue;
}
lct.ChangeRoot(lct.node[x]);
lct.Cut(lct.node[y]);
}
if (op == 3) {
int w, x, y;
scanf("%d%d%d", &w, &x, &y);
if (!lct.IsSameTree(lct.node[x], lct.node[y])) {
printErr();
continue;
}
lct.AddVal(lct.node[x], lct.node[y], w);
}
if (op == 4) {
int x, y;
scanf("%d%d", &x, &y);
if (!lct.IsSameTree(lct.node[x], lct.node[y])) {
printErr();
continue;
}
printf("%d\n", lct.QueryMaxVal(lct.node[x], lct.node[y]));
}
}
printf("\n");
}
return 0;
}
