1337xyz1337xyz/codeforces-editorial-full-2026-07-16 huggingface dataset:
Koxia and Number Theory
Contest: Good Bye 2022: 2023 is NEAR
Difficulty rating: 1700
Tags: brute force, chinese remainder theorem, math, number theory

Joi has an array $$$a$$$ of $$$n$$$ positive integers. Koxia wants you to determine whether there exists a positive integer $$$x > 0$$$ such that $$$\gcd(a_i+x,a_j+x)=1$$$ for all $$$1 \leq i < j \leq n$$$.

Here $$$\gcd(y, z)$$$ denotes the greatest common divisor (GCD) of integers $$$y$$$ and $$$z$$$.

Input format:
Each test consists of multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \le t \le 100$$$) — the number of test cases. The description of test cases follows.

The first line of each test case contains an integer $$$n$$$ ($$$2 \leq n \leq 100$$$) — the size of the array.

The second line of each test case contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$1 \leq a_i \leq {10}^{18}$$$).

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

Output format:
For each test case, output "YES" (without quotes) if there exists a positive integer $$$x$$$ such that $$$\gcd(a_i+x,a_j+x)=1$$$ for all $$$1 \leq i < j \leq n$$$, and "NO" (without quotes) otherwise.

You can output the answer in any case (upper or lower). For example, the strings "yEs", "yes", "Yes", and "YES" will be recognized as positive responses.

Constraints:
Time limit: 1.0 s
Memory limit: 256.0 MB

Note:
In the first test case, we can set $$$x = 4$$$. This is valid because:

- When $$$i=1$$$ and $$$j=2$$$, $$$\gcd(a_i+x,a_j+x)=\gcd(5+4,7+4)=\gcd(9,11)=1$$$.
- When $$$i=1$$$ and $$$j=3$$$, $$$\gcd(a_i+x,a_j+x)=\gcd(5+4,10+4)=\gcd(9,14)=1$$$.
- When $$$i=2$$$ and $$$j=3$$$, $$$\gcd(a_i+x,a_j+x)=\gcd(7+4,10+4)=\gcd(11,14)=1$$$.

In the second test case, any choice of $$$x$$$ makes $$$\gcd(a_1 + x, a_2 + x) = \gcd(3+x,3+x)=3+x$$$. Therefore, no such $$$x$$$ exists.

Example input:
2
3
5 7 10
3
3 3 4

Example output:
YES
NO

Editorial:
Koxia and Game
Contest: Good Bye 2022: 2023 is NEAR
Difficulty rating: 2000
Tags: constructive algorithms, data structures, dfs and similar, dsu, flows, games, graph matchings, graphs, implementation

Koxia and Mahiru are playing a game with three arrays $$$a$$$, $$$b$$$, and $$$c$$$ of length $$$n$$$. Each element of $$$a$$$, $$$b$$$ and $$$c$$$ is an integer between $$$1$$$ and $$$n$$$ inclusive.

The game consists of $$$n$$$ rounds. In the $$$i$$$-th round, they perform the following moves:

- Let $$$S$$$ be the multiset $$$\{a_i, b_i, c_i\}$$$.
- Koxia removes one element from the multiset $$$S$$$ by her choice.
- Mahiru chooses one integer from the two remaining in the multiset $$$S$$$.

Let $$$d_i$$$ be the integer Mahiru chose in the $$$i$$$-th round. If $$$d$$$ is a permutation$$$^\dagger$$$, Koxia wins. Otherwise, Mahiru wins.

Currently, only the arrays $$$a$$$ and $$$b$$$ have been chosen. As an avid supporter of Koxia, you want to choose an array $$$c$$$ such that Koxia will win. Count the number of such $$$c$$$, modulo $$$998\,244\,353$$$.

Note that Koxia and Mahiru both play optimally.

$$$^\dagger$$$ A permutation of length $$$n$$$ is an array consisting of $$$n$$$ distinct integers from $$$1$$$ to $$$n$$$ in arbitrary order. For example, $$$[2,3,1,5,4]$$$ is a permutation, but $$$[1,2,2]$$$ is not a permutation ($$$2$$$ appears twice in the array), and $$$[1,3,4]$$$ is also not a permutation ($$$n=3$$$ but there is $$$4$$$ in the array).

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

