Problem: Pieguy and Piegirl are playing a game. They have a rooted binary tree, that has a property that each node is either a leaf or has exactly two children. Each leaf has a number associated with it.

On his/her turn a player can choose any two leafs that share their immediate parent, remove them, and associate either of their values with their parent, that now became a leaf (the player decides which of the two values to associate). The game ends when only one node (the one that was the root of the tree) is left.

Pieguy goes first, and his goal is to maximize the value that will be associated with the root when the game ends. Piegirl wants to minimize that value. Assuming that both players are playing optimally, what number will be associated with the root when the game ends?

Input

First line contains a single integer t (1 ≤ t ≤ 100) — number of test cases. Then t test cases follow. Each test case begins with an empty line, followed by a line with a single integer n (1 ≤ n ≤ 250), followed by n lines describing n nodes of the tree. Each of those n lines either contains a non-negative number ai, indicating a leaf node with value ai (0 ≤ ai ≤ 1000) associated with it, or  - 1 followed by integers l and r, indicating a non-leaf node with children l and r (0 ≤ l, r ≤ n - 1). Nodes are numbered from 0 to n - 1. The root is always node 0.

Output

For each test case print one line with one integer on it — the number that will be associated with the root when the game ends.

Examples

Input

4

3
-1 1 2
10
5

5
-1 1 2
-1 3 4
10
5
20

7
-1 1 2
-1 3 4
-1 5 6
1
2
3
4

11
-1 1 2
-1 3 4
-1 5 6
-1 7 8
15
7
-1 9 10
7
8
9
11


Output

10
10
4
8

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
const int N = 256;
int n, a[N], l[N], r[N];
int size[N];
void dfs(int x) {
  if (a[x] != -1) {
    size[x] = 0;
    return;
  }
  dfs(l[x]);
  dfs(r[x]);
  size[x] = size[l[x]] + size[r[x]] + 1;
  if (size[r[x]] & 1) std::swap(l[x], r[x]);
}
inline int merge(int lhs, int rhs, int dir) {
  return ((lhs < rhs) ^ dir) ? rhs : lhs;
}
int mem[N][2][3];
int solve(int x, int y, int z) {
  if (a[x] != -1) return a[x];
  if (size[x] == 1) return merge(a[l[x]], a[r[x]], y ^ (z == 2));
  int &res = mem[x][y][z];
  if (res != -1) return res;
  if (z) {
    res = solve(x, !y, 0);
    if (size[x] & 1) {
      if (size[l[x]] & 1) {
        res =
            merge(res,
                  merge(solve(l[x], y, 0),
                        solve(r[x], !y, size[l[x]] == 1 && z == 1 ? 2 : 1), !y),
                  y);
        res =
            merge(res,
                  merge(solve(r[x], y, 0),
                        solve(l[x], !y, size[r[x]] == 1 && z == 1 ? 2 : 1), !y),
                  y);
      } else {
        if (size[l[x]])
          res = merge(
              res,
              merge(solve(r[x], !y, 0),
                    solve(l[x], y, size[r[x]] == 0 && z == 1 ? 2 : 1), !y),
              y);
        if (size[r[x]])
          res = merge(
              res,
              merge(solve(l[x], !y, 0),
                    solve(r[x], y, size[l[x]] == 0 && z == 1 ? 2 : 1), !y),
              y);
      }
    } else {
      res = merge(res,
                  merge(solve(r[x], y, 0),
                        solve(l[x], y, size[r[x]] == 0 && z == 1 ? 2 : 1), y),
                  y);
    }
  } else {
    if (size[x] & 1) {
      int s = size[l[x]] & 1;
      res = merge(solve(l[x], y, s), solve(r[x], y, s), y);
    } else {
      res = merge(merge(solve(l[x], y, 0), solve(r[x], !y, 0), !y),
                  merge(solve(l[x], !y, 1), solve(r[x], y, 1), !y), y);
    }
  }
  return res;
}
int main() {
  int tcase;
  for (scanf("%d", &tcase); tcase--;) {
    scanf("%d", &n);
    for (int i = 0; i < n; ++i) {
      scanf("%d", &a[i]);
      if (a[i] == -1) scanf("%d%d", &l[i], &r[i]);
    }
    dfs(0);
    memset(mem, -1, sizeof mem);
    printf("%d\n", solve(0, 0, 0));
  }
  return 0;
}