#include<bits/stdc++.h>

using namespace std;

#define MAXN 100010

struct Node

{

        int l , r;

        bool flg;

} Tree[MAXN << ];

struct edge

{

        int to , nxt;

} e[MAXN << ];

int n , q , timer , tot;

int size[MAXN],top[MAXN],dfn[MAXN],head[MAXN],son[MAXN],father[MAXN],rev[MAXN];

template <typename T> inline void chkmax(T &x,T y) { x = max(x,y); }

template <typename T> inline void chkmin(T &x,T y) { x = min(x,y); }

template <typename T> inline void read(T &x)

{

    T f = ; x = ;

    char c = getchar();

    for (; !isdigit(c); c = getchar()) if (c == '-') f = -f;

    for (; isdigit(c); c = getchar()) x = (x << ) + (x << ) + c - '';

    x *= f;

}

inline void addedge(int u,int v)

{

        tot++;

        e[tot] = (edge){v,head[u]};

        head[u] = tot;

}

inline void dfs1(int u)

{

        size[u] = ;

        for (int i = head[u]; i; i = e[i].nxt)

        {

                int v = e[i].to;

                if (v == father[u]) continue;

                father[v] = u;

                dfs1(v);

                size[u] += size[v];

                if (size[v] > size[son[u]]) son[u] = v;

        }

}

inline void dfs2(int u,int tp)

{

        dfn[u] = ++timer;

        rev[timer] = u;

        top[u] = tp;

        if (son[u]) dfs2(son[u],tp);

        for (int i = head[u]; i; i = e[i].nxt)

        {

                int v = e[i].to;

                if (v != son[u] && v != father[u]) dfs2(v,v);

        }

}

inline void update(int index)

{

        Tree[index].flg = Tree[index << ].flg | Tree[index <<  | ].flg;

}

inline void build(int index,int l,int r)

{

        Tree[index].l = l;

        Tree[index].r = r;

        Tree[index].flg = false;

        if (l == r)

        {

                if (l == ) Tree[index].flg = true;

                return;

        }

        int mid = (l + r) >> ;

        build(index << ,l,mid);

        build(index <<  | ,mid + ,r);

        update(index);

}

inline void modify(int index,int pos)

{

        if (Tree[index].l == Tree[index].r)

        {

                Tree[index].flg = true;

                return;

        }

        int mid = (Tree[index].l + Tree[index].r) >> ;

        if (mid >= pos) modify(index << ,pos);

        else modify(index <<  | ,pos);

        update(index);

}

inline int query(int index,int l,int r)

{

        if (!Tree[index].flg) return ;

        if (Tree[index].l == Tree[index].r) return l;

        int mid = (Tree[index].l + Tree[index].r) >> ;

        if (mid >= r) return query(index << ,l,r);

        else if (mid +  <= l) return query(index <<  | ,l,r);

        else

        {

                int tmp = query(index <<  | ,mid + ,r);

                if (tmp == ) tmp = query(index << ,l,mid);

                return tmp;

        }

}

int main()

{

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

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

        {

                int u , v;

                scanf("%d%d",&u,&v);

                addedge(u,v);

                addedge(v,u);

        }

        dfs1();

        dfs2(,);

        build(,,n);

        while (q--)

        {

                char op[];

                int x;

                scanf("%s%d",&op,&x);

                if (op[] == 'Q')

                {

                        int tx = top[x] , pos = ;

                        while (true)

                        {

                                pos = query(,dfn[tx],dfn[x]);

                                if (pos != ) break;

                                x = father[tx]; tx = top[x];

                        }

                        printf("%d\n",rev[pos]);

                } else modify(,dfn[x]);

        }

        return ;

}