hackercupai/hackercup huggingface dataset:
This weekend, the long-awaited BIT (Boomerang Invitational Tournament) will be
taking place! **N** of the finest boomerangists will be competing in a
randomly-seeded single-elimination bracket.

For those unfamiliar with this tournament format, the process can be modelled
as follows:

1. The **N** competitors are arranged in a queue (an ordered list), in some order
2. If the queue currently contains only 1 competitor, the tournament ends with them as the champion
3. Otherwise, the first 2 competitors in the front of the queue are removed, and they play a match against one another
4. The winner of that match is re-inserted into the queue, at the back
5. Repeat from step 2

The one-on-one matches in this tournament are, of course, boomerang duels to
the death. If the **i**th and **j**th competitors face off against one
another, the **i**th competitor will win if **Wi,j** = 1. Otherwise, if
**Wi,j** = 0, the **j**th competitor will win. Note that, for all (1 ≤ **i**,
**j** ≤ **N**), **Wi,j** = 0 or 1, and **Wi,i** = 0 (no one will play against
themselves anyway), and **Wi,j** ≠ **Wj,i** (if **i** ≠ **j**). Those are the
only constraints. It's possible that, for example, competitor A can beat B, B
can beat C, and C can beat A.

Once the tournament is over, each boomerangist is given a placing (even if
they didn't survive the competition). A given competitor **c**'s placing is an
integer one greater than the number of competitors who won strictly more
matches than **c** did.

For each boomerangist, you'd like to know both the best (smallest) and the
worst (largest) placing they could possibly end up with, given that the
initial ordering of the competitors (in step 1 of the tournament) is unknown.

### Input

Input begins with an integer **T**, the number of tournaments. For each
tournament, there is first a line containing the integer **N**. Then follow
**N** lines, the **i**th of which contains the space-separated integers
**Wi,1** through **Wi,N**.

### Output

For the **i**th tournament, print a line containing "Case #**i**: " followed
by **N** lines that each contain two space-separated integers. The first
integer on the **i**th line should be the best possible placing for the
**i**th competitor, and the second should be the worst possible placing.

### Constraints

1 ≤ **T** ≤ 250
**N** = 2**K** where **K** is an integer and 0 ≤ **K** ≤ 4

### Explanation of Sample

In the second tournament, the first competitor will always beat the second
competitor, so the first competitor will finish in 1st place, and the other in
2nd place. In the third tournament, the first competitor never loses, so they
will finish in 1st place. The fourth competitor never wins, so they will
finish tied for 3rd place with the other competitor who loses their initial
match. The other two competitors will either lose their first match (if
initially paired with the first competitor) or their second match (if
initially paired with the fourth competitor), so they can each finish in 2nd
place, or tied for 3rd place.