hackercupai/hackercup huggingface dataset:
You're looking at a sort of clock which has a row of **N** lights. Each light
is either on or off, and their states can be read as an **N**-digit binary
number. The first light represents the most significant (leftmost) digit while
the **N**th light represents the least significant digit. A light that's on
corresponds to a 1, and a light that's off corresponds to a 0.

You've just started looking at the clock, and you know that every second from
now on, it will count upwards by 1, with its lights turning on or off to
display the next number in binary. Once the clock displays 2**N** \- 1 (with
all **N** lights on), it will wrap around to display 0 (with all lights off)
on the following second, and then continue counting up again.

However, 0 or more of the clock's lights may be permanently broken. You don't
know which ones those are, but you know that they'll always appear to be off,
even when they should be on.

Currently, the _i_th light appears to be on if **Li** = 1, and otherwise
appears to be off (if **Li** = 0). You have also received insider information
that exactly **K** of the lights are currently supposed to be on. It's
guaranteed that **K** is at least as large as the number of lights which
appear to be on.

Assuming you stand around and look at this clock for a while, what's the
maximum amount of time you might have to wait before you can be completely
sure of what state every single light is currently supposed to be in? It's
possible that you can be sure immediately, after 0 seconds. On the other hand,
it's also possible that you might never be sure, no matter how long you wait.

### Input

Input begins with an integer **T**, the number of different clocks you own.
For each clock, there is first a line containing the two space-separated
integers, **N** and **K**. Then there is a line containing **N** space-
separated integers, the _i_th of which is **Li**.

### Output

For the _i_th clock, print a line containing "Case #**i**: " followed by the
maximum number of seconds which might go by before you know the true current
state of each light, or -1 if you might never know.

### Constraints

1 ≤ **T** ≤ 5,000
1 ≤ **N** ≤ 60
0 ≤ **K** ≤ **N**
0 ≤ **Li** ≤ 1

### Explanation of Sample

In the first case, exactly one of the two rightmost lights is initially
supposed to be on, so the clock is either supposed to be showing 101 (5) or
110 (6). After one second, the clock will be supposed to show either 110 (6)
or 111 (7). Supposing that the two rightmost lights are both broken, both of
these values will still look like 100 to you, so you won't be able to tell
which one is correct. After one more second, the clock will be supposed to
show either 111 (7) or 000 (0). At that point, by observing the functioning
leftmost light, you can determine whether all three lights are supposed to be
on or off at that moment.

In the second case, you'll never be able to tell which of the two leftmost
lights are supposed to be on if they're both broken.