The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq {10}^5$$$) — the size of the arrays.

The second line of each test case contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$1 \leq a_i \leq n$$$).

The third line of each test case contains $$$n$$$ integers $$$b_1, b_2, \dots, b_n$$$ ($$$1 \leq b_i \leq n$$$).

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

Output format:
Output a single integer — the number of $$$c$$$ makes Koxia win, modulo $$$998\,244\,353$$$.

Constraints:
Time limit: 2.0 s
Memory limit: 256.0 MB

Note:
In the first test case, there are $$$6$$$ possible arrays $$$c$$$ that make Koxia win — $$$[1, 2, 3]$$$, $$$[1, 3, 2]$$$, $$$[2, 2, 3]$$$, $$$[2, 3, 2]$$$, $$$[3, 2, 3]$$$, $$$[3, 3, 2]$$$.

In the second test case, it can be proved that no array $$$c$$$ makes Koxia win.

Example input:
2
3
1 2 2
1 3 3
5
3 3 1 3 4
4 5 2 5 5

Example output:
6
0

Editorial:
Koxia and Sequence
Contest: Good Bye 2022: 2023 is NEAR
Difficulty rating: 3100
Tags: bitmasks, combinatorics, dp, math, number theory

Mari has three integers $$$n$$$, $$$x$$$, and $$$y$$$.

Call an array $$$a$$$ of $$$n$$$ non-negative integers good if it satisfies the following conditions:

- $$$a_1+a_2+\ldots+a_n=x$$$, and
- $$$a_1 \, | \, a_2 \, | \, \ldots \, | \, a_n=y$$$, where $$$|$$$ denotes the bitwise OR operation.

The score of a good array is the value of $$$a_1 \oplus a_2 \oplus \ldots \oplus a_n$$$, where $$$\oplus$$$ denotes the bitwise XOR operation.

Koxia wants you to find the total bitwise XOR of the scores of all good arrays. If there are no good arrays, output $$$0$$$ instead.

Input format:
The first line of input contains three integers $$$n$$$, $$$x$$$ and $$$y$$$ ($$$1 \leq n < 2^{40}$$$, $$$0 \leq x < 2^{60}$$$, $$$0 \leq y < 2^{20}$$$).

Output format:
Output a single integer — the total bitwise XOR of the scores of all good arrays.

Constraints:
Time limit: 1.0 s
Memory limit: 256.0 MB

Note:
In the first test case, there are $$$12$$$ good arrays totally as follows.

- $$$[0,2,3]$$$, $$$[0,3,2]$$$, $$$[2,0,3]$$$, $$$[2,3,0]$$$, $$$[3,0,2]$$$ and $$$[3,2,0]$$$ — the score is $$$0 \oplus 2 \oplus 3 = 1$$$;
- $$$[1, 2, 2]$$$, $$$[2, 1, 2]$$$ and $$$[2, 2, 1]$$$ — the score is $$$1 \oplus 2 \oplus 2 = 1$$$;
- $$$[1, 1, 3]$$$, $$$[1, 3, 1]$$$ and $$$[3, 1, 1]$$$ — the score is $$$1 \oplus 1 \oplus 3 = 3$$$.

Therefore, the total bitwise xor of the scores is $$$\underbrace{1 \oplus \ldots \oplus 1}_{9\text{ times}} \oplus 3 \oplus 3 \oplus 3 = 2$$$.

In the second test case, there are no good sequences. The output should be $$$0$$$.

Example input:
3 5 3

Example output:
2

Example input:
100 0 100

Example output:
0

Editorial:
Koxia and Bracket
Contest: Good Bye 2022: 2023 is NEAR
Difficulty rating: 3400
Tags: divide and conquer, fft, math

Chiyuu has a bracket sequence$$$^\dagger$$$ $$$s$$$ of length $$$n$$$. Let $$$k$$$ be the minimum number of characters that Chiyuu has to remove from $$$s$$$ to make $$$s$$$ balanced$$$^\ddagger$$$.

