#include <cstdio>

#include <cstring>

#include <cstdlib>

#include <algorithm>

#define lson l, mid, rt << 1

#define rson mid + 1, r, rt << 1 | 1

using namespace std;

typedef long long ll;

typedef double dd;

const int maxn=;

const ll INF = (ll)1E14 + ;

int h[maxn], n, m, top[maxn], lca[maxn][], son[maxn], edge, sz[maxn], dep[maxn];

int L[maxn], R[maxn], root, num, x, y, tx, ty, t, opt;

ll val, a[maxn];

struct Edge {

    int to, ne;

} e[maxn * ];

struct Seg {

    ll minn, same;

} seg[maxn << ];

void close() {

    exit();

}

void addedge(int x,int y) {

    e[edge].to = y;

    e[edge].ne = h[x];

    h[x] = edge++;

}

void dfs(int k,int from) {

    sz[k] = ;

    dep[k] = dep[from] + ;

    son[k] = ;

    for (int p=h[k]; p!=-; p=e[p].ne) {

        int to = e[p].to;

        if (to == from) continue;

        lca[to][] = k;

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

            lca[to][i] = lca[lca[to][i-]][i-];

        dfs(to, k);

        sz[k] += sz[to];

        if (sz[to] > sz[son[k]]) son[k] = to;

    }

}

void build(int k,int from) {

    L[k] = ++num;

    top[k] = from;

    if (son[k]) build(son[k], from);

    for (int p=h[k]; p!=-; p=e[p].ne) {

        int to = e[p].to;

        if (to != lca[k][] && to != son[k])

            build(to, to);

    }

    R[k] = num;

}

int get_lca(int x,int y) {

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

    int depth = dep[x] - dep[y];

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

        if (depth & ( << i))

            x = lca[x][i];

    if (x == y) return x;

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

        if (lca[x][i] != lca[y][i]) {

            x = lca[x][i];

            y = lca[y][i];

        }

    }

    return lca[x][];

}

void pushup(int rt) {

    seg[rt].minn = min(seg[rt<<].minn, seg[rt<<|].minn);

}

void same(int rt,ll val) {

    seg[rt].minn = val;

    seg[rt].same = val;

}

void pushdown(int rt) {

    if (seg[rt].same) {

        same(rt << , seg[rt].same);

        same(rt <<  | , seg[rt].same);

        seg[rt].same = ;

    }

}

void change(int L,int R,ll val,int l,int r,int rt) {

    if (L <= l && r <= R) {

        same(rt, val);

        return;

    }

    int mid = (l + r) >> ;

    pushdown(rt);

    if (L <= mid)

        change(L,R,val,lson);

    if (mid +  <= R)

        change(L,R,val,rson);

    pushup(rt);

}

ll query(int L,int R,int l,int r,int rt) {

    if (L > R) return INF;

    if (L <= l && r <= R) {

        return seg[rt].minn;

    }

    int mid = (l + r) >> ;

    pushdown(rt);

    ll ans = INF;

    if (L <= mid)

        ans = min(ans, query(L,R,lson));

    if (mid +  <= R)

        ans = min(ans, query(L,R,rson));

    pushup(rt);

    return ans;

}

void cc() {

    tx = top[x];

    ty = top[y];

    while (tx != ty) {

        if (dep[tx] < dep[ty]) {

            swap(x, y);

            swap(tx, ty);

        }

        change(L[tx], L[x], val, , n, );

        x = lca[tx][];

        tx = top[x];

    }

    if (dep[x] < dep[y])

        swap(x, y);

    change(L[y], L[x], val, , n, );

}

void work() {

    if (root == x) {

        printf("%lld\n", seg[].minn);

        return;

    }

    t = get_lca(root, x);

    if (t != x) {

        printf("%lld\n", query(L[x], R[x], , n, ));

        return;

    }

    int depth = dep[root] - dep[x] - ;

    int haha = root;

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

        if (depth & ( << i))

            haha = lca[haha][i];

    printf("%lld\n", min(query(, L[haha] - , , n, ), query(R[haha] + , n, , n, )) );

}

void init() {

    scanf("%d %d",&n,&m);

    memset(h, -, sizeof(h));

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

        scanf("%d %d",&x, &y);

        addedge(x, y);

        addedge(y, x);

    }

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

        scanf("%lld",&a[i]);

    dfs(, );

    build(, );

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

        change(L[i], L[i], a[i], , n, );

    scanf("%d",&root);

    while (m--) {

        scanf("%d",&opt);

        if (opt == ) scanf("%d",&root);

        if (opt == ) {

            scanf("%d %d %lld",&x,&y,&val);

            cc();

        }

        if (opt == ) {

            scanf("%d",&x);

            work();

        }

    }

}

int main () {

    init();

    close();

    return ;

}