#include <iostream>
#include <vector>
#include <string>
#include <iomanip>
#include <queue>
#include <cmath>
#include <algorithm>
#include <unordered_map>
#include <tuple>
#include <iomanip>
#include <stdio.h>
#include <map>
#include <bitset>
#include <set>
#include <stack>
#include <queue>
#include <unordered_set>
#include <cassert>
#include <stdlib.h>
#include <time.h>
#include <random>


//#pragma GCC optimize("Ofast,no-stack-protector")
//#pragma GCC target("sse,sse2,sse3,sse3,sse4")
//#pragma GCC optimize("unroll-loops")
//#pragma GCC optimize("fast-math")
//#pragma GCC target("avx2")
//#pragma GCC optimize("section-anchors")
//#pragma GCC optimize("profile-values,profile-reorder-functions,tracer")
//#pragma GCC optimize("vpt")
//#pragma GCC optimize("rename-registers")
//#pragma GCC optimize("move-loop-invariants")
//#pragma GCC optimize("unswitch-loops")
//#pragma GCC optimize("function-sections")
//#pragma GCC optimize("data-sections")

//#define int long long
#define ll long long
#define ull unsigned long long
#define all(a) (a).begin(), (a).end()
#define pii pair<int, int>
#define pb push_back
#define ld long double

using namespace std;

//const int INF = 1e17;
//const int mod = 2600000069;
//const int p = 179;
const int MAXN = 1e5 + 1;
const int logn = 18;

int tin[MAXN], tout[MAXN], up[MAXN][logn];
vector<int> g[MAXN];
int timer = 0;

void dfs(int v, int p) {
    up[v][0] = p;
    tin[v] = timer++;
    for (int i = 1; i < logn; i++) {
        up[v][i] = up[up[v][i - 1]][i - 1];
    }
    for (auto u : g[v]) {
        if (u != p) dfs(u, v);
    }
    tout[v] = timer++;
}

bool ancestor(int v, int u) {
    return tin[v] <= tin[u] && tout[v] >= tout[u];
}

int lca(int v, int u) {
    if (ancestor(u, v)) return u;
    if (ancestor(v, u)) return v;
    for (int i = logn - 1; i >= 0; i--) {
        if (!ancestor(up[v][i], u)) v = up[v][i];
    }
    return up[v][0];
}

int cur = 0;

int ans() {
    int u, v;
    cin >> u >> v;
    u--;v--;
    if (u == v) return u;
    int uv = lca(u, v), ur = lca(u, cur), vr = lca(v, cur);
//    cout << "vr : " << vr << "\n";
//    cout << "ur : " << ur << "\n";
    int help = 0;
    if (!ancestor(uv, cur) || ancestor(cur, uv)) return uv;
    if (ancestor(u, v)) {
        if (ancestor(vr, v) && ancestor(u, vr)) return vr;
        if (ancestor(cur, u)) return u;
        if (ancestor(v, cur)) return v;
        while(1) help++;
    }
    if (ancestor(v, u)) {
        if (ancestor(ur, u) && ancestor(v, ur)) return ur;
        if (ancestor(cur, v)) return v;
        if (ancestor(u, cur)) return u;
        while(1) help++;
    }
    if (ancestor(u, cur)) return u;
    if (ancestor(v, cur)) return v;
    if (ancestor(uv, ur) && ur != uv) return ur;
    if (ancestor(uv, vr) && uv != vr) return vr;
    if (ancestor(uv, ur)) return ur;
//    if (ancestor(uv, vr)) return vr;
    return 123456789;
}

signed main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    int n;
    cin >> n;
    while (n != 0) {
        int u, v;
        cur = 0;
        for (int i = 0; i < n; i++) g[i].clear();
        for (int i = 0; i < n - 1; i++) {
            cin >> u >> v;
            u--;v--;
            g[u].pb(v);
            g[v].pb(u);
        }
        dfs(0, 0);
        int q;
        cin >> q;
        char t;
        while (q--) {
            cin >> t;
            if (t == '?') cout << ans() + 1 << "\n";
            else {
               cin >> cur;
               cur--;
            }
        }
        cin >> n;
    }
}
/*
9
1 2
1 3
2 4
2 5
3 6
3 7
6 8
6 9
10
? 4 5
? 5 6
? 8 7
! 6
? 8 7
? 4 5
? 4 7
? 5 9
! 2
? 4 3
0
*/