#### Registered Users Only

Please login to utilize this feature.

Do note that this website only supports submissions in C++.

## 2048

You are fascinated by the game *2048* and have been playing it
for more than 24 hours consecutively! However, because of the complexity
of the game, you could hardly win the game. After many frustrating tries,
you realised that it would probably be better to write a program to play
it.

The game *2048* is played on a 4x4 board. At the start, two of
the grids are filled with the number 2. On each of your move, you can
slide in four different directions, namely, left, right, up and down, to
move the grids that are filled with numbers. The movement of the grids
follow these rules:

- The grids closer to the edge of the board that you are sliding towards
move first,
*i.e.*, if you slide leftwards, the grids in the leftmost row move first, followed by the grids in the second left row, the third left row, and the rightmost row; - Only grids that are filled with numbers move;
- A grid moves toward your direction until it hits the edge of the board or another grid that is filled with a number. In the second case, if the two numbers are the same, and the number in the grid that is hit has not been doubled in this turn, the number in the grid that is hit will be doubled, while the number in the grid that is moving disappears, and you are awarded score that is equal to the sum of the two numbers;
- If a slide towards a direction does not cause any change to the board, then you are not allowed to slide towards that direction in this turn(unless there is no legal move; in that case, the game ends);
- After each of your turn, a new number is generated in a random empty grid. The new number has a 75% chance to be 2, and a 25% chance to be 4. If after one of your turn there is no empty grid, then the game ends.

Your aim, however, is not to obtain the maximum score, but to make the largest number on the board as large as possible when the game ends. For example, a score of 2000 with the largest number 512 is considered superior to a score of 10000 with the largest number only 256. In the original game, you would have won once you made a 2048 in one of the grids; but since you are cheating by writing a program, you will naturally aim for as high as possible.

There are 20 test cases. For each test case, you are given an award according to the following scheme:

- 120; if
*M*> 2048 - 100; if
*M*= 2048 - 60; if
*M*= 1024 - 35; if
*M*= 512 - 10; if
*M*= 256 - 0; if
*M*<= 128

Let S be the average of your awards. Your final score is then given by the following formula:

- 100; if
*S*>= 92 - 4*(25
^{(S-20)/72}); if 20 <=*S*< 92 - 0; if
*S*< 20

## Functions that you must implement:

void init(int r1, int c1, int r2, int c2);

This function will be called once before anything else is called. It is
for you to initialise any global variables you might need. *(r1,c1)* and *(r2,c2)* are the positions of the two starting 2s(0-based
indexing).(*(r,c)* refers to row r column c)

void generate(int r, int c, int x);

This function will be called after each of your move to generate a new
number *x* in a random empty grid *(r,c)*.The number has a
75% chance to be 2 and a 25% chance to be 4.

int sliderequest();

This function will be called when it is your turn to slide. Your return must be an integer between 1 and 4, representing upward(1), rightward(2), downward(3) and leftward(4) respectively.

## Constraints

None.

## Sample

No sample is provided. If you are still unsure about any of the rules,
simply google *2048* and click on the first result.

### Tags

### Subtasks and Limits

Subtask | Score | #TC | Time | Memory | Scoring |
---|---|---|---|---|---|

1 | 100 | 100 | 5s | 32MB | Custom |

### Judge Compile Command

g++-7 grader.cpp -o 2048 -Wall -static -O2 -lm -m64 -s -w -std=gnu++17 -fmax-errors=512