#include<cstdio>

#include<vector>

#include<algorithm>

using namespace std;

const int MAXN = 1e5 + , B = , INF = ;

inline int read() {

    char c = getchar(); int x = , f = ;

    while(c < '' || c > '') {if(c == '-') f = -; c = getchar();}

    while(c >= '' && c <= '') x = x *  + c - '', c = getchar();

    return x * f;

}

int N, M, root = ;

int a[MAXN], b[MAXN];

vector<int> v[MAXN];

int fa[MAXN], top[MAXN], jump[MAXN][], deep[MAXN], siz[MAXN], l[MAXN], r[MAXN], tot = , cnt, son[MAXN], ID[MAXN];

void dfs1(int x, int _fa) {

    fa[x] = _fa; siz[x] = ; l[x] = ++cnt;

    jump[x][] = fa[x];

    for(int i = ; i < v[x].size(); i++) {

        int to = v[x][i];

        if(deep[to]) continue;

        deep[to] = deep[x] + ;

        dfs1(to, x);

        siz[x] += siz[to];

        if(siz[to] > siz[son[x]]) son[x] = to;

    }

    r[x] = cnt;

}

void dfs2(int x, int topf) {

    top[x] = topf; ID[x] = ++tot; a[tot] = b[x];

    l[x] = tot;

    if(!son[x]) {r[x] = tot; return ;}

    dfs2(son[x], topf);

    for(int i = ; i < v[x].size(); i++) {

        int to = v[x][i];

        if(top[to]) continue;

        dfs2(to, to);

    }

    r[x] = tot;

}

void Pre() {

    for(int i = ; i <= B; i++)

        for(int j = ; j <= N; j++)

            jump[j][i] = jump[jump[j][i - ]][i - ];

}

#define ls k << 1

#define rs k << 1 | 1

struct Node {

    int l, r, mi, si, tag;

}T[MAXN * ];

void update(int k) {T[k].mi = min(T[ls].mi, T[rs].mi);}

void ps(int k, int val) {T[k].mi = val; T[k].tag = val; return ;}

void pushdown(int k) {

    if(!T[k].tag) return;

    ps(ls, T[k].tag); ps(rs, T[k].tag);

    T[k].tag = ;

}

void Build(int k, int ll, int rr) {

    T[k].l = ll; T[k].r = rr; T[k].si = r - l + ;

    if(ll == rr) {T[k].mi = a[ll]; return ;}

    int mid = ll + rr >> ;

    Build(ls, ll, mid); Build(rs, mid + , rr);

    update(k);

}

void IntervalMem(int k, int ll, int rr, int val) {

    if(ll <= T[k].l && T[k].r <= rr) {

        T[k].mi = T[k].tag = val;

        return;

    }

    pushdown(k);

    int mid = T[k].l + T[k].r >> ;

    if(ll <= mid) IntervalMem(ls, ll, rr, val);

    if(rr >  mid) IntervalMem(rs, ll, rr, val);

    update(k);

}

void TreeChange(int x, int y, int val) {

    while(top[x] != top[y]) {

        if(deep[top[x]] < deep[top[y]]) swap(x, y);

        IntervalMem(, ID[top[x]], ID[x], val);

        x = fa[top[x]];

    }

    if(deep[x] < deep[y]) swap(x, y);

    IntervalMem(, ID[y], ID[x], val);

}

int IntervalMin(int k, int ll, int rr) {

    int ans = INF;

    if(ll <= T[k].l && T[k].r <= rr) return T[k].mi;

    pushdown(k);

    int mid = (T[k].l + T[k].r) >> ;

    if(ll <= mid) ans = min(ans, IntervalMin(ls, ll, rr));

    if(rr >  mid) ans = min(ans, IntervalMin(rs, ll, rr));

    return ans;

}

int LCA(int x, int y) {

    while(top[x] != top[y]) {

        if(deep[top[x]] < deep[top[y]]) swap(x, y);

        x = fa[top[x]];

    }

    if(deep[x] < deep[y]) swap(x, y);

    return y;

}

int Find(int rt, int x) {

    for(int i = B; i >= ; i--)

        while(deep[jump[rt][i]] > deep[x])

            rt = jump[rt][i];

    return rt;

}

int Query(int x) {

    if(x == root) return T[].mi;

    int lca = LCA(x, root);

    if(lca != x) return IntervalMin(, l[x], r[x]);

    int v = Find(root, x), ans = INF;

    if(l[v] > ) ans = min(ans, IntervalMin(, , l[v] - ));//tag

    if(r[v] < N) ans = min(ans, IntervalMin(, r[v] + , tot));

    return ans;

}

int main() {

    N = read(); M = read();

    for(int i = ; i <= N - ; i++) {

        int x = read(), y = read();

        v[x].push_back(y); v[y].push_back(x);

    }

    for(int i = ; i <= N; i++) b[i] = read();

    root = read();

    deep[] = ;

    dfs1(, );

    dfs2(, );

    Pre();

    Build(, , tot);

    while(M--) {

        int opt = read();

        if(opt == ) root = read();

        else if(opt == ){

            int x1 = read(), x2 = read(), v = read();

            TreeChange(x1, x2, v);

        } else {

            int x = read();

            printf("%d\n", Query(x));

        }

    }

    return ;

} 

/*

3 7

1 2

1 3

1 2 3

1

3 1

2 1 1 6

3 1

2 2 2 5

3 1

2 3 3 4

3 1

*/