Now, Koxia wants you to count the number of ways to remove $$$k$$$ characters from $$$s$$$ so that $$$s$$$ becomes balanced, modulo $$$998\,244\,353$$$.

Note that two ways of removing characters are considered distinct if and only if the set of indices removed is different.

$$$^\dagger$$$ A bracket sequence is a string containing only the characters "(" and ")".

$$$^\ddagger$$$ A bracket sequence is called balanced if one can turn it into a valid math expression by adding characters + and 1. For example, sequences (())(), (), (()(())) and the empty string are balanced, while )(, ((), and (()))( are not.

Input format:
The first line of input contains a string $$$s$$$ ($$$1 \leq |s| \leq 5 \cdot {10}^5$$$) — the bracket sequence.

It is guaranteed that $$$s$$$ only contains the characters "(" and ")".

Output format:
Output a single integer — the number of ways to remove $$$k$$$ characters from $$$s$$$ so that $$$s$$$ becomes balanced, modulo $$$998\,244\,353$$$.

Constraints:
Time limit: 5.0 s
Memory limit: 256.0 MB

Note:
In the first test case, it can be proved that the minimum number of characters that Chiyuu has to remove is $$$2$$$. There are $$$4$$$ ways to remove $$$2$$$ characters to make $$$s$$$ balanced as follows. Deleted characters are noted as red.

- $$$\texttt{(} \color{Red}{\texttt{)}} \texttt{)} \color{Red}{\texttt{(}} \texttt{(} \texttt{)}$$$,
- $$$\texttt{(} \texttt{)} \color{Red}{\texttt{)}} \color{Red}{\texttt{(}} \texttt{(} \texttt{)}$$$,
- $$$\texttt{(} \color{Red}{\texttt{)}} \texttt{)} \texttt{(} \color{Red}{\texttt{(}} \texttt{)}$$$,
- $$$\texttt{(} \texttt{)} \color{Red}{\texttt{)}} \texttt{(} \color{Red}{\texttt{(}} \texttt{)}$$$.

In the second test case, the only way to make $$$s$$$ balanced is by deleting the only character to get an empty bracket sequence, which is considered balanced.

Example input:
())(()

Example output:
4

Example input:
(

Example output:
1

Editorial:
Alex and a Rhombus
Contest: Codeforces Round 569 (Div. 2)
Difficulty rating: 800
Tags: dp, implementation, math

While playing with geometric figures Alex has accidentally invented a concept of a $$$n$$$-th order rhombus in a cell grid.

A $$$1$$$-st order rhombus is just a square $$$1 \times 1$$$ (i.e just a cell).

A $$$n$$$-th order rhombus for all $$$n \geq 2$$$ one obtains from a $$$n-1$$$-th order rhombus adding all cells which have a common side with it to it (look at the picture to understand it better).

Alex asks you to compute the number of cells in a $$$n$$$-th order rhombus.

Input format:
The first and only input line contains integer $$$n$$$ ($$$1 \leq n \leq 100$$$) — order of a rhombus whose numbers of cells should be computed.

Output format:
Print exactly one integer — the number of cells in a $$$n$$$-th order rhombus.

Constraints:
Time limit: 1.0 s
Memory limit: 256.0 MB

Note:
Images of rhombus corresponding to the examples are given in the statement.

Example input:
1

Example output:
1

Example input:
2

Example output:
5

Editorial:
Looking into the picture attentively, one can realize that there are $$$2$$$ rows with one cell, $$$2$$$ rows with two cells, ..., and $$$1$$$ row with $$$n$$$ cells. Thus the answer can be easily computed by $$$O(n)$$$.
Nick and Array
Contest: Codeforces Round 569 (Div. 2)
Difficulty rating: 1500
Tags: greedy, implementation

Nick had received an awesome array of integers $$$a=[a_1, a_2, \dots, a_n]$$$ as a gift for his $$$5$$$ birthday from his mother. He was already going to explore its various properties but after unpacking he was disappointed a lot because the product $$$a_1 \cdot a_2 \cdot \dots a_n$$$ of its elements seemed to him not large enough.

He was ready to throw out the array, but his mother reassured him. She told him, that array would not be spoiled after the following operation: choose any index $$$i$$$ ($$$1 \le i \le n$$$) and do $$$a_i := -a_i - 1$$$.

For example, he can change array $$$[3, -1, -4, 1]$$$ to an array $$$[-4, -1, 3, 1]$$$ after applying this operation to elements with indices $$$i=1$$$ and $$$i=3$$$.

Kolya had immediately understood that sometimes it's possible to increase the product of integers of the array a lot. Now he has decided that he wants to get an array with the maximal possible product of integers using only this operation with its elements (possibly zero, one or more times, as many as he wants), it is not forbidden to do this operation several times for the same index.

Help Kolya and print the array with the maximal possible product of elements $$$a_1 \cdot a_2 \cdot \dots a_n$$$ which can be received using only this operation in some order.

If there are multiple answers, print any of them.

Input format:
The first line contains integer $$$n$$$ ($$$1 \leq n \leq 10^{5}$$$) — number of integers in the array.

The second line contains $$$n$$$ integers $$$a_1, a_2, \ldots, a_n$$$ ($$$-10^{6} \leq a_i \leq 10^{6}$$$) — elements of the array

Output format:
Print $$$n$$$ numbers — elements of the array with the maximal possible product of elements which can be received using only this operation in some order from the given array.

If there are multiple answers, print any of them.

Constraints:
Time limit: 1.0 s
Memory limit: 256.0 MB

Example input:
4
2 2 2 2

Example output:
-3 -3 -3 -3

Example input:
1
0

Example output:
0

Editorial:
Initially, we are going to make a product maximal by absolute value. It means that if $$$a_i \geq 0$$$ we are going to apply described operation (i.e to increase the absolute value). Now if the product is already positive, it's the answer. Else to apply the operation to the minimal number is obviously optimal (if we applied the operation to any other number the result would not be greater by absolute value, but applying to the minimum we have received non-negative product already). Thus the solution works in $$$O(n)$$$.
Karen and Morning
Contest: Codeforces Round 419 (Div. 2)
Difficulty rating: 1000
Tags: brute force, implementation

Karen is getting ready for a new school day!

It is currently hh:mm, given in a 24-hour format. As you know, Karen loves palindromes, and she believes that it is good luck to wake up when the time is a palindrome.

What is the minimum number of minutes she should sleep, such that, when she wakes up, the time is a palindrome?

Remember that a palindrome is a string that reads the same forwards and backwards. For instance, 05:39 is not a palindrome, because 05:39 backwards is 93:50. On the other hand, 05:50 is a palindrome, because 05:50 backwards is 05:50.

Input format:
The first and only line of input contains a single string in the format hh:mm (00 ≤  hh  ≤ 23, 00 ≤  mm  ≤ 59).

Output format:
Output a single integer on a line by itself, the minimum number of minutes she should sleep, such that, when she wakes up, the time is a palindrome.

Constraints:
Time limit: 2.0 s
Memory limit: 512.0 MB

Note:
In the first test case, the minimum number of minutes Karen should sleep for is 11. She can wake up at 05:50, when the time is a palindrome.

In the second test case, Karen can wake up immediately, as the current time, 13:31, is already a palindrome.

In the third test case, the minimum number of minutes Karen should sleep for is 1 minute. She can wake up at 00:00, when the time is a palindrome.

Example input:
05:39

Example output:
11

Example input:
13:31

Example output:
0

Editorial:
This is a rather straightforward implementation problem.
The only observation here is that there are only 1440 different possible times. It is enough to iterate through all of them until we encounter a palindromic time, and count the number of times we had to check before we reached a palindromic time.
How do we iterate through them? The most straightforward way is to simply convert the given string into two integers h and m. We can do this manually or maybe use some functions specific to your favorite language. It is good to be familiar with how your language deals with strings. It is also possible, though inadvisable, to try to work with the string directly.
To go to the next time, we simply increment m. If m becomes 60, then make it 0 and increment h. If h becomes 24, then make it 0.
To check whether a given time is palindromic, we simply need to check if the tens digit of h is the same as the ones digit of m, and if the ones digit of h is the same as the tens digit of m. This can be done like so: check if $$\lfloor \frac{h}{10} \rfloor = m \mod 10$$ and $$h \bmod 10 = \left\lfloor \frac{m}{10} \right\rfloor$$.
Another way is to simply cross-check against a list of palindromic times. Just be careful not to miss any of them, and not to add any extraneous values. There are 16 palindromic times, namely: 00: 00, 01: 10, 02: 20, 03: 30, 04: 40, 05: 50, 10: 01, 11: 11, 12: 21, 13: 31, 14: 41, 15: 51, 20: 02, 21: 12, 22: 22 and 23: 32.
Phoenix and Balance
Contest: Codeforces Round 638 (Div. 2)
Difficulty rating: 800
Tags: greedy, math

Phoenix has $$$n$$$ coins with weights $$$2^1, 2^2, \dots, 2^n$$$. He knows that $$$n$$$ is even.

He wants to split the coins into two piles such that each pile has exactly $$$\frac{n}{2}$$$ coins and the difference of weights between the two piles is minimized. Formally, let $$$a$$$ denote the sum of weights in the first pile, and $$$b$$$ denote the sum of weights in the second pile. Help Phoenix minimize $$$|a-b|$$$, the absolute value of $$$a-b$$$.

Input format:
The input consists of multiple test cases. The first line contains an integer $$$t$$$ ($$$1 \le t \le 100$$$) — the number of test cases.

The first line of each test case contains an integer $$$n$$$ ($$$2 \le n \le 30$$$; $$$n$$$ is even) — the number of coins that Phoenix has.

Output format:
For each test case, output one integer — the minimum possible difference of weights between the two piles.

Constraints:
Time limit: 2.0 s
Memory limit: 256.0 MB

Note:
In the first test case, Phoenix has two coins with weights $$$2$$$ and $$$4$$$. No matter how he divides the coins, the difference will be $$$4-2=2$$$.

In the second test case, Phoenix has four coins of weight $$$2$$$, $$$4$$$, $$$8$$$, and $$$16$$$. It is optimal for Phoenix to place coins with weights $$$2$$$ and $$$16$$$ in one pile, and coins with weights $$$4$$$ and $$$8$$$ in another pile. The difference is $$$(2+16)-(4+8)=6$$$.

Example input:
2
2
4

Example output:
2
6

Editorial:
We observe that the coin with the weight $$$2^n$$$ is greater than the sum of all the other weights combined. This is true because $$$\sum\limits_{i = 1}^{n-1}2^i=2^n-2$$$. Therefore, the pile that has the heaviest coin will always weigh more. To minimize the weight differences, we put the $$$n/2-1$$$ lightest coins into the pile with the heaviest coin. The answer will be $$$(2^n+\sum\limits_{i = 1}^{n/2-1}2^i)-\sum\limits_{i = n/2}^{n-1}2^i$$$.
Time complexity for each test case: $$$O(n)$$$
You can also solve the problem in $$$O(1)$$$ by simplifying the mathematical expression.
Love Triangle
Contest: Codeforces Round 464 (Div. 2)
Difficulty rating: 800
Tags: graphs

As you could know there are no male planes nor female planes. However, each plane on Earth likes some other plane. There are n planes on Earth, numbered from 1 to n, and the plane with number i likes the plane with number fi, where 1 ≤ fi ≤ n and fi ≠ i.

We call a love triangle a situation in which plane A likes plane B, plane B likes plane C and plane C likes plane A. Find out if there is any love triangle on Earth.

Input format:
The first line contains a single integer n (2 ≤ n ≤ 5000) — the number of planes.

The second line contains n integers f1, f2, ..., fn (1 ≤ fi ≤ n, fi ≠ i), meaning that the i-th plane likes the fi-th.

Output format:
Output «YES» if there is a love triangle consisting of planes on Earth. Otherwise, output «NO».

You can output any letter in lower case or in upper case.

Constraints:
Time limit: 1.0 s
Memory limit: 256.0 MB

Note:
In first example plane 2 likes plane 4, plane 4 likes plane 1, plane 1 likes plane 2 and that is a love triangle.

In second example there are no love triangles.

Example input:
5
2 4 5 1 3

Example output:
YES

Example input:
5
5 5 5 5 1

Example output:
NO

Editorial:
It is enough to check if there is some i such that fffi = i, i. e. f[f[f[i]]] == i.
Hamster Farm
Contest: Codeforces Round 464 (Div. 2)
Difficulty rating: 1000
Tags: implementation

Dima has a hamsters farm. Soon N hamsters will grow up on it and Dima will sell them in a city nearby.

Hamsters should be transported in boxes. If some box is not completely full, the hamsters in it are bored, that's why each box should be completely full with hamsters.

Dima can buy boxes at a factory. The factory produces boxes of K kinds, boxes of the i-th kind can contain in themselves ai hamsters. Dima can buy any amount of boxes, but he should buy boxes of only one kind to get a wholesale discount.

Of course, Dima would buy boxes in such a way that each box can be completely filled with hamsters and transported to the city. If there is no place for some hamsters, Dima will leave them on the farm.

Find out how many boxes and of which type should Dima buy to transport maximum number of hamsters.

Input format:
The first line contains two integers N and K (0 ≤ N ≤ 1018, 1 ≤ K ≤ 105) — the number of hamsters that will grow up on Dima's farm and the number of types of boxes that the factory produces.

The second line contains K integers a1, a2, ..., aK (1 ≤ ai ≤ 1018 for all i) — the capacities of boxes.

Output format:
Output two integers: the type of boxes that Dima should buy and the number of boxes of that type Dima should buy. Types of boxes are numbered from 1 to K in the order they are given in input.

If there are many correct answers, output any of them.

Constraints:
Time limit: 2.0 s
Memory limit: 256.0 MB

Example input:
19 3
5 4 10

Example output:
2 4

Example input:
28 3
5 6 30

Example output:
1 5

Editorial:
The easies way to solve this problem is to find the minimum number of hamsters that can be left on the farm. If Dima byes boxes of the i-th type, there are $$n \bmod a_i$$ hamsters left on the farm. So we should find such a type x, that the value $$n \bmod a_x$$ is minimum among all x; The number of boxes to buy is then equal to $$n \operatorname{div} a_{x}$$.
Convenient For Everybody
Contest: Codeforces Round 464 (Div. 2)
Difficulty rating: 1600
Tags: binary search, two pointers

In distant future on Earth day lasts for n hours and that's why there are n timezones. Local times in adjacent timezones differ by one hour. For describing local time, hours numbers from 1 to n are used, i.e. there is no time "0 hours", instead of it "n hours" is used. When local time in the 1-st timezone is 1 hour, local time in the i-th timezone is i hours.

Some online programming contests platform wants to conduct a contest that lasts for an hour in such a way that its beginning coincides with beginning of some hour (in all time zones). The platform knows, that there are ai people from i-th timezone who want to participate in the contest. Each person will participate if and only if the contest starts no earlier than s hours 00 minutes local time and ends not later than f hours 00 minutes local time. Values s and f are equal for all time zones. If the contest starts at f hours 00 minutes local time, the person won't participate in it.

Help platform select such an hour, that the number of people who will participate in the contest is maximum.

Input format:
The first line contains a single integer n (2 ≤ n ≤ 100 000) — the number of hours in day.

The second line contains n space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 10 000), where ai is the number of people in the i-th timezone who want to participate in the contest.

The third line contains two space-separated integers s and f (1 ≤ s < f ≤ n).

Output format:
Output a single integer — the time of the beginning of the contest (in the first timezone local time), such that the number of participants will be maximum possible. If there are many answers, output the smallest among them.

Constraints:
Time limit: 2.0 s
Memory limit: 256.0 MB

Note:
In the first example, it's optimal to start competition at 3 hours (in first timezone). In this case, it will be 1 hour in the second timezone and 2 hours in the third timezone. Only one person from the first timezone won't participate.

In second example only people from the third and the fourth timezones will participate.

Example input:
3
1 2 3
1 3

Example output:
3

Example input:
5
1 2 3 4 1
1 3

Example output:
4

Editorial:
Initially, compute prefix sums: for each i the total number of people in timezones from the first to the i-th. Let's loop through all possible starting times of the competition. Each starting time gives as one or two segments of timezones, in which people will compete in the contest. We can easily compute the total number of participants in O(1) with the use of prefix sums. The total complexity is O(N).