Split (1)

train · 24.3k rows

question large_stringlengths 265 13.2k
Solve the programming task below in a Python markdown code block. A correct expression of the form a+b=c was written; a, b and c are non-negative integers without leading zeros. In this expression, the plus and equally signs were lost. The task is to restore the expression. In other words, one character '+' and one character '=' should be inserted into given sequence of digits so that: * character'+' is placed on the left of character '=', * characters '+' and '=' split the sequence into three non-empty subsequences consisting of digits (let's call the left part a, the middle part — b and the right part — c), * all the three parts a, b and c do not contain leading zeros, * it is true that a+b=c. It is guaranteed that in given tests answer always exists. Input The first line contains a non-empty string consisting of digits. The length of the string does not exceed 106. Output Output the restored expression. If there are several solutions, you can print any of them. Note that the answer at first should contain two terms (divided with symbol '+'), and then the result of their addition, before which symbol'=' should be. Do not separate numbers and operation signs with spaces. Strictly follow the output format given in the examples. If you remove symbol '+' and symbol '=' from answer string you should get a string, same as string from the input data. Examples Input 12345168 Output 123+45=168 Input 099 Output 0+9=9 Input 199100 Output 1+99=100 Input 123123123456456456579579579 Output 123123123+456456456=579579579 The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. A newspaper is published in Walrusland. Its heading is s1, it consists of lowercase Latin letters. Fangy the little walrus wants to buy several such newspapers, cut out their headings, glue them one to another in order to get one big string. After that walrus erase several letters from this string in order to get a new word s2. It is considered that when Fangy erases some letter, there's no whitespace formed instead of the letter. That is, the string remains unbroken and it still only consists of lowercase Latin letters. For example, the heading is "abc". If we take two such headings and glue them one to the other one, we get "abcabc". If we erase the letters on positions 1 and 5, we get a word "bcac". Which least number of newspaper headings s1 will Fangy need to glue them, erase several letters and get word s2? Input The input data contain two lines. The first line contain the heading s1, the second line contains the word s2. The lines only consist of lowercase Latin letters (1 ≤ \|s1\| ≤ 104, 1 ≤ \|s2\| ≤ 106). Output If it is impossible to get the word s2 in the above-described manner, print "-1" (without the quotes). Otherwise, print the least number of newspaper headings s1, which Fangy will need to receive the word s2. Examples Input abc xyz Output -1 Input abcd dabc Output 2 The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Ghosts live in harmony and peace, they travel the space without any purpose other than scare whoever stands in their way. There are n ghosts in the universe, they move in the OXY plane, each one of them has its own velocity that does not change in time: \overrightarrow{V} = V_{x}\overrightarrow{i} + V_{y}\overrightarrow{j} where V_{x} is its speed on the x-axis and V_{y} is on the y-axis. A ghost i has experience value EX_i, which represent how many ghosts tried to scare him in his past. Two ghosts scare each other if they were in the same cartesian point at a moment of time. As the ghosts move with constant speed, after some moment of time there will be no further scaring (what a relief!) and the experience of ghost kind GX = ∑_{i=1}^{n} EX_i will never increase. Tameem is a red giant, he took a picture of the cartesian plane at a certain moment of time T, and magically all the ghosts were aligned on a line of the form y = a ⋅ x + b. You have to compute what will be the experience index of the ghost kind GX in the indefinite future, this is your task for today. Note that when Tameem took the picture, GX may already be greater than 0, because many ghosts may have scared one another at any moment between [-∞, T]. Input The first line contains three integers n, a and b (1 ≤ n ≤ 200000, 1 ≤ \|a\| ≤ 10^9, 0 ≤ \|b\| ≤ 10^9) — the number of ghosts in the universe and the parameters of the straight line. Each of the next n lines contains three integers x_i, V_{xi}, V_{yi} (-10^9 ≤ x_i ≤ 10^9, -10^9 ≤ V_{x i}, V_{y i} ≤ 10^9), where x_i is the current x-coordinate of the i-th ghost (and y_i = a ⋅ x_i + b). It is guaranteed that no two ghosts share the same initial position, in other words, it is guaranteed that for all (i,j) x_i ≠ x_j for i ≠ j. Output Output one line: experience index of the ghost kind GX in the indefinite future. Examples Input 4 1 1 1 -1 -1 2 1 1 3 1 1 4 -1 -1 Output 8 Input 3 1 0 -1 1 0 0 0 -1 1 -1 -2 Output 6 Input 3 1 0 0 0 0 1 0 0 2 0 0 Output 0 Note There are four collisions (1,2,T-0.5), (1,3,T-1), (2,4,T+1), (3,4,T+0.5), where (u,v,t) means a collision happened between ghosts u and v at moment t. At each collision, each ghost gained one experience point, this means that GX = 4 ⋅ 2 = 8. In the second test, all points will collide when t = T + 1. <image> The red arrow represents the 1-st ghost velocity, orange represents the 2-nd ghost velocity, and blue represents the 3-rd ghost velocity. The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. For a vector \vec{v} = (x, y), define \|v\| = √{x^2 + y^2}. Allen had a bit too much to drink at the bar, which is at the origin. There are n vectors \vec{v_1}, \vec{v_2}, ⋅⋅⋅, \vec{v_n}. Allen will make n moves. As Allen's sense of direction is impaired, during the i-th move he will either move in the direction \vec{v_i} or -\vec{v_i}. In other words, if his position is currently p = (x, y), he will either move to p + \vec{v_i} or p - \vec{v_i}. Allen doesn't want to wander too far from home (which happens to also be the bar). You need to help him figure out a sequence of moves (a sequence of signs for the vectors) such that his final position p satisfies \|p\| ≤ 1.5 ⋅ 10^6 so that he can stay safe. Input The first line contains a single integer n (1 ≤ n ≤ 10^5) — the number of moves. Each of the following lines contains two space-separated integers x_i and y_i, meaning that \vec{v_i} = (x_i, y_i). We have that \|v_i\| ≤ 10^6 for all i. Output Output a single line containing n integers c_1, c_2, ⋅⋅⋅, c_n, each of which is either 1 or -1. Your solution is correct if the value of p = ∑_{i = 1}^n c_i \vec{v_i}, satisfies \|p\| ≤ 1.5 ⋅ 10^6. It can be shown that a solution always exists under the given constraints. Examples Input 3 999999 0 0 999999 999999 0 Output 1 1 -1 Input 1 -824590 246031 Output 1 Input 8 -67761 603277 640586 -396671 46147 -122580 569609 -2112 400 914208 131792 309779 -850150 -486293 5272 721899 Output 1 1 1 1 1 1 1 -1 The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Bajirao's city has N X N police stations P(i,j) (1 ≤ i ≤ N, 1 ≤ j ≤ N) arranged in an N X N square matrix format. Bajirao is a really hardworking police officer and wants to solve all the pending cases of all the police stations in his city. However, the Police Commissioner (his senior) is not allowing him to do so due to political pressure. Bajirao is too passionate about solving cases and hence the Police Commissioner has decided to transfer him to another city after N days (Day 1, Day 2 .... Day N). Each police station P(i,j) has a single dedicated vehicle V(i,j) to aid Bajirao's transport. Every vehicle V(i,j) belonging to police station P(i,j) can drop Bajirao to either police station P(i,2j) (if 2j ≤ N) or police station P(i,j/2) (if j/2 ≥ 1) (Integer division, For eg. 4/2=2 and 7/2=3). Once vehicle V(i,j) drops Bajirao, it returns to Police Station P(i,j). On the i th day, he can solve all the pending cases of exactly 1 police station present in the i th row. On the 1st day, Bajirao can visit any Police Station of his choice, choose one of them and solve all its pending cases. Say on the (i-1)th day (i ≥ 2) Bajirao solves all the pending cases of police station P(i-1,x). Vehicle V(i-1,x) takes him home, drops him to P(i,x) the next day and returns to Police Station P(i-1,x). Bajirao wants to solve as many cases as possible before he gets transferred to another city. What is the maximum number of cases he can solve? Input : First line consists of N. The next N lines are such that each line consists of N space separated integers such that the j th integer on the i th line represents the number of pending cases in Police Station P(i,j). Output : A single integer denoting the answer to the given problem. Constraints : 1 ≤ N ≤ 100 1 ≤ Number of pending cases in P(i,j) ≤ 1000 Author : Shreyans Tester : Sayan (By IIT Kgp HackerEarth Programming Club) SAMPLE INPUT 3 1 2 3 3 1 2 1 4 1 SAMPLE OUTPUT 10 Explanation On the first day, Bajirao solves all the 3 cases of P(1,3). V(1,3) takes him home. On the second day, V(1,3) drops him to P(2,3). V(2,3) drops him to P(2,3/2) ie. P(2,1). Bajirao solves all the 3 cases of P(2,1). V(2,1) takes him home. On the third day, V(2,1) drops him to P(3,1). V(3,1) drops him to V(3,2*1) ie. P(3,2). Bajirao solves all the 4 cases of P(3,2). V(3,2) takes him home. Bajirao's stay in his city is over. He was able to solve 3 + 3 + 4 = 10 cases. The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Description: Name string is a string consisting of letters "R","K" and "V". Today Oz wants to design a name string in a beautiful manner. Actually Oz cannot insert these three letters arbitrary anywhere ,he has to follow some rules to make the name string look beautiful. First thing is that the name string should consist of at most two different letters. Secondly adjacent letters in name string must be different. After this procedure Oz wants name string to be as long as possible. Given the number of "R","K" and "V" letters that you have initially ,help Oz to find the maximum length of name string that Oz can make. Input : The first line contains the number of test cases T . Each test case consists of three space separated integers - A,B and C representing number of "R" letters, number of "K" letters and number of "V" letters respectively. Output : For each test case T, output maximum length of name string that Oz can make. Constraints : 1 ≤ T ≤100 0 ≤ A,B,C ≤10^6 SAMPLE INPUT 2 1 2 5 0 0 2 SAMPLE OUTPUT 5 1 Explanation For first sample : The longest name string possible is : VKVKV using 3 "V" letters and 2 "K" letters and its length is 5. The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Fatal Eagle has finally teamed up with Arjit to take on this weird army of zombies and vampires. And they are coming up with strategies to beat these guys on a roll. The simple thing they figured out is that these creatures attack everything by the method of brute force - i.e., the total power they have while attacking is the sum of their individual powers. Bangalore City has two entrances which are located adjacent to each other. And the members of enemy's army are going to rush over to both the entrances to attack the city. The heroes, though, know that they will be facing N enemies who have different individual powers from Power1 to Powern. The enemies attack at a particular entrance if they see a hero standing on that entrance. So basically, the heroes can manipulate an enemy into attacking one particular entrance. All the enemies attack one by one, and whenever they see someone standing on one particular entrance, they run attack that particular entrance. Our heroes need to know the number of ways in which they can trick the enemies and beat them! Fatal Eagle and Arjit have to make sure that the enemies are tricked in such a way - that the sum of the powers of enemies on the 1^st entrance of the city is NEVER greater than the 2^nd entrance of the city. The number of such ways possible is the number of ways in which they can defeat the enemies. In any case, if the sum of the powers of the enemies (Brute force!) is greater than or equal to the number of ways in which they can be defeated, print "Got no way out!" otherwise "We will win!" needs to be printed. Input format: The first line contains an integer N denoting the number of enemies. On the next line, there will be N integers denoting the individual powers of the N enemies. Output format: On the first line of the output print two integers separated by a space, the first one denoting the number of ways in which the task can be performed, the second one denoting the total power the enemies have while attacking. In the next line of the output, you've to print the message as We will win! or Got no way out! accordingly. Constraints: 0 ≤ N ≤ 8 0 ≤ Poweri ≤ 500 SAMPLE INPUT 3 1 2 13 SAMPLE OUTPUT 15 16 Got no way out! Explanation The thing to remember is that all the enemies come one by one, and their order matters. Some of the possible ways which are valid would be: - 1, 2 and 13 all on the 2^nd entrance. Final result: 1-2-13. - Firstly, 13 on the 2^nd entrance, then 1 on the 1^st entrance. And then, 2 on the 2^nd entrance. Final result: 13-2 1. The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Given is a number sequence A of length N. Find the number of integers i \left(1 \leq i \leq N\right) with the following property: * For every integer j \left(1 \leq j \leq N\right) such that i \neq j , A_j does not divide A_i. Constraints * All values in input are integers. * 1 \leq N \leq 2 \times 10^5 * 1 \leq A_i \leq 10^6 Input Input is given from Standard Input in the following format: N A_1 A_2 \cdots A_N Output Print the answer. Examples Input 5 24 11 8 3 16 Output 3 Input 4 5 5 5 5 Output 0 Input 10 33 18 45 28 8 19 89 86 2 4 Output 5 The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. You are an immigration officer in the Kingdom of AtCoder. The document carried by an immigrant has some number of integers written on it, and you need to check whether they meet certain criteria. According to the regulation, the immigrant should be allowed entry to the kingdom if and only if the following condition is satisfied: * All even numbers written on the document are divisible by 3 or 5. If the immigrant should be allowed entry according to the regulation, output `APPROVED`; otherwise, print `DENIED`. Constraints * All values in input are integers. * 1 \leq N \leq 100 * 1 \leq A_i \leq 1000 Input Input is given from Standard Input in the following format: N A_1 A_2 \dots A_N Output If the immigrant should be allowed entry according to the regulation, print `APPROVED`; otherwise, print `DENIED`. Examples Input 5 6 7 9 10 31 Output APPROVED Input 3 28 27 24 Output DENIED The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. You have a digit sequence S of length 4. You are wondering which of the following formats S is in: * YYMM format: the last two digits of the year and the two-digit representation of the month (example: `01` for January), concatenated in this order * MMYY format: the two-digit representation of the month and the last two digits of the year, concatenated in this order If S is valid in only YYMM format, print `YYMM`; if S is valid in only MMYY format, print `MMYY`; if S is valid in both formats, print `AMBIGUOUS`; if S is valid in neither format, print `NA`. Constraints * S is a digit sequence of length 4. Input Input is given from Standard Input in the following format: S Output Print the specified string: `YYMM`, `MMYY`, `AMBIGUOUS` or `NA`. Examples Input 1905 Output YYMM Input 0112 Output AMBIGUOUS Input 1700 Output NA The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. There is a grid with H horizontal rows and W vertical columns. Let (i, j) denote the square at the i-th row from the top and the j-th column from the left. In the grid, N Squares (r_1, c_1), (r_2, c_2), \ldots, (r_N, c_N) are wall squares, and the others are all empty squares. It is guaranteed that Squares (1, 1) and (H, W) are empty squares. Taro will start from Square (1, 1) and reach (H, W) by repeatedly moving right or down to an adjacent empty square. Find the number of Taro's paths from Square (1, 1) to (H, W), modulo 10^9 + 7. Constraints * All values in input are integers. * 2 \leq H, W \leq 10^5 * 1 \leq N \leq 3000 * 1 \leq r_i \leq H * 1 \leq c_i \leq W * Squares (r_i, c_i) are all distinct. * Squares (1, 1) and (H, W) are empty squares. Input Input is given from Standard Input in the following format: H W N r_1 c_1 r_2 c_2 : r_N c_N Output Print the number of Taro's paths from Square (1, 1) to (H, W), modulo 10^9 + 7. Examples Input 3 4 2 2 2 1 4 Output 3 Input 5 2 2 2 1 4 2 Output 0 Input 5 5 4 3 1 3 5 1 3 5 3 Output 24 Input 100000 100000 1 50000 50000 Output 123445622 The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Takahashi has two positive integers A and B. It is known that A plus B equals N. Find the minimum possible value of "the sum of the digits of A" plus "the sum of the digits of B" (in base 10). Constraints * 2 ≤ N ≤ 10^5 * N is an integer. Input Input is given from Standard Input in the following format: N Output Print the minimum possible value of "the sum of the digits of A" plus "the sum of the digits of B". Examples Input 15 Output 6 Input 100000 Output 10 The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. A robot is put at the origin in a two-dimensional plane. Initially, the robot is facing in the positive x-axis direction. This robot will be given an instruction sequence s. s consists of the following two kinds of letters, and will be executed in order from front to back. * `F` : Move in the current direction by distance 1. * `T` : Turn 90 degrees, either clockwise or counterclockwise. The objective of the robot is to be at coordinates (x, y) after all the instructions are executed. Determine whether this objective is achievable. Constraints * s consists of `F` and `T`. * 1 \leq \|s\| \leq 8 000 * x and y are integers. * \|x\|, \|y\| \leq \|s\| Input Input is given from Standard Input in the following format: s x y Output If the objective is achievable, print `Yes`; if it is not, print `No`. Examples Input FTFFTFFF 4 2 Output Yes Input FTFFTFFF -2 -2 Output Yes Input FF 1 0 Output No Input TF 1 0 Output No Input FFTTFF 0 0 Output Yes Input TTTT 1 0 Output No The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. There are N boxes arranged in a circle. The i-th box contains A_i stones. Determine whether it is possible to remove all the stones from the boxes by repeatedly performing the following operation: * Select one box. Let the box be the i-th box. Then, for each j from 1 through N, remove exactly j stones from the (i+j)-th box. Here, the (N+k)-th box is identified with the k-th box. Note that the operation cannot be performed if there is a box that does not contain enough number of stones to be removed. Constraints * 1 ≦ N ≦ 10^5 * 1 ≦ A_i ≦ 10^9 Input The input is given from Standard Input in the following format: N A_1 A_2 … A_N Output If it is possible to remove all the stones from the boxes, print `YES`. Otherwise, print `NO`. Examples Input 5 4 5 1 2 3 Output YES Input 5 6 9 12 10 8 Output YES Input 4 1 2 3 1 Output NO The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. There is data that records the customer number of the business partner and the trading date on a monthly basis. Please create a program that reads this month's data and last month's data and outputs the customer number of the company with which you have transactions and the number of transactions for two consecutive months from last month. However, the number of monthly business partners is 1,000 or less. Input This month's data and last month's data are given separated by one blank line. Each data is given in the following format. c1, d1 c2, d2 ... ... ci (1 ≤ ci ≤ 1,000) is an integer representing the customer number, and di (1 ≤ di ≤ 31) is an integer representing the trading day. Output For companies that have transactions for two consecutive months, the customer number and the total number of transactions are output separated by a blank in ascending order of customer number. Example Input 123,10 56,12 34,14 123,3 56,4 123,5 Output 56 2 123 3 The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. The greatest common divisor is an indispensable element in mathematics handled on a computer. Using the greatest common divisor can make a big difference in the efficiency of the calculation. One of the algorithms to find the greatest common divisor is "Euclidean algorithm". The flow of the process is shown below. <image> For example, for 1071 and 1029, substitute 1071 for X and 1029 for Y, The remainder of 1071 ÷ 1029 is 42, and 42 is substituted for X to replace X and Y. (1 step) The remainder of 1029 ÷ 42 is 21, and 21 is substituted for X to replace X and Y. (2 steps) The remainder of 42 ÷ 21 is 0, and 0 is substituted for X to replace X and Y. (3 steps) Since Y has become 0, X at this time is the greatest common divisor. Therefore, the greatest common divisor is 21. In this way, we were able to find the greatest common divisor of 1071 and 1029 in just three steps. The Euclidean algorithm produces results overwhelmingly faster than the method of comparing divisors. Create a program that takes two integers as inputs, finds the greatest common divisor using the Euclidean algorithm, and outputs the greatest common divisor and the number of steps required for the calculation. Input A sequence of multiple datasets is given as input. The end of the input is indicated by two lines of zeros. Two integers a, b (2 ≤ a, b ≤ 231-1) are given on one line for each dataset. The number of datasets does not exceed 1000. Output For each data set, the greatest common divisor of the two input integers and the number of steps of the Euclidean algorithm for calculation are output on one line separated by blanks. Example Input 1071 1029 5 5 0 0 Output 21 3 5 1 The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. There is a rectangular room, covered with square tiles. Each tile is colored either red or black. A man is standing on a black tile. From a tile, he can move to one of four adjacent tiles. But he can't move on red tiles, he can move only on black tiles. Write a program to count the number of black tiles which he can reach by repeating the moves described above. Input The input consists of multiple data sets. A data set starts with a line containing two positive integers W and H; W and H are the numbers of tiles in the x- and y- directions, respectively. W and H are not more than 20. There are H more lines in the data set, each of which includes W characters. Each character represents the color of a tile as follows. * '.' - a black tile * '#' - a red tile * '@' - a man on a black tile(appears exactly once in a data set) The end of the input is indicated by a line consisting of two zeros. Output For each data set, your program should output a line which contains the number of tiles he can reach from the initial tile (including itself). Examples Input 6 9 ....#. .....# ...... ...... ...... ...... ...... #@...# .#..#. 11 9 .#......... .#.#######. .#.#.....#. .#.#.###.#. .#.#..@#.#. .#.#####.#. .#.......#. .#########. ........... 11 6 ..#..#..#.. ..#..#..#.. ..#..#..### ..#..#..#@. ..#..#..#.. ..#..#..#.. 7 7 ..#.#.. ..#.#.. ###.### ...@... ###.### ..#.#.. ..#.#.. 0 0 Output 45 59 6 13 Input 6 9 ....#. .....# ...... ...... ...... ...... ...... @...# .#..#. 11 9 .#......... .#.#######. .#.#.....#. .#.#.###.#. .#.#..@#.#. .#.#####.#. .#.......#. .#########. ........... 11 6 ..#..#..#.. ..#..#..#.. ..#..#..### ..#..#..#@. ..#..#..#.. ..#..#..#.. 7 7 ..#.#.. ..#.#.. .### ...@... .### ..#.#.. ..#.#.. 0 0 Output 45 59 6 13 The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Training is indispensable for achieving good results at ICPC. Rabbit wants to win at ICPC, so he decided to practice today as well. Today's training is to gain the power of business by running around the city and conducting trade. I want to earn as much money as possible for future training. In this world, roads in the north, south, east, and west directions are lined up at equal intervals, forming a grid pattern. The position of the only existing market is (0, 0), and the x-coordinate and y-coordinate are fixed in the city (points with integer coordinates correspond to intersections). Rabbits can only move along the road, and it takes one minute to move between adjacent intersections. There are towns at some intersections. In trade, you get the profit of the price difference by buying goods in the city and selling them in the market. Rabbits have enough initial funds, and there is no such thing as being unable to purchase products due to lack of money. However, each product has a weight, and a rabbit can only carry products with a total weight of up to W at the same time. Therefore, it is necessary to repeatedly purchase products in the city and return to the market. In some cases, you may end up buying goods in multiple cities before returning to the market. It is assumed that the purchase of products in the city and the sale of products in the market can be done in an instant. In addition, it is unlikely that the products in the city will be out of stock, and you can purchase them indefinitely. For Usagi, the name of each product that we are going to buy and sell this time, the weight and selling price of each product, and the x-coordinate, y-coordinate and the name and price of the product for sale in each town are summarized in the data. The rabbit is now in the position of the market (0, 0). I want to find out how much I can earn during the time limit of T minutes using a program. Input N M W T S1 V1 P1 ... SM VM PM L1 X1 Y1 R1,1 Q1,1 ... R1, L1 Q1, L1 ... LN XN YN RN, 1 QN, 1 ... RN, LN QN, LN N is the number of towns and M is the number of product types. Si, Vi, and Pi (1 ≤ i ≤ M) are the name of the i-th product, the weight per product, and the selling price per product, respectively. A city is represented by an integer greater than or equal to 1 and less than or equal to N. Lj, Xj, and Yj (1 ≤ j ≤ N) are the number of types of goods sold in the city j, the x-coordinate of the city j, and the y-coordinate, respectively. Rj, k, Qj, k (1 ≤ j ≤ N, 1 ≤ k ≤ Lj) are the names and prices of the kth products sold in town j, respectively. 1 ≤ N ≤ 7, 1 ≤ M ≤ 7, 1 ≤ W ≤ 10,000, 1 ≤ T ≤ 10,000, 1 ≤ Vi ≤ W, 1 ≤ Pi ≤ 10,000, 1 ≤ Lj ≤ M, -10,000 ≤ Xj ≤ 10,000,- Satisfy 10,000 ≤ Yj ≤ 10,000, 1 ≤ Qj, k ≤ 10,000. The product name is a character string consisting of lowercase letters and having a length of 1 or more and 7 or less. All other values are integers. Si are all different. The same set as (Xj, Yj) does not appear multiple times, and (Xj, Yj) = (0, 0) does not hold. For each j, Rj and k are all different, and each Rj and k matches any Si. Output Output the maximum profit that the rabbit can get on one line. Examples Input 2 2 100 20 alfalfa 10 10 carrot 5 10 1 1 6 carrot 4 1 -3 0 alfalfa 5 Output 170 Input 2 3 100 20 vim 10 10 emacs 5 10 vstudio 65 100 2 1 6 emacs 4 vstudio 13 3 -3 0 vim 5 emacs 9 vstudio 62 Output 183 The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. You are playing a game called Guru Guru Gururin. In this game, you can move with the vehicle called Gururin. There are two commands you can give to Gururin: 'R' and 'L'. When 'R' is sent, Gururin rotates clockwise by 90 degrees. Otherwise, when 'L' is sent, Gururin rotates counterclockwise by 90 degrees. During the game, you noticed that Gururin obtains magical power by performing special commands. In short, Gururin obtains magical power every time when it performs one round in the clockwise direction from north to north. In more detail, the conditions under which magical power can be obtained is as follows. * At the beginning of the special commands, Gururin faces north. * At the end of special commands, Gururin faces north. * Except for the beginning and the end of special commands, Gururin does not face north. * During the special commands, Gururin faces north, east, south, and west one or more times, respectively, after the command of 'R'. At the beginning of the game, Gururin faces north. For example, if the sequence of commands Gururin received in order is 'RRRR' or 'RRLRRLRR', Gururin can obtain magical power. Otherwise, if the sequence of commands is 'LLLL' or 'RLLR', Gururin cannot obtain magical power. Your task is to calculate how many times Gururin obtained magical power throughout the game. In other words, given the sequence of the commands Gururin received, calculate how many special commands exists in it. Input The input consists of a single test case in the format below. $S$ The first line consists of a string $S$, which represents the sequence of commands Gururin received. $S$ consists of 'L' and 'R'. The length of $S$ is between $1$ and $10^3$ inclusive. Output Print the number of times Gururin obtained magical power throughout the game in one line. Examples Input RRRRLLLLRRRR Output 2 Input RLLRLLLLRRRLLLRRR Output 0 Input LR Output 0 Input RRLRRLRRRRLRRLRRRRLRRLRRRRLRRLRR Output 4 The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. A priority queue is a data structure which maintains a set $S$ of elements, each of with an associated value (key), and supports the following operations: * $insert(S, k)$: insert an element $k$ into the set $S$ * $extractMax(S)$: remove and return the element of $S$ with the largest key Write a program which performs the $insert(S, k)$ and $extractMax(S)$ operations to a priority queue $S$. The priority queue manages a set of integers, which are also keys for the priority. Constraints * The number of operations $\leq 2,000,000$ * $0 \leq k \leq 2,000,000,000$ Input Multiple operations to the priority queue $S$ are given. Each operation is given by "insert $k$", "extract" or "end" in a line. Here, $k$ represents an integer element to be inserted to the priority queue. The input ends with "end" operation. Output For each "extract" operation, print the element extracted from the priority queue $S$ in a line. Example Input insert 8 insert 2 extract insert 10 extract insert 11 extract extract end Output 8 10 11 2 The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Queue is a container of elements that are inserted and deleted according to FIFO (First In First Out). For $n$ queues $Q_i$ ($i = 0, 1, ..., n-1$), perform a sequence of the following operations. * enqueue($t$, $x$): Insert an integer $x$ to $Q_t$. * front($t$): Report the value which should be deleted next from $Q_t$. If $Q_t$ is empty, do nothing. * dequeue($t$): Delete an element from $Q_t$. If $Q_t$ is empty, do nothing. In the initial state, all queues are empty. Constraints * $1 \leq n \leq 1,000$ * $1 \leq q \leq 200,000$ * $-1,000,000,000 \leq x \leq 1,000,000,000$ Input The input is given in the following format. $n \; q$ $query_1$ $query_2$ : $query_q$ Each query $query_i$ is given by 0 $t$ $x$ or 1 $t$ or 2 $t$ where the first digits 0, 1 and 2 represent enqueue, front and dequeue operations respectively. Output For each front operation, print an integer in a line. Example Input 3 9 0 0 1 0 0 2 0 0 3 0 2 4 0 2 5 1 0 1 2 2 0 1 0 Output 1 4 2 The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. There are n rectangles in a row. You can either turn each rectangle by 90 degrees or leave it as it is. If you turn a rectangle, its width will be height, and its height will be width. Notice that you can turn any number of rectangles, you also can turn all or none of them. You can not change the order of the rectangles. Find out if there is a way to make the rectangles go in order of non-ascending height. In other words, after all the turns, a height of every rectangle has to be not greater than the height of the previous rectangle (if it is such). Input The first line contains a single integer n (1 ≤ n ≤ 10^5) — the number of rectangles. Each of the next n lines contains two integers w_i and h_i (1 ≤ w_i, h_i ≤ 10^9) — the width and the height of the i-th rectangle. Output Print "YES" (without quotes) if there is a way to make the rectangles go in order of non-ascending height, otherwise print "NO". You can print each letter in any case (upper or lower). Examples Input 3 3 4 4 6 3 5 Output YES Input 2 3 4 5 5 Output NO Note In the first test, you can rotate the second and the third rectangles so that the heights will be [4, 4, 3]. In the second test, there is no way the second rectangle will be not higher than the first one. The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. All bus tickets in Berland have their numbers. A number consists of n digits (n is even). Only k decimal digits d_1, d_2, ..., d_k can be used to form ticket numbers. If 0 is among these digits, then numbers may have leading zeroes. For example, if n = 4 and only digits 0 and 4 can be used, then 0000, 4004, 4440 are valid ticket numbers, and 0002, 00, 44443 are not. A ticket is lucky if the sum of first n / 2 digits is equal to the sum of remaining n / 2 digits. Calculate the number of different lucky tickets in Berland. Since the answer may be big, print it modulo 998244353. Input The first line contains two integers n and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ k ≤ 10) — the number of digits in each ticket number, and the number of different decimal digits that may be used. n is even. The second line contains a sequence of pairwise distinct integers d_1, d_2, ..., d_k (0 ≤ d_i ≤ 9) — the digits that may be used in ticket numbers. The digits are given in arbitrary order. Output Print the number of lucky ticket numbers, taken modulo 998244353. Examples Input 4 2 1 8 Output 6 Input 20 1 6 Output 1 Input 10 5 6 1 4 0 3 Output 569725 Input 1000 7 5 4 0 1 8 3 2 Output 460571165 Note In the first example there are 6 lucky ticket numbers: 1111, 1818, 1881, 8118, 8181 and 8888. There is only one ticket number in the second example, it consists of 20 digits 6. This ticket number is lucky, so the answer is 1. The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Polycarp wants to cook a soup. To do it, he needs to buy exactly n liters of water. There are only two types of water bottles in the nearby shop — 1-liter bottles and 2-liter bottles. There are infinitely many bottles of these two types in the shop. The bottle of the first type costs a burles and the bottle of the second type costs b burles correspondingly. Polycarp wants to spend as few money as possible. Your task is to find the minimum amount of money (in burles) Polycarp needs to buy exactly n liters of water in the nearby shop if the bottle of the first type costs a burles and the bottle of the second type costs b burles. You also have to answer q independent queries. Input The first line of the input contains one integer q (1 ≤ q ≤ 500) — the number of queries. The next q lines contain queries. The i-th query is given as three space-separated integers n_i, a_i and b_i (1 ≤ n_i ≤ 10^{12}, 1 ≤ a_i, b_i ≤ 1000) — how many liters Polycarp needs in the i-th query, the cost (in burles) of the bottle of the first type in the i-th query and the cost (in burles) of the bottle of the second type in the i-th query, respectively. Output Print q integers. The i-th integer should be equal to the minimum amount of money (in burles) Polycarp needs to buy exactly n_i liters of water in the nearby shop if the bottle of the first type costs a_i burles and the bottle of the second type costs b_i burles. Example Input 4 10 1 3 7 3 2 1 1000 1 1000000000000 42 88 Output 10 9 1000 42000000000000 The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. You are given an array a consisting of n integers. You can perform the following operations arbitrary number of times (possibly, zero): 1. Choose a pair of indices (i, j) such that \|i-j\|=1 (indices i and j are adjacent) and set a_i := a_i + \|a_i - a_j\|; 2. Choose a pair of indices (i, j) such that \|i-j\|=1 (indices i and j are adjacent) and set a_i := a_i - \|a_i - a_j\|. The value \|x\| means the absolute value of x. For example, \|4\| = 4, \|-3\| = 3. Your task is to find the minimum number of operations required to obtain the array of equal elements and print the order of operations to do it. It is guaranteed that you always can obtain the array of equal elements using such operations. Note that after each operation each element of the current array should not exceed 10^{18} by absolute value. Input The first line of the input contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of elements in a. The second line of the input contains n integers a_1, a_2, ..., a_n (0 ≤ a_i ≤ 2 ⋅ 10^5), where a_i is the i-th element of a. Output In the first line print one integer k — the minimum number of operations required to obtain the array of equal elements. In the next k lines print operations itself. The p-th operation should be printed as a triple of integers (t_p, i_p, j_p), where t_p is either 1 or 2 (1 means that you perform the operation of the first type, and 2 means that you perform the operation of the second type), and i_p and j_p are indices of adjacent elements of the array such that 1 ≤ i_p, j_p ≤ n, \|i_p - j_p\| = 1. See the examples for better understanding. Note that after each operation each element of the current array should not exceed 10^{18} by absolute value. If there are many possible answers, you can print any. Examples Input 5 2 4 6 6 6 Output 2 1 2 3 1 1 2 Input 3 2 8 10 Output 2 2 2 1 2 3 2 Input 4 1 1 1 1 Output 0 The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Let's call (yet again) a string good if its length is even, and every character in odd position of this string is different from the next character (the first character is different from the second, the third is different from the fourth, and so on). For example, the strings good, string and xyyx are good strings, and the strings bad, aa and aabc are not good. Note that the empty string is considered good. You are given a string s, you have to delete minimum number of characters from this string so that it becomes good. Input The first line contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of characters in s. The second line contains the string s, consisting of exactly n lowercase Latin letters. Output In the first line, print one integer k (0 ≤ k ≤ n) — the minimum number of characters you have to delete from s to make it good. In the second line, print the resulting string s. If it is empty, you may leave the second line blank, or not print it at all. Examples Input 4 good Output 0 good Input 4 aabc Output 2 ab Input 3 aaa Output 3 The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. The Cybermen solved that first test much quicker than the Daleks. Luckily for us, the Daleks were angry (shocking!) and they destroyed some of the Cybermen. After the fighting stopped, Heidi gave them another task to waste their time on. There are n points on a plane. Given a radius r, find the maximum number of points that can be covered by an L^1-ball with radius r. An L^1-ball with radius r and center (x_0, y_0) in a 2D-plane is defined as the set of points (x, y) such that the Manhattan distance between (x_0, y_0) and (x, y) is at most r. Manhattan distance between (x_0, y_0) and (x, y) is defined as \|x - x_0\| + \|y - y_0\|. Input The first line contains two integers n, r (1 ≤ n ≤ 300 000, 1 ≤ r ≤ 10^6), the number of points and the radius of the ball, respectively. Each of the next n lines contains integers x_i, y_i (-10^6 ≤ x_i, y_i ≤ 10^6), describing the coordinates of the i-th point. It is guaranteed, that all points are distinct. Output Print one integer — the maximum number points that an L^1-ball with radius r can cover. Examples Input 5 1 1 1 1 -1 -1 1 -1 -1 2 0 Output 3 Input 5 2 1 1 1 -1 -1 1 -1 -1 2 0 Output 5 Note In the first example, a ball centered at (1, 0) covers the points (1, 1), (1, -1), (2, 0). In the second example, a ball centered at (0, 0) covers all the points. Note that x_0 and y_0 need not be integer. The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. You are given a string t and n strings s_1, s_2, ..., s_n. All strings consist of lowercase Latin letters. Let f(t, s) be the number of occurences of string s in string t. For example, f('aaabacaa', 'aa') = 3, and f('ababa', 'aba') = 2. Calculate the value of ∑_{i=1}^{n} ∑_{j=1}^{n} f(t, s_i + s_j), where s + t is the concatenation of strings s and t. Note that if there are two pairs i_1, j_1 and i_2, j_2 such that s_{i_1} + s_{j_1} = s_{i_2} + s_{j_2}, you should include both f(t, s_{i_1} + s_{j_1}) and f(t, s_{i_2} + s_{j_2}) in answer. Input The first line contains string t (1 ≤ \|t\| ≤ 2 ⋅ 10^5). The second line contains integer n (1 ≤ n ≤ 2 ⋅ 10^5). Each of next n lines contains string s_i (1 ≤ \|s_i\| ≤ 2 ⋅ 10^5). It is guaranteed that ∑_{i=1}^{n} \|s_i\| ≤ 2 ⋅ 10^5. All strings consist of lowercase English letters. Output Print one integer — the value of ∑_{i=1}^{n} ∑_{j=1}^{n} f(t, s_i + s_j). Examples Input aaabacaa 2 a aa Output 5 Input aaabacaa 4 a a a b Output 33 The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. You are given a sequence a_1, a_2, ..., a_n consisting of n integers. You may perform the following operation on this sequence: choose any element and either increase or decrease it by one. Calculate the minimum possible difference between the maximum element and the minimum element in the sequence, if you can perform the aforementioned operation no more than k times. Input The first line contains two integers n and k (2 ≤ n ≤ 10^{5}, 1 ≤ k ≤ 10^{14}) — the number of elements in the sequence and the maximum number of times you can perform the operation, respectively. The second line contains a sequence of integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^{9}). Output Print the minimum possible difference between the maximum element and the minimum element in the sequence, if you can perform the aforementioned operation no more than k times. Examples Input 4 5 3 1 7 5 Output 2 Input 3 10 100 100 100 Output 0 Input 10 9 4 5 5 7 5 4 5 2 4 3 Output 1 Note In the first example you can increase the first element twice and decrease the third element twice, so the sequence becomes [3, 3, 5, 5], and the difference between maximum and minimum is 2. You still can perform one operation after that, but it's useless since you can't make the answer less than 2. In the second example all elements are already equal, so you may get 0 as the answer even without applying any operations. The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. There are n segments on a Ox axis [l_1, r_1], [l_2, r_2], ..., [l_n, r_n]. Segment [l, r] covers all points from l to r inclusive, so all x such that l ≤ x ≤ r. Segments can be placed arbitrarily — be inside each other, coincide and so on. Segments can degenerate into points, that is l_i=r_i is possible. Union of the set of segments is such a set of segments which covers exactly the same set of points as the original set. For example: * if n=3 and there are segments [3, 6], [100, 100], [5, 8] then their union is 2 segments: [3, 8] and [100, 100]; * if n=5 and there are segments [1, 2], [2, 3], [4, 5], [4, 6], [6, 6] then their union is 2 segments: [1, 3] and [4, 6]. Obviously, a union is a set of pairwise non-intersecting segments. You are asked to erase exactly one segment of the given n so that the number of segments in the union of the rest n-1 segments is maximum possible. For example, if n=4 and there are segments [1, 4], [2, 3], [3, 6], [5, 7], then: * erasing the first segment will lead to [2, 3], [3, 6], [5, 7] remaining, which have 1 segment in their union; * erasing the second segment will lead to [1, 4], [3, 6], [5, 7] remaining, which have 1 segment in their union; * erasing the third segment will lead to [1, 4], [2, 3], [5, 7] remaining, which have 2 segments in their union; * erasing the fourth segment will lead to [1, 4], [2, 3], [3, 6] remaining, which have 1 segment in their union. Thus, you are required to erase the third segment to get answer 2. Write a program that will find the maximum number of segments in the union of n-1 segments if you erase any of the given n segments. Note that if there are multiple equal segments in the given set, then you can erase only one of them anyway. So the set after erasing will have exactly n-1 segments. Input The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases in the test. Then the descriptions of t test cases follow. The first of each test case contains a single integer n (2 ≤ n ≤ 2⋅10^5) — the number of segments in the given set. Then n lines follow, each contains a description of a segment — a pair of integers l_i, r_i (-10^9 ≤ l_i ≤ r_i ≤ 10^9), where l_i and r_i are the coordinates of the left and right borders of the i-th segment, respectively. The segments are given in an arbitrary order. It is guaranteed that the sum of n over all test cases does not exceed 2⋅10^5. Output Print t integers — the answers to the t given test cases in the order of input. The answer is the maximum number of segments in the union of n-1 segments if you erase any of the given n segments. Example Input 3 4 1 4 2 3 3 6 5 7 3 5 5 5 5 5 5 6 3 3 1 1 5 5 1 5 2 2 4 4 Output 2 1 5 The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Dreamoon likes sequences very much. So he created a problem about the sequence that you can't find in OEIS: You are given two integers d, m, find the number of arrays a, satisfying the following constraints: * The length of a is n, n ≥ 1 * 1 ≤ a_1 < a_2 < ... < a_n ≤ d * Define an array b of length n as follows: b_1 = a_1, ∀ i > 1, b_i = b_{i - 1} ⊕ a_i, where ⊕ is the bitwise exclusive-or (xor). After constructing an array b, the constraint b_1 < b_2 < ... < b_{n - 1} < b_n should hold. Since the number of possible arrays may be too large, you need to find the answer modulo m. Input The first line contains an integer t (1 ≤ t ≤ 100) denoting the number of test cases in the input. Each of the next t lines contains two integers d, m (1 ≤ d, m ≤ 10^9). Note that m is not necessary the prime! Output For each test case, print the number of arrays a, satisfying all given constrains, modulo m. Example Input 10 1 1000000000 2 999999999 3 99999998 4 9999997 5 999996 6 99995 7 9994 8 993 9 92 10 1 Output 1 3 5 11 17 23 29 59 89 0 The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Slime has a sequence of positive integers a_1, a_2, …, a_n. In one operation Orac can choose an arbitrary subsegment [l … r] of this sequence and replace all values a_l, a_{l + 1}, …, a_r to the value of median of \\{a_l, a_{l + 1}, …, a_r\}. In this problem, for the integer multiset s, the median of s is equal to the ⌊ (\|s\|+1)/(2)⌋-th smallest number in it. For example, the median of \{1,4,4,6,5\} is 4, and the median of \{1,7,5,8\} is 5. Slime wants Orac to make a_1 = a_2 = … = a_n = k using these operations. Orac thinks that it is impossible, and he does not want to waste his time, so he decided to ask you if it is possible to satisfy the Slime's requirement, he may ask you these questions several times. Input The first line of the input is a single integer t: the number of queries. The first line of each query contains two integers n\ (1≤ n≤ 100 000) and k\ (1≤ k≤ 10^9), the second line contains n positive integers a_1,a_2,...,a_n\ (1≤ a_i≤ 10^9) The total sum of n is at most 100 000. Output The output should contain t lines. The i-th line should be equal to 'yes' if it is possible to make all integers k in some number of operations or 'no', otherwise. You can print each letter in lowercase or uppercase. Example Input 5 5 3 1 5 2 6 1 1 6 6 3 2 1 2 3 4 3 3 1 2 3 10 3 1 2 3 4 5 6 7 8 9 10 Output no yes yes no yes Note In the first query, Orac can't turn all elements into 3. In the second query, a_1=6 is already satisfied. In the third query, Orac can select the complete array and turn all elements into 2. In the fourth query, Orac can't turn all elements into 3. In the fifth query, Orac can select [1,6] at first and then select [2,10]. The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Lee is used to finish his stories in a stylish way, this time he barely failed it, but Ice Bear came and helped him. Lee is so grateful for it, so he decided to show Ice Bear his new game called "Critic"... The game is a one versus one game. It has t rounds, each round has two integers s_i and e_i (which are determined and are known before the game begins, s_i and e_i may differ from round to round). The integer s_i is written on the board at the beginning of the corresponding round. The players will take turns. Each player will erase the number on the board (let's say it was a) and will choose to write either 2 ⋅ a or a + 1 instead. Whoever writes a number strictly greater than e_i loses that round and the other one wins that round. Now Lee wants to play "Critic" against Ice Bear, for each round he has chosen the round's s_i and e_i in advance. Lee will start the first round, the loser of each round will start the next round. The winner of the last round is the winner of the game, and the loser of the last round is the loser of the game. Determine if Lee can be the winner independent of Ice Bear's moves or not. Also, determine if Lee can be the loser independent of Ice Bear's moves or not. Input The first line contains the integer t (1 ≤ t ≤ 10^5) — the number of rounds the game has. Then t lines follow, each contains two integers s_i and e_i (1 ≤ s_i ≤ e_i ≤ 10^{18}) — the i-th round's information. The rounds are played in the same order as given in input, s_i and e_i for all rounds are known to everyone before the game starts. Output Print two integers. The first one should be 1 if Lee can be the winner independent of Ice Bear's moves, and 0 otherwise. The second one should be 1 if Lee can be the loser independent of Ice Bear's moves, and 0 otherwise. Examples Input 3 5 8 1 4 3 10 Output 1 1 Input 4 1 2 2 3 3 4 4 5 Output 0 0 Input 1 1 1 Output 0 1 Input 2 1 9 4 5 Output 0 0 Input 2 1 2 2 8 Output 1 0 Input 6 216986951114298167 235031205335543871 148302405431848579 455670351549314242 506251128322958430 575521452907339082 1 768614336404564650 189336074809158272 622104412002885672 588320087414024192 662540324268197150 Output 1 0 Note Remember, whoever writes an integer greater than e_i loses. The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. You have a simple and connected undirected graph consisting of n nodes and m edges. Consider any way to pair some subset of these n nodes such that no node is present in more than one pair. This pairing is valid if for every pair of pairs, the induced subgraph containing all 4 nodes, two from each pair, has at most 2 edges (out of the 6 possible edges). More formally, for any two pairs, (a,b) and (c,d), the induced subgraph with nodes \\{a,b,c,d\} should have at most 2 edges. Please note that the subgraph induced by a set of nodes contains nodes only from this set and edges which have both of its end points in this set. Now, do one of the following: * Find a simple path consisting of at least ⌈ n/2 ⌉ nodes. Here, a path is called simple if it does not visit any node multiple times. * Find a valid pairing in which at least ⌈ n/2 ⌉ nodes are paired. It can be shown that it is possible to find at least one of the two in every graph satisfying constraints from the statement. Input Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10^5). Description of the test cases follows. The first line of each test case contains 2 integers n, m (2 ≤ n ≤ 5⋅ 10^5, 1 ≤ m ≤ 10^6), denoting the number of nodes and edges, respectively. The next m lines each contain 2 integers u and v (1 ≤ u, v ≤ n, u ≠ v), denoting that there is an undirected edge between nodes u and v in the given graph. It is guaranteed that the given graph is connected, and simple — it does not contain multiple edges between the same pair of nodes, nor does it have any self-loops. It is guaranteed that the sum of n over all test cases does not exceed 5⋅ 10^5. It is guaranteed that the sum of m over all test cases does not exceed 10^6. Output For each test case, the output format is as follows. If you have found a pairing, in the first line output "PAIRING" (without quotes). * Then, output k (⌈ n/2 ⌉ ≤ 2⋅ k ≤ n), the number of pairs in your pairing. * Then, in each of the next k lines, output 2 integers a and b — denoting that a and b are paired with each other. Note that the graph does not have to have an edge between a and b! * This pairing has to be valid, and every node has to be a part of at most 1 pair. Otherwise, in the first line output "PATH" (without quotes). * Then, output k (⌈ n/2 ⌉ ≤ k ≤ n), the number of nodes in your path. * Then, in the second line, output k integers, v_1, v_2, …, v_k, in the order in which they appear on the path. Formally, v_i and v_{i+1} should have an edge between them for every i (1 ≤ i < k). * This path has to be simple, meaning no node should appear more than once. Example Input 4 6 5 1 4 2 5 3 6 1 5 3 5 6 5 1 4 2 5 3 6 1 5 3 5 12 14 1 2 2 3 3 4 4 1 1 5 1 12 2 6 2 7 3 8 3 9 4 10 4 11 2 4 1 3 12 14 1 2 2 3 3 4 4 1 1 5 1 12 2 6 2 7 3 8 3 9 4 10 4 11 2 4 1 3 Output PATH 4 1 5 3 6 PAIRING 2 1 6 2 4 PAIRING 3 1 8 2 5 4 10 PAIRING 4 1 7 2 9 3 11 4 5 Note The path outputted in the first case is the following. <image> The pairing outputted in the second case is the following. <image> Here is an invalid pairing for the same graph — the subgraph \{1,3,4,5\} has 3 edges. <image> Here is the pairing outputted in the third case. <image> It's valid because — * The subgraph \{1,8,2,5\} has edges (1,2) and (1,5). * The subgraph \{1,8,4,10\} has edges (1,4) and (4,10). * The subgraph \{4,10,2,5\} has edges (2,4) and (4,10). Here is the pairing outputted in the fourth case. <image> The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. There is a building consisting of 10~000 apartments numbered from 1 to 10~000, inclusive. Call an apartment boring, if its number consists of the same digit. Examples of boring apartments are 11, 2, 777, 9999 and so on. Our character is a troublemaker, and he calls the intercoms of all boring apartments, till someone answers the call, in the following order: * First he calls all apartments consisting of digit 1, in increasing order (1, 11, 111, 1111). * Next he calls all apartments consisting of digit 2, in increasing order (2, 22, 222, 2222) * And so on. The resident of the boring apartment x answers the call, and our character stops calling anyone further. Our character wants to know how many digits he pressed in total and your task is to help him to count the total number of keypresses. For example, if the resident of boring apartment 22 answered, then our character called apartments with numbers 1, 11, 111, 1111, 2, 22 and the total number of digits he pressed is 1 + 2 + 3 + 4 + 1 + 2 = 13. You have to answer t independent test cases. Input The first line of the input contains one integer t (1 ≤ t ≤ 36) — the number of test cases. The only line of the test case contains one integer x (1 ≤ x ≤ 9999) — the apartment number of the resident who answered the call. It is guaranteed that x consists of the same digit. Output For each test case, print the answer: how many digits our character pressed in total. Example Input 4 22 9999 1 777 Output 13 90 1 66 The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. The great hero guards the country where Homer lives. The hero has attack power A and initial health value B. There are n monsters in front of the hero. The i-th monster has attack power a_i and initial health value b_i. The hero or a monster is said to be living, if his or its health value is positive (greater than or equal to 1); and he or it is said to be dead, if his or its health value is non-positive (less than or equal to 0). In order to protect people in the country, the hero will fight with monsters until either the hero is dead or all the monsters are dead. * In each fight, the hero can select an arbitrary living monster and fight with it. Suppose the i-th monster is selected, and the health values of the hero and the i-th monster are x and y before the fight, respectively. After the fight, the health values of the hero and the i-th monster become x-a_i and y-A, respectively. Note that the hero can fight the same monster more than once. For the safety of the people in the country, please tell them whether the great hero can kill all the monsters (even if the great hero himself is dead after killing the last monster). Input Each test contains multiple test cases. The first line contains t (1 ≤ t ≤ 10^5) — the number of test cases. Description of the test cases follows. The first line of each test case contains three integers A (1 ≤ A ≤ 10^6), B (1 ≤ B ≤ 10^6) and n (1 ≤ n ≤ 10^5) — the attack power of the great hero, the initial health value of the great hero, and the number of monsters. The second line of each test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^6), where a_i denotes the attack power of the i-th monster. The third line of each test case contains n integers b_1, b_2, ..., b_n (1 ≤ b_i ≤ 10^6), where b_i denotes the initial health value of the i-th monster. It is guaranteed that the sum of n over all test cases does not exceed 10^5. Output For each test case print the answer: "YES" (without quotes) if the great hero can kill all the monsters. Otherwise, print "NO" (without quotes). Example Input 5 3 17 1 2 16 10 999 3 10 20 30 100 50 30 1000 1000 4 200 300 400 500 1000 1000 1000 1000 999 999 1 1000 1000 999 999 1 1000000 999 Output YES YES YES NO YES Note In the first example: There will be 6 fights between the hero and the only monster. After that, the monster is dead and the health value of the hero becomes 17 - 6 × 2 = 5 > 0. So the answer is "YES", and moreover, the hero is still living. In the second example: After all monsters are dead, the health value of the hero will become 709, regardless of the order of all fights. So the answer is "YES". In the third example: A possible order is to fight with the 1-st, 2-nd, 3-rd and 4-th monsters. After all fights, the health value of the hero becomes -400. Unfortunately, the hero is dead, but all monsters are also dead. So the answer is "YES". In the fourth example: The hero becomes dead but the monster is still living with health value 1000 - 999 = 1. So the answer is "NO". The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Little Dormi received a histogram with n bars of height a_1, a_2, …, a_n for Christmas. However, the more he played with his new histogram, the more he realized its imperfections, so today he wanted to modify it to his liking. To modify the histogram, Little Dormi is able to perform the following operation an arbitrary number of times: * Select an index i (1 ≤ i ≤ n) where a_i>0, and assign a_i := a_i-1. Little Dormi defines the ugliness score of his histogram (after performing some number of operations) as the sum of the vertical length of its outline and the number of operations he performed on it. And to make the histogram as perfect as possible, he would like to minimize the ugliness score after modifying it with some number of operations. However, as his histogram is very large, Little Dormi is having trouble minimizing the ugliness score, so as Little Dormi's older brother, help him find the minimal ugliness. Consider the following example where the histogram has 4 columns of heights 4,8,9,6: <image> The blue region represents the histogram, and the red lines represent the vertical portion of the outline. Currently, the vertical length of the outline is 4+4+1+3+6 = 18, so if Little Dormi does not modify the histogram at all, the ugliness would be 18. However, Little Dormi can apply the operation once on column 2 and twice on column 3, resulting in a histogram with heights 4,7,7,6: <image> Now, as the total vertical length of the outline (red lines) is 4+3+1+6=14, the ugliness is 14+3=17 dollars. It can be proven that this is optimal. Input Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10^4). Description of the test cases follows. The first line of each test case contains a single integer n (1 ≤ n ≤ 4 ⋅ 10^5). The second line of each test case contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 10^9). It is guaranteed that the sum of n over all test cases does not exceed 4 ⋅ 10^5. Output For each test case output one integer, the minimal ugliness Little Dormi can achieve with the histogram in that test case. Example Input 2 4 4 8 9 6 6 2 1 7 4 0 0 Output 17 12 Note Example 1 is the example described in the statement. The initial histogram for example 2 is given below: <image> The ugliness is currently 2+1+6+3+4=16. By applying the operation once on column 1, six times on column 3, and three times on column 4, we can end up with a histogram with heights 1,1,1,1,0,0: <image> The vertical length of the outline is now 1+1=2 and Little Dormi made 1+6+3=10 operations, so the final ugliness is 2+10=12, which can be proven to be optimal. The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Students of group 199 have written their lectures dismally. Now an exam on Mathematical Analysis is approaching and something has to be done asap (that is, quickly). Let's number the students of the group from 1 to n. Each student i (1 ≤ i ≤ n) has a best friend p[i] (1 ≤ p[i] ≤ n). In fact, each student is a best friend of exactly one student. In other words, all p[i] are different. It is possible that the group also has some really "special individuals" for who i = p[i]. Each student wrote exactly one notebook of lecture notes. We know that the students agreed to act by the following algorithm: * on the first day of revising each student studies his own Mathematical Analysis notes, * in the morning of each following day each student gives the notebook to his best friend and takes a notebook from the student who calls him the best friend. Thus, on the second day the student p[i] (1 ≤ i ≤ n) studies the i-th student's notes, on the third day the notes go to student p[p[i]] and so on. Due to some characteristics of the boys' friendship (see paragraph 1), each day each student has exactly one notebook to study. You are given two sequences that describe the situation on the third and fourth days of revising: * a1, a2, ..., an, where ai means the student who gets the i-th student's notebook on the third day of revising; * b1, b2, ..., bn, where bi means the student who gets the i-th student's notebook on the fourth day of revising. You do not know array p, that is you do not know who is the best friend to who. Write a program that finds p by the given sequences a and b. Input The first line contains integer n (1 ≤ n ≤ 105) — the number of students in the group. The second line contains sequence of different integers a1, a2, ..., an (1 ≤ ai ≤ n). The third line contains the sequence of different integers b1, b2, ..., bn (1 ≤ bi ≤ n). Output Print sequence n of different integers p[1], p[2], ..., p[n] (1 ≤ p[i] ≤ n). It is guaranteed that the solution exists and that it is unique. Examples Input 4 2 1 4 3 3 4 2 1 Output 4 3 1 2 Input 5 5 2 3 1 4 1 3 2 4 5 Output 4 3 2 5 1 Input 2 1 2 2 1 Output 2 1 The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. The Little Elephant loves to play with color cards. He has n cards, each has exactly two colors (the color of the front side and the color of the back side). Initially, all the cards lay on the table with the front side up. In one move the Little Elephant can turn any card to the other side. The Little Elephant thinks that a set of cards on the table is funny if at least half of the cards have the same color (for each card the color of the upper side is considered). Help the Little Elephant to find the minimum number of moves needed to make the set of n cards funny. Input The first line contains a single integer n (1 ≤ n ≤ 105) — the number of the cards. The following n lines contain the description of all cards, one card per line. The cards are described by a pair of positive integers not exceeding 109 — colors of both sides. The first number in a line is the color of the front of the card, the second one — of the back. The color of the front of the card may coincide with the color of the back of the card. The numbers in the lines are separated by single spaces. Output On a single line print a single integer — the sought minimum number of moves. If it is impossible to make the set funny, print -1. Examples Input 3 4 7 4 7 7 4 Output 0 Input 5 4 7 7 4 2 11 9 7 1 1 Output 2 Note In the first sample there initially are three cards lying with colors 4, 4, 7. Since two of the three cards are of the same color 4, you do not need to change anything, so the answer is 0. In the second sample, you can turn the first and the fourth cards. After that three of the five cards will be of color 7. The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Little Petya likes permutations a lot. Recently his mom has presented him permutation q1, q2, ..., qn of length n. A permutation a of length n is a sequence of integers a1, a2, ..., an (1 ≤ ai ≤ n), all integers there are distinct. There is only one thing Petya likes more than permutations: playing with little Masha. As it turns out, Masha also has a permutation of length n. Petya decided to get the same permutation, whatever the cost may be. For that, he devised a game with the following rules: * Before the beginning of the game Petya writes permutation 1, 2, ..., n on the blackboard. After that Petya makes exactly k moves, which are described below. * During a move Petya tosses a coin. If the coin shows heads, he performs point 1, if the coin shows tails, he performs point 2. 1. Let's assume that the board contains permutation p1, p2, ..., pn at the given moment. Then Petya removes the written permutation p from the board and writes another one instead: pq1, pq2, ..., pqn. In other words, Petya applies permutation q (which he has got from his mother) to permutation p. 2. All actions are similar to point 1, except that Petya writes permutation t on the board, such that: tqi = pi for all i from 1 to n. In other words, Petya applies a permutation that is inverse to q to permutation p. We know that after the k-th move the board contained Masha's permutation s1, s2, ..., sn. Besides, we know that throughout the game process Masha's permutation never occurred on the board before the k-th move. Note that the game has exactly k moves, that is, throughout the game the coin was tossed exactly k times. Your task is to determine whether the described situation is possible or else state that Petya was mistaken somewhere. See samples and notes to them for a better understanding. Input The first line contains two integers n and k (1 ≤ n, k ≤ 100). The second line contains n space-separated integers q1, q2, ..., qn (1 ≤ qi ≤ n) — the permutation that Petya's got as a present. The third line contains Masha's permutation s, in the similar format. It is guaranteed that the given sequences q and s are correct permutations. Output If the situation that is described in the statement is possible, print "YES" (without the quotes), otherwise print "NO" (without the quotes). Examples Input 4 1 2 3 4 1 1 2 3 4 Output NO Input 4 1 4 3 1 2 3 4 2 1 Output YES Input 4 3 4 3 1 2 3 4 2 1 Output YES Input 4 2 4 3 1 2 2 1 4 3 Output YES Input 4 1 4 3 1 2 2 1 4 3 Output NO Note In the first sample Masha's permutation coincides with the permutation that was written on the board before the beginning of the game. Consequently, that violates the condition that Masha's permutation never occurred on the board before k moves were performed. In the second sample the described situation is possible, in case if after we toss a coin, we get tails. In the third sample the possible coin tossing sequence is: heads-tails-tails. In the fourth sample the possible coin tossing sequence is: heads-heads. The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. There is a square matrix n × n, consisting of non-negative integer numbers. You should find such a way on it that * starts in the upper left cell of the matrix; * each following cell is to the right or down from the current cell; * the way ends in the bottom right cell. Moreover, if we multiply together all the numbers along the way, the result should be the least "round". In other words, it should end in the least possible number of zeros. Input The first line contains an integer number n (2 ≤ n ≤ 1000), n is the size of the matrix. Then follow n lines containing the matrix elements (non-negative integer numbers not exceeding 109). Output In the first line print the least number of trailing zeros. In the second line print the correspondent way itself. Examples Input 3 1 2 3 4 5 6 7 8 9 Output 0 DDRR The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Daniel is organizing a football tournament. He has come up with the following tournament format: 1. In the first several (possibly zero) stages, while the number of teams is even, they split in pairs and play one game for each pair. At each stage the loser of each pair is eliminated (there are no draws). Such stages are held while the number of teams is even. 2. Eventually there will be an odd number of teams remaining. If there is one team remaining, it will be declared the winner, and the tournament ends. Otherwise each of the remaining teams will play with each other remaining team once in round robin tournament (if there are x teams, there will be <image> games), and the tournament ends. For example, if there were 20 teams initially, they would begin by playing 10 games. So, 10 teams would be eliminated, and the remaining 10 would play 5 games. Then the remaining 5 teams would play 10 games in a round robin tournament. In total there would be 10+5+10=25 games. Daniel has already booked the stadium for n games. Help him to determine how many teams he should invite so that the tournament needs exactly n games. You should print all possible numbers of teams that will yield exactly n games in ascending order, or -1 if there are no such numbers. Input The first line contains a single integer n (1 ≤ n ≤ 1018), the number of games that should be played. Please, do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier. Output Print all possible numbers of invited teams in ascending order, one per line. If exactly n games cannot be played, output one number: -1. Examples Input 3 Output 3 4 Input 25 Output 20 Input 2 Output -1 The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. There is a system of n vessels arranged one above the other as shown in the figure below. Assume that the vessels are numbered from 1 to n, in the order from the highest to the lowest, the volume of the i-th vessel is ai liters. <image> Initially, all the vessels are empty. In some vessels water is poured. All the water that overflows from the i-th vessel goes to the (i + 1)-th one. The liquid that overflows from the n-th vessel spills on the floor. Your task is to simulate pouring water into the vessels. To do this, you will need to handle two types of queries: 1. Add xi liters of water to the pi-th vessel; 2. Print the number of liters of water in the ki-th vessel. When you reply to the second request you can assume that all the water poured up to this point, has already overflown between the vessels. Input The first line contains integer n — the number of vessels (1 ≤ n ≤ 2·105). The second line contains n integers a1, a2, ..., an — the vessels' capacities (1 ≤ ai ≤ 109). The vessels' capacities do not necessarily increase from the top vessels to the bottom ones (see the second sample). The third line contains integer m — the number of queries (1 ≤ m ≤ 2·105). Each of the next m lines contains the description of one query. The query of the first type is represented as "1 pi xi", the query of the second type is represented as "2 ki" (1 ≤ pi ≤ n, 1 ≤ xi ≤ 109, 1 ≤ ki ≤ n). Output For each query, print on a single line the number of liters of water in the corresponding vessel. Examples Input 2 5 10 6 1 1 4 2 1 1 2 5 1 1 4 2 1 2 2 Output 4 5 8 Input 3 5 10 8 6 1 1 12 2 2 1 1 6 1 3 2 2 2 2 3 Output 7 10 5 The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Alice likes word "nineteen" very much. She has a string s and wants the string to contain as many such words as possible. For that reason she can rearrange the letters of the string. For example, if she has string "xiineteenppnnnewtnee", she can get string "xnineteenppnineteenw", containing (the occurrences marked) two such words. More formally, word "nineteen" occurs in the string the number of times you can read it starting from some letter of the string. Of course, you shouldn't skip letters. Help her to find the maximum number of "nineteen"s that she can get in her string. Input The first line contains a non-empty string s, consisting only of lowercase English letters. The length of string s doesn't exceed 100. Output Print a single integer — the maximum number of "nineteen"s that she can get in her string. Examples Input nniinneetteeeenn Output 2 Input nneteenabcnneteenabcnneteenabcnneteenabcnneteenabcii Output 2 Input nineteenineteen Output 2 The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Sergey is testing a next-generation processor. Instead of bytes the processor works with memory cells consisting of n bits. These bits are numbered from 1 to n. An integer is stored in the cell in the following way: the least significant bit is stored in the first bit of the cell, the next significant bit is stored in the second bit, and so on; the most significant bit is stored in the n-th bit. Now Sergey wants to test the following instruction: "add 1 to the value of the cell". As a result of the instruction, the integer that is written in the cell must be increased by one; if some of the most significant bits of the resulting number do not fit into the cell, they must be discarded. Sergey wrote certain values of the bits in the cell and is going to add one to its value. How many bits of the cell will change after the operation? Input The first line contains a single integer n (1 ≤ n ≤ 100) — the number of bits in the cell. The second line contains a string consisting of n characters — the initial state of the cell. The first character denotes the state of the first bit of the cell. The second character denotes the second least significant bit and so on. The last character denotes the state of the most significant bit. Output Print a single integer — the number of bits in the cell which change their state after we add 1 to the cell. Examples Input 4 1100 Output 3 Input 4 1111 Output 4 Note In the first sample the cell ends up with value 0010, in the second sample — with 0000. The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Nura wants to buy k gadgets. She has only s burles for that. She can buy each gadget for dollars or for pounds. So each gadget is selling only for some type of currency. The type of currency and the cost in that currency are not changing. Nura can buy gadgets for n days. For each day you know the exchange rates of dollar and pound, so you know the cost of conversion burles to dollars or to pounds. Each day (from 1 to n) Nura can buy some gadgets by current exchange rate. Each day she can buy any gadgets she wants, but each gadget can be bought no more than once during n days. Help Nura to find the minimum day index when she will have k gadgets. Nura always pays with burles, which are converted according to the exchange rate of the purchase day. Nura can't buy dollars or pounds, she always stores only burles. Gadgets are numbered with integers from 1 to m in order of their appearing in input. Input First line contains four integers n, m, k, s (1 ≤ n ≤ 2·105, 1 ≤ k ≤ m ≤ 2·105, 1 ≤ s ≤ 109) — number of days, total number and required number of gadgets, number of burles Nura has. Second line contains n integers ai (1 ≤ ai ≤ 106) — the cost of one dollar in burles on i-th day. Third line contains n integers bi (1 ≤ bi ≤ 106) — the cost of one pound in burles on i-th day. Each of the next m lines contains two integers ti, ci (1 ≤ ti ≤ 2, 1 ≤ ci ≤ 106) — type of the gadget and it's cost. For the gadgets of the first type cost is specified in dollars. For the gadgets of the second type cost is specified in pounds. Output If Nura can't buy k gadgets print the only line with the number -1. Otherwise the first line should contain integer d — the minimum day index, when Nura will have k gadgets. On each of the next k lines print two integers qi, di — the number of gadget and the day gadget should be bought. All values qi should be different, but the values di can coincide (so Nura can buy several gadgets at one day). The days are numbered from 1 to n. In case there are multiple possible solutions, print any of them. Examples Input 5 4 2 2 1 2 3 2 1 3 2 1 2 3 1 1 2 1 1 2 2 2 Output 3 1 1 2 3 Input 4 3 2 200 69 70 71 72 104 105 106 107 1 1 2 2 1 2 Output -1 Input 4 3 1 1000000000 900000 910000 940000 990000 990000 999000 999900 999990 1 87654 2 76543 1 65432 Output -1 The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. The numbers of all offices in the new building of the Tax Office of IT City will have lucky numbers. Lucky number is a number that consists of digits 7 and 8 only. Find the maximum number of offices in the new building of the Tax Office given that a door-plate can hold a number not longer than n digits. Input The only line of input contains one integer n (1 ≤ n ≤ 55) — the maximum length of a number that a door-plate can hold. Output Output one integer — the maximum number of offices, than can have unique lucky numbers not longer than n digits. Examples Input 2 Output 6 The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. A simple recommendation system would recommend a user things liked by a certain number of their friends. In this problem you will implement part of such a system. You are given user's friends' opinions about a list of items. You are also given a threshold T — the minimal number of "likes" necessary for an item to be recommended to the user. Output the number of items in the list liked by at least T of user's friends. Input The first line of the input will contain three space-separated integers: the number of friends F (1 ≤ F ≤ 10), the number of items I (1 ≤ I ≤ 10) and the threshold T (1 ≤ T ≤ F). The following F lines of input contain user's friends' opinions. j-th character of i-th line is 'Y' if i-th friend likes j-th item, and 'N' otherwise. Output Output an integer — the number of items liked by at least T of user's friends. Examples Input 3 3 2 YYY NNN YNY Output 2 Input 4 4 1 NNNY NNYN NYNN YNNN Output 4 The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. There are n cities in Bearland, numbered 1 through n. Cities are arranged in one long row. The distance between cities i and j is equal to \|i - j\|. Limak is a police officer. He lives in a city a. His job is to catch criminals. It's hard because he doesn't know in which cities criminals are. Though, he knows that there is at most one criminal in each city. Limak is going to use a BCD (Bear Criminal Detector). The BCD will tell Limak how many criminals there are for every distance from a city a. After that, Limak can catch a criminal in each city for which he is sure that there must be a criminal. You know in which cities criminals are. Count the number of criminals Limak will catch, after he uses the BCD. Input The first line of the input contains two integers n and a (1 ≤ a ≤ n ≤ 100) — the number of cities and the index of city where Limak lives. The second line contains n integers t1, t2, ..., tn (0 ≤ ti ≤ 1). There are ti criminals in the i-th city. Output Print the number of criminals Limak will catch. Examples Input 6 3 1 1 1 0 1 0 Output 3 Input 5 2 0 0 0 1 0 Output 1 Note In the first sample, there are six cities and Limak lives in the third one (blue arrow below). Criminals are in cities marked red. <image> Using the BCD gives Limak the following information: * There is one criminal at distance 0 from the third city — Limak is sure that this criminal is exactly in the third city. * There is one criminal at distance 1 from the third city — Limak doesn't know if a criminal is in the second or fourth city. * There are two criminals at distance 2 from the third city — Limak is sure that there is one criminal in the first city and one in the fifth city. * There are zero criminals for every greater distance. So, Limak will catch criminals in cities 1, 3 and 5, that is 3 criminals in total. In the second sample (drawing below), the BCD gives Limak the information that there is one criminal at distance 2 from Limak's city. There is only one city at distance 2 so Limak is sure where a criminal is. <image> The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Mishka is a little polar bear. As known, little bears loves spending their free time playing dice for chocolates. Once in a wonderful sunny morning, walking around blocks of ice, Mishka met her friend Chris, and they started playing the game. Rules of the game are very simple: at first number of rounds n is defined. In every round each of the players throws a cubical dice with distinct numbers from 1 to 6 written on its faces. Player, whose value after throwing the dice is greater, wins the round. In case if player dice values are equal, no one of them is a winner. In average, player, who won most of the rounds, is the winner of the game. In case if two players won the same number of rounds, the result of the game is draw. Mishka is still very little and can't count wins and losses, so she asked you to watch their game and determine its result. Please help her! Input The first line of the input contains single integer n n (1 ≤ n ≤ 100) — the number of game rounds. The next n lines contains rounds description. i-th of them contains pair of integers mi and ci (1 ≤ mi, ci ≤ 6) — values on dice upper face after Mishka's and Chris' throws in i-th round respectively. Output If Mishka is the winner of the game, print "Mishka" (without quotes) in the only line. If Chris is the winner of the game, print "Chris" (without quotes) in the only line. If the result of the game is draw, print "Friendship is magic!^^" (without quotes) in the only line. Examples Input 3 3 5 2 1 4 2 Output Mishka Input 2 6 1 1 6 Output Friendship is magic!^^ Input 3 1 5 3 3 2 2 Output Chris Note In the first sample case Mishka loses the first round, but wins second and third rounds and thus she is the winner of the game. In the second sample case Mishka wins the first round, Chris wins the second round, and the game ends with draw with score 1:1. In the third sample case Chris wins the first round, but there is no winner of the next two rounds. The winner of the game is Chris. The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. In a new version of the famous Pinball game, one of the most important parts of the game field is a sequence of n bumpers. The bumpers are numbered with integers from 1 to n from left to right. There are two types of bumpers. They are denoted by the characters '<' and '>'. When the ball hits the bumper at position i it goes one position to the right (to the position i + 1) if the type of this bumper is '>', or one position to the left (to i - 1) if the type of the bumper at position i is '<'. If there is no such position, in other words if i - 1 < 1 or i + 1 > n, the ball falls from the game field. Depending on the ball's starting position, the ball may eventually fall from the game field or it may stay there forever. You are given a string representing the bumpers' types. Calculate the number of positions such that the ball will eventually fall from the game field if it starts at that position. Input The first line of the input contains a single integer n (1 ≤ n ≤ 200 000) — the length of the sequence of bumpers. The second line contains the string, which consists of the characters '<' and '>'. The character at the i-th position of this string corresponds to the type of the i-th bumper. Output Print one integer — the number of positions in the sequence such that the ball will eventually fall from the game field if it starts at that position. Examples Input 4 <<>< Output 2 Input 5 >>>>> Output 5 Input 4 >><< Output 0 Note In the first sample, the ball will fall from the field if starts at position 1 or position 2. In the second sample, any starting position will result in the ball falling from the field. The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Bitwise exclusive OR (or bitwise addition modulo two) is a binary operation which is equivalent to applying logical exclusive OR to every pair of bits located on the same positions in binary notation of operands. In other words, a binary digit of the result is equal to 1 if and only if bits on the respective positions in the operands are different. For example, if X = 10910 = 11011012, Y = 4110 = 1010012, then: X xor Y = 6810 = 10001002. Write a program, which takes two non-negative integers A and B as an input and finds two non-negative integers X and Y, which satisfy the following conditions: * A = X + Y * B = X xor Y, where xor is bitwise exclusive or. * X is the smallest number among all numbers for which the first two conditions are true. Input The first line contains integer number A and the second line contains integer number B (0 ≤ A, B ≤ 264 - 1). Output The only output line should contain two integer non-negative numbers X and Y. Print the only number -1 if there is no answer. Examples Input 142 76 Output 33 109 The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. A robber has attempted to rob a bank but failed to complete his task. However, he had managed to open all the safes. Oleg the bank client loves money (who doesn't), and decides to take advantage of this failed robbery and steal some money from the safes. There are many safes arranged in a line, where the i-th safe from the left is called safe i. There are n banknotes left in all the safes in total. The i-th banknote is in safe xi. Oleg is now at safe a. There are two security guards, one of which guards the safe b such that b < a, i.e. the first guard is to the left of Oleg. The other guard guards the safe c so that c > a, i.e. he is to the right of Oleg. The two guards are very lazy, so they do not move. In every second, Oleg can either take all the banknotes from the current safe or move to any of the neighboring safes. However, he cannot visit any safe that is guarded by security guards at any time, becaues he might be charged for stealing. Determine the maximum amount of banknotes Oleg can gather. Input The first line of input contains three space-separated integers, a, b and c (1 ≤ b < a < c ≤ 109), denoting the positions of Oleg, the first security guard and the second security guard, respectively. The next line of input contains a single integer n (1 ≤ n ≤ 105), denoting the number of banknotes. The next line of input contains n space-separated integers x1, x2, ..., xn (1 ≤ xi ≤ 109), denoting that the i-th banknote is located in the xi-th safe. Note that xi are not guaranteed to be distinct. Output Output a single integer: the maximum number of banknotes Oleg can take. Examples Input 5 3 7 8 4 7 5 5 3 6 2 8 Output 4 Input 6 5 7 5 1 5 7 92 3 Output 0 Note In the first example Oleg can take the banknotes in positions 4, 5, 6 (note that there are 2 banknotes at position 5). Oleg can't take the banknotes in safes 7 and 8 because he can't run into the second security guard. Similarly, Oleg cannot take the banknotes at positions 3 and 2 because he can't run into the first security guard. Thus, he can take a maximum of 4 banknotes. For the second sample, Oleg can't take any banknotes without bumping into any of the security guards. The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Beroffice text editor has a wide range of features that help working with text. One of the features is an automatic search for typos and suggestions of how to fix them. Beroffice works only with small English letters (i.e. with 26 letters from a to z). Beroffice thinks that a word is typed with a typo if there are three or more consonants in a row in the word. The only exception is that if the block of consonants has all letters the same, then this block (even if its length is greater than three) is not considered a typo. Formally, a word is typed with a typo if there is a block of not less that three consonants in a row, and there are at least two different letters in this block. For example: * the following words have typos: "hellno", "hackcerrs" and "backtothefutttture"; * the following words don't have typos: "helllllooooo", "tobeornottobe" and "oooooo". When Beroffice editor finds a word with a typo, it inserts as little as possible number of spaces in this word (dividing it into several words) in such a way that each of the resulting words is typed without any typos. Implement this feature of Beroffice editor. Consider the following letters as the only vowels: 'a', 'e', 'i', 'o' and 'u'. All the other letters are consonants in this problem. Input The only line contains a non-empty word consisting of small English letters. The length of the word is between 1 and 3000 letters. Output Print the given word without any changes if there are no typos. If there is at least one typo in the word, insert the minimum number of spaces into the word so that each of the resulting words doesn't have any typos. If there are multiple solutions, print any of them. Examples Input hellno Output hell no Input abacaba Output abacaba Input asdfasdf Output asd fasd f The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. You are given a set of n points on the plane. A line containing the origin is called good, if projection of the given set to this line forms a symmetric multiset of points. Find the total number of good lines. Multiset is a set where equal elements are allowed. Multiset is called symmetric, if there is a point P on the plane such that the multiset is [centrally symmetric](https://en.wikipedia.org/wiki/Point_reflection) in respect of point P. Input The first line contains a single integer n (1 ≤ n ≤ 2000) — the number of points in the set. Each of the next n lines contains two integers xi and yi ( - 106 ≤ xi, yi ≤ 106) — the coordinates of the points. It is guaranteed that no two points coincide. Output If there are infinitely many good lines, print -1. Otherwise, print single integer — the number of good lines. Examples Input 3 1 2 2 1 3 3 Output 3 Input 2 4 3 1 2 Output -1 Note Picture to the first sample test: <image> In the second sample, any line containing the origin is good. The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. There is unrest in the Galactic Senate. Several thousand solar systems have declared their intentions to leave the Republic. Master Heidi needs to select the Jedi Knights who will go on peacekeeping missions throughout the galaxy. It is well-known that the success of any peacekeeping mission depends on the colors of the lightsabers of the Jedi who will go on that mission. Heidi has n Jedi Knights standing in front of her, each one with a lightsaber of one of m possible colors. She knows that for the mission to be the most effective, she needs to select some contiguous interval of knights such that there are exactly k1 knights with lightsabers of the first color, k2 knights with lightsabers of the second color, ..., km knights with lightsabers of the m-th color. Help her find out if this is possible. Input The first line of the input contains n (1 ≤ n ≤ 100) and m (1 ≤ m ≤ n). The second line contains n integers in the range {1, 2, ..., m} representing colors of the lightsabers of the subsequent Jedi Knights. The third line contains m integers k1, k2, ..., km (with <image>) – the desired counts of lightsabers of each color from 1 to m. Output Output YES if an interval with prescribed color counts exists, or output NO if there is none. Example Input 5 2 1 1 2 2 1 1 2 Output YES The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. You have m = n·k wooden staves. The i-th stave has length ai. You have to assemble n barrels consisting of k staves each, you can use any k staves to construct a barrel. Each stave must belong to exactly one barrel. Let volume vj of barrel j be equal to the length of the minimal stave in it. <image> You want to assemble exactly n barrels with the maximal total sum of volumes. But you have to make them equal enough, so a difference between volumes of any pair of the resulting barrels must not exceed l, i.e. \|vx - vy\| ≤ l for any 1 ≤ x ≤ n and 1 ≤ y ≤ n. Print maximal total sum of volumes of equal enough barrels or 0 if it's impossible to satisfy the condition above. Input The first line contains three space-separated integers n, k and l (1 ≤ n, k ≤ 105, 1 ≤ n·k ≤ 105, 0 ≤ l ≤ 109). The second line contains m = n·k space-separated integers a1, a2, ..., am (1 ≤ ai ≤ 109) — lengths of staves. Output Print single integer — maximal total sum of the volumes of barrels or 0 if it's impossible to construct exactly n barrels satisfying the condition \|vx - vy\| ≤ l for any 1 ≤ x ≤ n and 1 ≤ y ≤ n. Examples Input 4 2 1 2 2 1 2 3 2 2 3 Output 7 Input 2 1 0 10 10 Output 20 Input 1 2 1 5 2 Output 2 Input 3 2 1 1 2 3 4 5 6 Output 0 Note In the first example you can form the following barrels: [1, 2], [2, 2], [2, 3], [2, 3]. In the second example you can form the following barrels: [10], [10]. In the third example you can form the following barrels: [2, 5]. In the fourth example difference between volumes of barrels in any partition is at least 2 so it is impossible to make barrels equal enough. The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Those of you who are familiar with the TV Show Community and it's 'lovable' character, Abed, who likes to travel around dimensions, parallel universes, and various other parallel time lines, would know that Abed needs your help. And if you aren't familiar, help the kid, anyway. Now Abed has been told by Britta that she's going to marry Jeff, and that has freaked him out. He thinks their study group will no longer be able to stay intact anymore. Abed wants to use his weird super-power to move across coordinates to reach the desired time-line where everyone is together. From the current coordinate, Abed can go to a cell which is vertically, or horizontally adjacent to it. As we know, every story has a twist: if you're on the rightmost cell, moving right from it will move you to the leftmost cell. And vice versa - for the left move from the leftmost cell will lead you to the rightmost cell. If you move down from the most bottom cell, it will lead you to the corresponding top cell, and vice versa for the top cell, too. Anyway, everyone gets one chance, Abed has got one, too. He has exactly "1000" time-line coins, which he can use to travel across various time-lines. These time-lines are represented as N rows and M columns. For every move, there's a constant price attached to it, and no matter whatever move you make, you have to pay that price. Obviously, if that price exceeds 1000, Abed will not be able to travel any further, and his group will not be saved. Otherwise, if he can travel from the time-line he's in, to the one he's supposed to go to in less than or equal to 1000 coins, the group will be saved. Each cell of a matrix is a unique time-line. Also, each time-line is uniquely defined by two variables, x and y. Given a coordinate x1, y1, he would have to go to x2, y2 - and for every move, there'll be a price p associated as well. Input format: The first line contains the number of test cases, following which two numbers N, and M denoting the number of rows and columns. For every pair of row and column, you need to input the initial coordinates of Abed, the final coordinates where he needs to reach, and the price of every move in that unique matrix. Output format: Print the final cost incurred. And "Let go of the group." if the cost is above 1000, or "You saved the group.", if he manages to do it under 1000. Constraints: 1 ≤ tc ≤ 10 1 ≤ N, M ≤ 10^6 0 ≤ x1, x2 ≤ N-1 0 ≤ y1, y2 ≤ M-1 1 ≤ p ≤ 10SAMPLE INPUT 1 4 4 3 0 2 2 9 SAMPLE OUTPUT 27 You saved the group. Explanation Total number of moves = number of moves to walk along rows + number of moves to walk along column. Note that, These two distances are independent. So, we can handle them individually. Also, to reach from a row to another row OR from a column to another column there are two ways: 1) Go directly i.e abs(x1-x2) where we are going from row x1 to row x2. 2) Use the wrapped around matrix. abs(n-x1-x2) i.e we will move through all the blocks except which connects them directly. We take the minimum of two to get the minimum moves to reach there. The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Exams are over !! Everyone is now in the mood to play the multiplayer game Counter-Strike 1.6. 12 players decide to play Counter-Strike 1.6, each one playing from his own room via LAN on his own laptop. The 12 players (6 on 6) : Counter Terrorists vs Terrorists are playing on the map de_dust 2 . They decide to play a total of T rounds. In every round, Terrorists plant a bomb at the point (u,v) of the 2-D coordinate plane. HELL, a Counter-Terrorist, is a very good player and manages to remain the sole survivor at the end of every round. However just surviving won't help the Counter-Terrorists win that round. HELL has to defuse the bomb the terrorists planted (while they were alive) before it blows up. The bomb will blow up exactly P seconds from the current moment (ie. from the moment HELL remains the sole survivor). HELL is currently at a point (x,y) of the coordinate plane. HELL can move from a general point (a,b) to either of the 4 points (a+i,b+i) , (a+i,b-i) , (a-i,b+i) or (a-i,b-i) in 1 second , i>0 is an integer and i is always of HELL's choice in every move he makes . HELL has to reach the bomb site within a time strictly lesser than P seconds in order to defuse the bomb safely, and, he reaches the bomb (if he can) optimally. Once a round ends, all players become alive for the next round. Given the entire situation of every round (ie. from the moment HELL is the sole survivor) you have to find out the result of each and every round. Assume that HELL is carrying the defusal kit and hence defusing the bomb takes negligible amount of time. Input : The first line consists of T the number of rounds the 10 of them play. The next T lines are such that each line consists of 5 space-separated integers P, x, y, u, v. Output : Print the result of every round on a new line. If HELL can reach the bomb site on time print "Counter-Terrorists Win !" otherwise print "Terrorists Win !" (Quotes for clarity). Constraints : 1 ≤ T ≤ 1000 1 ≤ P ≤ 10 -10000 ≤ x,y,u,v ≤ +10000 Author : Shreyans Tester : Sandeep (By IIT Kgp HackerEarth Programming Club) SAMPLE INPUT 6 2 1 2 3 4 1 1 2 3 4 2 1 2 4 3 1 1 2 4 3 3 1 2 4 3 1 1 2 1 2 SAMPLE OUTPUT Counter-Terrorists Win ! Terrorists Win ! Terrorists Win ! Terrorists Win ! Counter-Terrorists Win ! Counter-Terrorists Win ! Explanation Lets take the first 2 rounds. In both the rounds HELL has to go from (1,2) -> (3,4). When he is at (1,2), he will choose i=2 and go to point (3,4) in the following manner : (1,2) -> (1+2,2+2) = (3,4). The minimum time HELL takes to reach the bombsite is 1 second. In the first round 1 second < 2 seconds hence the bomb has been successfully defused. This does not happen in the second round. In each of the next 3 rounds HELL plays optimally in the following manner : (1,2) -> (1+2,2+2) = (3,4) (HELL chooses i=2) (3,4) -> (3+1,4-1) = (4,3) (HELL chooses i=1) In the last round, HELL is already present at the bombsite. Hence the time taken by him to reach the bombsite = 0 . The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Hansa did not have enough money to pay the bill of the party. Now she loves cupcakes (and can also eat any amount of it apparently), so she came up with a cupcake challenge. She challenges t people individually every time for the challenge. The task is as follows: Given 3 baskets filled with known amount of cupcakes in each, turn-by-turn, both the competitors have to eat at least one cupcake to at most all the cupcakes from any one basket. The one, who eats the last cupcake of all, is the winner and the other person has to pay the entire bill of the party. All the competitors, including Hansa, will play optimally. Now as Hansa is the birthday girl, she always takes the first turn. Tell us who wins each challenge. Input: The first line contains a single positive integer, T. T test cases follow. Each of the next T lines contain 3 space-separated integers “a b c” denoting the number of cupcakes in each basket. Output: A single line for each test case telling if Hansa has to pay the bill or not. If she loses the game then print “BILL” otherwise print “NO BILL”. Constraints: 1 ≤ t ≤ 100 1 ≤ a, b, c ≤ 10^6 Problem Setter: Chintan Shah SAMPLE INPUT 2 1 1 1 1 2 3 SAMPLE OUTPUT NO BILL BILL The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Takahashi loves takoyaki - a ball-shaped snack. With a takoyaki machine, he can make at most X pieces of takoyaki at a time, taking T minutes regardless of the number of pieces to make. How long does it take to make N takoyaki? Constraints * 1 \leq N,X,T \leq 1000 * All values in input are integers. Input Input is given from Standard Input in the following format: N X T Output Print an integer representing the minimum number of minutes needed to make N pieces of takoyaki. Examples Input 20 12 6 Output 12 Input 1000 1 1000 Output 1000000 The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. A company has N members, who are assigned ID numbers 1, ..., N. Every member, except the member numbered 1, has exactly one immediate boss with a smaller ID number. When a person X is the immediate boss of a person Y, the person Y is said to be an immediate subordinate of the person X. You are given the information that the immediate boss of the member numbered i is the member numbered A_i. For each member, find how many immediate subordinates it has. Constraints * 2 \leq N \leq 2 \times 10^5 * 1 \leq A_i < i Input Input is given from Standard Input in the following format: N A_2 ... A_N Output For each of the members numbered 1, 2, ..., N, print the number of immediate subordinates it has, in its own line. Examples Input 5 1 1 2 2 Output 2 2 0 0 0 Input 10 1 1 1 1 1 1 1 1 1 Output 9 0 0 0 0 0 0 0 0 0 Input 7 1 2 3 4 5 6 Output 1 1 1 1 1 1 0 The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Takahashi loves palindromes. Non-palindromic strings are unacceptable to him. Each time he hugs a string, he can change one of its characters to any character of his choice. Given is a string S. Find the minimum number of hugs needed to make S palindromic. Constraints * S is a string consisting of lowercase English letters. * The length of S is between 1 and 100 (inclusive). Input Input is given from Standard Input in the following format: S Output Print the minimum number of hugs needed to make S palindromic. Examples Input redcoder Output 1 Input vvvvvv Output 0 Input abcdabc Output 2 The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. You are given a string S as input. This represents a valid date in the year 2019 in the `yyyy/mm/dd` format. (For example, April 30, 2019 is represented as `2019/04/30`.) Write a program that prints `Heisei` if the date represented by S is not later than April 30, 2019, and prints `TBD` otherwise. Constraints * S is a string that represents a valid date in the year 2019 in the `yyyy/mm/dd` format. Input Input is given from Standard Input in the following format: S Output Print `Heisei` if the date represented by S is not later than April 30, 2019, and print `TBD` otherwise. Examples Input 2019/04/30 Output Heisei Input 2019/11/01 Output TBD The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. You are given an undirected graph consisting of N vertices and M edges. The vertices are numbered 1 to N, and the edges are numbered 1 to M. In addition, each vertex has a label, `A` or `B`. The label of Vertex i is s_i. Edge i bidirectionally connects vertex a_i and b_i. The phantom thief Nusook likes to choose some vertex as the startpoint and traverse an edge zero or more times. Today, he will make a string after traveling as above, by placing the labels of the visited vertices in the order visited, beginning from the startpoint. For example, in a graph where Vertex 1 has the label `A` and Vertex 2 has the label `B`, if Nusook travels along the path 1 \rightarrow 2 \rightarrow 1 \rightarrow 2 \rightarrow 2, the resulting string is `ABABB`. Determine if Nusook can make all strings consisting of `A` and `B`. Constraints * 2 \leq N \leq 2 \times 10^{5} * 1 \leq M \leq 2 \times 10^{5} * \|s\| = N * s_i is `A` or `B`. * 1 \leq a_i, b_i \leq N * The given graph may NOT be simple or connected. Input Input is given from Standard Input in the following format: N M s a_1 b_1 : a_{M} b_{M} Output If Nusook can make all strings consisting of `A` and `B`, print `Yes`; otherwise, print `No`. Examples Input 2 3 AB 1 1 1 2 2 2 Output Yes Input 4 3 ABAB 1 2 2 3 3 1 Output No Input 13 23 ABAAAABBBBAAB 7 1 10 6 1 11 2 10 2 8 2 11 11 12 8 3 7 12 11 2 13 13 11 9 4 1 9 7 9 6 8 13 8 6 4 10 8 7 4 3 2 1 8 12 6 9 Output Yes Input 13 17 BBABBBAABABBA 7 1 7 9 11 12 3 9 11 9 2 1 11 5 12 11 10 8 1 11 1 8 7 7 9 10 8 8 8 12 6 2 13 11 Output No The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. On a two-dimensional plane, there are N red points and N blue points. The coordinates of the i-th red point are (a_i, b_i), and the coordinates of the i-th blue point are (c_i, d_i). A red point and a blue point can form a friendly pair when, the x-coordinate of the red point is smaller than that of the blue point, and the y-coordinate of the red point is also smaller than that of the blue point. At most how many friendly pairs can you form? Note that a point cannot belong to multiple pairs. Constraints * All input values are integers. * 1 \leq N \leq 100 * 0 \leq a_i, b_i, c_i, d_i < 2N * a_1, a_2, ..., a_N, c_1, c_2, ..., c_N are all different. * b_1, b_2, ..., b_N, d_1, d_2, ..., d_N are all different. Input Input is given from Standard Input in the following format: N a_1 b_1 a_2 b_2 : a_N b_N c_1 d_1 c_2 d_2 : c_N d_N Output Print the maximum number of friendly pairs. Examples Input 3 2 0 3 1 1 3 4 2 0 4 5 5 Output 2 Input 3 0 0 1 1 5 2 2 3 3 4 4 5 Output 2 Input 2 2 2 3 3 0 0 1 1 Output 0 Input 5 0 0 7 3 2 2 4 8 1 6 8 5 6 9 5 4 9 1 3 7 Output 5 Input 5 0 0 1 1 5 5 6 6 7 7 2 2 3 3 4 4 8 8 9 9 Output 4 The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. There is a tree with N vertices numbered 1 through N. The i-th of the N-1 edges connects vertices a_i and b_i. Initially, each edge is painted blue. Takahashi will convert this blue tree into a red tree, by performing the following operation N-1 times: * Select a simple path that consists of only blue edges, and remove one of those edges. * Then, span a new red edge between the two endpoints of the selected path. His objective is to obtain a tree that has a red edge connecting vertices c_i and d_i, for each i. Determine whether this is achievable. Constraints * 2 ≤ N ≤ 10^5 * 1 ≤ a_i,b_i,c_i,d_i ≤ N * a_i ≠ b_i * c_i ≠ d_i * Both input graphs are trees. Input Input is given from Standard Input in the following format: N a_1 b_1 : a_{N-1} b_{N-1} c_1 d_1 : c_{N-1} d_{N-1} Output Print `YES` if the objective is achievable; print `NO` otherwise. Examples Input 3 1 2 2 3 1 3 3 2 Output YES Input 5 1 2 2 3 3 4 4 5 3 4 2 4 1 4 1 5 Output YES Input 6 1 2 3 5 4 6 1 6 5 1 5 3 1 4 2 6 4 3 5 6 Output NO The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Snuke got a present from his mother on his birthday. The present was a pair of two sequences a and b, consisting of positive integers. They satisfied all of the following properties: * The sum of all elements of a is N. * The sum of all elements of b is N. * Any string of length N that satisfies the following two conditions (1) and (2) will also satisfy the condition (3). * (1) Any of the following forms a palindrome: the first a_1 letters, the following a_2 letters, the following a_3 letters and so on. * (2) Any of the following forms a palindrome: the first b_1 letters, the following b_2 letters, the following b_3 letters and so on. * (3) All N letters are the same. He was happy, until one day he lost both of the sequences. Now, he only remembers that the sequence a was a permutation of another sequence A of length M. To bring him happiness again, his mother has decided to give him another pair of sequences a and b that satisfies his favorite properties and is consistent with his memory. Constraints * 1≦N≦10^5 * 1≦M≦100 * 1≦A_i≦10^5 * The sum of all A_i equals N. Input The input is given from Standard Input in the following format: N M A_1 A_2 ... A_M Output If there exists a pair of sequences a and b that satisfies the properties and is consistent with Snuke's memory, print three lines. The first line must contain the sequence a, the second line must contain the length of the sequence b, and the third line must contain the sequence b. If such a pair does not exist (because Snuke's memory is wrong or some other reason), print a single line containing the word `Impossible` (case-sensitive). Examples Input 3 2 2 1 Output 1 2 1 3 Input 6 1 6 Output 6 3 1 2 3 Input 55 10 1 2 3 4 5 6 7 8 9 10 Output Impossible The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Taro is not good at hide-and-seek. As soon as you hide, you will find it, and it will be difficult to find the hidden child. My father, who couldn't see it, made an ultra-high performance location search system. You can use it to know exactly where your friends are, including your own. Once you become a demon, you can easily find the hidden child. Taro came up with the idea of further evolving this system and adding a function to judge whether or not he can be seen by the demon. If you can do this, even if you are told "Is it okay", if you are in a visible position, it is "OK", and if you are in an invisible position, it is "Okay". The park I play all the time has cylindrical walls of various sizes. This wall cannot be seen from the outside, nor can it be seen from the inside. If you go inside with a demon, you can see it without another wall. <image> Taro has a good idea, but he is not good at making software. So, your best friend, you, decided to make the software of "Invisible to the Demon Confirmation System" on behalf of Mr. Taro. The walls of the park are fixed, but you need to determine if you can see them for various locations of Taro and the demon. Information on the walls in the park (center coordinates (wx, wy) and radius r) and position information of Taro and the demon (coordinates of Taro's position (tx, ty) and coordinates of the position of the demon (sx, sy)) ) Is input, and create a program that determines whether or not you can see Taro from the demon at that position. If you can see Taro from the demon, output Danger, and if you cannot see it, output Safe. If there is a wall on the line segment connecting the positions of the demon and Taro, it shall not be visible, and neither the demon nor Taro shall be on the wall. Input Given multiple datasets. Each dataset is given in the following format: n wx1 wy1 r1 wx2 wy2 r2 :: wxn wyn rn m tx1 ty1 sx1 sy1 tx2 ty2 sx2 sy2 :: txm tym sxm sym The first line is the number of cylindrical walls n (0 ≤ n ≤ 100), the next n lines are the integers wxi, wyi (0 ≤ wxi, wyi ≤ 255) representing the coordinates of the center of the wall i and the integer ri representing the radius. (1 ≤ ri ≤ 255) is given. The number of position information of Taro-kun and the demon in the following line m (m ≤ 100), and the integers txi, tyi (0 ≤ txi, tyi ≤ 255) and the demon that represent the coordinates of the position of Taro-kun in the position information i in the following line. Given the integers sxi, syi (0 ≤ sxi, syi ≤ 255) that represent the coordinates of the position of. Also, not all of the cylindrical walls are in the park, they are all cylindrical and enter the park. When n is 0, it indicates the end of input. The number of datasets does not exceed 20. Output For each data set, output the judgment result Danger or Safe of the location information i on the i-line. Example Input 3 6 6 3 19 7 4 21 8 1 6 5 4 2 11 12 4 2 11 11 9 2 11 14 3 20 5 17 9 20 5 20 10 20 5 0 Output Safe Safe Danger Safe Danger Safe The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. The following sorting operation is repeated for the stacked blocks as shown in Fig. A. 1. Stack all the bottom blocks (white blocks in Figure a) on the right edge (the remaining blocks will automatically drop one step down, as shown in Figure b). 2. If there is a gap between the blocks, pack it to the left to eliminate the gap (from Fig. B to Fig. C). For an integer k greater than or equal to 1, a number represented by k × (k + 1) / 2 (example: 1, 3, 6, 10, ...) is called a triangular number. If the total number of blocks is a triangular number, it is expected that if the above sorting is repeated, the height of the left end will be 1 and the total number will increase by 1 toward the right (Fig. D shows the total number). For 15). <image> When the first sequence of blocks is given, when the triangle of the block as explained above is created by the operation less than the predetermined number of times, create a program that outputs the minimum number of operations until the triangle is obtained. please. input The input consists of multiple datasets. The end of the input is indicated by a single zero line. Each dataset is given in the following format. N b1 b2 ... bN Each dataset has two rows and represents the first sequence of blocks. N (1 ≤ N ≤ 100) indicates the number of blocks in the bottom row. bi (1 ≤ bi ≤ 10000) indicates the number of blocks stacked in the i-th position from the left. bi and bi + 1 are separated by a single space. The total number of blocks is 3 or more. The number of datasets does not exceed 20. output For each data set, the number of sorting operations performed until the triangle is formed is output on one line. However, if a triangle cannot be created or the number of operations exceeds 10000, -1 is output. Example Input 6 1 4 1 3 2 4 5 1 2 3 4 5 10 1 1 1 1 1 1 1 1 1 1 9 1 1 1 1 1 1 1 1 1 12 1 4 1 3 2 4 3 3 2 1 2 2 1 5050 3 10000 10000 100 0 Output 24 0 10 -1 48 5049 -1 The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. problem There are n islands in JOI, and each island is numbered from 1 to n. Currently, the JOI country is developing a route network connecting each island. You work at a ticket center that handles ship tickets. There are many people in JOI who want to travel between islands by boat, as cheaply as possible, and they fill out the order form with their origin and destination, and they are at your place. Will be sent to. Your job is to transfer several vessels as soon as you receive the order form from the customer, calculate the cheapest fare on the route connecting the departure point and the destination, and tell the customer. However, depending on the itinerary, it may not be possible to travel by ship. At that time, it is necessary to tell the customer that "I cannot travel by ship". Also, in JOI, new vessels connecting the islands are starting to operate one after another, and you will be informed of this information from time to time. When replying to customers, you must keep in mind the latest information. Create a program that asks for a reply to the customer when the customer's order form or operation information of the newly started vessel is given as input. The execution status of Input Example 1 and Output Example 1 is shown in Fig. 1. input The input consists of multiple datasets. Each dataset is given in the following format. Two integers n, k (1 ≤ n ≤ 100, 1 ≤ k ≤ 5000) are written on the first line of the input. This means that the number of islands is n and the input consists of k + 1 lines. On the first line of i + (1 ≤ i ≤ k), three or four integers are written separated by blanks. * When the first number is 0, this line represents the customer's order form. Three integers 0, a, b (1 ≤ a ≤ n, 1 ≤ b ≤ n, a ≠ b) are written on this line, separated by blanks. This means that the customer has sent an order form with island a as the starting point and island b as the destination. * When the first number is 1, this line represents the operation information of the newly started vessel. This line contains four integers 1, c, d, e (1 ≤ c ≤ n, 1 ≤ d ≤ n, c ≠ d, 1 ≤ e ≤ 1000000). This means that a vessel that goes back and forth between island c and island d has newly started operation, and the fare from island c to island d and the fare from island d to island c are both e. The order form after this line must be answered in consideration of this vessel. At the first stage, it is assumed that no vessel is in operation. Of the inputs, the number of lines representing ship operation information is 1000 or less. Also note that multiple vessels may operate between islands. When both n and k are 0, it indicates the end of input. The number of data sets does not exceed 5. output Output in the following format for each data set. Let m be the number of lines representing the order form in the input. The output of each dataset consists of m lines, and on the i-th line (1 ≤ i ≤ m), an integer representing the reply to the i-th order form is written. That is, if it is possible to travel between the departure point and the destination of the i-th order form by connecting several vessels, write the minimum value of the total fare. If it is impossible to travel, output -1. Examples Input 3 8 1 3 1 10 0 2 3 1 2 3 20 1 1 2 5 0 3 2 1 1 3 7 1 2 1 9 0 2 3 5 16 1 1 2 343750 1 1 3 3343 1 1 4 347392 1 1 5 5497 1 2 3 123394 1 2 4 545492 1 2 5 458 1 3 4 343983 1 3 5 843468 1 4 5 15934 0 2 1 0 4 1 0 3 2 0 4 2 0 4 3 0 5 3 0 0 Output -1 15 12 5955 21431 9298 16392 24774 8840 Input None Output None The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Saying that it is not surprising that people want to know about their love, she has checked up his address, name, age, phone number, hometown, medical history, political party and even his sleeping position, every piece of his personal information. The word "privacy" is not in her dictionary. A person like her is called "stoker" or "yandere", but it doesn't mean much to her. To know about him, she set up spyware to his PC. This spyware can record his mouse operations while he is browsing websites. After a while, she could successfully obtain the record from the spyware in absolute secrecy. Well, we want you to write a program which extracts web pages he visited from the records. All pages have the same size H × W where upper-left corner is (0, 0) and lower right corner is (W, H). A page includes several (or many) rectangular buttons (parallel to the page). Each button has a link to another page, and when a button is clicked the browser leads you to the corresponding page. His browser manages history and the current page in the following way: The browser has a buffer of 1-dimensional array with enough capacity to store pages, and a pointer to indicate a page in the buffer. A page indicated by the pointer is shown on the browser. At first, a predetermined page is stored and the pointer indicates that page. When the link button is clicked, all pages recorded in the right side from the pointer are removed from the buffer. Then, the page indicated by the link button is stored into the right-most position of the buffer, and the pointer moves to right. As a result, the user browse the page indicated by the button. The browser also has special buttons 'back to the previous page' (back button) and 'forward to the next page' (forward button). When the user clicks the back button, the pointer moves to left, and the user clicks the forward button, the pointer moves to right. But in both cases, if there are no such pages in the buffer, nothing happen. The record consists of the following operations: click x y It means to click (x, y). If there is a button on the point (x, y), he moved to the corresponding page. If there is nothing in the point, nothing happen. The button is clicked if x1 ≤ x ≤ x2 and y1 ≤ y ≤ y2 where x1, x2 means the leftmost and rightmost coordinate and y1, y2 means the topmost and bottommost coordinate of the corresponding button respectively. back It means to click the Back button. forward It means to click the Forward button. In addition, there is a special operation show. Your program should print the name of current page for each show operation. By the way, setting spyware into computers of others may conflict with the law. Do not attempt, or you will be reprimanded by great men. Constraints * 1 ≤ n ≤ 100 * b[i] ≤ 100 * 1 ≤ the number of characters in the name ≤ 20 * Buttons are not touch, overlapped nor run over from the browser. Input Input consists of several datasets. Each dataset starts with an integer n which represents the number of pages in the dataset. Next line contains two integers W and H. Next, information of each page are given. Each page starts with a string of characters and b[i], the number of buttons the page has. Following b[i] lines give information of buttons. Each button consists of four integers representing the coordinate (x1, y1) of upper left corner and the coordinate (x2, y2) of lower right corner of the button and a string of characters, which represents the name of page that the link of the button represents. Next, the number of operation m is given. Following m lines represent the record of operations. Please see the above description for the operation. The first page is stored in the buffer at first. Input ends when n = 0. Output For each dataset, output the name of current page for each show operation. Example Input 3 800 600 index 1 500 100 700 200 profile profile 2 100 100 400 200 index 100 400 400 500 link link 1 100 100 300 200 index 9 click 600 150 show click 200 450 show back back show forward show 0 Output profile link index profile The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. There are a number of rectangles on the x-y plane. The four sides of the rectangles are parallel to either the x-axis or the y-axis, and all of the rectangles reside within a range specified later. There are no other constraints on the coordinates of the rectangles. The plane is partitioned into regions surrounded by the sides of one or more rectangles. In an example shown in Figure C.1, three rectangles overlap one another, and the plane is partitioned into eight regions. Rectangles may overlap in more complex ways. For example, two rectangles may have overlapped sides, they may share their corner points, and/or they may be nested. Figure C.2 illustrates such cases. Your job is to write a program that counts the number of the regions on the plane partitioned by the rectangles. Input The input consists of multiple datasets. Each dataset is formatted as follows. n l1 t1 r1 b1 l2 t2 r2 b2 : ln tn rn bn A dataset starts with n (1 ≤ n ≤ 50), the number of rectangles on the plane. Each of the following n lines describes a rectangle. The i-th line contains four integers, li, ti, ri, and bi, which are the coordinates of the i-th rectangle; (li, ti) gives the x-y coordinates of the top left corner, and (ri, bi) gives that of the bottom right corner of the rectangle (0 ≤ li < ri ≤ 106, 0 ≤ bi < ti ≤ 106, for 1 ≤ i ≤ n). The four integers are separated by a space. The input is terminated by a single zero. Output For each dataset, output a line containing the number of regions on the plane partitioned by the sides of the rectangles. <image> Figure C.1. Three rectangles partition the plane into eight regions. This corresponds to the first dataset of the sample input. The x- and y-axes are shown for illustration purposes only, and therefore they do not partition the plane. <image> Figure C.2. Rectangles overlapping in more complex ways. This corresponds to the second dataset. Example Input 3 4 28 27 11 15 20 42 5 11 24 33 14 5 4 28 27 11 12 11 34 2 7 26 14 16 14 16 19 12 17 28 27 21 2 300000 1000000 600000 0 0 600000 1000000 300000 0 Output 8 6 6 The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Problem There is an arithmetic progression A with the number of terms N, the first term a, and the tolerance d. Since M statements that update the sequence are given in the following format, find the value of the K item when the sequence A is updated M times in the given order. * The i-th statement is represented by the three integers xi, yi, zi (1 ≤ i ≤ M). * If xi is 0, swap the value of yi item and the value of zi item. * If xi is 1, rewrite the value of yi item to the value of zi item. Constraints * 1 ≤ N ≤ 108 * 1 ≤ a ≤ 5 * 1 ≤ d ≤ 5 * 1 ≤ M ≤ 10 * 0 ≤ xi ≤ 1 (1 ≤ i ≤ M) * 1 ≤ yi ≤ N (1 ≤ i ≤ M) * 1 ≤ zi ≤ N (1 ≤ i ≤ M) * yi ≠ zi (1 ≤ i ≤ M) * 1 ≤ K ≤ N Input N a d M x1 y1 z1 x2 y2 z2 ... xM yM zM K The first line is given one integer N. On the second line, two integers a and d are given, separated by blanks. On the third line, one integer M is given. Of the M lines from the 4th line, the ith line is given three integers xi, yi, and zi representing the i-th statement, separated by blanks. The last line is given one integer K. Output Output the K item when the sequence A is updated M times in the order given by the input. Examples Input 5 2 3 3 0 2 5 0 3 5 1 2 4 2 Output 11 Input 6 5 5 4 0 1 2 1 1 2 0 4 1 1 1 6 3 Output 15 The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. English text is not available in this practice contest. At one point, a nobleman fell in love with a brave princess in a poor country and applied for marriage. The princess has given certain conditions to the aristocrats. The condition was to bring in a large number of jewels called "immortal jewels". Immortal gems are extremely rare gems that can only be taken at specific locations on a mountain. Moreover, it was very fragile, so a special method was required to collect it. Immortal gems have a circular shape, and there are multiple immortal gems in two-dimensional space. To take these gems, you need to adsorb them with a special metal rod. The metal rod is a straight line with infinite length, and the thickness can be ignored. Each gem has a different strength of magnetic force, and if the metal is close enough to react to the magnetic force, the gem will be adsorbed. Specifically, when the distance between the metal and the surface of the gemstone is d and the strength of the magnetic force of the gemstone is m, > 0 ≤ d ≤ m If so, the gem is adsorbed on the metal. On the contrary, if the metal rod and the jewel are farther than their magnetic force, they cannot be attracted. Also, even if the stick penetrates the jewel even a little, the jewel will break and cannot be adsorbed. Let's look at an example. The figure below is an example of a jewel placed in a two-dimensional space. It is assumed that there are jewels 1 to 6 and the magnetic forces are 1, 0, 1, 1, 1, 2, respectively. <image> Figure E-1: Example of jewel placement The figure below shows an example of arranging metal rods in addition to the figure above. The results of adsorbing gems are also shown in the table. In the case of this example, the jewel 3 is far from the reach of the magnetic force, and the jewel 4 cannot be adsorbed because it is penetrated by the rod, but the remaining four can be adsorbed. <image> Figure E-2: Example of metal rod placement Gem name \| Magnetic force \| Distance to metal \| Can it be adsorbed? --- \| --- \| --- \| --- Jewels 1 \| 1 \| About 0.21 \| Can Jewels 2 \| 0 \| 0 \| Can Jewels 3 \| 1 \| About 5.37 \| Can't Jewels 4 \| 1 \| Penetrate \| Can't Jewels 5 \| 1 \| About 0.97 \| Can Jewels 6 \| 2 \| About 0.53 \| Can Table E-3: Adsorption results The aristocrat poured all his fortune and desperately sought a special metal rod. However, this metal was also so valuable that only one was available in the end. Therefore, there is only one chance of adsorption. You are a programmer who serves an aristocrat. Your job is to write a program to find out how many gems can be adsorbed when a metal rod is placed well for a given two-dimensional gem placement. .. Input The input consists of multiple datasets, one dataset is given in the following format. > N > x1 y1 r1 m1 > x2 y2 r2 m2 > ... > xN yN rN mN > The first row of the dataset represents the number of gems N (1 ≤ N ≤ 50). Each of the following N lines contains four integers xi, yi, ri, mi (-1000 ≤ xi, yi ≤ 1000, 1 ≤ ri ≤ 100, 0 ≤ mi ≤ 100), and the position and size of the gem. And represents the magnetic force. That is, the jewel i has a circular shape with the center (xi, yi) and a radius of ri, and its magnetic force is mi. Jewels do not overlap each other. The end of the input is represented by a line consisting of only 0s. Output For each dataset, output the maximum number of gems that can be adsorbed at one time on one line. Example Input 6 -2 -2 1 1 2 2 2 0 5 7 1 1 8 0 3 1 13 4 1 1 16 1 1 2 3 0 0 2 1 10 0 2 1 0 10 2 1 3 0 0 2 1 10 0 2 1 0 6 2 1 3 0 0 2 1 10 0 2 1 0 4 2 1 1 0 0 1 1 0 Output 4 2 3 3 1 The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Example Input mmemewwemeww Output Cat The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. problem In Ikatta, the SNS used by AOR Ika-chan, posts are called tweets. And in squid, there is a concern that visibility will deteriorate if there are many replies to tweets, so when a tweet meets any of the following rules, the tweet will be displayed on the screen. ing. * Rule 1. No reply to any tweet * Rule 2. No reply from any tweet * Rule 3. When you follow the reply destinations in order from the tweet to which Rule 2 is applied, you can reach it in less than $ K $ times. The same tweet will not be displayed more than once. Now, when there are $ N $ tweets and $ A_i $ is $ 0 $, the $ i $ th tweet is a non-reply tweet, and when $ A_i $ is not $ 0 $, the $ i $ th tweet is the $ A_i $ th tweet. It is a tweet of the reply to the tweet of. Answer the number of tweets displayed on the screen. output Output the number of tweets displayed on the screen. Also, output a line break at the end. Example Input 6 3 0 0 2 3 4 5 Output 5 The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Problem statement I have a grid of $ H $ rows and $ W $ columns. Hereafter, the cells in the $ i $ row and $ j $ column on the grid are written as $ (i, j) $ cells. Each cell in the grid has a number between $ 1 $ and $ 6 $, or the letter `#` in $ 1 $ each. However, `#` is always written in the cell of $ (i, j) $ where both $ i $ and $ j $ are even numbers. You have $ 1 $ on the dice as shown in the figure below. dice_picture Initially, you place this dice on a $ (1, 1) $ square with a bottom of $ 6 $, a front of $ 2 $, and a right of $ 3 $. Here, the front side is the surface of $ (i, j) $ in the direction of increasing $ i $, and the right side is the surface of $ j $ in the direction of increasing $ j $. You can then roll the dice to any of the $ 4 $ squares adjacent to the square on which the dice are placed, as many times as you like. When rolling the dice, the dice rotate 90 degrees in the rolling direction. However, the following conditions must be met when rolling the dice. * Do not roll the dice off the grid * Do not roll on the square where `#` is written * When considering the state after rolling, the number written on the bottom of the dice matches the number written on the square. It is guaranteed that $ 6 $ is always written in the $ (1, 1) $ cell. Determine if you can move the dice from the $ (1, 1) $ square to the $ (H, W) $ square by repeating the rolling operation of the dice. Constraint * $ 1 \ leq H, W \ leq 100 $ * Each cell in the grid has a number between $ 1 $ and $ 6 $, or `#`. * `#` Is always written in the cell of $ (i, j) $ where both $ i and j $ are even numbers. * It is guaranteed that $ 6 $ is written in $ (1, 1) $ * * * input Input is given from standard input in the following format. $ H $ $ W $ $ s_ {11} s_ {12} \ ldots s_ {1W} $ $ s_ {21} s_ {22} \ ldots s_ {2W} $ $ \ vdots $ $ s_ {H1} s_ {H2} \ ldots s_ {HW} $ Here, $ s_ {ij} $ represents a number or letter written in the cell of $ (i, j) $. That is, $ s_ {ij} $ is a number greater than or equal to $ 1 $ and less than or equal to $ 6 $, or is `#`. output Output `YES` on one line if you can roll the dice from the $ (1, 1) $ cell to the $ (H, W) $ cell, otherwise output` NO`. * * * Input example 1 3 3 631 4 # 2 516 Output example 1 YES YES It can be reached by rolling in the order of $ (1, 1), (1, 2), (1, 3), (2, 3), (3, 3) $. * * * Input example 2 3 3 6 # 1 2 516 Output example 2 NO * * * Input example 3 5 5 61244 2 # 5 # 3 14641 5 # 5 # 5 63126 Output example 3 YES YES Example Input 3 3 631 4#2 516 Output YES The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Find bridges of an undirected graph G(V, E). A bridge (also known as a cut-edge) is an edge whose deletion increase the number of connected components. Constraints * 1 ≤ \|V\| ≤ 100,000 * 0 ≤ \|E\| ≤ 100,000 * The graph is connected * There are no parallel edges * There are no self-loops Input \|V\| \|E\| s0 t0 s1 t1 : s\|E\|-1 t\|E\|-1 , where \|V\| is the number of nodes and \|E\| is the number of edges in the graph. The graph nodes are named with the numbers 0, 1,..., \|V\|-1 respectively. si and ti represent source and target nodes of i-th edge (undirected). Output A list of bridges of the graph ordered by name. For each bridge, names of its end-ponints, source and target (source < target), should be printed separated by a space. The sources should be printed ascending order, then the target should also be printed ascending order for the same source. Examples Input 4 4 0 1 0 2 1 2 2 3 Output 2 3 Input 5 4 0 1 1 2 2 3 3 4 Output 0 1 1 2 2 3 3 4 The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. You are given n integers a_1, a_2, …, a_n. Each of a_i has between 3 and 5 divisors. Consider a = ∏ a_i — the product of all input integers. Find the number of divisors of a. As this number may be very large, print it modulo prime number 998244353. Input The first line contains a single integer n (1 ≤ n ≤ 500) — the number of numbers. Each of the next n lines contains an integer a_i (1 ≤ a_i ≤ 2⋅ 10^{18}). It is guaranteed that the number of divisors of each a_i is between 3 and 5. Output Print a single integer d — the number of divisors of the product a_1 ⋅ a_2 ⋅ ... ⋅ a_n modulo 998244353. Hacks input For hacks, the input needs to be provided in a special format. The first line contains an integer n (1 ≤ n ≤ 500) — the number of numbers. Each of the next n lines contains a prime factorization of a_i. The line contains an integer k_i (2 ≤ k_i ≤ 4) — the number of prime factors of a_i and k_i integers p_{i,j} (2 ≤ p_{i,j} ≤ 2 ⋅ 10^{18}) where p_{i,j} is the j-th prime factor of a_i. Before supplying the input to the contestant, a_i = ∏ p_{i,j} are calculated. Note that each p_{i,j} must be prime, each computed a_i must satisfy a_i ≤ 2⋅10^{18} and must have between 3 and 5 divisors. The contestant will be given only a_i, and not its prime factorization. For example, you need to use this test to get the first sample: 3 2 3 3 2 3 5 2 11 13 Interaction From the technical side, this problem is interactive. Therefore, do not forget to output end of line and flush the output. Also, do not read more than you need. To flush the output, use: * fflush(stdout) or cout.flush() in C++; * System.out.flush() in Java; * flush(output) in Pascal; * stdout.flush() in Python; * see documentation for other languages. Examples Input 3 9 15 143 Output 32 Input 1 7400840699802997 Output 4 Input 8 4606061759128693 4606066102679989 4606069767552943 4606063116488033 4606063930903637 4606064745319241 4606063930904021 4606065559735517 Output 1920 Input 3 4 8 16 Output 10 Note In the first case, a = 19305. Its divisors are 1, 3, 5, 9, 11, 13, 15, 27, 33, 39, 45, 55, 65, 99, 117, 135, 143, 165, 195, 297, 351, 429, 495, 585, 715, 1287, 1485, 1755, 2145, 3861, 6435, 19305 — a total of 32. In the second case, a has four divisors: 1, 86028121, 86028157, and 7400840699802997 . In the third case a = 202600445671925364698739061629083877981962069703140268516570564888699 375209477214045102253766023072401557491054453690213483547. In the fourth case, a=512=2^9, so answer equals to 10. The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Arkady and his friends love playing checkers on an n × n field. The rows and the columns of the field are enumerated from 1 to n. The friends have recently won a championship, so Arkady wants to please them with some candies. Remembering an old parable (but not its moral), Arkady wants to give to his friends one set of candies per each cell of the field: the set of candies for cell (i, j) will have exactly (i^2 + j^2) candies of unique type. There are m friends who deserve the present. How many of these n × n sets of candies can be split equally into m parts without cutting a candy into pieces? Note that each set has to be split independently since the types of candies in different sets are different. Input The only line contains two integers n and m (1 ≤ n ≤ 10^9, 1 ≤ m ≤ 1000) — the size of the field and the number of parts to split the sets into. Output Print a single integer — the number of sets that can be split equally. Examples Input 3 3 Output 1 Input 6 5 Output 13 Input 1000000000 1 Output 1000000000000000000 Note In the first example, only the set for cell (3, 3) can be split equally (3^2 + 3^2 = 18, which is divisible by m=3). In the second example, the sets for the following cells can be divided equally: * (1, 2) and (2, 1), since 1^2 + 2^2 = 5, which is divisible by 5; * (1, 3) and (3, 1); * (2, 4) and (4, 2); * (2, 6) and (6, 2); * (3, 4) and (4, 3); * (3, 6) and (6, 3); * (5, 5). In the third example, sets in all cells can be divided equally, since m = 1. The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Andrey received a postcard from Irina. It contained only the words "Hello, Andrey!", and a strange string consisting of lowercase Latin letters, snowflakes and candy canes. Andrey thought that this string is an encrypted message, and decided to decrypt it. Andrey noticed that snowflakes and candy canes always stand after the letters, so he supposed that the message was encrypted as follows. Candy cane means that the letter before it can be removed, or can be left. A snowflake means that the letter before it can be removed, left, or repeated several times. For example, consider the following string: <image> This string can encode the message «happynewyear». For this, candy canes and snowflakes should be used as follows: * candy cane 1: remove the letter w, * snowflake 1: repeat the letter p twice, * candy cane 2: leave the letter n, * snowflake 2: remove the letter w, * snowflake 3: leave the letter e. <image> Please note that the same string can encode different messages. For example, the string above can encode «hayewyar», «happpppynewwwwwyear», and other messages. Andrey knows that messages from Irina usually have a length of k letters. Help him to find out if a given string can encode a message of k letters, and if so, give an example of such a message. Input The first line contains the string received in the postcard. The string consists only of lowercase Latin letters, as well as the characters «» and «?», meaning snowflake and candy cone, respectively. These characters can only appear immediately after the letter. The length of the string does not exceed 200. The second line contains an integer number k (1 ≤ k ≤ 200), the required message length. Output Print any message of length k that the given string can encode, or «Impossible» if such a message does not exist. Examples Input hw?apyn?ewwyear 12 Output happynewyear Input ab?a 2 Output aa Input ab?a 3 Output aba Input ababb 5 Output ababb Input ab?a 1 Output Impossible The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Vus the Cossack has two binary strings, that is, strings that consist only of "0" and "1". We call these strings a and b. It is known that \|b\| ≤ \|a\|, that is, the length of b is at most the length of a. The Cossack considers every substring of length \|b\| in string a. Let's call this substring c. He matches the corresponding characters in b and c, after which he counts the number of positions where the two strings are different. We call this function f(b, c). For example, let b = 00110, and c = 11000. In these strings, the first, second, third and fourth positions are different. Vus the Cossack counts the number of such substrings c such that f(b, c) is even. For example, let a = 01100010 and b = 00110. a has four substrings of the length \|b\|: 01100, 11000, 10001, 00010. * f(00110, 01100) = 2; * f(00110, 11000) = 4; * f(00110, 10001) = 4; * f(00110, 00010) = 1. Since in three substrings, f(b, c) is even, the answer is 3. Vus can not find the answer for big strings. That is why he is asking you to help him. Input The first line contains a binary string a (1 ≤ \|a\| ≤ 10^6) — the first string. The second line contains a binary string b (1 ≤ \|b\| ≤ \|a\|) — the second string. Output Print one number — the answer. Examples Input 01100010 00110 Output 3 Input 1010111110 0110 Output 4 Note The first example is explained in the legend. In the second example, there are five substrings that satisfy us: 1010, 0101, 1111, 1111. The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Recently Ivan the Fool decided to become smarter and study the probability theory. He thinks that he understands the subject fairly well, and so he began to behave like he already got PhD in that area. To prove his skills, Ivan decided to demonstrate his friends a concept of random picture. A picture is a field of n rows and m columns, where each cell is either black or white. Ivan calls the picture random if for every cell it has at most one adjacent cell of the same color. Two cells are considered adjacent if they share a side. Ivan's brothers spent some time trying to explain that it's not how the randomness usually works. Trying to convince Ivan, they want to count the number of different random (according to Ivan) pictures. Two pictures are considered different if at least one cell on those two picture is colored differently. Since the number of such pictures may be quite large, print it modulo 10^9 + 7. Input The only line contains two integers n and m (1 ≤ n, m ≤ 100 000), the number of rows and the number of columns of the field. Output Print one integer, the number of random pictures modulo 10^9 + 7. Example Input 2 3 Output 8 Note The picture below shows all possible random pictures of size 2 by 3. <image> The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Try guessing the statement from this picture <http://tiny.cc/ogyoiz>. You are given two integers A and B, calculate the number of pairs (a, b) such that 1 ≤ a ≤ A, 1 ≤ b ≤ B, and the equation a ⋅ b + a + b = conc(a, b) is true; conc(a, b) is the concatenation of a and b (for example, conc(12, 23) = 1223, conc(100, 11) = 10011). a and b should not contain leading zeroes. Input The first line contains t (1 ≤ t ≤ 100) — the number of test cases. Each test case contains two integers A and B (1 ≤ A, B ≤ 10^9). Output Print one integer — the number of pairs (a, b) such that 1 ≤ a ≤ A, 1 ≤ b ≤ B, and the equation a ⋅ b + a + b = conc(a, b) is true. Example Input 3 1 11 4 2 191 31415926 Output 1 0 1337 Note There is only one suitable pair in the first test case: a = 1, b = 9 (1 + 9 + 1 ⋅ 9 = 19). The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. <image> Input The input contains two integers row, col (0 ≤ row, col ≤ 63), separated by a single space. Output Output "IN" or "OUT". Examples Input 0 0 Output OUT Input 27 0 Output IN Input 0 27 Output OUT Input 27 27 Output IN The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Skier rides on a snowy field. Its movements can be described by a string of characters 'S', 'N', 'W', 'E' (which correspond to 1 meter movement in the south, north, west or east direction respectively). It is known that if he moves along a previously unvisited segment of a path (i.e. this segment of the path is visited the first time), then the time of such movement is 5 seconds. If he rolls along previously visited segment of a path (i.e., this segment of the path has been covered by his path before), then it takes 1 second. Find the skier's time to roll all the path. Input The first line contains an integer t (1 ≤ t ≤ 10^4) — the number of test cases in the input. Then t test cases follow. Each set is given by one nonempty string of the characters 'S', 'N', 'W', 'E'. The length of the string does not exceed 10^5 characters. The sum of the lengths of t given lines over all test cases in the input does not exceed 10^5. Output For each test case, print the desired path time in seconds. Example Input 5 NNN NS WWEN WWEE NWNWS Output 15 6 16 12 25 The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. This is the easy version of the problem. The difference between versions is the constraints on n and a_i. You can make hacks only if all versions of the problem are solved. First, Aoi came up with the following idea for the competitive programming problem: Yuzu is a girl who collecting candies. Originally, she has x candies. There are also n enemies numbered with integers from 1 to n. Enemy i has a_i candies. Yuzu is going to determine a permutation P. A permutation 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 (because n=3 but there is the number 4 in the array). After that, she will do n duels with the enemies with the following rules: * If Yuzu has equal or more number of candies than enemy P_i, she wins the duel and gets 1 candy. Otherwise, she loses the duel and gets nothing. * The candy which Yuzu gets will be used in the next duels. Yuzu wants to win all duels. How many valid permutations P exist? This problem was easy and wasn't interesting for Akari, who is a friend of Aoi. And Akari made the following problem from the above idea: Let's define f(x) as the number of valid permutations for the integer x. You are given n, a and a prime number p ≤ n. Let's call a positive integer x good, if the value f(x) is not divisible by p. Find all good integers x. Your task is to solve this problem made by Akari. Input The first line contains two integers n, p (2 ≤ p ≤ n ≤ 2000). It is guaranteed, that the number p is prime (it has exactly two divisors 1 and p). The second line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 2000). Output In the first line, print the number of good integers x. In the second line, output all good integers x in the ascending order. It is guaranteed that the number of good integers x does not exceed 10^5. Examples Input 3 2 3 4 5 Output 1 3 Input 4 3 2 3 5 6 Output 2 3 4 Input 4 3 9 1 1 1 Output 0 Note In the first test, p=2. * If x ≤ 2, there are no valid permutations for Yuzu. So f(x)=0 for all x ≤ 2. The number 0 is divisible by 2, so all integers x ≤ 2 are not good. * If x = 3, \{1,2,3\} is the only valid permutation for Yuzu. So f(3)=1, so the number 3 is good. * If x = 4, \{1,2,3\} , \{1,3,2\} , \{2,1,3\} , \{2,3,1\} are all valid permutations for Yuzu. So f(4)=4, so the number 4 is not good. * If x ≥ 5, all 6 permutations are valid for Yuzu. So f(x)=6 for all x ≥ 5, so all integers x ≥ 5 are not good. So, the only good number is 3. In the third test, for all positive integers x the value f(x) is divisible by p = 3. The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. You are given an array a consisting of n integers. We denote the subarray a[l..r] as the array [a_l, a_{l + 1}, ..., a_r] (1 ≤ l ≤ r ≤ n). A subarray is considered good if every integer that occurs in this subarray occurs there exactly thrice. For example, the array [1, 2, 2, 2, 1, 1, 2, 2, 2] has three good subarrays: * a[1..6] = [1, 2, 2, 2, 1, 1]; * a[2..4] = [2, 2, 2]; * a[7..9] = [2, 2, 2]. Calculate the number of good subarrays of the given array a. Input The first line contains one integer n (1 ≤ n ≤ 5 ⋅ 10^5). The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n). Output Print one integer — the number of good subarrays of the array a. Examples Input 9 1 2 2 2 1 1 2 2 2 Output 3 Input 10 1 2 3 4 1 2 3 1 2 3 Output 0 Input 12 1 2 3 4 3 4 2 1 3 4 2 1 Output 1 The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Mike received an array a of length n as a birthday present and decided to test how pretty it is. An array would pass the i-th prettiness test if there is a way to get an array with a sum of elements totaling s_i, using some number (possibly zero) of slicing operations. <image> An array slicing operation is conducted in the following way: * assume mid = ⌊(max(array) + min(array))/(2)⌋, where max and min — are functions that find the maximum and the minimum array elements. In other words, mid is the sum of the maximum and the minimum element of array divided by 2 rounded down. * Then the array is split into two parts left and right. The left array contains all elements which are less than or equal mid, and the right array contains all elements which are greater than mid. Elements in left and right keep their relative order from array. * During the third step we choose which of the left and right arrays we want to keep. The chosen array replaces the current one and the other is permanently discarded. You need to help Mike find out the results of q prettiness tests. Note that you test the prettiness of the array a, so you start each prettiness test with the primordial (initial) array a. Thus, the first slice (if required) is always performed on the array a. Input Each test contains one or more test cases. The first line contains the number of test cases t (1 ≤ t ≤ 100). The first line of each test case contains two integers n and q (1 ≤ n, q ≤ 10^5) — the length of the array a and the total number of prettiness tests. The second line of each test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^6) — the contents of the array a. Next q lines of each test case contain a single integer s_i (1 ≤ s_i ≤ 10^9) — the sum of elements which Mike wants to get in the i-th test. It is guaranteed that the sum of n and the sum of q does not exceed 10^5 (∑ n, ∑ q ≤ 10^5). Output Print q lines, each containing either a "Yes" if the corresponding prettiness test is passed and "No" in the opposite case. Example Input 2 5 5 1 2 3 4 5 1 8 9 12 6 5 5 3 1 3 1 3 1 2 3 9 11 Output Yes No Yes No Yes No Yes No Yes Yes Note Explanation of the first test case: 1. We can get an array with the sum s_1 = 1 in the following way: 1.1 a = [1, 2, 3, 4, 5], mid = (1+5)/(2) = 3, left = [1, 2, 3], right = [4, 5]. We choose to keep the left array. 1.2 a = [1, 2, 3], mid = (1+3)/(2) = 2, left = [1, 2], right = [3]. We choose to keep the left array. 1.3 a = [1, 2], mid = (1+2)/(2) = 1, left = [1], right = [2]. We choose to keep the left array with the sum equalling 1. 2. It can be demonstrated that an array with the sum s_2 = 8 is impossible to generate. 3. An array with the sum s_3 = 9 can be generated in the following way: 3.1 a = [1, 2, 3, 4, 5], mid = (1+5)/(2) = 3, left = [1, 2, 3], right = [4, 5]. We choose to keep the right array with the sum equalling 9. 4. It can be demonstrated that an array with the sum s_4 = 12 is impossible to generate. 5. We can get an array with the sum s_5 = 6 in the following way: 5.1 a = [1, 2, 3, 4, 5], mid = (1+5)/(2) = 3, left = [1, 2, 3], right = [4, 5]. We choose to keep the left with the sum equalling 6. Explanation of the second test case: 1. It can be demonstrated that an array with the sum s_1 = 1 is imposssible to generate. 2. We can get an array with the sum s_2 = 2 in the following way: 2.1 a = [3, 1, 3, 1, 3], mid = (1+3)/(2) = 2, left = [1, 1], right = [3, 3, 3]. We choose to keep the left array with the sum equalling 2. 3. It can be demonstrated that an array with the sum s_3 = 3 is imposssible to generate. 4. We can get an array with the sum s_4 = 9 in the following way: 4.1 a = [3, 1, 3, 1, 3], mid = (1+3)/(2) = 2, left = [1, 1], right = [3, 3, 3]. We choose to keep the right array with the sum equalling 9. 5. We can get an array with the sum s_5 = 11 with zero slicing operations, because array sum is equal to 11. The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Polycarp is playing a new computer game. This game has n stones in a row. The stone on the position i has integer power a_i. The powers of all stones are distinct. Each turn Polycarp can destroy either stone on the first position or stone on the last position (in other words, either the leftmost or the rightmost stone). When Polycarp destroys the stone it does not exist any more. Now, Polycarp wants two achievements. He gets them if he destroys the stone with the least power and the stone with the greatest power. Help Polycarp find out what is the minimum number of moves he should make in order to achieve his goal. For example, if n = 5 and a = [1, 5, 4, 3, 2], then Polycarp could make the following moves: * Destroy the leftmost stone. After this move a = [5, 4, 3, 2]; * Destroy the rightmost stone. After this move a = [5, 4, 3]; * Destroy the leftmost stone. After this move a = [4, 3]. Polycarp destroyed the stones with the greatest and least power, so he can end the game. Please note that in the example above, you can complete the game in two steps. For example: * Destroy the leftmost stone. After this move a = [5, 4, 3, 2]; * Destroy the leftmost stone. After this move a = [4, 3, 2]. Polycarp destroyed the stones with the greatest and least power, so he can end the game. Input The first line contains an integer t (1 ≤ t ≤ 100). Then t test cases follow. The first line of each test case contains one integer n (2 ≤ n ≤ 100) — the number of stones. The second line contains n distinct integers a_1, a_2, …, a_n (1 ≤ a_i ≤ n) — the power of the stones. Output For each test case, output the minimum number of moves required to destroy the stones with the greatest and the lowest power. Example Input 5 5 1 5 4 3 2 8 2 1 3 4 5 6 8 7 8 4 2 3 1 8 6 7 5 4 3 4 2 1 4 2 3 1 4 Output 2 4 5 3 2 The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. As you very well know, the whole Universe traditionally uses three-dimensional Cartesian system of coordinates. In this system each point corresponds to three real coordinates (x, y, z). In this coordinate system, the distance between the center of the Universe and the point is calculated by the following formula: <image>. Mushroom scientists that work for the Great Mushroom King think that the Universe isn't exactly right and the distance from the center of the Universe to a point equals xa·yb·zc. To test the metric of mushroom scientists, the usual scientists offered them a task: find such x, y, z (0 ≤ x, y, z; x + y + z ≤ S), that the distance between the center of the Universe and the point (x, y, z) is maximum possible in the metric of mushroom scientists. The mushroom scientists aren't good at maths, so they commissioned you to do the task. Note that in this problem, it is considered that 00 = 1. Input The first line contains a single integer S (1 ≤ S ≤ 103) — the maximum sum of coordinates of the sought point. The second line contains three space-separated integers a, b, c (0 ≤ a, b, c ≤ 103) — the numbers that describe the metric of mushroom scientists. Output Print three real numbers — the coordinates of the point that reaches maximum value in the metrics of mushroom scientists. If there are multiple answers, print any of them that meets the limitations. A natural logarithm of distance from the center of the Universe to the given point in the metric of mushroom scientists shouldn't differ from the natural logarithm of the maximum distance by more than 10 - 6. We think that ln(0) = - ∞. Examples Input 3 1 1 1 Output 1.0 1.0 1.0 Input 3 2 0 0 Output 3.0 0.0 0.0 The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Ternary numeric notation is quite popular in Berland. To telegraph the ternary number the Borze alphabet is used. Digit 0 is transmitted as «.», 1 as «-.» and 2 as «--». You are to decode the Borze code, i.e. to find out the ternary number given its representation in Borze alphabet. Input The first line contains a number in Borze code. The length of the string is between 1 and 200 characters. It's guaranteed that the given string is a valid Borze code of some ternary number (this number can have leading zeroes). Output Output the decoded ternary number. It can have leading zeroes. Examples Input .-.-- Output 012 Input --. Output 20 Input -..-.-- Output 1012 The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Valera conducts experiments with algorithms that search for shortest paths. He has recently studied the Floyd's algorithm, so it's time to work with it. Valera's already written the code that counts the shortest distance between any pair of vertexes in a non-directed connected graph from n vertexes and m edges, containing no loops and multiple edges. Besides, Valera's decided to mark part of the vertexes. He's marked exactly k vertexes a1, a2, ..., ak. Valera's code is given below. ans[i][j] // the shortest distance for a pair of vertexes i, j a[i] // vertexes, marked by Valera for(i = 1; i <= n; i++) { for(j = 1; j <= n; j++) { if (i == j) ans[i][j] = 0; else ans[i][j] = INF; //INF is a very large number } } for(i = 1; i <= m; i++) { read a pair of vertexes u, v that have a non-directed edge between them; ans[u][v] = 1; ans[v][u] = 1; } for (i = 1; i <= k; i++) { v = a[i]; for(j = 1; j <= n; j++) for(r = 1; r <= n; r++) ans[j][r] = min(ans[j][r], ans[j][v] + ans[v][r]); } Valera has seen that his code is wrong. Help the boy. Given the set of marked vertexes a1, a2, ..., ak, find such non-directed connected graph, consisting of n vertexes and m edges, for which Valera's code counts the wrong shortest distance for at least one pair of vertexes (i, j). Valera is really keen to get a graph without any loops and multiple edges. If no such graph exists, print -1. Input The first line of the input contains three integers n, m, k (3 ≤ n ≤ 300, 2 ≤ k ≤ n , <image>) — the number of vertexes, the number of edges and the number of marked vertexes. The second line of the input contains k space-separated integers a1, a2, ... ak (1 ≤ ai ≤ n) — the numbers of the marked vertexes. It is guaranteed that all numbers ai are distinct. Output If the graph doesn't exist, print -1 on a single line. Otherwise, print m lines, each containing two integers u, v — the description of the edges of the graph Valera's been looking for. Examples Input 3 2 2 1 2 Output 1 3 2 3 Input 3 3 2 1 2 Output -1 The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. You have number a, whose decimal representation quite luckily contains digits 1, 6, 8, 9. Rearrange the digits in its decimal representation so that the resulting number will be divisible by 7. Number a doesn't contain any leading zeroes and contains digits 1, 6, 8, 9 (it also can contain another digits). The resulting number also mustn't contain any leading zeroes. Input The first line contains positive integer a in the decimal record. It is guaranteed that the record of number a contains digits: 1, 6, 8, 9. Number a doesn't contain any leading zeroes. The decimal representation of number a contains at least 4 and at most 106 characters. Output Print a number in the decimal notation without leading zeroes — the result of the permutation. If it is impossible to rearrange the digits of the number a in the required manner, print 0. Examples Input 1689 Output 1869 Input 18906 Output 18690 The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. On some square in the lowest row of a chessboard a stands a pawn. It has only two variants of moving: upwards and leftwards or upwards and rightwards. The pawn can choose from which square of the lowest row it can start its journey. On each square lay from 0 to 9 peas. The pawn wants to reach the uppermost row having collected as many peas as possible. As there it will have to divide the peas between itself and its k brothers, the number of peas must be divisible by k + 1. Find the maximal number of peas it will be able to collect and which moves it should make to do it. The pawn cannot throw peas away or leave the board. When a pawn appears in some square of the board (including the first and last square of the way), it necessarily takes all the peas. Input The first line contains three integers n, m, k (2 ≤ n, m ≤ 100, 0 ≤ k ≤ 10) — the number of rows and columns on the chessboard, the number of the pawn's brothers. Then follow n lines containing each m numbers from 0 to 9 without spaces — the chessboard's description. Each square is described by one number — the number of peas in it. The first line corresponds to the uppermost row and the last line — to the lowest row. Output If it is impossible to reach the highest row having collected the number of peas divisible by k + 1, print -1. Otherwise, the first line must contain a single number — the maximal number of peas the pawn can collect given that the number must be divisible by k + 1. The second line must contain a single number — the number of the square's column in the lowest row, from which the pawn must start its journey. The columns are numbered from the left to the right with integral numbers starting from 1. The third line must contain a line consisting of n - 1 symbols — the description of the pawn's moves. If the pawn must move upwards and leftwards, print L, if it must move upwards and rightwards, print R. If there are several solutions to that problem, print any of them. Examples Input 3 3 1 123 456 789 Output 16 2 RL Input 3 3 0 123 456 789 Output 17 3 LR Input 2 2 10 98 75 Output -1 The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Little X has met the following problem recently. Let's define f(x) as the sum of digits in decimal representation of number x (for example, f(1234) = 1 + 2 + 3 + 4). You are to calculate <image> Of course Little X has solved this problem quickly, has locked it, and then has tried to hack others. He has seen the following C++ code: ans = solve(l, r) % a; if (ans <= 0) ans += a; This code will fail only on the test with <image>. You are given number a, help Little X to find a proper test for hack. Input The first line contains a single integer a (1 ≤ a ≤ 1018). Output Print two integers: l, r (1 ≤ l ≤ r < 10200) — the required test data. Leading zeros aren't allowed. It's guaranteed that the solution exists. Examples Input 46 Output 1 10 Input 126444381000032 Output 2333333 2333333333333 The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Polycarpus participates in a competition for hacking into a new secure messenger. He's almost won. Having carefully studied the interaction protocol, Polycarpus came to the conclusion that the secret key can be obtained if he properly cuts the public key of the application into two parts. The public key is a long integer which may consist of even a million digits! Polycarpus needs to find such a way to cut the public key into two nonempty parts, that the first (left) part is divisible by a as a separate number, and the second (right) part is divisible by b as a separate number. Both parts should be positive integers that have no leading zeros. Polycarpus knows values a and b. Help Polycarpus and find any suitable method to cut the public key. Input The first line of the input contains the public key of the messenger — an integer without leading zeroes, its length is in range from 1 to 106 digits. The second line contains a pair of space-separated positive integers a, b (1 ≤ a, b ≤ 108). Output In the first line print "YES" (without the quotes), if the method satisfying conditions above exists. In this case, next print two lines — the left and right parts after the cut. These two parts, being concatenated, must be exactly identical to the public key. The left part must be divisible by a, and the right part must be divisible by b. The two parts must be positive integers having no leading zeros. If there are several answers, print any of them. If there is no answer, print in a single line "NO" (without the quotes). Examples Input 116401024 97 1024 Output YES 11640 1024 Input 284254589153928171911281811000 1009 1000 Output YES 2842545891539 28171911281811000 Input 120 12 1 Output NO The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Watto, the owner of a spare parts store, has recently got an order for the mechanism that can process strings in a certain way. Initially the memory of the mechanism is filled with n strings. Then the mechanism should be able to process queries of the following type: "Given string s, determine if the memory of the mechanism contains string t that consists of the same number of characters as s and differs from s in exactly one position". Watto has already compiled the mechanism, all that's left is to write a program for it and check it on the data consisting of n initial lines and m queries. He decided to entrust this job to you. Input The first line contains two non-negative numbers n and m (0 ≤ n ≤ 3·105, 0 ≤ m ≤ 3·105) — the number of the initial strings and the number of queries, respectively. Next follow n non-empty strings that are uploaded to the memory of the mechanism. Next follow m non-empty strings that are the queries to the mechanism. The total length of lines in the input doesn't exceed 6·105. Each line consists only of letters 'a', 'b', 'c'. Output For each query print on a single line "YES" (without the quotes), if the memory of the mechanism contains the required string, otherwise print "NO" (without the quotes). Examples Input 2 3 aaaaa acacaca aabaa ccacacc caaac Output YES NO NO The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. The Bad Luck Island is inhabited by three kinds of species: r rocks, s scissors and p papers. At some moments of time two random individuals meet (all pairs of individuals can meet equiprobably), and if they belong to different species, then one individual kills the other one: a rock kills scissors, scissors kill paper, and paper kills a rock. Your task is to determine for each species what is the probability that this species will be the only one to inhabit this island after a long enough period of time. Input The single line contains three integers r, s and p (1 ≤ r, s, p ≤ 100) — the original number of individuals in the species of rock, scissors and paper, respectively. Output Print three space-separated real numbers: the probabilities, at which the rocks, the scissors and the paper will be the only surviving species, respectively. The answer will be considered correct if the relative or absolute error of each number doesn't exceed 10 - 9. Examples Input 2 2 2 Output 0.333333333333 0.333333333333 0.333333333333 Input 2 1 2 Output 0.150000000000 0.300000000000 0.550000000000 Input 1 1 3 Output 0.057142857143 0.657142857143 0.285714285714 The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.

Subsets and Splits

No community queries yet

The top public SQL queries from the community will appear here once available.