Split (1)

train · 24.3k rows

question large_stringlengths 265 13.2k
Solve the programming task below in a Python markdown code block. You are both a shop keeper and a shop assistant at a small nearby shop. You have n goods, the i-th good costs a_i coins. You got tired of remembering the price of each product when customers ask for it, thus you decided to simplify your life. More precisely you decided to set the same price for all n goods you have. However, you don't want to lose any money so you want to choose the price in such a way that the sum of new prices is not less than the sum of the initial prices. It means that if you sell all n goods for the new price, you will receive at least the same (or greater) amount of money as if you sell them for their initial prices. On the other hand, you don't want to lose customers because of big prices so among all prices you can choose you need to choose the minimum one. So you need to find the minimum possible equal price of all n goods so if you sell them for this price, you will receive at least the same (or greater) amount of money as if you sell them for their initial prices. You have to answer q independent queries. Input The first line of the input contains one integer q (1 ≤ q ≤ 100) — the number of queries. Then q queries follow. The first line of the query contains one integer n (1 ≤ n ≤ 100) — the number of goods. The second line of the query contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^7), where a_i is the price of the i-th good. Output For each query, print the answer for it — the minimum possible equal price of all n goods so if you sell them for this price, you will receive at least the same (or greater) amount of money as if you sell them for their initial prices. Example Input 3 5 1 2 3 4 5 3 1 2 2 4 1 1 1 1 Output 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. A queen is the strongest chess piece. In modern chess the queen can move any number of squares in any horizontal, vertical or diagonal direction (considering that there're no other pieces on its way). The queen combines the options given to the rook and the bishop. There are m queens on a square n × n chessboard. You know each queen's positions, the i-th queen is positioned in the square (ri, ci), where ri is the board row number (numbered from the top to the bottom from 1 to n), and ci is the board's column number (numbered from the left to the right from 1 to n). No two queens share the same position. For each queen one can count w — the number of other queens that the given queen threatens (attacks). For a fixed attack direction only the first queen in this direction is under attack if there are many queens are on the ray of the attack. Obviously, for any queen w is between 0 and 8, inclusive. Print the sequence t0, t1, ..., t8, where ti is the number of queens that threaten exactly i other queens, i.e. the number of queens that their w equals i. Input The first line of the input contains a pair of integers n, m (1 ≤ n, m ≤ 105), where n is the size of the board and m is the number of queens on the board. Then m following lines contain positions of the queens, one per line. Each line contains a pair of integers ri, ci (1 ≤ ri, ci ≤ n) — the queen's position. No two queens stand on the same square. Output Print the required sequence t0, t1, ..., t8, separating the numbers with spaces. Examples Input 8 4 4 3 4 8 6 5 1 6 Output 0 3 0 1 0 0 0 0 0 Input 10 3 1 1 1 2 1 3 Output 0 2 1 0 0 0 0 0 0 The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. You are given n strings a_1, a_2, …, a_n: all of them have the same length m. The strings consist of lowercase English letters. Find any string s of length m such that each of the given n strings differs from s in at most one position. Formally, for each given string a_i, there is no more than one position j such that a_i[j] ≠ s[j]. Note that the desired string s may be equal to one of the given strings a_i, or it may differ from all the given strings. For example, if you have the strings abac and zbab, then the answer to the problem might be the string abab, which differs from the first only by the last character, and from the second only by the first. Input The first line contains an integer t (1 ≤ t ≤ 100) — the number of test cases. Then t test cases follow. Each test case starts with a line containing two positive integers n (1 ≤ n ≤ 10) and m (1 ≤ m ≤ 10) — the number of strings and their length. Then follow n strings a_i, one per line. Each of them has length m and consists of lowercase English letters. Output Print t answers to the test cases. Each answer (if it exists) is a string of length m consisting of lowercase English letters. If there are several answers, print any of them. If the answer does not exist, print "-1" ("minus one", without quotes). Example Input 5 2 4 abac zbab 2 4 aaaa bbbb 3 3 baa aaa aab 2 2 ab bb 3 1 a b c Output abab -1 aaa ab z Note The first test case was explained in the statement. In the second test case, the answer does not exist. 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 creating a level for a video game. The level consists of n rooms placed in a circle. The rooms are numbered 1 through n. Each room contains exactly one exit: completing the j-th room allows you to go the (j+1)-th room (and completing the n-th room allows you to go the 1-st room). You are given the description of the multiset of n chests: the i-th chest has treasure value c_i. Each chest can be of one of two types: * regular chest — when a player enters a room with this chest, he grabs the treasure and proceeds to the next room; * mimic chest — when a player enters a room with this chest, the chest eats him alive, and he loses. The player starts in a random room with each room having an equal probability of being chosen. The players earnings is equal to the total value of treasure chests he'd collected before he lost. You are allowed to choose the order the chests go into the rooms. For each k from 1 to n place the chests into the rooms in such a way that: * each room contains exactly one chest; * exactly k chests are mimics; * the expected value of players earnings is minimum possible. Please note that for each k the placement is chosen independently. It can be shown that it is in the form of P/Q where P and Q are non-negative integers and Q ≠ 0. Report the values of P ⋅ Q^{-1} \pmod {998244353}. Input The first contains a single integer n (2 ≤ n ≤ 3 ⋅ 10^5) — the number of rooms and the number of chests. The second line contains n integers c_1, c_2, ..., c_n (1 ≤ c_i ≤ 10^6) — the treasure values of each chest. Output Print n integers — the k -th value should be equal to the minimum possible expected value of players earnings if the chests are placed into the rooms in some order and exactly k of the chests are mimics. It can be shown that it is in the form of P/Q where P and Q are non-negative integers and Q ≠ 0. Report the values of P ⋅ Q^{-1} \pmod {998244353}. Examples Input 2 1 2 Output 499122177 0 Input 8 10 4 3 6 5 10 7 5 Output 499122193 249561095 249561092 873463811 499122178 124780545 623902721 0 Note In the first example the exact values of minimum expected values are: \frac 1 2, \frac 0 2. In the second example the exact values of minimum expected values are: \frac{132} 8, \frac{54} 8, \frac{30} 8, \frac{17} 8, \frac{12} 8, \frac 7 8, \frac 3 8, \frac 0 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. During one of the space missions, humans have found an evidence of previous life at one of the planets. They were lucky enough to find a book with birth and death years of each individual that had been living at this planet. What's interesting is that these years are in the range (1, 10^9)! Therefore, the planet was named Longlifer. In order to learn more about Longlifer's previous population, scientists need to determine the year with maximum number of individuals that were alive, as well as the number of alive individuals in that year. Your task is to help scientists solve this problem! Input The first line contains an integer n (1 ≤ n ≤ 10^5) — the number of people. Each of the following n lines contain two integers b and d (1 ≤ b < d ≤ 10^9) representing birth and death year (respectively) of each individual. Output Print two integer numbers separated by blank character, y — the year with a maximum number of people alive and k — the number of people alive in year y. In the case of multiple possible solutions, print the solution with minimum year. Examples Input 3 1 5 2 4 5 6 Output 2 2 Input 4 3 4 4 5 4 6 8 10 Output 4 2 Note You can assume that an individual living from b to d has been born at the beginning of b and died at the beginning of d, and therefore living for d - b years. 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. Oleg's favorite subjects are History and Math, and his favorite branch of mathematics is division. To improve his division skills, Oleg came up with t pairs of integers p_i and q_i and for each pair decided to find the greatest integer x_i, such that: * p_i is divisible by x_i; * x_i is not divisible by q_i. Oleg is really good at division and managed to find all the answers quickly, how about you? Input The first line contains an integer t (1 ≤ t ≤ 50) — the number of pairs. Each of the following t lines contains two integers p_i and q_i (1 ≤ p_i ≤ 10^{18}; 2 ≤ q_i ≤ 10^{9}) — the i-th pair of integers. Output Print t integers: the i-th integer is the largest x_i such that p_i is divisible by x_i, but x_i is not divisible by q_i. One can show that there is always at least one value of x_i satisfying the divisibility conditions for the given constraints. Example Input 3 10 4 12 6 179 822 Output 10 4 179 Note For the first pair, where p_1 = 10 and q_1 = 4, the answer is x_1 = 10, since it is the greatest divisor of 10 and 10 is not divisible by 4. For the second pair, where p_2 = 12 and q_2 = 6, note that * 12 is not a valid x_2, since 12 is divisible by q_2 = 6; * 6 is not valid x_2 as well: 6 is also divisible by q_2 = 6. The next available divisor of p_2 = 12 is 4, which is the answer, since 4 is not divisible by 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. Petya loves lucky numbers very much. Everybody knows that lucky numbers are positive integers whose decimal record contains only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not. Petya has two strings a and b of the same length n. The strings consist only of lucky digits. Petya can perform operations of two types: * replace any one digit from string a by its opposite (i.e., replace 4 by 7 and 7 by 4); * swap any pair of digits in string a. Petya is interested in the minimum number of operations that are needed to make string a equal to string b. Help him with the task. Input The first and the second line contains strings a and b, correspondingly. Strings a and b have equal lengths and contain only lucky digits. The strings are not empty, their length does not exceed 105. Output Print on the single line the single number — the minimum number of operations needed to convert string a into string b. Examples Input 47 74 Output 1 Input 774 744 Output 1 Input 777 444 Output 3 Note In the first sample it is enough simply to swap the first and the second digit. In the second sample we should replace the second digit with its opposite. In the third number we should replace all three digits with their opposites. 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 n × m grid. You are standing at cell (1, 1) and your goal is to finish at cell (n, m). You can move to the neighboring cells to the right or down. In other words, suppose you are standing at cell (x, y). You can: * move right to the cell (x, y + 1) — it costs x burles; * move down to the cell (x + 1, y) — it costs y burles. Can you reach cell (n, m) spending exactly k burles? Input The first line contains the single integer t (1 ≤ t ≤ 100) — the number of test cases. The first and only line of each test case contains three integers n, m, and k (1 ≤ n, m ≤ 100; 0 ≤ k ≤ 10^4) — the sizes of grid and the exact amount of money you need to spend. Output For each test case, if you can reach cell (n, m) spending exactly k burles, print YES. Otherwise, print NO. You may print every letter in any case you want (so, for example, the strings yEs, yes, Yes and YES are all recognized as positive answer). Example Input 6 1 1 0 2 2 2 2 2 3 2 2 4 1 4 3 100 100 10000 Output YES NO YES NO YES NO Note In the first test case, you are already in the final cell, so you spend 0 burles. In the second, third and fourth test cases, there are two paths from (1, 1) to (2, 2): (1, 1) → (1, 2) → (2, 2) or (1, 1) → (2, 1) → (2, 2). Both costs 1 + 2 = 3 burles, so it's the only amount of money you can spend. In the fifth test case, there is the only way from (1, 1) to (1, 4) and it costs 1 + 1 + 1 = 3 burles. 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. AquaMoon had n strings of length m each. n is an odd number. When AquaMoon was gone, Cirno tried to pair these n strings together. After making (n-1)/(2) pairs, she found out that there was exactly one string without the pair! In her rage, she disrupted each pair of strings. For each pair, she selected some positions (at least 1 and at most m) and swapped the letters in the two strings of this pair at the selected positions. For example, if m = 6 and two strings "abcdef" and "xyzklm" are in one pair and Cirno selected positions 2, 3 and 6 she will swap 'b' with 'y', 'c' with 'z' and 'f' with 'm'. The resulting strings will be "ayzdem" and "xbcklf". Cirno then stole away the string without pair and shuffled all remaining strings in arbitrary order. AquaMoon found the remaining n-1 strings in complete disarray. Also, she remembers the initial n strings. She wants to know which string was stolen, but she is not good at programming. Can you help her? Input This problem is made as interactive. It means, that your solution will read the input, given by the interactor. But the interactor will give you the full input at the beginning and after that, you should print the answer. So you should solve the problem, like as you solve the usual, non-interactive problem because you won't have any interaction process. The only thing you should not forget is to flush the output buffer, after printing the answer. Otherwise, you can get an "Idleness limit exceeded" verdict. Refer to the [interactive problems guide](https://codeforces.com/blog/entry/45307) for the detailed information about flushing the output buffer. The input consists of multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases. The first line of each test case contains two integers n, m (1 ≤ n ≤ 10^5, 1 ≤ m ≤ 10^5) — the number of strings and the length of each string, respectively. The next n lines each contain a string with length m, describing the original n strings. All string consists of lowercase Latin letters. The next n-1 lines each contain a string with length m, describing the strings after Cirno exchanged and reordered them. It is guaranteed that n is odd and that the sum of n ⋅ m over all test cases does not exceed 10^5. Hack format: The first line should contain a single integer t. After that t test cases should follow in the following format: The first line should contain two integers n and m. The following n lines should contain n strings of length m, describing the original strings. The following (n-1)/(2) lines should describe the pairs. They should contain, in the following order: the index of the first string i (1 ≤ i ≤ n), the index of the second string j (1 ≤ j ≤ n, i ≠ j), the number of exchanged positions k (1 ≤ k ≤ m), and the list of k positions that are exchanged (k distinct indices from 1 to m in any order). The final line should contain a permutation of integers from 1 to n, describing the way the strings should be reordered. The strings will be placed in the order indices placed in this permutation, the stolen string index will be ignored. Output For each test case print a single line with the stolen string. Example Input 3 3 5 aaaaa bbbbb ccccc aaaaa bbbbb 3 4 aaaa bbbb cccc aabb bbaa 5 6 abcdef uuuuuu kekeke ekekek xyzklm xbcklf eueueu ayzdem ukukuk Output ccccc cccc kekeke Note In the first test case, "aaaaa" and "bbbbb" exchanged all positions, and "ccccc" is the stolen string. In the second test case, "aaaa" and "bbbb" exchanged two first positions, and "cccc" is the stolen string. This is the first test in the hack format: 3 3 5 aaaaa bbbbb ccccc 1 2 5 1 2 3 4 5 2 1 3 3 4 aaaa bbbb cccc 1 2 2 1 2 2 1 3 5 6 abcdef uuuuuu kekeke ekekek xyzklm 1 5 3 2 3 6 2 4 3 2 4 6 5 4 1 2 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. During the break the schoolchildren, boys and girls, formed a queue of n people in the canteen. Initially the children stood in the order they entered the canteen. However, after a while the boys started feeling awkward for standing in front of the girls in the queue and they started letting the girls move forward each second. Let's describe the process more precisely. Let's say that the positions in the queue are sequentially numbered by integers from 1 to n, at that the person in the position number 1 is served first. Then, if at time x a boy stands on the i-th position and a girl stands on the (i + 1)-th position, then at time x + 1 the i-th position will have a girl and the (i + 1)-th position will have a boy. The time is given in seconds. You've got the initial position of the children, at the initial moment of time. Determine the way the queue is going to look after t seconds. Input The first line contains two integers n and t (1 ≤ n, t ≤ 50), which represent the number of children in the queue and the time after which the queue will transform into the arrangement you need to find. The next line contains string s, which represents the schoolchildren's initial arrangement. If the i-th position in the queue contains a boy, then the i-th character of string s equals "B", otherwise the i-th character equals "G". Output Print string a, which describes the arrangement after t seconds. If the i-th position has a boy after the needed time, then the i-th character a must equal "B", otherwise it must equal "G". Examples Input 5 1 BGGBG Output GBGGB Input 5 2 BGGBG Output GGBGB Input 4 1 GGGB Output GGGB 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. Sereja has got an array, consisting of n integers, a1, a2, ..., an. Sereja is an active boy, so he is now going to complete m operations. Each operation will have one of the three forms: 1. Make vi-th array element equal to xi. In other words, perform the assignment avi = xi. 2. Increase each array element by yi. In other words, perform n assignments ai = ai + yi (1 ≤ i ≤ n). 3. Take a piece of paper and write out the qi-th array element. That is, the element aqi. Help Sereja, complete all his operations. Input The first line contains integers n, m (1 ≤ n, m ≤ 105). The second line contains n space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 109) — the original array. Next m lines describe operations, the i-th line describes the i-th operation. The first number in the i-th line is integer ti (1 ≤ ti ≤ 3) that represents the operation type. If ti = 1, then it is followed by two integers vi and xi, (1 ≤ vi ≤ n, 1 ≤ xi ≤ 109). If ti = 2, then it is followed by integer yi (1 ≤ yi ≤ 104). And if ti = 3, then it is followed by integer qi (1 ≤ qi ≤ n). Output For each third type operation print value aqi. Print the values in the order, in which the corresponding queries follow in the input. Examples Input 10 11 1 2 3 4 5 6 7 8 9 10 3 2 3 9 2 10 3 1 3 10 1 1 10 2 10 2 10 3 1 3 10 3 9 Output 2 9 11 20 30 40 39 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. Paladin Manao caught the trail of the ancient Book of Evil in a swampy area. This area contains n settlements numbered from 1 to n. Moving through the swamp is very difficult, so people tramped exactly n - 1 paths. Each of these paths connects some pair of settlements and is bidirectional. Moreover, it is possible to reach any settlement from any other one by traversing one or several paths. The distance between two settlements is the minimum number of paths that have to be crossed to get from one settlement to the other one. Manao knows that the Book of Evil has got a damage range d. This means that if the Book of Evil is located in some settlement, its damage (for example, emergence of ghosts and werewolves) affects other settlements at distance d or less from the settlement where the Book resides. Manao has heard of m settlements affected by the Book of Evil. Their numbers are p1, p2, ..., pm. Note that the Book may be affecting other settlements as well, but this has not been detected yet. Manao wants to determine which settlements may contain the Book. Help him with this difficult task. Input The first line contains three space-separated integers n, m and d (1 ≤ m ≤ n ≤ 100000; 0 ≤ d ≤ n - 1). The second line contains m distinct space-separated integers p1, p2, ..., pm (1 ≤ pi ≤ n). Then n - 1 lines follow, each line describes a path made in the area. A path is described by a pair of space-separated integers ai and bi representing the ends of this path. Output Print a single number — the number of settlements that may contain the Book of Evil. It is possible that Manao received some controversial information and there is no settlement that may contain the Book. In such case, print 0. Examples Input 6 2 3 1 2 1 5 2 3 3 4 4 5 5 6 Output 3 Note Sample 1. The damage range of the Book of Evil equals 3 and its effects have been noticed in settlements 1 and 2. Thus, it can be in settlements 3, 4 or 5. <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. Levko loves array a1, a2, ... , an, consisting of integers, very much. That is why Levko is playing with array a, performing all sorts of operations with it. Each operation Levko performs is of one of two types: 1. Increase all elements from li to ri by di. In other words, perform assignments aj = aj + di for all j that meet the inequation li ≤ j ≤ ri. 2. Find the maximum of elements from li to ri. That is, calculate the value <image>. Sadly, Levko has recently lost his array. Fortunately, Levko has records of all operations he has performed on array a. Help Levko, given the operation records, find at least one suitable array. The results of all operations for the given array must coincide with the record results. Levko clearly remembers that all numbers in his array didn't exceed 109 in their absolute value, so he asks you to find such an array. Input The first line contains two integers n and m (1 ≤ n, m ≤ 5000) — the size of the array and the number of operations in Levko's records, correspondingly. Next m lines describe the operations, the i-th line describes the i-th operation. The first integer in the i-th line is integer ti (1 ≤ ti ≤ 2) that describes the operation type. If ti = 1, then it is followed by three integers li, ri and di (1 ≤ li ≤ ri ≤ n, - 104 ≤ di ≤ 104) — the description of the operation of the first type. If ti = 2, then it is followed by three integers li, ri and mi (1 ≤ li ≤ ri ≤ n, - 5·107 ≤ mi ≤ 5·107) — the description of the operation of the second type. The operations are given in the order Levko performed them on his array. Output In the first line print "YES" (without the quotes), if the solution exists and "NO" (without the quotes) otherwise. If the solution exists, then on the second line print n integers a1, a2, ... , an (\|ai\| ≤ 109) — the recovered array. Examples Input 4 5 1 2 3 1 2 1 2 8 2 3 4 7 1 1 3 3 2 3 4 8 Output YES 4 7 4 7 Input 4 5 1 2 3 1 2 1 2 8 2 3 4 7 1 1 3 3 2 3 4 13 Output NO The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Valera had an undirected connected graph without self-loops and multiple edges consisting of n vertices. The graph had an interesting property: there were at most k edges adjacent to each of its vertices. For convenience, we will assume that the graph vertices were indexed by integers from 1 to n. One day Valera counted the shortest distances from one of the graph vertices to all other ones and wrote them out in array d. Thus, element d[i] of the array shows the shortest distance from the vertex Valera chose to vertex number i. Then something irreparable terrible happened. Valera lost the initial graph. However, he still has the array d. Help him restore the lost graph. Input The first line contains two space-separated integers n and k (1 ≤ k < n ≤ 105). Number n shows the number of vertices in the original graph. Number k shows that at most k edges were adjacent to each vertex in the original graph. The second line contains space-separated integers d[1], d[2], ..., d[n] (0 ≤ d[i] < n). Number d[i] shows the shortest distance from the vertex Valera chose to the vertex number i. Output If Valera made a mistake in his notes and the required graph doesn't exist, print in the first line number -1. Otherwise, in the first line print integer m (0 ≤ m ≤ 106) — the number of edges in the found graph. In each of the next m lines print two space-separated integers ai and bi (1 ≤ ai, bi ≤ n; ai ≠ bi), denoting the edge that connects vertices with numbers ai and bi. The graph shouldn't contain self-loops and multiple edges. If there are multiple possible answers, print any of them. Examples Input 3 2 0 1 1 Output 3 1 2 1 3 3 2 Input 4 2 2 0 1 3 Output 3 1 3 1 4 2 3 Input 3 1 0 0 0 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. One day, after a difficult lecture a diligent student Sasha saw a graffitied desk in the classroom. She came closer and read: "Find such positive integer n, that among numbers n + 1, n + 2, ..., 2·n there are exactly m numbers which binary representation contains exactly k digits one". The girl got interested in the task and she asked you to help her solve it. Sasha knows that you are afraid of large numbers, so she guaranteed that there is an answer that doesn't exceed 1018. Input The first line contains two space-separated integers, m and k (0 ≤ m ≤ 1018; 1 ≤ k ≤ 64). Output Print the required number n (1 ≤ n ≤ 1018). If there are multiple answers, print any of them. Examples Input 1 1 Output 1 Input 3 2 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. Twilight Sparkle once got a crystal from the Crystal Mine. A crystal of size n (n is odd; n > 1) is an n × n matrix with a diamond inscribed into it. You are given an odd integer n. You need to draw a crystal of size n. The diamond cells of the matrix should be represented by character "D". All other cells of the matrix should be represented by character "". Look at the examples to understand what you need to draw. Input The only line contains an integer n (3 ≤ n ≤ 101; n is odd). Output Output a crystal of size n. Examples Input 3 Output D* DDD D Input 5 Output D DDD DDDDD DDD D Input 7 Output *D* DDD DDDDD DDDDDDD DDDDD DDD *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. Dreamoon likes to play with sets, integers and <image>. <image> is defined as the largest positive integer that divides both a and b. Let S be a set of exactly four distinct integers greater than 0. Define S to be of rank k if and only if for all pairs of distinct elements si, sj from S, <image>. Given k and n, Dreamoon wants to make up n sets of rank k using integers from 1 to m such that no integer is used in two different sets (of course you can leave some integers without use). Calculate the minimum m that makes it possible and print one possible solution. Input The single line of the input contains two space separated integers n, k (1 ≤ n ≤ 10 000, 1 ≤ k ≤ 100). Output On the first line print a single integer — the minimal possible m. On each of the next n lines print four space separated integers representing the i-th set. Neither the order of the sets nor the order of integers within a set is important. If there are multiple possible solutions with minimal m, print any one of them. Examples Input 1 1 Output 5 1 2 3 5 Input 2 2 Output 22 2 4 6 22 14 18 10 16 Note For the first example it's easy to see that set {1, 2, 3, 4} isn't a valid set of rank 1 since <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. The DNA sequence for every living creature in Berland can be represented as a non-empty line consisting of lowercase Latin letters. Berland scientists found out that all the creatures evolve by stages. During one stage exactly one symbol of the DNA line is replaced by exactly two other ones. At that overall there are n permissible substitutions. The substitution ai->bici means that any one symbol ai can be replaced with two symbols bici. Every substitution could happen an unlimited number of times. They say that two creatures with DNA sequences s1 and s2 can have a common ancestor if there exists such a DNA sequence s3 that throughout evolution it can result in s1 and s2, perhaps after a different number of stages. Your task is to find out by the given s1 and s2 whether the creatures possessing such DNA sequences can have a common ancestor. If the answer is positive, you have to find the length of the shortest sequence of the common ancestor’s DNA. Input The first line contains a non-empty DNA sequence s1, the second line contains a non-empty DNA sequence s2. The lengths of these lines do not exceed 50, the lines contain only lowercase Latin letters. The third line contains an integer n (0 ≤ n ≤ 50) — the number of permissible substitutions. Then follow n lines each of which describes a substitution in the format ai->bici. The characters ai, bi, and ci are lowercase Latin letters. Lines s1 and s2 can coincide, the list of substitutions can contain similar substitutions. Output If s1 and s2 cannot have a common ancestor, print -1. Otherwise print the length of the shortest sequence s3, from which s1 and s2 could have evolved. Examples Input ababa aba 2 c->ba c->cc Output 2 Input ababa aba 7 c->ba c->cc e->ab z->ea b->ba d->dd d->ab Output 1 Input ababa aba 1 c->ba 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. Let's consider a table consisting of n rows and n columns. The cell located at the intersection of i-th row and j-th column contains number i × j. The rows and columns are numbered starting from 1. You are given a positive integer x. Your task is to count the number of cells in a table that contain number x. Input The single line contains numbers n and x (1 ≤ n ≤ 105, 1 ≤ x ≤ 109) — the size of the table and the number that we are looking for in the table. Output Print a single number: the number of times x occurs in the table. Examples Input 10 5 Output 2 Input 6 12 Output 4 Input 5 13 Output 0 Note A table for the second sample test is given below. The occurrences of number 12 are marked bold. <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. Spongebob is already tired trying to reason his weird actions and calculations, so he simply asked you to find all pairs of n and m, such that there are exactly x distinct squares in the table consisting of n rows and m columns. For example, in a 3 × 5 table there are 15 squares with side one, 8 squares with side two and 3 squares with side three. The total number of distinct squares in a 3 × 5 table is 15 + 8 + 3 = 26. Input The first line of the input contains a single integer x (1 ≤ x ≤ 1018) — the number of squares inside the tables Spongebob is interested in. Output First print a single integer k — the number of tables with exactly x distinct squares inside. Then print k pairs of integers describing the tables. Print the pairs in the order of increasing n, and in case of equality — in the order of increasing m. Examples Input 26 Output 6 1 26 2 9 3 5 5 3 9 2 26 1 Input 2 Output 2 1 2 2 1 Input 8 Output 4 1 8 2 3 3 2 8 1 Note In a 1 × 2 table there are 2 1 × 1 squares. So, 2 distinct squares in total. <image> In a 2 × 3 table there are 6 1 × 1 squares and 2 2 × 2 squares. That is equal to 8 squares in total. <image> The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. There are n pearls in a row. Let's enumerate them with integers from 1 to n from the left to the right. The pearl number i has the type ai. Let's call a sequence of consecutive pearls a segment. Let's call a segment good if it contains two pearls of the same type. Split the row of the pearls to the maximal number of good segments. Note that each pearl should appear in exactly one segment of the partition. As input/output can reach huge size it is recommended to use fast input/output methods: for example, prefer to use scanf/printf instead of cin/cout in C++, prefer to use BufferedReader/PrintWriter instead of Scanner/System.out in Java. Input The first line contains integer n (1 ≤ n ≤ 3·105) — the number of pearls in a row. The second line contains n integers ai (1 ≤ ai ≤ 109) – the type of the i-th pearl. Output On the first line print integer k — the maximal number of segments in a partition of the row. Each of the next k lines should contain two integers lj, rj (1 ≤ lj ≤ rj ≤ n) — the number of the leftmost and the rightmost pearls in the j-th segment. Note you should print the correct partition of the row of the pearls, so each pearl should be in exactly one segment and all segments should contain two pearls of the same type. If there are several optimal solutions print any of them. You can print the segments in any order. If there are no correct partitions of the row print the number "-1". Examples Input 5 1 2 3 4 1 Output 1 1 5 Input 5 1 2 3 4 5 Output -1 Input 7 1 2 1 3 1 2 1 Output 2 1 3 4 7 The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Little Artem likes electronics. He can spend lots of time making different schemas and looking for novelties in the nearest electronics store. The new control element was delivered to the store recently and Artem immediately bought it. That element can store information about the matrix of integers size n × m. There are n + m inputs in that element, i.e. each row and each column can get the signal. When signal comes to the input corresponding to some row, this row cyclically shifts to the left, that is the first element of the row becomes last element, second element becomes first and so on. When signal comes to the input corresponding to some column, that column shifts cyclically to the top, that is first element of the column becomes last element, second element becomes first and so on. Rows are numbered with integers from 1 to n from top to bottom, while columns are numbered with integers from 1 to m from left to right. Artem wants to carefully study this element before using it. For that purpose he is going to set up an experiment consisting of q turns. On each turn he either sends the signal to some input or checks what number is stored at some position of the matrix. Artem has completed his experiment and has written down the results, but he has lost the chip! Help Artem find any initial matrix that will match the experiment results. It is guaranteed that experiment data is consistent, which means at least one valid matrix exists. Input The first line of the input contains three integers n, m and q (1 ≤ n, m ≤ 100, 1 ≤ q ≤ 10 000) — dimensions of the matrix and the number of turns in the experiment, respectively. Next q lines contain turns descriptions, one per line. Each description starts with an integer ti (1 ≤ ti ≤ 3) that defines the type of the operation. For the operation of first and second type integer ri (1 ≤ ri ≤ n) or ci (1 ≤ ci ≤ m) follows, while for the operations of the third type three integers ri, ci and xi (1 ≤ ri ≤ n, 1 ≤ ci ≤ m, - 109 ≤ xi ≤ 109) are given. Operation of the first type (ti = 1) means that signal comes to the input corresponding to row ri, that is it will shift cyclically. Operation of the second type (ti = 2) means that column ci will shift cyclically. Finally, operation of the third type means that at this moment of time cell located in the row ri and column ci stores value xi. Output Print the description of any valid initial matrix as n lines containing m integers each. All output integers should not exceed 109 by their absolute value. If there are multiple valid solutions, output any of them. Examples Input 2 2 6 2 1 2 2 3 1 1 1 3 2 2 2 3 1 2 8 3 2 1 8 Output 8 2 1 8 Input 3 3 2 1 2 3 2 2 5 Output 0 0 0 0 0 5 0 0 0 The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Little Artem has invented a time machine! He could go anywhere in time, but all his thoughts of course are with computer science. He wants to apply this time machine to a well-known data structure: multiset. Artem wants to create a basic multiset of integers. He wants these structure to support operations of three types: 1. Add integer to the multiset. Note that the difference between set and multiset is that multiset may store several instances of one integer. 2. Remove integer from the multiset. Only one instance of this integer is removed. Artem doesn't want to handle any exceptions, so he assumes that every time remove operation is called, that integer is presented in the multiset. 3. Count the number of instances of the given integer that are stored in the multiset. But what about time machine? Artem doesn't simply apply operations to the multiset one by one, he now travels to different moments of time and apply his operation there. Consider the following example. * First Artem adds integer 5 to the multiset at the 1-st moment of time. * Then Artem adds integer 3 to the multiset at the moment 5. * Then Artem asks how many 5 are there in the multiset at moment 6. The answer is 1. * Then Artem returns back in time and asks how many integers 3 are there in the set at moment 4. Since 3 was added only at moment 5, the number of integers 3 at moment 4 equals to 0. * Then Artem goes back in time again and removes 5 from the multiset at moment 3. * Finally Artyom asks at moment 7 how many integers 5 are there in the set. The result is 0, since we have removed 5 at the moment 3. Note that Artem dislikes exceptions so much that he assures that after each change he makes all delete operations are applied only to element that is present in the multiset. The answer to the query of the third type is computed at the moment Artem makes the corresponding query and are not affected in any way by future changes he makes. Help Artem implement time travellers multiset. Input The first line of the input contains a single integer n (1 ≤ n ≤ 100 000) — the number of Artem's queries. Then follow n lines with queries descriptions. Each of them contains three integers ai, ti and xi (1 ≤ ai ≤ 3, 1 ≤ ti, xi ≤ 109) — type of the query, moment of time Artem travels to in order to execute this query and the value of the query itself, respectively. It's guaranteed that all moments of time are distinct and that after each operation is applied all operations of the first and second types are consistent. Output For each ask operation output the number of instances of integer being queried at the given moment of time. Examples Input 6 1 1 5 3 5 5 1 2 5 3 6 5 2 3 5 3 7 5 Output 1 2 1 Input 3 1 1 1 2 2 1 3 3 1 Output 0 The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. ZS the Coder has drawn an undirected graph of n vertices numbered from 0 to n - 1 and m edges between them. Each edge of the graph is weighted, each weight is a positive integer. The next day, ZS the Coder realized that some of the weights were erased! So he wants to reassign positive integer weight to each of the edges which weights were erased, so that the length of the shortest path between vertices s and t in the resulting graph is exactly L. Can you help him? Input The first line contains five integers n, m, L, s, t (2 ≤ n ≤ 1000, 1 ≤ m ≤ 10 000, 1 ≤ L ≤ 109, 0 ≤ s, t ≤ n - 1, s ≠ t) — the number of vertices, number of edges, the desired length of shortest path, starting vertex and ending vertex respectively. Then, m lines describing the edges of the graph follow. i-th of them contains three integers, ui, vi, wi (0 ≤ ui, vi ≤ n - 1, ui ≠ vi, 0 ≤ wi ≤ 109). ui and vi denote the endpoints of the edge and wi denotes its weight. If wi is equal to 0 then the weight of the corresponding edge was erased. It is guaranteed that there is at most one edge between any pair of vertices. Output Print "NO" (without quotes) in the only line if it's not possible to assign the weights in a required way. Otherwise, print "YES" in the first line. Next m lines should contain the edges of the resulting graph, with weights assigned to edges which weights were erased. i-th of them should contain three integers ui, vi and wi, denoting an edge between vertices ui and vi of weight wi. The edges of the new graph must coincide with the ones in the graph from the input. The weights that were not erased must remain unchanged whereas the new weights can be any positive integer not exceeding 1018. The order of the edges in the output doesn't matter. The length of the shortest path between s and t must be equal to L. If there are multiple solutions, print any of them. Examples Input 5 5 13 0 4 0 1 5 2 1 2 3 2 3 1 4 0 4 3 4 Output YES 0 1 5 2 1 2 3 2 3 1 4 8 4 3 4 Input 2 1 123456789 0 1 0 1 0 Output YES 0 1 123456789 Input 2 1 999999999 1 0 0 1 1000000000 Output NO Note Here's how the graph in the first sample case looks like : <image> In the first sample case, there is only one missing edge weight. Placing the weight of 8 gives a shortest path from 0 to 4 of length 13. In the second sample case, there is only a single edge. Clearly, the only way is to replace the missing weight with 123456789. In the last sample case, there is no weights to assign but the length of the shortest path doesn't match the required value, so the answer is "NO". The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Ahmed and Mostafa used to compete together in many programming contests for several years. Their coach Fegla asked them to solve one challenging problem, of course Ahmed was able to solve it but Mostafa couldn't. This problem is similar to a standard problem but it has a different format and constraints. In the standard problem you are given an array of integers, and you have to find one or more consecutive elements in this array where their sum is the maximum possible sum. But in this problem you are given n small arrays, and you will create one big array from the concatenation of one or more instances of the small arrays (each small array could occur more than once). The big array will be given as an array of indexes (1-based) of the small arrays, and the concatenation should be done in the same order as in this array. Then you should apply the standard problem mentioned above on the resulting big array. For example let's suppose that the small arrays are {1, 6, -2}, {3, 3} and {-5, 1}. And the indexes in the big array are {2, 3, 1, 3}. So the actual values in the big array after formatting it as concatenation of the small arrays will be {3, 3, -5, 1, 1, 6, -2, -5, 1}. In this example the maximum sum is 9. Can you help Mostafa solve this problem? Input The first line contains two integers n and m, n is the number of the small arrays (1 ≤ n ≤ 50), and m is the number of indexes in the big array (1 ≤ m ≤ 250000). Then follow n lines, the i-th line starts with one integer l which is the size of the i-th array (1 ≤ l ≤ 5000), followed by l integers each one will be greater than or equal -1000 and less than or equal 1000. The last line contains m integers which are the indexes in the big array, and you should concatenate the small arrays in the same order, and each index will be greater than or equal to 1 and less than or equal to n. The small arrays are numbered from 1 to n in the same order as given in the input. Some of the given small arrays may not be used in big array. Note, that the array is very big. So if you try to build it straightforwardly, you will probably get time or/and memory limit exceeded. Output Print one line containing the maximum sum in the big array after formatting it as described above. You must choose at least one element for the sum, i. e. it cannot be empty. Please, do not use %lld specificator to write 64-bit integers in C++. It is preferred to use cout (also you may use %I64d). Examples Input 3 4 3 1 6 -2 2 3 3 2 -5 1 2 3 1 3 Output 9 Input 6 1 4 0 8 -3 -10 8 3 -2 -5 10 8 -9 -5 -4 1 0 1 -3 3 -8 5 6 2 9 6 1 Output 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. You are given an array a consisting of positive integers and q queries to this array. There are two types of queries: * 1 l r x — for each index i such that l ≤ i ≤ r set ai = x. * 2 l r — find the minimum among such ai that l ≤ i ≤ r. We decided that this problem is too easy. So the array a is given in a compressed form: there is an array b consisting of n elements and a number k in the input, and before all queries a is equal to the concatenation of k arrays b (so the size of a is n·k). Input The first line contains two integers n and k (1 ≤ n ≤ 105, 1 ≤ k ≤ 104). The second line contains n integers — elements of the array b (1 ≤ bi ≤ 109). The third line contains one integer q (1 ≤ q ≤ 105). Then q lines follow, each representing a query. Each query is given either as 1 l r x — set all elements in the segment from l till r (including borders) to x (1 ≤ l ≤ r ≤ n·k, 1 ≤ x ≤ 109) or as 2 l r — find the minimum among all elements in the segment from l till r (1 ≤ l ≤ r ≤ n·k). Output For each query of type 2 print the answer to this query — the minimum on the corresponding segment. Examples Input 3 1 1 2 3 3 2 1 3 1 1 2 4 2 1 3 Output 1 3 Input 3 2 1 2 3 5 2 4 4 1 4 4 5 2 4 4 1 1 6 1 2 6 6 Output 1 5 1 The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. You are given set of n points in 5-dimensional space. The points are labeled from 1 to n. No two points coincide. We will call point a bad if there are different points b and c, not equal to a, from the given set such that angle between vectors <image> and <image> is acute (i.e. strictly less than <image>). Otherwise, the point is called good. The angle between vectors <image> and <image> in 5-dimensional space is defined as <image>, where <image> is the scalar product and <image> is length of <image>. Given the list of points, print the indices of the good points in ascending order. Input The first line of input contains a single integer n (1 ≤ n ≤ 103) — the number of points. The next n lines of input contain five integers ai, bi, ci, di, ei (\|ai\|, \|bi\|, \|ci\|, \|di\|, \|ei\| ≤ 103) — the coordinates of the i-th point. All points are distinct. Output First, print a single integer k — the number of good points. Then, print k integers, each on their own line — the indices of the good points in ascending order. Examples Input 6 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 1 Output 1 1 Input 3 0 0 1 2 0 0 0 9 2 0 0 0 5 9 0 Output 0 Note In the first sample, the first point forms exactly a <image> angle with all other pairs of points, so it is good. In the second sample, along the cd plane, we can see the points look as follows: <image> We can see that all angles here are acute, so no points are good. The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Everybody in Russia uses Gregorian calendar. In this calendar there are 31 days in January, 28 or 29 days in February (depending on whether the year is leap or not), 31 days in March, 30 days in April, 31 days in May, 30 in June, 31 in July, 31 in August, 30 in September, 31 in October, 30 in November, 31 in December. A year is leap in one of two cases: either its number is divisible by 4, but not divisible by 100, or is divisible by 400. For example, the following years are leap: 2000, 2004, but years 1900 and 2018 are not leap. In this problem you are given n (1 ≤ n ≤ 24) integers a1, a2, ..., an, and you have to check if these integers could be durations in days of n consecutive months, according to Gregorian calendar. Note that these months could belong to several consecutive years. In other words, check if there is a month in some year, such that its duration is a1 days, duration of the next month is a2 days, and so on. Input The first line contains single integer n (1 ≤ n ≤ 24) — the number of integers. The second line contains n integers a1, a2, ..., an (28 ≤ ai ≤ 31) — the numbers you are to check. Output If there are several consecutive months that fit the sequence, print "YES" (without quotes). Otherwise, print "NO" (without quotes). You can print each letter in arbitrary case (small or large). Examples Input 4 31 31 30 31 Output Yes Input 2 30 30 Output No Input 5 29 31 30 31 30 Output Yes Input 3 31 28 30 Output No Input 3 31 31 28 Output Yes Note In the first example the integers can denote months July, August, September and October. In the second example the answer is no, because there are no two consecutive months each having 30 days. In the third example the months are: February (leap year) — March — April – May — June. In the fourth example the number of days in the second month is 28, so this is February. March follows February and has 31 days, but not 30, so the answer is NO. In the fifth example the months are: December — January — February (non-leap year). 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 ski base is planned to be built in Walrusland. Recently, however, the project is still in the constructing phase. A large land lot was chosen for the construction. It contains n ski junctions, numbered from 1 to n. Initially the junctions aren't connected in any way. In the constructing process m bidirectional ski roads will be built. The roads are built one after another: first the road number 1 will be built, then the road number 2, and so on. The i-th road connects the junctions with numbers ai and bi. Track is the route with the following properties: * The route is closed, that is, it begins and ends in one and the same junction. * The route contains at least one road. * The route doesn't go on one road more than once, however it can visit any junction any number of times. Let's consider the ski base as a non-empty set of roads that can be divided into one or more tracks so that exactly one track went along each road of the chosen set. Besides, each track can consist only of roads from the chosen set. Ski base doesn't have to be connected. Two ski bases are considered different if they consist of different road sets. After building each new road the Walrusland government wants to know the number of variants of choosing a ski base based on some subset of the already built roads. The government asks you to help them solve the given problem. Input The first line contains two integers n and m (2 ≤ n ≤ 105, 1 ≤ m ≤ 105). They represent the number of junctions and the number of roads correspondingly. Then on m lines follows the description of the roads in the order in which they were built. Each road is described by a pair of integers ai and bi (1 ≤ ai, bi ≤ n, ai ≠ bi) — the numbers of the connected junctions. There could be more than one road between a pair of junctions. Output Print m lines: the i-th line should represent the number of ways to build a ski base after the end of construction of the road number i. The numbers should be printed modulo 1000000009 (109 + 9). Examples Input 3 4 1 3 2 3 1 2 1 2 Output 0 0 1 3 Note Let us have 3 junctions and 4 roads between the junctions have already been built (as after building all the roads in the sample): 1 and 3, 2 and 3, 2 roads between junctions 1 and 2. The land lot for the construction will look like this: <image> The land lot for the construction will look in the following way: <image> We can choose a subset of roads in three ways: <image> In the first and the second ways you can choose one path, for example, 1 - 2 - 3 - 1. In the first case you can choose one path 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. Bob is a farmer. He has a large pasture with many sheep. Recently, he has lost some of them due to wolf attacks. He thus decided to place some shepherd dogs in such a way that all his sheep are protected. The pasture is a rectangle consisting of R × C cells. Each cell is either empty, contains a sheep, a wolf or a dog. Sheep and dogs always stay in place, but wolves can roam freely around the pasture, by repeatedly moving to the left, right, up or down to a neighboring cell. When a wolf enters a cell with a sheep, it consumes it. However, no wolf can enter a cell with a dog. Initially there are no dogs. Place dogs onto the pasture in such a way that no wolf can reach any sheep, or determine that it is impossible. Note that since you have many dogs, you do not need to minimize their number. Input First line contains two integers R (1 ≤ R ≤ 500) and C (1 ≤ C ≤ 500), denoting the number of rows and the numbers of columns respectively. Each of the following R lines is a string consisting of exactly C characters, representing one row of the pasture. Here, 'S' means a sheep, 'W' a wolf and '.' an empty cell. Output If it is impossible to protect all sheep, output a single line with the word "No". Otherwise, output a line with the word "Yes". Then print R lines, representing the pasture after placing dogs. Again, 'S' means a sheep, 'W' a wolf, 'D' is a dog and '.' an empty space. You are not allowed to move, remove or add a sheep or a wolf. If there are multiple solutions, you may print any of them. You don't have to minimize the number of dogs. Examples Input 6 6 ..S... ..S.W. .S.... ..W... ...W.. ...... Output Yes ..SD.. ..SDW. .SD... .DW... DD.W.. ...... Input 1 2 SW Output No Input 5 5 .S... ...S. S.... ...S. .S... Output Yes .S... ...S. S.D.. ...S. .S... Note In the first example, we can split the pasture into two halves, one containing wolves and one containing sheep. Note that the sheep at (2,1) is safe, as wolves cannot move diagonally. In the second example, there are no empty spots to put dogs that would guard the lone sheep. In the third example, there are no wolves, so the task is very easy. We put a dog in the center to observe the peacefulness of the meadow, but the solution would be correct even without him. 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. String can be called correct if it consists of characters "0" and "1" and there are no redundant leading zeroes. Here are some examples: "0", "10", "1001". You are given a correct string s. You can perform two different operations on this string: 1. swap any pair of adjacent characters (for example, "101" <image> "110"); 2. replace "11" with "1" (for example, "110" <image> "10"). Let val(s) be such a number that s is its binary representation. Correct string a is less than some other correct string b iff val(a) < val(b). Your task is to find the minimum correct string that you can obtain from the given one using the operations described above. You can use these operations any number of times in any order (or even use no operations at all). Input The first line contains integer number n (1 ≤ n ≤ 100) — the length of string s. The second line contains the string s consisting of characters "0" and "1". It is guaranteed that the string s is correct. Output Print one string — the minimum correct string that you can obtain from the given one. Examples Input 4 1001 Output 100 Input 1 1 Output 1 Note In the first example you can obtain the answer by the following sequence of operations: "1001" <image> "1010" <image> "1100" <image> "100". In the second example you can't obtain smaller answer no matter what operations you use. 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. Cat Noku recently picked up construction working as a hobby. He's currently working with a row of buildings and would like to make it beautiful. There are n buildings in a row. The height of the i-th building is xi. Cat Noku can modify the buildings by adding or removing floors to change the heights. It costs him P dollars to increase the height of one building by 1, and M dollars to lower the height of one building by 1. Note that the heights of all the buildlings must remain integers (i.e. Cat Noku cannot choose to raise the height of a building by 0.5). At the end of the day Cat Noku will get a bonus for the number of buildings which are adjacent and have the same height. For each section i, if section i+1 has the same height, Cat Noku will gain a profit of S (of course, it is not possible to get this bonus for the last building in the row). Thus, his net profit can be described by his total profit minus the cost it took him to change the building heights. Help Cat Noku determine the maximum possible net profit he can gain. Input format: The first line will contain four space separated integers n, S, M, P. The second line will contain n space separated integers. The i-th integer in this line will be equal to xi. Output format: Print a single integer on its own line, the maximum net profit that Cat Noku can earn. Constraints: For all subtasks: 2 ≤ n 1 ≤ xi 1 ≤ S, M, P Subtask 1 (56 pts): n ≤ 5 xi ≤ 10 S, M, P ≤ 100 Subtask 2 (32 pts): n ≤ 50 xi ≤ 100 S, M, P ≤ 1,000 Subtask 3 (12 pts): n ≤ 2,500 xi ≤ 1,000,000 S, M, P ≤ 1,000,000,000 SAMPLE INPUT 5 4 2 1 1 2 1 5 4 SAMPLE OUTPUT 9 Explanation In this case, we have 5 buildings with heights 1,2,1,5,4. Cat Noku will get a bonus of 4 for adjacent buildings with the same height. It costs 2 dollars to lower the height of a building by 1, and 1 dollar to raise the height by 1. One optimal solution is to modify the buildings heights to be 1,1,1,5,5. This costs 2+1=3 dollars. Cat Noku gets the bonus 3 times (i.e. the first, second and fourth buildings qualify for the bonus). Thus, his gross profit is 3*4=12. His net profit is 12-3=9 in this 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. There are 26 letters in the English alphabet and 6 of them are vowels: a,e,i,o,u,y. Other 20 letters are called consonants. Limak is a little polar bear. He found a string s consisting of lowercase English letters. He is going to read and pronounce s but it may be hard for him. Some letters are harder to pronounce, some are easier. Generally, little polar bears like vowels (letters a,e,i,o,u,y) and hate consonants. Your task is to check whether pronouncing s will be hard or easy. We define s to be hard if at least one of the two conditions holds true: There are more consonants than vowels. Some 3 consecutive letters are all consonants. For each test case in one line print "hard" (without the quotes) if s is hard to pronounce. Otherwise, print "easy" (without the quotes). Input format The first line of the input contains one integer T denoting the number of test cases. The first line of each test case description contains one string s denoting a string found by Limak. Each character in s is one of 26 lowercase English letters. Output format For each test case, output a single line containing the answer — either "hard" or "easy". Constraints 1 ≤ T ≤ 50 1 ≤ \|s\| ≤ 50 SAMPLE INPUT 5 qiewldoaa life ayayayyy szczebrzeszyn gg SAMPLE OUTPUT hard easy easy hard hard Explanation In the first sample test case, Limak found a string "qiewldoaa". It's hard to pronounce because there are 3 consecutive consonants: w,l,d. In the last sample test case, a string "gg" is hard to pronounce because it contains more consonants than vowels. 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. "She loves me", "She loves me not", "She loves me", "She loves me not", OH WAIT, I'm LALA, "They love me", "They love me not", "They love me", "They love me not". Lala was indeed overwhelmed by the 'runner's high' and the turbulence inside him. Heart-broken by one of his many lalis, he decided to code out his frustration, and also having read somewhere that some specific amount of 'so-called high' heightens brain power and creativity. He thinks of making a large palindrome, using the formula S(n)=S(n-1)+"0"+reverse(S(n-1)) but instead makes it up as S(n)=S(n-1)+"0"+switch(reverse(S(n-1))) After lala's passing out, in came patrick and wanted to check out what lala has done. Due to his over-technical abilities, lala has encrypted the code such that at a time only the kth digit of the string will be visible. As lala is lala, he has taken the upper limit to a whole another level and has coded it for 10^100. As a programmer you are asked to fill in lala's shoes and code the program generating the kth digit for the last string. The digits used are 0 and 1 and the functions are as follows: switch: the digit will be interchanged (0 for 1, 1 for 0) reverse: the string will be reversed. Input The first line of the input gives the number of test cases, T. Each of the next T lines contains a number K. Output For each test case, output one line containing is the Kth character of S SAMPLE INPUT 4 1 2 3 10 SAMPLE OUTPUT 0 0 1 0 The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. WizKid went on a trip to Wonderland with his classmates. Now, as you know, going on trips incurs costs including hotel costs, fooding, shopping, etc. And when many people go together, usually one person pays and it is expected that the others will pay back their share. But, after a few days people lost track of who owed whom how much and there was a lot of confusion. So WizKid set down to make a program which will help solve all these problems in future. He will record the details of all the people going on the trip and the details of each transaction made on the trip. Note: It is not necessary that all the people were present in all transactions. Only those present will share the amount. So he also has to note who all were present, who paid and the amount paid. Even after this, one more issue remained about what happens when the amount spent could not be divided equally integrally to each person. Well, he decided that the person who paid the bill will have to bear the little extra cost himself on each bill. Now, we need you to simulate the same and give the final summary for each person accordingly. Input: First line contains T which is the number of test cases. First line of each test case consists of 2 integers N and Q where N is the number of people who went on the trip and Q is the number of transactions made. N lines follow, each containing the names of the N persons who went on the trip. Each name will be distinct and will be a single word consisting of lowercase or uppercase alphabets only. Q transactions follow each containing the details of each transaction made. The first line of each transaction contains the name of the person who paid for the transaction. The second line of each transaction contains the amount paid by the person for the transaction. The third line of each transaction contains the number of people(other than the person who paid) M between whom this amount is to be split. M lines follow each containing the names of the people between whom this amount is to be split. Output: For each test case, print N lines containing the final dues for each person in the following manner : If a person X is supposed to get Y money from the others, then print "X is owed Y" If a person X is supposed to pay Y money to the others, then print "X owes Y" If a person X has no dues, then print "X neither owes nor is owed" Constraints: 1 ≤ T ≤ 10 2 ≤ N ≤ 50 1 ≤ Q ≤ 50 1 ≤ M ≤ N-1 1 ≤ length of each name ≤ 10 1 ≤ all amounts ≤ 1000 Scoring: 2 ≤ N ≤ 5, 1 ≤ Q ≤ 5 : (30 pts) 2 ≤ N ≤ 10, 1 ≤ Q ≤ 10 : (30 pts) Original Constraints : (40 pts) SAMPLE INPUT 1 4 2 Alice Bob Daniel Mike Bob 97 1 Alice Mike 24 2 Alice Bob SAMPLE OUTPUT Alice owes 56 Bob is owed 40 Daniel neither owes nor is owed Mike is owed 16 Explanation After the first transaction, Bob pays 97 for Alice and himself. The share will have to divided as 49 for Bob and 48 for Alice. ALICE: Expenses = 48, Paid = 0 BOB: Expenses = 49, Paid = 49 After the second transaction, Mike spends 24 on Alice, Bob and himself. The share will have to divided equally. So now, ALICE: Expenses = 48+8 , Paid = 0 BOB: Expenses = 49+8, Paid = 97 MIKE: Expenses = 8, Paid = 24 Thus finally, ALICE has to pay 56. BOB will get back 97-49-8 = 40. MIKE will get back 16. DANIEL has no dues. 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. Today, teacher taught Xenny the chapter 'Prime numbers and Composite numbers'. Xenny liked it and being a studious boy, wanted some homework. So teacher gave him a simple task. The task is to find the smallest composite number greater than given no. Xenny was happy to get the simple task. But Xenny didn't get the time for complting the homework being busy in helping his mother throughout the day. You, a best friend of Xenny, don't want Xenny to get punished by teacher. So its your job to complete his homework. Formally, there will be t numbers and you have to find smallest greater composite number for each of them. Input: The first line of input will be t i.e. number of test-cases. Followed by t lines each containing n. Output: For each test-case, Print the smallest greater number than n which is a composite number on new line. Constraints: SMALL: 1 ≤ t ≤ 10 0 ≤ n ≤ 10 MEDIUM: 1 ≤ t ≤ 500 0 ≤ n ≤ 1000 LARGE: 1 ≤ t ≤ 50000 0 ≤ n ≤ 100000 SAMPLE INPUT 2 3 8 SAMPLE OUTPUT 4 9 Explanation Test-cases are 2. For first case, the smallest composite no. greater than 3 is 4 . For second case, the smallest composite no. greater than 8 is 9 . 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. When you asked some guy in your class his name, he called himself S, where S is a string of length between 3 and 20 (inclusive) consisting of lowercase English letters. You have decided to choose some three consecutive characters from S and make it his nickname. Print a string that is a valid nickname for him. Constraints * 3 \leq \|S\| \leq 20 * S consists of lowercase English letters. Input Input is given from Standard Input in the following format: S Output Print your answer. Examples Input takahashi Output tak Input naohiro Output nao 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 integers A_1, A_2, ..., A_N. There are \frac{N(N-1)}{2} ways to choose two of them and form a pair. If we compute the product of each of those pairs and sort the results in ascending order, what will be the K-th number in that list? Constraints * All values in input are integers. * 2 \leq N \leq 2 \times 10^5 * 1 \leq K \leq \frac{N(N-1)}{2} * -10^9 \leq A_i \leq 10^9\ (1 \leq i \leq N) Input Input is given from Standard Input in the following format: N K A_1 A_2 \dots A_N Output Print the answer. Examples Input 4 3 3 3 -4 -2 Output -6 Input 10 40 5 4 3 2 -1 0 0 0 0 0 Output 6 Input 30 413 -170202098 -268409015 537203564 983211703 21608710 -443999067 -937727165 -97596546 -372334013 398994917 -972141167 798607104 -949068442 -959948616 37909651 0 886627544 -20098238 0 -948955241 0 -214720580 277222296 -18897162 834475626 0 -425610555 110117526 663621752 0 Output 448283280358331064 The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. There is a tree with N vertices. The vertices are numbered 1 through N. The i-th edge (1 \leq i \leq N - 1) connects Vertex x_i and y_i. For vertices v and w (1 \leq v, w \leq N), we will define the distance between v and w d(v, w) as "the number of edges contained in the path v-w". A squirrel lives in each vertex of the tree. They are planning to move, as follows. First, they will freely choose a permutation of (1, 2, ..., N), p = (p_1, p_2, ..., p_N). Then, for each 1 \leq i \leq N, the squirrel that lived in Vertex i will move to Vertex p_i. Since they like long travels, they have decided to maximize the total distance they traveled during the process. That is, they will choose p so that d(1, p_1) + d(2, p_2) + ... + d(N, p_N) will be maximized. How many such ways are there to choose p, modulo 10^9 + 7? Constraints * 2 \leq N \leq 5,000 * 1 \leq x_i, y_i \leq N * The input graph is a tree. Input Input is given from Standard Input in the following format: N x_1 y_1 x_2 y_2 : x_{N - 1} y_{N - 1} Output Print the number of the ways to choose p so that the condition is satisfied, modulo 10^9 + 7. Examples Input 3 1 2 2 3 Output 3 Input 4 1 2 1 3 1 4 Output 11 Input 6 1 2 1 3 1 4 2 5 2 6 Output 36 Input 7 1 2 6 3 4 5 1 7 1 5 2 3 Output 396 The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. There is a tree with N vertices, numbered 1 through N. The i-th edge in this tree connects Vertices A_i and B_i and has a length of C_i. Joisino created a complete graph with N vertices. The length of the edge connecting Vertices u and v in this graph, is equal to the shortest distance between Vertices u and v in the tree above. Joisino would like to know the length of the longest Hamiltonian path (see Notes) in this complete graph. Find the length of that path. Constraints * 2 \leq N \leq 10^5 * 1 \leq A_i < B_i \leq N * The given graph is a tree. * 1 \leq C_i \leq 10^8 * All input values are integers. Input Input is given from Standard Input in the following format: N A_1 B_1 C_1 A_2 B_2 C_2 : A_{N-1} B_{N-1} C_{N-1} Output Print the length of the longest Hamiltonian path in the complete graph created by Joisino. Examples Input 5 1 2 5 3 4 7 2 3 3 2 5 2 Output 38 Input 8 2 8 8 1 5 1 4 8 2 2 5 4 3 8 6 6 8 9 2 7 12 Output 132 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 plan view consisting of 12 vertical and 12 horizontal squares showing the terrain. Each square is painted white or black. White represents the sea and black represents the land. When two black squares touch each other vertically or horizontally, they are said to be continuous. In this plan view, the area created by only one black square or a continuous black square is called an "island". For example, in the figure below, there are five islands. ■■■■ □□□□ ■■■■ ■■■ □□□□□ ■■■■ ■■ □□□□□□ ■■■■ ■ □□□□□□□ ■■■■ □□□ ■ □□□ ■ □□□□ □□□□□□ ■■■ □□□ □□□□□ ■■■■■ □□ ■ □□□ ■■■■■■■ □ ■■ □□□ ■■■■■ □□ ■■■ □□□ ■■■ □□□ ■■■■ □□□ ■ □□□□ □□□□□□□□□□□□ Create a program that reads the mass data and outputs the number of islands. Hint The following shows the sample inputs with ■ and □. ■■■■ □□□□ ■■■■ □ ■ □□□ ■■■■■ □□ □□□□□□□□□□□□ ■■■ □□□□□ ■■■■ ■■ □□ ■ □□□□□ ■ □ ■■■■■■■■■■■■ ■■ □□□□□□ ■■■■ □ ■ □□ ■ □□□□□□ ■ ■ □□□ ■ □ ■ □□□□ ■ ■ □□□□□□□ ■■■■ □ ■ □□□□□□□□□ ■ ■ □□□ ■ □ ■ □□□□ ■ □□□ ■ □□□ ■ □□□□ □ ■ □□□□□□□ ■■ □ ■ □□□ ■ □ ■ □□□□ ■ □□□□□□ ■■■ □□□ □ ■ □□□□ ■■■ □□□ ■ □□□ ■ □ ■ □□□□ ■ □□□□□ ■■■■■ □□ □ ■ □□□□□□□ ■ □□ ■ □□ ■ □□ ■ □□ ■ □ ■ ■ □□□ ■■■■■■■ □ □ ■ □□□□□□□□ ■ □ ■ □ ■ □□□□ ■■■ □ ■ ■■ □□□ ■■■■■ □□ □ ■ □□□□□□□□□ ■ ■ □□□□□□□□□□ ■ ■■■ □□□ ■■■ □□□ □ ■ □□ ■ □□□□□□ ■ ■ □□□□□□□□□□ ■ ■■■■ □□□ ■ □□□□ □ ■ □□ ■ □□□□□ ■ □ ■■■■■■■■■■■■ □□□□□□□□□□□□ ■■■ □□ ■■■■■ □□ ■ □□□□□□□□□□ ■ Input The input consists of multiple datasets. One plan view is given for each dataset. A plan view is represented by 12 rows of 12 number columns, with black squares represented by 1 and white squares represented by 0. The datasets are separated by a single blank line. The number of datasets does not exceed 20. Output Outputs the number of islands on one line for each dataset. Example Input 111100001111 111000001111 110000001111 100000001111 000100010000 000000111000 000001111100 100011111110 110001111100 111000111000 111100010000 000000000000 010001111100 110010000010 010010000001 010000000001 010000000110 010000111000 010000000100 010000000010 010000000001 010010000001 010010000010 111001111100 000000000000 111111111111 100010100001 100010100001 100010100001 100010100001 100100100101 101000011101 100000000001 100000000001 111111111111 100000000001 Output 5 13 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. The neutral city of Eyes City, in the heart of the four countries, is home to the transcontinental train Bandai. The platform has a row of chairs for passengers waiting for the Bandai, and people who enter the platform can use the chairs freely. The Bandai is cheap, fast and comfortable, so there are a constant number of users from the four surrounding countries. Today is the anniversary of the opening, so I'm thinking of doing something special for the people sitting at home. To do this, you need to know where the people who pass through the ticket gate are sitting. Consider the difficult personalities of people from four countries and create a program that simulates how the chairs are buried. People who pass through the ticket gate sit in a row of chairs one after another. People from four countries have their own personalities and ways of sitting. Each sitting style is as follows. Personality of Country A \| Country A should be able to sit down. Look from the left end and sit in an empty chair. --- \| --- <image> Personality of country B \| Country B is not good at country A. A Sit in an empty chair from the right end, except next to a national. However, if only the person next to Country A is vacant, be patient and sit in the vacant chair from the left end. --- \| --- <image> <image> Personality of C country \| C country wants to sit next to a person. Look at the person sitting in order from the left side and try to sit to the right of the person sitting on the far left, but if it is full, try to sit to the left of that person. If it is also filled, try to sit next to the next person under the same conditions. If no one is sitting in any of the chairs, sit in the middle chair (n / 2 + 1 if the number of chairs n is odd (n + 1) / 2). --- \| --- <image> <image> Personality of D country \| D country does not want to sit next to a person. Trying to sit in the chair that is the closest to the closest person. If you have more than one chair with the same conditions, or if you have to sit next to someone, sit on the leftmost chair. If no one is sitting, sit in the leftmost chair. --- \| --- <image> <image> Create a program that takes in the information of the passengers trying to get on the Bandai and outputs how they are sitting in the chair. The nationality of the person sitting in order from the left is output. However, if the seat is vacant, output # (half-width sharp). 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: n m a1 a2 :: am The first line gives the number of chairs n (1 ≤ n ≤ 100) and the number of passengers m (m ≤ n). The next m line is given the i-th information ai. ai is a single letter, with'A' representing country A,'B' representing country B,'C' representing country C, and'D' representing country D. The number of datasets does not exceed 100. Output Outputs the final chair status on one line for each dataset. Example Input 5 4 A B C D 5 4 D C B A 0 0 Output ACD#B DCA#B 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 now in a bookshop with your friend Alice to buy a book, "The Winning Strategy for the Programming Koshien Contest,” just released today. As you definitely want to buy it, you are planning to borrow some money from Alice in case the amount you have falls short of the price. If the amount you receive from Alice still fails to meet the price, you have to abandon buying the book this time. Write a program to calculate the minimum amount of money you need to borrow from Alice given the following three items of data: the money you and Alice have now and the price of the book. Input The input is given in the following format. m f b A line containing the three amounts of money is given: the amount you have with you now m (0 ≤ m ≤ 10000), the money Alice has now f (0 ≤ f ≤ 10000) and the price of the book b (100 ≤ b ≤ 20000). Output Output a line suggesting the minimum amount of money you need to borrow from Alice. Output "NA" if all the money Alice has with him now is not a sufficient amount for you to buy the book. Examples Input 1000 3000 3000 Output 2000 Input 5000 3000 4500 Output 0 Input 500 1000 2000 Output NA The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. The JOI Railways is the only railway company in the Kingdom of JOI. There are $N$ stations numbered from $1$ to $N$ along a railway. Currently, two kinds of trains are operated; one is express and the other one is local. A local train stops at every station. For each $i$ ($1 \leq i < N$), by a local train, it takes $A$ minutes from the station $i$ to the station ($i + 1$). An express train stops only at the stations $S_1, S_2, ..., S_M$ ($1 = S_1 < S_2 < ... < S_M = N$). For each $i$ ($1 \leq i < N$), by an express train, it takes $B$ minutes from the station $i$ to the station ($i + 1$). The JOI Railways plans to operate another kind of trains called "semiexpress." For each $i$ ($1 \leq i < N$), by a semiexpress train, it takes $C$ minutes from the station $i$ to the station ($i + 1$). The stops of semiexpress trains are not yet determined. But they must satisfy the following conditions: * Semiexpress trains must stop at every station where express trains stop. * Semiexpress trains must stop at $K$ stations exactly. The JOI Railways wants to maximize the number of stations (except for the station 1) to which we can travel from the station 1 within $T$ minutes. The JOI Railways plans to determine the stops of semiexpress trains so that this number is maximized. We do not count the standing time of trains. When we travel from the station 1 to another station, we can take trains only to the direction where the numbers of stations increase. If several kinds of trains stop at the station $i$ ($2 \leq i \leq N - 1$), you can transfer between any trains which stop at that station. When the stops of semiexpress trains are determined appropriately, what is the maximum number of stations (except for the station 1) to which we can travel from the station 1 within $T$ minutes? Task Given the number of stations of the JOI Railways, the stops of express trains, the speeds of the trains, and maximum travel time, write a program which calculates the maximum number of stations which satisfy the condition on the travel time. Input Read the following data from the standard input. * The first line of input contains three space separated integers $N$, $M$, $K$. This means there are $N$ stations of the JOI Railways, an express train stops at $M$ stations, and a semiexpress train stops at $K$ stations, * The second line of input contains three space separated integers $A$, $B$, $C$. This means it takes $A$, $B$, $C$ minutes by a local, express, semiexpress train to travel from a station to the next station, respectively. >li> The third line of input contains an integer $T$. This means the JOI Railways wants to maximize the number of stations (except for the station 1) to which we can travel from the station 1 within $T$ minutes. * The $i$-th line ($1 \leq i \leq M$) of the following $M$ lines contains an integer $S_i$. This means an express train stops at the station $S_i$. Output Write one line to the standard output. The output contains the maximum number of stations satisfying the condition on the travel time. Constraints All input data satisfy the following conditions. * $2 \leq N \leq 1 000 000 000．$ * $2 \leq M \leq K \leq 3 000．$ * $K \leq N．$ * $1 \leq B < C < A \leq 1 000 000 000．$ * $1 \leq T \leq 10^{18}$ * $1 = S_1 < S_2 < ... < S_M = N$ Sample Input and Output Sample Input 1 10 3 5 10 3 5 30 1 6 10 Sample Output 1 8 In this sample input, there are 10 stations of the JOI Railways. An express train stops at three stations 1, 6, 10. Assume that the stops of an semiexpress train are 1, 5, 6, 8, 10. Then, among the stations 2, 3, ...10, we can travel from the station 1 to every station except for the station 9 within 30 minutes. For some $i$, the travel time and the route from the station 1 to the station $i$ are as follows: * From the station 1 to the station 3, we can travel using a local train only. The travel time is 20 minutes. * From the station 1 to the station 7, we travel from the station 1 to the station 6 by an express train, and transfer to a local train. The travel time is 25 minutes. * From the station 1 to the station 8, we travel from the station 1 to the station 6 by an express train, and transfer to a semiexpress train. The travel time is 25 minutes. * From the station 1 to the station 9, we travel from the station 1 to the station 6 by an express train, from the station 6 to the station 8 by a semiexpress train, and from the station 8 to the station 9 by a local train. In total, the travel time is 35 minutes. Sample Input 2 10 3 5 10 3 5 25 1 6 10 Sample Output 2 7 Sample Input 3 90 10 12 100000 1000 10000 10000 1 10 20 30 40 50 60 70 80 90 Sample Output 2 2 Sample Input 4 12 3 4 10 1 2 30 1 11 12 Sample Output 4 8 Sample Input 5 300 8 16 345678901 123456789 234567890 12345678901 1 10 77 82 137 210 297 300 Sample Output 5 72 Sample Input 6 1000000000 2 3000 1000000000 1 2 1000000000 1 1000000000 Sample Output 6 3000 Creative Commonse License The 16th Japanese Olympiad in Informatics (JOI 2016/2017) Final Round Example Input 10 3 5 10 3 5 30 1 6 10 Output 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. You are given N points in the xy-plane. You have a circle of radius one and move it on the xy-plane, so as to enclose as many of the points as possible. Find how many points can be simultaneously enclosed at the maximum. A point is considered enclosed by a circle when it is inside or on the circle. <image> Fig 1. Circle and Points Input The input consists of a series of data sets, followed by a single line only containing a single character '0', which indicates the end of the input. Each data set begins with a line containing an integer N, which indicates the number of points in the data set. It is followed by N lines describing the coordinates of the points. Each of the N lines has two decimal fractions X and Y, describing the x- and y-coordinates of a point, respectively. They are given with five digits after the decimal point. You may assume 1 <= N <= 300, 0.0 <= X <= 10.0, and 0.0 <= Y <= 10.0. No two points are closer than 0.0001. No two points in a data set are approximately at a distance of 2.0. More precisely, for any two points in a data set, the distance d between the two never satisfies 1.9999 <= d <= 2.0001. Finally, no three points in a data set are simultaneously very close to a single circle of radius one. More precisely, let P1, P2, and P3 be any three points in a data set, and d1, d2, and d3 the distances from an arbitrarily selected point in the xy-plane to each of them respectively. Then it never simultaneously holds that 0.9999 <= di <= 1.0001 (i = 1, 2, 3). Output For each data set, print a single line containing the maximum number of points in the data set that can be simultaneously enclosed by a circle of radius one. No other characters including leading and trailing spaces should be printed. Example Input 3 6.47634 7.69628 5.16828 4.79915 6.69533 6.20378 6 7.15296 4.08328 6.50827 2.69466 5.91219 3.86661 5.29853 4.16097 6.10838 3.46039 6.34060 2.41599 8 7.90650 4.01746 4.10998 4.18354 4.67289 4.01887 6.33885 4.28388 4.98106 3.82728 5.12379 5.16473 7.84664 4.67693 4.02776 3.87990 20 6.65128 5.47490 6.42743 6.26189 6.35864 4.61611 6.59020 4.54228 4.43967 5.70059 4.38226 5.70536 5.50755 6.18163 7.41971 6.13668 6.71936 3.04496 5.61832 4.23857 5.99424 4.29328 5.60961 4.32998 6.82242 5.79683 5.44693 3.82724 6.70906 3.65736 7.89087 5.68000 6.23300 4.59530 5.92401 4.92329 6.24168 3.81389 6.22671 3.62210 0 Output 2 5 5 11 The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. 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 develop physical strength and judgment by running on a straight road. The rabbit is now standing at the starting line and looking out over a long, long road. There are some carrots along the way, and rabbits can accelerate by eating carrots. Rabbits run at U meters per second when not accelerating, but by eating carrots, the speed is V meters per second from the last carrot eaten to T seconds later. Rabbits can also carry up to K carrots without eating them. Even if you have a carrot, the running speed does not change. Assuming that it does not take long to bring and eat carrots, I would like to find the shortest time required to reach the goal. Input N K T U V L D1 ... DN N is the number of carrots, L is the distance from the start to the goal (meters), and Di (1 ≤ i ≤ N) is the distance from the start where the i-th carrot is located (meters). 1 ≤ N ≤ 200, 1 ≤ K ≤ N, 1 ≤ T ≤ 10,000, 1 ≤ U <V ≤ 10,000, 2 ≤ L ≤ 10,000, 0 <D1 <D2 <... <DN <L. All input values are integers. Output Output the shortest required time (seconds) on one line. Absolute errors of 10-6 or less are allowed. Examples Input 1 1 1 2 3 100 50 Output 49.500000000 Input 3 1 1 2 3 100 49 50 51 Output 48.666666667 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. Nathan O. Davis has been running an electronic bulletin board system named JAG-channel. He is now having hard time to add a new feature there --- threaded view. Like many other bulletin board systems, JAG-channel is thread-based. Here a thread (also called a topic) refers to a single conversation with a collection of posts. Each post can be an opening post, which initiates a new thread, or a reply to a previous post in an existing thread. Threaded view is a tree-like view that reflects the logical reply structure among the posts: each post forms a node of the tree and contains its replies as its subnodes in the chronological order (i.e. older replies precede newer ones). Note that a post along with its direct and indirect replies forms a subtree as a whole. Let us take an example. Suppose: a user made an opening post with a message `hoge`; another user replied to it with `fuga`; yet another user also replied to the opening post with `piyo`; someone else replied to the second post (i.e. `fuga`”) with `foobar`; and the fifth user replied to the same post with `jagjag`. The tree of this thread would look like: hoge ├─fuga │　├─foobar │　└─jagjag └─piyo For easier implementation, Nathan is thinking of a simpler format: the depth of each post from the opening post is represented by dots. Each reply gets one more dot than its parent post. The tree of the above thread would then look like: hoge .fuga ..foobar ..jagjag .piyo Your task in this problem is to help Nathan by writing a program that prints a tree in the Nathan's format for the given posts in a single thread. Input Input contains a single dataset in the following format: n k_1 M_1 k_2 M_2 : : k_n M_n The first line contains an integer n (1 ≤ n ≤ 1,000), which is the number of posts in the thread. Then 2n lines follow. Each post is represented by two lines: the first line contains an integer k_i (k_1 = 0, 1 ≤ k_i < i for 2 ≤ i ≤ n) and indicates the i-th post is a reply to the k_i-th post; the second line contains a string M_i and represents the message of the i-th post. k_1 is always 0, which means the first post is not replying to any other post, i.e. it is an opening post. Each message contains 1 to 50 characters, consisting of uppercase, lowercase, and numeric letters. Output Print the given n messages as specified in the problem statement. Sample Input 1 1 0 icpc Output for the Sample Input 1 icpc Sample Input 2 5 0 hoge 1 fuga 1 piyo 2 foobar 2 jagjag Output for the Sample Input 2 hoge .fuga ..foobar ..jagjag .piyo Sample Input 3 8 0 jagjag 1 hogehoge 1 buhihi 2 fugafuga 4 ponyoponyo 5 evaeva 4 nowawa 5 pokemon Output for the Sample Input 3 jagjag .hogehoge ..fugafuga ...ponyoponyo ....evaeva ....pokemon ...nowawa .buhihi Sample Input 4 6 0 nakachan 1 fan 2 yamemasu 3 nennryou2 4 dannyaku4 5 kouzai11 Output for the Sample Input 4 nakachan .fan ..yamemasu ...nennryou2 ....dannyaku4 .....kouzai11 Sample Input 5 34 0 LoveLive 1 honoka 2 borarara 2 sunohare 2 mogyu 1 eri 6 kasikoi 7 kawaii 8 eriichika 1 kotori 10 WR 10 haetekurukotori 10 ichigo 1 umi 14 love 15 arrow 16 shoot 1 rin 18 nyanyanya 1 maki 20 6th 20 star 22 nishikino 1 nozomi 24 spiritual 25 power 1 hanayo 27 darekatasukete 28 chottomattete 1 niko 30 natsuiro 30 nikkonikkoni 30 sekaino 33 YAZAWA Output for the Sample Input 5 LoveLive .honoka ..borarara ..sunohare ..mogyu .eri ..kasikoi ...kawaii ....eriichika .kotori ..WR ..haetekurukotori ..ichigo .umi ..love ...arrow ....shoot .rin ..nyanyanya .maki ..6th ..star ...nishikino .nozomi ..spiritual ...power .hanayo ..darekatasukete ...chottomattete .niko ..natsuiro ..nikkonikkoni ..sekaino ...YAZAWA Sample Input 6 6 0 2ch 1 1ostu 1 2get 1 1otsu 1 1ostu 3 pgr Output for the Sample Input 6 2ch .1ostu .2get ..pgr .1otsu .1ostu Example Input 1 0 icpc Output icpc The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Problem If you bring an empty bottle of $ a $ milk, you can exchange it for a new bottle of $ b $ milk. How many bottles of milk can Mr. Kawabayashi, who initially has a bottle of $ x $ milk, drink? Output the remainder after dividing by $ 1000000007 $. Constraints The input satisfies the following conditions. * $ 1 \ leq a \ leq 10 ^ {15} $ * $ 0 \ leq b \ lt a $ * $ 0 \ leq x \ leq 10 ^ {15} $ Input The input is given in the following format. $ a $ $ b $ $ x $ Three integers $ a $, $ b $, $ x $ are given, separated by spaces. Output Print the answer on one line. Examples Input 3 1 5 Output 7 Input 3 2 5 Output 11 Input 82 69 64 Output 64 Input 316250877917604 316250877917599 681260158257385 Output 62687552 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 given three points p1, p2, p, find the reflection point x of p onto p1p2. <image> Constraints * 1 ≤ q ≤ 1000 * -10000 ≤ xi, yi ≤ 10000 * p1 and p2 are not identical. Input xp1 yp1 xp2 yp2 q xp0 yp0 xp1 yp1 ... xpq−1 ypq−1 In the first line, integer coordinates of p1 and p2 are given. Then, q queries are given for integer coordinates of p. Output For each query, print the coordinate of the reflection point x. The output values should be in a decimal fraction with an error less than 0.00000001. Examples Input 0 0 2 0 3 -1 1 0 1 1 1 Output -1.0000000000 -1.0000000000 0.0000000000 -1.0000000000 1.0000000000 -1.0000000000 Input 0 0 3 4 3 2 5 1 4 0 3 Output 4.2400000000 3.3200000000 3.5600000000 2.0800000000 2.8800000000 0.8400000000 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 $n$ lists $L_i$ $(i = 0, 1, ..., n-1)$, perform a sequence of the following operations. * insert($t$, $x$): Insert an integer $x$ at the end of $L_t$. * dump($t$): Print all elements in $L_t$. * splice($s$, $t$): Transfer elements of $L_s$ to the end of $L_t$. $L_s$ becomes empty. In the initial state, $L_i$ $(i = 0, 1, ..., n-1)$ are empty. Constraints * $1 \leq n \leq 1,000$ * $1 \leq q \leq 500,000$ * For a splice operation, $s \ne t$ * For a splice operation, $L_s$ is not empty * The total number of elements printed by dump operations do not exceed 1,000,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 $s$ $t$ where the first digits 0, 1 and 2 represent insert, dump and splice operations respectively. Output For each dump operation, print elements of the corresponding list in a line. Separete adjacency elements by a space character (do not print the space after the last element). Note that, if the list is empty, an empty line should be printed. Example Input 3 10 0 0 1 0 0 2 0 0 3 0 1 4 0 1 5 2 1 0 0 2 6 1 0 1 1 1 2 Output 1 2 3 4 5 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. Did you know that Chwee kueh, a cuisine of Singapore, means water rice cake ? Its a variety of the most popular South Indian savory cake, only that we call it here idli :). The tastiest idlis are made in Chennai, by none other than our famous chef, Dexter Murugan. Being very popular, he is flown from Marina to Miami, to serve idlis in the opening ceremony of icpc world finals ( which is happening right now ! ). There are N students and they are initially served with some idlis. Some of them are angry because they got less idlis than some other. Dexter decides to redistribute the idlis so they all get equal number of idlis finally. He recollects his father's code, "Son, if you ever want to redistribute idlis, follow this method. While there are two persons with unequal number of idlis, repeat the following step. Select two persons A and B, A having the maximum and B having the minimum number of idlis, currently. If there are multiple ways to select A (similarly B), select any one randomly. Let A and B have P and Q number of idlis respectively and R = ceil( ( P - Q ) / 2 ), Transfer R idlis from A to B." Given the initial number of idlis served to each student, find the number of times Dexter has to repeat the above step. If he can not distribute idlis equally by following the above method, print -1. Notes ceil(x) is the smallest integer that is not less than x. Input First line contains an integer T ( number of test cases, around 20 ). T cases follows. Each case starts with an integer N ( 1 <= N <= 3000 ). Next line contains an array A of N integers separated by spaces, the initial number of idlis served ( 0 <= A[i] <= N ) Output For each case, output the number of times Dexter has to repeat the given step to distribute idlis equally or -1 if its not possible. Example Input: 3 4 1 2 2 3 2 1 2 7 1 2 3 4 5 6 7 Output: 1 -1 3 Explanation: Case 1 : { 1, 2, 2, 3}. Maximum 3, Minimum 1. R = ceil((3-1)/2) = 1. Transfer 1 idli from person having 3 idlis to the person having 1 idli. Each of them has 2 idlis now, so just 1 step is enough. Case 2 : {1,2} R = ceil((2-1)/2) = 1. {1,2} -> {2,1} -> {1,2} .... they can never get equal idlis :( Case 3 : Sorted arrays, in the order encountered {1, 2, 3, 4, 5, 6, 7} -> {2, 3, 4, 4, 4, 5, 6} -> {3, 4, 4, 4, 4, 4, 5} -> {4, 4, 4, 4, 4, 4, 4} NoteThere are multiple test sets, and the judge shows the sum of the time taken over all test sets of your submission, if Accepted. Time limit on each test set is 3 sec 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 Gerald studies at school which is quite far from his house. That's why he has to go there by bus every day. The way from home to school is represented by a segment of a straight line; the segment contains exactly n + 1 bus stops. All of them are numbered with integers from 0 to n in the order in which they follow from Gerald's home. The bus stop by Gerald's home has number 0 and the bus stop by the school has number n. There are m buses running between the house and the school: the i-th bus goes from stop si to ti (si < ti), visiting all the intermediate stops in the order in which they follow on the segment. Besides, Gerald's no idiot and he wouldn't get off the bus until it is still possible to ride on it closer to the school (obviously, getting off would be completely pointless). In other words, Gerald can get on the i-th bus on any stop numbered from si to ti - 1 inclusive, but he can get off the i-th bus only on the bus stop ti. Gerald can't walk between the bus stops and he also can't move in the direction from the school to the house. Gerald wants to know how many ways he has to get from home to school. Tell him this number. Two ways are considered different if Gerald crosses some segment between the stops on different buses. As the number of ways can be too much, find the remainder of a division of this number by 1000000007 (109 + 7). Input The first line contains two space-separated integers: n and m (1 ≤ n ≤ 109, 0 ≤ m ≤ 105). Then follow m lines each containing two integers si, ti. They are the numbers of starting stops and end stops of the buses (0 ≤ si < ti ≤ n). Output Print the only number — the number of ways to get to the school modulo 1000000007 (109 + 7). Examples Input 2 2 0 1 1 2 Output 1 Input 3 2 0 1 1 2 Output 0 Input 5 5 0 1 0 2 0 3 0 4 0 5 Output 16 Note The first test has the only variant to get to school: first on bus number one to the bus stop number one; then on bus number two to the bus stop number two. In the second test no bus goes to the third bus stop, where the school is positioned. Thus, the correct answer is 0. In the third test Gerald can either get or not on any of the first four buses to get closer to the school. Thus, the correct answer is 24 = 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. You are given a grid, consisting of 2 rows and n columns. Each cell of this grid should be colored either black or white. Two cells are considered neighbours if they have a common border and share the same color. Two cells A and B belong to the same component if they are neighbours, or if there is a neighbour of A that belongs to the same component with B. Let's call some bicoloring beautiful if it has exactly k components. Count the number of beautiful bicolorings. The number can be big enough, so print the answer modulo 998244353. Input The only line contains two integers n and k (1 ≤ n ≤ 1000, 1 ≤ k ≤ 2n) — the number of columns in a grid and the number of components required. Output Print a single integer — the number of beautiful bicolorings modulo 998244353. Examples Input 3 4 Output 12 Input 4 1 Output 2 Input 1 2 Output 2 Note One of possible bicolorings in sample 1: <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. You are given two integers l and r (l ≤ r). Your task is to calculate the sum of numbers from l to r (including l and r) such that each number contains at most k different digits, and print this sum modulo 998244353. For example, if k = 1 then you have to calculate all numbers from l to r such that each number is formed using only one digit. For l = 10, r = 50 the answer is 11 + 22 + 33 + 44 = 110. Input The only line of the input contains three integers l, r and k (1 ≤ l ≤ r < 10^{18}, 1 ≤ k ≤ 10) — the borders of the segment and the maximum number of different digits. Output Print one integer — the sum of numbers from l to r such that each number contains at most k different digits, modulo 998244353. Examples Input 10 50 2 Output 1230 Input 1 2345 10 Output 2750685 Input 101 154 2 Output 2189 Note For the first example the answer is just the sum of numbers from l to r which equals to (50 ⋅ 51)/(2) - (9 ⋅ 10)/(2) = 1230. This example also explained in the problem statement but for k = 1. For the second example the answer is just the sum of numbers from l to r which equals to (2345 ⋅ 2346)/(2) = 2750685. For the third example the answer is 101 + 110 + 111 + 112 + 113 + 114 + 115 + 116 + 117 + 118 + 119 + 121 + 122 + 131 + 133 + 141 + 144 + 151 = 2189. 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 bracket sequence s consisting of n opening '(' and closing ')' brackets. A regular bracket sequence is a bracket sequence that can be transformed into a correct arithmetic expression by inserting characters '1' and '+' between the original characters of the sequence. For example, bracket sequences "()()", "(())" are regular (the resulting expressions are: "(1)+(1)", "((1+1)+1)"), and ")(" and "(" are not. You can change the type of some bracket s_i. It means that if s_i = ')' then you can change it to '(' and vice versa. Your task is to calculate the number of positions i such that if you change the type of the i-th bracket, then the resulting bracket sequence becomes regular. Input The first line of the input contains one integer n (1 ≤ n ≤ 10^6) — the length of the bracket sequence. The second line of the input contains the string s consisting of n opening '(' and closing ')' brackets. Output Print one integer — the number of positions i such that if you change the type of the i-th bracket, then the resulting bracket sequence becomes regular. Examples Input 6 (((()) Output 3 Input 6 ()()() Output 0 Input 1 ) Output 0 Input 8 )))((((( 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. Kurt reaches nirvana when he finds the product of all the digits of some positive integer. Greater value of the product makes the nirvana deeper. Help Kurt find the maximum possible product of digits among all integers from 1 to n. Input The only input line contains the integer n (1 ≤ n ≤ 2⋅10^9). Output Print the maximum product of digits among all integers from 1 to n. Examples Input 390 Output 216 Input 7 Output 7 Input 1000000000 Output 387420489 Note In the first example the maximum product is achieved for 389 (the product of digits is 3⋅8⋅9=216). In the second example the maximum product is achieved for 7 (the product of digits is 7). In the third example the maximum product is achieved for 999999999 (the product of digits is 9^9=387420489). 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 problem is same as the previous one, but has larger constraints. Shiro's just moved to the new house. She wants to invite all friends of her to the house so they can play monopoly. However, her house is too small, so she can only invite one friend at a time. For each of the n days since the day Shiro moved to the new house, there will be exactly one cat coming to the Shiro's house. The cat coming in the i-th day has a ribbon with color u_i. Shiro wants to know the largest number x, such that if we consider the streak of the first x days, it is possible to remove exactly one day from this streak so that every ribbon color that has appeared among the remaining x - 1 will have the same number of occurrences. For example, consider the following sequence of u_i: [2, 2, 1, 1, 5, 4, 4, 5]. Then x = 7 makes a streak, since if we remove the leftmost u_i = 5, each ribbon color will appear exactly twice in the prefix of x - 1 days. Note that x = 8 doesn't form a streak, since you must remove exactly one day. Since Shiro is just a cat, she is not very good at counting and needs your help finding the longest streak. Input The first line contains a single integer n (1 ≤ n ≤ 10^5) — the total number of days. The second line contains n integers u_1, u_2, …, u_n (1 ≤ u_i ≤ 10^5) — the colors of the ribbons the cats wear. Output Print a single integer x — the largest possible streak of days. Examples Input 13 1 1 1 2 2 2 3 3 3 4 4 4 5 Output 13 Input 5 10 100 20 200 1 Output 5 Input 1 100000 Output 1 Input 7 3 2 1 1 4 5 1 Output 6 Input 6 1 1 1 2 2 2 Output 5 Note In the first example, we can choose the longest streak of 13 days, since upon removing the last day out of the streak, all of the remaining colors 1, 2, 3, and 4 will have the same number of occurrences of 3. Note that the streak can also be 10 days (by removing the 10-th day from this streak) but we are interested in the longest streak. In the fourth example, if we take the streak of the first 6 days, we can remove the third day from this streak then all of the remaining colors 1, 2, 3, 4 and 5 will occur exactly once. 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 the easy and the hard versions is constraints. A subsequence is a string that can be derived from another string by deleting some or no symbols without changing the order of the remaining symbols. Characters to be deleted are not required to go successively, there can be any gaps between them. For example, for the string "abaca" the following strings are subsequences: "abaca", "aba", "aaa", "a" and "" (empty string). But the following strings are not subsequences: "aabaca", "cb" and "bcaa". You are given a string s consisting of n lowercase Latin letters. In one move you can take any subsequence t of the given string and add it to the set S. The set S can't contain duplicates. This move costs n - \|t\|, where \|t\| is the length of the added subsequence (i.e. the price equals to the number of the deleted characters). Your task is to find out the minimum possible total cost to obtain a set S of size k or report that it is impossible to do so. Input The first line of the input contains two integers n and k (1 ≤ n ≤ 100, 1 ≤ k ≤ 10^{12}) — the length of the string and the size of the set, correspondingly. The second line of the input contains a string s consisting of n lowercase Latin letters. Output Print one integer — if it is impossible to obtain the set S of size k, print -1. Otherwise, print the minimum possible total cost to do it. Examples Input 4 5 asdf Output 4 Input 5 6 aaaaa Output 15 Input 5 7 aaaaa Output -1 Input 10 100 ajihiushda Output 233 Note In the first example we can generate S = { "asdf", "asd", "adf", "asf", "sdf" }. The cost of the first element in S is 0 and the cost of the others is 1. So the total cost of S is 4. The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. You are given an array a of n integers, where n is odd. You can make the following operation with it: * Choose one of the elements of the array (for example a_i) and increase it by 1 (that is, replace it with a_i + 1). You want to make the median of the array the largest possible using at most k operations. The median of the odd-sized array is the middle element after the array is sorted in non-decreasing order. For example, the median of the array [1, 5, 2, 3, 5] is 3. Input The first line contains two integers n and k (1 ≤ n ≤ 2 ⋅ 10^5, n is odd, 1 ≤ k ≤ 10^9) — the number of elements in the array and the largest number of operations you can make. The second line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^9). Output Print a single integer — the maximum possible median after the operations. Examples Input 3 2 1 3 5 Output 5 Input 5 5 1 2 1 1 1 Output 3 Input 7 7 4 1 2 4 3 4 4 Output 5 Note In the first example, you can increase the second element twice. Than array will be [1, 5, 5] and it's median is 5. In the second example, it is optimal to increase the second number and than increase third and fifth. This way the answer is 3. In the third example, you can make four operations: increase first, fourth, sixth, seventh element. This way the array will be [5, 1, 2, 5, 3, 5, 5] and the median will be 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. This problem is different from the easy version. In this version Ujan makes at most 2n swaps. In addition, k ≤ 1000, n ≤ 50 and it is necessary to print swaps themselves. You can hack this problem if you solve it. But you can hack the previous problem only if you solve both problems. After struggling and failing many times, Ujan decided to try to clean up his house again. He decided to get his strings in order first. Ujan has two distinct strings s and t of length n consisting of only of lowercase English characters. He wants to make them equal. Since Ujan is lazy, he will perform the following operation at most 2n times: he takes two positions i and j (1 ≤ i,j ≤ n, the values i and j can be equal or different), and swaps the characters s_i and t_j. Ujan's goal is to make the strings s and t equal. He does not need to minimize the number of performed operations: any sequence of operations of length 2n or shorter is suitable. Input The first line contains a single integer k (1 ≤ k ≤ 1000), the number of test cases. For each of the test cases, the first line contains a single integer n (2 ≤ n ≤ 50), the length of the strings s and t. Each of the next two lines contains the strings s and t, each having length exactly n. The strings consist only of lowercase English letters. It is guaranteed that strings are different. Output For each test case, output "Yes" if Ujan can make the two strings equal with at most 2n operations and "No" otherwise. You can print each letter in any case (upper or lower). In the case of "Yes" print m (1 ≤ m ≤ 2n) on the next line, where m is the number of swap operations to make the strings equal. Then print m lines, each line should contain two integers i, j (1 ≤ i, j ≤ n) meaning that Ujan swaps s_i and t_j during the corresponding operation. You do not need to minimize the number of operations. Any sequence of length not more than 2n is suitable. Example Input 4 5 souse houhe 3 cat dog 2 aa az 3 abc bca Output Yes 1 1 4 No No Yes 3 1 2 3 1 2 3 The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. You have three piles of candies: red, green and blue candies: * the first pile contains only red candies and there are r candies in it, * the second pile contains only green candies and there are g candies in it, * the third pile contains only blue candies and there are b candies in it. Each day Tanya eats exactly two candies of different colors. She is free to choose the colors of eaten candies: the only restriction that she can't eat two candies of the same color in a day. Find the maximal number of days Tanya can eat candies? Each day she needs to eat exactly two candies. Input The first line contains integer t (1 ≤ t ≤ 1000) — the number of test cases in the input. Then t test cases follow. Each test case is given as a separate line of the input. It contains three integers r, g and b (1 ≤ r, g, b ≤ 10^8) — the number of red, green and blue candies, respectively. Output Print t integers: the i-th printed integer is the answer on the i-th test case in the input. Example Input 6 1 1 1 1 2 1 4 1 1 7 4 10 8 1 4 8 2 8 Output 1 2 2 10 5 9 Note In the first example, Tanya can eat candies for one day only. She can eat any pair of candies this day because all of them have different colors. In the second example, Tanya can eat candies for two days. For example, she can eat red and green candies on the first day, and green and blue candies on the second day. In the third example, Tanya can eat candies for two days. For example, she can eat red and green candies on the first day, and red and blue candies on the second day. Note, that two red candies will remain uneaten. 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. Filled with optimism, Hyunuk will host a conference about how great this new year will be! The conference will have n lectures. Hyunuk has two candidate venues a and b. For each of the n lectures, the speaker specified two time intervals [sa_i, ea_i] (sa_i ≤ ea_i) and [sb_i, eb_i] (sb_i ≤ eb_i). If the conference is situated in venue a, the lecture will be held from sa_i to ea_i, and if the conference is situated in venue b, the lecture will be held from sb_i to eb_i. Hyunuk will choose one of these venues and all lectures will be held at that venue. Two lectures are said to overlap if they share any point in time in common. Formally, a lecture held in interval [x, y] overlaps with a lecture held in interval [u, v] if and only if max(x, u) ≤ min(y, v). We say that a participant can attend a subset s of the lectures if the lectures in s do not pairwise overlap (i.e. no two lectures overlap). Note that the possibility of attending may depend on whether Hyunuk selected venue a or venue b to hold the conference. A subset of lectures s is said to be venue-sensitive if, for one of the venues, the participant can attend s, but for the other venue, the participant cannot attend s. A venue-sensitive set is problematic for a participant who is interested in attending the lectures in s because the participant cannot be sure whether the lecture times will overlap. Hyunuk will be happy if and only if there are no venue-sensitive sets. Determine whether Hyunuk will be happy. Input The first line contains an integer n (1 ≤ n ≤ 100 000), the number of lectures held in the conference. Each of the next n lines contains four integers sa_i, ea_i, sb_i, eb_i (1 ≤ sa_i, ea_i, sb_i, eb_i ≤ 10^9, sa_i ≤ ea_i, sb_i ≤ eb_i). Output Print "YES" if Hyunuk will be happy. Print "NO" otherwise. You can print each letter in any case (upper or lower). Examples Input 2 1 2 3 6 3 4 7 8 Output YES Input 3 1 3 2 4 4 5 6 7 3 4 5 5 Output NO Input 6 1 5 2 9 2 4 5 8 3 6 7 11 7 10 12 16 8 11 13 17 9 12 14 18 Output YES Note In second example, lecture set \{1, 3\} is venue-sensitive. Because participant can't attend this lectures in venue a, but can attend in venue b. In first and third example, venue-sensitive set does not exist. The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Andrey's favourite number is n. Andrey's friends gave him two identical numbers n as a New Year present. He hung them on a wall and watched them adoringly. Then Andrey got bored from looking at the same number and he started to swap digits first in one, then in the other number, then again in the first number and so on (arbitrary number of changes could be made in each number). At some point it turned out that if we sum the resulting numbers, then the number of zeroes with which the sum will end would be maximum among the possible variants of digit permutations in those numbers. Given number n, can you find the two digit permutations that have this property? Input The first line contains a positive integer n — the original number. The number of digits in this number does not exceed 105. The number is written without any leading zeroes. Output Print two permutations of digits of number n, such that the sum of these numbers ends with the maximum number of zeroes. The permutations can have leading zeroes (if they are present, they all should be printed). The permutations do not have to be different. If there are several answers, print any of them. Examples Input 198 Output 981 819 Input 500 Output 500 500 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 an interactive problem. Homer likes arrays a lot and he wants to play a game with you. Homer has hidden from you a permutation a_1, a_2, ..., a_n of integers 1 to n. You are asked to find any index k (1 ≤ k ≤ n) which is a local minimum. For an array a_1, a_2, ..., a_n, an index i (1 ≤ i ≤ n) is said to be a local minimum if a_i < min\\{a_{i-1},a_{i+1}\}, where a_0 = a_{n+1} = +∞. An array is said to be a permutation of integers 1 to n, if it contains all integers from 1 to n exactly once. Initially, you are only given the value of n without any other information about this permutation. At each interactive step, you are allowed to choose any i (1 ≤ i ≤ n) and make a query with it. As a response, you will be given the value of a_i. You are asked to find any index k which is a local minimum after at most 100 queries. Interaction You begin the interaction by reading an integer n (1≤ n ≤ 10^5) on a separate line. To make a query on index i (1 ≤ i ≤ n), you should output "? i" in a separate line. Then read the value of a_i in a separate line. The number of the "?" queries is limited within 100. When you find an index k (1 ≤ k ≤ n) which is a local minimum, output "! k" in a separate line and terminate your program. In case your query format is invalid, or you have made more than 100 "?" queries, you will receive Wrong Answer verdict. After printing a query do not forget to output end of line and flush the output. Otherwise, you will get Idleness limit exceeded. To do this, use: * fflush(stdout) or cout.flush() in C++; * System.out.flush() in Java; * flush(output) in Pascal; * stdout.flush() in Python; * see documentation for other languages. Hack Format The first line of the hack should contain a single integer n (1 ≤ n ≤ 10^5). The second line should contain n distinct integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n). Example Input 5 3 2 1 4 5 Output ? 1 ? 2 ? 3 ? 4 ? 5 ! 3 Note In the example, the first line contains an integer 5 indicating that the length of the array is n = 5. The example makes five "?" queries, after which we conclude that the array is a = [3,2,1,4,5] and k = 3 is local minimum. 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. Input The first line of the input contains a single integer N (1 ≤ N ≤ 24). The next N lines contain 5 space-separated integers each. The first three integers will be between 0 and 2, inclusive. The last two integers will be between 0 and 3, inclusive. The sum of the first three integers will be equal to the sum of the last two integers. Output Output the result – a string of lowercase English letters. Examples Input 1 1 0 0 1 0 Output a Input 10 2 0 0 1 1 1 1 1 2 1 2 1 0 1 2 1 1 0 1 1 2 1 0 2 1 1 1 1 2 1 1 2 1 3 1 2 0 0 1 1 1 1 0 1 1 1 1 2 2 2 Output codeforcez 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. Eshag has an array a consisting of n integers. Eshag can perform the following operation any number of times: choose some subsequence of a and delete every element from it which is strictly larger than AVG, where AVG is the average of the numbers in the chosen subsequence. For example, if a = [1 , 4 , 3 , 2 , 4] and Eshag applies the operation to the subsequence containing a_1, a_2, a_4 and a_5, then he will delete those of these 4 elements which are larger than (a_1+a_2+a_4+a_5)/(4) = 11/4, so after the operation, the array a will become a = [1 , 3 , 2]. Your task is to find the maximum number of elements Eshag can delete from the array a by applying the operation described above some number (maybe, zero) times. A sequence b is a subsequence of an array c if b can be obtained from c by deletion of several (possibly, zero or all) elements. Input The first line contains an integer t (1≤ t≤ 100) — the number of test cases. The description of the test cases follows. The first line of each test case contains an integer n (1≤ n≤ 100) — the length of the array a. The second line of each test case contains n integers a_1, a_2, …, a_n (1≤ a_i ≤ 100) — the elements of the array a. Output For each test case print a single integer — the maximum number of elements Eshag can delete from the array a. Example Input 3 6 1 1 1 2 2 3 6 9 9 9 9 9 9 6 6 4 1 1 4 1 Output 3 0 3 Note Consider the first test case. Initially a = [1, 1, 1, 2, 2, 3]. In the first operation, Eshag can choose the subsequence containing a_1, a_5 and a_6, their average is equal to (a_1 + a_5 + a_6)/(3) = 6/3 = 2. So a_6 will be deleted. After this a = [1, 1, 1, 2, 2]. In the second operation, Eshag can choose the subsequence containing the whole array a, the average of all its elements is equal to 7/5. So a_4 and a_5 will be deleted. After this a = [1, 1, 1]. In the second test case, Eshag can't delete any element. 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. Imagine that you have a twin brother or sister. Having another person that looks exactly like you seems very unusual. It's hard to say if having something of an alter ego is good or bad. And if you do have a twin, then you very well know what it's like. Now let's imagine a typical morning in your family. You haven't woken up yet, and Mom is already going to work. She has been so hasty that she has nearly forgotten to leave the two of her darling children some money to buy lunches in the school cafeteria. She fished in the purse and found some number of coins, or to be exact, n coins of arbitrary values a1, a2, ..., an. But as Mom was running out of time, she didn't split the coins for you two. So she scribbled a note asking you to split the money equally. As you woke up, you found Mom's coins and read her note. "But why split the money equally?" — you thought. After all, your twin is sleeping and he won't know anything. So you decided to act like that: pick for yourself some subset of coins so that the sum of values of your coins is strictly larger than the sum of values of the remaining coins that your twin will have. However, you correctly thought that if you take too many coins, the twin will suspect the deception. So, you've decided to stick to the following strategy to avoid suspicions: you take the minimum number of coins, whose sum of values is strictly more than the sum of values of the remaining coins. On this basis, determine what minimum number of coins you need to take to divide them in the described manner. Input The first line contains integer n (1 ≤ n ≤ 100) — the number of coins. The second line contains a sequence of n integers a1, a2, ..., an (1 ≤ ai ≤ 100) — the coins' values. All numbers are separated with spaces. Output In the single line print the single number — the minimum needed number of coins. Examples Input 2 3 3 Output 2 Input 3 2 1 2 Output 2 Note In the first sample you will have to take 2 coins (you and your twin have sums equal to 6, 0 correspondingly). If you take 1 coin, you get sums 3, 3. If you take 0 coins, you get sums 0, 6. Those variants do not satisfy you as your sum should be strictly more that your twins' sum. In the second sample one coin isn't enough for us, too. You can pick coins with values 1, 2 or 2, 2. In any case, the minimum number of coins equals 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. A widely known among some people Belarusian sport programmer Yura possesses lots of information about cars. That is why he has been invited to participate in a game show called "Guess That Car!". The game show takes place on a giant parking lot, which is 4n meters long from north to south and 4m meters wide from west to east. The lot has n + 1 dividing lines drawn from west to east and m + 1 dividing lines drawn from north to south, which divide the parking lot into n·m 4 by 4 meter squares. There is a car parked strictly inside each square. The dividing lines are numbered from 0 to n from north to south and from 0 to m from west to east. Each square has coordinates (i, j) so that the square in the north-west corner has coordinates (1, 1) and the square in the south-east corner has coordinates (n, m). See the picture in the notes for clarifications. Before the game show the organizers offer Yura to occupy any of the (n + 1)·(m + 1) intersection points of the dividing lines. After that he can start guessing the cars. After Yura chooses a point, he will be prohibited to move along the parking lot before the end of the game show. As Yura is a car expert, he will always guess all cars he is offered, it's just a matter of time. Yura knows that to guess each car he needs to spend time equal to the square of the euclidean distance between his point and the center of the square with this car, multiplied by some coefficient characterizing the machine's "rarity" (the rarer the car is, the harder it is to guess it). More formally, guessing a car with "rarity" c placed in a square whose center is at distance d from Yura takes c·d2 seconds. The time Yura spends on turning his head can be neglected. It just so happened that Yura knows the "rarity" of each car on the parking lot in advance. Help him choose his point so that the total time of guessing all cars is the smallest possible. Input The first line contains two integers n and m (1 ≤ n, m ≤ 1000) — the sizes of the parking lot. Each of the next n lines contains m integers: the j-th number in the i-th line describes the "rarity" cij (0 ≤ cij ≤ 100000) of the car that is located in the square with coordinates (i, j). Output In the first line print the minimum total time Yura needs to guess all offered cars. In the second line print two numbers li and lj (0 ≤ li ≤ n, 0 ≤ lj ≤ m) — the numbers of dividing lines that form a junction that Yura should choose to stand on at the beginning of the game show. If there are multiple optimal starting points, print the point with smaller li. If there are still multiple such points, print the point with smaller lj. 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. Examples Input 2 3 3 4 5 3 9 1 Output 392 1 1 Input 3 4 1 0 0 0 0 0 3 0 0 0 5 5 Output 240 2 3 Note In the first test case the total time of guessing all cars is equal to 3·8 + 3·8 + 4·8 + 9·8 + 5·40 + 1·40 = 392. The coordinate system of the field: <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. An expedition group flew from planet ACM-1 to Earth in order to study the bipedal species (its representatives don't even have antennas on their heads!). The flying saucer, on which the brave pioneers set off, consists of three sections. These sections are connected by a chain: the 1-st section is adjacent only to the 2-nd one, the 2-nd one — to the 1-st and the 3-rd ones, the 3-rd one — only to the 2-nd one. The transitions are possible only between the adjacent sections. The spacecraft team consists of n aliens. Each of them is given a rank — an integer from 1 to n. The ranks of all astronauts are distinct. The rules established on the Saucer, state that an alien may move from section a to section b only if it is senior in rank to all aliens who are in the segments a and b (besides, the segments a and b are of course required to be adjacent). Any alien requires exactly 1 minute to make a move. Besides, safety regulations require that no more than one alien moved at the same minute along the ship. Alien A is senior in rank to alien B, if the number indicating rank A, is more than the corresponding number for B. At the moment the whole saucer team is in the 3-rd segment. They all need to move to the 1-st segment. One member of the crew, the alien with the identification number CFR-140, decided to calculate the minimum time (in minutes) they will need to perform this task. Help CFR-140, figure out the minimum time (in minutes) that all the astronauts will need to move from the 3-rd segment to the 1-st one. Since this number can be rather large, count it modulo m. Input The first line contains two space-separated integers: n and m (1 ≤ n, m ≤ 109) — the number of aliens on the saucer and the number, modulo which you should print the answer, correspondingly. Output Print a single number — the answer to the problem modulo m. Examples Input 1 10 Output 2 Input 3 8 Output 2 Note In the first sample the only crew member moves from segment 3 to segment 2, and then from segment 2 to segment 1 without any problems. Thus, the whole moving will take two minutes. To briefly describe the movements in the second sample we will use value <image>, which would correspond to an alien with rank i moving from the segment in which it is at the moment, to the segment number j. Using these values, we will describe the movements between the segments in the second sample: <image>, <image>, <image>, <image>, <image>, <image>, <image>, <image>, <image>, <image>, <image>, <image>, <image>, <image>, <image>, <image>, <image>, <image>, <image>, <image>, <image>, <image>, <image>, <image>, <image>, <image>; In total: the aliens need 26 moves. The remainder after dividing 26 by 8 equals 2, so the answer to this test is 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. Little Petya likes points a lot. Recently his mom has presented him n points lying on the line OX. Now Petya is wondering in how many ways he can choose three distinct points so that the distance between the two farthest of them doesn't exceed d. Note that the order of the points inside the group of three chosen points doesn't matter. Input The first line contains two integers: n and d (1 ≤ n ≤ 105; 1 ≤ d ≤ 109). The next line contains n integers x1, x2, ..., xn, their absolute value doesn't exceed 109 — the x-coordinates of the points that Petya has got. It is guaranteed that the coordinates of the points in the input strictly increase. Output Print a single integer — the number of groups of three points, where the distance between two farthest points doesn't exceed d. 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. Examples Input 4 3 1 2 3 4 Output 4 Input 4 2 -3 -2 -1 0 Output 2 Input 5 19 1 10 20 30 50 Output 1 Note In the first sample any group of three points meets our conditions. In the seconds sample only 2 groups of three points meet our conditions: {-3, -2, -1} and {-2, -1, 0}. In the third sample only one group does: {1, 10, 20}. The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. The Little Girl loves problems on games very much. Here's one of them. Two players have got a string s, consisting of lowercase English letters. They play a game that is described by the following rules: * The players move in turns; In one move the player can remove an arbitrary letter from string s. * If the player before his turn can reorder the letters in string s so as to get a palindrome, this player wins. A palindrome is a string that reads the same both ways (from left to right, and vice versa). For example, string "abba" is a palindrome and string "abc" isn't. Determine which player will win, provided that both sides play optimally well — the one who moves first or the one who moves second. Input The input contains a single line, containing string s (1 ≤ \|s\| ≤ 103). String s consists of lowercase English letters. Output In a single line print word "First" if the first player wins (provided that both players play optimally well). Otherwise, print word "Second". Print the words without the quotes. Examples Input aba Output First Input abca Output 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. Fox Ciel has some flowers: r red flowers, g green flowers and b blue flowers. She wants to use these flowers to make several bouquets. There are 4 types of bouquets: * To make a "red bouquet", it needs 3 red flowers. * To make a "green bouquet", it needs 3 green flowers. * To make a "blue bouquet", it needs 3 blue flowers. * To make a "mixing bouquet", it needs 1 red, 1 green and 1 blue flower. Help Fox Ciel to find the maximal number of bouquets she can make. Input The first line contains three integers r, g and b (0 ≤ r, g, b ≤ 109) — the number of red, green and blue flowers. Output Print the maximal number of bouquets Fox Ciel can make. Examples Input 3 6 9 Output 6 Input 4 4 4 Output 4 Input 0 0 0 Output 0 Note In test case 1, we can make 1 red bouquet, 2 green bouquets and 3 blue bouquets. In test case 2, we can make 1 red, 1 green, 1 blue and 1 mixing bouquet. The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Little Petya is learning to play chess. He has already learned how to move a king, a rook and a bishop. Let us remind you the rules of moving chess pieces. A chessboard is 64 square fields organized into an 8 × 8 table. A field is represented by a pair of integers (r, c) — the number of the row and the number of the column (in a classical game the columns are traditionally indexed by letters). Each chess piece takes up exactly one field. To make a move is to move a chess piece, the pieces move by the following rules: * A rook moves any number of fields horizontally or vertically. * A bishop moves any number of fields diagonally. * A king moves one field in any direction — horizontally, vertically or diagonally. <image> The pieces move like that Petya is thinking about the following problem: what minimum number of moves is needed for each of these pieces to move from field (r1, c1) to field (r2, c2)? At that, we assume that there are no more pieces besides this one on the board. Help him solve this problem. Input The input contains four integers r1, c1, r2, c2 (1 ≤ r1, c1, r2, c2 ≤ 8) — the coordinates of the starting and the final field. The starting field doesn't coincide with the final one. You can assume that the chessboard rows are numbered from top to bottom 1 through 8, and the columns are numbered from left to right 1 through 8. Output Print three space-separated integers: the minimum number of moves the rook, the bishop and the king (in this order) is needed to move from field (r1, c1) to field (r2, c2). If a piece cannot make such a move, print a 0 instead of the corresponding number. Examples Input 4 3 1 6 Output 2 1 3 Input 5 5 5 6 Output 1 0 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. This problem consists of three subproblems: for solving subproblem F1 you will receive 8 points, for solving subproblem F2 you will receive 15 points, and for solving subproblem F3 you will receive 10 points. Manao has developed a model to predict the stock price of a company over the next n days and wants to design a profit-maximizing trading algorithm to make use of these predictions. Unfortunately, Manao's trading account has the following restrictions: * It only allows owning either zero or one shares of stock at a time; * It only allows buying or selling a share of this stock once per day; * It allows a maximum of k buy orders over the next n days; For the purposes of this problem, we define a trade to a be the act of buying one share of stock on day i, then holding the stock until some day j > i at which point the share is sold. To restate the above constraints, Manao is permitted to make at most k non-overlapping trades during the course of an n-day trading period for which Manao's model has predictions about the stock price. Even though these restrictions limit the amount of profit Manao can make compared to what would be achievable with an unlimited number of trades or the ability to hold more than one share at a time, Manao still has the potential to make a lot of money because Manao's model perfectly predicts the daily price of the stock. For example, using this model, Manao could wait until the price is low, then buy one share and hold until the price reaches a high value, then sell for a profit, and repeat this process up to k times until n days have passed. Nevertheless, Manao is not satisfied by having a merely good trading algorithm, and wants to develop an optimal strategy for trading subject to these constraints. Help Manao achieve this goal by writing a program that will determine when to buy and sell stock to achieve the greatest possible profit during the n-day trading period subject to the above constraints. Input The first line contains two integers n and k, separated by a single space, with <image>. The i-th of the following n lines contains a single integer pi (0 ≤ pi ≤ 1012), where pi represents the price at which someone can either buy or sell one share of stock on day i. The problem consists of three subproblems. The subproblems have different constraints on the input. You will get some score for the correct submission of the subproblem. The description of the subproblems follows. * In subproblem F1 (8 points), n will be between 1 and 3000, inclusive. * In subproblem F2 (15 points), n will be between 1 and 100000, inclusive. * In subproblem F3 (10 points), n will be between 1 and 4000000, inclusive. Output For this problem, the program will only report the amount of the optimal profit, rather than a list of trades that can achieve this profit. Therefore, the program should print one line containing a single integer, the maximum profit Manao can achieve over the next n days with the constraints of starting with no shares on the first day of trading, always owning either zero or one shares of stock, and buying at most k shares over the course of the n-day trading period. Examples Input 10 2 2 7 3 9 8 7 9 7 1 9 Output 15 Input 10 5 2 7 3 9 8 7 9 7 1 9 Output 21 Note In the first example, the best trade overall is to buy at a price of 1 on day 9 and sell at a price of 9 on day 10 and the second best trade overall is to buy at a price of 2 on day 1 and sell at a price of 9 on day 4. Since these two trades do not overlap, both can be made and the profit is the sum of the profits of the two trades. Thus the trade strategy looks like this: 2 \| 7 \| 3 \| 9 \| 8 \| 7 \| 9 \| 7 \| 1 \| 9 buy \| \| \| sell \| \| \| \| \| buy \| sell The total profit is then (9 - 2) + (9 - 1) = 15. In the second example, even though Manao is allowed up to 5 trades there are only 4 profitable trades available. Making a fifth trade would cost Manao money so he only makes the following 4: 2 \| 7 \| 3 \| 9 \| 8 \| 7 \| 9 \| 7 \| 1 \| 9 buy \| sell \| buy \| sell \| \| buy \| sell \| \| buy \| sell The total profit is then (7 - 2) + (9 - 3) + (9 - 7) + (9 - 1) = 21. The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Valera loves his garden, where n fruit trees grow. This year he will enjoy a great harvest! On the i-th tree bi fruit grow, they will ripen on a day number ai. Unfortunately, the fruit on the tree get withered, so they can only be collected on day ai and day ai + 1 (all fruits that are not collected in these two days, become unfit to eat). Valera is not very fast, but there are some positive points. Valera is ready to work every day. In one day, Valera can collect no more than v fruits. The fruits may be either from the same tree, or from different ones. What is the maximum amount of fruit Valera can collect for all time, if he operates optimally well? Input The first line contains two space-separated integers n and v (1 ≤ n, v ≤ 3000) — the number of fruit trees in the garden and the number of fruits that Valera can collect in a day. Next n lines contain the description of trees in the garden. The i-th line contains two space-separated integers ai and bi (1 ≤ ai, bi ≤ 3000) — the day the fruits ripen on the i-th tree and the number of fruits on the i-th tree. Output Print a single integer — the maximum number of fruit that Valera can collect. Examples Input 2 3 1 5 2 3 Output 8 Input 5 10 3 20 2 20 1 20 4 20 5 20 Output 60 Note In the first sample, in order to obtain the optimal answer, you should act as follows. * On the first day collect 3 fruits from the 1-st tree. * On the second day collect 1 fruit from the 2-nd tree and 2 fruits from the 1-st tree. * On the third day collect the remaining fruits from the 2-nd tree. In the second sample, you can only collect 60 fruits, the remaining fruit will simply wither. 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. Alexandra has a paper strip with n numbers on it. Let's call them ai from left to right. Now Alexandra wants to split it into some pieces (possibly 1). For each piece of strip, it must satisfy: * Each piece should contain at least l numbers. * The difference between the maximal and the minimal number on the piece should be at most s. Please help Alexandra to find the minimal number of pieces meeting the condition above. Input The first line contains three space-separated integers n, s, l (1 ≤ n ≤ 105, 0 ≤ s ≤ 109, 1 ≤ l ≤ 105). The second line contains n integers ai separated by spaces ( - 109 ≤ ai ≤ 109). Output Output the minimal number of strip pieces. If there are no ways to split the strip, output -1. Examples Input 7 2 2 1 3 1 2 4 1 2 Output 3 Input 7 2 2 1 100 1 100 1 100 1 Output -1 Note For the first sample, we can split the strip into 3 pieces: [1, 3, 1], [2, 4], [1, 2]. For the second sample, we can't let 1 and 100 be on the same piece, so no solution exists. 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. Fox Ciel starts to learn programming. The first task is drawing a fox! However, that turns out to be too hard for a beginner, so she decides to draw a snake instead. A snake is a pattern on a n by m table. Denote c-th cell of r-th row as (r, c). The tail of the snake is located at (1, 1), then it's body extends to (1, m), then goes down 2 rows to (3, m), then goes left to (3, 1) and so on. Your task is to draw this snake for Fox Ciel: the empty cells should be represented as dot characters ('.') and the snake cells should be filled with number signs ('#'). Consider sample tests in order to understand the snake pattern. Input The only line contains two integers: n and m (3 ≤ n, m ≤ 50). n is an odd number. Output Output n lines. Each line should contain a string consisting of m characters. Do not output spaces. Examples Input 3 3 Output ### ..# ### Input 3 4 Output #### ...# #### Input 5 3 Output ### ..# ### #.. ### Input 9 9 Output ######### ........# ######### #........ ######### ........# ######### #........ ######### 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. Once again Tavas started eating coffee mix without water! Keione told him that it smells awful, but he didn't stop doing that. That's why Keione told his smart friend, SaDDas to punish him! SaDDas took Tavas' headphones and told him: "If you solve the following problem, I'll return it to you." <image> The problem is: You are given a lucky number n. Lucky numbers are the positive integers whose decimal representations contain only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not. If we sort all lucky numbers in increasing order, what's the 1-based index of n? Tavas is not as smart as SaDDas, so he asked you to do him a favor and solve this problem so he can have his headphones back. Input The first and only line of input contains a lucky number n (1 ≤ n ≤ 109). Output Print the index of n among all lucky numbers. Examples Input 4 Output 1 Input 7 Output 2 Input 77 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. Volodya and Vlad play the following game. There are k pies at the cells of n × m board. Each turn Volodya moves one pie to the neighbouring (by side) cell. If the pie lies at the border of the board then Volodya can move it outside the board, get the pie and win. After Volodya's move, Vlad bans some edge at the border of the board of length 1 (between two knots of the board) so that Volodya is not able to move the pie outside the board through this edge anymore. The question is: will Volodya win this game? We suppose both players follow the optimal strategy. <image> Input First line contains 3 integers, separated by space: 1 ≤ n, m ≤ 100 — dimensions of the board and 0 ≤ k ≤ 100 — the number of pies. Each of the next k lines contains 2 integers, separated by space: 1 ≤ x ≤ n, 1 ≤ y ≤ m — coordinates of the corresponding pie. There could be more than one pie at a cell. Output Output only one word: "YES" — if Volodya wins, "NO" — otherwise. Examples Input 2 2 1 1 2 Output YES Input 3 4 0 Output NO Input 100 50 2 50 25 50 25 Output NO The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Saitama accidentally destroyed a hotel again. To repay the hotel company, Genos has volunteered to operate an elevator in one of its other hotels. The elevator is special — it starts on the top floor, can only move down, and has infinite capacity. Floors are numbered from 0 to s and elevator initially starts on floor s at time 0. The elevator takes exactly 1 second to move down exactly 1 floor and negligible time to pick up passengers. Genos is given a list detailing when and on which floor passengers arrive. Please determine how long in seconds it will take Genos to bring all passengers to floor 0. Input The first line of input contains two integers n and s (1 ≤ n ≤ 100, 1 ≤ s ≤ 1000) — the number of passengers and the number of the top floor respectively. The next n lines each contain two space-separated integers fi and ti (1 ≤ fi ≤ s, 1 ≤ ti ≤ 1000) — the floor and the time of arrival in seconds for the passenger number i. Output Print a single integer — the minimum amount of time in seconds needed to bring all the passengers to floor 0. Examples Input 3 7 2 1 3 8 5 2 Output 11 Input 5 10 2 77 3 33 8 21 9 12 10 64 Output 79 Note In the first sample, it takes at least 11 seconds to bring all passengers to floor 0. Here is how this could be done: 1. Move to floor 5: takes 2 seconds. 2. Pick up passenger 3. 3. Move to floor 3: takes 2 seconds. 4. Wait for passenger 2 to arrive: takes 4 seconds. 5. Pick up passenger 2. 6. Go to floor 2: takes 1 second. 7. Pick up passenger 1. 8. Go to floor 0: takes 2 seconds. This gives a total of 2 + 2 + 4 + 1 + 2 = 11 seconds. 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. Treeland is a country in which there are n towns connected by n - 1 two-way road such that it's possible to get from any town to any other town. In Treeland there are 2k universities which are located in different towns. Recently, the president signed the decree to connect universities by high-speed network.The Ministry of Education understood the decree in its own way and decided that it was enough to connect each university with another one by using a cable. Formally, the decree will be done! To have the maximum sum in the budget, the Ministry decided to divide universities into pairs so that the total length of the required cable will be maximum. In other words, the total distance between universities in k pairs should be as large as possible. Help the Ministry to find the maximum total distance. Of course, each university should be present in only one pair. Consider that all roads have the same length which is equal to 1. Input The first line of the input contains two integers n and k (2 ≤ n ≤ 200 000, 1 ≤ k ≤ n / 2) — the number of towns in Treeland and the number of university pairs. Consider that towns are numbered from 1 to n. The second line contains 2k distinct integers u1, u2, ..., u2k (1 ≤ ui ≤ n) — indices of towns in which universities are located. The next n - 1 line contains the description of roads. Each line contains the pair of integers xj and yj (1 ≤ xj, yj ≤ n), which means that the j-th road connects towns xj and yj. All of them are two-way roads. You can move from any town to any other using only these roads. Output Print the maximum possible sum of distances in the division of universities into k pairs. Examples Input 7 2 1 5 6 2 1 3 3 2 4 5 3 7 4 3 4 6 Output 6 Input 9 3 3 2 1 6 5 9 8 9 3 2 2 7 3 4 7 6 4 5 2 1 2 8 Output 9 Note The figure below shows one of possible division into pairs in the first test. If you connect universities number 1 and 6 (marked in red) and universities number 2 and 5 (marked in blue) by using the cable, the total distance will equal 6 which will be the maximum sum in this example. <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. Vova plays a computer game known as Mages and Monsters. Vova's character is a mage. Though as he has just started, his character knows no spells. Vova's character can learn new spells during the game. Every spell is characterized by two values xi and yi — damage per second and mana cost per second, respectively. Vova doesn't have to use a spell for an integer amount of seconds. More formally, if he uses a spell with damage x and mana cost y for z seconds, then he will deal x·z damage and spend y·z mana (no rounding). If there is no mana left (mana amount is set in the start of the game and it remains the same at the beginning of every fight), then character won't be able to use any spells. It is prohibited to use multiple spells simultaneously. Also Vova can fight monsters. Every monster is characterized by two values tj and hj — monster kills Vova's character in tj seconds and has hj health points. Mana refills after every fight (or Vova's character revives with full mana reserve), so previous fights have no influence on further ones. Vova's character kills a monster, if he deals hj damage to it in no more than tj seconds using his spells (it is allowed to use more than one spell in a fight) and spending no more mana than he had at the beginning of the fight. If monster's health becomes zero exactly in tj seconds (it means that the monster and Vova's character kill each other at the same time), then Vova wins the fight. You have to write a program which can answer two types of queries: * 1 x y — Vova's character learns new spell which deals x damage per second and costs y mana per second. * 2 t h — Vova fights the monster which kills his character in t seconds and has h health points. Note that queries are given in a different form. Also remember that Vova's character knows no spells at the beginning of the game. For every query of second type you have to determine if Vova is able to win the fight with corresponding monster. Input The first line contains two integer numbers q and m (2 ≤ q ≤ 105, 1 ≤ m ≤ 1012) — the number of queries and the amount of mana at the beginning of every fight. i-th of each next q lines contains three numbers ki, ai and bi (1 ≤ ki ≤ 2, 1 ≤ ai, bi ≤ 106). Using them you can restore queries this way: let j be the index of the last query of second type with positive answer (j = 0 if there were none of these). * If ki = 1, then character learns spell with x = (ai + j) mod 106 + 1, y = (bi + j) mod 106 + 1. * If ki = 2, then you have to determine if Vova is able to win the fight against monster with t = (ai + j) mod 106 + 1, h = (bi + j) mod 106 + 1. Output For every query of second type print YES if Vova is able to win the fight with corresponding monster and NO otherwise. Example Input 3 100 1 4 9 2 19 49 2 19 49 Output YES NO Note In first example Vova's character at first learns the spell with 5 damage and 10 mana cost per second. Next query is a fight with monster which can kill character in 20 seconds and has 50 health points. Vova kills it in 10 seconds (spending 100 mana). Next monster has 52 health, so Vova can't deal that much damage with only 100 mana. 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 got tired of playing the tag game by the usual rules so she offered Bob a little modification to it. Now the game should be played on an undirected rooted tree of n vertices. Vertex 1 is the root of the tree. Alice starts at vertex 1 and Bob starts at vertex x (x ≠ 1). The moves are made in turns, Bob goes first. In one move one can either stay at the current vertex or travel to the neighbouring one. The game ends when Alice goes to the same vertex where Bob is standing. Alice wants to minimize the total number of moves and Bob wants to maximize it. You should write a program which will determine how many moves will the game last. Input The first line contains two integer numbers n and x (2 ≤ n ≤ 2·105, 2 ≤ x ≤ n). Each of the next n - 1 lines contains two integer numbers a and b (1 ≤ a, b ≤ n) — edges of the tree. It is guaranteed that the edges form a valid tree. Output Print the total number of moves Alice and Bob will make. Examples Input 4 3 1 2 2 3 2 4 Output 4 Input 5 2 1 2 2 3 3 4 2 5 Output 6 Note In the first example the tree looks like this: <image> The red vertex is Alice's starting position, the blue one is Bob's. Bob will make the game run the longest by standing at the vertex 3 during all the game. So here are the moves: B: stay at vertex 3 A: go to vertex 2 B: stay at vertex 3 A: go to vertex 3 In the second example the tree looks like this: <image> The moves in the optimal strategy are: B: go to vertex 3 A: go to vertex 2 B: go to vertex 4 A: go to vertex 3 B: stay at vertex 4 A: go 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. Daenerys Targaryen has an army consisting of k groups of soldiers, the i-th group contains ai soldiers. She wants to bring her army to the other side of the sea to get the Iron Throne. She has recently bought an airplane to carry her army through the sea. The airplane has n rows, each of them has 8 seats. We call two seats neighbor, if they are in the same row and in seats {1, 2}, {3, 4}, {4, 5}, {5, 6} or {7, 8}. <image> A row in the airplane Daenerys Targaryen wants to place her army in the plane so that there are no two soldiers from different groups sitting on neighboring seats. Your task is to determine if there is a possible arranging of her army in the airplane such that the condition above is satisfied. Input The first line contains two integers n and k (1 ≤ n ≤ 10000, 1 ≤ k ≤ 100) — the number of rows and the number of groups of soldiers, respectively. The second line contains k integers a1, a2, a3, ..., ak (1 ≤ ai ≤ 10000), where ai denotes the number of soldiers in the i-th group. It is guaranteed that a1 + a2 + ... + ak ≤ 8·n. Output If we can place the soldiers in the airplane print "YES" (without quotes). Otherwise print "NO" (without quotes). You can choose the case (lower or upper) for each letter arbitrary. Examples Input 2 2 5 8 Output YES Input 1 2 7 1 Output NO Input 1 2 4 4 Output YES Input 1 4 2 2 1 2 Output YES Note In the first sample, Daenerys can place the soldiers like in the figure below: <image> In the second sample, there is no way to place the soldiers in the plane since the second group soldier will always have a seat neighboring to someone from the first group. In the third example Daenerys can place the first group on seats (1, 2, 7, 8), and the second group an all the remaining seats. In the fourth example she can place the first two groups on seats (1, 2) and (7, 8), the third group on seats (3), and the fourth group on seats (5, 6). The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. A new set of desks just arrived, and it's about time! Things were getting quite cramped in the office. You've been put in charge of creating a new seating chart for the engineers. The desks are numbered, and you sent out a survey to the engineering team asking each engineer the number of the desk they currently sit at, and the number of the desk they would like to sit at (which may be the same as their current desk). Each engineer must either remain where they sit, or move to the desired seat they indicated in the survey. No two engineers currently sit at the same desk, nor may any two engineers sit at the same desk in the new seating arrangement. How many seating arrangements can you create that meet the specified requirements? The answer may be very large, so compute it modulo 1000000007 = 109 + 7. Input Input will begin with a line containing N (1 ≤ N ≤ 100000), the number of engineers. N lines follow, each containing exactly two integers. The i-th line contains the number of the current desk of the i-th engineer and the number of the desk the i-th engineer wants to move to. Desks are numbered from 1 to 2·N. It is guaranteed that no two engineers sit at the same desk. Output Print the number of possible assignments, modulo 1000000007 = 109 + 7. Examples Input 4 1 5 5 2 3 7 7 3 Output 6 Input 5 1 10 2 10 3 10 4 10 5 5 Output 5 Note These are the possible assignments for the first example: * 1 5 3 7 * 1 2 3 7 * 5 2 3 7 * 1 5 7 3 * 1 2 7 3 * 5 2 7 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. A ski base is planned to be built in Walrusland. Recently, however, the project is still in the constructing phase. A large land lot was chosen for the construction. It contains n ski junctions, numbered from 1 to n. Initially the junctions aren't connected in any way. In the constructing process m bidirectional ski roads will be built. The roads are built one after another: first the road number 1 will be built, then the road number 2, and so on. The i-th road connects the junctions with numbers ai and bi. Track is the route with the following properties: * The route is closed, that is, it begins and ends in one and the same junction. * The route contains at least one road. * The route doesn't go on one road more than once, however it can visit any junction any number of times. Let's consider the ski base as a non-empty set of roads that can be divided into one or more tracks so that exactly one track went along each road of the chosen set. Besides, each track can consist only of roads from the chosen set. Ski base doesn't have to be connected. Two ski bases are considered different if they consist of different road sets. After building each new road the Walrusland government wants to know the number of variants of choosing a ski base based on some subset of the already built roads. The government asks you to help them solve the given problem. Input The first line contains two integers n and m (2 ≤ n ≤ 105, 1 ≤ m ≤ 105). They represent the number of junctions and the number of roads correspondingly. Then on m lines follows the description of the roads in the order in which they were built. Each road is described by a pair of integers ai and bi (1 ≤ ai, bi ≤ n, ai ≠ bi) — the numbers of the connected junctions. There could be more than one road between a pair of junctions. Output Print m lines: the i-th line should represent the number of ways to build a ski base after the end of construction of the road number i. The numbers should be printed modulo 1000000009 (109 + 9). Examples Input 3 4 1 3 2 3 1 2 1 2 Output 0 0 1 3 Note Let us have 3 junctions and 4 roads between the junctions have already been built (as after building all the roads in the sample): 1 and 3, 2 and 3, 2 roads between junctions 1 and 2. The land lot for the construction will look like this: <image> The land lot for the construction will look in the following way: <image> We can choose a subset of roads in three ways: <image> In the first and the second ways you can choose one path, for example, 1 - 2 - 3 - 1. In the first case you can choose one path 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. Vivek was roaming around in the electronics shop, where he saw a box called as BlackBox. He was intrigued by its function, so he bought it. It's functionality states that for given integer input N ≤ 1000 - it outputs the sum of all the digits in factorial of N (N!). Now Vivek wants to extend its functionality for large numbers. So, he wants you to write a program that can check the correctness of the BlackBox . INPUT : The first line of the input contains a single integer T ( the number of test cases ). Next T lines of input contains an integer N . OUTPUT : For each test case, print the sum of all digits in the factorial of the corresponding input integer. CONSTRAINTS : 1 ≤ T ≤ 10^3 0 ≤ N ≤ 1000 SAMPLE INPUT 5 1 2 3 4 5 SAMPLE OUTPUT 1 2 6 6 3 Explanation for test 1, N=1 , factorial of N = 1 , sum of digits = 1. for test 2, N=2 , factorial of N = 2 , sum of digits = 2. for test 3, N=3 , factorial of N = 6 , sum of digits = 6. for test 4, N=4 , factorial of N = 24 , sum of digits = 6. for test 5, N=5 , factorial of N = 120 , sum of digits = 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. Foo was not amongst the most brilliant students of his class. So, he has some pending exams to clear. As the exams are approaching, this time he vowed to pass in all of them. This will only happen if he is not under stress. Foo's stress can be calculated using a simple function called Foo_function which depends upon the time for which Foo studies continuously . Foo_funtion is defined as follows: F(t)=A(t^3)+B(t^2)+C*(t)+D, F(t) ≤ 10^18 where A,B,C,D belong to the set of prime numbers. t is the time in minutes for which foo studies continuously. As foo is not very good at solving cubic equations, he seeks your help to find out the maximum number of minutes for which he can study continuously without taking stress. Help him find t such that F(t+1) > K, and F(t) ≤ K, where K is the maximum stress Foo can bear. Input: The first line of the input contains a single integer T denoting the number of test cases. each test case consists of a single line containing 5 space seperated positive numbers a, b, c, d, K. Output: for each test case, output a single integer t denoting the maximum time for which foo can study continuously without taking stress. Constraints: 1 ≤ T ≤ 10^4 A, B, C, D belong to a set of prime numbers such that F(t) would never exceed 10^18 t ≥ 0 1 ≤ K ≤ 10^18 SAMPLE INPUT 2 2 2 2 2 10 2 3 5 7 1000 SAMPLE OUTPUT 1 7 Explanation In the 1st test case for t = 2 foo will be under stress because F(2)=30 > K, therefore he can study for a maximum time of 1 minute without having stress. In the 2nd test case for t = 8 foo will be under stess because F(8)=1263 > K, therefore he can study for a maximum time of 7 minutes continuously without having stress. 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. Milly and Pranjul are playing a game in which Pranjul will give an index of a chocolate. Then, Milly has to tell him the box number in which that chocolate is in. There are N such boxes and Ci chocolates are there in i^th the box. Description of index is given below : Suppose there are A1, A2 … AN chocolates in 1^st, 2^nd… N^th boxes respectively. So, indexing of chocolates in 1^st box will be from 1 to A1, similarly in 2^nd box indexing will be A1 + 1 to A2 … and indexing in N^th box will be from AN-1 + 1 to AN. Milly is blind folded so she can’t see the boxes. You are required to help her. Input First line will contain N (No. of boxes). Next line will contain N space separated integers denoting Ci, the number of chocolates in i^th box. Next line will contain Q (No. of times Pranjul will ask her). Then each next Q lines will contain the asked index I. Output For every query, print in a new line : the box number in which that index of chocolate is in. Constraints 1 ≤ N, Q ≤ 10^5 1 ≤ Ci ≤ 10 1 ≤ ∑ Ci ≤ 10^6 1 ≤ I ≤ ∑ Ci SAMPLE INPUT 2 2 3 2 2 4 SAMPLE OUTPUT 1 2 Explanation First Box will have the indexes : 1, 2 Second Box will have the indexes : 3, 4, 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. Rahul has set upon the quest for a new logo of his company. He has created the following continuous logo: /\ / \ / /\ \ / / \ \ / / /\ \ \ \ \ \/ / / \ \ / / \ \/ / \ / \/ However, his sister, Rashi, likes the following discontinuous design more /\ / \ / /\ \ / / \ \ \ \ / / \ \/ / \ / \/ The size of a logo is the longest continuous streak of same characters on an arm. So, size of 1st logo is 5 while that of 2nd one is 4. We know that every '/' or '\' character requires exactly 1 unit of paint. Now, Rahul has X units of paint and would like to draw each of the two favorite logos of himself and his sister, Rashi. So, as to consume it optimally, he wants to know the maximal possible sizes of the two logos that can be drawn such that the difference in sizes of both logos is atmost 1. Note that it is necessary to be able to draw both the logos. In case, the paint is not enough, output 0 0 instead. Input Format: The first line of input file contains T, the number of test cases to follow. Each test case contains exactly 1 line containing X, the amount of paint Rahul has. Output Format: Print two space-separated integers, which denote sizes of Rahul's favourite logo and Rashi's favorite logo, respectively. Constraints: 1 ≤ T ≤ 10^5 1 ≤ N ≤ 10^15 Sample Explanation: Case #1: We have only 10 units of paint which is not enough to draw both logos. Case #2: We have 20 units of paint and following logos can, hence, be drawn. /\ \/ /\ / \ / \/ This requires exactly 12 units, and we cannot do better SAMPLE INPUT 3 10 20 30 SAMPLE OUTPUT 0 0 1 2 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. You are given an array a_0, a_1, ..., a_{N-1} of length N. Process Q queries of the following types. * `0 l r b c`: For each i = l, l+1, \dots, {r - 1}, set a_i \gets b \times a_i + c. * `1 l r`: Print \sum_{i = l}^{r - 1} a_i \bmod 998244353. Constraints * 1 \leq N, Q \leq 500000 * 0 \leq a_i, c < 998244353 * 1 \leq b < 998244353 * 0 \leq l < r \leq N * All values in Input are integer. Input Input is given from Standard Input in the following format: N Q a_0 a_1 ... a_{N - 1} \textrm{Query}_0 \textrm{Query}_1 : \textrm{Query}_{Q - 1} Output For each query of the latter type, print the answer. Example Input 5 7 1 2 3 4 5 1 0 5 0 2 4 100 101 1 0 3 0 1 3 102 103 1 2 5 0 2 5 104 105 1 0 5 Output 15 404 41511 4317767 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 S sheep and W wolves. If the number of wolves is greater than or equal to that of sheep, the wolves will attack the sheep. If the wolves will attack the sheep, print `unsafe`; otherwise, print `safe`. Constraints * 1 \leq S \leq 100 * 1 \leq W \leq 100 Input Input is given from Standard Input in the following format: S W Output If the wolves will attack the sheep, print `unsafe`; otherwise, print `safe`. Examples Input 4 5 Output unsafe Input 100 2 Output safe Input 10 10 Output unsafe 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 a sequence of N integers: x=(x_0,x_1,\cdots,x_{N-1}). Initially, x_i=0 for each i (0 \leq i \leq N-1). Snuke will perform the following operation exactly M times: * Choose two distinct indices i, j (0 \leq i,j \leq N-1,\ i \neq j). Then, replace x_i with x_i+2 and x_j with x_j+1. Find the number of different sequences that can result after M operations. Since it can be enormous, compute the count modulo 998244353. Constraints * 2 \leq N \leq 10^6 * 1 \leq M \leq 5 \times 10^5 * All values in input are integers. Input Input is given from Standard Input in the following format: N M Output Print the number of different sequences that can result after M operations, modulo 998244353. Examples Input 2 2 Output 3 Input 3 2 Output 19 Input 10 10 Output 211428932 Input 100000 50000 Output 3463133 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 planned a trip using trains and buses. The train fare will be A yen (the currency of Japan) if you buy ordinary tickets along the way, and B yen if you buy an unlimited ticket. Similarly, the bus fare will be C yen if you buy ordinary tickets along the way, and D yen if you buy an unlimited ticket. Find the minimum total fare when the optimal choices are made for trains and buses. Constraints * 1 \leq A \leq 1 000 * 1 \leq B \leq 1 000 * 1 \leq C \leq 1 000 * 1 \leq D \leq 1 000 * All input values are integers. Input Input is given from Standard Input in the following format: A B C D Output Print the minimum total fare. Examples Input 600 300 220 420 Output 520 Input 555 555 400 200 Output 755 Input 549 817 715 603 Output 1152 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. Square1001 has seen an electric bulletin board displaying the integer 1. He can perform the following operations A and B to change this value: * Operation A: The displayed value is doubled. * Operation B: The displayed value increases by K. Square1001 needs to perform these operations N times in total. Find the minimum possible value displayed in the board after N operations. Constraints * 1 \leq N, K \leq 10 * All input values are integers. Input Input is given from Standard Input in the following format: N K Output Print the minimum possible value displayed in the board after N operations. Examples Input 4 3 Output 10 Input 10 10 Output 76 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 and C. Determine whether C is not less than A and not greater than B. Constraints * -100≤A,B,C≤100 * A, B and C are all integers. Input Input is given from Standard Input in the following format: A B C Output If the condition is satisfied, print `Yes`; otherwise, print `No`. Examples Input 1 3 2 Output Yes Input 6 5 4 Output No Input 2 2 2 Output Yes The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Snuke received a triangle as a birthday present. The coordinates of the three vertices were (x_1, y_1), (x_2, y_2), and (x_3, y_3). He wants to draw two circles with the same radius inside the triangle such that the two circles do not overlap (but they may touch). Compute the maximum possible radius of the circles. Constraints * 0 ≤ x_i, y_i ≤ 1000 * The coordinates are integers. * The three points are not on the same line. Input The input is given from Standard Input in the following format: x_1 y_1 x_2 y_2 x_3 y_3 Output Print the maximum possible radius of the circles. The absolute error or the relative error must be at most 10^{-9}. Examples Input 0 0 1 1 2 0 Output 0.292893218813 Input 3 1 1 5 4 9 Output 0.889055514217 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 a large square grid with H rows and W columns. Iroha is now standing in the top-left cell. She will repeat going right or down to the adjacent cell, until she reaches the bottom-right cell. However, she cannot enter the cells in the intersection of the bottom A rows and the leftmost B columns. (That is, there are A×B forbidden cells.) There is no restriction on entering the other cells. Find the number of ways she can travel to the bottom-right cell. Since this number can be extremely large, print the number modulo 10^9+7. Constraints * 1 ≦ H, W ≦ 100,000 * 1 ≦ A < H * 1 ≦ B < W Input The input is given from Standard Input in the following format: H W A B Output Print the number of ways she can travel to the bottom-right cell, modulo 10^9+7. Examples Input 2 3 1 1 Output 2 Input 10 7 3 4 Output 3570 Input 100000 100000 99999 99999 Output 1 Input 100000 100000 44444 55555 Output 738162020 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. Do the following for a four-digit number N consisting of numbers 0-9. 1. Let L be the number obtained as a result of arranging the numerical values of each of the N digits in descending order. 2. Let S be the number obtained as a result of arranging the numerical values of each of the N digits in ascending order. 3. Let the difference L-S be the new N (end of one operation) 4. Repeat from 1. for the new N At this time, it is known that any four-digit number will eventually become 6174, unless all digits are the same number (0000, 1111, etc.). For example, when N = 2012 First time (N = 2012): L = 2210, S = 0122, L-S = 2088 Second time (N = 2088): L = 8820, S = 0288, L-S = 8532 Third time (N = 8532): L = 8532, S = 2358, L-S = 6174 And reach 6174 in 3 operations. Write a program that calculates how many operations will reach 6174 given a four-digit number consisting of the numbers 0-9. input The input consists of multiple datasets. The end of the input is indicated by 0000 on one line. Each dataset is given in the following format: N The dataset is one line and N (1 ≤ N ≤ 9999) indicates a four-digit number. If N <1000, the upper digit is padded with zeros. The number of datasets does not exceed 10000. output The number of operations to reach 6174 for each data set is output on one line. However, if a number with all the same digits is given as input, NA is output. Example Input 6174 2012 3333 0000 Output 0 3 NA The input will be give Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Brave Ponta and his best friend, Brave Gonta, have come to Luida's bar in search of friends to embark on an epic adventure. There are many warriors, monks and wizards in the tavern who are itching to go on an adventure. Gonta, who is kind-hearted, cared for Ponta and said, "You can choose your friends first." On the other hand, don't worry about Ponta and Gonta. "No, you can choose first." We continued to give in to each other, and finally Luida proposed: "Then, I'll divide the n registrants here with this" party division machine "so that the total fighting power of each party is as even as possible." The task given to you is to create a program that is built into the partying machine. This program inputs n integers and outputs the minimum difference between the total value of the integers contained in A and the total value of the integers contained in B when they are divided into two groups A and B. Must be. Thanks to this machine, Ponta and Gonta got along well and went on an epic adventure ... Input Multiple datasets are given as input. Each dataset is given in the following format: n (number of registrants: integer) a1 a2 ... an (combat power of each registrant: blank-separated integer) n is 20 or less, and each registrant's combat power does not exceed 1 million. When n is 0, it is the end of input. Output Print the minimum value on one line for each dataset. Example Input 5 1 2 3 4 5 4 2 3 5 7 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.

Subsets and Splits

No community queries yet

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