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 ~n~ cells. The cells are numbered 0 through ~n-1~ 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 ~c = [c_0 \dots c_{k-1}]~ of ~k~ positive integers: the clues. He has to paint the cells in a way such that the black cells in the row form exactly ~k~ blocks of consecutive cells. Moreover, the number of black cells in the ~i^\text{th}~ block (~0~-based) from the left should be equal to ~c_i~. For example, if the clues are ~c = [3, 4]~, the solved puzzle must have exactly two blocks of consecutive black cells: one of length ~3~ and then another of length ~4~. Hence, if ~n = 10~ and ~c = [3, 4]~, 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 ~n~ and ~c~, 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):

std::string solve_puzzle(std::string s, int k, int c[])

• s: string of length ~n~. For each ~i~ ~(0 \le i \le n-1)~ character ~i~ is:
  • X, if cell must be black,
  • _, if cell must be white,
  • ., if there is no information about cell ~i~.
• k: the length of array c
• c: array of length ~k~ containing clues, as defined above,
• the function should return a string of length ~n~. For each ~i~ ~(0 \le i \le n-1)~ character ~i~ of the output string should be:
  • X, if cell ~i~ is black in every valid solution,
  • _, if cell ~i~ is white in every valid solution,
  • ?, otherwise (i.e., if there exist two valid solutions such that cell ~i~ 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 ~1 \le k \le n~ and ~1 \le c_i \le n~ for each ~0 \le i \le k-1~.

1. (7 points) ~n \le 20~, ~k=1~, ~s~ contains only . (empty puzzle),
2. (3 points) ~n \le 20~, ~s~ contains only .,
3. (22 points) ~n \le 100~, ~s~ contains only .,
4. (27 points) ~n \le 100~, ~s~ contains only . and _ (information about white cells),
5. (21 points) ~n \le 100~,
6. (10 points) ~n \le 5\,000~, ~k \le 100~,
7. (10 points) ~n \le 200\,000~, ~k \le 100~.