#include<cstdio>

#include<cstdlib>

#include<cctype>

#include<algorithm>

#include<cstring>

#define left (rt<<1)

#define right (rt<<1|1)

#define mid ((l+r)>>1)

#define lson l,mid,left

#define rson mid+1,r,right

#define maxn 100020

using namespace std;

inline long long read(){

    long long num=,f=;

    char ch=getchar();

    while(!isdigit(ch)){

        if(ch=='-')    f=-;

        ch=getchar();

    }

    while(isdigit(ch)){

        num=num*+ch-'';

        ch=getchar();

    }

    return num*f;

}

struct Edge{

    int next,to;

}edge[maxn*];

int head[maxn],num;

inline void add(int from,int to){

    edge[++num]=(Edge){head[from],to};

    head[from]=num;

}

int tree[maxn*];

int tag[maxn*];

int size[maxn];

int deep[maxn];

int son[maxn];

int father[maxn];

int top[maxn];

int dfn[maxn];

int back[maxn],ID;

int q[maxn];

int s[maxn][];

int n,m;

void find(int x,int fa){

    deep[x]=deep[fa]+;    size[x]=;

    for(int i=head[x];i;i=edge[i].next){

        int to=edge[i].to;

        if(to==fa)    continue;

        father[to]=x;

        s[to][]=x;

        find(to,x);

        size[x]+=size[to];

        if(son[x]==||size[son[x]]<size[to])    son[x]=to;

    }

}

void unionn(int x,int Top){

    dfn[x]=++ID;    back[ID]=x;

    top[x]=Top;

    if(!son[x])    return;

    unionn(son[x],Top);

    for(int i=head[x];i;i=edge[i].next){

        int to=edge[i].to;

        if(to==father[x]||to==son[x])    continue;

        unionn(to,to);

    }

}

inline void pushup(int rt){

    tree[rt]=min(tree[left],tree[right]);

}

void pushdown(int rt){

    if(tag[rt]==-)    return;

    tag[left]=tag[right]=tag[rt];

    tree[left]=tree[right]=tag[rt];

    tag[rt]=-;

    return;

}

void build(int l,int r,int rt){

    tag[rt]=-;

    if(l==r){

        tree[rt]=q[back[l]];

        return;

    }

    build(lson);

    build(rson);

    pushup(rt);

}

void memseg(int from,int to,int num,int l,int r,int rt){

    if(from<=l&&to>=r){

        tree[rt]=tag[rt]=num;

        //printf("%d %d l=%d r=%d %d\n",from,to,l,r,num);

        return;

    }

    pushdown(rt);

    if(from<=mid)    memseg(from,to,num,lson);

    if(to>mid)        memseg(from,to,num,rson);

    pushup(rt);

    return;

}

int query(int from,int to,int l,int r,int rt){

    if(from<=l&&to>=r)    return tree[rt];

    pushdown(rt);

    int ans=0x7fffffff;

    if(from<=mid)    ans=min(ans,query(from,to,lson));

    if(to>mid)        ans=min(ans,query(from,to,rson));

    return ans;

}

int root;

void update(int from,int to,int num){

    while(top[from]!=top[to]){

        if(deep[top[from]]<deep[top[to]])    swap(from,to);

        memseg(dfn[top[from]],dfn[from],num,,n,);

        from=father[top[from]];

    }

    if(deep[from]>deep[to])    swap(from,to);

    memseg(dfn[from],dfn[to],num,,n,);

    return;

}

int LCA(int from,int to){

    if(deep[from]<deep[to])    swap(from,to);

    int f=deep[from]-deep[to];

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

        if(f&(<<i))    from=s[from][i];

    if(from==to)    return from;

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

        if(s[from][i]==s[to][i])    continue;

        from=s[from][i];

        to=s[to][i];

    }

    return s[from][];

}

inline void prepare(){

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

        for(int i=;i<=n;++i)    s[i][j]=s[s[i][j-]][j-];

}

int ask(int o){

    if(root==)    return query(dfn[o],dfn[o]+size[o]-,,n,);

    int lca=LCA(root,o);

    if(lca!=o)    return query(dfn[o],dfn[o]+size[o]-,,n,);

    else{

        int now=root;

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

            if(deep[s[now][i]]>deep[o])    now=s[now][i];

        int ans=0x7fffffff;

        if(dfn[now]>)                ans=min(ans,query(,dfn[now]-,,n,));

        if(dfn[now]+size[now]<=n)    ans=min(ans,query(dfn[now]+size[now],n,,n,));

        return ans;

    }

}

int main(){

    n=read(),m=read();

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

        int from=read(),to=read();

        add(from,to);

        add(to,from);

    }

    for(int i=;i<=n;++i)    q[i]=read();

    root=read();

    find(,);

    unionn(,);

    build(,n,);

    prepare();

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

        int opt=read();

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

        else if(opt==){

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

            update(x,y,z);

        }

        else{

            int x=read();

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

        }

    }

    return ;

}

/*

10 10

1 2

2 3

2 4

1 5

5 6

5 10

5 7

7 8

7 9

5 1 2 3 6 4 7 8 9 10

1

*/