Jolly and Emily are two bees studying in Computer Science. Unlike other bees they are fond of playing two-player games. They used to play Tic-tac-toe, Chess etc. But now since they are in CS they invented a new game that definitely requires some knowledge of computer science.

Initially they draw a random rooted tree (a connected graph with no cycles) in a paper which consists of n

nodes, where the nodes are numbered from 0 to n-1 and 0 is the root, and the edges are weighted. Initially all the edges are unmarked. And an edge weigh w, has w identical units.

1. Jolly has a green marker and Emily has a red marker. Emily starts the game first and they alternate turns.
2. In each turn, a player can color one unit
   of an edge of the tree if that edge has some (at least one) uncolored units and the edge can be traversed from the root using only free edges. An edge is said to be free if the edge is not fully colored (may be uncolored or partially colored).
3. If it's Emily's turn, she finds such an edge and colors one unit of it using the red marker.
4. If it's Jolly's turn, he finds such an edge and colors one unit of it with the green marker.
5. The player, who can't find any edges to color, loses the game.

For example, Fig 1 shows the initial tree they have drawn. The tree contains four nodes and the weights of the edge (0, 1), (1, 2) and (0, 3) are 1, 1 and 2 respectively. Emily starts the game. She can color any edge she wants; she colors one unit of edge (0 1) with her red marker (Fig 2). Since the weight of edge (0 1) is 1 so, this edge is fully colored.

Fig 1

Fig 2

Fig 3

Fig 4

Now it's Jolly's turn. He can only color one unit of edge (0 3). He can't color edge (1 2) since if he wants to traverse it from the root (0), he needs to use (0, 1) which is fully colored already. So, he colors one unit of edge (0 3) with his green marker (Fig 3). And now Emily has only one option and she colors the other unit of (0 3) with the red marker (Fig 4). So, both units of edge (0 3) are colored. Now it's Jolly's turn but he has no move left. Thus Emily wins. But if Emily would have colored edge (1 2) instead of edge (0 1), then Jolly would win. So, for this tree Emily will surely win if both of them play optimally.

Input

Input starts with an integer T (≤ 500), denoting the number of test cases.

Each case starts with a line containing an integer n (2 ≤ n ≤ 1000). Each of the next n-1 lines contains two integers u v w (0 ≤ u, v < n, u ≠ v, 1 ≤ w ≤ 10⁹) denoting that there is an edge between u and v and their weight is w. You can assume that the given tree is valid.

Output

For each case, print the case number and the name of the winner. See the samples for details.

Sample Input

4

4

0 1 1

1 2 1

0 3 2

5

0 1 1

1 2 2

0 3 3

0 4 7

3

0 1 1

0 2 1

4

0 1 1

1 2 1

1 3 1

Sample Output

Case 1: Emily

Case 2: Emily

Case 3: Jolly

Case 4: Emily

 

題意：給定有根帶權樹，玩家可以給長度為1的樹枝染色，不能染為輸，可以給一個邊染色，需要滿足它到根的所有邊被染色的長度<邊權。

思路：如果沒有邊權（即長度都為1），那麼就是一個裸的green博弈，即每個點的sg函式=子節點的sg函式+1的異或和。

這裡有邊權，我們可以先得到幾種比較特別的情況。

1：邊權為1，那麼就是正常的考慮。

2：邊權為偶數，其貢獻為0，因為無論先手如何染色，後手有地方可以染色。

那就只剩下一種情況，我也不知道怎麼回事。

3：為奇數而且不為1...std是^1。佔位。

#include<bits/stdc++.h>
#define rep(i,o,l) for(int i=o;i<=l;i++)
using namespace std;
const int maxn=2010;
int Laxt[maxn],Next[maxn],To[maxn],Len[maxn],cnt,sg[maxn];
void add(int u,int v,int c)
{
    Next[++cnt]=Laxt[u]; Laxt[u]=cnt; To[cnt]=v; Len[cnt]=c;
}
void dfs(int u,int f)
{
    sg[u]=0;
    for(int i=Laxt[u];i;i=Next[i])
      if(To[i]!=f){
         dfs(To[i],u);
         if(Len[i]==1) sg[u]^=(sg[To[i]]+1);
         else sg[u]^=(sg[To[i]]^(Len[i]%2));
      }
}
int main()
{
    int T,N,u,v,d,C=0;
    scanf("%d",&T);
    while(T--){
        scanf("%d",&N); cnt=0;
        rep(i,0,N) Laxt[i]=0;
        rep(i,1,N-1) {
            scanf("%d%d%d",&u,&v,&d);
            add(u,v,d); add(v,u,d);
        }
        dfs(0,0);
        printf("Case %d: ",++C);
        puts(sg[0]?"Emily":"Jolly");
    }
    return 0;
}