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>
using namespace std;
const int N = 260;
int n, a[N], l[N], r[N];
int size[N], f[N][2][3];
void init() {
  memset(f, 255, sizeof(f));
  memset(size, 0, sizeof(size));
}
void search(int x) {
  if (a[x] != -1) return;
  search(l[x]), search(r[x]);
  size[x] = size[l[x]] + size[r[x]] + 1;
  if (size[r[x]] & 1) swap(l[x], r[x]);
}
int merge(int l, int r, int t) { return (l < r) ^ t ? r : l; }
int tree_type(int x, int t) { return size[x] <= 1 && t == 1 ? 2 : 1; }
int work(int x, int y, int z) {
  if (size[x] == 0) return a[x];
  if (size[x] == 1) return merge(a[l[x]], a[r[x]], y ^ (z == 2));
  int &res = f[x][y][z];
  if (res != -1) return res;
  if (z) {
    res = work(x, !y, 0);
    if (size[x] & 1) {
      if (size[l[x]] & 1) {
        res = merge(
            res,
            merge(work(l[x], y, 0), work(r[x], !y, tree_type(l[x], z)), !y), y);
        res = merge(
            res,
            merge(work(r[x], y, 0), work(l[x], !y, tree_type(r[x], z)), !y), y);
      } else {
        if (size[l[x]])
          res = merge(
              res,
              merge(work(r[x], !y, 0), work(l[x], y, tree_type(r[x], z)), !y),
              y);
        if (size[r[x]])
          res = merge(
              res,
              merge(work(l[x], !y, 0), work(r[x], y, tree_type(l[x], z)), !y),
              y);
      }
    } else {
      int t = size[r[x]] == 0 && z == 1 ? 2 : 1;
      res = merge(res, merge(work(r[x], y, 0), work(l[x], y, t), y), y);
    }
  } else if (size[x] & 1) {
    int s = size[l[x]] & 1;
    res = merge(work(l[x], y, s), work(r[x], y, s), y);
  } else
    res = merge(merge(work(l[x], y, 0), work(r[x], !y, 0), !y),
                merge(work(l[x], !y, 1), work(r[x], y, 1), !y), y);
  return res;
}
void solve() {
  search(0);
  printf("%d\n", work(0, 0, 0));
}
int main() {
  int tasecase;
  for (scanf("%d", &tasecase); tasecase--;) {
    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]);
    }
    init();
    solve();
  }
  return 0;
}