//████████╗██╗███╗░░██╗ ██╗░░░░░███████╗
//╚══██╔══╝██║████╗░██║ ██║░░░░░██╔════╝
//░░░██║░░░██║██╔██╗██║ ██║░░░░░█████╗░░
//░░░██║░░░██║██║╚████║ ██║░░░░░██╔══╝░░
//░░░██║░░░██║██║░╚███║ ███████╗███████╗
//░░░╚═╝░░░╚═╝╚═╝░░╚══╝ ╚══════╝╚══════╝
// __________________
// | ________________ |
// || ____ ||
// || /\ | ||
// || /__\ | ||
// || / \ |____ ||
// ||________________||
// |__________________|
// \###################\
// \###################\
// \ ____ \
// \_______\___\_______\
// An AC a day keeps the doctor away.
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <cmath>
#include <vector>
#include <set>
#include <map>
#include <unordered_set>
#include <unordered_map>
#include <queue>
#include <ctime>
#include <cassert>
#include <complex>
#include <string>
#include <cstring>
#include <chrono>
#include <random>
#include <bitset>
#include <iomanip>
#include <functional>
#include <numeric>
#include <stack>
#include <array>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;
template<class T> using ordered_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
#define vt vector
#define all(x) begin(x), end(x)
#define allr(x) rbegin(x), rend(x)
#define ub upper_bound
#define lb lower_bound
#define db double
#define ld long db
#define ll long long
#define ull unsigned long long
#define vll vt<ll>
#define vvll vt<vll>
#define pll pair<ll, ll>
#define vpll vt<pll>
#define vvpll vt<vpll>
#define vc vt<char>
#define vvc vt<vc>
#define vi vt<int>
#define vvi vt<vi>
#define vvvi vt<vvi>
#define pii pair<int, int>
#define vpii vt<pii>
#define vs vt<string>
#define vvs vt<vs>
#define vb vt<bool>
#define vvb vt<vb>
#define vvpii vt<vpii>
#define vd vt<db>
#define ar(x) array<int, x>
#define var(x) vt<ar(x)>
#define vvar(x) vt<var(x)>
#define al(x) array<ll, x>
#define vall(x) vt<al(x)>
#define vvall(x) vt<vall(x)>
#define mset(m, v) memset(m, v, sizeof(m))
#define pb push_back
#define ff first
#define ss second
#define sv string_view
#define MP make_pair
#define MT make_tuple
#define rsz resize
#define sum(x) (ll)accumulate(all(x), 0LL)
#define srt(x) sort(all(x))
#define srtR(x) sort(allr(x))
#define srtU(x) sort(all(x)), (x).erase(unique(all(x)), (x).end())
#define SORTED(x) is_sorted(all(x))
#define rev(x) reverse(all(x))
#define MAX(a) *max_element(all(a))
#define MIN(a) *min_element(all(a))
#define ROTATE(a, p) rotate(begin(a), begin(a) + p, end(a))
#define i128 __int128
//SGT DEFINE
#define lc i * 2 + 1
#define rc i * 2 + 2
#define lp lc, left, middle
#define rp rc, middle + 1, right
#define entireTree 0, 0, n - 1
#define midPoint left + (right - left) / 2
#define pushDown push(i, left, right)
#define iter int i, int left, int right
#define IOS ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0)
struct custom {
static const uint64_t C = 0x9e3779b97f4a7c15; const uint32_t RANDOM = std::chrono::steady_clock::now().time_since_epoch().count();
size_t operator()(uint64_t x) const { return __builtin_bswap64((x ^ RANDOM) * C); }
size_t operator()(const std::string& s) const { size_t hash = std::hash<std::string>{}(s); return hash ^ RANDOM; } };
template <class K, class V> using umap = std::unordered_map<K, V, custom>; template <class K> using uset = std::unordered_set<K, custom>;
template<class T> using max_heap = priority_queue<T>;
template<class T> using min_heap = priority_queue<T, vector<T>, greater<T>>;
template<typename T, size_t N>
istream& operator>>(istream& is, array<T, N>& arr) {
for (size_t i = 0; i < N; i++) { is >> arr[i]; } return is;
}
template<typename T, size_t N>
istream& operator>>(istream& is, vector<array<T, N>>& vec) {
for (auto &arr : vec) { is >> arr; } return is;
}
template <typename T1, typename T2> istream &operator>>(istream& in, pair<T1, T2>& input) { return in >> input.ff >> input.ss; }
template <typename T> istream &operator>>(istream &in, vector<T> &v) { for (auto &el : v) in >> el; return in; }
template<class T>
void output_vector(vt<T>& a, int off_set = 0) {
int n = a.size();
for(int i = off_set; i < n; i++) {
cout << a[i] << (i == n - 1 ? '\n' : ' ');
}
}
template<typename T, typename Compare>
vi closest_left(const vt<T>& a, Compare cmp) {
int n = a.size(); vi closest(n); iota(all(closest), 0);
for (int i = 0; i < n; i++) {
auto& j = closest[i];
while(j && cmp(a[i], a[j - 1])) j = closest[j - 1];
}
return closest;
}
template<typename T, typename Compare> // auto right = closest_right<int>(a, std::less<int>());
vi closest_right(const vt<T>& a, Compare cmp) {
int n = a.size(); vi closest(n); iota(all(closest), 0);
for (int i = n - 1; i >= 0; i--) {
auto& j = closest[i];
while(j < n - 1 && cmp(a[i], a[j + 1])) j = closest[j + 1];
}
return closest;
}
template<typename T, typename V = string>
vt<pair<T, int>> encode(const V& s) {
vt<pair<T, int>> seg;
for(auto& ch : s) {
if(seg.empty() || ch != seg.back().ff) seg.pb({ch, 1});
else seg.back().ss++;
}
return seg;
}
template<typename K, typename V>
auto operator<<(std::ostream &o, const std::map<K, V> &m) -> std::ostream& {
o << "{"; int i = 0;
for (const auto &[key, value] : m) { if (i++) o << " , "; o << key << " : " << value; }
return o << "}";
}
#ifdef LOCAL
#define debug(x...) debug_out(#x, x)
void debug_out(const char* names) { std::cerr << std::endl; }
template <typename T, typename... Args>
void debug_out(const char* names, T value, Args... args) {
const char* comma = strchr(names, ',');
std::cerr << "[" << (comma ? std::string(names, comma) : names) << " = " << value << "]";
if (sizeof...(args)) { std::cerr << ", "; debug_out(comma + 1, args...); }
else { std::cerr << std::endl; }
}
template<typename T1, typename T2>
std::ostream& operator<<(std::ostream& o, const std::pair<T1, T2>& p) { return o << "{" << p.ff << " , " << p.ss << "}"; }
auto operator<<(auto &o, const auto &x) -> decltype(end(x), o) {
o << "{"; int i = 0; for (const auto &e : x) { if (i++) o << " , "; o << e; } return o << "}";
} // remove for leetcode
#include <sys/resource.h>
#include <sys/time.h>
void printMemoryUsage() {
struct rusage usage;
getrusage(RUSAGE_SELF, &usage);
double memoryMB = usage.ru_maxrss / 1024.0;
cerr << "Memory usage: " << memoryMB << " MB" << "\n";
}
#define startClock clock_t tStart = clock();
#define endClock std::cout << std::fixed << std::setprecision(10) << "\nTime Taken: " << (double)(clock() - tStart) / CLOCKS_PER_SEC << " seconds" << std::endl;
#else
#define debug(...)
#define startClock
#define endClock
#endif
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
#define eps 1e-9
#define M_PI 3.14159265358979323846
const static string pi = "3141592653589793238462643383279";
const static ll INF = 1LL << 62;
const static int inf = 1e9 + 100;
const static int MK = 30;
const static int MX = 2e5 + 5;
ll gcd(ll a, ll b) { while (b != 0) { ll temp = b; b = a % b; a = temp; } return a; }
ll lcm(ll a, ll b) { return (a / gcd(a, b)) * b; }
int pct(ll x) { return __builtin_popcountll(x); }
ll have_bit(ll x, int b) { return x & (1LL << b); }
int min_bit(ll x) { return __builtin_ctzll(x); }
int max_bit(ll x) { return 63 - __builtin_clzll(x); }
const vvi dirs = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}, {1, 1}, {-1, -1}, {1, -1}, {-1, 1}}; // UP, DOWN, LEFT, RIGHT
const vc dirChar = {'U', 'D', 'L', 'R'};
int modExpo(ll base, ll exp, ll mod) { ll res = 1; base %= mod; while(exp) { if(exp & 1) res = (res * base) % mod; base = (base * base) % mod; exp >>= 1; } return res; }
int modExpo_on_string(ll a, string exp, int mod) { ll b = 0; for(auto& ch : exp) b = (b * 10 + (ch - '0')) % (mod - 1); return modExpo(a, b, mod); }
ll sum_even_series(ll n) { return (n / 2) * (n / 2 + 1);}
ll sum_odd_series(ll n) {return n - sum_even_series(n);} // sum of first n odd number is n ^ 2
ll sum_of_square(ll n) { return n * (n + 1) * (2 * n + 1) / 6; } // sum of 1 + 2 * 2 + 3 * 3 + 4 * 4 + ... + n * n
string make_lower(const string& t) { string s = t; transform(all(s), s.begin(), [](unsigned char c) { return tolower(c); }); return s; }
string make_upper(const string&t) { string s = t; transform(all(s), s.begin(), [](unsigned char c) { return toupper(c); }); return s; }
ll sqrt(ll n) { ll t = sqrtl(n); while(t * t < n) t++; while(t * t > n) t--; return t;}
int T[MX * MK][2], cnt[MX * MK], ptr;
set<int> s[MX * MK];
class Binary_Trie {
public:
void insert(ll num, int v = 1, int t = 0) {
int curr = 0;
for(int i = MK - 1; i >= 0; i--) {
int bits = (num >> i) & 1;
if(!T[curr][bits]) T[curr][bits] = ++ptr, cnt[ptr] = 0;
curr = T[curr][bits];
cnt[curr] += v;
s[curr].insert(t);
}
// dfs_insert(0, num, m - 1);
}
void dfs_insert(int curr, ll num, int bit) {
if(bit == -1) {
cnt[curr ] = 1;
return;
}
int b = (num >> bit) & 1;
if(!T[curr][b]) T[curr][b] = ++ptr;
int nxt = T[curr][b];
dfs_insert(nxt, num, bit - 1);
cnt[curr] = cnt[nxt] + (T[curr][!b] ? cnt[T[curr][!b]] : 0);
}
ll max_xor(ll num, int st, int e) {
ll res = 0, curr = 0;
for(int i = MK - 1; i >= 0; i--) {
int bits = (num >> i) & 1;
int nxt = T[curr][!bits];
if(nxt && cnt[nxt]) {
auto it = s[nxt].lb(st);
if(it != end(s[nxt]) && *it <= e) {
curr = T[curr][!bits];
res |= (1LL << i);
continue;
}
}
curr = T[curr][bits];
if(!curr) break;
}
return res;
}
ll min_xor(ll num) {
ll res = num, curr = 0;
for(int i = MK - 1; i >= 0; i--) {
int bits = (num >> i) & 1;
if(T[curr][bits] && cnt[T[curr][bits]]) {
curr = T[curr][bits];
if(bits) res ^= (1LL << i);
}
else {
curr = T[curr][!bits];
if(!bits) res ^= (1LL << i);
}
if(!curr) break;
}
return res;
}
ll count_less_than(ll a, ll b) {
int curr = 0;
ll res = 0;
for(int i = MK - 1; i >= 0; i--) {
int bits = (a >> i) & 1;
int b_bits = (b >> i) & 1;
if(b_bits) {
if(T[curr][bits]) {
res += cnt[T[curr][bits]];
}
curr = T[curr][!bits];
}
else {
curr = T[curr][bits];
}
if(!curr) break;
}
// res += cnt[curr]; // remove comments if count equal to as well
return res;
}
ll count_greater_than(ll a, ll b) {
int curr = 0;
ll res = 0;
for(int i = MK - 1; i >= 0; i--) {
int bits = (a >> i) & 1;
int b_bits = (b >> i) & 1;
if(b_bits == 0 && T[curr][!bits]) {
res += cnt[T[curr][!bits]];
}
curr = T[curr][b_bits ^ bits];
if(!curr) break;
}
// res += cnt[curr]; // remove comments if count equal to as well
return res;
}
ll find_mex(ll x) { // find a first missing number
ll mex = 0, curr = 0;
for(int i = MK - 1; i >= 0; i--) {
int bit = (x >> i) & 1;
int c = T[curr][bit] ? cnt[T[curr][bit]] : 0;
if(c < (1LL << i)) {
curr = T[curr][bit];
}
else {
mex |= (1LL << i);
curr = T[curr][!bit];
}
if(!curr) break;
}
return mex;
}
};
void reset() {
for(int i = 0; i <= ptr; i++) {
T[i][0] = T[i][1] = 0;
cnt[i] = 0;
s[i].clear();
}
ptr = 0;
}
Binary_Trie Tree;
void solve() {
reset();
int q; cin >> q;
var(4) Q(q);
vvpii graph(q + 1);
int c = 1;
for(auto& [op, u, v, x] : Q) {
string s; cin >> s;
op = s == "Query";
cin >> u >> x;
if(op == 0) {
v = ++c;
graph[u].pb({v, x});
} else swap(v, x);
}
vi a(c + 1);
vi tin(c + 1), tout(c + 1);
int timer = 1;
auto dfs = [&](auto& dfs, int node = 1, int par = -1) -> void {
tin[node] = timer++;
for(auto& [nei, v] : graph[node]) {
if(nei == par) continue;
a[nei] = a[node] ^ v;
dfs(dfs, nei, node);
}
tout[node] = timer - 1;
}; dfs(dfs);
Tree.insert(a[1], 1, tin[1]);
for(auto& [op, u, v, x] : Q) {
if(op == 0) { // Add
Tree.insert(a[v], 1, tin[v]);
continue;
}
cout << Tree.max_xor(a[u], tin[v], tout[v]) << '\n';
}
}
signed main() {
// careful for overflow, check for long long, use unsigned long long for random generator
// when mle, look if problem require read in file, typically old problems
IOS;
startClock
//generatePrime();
int t = 1;
//cin >> t;
for(int i = 1; i <= t; i++) {
//cout << "Case #" << i << ": ";
solve();
}
endClock
#ifdef LOCAL
printMemoryUsage();
#endif
return 0;
}
//███████████████████████████████████████████████████████████████████████████████████████████████████████
//█░░░░░░░░░░░░░░█░░░░░░██████████░░░░░░█░░░░░░░░░░░░███░░░░░░░░░░█░░░░░░██████████░░░░░░█░░░░░░░░░░░░░░█
//█░░▄▀▄▀▄▀▄▀▄▀░░█░░▄▀░░░░░░░░░░██░░▄▀░░█░░▄▀▄▀▄▀▄▀░░░░█░░▄▀▄▀▄▀░░█░░▄▀░░░░░░░░░░██░░▄▀░░█░░▄▀▄▀▄▀▄▀▄▀░░█
//█░░▄▀░░░░░░░░░░█░░▄▀▄▀▄▀▄▀▄▀░░██░░▄▀░░█░░▄▀░░░░▄▀▄▀░░█░░░░▄▀░░░░█░░▄▀▄▀▄▀▄▀▄▀░░██░░▄▀░░█░░▄▀░░░░░░░░░░█
//█░░▄▀░░█████████░░▄▀░░░░░░▄▀░░██░░▄▀░░█░░▄▀░░██░░▄▀░░███░░▄▀░░███░░▄▀░░░░░░▄▀░░██░░▄▀░░█░░▄▀░░█████████
//█░░▄▀░░░░░░░░░░█░░▄▀░░██░░▄▀░░██░░▄▀░░█░░▄▀░░██░░▄▀░░███░░▄▀░░███░░▄▀░░██░░▄▀░░██░░▄▀░░█░░▄▀░░█████████
//█░░▄▀▄▀▄▀▄▀▄▀░░█░░▄▀░░██░░▄▀░░██░░▄▀░░█░░▄▀░░██░░▄▀░░███░░▄▀░░███░░▄▀░░██░░▄▀░░██░░▄▀░░█░░▄▀░░██░░░░░░█
//█░░▄▀░░░░░░░░░░█░░▄▀░░██░░▄▀░░██░░▄▀░░█░░▄▀░░██░░▄▀░░███░░▄▀░░███░░▄▀░░██░░▄▀░░██░░▄▀░░█░░▄▀░░██░░▄▀░░█
//█░░▄▀░░█████████░░▄▀░░██░░▄▀░░░░░░▄▀░░█░░▄▀░░██░░▄▀░░███░░▄▀░░███░░▄▀░░██░░▄▀░░░░░░▄▀░░█░░▄▀░░██░░▄▀░░█
//█░░▄▀░░░░░░░░░░█░░▄▀░░██░░▄▀▄▀▄▀▄▀▄▀░░█░░▄▀░░░░▄▀▄▀░░█░░░░▄▀░░░░█░░▄▀░░██░░▄▀▄▀▄▀▄▀▄▀░░█░░▄▀░░░░░░▄▀░░█
//█░░▄▀▄▀▄▀▄▀▄▀░░█░░▄▀░░██░░░░░░░░░░▄▀░░█░░▄▀▄▀▄▀▄▀░░░░█░░▄▀▄▀▄▀░░█░░▄▀░░██░░░░░░░░░░▄▀░░█░░▄▀▄▀▄▀▄▀▄▀░░█
//█░░░░░░░░░░░░░░█░░░░░░██████████░░░░░░█░░░░░░░░░░░░███░░░░░░░░░░█░░░░░░██████████░░░░░░█░░░░░░░░░░░░░░█
//███████████████████████████████████████████████████████████████████████████████████████████████████████
