//date 20140521

 #include <cstdio>

 #include <cstring>

 const int maxn = ;

 const int INF = 0x7FFFFFFF;

 template <typename T> inline void swap(T &a, T &b){T x = a; a = b; b = x;}

 inline int innew(int &a, int b){if(a < b){a = b; return ;} return ;}

 inline int denew(int &a, int b){if(a > b){a = b; return ;} return ;}

 inline int min(int a, int b){return a < b ? a : b;}

 inline int getint()

 {

     int ans(); char w = getchar();

     while(w < '' || '' < w) w = getchar();

     while('' <= w && w <= '')

     {

         ans = ans *  + w - '';

         w = getchar();

     }

     return ans;

 }

 int n, m, root;

 struct edge

 {

     int v, next;

 }E[maxn << ];

 int nedge, a[maxn], num[maxn];

 inline void add(int u, int v)

 {

     E[++nedge].v = v;

     E[nedge].next = a[u];

     a[u] = nedge;

 }

 int dpt[maxn], p[maxn], size[maxn], hp[maxn], hs[maxn];

 int order[maxn], ps[maxn], ped[maxn];

 inline void dfs_one(int v0)

 {

     static int d[maxn], now[maxn];

     int last, i, j;

     memcpy(now, a, sizeof a);

     d[last = dpt[v0] = size[v0] = ] = v0;

     while(last)

     {

         if(!(j = now[i = d[last]]))

         {

             if((--last) && (size[d[last]] += size[i], size[hs[d[last]]] < size[i]))

                 hs[d[last]] = i;

             continue;

         }

         if(p[i] != E[j].v) dpt[d[++last] = E[j].v] = dpt[p[E[j].v] = i] + (size[E[j].v] = );

         now[i] = E[j].next;

     }

 }

 inline void dfs_two(int v0)

 {

     static int d[maxn], now[maxn];

     int last, i, j, tot;

     d[last = ] = order[ps[v0] = ped[v0] = tot = ] = v0;

     memset(now, 0xFF, sizeof now);

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

     while(last)

     {

         if(!(j = now[i = d[last]]))

         {

             if(--last) innew(ped[d[last]], ped[i]);

             continue;

         }

         if(j == -)

         {

             if(hs[i]) hp[d[++last] = order[ps[hs[i]] = ped[hs[i]] = ++tot] = hs[i]] = hp[i];

             now[i] = a[i]; continue;

         }

         if(E[j].v != hs[i] && E[j].v != p[i]) d[++last] = order[ps[E[j].v] = ped[E[j].v] = ++tot] = E[j].v;

         now[i] = E[j].next;

     }

 }

 struct Segment_Tree

 {

     struct node

     {

         node *s[];

         int l, r, Min, cov;

         node(){}

         int cover(int v){Min = v; cov = ;}

         void pushdown()

         {

             if(cov && l < r){s[]->cover(Min); s[]->cover(Min);}

             cov = ;

         }

         void update(){ Min = min(s[]->Min, s[]->Min);}

     }*root, pond[maxn << ];

     int stop;

     void change(node *p, int l, int r, int v)

     {

         if(l <= p->l && p->r <= r){p->cover(v); return;}

         p->pushdown();

         int mid = (p->l + p->r) >> ;

         if(l <= mid) change(p->s[], l, r, v);

         if(r >  mid) change(p->s[], l, r, v);

         p->update();

     }

     int query(node *p, int l, int r)

     {

         if(l <= p->l && p->r <= r){return p->Min;}

         p->pushdown();

         int mid = (p->l + p->r) >> ;

         int ans = INF;

         if(l <= mid) denew(ans, query(p->s[], l, r));

         if(r >  mid) denew(ans, query(p->s[], l, r));

         return ans;

     }

     node *build(int l, int r)

     {

         node *p = &pond[stop++];

         p->s[] = p->s[] = NULL; p->cov = ; p->l = l; p->r = r;

         if(l == r) {p->Min = num[order[l]]; return p;}

         int mid = (l + r) >> ;

         p->s[] = build(l, mid);

         p->s[] = build(mid + , r);

         p->update();

         return p;

     }

     void preset(){stop = ; root = build(, n);}

     int get_min(int l, int r)

     {

         if(l > r) swap(l, r);

         return query(root, l, r);

     }

     void change(int l, int r, int v)

     {

         if(l > r) swap(l, r);

         change(root, l, r, v);

     }

 }MEOW;

 inline void reroot(int r){root = r;}

 inline void change(int x, int y, int v)

 {

     int x0 = x, y0 = y;

     while(hp[x0] != hp[y0])

     {

         if(dpt[hp[x0]] > dpt[hp[y0]])

         {

             MEOW.change(ps[hp[x0]], ps[x0], v);

             x0 = p[hp[x0]];

         }else{

             MEOW.change(ps[hp[y0]], ps[y0], v);

             y0 = p[hp[y0]];

         }

     }

     MEOW.change(ps[x0], ps[y0], v);

 }

 inline int query(int x)

 {

     if(x == root) return MEOW.root->Min;

     int x0 = x, r = root, sgn = , tp = ;

     if(hp[x0] == hp[r] && dpt[r] > dpt[x]) sgn = ;

     while(hp[x0] != hp[r])

     {

         if(dpt[hp[x0]] > dpt[hp[r]]) {sgn = ; break;}

         if(p[hp[r]] == x0) tp = hp[r];

         sgn = ; r = p[hp[r]];

     }

     if(dpt[r] < dpt[x]) sgn = ;

     if(sgn) return MEOW.get_min(ps[x], ped[x]);

     if(r != x0) tp = hs[x0];

     int ans = MEOW.get_min(, ps[tp] - );

     if(ped[tp] != n) denew(ans, MEOW.get_min(ped[tp] + , n));

     return ans;

 }

 int main()

 {

     freopen("bzoj.in", "r", stdin);

     freopen("bzoj.out", "w", stdout);

     n = getint(); m = getint();

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

     {

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

         add(x, y); add(y, x);

     }

     for(int i = ; i <= n; ++i) num[i] = getint() - ;

     root = getint();

     dfs_one(root); dfs_two(root);

     MEOW.preset();

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

     {

         int k, x, y, v;

         k = getint();

         switch(k)

         {

             case : x = getint(); reroot(x); break;

             case : x = getint(); y = getint(); v = getint() - ; change(x, y, v); break;

             case : x = getint(); printf("%u\n", (unsigned)query(x) + 1u); break;

         }

     }

     return ;

 }