yl-9/probench huggingface dataset:
# Dora's Set

## Problem Description

Dora has a set $ s $ containing integers. In the beginning, she will put all integers in $ [l, r] $ into the set $ s $ . That is, an integer $ x $ is initially contained in the set if and only if $ l \leq x \leq r $ . Then she allows you to perform the following operations:

- Select three distinct integers $ a $ , $ b $ , and $ c $ from the set $ s $ , such that $ \gcd(a, b) = \gcd(b, c) = \gcd(a, c) = 1^\dagger $ .
- Then, remove these three integers from the set $ s $ .

What is the maximum number of operations you can perform?

 $ ^\dagger $ Recall that $ \gcd(x, y) $ means the [greatest common divisor](https://en.wikipedia.org/wiki/Greatest_common_divisor) of integers $ x $ and $ y $ .

## Input Format

Each test consists of multiple test cases. The first line contains a single integer $ t $ ( $ 1 \leq t \leq 500 $ ) — the number of test cases. The description of the test cases follows.

The only line of each test case contains two integers $ l $ and $ r $ ( $ 1 \leq l \leq r \leq 1000 $ ) — the range of integers in the initial set.

## Output Format

For each test case, output a single integer — the maximum number of operations you can perform.

## Sample #1

### Sample Input #1

```
8
1 3
3 7
10 21
2 8
51 60
2 15
10 26
1 1000
```

### Sample Output #1

```
1
1
3
1
2
3
4
250
```

## Hint

In the first test case, you can choose $ a = 1 $ , $ b = 2 $ , $ c = 3 $ in the only operation, since $ \gcd(1, 2) = \gcd(2, 3) = \gcd(1, 3) = 1 $ , and then there are no more integers in the set, so no more operations can be performed.

In the second test case, you can choose $ a = 3 $ , $ b = 5 $ , $ c = 7 $ in the only operation.

In the third test case, you can choose $ a = 11 $ , $ b = 19 $ , $ c = 20 $ in the first operation, $ a = 13 $ , $ b = 14 $ , $ c = 15 $ in the second operation, and $ a = 10 $ , $ b = 17 $ , $ c = 21 $ in the third operation. After the three operations, the set $ s $ contains the following integers: $ 12 $ , $ 16 $ , $ 18 $ . It can be proven that it's impossible to perform more than $ 3 $ operations.

## Limit



Time Limit
1.00s

Memory Limit
250.00MB

Tags: greedy, math, number theory
Difficulty: 800
# Eri and Expanded Sets

## Problem Description

Let there be a set that contains distinct positive integers. To expand the set to contain as many integers as possible, Eri can choose two integers $ x\neq y $ from the set such that their average $ \frac{x+y}2 $ is still a positive integer and isn't contained in the set, and add it to the set. The integers $ x $ and $ y $ remain in the set.

Let's call the set of integers consecutive if, after the elements are sorted, the difference between any pair of adjacent elements is $ 1 $ . For example, sets $ \{2\} $ , $ \{2, 5, 4, 3\} $ , $ \{5, 6, 8, 7\} $ are consecutive, while $ \{2, 4, 5, 6\} $ , $ \{9, 7\} $ are not.

Eri likes consecutive sets. Suppose there is an array $ b $ , then Eri puts all elements in $ b $ into the set. If after a finite number of operations described above, the set can become consecutive, the array $ b $ will be called brilliant.

Note that if the same integer appears in the array multiple times, we only put it into the set once, as a set always contains distinct positive integers.

Eri has an array $ a $ of $ n $ positive integers. Please help him to count the number of pairs of integers $ (l,r) $ such that $ 1 \leq l \leq r \leq n $ and the subarray $ a_l, a_{l+1}, \ldots, a_r $ is brilliant.

## Input Format

Each test consists of multiple test cases. The first line contains a single integer $ t $ ( $ 1 \leq t \leq 10^4 $ ) — the number of test cases. The description of the test cases follows.

The first line of each test case contains a single integer $ n $ ( $ 1 \leq n \leq 4 \cdot 10^5 $ ) — length of the array $ a $ .

The second line of each test case contains $ n $ integers $ a_1, a_2, \ldots a_n $ ( $ 1 \leq a_i \leq 10^9 $ ) — the elements of the array $ a $ .

It is guaranteed that the sum of $ n $ over all test cases doesn't exceed $ 4 \cdot 10^5 $ .

## Output Format

For each test case, output a single integer — the number of brilliant subarrays.

## Sample #1

### Sample Input #1

```
6
2
2 2
6
1 3 6 10 15 21
5
6 30 18 36 9
1
1000000000
6
1 1 4 5 1 4
12
70 130 90 90 90 108 612 500 451 171 193 193
```

### Sample Output #1

```
3
18
5
1
18
53
```

## Hint

In the first test case, the array $ a = [2, 2] $ has $ 3 $ subarrays: $ [2] $ , $ [2] $ , and $ [2, 2] $ . For all of them, the set only contains a single integer $ 2 $ , therefore it's always consecutive. All these subarrays are brilliant, so the answer is $ 3 $ .

In the second test case, let's consider the subarray $ [3, 6, 10] $ . We can do operations as follows:

 $ $$$\{3,6,10\} \xrightarrow{x=6,y=10} \{3,6,8,10\} \xrightarrow{x=6,y=8} \{3,6,7,8,10\} \xrightarrow{x=3,y=7} \{3,5,6,7,8,10\} $ $     $ $ \xrightarrow{x=3,y=5} \{3,4,5,6,7,8,10\} \xrightarrow{x=8,y=10} \{3,4,5,6,7,8,9,10\} $ $  </center><p> $ \\{3,4,5,6,7,8,9,10\\} $  is a consecutive set, so the subarray  $ \[3, 6, 10\]$$$ is brilliant.

## Limit



Time Limit
3.00s

Memory Limit
500.00MB

Tags: data structures, divide and conquer, math, number theory, two pointers
Difficulty: 2300
# Subtangle Game (Easy Version)

## Problem Description

This is the easy version of the problem. The differences between the two versions are the constraints on all the variables. You can make hacks only if both versions of the problem are solved.

Tsovak and Narek are playing a game. They have an array $ a $ and a matrix $ b $ of integers with $ n $ rows and $ m $ columns, numbered from $ 1 $ . The cell in the $ i $ -th row and the $ j $ -th column is $ (i, j) $ .

They are looking for the elements of $ a $ in turns; Tsovak starts first. Each time a player looks for a cell in the matrix containing the current element of $ a $ (Tsovak looks for the first, then Narek looks for the second, etc.). Let's say a player has chosen the cell $ (r, c) $ . The next player has to choose his cell in the submatrix starting at $ (r + 1, c + 1) $ and ending in $ (n, m) $ (the submatrix can be empty if $ r=n $ or $ c=m $ ). If a player cannot find such a cell (or the remaining submatrix is empty) or the array ends (the previous player has chosen the last element), then he loses.

Your task is to determine the winner if the players play optimally.

## Input Format

The first line of the input contains $ t $ ( $ 1 \le t \le 300 $ ) – the number of test cases.

The first line of each test case contains three integers $ l $ , $ n $ , and $ m $ ( $ 1 \le l, n, m \le 300 $ ) – the size of the array and the sizes of the matrix.

The second line contains $ l $ integers $ a_1, a_2, a_3, \ldots a_l $ ( $ 1 \le a_i \le \min(7, n \cdot m) $ ) – the elements of the array $ a $ .

The $ i $ -th of the last $ n $ lines contains $ m $ integers $ b_{i,1}, b_{i,2}, b_{i,3}, \ldots b_{i,m} $ ( $ 1 \le b_{i,j} \le \min(7, n \cdot m) $ ) – representing the $ i $ -th row of the matrix.

It is guaranteed that the sum of $ n \cdot m $ over all test cases does not exceed $ 10^5 $ .

It is guaranteed that the sum of $ l $ over all test cases does not exceed $ 300 $ .

## Output Format

You should output $ t $ lines, the $ i $ -th of them containing a character representing the answer of the $ i $ -th test case: "T" if Tsovak wins or "N", otherwise (without quotes).

## Sample #1

### Sample Input #1

```
3
2 2 3
1 2
1 3 5
4 5 2
2 2 4
1 2
1 1 3 2
4 2 5 1
2 4 2
1 2
3 4
5 5
5 5
5 5
```

### Sample Output #1

```
N
T
N
```

## Hint

In the first example, Tsovak starts by looking for $ 1 $ . There is only one occurrence of $ 1 $ at $ (1,1) $ , so he chooses it. Then Narek needs to look for $ 2 $ in the submatrix of $ (2, 2) $ , which consists of just the last two elements: $ 5 $ and $ 2 $ . He chooses $ 2 $ , and then Tsovak loses since the array has ended.

In the second example, Tsovak needs to choose $ 1 $ . There is a $ 1 $ at the cell $ (n,m) $ , so he chooses that cell. Then, since the submatrix of $ (n + 1, m + 1) $ is empty, Narek cannot find $ 2 $ , so he loses.

## Limit



Time Limit
2.00s

Memory Limit
250.00MB

Tags: dp, games, greedy, implementation
Difficulty: 2100
# Alter the GCD

## Problem Description

You are given two arrays $ a_1, a_2, \ldots, a_n $ and $ b_1, b_2, \ldots, b_n $ .

You must perform the following operation exactly once:

- choose any indices $ l $ and $ r $ such that $ 1 \le l \le r \le n $ ;
- swap $ a_i $ and $ b_i $ for all $ i $ such that $ l \leq i \leq r $ .

Find the maximum possible value of $ \text{gcd}(a_1, a_2, \ldots, a_n) + \text{gcd}(b_1, b_2, \ldots, b_n) $ after performing the operation exactly once. Also find the number of distinct pairs $ (l, r) $ which achieve the maximum value.

## Input Format

In the first line of the input, you are given a single integer $ t $ ( $ 1 \le t \le 10^5 $ ), the number of test cases. Then the description of each test case follows.

In the first line of each test case, you are given a single integer $ n $ ( $ 1 \le n \le 2 \cdot 10^5 $ ), representing the number of integers in each array.

In the next line, you are given $ n $ integers $ a_1, a_2, \ldots, a_n $ ( $ 1 \le a_i \le 10^9 $ ) — the elements of the array $ a $ .

In the last line, you are given $ n $ integers $ b_1, b_2, \ldots, b_n $ ( $ 1 \le b_i \le 10^9 $ ) — the elements of the array $ b $ .

The sum of values of $ n $ over all test cases does not exceed $ 5 \cdot 10^5 $ .

## Output Format

For each test case, output a line with two integers: the maximum value of $ \text{gcd}(a_1, a_2, \ldots, a_n) + \text{gcd}(b_1, b_2, \ldots, b_n) $ after performing the operation exactly once, and the number of ways.

## Sample #1

### Sample Input #1

```
5
8
11 4 16 17 3 24 25 8
8 10 4 21 17 18 25 21
4
6 4 24 13
15 3 1 14
2
13 14
5 8
8
20 17 15 11 21 10 3 7
9 9 4 20 14 9 13 1
2
18 13
15 20
```

### Sample Output #1

```
2 36
3 2
2 3
2 36
6 1
```

## Hint

In the first, third, and fourth test cases, there's no way to achieve a higher GCD than $ 1 $ in any of the arrays, so the answer is $ 1 + 1 = 2 $ . Any pair $ (l, r) $ achieves the same result; for example, in the first test case there are $ 36 $ such pairs.

In the last test case, you must choose $ l = 1 $ , $ r = 2 $ to maximize the answer. In this case, the GCD of the first array is $ 5 $ , and the GCD of the second array is $ 1 $ , so the answer is $ 5 + 1 = 6 $ , and the number of ways is $ 1 $ .

## Limit



Time Limit
4.00s

Memory Limit
250.00MB

Tags: binary search, brute force, data structures, divide and conquer, implementation, number theory
Difficulty: 2400
# Simple Palindrome

## Problem Description

Narek has to spend 2 hours with some 2-year-old kids at the kindergarten. He wants to teach them competitive programming, and their first lesson is about palindromes.

Narek found out that the kids only know the vowels of the English alphabet (the letters $ \mathtt{a} $ , $ \mathtt{e} $ , $ \mathtt{i} $ , $ \mathtt{o} $ , and $ \mathtt{u} $ ), so Narek needs to make a string that consists of vowels only. After making the string, he'll ask the kids to count the number of subsequences that are palindromes. Narek wants to keep it simple, so he's looking for a string such that the amount of palindrome subsequences is minimal.

Help Narek find a string of length $ n $ , consisting of lowercase English vowels only (letters $ \mathtt{a} $ , $ \mathtt{e} $ , $ \mathtt{i} $ , $ \mathtt{o} $ , and $ \mathtt{u} $ ), which minimizes the amount of palindrome $ ^{\dagger} $ subsequences $ ^{\ddagger} $  in it.

 $ ^{\dagger} $ A string is called a palindrome if it reads the same from left to right and from right to left.

 $ ^{\ddagger} $ String $ t $ is a subsequence of string $ s $ if $ t $ can be obtained from $ s $ by removing several (possibly, zero or all) characters from $ s $ and concatenating the remaining ones, without changing their order. For example, $ \mathtt{odocs} $ is a subsequence of $ \texttt{c}{\color{red}{\texttt{od}}}\texttt{ef}{\color{red}{\texttt{o}}}\texttt{r}{\color{red}{\texttt{c}}}\texttt{e}{\color{red}{\texttt{s}}} $ .

## Input Format

The first line of the input contains a single integer $ t $ ( $ 1 \le t \le 100 $ ) — the number of test cases. Subsequently, the description of each test case follows.

The only line of each test case contains a single integer $ n $ ( $ 1 \le n \le 100 $ ) — the size of the string.

## Output Format

For each test case, output any string of length $ n $ that satisfies the above conditions.

## Sample #1

### Sample Input #1

```
3
2
3
6
```

### Sample Output #1

```
uo
iae
oeiiua
```

## Hint

In the first example, $ \texttt{uo} $ has only three palindrome subsequences: $ \texttt{u} $ , $ \texttt{o} $ , and the empty string. It can be shown that there is no better answer.

In the third example, $ \texttt{oeiiua} $ has only eight palindrome subsequences: $ \texttt{o} $ , $ \texttt{e} $ , $ \texttt{i} $ , $ \texttt{i} $ , $ \texttt{u} $ , $ \texttt{a} $ , $ \texttt{ii} $ , and the empty string. It can be shown that there is no better answer.

## Limit



Time Limit
1.00s

Memory Limit
250.00MB

Tags: combinatorics, constructive algorithms, greedy, math
Difficulty: 900
# Substring Compression

## Problem Description

Let's define the operation of compressing a string $ t $ , consisting of at least $ 2 $ digits from $ 1 $ to $ 9 $ , as follows:

- split it into an even number of non-empty substrings — let these substrings be $ t_1, t_2, \dots, t_m $ (so, $ t = t_1 + t_2 + \dots + t_m $ , where $ + $ is the concatenation operation);
- write the string $ t_2 $ $ t_1 $ times, then the string $ t_4 $ $ t_3 $ times, and so on.

For example, for a string "12345", one could do the following: split it into ("1", "23", "4", "5"), and write "235555".

Let the function $ f(t) $ for a string $ t $ return the minimum length of the string that can be obtained as a result of that process.

You are given a string $ s $ , consisting of $ n $ digits from $ 1 $ to $ 9 $ , and an integer $ k $ . Calculate the value of the function $ f $ for all contiguous substrings of $ s $ of length exactly $ k $ .

## Input Format

The first line contains two integers $ n $ and $ k $ ( $ 2 \le k \le n \le 2 \cdot 10^5 $ ).

The second line contains the string $ s $ ( $ |s| = n $ ), consisting only of digits from $ 1 $ to $ 9 $ .

## Output Format

Output $ n - k + 1 $ integers — $ f(s_{1,k}), f(s_{2,k+1}), \dots, f(s_{n - k + 1, n}) $ .

## Sample #1

### Sample Input #1

```
4 4
5999
```

### Sample Output #1

```
14
```

## Sample #2

### Sample Input #2

```
10 3
1111111111
```

### Sample Output #2

```
2 2 2 2 2 2 2 2
```

## Sample #3

### Sample Input #3

```
11 4
49998641312
```

### Sample Output #3

```
12 18 17 15 12 7 7 2
```

## Limit



Time Limit
2.00s

Memory Limit
1000.00MB

Tags: data structures, dp, matrices
Difficulty: 3200
# Make a Palindrome

## Problem Description

You are given an array $ a $ consisting of $ n $ integers.

Let the function $ f(b) $ return the minimum number of operations needed to make an array $ b $ a palindrome. The operations you can make are:

- choose two adjacent elements $ b_i $ and $ b_{i+1} $ , remove them, and replace them with a single element equal to $ (b_i + b_{i + 1}) $ ;
- or choose an element $ b_i > 1 $ , remove it, and replace it with two positive integers $ x $ and $ y $ ( $ x > 0 $ and $ y > 0 $ ) such that $ x + y = b_i $ .

For example, from an array $ b=[2, 1, 3] $ , you can obtain the following arrays in one operation: $ [1, 1, 1, 3] $ , $ [2, 1, 1, 2] $ , $ [3, 3] $ , $ [2, 4] $ , or $ [2, 1, 2, 1] $ .

Calculate $ \displaystyle \left(\sum_{1 \le l \le r \le n}{f(a[l..r])}\right) $ , where $ a[l..r] $ is the subarray of $ a $ from index $ l $ to index $ r $ , inclusive. In other words, find the sum of the values of the function $ f $ for all subarrays of the array $ a $ .

## Input Format

The first line contains a single integer $ t $ ( $ 1 \le t \le 1000 $ ) — the number of test cases.

The first line of each test case contains a single integer $ n $ ( $ 1 \le n \le 2000 $ ).

The second line contains $ n $ integers $ a_1, a_2, \dots, a_n $ ( $ 1 \le a_i \le 10^5 $ ).

Additional constraint on the input: the sum of $ n $ over all test cases does not exceed $ 2000 $ .

## Output Format

For each test case, print a single integer — the sum of the values of the function $ f $ for all subarrays of the array $ a $ .

## Sample #1

### Sample Input #1

```
4
3
2 1 3
4
1 1 1 1
5
4 2 3 1 5
4
1 2 1 2
```

### Sample Output #1

```
3
0
14
5
```

## Limit



Time Limit
5.00s

Memory Limit
500.00MB

Tags: binary search, brute force, data structures, greedy, math
Difficulty: 2600
# Not a Nim Problem

## Problem Description

Two players, Alice and Bob, are playing a game. They have $ n $ piles of stones, with the $ i $ -th pile initially containing $ a_i $ stones.

On their turn, a player can choose any pile of stones and take any positive number of stones from it, with one condition:

- let the current number of stones in the pile be $ x $ . It is not allowed to take from the pile a number of stones $ y $ such that the greatest common divisor of $ x $ and $ y $ is not equal to $ 1 $ .

The player who cannot make a move loses. Both players play optimally (that is, if a player has a strategy that allows them to win, no matter how the opponent responds, they will win). Alice goes first.

Determine who will win.

## Input Format

The first line contains a single integer $ t $ ( $ 1 \le t \le 10^4 $ ) — the number of test cases.

Each test case consists of two lines:

- the first line contains a single integer $ n $ ( $ 1 \le n \le 3 \cdot 10^5 $ );
- the second line contains $ n $ integers $ a_1, a_2, \dots, a_n $ ( $ 1 \le a_i \le 10^7 $ ).

Additional constraint on the input: the sum of $ n $ across all test cases does not exceed $ 3 \cdot 10^5 $ .

## Output Format

For each test case, output Alice if Alice wins, or Bob if Bob wins.

## Sample #1

### Sample Input #1

```
3
3
3 2 9
4
3 3 6 1
5
1 2 3 4 5
```

### Sample Output #1

```
Bob
Alice
Bob
```

## Limit



Time Limit
2.00s

Memory Limit
500.00MB

Tags: brute force, games, math, number theory
Difficulty: 2100
# Colored Portals

## Problem Description

There are $ n $ cities located on a straight line. The cities are numbered from $ 1 $ to $ n $ .

Portals are used to move between cities. There are $ 4 $ colors of portals: blue, green, red, and yellow. Each city has portals of two different colors. You can move from city $ i $ to city $ j $ if they have portals of the same color (for example, you can move between a "blue-red" city and a "blue-green" city). This movement costs $ |i-j| $ coins.

Your task is to answer $ q $ independent queries: calculate the minimum cost to move from city $ x $ to city $ y $ .

## Input Format

The first line contains a single integer $ t $ ( $ 1 \le t \le 10^4 $ ) — the number of test cases.

The first line of each test case contains two integers $ n $ and $ q $ ( $ 1 \le n, q \le 2 \cdot 10^5 $ ) — the number of cities and the number of queries, respectively.

The second line contains $ n $ strings of the following types: BG, BR, BY, GR, GY, or RY; the $ i $ -th of them describes the portals located in the $ i $ -th city; the symbol B indicates that there is a blue portal in the city, G — green, R — red, and Y — yellow.

The $ j $ -th of the next $ q $ lines contains two integers $ x_j $ and $ y_j $ ( $ 1 \le x_j, y_j \le n $ ) — the description of the $ j $ -th query.

Additional constraints on the input:

- the sum of $ n $ over all test cases does not exceed $ 2 \cdot 10^5 $ ;
- the sum of $ q $ over all test cases does not exceed $ 2 \cdot 10^5 $ .

## Output Format

For each query, print a single integer — the minimum cost to move from city $ x $ to city $ y $ (or $ -1 $ if it is impossible).

## Sample #1

### Sample Input #1

```
2
4 5
BR BR GY GR
1 2
3 1
4 4
1 4
4 2
2 1
BG RY
1 2
```

### Sample Output #1

```
1
4
0
3
2
-1
```

## Limit



Time Limit
2.00s

Memory Limit
250.00MB

Tags: binary search, brute force, data structures, graphs, greedy, implementation, shortest paths
Difficulty: 1600
# Splitting Items

## Problem Description

Alice and Bob have $ n $ items they'd like to split between them, so they decided to play a game. All items have a cost, and the $ i $ -th item costs $ a_i $ . Players move in turns starting from Alice.

In each turn, the player chooses one of the remaining items and takes it. The game goes on until no items are left.

Let's say that $ A $ is the total cost of items taken by Alice and $ B $ is the total cost of Bob's items. The resulting score of the game then will be equal to $ A - B $ .

Alice wants to maximize the score, while Bob wants to minimize it. Both Alice and Bob will play optimally.

But the game will take place tomorrow, so today Bob can modify the costs a little. He can increase the costs $ a_i $ of several (possibly none or all) items by an integer value (possibly, by the same value or by different values for each item). However, the total increase must be less than or equal to $ k $ . Otherwise, Alice may suspect something. Note that Bob can't decrease costs, only increase.

What is the minimum possible score Bob can achieve?

## Input Format

The first line contains a single integer $ t $ ( $ 1 \le t \le 5000 $ ) — the number of test cases. Then $ t $ cases follow.

The first line of each test case contains two integers $ n $ and $ k $ ( $ 2 \le n \le 2 \cdot 10^5 $ ; $ 0 \le k \le 10^9 $ ) — the number of items and the maximum total increase Bob can make.

The second line of each test case contains $ n $ integers $ a_1, a_2, \dots, a_n $ ( $ 1 \le a_i \le 10^9 $ ) — the initial costs of the items.

It's guaranteed that the sum of $ n $ over all test cases doesn't exceed $ 2 \cdot 10^5 $ .

## Output Format

For each test case, print a single integer — the minimum possible score $ A - B $ after Bob increases the costs of several (possibly none or all) items.

## Sample #1

### Sample Input #1

```
4
2 5
1 10
3 0
10 15 12
4 6
3 1 2 4
2 4
6 9
```

### Sample Output #1

```
4
13
0
0
```

## Hint

In the first test case, Bob can increase $ a_1 $ by $ 5 $ , making costs equal to $ [6, 10] $ . Tomorrow, Alice will take $ 10 $ and Bob will take $ 6 $ . The total score will be equal to $ 10 - 6 = 4 $ , and it's the minimum possible.

In the second test case, Bob can't change costs. So the score will be equal to $ (15 + 10) - 12 = 13 $ , since Alice will take $ 15 $ , Bob will take $ 12 $ , and Alice — $ 10 $ .

In the third test case, Bob, for example, can increase $ a_1 $ by $ 1 $ , $ a_2 $ by $ 3 $ , and $ a_3 $ by $ 2 $ . The total change is equal to $ 1 + 3 + 2 \le 6 $ and costs will be equal to $ [4, 4, 4, 4] $ . Obviously, the score will be equal to $ (4 + 4) - (4 + 4) = 0 $ .

In the fourth test case, Bob can increase $ a_1 $ by $ 3 $ , making costs equal to $ [9, 9] $ . The score will be equal to $ 9 - 9 = 0 $ .

## Limit



Time Limit
2.00s

Memory Limit
250.00MB

Tags: games, greedy, sortings
Difficulty: 1100