Ethan's doing his very first programming assignment: implementing a
`contains()` function. This function takes two strings, **A** and **B**, and
returns `true` if **A** is a substring of **B**, and `false` otherwise.

Here's the algorithm that Ethan has come up with. Note that |**A**| denotes
the length of **A**, and the individual characters of the strings are
1-indexed.

  1. Set _i_ and _j_ to each be equal to 1.
  2. If _i_ > |**A**|, return `true`.
  3. If _j_ > |**B**|, return `false`.
  4. If **Ai** = **Bj**, increment _i_ and _j_ by 1 each, and return to Step 2.
  5. If _i_ = 1, increment _j_ by 1, and return to Step 2.
  6. Set _i_ to be equal to 1, and return to Step 2.

As the TA in charge of grading Ethan's assignment, this doesn't look quite
right to you. To make sure Ethan doesn't get any more credit than he deserves,
you'd like to find some inputs for which his algorithm returns `false` even
though it should return `true`.

The professor teaching this class has provided you with a half-written list of
test cases. In particular, it's a list of inputs for the **A** parameter, and
you're free to come up with your own inputs for the **B** parameter. For each
given string **A**, you want to find a string **B** that will cause Ethan's
algorithm to return the wrong output (`false` instead of `true`), if possible.
**A** will only contain uppercase alphabetic characters, and **B** must follow
the same constraint. The test cases shouldn't be too large, so **B** must also
contain at most 10,000 characters.

### Input

Input begins with an integer **T**, the number of given strings. Then, **T**
lines follow. Each line contains a single string, **A**.

### Output

For the _i_th given string, print a line containing "Case #_i_: " followed by
any valid string **B** that will cause Ethan's algorithm to return the wrong
value, or "Impossible" if no such string exists.

### Constraints

1 ≤ **T** ≤ 100  
1 ≤ |**A**| ≤ 2,000  

### Explanation of Sample

In the first case, _i_ and _j_ will have these values in order the first 10
times the algorithm is at Step 2:

    i j
    ---
    1 1
    2 2
    1 2
    1 3
    1 4
    1 5
    2 6
    3 7
    4 8
    1 8

Please note that other outputs for example cases 1 and 3 would also be
accepted.