| 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. | |