There are N birds in a 3D space, let x, y and z denote their coordinates in each dimension. You, the excellent shooter, this time sit in a helicopter and want to shoot these birds with your gun. Through the window of the helicopter you can only see a rectangle area and you choose to shoot the highest bird in view (the helicopter is above all the birds and the rectangle area is parallel to the ground). Now given the rectangle area of your view, can you figure out which bird to shoot?

Input

First line will be a positive integer T (1≤T≤10) indicating the test case number.. Following there are T test cases.. Each test case begins with a positive integer N (1≤N≤10000), the number of birds.. Then following N lines with three positive integers x, y and z (1≤x,y,z≤100000), which are the coordinates of each bird (you can assume no two birds have the same height z).. Next will be a positive integer Q (1≤Q≤10000) representing the number of query.. Following Q lines with four positive integers which are the lower-left and upper-right points' coordinates of the rectangle view area.. (please note that after each query you will shoot down the bird you choose and you can't shoot it any more in the later).

Output

For each query output the coordinate of the bird you choose to shoot or output 'Where are the birds?' (without the quotes) if there are no birds in your view.

Sample Input

2

3

1 1 1

2 2 2

3 3 3

2

1 1 2 2

1 1 3 3

2

1 1 1

3 3 3

2

2 2 3 3

2 2 3 3

Sample Output

2 2 2

3 3 3

3 3 3

Where are the birds?

 #include <cstdio>

 #include <cstring>

 #include <algorithm>

 using namespace std;

 #define N 10005

 int idx;

 struct point{

     int x[];

     bool operator < (const point &a) const{

         return x[idx] < a.x[idx];

     }

 };

 point p[N];

 point tr[N<<];

 int cnt[N<<];

 bool flag[N<<];

 int x1, x2, y1, y2;

 void build(int l, int r, int u, int dep)

 {

     if(l > r) return;

     cnt[u] = r-l+;

     if(l == r)

     {

         tr[u] = p[l];

         return;

     }

     idx = dep%;

     int mid = l+r>>;

     nth_element(p+l, p+mid, p+r+);

     tr[u] = p[mid];

     build(l, mid-, u<<, dep+);

     build(mid+, r, u<<|, dep+);

 }

 int ans, id;

 bool check(point u)

 {

     return u.x[] >= x1 && u.x[] <= x2 && u.x[] >= y1 && u.x[] <= y2;

 }

 void query(int u, int dep)

 {

     if(cnt[u] == ) return;

     if(!flag[u] && check(tr[u]))

         if(tr[u].x[] > ans) ans = tr[u].x[], id = u;

     int tid = dep%;

     if(tid == )

     {

         if(x2 < tr[u].x[]) query(u<<, dep+);

         else if(x1 > tr[u].x[]) query(u<<|, dep+);

         else {

             query(u<<, dep+);

             query(u<<|, dep+);

         }

     }

     else if(tid == )

     {

         if(y2 < tr[u].x[]) query(u<<, dep+);

         else if(y1 > tr[u].x[]) query(u<<|, dep+);

         else {

             query(u<<, dep+);

             query(u<<|, dep+);

         }

     }

     else if(tid == )

     {

         query(u<<|, dep+);

         if(ans < tr[u].x[])//这儿因为写成if(ans == -1)错了很多次

             query(u<<, dep+);

     }

 }

 int main()

 {

     int T, n, q;

     scanf("%d", &T);

     while(T--)

     {

         scanf("%d", &n);

         for(int i = ; i < n; i++) scanf("%d %d %d", &p[i].x[], &p[i].x[], &p[i].x[]);

         memset(flag, , sizeof(flag));

         memset(cnt, , sizeof(cnt));

         build(, n-, , );

         scanf("%d", &q);

         while(q--)

         {

             ans = -;

             scanf("%d %d %d %d", &x1, &y1, &x2, &y2);

             query(, );

             if(ans == -)

                 puts("Where are the birds?");

             else{

                 printf("%d %d %d\n", tr[id].x[], tr[id].x[], tr[id].x[]);

                 flag[id] = ;

             }

         }

     }

     return ;

 }