#include <bits/stdc++.h>
#define L(i, m, n) for(int i(m);i < n;i++)
#define pb push_back
#define D(X) cout<<"  "<<#X": "<<X<<endl;
#define in(x) cin >> x
#define SZ(X) int(X.size())
#define ff first
#define ss second
#define RF(X) freopen(X, "r", stdin)
#define WF(X) freopen(X, "w", stdout)
using namespace std;
typedef long long ll;
typedef pair<ll,ll> pll;
typedef vector<int> vi;
typedef vector<vi> vii;
typedef pair<int,int> pii;
typedef vector<pii> vpii;
typedef pair<int, string> pis;
typedef vector<string> vs;
typedef pair<pair<int, int>, pair<int, int > > piiii;
const int MAXN=10009;
const int LOGMAXN=20;
vector <vpii> adj(MAXN);

bool vis[MAXN];
int T[MAXN],P[MAXN][20],cst[MAXN],lvl[MAXN],t,n,k;

string blank;
void DFS(int node, int level, int cost,int P){
//    D(node);D(level);
    vis[node]=1;lvl[node]=level;cst[node]+=cost;T[node]=P;
    L(i,0,SZ(adj[node])) if(!vis[adj[node][i].ff]) DFS(adj[node][i].ff,level+1,cost+adj[node][i].ss,node);
}
void process(int N){
    int i, j;
  /**we initialize every element in P with -1**/
      for (i = 1; i <= N; i++)
          for (j = 0; 1 << j <= N; j++)
              P[i][j] = -1;

  /**the first ancestor of every node i is T[i]**/
      for (i = 1; i <= N; i++)
          P[i][0] = T[i];

  /**bottom up dynamic programing**/
      for (j = 1; 1 << j <= N; j++)
         for (i = 1; i <= N; i++)
             if (P[i][j - 1] != -1)
                 P[i][j] = P[P[i][j - 1]][j - 1];
}
int query(int N,int p, int q)
{
    int log, i;
  /**if p is situated on a higher level than q then we swap them**/
      if (lvl[p] < lvl[q])swap(p,q);
  /**we compute the value of [log(L[p)]**/
      log=floor(log2(lvl[p]));
  /**we find the ancestor of node p situated on the same level
  with q using the values in P**/
      for (i = log; i >= 0; i--)
          if (lvl[p] - (1 << i) >= lvl[q])
              p = P[p][i];
      if (p == q)
          return p;
  /**we compute LCA(p, q) using the values in P**/
      for (i = log; i >= 0; i--)
          if (P[p][i] != -1 && P[p][i] != P[q][i])
              p = P[p][i], q = P[q][i];
      return T[p];
}
void walk(int node, int target){
    if(lvl[node]==target){/**0-Jump**/
        cout << node <<endl;
        return ;
    }

    for(int i = floor(log2(lvl[node]));i>=0;i--){

        if(lvl[P[node][i]]>= target)node=P[node][i];
    }
    cout << node <<endl;
}
int main(){
    in(t);getline(cin,blank);
    L(test,0,t){
        getline(cin,blank);
        adj.clear();adj.resize(MAXN);memset(vis,0,sizeof(vis));
        memset(T,-1,sizeof(T));
        memset(cst,0,sizeof(cst));
        memset(lvl,0,sizeof(lvl));
        in(n);
        int u,v,w;
        L(i,0,n-1){
            in(u);in(v);in(w);
            adj[u].pb({v,w});adj[v].pb({u,w});
        }
        DFS(1,0,0,-1);
        process(n);
        while(in(blank)){
            if(blank=="DONE") break;
            if(blank=="DIST"){
                in(u),in(v);
                int LCA=query(n,u,v);
                cout << cst[u]+cst[v] - 2 * cst[LCA] <<endl;
            }
            else{
                in(u),in(v),in(k);
                int LCA = query(n,u,v);
                if(lvl[u]-lvl[LCA]+1 >= k){
                    int target=lvl[u]-k+1;
                    walk(u,target);
                }
                else{
                    k-=lvl[u]-lvl[LCA]+1;
                    int target=lvl[LCA]+k;
                    walk(v,target);
                }
            }
            if(test < t-1)puts("");
        }
    }

}