Paint By Numbers is a well-known puzzle game. We consider a simple one-dimensional version of this puzzle. In this puzzle, the player is given a row of cells. The cells are numbered 0 through from the left to the right.
The player has to paint each cell black or white. We use `X`

to denote black cells and `_`

to denote white cells.

The player is given a sequence of positive integers: the *clues*. He has to paint the cells in a way such that the black cells in the row form exactly blocks of consecutive cells. Moreover, the number of black cells in the block (-based) from the left should be equal to . For example, if the clues are , the solved puzzle must have exactly two blocks of consecutive black cells: one of
length and then another of length . Hence, if and , one solution satisfying the clues is `_XXX__XXXX`

. Note that `XXXX_XXX__`

does not satisfy the
clues because the blocks of black cells are not in the correct order. Also, `__XXXXXXX_`

does not satisfy the clues because there is a single block of black cells,
not two separate blocks.

You are given a partially solved Paint By Numbers puzzle. That is, you know and , and additionally you know that some cells must be black and some cells must be white. Your task is to deduce additional information about the cells.

Specifically, a *valid solution* is one that satisfies the clues, and also agrees with the colours of the known cells. Your program should find cells that are painted black in every valid solution, and cells that are painted white in every valid solution.

You may assume that the input is such that there is at least one valid solution.

#### Implementation Details

You should implement the following function (method):

```
string solve_puzzle(string s, int k, int c[])
```

`s`

: string of length . For each character is:`X`

, if cell must be black,`_`

, if cell must be white,`.`

, if there is no information about cell .

`k`

: the length of array`c`

`c`

: array of length containing clues, as defined above,- the function should return a string of length . For each character of the output string should be:
`X`

, if cell is black in every valid solution,`_`

, if cell is white in every valid solution,`?`

, otherwise (i.e., if there exist two valid solutions such that cell is black in one of them and white in the other one).

#### Examples

##### Example 1

```
solve_puzzle("..........", 2, [3, 4])
```

These are all possible valid solutions of the puzzle:

`XXX_XXXX__`

,`XXX__XXXX_`

,`XXX___XXXX`

,`_XXX_XXXX_`

,`_XXX__XXXX`

,`__XXX_XXXX`

.

One can observe that the cells with (0-based) indices 2, 6, and 7 are black in each valid solution. Each of the other cells can be, but does not have to be black. Hence,
the correct answer is `??X???XX??`

.

##### Example 2

```
solve_puzzle("........", 2, [3, 4])
```

In this example the entire solution is uniquely determined and the correct answer is `XXX_XXXX`

.

##### Example 3

```
solve_puzzle("..._._....", 1, [3])
```

In this example we can deduce that cell 4 must be white as well — there is no way to fit three consecutive black cells between the white cells at indices 3 and 5. Hence, the correct answer is `???___????`

.

##### Example 4

```
solve_puzzle(".X........", 1, [3])
```

There are only two valid solutions that match the above description:

`XXX_______`

,`_XXX______`

.

Thus, the correct answer is `?XX?______`

.

#### Subtasks

In all subtasks and for each .

- (7 points) , , contains only
`.`

(empty puzzle), - (3 points) , contains only
`.`

, - (22 points) , contains only
`.`

, - (27 points) , contains only
`.`

and`_`

(information about white cells), - (21 points) ,
- (10 points) , ,
- (10 points) , .

## Comments