Split (1)

train · 24.3k rows

question large_stringlengths 265 13.2k
Solve the programming task below in a Python markdown code block. View Russian Translation In this problem the goal is to implement a program managing an elevator designed especially for mathematicians. The elevator can go to any of N floors numbered from 1 to N and it can carry an arbitrary number of people at one time. Initially the elevator is at floor 1, without any people inside, and it can go to any floor from 1 to N at any time. The total distance the elevator travels is defined as the sum of distances between the consecutive floors it went to in the whole process, and the distance between two floors F_1 and F_2 is defined as \|F_1 - F_2\|. In addition, there are Q events which are about to happen consecutively starting from now. There are two types of events to handle: entry(F, K) - K people are waiting to enter the elevator at floor F exit(F, K) - K people are waiting to exit the elevator at floor F The elevator must handle events in the order they come, and must handle only the events which are possible. An entry event entry(F, K) is possible if and only if X = F + K is a prime number. An exit event exit(F, K) is possible if and only if X = F + K has odd number of divisors. If the elevator being currently on floor F_1 has to handle an event taking place on floor F_2, it must first go from floor F_1 to floor F_2 moving up and/or down in any possible way, and it can handle the event only while it is at floor F_2. The task in this problem is to print the minimum distance that the elevator has to travel to handle all possible events in the order they come and the number of people inside the elevator after handling the last possible event. Since the total distance can be very large, output it modulo 10^9 + 7. Constraints: 1 ≤q N ≤q 10^{12} 1 ≤q Q ≤q 10^5 1 ≤q F ≤q N 1 ≤q K ≤q 10^6 for an exit event exit(F, K), parameter K is not greater than the number of people in the elevator just before that event Input format: In the first line there are two integers N and Q denoting the number of floors and the number of events. In the following Q lines the descriptions of Q events in the order they come are given. Each single event is given by 3 space separated integers T, F, K, where T is either 1 or 2 and denotes the type of the event (1 stands for an entry event, 2 stands for an exit event), F denotes the number of floor where this event has to be handled if it is a possible event, and K denotes the number of people in this event. Output format: In a single line output two space separated integers D, K denoting the minimum total distance the elevator travels to handle all possible events taken modulo 10^9 + 7, and the number of people in the elevator after the last handled event. SAMPLE INPUT 10 2 1 2 3 2 6 2 SAMPLE OUTPUT 1 3 Explanation Initially the elevator is at floor 1 with no people inside. The first event is an entry event at floor 2 with 3 people wanting to enter the elevator. Is is a possible event, because 2 + 3 = 5 is a prime number, so the elevator must go to the 2nd floor to handle this event. However, the second event is not possible, because it is an exit event and 6 + 2 = 8 has 4 divisors, which is an even number. Finally, the elevator must handle only the first event, and the minimal distance it need to cover to do that is 1 and the number of people after handling this event inside the elevator is 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. Nandu is stuck in a maze consisting of N rooms. Each room with room number x has a door leading into room number 2x (if 2x ≤ N) and another door leading into room number 2x+1 (if 2x+1 ≤ N). All these doors are 2-way doors ie. they can be opened from both the sides. Some of these N rooms have monsters living in them. Nandu is currently in room number i . Nandu's only escape from this maze is to somehow reach room number j which contains the magical Wish-Granting Well. The Well will only grant a wish to Nandu if he offers it a single golden coin. Nandu presently has only a single golden coin in his possession. However, if while going from room number i to j he meets a monster, the monster will take away the only golden coin Nandu has and Nandu will never be able to escape from the maze. You will be given information about every room telling you whether a monster resides in it or not. You will then be given Q scenarios, each scenario describing the locations i (the room currently Nandu is present in) and j (the room where the wishing well is present), i and j will vary over different scenarios but the locations of the monsters will remain fixed for all these scenarios. For each of these scenarios, you have to find out whether Nandu can escape from the maze or not. Input : The first line consists on N and Q denoting the number of rooms in the maze and the number of different scenarios that will be given to you. The next line consists of N non-space separated integers such that if the kth integer is '0' , there is no monster present in room number k and if the kth integer is '1' , there is a monster present in room number k. The next Q lines are such that each line consists of two space separated integers i and j denoting Nandu's current location and the location of the Wishing Well for this particular scenario respectively. Output : For every scenario print on a new line 'Yes' if Nandu can escape from the maze and 'No' if he cannot escape from the maze. (Quotes for clarity). Constraints : 1 ≤ N ≤ 100000 1 ≤ Q ≤ 100000 1 ≤ i,j ≤ N Author : Shreyans Tester : Sayan (By IIT Kgp HackerEarth Programming Club) SAMPLE INPUT 3 9 001 1 2 1 3 3 2 2 1 2 3 3 1 1 1 2 2 3 3 SAMPLE OUTPUT Yes No No Yes No No Yes Yes No Explanation A monster is present only in room number 3. Scenario 1 : Nandu is initially present in room number 1 and the Wish-Granting Well is present in room number 2 . Since there is no monster in either of the rooms Nandu goes from 1 -> 2 without losing his golden coin. Hence Nandu can escape the maze by making a wish to the Wish-Granting Well Scenario 2 : Nandu goes from 1 -> 3. However, there is a monster present in room number 3, which takes away his only golden coin before he can make a wish to the Wish-Granting Well. Hence Nandu cannot escape the maze. 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. Shantam is very rich , even richer than Richie Rich. He is extremely talented in almost everything except one , mathematics. So one day, he pays a visit to a temple (to pray for his upcoming mathematics exams) and decides to donate some amount of money to the poor people ( everyone is poor on a relative scale to Shantam). He order N people to sit in a linear arrangement and indexes them from 1 to N , to ease the process of donating money. As with all rich people , their way of doing things is completely eerie and different. Shantam donates his money in M steps , each of his step being to choose two indices L and R , and an amount of money C and then he donates C currencies to each and every person whose index lies in [L,R]. In other words he donates C currencies to every index i such L ≤ i ≤ R. Luckily, you too were among the N people selected and somehow you know all the M steps in advance. Figure out the maximum amount of money you can obtain and at what position you should sit to get this maximum amount of money. If multiple positions guarantee the maximum amount of money , output the minimum index out of all these possibilities. You will be given initial L , R and C (which points to first query) as well as P , Q and S. Each subsequent query is generated as : L[i] = (L[i-1] * P + R[i-1]) % N + 1; R[i] = (R[i-1] * Q + L[i-1]) % N + 1; if(L[i] > R[i]) swap(L[i] , R[i]); C[i] = (C[i-1] * S) % 1000000 + 1; Input Format : The first line contains T , the number of test cases. The first line of each test case contains two space separated integers N and M , which denotes the number of people and the number of steps, respectively. The next line contains integers L , R , C , P , Q and S , which are used to generate the queries using the method specified above. Output Format : For each test case , output one line containing two space separated integers, the first being the optimal position and the second being the highest amount of money that can be obtained. Constraints : 1 ≤ T ≤ 200 1 ≤ N ≤ 10^5 1 ≤ M ≤ 10^5 1 ≤ L ≤ R ≤ N 1 ≤ C ≤ 10^6 1 ≤ P,Q,S ≤ 10^4 SAMPLE INPUT 2 5 2 1 1 1 1 1 1 5 1 1 3 2 4 3 5 SAMPLE OUTPUT 3 2 1 2 Explanation Sample Case 2 : Initially all have 0 money, and can be represented as [ 0 , 0 , 0 , 0 , 0]. After first update , [2, 2, 2, 0, 0] The maximum amount is 2 and the minimum position with this maximum amount 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. Xenny was a teacher and his class consisted of N boys and N girls. He took all his students to the playground and asked them to stand in a straight line. The boys and the girls formed a perfect line, but Xenny seemed unhappy. He wanted them to form an alternating sequence of boys and girls, i.e., he wanted that after a boy, there should be a girl in the line, and vice-versa. In order to form an alternating sequence, a boy and a girl could swap their positions. Given the original sequence in which the boys and girls were standing, find the minimum number of swaps required to form an alternating sequence. Note: An alternating sequence can start either with a boy or a girl. Input First line of input consists of a natural number T - the number of testcases. T testcases follow. For each testcase: First line consists of a single integer N - the number of boys, and the number of girls. Second line consists of a string of length 2N, representing the original sequence. In this string, a boy is represented by uppercase character B and a girl by G. Output For each testcase, print the minimum number of swaps required to get an alternating sequence on a new line. Constraints 1 ≤ T ≤ 5 1 ≤ N ≤ 10^6 SAMPLE INPUT 1 2 BBGG SAMPLE OUTPUT 1 Explanation The first boy from left can swap his position with the first girl from right to get the sequence: GBGB This is an alternating sequence and it was obtained using 1 swap. 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. We have N voting papers. The i-th vote (1 \leq i \leq N) has the string S_i written on it. Print all strings that are written on the most number of votes, in lexicographical order. Constraints * 1 \leq N \leq 2 \times 10^5 * S_i (1 \leq i \leq N) are strings consisting of lowercase English letters. * The length of S_i (1 \leq i \leq N) is between 1 and 10 (inclusive). Input Input is given from Standard Input in the following format: N S_1 : S_N Output Print all strings in question in lexicographical order. Examples Input 7 beat vet beet bed vet bet beet Output beet vet Input 8 buffalo buffalo buffalo buffalo buffalo buffalo buffalo buffalo Output buffalo Input 7 bass bass kick kick bass kick kick Output kick Input 4 ushi tapu nichia kun Output kun nichia tapu ushi 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 a tower which is divided into N layers. Initially, all the layers are uncolored. Takahashi is going to paint some of the layers in red, green or blue to make a beautiful tower. He defines the beauty of the tower as follows: * The beauty of the tower is the sum of the scores of the N layers, where the score of a layer is A if the layer is painted red, A+B if the layer is painted green, B if the layer is painted blue, and 0 if the layer is uncolored. Here, A and B are positive integer constants given beforehand. Also note that a layer may not be painted in two or more colors. Takahashi is planning to paint the tower so that the beauty of the tower becomes exactly K. How many such ways are there to paint the tower? Find the count modulo 998244353. Two ways to paint the tower are considered different when there exists a layer that is painted in different colors, or a layer that is painted in some color in one of the ways and not in the other. Constraints * 1 ≤ N ≤ 3×10^5 * 1 ≤ A,B ≤ 3×10^5 * 0 ≤ K ≤ 18×10^{10} * All values in the input are integers. Input Input is given from Standard Input in the following format: N A B K Output Print the number of the ways to paint tiles, modulo 998244353. Examples Input 4 1 2 5 Output 40 Input 2 5 6 0 Output 1 Input 90081 33447 90629 6391049189 Output 577742975 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. Tic-tac-toe is a game in which you win when you put ○ and × alternately in the 3 × 3 squares and line up ○ or × in one of the vertical, horizontal, and diagonal lines (Fig.). 1 to Fig. 3) <image> \| <image> \| <image> --- \| --- \| --- Figure 1: ○ wins \| Figure 2: × wins \| Figure 3: Draw In tic-tac-toe, ○ and × alternately fill the squares, and the game ends when either one is lined up. Therefore, as shown in Fig. 4, it is impossible for both ○ and × to be aligned. No improbable aspect is entered. <image> --- Figure 4: Impossible phase Please create a program that reads the board of tic-tac-toe and outputs the result of victory or defeat. Input The input consists of multiple datasets. For each data set, one character string representing the board is given on one line. The character strings on the board are represented by o, x, and s in half-width lowercase letters for ○, ×, and blanks, respectively, and are arranged in the order of the squares in the figure below. <image> The number of datasets does not exceed 50. Output For each data set, output o in half-width lowercase letters if ○ wins, x in lowercase half-width letters if × wins, and d in lowercase half-width letters if it is a draw. Example Input ooosxssxs xoosxsosx ooxxxooxo Output o x d 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. Artist Shinagawa was asked to exhibit n works. Therefore, I decided to exhibit the six sides of the cube colored with paint as a work. The work uses all six colors, Red, Yellow, Blue, Magenta, Green, and Cyan, and each side is filled with one color. Shinagawa changed the arrangement of colors even for cubic works with the same shape, and created n points as different works. <image> As a friend of mine, you, a friend of mine, allowed you to browse the work before exhibiting, and noticed that it was there. Even though they seemed to be colored differently, there were actually cubes with the same color combination. At this rate, it will not be possible to exhibit n works. Please create a program that inputs the number of created works and the color information of each work and outputs how many more points you need to exhibit. The color of each side of the cube is represented by the symbols from c1 to c6, and the arrangement is as follows. Also, each of c1 to c6 is one of Red, Yellow, Blue, Magenta, Green, and Cyan. <image> Input A sequence of multiple datasets is given as input. The end of the input is indicated by a single line of zeros. Each dataset is given in the following format: n cube1 cube2 :: cuben The first line gives the number of works n (1 ≤ n ≤ 30), and the following n lines give information on the i-th work. Information on each work is given in the following format. c1 c2 c3 c4 c5 c6 The color arrangement ci of the work is given, separated by blanks. The number of datasets does not exceed 100. Output For each dataset, output how many more works are needed to exhibit in one line. Example Input 3 Cyan Yellow Red Magenta Green Blue Cyan Yellow Red Magenta Green Blue Red Yellow Magenta Blue Green Cyan 4 Red Magenta Blue Green Yellow Cyan Red Yellow Magenta Blue Green Cyan Magenta Green Red Cyan Yellow Blue Cyan Green Yellow Blue Magenta Red 0 Output 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. Alice and Brown are brothers in a family and each receives pocket money in celebration of the coming year. They are very close and share the total amount of the money fifty-fifty. The pocket money each receives is a multiple of 1,000 yen. Write a program to calculate each one’s share given the amount of money Alice and Brown received. Input The input is given in the following format. a b A line of data is given that contains two values of money: a (1000 ≤ a ≤ 50000) for Alice and b (1000 ≤ b ≤ 50000) for Brown. Output Output the amount of money each of Alice and Brown receive in a line. Examples Input 1000 3000 Output 2000 Input 5000 5000 Output 5000 Input 1000 2000 Output 1500 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 the Kingdom of IOI, the wind always blows from sea to land. There are $N + 1$ spots numbered from $0$ to $N$. The wind from Spot $0$ to Spot $N$ in order. Mr. JOI has a house at Spot $N$. The altitude of Spot $0$ is $A_0 = 0$, and the altitude of Spot $i$ ($1 \leq i \leq N$) is $A_i$. The wind blows on the surface of the ground. The temperature of the wind changes according to the change of the altitude. The temperature of the wind at Spot $0$, which is closest to the sea, is $0$ degree. For each $i$ ($0 \leq i \leq N - 1$), the change of the temperature of the wind from Spot $i$ to Spot $i + 1$ depends only on the values of $A_i$ and $A_{i+1}$ in the following way: * If $A_i < A_{i+1}$, the temperature of the wind decreases by $S$ degrees per altitude. * If $A_i \geq A_{i+1}$, the temperature of the wind increases by $T$ degrees per altitude. The tectonic movement is active in the land of the Kingdom of IOI. You have the data of tectonic movements for $Q$ days. In the $j$-th ($1 \leq j \leq Q$) day, the change of the altitude of Spot $k$ for $L_j \leq k \leq R_j$ ($1 \leq L_j \leq R_j \leq N$) is described by $X_j$. If $X_j$ is not negative, the altitude increases by $X_j$. If $X_j$ is negative, the altitude decreases by $\|X_j\|$. Your task is to calculate the temperature of the wind at the house of Mr. JOI after each tectonic movement. Task Given the data of tectonic movements, write a program which calculates, for each $j$ ($1 \leq j \leq Q$), the temperature of the wind at the house of Mr. JOI after the tectonic movement on the $j$-th day. Input Read the following data from the standard input. * The first line of input contains four space separated integers $N$, $Q$, $S$, $T$. This means there is a house of Mr. JOI at Spot $N$, there are $Q$ tectonic movements, the temperature of the wind decreases by $S$ degrees per altitude if the altitude increases, and the temperature of the wind increases by $T$ degrees per altitude if the altitude decreases. * The $i$-th line ($1 \leq i \leq N +1$) of the following $N +1$ lines contains an integer $A_{i-1}$, which is the initial altitude at Spot ($i - 1$) before tectonic movements. * The $j$-th line ($1 \leq j \leq Q$) of the following $Q$ lines contains three space separated integers $L_j$, $R_j$, $X_j$. This means, for the tectonic movement on the $j$-th day, the change of the altitude at the spots from $L_j$ to $R_j$ is described by $X_j$. Output Write $Q$ lines to the standard output. The $j$-th line ($1 \leq j \leq Q$) of output contains the temperature of the wind at the house of Mr. JOI after the tectonic movement on the $j$-th day. Constraints All input data satisfy the following conditions. * $1 \leq N \leq 200 000．$ * $1 \leq Q \leq 200 000．$ * $1 \leq S \leq 1 000 000．$ * $1 \leq T \leq 1 000 000．$ * $A_0 = 0．$ * $-1 000 000 \leq A_i \leq 1 000 000 (1 \leq i \leq N)．$ * $1 \leq L_j \leq R_j \leq N (1 \leq j \leq Q)．$ * $ -1 000 000 \leq X_j \leq 1 000 000 (1 \leq j \leq Q)．$ Sample Input and Output Sample Input 1 3 5 1 2 0 4 1 8 1 2 2 1 1 -2 2 3 5 1 2 -1 1 3 5 Sample Output 1 -5 -7 -13 -13 -18 Initially, the altitudes of the Spot 0, 1, 2, 3 are 0, 4, 1, 8, respectively. After the tectonic movement on the first day, the altitudes become 0, 6, 3, 8, respectively. At that moment, the temperatures of the wind are 0, -6, 0, -5,respectively. Sample Input 2 2 2 5 5 0 6 -1 1 1 4 1 2 8 Sample Output 2 5 -35 Sample Input 3 7 8 8 13 0 4 -9 4 -2 3 10 -9 1 4 8 3 5 -2 3 3 9 1 7 4 3 5 -1 5 6 3 4 4 9 6 7 -10 Sample output 3 277 277 322 290 290 290 290 370 Creatie Commons License The 16th Japanese Olympiad in Informatics (JOI 2016/2017) Final Round Example Input 3 5 1 2 0 4 1 8 1 2 2 1 1 -2 2 3 5 1 2 -1 1 3 5 Output -5 -7 -13 -13 -18 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 fraction whose numerator is 1 and whose denominator is a positive integer is called a unit fraction. A representation of a positive rational number p/q as the sum of finitely many unit fractions is called a partition of p/q into unit fractions. For example, 1/2 + 1/6 is a partition of 2/3 into unit fractions. The difference in the order of addition is disregarded. For example, we do not distinguish 1/6 + 1/2 from 1/2 + 1/6. For given four positive integers p, q, a, and n, count the number of partitions of p/q into unit fractions satisfying the following two conditions. * The partition is the sum of at most n many unit fractions. * The product of the denominators of the unit fractions in the partition is less than or equal to a. For example, if (p,q,a,n) = (2,3,120,3), you should report 4 since 2/3 = 1/3 + 1/3 = 1/2 + 1/6 = 1/4 + 1/4 + 1/6 = 1/3 + 1/6 + 1/6 enumerates all of the valid partitions. Input The input is a sequence of at most 1000 data sets followed by a terminator. A data set is a line containing four positive integers p, q, a, and n satisfying p,q <= 800, a <= 12000 and n <= 7. The integers are separated by a space. The terminator is composed of just one line which contains four zeros separated by a space. It is not a part of the input data but a mark for the end of the input. Output The output should be composed of lines each of which contains a single integer. No other characters should appear in the output. The output integer corresponding to a data set p, q, a, n should be the number of all partitions of p/q into at most n many unit fractions such that the product of the denominators of the unit fractions is less than or equal to a. Example Input 2 3 120 3 2 3 300 3 2 3 299 3 2 3 12 3 2 3 12000 7 54 795 12000 7 2 3 300 1 2 1 200 5 2 4 54 2 0 0 0 0 Output 4 7 6 2 42 1 0 9 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. Reordering the Documents Susan is good at arranging her dining table for convenience, but not her office desk. Susan has just finished the paperwork on a set of documents, which are still piled on her desk. They have serial numbers and were stacked in order when her boss brought them in. The ordering, however, is not perfect now, as she has been too lazy to put the documents slid out of the pile back to their proper positions. Hearing that she has finished, the boss wants her to return the documents immediately in the document box he is sending her. The documents should be stowed in the box, of course, in the order of their serial numbers. The desk has room just enough for two more document piles where Susan plans to make two temporary piles. All the documents in the current pile are to be moved one by one from the top to either of the two temporary piles. As making these piles too tall in haste would make them tumble, not too many documents should be placed on them. After moving all the documents to the temporary piles and receiving the document box, documents in the two piles will be moved from their tops, one by one, into the box. Documents should be in reverse order of their serial numbers in the two piles to allow moving them to the box in order. For example, assume that the pile has six documents #1, #3, #4, #2, #6, and #5, in this order from the top, and that the temporary piles can have no more than three documents. Then, she can form two temporary piles, one with documents #6, #4, and #3, from the top, and the other with #5, #2, and #1 (Figure E.1). Both of the temporary piles are reversely ordered. Then, comparing the serial numbers of documents on top of the two temporary piles, one with the larger number (#6, in this case) is to be removed and stowed into the document box first. Repeating this, all the documents will be perfectly ordered in the document box. <image> Figure E.1. Making two temporary piles Susan is wondering whether the plan is actually feasible with the documents in the current pile and, if so, how many different ways of stacking them to two temporary piles would do. You are asked to help Susan by writing a program to compute the number of different ways, which should be zero if the plan is not feasible. As each of the documents in the pile can be moved to either of the two temporary piles, for $n$ documents, there are $2^n$ different choice combinations in total, but some of them may disturb the reverse order of the temporary piles and are thus inappropriate. The example described above corresponds to the first case of the sample input. In this case, the last two documents, #5 and #6, can be swapped their destinations. Also, exchanging the roles of two temporary piles totally will be OK. As any other move sequences would make one of the piles higher than three and/or make them out of order, the total number of different ways of stacking documents to temporary piles in this example is $2 \times 2 = 4$. Input The input consists of a single test case of the following format. $n$ $m$ $s_1$ ... $s_n$ Here, $n$ is the number of documents in the pile ($1 \leq n \leq 5000$), and $m$ is the number of documents that can be stacked in one temporary pile without committing risks of making it tumble down ($n/2 \leq m \leq n$). Numbers $s_1$ through $s_n$ are the serial numbers of the documents in the document pile, from its top to its bottom. It is guaranteed that all the numbers $1$ through $n$ appear exactly once. Output Output a single integer in a line which is the number of ways to form two temporary piles suited for the objective. When no choice will do, the number of ways is $0$, of course. If the number of possible ways is greater than or equal to $10^9 + 7$, output the number of ways modulo $10^9 + 7$. Sample Input 1 6 3 1 3 4 2 6 5 Sample Output 1 4 Sample Input 2 6 6 1 3 4 2 6 5 Sample Output 2 8 Sample Input 3 4 4 4 3 1 2 Sample Output 3 0 Example Input 6 3 1 3 4 2 6 5 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. Expression Mining Consider an arithmetic expression built by combining single-digit positive integers with addition symbols `+`, multiplication symbols ``, and parentheses `(` `)`, defined by the following grammar rules with the start symbol `E`. E ::= T \| E '+' T T ::= F \| T '' F F ::= '1' \| '2' \| '3' \| '4' \| '5' \| '6' \| '7' \| '8' \| '9' \| '(' E ')' When such an arithmetic expression is viewed as a string, its substring, that is, a contiguous sequence of characters within the string, may again form an arithmetic expression. Given an integer n and a string s representing an arithmetic expression, let us count the number of its substrings that can be read as arithmetic expressions with values computed equal to n. Input The input consists of multiple datasets, each in the following format. > n > s > A dataset consists of two lines. In the first line, the target value n is given. n is an integer satisfying 1 ≤ n ≤ 109. The string s given in the second line is an arithmetic expression conforming to the grammar defined above. The length of s does not exceed 2×106. The nesting depth of the parentheses in the string is at most 1000. The end of the input is indicated by a line containing a single zero. The sum of the lengths of s in all the datasets does not exceed 5×106. Output For each dataset, output in one line the number of substrings of s that conform to the above grammar and have the value n. The same sequence of characters appearing at different positions should be counted separately. Sample Input 3 (1+2)3+3 2 111+111 587 1(234)+5+((6+78))(9) 0 Output for the Sample Input 4 9 2 Example Input 3 (1+2)3+3 2 111+111 587 1(234)+5+((6+78))(9) 0 Output 4 9 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. 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 increase creativity by drawing pictures. Let's draw a pattern well using a square stamp. I want to use stamps of various sizes to complete the picture of the red, green, and blue streets specified on the 4 x 4 squared paper. The stamp is rectangular and is used to fit the squares. The height and width of the stamp cannot be swapped. The paper is initially uncolored. When you stamp on paper, the stamped part changes to the color of the stamp, and the color hidden underneath becomes completely invisible. Since the color of the stamp is determined by the ink to be applied, it is possible to choose the color of any stamp. The stamp can be stamped with a part protruding from the paper, and the protruding part is ignored. It is possible to use one stamp multiple times. You may use the same stamp for different colors. Stamping is a rather nerve-wracking task, so I want to reduce the number of stamps as much as possible. Input N H1 W1 ... HN WN C1,1C1,2C1,3C1,4 C2,1C2,2C2,3C2,4 C3,1C3,2C3,3C3,4 C4,1C4,2C4,3C4,4 N is the number of stamps, and Hi and Wi (1 ≤ i ≤ N) are integers representing the vertical and horizontal lengths of the i-th stamp, respectively. Ci, j (1 ≤ i ≤ 4, 1 ≤ j ≤ 4) is a character that represents the color of the picture specified for the cells in the i-th row from the top and the j-th column from the left. Red is represented by `R`, green is represented by` G`, and blue is represented by `B`. Satisfy 1 ≤ N ≤ 16, 1 ≤ Hi ≤ 4, 1 ≤ Wi ≤ 4. The same set as (Hi, Wi) does not appear multiple times. Output Print the minimum number of stamps that must be stamped to complete the picture on a single line. Examples Input 2 4 4 1 1 RRRR RRGR RBRR RRRR Output 3 Input 1 2 3 RRGG BRGG BRRR BRRR 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. In the International City of Pipe Construction, it is planned to repair the water pipe at a certain point in the water pipe network. The network consists of water pipe segments, stop valves and source point. A water pipe is represented by a segment on a 2D-plane and intersected pair of water pipe segments are connected at the intersection point. A stop valve, which prevents from water flowing into the repairing point while repairing, is represented by a point on some water pipe segment. In the network, just one source point exists and water is supplied to the network from this point. Of course, while repairing, we have to stop water supply in some areas, but, in order to reduce the risk of riots, the length of water pipes stopping water supply must be minimized. What you have to do is to write a program to minimize the length of water pipes needed to stop water supply when the coordinates of end points of water pipe segments, stop valves, source point and repairing point are given. Input A data set has the following format: > N M > xs1 ys1 xd1 yd1 > ... > xsN ysN xdN ydN > xv1 yv1 > ... > xvM yvM > xb yb > xc yc > The first line of the input contains two integers, N (1 ≤ N ≤ 300) and M (0 ≤ M ≤ 1,000) that indicate the number of water pipe segments and stop valves. The following N lines describe the end points of water pipe segments. The i-th line contains four integers, xsi, ysi, xdi and ydi that indicate the pair of coordinates of end points of i-th water pipe segment. The following M lines describe the points of stop valves. The i-th line contains two integers, xvi and yvi that indicate the coordinate of end points of i-th stop valve. The following line contains two integers, xb and yb that indicate the coordinate of the source point. The last line contains two integers, xc and yc that indicate the coordinate of the repairing point. You may assume that any absolute values of coordinate integers are less than 1,000 (inclusive.) You may also assume each of the stop valves, the source point and the repairing point is always on one of water pipe segments and that that each pair among the stop valves, the source point and the repairing point are different. And, there is not more than one intersection between each pair of water pipe segments. Finally, the water pipe network is connected, that is, all the water pipes are received water supply initially. Output Print the minimal length of water pipes needed to stop water supply in a line. The absolute or relative error should be less than or 10-6. When you cannot stop water supply to the repairing point even though you close all stop valves, print "`-1`" in a line. Examples Input 1 2 0 0 10 0 1 0 9 0 0 0 5 0 Output 9.0 Input 5 3 0 4 2 4 0 2 2 2 0 0 2 0 0 0 0 4 2 0 2 4 0 2 1 0 2 2 1 4 2 1 Output 3.0 Input 2 1 0 0 0 4 0 2 2 2 1 2 0 1 0 3 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. In the Jambo Amusement Garden (JAG), you sell colorful drinks consisting of multiple color layers. This colorful drink can be made by pouring multiple colored liquids of different density from the bottom in order. You have already prepared several colored liquids with various colors and densities. You will receive a drink request with specified color layers. The colorful drink that you will serve must satisfy the following conditions. * You cannot use a mixed colored liquid as a layer. Thus, for instance, you cannot create a new liquid with a new color by mixing two or more different colored liquids, nor create a liquid with a density between two or more liquids with the same color by mixing them. * Only a colored liquid with strictly less density can be an upper layer of a denser colored liquid in a drink. That is, you can put a layer of a colored liquid with density $x$ directly above the layer of a colored liquid with density $y$ if $x < y$ holds. Your task is to create a program to determine whether a given request can be fulfilled with the prepared colored liquids under the above conditions or not. Input The input consists of a single test case in the format below. $N$ $C_1$ $D_1$ $\vdots$ $C_N$ $D_N$ $M$ $O_1$ $\vdots$ $O_M$ The first line consists of an integer $N$ ($1 \leq N \leq 10^5$), which represents the number of the prepared colored liquids. The following $N$ lines consists of $C_i$ and $D_i$ ($1 \leq i \leq N$). $C_i$ is a string consisting of lowercase alphabets and denotes the color of the $i$-th prepared colored liquid. The length of $C_i$ is between $1$ and $20$ inclusive. $D_i$ is an integer and represents the density of the $i$-th prepared colored liquid. The value of $D_i$ is between $1$ and $10^5$ inclusive. The ($N+2$)-nd line consists of an integer $M$ ($1 \leq M \leq 10^5$), which represents the number of color layers of a drink request. The following $M$ lines consists of $O_i$ ($1 \leq i \leq M$). $O_i$ is a string consisting of lowercase alphabets and denotes the color of the $i$-th layer from the top of the drink request. The length of $O_i$ is between $1$ and $20$ inclusive. Output If the requested colorful drink can be served by using some of the prepared colored liquids, print 'Yes'. Otherwise, print 'No'. Examples Input 2 white 20 black 10 2 black white Output Yes Input 2 white 10 black 10 2 black white Output No Input 2 white 20 black 10 2 black orange Output No Input 3 white 10 red 20 white 30 3 white red white Output Yes Input 4 red 3444 red 3018 red 3098 red 3319 4 red red red red 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. Priority queue is a container of elements which the element with the highest priority should be extracted first. For $n$ priority queues $Q_i$ ($i = 0, 1, ..., n-1$) of integers, perform a sequence of the following operations. * insert($t$, $x$): Insert $x$ to $Q_t$. * getMax($t$): Report the maximum value in $Q_t$. If $Q_t$ is empty, do nothing. * deleteMax($t$): Delete the maximum 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 insert, getMax and deleteMax operations respectively. Output For each getMax operation, print an integer in a line. Example Input 2 10 0 0 3 0 0 9 0 0 1 1 0 2 0 1 0 0 0 4 1 0 0 1 8 1 1 Output 9 3 4 8 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 Summer Informatics School, if a student doesn't behave well, teachers make a hole in his badge. And today one of the teachers caught a group of n students doing yet another trick. Let's assume that all these students are numbered from 1 to n. The teacher came to student a and put a hole in his badge. The student, however, claimed that the main culprit is some other student p_a. After that, the teacher came to student p_a and made a hole in his badge as well. The student in reply said that the main culprit was student p_{p_a}. This process went on for a while, but, since the number of students was finite, eventually the teacher came to the student, who already had a hole in his badge. After that, the teacher put a second hole in the student's badge and decided that he is done with this process, and went to the sauna. You don't know the first student who was caught by the teacher. However, you know all the numbers p_i. Your task is to find out for every student a, who would be the student with two holes in the badge if the first caught student was a. Input The first line of the input contains the only integer n (1 ≤ n ≤ 1000) — the number of the naughty students. The second line contains n integers p_1, ..., p_n (1 ≤ p_i ≤ n), where p_i indicates the student who was reported to the teacher by student i. Output For every student a from 1 to n print which student would receive two holes in the badge, if a was the first student caught by the teacher. Examples Input 3 2 3 2 Output 2 2 3 Input 3 1 2 3 Output 1 2 3 Note The picture corresponds to the first example test case. <image> When a = 1, the teacher comes to students 1, 2, 3, 2, in this order, and the student 2 is the one who receives a second hole in his badge. When a = 2, the teacher comes to students 2, 3, 2, and the student 2 gets a second hole in his badge. When a = 3, the teacher will visit students 3, 2, 3 with student 3 getting a second hole in his badge. For the second example test case it's clear that no matter with whom the teacher starts, that student would be the one who gets the second hole in his badge. 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. Zibi is a competitive programming coach. There are n competitors who want to be prepared well. The training contests are quite unusual – there are two people in a team, two problems, and each competitor will code exactly one of them. Of course, people in one team will code different problems. Rules of scoring also aren't typical. The first problem is always an implementation problem: you have to implement some well-known algorithm very fast and the time of your typing is rated. The second one is an awful geometry task and you just have to get it accepted in reasonable time. Here the length and difficulty of your code are important. After that, Zibi will give some penalty points (possibly negative) for each solution and the final score of the team is the sum of them (the less the score is, the better). We know that the i-th competitor will always have score x_i when he codes the first task and y_i when he codes the second task. We can assume, that all competitors know each other's skills and during the contest distribute the problems in the way that minimizes their final score. Remember that each person codes exactly one problem in a contest. Zibi wants all competitors to write a contest with each other. However, there are m pairs of people who really don't like to cooperate and they definitely won't write a contest together. Still, the coach is going to conduct trainings for all possible pairs of people, such that the people in pair don't hate each other. The coach is interested for each participant, what will be his or her sum of scores of all teams he trained in? Input The first line contains two integers n and m (2 ≤ n ≤ 300 000, 0 ≤ m ≤ 300 000) — the number of participants and the number of pairs of people who will not write a contest together. Each of the next n lines contains two integers x_i and y_i (-10^9 ≤ x_i, y_i ≤ 10^9) — the scores which will the i-th competitor get on the first problem and on the second problem. It is guaranteed that there are no two people having both x_i and y_i same. Each of the next m lines contain two integers u_i and v_i (1 ≤ u_i, v_i ≤ n, u_i ≠ v_i) — indices of people who don't want to write a contest in one team. Each unordered pair of indices will appear at most once. Output Output n integers — the sum of scores for all participants in the same order as they appear in the input. Examples Input 3 2 1 2 2 3 1 3 1 2 2 3 Output 3 0 3 Input 3 3 1 2 2 3 1 3 1 2 2 3 1 3 Output 0 0 0 Input 5 3 -1 3 2 4 1 1 3 5 2 2 1 4 2 3 3 5 Output 4 14 4 16 10 Note In the first example, there will be only one team consisting of persons 1 and 3. The optimal strategy for them is to assign the first task to the 3-rd person and the second task to the 1-st person, this will lead to score equal to 1 + 2 = 3. In the second example, nobody likes anyone, so there won't be any trainings. It seems that Zibi won't be titled coach in that case... 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 got a shelf and want to put some books on it. You are given q queries of three types: 1. L id — put a book having index id on the shelf to the left from the leftmost existing book; 2. R id — put a book having index id on the shelf to the right from the rightmost existing book; 3. ? id — calculate the minimum number of books you need to pop from the left or from the right in such a way that the book with index id will be leftmost or rightmost. You can assume that the first book you will put can have any position (it does not matter) and queries of type 3 are always valid (it is guaranteed that the book in each such query is already placed). You can also assume that you don't put the same book on the shelf twice, so ids don't repeat in queries of first two types. Your problem is to answer all the queries of type 3 in order they appear in the input. Note that after answering the query of type 3 all the books remain on the shelf and the relative order of books does not change. If you are Python programmer, consider using PyPy instead of Python when you submit your code. Input The first line of the input contains one integer q (1 ≤ q ≤ 2 ⋅ 10^5) — the number of queries. Then q lines follow. The i-th line contains the i-th query in format as in the problem statement. It is guaranteed that queries are always valid (for query type 3, it is guaranteed that the book in each such query is already placed, and for other types, it is guaranteed that the book was not placed before). It is guaranteed that there is at least one query of type 3 in the input. In each query the constraint 1 ≤ id ≤ 2 ⋅ 10^5 is met. Output Print answers to queries of the type 3 in order they appear in the input. Examples Input 8 L 1 R 2 R 3 ? 2 L 4 ? 1 L 5 ? 1 Output 1 1 2 Input 10 L 100 R 100000 R 123 L 101 ? 123 L 10 R 115 ? 100 R 110 ? 115 Output 0 2 1 Note Let's take a look at the first example and let's consider queries: 1. The shelf will look like [1]; 2. The shelf will look like [1, 2]; 3. The shelf will look like [1, 2, 3]; 4. The shelf looks like [1, 2, 3] so the answer is 1; 5. The shelf will look like [4, 1, 2, 3]; 6. The shelf looks like [4, 1, 2, 3] so the answer is 1; 7. The shelf will look like [5, 4, 1, 2, 3]; 8. The shelf looks like [5, 4, 1, 2, 3] so the answer is 2. Let's take a look at the second example and let's consider queries: 1. The shelf will look like [100]; 2. The shelf will look like [100, 100000]; 3. The shelf will look like [100, 100000, 123]; 4. The shelf will look like [101, 100, 100000, 123]; 5. The shelf looks like [101, 100, 100000, 123] so the answer is 0; 6. The shelf will look like [10, 101, 100, 100000, 123]; 7. The shelf will look like [10, 101, 100, 100000, 123, 115]; 8. The shelf looks like [10, 101, 100, 100000, 123, 115] so the answer is 2; 9. The shelf will look like [10, 101, 100, 100000, 123, 115, 110]; 10. The shelf looks like [10, 101, 100, 100000, 123, 115, 110] 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. You are given two segments [l_1; r_1] and [l_2; r_2] on the x-axis. It is guaranteed that l_1 < r_1 and l_2 < r_2. Segments may intersect, overlap or even coincide with each other. <image> The example of two segments on the x-axis. Your problem is to find two integers a and b such that l_1 ≤ a ≤ r_1, l_2 ≤ b ≤ r_2 and a ≠ b. In other words, you have to choose two distinct integer points in such a way that the first point belongs to the segment [l_1; r_1] and the second one belongs to the segment [l_2; r_2]. It is guaranteed that the answer exists. If there are multiple answers, you can print any of them. You have to answer q independent queries. Input The first line of the input contains one integer q (1 ≤ q ≤ 500) — the number of queries. Each of the next q lines contains four integers l_{1_i}, r_{1_i}, l_{2_i} and r_{2_i} (1 ≤ l_{1_i}, r_{1_i}, l_{2_i}, r_{2_i} ≤ 10^9, l_{1_i} < r_{1_i}, l_{2_i} < r_{2_i}) — the ends of the segments in the i-th query. Output Print 2q integers. For the i-th query print two integers a_i and b_i — such numbers that l_{1_i} ≤ a_i ≤ r_{1_i}, l_{2_i} ≤ b_i ≤ r_{2_i} and a_i ≠ b_i. Queries are numbered in order of the input. It is guaranteed that the answer exists. If there are multiple answers, you can print any. Example Input 5 1 2 1 2 2 6 3 4 2 4 1 3 1 2 1 3 1 4 5 8 Output 2 1 3 4 3 2 1 2 3 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. Recall that string a is a subsequence of a string b if a can be obtained from b by deletion of several (possibly zero or all) characters. For example, for the string a="wowwo", the following strings are subsequences: "wowwo", "wowo", "oo", "wow", "", and others, but the following are not subsequences: "owoo", "owwwo", "ooo". The wow factor of a string is the number of its subsequences equal to the word "wow". Bob wants to write a string that has a large wow factor. However, the "w" key on his keyboard is broken, so he types two "v"s instead. Little did he realise that he may have introduced more "w"s than he thought. Consider for instance the string "ww". Bob would type it as "vvvv", but this string actually contains three occurrences of "w": * "vvvv" * "vvvv" * "vvvv" For example, the wow factor of the word "vvvovvv" equals to four because there are four wows: * "vvvovvv" * "vvvovvv" * "vvvovvv" * "vvvovvv" Note that the subsequence "vvvovvv" does not count towards the wow factor, as the "v"s have to be consecutive. For a given string s, compute and output its wow factor. Note that it is not guaranteed that it is possible to get s from another string replacing "w" with "vv". For example, s can be equal to "vov". Input The input contains a single non-empty string s, consisting only of characters "v" and "o". The length of s is at most 10^6. Output Output a single integer, the wow factor of s. Examples Input vvvovvv Output 4 Input vvovooovovvovoovoovvvvovovvvov Output 100 Note The first example is explained in the legend. 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 only difference between easy and hard versions is the number of elements in the array. You are given an array a consisting of n integers. In one move you can choose any a_i and divide it by 2 rounding down (in other words, in one move you can set a_i := ⌊(a_i)/(2)⌋). You can perform such an operation any (possibly, zero) number of times with any a_i. Your task is to calculate the minimum possible number of operations required to obtain at least k equal numbers in the array. Don't forget that it is possible to have a_i = 0 after some operations, thus the answer always exists. Input The first line of the input contains two integers n and k (1 ≤ k ≤ n ≤ 50) — the number of elements in the array and the number of equal numbers required. The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 2 ⋅ 10^5), where a_i is the i-th element of a. Output Print one integer — the minimum possible number of operations required to obtain at least k equal numbers in the array. Examples Input 5 3 1 2 2 4 5 Output 1 Input 5 3 1 2 3 4 5 Output 2 Input 5 3 1 2 3 3 3 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. Alice is playing a game with her good friend, Marisa. There are n boxes arranged in a line, numbered with integers from 1 to n from left to right. Marisa will hide a doll in one of the boxes. Then Alice will have m chances to guess where the doll is. If Alice will correctly guess the number of box, where doll is now, she will win the game, otherwise, her friend will win the game. In order to win, Marisa will use some unfair tricks. After each time Alice guesses a box, she can move the doll to the neighboring box or just keep it at its place. Boxes i and i + 1 are neighboring for all 1 ≤ i ≤ n - 1. She can also use this trick once before the game starts. So, the game happens in this order: the game starts, Marisa makes the trick, Alice makes the first guess, Marisa makes the trick, Alice makes the second guess, Marisa makes the trick, …, Alice makes m-th guess, Marisa makes the trick, the game ends. Alice has come up with a sequence a_1, a_2, …, a_m. In the i-th guess, she will ask if the doll is in the box a_i. She wants to know the number of scenarios (x, y) (for all 1 ≤ x, y ≤ n), such that Marisa can win the game if she will put the doll at the x-th box at the beginning and at the end of the game, the doll will be at the y-th box. Help her and calculate this number. Input The first line contains two integers n and m, separated by space (1 ≤ n, m ≤ 10^5) — the number of boxes and the number of guesses, which Alice will make. The next line contains m integers a_1, a_2, …, a_m, separated by spaces (1 ≤ a_i ≤ n), the number a_i means the number of the box which Alice will guess in the i-th guess. Output Print the number of scenarios in a single line, or the number of pairs of boxes (x, y) (1 ≤ x, y ≤ n), such that if Marisa will put the doll into the box with number x, she can make tricks in such way, that at the end of the game the doll will be in the box with number y and she will win the game. Examples Input 3 3 2 2 2 Output 7 Input 5 2 3 1 Output 21 Note In the first example, the possible scenarios are (1, 1), (1, 2), (2, 1), (2, 2), (2, 3), (3, 2), (3, 3). Let's take (2, 2) as an example. The boxes, in which the doll will be during the game can be 2 → 3 → 3 → 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. Karlsson has recently discovered a huge stock of berry jam jars in the basement of the house. More specifically, there were 2n jars of strawberry and blueberry jam. All the 2n jars are arranged in a row. The stairs to the basement are exactly in the middle of that row. So when Karlsson enters the basement, he sees exactly n jars to his left and n jars to his right. For example, the basement might look like this: <image> Being the starightforward man he is, he immediately starts eating the jam. In one minute he chooses to empty either the first non-empty jar to his left or the first non-empty jar to his right. Finally, Karlsson decided that at the end the amount of full strawberry and blueberry jam jars should become the same. For example, this might be the result: <image> He has eaten 1 jar to his left and then 5 jars to his right. There remained exactly 3 full jars of both strawberry and blueberry jam. Jars are numbered from 1 to 2n from left to right, so Karlsson initially stands between jars n and n+1. What is the minimum number of jars Karlsson is required to empty so that an equal number of full strawberry and blueberry jam jars is left? Your program should answer t independent test cases. Input The first line contains one integer t (1 ≤ t ≤ 1000) — the number of test cases. The first line of each test case contains a single integer n (1 ≤ n ≤ 10^5). The second line of each test case contains 2n integers a_1, a_2, ..., a_{2n} (1 ≤ a_i ≤ 2) — a_i=1 means that the i-th jar from the left is a strawberry jam jar and a_i=2 means that it is a blueberry jam jar. 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 to it — the minimum number of jars Karlsson is required to empty so that an equal number of full strawberry and blueberry jam jars is left. Example Input 4 6 1 1 1 2 2 1 2 1 2 1 1 2 2 1 2 1 2 3 1 1 1 1 1 1 2 2 1 1 1 Output 6 0 6 2 Note The picture from the statement describes the first test case. In the second test case the number of strawberry and blueberry jam jars is already equal. In the third test case Karlsson is required to eat all 6 jars so that there remain 0 jars of both jams. In the fourth test case Karlsson can empty either the second and the third jars or the third and the fourth one. The both scenarios will leave 1 jar of both jams. 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 map of Bertown can be represented as a set of n intersections, numbered from 1 to n and connected by m one-way roads. It is possible to move along the roads from any intersection to any other intersection. The length of some path from one intersection to another is the number of roads that one has to traverse along the path. The shortest path from one intersection v to another intersection u is the path that starts in v, ends in u and has the minimum length among all such paths. Polycarp lives near the intersection s and works in a building near the intersection t. Every day he gets from s to t by car. Today he has chosen the following path to his workplace: p_1, p_2, ..., p_k, where p_1 = s, p_k = t, and all other elements of this sequence are the intermediate intersections, listed in the order Polycarp arrived at them. Polycarp never arrived at the same intersection twice, so all elements of this sequence are pairwise distinct. Note that you know Polycarp's path beforehand (it is fixed), and it is not necessarily one of the shortest paths from s to t. Polycarp's car has a complex navigation system installed in it. Let's describe how it works. When Polycarp starts his journey at the intersection s, the system chooses some shortest path from s to t and shows it to Polycarp. Let's denote the next intersection in the chosen path as v. If Polycarp chooses to drive along the road from s to v, then the navigator shows him the same shortest path (obviously, starting from v as soon as he arrives at this intersection). However, if Polycarp chooses to drive to another intersection w instead, the navigator rebuilds the path: as soon as Polycarp arrives at w, the navigation system chooses some shortest path from w to t and shows it to Polycarp. The same process continues until Polycarp arrives at t: if Polycarp moves along the road recommended by the system, it maintains the shortest path it has already built; but if Polycarp chooses some other path, the system rebuilds the path by the same rules. Here is an example. Suppose the map of Bertown looks as follows, and Polycarp drives along the path [1, 2, 3, 4] (s = 1, t = 4): Check the picture by the link [http://tk.codeforces.com/a.png](//tk.codeforces.com/a.png) 1. When Polycarp starts at 1, the system chooses some shortest path from 1 to 4. There is only one such path, it is [1, 5, 4]; 2. Polycarp chooses to drive to 2, which is not along the path chosen by the system. When Polycarp arrives at 2, the navigator rebuilds the path by choosing some shortest path from 2 to 4, for example, [2, 6, 4] (note that it could choose [2, 3, 4]); 3. Polycarp chooses to drive to 3, which is not along the path chosen by the system. When Polycarp arrives at 3, the navigator rebuilds the path by choosing the only shortest path from 3 to 4, which is [3, 4]; 4. Polycarp arrives at 4 along the road chosen by the navigator, so the system does not have to rebuild anything. Overall, we get 2 rebuilds in this scenario. Note that if the system chose [2, 3, 4] instead of [2, 6, 4] during the second step, there would be only 1 rebuild (since Polycarp goes along the path, so the system maintains the path [3, 4] during the third step). The example shows us that the number of rebuilds can differ even if the map of Bertown and the path chosen by Polycarp stays the same. Given this information (the map and Polycarp's path), can you determine the minimum and the maximum number of rebuilds that could have happened during the journey? Input The first line contains two integers n and m (2 ≤ n ≤ m ≤ 2 ⋅ 10^5) — the number of intersections and one-way roads in Bertown, respectively. Then m lines follow, each describing a road. Each line contains two integers u and v (1 ≤ u, v ≤ n, u ≠ v) denoting a road from intersection u to intersection v. All roads in Bertown are pairwise distinct, which means that each ordered pair (u, v) appears at most once in these m lines (but if there is a road (u, v), the road (v, u) can also appear). The following line contains one integer k (2 ≤ k ≤ n) — the number of intersections in Polycarp's path from home to his workplace. The last line contains k integers p_1, p_2, ..., p_k (1 ≤ p_i ≤ n, all these integers are pairwise distinct) — the intersections along Polycarp's path in the order he arrived at them. p_1 is the intersection where Polycarp lives (s = p_1), and p_k is the intersection where Polycarp's workplace is situated (t = p_k). It is guaranteed that for every i ∈ [1, k - 1] the road from p_i to p_{i + 1} exists, so the path goes along the roads of Bertown. Output Print two integers: the minimum and the maximum number of rebuilds that could have happened during the journey. Examples Input 6 9 1 5 5 4 1 2 2 3 3 4 4 1 2 6 6 4 4 2 4 1 2 3 4 Output 1 2 Input 7 7 1 2 2 3 3 4 4 5 5 6 6 7 7 1 7 1 2 3 4 5 6 7 Output 0 0 Input 8 13 8 7 8 6 7 5 7 4 6 5 6 4 5 3 5 2 4 3 4 2 3 1 2 1 1 8 5 8 7 5 2 1 Output 0 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. If the girl doesn't go to Denis, then Denis will go to the girl. Using this rule, the young man left home, bought flowers and went to Nastya. On the way from Denis's house to the girl's house is a road of n lines. This road can't be always crossed in one green light. Foreseeing this, the good mayor decided to place safety islands in some parts of the road. Each safety island is located after a line, as well as at the beginning and at the end of the road. Pedestrians can relax on them, gain strength and wait for a green light. Denis came to the edge of the road exactly at the moment when the green light turned on. The boy knows that the traffic light first lights up g seconds green, and then r seconds red, then again g seconds green and so on. Formally, the road can be represented as a segment [0, n]. Initially, Denis is at point 0. His task is to get to point n in the shortest possible time. He knows many different integers d_1, d_2, …, d_m, where 0 ≤ d_i ≤ n — are the coordinates of points, in which the safety islands are located. Only at one of these points, the boy can be at a time when the red light is on. Unfortunately, Denis isn't always able to control himself because of the excitement, so some restrictions are imposed: * He must always move while the green light is on because it's difficult to stand when so beautiful girl is waiting for you. Denis can change his position by ± 1 in 1 second. While doing so, he must always stay inside the segment [0, n]. * He can change his direction only on the safety islands (because it is safe). This means that if in the previous second the boy changed his position by +1 and he walked on a safety island, then he can change his position by ± 1. Otherwise, he can change his position only by +1. Similarly, if in the previous second he changed his position by -1, on a safety island he can change position by ± 1, and at any other point by -1. * At the moment when the red light is on, the boy must be on one of the safety islands. He can continue moving in any direction when the green light is on. Denis has crossed the road as soon as his coordinate becomes equal to n. This task was not so simple, because it's possible that it is impossible to cross the road. Since Denis has all thoughts about his love, he couldn't solve this problem and asked us to help him. Find the minimal possible time for which he can cross the road according to these rules, or find that it is impossible to do. Input The first line contains two integers n and m (1 ≤ n ≤ 10^6, 2 ≤ m ≤ min(n + 1, 10^4)) — road width and the number of safety islands. The second line contains m distinct integers d_1, d_2, …, d_m (0 ≤ d_i ≤ n) — the points where the safety islands are located. It is guaranteed that there are 0 and n among them. The third line contains two integers g, r (1 ≤ g, r ≤ 1000) — the time that the green light stays on and the time that the red light stays on. Output Output a single integer — the minimum time for which Denis can cross the road with obeying all the rules. If it is impossible to cross the road output -1. Examples Input 15 5 0 3 7 14 15 11 11 Output 45 Input 13 4 0 3 7 13 9 9 Output -1 Note In the first test, the optimal route is: * for the first green light, go to 7 and return to 3. In this case, we will change the direction of movement at the point 7, which is allowed, since there is a safety island at this point. In the end, we will be at the point of 3, where there is also a safety island. The next 11 seconds we have to wait for the red light. * for the second green light reaches 14. Wait for the red light again. * for 1 second go to 15. As a result, Denis is at the end of the road. In total, 45 seconds are obtained. In the second test, it is impossible to cross the road according to all the rules. 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 last contest held on Johnny's favorite competitive programming platform has been received rather positively. However, Johnny's rating has dropped again! He thinks that the presented tasks are lovely, but don't show the truth about competitors' skills. The boy is now looking at the ratings of consecutive participants written in a binary system. He thinks that the more such ratings differ, the more unfair is that such people are next to each other. He defines the difference between two numbers as the number of bit positions, where one number has zero, and another has one (we suppose that numbers are padded with leading zeros to the same length). For example, the difference of 5 = 101_2 and 14 = 1110_2 equals to 3, since 0101 and 1110 differ in 3 positions. Johnny defines the unfairness of the contest as the sum of such differences counted for neighboring participants. Johnny has just sent you the rating sequence and wants you to find the unfairness of the competition. You have noticed that you've got a sequence of consecutive integers from 0 to n. That's strange, but the boy stubbornly says that everything is right. So help him and find the desired unfairness for received numbers. Input The input consists of multiple test cases. The first line contains one integer t (1 ≤ t ≤ 10 000) — the number of test cases. The following t lines contain a description of test cases. The first and only line in each test case contains a single integer n (1 ≤ n ≤ 10^{18}). Output Output t lines. For each test case, you should output a single line with one integer — the unfairness of the contest if the rating sequence equals to 0, 1, ..., n - 1, n. Example Input 5 5 7 11 1 2000000000000 Output 8 11 19 1 3999999999987 Note For n = 5 we calculate unfairness of the following sequence (numbers from 0 to 5 written in binary with extra leading zeroes, so they all have the same length): * 000 * 001 * 010 * 011 * 100 * 101 The differences are equal to 1, 2, 1, 3, 1 respectively, so unfairness is equal to 1 + 2 + 1 + 3 + 1 = 8. 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. Mr. Chanek The Ninja is one day tasked with a mission to handle mad snakes that are attacking a site. Now, Mr. Chanek already arrived at the hills where the destination is right below these hills. The mission area can be divided into a grid of size 1000 × 1000 squares. There are N mad snakes on the site, the i'th mad snake is located on square (X_i, Y_i) and has a danger level B_i. Mr. Chanek is going to use the Shadow Clone Jutsu and Rasengan that he learned from Lord Seventh to complete this mission. His attack strategy is as follows: 1. Mr. Chanek is going to make M clones. 2. Each clone will choose a mad snake as the attack target. Each clone must pick a different mad snake to attack. 3. All clones jump off the hills and attack their respective chosen target at once with Rasengan of radius R. If the mad snake at square (X, Y) is attacked with a direct Rasengan, it and all mad snakes at squares (X', Y') where max(\|X' - X\|, \|Y' - Y\|) ≤ R will die. 4. The real Mr. Chanek will calculate the score of this attack. The score is defined as the square of the sum of the danger levels of all the killed snakes. Now Mr. Chanek is curious, what is the sum of scores for every possible attack strategy? Because this number can be huge, Mr. Chanek only needs the output modulo 10^9 + 7. Input The first line contains three integers N M R (1 ≤ M ≤ N ≤ 2 ⋅ 10^3, 0 ≤ R < 10^3), the number of mad snakes, the number of clones, and the radius of the Rasengan. The next N lines each contains three integers, X_i, Y_i, dan B_i (1 ≤ X_i, Y_i ≤ 10^3, 1 ≤ B_i ≤ 10^6). It is guaranteed that no two mad snakes occupy the same square. Output A line with an integer that denotes the sum of scores for every possible attack strategy. Example Input 4 2 1 1 1 10 2 2 20 2 3 30 5 2 40 Output 33800 Note Here is the illustration of all six possible attack strategies. The circles denote the chosen mad snakes, and the blue squares denote the region of the Rasengan: <image> So, the total score of all attacks is: 3.600 + 3.600 + 4.900 + 3.600 + 10.000 + 8.100 = 33.800. 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 rectangular grid with n rows and m columns. The cell located on the i-th row from the top and the j-th column from the left has a value a_{ij} written in it. You can perform the following operation any number of times (possibly zero): * Choose any two adjacent cells and multiply the values in them by -1. Two cells are called adjacent if they share a side. Note that you can use a cell more than once in different operations. You are interested in X, the sum of all the numbers in the grid. What is the maximum X you can achieve with these operations? Input Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 100). Description of the test cases follows. The first line of each test case contains two integers n,m (2 ≤ n, m ≤ 10). The following n lines contain m integers each, the j-th element in the i-th line is a_{ij} (-100≤ a_{ij}≤ 100). Output For each testcase, print one integer X, the maximum possible sum of all the values in the grid after applying the operation as many times as you want. Example Input 2 2 2 -1 1 1 1 3 4 0 -1 -2 -3 -1 -2 -3 -4 -2 -3 -4 -5 Output 2 30 Note In the first test case, there will always be at least one -1, so the answer is 2. In the second test case, we can use the operation six times to elements adjacent horizontally and get all numbers to be non-negative. So the answer is: 2× 1 + 3×2 + 3× 3 + 2× 4 + 1× 5 = 30. 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 the New Year, Polycarp decided to send postcards to all his n friends. He wants to make postcards with his own hands. For this purpose, he has a sheet of paper of size w × h, which can be cut into pieces. Polycarp can cut any sheet of paper w × h that he has in only two cases: * If w is even, then he can cut the sheet in half and get two sheets of size w/2 × h; * If h is even, then he can cut the sheet in half and get two sheets of size w × h/2; If w and h are even at the same time, then Polycarp can cut the sheet according to any of the rules above. After cutting a sheet of paper, the total number of sheets of paper is increased by 1. Help Polycarp to find out if he can cut his sheet of size w × h at into n or more pieces, using only the rules described above. Input The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow. Each test case consists of one line containing three integers w, h, n (1 ≤ w, h ≤ 10^4, 1 ≤ n ≤ 10^9) — the width and height of the sheet Polycarp has and the number of friends he needs to send a postcard to. Output For each test case, output on a separate line: * "YES", if it is possible to cut a sheet of size w × h into at least n pieces; * "NO" otherwise. You can output "YES" and "NO" in any case (for example, the strings yEs, yes, Yes and YES will be recognized as positive). Example Input 5 2 2 3 3 3 2 5 10 2 11 13 1 1 4 4 Output YES NO YES YES YES Note In the first test case, you can first cut the 2 × 2 sheet into two 2 × 1 sheets, and then cut each of them into two more sheets. As a result, we get four sheets 1 × 1. We can choose any three of them and send them to our friends. In the second test case, a 3 × 3 sheet cannot be cut, so it is impossible to get two sheets. In the third test case, you can cut a 5 × 10 sheet into two 5 × 5 sheets. In the fourth test case, there is no need to cut the sheet, since we only need one sheet. In the fifth test case, you can first cut the 1 × 4 sheet into two 1 × 2 sheets, and then cut each of them into two more sheets. As a result, we get four sheets 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. Gaurang has grown up in a mystical universe. He is faced by n consecutive 2D planes. He shoots a particle of decay age k at the planes. A particle can pass through a plane directly, however, every plane produces an identical copy of the particle going in the opposite direction with a decay age k-1. If a particle has decay age equal to 1, it will NOT produce a copy. For example, if there are two planes and a particle is shot with decay age 3 (towards the right), the process is as follows: (here, D(x) refers to a single particle with decay age x) 1. the first plane produces a D(2) to the left and lets D(3) continue on to the right; 2. the second plane produces a D(2) to the left and lets D(3) continue on to the right; 3. the first plane lets D(2) continue on to the left and produces a D(1) to the right; 4. the second plane lets D(1) continue on to the right (D(1) cannot produce any copies). In total, the final multiset S of particles is \\{D(3), D(2), D(2), D(1)\}. (See notes for visual explanation of this test case.) Gaurang is unable to cope up with the complexity of this situation when the number of planes is too large. Help Gaurang find the size of the multiset S, given n and k. Since the size of the multiset can be very large, you have to output it modulo 10^9+7. Note: Particles can go back and forth between the planes without colliding with each other. Input The first line of the input contains the number of test cases t (1 ≤ t ≤ 100). Then, t lines follow, each containing two integers n and k (1 ≤ n, k ≤ 1000). Additionally, the sum of n over all test cases will not exceed 1000, and the sum of k over all test cases will not exceed 1000. All test cases in one test are different. Output Output t integers. The i-th of them should be equal to the answer to the i-th test case. Examples Input 4 2 3 2 2 3 1 1 3 Output 4 3 1 2 Input 3 1 1 1 500 500 250 Output 1 2 257950823 Note Let us explain the first example with four test cases. Test case 1: (n = 2, k = 3) is already explained in the problem statement. See the below figure of this simulation. Each straight line with a different color represents the path of a different particle. As you can see, there are four distinct particles in the multiset. Note that the vertical spacing between reflected particles is for visual clarity only (as mentioned before, no two distinct particles collide with each other) <image> Test case 2: (n = 2, k = 2) is explained as follows: 1. the first plane produces a D(1) to the left and lets D(2) continue on to the right; 2. the second plane produces a D(1) to the left and lets D(2) continue on to the right; 3. the first plane lets D(1) continue on to the left (D(1) cannot produce any copies). Total size of multiset obtained \\{D(1), D(1), D(2)\} is equal to three. Test case 3: (n = 3, k = 1), there are three planes, but decay age is only one. So no new copies are produced while the one particle passes through the planes. Hence, the answer is one. Test case 4: (n = 1, k = 3) there is only one plane. The particle produces a new copy to the left. The multiset \\{D(2), D(3)\} is of size two. 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 a positive integer n ordinary if in the decimal notation all its digits are the same. For example, 1, 2 and 99 are ordinary numbers, but 719 and 2021 are not ordinary numbers. For a given number n, find the number of ordinary numbers among the numbers from 1 to n. Input The first line contains one integer t (1 ≤ t ≤ 10^4). Then t test cases follow. Each test case is characterized by one integer n (1 ≤ n ≤ 10^9). Output For each test case output the number of ordinary numbers among numbers from 1 to n. Example Input 6 1 2 3 4 5 100 Output 1 2 3 4 5 18 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 directed graph G which can contain loops (edges from a vertex to itself). Multi-edges are absent in G which means that for all ordered pairs (u, v) exists at most one edge from u to v. Vertices are numbered from 1 to n. A path from u to v is a sequence of edges such that: * vertex u is the start of the first edge in the path; * vertex v is the end of the last edge in the path; * for all pairs of adjacent edges next edge starts at the vertex that the previous edge ends on. We will assume that the empty sequence of edges is a path from u to u. For each vertex v output one of four values: * 0, if there are no paths from 1 to v; * 1, if there is only one path from 1 to v; * 2, if there is more than one path from 1 to v and the number of paths is finite; * -1, if the number of paths from 1 to v is infinite. Let's look at the example shown in the figure. <image> Then: * the answer for vertex 1 is 1: there is only one path from 1 to 1 (path with length 0); * the answer for vertex 2 is 0: there are no paths from 1 to 2; * the answer for vertex 3 is 1: there is only one path from 1 to 3 (it is the edge (1, 3)); * the answer for vertex 4 is 2: there are more than one paths from 1 to 4 and the number of paths are finite (two paths: [(1, 3), (3, 4)] and [(1, 4)]); * the answer for vertex 5 is -1: the number of paths from 1 to 5 is infinite (the loop can be used in a path many times); * the answer for vertex 6 is -1: the number of paths from 1 to 6 is infinite (the loop can be used in a path many times). Input The first contains an integer t (1 ≤ t ≤ 10^4) — the number of test cases in the input. Then t test cases follow. Before each test case, there is an empty line. The first line of the test case contains two integers n and m (1 ≤ n ≤ 4 ⋅ 10^5, 0 ≤ m ≤ 4 ⋅ 10^5) — numbers of vertices and edges in graph respectively. The next m lines contain edges descriptions. Each line contains two integers a_i, b_i (1 ≤ a_i, b_i ≤ n) — the start and the end of the i-th edge. The vertices of the graph are numbered from 1 to n. The given graph can contain loops (it is possible that a_i = b_i), but cannot contain multi-edges (it is not possible that a_i = a_j and b_i = b_j for i ≠ j). The sum of n over all test cases does not exceed 4 ⋅ 10^5. Similarly, the sum of m over all test cases does not exceed 4 ⋅ 10^5. Output Output t lines. The i-th line should contain an answer for the i-th test case: a sequence of n integers from -1 to 2. Example Input 5 6 7 1 4 1 3 3 4 4 5 2 1 5 5 5 6 1 0 3 3 1 2 2 3 3 1 5 0 4 4 1 2 2 3 1 4 4 3 Output 1 0 1 2 -1 -1 1 -1 -1 -1 1 0 0 0 0 1 1 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 problem describes the properties of a command line. The description somehow resembles the one you usually see in real operating systems. However, there are differences in the behavior. Please make sure you've read the statement attentively and use it as a formal document. In the Pindows operating system a strings are the lexemes of the command line — the first of them is understood as the name of the program to run and the following lexemes are its arguments. For example, as we execute the command " run.exe one, two . ", we give four lexemes to the Pindows command line: "run.exe", "one,", "two", ".". More formally, if we run a command that can be represented as string s (that has no quotes), then the command line lexemes are maximal by inclusion substrings of string s that contain no spaces. To send a string with spaces or an empty string as a command line lexeme, we can use double quotes. The block of characters that should be considered as one lexeme goes inside the quotes. Embedded quotes are prohibited — that is, for each occurrence of character """ we should be able to say clearly that the quotes are opening or closing. For example, as we run the command ""run.exe o" "" " ne, " two . " " ", we give six lexemes to the Pindows command line: "run.exe o", "" (an empty string), " ne, ", "two", ".", " " (a single space). It is guaranteed that each lexeme of the command line is either surrounded by spaces on both sides or touches the corresponding command border. One of its consequences is: the opening brackets are either the first character of the string or there is a space to the left of them. You have a string that consists of uppercase and lowercase English letters, digits, characters ".,?!"" and spaces. It is guaranteed that this string is a correct OS Pindows command line string. Print all lexemes of this command line string. Consider the character """ to be used only in order to denote a single block of characters into one command line lexeme. In particular, the consequence is that the given string has got an even number of such characters. Input The single line contains a non-empty string s. String s consists of at most 105 characters. Each character is either an uppercase or a lowercase English letter, or a digit, or one of the ".,?!"" signs, or a space. It is guaranteed that the given string is some correct command line string of the OS Pindows. It is guaranteed that the given command line string contains at least one lexeme. Output In the first line print the first lexeme, in the second line print the second one and so on. To make the output clearer, print the "<" (less) character to the left of your lexemes and the ">" (more) character to the right. Print the lexemes in the order in which they occur in the command. Please, follow the given output format strictly. For more clarifications on the output format see the test samples. Examples Input "RUn.exe O" "" " 2ne, " two! . " " Output <RUn.exe O> <> < 2ne, > <two!> <.> < > Input firstarg second "" Output <firstarg> <second> <> 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 boy Petya loves stairs very much. But he is bored from simple going up and down them — he loves jumping over several stairs at a time. As he stands on some stair, he can either jump to the next one or jump over one or two stairs at a time. But some stairs are too dirty and Petya doesn't want to step on them. Now Petya is on the first stair of the staircase, consisting of n stairs. He also knows the numbers of the dirty stairs of this staircase. Help Petya find out if he can jump through the entire staircase and reach the last stair number n without touching a dirty stair once. One has to note that anyway Petya should step on the first and last stairs, so if the first or the last stair is dirty, then Petya cannot choose a path with clean steps only. Input The first line contains two integers n and m (1 ≤ n ≤ 109, 0 ≤ m ≤ 3000) — the number of stairs in the staircase and the number of dirty stairs, correspondingly. The second line contains m different space-separated integers d1, d2, ..., dm (1 ≤ di ≤ n) — the numbers of the dirty stairs (in an arbitrary order). Output Print "YES" if Petya can reach stair number n, stepping only on the clean stairs. Otherwise print "NO". Examples Input 10 5 2 4 8 3 6 Output NO Input 10 5 2 4 5 7 9 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. Our bear's forest has a checkered field. The checkered field is an n × n table, the rows are numbered from 1 to n from top to bottom, the columns are numbered from 1 to n from left to right. Let's denote a cell of the field on the intersection of row x and column y by record (x, y). Each cell of the field contains growing raspberry, at that, the cell (x, y) of the field contains x + y raspberry bushes. The bear came out to walk across the field. At the beginning of the walk his speed is (dx, dy). Then the bear spends exactly t seconds on the field. Each second the following takes place: * Let's suppose that at the current moment the bear is in cell (x, y). * First the bear eats the raspberry from all the bushes he has in the current cell. After the bear eats the raspberry from k bushes, he increases each component of his speed by k. In other words, if before eating the k bushes of raspberry his speed was (dx, dy), then after eating the berry his speed equals (dx + k, dy + k). * Let's denote the current speed of the bear (dx, dy) (it was increased after the previous step). Then the bear moves from cell (x, y) to cell (((x + dx - 1) mod n) + 1, ((y + dy - 1) mod n) + 1). * Then one additional raspberry bush grows in each cell of the field. You task is to predict the bear's actions. Find the cell he ends up in if he starts from cell (sx, sy). Assume that each bush has infinitely much raspberry and the bear will never eat all of it. Input The first line of the input contains six space-separated integers: n, sx, sy, dx, dy, t (1 ≤ n ≤ 109; 1 ≤ sx, sy ≤ n; - 100 ≤ dx, dy ≤ 100; 0 ≤ t ≤ 1018). Output Print two integers — the coordinates of the cell the bear will end up in after t seconds. Examples Input 5 1 2 0 1 2 Output 3 1 Input 1 1 1 -1 -1 2 Output 1 1 Note Operation a mod b means taking the remainder after dividing a by b. Note that the result of the operation is always non-negative. For example, ( - 1) mod 3 = 2. In the first sample before the first move the speed vector will equal (3,4) and the bear will get to cell (4,1). Before the second move the speed vector will equal (9,10) and he bear will get to cell (3,1). Don't forget that at the second move, the number of berry bushes increased by 1. In the second sample before the first move the speed vector will equal (1,1) and the bear will get to cell (1,1). Before the second move, the speed vector will equal (4,4) and the bear will get to cell (1,1). Don't forget that at the second move, the number of berry bushes increased by 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. Fedya studies in a gymnasium. Fedya's maths hometask is to calculate the following expression: (1n + 2n + 3n + 4n) mod 5 for given value of n. Fedya managed to complete the task. Can you? Note that given number n can be extremely large (e.g. it can exceed any integer type of your programming language). Input The single line contains a single integer n (0 ≤ n ≤ 10105). The number doesn't contain any leading zeroes. Output Print the value of the expression without leading zeros. Examples Input 4 Output 4 Input 124356983594583453458888889 Output 0 Note Operation x mod y means taking remainder after division x by y. Note to the first sample: <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. Vanya has a table consisting of 100 rows, each row contains 100 cells. The rows are numbered by integers from 1 to 100 from bottom to top, the columns are numbered from 1 to 100 from left to right. In this table, Vanya chose n rectangles with sides that go along borders of squares (some rectangles probably occur multiple times). After that for each cell of the table he counted the number of rectangles it belongs to and wrote this number into it. Now he wants to find the sum of values in all cells of the table and as the table is too large, he asks you to help him find the result. Input The first line contains integer n (1 ≤ n ≤ 100) — the number of rectangles. Each of the following n lines contains four integers x1, y1, x2, y2 (1 ≤ x1 ≤ x2 ≤ 100, 1 ≤ y1 ≤ y2 ≤ 100), where x1 and y1 are the number of the column and row of the lower left cell and x2 and y2 are the number of the column and row of the upper right cell of a rectangle. Output In a single line print the sum of all values in the cells of the table. Examples Input 2 1 1 2 3 2 2 3 3 Output 10 Input 2 1 1 3 3 1 1 3 3 Output 18 Note Note to the first sample test: Values of the table in the first three rows and columns will be as follows: 121 121 110 So, the sum of values will be equal to 10. Note to the second sample test: Values of the table in the first three rows and columns will be as follows: 222 222 222 So, the sum of values will be equal to 18. 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 a lover of bacteria. You want to raise some bacteria in a box. Initially, the box is empty. Each morning, you can put any number of bacteria into the box. And each night, every bacterium in the box will split into two bacteria. You hope to see exactly x bacteria in the box at some moment. What is the minimum number of bacteria you need to put into the box across those days? Input The only line containing one integer x (1 ≤ x ≤ 109). Output The only line containing one integer: the answer. Examples Input 5 Output 2 Input 8 Output 1 Note For the first sample, we can add one bacterium in the box in the first day morning and at the third morning there will be 4 bacteria in the box. Now we put one more resulting 5 in the box. We added 2 bacteria in the process so the answer is 2. For the second sample, we can put one in the first morning and in the 4-th morning there will be 8 in the box. 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. Everyone knows that long ago on the territory of present-day Berland there lived Bindian tribes. Their capital was surrounded by n hills, forming a circle. On each hill there was a watchman, who watched the neighbourhood day and night. In case of any danger the watchman could make a fire on the hill. One watchman could see the signal of another watchman, if on the circle arc connecting the two hills there was no hill higher than any of the two. As for any two hills there are two different circle arcs connecting them, the signal was seen if the above mentioned condition was satisfied on at least one of the arcs. For example, for any two neighbouring watchmen it is true that the signal of one will be seen by the other. An important characteristics of this watch system was the amount of pairs of watchmen able to see each other's signals. You are to find this amount by the given heights of the hills. Input The first line of the input data contains an integer number n (3 ≤ n ≤ 106), n — the amount of hills around the capital. The second line contains n numbers — heights of the hills in clockwise order. All height numbers are integer and lie between 1 and 109. Output Print the required amount of pairs. Examples Input 5 1 2 4 5 3 Output 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. Recently Polycarp started to develop a text editor that works only with correct bracket sequences (abbreviated as CBS). Note that a bracket sequence is correct if it is possible to get a correct mathematical expression by adding "+"-s and "1"-s to it. For example, sequences "(())()", "()" and "(()(()))" are correct, while ")(", "(()" and "(()))(" are not. Each bracket in CBS has a pair. For example, in "(()(()))": * 1st bracket is paired with 8th, * 2d bracket is paired with 3d, * 3d bracket is paired with 2d, * 4th bracket is paired with 7th, * 5th bracket is paired with 6th, * 6th bracket is paired with 5th, * 7th bracket is paired with 4th, * 8th bracket is paired with 1st. Polycarp's editor currently supports only three operations during the use of CBS. The cursor in the editor takes the whole position of one of the brackets (not the position between the brackets!). There are three operations being supported: * «L» — move the cursor one position to the left, * «R» — move the cursor one position to the right, * «D» — delete the bracket in which the cursor is located, delete the bracket it's paired to and all brackets between them (that is, delete a substring between the bracket in which the cursor is located and the one it's paired to). After the operation "D" the cursor moves to the nearest bracket to the right (of course, among the non-deleted). If there is no such bracket (that is, the suffix of the CBS was deleted), then the cursor moves to the nearest bracket to the left (of course, among the non-deleted). There are pictures illustrated several usages of operation "D" below. <image> All incorrect operations (shift cursor over the end of CBS, delete the whole CBS, etc.) are not supported by Polycarp's editor. Polycarp is very proud of his development, can you implement the functionality of his editor? Input The first line contains three positive integers n, m and p (2 ≤ n ≤ 500 000, 1 ≤ m ≤ 500 000, 1 ≤ p ≤ n) — the number of brackets in the correct bracket sequence, the number of operations and the initial position of cursor. Positions in the sequence are numbered from left to right, starting from one. It is guaranteed that n is even. It is followed by the string of n characters "(" and ")" forming the correct bracket sequence. Then follow a string of m characters "L", "R" and "D" — a sequence of the operations. Operations are carried out one by one from the first to the last. It is guaranteed that the given operations never move the cursor outside the bracket sequence, as well as the fact that after all operations a bracket sequence will be non-empty. Output Print the correct bracket sequence, obtained as a result of applying all operations to the initial sequence. Examples Input 8 4 5 (())()() RDLD Output () Input 12 5 3 ((()())(())) RRDLD Output (()(())) Input 8 8 8 (())()() LLLLLLDD Output ()() Note In the first sample the cursor is initially at position 5. Consider actions of the editor: 1. command "R" — the cursor moves to the position 6 on the right; 2. command "D" — the deletion of brackets from the position 5 to the position 6. After that CBS takes the form (())(), the cursor is at the position 5; 3. command "L" — the cursor moves to the position 4 on the left; 4. command "D" — the deletion of brackets from the position 1 to the position 4. After that CBS takes the form (), the cursor is at the position 1. Thus, the answer is equal to (). 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. Barney lives in country USC (United States of Charzeh). USC has n cities numbered from 1 through n and n - 1 roads between them. Cities and roads of USC form a rooted tree (Barney's not sure why it is rooted). Root of the tree is the city number 1. Thus if one will start his journey from city 1, he can visit any city he wants by following roads. <image> Some girl has stolen Barney's heart, and Barney wants to find her. He starts looking for in the root of the tree and (since he is Barney Stinson not a random guy), he uses a random DFS to search in the cities. A pseudo code of this algorithm is as follows: let starting_time be an array of length n current_time = 0 dfs(v): current_time = current_time + 1 starting_time[v] = current_time shuffle children[v] randomly (each permutation with equal possibility) // children[v] is vector of children cities of city v for u in children[v]: dfs(u) As told before, Barney will start his journey in the root of the tree (equivalent to call dfs(1)). Now Barney needs to pack a backpack and so he wants to know more about his upcoming journey: for every city i, Barney wants to know the expected value of starting_time[i]. He's a friend of Jon Snow and knows nothing, that's why he asked for your help. Input The first line of input contains a single integer n (1 ≤ n ≤ 105) — the number of cities in USC. The second line contains n - 1 integers p2, p3, ..., pn (1 ≤ pi < i), where pi is the number of the parent city of city number i in the tree, meaning there is a road between cities numbered pi and i in USC. Output In the first and only line of output print n numbers, where i-th number is the expected value of starting_time[i]. Your answer for each city will be considered correct if its absolute or relative error does not exceed 10 - 6. Examples Input 7 1 2 1 1 4 4 Output 1.0 4.0 5.0 3.5 4.5 5.0 5.0 Input 12 1 1 2 2 4 4 3 3 1 10 8 Output 1.0 5.0 5.5 6.5 7.5 8.0 8.0 7.0 7.5 6.5 7.5 8.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. Harry Water, Ronaldo, Her-my-oh-knee and their friends have started a new school year at their MDCS School of Speechcraft and Misery. At the time, they are very happy to have seen each other after a long time. The sun is shining, birds are singing, flowers are blooming, and their Potions class teacher, professor Snipe is sulky as usual. Due to his angst fueled by disappointment in his own life, he has given them a lot of homework in Potions class. Each of the n students has been assigned a single task. Some students do certain tasks faster than others. Thus, they want to redistribute the tasks so that each student still does exactly one task, and that all tasks are finished. Each student has their own laziness level, and each task has its own difficulty level. Professor Snipe is trying hard to improve their work ethics, so each student’s laziness level is equal to their task’s difficulty level. Both sets of values are given by the sequence a, where ai represents both the laziness level of the i-th student and the difficulty of his task. The time a student needs to finish a task is equal to the product of their laziness level and the task’s difficulty. They are wondering, what is the minimum possible total time they must spend to finish all tasks if they distribute them in the optimal way. Each person should receive one task and each task should be given to one person. Print the answer modulo 10 007. Input The first line of input contains integer n (1 ≤ n ≤ 100 000) — the number of tasks. The next n lines contain exactly one integer number ai (1 ≤ ai ≤ 100 000) — both the difficulty of the initial task and the laziness of the i-th students. Output Print the minimum total time to finish all tasks modulo 10 007. Example Input 2 1 3 Output 6 Note In the first sample, if the students switch their tasks, they will be able to finish them in 3 + 3 = 6 time units. 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. Dasha logged into the system and began to solve problems. One of them is as follows: Given two sequences a and b of length n each you need to write a sequence c of length n, the i-th element of which is calculated as follows: ci = bi - ai. About sequences a and b we know that their elements are in the range from l to r. More formally, elements satisfy the following conditions: l ≤ ai ≤ r and l ≤ bi ≤ r. About sequence c we know that all its elements are distinct. <image> Dasha wrote a solution to that problem quickly, but checking her work on the standard test was not so easy. Due to an error in the test system only the sequence a and the compressed sequence of the sequence c were known from that test. Let's give the definition to a compressed sequence. A compressed sequence of sequence c of length n is a sequence p of length n, so that pi equals to the number of integers which are less than or equal to ci in the sequence c. For example, for the sequence c = [250, 200, 300, 100, 50] the compressed sequence will be p = [4, 3, 5, 2, 1]. Pay attention that in c all integers are distinct. Consequently, the compressed sequence contains all integers from 1 to n inclusively. Help Dasha to find any sequence b for which the calculated compressed sequence of sequence c is correct. Input The first line contains three integers n, l, r (1 ≤ n ≤ 105, 1 ≤ l ≤ r ≤ 109) — the length of the sequence and boundaries of the segment where the elements of sequences a and b are. The next line contains n integers a1, a2, ..., an (l ≤ ai ≤ r) — the elements of the sequence a. The next line contains n distinct integers p1, p2, ..., pn (1 ≤ pi ≤ n) — the compressed sequence of the sequence c. Output If there is no the suitable sequence b, then in the only line print "-1". Otherwise, in the only line print n integers — the elements of any suitable sequence b. Examples Input 5 1 5 1 1 1 1 1 3 1 5 4 2 Output 3 1 5 4 2 Input 4 2 9 3 4 8 9 3 2 1 4 Output 2 2 2 9 Input 6 1 5 1 1 1 1 1 1 2 3 5 4 1 6 Output -1 Note Sequence b which was found in the second sample is suitable, because calculated sequence c = [2 - 3, 2 - 4, 2 - 8, 9 - 9] = [ - 1, - 2, - 6, 0] (note that ci = bi - ai) has compressed sequence equals to p = [3, 2, 1, 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 developing a new feature for the website which sells airline tickets: being able to sort tickets by price! You have already extracted the tickets' prices, so there's just the last step to be done... You are given an array of integers. Sort it in non-descending order. Input The input consists of a single line of space-separated integers. The first number is n (1 ≤ n ≤ 10) — the size of the array. The following n numbers are the elements of the array (1 ≤ ai ≤ 100). Output Output space-separated elements of the sorted array. Example Input 3 3 1 2 Output 1 2 3 Note Remember, this is a very important feature, and you have to make sure the customers appreciate it! 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 multiset of n integers. You should select exactly k of them in a such way that the difference between any two of them is divisible by m, or tell that it is impossible. Numbers can be repeated in the original multiset and in the multiset of selected numbers, but number of occurrences of any number in multiset of selected numbers should not exceed the number of its occurrences in the original multiset. Input First line contains three integers n, k and m (2 ≤ k ≤ n ≤ 100 000, 1 ≤ m ≤ 100 000) — number of integers in the multiset, number of integers you should select and the required divisor of any pair of selected integers. Second line contains n integers a1, a2, ..., an (0 ≤ ai ≤ 109) — the numbers in the multiset. Output If it is not possible to select k numbers in the desired way, output «No» (without the quotes). Otherwise, in the first line of output print «Yes» (without the quotes). In the second line print k integers b1, b2, ..., bk — the selected numbers. If there are multiple possible solutions, print any of them. Examples Input 3 2 3 1 8 4 Output Yes 1 4 Input 3 3 3 1 8 4 Output No Input 4 3 5 2 7 7 7 Output Yes 2 7 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. The whole world got obsessed with robots,and to keep pace with the progress, great Berland's programmer Draude decided to build his own robot. He was working hard at the robot. He taught it to walk the shortest path from one point to another, to record all its movements, but like in many Draude's programs, there was a bug — the robot didn't always walk the shortest path. Fortunately, the robot recorded its own movements correctly. Now Draude wants to find out when his robot functions wrong. Heh, if Draude only remembered the map of the field, where he tested the robot, he would easily say if the robot walked in the right direction or not. But the field map was lost never to be found, that's why he asks you to find out if there exist at least one map, where the path recorded by the robot is the shortest. The map is an infinite checkered field, where each square is either empty, or contains an obstruction. It is also known that the robot never tries to run into the obstruction. By the recorded robot's movements find out if there exist at least one such map, that it is possible to choose for the robot a starting square (the starting square should be empty) such that when the robot moves from this square its movements coincide with the recorded ones (the robot doesn't run into anything, moving along empty squares only), and the path from the starting square to the end one is the shortest. In one movement the robot can move into the square (providing there are no obstrutions in this square) that has common sides with the square the robot is currently in. Input The first line of the input file contains the recording of the robot's movements. This recording is a non-empty string, consisting of uppercase Latin letters L, R, U and D, standing for movements left, right, up and down respectively. The length of the string does not exceed 100. Output In the first line output the only word OK (if the above described map exists), or BUG (if such a map does not exist). Examples Input LLUUUR Output OK Input RRUULLDD Output BUG 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. Imp likes his plush toy a lot. <image> Recently, he found a machine that can clone plush toys. Imp knows that if he applies the machine to an original toy, he additionally gets one more original toy and one copy, and if he applies the machine to a copied toy, he gets two additional copies. Initially, Imp has only one original toy. He wants to know if it is possible to use machine to get exactly x copied toys and y original toys? He can't throw toys away, and he can't apply the machine to a copy if he doesn't currently have any copies. Input The only line contains two integers x and y (0 ≤ x, y ≤ 109) — the number of copies and the number of original toys Imp wants to get (including the initial one). Output Print "Yes", if the desired configuration is possible, and "No" otherwise. You can print each letter in arbitrary case (upper or lower). Examples Input 6 3 Output Yes Input 4 2 Output No Input 1000 1001 Output Yes Note In the first example, Imp has to apply the machine twice to original toys and then twice to copies. 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. One day Igor K. stopped programming and took up math. One late autumn evening he was sitting at a table reading a book and thinking about something. The following statement caught his attention: "Among any six people there are either three pairwise acquainted people or three pairwise unacquainted people" Igor just couldn't get why the required minimum is 6 people. "Well, that's the same for five people, too!" — he kept on repeating in his mind. — "Let's take, say, Max, Ilya, Vova — here, they all know each other! And now let's add Dima and Oleg to Vova — none of them is acquainted with each other! Now, that math is just rubbish!" Igor K. took 5 friends of his and wrote down who of them is friends with whom. Now he wants to check whether it is true for the five people that among them there are either three pairwise acquainted or three pairwise not acquainted people. Input The first line contains an integer m (0 ≤ m ≤ 10), which is the number of relations of acquaintances among the five friends of Igor's. Each of the following m lines contains two integers ai and bi (1 ≤ ai, bi ≤ 5;ai ≠ bi), where (ai, bi) is a pair of acquainted people. It is guaranteed that each pair of the acquaintances is described exactly once. The acquaintance relation is symmetrical, i.e. if x is acquainted with y, then y is also acquainted with x. Output Print "FAIL", if among those five people there are no either three pairwise acquainted or three pairwise unacquainted people. Otherwise print "WIN". Examples Input 4 1 3 2 3 1 4 5 3 Output WIN Input 5 1 2 2 3 3 4 4 5 5 1 Output FAIL 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. Limak is an old brown bear. He often goes bowling with his friends. For rolling a ball one gets a score - a non-negative integer number of points. Score for the i-th roll is multiplied by i and scores are summed up. For example, for rolls with scores 7, 10, 5 the total score is equal to 7×1 + 10×2 + 5×3 = 42. Limak made N rolls and got a score Ai for the i-th of them. Unfortunately, the bowling club's computer system isn't stable today. Any rolls can be erased! Then, the total score is calculated as if there were only non-erased rolls. There are 2^N possible sequences of remaining (non-erased) rolls. Limak is curious about various statistics of this situation. He asks you for one thing. Find the sum of total scores of all 2^N possible sequences of remaining rolls. Print it modulo 10^9+7. Input format The first line contains a single integer N. The second line contains N non-negative integers A1, A2, ..., AN. Output format In a single line print modulo 10^9+7 the sum of total scores of possible remaining sequences. Constraints 1 ≤ N ≤ 200,000 0 ≤ Ai ≤ 10^9 SAMPLE INPUT 3 6 12 8 SAMPLE OUTPUT 160 Explanation There are eight possible remaining subsequences. {} - 0 {6} - 6 {12} - 12 {8} - 8 {6, 12} - 30 {6, 8} - 22 {12, 8} - 28 {6, 12, 8} - 54 0 + 6 + 12 + 8 + 30 + 22 + 28 + 54 = 160 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. Ma5termind and Subway are bored of their normal life.They want to do something interesting so that they can enjoy their last sem of college life.As usual Ma5termind comes up with a simple and interesting game. Ma5termind gives Subway a compressed string. A compressed String is composed of characters and numbers.Every character in a compressed string contains a number. Ex a3b1c2 it represents aaabcc. Other compressed string could be a22b2a1 , z5c2x36. Each number in the compressed string indicates the number of times the corresponding character occurs in the string. The final string is 1 indexed. Ma5termind wants Subway to sort the compressed string and tell him the kth character in the sorted compressed string.Since subway got speed Ma5termind asks him various such questions. Help Subway in answering Ma5termind's question. Input: The first line contains the compressed string.This is followed by Q that indicates the number of questions Ma5termind shoots on Subway.Follows Q lines each line contain an integer K. Output: For every question output the Kth character if it exists else print -1 . Constraints: 2 ≤ Length of Compressed String ≤ 10^4 1 ≤ Length of Final String ≤ 10^18 1 ≤ Q ≤ 10^5 1 ≤ K ≤ 10^18 Every character in the string is lowercase English letter. Note: The number for a character may contain leading zeroes. SAMPLE INPUT a2b3c2a1 4 2 5 1 8 SAMPLE OUTPUT a b a c Explanation The final sorted string is aaabbbcc. 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 mysterious temple in Mysteryland. The door of the temple is always closed.It can only be opened by a unique procedure.There are two boxes and N items outside the temple.Sherlock holmes visits the temple many times.Each time Sherlock holmes visits the temple,the number of items N outside the door of the temple is changed but each time he anyhow manages to know the cost of those N items.The door of the temple can only be opened if those "N items" are distributed in those two boxes such that the sum of cost of items in one box is equal to the sum of cost of items in other box.Sherlock holmes is trying to do such a distribution so as to open the door of the temple.you have to tell whether the door the temple can be opened or not. INPUT the first line contain the number of test cases i.e the number of time sherlock holmes visits the temple. Next lines contains the description of those test cases.For the first line contain number of items "N".The second line contains cost of those N items. OUTPUT output "YES" if the door of the temple can be opened otherwise output "NO". Constraint: 1 ≤ testcases ≤ 10 1 ≤ N ≤ 100 1 ≤ cost ≤ 100 SAMPLE INPUT 3 5 4 3 5 5 3 4 1 2 3 4 2 1 2 SAMPLE OUTPUT YES YES NO Explanation there are three testcases testcase 1:the items can be distributed in the boxes as {4,3,3} ,{5,5} so output is YES testcase 2: the items can be distributed in the boxes as {4,1} ,{3,2} so output is YES testcase 3: such a distribution is not possible. 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 predicted by the great Gods, Little Arjit has got nothing to do this summer. (Are you surprised?) But, he's not one of those people to lose hope... not so easily. He decided to work hard this summer on the two things he wants the most, as of now: "Dual degree work", and "an internship!" So, following the signs from the universe, he makes multiple chits like the one shown below, and folds them, and puts all of them in a jar. Now, he follows a certain algorithm to complete his planned hard work in the 60 days of vacations, he's got. Let's say, little Arjit has c number of chits. Every day, he picks up a chit from the jar. If it's a normal, proper complete chit, he prefers selecting "dual degree" as his first choice. He finishes off the work selected from the chit; tears that portion, and puts back the remaining half of the chit, back in the jar. Let's say, if he picks a remaining half of some chit, he does that work - and so that chit's work is finished; and that chit is discarded. Given the total number of chits made by Little Arjit, in how many ways can he finish of all his work? Input format: The first line contains an integer, t, denoting the number of test cases. The next t lines contain one integer, n, in every line, denoting the number of chits made by little Arjit. Output format: Print the number of ways he can empty the jar. Constraints: 1 ≤ t ≤ 700 1 ≤ n ≤ 30 Obvious fact: For completing 30 chits, he'll be needing 30*2=60 days. SAMPLE INPUT 2 1 3 SAMPLE OUTPUT 1 5 Explanation Let's represent events happening on all those days as a string. How many different valid strings would be there that would empty the jar? Let's say that n = 3. D means dual degree. I means internships. So, there will be 5 different ways. They will be: DDDIII DIDDII DIDIDI DDIIDI DDIDII 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. Fennec is fighting with N monsters. The health of the i-th monster is H_i. Fennec can do the following two actions: * Attack: Fennec chooses one monster. That monster's health will decrease by 1. * Special Move: Fennec chooses one monster. That monster's health will become 0. There is no way other than Attack and Special Move to decrease the monsters' health. Fennec wins when all the monsters' healths become 0 or below. Find the minimum number of times Fennec needs to do Attack (not counting Special Move) before winning when she can use Special Move at most K times. Constraints * 1 \leq N \leq 2 \times 10^5 * 0 \leq K \leq 2 \times 10^5 * 1 \leq H_i \leq 10^9 * All values in input are integers. Input Input is given from Standard Input in the following format: N K H_1 ... H_N Output Print the minimum number of times Fennec needs to do Attack (not counting Special Move) before winning. Examples Input 3 1 4 1 5 Output 5 Input 8 9 7 9 3 2 3 8 4 6 Output 0 Input 3 0 1000000000 1000000000 1000000000 Output 3000000000 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 will be given a string S of length 3 representing the weather forecast for three days in the past. The i-th character (1 \leq i \leq 3) of S represents the forecast for the i-th day. `S`, `C`, and `R` stand for sunny, cloudy, and rainy, respectively. You will also be given a string T of length 3 representing the actual weather on those three days. The i-th character (1 \leq i \leq 3) of S represents the actual weather on the i-th day. `S`, `C`, and `R` stand for sunny, cloudy, and rainy, respectively. Print the number of days for which the forecast was correct. Constraints * S and T are strings of length 3 each. * S and T consist of `S`, `C`, and `R`. Input Input is given from Standard Input in the following format: S T Output Print the number of days for which the forecast was correct. Examples Input CSS CSR Output 2 Input SSR SSR Output 3 Input RRR SSS 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. Note the unusual memory limit. For a rectangular grid where each square is painted white or black, we define its complexity as follows: * If all the squares are black or all the squares are white, the complexity is 0. * Otherwise, divide the grid into two subgrids by a line parallel to one of the sides of the grid, and let c_1 and c_2 be the complexities of the subgrids. There can be multiple ways to perform the division, and let m be the minimum value of \max(c_1, c_2) in those divisions. The complexity of the grid is m+1. You are given a grid with H horizontal rows and W vertical columns where each square is painted white or black. HW characters from A_{11} to A_{HW} represent the colors of the squares. A_{ij} is `#` if the square at the i-th row from the top and the j-th column from the left is black, and A_{ij} is `.` if that square is white. Find the complexity of the given grid. Constraints * 1 \leq H,W \leq 185 * A_{ij} is `#` or `.`. Input Input is given from Standard Input in the following format: H W A_{11}A_{12}...A_{1W} : A_{H1}A_{H2}...A_{HW} Output Print the complexity of the given grid. Examples Input 3 3 ... .## .## Output 2 Input 6 7 .####.# ....#. ....#. ....#. .####.# ....## 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. In your garden, there is a long and narrow flowerbed that stretches infinitely to the east. You have decided to plant N kinds of flowers in this empty flowerbed. For convenience, we will call these N kinds of flowers Flower 1, 2, …, N. Also, we will call the position that is p centimeters from the west end of the flowerbed Position p. You will plant Flower i (1 ≤ i ≤ N) as follows: first, plant one at Position w_i, then plant one every d_i centimeters endlessly toward the east. That is, Flower i will be planted at the positions w_i, w_i + d_i, w_i + 2 d_i, … Note that more than one flower may be planted at the same position. Find the position at which the K-th flower from the west is planted. If more than one flower is planted at the same position, they are counted individually. Constraints * 1 ≤ N ≤ 10^5 * 1 ≤ K ≤ 10^9 * 1 ≤ w_i ≤ 10^{18} * 1 ≤ d_i ≤ 10^9 * All input values are integers. Input Input is given from Standard Input in the following format: N K w_1 d_1 : w_N d_N Output When the K-th flower from the west is planted at Position X, print the value of X. (The westmost flower is counted as the 1-st flower.) Examples Input 2 6 20 10 25 15 Output 50 Input 3 9 10 10 10 10 10 10 Output 30 Input 1 1000000000 1000000000000000000 1000000000 Output 1999999999000000000 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 set consisting of N distinct integers. The i-th smallest element in this set is S_i. We want to divide this set into two sets, X and Y, such that: * The absolute difference of any two distinct elements in X is A or greater. * The absolute difference of any two distinct elements in Y is B or greater. How many ways are there to perform such division, modulo 10^9 + 7? Note that one of X and Y may be empty. Constraints * All input values are integers. * 1 ≦ N ≦ 10^5 * 1 ≦ A , B ≦ 10^{18} * 0 ≦ S_i ≦ 10^{18}(1 ≦ i ≦ N) * S_i < S_{i+1}(1 ≦ i ≦ N - 1) Input The input is given from Standard Input in the following format: N A B S_1 : S_N Output Print the number of the different divisions under the conditions, modulo 10^9 + 7. Examples Input 5 3 7 1 3 6 9 12 Output 5 Input 7 5 3 0 2 4 7 8 11 15 Output 4 Input 8 2 9 3 4 5 13 15 22 26 32 Output 13 Input 3 3 4 5 6 7 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. Sigma and Sugim are playing a game. The game is played on a graph with N vertices numbered 1 through N. The graph has N-1 red edges and N-1 blue edges, and the N-1 edges in each color forms a tree. The red edges are represented by pairs of integers (a_i, b_i), and the blue edges are represented by pairs of integers (c_i, d_i). Each player has his own piece. Initially, Sigma's piece is at vertex X, and Sugim's piece is at vertex Y. The game is played in turns, where turns are numbered starting from turn 1. Sigma takes turns 1, 3, 5, ..., and Sugim takes turns 2, 4, 6, .... In each turn, the current player either moves his piece, or does nothing. Here, Sigma can only move his piece to a vertex that is directly connected to the current vertex by a red edge. Similarly, Sugim can only move his piece to a vertex that is directly connected to the current vertex by a blue edge. When the two pieces come to the same vertex, the game ends immediately. If the game ends just after the operation in turn i, let i be the total number of turns in the game. Sigma's objective is to make the total number of turns as large as possible, while Sugim's objective is to make it as small as possible. Determine whether the game will end in a finite number of turns, assuming both players plays optimally to achieve their respective objectives. If the answer is positive, find the number of turns in the game. Constraints * 2 ≦ N ≦ 200,000 * 1 ≦ X, Y ≦ N * X \neq Y * 1 ≦ a_i, b_i, c_i, d_i ≦ N * The N-1 edges in each color (red and blue) forms a tree. Input The input is given from Standard Input in the following format: N X Y a_1 b_1 a_2 b_2 : a_{N-1} b_{N-1} c_1 d_1 c_2 d_2 : c_{N-1} d_{N-1} Output If the game will end in a finite number of turns, print the number of turns. Otherwise, print `-1`. Examples Input 4 1 2 1 2 1 3 1 4 2 1 2 3 1 4 Output 4 Input 3 3 1 1 2 2 3 1 2 2 3 Output 4 Input 4 1 2 1 2 3 4 2 4 1 2 3 4 1 3 Output 2 Input 4 2 1 1 2 3 4 2 4 1 2 3 4 1 3 Output -1 Input 5 1 2 1 2 1 3 1 4 4 5 2 1 1 3 1 5 5 4 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. The huge maze The Squares has been newly completed in the famous theme park. Evacuation drills must be conducted under the guidance of the fire department, but the time required for the drills cannot be predicted due to the huge maze. Therefore, you decided to develop an evacuation drill simulator based on the following specifications. As shown in Fig. 1, the giant maze is represented by W × H squares of horizontal W and vertical H. Each square is either a passage (white square), a wall (brown square), or an emergency exit (green square). The circles in the figure represent people, and the lowercase letters (E, W, S, N) in them represent the direction in which the person is facing (north, south, east, and west). The figure is drawn with the upward direction facing north. <image> Figure 1 People in the giant maze initially stand facing either north, south, east, or west. Each person attempts to move in 1-second increments at the same time, following the steps below. 1. Look at the right, front, left, and back squares in the direction you are currently facing, and turn to the first vacant aisle or emergency exit you find. If there is no such square, the direction will not change. 2. If the square in front of you is open and not in front of another person, move it. If there are multiple people with the same square in front of you, the selected one will move in the order of the people in that square, east, north, west, and south. Those who arrive at the emergency exit after moving will evacuate safely and disappear from the maze. Create a program that inputs the given huge maze and the location information of people and outputs the time when all people finish evacuating. If it takes more than 180 seconds to escape, output NA. Maze and person location information is given by the characters in rows H and columns W. The meaning of each character is as follows. : Wall .: Floor X: Emergency exit E: People facing east N: People facing north W: People facing west S: People facing south The boundary between the maze and the outside is either the wall # or the emergency exit X. In addition, there is always one or more people in the huge maze. Input A sequence of multiple datasets is given as input. The end of the input is indicated by two lines of zeros. Each dataset is given in the following format: W H str1 str2 :: strH The first line gives the horizontal size W of the maze and the vertical size H (1 ≤ W, H ≤ 30). The following H line is given the string stri (length W) that represents the i-th line of the maze. The number of datasets does not exceed 50. Output For each input dataset, the time when all people finish evacuating is output on one line. Examples Input 10 3 ########## #E.......X ########## 4 4 #### #N.# #..X #### 5 5 ##### #N..# ###.X #S..# ##### 6 6 ###### #..#X# #.EE.# ####N# #....# ###### 8 8 ##X##### #....E.# #####.## #.#...## #.W.#..# #.#.N#.X #X##.#.# ######## 0 0 Output 8 NA 9 16 10 Input 10 3 E.......X 4 4 N.# ..X 5 5 N..# .X S..# 6 6 ..#X# .EE.# N# ....# 8 8 X##### ....E.# .## .#...## .W.#..# .#.N#.X X##.#.# 0 0 Output 8 NA 9 16 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. Dr. Grey is a data analyst, who visualizes various aspects of data received from all over the world everyday. He is extremely good at sophisticated visualization tools, but yet his favorite is a simple self-made histogram generator. Figure 1 is an example of histogram automatically produced by his histogram. <image> A histogram is a visual display of frequencies of value occurrences as bars. In this example, values in the interval 0-9 occur five times, those in the interval 10-19 occur three times, and 20-29 and 30-39 once each. Dr. Grey’s histogram generator is a simple tool. First, the height of the histogram is fixed, that is, the height of the highest bar is always the same and those of the others are automatically adjusted proportionately. Second, the widths of bars are also fixed. It can only produce a histogram of uniform intervals, that is, each interval of a histogram should have the same width (10 in the above example). Finally, the bar for each interval is painted in a grey color, where the colors of the leftmost and the rightmost intervals are black and white, respectively, and the darkness of bars monotonically decreases at the same rate from left to right. For instance, in Figure 1, the darkness levels of the four bars are 1, 2/3, 1/3, and 0, respectively. In this problem, you are requested to estimate ink consumption when printing a histogram on paper. The amount of ink necessary to draw a bar is proportional to both its area and darkness. Input The input consists of multiple datasets, each of which contains integers and specifies a value table and intervals for the histogram generator, in the following format. n w v1 v2 . . vn n is the total number of value occurrences for the histogram, and each of the n lines following the first line contains a single value. Note that the same value may possibly occur multiple times. w is the interval width. A value v is in the first (i.e. leftmost) interval if 0 ≤ v < w, the second one if w ≤ v < 2w, and so on. Note that the interval from 0 (inclusive) to w (exclusive) should be regarded as the leftmost even if no values occur in this interval. The last (i.e. rightmost) interval is the one that includes the largest value in the dataset. You may assume the following. 1 ≤ n ≤ 100 10 ≤ w ≤ 50 0 ≤ vi ≤ 100 for 1 ≤ i ≤ n You can also assume that the maximum value is no less than w. This means that the histogram has more than one interval. The end of the input is indicated by a line containing two zeros. Output For each dataset, output a line containing the amount of ink consumed in printing the histogram. One unit of ink is necessary to paint one highest bar black. Assume that 0.01 units of ink per histogram is consumed for various purposes except for painting bars such as drawing lines and characters (see Figure 1). For instance, the amount of ink consumed in printing the histogram in Figure 1 is: <image> Each output value should be in a decimal fraction and may have an error less than 10-5 . Example Input 3 50 100 0 100 3 50 100 100 50 10 10 1 2 3 4 5 16 17 18 29 30 0 0 Output 0.51 0.26 1.4766666666666667 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 story of 20XX. The number of air passengers increased as a result of the stable energy supply by the renewable power network and the invention of liquefied synthetic fuel. However, the threat of terrorism by aircraft still exists, and the importance of fast and highly reliable automatic baggage inspection systems is increasing. Since it is actually difficult for an inspector to inspect all the baggage, we would like to establish a mechanism for the inspector to inspect only the baggage judged to be suspicious by the automatic inspection. At the request of the aviation industry, the International Cabin Protection Company investigated recent passenger baggage in order to develop a new automated inspection system. As a result of the investigation, it was found that the baggage of recent passengers has the following tendency. * Baggage is shaped like a rectangular parallelepiped with only one side short. * Items that ordinary passengers pack in their baggage and bring into the aircraft include laptop computers, music players, handheld game consoles, and playing cards, all of which are rectangular. * Individual items are packed so that their rectangular sides are parallel to the sides of the baggage. * On the other hand, weapons such as those used for terrorism have a shape very different from a rectangle. Based on the above survey results, we devised the following model for baggage inspection. Each piece of baggage is considered to be a rectangular parallelepiped container that is transparent to X-rays. It contains multiple items that are opaque to X-rays. Here, consider a coordinate system with the three sides of the rectangular parallelepiped as the x-axis, y-axis, and z-axis, irradiate X-rays in the direction parallel to the x-axis, and take an image projected on the y-z plane. The captured image is divided into grids of appropriate size, and the material of the item reflected in each grid area is estimated by image analysis. Since this company has a very high level of analysis technology and can analyze even the detailed differences in materials, it can be considered that the materials of the products are different from each other. When multiple items overlap in the x-axis direction, the material of the item that is in the foreground for each lattice region, that is, the item with the smallest x-coordinate is obtained. We also assume that the x-coordinates of two or more items are never equal. Your job can be asserted that it contains non-rectangular (possibly a weapon) item when given the results of the image analysis, or that the baggage contains anything other than a rectangular item. It is to create a program that determines whether it is presumed that it is not included. Input The first line of input contains a single positive integer, which represents the number of datasets. Each dataset is given in the following format. > H W > Analysis result 1 > Analysis result 2 > ... > Analysis result H > H is the vertical size of the image, and W is an integer representing the horizontal size (1 <= h, w <= 50). Each line of the analysis result is composed of W characters, and the i-th character represents the analysis result in the grid region i-th from the left of the line. For the lattice region where the substance is detected, the material is represented by uppercase letters (A to Z). At this time, the same characters are used if they are made of the same material, and different characters are used if they are made of different materials. The lattice region where no substance was detected is represented by a dot (.). For all datasets, it is guaranteed that there are no more than seven material types. Output For each data set, output "SUSPICIOUS" if it contains items other than rectangles, and "SAFE" if not, on one line. Sample Input 6 1 1 .. 3 3 ... .W. ... 10 10 .......... .DDDDCC .. .DDDDCC .. .DDDDCC .. ADDDDCCC .. AAA .. CCC .. AAABB BBC .. AAABBBB ... ..BBBBB ... .......... 10 10 .......... .DDDDDD ... .DDDDCC .. .DDDDCC .. ADDDDCCC .. AAA .. CCC .. AAABB BBC .. AAABBBB ... ..BBBBB ... .......... 10 10 R..E..C.T. R.EEE.C.T. .EEEEE .... EEEEEEE ... .EEEEEEE .. ..EEEEEEE. ... EEEEEEE .... EEEEE. ..... EEE .. ...... E ... 16 50 ................................................................. ......... AAAAAAAAAAAAAAAAA ............................ .... PPP ... AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA ..... .... PPP ... AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA ..... .... PPP ... AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA .... .... PPP .............. AAAAA.AAAAAAAAAAAAAAAA ....... .... PPP ................ A .... AAA.AAAAAAAAAA ........ .... PPP ........... IIIIIAAIIAIII.AAAAAAAAAA ........ ..CCCCCCCCCCCCCC ... IIIIIIAAAAAAAAAAAAAAAAAA ........ ..CCCCCCCCCCCCCC ... IIIIIIIIIIIII ... AAAAAAAAAAA ...... .... PPP .................. AAAAAAAAAAA ..... MMMMPPPMMMMMMMMMMMMMMM ............. AAAAAAAAAAA .... MMMMPPPMMMMMMMMMMMMMMM .............. AAAAAAAAAAA ... MMMMMMMMMMMMMMMMMMMMMM ............... AAAAAAAAAAA ... MMMMMMMMMMMMMMMMMMMMMM ............... AAAAAAAAAAA ... MMMMMMMMMMMMMMMMMMMMMM ............................ Output for the Sample Input SAFE SAFE SAFE SUSPICIOUS SUSPICIOUS SUSPICIOUS Example Input 6 1 1 . 3 3 ... .W. ... 10 10 .......... .DDDDCCC.. .DDDDCCC.. .DDDDCCC.. ADDDDCCC.. AAA..CCC.. AAABBBBC.. AAABBBB... ..BBBBB... .......... 10 10 .......... .DDDDDD... .DDDDCCC.. .DDDDCCC.. ADDDDCCC.. AAA..CCC.. AAABBBBC.. AAABBBB... ..BBBBB... .......... 10 10 R..E..C.T. R.EEE.C.T. .EEEEE.... EEEEEEE... .EEEEEEE.. ..EEEEEEE. ...EEEEEEE ....EEEEE. .....EEE.. ......E... 16 50 .................................................. .........AAAAAAAAAAAAAAAA......................... ....PPP...AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA..... ....PPP...AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA..... ....PPP...AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA.... ....PPP..............AAAAA.AAAAAAAAAAAAAAAA....... ....PPP................A....AAA.AAAAAAAAAA........ ....PPP...........IIIIIAAIIAIII.AAAAAAAAAA........ ..CCCCCCCCCCCCC...IIIIIIAAAAAAAAAAAAAAAAAA........ ..CCCCCCCCCCCCC...IIIIIIIIIIIII...AAAAAAAAAA...... ....PPP............................AAAAAAAAAA..... MMMMPPPMMMMMMMMMMMMMMM.............AAAAAAAAAAA.... MMMMPPPMMMMMMMMMMMMMMM..............AAAAAAAAAAA... MMMMMMMMMMMMMMMMMMMMMM...............AAAAAAAAAA... MMMMMMMMMMMMMMMMMMMMMM...............AAAAAAAAAA... MMMMMMMMMMMMMMMMMMMMMM............................ Output SAFE SAFE SAFE SUSPICIOUS SUSPICIOUS SUSPICIOUS 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 recording a result of a secret experiment, which consists of a large set of N-dimensional vectors. Since the result may become very large, you are thinking of compressing it. Fortunately you already have a good compression method for vectors with small absolute values, all you have to do is to preprocess the vectors and make them small. You can record the set of vectors in any order you like. Let's assume you process them in the order v_1, v_2,..., v_M. Each vector v_i is recorded either as is, or as a difference vector. When it is recorded as a difference, you can arbitrarily pick up an already chosen vector v_j (j<i) and a real value r. Then the actual vector value recorded is (v_i - r v_j). The values of r and j do not affect the compression ratio so much, so you don't have to care about them. Given a set of vectors, your task is to write a program that calculates the minimum sum of the squared length of the recorded vectors. Input The input is like the following style. N M v_{1,1} v_{1,2} ... v_{1,N} ... v_{M,1} v_{M,2} ... v_{M,N} The first line contains two integers N and M (1 \leq N, M \leq 100), where N is the dimension of each vector, and M is the number of the vectors. Each of the following M lines contains N floating point values v_{i,j} (-1.0 \leq v_{i,j} \leq 1.0) which represents the j-th element value of the i-th vector. Output Output the minimum sum of the squared length of the recorded vectors. The output should not contain an absolute error greater than 10^{-6}. Examples Input 2 3 1.0 1.0 -1.0 0.0 0.5 0.5 Output 1.0 Input 1 1 1.0 Output 1.0 Input 4 3 1.0 1.0 0.0 0.0 -1.0 0.0 -1.0 0.0 0.5 0.5 0.5 0.5 Output 3.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. Sunuke-kun's dictionary contains the words s1, ..., sn, which consist of n lowercase letters. This satisfies s1 <... <sn when compared in lexicographical order. Unfortunately, some characters are faint and unreadable. Unreadable characters are represented by?. Find out how many ways to restore the dictionary by replacing? With lowercase letters, even with mod 1,000,000,007. Constraints * 1 ≤ n ≤ 50 * 1 ≤ \| si \| ≤ 20 * The characters that appear in si are lowercase letters or? Input n s1 .. .. sn Output Print the answer on one line. Examples Input 2 ?sum??mer c??a??mp Output 703286064 Input 3 snuje ????e snule 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. Example Input 4 Durett 7 Gayles 3 Facenda 6 Daughtery 0 1 + Mccourtney 2 Output Mccourtney is not working now. Durett is working hard now. 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> As shown in the figure above, cut a convex polygon g by a line p1p2 and print the area of the cut polygon which is on the left-hand side of the line. g is represented by a sequence of points p1, p2,..., pn where line segments connecting pi and pi+1 (1 ≤ i ≤ n−1) are sides of the convex polygon. The line segment connecting pn and p1 is also a side of the polygon. Constraints * 3 ≤ n ≤ 100 * 1 ≤ q ≤ 100 * -10000 ≤ xi, yi ≤ 10000 * -10000 ≤ p1x,p1y,p2x,p2y ≤ 10000 * No point in g will occur more than once. * p1 ≠ p2 Input The input is given in the following format: g (the sequence of the points of the polygon) q (the number of queries = the number of target lines) 1st query 2nd query : qth query g is given as a sequence of points p1,..., pn in the following format: n x1 y1 x2 y2 : xn yn The first integer n is the number of points. The coordinate of the i-th point pi is given by two integers xi and yi. The coordinates of points are given in the order of counter-clockwise visit of them. Note that all interior angles of given convex polygons are less than or equal to 180. For each query, a line represented by two points p1 and p2 is given. The coordinates of the points are given by four integers p1x, p1y, p2x and p2y. Output For each query, print the area of the cut polygon. The output values should be in a decimal fraction with an error less than 0.00001. Example Input 4 1 1 4 1 4 3 1 3 2 2 0 2 4 2 4 2 0 Output 2.00000000 4.00000000 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. Tug of war is a sport that directly puts two teams against each other in a test of strength. During school days, both Chef Shifu and Chef Po were champions of tug of war. On behalf of restaurant's anniversary, Chef Shifu and Chef Po have decided to conduct a tug of war game for their customers. Master Chef Oogway has decided the following rules for the game. Let N be the number of players participating in the game. All of these players would stand in a circle in clock wise direction. There are an infinite number of long ropes available. When a rope is held by exactly two players, it is termed as bonding. At least one bonding is necessary to conduct a game. A player can play against multiple people simultaneously i.e he can have more than one bonding at the same time. Both members of a pair of players that have a bonding must have the same number of total bondings. That is, if the player A makes bonding with the player B, then the number of total bondings of the player A must be the same as that of the player B. Bondings should be created in such a fashion that ropes must not intersect each other. The number of bondings of every player must be no more than K. Now Master Chef Oogway asked Chef Shifu and Chef Po to find out the number of possible games. Your task is to help them find this number. As this number might become huge, you've to find it modulo (10^14+7). Two games are different iff there is some bonding that is present in only of them. Input First line contains T, the number of test cases. Each of T lines contain 2 positive integers N and K separated by a space. Output For each test case, output the number of ways to conduct the game modulo 100000000000007 (10^14+7) in one line. Example Input: 3 3 2 4 0 2 1 Output: 4 0 1 Explanation: For the 1st case, there are 3 players. Let's call them p1, p2, p3. Different games possible are: Game 1: p1-p2 (numbers of bondings of p1, p2 are 1 ≤ K = 2) Game 2: p1-p3 (numbers of bondings of p1, p3 are 1 ≤ K = 2) Game 3: p2-p3 (numbers of bondings of p2, p3 are 1 ≤ K = 2) Game 4: p1-p2, p1-p3, p2-p3 (numbers of bondings of p1, p2, p3 are 2 ≤ K = 2) For the 2nd test case, we cannot form the game, because K = 0 and hence no player is allowed to make any bonding. As any game must have atleast one bonding, no game is possible here. For the 3rd case, only possible game is: Game 1: p1-p2 (number of bondings in p1, p2 are 1) Constraints 1 ≤ T ≤ 10000 0 ≤ N ≤ 10000 0 ≤ K ≤ N 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 star is a figure of the following type: an asterisk character '' in the center of the figure and four rays (to the left, right, top, bottom) of the same positive length. The size of a star is the length of its rays. The size of a star must be a positive number (i.e. rays of length 0 are not allowed). Let's consider empty cells are denoted by '.', then the following figures are stars: <image> The leftmost figure is a star of size 1, the middle figure is a star of size 2 and the rightmost figure is a star of size 3. You are given a rectangular grid of size n × m consisting only of asterisks '' and periods (dots) '.'. Rows are numbered from 1 to n, columns are numbered from 1 to m. Your task is to draw this grid using any number of stars or find out that it is impossible. Stars can intersect, overlap or even coincide with each other. The number of stars in the output can't exceed n ⋅ m. Each star should be completely inside the grid. You can use stars of same and arbitrary sizes. In this problem, you do not need to minimize the number of stars. Just find any way to draw the given grid with at most n ⋅ m stars. Input The first line of the input contains two integers n and m (3 ≤ n, m ≤ 1000) — the sizes of the given grid. The next n lines contains m characters each, the i-th line describes the i-th row of the grid. It is guaranteed that grid consists of characters '' and '.' only. Output If it is impossible to draw the given grid using stars only, print "-1". Otherwise in the first line print one integer k (0 ≤ k ≤ n ⋅ m) — the number of stars needed to draw the given grid. The next k lines should contain three integers each — x_j, y_j and s_j, where x_j is the row index of the central star character, y_j is the column index of the central star character and s_j is the size of the star. Each star should be completely inside the grid. Examples Input 6 8 ....... ...... ..*. ...... ....... ........ Output 3 3 4 1 3 5 2 3 5 1 Input 5 5 .... **. . ... ..... Output 3 2 2 1 3 3 1 3 4 1 Input 5 5 .... *.. .... .... ..... Output -1 Input 3 3 .* .. .* Output -1 Note In the first example the output 2 3 4 1 3 5 2 is also correct. 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 order to make the "Sea Battle" game more interesting, Boris decided to add a new ship type to it. The ship consists of two rectangles. The first rectangle has a width of w_1 and a height of h_1, while the second rectangle has a width of w_2 and a height of h_2, where w_1 ≥ w_2. In this game, exactly one ship is used, made up of two rectangles. There are no other ships on the field. The rectangles are placed on field in the following way: * the second rectangle is on top the first rectangle; * they are aligned to the left, i.e. their left sides are on the same line; * the rectangles are adjacent to each other without a gap. See the pictures in the notes: the first rectangle is colored red, the second rectangle is colored blue. Formally, let's introduce a coordinate system. Then, the leftmost bottom cell of the first rectangle has coordinates (1, 1), the rightmost top cell of the first rectangle has coordinates (w_1, h_1), the leftmost bottom cell of the second rectangle has coordinates (1, h_1 + 1) and the rightmost top cell of the second rectangle has coordinates (w_2, h_1 + h_2). After the ship is completely destroyed, all cells neighboring by side or a corner with the ship are marked. Of course, only cells, which don't belong to the ship are marked. On the pictures in the notes such cells are colored green. Find out how many cells should be marked after the ship is destroyed. The field of the game is infinite in any direction. Input Four lines contain integers w_1, h_1, w_2 and h_2 (1 ≤ w_1, h_1, w_2, h_2 ≤ 10^8, w_1 ≥ w_2) — the width of the first rectangle, the height of the first rectangle, the width of the second rectangle and the height of the second rectangle. You can't rotate the rectangles. Output Print exactly one integer — the number of cells, which should be marked after the ship is destroyed. Examples Input 2 1 2 1 Output 12 Input 2 2 1 2 Output 16 Note In the first example the field looks as follows (the first rectangle is red, the second rectangle is blue, green shows the marked squares): <image> In the second example the field looks as: <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. Nazar, a student of the scientific lyceum of the Kingdom of Kremland, is known for his outstanding mathematical abilities. Today a math teacher gave him a very difficult task. Consider two infinite sets of numbers. The first set consists of odd positive numbers (1, 3, 5, 7, …), and the second set consists of even positive numbers (2, 4, 6, 8, …). At the first stage, the teacher writes the first number on the endless blackboard from the first set, in the second stage — the first two numbers from the second set, on the third stage — the next four numbers from the first set, on the fourth — the next eight numbers from the second set and so on. In other words, at each stage, starting from the second, he writes out two times more numbers than at the previous one, and also changes the set from which these numbers are written out to another. The ten first written numbers: 1, 2, 4, 3, 5, 7, 9, 6, 8, 10. Let's number the numbers written, starting with one. The task is to find the sum of numbers with numbers from l to r for given integers l and r. The answer may be big, so you need to find the remainder of the division by 1000000007 (10^9+7). Nazar thought about this problem for a long time, but didn't come up with a solution. Help him solve this problem. Input The first line contains two integers l and r (1 ≤ l ≤ r ≤ 10^{18}) — the range in which you need to find the sum. Output Print a single integer — the answer modulo 1000000007 (10^9+7). Examples Input 1 3 Output 7 Input 5 14 Output 105 Input 88005553535 99999999999 Output 761141116 Note In the first example, the answer is the sum of the first three numbers written out (1 + 2 + 4 = 7). In the second example, the numbers with numbers from 5 to 14: 5, 7, 9, 6, 8, 10, 12, 14, 16, 18. Their sum is 105. 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. Petya loves lucky numbers. Everybody knows that lucky numbers are positive integers whose decimal representation contains only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not. One day Petya was delivered a string s, containing only digits. He needs to find a string that * represents a lucky number without leading zeroes, * is not empty, * is contained in s as a substring the maximum number of times. Among all the strings for which the three conditions given above are fulfilled, Petya only needs the lexicographically minimum one. Find this string for Petya. Input The single line contains a non-empty string s whose length can range from 1 to 50, inclusive. The string only contains digits. The string can contain leading zeroes. Output In the only line print the answer to Petya's problem. If the sought string does not exist, print "-1" (without quotes). Examples Input 047 Output 4 Input 16 Output -1 Input 472747 Output 7 Note The lexicographical comparison of strings is performed by the < operator in the modern programming languages. String x is lexicographically less than string y either if x is a prefix of y, or exists such i (1 ≤ i ≤ min(\|x\|, \|y\|)), that xi < yi and for any j (1 ≤ j < i) xj = yj. Here \|a\| denotes the length of string a. In the first sample three conditions are fulfilled for strings "4", "7" and "47". The lexicographically minimum one is "4". In the second sample s has no substrings which are lucky numbers. In the third sample the three conditions are only fulfilled for string "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. Recently Polycarp noticed that some of the buttons of his keyboard are malfunctioning. For simplicity, we assume that Polycarp's keyboard contains 26 buttons (one for each letter of the Latin alphabet). Each button is either working fine or malfunctioning. To check which buttons need replacement, Polycarp pressed some buttons in sequence, and a string s appeared on the screen. When Polycarp presses a button with character c, one of the following events happened: * if the button was working correctly, a character c appeared at the end of the string Polycarp was typing; * if the button was malfunctioning, two characters c appeared at the end of the string. For example, suppose the buttons corresponding to characters a and c are working correctly, and the button corresponding to b is malfunctioning. If Polycarp presses the buttons in the order a, b, a, c, a, b, a, then the string he is typing changes as follows: a → abb → abba → abbac → abbaca → abbacabb → abbacabba. You are given a string s which appeared on the screen after Polycarp pressed some buttons. Help Polycarp to determine which buttons are working correctly for sure (that is, this string could not appear on the screen if any of these buttons was malfunctioning). You may assume that the buttons don't start malfunctioning when Polycarp types the string: each button either works correctly throughout the whole process, or malfunctions throughout the whole process. Input The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases in the input. Then the test cases follow. Each test case is represented by one line containing a string s consisting of no less than 1 and no more than 500 lowercase Latin letters. Output For each test case, print one line containing a string res. The string res should contain all characters which correspond to buttons that work correctly in alphabetical order, without any separators or repetitions. If all buttons may malfunction, res should be empty. Example Input 4 a zzaaz ccff cbddbb Output a z bc 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. Vasya had three strings a, b and s, which consist of lowercase English letters. The lengths of strings a and b are equal to n, the length of the string s is equal to m. Vasya decided to choose a substring of the string a, then choose a substring of the string b and concatenate them. Formally, he chooses a segment [l_1, r_1] (1 ≤ l_1 ≤ r_1 ≤ n) and a segment [l_2, r_2] (1 ≤ l_2 ≤ r_2 ≤ n), and after concatenation he obtains a string a[l_1, r_1] + b[l_2, r_2] = a_{l_1} a_{l_1 + 1} … a_{r_1} b_{l_2} b_{l_2 + 1} … b_{r_2}. Now, Vasya is interested in counting number of ways to choose those segments adhering to the following conditions: * segments [l_1, r_1] and [l_2, r_2] have non-empty intersection, i.e. there exists at least one integer x, such that l_1 ≤ x ≤ r_1 and l_2 ≤ x ≤ r_2; * the string a[l_1, r_1] + b[l_2, r_2] is equal to the string s. Input The first line contains integers n and m (1 ≤ n ≤ 500 000, 2 ≤ m ≤ 2 ⋅ n) — the length of strings a and b and the length of the string s. The next three lines contain strings a, b and s, respectively. The length of the strings a and b is n, while the length of the string s is m. All strings consist of lowercase English letters. Output Print one integer — the number of ways to choose a pair of segments, which satisfy Vasya's conditions. Examples Input 6 5 aabbaa baaaab aaaaa Output 4 Input 5 4 azaza zazaz azaz Output 11 Input 9 12 abcabcabc xyzxyzxyz abcabcayzxyz Output 2 Note Let's list all the pairs of segments that Vasya could choose in the first example: 1. [2, 2] and [2, 5]; 2. [1, 2] and [2, 4]; 3. [5, 5] and [2, 5]; 4. [5, 6] and [3, 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. Kaavi, the mysterious fortune teller, deeply believes that one's fate is inevitable and unavoidable. Of course, she makes her living by predicting others' future. While doing divination, Kaavi believes that magic spells can provide great power for her to see the future. <image> Kaavi has a string T of length m and all the strings with the prefix T are magic spells. Kaavi also has a string S of length n and an empty string A. During the divination, Kaavi needs to perform a sequence of operations. There are two different operations: * Delete the first character of S and add it at the front of A. * Delete the first character of S and add it at the back of A. Kaavi can perform no more than n operations. To finish the divination, she wants to know the number of different operation sequences to make A a magic spell (i.e. with the prefix T). As her assistant, can you help her? The answer might be huge, so Kaavi only needs to know the answer modulo 998 244 353. Two operation sequences are considered different if they are different in length or there exists an i that their i-th operation is different. A substring is a contiguous sequence of characters within a string. A prefix of a string S is a substring of S that occurs at the beginning of S. Input The first line contains a string S of length n (1 ≤ n ≤ 3000). The second line contains a string T of length m (1 ≤ m ≤ n). Both strings contain only lowercase Latin letters. Output The output contains only one integer — the answer modulo 998 244 353. Examples Input abab ba Output 12 Input defineintlonglong signedmain Output 0 Input rotator rotator Output 4 Input cacdcdbbbb bdcaccdbbb Output 24 Note The first test: <image> The red ones are the magic spells. In the first operation, Kaavi can either add the first character "a" at the front or the back of A, although the results are the same, they are considered as different operations. So the answer is 6×2=12. 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. Oh, no! The coronavirus has caught you, and now you're sitting in a dark cellar, with tied legs (but not hands). You have a delicious cookie, a laptop in front of you, and your ideal development environment is open. The coronavirus convinces you to solve the following problem. You are given two arrays A and B of size n. You can do operations of two types with array A: * Reverse array A. That is the array [A_1,\ A_2,\ …,\ A_n] transformes into [A_n,\ A_{n-1},\ …,\ A_1]. * Replace A with an array of its prefix sums. That is, the array [A_1,\ A_2,\ …,\ A_n] goes to [A_1,\ (A_1+A_2),\ …,\ (A_1+A_2+…+A_n)]. You need to understand if you can get an array B from the array A. If it is possible, you will have to restore the order of these operations by minimizing the number of operations of the second type. Fortunately, the coronavirus is good today, so he has allowed you not to restore actions if the minimum number of second type operations is more than 2⋅ 10^5. But coronavirus resents you, so if you restore the answer, the total number of operations should not exceed 5⋅ 10^5. Solve this problem and get the cookie, or the coronavirus will extend the quarantine for five years and make the whole economy collapse! Input The first line contains a single integer n (1≤ n ≤ 2⋅ 10^5). The second line contains n integers A_1, A_2, …, A_n (1 ≤ A_i ≤ 10 ^ {12}). The third line contains n integers B_1, B_2, …, B_n (1 ≤ B_i ≤ 10 ^ {12}). Output If you cannot get B from the A array, print "IMPOSSIBLE" (without quotes) on a single line. If the minimum number of operations of the second type exceeds 2⋅ 10^5, print "BIG" (without quotes). In the second line print the number of operations of the second type, that needs to be applied to get array B from A. Otherwise, in the first line print "SMALL" (without quotes). In the second line print the total number of operations of the first and second types m ≤ 5⋅ 10^5 (it is guaranteed that in this case there is such a sequence of actions). In the third line print a line of length m, consisting of characters 'R"and 'P' (without quotes). The i-th character should be 'R', if the i-th action is of the first type, and should be 'P', otherwise. If there are several such sequences, you can print any of them. You can print each character in the uppercase or in the lowercase. Examples Input 2 5 7 5 7 Output SMALL 0 Input 2 1 1 300000 1 Output BIG 299999 Input 2 10 1 13 14 Output SMALL 6 RPPPRP Input 3 1 2 1 2 1 2 Output IMPOSSIBLE Note In the first example, the arrays A and B already equal, so the number of required operations =0. In the second example, we need to replace A with the prefix sums 299999 times and then reverse the array. Since 299999>2⋅ 10^5, there is no need to restore the answer. In the fourth example, you cannot get B from the A. 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 directed graph of n vertices and m edges. Vertices are numbered from 1 to n. There is a token in vertex 1. The following actions are allowed: * Token movement. To move the token from vertex u to vertex v if there is an edge u → v in the graph. This action takes 1 second. * Graph transposition. To transpose all the edges in the graph: replace each edge u → v by an edge v → u. This action takes increasingly more time: k-th transposition takes 2^{k-1} seconds, i.e. the first transposition takes 1 second, the second one takes 2 seconds, the third one takes 4 seconds, and so on. The goal is to move the token from vertex 1 to vertex n in the shortest possible time. Print this time modulo 998 244 353. Input The first line of input contains two integers n, m (1 ≤ n, m ≤ 200 000). The next m lines contain two integers each: u, v (1 ≤ u, v ≤ n; u ≠ v), which represent the edges of the graph. It is guaranteed that all ordered pairs (u, v) are distinct. It is guaranteed that it is possible to move the token from vertex 1 to vertex n using the actions above. Output Print one integer: the minimum required time modulo 998 244 353. Examples Input 4 4 1 2 2 3 3 4 4 1 Output 2 Input 4 3 2 1 2 3 4 3 Output 10 Note The first example can be solved by transposing the graph and moving the token to vertex 4, taking 2 seconds. The best way to solve the second example is the following: transpose the graph, move the token to vertex 2, transpose the graph again, move the token to vertex 3, transpose the graph once more and move the token to vertex 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. Monocarp wants to draw four line segments on a sheet of paper. He wants the i-th segment to have its length equal to a_i (1 ≤ i ≤ 4). These segments can intersect with each other, and each segment should be either horizontal or vertical. Monocarp wants to draw the segments in such a way that they enclose a rectangular space, and the area of that rectangular space should be maximum possible. For example, if Monocarp wants to draw four segments with lengths 1, 2, 3 and 4, he can do it the following way: <image> Here, Monocarp has drawn segments AB (with length 1), CD (with length 2), BC (with length 3) and EF (with length 4). He got a rectangle ABCF with area equal to 3 that is enclosed by the segments. Calculate the maximum area of a rectangle Monocarp can enclose with four segments. Input The first line contains one integer t (1 ≤ t ≤ 3 ⋅ 10^4) — the number of test cases. Each test case consists of a single line containing four integers a_1, a_2, a_3, a_4 (1 ≤ a_i ≤ 10^4) — the lengths of the segments Monocarp wants to draw. Output For each test case, print one integer — the maximum area of a rectangle Monocarp can enclose with four segments (it can be shown that the answer is always an integer). Example Input 4 1 2 3 4 5 5 5 5 3 1 4 1 100 20 20 100 Output 3 25 3 2000 Note The first test case of the example is described in the statement. For the second test case, Monocarp can draw the segments AB, BC, CD and DA as follows: <image> Here, Monocarp has drawn segments AB (with length 5), BC (with length 5), CD (with length 5) and DA (with length 5). He got a rectangle ABCD with area equal to 25 that is enclosed by the segments. 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 three integers a, b, k. Find two binary integers x and y (x ≥ y) such that 1. both x and y consist of a zeroes and b ones; 2. x - y (also written in binary form) has exactly k ones. You are not allowed to use leading zeros for x and y. Input The only line contains three integers a, b, and k (0 ≤ a; 1 ≤ b; 0 ≤ k ≤ a + b ≤ 2 ⋅ 10^5) — the number of zeroes, ones, and the number of ones in the result. Output If it's possible to find two suitable integers, print "Yes" followed by x and y in base-2. Otherwise print "No". If there are multiple possible answers, print any of them. Examples Input 4 2 3 Output Yes 101000 100001 Input 3 2 1 Output Yes 10100 10010 Input 3 2 5 Output No Note In the first example, x = 101000_2 = 2^5 + 2^3 = 40_{10}, y = 100001_2 = 2^5 + 2^0 = 33_{10}, 40_{10} - 33_{10} = 7_{10} = 2^2 + 2^1 + 2^0 = 111_{2}. Hence x-y has 3 ones in base-2. In the second example, x = 10100_2 = 2^4 + 2^2 = 20_{10}, y = 10010_2 = 2^4 + 2^1 = 18, x - y = 20 - 18 = 2_{10} = 10_{2}. This is precisely one 1. In the third example, one may show, that it's impossible to find an answer. 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 computers in a row, all originally off, and Phoenix wants to turn all of them on. He will manually turn on computers one at a time. At any point, if computer i-1 and computer i+1 are both on, computer i (2 ≤ i ≤ n-1) will turn on automatically if it is not already on. Note that Phoenix cannot manually turn on a computer that already turned on automatically. If we only consider the sequence of computers that Phoenix turns on manually, how many ways can he turn on all the computers? Two sequences are distinct if either the set of computers turned on manually is distinct, or the order of computers turned on manually is distinct. Since this number may be large, please print it modulo M. Input The first line contains two integers n and M (3 ≤ n ≤ 400; 10^8 ≤ M ≤ 10^9) — the number of computers and the modulo. It is guaranteed that M is prime. Output Print one integer — the number of ways to turn on the computers modulo M. Examples Input 3 100000007 Output 6 Input 4 100000007 Output 20 Input 400 234567899 Output 20914007 Note In the first example, these are the 6 orders in which Phoenix can turn on all computers: * [1,3]. Turn on computer 1, then 3. Note that computer 2 turns on automatically after computer 3 is turned on manually, but we only consider the sequence of computers that are turned on manually. * [3,1]. Turn on computer 3, then 1. * [1,2,3]. Turn on computer 1, 2, then 3. * [2,1,3] * [2,3,1] * [3,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. You are given a sequence A, where its elements are either in the form + x or -, where x is an integer. For such a sequence S where its elements are either in the form + x or -, define f(S) as follows: * iterate through S's elements from the first one to the last one, and maintain a multiset T as you iterate through it. * for each element, if it's in the form + x, add x to T; otherwise, erase the smallest element from T (if T is empty, do nothing). * after iterating through all S's elements, compute the sum of all elements in T. f(S) is defined as the sum. The sequence b is a subsequence of the sequence a if b can be derived from a by removing zero or more elements without changing the order of the remaining elements. For all A's subsequences B, compute the sum of f(B), modulo 998 244 353. Input The first line contains an integer n (1≤ n≤ 500) — the length of A. Each of the next n lines begins with an operator + or -. If the operator is +, then it's followed by an integer x (1≤ x<998 244 353). The i-th line of those n lines describes the i-th element in A. Output Print one integer, which is the answer to the problem, modulo 998 244 353. Examples Input 4 - + 1 + 2 - Output 16 Input 15 + 2432543 - + 4567886 + 65638788 - + 578943 - - + 62356680 - + 711111 - + 998244352 - - Output 750759115 Note In the first example, the following are all possible pairs of B and f(B): * B= {}, f(B)=0. * B= {-}, f(B)=0. * B= {+ 1, -}, f(B)=0. * B= {-, + 1, -}, f(B)=0. * B= {+ 2, -}, f(B)=0. * B= {-, + 2, -}, f(B)=0. * B= {-}, f(B)=0. * B= {-, -}, f(B)=0. * B= {+ 1, + 2}, f(B)=3. * B= {+ 1, + 2, -}, f(B)=2. * B= {-, + 1, + 2}, f(B)=3. * B= {-, + 1, + 2, -}, f(B)=2. * B= {-, + 1}, f(B)=1. * B= {+ 1}, f(B)=1. * B= {-, + 2}, f(B)=2. * B= {+ 2}, f(B)=2. The sum of these values is 16. 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 main server of Gomble company received a log of one top-secret process, the name of which can't be revealed. The log was written in the following format: «[date:time]: message», where for each «[date:time]» value existed not more than 10 lines. All the files were encoded in a very complicated manner, and only one programmer — Alex — managed to decode them. The code was so complicated that Alex needed four weeks to decode it. Right after the decoding process was finished, all the files were deleted. But after the files deletion, Alex noticed that he saved the recordings in format «[time]: message». So, information about the dates was lost. However, as the lines were added into the log in chronological order, it's not difficult to say if the recordings could appear during one day or not. It is possible also to find the minimum amount of days during which the log was written. So, to make up for his mistake Alex has to find the minimum amount of days covered by the log. Note that Alex doesn't have to find the minimum amount of days between the beginning and the end of the logging, he has to find the minimum amount of dates in which records could be done. (See Sample test 2 for further clarifications). We should remind you that the process made not more than 10 recordings in a minute. Consider that a midnight belongs to coming day. Input The first input line contains number n (1 ≤ n ≤ 100). The following n lines contain recordings in format «[time]: message», where time is given in format «hh:mm x.m.». For hh two-digit numbers from 01 to 12 are used, for mm two-digit numbers from 00 to 59 are used, and x is either character «a» or character «p». A message is a non-empty sequence of Latin letters and/or spaces, it doesn't start or end with a space. The length of each message doesn't exceed 20. Output Output one number — the minimum amount of days covered by the log. Examples Input 5 [05:00 a.m.]: Server is started [05:00 a.m.]: Rescan initialized [01:13 p.m.]: Request processed [01:10 p.m.]: Request processed [11:40 p.m.]: Rescan completed Output 2 Input 3 [09:00 a.m.]: User logged in [08:00 a.m.]: User logged in [07:00 a.m.]: User logged in Output 3 Note Formally the 12-hour time format is described at: * http://en.wikipedia.org/wiki/12-hour_clock. The problem authors recommend you to look through these descriptions before you start with the problem. 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. So, the Berland is at war with its eternal enemy Flatland again, and Vasya, an accountant, was assigned to fulfil his duty to the nation. Right now the situation in Berland is dismal — their both cities are surrounded! The armies of flatlanders stand on the borders of circles, the circles' centers are in the surrounded cities. At any moment all points of the flatland ring can begin to move quickly in the direction of the city — that's the strategy the flatlanders usually follow when they besiege cities. The berlanders are sure that they can repel the enemy's attack if they learn the exact time the attack starts. For that they need to construct a radar that would register any movement at the distance of at most r from it. Thus, we can install a radar at such point, that at least one point of the enemy ring will be in its detecting range (that is, at a distance of at most r). Then the radar can immediately inform about the enemy's attack. Due to the newest technologies, we can place a radar at any point without any problems. But the problem is that the berlanders have the time to make only one radar. Besides, the larger the detection radius (r) is, the more the radar costs. That's why Vasya's task (that is, your task) is to find the minimum possible detection radius for the radar. In other words, your task is to find the minimum radius r (r ≥ 0) such, that a radar with radius r can be installed at some point and it can register the start of the movements of both flatland rings from that point. In this problem you can consider the cities as material points, the attacking enemy rings - as circles with centers in the cities, the radar's detection range — as a disk (including the border) with the center at the point where the radar is placed. Input The input files consist of two lines. Each line represents the city and the flatland ring that surrounds it as three space-separated integers xi, yi, ri (\|xi\|, \|yi\| ≤ 104; 1 ≤ ri ≤ 104) — the city's coordinates and the distance from the city to the flatlanders, correspondingly. It is guaranteed that the cities are located at different points. Output Print a single real number — the minimum detection radius of the described radar. The answer is considered correct if the absolute or relative error does not exceed 10 - 6. Examples Input 0 0 1 6 0 3 Output 1.000000000000000 Input -10 10 3 10 -10 3 Output 11.142135623730951 Note The figure below shows the answer to the first sample. In this sample the best decision is to put the radar at point with coordinates (2, 0). <image> The figure below shows the answer for the second sample. In this sample the best decision is to put the radar at point with coordinates (0, 0). <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. Gerald has been selling state secrets at leisure. All the secrets cost the same: n marks. The state which secrets Gerald is selling, has no paper money, only coins. But there are coins of all positive integer denominations that are powers of three: 1 mark, 3 marks, 9 marks, 27 marks and so on. There are no coins of other denominations. Of course, Gerald likes it when he gets money without the change. And all buyers respect him and try to give the desired sum without change, if possible. But this does not always happen. One day an unlucky buyer came. He did not have the desired sum without change. Then he took out all his coins and tried to give Gerald a larger than necessary sum with as few coins as possible. What is the maximum number of coins he could get? The formal explanation of the previous paragraph: we consider all the possible combinations of coins for which the buyer can not give Gerald the sum of n marks without change. For each such combination calculate the minimum number of coins that can bring the buyer at least n marks. Among all combinations choose the maximum of the minimum number of coins. This is the number we want. Input The single line contains a single integer n (1 ≤ n ≤ 1017). 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 In a single line print an integer: the maximum number of coins the unlucky buyer could have paid with. Examples Input 1 Output 1 Input 4 Output 2 Note In the first test case, if a buyer has exactly one coin of at least 3 marks, then, to give Gerald one mark, he will have to give this coin. In this sample, the customer can not have a coin of one mark, as in this case, he will be able to give the money to Gerald without any change. In the second test case, if the buyer had exactly three coins of 3 marks, then, to give Gerald 4 marks, he will have to give two of these coins. The buyer cannot give three coins as he wants to minimize the number of coins that he gives. 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. Hooray! Berl II, the king of Berland is making a knight tournament. The king has already sent the message to all knights in the kingdom and they in turn agreed to participate in this grand event. As for you, you're just a simple peasant. There's no surprise that you slept in this morning and were late for the tournament (it was a weekend, after all). Now you are really curious about the results of the tournament. This time the tournament in Berland went as follows: * There are n knights participating in the tournament. Each knight was assigned his unique number — an integer from 1 to n. * The tournament consisted of m fights, in the i-th fight the knights that were still in the game with numbers at least li and at most ri have fought for the right to continue taking part in the tournament. * After the i-th fight among all participants of the fight only one knight won — the knight number xi, he continued participating in the tournament. Other knights left the tournament. * The winner of the last (the m-th) fight (the knight number xm) became the winner of the tournament. You fished out all the information about the fights from your friends. Now for each knight you want to know the name of the knight he was conquered by. We think that the knight number b was conquered by the knight number a, if there was a fight with both of these knights present and the winner was the knight number a. Write the code that calculates for each knight, the name of the knight that beat him. Input The first line contains two integers n, m (2 ≤ n ≤ 3·105; 1 ≤ m ≤ 3·105) — the number of knights and the number of fights. Each of the following m lines contains three integers li, ri, xi (1 ≤ li < ri ≤ n; li ≤ xi ≤ ri) — the description of the i-th fight. It is guaranteed that the input is correct and matches the problem statement. It is guaranteed that at least two knights took part in each battle. Output Print n integers. If the i-th knight lost, then the i-th number should equal the number of the knight that beat the knight number i. If the i-th knight is the winner, then the i-th number must equal 0. Examples Input 4 3 1 2 1 1 3 3 1 4 4 Output 3 1 4 0 Input 8 4 3 5 4 3 7 6 2 8 8 1 8 1 Output 0 8 4 6 4 8 6 1 Note Consider the first test case. Knights 1 and 2 fought the first fight and knight 1 won. Knights 1 and 3 fought the second fight and knight 3 won. The last fight was between knights 3 and 4, knight 4 won. 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. Vanya loves playing. He even has a special set of cards to play with. Each card has a single integer. The number on the card can be positive, negative and can even be equal to zero. The only limit is, the number on each card doesn't exceed x in the absolute value. Natasha doesn't like when Vanya spends a long time playing, so she hid all of his cards. Vanya became sad and started looking for the cards but he only found n of them. Vanya loves the balance, so he wants the sum of all numbers on found cards equal to zero. On the other hand, he got very tired of looking for cards. Help the boy and say what is the minimum number of cards does he need to find to make the sum equal to zero? You can assume that initially Vanya had infinitely many cards with each integer number from - x to x. Input The first line contains two integers: n (1 ≤ n ≤ 1000) — the number of found cards and x (1 ≤ x ≤ 1000) — the maximum absolute value of the number on a card. The second line contains n space-separated integers — the numbers on found cards. It is guaranteed that the numbers do not exceed x in their absolute value. Output Print a single number — the answer to the problem. Examples Input 3 2 -1 1 2 Output 1 Input 2 3 -2 -2 Output 2 Note In the first sample, Vanya needs to find a single card with number -2. In the second sample, Vanya needs to find two cards with number 2. He can't find a single card with the required number as the numbers on the lost cards do not exceed 3 in their absolute value. 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. Summer is coming! It's time for Iahub and Iahubina to work out, as they both want to look hot at the beach. The gym where they go is a matrix a with n lines and m columns. Let number a[i][j] represents the calories burned by performing workout at the cell of gym in the i-th line and the j-th column. Iahub starts with workout located at line 1 and column 1. He needs to finish with workout a[n][m]. After finishing workout a[i][j], he can go to workout a[i + 1][j] or a[i][j + 1]. Similarly, Iahubina starts with workout a[n][1] and she needs to finish with workout a[1][m]. After finishing workout from cell a[i][j], she goes to either a[i][j + 1] or a[i - 1][j]. There is one additional condition for their training. They have to meet in exactly one cell of gym. At that cell, none of them will work out. They will talk about fast exponentiation (pretty odd small talk) and then both of them will move to the next workout. If a workout was done by either Iahub or Iahubina, it counts as total gain. Please plan a workout for Iahub and Iahubina such as total gain to be as big as possible. Note, that Iahub and Iahubina can perform workouts with different speed, so the number of cells that they use to reach meet cell may differs. Input The first line of the input contains two integers n and m (3 ≤ n, m ≤ 1000). Each of the next n lines contains m integers: j-th number from i-th line denotes element a[i][j] (0 ≤ a[i][j] ≤ 105). Output The output contains a single number — the maximum total gain possible. Examples Input 3 3 100 100 100 100 1 100 100 100 100 Output 800 Note Iahub will choose exercises a[1][1] → a[1][2] → a[2][2] → a[3][2] → a[3][3]. Iahubina will choose exercises a[3][1] → a[2][1] → a[2][2] → a[2][3] → a[1][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. Petya and Gena love playing table tennis. A single match is played according to the following rules: a match consists of multiple sets, each set consists of multiple serves. Each serve is won by one of the players, this player scores one point. As soon as one of the players scores t points, he wins the set; then the next set starts and scores of both players are being set to 0. As soon as one of the players wins the total of s sets, he wins the match and the match is over. Here s and t are some positive integer numbers. To spice it up, Petya and Gena choose new numbers s and t before every match. Besides, for the sake of history they keep a record of each match: that is, for each serve they write down the winner. Serve winners are recorded in the chronological order. In a record the set is over as soon as one of the players scores t points and the match is over as soon as one of the players wins s sets. Petya and Gena have found a record of an old match. Unfortunately, the sequence of serves in the record isn't divided into sets and numbers s and t for the given match are also lost. The players now wonder what values of s and t might be. Can you determine all the possible options? Input The first line contains a single integer n — the length of the sequence of games (1 ≤ n ≤ 105). The second line contains n space-separated integers ai. If ai = 1, then the i-th serve was won by Petya, if ai = 2, then the i-th serve was won by Gena. It is not guaranteed that at least one option for numbers s and t corresponds to the given record. Output In the first line print a single number k — the number of options for numbers s and t. In each of the following k lines print two integers si and ti — the option for numbers s and t. Print the options in the order of increasing si, and for equal si — in the order of increasing ti. Examples Input 5 1 2 1 2 1 Output 2 1 3 3 1 Input 4 1 1 1 1 Output 3 1 4 2 2 4 1 Input 4 1 2 1 2 Output 0 Input 8 2 1 2 1 1 1 1 1 Output 3 1 6 2 3 6 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. While Mike was walking in the subway, all the stuff in his back-bag dropped on the ground. There were several fax messages among them. He concatenated these strings in some order and now he has string s. <image> He is not sure if this is his own back-bag or someone else's. He remembered that there were exactly k messages in his own bag, each was a palindrome string and all those strings had the same length. He asked you to help him and tell him if he has worn his own back-bag. Check if the given string s is a concatenation of k palindromes of the same length. Input The first line of input contains string s containing lowercase English letters (1 ≤ \|s\| ≤ 1000). The second line contains integer k (1 ≤ k ≤ 1000). Output Print "YES"(without quotes) if he has worn his own back-bag or "NO"(without quotes) otherwise. Examples Input saba 2 Output NO Input saddastavvat 2 Output YES Note Palindrome is a string reading the same forward and backward. In the second sample, the faxes in his back-bag can be "saddas" and "tavvat". 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. Limak is an old brown bear. He often plays poker with his friends. Today they went to a casino. There are n players (including Limak himself) and right now all of them have bids on the table. i-th of them has bid with size ai dollars. Each player can double his bid any number of times and triple his bid any number of times. The casino has a great jackpot for making all bids equal. Is it possible that Limak and his friends will win a jackpot? Input First line of input contains an integer n (2 ≤ n ≤ 105), the number of players. The second line contains n integer numbers a1, a2, ..., an (1 ≤ ai ≤ 109) — the bids of players. Output Print "Yes" (without the quotes) if players can make their bids become equal, or "No" otherwise. Examples Input 4 75 150 75 50 Output Yes Input 3 100 150 250 Output No Note In the first sample test first and third players should double their bids twice, second player should double his bid once and fourth player should both double and triple his bid. It can be shown that in the second sample test there is no way to make all bids equal. 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. After making bad dives into swimming pools, Wilbur wants to build a swimming pool in the shape of a rectangle in his backyard. He has set up coordinate axes, and he wants the sides of the rectangle to be parallel to them. Of course, the area of the rectangle must be positive. Wilbur had all four vertices of the planned pool written on a paper, until his friend came along and erased some of the vertices. Now Wilbur is wondering, if the remaining n vertices of the initial rectangle give enough information to restore the area of the planned swimming pool. Input The first line of the input contains a single integer n (1 ≤ n ≤ 4) — the number of vertices that were not erased by Wilbur's friend. Each of the following n lines contains two integers xi and yi ( - 1000 ≤ xi, yi ≤ 1000) —the coordinates of the i-th vertex that remains. Vertices are given in an arbitrary order. It's guaranteed that these points are distinct vertices of some rectangle, that has positive area and which sides are parallel to the coordinate axes. Output Print the area of the initial rectangle if it could be uniquely determined by the points remaining. Otherwise, print - 1. Examples Input 2 0 0 1 1 Output 1 Input 1 1 1 Output -1 Note In the first sample, two opposite corners of the initial rectangle are given, and that gives enough information to say that the rectangle is actually a unit square. In the second sample there is only one vertex left and this is definitely not enough to uniquely define the area. 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 flowerbed has many flowers and two fountains. You can adjust the water pressure and set any values r1(r1 ≥ 0) and r2(r2 ≥ 0), giving the distances at which the water is spread from the first and second fountain respectively. You have to set such r1 and r2 that all the flowers are watered, that is, for each flower, the distance between the flower and the first fountain doesn't exceed r1, or the distance to the second fountain doesn't exceed r2. It's OK if some flowers are watered by both fountains. You need to decrease the amount of water you need, that is set such r1 and r2 that all the flowers are watered and the r12 + r22 is minimum possible. Find this minimum value. Input The first line of the input contains integers n, x1, y1, x2, y2 (1 ≤ n ≤ 2000, - 107 ≤ x1, y1, x2, y2 ≤ 107) — the number of flowers, the coordinates of the first and the second fountain. Next follow n lines. The i-th of these lines contains integers xi and yi ( - 107 ≤ xi, yi ≤ 107) — the coordinates of the i-th flower. It is guaranteed that all n + 2 points in the input are distinct. Output Print the minimum possible value r12 + r22. Note, that in this problem optimal answer is always integer. Examples Input 2 -1 0 5 3 0 2 5 2 Output 6 Input 4 0 0 5 0 9 4 8 3 -1 0 1 4 Output 33 Note The first sample is (r12 = 5, r22 = 1): <image> The second sample is (r12 = 1, r22 = 32): <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. A sportsman starts from point xstart = 0 and runs to point with coordinate xfinish = m (on a straight line). Also, the sportsman can jump — to jump, he should first take a run of length of not less than s meters (in this case for these s meters his path should have no obstacles), and after that he can jump over a length of not more than d meters. Running and jumping is permitted only in the direction from left to right. He can start andfinish a jump only at the points with integer coordinates in which there are no obstacles. To overcome some obstacle, it is necessary to land at a point which is strictly to the right of this obstacle. On the way of an athlete are n obstacles at coordinates x1, x2, ..., xn. He cannot go over the obstacles, he can only jump over them. Your task is to determine whether the athlete will be able to get to the finish point. Input The first line of the input containsd four integers n, m, s and d (1 ≤ n ≤ 200 000, 2 ≤ m ≤ 109, 1 ≤ s, d ≤ 109) — the number of obstacles on the runner's way, the coordinate of the finishing point, the length of running before the jump and the maximum length of the jump, correspondingly. The second line contains a sequence of n integers a1, a2, ..., an (1 ≤ ai ≤ m - 1) — the coordinates of the obstacles. It is guaranteed that the starting and finishing point have no obstacles, also no point can have more than one obstacle, The coordinates of the obstacles are given in an arbitrary order. Output If the runner cannot reach the finishing point, print in the first line of the output "IMPOSSIBLE" (without the quotes). If the athlete can get from start to finish, print any way to do this in the following format: * print a line of form "RUN X>" (where "X" should be a positive integer), if the athlete should run for "X" more meters; * print a line of form "JUMP Y" (where "Y" should be a positive integer), if the sportsman starts a jump and should remain in air for "Y" more meters. All commands "RUN" and "JUMP" should strictly alternate, starting with "RUN", besides, they should be printed chronologically. It is not allowed to jump over the finishing point but it is allowed to land there after a jump. The athlete should stop as soon as he reaches finish. Examples Input 3 10 1 3 3 4 7 Output RUN 2 JUMP 3 RUN 1 JUMP 2 RUN 2 Input 2 9 2 3 6 4 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. It is well known that the planet suffers from the energy crisis. Little Petya doesn't like that and wants to save the world. For this purpose he needs every accumulator to contain the same amount of energy. Initially every accumulator has some amount of energy: the i-th accumulator has ai units of energy. Energy can be transferred from one accumulator to the other. Every time x units of energy are transferred (x is not necessarily an integer) k percent of it is lost. That is, if x units were transferred from one accumulator to the other, amount of energy in the first one decreased by x units and in other increased by <image> units. Your task is to help Petya find what maximum equal amount of energy can be stored in each accumulator after the transfers. Input First line of the input contains two integers n and k (1 ≤ n ≤ 10000, 0 ≤ k ≤ 99) — number of accumulators and the percent of energy that is lost during transfers. Next line contains n integers a1, a2, ... , an — amounts of energy in the first, second, .., n-th accumulator respectively (0 ≤ ai ≤ 1000, 1 ≤ i ≤ n). Output Output maximum possible amount of energy that can remain in each of accumulators after the transfers of energy. The absolute or relative error in the answer should not exceed 10 - 6. Examples Input 3 50 4 2 1 Output 2.000000000 Input 2 90 1 11 Output 1.909090909 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. ZS the Coder has recently found an interesting concept called the Birthday Paradox. It states that given a random set of 23 people, there is around 50% chance that some two of them share the same birthday. ZS the Coder finds this very interesting, and decides to test this with the inhabitants of Udayland. In Udayland, there are 2n days in a year. ZS the Coder wants to interview k people from Udayland, each of them has birthday in one of 2n days (each day with equal probability). He is interested in the probability of at least two of them have the birthday at the same day. ZS the Coder knows that the answer can be written as an irreducible fraction <image>. He wants to find the values of A and B (he does not like to deal with floating point numbers). Can you help him? Input The first and only line of the input contains two integers n and k (1 ≤ n ≤ 1018, 2 ≤ k ≤ 1018), meaning that there are 2n days in a year and that ZS the Coder wants to interview exactly k people. Output If the probability of at least two k people having the same birthday in 2n days long year equals <image> (A ≥ 0, B ≥ 1, <image>), print the A and B in a single line. Since these numbers may be too large, print them modulo 106 + 3. Note that A and B must be coprime before their remainders modulo 106 + 3 are taken. Examples Input 3 2 Output 1 8 Input 1 3 Output 1 1 Input 4 3 Output 23 128 Note In the first sample case, there are 23 = 8 days in Udayland. The probability that 2 people have the same birthday among 2 people is clearly <image>, so A = 1, B = 8. In the second sample case, there are only 21 = 2 days in Udayland, but there are 3 people, so it is guaranteed that two of them have the same birthday. Thus, the probability is 1 and A = B = 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. Bob recently read about bitwise operations used in computers: AND, OR and XOR. He have studied their properties and invented a new game. Initially, Bob chooses integer m, bit depth of the game, which means that all numbers in the game will consist of m bits. Then he asks Peter to choose some m-bit number. After that, Bob computes the values of n variables. Each variable is assigned either a constant m-bit number or result of bitwise operation. Operands of the operation may be either variables defined before, or the number, chosen by Peter. After that, Peter's score equals to the sum of all variable values. Bob wants to know, what number Peter needs to choose to get the minimum possible score, and what number he needs to choose to get the maximum possible score. In both cases, if there are several ways to get the same score, find the minimum number, which he can choose. Input The first line contains two integers n and m, the number of variables and bit depth, respectively (1 ≤ n ≤ 5000; 1 ≤ m ≤ 1000). The following n lines contain descriptions of the variables. Each line describes exactly one variable. Description has the following format: name of a new variable, space, sign ":=", space, followed by one of: 1. Binary number of exactly m bits. 2. The first operand, space, bitwise operation ("AND", "OR" or "XOR"), space, the second operand. Each operand is either the name of variable defined before or symbol '?', indicating the number chosen by Peter. Variable names are strings consisting of lowercase Latin letters with length at most 10. All variable names are different. Output In the first line output the minimum number that should be chosen by Peter, to make the sum of all variable values minimum possible, in the second line output the minimum number that should be chosen by Peter, to make the sum of all variable values maximum possible. Both numbers should be printed as m-bit binary numbers. Examples Input 3 3 a := 101 b := 011 c := ? XOR b Output 011 100 Input 5 1 a := 1 bb := 0 cx := ? OR a d := ? XOR ? e := d AND bb Output 0 0 Note In the first sample if Peter chooses a number 0112, then a = 1012, b = 0112, c = 0002, the sum of their values is 8. If he chooses the number 1002, then a = 1012, b = 0112, c = 1112, the sum of their values is 15. For the second test, the minimum and maximum sum of variables a, bb, cx, d and e is 2, and this sum doesn't depend on the number chosen by Peter, so the minimum Peter can choose is 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. Polycarp has just invented a new binary protocol for data transmission. He is encoding positive integer decimal number to binary string using following algorithm: * Each digit is represented with number of '1' characters equal to the value of that digit (for 0 it is zero ones). * Digits are written one by one in order corresponding to number and separated by single '0' character. Though Polycarp learnt how to encode the numbers, he has no idea how to decode them back. Help him calculate the decoded number. Input The first line contains one integer number n (1 ≤ n ≤ 89) — length of the string s. The second line contains string s — sequence of '0' and '1' characters, number in its encoded format. It is guaranteed that the number corresponding to the string is positive and doesn't exceed 109. The string always starts with '1'. Output Print the decoded number. Examples Input 3 111 Output 3 Input 9 110011101 Output 2031 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 the computer network of the Berland State University there are n routers numbered from 1 to n. Some pairs of routers are connected by patch cords. Information can be transmitted over patch cords in both direction. The network is arranged in such a way that communication between any two routers (directly or through other routers) is possible. There are no cycles in the network, so there is only one path between each pair of routers over patch cords. Unfortunately, the exact topology of the network was lost by administrators. In order to restore it, the following auxiliary information was collected. For each patch cord p, directly connected to the router i, list of routers located behind the patch cord p relatively i is known. In other words, all routers path from which to the router i goes through p are known. So for each router i there are ki lists, where ki is the number of patch cords connected to i. For example, let the network consists of three routers connected in chain 1 - 2 - 3. Then: * the router 1: for the single patch cord connected to the first router there is a single list containing two routers: 2 and 3; * the router 2: for each of the patch cords connected to the second router there is a list: one list contains the router 1 and the other — the router 3; * the router 3: for the single patch cord connected to the third router there is a single list containing two routers: 1 and 2. Your task is to help administrators to restore the network topology, i. e. to identify all pairs of routers directly connected by a patch cord. Input The first line contains a single integer n (2 ≤ n ≤ 1000) — the number of routers in the network. The i-th of the following n lines contains a description of the lists for the router i. The description of each list begins with the number of routers in it. Then the symbol ':' follows, and after that the numbers of routers from the list are given. This numbers are separated by comma. Lists are separated by symbol '-'. It is guaranteed, that for each router i the total number of routers in its lists equals to n - 1 and all the numbers in lists of each router are distinct. For each router i lists do not contain the number i. Output Print -1 if no solution exists. In the other case print to the first line n - 1 — the total number of patch cords in the network. In each of the following n - 1 lines print two integers — the routers which are directly connected by a patch cord. Information about each patch cord must be printed exactly once. Patch cords and routers can be printed in arbitrary order. Examples Input 3 2:3,2 1:1-1:3 2:1,2 Output 2 2 1 2 3 Input 5 4:2,5,3,4 1:4-1:1-2:5,3 4:4,5,2,1 4:2,1,3,5 1:3-3:4,2,1 Output 4 2 1 2 4 5 2 3 5 Input 3 1:2-1:3 1:1-1:3 1:1-1:2 Output -1 Note The first example is analyzed in the statement. The answer to the second example is shown on the picture. <image> The first router has one list, which contains all other routers. The second router has three lists: the first — the single router 4, the second — the single router 1, the third — two routers 3 and 5. The third router has one list, which contains all other routers. The fourth router also has one list, which contains all other routers. The fifth router has two lists: the first — the single router 3, the second — three routers 1, 2 and 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. What are you doing at the end of the world? Are you busy? Will you save us? <image> Nephren is playing a game with little leprechauns. She gives them an infinite array of strings, f0... ∞. f0 is "What are you doing at the end of the world? Are you busy? Will you save us?". She wants to let more people know about it, so she defines fi = "What are you doing while sending "fi - 1"? Are you busy? Will you send "fi - 1"?" for all i ≥ 1. For example, f1 is "What are you doing while sending "What are you doing at the end of the world? Are you busy? Will you save us?"? Are you busy? Will you send "What are you doing at the end of the world? Are you busy? Will you save us?"?". Note that the quotes in the very beginning and in the very end are for clarity and are not a part of f1. It can be seen that the characters in fi are letters, question marks, (possibly) quotation marks and spaces. Nephren will ask the little leprechauns q times. Each time she will let them find the k-th character of fn. The characters are indexed starting from 1. If fn consists of less than k characters, output '.' (without quotes). Can you answer her queries? Input The first line contains one integer q (1 ≤ q ≤ 10) — the number of Nephren's questions. Each of the next q lines describes Nephren's question and contains two integers n and k (0 ≤ n ≤ 105, 1 ≤ k ≤ 1018). Output One line containing q characters. The i-th character in it should be the answer for the i-th query. Examples Input 3 1 1 1 2 1 111111111111 Output Wh. Input 5 0 69 1 194 1 139 0 47 1 66 Output abdef Input 10 4 1825 3 75 3 530 4 1829 4 1651 3 187 4 584 4 255 4 774 2 474 Output Areyoubusy Note For the first two examples, refer to f0 and f1 given in the legend. 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 we all know, Max is the best video game player among her friends. Her friends were so jealous of hers, that they created an actual game just to prove that she's not the best at games. The game is played on a directed acyclic graph (a DAG) with n vertices and m edges. There's a character written on each edge, a lowercase English letter. <image> Max and Lucas are playing the game. Max goes first, then Lucas, then Max again and so on. Each player has a marble, initially located at some vertex. Each player in his/her turn should move his/her marble along some edge (a player can move the marble from vertex v to vertex u if there's an outgoing edge from v to u). If the player moves his/her marble from vertex v to vertex u, the "character" of that round is the character written on the edge from v to u. There's one additional rule; the ASCII code of character of round i should be greater than or equal to the ASCII code of character of round i - 1 (for i > 1). The rounds are numbered for both players together, i. e. Max goes in odd numbers, Lucas goes in even numbers. The player that can't make a move loses the game. The marbles may be at the same vertex at the same time. Since the game could take a while and Lucas and Max have to focus on finding Dart, they don't have time to play. So they asked you, if they both play optimally, who wins the game? You have to determine the winner of the game for all initial positions of the marbles. Input The first line of input contains two integers n and m (2 ≤ n ≤ 100, <image>). The next m lines contain the edges. Each line contains two integers v, u and a lowercase English letter c, meaning there's an edge from v to u written c on it (1 ≤ v, u ≤ n, v ≠ u). There's at most one edge between any pair of vertices. It is guaranteed that the graph is acyclic. Output Print n lines, a string of length n in each one. The j-th character in i-th line should be 'A' if Max will win the game in case her marble is initially at vertex i and Lucas's marble is initially at vertex j, and 'B' otherwise. Examples Input 4 4 1 2 b 1 3 a 2 4 c 3 4 b Output BAAA ABAA BBBA BBBB Input 5 8 5 3 h 1 2 c 3 1 c 3 2 r 5 1 r 4 3 z 5 4 r 5 2 h Output BABBB BBBBB AABBB AAABA AAAAB Note Here's the graph in the first sample test case: <image> Here's the graph in the second sample test 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.

Subsets and Splits

No community queries yet

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