#include<bits/stdc++.h>

 using namespace std;

 const int Mn=;

 int cnt=,h[Mn],n,m,vst[Mn],maxx,tg,s[Mn],sz,prt[Mn];

 int d[Mn],p[Mn][],co[Mn];

 struct Priority_Queue{

     priority_queue<int> q,del;

     void push(int x)

     {q.push(x);}

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

     int top()

     {

         while(del.size()&&del.top()==q.top())

             {del.pop();q.pop();}

         return q.top();

     }

     void Pop()

     {

         while(del.size()&&del.top()==q.top())

             del.pop(),q.pop();

         q.pop();

     }

     int sec_top()

     {

         int tmp=top();Pop();

         int se=top();push(tmp);

         return se;

     }

     int size()

     {

         return q.size()-del.size();

     }

 }c[Mn],f[Mn],ans;

 struct Edge{int to,next;}w[Mn*];

 void add(int x,int y)

 {w[++cnt]=(Edge){y,h[x]};h[x]=cnt;}

 void build(int x,int fa)

 {

     p[x][]=fa;d[x]=d[fa]+;

     for(int i=;p[x][i-];i++)

         p[x][i]=p[p[x][i-]][i-];

     for(int i=h[x];i;i=w[i].next)

     if(w[i].to!=fa)

         build(w[i].to,x);

 }

 void Insert(Priority_Queue &s){

      if(s.size()>)ans.push(s.top()+s.sec_top());

 }

 void Erase(Priority_Queue &s){

      if(s.size()>)ans.erase(s.top()+s.sec_top());

 }

 void DP(int x,int fa)

 {

      int j,y;s[x]=;

      for(j=h[x];j;j=w[j].next)

      {

         y=w[j].to;

         if(y==fa||vst[y])continue;

         DP(y,x);

         s[x]+=s[y];

      }

 }

 void Biggest(int x,int fa){

      int j,y,mx=;

      for(j=h[x];j;j=w[j].next){

         y=w[j].to;

         if(y==fa||vst[y])continue;

         Biggest(y,x);

         mx=max(mx,s[y]);

      }

      if(maxx>max(mx,sz-s[x])){

         maxx=max(mx,sz-s[x]);

         tg=x;

      }

 }

 int gg(int x)//get G

 {

     maxx=n+;tg=;

     DP(x,);

     sz=s[x];

     Biggest(x,);

     return tg;

 }

 int LCA(int x,int y){

     int j;

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

     for(j=;j>=;j--)

       if(d[p[x][j]]>=d[y])x=p[x][j];

     if(x==y)return x;

     for(j=;j>=;j--)

       if(p[x][j]!=p[y][j])

        {x=p[x][j];y=p[y][j];}

     return p[x][];

 }

 int Dis(int x,int y){return d[x]+d[y]-*d[LCA(x,y)];}

 void work(int x,int fa,int Gra){

      int j,y;

      f[Gra].push(Dis(x,prt[Gra]));

      for(j=h[x];j;j=w[j].next){

         y=w[j].to;

         if(y==fa||vst[y])continue;

         work(y,x,Gra);

      }

 }

 int mzz(int x,int fa)

 {

     int j,y,G,Gy;

     G=gg(x);prt[G]=fa;

     work(G,,G);

     vst[G]=;

     c[G].push();

     for(j=h[G];j;j=w[j].next)

     {

         y=w[j].to;

         if(!vst[y]){

             Gy=mzz(y,G);

             c[G].push(f[Gy].top());

         }

     }

     Insert(c[G]);

     return G;

 }

 void Light(int x){

      Erase(c[x]);

      c[x].erase();

      Insert(c[x]);

      for(int y=x;prt[y];y=prt[y]){

         Erase(c[prt[y]]);

         if(f[y].size())c[prt[y]].erase(f[y].top());

         f[y].erase(Dis(x,prt[y]));

         if(f[y].size())c[prt[y]].push(f[y].top());

         Insert(c[prt[y]]);

      }

 }

 void LiOut(int x){

      Erase(c[x]);

      c[x].push();

      Insert(c[x]);

      for(int y=x;prt[y];y=prt[y]){

         Erase(c[prt[y]]);

         if(f[y].size())c[prt[y]].erase(f[y].top());

         f[y].push(Dis(x,prt[y]));

         if(f[y].size())c[prt[y]].push(f[y].top());

         Insert(c[prt[y]]);

      }

 }

 void solve(){

      int i,x;char ch[];

      cnt=n;

      scanf("%d",&m);

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

         scanf("%s",ch);

         if(ch[]=='G'){

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

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

         }

         else{

             scanf("%d",&x);

             if(!co[x]){cnt--;Light(x);co[x]=;}

             else{cnt++;LiOut(x);co[x]=;}

         }

      }

 }

 int main()

 {

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

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

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

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

     build(,);mzz(,);

     solve();

     return ;

 }