#include<bits/stdc++.h>

using namespace std;

const int N = 1e5 + ;

int rd()

{

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

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

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

    return x * f;

}

int n, sum, m, root;

int size[N], f[N], vis[N], val[N], dep[N], fa[N][], Fa[N];

vector<int> G[N];

struct Heap {

    priority_queue<int> A, B;

    void push(int x) { A.push(x); }

    void del(int x) { B.push(x); }

    int top()

    {

        while(!A.empty() && !B.empty() && A.top() == B.top()) A.pop(), B.pop();

        return A.top();

    }

    int sum()

    {

        int x = top();

        A.pop();

        int y = top();

        A.push(x);

        return x + y;

    }

    int size()

    {

        return A.size() - B.size();

    }

} s1[N], s2[N], s3;

void erase(Heap &s)

{

    if(s.size() > ) s3.del(s.sum());

}

void Insert(Heap &s)

{

    if(s.size() > ) s3.push(s.sum());

}

void dfs(int u, int last)

{

    for(int i = ; i < G[u].size(); ++i)

    {

        int v = G[u][i];

        if(v == last) continue;

        fa[v][] = u;

        dep[v] = dep[u] + ;

        dfs(v, u);

    }

}

int lca(int u, int v)

{

    if(dep[u] < dep[v]) swap(u, v);

    int d = dep[u] - dep[v];

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

        if(d & ( << i))

            u = fa[u][i];

    if(u == v) return u;

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

        if(fa[u][i] != fa[v][i])

            u = fa[u][i],

            v = fa[v][i];

    return fa[u][];

}

int getsize(int u, int last)

{

    int ret = ;

    for(int i = ; i < G[u].size(); ++i)

    {

        int v = G[u][i];

        if(v == last || vis[v]) continue;

        ret += getsize(v, u);

    }

    return ret;

}

void getroot(int u, int last, int S)

{

    f[u] = ;

    size[u] = ;

    for(int i = ; i < G[u].size(); ++i)

    {

        int v = G[u][i];

        if(v == last || vis[v]) continue;

        getroot(v, u, S);

        size[u] += size[v];

        f[u] = max(f[u], size[v]);

    }

    f[u] = max(f[u], S - size[u]);

    if(f[u] < f[root]) root = u;

}

void divide(int u)

{

    vis[u] = ;

    for(int i = ; i < G[u].size(); ++i)

    {

        int v = G[u][i];

        if(vis[v]) continue;

        root = ;

        getroot(v, u, getsize(v, u));

        Fa[root] = u;

        divide(root);

    }

}

int dis(int u, int v)

{

    int x = lca(u, v);

    return dep[u] + dep[v] -  * dep[x];

}

void join(int u)

{

    int tmp = u;

    erase(s2[u]);

    s2[u].push();

    Insert(s2[u]);

    while(Fa[u])

    {

        erase(s2[Fa[u]]);

        if(s1[u].size()) s2[Fa[u]].del(s1[u].top());

        s1[u].push(dis(Fa[u], tmp));

        s2[Fa[u]].push(s1[u].top());

        Insert(s2[Fa[u]]);

        u = Fa[u];

    }

}

void remove(int u)

{

    int tmp = u;

    erase(s2[u]);

    s2[u].del();

    Insert(s2[u]);

    while(Fa[u])

    {

        erase(s2[Fa[u]]);

        s2[Fa[u]].del(s1[u].top());

        s1[u].del(dis(tmp, Fa[u]));

        if(s1[u].size()) s2[Fa[u]].push(s1[u].top());

        Insert(s2[Fa[u]]);

        u = Fa[u];

    }

}

int main()

{

    f[] = 1e9;

    n = sum = rd();

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

    {

        int u = rd(), v = rd();

        G[u].push_back(v);

        G[v].push_back(u);

    }

    dfs(, );

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

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

            fa[i][j] = fa[fa[i][j - ]][j - ];

    getroot(, , getsize(, ));

    divide(root);

    m = rd();

    for(int i = ; i <= n; ++i) join(i), val[i] = ;

    while(m--)

    {

        char opt[];

        scanf("%s", opt);

        if(opt[] == 'G')

        {

            if(sum < ) printf("%d\n", sum - );

            else printf("%d\n", s3.top());

        }

        if(opt[] == 'C')

        {

            int u = rd();

            if(val[u] == )

            {

                val[u] = ;

                remove(u);

                --sum;

            }

            else

            {

                val[u] = ;

                join(u);

                ++sum;

            }

        }

    }

    return ;

}