"{\"inputs\":\"Can you solve the below in JAVA?\\nMoamen has an array of n distinct integers. He wants to sort that array in non-decreasing order by doing the following operations in order exactly once:\\n\\n  1. Split the array into exactly k non-empty subarrays such that each element belongs to exactly one subarray. \\n  2. Reorder these subarrays arbitrary. \\n  3. Merge the subarrays in their new order. \\n\\n\\n\\nA sequence a is a subarray of a sequence b if a can be obtained from b by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.\\n\\nCan you tell Moamen if there is a way to sort the array in non-decreasing order using the operations written above?\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 10^3) \u2014 the number of test cases. The description of the test cases follows.\\n\\nThe first line of each test case contains two integers n and k (1 \u2264 k \u2264 n \u2264 10^5).\\n\\nThe second line contains n integers a_1, a_2, \u2026, a_n (0 \u2264 |a_i| \u2264 10^9). It is guaranteed that all numbers are distinct.\\n\\nIt is guaranteed that the sum of n over all test cases does not exceed 3\u22c510^5.\\n\\nOutput\\n\\nFor each test case, you should output a single string.\\n\\nIf Moamen can sort the array in non-decreasing order, output \\\"YES\\\" (without quotes). Otherwise, output \\\"NO\\\" (without quotes).\\n\\nYou can print each letter of \\\"YES\\\" and \\\"NO\\\" in any case (upper or lower).\\n\\nExample\\n\\nInput\\n\\n\\n3\\n5 4\\n6 3 4 2 1\\n4 2\\n1 -4 0 -2\\n5 1\\n1 2 3 4 5\\n\\n\\nOutput\\n\\n\\nYes\\nNo\\nYes\\n\\nNote\\n\\nIn the first test case, a = [6, 3, 4, 2, 1], and k = 4, so we can do the operations as follows: \\n\\n  1. Split a into \\\\{ [6], [3, 4], [2], [1] \\\\}. \\n  2. Reorder them: \\\\{ [1], [2], [3,4], [6] \\\\}. \\n  3. Merge them: [1, 2, 3, 4, 6], so now the array is sorted. \\n\\n\\n\\nIn the second test case, there is no way to sort the array by splitting it into only 2 subarrays.\\n\\nAs an example, if we split it into \\\\{ [1, -4], [0, -2] \\\\}, we can reorder them into \\\\{ [1, -4], [0, -2] \\\\} or \\\\{ [0, -2], [1, -4] \\\\}. However, after merging the subarrays, it is impossible to get a sorted array.\",\"targets\":\"import java.util.Arrays;\\nimport java.util.HashMap;\\nimport java.util.Map;\\nimport java.util.Scanner;\\n \\npublic class Main{\\n \\n \\n    public static void main(String[] args) {\\n        Scanner sc = new Scanner(System.in);\\n        int time = sc.nextInt();\\n        for (int j = 0; j < time; j++) {\\n            int a = sc.nextInt();\\n            int b = sc.nextInt();\\n            int[] x = new int[a];\\n            for (int i = 0; i < a; i++) {\\n                x[i] = sc.nextInt();\\n            }\\n            System.out.println(b>=getTime(x)?\\\"Yes\\\":\\\"No\\\");\\n        }\\n    }\\n \\n    public static int getTime(int[] arr){\\n        int len = arr.length;\\n        Map<Integer,Integer> map = new HashMap<>();\\n        int index = 0;\\n        for(int i:arr){\\n            map.put(i,index++);\\n        }\\n        Arrays.sort(arr);\\n        int k=1;\\n        for(int i=0;i<len-1;i++){\\n            if(map.get(arr[i])+1!=map.get(arr[i+1])){\\n                k++;\\n            }\\n        }\\n        return k;\\n    }\\n \\n \\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Monocarp plays a computer game (yet again!). This game has a unique trading mechanics.\\n\\nTo trade with a character, Monocarp has to choose one of the items he possesses and trade it for some item the other character possesses. Each item has an integer price. If Monocarp's chosen item has price x, then he can trade it for any item (exactly one item) with price not greater than x+k.\\n\\nMonocarp initially has n items, the price of the i-th item he has is a_i. The character Monocarp is trading with has m items, the price of the i-th item they have is b_i. Monocarp can trade with this character as many times as he wants (possibly even zero times), each time exchanging one of his items with one of the other character's items according to the aforementioned constraints. Note that if Monocarp gets some item during an exchange, he can trade it for another item (since now the item belongs to him), and vice versa: if Monocarp trades one of his items for another item, he can get his item back by trading something for it.\\n\\nYou have to answer q queries. Each query consists of one integer, which is the value of k, and asks you to calculate the maximum possible total cost of items Monocarp can have after some sequence of trades, assuming that he can trade an item of cost x for an item of cost not greater than x+k during each trade. Note that the queries are independent: the trades do not actually occur, Monocarp only wants to calculate the maximum total cost he can get.\\n\\nInput\\n\\nThe first line contains three integers n, m and q (1 \u2264 n, m, q \u2264 2 \u22c5 10^5).\\n\\nThe second line contains n integers a_1, a_2, ..., a_n (1 \u2264 a_i \u2264 10^9) \u2014 the prices of the items Monocarp has.\\n\\nThe third line contains m integers b_1, b_2, ..., b_m (1 \u2264 b_i \u2264 10^9) \u2014 the prices of the items the other character has.\\n\\nThe fourth line contains q integers, where the i-th integer is the value of k for the i-th query (0 \u2264 k \u2264 10^9).\\n\\nOutput\\n\\nFor each query, print one integer \u2014 the maximum possible total cost of items Monocarp can have after some sequence of trades,...\",\"targets\":\"import sys, itertools, bisect\\ninput = sys.stdin.readline\\nn, m, q = [*map(int, input().split())]\\na = [*map(int, input().split())]\\nb = [*map(int, input().split())]\\nqry = [*map(int, input().split())]\\ns = sorted([(i,1) for i in a]+[(i,0) for i in b], reverse=True)\\nac = [0] + list(itertools.accumulate(i[0] for i in s))\\ng = sorted((s[i][0]-s[i+1][0], i) for i in range(m+n-1))\\nd = [(1, i, i) if s[i][1] else (0, i, i) for i in range(m+n)]\\ntotal = sum(a)\\nr, ans = [], []\\nlastgap = 0\\nfor gap, pos in g:\\n    if lastgap != gap:\\n        r.append(lastgap)\\n        ans.append(str(total))\\n    lastgap = gap\\n    start = d[pos][1]\\n    nextpos = d[pos][2]+1\\n    nextnum = d[nextpos][0]\\n    total += ac[start+d[pos][0]+nextnum] - ac[start+d[pos][0]] - (ac[nextpos+nextnum] - ac[nextpos])\\n    d[start] = d[d[nextpos][2]] = (d[pos][0]+nextnum, start, d[nextpos][2])\\nr.append(lastgap)\\nans.append(str(total))\\nprint('\\\\n'.join(ans[bisect.bisect_right(r, i)-1] for i in qry))\",\"language\":\"python\",\"split\":\"test\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Allen has a LOT of money. He has n dollars in the bank. For security reasons, he wants to withdraw it in cash (we will not disclose the reasons here). The denominations for dollar bills are 1, 5, 10, 20, 100. What is the minimum number of bills Allen could receive after withdrawing his entire balance?\\n\\nInput\\n\\nThe first and only line of input contains a single integer n (1 \u2264 n \u2264 10^9).\\n\\nOutput\\n\\nOutput the minimum number of bills that Allen could receive.\\n\\nExamples\\n\\nInput\\n\\n125\\n\\n\\nOutput\\n\\n3\\n\\n\\nInput\\n\\n43\\n\\n\\nOutput\\n\\n5\\n\\n\\nInput\\n\\n1000000000\\n\\n\\nOutput\\n\\n10000000\\n\\nNote\\n\\nIn the first sample case, Allen can withdraw this with a 100 dollar bill, a 20 dollar bill, and a 5 dollar bill. There is no way for Allen to receive 125 dollars in one or two bills.\\n\\nIn the second sample case, Allen can withdraw two 20 dollar bills and three 1 dollar bills.\\n\\nIn the third sample case, Allen can withdraw 100000000 (ten million!) 100 dollar bills.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint main() {\\n  long long n;\\n  cin >> n;\\n  long c = 0;\\n  while (n > 0) {\\n    if (n >= 100) {\\n      long k = n \\/ 100;\\n      c += k;\\n      n -= (k * 100);\\n    } else if (n >= 20) {\\n      long k = n \\/ 20;\\n      c += k;\\n      n -= (k * 20);\\n    } else if (n >= 10) {\\n      long k = n \\/ 10;\\n      c += k;\\n      n -= (k * 10);\\n    } else if (n >= 5) {\\n      long k = n \\/ 5;\\n      c += k;\\n      n -= (k * 5);\\n    } else if (n >= 1) {\\n      c += n;\\n      break;\\n    }\\n  }\\n  cout << c;\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You are given a string s, consisting of n letters, each letter is either 'a' or 'b'. The letters in the string are numbered from 1 to n.\\n\\ns[l; r] is a continuous substring of letters from index l to r of the string inclusive. \\n\\nA string is called balanced if the number of letters 'a' in it is equal to the number of letters 'b'. For example, strings \\\"baba\\\" and \\\"aabbab\\\" are balanced and strings \\\"aaab\\\" and \\\"b\\\" are not.\\n\\nFind any non-empty balanced substring s[l; r] of string s. Print its l and r (1 \u2264 l \u2264 r \u2264 n). If there is no such substring, then print -1 -1.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 1000) \u2014 the number of testcases.\\n\\nThen the descriptions of t testcases follow.\\n\\nThe first line of the testcase contains a single integer n (1 \u2264 n \u2264 50) \u2014 the length of the string.\\n\\nThe second line of the testcase contains a string s, consisting of n letters, each letter is either 'a' or 'b'.\\n\\nOutput\\n\\nFor each testcase print two integers. If there exists a non-empty balanced substring s[l; r], then print l r (1 \u2264 l \u2264 r \u2264 n). Otherwise, print -1 -1.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n1\\na\\n6\\nabbaba\\n6\\nabbaba\\n9\\nbabbabbaa\\n\\n\\nOutput\\n\\n\\n-1 -1\\n1 6\\n3 6\\n2 5\\n\\nNote\\n\\nIn the first testcase there are no non-empty balanced subtrings.\\n\\nIn the second and third testcases there are multiple balanced substrings, including the entire string \\\"abbaba\\\" and substring \\\"baba\\\".\\nimpor\",\"targets\":\"t java.io.BufferedReader;\\nimport java.io.IOException;\\nimport java.io.InputStreamReader;\\nimport java.util.ArrayList;\\nimport java.util.List;\\nimport java.util.Objects;\\nimport java.util.StringTokenizer;\\n\\nimport static java.lang.Math.log;\\nimport static java.lang.Math.min;\\n\\npublic class Codeforces742 {\\n\\n    \\/\\/------------------------------------------CONSTANTS---------------------------------------------------------------\\n    public static final int MOD = (int) (1e9 + 7);\\n\\n    \\/\\/---------------------------------------------I\\/0------------------------------------------------------------------\\n\\n    static class FastReader {\\n        BufferedReader br;\\n        StringTokenizer st;\\n\\n        public FastReader()\\n        {\\n            br = new BufferedReader(\\n                    new InputStreamReader(System.in));\\n        }\\n\\n        String next()\\n        {\\n            while (st == null || !st.hasMoreElements()) {\\n                try {\\n                    st = new StringTokenizer(br.readLine());\\n                }\\n                catch (IOException e) {\\n                    e.printStackTrace();\\n                }\\n            }\\n            return st.nextToken();\\n        }\\n\\n        int nextInt() { return Integer.parseInt(next()); }\\n\\n        long nextLong() { return Long.parseLong(next()); }\\n\\n        double nextDouble()\\n        {\\n            return Double.parseDouble(next());\\n        }\\n\\n        String nextLine()\\n        {\\n            String str = \\\"\\\";\\n            try {\\n                str = br.readLine();\\n            }\\n            catch (IOException e) {\\n                e.printStackTrace();\\n            }\\n            return str;\\n        }\\n    }\\n\\n    public static void print(String s) {\\n        System.out.println(s);\\n    }\\n\\n    public static void main(String[] args) {\\n        FastReader sc = new FastReader();\\n\\n        int t = 1;\\n        t = sc.nextInt();\\n\\n        for(int i = 0; i<t; i++) {\\n            System.out.println(solve(sc));\\n        }\\n    }\\n\\n   ...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in CPP?\\nFurik loves math lessons very much, so he doesn't attend them, unlike Rubik. But now Furik wants to get a good mark for math. For that Ms. Ivanova, his math teacher, gave him a new task. Furik solved the task immediately. Can you?\\n\\nYou are given a set of digits, your task is to find the maximum integer that you can make from these digits. The made number must be divisible by 2, 3, 5 without a residue. It is permitted to use not all digits from the set, it is forbidden to use leading zeroes.\\n\\nEach digit is allowed to occur in the number the same number of times it occurs in the set.\\n\\nInput\\n\\nA single line contains a single integer n (1 \u2264 n \u2264 100000) \u2014 the number of digits in the set. The second line contains n digits, the digits are separated by a single space. \\n\\nOutput\\n\\nOn a single line print the answer to the problem. If such number does not exist, then you should print -1.\\n\\nExamples\\n\\nInput\\n\\n1\\n0\\n\\n\\nOutput\\n\\n0\\n\\n\\nInput\\n\\n11\\n3 4 5 4 5 3 5 3 4 4 0\\n\\n\\nOutput\\n\\n5554443330\\n\\n\\nInput\\n\\n8\\n3 2 5 1 5 2 2 3\\n\\n\\nOutput\\n\\n-1\\n\\nNote\\n\\nIn the first sample there is only one number you can make \u2014 0. In the second sample the sought number is 5554443330. In the third sample it is impossible to make the required number.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst int MAXN = 1e5 + 5;\\nlong long dp[MAXN];\\nvector<int> arr;\\nint to_del[MAXN];\\nvector<int> print_ans;\\nbool check() {\\n  for (auto i : print_ans)\\n    if (i != 0) return false;\\n  return true;\\n}\\nint main() {\\n  ios_base::sync_with_stdio(false);\\n  cin.tie(NULL);\\n  ;\\n  int n;\\n  cin >> n;\\n  for (int i = 0; i < n; i++) {\\n    int x;\\n    cin >> x;\\n    arr.push_back(x);\\n  }\\n  sort(arr.begin(), arr.end());\\n  reverse(arr.begin(), arr.end());\\n  int zeroes = 0;\\n  int sum = 0;\\n  for (int i = 0; i < n; i++) {\\n    if (arr[i] == 0) zeroes++;\\n    sum += arr[i];\\n  }\\n  if (zeroes == 0) {\\n    cout << -1 << endl;\\n    return 0;\\n  } else {\\n    if (sum % 3 == 0) {\\n      for (int i = 0; i < n; i++) print_ans.push_back(arr[i]);\\n    } else if (sum % 3 == 1) {\\n      bool found = false;\\n      for (int i = n - 1; i >= 0; i--) {\\n        if (arr[i] % 3 == 1) {\\n          to_del[i] = 1;\\n          found = true;\\n          break;\\n        }\\n      }\\n      if (found) {\\n        for (int i = 0; i < n; i++) {\\n          if (to_del[i] == 0) print_ans.push_back(arr[i]);\\n        }\\n      } else {\\n        int find_two = 0;\\n        for (int i = n - 1; i >= 0; i--) {\\n          if (arr[i] % 3 == 2) {\\n            to_del[i] = 1;\\n            find_two++;\\n            if (find_two == 2) break;\\n          }\\n        }\\n        if (find_two == 2) {\\n          for (int i = 0; i < n; i++) {\\n            if (to_del[i] == 0) print_ans.push_back(arr[i]);\\n          }\\n        } else {\\n          cout << -1 << endl;\\n          return 0;\\n        }\\n      }\\n    } else {\\n      bool found = false;\\n      for (int i = n - 1; i >= 0; i--) {\\n        if (arr[i] % 3 == 2) {\\n          to_del[i] = 1;\\n          found = true;\\n          break;\\n        }\\n      }\\n      if (found) {\\n        for (int i = 0; i < n; i++) {\\n          if (to_del[i] == 0) print_ans.push_back(arr[i]);\\n        }\\n      } else {\\n        int find_two = 0;\\n        for (int i = n - 1; i >= 0; i--) {\\n          if (arr[i] % 3 == 1) {\\n            to_del[i] = 1;\\n            find_two++;\\n     ...\",\"language\":\"python\",\"split\":\"train\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Alice and Bob are playing a game on a matrix, consisting of 2 rows and m columns. The cell in the i-th row in the j-th column contains a_{i, j} coins in it.\\n\\nInitially, both Alice and Bob are standing in a cell (1, 1). They are going to perform a sequence of moves to reach a cell (2, m).\\n\\nThe possible moves are: \\n\\n  * Move right \u2014 from some cell (x, y) to (x, y + 1); \\n  * Move down \u2014 from some cell (x, y) to (x + 1, y). \\n\\n\\n\\nFirst, Alice makes all her moves until she reaches (2, m). She collects the coins in all cells she visit (including the starting cell).\\n\\nWhen Alice finishes, Bob starts his journey. He also performs the moves to reach (2, m) and collects the coins in all cells that he visited, but Alice didn't.\\n\\nThe score of the game is the total number of coins Bob collects.\\n\\nAlice wants to minimize the score. Bob wants to maximize the score. What will the score of the game be if both players play optimally?\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 10^4) \u2014 the number of testcases.\\n\\nThen the descriptions of t testcases follow.\\n\\nThe first line of the testcase contains a single integer m (1 \u2264 m \u2264 10^5) \u2014 the number of columns of the matrix.\\n\\nThe i-th of the next 2 lines contain m integers a_{i,1}, a_{i,2}, ..., a_{i,m} (1 \u2264 a_{i,j} \u2264 10^4) \u2014 the number of coins in the cell in the i-th row in the j-th column of the matrix.\\n\\nThe sum of m over all testcases doesn't exceed 10^5.\\n\\nOutput\\n\\nFor each testcase print a single integer \u2014 the score of the game if both players play optimally.\\n\\nExample\\n\\nInput\\n\\n\\n3\\n3\\n1 3 7\\n3 5 1\\n3\\n1 3 9\\n3 5 1\\n1\\n4\\n7\\n\\n\\nOutput\\n\\n\\n7\\n8\\n0\\n\\nNote\\n\\nThe paths for the testcases are shown on the following pictures. Alice's path is depicted in red and Bob's path is depicted in blue.\\n\\n<image>\\n#incl\",\"targets\":\"ude <bits\\/stdc++.h>\\nusing namespace std;\\nvoid fast(void) __attribute__((constructor));\\nvoid fast(void) {\\n  ios_base::sync_with_stdio(false);\\n  cin.tie(NULL);\\n}\\nvoid solve() {\\n  long long m;\\n  cin >> m;\\n  vector<long long> a(m), b(m);\\n  for (long long i = 0; i < m; ++i) cin >> a[i];\\n  for (long long i = 0; i < m; ++i) cin >> b[i];\\n  vector<long long> pref(m + 1);\\n  for (long long i = 0; i < m; ++i) {\\n    pref[i + 1] = pref[i] + b[i];\\n  }\\n  vector<long long> suf(m + 1);\\n  for (long long i = m - 1; i >= 0; --i) {\\n    suf[i] = suf[i + 1] + a[i];\\n  }\\n  long long ans = (long long)1e9;\\n  for (long long i = 0; i < m; ++i) {\\n    ans = min(ans, max(pref[i], suf[i + 1]));\\n  }\\n  cout << ans;\\n}\\nsigned main(void) {\\n  long long t;\\n  cin >> t;\\n  while (t--) {\\n    solve();\\n    cout << \\\"\\\\n\\\";\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in PYTHON3?\\nYou are given two strings s and t, both consisting of lowercase English letters. You are going to type the string s character by character, from the first character to the last one.\\n\\nWhen typing a character, instead of pressing the button corresponding to it, you can press the \\\"Backspace\\\" button. It deletes the last character you have typed among those that aren't deleted yet (or does nothing if there are no characters in the current string). For example, if s is \\\"abcbd\\\" and you press Backspace instead of typing the first and the fourth characters, you will get the string \\\"bd\\\" (the first press of Backspace deletes no character, and the second press deletes the character 'c'). Another example, if s is \\\"abcaa\\\" and you press Backspace instead of the last two letters, then the resulting text is \\\"a\\\".\\n\\nYour task is to determine whether you can obtain the string t, if you type the string s and press \\\"Backspace\\\" instead of typing several (maybe zero) characters of s.\\n\\nInput\\n\\nThe first line contains a single integer q (1 \u2264 q \u2264 10^5) \u2014 the number of test cases.\\n\\nThe first line of each test case contains the string s (1 \u2264 |s| \u2264 10^5). Each character of s is a lowercase English letter.\\n\\nThe second line of each test case contains the string t (1 \u2264 |t| \u2264 10^5). Each character of t is a lowercase English letter.\\n\\nIt is guaranteed that the total number of characters in the strings over all test cases does not exceed 2 \u22c5 10^5.\\n\\nOutput\\n\\nFor each test case, print \\\"YES\\\" if you can obtain the string t by typing the string s and replacing some characters with presses of \\\"Backspace\\\" button, or \\\"NO\\\" if you cannot.\\n\\nYou may print each letter in any case (YES, yes, Yes will all be recognized as positive answer, NO, no and nO will all be recognized as negative answer).\\n\\nExample\\n\\nInput\\n\\n\\n4\\nababa\\nba\\nababa\\nbb\\naaa\\naaaa\\naababa\\nababa\\n\\n\\nOutput\\n\\n\\nYES\\nNO\\nNO\\nYES\\n\\nNote\\n\\nConsider the example test from the statement.\\n\\nIn order to obtain \\\"ba\\\" from \\\"ababa\\\", you may press Backspace instead of typing the first and the fourth characters.\\n\\nThere's no way...\",\"targets\":\"import bisect\\nimport math\\nimport collections\\nimport sys\\nimport copy\\nfrom functools import reduce\\nimport decimal\\n\\nsys.setrecursionlimit(10 ** 9)\\ndecimal.getcontext().rounding = decimal.ROUND_HALF_UP\\n\\ngraphDict = collections.defaultdict\\nqueue = collections.deque\\n\\n\\nclass Graphs:\\n    def __init__(self):\\n        self.graph = graphDict(list)\\n\\n    def add_edge(self, u, v):\\n        self.graph[u].append(v)\\n\\n    def dfs_utility(self, nodes, visited_nodes):\\n        visited_nodes.add(nodes)\\n        for neighbour in self.graph[nodes]:\\n            if neighbour not in visited_nodes:\\n                self.dfs_utility(neighbour, visited_nodes)\\n            else:\\n                return neighbour\\n\\n    def dfs(self, node):\\n        Visited = set()\\n        self.dfs_utility(node, Visited)\\n\\n    def bfs(self, node):\\n        visited = set()\\n        if node not in visited:\\n            queue.append(node)\\n            visited.add(node)\\n        while queue:\\n            parent = queue.popleft()\\n            print(parent)\\n            for item in self.graph[parent]:\\n                if item not in visited:\\n                    queue.append(item)\\n                    visited.add(item)\\n\\n\\ndef rounding(n):\\n    return int(decimal.Decimal(f'{n}').to_integral_value())\\n\\n\\ndef factors(n):\\n    return set(reduce(list.__add__,\\n                      ([i, n \\/\\/ i] for i in range(1, int(n ** 0.5) + 1) if n % i == 0)))\\n\\n\\ndef inp():\\n    return sys.stdin.readline().strip()\\n\\n\\ndef map_inp(v_type):\\n    return map(v_type, inp().split())\\n\\n\\ndef list_inp(v_type):\\n    return list(map_inp(v_type))\\n\\n\\n######################################## Solution ####################################\\n\\nfor _ in range(int(inp())):\\n    s = inp()\\n    t = inp()\\n    j = 0\\n    if len(t) > len(s):\\n        print(\\\"NO\\\")\\n    else:\\n        ans = \\\"YES\\\"\\n        clone = \\\"\\\"\\n        j = len(t) - 1\\n        i = len(s) - 1\\n        while i > -1:\\n            if s[i] == t[j]:\\n                clone += t[j]\\n                j -= 1\\n                i -= 1\\n            else:\\n                i -= 2\\n            if j < 0:\\n   ...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Dr .: Peter, I've finally done it.\\nPeter: What's wrong, Dr. David? Is it a silly invention again?\\nDr .: This table, this table.\\n\\n\\n| Character | Sign\\n--- | ---\\n(Blank) | 101\\n'| 000000\\n, | 000011\\n-| 10010001\\n. | 010001\\n? | 000001\\nA | 100101\\nB | 10011010\\n| Character | Sign\\n--- | ---\\nC | 0101\\nD | 0001\\nE | 110\\nF | 01001\\nG | 10011011\\nH | 010000\\nI | 0111\\nJ | 10011000\\n| Character | Sign\\n--- | ---\\nK | 0110\\nL | 00100\\nM | 10011001\\nN | 10011110\\nO | 00101\\nP | 111\\nQ | 10011111\\nR | 1000\\n| Character | Sign\\n--- | ---\\nS | 00110\\nT | 00111\\nU | 10011100\\nV | 10011101\\nW | 000010\\nX | 10010010\\nY | 10010011\\nZ | 10010000\\n\\n\\n\\nPeter: What? This table is.\\nDr .: Okay, just do what you say. First, write your name on a piece of paper.\\nPeter: Yes, \\\"PETER POTTER\\\".\\nDr .: Then, replace each character with the \\\"code\\\" in this table.\\nPeter: Well, change \\\"P\\\" to \\\"111\\\" and \\\"E\\\" to \\\"110\\\" ... It's quite annoying.\\n\\n\\n111 110 00111 110 1000 101 111 00101 00111 00111 110 1000\\n\\n\\nbecame. It looks like a barcode.\\nDr .: All right. Then connect all the replaced strings and separate them by 5 characters.\\nPeter: Yes, if you connect and separate.\\n\\n\\n11111 00011 11101 00010 11110 01010 01110 01111 10100 0\\n\\n\\nIt turned out to be something like this. But what about the last \\\"0\\\" guy?\\nDr .: Add 0 to make it 5 letters.\\nPeter: Well, there is only one 0 at the end, so I should add four more 0s. I was able to do it.\\n\\n\\n\\n11111 00011 11101 00010 11110 01010 01110 01111 10100 00000\\n\\n\\nDr .: Next, use this table.\\n\\n\\n| Sign | Character\\n--- | ---\\n00000 | A\\n00001 | B\\n00010 | C\\n00011 | D\\n00100 | E\\n00101 | F\\n00110 | G\\n00111 | H\\n| Sign | Character\\n--- | ---\\n01000 | I\\n01001 | J\\n01010 | K\\n01011 | L\\n01100 | M\\n01101 | N\\n01110 | O\\n01111 | P\\n| Sign | Character\\n--- | ---\\n10000 | Q\\n10001 | R\\n10010 | S\\n10011 | T\\n10100 | U\\n10101 | V\\n10110 | W\\n10111 | X\\n| Sign | Character\\n--- | ---\\n11000 | Y\\n11001 | Z\\n11010 | (blank)\\n11011 | ..\\n11100 |,\\n11101 |-\\n11110 |'\\n11111 |?\\n\\n\\n\\nPeter: How do you use this ... yeah! Now you're going to replace the code with a letter!\\nDr .: That's right. If it is \\\"11111\\\", go to \\\"?\\\",...\\n#incl\",\"targets\":\"ude <iostream>\\n#include <string>\\n\\nusing namespace std;\\n\\nchar c1[32] = {' ','\\\\'',',','-','.','?','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z'};\\nstring s1[32] = {\\\"101\\\", \\\"000000\\\",\\\"000011\\\",\\\"10010001\\\",\\\"010001\\\",\\\"000001\\\",\\\"100101\\\",\\\"10011010\\\",\\n\\t\\t\\t\\t \\\"0101\\\",\\\"0001\\\",\\\"110\\\",\\\"01001\\\",\\\"10011011\\\",\\\"010000\\\",\\\"0111\\\",\\\"10011000\\\",\\n\\t\\t\\t\\t \\\"0110\\\",\\\"00100\\\",\\\"10011001\\\",\\\"10011110\\\",\\\"00101\\\",\\\"111\\\",\\\"10011111\\\",\\\"1000\\\",\\n\\t\\t\\t\\t \\\"00110\\\",\\\"00111\\\",\\\"10011100\\\",\\\"10011101\\\",\\\"000010\\\",\\\"10010010\\\",\\\"10010011\\\",\\\"10010000\\\"};\\n\\nstring s2[32] = {\\\"00000\\\", \\\"00001\\\", \\\"00010\\\", \\\"00011\\\", \\\"00100\\\", \\\"00101\\\", \\\"00110\\\", \\\"00111\\\", \\n\\t\\t\\t\\t \\\"01000\\\", \\\"01001\\\", \\\"01010\\\", \\\"01011\\\", \\\"01100\\\", \\\"01101\\\", \\\"01110\\\", \\\"01111\\\", \\n\\t\\t\\t\\t \\\"10000\\\", \\\"10001\\\", \\\"10010\\\", \\\"10011\\\", \\\"10100\\\", \\\"10101\\\", \\\"10110\\\", \\\"10111\\\", \\n\\t\\t\\t\\t \\\"11000\\\", \\\"11001\\\", \\\"11010\\\", \\\"11011\\\", \\\"11100\\\", \\\"11101\\\", \\\"11110\\\", \\\"11111\\\"};\\nchar c2[32] = {'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z', ' ', '.',',','-','\\\\'','?'};\\n\\nvoid solve()\\n{\\n\\tstring s;\\n\\twhile(getline(cin, s))\\n\\t{\\n\\t\\tstring binary;\\n\\t\\tfor(int i = 0; i < s.size(); ++i)\\n\\t\\t{\\n\\t\\t\\tfor(int j = 0; j < 32; ++j)\\n\\t\\t\\t{\\n\\t\\t\\t\\tif(s[i] == c1[j])\\n\\t\\t\\t\\t{\\n\\t\\t\\t\\t\\tbinary += s1[j];\\n\\t\\t\\t\\t}\\n\\t\\t\\t}\\n\\t\\t}\\n\\t\\twhile(binary.size() % 5)\\n\\t\\t{\\n\\t\\t\\tbinary += '0';\\n\\t\\t}\\n\\t\\t\\n\\t\\tstring ans;\\n\\t\\tfor(int i = 0; i < binary.size(); i += 5)\\n\\t\\t{\\n\\t\\t\\tstring temp;\\n\\t\\t\\tfor(int j = 0; j < 5; ++j)\\n\\t\\t\\t{\\n\\t\\t\\t\\ttemp += binary[i + j];\\n\\t\\t\\t}\\n\\t\\t\\tfor(int j = 0; j < 32; ++j)\\n\\t\\t\\t{\\n\\t\\t\\t\\tif(temp == s2[j])\\n\\t\\t\\t\\t{\\n\\t\\t\\t\\t\\tans += c2[j];\\n\\t\\t\\t\\t}\\n\\t\\t\\t}\\n\\t\\t}\\n\\t\\tcout << ans << endl;\\n\\t}\\n}\\n\\nint main()\\n{\\n\\tsolve();\\n\\treturn(0);\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"The new generation external memory contains an array of integers a[1 \u2026 n] = [a_1, a_2, \u2026, a_n].\\n\\nThis type of memory does not support changing the value of an arbitrary element. Instead, it allows you to cut out any segment of the given array, cyclically shift (rotate) it by any offset and insert it back into the same place.\\n\\nTechnically, each cyclic shift consists of two consecutive actions: \\n\\n  1. You may select arbitrary indices l and r (1 \u2264 l < r \u2264 n) as the boundaries of the segment. \\n  2. Then you replace the segment a[l \u2026 r] with it's cyclic shift to the left by an arbitrary offset d. The concept of a cyclic shift can be also explained by following relations: the sequence [1, 4, 1, 3] is a cyclic shift of the sequence [3, 1, 4, 1] to the left by the offset 1 and the sequence [4, 1, 3, 1] is a cyclic shift of the sequence [3, 1, 4, 1] to the left by the offset 2. \\n\\n\\n\\nFor example, if a = [1, \\\\color{blue}{3, 2, 8}, 5], then choosing l = 2, r = 4 and d = 2 yields a segment a[2 \u2026 4] = [3, 2, 8]. This segment is then shifted by the offset d = 2 to the left, and you get a segment [8, 3, 2] which then takes the place of of the original elements of the segment. In the end you get a = [1, \\\\color{blue}{8, 3, 2}, 5].\\n\\nSort the given array a using no more than n cyclic shifts of any of its segments. Note that you don't need to minimize the number of cyclic shifts. Any method that requires n or less cyclic shifts will be accepted.\\n\\nInput\\n\\nThe first line contains an integer t (1 \u2264 t \u2264 1000) \u2014 the number of test cases.\\n\\nThe next 2t lines contain the descriptions of the test cases. \\n\\nThe first line of each test case description contains an integer n (2 \u2264 n \u2264 50) \u2014 the length of the array. The second line consists of space-separated elements of the array a_i (-10^9 \u2264 a_i \u2264 10^9). Elements of array a may repeat and don't have to be unique.\\n\\nOutput\\n\\nPrint t answers to all input test cases. \\n\\nThe first line of the answer of each test case should contain an integer k (0 \u2264 k \u2264 n) \u2014 the number of actions to sort the array....\\nUsing python3 can you solve the prior task?\",\"targets\":\"def rotate(arr, left, cnt):\\n    return arr[:left] + arr[left+cnt:] + arr[left:left+cnt]\\n   \\nfor _ in range(int(input())):\\n    n = int(input())\\n    a = list(map(int, input().split()))\\n\\n    st = sorted(a)\\n\\n    ans = []\\n    for i in range(1, n+1):\\n        # print('=>', a)\\n        if a[i-1] != st[i-1]:\\n            index = a.index(st[i-1], i-1)\\n            r = index - i + 1\\n\\n            # print(i, r, index)\\n\\n            ans.append((i, n, r))\\n            a = rotate(a, i-1, r)\\n            # print('!=', a)\\n    \\n    print(len(ans))\\n\\n    for x in ans:\\n        print(*x)\",\"language\":\"python\",\"split\":\"test\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Monocarp is playing a computer game. Now he wants to complete the first level of this game.\\n\\nA level is a rectangular grid of 2 rows and n columns. Monocarp controls a character, which starts in cell (1, 1) \u2014 at the intersection of the 1-st row and the 1-st column.\\n\\nMonocarp's character can move from one cell to another in one step if the cells are adjacent by side and\\/or corner. Formally, it is possible to move from cell (x_1, y_1) to cell (x_2, y_2) in one step if |x_1 - x_2| \u2264 1 and |y_1 - y_2| \u2264 1. Obviously, it is prohibited to go outside the grid.\\n\\nThere are traps in some cells. If Monocarp's character finds himself in such a cell, he dies, and the game ends.\\n\\nTo complete a level, Monocarp's character should reach cell (2, n) \u2014 at the intersection of row 2 and column n.\\n\\nHelp Monocarp determine if it is possible to complete the level.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 100) \u2014 the number of test cases. Then the test cases follow. Each test case consists of three lines.\\n\\nThe first line contains a single integer n (3 \u2264 n \u2264 100) \u2014 the number of columns.\\n\\nThe next two lines describe the level. The i-th of these lines describes the i-th line of the level \u2014 the line consists of the characters '0' and '1'. The character '0' corresponds to a safe cell, the character '1' corresponds to a trap cell.\\n\\nAdditional constraint on the input: cells (1, 1) and (2, n) are safe.\\n\\nOutput\\n\\nFor each test case, output YES if it is possible to complete the level, and NO otherwise.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n3\\n000\\n000\\n4\\n0011\\n1100\\n4\\n0111\\n1110\\n6\\n010101\\n101010\\n\\n\\nOutput\\n\\n\\nYES\\nYES\\nNO\\nYES\\n\\nNote\\n\\nConsider the example from the statement.\\n\\nIn the first test case, one of the possible paths is (1, 1) \u2192 (2, 2) \u2192 (2, 3).\\n\\nIn the second test case, one of the possible paths is (1, 1) \u2192 (1, 2) \u2192 (2, 3) \u2192 (2, 4).\\n\\nIn the fourth test case, one of the possible paths is (1, 1) \u2192 (2, 2) \u2192 (1, 3) \u2192 (2, 4) \u2192 (1, 5) \u2192 (2, 6).\\nSolve the task in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint main() {\\n  long t;\\n  cin >> t;\\n  while (t--) {\\n    long n;\\n    cin >> n;\\n    string s1;\\n    string s2;\\n    cin >> s1;\\n    cin >> s2;\\n    int flag = 0;\\n    for (long i = 1; i < n; i++) {\\n      if (s1[i] == '1' && s2[i] == '1') {\\n        flag = 1;\\n        break;\\n      }\\n    }\\n    if (s2[n - 1] == '1') {\\n      flag = 1;\\n    }\\n    if (flag == 1) {\\n      cout << \\\"NO\\\" << endl;\\n    } else {\\n      cout << \\\"YES\\\" << endl;\\n    }\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Monocarp has got an array a consisting of n integers. Let's denote k as the mathematic mean of these elements (note that it's possible that k is not an integer). \\n\\nThe mathematic mean of an array of n elements is the sum of elements divided by the number of these elements (i. e. sum divided by n).\\n\\nMonocarp wants to delete exactly two elements from a so that the mathematic mean of the remaining (n - 2) elements is still equal to k.\\n\\nYour task is to calculate the number of pairs of positions [i, j] (i < j) such that if the elements on these positions are deleted, the mathematic mean of (n - 2) remaining elements is equal to k (that is, it is equal to the mathematic mean of n elements of the original array a).\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 10^4) \u2014 the number of testcases.\\n\\nThe first line of each testcase contains one integer n (3 \u2264 n \u2264 2 \u22c5 10^5) \u2014 the number of elements in the array.\\n\\nThe second line contains a sequence of integers a_1, a_2, ..., a_n (0 \u2264 a_i \u2264 10^{9}), where a_i is the i-th element of the array.\\n\\nThe sum of n over all testcases doesn't exceed 2 \u22c5 10^5.\\n\\nOutput\\n\\nPrint one integer \u2014 the number of pairs of positions [i, j] (i < j) such that if the elements on these positions are deleted, the mathematic mean of (n - 2) remaining elements is equal to k (that is, it is equal to the mathematic mean of n elements of the original array a).\\n\\nExample\\n\\nInput\\n\\n\\n4\\n4\\n8 8 8 8\\n3\\n50 20 10\\n5\\n1 4 7 3 5\\n7\\n1 2 3 4 5 6 7\\n\\n\\nOutput\\n\\n\\n6\\n0\\n2\\n3\\n\\nNote\\n\\nIn the first example, any pair of elements can be removed since all of them are equal.\\n\\nIn the second example, there is no way to delete two elements so the mathematic mean doesn't change.\\n\\nIn the third example, it is possible to delete the elements on positions 1 and 3, or the elements on positions 4 and 5.\\nfrom\",\"targets\":\"sys import stdin, stdout\\nip = lambda : stdin.readline().rstrip(\\\"\\\\r\\\\n\\\")\\nips = lambda : ip().split()\\nmp = lambda : map(int, ips())\\nls = lambda : list(mp())\\nout = lambda x, end='\\\\n': stdout.write(f\\\"{x}{end}\\\")\\nfrom collections import defaultdict\\n# inf = float(\\\"inf\\\")\\n# mod = 10**9+7\\n    \\nfor _ in range(int(ip())):\\n    n = int(ip())\\n    a = ls()\\n    s = sum(a)*2\\n    if s%n != 0:\\n        out(0)\\n    else:\\n        s \\/\\/= n\\n        d = defaultdict(int)\\n        c = 0\\n        for i in range(n):\\n            if d.get(s-a[i], -1) != -1:\\n                c += d[s-a[i]]\\n            d[a[i]] += 1\\n        out(c)\",\"language\":\"python\",\"split\":\"test\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Monocarp is playing yet another computer game. In this game, his character has to kill a dragon. The battle with the dragon lasts 100^{500} seconds, during which Monocarp attacks the dragon with a poisoned dagger. The i-th attack is performed at the beginning of the a_i-th second from the battle start. The dagger itself does not deal damage, but it applies a poison effect on the dragon, which deals 1 damage during each of the next k seconds (starting with the same second when the dragon was stabbed by the dagger). However, if the dragon has already been poisoned, then the dagger updates the poison effect (i.e. cancels the current poison effect and applies a new one).\\n\\nFor example, suppose k = 4, and Monocarp stabs the dragon during the seconds 2, 4 and 10. Then the poison effect is applied at the start of the 2-nd second and deals 1 damage during the 2-nd and 3-rd seconds; then, at the beginning of the 4-th second, the poison effect is reapplied, so it deals exactly 1 damage during the seconds 4, 5, 6 and 7; then, during the 10-th second, the poison effect is applied again, and it deals 1 damage during the seconds 10, 11, 12 and 13. In total, the dragon receives 10 damage.\\n\\nMonocarp knows that the dragon has h hit points, and if he deals at least h damage to the dragon during the battle \u2014 he slays the dragon. Monocarp has not decided on the strength of the poison he will use during the battle, so he wants to find the minimum possible value of k (the number of seconds the poison effect lasts) that is enough to deal at least h damage to the dragon.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 1000) \u2014 the number of test cases.\\n\\nThe first line of the test case contains two integers n and h (1 \u2264 n \u2264 100; 1 \u2264 h \u2264 10^{18}) \u2014 the number of Monocarp's attacks and the amount of damage that needs to be dealt.\\n\\nThe second line contains n integers a_1, a_2, ..., a_n (1 \u2264 a_i \u2264 10^9; a_i < a_{i + 1}), where a_i is the second when the i-th attack is performed.\\n\\nOutput\\n\\nFor each test case, print a single...\\nSolve the task in JAVA.\",\"targets\":\"import java.util.*;\\nimport java.lang.*;\\nimport java.io.*;\\n\\n\\npublic class Main {\\n\\n\\tpublic static void solve() {\\n\\t\\tint n = in.nextInt();\\n\\t\\tlong h = in.nextLong();\\n\\t\\tint[] a = array(n);\\n\\t\\tfor (int i = 0; i < n - 1; i++) {\\n\\t\\t\\ta[i] = a[i + 1] - a[i];\\n\\t\\t}\\n\\t\\tlong low = 1;\\n\\t\\tlong high = (long)1e18;\\n\\t\\twhile (low <= high) {\\n\\t\\t\\tlong mid = low + (high - low) \\/ 2;\\n\\t\\t\\tlong val = compute(a, mid);\\n\\t\\t\\tlong valMinus = compute(a, mid - 1);\\n\\t\\t\\tif (val == h) {\\n\\t\\t\\t\\t\\/\\/ print(\\\"From 1\\\");\\n\\t\\t\\t\\tout.append(mid + \\\"\\\\n\\\");\\n\\t\\t\\t\\treturn;\\n\\t\\t\\t}\\n\\t\\t\\tif (val >= h && valMinus < h) {\\n\\t\\t\\t\\tout.append(mid + \\\"\\\\n\\\");\\n\\t\\t\\t\\treturn;\\n\\t\\t\\t}\\n\\t\\t\\tif (val > h) {\\n\\t\\t\\t\\thigh = mid - 1;\\n\\t\\t\\t}\\n\\t\\t\\tif (val < h) {\\n\\t\\t\\t\\tlow = mid + 1;\\n\\t\\t\\t}\\n\\t\\t}\\n\\n\\t}\\n\\tstatic long compute(int[] a, long k) {\\n\\t\\tlong val = 0l;\\n\\t\\tfor (int i = 0 ; i < a.length - 1; i++) {\\n\\t\\t\\tval += Math.min(a[i], k);\\n\\t\\t}\\n\\t\\tval += k;\\n\\t\\treturn val;\\n\\t}\\n\\n\\tpublic static void main (String[] args) throws java.lang.Exception {\\n\\t\\t\\/\\/ your code goes here\\n\\t\\tint t = in.nextInt();\\n\\t\\twhile (t-- != 0) {\\n\\t\\t\\tsolve();\\n\\t\\t}\\n\\t\\tSystem.out.print(out);\\n\\t}\\n\\tpublic static <T> void print(T s) {\\n\\t\\tSystem.out.print(s);\\n\\t}\\n\\tpublic static <T> void println(T s) {\\n\\t\\tSystem.out.println(s);\\n\\t}\\n\\tpublic static void print(int s) {\\n\\t\\tSystem.out.print(s);\\n\\t}\\n\\tpublic static void println(int s) {\\n\\t\\tSystem.out.println(s);\\n\\t}\\n\\n\\tpublic static  void print(int[] a) {\\n\\t\\tint k = 0;\\n\\t\\tfor (int i : a) {\\n\\t\\t\\tprint(k++ +\\\":\\\" + i + \\\" \\\");\\n\\t\\t}\\n\\t\\tprintln(\\\"\\\");\\n\\t}\\n\\tpublic static int[] array(int n) {\\n\\t\\tint[] a = new int[n];\\n\\t\\tfor (int i = 0; i < n; i++) {\\n\\t\\t\\ta[i] = in.nextInt();\\n\\t\\t}\\n\\t\\treturn a;\\n\\t}\\n\\tpublic static int[] array1(int n) {\\n\\t\\tint[] a = new int[n + 1];\\n\\t\\tfor (int i = 1; i <= n; i++) {\\n\\t\\t\\ta[i] = in.nextInt();\\n\\t\\t}\\n\\t\\treturn a;\\n\\t}\\n\\n\\n\\tstatic FastReader in = new FastReader();\\n\\tstatic StringBuffer out = new StringBuffer();\\n\\tstatic final int MAX = Integer.MAX_VALUE;\\n\\tstatic final int MIN = Integer.MIN_VALUE;\\n\\tstatic int mod = 1000000007;\\n}\\nclass FastReader {\\n\\tBufferedReader br;\\n\\tStringTokenizer st;\\n\\n\\tpublic FastReader() {\\n\\t\\tbr = new BufferedReader(\\n\\t\\t    new...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"This is the easy version of the problem. The only difference between the two versions is the constraint on n. You can make hacks only if all versions of the problem are solved.\\n\\nA forest is an undirected graph without cycles (not necessarily connected).\\n\\nMocha and Diana are friends in Zhijiang, both of them have a forest with nodes numbered from 1 to n, and they would like to add edges to their forests such that: \\n\\n  * After adding edges, both of their graphs are still forests. \\n  * They add the same edges. That is, if an edge (u, v) is added to Mocha's forest, then an edge (u, v) is added to Diana's forest, and vice versa. \\n\\n\\n\\nMocha and Diana want to know the maximum number of edges they can add, and which edges to add.\\n\\nInput\\n\\nThe first line contains three integers n, m_1 and m_2 (1 \u2264 n \u2264 1000, 0 \u2264 m_1, m_2 < n) \u2014 the number of nodes and the number of initial edges in Mocha's forest and Diana's forest.\\n\\nEach of the next m_1 lines contains two integers u and v (1 \u2264 u, v \u2264 n, u \u2260 v) \u2014 the edges in Mocha's forest.\\n\\nEach of the next m_2 lines contains two integers u and v (1 \u2264 u, v \u2264 n, u \u2260 v) \u2014 the edges in Diana's forest.\\n\\nOutput\\n\\nThe first line contains only one integer h, the maximum number of edges Mocha and Diana can add (in each forest).\\n\\nEach of the next h lines contains two integers u and v (1 \u2264 u, v \u2264 n, u \u2260 v) \u2014 the edge you add each time.\\n\\nIf there are multiple correct answers, you can print any one of them.\\n\\nExamples\\n\\nInput\\n\\n\\n3 2 2\\n1 2\\n2 3\\n1 2\\n1 3\\n\\n\\nOutput\\n\\n\\n0\\n\\n\\nInput\\n\\n\\n5 3 2\\n5 4\\n2 1\\n4 3\\n4 3\\n1 4\\n\\n\\nOutput\\n\\n\\n1\\n2 4\\n\\n\\nInput\\n\\n\\n8 1 2\\n1 7\\n2 6\\n1 5\\n\\n\\nOutput\\n\\n\\n5\\n5 2\\n2 3\\n3 4\\n4 7\\n6 8\\n\\nNote\\n\\nIn the first example, we cannot add any edge.\\n\\nIn the second example, the initial forests are as follows.\\n\\n<image>\\n\\nWe can add an edge (2, 4).\\n\\n<image>\\nThe above is tricky. Write me a correct solution in JAVA.\",\"targets\":\"import java.io.OutputStream;\\nimport java.io.IOException;\\nimport java.io.InputStream;\\nimport java.io.OutputStream;\\nimport java.io.PrintWriter;\\nimport java.io.BufferedWriter;\\nimport java.io.IOException;\\nimport java.io.InputStreamReader;\\nimport java.util.ArrayList;\\nimport java.util.Objects;\\nimport java.util.StringTokenizer;\\nimport java.io.Writer;\\nimport java.io.OutputStreamWriter;\\nimport java.io.BufferedReader;\\nimport java.io.InputStream;\\n\\n\\/**\\n * Built using CHelper plug-in\\n * Actual solution is at the top\\n *\\/\\npublic class Main {\\n    public static void main(String[] args) {\\n        InputStream inputStream = System.in;\\n        OutputStream outputStream = System.out;\\n        InputReader in = new InputReader(inputStream);\\n        OutputWriter out = new OutputWriter(outputStream);\\n        D1MochaAndDianaEasyVersion solver = new D1MochaAndDianaEasyVersion();\\n        solver.solve(1, in, out);\\n        out.close();\\n    }\\n\\n    static class D1MochaAndDianaEasyVersion {\\n        public void solve(int testNumber, InputReader in, OutputWriter out) {\\n            int n = in.nextInt(), m1 = in.nextInt(), m2 = in.nextInt();\\n            UnionFind g1 = new UnionFind(n), g2 = new UnionFind(n);\\n            for (int i = 0; i < m1; i++) {\\n                g1.unify(in.nextInt() - 1, in.nextInt() - 1);\\n            }\\n            for (int i = 0; i < m2; i++) {\\n                g2.unify(in.nextInt() - 1, in.nextInt() - 1);\\n            }\\n            ArrayList<D1MochaAndDianaEasyVersion.Pair> list = new ArrayList<>();\\n            for (int i = 0; i < n; i++) {\\n                for (int j = i + 1; j < n; j++) {\\n                    if (!g1.connected(i, j) && !g2.connected(i, j)) {\\n                        list.add(new D1MochaAndDianaEasyVersion.Pair(i + 1, j + 1));\\n                        g1.unify(i, j);\\n                        g2.unify(i, j);\\n                    }\\n                }\\n            }\\n            out.println(list.size());\\n            for (D1MochaAndDianaEasyVersion.Pair p : list) out.println(p.a + \\\" \\\" + p.b);\\n        }\\n\\n        static...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Baby Badawy's first words were \\\"AND 0 SUM BIG\\\", so he decided to solve the following problem. Given two integers n and k, count the number of arrays of length n such that:\\n\\n  * all its elements are integers between 0 and 2^k-1 (inclusive); \\n  * the [bitwise AND](https:\\/\\/en.wikipedia.org\\/wiki\\/Bitwise_operation#AND) of all its elements is 0; \\n  * the sum of its elements is as large as possible. \\n\\n\\n\\nSince the answer can be very large, print its remainder when divided by 10^9+7.\\n\\nInput\\n\\nThe first line contains an integer t (1 \u2264 t \u2264 10) \u2014 the number of test cases you need to solve.\\n\\nEach test case consists of a line containing two integers n and k (1 \u2264 n \u2264 10^{5}, 1 \u2264 k \u2264 20).\\n\\nOutput\\n\\nFor each test case, print the number of arrays satisfying the conditions. Since the answer can be very large, print its remainder when divided by 10^9+7.\\n\\nExample\\n\\nInput\\n\\n\\n2\\n2 2\\n100000 20\\n\\n\\nOutput\\n\\n\\n4\\n226732710\\n\\nNote\\n\\nIn the first example, the 4 arrays are:\\n\\n  * [3,0], \\n  * [0,3], \\n  * [1,2], \\n  * [2,1]. \\nThe above is tricky. Write me a correct solution in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\n#define rep(i,a,n) for (int i=a;i<n;i++)\\n#define rev(i,a,n) for (int i=a;i>n;i--)\\n#define repi(it,v) for (auto it=(v).begin();it!=(v).end();it++)\\n#define revi(it,v) for (auto it=(v).rbegin();it!=(v).rend();it++)\\n#define pii pair<int,int>\\n#define fr first\\n#define sc second\\n#define mpr make_pair\\n#define all(v) (v).begin(),(v).end()\\n#define init(a,i) memset(a,i,sizeof(a))\\n#define vi vector <int>\\n#define vc vector <char>\\n#define pb push_back\\n#define ppb pop_back\\n#define si set <int>\\n#define in insert\\n#define endl \\\"\\\\n\\\"\\n\\n#define L 1000000007 \\/\\/10e9\\n#define mod 100007 \\/\\/10e5\\n\\n#define io ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);\\n#define int long long\\n\\nusing namespace std;\\nsigned main()\\n{\\n  io;\\n  int T = 1;\\n  cin >> T;\\n\\n  while (T--)\\n  {\\n    int n,k;\\n    cin>>n>>k;\\n    int ans=1;\\n    rep(i,0,k)\\n    {\\n      ans*=n;\\n      ans%=L;\\n    }\\n    cout<<ans<<\\\"\\\\n\\\";\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Bob is an avid fan of the video game \\\"League of Leesins\\\", and today he celebrates as the League of Leesins World Championship comes to an end! \\n\\nThe tournament consisted of n (n \u2265 5) teams around the world. Before the tournament starts, Bob has made a prediction of the rankings of each team, from 1-st to n-th. After the final, he compared the prediction with the actual result and found out that the i-th team according to his prediction ended up at the p_i-th position (1 \u2264 p_i \u2264 n, all p_i are unique). In other words, p is a permutation of 1, 2, ..., n.\\n\\nAs Bob's favorite League player is the famous \\\"3ga\\\", he decided to write down every 3 consecutive elements of the permutation p. Formally, Bob created an array q of n-2 triples, where q_i = (p_i, p_{i+1}, p_{i+2}) for each 1 \u2264 i \u2264 n-2. Bob was very proud of his array, so he showed it to his friend Alice.\\n\\nAfter learning of Bob's array, Alice declared that she could retrieve the permutation p even if Bob rearranges the elements of q and the elements within each triple. Of course, Bob did not believe in such magic, so he did just the same as above to see Alice's respond.\\n\\nFor example, if n = 5 and p = [1, 4, 2, 3, 5], then the original array q will be [(1, 4, 2), (4, 2, 3), (2, 3, 5)]. Bob can then rearrange the numbers within each triple and the positions of the triples to get [(4, 3, 2), (2, 3, 5), (4, 1, 2)]. Note that [(1, 4, 2), (4, 2, 2), (3, 3, 5)] is not a valid rearrangement of q, as Bob is not allowed to swap numbers belong to different triples.\\n\\nAs Alice's friend, you know for sure that Alice was just trying to show off, so you decided to save her some face by giving her any permutation p that is consistent with the array q she was given. \\n\\nInput\\n\\nThe first line contains a single integer n (5 \u2264 n \u2264 10^5) \u2014 the size of permutation p.\\n\\nThe i-th of the next n-2 lines contains 3 integers q_{i, 1}, q_{i, 2}, q_{i, 3} (1 \u2264 q_{i, j} \u2264 n) \u2014 the elements of the i-th triple of the rearranged (shuffled) array q_i, in random order. Remember, that the numbers...\\nThe above is tricky. Write me a correct solution in JAVA.\",\"targets\":\"import java.util.*;\\nimport java.io.*;\\n\\npublic class Solution{\\n    static HashMap<String,List> map;\\n    public static void add(int x,int y,int z)\\n    {\\n        List list;\\n        String s=\\\"\\\"+x+\\\" \\\"+y;\\n        if(map.containsKey(s))\\n        {\\n            list=map.get(s);\\n            list.add(z);\\n            map.put(s,list);\\n        }\\n        else {\\n            list=new LinkedList<>();\\n            list.add(z);\\n            map.put(s, list);\\n        }\\n    }\\n    public static void main(String args[])throws IOException{\\n        FastReader in=new FastReader(System.in);\\n        StringBuilder sb=new StringBuilder();\\n        int i,j;\\n        int n=in.nextInt();\\n        int x,y,z,pre;\\n        int freq[]=new int[n+1];\\n        Integer ind[]=new Integer[n+1];\\n        int ans[]=new int[n+1];\\n        for(i=0;i<=n;i++)\\n            ind[i]=i;\\n        map=new HashMap<>();\\n        List list;\\n        String s;\\n        for(i=0;i<n-2;i++)\\n        {\\n            x=in.nextInt();\\n            y=in.nextInt();\\n            z=in.nextInt();\\n            freq[x]++;\\n            freq[y]++;\\n            freq[z]++;\\n            add(x,y,z);\\n            add(y,x,z);\\n            add(x,z,y);\\n            add(z,x,y);\\n            add(y,z,x);\\n            add(z,y,x);\\n\\n        }\\n        \\/\\/System.out.println(Arrays.toString(freq));\\n        \\/\\/System.out.println(Arrays.toString(ind));\\n        Arrays.sort(ind,(a,b)->Integer.compare(freq[a],freq[b]));\\n        y=ind[3];\\n        s=\\\"\\\"+ind[1]+\\\" \\\"+ind[3];\\n        x=ind[1];\\n        if(map.containsKey(s))\\n        {\\n            ans[1]=ind[1];\\n            ans[2]=ind[3];\\n        }\\n        else\\n        {\\n            ans[1]=ind[1];\\n            ans[2]=ind[4];\\n            s=\\\"\\\"+ind[1]+\\\" \\\"+ind[4];\\n            y=ind[4];\\n        }\\n        list=map.get(s);\\n        ans[3]=(int)list.get(0);\\n        z=ans[3];\\n        \\/\\/System.out.println(s);\\n        \\/\\/System.out.println(Arrays.toString(ans));\\n        for(i=4;i<=n;i++)\\n        {\\n            s=\\\"\\\"+y+\\\" \\\"+z;\\n            \\/\\/System.out.println(s);\\n           ...\",\"language\":\"python\",\"split\":\"train\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Some number of people (this number is even) have stood in a circle. The people stand in the circle evenly. They are numbered clockwise starting from a person with the number 1. Each person is looking through the circle's center at the opposite person.\\n\\n<image> A sample of a circle of 6 persons. The orange arrows indicate who is looking at whom.\\n\\nYou don't know the exact number of people standing in the circle (but this number is even, no doubt). It is known that the person with the number a is looking at the person with the number b (and vice versa, of course). What is the number associated with a person being looked at by the person with the number c? If, for the specified a, b, and c, no such circle exists, output -1.\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases. Then t test cases follow.\\n\\nEach test case consists of one line containing three distinct integers a, b, c (1 \u2264 a,b,c \u2264 10^8).\\n\\nOutput\\n\\nFor each test case output in a separate line a single integer d \u2014 the number of the person being looked at by the person with the number c in a circle such that the person with the number a is looking at the person with the number b. If there are multiple solutions, print any of them. Output -1 if there's no circle meeting the given conditions.\\n\\nExample\\n\\nInput\\n\\n\\n7\\n6 2 4\\n2 3 1\\n2 4 10\\n5 3 4\\n1 3 2\\n2 5 4\\n4 3 2\\n\\n\\nOutput\\n\\n\\n8\\n-1\\n-1\\n-1\\n4\\n1\\n-1\\n\\nNote\\n\\nIn the first test case, there's a desired circle of 8 people. The person with the number 6 will look at the person with the number 2 and the person with the number 8 will look at the person with the number 4.\\n\\nIn the second test case, there's no circle meeting the conditions. If the person with the number 2 is looking at the person with the number 3, the circle consists of 2 people because these persons are neighbors. But, in this case, they must have the numbers 1 and 2, but it doesn't meet the problem's conditions.\\n\\nIn the third test case, the only circle with the persons with the numbers 2 and 4 looking at each other consists of 4...\",\"targets\":\"#include <bits\\/stdc++.h>\\n#pragma GCC optimize(\\\"unroll-loops\\\")\\n#pragma GCC optimize(\\\"Ofast,no-stack-protector\\\")\\n#pragma GCC target(\\\"sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,fma\\\")\\n#pragma GCC target(\\\"sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native\\\")\\n#pragma GCC optimization(\\\"O3\\\")\\n#pragma GCC optimization(\\\"unroll-loops\\\")\\nusing namespace std;\\nint t, a, b, c;\\nvoid ILoveYasashiSenseiForever() {\\n  if (a > b) swap(a, b);\\n  int all = (b - a) * 2;\\n  if (all < max(a, b))\\n    cout << \\\"-1\\\\n\\\";\\n  else if (c > all)\\n    cout << \\\"-1\\\\n\\\";\\n  else if (c == all \\/ 2) {\\n    cout << all << \\\"\\\\n\\\";\\n  } else if (c < all \\/ 2) {\\n    cout << c - a + b << \\\"\\\\n\\\";\\n  } else\\n    cout << c - b + a << \\\"\\\\n\\\";\\n}\\nint main() {\\n  ios_base::sync_with_stdio(false);\\n  cin.tie(0);\\n  cout.tie(0);\\n  if (fopen(\\\"A\\\"\\n            \\\".inp\\\",\\n            \\\"r\\\")) {\\n    freopen(\\n        \\\"A\\\"\\n        \\\".inp\\\",\\n        \\\"r\\\", stdin);\\n    freopen(\\n        \\\"A\\\"\\n        \\\".out\\\",\\n        \\\"w\\\", stdout);\\n  }\\n  cin >> t;\\n  while (t--) {\\n    cin >> a >> b >> c;\\n    ILoveYasashiSenseiForever();\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"In this task Anna and Maria play the following game. Initially they have a checkered piece of paper with a painted n \u00d7 m rectangle (only the border, no filling). Anna and Maria move in turns and Anna starts. During each move one should paint inside the last-painted rectangle a new lesser rectangle (along the grid lines). The new rectangle should have no common points with the previous one. Note that when we paint a rectangle, we always paint only the border, the rectangles aren't filled.\\n\\nNobody wins the game \u2014 Anna and Maria simply play until they have done k moves in total. Count the number of different ways to play this game.\\n\\nInput\\n\\nThe first and only line contains three integers: n, m, k (1 \u2264 n, m, k \u2264 1000).\\n\\nOutput\\n\\nPrint the single number \u2014 the number of the ways to play the game. As this number can be very big, print the value modulo 1000000007 (109 + 7).\\n\\nExamples\\n\\nInput\\n\\n3 3 1\\n\\n\\nOutput\\n\\n1\\n\\n\\nInput\\n\\n4 4 1\\n\\n\\nOutput\\n\\n9\\n\\n\\nInput\\n\\n6 7 2\\n\\n\\nOutput\\n\\n75\\n\\nNote\\n\\nTwo ways to play the game are considered different if the final pictures are different. In other words, if one way contains a rectangle that is not contained in the other way.\\n\\nIn the first sample Anna, who performs her first and only move, has only one possible action plan \u2014 insert a 1 \u00d7 1 square inside the given 3 \u00d7 3 square.\\n\\nIn the second sample Anna has as much as 9 variants: 4 ways to paint a 1 \u00d7 1 square, 2 ways to insert a 1 \u00d7 2 rectangle vertically, 2 more ways to insert it horizontally and one more way is to insert a 2 \u00d7 2 square.\\\":\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst long long MOD = 1000000000 + 7;\\nlong long n, m, k;\\nlong long F[1009][1009];\\nvoid init() {\\n  for (int i = 1; i <= 1000; i++)\\n    for (int j = 1; j <= 1000; j++) F[i][j] = 0LL;\\n  for (int i = 1; i <= 1000; i++) F[i][0] = 1LL;\\n  F[3][1] = 1;\\n  for (int i = 4; i <= 1000; i++)\\n    for (int j = 1; j <= 1000; j++)\\n      F[i][j] =\\n          (F[i - 2][j - 1] + F[i - 1][j] + F[i - 1][j] - F[i - 2][j] + MOD) %\\n          MOD;\\n}\\nint main() {\\n  cin >> n >> m >> k;\\n  init();\\n  cout << (F[n][k] * F[m][k]) % MOD << \\\"\\\\n\\\";\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Polycarp likes squares and cubes of positive integers. Here is the beginning of the sequence of numbers he likes: 1, 4, 8, 9, ....\\n\\nFor a given number n, count the number of integers from 1 to n that Polycarp likes. In other words, find the number of such x that x is a square of a positive integer number or a cube of a positive integer number (or both a square and a cube simultaneously).\\n\\nInput\\n\\nThe first line contains an integer t (1 \u2264 t \u2264 20) \u2014 the number of test cases.\\n\\nThen t lines contain the test cases, one per line. Each of the lines contains one integer n (1 \u2264 n \u2264 10^9).\\n\\nOutput\\n\\nFor each test case, print the answer you are looking for \u2014 the number of integers from 1 to n that Polycarp likes.\\n\\nExample\\n\\nInput\\n\\n\\n6\\n10\\n1\\n25\\n1000000000\\n999999999\\n500000000\\n\\n\\nOutput\\n\\n\\n4\\n1\\n6\\n32591\\n32590\\n23125\\n#incl\",\"targets\":\"ude <bits\\/stdc++.h>\\nusing namespace std;\\nint countSC(int N) {\\n  int res = (int)sqrt(N) + (int)cbrt(N) - (int)(sqrt(cbrt(N)));\\n  return res;\\n}\\nint main() {\\n  int t;\\n  cin >> t;\\n  while (t--) {\\n    int n;\\n    cin >> n;\\n    cout << countSC(n) << endl;\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"As you may know, MemSQL has American offices in both San Francisco and Seattle. Being a manager in the company, you travel a lot between the two cities, always by plane.\\n\\nYou prefer flying from Seattle to San Francisco than in the other direction, because it's warmer in San Francisco. You are so busy that you don't remember the number of flights you have made in either direction. However, for each of the last n days you know whether you were in San Francisco office or in Seattle office. You always fly at nights, so you never were at both offices on the same day. Given this information, determine if you flew more times from Seattle to San Francisco during the last n days, or not.\\n\\nInput\\n\\nThe first line of input contains single integer n (2 \u2264 n \u2264 100) \u2014 the number of days.\\n\\nThe second line contains a string of length n consisting of only capital 'S' and 'F' letters. If the i-th letter is 'S', then you were in Seattle office on that day. Otherwise you were in San Francisco. The days are given in chronological order, i.e. today is the last day in this sequence.\\n\\nOutput\\n\\nPrint \\\"YES\\\" if you flew more times from Seattle to San Francisco, and \\\"NO\\\" otherwise.\\n\\nYou can print each letter in any case (upper or lower).\\n\\nExamples\\n\\nInput\\n\\n4\\nFSSF\\n\\n\\nOutput\\n\\nNO\\n\\n\\nInput\\n\\n2\\nSF\\n\\n\\nOutput\\n\\nYES\\n\\n\\nInput\\n\\n10\\nFFFFFFFFFF\\n\\n\\nOutput\\n\\nNO\\n\\n\\nInput\\n\\n10\\nSSFFSFFSFF\\n\\n\\nOutput\\n\\nYES\\n\\nNote\\n\\nIn the first example you were initially at San Francisco, then flew to Seattle, were there for two days and returned to San Francisco. You made one flight in each direction, so the answer is \\\"NO\\\".\\n\\nIn the second example you just flew from Seattle to San Francisco, so the answer is \\\"YES\\\".\\n\\nIn the third example you stayed the whole period in San Francisco, so the answer is \\\"NO\\\".\\n\\nIn the fourth example if you replace 'S' with ones, and 'F' with zeros, you'll get the first few digits of \u03c0 in binary representation. Not very useful information though.\\nUsing python3 can you solve the prior task?\",\"targets\":\"a=int(input())\\na=input()\\nif a[0]==\\\"S\\\" and a[-1]==\\\"F\\\":\\n    print(\\\"YES\\\")\\nelse:\\n    print(\\\"NO\\\")\",\"language\":\"python\",\"split\":\"train\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in JAVA?\\nYou are given an array consisting of all integers from [l, r] inclusive. For example, if l = 2 and r = 5, the array would be [2, 3, 4, 5]. What's the minimum number of elements you can delete to make the [bitwise AND](https:\\/\\/en.wikipedia.org\\/wiki\\/Bitwise_operation#AND) of the array non-zero?\\n\\nA bitwise AND is a binary operation that takes two equal-length binary representations and performs the AND operation on each pair of the corresponding bits.\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases. Then t cases follow.\\n\\nThe first line of each test case contains two integers l and r (1 \u2264 l \u2264 r \u2264 2 \u22c5 10^5) \u2014 the description of the array.\\n\\nOutput\\n\\nFor each test case, output a single integer \u2014 the answer to the problem.\\n\\nExample\\n\\nInput\\n\\n\\n5\\n1 2\\n2 8\\n4 5\\n1 5\\n100000 200000\\n\\n\\nOutput\\n\\n\\n1\\n3\\n0\\n2\\n31072\\n\\nNote\\n\\nIn the first test case, the array is [1, 2]. Currently, the bitwise AND is 0, as 1\\\\ \\\\& \\\\ 2 = 0. However, after deleting 1 (or 2), the array becomes [2] (or [1]), and the bitwise AND becomes 2 (or 1). This can be proven to be the optimal, so the answer is 1.\\n\\nIn the second test case, the array is [2, 3, 4, 5, 6, 7, 8]. Currently, the bitwise AND is 0. However, after deleting 4, 5, and 8, the array becomes [2, 3, 6, 7], and the bitwise AND becomes 2. This can be proven to be the optimal, so the answer is 3. Note that there may be other ways to delete 3 elements.\",\"targets\":\"import java.io.IOException;\\nimport java.io.BufferedReader;\\nimport java.io.InputStreamReader;\\nimport java.io.PrintWriter;\\nimport java.util.Arrays;\\nimport java.util.ArrayList;\\nimport java.util.Collections;\\nimport java.lang.Math;\\npublic class AndItsNon_Zero\\n{\\n\\tpublic static void main(String args[]) throws IOException\\n\\t{\\n\\t\\tBufferedReader br = new BufferedReader(new InputStreamReader(System.in));\\n\\t\\tPrintWriter out = new PrintWriter(System.out);\\n\\t\\tint t = Integer.parseInt(br.readLine());\\n\\t\\twhile(t-->0)\\n\\t\\t{\\n\\t\\t\\tString input[] = br.readLine().split(\\\" \\\");\\n\\t\\t\\tint in = Integer.parseInt(input[0]);\\n\\t\\t\\tint r = Integer.parseInt(input[1]);\\n\\t\\t\\tif(in ==r){out.println(0);continue;}\\n\\t\\t\\tString inb = Integer.toBinaryString(in);\\n\\t\\t\\tString rb = Integer.toBinaryString(r);\\n\\t\\t\\tint lin = inb.length();\\n\\t\\t\\tint lr = rb.length();\\n\\t\\t\\tint result[] = new int[lr];\\n\\t\\t\\tint diff = r - in + 1;\\n\\t\\t\\tint temp = 0, temp2 = 0;\\n\\t\\t\\tfor(int i = 0; i<lin; i++)\\n\\t\\t\\t{\\n\\t\\t\\t\\tint j = lin-i-1;\\n\\t\\t\\t\\tint rem = (in - (int)Math.pow(2,j))% ((int)Math.pow(2,j+1));\\n\\t\\t\\t\\tif(Math.pow(2,j)>rem)\\n\\t\\t\\t\\t{\\n\\t\\t\\t\\t\\t\\/\\/if(Math.pow(2,j+1)>r)\\n\\t\\t\\t\\t\\t\\t\\/\\/result[j] = diff;\\n\\t\\t\\t\\t\\tif(Math.pow(2,j)+in-rem>r)\\n\\t\\t\\t\\t\\t\\tresult[j] = diff;\\n\\t\\t\\t\\t\\telse\\n\\t\\t\\t\\t\\t{\\n\\t\\t\\t\\t\\t\\ttemp = (diff - ((int) Math.pow(2,j) -rem))\\/((int)Math.pow(2,j+1));\\n\\t\\t\\t\\t\\t\\ttemp = temp*(int)Math.pow(2,j);\\n\\t\\t\\t\\t\\t\\ttemp2 = (diff - ((int) Math.pow(2,j) -rem))%((int)Math.pow(2,j+1));\\n\\t\\t\\t\\t\\t\\tif(temp2>Math.pow(2,j))\\n\\t\\t\\t\\t\\t\\t\\ttemp = temp + temp2-(int)Math.pow(2,j);\\n\\t\\t\\t\\t\\t\\tresult[j] = temp+(int)Math.pow(2,j) - rem;\\n\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\t}\\n\\t\\t\\t\\telse\\n\\t\\t\\t\\t{\\n\\t\\t\\t\\t\\tif(rem == (int) Math.pow(2,j))\\n\\t\\t\\t\\t\\t{\\n\\t\\t\\t\\t\\t\\ttemp = (diff)\\/((int)Math.pow(2,j+1));\\n\\t\\t\\t\\t\\t\\ttemp = temp*(int)Math.pow(2,j);\\n\\t\\t\\t\\t\\t\\ttemp2 = (diff)%((int)Math.pow(2,j+1));\\n\\t\\t\\t\\t\\t\\tif(temp2>Math.pow(2,j))\\n\\t\\t\\t\\t\\t\\t\\ttemp = temp + temp2 - (int)Math.pow(2,j);\\n\\t\\t\\t\\t\\t\\tresult[j] = temp;\\n\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\t\\telse\\n\\t\\t\\t\\t\\t{\\n\\t\\t\\t\\t\\t\\t\\/\\/if(Math.pow(2,j+1)+Math.pow(2,j)>r)\\n\\t\\t\\t\\t\\t\\t\\t\\/\\/result[j] = 0;\\n\\t\\t\\t\\t\\t\\tif(in+Math.pow(2,j+1)-rem>r)\\n\\t\\t\\t\\t\\t\\t\\tresult[j] = 0;\\n\\t\\t\\t\\t\\t\\telse\\n\\t\\t\\t\\t\\t\\t{\\n\\t\\t\\t\\t\\t\\t\\ttemp = (diff - ((int)Math.pow(2,j+1)-rem))\\/((int)Math.pow(2,j+1));\\n\\t\\t\\t\\t\\t\\t\\ttemp =...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"2^k teams participate in a playoff tournament. The tournament consists of 2^k - 1 games. They are held as follows: first of all, the teams are split into pairs: team 1 plays against team 2, team 3 plays against team 4 (exactly in this order), and so on (so, 2^{k-1} games are played in that phase). When a team loses a game, it is eliminated, and each game results in elimination of one team (there are no ties). After that, only 2^{k-1} teams remain. If only one team remains, it is declared the champion; otherwise, 2^{k-2} games are played: in the first one of them, the winner of the game \\\"1 vs 2\\\" plays against the winner of the game \\\"3 vs 4\\\", then the winner of the game \\\"5 vs 6\\\" plays against the winner of the game \\\"7 vs 8\\\", and so on. This process repeats until only one team remains.\\n\\nAfter the tournament ends, the teams are assigned places according to the tournament phase when they were eliminated. In particular:\\n\\n  * the winner of the tournament gets place 1; \\n  * the team eliminated in the finals gets place 2; \\n  * both teams eliminated in the semifinals get place 3; \\n  * all teams eliminated in the quarterfinals get place 5; \\n  * all teams eliminated in the 1\\/8 finals get place 9, and so on. \\n\\n\\n\\nFor example, this picture describes one of the possible ways the tournament can go with k = 3, and the resulting places of the teams:\\n\\n<image>\\n\\nAfter a tournament which was conducted by the aforementioned rules ended, its results were encoded in the following way. Let p_i be the place of the i-th team in the tournament. The hash value of the tournament h is calculated as h = (\u2211 _{i=1}^{2^k} i \u22c5 A^{p_i}) mod 998244353, where A is some given integer.\\n\\nUnfortunately, due to a system crash, almost all tournament-related data was lost. The only pieces of data that remain are the values of k, A and h. You are asked to restore the resulting placing of the teams in the tournament, if it is possible at all.\\n\\nInput\\n\\nThe only line contains three integers k, A and h (1 \u2264 k \u2264 5; 100 \u2264 A \u2264 10^8; 0 \u2264 h \u2264 998244352).\\n\\nOutput\\n\\nIf...\\nSolve the task in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst int mod = 998244353;\\nint k, A, h, m;\\nint a[1000] = {}, b[161616] = {}, cnt, f[10100], d[151515] = {},\\n    ans[111111] = {};\\nunordered_map<int, int> mp;\\nint fpw(int x, int k, int p) {\\n  int ret = 1;\\n  while (k) {\\n    if (k & 1) ret = 1ll * ret * x % p;\\n    x = 1ll * x * x % p;\\n    k >>= 1;\\n  }\\n  return ret;\\n}\\nint add(int x, int y) { return (x += y) >= mod ? x - mod : x; }\\nint Sum[1000100];\\nint solve(vector<int> &c, int len) {\\n  int sum = 0;\\n  for (int i = 1; i <= 2 * len; i++) {\\n    if (i & 1)\\n      sum = add(sum, 1ll * i * f[c[(i + 1) \\/ 2]] % mod);\\n    else\\n      sum = add(sum, 1ll * i * f[a[k]] % mod);\\n  }\\n  if (!mp[add(sum, mod - h)]) return 0;\\n  int st = mp[add(sum, mod - h)] - 1;\\n  for (int i = 0; i < cnt; i++) {\\n    if (st >> i & 1) {\\n      Sum[d[i]]++;\\n    }\\n  }\\n  for (int i = 1; i <= len; i++) ans[i * 2 - 1] = c[i], ans[i * 2] = a[k];\\n  for (int i = 1; i <= len; i++) {\\n    if (Sum[c[i]]) {\\n      swap(ans[i * 2 - 1], ans[i * 2]);\\n      Sum[c[i]]--;\\n    }\\n  }\\n  return 1;\\n}\\nint check(vector<int> &c) {\\n  for (int i = k - 1; i >= 0; i--) {\\n    int p = (1 << (k - i));\\n    if (i == 0) p = (1 << (k - 1));\\n    if (c.size() - 1 < p) return 1;\\n    for (int l = 1, r = p; r < c.size(); l = r + 1, r += p) {\\n      int cnt = 0;\\n      for (int j = l; j <= r; j++) {\\n        if (c[j] == a[i]) {\\n          cnt++;\\n        }\\n      }\\n      if (cnt != 1) return 0;\\n    }\\n  }\\n  return 1;\\n}\\nvoid dfs(vector<int> &siz, vector<int> &c, int pos) {\\n  if (!check(c)) return;\\n  if (pos == m + 1) {\\n    if (solve(c, m)) {\\n      for (int i = 1; i <= 2 * m; i++) {\\n        printf(\\\"%d \\\", ans[i]);\\n      }\\n      exit(0);\\n    } else\\n      return;\\n  }\\n  for (int i = 0; i <= k - 1; i++) {\\n    if (siz[i]) {\\n      siz[i]--;\\n      c.push_back(a[i]);\\n      dfs(siz, c, pos + 1);\\n      c.pop_back();\\n      siz[i]++;\\n    }\\n  }\\n}\\nvector<int> siz;\\nint main() {\\n  mp.rehash((1 << 16) + 5);\\n  cin >> k >> A >> h;\\n  siz.resize(k + 1);\\n  m = (1 << (k - 1));\\n  if (k == 0) {\\n    if (h == A) {\\n      puts(\\\"1\\\");\\n    }...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Alice likes word \\\"nineteen\\\" very much. She has a string s and wants the string to contain as many such words as possible. For that reason she can rearrange the letters of the string.\\n\\nFor example, if she has string \\\"xiineteenppnnnewtnee\\\", she can get string \\\"xnineteenppnineteenw\\\", containing (the occurrences marked) two such words. More formally, word \\\"nineteen\\\" occurs in the string the number of times you can read it starting from some letter of the string. Of course, you shouldn't skip letters.\\n\\nHelp her to find the maximum number of \\\"nineteen\\\"s that she can get in her string.\\n\\nInput\\n\\nThe first line contains a non-empty string s, consisting only of lowercase English letters. The length of string s doesn't exceed 100.\\n\\nOutput\\n\\nPrint a single integer \u2014 the maximum number of \\\"nineteen\\\"s that she can get in her string.\\n\\nExamples\\n\\nInput\\n\\nnniinneetteeeenn\\n\\n\\nOutput\\n\\n2\\n\\nInput\\n\\nnneteenabcnneteenabcnneteenabcnneteenabcnneteenabcii\\n\\n\\nOutput\\n\\n2\\n\\nInput\\n\\nnineteenineteen\\n\\n\\nOutput\\n\\n2\\nThe above is tricky. Write me a correct solution in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint cnt[333];\\nstring s;\\nint main() {\\n  cin >> s;\\n  for (auto c : s) ++cnt[c];\\n  cout << min({(cnt['n'] - 1) \\/ 2, cnt['i'], cnt['e'] \\/ 3, cnt['t']});\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Alice and Bob play the following game. Alice has a set S of disjoint ranges of integers, initially containing only one range [1, n]. In one turn, Alice picks a range [l, r] from the set S and asks Bob to pick a number in the range. Bob chooses a number d (l \u2264 d \u2264 r). Then Alice removes [l, r] from S and puts into the set S the range [l, d - 1] (if l \u2264 d - 1) and the range [d + 1, r] (if d + 1 \u2264 r). The game ends when the set S is empty. We can show that the number of turns in each game is exactly n.\\n\\nAfter playing the game, Alice remembers all the ranges [l, r] she picked from the set S, but Bob does not remember any of the numbers that he picked. But Bob is smart, and he knows he can find out his numbers d from Alice's ranges, and so he asks you for help with your programming skill.\\n\\nGiven the list of ranges that Alice has picked ([l, r]), for each range, help Bob find the number d that Bob has picked.\\n\\nWe can show that there is always a unique way for Bob to choose his number for a list of valid ranges picked by Alice.\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 1000). Description of the test cases follows.\\n\\nThe first line of each test case contains a single integer n (1 \u2264 n \u2264 1000).\\n\\nEach of the next n lines contains two integers l and r (1 \u2264 l \u2264 r \u2264 n), denoting the range [l, r] that Alice picked at some point.\\n\\nNote that the ranges are given in no particular order.\\n\\nIt is guaranteed that the sum of n over all test cases does not exceed 1000, and the ranges for each test case are from a valid game.\\n\\nOutput\\n\\nFor each test case print n lines. Each line should contain three integers l, r, and d, denoting that for Alice's range [l, r] Bob picked the number d.\\n\\nYou can print the lines in any order. We can show that the answer is unique.\\n\\nIt is not required to print a new line after each test case. The new lines in the output of the example are for readability only. \\n\\nExample\\n\\nInput\\n\\n\\n4\\n1\\n1 1\\n3\\n1 3\\n2 3\\n2 2\\n6\\n1 1\\n3 5\\n4 4\\n3 6\\n4 5\\n1 6\\n5\\n1 5\\n1 2\\n4 5\\n2...\\nSolve the task in JAVA.\",\"targets\":\"import java.io.BufferedReader;\\nimport java.io.IOException;\\nimport java.io.InputStreamReader;\\nimport java.io.PrintWriter;\\nimport java.text.DecimalFormat;\\nimport java.util.*;\\n\\n\\/\\/import sun.nio.fs.RegistryFileTypeDetector;\\n\\n\\n \\npublic class B {\\n\\tstatic int mod= 1000000007;\\n\\tstatic class Node{\\n\\t\\tint l,r;\\n\\t\\tint len;\\n\\t\\tNode(int l,int r){\\n\\t\\t\\tthis.l=l;\\n\\t\\t\\tthis.r=r;\\n\\t\\t\\tthis.len= r-l+1;\\n\\t\\t}\\n\\t}\\n\\tpublic static void main(String[] args) throws Exception {\\n\\t\\tPrintWriter out=new PrintWriter(System.out);\\n\\t\\tFastScanner fs=new FastScanner();\\n\\t\\tint t=fs.nextInt();\\n\\t\\t\\n\\t\\touter:while(t-->0) {\\n\\t\\t\\tint n=fs.nextInt();\\n\\t\\t\\tTreeSet<Integer> set=new TreeSet<>();\\n\\t\\t\\tfor(int i=1;i<=n;i++) set.add(i);\\n\\t\\t\\tNode arr[]=new Node[n];\\n\\t\\t\\tfor(int i=0;i<n;i++) {\\n\\t\\t\\t\\tint l=fs.nextInt(), r=fs.nextInt();\\n\\t\\t\\t\\tarr[i]=new Node(l,r);\\n\\t\\t\\t}\\n\\t\\t\\t\\n\\t\\t\\tArrays.sort(arr,new Comparator<Node>() {\\n\\t\\t\\t\\tpublic int compare(Node a,Node b) {\\n\\t\\t\\t\\t\\tif(a.len==b.len) {\\n\\t\\t\\t\\t\\t\\treturn a.l-b.l;\\n\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\t\\treturn a.len-b.len;\\n\\t\\t\\t\\t}\\n\\t\\t\\t});\\n\\t\\t\\tfor(int i=0;i<n;i++) {\\n\\t\\t\\t\\tint l=arr[i].l, r=arr[i].r;\\n\\t\\t\\t\\tint cur=set.ceiling(l);\\n\\t\\t\\t\\tset.remove(cur);\\n\\t\\t\\t\\tout.println(l+\\\" \\\"+r+\\\" \\\"+cur);\\n\\t\\t\\t}\\n\\t\\t\\tout.println();\\n\\t\\t}\\n\\t\\t\\n\\t\\tout.close();\\n\\t\\t\\n\\t}\\n\\t\\n\\tstatic long pow(long a,long b) {\\n\\t\\tif(b<0) return 1;\\n\\t\\tlong res=1;\\n\\t\\twhile(b!=0) {\\n\\t\\t\\tif((b&1)!=0) {\\n\\t\\t\\t\\tres*=a;\\n\\t\\t\\t\\tres%=mod;\\n\\t\\t\\t}\\n\\t\\t\\ta*=a;\\n\\t\\t\\ta%=mod;\\n\\t\\t\\tb=b>>1;\\n\\t\\t}\\n\\t\\treturn res;\\n\\t}\\n\\tstatic int gcd(int  a,int  b) {\\n\\t\\tif(b==0) return a;\\n\\t\\treturn gcd(b,a%b);\\n\\t}\\n\\tstatic long nck(int n,int k) {\\n\\t\\tif(k>n) return 0;\\n\\t\\tlong res=1;\\n\\t\\tres*=fact(n);\\n\\t\\tres%=mod;\\n\\t\\tres*=modInv(fact(k));\\n\\t\\tres%=mod;\\n\\t\\tres*=modInv(fact(n-k)); \\n\\t\\tres%=mod;\\n\\t\\treturn res;\\n\\t}\\n\\tstatic long fact(long n) {\\n\\/\\/\\t\\treturn fact[(int)n];\\n\\t\\tlong res=1;\\n\\t\\tfor(int i=2;i<=n;i++) {\\n\\t\\t\\tres*=i;\\n\\t\\t\\tres%=mod;\\n\\t\\t}\\n\\t\\treturn res;\\n\\t}\\n\\t\\n\\tstatic long modInv(long n) {\\n\\t\\treturn pow(n,mod-2);\\n\\t}\\n\\t\\n\\tstatic void sort(int[] a) {\\n\\t\\t\\/\\/suffle\\n\\t\\tint n=a.length;\\n\\t\\tRandom r=new Random();\\n\\t\\tfor (int i=0; i<a.length; i++) {\\n\\t\\t\\tint oi=r.nextInt(n);\\n\\t\\t\\tint temp=a[i];\\n\\t\\t\\ta[i]=a[oi];\\n\\t\\t\\ta[oi]=temp;\\n\\t\\t}\\n\\t\\t\\n\\t\\t\\/\\/then...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You are given two positive integers n and s. Find the maximum possible median of an array of n non-negative integers (not necessarily distinct), such that the sum of its elements is equal to s.\\n\\nA median of an array of integers of length m is the number standing on the \u2308 {m\\/2} \u2309-th (rounding up) position in the non-decreasing ordering of its elements. Positions are numbered starting from 1. For example, a median of the array [20,40,20,50,50,30] is the \u2308 m\\/2 \u2309-th element of [20,20,30,40,50,50], so it is 30. There exist other definitions of the median, but in this problem we use the described definition.\\n\\nInput\\n\\nThe input consists of multiple test cases. The first line contains a single integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases. Description of the test cases follows.\\n\\nEach test case contains a single line with two integers n and s (1 \u2264 n, s \u2264 10^9) \u2014 the length of the array and the required sum of the elements.\\n\\nOutput\\n\\nFor each test case print a single integer \u2014 the maximum possible median.\\n\\nExample\\n\\nInput\\n\\n\\n8\\n1 5\\n2 5\\n3 5\\n2 1\\n7 17\\n4 14\\n1 1000000000\\n1000000000 1\\n\\n\\nOutput\\n\\n\\n5\\n2\\n2\\n0\\n4\\n4\\n1000000000\\n0\\n\\nNote\\n\\nPossible arrays for the first three test cases (in each array the median is underlined):\\n\\n  * In the first test case [\\\\underline{5}] \\n  * In the second test case [\\\\underline{2}, 3] \\n  * In the third test case [1, \\\\underline{2}, 2] \\nSolve the task in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nlong long add(long long x, long long y) {\\n  long long res = x + y;\\n  return (res >= 1000000007 ? res - 1000000007 : res);\\n}\\nlong long mul(long long x, long long y) {\\n  long long res = x * y;\\n  return (res >= 1000000007 ? res % 1000000007 : res);\\n}\\nlong long sub(long long x, long long y) {\\n  long long res = x - y;\\n  return (res < 0 ? res + 1000000007 : res);\\n}\\nlong long power(long long x, long long y) {\\n  long long res = 1;\\n  x %= 1000000007;\\n  while (y) {\\n    if (y & 1) res = mul(res, x);\\n    y >>= 1;\\n    x = mul(x, x);\\n  }\\n  return res;\\n}\\nlong long mod_inv(long long x) { return power(x, 1000000007 - 2); }\\nlong long floorSqrt(long long x) {\\n  if (x == 0 || x == 1) return x;\\n  unsigned long long start = 1, end = x, ans;\\n  while (start <= end) {\\n    unsigned long long mid = start + (end - start) \\/ 2;\\n    if (mid * mid == x) return mid;\\n    if (mid * mid < x) {\\n      start = mid + 1;\\n      ans = mid;\\n    } else\\n      end = mid - 1;\\n  }\\n  return ans;\\n}\\nstring tobinary(long long n, long long length) {\\n  string s;\\n  for (long long i = 0; i < length; i++) {\\n    if (n & 1)\\n      s.push_back('1');\\n    else\\n      s.push_back('0');\\n    n = n >> 1;\\n  }\\n  reverse(s.begin(), s.end());\\n  return s;\\n}\\nvoid solve() {\\n  int n, s;\\n  cin >> n >> s;\\n  cout << (s) \\/ (n \\/ 2 + 1) << endl;\\n  return;\\n}\\nint main() {\\n  ios::sync_with_stdio(0);\\n  cin.tie(0);\\n  int t, i = 1;\\n  ;\\n  cin >> t;\\n  while (t--) {\\n    solve();\\n    ++i;\\n  }\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in CPP?\\nPolycarp watched TV-show where k jury members one by one rated a participant by adding him a certain number of points (may be negative, i. e. points were subtracted). Initially the participant had some score, and each the marks were one by one added to his score. It is known that the i-th jury member gave ai points.\\n\\nPolycarp does not remember how many points the participant had before this k marks were given, but he remembers that among the scores announced after each of the k judges rated the participant there were n (n \u2264 k) values b1, b2, ..., bn (it is guaranteed that all values bj are distinct). It is possible that Polycarp remembers not all of the scores announced, i. e. n < k. Note that the initial score wasn't announced.\\n\\nYour task is to determine the number of options for the score the participant could have before the judges rated the participant.\\n\\nInput\\n\\nThe first line contains two integers k and n (1 \u2264 n \u2264 k \u2264 2 000) \u2014 the number of jury members and the number of scores Polycarp remembers.\\n\\nThe second line contains k integers a1, a2, ..., ak ( - 2 000 \u2264 ai \u2264 2 000) \u2014 jury's marks in chronological order.\\n\\nThe third line contains n distinct integers b1, b2, ..., bn ( - 4 000 000 \u2264 bj \u2264 4 000 000) \u2014 the values of points Polycarp remembers. Note that these values are not necessarily given in chronological order.\\n\\nOutput\\n\\nPrint the number of options for the score the participant could have before the judges rated the participant. If Polycarp messes something up and there is no options, print \\\"0\\\" (without quotes).\\n\\nExamples\\n\\nInput\\n\\n4 1\\n-5 5 0 20\\n10\\n\\n\\nOutput\\n\\n3\\n\\n\\nInput\\n\\n2 2\\n-2000 -2000\\n3998000 4000000\\n\\n\\nOutput\\n\\n1\\n\\nNote\\n\\nThe answer for the first example is 3 because initially the participant could have  - 10, 10 or 15 points.\\n\\nIn the second example there is only one correct initial score equaling to 4 002 000.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nusing ll = long long;\\nusing db = double;\\nusing ld = long double;\\nusing uint = unsigned int;\\nusing ull = unsigned long long;\\nusing pii = pair<int, int>;\\nusing pll = pair<ll, ll>;\\nusing tiii = tuple<int, int, int>;\\nusing tlll = tuple<ll, ll, ll>;\\nbitset<8000002> e, u;\\nbool exists(int i) { return e[i + 4000000]; }\\nbool used(int i) { return u[i + 4000000]; }\\nvoid setexist(int i) { e[i + 4000000] = true; }\\nvoid setused(int i) { u[i + 4000000] = true; }\\nvoid resetused() { u.reset(); }\\nint main() {\\n  cin.tie(nullptr);\\n  cout.tie(nullptr);\\n  ios_base::sync_with_stdio(false);\\n  int n, k;\\n  cin >> k >> n;\\n  vector<int> a(k), s(k), b(n);\\n  for (int i = 0; i < k; i++) {\\n    cin >> a[i];\\n    if (i == 0) {\\n      s[i] = a[i];\\n    } else {\\n      s[i] = s[i - 1] + a[i];\\n    }\\n  }\\n  for (int i = 0; i < n; i++) {\\n    cin >> b[i];\\n    setexist(b[i]);\\n  }\\n  unordered_set<int> set;\\n  for (int i = 0; i < k; i++) {\\n    int init = b[0] - s[i];\\n    int c = init;\\n    int s = 0;\\n    for (int j = 0; j < k; j++) {\\n      c += a[j];\\n      if (exists(c) && !used(c)) {\\n        s++;\\n        setused(c);\\n      }\\n    }\\n    if (s == n) {\\n      set.emplace(init);\\n    }\\n    resetused();\\n  }\\n  cout << set.size();\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"A rectangle with its opposite corners in (0, 0) and (w, h) and sides parallel to the axes is drawn on a plane.\\n\\nYou are given a list of lattice points such that each point lies on a side of a rectangle but not in its corner. Also, there are at least two points on every side of a rectangle.\\n\\nYour task is to choose three points in such a way that: \\n\\n  * exactly two of them belong to the same side of a rectangle; \\n  * the area of a triangle formed by them is maximum possible. \\n\\n\\n\\nPrint the doubled area of this triangle. It can be shown that the doubled area of any triangle formed by lattice points is always an integer.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 10^4) \u2014 the number of testcases.\\n\\nThe first line of each testcase contains two integers w and h (3 \u2264 w, h \u2264 10^6) \u2014 the coordinates of the corner of a rectangle.\\n\\nThe next two lines contain the description of the points on two horizontal sides. First, an integer k (2 \u2264 k \u2264 2 \u22c5 10^5) \u2014 the number of points. Then, k integers x_1 < x_2 < ... < x_k (0 < x_i < w) \u2014 the x coordinates of the points in the ascending order. The y coordinate for the first line is 0 and for the second line is h.\\n\\nThe next two lines contain the description of the points on two vertical sides. First, an integer k (2 \u2264 k \u2264 2 \u22c5 10^5) \u2014 the number of points. Then, k integers y_1 < y_2 < ... < y_k (0 < y_i < h) \u2014 the y coordinates of the points in the ascending order. The x coordinate for the first line is 0 and for the second line is w.\\n\\nThe total number of points on all sides in all testcases doesn't exceed 2 \u22c5 10^5.\\n\\nOutput\\n\\nFor each testcase print a single integer \u2014 the doubled maximum area of a triangle formed by such three points that exactly two of them belong to the same side.\\n\\nExample\\n\\nInput\\n\\n\\n3\\n5 8\\n2 1 2\\n3 2 3 4\\n3 1 4 6\\n2 4 5\\n10 7\\n2 3 9\\n2 1 7\\n3 1 3 4\\n3 4 5 6\\n11 5\\n3 1 6 8\\n3 3 6 8\\n3 1 3 4\\n2 2 4\\n\\n\\nOutput\\n\\n\\n25\\n42\\n35\\n\\nNote\\n\\nThe points in the first testcase of the example: \\n\\n  * (1, 0), (2, 0); \\n  * (2, 8), (3, 8), (4, 8); \\n  * (0, 1), (0, 4), (0, 6); \\n  * (5, 4), (5,...\\nimpor\",\"targets\":\"t java.util.*;\\nimport java.io.*;\\n\\npublic class A {\\n    public static void main(String[] args) throws IOException {\\n        Scanner sc = new Scanner(System.in);\\n        PrintWriter pw = new PrintWriter(System.out);\\n        int t = sc.nextInt();\\n        while (t-- > 0) {\\n            long w = sc.nextInt();\\n            long h = sc.nextInt();\\n            long ans = 0;\\n            for (int j = 0; j < 2; j++) {\\n                int k = sc.nextInt();\\n                Long[] in = new Long[k];\\n                for (int i = 0; i < k; i++) {\\n                    in[i] = sc.nextLong();\\n                }\\n                Arrays.sort(in);\\n                ans = Math.max((in[k - 1] - in[0]) * h, ans);\\n            }\\n            for (int j = 0; j < 2; j++) {\\n                int k = sc.nextInt();\\n                Long[] in = new Long[k];\\n                for (int i = 0; i < k; i++) {\\n                    in[i] = sc.nextLong();\\n                }\\n                Arrays.sort(in);\\n                ans = Math.max((in[k - 1] - in[0]) * w, ans);\\n            }\\n            pw.println(ans);\\n        }\\n        pw.close();\\n    }\\n\\n    static class Scanner {\\n        BufferedReader br;\\n        StringTokenizer st;\\n\\n        public Scanner(InputStream s) {\\n            br = new BufferedReader(new InputStreamReader(s));\\n        }\\n\\n        public Scanner(FileReader f) {\\n            br = new BufferedReader(f);\\n        }\\n\\n        public String next() throws IOException {\\n            while (st == null || !st.hasMoreTokens())\\n                st = new StringTokenizer(br.readLine());\\n            return st.nextToken();\\n        }\\n\\n        public int nextInt() throws IOException {\\n            return Integer.parseInt(next());\\n        }\\n\\n        public long nextLong() throws IOException {\\n            return Long.parseLong(next());\\n        }\\n\\n        public double nextDouble() throws IOException {\\n            return Double.parseDouble(next());\\n        }\\n\\n        public int[] nextIntArr(int n) throws IOException {\\n            int[] arr = new int[n];\\n            for (int i...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in JAVA?\\nA robot cleaner is placed on the floor of a rectangle room, surrounded by walls. The floor consists of n rows and m columns. The rows of the floor are numbered from 1 to n from top to bottom, and columns of the floor are numbered from 1 to m from left to right. The cell on the intersection of the r-th row and the c-th column is denoted as (r,c). The initial position of the robot is (r_b, c_b).\\n\\nIn one second, the robot moves by dr rows and dc columns, that is, after one second, the robot moves from the cell (r, c) to (r + dr, c + dc). Initially dr = 1, dc = 1. If there is a vertical wall (the left or the right walls) in the movement direction, dc is reflected before the movement, so the new value of dc is -dc. And if there is a horizontal wall (the upper or lower walls), dr is reflected before the movement, so the new value of dr is -dr.\\n\\nEach second (including the moment before the robot starts moving), the robot cleans every cell lying in the same row or the same column as its position. There is only one dirty cell at (r_d, c_d). The job of the robot is to clean that dirty cell.\\n\\n<image> Illustration for the first example. The blue arc is the robot. The red star is the target dirty cell. Each second the robot cleans a row and a column, denoted by yellow stripes.\\n\\nGiven the floor size n and m, the robot's initial position (r_b, c_b) and the dirty cell's position (r_d, c_d), find the time for the robot to do its job.\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 10^4). Description of the test cases follows.\\n\\nA test case consists of only one line, containing six integers n, m, r_b, c_b, r_d, and c_d (1 \u2264 n, m \u2264 100, 1 \u2264 r_b, r_d \u2264 n, 1 \u2264 c_b, c_d \u2264 m) \u2014 the sizes of the room, the initial position of the robot and the position of the dirt cell.\\n\\nOutput\\n\\nFor each test case, print an integer \u2014 the time for the robot to clean the dirty cell. We can show that the robot always cleans the dirty cell eventually.\\n\\nExample\\n\\nInput\\n\\n\\n5\\n10 10 6 1 2 8\\n10 10 9 9 1...\",\"targets\":\"import java.util.Scanner;\\n\\npublic class RobotCleaner {\\n\\n\\tpublic static void main(String[] args) {\\n\\t\\tScanner in = new Scanner(System.in);\\n\\n\\t\\tint t = in.nextInt();\\n\\t\\twhile (t-- > 0) {\\n\\t\\t\\tint n = in.nextInt();\\n\\t\\t\\tint m = in.nextInt();\\n\\t\\t\\tint ri = in.nextInt();\\n\\t\\t\\tint rj = in.nextInt();\\n\\t\\t\\tint di = in.nextInt();\\n\\t\\t\\tint dj = in.nextInt();\\n\\t\\t\\tint time = 0;\\n\\t\\t\\tint rInc = 1;\\n\\t\\t\\tint cInc = 1;\\n\\t\\t\\twhile (di != ri && dj != rj) {\\n\\t\\t\\t\\tif (ri + rInc > n)\\n\\t\\t\\t\\t\\trInc = -1;\\n\\t\\t\\t\\telse if (ri - rInc < 1)\\n\\t\\t\\t\\t\\trInc = 1;\\n\\n\\t\\t\\t\\tif (rj + cInc > m)\\n\\t\\t\\t\\t\\tcInc = -1;\\n\\t\\t\\t\\telse if (rj - cInc < 1)\\n\\t\\t\\t\\t\\tcInc = 1;\\n\\n\\t\\t\\t\\tri += rInc;\\n\\t\\t\\t\\trj += cInc;\\n\\t\\t\\t\\ttime++;\\n\\t\\t\\t}\\n\\n\\t\\t\\tSystem.out.println(time);\\n\\t\\t}\\n\\t}\\n\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"<image>\\n\\nMatryoshka is a wooden doll in the shape of a female figure and is a typical Russian folk craft. Matryoshka has a nested structure in which smaller dolls are contained inside a large doll, and is composed of multiple dolls of different sizes. In order to have such a nested structure, the body of each doll has a tubular structure that can be divided into upper and lower parts. Matryoshka dolls are handmade by craftsmen, so each doll is unique and extremely valuable in the world.\\n\\nBrothers Ichiro and Jiro loved to play with matryoshka dolls, and each had a pair of matryoshka dolls. Ichiro's matryoshka is made up of n dolls, and Jiro's matryoshka is made up of m dolls.\\n\\nOne day, curious Ichiro wondered if he could combine the dolls contained in these two pairs of matryoshka dolls to create a new matryoshka doll containing more dolls. In other words, I tried to make a pair of matryoshka dolls consisting of k dolls using n + m dolls. If k can be made larger than the larger of n and m, Ichiro's purpose will be achieved.\\n\\nThe two brothers got along well and wondered how to combine the dolls to maximize the value of k. But for the two younger ones, the problem is so difficult that you, older, decided to program to help your brothers.\\n\\nCreate a program that inputs the information of the matryoshka dolls of Ichiro and Jiro and outputs the number k of the dolls that the new matryoshka contains. No doll of the same size exists. Also, if we consider a doll to be a cylinder with a height h and a radius r, a doll with a height h and a radius r can contain a doll with a height x radius y that satisfies x <h and y <r.\\n\\n\\n\\nInput\\n\\nA sequence of multiple datasets is given as input. The end of the input is indicated by a single line of zeros. Each dataset is given in the following format:\\n\\n\\nn\\nh1 r1\\nh2 r2\\n::\\nhn rn\\nm\\nh1 r1\\nh2 r2\\n::\\nhm rm\\n\\n\\nThe first line gives the number of matryoshka dolls of Ichiro n (n \u2264 100), and the following n lines give the height hi and radius ri (hi, ri <1000) of the ith doll of Ichiro. ..\\n\\nThe...\\\":\",\"targets\":\"#include <iostream>\\n#include <algorithm>\\n#include <vector>\\nusing namespace std;\\n\\ntypedef pair<int,int> P;\\nconst int MAX = 201;\\n\\nint main(){\\n  int n;\\n\\n  while(cin >> n ,n){\\n    vector<P> v;\\n\\n    int x,y;\\n    for(int i = 0 ; i < n ; i++){\\n      cin >> x >> y;\\n      v.push_back(P(x,y));\\n    }\\n    int m;\\n    cin >> m;\\n    for(int i = 0 ; i < m ; i++){\\n      cin >> x >> y;\\n      v.push_back(P(x,y));\\n    }\\n\\n    sort(v.begin(),v.end());\\n    int dp[MAX] = {0};\\n    int ans = 0;\\n\\n    for(int i = 0 ; i < n+m ; i++){\\n      dp[i] = 1;\\n      for(int j = 0 ; j < i ; j++){\\n\\tif(v[j].first < v[i].first && v[j].second < v[i].second){\\n\\t  dp[i] = max(dp[i],dp[j]+1);\\n\\t}\\n      }\\n      ans = max(ans,dp[i]);\\n    }\\n\\n    cout << ans << endl;\\n  }\\n\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Petya has got an interesting flower. Petya is a busy person, so he sometimes forgets to water it. You are given n days from Petya's live and you have to determine what happened with his flower in the end.\\n\\nThe flower grows as follows: \\n\\n  * If the flower isn't watered for two days in a row, it dies. \\n  * If the flower is watered in the i-th day, it grows by 1 centimeter. \\n  * If the flower is watered in the i-th and in the (i-1)-th day (i > 1), then it grows by 5 centimeters instead of 1. \\n  * If the flower is not watered in the i-th day, it does not grow. \\n\\n\\n\\nAt the beginning of the 1-st day the flower is 1 centimeter tall. What is its height after n days?\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 100). Description of the test cases follows.\\n\\nThe first line of each test case contains the only integer n (1 \u2264 n \u2264 100).\\n\\nThe second line of each test case contains n integers a_1, a_2, ..., a_n (a_i = 0 or a_i = 1). If a_i = 1, the flower is watered in the i-th day, otherwise it is not watered.\\n\\nOutput\\n\\nFor each test case print a single integer k \u2014 the flower's height after n days, or -1, if the flower dies.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n3\\n1 0 1\\n3\\n0 1 1\\n4\\n1 0 0 1\\n1\\n0\\n\\n\\nOutput\\n\\n\\n3\\n7\\n-1\\n1\\nUsing java can you solve the prior task?\",\"targets\":\"import java.io.BufferedReader;\\nimport java.io.IOException;\\nimport java.io.InputStreamReader;\\nimport java.util.ArrayList;\\nimport java.util.Collections;\\nimport java.util.StringTokenizer;\\n\\n\\npublic class Test{\\n\\n\\tstatic int flower(int n,int[] arr) {\\n\\t\\tint k = 0;\\n\\t\\tif(arr[0] == 0) {\\n\\t\\t\\tk = 1;\\n\\t\\t}else {\\n\\t\\t\\tk = 2;\\n\\t\\t}\\n\\t\\tfor(int i=1;i<n;i++) {\\n\\t\\t\\tif(arr[i-1] == 1 && arr[i] == 1) {\\n\\t\\t\\t\\tk += 5;\\n\\t\\t\\t}\\n\\t\\t\\tif(arr[i-1] == 0 && arr[i] == 1) {\\n\\t\\t\\t\\tk += 1;\\n\\t\\t\\t}\\n\\t\\t\\tif(arr[i-1] == 0 && arr[i] == 0) {\\n\\t\\t\\t\\treturn -1;\\n\\t\\t\\t}\\n\\t\\t}\\n\\t\\t\\n\\t\\t\\n\\t\\treturn k;\\n\\t}\\n\\t  \\n\\t\\n\\t  public static void main(String[] args) {\\n\\t        FastScanner fs = new FastScanner();\\n\\t        int T = fs.nextInt();\\n\\t        for(int tt=0;tt<T;tt++){ \\n\\t        \\tint n = fs.nextInt();\\n\\t\\t    \\tint[] arr = new int[n];\\n\\t\\t    \\tfor(int i=0;i<n;i++) {\\n\\t\\t    \\t\\tarr[i] = fs.nextInt();\\n\\t\\t    \\t}\\n\\t\\t    \\t\\n\\t\\t    \\tint ans = flower(n,arr);\\n\\t\\t    \\tSystem.out.println(ans);\\n\\t\\t    \\t\\n\\t                      \\n\\t        }\\n\\t    }\\n\\n\\t    static void sort(int[] a){\\n\\t        ArrayList<Integer> l = new ArrayList<>();\\n\\t        for(int i:a) l.add(i);\\n\\t        Collections.sort(l);\\n\\t        for(int i=0;i<a.length;i++) a[i] = l.get(i);\\n\\t    }\\n\\n\\n\\t    static class FastScanner {\\n\\t        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));\\n\\t        StringTokenizer st=new StringTokenizer(\\\"\\\");\\n\\t        String next() {\\n\\t            while (!st.hasMoreTokens())\\n\\t                try {\\n\\t                    st=new StringTokenizer(br.readLine());\\n\\t                } catch (IOException e) {\\n\\t                    e.printStackTrace();\\n\\t                }\\n\\t            return st.nextToken();\\n\\t        }\\n\\n\\t        int nextInt() {\\n\\t            return Integer.parseInt(next());\\n\\t        }\\n\\t        int[] readArray(int n) {\\n\\t            int[] a=new int[n];\\n\\t            for (int i=0; i<n; i++) a[i]=nextInt();\\n\\t            return a;\\n\\t        }\\n\\t        long nextLong() {\\n\\t            return Long.parseLong(next());\\n\\t        }\\n\\t    }\\n\\t\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Every summer Vitya comes to visit his grandmother in the countryside. This summer, he got a huge wart. Every grandma knows that one should treat warts when the moon goes down. Thus, Vitya has to catch the moment when the moon is down.\\n\\nMoon cycle lasts 30 days. The size of the visible part of the moon (in Vitya's units) for each day is 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, and then cycle repeats, thus after the second 1 again goes 0.\\n\\nAs there is no internet in the countryside, Vitya has been watching the moon for n consecutive days and for each of these days he wrote down the size of the visible part of the moon. Help him find out whether the moon will be up or down next day, or this cannot be determined by the data he has.\\n\\nInput\\n\\nThe first line of the input contains a single integer n (1 \u2264 n \u2264 92) \u2014 the number of consecutive days Vitya was watching the size of the visible part of the moon. \\n\\nThe second line contains n integers ai (0 \u2264 ai \u2264 15) \u2014 Vitya's records.\\n\\nIt's guaranteed that the input data is consistent.\\n\\nOutput\\n\\nIf Vitya can be sure that the size of visible part of the moon on day n + 1 will be less than the size of the visible part on day n, then print \\\"DOWN\\\" at the only line of the output. If he might be sure that the size of the visible part will increase, then print \\\"UP\\\". If it's impossible to determine what exactly will happen with the moon, print -1.\\n\\nExamples\\n\\nInput\\n\\n5\\n3 4 5 6 7\\n\\n\\nOutput\\n\\nUP\\n\\n\\nInput\\n\\n7\\n12 13 14 15 14 13 12\\n\\n\\nOutput\\n\\nDOWN\\n\\n\\nInput\\n\\n1\\n8\\n\\n\\nOutput\\n\\n-1\\n\\nNote\\n\\nIn the first sample, the size of the moon on the next day will be equal to 8, thus the answer is \\\"UP\\\".\\n\\nIn the second sample, the size of the moon on the next day will be 11, thus the answer is \\\"DOWN\\\".\\n\\nIn the third sample, there is no way to determine whether the size of the moon on the next day will be 7 or 9, thus the answer is -1.\\nThe above is tricky. Write me a correct solution in PYTHON3.\",\"targets\":\"n=int(input())\\ns = list(map(int,input().split()))[:n]\\n\\n\\t\\nk=-1\\nif s[n-1]==0:\\n    print(\\\"UP\\\")\\nelif s[n-1]==15 or s[n-2]>s[n-1]:\\n\\tprint(\\\"DOWN\\\")\\nelif n==1:\\n\\tprint(k)\\nelse:\\n    print(\\\"UP\\\")\",\"language\":\"python\",\"split\":\"train\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You are given an array a of n integers, and another integer k such that 2k \u2264 n.\\n\\nYou have to perform exactly k operations with this array. In one operation, you have to choose two elements of the array (let them be a_i and a_j; they can be equal or different, but their positions in the array must not be the same), remove them from the array, and add \u230a (a_i)\\/(a_j) \u230b to your score, where \u230a x\\/y \u230b is the maximum integer not exceeding x\\/y.\\n\\nInitially, your score is 0. After you perform exactly k operations, you add all the remaining elements of the array to the score.\\n\\nCalculate the minimum possible score you can get.\\n\\nInput\\n\\nThe first line of the input contains one integer t (1 \u2264 t \u2264 500) \u2014 the number of test cases.\\n\\nEach test case consists of two lines. The first line contains two integers n and k (1 \u2264 n \u2264 100; 0 \u2264 k \u2264 \u230a n\\/2 \u230b).\\n\\nThe second line contains n integers a_1, a_2, ..., a_n (1 \u2264 a_i \u2264 2 \u22c5 10^5).\\n\\nOutput\\n\\nPrint one integer \u2014 the minimum possible score you can get.\\n\\nExample\\n\\nInput\\n\\n\\n5\\n7 3\\n1 1 1 2 1 3 1\\n5 1\\n5 5 5 5 5\\n4 2\\n1 3 3 7\\n2 0\\n4 2\\n9 2\\n1 10 10 1 10 2 7 10 3\\n\\n\\nOutput\\n\\n\\n2\\n16\\n0\\n6\\n16\\n\\nNote\\n\\nLet's consider the example test.\\n\\nIn the first test case, one way to obtain a score of 2 is the following one:\\n\\n  1. choose a_7 = 1 and a_4 = 2 for the operation; the score becomes 0 + \u230a 1\\/2 \u230b = 0, the array becomes [1, 1, 1, 1, 3]; \\n  2. choose a_1 = 1 and a_5 = 3 for the operation; the score becomes 0 + \u230a 1\\/3 \u230b = 0, the array becomes [1, 1, 1]; \\n  3. choose a_1 = 1 and a_2 = 1 for the operation; the score becomes 0 + \u230a 1\\/1 \u230b = 1, the array becomes [1]; \\n  4. add the remaining element 1 to the score, so the resulting score is 2. \\n\\n\\n\\nIn the second test case, no matter which operations you choose, the resulting score is 16.\\n\\nIn the third test case, one way to obtain a score of 0 is the following one:\\n\\n  1. choose a_1 = 1 and a_2 = 3 for the operation; the score becomes 0 + \u230a 1\\/3 \u230b = 0, the array becomes [3, 7]; \\n  2. choose a_1 = 3 and a_2 = 7 for the operation; the score becomes 0 + \u230a 3\\/7 \u230b = 0, the array becomes...\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nbool check(vector<int> A, vector<int> B, int n) {\\n  for (int i = 0; i < n; i++) {\\n    if (A[i] != B[i]) {\\n      return 0;\\n    }\\n  }\\n  return 1;\\n}\\nint main() {\\n  ios_base::sync_with_stdio(false);\\n  cin.tie(NULL);\\n  cout.tie(NULL);\\n  int t;\\n  cin >> t;\\n  while (t--) {\\n    int n, k;\\n    cin >> n >> k;\\n    vector<int> A;\\n    for (int i = 0; i < n; i++) {\\n      int a;\\n      cin >> a;\\n      A.push_back(a);\\n    }\\n    sort(A.begin(), A.end());\\n    int ans = 0;\\n    for (int i = 0; i < n - (2 * k); i++) {\\n      ans += A[i];\\n    }\\n    map<int, int> B;\\n    for (int i = n - (2 * k); i < n; i++) {\\n      B[A[i]]++;\\n    }\\n    priority_queue<pair<int, int> > C;\\n    map<int, int>::iterator it;\\n    for (it = B.begin(); it != B.end(); it++) {\\n      C.push({it->second, it->first});\\n    }\\n    int a, b, c, d;\\n    while (C.size() > 1) {\\n      a = C.top().first;\\n      b = C.top().second;\\n      C.pop();\\n      c = C.top().first;\\n      d = C.top().second;\\n      C.pop();\\n      a--;\\n      c--;\\n      if (a != 0) {\\n        C.push({a, b});\\n      }\\n      if (c != 0) {\\n        C.push({c, d});\\n      }\\n    }\\n    if (C.size() == 1) {\\n      ans += (C.top().first \\/ 2);\\n    }\\n    cout << ans << endl;\\n  }\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You are given two integers n and m. Find the \\\\operatorname{MEX} of the sequence n \u2295 0, n \u2295 1, \u2026, n \u2295 m. Here, \u2295 is the [bitwise XOR operator](https:\\/\\/en.wikipedia.org\\/wiki\\/Bitwise_operation#XOR).\\n\\n\\\\operatorname{MEX} of the sequence of non-negative integers is the smallest non-negative integer that doesn't appear in this sequence. For example, \\\\operatorname{MEX}(0, 1, 2, 4) = 3, and \\\\operatorname{MEX}(1, 2021) = 0. \\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 30 000) \u2014 the number of test cases.\\n\\nThe first and only line of each test case contains two integers n and m (0 \u2264 n, m \u2264 10^9).\\n\\nOutput\\n\\nFor each test case, print a single integer \u2014 the answer to the problem.\\n\\nExample\\n\\nInput\\n\\n\\n5\\n3 5\\n4 6\\n3 2\\n69 696\\n123456 654321\\n\\n\\nOutput\\n\\n\\n4\\n3\\n0\\n640\\n530866\\n\\nNote\\n\\nIn the first test case, the sequence is 3 \u2295 0, 3 \u2295 1, 3 \u2295 2, 3 \u2295 3, 3 \u2295 4, 3 \u2295 5, or 3, 2, 1, 0, 7, 6. The smallest non-negative integer which isn't present in the sequence i. e. the \\\\operatorname{MEX} of the sequence is 4.\\n\\nIn the second test case, the sequence is 4 \u2295 0, 4 \u2295 1, 4 \u2295 2, 4 \u2295 3, 4 \u2295 4, 4 \u2295 5, 4 \u2295 6, or 4, 5, 6, 7, 0, 1, 2. The smallest non-negative integer which isn't present in the sequence i. e. the \\\\operatorname{MEX} of the sequence is 3.\\n\\nIn the third test case, the sequence is 3 \u2295 0, 3 \u2295 1, 3 \u2295 2, or 3, 2, 1. The smallest non-negative integer which isn't present in the sequence i. e. the \\\\operatorname{MEX} of the sequence is 0.\\n#incl\",\"targets\":\"ude <bits\\/stdc++.h>\\nconst unsigned int MOD = 1000000007;\\nconst long double u = 1e+9;\\nusing namespace std;\\nint main() {\\n  int t;\\n  cin >> t;\\n  while (t--) {\\n    int n, m;\\n    cin >> n >> m;\\n    int p = m + 1;\\n    string n1 = \\\"\\\";\\n    string m1 = \\\"\\\";\\n    int z = 1;\\n    int w = 1 << 30;\\n    while (z < w) {\\n      int d = z & n;\\n      if (d == z) {\\n        n1 = \\\"1\\\" + n1;\\n      } else {\\n        n1 = \\\"0\\\" + n1;\\n      }\\n      z <<= 1;\\n    }\\n    z = 1;\\n    while (z < w) {\\n      int d = z & p;\\n      if (d == z) {\\n        m1 = \\\"1\\\" + m1;\\n      } else {\\n        m1 = \\\"0\\\" + m1;\\n      }\\n      z <<= 1;\\n    }\\n    string h = \\\"\\\";\\n    z = 0;\\n    for (int i = 0; i < n1.size(); i++) {\\n      if (z == 1) {\\n        h += \\\"0\\\";\\n        continue;\\n      }\\n      if (n1[i] == m1[i]) {\\n        h += \\\"0\\\";\\n        continue;\\n      }\\n      if (n1[i] > m1[i]) {\\n        h += \\\"0\\\";\\n        z = 1;\\n        continue;\\n      }\\n      if (n1[i] < m1[i]) {\\n        h += \\\"1\\\";\\n      }\\n    }\\n    int j = 0;\\n    reverse(h.begin(), h.end());\\n    for (int i = 0; i < h.size(); i++) {\\n      j += (h[i] - '0') * pow(2, i);\\n    }\\n    cout << j << endl;\\n  }\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in JAVA?\\nA string is called square if it is some string written twice in a row. For example, the strings \\\"aa\\\", \\\"abcabc\\\", \\\"abab\\\" and \\\"baabaa\\\" are square. But the strings \\\"aaa\\\", \\\"abaaab\\\" and \\\"abcdabc\\\" are not square.\\n\\nFor a given string s determine if it is square.\\n\\nInput\\n\\nThe first line of input data contains an integer t (1 \u2264 t \u2264 100) \u2014the number of test cases.\\n\\nThis is followed by t lines, each containing a description of one test case. The given strings consist only of lowercase Latin letters and have lengths between 1 and 100 inclusive.\\n\\nOutput\\n\\nFor each test case, output on a separate line:\\n\\n  * YES if the string in the corresponding test case is square, \\n  * NO otherwise. \\n\\n\\n\\nYou can output YES and NO in any case (for example, strings yEs, yes, Yes and YES will be recognized as a positive response).\\n\\nExample\\n\\nInput\\n\\n\\n10\\na\\naa\\naaa\\naaaa\\nabab\\nabcabc\\nabacaba\\nxxyy\\nxyyx\\nxyxy\\n\\n\\nOutput\\n\\n\\nNO\\nYES\\nNO\\nYES\\nYES\\nYES\\nNO\\nNO\\nNO\\nYES\",\"targets\":\"import java.util.*;\\n\\npublic class LongestString {\\n    public static void main(String[] args) {\\n        Scanner scanner = new Scanner(System.in);\\n        long cases = scanner.nextLong();\\n        scanner.nextLine();\\n        while (cases-- > 0) {\\n            String l = scanner.nextLine();\\n            Boolean flaf = true;\\n            char[] k = l.toCharArray();\\n            if (k.length % 2 == 0) {\\n                int halfLength = k.length \\/ 2;\\n                for (int i = 0; i < k.length \\/ 2; i++) {\\n                    if (k[i] != k[halfLength + i]) {\\n                        flaf = false;\\n                        break;\\n                    }\\n                }\\n            } else {\\n                flaf = false;\\n            }\\n            System.out.println(flaf ? \\\"YES\\\" : \\\"NO\\\");\\n        }\\n    }\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"After a hard day Vitaly got very hungry and he wants to eat his favorite potato pie. But it's not that simple. Vitaly is in the first room of the house with n room located in a line and numbered starting from one from left to right. You can go from the first room to the second room, from the second room to the third room and so on \u2014 you can go from the (n - 1)-th room to the n-th room. Thus, you can go to room x only from room x - 1.\\n\\nThe potato pie is located in the n-th room and Vitaly needs to go there. \\n\\nEach pair of consecutive rooms has a door between them. In order to go to room x from room x - 1, you need to open the door between the rooms with the corresponding key. \\n\\nIn total the house has several types of doors (represented by uppercase Latin letters) and several types of keys (represented by lowercase Latin letters). The key of type t can open the door of type T if and only if t and T are the same letter, written in different cases. For example, key f can open door F.\\n\\nEach of the first n - 1 rooms contains exactly one key of some type that Vitaly can use to get to next rooms. Once the door is open with some key, Vitaly won't get the key from the keyhole but he will immediately run into the next room. In other words, each key can open no more than one door.\\n\\nVitaly realizes that he may end up in some room without the key that opens the door to the next room. Before the start his run for the potato pie Vitaly can buy any number of keys of any type that is guaranteed to get to room n.\\n\\nGiven the plan of the house, Vitaly wants to know what is the minimum number of keys he needs to buy to surely get to the room n, which has a delicious potato pie. Write a program that will help Vitaly find out this number.\\n\\nInput\\n\\nThe first line of the input contains a positive integer n (2 \u2264 n \u2264 105) \u2014 the number of rooms in the house.\\n\\nThe second line of the input contains string s of length 2\u00b7n - 2. Let's number the elements of the string from left to right, starting from one. \\n\\nThe odd positions in the given...\\nThe above is tricky. Write me a correct solution in PYTHON3.\",\"targets\":\"n=int(input())\\ns=input()\\ns=list(s)\\nk=[0]*26\\ncount=0\\nfor i in range(0,(len(s)\\/\\/2)):\\n    p=s[i*2]\\n    q=s[i*2+1]\\n    k[ord(p)-97]+=1\\n    if k[ord(q)-65]>0:\\n        k[ord(q)-65]-=1\\n    else:\\n        count+=1\\nprint(count)\",\"language\":\"python\",\"split\":\"train\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"JAVA solution for \\\"The problem statement looms below, filling you with determination.\\n\\nConsider a grid in which some cells are empty and some cells are filled. Call a cell in this grid exitable if, starting at that cell, you can exit the grid by moving up and left through only empty cells. This includes the cell itself, so all filled in cells are not exitable. Note that you can exit the grid from any leftmost empty cell (cell in the first column) by going left, and from any topmost empty cell (cell in the first row) by going up.\\n\\nLet's call a grid determinable if, given only which cells are exitable, we can exactly determine which cells are filled in and which aren't.\\n\\nYou are given a grid a of dimensions n \u00d7 m , i. e. a grid with n rows and m columns. You need to answer q queries (1 \u2264 q \u2264 2 \u22c5 10^5). Each query gives two integers x_1, x_2 (1 \u2264 x_1 \u2264 x_2 \u2264 m) and asks whether the subgrid of a consisting of the columns x_1, x_1 + 1, \u2026, x_2 - 1, x_2 is determinable.\\n\\nInput\\n\\nThe first line contains two integers n, m (1 \u2264 n, m \u2264 10^6, nm \u2264 10^6) \u2014 the dimensions of the grid a.\\n\\nn lines follow. The y-th line contains m characters, the x-th of which is 'X' if the cell on the intersection of the the y-th row and x-th column is filled and \\\".\\\" if it is empty.\\n\\nThe next line contains a single integer q (1 \u2264 q \u2264 2 \u22c5 10^5) \u2014 the number of queries.\\n\\nq lines follow. Each line contains two integers x_1 and x_2 (1 \u2264 x_1 \u2264 x_2 \u2264 m), representing a query asking whether the subgrid of a containing the columns x_1, x_1 + 1, \u2026, x_2 - 1, x_2 is determinable.\\n\\nOutput\\n\\nFor each query, output one line containing \\\"YES\\\" if the subgrid specified by the query is determinable and \\\"NO\\\" otherwise. The output is case insensitive (so \\\"yEs\\\" and \\\"No\\\" will also be accepted).\\n\\nExample\\n\\nInput\\n\\n\\n4 5\\n..XXX\\n...X.\\n...X.\\n...X.\\n5\\n1 3\\n3 3\\n4 5\\n5 5\\n1 5\\n\\n\\nOutput\\n\\n\\nYES\\nYES\\nNO\\nYES\\nNO\\n\\nNote\\n\\nFor each query of the example, the corresponding subgrid is displayed twice below: first in its input format, then with each cell marked as \\\"E\\\" if it is exitable and \\\"N\\\" otherwise.\\n\\nFor the...\\\":\",\"targets\":\"import java.io.*;\\n\\nimport java.util.*;\\n\\/*\\n\\n4 5\\nXXXXX\\nX....\\nX....\\nX....\\n5\\n1 3\\n3 3\\n4 5\\n5 5\\n1 5\\n\\n*\\/\\n\\n \\n public class C2{\\n\\tstatic FastReader sc=null;\\n\\t\\n\\tpublic static void main(String[] args) {\\n\\t\\tsc=new FastReader();\\n\\t\\tPrintWriter out=new PrintWriter(System.out);\\n\\t\\t\\n\\t\\t\\/\\/all . have to reach the end\\n\\t\\t\\n\\t\\t\\/\\/if there is a . that cannot reach the end then bad\\n\\t\\t\\n\\t\\tint n=sc.nextInt(),m=sc.nextInt();\\n\\t\\tchar a[][]=new char[n][m];\\n\\t\\tfor(int i=0;i<n;i++)\\n\\t\\t\\ta[i]=sc.next().toCharArray();\\n\\t\\t\\n\\t\\t\\/\\/if if contains a bad square along with its neighbors, then the matrix is bad\\n\\t\\tTreeSet<Integer> cols=new TreeSet<>();\\n\\t\\tcols.add(m+1);\\n\\t\\t\\n\\t\\tfor(int i=0;i<n;i++) {\\n\\t\\t\\tfor(int j=0;j<m;j++) {\\n\\t\\t\\t\\tif(bad(i,j,a))cols.add(j-1);\\n\\t\\t\\t}\\n\\t\\t}\\n\\t\\t\\n\\t\\t\\n\\t\\tint q=sc.nextInt();\\n\\t\\twhile(q-->0) {\\n\\t\\t\\tint c1=sc.nextInt()-1,c2=sc.nextInt()-1;\\n\\t\\t\\tif(c2==c1) {\\n\\t\\t\\t\\tout.println(\\\"YES\\\");\\n\\t\\t\\t\\tcontinue;\\n\\t\\t\\t}\\n\\t\\t\\t\\n\\t\\t\\tint val=cols.ceiling(c1);\\n\\t\\t\\tboolean bad=(val>=c1 && val+1<=c2);\\n\\t\\t\\tout.println(bad?\\\"NO\\\":\\\"YES\\\");\\n\\t\\t}\\n\\t\\tout.close();\\n\\t\\t\\n\\t\\t\\n\\t}\\n\\tstatic boolean bad(int i,int j,char a[][]) {\\n\\t\\tif(i==0 || j==0)return false;\\n\\t\\t\\n\\t\\tif(a[i-1][j]=='X' && a[i][j-1]=='X')return true;\\n\\t\\t\\n\\t\\treturn false;\\n\\t}\\n\\t\\n\\t\\n\\tstatic int[] ruffleSort(int a[]) {\\n\\t\\tArrayList<Integer> al=new ArrayList<>();\\n\\t\\tfor(int i:a)al.add(i);\\n\\t\\tCollections.sort(al);\\n\\t\\tfor(int i=0;i<a.length;i++)a[i]=al.get(i);\\n\\t\\treturn a;\\n\\t}\\n\\t\\n\\tstatic void print(int a[]) {\\n\\t\\tfor(int e:a) {\\n\\t\\t\\tSystem.out.print(e+\\\" \\\");\\n\\t\\t}\\n\\t\\tSystem.out.println();\\n\\t}\\n\\t\\n\\tstatic class FastReader{\\n\\t\\t\\n\\t\\tStringTokenizer st=new StringTokenizer(\\\"\\\");\\n\\t\\tBufferedReader br=new BufferedReader(new InputStreamReader(System.in));\\n\\t\\t\\n\\t\\tString next() {\\n\\t\\t\\twhile(!st.hasMoreTokens()) \\n\\t\\t\\t\\ttry {\\n\\t\\t\\t\\t\\tst=new StringTokenizer(br.readLine());\\n\\t\\t\\t\\t}\\n\\t\\t\\t   catch(IOException e){\\n\\t\\t\\t\\t   e.printStackTrace();\\n\\t\\t\\t   }\\n\\t\\t\\treturn st.nextToken();\\n\\t\\t}\\n\\t\\t\\n\\t\\tint nextInt() {\\n\\t\\t\\treturn Integer.parseInt(next());\\n\\t\\t}\\n\\t\\t\\n\\t\\tlong nextLong() {\\n\\t\\t\\treturn Long.parseLong(next());\\n\\t\\t}\\n\\t\\t\\n\\t\\tint[] readArray(int n) {\\n\\t\\t\\tint a[]=new int[n];\\n\\t\\t\\tfor(int i=0;i<n;i++)a[i]=sc.nextInt();\\n\\t\\t\\treturn a;\\n\\t\\t}\\n\\t}\\n\\t\\n\\t\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"In this problem, we only consider strings consisting of lowercase English letters.\\n\\nStrings s and t are said to be isomorphic when the following conditions are satisfied:\\n\\n* |s| = |t| holds.\\n* For every pair i, j, one of the following holds:\\n* s_i = s_j and t_i = t_j.\\n* s_i \\\\neq s_j and t_i \\\\neq t_j.\\n\\n\\n\\nFor example, `abcac` and `zyxzx` are isomorphic, while `abcac` and `ppppp` are not.\\n\\nA string s is said to be in normal form when the following condition is satisfied:\\n\\n* For every string t that is isomorphic to s, s \\\\leq t holds. Here \\\\leq denotes lexicographic comparison.\\n\\n\\n\\nFor example, `abcac` is in normal form, but `zyxzx` is not since it is isomorphic to `abcac`, which is lexicographically smaller than `zyxzx`.\\n\\nYou are given an integer N. Print all strings of length N that are in normal form, in lexicographically ascending order.\\n\\nConstraints\\n\\n* 1 \\\\leq N \\\\leq 10\\n* All values in input are integers.\\n\\nInput\\n\\nInput is given from Standard Input in the following format:\\n\\n\\nN\\n\\n\\nOutput\\n\\nAssume that there are K strings of length N that are in normal form: w_1, \\\\ldots, w_K in lexicographical order. Output should be in the following format:\\n\\n\\nw_1\\n:\\nw_K\\n\\nOutput\\n\\nAssume that there are K strings of length N that are in normal form: w_1, \\\\ldots, w_K in lexicographical order. Output should be in the following format:\\n\\n\\nw_1\\n:\\nw_K\\n\\nExamples\\n\\nInput\\n\\n1\\n\\n\\nOutput\\n\\na\\n\\n\\nInput\\n\\n2\\n\\n\\nOutput\\n\\naa\\nab\\\":\",\"targets\":\"#include<bits\\/stdc++.h>\\nusing namespace std;\\nvoid f(string s,char m,int n){\\n  if(!n)cout<<s<<\\\"\\\\n\\\";\\n  else{\\n    for(char c='a';c<m;++c) f(s+c,m,n-1);\\n    f(s+m,m+1,n-1);\\n  }\\n}\\nint main(){\\n  int n;\\n  cin>>n;\\n  f(\\\"a\\\",'b',n-1);\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"It is a simplified version of problem F2. The difference between them is the constraints (F1: k \u2264 2, F2: k \u2264 10).\\n\\nYou are given an integer n. Find the minimum integer x such that x \u2265 n and the number x is k-beautiful.\\n\\nA number is called k-beautiful if its decimal representation having no leading zeroes contains no more than k different digits. E.g. if k = 2, the numbers 3434443, 55550, 777 and 21 are k-beautiful whereas the numbers 120, 445435 and 998244353 are not.\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases. Then t test cases follow.\\n\\nEach test case consists of one line containing two integers n and k (1 \u2264 n \u2264 10^9, 1 \u2264 k \u2264 2).\\n\\nOutput\\n\\nFor each test case output on a separate line x \u2014 the minimum k-beautiful integer such that x \u2265 n.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n1 1\\n221 2\\n177890 2\\n998244353 1\\n\\n\\nOutput\\n\\n\\n1\\n221\\n181111\\n999999999\\nSolve the task in PYTHON3.\",\"targets\":\"def upList(s, i):\\n    left = s[:i]\\n    right = s[i:]\\n    left = list(str(int(''.join(left)) + 1))\\n    return left + right\\n\\ndef jg(x, val):\\n    y = set(i for i in x if i >= val)\\n    if len(y) == 0:\\n        return None\\n    return min(y)\\n\\n\\nfor _ in range(int(input())):\\n    n, k = map(int, input().split())\\n    s = list(str(n))\\n\\n    i = len(s) - 1\\n    while i >= 0:\\n        cMax = set()\\n        j = 0\\n        while len(cMax) < k and j < len(s):\\n            cMax.add(s[j])\\n            j += 1\\n        if j == len(s):\\n            break\\n\\n        if s[i] not in cMax:\\n            z = jg(cMax, s[i])\\n            if z == None:\\n                s = upList(s, i)\\n                for var in range(i, len(s)):\\n                    s[var] = '0'\\n                i = len(s) - 1\\n            else:\\n                s[i] = z\\n                for var in range(i + 1, len(s)):\\n                    s[var] = min(cMax)\\n                i -= 1\\n        else:\\n            i -= 1\\n        \\n    print(''.join(s))\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"Given n, find any array a_1, a_2, \u2026, a_n of integers such that all of the following conditions hold: \\n\\n  * 1 \u2264 a_i \u2264 10^9 for every i from 1 to n.\\n\\n  * a_1 < a_2 < \u2026 <a_n\\n\\n  * For every i from 2 to n, a_i isn't divisible by a_{i-1}\\n\\n\\n\\n\\nIt can be shown that such an array always exists under the constraints of the problem.\\n\\nInput\\n\\nThe first line contains the number of test cases t (1 \u2264 t \u2264 100). Description of the test cases follows.\\n\\nThe only line of each test case contains a single integer n (1 \u2264 n \u2264 1000).\\n\\nIt is guaranteed that the sum of n over all test cases does not exceed 10^4.\\n\\nOutput\\n\\nFor each test case print n integers a_1, a_2, \u2026, a_n \u2014 the array you found. If there are multiple arrays satisfying all the conditions, print any of them.\\n\\nExample\\n\\nInput\\n\\n\\n3\\n1\\n2\\n7\\n\\n\\nOutput\\n\\n\\n1\\n2 3\\n111 1111 11111 111111 1111111 11111111 111111111\\n\\nNote\\n\\nIn the first test case, array [1] satisfies all the conditions.\\n\\nIn the second test case, array [2, 3] satisfies all the conditions, as 2<3 and 3 is not divisible by 2.\\n\\nIn the third test case, array [111, 1111, 11111, 111111, 1111111, 11111111, 111111111] satisfies all the conditions, as it's increasing and a_i isn't divisible by a_{i-1} for any i from 2 to 7.\\\":\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint main() {\\n  int n, num;\\n  cin >> n;\\n  for (int i = 0; i < n; i++) {\\n    cin >> num;\\n    int cnt = 1;\\n    for (int j = 0; j < num; j++) {\\n      cnt++;\\n      cout << cnt << \\\" \\\";\\n    }\\n    cout << endl;\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"There are n reindeer at the North Pole, all battling for the highest spot on the \\\"Top Reindeer\\\" leaderboard on the front page of CodeNorses (a popular competitive reindeer gaming website). Interestingly, the \\\"Top Reindeer\\\" title is just a measure of upvotes and has nothing to do with their skill level in the reindeer games, but they still give it the utmost importance.\\n\\nCurrently, the i-th reindeer has a score of a_i. You would like to influence the leaderboard with some operations. In an operation, you can choose a reindeer, and either increase or decrease his score by 1 unit. Negative scores are allowed.\\n\\nYou have m requirements for the resulting scores. Each requirement is given by an ordered pair (u, v), meaning that after all operations, the score of reindeer u must be less than or equal to the score of reindeer v.\\n\\nYour task is to perform the minimum number of operations so that all requirements will be satisfied.\\n\\nInput\\n\\nThe first line contains two integers n and m (2\u2264 n\u2264 1000; 1\u2264 m\u2264 1000) \u2014 the number of reindeer and requirements, respectively.\\n\\nThe second line contains n integers a_1,\u2026, a_n (1\u2264 a_i\u2264 10^9), where a_i is the current score of reindeer i.\\n\\nThe next m lines describe the requirements.\\n\\nThe i-th of these lines contains two integers u_i and v_i (1\u2264 u_i, v_i\u2264 n; u_i\u2260 v_i) \u2014 the two reindeer of the i-th requirement.\\n\\nOutput\\n\\nPrint n integers b_1,\u2026, b_n (-10^{15}\u2264 b_i\u2264 10^{15}), where b_i is the score of the i-th reindeer after all operations.\\n\\nIf there are multiple solutions achieving the minimum number of operations, you may output any.\\n\\nWe can prove that there is always an optimal solution such that |b_i|\u2264 10^{15} for all i.\\n\\nExamples\\n\\nInput\\n\\n\\n7 6\\n3 1 4 9 2 5 6\\n1 2\\n2 3\\n3 4\\n4 5\\n5 6\\n6 7\\n\\n\\nOutput\\n\\n\\n1 1 4 4 4 5 6 \\n\\n\\nInput\\n\\n\\n4 6\\n6 5 8 2\\n3 1\\n4 1\\n3 2\\n1 2\\n2 3\\n3 1\\n\\n\\nOutput\\n\\n\\n6 6 6 2 \\n\\n\\nInput\\n\\n\\n10 18\\n214 204 195 182 180 176 176 172 169 167\\n1 2\\n3 2\\n4 2\\n5 2\\n6 2\\n7 2\\n8 2\\n9 2\\n10 2\\n6 1\\n6 2\\n6 3\\n6 4\\n6 5\\n6 7\\n6 8\\n6 9\\n6 10\\n\\n\\nOutput\\n\\n\\n204 204 195 182 180 167 176 172 169 167 \\nSolve the task in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\ntemplate <typename T>\\nvoid cmax(T& x, T y) {\\n  if (x < y) x = y;\\n}\\ntemplate <typename T>\\nvoid cmin(T& x, T y) {\\n  if (x > y) x = y;\\n}\\nconst int N = 10005, INF = 1e9;\\nint n, m, s, t, num = 1, a[N], d[N], h[N], cur[N], dis[N], vis[N];\\nstruct E {\\n  int x, t, w, c;\\n} e[2 * N];\\nvoid add(int s, int t, int w, int c) { e[++num] = {h[s], t, w, c}, h[s] = num; }\\nbool spfa() {\\n  for (int i = (0); i <= (n + 1); i++) cur[i] = h[i], dis[i] = INF;\\n  queue<int> q;\\n  q.push(s), dis[s] = 0, vis[s] = 1;\\n  while (!q.empty()) {\\n    int u = q.front();\\n    q.pop(), vis[u] = 0;\\n    for (int i = h[u]; i; i = e[i].x)\\n      if (e[i].w && dis[e[i].t] > dis[u] + e[i].c) {\\n        dis[e[i].t] = dis[u] + e[i].c;\\n        if (!vis[e[i].t]) q.push(e[i].t), vis[e[i].t] = 1;\\n      }\\n  }\\n  return dis[t] < 0;\\n}\\nint dfs(int u, int lim) {\\n  if (u == t) return lim;\\n  vis[u] = 1;\\n  int res = 0;\\n  for (int& i = cur[u]; i && lim; i = e[i].x)\\n    if (!vis[e[i].t] && dis[e[i].t] == dis[u] + e[i].c) {\\n      int tmp = dfs(e[i].t, min(lim, e[i].w));\\n      res += tmp, lim -= tmp, e[i].w -= tmp, e[i ^ 1].w += tmp;\\n      if (lim == 0) break;\\n    }\\n  vis[u] = 0;\\n  return res;\\n}\\nint main() {\\n  scanf(\\\"%d%d\\\", &n, &m), s = 0, t = n + 1;\\n  for (int i = (1); i <= (n); i++) {\\n    scanf(\\\"%d\\\", &a[i]);\\n    add(s, i, 1, 0), add(i, s, 0, 0);\\n    add(i, t, 1, 0), add(t, i, 0, 0);\\n  }\\n  for (int i = (1); i <= (m); i++) {\\n    int x, y;\\n    scanf(\\\"%d%d\\\", &x, &y);\\n    add(x, y, INF, a[y] - a[x]), add(y, x, 0, a[x] - a[y]);\\n  }\\n  while (spfa()) {\\n    dfs(s, INF);\\n  }\\n  for (int i = (0); i <= (n + 1); i++) d[i] = -INF;\\n  d[0] = 0;\\n  for (int i = (1); i <= (n + 1); i++)\\n    for (int j = (0); j <= (n + 1); j++)\\n      if (d[j] != -INF)\\n        for (int k = h[j]; k; k = e[k].x)\\n          if (e[k].w) cmax(d[e[k].t], d[j] - e[k].c);\\n  for (int i = (1); i <= (n); i++) printf(\\\"%d \\\", a[i] + d[i]);\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Monocarp is the coach of the Berland State University programming teams. He decided to compose a problemset for a training session for his teams.\\n\\nMonocarp has n problems that none of his students have seen yet. The i-th problem has a topic a_i (an integer from 1 to n) and a difficulty b_i (an integer from 1 to n). All problems are different, that is, there are no two tasks that have the same topic and difficulty at the same time.\\n\\nMonocarp decided to select exactly 3 problems from n problems for the problemset. The problems should satisfy at least one of two conditions (possibly, both):\\n\\n  * the topics of all three selected problems are different; \\n  * the difficulties of all three selected problems are different. \\n\\n\\n\\nYour task is to determine the number of ways to select three problems for the problemset.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 50000) \u2014 the number of testcases.\\n\\nThe first line of each testcase contains an integer n (3 \u2264 n \u2264 2 \u22c5 10^5) \u2014 the number of problems that Monocarp have.\\n\\nIn the i-th of the following n lines, there are two integers a_i and b_i (1 \u2264 a_i, b_i \u2264 n) \u2014 the topic and the difficulty of the i-th problem.\\n\\nIt is guaranteed that there are no two problems that have the same topic and difficulty at the same time.\\n\\nThe sum of n over all testcases doesn't exceed 2 \u22c5 10^5.\\n\\nOutput\\n\\nPrint the number of ways to select three training problems that meet either of the requirements described in the statement.\\n\\nExample\\n\\nInput\\n\\n\\n2\\n4\\n2 4\\n3 4\\n2 1\\n1 3\\n5\\n1 5\\n2 4\\n3 3\\n4 2\\n5 1\\n\\n\\nOutput\\n\\n\\n3\\n10\\n\\nNote\\n\\nIn the first example, you can take the following sets of three problems:\\n\\n  * problems 1, 2, 4; \\n  * problems 1, 3, 4; \\n  * problems 2, 3, 4. \\n\\n\\n\\nThus, the number of ways is equal to three.\\nimpor\",\"targets\":\"t java.io.OutputStream;\\nimport java.io.IOException;\\nimport java.io.InputStream;\\nimport java.io.OutputStream;\\nimport java.io.PrintWriter;\\nimport java.io.BufferedWriter;\\nimport java.io.Writer;\\nimport java.io.OutputStreamWriter;\\nimport java.util.InputMismatchException;\\nimport java.io.IOException;\\nimport java.io.InputStream;\\n\\n\\/**\\n * Built using CHelper plug-in\\n * Actual solution is at the top\\n *\\/\\npublic class Main {\\n    public static void main(String[] args) {\\n        InputStream inputStream = System.in;\\n        OutputStream outputStream = System.out;\\n        InputReader in = new InputReader(inputStream);\\n        OutputWriter out = new OutputWriter(outputStream);\\n        DTrainingSession solver = new DTrainingSession();\\n        int testCount = Integer.parseInt(in.next());\\n        for (int i = 1; i <= testCount; i++)\\n            solver.solve(i, in, out);\\n        out.close();\\n    }\\n\\n    static class DTrainingSession {\\n        int n;\\n        P[] ps;\\n\\n        public void solve(int testNumber, InputReader in, OutputWriter out) {\\n            n = in.nextInt();\\n            int[] cnt1 = new int[n + 5];\\n            int[] cnt2 = new int[n + 5];\\n            ps = new P[n];\\n            for (int i = 0; i < n; i++) {\\n                ps[i] = new P(in.nextInt(), in.nextInt());\\n                cnt1[ps[i].a]++;\\n                cnt2[ps[i].b]++;\\n            }\\n\\/\\/        Arrays.sort(ps, Comparator.comparingInt(x -> x.a));\\n            long tmp = 0;\\n            for (int i = 0; i < n; i++) {\\n                long c1 = cnt1[ps[i].a];\\n                long c2 = cnt2[ps[i].b] - 1;\\n                tmp += (c1 - 1) * c2;\\n            }\\n            long sum = 1;\\n            for (int i = 0; i < 3; i++) {\\n                sum *= (n - i);\\n            }\\n            sum \\/= 6;\\n            out.println(sum - tmp);\\n        }\\n\\n        class P {\\n            int a;\\n            int b;\\n\\n            public P(int a, int b) {\\n                this.a = a;\\n                this.b = b;\\n            }\\n\\n        }\\n\\n    }\\n\\n    static class InputReader {\\n        private...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in JAVA?\\nDmitry has an array of n non-negative integers a_1, a_2, ..., a_n.\\n\\nIn one operation, Dmitry can choose any index j (1 \u2264 j \u2264 n) and increase the value of the element a_j by 1. He can choose the same index j multiple times.\\n\\nFor each i from 0 to n, determine whether Dmitry can make the MEX of the array equal to exactly i. If it is possible, then determine the minimum number of operations to do it.\\n\\nThe MEX of the array is equal to the minimum non-negative integer that is not in the array. For example, the MEX of the array [3, 1, 0] is equal to 2, and the array [3, 3, 1, 4] is equal to 0.\\n\\nInput\\n\\nThe first line of input data contains a single integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases in the input. \\n\\nThe descriptions of the test cases follow.\\n\\nThe first line of the description of each test case contains a single integer n (1 \u2264 n \u2264 2 \u22c5 10^5) \u2014 the length of the array a.\\n\\nThe second line of the description of each test case contains n integers a_1, a_2, ..., a_n (0 \u2264 a_i \u2264 n) \u2014 elements of the array a.\\n\\nIt is guaranteed that the sum of the values n over all test cases in the test does not exceed 2\u22c510^5.\\n\\nOutput\\n\\nFor each test case, output n + 1 integer \u2014 i-th number is equal to the minimum number of operations for which you can make the array MEX equal to i (0 \u2264 i \u2264 n), or -1 if this cannot be done.\\n\\nExample\\n\\nInput\\n\\n\\n5\\n3\\n0 1 3\\n7\\n0 1 2 3 4 3 2\\n4\\n3 0 0 0\\n7\\n4 6 2 3 5 0 5\\n5\\n4 0 1 0 4\\n\\n\\nOutput\\n\\n\\n1 1 0 -1 \\n1 1 2 2 1 0 2 6 \\n3 0 1 4 3 \\n1 0 -1 -1 -1 -1 -1 -1 \\n2 1 0 2 -1 -1 \\n\\nNote\\n\\nIn the first set of example inputs, n=3:\\n\\n  * to get MEX=0, it is enough to perform one increment: a_1++; \\n  * to get MEX=1, it is enough to perform one increment: a_2++; \\n  * MEX=2 for a given array, so there is no need to perform increments; \\n  * it is impossible to get MEX=3 by performing increments.\",\"targets\":\"import java.util.*;\\nimport java.io.*;\\npublic class E1619{\\n\\tstatic FastScanner fs = null;\\n\\tpublic static void main(String[] args) {\\n\\t\\tfs = new FastScanner();\\n\\t\\tPrintWriter out = new PrintWriter(System.out);\\n\\t\\tint t = fs.nextInt();\\n\\t\\twhile (t-->0) {\\n\\t\\t\\tint n = fs.nextInt();\\n\\t\\t\\tint a[] = new int[n+1];\\n\\t\\t\\tfor(int i=0;i<n;i++){\\n\\t\\t\\t\\tint num = fs.nextInt();\\n\\t\\t\\t\\ta[num]+=1;\\n\\t\\t\\t}\\n\\t\\t\\t\\/\\/ for(int i=1;i<=n;i++){\\n\\t\\t\\t\\/\\/ \\tsum[i]+=sum[i-1];\\n\\t\\t\\t\\/\\/ }\\n\\t\\t\\tint id = -1;\\n\\t\\t\\tint ex = 0;\\n\\t\\t\\tlong used = (long)0;\\n\\t\\t\\tPriorityQueue<Pair> pq = new PriorityQueue<>();\\n\\t\\t\\tfor(int i=0;i<=n;i++){\\n\\t\\t\\t\\tif(a[i]==0){\\n\\t\\t\\t\\t\\tout.print(used+\\\" \\\");\\n\\t\\t\\t\\t\\tex-=1;\\n\\t\\t\\t\\t\\tif(ex>=0){\\n\\t\\t\\t\\t\\tPair p2 = pq.remove();\\n\\t\\t\\t\\t\\tint value = p2.value;\\n\\t\\t\\t\\t\\tint index = p2.index;\\n\\t\\t\\t\\t\\tused+=(long)(i-value);\\n\\t\\t\\t\\t\\tindex-=1;\\n\\t\\t\\t\\t\\tif(index>0){\\n\\t\\t\\t\\t\\t\\tpq.add(new Pair(value,index));\\n\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\t}\\n\\t\\t\\t\\telse{\\n\\t\\t\\t\\t\\tex+=(a[i]);\\n\\t\\t\\t\\t\\tout.print((a[i]+used)+\\\" \\\");\\n\\t\\t\\t\\t\\tex-=1;\\n\\t\\t\\t\\t\\tif(a[i]>1)\\n\\t\\t\\t\\t\\tpq.add(new Pair(i,a[i]-1));\\n\\t\\t\\t\\t}\\n\\t\\t\\t\\tif(ex==-1){\\n\\t\\t\\t\\t\\tid = i;\\n\\t\\t\\t\\t\\tbreak;\\n\\t\\t\\t\\t}\\n\\t\\t\\t}\\n\\t\\t\\tif(id!=-1){\\n\\t\\t\\t\\tfor(int i=id+1;i<=n;i++){\\n\\t\\t\\t\\t\\tout.print(\\\"-1\\\"+\\\" \\\");\\n\\t\\t\\t\\t}\\n\\t\\t\\t}\\n\\t\\t\\tout.println();\\n\\t\\t}\\n\\t\\tout.close();\\n\\t}\\n\\tstatic class Pair implements Comparable<Pair> {\\n    \\tInteger value;\\n    \\tInteger index;\\n\\n    \\tpublic Pair(Integer value, Integer index) {\\n        \\tthis.value = value;\\n        \\tthis.index = index;\\n    \\t}\\n\\n    \\tpublic int compareTo(Pair o) {\\n        \\treturn (-value + o.value);\\n    \\t}\\n\\t}\\n\\tstatic void sort(int[] a) {\\n\\t\\tArrayList<Integer> l=new ArrayList<>();\\n\\t\\tfor (int i:a) l.add(i);\\n\\t\\tCollections.sort(l);\\n\\t\\tfor (int i=0; i<a.length; i++) a[i]=l.get(i);\\n\\t}\\n\\tstatic class FastScanner {\\n\\t\\tBufferedReader br=new BufferedReader(new InputStreamReader(System.in));\\n\\t\\tStringTokenizer st=new StringTokenizer(\\\"\\\");\\n\\t\\tString next() {\\n\\t\\t\\twhile (!st.hasMoreTokens())\\n\\t\\t\\t\\ttry {\\n\\t\\t\\t\\t\\tst=new StringTokenizer(br.readLine());\\n\\t\\t\\t\\t} catch (IOException e) {\\n\\t\\t\\t\\t\\te.printStackTrace();\\n\\t\\t\\t\\t}\\n\\t\\t\\treturn st.nextToken();\\n\\t\\t}\\n\\t\\t\\n\\t\\tint nextInt() {\\n\\t\\t\\treturn Integer.parseInt(next());\\n\\t\\t}\\n\\t\\tint[] readArray(int n) {\\n\\t\\t\\tint[] a=new...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You have a permutation: an array a = [a_1, a_2, \u2026, a_n] of distinct integers from 1 to n. The length of the permutation n is odd.\\n\\nConsider the following algorithm of sorting the permutation in increasing order.\\n\\nA helper procedure of the algorithm, f(i), takes a single argument i (1 \u2264 i \u2264 n-1) and does the following. If a_i > a_{i+1}, the values of a_i and a_{i+1} are exchanged. Otherwise, the permutation doesn't change.\\n\\nThe algorithm consists of iterations, numbered with consecutive integers starting with 1. On the i-th iteration, the algorithm does the following: \\n\\n  * if i is odd, call f(1), f(3), \u2026, f(n - 2); \\n  * if i is even, call f(2), f(4), \u2026, f(n - 1). \\n\\n\\n\\nIt can be proven that after a finite number of iterations the permutation will be sorted in increasing order.\\n\\nAfter how many iterations will this happen for the first time?\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 100). Description of the test cases follows.\\n\\nThe first line of each test case contains a single integer n (3 \u2264 n \u2264 999; n is odd) \u2014 the length of the permutation.\\n\\nThe second line contains n distinct integers a_1, a_2, \u2026, a_n (1 \u2264 a_i \u2264 n) \u2014 the permutation itself. \\n\\nIt is guaranteed that the sum of n over all test cases does not exceed 999.\\n\\nOutput\\n\\nFor each test case print the number of iterations after which the permutation will become sorted in increasing order for the first time.\\n\\nIf the given permutation is already sorted, print 0.\\n\\nExample\\n\\nInput\\n\\n\\n3\\n3\\n3 2 1\\n7\\n4 5 7 1 3 2 6\\n5\\n1 2 3 4 5\\n\\n\\nOutput\\n\\n\\n3\\n5\\n0\\n\\nNote\\n\\nIn the first test case, the permutation will be changing as follows: \\n\\n  * after the 1-st iteration: [2, 3, 1]; \\n  * after the 2-nd iteration: [2, 1, 3]; \\n  * after the 3-rd iteration: [1, 2, 3]. \\n\\n\\n\\nIn the second test case, the permutation will be changing as follows: \\n\\n  * after the 1-st iteration: [4, 5, 1, 7, 2, 3, 6]; \\n  * after the 2-nd iteration: [4, 1, 5, 2, 7, 3, 6]; \\n  * after the 3-rd iteration: [1, 4, 2, 5, 3, 7, 6]; \\n  * after the 4-th...\\nSolve the task in PYTHON3.\",\"targets\":\"import math \\nfrom collections import Counter, defaultdict\\nimport sys\\n# resource.setrlimit(resource.RLIMIT_STACK, (2**29,-1))\\n# sys.setrecursionlimit(10**6)\\n\\n\\\"\\\"\\\"\\n# Template Designed By: Shivshanker Singh\\n# Note: If you find this template useful and want to use it then please don't just copy paste it \\n        you can take ideas from this and make your own.\\n        because if you copy paste as it is then there are high chances that both of us will be plagiarized\\n        (because most of code will be same for small problems).\\n        So to avoid this please dont copy paste.\\n\\\"\\\"\\\"\\n\\nmod       = 10**9 + 7\\ninput     = sys.stdin.readline\\nreadInt   = lambda : int(input().strip())\\nreadfloat = lambda : float(input().strip())\\nreadStr   = lambda : input().strip()\\nintList   = lambda : list(map(int, input().strip().split()))\\nintMap    = lambda : map(int, input().strip().split())\\nfloatList = lambda : list(map(float, input().strip().split()))\\nfloatMap  = lambda : map(float, input().strip().split())\\nstrList   = lambda : list(input().strip().split())\\n\\n\\ndef print(*args, end='\\\\n', sep=' '):\\n    for i in args:\\n        sys.stdout.write(str(i))\\n        sys.stdout.write(sep)\\n    sys.stdout.write(end)\\n\\n\\ndef solve():\\n    brr = sorted(arr)\\n    res = 0\\n    while True:\\n        if arr == brr:\\n            return res\\n        for i in range(res%2, n-1, 2):\\n            if arr[i] > arr[i+1]:\\n                arr[i], arr[i+1] = arr[i+1], arr[i]\\n        res += 1\\n    \\n# if __name__ == '__main__':\\nfor _ in range(readInt()):\\n    n = readInt()\\n    arr = intList()\\n    \\n    print(solve())\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You are given an array of integers a of length n. The elements of the array can be either different or the same. \\n\\nEach element of the array is colored either blue or red. There are no unpainted elements in the array. One of the two operations described below can be applied to an array in a single step:\\n\\n  * either you can select any blue element and decrease its value by 1; \\n  * or you can select any red element and increase its value by 1. \\n\\n\\n\\nSituations in which there are no elements of some color at all are also possible. For example, if the whole array is colored blue or red, one of the operations becomes unavailable.\\n\\nDetermine whether it is possible to make 0 or more steps such that the resulting array is a permutation of numbers from 1 to n?\\n\\nIn other words, check whether there exists a sequence of steps (possibly empty) such that after applying it, the array a contains in some order all numbers from 1 to n (inclusive), each exactly once.\\n\\nInput\\n\\nThe first line contains an integer t (1 \u2264 t \u2264 10^4) \u2014 the number of input data sets in the test.\\n\\nThe description of each set of input data consists of three lines. The first line contains an integer n (1 \u2264 n \u2264 2 \u22c5 10^5) \u2014 the length of the original array a. The second line contains n integers a_1, a_2, ..., a_n (-10^9 \u2264 a_i \u2264 10^9) \u2014 the array elements themselves.\\n\\nThe third line has length n and consists exclusively of the letters 'B' and\\/or 'R': ith character is 'B' if a_i is colored blue, and is 'R' if colored red.\\n\\nIt is guaranteed that the sum of n over all input sets does not exceed 2 \u22c5 10^5.\\n\\nOutput\\n\\nPrint t lines, each of which contains the answer to the corresponding test case of the input. Print YES as an answer if the corresponding array can be transformed into a permutation, and NO otherwise.\\n\\nYou can print the answer in any case (for example, the strings yEs, yes, Yes, and YES will be recognized as a positive answer).\\n\\nExample\\n\\nInput\\n\\n\\n8\\n4\\n1 2 5 2\\nBRBR\\n2\\n1 1\\nBB\\n5\\n3 1 4 2 5\\nRBRRB\\n5\\n3 1 3 1 3\\nRBRRB\\n5\\n5 1 5 1 5\\nRBRRB\\n4\\n2 2 2 2\\nBRBR\\n2\\n1 -2\\nBR\\n4\\n-2...\\nUsing python3 can you solve the prior task?\",\"targets\":\"for t in range(int(input())):\\n    n= int(input())\\n    lis = list(map(int, input().split()))\\n    s=input()\\n    red=[]\\n    blue=[]\\n    for i in range(n):\\n        if s[i] == \\\"R\\\":\\n            red.append(lis[i])\\n        else:\\n            blue.append(lis[i])\\n    red.sort()\\n    blue.sort()\\n    r_pointer=b_pointer=0\\n    val=1\\n    flag=0\\n    #print(red,blue,n)\\n    while (r_pointer<len(red) or b_pointer<len(blue)) and val<=n:\\n        #print(r_pointer,b_pointer,val)\\n        if b_pointer<len(blue) and blue[b_pointer] >= val:\\n            b_pointer+=1\\n        elif r_pointer<len(red) and red[r_pointer] <= val:\\n            r_pointer+=1\\n        else:\\n            flag=1\\n            break\\n        val+=1\\n    #print(val)\\n    if flag==1 or val<n:\\n        print(\\\"NO\\\")\\n    else:\\n        print(\\\"YES\\\")\",\"language\":\"python\",\"split\":\"test\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You are given a sequence of n integers a_1,   a_2,   ...,   a_n.\\n\\nDoes there exist a sequence of n integers b_1,   b_2,   ...,   b_n such that the following property holds?\\n\\n  * For each 1 \u2264 i \u2264 n, there exist two (not necessarily distinct) indices j and k (1 \u2264 j,   k \u2264 n) such that a_i = b_j - b_k. \\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 20) \u2014 the number of test cases. Then t test cases follow.\\n\\nThe first line of each test case contains one integer n (1 \u2264 n \u2264 10).\\n\\nThe second line of each test case contains the n integers a_1,   ...,   a_n (-10^5 \u2264 a_i \u2264 10^5).\\n\\nOutput\\n\\nFor each test case, output a line containing YES if a sequence b_1,   ...,   b_n satisfying the required property exists, and NO otherwise.\\n\\nExample\\n\\nInput\\n\\n\\n5\\n5\\n4 -7 -1 5 10\\n1\\n0\\n3\\n1 10 100\\n4\\n-3 2 10 2\\n9\\n25 -171 250 174 152 242 100 -205 -258\\n\\n\\nOutput\\n\\n\\nYES\\nYES\\nNO\\nYES\\nYES\\n\\nNote\\n\\nIn the first test case, the sequence b = [-9,   2,   1,   3,   -2] satisfies the property. Indeed, the following holds: \\n\\n  * a_1 = 4 = 2 - (-2) = b_2 - b_5; \\n  * a_2 = -7 = -9 - (-2) = b_1 - b_5; \\n  * a_3 = -1 = 1 - 2 = b_3 - b_2; \\n  * a_4 = 5 = 3 - (-2) = b_4 - b_5; \\n  * a_5 = 10 = 1 - (-9) = b_3 - b_1. \\n\\n\\n\\nIn the second test case, it is sufficient to choose b = [0], since a_1 = 0 = 0 - 0 = b_1 - b_1.\\n\\nIn the third test case, it is possible to show that no sequence b of length 3 satisfies the property.\\nimpor\",\"targets\":\"t sys\\nimport bisect\\nfrom bisect import bisect_left as lb\\nfrom bisect import bisect_right as rb\\ninput_=lambda: sys.stdin.readline().strip(\\\"\\\\r\\\\n\\\")\\nfrom math import log\\nfrom math import gcd\\nfrom math import atan2,acos\\nfrom random import randint\\nsa=lambda :input_()\\nsb=lambda:int(input_())\\nsc=lambda:input_().split()\\nsd=lambda:list(map(int,input_().split()))\\nsflo=lambda:list(map(float,input_().split()))\\nse=lambda:float(input_())\\nsf=lambda:list(input_())\\nflsh=lambda: sys.stdout.flush()\\n#sys.setrecursionlimit(10**6)\\nmod=10**9+7\\nmod1=998244353\\ngp=[]\\ncost=[]\\ndp=[]\\nmx=[]\\nans1=[]\\nans2=[]\\nspecial=[]\\nspecnode=[]\\na=0\\nkthpar=[]\\ndef dfs2(root,par):\\n    if par!=-1:\\n        dp[root]=dp[par]+1\\n    for i in range(1,20):\\n        if kthpar[root][i-1]!=-1:\\n            kthpar[root][i]=kthpar[kthpar[root][i-1]][i-1]\\n    for child in gp[root]:\\n        if child==par:continue\\n        kthpar[child][0]=root\\n        dfs(child,root)\\n        \\nans=0\\nb=[]\\nvis=[]\\ntot=0\\ntime=[]\\ntime1=[]\\nadj=[]\\nmx=-1\\ndef dfs(a,b,p,c):\\n    if a==b:\\n        return c\\n    for i,j in adj[a]:\\n        if i==p:continue\\n        temp=dfs(i,b,a,c+j)\\n        if dfs(i,b,a):\\n            mx=max(i,mx)\\n            return 1\\na=[]\\nn=0\\ndef recur(ind,s,c):\\n    if ind==n:\\n        if s==0 and c==1:\\n            return True\\n        else:\\n            return False\\n    if recur(ind+1,s,c):\\n        return True\\n    if recur(ind+1,s+a[ind],1):\\n        return True\\n    if recur(ind+1,s-a[ind],1):\\n        return True\\n    return False\\ndef hnbhai(tc):\\n    global a,n\\n    n=sb()\\n    a=sd()\\n    if recur(0,0,0):\\n        print(\\\"YES\\\")\\n        return\\n    print(\\\"NO\\\")\\ndef dfs(root):\\n    global tot,vis,gp\\n    for child in gp[root]:\\n        if vis[child]==0:\\n            tot+=1\\n            vis[child]=1\\n            dfs(child)\\nfor _ in range(sb()):\\n    hnbhai(_+1)\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in CPP?\\nGiven are N points on the circumference of a circle centered at (0,0) in an xy-plane. The coordinates of the i-th point are (\\\\cos(\\\\frac{2\\\\pi T_i}{L}),\\\\sin(\\\\frac{2\\\\pi T_i}{L})).\\n\\nThree distinct points will be chosen uniformly at random from these N points. Find the expected x- and y-coordinates of the center of the circle inscribed in the triangle formed by the chosen points.\\n\\nConstraints\\n\\n* 3 \\\\leq N \\\\leq 3000\\n* N \\\\leq L \\\\leq 10^9\\n* 0 \\\\leq T_i \\\\leq L-1\\n* T_i<T_{i+1}\\n* All values in input are integers.\\n\\nInput\\n\\nInput is given from Standard Input in the following format:\\n\\n\\nN L\\nT_1\\n:\\nT_N\\n\\n\\nOutput\\n\\nPrint the expected x- and y-coordinates of the center of the circle inscribed in the triangle formed by the chosen points. Your output will be considered correct when the absolute or relative error is at most 10^{-9}.\\n\\nExamples\\n\\nInput\\n\\n3 4\\n0\\n1\\n3\\n\\n\\nOutput\\n\\n0.414213562373095 -0.000000000000000\\n\\n\\nInput\\n\\n4 8\\n1\\n3\\n5\\n6\\n\\n\\nOutput\\n\\n-0.229401949926902 -0.153281482438188\\n\\n\\nInput\\n\\n10 100\\n2\\n11\\n35\\n42\\n54\\n69\\n89\\n91\\n93\\n99\\n\\n\\nOutput\\n\\n0.352886583546338 -0.109065017701873\",\"targets\":\"\\/*\\n * @Author: RBQRBQ\\n * @Date: 2020-04-10 22:42:18\\n * @LastEditors: RBQRBQ\\n * @LastEditTime: 2020-04-12 23:54:47\\n *\\/\\n#include<bits\\/stdc++.h>\\nusing namespace std;\\ntypedef long long ll;\\ntypedef vector<int> VI;\\ntypedef pair<int,int> pii;\\nnamespace IO{\\n    template<typename T>inline void read(T &x){\\n        x=0;ll f=1;char ch=getchar();\\n        while(!isdigit(ch)){if(ch=='-')f=-f;ch=getchar();}\\n        while(isdigit(ch)){x=x*10+ch-48;ch=getchar();}\\n        x=x*f;\\n    }\\n}\\nusing namespace IO;\\nll N;\\nlong double L;\\nconst int maxn=5000;\\nlong double T[maxn];\\n\\n#define pi 3.14159265358979323846\\nint main()\\n{\\n    cin>>N>>L;\\n    for(int i=1;i<=N;i++)\\n    cin>>T[i];\\n    long double rx=0.0,ry=0.0;\\n    for(int i=1;i<=N;i++)\\n    for(int j=i+1;j<=N;j++)\\n    {\\n        rx+=(N-2*j+2*i)*cos((long double)2*pi*(T[j]+T[i])\\/(long double )(2.0*L));\\n        ry+=(N-2*j+2*i)*sin((long double)2*pi*(T[j]+T[i])\\/(long double)(2.0*L));\\n    }\\n    cout<<fixed<<setprecision(13)<<(long double)(6*rx)\\/(long double)((N)*(N-1)*(N-2))<<\\\" \\\"<<(long double)(6*ry)\\/(long double)((N)*(N-1)*(N-2));\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You are given n dominoes. Each domino has a left and a right cell. Each cell can be colored either black or white. Some cells are already colored, while some aren't yet.\\n\\nThe coloring is said to be valid if and only if it is possible to rearrange the dominoes in some order such that for each 1 \u2264 i \u2264 n the color of the right cell of the i-th domino is different from the color of the left cell of the ((i mod n)+1)-st domino. \\n\\nNote that you can't rotate the dominoes, so the left cell always remains the left cell, and the right cell always remains the right cell.\\n\\nCount the number of valid ways to color the yet uncolored cells of dominoes. Two ways are considered different if there is a cell that is colored white in one way and black in the other. In particular, colorings BW WB and WB BW different (and both invalid).\\n\\nAs this number can be very big, output it modulo 998 244 353.\\n\\nInput\\n\\nThe first line of the input contains a single integer n (1 \u2264 n \u2264 10^5) \u2014 the number of dominoes.\\n\\nThe next n lines describe dominoes. Each line contains two characters which represent the left and the right cell. Character B means that the corresponding cell is black, character W means that the corresponding cell is white, and ? means that the cell is yet to be colored. \\n\\nOutput\\n\\nPrint a single integer \u2014 the answer to the problem.\\n\\nExamples\\n\\nInput\\n\\n\\n1\\n?W\\n\\n\\nOutput\\n\\n\\n1\\n\\n\\nInput\\n\\n\\n2\\n??\\nW?\\n\\n\\nOutput\\n\\n\\n2\\n\\n\\nInput\\n\\n\\n4\\nBB\\n??\\nW?\\n??\\n\\n\\nOutput\\n\\n\\n10\\n\\nNote\\n\\nIn the first test case, there is only one domino, and we need the color of its right cell to be different from the color of its left cell. There is only one way to achieve this.\\n\\nIn the second test case, there are only 2 such colorings:\\n\\nBB WW and WB WB.\\nimpor\",\"targets\":\"t java.io.*;\\nimport java.util.*;\\n\\npublic class Main {\\n\\n\\tstatic final int MOD = 998244353;\\n\\t\\n\\tpublic static void main(String[] args) {\\n\\t\\tFastScanner fs=new FastScanner();\\n\\t\\tPrintWriter out = new PrintWriter(System.out);\\n\\n\\t\\t\\/******  CODE STARTS HERE  *****\\/\\n\\t\\t\\/\\/--------------------------------------------------------------------------------------------------------\\n\\t\\t\\n\\t\\t\\tint n=fs.nextInt();\\n\\t\\t\\tint f1=0, f2=0;\\n\\t\\t\\tchar[][] s = new char[n][2];\\n\\t\\t\\tfor(int i=0; i<n; i++)s[i]=fs.next().toCharArray();\\n\\t\\t\\t\\n\\t\\t\\tint cw=0, cb=0, emp=2, wl=0, bl=0, wr=0, br=0;\\n\\t\\t\\tlong cc = 1;\\n\\t\\t\\tfor(int i=0; i<n; i++) {\\n\\t\\t\\t\\tif(s[i][0]=='?' && s[i][1]=='?') {\\n\\t\\t\\t\\t\\tcc = (cc*2)%MOD;\\n\\t\\t\\t\\t\\tcontinue;\\n\\t\\t\\t\\t}\\n\\t\\t\\t\\temp = 1;\\n\\t\\t\\t\\t\\n\\t\\t\\t\\tif(s[i][0] == s[i][1] && s[i][0]!='?')f1=1;\\n\\t\\t\\t\\tif(s[i][0]=='W') {\\n\\t\\t\\t\\t\\tcw++;\\n\\t\\t\\t\\t\\twl=1;\\n\\t\\t\\t\\t}\\n\\t\\t\\t\\telse if(s[i][0]=='B') {\\n\\t\\t\\t\\t\\tbl=1;\\n\\t\\t\\t\\t\\tcb++;\\n\\t\\t\\t\\t}\\n\\t\\t\\t\\tif(s[i][1]=='W') {\\n\\t\\t\\t\\t\\tcw++;\\n\\t\\t\\t\\t\\twr=1;\\n\\t\\t\\t\\t}\\n\\t\\t\\t\\telse if(s[i][1]=='B') {\\n\\t\\t\\t\\t\\tcb++;\\n\\t\\t\\t\\t\\tbr=1;\\n\\t\\t\\t\\t}\\n\\t\\t\\t}\\n\\t\\t\\tif(n+n-cw-cb < 0 || cb>n || cw>n) {\\n\\t\\t\\t\\tSystem.out.println(0);\\n\\t\\t\\t\\treturn;\\n\\t\\t\\t}\\n\\t\\t\\t\\n\\t\\t\\tif((wl==1&&wr==1) || (bl==1&&br==1))emp=0;\\n\\t\\t\\t\\n\\t\\t\\tlong ans = nCrModPFermat(n+n-cw-cb, n-cw, MOD);\\n\\t\\t\\t\\n\\t\\t\\tif(f1==1) {\\n\\t\\t\\t\\tSystem.out.println(ans);\\n\\t\\t\\t}else {\\n\\t\\t\\t\\tSystem.out.println(((ans-cc)%MOD+emp)%MOD);\\n\\t\\t\\t}\\n\\t\\tout.close();\\n\\t}\\n\\t\\n\\t\\n\\t\\/* Iterative Function to calculate\\n    (x^y)%p in O(log y) *\\/\\n    static long power(long x, int y, int p)\\n    {\\n \\n        \\/\\/ Initialize result\\n        long res = 1;\\n \\n        \\/\\/ Update x if it is more than or\\n        \\/\\/ equal to p\\n        x = x % p;\\n \\n        while (y > 0) {\\n \\n            \\/\\/ If y is odd, multiply x\\n            \\/\\/ with result\\n            if (y % 2 == 1)\\n                res = (res * x) % p;\\n \\n            \\/\\/ y must be even now\\n            y = y >> 1; \\/\\/ y = y\\/2\\n            x = (x * x) % p;\\n        }\\n \\n        return res;\\n    }\\n \\n    \\/\\/ Returns n^(-1) mod p\\n    static long modInverse(long n, int p)\\n    {\\n        return power(n, p - 2, p);\\n    }\\n \\n    \\/\\/ Returns nCr % p using Fermat's\\n    \\/\\/ little theorem.\\n    static long...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"PYTHON3 solution for \\\"A binary string is a string that consists of characters 0 and 1. A bi-table is a table that has exactly two rows of equal length, each being a binary string.\\n\\nLet \\\\operatorname{MEX} of a bi-table be the smallest digit among 0, 1, or 2 that does not occur in the bi-table. For example, \\\\operatorname{MEX} for \\\\begin{bmatrix} 0011\\\\\\\\\\\\ 1010 \\\\end{bmatrix} is 2, because 0 and 1 occur in the bi-table at least once. \\\\operatorname{MEX} for \\\\begin{bmatrix} 111\\\\\\\\\\\\ 111 \\\\end{bmatrix} is 0, because 0 and 2 do not occur in the bi-table, and 0 < 2.\\n\\nYou are given a bi-table with n columns. You should cut it into any number of bi-tables (each consisting of consecutive columns) so that each column is in exactly one bi-table. It is possible to cut the bi-table into a single bi-table \u2014 the whole bi-table.\\n\\nWhat is the maximal sum of \\\\operatorname{MEX} of all resulting bi-tables can be?\\n\\nInput\\n\\nThe input consists of multiple test cases. The first line contains a single integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases. Description of the test cases follows.\\n\\nThe first line of the description of each test case contains a single integer n (1 \u2264 n \u2264 10^5) \u2014 the number of columns in the bi-table.\\n\\nEach of the next two lines contains a binary string of length n \u2014 the rows of the bi-table.\\n\\nIt's guaranteed that the sum of n over all test cases does not exceed 10^5.\\n\\nOutput\\n\\nFor each test case print a single integer \u2014 the maximal sum of \\\\operatorname{MEX} of all bi-tables that it is possible to get by cutting the given bi-table optimally.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n7\\n0101000\\n1101100\\n5\\n01100\\n10101\\n2\\n01\\n01\\n6\\n000000\\n111111\\n\\n\\nOutput\\n\\n\\n8\\n8\\n2\\n12\\n\\nNote\\n\\nIn the first test case you can cut the bi-table as follows:\\n\\n  * \\\\begin{bmatrix} 0\\\\\\\\\\\\ 1 \\\\end{bmatrix}, its \\\\operatorname{MEX} is 2.\\n  * \\\\begin{bmatrix} 10\\\\\\\\\\\\ 10 \\\\end{bmatrix}, its \\\\operatorname{MEX} is 2.\\n  * \\\\begin{bmatrix} 1\\\\\\\\\\\\ 1 \\\\end{bmatrix}, its \\\\operatorname{MEX} is 0.\\n  * \\\\begin{bmatrix} 0\\\\\\\\\\\\ 1 \\\\end{bmatrix}, its \\\\operatorname{MEX} is 2.\\n  * \\\\begin{bmatrix} 0\\\\\\\\\\\\ 0 \\\\end{bmatrix}, its...\\\":\",\"targets\":\"TESTS = int(input())\\n\\nfor t in range(TESTS):\\n\\tsize = int(input())\\n\\tA = [int(x) for x in input()]\\n\\tB = [int(x) for x in input()]\\n\\t\\n\\tmex = 0\\n\\tprevious = -1\\n\\tfor i in range(size):\\n\\t\\ta, b = A[i], B[i]\\n\\t\\tif a != b:\\n\\t\\t\\tmex += 2\\n\\t\\t\\tprevious = -1\\n\\t\\t\\tcontinue\\n\\t\\tif a+b == 0:\\n\\t\\t\\tmex += 1\\n\\t\\t\\tif previous == 1:\\n\\t\\t\\t\\tmex += 1\\n\\t\\t\\t\\tprevious = -1\\n\\t\\t\\telse:\\n\\t\\t\\t\\tprevious = 0\\n\\t\\tif a+b == 2:\\n\\t\\t\\tif previous == 0:\\n\\t\\t\\t\\tmex += 1\\n\\t\\t\\t\\tprevious = -1\\n\\t\\t\\telse:\\n\\t\\t\\t\\tprevious = 1\\n\\tprint(mex)\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in CPP?\\nMishka has got n empty boxes. For every i (1 \u2264 i \u2264 n), i-th box is a cube with side length ai.\\n\\nMishka can put a box i into another box j if the following conditions are met:\\n\\n  * i-th box is not put into another box; \\n  * j-th box doesn't contain any other boxes; \\n  * box i is smaller than box j (ai < aj). \\n\\n\\n\\nMishka can put boxes into each other an arbitrary number of times. He wants to minimize the number of visible boxes. A box is called visible iff it is not put into some another box.\\n\\nHelp Mishka to determine the minimum possible number of visible boxes!\\n\\nInput\\n\\nThe first line contains one integer n (1 \u2264 n \u2264 5000) \u2014 the number of boxes Mishka has got.\\n\\nThe second line contains n integers a1, a2, ..., an (1 \u2264 ai \u2264 109), where ai is the side length of i-th box.\\n\\nOutput\\n\\nPrint the minimum possible number of visible boxes.\\n\\nExamples\\n\\nInput\\n\\n3\\n1 2 3\\n\\n\\nOutput\\n\\n1\\n\\n\\nInput\\n\\n4\\n4 2 4 3\\n\\n\\nOutput\\n\\n2\\n\\nNote\\n\\nIn the first example it is possible to put box 1 into box 2, and 2 into 3.\\n\\nIn the second example Mishka can put box 2 into box 3, and box 4 into box 1.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint n, a[5005];\\nint check[5005];\\nint main() {\\n  cin >> n;\\n  for (int i = 1; i <= n; ++i) {\\n    cin >> a[i];\\n  }\\n  sort(a + 1, a + n + 1);\\n  memset(check, false, sizeof check);\\n  int d = 0;\\n  for (int i = 1; i <= n; ++i) {\\n    if (!check[i]) {\\n      ++d;\\n      check[i] = true;\\n      int x = a[i];\\n      for (int j = i + 1; j <= n; ++j) {\\n        if (a[j] > x && !check[j]) {\\n          check[j] = true;\\n          x = a[j];\\n        }\\n      }\\n    }\\n  }\\n  cout << d;\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in CPP?\\nInstructors of Some Informatics School make students go to bed.\\n\\nThe house contains n rooms, in each room exactly b students were supposed to sleep. However, at the time of curfew it happened that many students are not located in their assigned rooms. The rooms are arranged in a row and numbered from 1 to n. Initially, in i-th room there are ai students. All students are currently somewhere in the house, therefore a1 + a2 + ... + an = nb. Also 2 instructors live in this house.\\n\\nThe process of curfew enforcement is the following. One instructor starts near room 1 and moves toward room n, while the second instructor starts near room n and moves toward room 1. After processing current room, each instructor moves on to the next one. Both instructors enter rooms and move simultaneously, if n is odd, then only the first instructor processes the middle room. When all rooms are processed, the process ends.\\n\\nWhen an instructor processes a room, she counts the number of students in the room, then turns off the light, and locks the room. Also, if the number of students inside the processed room is not equal to b, the instructor writes down the number of this room into her notebook (and turns off the light, and locks the room). Instructors are in a hurry (to prepare the study plan for the next day), so they don't care about who is in the room, but only about the number of students.\\n\\nWhile instructors are inside the rooms, students can run between rooms that are not locked and not being processed. A student can run by at most d rooms, that is she can move to a room with number that differs my at most d. Also, after (or instead of) running each student can hide under a bed in a room she is in. In this case the instructor will not count her during the processing. In each room any number of students can hide simultaneously.\\n\\nFormally, here is what's happening:\\n\\n  * A curfew is announced, at this point in room i there are ai students. \\n  * Each student can run to another room but not further than d rooms away from her initial...\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst int NMAX = 100010;\\nint N, D, B;\\nint V[NMAX], leftSum[NMAX], rightSum[NMAX];\\nint computeLeft(int kStud) {\\n  int prefixSum = 0;\\n  int answer = 0;\\n  for (int i = 1; i <= (N + 1) \\/ 2; ++i) {\\n    int right = i + 1ll * D * i <= N ? i + D * i : N;\\n    if (leftSum[right] - prefixSum >= B && prefixSum + B <= kStud) {\\n      prefixSum += B;\\n    } else {\\n      ++answer;\\n    }\\n  }\\n  return answer;\\n}\\nint computeRight(int kStud) {\\n  int suffixSum = 0;\\n  int answer = 0;\\n  for (int i = N; i > (N + 1) \\/ 2; --i) {\\n    int left = i - 1ll * D * (N - i + 1) >= 1 ? i - D * (N - i + 1) : 1;\\n    if (rightSum[left] - suffixSum >= B && suffixSum + B <= kStud) {\\n      suffixSum += B;\\n    } else {\\n      ++answer;\\n    }\\n  }\\n  return answer;\\n}\\nint main() {\\n  cin >> N >> D >> B;\\n  for (int i = 1; i <= N; ++i) {\\n    cin >> V[i];\\n  }\\n  for (int i = 1; i <= N; ++i) {\\n    leftSum[i] = leftSum[i - 1] + V[i];\\n    rightSum[N - i + 1] = rightSum[N - i + 2] + V[N - i + 1];\\n  }\\n  int currAnswer = 0;\\n  for (int i = 30; i >= 0; --i) {\\n    if (computeLeft(currAnswer | (1 << i)) -\\n            computeRight(N * B - (currAnswer | (1 << i))) >=\\n        0) {\\n      currAnswer |= 1 << i;\\n    }\\n  }\\n  cout << min(max(computeLeft(currAnswer), computeRight(N * B - currAnswer)),\\n              max(computeLeft(currAnswer + 1),\\n                  computeRight(N * B - currAnswer - 1)))\\n       << '\\\\n';\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Consider writing each of the integers from 1 to N \\\\times M in a grid with N rows and M columns, without duplicates. Takahashi thinks it is not fun enough, and he will write the numbers under the following conditions:\\n\\n* The largest among the values in the i-th row (1 \\\\leq i \\\\leq N) is A_i.\\n* The largest among the values in the j-th column (1 \\\\leq j \\\\leq M) is B_j.\\n\\n\\n\\nFor him, find the number of ways to write the numbers under these conditions, modulo 10^9 + 7.\\n\\nConstraints\\n\\n* 1 \\\\leq N \\\\leq 1000\\n* 1 \\\\leq M \\\\leq 1000\\n* 1 \\\\leq A_i \\\\leq N \\\\times M\\n* 1 \\\\leq B_j \\\\leq N \\\\times M\\n* A_i and B_j are integers.\\n\\nInput\\n\\nInput is given from Standard Input in the following format:\\n\\n\\nN M\\nA_1 A_2 ... A_{N}\\nB_1 B_2 ... B_{M}\\n\\n\\nOutput\\n\\nPrint the number of ways to write the numbers under the conditions, modulo 10^9 + 7.\\n\\nExamples\\n\\nInput\\n\\n2 2\\n4 3\\n3 4\\n\\n\\nOutput\\n\\n2\\n\\n\\nInput\\n\\n3 3\\n5 9 7\\n3 6 9\\n\\n\\nOutput\\n\\n0\\n\\n\\nInput\\n\\n2 2\\n4 4\\n4 4\\n\\n\\nOutput\\n\\n0\\n\\n\\nInput\\n\\n14 13\\n158 167 181 147 178 151 179 182 176 169 180 129 175 168\\n181 150 178 179 167 180 176 169 182 177 175 159 173\\n\\n\\nOutput\\n\\n343772227\\nUsing python3 can you solve the prior task?\",\"targets\":\"P=10**9+7\\nN,M=map(int,input().split())\\nX=sorted([int(i) for i in input().split()])\\nY=sorted([int(i) for i in input().split()])\\nA=[i for i in X]\\nB=[i for i in Y]\\nif len(set(A))!=N or len(set(B))!=M:\\n    print(0)\\n    exit()\\nL=[]\\nx=0\\ny=0\\nD=N*M\\nwhile(len(A)>0 and len(B)>0):\\n    if max(A[-1],B[-1])==D:\\n        if A[-1]>B[-1]:\\n            A.pop()\\n            L.append(y)\\n            x+=1\\n        elif A[-1]<B[-1]:\\n            B.pop()\\n            L.append(x)\\n            y+=1\\n        else:\\n            A.pop()\\n            B.pop()\\n            x+=1\\n            y+=1\\n        D-=1\\n    else:\\n        C=max(A[-1],B[-1])+1\\n        tmp=x*y-(N*M-D)\\n        for i in range(C,D+1)[::-1]:\\n            L.append(tmp)\\n            tmp-=1\\n        D=max(A[-1],B[-1])\\nif len(A)>0:\\n    D=min(Y)-1\\n    while(len(A)>0):\\n        C=A[-1]+1\\n        tmp=x*y-(N*M-D)\\n        for i in range(C,D+1)[::-1]:\\n            L.append(tmp)\\n            tmp-=1\\n        D=A.pop()-1\\n        x+=1\\n        L.append(M)\\nif len(B)>0:\\n    D=min(X)-1\\n    while(len(B)>0):\\n        C=B[-1]+1\\n        tmp=x*y-(N*M-D)\\n        for i in range(C,D+1)[::-1]:\\n            L.append(tmp)\\n            tmp-=1\\n        D=B.pop()-1\\n        y+=1\\n        L.append(N)\\nm=min(min(X),min(Y))-1\\nfor i in range(1,m+1):\\n    L.append(i)\\nans=1\\nfor i in L:\\n    ans*=i\\n    ans%=P\\nprint(ans)\",\"language\":\"python\",\"split\":\"train\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in CPP?\\nMisha hacked the Codeforces site. Then he decided to let all the users change their handles. A user can now change his handle any number of times. But each new handle must not be equal to any handle that is already used or that was used at some point.\\n\\nMisha has a list of handle change requests. After completing the requests he wants to understand the relation between the original and the new handles of the users. Help him to do that.\\n\\nInput\\n\\nThe first line contains integer q (1 \u2264 q \u2264 1000), the number of handle change requests.\\n\\nNext q lines contain the descriptions of the requests, one per line.\\n\\nEach query consists of two non-empty strings old and new, separated by a space. The strings consist of lowercase and uppercase Latin letters and digits. Strings old and new are distinct. The lengths of the strings do not exceed 20.\\n\\nThe requests are given chronologically. In other words, by the moment of a query there is a single person with handle old, and handle new is not used and has not been used by anyone.\\n\\nOutput\\n\\nIn the first line output the integer n \u2014 the number of users that changed their handles at least once.\\n\\nIn the next n lines print the mapping between the old and the new handles of the users. Each of them must contain two strings, old and new, separated by a space, meaning that before the user had handle old, and after all the requests are completed, his handle is new. You may output lines in any order.\\n\\nEach user who changes the handle must occur exactly once in this description.\\n\\nExamples\\n\\nInput\\n\\n5\\nMisha ILoveCodeforces\\nVasya Petrov\\nPetrov VasyaPetrov123\\nILoveCodeforces MikeMirzayanov\\nPetya Ivanov\\n\\n\\nOutput\\n\\n3\\nPetya Ivanov\\nMisha MikeMirzayanov\\nVasya VasyaPetrov123\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst int N = 2e5 + 5;\\nint main() {\\n  ios_base::sync_with_stdio(0);\\n  cin.tie(0);\\n  cout.tie(0);\\n  int n, str_cnt = 0;\\n  cin >> n;\\n  vector<pair<string, string> > vps;\\n  map<string, int> m;\\n  for (int i = 0; i < n; ++i) {\\n    string str1, str2;\\n    cin >> str1 >> str2;\\n    if (!m[str1]) {\\n      vps.push_back({str1, str2});\\n      m[str1] = m[str2] = ++str_cnt;\\n    } else {\\n      m[str2] = m[str1];\\n      vps[m[str1] - 1].second = str2;\\n    }\\n  }\\n  cout << str_cnt << \\\"\\\\n\\\";\\n  for (int i = 0; i < str_cnt; ++i)\\n    cout << vps[i].first << \\\" \\\" << vps[i].second << \\\"\\\\n\\\";\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"In a certain video game, the player controls a hero characterized by a single integer value: power. The hero will have to beat monsters that are also characterized by a single integer value: armor.\\n\\nOn the current level, the hero is facing n caves. To pass the level, the hero must enter all the caves in some order, each cave exactly once, and exit every cave safe and sound. When the hero enters cave i, he will have to fight k_i monsters in a row: first a monster with armor a_{i, 1}, then a monster with armor a_{i, 2} and so on, finally, a monster with armor a_{i, k_i}.\\n\\nThe hero can beat a monster if and only if the hero's power is strictly greater than the monster's armor. If the hero can't beat the monster he's fighting, the game ends and the player loses. Note that once the hero enters a cave, he can't exit it before he fights all the monsters in it, strictly in the given order.\\n\\nEach time the hero beats a monster, the hero's power increases by 1.\\n\\nFind the smallest possible power the hero must start the level with to be able to enter all the caves in some order and beat all the monsters.\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 10^5). Description of the test cases follows.\\n\\nThe first line of each test case contains a single integer n (1 \u2264 n \u2264 10^5) \u2014 the number of caves.\\n\\nThe i-th of the next n lines contains an integer k_i (1 \u2264 k_i \u2264 10^5) \u2014 the number of monsters in the i-th cave, followed by k_i integers a_{i, 1}, a_{i, 2}, \u2026, a_{i, k_i} (1 \u2264 a_{i, j} \u2264 10^9) \u2014 armor levels of the monsters in cave i in order the hero has to fight them.\\n\\nIt is guaranteed that the sum of k_i over all test cases does not exceed 10^5.\\n\\nOutput\\n\\nFor each test case print a single integer \u2014 the smallest possible power the hero must start the level with to be able to enter all the caves in some order and beat all the monsters.\\n\\nExample\\n\\nInput\\n\\n\\n2\\n1\\n1 42\\n2\\n3 10 15 8\\n2 12 11\\n\\n\\nOutput\\n\\n\\n43\\n13\\n\\nNote\\n\\nIn the first test case, the hero has to beat a single monster with...\\nimpor\",\"targets\":\"t java.util.*;\\npublic class Test2 {\\n\\tpublic static void main(String[] args) {\\n\\t\\tScanner sc=new Scanner(System.in);\\n\\t\\tint t=sc.nextInt();\\n\\t\\twhile(t-->0) {\\n\\t\\t\\tint n=sc.nextInt();\\n\\t\\t\\tArrayList<ArrayList<Integer>> arr=new ArrayList<>(n);\\n\\t\\t\\tfor(int i=0;i<n;i++) {\\n\\t\\t\\t\\tint k=sc.nextInt();\\n\\t\\t\\t\\tArrayList<Integer> list=new ArrayList<>(k);\\n\\t\\t\\t\\tfor(int j=0;j<k;j++)\\n\\t\\t\\t\\t\\tlist.add(sc.nextInt());\\n\\t\\t\\t\\tarr.add(list);\\n\\t\\t\\t}\\n\\t\\t\\t\\n\\t\\t\\t\\n\\t\\t\\tArrayList<Integer> al=new ArrayList<>();\\n\\t\\t\\tfor(int i=0;i<n;i++) {\\n\\t\\t\\t\\tint b=arr.get(i).get(0);\\n\\t\\t\\t\\tfor(int j=0;j<arr.get(i).size();j++) {\\n\\t\\t\\t\\t\\tb=Math.max(b, arr.get(i).get(j)-j);\\n\\t\\t\\t\\t}\\n\\t\\t\\t\\tal.add(b);\\n\\t\\t\\t}\\n\\t\\t\\t\\n\\t\\t\\tMap<Integer,ArrayList<Integer>> map=new HashMap<>();\\n\\t\\t\\tint idx=0;\\n\\t\\t\\tfor(int x:al) {\\n\\t\\t\\t\\tArrayList<Integer> list=map.getOrDefault(x, new ArrayList<>());\\n\\t\\t\\t\\tlist.add(idx);\\n\\t\\t\\t\\tmap.put(x, list);\\n\\t\\t\\t\\tidx++;\\n\\t\\t\\t}\\n\\t\\t\\t\\n\\t\\t\\tMap<Integer,Integer> index=new HashMap<>();\\n\\t\\t\\tfor(int x:map.keySet())\\n\\t\\t\\t\\tindex.put(x,0);\\n\\t\\t\\t\\n\\t\\t\\tCollections.sort(al);\\n\\t\\t\\tint inc=0;\\n\\t\\t\\tint p=al.get(0);\\n\\t\\t\\tfor(int i=0;i<n;i++) {\\n\\t\\t\\t\\tp=Math.max(p, al.get(i)-inc);\\n\\t\\t\\t\\t\\n\\t\\t\\t\\tArrayList<Integer> get=map.get(al.get(i));\\n\\t\\t\\t\\tint j=index.get(al.get(i));\\n\\t\\t\\t\\tinc+=arr.get(get.get(j)).size();\\n\\t\\t\\t\\tindex.put(al.get(i), j+1);\\n\\t\\t\\t}\\n\\t\\t\\t\\n\\t\\t\\tint ans=p+1;\\n\\t\\t\\tSystem.out.println(ans);\\n\\t\\t}\\n\\t}\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in CPP?\\nMalek has recently found a treasure map. While he was looking for a treasure he found a locked door. There was a string s written on the door consisting of characters '(', ')' and '#'. Below there was a manual on how to open the door. After spending a long time Malek managed to decode the manual and found out that the goal is to replace each '#' with one or more ')' characters so that the final string becomes beautiful. \\n\\nBelow there was also written that a string is called beautiful if for each i (1 \u2264 i \u2264 |s|) there are no more ')' characters than '(' characters among the first i characters of s and also the total number of '(' characters is equal to the total number of ')' characters. \\n\\nHelp Malek open the door by telling him for each '#' character how many ')' characters he must replace it with.\\n\\nInput\\n\\nThe first line of the input contains a string s (1 \u2264 |s| \u2264 105). Each character of this string is one of the characters '(', ')' or '#'. It is guaranteed that s contains at least one '#' character.\\n\\nOutput\\n\\nIf there is no way of replacing '#' characters which leads to a beautiful string print  - 1. Otherwise for each character '#' print a separate line containing a positive integer, the number of ')' characters this character must be replaced with.\\n\\nIf there are several possible answers, you may output any of them.\\n\\nExamples\\n\\nInput\\n\\n(((#)((#)\\n\\n\\nOutput\\n\\n1\\n2\\n\\n\\nInput\\n\\n()((#((#(#()\\n\\n\\nOutput\\n\\n2\\n2\\n1\\n\\nInput\\n\\n#\\n\\n\\nOutput\\n\\n-1\\n\\n\\nInput\\n\\n(#)\\n\\n\\nOutput\\n\\n-1\\n\\nNote\\n\\n|s| denotes the length of the string s.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint k1 = 0, k2 = 0;\\nstring s;\\nint main() {\\n  getline(cin, s);\\n  int l = s.size();\\n  if (s[l - 1] == '(') {\\n    cout << \\\"-1\\\\n\\\";\\n    return 0;\\n  }\\n  for (int i = 0; i < l; ++i) {\\n    if (s[i] == '(')\\n      ++k1;\\n    else if (s[i] == ')')\\n      --k1;\\n    else if (s[i] == '#')\\n      ++k2;\\n    if (k2 > k1) {\\n      cout << \\\"-1\\\\n\\\";\\n      return 0;\\n    }\\n  }\\n  int kk = 0;\\n  int i = l - 1;\\n  while (s[i] != '#') {\\n    if (s[i] == ')')\\n      ++kk;\\n    else if (s[i] == '(')\\n      --kk;\\n    if (kk < 0) {\\n      cout << \\\"-1\\\\n\\\";\\n      return 0;\\n    }\\n    --i;\\n  }\\n  if (k2 > k1)\\n    cout << \\\"-1\\\\n\\\";\\n  else {\\n    for (int i = 1; i < k2; ++i) cout << \\\"1\\\\n\\\";\\n    cout << k1 - k2 + 1 << endl;\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (x, y) coordinate system.\\n\\nWe are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.\\n\\n<image>\\n\\n\\nOriginally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells. For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):\\n\\n<image>\\n\\n\\nIn the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.\\n\\nYour task is to write a program which reads a sequence of points of fall (x, y) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.\\n\\nYou may assume that the paper always consists of 10 \u00d7 10, and 0 \u2264 x < 10, 0 \u2264 y < 10.\\n\\n\\n\\nInput\\n\\n\\nx1,y1,s1\\nx2,y2,s2\\n:\\n:\\n\\n\\n(xi, yi) represents the position of the i-th drop and si denotes its size. The number of drops is less than or equal to 50.\\n\\nOutput\\n\\nPrint the number of cells whose density value is 0 in first line.\\nPrint the maximum value of density in the second line.\\n\\nExample\\n\\nInput\\n\\n2,5,3\\n3,6,1\\n3,4,2\\n4,5,2\\n3,6,3\\n2,4,1\\n\\n\\nOutput\\n\\n77\\n5\\nThe above is tricky. Write me a correct solution in PYTHON3.\",\"targets\":\"board = [[0]*10 for _ in range(10)]\\nwhile True:\\n    try:\\n        x, y, size = map(int, input().split(','))\\n    except:\\n        break\\n    small = [(-1, 0), (0, -1), (0, 0), (0, 1), (1, 0)]\\n    med = [(-1, -1), (-1, 0), (-1, 1),\\n           (0, -1), (0, 0), (0, 1),\\n           (1, -1), (1, 0), (1, 1)]\\n    large = [(-2, 0),\\n             (-1, -1), (-1, 0), (-1, 1),\\n             (0, -2), (0, -1), (0, 0), (0, 1), (0, 2),\\n             (1, -1), (1, 0), (1, 1),\\n             (2, 0)]\\n    dyx = [small, med, large][size-1]\\n    for dy, dx in dyx:\\n        ny, nx = y + dy, x + dx\\n        if 0 <= nx < 10 and 0 <= ny < 10:\\n            board[ny][nx] += 1\\n\\nprint(sum(sum(1 for i in range(10) if row[i] == 0) for row in board))\\nprint(max([max(row) for row in board]))\",\"language\":\"python\",\"split\":\"train\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"JAVA solution for \\\"Given n, find any array a_1, a_2, \u2026, a_n of integers such that all of the following conditions hold: \\n\\n  * 1 \u2264 a_i \u2264 10^9 for every i from 1 to n.\\n\\n  * a_1 < a_2 < \u2026 <a_n\\n\\n  * For every i from 2 to n, a_i isn't divisible by a_{i-1}\\n\\n\\n\\n\\nIt can be shown that such an array always exists under the constraints of the problem.\\n\\nInput\\n\\nThe first line contains the number of test cases t (1 \u2264 t \u2264 100). Description of the test cases follows.\\n\\nThe only line of each test case contains a single integer n (1 \u2264 n \u2264 1000).\\n\\nIt is guaranteed that the sum of n over all test cases does not exceed 10^4.\\n\\nOutput\\n\\nFor each test case print n integers a_1, a_2, \u2026, a_n \u2014 the array you found. If there are multiple arrays satisfying all the conditions, print any of them.\\n\\nExample\\n\\nInput\\n\\n\\n3\\n1\\n2\\n7\\n\\n\\nOutput\\n\\n\\n1\\n2 3\\n111 1111 11111 111111 1111111 11111111 111111111\\n\\nNote\\n\\nIn the first test case, array [1] satisfies all the conditions.\\n\\nIn the second test case, array [2, 3] satisfies all the conditions, as 2<3 and 3 is not divisible by 2.\\n\\nIn the third test case, array [111, 1111, 11111, 111111, 1111111, 11111111, 111111111] satisfies all the conditions, as it's increasing and a_i isn't divisible by a_{i-1} for any i from 2 to 7.\\\":\",\"targets\":\"import java.io.*;\\nimport java.io.InputStreamReader;\\nimport java.math.BigInteger;\\nimport java.net.Socket;\\nimport java.util.*;\\nimport java.util.Scanner;\\npublic class Main {\\n\\n\\n    public static void main(String[] args) throws IOException {\\n        Scanner cin=new Scanner(System.in);\\n        int t =cin.nextInt();\\n        while(t-->0)\\n        {\\n            int n=cin.nextInt();\\n            for(int i=2;i<=n+1;i++)\\n            {\\n                System.out.print(i+\\\" \\\");\\n            }\\n            System.out.println();\\n        }\\n\\n\\n\\n    }\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n    public class ListNode {\\n      int val;\\n      ListNode next;\\n     ListNode(int x) { val = x; }\\n  }\\n\\n\\n\\n\\n\\n\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in CPP?\\nBachgold problem is very easy to formulate. Given a positive integer n represent it as a sum of maximum possible number of prime numbers. One can prove that such representation exists for any integer greater than 1.\\n\\nRecall that integer k is called prime if it is greater than 1 and has exactly two positive integer divisors \u2014 1 and k. \\n\\nInput\\n\\nThe only line of the input contains a single integer n (2 \u2264 n \u2264 100 000).\\n\\nOutput\\n\\nThe first line of the output contains a single integer k \u2014 maximum possible number of primes in representation.\\n\\nThe second line should contain k primes with their sum equal to n. You can print them in any order. If there are several optimal solution, print any of them.\\n\\nExamples\\n\\nInput\\n\\n5\\n\\n\\nOutput\\n\\n2\\n2 3\\n\\n\\nInput\\n\\n6\\n\\n\\nOutput\\n\\n3\\n2 2 2\",\"targets\":\"#include <bits\\/stdc++.h>\\nint main() {\\n  long n, k = 0;\\n  scanf(\\\"%ld\\\", &n);\\n  k = n \\/ 2;\\n  printf(\\\"%ld\\\\n\\\", k);\\n  for (int i = 0; i < k; i++) {\\n    if (i == k - 1) {\\n      if (n % 2 == 0)\\n        printf(\\\"2\\\\n\\\");\\n      else\\n        printf(\\\"3\\\\n\\\");\\n    } else\\n      printf(\\\"2 \\\");\\n  }\\n  getchar();\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"A complete binary tree is a binary tree in which every internal node has two children and all leaves have the same depth. A binary tree in which if last level is not completely filled but all nodes (leaves) are pushed across to the left, is also (nearly) a complete binary tree.\\n\\nA binary heap data structure is an array that can be viewed as a nearly complete binary tree as shown in the following figure.\\n\\n<image>\\n\\n\\nEach node of a nearly complete binary tree corresponds to an element of the array that stores the value in the node. An array $A$ that represents a binary heap has the heap size $H$, the number of elements in the heap, and each element of the binary heap is stored into $A[1...H]$ respectively. The root of the tree is $A[1]$, and given the index $i$ of a node, the indices of its parent $parent(i)$, left child $left(i)$, right child $right(i)$ can be computed simply by $\\\\lfloor i \\/ 2 \\\\rfloor$, $2 \\\\times i$ and $2 \\\\times i + 1$ respectively.\\n\\nWrite a program which reads a binary heap represented by a nearly complete binary tree, and prints properties of nodes of the binary heap in the following format:\\n\\nnode $id$: key = $k$, parent key = $pk$, left key = $lk$, right key = $rk$,\\n\\n$id$, $k$, $pk$, $lk$ and $rk$ represent id (index) of the node, value of the node, value of its parent, value of its left child and value of its right child respectively. Print these properties in this order. If there are no appropriate nodes, print nothing.\\n\\nConstraints\\n\\n* $H \\\\leq 250$\\n* $-2,000,000,000 \\\\leq$ value of a node $\\\\leq 2,000,000,000$\\n\\nInput\\n\\nIn the first line, an integer $H$, the size of the binary heap, is given. In the second line, $H$ integers which correspond to values assigned to nodes of the binary heap are given in order of node id (from $1$ to $H$).\\n\\nOutput\\n\\nPrint the properties of the binary heap in the above format from node $1$ to $H$ in order. Note that, the last character of each line is a single space character.\\n\\nExample\\n\\nInput\\n\\n5\\n7 8 1 2 3\\n\\n\\nOutput\\n\\nnode 1: key = 7, left key = 8, right key = 1,\\nnode...\\\":\",\"targets\":\"#include <iostream>\\n#include <algorithm>\\nusing namespace std;\\n\\nint main(void){\\n\\tint n;\\n\\tint a[250];\\n\\tcin>>n;\\n\\tfor(int i=0;i<n;i++)cin>>a[i];\\n\\t\\/\\/ make_heap(a,a+n);\\n\\tfor(int i=0;i<n;i++){\\n\\t\\tcout<<\\\"node \\\"<<i+1<<\\\": key = \\\"<<a[i]<<\\\", \\\";\\n\\t\\tif(i!=0)cout<<\\\"parent key = \\\"<<a[(i-1)\\/2]<<\\\", \\\";\\n\\t\\tif(2*i+1<n)cout<<\\\"left key = \\\"<<a[2*i+1]<<\\\", \\\";\\n\\t\\tif(2*i+2<n)cout<<\\\"right key = \\\"<<a[2*i+2]<<\\\", \\\";\\n\\t\\tcout<<endl;\\n\\t}\\n\\treturn 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Polycarp must pay exactly n burles at the checkout. He has coins of two nominal values: 1 burle and 2 burles. Polycarp likes both kinds of coins equally. So he doesn't want to pay with more coins of one type than with the other.\\n\\nThus, Polycarp wants to minimize the difference between the count of coins of 1 burle and 2 burles being used. Help him by determining two non-negative integer values c_1 and c_2 which are the number of coins of 1 burle and 2 burles, respectively, so that the total value of that number of coins is exactly n (i. e. c_1 + 2 \u22c5 c_2 = n), and the absolute value of the difference between c_1 and c_2 is as little as possible (i. e. you must minimize |c_1-c_2|).\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases. Then t test cases follow.\\n\\nEach test case consists of one line. This line contains one integer n (1 \u2264 n \u2264 10^9) \u2014 the number of burles to be paid by Polycarp.\\n\\nOutput\\n\\nFor each test case, output a separate line containing two integers c_1 and c_2 (c_1, c_2 \u2265 0) separated by a space where c_1 is the number of coins of 1 burle and c_2 is the number of coins of 2 burles. If there are multiple optimal solutions, print any one.\\n\\nExample\\n\\nInput\\n\\n\\n6\\n1000\\n30\\n1\\n32\\n1000000000\\n5\\n\\n\\nOutput\\n\\n\\n334 333\\n10 10\\n1 0\\n10 11\\n333333334 333333333\\n1 2\\n\\nNote\\n\\nThe answer for the first test case is \\\"334 333\\\". The sum of the nominal values of all coins is 334 \u22c5 1 + 333 \u22c5 2 = 1000, whereas |334 - 333| = 1. One can't get the better value because if |c_1 - c_2| = 0, then c_1 = c_2 and c_1 \u22c5 1 + c_1 \u22c5 2 = 1000, but then the value of c_1 isn't an integer.\\n\\nThe answer for the second test case is \\\"10 10\\\". The sum of the nominal values is 10 \u22c5 1 + 10 \u22c5 2 = 30 and |10 - 10| = 0, whereas there's no number having an absolute value less than 0.\\nThe above is tricky. Write me a correct solution in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst bool testcase = 1;\\nconst long long int mod1 = 1000000007;\\nconst long long int mod2 = 998244353;\\nvoid solve(long long int& kes) {\\n  long long int n;\\n  cin >> n;\\n  long long int prt = n \\/ 3;\\n  long long int x = prt, y = prt;\\n  long long int sum = x + 2 * y;\\n  if (abs(n - sum) == 1) {\\n    x++;\\n  } else if (abs(n - sum) == 2) {\\n    y++;\\n  }\\n  cout << x << ' ' << y << '\\\\n';\\n}\\nint main() {\\n  ios_base::sync_with_stdio(0);\\n  cin.tie(NULL);\\n  long long int t = 1;\\n  int T_T = 1;\\n  if (testcase) {\\n    cin >> T_T;\\n  }\\n  while (T_T--) {\\n    solve(t);\\n    t++;\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"A telephone number is a sequence of exactly 11 digits such that its first digit is 8.\\n\\nVasya and Petya are playing a game. Initially they have a string s of length n (n is odd) consisting of digits. Vasya makes the first move, then players alternate turns. In one move the player must choose a character and erase it from the current string. For example, if the current string 1121, after the player's move it may be 112, 111 or 121. The game ends when the length of string s becomes 11. If the resulting string is a telephone number, Vasya wins, otherwise Petya wins.\\n\\nYou have to determine if Vasya has a winning strategy (that is, if Vasya can win the game no matter which characters Petya chooses during his moves).\\n\\nInput\\n\\nThe first line contains one integer n (13 \u2264 n < 10^5, n is odd) \u2014 the length of string s.\\n\\nThe second line contains the string s (|s| = n) consisting only of decimal digits.\\n\\nOutput\\n\\nIf Vasya has a strategy that guarantees him victory, print YES.\\n\\nOtherwise print NO.\\n\\nExamples\\n\\nInput\\n\\n\\n13\\n8380011223344\\n\\n\\nOutput\\n\\n\\nYES\\n\\n\\nInput\\n\\n\\n15\\n807345619350641\\n\\n\\nOutput\\n\\n\\nNO\\n\\nNote\\n\\nIn the first example Vasya needs to erase the second character. Then Petya cannot erase a character from the remaining string 880011223344 so that it does not become a telephone number.\\n\\nIn the second example after Vasya's turn Petya can erase one character character 8. The resulting string can't be a telephone number, because there is no digit 8 at all.\\nThe above is tricky. Write me a correct solution in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nvoid solve() {\\n  long long n;\\n  cin >> n;\\n  string s;\\n  cin >> s;\\n  int k = 0;\\n  for (int i = 0; i < s.size(); i++) {\\n    if (k < (n - 11) \\/ 2) {\\n      if (s[i] == '8') {\\n        k++;\\n        s[i] = '+';\\n      }\\n    } else {\\n      break;\\n    }\\n  }\\n  k = 0;\\n  for (int i = 0; i < s.size(); i++) {\\n    if (k < (n - 11) \\/ 2) {\\n      if (s[i] != '8' && s[i] != '+') {\\n        k++;\\n        s[i] = '+';\\n      }\\n    } else {\\n      break;\\n    }\\n  }\\n  int pos = 0;\\n  for (int i = 0; i < s.size(); i++) {\\n    if (s[i] != '+') {\\n      pos = i;\\n      break;\\n    }\\n  }\\n  if (s[pos] == '8') {\\n    cout << \\\"YES\\\" << endl;\\n  } else {\\n    cout << \\\"NO\\\" << endl;\\n  }\\n}\\nint main() { solve(); }\",\"language\":\"python\",\"split\":\"train\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Bachgold problem is very easy to formulate. Given a positive integer n represent it as a sum of maximum possible number of prime numbers. One can prove that such representation exists for any integer greater than 1.\\n\\nRecall that integer k is called prime if it is greater than 1 and has exactly two positive integer divisors \u2014 1 and k. \\n\\nInput\\n\\nThe only line of the input contains a single integer n (2 \u2264 n \u2264 100 000).\\n\\nOutput\\n\\nThe first line of the output contains a single integer k \u2014 maximum possible number of primes in representation.\\n\\nThe second line should contain k primes with their sum equal to n. You can print them in any order. If there are several optimal solution, print any of them.\\n\\nExamples\\n\\nInput\\n\\n5\\n\\n\\nOutput\\n\\n2\\n2 3\\n\\n\\nInput\\n\\n6\\n\\n\\nOutput\\n\\n3\\n2 2 2\\nSolve the task in PYTHON3.\",\"targets\":\"n = int(input())\\nvalue = n \\/\\/ 2\\nif n % 2 == 0:\\n\\n\\n    ans = '2' * value\\n    print(value)\\n    for i in ans:\\n\\n        print(i, end=' ')\\nelse:\\n    multiply = value - 1\\n    print(value)\\n\\n    another = 2*multiply\\n    forthree = value - multiply\\n    ans = '2' * multiply + '3' * forthree\\n    for i in ans:\\n        print(i, end=' ')\",\"language\":\"python\",\"split\":\"train\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"A bracket sequence is a string containing only characters \\\"(\\\" and \\\")\\\". 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 \\\"()()\\\" and \\\"(())\\\" are regular (the resulting expressions are: \\\"(1)+(1)\\\" and \\\"((1+1)+1)\\\"), and \\\")(\\\", \\\"(\\\" and \\\")\\\" are not.\\n\\nYou are given an integer n. Your goal is to construct and print exactly n different regular bracket sequences of length 2n.\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 50) \u2014 the number of test cases.\\n\\nEach test case consists of one line containing one integer n (1 \u2264 n \u2264 50).\\n\\nOutput\\n\\nFor each test case, print n lines, each containing a regular bracket sequence of length exactly 2n. All bracket sequences you output for a testcase should be different (though they may repeat in different test cases). If there are multiple answers, print any of them. It can be shown that it's always possible.\\n\\nExample\\n\\nInput\\n\\n\\n3\\n3\\n1\\n3\\n\\n\\nOutput\\n\\n\\n()()()\\n((()))\\n(()())\\n()\\n((()))\\n(())()\\n()(())\\nUsing python3 can you solve the prior task?\",\"targets\":\"def generateParentheses(openBr, closeBr, n, s = []):\\n    global k\\n    if k<n:\\n        if closeBr == n:\\n            k+=1\\n            print(''.join(s))\\n            return \\n\\n        if closeBr < openBr:\\n            s.append(')')\\n            generateParentheses(openBr, closeBr+1, n, s)\\n            s.pop()\\n        if openBr < n:\\n            s.append('(')\\n            generateParentheses(openBr+1, closeBr, n, s)\\n            s.pop()\\n        return\\n\\n\\nt = int(input())\\nwhile t>0:\\n    k =0\\n    n = int(input())\\n    generateParentheses(0, 0, n)\\n    t-=1\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in CPP?\\nChanek Jones is back, helping his long-lost relative Indiana Jones, to find a secret treasure in a maze buried below a desert full of illusions.\\n\\nThe map of the labyrinth forms a tree with n rooms numbered from 1 to n and n - 1 tunnels connecting them such that it is possible to travel between each pair of rooms through several tunnels.\\n\\nThe i-th room (1 \u2264 i \u2264 n) has a_i illusion rate. To go from the x-th room to the y-th room, there must exist a tunnel between x and y, and it takes max(|a_x + a_y|, |a_x - a_y|) energy. |z| denotes the absolute value of z.\\n\\nTo prevent grave robbers, the maze can change the illusion rate of any room in it. Chanek and Indiana would ask q queries.\\n\\nThere are two types of queries to be done:\\n\\n  * 1\\\\ u\\\\ c \u2014 The illusion rate of the x-th room is changed to c (1 \u2264 u \u2264 n, 0 \u2264 |c| \u2264 10^9). \\n  * 2\\\\ u\\\\ v \u2014 Chanek and Indiana ask you the minimum sum of energy needed to take the secret treasure at room v if they are initially at room u (1 \u2264 u, v \u2264 n). \\n\\n\\n\\nHelp them, so you can get a portion of the treasure!\\n\\nInput\\n\\nThe first line contains two integers n and q (2 \u2264 n \u2264 10^5, 1 \u2264 q \u2264 10^5) \u2014 the number of rooms in the maze and the number of queries.\\n\\nThe second line contains n integers a_1, a_2, \u2026, a_n (0 \u2264 |a_i| \u2264 10^9) \u2014 inital illusion rate of each room.\\n\\nThe i-th of the next n-1 lines contains two integers s_i and t_i (1 \u2264 s_i, t_i \u2264 n), meaning there is a tunnel connecting s_i-th room and t_i-th room. The given edges form a tree.\\n\\nThe next q lines contain the query as described. The given queries are valid.\\n\\nOutput\\n\\nFor each type 2 query, output a line containing an integer \u2014 the minimum sum of energy needed for Chanek and Indiana to take the secret treasure.\\n\\nExample\\n\\nInput\\n\\n\\n6 4\\n10 -9 2 -1 4 -6\\n1 5\\n5 4\\n5 6\\n6 2\\n6 3\\n2 1 2\\n1 1 -3\\n2 1 2\\n2 3 3\\n\\n\\nOutput\\n\\n\\n39\\n32\\n0\\n\\nNote\\n\\n<image>\\n\\nIn the first query, their movement from the 1-st to the 2-nd room is as follows.\\n\\n  * 1 \u2192 5 \u2014 takes max(|10 + 4|, |10 - 4|) = 14 energy. \\n  * 5 \u2192 6 \u2014 takes max(|4 + (-6)|, |4 - (-6)|) = 10 energy. \\n  * 6 \u2192 2 \u2014...\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nclass Fenwick {\\n  vector<long long> tree;\\n\\n public:\\n  Fenwick() {}\\n  Fenwick(int n, long long init) : tree(n + 5, 0) {}\\n  void add(int idx, long long val) {\\n    for (int i = idx; i < (int)tree.size(); i += i & -i) {\\n      tree[i] += val;\\n    }\\n  }\\n  long long get(int idx) {\\n    long long ans = 0;\\n    for (int i = idx; i > 0; i -= i & -i) {\\n      ans += tree[i];\\n    }\\n    return ans;\\n  }\\n  long long query(int l, int r) {\\n    long long ans = get(r) - get(l - 1);\\n    return ans;\\n  }\\n  void set(int idx, long long val) { add(idx, val - query(idx, idx)); }\\n};\\ntemplate <typename T, class DS>\\nclass HLD {\\n  int vertexc;\\n  vector<int> *adj;\\n  vector<int> subtree_size;\\n  DS structure;\\n  DS aux;\\n  void build_sizes(int vertex, int parent) {\\n    subtree_size[vertex] = 1;\\n    for (int child : adj[vertex]) {\\n      if (child != parent) {\\n        build_sizes(child, vertex);\\n        subtree_size[vertex] += subtree_size[child];\\n      }\\n    }\\n  }\\n  int cur;\\n  vector<int> ord;\\n  vector<int> chain_root;\\n  vector<int> par;\\n  void build_hld(int vertex, int parent, int chain_source) {\\n    cur++;\\n    ord[vertex] = cur;\\n    chain_root[vertex] = chain_source;\\n    par[vertex] = parent;\\n    if (adj[vertex].size() > 1 || (vertex == 1 && adj[vertex].size() == 1)) {\\n      int big_child, big_size = -1;\\n      for (int child : adj[vertex]) {\\n        if ((child != parent) && (subtree_size[child] > big_size)) {\\n          big_child = child;\\n          big_size = subtree_size[child];\\n        }\\n      }\\n      build_hld(big_child, vertex, chain_source);\\n      for (int child : adj[vertex]) {\\n        if ((child != parent) && (child != big_child))\\n          build_hld(child, vertex, child);\\n      }\\n    }\\n  }\\n\\n public:\\n  HLD(int _vertexc) {\\n    vertexc = _vertexc;\\n    adj = new vector<int>[vertexc + 5];\\n  }\\n  void add_edge(int u, int v) {\\n    adj[u].push_back(v);\\n    adj[v].push_back(u);\\n  }\\n  void build(T initial) {\\n    subtree_size = vector<int>(vertexc + 5);\\n    ord = vector<int>(vertexc + 5);\\n    chain_root =...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"There are n heroes fighting in the arena. Initially, the i-th hero has a_i health points.\\n\\nThe fight in the arena takes place in several rounds. At the beginning of each round, each alive hero deals 1 damage to all other heroes. Hits of all heroes occur simultaneously. Heroes whose health is less than 1 at the end of the round are considered killed.\\n\\nIf exactly 1 hero remains alive after a certain round, then he is declared the winner. Otherwise, there is no winner.\\n\\nYour task is to calculate the number of ways to choose the initial health points for each hero a_i, where 1 \u2264 a_i \u2264 x, so that there is no winner of the fight. The number of ways can be very large, so print it modulo 998244353. Two ways are considered different if at least one hero has a different amount of health. For example, [1, 2, 1] and [2, 1, 1] are different.\\n\\nInput\\n\\nThe only line contains two integers n and x (2 \u2264 n \u2264 500; 1 \u2264 x \u2264 500).\\n\\nOutput\\n\\nPrint one integer \u2014 the number of ways to choose the initial health points for each hero a_i, where 1 \u2264 a_i \u2264 x, so that there is no winner of the fight, taken modulo 998244353. \\n\\nExamples\\n\\nInput\\n\\n\\n2 5\\n\\n\\nOutput\\n\\n\\n5\\n\\n\\nInput\\n\\n\\n3 3\\n\\n\\nOutput\\n\\n\\n15\\n\\n\\nInput\\n\\n\\n5 4\\n\\n\\nOutput\\n\\n\\n1024\\n\\n\\nInput\\n\\n\\n13 37\\n\\n\\nOutput\\n\\n\\n976890680\\nUsing python3 can you solve the prior task?\",\"targets\":\"import sys\\ninput = lambda: sys.stdin.readline().strip()\\n\\n# sys.stdin = open('input.txt', 'r')\\n# sys.stdout = open('output.txt', 'w')\\n\\nfrom functools import lru_cache\\n\\nmod = 998244353\\n\\nmx = 505\\nfac = [1]*mx\\nfor i in range(1, mx):\\n    fac[i] = fac[i-1] * i % mod\\nifac = [1]*505\\nifac[-1] = pow(fac[-1], mod-2, mod)\\nfor i in range(mx-2, 0, -1):\\n    ifac[i] = (i+1) * ifac[i+1] % mod\\n\\ndef comb(a, b):\\n    return fac[a] * ifac[a-b] % mod * ifac[b] % mod\\n\\n@lru_cache(None)\\ndef helper(n, x):\\n    if x <= n - 1:\\n        return pow(x, n, mod)\\n    res = pow(n-1, n, mod)\\n    for j in range(2, n+1):\\n        res += comb(n, j) * helper(j, x - n + 1) * pow(n-1, n-j, mod)\\n        res %= mod\\n    return res\\n\\ndef solve():\\n    n, x = map(int, input().split())\\n    return helper(n, x)\\n\\nprint(solve())\",\"language\":\"python\",\"split\":\"test\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You are given an array a of length n.\\n\\nLet's define the eversion operation. Let x = a_n. Then array a is partitioned into two parts: left and right. The left part contains the elements of a that are not greater than x (\u2264 x). The right part contains the elements of a that are strictly greater than x (> x). The order of elements in each part is kept the same as before the operation, i. e. the partition is stable. Then the array is replaced with the concatenation of the left and the right parts.\\n\\nFor example, if the array a is [2, 4, 1, 5, 3], the eversion goes like this: [2, 4, 1, 5, 3] \u2192 [2, 1, 3], [4, 5] \u2192 [2, 1, 3, 4, 5].\\n\\nWe start with the array a and perform eversions on this array. We can prove that after several eversions the array a stops changing. Output the minimum number k such that the array stops changing after k eversions.\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 100). Description of the test cases follows.\\n\\nThe first line contains a single integer n (1 \u2264 n \u2264 2 \u22c5 10^5).\\n\\nThe second line contains n integers a_1, a_2, ..., a_n (1 \u2264 a_i \u2264 10^9).\\n\\nIt is guaranteed that the sum of n over all test cases does not exceed 2 \u22c5 10^5.\\n\\nOutput\\n\\nFor each test case print a single integer k \u2014 the number of eversions after which the array stops changing.\\n\\nExample\\n\\nInput\\n\\n\\n3\\n5\\n2 4 1 5 3\\n5\\n5 3 2 4 1\\n4\\n1 1 1 1\\n\\n\\nOutput\\n\\n\\n1\\n2\\n0\\n\\nNote\\n\\nConsider the fist example.\\n\\n  * The first eversion: a = [1, 4, 2, 5, 3], x = 3. [2, 4, 1, 5, 3] \u2192 [2, 1, 3], [4, 5] \u2192 [2, 1, 3, 4, 5]. \\n  * The second and following eversions: a = [2, 1, 3, 4, 5], x = 5. [2, 1, 3, 4, 5] \u2192 [2, 1, 3, 4, 5], [] \u2192 [2, 1, 3, 4, 5]. This eversion does not change the array, so the answer is 1. \\n\\n\\n\\nConsider the second example. \\n\\n  * The first eversion: a = [5, 3, 2, 4, 1], x = 1. [5, 3, 2, 4, 1] \u2192 [1], [5, 3, 2, 4] \u2192 [1, 5, 3, 2, 4]. \\n  * The second eversion: a = [1, 5, 3, 2, 4], x = 4. [1, 5, 3, 2, 4] \u2192 [1, 3, 2, 4], [5] \u2192 [1, 3, 2, 4, 5]. \\n  * The third and following eversions: a = [1, 3, 2, 4,...\\nUsing java can you solve the prior task?\",\"targets\":\"import javax.lang.model.type.IntersectionType;\\nimport java.sql.Array;\\nimport java.util.*;\\nimport java.io.*;\\nimport java.util.concurrent.ScheduledExecutorService;\\nimport java.util.concurrent.atomic.AtomicReferenceArray;\\nimport java.util.spi.AbstractResourceBundleProvider;\\n\\/\\/Timus judge id- 323935JJ\\n\\n\\npublic class Main {\\n    static class Pair<U, V> {\\n        public final U first;\\n        public final V second;\\n\\n        public Pair(U first, V second) {\\n            this.first = first;\\n            this.second = second;\\n        }\\n\\n        public static <U, V> Pair<U, V> of(U a, V b) {\\n            return new Pair<>(a, b);\\n        }\\n\\n        final int a = 2;\\n\\n        @Override\\n        public int hashCode() {\\n            int hash = 5;\\n            hash = 17 * hash + this.a;\\n            return hash;\\n        }\\n\\n        @Override\\n        public boolean equals(Object obj) {\\n            if (obj == null) {\\n                return false;\\n            }\\n            if (getClass() != obj.getClass()) {\\n                return false;\\n            }\\n            final Pair other = (Pair) obj;\\n            if (this.a != other.a) {\\n                return false;\\n            }\\n            return true;\\n        }\\n    }\\n\\n    \\/\\/----------------------------------------------------------------------------------------------\\n    public static class Node implements Comparable<Node> {\\n        String s;\\n        int x;\\n\\n        public Node(String str, int b) {\\n            this.s = str;\\n            this.x = b;\\n\\n        }\\n\\n        public int compareTo(Node o) {\\n            return this.x - o.x;\\n        }\\n    }\\n\\n\\n    public static int mod = (int) (1e9 + 7);\\n    static int ans = Integer.MAX_VALUE;\\n\\n    public static void main(String hi[]) throws Exception {\\n        FastReader sc = new FastReader();\\n\\n     int t =sc.nextInt();\\n     while(t-->0)\\n     {\\n         int n =sc.nextInt();\\n         int max=Integer.MIN_VALUE;\\n         int[] a = new int[n];\\n         for(int i=0;i<n;i++) {\\n             a[i] = sc.nextInt();\\n             max=Math.max(max,a[i]);\\n         }\\n...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Appleman has a very big sheet of paper. This sheet has a form of rectangle with dimensions 1 \u00d7 n. Your task is help Appleman with folding of such a sheet. Actually, you need to perform q queries. Each query will have one of the following types:\\n\\n  1. Fold the sheet of paper at position pi. After this query the leftmost part of the paper with dimensions 1 \u00d7 pi must be above the rightmost part of the paper with dimensions 1 \u00d7 ([current width of sheet] - pi). \\n  2. Count what is the total width of the paper pieces, if we will make two described later cuts and consider only the pieces between the cuts. We will make one cut at distance li from the left border of the current sheet of paper and the other at distance ri from the left border of the current sheet of paper. \\n\\n\\n\\nPlease look at the explanation of the first test example for better understanding of the problem.\\n\\nInput\\n\\nThe first line contains two integers: n and q (1 \u2264 n \u2264 105; 1 \u2264 q \u2264 105) \u2014 the width of the paper and the number of queries.\\n\\nEach of the following q lines contains one of the described queries in the following format:\\n\\n  * \\\"1 pi\\\" (1 \u2264 pi < [current width of sheet]) \u2014 the first type query. \\n  * \\\"2 li ri\\\" (0 \u2264 li < ri \u2264 [current width of sheet]) \u2014 the second type query. \\n\\nOutput\\n\\nFor each query of the second type, output the answer.\\n\\nExamples\\n\\nInput\\n\\n7 4\\n1 3\\n1 2\\n2 0 1\\n2 1 2\\n\\n\\nOutput\\n\\n4\\n3\\n\\n\\nInput\\n\\n10 9\\n2 2 9\\n1 1\\n2 0 1\\n1 8\\n2 0 8\\n1 2\\n2 1 3\\n1 4\\n2 2 4\\n\\n\\nOutput\\n\\n7\\n2\\n10\\n4\\n5\\n\\nNote\\n\\nThe pictures below show the shapes of the paper during the queries of the first example:\\n\\n<image>\\n\\nAfter the first fold operation the sheet has width equal to 4, after the second one the width of the sheet equals to 2.\\n#incl\",\"targets\":\"ude <bits\\/stdc++.h>\\nusing namespace std;\\nint n, a[100010];\\nint la, ra;\\nvoid update(int i, int delta) {\\n  for (; i < n; i = i | (i + 1)) {\\n    a[i] += delta;\\n  }\\n}\\nint get(int fr, int to) {\\n  int res = 0;\\n  for (int i = to; i >= 0; i = (i & (i + 1)) - 1) {\\n    res += a[i];\\n  }\\n  for (int i = fr - 1; i >= 0; i = (i & (i + 1)) - 1) {\\n    res -= a[i];\\n  }\\n  return res;\\n}\\nint main(void) {\\n  int q;\\n  scanf(\\\"%d%d\\\", &n, &q);\\n  for (int i = 0; i < n; ++i) {\\n    update(i, 1);\\n  }\\n  int la = 0;\\n  int ra = n;\\n  for (int i = 0; i < q; ++i) {\\n    int t;\\n    scanf(\\\"%d\\\", &t);\\n    if (t == 1) {\\n      int p, len, mid;\\n      scanf(\\\"%d\\\", &p);\\n      if (la < ra) {\\n        len = ra - la;\\n        mid = la + p;\\n      } else {\\n        len = la - ra;\\n        mid = la - p;\\n      }\\n      if (p > len \\/ 2) {\\n        swap(la, ra);\\n        p = len - p;\\n      }\\n      if (la < ra) {\\n        for (int i = 0; i < p; ++i) {\\n          update(mid + i, get(mid - 1 - i, mid - 1 - i));\\n        }\\n      } else {\\n        for (int i = 0; i < p; ++i) {\\n          update(mid - 1 - i, get(mid + i, mid + i));\\n        }\\n      }\\n      la = mid;\\n    } else {\\n      int l, r;\\n      scanf(\\\"%d%d\\\", &l, &r);\\n      if (la < ra) {\\n        l += la;\\n        r += la;\\n      } else {\\n        l = la - l;\\n        r = la - r;\\n        swap(l, r);\\n      }\\n      printf(\\\"%d\\\\n\\\", get(l, r - 1));\\n    }\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Lord Omkar would like to have a tree with n nodes (3 \u2264 n \u2264 10^5) and has asked his disciples to construct the tree. However, Lord Omkar has created m (1 \u2264 m < n) restrictions to ensure that the tree will be as heavenly as possible. \\n\\nA tree with n nodes is an connected undirected graph with n nodes and n-1 edges. Note that for any two nodes, there is exactly one simple path between them, where a simple path is a path between two nodes that does not contain any node more than once.\\n\\nHere is an example of a tree: \\n\\n<image>\\n\\nA restriction consists of 3 pairwise distinct integers, a, b, and c (1 \u2264 a,b,c \u2264 n). It signifies that node b cannot lie on the simple path between node a and node c. \\n\\nCan you help Lord Omkar and become his most trusted disciple? You will need to find heavenly trees for multiple sets of restrictions. It can be shown that a heavenly tree will always exist for any set of restrictions under the given constraints.\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 10^4). Description of the test cases follows.\\n\\nThe first line of each test case contains two integers, n and m (3 \u2264 n \u2264 10^5, 1 \u2264 m < n), representing the size of the tree and the number of restrictions.\\n\\nThe i-th of the next m lines contains three integers a_i, b_i, c_i (1 \u2264 a_i, b_i, c_i \u2264 n, a, b, c are distinct), signifying that node b_i cannot lie on the simple path between nodes a_i and c_i. \\n\\nIt is guaranteed that the sum of n across all test cases will not exceed 10^5.\\n\\nOutput\\n\\nFor each test case, output n-1 lines representing the n-1 edges in the tree. On each line, output two integers u and v (1 \u2264 u, v \u2264 n, u \u2260 v) signifying that there is an edge between nodes u and v. Given edges have to form a tree that satisfies Omkar's restrictions.\\n\\nExample\\n\\nInput\\n\\n\\n2\\n7 4\\n1 2 3\\n3 4 5\\n5 6 7\\n6 5 4\\n5 3\\n1 2 3\\n2 3 4\\n3 4 5\\n\\n\\nOutput\\n\\n\\n1 2\\n1 3\\n3 5\\n3 4\\n2 7\\n7 6\\n5 1\\n1 3\\n3 2\\n2 4\\n\\nNote\\n\\nThe output of the first sample case corresponds to the following tree: \\n\\n<image> For the first restriction,...\",\"targets\":\"import java.util.*;\\nimport java.io.*;\\n \\npublic class SolutionB{\\n  static HashSet<Integer>[] gr;\\n  static int[] vis;\\n       public static void main(String[] args) throws Exception{\\n               Fast sc=new Fast();\\n        PrintWriter out=new PrintWriter(System.out);\\n         int t=sc.nextInt();\\n         \\n         while(t-->0){\\n\\n\\n           int n=sc.nextInt();\\n           int m=sc.nextInt();\\n           gr=new HashSet[n+1];\\n           vis=new int[n+1];\\n           for(int i=0;i<=n;i++){\\n                 gr[i]=new HashSet<>();\\n                \\n           }\\n         \\n         int last=0;\\n          vis=new int[n+1];\\n           for(int i=0;i<m;i++){\\n              int a=sc.nextInt();\\n              int b=sc.nextInt();\\n              int c=sc.nextInt();\\n              gr[a].add(c);\\n              gr[c].add(a);\\n              vis[b]=1;         } \\n\\n\\n            \\n              for(int i=1;i<=n;i++){\\n                if(vis[i]==0){\\n                  last=i;\\n                  break;\\n                }\\n              }\\n\\n              for(int i=1;i<=n;i++){\\n                if(i!=last){\\n                  out.println(last+\\\" \\\"+i);\\n                }\\n              }\\n\\n        }\\n     out.close();\\n\\n}\\nstatic void dfs(int n){\\n   vis[n]=1;\\n   for(int a:gr[n]){\\n    if(vis[a]==0)dfs(a);\\n   }\\n}\\n\\nstatic void Sort(int[] ar){\\n    ArrayList<Integer> al=new ArrayList<>();\\n    for(int i=0;i<ar.length;i++){al.add(ar[i]);}\\n    Collections.sort(al);\\n    for(int i=0;i<al.size();i++)ar[i]=al.get(i);\\n  }\\nstatic int gcd(int a,int b){\\n    if(b==0) return a;\\n    else return  gcd(b,a%b);\\n}\\n}\\nclass Pair{\\n    int x, y;\\n     Pair(int x,int y){\\n        this.x=x;\\n        this.y=y;\\n     }\\n}\\nclass Fast{\\n  BufferedReader br; \\n  StringTokenizer st;\\n  public Fast(){ br=new BufferedReader(new InputStreamReader(System.in)); }\\n  String next() \\n        {  while (st == null || !st.hasMoreElements()) \\n            {   try\\n                {     st = new StringTokenizer(br.readLine()); } \\n                catch (IOException  e) \\n                {    e.printStackTrace(); } \\n        ...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Petya has got an interesting flower. Petya is a busy person, so he sometimes forgets to water it. You are given n days from Petya's live and you have to determine what happened with his flower in the end.\\n\\nThe flower grows as follows: \\n\\n  * If the flower isn't watered for two days in a row, it dies. \\n  * If the flower is watered in the i-th day, it grows by 1 centimeter. \\n  * If the flower is watered in the i-th and in the (i-1)-th day (i > 1), then it grows by 5 centimeters instead of 1. \\n  * If the flower is not watered in the i-th day, it does not grow. \\n\\n\\n\\nAt the beginning of the 1-st day the flower is 1 centimeter tall. What is its height after n days?\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 100). Description of the test cases follows.\\n\\nThe first line of each test case contains the only integer n (1 \u2264 n \u2264 100).\\n\\nThe second line of each test case contains n integers a_1, a_2, ..., a_n (a_i = 0 or a_i = 1). If a_i = 1, the flower is watered in the i-th day, otherwise it is not watered.\\n\\nOutput\\n\\nFor each test case print a single integer k \u2014 the flower's height after n days, or -1, if the flower dies.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n3\\n1 0 1\\n3\\n0 1 1\\n4\\n1 0 0 1\\n1\\n0\\n\\n\\nOutput\\n\\n\\n3\\n7\\n-1\\n1\\nSolve the task in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nvoid fun() {\\n  long long int co = 0, co1 = 0, co2 = 0, co3 = 0, count = 0, f = 0, f1 = 0,\\n                f2 = 0, f3 = 0, flag = 0;\\n  long long int i, j, k, l, m, n, a, b, c, d, x, tmp, temp;\\n  string s, s1, s2, s3;\\n  cin >> n;\\n  long long int arr[n + 10];\\n  for (i = 0; i < n; i++) {\\n    cin >> arr[i];\\n  }\\n  co = 1;\\n  f = 0;\\n  for (i = 0; i < n; i++) {\\n    if (arr[i] == 0) {\\n      f++;\\n      co1 = 0;\\n    } else if (arr[i] == 1) {\\n      co1++;\\n      if (co1 > 1)\\n        co += 5;\\n      else\\n        co += 1;\\n      f = 0;\\n    }\\n    if (f == 2) break;\\n  }\\n  if (f == 2)\\n    cout << -1 << endl;\\n  else\\n    cout << co << endl;\\n}\\nint main() {\\n  long long int n;\\n  cin >> n;\\n  while (n--) fun();\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in CPP?\\nAs you know, the most intelligent beings on the Earth are, of course, cows. This conclusion was reached long ago by the Martian aliens, as well as a number of other intelligent civilizations from outer space. \\n\\nSometimes cows gather into cowavans. This seems to be seasonal. But at this time the cows become passive and react poorly to external stimuli. A cowavan is a perfect target for the Martian scientific saucer, it's time for large-scale abductions, or, as the Martians say, raids. Simply put, a cowavan is a set of cows in a row. \\n\\nIf we number all cows in the cowavan with positive integers from 1 to n, then we can formalize the popular model of abduction, known as the (a, b)-Cowavan Raid: first they steal a cow number a, then number a + b, then \u2014 number a + 2\u00b7b, and so on, until the number of an abducted cow exceeds n. During one raid the cows are not renumbered. \\n\\nThe aliens would be happy to place all the cows on board of their hospitable ship, but unfortunately, the amount of cargo space is very, very limited. The researchers, knowing the mass of each cow in the cowavan, made p scenarios of the (a, b)-raid. Now they want to identify the following thing for each scenario individually: what total mass of pure beef will get on board of the ship. All the scenarios are independent, in the process of performing the calculations the cows are not being stolen. \\n\\n<image>\\n\\nInput\\n\\nThe first line contains the only positive integer n (1 \u2264 n \u2264 3\u00b7105) \u2014 the number of cows in the cowavan.\\n\\nThe second number contains n positive integer wi, separated by spaces, where the i-th number describes the mass of the i-th cow in the cowavan (1 \u2264 wi \u2264 109).\\n\\nThe third line contains the only positive integer p \u2014 the number of scenarios of (a, b)-raids (1 \u2264 p \u2264 3\u00b7105).\\n\\nEach following line contains integer parameters a and b of the corresponding scenario (1 \u2264 a, b \u2264 n).\\n\\nOutput\\n\\nPrint for each scenario of the (a, b)-raid the total mass of cows, that can be stolen using only this scenario.\\n\\nPlease, do not use the %lld specificator to...\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst double eps = 1e-9;\\nconst int inf = 2000000000;\\nconst long long infLL = 9000000000000000000;\\ntemplate <typename first, typename second>\\nostream& operator<<(ostream& os, const pair<first, second>& p) {\\n  return os << \\\"(\\\" << p.first << \\\", \\\" << p.second << \\\")\\\";\\n}\\ntemplate <typename T>\\nostream& operator<<(ostream& os, const vector<T>& v) {\\n  os << \\\"{\\\";\\n  for (auto it = v.begin(); it != v.end(); ++it) {\\n    if (it != v.begin()) os << \\\", \\\";\\n    os << *it;\\n  }\\n  return os << \\\"}\\\";\\n}\\ntemplate <typename T>\\nostream& operator<<(ostream& os, const set<T>& v) {\\n  os << \\\"[\\\";\\n  for (auto it = v.begin(); it != v.end(); ++it) {\\n    if (it != v.begin()) os << \\\",\\\";\\n    os << *it;\\n  }\\n  return os << \\\"]\\\";\\n}\\ntemplate <typename T>\\nostream& operator<<(ostream& os, const multiset<T>& v) {\\n  os << \\\"[\\\";\\n  for (auto it = v.begin(); it != v.end(); ++it) {\\n    if (it != v.begin()) os << \\\", \\\";\\n    os << *it;\\n  }\\n  return os << \\\"]\\\";\\n}\\ntemplate <typename first, typename second>\\nostream& operator<<(ostream& os, const map<first, second>& v) {\\n  os << \\\"[\\\";\\n  for (auto it = v.begin(); it != v.end(); ++it) {\\n    if (it != v.begin()) os << \\\", \\\";\\n    os << it->first << \\\" = \\\" << it->second;\\n  }\\n  return os << \\\"]\\\";\\n}\\nvoid faltu() { cerr << '\\\\n'; }\\ntemplate <typename T>\\nvoid faltu(T a[], int n) {\\n  for (int i = 0; i < n; ++i) cerr << a[i] << ' ';\\n  cerr << '\\\\n';\\n}\\ntemplate <typename T, typename... hello>\\nvoid faltu(T arg, const hello&... rest) {\\n  cerr << arg << ' ';\\n  faltu(rest...);\\n}\\nconst int mx = 3e5 + 5;\\nint n;\\nlong long w[mx];\\nvector<pair<int, int> > vec[mx];\\nlong long c;\\nlong long dp[mx];\\nlong long ans[mx];\\nint main() {\\n  ios_base::sync_with_stdio(0);\\n  cin.tie(0);\\n  cout.tie(0);\\n  ;\\n  cin >> n;\\n  for (int i = 1; i <= n; ++i) cin >> w[i];\\n  c = sqrt(n);\\n  int p;\\n  cin >> p;\\n  for (int i = 1; i <= p; ++i) {\\n    int a, b;\\n    cin >> a >> b;\\n    vec[b].push_back(make_pair(a, i));\\n  }\\n  for (int i = 1; i <= n; ++i) {\\n    if (vec[i].empty()) continue;\\n    if (i <= c) {\\n      for (int j = n; j >= 1;...\",\"language\":\"python\",\"split\":\"train\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Let's define S(x) to be the sum of digits of number x written in decimal system. For example, S(5) = 5, S(10) = 1, S(322) = 7.\\n\\nWe will call an integer x interesting if S(x + 1) < S(x). In each test you will be given one integer n. Your task is to calculate the number of integers x such that 1 \u2264 x \u2264 n and x is interesting.\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 1000) \u2014 number of test cases.\\n\\nThen t lines follow, the i-th line contains one integer n (1 \u2264 n \u2264 10^9) for the i-th test case.\\n\\nOutput\\n\\nPrint t integers, the i-th should be the answer for the i-th test case.\\n\\nExample\\n\\nInput\\n\\n\\n5\\n1\\n9\\n10\\n34\\n880055535\\n\\n\\nOutput\\n\\n\\n0\\n1\\n1\\n3\\n88005553\\n\\nNote\\n\\nThe first interesting number is equal to 9.\\nUsing python3 can you solve the prior task?\",\"targets\":\"def compute(num):\\n\\tlast = num %10;\\t\\n\\ttotal = int(num\\/10);\\n\\tif(last == 9):\\n\\t\\ttotal +=1;\\n\\treturn total;\\n\\nn = int(input());\\nfor i in range(0,n):\\n\\t\\n\\n\\tx=  int(input());\\n\\tprint(compute(x));\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"A conglomerate consists of n companies. To make managing easier, their owners have decided to merge all companies into one. By law, it is only possible to merge two companies, so the owners plan to select two companies, merge them into one, and continue doing so until there is only one company left.\\n\\nBut anti-monopoly service forbids to merge companies if they suspect unfriendly absorption. The criterion they use is the difference in maximum salaries between two companies. Merging is allowed only if the maximum salaries are equal.\\n\\nTo fulfill the anti-monopoly requirements, the owners can change salaries in their companies before merging. But the labor union insists on two conditions: it is only allowed to increase salaries, moreover all the employees in one company must get the same increase.\\n\\nSure enough, the owners want to minimize the total increase of all salaries in all companies. Help them find the minimal possible increase that will allow them to merge companies into one.\\n\\nInput\\n\\nThe first line contains a single integer n \u2014 the number of companies in the conglomerate (1 \u2264 n \u2264 2 \u22c5 10^5). Each of the next n lines describes a company. \\n\\nA company description start with an integer m_i \u2014 the number of its employees (1 \u2264 m_i \u2264 2 \u22c5 10^5). Then m_i integers follow: the salaries of the employees. All salaries are positive and do not exceed 10^9. \\n\\nThe total number of employees in all companies does not exceed 2 \u22c5 10^5. \\n\\nOutput\\n\\nOutput a single integer \u2014 the minimal total increase of all employees that allows to merge all companies.\\n\\nExample\\n\\nInput\\n\\n\\n3\\n2 4 3\\n2 2 1\\n3 1 1 1\\n\\n\\nOutput\\n\\n\\n13\\n\\nNote\\n\\nOne of the optimal merging strategies is the following. First increase all salaries in the second company by 2, and merge the first and the second companies. Now the conglomerate consists of two companies with salaries [4, 3, 4, 3] and [1, 1, 1]. To merge them, increase the salaries in the second of those by 3. The total increase is 2 + 2 + 3 + 3 + 3 = 13.\\nThe above is tricky. Write me a correct solution in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint main() {\\n  ios_base::sync_with_stdio(false);\\n  cin.tie(NULL);\\n  long long n, m, s;\\n  cin >> n;\\n  long long t = 0, e = 0, ma = 0, mb, i;\\n  while (n--) {\\n    cin >> m;\\n    i = 0;\\n    mb = 0;\\n    while (i < m) {\\n      cin >> s;\\n      if (s > mb) mb = s;\\n      i++;\\n    }\\n    if (ma > mb)\\n      t += (m * (ma - mb));\\n    else {\\n      t += (e * (mb - ma));\\n      ma = mb;\\n    }\\n    e += m;\\n  }\\n  cout << t << endl;\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You are given two integers n and m. Find the \\\\operatorname{MEX} of the sequence n \u2295 0, n \u2295 1, \u2026, n \u2295 m. Here, \u2295 is the [bitwise XOR operator](https:\\/\\/en.wikipedia.org\\/wiki\\/Bitwise_operation#XOR).\\n\\n\\\\operatorname{MEX} of the sequence of non-negative integers is the smallest non-negative integer that doesn't appear in this sequence. For example, \\\\operatorname{MEX}(0, 1, 2, 4) = 3, and \\\\operatorname{MEX}(1, 2021) = 0. \\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 30 000) \u2014 the number of test cases.\\n\\nThe first and only line of each test case contains two integers n and m (0 \u2264 n, m \u2264 10^9).\\n\\nOutput\\n\\nFor each test case, print a single integer \u2014 the answer to the problem.\\n\\nExample\\n\\nInput\\n\\n\\n5\\n3 5\\n4 6\\n3 2\\n69 696\\n123456 654321\\n\\n\\nOutput\\n\\n\\n4\\n3\\n0\\n640\\n530866\\n\\nNote\\n\\nIn the first test case, the sequence is 3 \u2295 0, 3 \u2295 1, 3 \u2295 2, 3 \u2295 3, 3 \u2295 4, 3 \u2295 5, or 3, 2, 1, 0, 7, 6. The smallest non-negative integer which isn't present in the sequence i. e. the \\\\operatorname{MEX} of the sequence is 4.\\n\\nIn the second test case, the sequence is 4 \u2295 0, 4 \u2295 1, 4 \u2295 2, 4 \u2295 3, 4 \u2295 4, 4 \u2295 5, 4 \u2295 6, or 4, 5, 6, 7, 0, 1, 2. The smallest non-negative integer which isn't present in the sequence i. e. the \\\\operatorname{MEX} of the sequence is 3.\\n\\nIn the third test case, the sequence is 3 \u2295 0, 3 \u2295 1, 3 \u2295 2, or 3, 2, 1. The smallest non-negative integer which isn't present in the sequence i. e. the \\\\operatorname{MEX} of the sequence is 0.\\nfrom\",\"targets\":\"os import path\\nimport sys, time\\n# mod = int(1e9 + 7)\\n# import re\\nfrom math import ceil, floor, gcd, log, log2, factorial, sqrt\\nfrom collections import defaultdict, Counter, OrderedDict, deque\\nfrom itertools import combinations, accumulate\\n# from string import ascii_lowercase ,ascii_uppercase\\nfrom bisect import *\\nfrom functools import reduce\\nfrom operator import mul\\n\\nstar = lambda x: print(' '.join(map(str, x)))\\ngrid = lambda r: [lint() for i in range(r)]\\nINF = float('inf')\\nif (path.exists('input.txt')):\\n    sys.stdin = open('input.txt', 'r')\\n    sys.stdout = open('output.txt', 'w')\\nimport sys\\nfrom sys import stdin, stdout\\nfrom collections import *\\nfrom math import gcd, floor, ceil\\n\\n\\ndef st():\\n    return list(stdin.readline().strip())\\n\\n\\ndef inp():\\n    return int(stdin.readline())\\n\\n\\ndef inlt():\\n    return list(map(int, stdin.readline().split()))\\n\\n\\ndef invr():\\n    return map(int, stdin.readline().split())\\n\\n\\n\\n\\n\\ndef solve():\\n    n,m = invr()\\n    ans = float(\\\"inf\\\")\\n    res = 0\\n    for i in range(31,-1,-1):\\n        if (n & pow(2,i)) and not(m & pow(2,i)):\\n            print(min(ans,res))\\n            return\\n        elif (m & pow(2,i)) and not(n & pow(2,i)):\\n            res += pow(2,i)\\n        elif not(n & pow(2,i)) and not(m & pow(2,i)):\\n            ans = min(ans,pow(2,i)+res)\\n    print(ans)\\n    return\\n\\nt = 1\\nt = inp()\\nfor _ in range(t):\\n    solve()\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"Ezzat has an array of n integers (maybe negative). He wants to split it into two non-empty subsequences a and b, such that every element from the array belongs to exactly one subsequence, and the value of f(a) + f(b) is the maximum possible value, where f(x) is the average of the subsequence x. \\n\\nA sequence x is a subsequence of a sequence y if x can be obtained from y by deletion of several (possibly, zero or all) elements.\\n\\nThe average of a subsequence is the sum of the numbers of this subsequence divided by the size of the subsequence.\\n\\nFor example, the average of [1,5,6] is (1+5+6)\\/3 = 12\\/3 = 4, so f([1,5,6]) = 4.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 10^3)\u2014 the number of test cases. Each test case consists of two lines.\\n\\nThe first line contains a single integer n (2 \u2264 n \u2264 10^5).\\n\\nThe second line contains n integers a_1, a_2, \u2026, a_n (-10^9 \u2264 a_i \u2264 10^9).\\n\\nIt is guaranteed that the sum of n over all test cases does not exceed 3\u22c510^5.\\n\\nOutput\\n\\nFor each test case, print a single value \u2014 the maximum value that Ezzat can achieve.\\n\\nYour answer is considered correct if its absolute or relative error does not exceed 10^{-6}.\\n\\nFormally, let your answer be a, and the jury's answer be b. Your answer is accepted if and only if \\\\frac{|a - b|}{max{(1, |b|)}} \u2264 10^{-6}.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n3\\n3 1 2\\n3\\n-7 -6 -6\\n3\\n2 2 2\\n4\\n17 3 5 -3\\n\\n\\nOutput\\n\\n\\n4.500000000\\n-12.500000000\\n4.000000000\\n18.666666667\\n\\nNote\\n\\nIn the first test case, the array is [3, 1, 2]. These are all the possible ways to split this array: \\n\\n  * a = [3], b = [1,2], so the value of f(a) + f(b) = 3 + 1.5 = 4.5. \\n  * a = [3,1], b = [2], so the value of f(a) + f(b) = 2 + 2 = 4. \\n  * a = [3,2], b = [1], so the value of f(a) + f(b) = 2.5 + 1 = 3.5. \\n\\nTherefore, the maximum possible value 4.5.\\n\\nIn the second test case, the array is [-7, -6, -6]. These are all the possible ways to split this array: \\n\\n  * a = [-7], b = [-6,-6], so the value of f(a) + f(b) = (-7) + (-6) = -13. \\n  * a = [-7,-6], b = [-6], so the value of f(a) + f(b) = (-6.5) + (-6) =...\\\":\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint main() {\\n  ios_base::sync_with_stdio(0);\\n  cin.tie(NULL);\\n  int t;\\n  cin >> t;\\n  while (t--) {\\n    int n;\\n    cin >> n;\\n    long long sum = 0;\\n    long long la = INT_MIN;\\n    long long x;\\n    for (int i = 0; i < n; i++) {\\n      cin >> x;\\n      sum += x;\\n      la = max(la, x);\\n    }\\n    double ans;\\n    ans = double(sum - la);\\n    ans \\/= double(n - 1);\\n    ans += double(la);\\n    cout << fixed << setprecision(7) << ans << endl;\\n  }\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"There are n block towers in a row, where tower i has a height of a_i. You're part of a building crew, and you want to make the buildings look as nice as possible. In a single day, you can perform the following operation:\\n\\n  * Choose two indices i and j (1 \u2264 i, j \u2264 n; i \u2260 j), and move a block from tower i to tower j. This essentially decreases a_i by 1 and increases a_j by 1. \\n\\n\\n\\nYou think the ugliness of the buildings is the height difference between the tallest and shortest buildings. Formally, the ugliness is defined as max(a)-min(a). \\n\\nWhat's the minimum possible ugliness you can achieve, after any number of days?\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 1000) \u2014 the number of test cases. Then t cases follow.\\n\\nThe first line of each test case contains one integer n (2 \u2264 n \u2264 100) \u2014 the number of buildings.\\n\\nThe second line of each test case contains n space separated integers a_1, a_2, \u2026, a_n (1 \u2264 a_i \u2264 10^7) \u2014 the heights of the buildings.\\n\\nOutput\\n\\nFor each test case, output a single integer \u2014 the minimum possible ugliness of the buildings.\\n\\nExample\\n\\nInput\\n\\n\\n3\\n3\\n10 10 10\\n4\\n3 2 1 2\\n5\\n1 2 3 1 5\\n\\n\\nOutput\\n\\n\\n0\\n0\\n1\\n\\nNote\\n\\nIn the first test case, the ugliness is already 0.\\n\\nIn the second test case, you should do one operation, with i = 1 and j = 3. The new heights will now be [2, 2, 2, 2], with an ugliness of 0.\\n\\nIn the third test case, you may do three operations: \\n\\n  1. with i = 3 and j = 1. The new array will now be [2, 2, 2, 1, 5], \\n  2. with i = 5 and j = 4. The new array will now be [2, 2, 2, 2, 4], \\n  3. with i = 5 and j = 3. The new array will now be [2, 2, 3, 2, 3]. \\n\\nThe resulting ugliness is 1. It can be proven that this is the minimum possible ugliness for this test.\\nThe above is tricky. Write me a correct solution in JAVA.\",\"targets\":\"\\/*===============================\\nAuthor   :   Shadman Shariar   ||\\n===============================*\\/\\nimport java.io.*;\\nimport java.util.*;\\n\\/\\/import java.lang.Math.*;\\n\\/\\/import java.math.BigInteger;\\n\\/\\/import java.text.DecimalFormat;\\npublic class Main {\\npublic static Main obj = new Main();\\npublic static int [] dx = {-1, 1, 0, 0, -1, -1, 1, 1};\\npublic static int [] dy = {0, 0, -1, 1, -1, 1, -1, 1};\\npublic static final long mod=(long)(Math.pow(10,9)+7);\\npublic static FastReader fr = new FastReader();\\n\\/\\/public static Scanner input = new Scanner(System.in);\\n\\/\\/public static PrintWriter pw = new PrintWriter(System.out);\\n\\/\\/public static DecimalFormat df = new DecimalFormat(\\\".000\\\");\\n\\/\\/public static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));\\npublic static void main (String[]args) throws Exception{Scanner input=new Scanner(System.in);\\n\\/\\/===========================================================================================\\/\\/\\n\\/\\/Vector vc = new Vector();\\n\\/\\/BigInteger bi = new BigInteger(\\\"1000\\\");\\n\\/\\/StringBuilder sb = new StringBuilder();\\n\\/\\/StringBuffer sbf = new StringBuffer();\\n\\/\\/StringTokenizer st = new StringTokenizer(\\\"string\\\",\\\"split\\\");\\n\\/\\/ArrayList<Integer> al= new ArrayList<Integer>();\\n\\/\\/LinkedList<Integer> ll= new LinkedList<Integer>();\\n\\/\\/Stack <Integer> stk = new Stack <Integer>();\\n\\/\\/Queue <Integer> q = new LinkedList<Integer>();\\n\\/\\/ArrayDeque<Integer> ad = new ArrayDeque<Integer>();\\n\\/\\/PriorityQueue <Integer> pq = new PriorityQueue<Integer>();\\n\\/\\/PriorityQueue <Integer> pqr = new PriorityQueue<Integer>(Comparator.reverseOrder());\\n\\/\\/HashSet<Integer> hs = new HashSet<Integer>();\\n\\/\\/LinkedHashSet<Integer> lhs = new LinkedHashSet<Integer>();\\n\\/\\/TreeSet<Integer> ts = new TreeSet<Integer>();\\n\\/\\/TreeSet<Integer> tsr = new TreeSet<Integer>(Comparator.reverseOrder());\\n\\/\\/Hashtable<Integer,Integer> ht = new Hashtable<Integer,Integer>();\\n\\/\\/HashMap<Integer,Integer> hm = new HashMap<Integer,Integer>();\\n\\/\\/LinkedHashMap<Integer,Integer> lhm = new...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"A bracket sequence is a string containing only characters \\\"(\\\" and \\\")\\\". 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 \\\"()()\\\" and \\\"(())\\\" are regular (the resulting expressions are: \\\"(1)+(1)\\\" and \\\"((1+1)+1)\\\"), and \\\")(\\\", \\\"(\\\" and \\\")\\\" are not.\\n\\nYou are given an integer n. Your goal is to construct and print exactly n different regular bracket sequences of length 2n.\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 50) \u2014 the number of test cases.\\n\\nEach test case consists of one line containing one integer n (1 \u2264 n \u2264 50).\\n\\nOutput\\n\\nFor each test case, print n lines, each containing a regular bracket sequence of length exactly 2n. All bracket sequences you output for a testcase should be different (though they may repeat in different test cases). If there are multiple answers, print any of them. It can be shown that it's always possible.\\n\\nExample\\n\\nInput\\n\\n\\n3\\n3\\n1\\n3\\n\\n\\nOutput\\n\\n\\n()()()\\n((()))\\n(()())\\n()\\n((()))\\n(())()\\n()(())\\\":\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst int maxn = 3e6 + 100;\\nconst int INF = 0x7fffffff;\\nconst int mod = 998244353;\\nconst long long mod1 = 998244353;\\nconst long long base = 137;\\nconst double Pi = acos(-1.0);\\nconst int G = 3;\\nint a[maxn];\\nint main() {\\n  int t;\\n  cin >> t;\\n  while (t--) {\\n    int n;\\n    scanf(\\\"%d\\\", &n);\\n    for (int i = 1; i <= n; i++) {\\n      for (int j = 1; j <= 2 * n - 2 * i; j++) {\\n        a[j] = (j - 1) % 2;\\n      }\\n      for (int j = 2 * n - 2 * i + 1; j <= 2 * n - i; j++) {\\n        a[j] = 0;\\n      }\\n      for (int j = 2 * n - i + 1; j <= 2 * n; j++) a[j] = 1;\\n      for (int j = 1; j <= 2 * n; j++) {\\n        if (a[j])\\n          printf(\\\")\\\");\\n        else\\n          printf(\\\"(\\\");\\n      }\\n      puts(\\\"\\\");\\n    }\\n  }\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"A bracket sequence is a string containing only characters \\\"(\\\" and \\\")\\\". 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 \\\"()()\\\" and \\\"(())\\\" are regular (the resulting expressions are: \\\"(1)+(1)\\\" and \\\"((1+1)+1)\\\"), and \\\")(\\\", \\\"(\\\" and \\\")\\\" are not.\\n\\nYou are given an integer n. Your goal is to construct and print exactly n different regular bracket sequences of length 2n.\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 50) \u2014 the number of test cases.\\n\\nEach test case consists of one line containing one integer n (1 \u2264 n \u2264 50).\\n\\nOutput\\n\\nFor each test case, print n lines, each containing a regular bracket sequence of length exactly 2n. All bracket sequences you output for a testcase should be different (though they may repeat in different test cases). If there are multiple answers, print any of them. It can be shown that it's always possible.\\n\\nExample\\n\\nInput\\n\\n\\n3\\n3\\n1\\n3\\n\\n\\nOutput\\n\\n\\n()()()\\n((()))\\n(()())\\n()\\n((()))\\n(())()\\n()(())\\nUsing java can you solve the prior task?\",\"targets\":\"import java.io.*;\\nimport java.util.*;\\n\\n\\npublic class A {\\n    public static void main(String[] args) {\\n        MyScanner sc = new MyScanner();\\n        out = new PrintWriter(new BufferedOutputStream(System.out));\\n\\n        \\/\\/ Start writing your solution here. -------------------------------------\\n\\n      \\/*\\n      int n      = sc.nextInt();        \\/\\/ read input as integer\\n      long k     = sc.nextLong();       \\/\\/ read input as long\\n      double d   = sc.nextDouble();     \\/\\/ read input as double\\n      String str = sc.next();           \\/\\/ read input as String\\n      String s   = sc.nextLine();       \\/\\/ read whole line as String\\n\\n      int result = 3*n;\\n      out.println(result);                    \\/\\/ print via PrintWriter\\n      *\\/\\n\\n        \\/\\/ Stop writing your solution here. -------------------------------------\\n\\n        int T = sc.nextInt();\\n\\n        for(int i=0;i<T;i++){\\n            int num = sc.nextInt();\\n            List<String> ans = solve(num);\\n            for(String word:ans)\\n                System.out.println(word);\\n        }\\n    }\\n\\n    private static List<String> solve(int n) {\\n        if(n==1)\\n            return List.of(\\\"()\\\");\\n\\n        List<String> prev = solve(n-1);\\n        List<String> ans = new ArrayList<>();\\n        for(int i=0;i<n;){\\n            for(String brackets:prev){\\n                ans.add(\\\"(\\\"+brackets+\\\")\\\");\\n                ans.add(brackets+\\\"()\\\");\\n                i+=2;\\n            }\\n\\n        }\\n        return ans.subList(0,n);\\n\\n    }\\n\\n\\n    \\/\\/-----------PrintWriter for faster output---------------------------------\\n    public static PrintWriter out;\\n\\n    \\/\\/-----------MyScanner class for faster input----------\\n    public static class MyScanner {\\n        BufferedReader br;\\n        StringTokenizer st;\\n\\n        public MyScanner() {\\n            br = new BufferedReader(new InputStreamReader(System.in));\\n        }\\n\\n        String next() {\\n            while (st == null || !st.hasMoreElements()) {\\n                try {\\n                    st = new StringTokenizer(br.readLine());\\n                } catch...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in CPP?\\nMaxim has opened his own restaurant! The restaurant has got a huge table, the table's length is p meters.\\n\\nMaxim has got a dinner party tonight, n guests will come to him. Let's index the guests of Maxim's restaurant from 1 to n. Maxim knows the sizes of all guests that are going to come to him. The i-th guest's size (ai) represents the number of meters the guest is going to take up if he sits at the restaurant table.\\n\\nLong before the dinner, the guests line up in a queue in front of the restaurant in some order. Then Maxim lets the guests in, one by one. Maxim stops letting the guests in when there is no place at the restaurant table for another guest in the queue. There is no place at the restaurant table for another guest in the queue, if the sum of sizes of all guests in the restaurant plus the size of this guest from the queue is larger than p. In this case, not to offend the guest who has no place at the table, Maxim doesn't let any other guest in the restaurant, even if one of the following guests in the queue would have fit in at the table.\\n\\nMaxim is now wondering, what is the average number of visitors who have come to the restaurant for all possible n! orders of guests in the queue. Help Maxim, calculate this number.\\n\\nInput\\n\\nThe first line contains integer n (1 \u2264 n \u2264 50) \u2014 the number of guests in the restaurant. The next line contains integers a1, a2, ..., an (1 \u2264 ai \u2264 50) \u2014 the guests' sizes in meters. The third line contains integer p (1 \u2264 p \u2264 50) \u2014 the table's length in meters. \\n\\nThe numbers in the lines are separated by single spaces.\\n\\nOutput\\n\\nIn a single line print a real number \u2014 the answer to the problem. The answer will be considered correct, if the absolute or relative error doesn't exceed 10 - 4.\\n\\nExamples\\n\\nInput\\n\\n3\\n1 2 3\\n3\\n\\n\\nOutput\\n\\n1.3333333333\\n\\nNote\\n\\nIn the first sample the people will come in the following orders: \\n\\n  * (1, 2, 3) \u2014 there will be two people in the restaurant; \\n  * (1, 3, 2) \u2014 there will be one person in the restaurant; \\n  * (2, 1, 3) \u2014 there will be two people in the...\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst int N = 52;\\nlong long n, a[N], p, dp[N][N][N], c[N][N];\\nint main() {\\n  scanf(\\\"%d\\\", &n);\\n  for (int i = 1; i <= n; ++i) scanf(\\\"%d\\\", &a[i]);\\n  scanf(\\\"%d\\\", &p);\\n  dp[0][0][0] = 1;\\n  c[0][0] = 1;\\n  for (int i = 0; i <= 50; i++)\\n    for (int j = 0; j <= 50; j++) {\\n      if (i) c[i][j] += c[i - 1][j];\\n      if (i && j) c[i][j] += c[i - 1][j - 1];\\n    }\\n  for (int i = 1; i <= n; ++i) {\\n    scanf(\\\"%d\\\", &a[i]);\\n    for (int j = 0; j <= i; ++j) {\\n      for (int k = 0; k <= 50; ++k) {\\n        if (k - a[i] >= 0)\\n          if (j - 1 >= 0) dp[i][j][k] += dp[i - 1][j - 1][k - a[i]];\\n        dp[i][j][k] += dp[i - 1][j][k];\\n      }\\n    }\\n  }\\n  double ans = 0;\\n  for (int i = 0; i <= n; ++i)\\n    for (int j = 1; j <= p; ++j) dp[n][i][j] += dp[n][i][j - 1];\\n  for (int i = 1; i <= n; ++i) ans += dp[n][i][p] * 1.0 \\/ c[n][i];\\n  cout.precision(10);\\n  cout << fixed << ans << '\\\\n';\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in JAVA?\\nPaprika loves permutations. She has an array a_1, a_2, ..., a_n. She wants to make the array a permutation of integers 1 to n.\\n\\nIn order to achieve this goal, she can perform operations on the array. In each operation she can choose two integers i (1 \u2264 i \u2264 n) and x (x > 0), then perform a_i := a_i mod x (that is, replace a_i by the remainder of a_i divided by x). In different operations, the chosen i and x can be different.\\n\\nDetermine the minimum number of operations needed to make the array a permutation of integers 1 to n. If it is impossible, output -1.\\n\\nA permutation is an array consisting of n distinct integers from 1 to n in arbitrary order. For example, [2,3,1,5,4] is a permutation, but [1,2,2] is not a permutation (2 appears twice in the array) and [1,3,4] is also not a permutation (n=3 but there is 4 in the array).\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains a single integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases. Description of the test cases follows.\\n\\nThe first line of each test case contains an integer n (1 \u2264 n \u2264 10^5).\\n\\nThe second line of each test case contains n integers a_1, a_2, ..., a_n. (1 \u2264 a_i \u2264 10^9).\\n\\nIt is guaranteed that the sum of n over all test cases does not exceed 2 \u22c5 10^5.\\n\\nOutput\\n\\nFor each test case, output the minimum number of operations needed to make the array a permutation of integers 1 to n, or -1 if it is impossible.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n2\\n1 7\\n3\\n1 5 4\\n4\\n12345678 87654321 20211218 23571113\\n9\\n1 2 3 4 18 19 5 6 7\\n\\n\\nOutput\\n\\n\\n1\\n-1\\n4\\n2\\n\\nNote\\n\\nFor the first test, the only possible sequence of operations which minimizes the number of operations is: \\n\\n  * Choose i=2, x=5. Perform a_2 := a_2 mod 5 = 2. \\n\\n\\n\\nFor the second test, it is impossible to obtain a permutation of integers from 1 to n.\",\"targets\":\"\\/\\/ Problem: C. Paprika and Permutation\\n\\/\\/ Contest: Codeforces - Codeforces Round #761 (Div. 2)\\n\\/\\/ URL: https:\\/\\/codeforces.com\\/contest\\/1617\\/problem\\/C\\n\\/\\/ Memory Limit: 256 MB\\n\\/\\/ Time Limit: 1000 ms\\n\\nimport java.io.*;\\nimport java.util.*;\\n\\nimport static java.lang.Math.max;\\nimport static java.lang.Math.min;\\nimport static java.lang.Math.abs;\\n\\n\\n\\npublic class X1631 {\\n    long mod = 1000000007;\\n    private void preparation() {\\n\\n    }\\n\\n\\n    private void clear() {\\n\\n    }\\n\\n    private void solve() throws Exception {\\n        rf();\\n        int n = ri();\\n        rf();int [] d = readArr(n);\\n        boolean [] f = new boolean[n + 1];\\n        ArrayList<Integer> a = new ArrayList<>();\\n        for(int i : d){\\n            if(i <= n && !f[i]){\\n                f[i] = true;\\n            }else{\\n                a.add(i);\\n            }\\n        }\\n        Collections.sort(a);\\n        int idx = 0;\\n        for(int i = 1; i <= n; i++){\\n            if(!f[i]){\\n                if((a.get(idx) - 1) \\/ 2 < i){\\n                    addAns(-1);\\n                    return ;\\n                }\\n                idx++;\\n            }\\n        }\\n        addAns(a.size());\\n\\t\\t\\n    }\\n\\n    private void run() throws Exception {\\n\\t\\t\\n        int T = 1;\\n\\t\\trf();\\n\\t\\tT = ri();\\n\\t\\t\\n\\t\\tpreparation();\\n        while (T-- > 0) {\\n            solve();\\n            if (T != 0) {\\n                clear();\\n            }\\n        }\\n        printAns();\\n    }\\n\\n    public static void main(String[] args) throws Exception {\\n        new X1631().run();\\n    }\\n\\n    StringBuilder sb = new StringBuilder();\\n    BufferedReader infile = new BufferedReader(new InputStreamReader(System.in));\\n    StringTokenizer strT;\\n\\n\\tprivate void addAns(int a){\\n\\t\\tsb.append(a + \\\"\\\\n\\\");\\n\\t}\\n\\t\\n\\tprivate void addAns(long a){\\n\\t\\tsb.append(a + \\\"\\\\n\\\");\\n\\t}\\n\\t\\n\\tprivate void addAns(String s){\\n\\t\\tsb.append(s + \\\"\\\\n\\\");\\n\\t}\\n\\n    private void rf() throws IOException {\\n        strT = new StringTokenizer(infile.readLine());\\n    }\\n\\n\\n    private int ri() {\\n        return Integer.parseInt(strT.nextToken());\\n    }\\n\\n    private long rl() {\\n       ...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"n people gathered to hold a jury meeting of the upcoming competition, the i-th member of the jury came up with a_i tasks, which they want to share with each other.\\n\\nFirst, the jury decides on the order which they will follow while describing the tasks. Let that be a permutation p of numbers from 1 to n (an array of size n where each integer from 1 to n occurs exactly once).\\n\\nThen the discussion goes as follows:\\n\\n  * If a jury member p_1 has some tasks left to tell, then they tell one task to others. Otherwise, they are skipped. \\n  * If a jury member p_2 has some tasks left to tell, then they tell one task to others. Otherwise, they are skipped. \\n  * ... \\n  * If a jury member p_n has some tasks left to tell, then they tell one task to others. Otherwise, they are skipped. \\n  * If there are still members with tasks left, then the process repeats from the start. Otherwise, the discussion ends. \\n\\n\\n\\nA permutation p is nice if none of the jury members tell two or more of their own tasks in a row. \\n\\nCount the number of nice permutations. The answer may be really large, so print it modulo 998 244 353.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases.\\n\\nThe first line of the test case contains a single integer n (2 \u2264 n \u2264 2 \u22c5 10^5) \u2014 number of jury members.\\n\\nThe second line contains n integers a_1, a_2, ..., a_n (1 \u2264 a_i \u2264 10^9) \u2014 the number of problems that the i-th member of the jury came up with.\\n\\nThe sum of n over all test cases does not exceed 2 \u22c5 10^5.\\n\\nOutput\\n\\nFor each test case, print one integer \u2014 the number of nice permutations, taken modulo 998 244 353.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n2\\n1 2\\n3\\n5 5 5\\n4\\n1 3 3 7\\n6\\n3 4 2 1 3 3\\n\\n\\nOutput\\n\\n\\n1\\n6\\n0\\n540\\n\\nNote\\n\\nExplanation of the first test case from the example:\\n\\nThere are two possible permutations, p = [1, 2] and p = [2, 1]. For p = [1, 2], the process is the following:\\n\\n  1. the first jury member tells a task; \\n  2. the second jury member tells a task; \\n  3. the first jury member doesn't have any tasks left to tell, so they are skipped;...\",\"targets\":\"tst = int(input())\\nfor _ in range(tst):\\n    n = int(input())\\n    arr = list(map(int,input().split(\\\" \\\")))\\n    m = max(arr)\\n    c = arr.count(m)\\n    k = arr.count(m-1)\\n    mod = 998244353\\n    \\n    ans = 1\\n    sub = 1\\n    for i in range(1,n+1):\\n        ans = ans*i%mod\\n        if i!=k+1:\\n            sub = sub*i%mod\\n\\n    if c >= 2:\\n        print(ans%mod)\\n    else:\\n        print((ans-sub)%mod)\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Consider the set of all nonnegative integers: {0, 1, 2, ...}. Given two integers a and b (1 \u2264 a, b \u2264 10^4). We paint all the numbers in increasing number first we paint 0, then we paint 1, then 2 and so on.\\n\\nEach number is painted white or black. We paint a number i according to the following rules: \\n\\n  * if i = 0, it is colored white; \\n  * if i \u2265 a and i - a is colored white, i is also colored white; \\n  * if i \u2265 b and i - b is colored white, i is also colored white; \\n  * if i is still not colored white, it is colored black. \\n\\n\\n\\nIn this way, each nonnegative integer gets one of two colors.\\n\\nFor example, if a=3, b=5, then the colors of the numbers (in the order from 0) are: white (0), black (1), black (2), white (3), black (4), white (5), white (6), black (7), white (8), white (9), ...\\n\\nNote that: \\n\\n  * It is possible that there are infinitely many nonnegative integers colored black. For example, if a = 10 and b = 10, then only 0, 10, 20, 30 and any other nonnegative integers that end in 0 when written in base 10 are white. The other integers are colored black. \\n  * It is also possible that there are only finitely many nonnegative integers colored black. For example, when a = 1 and b = 10, then there is no nonnegative integer colored black at all. \\n\\n\\n\\nYour task is to determine whether or not the number of nonnegative integers colored black is infinite.\\n\\nIf there are infinitely many nonnegative integers colored black, simply print a line containing \\\"Infinite\\\" (without the quotes). Otherwise, print \\\"Finite\\\" (without the quotes).\\n\\nInput\\n\\nThe first line of input contains a single integer t (1 \u2264 t \u2264 100) \u2014 the number of test cases in the input. Then t lines follow, each line contains two space-separated integers a and b (1 \u2264 a, b \u2264 10^4).\\n\\nOutput\\n\\nFor each test case, print one line containing either \\\"Infinite\\\" or \\\"Finite\\\" (without the quotes). Output is case-insensitive (i.e. \\\"infinite\\\", \\\"inFiNite\\\" or \\\"finiTE\\\" are all valid answers).\\n\\nExample\\n\\nInput\\n\\n\\n4\\n10 10\\n1 10\\n6 9\\n7 3\\n\\n\\nOutput\\n\\n\\nInfinite\\nFinite\\nInfinite\\nFinite\\nUsing python3 can you solve the prior task?\",\"targets\":\"from math import *\\nt = int(input())\\nfor i in range(t):\\n    a, b = map(int, input().split())\\n    if gcd(a, b) > 1:\\n        print('Infinite')\\n    else:\\n        print('Finite')\",\"language\":\"python\",\"split\":\"train\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Polycarp doesn't like integers that are divisible by 3 or end with the digit 3 in their decimal representation. Integers that meet both conditions are disliked by Polycarp, too.\\n\\nPolycarp starts to write out the positive (greater than 0) integers which he likes: 1, 2, 4, 5, 7, 8, 10, 11, 14, 16, .... Output the k-th element of this sequence (the elements are numbered from 1).\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 100) \u2014 the number of test cases. Then t test cases follow.\\n\\nEach test case consists of one line containing one integer k (1 \u2264 k \u2264 1000).\\n\\nOutput\\n\\nFor each test case, output in a separate line one integer x \u2014 the k-th element of the sequence that was written out by Polycarp.\\n\\nExample\\n\\nInput\\n\\n\\n10\\n1\\n2\\n3\\n4\\n5\\n6\\n7\\n8\\n9\\n1000\\n\\n\\nOutput\\n\\n\\n1\\n2\\n4\\n5\\n7\\n8\\n10\\n11\\n14\\n1666\\nSolve the task in PYTHON.\",\"targets\":\"import sys\\ninput = raw_input\\n\\nA = []\\ni = 1\\nwhile len(A) < 1000:\\n    if i % 3 != 0 and i % 10 != 3:\\n        A.append(i)\\n    i += 1\\n\\nt = int(input())\\nfor _ in range(t):\\n    k = int(input())\\n    print A[k - 1]\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Yelisey has an array a of n integers.\\n\\nIf a has length strictly greater than 1, then Yelisei can apply an operation called minimum extraction to it: \\n\\n  1. First, Yelisei finds the minimal number m in the array. If there are several identical minima, Yelisey can choose any of them. \\n  2. Then the selected minimal element is removed from the array. After that, m is subtracted from each remaining element. \\n\\n\\n\\nThus, after each operation, the length of the array is reduced by 1.\\n\\nFor example, if a = [1, 6, -4, -2, -4], then the minimum element in it is a_3 = -4, which means that after this operation the array will be equal to a=[1 {- (-4)}, 6 {- (-4)}, -2 {- (-4)}, -4 {- (-4)}] = [5, 10, 2, 0].\\n\\nSince Yelisey likes big numbers, he wants the numbers in the array a to be as big as possible.\\n\\nFormally speaking, he wants to make the minimum of the numbers in array a to be maximal possible (i.e. he want to maximize a minimum). To do this, Yelisey can apply the minimum extraction operation to the array as many times as he wants (possibly, zero). Note that the operation cannot be applied to an array of length 1.\\n\\nHelp him find what maximal value can the minimal element of the array have after applying several (possibly, zero) minimum extraction operations to the array.\\n\\nInput\\n\\nThe first line contains an integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases.\\n\\nThe next 2t lines contain descriptions of the test cases.\\n\\nIn the description of each test case, the first line contains an integer n (1 \u2264 n \u2264 2 \u22c5 10^5) \u2014 the original length of the array a. The second line of the description lists n space-separated integers a_i (-10^9 \u2264 a_i \u2264 10^9) \u2014 elements of the array a.\\n\\nIt is guaranteed that the sum of n over all test cases does not exceed 2 \u22c5 10^5.\\n\\nOutput\\n\\nPrint t lines, each of them containing the answer to the corresponding test case. The answer to the test case is a single integer \u2014 the maximal possible minimum in a, which can be obtained by several applications of the described operation to...\\nSolve the task in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\ninline long long int mul(long long int a, long long int b) {\\n  return (long long int)((long long)a * b % 1000000007);\\n}\\ninline long long int inv(long long int a) {\\n  a %= 1000000007;\\n  if (a < 0) a += 1000000007;\\n  long long int b = 1000000007, u = 0, v = 1;\\n  while (a) {\\n    long long int t = b \\/ a;\\n    b -= t * a;\\n    swap(a, b);\\n    u -= t * v;\\n    swap(u, v);\\n  }\\n  assert(b == 1);\\n  if (u < 0) u += 1000000007;\\n  return u;\\n}\\nvoid solve() {\\n  long long int n;\\n  cin >> n;\\n  long long int arr[n];\\n  for (long long int i = 0; i < n; i++) {\\n    cin >> arr[i];\\n  }\\n  sort(arr, arr + n);\\n  long long int m = arr[0];\\n  for (long long int i = 1; i < n; i++) {\\n    m = max(arr[i] - arr[i - 1], m);\\n  }\\n  if (n == 1) {\\n    cout << arr[0] << endl;\\n  } else {\\n    cout << m << endl;\\n  }\\n}\\nsigned main() {\\n  ios_base::sync_with_stdio(false);\\n  cin.tie(NULL);\\n  cout.tie(NULL);\\n  long long int t;\\n  cin >> t;\\n  while (t--) {\\n    solve();\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"'In Boolean logic, a formula is in conjunctive normal form (CNF) or clausal normal form if it is a conjunction of clauses, where a clause is a disjunction of literals' (cited from https:\\/\\/en.wikipedia.org\\/wiki\\/Conjunctive_normal_form)\\n\\nIn the other words, CNF is a formula of type <image>, where & represents a logical \\\"AND\\\" (conjunction), <image> represents a logical \\\"OR\\\" (disjunction), and vij are some boolean variables or their negations. Each statement in brackets is called a clause, and vij are called literals.\\n\\nYou are given a CNF containing variables x1, ..., xm and their negations. We know that each variable occurs in at most two clauses (with negation and without negation in total). Your task is to determine whether this CNF is satisfiable, that is, whether there are such values of variables where the CNF value is true. If CNF is satisfiable, then you also need to determine the values of the variables at which the CNF is true. \\n\\nIt is guaranteed that each variable occurs at most once in each clause.\\n\\nInput\\n\\nThe first line contains integers n and m (1 \u2264 n, m \u2264 2\u00b7105) \u2014 the number of clauses and the number variables, correspondingly.\\n\\nNext n lines contain the descriptions of each clause. The i-th line first contains first number ki (ki \u2265 1) \u2014 the number of literals in the i-th clauses. Then follow space-separated literals vij (1 \u2264 |vij| \u2264 m). A literal that corresponds to vij is x|vij| either with negation, if vij is negative, or without negation otherwise.\\n\\nOutput\\n\\nIf CNF is not satisfiable, print a single line \\\"NO\\\" (without the quotes), otherwise print two strings: string \\\"YES\\\" (without the quotes), and then a string of m numbers zero or one \u2014 the values of variables in satisfying assignment in the order from x1 to xm.\\n\\nExamples\\n\\nInput\\n\\n2 2\\n2 1 -2\\n2 2 -1\\n\\n\\nOutput\\n\\nYES\\n11\\n\\n\\nInput\\n\\n4 3\\n1 1\\n1 2\\n3 -1 -2 3\\n1 -3\\n\\n\\nOutput\\n\\nNO\\n\\n\\nInput\\n\\n5 6\\n2 1 2\\n3 1 -2 3\\n4 -3 5 4 6\\n2 -6 -4\\n1 5\\n\\n\\nOutput\\n\\nYES\\n100010\\n\\nNote\\n\\nIn the first sample test formula is <image>. One of possible answer is x1 = TRUE, x2 = TRUE.\\\":\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nlong long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }\\nconst int MAXCLS = 200000;\\nconst int MAXVAR = 200000;\\nconst int MAXN = MAXCLS;\\nconst int MAXM = MAXVAR;\\nint ncls, nvar;\\nint vcnt[MAXVAR];\\nint vcls[MAXVAR][2];\\nint vsgn[MAXVAR][2];\\nint ret[MAXVAR];\\nbool cok[MAXCLS];\\nint n, m;\\nint head[MAXN];\\nint nxt[2 * MAXM], to[2 * MAXM], idx[MAXM];\\nint qhead, qtail, q[MAXN];\\nint cback[MAXN];\\nint dfs(int at, int back) {\\n  cback[at] = back;\\n  for (int x = head[at]; x != -1; x = nxt[x])\\n    if (x != back && !cok[to[x]]) {\\n      if (cback[to[x]] != -2) {\\n        cback[to[x]] = x ^ 1;\\n        return to[x];\\n      }\\n      int ret = dfs(to[x], x ^ 1);\\n      if (ret != -1) return ret;\\n    }\\n  cback[at] = -2;\\n  return -1;\\n}\\nvoid processqueue() {\\n  while (qtail < qhead) {\\n    int at = q[qtail++];\\n    for (int x = head[at]; x != -1; x = nxt[x])\\n      if (!cok[to[x]]) {\\n        ret[idx[x >> 1]] = x & 1, cok[to[x]] = true, q[qhead++] = to[x];\\n      }\\n  }\\n}\\nvoid run() {\\n  scanf(\\\"%d%d\\\", &ncls, &nvar);\\n  for (int i = (0); i < (ncls); ++i) {\\n    int ccnt;\\n    scanf(\\\"%d\\\", &ccnt);\\n    cok[i] = false;\\n    cback[i] = -2;\\n    for (int j = (0); j < (ccnt); ++j) {\\n      int x;\\n      scanf(\\\"%d\\\", &x);\\n      int val = abs(x) - 1, sgn = x < 0 ? 0 : +1;\\n      assert(vcnt[val] <= 2);\\n      vcls[val][vcnt[val]] = i;\\n      vsgn[val][vcnt[val]] = sgn;\\n      ++vcnt[val];\\n    }\\n  }\\n  n = ncls, m = 0;\\n  for (int i = (0); i < (n); ++i) head[i] = -1;\\n  for (int i = (0); i < (nvar); ++i) {\\n    if (vcnt[i] == 0) {\\n      ret[i] = 0;\\n      continue;\\n    }\\n    if (vcnt[i] == 1) {\\n      cok[vcls[i][0]] = true;\\n      ret[i] = vsgn[i][0];\\n      continue;\\n    }\\n    if (vsgn[i][0] == vsgn[i][1]) {\\n      cok[vcls[i][0]] = cok[vcls[i][1]] = true;\\n      ret[i] = vsgn[i][0];\\n      continue;\\n    }\\n    if (vsgn[i][0] == 0)\\n      swap(vsgn[i][0], vsgn[i][1]), swap(vcls[i][0], vcls[i][1]);\\n    int a = vcls[i][0], b = vcls[i][1];\\n    ret[i] = -1;\\n    idx[m >> 1] = i;\\n    nxt[m] = head[a];\\n    head[a] = m;\\n  ...\",\"language\":\"python\",\"split\":\"train\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in CPP?\\nThe only difference between this problem and D1 is that you don't have to provide the way to construct the answer in D1, but you have to do it in this problem.\\n\\nThere's a table of n \u00d7 m cells (n rows and m columns). The value of n \u22c5 m is even.\\n\\nA domino is a figure that consists of two cells having a common side. It may be horizontal (one of the cells is to the right of the other) or vertical (one of the cells is above the other).\\n\\nYou need to place nm\\/2 dominoes on the table so that exactly k of them are horizontal and all the other dominoes are vertical. The dominoes cannot overlap and must fill the whole table.\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 10) \u2014 the number of test cases. Then t test cases follow.\\n\\nEach test case consists of a single line. The line contains three integers n, m, k (1 \u2264 n,m \u2264 100, 0 \u2264 k \u2264 nm\\/2, n \u22c5 m is even) \u2014 the count of rows, columns and horizontal dominoes, respectively.\\n\\nOutput\\n\\nFor each test case:\\n\\n  * print \\\"NO\\\" if it's not possible to place the dominoes on the table in the described way; \\n  * otherwise, print \\\"YES\\\" on a separate line, then print n lines so that each of them contains m lowercase letters of the Latin alphabet \u2014 the layout of the dominoes on the table. Each cell of the table must be marked by the letter so that for every two cells having a common side, they are marked by the same letters if and only if they are occupied by the same domino. I.e. both cells of the same domino must be marked with the same letter, but two dominoes that share a side must be marked with different letters. If there are multiple solutions, print any of them. \\n\\nExample\\n\\nInput\\n\\n\\n8\\n4 4 2\\n2 3 0\\n3 2 3\\n1 2 0\\n2 4 2\\n5 2 2\\n2 17 16\\n2 1 1\\n\\n\\nOutput\\n\\n\\nYES\\naccx\\naegx\\nbega\\nbdda\\nYES\\naha\\naha\\nYES\\nzz\\naa\\nzz\\nNO\\nYES\\naaza\\nbbza\\nNO\\nYES\\nbbaabbaabbaabbaay\\nddccddccddccddccy\\nNO\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nusing ll = long long;\\nusing ld = long double;\\nconst long long INFI = 1e9 + 228;\\nconst ll INFL = 1e18 + 228;\\nconst ld INFLD = 1e18 + 228;\\nconst ld PI = acos(-1);\\nconst long long MAXN = 1e5 + 228;\\nvector<pair<long long, long long> > DD = {{-1, 0}, {1, 0}, {0, 1}, {0, -1}};\\nchar ans[105][105];\\nchar get(long long i, long long j, long long i2, long long j2) {\\n  set<char> q = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k'};\\n  for (auto u : DD) {\\n    long long i3 = i + u.first;\\n    long long j3 = j + u.second;\\n    long long i4 = i2 + u.first;\\n    long long j4 = j2 + u.second;\\n    if (i3 >= 0 && j3 >= 0 && i3 < 105 && j3 < 105) {\\n      q.erase(ans[i3][j3]);\\n    }\\n    if (i4 >= 0 && j4 >= 0 && i4 < 105 && j4 < 105) {\\n      q.erase(ans[i4][j4]);\\n    }\\n  }\\n  return *q.begin();\\n}\\nvoid run() {\\n  long long n, m, k;\\n  cin >> n >> m >> k;\\n  for (long long i = 1; i <= n; ++i) {\\n    for (long long j = 1; j <= m; ++j) ans[i][j] = '.';\\n  }\\n  if (n % 2 != 0) {\\n    if (k >= m \\/ 2 && (k - m \\/ 2) % 2 == 0) {\\n      cout << \\\"YES\\\" << endl;\\n      for (long long j = 1; j <= m; j += 2) {\\n        char now = get(1, j, 1, j + 1);\\n        ans[1][j] = now;\\n        ans[1][j + 1] = now;\\n        k--;\\n      }\\n      for (long long j = 1; j <= m && k > 0; j += 2) {\\n        for (long long i = 2; i <= n && k > 0; ++i) {\\n          char now = get(i, j, i, j + 1);\\n          ans[i][j] = now;\\n          ans[i][j + 1] = now;\\n          k--;\\n        }\\n      }\\n    } else {\\n      cout << \\\"NO\\\" << endl;\\n      return;\\n    }\\n  } else if (m % 2 == 0) {\\n    if (k % 2 == 0) {\\n      cout << \\\"YES\\\" << endl;\\n      for (long long j = 1; j <= m && k > 0; j += 2) {\\n        for (long long i = 1; i <= n && k > 0; ++i) {\\n          char now = get(i, j, i, j + 1);\\n          ans[i][j] = now;\\n          ans[i][j + 1] = now;\\n          k--;\\n        }\\n      }\\n    } else {\\n      cout << \\\"NO\\\" << endl;\\n      return;\\n    }\\n  } else {\\n    if (k % 2 == 0 && k <= (m \\/ 2) * n) {\\n      cout << \\\"YES\\\" << endl;\\n      for (long long j = 1; j <= m...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"Alice has a very important message M consisting of some non-negative integers that she wants to keep secret from Eve. Alice knows that the only theoretically secure cipher is one-time pad. Alice generates a random key K of the length equal to the message's length. Alice computes the bitwise xor of each element of the message and the key (<image>, where <image> denotes the [bitwise XOR operation](https:\\/\\/en.wikipedia.org\\/wiki\\/Bitwise_operation#XOR)) and stores this encrypted message A. Alice is smart. Be like Alice.\\n\\nFor example, Alice may have wanted to store a message M = (0, 15, 9, 18). She generated a key K = (16, 7, 6, 3). The encrypted message is thus A = (16, 8, 15, 17).\\n\\nAlice realised that she cannot store the key with the encrypted message. Alice sent her key K to Bob and deleted her own copy. Alice is smart. Really, be like Alice.\\n\\nBob realised that the encrypted message is only secure as long as the key is secret. Bob thus randomly permuted the key before storing it. Bob thinks that this way, even if Eve gets both the encrypted message and the key, she will not be able to read the message. Bob is not smart. Don't be like Bob.\\n\\nIn the above example, Bob may have, for instance, selected a permutation (3, 4, 1, 2) and stored the permuted key P = (6, 3, 16, 7).\\n\\nOne year has passed and Alice wants to decrypt her message. Only now Bob has realised that this is impossible. As he has permuted the key randomly, the message is lost forever. Did we mention that Bob isn't smart?\\n\\nBob wants to salvage at least some information from the message. Since he is not so smart, he asks for your help. You know the encrypted message A and the permuted key P. What is the lexicographically smallest message that could have resulted in the given encrypted text?\\n\\nMore precisely, for given A and P, find the lexicographically smallest message O, for which there exists a permutation \u03c0 such that <image> for every i.\\n\\nNote that the sequence S is lexicographically smaller than the sequence T, if there is an index i such that Si <...\\\":\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nstruct vertex {\\n  int nxt[2], cnt;\\n  vertex() {\\n    nxt[0] = nxt[1] = -1;\\n    cnt = 0;\\n  }\\n} t[4000000];\\nint sz = 1;\\nvoid add(string s) {\\n  int v = 0;\\n  for (int i = 0; i < s.size(); i++) {\\n    int c = s[i] - '0';\\n    if (t[v].nxt[c] == -1) {\\n      t[v].nxt[c] = sz++;\\n    }\\n    v = t[v].nxt[c];\\n    t[v].cnt++;\\n  }\\n}\\nvoid erase_e(string s) {\\n  int v = 0;\\n  for (int i = 0; i < s.size(); i++) {\\n    int c = s[i] - '0';\\n    v = t[v].nxt[c];\\n    t[v].cnt--;\\n  }\\n}\\nstring get(int x) {\\n  int v = 0;\\n  string s = \\\"\\\";\\n  for (int i = 30; i >= 0; i--) {\\n    if ((x >> i) & 1) {\\n      if (t[v].nxt[1] == -1 || t[t[v].nxt[1]].cnt == 0) {\\n        v = t[v].nxt[0];\\n        s += '0';\\n      } else {\\n        v = t[v].nxt[1];\\n        s += '1';\\n      }\\n    } else {\\n      if (t[v].nxt[0] == -1 || t[t[v].nxt[0]].cnt == 0) {\\n        v = t[v].nxt[1];\\n        s += '1';\\n      } else {\\n        v = t[v].nxt[0];\\n        s += '0';\\n      }\\n    }\\n  }\\n  return s;\\n}\\nlong long n, a[300001], b[300001];\\nint main() {\\n  cin >> n;\\n  for (int i = 1; i <= n; i++) {\\n    cin >> a[i];\\n  }\\n  for (int j = 1; j <= n; j++) {\\n    cin >> b[j];\\n    string s;\\n    for (int i = 30; i >= 0; i--) {\\n      if ((b[j] >> i) & 1) {\\n        s += '1';\\n      } else {\\n        s += '0';\\n      }\\n    }\\n    add(s);\\n  }\\n  for (int i = 1; i <= n; i++) {\\n    string s = get(a[i]);\\n    int ans = 0;\\n    int step = 0;\\n    for (int j = s.size() - 1; j >= 0; j--) {\\n      if (s[j] == '1') {\\n        ans += (1 << step);\\n      }\\n      step++;\\n    }\\n    cout << (a[i] ^ ans) << \\\" \\\";\\n    erase_e(s);\\n  }\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Chef and his girlfriend are going to have a promenade. They are walking along the straight road which consists of segments placed one by one. Before walking Chef and his girlfriend stay at the beginning of the first segment, they want to achieve the end of the last segment. \\nThere are few problems: \\n\\n At the beginning Chef should choose constant integer - the velocity of mooving. It can't be changed inside one segment. \\n The velocity should be decreased by at least 1 after achieving the end of some segment. \\n There is exactly one shop on each segment. Each shop has an attractiveness. If it's attractiveness is W and Chef and his girlfriend move with velocity V then if V < W girlfriend will run away into the shop and the promenade will become ruined. \\n\\n Chef doesn't want to lose her girl in such a way, but he is an old one, so you should find the minimal possible velocity at the first segment to satisfy all conditions.\\n\u00a0\\n\\n\\nInput\\n\\nThe first line of the input contains an integer T denoting the number of test cases. The description of T test cases follows.\\nThe first line of each test case contains a single integer N denoting the number of segments. The second line contains N space-separated integers W1, W2, ..., WN denoting the attractiveness of shops. \\n\\n\u00a0\\n\\nOutput\\n\\nFor each test case, output a single line containing the minimal possible velocity at the beginning.\\n\\n\u00a0\\n\\nConstraints\\n\\n1 \u2264 T \u2264 10\\n1 \u2264 N \u2264 10^5\\n1 \u2264 Wi \u2264 10^6\\n\\n\u00a0\\n\\nExample\\nInput:\\n\\n2\\n5\\n6 5 4 3 2\\n5\\n3 4 3 1 1\\n\\nOutput:\\n\\n6\\n5\\n\u00a0\\n\\nExplanation\\nExample case 1. \\n If we choose velocity 6, on the first step we have 6 \u2265 6 everything is OK, then we should decrease the velocity to 5 and on the 2nd segment we'll receive 5 \u2265 5, again OK, and so on. \\nExample case 2. \\n If we choose velocity 4, the promanade will be ruined on the 2nd step (we sould decrease our velocity, so the maximal possible will be 3 which is less than 4).\\nThe above is tricky. Write me a correct solution in PYTHON.\",\"targets\":\"cases = int(raw_input())\\n\\nfor _ in xrange(cases):\\n    raw_input()\\n    attractiveness = map(int, raw_input().split())\\n    for i, a in enumerate(attractiveness):\\n        attractiveness[i] += i\\n\\n    print max(attractiveness)\",\"language\":\"python\",\"split\":\"train\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Luntik came out for a morning stroll and found an array a of length n. He calculated the sum s of the elements of the array (s= \u2211_{i=1}^{n} a_i). Luntik calls a subsequence of the array a nearly full if the sum of the numbers in that subsequence is equal to s-1.\\n\\nLuntik really wants to know the number of nearly full subsequences of the array a. But he needs to come home so he asks you to solve that problem!\\n\\nA sequence x is a subsequence of a sequence y if x can be obtained from y by deletion of several (possibly, zero or all) elements.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 1000) \u2014 the number of test cases. The next 2 \u22c5 t lines contain descriptions of test cases. The description of each test case consists of two lines.\\n\\nThe first line of each test case contains a single integer n (1 \u2264 n \u2264 60) \u2014 the length of the array.\\n\\nThe second line contains n integers a_1, a_2, \u2026, a_n (0 \u2264 a_i \u2264 10^9) \u2014 the elements of the array a.\\n\\nOutput\\n\\nFor each test case print the number of nearly full subsequences of the array.\\n\\nExample\\n\\nInput\\n\\n\\n5\\n5\\n1 2 3 4 5\\n2\\n1000 1000\\n2\\n1 0\\n5\\n3 0 2 1 1\\n5\\n2 1 0 3 0\\n\\n\\nOutput\\n\\n\\n1\\n0\\n2\\n4\\n4\\n\\nNote\\n\\nIn the first test case, s=1+2+3+4+5=15, only (2,3,4,5) is a nearly full subsequence among all subsequences, the sum in it is equal to 2+3+4+5=14=15-1.\\n\\nIn the second test case, there are no nearly full subsequences.\\n\\nIn the third test case, s=1+0=1, the nearly full subsequences are (0) and () (the sum of an empty subsequence is 0).\\nUsing python3 can you solve the prior task?\",\"targets\":\"for _ in range(int(input())):\\n    n = int(input())\\n    A = list(map(int,input().split()))\\n    \\n    c1 = A.count(1)\\n    c0 = A.count(0)\\n    ans = c1*(2**c0)\\n    print(ans)\",\"language\":\"python\",\"split\":\"test\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"The Winter holiday will be here soon. Mr. Chanek wants to decorate his house's wall with ornaments. The wall can be represented as a binary string a of length n. His favorite nephew has another binary string b of length m (m \u2264 n).\\n\\nMr. Chanek's nephew loves the non-negative integer k. His nephew wants exactly k occurrences of b as substrings in a. \\n\\nHowever, Mr. Chanek does not know the value of k. So, for each k (0 \u2264 k \u2264 n - m + 1), find the minimum number of elements in a that have to be changed such that there are exactly k occurrences of b in a.\\n\\nA string s occurs exactly k times in t if there are exactly k different pairs (p,q) such that we can obtain s by deleting p characters from the beginning and q characters from the end of t.\\n\\nInput\\n\\nThe first line contains two integers n and m (1 \u2264 m \u2264 n \u2264 500) \u2014 size of the binary string a and b respectively.\\n\\nThe second line contains a binary string a of length n.\\n\\nThe third line contains a binary string b of length m.\\n\\nOutput\\n\\nOutput n - m + 2 integers \u2014 the (k+1)-th integer denotes the minimal number of elements in a that have to be changed so there are exactly k occurrences of b as a substring in a.\\n\\nExample\\n\\nInput\\n\\n\\n9 3\\n100101011\\n101\\n\\n\\nOutput\\n\\n\\n1 1 0 1 6 -1 -1 -1\\n\\nNote\\n\\nFor k = 0, to make the string a have no occurrence of 101, you can do one character change as follows.\\n\\n100101011 \u2192 100100011\\n\\nFor k = 1, you can also change a single character.\\n\\n100101011 \u2192 100001011\\n\\nFor k = 2, no changes are needed.\\\":\",\"targets\":\"#include <bits\\/stdc++.h>\\n#pragma GCC optimize(\\\"Ofast\\\")\\n#pragma GCC optimization(\\\"unroll-loops, no-stack-protector\\\")\\n#pragma GCC target(\\\"avx,avx2,fma\\\")\\nusing namespace std;\\nmt19937_64 rnd;\\nconst long long maxn = 5e2 + 50;\\nconst long long mod = 1e9 + 7;\\nconst long long base = 1e13;\\nconst long long magic = 2000;\\nstruct aho_corasick {\\n  struct tk {\\n    long long link;\\n    long long nxt[27];\\n    long long par;\\n    char ch;\\n    long long go[27];\\n    long long val;\\n    long long leaf;\\n    tk(long long par = -1, char ch = '0') : par(par), ch(ch) {\\n      memset(nxt, -1, sizeof(nxt));\\n      memset(go, -1, sizeof(go));\\n      val = -1;\\n      link = -1;\\n      leaf = 0;\\n    }\\n  };\\n  vector<tk> vt;\\n  void init() {\\n    vt.clear();\\n    vt.push_back({-1, '0'});\\n  }\\n  long long add(string s, long long val) {\\n    long long nw = 0;\\n    for (auto to : s) {\\n      if (vt[nw].nxt[to - '0' + 1] == -1) {\\n        vt[nw].nxt[to - '0' + 1] = vt.size();\\n        vt.push_back({nw, to});\\n      }\\n      nw = vt[nw].nxt[to - '0' + 1];\\n    }\\n    vt[nw].leaf = val;\\n    return nw;\\n  }\\n  long long get_val(long long u) {\\n    if (u == 0) return 0;\\n    if (vt[u].val == -1) {\\n      vt[u].val = vt[u].leaf + get_val(get_link(u));\\n    }\\n    return vt[u].val;\\n  }\\n  long long go(long long v, long long t) {\\n    if (vt[v].go[t] == -1) {\\n      if (vt[v].nxt[t] != -1) {\\n        vt[v].go[t] = vt[v].nxt[t];\\n      } else {\\n        if (v == 0)\\n          vt[v].go[t] = 0;\\n        else\\n          vt[v].go[t] = go(get_link(v), t);\\n      }\\n    }\\n    return vt[v].go[t];\\n  }\\n  long long get_link(long long v) {\\n    if (vt[v].link == -1) {\\n      if (vt[v].par == 0 || v == 0)\\n        vt[v].link = 0;\\n      else\\n        vt[v].link = go(get_link(vt[v].par), vt[v].ch - '0' + 1);\\n    }\\n    return vt[v].link;\\n  }\\n  long long get(string s) {\\n    long long nw = 0;\\n    long long ans = 0;\\n    for (auto to : s) {\\n      nw = go(nw, to - 'a' + 1);\\n      ans += get_val(nw);\\n    }\\n    return ans;\\n  }\\n} man;\\nlong long dp[2][maxn][maxn];\\nint main() {\\n  ios_base::sync_with_stdio(false);\\n ...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"You are given n integers a_1, a_2, \u2026, a_n. Find the maximum value of max(a_l, a_{l + 1}, \u2026, a_r) \u22c5 min(a_l, a_{l + 1}, \u2026, a_r) over all pairs (l, r) of integers for which 1 \u2264 l < r \u2264 n.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 10 000) \u2014 the number of test cases.\\n\\nThe first line of each test case contains a single integer n (2 \u2264 n \u2264 10^5).\\n\\nThe second line of each test case contains n integers a_1, a_2, \u2026, a_n (1 \u2264 a_i \u2264 10^6).\\n\\nIt is guaranteed that the sum of n over all test cases doesn't exceed 3 \u22c5 10^5.\\n\\nOutput\\n\\nFor each test case, print a single integer \u2014 the maximum possible value of the product from the statement.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n3\\n2 4 3\\n4\\n3 2 3 1\\n2\\n69 69\\n6\\n719313 273225 402638 473783 804745 323328\\n\\n\\nOutput\\n\\n\\n12\\n6\\n4761\\n381274500335\\n\\nNote\\n\\nLet f(l, r) = max(a_l, a_{l + 1}, \u2026, a_r) \u22c5 min(a_l, a_{l + 1}, \u2026, a_r).\\n\\nIn the first test case, \\n\\n  * f(1, 2) = max(a_1, a_2) \u22c5 min(a_1, a_2) = max(2, 4) \u22c5 min(2, 4) = 4 \u22c5 2 = 8. \\n  * f(1, 3) = max(a_1, a_2, a_3) \u22c5 min(a_1, a_2, a_3) = max(2, 4, 3) \u22c5 min(2, 4, 3) = 4 \u22c5 2 = 8. \\n  * f(2, 3) = max(a_2, a_3) \u22c5 min(a_2, a_3) = max(4, 3) \u22c5 min(4, 3) = 4 \u22c5 3 = 12. \\n\\n\\n\\nSo the maximum is f(2, 3) = 12.\\n\\nIn the second test case, the maximum is f(1, 2) = f(1, 3) = f(2, 3) = 6.\\\":\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint32_t main() {\\n  ios_base::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);\\n  int t;\\n  cin >> t;\\n  while (t--) {\\n    long long n, m = 0, c = 0, ans = 0;\\n    cin >> n;\\n    long long a[n];\\n    for (long long i = 0; i < n; i++) {\\n      cin >> a[i];\\n    }\\n    for (long long i = 0; i < n - 1; i++) {\\n      c = a[i] * a[i + 1];\\n      if (c > m) {\\n        m = c;\\n      }\\n    }\\n    cout << m << endl;\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Consider a simplified penalty phase at the end of a football match.\\n\\nA penalty phase consists of at most 10 kicks, the first team takes the first kick, the second team takes the second kick, then the first team takes the third kick, and so on. The team that scores more goals wins; if both teams score the same number of goals, the game results in a tie (note that it goes against the usual football rules). The penalty phase is stopped if one team has scored more goals than the other team could reach with all of its remaining kicks. For example, if after the 7-th kick the first team has scored 1 goal, and the second team has scored 3 goals, the penalty phase ends \u2014 the first team cannot reach 3 goals.\\n\\nYou know which player will be taking each kick, so you have your predictions for each of the 10 kicks. These predictions are represented by a string s consisting of 10 characters. Each character can either be 1, 0, or ?. This string represents your predictions in the following way:\\n\\n  * if s_i is 1, then the i-th kick will definitely score a goal; \\n  * if s_i is 0, then the i-th kick definitely won't score a goal; \\n  * if s_i is ?, then the i-th kick could go either way. \\n\\n\\n\\nBased on your predictions, you have to calculate the minimum possible number of kicks there can be in the penalty phase (that means, the earliest moment when the penalty phase is stopped, considering all possible ways it could go). Note that the referee doesn't take into account any predictions when deciding to stop the penalty phase \u2014 you may know that some kick will\\/won't be scored, but the referee doesn't.\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 1 000) \u2014 the number of test cases.\\n\\nEach test case is represented by one line containing the string s, consisting of exactly 10 characters. Each character is either 1, 0, or ?.\\n\\nOutput\\n\\nFor each test case, print one integer \u2014 the minimum possible number of kicks in the penalty phase.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n1?0???1001\\n1111111111\\n??????????\\n0100000000\\n\\n\\nOutput\\n\\n\\n7\\n10\\n6\\n9\\n\\nNote\\n\\nConsider...\\nUsing cpp can you solve the prior task?\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nsigned main() {\\n  ios::sync_with_stdio(false);\\n  cin.tie(0);\\n  cout.tie(0);\\n  long long t;\\n  cin >> t;\\n  while (t--) {\\n    long long ans1 = 10, ans2 = 10;\\n    long long g1 = 0, g2 = 0;\\n    long long l1 = 5, l2 = 5;\\n    string s;\\n    cin >> s;\\n    for (long long i = 0; i < s.length(); i++) {\\n      if (i % 2 == 0 && s[i] == '1') {\\n        g1++;\\n      }\\n      if (i % 2 == 0) {\\n        l1--;\\n      } else if (i % 2 == 1 && s[i] != '0') {\\n        g2++;\\n      }\\n      if ((g2 - g1) > l1) {\\n        ans1 = i + 1;\\n        break;\\n      }\\n    }\\n    g1 = 0;\\n    g2 = 0;\\n    for (long long i = 0; i < s.length(); i++) {\\n      if (i % 2 == 1 && s[i] == '1') {\\n        g1++;\\n      } else if (i % 2 == 0 && s[i] != '0') {\\n        g2++;\\n      }\\n      if (i % 2 == 1) {\\n        l2--;\\n      }\\n      if ((g2 - g1) > l2) {\\n        ans2 = i + 1;\\n        break;\\n      }\\n    }\\n    cout << min(ans1, ans2) << \\\"\\\\n\\\";\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"A binary string is a string that consists of characters 0 and 1. A bi-table is a table that has exactly two rows of equal length, each being a binary string.\\n\\nLet \\\\operatorname{MEX} of a bi-table be the smallest digit among 0, 1, or 2 that does not occur in the bi-table. For example, \\\\operatorname{MEX} for \\\\begin{bmatrix} 0011\\\\\\\\\\\\ 1010 \\\\end{bmatrix} is 2, because 0 and 1 occur in the bi-table at least once. \\\\operatorname{MEX} for \\\\begin{bmatrix} 111\\\\\\\\\\\\ 111 \\\\end{bmatrix} is 0, because 0 and 2 do not occur in the bi-table, and 0 < 2.\\n\\nYou are given a bi-table with n columns. You should cut it into any number of bi-tables (each consisting of consecutive columns) so that each column is in exactly one bi-table. It is possible to cut the bi-table into a single bi-table \u2014 the whole bi-table.\\n\\nWhat is the maximal sum of \\\\operatorname{MEX} of all resulting bi-tables can be?\\n\\nInput\\n\\nThe input consists of multiple test cases. The first line contains a single integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases. Description of the test cases follows.\\n\\nThe first line of the description of each test case contains a single integer n (1 \u2264 n \u2264 10^5) \u2014 the number of columns in the bi-table.\\n\\nEach of the next two lines contains a binary string of length n \u2014 the rows of the bi-table.\\n\\nIt's guaranteed that the sum of n over all test cases does not exceed 10^5.\\n\\nOutput\\n\\nFor each test case print a single integer \u2014 the maximal sum of \\\\operatorname{MEX} of all bi-tables that it is possible to get by cutting the given bi-table optimally.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n7\\n0101000\\n1101100\\n5\\n01100\\n10101\\n2\\n01\\n01\\n6\\n000000\\n111111\\n\\n\\nOutput\\n\\n\\n8\\n8\\n2\\n12\\n\\nNote\\n\\nIn the first test case you can cut the bi-table as follows:\\n\\n  * \\\\begin{bmatrix} 0\\\\\\\\\\\\ 1 \\\\end{bmatrix}, its \\\\operatorname{MEX} is 2.\\n  * \\\\begin{bmatrix} 10\\\\\\\\\\\\ 10 \\\\end{bmatrix}, its \\\\operatorname{MEX} is 2.\\n  * \\\\begin{bmatrix} 1\\\\\\\\\\\\ 1 \\\\end{bmatrix}, its \\\\operatorname{MEX} is 0.\\n  * \\\\begin{bmatrix} 0\\\\\\\\\\\\ 1 \\\\end{bmatrix}, its \\\\operatorname{MEX} is 2.\\n  * \\\\begin{bmatrix} 0\\\\\\\\\\\\ 0 \\\\end{bmatrix}, its...\\nThe above is tricky. Write me a correct solution in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nlong long getGcd(long long a, long long b) {\\n  if (a == 0) return b;\\n  return getGcd(b % a, a);\\n}\\nlong long getLcm(long long a, long long b) { return (a \\/ getGcd(a, b)) * b; }\\nint main() {\\n  ios::sync_with_stdio(0);\\n  cin.tie(0);\\n  int t;\\n  cin >> t;\\n  while (t--) {\\n    int n;\\n    cin >> n;\\n    string s1, s2;\\n    cin >> s1;\\n    cin >> s2;\\n    vector<int> mex;\\n    for (int i = 0; i < n; i++) {\\n      if (s1[i] == s2[i]) {\\n        if (s1[i] == '0')\\n          mex.push_back(1);\\n        else\\n          mex.push_back(0);\\n      } else\\n        mex.push_back(2);\\n    }\\n    int ans = 0;\\n    int last = -1;\\n    for (int i = 0; i < n; i++) {\\n      if (mex[i] == 2) {\\n        ans += 2;\\n        last = 2;\\n      } else if (mex[i] == 1) {\\n        if (last == 0) {\\n          ans += 2;\\n          last = 2;\\n        } else {\\n          ans += 1;\\n          last = 1;\\n        }\\n      } else {\\n        if (last == 1) {\\n          ans += 1;\\n          last = 2;\\n        } else {\\n          last = 0;\\n        }\\n      }\\n    }\\n    cout << ans << \\\"\\\\n\\\";\\n  }\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"A new agent called Killjoy invented a virus COVID-2069 that infects accounts on Codeforces. Each account has a rating, described by an integer (it can possibly be negative or very large).\\n\\nKilljoy's account is already infected and has a rating equal to x. Its rating is constant. There are n accounts except hers, numbered from 1 to n. The i-th account's initial rating is a_i. Any infected account (initially the only infected account is Killjoy's) instantly infects any uninfected account if their ratings are equal. This can happen at the beginning (before any rating changes) and after each contest. If an account is infected, it can not be healed.\\n\\nContests are regularly held on Codeforces. In each contest, any of these n accounts (including infected ones) can participate. Killjoy can't participate. After each contest ratings are changed this way: each participant's rating is changed by an integer, but the sum of all changes must be equal to zero. New ratings can be any integer.\\n\\nFind out the minimal number of contests needed to infect all accounts. You can choose which accounts will participate in each contest and how the ratings will change.\\n\\nIt can be proven that all accounts can be infected in some finite number of contests.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 100) \u2014 the number of test cases. The next 2t lines contain the descriptions of all test cases.\\n\\nThe first line of each test case contains two integers n and x (2 \u2264 n \u2264 10^3, -4000 \u2264 x \u2264 4000) \u2014 the number of accounts on Codeforces and the rating of Killjoy's account.\\n\\nThe second line of each test case contains n integers a_1, a_2, ..., a_n (-4000 \u2264 a_i \u2264 4000) \u2014 the ratings of other accounts.\\n\\nOutput\\n\\nFor each test case output the minimal number of contests needed to infect all accounts.\\n\\nExample\\n\\nInput\\n\\n\\n3\\n2 69\\n68 70\\n6 4\\n4 4 4 4 4 4\\n9 38\\n-21 83 50 -59 -77 15 -71 -78 20\\n\\n\\nOutput\\n\\n\\n1\\n0\\n2\\n\\nNote\\n\\nIn the first test case it's possible to make all ratings equal to 69. First account's rating will increase by 1, and second account's...\\nSolve the task in PYTHON3.\",\"targets\":\"# Author: S Mahesh Raju\\n# Username: maheshraju2020\\n# Date: 19\\/09\\/2020\\nfrom sys import stdin, stdout, setrecursionlimit\\nimport heapq\\nfrom math import gcd, ceil, sqrt\\nfrom collections import Counter, deque\\nfrom bisect import bisect_left, bisect_right\\nfrom itertools import combinations, permutations\\nii1 = lambda: int(stdin.readline().strip())\\nis1 = lambda: stdin.readline().strip()\\niia = lambda: list(map(int, stdin.readline().strip().split()))\\nisa = lambda: stdin.readline().strip().split()\\nsetrecursionlimit(100000)\\nmod = 1000000007\\n\\ntc = ii1()\\nfor _ in range(tc):\\n    n, x = iia()\\n    arr = iia()\\n    tot = 0\\n    temp = []\\n    for i in arr:\\n        tot += x - i\\n    if set(arr) == set([x]):\\n        print(0)\\n    elif tot == 0:\\n        print(1)\\n    elif tot != 0 and x in arr:\\n        print(1)\\n    else:\\n        print(2)\",\"language\":\"python\",\"split\":\"train\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"The Olympic Games have just started and Federico is eager to watch the marathon race.\\n\\nThere will be n athletes, numbered from 1 to n, competing in the marathon, and all of them have taken part in 5 important marathons, numbered from 1 to 5, in the past. For each 1\u2264 i\u2264 n and 1\u2264 j\u2264 5, Federico remembers that athlete i ranked r_{i,j}-th in marathon j (e.g., r_{2,4}=3 means that athlete 2 was third in marathon 4).\\n\\nFederico considers athlete x superior to athlete y if athlete x ranked better than athlete y in at least 3 past marathons, i.e., r_{x,j}<r_{y,j} for at least 3 distinct values of j.\\n\\nFederico believes that an athlete is likely to get the gold medal at the Olympics if he is superior to all other athletes.\\n\\nFind any athlete who is likely to get the gold medal (that is, an athlete who is superior to all other athletes), or determine that there is no such athlete.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 1000) \u2014 the number of test cases. Then t test cases follow.\\n\\nThe first line of each test case contains a single integer n (1\u2264 n\u2264 50 000) \u2014 the number of athletes.\\n\\nThen n lines follow, each describing the ranking positions of one athlete.\\n\\nThe i-th of these lines contains the 5 integers r_{i,1},\\\\,r_{i,2},\\\\,r_{i,3},\\\\,r_{i,4},  r_{i,5} (1\u2264 r_{i,j}\u2264 50 000) \u2014 the ranking positions of athlete i in the past 5 marathons. It is guaranteed that, in each of the 5 past marathons, the n athletes have distinct ranking positions, i.e., for each 1\u2264 j\u2264 5, the n values r_{1,j},  r_{2, j},  ...,  r_{n, j} are distinct.\\n\\nIt is guaranteed that the sum of n over all test cases does not exceed 50 000.\\n\\nOutput\\n\\nFor each test case, print a single integer \u2014 the number of an athlete who is likely to get the gold medal (that is, an athlete who is superior to all other athletes). If there are no such athletes, print -1. If there is more than such one athlete, print any of them.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n1\\n50000 1 50000 50000 50000\\n3\\n10 10 20 30 30\\n20 20 30 10 10\\n30 30 10 20 20\\n3\\n1 1 1 1 1\\n2 2 2 2 2\\n3 3 3 3 3\\n6\\n9 5 3 7...\\nSolve the task in PYTHON3.\",\"targets\":\"from collections import *\\n\\nfor _ in range(int(input())):\\n    n = int(input())\\n    ranking = [[*map(int, input().split())] for i in range(n)]\\n    if n == 1:\\n        print(1)\\n        continue\\n    hypothetical_winner = ranking[0]\\n\\n    winner = 0\\n    i = 1\\n    ans = 1\\n\\n    while i < n:\\n        cnt = 0\\n        for j in range(5):\\n            if ranking[i][j] < hypothetical_winner[j]:\\n                cnt += 1\\n\\n        if cnt >= 3:\\n            hypothetical_winner = ranking[i]\\n            ans = i + 1\\n\\n        i += 1\\n        \\n    flag = False\\n\\n    for i in range(n):\\n        if i + 1 != ans:\\n            cnt = 0\\n            for j in range(5):\\n                if ranking[i][j] < hypothetical_winner[j]:\\n                    cnt += 1\\n\\n            if cnt >= 3:\\n                flag = True\\n                break\\n\\n    print(-1 if flag else ans)\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Casimir has a string s which consists of capital Latin letters 'A', 'B', and 'C' only. Each turn he can choose to do one of the two following actions:\\n\\n  * he can either erase exactly one letter 'A' and exactly one letter 'B' from arbitrary places of the string (these letters don't have to be adjacent); \\n  * or he can erase exactly one letter 'B' and exactly one letter 'C' from arbitrary places in the string (these letters don't have to be adjacent). \\n\\n\\n\\nTherefore, each turn the length of the string is decreased exactly by 2. All turns are independent so for each turn, Casimir can choose any of two possible actions.\\n\\nFor example, with s = \\\"ABCABC\\\" he can obtain a string s = \\\"ACBC\\\" in one turn (by erasing the first occurrence of 'B' and the second occurrence of 'A'). There are also many other options for a turn aside from this particular example.\\n\\nFor a given string s determine whether there is a sequence of actions leading to an empty string. In other words, Casimir's goal is to erase all letters from the string. Is there a way to do this?\\n\\nInput\\n\\nThe first line contains an integer t (1 \u2264 t \u2264 1000) \u2014 the number of test cases.\\n\\nEach test case is described by one string s, for which you need to determine if it can be fully erased by some sequence of turns. The string s consists of capital letters 'A', 'B', 'C' and has a length from 1 to 50 letters, inclusive.\\n\\nOutput\\n\\nPrint t lines, each line containing the answer to the corresponding test case. The answer to a test case should be YES if there is a way to fully erase the corresponding string and NO otherwise.\\n\\nYou may print every letter in any case you want (so, for example, the strings yEs, yes, Yes, and YES will all be recognized as positive answers).\\n\\nExample\\n\\nInput\\n\\n\\n6\\nABACAB\\nABBA\\nAC\\nABC\\nCABCBB\\nBCBCBCBCBCBCBCBC\\n\\n\\nOutput\\n\\n\\nNO\\nYES\\nNO\\nNO\\nYES\\nYES\\n#incl\",\"targets\":\"ude <bits\\/stdc++.h>\\nusing namespace std;\\nint main() {\\n  int t;\\n  cin >> t;\\n  for (int i = 0; i < t; i++) {\\n    int a = 0, b = 0, c = 0;\\n    string s;\\n    cin >> s;\\n    for (int i = 0; i < s.length(); i++) {\\n      if (s[i] == 'A')\\n        a++;\\n      else if (s[i] == 'B')\\n        b++;\\n      else if (s[i] == 'C')\\n        c++;\\n    }\\n    if (a + c == b)\\n      cout << \\\"Yes\\\";\\n    else\\n      cout << \\\"No\\\";\\n    cout << endl;\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"AtCoDeer the deer found two rectangles lying on the table, each with height 1 and width W. If we consider the surface of the desk as a two-dimensional plane, the first rectangle covers the vertical range of [0,1] and the horizontal range of [a,a+W], and the second rectangle covers the vertical range of [1,2] and the horizontal range of [b,b+W], as shown in the following figure:\\n\\n<image>\\n\\nAtCoDeer will move the second rectangle horizontally so that it connects with the first rectangle. Find the minimum distance it needs to be moved.\\n\\nConstraints\\n\\n* All input values are integers.\\n* 1\u2264W\u226410^5\\n* 1\u2264a,b\u226410^5\\n\\nInput\\n\\nThe input is given from Standard Input in the following format:\\n\\n\\nW a b\\n\\n\\nOutput\\n\\nPrint the minimum distance the second rectangle needs to be moved.\\n\\nExamples\\n\\nInput\\n\\n3 2 6\\n\\n\\nOutput\\n\\n1\\n\\n\\nInput\\n\\n3 1 3\\n\\n\\nOutput\\n\\n0\\n\\n\\nInput\\n\\n5 10 1\\n\\n\\nOutput\\n\\n4\\nimpor\",\"targets\":\"t java.util.Scanner;\\n\\npublic class Main{\\n\\n\\tpublic static void main(String[] args) {\\n\\t\\tScanner sc = new Scanner(System.in);\\n\\t\\tint W = sc.nextInt();\\n\\t\\tint a = sc.nextInt();\\n\\t\\tint b = sc.nextInt();\\n\\t\\t\\n\\t\\tif(Math.abs(a - b) <= W){\\n\\t\\t\\tSystem.out.println(\\\"0\\\");\\n\\t\\t}else{\\n\\t\\t\\tSystem.out.println(Math.abs(a - b) - W);\\n\\t\\t}\\n\\t\\t\\n\\n\\t}\\n\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in CPP?\\nAn infinitely long railway has a train consisting of n cars, numbered from 1 to n (the numbers of all the cars are distinct) and positioned in arbitrary order. David Blaine wants to sort the railway cars in the order of increasing numbers. In one move he can make one of the cars disappear from its place and teleport it either to the beginning of the train, or to the end of the train, at his desire. What is the minimum number of actions David Blaine needs to perform in order to sort the train?\\n\\nInput\\n\\nThe first line of the input contains integer n (1 \u2264 n \u2264 100 000) \u2014 the number of cars in the train. \\n\\nThe second line contains n integers pi (1 \u2264 pi \u2264 n, pi \u2260 pj if i \u2260 j) \u2014 the sequence of the numbers of the cars in the train.\\n\\nOutput\\n\\nPrint a single integer \u2014 the minimum number of actions needed to sort the railway cars.\\n\\nExamples\\n\\nInput\\n\\n5\\n4 1 2 5 3\\n\\n\\nOutput\\n\\n2\\n\\n\\nInput\\n\\n4\\n4 1 3 2\\n\\n\\nOutput\\n\\n2\\n\\nNote\\n\\nIn the first sample you need first to teleport the 4-th car, and then the 5-th car to the end of the train.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst int N = 100500;\\nint t[N * 3], a[N], d[N], pos[N];\\nint get_max(int l, int r) {\\n  int res = 0;\\n  while (l <= r) {\\n    if (l % 2 == 1) {\\n      res = max(t[l], res);\\n    }\\n    if (r % 2 == 0) {\\n      res = max(t[r], res);\\n    }\\n    l = (l + 1) \\/ 2;\\n    r = (r - 1) \\/ 2;\\n  }\\n  return res;\\n}\\nvoid upd(int p) {\\n  while (p) {\\n    p \\/= 2;\\n    t[p] = max(t[p * 2], t[p * 2 + 1]);\\n  }\\n}\\nint main() {\\n  srand(time(NULL));\\n  int n;\\n  cin >> n;\\n  int sz = 1;\\n  while (sz <= n) {\\n    sz *= 2;\\n  }\\n  for (int i = 1; i <= n; i++) {\\n    cin >> a[i];\\n    pos[a[i]] = i;\\n  }\\n  int mx = 0;\\n  for (int i = 1; i <= n; i++) {\\n    d[i] = d[pos[a[i] - 1]] + 1;\\n    mx = max(mx, d[i]);\\n  }\\n  cout << n - mx;\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"During a break in the buffet of the scientific lyceum of the Kingdom of Kremland, there was formed a queue of n high school students numbered from 1 to n. Initially, each student i is on position i. Each student i is characterized by two numbers \u2014 a_i and b_i. Dissatisfaction of the person i equals the product of a_i by the number of people standing to the left of his position, add the product b_i by the number of people standing to the right of his position. Formally, the dissatisfaction of the student i, which is on the position j, equals a_i \u22c5 (j-1) + b_i \u22c5 (n-j).\\n\\nThe director entrusted Stas with the task: rearrange the people in the queue so that minimize the total dissatisfaction.\\n\\nAlthough Stas is able to solve such problems, this was not given to him. He turned for help to you.\\n\\nInput\\n\\nThe first line contains a single integer n (1 \u2264 n \u2264 10^5) \u2014 the number of people in the queue.\\n\\nEach of the following n lines contains two integers a_i and b_i (1 \u2264 a_i, b_i \u2264 10^8) \u2014 the characteristic of the student i, initially on the position i.\\n\\nOutput\\n\\nOutput one integer \u2014 minimum total dissatisfaction which can be achieved by rearranging people in the queue.\\n\\nExamples\\n\\nInput\\n\\n\\n3\\n4 2\\n2 3\\n6 1\\n\\n\\nOutput\\n\\n\\n12\\n\\nInput\\n\\n\\n4\\n2 4\\n3 3\\n7 1\\n2 3\\n\\n\\nOutput\\n\\n\\n25\\n\\nInput\\n\\n\\n10\\n5 10\\n12 4\\n31 45\\n20 55\\n30 17\\n29 30\\n41 32\\n7 1\\n5 5\\n3 15\\n\\n\\nOutput\\n\\n\\n1423\\n\\nNote\\n\\nIn the first example it is optimal to put people in this order: (3, 1, 2). The first person is in the position of 2, then his dissatisfaction will be equal to 4 \u22c5 1+2 \u22c5 1=6. The second person is in the position of 3, his dissatisfaction will be equal to 2 \u22c5 2+3 \u22c5 0=4. The third person is in the position of 1, his dissatisfaction will be equal to 6 \u22c5 0+1 \u22c5 2=2. The total dissatisfaction will be 12.\\n\\nIn the second example, you need to put people in this order: (3, 2, 4, 1). The total dissatisfaction will be 25.\",\"targets\":\"import java.util.*;   \\/\\/7\\nimport java.io.*;\\n\\/\\/Mai soch rha hu kauye ko codeforces pr add krlu pr drr lgta hai ki kahin rating na chura le.......... \\npublic class march\\n{\\n\\tpublic static class comp implements Comparator<pair>\\n\\t{\\n\\t\\tpublic int compare(pair p1,pair p2)\\n\\t\\t{\\n\\t\\t\\treturn (int)((p1.val-p1.key)-(p2.val-p2.key));\\n\\t\\t}\\n\\t}\\n\\tpublic static void main(String args[]) throws IOException\\n\\t{\\n\\t\\tReader sc=new Reader();\\n\\t\\tint n=sc.nextInt();\\n\\t\\tpair a[]=new pair[n];\\n\\t\\t\\n\\t\\tfor(int i=0;i<n;i++)\\n\\t\\ta[i]=new pair(sc.nextLong(),sc.nextLong());\\n\\t\\n\\t\\n\\t\\tArrays.sort(a,new comp());\\n\\t\\tlong ans=0;\\n\\t\\tfor(int i=0;i<n;i++)\\n\\t\\t{\\n\\t\\t\\tif(i==0)\\n\\t\\t\\t{\\n\\t\\t\\t\\tans+=a[i].val*(n-1)*1L;\\n\\t\\t\\t}\\n\\t\\t\\telse if(i==n-1)\\n\\t\\t\\t{\\n\\t\\t\\t\\tans+=(a[i].key*1L)*(n-1);\\n\\t\\t\\t}\\n\\t\\t\\telse\\n\\t\\t\\t{\\n\\t\\t\\t\\tans+=(a[i].key*1l)*(i)*1l+(a[i].val*1l)*(n-i-1);\\n\\t\\t\\t}\\n\\t\\t}\\n\\t\\tSystem.out.println(ans);\\n\\t\\t\\n\\t\\t\\n\\t}\\n\\t\\n\\t\\n\\t\\n\\t\\n\\t\\n\\t\\n\\t\\n\\t\\n\\t\\n\\t\\n\\t\\n\\t\\n\\t\\n\\t\\n\\t\\n\\t\\n\\t\\n\\t\\n\\t\\n\\t\\n\\t\\n\\t\\n\\t\\n\\t\\n\\t\\n\\t\\n\\t\\n\\t\\n\\t\\n\\t\\n\\t\\n\\tstatic class pair\\n{\\n\\tlong key;\\n\\tlong val;\\n\\tpair(long key,long val)\\n\\t{\\n\\t\\tthis.key=key;\\n\\t\\tthis.val=val;\\n\\t}\\n}\\n\\t\\n\\t public static LinkedList<Integer> sieveOfEratosthenes(int n) \\n    {  \\n        boolean prime[] = new boolean[n+1];\\n\\t\\tLinkedList<Integer> l=new LinkedList<Integer>();\\t\\n        for(int i=0;i<n;i++) \\n            prime[i] = true; \\n          \\n        for(int p = 2; p*p <=n; p++) \\n        { \\n            if(prime[p] == true) \\n            { \\n                for(int i = p*p; i <= n; i += p) \\n                    prime[i] = false; \\n            } \\n        } \\n        for(int i = 2; i <= n; i++) \\n        { \\n            if(prime[i] == true) \\n            l.add(i); \\n        }\\n\\t\\treturn l;\\t\\n    } \\n\\t\\n\\tstatic class Reader \\n    { \\n        final private int BUFFER_SIZE = 1 << 16; \\n        private DataInputStream din; \\n        private byte[] buffer; \\n        private int bufferPointer, bytesRead; \\n  \\n        public Reader() \\n        { \\n            din = new DataInputStream(System.in); \\n            buffer = new byte[BUFFER_SIZE]; \\n            bufferPointer = bytesRead = 0; \\n        } \\n  \\n        public Reader(String file_name) throws IOException \\n       ...\",\"language\":\"python\",\"split\":\"train\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Dora loves adventures quite a lot. During some journey she encountered an amazing city, which is formed by n streets along the Eastern direction and m streets across the Southern direction. Naturally, this city has nm intersections. At any intersection of i-th Eastern street and j-th Southern street there is a monumental skyscraper. Dora instantly became curious and decided to explore the heights of the city buildings.\\n\\nWhen Dora passes through the intersection of the i-th Eastern and j-th Southern street she examines those two streets. After Dora learns the heights of all the skyscrapers on those two streets she wonders: how one should reassign heights to the skyscrapers on those two streets, so that the maximum height would be as small as possible and the result of comparing the heights of any two skyscrapers on one street wouldn't change.\\n\\nFormally, on every of nm intersections Dora solves an independent problem. She sees n + m - 1 skyscrapers and for each of them she knows its real height. Moreover, any two heights can be compared to get a result \\\"greater\\\", \\\"smaller\\\" or \\\"equal\\\". Now Dora wants to select some integer x and assign every skyscraper a height from 1 to x. When assigning heights, Dora wants to preserve the relative order of the skyscrapers in both streets. That is, the result of any comparison of heights of two skyscrapers in the current Eastern street shouldn't change and the result of any comparison of heights of two skyscrapers in current Southern street shouldn't change as well. Note that skyscrapers located on the Southern street are not compared with skyscrapers located on the Eastern street only. However, the skyscraper located at the streets intersection can be compared with both Southern and Eastern skyscrapers. For every intersection Dora wants to independently calculate the minimum possible x.\\n\\nFor example, if the intersection and the two streets corresponding to it look as follows:\\n\\n<image>\\n\\nThen it is optimal to replace the heights of the skyscrapers as follows (note that all...\\nThe above is tricky. Write me a correct solution in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst double PI = acos(-1.0);\\nconst double eps = 1e-6;\\nconst int inf = 1e9;\\nconst long long llf = 1e18;\\nconst int mod = 1e9 + 7;\\nconst int maxn = 1e5 + 10;\\nint n, m;\\nint a[1010][1010];\\nvector<int> r[1010], c[1010];\\nint main() {\\n  ios::sync_with_stdio(false);\\n  cin >> n >> m;\\n  for (int i = 1; i <= n; i++) {\\n    for (int j = 1; j <= m; j++) {\\n      cin >> a[i][j];\\n      r[i].push_back(a[i][j]);\\n      c[j].push_back(a[i][j]);\\n    }\\n  }\\n  for (int i = 1; i <= n; i++) {\\n    sort(r[i].begin(), r[i].end());\\n    r[i].erase(unique(r[i].begin(), r[i].end()), r[i].end());\\n  }\\n  for (int i = 1; i <= m; i++) {\\n    sort(c[i].begin(), c[i].end());\\n    c[i].erase(unique(c[i].begin(), c[i].end()), c[i].end());\\n  }\\n  for (int i = 1; i <= n; i++) {\\n    for (int j = 1; j <= m; j++) {\\n      int x = lower_bound(r[i].begin(), r[i].end(), a[i][j]) - r[i].begin();\\n      int y = lower_bound(c[j].begin(), c[j].end(), a[i][j]) - c[j].begin();\\n      int ans = max(max(x, y) + (int)c[j].size() - y,\\n                    max(x, y) + (int)r[i].size() - x);\\n      cout << ans << \\\" \\\";\\n    }\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"A schoolboy named Vasya loves reading books on programming and mathematics. He has recently read an encyclopedia article that described the method of median smoothing (or median filter) and its many applications in science and engineering. Vasya liked the idea of the method very much, and he decided to try it in practice.\\n\\nApplying the simplest variant of median smoothing to the sequence of numbers a1, a2, ..., an will result a new sequence b1, b2, ..., bn obtained by the following algorithm:\\n\\n  * b1 = a1, bn = an, that is, the first and the last number of the new sequence match the corresponding numbers of the original sequence. \\n  * For i = 2, ..., n - 1 value bi is equal to the median of three values ai - 1, ai and ai + 1. \\n\\n\\n\\nThe median of a set of three numbers is the number that goes on the second place, when these three numbers are written in the non-decreasing order. For example, the median of the set 5, 1, 2 is number 2, and the median of set 1, 0, 1 is equal to 1.\\n\\nIn order to make the task easier, Vasya decided to apply the method to sequences consisting of zeros and ones only.\\n\\nHaving made the procedure once, Vasya looked at the resulting sequence and thought: what if I apply the algorithm to it once again, and then apply it to the next result, and so on? Vasya tried a couple of examples and found out that after some number of median smoothing algorithm applications the sequence can stop changing. We say that the sequence is stable, if it does not change when the median smoothing is applied to it.\\n\\nNow Vasya wonders, whether the sequence always eventually becomes stable. He asks you to write a program that, given a sequence of zeros and ones, will determine whether it ever becomes stable. Moreover, if it ever becomes stable, then you should determine what will it look like and how many times one needs to apply the median smoothing algorithm to initial sequence in order to obtain a stable one.\\n\\nInput\\n\\nThe first input line of the input contains a single integer n (3 \u2264 n \u2264 500 000) \u2014 the length of...\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst int maxn = 500010;\\nint a[maxn], n, t, b[maxn], sum[maxn];\\nvoid update(int i, int l) {\\n  t = max(t, (l + 1) \\/ 2);\\n  if (l % 2 == 1)\\n    for (int j = i - l; j <= i - 1; j++) a[j] = a[i];\\n  else {\\n    for (int j = i - l; j <= i - l \\/ 2 - 1; j++) a[j] = a[i] ^ 1;\\n    for (int j = i - l \\/ 2; j <= i - 1; j++) a[j] = a[i];\\n  }\\n}\\nint main() {\\n  scanf(\\\"%d\\\", &n);\\n  for (int i = 1; i <= n; i++) scanf(\\\"%d\\\", &a[i]);\\n  int l = 0;\\n  for (int i = 2; i < n; i++) {\\n    if (a[i] != a[i + 1] && a[i] != a[i - 1])\\n      l++;\\n    else {\\n      update(i, l);\\n      l = 0;\\n    }\\n  }\\n  update(n, l);\\n  printf(\\\"%d\\\\n\\\", t);\\n  for (int i = 1; i <= n; i++) printf(\\\"%d \\\", a[i]);\\n  printf(\\\"\\\\n\\\");\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You are given an array a of length n.\\n\\nLet's define the eversion operation. Let x = a_n. Then array a is partitioned into two parts: left and right. The left part contains the elements of a that are not greater than x (\u2264 x). The right part contains the elements of a that are strictly greater than x (> x). The order of elements in each part is kept the same as before the operation, i. e. the partition is stable. Then the array is replaced with the concatenation of the left and the right parts.\\n\\nFor example, if the array a is [2, 4, 1, 5, 3], the eversion goes like this: [2, 4, 1, 5, 3] \u2192 [2, 1, 3], [4, 5] \u2192 [2, 1, 3, 4, 5].\\n\\nWe start with the array a and perform eversions on this array. We can prove that after several eversions the array a stops changing. Output the minimum number k such that the array stops changing after k eversions.\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 100). Description of the test cases follows.\\n\\nThe first line contains a single integer n (1 \u2264 n \u2264 2 \u22c5 10^5).\\n\\nThe second line contains n integers a_1, a_2, ..., a_n (1 \u2264 a_i \u2264 10^9).\\n\\nIt is guaranteed that the sum of n over all test cases does not exceed 2 \u22c5 10^5.\\n\\nOutput\\n\\nFor each test case print a single integer k \u2014 the number of eversions after which the array stops changing.\\n\\nExample\\n\\nInput\\n\\n\\n3\\n5\\n2 4 1 5 3\\n5\\n5 3 2 4 1\\n4\\n1 1 1 1\\n\\n\\nOutput\\n\\n\\n1\\n2\\n0\\n\\nNote\\n\\nConsider the fist example.\\n\\n  * The first eversion: a = [1, 4, 2, 5, 3], x = 3. [2, 4, 1, 5, 3] \u2192 [2, 1, 3], [4, 5] \u2192 [2, 1, 3, 4, 5]. \\n  * The second and following eversions: a = [2, 1, 3, 4, 5], x = 5. [2, 1, 3, 4, 5] \u2192 [2, 1, 3, 4, 5], [] \u2192 [2, 1, 3, 4, 5]. This eversion does not change the array, so the answer is 1. \\n\\n\\n\\nConsider the second example. \\n\\n  * The first eversion: a = [5, 3, 2, 4, 1], x = 1. [5, 3, 2, 4, 1] \u2192 [1], [5, 3, 2, 4] \u2192 [1, 5, 3, 2, 4]. \\n  * The second eversion: a = [1, 5, 3, 2, 4], x = 4. [1, 5, 3, 2, 4] \u2192 [1, 3, 2, 4], [5] \u2192 [1, 3, 2, 4, 5]. \\n  * The third and following eversions: a = [1, 3, 2, 4,...\\nUsing java can you solve the prior task?\",\"targets\":\"import java.io.BufferedReader;\\nimport java.io.IOException;\\nimport java.io.InputStreamReader;\\nimport java.io.PrintWriter;\\nimport java.util.ArrayList;\\nimport java.util.*;\\n\\npublic class ArrayEversion {\\n    static class Fast {\\n        BufferedReader br;\\n        StringTokenizer st;\\n\\n        public Fast() {\\n            br = new BufferedReader(\\n                    new InputStreamReader(System.in));\\n        }\\n\\n        String next() {\\n            while (st == null || !st.hasMoreElements()) {\\n                try {\\n                    st = new StringTokenizer(br.readLine());\\n                } catch (IOException e) {\\n                    e.printStackTrace();\\n                }\\n            }\\n            return st.nextToken();\\n        }\\n\\n        int nextInt() {\\n            return Integer.parseInt(next());\\n        }\\n\\n        long nextLong() {\\n            return Long.parseLong(next());\\n        }\\n\\n        double nextDouble() {\\n            return Double.parseDouble(next());\\n        }\\n\\n        int[] readArray(int n) {\\n            int a[] = new int[n];\\n            for (int i = 0; i < n; i++)\\n                a[i] = nextInt();\\n            return a;\\n        }\\n\\n        long[] readArray1(int n) {\\n            long a[] = new long[n];\\n            for (int i = 0; i < n; i++)\\n                a[i] = nextLong();\\n            return a;\\n        }\\n\\n        String nextLine() {\\n            String str = \\\"\\\";\\n            try {\\n                str = br.readLine().trim();\\n            } catch (IOException e) {\\n                e.printStackTrace();\\n            }\\n            return str;\\n        }\\n    }\\n\\n    public static void main(String args[]) {\\n        Fast sc = new Fast();\\n        PrintWriter out = new PrintWriter(System.out);\\n        int t = sc.nextInt();\\n        while (t-- > 0) {\\n            int n = sc.nextInt();\\n           ArrayList<Integer> arr=new ArrayList<>();\\n           for(int i=0;i<n;i++)\\n               arr.add(sc.nextInt());\\n            long count=0;\\nlong max=arr.get(n-1);\\n           for(int i=n-2;i>=0;i--)\\n           {\\n              ...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You are given two positive integers n and s. Find the maximum possible median of an array of n non-negative integers (not necessarily distinct), such that the sum of its elements is equal to s.\\n\\nA median of an array of integers of length m is the number standing on the \u2308 {m\\/2} \u2309-th (rounding up) position in the non-decreasing ordering of its elements. Positions are numbered starting from 1. For example, a median of the array [20,40,20,50,50,30] is the \u2308 m\\/2 \u2309-th element of [20,20,30,40,50,50], so it is 30. There exist other definitions of the median, but in this problem we use the described definition.\\n\\nInput\\n\\nThe input consists of multiple test cases. The first line contains a single integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases. Description of the test cases follows.\\n\\nEach test case contains a single line with two integers n and s (1 \u2264 n, s \u2264 10^9) \u2014 the length of the array and the required sum of the elements.\\n\\nOutput\\n\\nFor each test case print a single integer \u2014 the maximum possible median.\\n\\nExample\\n\\nInput\\n\\n\\n8\\n1 5\\n2 5\\n3 5\\n2 1\\n7 17\\n4 14\\n1 1000000000\\n1000000000 1\\n\\n\\nOutput\\n\\n\\n5\\n2\\n2\\n0\\n4\\n4\\n1000000000\\n0\\n\\nNote\\n\\nPossible arrays for the first three test cases (in each array the median is underlined):\\n\\n  * In the first test case [\\\\underline{5}] \\n  * In the second test case [\\\\underline{2}, 3] \\n  * In the third test case [1, \\\\underline{2}, 2] \\nSolve the task in JAVA.\",\"targets\":\"import java.util.*;\\npublic class median \\n{\\n    public static void main(String[] args)\\n    {\\n        try \\n        {\\n            Scanner sc=new Scanner(System.in);\\n            int T=sc.nextInt();\\n            for(int i=0;i<T;i++)\\n            {\\n                int n=sc.nextInt();\\n                int s=sc.nextInt();\\n                    if((n%2)!=0)\\n                  System.out.println((s\\/((n+1)\\/2)));\\n                  else\\n                  System.out.println((s\\/((n+2)\\/2)));\\n            }\\n        }\\n        catch(Exception e)\\n        {\\n            return;\\n        }\\n    }\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Three little pigs from all over the world are meeting for a convention! Every minute, a triple of 3 new pigs arrives on the convention floor. After the n-th minute, the convention ends.\\n\\nThe big bad wolf has learned about this convention, and he has an attack plan. At some minute in the convention, he will arrive and eat exactly x pigs. Then he will get away.\\n\\nThe wolf wants Gregor to help him figure out the number of possible attack plans that involve eating exactly x pigs for various values of x (1 \u2264 x \u2264 3n). Two attack plans are considered different, if they occur at different times or if the sets of little pigs to eat are different.\\n\\nNote that all queries are independent, that is, the wolf does not eat the little pigs, he only makes plans!\\n\\nInput\\n\\nThe first line of input contains two integers n and q (1 \u2264 n \u2264 10^6, 1 \u2264 q \u2264 2\u22c5 10^5), the number of minutes the convention lasts and the number of queries the wolf asks.\\n\\nEach of the next q lines contains a single integer x_i (1 \u2264 x_i \u2264 3n), the number of pigs the wolf will eat in the i-th query.\\n\\nOutput\\n\\nYou should print q lines, with line i representing the number of attack plans if the wolf wants to eat x_i pigs. Since each query answer can be large, output each answer modulo 10^9+7.\\n\\nExamples\\n\\nInput\\n\\n\\n2 3\\n1\\n5\\n6\\n\\n\\nOutput\\n\\n\\n9\\n6\\n1\\n\\n\\nInput\\n\\n\\n5 4\\n2\\n4\\n6\\n8\\n\\n\\nOutput\\n\\n\\n225\\n2001\\n6014\\n6939\\n\\nNote\\n\\nIn the example test, n=2. Thus, there are 3 pigs at minute 1, and 6 pigs at minute 2. There are three queries: x=1, x=5, and x=6.\\n\\nIf the wolf wants to eat 1 pig, he can do so in 3+6=9 possible attack plans, depending on whether he arrives at minute 1 or 2.\\n\\nIf the wolf wants to eat 5 pigs, the wolf cannot arrive at minute 1, since there aren't enough pigs at that time. Therefore, the wolf has to arrive at minute 2, and there are 6 possible attack plans.\\n\\nIf the wolf wants to eat 6 pigs, his only plan is to arrive at the end of the convention and devour everybody.\\n\\nRemember to output your answers modulo 10^9+7!\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst int mxn = 3e6 + 7, du = 1e9 + 7;\\nint add(int a, int b) {\\n  a += b;\\n  a %= du;\\n  return a;\\n}\\nint sub(int a, int b) {\\n  a -= b;\\n  if (a < 0) a += du;\\n  return a;\\n}\\nint mul(int a, int b) {\\n  long long pro = (long long)a * (long long)b;\\n  pro %= du;\\n  return pro;\\n}\\nint pw(int a, int b) {\\n  int res = 1;\\n  while (b) {\\n    if (b % 2) res = mul(res, a);\\n    a = mul(a, a);\\n    b \\/= 2;\\n  }\\n  return res;\\n}\\nint dv(int a, int b) { return mul(a, pw(b, du - 2)); }\\nint fact[mxn], inv[mxn];\\nvoid init() {\\n  fact[0] = 1;\\n  for (int i = 1; i < mxn; i++) fact[i] = mul(fact[i - 1], i);\\n  inv[mxn - 1] = dv(1, fact[mxn - 1]);\\n  for (int i = mxn - 2; i >= 0; i--) inv[i] = mul(inv[i + 1], i + 1);\\n}\\nint C(int a, int b) {\\n  if (a > b) return 0;\\n  return mul(fact[b], mul(inv[a], inv[b - a]));\\n}\\nint n, q;\\nint dp[mxn][3];\\nsigned main() {\\n  ios::sync_with_stdio(0);\\n  cin.tie(0);\\n  cout.tie(0);\\n  init();\\n  cin >> n >> q;\\n  dp[0][0] = dp[0][1] = dp[0][2] = n;\\n  for (int i = 1; i < 3 * n; i++) {\\n    int sum = C(i + 1, 3 * n);\\n    dp[i][0] = dv(sub(sub(sum, mul(2, dp[i - 1][0])), dp[i - 1][1]), 3);\\n    dp[i][1] = add(dp[i][0], dp[i - 1][0]);\\n    dp[i][2] = add(dp[i][1], dp[i - 1][1]);\\n  }\\n  while (q--) {\\n    int x;\\n    cin >> x;\\n    cout << add(dp[x][0], C(x, 3 * n)) << '\\\\n';\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"This problem is an extension of the problem \\\"Wonderful Coloring - 1\\\". It has quite many differences, so you should read this statement completely.\\n\\nRecently, Paul and Mary have found a new favorite sequence of integers a_1, a_2, ..., a_n. They want to paint it using pieces of chalk of k colors. The coloring of a sequence is called wonderful if the following conditions are met:\\n\\n  1. each element of the sequence is either painted in one of k colors or isn't painted; \\n  2. each two elements which are painted in the same color are different (i. e. there's no two equal values painted in the same color); \\n  3. let's calculate for each of k colors the number of elements painted in the color \u2014 all calculated numbers must be equal; \\n  4. the total number of painted elements of the sequence is the maximum among all colorings of the sequence which meet the first three conditions. \\n\\n\\n\\nE. g. consider a sequence a=[3, 1, 1, 1, 1, 10, 3, 10, 10, 2] and k=3. One of the wonderful colorings of the sequence is shown in the figure.\\n\\n<image> The example of a wonderful coloring of the sequence a=[3, 1, 1, 1, 1, 10, 3, 10, 10, 2] and k=3. Note that one of the elements isn't painted.\\n\\nHelp Paul and Mary to find a wonderful coloring of a given sequence a.\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 10000) \u2014 the number of test cases. Then t test cases follow.\\n\\nEach test case consists of two lines. The first one contains two integers n and k (1 \u2264 n \u2264 2\u22c510^5, 1 \u2264 k \u2264 n) \u2014 the length of a given sequence and the number of colors, respectively. The second one contains n integers a_1, a_2, ..., a_n (1 \u2264 a_i \u2264 n).\\n\\nIt is guaranteed that the sum of n over all test cases doesn't exceed 2 \u22c5 10^5.\\n\\nOutput\\n\\nOutput t lines, each of them must contain a description of a wonderful coloring for the corresponding test case.\\n\\nEach wonderful coloring must be printed as a sequence of n integers c_1, c_2, ..., c_n (0 \u2264 c_i \u2264 k) separated by spaces where\\n\\n  * c_i=0, if i-th element isn't painted; \\n  * c_i>0, if i-th element is painted in the...\",\"targets\":\"import java.util.Arrays;\\nimport java.util.Comparator;\\nimport java.util.Scanner;\\nimport static java.lang.Integer.min;\\n\\npublic class problemB {\\n    static Scanner input = new Scanner(System.in);\\n    static void solve() {\\n        int n = input.nextInt();\\n        int k = input.nextInt();\\n        int[] a = new int[n];\\n        Integer[] id = new Integer[n];\\n        int[] c = new int[n];\\n        for(int i=0; i<n; i++) {\\n            a[i] = input.nextInt() - 1;\\n            id[i] = i;\\n        }\\n        Arrays.sort(id, Comparator.comparingInt(x -> a[(int) x]));\\n        int col = 1;\\n        int[] cache = new int[k];\\n        for(int i=0; i<n; ) {\\n            int j = i + 1;\\n            while(j<n && a[id[j]]==a[id[i]]) ++j;\\n            int ed = min(j, i+k);\\n            while(i!=ed) {\\n                cache[col-1] = id[i];\\n                col++;\\n                if(col==k+1) {\\n                    for(int t=0; t<k; t++) c[cache[t]] = t + 1;\\n                    col -= k;\\n                }\\n                i++;\\n            }\\n            i = j;\\n        }\\n        for(int i=0; i<n; i++) System.out.print(c[i] + \\\" \\\");\\n        System.out.println();\\n    }\\n    public static void main(String[] args) {\\n        int test = input.nextInt();\\n        while(test>0) {\\n            solve();\\n            --test;\\n        }\\n    }\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"A soldier wants to buy w bananas in the shop. He has to pay k dollars for the first banana, 2k dollars for the second one and so on (in other words, he has to pay i\u00b7k dollars for the i-th banana). \\n\\nHe has n dollars. How many dollars does he have to borrow from his friend soldier to buy w bananas?\\n\\nInput\\n\\nThe first line contains three positive integers k, n, w (1 \u2264 k, w \u2264 1000, 0 \u2264 n \u2264 109), the cost of the first banana, initial number of dollars the soldier has and number of bananas he wants. \\n\\nOutput\\n\\nOutput one integer \u2014 the amount of dollars that the soldier must borrow from his friend. If he doesn't have to borrow money, output 0.\\n\\nExamples\\n\\nInput\\n\\n3 17 4\\n\\n\\nOutput\\n\\n13\",\"targets\":\"k, n, w = map(int, input().split())\\nsum = i = 0\\nwhile w:\\n\\tw -= 1\\n\\ti += 1\\n\\tsum += i*k\\nprint(max(0, sum-n))\",\"language\":\"python\",\"split\":\"train\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Alice and Borys are playing tennis.\\n\\nA tennis match consists of games. In each game, one of the players is serving and the other one is receiving.\\n\\nPlayers serve in turns: after a game where Alice is serving follows a game where Borys is serving, and vice versa.\\n\\nEach game ends with a victory of one of the players. If a game is won by the serving player, it's said that this player holds serve. If a game is won by the receiving player, it's said that this player breaks serve.\\n\\nIt is known that Alice won a games and Borys won b games during the match. It is unknown who served first and who won which games.\\n\\nFind all values of k such that exactly k breaks could happen during the match between Alice and Borys in total.\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 10^3). Description of the test cases follows.\\n\\nEach of the next t lines describes one test case and contains two integers a and b (0 \u2264 a, b \u2264 10^5; a + b > 0) \u2014 the number of games won by Alice and Borys, respectively.\\n\\nIt is guaranteed that the sum of a + b over all test cases does not exceed 2 \u22c5 10^5.\\n\\nOutput\\n\\nFor each test case print two lines.\\n\\nIn the first line, print a single integer m (1 \u2264 m \u2264 a + b + 1) \u2014 the number of values of k such that exactly k breaks could happen during the match.\\n\\nIn the second line, print m distinct integers k_1, k_2, \u2026, k_m (0 \u2264 k_1 < k_2 < \u2026 < k_m \u2264 a + b) \u2014 the sought values of k in increasing order.\\n\\nExample\\n\\nInput\\n\\n\\n3\\n2 1\\n1 1\\n0 5\\n\\n\\nOutput\\n\\n\\n4\\n0 1 2 3\\n2\\n0 2\\n2\\n2 3\\n\\nNote\\n\\nIn the first test case, any number of breaks between 0 and 3 could happen during the match: \\n\\n  * Alice holds serve, Borys holds serve, Alice holds serve: 0 breaks; \\n  * Borys holds serve, Alice holds serve, Alice breaks serve: 1 break; \\n  * Borys breaks serve, Alice breaks serve, Alice holds serve: 2 breaks; \\n  * Alice breaks serve, Borys breaks serve, Alice breaks serve: 3 breaks. \\n\\n\\n\\nIn the second test case, the players could either both hold serves (0 breaks) or both break serves (2...\\n\\ncnt\",\"targets\":\"= int(input())\\n\\n\\nfor _ in range(cnt):\\n\\ta, b = map(int, input().split())\\n\\tif b > a: a, b = b, a # a >= b now\\n\\n\\tdiff = a - b\\n\\n\\tmin_breaks = diff \\/\\/ 2\\n\\ta -= 2 * min_breaks\\n\\tcould_be_odd = a > b\\n\\n\\tnext_games = a + b\\n\\n\\tpossibilities = [str(min_breaks + i) for i in range(next_games+1) if could_be_odd or (i % 2 == 0)]\\n\\n\\tprint(len(possibilities))\\n\\tprint(\\\" \\\".join(possibilities))\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"Nearly each project of the F company has a whole team of developers working on it. They often are in different rooms of the office in different cities and even countries. To keep in touch and track the results of the project, the F company conducts shared online meetings in a Spyke chat.\\n\\nOne day the director of the F company got hold of the records of a part of an online meeting of one successful team. The director watched the record and wanted to talk to the team leader. But how can he tell who the leader is? The director logically supposed that the leader is the person who is present at any conversation during a chat meeting. In other words, if at some moment of time at least one person is present on the meeting, then the leader is present on the meeting.\\n\\nYou are the assistant director. Given the 'user logged on'\\/'user logged off' messages of the meeting in the chronological order, help the director determine who can be the leader. Note that the director has the record of only a continuous part of the meeting (probably, it's not the whole meeting).\\n\\nInput\\n\\nThe first line contains integers n and m (1 \u2264 n, m \u2264 105) \u2014 the number of team participants and the number of messages. Each of the next m lines contains a message in the format:\\n\\n  * '+ id': the record means that the person with number id (1 \u2264 id \u2264 n) has logged on to the meeting. \\n  * '- id': the record means that the person with number id (1 \u2264 id \u2264 n) has logged off from the meeting. \\n\\n\\n\\nAssume that all the people of the team are numbered from 1 to n and the messages are given in the chronological order. It is guaranteed that the given sequence is the correct record of a continuous part of the meeting. It is guaranteed that no two log on\\/log off events occurred simultaneously.\\n\\nOutput\\n\\nIn the first line print integer k (0 \u2264 k \u2264 n) \u2014 how many people can be leaders. In the next line, print k integers in the increasing order \u2014 the numbers of the people who can be leaders.\\n\\nIf the data is such that no member of the team can be a leader, print a single...\\\":\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint n, m;\\nint mcnt;\\nint cnt[100007];\\nint met[100007];\\nint lead[100007];\\nvector<int> metp;\\nvector<int> metm;\\nvector<int> endd;\\nint main() {\\n  scanf(\\\"%d %d\\\", &n, &m);\\n  char c[1];\\n  int d;\\n  for (int i = 0; i < m; i++) {\\n    scanf(\\\"%s %d\\\", &c, &d);\\n    if (c[0] == '-')\\n      met[i] = (-1) * d;\\n    else\\n      met[i] = d;\\n  }\\n  for (int i = 0; i < m; i++) {\\n    if (met[i] < 0)\\n      if (cnt[abs(met[i])] == 0) {\\n        metp.push_back(abs(met[i]));\\n        cnt[abs(met[i])] = 1;\\n      }\\n    cnt[abs(met[i])]++;\\n  }\\n  for (int i = 1; i <= n; i++) cnt[i] = 0;\\n  for (int i = m - 1; i >= 0; i--) {\\n    if (met[i] > 0)\\n      if (cnt[abs(met[i])] == 0) {\\n        metm.push_back((-1) * met[i]);\\n        cnt[abs(met[i])] = 1;\\n      }\\n    cnt[abs(met[i])]++;\\n  }\\n  for (int i = metp.size() - 1; i >= 0; i--) endd.push_back(metp[i]);\\n  for (int i = 0; i < m; i++) endd.push_back(met[i]);\\n  for (int i = 0; i < metm.size(); i++) endd.push_back(metm[i]);\\n  m = endd.size();\\n  for (int i = 0; i < m; i++) lead[abs(endd[i])] = 1;\\n  mcnt = 0;\\n  int pr = endd[0];\\n  bool f = 0;\\n  if (endd[m - 1] == -pr)\\n    for (int i = 0; i < m; i++) {\\n      if (endd[i] == -pr)\\n        if (i != m - 1)\\n          if (endd[i + 1] != pr || mcnt != 1) f = 1;\\n      if (endd[i] < 0)\\n        mcnt--;\\n      else\\n        mcnt++;\\n    }\\n  else\\n    f = 1;\\n  if (f == 0) lead[pr] = 0;\\n  mcnt = 0;\\n  for (int i = 1; i <= n; i++)\\n    if (lead[i] == 0) mcnt++;\\n  printf(\\\"%d\\\\n\\\", mcnt);\\n  for (int i = 1; i <= n; i++)\\n    if (lead[i] == 0) printf(\\\"%d \\\", i);\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Polycarp has found a table having an infinite number of rows and columns. The rows are numbered from 1, starting from the topmost one. The columns are numbered from 1, starting from the leftmost one.\\n\\nInitially, the table hasn't been filled and Polycarp wants to fix it. He writes integers from 1 and so on to the table as follows.\\n\\n<image> The figure shows the placement of the numbers from 1 to 10. The following actions are denoted by the arrows.\\n\\nThe leftmost topmost cell of the table is filled with the number 1. Then he writes in the table all positive integers beginning from 2 sequentially using the following algorithm.\\n\\nFirst, Polycarp selects the leftmost non-filled cell in the first row and fills it. Then, while the left neighbor of the last filled cell is filled, he goes down and fills the next cell. So he goes down until the last filled cell has a non-filled neighbor to the left (look at the vertical arrow going down in the figure above).\\n\\nAfter that, he fills the cells from the right to the left until he stops at the first column (look at the horizontal row in the figure above). Then Polycarp selects the leftmost non-filled cell in the first row, goes down, and so on.\\n\\nA friend of Polycarp has a favorite number k. He wants to know which cell will contain the number. Help him to find the indices of the row and the column, such that the intersection of the row and the column is the cell containing the number k.\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 100) \u2014 the number of test cases. Then t test cases follow.\\n\\nEach test case consists of one line containing one integer k (1 \u2264 k \u2264 10^9) which location must be found.\\n\\nOutput\\n\\nFor each test case, output in a separate line two integers r and c (r, c \u2265 1) separated by spaces \u2014 the indices of the row and the column containing the cell filled by the number k, respectively.\\n\\nExample\\n\\nInput\\n\\n\\n7\\n11\\n14\\n5\\n4\\n1\\n2\\n1000000000\\n\\n\\nOutput\\n\\n\\n2 4\\n4 3\\n1 3\\n2 1\\n1 1\\n1 2\\n31623 14130\\nimpor\",\"targets\":\"t math\\nt=int(input())\\nwhile t:\\n\\n    k=int(input())\\n    x=int(math.sqrt(k))\\n    y=x*x\\n    p=x+1\\n    q=p*p\\n    if k==y:\\n        print(x,1)\\n    elif (q-k)<=(p-1):\\n        print(p,q-k+1)\\n    else:\\n        a=1\\n        for i in range(y+1,10**9+1):\\n            if i==k:\\n                break\\n            else:\\n                a+=1\\n        print(a,p)\\n\\n\\n    t-=1\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"A bracket sequence is a string containing only characters \\\"(\\\" and \\\")\\\". A regular bracket sequence (or, shortly, an RBS) 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:\\n\\n  * bracket sequences \\\"()()\\\" and \\\"(())\\\" are regular (the resulting expressions are: \\\"(1)+(1)\\\" and \\\"((1+1)+1)\\\"); \\n  * bracket sequences \\\")(\\\", \\\"(\\\" and \\\")\\\" are not. \\n\\n\\n\\nLet's denote the concatenation of two strings x and y as x+y. For example, \\\"()()\\\" + \\\")(\\\" = \\\"()())(\\\".\\n\\nYou are given n bracket sequences s_1, s_2, ..., s_n. You can rearrange them in any order (you can rearrange only the strings themselves, but not the characters in them).\\n\\nYour task is to rearrange the strings in such a way that the string s_1 + s_2 + ... + s_n has as many non-empty prefixes that are RBS as possible.\\n\\nInput\\n\\nThe first line contains a single integer n (1 \u2264 n \u2264 20).\\n\\nThen n lines follow, the i-th of them contains s_i \u2014 a bracket sequence (a string consisting of characters \\\"(\\\" and\\/or \\\")\\\". All sequences s_i are non-empty, their total length does not exceed 4 \u22c5 10^5.\\n\\nOutput\\n\\nPrint one integer \u2014 the maximum number of non-empty prefixes that are RBS for the string s_1 + s_2 + ... + s_n, if the strings s_1, s_2, ..., s_n can be rearranged arbitrarily.\\n\\nExamples\\n\\nInput\\n\\n\\n2\\n(\\n)\\n\\n\\nOutput\\n\\n\\n1\\n\\n\\nInput\\n\\n\\n4\\n()()())\\n(\\n(\\n)\\n\\n\\nOutput\\n\\n\\n4\\n\\n\\nInput\\n\\n\\n1\\n(())\\n\\n\\nOutput\\n\\n\\n1\\n\\n\\nInput\\n\\n\\n1\\n)(()\\n\\n\\nOutput\\n\\n\\n0\\n\\nNote\\n\\nIn the first example, you can concatenate the strings as follows: \\\"(\\\" + \\\")\\\" = \\\"()\\\", the resulting string will have one prefix, that is an RBS: \\\"()\\\".\\n\\nIn the second example, you can concatenate the strings as follows: \\\"(\\\" + \\\")\\\" + \\\"()()())\\\" + \\\"(\\\" = \\\"()()()())(\\\", the resulting string will have four prefixes that are RBS: \\\"()\\\", \\\"()()\\\", \\\"()()()\\\", \\\"()()()()\\\".\\n\\nThe third and the fourth examples contain only one string each, so the order is fixed.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\ntemplate <class _F, class _S>\\nostream &operator<<(ostream &out, const pair<_F, _S> &_pair) {\\n  return out << \\\"(\\\" << _pair.first << \\\",\\\" << _pair.second << \\\")\\\";\\n}\\ntemplate <class T>\\nostream &operator<<(ostream &out, const vector<T> &_vec) {\\n  out << \\\"[\\\";\\n  for (int _vecp = 0; _vecp < _vec.size(); ++_vecp)\\n    out << _vec[_vecp] << \\\",]\\\"[_vecp + 1 == _vec.size()];\\n  return out;\\n}\\nvoid debug() {}\\ntemplate <class T, class... U>\\nvoid debug(const T &head, const U &...tail) {\\n  cerr << head << (sizeof...(tail) ? \\\" \\\" : \\\"\\\\n\\\"), debug(tail...);\\n}\\ntemplate <class... T>\\nvoid D(const T &...parm) {\\n  cerr << \\\">>> \\\", debug(parm...);\\n}\\nconst int mx = 4e5 + 10;\\nconst long long mod = 998244353;\\nmt19937_64 mtrand(time(0));\\nint n, m, T;\\nstring s[20];\\nint b[20];\\nint cnt[1 << 20];\\nvector<int> vec[20];\\nunordered_map<int, int> mp[20], mp2[20];\\nint dp[1 << 20][2];\\nint sk[mx], tot;\\nvoid solve(int id) {\\n  for (int i = 0; i < s[id].size(); ++i) {\\n    if (s[id][i] == '(')\\n      ++b[id];\\n    else\\n      --b[id];\\n    vec[id].push_back(b[id]);\\n    ++mp2[id][b[id]];\\n    if (!mp[id].count(b[id])) mp[id][b[id]] = mp2[id][b[id] + 1];\\n  }\\n}\\nvoid run_case() {\\n  cin >> n;\\n  for (int i = 0; i < n; ++i) {\\n    cin >> s[i];\\n    solve(i);\\n  }\\n  int up = 1 << n;\\n  for (int i = 0; i < up; ++i) {\\n    for (int j = 0; j < n; ++j) {\\n      if ((i >> j) & 1) cnt[i] += b[j];\\n    }\\n    dp[i][0] = dp[i][1] = -0x3f3f3f3f;\\n  }\\n  dp[0][0] = 0;\\n  for (int i = 1; i < up; ++i) {\\n    for (int j = 0; j < n; ++j) {\\n      if ((i >> j) & 1) {\\n        int st = i & (up - (1 << j) - 1);\\n        if (mp[j].count(-cnt[st] - 1)) {\\n          dp[i][1] = max(dp[i][1], dp[st][0] + mp[j][-cnt[st] - 1]);\\n        } else {\\n          dp[i][0] = max(dp[i][0], dp[st][0] + mp2[j][-cnt[st]]);\\n        }\\n        dp[i][1] = max(dp[i][1], dp[st][1]);\\n      }\\n    }\\n  }\\n  long long ans = max(dp[up - 1][0], dp[up - 1][1]);\\n  cout << ans << \\\"\\\\n\\\";\\n}\\nint main() {\\n  ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);\\n  T = 1;\\n  for (int i = 1; i <= T; ++i)...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Some number of people (this number is even) have stood in a circle. The people stand in the circle evenly. They are numbered clockwise starting from a person with the number 1. Each person is looking through the circle's center at the opposite person.\\n\\n<image> A sample of a circle of 6 persons. The orange arrows indicate who is looking at whom.\\n\\nYou don't know the exact number of people standing in the circle (but this number is even, no doubt). It is known that the person with the number a is looking at the person with the number b (and vice versa, of course). What is the number associated with a person being looked at by the person with the number c? If, for the specified a, b, and c, no such circle exists, output -1.\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases. Then t test cases follow.\\n\\nEach test case consists of one line containing three distinct integers a, b, c (1 \u2264 a,b,c \u2264 10^8).\\n\\nOutput\\n\\nFor each test case output in a separate line a single integer d \u2014 the number of the person being looked at by the person with the number c in a circle such that the person with the number a is looking at the person with the number b. If there are multiple solutions, print any of them. Output -1 if there's no circle meeting the given conditions.\\n\\nExample\\n\\nInput\\n\\n\\n7\\n6 2 4\\n2 3 1\\n2 4 10\\n5 3 4\\n1 3 2\\n2 5 4\\n4 3 2\\n\\n\\nOutput\\n\\n\\n8\\n-1\\n-1\\n-1\\n4\\n1\\n-1\\n\\nNote\\n\\nIn the first test case, there's a desired circle of 8 people. The person with the number 6 will look at the person with the number 2 and the person with the number 8 will look at the person with the number 4.\\n\\nIn the second test case, there's no circle meeting the conditions. If the person with the number 2 is looking at the person with the number 3, the circle consists of 2 people because these persons are neighbors. But, in this case, they must have the numbers 1 and 2, but it doesn't meet the problem's conditions.\\n\\nIn the third test case, the only circle with the persons with the numbers 2 and 4 looking at each other consists of 4...\\nUsing python3 can you solve the prior task?\",\"targets\":\"import os\\nimport sys\\nfrom io import BytesIO, IOBase\\n \\n \\n#--------------------fastio--------------------\\n\\nBUFSIZE = 8192\\n\\n\\nclass FastIO(IOBase):\\n    newlines = 0\\n\\n    def __init__(self, file):\\n        self._fd = file.fileno()\\n        self.buffer = BytesIO()\\n        self.writable = \\\"x\\\" in file.mode or \\\"r\\\" not in file.mode\\n        self.write = self.buffer.write if self.writable else None\\n\\n    def read(self):\\n        while True:\\n            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))\\n            if not b:\\n                break\\n            ptr = self.buffer.tell()\\n            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)\\n        self.newlines = 0\\n        return self.buffer.read()\\n\\n    def readline(self):\\n        while self.newlines == 0:\\n            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))\\n            self.newlines = b.count(b\\\"\\\\n\\\") + (not b)\\n            ptr = self.buffer.tell()\\n            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)\\n        self.newlines -= 1\\n        return self.buffer.readline()\\n\\n    def flush(self):\\n        if self.writable:\\n            os.write(self._fd, self.buffer.getvalue())\\n            self.buffer.truncate(0), self.buffer.seek(0)\\n\\n\\nclass IOWrapper(IOBase):\\n    def __init__(self, file):\\n        self.buffer = FastIO(file)\\n        self.flush = self.buffer.flush\\n        self.writable = self.buffer.writable\\n        self.write = lambda s: self.buffer.write(s.encode(\\\"ascii\\\"))\\n        self.read = lambda: self.buffer.read().decode(\\\"ascii\\\")\\n        self.readline = lambda: self.buffer.readline().decode(\\\"ascii\\\")\\n\\n\\nif(os.path.exists('input.txt')):\\n    sys.stdin = open('input.txt','r') ; sys.stdout = open('output.txt','w')\\nelse:\\n    sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)\\n    input = lambda: sys.stdin.readline().rstrip(\\\"\\\\r\\\\n\\\")\\n\\nfor t in range(int(input())):\\n    a,b,c = map(int, input().split())\\n    size = abs(a-b) * 2\\n    if size < max(a,b,c):\\n        print(-1)\\n    else:\\n        if...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"A total of n depots are located on a number line. Depot i lies at the point x_i for 1 \u2264 i \u2264 n.\\n\\nYou are a salesman with n bags of goods, attempting to deliver one bag to each of the n depots. You and the n bags are initially at the origin 0. You can carry up to k bags at a time. You must collect the required number of goods from the origin, deliver them to the respective depots, and then return to the origin to collect your next batch of goods.\\n\\nCalculate the minimum distance you need to cover to deliver all the bags of goods to the depots. You do not have to return to the origin after you have delivered all the bags.\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 10 500). Description of the test cases follows.\\n\\nThe first line of each test case contains two integers n and k (1 \u2264 k \u2264 n \u2264 2 \u22c5 10^5).\\n\\nThe second line of each test case contains n integers x_1, x_2, \u2026, x_n (-10^9 \u2264 x_i \u2264 10^9). It is possible that some depots share the same position.\\n\\nIt is guaranteed that the sum of n over all test cases does not exceed 2 \u22c5 10^5.\\n\\nOutput\\n\\nFor each test case, output a single integer denoting the minimum distance you need to cover to deliver all the bags of goods to the depots. \\n\\nExample\\n\\nInput\\n\\n\\n4\\n5 1\\n1 2 3 4 5\\n9 3\\n-5 -10 -15 6 5 8 3 7 4\\n5 3\\n2 2 3 3 3\\n4 2\\n1000000000 1000000000 1000000000 1000000000\\n\\n\\nOutput\\n\\n\\n25\\n41\\n7\\n3000000000\\n\\nNote\\n\\nIn the first test case, you can carry only one bag at a time. Thus, the following is a solution sequence that gives a minimum travel distance: 0 \u2192 2 \u2192 0 \u2192 4 \u2192 0 \u2192 3 \u2192 0 \u2192 1 \u2192 0 \u2192 5, where each 0 means you go the origin and grab one bag, and each positive integer means you deliver the bag to a depot at this coordinate, giving a total distance of 25 units. It must be noted that there are other sequences that give the same distance.\\n\\nIn the second test case, you can follow the following sequence, among multiple such sequences, to travel minimum distance: 0 \u2192 6 \u2192 8 \u2192 7 \u2192 0 \u2192 5 \u2192 4 \u2192 3 \u2192 0 \u2192 (-5) \u2192 (-10) \u2192 (-15), with distance...\\nThe above is tricky. Write me a correct solution in JAVA.\",\"targets\":\"import java.io.BufferedReader;\\nimport java.io.IOException;\\nimport java.io.InputStreamReader;\\nimport java.io.PrintWriter;\\nimport java.util.*;\\n\\npublic class minimizeDist {\\n    static class Fast {\\n        BufferedReader br;\\n        StringTokenizer st;\\n\\n        public Fast() {\\n            br = new BufferedReader(\\n                    new InputStreamReader(System.in));\\n        }\\n\\n        String next() {\\n            while (st == null || !st.hasMoreElements()) {\\n                try {\\n                    st = new StringTokenizer(br.readLine());\\n                } catch (IOException e) {\\n                    e.printStackTrace();\\n                }\\n            }\\n            return st.nextToken();\\n        }\\n\\n        int nextInt() {\\n            return Integer.parseInt(next());\\n        }\\n\\n        long nextLong() {\\n            return Long.parseLong(next());\\n        }\\n\\n        double nextDouble() {\\n            return Double.parseDouble(next());\\n        }\\n\\n        int[] readArray(int n) {\\n            int a[] = new int[n];\\n            for (int i = 0; i < n; i++)\\n                a[i] = nextInt();\\n            return a;\\n        }\\n\\n        long[] readArray1(int n) {\\n            long a[] = new long[n];\\n            for (int i = 0; i < n; i++)\\n                a[i] = nextLong();\\n            return a;\\n        }\\n\\n        String nextLine() {\\n            String str = \\\"\\\";\\n            try {\\n                str = br.readLine().trim();\\n            } catch (IOException e) {\\n                e.printStackTrace();\\n            }\\n            return str;\\n        }\\n    }\\n\\n    public static void main(String args[]) {\\n        Fast sc = new Fast();\\n        PrintWriter out = new PrintWriter(System.out);\\n        int t = sc.nextInt();\\n        while (t-- > 0) {\\n            int n = sc.nextInt();\\n            int k = sc.nextInt();\\n            long arr[] = sc.readArray1(n);\\n            Arrays.sort(arr);\\n            long res = 0;\\n            if (arr[0] < 0&&n>0) {\\n                if (arr[n - 1] >= 0&&Math.abs(arr[0]) >= arr[n - 1] )\\n                {\\n              ...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in PYTHON3?\\nYou are given a string s of length n consisting of characters a and\\/or b.\\n\\nLet \\\\operatorname{AB}(s) be the number of occurrences of string ab in s as a substring. Analogically, \\\\operatorname{BA}(s) is the number of occurrences of ba in s as a substring.\\n\\nIn one step, you can choose any index i and replace s_i with character a or b.\\n\\nWhat is the minimum number of steps you need to make to achieve \\\\operatorname{AB}(s) = \\\\operatorname{BA}(s)?\\n\\nReminder:\\n\\nThe number of occurrences of string d in s as substring is the number of indices i (1 \u2264 i \u2264 |s| - |d| + 1) such that substring s_i s_{i + 1} ... s_{i + |d| - 1} is equal to d. For example, \\\\operatorname{AB}(aabbbabaa) = 2 since there are two indices i: i = 2 where aabbbabaa and i = 6 where aabbbabaa.\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 1000). Description of the test cases follows.\\n\\nThe first and only line of each test case contains a single string s (1 \u2264 |s| \u2264 100, where |s| is the length of the string s), consisting only of characters a and\\/or b.\\n\\nOutput\\n\\nFor each test case, print the resulting string s with \\\\operatorname{AB}(s) = \\\\operatorname{BA}(s) you'll get making the minimum number of steps.\\n\\nIf there are multiple answers, print any of them.\\n\\nExample\\n\\nInput\\n\\n\\n4\\nb\\naabbbabaa\\nabbb\\nabbaab\\n\\n\\nOutput\\n\\n\\nb\\naabbbabaa\\nbbbb\\nabbaaa\\n\\nNote\\n\\nIn the first test case, both \\\\operatorname{AB}(s) = 0 and \\\\operatorname{BA}(s) = 0 (there are no occurrences of ab (ba) in b), so can leave s untouched.\\n\\nIn the second test case, \\\\operatorname{AB}(s) = 2 and \\\\operatorname{BA}(s) = 2, so you can leave s untouched. \\n\\nIn the third test case, \\\\operatorname{AB}(s) = 1 and \\\\operatorname{BA}(s) = 0. For example, we can change s_1 to b and make both values zero.\\n\\nIn the fourth test case, \\\\operatorname{AB}(s) = 2 and \\\\operatorname{BA}(s) = 1. For example, we can change s_6 to a and make both values equal to 1.\",\"targets\":\"for i in range(int(input())):\\n    s=input()\\n    a=0\\n    for i in range(len(s)-1):\\n        if s[i]=='a' and s[i+1]=='b':\\n            a+=1\\n        if s[i]=='b' and s[i+1]=='a':\\n            a-=1\\n    if a==0:\\n        print(s)\\n    else:\\n        if s[0]=='a':\\n            s='b'+s[1:]\\n        else:\\n            s='a'+s[1:]\\n        a=0\\n        for i in range(len(s)-1):\\n            if s[i]=='a' and s[i+1]=='b':\\n                    a+=1\\n            if s[i]=='b' and s[i+1]=='a':\\n                a-=1\\n        if a==0:\\n            print(s)\\n        else:\\n            if s[0]=='a':\\n                s='b'+s[1:]\\n            else:\\n                s='a'+s[1:]\\n            if s[-1]=='a':\\n                s=s[:-1]+'b'\\n            else:\\n                s=s[:-1]+'a'\\n            a=0\\n            for i in range(len(s)-1):\\n                if s[i]=='a' and s[i+1]=='b':\\n                        a+=1\\n                if s[i]=='b' and s[i+1]=='a':\\n                    a-=1\\n            if a==0:\\n                print(s)\\n            else:\\n                if s[0]=='a':\\n                    s='b'+s[1:]\\n                else:\\n                    s='a'+s[1:]\\n                print(s)\",\"language\":\"python\",\"split\":\"test\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Tanya is learning how to add numbers, but so far she is not doing it correctly. She is adding two numbers a and b using the following algorithm:\\n\\n  1. If one of the numbers is shorter than the other, Tanya adds leading zeros so that the numbers are the same length. \\n  2. The numbers are processed from right to left (that is, from the least significant digits to the most significant). \\n  3. In the first step, she adds the last digit of a to the last digit of b and writes their sum in the answer. \\n  4. At each next step, she performs the same operation on each pair of digits in the same place and writes the result to the left side of the answer. \\n\\n\\n\\nFor example, the numbers a = 17236 and b = 3465 Tanya adds up as follows:\\n\\n$$$ \\\\large{ \\\\begin{array}{r} + \\\\begin{array}{r} 17236\\\\\\\\\\\\ 03465\\\\\\\\\\\\ \\\\end{array} \\\\\\\\\\\\ \\\\hline \\\\begin{array}{r} 1106911 \\\\end{array} \\\\end{array}} $$$\\n\\n  * calculates the sum of 6 + 5 = 11 and writes 11 in the answer. \\n  * calculates the sum of 3 + 6 = 9 and writes the result to the left side of the answer to get 911. \\n  * calculates the sum of 2 + 4 = 6 and writes the result to the left side of the answer to get 6911. \\n  * calculates the sum of 7 + 3 = 10, and writes the result to the left side of the answer to get 106911. \\n  * calculates the sum of 1 + 0 = 1 and writes the result to the left side of the answer and get 1106911. \\n\\n\\n\\nAs a result, she gets 1106911.\\n\\nYou are given two positive integers a and s. Find the number b such that by adding a and b as described above, Tanya will get s. Or determine that no suitable b exists.\\n\\nInput\\n\\nThe first line of input data contains an integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases.\\n\\nEach test case consists of a single line containing two positive integers a and s (1 \u2264 a < s \u2264 10^{18}) separated by a space.\\n\\nOutput\\n\\nFor each test case print the answer on a separate line.\\n\\nIf the solution exists, print a single positive integer b. The answer must be written without leading zeros. If multiple answers exist, print any of them.\\n\\nIf no suitable number b...\\nThe above is tricky. Write me a correct solution in PYTHON3.\",\"targets\":\"import sys\\nimport math\\ninput=sys.stdin.readline\\ndef solve(a,s):\\n    a=[int(i) for i in a]\\n    s=[int(i) for i in s]\\n    i=len(a)-1\\n    j=len(s)-1\\n    ans=[]\\n    while(True):\\n        if(i==-1):\\n            for k in range(j,-1,-1):\\n                ans.append(s[k])\\n            break\\n        if(j==-1):\\n            return -1\\n        if(a[i]>s[j]):\\n            if(j==0):\\n                return -1\\n            if(s[j-1]!=1):\\n                return -1\\n            else:\\n                ans.append(int(str(s[j-1])+str(s[j]))-a[i])\\n                j-=2\\n                i-=1\\n        else:\\n            ans.append(s[j]-a[i])\\n            j-=1\\n            i-=1\\n    ans.reverse()\\n    index=len(ans)-1\\n    for i in range(len(ans)):\\n        if(ans[i]!=0):\\n            index=i\\n            break\\n    ans=ans[index:]\\n    anss=\\\"\\\"\\n    for i in ans:\\n        anss+=str(i)\\n    if(len(anss)==0):\\n        anss+='0'\\n    return anss\\nfor _ in range(int(input())):\\n    print(solve(*input().split()))\",\"language\":\"python\",\"split\":\"test\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"You are given strings S and T, consisting of lowercase English letters. It is guaranteed that T is a permutation of the string abc. \\n\\nFind string S', the lexicographically smallest permutation of S such that T is not a subsequence of S'.\\n\\nString a is a permutation of string b if the number of occurrences of each distinct character is the same in both strings.\\n\\nA string a is a subsequence of a string b if a can be obtained from b by deletion of several (possibly, zero or all) elements.\\n\\nA string a is lexicographically smaller than a string b if and only if one of the following holds:\\n\\n  * a is a prefix of b, but a \u2260 b;\\n  * in the first position where a and b differ, the string a has a letter that appears earlier in the alphabet than the corresponding letter in b.\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains a single integer t (1 \u2264 t \u2264 1000) \u2014 the number of test cases. Description of the test cases follows.\\n\\nThe first line of each test case contains a string S (1 \u2264 |S| \u2264 100), consisting of lowercase English letters.\\n\\nThe second line of each test case contains a string T that is a permutation of the string abc. (Hence, |T| = 3).\\n\\nNote that there is no limit on the sum of |S| across all test cases.\\n\\nOutput\\n\\nFor each test case, output a single string S', the lexicographically smallest permutation of S such that T is not a subsequence of S'.\\n\\nExample\\n\\nInput\\n\\n\\n7\\nabacaba\\nabc\\ncccba\\nacb\\ndbsic\\nbac\\nabracadabra\\nabc\\ndddddddddddd\\ncba\\nbbc\\nabc\\nac\\nabc\\n\\n\\nOutput\\n\\n\\naaaacbb\\nabccc\\nbcdis\\naaaaacbbdrr\\ndddddddddddd\\nbbc\\nac\\n\\nNote\\n\\nIn the first test case, both aaaabbc and aaaabcb are lexicographically smaller than aaaacbb, but they contain abc as a subsequence.\\n\\nIn the second test case, abccc is the smallest permutation of cccba and does not contain acb as a subsequence.\\n\\nIn the third test case, bcdis is the smallest permutation of dbsic and does not contain bac as a subsequence.\\\":\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint t;\\nstring s, T;\\nint main() {\\n  cin >> t;\\n  while (t--) {\\n    cin >> s >> T;\\n    int n = s.size();\\n    int a[n];\\n    for (int i = 0; i < n; i++) a[i] = s[i];\\n    sort(a, a + n);\\n    int acheck = 0, bcheck = 0, ccheck = 0;\\n    for (int i = 0; i < n; i++) {\\n      if (s[i] == 'a') acheck++;\\n      if (s[i] == 'b') bcheck++;\\n      if (s[i] == 'c') ccheck++;\\n    }\\n    if (acheck == 0 || bcheck == 0 || ccheck == 0 || T != \\\"abc\\\") {\\n      for (int i = 0; i < n; i++) cout << (char)a[i];\\n      cout << endl;\\n    } else {\\n      for (int i = 0; i < n; i++) {\\n        if (a[i] == 98) {\\n          continue;\\n        }\\n        cout << (char)a[i];\\n        if (a[i] == 99) ccheck--;\\n        if (ccheck == 0)\\n          while (bcheck > 0) {\\n            cout << \\\"b\\\";\\n            bcheck--;\\n          }\\n      }\\n      cout << endl;\\n    }\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in CPP?\\nAlice and Bob are playing a game on a line with n cells. There are n cells labeled from 1 through n. For each i from 1 to n-1, cells i and i+1 are adjacent.\\n\\nAlice initially has a token on some cell on the line, and Bob tries to guess where it is. \\n\\nBob guesses a sequence of line cell numbers x_1, x_2, \u2026, x_k in order. In the i-th question, Bob asks Alice if her token is currently on cell x_i. That is, Alice can answer either \\\"YES\\\" or \\\"NO\\\" to each Bob's question.\\n\\nAt most one time in this process, before or after answering a question, Alice is allowed to move her token from her current cell to some adjacent cell. Alice acted in such a way that she was able to answer \\\"NO\\\" to all of Bob's questions.\\n\\nNote that Alice can even move her token before answering the first question or after answering the last question. Alice can also choose to not move at all.\\n\\nYou are given n and Bob's questions x_1, \u2026, x_k. You would like to count the number of scenarios that let Alice answer \\\"NO\\\" to all of Bob's questions. \\n\\nLet (a,b) denote a scenario where Alice starts at cell a and ends at cell b. Two scenarios (a_i, b_i) and (a_j, b_j) are different if a_i \u2260 a_j or b_i \u2260 b_j.\\n\\nInput\\n\\nThe first line contains two integers n and k (1 \u2264 n,k \u2264 10^5) \u2014 the number of cells and the number of questions Bob asked.\\n\\nThe second line contains k integers x_1, x_2, \u2026, x_k (1 \u2264 x_i \u2264 n) \u2014 Bob's questions.\\n\\nOutput\\n\\nPrint a single integer, the number of scenarios that let Alice answer \\\"NO\\\" to all of Bob's questions.\\n\\nExamples\\n\\nInput\\n\\n\\n5 3\\n5 1 4\\n\\n\\nOutput\\n\\n\\n9\\n\\n\\nInput\\n\\n\\n4 8\\n1 2 3 4 4 3 2 1\\n\\n\\nOutput\\n\\n\\n0\\n\\n\\nInput\\n\\n\\n100000 1\\n42\\n\\n\\nOutput\\n\\n\\n299997\\n\\nNote\\n\\nThe notation (i,j) denotes a scenario where Alice starts at cell i and ends at cell j.\\n\\nIn the first example, the valid scenarios are (1, 2), (2, 1), (2, 2), (2, 3), (3, 2), (3, 3), (3, 4), (4, 3), (4, 5). For example, (3,4) is valid since Alice can start at cell 3, stay there for the first three questions, then move to cell 4 after the last question. \\n\\n(4,5) is valid since Alice can start at cell 4,...\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst int MAXN = 100005;\\nconst int INF = 987654321;\\nint x[MAXN];\\npair<int, int> pos[MAXN];\\nint main(int argc, char **argv) {\\n  ios_base::sync_with_stdio(false);\\n  cin.tie(NULL);\\n  cout.tie(NULL);\\n  ;\\n  int n, k;\\n  cin >> n >> k;\\n  for (int i = 1; i <= n; i++) {\\n    pos[i] = pair<int, int>(INF, -INF);\\n  }\\n  for (int i = 1; i <= k; i++) {\\n    cin >> x[i];\\n    pos[x[i]].first = min(pos[x[i]].first, i);\\n    pos[x[i]].second = max(pos[x[i]].second, i);\\n  }\\n  int ans = 0;\\n  for (int i = 1; i <= n; i++) {\\n    if (pos[i] == pair<int, int>(INF, -INF)) {\\n      if (i > 1 && i < n) {\\n        ans += 3;\\n      } else {\\n        ans += 2;\\n      }\\n    } else {\\n      if (i > 1 && pos[i].first > pos[i - 1].second) ans++;\\n      if (i < n && pos[i].first > pos[i + 1].second) ans++;\\n    }\\n  }\\n  cout << ans << endl;\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Ehab loves number theory, but for some reason he hates the number x. Given an array a, find the length of its longest subarray such that the sum of its elements isn't divisible by x, or determine that such subarray doesn't exist.\\n\\nAn array a is a subarray of an array b if a can be obtained from b by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.\\n\\nInput\\n\\nThe first line contains an integer t (1 \u2264 t \u2264 5) \u2014 the number of test cases you need to solve. The description of the test cases follows.\\n\\nThe first line of each test case contains 2 integers n and x (1 \u2264 n \u2264 10^5, 1 \u2264 x \u2264 10^4) \u2014 the number of elements in the array a and the number that Ehab hates.\\n\\nThe second line contains n space-separated integers a_1, a_2, \u2026, a_{n} (0 \u2264 a_i \u2264 10^4) \u2014 the elements of the array a.\\n\\nOutput\\n\\nFor each testcase, print the length of the longest subarray whose sum isn't divisible by x. If there's no such subarray, print -1.\\n\\nExample\\n\\nInput\\n\\n\\n3\\n3 3\\n1 2 3\\n3 4\\n1 2 3\\n2 2\\n0 6\\n\\n\\nOutput\\n\\n\\n2\\n3\\n-1\\n\\nNote\\n\\nIn the first test case, the subarray [2,3] has sum of elements 5, which isn't divisible by 3.\\n\\nIn the second test case, the sum of elements of the whole array is 6, which isn't divisible by 4.\\n\\nIn the third test case, all subarrays have an even sum, so the answer is -1.\\nSolve the task in PYTHON3.\",\"targets\":\"for i in range(int(input())):\\n    n = int(input())\\n    a = set(map(int, input().split(' ')))\\n    print(len(a))\",\"language\":\"python\",\"split\":\"train\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Petya is a math teacher. n of his students has written a test consisting of m questions. For each student, it is known which questions he has answered correctly and which he has not.\\n\\nIf the student answers the j-th question correctly, he gets p_j points (otherwise, he gets 0 points). Moreover, the points for the questions are distributed in such a way that the array p is a permutation of numbers from 1 to m.\\n\\nFor the i-th student, Petya knows that he expects to get x_i points for the test. Petya wonders how unexpected the results could be. Petya believes that the surprise value of the results for students is equal to \u2211_{i=1}^{n} |x_i - r_i|, where r_i is the number of points that the i-th student has got for the test.\\n\\nYour task is to help Petya find such a permutation p for which the surprise value of the results is maximum possible. If there are multiple answers, print any of them.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases.\\n\\nThe first line of each test case contains two integers n and m (1 \u2264 n \u2264 10; 1 \u2264 m \u2264 10^4) \u2014 the number of students and the number of questions, respectively.\\n\\nThe second line contains n integers x_1, x_2, ..., x_n (0 \u2264 x_i \u2264 (m(m+1))\\/(2)), where x_i is the number of points that the i-th student expects to get.\\n\\nThis is followed by n lines, the i-th line contains the string s_i (|s_i| = m; s_{i, j} \u2208 \\\\{0, 1\\\\}), where s_{i, j} is 1 if the i-th student has answered the j-th question correctly, and 0 otherwise.\\n\\nThe sum of m for all test cases does not exceed 10^4.\\n\\nOutput\\n\\nFor each test case, print m integers \u2014 a permutation p for which the surprise value of the results is maximum possible. If there are multiple answers, print any of them.\\n\\nExample\\n\\nInput\\n\\n\\n3\\n4 3\\n5 1 2 2\\n110\\n100\\n101\\n100\\n4 4\\n6 2 0 10\\n1001\\n0010\\n0110\\n0101\\n3 6\\n20 3 15\\n010110\\n000101\\n111111\\n\\n\\nOutput\\n\\n\\n3 1 2 \\n2 3 4 1 \\n3 1 4 5 2 6\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst long long LINF = 1e17;\\nconst long double pi = 3.1415926535897932;\\nconst string endstr = \\\"\\\\n\\\";\\ntemplate <typename T>\\nT gcd(T a, T b) {\\n  return (a == 0) ? b : gcd(b % a, a);\\n}\\ntemplate <typename T>\\nT lcm(T a, T b) {\\n  return a \\/ gcd(a, b) * b;\\n}\\nbool p_comp_fs(const pair<long long, long long> p1,\\n               const pair<long long, long long> p2) {\\n  return p1.first < p2.first;\\n};\\nbool p_comp_fg(const pair<long long, long long> p1,\\n               const pair<long long, long long> p2) {\\n  return p1.first > p2.first;\\n};\\nbool p_comp_ss(const pair<long long, long long> p1,\\n               const pair<long long, long long> p2) {\\n  return p1.second < p2.second;\\n};\\nbool p_comp_sg(const pair<long long, long long> p1,\\n               const pair<long long, long long> p2) {\\n  return p1.second > p2.second;\\n};\\ntemplate <typename T>\\nvector<T> uniquen(vector<T> vec) {\\n  sort((vec).begin(), (vec).end());\\n  vec.erase(unique(vec.begin(), vec.end()), vec.end());\\n  return vec;\\n}\\ninline long long popcnt(long long x) {\\n  return __builtin_popcountll((unsigned long long)x);\\n};\\ntemplate <class T>\\nbool chmax(T &a, T b) {\\n  if (a < b) {\\n    a = b;\\n    return true;\\n  }\\n  return false;\\n}\\ntemplate <class T>\\nbool chmin(T &a, T b) {\\n  if (a > b) {\\n    a = b;\\n    return true;\\n  }\\n  return false;\\n}\\nbool bit(long long st, long long b) { return ((st >> b) & 1) == 1; }\\nvoid solve() {\\n  long long N, M;\\n  cin >> N >> M;\\n  vector<long long> X(N);\\n  for (long long i = 0; i < N; i++) cin >> X[i];\\n  vector<vector<long long> > S(N, vector<long long>(M, 0));\\n  for (long long i = 0; i < N; i++)\\n    for (long long j = 0; j < M; j++) {\\n      char c;\\n      cin >> c;\\n      if (c == '1') S[i][j] = 1;\\n    }\\n  long long ans_v = -LINF;\\n  vector<long long> ans;\\n  for (long long st = 0; st < (1ll << N); st++) {\\n    vector<pair<long long, long long> > cnt;\\n    for (long long j = 0; j < M; j++) {\\n      long long c = 0;\\n      for (long long i = 0; i < N; i++) {\\n        if (bit(st, i))\\n          c -= S[i][j];\\n       ...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Calvin the robot lies in an infinite rectangular grid. Calvin's source code contains a list of n commands, each either 'U', 'R', 'D', or 'L' \u2014 instructions to move a single square up, right, down, or left, respectively. How many ways can Calvin execute a non-empty contiguous substrings of commands and return to the same square he starts in? Two substrings are considered different if they have different starting or ending indices.\\n\\nInput\\n\\nThe first line of the input contains a single positive integer, n (1 \u2264 n \u2264 200) \u2014 the number of commands.\\n\\nThe next line contains n characters, each either 'U', 'R', 'D', or 'L' \u2014 Calvin's source code.\\n\\nOutput\\n\\nPrint a single integer \u2014 the number of contiguous substrings that Calvin can execute and return to his starting square.\\n\\nExamples\\n\\nInput\\n\\n6\\nURLLDR\\n\\n\\nOutput\\n\\n2\\n\\n\\nInput\\n\\n4\\nDLUU\\n\\n\\nOutput\\n\\n0\\n\\n\\nInput\\n\\n7\\nRLRLRLR\\n\\n\\nOutput\\n\\n12\\n\\nNote\\n\\nIn the first case, the entire source code works, as well as the \\\"RL\\\" substring in the second and third characters.\\n\\nNote that, in the third case, the substring \\\"LR\\\" appears three times, and is therefore counted three times to the total result.\\n#incl\",\"targets\":\"ude <bits\\/stdc++.h>\\nusing namespace std;\\nconst double EPS = 1e-4;\\nconst long double PI = acos((long double)-1.0);\\nconst long long int MOD = 1e9 + 7;\\nlong long int powmod(long long int a, long long int b, long long int mod) {\\n  long long int res = 1;\\n  a %= mod;\\n  for (; b; b >>= 1) {\\n    if (b & 1) res = res * a % mod;\\n    a = a * a % mod;\\n  }\\n  return res;\\n}\\nconst int debug = 1;\\ntemplate <typename T>\\nvoid DBG(vector<T> v) {\\n  if (debug) {\\n    for (T t : v) cout << t << \\\"  \\\";\\n    cout << endl;\\n  }\\n}\\ntemplate <typename T>\\nvoid DBG(T t) {\\n  if (debug) cout << t << endl;\\n}\\nint main() {\\n  ios_base::sync_with_stdio(false);\\n  cin.tie(NULL);\\n  cout.precision(10);\\n  cout << fixed;\\n  int n;\\n  cin >> n;\\n  string commands;\\n  cin >> commands;\\n  int count = 0;\\n  for (int i = 0; i < n; i++) {\\n    auto t = make_pair(0, 0);\\n    for (int j = i; j < n; j++) {\\n      char c = commands[j];\\n      if (c == 'U') t.first++;\\n      if (c == 'D') t.first--;\\n      if (c == 'R') t.second++;\\n      if (c == 'L') t.second--;\\n      if (t.first == 0 and t.second == 0) {\\n        count++;\\n      }\\n    }\\n  }\\n  cout << count << endl;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"Drazil is playing a math game with Varda.\\n\\nLet's define <image> for positive integer x as a product of factorials of its digits. For example, <image>.\\n\\nFirst, they choose a decimal number a consisting of n digits that contains at least one digit larger than 1. This number may possibly start with leading zeroes. Then they should find maximum positive number x satisfying following two conditions:\\n\\n1. x doesn't contain neither digit 0 nor digit 1.\\n\\n2. <image> = <image>.\\n\\nHelp friends find such number.\\n\\nInput\\n\\nThe first line contains an integer n (1 \u2264 n \u2264 15) \u2014 the number of digits in a.\\n\\nThe second line contains n digits of a. There is at least one digit in a that is larger than 1. Number a may possibly contain leading zeroes.\\n\\nOutput\\n\\nOutput a maximum possible integer satisfying the conditions above. There should be no zeroes and ones in this number decimal representation.\\n\\nExamples\\n\\nInput\\n\\n4\\n1234\\n\\n\\nOutput\\n\\n33222\\n\\n\\nInput\\n\\n3\\n555\\n\\n\\nOutput\\n\\n555\\n\\nNote\\n\\nIn the first case, <image>\\\":\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nsigned main() {\\n  long long n;\\n  cin >> n;\\n  long long x;\\n  cin >> x;\\n  vector<long long> digits;\\n  while (x) {\\n    long long r = x % 10;\\n    if (r > 1) digits.push_back(r);\\n    x \\/= 10;\\n  }\\n  vector<long long> ans;\\n  for (long long i = 0; i < digits.size(); i++) {\\n    if (digits[i] == 2 || digits[i] == 3 || digits[i] == 5 || digits[i] == 7) {\\n      ans.push_back(digits[i]);\\n    } else if (digits[i] == 4) {\\n      ans.push_back(3);\\n      ans.push_back(2);\\n      ans.push_back(2);\\n    } else if (digits[i] == 6) {\\n      ans.push_back(5);\\n      ans.push_back(3);\\n    } else if (digits[i] == 8) {\\n      ans.push_back(7);\\n      ans.push_back(2);\\n      ans.push_back(2);\\n      ans.push_back(2);\\n    } else {\\n      ans.push_back(7);\\n      ans.push_back(3);\\n      ans.push_back(3);\\n      ans.push_back(2);\\n    }\\n  }\\n  sort(ans.begin(), ans.end(), greater<long long>());\\n  for (long long i = 0; i < ans.size(); i++) cout << ans[i];\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You are given an integer k and a string s that consists only of characters 'a' (a lowercase Latin letter) and '*' (an asterisk).\\n\\nEach asterisk should be replaced with several (from 0 to k inclusive) lowercase Latin letters 'b'. Different asterisk can be replaced with different counts of letter 'b'.\\n\\nThe result of the replacement is called a BA-string.\\n\\nTwo strings a and b are different if they either have different lengths or there exists such a position i that a_i \u2260 b_i.\\n\\nA string a is lexicographically smaller than a string b if and only if one of the following holds: \\n\\n  * a is a prefix of b, but a \u2260 b; \\n  * in the first position where a and b differ, the string a has a letter that appears earlier in the alphabet than the corresponding letter in b. \\n\\n\\n\\nNow consider all different BA-strings and find the x-th lexicographically smallest of them.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 2000) \u2014 the number of testcases.\\n\\nThe first line of each testcase contains three integers n, k and x (1 \u2264 n \u2264 2000; 0 \u2264 k \u2264 2000; 1 \u2264 x \u2264 10^{18}). n is the length of string s.\\n\\nThe second line of each testcase is a string s. It consists of n characters, each of them is either 'a' (a lowercase Latin letter) or '*' (an asterisk).\\n\\nThe sum of n over all testcases doesn't exceed 2000. For each testcase x doesn't exceed the total number of different BA-strings. String s contains at least one character 'a'.\\n\\nOutput\\n\\nFor each testcase, print a single string, consisting only of characters 'b' and 'a' (lowercase Latin letters) \u2014 the x-th lexicographically smallest BA-string.\\n\\nExample\\n\\nInput\\n\\n\\n3\\n2 4 3\\na*\\n4 1 3\\na**a\\n6 3 20\\n**a***\\n\\n\\nOutput\\n\\n\\nabb\\nabba\\nbabbbbbbbbb\\n\\nNote\\n\\nIn the first testcase of the example, BA-strings ordered lexicographically are: \\n\\n  1. a\\n  2. ab\\n  3. abb\\n  4. abbb\\n  5. abbbb\\n\\n\\n\\nIn the second testcase of the example, BA-strings ordered lexicographically are: \\n\\n  1. aa\\n  2. aba\\n  3. abba\\n\\n\\n\\nNote that string \\\"aba\\\" is only counted once, even though there are two ways to replace asterisks with characters...\\nimpor\",\"targets\":\"t sys\\ninput = sys.stdin.readline\\n############ ---- Input Functions ---- ############\\ndef inp():\\n    return (int(input()))\\ndef inlt():\\n    return (list(map(int, input().split())))\\ndef insr():\\n    s = input()\\n    return (list(s[:len(s) - 1]))\\ndef invr():\\n    return (map(int, input().split()))\\nfrom collections import Counter\\nt = inp()\\nfor _ in range(t):\\n    n,k,x = invr()\\n    s = insr()\\n    ss = [s[0]]\\n    for i,c in enumerate(list(s)[1:]):\\n        if c == 'a':\\n            ss.append(c)\\n            continue\\n        if c == ss[-1]:\\n            continue\\n        else:\\n            ss.append(c)\\n    A = []\\n    t = 0\\n    if s[0]=='*':\\n        t = 1\\n    for i,c in enumerate(list(s)[1:]):\\n        # print(c,s[i-1],'_____')\\n        if c == '*' and s[i]=='*':\\n            t+=1\\n        if c==\\\"*\\\" and s[i]!='*':\\n            t=1\\n        if c =='a' and s[i]=='*':\\n            A.append(t)\\n    if s[-1]=='*':\\n        A.append(t)\\n    res_cnt = []\\n    x -= 1\\n    for i in A[::-1]:\\n        res_cnt.append(x%(i*k+1))\\n        x\\/\\/=(i*k+1)\\n    # res_cnt = res_cnt[::-1]\\n    # print(res_cnt,ss,A)\\n    res = ''\\n    for c in ss:\\n        if c =='*':\\n            num = res_cnt.pop()\\n            res+='b'*num\\n        else:\\n            res+='a'\\n    print(res)\",\"language\":\"python\",\"split\":\"test\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You have an array a consisting of n distinct positive integers, numbered from 1 to n. Define p_k as $$$p_k = \u2211_{1 \u2264 i, j \u2264 k} a_i mod a_j, where x \\\\bmod y denotes the remainder when x is divided by y. You have to find and print p_1, p_2, \\\\ldots, p_n$$$. \\n\\nInput\\n\\nThe first line contains n \u2014 the length of the array (2 \u2264 n \u2264 2 \u22c5 10^5).\\n\\nThe second line contains n space-separated distinct integers a_1, \u2026, a_n (1 \u2264 a_i \u2264 3 \u22c5 10^5, a_i \u2260 a_j if i \u2260 j). \\n\\nOutput\\n\\nPrint n integers p_1, p_2, \u2026, p_n. \\n\\nExamples\\n\\nInput\\n\\n\\n4\\n6 2 7 3\\n\\n\\nOutput\\n\\n\\n0 2 12 22\\n\\n\\nInput\\n\\n\\n3\\n3 2 1\\n\\n\\nOutput\\n\\n\\n0 3 5\\nUsing cpp can you solve the prior task?\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nusing ll = long long;\\nusing ull = long unsigned long;\\nusing ld = double long;\\ntemplate <class T, int N, int B>\\nstruct asym_ra {\\n  T a[N + 1];\\n  T b[N \\/ B + 2];\\n  T get(int r) {\\n    if (r <= 0) return T();\\n    if (r > N) r = N;\\n    return a[r] + b[r \\/ B];\\n  }\\n  T operator()(int l, int r) { return get(r) - get(l); }\\n  void add(int p, const T& v) {\\n    for (int i = p + 1; i % B && i <= N; i++) a[i] += v;\\n    for (int i = p \\/ B + 1; i < N \\/ B + 2; i++) b[i] += v;\\n  }\\n};\\nint n;\\nint a[200005];\\nconst int H = 300000;\\nasym_ra<ll, H + 5, 512> cnt;\\nasym_ra<ll, H + 5, 512> sum;\\nint main() {\\n  ios::sync_with_stdio(!cin.tie(0));\\n  cin >> n;\\n  ll sol = 0;\\n  for (int i = 0; i < n; i++) {\\n    int x;\\n    cin >> x;\\n    for (int j = 0; j <= H; j += x) {\\n      sol += sum(j, j + x) - cnt(j, j + x) * 1ll * j;\\n    }\\n    for (int q = 1;;) {\\n      int r = x \\/ q;\\n      int l = x \\/ (q + 1) + 1;\\n      r++;\\n      sol += x * cnt(l, r) - q * sum(l, r);\\n      if (l == 1) break;\\n      q = x \\/ (l - 1);\\n    }\\n    sol += x * 1ll * cnt(x + 1, H + 1);\\n    cout << sol << ' ';\\n    cnt.add(x, 1);\\n    sum.add(x, x);\\n  }\\n  cout << '\\\\n';\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Capitalization is writing a word with its first letter as a capital letter. Your task is to capitalize the given word.\\n\\nNote, that during capitalization all the letters except the first one remains unchanged.\\n\\nInput\\n\\nA single line contains a non-empty word. This word consists of lowercase and uppercase English letters. The length of the word will not exceed 103.\\n\\nOutput\\n\\nOutput the given word after capitalization.\\n\\nExamples\\n\\nInput\\n\\nApPLe\\n\\n\\nOutput\\n\\nApPLe\\n\\n\\nInput\\n\\nkonjac\\n\\n\\nOutput\\n\\nKonjac\\npalav\",\"targets\":\"ra = input()\\nprint(palavra[0].upper() + palavra[1:])\",\"language\":\"python\",\"split\":\"train\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"A balance scale tips to the left if L>R, where L is the total weight of the masses on the left pan and R is the total weight of the masses on the right pan. Similarly, it balances if L=R, and tips to the right if L<R.\\n\\nTakahashi placed a mass of weight A and a mass of weight B on the left pan of a balance scale, and placed a mass of weight C and a mass of weight D on the right pan.\\n\\nPrint `Left` if the balance scale tips to the left; print `Balanced` if it balances; print `Right` if it tips to the right.\\n\\nConstraints\\n\\n* 1\\\\leq A,B,C,D \\\\leq 10\\n* All input values are integers.\\n\\nInput\\n\\nInput is given from Standard Input in the following format:\\n\\n\\nA B C D\\n\\n\\nOutput\\n\\nPrint `Left` if the balance scale tips to the left; print `Balanced` if it balances; print `Right` if it tips to the right.\\n\\nExamples\\n\\nInput\\n\\n3 8 7 1\\n\\n\\nOutput\\n\\nLeft\\n\\n\\nInput\\n\\n3 4 5 2\\n\\n\\nOutput\\n\\nBalanced\\n\\n\\nInput\\n\\n1 7 6 4\\n\\n\\nOutput\\n\\nRight\\na, b,\",\"targets\":\"c, d = map(int, input().split())\\nprint(\\\"Left\\\" if (a + b > c + d) else \\\"Balanced\\\" if a + b == c + d else \\\"Right\\\")\",\"language\":\"python\",\"split\":\"train\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Moamen has an array of n distinct integers. He wants to sort that array in non-decreasing order by doing the following operations in order exactly once:\\n\\n  1. Split the array into exactly k non-empty subarrays such that each element belongs to exactly one subarray. \\n  2. Reorder these subarrays arbitrary. \\n  3. Merge the subarrays in their new order. \\n\\n\\n\\nA sequence a is a subarray of a sequence b if a can be obtained from b by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.\\n\\nCan you tell Moamen if there is a way to sort the array in non-decreasing order using the operations written above?\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 10^3) \u2014 the number of test cases. The description of the test cases follows.\\n\\nThe first line of each test case contains two integers n and k (1 \u2264 k \u2264 n \u2264 10^5).\\n\\nThe second line contains n integers a_1, a_2, \u2026, a_n (0 \u2264 |a_i| \u2264 10^9). It is guaranteed that all numbers are distinct.\\n\\nIt is guaranteed that the sum of n over all test cases does not exceed 3\u22c510^5.\\n\\nOutput\\n\\nFor each test case, you should output a single string.\\n\\nIf Moamen can sort the array in non-decreasing order, output \\\"YES\\\" (without quotes). Otherwise, output \\\"NO\\\" (without quotes).\\n\\nYou can print each letter of \\\"YES\\\" and \\\"NO\\\" in any case (upper or lower).\\n\\nExample\\n\\nInput\\n\\n\\n3\\n5 4\\n6 3 4 2 1\\n4 2\\n1 -4 0 -2\\n5 1\\n1 2 3 4 5\\n\\n\\nOutput\\n\\n\\nYes\\nNo\\nYes\\n\\nNote\\n\\nIn the first test case, a = [6, 3, 4, 2, 1], and k = 4, so we can do the operations as follows: \\n\\n  1. Split a into \\\\{ [6], [3, 4], [2], [1] \\\\}. \\n  2. Reorder them: \\\\{ [1], [2], [3,4], [6] \\\\}. \\n  3. Merge them: [1, 2, 3, 4, 6], so now the array is sorted. \\n\\n\\n\\nIn the second test case, there is no way to sort the array by splitting it into only 2 subarrays.\\n\\nAs an example, if we split it into \\\\{ [1, -4], [0, -2] \\\\}, we can reorder them into \\\\{ [1, -4], [0, -2] \\\\} or \\\\{ [0, -2], [1, -4] \\\\}. However, after merging the subarrays, it is impossible to get a sorted array.\\nThe above is tricky. Write me a correct solution in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\ntemplate <typename T>\\nvoid print_vec(vector<T> &v) {\\n  for (auto i : v) {\\n    cout << i << \\\" \\\";\\n  }\\n  cout << std::endl;\\n  return;\\n}\\nvoid solve() {\\n  int n, k;\\n  cin >> n >> k;\\n  vector<long long> v(n);\\n  for (auto &i : v) {\\n    cin >> i;\\n  }\\n  vector<long long> co(v);\\n  sort(begin(co), end(co));\\n  int subarrays = 0;\\n  for (auto i = begin(v); i < end(v); i++) {\\n    auto j = lower_bound(begin(co), end(co), *i);\\n    while (i < end(v) - 1 && j < end(co) - 1 && (*(i + 1) == *(j + 1))) {\\n      i++;\\n      j++;\\n    }\\n    subarrays++;\\n  }\\n  cout << (k >= subarrays ? \\\"YES\\\" : \\\"NO\\\") << std::endl;\\n}\\nint main() {\\n  std::ios::sync_with_stdio(false);\\n  cout << fixed;\\n  unsigned long long n = 1;\\n  cin >> n;\\n  while (n--) {\\n    solve();\\n  }\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Stephen Queen wants to write a story. He is a very unusual writer, he uses only letters 'a', 'b', 'c', 'd' and 'e'!\\n\\nTo compose a story, Stephen wrote out n words consisting of the first 5 lowercase letters of the Latin alphabet. He wants to select the maximum number of words to make an interesting story.\\n\\nLet a story be a sequence of words that are not necessarily different. A story is called interesting if there exists a letter which occurs among all words of the story more times than all other letters together.\\n\\nFor example, the story consisting of three words \\\"bac\\\", \\\"aaada\\\", \\\"e\\\" is interesting (the letter 'a' occurs 5 times, all other letters occur 4 times in total). But the story consisting of two words \\\"aba\\\", \\\"abcde\\\" is not (no such letter that it occurs more than all other letters in total).\\n\\nYou are given a sequence of n words consisting of letters 'a', 'b', 'c', 'd' and 'e'. Your task is to choose the maximum number of them to make an interesting story. If there's no way to make a non-empty story, output 0.\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 5000) \u2014 the number of test cases. Then t test cases follow.\\n\\nThe first line of each test case contains one integer n (1 \u2264 n \u2264 2 \u22c5 10^5) \u2014 the number of the words in the sequence. Then n lines follow, each of them contains a word \u2014 a non-empty string consisting of lowercase letters of the Latin alphabet. The words in the sequence may be non-distinct (i. e. duplicates are allowed). Only the letters 'a', 'b', 'c', 'd' and 'e' may occur in the words.\\n\\nIt is guaranteed that the sum of n over all test cases doesn't exceed 2 \u22c5 10^5; the sum of the lengths of all words over all test cases doesn't exceed 4 \u22c5 10^5.\\n\\nOutput\\n\\nFor each test case, output the maximum number of words that compose an interesting story. Print 0 if there's no way to make a non-empty interesting story.\\n\\nExample\\n\\nInput\\n\\n\\n6\\n3\\nbac\\naaada\\ne\\n3\\naba\\nabcde\\naba\\n2\\nbaba\\nbaba\\n4\\nab\\nab\\nc\\nbc\\n5\\ncbdca\\nd\\na\\nd\\ne\\n3\\nb\\nc\\nca\\n\\n\\nOutput\\n\\n\\n3\\n2\\n0\\n2\\n3\\n2\\n\\nNote\\n\\nIn the first test case of the example, all 3 words...\\nSolve the task in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst int mxn = (int)2e5 + 5;\\nvoid solve() {\\n  int n;\\n  cin >> n;\\n  vector<array<int, 6>> a(n);\\n  for (int i = 0; i < n; i++) {\\n    string s;\\n    cin >> s;\\n    for (auto x : s) a[i][x - 'a']++;\\n    a[i][5] = s.length();\\n    if (0) {\\n      cerr << i << \\\": \\\";\\n      for (auto x : a[i]) cerr << x << \\\" \\\";\\n      cerr << \\\"\\\\n\\\";\\n    }\\n  }\\n  if (0) cerr << \\\"done\\\\n\\\";\\n  int ans = 0;\\n  for (int i = 0; i < 5; i++) {\\n    vector<int> need;\\n    for (int j = 0; j < n; j++) need.push_back(2 * a[j][i] - a[j][5]);\\n    sort(need.begin(), need.end());\\n    reverse(need.begin(), need.end());\\n    int cnt = 0;\\n    int res = 0;\\n    do {\\n      if (cnt == n) break;\\n      res += need[cnt++];\\n    } while (res > 0);\\n    if (res <= 0) cnt--;\\n    ans = max(ans, cnt);\\n  }\\n  cout << ans << \\\"\\\\n\\\";\\n}\\nint main() {\\n  ios_base::sync_with_stdio(0);\\n  cin.tie(0);\\n  cout.tie(0);\\n  int t = 1;\\n  cin >> t;\\n  while (t--) solve();\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You are given three integers n, a, b. Determine if there exists a permutation p_1, p_2, \u2026, p_n of integers from 1 to n, such that:\\n\\n  * There are exactly a integers i with 2 \u2264 i \u2264 n-1 such that p_{i-1} < p_i > p_{i+1} (in other words, there are exactly a local maximums).\\n\\n  * There are exactly b integers i with 2 \u2264 i \u2264 n-1 such that p_{i-1} > p_i < p_{i+1} (in other words, there are exactly b local minimums).\\n\\n\\n\\n\\nIf such permutations exist, find any such permutation.\\n\\nInput\\n\\nThe first line of the input contains a single integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases. The description of test cases follows.\\n\\nThe only line of each test case contains three integers n, a and b (2 \u2264 n \u2264 10^5, 0 \u2264 a,b \u2264 n).\\n\\nThe sum of n over all test cases doesn't exceed 10^5.\\n\\nOutput\\n\\nFor each test case, if there is no permutation with the requested properties, output -1.\\n\\nOtherwise, print the permutation that you are found. If there are several such permutations, you may print any of them.\\n\\nExample\\n\\nInput\\n\\n\\n3\\n4 1 1\\n6 1 2\\n6 4 0\\n\\n\\nOutput\\n\\n\\n1 3 2 4\\n4 2 3 1 5 6\\n-1\\n\\nNote\\n\\nIn the first test case, one example of such permutations is [1, 3, 2, 4]. In it p_1 < p_2 > p_3, and 2 is the only such index, and p_2> p_3 < p_4, and 3 the only such index.\\n\\nOne can show that there is no such permutation for the third test case.\\nSolve the task in PYTHON3.\",\"targets\":\"for s in[*open(0)][1:]:\\n n,a,b=map(int,s.split());r=-1,\\n if-2<a-b<2and a+b<n-1:\\n  *r,=range(1,n+1);j=a>=b\\n  if a^b:k=(n-2)*(a>b);r[k:k+2]=r[k+1],r[k]\\n  for i in range(2-j,a+b-(a>b)+j,2):r[i:i+2]=r[i+1],r[i]\\n print(*r)\",\"language\":\"python\",\"split\":\"test\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"A parking lot in the City consists of n parking spaces, standing in a line. The parking spaces are numbered from 1 to n from left to right. \\n\\nWhen a car arrives at the lot, the operator determines an empty parking space for it. For the safety's sake the chosen place should be located as far from the already occupied places as possible. That is, the closest occupied parking space must be as far away as possible. If there are several such places, then the operator chooses the place with the minimum index from them. If all parking lot places are empty, then the car gets place number 1.\\n\\nWe consider the distance between the i-th and the j-th parking spaces equal to 4\u00b7|i - j| meters.\\n\\nYou are given the parking lot records of arriving and departing cars in the chronological order. For each record of an arriving car print the number of the parking lot that was given to this car.\\n\\nInput\\n\\nThe first line contains two space-separated integers n and m (1 \u2264 n, m \u2264 2\u00b7105) \u2014 the number of parking places and the number of records correspondingly. \\n\\nNext m lines contain the descriptions of the records, one per line. The i-th line contains numbers ti, idi (1 \u2264 ti \u2264 2; 1 \u2264 idi \u2264 106). If ti equals 1, then the corresponding record says that the car number idi arrived at the parking lot. If ti equals 2, then the corresponding record says that the car number idi departed from the parking lot. \\n\\nRecords about arriving to the parking lot and departing from the parking lot are given chronologically. All events occurred consecutively, no two events occurred simultaneously.\\n\\nIt is guaranteed that all entries are correct: \\n\\n  * each car arrived at the parking lot at most once and departed from the parking lot at most once, \\n  * there is no record of a departing car if it didn't arrive at the parking lot earlier, \\n  * there are no more than n cars on the parking lot at any moment. \\n\\n\\n\\nYou can consider the cars arbitrarily numbered from 1 to 106, all numbers are distinct. Initially all places in the parking lot are empty.\\n\\nOutput\\n\\nFor...\\nThe above is tricky. Write me a correct solution in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nset<int> ss;\\nstruct node {\\n  int val, id;\\n  bool operator<(const node &b) const {\\n    if (val != b.val) return val > b.val;\\n    return id < b.id;\\n  }\\n};\\nset<node> ss2;\\nset<int>::iterator pos, pos1, pos2;\\nnode tot[30];\\nint n;\\nvoid add(int id, int val, int &cnt) {\\n  tot[cnt].id = id;\\n  tot[cnt].val = val;\\n  cnt++;\\n}\\nvoid check(int l, int r, int &cnt) {\\n  if (l == 0 && r == n + 1) return;\\n  if (l + 1 == r)\\n    return;\\n  else if (l == 0)\\n    add(1, 4 * (r - 1), cnt);\\n  else if (r == n + 1)\\n    add(n, 4 * (n - l), cnt);\\n  else if ((l + r) % 2 == 0)\\n    add((l + r) \\/ 2, 4 * ((l + r) \\/ 2 - l), cnt);\\n  else {\\n    add((l + r) \\/ 2, 4 * ((l + r) \\/ 2 - l), cnt);\\n    add((l + r) \\/ 2 + 1, 4 * (r - ((l + r) \\/ 2 + 1)), cnt);\\n  }\\n}\\nmap<int, int> mp;\\nint main() {\\n  mp.clear();\\n  ss.clear();\\n  ss2.clear();\\n  int m;\\n  scanf(\\\"%d%d\\\", &n, &m);\\n  for (int ii = 0; ii < m; ii++) {\\n    int ope, x;\\n    scanf(\\\"%d%d\\\", &ope, &x);\\n    int ans;\\n    if (ope == 1) {\\n      if (ss.size() == 0)\\n        ans = 1;\\n      else\\n        ans = ss2.begin()->id;\\n      mp[x] = ans;\\n      ss.insert(ans);\\n      printf(\\\"%d\\\\n\\\", ans);\\n    } else\\n      ans = mp[x];\\n    pos = ss.find(ans);\\n    int ll, rr;\\n    if (pos != ss.begin()) {\\n      pos1 = pos;\\n      pos1--;\\n      ll = *pos1;\\n    } else\\n      ll = 0;\\n    pos2 = pos;\\n    pos2++;\\n    if (pos2 != ss.end())\\n      rr = *pos2;\\n    else\\n      rr = n + 1;\\n    int cnt = 0;\\n    check(ll, rr, cnt);\\n    int cnt1 = cnt;\\n    check(ll, ans, cnt);\\n    check(ans, rr, cnt);\\n    if (ope == 1) {\\n      for (int i = 0; i < cnt1; i++) ss2.erase(tot[i]);\\n      for (int i = cnt1; i < cnt; i++) ss2.insert(tot[i]);\\n    } else {\\n      for (int i = cnt1; i < cnt; i++) ss2.erase(tot[i]);\\n      for (int i = 0; i < cnt1; i++) ss2.insert(tot[i]);\\n    }\\n    if (ope == 2) ss.erase(ans);\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"\\\"Contestant who earns a score equal to or greater than the k-th place finisher's score will advance to the next round, as long as the contestant earns a positive score...\\\" \u2014 an excerpt from contest rules.\\n\\nA total of n participants took part in the contest (n \u2265 k), and you already know their scores. Calculate how many participants will advance to the next round.\\n\\nInput\\n\\nThe first line of the input contains two integers n and k (1 \u2264 k \u2264 n \u2264 50) separated by a single space.\\n\\nThe second line contains n space-separated integers a1, a2, ..., an (0 \u2264 ai \u2264 100), where ai is the score earned by the participant who got the i-th place. The given sequence is non-increasing (that is, for all i from 1 to n - 1 the following condition is fulfilled: ai \u2265 ai + 1).\\n\\nOutput\\n\\nOutput the number of participants who advance to the next round.\\n\\nExamples\\n\\nInput\\n\\n8 5\\n10 9 8 7 7 7 5 5\\n\\n\\nOutput\\n\\n6\\n\\n\\nInput\\n\\n4 2\\n0 0 0 0\\n\\n\\nOutput\\n\\n0\\n\\nNote\\n\\nIn the first example the participant on the 5th place earned 7 points. As the participant on the 6th place also earned 7 points, there are 6 advancers.\\n\\nIn the second example nobody got a positive score.\",\"targets\":\"import sys\\n\\ndef solution():\\n    arr = []\\n    line = input()\\n    k = int(line.split(\\\" \\\")[1])\\n    arr = list(map(int, input().split(\\\" \\\")))\\n    n = len(arr)\\n    cutOff = arr[k - 1]\\n    result = 0\\n    for i in range(n):\\n        if arr[i] < cutOff:\\n            break\\n        elif arr[i] > 0:\\n            result += 1\\n    \\n    print(result)\\n\\n\\n\\nsolution()\",\"language\":\"python\",\"split\":\"train\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Note that the memory limit in this problem is lower than in others.\\n\\nYou have a vertical strip with n cells, numbered consecutively from 1 to n from top to bottom.\\n\\nYou also have a token that is initially placed in cell n. You will move the token up until it arrives at cell 1.\\n\\nLet the token be in cell x > 1 at some moment. One shift of the token can have either of the following kinds: \\n\\n  * Subtraction: you choose an integer y between 1 and x-1, inclusive, and move the token from cell x to cell x - y. \\n  * Floored division: you choose an integer z between 2 and x, inclusive, and move the token from cell x to cell \u230a x\\/z \u230b (x divided by z rounded down). \\n\\n\\n\\nFind the number of ways to move the token from cell n to cell 1 using one or more shifts, and print it modulo m. Note that if there are several ways to move the token from one cell to another in one shift, all these ways are considered distinct (check example explanation for a better understanding).\\n\\nInput\\n\\nThe only line contains two integers n and m (2 \u2264 n \u2264 4 \u22c5 10^6; 10^8 < m < 10^9; m is a prime number) \u2014 the length of the strip and the modulo.\\n\\nOutput\\n\\nPrint the number of ways to move the token from cell n to cell 1, modulo m.\\n\\nExamples\\n\\nInput\\n\\n\\n3 998244353\\n\\n\\nOutput\\n\\n\\n5\\n\\n\\nInput\\n\\n\\n5 998244353\\n\\n\\nOutput\\n\\n\\n25\\n\\n\\nInput\\n\\n\\n42 998244353\\n\\n\\nOutput\\n\\n\\n793019428\\n\\n\\nInput\\n\\n\\n787788 100000007\\n\\n\\nOutput\\n\\n\\n94810539\\n\\nNote\\n\\nIn the first test, there are three ways to move the token from cell 3 to cell 1 in one shift: using subtraction of y = 2, or using division by z = 2 or z = 3.\\n\\nThere are also two ways to move the token from cell 3 to cell 1 via cell 2: first subtract y = 1, and then either subtract y = 1 again or divide by z = 2.\\n\\nTherefore, there are five ways in total.\\nThe above is tricky. Write me a correct solution in JAVA.\",\"targets\":\"import java.util.*;\\nimport java.io.*;\\n\\npublic class Main {\\n\\n    static long startTime = System.currentTimeMillis();\\n\\n    \\/\\/ for global initializations and methods starts here\\n\\n    \\/\\/ global initialisations and methods end here\\n\\n    static void run() {\\n        boolean tc = false;\\n        AdityaFastIO r = new AdityaFastIO();\\n        \\/\\/FastReader r = new FastReader();\\n\\n        try (OutputStream out = new BufferedOutputStream(System.out)) {\\n\\n            \\/\\/long startTime = System.currentTimeMillis();\\n\\n            int testcases = tc ? r.ni() : 1;\\n            int tcCounter = 1;\\n            \\/\\/ Hold Here Sparky------------------->>>\\n            \\/\\/ Solution Starts Here\\n\\n            start:\\n            while (testcases-- > 0) {\\n\\n                int n = r.ni();\\n                int mod = r.ni();\\n\\n                int[] dp = new int[n + 2];\\n                int[] temp = new int[n + 2];\\n                dp[n] = temp[n] = 1;\\n                for (int i = n - 1; i > 0; i--) {\\n                    dp[i] = temp[i + 1];\\n                    for (int j = 2; i * j <= n; j++) {\\n                        int ind = Math.min(n + 1, (i + 1) * j);\\n                        dp[i] = ((dp[i] + temp[i * j]) % mod - temp[ind] + mod) % mod;\\n                    }\\n                    temp[i] = (temp[i + 1] + dp[i]) % mod;\\n                }\\n\\n                out.write((dp[1] + \\\" \\\").getBytes());\\n            }\\n            \\/\\/ Solution Ends Here\\n        } catch (IOException e) {\\n            e.printStackTrace();\\n        }\\n    }\\n\\n    static class AdityaFastIO {\\n        final private int BUFFER_SIZE = 1 << 16;\\n        private final DataInputStream din;\\n        private final byte[] buffer;\\n        private int bufferPointer, bytesRead;\\n        public BufferedReader br;\\n        public StringTokenizer st;\\n\\n        public AdityaFastIO() {\\n            br = new BufferedReader(new InputStreamReader(System.in));\\n            din = new DataInputStream(System.in);\\n            buffer = new byte[BUFFER_SIZE];\\n            bufferPointer = bytesRead = 0;\\n        }\\n\\n        public...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"An atom of element X can exist in n distinct states with energies E1 < E2 < ... < En. Arkady wants to build a laser on this element, using a three-level scheme. Here is a simplified description of the scheme. \\n\\nThree distinct states i, j and k are selected, where i < j < k. After that the following process happens: \\n\\n  1. initially the atom is in the state i,\\n  2. we spend Ek - Ei energy to put the atom in the state k,\\n  3. the atom emits a photon with useful energy Ek - Ej and changes its state to the state j,\\n  4. the atom spontaneously changes its state to the state i, losing energy Ej - Ei,\\n  5. the process repeats from step 1. \\n\\n\\n\\nLet's define the energy conversion efficiency as <image>, i. e. the ration between the useful energy of the photon and spent energy.\\n\\nDue to some limitations, Arkady can only choose such three states that Ek - Ei \u2264 U.\\n\\nHelp Arkady to find such the maximum possible energy conversion efficiency within the above constraints.\\n\\nInput\\n\\nThe first line contains two integers n and U (3 \u2264 n \u2264 105, 1 \u2264 U \u2264 109) \u2014 the number of states and the maximum possible difference between Ek and Ei.\\n\\nThe second line contains a sequence of integers E1, E2, ..., En (1 \u2264 E1 < E2... < En \u2264 109). It is guaranteed that all Ei are given in increasing order.\\n\\nOutput\\n\\nIf it is not possible to choose three states that satisfy all constraints, print -1.\\n\\nOtherwise, print one real number \u03b7 \u2014 the maximum possible energy conversion efficiency. Your answer is considered correct its absolute or relative error does not exceed 10 - 9.\\n\\nFormally, let your answer be a, and the jury's answer be b. Your answer is considered correct if <image>.\\n\\nExamples\\n\\nInput\\n\\n4 4\\n1 3 5 7\\n\\n\\nOutput\\n\\n0.5\\n\\n\\nInput\\n\\n10 8\\n10 13 15 16 17 19 20 22 24 25\\n\\n\\nOutput\\n\\n0.875\\n\\n\\nInput\\n\\n3 1\\n2 5 10\\n\\n\\nOutput\\n\\n-1\\n\\nNote\\n\\nIn the first example choose states 1, 2 and 3, so that the energy conversion efficiency becomes equal to <image>.\\n\\nIn the second example choose states 4, 5 and 9, so that the energy conversion efficiency becomes equal to <image>.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nnamespace {\\nnamespace aimi {\\ntemplate <class T>\\nvoid _input(T &x) {\\n  cin >> x;\\n}\\nvoid _input(int &x) { scanf(\\\"%d\\\", &x); }\\nvoid _input(int64_t &x) { scanf(\\\"%\\\" SCNd64, &x); }\\nvoid _input(double &x) { scanf(\\\"%lf\\\", &x); }\\nvoid _input(char &x) { scanf(\\\" %c\\\", &x); }\\nvoid _input(char *x) { scanf(\\\"%s\\\", x); }\\nvoid input() {}\\nvoid input(char *x) { scanf(\\\"%s\\\", x); }\\ntemplate <class T, class... U>\\nvoid input(T &head, U &...tail) {\\n  _input(head);\\n  input(tail...);\\n}\\ntemplate <class T>\\nvoid _print(const T &x) {\\n  cout << x;\\n}\\nvoid _print(const int &x) { printf(\\\"%d\\\", x); }\\nvoid _print(const int64_t &x) { printf(\\\"%\\\" PRId64, x); }\\nvoid _print(const double &x) { printf(\\\"%.16f\\\", x); }\\nvoid _print(const char &x) { putchar(x); }\\nvoid _print(const char *x) { printf(\\\"%s\\\", x); }\\ntemplate <class T>\\nvoid _print(const vector<T> &x) {\\n  for (auto i = cbegin(x); i != cend(x); _print(*i++))\\n    if (i != cbegin(x)) putchar(' ');\\n}\\nvoid print() {}\\ntemplate <class T, class... U>\\nvoid print(const T &head, const U &...tail) {\\n  _print(head);\\n  putchar(sizeof...(tail) ? ' ' : '\\\\n');\\n  print(tail...);\\n}\\ntemplate <class T, class F = less<T>>\\nvoid sort_unique(vector<T> &v, F f = F()) {\\n  sort(begin(v), end(v), f);\\n  v.resize(unique(begin(v), end(v)) - begin(v));\\n}\\ntemplate <class T>\\ninline T get_bit(T x, int i) {\\n  return (x >> i) & 1;\\n}\\ntemplate <class T>\\ninline bool chkmax(T &a, const T &b) {\\n  return b > a ? a = b, true : false;\\n}\\ntemplate <class T>\\ninline bool chkmin(T &a, const T &b) {\\n  return b < a ? a = b, true : false;\\n}\\ntemplate <class T>\\nusing MaxHeap = priority_queue<T>;\\ntemplate <class T>\\nusing MinHeap = priority_queue<T, vector<T>, greater<T>>;\\nconst int MAX = 100005;\\nint n, u;\\nint a[MAX];\\nvoid main() {\\n  input(n, u);\\n  for (int i = 0; i < int(n); ++i) input(a[i]);\\n  double ans = -1e+100;\\n  for (int i = 0; i < int(n); ++i) {\\n    int k = int(prev(lower_bound(a + i, a + n, a[i] + u + 1)) - a);\\n    if (k - i < 2) continue;\\n    chkmax(ans, double(a[k] - a[i + 1]) \\/ double(a[k] - a[i]));\\n ...\",\"language\":\"python\",\"split\":\"train\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You had n positive integers a_1, a_2, ..., a_n arranged in a circle. For each pair of neighboring numbers (a_1 and a_2, a_2 and a_3, ..., a_{n - 1} and a_n, and a_n and a_1), you wrote down: are the numbers in the pair equal or not.\\n\\nUnfortunately, you've lost a piece of paper with the array a. Moreover, you are afraid that even information about equality of neighboring elements may be inconsistent. So, you are wondering: is there any array a which is consistent with information you have about equality or non-equality of corresponding pairs?\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 1000) \u2014 the number of test cases. Next t cases follow.\\n\\nThe first and only line of each test case contains a non-empty string s consisting of characters E and\\/or N. The length of s is equal to the size of array n and 2 \u2264 n \u2264 50. For each i from 1 to n: \\n\\n  * if s_i = E then a_i is equal to a_{i + 1} (a_n = a_1 for i = n); \\n  * if s_i = N then a_i is not equal to a_{i + 1} (a_n \u2260 a_1 for i = n). \\n\\nOutput\\n\\nFor each test case, print YES if it's possible to choose array a that are consistent with information from s you know. Otherwise, print NO.\\n\\nIt can be proved, that if there exists some array a, then there exists an array a of positive integers with values less or equal to 10^9.\\n\\nExample\\n\\nInput\\n\\n\\n4\\nEEE\\nEN\\nENNEENE\\nNENN\\n\\n\\nOutput\\n\\n\\nYES\\nNO\\nYES\\nYES\\n\\nNote\\n\\nIn the first test case, you can choose, for example, a_1 = a_2 = a_3 = 5.\\n\\nIn the second test case, there is no array a, since, according to s_1, a_1 is equal to a_2, but, according to s_2, a_2 is not equal to a_1.\\n\\nIn the third test case, you can, for example, choose array a = [20, 20, 4, 50, 50, 50, 20].\\n\\nIn the fourth test case, you can, for example, choose a = [1, 3, 3, 7].\\nThe above is tricky. Write me a correct solution in JAVA.\",\"targets\":\"import java.util.Scanner;\\nimport java.util.List;\\npublic class t1 {\\n    public static void main(String[] args) {\\n        Scanner in = new Scanner(System.in);\\n        var n=in.nextInt();\\n        for (var i=0; i<n; i++){\\n            var s=in.next();\\n\\n            var k=0;\\n            for (var x : s.toCharArray()){\\n                if (x=='N'){\\n                    k++;\\n                        }\\n\\n            }\\n            if (s.length()>1 && k==1){\\n                System.out.println(\\\"NO\\\");\\n            }\\n            else System.out.println(\\\"YES\\\");\\n\\n        }\\n    }\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"n towns are arranged in a circle sequentially. The towns are numbered from 1 to n in clockwise order. In the i-th town, there lives a singer with a repertoire of a_i minutes for each i \u2208 [1, n].\\n\\nEach singer visited all n towns in clockwise order, starting with the town he lives in, and gave exactly one concert in each town. In addition, in each town, the i-th singer got inspired and came up with a song that lasts a_i minutes. The song was added to his repertoire so that he could perform it in the rest of the cities.\\n\\nHence, for the i-th singer, the concert in the i-th town will last a_i minutes, in the (i + 1)-th town the concert will last 2 \u22c5 a_i minutes, ..., in the ((i + k) mod n + 1)-th town the duration of the concert will be (k + 2) \u22c5 a_i, ..., in the town ((i + n - 2) mod n + 1) \u2014 n \u22c5 a_i minutes.\\n\\nYou are given an array of b integer numbers, where b_i is the total duration of concerts in the i-th town. Reconstruct any correct sequence of positive integers a or say that it is impossible.\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 10^3) \u2014 the number of test cases. Then the test cases follow.\\n\\nEach test case consists of two lines. The first line contains a single integer n (1 \u2264 n \u2264 4 \u22c5 10^4) \u2014 the number of cities. The second line contains n integers b_1, b_2, ..., b_n (1 \u2264 b_i \u2264 10^{9}) \u2014 the total duration of concerts in i-th city.\\n\\nThe sum of n over all test cases does not exceed 2 \u22c5 10^5.\\n\\nOutput\\n\\nFor each test case, print the answer as follows:\\n\\nIf there is no suitable sequence a, print NO. Otherwise, on the first line print YES, on the next line print the sequence a_1, a_2, ..., a_n of n integers, where a_i (1 \u2264 a_i \u2264 10^{9}) is the initial duration of repertoire of the i-th singer. If there are multiple answers, print any of them.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n3\\n12 16 14\\n1\\n1\\n3\\n1 2 3\\n6\\n81 75 75 93 93 87\\n\\n\\nOutput\\n\\n\\nYES\\n3 1 3 \\nYES\\n1 \\nNO\\nYES\\n5 5 4 1 4 5 \\n\\nNote\\n\\nLet's consider the 1-st test case of the example:\\n\\n  1. the 1-st singer in the 1-st city will give a concert for 3 minutes, in the 2-nd \u2014...\\nSolve the task in JAVA.\",\"targets\":\"import java.util.*;\\nimport java.io.*;\\n\\n\\/\\/\\/\\/***************************************************************************\\n \\/* public class E_Gardener_and_Tree implements Runnable{\\n\\n       public static void main(String[] args) throws Exception {\\n        new Thread(null, new E_Gardener_and_Tree(), \\\"E_Gardener_and_Tree\\\", 1<<28).start();\\n       }\\n    public void run(){\\n         WRITE YOUR CODE HERE!!!!\\n         JUST WRITE EVERYTHING HERE WHICH YOU WRITE IN MAIN!!!\\n       }\\n\\n  }\\n*\\/\\n\\/\\/\\/\\/\\/**************************************************************************\\n\\n\\npublic class E_Singers_Tour{\\n    public static void main(String[] args) {\\n        FastScanner s= new FastScanner();\\n        \\/\\/PrintWriter out=new PrintWriter(System.out);\\n        \\/\\/end of program\\n        \\/\\/out.println(answer);\\n        \\/\\/out.close();\\n        StringBuilder res = new StringBuilder();\\n        int t=s.nextInt();\\n        int p=0;\\n        while(p<t){\\n        int n=s.nextInt();\\n        long array[]= new long[n];\\n        long sum=0;\\n        for(int i=0;i<n;i++){\\n            array[i]=s.nextLong();\\n            sum+=array[i];\\n        }\\n        long yo=n;\\n        long a1=2;\\n        long hh=((yo)*(yo+1))\\/a1;\\n        \\n        if(sum%hh!=0){\\n            res.append(\\\"NO \\\\n\\\");\\n        }\\n        else{\\n            long well=sum\\/hh;\\n            long ans[]= new long[n];\\n            int check=0;\\n            for(int i=1;i<n;i++){\\n                long yo1=array[i-1]-array[i]+well;\\n                if(yo1<=0){\\n                    check=1;\\n                    break;\\n                }\\n                else{\\n                    if(yo1%n!=0){\\n                        check=1;\\n                        break;\\n                    }\\n                    else{\\n                        long kk=yo1\\/n;\\n                        ans[i]=kk;\\n                    }\\n                }\\n\\n            }\\n            long q=array[n-1]-array[0]+well;\\n            if(q<=0){\\n                check=1;\\n            }\\n            if(q%n!=0){\\n                check=1;\\n            }\\n            else{\\n           ...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Polycarp must pay exactly n burles at the checkout. He has coins of two nominal values: 1 burle and 2 burles. Polycarp likes both kinds of coins equally. So he doesn't want to pay with more coins of one type than with the other.\\n\\nThus, Polycarp wants to minimize the difference between the count of coins of 1 burle and 2 burles being used. Help him by determining two non-negative integer values c_1 and c_2 which are the number of coins of 1 burle and 2 burles, respectively, so that the total value of that number of coins is exactly n (i. e. c_1 + 2 \u22c5 c_2 = n), and the absolute value of the difference between c_1 and c_2 is as little as possible (i. e. you must minimize |c_1-c_2|).\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases. Then t test cases follow.\\n\\nEach test case consists of one line. This line contains one integer n (1 \u2264 n \u2264 10^9) \u2014 the number of burles to be paid by Polycarp.\\n\\nOutput\\n\\nFor each test case, output a separate line containing two integers c_1 and c_2 (c_1, c_2 \u2265 0) separated by a space where c_1 is the number of coins of 1 burle and c_2 is the number of coins of 2 burles. If there are multiple optimal solutions, print any one.\\n\\nExample\\n\\nInput\\n\\n\\n6\\n1000\\n30\\n1\\n32\\n1000000000\\n5\\n\\n\\nOutput\\n\\n\\n334 333\\n10 10\\n1 0\\n10 11\\n333333334 333333333\\n1 2\\n\\nNote\\n\\nThe answer for the first test case is \\\"334 333\\\". The sum of the nominal values of all coins is 334 \u22c5 1 + 333 \u22c5 2 = 1000, whereas |334 - 333| = 1. One can't get the better value because if |c_1 - c_2| = 0, then c_1 = c_2 and c_1 \u22c5 1 + c_1 \u22c5 2 = 1000, but then the value of c_1 isn't an integer.\\n\\nThe answer for the second test case is \\\"10 10\\\". The sum of the nominal values is 10 \u22c5 1 + 10 \u22c5 2 = 30 and |10 - 10| = 0, whereas there's no number having an absolute value less than 0.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst long long mod = 1e9 + 7;\\nconst long long m1 = 1000000123;\\nconst long long m2 = 1000000321;\\ninline long long modMul(long long a, long long b) {\\n  return ((a % mod) * (b % mod)) % mod;\\n}\\ninline long long modAdd(long long a, long long b) {\\n  return ((a % mod) + (b % mod)) % mod;\\n}\\ninline long long modPow(long long b, long long p) {\\n  long long r = 1;\\n  while (p) {\\n    if (p & 1) r = modMul(r, b);\\n    b = modMul(b, b);\\n    p >>= 1;\\n  }\\n  return r;\\n}\\ninline long long modInverse(long long a) { return modPow(a, mod - 2); }\\ninline long long modDiv(long long a, long long b) {\\n  return modMul(a, modInverse(b));\\n}\\nlong long const maxn = 1000000 + 1;\\nlong long fact[1000006];\\nlong long inv[1000006];\\nlong long gcd(long long a, long long b) {\\n  if (b == 0) {\\n    return a;\\n  }\\n  return gcd(b, a % b);\\n}\\nbool comp(long long a, long long b) { return a > b; }\\nlong long power(long long a, long long n) {\\n  long long res = 1;\\n  while (n) {\\n    if (n % 2 == 0) {\\n      a = ((a) * (a));\\n      n = n \\/ 2;\\n    } else {\\n      n--;\\n      res = ((a) * (res));\\n    }\\n  }\\n  return res;\\n}\\nvoid solve() {\\n  long long n;\\n  cin >> n;\\n  long long a = 0;\\n  long long b = 0;\\n  if (n % 3 == 0) {\\n    long long x = n \\/ 3;\\n    cout << x << \\\" \\\" << x << \\\"\\\\n\\\";\\n  } else {\\n    long long r = n % 3;\\n    a = n \\/ 3;\\n    b = n \\/ 3;\\n    if (r == 2) {\\n      b++;\\n    } else {\\n      a++;\\n    }\\n    cout << a << \\\" \\\";\\n    ;\\n    cout << b << \\\"\\\\n\\\";\\n    ;\\n  }\\n}\\nint32_t main() {\\n  ios::sync_with_stdio(false);\\n  cin.tie(NULL);\\n  long long test;\\n  test = 1;\\n  cin >> test;\\n  while (test--) {\\n    solve();\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in CPP?\\nPetya recently found a game \\\"Choose a Square\\\". In this game, there are n points numbered from 1 to n on an infinite field. The i-th point has coordinates (x_i, y_i) and cost c_i.\\n\\nYou have to choose a square such that its sides are parallel to coordinate axes, the lower left and upper right corners belong to the line y = x, and all corners have integer coordinates.\\n\\nThe score you get is the sum of costs of the points covered by the selected square minus the length of the side of the square. Note that the length of the side can be zero.\\n\\nPetya asks you to calculate the maximum possible score in the game that can be achieved by placing exactly one square.\\n\\nInput\\n\\nThe first line of the input contains one integer n (1 \u2264 n \u2264 5 \u22c5 10^5) \u2014 the number of points on the field.\\n\\nEach of the following n lines contains three integers x_i, y_i, c_i (0 \u2264 x_i, y_i \u2264 10^9, -10^6 \u2264 c_i \u2264 10^6) \u2014 coordinates of the i-th point and its cost, respectively.\\n\\nOutput\\n\\nIn the first line print the maximum score Petya can achieve.\\n\\nIn the second line print four integers x_1, y_1, x_2, y_2 (0 \u2264 x_1, y_1, x_2, y_2 \u2264 2 \u22c5 10^9, x_1 = y_1, x_2 = y_2, x_1 \u2264 x_2) separated by spaces \u2014 the coordinates of the lower left and upper right corners of the square which Petya has to select in order to achieve the maximum score.\\n\\nExamples\\n\\nInput\\n\\n\\n6\\n0 0 2\\n1 0 -5\\n1 1 3\\n2 3 4\\n1 4 -4\\n3 1 -1\\n\\n\\nOutput\\n\\n\\n4\\n1 1 3 3\\n\\n\\nInput\\n\\n\\n5\\n3 3 0\\n3 3 -3\\n0 2 -1\\n3 1 3\\n0 0 -2\\n\\n\\nOutput\\n\\n\\n0\\n1 1 1 1\\n\\nNote\\n\\nThe field corresponding to the first example: <image>\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nusing LL = long long;\\nusing PLI = pair<LL, int>;\\nconst LL INF = 1e18;\\nclass SegmentTree {\\n  int sz;\\n  vector<PLI> tree;\\n  vector<LL> lazy;\\n  void split(int node) {\\n    tree[2 * node].first += lazy[node];\\n    lazy[2 * node] += lazy[node];\\n    tree[2 * node + 1].first += lazy[node];\\n    lazy[2 * node + 1] += lazy[node];\\n    lazy[node] = 0;\\n  }\\n  void merge(int node) { tree[node] = max(tree[2 * node], tree[2 * node + 1]); }\\n\\n public:\\n  SegmentTree(int n) {\\n    for (sz = 1; sz < n; sz <<= 1)\\n      ;\\n    tree.resize(2 * sz);\\n    for (int i = 0; i < sz; i++) {\\n      tree[sz + i].second = i;\\n    }\\n    for (int i = sz - 1; i >= 1; i--) {\\n      merge(i);\\n    }\\n    lazy.resize(2 * sz, 0);\\n  }\\n  void update(int l, int r, LL delta, int node = 1, int x = 0, int y = -1) {\\n    if (y == -1) y = sz;\\n    if (r <= x || l >= y) return;\\n    if (l <= x && y <= r) {\\n      tree[node].first += delta;\\n      lazy[node] += delta;\\n      return;\\n    }\\n    split(node);\\n    update(l, r, delta, 2 * node, x, (x + y) \\/ 2);\\n    update(l, r, delta, 2 * node + 1, (x + y) \\/ 2, y);\\n    merge(node);\\n  }\\n  PLI query(int l, int r, int node = 1, int x = 0, int y = -1) {\\n    if (y == -1) y = sz;\\n    if (r <= x || l >= y) return {-INF, -1};\\n    if (l <= x && y <= r) return tree[node];\\n    return max(query(l, r, 2 * node, x, (x + y) \\/ 2),\\n               query(l, r, 2 * node + 1, (x + y) \\/ 2, y));\\n  }\\n};\\nint main() {\\n  ios_base::sync_with_stdio(false);\\n  cin.tie(NULL);\\n  int n;\\n  cin >> n;\\n  vector<pair<int, pair<int, int>>> pts;\\n  vector<int> ys;\\n  for (int i = 0; i < n; i++) {\\n    int x, y, c;\\n    cin >> x >> y >> c;\\n    if (x > y) swap(x, y);\\n    pts.emplace_back(x, make_pair(y, c));\\n    ys.push_back(y);\\n    ;\\n  }\\n  SegmentTree tree(n);\\n  sort(ys.begin(), ys.end());\\n  ys.resize(unique(ys.begin(), ys.end()) - ys.begin());\\n  map<int, int> idy;\\n  int m = 0;\\n  for (int y : ys) {\\n    idy[y] = m++;\\n    tree.update(idy[y], idy[y] + 1, -y);\\n  }\\n  sort(pts.rbegin(), pts.rend());\\n  const int MAXC = 2e9;\\n  pair<LL,...\",\"language\":\"python\",\"split\":\"train\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"An important meeting is to be held and there are exactly n people invited. At any moment, any two people can step back and talk in private. The same two people can talk several (as many as they want) times per meeting.\\n\\nEach person has limited sociability. The sociability of the i-th person is a non-negative integer a_i. This means that after exactly a_i talks this person leaves the meeting (and does not talk to anyone else anymore). If a_i = 0, the i-th person leaves the meeting immediately after it starts.\\n\\nA meeting is considered most productive if the maximum possible number of talks took place during it.\\n\\nYou are given an array of sociability a, determine which people should talk to each other so that the total number of talks is as large as possible.\\n\\nInput\\n\\nThe first line contains an integer t (1 \u2264 t \u2264 1000) \u2014 the number of test cases.\\n\\nThe next 2t lines contain descriptions of the test cases.\\n\\nThe first line of each test case description contains an integer n (2 \u2264 n \u2264 2 \u22c5 10^5) \u2014the number of people in the meeting. The second line consists of n space-separated integers a_1, a_2, ..., a_n (0 \u2264 a_i \u2264 2 \u22c5 10^5) \u2014 the sociability parameters of all people. \\n\\nIt is guaranteed that the sum of n over all test cases does not exceed 2 \u22c5 10^5. It is also guaranteed that the sum of all a_i (over all test cases and all i) does not exceed 2 \u22c5 10^5.\\n\\nOutput\\n\\nPrint t answers to all test cases.\\n\\nOn the first line of each answer print the number k \u2014 the maximum number of talks possible in a meeting.\\n\\nOn each of the next k lines print two integers i and j (1 \u2264 i, j \u2264 n and i \u2260 j) \u2014 the numbers of people who will have another talk.\\n\\nIf there are several possible answers, you may print any of them.\\n\\nExample\\n\\nInput\\n\\n\\n8\\n2\\n2 3\\n3\\n1 2 3\\n4\\n1 2 3 4\\n3\\n0 0 2\\n2\\n6 2\\n3\\n0 0 2\\n5\\n8 2 0 1 1\\n5\\n0 1 0 0 6\\n\\n\\nOutput\\n\\n\\n2\\n1 2\\n1 2\\n3\\n1 3\\n2 3\\n2 3\\n5\\n1 3\\n2 4\\n2 4\\n3 4\\n3 4\\n0\\n2\\n1 2\\n1 2\\n0\\n4\\n1 2\\n1 5\\n1 4\\n1 2\\n1\\n5 2\",\"targets\":\"#include <bits\\/stdc++.h>\\nconst long long mod = 1e9 + 7;\\nconst long long N = 2e5 + 5;\\nconst long long MAXN = 10000001;\\nlong long spf[MAXN];\\nlong long fact[N], invfact[N];\\nusing namespace std;\\nbool is_prime(long long n) {\\n  if (n == 1) {\\n    return false;\\n  }\\n  long long i = 2;\\n  while (i * i <= n) {\\n    if (n % i == 0) {\\n      return false;\\n    }\\n    i += 1;\\n  }\\n  return true;\\n}\\nlong long pow(long long a, long long b, long long m) {\\n  long long ans = 1;\\n  while (b) {\\n    if (b & 1) ans = (ans * a) % m;\\n    b \\/= 2;\\n    a = (a * a) % m;\\n  }\\n  return ans;\\n}\\nlong long modinv(long long k) { return pow(k, mod - 2, mod); }\\nvoid precompute() {\\n  fact[0] = fact[1] = 1;\\n  for (long long i = 2; i < N; i++) {\\n    fact[i] = fact[i - 1] * i;\\n    fact[i] %= mod;\\n  }\\n  invfact[N - 1] = modinv(fact[N - 1]);\\n  for (long long i = N - 2; i >= 0; i--) {\\n    invfact[i] = invfact[i + 1] * (i + 1);\\n    invfact[i] %= mod;\\n  }\\n}\\nlong long nCr(long long x, long long y) {\\n  if (y > x) return 0;\\n  long long num = fact[x];\\n  num *= invfact[y];\\n  num %= mod;\\n  num *= invfact[x - y];\\n  num %= mod;\\n  return num;\\n}\\nbool sortbysec(const pair<long long, long long> &a,\\n               const pair<long long, long long> &b) {\\n  return (a.second < b.second);\\n}\\nstring toBinary(long long n) {\\n  string r;\\n  while (n != 0) {\\n    r = (n % 2 == 0 ? \\\"0\\\" : \\\"1\\\") + r;\\n    n \\/= 2;\\n  }\\n  return r;\\n}\\nvoid sieve() {\\n  spf[1] = 1;\\n  for (long long i = 2; i < MAXN; i++) spf[i] = i;\\n  for (long long i = 4; i < MAXN; i += 2) spf[i] = 2;\\n  for (long long i = 3; i * i < MAXN; i++) {\\n    if (spf[i] == i) {\\n      for (long long j = i * i; j < MAXN; j += i)\\n        if (spf[j] == j) spf[j] = i;\\n    }\\n  }\\n}\\nlong long getFactorization(long long x) {\\n  long long ret = 0;\\n  while (x != 1) {\\n    ret++;\\n    x = x \\/ spf[x];\\n  }\\n  return ret;\\n}\\nvoid solve(long long in) {\\n  long long n;\\n  cin >> n;\\n  vector<long long> a(n);\\n  multimap<long long, long long> m;\\n  multiset<pair<long long, long long>> s;\\n  long long sum = 0;\\n  long long zc = 0;\\n  for (long long i = 0; i < n; i++) {\\n   ...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"'Twas the night before Christmas, and Santa's frantically setting up his new Christmas tree! There are n nodes in the tree, connected by n-1 edges. On each edge of the tree, there's a set of Christmas lights, which can be represented by an integer in binary representation.\\n\\n<image>\\n\\nHe has m elves come over and admire his tree. Each elf is assigned two nodes, a and b, and that elf looks at all lights on the simple path between the two nodes. After this, the elf's favorite number becomes the [bitwise XOR](https:\\/\\/en.wikipedia.org\\/wiki\\/Bitwise_operation#XOR) of the values of the lights on the edges in that path.\\n\\nHowever, the North Pole has been recovering from a nasty bout of flu. Because of this, Santa forgot some of the configurations of lights he had put on the tree, and he has already left the North Pole! Fortunately, the elves came to the rescue, and each one told Santa what pair of nodes he was assigned (a_i, b_i), as well as the parity of the number of set bits in his favorite number. In other words, he remembers whether the number of 1's when his favorite number is written in binary is odd or even.\\n\\nHelp Santa determine if it's possible that the memories are consistent, and if it is, remember what his tree looked like, and maybe you'll go down in history!\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 2 \u22c5 10^4) \u2014 the number of test cases. Then t cases follow.\\n\\nThe first line of each test case contains two integers, n and m (2 \u2264 n \u2264 2 \u22c5 10^5; 1 \u2264 m \u2264 2 \u22c5 10^5) \u2014 the size of tree and the number of elves respectively.\\n\\nThe next n-1 lines of each test case each contains three integers, x, y, and v (1 \u2264 x, y \u2264 n; -1 \u2264 v < 2^{30}) \u2014 meaning that there's an edge between nodes x and y. If \\n\\n  * v = -1: Santa doesn't remember what the set of lights were on for this edge. \\n  * v \u2265 0: The set of lights on the edge is v. \\n\\n\\n\\nThe next m lines of each test case each contains three integers, a, b, and p (1 \u2264 a, b \u2264 n; a \u2260 b; 0 \u2264 p \u2264 1) \u2014 the nodes that the elf was assigned to, and the parity of the number of...\\nSolve the task in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nlong long i, i1, j, k, k1, t, n, m, res, flag[10], a, b;\\nlong long c[200010], w, dist[200010];\\nbool vis[200010];\\nvector<array<long long, 2>> adj[200010], gr[200010];\\nvoid dfs(long long s) {\\n  vis[s] = true;\\n  for (auto [u, w] : adj[s]) {\\n    if (vis[u]) continue;\\n    if (w != -1) {\\n      w = __builtin_popcountll(w) % 2;\\n      gr[s].push_back({u, w});\\n      gr[u].push_back({s, w});\\n    }\\n    dist[u] = dist[s] + 1;\\n    dfs(u);\\n  }\\n}\\nvoid bip(long long s) {\\n  vis[s] = true;\\n  for (auto [u, w] : gr[s]) {\\n    if (vis[u] == true && c[u] != (c[s] ^ w)) {\\n      flag[0] = 0;\\n      break;\\n    }\\n    if (vis[u]) continue;\\n    c[u] = c[s] ^ w;\\n    bip(u);\\n  }\\n}\\nvoid fns(long long s) {\\n  vis[s] = true;\\n  for (auto &u : adj[s]) {\\n    if (vis[u[0]]) continue;\\n    if (u[1] == -1) u[1] = c[u[0]] ^ c[s];\\n    fns(u[0]);\\n  }\\n}\\nvoid rst() {\\n  long long i;\\n  flag[0] = 1;\\n  for (i = 1; i <= n; i++) {\\n    adj[i].clear();\\n    gr[i].clear();\\n    vis[i] = false;\\n  }\\n}\\nint main() {\\n  ios::sync_with_stdio(0);\\n  cin.tie(0);\\n  cin >> t;\\n  while (t--) {\\n    cin >> n >> m;\\n    rst();\\n    for (i = 1; i <= n - 1; i++) {\\n      cin >> a >> b >> w;\\n      adj[a].push_back({b, w});\\n      adj[b].push_back({a, w});\\n    }\\n    for (i = 1; i <= m; i++) {\\n      cin >> a >> b >> w;\\n      gr[a].push_back({b, w});\\n      gr[b].push_back({a, w});\\n    }\\n    dfs(1);\\n    for (i = 1; i <= n; i++) vis[i] = false;\\n    for (i = 1; i <= n; i++) {\\n      if (vis[i]) continue;\\n      bip(i);\\n    }\\n    if (flag[0] == 0) {\\n      cout << \\\"NO\\\"\\n           << \\\"\\\\n\\\";\\n      continue;\\n    }\\n    for (i = 1; i <= n; i++) vis[i] = false;\\n    fns(1);\\n    cout << \\\"YES\\\"\\n         << \\\"\\\\n\\\";\\n    for (i = 1; i <= n; i++) {\\n      for (auto [u, w] : adj[i]) {\\n        if (dist[u] < dist[i]) continue;\\n        cout << i << ' ' << u << ' ' << w << \\\"\\\\n\\\";\\n      }\\n    }\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CQXYM wants to create a connected undirected graph with n nodes and m edges, and the diameter of the graph must be strictly less than k-1. Also, CQXYM doesn't want a graph that contains self-loops or multiple edges (i.e. each edge connects two different vertices and between each pair of vertices there is at most one edge).\\n\\nThe diameter of a graph is the maximum distance between any two nodes.\\n\\nThe distance between two nodes is the minimum number of the edges on the path which endpoints are the two nodes.\\n\\nCQXYM wonders whether it is possible to create such a graph.\\n\\nInput\\n\\nThe input consists of multiple test cases. \\n\\nThe first line contains an integer t (1 \u2264 t \u2264 10^5) \u2014 the number of test cases. The description of the test cases follows.\\n\\nOnly one line of each test case contains three integers n(1 \u2264 n \u2264 10^9), m, k (0 \u2264 m,k \u2264 10^9).\\n\\nOutput\\n\\nFor each test case, print YES if it is possible to create the graph, or print NO if it is impossible. You can print each letter in any case (upper or lower).\\n\\nExample\\n\\nInput\\n\\n\\n5\\n1 0 3\\n4 5 3\\n4 6 3\\n5 4 1\\n2 1 1\\n\\n\\nOutput\\n\\n\\nYES\\nNO\\nYES\\nNO\\nNO\\n\\nNote\\n\\nIn the first test case, the graph's diameter equal to 0.\\n\\nIn the second test case, the graph's diameter can only be 2.\\n\\nIn the third test case, the graph's diameter can only be 1.\\nSolve the task in JAVA.\",\"targets\":\"import java.io.BufferedReader;\\nimport java.io.FileReader;\\nimport java.io.IOException;\\nimport java.io.InputStreamReader;\\nimport java.util.StringTokenizer;\\nimport java.util.Arrays;\\nimport java.util.Random;\\nimport java.io.FileWriter;\\nimport java.io.PrintWriter;\\n\\/*\\n    Solution Created: 14:02:15 30\\/09\\/2021\\n    Custom Competitive programming helper.\\n*\\/\\npublic class Main {\\n\\tpublic static void solve() {\\n\\t\\tlong n = in.nextInt(), m = in.nextInt(), k = in.nextInt();\\n\\t\\tlong maxEdges = n*(n-1)\\/2, minEdges = n-1, maxD = k-2;\\n\\t\\tboolean can = (minEdges<=m && m <= maxEdges);\\n\\t\\tif(!can) {\\n\\t\\t\\tout.yesNo(false);\\n\\t\\t\\treturn;\\n\\t\\t}\\n\\t\\tlong bestD = m==maxEdges?1:2;\\n\\t\\tif(n==1) bestD = 0;\\n\\t\\tcan &= bestD<=maxD;\\n\\t\\tout.yesNo(can);\\n\\t}\\n\\t\\n\\tpublic static void main(String[] args) {\\n\\t\\tin = new Reader();\\n\\t\\tout = new Writer();\\n\\t\\tint t = in.nextInt();\\n\\t\\twhile(t-->0) solve();\\n\\t\\tout.exit();\\n\\t}\\n\\tstatic Reader in; static Writer out;\\n\\nstatic class Reader {\\n\\tstatic BufferedReader br;\\n\\tstatic StringTokenizer st;\\n\\t\\n\\tpublic Reader() {\\n\\t\\tthis.br = new BufferedReader(new InputStreamReader(System.in));\\n\\t}\\n\\t\\n\\tpublic Reader(String f){\\n\\t\\ttry {\\n\\t\\t\\tthis.br = new BufferedReader(new FileReader(f));\\n\\t\\t} catch (IOException e) {\\n\\t\\t\\te.printStackTrace();\\n\\t\\t}\\n\\t}\\n\\t\\n\\tpublic int[] na(int n) {\\n\\t\\tint[] a = new int[n];\\n\\t\\tfor (int i = 0; i < n; i++) a[i] = nextInt();\\n\\t\\treturn a;\\n\\t}\\n\\n\\tpublic double[] nd(int n) {\\n\\t\\tdouble[] a = new double[n];\\n\\t\\tfor (int i = 0; i < n; i++) a[i] = nextDouble();\\n\\t\\treturn a;\\n\\t}\\n\\t\\n\\tpublic long[] nl(int n) {\\n\\t\\tlong[] a = new long[n];\\n\\t\\tfor (int i = 0; i < n; i++) a[i] = nextLong();\\n\\t\\treturn a;\\n\\t}\\n\\n\\tpublic char[] nca() {\\n\\t\\treturn next().toCharArray();\\n\\t}\\n\\n\\tpublic String[] ns(int n) {\\n\\t\\tString[] a = new String[n];\\n\\t\\tfor (int i = 0; i < n; i++) a[i] = next();\\n\\t\\treturn a;\\n\\t}\\n\\n\\tpublic int nextInt() {\\n\\t\\tensureNext();\\n\\t\\treturn Integer.parseInt(st.nextToken());\\n\\t}\\n\\n\\tpublic double nextDouble() {\\n\\t\\tensureNext();\\n\\t\\treturn Double.parseDouble(st.nextToken());\\n\\t}\\n\\n\\tpublic Long nextLong() {\\n\\t\\tensureNext();\\n\\t\\treturn Long.parseLong(st.nextToken());\\n\\t}\\n\\n\\tpublic String...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Omkar is hosting tours of his country, Omkarland! There are n cities in Omkarland, and, rather curiously, there are exactly n-1 bidirectional roads connecting the cities to each other. It is guaranteed that you can reach any city from any other city through the road network.\\n\\nEvery city has an enjoyment value e. Each road has a capacity c, denoting the maximum number of vehicles that can be on it, and an associated toll t. However, the toll system in Omkarland has an interesting quirk: if a vehicle travels on multiple roads on a single journey, they pay only the highest toll of any single road on which they traveled. (In other words, they pay max t over all the roads on which they traveled.) If a vehicle traverses no roads, they pay 0 toll.\\n\\nOmkar has decided to host q tour groups. Each tour group consists of v vehicles starting at city x. (Keep in mind that a tour group with v vehicles can travel only on roads with capacity \u2265 v.) Being the tour organizer, Omkar wants his groups to have as much fun as they possibly can, but also must reimburse his groups for the tolls that they have to pay. Thus, for each tour group, Omkar wants to know two things: first, what is the enjoyment value of the city y with maximum enjoyment value that the tour group can reach from their starting city, and second, how much per vehicle will Omkar have to pay to reimburse the entire group for their trip from x to y? (This trip from x to y will always be on the shortest path from x to y.)\\n\\nIn the case that there are multiple reachable cities with the maximum enjoyment value, Omkar will let his tour group choose which one they want to go to. Therefore, to prepare for all possible scenarios, he wants to know the amount of money per vehicle that he needs to guarantee that he can reimburse the group regardless of which city they choose.\\n\\nInput\\n\\nThe first line contains two integers n and q (2 \u2264 n \u2264 2 \u22c5 10^5, 1 \u2264 q \u2264 2 \u22c5 10^5), representing the number of cities and the number of groups, respectively.\\n\\nThe next line contains n integers e_1,...\\nUsing cpp can you solve the prior task?\",\"targets\":\"#include <bits\\/stdc++.h>\\n#pragma GCC optimize(2, 3, \\\"Ofast\\\")\\nusing namespace std;\\ntemplate <typename T1, typename T2>\\nvoid ckmin(T1 &a, T2 b) {\\n  if (a > b) a = b;\\n}\\ntemplate <typename T1, typename T2>\\nvoid ckmax(T1 &a, T2 b) {\\n  if (a < b) a = b;\\n}\\nint read() {\\n  int x = 0, f = 0;\\n  char ch = getchar();\\n  while (!isdigit(ch)) f |= ch == '-', ch = getchar();\\n  while (isdigit(ch)) x = 10 * x + ch - '0', ch = getchar();\\n  return f ? -x : x;\\n}\\ntemplate <typename T>\\nvoid print(T x) {\\n  if (x < 0) putchar('-'), x = -x;\\n  if (x >= 10) print(x \\/ 10);\\n  putchar(x % 10 + '0');\\n}\\ntemplate <typename T>\\nvoid print(T x, char let) {\\n  print(x), putchar(let);\\n}\\nconst int N = 200005;\\nstruct Edge {\\n  int to, nxt, val;\\n} edge[N << 1];\\nint head[N], tot;\\nvoid add(int u, int v, int val) {\\n  edge[++tot] = {v, head[u], val};\\n  head[u] = tot;\\n}\\nint a[N], ans1[N], ans2[N];\\nint _u[N], _v[N], _c[N], _t[N], ide[N];\\nint _qc[N], _qx[N], idq[N];\\nint n, q;\\nint jp[N][20], mx[N][20], dep[N];\\nvoid dfs1(int u, int fa) {\\n  dep[u] = dep[fa] + 1;\\n  for (int i = 1; i < 20; i++) {\\n    jp[u][i] = jp[jp[u][i - 1]][i - 1];\\n    mx[u][i] = max(mx[u][i - 1], mx[jp[u][i - 1]][i - 1]);\\n  }\\n  for (int i = head[u]; i; i = edge[i].nxt) {\\n    int v = edge[i].to;\\n    if (v == fa) continue;\\n    jp[v][0] = u, mx[v][0] = edge[i].val;\\n    dfs1(v, u);\\n  }\\n}\\nint query(int u, int v) {\\n  if (dep[u] < dep[v]) swap(u, v);\\n  int k = 0;\\n  for (int i = 19; i >= 0; i--) {\\n    if (dep[jp[u][i]] >= dep[v]) ckmax(k, mx[u][i]), u = jp[u][i];\\n  }\\n  if (u == v) return k;\\n  for (int i = 19; i >= 0; i--) {\\n    if (jp[u][i] != jp[v][i]) {\\n      ckmax(k, max(mx[u][i], mx[v][i]));\\n      u = jp[u][i];\\n      v = jp[v][i];\\n    }\\n  }\\n  return max(k, max(mx[u][0], mx[v][0]));\\n}\\nint f[N], dot[N], maxx[N];\\nint find(int x) { return f[x] == x ? x : f[x] = find(f[x]); }\\nvoid merge(int x, int y) {\\n  x = find(x), y = find(y);\\n  if (x == y) return;\\n  f[x] = y;\\n  if (a[dot[x]] > a[dot[y]]) {\\n    dot[y] = dot[x];\\n    maxx[y] = maxx[x];\\n  } else if (a[dot[x]] == a[dot[y]]) {\\n    ckmax(maxx[y],...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Morning desert sun horizon\\n\\nRise above the sands of time...\\n\\nFates Warning, \\\"Exodus\\\"\\n\\nAfter crossing the Windswept Wastes, Ori has finally reached the Windtorn Ruins to find the Heart of the Forest! However, the ancient repository containing this priceless Willow light did not want to open!\\n\\nOri was taken aback, but the Voice of the Forest explained to him that the cunning Gorleks had decided to add protection to the repository.\\n\\nThe Gorleks were very fond of the \\\"string expansion\\\" operation. They were also very fond of increasing subsequences.\\n\\nSuppose a string s_1s_2s_3 \u2026 s_n is given. Then its \\\"expansion\\\" is defined as the sequence of strings s_1, s_1 s_2, ..., s_1 s_2 \u2026 s_n, s_2, s_2 s_3, ..., s_2 s_3 \u2026 s_n, s_3, s_3 s_4, ..., s_{n-1} s_n, s_n. For example, the \\\"expansion\\\" the string 'abcd' will be the following sequence of strings: 'a', 'ab', 'abc', 'abcd', 'b', 'bc', 'bcd', 'c', 'cd', 'd'. \\n\\nTo open the ancient repository, Ori must find the size of the largest increasing subsequence of the \\\"expansion\\\" of the string s. Here, strings are compared lexicographically.\\n\\nHelp Ori with this task!\\n\\nA string a is lexicographically smaller than a string b if and only if one of the following holds:\\n\\n  * a is a prefix of b, but a \u2260 b;\\n  * in the first position where a and b differ, the string a has a letter that appears earlier in the alphabet than the corresponding letter in b.\\n\\nInput\\n\\nEach test contains multiple test cases.\\n\\nThe first line contains one positive integer t (1 \u2264 t \u2264 10^3), denoting the number of test cases. Description of the test cases follows.\\n\\nThe first line of each test case contains one positive integer n (1 \u2264 n \u2264 5000) \u2014 length of the string.\\n\\nThe second line of each test case contains a non-empty string of length n, which consists of lowercase latin letters.\\n\\nIt is guaranteed that the sum of n over all test cases does not exceed 10^4.\\n\\nOutput\\n\\nFor every test case print one non-negative integer \u2014 the answer to the...\\nUsing cpp can you solve the prior task?\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst int INF = 0x3f3f3f3f;\\nconst long long INF64 = 0x3f3f3f3f3f3f3f3f;\\nconst double PI = acos(-1);\\ntypedef std::priority_queue<int, vector<int>, greater<int>> small_pq;\\ntypedef std::priority_queue<int, vector<int>, less<int>> big_pq;\\ntemplate <typename A, typename B>\\nostream &operator<<(ostream &os, const pair<A, B> &p) {\\n  return os << '(' << p.first << \\\", \\\" << p.second << ')';\\n}\\ntemplate <typename T_container, typename T = typename enable_if<\\n                                    !is_same<T_container, string>::value,\\n                                    typename T_container::value_type>::type>\\nostream &operator<<(ostream &os, const T_container &v) {\\n  os << '{';\\n  string sep;\\n  for (const T &x : v) os << sep << x, sep = \\\", \\\";\\n  return os << '}';\\n}\\nvoid dbg_out() {}\\ntemplate <typename Head, typename... Tail>\\nvoid dbg_out(Head H, Tail... T) {\\n  cerr << \\\" \\\" << H;\\n  if (sizeof...(T) > 0) cerr << \\\" ,\\\";\\n  dbg_out(T...);\\n}\\nvoid dbg_name(const string &s) {\\n  string ss = s;\\n  replace(ss.begin(), ss.end(), ',', ' ');\\n  cerr << \\\"  ( \\\" << ss << \\\" )  \\\";\\n}\\ntemplate <typename T>\\ninline void setmin(T &a, const T &b) {\\n  if (b < a) a = b;\\n}\\ntemplate <typename T>\\ninline void setmax(T &a, const T &b) {\\n  if (b > a) a = b;\\n}\\nstruct custom_hash {\\n  static uint64_t splitmix64(uint64_t x) {\\n    x += 0x9e3779b97f4a7c15;\\n    x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;\\n    x = (x ^ (x >> 27)) * 0x94d049bb133111eb;\\n    return x ^ (x >> 31);\\n  }\\n  size_t operator()(uint64_t x) const {\\n    static const uint64_t FIXED_RANDOM =\\n        chrono::steady_clock::now().time_since_epoch().count();\\n    return splitmix64(x + FIXED_RANDOM);\\n  }\\n};\\nunordered_map<long long, int, custom_hash> safe_map;\\nmt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());\\nmt19937_64 rnd64(chrono::steady_clock::now().time_since_epoch().count());\\nconst int MOD = 998244353;\\nint mul(int x, int y) { return 1ll * x * y % MOD; }\\nint add(int x, int y) { return ((x + y) % MOD + MOD) % MOD; }\\nint sub(int x, int y) {...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Polycarp likes squares and cubes of positive integers. Here is the beginning of the sequence of numbers he likes: 1, 4, 8, 9, ....\\n\\nFor a given number n, count the number of integers from 1 to n that Polycarp likes. In other words, find the number of such x that x is a square of a positive integer number or a cube of a positive integer number (or both a square and a cube simultaneously).\\n\\nInput\\n\\nThe first line contains an integer t (1 \u2264 t \u2264 20) \u2014 the number of test cases.\\n\\nThen t lines contain the test cases, one per line. Each of the lines contains one integer n (1 \u2264 n \u2264 10^9).\\n\\nOutput\\n\\nFor each test case, print the answer you are looking for \u2014 the number of integers from 1 to n that Polycarp likes.\\n\\nExample\\n\\nInput\\n\\n\\n6\\n10\\n1\\n25\\n1000000000\\n999999999\\n500000000\\n\\n\\nOutput\\n\\n\\n4\\n1\\n6\\n32591\\n32590\\n23125\\nUsing python3 can you solve the prior task?\",\"targets\":\"import sys\\nimport math\\nimport itertools\\nimport functools\\nimport collections\\nimport operator\\nimport fileinput\\nimport copy\\nimport string\\n\\nORDA = 97  # a\\n\\n\\ndef ii(): return int(input())\\n\\n\\ndef mi(): return map(int, input().split())\\n\\n\\ndef li(): return list(map(int, input().split()))\\n\\n\\ndef lcm(a, b): return abs(a * b) \\/\\/ math.gcd(a, b)\\n\\n\\ndef revn(n): return str(n)[::-1]\\n\\n\\ndef dd(): return collections.defaultdict(int)\\n\\n\\ndef ddl(): return collections.defaultdict(list)\\n\\n\\ndef sieve(n):\\n    if n < 2: return list()\\n    prime = [True for _ in range(n + 1)]\\n    p = 3\\n    while p * p <= n:\\n        if prime[p]:\\n            for i in range(p * 2, n + 1, p):\\n                prime[i] = False\\n        p += 2\\n    r = [2]\\n    for p in range(3, n + 1, 2):\\n        if prime[p]:\\n            r.append(p)\\n    return r\\n\\n\\ndef divs(n, start=2):\\n    r = []\\n    for i in range(start, int(math.sqrt(n) + 1)):\\n        if (n % i == 0):\\n            if (n \\/\\/ i == i):\\n                r.append(i)\\n            else:\\n                r.extend([i, n \\/\\/ i])\\n    return r\\n\\n\\ndef divn(n, primes):\\n    divs_number = 1\\n    for i in primes:\\n        if n == 1:\\n            return divs_number\\n        t = 1\\n        while n % i == 0:\\n            t += 1\\n            n \\/\\/= i\\n        divs_number *= t\\n\\n\\ndef prime(n):\\n    if n == 2: return True\\n    if n % 2 == 0 or n <= 1: return False\\n    sqr = int(math.sqrt(n)) + 1\\n    for d in range(3, sqr, 2):\\n        if n % d == 0: return False\\n    return True\\n\\n\\ndef convn(number, base):\\n    new_number = 0\\n    while number > 0:\\n        new_number += number % base\\n        number \\/\\/= base\\n    return new_number\\n\\n\\ndef cdiv(n, k): return n \\/\\/ k + (n % k != 0)\\n\\n\\ndef ispal(s):\\n    for i in range(len(s) \\/\\/ 2 + 1):\\n        if s[i] != s[-i - 1]:\\n            return False\\n    return True\\n\\n\\nfor _ in range(ii()):\\n    n = ii()\\n    ans = 0\\n    i = 1\\n    while i ** 2 <= n:\\n        ans += 1\\n        i += 1\\n    i = 1\\n    while i ** 3 <= n:\\n        ans += 1\\n        i += 1\\n    i = 1\\n    while i ** 6 <= n:\\n        ans -= 1\\n        i += 1\\n    print(ans)\",\"language\":\"python\",\"split\":\"test\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Ehab has an array a of length n. He has just enough free time to make a new array consisting of n copies of the old array, written back-to-back. What will be the length of the new array's longest increasing subsequence?\\n\\nA sequence a is a subsequence of an array b if a can be obtained from b by deletion of several (possibly, zero or all) elements. The longest increasing subsequence of an array is the longest subsequence such that its elements are ordered in strictly increasing order.\\n\\nInput\\n\\nThe first line contains an integer t \u2014 the number of test cases you need to solve. The description of the test cases follows.\\n\\nThe first line of each test case contains an integer n (1 \u2264 n \u2264 10^5) \u2014 the number of elements in the array a.\\n\\nThe second line contains n space-separated integers a_1, a_2, \u2026, a_{n} (1 \u2264 a_i \u2264 10^9) \u2014 the elements of the array a.\\n\\nThe sum of n across the test cases doesn't exceed 10^5.\\n\\nOutput\\n\\nFor each testcase, output the length of the longest increasing subsequence of a if you concatenate it to itself n times.\\n\\nExample\\n\\nInput\\n\\n\\n2\\n3\\n3 2 1\\n6\\n3 1 4 1 5 9\\n\\n\\nOutput\\n\\n\\n3\\n5\\n\\nNote\\n\\nIn the first sample, the new array is [3,2,1,3,2,1,3,2,1]. The longest increasing subsequence is marked in bold.\\n\\nIn the second sample, the longest increasing subsequence will be [1,3,4,5,9].\\nSolve the task in JAVA.\",\"targets\":\"import java.util.*;\\npublic class Solution\\n{\\n    public static void main(String[] args) \\n    {\\n     Scanner sc=new Scanner(System.in);\\n     int t=sc.nextInt();\\n     for(int z=0;z<t;z++)\\n     {\\n     int n=sc.nextInt();\\n     int a[]=new int[n];\\n        for(int i=0;i<n;i++)\\n        {\\n             a[i]=sc.nextInt();\\n        }\\n        Arrays.sort(a);\\n     for(int i=0;i<n-1;i++)\\n     {\\n         if(a[i]==0)\\n         {\\n             break;\\n         }\\n         for(int j=i+1;j<n;j++)\\n         {\\n             if(a[i]==a[j])\\n             {\\n                 a[j]=0;\\n             }\\n             else if(a[i]!=a[j])\\n             {\\n                 i=j-1;\\n                 break;\\n             }\\n         }\\n     }\\n     int count=0;\\n        for(int i=0;i<n;i++)\\n        {\\n            if(a[i]>0)\\n            {\\n                count++;\\n            }\\n        }\\n        \\n         System.out.println(count);\\n         \\n     }\\n    }\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"There is a city park represented as a tree with n attractions as its vertices and n - 1 rails as its edges. The i-th attraction has happiness value a_i.\\n\\nEach rail has a color. It is either black if t_i = 0, or white if t_i = 1. Black trains only operate on a black rail track, and white trains only operate on a white rail track. If you are previously on a black train and want to ride a white train, or you are previously on a white train and want to ride a black train, you need to use 1 ticket.\\n\\nThe path of a tour must be a simple path \u2014 it must not visit an attraction more than once. You do not need a ticket the first time you board a train. You only have k tickets, meaning you can only switch train types at most k times. In particular, you do not need a ticket to go through a path consisting of one rail color.\\n\\nDefine f(u, v) as the sum of happiness values of the attractions in the tour (u, v), which is a simple path that starts at the u-th attraction and ends at the v-th attraction. Find the sum of f(u,v) for all valid tours (u, v) (1 \u2264 u \u2264 v \u2264 n) that does not need more than k tickets, modulo 10^9 + 7.\\n\\nInput\\n\\nThe first line contains two integers n and k (2 \u2264 n \u2264 2 \u22c5 10^5, 0 \u2264 k \u2264 n-1) \u2014 the number of attractions in the city park and the number of tickets you have.\\n\\nThe second line contains n integers a_1, a_2,\u2026, a_n (0 \u2264 a_i \u2264 10^9) \u2014 the happiness value of each attraction.\\n\\nThe i-th of the next n - 1 lines contains three integers u_i, v_i, and t_i (1 \u2264 u_i, v_i \u2264 n, 0 \u2264 t_i \u2264 1) \u2014 an edge between vertices u_i and v_i with color t_i. The given edges form a tree.\\n\\nOutput\\n\\nOutput an integer denoting the total happiness value for all valid tours (u, v) (1 \u2264 u \u2264 v \u2264 n), modulo 10^9 + 7.\\n\\nExamples\\n\\nInput\\n\\n\\n5 0\\n1 3 2 6 4\\n1 2 1\\n1 4 0\\n3 2 1\\n2 5 0\\n\\n\\nOutput\\n\\n\\n45\\n\\n\\nInput\\n\\n\\n3 1\\n1 1 1\\n1 2 1\\n3 2 0\\n\\n\\nOutput\\n\\n\\n10\\\":\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst int N = 200000 + 9;\\nconst int P = 1000000000 + 7;\\nconst int inv2 = (P + 1) \\/ 2;\\ninline int add(int a, int b) { return a + b < P ? a + b : a + b - P; }\\ninline int sub(int a, int b) { return a - b < 0 ? a - b + P : a - b; }\\ninline int mul(int a, int b) { return (long long)a * b % P; }\\nint n, K, a[N], ans;\\nvector<pair<int, int>> G[N];\\nint rt, tot, msz, top, sz[N];\\nbool vis[N];\\nvoid dfs1(int u, int p) {\\n  int _max = 0;\\n  sz[u] = 1;\\n  for (auto [v, w] : G[u])\\n    if (!vis[v] && v != p) {\\n      dfs1(v, u);\\n      sz[u] += sz[v];\\n      _max = max(_max, sz[v]);\\n    }\\n  _max = max(_max, tot - sz[u]);\\n  if (_max < msz) {\\n    msz = _max;\\n    rt = u;\\n  }\\n}\\nvector<int> cnt[N], C[2], sum[N], S[2];\\nvoid dfs3(int u, int p, int c, int k, int ans) {\\n  if (k > K) return;\\n  cnt[top][k] = add(cnt[top][k], 1);\\n  sum[top][k] = add(sum[top][k], ans);\\n  for (auto [v, w] : G[u])\\n    if (!vis[v] && v != p) {\\n      dfs3(v, u, w, k + (c != w), add(ans, a[v]));\\n    }\\n}\\nvoid dfs2(int u, int _tot) {\\n  tot = _tot;\\n  msz = tot + 1;\\n  dfs1(u, 0);\\n  vis[rt] = true;\\n  int _sz = sz[rt];\\n  C[0].resize(min(K + 1, _tot));\\n  fill(C[0].begin(), C[0].end(), 0);\\n  C[1].resize(min(K + 1, _tot));\\n  fill(C[1].begin(), C[1].end(), 0);\\n  S[0].resize(min(K + 1, _tot));\\n  fill(S[0].begin(), S[0].end(), 0);\\n  S[1].resize(min(K + 1, _tot));\\n  fill(S[1].begin(), S[1].end(), 0);\\n  for (auto [v, w] : G[rt])\\n    if (!vis[v]) {\\n      top = v;\\n      cnt[v].resize(min(K + 1, sz[v] < _sz ? sz[v] : _tot - _sz));\\n      fill(cnt[v].begin(), cnt[v].end(), 0);\\n      sum[v].resize(min(K + 1, sz[v] < _sz ? sz[v] : _tot - _sz));\\n      fill(sum[v].begin(), sum[v].end(), 0);\\n      dfs3(v, rt, w, 0, a[v]);\\n      for (int i = 0, ed = cnt[v].size(); i < ed; ++i) {\\n        C[w][i] = add(C[w][i], cnt[v][i]);\\n        S[w][i] = add(S[w][i], sum[v][i]);\\n      }\\n    }\\n  ans = add(ans, a[rt]);\\n  for (int i = 0, ed = C[0].size(); i < ed; ++i) {\\n    ans = add(ans, add(mul(a[rt], C[0][i]), S[0][i]));\\n    ans = add(ans, add(mul(a[rt],...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Chef likes to watch movies very much.A movie of his favorite actress has recently released and he wants to go to cinema hall with his friends to watch the movie.\\nBut he will book tickets for him and his friends only if he gets the seats in his desired block size. eg. if he has 9 friends, then he has to book 10 tickets, and wants the seats to be in a rectangular block to 2 X 5. i.e if Chef has to book n number of seats, then the block of seats he would want is p X q where p * q = n\\nYou are given the status of all the seats(booked or not) and you have tell the Chef the number of blocks of exact size, in which all the seats in the block are not booked, and the seat number of the top left corner of the block, so that Chef could chose one of the them.(The seat number of the seats is same as the indices of  2D matrix with base index 0)\\n.\\nIt might be possible that no such block of empty seats is available\\n\\n\\nInput\\n\\nThe first line contains the number of test cases ( 1 <= t <= 10).\\nFirst line of each test contains n and m( 1 <= n,m <= 1000) which is the size of cinema hall. Cinema hall contains (n X m) no. of seats. The next line contains by p and q separated by a space which tells the block size non-booked seats that Chef wants.\\nIt is followed by n lines where each line contains m characters. A booked seat is denoted by '.' and an available seat is denoted by '#' . \\n\\n\\nOutput\\n\\nThe first line of output of each test case should consist of the number of available blocks of empty seats(  e ) i.e the number of blocks of p X q that have no booked seats.\\nIt should be followed by e number of lines where each line contains a and b (0 <= a < n , 0 <= b < m) denoting the top left corner of the  block of size p X q having all seats non-booked. \\nExample\\nInput:\\n1\\n2 6\\n2 3\\n.####.\\n.#####\\nOutput:\\n2\\n0 1\\n0 2\\nSolve the task in PYTHON.\",\"targets\":\"import sys\\ntimes=input()\\nwhile times:\\n times-=1   \\n a,b=[int(x) for x in sys.stdin.readline().strip().split()]\\n c,d=[int(x) for x in sys.stdin.readline().strip().split()]\\n p=a\\n t=[]\\n while p:\\n    p=p-1\\n    l=list(sys.stdin.readline().strip())\\n    t+=[l]\\n i=0\\n count=0\\n count2=[]\\n while i<a-c+1:\\n    j=0\\n    while j<b-d+1:\\n        if(t[i][j]=='#'):\\n            k=i\\n            flag=0\\n            while (k<a)&(k<i+c):\\n                h=j\\n                while (h<b)&(h<j+d):\\n                    if(t[k][h]=='#'):\\n                        flag+=1\\n                    else:\\n                        flag=0\\n                        break\\n                    h+=1\\n                k+=1\\n            if(flag==c*d):\\n                count+=1\\n                count2+=[[i,j]]\\n        j+=1\\n    i+=1\\n print count\\n for i in count2:\\n    for j in i:\\n        print j,\\\" \\\",\\n    print\",\"language\":\"python\",\"split\":\"train\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in PYTHON3?\\nA bow adorned with nameless flowers that bears the earnest hopes of an equally nameless person.\\n\\nYou have obtained the elegant bow known as the Windblume Ode. Inscribed in the weapon is an array of n (n \u2265 3) positive distinct integers (i.e. different, no duplicates are allowed).\\n\\nFind the largest subset (i.e. having the maximum number of elements) of this array such that its sum is a composite number. A positive integer x is called composite if there exists a positive integer y such that 1 < y < x and x is divisible by y.\\n\\nIf there are multiple subsets with this largest size with the composite sum, you can output any of them. It can be proven that under the constraints of the problem such a non-empty subset always exists.\\n\\nInput\\n\\nEach test consists of multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 100). Description of the test cases follows.\\n\\nThe first line of each test case contains an integer n (3 \u2264 n \u2264 100) \u2014 the length of the array.\\n\\nThe second line of each test case contains n distinct integers a_{1},a_{2},...,a_{n} (1 \u2264 a_{i} \u2264 200) \u2014 the elements of the array.\\n\\nOutput\\n\\nEach test case should have two lines of output.\\n\\nThe first line should contain a single integer x: the size of the largest subset with composite sum. The next line should contain x space separated integers representing the indices of the subset of the initial array.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n3\\n8 1 2\\n4\\n6 9 4 2\\n9\\n1 2 3 4 5 6 7 8 9\\n3\\n200 199 198\\n\\n\\nOutput\\n\\n\\n2\\n2 1\\n4\\n2 1 4 3\\n9\\n6 9 1 2 3 4 5 7 8\\n3\\n1 2 3 \\n\\nNote\\n\\nIn the first test case, the subset \\\\\\\\{a_2, a_1\\\\} has a sum of 9, which is a composite number. The only subset of size 3 has a prime sum equal to 11. Note that you could also have selected the subset \\\\\\\\{a_1, a_3\\\\} with sum 8 + 2 = 10, which is composite as it's divisible by 2.\\n\\nIn the second test case, the sum of all elements equals to 21, which is a composite number. Here we simply take the whole array as our subset.\",\"targets\":\"from itertools import permutations as per\\nfrom math import factorial as fact\\nfrom difflib import SequenceMatcher\\nt = int(input())\\n# map(int,input().split())\\n# [int(i) for i in input().split()]\\np = [1]*20005\\nfor i in range(2,20005):\\n    if(p[i]==1):\\n        for j in range(i*2,20005,i):\\n            p[j] = 0\\nfor _ in range(t):\\n    n = int(input())\\n    a = [int(i) for i in input().split()]\\n    if(p[sum(a)] == 0):\\n        print(n)\\n        for i in range(n):print(i+1,end = \\\" \\\")\\n                \\n    else:\\n        print(n-1)\\n        t = 0\\n        for i in range(n):\\n            if(t == 1):\\n                print(i+1,end=\\\" \\\")\\n            elif a[i]%2 != 0:\\n                t = 1\\n            else:\\n                print(i+1,end=\\\" \\\")\\n    print()\",\"language\":\"python\",\"split\":\"test\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in CPP?\\nOmkar is hosting tours of his country, Omkarland! There are n cities in Omkarland, and, rather curiously, there are exactly n-1 bidirectional roads connecting the cities to each other. It is guaranteed that you can reach any city from any other city through the road network.\\n\\nEvery city has an enjoyment value e. Each road has a capacity c, denoting the maximum number of vehicles that can be on it, and an associated toll t. However, the toll system in Omkarland has an interesting quirk: if a vehicle travels on multiple roads on a single journey, they pay only the highest toll of any single road on which they traveled. (In other words, they pay max t over all the roads on which they traveled.) If a vehicle traverses no roads, they pay 0 toll.\\n\\nOmkar has decided to host q tour groups. Each tour group consists of v vehicles starting at city x. (Keep in mind that a tour group with v vehicles can travel only on roads with capacity \u2265 v.) Being the tour organizer, Omkar wants his groups to have as much fun as they possibly can, but also must reimburse his groups for the tolls that they have to pay. Thus, for each tour group, Omkar wants to know two things: first, what is the enjoyment value of the city y with maximum enjoyment value that the tour group can reach from their starting city, and second, how much per vehicle will Omkar have to pay to reimburse the entire group for their trip from x to y? (This trip from x to y will always be on the shortest path from x to y.)\\n\\nIn the case that there are multiple reachable cities with the maximum enjoyment value, Omkar will let his tour group choose which one they want to go to. Therefore, to prepare for all possible scenarios, he wants to know the amount of money per vehicle that he needs to guarantee that he can reimburse the group regardless of which city they choose.\\n\\nInput\\n\\nThe first line contains two integers n and q (2 \u2264 n \u2264 2 \u22c5 10^5, 1 \u2264 q \u2264 2 \u22c5 10^5), representing the number of cities and the number of groups, respectively.\\n\\nThe next line contains n integers e_1,...\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\ntemplate <typename T>\\nvoid chkMax(T &x, T y) {\\n  if (y > x) x = y;\\n}\\ntemplate <typename T>\\nvoid chkMin(T &x, T y) {\\n  if (y < x) x = y;\\n}\\ntemplate <typename T>\\nvoid inline read(T &x) {\\n  int f = 1;\\n  x = 0;\\n  char s = getchar();\\n  while (s < '0' || s > '9') {\\n    if (s == '-') f = -1;\\n    s = getchar();\\n  }\\n  while (s <= '9' && s >= '0') x = x * 10 + (s ^ 48), s = getchar();\\n  x *= f;\\n}\\nconst int N = 2e5 + 5, L = 18;\\nint n, q, a[N], r1[N], r2[N], pre[N], dep[N], dfn[N], dfncnt, fa[N][L],\\n    mx[N][L], sz[N];\\nstruct E {\\n  int v, c, t;\\n};\\nstruct Ed {\\n  int u, v, w;\\n  bool operator<(const Ed &b) const { return w < b.w; }\\n} ed[N];\\nvector<E> g[N];\\nstruct Q {\\n  int v, x, id;\\n  bool operator<(const Q &b) const { return v < b.v; }\\n} e[N];\\nvoid dfs(int u) {\\n  dep[u] = dep[fa[u][0]] + 1;\\n  dfn[u] = ++dfncnt;\\n  pre[dfn[u]] = u;\\n  for (int i = 1; i < L; i++) {\\n    mx[u][i] = max(mx[u][i - 1], mx[fa[u][i - 1]][i - 1]);\\n    fa[u][i] = fa[fa[u][i - 1]][i - 1];\\n  }\\n  sz[u] = 1;\\n  for (E t : g[u]) {\\n    int v = t.v;\\n    if (v == fa[u][0]) continue;\\n    mx[v][0] = t.t;\\n    fa[v][0] = u;\\n    dfs(v);\\n    sz[u] += sz[v];\\n  }\\n}\\nint inline lca(int x, int y) {\\n  if (dep[x] < dep[y]) swap(x, y);\\n  for (int i = L - 1; ~i; i--)\\n    if (dep[x] - (1 << i) >= dep[y]) x = fa[x][i];\\n  if (x == y) return x;\\n  for (int i = L - 1; ~i; i--)\\n    if (fa[x][i] != fa[y][i]) x = fa[x][i], y = fa[y][i];\\n  return x;\\n}\\nint inline qv(int x, int y) {\\n  if (dep[x] < dep[y]) swap(x, y);\\n  int res = 0;\\n  for (int i = L - 1; ~i; i--)\\n    if (dep[x] - (1 << i) >= dep[y]) chkMax(res, mx[x][i]), x = fa[x][i];\\n  if (x == y) return res;\\n  for (int i = L - 1; ~i; i--)\\n    if (fa[x][i] != fa[y][i])\\n      chkMax(res, mx[x][i]), chkMax(res, mx[y][i]), x = fa[x][i], y = fa[y][i];\\n  chkMax(res, mx[x][0]), chkMax(res, mx[y][0]);\\n  return res;\\n}\\nint w[N], d[N], f[N], p[N];\\nset<int> s[N];\\nint find(int x) { return x == f[x] ? x : f[x] = find(f[x]); }\\nvoid merge(int x, int y) {\\n  x = find(x), y = find(y);\\n  if (sz[x] > sz[y])...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"The only difference between this problem and D2 is that you don't have to provide the way to construct the answer in this problem, but you have to do it in D2.\\n\\nThere's a table of n \u00d7 m cells (n rows and m columns). The value of n \u22c5 m is even.\\n\\nA domino is a figure that consists of two cells having a common side. It may be horizontal (one of the cells is to the right of the other) or vertical (one of the cells is above the other).\\n\\nYou need to find out whether it is possible to place nm\\/2 dominoes on the table so that exactly k of them are horizontal and all the other dominoes are vertical. The dominoes cannot overlap and must fill the whole table.\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 10) \u2014 the number of test cases. Then t test cases follow.\\n\\nEach test case consists of a single line. The line contains three integers n, m, k (1 \u2264 n,m \u2264 100, 0 \u2264 k \u2264 nm\\/2, n \u22c5 m is even) \u2014 the number of rows, columns and horizontal dominoes, respectively.\\n\\nOutput\\n\\nFor each test case output \\\"YES\\\", if it is possible to place dominoes in the desired way, or \\\"NO\\\" otherwise.\\n\\nYou may print each letter in any case (YES, yes, Yes will all be recognized as positive answer, NO, no and nO will all be recognized as negative answer).\\n\\nExample\\n\\nInput\\n\\n\\n8\\n4 4 2\\n2 3 0\\n3 2 3\\n1 2 0\\n2 4 2\\n5 2 2\\n2 17 16\\n2 1 1\\n\\n\\nOutput\\n\\n\\nYES\\nYES\\nYES\\nNO\\nYES\\nNO\\nYES\\nNO\",\"targets\":\"def f(n,m,k):\\n    if n*m<2*k:\\n        return \\\"NO\\\"\\n    if n%2==0 and m%2==0:\\n        return \\\"YES\\\" if k%2==0 else \\\"NO\\\"\\n    elif n%2==0:\\n        return f(n,m-1,k)\\n    else:\\n        return f(m,n,n*m\\/\\/2 -k)\\nt=int(input())\\nfor test in range(t):\\n    n,m,k=map(int,input().split())\\n    print(f(n,m,k))\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"An n \u00d7 n table a is defined as follows:\\n\\n  * The first row and the first column contain ones, that is: ai, 1 = a1, i = 1 for all i = 1, 2, ..., n. \\n  * Each of the remaining numbers in the table is equal to the sum of the number above it and the number to the left of it. In other words, the remaining elements are defined by the formula ai, j = ai - 1, j + ai, j - 1. \\n\\n\\n\\nThese conditions define all the values in the table.\\n\\nYou are given a number n. You need to determine the maximum value in the n \u00d7 n table defined by the rules above.\\n\\nInput\\n\\nThe only line of input contains a positive integer n (1 \u2264 n \u2264 10) \u2014 the number of rows and columns of the table.\\n\\nOutput\\n\\nPrint a single line containing a positive integer m \u2014 the maximum value in the table.\\n\\nExamples\\n\\nInput\\n\\n1\\n\\n\\nOutput\\n\\n1\\n\\nInput\\n\\n5\\n\\n\\nOutput\\n\\n70\\n\\nNote\\n\\nIn the second test the rows of the table look as follows: \\n\\n{1, 1, 1, 1, 1},  {1, 2, 3, 4, 5},  {1, 3, 6, 10, 15},  {1, 4, 10, 20, 35},  {1, 5, 15, 35, 70}.\\nSolve the task in PYTHON3.\",\"targets\":\"n = int(input())\\na = [[i for i in range(n)] for j in range(n)]\\n\\nfor i in range(n):\\n    for j in range(n):\\n        if i == 0 or j == 0:\\n            a[i][j] = 1\\n        else:\\n            a[i][j] = a[i-1][j]+a[i][j-1]\\n\\nprint(a[n-1][n-1])\",\"language\":\"python\",\"split\":\"train\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Ehab has an array a of n integers. He likes the [bitwise-xor operation](https:\\/\\/en.wikipedia.org\\/wiki\\/Bitwise_operation#XOR) and he likes to bother Mahmoud so he came up with a problem. He gave Mahmoud q queries. In each of them, he gave Mahmoud 2 integers l and x, and asked him to find the number of subsequences of the first l elements of the array such that their bitwise-xor sum is x. Can you help Mahmoud answer the queries?\\n\\nA subsequence can contain elements that are not neighboring.\\n\\nInput\\n\\nThe first line contains integers n and q (1 \u2264 n, q \u2264 105), the number of elements in the array and the number of queries.\\n\\nThe next line contains n integers a1, a2, ..., an (0 \u2264 ai < 220), the elements of the array.\\n\\nThe next q lines, each contains integers l and x (1 \u2264 l \u2264 n, 0 \u2264 x < 220), representing the queries.\\n\\nOutput\\n\\nFor each query, output its answer modulo 109 + 7 in a newline.\\n\\nExamples\\n\\nInput\\n\\n5 5\\n0 1 2 3 4\\n4 3\\n2 0\\n3 7\\n5 7\\n5 8\\n\\n\\nOutput\\n\\n4\\n2\\n0\\n4\\n0\\n\\n\\nInput\\n\\n3 2\\n1 1 1\\n3 1\\n2 0\\n\\n\\nOutput\\n\\n4\\n2\\n\\nNote\\n\\nThe bitwise-xor sum of the empty set is 0 and the bitwise-xor sum of a set containing one element is that element itself.\\nSolve the task in JAVA.\",\"targets\":\"import java.io.BufferedReader;\\nimport java.io.IOException;\\nimport java.io.InputStreamReader;\\nimport java.io.PrintWriter;\\nimport java.util.ArrayList;\\nimport java.util.List;\\nimport java.util.StringTokenizer;\\n\\n\\/**\\n * @author Don Li\\n *\\/\\npublic class XorTask {\\n    \\n    int N = 1 << 20;\\n    int MOD = (int) 1e9 + 7;\\n    \\n    boolean[] in_set = new boolean[N];\\n    List<Integer> set = new ArrayList<>();\\n    \\n    void solve() {\\n        int n = in.nextInt(), m = in.nextInt();\\n        int[] a = new int[n];\\n        for (int i = 0; i < n; i++) a[i] = in.nextInt();\\n        int[] l = new int[m], x = new int[m];\\n        for (int i = 0; i < m; i++) {\\n            l[i] = in.nextInt();\\n            x[i] = in.nextInt();\\n        }\\n        \\n        int[] cnt = new int[n + 1];\\n        for (int i = 0; i < m; i++) {\\n            cnt[l[i]]++;\\n        }\\n        int[][][] grp = new int[n + 1][][];\\n        for (int i = 0; i <= n; i++) grp[i] = new int[cnt[i]][];\\n        for (int i = 0; i < m; i++) {\\n            grp[l[i]][--cnt[l[i]]] = new int[]{x[i], i};\\n        }\\n        \\n        int[] res = new int[m];\\n        set.add(0);\\n        in_set[0] = true;\\n        int ans = 1;\\n        for (int i = 0; i < n; i++) {\\n            if (in_set[a[i]]) {\\n                ans = ans * 2 % MOD;\\n            } else {\\n                int sz = set.size();\\n                for (int j = 0; j < sz; j++) {\\n                    int v = set.get(j) ^ a[i];\\n                    set.add(v);\\n                    in_set[v] = true;\\n                }\\n            }\\n            for (int[] t : grp[i + 1]) {\\n                if (in_set[t[0]]) res[t[1]] = ans;\\n            }\\n        }\\n        \\n        for (int i = 0; i < m; i++) {\\n            out.println(res[i]);\\n        }\\n    }\\n    \\n    public static void main(String[] args) {\\n        in = new FastScanner(new BufferedReader(new InputStreamReader(System.in)));\\n        out = new PrintWriter(System.out);\\n        new XorTask().solve();\\n        out.close();\\n    }\\n    \\n    static FastScanner in;\\n    static PrintWriter out;\\n    \\n    static...\",\"language\":\"python\",\"split\":\"train\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"This is a simplified version of the problem B2. Perhaps you should read the problem B2 before you start solving B1.\\n\\nPaul and Mary have a favorite string s which consists of lowercase letters of the Latin alphabet. They want to paint it using pieces of chalk of two colors: red and green. Let's call a coloring of a string wonderful if the following conditions are met:\\n\\n  1. each letter of the string is either painted in exactly one color (red or green) or isn't painted; \\n  2. each two letters which are painted in the same color are different; \\n  3. the number of letters painted in red is equal to the number of letters painted in green; \\n  4. the number of painted letters of this coloring is maximum among all colorings of the string which meet the first three conditions. \\n\\n\\n\\nE. g. consider a string s equal to \\\"kzaaa\\\". One of the wonderful colorings of the string is shown in the figure.\\n\\n<image> The example of a wonderful coloring of the string \\\"kzaaa\\\".\\n\\nPaul and Mary want to learn by themselves how to find a wonderful coloring of the string. But they are very young, so they need a hint. Help them find k \u2014 the number of red (or green, these numbers are equal) letters in a wonderful coloring.\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 1000) \u2014 the number of test cases. Then t test cases follow.\\n\\nEach test case consists of one non-empty string s which consists of lowercase letters of the Latin alphabet. The number of characters in the string doesn't exceed 50.\\n\\nOutput\\n\\nFor each test case, output a separate line containing one non-negative integer k \u2014 the number of letters which will be painted in red in a wonderful coloring.\\n\\nExample\\n\\nInput\\n\\n\\n5\\nkzaaa\\ncodeforces\\narchive\\ny\\nxxxxxx\\n\\n\\nOutput\\n\\n\\n2\\n5\\n3\\n0\\n1\\n\\nNote\\n\\nThe first test case contains the string from the statement. One of the wonderful colorings is shown in the figure. There's no wonderful coloring containing 3 or more red letters because the total number of painted symbols will exceed the string's length.\\n\\nThe string from the second test case can be...\\nThe above is tricky. Write me a correct solution in PYTHON3.\",\"targets\":\"t=int(input())\\nfor i in range(t):\\n  s=input()\\n  mp={}\\n  lst=[]\\n  uniq=0\\n  ans=0\\n  if(len(s)==1):\\n    print(0)\\n  else:  \\n    for i in range(len(s)):\\n      if(s[i] not in mp.keys()):\\n        mp[s[i]]=1\\n        lst.append(s[i])\\n      else:\\n        mp[s[i]]+=1\\n        \\n    if(len(mp)==1):\\n      print(1)\\n    else:\\n      for i in range(len(lst)):\\n        if(mp[lst[i]]>1):\\n          ans+=1\\n        else:\\n          uniq+=1\\n      ans+=uniq\\/\\/2\\n      print(ans)\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"It is the hard version of the problem. The only difference is that in this version 1 \u2264 n \u2264 300.\\n\\nIn the cinema seats can be represented as the table with n rows and m columns. The rows are numbered with integers from 1 to n. The seats in each row are numbered with consecutive integers from left to right: in the k-th row from m (k - 1) + 1 to m k for all rows 1 \u2264 k \u2264 n.\\n\\n1| 2| \u22c5\u22c5\u22c5| m - 1| m  \\n---|---|---|---|---  \\nm + 1| m + 2| \u22c5\u22c5\u22c5| 2 m - 1| 2 m  \\n2m + 1| 2m + 2| \u22c5\u22c5\u22c5| 3 m - 1| 3 m  \\n\\\\vdots| \\\\vdots| \\\\ddots| \\\\vdots| \\\\vdots  \\nm (n - 1) + 1| m (n - 1) + 2| \u22c5\u22c5\u22c5| n m - 1| n m  \\nThe table with seats indices\\n\\nThere are nm people who want to go to the cinema to watch a new film. They are numbered with integers from 1 to nm. You should give exactly one seat to each person.\\n\\nIt is known, that in this cinema as lower seat index you have as better you can see everything happening on the screen. i-th person has the level of sight a_i. Let's define s_i as the seat index, that will be given to i-th person. You want to give better places for people with lower sight levels, so for any two people i, j such that a_i < a_j it should be satisfied that s_i < s_j.\\n\\nAfter you will give seats to all people they will start coming to their seats. In the order from 1 to nm, each person will enter the hall and sit in their seat. To get to their place, the person will go to their seat's row and start moving from the first seat in this row to theirs from left to right. While moving some places will be free, some will be occupied with people already seated. The inconvenience of the person is equal to the number of occupied seats he or she will go through.\\n\\nLet's consider an example: m = 5, the person has the seat 4 in the first row, the seats 1, 3, 5 in the first row are already occupied, the seats 2 and 4 are free. The inconvenience of this person will be 2, because he will go through occupied seats 1 and 3.\\n\\nFind the minimal total inconvenience (the sum of inconveniences of all people), that is possible to have by giving places for all...\\nimpor\",\"targets\":\"t java.util.*;\\nimport java.lang.*;\\nimport java.io.*;\\n\\npublic class Main\\n{\\n\\tPrintWriter out = new PrintWriter(System.out);\\n\\tBufferedReader in = new BufferedReader(new InputStreamReader(System.in));\\n    StringTokenizer tok = new StringTokenizer(\\\"\\\");\\n    String next() throws IOException {\\n        if (!tok.hasMoreTokens()) { tok = new StringTokenizer(in.readLine()); }\\n        return tok.nextToken();\\n    }\\n    int ni() throws IOException { return Integer.parseInt(next()); }\\n    long nl() throws IOException { return Long.parseLong(next()); }\\n    \\n    long mod=1000000007;\\n    \\n    void solve() throws IOException {\\n        for (int tc=ni();tc>0;tc--) {\\n            int n=ni(),m=ni();\\n            HashMap<Integer,ArrayList<Integer>>H=new HashMap();\\n            ArrayList<Integer>A=new ArrayList();\\n            for (int i=0;i<n*m;i++) {\\n                int u=ni();\\n                if (!H.containsKey(u)) { H.put(u,new ArrayList()); A.add(u); }\\n                H.get(u).add(i);\\n            }\\n            \\n            Collections.sort(A);\\n            int[][]B=new int[n*m][2];\\n            int x=0;\\n            int y=0;\\n            for (int u:A) {\\n                int left=H.get(u).size();\\n                int p=0;\\n                while (left>0) {\\n                    if (left>m-y) {\\n                        int pos=m-1;\\n                        while (pos>=y) {\\n                            int v=H.get(u).get(p);\\n                            B[v][0]=x;\\n                            B[v][1]=pos;\\n                            pos--;\\n                            p++;\\n                            left--;\\n                        }\\n                        y=0;\\n                        x++;\\n                    }\\n                    else {\\n                        int pos=y+left-1;\\n                        while (pos>=y) {\\n                            int v=H.get(u).get(p);\\n                            B[v][0]=x;\\n                            B[v][1]=pos;\\n                            pos--;\\n                            p++;\\n                        }\\n           ...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Ivan is playing yet another roguelike computer game. He controls a single hero in the game. The hero has n equipment slots. There is a list of c_i items for the i-th slot, the j-th of them increases the hero strength by a_{i,j}. The items for each slot are pairwise distinct and are listed in the increasing order of their strength increase. So, a_{i,1} < a_{i,2} < ... < a_{i,c_i}.\\n\\nFor each slot Ivan chooses exactly one item. Let the chosen item for the i-th slot be the b_i-th item in the corresponding list. The sequence of choices [b_1, b_2, ..., b_n] is called a build.\\n\\nThe strength of a build is the sum of the strength increases of the items in it. Some builds are banned from the game. There is a list of m pairwise distinct banned builds. It's guaranteed that there's at least one build that's not banned.\\n\\nWhat is the build with the maximum strength that is not banned from the game? If there are multiple builds with maximum strength, print any of them.\\n\\nInput\\n\\nThe first line contains a single integer n (1 \u2264 n \u2264 10) \u2014 the number of equipment slots.\\n\\nThe i-th of the next n lines contains the description of the items for the i-th slot. First, one integer c_i (1 \u2264 c_i \u2264 2 \u22c5 10^5) \u2014 the number of items for the i-th slot. Then c_i integers a_{i,1}, a_{i,2}, ..., a_{i,c_i} (1 \u2264 a_{i,1} < a_{i,2} < ... < a_{i,c_i} \u2264 10^8).\\n\\nThe sum of c_i doesn't exceed 2 \u22c5 10^5.\\n\\nThe next line contains a single integer m (0 \u2264 m \u2264 10^5) \u2014 the number of banned builds.\\n\\nEach of the next m lines contains a description of a banned build \u2014 a sequence of n integers b_1, b_2, ..., b_n (1 \u2264 b_i \u2264 c_i).\\n\\nThe builds are pairwise distinct, and there's at least one build that's not banned.\\n\\nOutput\\n\\nPrint the build with the maximum strength that is not banned from the game. If there are multiple builds with maximum strength, print any of them.\\n\\nExamples\\n\\nInput\\n\\n\\n3\\n3 1 2 3\\n2 1 5\\n3 2 4 6\\n2\\n3 2 3\\n3 2 2\\n\\n\\nOutput\\n\\n\\n2 2 3 \\n\\n\\nInput\\n\\n\\n3\\n3 1 2 3\\n2 1 5\\n3 2 4 6\\n2\\n3 2 3\\n2 2 3\\n\\n\\nOutput\\n\\n\\n1 2 3\\n\\n\\nInput\\n\\n\\n3\\n3 1 2 3\\n2 1 5\\n3 2 4 6\\n2\\n3 2 3\\n2 2 3\\n\\n\\nOutput\\n\\n\\n3 2...\\nSolve the task in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst int maxn = 15, maxm = 100005;\\nint n, m;\\nlong long sum, res;\\nlong long tot[maxm];\\nvector<int> ans, v[maxn], w[maxm];\\nset<vector<int> > s;\\nint main() {\\n  scanf(\\\"%d\\\", &n), ans.resize(n);\\n  for (int i = 1, k, x; i <= n; i++) {\\n    scanf(\\\"%d\\\", &k), v[i].resize(k);\\n    for (int j = 0; j < k; j++) scanf(\\\"%d\\\", &v[i][j]);\\n    sum += v[i][k - 1], ans[i - 1] = k;\\n  }\\n  scanf(\\\"%d\\\", &m);\\n  for (int i = 1; i <= m; i++) {\\n    vector<int> p;\\n    p.clear(), p.resize(n);\\n    for (int j = 0; j < n; j++)\\n      scanf(\\\"%d\\\", &p[j]), tot[i] += v[j + 1][p[j] - 1];\\n    s.insert(p), w[i] = p;\\n  }\\n  if (s.find(ans) != s.end())\\n    for (int i = 1; i <= m; i++) {\\n      vector<int> p = w[i];\\n      for (int j = 1; j <= n; j++)\\n        if (p[j - 1] != 1) {\\n          p[j - 1]--;\\n          if (s.find(p) == s.end()) {\\n            long long now =\\n                tot[i] - v[j][p[j - 1] + 1 - 1] + v[j][p[j - 1] - 1];\\n            if (now > res) ans = p, res = now;\\n          }\\n          p[j - 1]++;\\n        }\\n    }\\n  for (int i = 0; i < n; i++) printf(\\\"%d%c\\\", ans[i], i == n - 1 ? '\\\\n' : ' ');\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"A total of n depots are located on a number line. Depot i lies at the point x_i for 1 \u2264 i \u2264 n.\\n\\nYou are a salesman with n bags of goods, attempting to deliver one bag to each of the n depots. You and the n bags are initially at the origin 0. You can carry up to k bags at a time. You must collect the required number of goods from the origin, deliver them to the respective depots, and then return to the origin to collect your next batch of goods.\\n\\nCalculate the minimum distance you need to cover to deliver all the bags of goods to the depots. You do not have to return to the origin after you have delivered all the bags.\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 10 500). Description of the test cases follows.\\n\\nThe first line of each test case contains two integers n and k (1 \u2264 k \u2264 n \u2264 2 \u22c5 10^5).\\n\\nThe second line of each test case contains n integers x_1, x_2, \u2026, x_n (-10^9 \u2264 x_i \u2264 10^9). It is possible that some depots share the same position.\\n\\nIt is guaranteed that the sum of n over all test cases does not exceed 2 \u22c5 10^5.\\n\\nOutput\\n\\nFor each test case, output a single integer denoting the minimum distance you need to cover to deliver all the bags of goods to the depots. \\n\\nExample\\n\\nInput\\n\\n\\n4\\n5 1\\n1 2 3 4 5\\n9 3\\n-5 -10 -15 6 5 8 3 7 4\\n5 3\\n2 2 3 3 3\\n4 2\\n1000000000 1000000000 1000000000 1000000000\\n\\n\\nOutput\\n\\n\\n25\\n41\\n7\\n3000000000\\n\\nNote\\n\\nIn the first test case, you can carry only one bag at a time. Thus, the following is a solution sequence that gives a minimum travel distance: 0 \u2192 2 \u2192 0 \u2192 4 \u2192 0 \u2192 3 \u2192 0 \u2192 1 \u2192 0 \u2192 5, where each 0 means you go the origin and grab one bag, and each positive integer means you deliver the bag to a depot at this coordinate, giving a total distance of 25 units. It must be noted that there are other sequences that give the same distance.\\n\\nIn the second test case, you can follow the following sequence, among multiple such sequences, to travel minimum distance: 0 \u2192 6 \u2192 8 \u2192 7 \u2192 0 \u2192 5 \u2192 4 \u2192 3 \u2192 0 \u2192 (-5) \u2192 (-10) \u2192 (-15), with distance...\\nThe above is tricky. Write me a correct solution in PYTHON3.\",\"targets\":\"from __future__ import print_function\\nfrom math import *\\nfrom collections import deque\\nimport os\\nimport sys\\nfrom io import BytesIO, IOBase\\n#import time\\n \\ndef main():\\n    pass\\n \\n# region fastio\\n \\nBUFSIZE = 8192\\n \\n \\nclass FastIO(IOBase):\\n    newlines = 0\\n \\n    def __init__(self, file):\\n        self._fd = file.fileno()\\n        self.buffer = BytesIO()\\n        self.writable = \\\"x\\\" in file.mode or \\\"r\\\" not in file.mode\\n        self.write = self.buffer.write if self.writable else None\\n \\n    def read(self):\\n        while True:\\n            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))\\n            if not b:\\n                break\\n            ptr = self.buffer.tell()\\n            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)\\n        self.newlines = 0\\n        return self.buffer.read()\\n \\n    def readline(self):\\n        while self.newlines == 0:\\n            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))\\n            self.newlines = b.count(b\\\"\\\\n\\\") + (not b)\\n            ptr = self.buffer.tell()\\n            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)\\n        self.newlines -= 1\\n        return self.buffer.readline()\\n \\n    def flush(self):\\n        if self.writable:\\n            os.write(self._fd, self.buffer.getvalue())\\n            self.buffer.truncate(0), self.buffer.seek(0)\\n \\n \\nclass IOWrapper(IOBase):\\n    def __init__(self, file):\\n        self.buffer = FastIO(file)\\n        self.flush = self.buffer.flush\\n        self.writable = self.buffer.writable\\n        self.write = lambda s: self.buffer.write(s.encode(\\\"ascii\\\"))\\n        self.read = lambda: self.buffer.read().decode(\\\"ascii\\\")\\n        self.readline = lambda: self.buffer.readline().decode(\\\"ascii\\\")\\n \\n \\nsys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)\\n#sys.stdin, sys.stdout =open(\\\"test.txt\\\",\\\"r\\\"),open(\\\"result.txt\\\",\\\"w\\\")\\n#ini=time.time()\\ninput = lambda: sys.stdin.readline().rstrip(\\\"\\\\r\\\\n\\\")\\nmod=10**9+7\\n############ ---- Input Functions ---- ############\\ndef inp():\\n    return(int(input()))\\ndef...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Alice and Brown are brothers in a family and each receives pocket money in celebration of the coming year. They are very close and share the total amount of the money fifty-fifty. The pocket money each receives is a multiple of 1,000 yen.\\n\\nWrite a program to calculate each one\u2019s share given the amount of money Alice and Brown received.\\n\\n\\n\\nInput\\n\\nThe input is given in the following format.\\n\\n\\na b\\n\\n\\nA line of data is given that contains two values of money: a (1000 \u2264 a \u2264 50000) for Alice and b (1000 \u2264 b \u2264 50000) for Brown.\\n\\nOutput\\n\\nOutput the amount of money each of Alice and Brown receive in a line.\\n\\nExamples\\n\\nInput\\n\\n1000 3000\\n\\n\\nOutput\\n\\n2000\\n\\n\\nInput\\n\\n5000 5000\\n\\n\\nOutput\\n\\n5000\\n\\n\\nInput\\n\\n1000 2000\\n\\n\\nOutput\\n\\n1500\",\"targets\":\"#include <iostream>\\n#include <string>\\n\\nusing namespace std;\\n\\nint main()\\n{\\n\\tint i;\\n\\tint n;\\n\\tint s;\\n\\tcin >> i;\\n\\tcin >> n;\\n\\ts = (i + n)\\/2;\\n\\tcout << s << endl;\\n\\treturn 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You are given two integers n and m. Find the \\\\operatorname{MEX} of the sequence n \u2295 0, n \u2295 1, \u2026, n \u2295 m. Here, \u2295 is the [bitwise XOR operator](https:\\/\\/en.wikipedia.org\\/wiki\\/Bitwise_operation#XOR).\\n\\n\\\\operatorname{MEX} of the sequence of non-negative integers is the smallest non-negative integer that doesn't appear in this sequence. For example, \\\\operatorname{MEX}(0, 1, 2, 4) = 3, and \\\\operatorname{MEX}(1, 2021) = 0. \\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 30 000) \u2014 the number of test cases.\\n\\nThe first and only line of each test case contains two integers n and m (0 \u2264 n, m \u2264 10^9).\\n\\nOutput\\n\\nFor each test case, print a single integer \u2014 the answer to the problem.\\n\\nExample\\n\\nInput\\n\\n\\n5\\n3 5\\n4 6\\n3 2\\n69 696\\n123456 654321\\n\\n\\nOutput\\n\\n\\n4\\n3\\n0\\n640\\n530866\\n\\nNote\\n\\nIn the first test case, the sequence is 3 \u2295 0, 3 \u2295 1, 3 \u2295 2, 3 \u2295 3, 3 \u2295 4, 3 \u2295 5, or 3, 2, 1, 0, 7, 6. The smallest non-negative integer which isn't present in the sequence i. e. the \\\\operatorname{MEX} of the sequence is 4.\\n\\nIn the second test case, the sequence is 4 \u2295 0, 4 \u2295 1, 4 \u2295 2, 4 \u2295 3, 4 \u2295 4, 4 \u2295 5, 4 \u2295 6, or 4, 5, 6, 7, 0, 1, 2. The smallest non-negative integer which isn't present in the sequence i. e. the \\\\operatorname{MEX} of the sequence is 3.\\n\\nIn the third test case, the sequence is 3 \u2295 0, 3 \u2295 1, 3 \u2295 2, or 3, 2, 1. The smallest non-negative integer which isn't present in the sequence i. e. the \\\\operatorname{MEX} of the sequence is 0.\\nSolve the task in PYTHON3.\",\"targets\":\"#!\\/usr\\/bin\\/env python3\\n\\ndef msb(x):\\n\\ti = 0\\n\\tp = 1\\n\\t\\n\\tassert x != 0\\n\\n\\twhile (p < x):\\n\\t\\ti += 1\\n\\t\\tp = p << 1\\n\\n\\treturn i\\n\\ndef solve():\\n\\tn, m = map(int, input().split(\\\" \\\"))\\n\\tM = m + 1\\n\\n\\tmex = 0\\n\\tfor bit in range(29, -1, -1):\\n\\t\\tl_bit = ((n >> bit) & 1) > 0\\n\\t\\tr_bit = ((M >> bit) & 1) > 0\\n\\t\\t\\n\\t\\tset_this_bit = False\\n\\t\\tif r_bit and (not l_bit):\\n\\t\\t\\tset_this_bit = True\\n\\t\\telif l_bit and not r_bit:\\n\\t\\t\\treturn mex\\n\\n\\t\\tif set_this_bit:\\n\\t\\t\\tmex = mex | 1 << bit\\n\\n\\treturn mex\\n\\ndef main():\\n\\tt = int(input())\\n\\tfor tt in range(t):\\n\\t\\tprint(solve())\\n\\nmain()\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"<image>\\n\\nInput\\n\\nThe first line of the input is a string (between 1 and 50 characters long, inclusive). Each character will be a letter of English alphabet, lowercase or uppercase.\\n\\nThe second line of the input is an integer between 0 and 26, inclusive.\\n\\nOutput\\n\\nOutput the required string.\\n\\nExamples\\n\\nInput\\n\\nAprilFool\\n14\\n\\n\\nOutput\\n\\nAprILFooL\\nThe above is tricky. Write me a correct solution in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint main() {\\n  string str_27;\\n  getline(cin, str_27);\\n  int i16;\\n  cin >> i16;\\n  string res = \\\"\\\";\\n  for (int i26 = 0; i26 < str_27.size(); i26++) {\\n    char c19 = tolower(str_27[i26]);\\n    if (c19 < i16 + 97) {\\n      res.push_back(toupper(c19));\\n    } else {\\n      res.push_back(tolower(c19));\\n    }\\n  }\\n  cout << res;\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in PYTHON3?\\nYou are given a string s, consisting of n letters, each letter is either 'a' or 'b'. The letters in the string are numbered from 1 to n.\\n\\ns[l; r] is a continuous substring of letters from index l to r of the string inclusive. \\n\\nA string is called balanced if the number of letters 'a' in it is equal to the number of letters 'b'. For example, strings \\\"baba\\\" and \\\"aabbab\\\" are balanced and strings \\\"aaab\\\" and \\\"b\\\" are not.\\n\\nFind any non-empty balanced substring s[l; r] of string s. Print its l and r (1 \u2264 l \u2264 r \u2264 n). If there is no such substring, then print -1 -1.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 1000) \u2014 the number of testcases.\\n\\nThen the descriptions of t testcases follow.\\n\\nThe first line of the testcase contains a single integer n (1 \u2264 n \u2264 50) \u2014 the length of the string.\\n\\nThe second line of the testcase contains a string s, consisting of n letters, each letter is either 'a' or 'b'.\\n\\nOutput\\n\\nFor each testcase print two integers. If there exists a non-empty balanced substring s[l; r], then print l r (1 \u2264 l \u2264 r \u2264 n). Otherwise, print -1 -1.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n1\\na\\n6\\nabbaba\\n6\\nabbaba\\n9\\nbabbabbaa\\n\\n\\nOutput\\n\\n\\n-1 -1\\n1 6\\n3 6\\n2 5\\n\\nNote\\n\\nIn the first testcase there are no non-empty balanced subtrings.\\n\\nIn the second and third testcases there are multiple balanced substrings, including the entire string \\\"abbaba\\\" and substring \\\"baba\\\".\",\"targets\":\"t=int(input())\\nfor _ in range(t):\\n    n=int(input())\\n    s=input()\\n    flag=False\\n    if(n==1):\\n        flag=True\\n        print('-1 -1')\\n    else:\\n        for i in range(len(s)-1):\\n                if(s[i]!=s[i+1]):\\n                    flag=True\\n                    print(str(i+1)+' '+str(i+2))\\n                    break\\n    if(flag==False):\\n        print('-1 -1')\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Alice gave Bob two integers a and b (a > 0 and b \u2265 0). Being a curious boy, Bob wrote down an array of non-negative integers with \\\\operatorname{MEX} value of all elements equal to a and \\\\operatorname{XOR} value of all elements equal to b.\\n\\nWhat is the shortest possible length of the array Bob wrote?\\n\\nRecall that the \\\\operatorname{MEX} (Minimum EXcluded) of an array is the minimum non-negative integer that does not belong to the array and the \\\\operatorname{XOR} of an array is the [bitwise XOR](https:\\/\\/en.wikipedia.org\\/wiki\\/Bitwise_operation#XOR) of all the elements of the array.\\n\\nInput\\n\\nThe input consists of multiple test cases. The first line contains an integer t (1 \u2264 t \u2264 5 \u22c5 10^4) \u2014 the number of test cases. The description of the test cases follows.\\n\\nThe only line of each test case contains two integers a and b (1 \u2264 a \u2264 3 \u22c5 10^5; 0 \u2264 b \u2264 3 \u22c5 10^5) \u2014 the \\\\operatorname{MEX} and \\\\operatorname{XOR} of the array, respectively.\\n\\nOutput\\n\\nFor each test case, output one (positive) integer \u2014 the length of the shortest array with \\\\operatorname{MEX} a and \\\\operatorname{XOR} b. We can show that such an array always exists.\\n\\nExample\\n\\nInput\\n\\n\\n5\\n1 1\\n2 1\\n2 0\\n1 10000\\n2 10000\\n\\n\\nOutput\\n\\n\\n3\\n2\\n3\\n2\\n3\\n\\nNote\\n\\nIn the first test case, one of the shortest arrays with \\\\operatorname{MEX} 1 and \\\\operatorname{XOR} 1 is [0, 2020, 2021].\\n\\nIn the second test case, one of the shortest arrays with \\\\operatorname{MEX} 2 and \\\\operatorname{XOR} 1 is [0, 1].\\n\\nIt can be shown that these arrays are the shortest arrays possible.\\nSolve the task in PYTHON3.\",\"targets\":\"import sys\\nimport math\\nfrom bisect import bisect_left\\nimport heapq\\nfrom collections import deque\\nfrom itertools import product, permutations\\nimport random\\ndef II():\\n\\treturn int(sys.stdin.readline())\\n \\ndef LI():\\n\\treturn list(map(int, sys.stdin.readline().split()))\\n \\ndef MI():\\n\\treturn map(int, sys.stdin.readline().split())\\n \\ndef SI():\\n\\treturn sys.stdin.readline().strip()\\n \\ndef C(n, k, mod):\\n    return (FACT(n,mod) * pow((FACT(k,mod)*FACT(n-k,mod))%mod,mod-2, mod))%mod\\n \\ndef lcm(a,b):\\n    return abs(a*b) \\/\\/ math.gcd(a, b)\\n\\nx = []\\nxor = 0\\nfor i in range(10**6):\\n\\txor^=i\\n\\tx.append(xor)\\n \\nfor _ in range(II()):\\n\\ta,b = MI()\\n\\txor = x[a-1]\\n\\tif xor == b:\\n\\t\\tprint(a)\\n\\telif xor^b == a:\\n\\t\\tprint(a+2)\\n\\telse:\\n\\t\\tprint(a+1)\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in PYTHON3?\\nA chess tournament will be held soon, where n chess players will take part. Every participant will play one game against every other participant. Each game ends in either a win for one player and a loss for another player, or a draw for both players.\\n\\nEach of the players has their own expectations about the tournament, they can be one of two types:\\n\\n  1. a player wants not to lose any game (i. e. finish the tournament with zero losses); \\n  2. a player wants to win at least one game. \\n\\n\\n\\nYou have to determine if there exists an outcome for all the matches such that all the players meet their expectations. If there are several possible outcomes, print any of them. If there are none, report that it's impossible.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 200) \u2014 the number of test cases.\\n\\nThe first line of each test case contains one integer n (2 \u2264 n \u2264 50) \u2014 the number of chess players.\\n\\nThe second line contains the string s (|s| = n; s_i \u2208 \\\\{1, 2\\\\}). If s_i = 1, then the i-th player has expectations of the first type, otherwise of the second type.\\n\\nOutput\\n\\nFor each test case, print the answer in the following format:\\n\\nIn the first line, print NO if it is impossible to meet the expectations of all players.\\n\\nOtherwise, print YES, and the matrix of size n \u00d7 n in the next n lines.\\n\\nThe matrix element in the i-th row and j-th column should be equal to:\\n\\n  * +, if the i-th player won in a game against the j-th player; \\n  * -, if the i-th player lost in a game against the j-th player; \\n  * =, if the i-th and j-th players' game resulted in a draw; \\n  * X, if i = j. \\n\\nExample\\n\\nInput\\n\\n\\n3\\n3\\n111\\n2\\n21\\n4\\n2122\\n\\n\\nOutput\\n\\n\\nYES\\nX==\\n=X=\\n==X\\nNO\\nYES\\nX--+\\n+X++\\n+-X-\\n--+X\",\"targets\":\"# <editor-fold desc=\\\"imports\\\">\\nfrom os import path\\nfrom sys import stdin, stdout\\nif path.exists('tc.txt'):\\n    stdin = open('tc.txt', 'r')\\nfrom collections import defaultdict\\ndef gmi(): return map(int, stdin.readline().strip().split())\\ndef gms(): return map(str, stdin.readline().strip().split())\\ndef gari(): return list(map(int, stdin.readline().strip().split()))\\ndef gart(): return tuple(map(int, stdin.readline().strip().split()))\\ndef gars(): return list(map(str, stdin.readline().strip().split()))\\ndef gs(): return stdin.readline().strip()\\ndef gls(): return list(stdin.readline().strip())\\ndef gi(): return int(stdin.readline())\\n# <\\/editor-fold>\\n\\n\\ndef solve():\\n    n, s = gi(), gs()\\n    mat = [['X']*n for _ in range(n)]\\n\\n    for i in range(n):\\n        si = s[i] == '1'\\n        already = False\\n        for j in range(i+1, n):\\n            sj = s[j] == '1'\\n            if si and sj: mat[i][j] = mat[j][i] = '='\\n            elif si or sj: mat[i][j] = mat[j][i] = '='\\n            else:\\n                if not already:\\n                    mat[i][j], mat[j][i] = '+', '-'\\n                    already = True\\n                else:\\n                    mat[i][j], mat[j][i] = '-', '+'\\n\\n    check = []\\n    for i in range(n):\\n        if s[i] == '1':\\n            check.append(False if '-' in mat[i] else True)\\n        else:\\n            check.append(True if '+' in mat[i] else False)\\n\\n    if all(check):\\n        print(\\\"YES\\\")\\n        for i in mat: print(\\\"\\\".join(i))\\n    else:\\n        print(\\\"NO\\\")\\n\\n\\n# <editor-fold desc=\\\"Main\\\">\\ntc = gi()\\nwhile tc:\\n    tc -= 1\\n    solve()\\n# <\\/editor-fold>\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Example\\n\\nInput\\n\\n6 3\\n1 0 0 1 0 1\\n1 3 2\\n\\n\\nOutput\\n\\n1\\nThe above is tricky. Write me a correct solution in CPP.\",\"targets\":\"#define _USE_MATH_DEFINES\\n\\n#include <cstdio>\\n#include <cstdlib>\\n#include <iostream>\\n#include <cmath>\\n#include <algorithm>\\n#include <vector>\\n#include <queue>\\n#include <map>\\n#include <list>\\n\\nusing namespace std;\\n\\ntypedef pair<long long int, long long int> P;\\n\\nlong long int INF = 1e18;\\nlong long int MOD = 1e9 + 7;\\n\\nlong long int cnt[100000];\\n\\nint main(){\\n\\t\\n\\tint N, M;\\n\\tcin >> N >> M;\\n\\t\\n\\tint num = 0;\\n\\t\\n\\tfor(int i = 0; i < N; i++){\\n\\t\\tint p;\\n\\t\\tcin >> p;\\n\\t\\tnum *= 2;\\n\\t\\tnum += p;\\n\\t}\\n\\tqueue<int> que;\\n\\tque.push(num);\\n\\t\\n\\tfor(int i = 0; i < (1 << N); i++){\\n\\t\\tcnt[i] = INF;\\n\\t}\\n\\t\\n\\tfor(int loop = 0; loop < (1 << N); loop++){\\n\\t\\tint sz = que.size();\\n\\t\\tif(sz == 0){\\n\\t\\t\\tbreak;\\n\\t\\t}\\n\\t\\tfor(int i = 0; i < sz; i++){\\n\\t\\t\\tnum = que.front();\\n\\t\\t\\tque.pop();\\n\\t\\t\\tif(cnt[num] != INF){\\n\\t\\t\\t\\tcontinue;\\n\\t\\t\\t}\\n\\t\\t\\tcnt[num] = loop;\\n\\t\\t\\tfor(int j = 0; j < N - 1; j++){\\n\\t\\t\\t\\tint d1 = (num & (1 << j));\\n\\t\\t\\t\\tint d2 = (num & (1 << (j + 1)));\\n\\t\\t\\t\\tque.push(num + d1 - d2 \\/ 2);\\n\\t\\t\\t}\\n\\t\\t}\\n\\t}\\n\\t\\n\\tnum = 0;\\n\\tint bin = 0;\\n\\tfor(int i = 0; i < M; i++){\\n\\t\\tint p;\\n\\t\\tcin >> p;\\n\\t\\tfor(int j = 0; j < p; j++){\\n\\t\\t\\tnum *= 2;\\n\\t\\t\\tnum += bin;\\n\\t\\t}\\n\\t\\tbin++;\\n\\t\\tbin %= 2;\\n\\t}\\n\\t\\n\\tlong long int ans = cnt[num];\\n\\t\\n\\tfor(int i = 0; i < N; i++){\\n\\t\\tif(num & (1 << i)){\\n\\t\\t\\tnum -= (1 << i);\\n\\t\\t}else{\\n\\t\\t\\tnum += (1 << i);\\n\\t\\t}\\n\\t}\\n\\t\\n\\tcout << min(ans, cnt[num]) << endl;\\n\\t\\n\\treturn 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Two players, Red and Blue, are at it again, and this time they're playing with crayons! The mischievous duo is now vandalizing a rooted tree, by coloring the nodes while playing their favorite game.\\n\\nThe game works as follows: there is a tree of size n, rooted at node 1, where each node is initially white. Red and Blue get one turn each. Red goes first. \\n\\nIn Red's turn, he can do the following operation any number of times: \\n\\n  * Pick any subtree of the rooted tree, and color every node in the subtree red. \\n\\nHowever, to make the game fair, Red is only allowed to color k nodes of the tree. In other words, after Red's turn, at most k of the nodes can be colored red.\\n\\nThen, it's Blue's turn. Blue can do the following operation any number of times: \\n\\n  * Pick any subtree of the rooted tree, and color every node in the subtree blue. However, he's not allowed to choose a subtree that contains a node already colored red, as that would make the node purple and no one likes purple crayon. \\n\\nNote: there's no restriction on the number of nodes Blue can color, as long as he doesn't color a node that Red has already colored.\\n\\nAfter the two turns, the score of the game is determined as follows: let w be the number of white nodes, r be the number of red nodes, and b be the number of blue nodes. The score of the game is w \u22c5 (r - b).\\n\\nRed wants to maximize this score, and Blue wants to minimize it. If both players play optimally, what will the final score of the game be?\\n\\nInput\\n\\nThe first line contains two integers n and k (2 \u2264 n \u2264 2 \u22c5 10^5; 1 \u2264 k \u2264 n) \u2014 the number of vertices in the tree and the maximum number of red nodes.\\n\\nNext n - 1 lines contains description of edges. The i-th line contains two space separated integers u_i and v_i (1 \u2264 u_i, v_i \u2264 n; u_i \u2260 v_i) \u2014 the i-th edge of the tree.\\n\\nIt's guaranteed that given edges form a tree.\\n\\nOutput\\n\\nPrint one integer \u2014 the resulting score if both Red and Blue play optimally.\\n\\nExamples\\n\\nInput\\n\\n\\n4 2\\n1 2\\n1 3\\n1 4\\n\\n\\nOutput\\n\\n\\n1\\n\\n\\nInput\\n\\n\\n5 2\\n1 2\\n2 3\\n3 4\\n4 5\\n\\n\\nOutput\\n\\n\\n6\\n\\n\\nInput\\n\\n\\n7...\\nUsing cpp can you solve the prior task?\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint n, k, dfn[200011], rk[200011], dep[200011], siz[200011], fa[200011], clk;\\nlong long ans = -1e18;\\nbool vis[200011];\\nstruct edge {\\n  int v, next;\\n  edge() {}\\n  edge(int _v, int _next) {\\n    v = _v;\\n    next = _next;\\n  }\\n} e[400011];\\nint head[200011], sz;\\nvoid init() {\\n  memset(head, -1, sizeof(head));\\n  sz = 0;\\n}\\nvoid insert(int u, int v) {\\n  e[++sz] = edge(v, head[u]);\\n  head[u] = sz;\\n}\\nstruct node {\\n  int l, r, mx, id, tag;\\n  node() {\\n    mx = -1e9;\\n    id = 0;\\n    tag = 0;\\n  }\\n} tree[800011];\\nnode merge(node a, node b) {\\n  node c;\\n  c.l = a.l;\\n  c.r = b.r;\\n  c.mx = max(a.mx, b.mx);\\n  if (c.mx == a.mx)\\n    c.id = a.id;\\n  else\\n    c.id = b.id;\\n  return c;\\n}\\nvoid pushup(int x) { tree[x] = merge(tree[(x << 1)], tree[(x << 1 | 1)]); }\\nvoid apply(int x, int p) {\\n  tree[x].tag += p;\\n  tree[x].mx += p;\\n}\\nvoid pushdown(int x) {\\n  if (tree[x].tag)\\n    apply((x << 1), tree[x].tag), apply((x << 1 | 1), tree[x].tag),\\n        tree[x].tag = 0;\\n}\\nvoid build(int l, int r, int x) {\\n  tree[x].l = l;\\n  tree[x].r = r;\\n  if (l == r) {\\n    tree[x].mx = dep[rk[l]];\\n    tree[x].id = l;\\n    return;\\n  }\\n  build(l, l + r >> 1, (x << 1));\\n  build((l + r >> 1) + 1, r, (x << 1 | 1));\\n  pushup(x);\\n}\\nvoid add(int l, int r, int p, int x) {\\n  if (l <= tree[x].l && tree[x].r <= r) {\\n    apply(x, p);\\n    return;\\n  }\\n  pushdown(x);\\n  if (l <= tree[x].l + tree[x].r >> 1) add(l, r, p, (x << 1));\\n  if (r > tree[x].l + tree[x].r >> 1) add(l, r, p, (x << 1 | 1));\\n  pushup(x);\\n}\\nvoid dfs(int u, int f) {\\n  siz[u] = 1;\\n  dfn[u] = ++clk;\\n  rk[clk] = u;\\n  fa[u] = f;\\n  dep[u] = dep[f] + 1;\\n  for (int i = head[u]; ~i; i = e[i].next)\\n    if (e[i].v ^ f) dfs(e[i].v, u), siz[u] += siz[e[i].v];\\n}\\nint main() {\\n  scanf(\\\"%d%d\\\", &n, &k);\\n  init();\\n  for (int i = 1; i < n; ++i) {\\n    int u, v;\\n    scanf(\\\"%d%d\\\", &u, &v);\\n    insert(u, v);\\n    insert(v, u);\\n  }\\n  dfs(1, 0);\\n  ans = max(ans, -1ll * (n \\/ 2) * (n - n \\/ 2));\\n  int cnt = n;\\n  build(1, n, 1);\\n  for (int i = 1; i <= k; ++i) {\\n    int x = rk[tree[1].id];\\n   ...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Given n, find any array a_1, a_2, \u2026, a_n of integers such that all of the following conditions hold: \\n\\n  * 1 \u2264 a_i \u2264 10^9 for every i from 1 to n.\\n\\n  * a_1 < a_2 < \u2026 <a_n\\n\\n  * For every i from 2 to n, a_i isn't divisible by a_{i-1}\\n\\n\\n\\n\\nIt can be shown that such an array always exists under the constraints of the problem.\\n\\nInput\\n\\nThe first line contains the number of test cases t (1 \u2264 t \u2264 100). Description of the test cases follows.\\n\\nThe only line of each test case contains a single integer n (1 \u2264 n \u2264 1000).\\n\\nIt is guaranteed that the sum of n over all test cases does not exceed 10^4.\\n\\nOutput\\n\\nFor each test case print n integers a_1, a_2, \u2026, a_n \u2014 the array you found. If there are multiple arrays satisfying all the conditions, print any of them.\\n\\nExample\\n\\nInput\\n\\n\\n3\\n1\\n2\\n7\\n\\n\\nOutput\\n\\n\\n1\\n2 3\\n111 1111 11111 111111 1111111 11111111 111111111\\n\\nNote\\n\\nIn the first test case, array [1] satisfies all the conditions.\\n\\nIn the second test case, array [2, 3] satisfies all the conditions, as 2<3 and 3 is not divisible by 2.\\n\\nIn the third test case, array [111, 1111, 11111, 111111, 1111111, 11111111, 111111111] satisfies all the conditions, as it's increasing and a_i isn't divisible by a_{i-1} for any i from 2 to 7.\\n#incl\",\"targets\":\"ude <bits\\/stdc++.h>\\nusing namespace std;\\nconst long long mod = 1e9 + 7;\\nusing ii = pair<long long, long long>;\\nlong long power(long long x, long long y) {\\n  long long res = 1;\\n  while (y) {\\n    if (y & 1) res = (res * x) % mod;\\n    y = y \\/ 2, x = (x * x) % mod;\\n  }\\n  return res % mod;\\n}\\nvoid solve() {\\n  long long n;\\n  cin >> n;\\n  for (long long i = 2; i <= n + 1; i++) {\\n    cout << i << \\\" \\\";\\n  }\\n  cout << \\\"\\\\n\\\";\\n}\\nsigned main() {\\n  ios_base::sync_with_stdio(0);\\n  cin.tie(0);\\n  cout.tie(0);\\n  int t;\\n  cin >> t;\\n  while (t--) {\\n    solve();\\n  }\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"When you play the game of thrones, you win, or you die. There is no middle ground.\\n\\nCersei Lannister, A Game of Thrones by George R. R. Martin\\n\\nThere are n nobles, numbered from 1 to n. Noble i has a power of i. There are also m \\\"friendships\\\". A friendship between nobles a and b is always mutual.\\n\\nA noble is defined to be vulnerable if both of the following conditions are satisfied: \\n\\n  * the noble has at least one friend, and \\n  * all of that noble's friends have a higher power. \\n\\n\\n\\nYou will have to process the following three types of queries. \\n\\n  1. Add a friendship between nobles u and v. \\n  2. Remove a friendship between nobles u and v. \\n  3. Calculate the answer to the following process. \\n\\n\\n\\nThe process: all vulnerable nobles are simultaneously killed, and all their friendships end. Then, it is possible that new nobles become vulnerable. The process repeats itself until no nobles are vulnerable. It can be proven that the process will end in finite time. After the process is complete, you need to calculate the number of remaining nobles.\\n\\nNote that the results of the process are not carried over between queries, that is, every process starts with all nobles being alive!\\n\\nInput\\n\\nThe first line contains the integers n and m (1 \u2264 n \u2264 2\u22c5 10^5, 0 \u2264 m \u2264 2\u22c5 10^5) \u2014 the number of nobles and number of original friendships respectively.\\n\\nThe next m lines each contain the integers u and v (1 \u2264 u,v \u2264 n, u \u2260 v), describing a friendship. No friendship is listed twice.\\n\\nThe next line contains the integer q (1 \u2264 q \u2264 2\u22c5 {10}^{5}) \u2014 the number of queries. \\n\\nThe next q lines contain the queries themselves, each query has one of the following three formats. \\n\\n  * 1 u v (1 \u2264 u,v \u2264 n, u \u2260 v) \u2014 add a friendship between u and v. It is guaranteed that u and v are not friends at this moment. \\n  * 2 u v (1 \u2264 u,v \u2264 n, u \u2260 v) \u2014 remove a friendship between u and v. It is guaranteed that u and v are friends at this moment. \\n  * 3 \u2014 print the answer to the process described in the statement. \\n\\nOutput\\n\\nFor each type 3 query print one...\\n#incl\",\"targets\":\"ude <bits\\/stdc++.h>\\nusing namespace std;\\nusing ll = long long;\\nconst int MXN = 2e5;\\nint curans;\\nvector<set<int> > adj(MXN);\\nint g[MXN];\\nint main() {\\n  int n, m;\\n  cin >> n >> m;\\n  curans = n;\\n  for (int x = 0; x < m; x++) {\\n    int a, b;\\n    cin >> a >> b;\\n    --a;\\n    --b;\\n    adj[a].insert(b);\\n    adj[b].insert(a);\\n    ++g[min(a, b)];\\n    if (g[min(a, b)] == 1) --curans;\\n  }\\n  int q;\\n  cin >> q;\\n  while (q--) {\\n    int qt;\\n    cin >> qt;\\n    if (qt == 1) {\\n      int a, b;\\n      cin >> a >> b;\\n      --a;\\n      --b;\\n      adj[a].insert(b);\\n      adj[b].insert(a);\\n      ++g[min(a, b)];\\n      if (g[min(a, b)] == 1) --curans;\\n    } else if (qt == 2) {\\n      int a, b;\\n      cin >> a >> b;\\n      --a;\\n      --b;\\n      adj[a].erase(b);\\n      adj[b].erase(a);\\n      --g[min(a, b)];\\n      if (g[min(a, b)] == 0) ++curans;\\n    } else {\\n      cout << curans << endl;\\n    }\\n  }\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"A few years ago, Hitagi encountered a giant crab, who stole the whole of her body weight. Ever since, she tried to avoid contact with others, for fear that this secret might be noticed.\\n\\nTo get rid of the oddity and recover her weight, a special integer sequence is needed. Hitagi's sequence has been broken for a long time, but now Kaiki provides an opportunity.\\n\\nHitagi's sequence a has a length of n. Lost elements in it are denoted by zeros. Kaiki provides another sequence b, whose length k equals the number of lost elements in a (i.e. the number of zeros). Hitagi is to replace each zero in a with an element from b so that each element in b should be used exactly once. Hitagi knows, however, that, apart from 0, no integer occurs in a and b more than once in total.\\n\\nIf the resulting sequence is not an increasing sequence, then it has the power to recover Hitagi from the oddity. You are to determine whether this is possible, or Kaiki's sequence is just another fake. In other words, you should detect whether it is possible to replace each zero in a with an integer from b so that each integer from b is used exactly once, and the resulting sequence is not increasing.\\n\\nInput\\n\\nThe first line of input contains two space-separated positive integers n (2 \u2264 n \u2264 100) and k (1 \u2264 k \u2264 n) \u2014 the lengths of sequence a and b respectively.\\n\\nThe second line contains n space-separated integers a1, a2, ..., an (0 \u2264 ai \u2264 200) \u2014 Hitagi's broken sequence with exactly k zero elements.\\n\\nThe third line contains k space-separated integers b1, b2, ..., bk (1 \u2264 bi \u2264 200) \u2014 the elements to fill into Hitagi's sequence.\\n\\nInput guarantees that apart from 0, no integer occurs in a and b more than once in total.\\n\\nOutput\\n\\nOutput \\\"Yes\\\" if it's possible to replace zeros in a with elements in b and make the resulting sequence not increasing, and \\\"No\\\" otherwise.\\n\\nExamples\\n\\nInput\\n\\n4 2\\n11 0 0 14\\n5 4\\n\\n\\nOutput\\n\\nYes\\n\\n\\nInput\\n\\n6 1\\n2 3 0 8 9 10\\n5\\n\\n\\nOutput\\n\\nNo\\n\\n\\nInput\\n\\n4 1\\n8 94 0 4\\n89\\n\\n\\nOutput\\n\\nYes\\n\\n\\nInput\\n\\n7 7\\n0 0 0 0 0 0 0\\n1 2 3 4 5 6...\\nSolve the task in JAVA.\",\"targets\":\"import java.util.*;\\nimport java.io.*;\\n\\npublic class CF418A {\\n\\tpublic static void main(String args[]) {\\n\\t\\tInputReader in = new InputReader(System.in);\\n\\t\\tOutputStream outputStream = System.out;\\n\\t\\tPrintWriter out = new PrintWriter(outputStream);\\n\\t\\t\\/*------------------------------My Code starts here------------------------------*\\/\\n\\t\\tint n=in.nextInt(),k=in.nextInt(),i;\\n\\t\\tint[] a=nextIntArray(in, n);\\n\\t\\tint[] b=nextIntArray(in, k);\\n\\t\\tif(k>1)\\n\\t\\t{\\n\\t\\t\\tout.println(\\\"Yes\\\");\\n\\t\\t\\tout.close();\\n\\t\\t\\treturn ;\\n\\t\\t}\\n\\t\\tfor(i=0;i<n;i++)\\n\\t\\t{\\n\\t\\t\\tif(a[i]==0)\\n\\t\\t\\t\\ta[i]=b[0];\\n\\t\\t}\\n\\t\\tboolean ans=true;\\n\\t\\ti=1;\\n\\t\\twhile(i<n)\\n\\t\\t{\\n\\t\\t\\tif(a[i-1]>a[i])\\n\\t\\t\\t\\tans=false;\\n\\t\\t\\ti++;\\n\\t\\t}\\n\\t\\tif(ans)\\n\\t\\t\\tout.println(\\\"No\\\");\\n\\t\\telse\\n\\t\\t\\tout.println(\\\"Yes\\\");\\n\\t\\tout.close();\\n\\t\\t\\/*------------------------------The End------------------------------------------*\\/\\n\\t}\\n\\n\\tpublic static final long l = (int) (1e9 + 7);\\n\\n\\tprivate static int[] nextIntArray(InputReader in, int n) {\\n\\t\\tint[] a = new int[n];\\n\\t\\tfor (int i = 0; i < n; i++)\\n\\t\\t\\ta[i] = in.nextInt();\\n\\t\\treturn a;\\n\\t}\\n\\n\\tprivate static long[] nextLongArray(InputReader in, int n) {\\n\\t\\tlong[] a = new long[n];\\n\\t\\tfor (int i = 0; i < n; i++)\\n\\t\\t\\ta[i] = in.nextLong();\\n\\t\\treturn a;\\n\\t}\\n\\n\\tprivate static int[][] nextIntMatrix(InputReader in, int n, int m) {\\n\\t\\tint[][] a = new int[n][m];\\n\\t\\tfor (int i = 0; i < n; i++) {\\n\\t\\t\\tfor (int j = 0; j < m; j++)\\n\\t\\t\\t\\ta[i][j] = in.nextInt();\\n\\t\\t}\\n\\t\\treturn a;\\n\\t}\\n\\n\\tprivate static void show(int[] a) {\\n\\t\\tfor (int i = 0; i < a.length; i++)\\n\\t\\t\\tSystem.out.print(a[i] + \\\" \\\");\\n\\t\\tSystem.out.println();\\n\\t}\\n\\n\\tprivate static void show2DArray(char[][] a) {\\n\\t\\tfor (int i = 0; i < a.length; i++) {\\n\\t\\t\\tfor (int j = 0; j < a[0].length; j++)\\n\\t\\t\\t\\tSystem.out.print(a[i][j]);\\n\\t\\t\\tSystem.out.println();\\n\\t\\t}\\n\\t}\\n\\n\\tstatic class Pair {\\n\\t\\tprivate int first;\\n\\t\\tprivate int second;\\n\\n\\t\\tpublic Pair(int i, int j) {\\n\\t\\t\\tthis.first = i;\\n\\t\\t\\tthis.second = j;\\n\\t\\t}\\n\\n\\t\\tpublic int getFirst() {\\n\\t\\t\\treturn first;\\n\\t\\t}\\n\\n\\t\\tpublic int getSecond() {\\n\\t\\t\\treturn second;\\n\\t\\t}\\n\\n\\t\\tpublic void setFirst(int k) {\\n\\t\\t\\tthis.first = k;\\n\\t\\t}\\n\\n\\t\\tpublic void setSecond(int k)...\",\"language\":\"python\",\"split\":\"train\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in JAVA?\\nThe problem statement looms below, filling you with determination.\\n\\nConsider a grid in which some cells are empty and some cells are filled. Call a cell in this grid exitable if, starting at that cell, you can exit the grid by moving up and left through only empty cells. This includes the cell itself, so all filled in cells are not exitable. Note that you can exit the grid from any leftmost empty cell (cell in the first column) by going left, and from any topmost empty cell (cell in the first row) by going up.\\n\\nLet's call a grid determinable if, given only which cells are exitable, we can exactly determine which cells are filled in and which aren't.\\n\\nYou are given a grid a of dimensions n \u00d7 m , i. e. a grid with n rows and m columns. You need to answer q queries (1 \u2264 q \u2264 2 \u22c5 10^5). Each query gives two integers x_1, x_2 (1 \u2264 x_1 \u2264 x_2 \u2264 m) and asks whether the subgrid of a consisting of the columns x_1, x_1 + 1, \u2026, x_2 - 1, x_2 is determinable.\\n\\nInput\\n\\nThe first line contains two integers n, m (1 \u2264 n, m \u2264 10^6, nm \u2264 10^6) \u2014 the dimensions of the grid a.\\n\\nn lines follow. The y-th line contains m characters, the x-th of which is 'X' if the cell on the intersection of the the y-th row and x-th column is filled and \\\".\\\" if it is empty.\\n\\nThe next line contains a single integer q (1 \u2264 q \u2264 2 \u22c5 10^5) \u2014 the number of queries.\\n\\nq lines follow. Each line contains two integers x_1 and x_2 (1 \u2264 x_1 \u2264 x_2 \u2264 m), representing a query asking whether the subgrid of a containing the columns x_1, x_1 + 1, \u2026, x_2 - 1, x_2 is determinable.\\n\\nOutput\\n\\nFor each query, output one line containing \\\"YES\\\" if the subgrid specified by the query is determinable and \\\"NO\\\" otherwise. The output is case insensitive (so \\\"yEs\\\" and \\\"No\\\" will also be accepted).\\n\\nExample\\n\\nInput\\n\\n\\n4 5\\n..XXX\\n...X.\\n...X.\\n...X.\\n5\\n1 3\\n3 3\\n4 5\\n5 5\\n1 5\\n\\n\\nOutput\\n\\n\\nYES\\nYES\\nNO\\nYES\\nNO\\n\\nNote\\n\\nFor each query of the example, the corresponding subgrid is displayed twice below: first in its input format, then with each cell marked as \\\"E\\\" if it is exitable and \\\"N\\\" otherwise.\\n\\nFor the...\",\"targets\":\"\\/\\/Praise our lord and saviour qlf9\\n\\/\\/DecimalFormat f = new DecimalFormat(\\\"##.00\\\");\\n\\nimport java.util.*;\\nimport java.io.*;\\nimport java.math.*;\\nimport java.text.*;\\npublic class CCorrect{\\npublic static void main(String[] omkar) throws Exception\\n{\\n   BufferedReader in = new BufferedReader(new InputStreamReader(System.in));\\n   StringTokenizer st = new StringTokenizer(in.readLine());\\n   StringBuilder sb = new StringBuilder();\\n   int n = Integer.parseInt(st.nextToken());\\n   int m = Integer.parseInt(st.nextToken());\\n   int[][] grid = new int[n][m];\\n   String s;\\n   char cc;\\n   for(int i = 0; i < n; i++)\\n   {\\n      s = in.readLine();\\n      for(int j = 0; j < m; j++)\\n      {\\n         if(s.charAt(j) == 'X')\\n         {\\n            grid[i][j] = 1;\\n         }\\n         else\\n         {\\n            grid[i][j] = 0;\\n         }\\n      }\\n   }\\n   int[] numBad = new int[m+1]; \\n   int total = 0;\\n   for(int j = 0; j < m-1; j++)\\n   {\\n      for(int i = 1; i< n; i++)\\n      {\\n         if(grid[i][j] == 1 && grid[i-1][j+1] == 1)\\n         {\\n            total++;\\n         }\\n      }\\n      numBad[j+1] = total;\\n   } \\n   numBad[m] = total;\\n   int q = Integer.parseInt(in.readLine());\\n   int a, b;\\n   for(int i = 0; i < q; i++)\\n   {\\n      st = new StringTokenizer(in.readLine());\\n      a = Integer.parseInt(st.nextToken())-1;\\n      b = Integer.parseInt(st.nextToken())-1;\\n      if(numBad[b]-numBad[a] == 0)\\n      {\\n         sb.append(\\\"yes\\\\n\\\");\\n      }\\n      else\\n      {\\n         sb.append(\\\"no\\\\n\\\");\\n      }\\n   }\\n   System.out.println(sb);\\n        }\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Monocarp is the coach of the Berland State University programming teams. He decided to compose a problemset for a training session for his teams.\\n\\nMonocarp has n problems that none of his students have seen yet. The i-th problem has a topic a_i (an integer from 1 to n) and a difficulty b_i (an integer from 1 to n). All problems are different, that is, there are no two tasks that have the same topic and difficulty at the same time.\\n\\nMonocarp decided to select exactly 3 problems from n problems for the problemset. The problems should satisfy at least one of two conditions (possibly, both):\\n\\n  * the topics of all three selected problems are different; \\n  * the difficulties of all three selected problems are different. \\n\\n\\n\\nYour task is to determine the number of ways to select three problems for the problemset.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 50000) \u2014 the number of testcases.\\n\\nThe first line of each testcase contains an integer n (3 \u2264 n \u2264 2 \u22c5 10^5) \u2014 the number of problems that Monocarp have.\\n\\nIn the i-th of the following n lines, there are two integers a_i and b_i (1 \u2264 a_i, b_i \u2264 n) \u2014 the topic and the difficulty of the i-th problem.\\n\\nIt is guaranteed that there are no two problems that have the same topic and difficulty at the same time.\\n\\nThe sum of n over all testcases doesn't exceed 2 \u22c5 10^5.\\n\\nOutput\\n\\nPrint the number of ways to select three training problems that meet either of the requirements described in the statement.\\n\\nExample\\n\\nInput\\n\\n\\n2\\n4\\n2 4\\n3 4\\n2 1\\n1 3\\n5\\n1 5\\n2 4\\n3 3\\n4 2\\n5 1\\n\\n\\nOutput\\n\\n\\n3\\n10\\n\\nNote\\n\\nIn the first example, you can take the following sets of three problems:\\n\\n  * problems 1, 2, 4; \\n  * problems 1, 3, 4; \\n  * problems 2, 3, 4. \\n\\n\\n\\nThus, the number of ways is equal to three.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint main() {\\n  int t;\\n  cin >> t;\\n  while (t--) {\\n    int n;\\n    cin >> n;\\n    vector<int> a(n), b(n);\\n    for (int i = 0; i < n; i++) {\\n      cin >> a[i];\\n      cin >> b[i];\\n      a[i] -= 1;\\n      b[i] -= 1;\\n    }\\n    vector<int> ca(n), cb(n);\\n    for (int i = 0; i < n; i++) {\\n      ca[a[i]] += 1;\\n      cb[b[i]] += 1;\\n    }\\n    long long ans = (long long)n * (n - 1) * (n - 2) \\/ 6;\\n    for (int i = 0; i < n; i++) {\\n      ans -= 1LL * (ca[a[i]] - 1) * (cb[b[i]] - 1);\\n    }\\n    cout << ans << '\\\\n';\\n  }\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You are given two integers l and r, l\u2264 r. Find the largest possible value of a mod b over all pairs (a, b) of integers for which r\u2265 a \u2265 b \u2265 l.\\n\\nAs a reminder, a mod b is a remainder we get when dividing a by b. For example, 26 mod 8 = 2.\\n\\nInput\\n\\nEach test contains multiple test cases.\\n\\nThe first line contains one positive integer t (1\u2264 t\u2264 10^4), denoting the number of test cases. Description of the test cases follows.\\n\\nThe only line of each test case contains two integers l, r (1\u2264 l \u2264 r \u2264 10^9).\\n\\nOutput\\n\\nFor every test case, output the largest possible value of a mod b over all pairs (a, b) of integers for which r\u2265 a \u2265 b \u2265 l.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n1 1\\n999999999 1000000000\\n8 26\\n1 999999999\\n\\n\\nOutput\\n\\n\\n0\\n1\\n12\\n499999999\\n\\nNote\\n\\nIn the first test case, the only allowed pair is (a, b) = (1, 1), for which a mod b = 1 mod 1 = 0.\\n\\nIn the second test case, the optimal choice is pair (a, b) = (1000000000, 999999999), for which a mod b = 1.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nvoid solve() {\\n  long long int a, b;\\n  cin >> a >> b;\\n  if (b % 2 == 1) {\\n    if ((b + 1) \\/ 2 >= a)\\n      cout << b \\/ 2 << endl;\\n    else\\n      cout << b - a << endl;\\n  } else {\\n    if ((b \\/ 2) + 1 >= a)\\n      cout << (b \\/ 2) - 1 << endl;\\n    else\\n      cout << b - a << endl;\\n  }\\n}\\nint main() {\\n  ios_base::sync_with_stdio(false);\\n  cin.tie(NULL);\\n  long long int t;\\n  cin >> t;\\n  while (t--) solve();\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"Luntik came out for a morning stroll and found an array a of length n. He calculated the sum s of the elements of the array (s= \u2211_{i=1}^{n} a_i). Luntik calls a subsequence of the array a nearly full if the sum of the numbers in that subsequence is equal to s-1.\\n\\nLuntik really wants to know the number of nearly full subsequences of the array a. But he needs to come home so he asks you to solve that problem!\\n\\nA sequence x is a subsequence of a sequence y if x can be obtained from y by deletion of several (possibly, zero or all) elements.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 1000) \u2014 the number of test cases. The next 2 \u22c5 t lines contain descriptions of test cases. The description of each test case consists of two lines.\\n\\nThe first line of each test case contains a single integer n (1 \u2264 n \u2264 60) \u2014 the length of the array.\\n\\nThe second line contains n integers a_1, a_2, \u2026, a_n (0 \u2264 a_i \u2264 10^9) \u2014 the elements of the array a.\\n\\nOutput\\n\\nFor each test case print the number of nearly full subsequences of the array.\\n\\nExample\\n\\nInput\\n\\n\\n5\\n5\\n1 2 3 4 5\\n2\\n1000 1000\\n2\\n1 0\\n5\\n3 0 2 1 1\\n5\\n2 1 0 3 0\\n\\n\\nOutput\\n\\n\\n1\\n0\\n2\\n4\\n4\\n\\nNote\\n\\nIn the first test case, s=1+2+3+4+5=15, only (2,3,4,5) is a nearly full subsequence among all subsequences, the sum in it is equal to 2+3+4+5=14=15-1.\\n\\nIn the second test case, there are no nearly full subsequences.\\n\\nIn the third test case, s=1+0=1, the nearly full subsequences are (0) and () (the sum of an empty subsequence is 0).\\\":\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\ninline void pisz(int n) { printf(\\\"%d\\\\n\\\", n); }\\nconst int dr[4] = {-1, 0, 1, 0};\\nconst int dc[4] = {0, -1, 0, 1};\\nconst int drr[8] = {-1, -1, 0, 1, 1, 1, 0, -1};\\nconst int dcc[8] = {0, -1, -1, -1, 0, 1, 1, 1};\\ntemplate <typename T, typename TT>\\nostream& operator<<(ostream& s, pair<T, TT> t) {\\n  return s << \\\"(\\\" << t.first << \\\",\\\" << t.second << \\\")\\\";\\n}\\ntemplate <typename T>\\nostream& operator<<(ostream& s, vector<T> t) {\\n  for (int i = 0; i < ((int)((t).size())); i++) s << t[i] << \\\" \\\";\\n  return s;\\n}\\nclass UnionFind {\\n private:\\n  vector<int> rank, p;\\n\\n public:\\n  UnionFind(int n) {\\n    for (int i = 0; i < n; i++) p.push_back(i);\\n    rank.assign(n, 0);\\n  }\\n  int findSet(int s) { return (p[s] == s) ? s : (p[s] = findSet(p[s])); }\\n  bool isSameSet(int i, int j) { return findSet(i) == findSet(j); }\\n  void unionSet(int i, int j) {\\n    if (isSameSet(i, j)) return;\\n    int x = findSet(i), y = findSet(j);\\n    if (rank[x] > rank[y])\\n      p[y] = x;\\n    else {\\n      p[x] = y;\\n      if (rank[x] == rank[y]) rank[y]++;\\n    }\\n  }\\n};\\nbool fcomp(double A, double B) {\\n  double EPSILON = numeric_limits<double>::epsilon();\\n  double diff = A - B;\\n  return fabs(diff) < EPSILON;\\n}\\ndouble x_y(int x1, int y1, int x2, int y2) {\\n  return sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));\\n}\\nint main() {\\n  int(testow);\\n  scanf(\\\"%d\\\", &(testow));\\n  while (testow--) {\\n    long long ct[2];\\n    memset(ct, 0, sizeof(ct));\\n    int(n);\\n    scanf(\\\"%d\\\", &(n));\\n    int dt[n];\\n    for (int i = 0; i < n; i++) {\\n      scanf(\\\"%d\\\", &dt[i]);\\n      if (dt[i] == 0 || dt[i] == 1) ct[dt[i]]++;\\n    }\\n    long long mul = 1;\\n    for (int i = 1; i <= ct[0]; i++) mul *= 2;\\n    cout << ct[1] * mul << endl;\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Arpa has found a list containing n numbers. He calls a list bad if and only if it is not empty and gcd (see notes section for more information) of numbers in the list is 1.\\n\\nArpa can perform two types of operations:\\n\\n  * Choose a number and delete it with cost x. \\n  * Choose a number and increase it by 1 with cost y. \\n\\n\\n\\nArpa can apply these operations to as many numbers as he wishes, and he is allowed to apply the second operation arbitrarily many times on the same number.\\n\\nHelp Arpa to find the minimum possible cost to make the list good.\\n\\nInput\\n\\nFirst line contains three integers n, x and y (1 \u2264 n \u2264 5\u00b7105, 1 \u2264 x, y \u2264 109) \u2014 the number of elements in the list and the integers x and y.\\n\\nSecond line contains n integers a1, a2, ..., an (1 \u2264 ai \u2264 106) \u2014 the elements of the list.\\n\\nOutput\\n\\nPrint a single integer: the minimum possible cost to make the list good.\\n\\nExamples\\n\\nInput\\n\\n4 23 17\\n1 17 17 16\\n\\n\\nOutput\\n\\n40\\n\\n\\nInput\\n\\n10 6 2\\n100 49 71 73 66 96 8 60 41 63\\n\\n\\nOutput\\n\\n10\\n\\nNote\\n\\nIn example, number 1 must be deleted (with cost 23) and number 16 must increased by 1 (with cost 17).\\n\\nA gcd (greatest common divisor) of a set of numbers is the maximum integer that divides all integers in the set. Read more about gcd [here](https:\\/\\/en.wikipedia.org\\/wiki\\/Greatest_common_divisor).\\nUsing cpp can you solve the prior task?\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst int N = 2e6 + 5, INF = 1e12;\\nint a[N];\\nlong long s[N];\\nint main() {\\n  int n, x, y;\\n  cin >> n >> x >> y;\\n  int p = x \\/ y;\\n  for (int i = 0; i < n; i++) {\\n    int l;\\n    cin >> l;\\n    a[l]++;\\n    s[l] += l;\\n  }\\n  for (int i = 1; i <= 2000000; i++) {\\n    a[i] += a[i - 1], s[i] += s[i - 1];\\n  }\\n  long long ans = (long long)1e18;\\n  for (int i = 2; i <= 1000000; i++) {\\n    long long t = 0;\\n    for (int j = i; j <= 1000000 + i && t < ans; j += i) {\\n      int k = max(j - i + 1, j - p);\\n      t += ((a[j] - a[k - 1]) * 1LL * j - (s[j] - s[k - 1])) * 1LL * y;\\n      t += (a[k - 1] - a[j - i]) * 1LL * x;\\n    }\\n    ans = min(ans, t);\\n  }\\n  cout << ans << endl;\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"A total of n depots are located on a number line. Depot i lies at the point x_i for 1 \u2264 i \u2264 n.\\n\\nYou are a salesman with n bags of goods, attempting to deliver one bag to each of the n depots. You and the n bags are initially at the origin 0. You can carry up to k bags at a time. You must collect the required number of goods from the origin, deliver them to the respective depots, and then return to the origin to collect your next batch of goods.\\n\\nCalculate the minimum distance you need to cover to deliver all the bags of goods to the depots. You do not have to return to the origin after you have delivered all the bags.\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 10 500). Description of the test cases follows.\\n\\nThe first line of each test case contains two integers n and k (1 \u2264 k \u2264 n \u2264 2 \u22c5 10^5).\\n\\nThe second line of each test case contains n integers x_1, x_2, \u2026, x_n (-10^9 \u2264 x_i \u2264 10^9). It is possible that some depots share the same position.\\n\\nIt is guaranteed that the sum of n over all test cases does not exceed 2 \u22c5 10^5.\\n\\nOutput\\n\\nFor each test case, output a single integer denoting the minimum distance you need to cover to deliver all the bags of goods to the depots. \\n\\nExample\\n\\nInput\\n\\n\\n4\\n5 1\\n1 2 3 4 5\\n9 3\\n-5 -10 -15 6 5 8 3 7 4\\n5 3\\n2 2 3 3 3\\n4 2\\n1000000000 1000000000 1000000000 1000000000\\n\\n\\nOutput\\n\\n\\n25\\n41\\n7\\n3000000000\\n\\nNote\\n\\nIn the first test case, you can carry only one bag at a time. Thus, the following is a solution sequence that gives a minimum travel distance: 0 \u2192 2 \u2192 0 \u2192 4 \u2192 0 \u2192 3 \u2192 0 \u2192 1 \u2192 0 \u2192 5, where each 0 means you go the origin and grab one bag, and each positive integer means you deliver the bag to a depot at this coordinate, giving a total distance of 25 units. It must be noted that there are other sequences that give the same distance.\\n\\nIn the second test case, you can follow the following sequence, among multiple such sequences, to travel minimum distance: 0 \u2192 6 \u2192 8 \u2192 7 \u2192 0 \u2192 5 \u2192 4 \u2192 3 \u2192 0 \u2192 (-5) \u2192 (-10) \u2192 (-15), with distance...\\nThe above is tricky. Write me a correct solution in PYTHON3.\",\"targets\":\"from collections import defaultdict, Counter,deque\\nfrom math import sqrt, log10, log, floor, factorial,gcd\\nfrom bisect import bisect_left, bisect_right,insort\\nfrom itertools import permutations,combinations\\nimport sys, io, os\\ninput = sys.stdin.readline\\ninput=io.BytesIO(os.read(0,os.fstat(0).st_size)).readline\\n# sys.setrecursionlimit(10000)\\ninf = float('inf')\\nmod = 10 ** 9 + 7\\ndef yn(a): print(\\\"YES\\\" if a else \\\"NO\\\")\\nceil = lambda a, b: (a + b - 1) \\/\\/ b\\ndef get(pos):\\n    arr = []\\n    while pos:\\n        arr.append(pos.pop())\\n        for i in range(k-1):\\n            if pos:\\n                pos.pop()\\n    return arr\\nt = int(input())\\nfor i in range(t):\\n    n,k=[int(i) for i in input().split()]\\n    l=[int(i) for i in input().split()]\\n    pos=[i for i in l if i>0]\\n    neg=[-i for i in l if i<0]\\n    pos.sort()\\n    neg.sort()\\n    arr1=get(pos)\\n    arr2=get(neg)\\n    arr=sorted(arr1+arr2)\\n    counter=0\\n    if arr:\\n        counter=arr.pop()\\n    for i in arr:\\n        counter+=i*2\\n    print(counter)\",\"language\":\"python\",\"split\":\"test\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Alice and Borys are playing tennis.\\n\\nA tennis match consists of games. In each game, one of the players is serving and the other one is receiving.\\n\\nPlayers serve in turns: after a game where Alice is serving follows a game where Borys is serving, and vice versa.\\n\\nEach game ends with a victory of one of the players. If a game is won by the serving player, it's said that this player holds serve. If a game is won by the receiving player, it's said that this player breaks serve.\\n\\nIt is known that Alice won a games and Borys won b games during the match. It is unknown who served first and who won which games.\\n\\nFind all values of k such that exactly k breaks could happen during the match between Alice and Borys in total.\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 10^3). Description of the test cases follows.\\n\\nEach of the next t lines describes one test case and contains two integers a and b (0 \u2264 a, b \u2264 10^5; a + b > 0) \u2014 the number of games won by Alice and Borys, respectively.\\n\\nIt is guaranteed that the sum of a + b over all test cases does not exceed 2 \u22c5 10^5.\\n\\nOutput\\n\\nFor each test case print two lines.\\n\\nIn the first line, print a single integer m (1 \u2264 m \u2264 a + b + 1) \u2014 the number of values of k such that exactly k breaks could happen during the match.\\n\\nIn the second line, print m distinct integers k_1, k_2, \u2026, k_m (0 \u2264 k_1 < k_2 < \u2026 < k_m \u2264 a + b) \u2014 the sought values of k in increasing order.\\n\\nExample\\n\\nInput\\n\\n\\n3\\n2 1\\n1 1\\n0 5\\n\\n\\nOutput\\n\\n\\n4\\n0 1 2 3\\n2\\n0 2\\n2\\n2 3\\n\\nNote\\n\\nIn the first test case, any number of breaks between 0 and 3 could happen during the match: \\n\\n  * Alice holds serve, Borys holds serve, Alice holds serve: 0 breaks; \\n  * Borys holds serve, Alice holds serve, Alice breaks serve: 1 break; \\n  * Borys breaks serve, Alice breaks serve, Alice holds serve: 2 breaks; \\n  * Alice breaks serve, Borys breaks serve, Alice breaks serve: 3 breaks. \\n\\n\\n\\nIn the second test case, the players could either both hold serves (0 breaks) or both break serves (2...\\ndef s\",\"targets\":\"olve():\\n    a,b=map(int,input().split())\\n    if a==b:\\n        print((a+b)\\/\\/2+1)\\n        for i in range(0,a+b+1,2):\\n            print(i,end=' ')\\n        print()\\n    elif abs(a-b)==1:\\n        print(a+b+1)\\n        for i in range(a+b+1):\\n            print(i,end=' ')\\n        print()\\n    elif a==0 or b==0:\\n        if (a==0 and b%2==0):\\n            print(1)\\n            print(b\\/\\/2)\\n        elif (b==0 and a%2==0):\\n            print(1)\\n            print(a\\/\\/2)\\n        else:\\n            print(2)\\n            if a==0:\\n                print(b\\/\\/2,b\\/\\/2+1,end=' ')\\n            else:\\n                print(a\\/\\/2,a\\/\\/2+1,end=' ')\\n            print()\\n    else:\\n        if (a+b)%2==0:\\n            x=abs(a-b)\\/\\/2\\n            y=a+b-abs(a-b)\\/\\/2\\n            print((y-x)\\/\\/2+1)\\n            for i in range(x,y+1,2):\\n                print(i,end=' ')\\n            print()\\n        else:\\n            print(a+b-abs(a-b)\\/\\/2+1-abs(a-b)\\/\\/2)\\n            for i in range(abs(a-b)\\/\\/2,a+b-abs(a-b)\\/\\/2+1):\\n                print(i,end=' ')\\n            print()\\nt=int(input())\\nwhile(t):\\n   solve()\\n   t-=1\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"One day, early in the morning, you decided to buy yourself a bag of chips in the nearby store. The store has chips of n different flavors. A bag of the i-th flavor costs a_i burles.\\n\\nThe store may run out of some flavors, so you'll decide which one to buy after arriving there. But there are two major flaws in this plan: \\n\\n  1. you have only coins of 1, 2 and 3 burles; \\n  2. since it's morning, the store will ask you to pay in exact change, i. e. if you choose the i-th flavor, you'll have to pay exactly a_i burles. \\n\\n\\n\\nCoins are heavy, so you'd like to take the least possible number of coins in total. That's why you are wondering: what is the minimum total number of coins you should take with you, so you can buy a bag of chips of any flavor in exact change?\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 1000) \u2014 the number of test cases.\\n\\nThe first line of each test case contains the single integer n (1 \u2264 n \u2264 100) \u2014 the number of flavors in the store.\\n\\nThe second line of each test case contains n integers a_1, a_2, ..., a_n (1 \u2264 a_i \u2264 10^9) \u2014 the cost of one bag of each flavor.\\n\\nOutput\\n\\nFor each test case, print one integer \u2014 the minimum number of coins you need to buy one bag of any flavor you'll choose in exact change.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n1\\n1337\\n3\\n10 8 10\\n5\\n1 2 3 4 5\\n3\\n7 77 777\\n\\n\\nOutput\\n\\n\\n446\\n4\\n3\\n260\\n\\nNote\\n\\nIn the first test case, you should, for example, take with you 445 coins of value 3 and 1 coin of value 2. So, 1337 = 445 \u22c5 3 + 1 \u22c5 2.\\n\\nIn the second test case, you should, for example, take 2 coins of value 3 and 2 coins of value 2. So you can pay either exactly 8 = 2 \u22c5 3 + 1 \u22c5 2 or 10 = 2 \u22c5 3 + 2 \u22c5 2.\\n\\nIn the third test case, it's enough to take 1 coin of value 3 and 2 coins of value 1.\\nimpor\",\"targets\":\"t java.lang.reflect.Array;\\nimport java.util.*;\\nimport java.io.*;\\n\\npublic class A {\\n    static final int INF = (int) 1e9;\\n\\n    public static int isValid(int val, int ones, int twos) {\\n        int ans = (int) 1e9;\\n        for (int j = 0; j <= ones; j++) {\\n            for (int k = 0; k <= twos; k++) {\\n                int newVal = val - j - 2 * k;\\n                if (newVal >= 0 && newVal % 3 == 0) {\\n                    ans = Math.min(ans, newVal \\/ 3);\\n                }\\n            }\\n        }\\n        return ans;\\n    }\\n\\n    public static void main(String[] args) throws IOException {\\n        Scanner sc = new Scanner(System.in);\\n        PrintWriter pw = new PrintWriter(System.out);\\n        int t = sc.nextInt();\\n        while (t-- > 0) {\\n            int n = sc.nextInt();\\n            int[] arr = new int[n];\\n            int ans = (int) 1e9;\\n            for (int i = 0; i < n; i++) {\\n                arr[i] = sc.nextInt();\\n            }\\n            for (int ones = 0; ones <= 3; ones++) {\\n                for (int twos = 0; twos <= 3; twos++) {\\n                    int cand = 0;\\n                    for (int x : arr) {\\n                        cand = Math.max(cand, isValid(x, ones, twos));\\n                    }\\n                    ans = Math.min(ans, cand + ones + twos);\\n                }\\n            }\\n            pw.println(ans);\\n        }\\n        pw.close();\\n    }\\n\\n    static class Scanner {\\n        BufferedReader br;\\n        StringTokenizer st;\\n\\n        public Scanner(InputStream s) {\\n            br = new BufferedReader(new InputStreamReader(s));\\n        }\\n\\n        public Scanner(FileReader f) {\\n            br = new BufferedReader(f);\\n        }\\n\\n        public String next() throws IOException {\\n            while (st == null || !st.hasMoreTokens())\\n                st = new StringTokenizer(br.readLine());\\n            return st.nextToken();\\n        }\\n\\n        public int nextInt() throws IOException {\\n            return Integer.parseInt(next());\\n        }\\n\\n        public long nextLong() throws IOException {\\n            return...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Polycarp has found a table having an infinite number of rows and columns. The rows are numbered from 1, starting from the topmost one. The columns are numbered from 1, starting from the leftmost one.\\n\\nInitially, the table hasn't been filled and Polycarp wants to fix it. He writes integers from 1 and so on to the table as follows.\\n\\n<image> The figure shows the placement of the numbers from 1 to 10. The following actions are denoted by the arrows.\\n\\nThe leftmost topmost cell of the table is filled with the number 1. Then he writes in the table all positive integers beginning from 2 sequentially using the following algorithm.\\n\\nFirst, Polycarp selects the leftmost non-filled cell in the first row and fills it. Then, while the left neighbor of the last filled cell is filled, he goes down and fills the next cell. So he goes down until the last filled cell has a non-filled neighbor to the left (look at the vertical arrow going down in the figure above).\\n\\nAfter that, he fills the cells from the right to the left until he stops at the first column (look at the horizontal row in the figure above). Then Polycarp selects the leftmost non-filled cell in the first row, goes down, and so on.\\n\\nA friend of Polycarp has a favorite number k. He wants to know which cell will contain the number. Help him to find the indices of the row and the column, such that the intersection of the row and the column is the cell containing the number k.\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 100) \u2014 the number of test cases. Then t test cases follow.\\n\\nEach test case consists of one line containing one integer k (1 \u2264 k \u2264 10^9) which location must be found.\\n\\nOutput\\n\\nFor each test case, output in a separate line two integers r and c (r, c \u2265 1) separated by spaces \u2014 the indices of the row and the column containing the cell filled by the number k, respectively.\\n\\nExample\\n\\nInput\\n\\n\\n7\\n11\\n14\\n5\\n4\\n1\\n2\\n1000000000\\n\\n\\nOutput\\n\\n\\n2 4\\n4 3\\n1 3\\n2 1\\n1 1\\n1 2\\n31623 14130\\nUsing java can you solve the prior task?\",\"targets\":\"\\/* package codechef; \\/\\/ don't place package name! *\\/\\n\\nimport java.util.*;\\nimport java.lang.*;\\nimport java.io.*;\\n\\n\\/* Name of the class has to be \\\"Main\\\" only if the class is public. *\\/\\npublic class Codechef {\\n\\tstatic int max = 200020;\\n\\tstatic long mod = 1000000007l;\\n\\tstatic long prime[] = new long[max];\\n\\tstatic long fac[] = new long[max];\\n\\tstatic long invfac[] = new long[max];\\n\\n\\tstatic void init() {\\n\\n\\t\\tprime[1] = 1;\\n\\t\\tfac[1] = 1;\\n\\t\\tinvfac[1] = 1;\\n\\n\\t\\tfor (int i = 2; i < max; i++) {\\n\\t\\t\\tfac[i] = multiply(fac[i - 1], i);\\n\\t\\t\\tinvfac[i] = power(fac[i], mod - 2l);\\n\\t\\t\\t\\/*\\n\\t\\t\\tif(prime[i] == 0)\\n\\t\\t\\t{\\n\\t\\t\\t\\tfor(int j =  i;j<max;j+=i)\\n\\t\\t\\t\\t{\\n\\t\\t\\t\\t\\tif(prime[j] == 0)\\n\\t\\t\\t\\t\\t\\tprime[j] = i;\\n\\t\\t\\t\\t}\\n\\t\\t\\t}*\\/\\n\\t\\t}\\n\\n\\t}\\n\\n\\tstatic long multiply(long a, long b) {\\n\\t\\treturn ((a % mod) * (b % mod)) % mod;\\n\\t}\\n\\n\\tstatic long ncr(int n, int r) {\\n\\t\\treturn multiply(multiply(fac[n], invfac[r]), invfac[n - r]);\\n\\t}\\n\\n\\tpublic static void main(String[] args) throws java.lang.Exception {\\n\\t\\tFastReader in = new FastReader(System.in);\\n\\t\\tStringBuilder sb = new StringBuilder();\\n\\t\\tint t = 1;\\n\\t\\t\\/\\/init();\\n\\t\\tt = in.nextInt();\\n\\t\\twhile (t > 0) {\\n\\t\\t\\t--t;\\n\\t\\t int k = in.nextInt();\\n\\t\\t if(k == 1)\\n\\t\\t {\\n\\t\\t\\t sb.append(\\\"1 1\\\\n\\\");\\n\\t\\t }\\n\\t\\t else if(k == 2)\\n\\t\\t\\t sb.append(\\\"1 2\\\\n\\\");\\n\\t\\t else if(k == 3)\\n\\t\\t\\t sb.append(\\\"2 2\\\\n\\\");\\n\\t\\t else if(k == 4)\\n\\t\\t\\t sb.append(\\\"2 1\\\\n\\\");\\n\\t\\t else {\\n\\t\\t int l1 = (int)Math.sqrt(k-1);\\n\\t\\t int s = l1*l1;\\n\\t\\t int l = 2*(l1+1);\\n\\t\\t if(s+(l\\/2) == k)\\n\\t\\t\\t sb.append((l1+1)+\\\" \\\"+(l1+1)+\\\"\\\\n\\\");\\n\\t\\t else if(k>s+(l\\/2))\\n\\t\\t {\\n\\t\\t\\t int x = s+l-1-k;\\n\\t\\t\\t sb.append((l1+1)+\\\" \\\"+(1+x)+\\\"\\\\n\\\");\\n\\t\\t }\\n\\t\\t else \\n\\t\\t {\\n\\t\\t\\t int y = s+1;\\n\\t\\t\\t int x = k-y;\\n\\t\\t\\t sb.append((1+x)+\\\" \\\"+(l1+1)+\\\"\\\\n\\\");\\n\\t\\t }\\n\\t\\t }\\n\\t\\t}\\n\\t\\tSystem.out.print(sb);\\n\\t}\\n\\n\\tstatic long gcd(long a, long b) {\\n\\t\\tif (a == 0)\\n\\t\\t\\treturn b;\\n\\t\\telse\\n\\t\\t\\treturn gcd(b % a, a);\\n\\t}\\n\\n\\tstatic long lcm(long a, long b) {\\n\\t\\treturn (a \\/ gcd(a, b)) * b;\\n\\t}\\n\\n\\tstatic long power(long a, long n) {\\n\\t\\tif (n == 0)\\n\\t\\t\\treturn 1l;\\n\\t\\tlong res = 1;\\n\\n\\t\\twhile (n > 0) {\\n\\t\\t\\tif (n % 2 == 1) {\\n\\t\\t\\t\\tres = ((res % mod) * (a % mod)) % mod;\\n\\t\\t\\t\\t--n;\\n\\t\\t\\t}\\n\\t\\t\\ta = ((a % mod) * (a % mod))...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You are given n integers a_1, a_2, \u2026, a_n and an integer k. Find the maximum value of i \u22c5 j - k \u22c5 (a_i | a_j) over all pairs (i, j) of integers with 1 \u2264 i < j \u2264 n. Here, | is the [bitwise OR operator](https:\\/\\/en.wikipedia.org\\/wiki\\/Bitwise_operation#OR).\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 10 000) \u2014 the number of test cases.\\n\\nThe first line of each test case contains two integers n (2 \u2264 n \u2264 10^5) and k (1 \u2264 k \u2264 min(n, 100)).\\n\\nThe second line of each test case contains n integers a_1, a_2, \u2026, a_n (0 \u2264 a_i \u2264 n).\\n\\nIt is guaranteed that the sum of n over all test cases doesn't exceed 3 \u22c5 10^5.\\n\\nOutput\\n\\nFor each test case, print a single integer \u2014 the maximum possible value of i \u22c5 j - k \u22c5 (a_i | a_j).\\n\\nExample\\n\\nInput\\n\\n\\n4\\n3 3\\n1 1 3\\n2 2\\n1 2\\n4 3\\n0 1 2 3\\n6 6\\n3 2 0 0 5 6\\n\\n\\nOutput\\n\\n\\n-1\\n-4\\n3\\n12\\n\\nNote\\n\\nLet f(i, j) = i \u22c5 j - k \u22c5 (a_i | a_j).\\n\\nIn the first test case, \\n\\n  * f(1, 2) = 1 \u22c5 2 - k \u22c5 (a_1 | a_2) = 2 - 3 \u22c5 (1 | 1) = -1. \\n  * f(1, 3) = 1 \u22c5 3 - k \u22c5 (a_1 | a_3) = 3 - 3 \u22c5 (1 | 3) = -6. \\n  * f(2, 3) = 2 \u22c5 3 - k \u22c5 (a_2 | a_3) = 6 - 3 \u22c5 (1 | 3) = -3. \\n\\n\\n\\nSo the maximum is f(1, 2) = -1.\\n\\nIn the fourth test case, the maximum is f(3, 4) = 12.\\nfrom\",\"targets\":\"sys import stdin, gettrace\\n\\nif gettrace():\\n    def inputi():\\n        return input()\\nelse:\\n    def input():\\n        return next(stdin)[:-1]\\n\\n\\n    def inputi():\\n        return stdin.buffer.readline()\\n\\n\\ndef solve():\\n    n,k = map(int, input().split())\\n    aa = [int(a) for a in input().split()]\\n    mnv = n*(n-1) - 200*n\\n    def minj(i):\\n        return max(i+1, mnv\\/\\/(i+1))\\n    res = max(i*j - k*(a|b) for i,a in enumerate(aa[:-1],1)\\n              for j,b in enumerate(aa[minj(i)-1:], minj(i)))\\n    print(res)\\n\\n\\ndef main():\\n    t = int(input())\\n    for _ in range(t):\\n        solve()\\n\\n\\nif __name__ == \\\"__main__\\\":\\n    main()\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"A magic number is a number formed by concatenation of numbers 1, 14 and 144. We can use each of these numbers any number of times. Therefore 14144, 141414 and 1411 are magic numbers but 1444, 514 and 414 are not.\\n\\nYou're given a number. Determine if it is a magic number or not.\\n\\nInput\\n\\nThe first line of input contains an integer n, (1 \u2264 n \u2264 109). This number doesn't contain leading zeros.\\n\\nOutput\\n\\nPrint \\\"YES\\\" if n is a magic number or print \\\"NO\\\" if it's not.\\n\\nExamples\\n\\nInput\\n\\n114114\\n\\n\\nOutput\\n\\nYES\\n\\n\\nInput\\n\\n1111\\n\\n\\nOutput\\n\\nYES\\n\\n\\nInput\\n\\n441231\\n\\n\\nOutput\\n\\nNO\\nSolve the task in PYTHON3.\",\"targets\":\"s=input()\\ni=0\\nflag=1\\nwhile(i<len(s)):\\n    if(s[i]=='1'):\\n        if(i<len(s)-1):\\n            if(s[i+1]!='4'):\\n                i+=1\\n            else:\\n                if(i<len(s)-2):\\n                    if(s[i+2]!='4'):\\n                        i+=2\\n                    else:\\n                        i+=3\\n                else:\\n                    i+=2\\n        else:\\n            i+=1\\n    else:\\n        flag=0\\n        break\\nif(flag==1):\\n    print(\\\"YES\\\")\\nelse:\\n    print(\\\"NO\\\")\",\"language\":\"python\",\"split\":\"train\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Consider writing each of the integers from 1 to N \\\\times M in a grid with N rows and M columns, without duplicates. Takahashi thinks it is not fun enough, and he will write the numbers under the following conditions:\\n\\n* The largest among the values in the i-th row (1 \\\\leq i \\\\leq N) is A_i.\\n* The largest among the values in the j-th column (1 \\\\leq j \\\\leq M) is B_j.\\n\\n\\n\\nFor him, find the number of ways to write the numbers under these conditions, modulo 10^9 + 7.\\n\\nConstraints\\n\\n* 1 \\\\leq N \\\\leq 1000\\n* 1 \\\\leq M \\\\leq 1000\\n* 1 \\\\leq A_i \\\\leq N \\\\times M\\n* 1 \\\\leq B_j \\\\leq N \\\\times M\\n* A_i and B_j are integers.\\n\\nInput\\n\\nInput is given from Standard Input in the following format:\\n\\n\\nN M\\nA_1 A_2 ... A_{N}\\nB_1 B_2 ... B_{M}\\n\\n\\nOutput\\n\\nPrint the number of ways to write the numbers under the conditions, modulo 10^9 + 7.\\n\\nExamples\\n\\nInput\\n\\n2 2\\n4 3\\n3 4\\n\\n\\nOutput\\n\\n2\\n\\n\\nInput\\n\\n3 3\\n5 9 7\\n3 6 9\\n\\n\\nOutput\\n\\n0\\n\\n\\nInput\\n\\n2 2\\n4 4\\n4 4\\n\\n\\nOutput\\n\\n0\\n\\n\\nInput\\n\\n14 13\\n158 167 181 147 178 151 179 182 176 169 180 129 175 168\\n181 150 178 179 167 180 176 169 182 177 175 159 173\\n\\n\\nOutput\\n\\n343772227\\nSolve the task in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\n#define maxn 1010\\n#define modn 1000000007\\nusing namespace std;\\nint f[maxn][maxn],a[maxn],b[maxn],n,m,i,t1=1,t2=1,ans=1;\\nint getnum()\\n{\\n\\tint s=0;\\n\\tchar c=getchar();\\n\\tfor (;!isdigit(c);c=getchar());\\n\\tfor (;isdigit(c);c=getchar())\\n\\t\\ts=s*10+c-'0';\\n\\treturn s;\\n}\\nbool cmp(int x,int y)\\n{\\n\\treturn x>y;\\n}\\nint main()\\n{\\n\\tn=getnum();\\n\\tm=getnum();\\n\\tfor (i=1;i<=n;i++)\\n\\t\\ta[i]=getnum();\\n\\tfor (i=1;i<=m;i++)\\n\\t\\tb[i]=getnum();\\n\\tsort(a+1,a+n+1,cmp);\\n\\tsort(b+1,b+m+1,cmp);\\n\\tfor (i=n*m;i;i--)\\n\\t{\\n\\t\\tif ((t1<=n) && (a[t1]>i)) break;\\n\\t\\tif ((t2<=m) && (b[t2]>i)) break;\\n\\t\\tif ((a[t1]==i) && (b[t2]==i)) t1++,t2++;\\n\\t\\t\\telse if (a[t1]==i) t1++,ans=1LL*ans*(t2-1)%modn;\\n\\t\\t\\t\\telse if (b[t2]==i) t2++,ans=1LL*ans*(t1-1)%modn;\\n\\t\\t\\t\\t\\telse ans=1LL*ans*((t1-1)*(t2-1)-(n*m-i))%modn;\\n\\t}\\n\\tif (i) printf(\\\"0\\\");\\n\\t\\telse printf(\\\"%d\\\",ans);\\n\\treturn 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"As meticulous Gerald sets the table and caring Alexander sends the postcards, Sergey makes snowmen. Each showman should consist of three snowballs: a big one, a medium one and a small one. Sergey's twins help him: they've already made n snowballs with radii equal to r1, r2, ..., rn. To make a snowman, one needs any three snowballs whose radii are pairwise different. For example, the balls with radii 1, 2 and 3 can be used to make a snowman but 2, 2, 3 or 2, 2, 2 cannot. Help Sergey and his twins to determine what maximum number of snowmen they can make from those snowballs.\\n\\nInput\\n\\nThe first line contains integer n (1 \u2264 n \u2264 105) \u2014 the number of snowballs. The next line contains n integers \u2014 the balls' radii r1, r2, ..., rn (1 \u2264 ri \u2264 109). The balls' radii can coincide.\\n\\nOutput\\n\\nPrint on the first line a single number k \u2014 the maximum number of the snowmen. Next k lines should contain the snowmen's descriptions. The description of each snowman should consist of three space-separated numbers \u2014 the big ball's radius, the medium ball's radius and the small ball's radius. It is allowed to print the snowmen in any order. If there are several solutions, print any of them.\\n\\nExamples\\n\\nInput\\n\\n7\\n1 2 3 4 5 6 7\\n\\n\\nOutput\\n\\n2\\n3 2 1\\n6 5 4\\n\\n\\nInput\\n\\n3\\n2 2 3\\n\\n\\nOutput\\n\\n0\",\"targets\":\"import java.io.*;\\nimport java.util.*;\\n\\npublic class C {\\n\\n\\tpublic C () throws IOException {\\n\\t\\tString input = r.readLine();\\n\\t\\tint N = Integer.parseInt(input);\\n\\t\\tint [] R = new int [N];\\n\\t\\tString [] S = r.readLine().split(\\\" \\\");\\n\\t\\tfor (int i = 0; i < N; ++i)\\n\\t\\t\\tR[i] = Integer.parseInt(S[i]);\\n\\t\\tsolve(N, R);\\n\\t}\\n\\t\\n\\tpublic void solve (int N, int [] R) {\\n\\t\\tt = millis();\\n\\t\\tArrays.sort(R);\\n\\t\\t\\n\\t\\tint [] Q = new int [N];\\n\\t\\t\\n\\t\\tQ[0] = 1;\\n\\t\\tint Z = 1;\\n\\t\\tfor (int i = 1; i < N; ++i)\\n\\t\\t\\tif (R[i] == R[i-1]) {\\n\\t\\t\\t\\tQ[i] = Q[i-1]+1;\\n\\t\\t\\t\\tQ[i-1] = -1;\\n\\t\\t\\t} else {\\n\\t\\t\\t\\tQ[i] = 1;\\n\\t\\t\\t\\t++Z;\\n\\t\\t\\t}\\n\\n\\t\\tif (Z < 3)\\n\\t\\t\\tprint(0);\\n\\t\\t\\n\\t\\tMap<Integer, Integer> M = new HashMap<Integer, Integer>();\\n\\t\\tfor (int i = 0; i < N; ++i)\\n\\t\\t\\tif (Q[i] > 0)\\n\\t\\t\\t\\tM.put(R[i], Q[i]);\\n\\t\\t\\n\\t\\tInteger [] U = M.values().toArray(new Integer[Z]);\\n\\t\\tArrays.sort(U);\\t\\t\\n\\t\\tint M1 = U[Z-1], M2 = U[Z-2];\\n\\t\\t\\n\\t\\tint M3 = N - M1 - M2;\\n\\t\\tint C = Math.min(M3, (M3+M2)\\/2);\\n\\t\\tC = Math.min(C, N\\/3);\\n\\t\\t\\n\\t\\tif (C == 0)\\n\\t\\t\\tprint(0);\\n\\t\\t\\n\\t\\tint [][] B = new int[C][3];\\n\\t\\tint c = 0, b = 0;\\n\\t\\tfor (int m : M.keySet()) {\\n\\t\\t\\tint z = Math.min(M.get(m), C);\\n\\t\\t\\tfor (int i = 0; i < z && b < 3; ++i) {\\n\\t\\t\\t\\tB[c++][b] = m;\\n\\t\\t\\t\\tif (c == C) {\\n\\t\\t\\t\\t\\tc = 0; ++b;\\n\\t\\t\\t\\t}\\n\\t\\t\\t}\\n\\t\\t}\\n\\t\\t\\t\\t\\n\\t\\tprint2(C);\\n\\t\\tfor (c = 0; c < C; ++c) {\\n\\t\\t\\tArrays.sort(B[c]);\\n\\t\\t\\tprint2(B[c][2] + \\\" \\\" + B[c][1] + \\\" \\\" + B[c][0]);\\n\\t\\t}\\n\\t}\\n\\n\\t\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\n\\n\\tstatic BufferedReader r;\\n\\tstatic long t;\\n\\t\\n\\tstatic void print2 (Object o) {\\n\\t\\tSystem.out.println(o);\\n\\t}\\n\\t\\n\\tstatic void print (Object o) {\\n\\t\\tprint2(o);\\n\\t\\t\\/\\/print2((millis() - t) \\/ 1000.0);\\n\\t\\tSystem.exit(0);\\n\\t}\\n\\t\\n\\tstatic void run () throws IOException {\\n\\t\\tr = new BufferedReader(new InputStreamReader(System.in));\\n\\t\\tnew C();\\n\\t}\\n\\t\\n\\tpublic static void main(String[] args) throws IOException {\\n\\t\\trun();\\n\\t}\\n\\t\\n\\tstatic long millis() {\\n\\t\\treturn System.currentTimeMillis();\\n\\t}\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You are given a keyboard that consists of 26 keys. The keys are arranged sequentially in one row in a certain order. Each key corresponds to a unique lowercase Latin letter.\\n\\nYou have to type the word s on this keyboard. It also consists only of lowercase Latin letters.\\n\\nTo type a word, you need to type all its letters consecutively one by one. To type each letter you must position your hand exactly over the corresponding key and press it.\\n\\nMoving the hand between the keys takes time which is equal to the absolute value of the difference between positions of these keys (the keys are numbered from left to right). No time is spent on pressing the keys and on placing your hand over the first letter of the word.\\n\\nFor example, consider a keyboard where the letters from 'a' to 'z' are arranged in consecutive alphabetical order. The letters 'h', 'e', 'l' and 'o' then are on the positions 8, 5, 12 and 15, respectively. Therefore, it will take |5 - 8| + |12 - 5| + |12 - 12| + |15 - 12| = 13 units of time to type the word \\\"hello\\\". \\n\\nDetermine how long it will take to print the word s.\\n\\nInput\\n\\nThe first line contains an integer t (1 \u2264 t \u2264 1000) \u2014 the number of test cases.\\n\\nThe next 2t lines contain descriptions of the test cases.\\n\\nThe first line of a description contains a keyboard \u2014 a string of length 26, which consists only of lowercase Latin letters. Each of the letters from 'a' to 'z' appears exactly once on the keyboard.\\n\\nThe second line of the description contains the word s. The word has a length from 1 to 50 letters inclusive and consists of lowercase Latin letters.\\n\\nOutput\\n\\nPrint t lines, each line containing the answer to the corresponding test case. The answer to the test case is the minimal time it takes to type the word s on the given keyboard.\\n\\nExample\\n\\nInput\\n\\n\\n5\\nabcdefghijklmnopqrstuvwxyz\\nhello\\nabcdefghijklmnopqrstuvwxyz\\ni\\nabcdefghijklmnopqrstuvwxyz\\ncodeforces\\nqwertyuiopasdfghjklzxcvbnm\\nqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\nqwertyuiopasdfghjklzxcvbnm\\nabacaba\\n\\n\\nOutput\\n\\n\\n13\\n0\\n68\\n0\\n74\\nSolve the task in JAVA.\",\"targets\":\"import java.io.BufferedReader;\\nimport java.io.IOException;\\nimport java.io.InputStreamReader;\\nimport java.util.HashMap;\\nimport java.util.Map;\\nimport java.util.StringTokenizer;\\n\\npublic class Main {\\n\\n    public static void main(String[] args) {\\n        MyScanner myScanner = new MyScanner();\\n        int t = myScanner.nextInt();\\n        while (t-- > 0) {\\n            String s = myScanner.nextLine();\\n            Map<Character, Integer> map = new HashMap<>();\\n            for(int i=0; i<s.length(); i++) {\\n                map.put(s.charAt(i), i);\\n            }\\n            String input = myScanner.nextLine();\\n            if(input.length() <= 1) {\\n                System.out.println(0);\\n                continue;\\n            }\\n            int cost = 0;\\n            for(int i=1; i<input.length(); i++) {\\n                cost += Math.abs(map.get(input.charAt(i)) - map.get(input.charAt(i-1)));\\n            }\\n            System.out.println(cost);\\n        }\\n    }\\n\\n    private static void printArray(int[] result) {\\n        for(int i=0; i<result.length; i++) {\\n            System.out.print(result[i] + \\\" \\\");\\n        }\\n        System.out.println();\\n    }\\n\\n\\n    public static class MyScanner {\\n        BufferedReader br;\\n        StringTokenizer st;\\n\\n        public MyScanner() {\\n            br = new BufferedReader(new InputStreamReader(System.in));\\n        }\\n\\n        String next() {\\n            while (st == null || !st.hasMoreElements()) {\\n                try {\\n                    st = new StringTokenizer(br.readLine());\\n                } catch (IOException e) {\\n                    e.printStackTrace();\\n                }\\n            }\\n            return st.nextToken();\\n        }\\n\\n        int nextInt() {\\n            return Integer.parseInt(next());\\n        }\\n\\n        long nextLong() {\\n            return Long.parseLong(next());\\n        }\\n\\n        double nextDouble() {\\n            return Double.parseDouble(next());\\n        }\\n\\n        String nextLine(){\\n            String str = \\\"\\\";\\n            try {\\n                str = br.readLine();\\n        ...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"A permutation is a sequence of integers p1, p2, ..., pn, consisting of n distinct positive integers, each of them doesn't exceed n. Let's denote the i-th element of permutation p as pi. We'll call number n the size of permutation p1, p2, ..., pn.\\n\\nNickolas adores permutations. He likes some permutations more than the others. He calls such permutations perfect. A perfect permutation is such permutation p that for any i (1 \u2264 i \u2264 n) (n is the permutation size) the following equations hold ppi = i and pi \u2260 i. Nickolas asks you to print any perfect permutation of size n for the given n.\\n\\nInput\\n\\nA single line contains a single integer n (1 \u2264 n \u2264 100) \u2014 the permutation size.\\n\\nOutput\\n\\nIf a perfect permutation of size n doesn't exist, print a single integer -1. Otherwise print n distinct integers from 1 to n, p1, p2, ..., pn \u2014 permutation p, that is perfect. Separate printed numbers by whitespaces.\\n\\nExamples\\n\\nInput\\n\\n1\\n\\n\\nOutput\\n\\n-1\\n\\n\\nInput\\n\\n2\\n\\n\\nOutput\\n\\n2 1 \\n\\n\\nInput\\n\\n4\\n\\n\\nOutput\\n\\n2 1 4 3 \\nSolve the task in PYTHON3.\",\"targets\":\"n=int(input())\\nif n%2 == 1: print(-1)\\nelse:\\n\\tfor i in range(1,n+1,2):\\n\\t\\tprint(i+1,i,end=' ')\",\"language\":\"python\",\"split\":\"train\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"On a circle lie 2n distinct points, with the following property: however you choose 3 chords that connect 3 disjoint pairs of points, no point strictly inside the circle belongs to all 3 chords. The points are numbered 1,   2,   ...,   2n in clockwise order.\\n\\nInitially, k chords connect k pairs of points, in such a way that all the 2k endpoints of these chords are distinct.\\n\\nYou want to draw n - k additional chords that connect the remaining 2(n - k) points (each point must be an endpoint of exactly one chord).\\n\\nIn the end, let x be the total number of intersections among all n chords. Compute the maximum value that x can attain if you choose the n - k chords optimally.\\n\\nNote that the exact position of the 2n points is not relevant, as long as the property stated in the first paragraph holds.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 100) \u2014 the number of test cases. Then t test cases follow.\\n\\nThe first line of each test case contains two integers n and k (1 \u2264 n \u2264 100, 0 \u2264 k \u2264 n) \u2014 half the number of points and the number of chords initially drawn.\\n\\nThen k lines follow. The i-th of them contains two integers x_i and y_i (1 \u2264 x_i,   y_i \u2264 2n, x_i \u2260 y_i) \u2014 the endpoints of the i-th chord. It is guaranteed that the 2k numbers x_1,   y_1,   x_2,   y_2,   ...,   x_k,   y_k are all distinct.\\n\\nOutput\\n\\nFor each test case, output the maximum number of intersections that can be obtained by drawing n - k additional chords.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n4 2\\n8 2\\n1 5\\n1 1\\n2 1\\n2 0\\n10 6\\n14 6\\n2 20\\n9 10\\n13 18\\n15 12\\n11 7\\n\\n\\nOutput\\n\\n\\n4\\n0\\n1\\n14\\n\\nNote\\n\\nIn the first test case, there are three ways to draw the 2 additional chords, shown below (black chords are the ones initially drawn, while red chords are the new ones):\\n\\n<image>\\n\\nWe see that the third way gives the maximum number of intersections, namely 4.\\n\\nIn the second test case, there are no more chords to draw. Of course, with only one chord present there are no intersections.\\n\\nIn the third test case, we can make at most one intersection by drawing chords 1-3 and 2-4, as...\\nimpor\",\"targets\":\"t java.io.OutputStream;\\nimport java.io.IOException;\\nimport java.io.InputStream;\\nimport java.io.PrintWriter;\\nimport java.io.BufferedReader;\\nimport java.io.InputStreamReader;\\nimport java.util.*;\\n\\npublic class Main {\\n    public static void main(String[] args){\\n        InputStream inputStream = System.in;\\n        OutputStream outputStream = System.out;\\n        InputReader in = new InputReader(inputStream);\\n        PrintWriter out = new PrintWriter(outputStream);\\n        solve(in, out);\\n        out.close();\\n    }\\n\\n    static String reverse(String s) {\\n        return (new StringBuilder(s)).reverse().toString();\\n    }\\n\\n    static void sieveOfEratosthenes(int n, int factors[], ArrayList<Integer> ar) \\n    { \\n        factors[1]=1;\\n        int p;\\n        for(p = 2; p*p <=n; p++) \\n        { \\n            if(factors[p] == 0) \\n            { \\n                ar.add(p);\\n                factors[p]=p;\\n                for(int i = p*p; i <= n; i += p) \\n                    if(factors[i]==0)\\n                        factors[i] = p; \\n            } \\n        } \\n        for(;p<=n;p++){\\n            if(factors[p] == 0) \\n            { \\n                factors[p] = p;\\n                ar.add(p);\\n            } \\n        }\\n    }\\n\\n    static void sort(int ar[]) {\\n        int n = ar.length;\\n        ArrayList<Integer> a = new ArrayList<>();\\n        for (int i = 0; i < n; i++)\\n            a.add(ar[i]);\\n        Collections.sort(a);\\n        for (int i = 0; i < n; i++)\\n            ar[i] = a.get(i);\\n    }\\n\\n    static void sort1(long ar[]) {\\n        int n = ar.length;\\n        ArrayList<Long> a = new ArrayList<>();\\n        for (int i = 0; i < n; i++)\\n            a.add(ar[i]);\\n        Collections.sort(a);\\n        for (int i = 0; i < n; i++)\\n            ar[i] = a.get(i);\\n    }\\n\\n    static void sort2(char ar[]) {\\n        int n = ar.length;\\n        ArrayList<Character> a = new ArrayList<>();\\n        for (int i = 0; i < n; i++)\\n            a.add(ar[i]);\\n        Collections.sort(a);\\n        for (int i = 0; i < n; i++)\\n            ar[i] = a.get(i);\\n    }\\n\\n   ...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Ehab loves number theory, but for some reason he hates the number x. Given an array a, find the length of its longest subarray such that the sum of its elements isn't divisible by x, or determine that such subarray doesn't exist.\\n\\nAn array a is a subarray of an array b if a can be obtained from b by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.\\n\\nInput\\n\\nThe first line contains an integer t (1 \u2264 t \u2264 5) \u2014 the number of test cases you need to solve. The description of the test cases follows.\\n\\nThe first line of each test case contains 2 integers n and x (1 \u2264 n \u2264 10^5, 1 \u2264 x \u2264 10^4) \u2014 the number of elements in the array a and the number that Ehab hates.\\n\\nThe second line contains n space-separated integers a_1, a_2, \u2026, a_{n} (0 \u2264 a_i \u2264 10^4) \u2014 the elements of the array a.\\n\\nOutput\\n\\nFor each testcase, print the length of the longest subarray whose sum isn't divisible by x. If there's no such subarray, print -1.\\n\\nExample\\n\\nInput\\n\\n\\n3\\n3 3\\n1 2 3\\n3 4\\n1 2 3\\n2 2\\n0 6\\n\\n\\nOutput\\n\\n\\n2\\n3\\n-1\\n\\nNote\\n\\nIn the first test case, the subarray [2,3] has sum of elements 5, which isn't divisible by 3.\\n\\nIn the second test case, the sum of elements of the whole array is 6, which isn't divisible by 4.\\n\\nIn the third test case, all subarrays have an even sum, so the answer is -1.\\nUsing python3 can you solve the prior task?\",\"targets\":\"# ------------------- fast io --------------------\\nimport os\\nimport sys\\nfrom io import BytesIO, IOBase\\n\\nBUFSIZE = 8192\\n\\n\\nclass FastIO(IOBase):\\n    newlines = 0\\n\\n    def __init__(self, file):\\n        self._fd = file.fileno()\\n        self.buffer = BytesIO()\\n        self.writable = \\\"x\\\" in file.mode or \\\"r\\\" not in file.mode\\n        self.write = self.buffer.write if self.writable else None\\n\\n    def read(self):\\n        while True:\\n            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))\\n            if not b:\\n                break\\n            ptr = self.buffer.tell()\\n            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)\\n        self.newlines = 0\\n        return self.buffer.read()\\n\\n    def readline(self):\\n        while self.newlines == 0:\\n            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))\\n            self.newlines = b.count(b\\\"\\\\n\\\") + (not b)\\n            ptr = self.buffer.tell()\\n            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)\\n        self.newlines -= 1\\n        return self.buffer.readline()\\n\\n    def flush(self):\\n        if self.writable:\\n            os.write(self._fd, self.buffer.getvalue())\\n            self.buffer.truncate(0), self.buffer.seek(0)\\n\\n\\nclass IOWrapper(IOBase):\\n    def __init__(self, file):\\n        self.buffer = FastIO(file)\\n        self.flush = self.buffer.flush\\n        self.writable = self.buffer.writable\\n        self.write = lambda s: self.buffer.write(s.encode(\\\"ascii\\\"))\\n        self.read = lambda: self.buffer.read().decode(\\\"ascii\\\")\\n        self.readline = lambda: self.buffer.readline().decode(\\\"ascii\\\")\\n\\n\\nsys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)\\ninput = lambda: sys.stdin.readline().rstrip(\\\"\\\\r\\\\n\\\")\\n\\n# ------------------- fast io --------------------\\nfrom math import gcd, ceil\\n\\ndef pre(s):\\n    n = len(s)\\n    pi = [0] * n\\n    for i in range(1, n):\\n        j = pi[i - 1]\\n        while j and s[i] != s[j]:\\n            j = pi[j - 1]\\n        if s[i] == s[j]:\\n            j += 1\\n        pi[i]...\",\"language\":\"python\",\"split\":\"train\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You are given a permutation p of n elements. A permutation of n elements is an array of length n containing each integer from 1 to n exactly once. For example, [1, 2, 3] and [4, 3, 5, 1, 2] are permutations, but [1, 2, 4] and [4, 3, 2, 1, 2] are not permutations. You should perform q queries.\\n\\nThere are two types of queries:\\n\\n  * 1 x y \u2014 swap p_x and p_y. \\n  * 2 i k \u2014 print the number that i will become if we assign i = p_i k times. \\n\\nInput\\n\\nThe first line contains two integers n and q (1 \u2264 n, q \u2264 10^5).\\n\\nThe second line contains n integers p_1, p_2, ..., p_n.\\n\\nEach of the next q lines contains three integers. The first integer is t (1 \u2264 t \u2264 2) \u2014 type of query. If t = 1, then the next two integers are x and y (1 \u2264 x, y \u2264 n; x \u2260 y) \u2014 first-type query. If t = 2, then the next two integers are i and k (1 \u2264 i, k \u2264 n) \u2014 second-type query.\\n\\nIt is guaranteed that there is at least one second-type query.\\n\\nOutput\\n\\nFor every second-type query, print one integer in a new line \u2014 answer to this query.\\n\\nExamples\\n\\nInput\\n\\n\\n5 4\\n5 3 4 2 1\\n2 3 1\\n2 1 2\\n1 1 3\\n2 1 2\\n\\n\\nOutput\\n\\n\\n4\\n1\\n2\\n\\n\\nInput\\n\\n\\n5 9\\n2 3 5 1 4\\n2 3 5\\n2 5 5\\n2 5 1\\n2 5 3\\n2 5 4\\n1 5 4\\n2 5 3\\n2 2 5\\n2 5 1\\n\\n\\nOutput\\n\\n\\n3\\n5\\n4\\n2\\n3\\n3\\n3\\n1\\n\\nNote\\n\\nIn the first example p = \\\\{5, 3, 4, 2, 1\\\\}. \\n\\nThe first query is to print p_3. The answer is 4.\\n\\nThe second query is to print p_{p_1}. The answer is 1.\\n\\nThe third query is to swap p_1 and p_3. Now p = \\\\{4, 3, 5, 2, 1\\\\}.\\n\\nThe fourth query is to print p_{p_1}. The answer is 2.\\n#incl\",\"targets\":\"ude <bits\\/stdc++.h>\\nconst int maxn = 1e5 + 10;\\nint n, q, m, p[maxn], r[maxn], tar[maxn];\\ninline int jump(int x, int k) {\\n  for (int i = 0; i < k; ++i) x = p[x];\\n  return x;\\n}\\ninline int query(int x, int k) {\\n  while (k >= m) {\\n    x = tar[x];\\n    k -= m;\\n  }\\n  for (int i = 0; i < k; ++i) x = p[x];\\n  return x;\\n}\\nint main() {\\n  scanf(\\\"%d%d\\\", &n, &q);\\n  for (int i = 1; i <= n; ++i) {\\n    scanf(\\\"%d\\\", p + i);\\n    r[p[i]] = i;\\n  }\\n  m = ceil(sqrt(n));\\n  for (int i = 1; i <= n; ++i) tar[i] = jump(i, m);\\n  int opt, x, y;\\n  while (q--) {\\n    scanf(\\\"%d%d%d\\\", &opt, &x, &y);\\n    if (opt == 1) {\\n      std::swap(p[x], p[y]);\\n      std::swap(r[p[x]], r[p[y]]);\\n      tar[x] = jump(x, m);\\n      for (int i = 0; i < m; ++i) {\\n        tar[r[x]] = r[tar[x]];\\n        x = r[x];\\n      }\\n      tar[y] = jump(y, m);\\n      for (int i = 0; i < m; ++i) {\\n        tar[r[y]] = r[tar[y]];\\n        y = r[y];\\n      }\\n    } else\\n      printf(\\\"%d\\\\n\\\", query(x, y));\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"A binary string is a string that consists of characters 0 and 1.\\n\\nLet \\\\operatorname{MEX} of a binary string be the smallest digit among 0, 1, or 2 that does not occur in the string. For example, \\\\operatorname{MEX} of 001011 is 2, because 0 and 1 occur in the string at least once, \\\\operatorname{MEX} of 1111 is 0, because 0 and 2 do not occur in the string and 0 < 2.\\n\\nA binary string s is given. You should cut it into any number of substrings such that each character is in exactly one substring. It is possible to cut the string into a single substring \u2014 the whole string.\\n\\nA string a is a substring of a string b if a can be obtained from b by deletion of several (possibly, zero or all) characters from the beginning and several (possibly, zero or all) characters from the end.\\n\\nWhat is the minimal sum of \\\\operatorname{MEX} of all substrings pieces can be?\\n\\nInput\\n\\nThe input consists of multiple test cases. The first line contains a single integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases. Description of the test cases follows.\\n\\nEach test case contains a single binary string s (1 \u2264 |s| \u2264 10^5).\\n\\nIt's guaranteed that the sum of lengths of s over all test cases does not exceed 10^5.\\n\\nOutput\\n\\nFor each test case print a single integer \u2014 the minimal sum of \\\\operatorname{MEX} of all substrings that it is possible to get by cutting s optimally.\\n\\nExample\\n\\nInput\\n\\n\\n6\\n01\\n1111\\n01100\\n101\\n0000\\n01010\\n\\n\\nOutput\\n\\n\\n1\\n0\\n2\\n1\\n1\\n2\\n\\nNote\\n\\nIn the first test case the minimal sum is \\\\operatorname{MEX}(0) + \\\\operatorname{MEX}(1) = 1 + 0 = 1.\\n\\nIn the second test case the minimal sum is \\\\operatorname{MEX}(1111) = 0.\\n\\nIn the third test case the minimal sum is \\\\operatorname{MEX}(01100) = 2.\\nUsing cpp can you solve the prior task?\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst long long int MAX = 9187201950435737471;\\nconst double pi = acos(-1);\\nconst int N = 150009;\\nconst long long mod = 1000000007;\\nconst int M = 2147483647;\\nconst int lg = 101;\\nint t, n, m, k;\\nint main() {\\n  cin >> t;\\n  while (t--) {\\n    string s;\\n    cin >> s;\\n    n = s.size();\\n    s += '2';\\n    int ans = 0;\\n    for (int i = 0; i < n; i++) {\\n      if (s[i] != s[i + 1]) {\\n        if (s[i] == '0') ans++;\\n      }\\n    }\\n    cout << min(ans, 2) << \\\"\\\\n\\\";\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Compute A \\\\times B, truncate its fractional part, and print the result as an integer.\\n\\nConstraints\\n\\n* 0 \\\\leq A \\\\leq 10^{15}\\n* 0 \\\\leq B < 10\\n* A is an integer.\\n* B is a number with two digits after the decimal point.\\n\\nInput\\n\\nInput is given from Standard Input in the following format:\\n\\n\\nA B\\n\\n\\nOutput\\n\\nPrint the answer as an integer.\\n\\nExamples\\n\\nInput\\n\\n198 1.10\\n\\n\\nOutput\\n\\n217\\n\\n\\nInput\\n\\n1 0.01\\n\\n\\nOutput\\n\\n0\\n\\n\\nInput\\n\\n1000000000000000 9.99\\n\\n\\nOutput\\n\\n9990000000000000\\nThe above is tricky. Write me a correct solution in PYTHON3.\",\"targets\":\"a,b=map(int,input().replace('.','').split());print(a*b\\/\\/100)\",\"language\":\"python\",\"split\":\"train\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"After winning gold and silver in IOI 2014, Akshat and Malvika want to have some fun. Now they are playing a game on a grid made of n horizontal and m vertical sticks.\\n\\nAn intersection point is any point on the grid which is formed by the intersection of one horizontal stick and one vertical stick.\\n\\nIn the grid shown below, n = 3 and m = 3. There are n + m = 6 sticks in total (horizontal sticks are shown in red and vertical sticks are shown in green). There are n\u00b7m = 9 intersection points, numbered from 1 to 9.\\n\\n<image>\\n\\nThe rules of the game are very simple. The players move in turns. Akshat won gold, so he makes the first move. During his\\/her move, a player must choose any remaining intersection point and remove from the grid all sticks which pass through this point. A player will lose the game if he\\/she cannot make a move (i.e. there are no intersection points remaining on the grid at his\\/her move).\\n\\nAssume that both players play optimally. Who will win the game?\\n\\nInput\\n\\nThe first line of input contains two space-separated integers, n and m (1 \u2264 n, m \u2264 100).\\n\\nOutput\\n\\nPrint a single line containing \\\"Akshat\\\" or \\\"Malvika\\\" (without the quotes), depending on the winner of the game.\\n\\nExamples\\n\\nInput\\n\\n2 2\\n\\n\\nOutput\\n\\nMalvika\\n\\n\\nInput\\n\\n2 3\\n\\n\\nOutput\\n\\nMalvika\\n\\n\\nInput\\n\\n3 3\\n\\n\\nOutput\\n\\nAkshat\\n\\nNote\\n\\nExplanation of the first sample:\\n\\nThe grid has four intersection points, numbered from 1 to 4.\\n\\n<image>\\n\\nIf Akshat chooses intersection point 1, then he will remove two sticks (1 - 2 and 1 - 3). The resulting grid will look like this.\\n\\n<image>\\n\\nNow there is only one remaining intersection point (i.e. 4). Malvika must choose it and remove both remaining sticks. After her move the grid will be empty.\\n\\nIn the empty grid, Akshat cannot make any move, hence he will lose.\\n\\nSince all 4 intersection points of the grid are equivalent, Akshat will lose no matter which one he picks.\",\"targets\":\"a = list(map(int, input().split()))\\nc = a[1]\\nb = a[0]\\ncount1 = 1\\ncount2 = 0\\n\\ni = 2\\nwhile True:\\n    if (b - 1) * (c - 1) > 0:\\n        if i % 2 != 0:\\n            count1 += 1\\n        else:\\n            count2 += 1\\n        b = b - 1\\n        c = c - 1\\n    else:\\n        break\\n\\n    i += 1\\n\\nif count1 > count2:\\n    print(\\\"Akshat\\\")\\nelse:\\n    print(\\\"Malvika\\\")\",\"language\":\"python\",\"split\":\"train\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Denis was very sad after Nastya rejected him. So he decided to walk through the gateways to have some fun. And luck smiled at him! When he entered the first courtyard, he met a strange man who was selling something. \\n\\nDenis bought a mysterious item and it was... Random permutation generator! Denis could not believed his luck.\\n\\nWhen he arrived home, he began to study how his generator works and learned the algorithm. The process of generating a permutation consists of n steps. At the i-th step, a place is chosen for the number i (1 \u2264 i \u2264 n). The position for the number i is defined as follows:\\n\\n  * For all j from 1 to n, we calculate r_j \u2014 the minimum index such that j \u2264 r_j \u2264 n, and the position r_j is not yet occupied in the permutation. If there are no such positions, then we assume that the value of r_j is not defined. \\n  * For all t from 1 to n, we calculate count_t \u2014 the number of positions 1 \u2264 j \u2264 n such that r_j is defined and r_j = t. \\n  * Consider the positions that are still not occupied by permutation and among those we consider the positions for which the value in the count array is maximum. \\n  * The generator selects one of these positions for the number i. The generator can choose any position. \\n\\n\\n\\nLet's have a look at the operation of the algorithm in the following example:\\n\\n<image>\\n\\nLet n = 5 and the algorithm has already arranged the numbers 1, 2, 3 in the permutation. Consider how the generator will choose a position for the number 4:\\n\\n  * The values of r will be r = [3, 3, 3, 4, \u00d7], where \u00d7 means an indefinite value. \\n  * Then the count values will be count = [0, 0, 3, 1, 0]. \\n  * There are only two unoccupied positions in the permutation: 3 and 4. The value in the count array for position 3 is 3, for position 4 it is 1. \\n  * The maximum value is reached only for position 3, so the algorithm will uniquely select this position for number 4. \\n\\n\\n\\nSatisfied with his purchase, Denis went home. For several days without a break, he generated permutations. He believes that he can come up with...\\nSolve the task in PYTHON3.\",\"targets\":\"import math\\nimport collections\\nimport sys\\ninput = sys.stdin.readline\\ndef check(a, start):\\n    count = 0\\n    for i in a[::-1]:\\n        if i == start+count:\\n            count+=1\\n        else:\\n            return False\\n    return True\\ndef solve():\\n    n = int(input())\\n    a = list(map(int, input().split()))\\n    z = []\\n    find = 1\\n    while a:\\n        z.append(a[-1])\\n        if find == a[-1]:\\n            if check(z, find):\\n                find = max(z)+1\\n                z = []\\n            else:\\n                print(\\\"No\\\")\\n                return\\n        a.pop()\\n    if not z:\\n        print(\\\"Yes\\\")\\n    else:\\n        print(\\\"No\\\")\\nfor _ in range(int(input())):\\n    solve()\",\"language\":\"python\",\"split\":\"train\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"After the mysterious disappearance of Ashish, his two favourite disciples Ishika and Hriday, were each left with one half of a secret message. These messages can each be represented by a permutation of size n. Let's call them a and b.\\n\\nNote that a permutation of n elements is a sequence of numbers a_1, a_2, \u2026, a_n, in which every number from 1 to n appears exactly once. \\n\\nThe message can be decoded by an arrangement of sequence a and b, such that the number of matching pairs of elements between them is maximum. A pair of elements a_i and b_j is said to match if: \\n\\n  * i = j, that is, they are at the same index. \\n  * a_i = b_j \\n\\n\\n\\nHis two disciples are allowed to perform the following operation any number of times: \\n\\n  * choose a number k and cyclically shift one of the permutations to the left or right k times. \\n\\n\\n\\nA single cyclic shift to the left on any permutation c is an operation that sets c_1:=c_2, c_2:=c_3, \u2026, c_n:=c_1 simultaneously. Likewise, a single cyclic shift to the right on any permutation c is an operation that sets c_1:=c_n, c_2:=c_1, \u2026, c_n:=c_{n-1} simultaneously.\\n\\nHelp Ishika and Hriday find the maximum number of pairs of elements that match after performing the operation any (possibly zero) number of times.\\n\\nInput\\n\\nThe first line of the input contains a single integer n (1 \u2264 n \u2264 2 \u22c5 10^5) \u2014 the size of the arrays.\\n\\nThe second line contains n integers a_1, a_2, ..., a_n (1 \u2264 a_i \u2264 n) \u2014 the elements of the first permutation.\\n\\nThe third line contains n integers b_1, b_2, ..., b_n (1 \u2264 b_i \u2264 n) \u2014 the elements of the second permutation.\\n\\nOutput\\n\\nPrint the maximum number of matching pairs of elements after performing the above operations some (possibly zero) times.\\n\\nExamples\\n\\nInput\\n\\n\\n5\\n1 2 3 4 5\\n2 3 4 5 1\\n\\n\\nOutput\\n\\n\\n5\\n\\nInput\\n\\n\\n5\\n5 4 3 2 1\\n1 2 3 4 5\\n\\n\\nOutput\\n\\n\\n1\\n\\nInput\\n\\n\\n4\\n1 3 2 4\\n4 2 3 1\\n\\n\\nOutput\\n\\n\\n2\\n\\nNote\\n\\nFor the first case: b can be shifted to the right by k = 1. The resulting permutations will be \\\\{1, 2, 3, 4, 5\\\\} and \\\\{1, 2, 3, 4, 5\\\\}.\\n\\nFor the second case: The operation is not required....\\nUsing python3 can you solve the prior task?\",\"targets\":\"n = int(input())\\nM = [0 for i in range(n)]\\na = input().split()\\nb = input().split()\\nfor i in range(n):\\n  M[ int(a[i]) - 1] = i\\nfor i in range(n):\\n  t = i - M[ int(b[i]) - 1]\\n  if t < 0:\\n    M[ int(b[i]) - 1] = n + t\\n  else:\\n    M[ int(b[i]) - 1] = t\\nR = [0 for i in range(n)]\\nfor i in range(n):\\n  R[M[i]] += 1\\nprint(max(R))\",\"language\":\"python\",\"split\":\"train\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"JAVA solution for \\\"Alice has just learned addition. However, she hasn't learned the concept of \\\"carrying\\\" fully \u2014 instead of carrying to the next column, she carries to the column two columns to the left.\\n\\nFor example, the regular way to evaluate the sum 2039 + 2976 would be as shown: \\n\\n<image>\\n\\nHowever, Alice evaluates it as shown: \\n\\n<image>\\n\\nIn particular, this is what she does: \\n\\n  * add 9 and 6 to make 15, and carry the 1 to the column two columns to the left, i. e. to the column \\\"0 9\\\"; \\n  * add 3 and 7 to make 10 and carry the 1 to the column two columns to the left, i. e. to the column \\\"2 2\\\"; \\n  * add 1, 0, and 9 to make 10 and carry the 1 to the column two columns to the left, i. e. to the column above the plus sign; \\n  * add 1, 2 and 2 to make 5; \\n  * add 1 to make 1. \\n\\nThus, she ends up with the incorrect result of 15005.\\n\\nAlice comes up to Bob and says that she has added two numbers to get a result of n. However, Bob knows that Alice adds in her own way. Help Bob find the number of ordered pairs of positive integers such that when Alice adds them, she will get a result of n. Note that pairs (a, b) and (b, a) are considered different if a \u2260 b.\\n\\nInput\\n\\nThe input consists of multiple test cases. The first line contains an integer t (1 \u2264 t \u2264 1000) \u2014 the number of test cases. The description of the test cases follows.\\n\\nThe only line of each test case contains an integer n (2 \u2264 n \u2264 10^9) \u2014 the number Alice shows Bob.\\n\\nOutput\\n\\nFor each test case, output one integer \u2014 the number of ordered pairs of positive integers such that when Alice adds them, she will get a result of n. \\n\\nExample\\n\\nInput\\n\\n\\n5\\n100\\n12\\n8\\n2021\\n10000\\n\\n\\nOutput\\n\\n\\n9\\n4\\n7\\n44\\n99\\n\\nNote\\n\\nIn the first test case, when Alice evaluates any of the sums 1 + 9, 2 + 8, 3 + 7, 4 + 6, 5 + 5, 6 + 4, 7 + 3, 8 + 2, or 9 + 1, she will get a result of 100. The picture below shows how Alice evaluates 6 + 4: \\n\\n<image>\\\":\",\"targets\":\"import java.io.BufferedReader;\\nimport java.io.IOException;\\nimport java.io.InputStreamReader;\\nimport java.util.StringTokenizer;\\n\\npublic class CF1 {\\n    public static void main(String[] args) {\\n        FastScanner sc=new FastScanner();\\n        int T=sc.nextInt();\\n        for (int tt=0; tt<T; tt++) {\\n            int n = sc.nextInt();\\n            int a =0;\\n            int b =0;\\n            int x=1;\\n            int mul1=1;\\n            int mul2=1;\\n            while (n>0){\\n                if ((x&1)==1){\\n                    a+=mul1* (n%10);\\n                    mul1*=10;\\n                    n\\/=10;\\n                    x=0;\\n                }\\n                else {\\n                    b+=mul2* (n%10);\\n                    mul2*=10;\\n                    n\\/=10;\\n                    x=1;\\n                }\\n            }\\n            System.out.println((a+1)*(b+1)-2);\\n        }\\n    }\\n\\n    static class FastScanner {\\n        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));\\n        StringTokenizer st=new StringTokenizer(\\\"\\\");\\n        String next() {\\n            while (!st.hasMoreTokens())\\n                try {\\n                    st=new StringTokenizer(br.readLine());\\n                } catch (IOException e) {\\n                    e.printStackTrace();\\n                }\\n            return st.nextToken();\\n        }\\n\\n        int nextInt() {\\n            return Integer.parseInt(next());\\n        }\\n        int[] readArray(int n) {\\n            int[] a=new int[n];\\n            for (int i=0; i<n; i++) a[i]=nextInt();\\n            return a;\\n        }\\n        long nextLong() {\\n            return Long.parseLong(next());\\n        }\\n    }\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Alena has successfully passed the entrance exams to the university and is now looking forward to start studying.\\n\\nOne two-hour lesson at the Russian university is traditionally called a pair, it lasts for two academic hours (an academic hour is equal to 45 minutes).\\n\\nThe University works in such a way that every day it holds exactly n lessons. Depending on the schedule of a particular group of students, on a given day, some pairs may actually contain classes, but some may be empty (such pairs are called breaks).\\n\\nThe official website of the university has already published the schedule for tomorrow for Alena's group. Thus, for each of the n pairs she knows if there will be a class at that time or not.\\n\\nAlena's House is far from the university, so if there are breaks, she doesn't always go home. Alena has time to go home only if the break consists of at least two free pairs in a row, otherwise she waits for the next pair at the university.\\n\\nOf course, Alena does not want to be sleepy during pairs, so she will sleep as long as possible, and will only come to the first pair that is presented in her schedule. Similarly, if there are no more pairs, then Alena immediately goes home.\\n\\nAlena appreciates the time spent at home, so she always goes home when it is possible, and returns to the university only at the beginning of the next pair. Help Alena determine for how many pairs she will stay at the university. Note that during some pairs Alena may be at the university waiting for the upcoming pair.\\n\\nInput\\n\\nThe first line of the input contains a positive integer n (1 \u2264 n \u2264 100) \u2014 the number of lessons at the university. \\n\\nThe second line contains n numbers ai (0 \u2264 ai \u2264 1). Number ai equals 0, if Alena doesn't have the i-th pairs, otherwise it is equal to 1. Numbers a1, a2, ..., an are separated by spaces.\\n\\nOutput\\n\\nPrint a single number \u2014 the number of pairs during which Alena stays at the university.\\n\\nExamples\\n\\nInput\\n\\n5\\n0 1 0 1 1\\n\\n\\nOutput\\n\\n4\\n\\n\\nInput\\n\\n7\\n1 0 1 0 0 1 0\\n\\n\\nOutput\\n\\n4\\n\\n\\nInput\\n\\n1\\n0\\n\\n\\nOutput\\n\\n0\\n\\nNote\\n\\nIn the...\\nUsing cpp can you solve the prior task?\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint n, m;\\nconst int N = 10000010;\\nint a[N];\\nint main() {\\n  cin >> n;\\n  for (int i = 1; i <= n; i++) {\\n    cin >> a[i];\\n  }\\n  int ans = 0;\\n  for (int i = 1; i <= n; i++) {\\n    if (a[i] == 1) {\\n      ans++;\\n    }\\n  }\\n  for (int i = 2; i < n; i++) {\\n    if (a[i] == 0 and a[i + 1] == 1 and a[i - 1] == 1) {\\n      ans++;\\n    }\\n  }\\n  cout << ans << endl;\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in PYTHON3?\\nVupsen and Pupsen were gifted an integer array. Since Vupsen doesn't like the number 0, he threw away all numbers equal to 0 from the array. As a result, he got an array a of length n.\\n\\nPupsen, on the contrary, likes the number 0 and he got upset when he saw the array without zeroes. To cheer Pupsen up, Vupsen decided to come up with another array b of length n such that \u2211_{i=1}^{n}a_i \u22c5 b_i=0. Since Vupsen doesn't like number 0, the array b must not contain numbers equal to 0. Also, the numbers in that array must not be huge, so the sum of their absolute values cannot exceed 10^9. Please help Vupsen to find any such array b!\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 100) \u2014 the number of test cases. The next 2 \u22c5 t lines contain the description of test cases. The description of each test case consists of two lines.\\n\\nThe first line of each test case contains a single integer n (2 \u2264 n \u2264 10^5) \u2014 the length of the array.\\n\\nThe second line contains n integers a_1, a_2, \u2026, a_n (-10^4 \u2264 a_i \u2264 10^4, a_i \u2260 0) \u2014 the elements of the array a.\\n\\nIt is guaranteed that the sum of n over all test cases does not exceed 2 \u22c5 10^5.\\n\\nOutput\\n\\nFor each test case print n integers b_1, b_2, \u2026, b_n \u2014 elements of the array b (|b_1|+|b_2|+\u2026 +|b_n| \u2264 10^9, b_i \u2260 0, \u2211_{i=1}^{n}a_i \u22c5 b_i=0).\\n\\nIt can be shown that the answer always exists.\\n\\nExample\\n\\nInput\\n\\n\\n3\\n2\\n5 5\\n5\\n5 -2 10 -9 4\\n7\\n1 2 3 4 5 6 7\\n\\n\\nOutput\\n\\n\\n1 -1\\n-1 5 1 -1 -1\\n-10 2 2 -3 5 -1 -1\\n\\nNote\\n\\nIn the first test case, 5 \u22c5 1 + 5 \u22c5 (-1)=5-5=0. You could also print 3 -3, for example, since 5 \u22c5 3 + 5 \u22c5 (-3)=15-15=0\\n\\nIn the second test case, 5 \u22c5 (-1) + (-2) \u22c5 5 + 10 \u22c5 1 + (-9) \u22c5 (-1) + 4 \u22c5 (-1)=-5-10+10+9-4=0.\",\"targets\":\"def bsdk(ans, i,j,k):\\n    ans.append(-(i+j) ,k,k)\\nt = int(input())\\nfor q in range(t):\\n    n = int(input())\\n    arr = [int(x) for x in input().split()]\\n    if n%2 == 0:\\n        ans = []\\n        for i in range(n\\/\\/2):\\n            ans.append(-arr[2*i+1])\\n            ans.append(arr[2*i])\\n        print(*ans)    \\n    else:\\n        ans = []\\n        if (arr[1]+ arr[0])!= 0:\\n            ans.append(arr[2])\\n            ans.append(arr[2], )\\n            ans.append( -(arr[0]+ arr[1]))\\n        elif (arr[1] + arr[2]) != 0:\\n            ans.append(-(arr[1] + arr[2]))\\n            ans.append(arr[0])\\n            ans.append(arr[0])\\n        else :\\n            ans.append(arr[1])\\n            ans.append(-(arr[2] + arr[0]) )\\n            ans.append(arr[1])\\n        arr.pop(0)\\n        arr.pop(0)\\n        arr.pop(0)\\n        n = n-3\\n        for i in range(n\\/\\/2):\\n            ans.append(-arr[2*i+1])\\n            ans.append(arr[2*i])\\n        print(*ans)    \\n        \\n\\n\\n\\n\\n\\n    # ans = [1 for i in range(n)]    \\n    # s = sum(arr)\\n    # i = n-1\\n    # while(s!= 0 and i >=0):\\n    #     a = s\\/\\/arr[i]\\n    #     ans[i] -= a\\n    #     s -= a*arr[i]\\n    #     i -= 1\\n\\n    # print(*ans)\",\"language\":\"python\",\"split\":\"test\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You are given an array a of length n.\\n\\nLet's define the eversion operation. Let x = a_n. Then array a is partitioned into two parts: left and right. The left part contains the elements of a that are not greater than x (\u2264 x). The right part contains the elements of a that are strictly greater than x (> x). The order of elements in each part is kept the same as before the operation, i. e. the partition is stable. Then the array is replaced with the concatenation of the left and the right parts.\\n\\nFor example, if the array a is [2, 4, 1, 5, 3], the eversion goes like this: [2, 4, 1, 5, 3] \u2192 [2, 1, 3], [4, 5] \u2192 [2, 1, 3, 4, 5].\\n\\nWe start with the array a and perform eversions on this array. We can prove that after several eversions the array a stops changing. Output the minimum number k such that the array stops changing after k eversions.\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 100). Description of the test cases follows.\\n\\nThe first line contains a single integer n (1 \u2264 n \u2264 2 \u22c5 10^5).\\n\\nThe second line contains n integers a_1, a_2, ..., a_n (1 \u2264 a_i \u2264 10^9).\\n\\nIt is guaranteed that the sum of n over all test cases does not exceed 2 \u22c5 10^5.\\n\\nOutput\\n\\nFor each test case print a single integer k \u2014 the number of eversions after which the array stops changing.\\n\\nExample\\n\\nInput\\n\\n\\n3\\n5\\n2 4 1 5 3\\n5\\n5 3 2 4 1\\n4\\n1 1 1 1\\n\\n\\nOutput\\n\\n\\n1\\n2\\n0\\n\\nNote\\n\\nConsider the fist example.\\n\\n  * The first eversion: a = [1, 4, 2, 5, 3], x = 3. [2, 4, 1, 5, 3] \u2192 [2, 1, 3], [4, 5] \u2192 [2, 1, 3, 4, 5]. \\n  * The second and following eversions: a = [2, 1, 3, 4, 5], x = 5. [2, 1, 3, 4, 5] \u2192 [2, 1, 3, 4, 5], [] \u2192 [2, 1, 3, 4, 5]. This eversion does not change the array, so the answer is 1. \\n\\n\\n\\nConsider the second example. \\n\\n  * The first eversion: a = [5, 3, 2, 4, 1], x = 1. [5, 3, 2, 4, 1] \u2192 [1], [5, 3, 2, 4] \u2192 [1, 5, 3, 2, 4]. \\n  * The second eversion: a = [1, 5, 3, 2, 4], x = 4. [1, 5, 3, 2, 4] \u2192 [1, 3, 2, 4], [5] \u2192 [1, 3, 2, 4, 5]. \\n  * The third and following eversions: a = [1, 3, 2, 4,...\\nThe above is tricky. Write me a correct solution in JAVA.\",\"targets\":\"import java.util.*;\\npublic class Codeforces {\\n\\n\\n\\t\\/\\/ CHECK CONSTRAINTS ALWAYS EDGE CASE MISSED \\n\\t\\nstatic int mod = 1000000007;\\t\\n public static void main(String[] args) {\\n\\nScanner sc=  new Scanner(System.in);\\nwhile(sc.hasNext()) {\\n\\nint t   =sc.nextInt();\\nwhile(t-->0) {\\n\\nint n  =  sc.nextInt();\\nint a[] = new int[n];\\nint max  = Integer.MIN_VALUE;\\nint mi = -1;\\nfor(int i = 0 ;  i<n;i++) {\\n\\ta[i] = sc.nextInt();\\n\\n\\tif(max<a[i]) {\\n\\t\\tmax  = a[i];\\n\\t\\tmi = i;\\n\\t}\\n}\\n\\nint check = 0;\\nint cnt = 0;\\nfor(int i  = n-1 ;  i>=0 ; i--) {\\n\\tif(a[i] == max) {\\n\\t\\tbreak;\\n\\t}\\n\\telse {\\n\\tif(a[i] > check) {\\n\\t\\tcheck = a[i];\\n\\t\\tcnt++;\\n\\t}\\n\\t}\\n}\\n\\nSystem.out.println(cnt);\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\t\\n\\t\\n\\t\\n\\t\\n\\t\\n\\t\\n\\t\\n\\t\\n\\t\\n\\t\\n}\\n}\\n} \\n\\n\\n\\n\\n\\n\\n\\n\\n\\t\\n\\n\\n\\n \\n static void primeFactors(long n , ArrayList<Integer> al) {\\n\\t while(n%2 == 0) {\\n\\t\\t al.add(2);\\n\\t\\t n  = n\\/2;\\n\\t }\\n\\t\\n\\t for(int i = 3 ; i*i<= n;i+=2) {\\n\\t\\t while(n%i == 0) {\\n\\t\\t\\t al.add(i);\\n\\t\\t\\t n = n\\/i;\\n\\t\\t }\\n\\t }\\n\\t\\n\\tif(n>2) {\\n\\t\\tal.add((int) n);\\n\\t}\\n }\\n \\n \\n \\n static class Pair implements Comparable<Pair>{\\n\\t int a;\\n\\t int b;\\n\\t Pair(int a, int b){\\n\\t\\t this.a = a;\\n\\t\\t this.b = b;\\n\\t }\\n\\t@Override\\n\\tpublic int compareTo(Pair o) {\\n\\t\\t\\/\\/ TODO Auto-generated method stub\\n\\tint temp =  this.a - o.a;\\n\\tif(temp == 0) {\\n\\t  return this.b - o.b;\\t\\n\\t}\\n\\telse {\\n\\treturn temp;\\t\\n\\t}\\n\\t\\n\\t\\n\\t}\\n\\t \\n\\t \\n }\\n \\n \\n \\n \\n static long gcd(long a ,  long b) {\\n\\t if(b == 0) {\\n\\t\\t return a;\\n\\t }\\n\\t \\n\\t return gcd(b, a%b);\\n }\\n \\n \\n  static boolean isPalindrome(int a[]) {\\n\\t  int i= 0;\\n\\t  int j = a.length - 1;\\n\\t  \\n\\t  while(i<=j) {\\n\\t\\t  if(a[i] != a[j]) {\\n\\t\\t      return false;\\t  \\n\\t\\t  }\\n\\t\\t  i++;\\n\\t\\t  j--;\\n\\t  }\\n\\t  \\n\\t  return true;\\n\\t  \\n  }\\n \\n \\n \\n static boolean isSubsequence(String a , String b) {\\n\\t \\n\\tint i = 0 , j = 0;\\n\\twhile(i<a.length() && j<b.length()) {\\n\\t\\t\\n\\t\\tif(a.charAt(i) == b.charAt(j)) {\\n\\t\\t\\ti++;\\n\\t\\t\\tj++;\\n\\t\\t}\\n\\t\\telse {\\n\\t\\t\\tj++;\\n\\t\\t}\\n\\t}\\n\\t\\n\\tif(i == a.length()) {\\n\\t\\treturn true;\\n\\t}\\n\\treturn false;\\n\\t\\n }\\n\\n \\n \\n \\n \\n }\",\"language\":\"python\",\"split\":\"test\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Given n, find any array a_1, a_2, \u2026, a_n of integers such that all of the following conditions hold: \\n\\n  * 1 \u2264 a_i \u2264 10^9 for every i from 1 to n.\\n\\n  * a_1 < a_2 < \u2026 <a_n\\n\\n  * For every i from 2 to n, a_i isn't divisible by a_{i-1}\\n\\n\\n\\n\\nIt can be shown that such an array always exists under the constraints of the problem.\\n\\nInput\\n\\nThe first line contains the number of test cases t (1 \u2264 t \u2264 100). Description of the test cases follows.\\n\\nThe only line of each test case contains a single integer n (1 \u2264 n \u2264 1000).\\n\\nIt is guaranteed that the sum of n over all test cases does not exceed 10^4.\\n\\nOutput\\n\\nFor each test case print n integers a_1, a_2, \u2026, a_n \u2014 the array you found. If there are multiple arrays satisfying all the conditions, print any of them.\\n\\nExample\\n\\nInput\\n\\n\\n3\\n1\\n2\\n7\\n\\n\\nOutput\\n\\n\\n1\\n2 3\\n111 1111 11111 111111 1111111 11111111 111111111\\n\\nNote\\n\\nIn the first test case, array [1] satisfies all the conditions.\\n\\nIn the second test case, array [2, 3] satisfies all the conditions, as 2<3 and 3 is not divisible by 2.\\n\\nIn the third test case, array [111, 1111, 11111, 111111, 1111111, 11111111, 111111111] satisfies all the conditions, as it's increasing and a_i isn't divisible by a_{i-1} for any i from 2 to 7.\\nThe above is tricky. Write me a correct solution in JAVA.\",\"targets\":\"import java.util.Scanner;\\n\\npublic class MyClass {\\n    \\n    static Scanner in=new Scanner(System.in);\\n    \\n    public static void main(String args[]) {\\n      \\n      int testCases=in.nextInt();\\n      \\n      for(int t=0;t<testCases;t++){\\n          \\n          int n=in.nextInt();\\n          \\n          if(n==1){\\n              \\n              System.out.println(1);\\n              \\n              continue;\\n              \\n          }\\n          \\n          int i=2;\\n          \\n          int time=1;\\n          \\n          for( i=n;i<=n*2 && time<=n;i++){\\n             \\n             System.out.print(i+\\\" \\\");\\n             \\n             i++;\\n             \\n             time++;\\n             \\n             if(time<=n){\\n             \\n             System.out.print(i+\\\" \\\");\\n              \\n             }\\n              \\n              ++time;\\n              \\n          }\\n          \\n         System.out.println();\\n          \\n      }\\n      \\n    }\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Stephen Queen wants to write a story. He is a very unusual writer, he uses only letters 'a', 'b', 'c', 'd' and 'e'!\\n\\nTo compose a story, Stephen wrote out n words consisting of the first 5 lowercase letters of the Latin alphabet. He wants to select the maximum number of words to make an interesting story.\\n\\nLet a story be a sequence of words that are not necessarily different. A story is called interesting if there exists a letter which occurs among all words of the story more times than all other letters together.\\n\\nFor example, the story consisting of three words \\\"bac\\\", \\\"aaada\\\", \\\"e\\\" is interesting (the letter 'a' occurs 5 times, all other letters occur 4 times in total). But the story consisting of two words \\\"aba\\\", \\\"abcde\\\" is not (no such letter that it occurs more than all other letters in total).\\n\\nYou are given a sequence of n words consisting of letters 'a', 'b', 'c', 'd' and 'e'. Your task is to choose the maximum number of them to make an interesting story. If there's no way to make a non-empty story, output 0.\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 5000) \u2014 the number of test cases. Then t test cases follow.\\n\\nThe first line of each test case contains one integer n (1 \u2264 n \u2264 2 \u22c5 10^5) \u2014 the number of the words in the sequence. Then n lines follow, each of them contains a word \u2014 a non-empty string consisting of lowercase letters of the Latin alphabet. The words in the sequence may be non-distinct (i. e. duplicates are allowed). Only the letters 'a', 'b', 'c', 'd' and 'e' may occur in the words.\\n\\nIt is guaranteed that the sum of n over all test cases doesn't exceed 2 \u22c5 10^5; the sum of the lengths of all words over all test cases doesn't exceed 4 \u22c5 10^5.\\n\\nOutput\\n\\nFor each test case, output the maximum number of words that compose an interesting story. Print 0 if there's no way to make a non-empty interesting story.\\n\\nExample\\n\\nInput\\n\\n\\n6\\n3\\nbac\\naaada\\ne\\n3\\naba\\nabcde\\naba\\n2\\nbaba\\nbaba\\n4\\nab\\nab\\nc\\nbc\\n5\\ncbdca\\nd\\na\\nd\\ne\\n3\\nb\\nc\\nca\\n\\n\\nOutput\\n\\n\\n3\\n2\\n0\\n2\\n3\\n2\\n\\nNote\\n\\nIn the first test case of the example, all 3 words...\",\"targets\":\"t = int(input())\\n\\ndef findCycle(start, offset, used, l):\\n    n=  len(l)\\n    cur = start\\n    while 1:\\n        used[cur] = True\\n        next = l[(cur+offset)%n]\\n        if used[next]:\\n            return used\\n        cur = next\\ndef calculateCycles(offset, l):\\n    n = len(l)\\n    used = [False for i in range(n)]\\n    tot = 0\\n    for i in range(n):\\n        if l[i] == (i+offset)%n:\\n            continue\\n        else:\\n            if used[l[i]] == True:\\n                continue\\n            else:\\n                tot += 1\\n                used = findCycle(l[i], offset, used, l)\\n    return tot\\nfor o in range(t):\\n    n = int(input())\\n    counts = [[] for i in range(5)]\\n    for i in range(n):\\n        d = {}\\n        l = input()\\n        m = len(l)\\n        for c in l:\\n            if c in d:\\n                d[c] = d[c] + 1\\n            else:\\n                d[c] = 1\\n        for j in range(5):\\n            c = chr(j + ord('a'))\\n            surplus = -m\\n            if c in d:\\n                surplus = 2*d[c] - m\\n            counts[j].append(surplus)\\n    mx = 0\\n    for i in range(5):\\n        cur = counts[i]\\n        cur = sorted(cur)\\n        tot = 0\\n        ind = 0\\n        while 1:\\n            tot += cur[-1 - ind]\\n            if tot <= 0:\\n                break\\n            if ind == (len(cur)-1):\\n                mx = len(cur)\\n                break\\n            ind += 1\\n            mx = max(mx, ind)\\n    print(mx)\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in CPP?\\nCapitalization is writing a word with its first letter as a capital letter. Your task is to capitalize the given word.\\n\\nNote, that during capitalization all the letters except the first one remains unchanged.\\n\\nInput\\n\\nA single line contains a non-empty word. This word consists of lowercase and uppercase English letters. The length of the word will not exceed 103.\\n\\nOutput\\n\\nOutput the given word after capitalization.\\n\\nExamples\\n\\nInput\\n\\nApPLe\\n\\n\\nOutput\\n\\nApPLe\\n\\n\\nInput\\n\\nkonjac\\n\\n\\nOutput\\n\\nKonjac\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint main() {\\n  string str;\\n  cin >> str;\\n  if (str[0] >= 'a' && str[0] <= 'z') str[0] = str[0] + ('A' - 'a');\\n  cout << str << endl;\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"Farmer John has a farm that consists of n pastures connected by one-directional roads. Each road has a weight, representing the time it takes to go from the start to the end of the road. The roads could have negative weight, where the cows go so fast that they go back in time! However, Farmer John guarantees that it is impossible for the cows to get stuck in a time loop, where they can infinitely go back in time by traveling across a sequence of roads. Also, each pair of pastures is connected by at most one road in each direction.\\n\\nUnfortunately, Farmer John lost the map of the farm. All he remembers is an array d, where d_i is the smallest amount of time it took the cows to reach the i-th pasture from pasture 1 using a sequence of roads. The cost of his farm is the sum of the weights of each of the roads, and Farmer John needs to know the minimal cost of a farm that is consistent with his memory.\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases. Then t cases follow.\\n\\nThe first line of each test case contains a single integer n (1 \u2264 n \u2264 10^5) \u2014 the number of pastures.\\n\\nThe second line of each test case contains n space separated integers d_1, d_2, \u2026, d_n (0 \u2264 d_i \u2264 10^9) \u2014 the array d. It is guaranteed that d_1 = 0.\\n\\nIt is guaranteed that the sum of n over all test cases does not exceed 10^5.\\n\\nOutput\\n\\nFor each test case, output the minimum possible cost of a farm that is consistent with Farmer John's memory.\\n\\nExample\\n\\nInput\\n\\n\\n3\\n3\\n0 2 3\\n2\\n0 1000000000\\n1\\n0\\n\\n\\nOutput\\n\\n\\n-3\\n0\\n0\\n\\nNote\\n\\nIn the first test case, you can add roads \\n\\n  * from pasture 1 to pasture 2 with a time of 2, \\n  * from pasture 2 to pasture 3 with a time of 1, \\n  * from pasture 3 to pasture 1 with a time of -3, \\n  * from pasture 3 to pasture 2 with a time of -1, \\n  * from pasture 2 to pasture 1 with a time of -2. \\n\\nThe total cost is 2 + 1 + -3 + -1 + -2 = -3.\\n\\nIn the second test case, you can add a road from pasture 1 to pasture 2 with cost 1000000000 and a road from pasture 2 to pasture 1 with cost...\\\":\",\"targets\":\"#include<bits\\/stdc++.h>\\nusing namespace std;\\nconst int maxn=1e5+10;\\nint d[maxn];\\nint main() {\\n\\tint T,n;\\n\\tscanf(\\\"%d\\\",&T);\\n\\twhile(T--) {\\n\\t\\tlong long ans=0,sum=0;\\n\\t\\tscanf(\\\"%d\\\",&n);\\n\\t\\tfor(int i=1;i<=n;i++)\\n\\t\\t\\tscanf(\\\"%d\\\",d+i);\\n\\t\\tsort(d+1,d+n+1);\\n\\t\\tfor(int i=2;i<=n;i++) {\\n\\t\\t\\tans+=1ll*d[i]*(i-1)-sum;\\n\\t\\t\\tsum+=d[i];\\n\\t\\t}\\n\\t\\tans-=d[n];\\n\\t\\tprintf(\\\"%lld\\\\n\\\",-ans);\\n\\t}\\n\\treturn 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in CPP?\\n<image>\\n\\nWilliam has two arrays a and b, each consisting of n items.\\n\\nFor some segments l..r of these arrays William wants to know if it is possible to equalize the values of items in these segments using a balancing operation. Formally, the values are equalized if for each i from l to r holds a_i = b_i.\\n\\nTo perform a balancing operation an even number of indices must be selected, such that l \u2264 pos_1 < pos_2 < ... < pos_k \u2264 r. Next the items of array a at positions pos_1, pos_3, pos_5, ... get incremented by one and the items of array b at positions pos_2, pos_4, pos_6, ... get incremented by one.\\n\\nWilliam wants to find out if it is possible to equalize the values of elements in two arrays for each segment using some number of balancing operations, and what is the minimal number of operations required for that. Note that for each segment the operations are performed independently.\\n\\nInput\\n\\nThe first line contains a two integers n and q (2 \u2264 n \u2264 10^5, 1 \u2264 q \u2264 10^5), the size of arrays a and b and the number of segments.\\n\\nThe second line contains n integers a_1, a_2, ..., a_n (0 \u2264 a_i \u2264 10^9).\\n\\nThe third line contains n integers b_1, b_2, ..., b_n (0 \u2264 b_i \u2264 10^9).\\n\\nEach of the next q lines contains two integers l_i and r_i (1 \u2264 l_i < r_i \u2264 n), the edges of segments.\\n\\nOutput\\n\\nFor each segment output a single number \u2014 the minimal number of balancing operations needed or \\\"-1\\\" if it is impossible to equalize segments of arrays.\\n\\nExample\\n\\nInput\\n\\n\\n8 5\\n0 1 2 9 3 2 7 5\\n2 2 1 9 4 1 5 8\\n2 6\\n1 7\\n2 4\\n7 8\\n5 8\\n\\n\\nOutput\\n\\n\\n1\\n3\\n1\\n-1\\n-1\\n\\nNote\\n\\nFor the first segment from 2 to 6 you can do one operation with pos = [2, 3, 5, 6], after this operation the arrays will be: a = [0, 2, 2, 9, 4, 2, 7, 5], b = [2, 2, 2, 9, 4, 2, 5, 8]. Arrays are equal on a segment from 2 to 6 after this operation.\\n\\nFor the second segment from 1 to 7 you can do three following operations: \\n\\n  1. pos = [1, 3, 5, 6] \\n  2. pos = [1, 7] \\n  3. pos = [2, 7] \\n\\n\\n\\nAfter these operations, the arrays will be: a = [2, 2, 2, 9, 4, 2, 7, 5], b = [2, 2, 2, 9, 4, 2, 7,...\",\"targets\":\"#include <bits\\/stdc++.h>\\n#pragma optimize(\\\"unroll-loops\\\")\\nusing namespace std;\\nconst long long N = 1 << 18;\\nconst long long M = 1e10 + 7;\\nint main() {\\n  ios_base::sync_with_stdio(0);\\n  cin.tie(0);\\n  cout.tie(0);\\n  long long n, kyu;\\n  cin >> n >> kyu;\\n  long long a[n];\\n  for (long long i = 0; i < n; i++) cin >> a[i];\\n  long long tmp, pre[n];\\n  for (long long i = 0; i < n; i++) {\\n    cin >> tmp;\\n    a[i] = tmp - a[i];\\n    pre[i] = a[i];\\n    if (i > 0) pre[i] += pre[i - 1];\\n  }\\n  long long st[n][17][2];\\n  for (long long i = 0; i < n; i++) st[i][0][0] = st[i][0][1] = pre[i];\\n  for (long long j = 1; j < 17; j++)\\n    for (long long i = 0; i < n; i++)\\n      if (i + (1 << j - 1) < n) {\\n        st[i][j][0] = min(st[i][j - 1][0], st[i + (1 << j - 1)][j - 1][0]);\\n        st[i][j][1] = max(st[i][j - 1][1], st[i + (1 << j - 1)][j - 1][1]);\\n      }\\n  while (kyu--) {\\n    long long l, r;\\n    cin >> l >> r;\\n    --l, --r;\\n    long long df = r - l + 1;\\n    df = log2(df);\\n    long long mn = min(st[l][df][0], st[r - (1 << df) + 1][df][0]);\\n    long long mx = max(st[l][df][1], st[r - (1 << df) + 1][df][1]);\\n    long long last = 0;\\n    if (l > 0) last = pre[l - 1];\\n    if (mn < last || pre[r] != last) {\\n      cout << -1 << '\\\\n';\\n      continue;\\n    }\\n    cout << mx - last << '\\\\n';\\n  }\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in CPP?\\nAndi and Budi were given an assignment to tidy up their bookshelf of n books. Each book is represented by the book title \u2014 a string s_i numbered from 1 to n, each with length m. Andi really wants to sort the book lexicographically ascending, while Budi wants to sort it lexicographically descending.\\n\\nSettling their fight, they decided to combine their idea and sort it asc-desc-endingly, where the odd-indexed characters will be compared ascendingly, and the even-indexed characters will be compared descendingly.\\n\\nA string a occurs before a string b in asc-desc-ending order if and only if in the first position where a and b differ, the following holds:\\n\\n  * if it is an odd position, the string a has a letter that appears earlier in the alphabet than the corresponding letter in b; \\n  * if it is an even position, the string a has a letter that appears later in the alphabet than the corresponding letter in b. \\n\\nInput\\n\\nThe first line contains two integers n and m (1 \u2264 n \u22c5 m \u2264 10^6).\\n\\nThe i-th of the next n lines contains a string s_i consisting of m uppercase Latin letters \u2014 the book title. The strings are pairwise distinct.\\n\\nOutput\\n\\nOutput n integers \u2014 the indices of the strings after they are sorted asc-desc-endingly.\\n\\nExample\\n\\nInput\\n\\n\\n5 2\\nAA\\nAB\\nBB\\nBA\\nAZ\\n\\n\\nOutput\\n\\n\\n5 2 1 3 4\\n\\nNote\\n\\nThe following illustrates the first example.\\n\\n<image>\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst int N = 2e5 + 5;\\nint n, m;\\nbool comp(pair<string, int> &a, pair<string, int> &b) {\\n  int id = 0;\\n  for (int i = 0; i < m; i++) {\\n    if (a.first[i] != b.first[i]) {\\n      id = i;\\n      break;\\n    }\\n  }\\n  if (id % 2 == 0) {\\n    return a.first[id] < b.first[id];\\n  } else {\\n    return a.first[id] > b.first[id];\\n  }\\n}\\nvoid TEST_CASES() {\\n  cin >> n >> m;\\n  vector<pair<string, int> > a(n);\\n  for (int i = 0; i < n; i++) {\\n    cin >> a[i].first;\\n    a[i].second = i + 1;\\n  }\\n  sort(a.begin(), a.end(), comp);\\n  for (auto &it : a) {\\n    cout << it.second << \\\" \\\";\\n  }\\n}\\nint32_t main() {\\n  ios_base::sync_with_stdio(false);\\n  cin.tie(nullptr);\\n  int t = 1;\\n  while (t--) {\\n    TEST_CASES();\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in CPP?\\nMolly Hooper has n different kinds of chemicals arranged in a line. Each of the chemicals has an affection value, The i-th of them has affection value ai.\\n\\nMolly wants Sherlock to fall in love with her. She intends to do this by mixing a contiguous segment of chemicals together to make a love potion with total affection value as a non-negative integer power of k. Total affection value of a continuous segment of chemicals is the sum of affection values of each chemical in that segment.\\n\\nHelp her to do so in finding the total number of such segments.\\n\\nInput\\n\\nThe first line of input contains two integers, n and k, the number of chemicals and the number, such that the total affection value is a non-negative power of this number k. (1 \u2264 n \u2264 105, 1 \u2264 |k| \u2264 10).\\n\\nNext line contains n integers a1, a2, ..., an ( - 109 \u2264 ai \u2264 109) \u2014 affection values of chemicals.\\n\\nOutput\\n\\nOutput a single integer \u2014 the number of valid segments.\\n\\nExamples\\n\\nInput\\n\\n4 2\\n2 2 2 2\\n\\n\\nOutput\\n\\n8\\n\\n\\nInput\\n\\n4 -3\\n3 -6 -3 12\\n\\n\\nOutput\\n\\n3\\n\\nNote\\n\\nDo keep in mind that k0 = 1.\\n\\nIn the first sample, Molly can get following different affection values: \\n\\n  * 2: segments [1, 1], [2, 2], [3, 3], [4, 4];\\n\\n  * 4: segments [1, 2], [2, 3], [3, 4];\\n\\n  * 6: segments [1, 3], [2, 4];\\n\\n  * 8: segments [1, 4]. \\n\\n\\n\\nOut of these, 2, 4 and 8 are powers of k = 2. Therefore, the answer is 8.\\n\\nIn the second sample, Molly can choose segments [1, 2], [3, 3], [3, 4].\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nstruct myhashi64 {\\n  size_t operator()(int64_t x) const {\\n    x = (x ^ (x >> 30)) * UINT64_C(0xbf58476d1ce4e5b9);\\n    x = (x ^ (x >> 27)) * UINT64_C(0x94d049bb133111eb);\\n    x = x ^ (x >> 31);\\n    return x;\\n  }\\n};\\nstatic int64_t cnt(const vector<int64_t> &ss, const vector<int64_t> &vkp) {\\n  int64_t sum = 0;\\n  unordered_map<int64_t, int64_t, myhashi64> r;\\n  for (int i = ss.size() - 1; i >= 0; i--) {\\n    for (auto kp : vkp) {\\n      auto v = r.find(kp + ss[i]);\\n      if (v != r.end()) sum += v->second;\\n    }\\n    r[ss[i]]++;\\n  }\\n  for (auto kp : vkp) {\\n    auto v = r.find(kp);\\n    if (v != r.end()) sum += v->second;\\n  }\\n  return sum;\\n}\\nint main(int argc, char **argv) {\\n  int n, k;\\n  cin >> n >> k;\\n  vector<int64_t> aa(n);\\n  vector<int64_t> ss(n, 0);\\n  for (int i = 0; i < n; i++) cin >> aa[i];\\n  ss[0] = aa[0];\\n  for (int i = 1; i < n; i++) ss[i] = ss[i - 1] + aa[i];\\n  int64_t sum = 0;\\n  if (abs(k) > 1) {\\n    vector<int64_t> vkp;\\n    for (int64_t kp = 1; abs(kp) <= 100000000000000; kp *= k) vkp.push_back(kp);\\n    sum = cnt(ss, vkp);\\n  } else if (k == -1) {\\n    sum = cnt(ss, vector<int64_t>{-1, 1});\\n  } else {\\n    sum = cnt(ss, vector<int64_t>{1});\\n  }\\n  cout << sum << endl;\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"JAVA solution for \\\"n people gathered to hold a jury meeting of the upcoming competition, the i-th member of the jury came up with a_i tasks, which they want to share with each other.\\n\\nFirst, the jury decides on the order which they will follow while describing the tasks. Let that be a permutation p of numbers from 1 to n (an array of size n where each integer from 1 to n occurs exactly once).\\n\\nThen the discussion goes as follows:\\n\\n  * If a jury member p_1 has some tasks left to tell, then they tell one task to others. Otherwise, they are skipped. \\n  * If a jury member p_2 has some tasks left to tell, then they tell one task to others. Otherwise, they are skipped. \\n  * ... \\n  * If a jury member p_n has some tasks left to tell, then they tell one task to others. Otherwise, they are skipped. \\n  * If there are still members with tasks left, then the process repeats from the start. Otherwise, the discussion ends. \\n\\n\\n\\nA permutation p is nice if none of the jury members tell two or more of their own tasks in a row. \\n\\nCount the number of nice permutations. The answer may be really large, so print it modulo 998 244 353.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases.\\n\\nThe first line of the test case contains a single integer n (2 \u2264 n \u2264 2 \u22c5 10^5) \u2014 number of jury members.\\n\\nThe second line contains n integers a_1, a_2, ..., a_n (1 \u2264 a_i \u2264 10^9) \u2014 the number of problems that the i-th member of the jury came up with.\\n\\nThe sum of n over all test cases does not exceed 2 \u22c5 10^5.\\n\\nOutput\\n\\nFor each test case, print one integer \u2014 the number of nice permutations, taken modulo 998 244 353.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n2\\n1 2\\n3\\n5 5 5\\n4\\n1 3 3 7\\n6\\n3 4 2 1 3 3\\n\\n\\nOutput\\n\\n\\n1\\n6\\n0\\n540\\n\\nNote\\n\\nExplanation of the first test case from the example:\\n\\nThere are two possible permutations, p = [1, 2] and p = [2, 1]. For p = [1, 2], the process is the following:\\n\\n  1. the first jury member tells a task; \\n  2. the second jury member tells a task; \\n  3. the first jury member doesn't have any tasks left to tell, so they are skipped;...\\\":\",\"targets\":\"import java.io.*;\\nimport java.util.*;\\n\\npublic class C {\\n    \\/\\/--------------------------INPUT READER--------------------------------\\/\\/\\n    static class fs {\\n        public BufferedReader br;\\n        StringTokenizer st = new StringTokenizer(\\\"\\\");\\n\\n        public fs() { this(System.in); }\\n        public fs(InputStream is) {\\n            br = new BufferedReader(new InputStreamReader(is));\\n        }\\n        String next() {\\n            while (!st.hasMoreTokens()) {\\n                try { st = new StringTokenizer(br.readLine()); }\\n                catch (IOException e) { e.printStackTrace(); }\\n            }\\n            return st.nextToken();\\n        }\\n\\n        int ni() { return Integer.parseInt(next()); }\\n        long nl() { return Long.parseLong(next()); }\\n        double nd() { return Double.parseDouble(next()); }\\n        String ns() { return next(); }\\n\\n        int[] na(int n) {\\n            int[] a = new int[n];\\n            for (int i = 0; i < n; i++) a[i] = ni();\\n            return a;\\n        }\\n    }\\n    \\/\\/-----------------------------------------------------------------------\\/\\/\\n\\n    \\/\\/---------------------------PRINTER-------------------------------------\\/\\/\\n    static class Printer {\\n        static PrintWriter w;\\n        public Printer() {this(System.out);}\\n        public Printer(OutputStream os) {\\n            w = new PrintWriter(os);\\n        }\\n        public void p(int i) {w.println(i);};\\n        public void p(long l) {w.println(l);};\\n        public void p(double d) {w.println(d);};\\n        public void p(String s) { w.println(s);};\\n        public void pr(int i) {w.println(i);};\\n        public void pr(long l) {w.print(l);};\\n        public void pr(double d) {w.print(d);};\\n        public void pr(String s) { w.print(s);};\\n        public void pl() {w.println();};\\n        public void close() {w.close();};\\n    }\\n    \\/\\/------------------------------------------------------------------------\\/\\/\\n\\n    \\/\\/--------------------------VARIABLES------------------------------------\\/\\/\\n    static fs sc = new fs();\\n    static...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Let's call a positive integer good if there is no digit 0 in its decimal representation.\\n\\nFor an array of a good numbers a, one found out that the sum of some two neighboring elements is equal to x (i.e. x = a_i + a_{i + 1} for some i). x had turned out to be a good number as well.\\n\\nThen the elements of the array a were written out one after another without separators into one string s. For example, if a = [12, 5, 6, 133], then s = 1256133.\\n\\nYou are given a string s and a number x. Your task is to determine the positions in the string that correspond to the adjacent elements of the array that have sum x. If there are several possible answers, you can print any of them.\\n\\nInput\\n\\nThe first line contains the string s (2 \u2264 |s| \u2264 5 \u22c5 10^5).\\n\\nThe second line contains an integer x (2 \u2264 x < 10^{200000}).\\n\\nAn additional constraint on the input: the answer always exists, i.e you can always select two adjacent substrings of the string s so that if you convert these substrings to integers, their sum is equal to x.\\n\\nOutput\\n\\nIn the first line, print two integers l_1, r_1, meaning that the first term of the sum (a_i) is in the string s from position l_1 to position r_1.\\n\\nIn the second line, print two integers l_2, r_2, meaning that the second term of the sum (a_{i + 1}) is in the string s from position l_2 to position r_2.\\n\\nExamples\\n\\nInput\\n\\n\\n1256133\\n17\\n\\n\\nOutput\\n\\n\\n1 2\\n3 3\\n\\n\\nInput\\n\\n\\n9544715561\\n525\\n\\n\\nOutput\\n\\n\\n2 3\\n4 6\\n\\n\\nInput\\n\\n\\n239923\\n5\\n\\n\\nOutput\\n\\n\\n1 1\\n2 2\\n\\n\\nInput\\n\\n\\n1218633757639\\n976272\\n\\n\\nOutput\\n\\n\\n2 7\\n8 13\\n\\nNote\\n\\nIn the first example s[1;2] = 12 and s[3;3] = 5, 12+5=17.\\n\\nIn the second example s[2;3] = 54 and s[4;6] = 471, 54+471=525.\\n\\nIn the third example s[1;1] = 2 and s[2;2] = 3, 2+3=5.\\n\\nIn the fourth example s[2;7] = 218633 and s[8;13] = 757639, 218633+757639=976272.\\nThe above is tricky. Write me a correct solution in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst int N = 500000;\\nmt19937 Rand(time(0));\\nint mod[3];\\nstruct hasher {\\n  int a[3];\\n  hasher(int x = 0) { a[0] = a[1] = a[2] = x; }\\n  friend hasher operator+(const hasher &a, const hasher &b) {\\n    hasher res;\\n    for (int i = 0; i < 3; ++i) {\\n      res.a[i] = a.a[i] + b.a[i];\\n      if (res.a[i] >= mod[i]) res.a[i] -= mod[i];\\n    }\\n    return res;\\n  }\\n  friend hasher operator-(const hasher &a, const hasher &b) {\\n    hasher res;\\n    for (int i = 0; i < 3; ++i) {\\n      res.a[i] = a.a[i] - b.a[i];\\n      if (res.a[i] < 0) res.a[i] += mod[i];\\n    }\\n    return res;\\n  }\\n  friend hasher operator*(const hasher &a, const hasher &b) {\\n    hasher res;\\n    for (int i = 0; i < 3; ++i) res.a[i] = 1LL * a.a[i] * b.a[i] % mod[i];\\n    return res;\\n  }\\n  friend bool operator==(const hasher &a, const hasher &b) {\\n    for (int i = 0; i < 3; ++i)\\n      if (a.a[i] != b.a[i]) return 0;\\n    return 1;\\n  }\\n  hasher inv() {\\n    hasher res = 1;\\n    for (int i = 0; i < 3; ++i) {\\n      int k = mod[i] - 2, x = a[i];\\n      for (; k; k >>= 1, x = 1LL * x * x % mod[i])\\n        if (k & 1) res.a[i] = 1LL * res.a[i] * x % mod[i];\\n    }\\n    return res;\\n  }\\n} pw[N + 9];\\nvoid Get_pw() {\\n  pw[0] = 1;\\n  pw[1] = 10;\\n  for (int i = 2; i <= N; ++i) pw[i] = pw[i - 1] * pw[1];\\n}\\nhasher Get_hash(hasher *h, int l, int r) {\\n  return h[r] - h[l - 1] * pw[r - l + 1];\\n}\\nhasher Get_hash(vector<hasher> &h, int l, int r) {\\n  return h[r] - h[l - 1] * pw[r - l + 1];\\n}\\nchar s[N + 9], t[N + 9];\\nint n, m;\\nvoid into() {\\n  scanf(\\\"%s%s\\\", s + 1, t + 1);\\n  n = strlen(s + 1);\\n  m = strlen(t + 1);\\n}\\nint Get_mod0() { return 19260817; }\\nbool Check_prime(int n) {\\n  for (int i = 2; i * i <= n; ++i)\\n    if (n % i == 0) return 0;\\n  return 1;\\n}\\nint Get_prime(int n) {\\n  for (; !Check_prime(n); ++n)\\n    ;\\n  return n;\\n}\\nint Get_mod1() {\\n  int sum = 0;\\n  for (int i = 1; i <= n; ++i) sum += s[i];\\n  for (int i = 1; i <= m; ++i) sum += t[i];\\n  int n = Rand() % 200000000 + 300000000 + sum;\\n  return Get_prime(n);\\n}\\nint Get_mod2() {\\n  int x =...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"Furik and Rubik love playing computer games. Furik has recently found a new game that greatly interested Rubik. The game consists of n parts and to complete each part a player may probably need to complete some other ones. We know that the game can be fully completed, that is, its parts do not form cyclic dependencies. \\n\\nRubik has 3 computers, on which he can play this game. All computers are located in different houses. Besides, it has turned out that each part of the game can be completed only on one of these computers. Let's number the computers with integers from 1 to 3. Rubik can perform the following actions: \\n\\n  * Complete some part of the game on some computer. Rubik spends exactly 1 hour on completing any part on any computer. \\n  * Move from the 1-st computer to the 2-nd one. Rubik spends exactly 1 hour on that. \\n  * Move from the 1-st computer to the 3-rd one. Rubik spends exactly 2 hours on that. \\n  * Move from the 2-nd computer to the 1-st one. Rubik spends exactly 2 hours on that. \\n  * Move from the 2-nd computer to the 3-rd one. Rubik spends exactly 1 hour on that. \\n  * Move from the 3-rd computer to the 1-st one. Rubik spends exactly 1 hour on that. \\n  * Move from the 3-rd computer to the 2-nd one. Rubik spends exactly 2 hours on that. \\n\\n\\n\\nHelp Rubik to find the minimum number of hours he will need to complete all parts of the game. Initially Rubik can be located at the computer he considers necessary. \\n\\nInput\\n\\nThe first line contains integer n (1 \u2264 n \u2264 200) \u2014 the number of game parts. The next line contains n integers, the i-th integer \u2014 ci (1 \u2264 ci \u2264 3) represents the number of the computer, on which you can complete the game part number i. \\n\\nNext n lines contain descriptions of game parts. The i-th line first contains integer ki (0 \u2264 ki \u2264 n - 1), then ki distinct integers ai, j (1 \u2264 ai, j \u2264 n; ai, j \u2260 i) \u2014 the numbers of parts to complete before part i.\\n\\nNumbers on all lines are separated by single spaces. You can assume that the parts of the game are numbered from 1 to n in some way. It is...\\\":\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint i, j, k, n, m, an;\\nint co[210], len[210], a[210][210], f[210];\\ninline bool ju(int x) {\\n  int i;\\n  for (i = 1; i <= len[x]; i++)\\n    if (!f[a[x][i]]) return 0;\\n  return 1;\\n}\\ninline void work(int x) {\\n  int s = 0, re = 0, i;\\n  for (i = 1; i <= n; i++) f[i] = 0;\\n  for (;;) {\\n    int F = 0;\\n    for (;;) {\\n      for (i = 1; i <= n; i++)\\n        if (!f[i] && co[i] == x && ju(i)) {\\n          F = 1;\\n          f[i] = 1;\\n          re++;\\n          s++;\\n          break;\\n        }\\n      if (!F) break;\\n      F = 0;\\n    }\\n    if (s == n) break;\\n    x++;\\n    if (x > 3) x = 1;\\n    re++;\\n  }\\n  an = min(an, re);\\n}\\nint main() {\\n  scanf(\\\"%d\\\", &n);\\n  for (i = 1; i <= n; i++) scanf(\\\"%d\\\", &co[i]);\\n  for (i = 1; i <= n; i++) {\\n    scanf(\\\"%d\\\", &len[i]);\\n    for (j = 1; j <= len[i]; j++) scanf(\\\"%d\\\", &a[i][j]);\\n  }\\n  an = 210 * 210;\\n  for (i = 1; i <= 3; i++) work(i);\\n  printf(\\\"%d\\\\n\\\", an);\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"During the hypnosis session, Nicholas suddenly remembered a positive integer n, which doesn't contain zeros in decimal notation. \\n\\nSoon, when he returned home, he got curious: what is the maximum number of digits that can be removed from the number so that the number becomes not prime, that is, either composite or equal to one?\\n\\nFor some numbers doing so is impossible: for example, for number 53 it's impossible to delete some of its digits to obtain a not prime integer. However, for all n in the test cases of this problem, it's guaranteed that it's possible to delete some of their digits to obtain a not prime number.\\n\\nNote that you cannot remove all the digits from the number.\\n\\nA prime number is a number that has no divisors except one and itself. A composite is a number that has more than two divisors. 1 is neither a prime nor a composite number.\\n\\nInput\\n\\nEach test contains multiple test cases.\\n\\nThe first line contains one positive integer t (1 \u2264 t \u2264 10^3), denoting the number of test cases. Description of the test cases follows.\\n\\nThe first line of each test case contains one positive integer k (1 \u2264 k \u2264 50) \u2014 the number of digits in the number.\\n\\nThe second line of each test case contains a positive integer n, which doesn't contain zeros in decimal notation (10^{k-1} \u2264 n < 10^{k}). It is guaranteed that it is always possible to remove less than k digits to make the number not prime.\\n\\nIt is guaranteed that the sum of k over all test cases does not exceed 10^4.\\n\\nOutput\\n\\nFor every test case, print two numbers in two lines. In the first line print the number of digits, that you have left in the number. In the second line print the digits left after all delitions. \\n\\nIf there are multiple solutions, print any.\\n\\nExample\\n\\nInput\\n\\n\\n7\\n3\\n237\\n5\\n44444\\n3\\n221\\n2\\n35\\n3\\n773\\n1\\n4\\n30\\n626221626221626221626221626221\\n\\n\\nOutput\\n\\n\\n2\\n27\\n1\\n4\\n1\\n1\\n2\\n35\\n2\\n77\\n1\\n4\\n1\\n6\\n\\nNote\\n\\nIn the first test case, you can't delete 2 digits from the number 237, as all the numbers 2, 3, and 7 are prime. However, you can delete 1 digit, obtaining a number 27 =...\\nThe above is tricky. Write me a correct solution in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst int N = 55;\\nchar a[N];\\nint flag[N];\\nvector<int> v[15];\\nvoid solve() {\\n  int q = 0, i, n, ans;\\n  memset(flag, 0, sizeof(flag));\\n  memset(a, '\\\\0', sizeof(a));\\n  scanf(\\\"%d%s\\\", &n, a + 1);\\n  for (i = 1; i <= n; ++i) {\\n    if (a[i] == '1' || a[i] == '4' || a[i] == '6' || a[i] == '8' ||\\n        a[i] == '9') {\\n      printf(\\\"1\\\\n\\\");\\n      printf(\\\"%c\\\\n\\\", a[i]);\\n      return;\\n    }\\n    flag[a[i] - '0']++;\\n    if (a[i] == '5' && (flag[3] || flag[2] || flag[7])) {\\n      q = 1;\\n      if (flag[3])\\n        ans = 3;\\n      else if (flag[2])\\n        ans = 2;\\n      else\\n        ans = 7;\\n    } else if (a[i] == '7' && (flag[2] || flag[5])) {\\n      if (flag[2]) {\\n        q = 2;\\n      } else {\\n        q = 5;\\n      }\\n    } else if (a[i] == '2' && i > 1) {\\n      q = 3;\\n    }\\n  }\\n  printf(\\\"2\\\\n\\\");\\n  if (q == 1) {\\n    printf(\\\"%d%d\\\\n\\\", ans, 5);\\n    return;\\n  } else if (q == 3) {\\n    printf(\\\"%c%d\\\\n\\\", a[1], 2);\\n    return;\\n  } else if (q > 0) {\\n    printf(\\\"%d%d\\\\n\\\", q, 7);\\n    return;\\n  }\\n  for (i = 1; i <= 9; ++i) {\\n    if (flag[i] > 1) {\\n      printf(\\\"%d%d\\\\n\\\", i, i);\\n      return;\\n    }\\n  }\\n}\\nint main() {\\n  int t;\\n  scanf(\\\"%d\\\", &t);\\n  while (t--) {\\n    solve();\\n  }\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Shohag has an integer sequence a_1, a_2, \u2026, a_n. He can perform the following operation any number of times (possibly, zero):\\n\\n  * Select any positive integer k (it can be different in different operations). \\n  * Choose any position in the sequence (possibly the beginning or end of the sequence, or in between any two elements) and insert k into the sequence at this position. \\n  * This way, the sequence a changes, and the next operation is performed on this changed sequence. \\n\\n\\n\\nFor example, if a=[3,3,4] and he selects k = 2, then after the operation he can obtain one of the sequences [\\\\underline{2},3,3,4], [3,\\\\underline{2},3,4], [3,3,\\\\underline{2},4], or [3,3,4,\\\\underline{2}].\\n\\nShohag wants this sequence to satisfy the following condition: for each 1 \u2264 i \u2264 |a|, a_i \u2264 i. Here, |a| denotes the size of a.\\n\\nHelp him to find the minimum number of operations that he has to perform to achieve this goal. We can show that under the constraints of the problem it's always possible to achieve this goal in a finite number of operations.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 200) \u2014 the number of test cases.\\n\\nThe first line of each test case contains a single integer n (1 \u2264 n \u2264 100) \u2014 the initial length of the sequence.\\n\\nThe second line of each test case contains n integers a_1, a_2, \u2026, a_n (1 \u2264 a_i \u2264 10^9) \u2014 the elements of the sequence.\\n\\nOutput\\n\\nFor each test case, print a single integer \u2014 the minimum number of operations needed to perform to achieve the goal mentioned in the statement.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n3\\n1 3 4\\n5\\n1 2 5 7 4\\n1\\n1\\n3\\n69 6969 696969\\n\\n\\nOutput\\n\\n\\n1\\n3\\n0\\n696966\\n\\nNote\\n\\nIn the first test case, we have to perform at least one operation, as a_2=3>2. We can perform the operation [1, 3, 4] \u2192 [1, \\\\underline{2}, 3, 4] (the newly inserted element is underlined), now the condition is satisfied.\\n\\nIn the second test case, Shohag can perform the following operations:\\n\\n[1, 2, 5, 7, 4] \u2192 [1, 2, \\\\underline{3}, 5, 7, 4] \u2192 [1, 2, 3, \\\\underline{4}, 5, 7, 4] \u2192 [1, 2, 3, 4, 5, \\\\underline{3}, 7, 4].\\n\\nIn the third...\",\"targets\":\"import java.io.BufferedReader;\\nimport java.io.IOException;\\nimport java.io.InputStreamReader;\\nimport java.util.*;\\npublic class A{\\n\\tpublic static void main(String[] args){\\n\\t\\tFastReader sc = new FastReader();\\n\\t\\tint t=sc.nextInt();\\n\\t\\twhile(t-->0){\\n\\t\\t\\tint n=sc.nextInt();\\n\\t\\t\\tint a[]=sc.fastArray(n);boolean check=false;\\n\\t\\t\\tint ans=0;\\n\\t\\t\\tif(a[0]!=1) {\\n\\t\\t\\t\\tans+=a[0]-1;\\n\\t\\t\\t\\tcheck=true;\\n\\t\\t\\t}\\n\\t\\t\\tfor(int i=1;i<n;i++) {\\n\\t\\t\\t\\tif((ans+i+1)<a[i]) {\\n\\t\\t\\t\\t\\tint add=a[i]-(i+1+ans);\\n\\t\\t\\t\\t\\tif(add>0)ans+=add;\\n\\t\\t\\t\\t\\tcheck=true;\\t\\n\\t\\t\\t\\t}\\n\\t\\t\\t}\\n\\t\\t\\tSystem.out.println(ans);\\n\\t\\t}\\t\\t \\n    }\\n\\n\\tstatic class pair {\\n\\t\\tint x;int y;\\n\\t\\t pair(int x,int y){\\n\\t\\t\\tthis.x=x;\\n\\t\\t\\tthis.y=y;\\n\\t\\t}\\n\\t\\t\\n\\t}\\n\\tstatic ArrayList<Integer> primeFac(int n){\\n\\t\\tArrayList<Integer>ans = new ArrayList<Integer>();\\n\\t\\tint lp[]=new int [n+1];\\n\\t\\tArrays.fill(lp, 0);  \\t\\/\\/0-prime\\n\\t\\tfor(int i=2;i<=n;i++) {\\n\\t\\t\\tif(lp[i]==0) {\\n\\t\\t\\t\\tfor(int j=i;j<=n;j+=i) {\\n\\t\\t\\t\\t\\tif(lp[j]==0) lp[j]=i;\\n\\t\\t\\t\\t}\\n\\t\\t\\t}\\n\\t\\t}\\n\\t\\tint fac=n;\\n\\t\\twhile(fac>1) {\\n\\t\\t\\tans.add(lp[fac]);\\n\\t\\t\\tfac=fac\\/lp[fac];\\n\\t\\t}\\n\\t\\tprint(ans);\\n\\t\\treturn ans;\\n\\t}\\n\\tstatic ArrayList<Long> prime_in_given_range(long l,long r){\\n\\t\\tArrayList<Long> ans= new ArrayList<>();\\n\\t\\tint n=(int)Math.sqrt(r)+1;\\n\\t\\tint prime[]=sieve_of_Eratosthenes(n);\\n\\t\\tlong res[]=new long [(int)(r-l)+1];\\n\\t\\tfor(int i=0;i<=r-l;i++) {\\n\\t\\t\\tres[i]=i+l;\\n\\t\\t}\\n\\t\\tfor(int i=0;i<prime.length;i++) {\\n\\t\\t\\tif(prime[i]==1) {\\n\\t\\t\\t\\tSystem.out.println(2);\\n\\t\\t\\t\\tfor(int j=Math.max((int)i*i, (int)(l+i-1)\\/i*i);j<=r;j+=i) {\\n\\t\\t\\t\\t\\tres[j-(int)l]=0; \\n\\t\\t\\t\\t}\\n\\t\\t\\t}\\n\\t\\t}\\n\\t\\tfor(long i:res) if(i!=0)ans.add(i);\\n\\t\\treturn ans;\\n\\t}\\n\\tstatic int [] sieve_of_Eratosthenes(int n) {\\n\\t\\tint prime[]=new int [n];\\n\\t\\tArrays.fill(prime, 1);  \\/\\/ 1-prime | 0-not prime\\n\\t\\tprime[0]=prime[1]=0;\\n\\t\\tfor(int i=2;i<n;i++) {\\n\\t\\t\\tif(prime[i]==1) {\\n\\t\\t\\t\\tfor(int j=i*i;j<n;j+=i) {\\n\\t\\t\\t\\t\\tprime[j]=0;\\n\\t\\t\\t\\t}\\n\\t\\t\\t}\\n\\t\\t}\\n\\t\\treturn prime;\\n\\t}\\n\\tstatic long binpow(long a,long b) {\\n\\t\\tlong res=1;\\n\\t\\tif(b==0)return a;\\n\\t\\tif(a==0)return 1;\\n\\t\\twhile(b>0) {\\n\\t\\t\\tif((b&1)==1) {\\n\\t\\t\\t\\tres*=a;\\n\\t\\t\\t}\\n\\t\\t\\ta*=a;\\n\\t\\t\\tb>>=1;\\n\\t\\t}\\n\\t\\treturn res;\\n\\t}\\n\\tstatic void print(int a[])...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"This is the easy version of the problem. The only difference from the hard version is that in this version all coordinates are even.\\n\\nThere are n fence-posts at distinct coordinates on a plane. It is guaranteed that no three fence posts lie on the same line.\\n\\nThere are an infinite number of cows on the plane, one at every point with integer coordinates.\\n\\nGregor is a member of the Illuminati, and wants to build a triangular fence, connecting 3 distinct existing fence posts. A cow strictly inside the fence is said to be enclosed. If there are an odd number of enclosed cows and the area of the fence is an integer, the fence is said to be interesting.\\n\\nFind the number of interesting fences.\\n\\nInput\\n\\nThe first line contains the integer n (3 \u2264 n \u2264 6000), the number of fence posts which Gregor can choose to form the vertices of a fence.\\n\\nEach of the next n line contains two integers x and y (0 \u2264 x,y \u2264 10^7, x and y are even), where (x,y) is the coordinate of a fence post. All fence posts lie at distinct coordinates. No three fence posts are on the same line.\\n\\nOutput\\n\\nPrint a single integer, the number of interesting fences. Two fences are considered different if they are constructed with a different set of three fence posts.\\n\\nExamples\\n\\nInput\\n\\n\\n3\\n0 0\\n2 0\\n0 4\\n\\n\\nOutput\\n\\n\\n1\\n\\n\\nInput\\n\\n\\n5\\n0 0\\n2 16\\n30 14\\n4 6\\n2 10\\n\\n\\nOutput\\n\\n\\n3\\n\\nNote\\n\\nIn the first example, there is only 1 fence. That fence is interesting since its area is 4 and there is 1 enclosed cow, marked in red.\\n\\n<image>\\n\\nIn the second example, there are 3 interesting fences. \\n\\n  * (0,0) \u2014 (30,14) \u2014 (2,10) \\n  * (2,16) \u2014 (30,14) \u2014 (2,10) \\n  * (30,14) \u2014 (4,6) \u2014 (2,10)\",\"targets\":\"n = int(input())\\nnum = [0, 0, 0, 0]\\n\\nfor _ in range(n):\\n    x, y = map(int, input().split())\\n    num[bool(x&2) + (y&2)] += 1\\n\\nprint((n*(n-1)*(n-2))\\/\\/6 - num[0]*num[1]*num[2] - num[0]*num[1]*num[3] - num[0]*num[2]*num[3] - num[1]*num[2]*num[3])\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You are given two positive integers n and s. Find the maximum possible median of an array of n non-negative integers (not necessarily distinct), such that the sum of its elements is equal to s.\\n\\nA median of an array of integers of length m is the number standing on the \u2308 {m\\/2} \u2309-th (rounding up) position in the non-decreasing ordering of its elements. Positions are numbered starting from 1. For example, a median of the array [20,40,20,50,50,30] is the \u2308 m\\/2 \u2309-th element of [20,20,30,40,50,50], so it is 30. There exist other definitions of the median, but in this problem we use the described definition.\\n\\nInput\\n\\nThe input consists of multiple test cases. The first line contains a single integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases. Description of the test cases follows.\\n\\nEach test case contains a single line with two integers n and s (1 \u2264 n, s \u2264 10^9) \u2014 the length of the array and the required sum of the elements.\\n\\nOutput\\n\\nFor each test case print a single integer \u2014 the maximum possible median.\\n\\nExample\\n\\nInput\\n\\n\\n8\\n1 5\\n2 5\\n3 5\\n2 1\\n7 17\\n4 14\\n1 1000000000\\n1000000000 1\\n\\n\\nOutput\\n\\n\\n5\\n2\\n2\\n0\\n4\\n4\\n1000000000\\n0\\n\\nNote\\n\\nPossible arrays for the first three test cases (in each array the median is underlined):\\n\\n  * In the first test case [\\\\underline{5}] \\n  * In the second test case [\\\\underline{2}, 3] \\n  * In the third test case [1, \\\\underline{2}, 2] \\nThe above is tricky. Write me a correct solution in PYTHON3.\",\"targets\":\"t = int(input())\\nfor i in range(t):\\n    n, s = map(int, input().split())\\n    if n % 2 == 0:\\n        m = n \\/\\/ 2 - 1\\n    else:\\n        m = n \\/\\/ 2\\n    print(s \\/\\/ (n - m))\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Anastasia loves going for a walk in Central Uzhlyandian Park. But she became uninterested in simple walking, so she began to collect Uzhlyandian pebbles. At first, she decided to collect all the pebbles she could find in the park.\\n\\nShe has only two pockets. She can put at most k pebbles in each pocket at the same time. There are n different pebble types in the park, and there are wi pebbles of the i-th type. Anastasia is very responsible, so she never mixes pebbles of different types in same pocket. However, she can put different kinds of pebbles in different pockets at the same time. Unfortunately, she can't spend all her time collecting pebbles, so she can collect pebbles from the park only once a day.\\n\\nHelp her to find the minimum number of days needed to collect all the pebbles of Uzhlyandian Central Park, taking into consideration that Anastasia can't place pebbles of different types in same pocket.\\n\\nInput\\n\\nThe first line contains two integers n and k (1 \u2264 n \u2264 105, 1 \u2264 k \u2264 109) \u2014 the number of different pebble types and number of pebbles Anastasia can place in one pocket.\\n\\nThe second line contains n integers w1, w2, ..., wn (1 \u2264 wi \u2264 104) \u2014 number of pebbles of each type. \\n\\nOutput\\n\\nThe only line of output contains one integer \u2014 the minimum number of days Anastasia needs to collect all the pebbles.\\n\\nExamples\\n\\nInput\\n\\n3 2\\n2 3 4\\n\\n\\nOutput\\n\\n3\\n\\n\\nInput\\n\\n5 4\\n3 1 8 9 7\\n\\n\\nOutput\\n\\n5\\n\\nNote\\n\\nIn the first sample case, Anastasia can collect all pebbles of the first type on the first day, of second type \u2014 on the second day, and of third type \u2014 on the third day.\\n\\nOptimal sequence of actions in the second sample case: \\n\\n  * In the first day Anastasia collects 8 pebbles of the third type. \\n  * In the second day she collects 8 pebbles of the fourth type. \\n  * In the third day she collects 3 pebbles of the first type and 1 pebble of the fourth type. \\n  * In the fourth day she collects 7 pebbles of the fifth type. \\n  * In the fifth day she collects 1 pebble of the second type. \\nimpor\",\"targets\":\"t java.io.*;\\nimport java.math.BigInteger;\\nimport java.util.*;\\nimport java.util.concurrent.*;\\npublic class Main {\\n    public static void main(String[] args) {\\n        InputStream inputStream = System.in;\\n        OutputStream outputStream = System.out;\\n        InputReader in = new InputReader(inputStream);\\n        PrintWriter out = new PrintWriter(outputStream);\\n        Solver solver = new Solver();\\n        solver.solve(in, out);\\n        out.close();\\n    }\\n    static class Solver {\\n        public void solve(InputReader in, PrintWriter out) {\\n            int n = in.nextInt();\\n            int k = in.nextInt();\\n            int[] w = new int[n];\\n            int tot = 0, nz = 0;\\n            for (int i = 0; i < n; ++i) {\\n                w[i] = in.nextInt();\\n                if (w[i] >= 2 * k) {\\n                    tot += w[i] \\/ (2 * k);\\n                    w[i] = w[i] % (2 * k);\\n                }\\n                if (w[i] > k) {\\n                    tot += 1;\\n                    w[i] = 0;\\n                }\\n                if (w[i] > 0) {\\n                    ++nz;\\n                }\\n            }\\n            tot += nz \\/ 2 + (nz % 2);\\n            out.println(tot);\\n        }\\n    } \\/\\/ wubba lubba dub dub\\n    static class InputReader {\\n        public BufferedReader reader;\\n        public StringTokenizer tokenizer;\\n        public InputReader(InputStream stream) {\\n            reader = new BufferedReader(new InputStreamReader(stream), 32768);\\n            tokenizer = null;\\n        }\\n        public String next() {\\n            while (tokenizer == null || !tokenizer.hasMoreElements()) {\\n                try {\\n                    tokenizer = new StringTokenizer(reader.readLine());\\n                } catch (IOException e) {\\n                    throw new RuntimeException(e);\\n                }\\n            }\\n            return tokenizer.nextToken();\\n        }\\n        public int nextInt() {\\n            return Integer.parseInt(next());\\n        }\\n        public long nextLong() {\\n            return Long.parseLong(next());\\n        }\\n       ...\",\"language\":\"python\",\"split\":\"train\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"A permutation of length n is an array consisting of n distinct integers from 1 to n in arbitrary order. For example, [2,3,1,5,4] is a permutation, but [1,2,2] is not a permutation (2 appears twice in the array) and [1,3,4] is also not a permutation (n=3 but there is 4 in the array).\\n\\nFor a positive integer n, we call a permutation p of length n good if the following condition holds for every pair i and j (1 \u2264 i \u2264 j \u2264 n) \u2014 \\n\\n  * (p_i  OR  p_{i+1}  OR  \u2026  OR  p_{j-1}  OR  p_{j}) \u2265 j-i+1, where OR denotes the [bitwise OR operation.](https:\\/\\/en.wikipedia.org\\/wiki\\/Bitwise_operation#OR)\\n\\n\\n\\nIn other words, a permutation p is good if for every subarray of p, the OR of all elements in it is not less than the number of elements in that subarray. \\n\\nGiven a positive integer n, output any good permutation of length n. We can show that for the given constraints such a permutation always exists.\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 100). Description of the test cases follows.\\n\\nThe first and only line of every test case contains a single integer n (1 \u2264 n \u2264 100).\\n\\nOutput\\n\\nFor every test, output any good permutation of length n on a separate line. \\n\\nExample\\n\\nInput\\n\\n\\n3\\n1\\n3\\n7\\n\\n\\nOutput\\n\\n\\n1\\n3 1 2\\n4 3 5 2 7 1 6\\n\\nNote\\n\\nFor n = 3, [3,1,2] is a good permutation. Some of the subarrays are listed below. \\n\\n  * 3 OR 1 = 3 \u2265 2 (i = 1,j = 2) \\n  * 3 OR 1 OR 2 = 3 \u2265 3 (i = 1,j = 3) \\n  * 1 OR 2 = 3 \u2265 2 (i = 2,j = 3) \\n  * 1 \u2265 1 (i = 2,j = 2) \\n\\n\\n\\nSimilarly, you can verify that [4,3,5,2,7,1,6] is also good.\\nUsing java can you solve the prior task?\",\"targets\":\"\\/*********CODE BY SHREY_SHREYANSH*********\\/\\n\\nimport java.io.BufferedReader;\\nimport java.io.IOException;\\nimport java.io.InputStreamReader;\\nimport java.util.Arrays;\\nimport java.util.Scanner;\\nimport java.util.StringTokenizer;\\n\\npublic class Main\\n{\\n    static class FastReader\\n    {\\n        BufferedReader br;\\n        StringTokenizer st;\\n\\n        public FastReader()\\n        {\\n            br = new BufferedReader(new\\n                    InputStreamReader(System.in));\\n        }\\n\\n        String next()\\n        {\\n            while (st == null || !st.hasMoreElements())\\n            {\\n                try\\n                {\\n                    st = new StringTokenizer(br.readLine());\\n                }\\n                catch (IOException  e)\\n                {\\n                    e.printStackTrace();\\n                }\\n            }\\n            return st.nextToken();\\n        }\\n\\n        int nextInt()\\n        {\\n            return Integer.parseInt(next());\\n        }\\n\\n        long nextLong()\\n        {\\n            return Long.parseLong(next());\\n        }\\n\\n        double nextDouble()\\n        {\\n            return Double.parseDouble(next());\\n        }\\n\\n        String nextLine()\\n        {\\n            String str = \\\"\\\";\\n            try\\n            {\\n                str = br.readLine();\\n            }\\n            catch (IOException e)\\n            {\\n                e.printStackTrace();\\n            }\\n            return str;\\n        }\\n    }\\n\\n    public static void main(String[] args)\\n    {\\n        FastReader sc =new FastReader();\\n        int T = sc.nextInt();\\n        while (T-- > 0) {\\n            int n = sc.nextInt();\\n            for(int i=1;i<=n;i++)\\n                System.out.print(i+\\\" \\\");\\n            System.out.println();\\n        }\\n    }\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Alice has an empty grid with n rows and m columns. Some of the cells are marked, and no marked cells are adjacent to the edge of the grid. (Two squares are adjacent if they share a side.) \\n\\nAlice wants to fill each cell with a number such that the following statements are true: \\n\\n  * every unmarked cell contains either the number 1 or 4; \\n  * every marked cell contains the sum of the numbers in all unmarked cells adjacent to it (if a marked cell is not adjacent to any unmarked cell, this sum is 0); \\n  * every marked cell contains a multiple of 5. \\n\\nAlice couldn't figure it out, so she asks Bob to help her. Help Bob find any such grid, or state that no such grid exists.\\n\\nInput\\n\\nThe first line of input contains two integers n and m (1 \u2264 n, m \u2264 500) \u2014 the number of rows and the number of columns in the grid, respectively.\\n\\nThen n lines follow, each containing m characters. Each of these characters is either '.' or 'X' \u2014 an unmarked and a marked cell, respectively. No marked cells are adjacent to the edge of the grid.\\n\\nOutput\\n\\nOutput \\\"'NO\\\" if no suitable grid exists. Otherwise, output \\\"'YES\\\"'. Then output n lines of m space-separated integers \u2014 the integers in the grid.\\n\\nExamples\\n\\nInput\\n\\n\\n5 5\\n.....\\n.XXX.\\n.X.X.\\n.XXX.\\n.....\\n\\n\\nOutput\\n\\n\\nYES\\n4 1 4 4 1\\n4 5 5 5 1\\n4 5 1 5 4\\n1 5 5 5 4\\n1 4 4 1 4\\n\\n\\nInput\\n\\n\\n5 5\\n.....\\n.XXX.\\n.XXX.\\n.XXX.\\n.....\\n\\n\\nOutput\\n\\n\\nNO\\n\\n\\nInput\\n\\n\\n3 2\\n..\\n..\\n..\\n\\n\\nOutput\\n\\n\\nYES\\n4 1\\n4 1\\n1 4\\n\\n\\nInput\\n\\n\\n9 9\\n.........\\n.XXXXX.X.\\n.X...X...\\n.X.XXXXX.\\n.X.X.X.X.\\n.X.XXX.X.\\n.X.....X.\\n.XXXXXXX.\\n.........\\n\\n\\nOutput\\n\\n\\nYES\\n4 4 4 1 4 1 4 1 4\\n1 5 5 5 5 5 4 10 1\\n4 5 1 4 1 5 4 4 4\\n4 5 1 5 5 0 5 5 1\\n4 5 1 5 4 5 1 5 4\\n4 5 1 5 5 5 4 5 1\\n1 5 4 4 1 1 4 5 1\\n4 5 5 5 5 5 5 5 4\\n1 1 1 1 4 4 1 1 4\\n\\nNote\\n\\nIt can be shown that no such grid exists for the second test.\\nThe above is tricky. Write me a correct solution in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst long long INF = 1e9 + 7;\\nconst long long MOD = 998244353;\\nvector<vector<long long> > adj;\\nlong long color[1000005];\\nbool v[1000005] = {0};\\nlong long block(long long x, long long y, long long m) { return m * x + y; }\\nvoid dfs(long long idx, long long y) {\\n  v[idx] = 1;\\n  color[idx] = y;\\n  for (auto x : adj[idx]) {\\n    if (!v[x]) {\\n      dfs(x, y ^ 1);\\n    } else if (v[x]) {\\n      assert(color[x] == (y ^ 1));\\n    }\\n  }\\n}\\nint main(void) {\\n  ios_base::sync_with_stdio(0);\\n  cin.tie(0);\\n  long long n, m;\\n  cin >> n >> m;\\n  char arr[n][m];\\n  long long ans[n][m];\\n  for (long long i = 0; i < n; i++) {\\n    for (long long j = 0; j < m; j++) {\\n      cin >> arr[i][j];\\n    }\\n  }\\n  bool ok = 1;\\n  long long ola = n * m + 10;\\n  adj.assign(ola, vector<long long>());\\n  long long dx[4] = {0, 0, 1, -1};\\n  long long dy[4] = {1, -1, 0, 0};\\n  for (long long i = 0; i < n; i++) {\\n    for (long long j = 0; j < m; j++) {\\n      if (arr[i][j] == 'X') {\\n        long long posa = 0;\\n        vector<long long> ex;\\n        for (long long k = 0; k < 4; k++) {\\n          long long x = i + dx[k], y = dy[k] + j;\\n          if (arr[x][y] == '.') {\\n            ex.push_back(block(x, y, m));\\n            posa++;\\n          }\\n        }\\n        if (posa == 2) {\\n          for (long long i = 0; i < posa; i++) {\\n            adj[ex[i]].push_back(ex[(i + 1) % posa]);\\n            adj[ex[(i + 1) % posa]].push_back(ex[i]);\\n          }\\n        } else if (posa == 4) {\\n          adj[ex[0]].push_back(ex[2]);\\n          adj[ex[2]].push_back(ex[0]);\\n          adj[ex[1]].push_back(ex[3]);\\n          adj[ex[3]].push_back(ex[1]);\\n        }\\n        if (posa % 2) {\\n          ok = 0;\\n        }\\n      }\\n    }\\n  }\\n  if (!ok) {\\n    cout << \\\"NO\\\";\\n    return 0;\\n  }\\n  for (long long i = 0; i < n; i++) {\\n    for (long long j = 0; j < m; j++) {\\n      if (arr[i][j] == '.' && !v[block(i, j, m)]) {\\n        dfs(block(i, j, m), 0);\\n      }\\n      if (arr[i][j] == '.') {\\n        ans[i][j] = 1;\\n        if (color[block(i, j, m)] == 1) {\\n         ...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Given n, find any array a_1, a_2, \u2026, a_n of integers such that all of the following conditions hold: \\n\\n  * 1 \u2264 a_i \u2264 10^9 for every i from 1 to n.\\n\\n  * a_1 < a_2 < \u2026 <a_n\\n\\n  * For every i from 2 to n, a_i isn't divisible by a_{i-1}\\n\\n\\n\\n\\nIt can be shown that such an array always exists under the constraints of the problem.\\n\\nInput\\n\\nThe first line contains the number of test cases t (1 \u2264 t \u2264 100). Description of the test cases follows.\\n\\nThe only line of each test case contains a single integer n (1 \u2264 n \u2264 1000).\\n\\nIt is guaranteed that the sum of n over all test cases does not exceed 10^4.\\n\\nOutput\\n\\nFor each test case print n integers a_1, a_2, \u2026, a_n \u2014 the array you found. If there are multiple arrays satisfying all the conditions, print any of them.\\n\\nExample\\n\\nInput\\n\\n\\n3\\n1\\n2\\n7\\n\\n\\nOutput\\n\\n\\n1\\n2 3\\n111 1111 11111 111111 1111111 11111111 111111111\\n\\nNote\\n\\nIn the first test case, array [1] satisfies all the conditions.\\n\\nIn the second test case, array [2, 3] satisfies all the conditions, as 2<3 and 3 is not divisible by 2.\\n\\nIn the third test case, array [111, 1111, 11111, 111111, 1111111, 11111111, 111111111] satisfies all the conditions, as it's increasing and a_i isn't divisible by a_{i-1} for any i from 2 to 7.\\nt = i\",\"targets\":\"nt(input())\\nfor i in range(t):\\n    n = int(input())\\n    ans = [int(j+2) for j in range(n)]\\n    print(*ans)\",\"language\":\"python\",\"split\":\"test\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Mocha wants to be an astrologer. There are n stars which can be seen in Zhijiang, and the brightness of the i-th star is a_i. \\n\\nMocha considers that these n stars form a constellation, and she uses (a_1,a_2,\u2026,a_n) to show its state. A state is called mathematical if all of the following three conditions are satisfied:\\n\\n  * For all i (1\u2264 i\u2264 n), a_i is an integer in the range [l_i, r_i].\\n  * \u2211  _{i=1} ^ n a_i \u2264 m.\\n  * \\\\gcd(a_1,a_2,\u2026,a_n)=1.\\n\\n\\n\\nHere, \\\\gcd(a_1,a_2,\u2026,a_n) denotes the [greatest common divisor (GCD)](https:\\/\\/en.wikipedia.org\\/wiki\\/Greatest_common_divisor) of integers a_1,a_2,\u2026,a_n.\\n\\nMocha is wondering how many different mathematical states of this constellation exist. Because the answer may be large, you must find it modulo 998 244 353.\\n\\nTwo states (a_1,a_2,\u2026,a_n) and (b_1,b_2,\u2026,b_n) are considered different if there exists i (1\u2264 i\u2264 n) such that a_i \u2260 b_i.\\n\\nInput\\n\\nThe first line contains two integers n and m (2 \u2264 n \u2264 50, 1 \u2264 m \u2264 10^5) \u2014 the number of stars and the upper bound of the sum of the brightness of stars.\\n\\nEach of the next n lines contains two integers l_i and r_i (1 \u2264 l_i \u2264 r_i \u2264 m) \u2014 the range of the brightness of the i-th star.\\n\\nOutput\\n\\nPrint a single integer \u2014 the number of different mathematical states of this constellation, modulo 998 244 353.\\n\\nExamples\\n\\nInput\\n\\n\\n2 4\\n1 3\\n1 2\\n\\n\\nOutput\\n\\n\\n4\\n\\nInput\\n\\n\\n5 10\\n1 10\\n1 10\\n1 10\\n1 10\\n1 10\\n\\n\\nOutput\\n\\n\\n251\\n\\nInput\\n\\n\\n5 100\\n1 94\\n1 96\\n1 91\\n4 96\\n6 97\\n\\n\\nOutput\\n\\n\\n47464146\\n\\nNote\\n\\nIn the first example, there are 4 different mathematical states of this constellation:\\n\\n  * a_1=1, a_2=1.\\n  * a_1=1, a_2=2.\\n  * a_1=2, a_2=1.\\n  * a_1=3, a_2=1.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nusing ll = long long;\\nusing ld = long double;\\nusing pii = pair<int, int>;\\nusing pll = pair<ll, ll>;\\nusing vi = vector<int>;\\nusing vl = vector<ll>;\\nconst char nl = '\\\\n';\\nconst ll mod = 998244353;\\nconst int max_n = 50;\\nconst int max_m = 1e5;\\nconst int max_sum = max_n * max_m;\\nint l[max_n + 1], r[max_n + 1];\\nll f[max_m + 1];\\nll cnt[max_m + 2][max_n + 1];\\nll cnt_pref[max_m + 2][max_n + 1];\\nvoid solve() {\\n  int n, m;\\n  cin >> n >> m;\\n  for (int i = 1; i <= n; i++) cin >> l[i] >> r[i];\\n  int l_sum = 0;\\n  for (int i = 1; i <= n; i++) l_sum += l[i];\\n  if (l_sum > m) {\\n    cout << 0 << nl;\\n    return;\\n  }\\n  for (int d = m \\/ n; d >= 1; d--) {\\n    int ms = m \\/ d;\\n    bool can = true;\\n    for (int i = 1; i <= n; i++) {\\n      can &= (l[i] + d - 1) \\/ d * d <= r[i];\\n    }\\n    if (!can) continue;\\n    for (int i = 0; i <= n; i++) {\\n      for (int s = 0; s <= ms; s++) {\\n        cnt[s][i] = cnt_pref[s][i] = 0;\\n      }\\n    }\\n    cnt[0][0] = 1;\\n    for (int s = 0; s <= ms; s++) cnt_pref[s][0] = 1;\\n    for (int i = 1; i <= n; i++) {\\n      for (int s = 0; s <= ms; s++) {\\n        int left = max(0, s - r[i] \\/ d), right = s - (l[i] + d - 1) \\/ d;\\n        if (left > right) continue;\\n        ll range_sum = cnt_pref[right][i - 1];\\n        if (left > 0) {\\n          range_sum -= cnt_pref[left - 1][i - 1];\\n          range_sum += mod;\\n          range_sum %= mod;\\n        }\\n        cnt[s][i] = range_sum;\\n        cnt_pref[s][i] = cnt[s][i];\\n        if (s > 0) {\\n          cnt_pref[s][i] += cnt_pref[s - 1][i];\\n          cnt_pref[s][i] %= mod;\\n        }\\n      }\\n    }\\n    f[d] = cnt_pref[ms][n];\\n    for (int d2 = 2 * d; d2 <= m; d2 += d) {\\n      f[d] -= f[d2];\\n      f[d] += mod;\\n      f[d] %= mod;\\n    }\\n  }\\n  cout << f[1] << nl;\\n}\\nint main() {\\n  ios_base::sync_with_stdio(false);\\n  cin.tie(nullptr);\\n  int t = 1;\\n  while (t--) solve();\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Vlad has n friends, for each of whom he wants to buy one gift for the New Year.\\n\\nThere are m shops in the city, in each of which he can buy a gift for any of his friends. If the j-th friend (1 \u2264 j \u2264 n) receives a gift bought in the shop with the number i (1 \u2264 i \u2264 m), then the friend receives p_{ij} units of joy. The rectangular table p_{ij} is given in the input.\\n\\nVlad has time to visit at most n-1 shops (where n is the number of friends). He chooses which shops he will visit and for which friends he will buy gifts in each of them.\\n\\nLet the j-th friend receive a_j units of joy from Vlad's gift. Let's find the value \u03b1=min\\\\\\\\{a_1, a_2, ..., a_n\\\\}. Vlad's goal is to buy gifts so that the value of \u03b1 is as large as possible. In other words, Vlad wants to maximize the minimum of the joys of his friends.\\n\\nFor example, let m = 2, n = 2. Let the joy from the gifts that we can buy in the first shop: p_{11} = 1, p_{12}=2, in the second shop: p_{21} = 3, p_{22}=4.\\n\\nThen it is enough for Vlad to go only to the second shop and buy a gift for the first friend, bringing joy 3, and for the second \u2014 bringing joy 4. In this case, the value \u03b1 will be equal to min\\\\{3, 4\\\\} = 3\\n\\nHelp Vlad choose gifts for his friends so that the value of \u03b1 is as high as possible. Please note that each friend must receive one gift. Vlad can visit at most n-1 shops (where n is the number of friends). In the shop, he can buy any number of gifts.\\n\\nInput\\n\\nThe first line of the input contains an integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases in the input.\\n\\nAn empty line is written before each test case. Then there is a line containing integers m and n (2 \u2264 n, 2 \u2264 n \u22c5 m \u2264 10^5) separated by a space \u2014 the number of shops and the number of friends, where n \u22c5 m is the product of n and m.\\n\\nThen m lines follow, each containing n numbers. The number in the i-th row of the j-th column p_{ij} (1 \u2264 p_{ij} \u2264 10^9) is the joy of the product intended for friend number j in shop number i.\\n\\nIt is guaranteed that the sum of the values n \u22c5 m over all test cases in...\\nt = i\",\"targets\":\"nt(input())\\n\\nfor i in range(t):\\n    input()\\n    x, y = [], []\\n    n, m = map(int, input().split())\\n    for j in range(n):\\n        x.append(list(map(int, input().split())))\\n    for j in range(n):\\n        for g in range(m):\\n            y.append([x[j][g], j, g])\\n    y.sort()\\n    y.reverse()\\n    found = [0 for i in range(m)]\\n    deg = [0 for j in range(n)]\\n    deg2 = False\\n    rem = m\\n    for [v, i, j] in y:\\n        deg[i] += 1;\\n        if (deg[i] >= 2):\\n            deg2 = True;\\n        if (found[j] == 0):\\n            rem -= 1;\\n            found[j] = 1;\\n        if (deg2 and rem == 0):\\n            print(v)\\n            break\",\"language\":\"python\",\"split\":\"test\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Gregor is learning about RSA cryptography, and although he doesn't understand how RSA works, he is now fascinated with prime numbers and factoring them.\\n\\nGregor's favorite prime number is P. Gregor wants to find two bases of P. Formally, Gregor is looking for two integers a and b which satisfy both of the following properties.\\n\\n  * P mod a = P mod b, where x mod y denotes the remainder when x is divided by y, and \\n  * 2 \u2264 a < b \u2264 P. \\n\\n\\n\\nHelp Gregor find two bases of his favorite prime number!\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 1000).\\n\\nEach subsequent line contains the integer P (5 \u2264 P \u2264 {10}^9), with P guaranteed to be prime.\\n\\nOutput\\n\\nYour output should consist of t lines. Each line should consist of two integers a and b (2 \u2264 a < b \u2264 P). If there are multiple possible solutions, print any.\\n\\nExample\\n\\nInput\\n\\n\\n2\\n17\\n5\\n\\n\\nOutput\\n\\n\\n3 5\\n2 4\\n\\nNote\\n\\nThe first query is P=17. a=3 and b=5 are valid bases in this case, because 17 mod 3 = 17 mod 5 = 2. There are other pairs which work as well.\\n\\nIn the second query, with P=5, the only solution is a=2 and b=4.\\nUsing java can you solve the prior task?\",\"targets\":\"import java.io.BufferedReader;\\nimport java.io.BufferedWriter;\\nimport java.io.IOException;\\nimport java.io.InputStreamReader;\\nimport java.io.OutputStreamWriter;\\nimport java.util.StringTokenizer;\\n\\npublic class main{\\n\\tprivate static BufferedReader br=new BufferedReader(new InputStreamReader(System.in));\\n\\tprivate static BufferedWriter w=new BufferedWriter(new OutputStreamWriter(System.out));\\n\\t\\n\\tpublic static void main(String[] args) throws IOException {\\n\\t\\t\\/\\/ TODO Auto-generated method stub\\n\\t\\tint t=Integer.parseInt(br.readLine());\\n\\n\\t\\twhile(t>0) {\\n\\t\\t    long n=Long.parseLong(br.readLine());\\n\\t\\t    long a=2;\\n\\t\\t    long temp=(n-1)\\/2;\\n\\t\\t    if(n==5) {\\n\\t\\t    \\ttemp=4;\\n\\t\\t    }\\n\\t\\t    w.write(a+\\\" \\\"+temp);\\n\\t\\t    w.newLine();\\n\\t\\t\\tt--;\\n\\t\\t}\\n\\t\\tw.flush();\\n\\t\\tw.close();\\n\\t}\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in CPP?\\nIn Byteland, there are two political parties fighting for seats in the Parliament in the upcoming elections: Wrong Answer Party and Time Limit Exceeded Party. As they want to convince as many citizens as possible to cast their votes on them, they keep promising lower and lower taxes.\\n\\nThere are n cities in Byteland, connected by m one-way roads. Interestingly enough, the road network has no cycles \u2014 it's impossible to start in any city, follow a number of roads, and return to that city. Last year, citizens of the i-th city had to pay h_i bourles of tax.\\n\\nParties will now alternately hold the election conventions in various cities. If a party holds a convention in city v, the party needs to decrease the taxes in this city to a non-negative integer amount of bourles. However, at the same time they can arbitrarily modify the taxes in each of the cities that can be reached from v using a single road. The only condition that must be fulfilled that the tax in each city has to remain a non-negative integer amount of bourles.\\n\\nThe first party to hold the convention is Wrong Answer Party. It's predicted that the party to hold the last convention will win the election. Can Wrong Answer Party win regardless of Time Limit Exceeded Party's moves?\\n\\nInput\\n\\nThe first line of the input contains two integers n, m (1 \u2264 n \u2264 200 000, 0 \u2264 m \u2264 200 000) \u2014 the number of cities and roads in Byteland.\\n\\nThe next line contains n space-separated integers h_1, h_2, ..., h_n (0 \u2264 h_i \u2264 10^9); h_i denotes the amount of taxes paid in the i-th city.\\n\\nEach of the following m lines contains two integers (1 \u2264 u, v \u2264 n, u \u2260 v), and describes a one-way road leading from the city u to the city v. There will be no cycles in the road network. No two roads will connect the same pair of cities.\\n\\nWe can show that the conventions cannot be held indefinitely for any correct test case.\\n\\nOutput\\n\\nIf Wrong Answer Party can win the election, output WIN in the first line of your output. In this case, you're additionally asked to produce any convention allowing...\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint he[200010], ver[2 * 200010], nxt[2 * 200010], tot, in[200010];\\nvoid add(int x, int y) {\\n  ver[++tot] = y;\\n  nxt[tot] = he[x];\\n  he[x] = tot;\\n}\\nint que[200010], cnt;\\nlong long w[200010];\\nvector<int> v[200010];\\nlong long ans[200010];\\nint s[200010];\\nbool vis[200010];\\nint main() {\\n  int n, m;\\n  scanf(\\\"%d%d\\\", &n, &m);\\n  for (int i = 1; i <= n; i++) {\\n    scanf(\\\"%lld\\\", &w[i]);\\n  }\\n  for (int i = 1; i <= m; i++) {\\n    int x, y;\\n    scanf(\\\"%d%d\\\", &x, &y);\\n    add(y, x);\\n    in[x]++;\\n  }\\n  queue<int> q;\\n  for (int i = 1; i <= n; i++) {\\n    if (in[i] == 0) q.push(i);\\n  }\\n  while (!q.empty()) {\\n    int x = q.front();\\n    q.pop();\\n    que[++cnt] = x;\\n    for (int i = he[x]; i; i = nxt[i]) {\\n      in[ver[i]]--;\\n      if (!in[ver[i]]) q.push(ver[i]);\\n    }\\n  }\\n  int maxx = 0;\\n  for (int i = 1; i <= cnt; i++) {\\n    int x = que[i];\\n    int stp = 0;\\n    if (!v[x].size())\\n      ans[0] ^= w[x];\\n    else {\\n      sort(v[x].begin(), v[x].end());\\n      s[x] = 0;\\n      for (int j = 0; j < v[x].size(); j++) {\\n        if (v[x][j] == s[x]) s[x]++;\\n      }\\n      stp = s[x];\\n      ans[stp] ^= w[x];\\n      maxx = max(maxx, stp);\\n    }\\n    s[x] = stp;\\n    for (int j = he[x]; j; j = nxt[j]) v[ver[j]].push_back(stp);\\n  }\\n  bool xx = false;\\n  for (int i = 0; i <= maxx; i++) {\\n    if (ans[i] != 0) {\\n      xx = true;\\n      break;\\n    }\\n  }\\n  if (xx) {\\n    puts(\\\"WIN\\\");\\n    for (int i = maxx; i >= 0; i--) {\\n      if (ans[i]) {\\n        maxx = i;\\n        break;\\n      }\\n    }\\n    int tmp = 0;\\n    for (int i = 1; i <= n; i++) {\\n      if (s[i] == maxx && ((w[i] ^ ans[s[i]]) < w[i])) {\\n        tmp = i;\\n        break;\\n      }\\n    }\\n    w[tmp] = ans[maxx] ^ w[tmp];\\n    for (int i = 1; i <= n; i++) {\\n      if (i == tmp || s[i] >= s[tmp]) continue;\\n      for (int j = he[i]; j; j = nxt[j]) {\\n        if (ver[j] == tmp && vis[s[i]] == 0) {\\n          w[i] = ans[s[i]] ^ w[i];\\n          vis[s[i]] = 1;\\n          break;\\n        }\\n      }\\n    }\\n    for (int i = 1; i <= n; i++) printf(\\\"%lld \\\", w[i]);\\n  } else\\n   ...\",\"language\":\"python\",\"split\":\"train\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You are given a matrix, consisting of n rows and m columns. The rows are numbered top to bottom, the columns are numbered left to right.\\n\\nEach cell of the matrix can be either free or locked.\\n\\nLet's call a path in the matrix a staircase if it: \\n\\n  * starts and ends in the free cell; \\n  * visits only free cells; \\n  * has one of the two following structures: \\n    1. the second cell is 1 to the right from the first one, the third cell is 1 to the bottom from the second one, the fourth cell is 1 to the right from the third one, and so on; \\n    2. the second cell is 1 to the bottom from the first one, the third cell is 1 to the right from the second one, the fourth cell is 1 to the bottom from the third one, and so on. \\n\\n\\n\\nIn particular, a path, consisting of a single cell, is considered to be a staircase.\\n\\nHere are some examples of staircases:\\n\\n<image>\\n\\nInitially all the cells of the matrix are free.\\n\\nYou have to process q queries, each of them flips the state of a single cell. So, if a cell is currently free, it makes it locked, and if a cell is currently locked, it makes it free.\\n\\nPrint the number of different staircases after each query. Two staircases are considered different if there exists such a cell that appears in one path and doesn't appear in the other path.\\n\\nInput\\n\\nThe first line contains three integers n, m and q (1 \u2264 n, m \u2264 1000; 1 \u2264 q \u2264 10^4) \u2014 the sizes of the matrix and the number of queries.\\n\\nEach of the next q lines contains two integers x and y (1 \u2264 x \u2264 n; 1 \u2264 y \u2264 m) \u2014 the description of each query.\\n\\nOutput\\n\\nPrint q integers \u2014 the i-th value should be equal to the number of different staircases after i queries. Two staircases are considered different if there exists such a cell that appears in one path and doesn't appear in the other path.\\n\\nExamples\\n\\nInput\\n\\n\\n2 2 8\\n1 1\\n1 1\\n1 1\\n2 2\\n1 1\\n1 2\\n2 1\\n1 1\\n\\n\\nOutput\\n\\n\\n5\\n10\\n5\\n2\\n5\\n3\\n1\\n0\\n\\n\\nInput\\n\\n\\n3 4 10\\n1 4\\n1 2\\n2 3\\n1 2\\n2 3\\n3 2\\n1 3\\n3 4\\n1 3\\n3 1\\n\\n\\nOutput\\n\\n\\n49\\n35\\n24\\n29\\n49\\n39\\n31\\n23\\n29\\n27\\n\\n\\nInput\\n\\n\\n1000 1000 2\\n239 634\\n239 634\\n\\n\\nOutput\\n\\n\\n1332632508\\n1333333000\\nUsing cpp can you solve the prior task?\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst long long maxn = 1e3 + 10;\\nint dp0[maxn][maxn], dp1[maxn][maxn];\\nint pd0[maxn][maxn], pd1[maxn][maxn];\\nbool c[maxn][maxn];\\nint l, r;\\nint main() {\\n  ios_base::sync_with_stdio(0);\\n  cin.tie(0);\\n  cout.tie(0);\\n  int n, m, q;\\n  cin >> n >> m >> q;\\n  long long maxx = 0;\\n  for (int i = 1; i <= n; i++) {\\n    for (int j = 1; j <= m; j++) {\\n      c[i][j] = 1;\\n      dp0[i][j] = dp1[i][j - 1] + 1;\\n      dp1[i][j] = dp0[i - 1][j] + 1;\\n      pd1[i][j] = dp1[i][j];\\n      pd0[i][j] = dp0[i][j];\\n      maxx += dp0[i][j] + dp1[i][j] - 1;\\n    }\\n  }\\n  int x, y;\\n  int vv = 0;\\n  while (q--) {\\n    cin >> l >> r;\\n    x = l, y = r;\\n    if (c[l][r] == 1) {\\n      x = l, y = r;\\n      vv = 0;\\n      for (int i = 1; i <= 2000; i++) {\\n        if (i % 2 == 1) {\\n          y++;\\n          if (x > n || y > m) {\\n            break;\\n          }\\n          if (c[x][y] == 0) {\\n            dp0[x][y] -= dp1[l][r];\\n            break;\\n            vv++;\\n          }\\n          dp0[x][y] -= dp1[l][r];\\n          if (vv == 0) {\\n            maxx -= dp1[l][r];\\n          }\\n        } else {\\n          x++;\\n          if (x > n || y > m) {\\n            break;\\n          }\\n          if (c[x][y] == 0) {\\n            dp1[x][y] -= dp1[l][r];\\n            break;\\n            vv++;\\n          }\\n          dp1[x][y] -= dp1[l][r];\\n          if (vv == 0) {\\n            maxx -= dp1[l][r];\\n          }\\n        }\\n      }\\n      vv = 0;\\n      x = l, y = r;\\n      for (int i = 1; i <= 2000; i++) {\\n        if (i % 2 == 0) {\\n          y++;\\n          if (x > n || y > m) {\\n            break;\\n          }\\n          if (c[x][y] == 0) {\\n            vv++;\\n            dp0[x][y] -= dp0[l][r];\\n            break;\\n          }\\n          dp0[x][y] -= dp0[l][r];\\n          if (vv == 0) {\\n            maxx -= dp0[l][r];\\n          }\\n        } else {\\n          x++;\\n          if (x > n || y > m) {\\n            break;\\n          }\\n          if (c[x][y] == 0) {\\n            vv++;\\n            dp1[x][y] -= dp0[l][r];\\n            break;\\n          }\\n          dp1[x][y] -=...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in CPP?\\nBlake is a CEO of a large company called \\\"Blake Technologies\\\". He loves his company very much and he thinks that his company should be the best. That is why every candidate needs to pass through the interview that consists of the following problem.\\n\\nWe define function f(x, l, r) as a bitwise OR of integers xl, xl + 1, ..., xr, where xi is the i-th element of the array x. You are given two arrays a and b of length n. You need to determine the maximum value of sum f(a, l, r) + f(b, l, r) among all possible 1 \u2264 l \u2264 r \u2264 n.\\n\\n<image>\\n\\nInput\\n\\nThe first line of the input contains a single integer n (1 \u2264 n \u2264 1000) \u2014 the length of the arrays.\\n\\nThe second line contains n integers ai (0 \u2264 ai \u2264 109).\\n\\nThe third line contains n integers bi (0 \u2264 bi \u2264 109).\\n\\nOutput\\n\\nPrint a single integer \u2014 the maximum value of sum f(a, l, r) + f(b, l, r) among all possible 1 \u2264 l \u2264 r \u2264 n.\\n\\nExamples\\n\\nInput\\n\\n5\\n1 2 4 3 2\\n2 3 3 12 1\\n\\n\\nOutput\\n\\n22\\n\\nInput\\n\\n10\\n13 2 7 11 8 4 9 8 5 1\\n5 7 18 9 2 3 0 11 8 6\\n\\n\\nOutput\\n\\n46\\n\\nNote\\n\\nBitwise OR of two non-negative integers a and b is the number c = a OR b, such that each of its digits in binary notation is 1 if and only if at least one of a or b have 1 in the corresponding position in binary notation.\\n\\nIn the first sample, one of the optimal answers is l = 2 and r = 4, because f(a, 2, 4) + f(b, 2, 4) = (2 OR 4 OR 3) + (3 OR 3 OR 12) = 7 + 15 = 22. Other ways to get maximum value is to choose l = 1 and r = 4, l = 1 and r = 5, l = 2 and r = 4, l = 2 and r = 5, l = 3 and r = 4, or l = 3 and r = 5.\\n\\nIn the second sample, the maximum value is obtained for l = 1 and r = 9.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint main() {\\n  int timer;\\n  timer = 1;\\n  while (timer--) {\\n    long long n, i, j, a = 0, b = 0;\\n    cin >> n;\\n    long long dta[n];\\n    for (i = 0; i < n; ++i) {\\n      cin >> j;\\n      a = a | j;\\n    }\\n    for (i = 0; i < n; ++i) {\\n      cin >> j;\\n      b = b | j;\\n    }\\n    cout << (a + b) << \\\"\\\\n\\\";\\n  }\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"There are n points and m segments on the coordinate line. The initial coordinate of the i-th point is a_i. The endpoints of the j-th segment are l_j and r_j \u2014 left and right endpoints, respectively.\\n\\nYou can move the points. In one move you can move any point from its current coordinate x to the coordinate x - 1 or the coordinate x + 1. The cost of this move is 1.\\n\\nYou should move the points in such a way that each segment is visited by at least one point. A point visits the segment [l, r] if there is a moment when its coordinate was on the segment [l, r] (including endpoints).\\n\\nYou should find the minimal possible total cost of all moves such that all segments are visited.\\n\\nInput\\n\\nThe input consists of multiple test cases. The first line contains a single integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases. Description of the test cases follows.\\n\\nThe first line of each test case contains two integers n and m (1 \u2264 n, m \u2264 2 \u22c5 10^5) \u2014 the number of points and segments respectively.\\n\\nThe next line contains n distinct integers a_1, a_2, \u2026, a_n (-10^9 \u2264 a_i \u2264 10^9) \u2014 the initial coordinates of the points.\\n\\nEach of the next m lines contains two integers l_j, r_j (-10^9 \u2264 l_j \u2264 r_j \u2264 10^9) \u2014 the left and the right endpoints of the j-th segment.\\n\\nIt's guaranteed that the sum of n and the sum of m over all test cases does not exceed 2 \u22c5 10^5.\\n\\nOutput\\n\\nFor each test case print a single integer \u2014 the minimal total cost of all moves such that all segments are visited.\\n\\nExample\\n\\nInput\\n\\n\\n2\\n4 11\\n2 6 14 18\\n0 3\\n4 5\\n11 15\\n3 5\\n10 13\\n16 16\\n1 4\\n8 12\\n17 19\\n7 13\\n14 19\\n4 12\\n-9 -16 12 3\\n-20 -18\\n-14 -13\\n-10 -7\\n-3 -1\\n0 4\\n6 11\\n7 9\\n8 10\\n13 15\\n14 18\\n16 17\\n18 19\\n\\n\\nOutput\\n\\n\\n5\\n22\\n\\nNote\\n\\nIn the first test case the points can be moved as follows:\\n\\n  * Move the second point from the coordinate 6 to the coordinate 5. \\n  * Move the third point from the coordinate 14 to the coordinate 13. \\n  * Move the fourth point from the coordinate 18 to the coordinate 17. \\n  * Move the third point from the coordinate 13 to the coordinate 12. \\n  * Move the...\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nchar gc() {\\n  static char buf[1 << 16], *s, *t;\\n  if (s == t) {\\n    t = (s = buf) + fread(buf, 1, 1 << 16, stdin);\\n    if (s == t) return EOF;\\n  }\\n  return *s++;\\n}\\nint read() {\\n  char c;\\n  int w = 1;\\n  while ((c = getchar()) > '9' || c < '0')\\n    if (c == '-') w = -1;\\n  int ans = c - '0';\\n  while ((c = getchar()) >= '0' && c <= '9')\\n    ans = (ans << 1) + (ans << 3) + c - '0';\\n  return ans * w;\\n}\\nchar st;\\nconst int xx = 2e5 + 5;\\nlong long n, m;\\nlong long a[xx];\\nstruct node {\\n  long long l, r;\\n  bool operator<(const node& w) const { return l < w.l; };\\n} e[xx], w[xx];\\nlong long vis[xx];\\nstruct no {\\n  long long x, y;\\n  bool operator<(const no& w) const { return x < w.x; }\\n};\\nlong long f[xx][2];\\nmultiset<no> s;\\nlong long mn[xx << 2];\\nvoid build(long long k, long long l, long long r) {\\n  if (l == r) return mn[k] = e[l].r, void();\\n  long long mid = l + r >> 1;\\n  build(k << 1, l, mid);\\n  build(k << 1 | 1, mid + 1, r);\\n  mn[k] = min(mn[k << 1], mn[k << 1 | 1]);\\n}\\nlong long ask(long long k, long long l, long long r, long long x, long long y) {\\n  if (x <= l && r <= y) return mn[k];\\n  long long mid = l + r >> 1, ans = 2e9 + 1000;\\n  if (x <= mid) ans = min(ans, ask(k << 1, l, mid, x, y));\\n  if (mid < y) ans = min(ans, ask(k << 1 | 1, mid + 1, r, x, y));\\n  return ans;\\n}\\nchar ed;\\nsigned main() {\\n  int T = read();\\n  while (T--) {\\n    n = read(), m = read();\\n    for (int i = 1; i <= n; i++) a[i] = read();\\n    a[++n] = -5e9 - 1000, a[++n] = 5e9 + 1000;\\n    memset(vis, 0, sizeof(vis[0]) * (m + 1));\\n    sort(a + 1, a + n + 1);\\n    s.clear();\\n    for (int i = 1; i <= m; i++) w[i].l = read(), w[i].r = read();\\n    sort(w + 1, w + m + 1);\\n    long long tt = 1;\\n    for (int i = 1; i <= n; i++) {\\n      while (tt <= m && w[tt].l <= a[i]) s.insert((no){w[tt].r, tt}), tt++;\\n      while (s.size() && ((--s.end())->x) >= a[i])\\n        vis[((--s.end())->y)] = 1, s.erase(--s.end());\\n    }\\n    long long oo = 0;\\n    for (int i = 1; i <= m; i++)\\n      if (!vis[i]) e[++oo] = w[i];\\n    m = oo;\\n    for...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"n players are playing a game. \\n\\nThere are two different maps in the game. For each player, we know his strength on each map. When two players fight on a specific map, the player with higher strength on that map always wins. No two players have the same strength on the same map. \\n\\nYou are the game master and want to organize a tournament. There will be a total of n-1 battles. While there is more than one player in the tournament, choose any map and any two remaining players to fight on it. The player who loses will be eliminated from the tournament. \\n\\nIn the end, exactly one player will remain, and he is declared the winner of the tournament. For each player determine if he can win the tournament.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 100) \u2014 the number of test cases. The description of test cases follows.\\n\\nThe first line of each test case contains a single integer n (1 \u2264 n \u2264 10^5) \u2014 the number of players.\\n\\nThe second line of each test case contains n integers a_1, a_2, ..., a_n (1 \u2264 a_i \u2264 10^9, a_i \u2260 a_j for i \u2260 j), where a_i is the strength of the i-th player on the first map. \\n\\nThe third line of each test case contains n integers b_1, b_2, ..., b_n (1 \u2264 b_i \u2264 10^9, b_i \u2260 b_j for i \u2260 j), where b_i is the strength of the i-th player on the second map. \\n\\nIt is guaranteed that the sum of n over all test cases does not exceed 10^5.\\n\\nOutput\\n\\nFor each test case print a string of length n. i-th character should be \\\"1\\\" if the i-th player can win the tournament, or \\\"0\\\" otherwise.\\n\\nExample\\n\\nInput\\n\\n\\n3\\n4\\n1 2 3 4\\n1 2 3 4\\n4\\n11 12 20 21\\n44 22 11 30\\n1\\n1000000000\\n1000000000\\n\\n\\nOutput\\n\\n\\n0001\\n1111\\n1\\n\\nNote\\n\\nIn the first test case, the 4-th player will beat any other player on any game, so he will definitely win the tournament.\\n\\nIn the second test case, everyone can be a winner. \\n\\nIn the third test case, there is only one player. Clearly, he will win the tournament.\\nUsing cpp can you solve the prior task?\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nbool isrange(int second, int first, int n, int m) {\\n  if (0 <= second && second < n && 0 <= first && first < m) return true;\\n  return false;\\n}\\nint dy[4] = {1, 0, -1, 0}, dx[4] = {0, 1, 0, -1},\\n    ddy[8] = {1, 0, -1, 0, 1, 1, -1, -1}, ddx[8] = {0, 1, 0, -1, 1, -1, 1, -1};\\nconst int MAX = 1e5 + 100;\\nint A[MAX], B[MAX], vis[MAX];\\nset<pair<int, int> > a, b;\\nvoid del(int k) {\\n  a.erase(make_pair(A[k], k));\\n  b.erase(make_pair(B[k], k));\\n}\\nvoid solve(int tc) {\\n  int n;\\n  cin >> n;\\n  a.clear();\\n  b.clear();\\n  for (int e = 1; e <= n; e++) {\\n    vis[e] = 0;\\n    cin >> A[e];\\n    a.insert(make_pair(A[e], e));\\n  }\\n  for (int e = 1; e <= n; e++) {\\n    cin >> B[e];\\n    b.insert(make_pair(B[e], e));\\n  }\\n  int pos1 = prev(a.end())->second;\\n  int pos2 = prev(b.end())->second;\\n  del(pos1);\\n  del(pos2);\\n  vector<int> candi;\\n  candi.push_back(pos1);\\n  candi.push_back(pos2);\\n  int st = 0;\\n  while ((int)candi.size() != n) {\\n    int lim = (int)candi.size();\\n    bool flag = false;\\n    for (int p = st; p < lim; p++) {\\n      int pos = candi[p];\\n      set<pair<int, int> >::iterator lo1 = a.lower_bound(make_pair(A[pos], -1));\\n      vector<int> res;\\n      for (; lo1 != a.end(); lo1++) {\\n        res.push_back(lo1->second);\\n      }\\n      for (int e = 0; e < (int)res.size(); e++) {\\n        flag = true;\\n        candi.push_back(res[e]);\\n        del(res[e]);\\n      }\\n      set<pair<int, int> >::iterator lo2 = b.lower_bound(make_pair(B[pos], -1));\\n      res.clear();\\n      for (; lo2 != b.end(); lo2++) {\\n        res.push_back(lo2->second);\\n      }\\n      for (int e = 0; e < (int)res.size(); e++) {\\n        flag = true;\\n        candi.push_back(res[e]);\\n        del(res[e]);\\n      }\\n    }\\n    if (!flag) break;\\n    st = lim;\\n  }\\n  for (int e = 0; e < (int)candi.size(); e++) vis[candi[e]] = 1;\\n  for (int e = 1; e <= n; e++) cout << vis[e];\\n  cout << \\\"\\\\n\\\";\\n}\\nint main(void) {\\n  ios_base ::sync_with_stdio(false);\\n  cin.tie(NULL);\\n  cout.tie(NULL);\\n  int tc = 1;\\n  cin >> tc;\\n  for (int test_number = 1;...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Bob loves everything sweet. His favorite chocolate bar consists of pieces, each piece may contain a nut. Bob wants to break the bar of chocolate into multiple pieces so that each part would contain exactly one nut and any break line goes between two adjacent pieces.\\n\\nYou are asked to calculate the number of ways he can do it. Two ways to break chocolate are considered distinct if one of them contains a break between some two adjacent pieces and the other one doesn't. \\n\\nPlease note, that if Bob doesn't make any breaks, all the bar will form one piece and it still has to have exactly one nut.\\n\\nInput\\n\\nThe first line of the input contains integer n (1 \u2264 n \u2264 100) \u2014 the number of pieces in the chocolate bar.\\n\\nThe second line contains n integers ai (0 \u2264 ai \u2264 1), where 0 represents a piece without the nut and 1 stands for a piece with the nut.\\n\\nOutput\\n\\nPrint the number of ways to break the chocolate into multiple parts so that each part would contain exactly one nut.\\n\\nExamples\\n\\nInput\\n\\n3\\n0 1 0\\n\\n\\nOutput\\n\\n1\\n\\n\\nInput\\n\\n5\\n1 0 1 0 1\\n\\n\\nOutput\\n\\n4\\n\\nNote\\n\\nIn the first sample there is exactly one nut, so the number of ways equals 1 \u2014 Bob shouldn't make any breaks.\\n\\nIn the second sample you can break the bar in four ways:\\n\\n10|10|1\\n\\n1|010|1\\n\\n10|1|01\\n\\n1|01|01\\n\\n\\nimp\",\"targets\":\"ort java.io.BufferedReader;\\nimport java.io.IOException;\\nimport java.io.InputStreamReader;\\nimport java.io.PrintWriter;\\nimport java.math.BigInteger;\\nimport java.util.ArrayList;\\nimport java.util.Arrays;\\nimport java.util.Date;\\nimport java.util.HashMap;\\nimport java.util.Map;\\nimport java.util.Scanner;\\nimport java.util.StringTokenizer;\\n\\/**\\n *\\n * @author agavrikov\\n *\\/\\npublic class Solution {\\n\\t\\n\\tScanner scanner = new Scanner(System.in);\\n\\tBufferedReader cin = new BufferedReader(new InputStreamReader(System.in));\\n\\tPrintWriter cout = new PrintWriter(System.out);\\n\\tStringTokenizer tok;\\n\\t\\n\\tint n;\\n\\tint a[];\\n        BigInteger ans = BigInteger.ONE;\\n        \\n\\tprivate void run() throws IOException {\\n\\t\\t\\n\\t\\tn = scanner.nextInt();\\n\\t\\t\\n                a = new int[n];\\n                \\n\\t\\tfor (int i = 0; i < n; ++i) {\\n                    a[i] = scanner.nextInt();\\n                }\\n                \\n                int cur = 0;\\n                while (cur < n && a[cur] == 0) {\\n                    cur++;\\n                } \\n                \\n                if (cur == n) {\\n                    cout.println(0);\\n                    scanner.close();\\n                    cin.close();\\n                    cout.close();\\n                    return;\\n                }\\n                \\n                long curCnt = 1;\\n                while (cur < n) {\\n                    if (a[cur] == 1) {\\n                        ans = ans.multiply(BigInteger.valueOf(curCnt));\\n                        curCnt = 1;\\n                    } else {\\n                        curCnt++;\\n                    }\\n                    cur++;\\n                }\\n                \\n                cout.println(ans);\\n                \\n\\t\\tscanner.close();\\n\\t\\tcin.close();\\n\\t\\tcout.close();\\n\\t}\\n\\t\\n\\tpublic static void main(String[] args) throws IOException {\\n\\t\\tSolution solution = new Solution();\\n\\t\\tsolution.run();\\n\\t}\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"JAVA solution for \\\"Recently, Petya learned about a new game \\\"Slay the Dragon\\\". As the name suggests, the player will have to fight with dragons. To defeat a dragon, you have to kill it and defend your castle. To do this, the player has a squad of n heroes, the strength of the i-th hero is equal to a_i.\\n\\nAccording to the rules of the game, exactly one hero should go kill the dragon, all the others will defend the castle. If the dragon's defense is equal to x, then you have to send a hero with a strength of at least x to kill it. If the dragon's attack power is y, then the total strength of the heroes defending the castle should be at least y.\\n\\nThe player can increase the strength of any hero by 1 for one gold coin. This operation can be done any number of times.\\n\\nThere are m dragons in the game, the i-th of them has defense equal to x_i and attack power equal to y_i. Petya was wondering what is the minimum number of coins he needs to spend to defeat the i-th dragon.\\n\\nNote that the task is solved independently for each dragon (improvements are not saved).\\n\\nInput\\n\\nThe first line contains a single integer n (2 \u2264 n \u2264 2 \u22c5 10^5) \u2014 number of heroes.\\n\\nThe second line contains n integers a_1, a_2, ..., a_n (1 \u2264 a_i \u2264 10^{12}), where a_i is the strength of the i-th hero.\\n\\nThe third line contains a single integer m (1 \u2264 m \u2264 2 \u22c5 10^5) \u2014 the number of dragons.\\n\\nThe next m lines contain two integers each, x_i and y_i (1 \u2264 x_i \u2264 10^{12}; 1 \u2264 y_i \u2264 10^{18}) \u2014 defense and attack power of the i-th dragon.\\n\\nOutput\\n\\nPrint m lines, i-th of which contains a single integer \u2014 the minimum number of coins that should be spent to defeat the i-th dragon.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n3 6 2 3\\n5\\n3 12\\n7 9\\n4 14\\n1 10\\n8 7\\n\\n\\nOutput\\n\\n\\n1\\n2\\n4\\n0\\n2\\n\\nNote\\n\\nTo defeat the first dragon, you can increase the strength of the third hero by 1, then the strength of the heroes will be equal to [3, 6, 3, 3]. To kill the dragon, you can choose the first hero.\\n\\nTo defeat the second dragon, you can increase the forces of the second and third heroes by 1, then the strength of the heroes will...\\\":\",\"targets\":\"import javax.swing.*;\\nimport java.io.BufferedReader;\\nimport java.io.IOException;\\nimport java.io.InputStreamReader;\\nimport java.io.PrintWriter;\\nimport java.util.*;\\n\\npublic class Codeforces {\\n\\n    static FastScanner sc;\\n    static PrintWriter out;\\n    static int mod = (int) (1e9+7);\\n\\n    public static void main(String[] args){\\n        sc = new FastScanner();\\n        out = new PrintWriter(System.out);\\n\\n        int t = 1;\\n        while(t-- > 0){\\n            solve();\\n        }\\n\\n        out.close();\\n    }\\n\\n    private static void solve() {\\n\\n        int n = sc.nextInt();\\n        long[] heros = new long[n];\\n        long sum = 0;\\n        for(int i=0; i<n; i++){\\n            heros[i] = sc.nextLong();\\n            sum += heros[i];\\n        }\\n        Arrays.sort(heros);\\n        int m = sc.nextInt();\\n        long[] op = new long[m];\\n        for(int i=0; i<m; i++){\\n            long defense = sc.nextLong();\\n            long attack = sc.nextLong();\\n\\n            int temp = Arrays.binarySearch(heros, defense);\\n            int index = -1;\\n            if(temp >= 0){\\n                index = temp;\\n                System.out.println((sum-heros[index]) >= attack ? 0 : attack-(sum-heros[index]));\\n            }\\n            else{\\n                index = -(temp+1);\\n                long val1 = Long.MAX_VALUE, val2 = Long.MAX_VALUE;\\n                \\/\\/ focus on index-1;\\n                if(index-1 >= 0){\\n                    val1 = ((sum-heros[index-1]) >= attack ? 0 : attack-(sum-heros[index-1])) +\\n                            defense - heros[index-1];\\n                }\\n                \\/\\/focus on index\\n                if(index < n)\\n                    val2 = ((sum-heros[index]) >= attack ? 0 : attack-(sum-heros[index]));\\n                System.out.println(Math.min(val1, val2));\\n            }\\n\\n        }\\n\\n\\n\\n    }\\n\\n    public static int nCr(int n, int k) {\\n        int C[] = new int[k + 1];\\n\\n        \\/\\/ nC0 is 1\\n        C[0] = 1;\\n\\n        for (int i = 1; i <= n; i++) {\\n            \\/\\/ Compute next row of pascal\\n            \\/\\/ triangle using the...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You are given a keyboard that consists of 26 keys. The keys are arranged sequentially in one row in a certain order. Each key corresponds to a unique lowercase Latin letter.\\n\\nYou have to type the word s on this keyboard. It also consists only of lowercase Latin letters.\\n\\nTo type a word, you need to type all its letters consecutively one by one. To type each letter you must position your hand exactly over the corresponding key and press it.\\n\\nMoving the hand between the keys takes time which is equal to the absolute value of the difference between positions of these keys (the keys are numbered from left to right). No time is spent on pressing the keys and on placing your hand over the first letter of the word.\\n\\nFor example, consider a keyboard where the letters from 'a' to 'z' are arranged in consecutive alphabetical order. The letters 'h', 'e', 'l' and 'o' then are on the positions 8, 5, 12 and 15, respectively. Therefore, it will take |5 - 8| + |12 - 5| + |12 - 12| + |15 - 12| = 13 units of time to type the word \\\"hello\\\". \\n\\nDetermine how long it will take to print the word s.\\n\\nInput\\n\\nThe first line contains an integer t (1 \u2264 t \u2264 1000) \u2014 the number of test cases.\\n\\nThe next 2t lines contain descriptions of the test cases.\\n\\nThe first line of a description contains a keyboard \u2014 a string of length 26, which consists only of lowercase Latin letters. Each of the letters from 'a' to 'z' appears exactly once on the keyboard.\\n\\nThe second line of the description contains the word s. The word has a length from 1 to 50 letters inclusive and consists of lowercase Latin letters.\\n\\nOutput\\n\\nPrint t lines, each line containing the answer to the corresponding test case. The answer to the test case is the minimal time it takes to type the word s on the given keyboard.\\n\\nExample\\n\\nInput\\n\\n\\n5\\nabcdefghijklmnopqrstuvwxyz\\nhello\\nabcdefghijklmnopqrstuvwxyz\\ni\\nabcdefghijklmnopqrstuvwxyz\\ncodeforces\\nqwertyuiopasdfghjklzxcvbnm\\nqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\nqwertyuiopasdfghjklzxcvbnm\\nabacaba\\n\\n\\nOutput\\n\\n\\n13\\n0\\n68\\n0\\n74\\nUsing cpp can you solve the prior task?\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst int maxn = 100;\\nchar s1[maxn];\\nchar s2[maxn];\\nint main() {\\n  ios_base ::sync_with_stdio(0);\\n  cin.tie(0);\\n  cout.tie(0);\\n  int t;\\n  cin >> t;\\n  while (t--) {\\n    cin >> s1 + 1;\\n    cin >> s2 + 1;\\n    int len1 = strlen(s1 + 1);\\n    int len2 = strlen(s2 + 1);\\n    int sum = 0;\\n    int pos1, pos2;\\n    for (int i = 1; i <= len2; i++) {\\n      for (int j = 1; j <= len1; j++) {\\n        if (s2[i] == s1[j]) {\\n          pos1 = j;\\n        }\\n        if (s2[i + 1] == s1[j]) {\\n          pos2 = j;\\n        }\\n      }\\n      sum += abs(pos2 - pos1);\\n    }\\n    if (len2 == 1)\\n      cout << 0 << endl;\\n    else\\n      cout << sum << endl;\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Consider the insertion sort algorithm used to sort an integer sequence [a_1, a_2, \u2026, a_n] of length n in non-decreasing order.\\n\\nFor each i in order from 2 to n, do the following. If a_i \u2265 a_{i-1}, do nothing and move on to the next value of i. Otherwise, find the smallest j such that a_i < a_j, shift the elements on positions from j to i-1 by one position to the right, and write down the initial value of a_i to position j. In this case we'll say that we performed an insertion of an element from position i to position j.\\n\\nIt can be noticed that after processing any i, the prefix of the sequence [a_1, a_2, \u2026, a_i] is sorted in non-decreasing order, therefore, the algorithm indeed sorts any sequence.\\n\\nFor example, sorting [4, 5, 3, 1, 3] proceeds as follows: \\n\\n  * i = 2: a_2 \u2265 a_1, do nothing; \\n  * i = 3: j = 1, insert from position 3 to position 1: [3, 4, 5, 1, 3]; \\n  * i = 4: j = 1, insert from position 4 to position 1: [1, 3, 4, 5, 3]; \\n  * i = 5: j = 3, insert from position 5 to position 3: [1, 3, 3, 4, 5]. \\n\\n\\n\\nYou are given an integer n and a list of m integer pairs (x_i, y_i). We are interested in sequences such that if you sort them using the above algorithm, exactly m insertions will be performed: first from position x_1 to position y_1, then from position x_2 to position y_2, ..., finally, from position x_m to position y_m.\\n\\nHow many sequences of length n consisting of (not necessarily distinct) integers between 1 and n, inclusive, satisfy the above condition? Print this number modulo 998 244 353.\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 10^5). Description of the test cases follows.\\n\\nThe first line of each test case contains two integers n and m (2 \u2264 n \u2264 2 \u22c5 10^5; 0 \u2264 m < n) \u2014 the length of the sequence and the number of insertions.\\n\\nThe i-th of the following m lines contains two integers x_i and y_i (2 \u2264 x_1 < x_2 < \u2026 < x_m \u2264 n; 1 \u2264 y_i < x_i). These lines describe the sequence of insertions in chronological order.\\n\\nIt is guaranteed...\\n#incl\",\"targets\":\"ude <bits\\/stdc++.h>\\n#pragma GCC optimize(\\\"Ofast,no-stack-protector,unroll-loops,fast-math\\\")\\nusing namespace std;\\ntemplate <class T>\\nusing rque = priority_queue<T, vector<T>, greater<T>>;\\ntemplate <class T>\\nbool chmin(T &a, const T &b) {\\n  if (b < a) {\\n    a = b;\\n    return 1;\\n  }\\n  return 0;\\n}\\ntemplate <class T>\\nbool chmax(T &a, const T &b) {\\n  if (b > a) {\\n    a = b;\\n    return 1;\\n  }\\n  return 0;\\n}\\nlong long gcd(long long a, long long b) {\\n  if (a == 0) return b;\\n  if (b == 0) return a;\\n  long long cnt = a % b;\\n  while (cnt != 0) {\\n    a = b;\\n    b = cnt;\\n    cnt = a % b;\\n  }\\n  return b;\\n}\\nlong long extGCD(long long a, long long b, long long &x, long long &y) {\\n  if (b == 0) {\\n    x = 1;\\n    y = 0;\\n    return a;\\n  }\\n  long long d = extGCD(b, a % b, y, x);\\n  y -= a \\/ b * x;\\n  return d;\\n}\\nstruct UnionFind {\\n  vector<long long> data;\\n  int num;\\n  UnionFind(int sz) {\\n    data.assign(sz, -1);\\n    num = sz;\\n  }\\n  bool unite(int x, int y) {\\n    x = find(x), y = find(y);\\n    if (x == y) return (false);\\n    if (data[x] > data[y]) swap(x, y);\\n    data[x] += data[y];\\n    data[y] = x;\\n    num--;\\n    return (true);\\n  }\\n  int find(int k) {\\n    if (data[k] < 0) return (k);\\n    return (data[k] = find(data[k]));\\n  }\\n  long long size(int k) { return (-data[find(k)]); }\\n  bool same(int x, int y) { return find(x) == find(y); }\\n};\\ntemplate <int mod>\\nstruct ModInt {\\n  int x;\\n  ModInt() : x(0) {}\\n  ModInt(int64_t y) : x(y >= 0 ? y % mod : (mod - (-y) % mod) % mod) {}\\n  ModInt &operator+=(const ModInt &p) {\\n    if ((x += p.x) >= mod) x -= mod;\\n    return *this;\\n  }\\n  ModInt &operator-=(const ModInt &p) {\\n    if ((x += mod - p.x) >= mod) x -= mod;\\n    return *this;\\n  }\\n  ModInt &operator*=(const ModInt &p) {\\n    x = (int)(1LL * x * p.x % mod);\\n    return *this;\\n  }\\n  ModInt &operator\\/=(const ModInt &p) {\\n    *this *= p.inverse();\\n    return *this;\\n  }\\n  ModInt operator-() const { return ModInt(-x); }\\n  ModInt operator+(const ModInt &p) const { return ModInt(*this) += p; }\\n  ModInt operator-(const ModInt &p) const { return...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in CPP?\\nAlice and Bob play a game. There is a paper strip which is divided into n + 1 cells numbered from left to right starting from 0. There is a chip placed in the n-th cell (the last one).\\n\\nPlayers take turns, Alice is first. Each player during his or her turn has to move the chip 1, 2 or k cells to the left (so, if the chip is currently in the cell i, the player can move it into cell i - 1, i - 2 or i - k). The chip should not leave the borders of the paper strip: it is impossible, for example, to move it k cells to the left if the current cell has number i < k. The player who can't make a move loses the game.\\n\\nWho wins if both participants play optimally?\\n\\nAlice and Bob would like to play several games, so you should determine the winner in each game.\\n\\nInput\\n\\nThe first line contains the single integer T (1 \u2264 T \u2264 100) \u2014 the number of games. Next T lines contain one game per line. All games are independent.\\n\\nEach of the next T lines contains two integers n and k (0 \u2264 n \u2264 109, 3 \u2264 k \u2264 109) \u2014 the length of the strip and the constant denoting the third move, respectively.\\n\\nOutput\\n\\nFor each game, print Alice if Alice wins this game and Bob otherwise.\\n\\nExample\\n\\nInput\\n\\n4\\n0 3\\n3 3\\n3 4\\n4 4\\n\\n\\nOutput\\n\\nBob\\nAlice\\nBob\\nAlice\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint n, t, k;\\nint main() {\\n  cin >> t;\\n  while (t--) {\\n    cin >> n >> k;\\n    if (n == 0)\\n      cout << \\\"Bob\\\" << endl;\\n    else if (k % 3 != 0) {\\n      if (n % 3 == 0)\\n        cout << \\\"Bob\\\" << endl;\\n      else\\n        cout << \\\"Alice\\\" << endl;\\n    } else if ((n % (k + 1)) % 3 == 0 && (n % (k + 1)) != k)\\n      cout << \\\"Bob\\\" << endl;\\n    else\\n      cout << \\\"Alice\\\" << endl;\\n  }\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"Two players, Red and Blue, are at it again, and this time they're playing with crayons! The mischievous duo is now vandalizing a rooted tree, by coloring the nodes while playing their favorite game.\\n\\nThe game works as follows: there is a tree of size n, rooted at node 1, where each node is initially white. Red and Blue get one turn each. Red goes first. \\n\\nIn Red's turn, he can do the following operation any number of times: \\n\\n  * Pick any subtree of the rooted tree, and color every node in the subtree red. \\n\\nHowever, to make the game fair, Red is only allowed to color k nodes of the tree. In other words, after Red's turn, at most k of the nodes can be colored red.\\n\\nThen, it's Blue's turn. Blue can do the following operation any number of times: \\n\\n  * Pick any subtree of the rooted tree, and color every node in the subtree blue. However, he's not allowed to choose a subtree that contains a node already colored red, as that would make the node purple and no one likes purple crayon. \\n\\nNote: there's no restriction on the number of nodes Blue can color, as long as he doesn't color a node that Red has already colored.\\n\\nAfter the two turns, the score of the game is determined as follows: let w be the number of white nodes, r be the number of red nodes, and b be the number of blue nodes. The score of the game is w \u22c5 (r - b).\\n\\nRed wants to maximize this score, and Blue wants to minimize it. If both players play optimally, what will the final score of the game be?\\n\\nInput\\n\\nThe first line contains two integers n and k (2 \u2264 n \u2264 2 \u22c5 10^5; 1 \u2264 k \u2264 n) \u2014 the number of vertices in the tree and the maximum number of red nodes.\\n\\nNext n - 1 lines contains description of edges. The i-th line contains two space separated integers u_i and v_i (1 \u2264 u_i, v_i \u2264 n; u_i \u2260 v_i) \u2014 the i-th edge of the tree.\\n\\nIt's guaranteed that given edges form a tree.\\n\\nOutput\\n\\nPrint one integer \u2014 the resulting score if both Red and Blue play optimally.\\n\\nExamples\\n\\nInput\\n\\n\\n4 2\\n1 2\\n1 3\\n1 4\\n\\n\\nOutput\\n\\n\\n1\\n\\n\\nInput\\n\\n\\n5 2\\n1 2\\n2 3\\n3 4\\n4 5\\n\\n\\nOutput\\n\\n\\n6\\n\\n\\nInput\\n\\n\\n7...\\\":\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst int N = 2e5 + 10;\\nint n, k;\\nint dep[N];\\nint len[N], tot = 0;\\nvector<int> son[N];\\nvoid dfs(int u, int fa) {\\n  int dson = -1;\\n  int deg = 0;\\n  for (int v : son[u])\\n    if (v != fa) {\\n      dfs(v, u), deg++;\\n      if (dson == -1 || dep[v] > dep[dson]) dson = v;\\n    }\\n  if (deg == 0) {\\n    dep[u] = 1;\\n    return;\\n  }\\n  for (int v : son[u])\\n    if (v != fa) {\\n      if (v != dson) {\\n        len[++tot] = dep[v];\\n      }\\n    }\\n  dep[u] = dep[dson] + 1;\\n  return;\\n}\\nlong long f(int b) { return 1ll * (n - k - b) * (k - b); }\\nvoid solve() {\\n  tot = 0;\\n  cin >> n >> k;\\n  for (int i = 1; i <= n; i++) son[i].clear();\\n  for (int i = 1, u, v; i < n; i++) {\\n    cin >> u >> v;\\n    son[u].emplace_back(v), son[v].emplace_back(u);\\n  }\\n  dfs(1, 0);\\n  len[++tot] = dep[1];\\n  sort(len + 1, len + tot + 1, greater<int>());\\n  if (k >= tot) {\\n    long long ans = 0;\\n    for (int i = tot; i <= k; i++) ans = max(ans, 1ll * i * (n - i));\\n    cout << ans << endl;\\n  } else {\\n    int r = 0;\\n    for (int i = 1; i <= k; i++) r += len[i];\\n    r -= k;\\n    long long ans = f(0);\\n    for (int i = 1; i <= n - r - k; i++) ans = min(ans, f(i));\\n    cout << ans << endl;\\n  }\\n  return;\\n}\\nint main() {\\n  ios::sync_with_stdio(0);\\n  cin.tie(0), cout.tie(0);\\n  solve();\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"An ant moves on the real line with constant speed of 1 unit per second. It starts at 0 and always moves to the right (so its position increases by 1 each second).\\n\\nThere are n portals, the i-th of which is located at position x_i and teleports to position y_i < x_i. Each portal can be either active or inactive. The initial state of the i-th portal is determined by s_i: if s_i=0 then the i-th portal is initially inactive, if s_i=1 then the i-th portal is initially active. When the ant travels through a portal (i.e., when its position coincides with the position of a portal): \\n\\n  * if the portal is inactive, it becomes active (in this case the path of the ant is not affected); \\n  * if the portal is active, it becomes inactive and the ant is instantly teleported to the position y_i, where it keeps on moving as normal. \\n\\n\\n\\nHow long (from the instant it starts moving) does it take for the ant to reach the position x_n + 1? It can be shown that this happens in a finite amount of time. Since the answer may be very large, compute it modulo 998 244 353.\\n\\nInput\\n\\nThe first line contains the integer n (1\u2264 n\u2264 2\u22c5 10^5) \u2014 the number of portals.\\n\\nThe i-th of the next n lines contains three integers x_i, y_i and s_i (1\u2264 y_i < x_i\u2264 10^9, s_i\u2208\\\\{0,1\\\\}) \u2014 the position of the i-th portal, the position where the ant is teleported when it travels through the i-th portal (if it is active), and the initial state of the i-th portal.\\n\\nThe positions of the portals are strictly increasing, that is x_1<x_2<\u22c5\u22c5\u22c5<x_n. It is guaranteed that the 2n integers x_1,   x_2,   ...,   x_n,   y_1,   y_2,   ...,   y_n are all distinct.\\n\\nOutput\\n\\nOutput the amount of time elapsed, in seconds, from the instant the ant starts moving to the instant it reaches the position x_n+1. Since the answer may be very large, output it modulo 998 244 353.\\n\\nExamples\\n\\nInput\\n\\n\\n4\\n3 2 0\\n6 5 1\\n7 4 0\\n8 1 1\\n\\n\\nOutput\\n\\n\\n23\\n\\n\\nInput\\n\\n\\n1\\n454971987 406874902 1\\n\\n\\nOutput\\n\\n\\n503069073\\n\\n\\nInput\\n\\n\\n5\\n243385510 42245605 0\\n644426565 574769163 0\\n708622105 208990040 0\\n786625660 616437691...\\\":\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing ll = long long;\\nusing ld = long double;\\nusing ull = unsigned long long;\\nusing namespace std;\\nconst int N = 2e5 + 3, mod = 998244353;\\nint n, x[N], y[N];\\nll s[N];\\nvector<array<int, 3> > eve;\\nint main() {\\n  ios_base::sync_with_stdio(false);\\n  cin.tie(nullptr);\\n  cin >> n;\\n  for (int i = (1); i <= (n); ++i) {\\n    cin >> x[i] >> y[i] >> s[i];\\n    eve.push_back({x[i], i, 1});\\n    eve.push_back({y[i], i, -1});\\n  }\\n  sort((eve).begin(), (eve).end(), greater<array<int, 3> >());\\n  int sum = 0;\\n  for (auto &E : eve) {\\n    if (E[2] == 1)\\n      (s[E[1]] += sum) %= mod, (sum += s[E[1]]) %= mod;\\n    else\\n      (sum -= s[E[1]] - mod) %= mod;\\n  }\\n  int ans = x[n] + 1;\\n  for (int i = (1); i <= (n); ++i)\\n    (ans += s[i] * 1LL * (x[i] - y[i]) % mod) %= mod;\\n  cout << ans;\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"<image>\\n\\nWilliam has an array of n integers a_1, a_2, ..., a_n. In one move he can swap two neighboring items. Two items a_i and a_j are considered neighboring if the condition |i - j| = 1 is satisfied.\\n\\nWilliam wants you to calculate the minimal number of swaps he would need to perform to make it so that the array does not contain two neighboring items with the same parity.\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 10^4). Description of the test cases follows.\\n\\nThe first line of each test case contains an integer n (1 \u2264 n \u2264 10^5) which is the total number of items in William's array.\\n\\nThe second line contains n integers a_1, a_2, ..., a_n (1 \u2264 a_i \u2264 10^9) which are William's array.\\n\\nIt is guaranteed that the sum of n over all test cases does not exceed 10^5.\\n\\nOutput\\n\\nFor each test case output the minimal number of operations needed or -1 if it is impossible to get the array to a state when no neighboring numbers have the same parity.\\n\\nExample\\n\\nInput\\n\\n\\n5\\n3\\n6 6 1\\n1\\n9\\n6\\n1 1 1 2 2 2\\n2\\n8 6\\n6\\n6 2 3 4 5 1\\n\\n\\nOutput\\n\\n\\n1\\n0\\n3\\n-1\\n2\\n\\nNote\\n\\nIn the first test case the following sequence of operations would satisfy the requirements: \\n\\n  1. swap(2, 3). Array after performing the operation: [6, 1, 6] \\n\\n\\n\\nIn the second test case the array initially does not contain two neighboring items of the same parity.\\n\\nIn the third test case the following sequence of operations would satisfy the requirements: \\n\\n  1. swap(3, 4). Array after performing the operation: [1, 1, 2, 1, 2, 2] \\n  2. swap(2, 3). Array after performing the operation: [1, 2, 1, 1, 2, 2] \\n  3. swap(4, 5). Array after performing the operation: [1, 2, 1, 2, 1, 2] \\n\\n\\n\\nIn the fourth test case it is impossible to satisfy the requirements.\\n\\nIn the fifth test case the following sequence of operations would satisfy the requirements: \\n\\n  1. swap(2, 3). Array after performing the operation: [6, 3, 2, 4, 5, 1] \\n  2. swap(4, 5). Array after performing the operation: [6, 3, 2, 5, 4, 1]\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst int N = 5e6 + 10;\\nlong long a[N], n;\\nbool is[N];\\ninline long long Read() {\\n  long long x = 0, f = 1;\\n  char ch = getchar();\\n  while (ch > '9' || ch < '0') {\\n    if (ch == '-') f = -1;\\n    ch = getchar();\\n  }\\n  while (ch >= '0' && ch <= '9') {\\n    x = x * 10 + ch - '0';\\n    ch = getchar();\\n  }\\n  return x * f;\\n}\\nvoid work() {\\n  long long ans = 1e18;\\n  int e = 0, o = 0;\\n  n = Read();\\n  for (int i = 1; i <= n; ++i) {\\n    a[i] = Read();\\n    if (a[i] % 2 == 0)\\n      e++, is[i] = 0;\\n    else\\n      o++, is[i] = 1;\\n  }\\n  if (n % 2 == 0) {\\n    if (o != e)\\n      puts(\\\"-1\\\");\\n    else {\\n      long long c1 = 0, c0 = 0;\\n      for (int i = 1, j = 1, k = 1; i <= n; ++i) {\\n        if (is[i] == 1) {\\n          c1 += abs(i - j);\\n          j += 2;\\n        } else {\\n          c0 += abs(i - k);\\n          k += 2;\\n        }\\n      }\\n      ans = min(min(ans, c0), c1);\\n      cout << ans << '\\\\n';\\n    }\\n  } else {\\n    if (o == n \\/ 2 && e == n \\/ 2 + 1) {\\n      long long c = 0;\\n      for (int i = 1, j = 1; i <= n; ++i) {\\n        if (is[i] == 0) {\\n          c += abs(i - j);\\n          j += 2;\\n        }\\n      }\\n      ans = min(ans, c);\\n      cout << ans << '\\\\n';\\n    } else if (e == n \\/ 2 && o == n \\/ 2 + 1) {\\n      long long c = 0;\\n      for (int i = 1, j = 1; i <= n; ++i) {\\n        if (is[i] == 1) {\\n          c += abs(i - j);\\n          j += 2;\\n        }\\n      }\\n      ans = min(ans, c);\\n      cout << ans << '\\\\n';\\n    } else\\n      puts(\\\"-1\\\");\\n  }\\n}\\nint main() {\\n  int T;\\n  cin >> T;\\n  while (T--) work();\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Arthur has bought a beautiful big table into his new flat. When he came home, Arthur noticed that the new table is unstable.\\n\\nIn total the table Arthur bought has n legs, the length of the i-th leg is li.\\n\\nArthur decided to make the table stable and remove some legs. For each of them Arthur determined number di \u2014 the amount of energy that he spends to remove the i-th leg.\\n\\nA table with k legs is assumed to be stable if there are more than half legs of the maximum length. For example, to make a table with 5 legs stable, you need to make sure it has at least three (out of these five) legs of the maximum length. Also, a table with one leg is always stable and a table with two legs is stable if and only if they have the same lengths.\\n\\nYour task is to help Arthur and count the minimum number of energy units Arthur should spend on making the table stable.\\n\\nInput\\n\\nThe first line of the input contains integer n (1 \u2264 n \u2264 105) \u2014 the initial number of legs in the table Arthur bought.\\n\\nThe second line of the input contains a sequence of n integers li (1 \u2264 li \u2264 105), where li is equal to the length of the i-th leg of the table.\\n\\nThe third line of the input contains a sequence of n integers di (1 \u2264 di \u2264 200), where di is the number of energy units that Arthur spends on removing the i-th leg off the table.\\n\\nOutput\\n\\nPrint a single integer \u2014 the minimum number of energy units that Arthur needs to spend in order to make the table stable.\\n\\nExamples\\n\\nInput\\n\\n2\\n1 5\\n3 2\\n\\n\\nOutput\\n\\n2\\n\\n\\nInput\\n\\n3\\n2 4 4\\n1 1 1\\n\\n\\nOutput\\n\\n0\\n\\n\\nInput\\n\\n6\\n2 2 1 1 3 3\\n4 3 5 5 2 1\\n\\n\\nOutput\\n\\n8\\nUsing java can you solve the prior task?\",\"targets\":\"import java.util.*;\\nimport java.util.LinkedList;\\nimport java.io.BufferedReader;\\nimport java.io.InputStreamReader;\\nimport java.util.StringTokenizer;\\n\\npublic class tmp {\\n    public static void main(String [] args) throws Exception{\\n        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));\\n        StringTokenizer st = new StringTokenizer(in.readLine());\\n        StringBuilder sb = new StringBuilder();\\n        \\n        int n = Integer.parseInt(st.nextToken());\\n\\tint tot = n;\\n\\tint array[] = new int[n];\\n\\t\\n\\tArrayList<Integer>[] list = new ArrayList[100005];\\n\\t\\n\\tfor(int i = 0;i<list.length;i++)\\n\\t\\tlist[i] = new ArrayList<Integer>();\\n\\t\\t\\n\\tst = new StringTokenizer(in.readLine());\\n\\t\\n\\tfor(int i = 0;i < n;i++){\\n\\t\\tarray[i] = Integer.parseInt(st.nextToken());\\n\\t}\\n\\tint d[] = new int[205];\\n\\tst = new StringTokenizer(in.readLine());\\n\\tfor(int i = 0;i < n;i++){\\n\\t\\tint cost = Integer.parseInt(st.nextToken());\\n\\t\\td[cost]++;\\n\\t\\tlist[array[i]].add(cost);\\n\\t}\\n\\t\\n\\tlong cnt = 0;\\n\\tlong ans = 100000005;\\n\\tfor(int i = list.length - 1;i>=0;i--){\\n\\t\\tif(list[i].isEmpty())\\n                    continue;\\n\\t\\tint var = 0;\\n\\t\\tint aux = 0;\\n\\t\\tfor(int j = 0;j < list[i].size();j++){\\n                    int tmp = list[i].get(j);\\n                    d[tmp]--;\\n                    var += tmp;\\n\\t\\t}\\n\\t\\tint left = tot - (2*list[i].size() - 1);\\n\\t\\t\\/\\/System.out.println(left);\\n\\t\\tfor(int j = 1;j < d.length && left > 0;j++){\\n\\t\\t\\taux += Math.min(left,d[j])*j;\\n\\t\\t\\tleft -= d[j];\\n\\t\\t}\\n\\t\\tans = Math.min(ans,cnt + aux);\\n\\t\\tcnt += var;\\n\\t\\ttot -= list[i].size();\\n\\t\\t\\n\\t}\\n\\tSystem.out.println(ans);\\n        \\n        \\n     \\n        \\n        \\n        \\n        \\n        \\n        \\n        \\n        \\n        \\n        \\n        \\n        \\n        \\n        \\n        \\n        \\n        \\n    }\\n    \\n    \\n\\n    \\n    \\n    \\n    \\n    \\n\\n\\n    \\n    \\n    \\n    \\n}\\n\\n    \\nclass P implements Comparable<P>{\\n    int val, idx;\\n    public P(int val, int idx){\\n        this.val = val;\\n        this.idx = idx;\\n    }\\n\\n    public int compareTo(P other){\\n        if (this.val != other.val) return -this.val +...\",\"language\":\"python\",\"split\":\"train\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"JAVA solution for \\\"The only difference between this problem and D2 is that you don't have to provide the way to construct the answer in this problem, but you have to do it in D2.\\n\\nThere's a table of n \u00d7 m cells (n rows and m columns). The value of n \u22c5 m is even.\\n\\nA domino is a figure that consists of two cells having a common side. It may be horizontal (one of the cells is to the right of the other) or vertical (one of the cells is above the other).\\n\\nYou need to find out whether it is possible to place nm\\/2 dominoes on the table so that exactly k of them are horizontal and all the other dominoes are vertical. The dominoes cannot overlap and must fill the whole table.\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 10) \u2014 the number of test cases. Then t test cases follow.\\n\\nEach test case consists of a single line. The line contains three integers n, m, k (1 \u2264 n,m \u2264 100, 0 \u2264 k \u2264 nm\\/2, n \u22c5 m is even) \u2014 the number of rows, columns and horizontal dominoes, respectively.\\n\\nOutput\\n\\nFor each test case output \\\"YES\\\", if it is possible to place dominoes in the desired way, or \\\"NO\\\" otherwise.\\n\\nYou may print each letter in any case (YES, yes, Yes will all be recognized as positive answer, NO, no and nO will all be recognized as negative answer).\\n\\nExample\\n\\nInput\\n\\n\\n8\\n4 4 2\\n2 3 0\\n3 2 3\\n1 2 0\\n2 4 2\\n5 2 2\\n2 17 16\\n2 1 1\\n\\n\\nOutput\\n\\n\\nYES\\nYES\\nYES\\nNO\\nYES\\nNO\\nYES\\nNO\\\":\",\"targets\":\"\\/\\/ package com.company;\\nimport java.util.*;\\nimport java.io.*;\\nimport java.lang.*;\\nimport java.util.jar.JarEntry;\\n\\npublic class Main{\\n    \\/* || \u0936\u094d\u0930\u0940 \u0917\u0923\u0947\u0936\u093e\u092f \u0928\u092e\u0903 ||\\n       @\ud835\udc1a\ud835\udc2e\ud835\udc2d\ud835\udc21\ud835\udc28\ud835\udc2b \ud835\udc09\ud835\udc22\ud835\udc20\ud835\udc1a\ud835\udc2b \ud835\udc0d\ud835\udc1a\ud835\udc22\ud835\udc27\ud835\udc2e\ud835\udc23\ud835\udc22\\n       \ud835\udc12\ud835\udc15\ud835\udc0d\ud835\udc08\ud835\udc13- \ud835\udc12\ud835\udc2e\ud835\udc2b\ud835\udc1a\ud835\udc2d\\n    *\\/\\n    public static void main(String args[]){\\n        InputReader in=new InputReader(System.in);\\n        TASK solver = new TASK();\\n        int t=1;\\n        t = in.nextInt();\\n        for(int i=1;i<=t;i++)\\n        {\\n            solver.solve(in,i);\\n        }\\n    }\\n    static class TASK {\\n\\n\\n        void solve(InputReader in, int testNumber) {\\n           int n = in.nextInt();\\n           int m = in.nextInt();\\n           int k = in.nextInt();\\n           if(n==1)\\n           {\\n               if(k==m\\/2)\\n                   System.out.println(\\\"YES\\\");\\n               else\\n                   System.out.println(\\\"NO\\\");\\n               return;\\n           }\\n           if(m==1)\\n           {\\n               if(k==0)\\n                   System.out.println(\\\"YES\\\");\\n               else\\n                   System.out.println(\\\"NO\\\");\\n               return;\\n           }\\n           if(n%2==1 && m%2==0)\\n           {\\n               int min = m\\/2;\\n               if(k<min)\\n               {\\n                   System.out.println(\\\"NO\\\");\\n                   return;\\n               }\\n               k-=min;\\n               n--;\\n               if((n-k%n)%2==0)\\n               {\\n                   System.out.println(\\\"YES\\\");\\n               }\\n               else\\n                   System.out.println(\\\"NO\\\");\\n\\n           }\\n           else if(n%2==0 && m%2==1)\\n           {\\n               int kk = (m*n)\\/2-k;\\n               int min=n\\/2;\\n               if(kk<min)\\n               {\\n                   System.out.println(\\\"NO\\\");\\n                   return;\\n               }\\n               kk-=min;\\n               m--;\\n               if((m-k%m)%2==0)\\n               {\\n                   System.out.println(\\\"YES\\\");\\n               }\\n               else\\n                   System.out.println(\\\"NO\\\");\\n\\n           }\\n           else\\n           {\\n              ...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"PizzaForces is Petya's favorite pizzeria. PizzaForces makes and sells pizzas of three sizes: small pizzas consist of 6 slices, medium ones consist of 8 slices, and large pizzas consist of 10 slices each. Baking them takes 15, 20 and 25 minutes, respectively.\\n\\nPetya's birthday is today, and n of his friends will come, so he decided to make an order from his favorite pizzeria. Petya wants to order so much pizza that each of his friends gets at least one slice of pizza. The cooking time of the order is the total baking time of all the pizzas in the order.\\n\\nYour task is to determine the minimum number of minutes that is needed to make pizzas containing at least n slices in total. For example: \\n\\n  * if 12 friends come to Petya's birthday, he has to order pizzas containing at least 12 slices in total. He can order two small pizzas, containing exactly 12 slices, and the time to bake them is 30 minutes; \\n  * if 15 friends come to Petya's birthday, he has to order pizzas containing at least 15 slices in total. He can order a small pizza and a large pizza, containing 16 slices, and the time to bake them is 40 minutes; \\n  * if 300 friends come to Petya's birthday, he has to order pizzas containing at least 300 slices in total. He can order 15 small pizzas, 10 medium pizzas and 13 large pizzas, in total they contain 15 \u22c5 6 + 10 \u22c5 8 + 13 \u22c5 10 = 300 slices, and the total time to bake them is 15 \u22c5 15 + 10 \u22c5 20 + 13 \u22c5 25 = 750 minutes; \\n  * if only one friend comes to Petya's birthday, he can order a small pizza, and the time to bake it is 15 minutes. \\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 10^4) \u2014 the number of testcases.\\n\\nEach testcase consists of a single line that contains a single integer n (1 \u2264 n \u2264 10^{16}) \u2014 the number of Petya's friends.\\n\\nOutput\\n\\nFor each testcase, print one integer \u2014 the minimum number of minutes that is needed to bake pizzas containing at least n slices in total.\\n\\nExample\\n\\nInput\\n\\n\\n6\\n12\\n15\\n300\\n1\\n9999999999999999\\n3\\n\\n\\nOutput\\n\\n\\n30\\n40\\n750\\n15\\n25000000000000000\\n15\\nSolve the task in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nconst long long _INF = 1e18;\\nconst int INF = 1e9;\\nusing namespace std;\\nint T;\\nvoid solved() {\\n  long long n = 0;\\n  cin >> n;\\n  if (n % 2 == 1) n++;\\n  if (n <= 6)\\n    cout << 15 << \\\"\\\\n\\\";\\n  else\\n    cout << n * 5 \\/ 2 << \\\"\\\\n\\\";\\n}\\nint main() {\\n  setbuf(stdout, NULL);\\n  ios::sync_with_stdio(0);\\n  cin.tie(0);\\n  cin >> T;\\n  for (int i = 0; i < (T); i++) {\\n    solved();\\n  }\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"There are n block towers in a row, where tower i has a height of a_i. You're part of a building crew, and you want to make the buildings look as nice as possible. In a single day, you can perform the following operation:\\n\\n  * Choose two indices i and j (1 \u2264 i, j \u2264 n; i \u2260 j), and move a block from tower i to tower j. This essentially decreases a_i by 1 and increases a_j by 1. \\n\\n\\n\\nYou think the ugliness of the buildings is the height difference between the tallest and shortest buildings. Formally, the ugliness is defined as max(a)-min(a). \\n\\nWhat's the minimum possible ugliness you can achieve, after any number of days?\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 1000) \u2014 the number of test cases. Then t cases follow.\\n\\nThe first line of each test case contains one integer n (2 \u2264 n \u2264 100) \u2014 the number of buildings.\\n\\nThe second line of each test case contains n space separated integers a_1, a_2, \u2026, a_n (1 \u2264 a_i \u2264 10^7) \u2014 the heights of the buildings.\\n\\nOutput\\n\\nFor each test case, output a single integer \u2014 the minimum possible ugliness of the buildings.\\n\\nExample\\n\\nInput\\n\\n\\n3\\n3\\n10 10 10\\n4\\n3 2 1 2\\n5\\n1 2 3 1 5\\n\\n\\nOutput\\n\\n\\n0\\n0\\n1\\n\\nNote\\n\\nIn the first test case, the ugliness is already 0.\\n\\nIn the second test case, you should do one operation, with i = 1 and j = 3. The new heights will now be [2, 2, 2, 2], with an ugliness of 0.\\n\\nIn the third test case, you may do three operations: \\n\\n  1. with i = 3 and j = 1. The new array will now be [2, 2, 2, 1, 5], \\n  2. with i = 5 and j = 4. The new array will now be [2, 2, 2, 2, 4], \\n  3. with i = 5 and j = 3. The new array will now be [2, 2, 3, 2, 3]. \\n\\nThe resulting ugliness is 1. It can be proven that this is the minimum possible ugliness for this test.\\nSolve the task in PYTHON3.\",\"targets\":\"tcase = int(input())\\nfor i in range(tcase):\\n    n = int(input())\\n    lst = list(map(int,input().split()))\\n    v = sum(lst)\\n    if v%n == 0:\\n        print(0)\\n    else:\\n        print(1)\",\"language\":\"python\",\"split\":\"test\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"It is the easy version of the problem. The only difference is that in this version n = 1.\\n\\nIn the cinema seats can be represented as the table with n rows and m columns. The rows are numbered with integers from 1 to n. The seats in each row are numbered with consecutive integers from left to right: in the k-th row from m (k - 1) + 1 to m k for all rows 1 \u2264 k \u2264 n.\\n\\n1| 2| \u22c5\u22c5\u22c5| m - 1| m  \\n---|---|---|---|---  \\nm + 1| m + 2| \u22c5\u22c5\u22c5| 2 m - 1| 2 m  \\n2m + 1| 2m + 2| \u22c5\u22c5\u22c5| 3 m - 1| 3 m  \\n\\\\vdots| \\\\vdots| \\\\ddots| \\\\vdots| \\\\vdots  \\nm (n - 1) + 1| m (n - 1) + 2| \u22c5\u22c5\u22c5| n m - 1| n m  \\nThe table with seats indices\\n\\nThere are nm people who want to go to the cinema to watch a new film. They are numbered with integers from 1 to nm. You should give exactly one seat to each person.\\n\\nIt is known, that in this cinema as lower seat index you have as better you can see everything happening on the screen. i-th person has the level of sight a_i. Let's define s_i as the seat index, that will be given to i-th person. You want to give better places for people with lower sight levels, so for any two people i, j such that a_i < a_j it should be satisfied that s_i < s_j.\\n\\nAfter you will give seats to all people they will start coming to their seats. In the order from 1 to nm, each person will enter the hall and sit in their seat. To get to their place, the person will go to their seat's row and start moving from the first seat in this row to theirs from left to right. While moving some places will be free, some will be occupied with people already seated. The inconvenience of the person is equal to the number of occupied seats he or she will go through.\\n\\nLet's consider an example: m = 5, the person has the seat 4 in the first row, the seats 1, 3, 5 in the first row are already occupied, the seats 2 and 4 are free. The inconvenience of this person will be 2, because he will go through occupied seats 1 and 3.\\n\\nFind the minimal total inconvenience (the sum of inconveniences of all people), that is possible to have by giving places for all people...\\nUsing python3 can you solve the prior task?\",\"targets\":\"# Author : nitish420 --------------------------------------------------------------------\\nimport os\\nimport sys\\nfrom io import BytesIO, IOBase\\n\\nclass SortedList:\\n    def __init__(self, iterable=None, _load=200):\\n        \\\"\\\"\\\"Initialize sorted list instance.\\\"\\\"\\\"\\n        if iterable is None:\\n            iterable = []\\n        values = sorted(iterable)\\n        self._len = _len = len(values)\\n        self._load = _load\\n        self._lists = _lists = [values[i:i + _load] for i in range(0, _len, _load)]\\n        self._list_lens = [len(_list) for _list in _lists]\\n        self._mins = [_list[0] for _list in _lists]\\n        self._fen_tree = []\\n        self._rebuild = True\\n\\n    def _fen_build(self):\\n        \\\"\\\"\\\"Build a fenwick tree instance.\\\"\\\"\\\"\\n        self._fen_tree[:] = self._list_lens\\n        _fen_tree = self._fen_tree\\n        for i in range(len(_fen_tree)):\\n            if i | i + 1 < len(_fen_tree):\\n                _fen_tree[i | i + 1] += _fen_tree[i]\\n        self._rebuild = False\\n\\n    def _fen_update(self, index, value):\\n        \\\"\\\"\\\"Update `fen_tree[index] += value`.\\\"\\\"\\\"\\n        if not self._rebuild:\\n            _fen_tree = self._fen_tree\\n            while index < len(_fen_tree):\\n                _fen_tree[index] += value\\n                index |= index + 1\\n\\n    def _fen_query(self, end):\\n        \\\"\\\"\\\"Return `sum(_fen_tree[:end])`.\\\"\\\"\\\"\\n        if self._rebuild:\\n            self._fen_build()\\n\\n        _fen_tree = self._fen_tree\\n        x = 0\\n        while end:\\n            x += _fen_tree[end - 1]\\n            end &= end - 1\\n        return x\\n\\n    def _fen_findkth(self, k):\\n        \\\"\\\"\\\"Return a pair of (the largest `idx` such that `sum(_fen_tree[:idx]) <= k`, `k - sum(_fen_tree[:idx])`).\\\"\\\"\\\"\\n        _list_lens = self._list_lens\\n        if k < _list_lens[0]:\\n            return 0, k\\n        if k >= self._len - _list_lens[-1]:\\n            return len(_list_lens) - 1, k + _list_lens[-1] - self._len\\n        if self._rebuild:\\n            self._fen_build()\\n\\n        _fen_tree = self._fen_tree\\n        idx = -1\\n        for d in...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You are given a binary string (i. e. a string consisting of characters 0 and\\/or 1) s of length n. You can perform the following operation with the string s at most once: choose a substring (a contiguous subsequence) of s having exactly k characters 1 in it, and shuffle it (reorder the characters in the substring as you wish).\\n\\nCalculate the number of different strings which can be obtained from s by performing this operation at most once.\\n\\nInput\\n\\nThe first line contains two integers n and k (2 \u2264 n \u2264 5000; 0 \u2264 k \u2264 n).\\n\\nThe second line contains the string s of length n, consisting of characters 0 and\\/or 1.\\n\\nOutput\\n\\nPrint one integer \u2014 the number of different strings which can be obtained from s by performing the described operation at most once. Since the answer can be large, output it modulo 998244353.\\n\\nExamples\\n\\nInput\\n\\n\\n7 2\\n1100110\\n\\n\\nOutput\\n\\n\\n16\\n\\n\\nInput\\n\\n\\n5 0\\n10010\\n\\n\\nOutput\\n\\n\\n1\\n\\n\\nInput\\n\\n\\n8 1\\n10001000\\n\\n\\nOutput\\n\\n\\n10\\n\\n\\nInput\\n\\n\\n10 8\\n0010011000\\n\\n\\nOutput\\n\\n\\n1\\n\\nNote\\n\\nSome strings you can obtain in the first example:\\n\\n  * to obtain 0110110, you can take the substring from the 1-st character to the 4-th character, which is 1100, and reorder its characters to get 0110; \\n  * to obtain 1111000, you can take the substring from the 3-rd character to the 7-th character, which is 00110, and reorder its characters to get 11000; \\n  * to obtain 1100101, you can take the substring from the 5-th character to the 7-th character, which is 110, and reorder its characters to get 101. \\n\\n\\n\\nIn the second example, k = 0 so you can only choose the substrings consisting only of 0 characters. Reordering them doesn't change the string at all, so the only string you can obtain is 10010.\\nimpor\",\"targets\":\"t java.io.BufferedReader;\\nimport java.io.BufferedWriter;\\nimport java.io.IOException;\\nimport java.io.InputStreamReader;\\nimport java.io.OutputStreamWriter;\\nimport java.util.*;\\nimport java.util.stream.Stream;\\n\\npublic class Program {\\n\\n    static BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));\\n    static BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));\\n\\n    public static void main(String[] args) throws NumberFormatException, IOException {\\n\\n\\/\\/        int cases = Integer.parseInt(reader.readLine());\\n        int cases = 1;\\n        int mod = 998244353;\\n\\n        long[] fact = factorial(10000, mod);\\n        long[] invfact = invfactorial(10000, mod, fact);\\n\\n        while(cases-- > 0) {\\n\\n            String[] firstLine = reader.readLine().split(\\\" \\\");\\n\\n            int n = Integer.parseInt(firstLine[0]);\\n            int k = Integer.parseInt(firstLine[1]);\\n\\n            String str = reader.readLine();\\n\\n            int[] arr = new int[n];\\n            int sum = 0;\\n\\n            for(int i=0;i<arr.length;i++) {\\n                arr[i] = str.charAt(i)-'0';\\n                sum += arr[i];\\n            }\\n\\n            if(sum < k || k==0) {\\n                printNumber(1);\\n                continue;\\n            }\\n\\n            long ans = 0;\\n            int count = 0;\\n            int st = 0;\\n            int en = 0;\\n            for(int i=0;i<arr.length;i++) {\\n                if(arr[i] == 1) {\\n                    count++;\\n                }\\n                if(count>k) {\\n                    break;\\n                }\\n                en = i;\\n            }\\n\\n            ans += ncr(en-st+1, k, mod, fact, invfact);\\n\\n            for(int j=en+1;j<arr.length;j++) {\\n\\n                if(arr[j]==0) {\\n                    ans += ncr(j-st, k-1, mod, fact, invfact);\\n                }else {\\n                    while(arr[st] == 0) st++;\\n                    st++;\\n                    ans += ncr(j-st, k, mod, fact, invfact);\\n                }\\n\\n                ans%=mod;\\n\\n            }\\n\\n           ...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"JAVA solution for \\\"You are given an integer n. In 1 move, you can do one of the following actions:\\n\\n  * erase any digit of the number (it's acceptable that the number before the operation has exactly one digit and after the operation, it is \\\"empty\\\"); \\n  * add one digit to the right. \\n\\n\\n\\nThe actions may be performed in any order any number of times.\\n\\nNote that if, after deleting some digit from a number, it will contain leading zeroes, they will not be deleted. E.g. if you delete from the number 301 the digit 3, the result is the number 01 (not 1).\\n\\nYou need to perform the minimum number of actions to make the number any power of 2 (i.e. there's an integer k (k \u2265 0) such that the resulting number is equal to 2^k). The resulting number must not have leading zeroes.\\n\\nE.g. consider n=1052. The answer is equal to 2. First, let's add to the right one digit 4 (the result will be 10524). Then let's erase the digit 5, so the result will be 1024 which is a power of 2.\\n\\nE.g. consider n=8888. The answer is equal to 3. Let's erase any of the digits 8 three times. The result will be 8 which is a power of 2.\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases. Then t test cases follow.\\n\\nEach test case consists of one line containing one integer n (1 \u2264 n \u2264 10^9).\\n\\nOutput\\n\\nFor each test case, output in a separate line one integer m \u2014 the minimum number of moves to transform the number into any power of 2.\\n\\nExample\\n\\nInput\\n\\n\\n12\\n1052\\n8888\\n6\\n75\\n128\\n1\\n301\\n12048\\n1504\\n6656\\n1000000000\\n687194767\\n\\n\\nOutput\\n\\n\\n2\\n3\\n1\\n3\\n0\\n0\\n2\\n1\\n3\\n4\\n9\\n2\\n\\nNote\\n\\nThe answer for the first test case was considered above.\\n\\nThe answer for the second test case was considered above.\\n\\nIn the third test case, it's enough to add to the right the digit 4 \u2014 the number 6 will turn into 64.\\n\\nIn the fourth test case, let's add to the right the digit 8 and then erase 7 and 5 \u2014 the taken number will turn into 8.\\n\\nThe numbers of the fifth and the sixth test cases are already powers of two so there's no need to make any move.\\n\\nIn the seventh test case, you can...\\\":\",\"targets\":\"import java.util.*;\\n\\npublic class D {\\n\\t\\n\\tstatic String[] str;\\n\\tstatic int sz = 0;\\n\\t\\n\\tpublic static void main(String[] args) {\\n\\t\\t\\/\\/ TODO Auto-generated method stub\\n\\t\\t\\n\\t\\tstr = new String[100];\\n\\t\\t\\n\\t\\tlong a = 1;\\n\\t\\tfor(;a <= 1000000000000000000L;sz++,a*=2) {\\n\\t\\t\\tstr[sz] = String.valueOf(a);\\n\\/\\/\\t\\t\\tSystem.out.println(sz+\\\" \\\"+str[sz]);\\n\\t\\t}\\n\\n\\t\\tScanner sc = new Scanner(System.in);\\n\\t\\t\\n\\t\\tint t = sc.nextInt();\\n\\t\\t\\n\\t\\twhile(t-- >0) {\\n\\t\\t\\t\\n\\t\\t\\tint n = sc.nextInt();\\n\\t\\t\\tString s = String.valueOf(n);\\n\\t\\t\\tint ans = s.length()+1; \\n\\t\\t\\tfor(int i=0;i<sz;i++) {\\n\\t\\t\\t\\tans = Math.min(ans,check(i,s));\\n\\t\\t\\t}\\n\\t\\t\\t\\n\\t\\t\\tSystem.out.println(ans);\\n\\t\\t\\t\\n\\t\\t}\\n\\t\\t\\n\\n\\t}\\n\\t\\n\\tprivate static int check(int a, String s) {\\n\\t\\t\\n\\/\\/\\t\\tSystem.out.println(\\\"Check: \\\"+ a+\\\" \\\"+s);\\n\\t\\t\\n\\t\\tint sz = str[a].length();\\n\\t\\tint p1=0,p2=0;\\n\\t\\t\\n\\t\\twhile(true) {\\n\\t\\t\\tif(str[a].charAt(p1) == s.charAt(p2)) {\\n\\t\\t\\t\\tp1++;p2++;\\n\\t\\t\\t}\\n\\t\\t\\telse {\\n\\t\\t\\t\\tp2++;\\n\\t\\t\\t}\\n\\t\\t\\t\\n\\t\\t\\tif(p1==sz || p2==s.length())break;\\n\\t\\t}\\n\\t\\t\\n\\t\\t\\n\\t\\treturn (sz-p1)+(s.length()-p1);\\n\\t}\\n\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in CPP?\\nA teacher decides to give toffees to his students. He asks n students to stand in a queue. Since the teacher is very partial, he follows the following rule to distribute toffees.\\n\\nHe looks at the first two students and gives more toffees to the student having higher marks than the other one. If they have the same marks they get the same number of toffees. The same procedure is followed for each pair of adjacent students starting from the first one to the last one.\\n\\nIt is given that each student receives at least one toffee. You have to find the number of toffees given to each student by the teacher such that the total number of toffees is minimum.\\n\\nInput\\n\\nThe first line of input contains the number of students n (2 \u2264 n \u2264 1000). The second line gives (n - 1) characters consisting of \\\"L\\\", \\\"R\\\" and \\\"=\\\". For each pair of adjacent students \\\"L\\\" means that the left student has higher marks, \\\"R\\\" means that the right student has higher marks and \\\"=\\\" means that both have equal marks. \\n\\nOutput\\n\\nOutput consists of n integers separated by a space representing the number of toffees each student receives in the queue starting from the first one to the last one.\\n\\nExamples\\n\\nInput\\n\\n5\\nLRLR\\n\\n\\nOutput\\n\\n2 1 2 1 2\\n\\n\\nInput\\n\\n5\\n=RRR\\n\\n\\nOutput\\n\\n1 1 2 3 4\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nlong long n, i, a[1010], m, j;\\nstring s;\\nlong long min(long long a, long long b) {\\n  if (a > b)\\n    return b;\\n  else\\n    return a;\\n}\\nlong long max(long long a, long long b) {\\n  if (a > b)\\n    return a;\\n  else\\n    return b;\\n}\\nlong long fabs(long long a) {\\n  if (a >= 0)\\n    return a;\\n  else\\n    return -a;\\n}\\nint main() {\\n  cin >> n;\\n  cin >> s;\\n  m = n - 1;\\n  a[1] = 1;\\n  for (i = 1; i <= m; i++) {\\n    if (s[i - 1] == '=') a[i + 1] = a[i];\\n    if (s[i - 1] == 'R') a[i + 1] = a[i] + 1;\\n    if (s[i - 1] == 'L') {\\n      if (a[i] != 1)\\n        a[i + 1] = 1;\\n      else {\\n        a[i + 1] = 1;\\n        j = i;\\n        while (j > 0) {\\n          if ((s[j - 1] == 'L') && (a[j + 1] >= a[j]))\\n            a[j] = a[j + 1] + 1;\\n          else if ((s[j - 1] == '=') && (a[j] != a[j + 1]))\\n            a[j] = a[j + 1];\\n          else\\n            j = -1;\\n          j--;\\n        }\\n      }\\n    }\\n  }\\n  for (i = 1; i <= n; i++) cout << a[i] << \\\" \\\";\\n  cout << endl;\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"It is a complicated version of problem F1. The difference between them is the constraints (F1: k \u2264 2, F2: k \u2264 10).\\n\\nYou are given an integer n. Find the minimum integer x such that x \u2265 n and the number x is k-beautiful.\\n\\nA number is called k-beautiful if its decimal representation having no leading zeroes contains no more than k different digits. E.g. if k = 2, the numbers 3434443, 55550, 777 and 21 are k-beautiful whereas the numbers 120, 445435 and 998244353 are not.\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases. Then t test cases follow.\\n\\nEach test case consists of one line containing two integers n and k (1 \u2264 n \u2264 10^9, 1 \u2264 k \u2264 10).\\n\\nOutput\\n\\nFor each test case output on a separate line x \u2014 the minimum k-beautiful integer such that x \u2265 n.\\n\\nExample\\n\\nInput\\n\\n\\n6\\n2021 3\\n177890 2\\n34512 3\\n724533 4\\n998244353 1\\n12345678 10\\n\\n\\nOutput\\n\\n\\n2021\\n181111\\n34533\\n724542\\n999999999\\n12345678\\nSolve the task in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nstring solve() {\\n  string n;\\n  int k;\\n  cin >> n >> k;\\n  while (1) {\\n    set<char> s;\\n    for (auto c : n) s.insert(c);\\n    if (s.size() <= k) return n;\\n    s.clear();\\n    for (int ptr = 0;; ptr++) {\\n      s.insert(n[ptr]);\\n      if (s.size() > k) {\\n        while (n[ptr] == '9') {\\n          ptr--;\\n        }\\n        n[ptr]++;\\n        for (int i = ptr + 1; i < n.size(); i++) {\\n          n[i] = '0';\\n        }\\n        break;\\n      }\\n    }\\n  }\\n}\\nint main() {\\n  int T;\\n  cin >> T;\\n  while (T--) {\\n    cout << solve() << '\\\\n';\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Chef talks a lot on his mobile phone. As a result he exhausts his talk-value (in Rokdas) very quickly. One day at a mobile recharge shop, he noticed that his service provider gives add-on plans which can lower his calling rates (Rokdas\\/minute). One of the plans said \\\"Recharge for 28 Rokdas and enjoy call rates of 0.50 Rokdas\\/min for one month\\\". Chef was very pleased. His normal calling rate is 1 Rokda\\/min. And he talked for 200 minutes in last month, which costed him 200 Rokdas. If he had this plan activated, it would have costed him: 28 + 0.5*200 = 128 Rokdas only! Chef could have saved 72 Rokdas. But if he pays for this add-on and talks for very little in the coming month, he may end up saving nothing or even wasting money. Now, Chef is a simple guy and he doesn't worry much about future. He decides to choose the plan based upon his last month\u2019s usage.\\nThere are numerous plans. Some for 1 month, some for 15 months. Some reduce call rate to 0.75 Rokdas\\/min, some reduce it to 0.60 Rokdas\\/min. And of course each of them differ in their activation costs. Note - If a plan is valid for M months, then we must pay for (re)activation after every M months (once in M months). Naturally, Chef is confused, and you (as always) are given the task to help him choose the best plan.\\n\\nInput\\nFirst line contains T- the number of test cases. In each test case, first line contains D- the default rate (Rokdas\\/minute, real number), U- the number of minutes Chef talked in last month and N- the number of add-on plans available. Then N lines follow, each containing M- the number of months the plan is valid for, R- the calling rate for the plan (Rokdas\\/minute, real number) and C- the cost of the plan.\\n\\nOutput\\nFor each test case, output one integer- the number of the best plan (from 1 to N). Output '0' if no plan is advantageous for Chef. No two plans are equally advantageous.\\n\\nConstraints\\n1 \u2264 T \u2264 1000.5 \u2264 D \u2264 10.0 (exactly 2 digits after the decimal point)1 \u2264 U \u2264 100001 \u2264 N \u2264 1001 \u2264 M \u2264 360.05 \u2264 R < D (exactly 2 digits after the...\\nUsing python can you solve the prior task?\",\"targets\":\"for t in range(int(raw_input())):\\n\\td,u,n = tuple(map(lambda x: float(x),raw_input().split()))\\n\\tp=[]\\n\\tn = int(n)\\n\\tfor i in range(n):\\n\\t\\tp.append(tuple(map(lambda x: float(x),raw_input().split())))\\n\\tplan=0\\n\\tprice=u*d\\n\\t# print\\n\\t# print \\\"price:\\\",price\\n\\t# print \\\"p:\\\",p\\n\\tfor j,i in enumerate(p):\\n\\t\\ttemp = i[1]*u + i[2]\\/i[0]\\n\\t\\t# print \\\"temp_price:\\\",temp\\n\\t\\tif temp < price:\\n\\t\\t\\tplan = j+1\\n\\t\\t\\tprice = temp\\n\\tprint plan\",\"language\":\"python\",\"split\":\"train\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"...Mike the TV greets you again!\\n\\nTired of the monotonous furniture? Sick of gray routine? Dreaming about dizzying changes in your humble abode? We have something to offer you!\\n\\nThis domino carpet for only $99.99 will change your life! You can lay it on the floor, hang it on the wall or even on the ceiling! Among other things ...\\n\\nHaving watched the commercial, virus Hexadecimal also wanted to get a Domino Carpet and wanted badly to be photographed in front of it. But of course, a virus will never consent to buying a licensed Carpet! So she ordered a truck of dominoes and decided to make such a Carpet herself. \\n\\nThe original Domino Carpet is a field of squares n \u00d7 m in size. Each square is half of a domino, and can be rotated either vertically or horizontally, independently from its neighbors. Vertically rotated domino halves look like this: \\n\\n<image>\\n\\nAnd horizontally rotated halves look like this: \\n\\n<image>\\n\\nNotice, that some halves looks the same in both rotations, but other halves differ.\\n\\nDominoes bought by Hexadecimal are represented by uncuttable chips 1 \u00d7 2 in size, which can be laid either vertically or horizontally. If the chip is laid vertically, then both of it's halves should be laid vertically orientated; if the chip is laid horizontally, then both of it's halves should be laid horizontally.\\n\\nThe samples of valid and invalid dominoes laid vertically and horizontally are: \\n\\n<image>\\n\\nVirus Hexadecimal assembles her own Domino Carpet so that the following conditions are satisfied:\\n\\n  * each carpet square is covered by a domino chip, i.e. there are no empty squares; \\n  * all domino chips lie entirely within the carpet and don't overlap with each other; \\n  * if there is a horizontal domino chip with its left half in column j then there are no horizontal domino chips with their left halves in columns j - 1 or j + 1. \\n\\n\\n\\nBefore starting to assemble her own Domino Carpet, the virus wants to know the number of ways to achieve the intended purpose modulo 109 + 7.\\n\\nYou can assume that the virus has an...\\n#incl\",\"targets\":\"ude <bits\\/stdc++.h>\\n#pragma comment(linker, \\\"\\/STACK:268435456\\\")\\nusing namespace std;\\ntemplate <typename T>\\ninline T abs(T a) {\\n  return ((a < 0) ? -a : a);\\n}\\ntemplate <typename T>\\ninline T sqr(T a) {\\n  return a * a;\\n}\\ntemplate <class T>\\nT gcd(T a, T b) {\\n  return a ? gcd(b % a, a) : b;\\n}\\ntemplate <class T>\\nT lcm(T a, T b) {\\n  return a \\/ gcd(a, b) * b;\\n}\\ntemplate <class T>\\nT sign(T a) {\\n  return a > 0 ? 1 : (a < 0 ? -1 : 0);\\n}\\nconst int dx[] = {-1, 0, 1, 0};\\nconst int dy[] = {0, 1, 0, -1};\\nconst int dxK[] = {-1, -1, 0, 1, 1, 1, 0, -1};\\nconst int dyK[] = {0, 1, 1, 1, 0, -1, -1, -1};\\nconst int dxKn[] = {-2, -1, 1, 2, 2, 1, -1, -2};\\nconst int dyKn[] = {1, 2, 2, 1, -1, -2, -2, -1};\\nconst int N = int(3e2) + 5;\\nconst int M = int(3e2) + 9;\\nconst int LOGN = 21;\\nconst int SQN = 350;\\nconst int MOD = int(1e9) + 7;\\nconst int INF = int(1e9) + 100;\\nconst long long INF64 = 2e18;\\nconst double PI = double(3.1415926535897932384626433832795);\\nconst double e = double(2.7182818284590452353602874713527);\\nconst double EPS = 1e-9;\\nint n, m;\\nstring s[N * 4];\\nint a[N][N];\\nint dp[N][N][2][2];\\nint DP[N];\\nint f(string cur, int cnt) {\\n  string s3 = \\\"O...O...O\\\";\\n  string s2 = \\\"O.......O\\\";\\n  string s6 = \\\"OOO...OOO\\\";\\n  if (cnt == 2) return (cur == s2 ? 1 : 2);\\n  if (cnt == 3) return (cur == s3 ? 1 : 2);\\n  if (cnt == 6) return (cur == s6 ? 1 : 2);\\n}\\nint calc(int i);\\nint calc(int i, int j, bool needH, bool uH) {\\n  int &res = dp[i][j][needH][uH];\\n  if (res != -1) return res;\\n  if (i == n) {\\n    int res = 1;\\n    if (needH && !uH) res = 0;\\n    res *= calc(j + 1 + needH);\\n    res %= MOD;\\n    return res;\\n  }\\n  res = 0;\\n  if (needH) {\\n    if (a[i][j] != 2 && a[i][j + 1] != 2) {\\n      res += calc(i + 1, j, needH, true);\\n      res %= MOD;\\n    }\\n    if (i + 1 < n && a[i][j] != 1 && a[i + 1][j] != 1 && a[i][j + 1] != 1 &&\\n        a[i + 1][j + 1] != 1) {\\n      res += calc(i + 2, j, needH, uH);\\n      res %= MOD;\\n    }\\n    return res;\\n  } else {\\n    if (i == n - 1) return res = 0;\\n    if (a[i][j] == 1 || a[i + 1][j] == 1) return res = 0;\\n    return calc(i +...\",\"language\":\"python\",\"split\":\"train\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Monocarp wrote down two numbers on a whiteboard. Both numbers follow a specific format: a positive integer x with p zeros appended to its end.\\n\\nNow Monocarp asks you to compare these two numbers. Can you help him?\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 10^4) \u2014 the number of testcases.\\n\\nThe first line of each testcase contains two integers x_1 and p_1 (1 \u2264 x_1 \u2264 10^6; 0 \u2264 p_1 \u2264 10^6) \u2014 the description of the first number.\\n\\nThe second line of each testcase contains two integers x_2 and p_2 (1 \u2264 x_2 \u2264 10^6; 0 \u2264 p_2 \u2264 10^6) \u2014 the description of the second number.\\n\\nOutput\\n\\nFor each testcase print the result of the comparison of the given two numbers. If the first number is smaller than the second one, print '<'. If the first number is greater than the second one, print '>'. If they are equal, print '='.\\n\\nExample\\n\\nInput\\n\\n\\n5\\n2 1\\n19 0\\n10 2\\n100 1\\n1999 0\\n2 3\\n1 0\\n1 0\\n99 0\\n1 2\\n\\n\\nOutput\\n\\n\\n&gt;\\n=\\n&lt;\\n=\\n&lt;\\n\\nNote\\n\\nThe comparisons in the example are: 20 > 19, 1000 = 1000, 1999 < 2000, 1 = 1, 99 < 100.\\n#incl\",\"targets\":\"ude <bits\\/stdc++.h>\\nusing namespace std;\\nconst int maxn = 1e6 + 5;\\nconst int mod = 998244353;\\nconst int INF = 0x3f3f3f3f;\\nconst long long llINF = 0x3f3f3f3f3f3f3f3f;\\nlong long make_compiler_happy() { return INF ^ 3 ^ maxn ^ mod ^ llINF; }\\nlong long fpow(long long a, long long b) {\\n  long long res = 1;\\n  a %= mod;\\n  assert(b >= 0);\\n  for (; b; b >>= 1) {\\n    if (b & 1) res = res * a % mod;\\n    a = a * a % mod;\\n  }\\n  return res;\\n}\\nlong long inv(long long x) { return fpow(x, mod - 2); }\\nmt19937 gen(chrono::high_resolution_clock::now().time_since_epoch().count());\\nvoid solve() {\\n  string s[2];\\n  int p[2];\\n  for (int i = 0; i < (2); i++) cin >> s[i] >> p[i];\\n  if (((int)s[0].size()) + p[0] < ((int)s[1].size()) + p[1]) {\\n    cout << \\\"<\\\\n\\\";\\n  } else if (((int)s[0].size()) + p[0] > ((int)s[1].size()) + p[1]) {\\n    cout << \\\">\\\\n\\\";\\n  } else {\\n    while (((int)s[0].size()) < ((int)s[1].size())) {\\n      p[0]--;\\n      s[0] += '0';\\n    }\\n    while (((int)s[1].size()) < ((int)s[0].size())) {\\n      p[1]--;\\n      s[1] += '0';\\n    }\\n    if (s[0] < s[1]) {\\n      cout << \\\"<\\\\n\\\";\\n    } else if (s[0] > s[1]) {\\n      cout << \\\">\\\\n\\\";\\n    } else {\\n      cout << \\\"=\\\\n\\\";\\n    }\\n  }\\n}\\nint main() {\\n  ios::sync_with_stdio(0), cin.tie(0);\\n  int T;\\n  cin >> T;\\n  for (int kase = (1); kase <= (T); kase++) {\\n    solve();\\n  }\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"The Olympic Games have just started and Federico is eager to watch the marathon race.\\n\\nThere will be n athletes, numbered from 1 to n, competing in the marathon, and all of them have taken part in 5 important marathons, numbered from 1 to 5, in the past. For each 1\u2264 i\u2264 n and 1\u2264 j\u2264 5, Federico remembers that athlete i ranked r_{i,j}-th in marathon j (e.g., r_{2,4}=3 means that athlete 2 was third in marathon 4).\\n\\nFederico considers athlete x superior to athlete y if athlete x ranked better than athlete y in at least 3 past marathons, i.e., r_{x,j}<r_{y,j} for at least 3 distinct values of j.\\n\\nFederico believes that an athlete is likely to get the gold medal at the Olympics if he is superior to all other athletes.\\n\\nFind any athlete who is likely to get the gold medal (that is, an athlete who is superior to all other athletes), or determine that there is no such athlete.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 1000) \u2014 the number of test cases. Then t test cases follow.\\n\\nThe first line of each test case contains a single integer n (1\u2264 n\u2264 50 000) \u2014 the number of athletes.\\n\\nThen n lines follow, each describing the ranking positions of one athlete.\\n\\nThe i-th of these lines contains the 5 integers r_{i,1},\\\\,r_{i,2},\\\\,r_{i,3},\\\\,r_{i,4},  r_{i,5} (1\u2264 r_{i,j}\u2264 50 000) \u2014 the ranking positions of athlete i in the past 5 marathons. It is guaranteed that, in each of the 5 past marathons, the n athletes have distinct ranking positions, i.e., for each 1\u2264 j\u2264 5, the n values r_{1,j},  r_{2, j},  ...,  r_{n, j} are distinct.\\n\\nIt is guaranteed that the sum of n over all test cases does not exceed 50 000.\\n\\nOutput\\n\\nFor each test case, print a single integer \u2014 the number of an athlete who is likely to get the gold medal (that is, an athlete who is superior to all other athletes). If there are no such athletes, print -1. If there is more than such one athlete, print any of them.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n1\\n50000 1 50000 50000 50000\\n3\\n10 10 20 30 30\\n20 20 30 10 10\\n30 30 10 20 20\\n3\\n1 1 1 1 1\\n2 2 2 2 2\\n3 3 3 3 3\\n6\\n9 5 3 7...\\nThe above is tricky. Write me a correct solution in JAVA.\",\"targets\":\"import java.util.*;\\npublic class B_Running_for_Gold{\\n    public static void main(String[] args){\\n        Scanner sc=new Scanner(System.in);\\n       int max=0;\\n        int t=sc.nextInt();\\n        for(int p=0;p<t;p++){\\n            max=0;\\n            int n=sc.nextInt();\\n            int[][] standing=new int[n][5];\\n            for(int i=0;i<n;i++){\\n                for(int j=0;j<5;j++){\\n                    standing[i][j]=sc.nextInt();\\n                }\\n            }\\n            if(n==1){\\n                max=0;\\n            }else{\\n                for(int i=1;i<n;i++){\\n                    int nums=0;\\n                    for(int j=0;j<5;j++){\\n                        if(standing[i][j]<standing[max][j])nums++;\\n                    }\\n                    if(nums>=3){\\n                        max=i;\\n                    }\\n                }\\n                for(int i=0;i<n;i++){\\n                    int nums=0;\\n                    if(i!=max){\\n                        for(int j=0;j<5;j++){\\n                            if(standing[i][j]<standing[max][j])nums++;\\n                        }\\n                    }\\n                    if(nums>=3){\\n                        max=-1;\\n                        break;\\n                    }\\n                }\\n            }\\n            if(max==-1)System.out.println(-1);\\n            else System.out.println(max+1);\\n        }\\n\\n    }\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"JAVA solution for \\\"<image>\\n\\nWilliam has an array of n integers a_1, a_2, ..., a_n. In one move he can swap two neighboring items. Two items a_i and a_j are considered neighboring if the condition |i - j| = 1 is satisfied.\\n\\nWilliam wants you to calculate the minimal number of swaps he would need to perform to make it so that the array does not contain two neighboring items with the same parity.\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 10^4). Description of the test cases follows.\\n\\nThe first line of each test case contains an integer n (1 \u2264 n \u2264 10^5) which is the total number of items in William's array.\\n\\nThe second line contains n integers a_1, a_2, ..., a_n (1 \u2264 a_i \u2264 10^9) which are William's array.\\n\\nIt is guaranteed that the sum of n over all test cases does not exceed 10^5.\\n\\nOutput\\n\\nFor each test case output the minimal number of operations needed or -1 if it is impossible to get the array to a state when no neighboring numbers have the same parity.\\n\\nExample\\n\\nInput\\n\\n\\n5\\n3\\n6 6 1\\n1\\n9\\n6\\n1 1 1 2 2 2\\n2\\n8 6\\n6\\n6 2 3 4 5 1\\n\\n\\nOutput\\n\\n\\n1\\n0\\n3\\n-1\\n2\\n\\nNote\\n\\nIn the first test case the following sequence of operations would satisfy the requirements: \\n\\n  1. swap(2, 3). Array after performing the operation: [6, 1, 6] \\n\\n\\n\\nIn the second test case the array initially does not contain two neighboring items of the same parity.\\n\\nIn the third test case the following sequence of operations would satisfy the requirements: \\n\\n  1. swap(3, 4). Array after performing the operation: [1, 1, 2, 1, 2, 2] \\n  2. swap(2, 3). Array after performing the operation: [1, 2, 1, 1, 2, 2] \\n  3. swap(4, 5). Array after performing the operation: [1, 2, 1, 2, 1, 2] \\n\\n\\n\\nIn the fourth test case it is impossible to satisfy the requirements.\\n\\nIn the fifth test case the following sequence of operations would satisfy the requirements: \\n\\n  1. swap(2, 3). Array after performing the operation: [6, 3, 2, 4, 5, 1] \\n  2. swap(4, 5). Array after performing the operation: [6, 3, 2, 5, 4, 1] \\\":\",\"targets\":\"import java.io.*;\\nimport java.util.*;\\n\\npublic class MainClass {\\n    public static void main(String[] args) {\\n        Reader in = new Reader(System.in);\\n        StringBuilder stringBuilder = new StringBuilder();\\n        int t = in.nextInt();\\n        while (t-- > 0) {\\n            int n = in.nextInt();\\n            long[] a = new long[n];\\n            for (int i = 0; i < n; i++) {\\n                a[i] = in.nextLong();\\n            }\\n            TreeSet<Integer> even = new TreeSet<>();\\n            TreeSet<Integer> odd = new TreeSet<>();\\n            for (int i = 0; i < n; i++) {\\n                if (i % 2 == a[i] % 2) {\\n                    if (i % 2 == 0)\\n                        even.add(i);\\n                    else\\n                        odd.add(i);\\n                }\\n            }\\n            int min = Integer.MAX_VALUE;\\n            if (even.size() == odd.size()) {\\n                int ans = 0;\\n                for (int x : even) {\\n                    int first = odd.first();\\n                    odd.remove(first);\\n                    ans += Math.abs(x - first);\\n                }\\n                min = Math.min(min, ans);\\n            }\\n            even.clear();\\n            odd.clear();\\n            for (int i = 0; i < n; i++) {\\n                if (i % 2 != a[i] % 2) {\\n                    if (i % 2 == 0)\\n                        even.add(i);\\n                    else\\n                        odd.add(i);\\n                }\\n            }\\n            if (even.size() == odd.size()) {\\n                int ans = 0;\\n                for (int x : even) {\\n                    int first = odd.first();\\n                    odd.remove(first);\\n                    ans += Math.abs(x - first);\\n                }\\n                min = Math.min(min, ans);\\n            }\\n            if (min == Integer.MAX_VALUE) {\\n                stringBuilder.append(-1);\\n            } else {\\n                stringBuilder.append(min);\\n            }\\n            stringBuilder.append(\\\"\\\\n\\\");\\n        }\\n        System.out.println(stringBuilder);\\n    }\\n}\\nclass Reader {\\n   ...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Given n, find any array a_1, a_2, \u2026, a_n of integers such that all of the following conditions hold: \\n\\n  * 1 \u2264 a_i \u2264 10^9 for every i from 1 to n.\\n\\n  * a_1 < a_2 < \u2026 <a_n\\n\\n  * For every i from 2 to n, a_i isn't divisible by a_{i-1}\\n\\n\\n\\n\\nIt can be shown that such an array always exists under the constraints of the problem.\\n\\nInput\\n\\nThe first line contains the number of test cases t (1 \u2264 t \u2264 100). Description of the test cases follows.\\n\\nThe only line of each test case contains a single integer n (1 \u2264 n \u2264 1000).\\n\\nIt is guaranteed that the sum of n over all test cases does not exceed 10^4.\\n\\nOutput\\n\\nFor each test case print n integers a_1, a_2, \u2026, a_n \u2014 the array you found. If there are multiple arrays satisfying all the conditions, print any of them.\\n\\nExample\\n\\nInput\\n\\n\\n3\\n1\\n2\\n7\\n\\n\\nOutput\\n\\n\\n1\\n2 3\\n111 1111 11111 111111 1111111 11111111 111111111\\n\\nNote\\n\\nIn the first test case, array [1] satisfies all the conditions.\\n\\nIn the second test case, array [2, 3] satisfies all the conditions, as 2<3 and 3 is not divisible by 2.\\n\\nIn the third test case, array [111, 1111, 11111, 111111, 1111111, 11111111, 111111111] satisfies all the conditions, as it's increasing and a_i isn't divisible by a_{i-1} for any i from 2 to 7.\",\"targets\":\"#include <bits\\/stdc++.h>\\n#pragma GCC optimize(\\\"Ofast\\\")\\nusing namespace std;\\nvoid solve() {\\n  long long n;\\n  cin >> n;\\n  long long j = 2;\\n  for (long long i = 2; i <= n + 1; i++) {\\n    cout << i << \\\" \\\";\\n  }\\n  cout << \\\"\\\\n\\\";\\n}\\nint32_t main() {\\n  ios_base::sync_with_stdio(false), cin.tie(NULL);\\n  cout << fixed << setprecision(20);\\n  long long t = 1;\\n  cin >> t;\\n  for (long long tt = 1; tt <= t; tt++) {\\n    solve();\\n  }\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Consider a tunnel on a one-way road. During a particular day, n cars numbered from 1 to n entered and exited the tunnel exactly once. All the cars passed through the tunnel at constant speeds.\\n\\nA traffic enforcement camera is mounted at the tunnel entrance. Another traffic enforcement camera is mounted at the tunnel exit. Perfectly balanced.\\n\\nThanks to the cameras, the order in which the cars entered and exited the tunnel is known. No two cars entered or exited at the same time.\\n\\nTraffic regulations prohibit overtaking inside the tunnel. If car i overtakes any other car j inside the tunnel, car i must be fined. However, each car can be fined at most once.\\n\\nFormally, let's say that car i definitely overtook car j if car i entered the tunnel later than car j and exited the tunnel earlier than car j. Then, car i must be fined if and only if it definitely overtook at least one other car.\\n\\nFind the number of cars that must be fined. \\n\\nInput\\n\\nThe first line contains a single integer n (2 \u2264 n \u2264 10^5), denoting the number of cars.\\n\\nThe second line contains n integers a_1, a_2, \u2026, a_n (1 \u2264 a_i \u2264 n), denoting the ids of cars in order of entering the tunnel. All a_i are pairwise distinct.\\n\\nThe third line contains n integers b_1, b_2, \u2026, b_n (1 \u2264 b_i \u2264 n), denoting the ids of cars in order of exiting the tunnel. All b_i are pairwise distinct.\\n\\nOutput\\n\\nOutput the number of cars to be fined.\\n\\nExamples\\n\\nInput\\n\\n\\n5\\n3 5 2 1 4\\n4 3 2 5 1\\n\\n\\nOutput\\n\\n\\n2\\n\\n\\nInput\\n\\n\\n7\\n5 2 3 6 7 1 4\\n2 3 6 7 1 4 5\\n\\n\\nOutput\\n\\n\\n6\\n\\n\\nInput\\n\\n\\n2\\n1 2\\n1 2\\n\\n\\nOutput\\n\\n\\n0\\n\\nNote\\n\\nThe first example is depicted below:\\n\\n<image>\\n\\nCar 2 definitely overtook car 5, while car 4 definitely overtook cars 1, 2, 3 and 5. Cars 2 and 4 must be fined.\\n\\nIn the second example car 5 was definitely overtaken by all other cars.\\n\\nIn the third example no car must be fined.\\nimpor\",\"targets\":\"t java.io.OutputStream;\\nimport java.io.IOException;\\nimport java.io.InputStream;\\nimport java.io.PrintWriter;\\nimport java.util.Scanner;\\n\\n\\/**\\n * Built using CHelper plug-in\\n * Actual solution is at the top\\n *\\/\\npublic class Main {\\n    public static void main(String[] args) {\\n        InputStream inputStream = System.in;\\n        OutputStream outputStream = System.out;\\n        Scanner in = new Scanner(inputStream);\\n        PrintWriter out = new PrintWriter(outputStream);\\n        BSbalansirovanniiTonnel solver = new BSbalansirovanniiTonnel();\\n        solver.solve(1, in, out);\\n        out.close();\\n    }\\n\\n    static class BSbalansirovanniiTonnel {\\n        public void solve(int testNumber, Scanner in, PrintWriter out) {\\n            int n = in.nextInt();\\n            int[] a = new int[n];\\n            int[] a1 = new int[n];\\n            for (int i = 0; i < n; i++) {\\n                a[i] = in.nextInt() - 1;\\n                a1[a[i]] = i;\\n            }\\n\\n            int[] b = new int[n];\\n            for (int i = 0; i < n; i++) {\\n                int x = in.nextInt() - 1;\\n                b[i] = a1[x];\\n            }\\n\\n            int[] sufmin = new int[n];\\n            sufmin[n - 1] = b[n - 1];\\n            int ans = 0;\\n            for (int i = n - 2; i >= 0; i--) {\\n                sufmin[i] = Math.min(sufmin[i + 1], b[i]);\\n                if (sufmin[i] != b[i]) {\\n                    ans++;\\n                }\\n            }\\n\\n            out.println(ans);\\n        }\\n\\n    }\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You are given an array of n positive integers a_1, a_2, \u2026, a_n. Your task is to calculate the number of arrays of n positive integers b_1, b_2, \u2026, b_n such that: \\n\\n  * 1 \u2264 b_i \u2264 a_i for every i (1 \u2264 i \u2264 n), and \\n  * b_i \u2260 b_{i+1} for every i (1 \u2264 i \u2264 n - 1). \\n\\n\\n\\nThe number of such arrays can be very large, so print it modulo 998 244 353.\\n\\nInput\\n\\nThe first line contains a single integer n (1 \u2264 n \u2264 2 \u22c5 10^5) \u2014 the length of the array a.\\n\\nThe second line contains n integers a_1, a_2, \u2026, a_n (1 \u2264 a_i \u2264 10^9).\\n\\nOutput\\n\\nPrint the answer modulo 998 244 353 in a single line.\\n\\nExamples\\n\\nInput\\n\\n\\n3\\n2 2 2\\n\\n\\nOutput\\n\\n\\n2\\n\\nInput\\n\\n\\n2\\n2 3\\n\\n\\nOutput\\n\\n\\n4\\n\\nInput\\n\\n\\n3\\n1 1 1\\n\\n\\nOutput\\n\\n\\n0\\n\\nNote\\n\\nIn the first test case possible arrays are [1, 2, 1] and [2, 1, 2].\\n\\nIn the second test case possible arrays are [1, 2], [1, 3], [2, 1] and [2, 3].\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst int p = 998244353;\\nlong long powmod(long long a, long long b) {\\n  b %= p - 1;\\n  long long r = 1;\\n  while (b) {\\n    if (b & 1) r = r * a % p;\\n    a = a * a % p;\\n    b >>= 1;\\n  }\\n  return r;\\n}\\nlong long C(long long n, long long m) {\\n  if (n < m) return m;\\n  static vector<int> fac({1});\\n  for (int i = fac.size(); i < n + 1; i++)\\n    fac.push_back(1ll * i * fac.back() % p);\\n  return fac[n] * powmod(m, p - 2) % p * powmod(n - m, p - 2) % p;\\n}\\nint main() {\\n  int n;\\n  cin >> n;\\n  vector<long long> f(n + 1, 0), sf(n + 1, 0);\\n  auto sum = [&sf](const int &l, const int &r) {\\n    if (!l) return sf[r];\\n    return (sf[r] + p - sf[l - 1]) % p;\\n  };\\n  sf[0] = 1;\\n  auto add = [](long long &a, long long b) { a = (a + b) % p; };\\n  stack<array<int, 2> > st;\\n  st.push({0, 0});\\n  for (int i = 1; i <= n; i++) {\\n    int x;\\n    cin >> x;\\n    while (!st.empty() && st.top()[0] > x) st.pop();\\n    int fa = st.top()[1];\\n    st.push({x, i});\\n    f[i] = (1ll * x * (i - 1 & 1 ? p - 1 : 1) % p * sum(fa, i - 1) % p +\\n            (i - fa & 1 ? p - 1ll : 1ll) * f[fa] % p) %\\n           p;\\n    sf[i] = (sf[i - 1] + (i & 1 ? p - 1ll : 1ll) * f[i]) % p;\\n  }\\n  cout << f[n] << endl;\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CQXYM is counting permutations length of 2n.\\n\\nA permutation is an array consisting of n distinct integers from 1 to n in arbitrary order. For example, [2,3,1,5,4] is a permutation, but [1,2,2] is not a permutation (2 appears twice in the array) and [1,3,4] is also not a permutation (n=3 but there is 4 in the array).\\n\\nA permutation p(length of 2n) will be counted only if the number of i satisfying p_i<p_{i+1} is no less than n. For example:\\n\\n  * Permutation [1, 2, 3, 4] will count, because the number of such i that p_i<p_{i+1} equals 3 (i = 1, i = 2, i = 3).\\n  * Permutation [3, 2, 1, 4] won't count, because the number of such i that p_i<p_{i+1} equals 1 (i = 3). \\n\\n\\n\\nCQXYM wants you to help him to count the number of such permutations modulo 1000000007 (10^9+7).\\n\\nIn addition, [modulo operation](https:\\/\\/en.wikipedia.org\\/wiki\\/Modulo_operation) is to get the remainder. For example:\\n\\n  * 7 mod 3=1, because 7 = 3 \u22c5 2 + 1, \\n  * 15 mod 4=3, because 15 = 4 \u22c5 3 + 3. \\n\\nInput\\n\\nThe input consists of multiple test cases. \\n\\nThe first line contains an integer t (t \u2265 1) \u2014 the number of test cases. The description of the test cases follows.\\n\\nOnly one line of each test case contains an integer n(1 \u2264 n \u2264 10^5).\\n\\nIt is guaranteed that the sum of n over all test cases does not exceed 10^5\\n\\nOutput\\n\\nFor each test case, print the answer in a single line.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n1\\n2\\n9\\n91234\\n\\n\\nOutput\\n\\n\\n1\\n12\\n830455698\\n890287984\\n\\nNote\\n\\nn=1, there is only one permutation that satisfies the condition: [1,2].\\n\\nIn permutation [1,2], p_1<p_2, and there is one i=1 satisfy the condition. Since 1 \u2265 n, this permutation should be counted. In permutation [2,1], p_1>p_2. Because 0<n, this permutation should not be counted.\\n\\nn=2, there are 12 permutations: [1,2,3,4],[1,2,4,3],[1,3,2,4],[1,3,4,2],[1,4,2,3],[2,1,3,4],[2,3,1,4],[2,3,4,1],[2,4,1,3],[3,1,2,4],[3,4,1,2],[4,1,2,3].\\nThe above is tricky. Write me a correct solution in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\ntemplate <typename T>\\ninline void read(T &x) {\\n  x = 0;\\n  char ch = getchar();\\n  bool f = false;\\n  while (!isdigit(ch)) f |= ch == '-', ch = getchar();\\n  while (isdigit(ch)) x = (x << 1) + (x << 3) + (ch ^ 48), ch = getchar();\\n  x = f ? -x : x;\\n  return;\\n}\\ntemplate <typename T>\\ninline void print(T x) {\\n  if (x < 0) putchar('-'), x = -x;\\n  if (x > 9) print(x \\/ 10);\\n  putchar(x % 10 ^ 48);\\n  return;\\n}\\nconst long long MOD = 1e9 + 7, N = 2e5 + 3;\\nlong long T;\\nlong long f[N];\\nsigned main() {\\n  read(T);\\n  while (T--) {\\n    long long n;\\n    read(n);\\n    long long ans = 1;\\n    for (register long long i = 1; i <= (n * 2); ++i) {\\n      if (i == 2) continue;\\n      ans = (ans * i) % MOD;\\n    }\\n    print(ans), putchar('\\\\n');\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"A string S of an odd length is said to be a strong palindrome if and only if all of the following conditions are satisfied:\\n\\n* S is a palindrome.\\n* Let N be the length of S. The string formed by the 1-st through ((N-1)\\/2)-th characters of S is a palindrome.\\n* The string consisting of the (N+3)\\/2-st through N-th characters of S is a palindrome.\\n\\n\\n\\nDetermine whether S is a strong palindrome.\\n\\nConstraints\\n\\n* S consists of lowercase English letters.\\n* The length of S is an odd number between 3 and 99 (inclusive).\\n\\nInput\\n\\nInput is given from Standard Input in the following format:\\n\\n\\nS\\n\\n\\nOutput\\n\\nIf S is a strong palindrome, print `Yes`; otherwise, print `No`.\\n\\nExamples\\n\\nInput\\n\\nakasaka\\n\\n\\nOutput\\n\\nYes\\n\\n\\nInput\\n\\nlevel\\n\\n\\nOutput\\n\\nNo\\n\\n\\nInput\\n\\natcoder\\n\\n\\nOutput\\n\\nNo\\n#incl\",\"targets\":\"ude<bits\\/stdc++.h>\\nusing namespace std;\\n                    \\n                    \\nint main(){\\n    string s, ans;\\n    int n;\\n    cin >> s;\\n    n = s.size();\\n    ans = \\\"Yes\\\";\\n\\n    if(s.substr(0, (n - 1) \\/ 2) != s.substr((n + 3) \\/ 2 - 1, n)){\\n        ans = \\\"No\\\";\\n    }\\n\\n    cout << ans << endl;\\n    \\n    return 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You are given n integers a_1, a_2, \u2026, a_n. Find the maximum value of max(a_l, a_{l + 1}, \u2026, a_r) \u22c5 min(a_l, a_{l + 1}, \u2026, a_r) over all pairs (l, r) of integers for which 1 \u2264 l < r \u2264 n.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 10 000) \u2014 the number of test cases.\\n\\nThe first line of each test case contains a single integer n (2 \u2264 n \u2264 10^5).\\n\\nThe second line of each test case contains n integers a_1, a_2, \u2026, a_n (1 \u2264 a_i \u2264 10^6).\\n\\nIt is guaranteed that the sum of n over all test cases doesn't exceed 3 \u22c5 10^5.\\n\\nOutput\\n\\nFor each test case, print a single integer \u2014 the maximum possible value of the product from the statement.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n3\\n2 4 3\\n4\\n3 2 3 1\\n2\\n69 69\\n6\\n719313 273225 402638 473783 804745 323328\\n\\n\\nOutput\\n\\n\\n12\\n6\\n4761\\n381274500335\\n\\nNote\\n\\nLet f(l, r) = max(a_l, a_{l + 1}, \u2026, a_r) \u22c5 min(a_l, a_{l + 1}, \u2026, a_r).\\n\\nIn the first test case, \\n\\n  * f(1, 2) = max(a_1, a_2) \u22c5 min(a_1, a_2) = max(2, 4) \u22c5 min(2, 4) = 4 \u22c5 2 = 8. \\n  * f(1, 3) = max(a_1, a_2, a_3) \u22c5 min(a_1, a_2, a_3) = max(2, 4, 3) \u22c5 min(2, 4, 3) = 4 \u22c5 2 = 8. \\n  * f(2, 3) = max(a_2, a_3) \u22c5 min(a_2, a_3) = max(4, 3) \u22c5 min(4, 3) = 4 \u22c5 3 = 12. \\n\\n\\n\\nSo the maximum is f(2, 3) = 12.\\n\\nIn the second test case, the maximum is f(1, 2) = f(1, 3) = f(2, 3) = 6.\\nThe above is tricky. Write me a correct solution in JAVA.\",\"targets\":\"import java.io.BufferedReader;\\nimport java.io.IOException;\\nimport java.io.InputStreamReader;\\nimport java.util.StringTokenizer;\\n\\npublic class Main {\\n\\tpublic static int N;\\n\\n\\tpublic static void main(String[] args) throws IOException {\\n\\t\\tBufferedReader br = new BufferedReader(new InputStreamReader(System.in));\\n\\t\\tStringTokenizer st;\\n\\t\\t\\n\\t\\tint T = Integer.parseInt(br.readLine());\\n\\t\\t\\n\\t\\tfor(int testcase = 0; testcase < T; testcase++) {\\n\\t\\t\\tN = Integer.parseInt(br.readLine());\\n\\t\\t\\tst = new StringTokenizer(br.readLine());\\n\\t\\t\\tlong[] arr = new long[N + 2];\\n\\t\\t\\t\\n\\t\\t\\tfor(int i = 1; i <= N; i++) {\\n\\t\\t\\t\\tarr[i] = Long.parseLong(st.nextToken());\\n\\t\\t\\t}\\n\\t\\t\\tarr[N + 1] = arr[N] - 1;\\n\\t\\t\\t\\n\\t\\t\\tSystem.out.println(solve(arr));\\n\\t\\t}\\n\\n\\t}\\n\\t\\n\\tpublic static long solve(long[] arr) {\\n\\t\\tlong max = 0;\\n\\t\\t\\n\\t\\tfor(int i = 1; i <= N; i++) {\\n\\t\\t\\tif(i == 1) {\\n\\t\\t\\t\\tif(arr[i - 1] <= arr[i] && arr[i] >= arr[i + 1]) {\\n\\t\\t\\t\\t\\tmax = Math.max(max, arr[i] * arr[i + 1]);\\n\\t\\t\\t\\t}\\n\\t\\t\\t}\\n\\t\\t\\telse if(i == N) {\\n\\t\\t\\t\\tif(arr[i - 1] <= arr[i] && arr[i] >= arr[i + 1]) {\\n\\t\\t\\t\\t\\tmax = Math.max(max, arr[i - 1] * arr[i]);\\n\\t\\t\\t\\t}\\n\\t\\t\\t}\\n\\t\\t\\telse {\\n\\t\\t\\t\\tif(arr[i - 1] <= arr[i] && arr[i] >= arr[i + 1]) {\\n\\t\\t\\t\\t\\tmax = Math.max(max, arr[i - 1] * arr[i]);\\n\\t\\t\\t\\t\\tmax = Math.max(max, arr[i] * arr[i + 1]);\\n\\t\\t\\t\\t}\\n\\t\\t\\t}\\n\\t\\t}\\n\\t\\t\\n\\t\\treturn max;\\n\\t}\\n\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"The grasshopper is located on the numeric axis at the point with coordinate x_0.\\n\\nHaving nothing else to do he starts jumping between integer points on the axis. Making a jump from a point with coordinate x with a distance d to the left moves the grasshopper to a point with a coordinate x - d, while jumping to the right moves him to a point with a coordinate x + d.\\n\\nThe grasshopper is very fond of positive integers, so for each integer i starting with 1 the following holds: exactly i minutes after the start he makes a jump with a distance of exactly i. So, in the first minutes he jumps by 1, then by 2, and so on.\\n\\nThe direction of a jump is determined as follows: if the point where the grasshopper was before the jump has an even coordinate, the grasshopper jumps to the left, otherwise he jumps to the right.\\n\\nFor example, if after 18 consecutive jumps he arrives at the point with a coordinate 7, he will jump by a distance of 19 to the right, since 7 is an odd number, and will end up at a point 7 + 19 = 26. Since 26 is an even number, the next jump the grasshopper will make to the left by a distance of 20, and it will move him to the point 26 - 20 = 6.\\n\\nFind exactly which point the grasshopper will be at after exactly n jumps.\\n\\nInput\\n\\nThe first line of input contains an integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases.\\n\\nEach of the following t lines contains two integers x_0 (-10^{14} \u2264 x_0 \u2264 10^{14}) and n (0 \u2264 n \u2264 10^{14}) \u2014 the coordinate of the grasshopper's initial position and the number of jumps.\\n\\nOutput\\n\\nPrint exactly t lines. On the i-th line print one integer \u2014 the answer to the i-th test case \u2014 the coordinate of the point the grasshopper will be at after making n jumps from the point x_0.\\n\\nExample\\n\\nInput\\n\\n\\n9\\n0 1\\n0 2\\n10 10\\n10 99\\n177 13\\n10000000000 987654321\\n-433494437 87178291199\\n1 0\\n-1 1\\n\\n\\nOutput\\n\\n\\n-1\\n1\\n11\\n110\\n190\\n9012345679\\n-87611785637\\n1\\n0\\n\\nNote\\n\\nThe first two test cases in the example correspond to the first two jumps from the point x_0 = 0. \\n\\nSince 0 is an even number, the first jump of length...\\nUsing cpp can you solve the prior task?\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst long long MAX = 1e9;\\nlong long powermod(long long A, long long B) {\\n  long long ret = 1;\\n  A %= MAX;\\n  B %= MAX - 1;\\n  while (B > 0) {\\n    if (B % 2 > 0) ret = ret * A % MAX;\\n    A = A * A % MAX;\\n    B \\/= 2;\\n  }\\n  return ret;\\n}\\nint main() {\\n  ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);\\n  long long t, x0, n;\\n  cin >> t;\\n  while (t--) {\\n    cin >> x0 >> n;\\n    vector<long long> a;\\n    long long ans = x0;\\n    for (long long i = 0; i < 4; i++) {\\n      long long min = i + 1;\\n      if (ans & 1)\\n        ans += min;\\n      else\\n        ans -= min;\\n      a.push_back(ans);\\n    }\\n    long long temp = n % 4;\\n    if (temp == 2 or temp == 0) {\\n      if (temp == 0) temp += 4;\\n      cout << a[temp - 1] << endl;\\n    } else {\\n      if (temp == 1) {\\n        n--;\\n        long long dem = n \\/ 4.0;\\n        if (x0 & 1)\\n          cout << a[temp - 1] + dem * 4 << endl;\\n        else\\n          cout << a[temp - 1] - dem * 4 << endl;\\n      } else {\\n        n--;\\n        long long dem = n \\/ 4.0;\\n        if (x0 & 1)\\n          cout << a[temp - 1] - dem * 4 << endl;\\n        else\\n          cout << a[temp - 1] + dem * 4 << endl;\\n      }\\n    }\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Counting was a difficult task in ancient Rome. The Arabic numerals 0,1,2,3,\u2026, 9 have not yet been disseminated. Instead, the following symbols were used:\\n\\nArabic numerals | Roman numerals | Arabic numerals | Roman numerals | Arabic numerals | Roman numerals\\n--- | --- | --- | --- | --- | ---\\n1 | I | 11 | XI | 30 | XXX | | 2 | II | 12 | XII | 40 | XL | | 3 | III | 13 | XIII | 50 | L | | 4 | IV | 14 | XIV | 60 | LX | | 5 | V | 15 | XV | 70 | LXX | | 6 | VI | 16 | XVI | 80 | LXXX | | 7 | VII | 17 | XVII | 90 | XC | | 8 | VIII | 18 | XVIII | 100 C | | 9 | IX | 19 | XIX | 500 | D | | 10 | X | 20 | XX | 1000 | M |\\n\\n\\nI is 1, V is 5, X is 10, L is 50, C is 100, D is 500, M is 1000, see the table above for other examples. Add when a small number follows a large number, that is, on the right side. When the small number is before the large number, that is, to the left, subtract the small number from the large number. There is only one small number in front of the large number that represents the subtraction per subtraction.\\n\\nCreate a program that converts Roman numerals into Arabic numerals (normal numbers) notation (decimal notation) and outputs them. However, the Roman numerals given only follow the above rules (there are more detailed rules for notation of actual Roman numerals, but they do not need to be considered here. For example, is I a V in actual Roman numerals? From X, X only subtracts from L or C, C only subtracts from D or M, and the same Roman numeral does not add more than 4 (or 5).)\\n\\n\\n\\nInput\\n\\nGiven multiple datasets. Roman numerals (consecutive strings represented by I, V, X, L, C, D, M in half-width uppercase letters) are given to each data set on one line. The length of each Roman numeral string given is 100 or less.\\n\\nThe number of datasets does not exceed 50.\\n\\nOutput\\n\\nOutput Arabic numerals (integers) on one line for each dataset.\\n\\nExample\\n\\nInput\\n\\nIV\\nCCCCLXXXXVIIII\\nCDXCIX\\n\\n\\nOutput\\n\\n4\\n499\\n499\",\"targets\":\"#include <iostream>\\n#include <string>\\nusing namespace std;\\n\\nint main(){\\n  int n,sum,a,b;\\n  string s;\\n  while(cin>>s){\\n    a=s.size();\\n    sum=0;\\n    b=0;\\n    for(int i=a-1;i>=0;i--){\\n      if(s[i]=='I')n=1;\\n      else if(s[i]=='V')n=5;\\n      else if(s[i]=='X')n=10;\\n      else if(s[i]=='L')n=50;\\n      else if(s[i]=='C')n=100;\\n      else if(s[i]=='D')n=500;\\n      else if(s[i]=='M')n=1000;\\n\\n      if(n<b)n*=-1;\\n\\n      sum+=n;\\n\\n      b=n;\\n\\n    }\\n    cout<<sum<<endl;\\n  }\\n  \\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You are given a digital clock with n digits. Each digit shows an integer from 0 to 9, so the whole clock shows an integer from 0 to 10^n-1. The clock will show leading zeroes if the number is smaller than 10^{n-1}.\\n\\nYou want the clock to show 0 with as few operations as possible. In an operation, you can do one of the following: \\n\\n  * decrease the number on the clock by 1, or \\n  * swap two digits (you can choose which digits to swap, and they don't have to be adjacent). \\n\\n\\n\\nYour task is to determine the minimum number of operations needed to make the clock show 0.\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 10^3).\\n\\nThe first line of each test case contains a single integer n (1 \u2264 n \u2264 100) \u2014 number of digits on the clock.\\n\\nThe second line of each test case contains a string of n digits s_1, s_2, \u2026, s_n (0 \u2264 s_1, s_2, \u2026, s_n \u2264 9) \u2014 the number on the clock.\\n\\nNote: If the number is smaller than 10^{n-1} the clock will show leading zeroes.\\n\\nOutput\\n\\nFor each test case, print one integer: the minimum number of operations needed to make the clock show 0.\\n\\nExample\\n\\nInput\\n\\n\\n7\\n3\\n007\\n4\\n1000\\n5\\n00000\\n3\\n103\\n4\\n2020\\n9\\n123456789\\n30\\n001678294039710047203946100020\\n\\n\\nOutput\\n\\n\\n7\\n2\\n0\\n5\\n6\\n53\\n115\\n\\nNote\\n\\nIn the first example, it's optimal to just decrease the number 7 times.\\n\\nIn the second example, we can first swap the first and last position and then decrease the number by 1.\\n\\nIn the third example, the clock already shows 0, so we don't have to perform any operations.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint main(void) {\\n  ios_base::sync_with_stdio(0);\\n  cin.tie(0);\\n  cout.tie(0);\\n  long long n, m = 0, t, z = -1, sum = 0, mx = 0, x;\\n  cin >> t;\\n  while (t--) {\\n    cin >> n;\\n    string s, p;\\n    cin >> s;\\n    x = count(s.begin(), s.end(), '0');\\n    p = s;\\n    sort(p.begin(), p.end());\\n    mx = 0, sum = 0, z = -1;\\n    for (int i = 0; i < n; i++) {\\n      sum += (s[i] - '0');\\n      if (s[i] != '0' && i != n - 1) sum++;\\n    }\\n    cout << sum << endl;\\n  }\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You are given an array a of length n.\\n\\nLet's define the eversion operation. Let x = a_n. Then array a is partitioned into two parts: left and right. The left part contains the elements of a that are not greater than x (\u2264 x). The right part contains the elements of a that are strictly greater than x (> x). The order of elements in each part is kept the same as before the operation, i. e. the partition is stable. Then the array is replaced with the concatenation of the left and the right parts.\\n\\nFor example, if the array a is [2, 4, 1, 5, 3], the eversion goes like this: [2, 4, 1, 5, 3] \u2192 [2, 1, 3], [4, 5] \u2192 [2, 1, 3, 4, 5].\\n\\nWe start with the array a and perform eversions on this array. We can prove that after several eversions the array a stops changing. Output the minimum number k such that the array stops changing after k eversions.\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 100). Description of the test cases follows.\\n\\nThe first line contains a single integer n (1 \u2264 n \u2264 2 \u22c5 10^5).\\n\\nThe second line contains n integers a_1, a_2, ..., a_n (1 \u2264 a_i \u2264 10^9).\\n\\nIt is guaranteed that the sum of n over all test cases does not exceed 2 \u22c5 10^5.\\n\\nOutput\\n\\nFor each test case print a single integer k \u2014 the number of eversions after which the array stops changing.\\n\\nExample\\n\\nInput\\n\\n\\n3\\n5\\n2 4 1 5 3\\n5\\n5 3 2 4 1\\n4\\n1 1 1 1\\n\\n\\nOutput\\n\\n\\n1\\n2\\n0\\n\\nNote\\n\\nConsider the fist example.\\n\\n  * The first eversion: a = [1, 4, 2, 5, 3], x = 3. [2, 4, 1, 5, 3] \u2192 [2, 1, 3], [4, 5] \u2192 [2, 1, 3, 4, 5]. \\n  * The second and following eversions: a = [2, 1, 3, 4, 5], x = 5. [2, 1, 3, 4, 5] \u2192 [2, 1, 3, 4, 5], [] \u2192 [2, 1, 3, 4, 5]. This eversion does not change the array, so the answer is 1. \\n\\n\\n\\nConsider the second example. \\n\\n  * The first eversion: a = [5, 3, 2, 4, 1], x = 1. [5, 3, 2, 4, 1] \u2192 [1], [5, 3, 2, 4] \u2192 [1, 5, 3, 2, 4]. \\n  * The second eversion: a = [1, 5, 3, 2, 4], x = 4. [1, 5, 3, 2, 4] \u2192 [1, 3, 2, 4], [5] \u2192 [1, 3, 2, 4, 5]. \\n  * The third and following eversions: a = [1, 3, 2, 4,...\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint32_t main() {\\n  ios_base::sync_with_stdio(false);\\n  cin.tie(NULL), cout.tie(NULL);\\n  long long int t;\\n  cin >> t;\\n  while (t--) {\\n    long long int n, k = 1, count = 1, p;\\n    cin >> n;\\n    long long int a[n];\\n    map<long long int, long long int> m;\\n    for (long long int i = 0; i < n; i++) {\\n      cin >> a[i];\\n      k = max(k, a[i]);\\n      m[a[i]] = i;\\n    }\\n    sort(a, a + n);\\n    p = m[a[n - 1]];\\n    long long int x = p, ans = n - p - 1;\\n    for (long long int i = n - 2; i >= 0; i--) {\\n      if (m[a[i]] > x) {\\n        ans -= m[a[i]] - x - 1;\\n        x = m[a[i]];\\n      }\\n    }\\n    cout << ans << endl;\\n  }\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"For a permutation p of numbers 1 through n, we define a stair array a as follows: a_i is length of the longest segment of permutation which contains position i and is made of consecutive values in sorted order: [x, x+1, \u2026, y-1, y] or [y, y-1, \u2026, x+1, x] for some x \u2264 y. For example, for permutation p = [4, 1, 2, 3, 7, 6, 5] we have a = [1, 3, 3, 3, 3, 3, 3]. \\n\\nYou are given the stair array a. Your task is to calculate the number of permutations which have stair array equal to a. Since the number can be big, compute it modulo 998 244 353. Note that this number can be equal to zero.\\n\\nInput\\n\\nThe first line of input contains integer n (1 \u2264 n \u2264 10^5) \u2014 the length of a stair array a.\\n\\nThe second line of input contains n integers a_1, a_2, \u2026, a_n (1 \u2264 a_i \u2264 n).\\n\\nOutput\\n\\nPrint the number of permutations which have stair array equal to a. Since the number can be big, compute it modulo 998 244 353.\\n\\nExamples\\n\\nInput\\n\\n\\n6\\n3 3 3 1 1 1\\n\\n\\nOutput\\n\\n\\n6\\n\\n\\nInput\\n\\n\\n7\\n4 4 4 4 3 3 3\\n\\n\\nOutput\\n\\n\\n6\\n\\n\\nInput\\n\\n\\n1\\n1\\n\\n\\nOutput\\n\\n\\n1\\n\\n\\nInput\\n\\n\\n8\\n2 2 2 2 2 2 1 1\\n\\n\\nOutput\\n\\n\\n370\\n\\n\\nInput\\n\\n\\n4\\n3 2 3 1\\n\\n\\nOutput\\n\\n\\n0\\nThe above is tricky. Write me a correct solution in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\ntemplate <const int &MOD>\\nstruct _m_int {\\n  int val;\\n  _m_int(int64_t v = 0) {\\n    if (v < 0) v = v % MOD + MOD;\\n    if (v >= MOD) v %= MOD;\\n    val = int(v);\\n  }\\n  _m_int(uint64_t v) {\\n    if (v >= MOD) v %= MOD;\\n    val = int(v);\\n  }\\n  _m_int(int v) : _m_int(int64_t(v)) {}\\n  _m_int(unsigned v) : _m_int(uint64_t(v)) {}\\n  static int inv_mod(int a, int m = MOD) {\\n    int g = m, r = a, x = 0, y = 1;\\n    while (r != 0) {\\n      int q = g \\/ r;\\n      g %= r;\\n      swap(g, r);\\n      x -= q * y;\\n      swap(x, y);\\n    }\\n    return x < 0 ? x + m : x;\\n  }\\n  explicit operator int() const { return val; }\\n  explicit operator unsigned() const { return val; }\\n  explicit operator int64_t() const { return val; }\\n  explicit operator uint64_t() const { return val; }\\n  explicit operator double() const { return val; }\\n  explicit operator long double() const { return val; }\\n  _m_int &operator+=(const _m_int &other) {\\n    val -= MOD - other.val;\\n    if (val < 0) val += MOD;\\n    return *this;\\n  }\\n  _m_int &operator-=(const _m_int &other) {\\n    val -= other.val;\\n    if (val < 0) val += MOD;\\n    return *this;\\n  }\\n  static unsigned fast_mod(uint64_t x, unsigned m = MOD) {\\n    return unsigned(x % m);\\n    unsigned x_high = unsigned(x >> 32), x_low = unsigned(x);\\n    unsigned quot, rem;\\n    asm(\\\"divl %4\\\\n\\\" : \\\"=a\\\"(quot), \\\"=d\\\"(rem) : \\\"d\\\"(x_high), \\\"a\\\"(x_low), \\\"r\\\"(m));\\n    return rem;\\n  }\\n  _m_int &operator*=(const _m_int &other) {\\n    val = fast_mod(uint64_t(val) * other.val);\\n    return *this;\\n  }\\n  _m_int &operator\\/=(const _m_int &other) { return *this *= other.inv(); }\\n  friend _m_int operator+(const _m_int &a, const _m_int &b) {\\n    return _m_int(a) += b;\\n  }\\n  friend _m_int operator-(const _m_int &a, const _m_int &b) {\\n    return _m_int(a) -= b;\\n  }\\n  friend _m_int operator*(const _m_int &a, const _m_int &b) {\\n    return _m_int(a) *= b;\\n  }\\n  friend _m_int operator\\/(const _m_int &a, const _m_int &b) {\\n    return _m_int(a) \\/= b;\\n  }\\n  _m_int &operator++() {\\n    val = val == MOD - 1 ? 0 : val +...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Mr. Chanek has a new game called Dropping Balls. Initially, Mr. Chanek has a grid a of size n \u00d7 m\\n\\nEach cell (x,y) contains an integer a_{x,y} denoting the direction of how the ball will move.\\n\\n  * a_{x,y}=1 \u2014 the ball will move to the right (the next cell is (x, y + 1)); \\n  * a_{x,y}=2 \u2014 the ball will move to the bottom (the next cell is (x + 1, y)); \\n  * a_{x,y}=3 \u2014 the ball will move to the left (the next cell is (x, y - 1)). \\n\\n\\n\\nEvery time a ball leaves a cell (x,y), the integer a_{x,y} will change to 2. Mr. Chanek will drop k balls sequentially, each starting from the first row, and on the c_1, c_2, ..., c_k-th (1 \u2264 c_i \u2264 m) columns.\\n\\nDetermine in which column each ball will end up in (position of the ball after leaving the grid).\\n\\nInput\\n\\nThe first line contains three integers n, m, and k (1 \u2264 n, m \u2264 1000, 1 \u2264 k \u2264 10^5) \u2014 the size of the grid and the number of balls dropped by Mr. Chanek.\\n\\nThe i-th of the next n lines contains m integers a_{i,1},a_{i,2},\u2026,a_{i,m} (1 \u2264 a_{i,j} \u2264 3). It will satisfy a_{i, 1} \u2260 3 and a_{i, m} \u2260 1.\\n\\nThe next line contains k integers c_1, c_2, \u2026, c_k (1 \u2264 c_i \u2264 m) \u2014 the balls' column positions dropped by Mr. Chanek sequentially.\\n\\nOutput\\n\\nOutput k integers \u2014 the i-th integer denoting the column where the i-th ball will end.\\n\\nExamples\\n\\nInput\\n\\n\\n5 5 3\\n1 2 3 3 3\\n2 2 2 2 2\\n2 2 2 2 2\\n2 2 2 2 2\\n2 2 2 2 2\\n1 2 1\\n\\n\\nOutput\\n\\n\\n2 2 1 \\n\\n\\nInput\\n\\n\\n1 2 2\\n1 3\\n1 2\\n\\n\\nOutput\\n\\n\\n1 2 \\n\\nNote\\n\\nIn the first example, the first ball will drop as follows. Note that the cell (1, 1) will change direction to the bottom direction.\\n\\n<image>\\n\\nThe second and third balls will drop as follows. \\n\\n<image>\\n\\nAll balls will be dropped from the first row and on the c_1, c_2, ..., c_k-th columns respectively. A ball will stop dropping once it leaves the grid.\\nUsing cpp can you solve the prior task?\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint main() {\\n  cin.tie(0)->sync_with_stdio(0);\\n  int n, m, k;\\n  cin >> n >> m >> k;\\n  int array[n][m];\\n  for (int i = 0; i < n; i++) {\\n    for (int j = 0; j < m; j++) {\\n      cin >> array[i][j];\\n    }\\n  }\\n  int pos[k];\\n  for (int i = 0; i < k; i++) cin >> pos[i];\\n  for (int i = 0; i < k; i++) {\\n    pair<int, int> currentpos;\\n    currentpos.first = 0;\\n    currentpos.second = pos[i] - 1;\\n    while (currentpos.first != n) {\\n      int row = currentpos.first;\\n      int column = currentpos.second;\\n      if (array[currentpos.first][currentpos.second] == 1) {\\n        currentpos.second++;\\n      } else if (array[currentpos.first][currentpos.second] == 2) {\\n        currentpos.first++;\\n      } else {\\n        currentpos.second--;\\n      }\\n      array[row][column] = 2;\\n    }\\n    cout << currentpos.second + 1;\\n    cout << \\\" \\\";\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"Appleman has a tree with n vertices. Some of the vertices (at least one) are colored black and other vertices are colored white.\\n\\nConsider a set consisting of k (0 \u2264 k < n) edges of Appleman's tree. If Appleman deletes these edges from the tree, then it will split into (k + 1) parts. Note, that each part will be a tree with colored vertices.\\n\\nNow Appleman wonders, what is the number of sets splitting the tree in such a way that each resulting part will have exactly one black vertex? Find this number modulo 1000000007 (109 + 7).\\n\\nInput\\n\\nThe first line contains an integer n (2 \u2264 n \u2264 105) \u2014 the number of tree vertices. \\n\\nThe second line contains the description of the tree: n - 1 integers p0, p1, ..., pn - 2 (0 \u2264 pi \u2264 i). Where pi means that there is an edge connecting vertex (i + 1) of the tree and vertex pi. Consider tree vertices are numbered from 0 to n - 1.\\n\\nThe third line contains the description of the colors of the vertices: n integers x0, x1, ..., xn - 1 (xi is either 0 or 1). If xi is equal to 1, vertex i is colored black. Otherwise, vertex i is colored white.\\n\\nOutput\\n\\nOutput a single integer \u2014 the number of ways to split the tree modulo 1000000007 (109 + 7).\\n\\nExamples\\n\\nInput\\n\\n3\\n0 0\\n0 1 1\\n\\n\\nOutput\\n\\n2\\n\\n\\nInput\\n\\n6\\n0 1 1 0 4\\n1 1 0 0 1 0\\n\\n\\nOutput\\n\\n1\\n\\n\\nInput\\n\\n10\\n0 1 2 1 4 4 4 0 8\\n0 0 0 1 0 1 1 0 0 1\\n\\n\\nOutput\\n\\n27\\\":\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint N;\\nvector<int> graph[100010];\\nlong long dp0[100010], dp1[100010];\\nint color[100010];\\nint main(void) {\\n  int i, j;\\n  cin >> N;\\n  for ((i) = 0; (i) < (int)(N - 1); (i)++) {\\n    int p;\\n    scanf(\\\"%d\\\", &p);\\n    graph[p].push_back(i + 1);\\n  }\\n  for ((i) = 0; (i) < (int)(N); (i)++) scanf(\\\"%d\\\", &color[i]);\\n  for (i = N - 1; i >= 0; i--) {\\n    long long zero = 0, one = 0;\\n    if (color[i] == 0)\\n      zero++;\\n    else\\n      one++;\\n    for ((j) = 0; (j) < (int)(graph[i].size()); (j)++) {\\n      int v = graph[i][j];\\n      long long zero2 = (zero * dp1[v] + zero * dp0[v]) % 1000000007ll;\\n      long long one2 =\\n          (one * dp1[v] + zero * dp1[v] + one * dp0[v]) % 1000000007ll;\\n      zero = zero2;\\n      one = one2;\\n    }\\n    dp0[i] = zero;\\n    dp1[i] = one;\\n  }\\n  cout << dp1[0] << endl;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Some number of people (this number is even) have stood in a circle. The people stand in the circle evenly. They are numbered clockwise starting from a person with the number 1. Each person is looking through the circle's center at the opposite person.\\n\\n<image> A sample of a circle of 6 persons. The orange arrows indicate who is looking at whom.\\n\\nYou don't know the exact number of people standing in the circle (but this number is even, no doubt). It is known that the person with the number a is looking at the person with the number b (and vice versa, of course). What is the number associated with a person being looked at by the person with the number c? If, for the specified a, b, and c, no such circle exists, output -1.\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases. Then t test cases follow.\\n\\nEach test case consists of one line containing three distinct integers a, b, c (1 \u2264 a,b,c \u2264 10^8).\\n\\nOutput\\n\\nFor each test case output in a separate line a single integer d \u2014 the number of the person being looked at by the person with the number c in a circle such that the person with the number a is looking at the person with the number b. If there are multiple solutions, print any of them. Output -1 if there's no circle meeting the given conditions.\\n\\nExample\\n\\nInput\\n\\n\\n7\\n6 2 4\\n2 3 1\\n2 4 10\\n5 3 4\\n1 3 2\\n2 5 4\\n4 3 2\\n\\n\\nOutput\\n\\n\\n8\\n-1\\n-1\\n-1\\n4\\n1\\n-1\\n\\nNote\\n\\nIn the first test case, there's a desired circle of 8 people. The person with the number 6 will look at the person with the number 2 and the person with the number 8 will look at the person with the number 4.\\n\\nIn the second test case, there's no circle meeting the conditions. If the person with the number 2 is looking at the person with the number 3, the circle consists of 2 people because these persons are neighbors. But, in this case, they must have the numbers 1 and 2, but it doesn't meet the problem's conditions.\\n\\nIn the third test case, the only circle with the persons with the numbers 2 and 4 looking at each other consists of 4...\",\"targets\":\"import sys\\nimport os\\nimport math\\nfrom io import BytesIO, IOBase\\nfrom collections import defaultdict,Counter,deque\\n\\n# input=sys.stdin.readline\\n# def print(x):\\n#     sys.stdout.write(str(x)+\\\"\\\\n\\\")\\n\\nBUFSIZE = 8192\\n\\n\\nclass FastIO(IOBase):\\n\\tnewlines = 0\\n\\n\\tdef __init__(self, file):\\n\\t\\tself._fd = file.fileno()\\n\\t\\tself.buffer = BytesIO()\\n\\t\\tself.writable = \\\"x\\\" in file.mode or \\\"r\\\" not in file.mode\\n\\t\\tself.write = self.buffer.write if self.writable else None\\n\\n\\tdef read(self):\\n\\t\\twhile True:\\n\\t\\t\\tb = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))\\n\\t\\t\\tif not b:\\n\\t\\t\\t\\tbreak\\n\\t\\t\\tptr = self.buffer.tell()\\n\\t\\t\\tself.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)\\n\\t\\tself.newlines = 0\\n\\t\\treturn self.buffer.read()\\n\\n\\tdef readline(self):\\n\\t\\twhile self.newlines == 0:\\n\\t\\t\\tb = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))\\n\\t\\t\\tself.newlines = b.count(b\\\"\\\\n\\\") + (not b)\\n\\t\\t\\tptr = self.buffer.tell()\\n\\t\\t\\tself.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)\\n\\t\\tself.newlines -= 1\\n\\t\\treturn self.buffer.readline()\\n\\n\\tdef flush(self):\\n\\t\\tif self.writable:\\n\\t\\t\\tos.write(self._fd, self.buffer.getvalue())\\n\\t\\t\\tself.buffer.truncate(0), self.buffer.seek(0)\\n\\n\\nclass IOWrapper(IOBase):\\n\\tdef __init__(self, file):\\n\\t\\tself.buffer = FastIO(file)\\n\\t\\tself.flush = self.buffer.flush\\n\\t\\tself.writable = self.buffer.writable\\n\\t\\tself.write = lambda s: self.buffer.write(s.encode(\\\"ascii\\\"))\\n\\t\\tself.read = lambda: self.buffer.read().decode(\\\"ascii\\\")\\n\\t\\tself.readline = lambda: self.buffer.readline().decode(\\\"ascii\\\")\\n\\n\\nsys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)\\ninput = lambda: sys.stdin.readline().rstrip(\\\"\\\\r\\\\n\\\")\\n\\n# sys.stdout=open(\\\"CP1\\/output.txt\\\",'w')\\n# sys.stdin=open(\\\"CP1\\/input.txt\\\",'r')\\n\\n# mod=pow(10,9)+7\\n\\n\\nt=int(input())\\nfor i in range(t):\\n\\ta,b,c=map(int,input().split())\\n\\tif a>b:\\n\\t\\ta,b=b,a\\n\\t# a=list(map(int,input().split()))\\n\\t# b=int(input())\\n\\tdist=b-a\\n\\tma=2*dist\\n\\tif max(a,b,c)>ma:\\n\\t\\tprint(-1)\\n\\t\\tcontinue\\n\\n\\tans=c+dist\\n\\tif ans>ma:\\n\\t\\tans=c-dist\\n\\tprint(ans)\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"This is the hard version of the problem. The difference between the versions is that the hard version does require you to output the numbers of the rods to be removed. You can make hacks only if all versions of the problem are solved.\\n\\nStitch likes experimenting with different machines with his friend Sparky. Today they built another machine.\\n\\nThe main element of this machine are n rods arranged along one straight line and numbered from 1 to n inclusive. Each of these rods must carry an electric charge quantitatively equal to either 1 or -1 (otherwise the machine will not work). Another condition for this machine to work is that the sign-variable sum of the charge on all rods must be zero.\\n\\nMore formally, the rods can be represented as an array of n numbers characterizing the charge: either 1 or -1. Then the condition must hold: a_1 - a_2 + a_3 - a_4 + \u2026 = 0, or \u2211_{i=1}^n (-1)^{i-1} \u22c5 a_i = 0.\\n\\nSparky charged all n rods with an electric current, but unfortunately it happened that the rods were not charged correctly (the sign-variable sum of the charge is not zero). The friends decided to leave only some of the rods in the machine. Sparky has q questions. In the ith question Sparky asks: if the machine consisted only of rods with numbers l_i to r_i inclusive, what minimal number of rods could be removed from the machine so that the sign-variable sum of charges on the remaining ones would be zero? Also Sparky wants to know the numbers of these rods. Perhaps the friends got something wrong, and the sign-variable sum is already zero. In that case, you don't have to remove the rods at all.\\n\\nIf the number of rods is zero, we will assume that the sign-variable sum of charges is zero, that is, we can always remove all rods.\\n\\nHelp your friends and answer all of Sparky's questions!\\n\\nInput\\n\\nEach test contains multiple test cases.\\n\\nThe first line contains one positive integer t (1 \u2264 t \u2264 10^3), denoting the number of test cases. Description of the test cases follows.\\n\\nThe first line of each test case contains two positive...\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst int mod = 998244353;\\nconst int maxn = 200005;\\nmap<int, vector<int>> mp;\\nvoid go() {\\n  int n, k;\\n  cin >> n >> k;\\n  int pre[n + 5];\\n  pre[0] = 0;\\n  string s;\\n  cin >> s;\\n  s = \\\" \\\" + s;\\n  mp.clear();\\n  auto solve = [&](int l, int r) {\\n    int sum = pre[r] + pre[l - 1];\\n    return *lower_bound(mp[sum].begin(), mp[sum].end(), l);\\n  };\\n  for (int i = 1; i < n + 1; i++) {\\n    pre[i] = pre[i - 1] + (i % 2 ? 1 : -1) * (s[i] == '+' ? 1 : -1);\\n    mp[pre[i] + pre[i - 1]].push_back(i);\\n  }\\n  while (k--) {\\n    int l, r;\\n    cin >> l >> r;\\n    if (pre[r] == pre[l - 1]) {\\n      cout << 0 << '\\\\n';\\n    } else if (r % 2 - l % 2) {\\n      cout << 2 << '\\\\n';\\n      cout << l << ' ' << solve(l + 1, r) << '\\\\n';\\n    } else {\\n      cout << 1 << '\\\\n' << solve(l, r) << '\\\\n';\\n    }\\n  }\\n}\\nint main() {\\n  ios_base::sync_with_stdio(0);\\n  cin.tie(0);\\n  int c = 1;\\n  int t;\\n  if (!c) {\\n    t = 1;\\n  } else {\\n    cin >> t;\\n  }\\n  while (t--) {\\n    go();\\n  }\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"On the board, Bob wrote n positive integers in [base](https:\\/\\/en.wikipedia.org\\/wiki\\/Positional_notation#Base_of_the_numeral_system) 10 with sum s (i. e. in decimal numeral system). Alice sees the board, but accidentally interprets the numbers on the board as base-11 integers and adds them up (in base 11).\\n\\nWhat numbers should Bob write on the board, so Alice's sum is as large as possible?\\n\\nInput\\n\\nThe input consists of multiple test cases. The first line contains an integer t (1 \u2264 t \u2264 100) \u2014 the number of test cases. The description of the test cases follows.\\n\\nThe only line of each test case contains two integers s and n (1 \u2264 s \u2264 10^9; 1 \u2264 n \u2264 min(100, s)) \u2014 the sum and amount of numbers on the board, respectively. Numbers s and n are given in decimal notation (base 10).\\n\\nOutput\\n\\nFor each test case, output n positive integers \u2014 the numbers Bob should write on the board, so Alice's sum is as large as possible. If there are multiple answers, print any of them.\\n\\nExample\\n\\nInput\\n\\n\\n6\\n97 2\\n17 1\\n111 4\\n100 2\\n10 9\\n999999 3\\n\\n\\nOutput\\n\\n\\n70 27 \\n17 \\n3 4 100 4\\n10 90\\n1 1 2 1 1 1 1 1 1 \\n999900 90 9\\n\\nNote\\n\\nIn the first test case, 70_{10} + 27_{10} = 97_{10}, and Alice's sum is $$$70_{11} + 27_{11} = 97_{11} = 9 \u22c5 11 + 7 = 106_{10}. (Here x_b represents the number x in base b.) It can be shown that it is impossible for Alice to get a larger sum than 106_{10}$$$.\\n\\nIn the second test case, Bob can only write a single number on the board, so he must write 17.\\n\\nIn the third test case, 3_{10} + 4_{10} + 100_{10} + 4_{10} = 111_{10}, and Alice's sum is $$$3_{11} + 4_{11} + 100_{11} + 4_{11} = 110_{11} = 1 \u22c5 11^2 + 1 \u22c5 11 = 132_{10}. It can be shown that it is impossible for Alice to get a larger sum than 132_{10}$$$.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint ans[10000];\\nint main() {\\n  int t = 1;\\n  scanf(\\\"%d\\\", &t);\\n  while (t--) {\\n    int s, n;\\n    scanf(\\\"%d%d\\\", &s, &n);\\n    int a = s, tot = 0;\\n    while (a) {\\n      tot += a % 10;\\n      a \\/= 10;\\n    }\\n    if (tot >= n) {\\n      int e = 1;\\n      ans[0] = 0;\\n      while (ans[0] + 1 < n) {\\n        if (s \\/ e % 10 > 0) {\\n          s -= e;\\n          ans[++ans[0]] = e;\\n        } else\\n          e *= 10;\\n      }\\n      ans[n] = s;\\n    } else {\\n      int e = 1;\\n      ans[0] = 0;\\n      while (s) {\\n        if (s \\/ e % 10 > 0) {\\n          s -= e;\\n          ans[++ans[0]] = e;\\n        } else\\n          e *= 10;\\n      }\\n      while (ans[0] != n) {\\n        int ma = n + 1;\\n        ans[n + 1] = 1000000001;\\n        for (int i = 1; i <= ans[0]; i++)\\n          if (ans[ma] > ans[i] && ans[i] != 1) ma = i;\\n        int a = ans[ma];\\n        int e = 1;\\n        while (e * 10 <= ans[ma]) e *= 10;\\n        e \\/= 10;\\n        int tt = 9;\\n        while (tt-- && ans[0] < n) {\\n          ans[++ans[0]] = e;\\n          ans[ma] -= e;\\n        }\\n      }\\n    }\\n    for (int i = 1; i <= n; i++) printf(\\\"%d \\\", ans[i]);\\n    puts(\\\"\\\");\\n  }\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"In Berland, n different types of banknotes are used. Banknotes of the i-th type have denomination 10^{a_i} burles (burles are the currency used in Berland); the denomination of banknotes of the first type is exactly 1.\\n\\nLet's denote f(s) as the minimum number of banknotes required to represent exactly s burles. For example, if the denominations of banknotes used in Berland are 1, 10 and 100, then f(59) = 14: 9 banknotes with denomination of 1 burle and 5 banknotes with denomination of 10 burles can be used to represent exactly 9 \u22c5 1 + 5 \u22c5 10 = 59 burles, and there's no way to do it with fewer banknotes.\\n\\nFor a given integer k, find the minimum positive number of burles s that cannot be represented with k or fewer banknotes (that is, f(s) > k).\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 10^4) \u2014 number of test cases.\\n\\nThe first line of each test case contains two integers n and k (1 \u2264 n \u2264 10; 1 \u2264 k \u2264 10^9).\\n\\nThe next line contains n integers a_1, a_2, ..., a_n (0 = a_1 < a_2 < ... < a_n \u2264 9).\\n\\nOutput\\n\\nFor each test case, print one integer \u2014 the minimum positive number of burles s that cannot be represented with k or fewer banknotes.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n3 13\\n0 1 2\\n2 777\\n0 4\\n3 255\\n0 1 3\\n10 1000000000\\n0 1 2 3 4 5 6 7 8 9\\n\\n\\nOutput\\n\\n\\n59\\n778\\n148999\\n999999920999999999\\\":\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint a[10];\\nlong long v[10];\\nlong long pw[12];\\nint len(long long x) {\\n  int ans = 0;\\n  while (x) {\\n    ans++;\\n    x \\/= 10;\\n  }\\n  return ans;\\n}\\nint main() {\\n  ios::sync_with_stdio(false);\\n  cin.tie(NULL);\\n  int t;\\n  cin >> t;\\n  pw[0] = 1;\\n  for (int i = 1; i <= 10; i++) pw[i] = pw[i - 1] * 10;\\n  while (t--) {\\n    long long n, k;\\n    cin >> n >> k;\\n    k++;\\n    for (int i = 0; i < n; i++) cin >> a[i];\\n    for (int i = 1; i < n; i++) {\\n      v[i] = min(k, pw[a[i] - a[i - 1]] - 1);\\n      k -= v[i];\\n    }\\n    bool flag = false;\\n    if (k != 0) {\\n      cout << k;\\n      flag = true;\\n    }\\n    for (int i = n - 2; i >= 0; i--) {\\n      if (flag)\\n        for (int j = 1; j <= a[i + 1] - a[i] - len(v[i + 1]); j++) cout << \\\"0\\\";\\n      if (v[i + 1] != 0) {\\n        cout << v[i + 1];\\n        flag = true;\\n      }\\n    }\\n    cout << \\\"\\\\n\\\";\\n  }\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You are given an array a of n integers, and another integer k such that 2k \u2264 n.\\n\\nYou have to perform exactly k operations with this array. In one operation, you have to choose two elements of the array (let them be a_i and a_j; they can be equal or different, but their positions in the array must not be the same), remove them from the array, and add \u230a (a_i)\\/(a_j) \u230b to your score, where \u230a x\\/y \u230b is the maximum integer not exceeding x\\/y.\\n\\nInitially, your score is 0. After you perform exactly k operations, you add all the remaining elements of the array to the score.\\n\\nCalculate the minimum possible score you can get.\\n\\nInput\\n\\nThe first line of the input contains one integer t (1 \u2264 t \u2264 500) \u2014 the number of test cases.\\n\\nEach test case consists of two lines. The first line contains two integers n and k (1 \u2264 n \u2264 100; 0 \u2264 k \u2264 \u230a n\\/2 \u230b).\\n\\nThe second line contains n integers a_1, a_2, ..., a_n (1 \u2264 a_i \u2264 2 \u22c5 10^5).\\n\\nOutput\\n\\nPrint one integer \u2014 the minimum possible score you can get.\\n\\nExample\\n\\nInput\\n\\n\\n5\\n7 3\\n1 1 1 2 1 3 1\\n5 1\\n5 5 5 5 5\\n4 2\\n1 3 3 7\\n2 0\\n4 2\\n9 2\\n1 10 10 1 10 2 7 10 3\\n\\n\\nOutput\\n\\n\\n2\\n16\\n0\\n6\\n16\\n\\nNote\\n\\nLet's consider the example test.\\n\\nIn the first test case, one way to obtain a score of 2 is the following one:\\n\\n  1. choose a_7 = 1 and a_4 = 2 for the operation; the score becomes 0 + \u230a 1\\/2 \u230b = 0, the array becomes [1, 1, 1, 1, 3]; \\n  2. choose a_1 = 1 and a_5 = 3 for the operation; the score becomes 0 + \u230a 1\\/3 \u230b = 0, the array becomes [1, 1, 1]; \\n  3. choose a_1 = 1 and a_2 = 1 for the operation; the score becomes 0 + \u230a 1\\/1 \u230b = 1, the array becomes [1]; \\n  4. add the remaining element 1 to the score, so the resulting score is 2. \\n\\n\\n\\nIn the second test case, no matter which operations you choose, the resulting score is 16.\\n\\nIn the third test case, one way to obtain a score of 0 is the following one:\\n\\n  1. choose a_1 = 1 and a_2 = 3 for the operation; the score becomes 0 + \u230a 1\\/3 \u230b = 0, the array becomes [3, 7]; \\n  2. choose a_1 = 3 and a_2 = 7 for the operation; the score becomes 0 + \u230a 3\\/7 \u230b = 0, the array becomes...\\nfor _\",\"targets\":\"in range(int(input())):\\n    s, k = [int(_) for _ in input().split()]\\n    a = [int(_) for _ in input().split()]\\n    if k == 0:\\n        print(sum(a))\\n    else:\\n        r = 0\\n        a.sort()\\n        header = a[s-2*k:s-k]\\n        tail = a[s-k:]\\n        for _ in zip(header, tail):\\n            r += _[0]\\/\\/_[1]\\n        r += sum(a[:s-2*k])\\n        print(r)\",\"language\":\"python\",\"split\":\"test\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in CPP?\\nKaren has just arrived at school, and she has a math test today!\\n\\n<image>\\n\\nThe test is about basic addition and subtraction. Unfortunately, the teachers were too busy writing tasks for Codeforces rounds, and had no time to make an actual test. So, they just put one question in the test that is worth all the points.\\n\\nThere are n integers written on a row. Karen must alternately add and subtract each pair of adjacent integers, and write down the sums or differences on the next row. She must repeat this process on the values on the next row, and so on, until only one integer remains. The first operation should be addition.\\n\\nNote that, if she ended the previous row by adding the integers, she should start the next row by subtracting, and vice versa.\\n\\nThe teachers will simply look at the last integer, and then if it is correct, Karen gets a perfect score, otherwise, she gets a zero for the test.\\n\\nKaren has studied well for this test, but she is scared that she might make a mistake somewhere and it will cause her final answer to be wrong. If the process is followed, what number can she expect to be written on the last row?\\n\\nSince this number can be quite large, output only the non-negative remainder after dividing it by 109 + 7.\\n\\nInput\\n\\nThe first line of input contains a single integer n (1 \u2264 n \u2264 200000), the number of numbers written on the first row.\\n\\nThe next line contains n integers. Specifically, the i-th one among these is ai (1 \u2264 ai \u2264 109), the i-th number on the first row.\\n\\nOutput\\n\\nOutput a single integer on a line by itself, the number on the final row after performing the process above.\\n\\nSince this number can be quite large, print only the non-negative remainder after dividing it by 109 + 7.\\n\\nExamples\\n\\nInput\\n\\n5\\n3 6 9 12 15\\n\\n\\nOutput\\n\\n36\\n\\n\\nInput\\n\\n4\\n3 7 5 2\\n\\n\\nOutput\\n\\n1000000006\\n\\nNote\\n\\nIn the first test case, the numbers written on the first row are 3, 6, 9, 12 and 15.\\n\\nKaren performs the operations as follows:\\n\\n<image>\\n\\nThe non-negative remainder after dividing the final number by 109 + 7 is still 36, so...\",\"targets\":\"#include <bits\\/stdc++.h>\\n#pragma comment(linker, \\\"\\/STACK:64000000\\\")\\nusing namespace std;\\nconst int inf = (int)1e9;\\nconst int mod = inf + 7;\\nconst double eps = 1e-9;\\nconst double pi = acos(-1.0);\\nint n, a[200200];\\nint fact[200200], inv[200200];\\nint binpow(int a, int k) {\\n  if (k == 0) return 1;\\n  int ans = binpow(a, k \\/ 2);\\n  ans = 1ll * ans * ans % mod;\\n  if (k % 2) ans = 1ll * ans * a % mod;\\n  return ans;\\n}\\nint C(int n, int k) {\\n  if (k > n) return 0;\\n  int ans = fact[n];\\n  ans = 1ll * ans * inv[k] % mod;\\n  ans = 1ll * ans * inv[n - k] % mod;\\n  return ans;\\n}\\nint main() {\\n  scanf(\\\"%d\\\", &n);\\n  for (int i = 0; i < n; i++) scanf(\\\"%d\\\", a + i);\\n  fact[0] = inv[0] = 1;\\n  for (int i = 1; i < 200200; i++) {\\n    fact[i] = 1ll * i * fact[i - 1] % mod;\\n    inv[i] = binpow(fact[i], mod - 2);\\n  }\\n  int cur = 1;\\n  while (n > 1) {\\n    if (n % 4 == 1) break;\\n    vector<int> b;\\n    for (int i = 1; i < n; i++) {\\n      if (cur == 1)\\n        b.push_back((a[i - 1] + a[i]) % mod);\\n      else\\n        b.push_back((a[i - 1] - a[i]) % mod);\\n      cur *= -1;\\n    }\\n    n = b.size();\\n    for (int i = 0; i < n; i++) {\\n      a[i] = b[i];\\n    }\\n  }\\n  if (n % 4 == 1) {\\n    int k = n \\/ 4;\\n    k *= 2;\\n    int ans = 0;\\n    for (int i = 0, st = 0; i <= k; i++) {\\n      ans += a[st] * 1ll * C(k, i) % mod;\\n      ans %= mod;\\n      ans += mod;\\n      ans %= mod;\\n      st += 2;\\n    }\\n    printf(\\\"%d\\\\n\\\", ans);\\n    return 0;\\n  }\\n  assert(false);\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Do the following for a four-digit number N consisting of numbers 0-9.\\n\\n1. Let L be the number obtained as a result of arranging the numerical values \u200b\u200bof each of the N digits in descending order.\\n2. Let S be the number obtained as a result of arranging the numerical values \u200b\u200bof each of the N digits in ascending order.\\n3. Let the difference L-S be the new N (end of one operation)\\n4. Repeat from 1. for the new N\\n\\n\\n\\nAt 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\\nFirst time (N = 2012): L = 2210, S = 0122, L-S = 2088\\nSecond time (N = 2088): L = 8820, S = 0288, L-S = 8532\\nThird time (N = 8532): L = 8532, S = 2358, L-S = 6174\\nAnd reach 6174 in 3 operations.\\n\\nWrite a program that calculates how many operations will reach 6174 given a four-digit number consisting of the numbers 0-9.\\n\\n\\n\\ninput\\n\\nThe 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\\n\\nN\\n\\n\\nThe dataset is one line and N (1 \u2264 N \u2264 9999) indicates a four-digit number. If N <1000, the upper digit is padded with zeros.\\n\\nThe number of datasets does not exceed 10000.\\n\\noutput\\n\\nThe 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.\\n\\nExample\\n\\nInput\\n\\n6174\\n2012\\n3333\\n0000\\n\\n\\nOutput\\n\\n0\\n3\\nNA\\nThe above is tricky. Write me a correct solution in CPP.\",\"targets\":\"#include <iostream>\\n#include <string>\\n#include <algorithm>\\n#include <sstream>\\n#include <cstdio>\\n#include <cassert>\\n\\nusing namespace std;\\n\\nint toInt(string s){int v;istringstream sin(s);sin>>v;return v;}\\ntemplate<class T> inline string toString(T x) {ostringstream sout;sout<<x;return sout.str();}\\n\\nint main(void)\\n{\\n\\tstring n;\\n\\twhile (cin >> n && n != \\\"0000\\\"){\\n\\t\\tif (count(n.begin(), n.end(), n[0]) == 4){\\n\\t\\t\\tcout << \\\"NA\\\" << endl;\\n\\t\\t\\tcontinue;\\n\\t\\t}\\n\\t\\t\\/\\/ assert(n != \\\"0000\\\");\\n\\n\\t\\tint tmp = toInt(n);\\n\\t\\tchar str[128];\\n\\t\\tsprintf(str, \\\"%04d\\\", tmp);\\n\\t\\tn = string(str);\\n\\t\\tint cnt = 0;\\n\\t\\twhile (n != \\\"6174\\\"){\\n\\t\\t\\tif (count(n.begin(), n.end(), n[0]) == 4){\\n\\t\\t\\t\\tcout << \\\"NA\\\" << endl;\\n\\t\\t\\t\\tgoto END;\\n\\t\\t\\t}\\n\\t\\t\\tstring L = n; sort(L.rbegin(), L.rend());\\n\\t\\t\\tstring S = n; sort(S.begin(), S.end());\\n\\t\\t\\t\\/\\/ cout << n << \\\" \\\" << L << \\\" \\\" << S << endl;\\n\\t\\t\\tint tmp = toInt(L) - toInt(S);\\n\\t\\t\\tchar str[128];\\n\\t\\t\\tsprintf(str, \\\"%04d\\\", tmp);\\n\\t\\t\\tn = string(str);\\n\\t\\t\\tcnt++;\\n\\t\\t}\\n\\t\\tcout << cnt << endl;\\n\\t\\tEND:;\\n\\t}\\n\\n\\treturn 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in CPP?\\nThis is an easier version of the problem with smaller constraints.\\n\\nKorney Korneevich dag up an array a of length n. Korney Korneevich has recently read about the operation [bitwise XOR](https:\\/\\/en.wikipedia.org\\/wiki\\/Bitwise_operation#XOR), so he wished to experiment with it. For this purpose, he decided to find all integers x \u2265 0 such that there exists an increasing subsequence of the array a, in which the bitwise XOR of numbers is equal to x.\\n\\nIt didn't take a long time for Korney Korneevich to find all such x, and he wants to check his result. That's why he asked you to solve this problem!\\n\\nA sequence s is a subsequence of a sequence b if s can be obtained from b by deletion of several (possibly, zero or all) elements.\\n\\nA sequence s_1, s_2, \u2026 , s_m is called increasing if s_1 < s_2 < \u2026 < s_m.\\n\\nInput\\n\\nThe first line contains a single integer n (1 \u2264 n \u2264 10^5).\\n\\nThe second line contains n integers a_1, a_2, \u2026, a_n (0 \u2264 a_i \u2264 500) \u2014 the elements of the array a.\\n\\nOutput\\n\\nIn the first line print a single integer k \u2014 the number of found x values.\\n\\nIn the second line print k integers in increasing order x_1, x_2, \u2026 x_k (0 \u2264 x_1 < \u2026 < x_k) \u2014 found x values.\\n\\nExamples\\n\\nInput\\n\\n\\n4\\n4 2 2 4\\n\\n\\nOutput\\n\\n\\n4\\n0 2 4 6 \\n\\n\\nInput\\n\\n\\n8\\n1 0 1 7 12 5 3 2\\n\\n\\nOutput\\n\\n\\n12\\n0 1 2 3 4 5 6 7 10 11 12 13 \\n\\nNote\\n\\nIn the first test case:\\n\\n  * To get value x = 0 it is possible to choose and empty subsequence \\n  * To get value x = 2 it is possible to choose a subsequence [2] \\n  * To get value x = 4 it is possible to choose a subsequence [4] \\n  * To get value x = 6 it is possible to choose a subsequence [2, 4]\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nlong long GCD(long long a, long long b) {\\n  if (b > a) {\\n    swap(a, b);\\n  }\\n  if (b == 0) {\\n    return a;\\n  }\\n  return GCD(b, a % b);\\n}\\nlong long mul_mod(long long a, long long b, long long m) {\\n  a %= m;\\n  b %= m;\\n  return ((((a * b) % m) + m) % m);\\n}\\nlong long power(long long base, long long n, long long m) {\\n  long long res = 1;\\n  while (n) {\\n    if (n & 1) res = mul_mod(res, base, m);\\n    base = mul_mod(base, base, m);\\n    n = n >> 1;\\n  }\\n  return res;\\n}\\nlong long ncr(long long x, long long y) {\\n  long long ans = 1;\\n  y = (y > x - y ? x - y : y);\\n  for (long long i = 0; i < y; i++) {\\n    ans = (ans * (x - i)) % 1000000007;\\n    ans = (ans * power(i + 1, 1000000007 - 2, 1000000007)) % 1000000007;\\n    ans = ans % 1000000007;\\n  }\\n  return ans;\\n}\\nbool isPrime(long long n) {\\n  if (n == 1 or n == 0) return false;\\n  if (n == 2 or n == 3) return true;\\n  if (n % 2 == 0 or n % 3 == 0) return false;\\n  for (long long i = 5; i * i <= n; i += 6) {\\n    if (n % i == 0 or n % (i + 2) == 0) return false;\\n  }\\n  return true;\\n}\\nlong long add_mod(long long a, long long b, long long m) {\\n  a % m;\\n  b % m;\\n  return ((((a + b) % m) + m) % m);\\n}\\nlong long sub_mod(long long a, long long b, long long m) {\\n  a % m;\\n  b % m;\\n  return ((((a - b) % m) + m) % m);\\n}\\nvector<long long> prmFactors(long long n) {\\n  vector<long long> res;\\n  for (long long i = 2; i * i <= n; i++) {\\n    if (n % i == 0) {\\n      while (n % i == 0) n \\/= i;\\n      res.push_back(i);\\n    }\\n  }\\n  if (n > 1) res.push_back(n);\\n  return res;\\n}\\nvoid run() {\\n  ios_base::sync_with_stdio(false);\\n  cin.tie(NULL);\\n  ;\\n}\\nvoid solve() {\\n  long long n;\\n  cin >> n;\\n  long long a[n];\\n  for (int i = 0; i < n; i++) cin >> a[i];\\n  vector<long long> mn(513, 1e9);\\n  vector<long long> ans;\\n  ans.push_back(0);\\n  mn[0] = 0;\\n  for (int i = 0; i < n; i++) {\\n    for (int j = 0; j < 513; j++) {\\n      if (mn[j] < a[i]) {\\n        mn[j ^ a[i]] = min(mn[j ^ a[i]], a[i]);\\n      }\\n    }\\n  }\\n  for (int i = 1; i < 513; i++)\\n    if (mn[i] != 1e9)...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"As you very well know, this year's funkiest numbers are so called triangular numbers (that is, integers that are representable as <image>, where k is some positive integer), and the coolest numbers are those that are representable as a sum of two triangular numbers.\\n\\nA well-known hipster Andrew adores everything funky and cool but unfortunately, he isn't good at maths. Given number n, help him define whether this number can be represented by a sum of two triangular numbers (not necessarily different)!\\n\\nInput\\n\\nThe first input line contains an integer n (1 \u2264 n \u2264 109).\\n\\nOutput\\n\\nPrint \\\"YES\\\" (without the quotes), if n can be represented as a sum of two triangular numbers, otherwise print \\\"NO\\\" (without the quotes).\\n\\nExamples\\n\\nInput\\n\\n256\\n\\n\\nOutput\\n\\nYES\\n\\n\\nInput\\n\\n512\\n\\n\\nOutput\\n\\nNO\\n\\nNote\\n\\nIn the first sample number <image>.\\n\\nIn the second sample number 512 can not be represented as a sum of two triangular numbers.\\nUsing python can you solve the prior task?\",\"targets\":\"h=set([x*(x+1)\\/2 for x in xrange(1,int(5e4))])\\nn=input()\\nprint \\\"YES\\\"if ([n-i in h for i in h].count(1)>0)else\\\"NO\\\"\",\"language\":\"python\",\"split\":\"train\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Polycarp likes squares and cubes of positive integers. Here is the beginning of the sequence of numbers he likes: 1, 4, 8, 9, ....\\n\\nFor a given number n, count the number of integers from 1 to n that Polycarp likes. In other words, find the number of such x that x is a square of a positive integer number or a cube of a positive integer number (or both a square and a cube simultaneously).\\n\\nInput\\n\\nThe first line contains an integer t (1 \u2264 t \u2264 20) \u2014 the number of test cases.\\n\\nThen t lines contain the test cases, one per line. Each of the lines contains one integer n (1 \u2264 n \u2264 10^9).\\n\\nOutput\\n\\nFor each test case, print the answer you are looking for \u2014 the number of integers from 1 to n that Polycarp likes.\\n\\nExample\\n\\nInput\\n\\n\\n6\\n10\\n1\\n25\\n1000000000\\n999999999\\n500000000\\n\\n\\nOutput\\n\\n\\n4\\n1\\n6\\n32591\\n32590\\n23125\",\"targets\":\"cases = int(input())\\n\\n\\n\\nfor i in range(cases):\\n    numbers = {1}\\n    variable = 2\\n    number = int(input())\\n    while True and number != 1:    \\n        if variable**2 <= number:\\n            numbers.add(variable**2)\\n        else:\\n            break\\n        if variable**3 <= number:\\n            numbers.add((variable**3))  \\n        variable += 1\\n    print(len(numbers))\",\"language\":\"python\",\"split\":\"test\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You have an array a consisting of n distinct positive integers, numbered from 1 to n. Define p_k as $$$p_k = \u2211_{1 \u2264 i, j \u2264 k} a_i mod a_j, where x \\\\bmod y denotes the remainder when x is divided by y. You have to find and print p_1, p_2, \\\\ldots, p_n$$$. \\n\\nInput\\n\\nThe first line contains n \u2014 the length of the array (2 \u2264 n \u2264 2 \u22c5 10^5).\\n\\nThe second line contains n space-separated distinct integers a_1, \u2026, a_n (1 \u2264 a_i \u2264 3 \u22c5 10^5, a_i \u2260 a_j if i \u2260 j). \\n\\nOutput\\n\\nPrint n integers p_1, p_2, \u2026, p_n. \\n\\nExamples\\n\\nInput\\n\\n\\n4\\n6 2 7 3\\n\\n\\nOutput\\n\\n\\n0 2 12 22\\n\\n\\nInput\\n\\n\\n3\\n3 2 1\\n\\n\\nOutput\\n\\n\\n0 3 5\\nThe above is tricky. Write me a correct solution in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst int B = 600;\\nint tcnt[300001];\\nlong long tree[300001], V[B + 1];\\nvoid update(int n) {\\n  for (int v = n; n <= 300000; n++) {\\n    tree[n] += v;\\n    tcnt[n]++;\\n    if (n % B == B - 1) break;\\n  }\\n}\\nlong long get_sum(int s, int e) {\\n  if (s \\/ B == e \\/ B) return tree[e] - (s % B ? tree[s - 1] : 0);\\n  long long ret = tree[s \\/ B * B + B - 1] - (s % B ? tree[s - 1] : 0) + tree[e];\\n  s = s \\/ B * B + B;\\n  e = e \\/ B * B;\\n  while (s < e) {\\n    ret += tree[s + B - 1];\\n    s += B;\\n  }\\n  return ret;\\n}\\nint get_cnt(int s, int e) {\\n  if (s \\/ B == e \\/ B) return tcnt[e] - (s % B ? tcnt[s - 1] : 0);\\n  int ret = tcnt[s \\/ B * B + B - 1] - (s % B ? tcnt[s - 1] : 0) + tcnt[e];\\n  s = s \\/ B * B + B;\\n  e = e \\/ B * B;\\n  while (s < e) {\\n    ret += tcnt[s + B - 1];\\n    s += B;\\n  }\\n  return ret;\\n}\\nint main() {\\n  ios::sync_with_stdio(false);\\n  cin.tie(NULL);\\n  cout.tie(NULL);\\n  ((void)0);\\n  ((void)0);\\n  ((void)0);\\n  int N, n;\\n  unsigned long long ans = 0;\\n  long long cv, cc;\\n  for (cin >> N; N--;) {\\n    int a;\\n    cin >> a;\\n    if (a <= B)\\n      ans += V[a];\\n    else {\\n      for (int i = 1; i <= a; i = n) {\\n        n = a \\/ (a \\/ i) + 1;\\n        cv = get_sum(i, n - 1);\\n        cc = get_cnt(i, n - 1);\\n        ans += cv;\\n        ans += 1LL * cc * a - (a \\/ i) * cv;\\n      }\\n      for (int i = 2 * a;; i += a) {\\n        cv = get_sum(i - a, min(i - 1, 300000));\\n        cc = get_cnt(i - a, min(i - 1, 300000));\\n        ans += cv - 1LL * cc * (i - a);\\n        ans += 1LL * a * cc;\\n        if (i > 300000) break;\\n      }\\n    }\\n    for (int i = 1; i <= B; i++) V[i] += a % i + i % a;\\n    update(a);\\n    cout << ans << ' ';\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Stephen Queen wants to write a story. He is a very unusual writer, he uses only letters 'a', 'b', 'c', 'd' and 'e'!\\n\\nTo compose a story, Stephen wrote out n words consisting of the first 5 lowercase letters of the Latin alphabet. He wants to select the maximum number of words to make an interesting story.\\n\\nLet a story be a sequence of words that are not necessarily different. A story is called interesting if there exists a letter which occurs among all words of the story more times than all other letters together.\\n\\nFor example, the story consisting of three words \\\"bac\\\", \\\"aaada\\\", \\\"e\\\" is interesting (the letter 'a' occurs 5 times, all other letters occur 4 times in total). But the story consisting of two words \\\"aba\\\", \\\"abcde\\\" is not (no such letter that it occurs more than all other letters in total).\\n\\nYou are given a sequence of n words consisting of letters 'a', 'b', 'c', 'd' and 'e'. Your task is to choose the maximum number of them to make an interesting story. If there's no way to make a non-empty story, output 0.\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 5000) \u2014 the number of test cases. Then t test cases follow.\\n\\nThe first line of each test case contains one integer n (1 \u2264 n \u2264 2 \u22c5 10^5) \u2014 the number of the words in the sequence. Then n lines follow, each of them contains a word \u2014 a non-empty string consisting of lowercase letters of the Latin alphabet. The words in the sequence may be non-distinct (i. e. duplicates are allowed). Only the letters 'a', 'b', 'c', 'd' and 'e' may occur in the words.\\n\\nIt is guaranteed that the sum of n over all test cases doesn't exceed 2 \u22c5 10^5; the sum of the lengths of all words over all test cases doesn't exceed 4 \u22c5 10^5.\\n\\nOutput\\n\\nFor each test case, output the maximum number of words that compose an interesting story. Print 0 if there's no way to make a non-empty interesting story.\\n\\nExample\\n\\nInput\\n\\n\\n6\\n3\\nbac\\naaada\\ne\\n3\\naba\\nabcde\\naba\\n2\\nbaba\\nbaba\\n4\\nab\\nab\\nc\\nbc\\n5\\ncbdca\\nd\\na\\nd\\ne\\n3\\nb\\nc\\nca\\n\\n\\nOutput\\n\\n\\n3\\n2\\n0\\n2\\n3\\n2\\n\\nNote\\n\\nIn the first test case of the example, all 3 words...\",\"targets\":\"import java.io.*;\\nimport java.util.*;\\n\\npublic class MainC {\\n    static class InputReader {\\n        public BufferedReader reader;\\n        public StringTokenizer tokenizer;\\n        public InputReader(InputStream stream) {\\n            reader = new BufferedReader(new InputStreamReader(stream), 32768);\\n            tokenizer = null;\\n        }\\n        public String next() {\\n            while (tokenizer == null || !tokenizer.hasMoreTokens()) {\\n                try {\\n                    tokenizer = new StringTokenizer(reader.readLine());\\n                } catch (IOException e) {\\n                    throw new RuntimeException(e);\\n                }\\n            }\\n            return tokenizer.nextToken();\\n        }\\n        public int nextInt() {\\n            return Integer.parseInt(next());\\n        }\\n        public long nextLong() {\\n            return Long.parseLong(next());\\n        }\\n        public boolean hasNext() {\\n            try {\\n                String string = reader.readLine();\\n                if (string == null) {\\n                    return false;\\n                }\\n                tokenizer = new StringTokenizer(string);\\n                return tokenizer.hasMoreTokens();\\n            } catch (IOException e) {\\n                return false;\\n            }\\n        }\\n    }\\n    static InputReader in = new InputReader(System.in);\\n    static PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));\\n\\n    public static void main(String[] args) {\\n        int t = in.nextInt();\\n        while (t -- > 0) {\\n            solve();\\n        }\\n        out.close();\\n    }\\n    static void solve() {\\n        int n = in.nextInt();\\n        Magic[] magics = new Magic[n];\\n        for (int i = 0; i < n; i++) {\\n            magics[i] = getMagic(in.next());\\n        }\\n        \\/\\/ count a\\n        int tot, index = -1;\\n        Arrays.sort(magics, Comparator.comparingInt(o -> -o.aDiff));\\n        tot = 0;\\n\\n        for (int i = 0; i < n; i++) {\\n            tot += magics[i].aDiff;\\n            index = i;\\n            if (tot <= 0) {\\n              ...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Emily's birthday is next week and Jack has decided to buy a present for her. He knows she loves books so he goes to the local bookshop, where there are n books on sale from one of m genres.\\n\\nIn the bookshop, Jack decides to buy two books of different genres.\\n\\nBased on the genre of books on sale in the shop, find the number of options available to Jack for choosing two books of different genres for Emily. Options are considered different if they differ in at least one book.\\n\\nThe books are given by indices of their genres. The genres are numbered from 1 to m.\\n\\nInput\\n\\nThe first line contains two positive integers n and m (2 \u2264 n \u2264 2\u00b7105, 2 \u2264 m \u2264 10) \u2014 the number of books in the bookstore and the number of genres.\\n\\nThe second line contains a sequence a1, a2, ..., an, where ai (1 \u2264 ai \u2264 m) equals the genre of the i-th book.\\n\\nIt is guaranteed that for each genre there is at least one book of that genre.\\n\\nOutput\\n\\nPrint the only integer \u2014 the number of ways in which Jack can choose books.\\n\\nIt is guaranteed that the answer doesn't exceed the value 2\u00b7109.\\n\\nExamples\\n\\nInput\\n\\n4 3\\n2 1 3 1\\n\\n\\nOutput\\n\\n5\\n\\n\\nInput\\n\\n7 4\\n4 2 3 1 2 4 3\\n\\n\\nOutput\\n\\n18\\n\\nNote\\n\\nThe answer to the first test sample equals 5 as Sasha can choose:\\n\\n  1. the first and second books, \\n  2. the first and third books, \\n  3. the first and fourth books, \\n  4. the second and third books, \\n  5. the third and fourth books. \\nThe above is tricky. Write me a correct solution in PYTHON3.\",\"targets\":\"x=[]\\nx = input().split()\\nn = int(x[0])\\nm = int (x[1])\\na=[]\\na=input().split()\\ns={}\\nfor i  in range (n):\\n    try:\\n        s[a[i]] += 1\\n    except KeyError:\\n        s[a[i]] = 1\\n\\nans = n*(n-1)\\/2\\nfor i in s.values():\\n    if (i != 1):\\n        ans -= i*(i-1)\\/2\\nprint(int(ans))\",\"language\":\"python\",\"split\":\"train\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in CPP?\\nFlatland has recently introduced a new type of an eye check for the driver's licence. The check goes like that: there is a plane with mannequins standing on it. You should tell the value of the minimum angle with the vertex at the origin of coordinates and with all mannequins standing inside or on the boarder of this angle. \\n\\nAs you spend lots of time \\\"glued to the screen\\\", your vision is impaired. So you have to write a program that will pass the check for you.\\n\\nInput\\n\\nThe first line contains a single integer n (1 \u2264 n \u2264 105) \u2014 the number of mannequins.\\n\\nNext n lines contain two space-separated integers each: xi, yi (|xi|, |yi| \u2264 1000) \u2014 the coordinates of the i-th mannequin. It is guaranteed that the origin of the coordinates has no mannequin. It is guaranteed that no two mannequins are located in the same point on the plane.\\n\\nOutput\\n\\nPrint a single real number \u2014 the value of the sought angle in degrees. The answer will be considered valid if the relative or absolute error doesn't exceed 10 - 6. \\n\\nExamples\\n\\nInput\\n\\n2\\n2 0\\n0 2\\n\\n\\nOutput\\n\\n90.0000000000\\n\\n\\nInput\\n\\n3\\n2 0\\n0 2\\n-2 2\\n\\n\\nOutput\\n\\n135.0000000000\\n\\n\\nInput\\n\\n4\\n2 0\\n0 2\\n-2 0\\n0 -2\\n\\n\\nOutput\\n\\n270.0000000000\\n\\n\\nInput\\n\\n2\\n2 1\\n1 2\\n\\n\\nOutput\\n\\n36.8698976458\\n\\nNote\\n\\nSolution for the first sample test is shown below: \\n\\n<image>\\n\\nSolution for the second sample test is shown below: \\n\\n<image>\\n\\nSolution for the third sample test is shown below: \\n\\n<image>\\n\\nSolution for the fourth sample test is shown below: \\n\\n<image>\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nvoid debug() {\\n  fflush(stdin);\\n  printf(\\\"Press any key to continue\\\");\\n  getc(stdin);\\n  fflush(stdin);\\n}\\nint n;\\ndouble angle[100005];\\nint main() {\\n  scanf(\\\"%d\\\", &n);\\n  for (int i = 1; i <= n; i++) {\\n    double x, y;\\n    scanf(\\\"%lf%lf\\\", &x, &y);\\n    double tmp = atan(y \\/ x) * 180 \\/ acos(-1.0);\\n    if (tmp > 0) {\\n      if (x <= 0 && y <= 0) tmp += 180;\\n    } else if (tmp < 0) {\\n      if (x <= 0 && y >= 0)\\n        tmp += 180;\\n      else if (x >= 0 && y <= 0)\\n        tmp += 360;\\n    } else {\\n      if (x < 0) tmp += 180;\\n    }\\n    angle[i] = tmp;\\n  }\\n  sort(angle + 1, angle + n + 1);\\n  double ans = angle[n] - angle[1];\\n  for (int i = 2; i <= n; i++) ans = min(ans, 360 - (angle[i] - angle[i - 1]));\\n  printf(\\\"%0.7lf\\\\n\\\", ans);\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"AquaMoon had n strings of length m each. n is an odd number.\\n\\nWhen 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!\\n\\nIn 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.\\n\\nFor 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\\\".\\n\\nCirno then stole away the string without pair and shuffled all remaining strings in arbitrary order.\\n\\nAquaMoon 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?\\n\\nInput\\n\\nThis 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.\\n\\nThe input consists of multiple test cases. The first line contains a single integer t (1 \u2264 t \u2264 100) \u2014 the number of test cases.\\n\\nThe first line of each test case contains two integers n, m (1 \u2264 n \u2264 10^5, 1 \u2264 m \u2264 10^5) \u2014 the number of strings and the length of each string, respectively.\\n\\nThe next n lines each contain a string with length m, describing the original n strings. All string consists of lowercase...\\nThe above is tricky. Write me a correct solution in JAVA.\",\"targets\":\"\\/\\/package Practise;\\n\\nimport java.io.BufferedReader;\\nimport java.io.IOException;\\nimport java.io.InputStreamReader;\\nimport java.util.Arrays;\\nimport java.util.Random;\\nimport java.util.StringTokenizer;\\n\\npublic class StolenString {\\n\\tpublic static void main(String args[]) {\\n\\t\\tFastScanner fs=new FastScanner();\\n\\t\\tint t=fs.nextInt();\\n\\t\\tfor(int t1=0;t1<t;t1++) {\\n\\t\\tint n=fs.nextInt();\\n\\t\\tint m=fs.nextInt();\\n\\t\\tint dp[][]=new int[m][26],i,j;\\n        for(i=0;i<n;i++)\\n        {\\n            String a=fs.next();\\n            for(j=0;j<m;j++)\\n            dp[j][a.charAt(j)-'a']++;\\n        }\\n\\n        for(i=0;i<n-1;i++)\\n        {\\n            String a=fs.next();\\n            for(j=0;j<m;j++)\\n            dp[j][a.charAt(j)-'a']--;\\n        }\\n\\n        StringBuilder sb=new StringBuilder();\\n        for(i=0;i<m;i++)\\n        {\\n            char cur=' ';\\n            for(j=0;j<26;j++) {\\n            if(dp[i][j]!=0) \\n            \\t{cur=(char)('a'+j);continue;}\\n            }\\n            sb.append(cur);\\n        }\\n        sb.append(\\\"\\\\n\\\");\\n        System.out.print(sb);\\n        System.out.flush();\\n\\t}\\n\\t}\\n\\tstatic final Random random=new Random();\\t\\n\\tstatic void ruffleSort(int[] a) {\\n\\t\\tint n=a.length;\\/\\/shuffle, then sort \\n\\t\\tfor (int i=0; i<n; i++) {\\n\\t\\t\\tint oi=random.nextInt(n), temp=a[oi];\\n\\t\\t\\ta[oi]=a[i]; a[i]=temp;\\n\\t\\t}\\n\\t\\tArrays.sort(a);\\n\\t}\\n\\t\\n\\tstatic class FastScanner {\\n\\t\\tBufferedReader br=new BufferedReader(new InputStreamReader(System.in));\\n\\t\\tStringTokenizer st=new StringTokenizer(\\\"\\\");\\n\\t\\tString next() {\\n\\t\\t\\twhile (!st.hasMoreTokens())\\n\\t\\t\\t\\ttry {\\n\\t\\t\\t\\t\\tst=new StringTokenizer(br.readLine());\\n\\t\\t\\t\\t} catch (IOException e) {\\n\\t\\t\\t\\t\\te.printStackTrace();\\n\\t\\t\\t\\t}\\n\\t\\t\\treturn st.nextToken();\\n\\t\\t}\\n\\t\\t\\n\\t\\tint nextInt() {\\n\\t\\t\\treturn Integer.parseInt(next());\\n\\t\\t}\\n\\t\\tint[] readArray(int n) {\\n\\t\\t\\tint[] a=new int[n];\\n\\t\\t\\tfor (int i=0; i<n; i++) a[i]=nextInt();\\n\\t\\t\\treturn a;\\n\\t\\t}\\n\\t\\tlong nextLong() {\\n\\t\\t\\treturn Long.parseLong(next());\\n\\t\\t}\\n\\t}\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in CPP?\\nThere are n points and m segments on the coordinate line. The initial coordinate of the i-th point is a_i. The endpoints of the j-th segment are l_j and r_j \u2014 left and right endpoints, respectively.\\n\\nYou can move the points. In one move you can move any point from its current coordinate x to the coordinate x - 1 or the coordinate x + 1. The cost of this move is 1.\\n\\nYou should move the points in such a way that each segment is visited by at least one point. A point visits the segment [l, r] if there is a moment when its coordinate was on the segment [l, r] (including endpoints).\\n\\nYou should find the minimal possible total cost of all moves such that all segments are visited.\\n\\nInput\\n\\nThe input consists of multiple test cases. The first line contains a single integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases. Description of the test cases follows.\\n\\nThe first line of each test case contains two integers n and m (1 \u2264 n, m \u2264 2 \u22c5 10^5) \u2014 the number of points and segments respectively.\\n\\nThe next line contains n distinct integers a_1, a_2, \u2026, a_n (-10^9 \u2264 a_i \u2264 10^9) \u2014 the initial coordinates of the points.\\n\\nEach of the next m lines contains two integers l_j, r_j (-10^9 \u2264 l_j \u2264 r_j \u2264 10^9) \u2014 the left and the right endpoints of the j-th segment.\\n\\nIt's guaranteed that the sum of n and the sum of m over all test cases does not exceed 2 \u22c5 10^5.\\n\\nOutput\\n\\nFor each test case print a single integer \u2014 the minimal total cost of all moves such that all segments are visited.\\n\\nExample\\n\\nInput\\n\\n\\n2\\n4 11\\n2 6 14 18\\n0 3\\n4 5\\n11 15\\n3 5\\n10 13\\n16 16\\n1 4\\n8 12\\n17 19\\n7 13\\n14 19\\n4 12\\n-9 -16 12 3\\n-20 -18\\n-14 -13\\n-10 -7\\n-3 -1\\n0 4\\n6 11\\n7 9\\n8 10\\n13 15\\n14 18\\n16 17\\n18 19\\n\\n\\nOutput\\n\\n\\n5\\n22\\n\\nNote\\n\\nIn the first test case the points can be moved as follows:\\n\\n  * Move the second point from the coordinate 6 to the coordinate 5. \\n  * Move the third point from the coordinate 14 to the coordinate 13. \\n  * Move the fourth point from the coordinate 18 to the coordinate 17. \\n  * Move the third point from the coordinate 13 to the coordinate 12. \\n  * Move the...\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\ninline int read() {\\n  int res = 0, f = 1;\\n  char ch;\\n  while (ch = getchar(), ch < '0' || ch > '9')\\n    if (ch == '-') f = -1;\\n  while (ch >= '0' && ch <= '9') res = res * 10 + ch - '0', ch = getchar();\\n  return res * f;\\n}\\nconst int N = 2e5 + 5, INF = 0x3f3f3f3f;\\nconst long long inf = 0x3f3f3f3f3f3f3f3f;\\nlong long fpool[N * 20], ppool[N * 20], spool[N * 20], dpool[N * 20],\\n    gpool[N * 20];\\nint o;\\nlong long *f[N], *pre[N], *suf[N], *d[N], *g[N];\\nint sz[N];\\nstruct seg {\\n  int l, r;\\n  inline bool operator<(const seg &a) const {\\n    return l != a.l ? l < a.l : r > a.r;\\n  }\\n} w[N], s[N];\\nbool ck[N];\\nint t, n, m;\\nlong long a[N];\\ninline void readdata() {\\n  n = read(), m = read();\\n  for (int i = 1; i <= n; ++i) a[i] = read();\\n  for (int i = 1; i <= m; ++i) w[i].l = read(), w[i].r = read();\\n}\\ninline void build() {\\n  sort(a + 1, a + n + 1), a[n + 1] = INF, sort(w + 1, w + m + 1);\\n  for (int i = 1, j = 1; i <= m; ++i) {\\n    while (j <= n && a[j] < w[i].l) ++j;\\n    if (a[j] >= w[i].l && a[j] <= w[i].r) ck[i] = 1;\\n  }\\n  t = 0;\\n  for (int i = 1; i <= m; ++i)\\n    if (!ck[i]) {\\n      while (t && s[t].r >= w[i].r) --t;\\n      s[++t] = w[i];\\n    }\\n  int j = 1;\\n  while (j <= t && s[j].r < a[1]) ++j;\\n  int mr = a[1];\\n  for (int i = 1; i < j; ++i) mr = min(mr, s[i].r);\\n  --j;\\n  for (int i = 1, l = j; i <= n; ++i) {\\n    while (j < t && s[j + 1].r < a[i + 1]) ++j;\\n    sz[i] = j - l, f[i] = fpool + o, d[i] = dpool + o, g[i] = gpool + o;\\n    pre[i] = ppool + o, suf[i] = spool + o, o += sz[i] + 1;\\n    for (int k = 1; k <= sz[i]; ++k) d[i][k] = s[l + k].l - a[i];\\n    int nr = a[i + 1];\\n    for (int k = sz[i]; ~k; --k)\\n      g[i][k] = a[i + 1] - nr, nr = min(nr, s[l + k].r);\\n    l = j;\\n  }\\n  for (int i = 0; i <= sz[1]; ++i)\\n    f[1][i] = 0ll + 2 * min(a[1] - mr, d[1][i]) + max(a[1] - mr, d[1][i]);\\n  pre[1][0] = f[1][0] + g[1][0];\\n  for (int i = 1; i <= sz[1]; ++i)\\n    pre[1][i] = min(pre[1][i - 1], f[1][i] + g[1][i]);\\n  suf[1][sz[1]] = f[1][sz[1]] + 2 * g[1][sz[1]];\\n  for (int i = sz[1] -...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CQXYM wants to create a connected undirected graph with n nodes and m edges, and the diameter of the graph must be strictly less than k-1. Also, CQXYM doesn't want a graph that contains self-loops or multiple edges (i.e. each edge connects two different vertices and between each pair of vertices there is at most one edge).\\n\\nThe diameter of a graph is the maximum distance between any two nodes.\\n\\nThe distance between two nodes is the minimum number of the edges on the path which endpoints are the two nodes.\\n\\nCQXYM wonders whether it is possible to create such a graph.\\n\\nInput\\n\\nThe input consists of multiple test cases. \\n\\nThe first line contains an integer t (1 \u2264 t \u2264 10^5) \u2014 the number of test cases. The description of the test cases follows.\\n\\nOnly one line of each test case contains three integers n(1 \u2264 n \u2264 10^9), m, k (0 \u2264 m,k \u2264 10^9).\\n\\nOutput\\n\\nFor each test case, print YES if it is possible to create the graph, or print NO if it is impossible. You can print each letter in any case (upper or lower).\\n\\nExample\\n\\nInput\\n\\n\\n5\\n1 0 3\\n4 5 3\\n4 6 3\\n5 4 1\\n2 1 1\\n\\n\\nOutput\\n\\n\\nYES\\nNO\\nYES\\nNO\\nNO\\n\\nNote\\n\\nIn the first test case, the graph's diameter equal to 0.\\n\\nIn the second test case, the graph's diameter can only be 2.\\n\\nIn the third test case, the graph's diameter can only be 1.\\nSolve the task in JAVA.\",\"targets\":\"import java.util.*;\\nimport java.lang.*;\\nimport java.io.*;\\nimport java.awt.*;\\n\\n\\/*AUTHOR - SHIVAM GUPTA *\\/\\n\\n\\/\\/ U KNOW THAT IF THIS DAY WILL BE URS THEN NO ONE CAN DEFEAT U HERE ,JUst keep faith in ur strengths .................................................. \\n\\/\\/ ASCII = 48 + i ;\\/\\/ 2^28 = 268,435,456  > 2* 10^8 \\/\\/ log 10 base 2 = 3.3219 \\n\\/\\/ odd:: (x^2+1)\\/2 , (x^2-1)\\/2 ; x>=3\\/\\/ even:: (x^2\\/4)+1 ,(x^2\\/4)-1  x >=4 \\n\\/\\/ FOR ANY ODD NO N : N,N-1,N-2,ALL ARE PAIRWISE COPRIME,THEIR COMBINED LCM IS PRODUCT OF ALL THESE NOS\\n\\/\\/ two consecutive odds are always coprime to each other, two consecutive even have always gcd  = 2 ;\\n\\n\\/\\/ Rectangle r = new Rectangle(int x , int y,int widht,int height) \\n\\/\\/Creates a rect. with bottom left cordinates as (x, y) and top right as ((x+width),(y+height))\\n\\n\\/\\/BY DEFAULT Priority Queue is MIN in nature in java\\n\\/\\/to use as max , just push with negative sign and change sign after removal \\n\\n\\/\\/ We can make a sieve of max size 1e7 .(no time or space issue) \\n\\/\\/ In 1e7 starting nos we have about 66*1e4 prime nos\\n\\/\\/ In 1e6 starting nos we have about 78,498 prime nos\\n\\n public class Main\\n \\/\\/public class Solution\\n{\\n    static PrintWriter out;\\n    \\n\\tstatic class FastReader{\\n\\t\\tBufferedReader br;\\n\\t\\tStringTokenizer st;\\n\\t\\tpublic FastReader(){\\n\\t\\t\\tbr=new BufferedReader(new InputStreamReader(System.in));\\n\\t\\t\\tout=new PrintWriter(System.out);\\n\\t\\t}\\n\\t\\tString next(){\\n\\t\\t\\twhile(st==null || !st.hasMoreElements()){\\n\\t\\t\\t\\ttry{\\n\\t\\t\\t\\t\\tst= new StringTokenizer(br.readLine());\\n\\t\\t\\t\\t}\\n\\t\\t\\t\\tcatch (IOException e){\\n\\t\\t\\t\\t\\te.printStackTrace();\\n\\t\\t\\t\\t}\\n\\t\\t\\t}\\n\\t\\t\\treturn st.nextToken();\\n\\t\\t}\\n\\t\\tint nextInt(){\\n\\t\\t\\treturn Integer.parseInt(next());\\n\\t\\t}\\n\\t\\tlong nextLong(){\\n\\t\\t\\treturn Long.parseLong(next());\\n\\t\\t}\\n\\t\\tdouble nextDouble(){\\n\\t\\t\\treturn Double.parseDouble(next());\\n\\t\\t}\\n\\t\\tString nextLine(){\\n\\t\\t\\tString str = \\\"\\\";\\n\\t\\t\\ttry{\\n\\t\\t\\t\\tstr=br.readLine();\\n\\t\\t\\t}\\n\\t\\t\\tcatch(IOException e){\\n\\t\\t\\t\\te.printStackTrace();\\n\\t\\t\\t}\\n\\t\\t\\treturn str;\\n\\t\\t}\\n\\t}\\n\\t\\n\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\n public static int...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Count the number of distinct sequences a1, a2, ..., an (1 \u2264 ai) consisting of positive integers such that gcd(a1, a2, ..., an) = x and <image>. As this number could be large, print the answer modulo 109 + 7.\\n\\ngcd here means the [greatest common divisor](https:\\/\\/en.wikipedia.org\\/wiki\\/Greatest_common_divisor).\\n\\nInput\\n\\nThe only line contains two positive integers x and y (1 \u2264 x, y \u2264 109).\\n\\nOutput\\n\\nPrint the number of such sequences modulo 109 + 7.\\n\\nExamples\\n\\nInput\\n\\n3 9\\n\\n\\nOutput\\n\\n3\\n\\n\\nInput\\n\\n5 8\\n\\n\\nOutput\\n\\n0\\n\\nNote\\n\\nThere are three suitable sequences in the first test: (3, 3, 3), (3, 6), (6, 3).\\n\\nThere are no suitable sequences in the second test.\\nSolve the task in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nvector<int> v;\\nmap<int, long long> dp;\\nlong long power(int a, long long b) {\\n  long long res = 1, base = a;\\n  while (b > 0) {\\n    if (b % 2) {\\n      res *= base;\\n      res %= (1000 * 1000 * 1000 + 7);\\n    }\\n    base *= base;\\n    base %= (1000 * 1000 * 1000 + 7);\\n    b \\/= 2;\\n  }\\n  return res;\\n}\\nlong long compute(int g) {\\n  if (g == 1) {\\n    return 1;\\n  }\\n  if (dp.find(g) != dp.end()) {\\n    return dp[g];\\n  }\\n  long long val = power(2, g - 1);\\n  int i;\\n  for (i = 0; i < v.size(); i++) {\\n    if (v[i] >= g) {\\n      break;\\n    }\\n    if (g % v[i] == 0) val -= compute(v[i]);\\n  }\\n  dp[g] = val;\\n  dp[g] %= (1000 * 1000 * 1000 + 7);\\n  dp[g] += (1000 * 1000 * 1000 + 7);\\n  dp[g] %= (1000 * 1000 * 1000 + 7);\\n  return dp[g];\\n}\\nint main() {\\n  std::ios::sync_with_stdio(false);\\n  int x, y, val1, i;\\n  cin >> x >> y;\\n  if (y % x) {\\n    cout << 0 << endl;\\n  } else {\\n    y \\/= x;\\n    for (i = 1; i * i <= y; i++) {\\n      if (y % i == 0) {\\n        v.push_back(i);\\n        if (y \\/ i != i) v.push_back(y \\/ i);\\n      }\\n    }\\n    sort(v.begin(), v.end());\\n    cout << compute(y);\\n  }\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Berland has n cities connected by m bidirectional roads. No road connects a city to itself, and each pair of cities is connected by no more than one road. It is not guaranteed that you can get from any city to any other one, using only the existing roads.\\n\\nThe President of Berland decided to make changes to the road system and instructed the Ministry of Transport to make this reform. Now, each road should be unidirectional (only lead from one city to another).\\n\\nIn order not to cause great resentment among residents, the reform needs to be conducted so that there can be as few separate cities as possible. A city is considered separate, if no road leads into it, while it is allowed to have roads leading from this city.\\n\\nHelp the Ministry of Transport to find the minimum possible number of separate cities after the reform.\\n\\nInput\\n\\nThe first line of the input contains two positive integers, n and m \u2014 the number of the cities and the number of roads in Berland (2 \u2264 n \u2264 100 000, 1 \u2264 m \u2264 100 000). \\n\\nNext m lines contain the descriptions of the roads: the i-th road is determined by two distinct integers xi, yi (1 \u2264 xi, yi \u2264 n, xi \u2260 yi), where xi and yi are the numbers of the cities connected by the i-th road.\\n\\nIt is guaranteed that there is no more than one road between each pair of cities, but it is not guaranteed that from any city you can get to any other one, using only roads.\\n\\nOutput\\n\\nPrint a single integer \u2014 the minimum number of separated cities after the reform.\\n\\nExamples\\n\\nInput\\n\\n4 3\\n2 1\\n1 3\\n4 3\\n\\n\\nOutput\\n\\n1\\n\\n\\nInput\\n\\n5 5\\n2 1\\n1 3\\n2 3\\n2 5\\n4 3\\n\\n\\nOutput\\n\\n0\\n\\n\\nInput\\n\\n6 5\\n1 2\\n2 3\\n4 5\\n4 6\\n5 6\\n\\n\\nOutput\\n\\n1\\n\\nNote\\n\\nIn the first sample the following road orientation is allowed: <image>, <image>, <image>.\\n\\nThe second sample: <image>, <image>, <image>, <image>, <image>.\\n\\nThe third sample: <image>, <image>, <image>, <image>, <image>.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst int N = 100111;\\nint n, m;\\nint p[N][2];\\nint cnt[N];\\nint main() {\\n  int i;\\n  while (scanf(\\\"%d%d\\\", &n, &m) != EOF) {\\n    memset(cnt, 0, sizeof(cnt));\\n    for (i = 1; i <= m; i++) {\\n      scanf(\\\"%d%d\\\", &p[i][0], &p[i][1]);\\n      cnt[p[i][0]]++;\\n      cnt[p[i][1]]++;\\n    }\\n    int ans = 0;\\n    bool flag = false;\\n    for (i = 1; i <= n; i++) {\\n      if (!cnt[i]) ans++;\\n      if (cnt[i] == 1) flag = true;\\n    }\\n    while (flag) {\\n      flag = false;\\n      for (i = 1; i <= m; i++) {\\n        if (p[i][0]) {\\n          if (cnt[p[i][0]] == 1) {\\n            cnt[p[i][1]]--;\\n            if (cnt[p[i][1]] == 1) flag = true;\\n            if (cnt[p[i][1]] == 0) ans++;\\n            p[i][0] = 0;\\n            continue;\\n          }\\n          if (cnt[p[i][1]] == 1) {\\n            cnt[p[i][0]]--;\\n            if (cnt[p[i][0]] == 1) flag = true;\\n            if (cnt[p[i][0]] == 0) ans++;\\n            p[i][0] = 0;\\n            continue;\\n          }\\n        }\\n      }\\n    }\\n    printf(\\\"%d\\\\n\\\", ans);\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in PYTHON3?\\nLord Omkar would like to have a tree with n nodes (3 \u2264 n \u2264 10^5) and has asked his disciples to construct the tree. However, Lord Omkar has created m (1 \u2264 m < n) restrictions to ensure that the tree will be as heavenly as possible. \\n\\nA tree with n nodes is an connected undirected graph with n nodes and n-1 edges. Note that for any two nodes, there is exactly one simple path between them, where a simple path is a path between two nodes that does not contain any node more than once.\\n\\nHere is an example of a tree: \\n\\n<image>\\n\\nA restriction consists of 3 pairwise distinct integers, a, b, and c (1 \u2264 a,b,c \u2264 n). It signifies that node b cannot lie on the simple path between node a and node c. \\n\\nCan you help Lord Omkar and become his most trusted disciple? You will need to find heavenly trees for multiple sets of restrictions. It can be shown that a heavenly tree will always exist for any set of restrictions under the given constraints.\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 10^4). Description of the test cases follows.\\n\\nThe first line of each test case contains two integers, n and m (3 \u2264 n \u2264 10^5, 1 \u2264 m < n), representing the size of the tree and the number of restrictions.\\n\\nThe i-th of the next m lines contains three integers a_i, b_i, c_i (1 \u2264 a_i, b_i, c_i \u2264 n, a, b, c are distinct), signifying that node b_i cannot lie on the simple path between nodes a_i and c_i. \\n\\nIt is guaranteed that the sum of n across all test cases will not exceed 10^5.\\n\\nOutput\\n\\nFor each test case, output n-1 lines representing the n-1 edges in the tree. On each line, output two integers u and v (1 \u2264 u, v \u2264 n, u \u2260 v) signifying that there is an edge between nodes u and v. Given edges have to form a tree that satisfies Omkar's restrictions.\\n\\nExample\\n\\nInput\\n\\n\\n2\\n7 4\\n1 2 3\\n3 4 5\\n5 6 7\\n6 5 4\\n5 3\\n1 2 3\\n2 3 4\\n3 4 5\\n\\n\\nOutput\\n\\n\\n1 2\\n1 3\\n3 5\\n3 4\\n2 7\\n7 6\\n5 1\\n1 3\\n3 2\\n2 4\\n\\nNote\\n\\nThe output of the first sample case corresponds to the following tree: \\n\\n<image> For the first restriction,...\",\"targets\":\"import sys\\n\\n\\ninp = sys.stdin.readline\\n\\n\\ndef solve():\\n    n, m = map(int, inp().split())\\n    d = [0] * (n + 1)\\n    for i in range(m):\\n        a, b, c = map(int, inp().split())\\n        d[b] += 1\\n    for i in range(1, n + 1):\\n        if d[i] == 0:\\n            print('\\\\n'.join(f'{j} {i}' for j in range(1, n + 1) if j != i))\\n            return\\n    raise Exception('wut')\\n\\n\\ndef main():\\n    for i in range(int(inp())):\\n        solve()\\n\\n\\nif __name__ == '__main__':\\n    main()\",\"language\":\"python\",\"split\":\"test\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You are given three integers n, a, b. Determine if there exists a permutation p_1, p_2, \u2026, p_n of integers from 1 to n, such that:\\n\\n  * There are exactly a integers i with 2 \u2264 i \u2264 n-1 such that p_{i-1} < p_i > p_{i+1} (in other words, there are exactly a local maximums).\\n\\n  * There are exactly b integers i with 2 \u2264 i \u2264 n-1 such that p_{i-1} > p_i < p_{i+1} (in other words, there are exactly b local minimums).\\n\\n\\n\\n\\nIf such permutations exist, find any such permutation.\\n\\nInput\\n\\nThe first line of the input contains a single integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases. The description of test cases follows.\\n\\nThe only line of each test case contains three integers n, a and b (2 \u2264 n \u2264 10^5, 0 \u2264 a,b \u2264 n).\\n\\nThe sum of n over all test cases doesn't exceed 10^5.\\n\\nOutput\\n\\nFor each test case, if there is no permutation with the requested properties, output -1.\\n\\nOtherwise, print the permutation that you are found. If there are several such permutations, you may print any of them.\\n\\nExample\\n\\nInput\\n\\n\\n3\\n4 1 1\\n6 1 2\\n6 4 0\\n\\n\\nOutput\\n\\n\\n1 3 2 4\\n4 2 3 1 5 6\\n-1\\n\\nNote\\n\\nIn the first test case, one example of such permutations is [1, 3, 2, 4]. In it p_1 < p_2 > p_3, and 2 is the only such index, and p_2> p_3 < p_4, and 3 the only such index.\\n\\nOne can show that there is no such permutation for the third test case.\\nThe above is tricky. Write me a correct solution in JAVA.\",\"targets\":\"import java.io.*;\\nimport java.math.BigInteger;\\nimport java.util.*;\\nimport static java.lang.Math.PI;\\nimport static java.lang.System.in;\\nimport static java.lang.System.out;\\nimport static java.lang.System.err;\\n\\npublic class B {    \\n\\n    static int what(ArrayList<Integer> arr, int min, int max) {\\n        int mina = 0, maxa = 0;\\n        for(int i = 1; i < arr.size()-1; i++) {\\n            int prev = arr.get(i-1);\\n            int cur = arr.get(i);\\n            int next = arr.get(i+1);\\n            if(prev > cur && cur < next)    mina++;\\n            if(prev < cur && cur > next)    maxa++;\\n        }\\n        \\/\\/ out.println(arr);\\n        \\/\\/ out.println(maxa + \\\" \\\" + mina);\\n        if(mina==min && maxa==max)  return 1;\\n        return 0;\\n    }\\n    public static void main(String[] args) throws Exception {   \\n        Foster sc = new Foster();\\n        PrintWriter p = new PrintWriter(out);\\n\\n       \\/*\\n        * Is that extra condition needed\\n        * Check overflow in pow function or in general\\n        * Check indices of read array functions\\n        * Think of an easier solution because the problems you solve are always easy\\n        * Check the iterator of loop\\n        *\\/   \\n\\n        int t = sc.nextInt();\\n        while(t--!=0) {\\n            int n = sc.nextInt(), b = sc.nextInt(), a = sc.nextInt();\\n            int min = a, max = b;\\n            \\/\\/ if(a+b+2 > n) {\\n            \\/\\/     p.println(\\\"-1\\\");\\n            \\/\\/     continue;\\n            \\/\\/ }\\n            \\/\\/ if(Math.abs(a-b) > 1) {\\n            \\/\\/     p.println(\\\"-1\\\");\\n            \\/\\/     continue;\\n            \\/\\/ }\\n            \\/\\/ if(a==b && n%2!=0) {\\n            \\/\\/     p.println(\\\"-1\\\");\\n            \\/\\/     continue;\\n            \\/\\/ }\\n            if(a==0 && b==0) {\\n                for(int i = 1; i <= n; i++) {\\n                    p.print(i + \\\" \\\");\\n                }\\n                p.println();\\n                continue;\\n            }\\n            ArrayList<Integer> arr = new ArrayList<>();\\n            int L = 1, H = n;\\n            if(a==b) {\\n                arr.add(L);\\n               ...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You are given two strings s and t, both consisting of lowercase English letters. You are going to type the string s character by character, from the first character to the last one.\\n\\nWhen typing a character, instead of pressing the button corresponding to it, you can press the \\\"Backspace\\\" button. It deletes the last character you have typed among those that aren't deleted yet (or does nothing if there are no characters in the current string). For example, if s is \\\"abcbd\\\" and you press Backspace instead of typing the first and the fourth characters, you will get the string \\\"bd\\\" (the first press of Backspace deletes no character, and the second press deletes the character 'c'). Another example, if s is \\\"abcaa\\\" and you press Backspace instead of the last two letters, then the resulting text is \\\"a\\\".\\n\\nYour task is to determine whether you can obtain the string t, if you type the string s and press \\\"Backspace\\\" instead of typing several (maybe zero) characters of s.\\n\\nInput\\n\\nThe first line contains a single integer q (1 \u2264 q \u2264 10^5) \u2014 the number of test cases.\\n\\nThe first line of each test case contains the string s (1 \u2264 |s| \u2264 10^5). Each character of s is a lowercase English letter.\\n\\nThe second line of each test case contains the string t (1 \u2264 |t| \u2264 10^5). Each character of t is a lowercase English letter.\\n\\nIt is guaranteed that the total number of characters in the strings over all test cases does not exceed 2 \u22c5 10^5.\\n\\nOutput\\n\\nFor each test case, print \\\"YES\\\" if you can obtain the string t by typing the string s and replacing some characters with presses of \\\"Backspace\\\" button, or \\\"NO\\\" if you cannot.\\n\\nYou may print each letter in any case (YES, yes, Yes will all be recognized as positive answer, NO, no and nO will all be recognized as negative answer).\\n\\nExample\\n\\nInput\\n\\n\\n4\\nababa\\nba\\nababa\\nbb\\naaa\\naaaa\\naababa\\nababa\\n\\n\\nOutput\\n\\n\\nYES\\nNO\\nNO\\nYES\\n\\nNote\\n\\nConsider the example test from the statement.\\n\\nIn order to obtain \\\"ba\\\" from \\\"ababa\\\", you may press Backspace instead of typing the first and the fourth characters.\\n\\nThere's no way...\\nThe above is tricky. Write me a correct solution in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nvoid _print(int t) { cerr << t; }\\nvoid _print(string t) { cerr << t; }\\nvoid _print(char t) { cerr << t; }\\nvoid _print(long double t) { cerr << t; }\\nvoid _print(double t) { cerr << t; }\\nvoid _print(unsigned long long t) { cerr << t; }\\ntemplate <class T, class V>\\nvoid _print(pair<T, V> p);\\ntemplate <class T>\\nvoid _print(vector<T> v);\\ntemplate <class T>\\nvoid _print(set<T> v);\\ntemplate <class T, class V>\\nvoid _print(map<T, V> v);\\ntemplate <class T>\\nvoid _print(multiset<T> v);\\ntemplate <class T, class V>\\nvoid _print(pair<T, V> p) {\\n  cerr << \\\"{\\\";\\n  _print(p.first);\\n  cerr << \\\",\\\";\\n  _print(p.second);\\n  cerr << \\\"}\\\";\\n}\\ntemplate <class T>\\nvoid _print(vector<T> v) {\\n  cerr << \\\"[ \\\";\\n  for (T i : v) {\\n    _print(i);\\n    cerr << \\\" \\\";\\n  }\\n  cerr << \\\"]\\\";\\n}\\ntemplate <class T>\\nvoid _print(set<T> v) {\\n  cerr << \\\"[ \\\";\\n  for (T i : v) {\\n    _print(i);\\n    cerr << \\\" \\\";\\n  }\\n  cerr << \\\"]\\\";\\n}\\ntemplate <class T>\\nvoid _print(multiset<T> v) {\\n  cerr << \\\"[ \\\";\\n  for (T i : v) {\\n    _print(i);\\n    cerr << \\\" \\\";\\n  }\\n  cerr << \\\"]\\\";\\n}\\ntemplate <class T, class V>\\nvoid _print(map<T, V> v) {\\n  cerr << \\\"[ \\\";\\n  for (auto i : v) {\\n    _print(i);\\n    cerr << \\\" \\\";\\n  }\\n  cerr << \\\"]\\\";\\n}\\nvoid init_code() {\\n  ios::sync_with_stdio(0);\\n  cin.tie(0);\\n  cout.tie(0);\\n}\\nvoid solve() {\\n  string a;\\n  string b;\\n  cin >> a >> b;\\n  string ans;\\n  int n = ((int)(a).size());\\n  int n1 = ((int)(b).size());\\n  int j = n1 - 1;\\n  int flag = 0;\\n  int i = n - 1;\\n  while (i >= 0) {\\n    if (a[i] == b[j]) {\\n      i--;\\n      j--;\\n    } else {\\n      i -= 2;\\n    }\\n    if (j == -1) {\\n      flag = 1;\\n      break;\\n    }\\n  }\\n  if (flag)\\n    cout << \\\"YES\\\";\\n  else\\n    cout << \\\"NO\\\";\\n  cout << \\\"\\\\n\\\";\\n}\\nsigned main() {\\n  init_code();\\n  long long t = 1;\\n  cin >> t;\\n  while (t--) {\\n    solve();\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"Consider sets of natural numbers. Some sets can be sorted in the same order numerically and lexicographically. {2, 27, 3125, 9000} is one example of such sets; {2, 27, 243} is not since lexicographic sorting would yield {2, 243, 27}.\\n\\nYour task is to write a program that, for the set of integers in a given range [A,B] (i.e. between A and B inclusive), counts the number of non-empty subsets satisfying the above property. Since the resulting number is expected to be very huge, your program should output the number in modulo P given as the input.\\n\\n\\n\\nInput\\n\\nThe input consists of multiple datasets. Each dataset consists of a line with three integers A, B, and P separated by a space. These numbers satisfy the following conditions: 1 \u2264 A \u2264 1,000,000,000, 0 \u2264 B - A < 100,000, 1 \u2264 P \u2264 1,000,000,000.\\n\\nThe end of input is indicated by a line with three zeros.\\n\\nOutput\\n\\nFor each dataset, output the number of the subsets in modulo P.\\n\\nExample\\n\\nInput\\n\\n1 10 1000\\n1 100000 1000000000\\n999999999 1000099998 1000000000\\n0 0 0\\n\\n\\nOutput\\n\\n513\\n899507743\\n941554688\\\":\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\n\\ntypedef long long ll;\\ntypedef unsigned long long ull;\\ntypedef pair<string, ll> P;\\n\\n#define fi first\\n#define se second\\n#define repl(i,a,b) for(ll i=(ll)(a);i<(ll)(b);i++)\\n#define rep(i,n) repl(i,0,n)\\n#define each(itr,v) for(auto itr:v)\\n#define pb push_back\\n#define all(x) (x).begin(),(x).end()\\n#define dbg(x) cout<<#x\\\"=\\\"<<x<<endl\\n#define mmax(x,y) (x>y?x:y)\\n#define mmin(x,y) (x<y?x:y)\\n#define maxch(x,y) x=mmax(x,y)\\n#define minch(x,y) x=mmin(x,y)\\n#define uni(x) x.erase(unique(all(x)),x.end())\\n#define exist(x,y) (find(all(x),y)!=x.end())\\n#define bcnt __builtin_popcount\\n\\n#define INF INT_MAX\\/3\\n#define MAX_N 100010\\n\\nll p;\\n\\nstruct BIT{\\n  ll bit[MAX_N];\\n\\n  void init(){\\n    memset(bit,0,sizeof(bit));\\n  }\\n\\n  ll sum(int i){\\n    ll s=0;\\n    while(i>0){\\n      s=(s+bit[i])%p;\\n      i-=i&-i;\\n    }\\n    return s;\\n  }\\n\\n  void add(int i,ll v){\\n    while(i<=MAX_N){\\n      bit[i]=(bit[i]+v)%p;\\n      i+=i&-i;\\n    }\\n  }\\n};\\n\\nll a,b,n;\\nll idx[100010];\\n\\nint main(){\\n\\tcin.sync_with_stdio(false);\\n  while(1){\\n    cin>>a>>b>>p;\\n    if(a==0&&b==0&&p==0)break;\\n    vector<P> ss;\\n    n=b-a+1;\\n    ss.resize(n);\\n    rep(i,n){\\n      ss[i]=P(to_string(i+a),i);\\n    }\\n    sort(all(ss));\\n    rep(i,n){\\n      idx[ss[i].se]=i;\\n    }\\n    BIT dp;\\n    dp.init();\\n    rep(i,n){\\n      ll tmp=dp.sum(idx[i]+1)%p;\\n      dp.add(idx[i]+1,(tmp+1)%p);\\n    }\\n    cout<<dp.sum(n+1)%p<<endl;\\n  }\\n\\treturn 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"As Sherlock Holmes was investigating a crime, he identified n suspects. He knows for sure that exactly one of them committed the crime. To find out which one did it, the detective lines up the suspects and numbered them from 1 to n. After that, he asked each one: \\\"Which one committed the crime?\\\". Suspect number i answered either \\\"The crime was committed by suspect number ai\\\", or \\\"Suspect number ai didn't commit the crime\\\". Also, the suspect could say so about himself (ai = i).\\n\\nSherlock Holmes understood for sure that exactly m answers were the truth and all other answers were a lie. Now help him understand this: which suspect lied and which one told the truth?\\n\\nInput\\n\\nThe first line contains two integers n and m (1 \u2264 n \u2264 105, 0 \u2264 m \u2264 n) \u2014 the total number of suspects and the number of suspects who told the truth. Next n lines contain the suspects' answers. The i-th line contains either \\\"+ai\\\" (without the quotes), if the suspect number i says that the crime was committed by suspect number ai, or \\\"-ai\\\" (without the quotes), if the suspect number i says that the suspect number ai didn't commit the crime (ai is an integer, 1 \u2264 ai \u2264 n).\\n\\nIt is guaranteed that at least one suspect exists, such that if he committed the crime, then exactly m people told the truth.\\n\\nOutput\\n\\nPrint n lines. Line number i should contain \\\"Truth\\\" if suspect number i has told the truth for sure. Print \\\"Lie\\\" if the suspect number i lied for sure and print \\\"Not defined\\\" if he could lie and could tell the truth, too, depending on who committed the crime.\\n\\nExamples\\n\\nInput\\n\\n1 1\\n+1\\n\\n\\nOutput\\n\\nTruth\\n\\n\\nInput\\n\\n3 2\\n-1\\n-2\\n-3\\n\\n\\nOutput\\n\\nNot defined\\nNot defined\\nNot defined\\n\\n\\nInput\\n\\n4 1\\n+2\\n-3\\n+4\\n-1\\n\\n\\nOutput\\n\\nLie\\nNot defined\\nLie\\nNot defined\\n\\nNote\\n\\nThe first sample has the single person and he confesses to the crime, and Sherlock Holmes knows that one person is telling the truth. That means that this person is telling the truth.\\n\\nIn the second sample there are three suspects and each one denies his guilt. Sherlock Holmes knows that only two of them are...\\nSolve the task in JAVA.\",\"targets\":\"import java.util.*;\\nimport java.io.*;\\n\\npublic class Solution implements Runnable {\\n\\n    final static int INF = 1000000000;\\n\\n    final static String TRUTH = \\\"Truth\\\";\\n    final static String LIE = \\\"Lie\\\";\\n    final static String UND = \\\"Not defined\\\";\\n\\n    public void run() {\\n        try {\\n            in = new BufferedReader(new InputStreamReader(System.in));\\n            st = new StringTokenizer(\\\"\\\");\\n            int n = nextInt();\\n            int m = nextInt();\\n            boolean[] neg = new boolean[n];\\n            int[] target = new int[n];\\n            int[] crimeLies = new int[n];\\n            int[] crimeTruths = new int[n];\\n            int notCrimeTruths = 0;\\n            for (int i = 0; i < n; i++) {\\n                String s = next();\\n                if (s.charAt(0) == '+')\\n                    s = s.substring(1, s.length());\\n                int val = Integer.parseInt(s);\\n                neg[i] = val < 0;\\n                target[i] = Math.abs(val) - 1;\\n                if (neg[i]) {\\n                    crimeLies[target[i]] ++;\\n                    notCrimeTruths ++;\\n                } else {\\n                    crimeTruths[target[i]] ++;\\n                }\\n            }\\n            boolean[] canCrime = new boolean[n];\\n            int canCrimes = 0;\\n            for (int i = 0; i < n; i++) {\\n                canCrime[i] = notCrimeTruths - crimeLies[i] + crimeTruths[i] == m;\\n                if (canCrime[i])\\n                    canCrimes ++;\\n            }\\n            PrintWriter out = new PrintWriter(System.out);\\n            for (int i = 0; i < n; i++) {\\n                int ti = target[i];\\n                if (!canCrime[ti]) {\\n                    out.println(neg[i] ? TRUTH : LIE);\\n                } else if (canCrimes > 1) {\\n                    out.println(UND);\\n                } else {\\n                    out.println(neg[i] ? LIE : TRUTH);\\n                }\\n            }\\n            out.flush();\\n        } catch (Exception ex) {\\n            ex.printStackTrace();\\n            System.exit(-1);\\n        }\\n    }\\n\\n    void...\",\"language\":\"python\",\"split\":\"train\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in CPP?\\nAlice and Bob are playing a game on a matrix, consisting of 2 rows and m columns. The cell in the i-th row in the j-th column contains a_{i, j} coins in it.\\n\\nInitially, both Alice and Bob are standing in a cell (1, 1). They are going to perform a sequence of moves to reach a cell (2, m).\\n\\nThe possible moves are: \\n\\n  * Move right \u2014 from some cell (x, y) to (x, y + 1); \\n  * Move down \u2014 from some cell (x, y) to (x + 1, y). \\n\\n\\n\\nFirst, Alice makes all her moves until she reaches (2, m). She collects the coins in all cells she visit (including the starting cell).\\n\\nWhen Alice finishes, Bob starts his journey. He also performs the moves to reach (2, m) and collects the coins in all cells that he visited, but Alice didn't.\\n\\nThe score of the game is the total number of coins Bob collects.\\n\\nAlice wants to minimize the score. Bob wants to maximize the score. What will the score of the game be if both players play optimally?\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 10^4) \u2014 the number of testcases.\\n\\nThen the descriptions of t testcases follow.\\n\\nThe first line of the testcase contains a single integer m (1 \u2264 m \u2264 10^5) \u2014 the number of columns of the matrix.\\n\\nThe i-th of the next 2 lines contain m integers a_{i,1}, a_{i,2}, ..., a_{i,m} (1 \u2264 a_{i,j} \u2264 10^4) \u2014 the number of coins in the cell in the i-th row in the j-th column of the matrix.\\n\\nThe sum of m over all testcases doesn't exceed 10^5.\\n\\nOutput\\n\\nFor each testcase print a single integer \u2014 the score of the game if both players play optimally.\\n\\nExample\\n\\nInput\\n\\n\\n3\\n3\\n1 3 7\\n3 5 1\\n3\\n1 3 9\\n3 5 1\\n1\\n4\\n7\\n\\n\\nOutput\\n\\n\\n7\\n8\\n0\\n\\nNote\\n\\nThe paths for the testcases are shown on the following pictures. Alice's path is depicted in red and Bob's path is depicted in blue.\\n\\n<image>\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\ntemplate <class c>\\nstruct rge {\\n  c b, e;\\n};\\ntemplate <class c>\\nrge<c> range(c i, c j) {\\n  return rge<c>{i, j};\\n}\\ntemplate <class c>\\nauto dud(c* x) -> decltype(cerr << *x, 0);\\ntemplate <class c>\\nchar dud(...);\\nstruct debug {\\n  template <class c>\\n  debug& operator<<(const c&) {\\n    return *this;\\n  }\\n};\\ntemplate <typename T>\\nvoid read(T& x) {\\n  cin >> x;\\n}\\ntemplate <typename T, typename U>\\nvoid read(T& x, U& y) {\\n  cin >> x >> y;\\n}\\ntemplate <typename T>\\nvoid read(vector<T>& a) {\\n  for (T& x : a) read(x);\\n}\\ntemplate <typename T>\\nT cd(T u, T v) {\\n  return (u + v - 1) \\/ v;\\n}\\nvoid solve() {\\n  long long n;\\n  read(n);\\n  if (n == 1) {\\n    long long a, b;\\n    read(a, b);\\n    cout << \\\"0\\\\n\\\";\\n    return;\\n  }\\n  vector<vector<long long>> a(2, vector<long long>(n));\\n  read(a[0]);\\n  read(a[1]);\\n  partial_sum(a[0].rbegin(), a[0].rend(), a[0].rbegin());\\n  partial_sum(a[1].begin(), a[1].end(), a[1].begin());\\n  long long ans = 1e18;\\n  for (long long i = 0; i < n; i++) {\\n    if (i == 0) {\\n      ans = min(ans, a[0][i + 1]);\\n    } else if (i == n - 1) {\\n      ans = min(ans, a[1][i - 1]);\\n    } else {\\n      ans = min(ans, max(a[0][i + 1], a[1][i - 1]));\\n    }\\n  }\\n  cout << ans << \\\"\\\\n\\\";\\n}\\nint32_t main() {\\n  ios_base::sync_with_stdio(false);\\n  cin.tie(NULL);\\n  long long t = 1;\\n  read(t);\\n  for (long long testcase = 1; testcase <= t; testcase++) {\\n    solve();\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Casimir has a string s which consists of capital Latin letters 'A', 'B', and 'C' only. Each turn he can choose to do one of the two following actions:\\n\\n  * he can either erase exactly one letter 'A' and exactly one letter 'B' from arbitrary places of the string (these letters don't have to be adjacent); \\n  * or he can erase exactly one letter 'B' and exactly one letter 'C' from arbitrary places in the string (these letters don't have to be adjacent). \\n\\n\\n\\nTherefore, each turn the length of the string is decreased exactly by 2. All turns are independent so for each turn, Casimir can choose any of two possible actions.\\n\\nFor example, with s = \\\"ABCABC\\\" he can obtain a string s = \\\"ACBC\\\" in one turn (by erasing the first occurrence of 'B' and the second occurrence of 'A'). There are also many other options for a turn aside from this particular example.\\n\\nFor a given string s determine whether there is a sequence of actions leading to an empty string. In other words, Casimir's goal is to erase all letters from the string. Is there a way to do this?\\n\\nInput\\n\\nThe first line contains an integer t (1 \u2264 t \u2264 1000) \u2014 the number of test cases.\\n\\nEach test case is described by one string s, for which you need to determine if it can be fully erased by some sequence of turns. The string s consists of capital letters 'A', 'B', 'C' and has a length from 1 to 50 letters, inclusive.\\n\\nOutput\\n\\nPrint t lines, each line containing the answer to the corresponding test case. The answer to a test case should be YES if there is a way to fully erase the corresponding string and NO otherwise.\\n\\nYou may print every letter in any case you want (so, for example, the strings yEs, yes, Yes, and YES will all be recognized as positive answers).\\n\\nExample\\n\\nInput\\n\\n\\n6\\nABACAB\\nABBA\\nAC\\nABC\\nCABCBB\\nBCBCBCBCBCBCBCBC\\n\\n\\nOutput\\n\\n\\nNO\\nYES\\nNO\\nNO\\nYES\\nYES\\nt = i\",\"targets\":\"nt(input())\\nfor l in range(t):\\n    s = input()\\n    ch = s\\n    i = 0\\n    a = 0\\n    b = 0\\n    c = 0\\n    j = (len(ch))\\n\\n    for i in range (j):\\n        if (ch[i]==\\\"A\\\"):\\n            a+=1\\n        elif (ch[i]==\\\"B\\\"):\\n            b+=1\\n        elif (ch[i]==\\\"C\\\"):\\n            c+=1\\n\\n    if (b<a):\\n        print(\\\"NO\\\")\\n        continue\\n    b=b-a\\n    if (b == c):\\n        print(\\\"YES\\\")\\n    else:\\n        print(\\\"NO\\\")\",\"language\":\"python\",\"split\":\"test\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You have an axis-aligned rectangle room with width W and height H, so the lower left corner is in point (0, 0) and the upper right corner is in (W, H).\\n\\nThere is a rectangular table standing in this room. The sides of the table are parallel to the walls, the lower left corner is in (x_1, y_1), and the upper right corner in (x_2, y_2).\\n\\nYou want to place another rectangular table in this room with width w and height h with the width of the table parallel to the width of the room.\\n\\nThe problem is that sometimes there is not enough space to place the second table without intersecting with the first one (there are no problems with tables touching, though).\\n\\nYou can't rotate any of the tables, but you can move the first table inside the room. \\n\\n<image> Example of how you may move the first table.\\n\\nWhat is the minimum distance you should move the first table to free enough space for the second one?\\n\\nInput\\n\\nThe first line contains the single integer t (1 \u2264 t \u2264 5000) \u2014 the number of the test cases.\\n\\nThe first line of each test case contains two integers W and H (1 \u2264 W, H \u2264 10^8) \u2014 the width and the height of the room.\\n\\nThe second line contains four integers x_1, y_1, x_2 and y_2 (0 \u2264 x_1 < x_2 \u2264 W; 0 \u2264 y_1 < y_2 \u2264 H) \u2014 the coordinates of the corners of the first table.\\n\\nThe third line contains two integers w and h (1 \u2264 w \u2264 W; 1 \u2264 h \u2264 H) \u2014 the width and the height of the second table.\\n\\nOutput\\n\\nFor each test case, print the minimum distance you should move the first table, or -1 if there is no way to free enough space for the second table.\\n\\nYour answer will be considered correct if its absolute or relative error doesn't exceed 10^{-6}.\\n\\nExample\\n\\nInput\\n\\n\\n5\\n8 5\\n2 1 7 4\\n4 2\\n5 4\\n2 2 5 4\\n3 3\\n1 8\\n0 3 1 6\\n1 5\\n8 1\\n3 0 6 1\\n5 1\\n8 10\\n4 5 7 8\\n8 5\\n\\n\\nOutput\\n\\n\\n1.000000000\\n-1\\n2.000000000\\n2.000000000\\n0.000000000\\n\\nNote\\n\\nThe configuration of the first test case is shown in the picture. But the movement of the first table is not optimal. One of the optimal movement, for example, is to move the table by (0, -1), so the lower left corner...\\nUsing cpp can you solve the prior task?\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint32_t main() {\\n  ios::sync_with_stdio(0);\\n  cin.tie(0);\\n  long long t = 1;\\n  cin >> t;\\n  while (t--) {\\n    long long w, h;\\n    cin >> w >> h;\\n    long long x1, y1, x2, y2;\\n    cin >> x1 >> y1 >> x2 >> y2;\\n    long long w1 = x2 - x1;\\n    long long h1 = y2 - y1;\\n    long long w2, h2;\\n    cin >> w2 >> h2;\\n    if (w1 + w2 > w && h1 + h2 > h) {\\n      cout << -1;\\n      cout << \\\"\\\\n\\\";\\n      continue;\\n    }\\n    long long ans = 0;\\n    if (w1 + w2 <= w && h1 + h2 <= h) {\\n      ans = min(min(w2 - x1, w2 - (w - x2)), min(h2 - y1, h2 - (h - y2)));\\n    } else {\\n      if (w1 + w2 <= w) {\\n        ans = min(w2 - x1, w2 - (w - x2));\\n      } else if (h1 + h2 <= h) {\\n        ans = min(h2 - y1, h2 - (h - y2));\\n      }\\n    }\\n    cout << fixed << setprecision(9) << (double)max(0ll, ans);\\n    cout << \\\"\\\\n\\\";\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"On a circle lie 2n distinct points, with the following property: however you choose 3 chords that connect 3 disjoint pairs of points, no point strictly inside the circle belongs to all 3 chords. The points are numbered 1,   2,   ...,   2n in clockwise order.\\n\\nInitially, k chords connect k pairs of points, in such a way that all the 2k endpoints of these chords are distinct.\\n\\nYou want to draw n - k additional chords that connect the remaining 2(n - k) points (each point must be an endpoint of exactly one chord).\\n\\nIn the end, let x be the total number of intersections among all n chords. Compute the maximum value that x can attain if you choose the n - k chords optimally.\\n\\nNote that the exact position of the 2n points is not relevant, as long as the property stated in the first paragraph holds.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 100) \u2014 the number of test cases. Then t test cases follow.\\n\\nThe first line of each test case contains two integers n and k (1 \u2264 n \u2264 100, 0 \u2264 k \u2264 n) \u2014 half the number of points and the number of chords initially drawn.\\n\\nThen k lines follow. The i-th of them contains two integers x_i and y_i (1 \u2264 x_i,   y_i \u2264 2n, x_i \u2260 y_i) \u2014 the endpoints of the i-th chord. It is guaranteed that the 2k numbers x_1,   y_1,   x_2,   y_2,   ...,   x_k,   y_k are all distinct.\\n\\nOutput\\n\\nFor each test case, output the maximum number of intersections that can be obtained by drawing n - k additional chords.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n4 2\\n8 2\\n1 5\\n1 1\\n2 1\\n2 0\\n10 6\\n14 6\\n2 20\\n9 10\\n13 18\\n15 12\\n11 7\\n\\n\\nOutput\\n\\n\\n4\\n0\\n1\\n14\\n\\nNote\\n\\nIn the first test case, there are three ways to draw the 2 additional chords, shown below (black chords are the ones initially drawn, while red chords are the new ones):\\n\\n<image>\\n\\nWe see that the third way gives the maximum number of intersections, namely 4.\\n\\nIn the second test case, there are no more chords to draw. Of course, with only one chord present there are no intersections.\\n\\nIn the third test case, we can make at most one intersection by drawing chords 1-3 and 2-4, as...\\nUsing java can you solve the prior task?\",\"targets\":\"import java.io.BufferedReader;\\nimport java.io.IOException;\\nimport java.io.InputStreamReader;\\nimport java.util.ArrayList;\\nimport java.util.Arrays;\\nimport java.util.List;\\nimport java.util.Random;\\nimport java.util.StringTokenizer;\\n\\npublic final class C {\\n\\n    public static void main(String[] args) {\\n        final FastScanner fs = new FastScanner();\\n        final int t = fs.nextInt();\\n        for (int test = 0; test < t; test++) {\\n            final int n = fs.nextInt();\\n            final int k = fs.nextInt();\\n            final List<int[]> chords = new ArrayList<>();\\n            final boolean[] used = new boolean[2 * n];\\n            for (int i = 0; i < k; i++) {\\n                int l = fs.nextInt() - 1;\\n                int r = fs.nextInt() - 1;\\n                if (l > r) {\\n                    final int temp = l;\\n                    l = r;\\n                    r = temp;\\n                }\\n                chords.add(new int[] { l, r });\\n                used[l] = used[r] = true;\\n            }\\n            final List<Integer> unused = new ArrayList<>();\\n            for (int i = 0; i < used.length; i++) {\\n                if (!used[i]) {\\n                    unused.add(i);\\n                }\\n            }\\n            for (int i = 0; i < n - k; i++) {\\n                chords.add(new int[] { unused.get(i), unused.get(i + n - k) });\\n            }\\n            int res = 0;\\n            for (int i = 0; i < chords.size(); i++) {\\n                for (int j = i + 1; j < chords.size(); j++) {\\n                    res += f(chords.get(i), chords.get(j));\\n                }\\n            }\\n            System.out.println(res);\\n        }\\n    }\\n\\n    private static int f(int[] c, int[] d) {\\n        if (c[0] > d[0]) {\\n            \\/\\/noinspection TailRecursion\\n            return f(d, c);\\n        }\\n        return d[0] < c[1] && c[1] < d[1] ? 1 : 0;\\n    }\\n\\n    static final class Utils {\\n        private static class Shuffler {\\n            private static void shuffle(int[] x) {\\n                final Random r = new Random();\\n\\n                for (int i =...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"Phoenix has collected n pieces of gold, and he wants to weigh them together so he can feel rich. The i-th piece of gold has weight w_i. All weights are distinct. He will put his n pieces of gold on a weight scale, one piece at a time. \\n\\nThe scale has an unusual defect: if the total weight on it is exactly x, it will explode. Can he put all n gold pieces onto the scale in some order, without the scale exploding during the process? If so, help him find some possible order. \\n\\nFormally, rearrange the array w so that for each i (1 \u2264 i \u2264 n), \u2211_{j = 1}^{i}w_j \u2260 x.\\n\\nInput\\n\\nThe input consists of multiple test cases. The first line contains an integer t (1 \u2264 t \u2264 1000) \u2014 the number of test cases.\\n\\nThe first line of each test case contains two integers n and x (1 \u2264 n \u2264 100; 1 \u2264 x \u2264 10^4) \u2014 the number of gold pieces that Phoenix has and the weight to avoid, respectively. \\n\\nThe second line of each test case contains n space-separated integers (1 \u2264 w_i \u2264 100) \u2014 the weights of the gold pieces. It is guaranteed that the weights are pairwise distinct.\\n\\nOutput\\n\\nFor each test case, if Phoenix cannot place all n pieces without the scale exploding, print NO. Otherwise, print YES followed by the rearranged array w. If there are multiple solutions, print any.\\n\\nExample\\n\\nInput\\n\\n\\n3\\n3 2\\n3 2 1\\n5 3\\n1 2 3 4 8\\n1 5\\n5\\n\\n\\nOutput\\n\\n\\nYES\\n3 2 1\\nYES\\n8 1 2 3 4\\nNO\\n\\nNote\\n\\nIn the first test case, Phoenix puts the gold piece with weight 3 on the scale first, then the piece with weight 2, and finally the piece with weight 1. The total weight on the scale is 3, then 5, then 6. The scale does not explode because the total weight on the scale is never 2.\\n\\nIn the second test case, the total weight on the scale is 8, 9, 11, 14, then 18. It is never 3.\\n\\nIn the third test case, Phoenix must put the gold piece with weight 5 on the scale, and the scale will always explode.\\\":\",\"targets\":\"#include<bits\\/stdc++.h>\\nusing namespace std;\\n#define lli long long int\\n#define ulli unsigned long long int\\n#define pi 3.1415926535897932384626\\n#define p_b push_back\\n\\/\\/ numeric_limits<double>::max();\\nlli gcd(lli a, lli b) { if (b == 0) return a; return gcd(b, a % b); }\\nlli lcm(lli a, lli b) {return (a * b) \\/ gcd(a, b);}\\ntemplate <typename T>\\nT max3(T x, T y, T z) {return (max(max(x, y), z));}\\ntemplate <typename T>\\nT min3(T x, T y, T z) {return (min(min(x, y), z));}\\n\\nvoid required()\\n{\\n#ifndef ONLINE_JUDGE\\n\\tfreopen(\\\"input.txt\\\", \\\"r\\\", stdin);\\n\\tfreopen(\\\"output.txt\\\", \\\"w\\\", stdout);\\n\\tfreopen(\\\"error.txt\\\", \\\"w\\\", stderr);\\n#endif\\n}\\n\\nvoid solve()\\n{\\n\\tlli n, x, s;\\n\\tcin >> n >> x;\\n\\tqueue<int> q;\\n\\tvector<int> ans;\\n\\tfor (int i = 0; i < n; i++)\\n\\t{\\n\\t\\tcin >> s;\\n\\t\\tq.push(s);\\n\\t}\\n\\tint ct = 0;\\n\\ts = 0;\\n\\twhile (!q.empty() && ct <= q.size())\\n\\t{\\n\\t\\t\\/*if (q.front() == x)\\n\\t\\t{\\n\\t\\t\\tq.push(q.front());\\n\\t\\t\\tq.pop();\\n\\t\\t\\tct++;\\n\\t\\t\\tcontinue;\\n\\t\\t}\\n\\t\\telse*\\/ if ((q.front() + s) == x)\\n\\t\\t{\\n\\t\\t\\tq.push(q.front());\\n\\t\\t\\tq.pop();\\n\\t\\t\\tct++;\\n\\t\\t\\tcontinue;\\n\\t\\t}\\n\\t\\telse\\n\\t\\t{\\n\\t\\t\\tans.push_back(q.front());\\n\\t\\t\\ts += q.front();\\n\\t\\t\\tq.pop();\\n\\t\\t\\tct = 0;\\n\\t\\t}\\n\\t}\\n\\tif (q.empty())\\n\\t{\\n\\t\\tcout << \\\"YES\\\\n\\\";\\n\\t\\tfor (auto e : ans)\\n\\t\\t\\tcout << e << \\\" \\\";\\n\\t\\tcout << endl;\\n\\t}\\n\\telse\\n\\t\\tcout << \\\"NO\\\" << endl;\\n}\\n\\nint main()\\n{\\n\\trequired();\\n\\tint t = 1;\\n\\tcin >> t;\\t\\t\\/\\/comment it for single test case\\n\\twhile (t--)\\n\\t{\\n\\t\\tsolve();\\n\\t}\\n\\treturn 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Authors guessed an array a consisting of n integers; each integer is not less than 2 and not greater than 2 \u22c5 10^5. You don't know the array a, but you know the array b which is formed from it with the following sequence of operations:\\n\\n  1. Firstly, let the array b be equal to the array a; \\n  2. Secondly, for each i from 1 to n: \\n    * if a_i is a prime number, then one integer p_{a_i} is appended to array b, where p is an infinite sequence of prime numbers (2, 3, 5, ...); \\n    * otherwise (if a_i is not a prime number), the greatest divisor of a_i which is not equal to a_i is appended to b; \\n  3. Then the obtained array of length 2n is shuffled and given to you in the input. \\n\\n\\n\\nHere p_{a_i} means the a_i-th prime number. The first prime p_1 = 2, the second one is p_2 = 3, and so on.\\n\\nYour task is to recover any suitable array a that forms the given array b. It is guaranteed that the answer exists (so the array b is obtained from some suitable array a). If there are multiple answers, you can print any.\\n\\nInput\\n\\nThe first line of the input contains one integer n (1 \u2264 n \u2264 2 \u22c5 10^5) \u2014 the number of elements in a.\\n\\nThe second line of the input contains 2n integers b_1, b_2, ..., b_{2n} (2 \u2264 b_i \u2264 2750131), where b_i is the i-th element of b. 2750131 is the 199999-th prime number.\\n\\nOutput\\n\\nIn the only line of the output print n integers a_1, a_2, ..., a_n (2 \u2264 a_i \u2264 2 \u22c5 10^5) in any order \u2014 the array a from which the array b can be obtained using the sequence of moves given in the problem statement. If there are multiple answers, you can print any.\\n\\nExamples\\n\\nInput\\n\\n\\n3\\n3 5 2 3 2 4\\n\\n\\nOutput\\n\\n\\n3 4 2 \\n\\nInput\\n\\n\\n1\\n2750131 199999\\n\\n\\nOutput\\n\\n\\n199999 \\n\\nInput\\n\\n\\n1\\n3 6\\n\\n\\nOutput\\n\\n\\n6\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst int N = 2750135;\\nconst int mod = 1e9 + 7;\\nint pos[N], pr[N], cnt, a[N], b[N];\\nbool d[N];\\nvector<int> A;\\nint main() {\\n  ios_base::sync_with_stdio(0);\\n  cin.tie(0);\\n  for (int i = 2; i <= 2750131; ++i) {\\n    if (!pr[i]) {\\n      pos[i] = ++cnt;\\n      if (i * 1ll * i <= 2750131) {\\n        for (int j = i * i; j <= 2750131; ++j) {\\n          if (!pr[j]) pr[j] = i;\\n          j += i - 1;\\n        }\\n      }\\n    }\\n  }\\n  int n;\\n  cin >> n;\\n  for (int i = 1; i <= 2 * n; ++i) cin >> a[i];\\n  sort(a + 1, a + 1 + 2 * n);\\n  for (int i = 2 * n; i >= 1; --i) {\\n    if (b[a[i]]) {\\n      d[i] = 1;\\n      --b[a[i]];\\n      continue;\\n    }\\n    if (pr[a[i]]) {\\n      d[i] = 1;\\n      A.push_back(a[i]);\\n      ++b[a[i] \\/ pr[a[i]]];\\n    }\\n  }\\n  for (int i = 2 * n; i >= 1; --i) {\\n    if (d[i]) continue;\\n    if (b[a[i]]) {\\n      --b[a[i]];\\n      continue;\\n    }\\n    A.push_back(pos[a[i]]);\\n    ++b[pos[a[i]]];\\n  }\\n  for (auto to : A) cout << to << ' ';\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Drazil is a monkey. He lives in a circular park. There are n trees around the park. The distance between the i-th tree and (i + 1)-st trees is di, the distance between the n-th tree and the first tree is dn. The height of the i-th tree is hi.\\n\\nDrazil starts each day with the morning run. The morning run consists of the following steps:\\n\\n  * Drazil chooses two different trees \\n  * He starts with climbing up the first tree \\n  * Then he climbs down the first tree, runs around the park (in one of two possible directions) to the second tree, and climbs on it \\n  * Then he finally climbs down the second tree. \\n\\n\\n\\nBut there are always children playing around some consecutive trees. Drazil can't stand children, so he can't choose the trees close to children. He even can't stay close to those trees.\\n\\nIf the two trees Drazil chooses are x-th and y-th, we can estimate the energy the morning run takes to him as 2(hx + hy) + dist(x, y). Since there are children on exactly one of two arcs connecting x and y, the distance dist(x, y) between trees x and y is uniquely defined.\\n\\nNow, you know that on the i-th day children play between ai-th tree and bi-th tree. More formally, if ai \u2264 bi, children play around the trees with indices from range [ai, bi], otherwise they play around the trees with indices from <image>.\\n\\nPlease help Drazil to determine which two trees he should choose in order to consume the most energy (since he wants to become fit and cool-looking monkey) and report the resulting amount of energy for each day.\\n\\nInput\\n\\nThe first line contains two integer n and m (3 \u2264 n \u2264 105, 1 \u2264 m \u2264 105), denoting number of trees and number of days, respectively. \\n\\nThe second line contains n integers d1, d2, ..., dn (1 \u2264 di \u2264 109), the distances between consecutive trees.\\n\\nThe third line contains n integers h1, h2, ..., hn (1 \u2264 hi \u2264 109), the heights of trees.\\n\\nEach of following m lines contains two integers ai and bi (1 \u2264 ai, bi \u2264 n) describing each new day. There are always at least two different trees Drazil can choose that are...\\nThe above is tricky. Write me a correct solution in JAVA.\",\"targets\":\"import java.io.OutputStream;\\nimport java.io.IOException;\\nimport java.io.InputStream;\\nimport java.io.PrintWriter;\\nimport java.util.StringTokenizer;\\nimport java.io.BufferedReader;\\nimport java.io.FileReader;\\nimport java.io.InputStreamReader;\\nimport java.io.InputStream;\\n\\n\\/**\\n * Built using CHelper plug-in\\n * Actual solution is at the top\\n *\\n * @author OmarYasser\\n *\\/\\npublic class Main {\\n    public static void main(String[] args) {\\n        InputStream inputStream = System.in;\\n        OutputStream outputStream = System.out;\\n        Scanner in = new Scanner(inputStream);\\n        PrintWriter out = new PrintWriter(outputStream);\\n        TaskE solver = new TaskE();\\n        solver.solve(1, in, out);\\n        out.close();\\n    }\\n\\n    static class TaskE {\\n        static int N;\\n        static int M;\\n        static long[] D;\\n        static long[] H;\\n\\n        static long energy(int a, int b) {\\n            return 2 * (H[a] + H[b]) + (b == 0 ? 0 : D[b - 1]) - (a == 0 ? 0 : D[a - 1]);\\n        }\\n\\n        public void solve(int testNumber, Scanner sc, PrintWriter out) {\\n            N = sc.nextInt();\\n            M = sc.nextInt();\\n            D = new long[N * 2];\\n            H = new long[N * 2];\\n            for (int i = 0; i < N; i++)\\n                D[i] = sc.nextInt();\\n            for (int i = N; i < N * 2; i++)\\n                D[i] = D[i % N];\\n            for (int i = 1; i < 2 * N; i++)\\n                D[i] += D[i - 1];\\n            for (int i = 0; i < N; i++)\\n                H[i] = sc.nextInt();\\n            for (int i = N; i < N * 2; i++)\\n                H[i] = H[i % N];\\n\\n            TaskE.SegmentTree st = new TaskE.SegmentTree(N << 1);\\n            while (M-- > 0) {\\n                int a = sc.nextInt() - 1, b = sc.nextInt() - 1;\\n                TaskE.Pair res = st.query(a > b ? b + N + 1 : b + 1, a + N - 1);\\n                out.println(energy(res.l, res.r));\\n            }\\n        }\\n\\n        static class Pair {\\n            int l;\\n            int r;\\n\\n            Pair(int ll, int rr) {\\n                l = ll;\\n                r = rr;\\n  ...\",\"language\":\"python\",\"split\":\"train\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"This problem is an extension of the problem \\\"Wonderful Coloring - 1\\\". It has quite many differences, so you should read this statement completely.\\n\\nRecently, Paul and Mary have found a new favorite sequence of integers a_1, a_2, ..., a_n. They want to paint it using pieces of chalk of k colors. The coloring of a sequence is called wonderful if the following conditions are met:\\n\\n  1. each element of the sequence is either painted in one of k colors or isn't painted; \\n  2. each two elements which are painted in the same color are different (i. e. there's no two equal values painted in the same color); \\n  3. let's calculate for each of k colors the number of elements painted in the color \u2014 all calculated numbers must be equal; \\n  4. the total number of painted elements of the sequence is the maximum among all colorings of the sequence which meet the first three conditions. \\n\\n\\n\\nE. g. consider a sequence a=[3, 1, 1, 1, 1, 10, 3, 10, 10, 2] and k=3. One of the wonderful colorings of the sequence is shown in the figure.\\n\\n<image> The example of a wonderful coloring of the sequence a=[3, 1, 1, 1, 1, 10, 3, 10, 10, 2] and k=3. Note that one of the elements isn't painted.\\n\\nHelp Paul and Mary to find a wonderful coloring of a given sequence a.\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 10000) \u2014 the number of test cases. Then t test cases follow.\\n\\nEach test case consists of two lines. The first one contains two integers n and k (1 \u2264 n \u2264 2\u22c510^5, 1 \u2264 k \u2264 n) \u2014 the length of a given sequence and the number of colors, respectively. The second one contains n integers a_1, a_2, ..., a_n (1 \u2264 a_i \u2264 n).\\n\\nIt is guaranteed that the sum of n over all test cases doesn't exceed 2 \u22c5 10^5.\\n\\nOutput\\n\\nOutput t lines, each of them must contain a description of a wonderful coloring for the corresponding test case.\\n\\nEach wonderful coloring must be printed as a sequence of n integers c_1, c_2, ..., c_n (0 \u2264 c_i \u2264 k) separated by spaces where\\n\\n  * c_i=0, if i-th element isn't painted; \\n  * c_i>0, if i-th element is painted in the...\\nfrom\",\"targets\":\"itertools import product\\nfrom math import ceil, gcd, sqrt\\nimport string\\nfrom decimal import Decimal\\n\\n\\ndef binary_table(string_with_all_characters, length_to_make):\\n    return [''.join(x) for x in product(string_with_all_characters, repeat=length_to_make)]\\n\\n\\ndef all_possible_substrings(string):\\n    return [int(string[i: j]) for i in range(len(string)) for j in range(i + 1, len(string) + 1)]\\n\\n\\ndef number_of_substrings(length):\\n    return int(length * (length + 1) \\/ 2)\\n\\n\\nfor enumeration in range(int(input())):\\n    temp = {}\\n    num_of_elements, num_of_colors = map(int, input().split())\\n    array = list(map(int, input().split()))\\n    current_color = 1\\n    indexes = {}\\n\\n    for i in range(len(array)):\\n        value = array[i]\\n        if temp.get(value) is None:\\n            temp[value] = 1\\n        else:\\n            temp[value] += 1\\n\\n        if indexes.get(value) is None:\\n            indexes[value] = [i]\\n        else:\\n            indexes[value].append(i)\\n\\n        if temp[value] > num_of_colors:\\n            array[i] = 0\\n            indexes[value].remove(i)\\n            temp[value] -= 1\\n    length_value = len([x for x in array if x > 0])\\n    num = 0\\n    #print(indexes)\\n    while length_value % num_of_colors:\\n        if array[num] != 0:\\n            indexes[array[num]].remove(num)\\n            array[num] = 0\\n            length_value -= 1\\n        num += 1\\n    #print(temp)\\n    #print(array)\\n    build = array[::]\\n    #print(indexes)\\n    for i in temp:\\n        possible_index = indexes[i]\\n        #print(i, possible_index)\\n        for j in possible_index:\\n            #print(j, current_color)\\n            build[j] = current_color\\n            current_color += 1\\n            if current_color > num_of_colors:\\n                current_color = 1\\n    #print(array)\\n    print(*build)\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"PYTHON3 solution for \\\"<image>\\n\\nWilliam has a favorite bracket sequence. Since his favorite sequence is quite big he provided it to you as a sequence of positive integers c_1, c_2, ..., c_n where c_i is the number of consecutive brackets \\\"(\\\" if i is an odd number or the number of consecutive brackets \\\")\\\" if i is an even number.\\n\\nFor example for a bracket sequence \\\"((())()))\\\" a corresponding sequence of numbers is [3, 2, 1, 3].\\n\\nYou need to find the total number of continuous subsequences (subsegments) [l, r] (l \u2264 r) of the original bracket sequence, which are regular bracket sequences.\\n\\nA bracket sequence is called regular if it is possible to obtain correct arithmetic expression by inserting characters \\\"+\\\" and \\\"1\\\" into this sequence. For example, sequences \\\"(())()\\\", \\\"()\\\" and \\\"(()(()))\\\" are regular, while \\\")(\\\", \\\"(()\\\" and \\\"(()))(\\\" are not.\\n\\nInput\\n\\nThe first line contains a single integer n (1 \u2264 n \u2264 1000), the size of the compressed sequence.\\n\\nThe second line contains a sequence of integers c_1, c_2, ..., c_n (1 \u2264 c_i \u2264 10^9), the compressed sequence.\\n\\nOutput\\n\\nOutput a single integer \u2014 the total number of subsegments of the original bracket sequence, which are regular bracket sequences.\\n\\nIt can be proved that the answer fits in the signed 64-bit integer data type.\\n\\nExamples\\n\\nInput\\n\\n\\n5\\n4 1 2 3 1\\n\\n\\nOutput\\n\\n\\n5\\n\\n\\nInput\\n\\n\\n6\\n1 3 2 1 2 4\\n\\n\\nOutput\\n\\n\\n6\\n\\n\\nInput\\n\\n\\n6\\n1 1 1 1 2 2\\n\\n\\nOutput\\n\\n\\n7\\n\\nNote\\n\\nIn the first example a sequence (((()(()))( is described. This bracket sequence contains 5 subsegments which form regular bracket sequences:\\n\\n  1. Subsequence from the 3rd to 10th character: (()(()))\\n  2. Subsequence from the 4th to 5th character: ()\\n  3. Subsequence from the 4th to 9th character: ()(())\\n  4. Subsequence from the 6th to 9th character: (())\\n  5. Subsequence from the 7th to 8th character: ()\\n\\n\\n\\nIn the second example a sequence ()))(()(()))) is described.\\n\\nIn the third example a sequence ()()(()) is described.\\\":\",\"targets\":\"# ------------------- fast io --------------------\\nimport os\\nimport sys\\nfrom io import BytesIO, IOBase\\n\\nBUFSIZE = 8192\\n\\n\\nclass FastIO(IOBase):\\n    newlines = 0\\n    \\n    def __init__(self, file):\\n        self._fd = file.fileno()\\n        self.buffer = BytesIO()\\n        self.writable = \\\"x\\\" in file.mode or \\\"r\\\" not in file.mode\\n        self.write = self.buffer.write if self.writable else None\\n    \\n    def read(self):\\n        while True:\\n            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))\\n            if not b:\\n                break\\n            ptr = self.buffer.tell()\\n            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)\\n        self.newlines = 0\\n        return self.buffer.read()\\n    \\n    def readline(self):\\n        while self.newlines == 0:\\n            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))\\n            self.newlines = b.count(b\\\"\\\\n\\\") + (not b)\\n            ptr = self.buffer.tell()\\n            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)\\n        self.newlines -= 1\\n        return self.buffer.readline()\\n    \\n    def flush(self):\\n        if self.writable:\\n            os.write(self._fd, self.buffer.getvalue())\\n            self.buffer.truncate(0), self.buffer.seek(0)\\n\\n\\nclass IOWrapper(IOBase):\\n    def __init__(self, file):\\n        self.buffer = FastIO(file)\\n        self.flush = self.buffer.flush\\n        self.writable = self.buffer.writable\\n        self.write = lambda s: self.buffer.write(s.encode(\\\"ascii\\\"))\\n        self.read = lambda: self.buffer.read().decode(\\\"ascii\\\")\\n        self.readline = lambda: self.buffer.readline().decode(\\\"ascii\\\")\\n\\n\\nsys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)\\ninput = lambda: sys.stdin.readline().rstrip(\\\"\\\\r\\\\n\\\")\\n\\n# ------------------- fast io --------------------\\nfrom math import ceil\\n\\n\\ndef prod(a, mod=10 ** 9 + 7):\\n    ans = 1\\n    for each in a:\\n        ans = (ans * each) % mod\\n    return ans\\n\\n\\ndef gcd(x, y):\\n    while y:\\n        x, y = y, x % y\\n    return x\\n\\n\\ndef lcm(a, b):...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Alice and Borys are playing tennis.\\n\\nA tennis match consists of games. In each game, one of the players is serving and the other one is receiving.\\n\\nPlayers serve in turns: after a game where Alice is serving follows a game where Borys is serving, and vice versa.\\n\\nEach game ends with a victory of one of the players. If a game is won by the serving player, it's said that this player holds serve. If a game is won by the receiving player, it's said that this player breaks serve.\\n\\nIt is known that Alice won a games and Borys won b games during the match. It is unknown who served first and who won which games.\\n\\nFind all values of k such that exactly k breaks could happen during the match between Alice and Borys in total.\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 10^3). Description of the test cases follows.\\n\\nEach of the next t lines describes one test case and contains two integers a and b (0 \u2264 a, b \u2264 10^5; a + b > 0) \u2014 the number of games won by Alice and Borys, respectively.\\n\\nIt is guaranteed that the sum of a + b over all test cases does not exceed 2 \u22c5 10^5.\\n\\nOutput\\n\\nFor each test case print two lines.\\n\\nIn the first line, print a single integer m (1 \u2264 m \u2264 a + b + 1) \u2014 the number of values of k such that exactly k breaks could happen during the match.\\n\\nIn the second line, print m distinct integers k_1, k_2, \u2026, k_m (0 \u2264 k_1 < k_2 < \u2026 < k_m \u2264 a + b) \u2014 the sought values of k in increasing order.\\n\\nExample\\n\\nInput\\n\\n\\n3\\n2 1\\n1 1\\n0 5\\n\\n\\nOutput\\n\\n\\n4\\n0 1 2 3\\n2\\n0 2\\n2\\n2 3\\n\\nNote\\n\\nIn the first test case, any number of breaks between 0 and 3 could happen during the match: \\n\\n  * Alice holds serve, Borys holds serve, Alice holds serve: 0 breaks; \\n  * Borys holds serve, Alice holds serve, Alice breaks serve: 1 break; \\n  * Borys breaks serve, Alice breaks serve, Alice holds serve: 2 breaks; \\n  * Alice breaks serve, Borys breaks serve, Alice breaks serve: 3 breaks. \\n\\n\\n\\nIn the second test case, the players could either both hold serves (0 breaks) or both break serves (2...\\nThe above is tricky. Write me a correct solution in JAVA.\",\"targets\":\"import java.util.*;\\n\\npublic class A {\\n\\t\\n\\tpublic static void main(String[] args) {\\n\\t\\tScanner scan=new Scanner(System.in);\\n\\t\\tint T=scan.nextInt();\\n\\t\\t\\n\\t\\t\\n\\t\\twhile (T-->0) {\\n\\t\\t\\tint a=scan.nextInt(),b=scan.nextInt();\\n\\t\\t\\tHashSet<Integer> set=helper(a, a+b);\\n\\t\\t\\tset.addAll(helper(b, a+b));\\n\\t\\t\\tSystem.out.println(set.size());\\n\\t\\t\\tArrayList<Integer> ls=new ArrayList<Integer>(set);\\n\\t\\t\\tCollections.sort(ls);\\n\\t\\t\\tfor(int i:ls) {\\n\\t\\t\\t\\tSystem.out.print(i+\\\" \\\");\\n\\t\\t\\t}System.out.println();\\n\\t\\t\\t\\n\\t\\t}\\n\\t\\tscan.close();\\n\\t}\\n\\tprivate static HashSet<Integer> helper(int win,int total) {\\n\\t\\tHashSet<Integer> arr=new HashSet<Integer>();\\n\\t\\tint ehalf=total\\/2;\\n\\t\\tint ohalf=(int)Math.ceil(total\\/2.0);\\n\\t\\tint lose=total-win;\\n\\t\\t\\n\\/\\/\\t\\tSystem.out.println(\\\"win=\\\"+win+\\\" lo=\\\"+lose);\\/\\/\\/\\/\\n\\/\\/\\t\\tSystem.out.println(\\\"eh=\\\"+ehalf+\\\" oh=\\\"+ohalf);\\/\\/\\/\\/\\/\\n\\t\\t\\n\\t\\t\\n\\t\\tfor(int i=Math.max(0, win-ohalf);i<=Math.min(win, ehalf);i++) {\\n\\/\\/\\t\\t\\tSystem.out.println(\\\"----i~\\\"+i+\\\" l~\\\"+(lose-(ehalf-i)));\\/\\/\\/\\/\\/\\n\\t\\t\\tarr.add(i+(lose-(ehalf-i)));\\n\\t\\t}\\n\\t\\treturn arr;\\n\\t\\t\\n\\t}\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"An elephant decided to visit his friend. It turned out that the elephant's house is located at point 0 and his friend's house is located at point x(x > 0) of the coordinate line. In one step the elephant can move 1, 2, 3, 4 or 5 positions forward. Determine, what is the minimum number of steps he need to make in order to get to his friend's house.\\n\\nInput\\n\\nThe first line of the input contains an integer x (1 \u2264 x \u2264 1 000 000) \u2014 The coordinate of the friend's house.\\n\\nOutput\\n\\nPrint the minimum number of steps that elephant needs to make to get from point 0 to point x.\\n\\nExamples\\n\\nInput\\n\\n5\\n\\n\\nOutput\\n\\n1\\n\\n\\nInput\\n\\n12\\n\\n\\nOutput\\n\\n3\\n\\nNote\\n\\nIn the first sample the elephant needs to make one step of length 5 to reach the point x.\\n\\nIn the second sample the elephant can get to point x if he moves by 3, 5 and 4. There are other ways to get the optimal answer but the elephant cannot reach x in less than three moves.\\nUsing python3 can you solve the prior task?\",\"targets\":\"n = int(input())\\n\\na = 0\\n\\na = int(n\\/5)\\n\\nif(n%5!=0):\\n    a+=1\\n\\nprint (a)\",\"language\":\"python\",\"split\":\"train\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Given n, find any array a_1, a_2, \u2026, a_n of integers such that all of the following conditions hold: \\n\\n  * 1 \u2264 a_i \u2264 10^9 for every i from 1 to n.\\n\\n  * a_1 < a_2 < \u2026 <a_n\\n\\n  * For every i from 2 to n, a_i isn't divisible by a_{i-1}\\n\\n\\n\\n\\nIt can be shown that such an array always exists under the constraints of the problem.\\n\\nInput\\n\\nThe first line contains the number of test cases t (1 \u2264 t \u2264 100). Description of the test cases follows.\\n\\nThe only line of each test case contains a single integer n (1 \u2264 n \u2264 1000).\\n\\nIt is guaranteed that the sum of n over all test cases does not exceed 10^4.\\n\\nOutput\\n\\nFor each test case print n integers a_1, a_2, \u2026, a_n \u2014 the array you found. If there are multiple arrays satisfying all the conditions, print any of them.\\n\\nExample\\n\\nInput\\n\\n\\n3\\n1\\n2\\n7\\n\\n\\nOutput\\n\\n\\n1\\n2 3\\n111 1111 11111 111111 1111111 11111111 111111111\\n\\nNote\\n\\nIn the first test case, array [1] satisfies all the conditions.\\n\\nIn the second test case, array [2, 3] satisfies all the conditions, as 2<3 and 3 is not divisible by 2.\\n\\nIn the third test case, array [111, 1111, 11111, 111111, 1111111, 11111111, 111111111] satisfies all the conditions, as it's increasing and a_i isn't divisible by a_{i-1} for any i from 2 to 7.\",\"targets\":\"t = int(input())\\nfor i in range(t):\\n    n = int(input())\\n    for k in range(n):\\n        print(k+2)\",\"language\":\"python\",\"split\":\"test\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Theofanis really likes sequences of positive integers, thus his teacher (Yeltsa Kcir) gave him a problem about a sequence that consists of only special numbers.\\n\\nLet's call a positive number special if it can be written as a sum of different non-negative powers of n. For example, for n = 4 number 17 is special, because it can be written as 4^0 + 4^2 = 1 + 16 = 17, but 9 is not.\\n\\nTheofanis asks you to help him find the k-th special number if they are sorted in increasing order. Since this number may be too large, output it modulo 10^9+7.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases.\\n\\nThe first and only line of each test case contains two integers n and k (2 \u2264 n \u2264 10^9; 1 \u2264 k \u2264 10^9).\\n\\nOutput\\n\\nFor each test case, print one integer \u2014 the k-th special number in increasing order modulo 10^9+7.\\n\\nExample\\n\\nInput\\n\\n\\n3\\n3 4\\n2 12\\n105 564\\n\\n\\nOutput\\n\\n\\n9\\n12\\n3595374\\n\\nNote\\n\\nFor n = 3 the sequence is [1,3,4,9...]\\nThe above is tricky. Write me a correct solution in PYTHON3.\",\"targets\":\"import sys\\nimport math\\nfrom collections import Counter\\ninput = sys.stdin.readline\\nN = int(1e9 + 7)\\n#use input().strip() \\n\\n\\nfor _ in range(int(input().strip())):\\n\\tn, k = [int(j) for j in input().strip().split()]\\n\\tb = [0 for i in range(50)]\\n\\tcount = 0\\n\\tt = 1\\n\\ta = []\\n\\twhile(k):\\n\\t\\tif (k % 2 == 0):\\n\\t\\t\\tk \\/\\/= 2\\n\\t\\t\\tcount += 1\\n\\t\\telif (k % 2 == 1):\\n\\t\\t\\tk -= 1\\n\\t\\t\\tb[count] += 1\\n\\t\\t\\tif (b[count] > 1):\\n\\t\\t\\t\\tt = 0\\n\\t\\telse:\\n\\t\\t\\tprint(-1)\\n\\t\\t\\tt = 0\\n\\t\\tif t != 0:\\n\\t\\t\\tfor i in range(50):\\n\\t\\t\\t\\tif (b[i] > 0):\\n\\t\\t\\t\\t\\ta.append(i)\\n\\ta = list(set(a))\\n\\tans = 0\\n\\tfor i in a:\\n\\t\\tans += pow(n, i, N)\\n\\tprint(ans % N)\",\"language\":\"python\",\"split\":\"test\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in PYTHON3?\\nThis is a simplified version of the problem B2. Perhaps you should read the problem B2 before you start solving B1.\\n\\nPaul and Mary have a favorite string s which consists of lowercase letters of the Latin alphabet. They want to paint it using pieces of chalk of two colors: red and green. Let's call a coloring of a string wonderful if the following conditions are met:\\n\\n  1. each letter of the string is either painted in exactly one color (red or green) or isn't painted; \\n  2. each two letters which are painted in the same color are different; \\n  3. the number of letters painted in red is equal to the number of letters painted in green; \\n  4. the number of painted letters of this coloring is maximum among all colorings of the string which meet the first three conditions. \\n\\n\\n\\nE. g. consider a string s equal to \\\"kzaaa\\\". One of the wonderful colorings of the string is shown in the figure.\\n\\n<image> The example of a wonderful coloring of the string \\\"kzaaa\\\".\\n\\nPaul and Mary want to learn by themselves how to find a wonderful coloring of the string. But they are very young, so they need a hint. Help them find k \u2014 the number of red (or green, these numbers are equal) letters in a wonderful coloring.\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 1000) \u2014 the number of test cases. Then t test cases follow.\\n\\nEach test case consists of one non-empty string s which consists of lowercase letters of the Latin alphabet. The number of characters in the string doesn't exceed 50.\\n\\nOutput\\n\\nFor each test case, output a separate line containing one non-negative integer k \u2014 the number of letters which will be painted in red in a wonderful coloring.\\n\\nExample\\n\\nInput\\n\\n\\n5\\nkzaaa\\ncodeforces\\narchive\\ny\\nxxxxxx\\n\\n\\nOutput\\n\\n\\n2\\n5\\n3\\n0\\n1\\n\\nNote\\n\\nThe first test case contains the string from the statement. One of the wonderful colorings is shown in the figure. There's no wonderful coloring containing 3 or more red letters because the total number of painted symbols will exceed the string's length.\\n\\nThe string from the second test case can be...\",\"targets\":\"def sol():\\n    s = input()\\n\\n    n = len(s)\\n    cnt = [0] * 26\\n\\n    for i in range(n):\\n        cnt[ord(s[i]) - 97] += 1\\n\\n    c1 = 0\\n    c2 = 0\\n\\n    for i in range(26):\\n        c1 += (cnt[i] == 1)\\n        c2 += (cnt[i] > 1)\\n\\n    print(c2 + c1 \\/\\/ 2)\\n\\nt = int(input())\\n\\nfor i in range(t):\\n    sol()\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"Berland State University has received a new update for the operating system. Initially it is installed only on the 1-st computer.\\n\\nUpdate files should be copied to all n computers. The computers are not connected to the internet, so the only way to transfer update files from one computer to another is to copy them using a patch cable (a cable connecting two computers directly). Only one patch cable can be connected to a computer at a time. Thus, from any computer where the update files are installed, they can be copied to some other computer in exactly one hour.\\n\\nYour task is to find the minimum number of hours required to copy the update files to all n computers if there are only k patch cables in Berland State University.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 10^5) \u2014 the number of test cases.\\n\\nEach test case consists of a single line that contains two integers n and k (1 \u2264 k \u2264 n \u2264 10^{18}) \u2014 the number of computers and the number of patch cables.\\n\\nOutput\\n\\nFor each test case print one integer \u2014 the minimum number of hours required to copy the update files to all n computers.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n8 3\\n6 6\\n7 1\\n1 1\\n\\n\\nOutput\\n\\n\\n4\\n3\\n6\\n0\\n\\nNote\\n\\nLet's consider the test cases of the example:\\n\\n  * n=8, k=3: \\n    1. during the first hour, we copy the update files from the computer 1 to the computer 2; \\n    2. during the second hour, we copy the update files from the computer 1 to the computer 3, and from the computer 2 to the computer 4; \\n    3. during the third hour, we copy the update files from the computer 1 to the computer 5, from the computer 2 to the computer 6, and from the computer 3 to the computer 7; \\n    4. during the fourth hour, we copy the update files from the computer 2 to the computer 8. \\n  * n=6, k=6: \\n    1. during the first hour, we copy the update files from the computer 1 to the computer 2; \\n    2. during the second hour, we copy the update files from the computer 1 to the computer 3, and from the computer 2 to the computer 4; \\n    3. during the third hour, we copy the update...\\\":\",\"targets\":\"#include <bits\\/stdc++.h>\\n#pragma GCC optimize(\\\"Ofast\\\")\\n#pragma GCC target(\\\"avx,avx2,fma\\\")\\nusing namespace std;\\ntemplate <typename D>\\nistream &operator>>(istream &in, vector<D> &arr) {\\n  long long n = arr.size();\\n  for (long long(i) = (0); (i) < (n); ++(i)) {\\n    in >> arr[i];\\n  }\\n  return in;\\n}\\ntemplate <typename D>\\nostream &operator<<(ostream &in, vector<D> &arr) {\\n  for (auto &x : arr) in << x << \\\" \\\";\\n  return in;\\n}\\ntemplate <typename D, typename B>\\nostream &operator<<(ostream &in, pair<D, B> &p) {\\n  in << p.first << \\\" \\\" << p.second << \\\" \\\";\\n  return in;\\n}\\ntemplate <typename D, typename B>\\nistream &operator>>(istream &in, pair<D, B> &p) {\\n  in >> p.first >> p.second;\\n  return in;\\n}\\nlong long i, j, k, l, x, y, z, m, n, a, b, c, r, d, t = 1, ans;\\nstring second;\\ntemplate <typename A, typename B>\\nA max(A a, B b) {\\n  return (a > b) ? a : b;\\n}\\ntemplate <typename A, typename B>\\nA min(A a, B b) {\\n  return (a < b) ? a : b;\\n}\\nint modpow(long long a, long long b, int m = 1000000007) {\\n  long long res = 1;\\n  a %= m;\\n  if (a == 0) return a;\\n  while (b > 0) {\\n    if (b & 1) res = (res * a) % m;\\n    a *= a;\\n    a %= m;\\n    b >>= 1;\\n  }\\n  return res;\\n}\\nvoid solve(int tc) {\\n  cin >> n >> k;\\n  ans = 0;\\n  long long curr = 1;\\n  while (curr < n && curr <= k) {\\n    ans++;\\n    curr <<= 1;\\n  }\\n  n -= curr;\\n  if (n <= 0) return void(cout << (ans) << \\\"\\\\n\\\");\\n  ans += (n + k - 1) \\/ k;\\n  cout << (ans) << \\\"\\\\n\\\";\\n}\\nint main() {\\n  ios_base::sync_with_stdio(false);\\n  cin.tie(NULL);\\n  cout.tie(NULL);\\n  ;\\n  int k = 1;\\n  cin >> t;\\n  while (t--) solve(k++);\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in CPP?\\nGregor is learning about RSA cryptography, and although he doesn't understand how RSA works, he is now fascinated with prime numbers and factoring them.\\n\\nGregor's favorite prime number is P. Gregor wants to find two bases of P. Formally, Gregor is looking for two integers a and b which satisfy both of the following properties.\\n\\n  * P mod a = P mod b, where x mod y denotes the remainder when x is divided by y, and \\n  * 2 \u2264 a < b \u2264 P. \\n\\n\\n\\nHelp Gregor find two bases of his favorite prime number!\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 1000).\\n\\nEach subsequent line contains the integer P (5 \u2264 P \u2264 {10}^9), with P guaranteed to be prime.\\n\\nOutput\\n\\nYour output should consist of t lines. Each line should consist of two integers a and b (2 \u2264 a < b \u2264 P). If there are multiple possible solutions, print any.\\n\\nExample\\n\\nInput\\n\\n\\n2\\n17\\n5\\n\\n\\nOutput\\n\\n\\n3 5\\n2 4\\n\\nNote\\n\\nThe first query is P=17. a=3 and b=5 are valid bases in this case, because 17 mod 3 = 17 mod 5 = 2. There are other pairs which work as well.\\n\\nIn the second query, with P=5, the only solution is a=2 and b=4.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint main() {\\n  int m;\\n  cin >> m;\\n  while (m--) {\\n    int n;\\n    cin >> n;\\n    cout << 2 << ' ' << n - 1 << endl;\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Amr has got a large array of size n. Amr doesn't like large arrays so he intends to make it smaller.\\n\\nAmr doesn't care about anything in the array except the beauty of it. The beauty of the array is defined to be the maximum number of times that some number occurs in this array. He wants to choose the smallest subsegment of this array such that the beauty of it will be the same as the original array.\\n\\nHelp Amr by choosing the smallest subsegment possible.\\n\\nInput\\n\\nThe first line contains one number n (1 \u2264 n \u2264 105), the size of the array.\\n\\nThe second line contains n integers ai (1 \u2264 ai \u2264 106), representing elements of the array.\\n\\nOutput\\n\\nOutput two integers l, r (1 \u2264 l \u2264 r \u2264 n), the beginning and the end of the subsegment chosen respectively.\\n\\nIf there are several possible answers you may output any of them. \\n\\nExamples\\n\\nInput\\n\\n5\\n1 1 2 2 1\\n\\n\\nOutput\\n\\n1 5\\n\\nInput\\n\\n5\\n1 2 2 3 1\\n\\n\\nOutput\\n\\n2 3\\n\\nInput\\n\\n6\\n1 2 2 1 1 2\\n\\n\\nOutput\\n\\n1 5\\n\\nNote\\n\\nA subsegment B of an array A from l to r is an array of size r - l + 1 where Bi = Al + i - 1 for all 1 \u2264 i \u2264 r - l + 1\\nUsing python3 can you solve the prior task?\",\"targets\":\"def solve():\\n    d1 = {}\\n    d2 = {}\\n    input()\\n    l = list(map(int,input().split()))\\n    for idx, i in enumerate(l):\\n        #print(idx, i)\\n        if i not in d1:\\n            d1[i] = [1,idx,idx]\\n        else:\\n            d1[i][0]+=1\\n            d1[i][2]=idx\\n\\n    for k,v in d1.items():\\n        if v[0] in d2:\\n            d2[v[0]].append(k)\\n        else:\\n            d2[v[0]] = [k]\\n\\n    sd2 = sorted(d2.items(), reverse=True)\\n    # print(d1)\\n    # print(d2)\\n    # print(sd2)\\n\\n\\n    v = sd2[0][1]\\n\\n    if len(v) == 1:\\n        print(d1[v[0]][1] + 1, d1[v[0]][2] + 1)\\n    else:\\n        shortestDistance = 10**5\\n        leftIndex = -1\\n        rightIndex = -1\\n        for elem in v:\\n            if d1[elem][2] - d1[elem][1] < shortestDistance:\\n                shortestDistance = d1[elem][2] - d1[elem][1]\\n                leftIndex = d1[elem][1]\\n                rightIndex = d1[elem][2]\\n        print(leftIndex + 1, rightIndex + 1)\\n\\n\\n\\n\\nsolve()\",\"language\":\"python\",\"split\":\"train\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Alice and Borys are playing tennis.\\n\\nA tennis match consists of games. In each game, one of the players is serving and the other one is receiving.\\n\\nPlayers serve in turns: after a game where Alice is serving follows a game where Borys is serving, and vice versa.\\n\\nEach game ends with a victory of one of the players. If a game is won by the serving player, it's said that this player holds serve. If a game is won by the receiving player, it's said that this player breaks serve.\\n\\nIt is known that Alice won a games and Borys won b games during the match. It is unknown who served first and who won which games.\\n\\nFind all values of k such that exactly k breaks could happen during the match between Alice and Borys in total.\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 10^3). Description of the test cases follows.\\n\\nEach of the next t lines describes one test case and contains two integers a and b (0 \u2264 a, b \u2264 10^5; a + b > 0) \u2014 the number of games won by Alice and Borys, respectively.\\n\\nIt is guaranteed that the sum of a + b over all test cases does not exceed 2 \u22c5 10^5.\\n\\nOutput\\n\\nFor each test case print two lines.\\n\\nIn the first line, print a single integer m (1 \u2264 m \u2264 a + b + 1) \u2014 the number of values of k such that exactly k breaks could happen during the match.\\n\\nIn the second line, print m distinct integers k_1, k_2, \u2026, k_m (0 \u2264 k_1 < k_2 < \u2026 < k_m \u2264 a + b) \u2014 the sought values of k in increasing order.\\n\\nExample\\n\\nInput\\n\\n\\n3\\n2 1\\n1 1\\n0 5\\n\\n\\nOutput\\n\\n\\n4\\n0 1 2 3\\n2\\n0 2\\n2\\n2 3\\n\\nNote\\n\\nIn the first test case, any number of breaks between 0 and 3 could happen during the match: \\n\\n  * Alice holds serve, Borys holds serve, Alice holds serve: 0 breaks; \\n  * Borys holds serve, Alice holds serve, Alice breaks serve: 1 break; \\n  * Borys breaks serve, Alice breaks serve, Alice holds serve: 2 breaks; \\n  * Alice breaks serve, Borys breaks serve, Alice breaks serve: 3 breaks. \\n\\n\\n\\nIn the second test case, the players could either both hold serves (0 breaks) or both break serves (2...\\nUsing cpp can you solve the prior task?\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst int OO = 1e9;\\nconst double EPS = 1e-9;\\ntemplate <class T>\\nvoid _db(const char* dbStr, T e) {\\n  cout << dbStr << \\\" = \\\" << e << endl;\\n}\\ntemplate <class T, class... L>\\nvoid _db(const char* dbStr, T e, L... r) {\\n  while (*dbStr != ',') cout << *dbStr++;\\n  cout << \\\" = \\\" << e << ',';\\n  _db(dbStr + 1, r...);\\n}\\ntemplate <class S, class T>\\nostream& operator<<(ostream& o, const map<S, T>& v) {\\n  o << \\\"[\\\";\\n  int i = 0;\\n  for (const pair<S, T>& pr : v)\\n    o << (!i++ ? \\\"\\\" : \\\", \\\") << \\\"{\\\" << pr.first << \\\" : \\\" << pr.second << \\\"}\\\";\\n  return o << \\\"]\\\";\\n}\\ntemplate <template <class, class...> class S, class T, class... L>\\nostream& operator<<(ostream& o, const S<T, L...>& v) {\\n  o << \\\"[\\\";\\n  int i = 0;\\n  for (const auto& e : v) o << (!i++ ? \\\"\\\" : \\\", \\\") << e;\\n  return o << \\\"]\\\";\\n}\\ntemplate <class S, class T>\\nostream& operator<<(ostream& o, const pair<S, T>& pr) {\\n  return o << \\\"(\\\" << pr.first << \\\", \\\" << pr.second << \\\")\\\";\\n}\\nostream& operator<<(ostream& o, const string& s) {\\n  for (const char& c : s) o << c;\\n  return o;\\n}\\ntemplate <class T>\\nusing V = vector<T>;\\ntemplate <class T>\\nusing VV = V<V<T>>;\\ntemplate <class T>\\nusing VVV = VV<V<T>>;\\nusing ll = long long;\\nusing pii = pair<int, int>;\\nusing vi = V<int>;\\nusing vii = V<pii>;\\nusing vvi = VV<int>;\\nusing mii = map<int, int>;\\nusing umii = unordered_map<int, int>;\\nusing si = set<int>;\\nusing usi = unordered_set<int>;\\nmt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());\\nint main() {\\n  ios::sync_with_stdio(false);\\n  cout.precision(10);\\n  cin.tie(0);\\n  int T;\\n  cin >> T;\\n  for (int tc = 1; tc <= T; ++tc) {\\n    int a, b;\\n    cin >> a >> b;\\n    si ans;\\n    for (int I = 0; I <= 1; ++I) {\\n      int odd = (a + b + 1) \\/ 2, even = (a + b) \\/ 2;\\n      for (int x = 0; x <= min(odd, a); ++x) {\\n        int rem = a - x;\\n        if (rem > even) continue;\\n        ans.insert((odd - x) + rem);\\n      }\\n      swap(a, b);\\n    }\\n    cout << int(ans.size()) << '\\\\n';\\n    for (auto& elem : ans) {\\n      cout << elem << ' ';\\n    }\\n    cout <<...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"YouKn0wWho has two even integers x and y. Help him to find an integer n such that 1 \u2264 n \u2264 2 \u22c5 10^{18} and n mod x = y mod n. Here, a mod b denotes the remainder of a after division by b. If there are multiple such integers, output any. It can be shown that such an integer always exists under the given constraints.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 10^5) \u2014 the number of test cases.\\n\\nThe first and only line of each test case contains two integers x and y (2 \u2264 x, y \u2264 10^9, both are even).\\n\\nOutput\\n\\nFor each test case, print a single integer n (1 \u2264 n \u2264 2 \u22c5 10^{18}) that satisfies the condition mentioned in the statement. If there are multiple such integers, output any. It can be shown that such an integer always exists under the given constraints.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n4 8\\n4 2\\n420 420\\n69420 42068\\n\\n\\nOutput\\n\\n\\n4\\n10\\n420\\n9969128\\n\\nNote\\n\\nIn the first test case, 4 mod 4 = 8 mod 4 = 0.\\n\\nIn the second test case, 10 mod 4 = 2 mod 10 = 2.\\n\\nIn the third test case, 420 mod 420 = 420 mod 420 = 0.\",\"targets\":\"import java.io.BufferedReader; \\nimport java.io.IOException; \\nimport java.io.InputStreamReader; \\nimport java.util.*;\\nimport java.math.*;\\npublic class Solution \\n{ \\n\\tstatic long MAX = 2*(long)1e18;\\n    static class FastReader \\n    { \\n        BufferedReader br; \\n        StringTokenizer st; \\n  \\n        public FastReader() \\n        { \\n            br = new BufferedReader(new\\n                     InputStreamReader(System.in)); \\n        } \\n  \\n        String next() \\n        { \\n            while (st == null || !st.hasMoreElements()) \\n            { \\n                try\\n                { \\n                    st = new StringTokenizer(br.readLine()); \\n                } \\n                catch (IOException  e) \\n                { \\n                    e.printStackTrace(); \\n                } \\n            } \\n            return st.nextToken(); \\n        } \\n  \\n        int nextInt() \\n        { \\n            return Integer.parseInt(next()); \\n        } \\n  \\n        long nextLong() \\n        { \\n            return Long.parseLong(next()); \\n        } \\n  \\n        double nextDouble() \\n        { \\n            return Double.parseDouble(next()); \\n        } \\n  \\n        String nextLine() \\n        { \\n            String str = \\\"\\\"; \\n            try\\n            { \\n                str = br.readLine(); \\n            } \\n            catch (IOException e) \\n            { \\n                e.printStackTrace(); \\n            } \\n            return str; \\n        } \\n    } \\n  \\n    public static void main(String[] args) \\n    { \\n        FastReader s=new FastReader(); \\n        int T = s.nextInt(); \\n\\t\\twhile(T-->=1)\\n\\t\\t{\\n\\t\\t\\tlong x = s.nextInt();\\n\\t\\t\\tlong y = s.nextInt();\\n\\t\\t\\t\\n\\t\\t\\tif(x>y)\\n\\t\\t\\t{\\n\\t\\t\\t\\tSystem.out.println(x+y);\\n\\t\\t\\t}\\n\\t\\t\\telse if(x==y)\\n\\t\\t\\t{\\n\\t\\t\\t\\tSystem.out.println(x);\\n\\t\\t\\t}\\n\\t\\t\\telse\\n\\t\\t\\t{\\n\\t\\t\\t\\t\\/\\/y>x\\n\\t\\t\\t\\tif(y%x==0)\\n\\t\\t\\t\\t\\tSystem.out.println(x);\\n\\t\\t\\t\\telse\\n\\t\\t\\t\\t{\\n\\t\\t\\t\\t\\tSystem.out.println(y-(y%x)\\/2);\\n\\t\\t\\t\\t}\\n\\t\\t\\t}\\n\\t\\t}\\n    } \\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"JAVA solution for \\\"Casimir has a string s which consists of capital Latin letters 'A', 'B', and 'C' only. Each turn he can choose to do one of the two following actions:\\n\\n  * he can either erase exactly one letter 'A' and exactly one letter 'B' from arbitrary places of the string (these letters don't have to be adjacent); \\n  * or he can erase exactly one letter 'B' and exactly one letter 'C' from arbitrary places in the string (these letters don't have to be adjacent). \\n\\n\\n\\nTherefore, each turn the length of the string is decreased exactly by 2. All turns are independent so for each turn, Casimir can choose any of two possible actions.\\n\\nFor example, with s = \\\"ABCABC\\\" he can obtain a string s = \\\"ACBC\\\" in one turn (by erasing the first occurrence of 'B' and the second occurrence of 'A'). There are also many other options for a turn aside from this particular example.\\n\\nFor a given string s determine whether there is a sequence of actions leading to an empty string. In other words, Casimir's goal is to erase all letters from the string. Is there a way to do this?\\n\\nInput\\n\\nThe first line contains an integer t (1 \u2264 t \u2264 1000) \u2014 the number of test cases.\\n\\nEach test case is described by one string s, for which you need to determine if it can be fully erased by some sequence of turns. The string s consists of capital letters 'A', 'B', 'C' and has a length from 1 to 50 letters, inclusive.\\n\\nOutput\\n\\nPrint t lines, each line containing the answer to the corresponding test case. The answer to a test case should be YES if there is a way to fully erase the corresponding string and NO otherwise.\\n\\nYou may print every letter in any case you want (so, for example, the strings yEs, yes, Yes, and YES will all be recognized as positive answers).\\n\\nExample\\n\\nInput\\n\\n\\n6\\nABACAB\\nABBA\\nAC\\nABC\\nCABCBB\\nBCBCBCBCBCBCBCBC\\n\\n\\nOutput\\n\\n\\nNO\\nYES\\nNO\\nNO\\nYES\\nYES\\\":\",\"targets\":\"import java.util.*;\\npublic class Main\\n{\\n\\tpublic static void main(String[] args) {\\n\\t\\tScanner sc=new Scanner(System.in);\\n\\t\\tint t=sc.nextInt(),n,ac=0,bc=0,cc=0;\\n\\t\\tString a;\\n\\t\\twhile(t>0)\\n\\t\\t{\\n\\t\\t    t--;\\n\\t\\t    a=sc.next();\\n\\t\\t    n=a.length();\\n\\t\\t    ac=0;\\n\\t\\t    bc=0;\\n\\t\\t    cc=0;\\n\\t\\t    for(int i=0;i<n;i++)\\n\\t\\t    {\\n\\t\\t        if(a.charAt(i)=='A')\\n\\t\\t        {\\n\\t\\t         ac++;   \\n\\t\\t        }\\n\\t\\t        else if(a.charAt(i)=='B')\\n\\t\\t        {\\n\\t\\t          bc++;  \\n\\t\\t        }\\n\\t\\t        else\\n\\t\\t        {\\n\\t\\t            cc++;\\n\\t\\t        }\\n\\t\\t    }\\n\\t\\t    if(ac+cc!=bc)\\n\\t\\t    {\\n\\t\\t       System.out.println(\\\"NO\\\");\\n\\t\\t    }\\n\\t\\t    else\\n\\t\\t    {\\n\\t\\t        System.out.println(\\\"YES\\\");\\n\\t\\t    }\\n\\t\\t}\\n\\t}\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in PYTHON3?\\nYou are given strings S and T, consisting of lowercase English letters. It is guaranteed that T is a permutation of the string abc. \\n\\nFind string S', the lexicographically smallest permutation of S such that T is not a subsequence of S'.\\n\\nString a is a permutation of string b if the number of occurrences of each distinct character is the same in both strings.\\n\\nA string a is a subsequence of a string b if a can be obtained from b by deletion of several (possibly, zero or all) elements.\\n\\nA string a is lexicographically smaller than a string b if and only if one of the following holds:\\n\\n  * a is a prefix of b, but a \u2260 b;\\n  * in the first position where a and b differ, the string a has a letter that appears earlier in the alphabet than the corresponding letter in b.\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains a single integer t (1 \u2264 t \u2264 1000) \u2014 the number of test cases. Description of the test cases follows.\\n\\nThe first line of each test case contains a string S (1 \u2264 |S| \u2264 100), consisting of lowercase English letters.\\n\\nThe second line of each test case contains a string T that is a permutation of the string abc. (Hence, |T| = 3).\\n\\nNote that there is no limit on the sum of |S| across all test cases.\\n\\nOutput\\n\\nFor each test case, output a single string S', the lexicographically smallest permutation of S such that T is not a subsequence of S'.\\n\\nExample\\n\\nInput\\n\\n\\n7\\nabacaba\\nabc\\ncccba\\nacb\\ndbsic\\nbac\\nabracadabra\\nabc\\ndddddddddddd\\ncba\\nbbc\\nabc\\nac\\nabc\\n\\n\\nOutput\\n\\n\\naaaacbb\\nabccc\\nbcdis\\naaaaacbbdrr\\ndddddddddddd\\nbbc\\nac\\n\\nNote\\n\\nIn the first test case, both aaaabbc and aaaabcb are lexicographically smaller than aaaacbb, but they contain abc as a subsequence.\\n\\nIn the second test case, abccc is the smallest permutation of cccba and does not contain acb as a subsequence.\\n\\nIn the third test case, bcdis is the smallest permutation of dbsic and does not contain bac as a subsequence.\",\"targets\":\"#Mamma don't raises quitter.................................................\\n#manan is improving, keep hustling manan bhai ;)\\nfrom collections import deque as de\\nimport math\\nimport sys\\nfrom math import sqrt as sq\\nfrom math import floor as fl\\nfrom math import ceil as ce\\nfrom sys import stdin, stdout\\n\\nsys.setrecursionlimit(10**7)\\nfrom collections import Counter as cnt\\nfrom functools import  reduce\\n\\nfrom itertools import groupby as gb\\n#from fractions import Fraction as fr\\nfrom bisect import bisect_left as bl, bisect_right as br\\nfrom typing import Coroutine\\n\\ndef factors(n):    \\n    return set(reduce(list.__add__, \\n                ([i, n\\/\\/i] for i in range(1, int(n**0.5) + 1) if n % i == 0)))\\n    \\nclass My_stack():\\n    def __init__(self):\\n        self.data = []\\n    def my_push(self, x):\\n        return (self.data.append(x))\\n    def my_pop(self):\\n        return (self.data.pop())\\n    def __iter__(self):\\n        return iter(self.data)\\n    def my_peak(self):\\n        return (self.data[-1])\\n    def my_contains(self, x):\\n        return (self.data.count(x))\\n    def my_show_all(self):\\n        return (self.data)\\n    def isEmpty(self):\\n      return len(self.data)==0\\n    def len(self):\\n        return len(self.data)\\n    \\n\\narrStack = My_stack() \\n\\nclass graph():\\n    def __init__(self):\\n        self.graphdict = {}\\n    def add_edge(self, node, neighbor):\\n        if node not in self.graphdict:\\n            self.graphdict[node]=[neighbor]\\n        else:\\n            self.graphdict[node].append(neighbor)\\n    def show_edge(self):\\n        for node in self.graphdict:\\n            for neighbors in self.graphdict:\\n                print(node, neighbors)\\n    def show_graph(self):\\n        return self.graphdict\\n\\n    \\n\\n\\n    \\n            \\n\\n#decimal to binary   \\ndef decimalToBinary(n): \\n    return bin(n).replace(\\\"0b\\\", \\\"\\\")\\n#binary to decimal\\ndef binarytodecimal(n):\\n    return int(n,2)\\n\\ndef isPrime(n) : \\n\\tif (n <= 1) : \\n\\t\\treturn False\\n\\tif (n <= 3) : \\n\\t\\treturn True\\n\\tif (n % 2 == 0 or n % 3 == 0) : \\n\\t\\treturn False\\n\\ti = 5\\n\\twhile(i * i <= n) : \\n\\t\\tif (n % i...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in PYTHON3?\\nPolycarp likes squares and cubes of positive integers. Here is the beginning of the sequence of numbers he likes: 1, 4, 8, 9, ....\\n\\nFor a given number n, count the number of integers from 1 to n that Polycarp likes. In other words, find the number of such x that x is a square of a positive integer number or a cube of a positive integer number (or both a square and a cube simultaneously).\\n\\nInput\\n\\nThe first line contains an integer t (1 \u2264 t \u2264 20) \u2014 the number of test cases.\\n\\nThen t lines contain the test cases, one per line. Each of the lines contains one integer n (1 \u2264 n \u2264 10^9).\\n\\nOutput\\n\\nFor each test case, print the answer you are looking for \u2014 the number of integers from 1 to n that Polycarp likes.\\n\\nExample\\n\\nInput\\n\\n\\n6\\n10\\n1\\n25\\n1000000000\\n999999999\\n500000000\\n\\n\\nOutput\\n\\n\\n4\\n1\\n6\\n32591\\n32590\\n23125\",\"targets\":\"import math\\nn=int(input())\\nfor x in range(0,n):\\n    mylist=[]\\n    num=int(input())\\n    i=1\\n    while i**2<=num:\\n        mylist.append(i**2)\\n        i+=1\\n        \\n    j=1\\n    while j**3<=num:\\n        if int(math.sqrt(j**3))**2!=j**3:\\n            mylist.append(j**3)\\n        j+=1\\n            \\n    print(len(mylist))\",\"language\":\"python\",\"split\":\"test\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"It is a simplified version of problem F2. The difference between them is the constraints (F1: k \u2264 2, F2: k \u2264 10).\\n\\nYou are given an integer n. Find the minimum integer x such that x \u2265 n and the number x is k-beautiful.\\n\\nA number is called k-beautiful if its decimal representation having no leading zeroes contains no more than k different digits. E.g. if k = 2, the numbers 3434443, 55550, 777 and 21 are k-beautiful whereas the numbers 120, 445435 and 998244353 are not.\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases. Then t test cases follow.\\n\\nEach test case consists of one line containing two integers n and k (1 \u2264 n \u2264 10^9, 1 \u2264 k \u2264 2).\\n\\nOutput\\n\\nFor each test case output on a separate line x \u2014 the minimum k-beautiful integer such that x \u2265 n.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n1 1\\n221 2\\n177890 2\\n998244353 1\\n\\n\\nOutput\\n\\n\\n1\\n221\\n181111\\n999999999\",\"targets\":\"import collections\\nimport bisect\\nfrom itertools import combinations\\n\\nt = int(input())\\n\\nall_cur = set()\\nfor x in combinations(['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'], 2):\\n    for l in range(1, 10):\\n        cur = list(range(l))\\n        for i in range(l+1):\\n            for y in combinations(cur, i):\\n                cur_res = ''\\n                for j in range(l):\\n                    if j in y:\\n                        cur_res += x[0]\\n                    else:\\n                        cur_res += x[1]\\n                if cur_res[0] == '0' and cur_res != '0':\\n                    continue\\n                all_cur.add(int(cur_res))\\n\\nall_cur = list(all_cur)\\nall_cur.sort()\\n# print(len(all_cur))\\n# print(all_cur)\\n\\nfor case in range(t):\\n    n, k = list(map(int, input().split()))\\n    if n == 1000000000:\\n        if k == 2:\\n            print(1000000000)\\n        else:\\n            print(1111111111)\\n        continue\\n    if k == 1:\\n        cur = []\\n        for i in range(0, 10):\\n            cur.append(str(i) * len(str(n)))\\n        res = float('inf')\\n        for x in cur:\\n            if len(str(int(x))) != len(x):\\n                continue\\n            if int(x) >= n:\\n                res = min(res, int(x))\\n        print(res)\\n    else:\\n        index = bisect.bisect_left(all_cur, n)\\n        # print(index, all_cur[index], n)\\n        print(all_cur[index])\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"n towns are arranged in a circle sequentially. The towns are numbered from 1 to n in clockwise order. In the i-th town, there lives a singer with a repertoire of a_i minutes for each i \u2208 [1, n].\\n\\nEach singer visited all n towns in clockwise order, starting with the town he lives in, and gave exactly one concert in each town. In addition, in each town, the i-th singer got inspired and came up with a song that lasts a_i minutes. The song was added to his repertoire so that he could perform it in the rest of the cities.\\n\\nHence, for the i-th singer, the concert in the i-th town will last a_i minutes, in the (i + 1)-th town the concert will last 2 \u22c5 a_i minutes, ..., in the ((i + k) mod n + 1)-th town the duration of the concert will be (k + 2) \u22c5 a_i, ..., in the town ((i + n - 2) mod n + 1) \u2014 n \u22c5 a_i minutes.\\n\\nYou are given an array of b integer numbers, where b_i is the total duration of concerts in the i-th town. Reconstruct any correct sequence of positive integers a or say that it is impossible.\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 10^3) \u2014 the number of test cases. Then the test cases follow.\\n\\nEach test case consists of two lines. The first line contains a single integer n (1 \u2264 n \u2264 4 \u22c5 10^4) \u2014 the number of cities. The second line contains n integers b_1, b_2, ..., b_n (1 \u2264 b_i \u2264 10^{9}) \u2014 the total duration of concerts in i-th city.\\n\\nThe sum of n over all test cases does not exceed 2 \u22c5 10^5.\\n\\nOutput\\n\\nFor each test case, print the answer as follows:\\n\\nIf there is no suitable sequence a, print NO. Otherwise, on the first line print YES, on the next line print the sequence a_1, a_2, ..., a_n of n integers, where a_i (1 \u2264 a_i \u2264 10^{9}) is the initial duration of repertoire of the i-th singer. If there are multiple answers, print any of them.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n3\\n12 16 14\\n1\\n1\\n3\\n1 2 3\\n6\\n81 75 75 93 93 87\\n\\n\\nOutput\\n\\n\\nYES\\n3 1 3 \\nYES\\n1 \\nNO\\nYES\\n5 5 4 1 4 5 \\n\\nNote\\n\\nLet's consider the 1-st test case of the example:\\n\\n  1. the 1-st singer in the 1-st city will give a concert for 3 minutes, in the 2-nd \u2014...\\nThe above is tricky. Write me a correct solution in PYTHON3.\",\"targets\":\"from math import *\\nt = int(input())\\n\\ndef intify(x):\\n    if floor(x) == floor(x+0.000001) == floor(x-0.000001):\\n        return x\\n    return round(x)\\n\\nfor pp in range(t):\\n    sus = False\\n    n = int(input())\\n    sumz = sum(range(1,n+1))\\n    lis = list(map(int, input().split()))\\n    ans = [0 for i in range(n)]\\n    if sum(lis)%sumz!=0:\\n        sus = True\\n    k = sum(lis)\\/\\/sumz\\n    for i in range(n):\\n        if (lis[i] - (lis[(i+1)%n]  - k))%(n) != 0:\\n            sus = True\\n        ans[(i+1)%n] = (lis[i] - (lis[(i+1)%n]  - k))\\/\\/(n)\\n    \\n    for i in range(n):\\n        if ans[i] <1:\\n            sus = True\\n\\n    if sus:\\n        print(\\\"NO\\\")\\n    else:\\n        print(\\\"YES\\\")\\n        print(*ans)\",\"language\":\"python\",\"split\":\"test\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Shohag has an integer sequence a_1, a_2, \u2026, a_n. He can perform the following operation any number of times (possibly, zero):\\n\\n  * Select any positive integer k (it can be different in different operations). \\n  * Choose any position in the sequence (possibly the beginning or end of the sequence, or in between any two elements) and insert k into the sequence at this position. \\n  * This way, the sequence a changes, and the next operation is performed on this changed sequence. \\n\\n\\n\\nFor example, if a=[3,3,4] and he selects k = 2, then after the operation he can obtain one of the sequences [\\\\underline{2},3,3,4], [3,\\\\underline{2},3,4], [3,3,\\\\underline{2},4], or [3,3,4,\\\\underline{2}].\\n\\nShohag wants this sequence to satisfy the following condition: for each 1 \u2264 i \u2264 |a|, a_i \u2264 i. Here, |a| denotes the size of a.\\n\\nHelp him to find the minimum number of operations that he has to perform to achieve this goal. We can show that under the constraints of the problem it's always possible to achieve this goal in a finite number of operations.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 200) \u2014 the number of test cases.\\n\\nThe first line of each test case contains a single integer n (1 \u2264 n \u2264 100) \u2014 the initial length of the sequence.\\n\\nThe second line of each test case contains n integers a_1, a_2, \u2026, a_n (1 \u2264 a_i \u2264 10^9) \u2014 the elements of the sequence.\\n\\nOutput\\n\\nFor each test case, print a single integer \u2014 the minimum number of operations needed to perform to achieve the goal mentioned in the statement.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n3\\n1 3 4\\n5\\n1 2 5 7 4\\n1\\n1\\n3\\n69 6969 696969\\n\\n\\nOutput\\n\\n\\n1\\n3\\n0\\n696966\\n\\nNote\\n\\nIn the first test case, we have to perform at least one operation, as a_2=3>2. We can perform the operation [1, 3, 4] \u2192 [1, \\\\underline{2}, 3, 4] (the newly inserted element is underlined), now the condition is satisfied.\\n\\nIn the second test case, Shohag can perform the following operations:\\n\\n[1, 2, 5, 7, 4] \u2192 [1, 2, \\\\underline{3}, 5, 7, 4] \u2192 [1, 2, 3, \\\\underline{4}, 5, 7, 4] \u2192 [1, 2, 3, 4, 5, \\\\underline{3}, 7, 4].\\n\\nIn the third...\\nfor g\",\"targets\":\"in range(int(input())):\\n    l = int(input())\\n    a = [int(x) for x in input().split()]\\n    if len(a) == 1:\\n        c = a[0] - 1\\n        print(c)\\n    else:\\n        nu = []\\n        for i in range(l):\\n            d = a[i] - a.index(a[i]) - 1\\n            nu.append(d)\\n        print(max(nu))\",\"language\":\"python\",\"split\":\"test\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"<image>\\n\\nWilliam has a favorite bracket sequence. Since his favorite sequence is quite big he provided it to you as a sequence of positive integers c_1, c_2, ..., c_n where c_i is the number of consecutive brackets \\\"(\\\" if i is an odd number or the number of consecutive brackets \\\")\\\" if i is an even number.\\n\\nFor example for a bracket sequence \\\"((())()))\\\" a corresponding sequence of numbers is [3, 2, 1, 3].\\n\\nYou need to find the total number of continuous subsequences (subsegments) [l, r] (l \u2264 r) of the original bracket sequence, which are regular bracket sequences.\\n\\nA bracket sequence is called regular if it is possible to obtain correct arithmetic expression by inserting characters \\\"+\\\" and \\\"1\\\" into this sequence. For example, sequences \\\"(())()\\\", \\\"()\\\" and \\\"(()(()))\\\" are regular, while \\\")(\\\", \\\"(()\\\" and \\\"(()))(\\\" are not.\\n\\nInput\\n\\nThe first line contains a single integer n (1 \u2264 n \u2264 1000), the size of the compressed sequence.\\n\\nThe second line contains a sequence of integers c_1, c_2, ..., c_n (1 \u2264 c_i \u2264 10^9), the compressed sequence.\\n\\nOutput\\n\\nOutput a single integer \u2014 the total number of subsegments of the original bracket sequence, which are regular bracket sequences.\\n\\nIt can be proved that the answer fits in the signed 64-bit integer data type.\\n\\nExamples\\n\\nInput\\n\\n\\n5\\n4 1 2 3 1\\n\\n\\nOutput\\n\\n\\n5\\n\\n\\nInput\\n\\n\\n6\\n1 3 2 1 2 4\\n\\n\\nOutput\\n\\n\\n6\\n\\n\\nInput\\n\\n\\n6\\n1 1 1 1 2 2\\n\\n\\nOutput\\n\\n\\n7\\n\\nNote\\n\\nIn the first example a sequence (((()(()))( is described. This bracket sequence contains 5 subsegments which form regular bracket sequences:\\n\\n  1. Subsequence from the 3rd to 10th character: (()(()))\\n  2. Subsequence from the 4th to 5th character: ()\\n  3. Subsequence from the 4th to 9th character: ()(())\\n  4. Subsequence from the 6th to 9th character: (())\\n  5. Subsequence from the 7th to 8th character: ()\\n\\n\\n\\nIn the second example a sequence ()))(()(()))) is described.\\n\\nIn the third example a sequence ()()(()) is described.\\nSolve the task in PYTHON3.\",\"targets\":\"n = int(input())\\narr = list(map(int,input().split()))\\nap = []\\nans = 0\\nfor i in range(0,n-1,2):\\n    mn = 0\\n    c = 0\\n    for j in range(i+1,n,2):\\n        if j-i>1:\\n            mn = min(mn,c-arr[j-2])\\n            c+= arr[j-1]-arr[j-2]\\n        ans+= max(-1,min(arr[i]+mn,arr[j]+mn-c))+(j-i>1)\\nprint(ans)\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Polycarp had an array a of 3 positive integers. He wrote out the sums of all non-empty subsequences of this array, sorted them in non-decreasing order, and got an array b of 7 integers.\\n\\nFor example, if a = \\\\{1, 4, 3\\\\}, then Polycarp wrote out 1, 4, 3, 1 + 4 = 5, 1 + 3 = 4, 4 + 3 = 7, 1 + 4 + 3 = 8. After sorting, he got an array b = \\\\{1, 3, 4, 4, 5, 7, 8\\\\}.\\n\\nUnfortunately, Polycarp lost the array a. He only has the array b left. Help him to restore the array a.\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 5000) \u2014 the number of test cases.\\n\\nEach test case consists of one line which contains 7 integers b_1, b_2, ..., b_7 (1 \u2264 b_i \u2264 10^9; b_i \u2264 b_{i+1}). \\n\\nAdditional constraint on the input: there exists at least one array a which yields this array b as described in the statement.\\n\\nOutput\\n\\nFor each test case, print 3 integers \u2014 a_1, a_2 and a_3. If there can be several answers, print any of them.\\n\\nExample\\n\\nInput\\n\\n\\n5\\n1 3 4 4 5 7 8\\n1 2 3 4 5 6 7\\n300000000 300000000 300000000 600000000 600000000 600000000 900000000\\n1 1 2 999999998 999999999 999999999 1000000000\\n1 2 2 3 3 4 5\\n\\n\\nOutput\\n\\n\\n1 4 3\\n4 1 2\\n300000000 300000000 300000000\\n999999998 1 1\\n1 2 2\\n\\nNote\\n\\nThe subsequence of the array a is a sequence that can be obtained from a by removing zero or more of its elements.\\n\\nTwo subsequences are considered different if index sets of elements included in them are different. That is, the values of the elements don't matter in the comparison of subsequences. In particular, any array of length 3 has exactly 7 different non-empty subsequences.\\n# coo\",\"targets\":\"k your dish here\\nfor _ in range(int(input())):\\n    b=list(map(int,input().split()))\\n    first=b[0]\\n    last=b[-1]\\n    res=[first]\\n    for i in range(1,len(b)-1):\\n        for j in range(i+1,len(b)-1):\\n            if b[i]+b[j]==last-first:\\n                res.append(b[i])\\n                res.append(b[j])\\n                break\\n    print(*res)\",\"language\":\"python\",\"split\":\"test\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Fedya studies in a gymnasium. Fedya's maths hometask is to calculate the following expression:\\n\\n(1n + 2n + 3n + 4n) mod 5\\n\\nfor given value of n. Fedya managed to complete the task. Can you? Note that given number n can be extremely large (e.g. it can exceed any integer type of your programming language).\\n\\nInput\\n\\nThe single line contains a single integer n (0 \u2264 n \u2264 10105). The number doesn't contain any leading zeroes.\\n\\nOutput\\n\\nPrint the value of the expression without leading zeros.\\n\\nExamples\\n\\nInput\\n\\n4\\n\\n\\nOutput\\n\\n4\\n\\n\\nInput\\n\\n124356983594583453458888889\\n\\n\\nOutput\\n\\n0\\n\\nNote\\n\\nOperation x mod y means taking remainder after division x by y.\\n\\nNote to the first sample:\\n\\n<image>\\nThe above is tricky. Write me a correct solution in PYTHON.\",\"targets\":\"n = input()\\nn = n%4\\nprint (1**n + 2**n + 3**n + 4**n)%5\",\"language\":\"python\",\"split\":\"train\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"A robot cleaner is placed on the floor of a rectangle room, surrounded by walls. The floor consists of n rows and m columns. The rows of the floor are numbered from 1 to n from top to bottom, and columns of the floor are numbered from 1 to m from left to right. The cell on the intersection of the r-th row and the c-th column is denoted as (r,c). The initial position of the robot is (r_b, c_b).\\n\\nIn one second, the robot moves by dr rows and dc columns, that is, after one second, the robot moves from the cell (r, c) to (r + dr, c + dc). Initially dr = 1, dc = 1. If there is a vertical wall (the left or the right walls) in the movement direction, dc is reflected before the movement, so the new value of dc is -dc. And if there is a horizontal wall (the upper or lower walls), dr is reflected before the movement, so the new value of dr is -dr.\\n\\nEach second (including the moment before the robot starts moving), the robot cleans every cell lying in the same row or the same column as its position. There is only one dirty cell at (r_d, c_d). The job of the robot is to clean that dirty cell.\\n\\n<image> Illustration for the first example. The blue arc is the robot. The red star is the target dirty cell. Each second the robot cleans a row and a column, denoted by yellow stripes.\\n\\nGiven the floor size n and m, the robot's initial position (r_b, c_b) and the dirty cell's position (r_d, c_d), find the time for the robot to do its job.\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 10^4). Description of the test cases follows.\\n\\nA test case consists of only one line, containing six integers n, m, r_b, c_b, r_d, and c_d (1 \u2264 n, m \u2264 100, 1 \u2264 r_b, r_d \u2264 n, 1 \u2264 c_b, c_d \u2264 m) \u2014 the sizes of the room, the initial position of the robot and the position of the dirt cell.\\n\\nOutput\\n\\nFor each test case, print an integer \u2014 the time for the robot to clean the dirty cell. We can show that the robot always cleans the dirty cell eventually.\\n\\nExample\\n\\nInput\\n\\n\\n5\\n10 10 6 1 2 8\\n10 10 9 9 1...\\nSolve the task in JAVA.\",\"targets\":\"import java.io.*;\\nimport java.util.*;\\n\\npublic class A {\\n    public static void main(String[] args) {\\n        FastReader in = new FastReader();\\n\\n        int T = in.nextInt();\\n        for(int ttt = 1; ttt <= T; ttt++) {\\n            int n = in.nextInt();\\n            int m = in.nextInt();\\n            int rb = in.nextInt();\\n            int cb = in.nextInt();\\n            int rd = in.nextInt();\\n            int cd = in.nextInt();\\n        \\n            int ans = 0;\\n            int dr = 1, dc = 1;\\n            while(rb!=rd && cb!=cd) {\\n                if(dr>0 && rb+dr>n) dr *= -1;\\n                else if(dr<0 && rb+dr<1) dr *= -1;\\n                if(dc>0 && cb+dc>m) dc *= -1;\\n                else if(dc<0 && cb+dc<1) dc *= -1;\\n\\n                rb+=dr;\\n                cb+=dc;\\n                ans++;\\n            }\\n            System.out.println(ans);\\n        }\\n    }\\n\\n    static class FastReader {\\n        BufferedReader br;\\n        StringTokenizer st;\\n        public FastReader() { br = new BufferedReader(new InputStreamReader(System.in)); }\\n        String next() {\\n            while (st == null || !st.hasMoreElements()) {\\n                try { st = new StringTokenizer(br.readLine()); }\\n                catch(IOException e) { e.printStackTrace(); }\\n            }\\n            return st.nextToken();\\n        }\\n        int nextInt() { return Integer.parseInt(next()); }\\n        long nextLong() { return Long.parseLong(next()); }\\n        double nextDouble() { return Double.parseDouble(next()); }\\n        String nextLine() {\\n            String str = \\\"\\\";\\n            try { str = br.readLine(); }\\n            catch(IOException e) { e.printStackTrace(); }\\n            return str;\\n        }\\n        int[] readInt(int size) {\\n            int[] arr = new int[size];\\n            for(int i = 0; i < size; i++)\\n                arr[i] = Integer.parseInt(next());\\n            return arr;\\n        }\\n        long[] readLong(int size) {\\n            long[] arr = new long[size];\\n            for(int i = 0; i < size; i++)\\n                arr[i] =...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Create a program that calculates and outputs the surface distance by inputting the north latitude and east longitude of two cities on the earth. However, the earth is a sphere with a radius of 6,378.1 km, and the surface distance between two points is the shortest distance along this sphere. Also, in the southern hemisphere, we will use 0 to -90 degrees north latitude without using south latitude, and 180 to 360 degrees east longitude without using west longitude even to the west of the Greenwich meridional line. Calculate the ground surface distance in km, round off to the nearest whole number, and output as an integer value.\\n\\nBelow are examples of north latitude and east longitude of major cities.\\n\\nPlace name | North latitude (degree) | East longitude (degree)\\n--- | --- | ---\\nTokyo | 35.68 | 139.77\\nSingapore | 1.37 | 103.92\\nSydney | -33.95 | 151.18\\nChicago | 41.78 | 272.25\\nBuenos Aires | -34.58 | 301.52\\nLondon | 51.15 | 359.82\\n\\n\\n\\n\\n\\nInput\\n\\nA sequence of multiple datasets is given as input. The end of the input is indicated by -1 four lines. Each dataset is given in the following format:\\n\\n\\na b c d\\n\\n\\nThe first city's north latitude a, the first city's east longitude b, the second city's north latitude c, and the second city's east longitude d are given on one line, separated by blanks. All inputs are given in real numbers.\\n\\nThe number of datasets does not exceed 30.\\n\\nOutput\\n\\nOutputs the surface distances of two cities on one line for each dataset.\\n\\nExample\\n\\nInput\\n\\n35.68 139.77 51.15 359.82\\n1.37 103.92 41.78 272.25\\n51.15 359.82 -34.58 301.52\\n-1 -1 -1 -1\\n\\n\\nOutput\\n\\n9609\\n15092\\n11112\\nUsing cpp can you solve the prior task?\",\"targets\":\"#include <stdio.h>\\n#include <string.h>\\n#include <math.h>\\n#include <bits\\/stdc++.h>\\nusing namespace std;\\n\\n#define EPS 1e-10\\n#define EQ(a, b) (fabs(a - b) < EPS)\\n \\nint main(void)\\n{\\n    const long double radius = 6378.1;\\n    const long double pi = acos(-1);\\n    long double x[2], y[2];\\n    long double dx;\\n    long double d;\\n     \\n    while (1){\\n        int i;\\n        \\n\\t\\tbool f = true;\\n\\t\\t\\n        for (i = 0; i < 2; i++){\\n            cin >> y[i] >> x[i];\\n            if (y[i] != -1 || x[i] != -1) f = false;\\n\\t\\t\\t \\n            x[i] = x[i] * pi \\/ 180;\\n            y[i] = y[i] * pi \\/ 180;\\n        }\\n\\t\\t\\n\\t\\tif (f) return 0;\\n         \\n        dx = x[1] - x[0];\\n         \\n        d = radius * acos( sin(y[0]) * sin(y[1]) + cos(y[0]) * cos(y[1]) * cos(dx) );\\n         \\n        cout << round(d) << endl;\\n    }\\n     \\n    return 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Polycarp has come up with a new game to play with you. He calls it \\\"A missing bigram\\\".\\n\\nA bigram of a word is a sequence of two adjacent letters in it.\\n\\nFor example, word \\\"abbaaba\\\" contains bigrams \\\"ab\\\", \\\"bb\\\", \\\"ba\\\", \\\"aa\\\", \\\"ab\\\" and \\\"ba\\\".\\n\\nThe game goes as follows. First, Polycarp comes up with a word, consisting only of lowercase letters 'a' and 'b'. Then, he writes down all its bigrams on a whiteboard in the same order as they appear in the word. After that, he wipes one of them off the whiteboard.\\n\\nFinally, Polycarp invites you to guess what the word that he has come up with was.\\n\\nYour goal is to find any word such that it's possible to write down all its bigrams and remove one of them, so that the resulting sequence of bigrams is the same as the one Polycarp ended up with.\\n\\nThe tests are generated in such a way that the answer exists. If there are multiple answers, you can print any of them.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 2000) \u2014 the number of testcases.\\n\\nThe first line of each testcase contains a single integer n (3 \u2264 n \u2264 100) \u2014 the length of the word Polycarp has come up with.\\n\\nThe second line of each testcase contains n-2 bigrams of that word, separated by a single space. Each bigram consists of two letters, each of them is either 'a' or 'b'.\\n\\nAdditional constraint on the input: there exists at least one string such that it is possible to write down all its bigrams, except one, so that the resulting sequence is the same as the sequence in the input. In other words, the answer exists.\\n\\nOutput\\n\\nFor each testcase print a word, consisting of n letters, each of them should be either 'a' or 'b'. It should be possible to write down all its bigrams and remove one of them, so that the resulting sequence of bigrams is the same as the one Polycarp ended up with.\\n\\nThe tests are generated in such a way that the answer exists. If there are multiple answers, you can print any of them. \\n\\nExample\\n\\nInput\\n\\n\\n4\\n7\\nab bb ba aa ba\\n7\\nab ba aa ab ba\\n3\\naa\\n5\\nbb ab...\",\"targets\":\"import java.util.*;\\nimport java.io.*;\\n\\npublic class Q760_3_b {\\n    public static void main(String[] args) throws IOException {\\n        Scanner sc = new Scanner(System.in);\\n        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));\\n        int t = Integer.parseInt(br.readLine());\\n        while(t-->0){\\n            int n = Integer.parseInt(br.readLine());\\n            String str = br.readLine();\\n            String[] arr = str.split(\\\" \\\");\\n            String response = new String();\\n            for(int i=0;i<arr.length;i++){\\n               if(response.length()==0) response += arr[i];\\n               else{\\n                   if(arr[i].charAt(0) == response.charAt(response.length()-1)){\\n                       response+=arr[i].charAt(1);\\n                   }else{\\n                       response+=arr[i];\\n                   }\\n               }\\n           }\\n            \\n            if(response.length() < n){\\n                response+= 'a';\\n            }\\n            \\n            System.out.println(response);\\n        }\\n    }\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CQXYM is counting permutations length of 2n.\\n\\nA permutation is an array consisting of n distinct integers from 1 to n in arbitrary order. For example, [2,3,1,5,4] is a permutation, but [1,2,2] is not a permutation (2 appears twice in the array) and [1,3,4] is also not a permutation (n=3 but there is 4 in the array).\\n\\nA permutation p(length of 2n) will be counted only if the number of i satisfying p_i<p_{i+1} is no less than n. For example:\\n\\n  * Permutation [1, 2, 3, 4] will count, because the number of such i that p_i<p_{i+1} equals 3 (i = 1, i = 2, i = 3).\\n  * Permutation [3, 2, 1, 4] won't count, because the number of such i that p_i<p_{i+1} equals 1 (i = 3). \\n\\n\\n\\nCQXYM wants you to help him to count the number of such permutations modulo 1000000007 (10^9+7).\\n\\nIn addition, [modulo operation](https:\\/\\/en.wikipedia.org\\/wiki\\/Modulo_operation) is to get the remainder. For example:\\n\\n  * 7 mod 3=1, because 7 = 3 \u22c5 2 + 1, \\n  * 15 mod 4=3, because 15 = 4 \u22c5 3 + 3. \\n\\nInput\\n\\nThe input consists of multiple test cases. \\n\\nThe first line contains an integer t (t \u2265 1) \u2014 the number of test cases. The description of the test cases follows.\\n\\nOnly one line of each test case contains an integer n(1 \u2264 n \u2264 10^5).\\n\\nIt is guaranteed that the sum of n over all test cases does not exceed 10^5\\n\\nOutput\\n\\nFor each test case, print the answer in a single line.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n1\\n2\\n9\\n91234\\n\\n\\nOutput\\n\\n\\n1\\n12\\n830455698\\n890287984\\n\\nNote\\n\\nn=1, there is only one permutation that satisfies the condition: [1,2].\\n\\nIn permutation [1,2], p_1<p_2, and there is one i=1 satisfy the condition. Since 1 \u2265 n, this permutation should be counted. In permutation [2,1], p_1>p_2. Because 0<n, this permutation should not be counted.\\n\\nn=2, there are 12 permutations: [1,2,3,4],[1,2,4,3],[1,3,2,4],[1,3,4,2],[1,4,2,3],[2,1,3,4],[2,3,1,4],[2,3,4,1],[2,4,1,3],[3,1,2,4],[3,4,1,2],[4,1,2,3].\",\"targets\":\"import java.util.*;\\nimport java.lang.*;\\npublic class Main\\n{\\n  public static void main(String[] args)\\n  {\\n   Scanner sc = new Scanner(System.in);\\n   \\n   \\n  int t = sc.nextInt();\\n  \\n  while(t--!=0)\\n  {\\n      \\n      \\n  int n=sc.nextInt();\\n  long ans=1;\\n  \\n  long mod = 1000000007;\\n  \\n  \\n  for(int k=3;k<=2*n;k++)\\n  {\\n      \\n      \\n    long val =ans%mod;\\n    \\n    val*=k%mod;\\n    \\n    ans=val%mod;\\n  }\\n \\n \\n\\n  System.out.println(ans);\\n  }\\n  \\n  }\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You are given two integers l and r, l\u2264 r. Find the largest possible value of a mod b over all pairs (a, b) of integers for which r\u2265 a \u2265 b \u2265 l.\\n\\nAs a reminder, a mod b is a remainder we get when dividing a by b. For example, 26 mod 8 = 2.\\n\\nInput\\n\\nEach test contains multiple test cases.\\n\\nThe first line contains one positive integer t (1\u2264 t\u2264 10^4), denoting the number of test cases. Description of the test cases follows.\\n\\nThe only line of each test case contains two integers l, r (1\u2264 l \u2264 r \u2264 10^9).\\n\\nOutput\\n\\nFor every test case, output the largest possible value of a mod b over all pairs (a, b) of integers for which r\u2265 a \u2265 b \u2265 l.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n1 1\\n999999999 1000000000\\n8 26\\n1 999999999\\n\\n\\nOutput\\n\\n\\n0\\n1\\n12\\n499999999\\n\\nNote\\n\\nIn the first test case, the only allowed pair is (a, b) = (1, 1), for which a mod b = 1 mod 1 = 0.\\n\\nIn the second test case, the optimal choice is pair (a, b) = (1000000000, 999999999), for which a mod b = 1.\\n#incl\",\"targets\":\"ude <bits\\/stdc++.h>\\nusing namespace std;\\nconst int N = 2e5 + 10, mod = 1e9 + 7;\\nconst double expp = 1e-10;\\nint n;\\nint main() {\\n  int T;\\n  cin >> T;\\n  while (T--) {\\n    long long a, b;\\n    cin >> a >> b;\\n    if (a <= (b - 1) \\/ 2 + 1)\\n      cout << (b - 1) \\/ 2 << endl;\\n    else {\\n      cout << b - a << endl;\\n    }\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"City X consists of n vertical and n horizontal infinite roads, forming n \u00d7 n intersections. Roads (both vertical and horizontal) are numbered from 1 to n, and the intersections are indicated by the numbers of the roads that form them.\\n\\nSand roads have long been recognized out of date, so the decision was made to asphalt them. To do this, a team of workers was hired and a schedule of work was made, according to which the intersections should be asphalted.\\n\\nRoad repairs are planned for n2 days. On the i-th day of the team arrives at the i-th intersection in the list and if none of the two roads that form the intersection were already asphalted they asphalt both roads. Otherwise, the team leaves the intersection, without doing anything with the roads.\\n\\nAccording to the schedule of road works tell in which days at least one road will be asphalted.\\n\\nInput\\n\\nThe first line contains integer n (1 \u2264 n \u2264 50) \u2014 the number of vertical and horizontal roads in the city. \\n\\nNext n2 lines contain the order of intersections in the schedule. The i-th of them contains two numbers hi, vi (1 \u2264 hi, vi \u2264 n), separated by a space, and meaning that the intersection that goes i-th in the timetable is at the intersection of the hi-th horizontal and vi-th vertical roads. It is guaranteed that all the intersections in the timetable are distinct.\\n\\nOutput\\n\\nIn the single line print the numbers of the days when road works will be in progress in ascending order. The days are numbered starting from 1.\\n\\nExamples\\n\\nInput\\n\\n2\\n1 1\\n1 2\\n2 1\\n2 2\\n\\n\\nOutput\\n\\n1 4 \\n\\n\\nInput\\n\\n1\\n1 1\\n\\n\\nOutput\\n\\n1 \\n\\nNote\\n\\nIn the sample the brigade acts like that:\\n\\n  1. On the first day the brigade comes to the intersection of the 1-st horizontal and the 1-st vertical road. As none of them has been asphalted, the workers asphalt the 1-st vertical and the 1-st horizontal road; \\n  2. On the second day the brigade of the workers comes to the intersection of the 1-st horizontal and the 2-nd vertical road. The 2-nd vertical road hasn't been asphalted, but as the 1-st horizontal road has...\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing std::abs;\\nusing std::cerr;\\nusing std::cin;\\nusing std::cout;\\nusing std::endl;\\nusing std::make_pair;\\nusing std::max;\\nusing std::min;\\nusing std::pair;\\nusing std::string;\\nusing std::vector;\\ntemplate <typename T>\\ninline T input() {\\n  T ans;\\n  cin >> ans;\\n  return ans;\\n}\\nint main() {\\n  uint32_t n = input<uint32_t>();\\n  vector<bool> state_horiz(n, false);\\n  vector<bool> state_vert(n, false);\\n  bool add_space = false;\\n  for (uint32_t i = 0; i != n * n; ++i) {\\n    uint32_t x = input<uint32_t>() - 1;\\n    uint32_t y = input<uint32_t>() - 1;\\n    if (not state_horiz[x] and not state_vert[y]) {\\n      if (add_space) cout << \\\" \\\";\\n      add_space = true, cout << i + 1, state_horiz[x] = state_vert[y] = true;\\n    }\\n  }\\n  endl(cout);\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Given a positive integer n. Find three distinct positive integers a, b, c such that a + b + c = n and \\\\operatorname{gcd}(a, b) = c, where \\\\operatorname{gcd}(x, y) denotes the [greatest common divisor (GCD)](https:\\/\\/en.wikipedia.org\\/wiki\\/Greatest_common_divisor) of integers x and y.\\n\\nInput\\n\\nThe input consists of multiple test cases. The first line contains a single integer t (1 \u2264 t \u2264 10^5) \u2014 the number of test cases. Description of the test cases follows.\\n\\nThe first and only line of each test case contains a single integer n (10 \u2264 n \u2264 10^9).\\n\\nOutput\\n\\nFor each test case, output three distinct positive integers a, b, c satisfying the requirements. If there are multiple solutions, you can print any. We can show that an answer always exists.\\n\\nExample\\n\\nInput\\n\\n\\n6\\n18\\n63\\n73\\n91\\n438\\n122690412\\n\\n\\nOutput\\n\\n\\n6 9 3\\n21 39 3\\n29 43 1\\n49 35 7\\n146 219 73\\n28622 122661788 2\\n\\nNote\\n\\nIn the first test case, 6 + 9 + 3 = 18 and \\\\operatorname{gcd}(6, 9) = 3.\\n\\nIn the second test case, 21 + 39 + 3 = 63 and \\\\operatorname{gcd}(21, 39) = 3.\\n\\nIn the third test case, 29 + 43 + 1 = 73 and \\\\operatorname{gcd}(29, 43) = 1.\",\"targets\":\"from math import gcd\\nfor _ in range(int(input())):\\n    n = int(input())\\n    if n%2:\\n        j = n\\/\\/2\\n        i = 1\\n        while gcd(j-i, j+i) != 1:\\n            i += 1\\n            # print(j-i,j+1)\\n        print(j-i, j+i, 1)\\n    else:\\n        print(n\\/\\/2,n\\/\\/2-1, 1)\",\"language\":\"python\",\"split\":\"test\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"n people gathered to hold a jury meeting of the upcoming competition, the i-th member of the jury came up with a_i tasks, which they want to share with each other.\\n\\nFirst, the jury decides on the order which they will follow while describing the tasks. Let that be a permutation p of numbers from 1 to n (an array of size n where each integer from 1 to n occurs exactly once).\\n\\nThen the discussion goes as follows:\\n\\n  * If a jury member p_1 has some tasks left to tell, then they tell one task to others. Otherwise, they are skipped. \\n  * If a jury member p_2 has some tasks left to tell, then they tell one task to others. Otherwise, they are skipped. \\n  * ... \\n  * If a jury member p_n has some tasks left to tell, then they tell one task to others. Otherwise, they are skipped. \\n  * If there are still members with tasks left, then the process repeats from the start. Otherwise, the discussion ends. \\n\\n\\n\\nA permutation p is nice if none of the jury members tell two or more of their own tasks in a row. \\n\\nCount the number of nice permutations. The answer may be really large, so print it modulo 998 244 353.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases.\\n\\nThe first line of the test case contains a single integer n (2 \u2264 n \u2264 2 \u22c5 10^5) \u2014 number of jury members.\\n\\nThe second line contains n integers a_1, a_2, ..., a_n (1 \u2264 a_i \u2264 10^9) \u2014 the number of problems that the i-th member of the jury came up with.\\n\\nThe sum of n over all test cases does not exceed 2 \u22c5 10^5.\\n\\nOutput\\n\\nFor each test case, print one integer \u2014 the number of nice permutations, taken modulo 998 244 353.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n2\\n1 2\\n3\\n5 5 5\\n4\\n1 3 3 7\\n6\\n3 4 2 1 3 3\\n\\n\\nOutput\\n\\n\\n1\\n6\\n0\\n540\\n\\nNote\\n\\nExplanation of the first test case from the example:\\n\\nThere are two possible permutations, p = [1, 2] and p = [2, 1]. For p = [1, 2], the process is the following:\\n\\n  1. the first jury member tells a task; \\n  2. the second jury member tells a task; \\n  3. the first jury member doesn't have any tasks left to tell, so they are skipped;...\\nThe above is tricky. Write me a correct solution in PYTHON3.\",\"targets\":\"mod=998244353 \\nfor _ in range(int(input())):\\n    n=int(input())\\n    a=list(map(int,input().split()))\\n    f=1\\n    for i in range(n):\\n        f=(f*(i+1))%mod\\n    a.sort()\\n    if a[-1]-a[-2]>=2:\\n        print(0)\\n    else:\\n        if a[-1]==a[-2]:\\n            print(f)\\n        else:\\n            i=n-2\\n            while i>=0 and a[i]==a[n-2]:\\n                i-=1\\n            c=n-2-i\\n            f=(f*c)%mod\\n            f=(f*pow(c+1,mod-2,mod))%mod\\n            print(f)\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"YouKn0wWho has an integer sequence a_1, a_2, \u2026 a_n. Now he will split the sequence a into one or more consecutive subarrays so that each element of a belongs to exactly one subarray. Let k be the number of resulting subarrays, and h_1, h_2, \u2026, h_k be the lengths of the longest increasing subsequences of corresponding subarrays.\\n\\nFor example, if we split [2, 5, 3, 1, 4, 3, 2, 2, 5, 1] into [2, 5, 3, 1, 4], [3, 2, 2, 5], [1], then h = [3, 2, 1].\\n\\nYouKn0wWho wonders if it is possible to split the sequence a in such a way that the [bitwise XOR](https:\\/\\/en.wikipedia.org\\/wiki\\/Bitwise_operation#XOR) of h_1, h_2, \u2026, h_k is equal to 0. You have to tell whether it is possible.\\n\\nThe longest increasing subsequence (LIS) of a sequence b_1, b_2, \u2026, b_m is the longest sequence of valid indices i_1, i_2, \u2026, i_k such that i_1 < i_2 < \u2026 < i_k and b_{i_1} < b_{i_2} < \u2026 < b_{i_k}. For example, the LIS of [2, 5, 3, 3, 5] is [2, 3, 5], which has length 3.\\n\\nAn array c is a subarray of an array b if c can be obtained from b by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 10 000) \u2014 the number of test cases.\\n\\nThe first line of each test case contains a single integer n (2 \u2264 n \u2264 10^5).\\n\\nThe second line of each test case contains n integers a_1, a_2, \u2026, a_n (1 \u2264 a_i \u2264 10^9).\\n\\nIt is guaranteed that the sum of n over all test cases doesn't exceed 3 \u22c5 10^5.\\n\\nOutput\\n\\nFor each test case, print \\\"YES\\\" (without quotes) if it is possible to split into subarrays in the desired way, print \\\"NO\\\" (without quotes) otherwise. You can print each letter in any register (upper or lower).\\n\\nExample\\n\\nInput\\n\\n\\n4\\n7\\n1 3 4 2 2 1 5\\n3\\n1 3 4\\n5\\n1 3 2 4 2\\n4\\n4 3 2 1\\n\\n\\nOutput\\n\\n\\nYES\\nNO\\nYES\\nYES\\n\\nNote\\n\\nIn the first test case, YouKn0wWho can split the sequence in the following way: [1, 3, 4], [2, 2], [1, 5]. This way, the LIS lengths are h = [3, 1, 2], and the bitwise XOR of the LIS lengths is 3 \u2295 1 \u2295 2 = 0.\\n\\nIn the second test...\\nThe above is tricky. Write me a correct solution in PYTHON3.\",\"targets\":\"t = int(input())\\nfor _ in range(t):\\n    n = int(input())\\n    l = list(map(int, input().split()))\\n    if n%2 == 0:\\n        print('YES')\\n    else:\\n        flag = 0\\n        for i in range(1,n):\\n            if l[i] <= l[i-1]:\\n                flag = 1\\n                break\\n        if flag == 0:\\n            print('NO')\\n        else:\\n            print('YES')\",\"language\":\"python\",\"split\":\"test\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Polycarp had an array a of 3 positive integers. He wrote out the sums of all non-empty subsequences of this array, sorted them in non-decreasing order, and got an array b of 7 integers.\\n\\nFor example, if a = \\\\{1, 4, 3\\\\}, then Polycarp wrote out 1, 4, 3, 1 + 4 = 5, 1 + 3 = 4, 4 + 3 = 7, 1 + 4 + 3 = 8. After sorting, he got an array b = \\\\{1, 3, 4, 4, 5, 7, 8\\\\}.\\n\\nUnfortunately, Polycarp lost the array a. He only has the array b left. Help him to restore the array a.\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 5000) \u2014 the number of test cases.\\n\\nEach test case consists of one line which contains 7 integers b_1, b_2, ..., b_7 (1 \u2264 b_i \u2264 10^9; b_i \u2264 b_{i+1}). \\n\\nAdditional constraint on the input: there exists at least one array a which yields this array b as described in the statement.\\n\\nOutput\\n\\nFor each test case, print 3 integers \u2014 a_1, a_2 and a_3. If there can be several answers, print any of them.\\n\\nExample\\n\\nInput\\n\\n\\n5\\n1 3 4 4 5 7 8\\n1 2 3 4 5 6 7\\n300000000 300000000 300000000 600000000 600000000 600000000 900000000\\n1 1 2 999999998 999999999 999999999 1000000000\\n1 2 2 3 3 4 5\\n\\n\\nOutput\\n\\n\\n1 4 3\\n4 1 2\\n300000000 300000000 300000000\\n999999998 1 1\\n1 2 2\\n\\nNote\\n\\nThe subsequence of the array a is a sequence that can be obtained from a by removing zero or more of its elements.\\n\\nTwo subsequences are considered different if index sets of elements included in them are different. That is, the values of the elements don't matter in the comparison of subsequences. In particular, any array of length 3 has exactly 7 different non-empty subsequences.\\nThe above is tricky. Write me a correct solution in JAVA.\",\"targets\":\"import java.io.*;\\nimport java.util.Arrays;\\nimport java.util.StringTokenizer;\\n\\npublic class SumSubseq {\\n    InputStream sin;\\n    FScanner scanner;\\n    PrintWriter out;\\n    SumSubseq() {\\n        this(System.in, System.out);\\n    }\\n    SumSubseq(InputStream sin, OutputStream sout) {\\n        this.sin = sin;\\n        scanner = new FScanner(sin);\\n        out = new PrintWriter(new BufferedOutputStream(sout));\\n    }\\n    public static void main(String[] args) {\\n        new SumSubseq().execute();\\n    }\\n    \\/\\/1 2 2 3 3 4 5\\n    \\/\\/  1 1 2 2 3 4\\n    void execute() {\\n        int t = scanner.nextInt();\\n        for (int i = 0; i < t; i++) {\\n            int arr[] = scanner.nextIntArr();\\n            int result[] = new int[3];\\n            result[0] = arr[0];\\n            result[1] = arr[1];\\n            result[2] = arr[2];\\n            if (arr[0] + arr[1] <= arr[2]) {\\n                result[2] = arr[3];\\n            }\\n            String[] strArr = Arrays.stream(result).mapToObj(String::valueOf).toArray(String[]::new);\\n            String str = String.join(\\\" \\\", strArr);\\n            out.println(str);\\n        }\\n        out.close();\\n    }\\n\\n    static class FScanner implements AutoCloseable {\\n        private BufferedReader bufferedReader;\\n        private StringTokenizer tokenizer;\\n        public FScanner(InputStream inputStream) {\\n            this.bufferedReader = new BufferedReader(new InputStreamReader(inputStream));\\n        }\\n        public int nextInt() {\\n            return Integer.parseInt(next());\\n        }\\n        public int[] nextIntArr() {\\n            String line = nextLine();\\n            String[] arr = line.split(\\\" \\\");\\n            int result[] = new int[arr.length];\\n            for (int i = 0; i < arr.length; i++) {\\n                result[i] = Integer.parseInt(arr[i]);\\n            }\\n            return result;\\n        }\\n        public Double nextDouble() {\\n            return Double.parseDouble(next());\\n        }\\n        public String next() {\\n            skipUntilTokenOrEnd();\\n            return tokenizer.nextToken();\\n        }\\n  ...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in PYTHON3?\\nA bow adorned with nameless flowers that bears the earnest hopes of an equally nameless person.\\n\\nYou have obtained the elegant bow known as the Windblume Ode. Inscribed in the weapon is an array of n (n \u2265 3) positive distinct integers (i.e. different, no duplicates are allowed).\\n\\nFind the largest subset (i.e. having the maximum number of elements) of this array such that its sum is a composite number. A positive integer x is called composite if there exists a positive integer y such that 1 < y < x and x is divisible by y.\\n\\nIf there are multiple subsets with this largest size with the composite sum, you can output any of them. It can be proven that under the constraints of the problem such a non-empty subset always exists.\\n\\nInput\\n\\nEach test consists of multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 100). Description of the test cases follows.\\n\\nThe first line of each test case contains an integer n (3 \u2264 n \u2264 100) \u2014 the length of the array.\\n\\nThe second line of each test case contains n distinct integers a_{1},a_{2},...,a_{n} (1 \u2264 a_{i} \u2264 200) \u2014 the elements of the array.\\n\\nOutput\\n\\nEach test case should have two lines of output.\\n\\nThe first line should contain a single integer x: the size of the largest subset with composite sum. The next line should contain x space separated integers representing the indices of the subset of the initial array.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n3\\n8 1 2\\n4\\n6 9 4 2\\n9\\n1 2 3 4 5 6 7 8 9\\n3\\n200 199 198\\n\\n\\nOutput\\n\\n\\n2\\n2 1\\n4\\n2 1 4 3\\n9\\n6 9 1 2 3 4 5 7 8\\n3\\n1 2 3 \\n\\nNote\\n\\nIn the first test case, the subset \\\\\\\\{a_2, a_1\\\\} has a sum of 9, which is a composite number. The only subset of size 3 has a prime sum equal to 11. Note that you could also have selected the subset \\\\\\\\{a_1, a_3\\\\} with sum 8 + 2 = 10, which is composite as it's divisible by 2.\\n\\nIn the second test case, the sum of all elements equals to 21, which is a composite number. Here we simply take the whole array as our subset.\",\"targets\":\"import sys\\ninput = sys.stdin.buffer.readline\\n\\n\\ndef is_prime(x):\\n    if x == 2:\\n        return True\\n    if x == 1 or x % 2 == 0:\\n        return False\\n    for k in range(3, int(x ** 0.5) + 1, 2):\\n        if x % k == 0:\\n            return False\\n    return True\\n\\n\\nt = int(input())\\nans = []\\n\\nfor _ in range(t):\\n    n = int(input())\\n    a = list(map(int, input().split()))\\n\\n    sum_ = sum(a)\\n    if not is_prime(sum_):\\n        ans.append([i + 1 for i in range(n)])\\n    else:\\n        for i in range(n):\\n            if a[i] % 2 == 1:\\n                res = [j + 1 for j in range(n)]\\n                res.remove(i + 1)\\n                ans.append(res)\\n                break\\n\\nfor res in ans:\\n    print(len(res))\\n    print(*res)\",\"language\":\"python\",\"split\":\"test\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in CPP?\\nA string is called square if it is some string written twice in a row. For example, the strings \\\"aa\\\", \\\"abcabc\\\", \\\"abab\\\" and \\\"baabaa\\\" are square. But the strings \\\"aaa\\\", \\\"abaaab\\\" and \\\"abcdabc\\\" are not square.\\n\\nFor a given string s determine if it is square.\\n\\nInput\\n\\nThe first line of input data contains an integer t (1 \u2264 t \u2264 100) \u2014the number of test cases.\\n\\nThis is followed by t lines, each containing a description of one test case. The given strings consist only of lowercase Latin letters and have lengths between 1 and 100 inclusive.\\n\\nOutput\\n\\nFor each test case, output on a separate line:\\n\\n  * YES if the string in the corresponding test case is square, \\n  * NO otherwise. \\n\\n\\n\\nYou can output YES and NO in any case (for example, strings yEs, yes, Yes and YES will be recognized as a positive response).\\n\\nExample\\n\\nInput\\n\\n\\n10\\na\\naa\\naaa\\naaaa\\nabab\\nabcabc\\nabacaba\\nxxyy\\nxyyx\\nxyxy\\n\\n\\nOutput\\n\\n\\nNO\\nYES\\nNO\\nYES\\nYES\\nYES\\nNO\\nNO\\nNO\\nYES\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint main() {\\n  int T;\\n  cin >> T;\\n  while (T--) {\\n    string s;\\n    cin >> s;\\n    int l = s.size();\\n    s.substr(0, l \\/ 2) == s.substr(l \\/ 2) ? cout << \\\"YES\\\" : cout << \\\"NO\\\";\\n    cout << endl;\\n  }\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You are given a keyboard that consists of 26 keys. The keys are arranged sequentially in one row in a certain order. Each key corresponds to a unique lowercase Latin letter.\\n\\nYou have to type the word s on this keyboard. It also consists only of lowercase Latin letters.\\n\\nTo type a word, you need to type all its letters consecutively one by one. To type each letter you must position your hand exactly over the corresponding key and press it.\\n\\nMoving the hand between the keys takes time which is equal to the absolute value of the difference between positions of these keys (the keys are numbered from left to right). No time is spent on pressing the keys and on placing your hand over the first letter of the word.\\n\\nFor example, consider a keyboard where the letters from 'a' to 'z' are arranged in consecutive alphabetical order. The letters 'h', 'e', 'l' and 'o' then are on the positions 8, 5, 12 and 15, respectively. Therefore, it will take |5 - 8| + |12 - 5| + |12 - 12| + |15 - 12| = 13 units of time to type the word \\\"hello\\\". \\n\\nDetermine how long it will take to print the word s.\\n\\nInput\\n\\nThe first line contains an integer t (1 \u2264 t \u2264 1000) \u2014 the number of test cases.\\n\\nThe next 2t lines contain descriptions of the test cases.\\n\\nThe first line of a description contains a keyboard \u2014 a string of length 26, which consists only of lowercase Latin letters. Each of the letters from 'a' to 'z' appears exactly once on the keyboard.\\n\\nThe second line of the description contains the word s. The word has a length from 1 to 50 letters inclusive and consists of lowercase Latin letters.\\n\\nOutput\\n\\nPrint t lines, each line containing the answer to the corresponding test case. The answer to the test case is the minimal time it takes to type the word s on the given keyboard.\\n\\nExample\\n\\nInput\\n\\n\\n5\\nabcdefghijklmnopqrstuvwxyz\\nhello\\nabcdefghijklmnopqrstuvwxyz\\ni\\nabcdefghijklmnopqrstuvwxyz\\ncodeforces\\nqwertyuiopasdfghjklzxcvbnm\\nqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\nqwertyuiopasdfghjklzxcvbnm\\nabacaba\\n\\n\\nOutput\\n\\n\\n13\\n0\\n68\\n0\\n74\\nThe above is tricky. Write me a correct solution in PYTHON3.\",\"targets\":\"# cook your dish here\\nt = int(input())\\nfor i in range(t):\\n    alpha = {}\\n    s = list(input())\\n    for idx, ch in enumerate(s):\\n        alpha[ch] = idx\\n    \\n    ans = 0\\n    inp = list(input())\\n    inp.append(inp[-1])\\n    for idx, ch in enumerate(inp[:-1]):\\n        ans = ans + abs(alpha[ch] - alpha[inp[idx+1]])\\n    \\n    print(ans)\",\"language\":\"python\",\"split\":\"test\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Alex doesn't like boredom. That's why whenever he gets bored, he comes up with games. One long winter evening he came up with a game and decided to play it.\\n\\nGiven a sequence a consisting of n integers. The player can make several steps. In a single step he can choose an element of the sequence (let's denote it ak) and delete it, at that all elements equal to ak + 1 and ak - 1 also must be deleted from the sequence. That step brings ak points to the player. \\n\\nAlex is a perfectionist, so he decided to get as many points as possible. Help him.\\n\\nInput\\n\\nThe first line contains integer n (1 \u2264 n \u2264 105) that shows how many numbers are in Alex's sequence. \\n\\nThe second line contains n integers a1, a2, ..., an (1 \u2264 ai \u2264 105).\\n\\nOutput\\n\\nPrint a single integer \u2014 the maximum number of points that Alex can earn.\\n\\nExamples\\n\\nInput\\n\\n2\\n1 2\\n\\n\\nOutput\\n\\n2\\n\\n\\nInput\\n\\n3\\n1 2 3\\n\\n\\nOutput\\n\\n4\\n\\n\\nInput\\n\\n9\\n1 2 1 3 2 2 2 2 3\\n\\n\\nOutput\\n\\n10\\n\\nNote\\n\\nConsider the third test example. At first step we need to choose any element equal to 2. After that step our sequence looks like this [2, 2, 2, 2]. Then we do 4 steps, on each step we choose any element equals to 2. In total we earn 10 points.\",\"targets\":\"from __future__ import division\\nfrom sys import stdin, stdout\\n\\nMAXE = 100000\\ncnt, dp = [0] * (MAXE + 1), [0] * (MAXE + 1)\\n\\nN = int (stdin.readline ())\\narr = map (int, stdin.readline ().split ())\\n\\nfor e in arr:\\n\\tcnt[e] += 1\\n\\ndp[1] = cnt[1]\\n\\nfor i in xrange (2, MAXE + 1):\\n    dp[i] = max (dp[i - 1], cnt[i] * i + dp[i - 2])\\n\\nprint dp[MAXE]\",\"language\":\"python\",\"split\":\"train\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Ashish has n elements arranged in a line. \\n\\nThese elements are represented by two integers a_i \u2014 the value of the element and b_i \u2014 the type of the element (there are only two possible types: 0 and 1). He wants to sort the elements in non-decreasing values of a_i.\\n\\nHe can perform the following operation any number of times: \\n\\n  * Select any two elements i and j such that b_i \u2260 b_j and swap them. That is, he can only swap two elements of different types in one move. \\n\\n\\n\\nTell him if he can sort the elements in non-decreasing values of a_i after performing any number of operations.\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 100) \u2014 the number of test cases. The description of the test cases follows.\\n\\nThe first line of each test case contains one integer n (1 \u2264 n \u2264 500) \u2014 the size of the arrays.\\n\\nThe second line contains n integers a_i (1 \u2264 a_i \u2264 10^5) \u2014 the value of the i-th element.\\n\\nThe third line containts n integers b_i (b_i \u2208 \\\\{0, 1\\\\}) \u2014 the type of the i-th element.\\n\\nOutput\\n\\nFor each test case, print \\\"Yes\\\" or \\\"No\\\" (without quotes) depending on whether it is possible to sort elements in non-decreasing order of their value.\\n\\nYou may print each letter in any case (upper or lower).\\n\\nExample\\n\\nInput\\n\\n\\n5\\n4\\n10 20 20 30\\n0 1 0 1\\n3\\n3 1 2\\n0 1 1\\n4\\n2 2 4 8\\n1 1 1 1\\n3\\n5 15 4\\n0 0 0\\n4\\n20 10 100 50\\n1 0 0 1\\n\\n\\nOutput\\n\\n\\nYes\\nYes\\nYes\\nNo\\nYes\\n\\nNote\\n\\nFor the first case: The elements are already in sorted order.\\n\\nFor the second case: Ashish may first swap elements at positions 1 and 2, then swap elements at positions 2 and 3.\\n\\nFor the third case: The elements are already in sorted order.\\n\\nFor the fourth case: No swap operations may be performed as there is no pair of elements i and j such that b_i \u2260 b_j. The elements cannot be sorted.\\n\\nFor the fifth case: Ashish may swap elements at positions 3 and 4, then elements at positions 1 and 2.\",\"targets\":\"#https:\\/\\/codeforces.com\\/contest\\/1365\\/problem\\/B\\nfor _ in range(int(input())):\\n\\tn=int(input())\\n\\ta=list(map(int,input().split()))\\n\\tb=list(map(int,input().split()))\\n\\ts=sorted(a)\\n\\tif s==a:\\n\\t\\tprint('Yes')\\n\\t\\tcontinue\\n\\tif len(set(b))==2:\\n\\t\\tprint('Yes')\\n\\telse:\\n\\t\\tprint('No')\\n\\t\\t\\n'''\\n2\\n7\\n45399 99669 77314 13900 19409 12543 79739\\n0 0 1 1 1 1 1\\n5\\n54423 7612 48964 84655 21084\\n0 0 1 1 0\\n'''\\n'''\\n5\\n4\\n10 20 20 30\\n0 1 0 1\\n3\\n3 1 2\\n0 1 1\\n4\\n2 2 4 8\\n1 1 1 1\\n3\\n5 15 4\\n0 0 0\\n4\\n20 10 100 50\\n1 0 0 1\\n'''\\n'''\\n10\\n4\\n61984 85101 45152 74839\\n1 0 0 1\\n4\\n4214 35436 84747 99946\\n0 0 1 1\\n3\\n79565 44828 8501\\n1 0 1\\n1\\n38344\\n0\\n2\\n34421 26750\\n1 0\\n3\\n16298 12276 30423\\n0 1 1\\n5\\n54423 7612 48964 84655 21084\\n0 0 1 1 0\\n4\\n3815 47682 5788 98926\\n0 1 0 0\\n1\\n89288\\n1\\n7\\n45399 99669 77314 13900 19409 12543 79739\\n0 0 1 1 1 1 1\\n'''\",\"language\":\"python\",\"split\":\"train\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"<image>\\n\\nWilliam has a favorite bracket sequence. Since his favorite sequence is quite big he provided it to you as a sequence of positive integers c_1, c_2, ..., c_n where c_i is the number of consecutive brackets \\\"(\\\" if i is an odd number or the number of consecutive brackets \\\")\\\" if i is an even number.\\n\\nFor example for a bracket sequence \\\"((())()))\\\" a corresponding sequence of numbers is [3, 2, 1, 3].\\n\\nYou need to find the total number of continuous subsequences (subsegments) [l, r] (l \u2264 r) of the original bracket sequence, which are regular bracket sequences.\\n\\nA bracket sequence is called regular if it is possible to obtain correct arithmetic expression by inserting characters \\\"+\\\" and \\\"1\\\" into this sequence. For example, sequences \\\"(())()\\\", \\\"()\\\" and \\\"(()(()))\\\" are regular, while \\\")(\\\", \\\"(()\\\" and \\\"(()))(\\\" are not.\\n\\nInput\\n\\nThe first line contains a single integer n (1 \u2264 n \u2264 1000), the size of the compressed sequence.\\n\\nThe second line contains a sequence of integers c_1, c_2, ..., c_n (1 \u2264 c_i \u2264 10^9), the compressed sequence.\\n\\nOutput\\n\\nOutput a single integer \u2014 the total number of subsegments of the original bracket sequence, which are regular bracket sequences.\\n\\nIt can be proved that the answer fits in the signed 64-bit integer data type.\\n\\nExamples\\n\\nInput\\n\\n\\n5\\n4 1 2 3 1\\n\\n\\nOutput\\n\\n\\n5\\n\\n\\nInput\\n\\n\\n6\\n1 3 2 1 2 4\\n\\n\\nOutput\\n\\n\\n6\\n\\n\\nInput\\n\\n\\n6\\n1 1 1 1 2 2\\n\\n\\nOutput\\n\\n\\n7\\n\\nNote\\n\\nIn the first example a sequence (((()(()))( is described. This bracket sequence contains 5 subsegments which form regular bracket sequences:\\n\\n  1. Subsequence from the 3rd to 10th character: (()(()))\\n  2. Subsequence from the 4th to 5th character: ()\\n  3. Subsequence from the 4th to 9th character: ()(())\\n  4. Subsequence from the 6th to 9th character: (())\\n  5. Subsequence from the 7th to 8th character: ()\\n\\n\\n\\nIn the second example a sequence ()))(()(()))) is described.\\n\\nIn the third example a sequence ()()(()) is described.\\nUsing java can you solve the prior task?\",\"targets\":\"import java.util.Scanner;\\n\\npublic class Main {\\n\\n    public static void main(String[] args) {\\n    \\n        var sc = new Scanner(System.in);\\n        \\n        int n = Integer.parseInt(sc.next());\\n        var c = new long[n];\\n        for(int i = 0; i < n; i++){\\n            c[i] = Long.parseLong(sc.next());\\n        }\\n        \\n        long ans = 0;\\n        for(int i = 0; i < n; i += 2){\\n            if(i+1 == n) break;\\n            ans += Math.min(c[i], c[i+1]);\\n            if(c[i] < c[i+1]) continue;\\n            long ci = c[i] - c[i+1];\\n            long cj = 0;\\n            for(int j = i+2; j < n; j += 2){\\n                if(j+1 == n) break;\\n                cj += c[j];\\n                if(c[j+1] < cj){\\n                    cj -= c[j+1];\\n                    continue;\\n                }\\n                \\n                long cj1 = c[j+1] - cj;\\n                cj = 0;\\n                ans++;\\n                if(cj1 > ci){\\n                    ans += ci;\\n                    break;\\n                }\\n                \\n                ans += cj1;\\n                ci -= cj1;\\n            }\\n        }\\n        System.out.println(ans);\\n    }\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"In a certain video game, the player controls a hero characterized by a single integer value: power.\\n\\nOn the current level, the hero got into a system of n caves numbered from 1 to n, and m tunnels between them. Each tunnel connects two distinct caves. Any two caves are connected with at most one tunnel. Any cave can be reached from any other cave by moving via tunnels.\\n\\nThe hero starts the level in cave 1, and every other cave contains a monster.\\n\\nThe hero can move between caves via tunnels. If the hero leaves a cave and enters a tunnel, he must finish his movement and arrive at the opposite end of the tunnel.\\n\\nThe hero can use each tunnel to move in both directions. However, the hero can not use the same tunnel twice in a row. Formally, if the hero has just moved from cave i to cave j via a tunnel, he can not head back to cave i immediately after, but he can head to any other cave connected to cave j with a tunnel.\\n\\nIt is known that at least two tunnels come out of every cave, thus, the hero will never find himself in a dead end even considering the above requirement.\\n\\nTo pass the level, the hero must beat the monsters in all the caves. When the hero enters a cave for the first time, he will have to fight the monster in it. The hero can beat the monster in cave i if and only if the hero's power is strictly greater than a_i. In case of beating the monster, the hero's power increases by b_i. If the hero can't beat the monster he's fighting, the game ends and the player loses.\\n\\nAfter the hero beats the monster in cave i, all subsequent visits to cave i won't have any consequences: the cave won't have any monsters, and the hero's power won't change either.\\n\\nFind the smallest possible power the hero must start the level with to be able to beat all the monsters and pass the level.\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 100). Description of the test cases follows.\\n\\nThe first line of each test case contains two integers n and m (3 \u2264 n \u2264 1000; n \u2264 m...\\nThe above is tricky. Write me a correct solution in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst int MAX = 1000;\\nint test, n, m, a[MAX + 1], b[MAX + 1], u, v, par[MAX + 1], lef, rig, mid, cnt,\\n    res;\\nlong long curB;\\nbool fr[MAX + 1], frInProcess[MAX + 1], found;\\nvector<int> adj[MAX + 1];\\nvoid visit(const int& u, const long long& bInProcess) {\\n  frInProcess[u] = true;\\n  for (const int& v : adj[u]) {\\n    if (v != par[u] && bInProcess >= a[v])\\n      if (frInProcess[v]) {\\n        for (int point = u; point != -1; point = par[point])\\n          if (!fr[point]) {\\n            fr[point] = true;\\n            curB += b[point];\\n            ++cnt;\\n          }\\n        for (int point = v; point != -1; point = par[point])\\n          if (!fr[point]) {\\n            fr[point] = true;\\n            curB += b[point];\\n            ++cnt;\\n          }\\n        found = true;\\n        return;\\n      } else {\\n        par[v] = u;\\n        visit(v, bInProcess + b[v]);\\n      }\\n    if (found) return;\\n  }\\n}\\nint main() {\\n  scanf(\\\"%d\\\", &test);\\n  while (test--) {\\n    scanf(\\\"%d %d\\\", &n, &m);\\n    lef = 1e9 + 10;\\n    rig = 0LL;\\n    for (int i = 2; i <= n; ++i) {\\n      scanf(\\\"%d\\\", a + i);\\n      ++a[i];\\n      lef = min(lef, a[i]);\\n      rig = max(rig, a[i]);\\n    }\\n    for (int i = 2; i <= n; ++i) scanf(\\\"%d\\\", b + i);\\n    for (int i = 1; i <= n; ++i) adj[i].clear();\\n    while (m--) {\\n      scanf(\\\"%d %d\\\", &u, &v);\\n      adj[u].push_back(v);\\n      adj[v].push_back(u);\\n    }\\n    while (lef <= rig) {\\n      mid = (lef + rig) >> 1;\\n      curB = mid;\\n      memset(fr + 1, false, n);\\n      fr[1] = true;\\n      cnt = 1;\\n      while (cnt < n) {\\n        memcpy(frInProcess + 1, fr + 1, n);\\n        memset(par + 1, -1, n * sizeof(int));\\n        found = false;\\n        for (int start = 1; start <= n; ++start)\\n          if (!found && fr[start])\\n            for (const int& u : adj[start])\\n              if (!found && !fr[u] && curB >= a[u]) {\\n                par[u] = start;\\n                visit(u, curB + b[u]);\\n              }\\n        if (!found) break;\\n      }\\n      if (cnt == n)\\n        rig = (res = mid) - 1;\\n      else\\n...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Arkady invited Anna for a dinner to a sushi restaurant. The restaurant is a bit unusual: it offers n pieces of sushi aligned in a row, and a customer has to choose a continuous subsegment of these sushi to buy.\\n\\nThe pieces of sushi are of two types: either with tuna or with eel. Let's denote the type of the i-th from the left sushi as t_i, where t_i = 1 means it is with tuna, and t_i = 2 means it is with eel.\\n\\nArkady does not like tuna, Anna does not like eel. Arkady wants to choose such a continuous subsegment of sushi that it has equal number of sushi of each type and each half of the subsegment has only sushi of one type. For example, subsegment [2, 2, 2, 1, 1, 1] is valid, but subsegment [1, 2, 1, 2, 1, 2] is not, because both halves contain both types of sushi.\\n\\nFind the length of the longest continuous subsegment of sushi Arkady can buy.\\n\\nInput\\n\\nThe first line contains a single integer n (2 \u2264 n \u2264 100 000) \u2014 the number of pieces of sushi.\\n\\nThe second line contains n integers t_1, t_2, ..., t_n (t_i = 1, denoting a sushi with tuna or t_i = 2, denoting a sushi with eel), representing the types of sushi from left to right.\\n\\nIt is guaranteed that there is at least one piece of sushi of each type. Note that it means that there is at least one valid continuous segment.\\n\\nOutput\\n\\nPrint a single integer \u2014 the maximum length of a valid continuous segment.\\n\\nExamples\\n\\nInput\\n\\n\\n7\\n2 2 2 1 1 2 2\\n\\n\\nOutput\\n\\n\\n4\\n\\n\\nInput\\n\\n\\n6\\n1 2 1 2 1 2\\n\\n\\nOutput\\n\\n\\n2\\n\\n\\nInput\\n\\n\\n9\\n2 2 1 1 1 2 2 2 2\\n\\n\\nOutput\\n\\n\\n6\\n\\nNote\\n\\nIn the first example Arkady can choose the subsegment [2, 2, 1, 1] or the subsegment [1, 1, 2, 2] with length 4.\\n\\nIn the second example there is no way but to choose one of the subsegments [2, 1] or [1, 2] with length 2.\\n\\nIn the third example Arkady's best choice is the subsegment [1, 1, 1, 2, 2, 2].\\ninput\",\"targets\":\"()\\nX = list(map(int, input().split()))\\nNum1, Num2, i, Max = 1, 0, 1, 0\\nwhile i < len(X):\\n    while i < len(X) and X[i] == X[0]:\\n        Num1 += 1\\n        i += 1\\n    Max = max(Max, (min(Num1, Num2) * 2))\\n    Num2 = 0\\n    while i < len(X) and X[i] != X[0]:\\n        Num2 += 1\\n        i += 1\\n    Max = max(Max, (min(Num1, Num2) * 2))\\n    Num1 = 0\\nprint(Max)\",\"language\":\"python\",\"split\":\"train\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in JAVA?\\nYou are given an integer n. In 1 move, you can do one of the following actions:\\n\\n  * erase any digit of the number (it's acceptable that the number before the operation has exactly one digit and after the operation, it is \\\"empty\\\"); \\n  * add one digit to the right. \\n\\n\\n\\nThe actions may be performed in any order any number of times.\\n\\nNote that if, after deleting some digit from a number, it will contain leading zeroes, they will not be deleted. E.g. if you delete from the number 301 the digit 3, the result is the number 01 (not 1).\\n\\nYou need to perform the minimum number of actions to make the number any power of 2 (i.e. there's an integer k (k \u2265 0) such that the resulting number is equal to 2^k). The resulting number must not have leading zeroes.\\n\\nE.g. consider n=1052. The answer is equal to 2. First, let's add to the right one digit 4 (the result will be 10524). Then let's erase the digit 5, so the result will be 1024 which is a power of 2.\\n\\nE.g. consider n=8888. The answer is equal to 3. Let's erase any of the digits 8 three times. The result will be 8 which is a power of 2.\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases. Then t test cases follow.\\n\\nEach test case consists of one line containing one integer n (1 \u2264 n \u2264 10^9).\\n\\nOutput\\n\\nFor each test case, output in a separate line one integer m \u2014 the minimum number of moves to transform the number into any power of 2.\\n\\nExample\\n\\nInput\\n\\n\\n12\\n1052\\n8888\\n6\\n75\\n128\\n1\\n301\\n12048\\n1504\\n6656\\n1000000000\\n687194767\\n\\n\\nOutput\\n\\n\\n2\\n3\\n1\\n3\\n0\\n0\\n2\\n1\\n3\\n4\\n9\\n2\\n\\nNote\\n\\nThe answer for the first test case was considered above.\\n\\nThe answer for the second test case was considered above.\\n\\nIn the third test case, it's enough to add to the right the digit 4 \u2014 the number 6 will turn into 64.\\n\\nIn the fourth test case, let's add to the right the digit 8 and then erase 7 and 5 \u2014 the taken number will turn into 8.\\n\\nThe numbers of the fifth and the sixth test cases are already powers of two so there's no need to make any move.\\n\\nIn the seventh test case, you can...\",\"targets\":\"import java.util.ArrayList;\\nimport java.util.Arrays;\\nimport java.util.Collections;\\nimport java.util.List;\\nimport java.util.Scanner;\\n\\npublic class Main {\\n    static Scanner in = new Scanner(System.in);\\n    static int n;\\n    static long[] a;\\n    static int cnt;\\n    public static void main(String[] args) {\\n        init();\\n        int t= in.nextInt();\\n        while (t-- > 0) {\\n            int n = in.nextInt();\\n            System.out.println(solve(n));\\n        }\\n    }\\n\\n    private static int solve(int n) {\\n        int ans = Integer.MAX_VALUE;\\n        for (int i = 0; i < cnt; i++) {\\n            ans = Math.min(ans, check(n, a[i]));\\n        }\\n        return ans;\\n    }\\n\\n    private static int check(long x, long y) {\\n        List<Long> a = getList(x);\\n        List<Long> b = getList(y);\\n        int lenA = a.size();\\n        int lenB = b.size();\\n        int cnt = 0;\\n        int i = 0, j = 0;\\n        while (i < lenA && j < lenB) {\\n            if (a.get(i) == b.get(j)) {\\n                j++;\\n                cnt++;\\n            }\\n            i++;\\n        }\\n        return lenA - cnt + lenB - cnt;\\n    }\\n\\n    private static List<Long> getList(long x) {\\n        List<Long> list = new ArrayList<>();\\n        while (x != 0) {\\n            list.add(x % 10);\\n            x \\/= 10;\\n        }\\n        Collections.reverse(list);\\n        return list;\\n    }\\n\\n    private static void init() {\\n        cnt = 60;\\n        a = new long[60];\\n        for (int i = 0; i < 60; i++) {\\n            a[i] = (1L << i);\\n        }\\n    }\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Two players, Red and Blue, are at it again, and this time they're playing with crayons! The mischievous duo is now vandalizing a rooted tree, by coloring the nodes while playing their favorite game.\\n\\nThe game works as follows: there is a tree of size n, rooted at node 1, where each node is initially white. Red and Blue get one turn each. Red goes first. \\n\\nIn Red's turn, he can do the following operation any number of times: \\n\\n  * Pick any subtree of the rooted tree, and color every node in the subtree red. \\n\\nHowever, to make the game fair, Red is only allowed to color k nodes of the tree. In other words, after Red's turn, at most k of the nodes can be colored red.\\n\\nThen, it's Blue's turn. Blue can do the following operation any number of times: \\n\\n  * Pick any subtree of the rooted tree, and color every node in the subtree blue. However, he's not allowed to choose a subtree that contains a node already colored red, as that would make the node purple and no one likes purple crayon. \\n\\nNote: there's no restriction on the number of nodes Blue can color, as long as he doesn't color a node that Red has already colored.\\n\\nAfter the two turns, the score of the game is determined as follows: let w be the number of white nodes, r be the number of red nodes, and b be the number of blue nodes. The score of the game is w \u22c5 (r - b).\\n\\nRed wants to maximize this score, and Blue wants to minimize it. If both players play optimally, what will the final score of the game be?\\n\\nInput\\n\\nThe first line contains two integers n and k (2 \u2264 n \u2264 2 \u22c5 10^5; 1 \u2264 k \u2264 n) \u2014 the number of vertices in the tree and the maximum number of red nodes.\\n\\nNext n - 1 lines contains description of edges. The i-th line contains two space separated integers u_i and v_i (1 \u2264 u_i, v_i \u2264 n; u_i \u2260 v_i) \u2014 the i-th edge of the tree.\\n\\nIt's guaranteed that given edges form a tree.\\n\\nOutput\\n\\nPrint one integer \u2014 the resulting score if both Red and Blue play optimally.\\n\\nExamples\\n\\nInput\\n\\n\\n4 2\\n1 2\\n1 3\\n1 4\\n\\n\\nOutput\\n\\n\\n1\\n\\n\\nInput\\n\\n\\n5 2\\n1 2\\n2 3\\n3 4\\n4 5\\n\\n\\nOutput\\n\\n\\n6\\n\\n\\nInput\\n\\n\\n7...\\nUsing java can you solve the prior task?\",\"targets\":\"import java.io.*;\\nimport java.util.*;\\n\\npublic class CF1615E extends PrintWriter {\\n\\tCF1615E() { super(System.out, true); }\\n\\tScanner sc = new Scanner(System.in);\\n\\tpublic static void main(String[] $) {\\n\\t\\tCF1615E o = new CF1615E(); o.main(); o.flush();\\n\\t}\\n\\n\\tint[] eo; int[][] ej;\\n\\tvoid append(int i, int j) {\\n\\t\\tint o = eo[i]++;\\n\\t\\tif (o >= 2 && (o & o - 1) == 0)\\n\\t\\t\\tej[i] = Arrays.copyOf(ej[i], o << 1);\\n\\t\\tej[i][o] = j;\\n\\t}\\n\\tboolean[] used; int[] pp, dd, xx;\\n\\tint dfs(int p, int i, int d) {\\n\\t\\tpp[i] = p;\\n\\t\\tdd[i] = d;\\n\\t\\tint x = i;\\n\\t\\tfor (int o = eo[i]; o-- > 0; ) {\\n\\t\\t\\tint j = ej[i][o];\\n\\t\\t\\tif (j != p) {\\n\\t\\t\\t\\tint y = dfs(i, j, d + 1);\\n\\t\\t\\t\\tif (dd[x] < dd[y])\\n\\t\\t\\t\\t\\tx = y;\\n\\t\\t\\t}\\n\\t\\t}\\n\\t\\treturn xx[i] = x;\\n\\t}\\n\\tint[] pq, iq; int cnt;\\n\\tboolean lt(int i, int j) {\\n\\t\\treturn dd[xx[i]] - dd[i] > dd[xx[j]] - dd[j];\\n\\t}\\n\\tint p2(int p) {\\n\\t\\treturn (p *= 2) > cnt ? 0 : p < cnt && lt(iq[p + 1], iq[p]) ? p + 1 : p;\\n\\t}\\n\\tvoid pq_up(int i) {\\n\\t\\tint j, p, q;\\n\\t\\tfor (p = pq[i]; (q = p \\/ 2) > 0 && lt(i, j = iq[q]); p = q)\\n\\t\\t\\tiq[pq[j] = p] = j;\\n\\t\\tiq[pq[i] = p] = i;\\n\\t}\\n\\tvoid pq_dn(int i) {\\n\\t\\tint j, p, q;\\n\\t\\tfor (p = pq[i]; (q = p2(p)) > 0 && lt(j = iq[q], i); p = q)\\n\\t\\t\\tiq[pq[j] = p] = j;\\n\\t\\tiq[pq[i] = p] = i;\\n\\t}\\n\\tvoid pq_add(int i) {\\n\\t\\tpq[i] = ++cnt; pq_up(i);\\n\\t}\\n\\tint pq_remove_first() {\\n\\t\\tint i = iq[1], j = iq[cnt--];\\n\\t\\tif (j != i) {\\n\\t\\t\\tpq[j] = 1; pq_dn(j);\\n\\t\\t}\\n\\t\\tpq[i] = 0;\\n\\t\\treturn i;\\n\\t}\\n\\tlong solve(int u, int v) {\\n\\t\\tif (u >= v)\\n\\t\\t\\treturn (long) u * v;\\n\\t\\tint a = (u + v) \\/ 2;\\n\\t\\treturn (long) a * (u + v - a);\\n\\t}\\n\\tlong solve(int r, int w, int wb) {\\n\\t\\tif (r >= wb)\\n\\t\\t\\treturn (long) w * (r - wb);\\n\\t\\treturn -solve(w, wb - r);\\n\\t}\\n\\tvoid main() {\\n\\t\\tint n = sc.nextInt();\\n\\t\\tint k = sc.nextInt();\\n\\t\\teo = new int[n]; ej = new int[n][2];\\n\\t\\tfor (int h = 0; h < n - 1; h++) {\\n\\t\\t\\tint i = sc.nextInt() - 1;\\n\\t\\t\\tint j = sc.nextInt() - 1;\\n\\t\\t\\tappend(i, j);\\n\\t\\t\\tappend(j, i);\\n\\t\\t}\\n\\t\\tused = new boolean[n]; pp = new int[n]; dd = new int[n]; xx = new int[n];\\n\\t\\tdfs(-1, 0, 0);\\n\\t\\tint w = 0, r = 0;\\n\\t\\tlong ans = solve(r, w, n - r - w);\\n\\t\\tpq = new int[n]; iq = new int[n + 1];\\n\\t\\tpq_add(0);\\n\\t\\twhile...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"A magic number is a number formed by concatenation of numbers 1, 14 and 144. We can use each of these numbers any number of times. Therefore 14144, 141414 and 1411 are magic numbers but 1444, 514 and 414 are not.\\n\\nYou're given a number. Determine if it is a magic number or not.\\n\\nInput\\n\\nThe first line of input contains an integer n, (1 \u2264 n \u2264 109). This number doesn't contain leading zeros.\\n\\nOutput\\n\\nPrint \\\"YES\\\" if n is a magic number or print \\\"NO\\\" if it's not.\\n\\nExamples\\n\\nInput\\n\\n114114\\n\\n\\nOutput\\n\\nYES\\n\\n\\nInput\\n\\n1111\\n\\n\\nOutput\\n\\nYES\\n\\n\\nInput\\n\\n441231\\n\\n\\nOutput\\n\\nNO\\nSolve the task in PYTHON.\",\"targets\":\"s=raw_input()\\nm=len(s)\\nflag=0\\n\\nif m==1:\\n    if s[0]!='1':\\n        flag=1\\n\\nelif m==2:\\n    temp=s[0]+s[1]\\n    if temp=='11' or temp=='14' or temp=='41' or temp=='44':\\n        flag=0\\n    else:\\n        flag=1\\n\\nelse:\\n    if s[0]=='1':    \\n        for i in range(3,m):\\n            if s[i]=='4':\\n                temp=s[i-1]+s[i-2]\\n                if temp=='11' or temp=='14' or temp=='41':\\n                    continue\\n                else:\\n                    flag=1\\n                    break\\n            elif s[i]!='1':\\n                flag=1\\n                break\\n    else:\\n        flag=1    \\n\\n\\nif flag==0:\\n    print \\\"YES\\\"\\nelse:\\n    print \\\"NO\\\"\",\"language\":\"python\",\"split\":\"train\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You have an array a consisting of n distinct positive integers, numbered from 1 to n. Define p_k as $$$p_k = \u2211_{1 \u2264 i, j \u2264 k} a_i mod a_j, where x \\\\bmod y denotes the remainder when x is divided by y. You have to find and print p_1, p_2, \\\\ldots, p_n$$$. \\n\\nInput\\n\\nThe first line contains n \u2014 the length of the array (2 \u2264 n \u2264 2 \u22c5 10^5).\\n\\nThe second line contains n space-separated distinct integers a_1, \u2026, a_n (1 \u2264 a_i \u2264 3 \u22c5 10^5, a_i \u2260 a_j if i \u2260 j). \\n\\nOutput\\n\\nPrint n integers p_1, p_2, \u2026, p_n. \\n\\nExamples\\n\\nInput\\n\\n\\n4\\n6 2 7 3\\n\\n\\nOutput\\n\\n\\n0 2 12 22\\n\\n\\nInput\\n\\n\\n3\\n3 2 1\\n\\n\\nOutput\\n\\n\\n0 3 5\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nstruct FT {\\n  vector<long long> s;\\n  FT(int n) : s(n) {}\\n  void update(int pos, long long dif) {\\n    for (; pos < (int)(s).size(); pos |= pos + 1) s[pos] += dif;\\n  }\\n  long long query(int pos) {\\n    long long res = 0;\\n    for (; pos > 0; pos &= pos - 1) res += s[pos - 1];\\n    return res;\\n  }\\n  long long query(int l, int r) { return query(r) - query(l); }\\n};\\nint main() {\\n  cin.tie(0)->sync_with_stdio(0);\\n  cin.exceptions(cin.failbit);\\n  int n;\\n  cin >> n;\\n  vector<int> a(n);\\n  for (int i = 0; i < (n); ++i) cin >> a[i];\\n  int MAX_A = *(max_element(begin(a), end(a)));\\n  FT A(MAX_A + 1);\\n  FT B(MAX_A + 1);\\n  long long p = 0;\\n  long long pref_sum = 0;\\n  for (int i = 0; i < n; i++) {\\n    p += pref_sum;\\n    p += (long long)i * a[i];\\n    p -= A.query(a[i] + 1);\\n    for (int j = a[i]; j <= MAX_A; j += a[i]) {\\n      int l = j, r = min(MAX_A + 1, j + a[i]);\\n      p -= B.query(l, r) * j;\\n      A.update(l, a[i]);\\n    }\\n    B.update(a[i], 1);\\n    cout << p << \\\" \\\";\\n    pref_sum += a[i];\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Akari has n kinds of flowers, one of each kind.\\n\\nShe is going to choose one or more of these flowers to make a bouquet.\\n\\nHowever, she hates two numbers a and b, so the number of flowers in the bouquet cannot be a or b.\\n\\nHow many different bouquets are there that Akari can make?\\n\\nFind the count modulo (10^9 + 7).\\n\\nHere, two bouquets are considered different when there is a flower that is used in one of the bouquets but not in the other bouquet.\\n\\nConstraints\\n\\n* All values in input are integers.\\n* 2 \\\\leq n \\\\leq 10^9\\n* 1 \\\\leq a < b \\\\leq \\\\textrm{min}(n, 2 \\\\times 10^5)\\n\\nInput\\n\\nInput is given from Standard Input in the following format:\\n\\n\\nn a b\\n\\n\\nOutput\\n\\nPrint the number of bouquets that Akari can make, modulo (10^9 + 7). (If there are no such bouquets, print `0`.)\\n\\nExamples\\n\\nInput\\n\\n4 1 3\\n\\n\\nOutput\\n\\n7\\n\\n\\nInput\\n\\n1000000000 141421 173205\\n\\n\\nOutput\\n\\n34076506\\nUsing python3 can you solve the prior task?\",\"targets\":\"from math import factorial\\n \\nM = 10**9 + 7\\nn, a, b = map(int, input().split())\\nr = pow(2, n, M) - 1\\nc = 1\\nfor i in range(b):\\n  c = c * (n - i) % M\\n  if i + 1 == a:\\n    r -= c * pow(factorial(a), M - 2, M)\\n    a = b\\nprint(r % M)\",\"language\":\"python\",\"split\":\"train\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Boboniu gives you\\n\\n  * r red balls, \\n  * g green balls, \\n  * b blue balls, \\n  * w white balls. \\n\\n\\n\\nHe allows you to do the following operation as many times as you want: \\n\\n  * Pick a red ball, a green ball, and a blue ball and then change their color to white. \\n\\n\\n\\nYou should answer if it's possible to arrange all the balls into a palindrome after several (possibly zero) number of described operations. \\n\\nInput\\n\\nThe first line contains one integer T (1\u2264 T\u2264 100) denoting the number of test cases.\\n\\nFor each of the next T cases, the first line contains four integers r, g, b and w (0\u2264 r,g,b,w\u2264 10^9).\\n\\nOutput\\n\\nFor each test case, print \\\"Yes\\\" if it's possible to arrange all the balls into a palindrome after doing several (possibly zero) number of described operations. Otherwise, print \\\"No\\\".\\n\\nExample\\n\\nInput\\n\\n\\n4\\n0 1 1 1\\n8 1 9 3\\n0 0 0 0\\n1000000000 1000000000 1000000000 1000000000\\n\\n\\nOutput\\n\\n\\nNo\\nYes\\nYes\\nYes\\n\\nNote\\n\\nIn the first test case, you're not able to do any operation and you can never arrange three balls of distinct colors into a palindrome.\\n\\nIn the second test case, after doing one operation, changing (8,1,9,3) to (7,0,8,6), one of those possible palindromes may be \\\"rrrwwwbbbbrbbbbwwwrrr\\\".\\n\\nA palindrome is a word, phrase, or sequence that reads the same backwards as forwards. For example, \\\"rggbwbggr\\\", \\\"b\\\", \\\"gg\\\" are palindromes while \\\"rgbb\\\", \\\"gbbgr\\\" are not. Notice that an empty word, phrase, or sequence is palindrome.\\nSolve the task in PYTHON3.\",\"targets\":\"for s in range(int(input())):\\n    rama=list(map(int,input().split()))\\n    add=0\\n    sum=0\\n    for i in range(4):\\n        if(rama[i]%2==0):\\n            add+=1\\n    if(add>=3):\\n        sum+=1\\n    for i in range(4):\\n        if(i==3):\\n            rama[i]+=3\\n        else:\\n            rama[i]-=1\\n    add=0\\n    for i in range(4):\\n        if(rama[i]>=0):\\n            if(rama[i]%2==0):\\n                add+=1\\n        else:\\n            flag=2\\n            break\\n    if(add>=3):\\n        sum+=1\\n    if(sum==0):\\n        print(\\\"No\\\")\\n    else:\\n        print(\\\"Yes\\\")\",\"language\":\"python\",\"split\":\"train\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"There are n candles on a Hanukkah menorah, and some of its candles are initially lit. We can describe which candles are lit with a binary string s, where the i-th candle is lit if and only if s_i=1.\\n\\n<image>\\n\\nInitially, the candle lights are described by a string a. In an operation, you select a candle that is currently lit. By doing so, the candle you selected will remain lit, and every other candle will change (if it was lit, it will become unlit and if it was unlit, it will become lit).\\n\\nYou would like to make the candles look the same as string b. Your task is to determine if it is possible, and if it is, find the minimum number of operations required.\\n\\nInput\\n\\nThe first line contains an integer t (1\u2264 t\u2264 10^4) \u2014 the number of test cases. Then t cases follow.\\n\\nThe first line of each test case contains a single integer n (1\u2264 n\u2264 10^5) \u2014 the number of candles.\\n\\nThe second line contains a string a of length n consisting of symbols 0 and 1 \u2014 the initial pattern of lights.\\n\\nThe third line contains a string b of length n consisting of symbols 0 and 1 \u2014 the desired pattern of lights.\\n\\nIt is guaranteed that the sum of n does not exceed 10^5.\\n\\nOutput\\n\\nFor each test case, output the minimum number of operations required to transform a to b, or -1 if it's impossible.\\n\\nExample\\n\\nInput\\n\\n\\n5\\n5\\n11010\\n11010\\n2\\n01\\n11\\n3\\n000\\n101\\n9\\n100010111\\n101101100\\n9\\n001011011\\n011010101\\n\\n\\nOutput\\n\\n\\n0\\n1\\n-1\\n3\\n4\\n\\nNote\\n\\nIn the first test case, the two strings are already equal, so we don't have to perform any operations.\\n\\nIn the second test case, we can perform a single operation selecting the second candle to transform 01 into 11.\\n\\nIn the third test case, it's impossible to perform any operations because there are no lit candles to select.\\n\\nIn the fourth test case, we can perform the following operations to transform a into b: \\n\\n  1. Select the 7-th candle: 100010{\\\\color{red}1}11\u2192 011101{\\\\color{red} 1}00. \\n  2. Select the 2-nd candle: 0{\\\\color{red} 1}1101100\u2192 1{\\\\color{red} 1}0010011. \\n  3. Select the 1-st candle: {\\\\color{red}1}10010011\u2192...\\nfor _\",\"targets\":\"in range(int(input())):\\n  n = int(input())\\n  a = input()\\n  b = input()\\n\\n  counts = [0, 0, 0, 0]\\n  ones = [0, 0]\\n  for i in range(n):\\n    counts[int(a[i]) * 2 + int(b[i])] += 1\\n    ones[0] += a[i] == '1'\\n    ones[1] += b[i] == '1'\\n\\n  ops = 1e9\\n  if ones[0] == ones[1]:\\n    ops = min(ops, counts[1] + counts[2])\\n  if n - ones[0] + 1 == ones[1]:\\n    # we switch all ones in A, except one, to zeros; all zeros to ones\\n    # 00 -> 10\\n    # 01 -> 11\\n    # 10 -> 00 (once 10)\\n    # 11 -> 01 (once 11)\\n    if counts[3]: # 11 present\\n      counts = [counts[2], counts[3] - 1, counts[0], counts[1] + 1]\\n      ops = min(ops, counts[1] + counts[2] + 1)\\n    else: # 10 is present, as there is at least 1 one in A\\n      counts = [counts[2] - 1, counts[3], counts[0] + 1, counts[1]]\\n      ops = min(ops, counts[1] + counts[2] + 1)\\n  \\n  if ops > 1e8:\\n    print(-1)\\n  else:\\n    print(ops)\",\"language\":\"python\",\"split\":\"test\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"A class of students wrote a multiple-choice test.\\n\\nThere are n students in the class. The test had m questions, each of them had 5 possible answers (A, B, C, D or E). There is exactly one correct answer for each question. The correct answer for question i worth a_i points. Incorrect answers are graded with zero points.\\n\\nThe students remember what answers they gave on the exam, but they don't know what are the correct answers. They are very optimistic, so they want to know what is the maximum possible total score of all students in the class. \\n\\nInput\\n\\nThe first line contains integers n and m (1 \u2264 n, m \u2264 1000) \u2014 the number of students in the class and the number of questions in the test.\\n\\nEach of the next n lines contains string s_i (|s_i| = m), describing an answer of the i-th student. The j-th character represents the student answer (A, B, C, D or E) on the j-th question.\\n\\nThe last line contains m integers a_1, a_2, \u2026, a_m (1 \u2264 a_i \u2264 1000) \u2014 the number of points for the correct answer for every question.\\n\\nOutput\\n\\nPrint a single integer \u2014 the maximum possible total score of the class.\\n\\nExamples\\n\\nInput\\n\\n\\n2 4\\nABCD\\nABCE\\n1 2 3 4\\n\\n\\nOutput\\n\\n\\n16\\n\\nInput\\n\\n\\n3 3\\nABC\\nBCD\\nCDE\\n5 4 12\\n\\n\\nOutput\\n\\n\\n21\\n\\nNote\\n\\nIn the first example, one of the most optimal test answers is \\\"ABCD\\\", this way the total number of points will be 16.\\n\\nIn the second example, one of the most optimal test answers is \\\"CCC\\\", this way each question will be answered by exactly one student and the total number of points is 5 + 4 + 12 = 21.\\nSolve the task in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint A[1000 + 113], B[1000 + 113], C[1000 + 113], D[1000 + 113], E[1000 + 113];\\nint main() {\\n  int n, m;\\n  cin >> n >> m;\\n  for (int i = 1; i <= n; ++i) {\\n    string s;\\n    cin >> s;\\n    for (int j = 0; j < s.size(); ++j) {\\n      if (s[j] == 'A') {\\n        A[j + 1]++;\\n      }\\n      if (s[j] == 'B') {\\n        B[j + 1]++;\\n      }\\n      if (s[j] == 'C') {\\n        C[j + 1]++;\\n      }\\n      if (s[j] == 'D') D[j + 1]++;\\n      if (s[j] == 'E') E[j + 1]++;\\n    }\\n  }\\n  long long ans = 0;\\n  for (int i = 1; i <= m; ++i) {\\n    int x;\\n    cin >> x;\\n    ans += max(max(max(max(A[i], B[i]), C[i]), D[i]), E[i]) * x;\\n  }\\n  cout << ans;\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Appleman has a tree with n vertices. Some of the vertices (at least one) are colored black and other vertices are colored white.\\n\\nConsider a set consisting of k (0 \u2264 k < n) edges of Appleman's tree. If Appleman deletes these edges from the tree, then it will split into (k + 1) parts. Note, that each part will be a tree with colored vertices.\\n\\nNow Appleman wonders, what is the number of sets splitting the tree in such a way that each resulting part will have exactly one black vertex? Find this number modulo 1000000007 (109 + 7).\\n\\nInput\\n\\nThe first line contains an integer n (2 \u2264 n \u2264 105) \u2014 the number of tree vertices. \\n\\nThe second line contains the description of the tree: n - 1 integers p0, p1, ..., pn - 2 (0 \u2264 pi \u2264 i). Where pi means that there is an edge connecting vertex (i + 1) of the tree and vertex pi. Consider tree vertices are numbered from 0 to n - 1.\\n\\nThe third line contains the description of the colors of the vertices: n integers x0, x1, ..., xn - 1 (xi is either 0 or 1). If xi is equal to 1, vertex i is colored black. Otherwise, vertex i is colored white.\\n\\nOutput\\n\\nOutput a single integer \u2014 the number of ways to split the tree modulo 1000000007 (109 + 7).\\n\\nExamples\\n\\nInput\\n\\n3\\n0 0\\n0 1 1\\n\\n\\nOutput\\n\\n2\\n\\n\\nInput\\n\\n6\\n0 1 1 0 4\\n1 1 0 0 1 0\\n\\n\\nOutput\\n\\n1\\n\\n\\nInput\\n\\n10\\n0 1 2 1 4 4 4 0 8\\n0 0 0 1 0 1 1 0 0 1\\n\\n\\nOutput\\n\\n27\\nSolve the task in JAVA.\",\"targets\":\"import java.util.ArrayList;\\nimport java.util.List;\\nimport java.util.Scanner;\\n\\npublic class Main {\\n\\n\\tstatic int n;\\n\\tstatic List<List<Integer>> v;\\n\\tstatic int[] color;\\n\\tstatic long[][] dp;\\n\\tstatic final int MOD = 1000000007;\\n\\n\\tpublic static void main(String[] args) {\\n\\t\\tScanner cin = new Scanner(System.in);\\n\\n\\t\\twhile (cin.hasNext()) {\\n\\t\\t\\tn = cin.nextInt();\\n\\t\\t\\tcolor = new int[n];\\n\\t\\t\\tdp = new long[n][2];\\n\\t\\t\\tv = new ArrayList<List<Integer>>();\\n\\t\\t\\tfor (int i = 0; i < n; i++)\\n\\t\\t\\t\\tv.add(new ArrayList<Integer>());\\n\\n\\t\\t\\tfor (int i = 1; i < n; i++) {\\n\\t\\t\\t\\tint p = cin.nextInt();\\n\\t\\t\\t\\tv.get(i).add(p);\\n\\t\\t\\t\\tv.get(p).add(i);\\n\\t\\t\\t}\\n\\t\\t\\tfor (int i = 0; i < n; i++)\\n\\t\\t\\t\\tcolor[i] = cin.nextInt();\\n\\n\\t\\t\\tdfs(0, -1);\\n\\n\\t\\t\\tSystem.out.println(dp[0][1]);\\n\\t\\t}\\n\\t\\tcin.close();\\n\\t}\\n\\n\\tprivate static void dfs(int i, int fa) {\\n\\t\\tdp[i][color[i]] = 1;\\n\\t\\tfor (int j : v.get(i)) {\\n\\t\\t\\tif (j != fa) {\\n\\t\\t\\t\\tdfs(j, i);\\n\\t\\t\\t\\tdp[i][1] = (dp[i][1] * (dp[j][0] + dp[j][1]) % MOD + dp[i][0]\\n\\t\\t\\t\\t\\t\\t* dp[j][1] % MOD)\\n\\t\\t\\t\\t\\t\\t% MOD;\\n\\t\\t\\t\\tdp[i][0] = dp[i][0] * (dp[j][0] + dp[j][1]) % MOD;\\n\\t\\t\\t}\\n\\t\\t}\\n\\t}\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Morning desert sun horizon\\n\\nRise above the sands of time...\\n\\nFates Warning, \\\"Exodus\\\"\\n\\nAfter crossing the Windswept Wastes, Ori has finally reached the Windtorn Ruins to find the Heart of the Forest! However, the ancient repository containing this priceless Willow light did not want to open!\\n\\nOri was taken aback, but the Voice of the Forest explained to him that the cunning Gorleks had decided to add protection to the repository.\\n\\nThe Gorleks were very fond of the \\\"string expansion\\\" operation. They were also very fond of increasing subsequences.\\n\\nSuppose a string s_1s_2s_3 \u2026 s_n is given. Then its \\\"expansion\\\" is defined as the sequence of strings s_1, s_1 s_2, ..., s_1 s_2 \u2026 s_n, s_2, s_2 s_3, ..., s_2 s_3 \u2026 s_n, s_3, s_3 s_4, ..., s_{n-1} s_n, s_n. For example, the \\\"expansion\\\" the string 'abcd' will be the following sequence of strings: 'a', 'ab', 'abc', 'abcd', 'b', 'bc', 'bcd', 'c', 'cd', 'd'. \\n\\nTo open the ancient repository, Ori must find the size of the largest increasing subsequence of the \\\"expansion\\\" of the string s. Here, strings are compared lexicographically.\\n\\nHelp Ori with this task!\\n\\nA string a is lexicographically smaller than a string b if and only if one of the following holds:\\n\\n  * a is a prefix of b, but a \u2260 b;\\n  * in the first position where a and b differ, the string a has a letter that appears earlier in the alphabet than the corresponding letter in b.\\n\\nInput\\n\\nEach test contains multiple test cases.\\n\\nThe first line contains one positive integer t (1 \u2264 t \u2264 10^3), denoting the number of test cases. Description of the test cases follows.\\n\\nThe first line of each test case contains one positive integer n (1 \u2264 n \u2264 5000) \u2014 length of the string.\\n\\nThe second line of each test case contains a non-empty string of length n, which consists of lowercase latin letters.\\n\\nIt is guaranteed that the sum of n over all test cases does not exceed 10^4.\\n\\nOutput\\n\\nFor every test case print one non-negative integer \u2014 the answer to the...\\nUsing cpp can you solve the prior task?\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst int INF = 0x3f3f3f3f;\\nconst long long INF64 = 0x3f3f3f3f3f3f3f3f;\\nconst double PI = acos(-1);\\ntypedef std::priority_queue<int, vector<int>, greater<int>> small_pq;\\ntypedef std::priority_queue<int, vector<int>, less<int>> big_pq;\\ntemplate <typename A, typename B>\\nostream &operator<<(ostream &os, const pair<A, B> &p) {\\n  return os << '(' << p.first << \\\", \\\" << p.second << ')';\\n}\\ntemplate <typename T_container, typename T = typename enable_if<\\n                                    !is_same<T_container, string>::value,\\n                                    typename T_container::value_type>::type>\\nostream &operator<<(ostream &os, const T_container &v) {\\n  os << '{';\\n  string sep;\\n  for (const T &x : v) os << sep << x, sep = \\\", \\\";\\n  return os << '}';\\n}\\nvoid dbg_out() {}\\ntemplate <typename Head, typename... Tail>\\nvoid dbg_out(Head H, Tail... T) {\\n  cerr << \\\" \\\" << H;\\n  if (sizeof...(T) > 0) cerr << \\\" ,\\\";\\n  dbg_out(T...);\\n}\\nvoid dbg_name(const string &s) {\\n  string ss = s;\\n  replace(ss.begin(), ss.end(), ',', ' ');\\n  cerr << \\\"  ( \\\" << ss << \\\" )  \\\";\\n}\\ntemplate <typename T>\\ninline void setmin(T &a, const T &b) {\\n  if (b < a) a = b;\\n}\\ntemplate <typename T>\\ninline void setmax(T &a, const T &b) {\\n  if (b > a) a = b;\\n}\\nstruct custom_hash {\\n  static uint64_t splitmix64(uint64_t x) {\\n    x += 0x9e3779b97f4a7c15;\\n    x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;\\n    x = (x ^ (x >> 27)) * 0x94d049bb133111eb;\\n    return x ^ (x >> 31);\\n  }\\n  size_t operator()(uint64_t x) const {\\n    static const uint64_t FIXED_RANDOM =\\n        chrono::steady_clock::now().time_since_epoch().count();\\n    return splitmix64(x + FIXED_RANDOM);\\n  }\\n};\\nunordered_map<long long, int, custom_hash> safe_map;\\nmt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());\\nmt19937_64 rnd64(chrono::steady_clock::now().time_since_epoch().count());\\nconst int MOD = 998244353;\\nint mul(int x, int y) { return 1ll * x * y % MOD; }\\nint add(int x, int y) { return ((x + y) % MOD + MOD) % MOD; }\\nint sub(int x, int y) {...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in JAVA?\\nOn a circle lie 2n distinct points, with the following property: however you choose 3 chords that connect 3 disjoint pairs of points, no point strictly inside the circle belongs to all 3 chords. The points are numbered 1,   2,   ...,   2n in clockwise order.\\n\\nInitially, k chords connect k pairs of points, in such a way that all the 2k endpoints of these chords are distinct.\\n\\nYou want to draw n - k additional chords that connect the remaining 2(n - k) points (each point must be an endpoint of exactly one chord).\\n\\nIn the end, let x be the total number of intersections among all n chords. Compute the maximum value that x can attain if you choose the n - k chords optimally.\\n\\nNote that the exact position of the 2n points is not relevant, as long as the property stated in the first paragraph holds.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 100) \u2014 the number of test cases. Then t test cases follow.\\n\\nThe first line of each test case contains two integers n and k (1 \u2264 n \u2264 100, 0 \u2264 k \u2264 n) \u2014 half the number of points and the number of chords initially drawn.\\n\\nThen k lines follow. The i-th of them contains two integers x_i and y_i (1 \u2264 x_i,   y_i \u2264 2n, x_i \u2260 y_i) \u2014 the endpoints of the i-th chord. It is guaranteed that the 2k numbers x_1,   y_1,   x_2,   y_2,   ...,   x_k,   y_k are all distinct.\\n\\nOutput\\n\\nFor each test case, output the maximum number of intersections that can be obtained by drawing n - k additional chords.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n4 2\\n8 2\\n1 5\\n1 1\\n2 1\\n2 0\\n10 6\\n14 6\\n2 20\\n9 10\\n13 18\\n15 12\\n11 7\\n\\n\\nOutput\\n\\n\\n4\\n0\\n1\\n14\\n\\nNote\\n\\nIn the first test case, there are three ways to draw the 2 additional chords, shown below (black chords are the ones initially drawn, while red chords are the new ones):\\n\\n<image>\\n\\nWe see that the third way gives the maximum number of intersections, namely 4.\\n\\nIn the second test case, there are no more chords to draw. Of course, with only one chord present there are no intersections.\\n\\nIn the third test case, we can make at most one intersection by drawing chords 1-3 and 2-4, as...\",\"targets\":\"import java.io.*;\\nimport java.util.*;\\npublic class Main {\\n    public static void main(String args[])\\n    {\\n        FastReader input=new FastReader();\\n        PrintWriter out=new PrintWriter(System.out);\\n        int T=input.nextInt();\\n        while(T-->0)\\n        {\\n            int n=input.nextInt();\\n            int k=input.nextInt();\\n            ArrayList<Pair> list=new ArrayList<>();\\n            HashSet<Integer> set=new HashSet<>();\\n            for(int i=0;i<k;i++)\\n            {\\n                int x=input.nextInt();\\n                int y=input.nextInt();\\n                int x1=Math.min(x,y);\\n                int y1=Math.max(x,y);\\n                list.add(new Pair(x1,y1));\\n                set.add(x);\\n                set.add(y);\\n            }\\n            ArrayList<Integer> l=new ArrayList<>();\\n            for(int i=1;i<=2*n;i++)\\n            {\\n                if(!set.contains(i))\\n                {\\n                    l.add(i);\\n                }\\n            }\\n            for(int i=0;i<l.size()\\/2;i++)\\n            {\\n                list.add(new Pair(l.get(i),l.get((l.size()\\/2)+i)));\\n            }\\n            Collections.sort(list, new Comparator<Pair>() {\\n                @Override\\n                public int compare(Pair o1, Pair o2) {\\n                    return o1.x-o2.x;\\n                }\\n            });\\n            int c=0;\\n            for(int i=0;i<list.size();i++)\\n            {\\n                for(int j=0;j<i;j++)\\n                {\\n                    if(list.get(j).y<list.get(i).y && list.get(j).y>list.get(i).x)\\n                    {\\n                        c++;\\n                    }\\n                }\\n            }\\n            out.println(c);\\n        }\\n        out.close();\\n    }\\n    static class Pair\\n    {\\n        int x,y;\\n        Pair(int x,int y)\\n        {\\n            this.x=x;\\n            this.y=y;\\n        }\\n    }\\n    static class FastReader\\n    {\\n        BufferedReader br;\\n        StringTokenizer st;\\n        public FastReader()\\n        {\\n            br = new BufferedReader(new...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You are given a book with n chapters.\\n\\nEach chapter has a specified list of other chapters that need to be understood in order to understand this chapter. To understand a chapter, you must read it after you understand every chapter on its required list.\\n\\nCurrently you don't understand any of the chapters. You are going to read the book from the beginning till the end repeatedly until you understand the whole book. Note that if you read a chapter at a moment when you don't understand some of the required chapters, you don't understand this chapter.\\n\\nDetermine how many times you will read the book to understand every chapter, or determine that you will never understand every chapter no matter how many times you read the book.\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 2\u22c510^4).\\n\\nThe first line of each test case contains a single integer n (1 \u2264 n \u2264 2\u22c510^5) \u2014 number of chapters.\\n\\nThen n lines follow. The i-th line begins with an integer k_i (0 \u2264 k_i \u2264 n-1) \u2014 number of chapters required to understand the i-th chapter. Then k_i integers a_{i,1}, a_{i,2}, ..., a_{i, k_i} (1 \u2264 a_{i, j} \u2264 n, a_{i, j} \u2260 i, a_{i, j} \u2260 a_{i, l} for j \u2260 l) follow \u2014 the chapters required to understand the i-th chapter.\\n\\nIt is guaranteed that the sum of n and sum of k_i over all testcases do not exceed 2\u22c510^5.\\n\\nOutput\\n\\nFor each test case, if the entire book can be understood, print how many times you will read it, otherwise print -1.\\n\\nExample\\n\\nInput\\n\\n\\n5\\n4\\n1 2\\n0\\n2 1 4\\n1 2\\n5\\n1 5\\n1 1\\n1 2\\n1 3\\n1 4\\n5\\n0\\n0\\n2 1 2\\n1 2\\n2 2 1\\n4\\n2 2 3\\n0\\n0\\n2 3 2\\n5\\n1 2\\n1 3\\n1 4\\n1 5\\n0\\n\\n\\nOutput\\n\\n\\n2\\n-1\\n1\\n2\\n5\\n\\nNote\\n\\nIn the first example, we will understand chapters \\\\{2, 4\\\\} in the first reading and chapters \\\\{1, 3\\\\} in the second reading of the book.\\n\\nIn the second example, every chapter requires the understanding of some other chapter, so it is impossible to understand the book.\\n\\nIn the third example, every chapter requires only chapters that appear earlier in the book, so we can understand everything in one...\\nSolve the task in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst long long maxn = 2 * 1e5 + 10;\\nvector<long long> a[maxn];\\nlong long i, j, k, mm[maxn], t, n, aa, m;\\nlong long dfs(long long i) {\\n  if (a[i].empty()) return 1;\\n  if (mm[i] != 0) return mm[i];\\n  mm[i] = -1;\\n  long long count = -1;\\n  for (long long j = 0; j < a[i].size(); j++) {\\n    long long k = dfs(a[i][j]);\\n    if (k == -1) return -1;\\n    if (a[i][j] < i)\\n      count = max(count, k);\\n    else\\n      count = max(count, k + 1);\\n  }\\n  mm[i] = count;\\n  return count;\\n}\\nint main() {\\n  scanf(\\\"%lld\\\", &t);\\n  while (t--) {\\n    scanf(\\\"%lld\\\", &n);\\n    memset(mm, 0, sizeof(mm));\\n    for (i = 1; i <= n; i++) {\\n      a[i].clear();\\n      scanf(\\\"%lld\\\", &aa);\\n      j = aa;\\n      while (j--) {\\n        scanf(\\\"%lld\\\", &m);\\n        a[i].push_back(m);\\n      }\\n    }\\n    long long flag = 0, val = -1;\\n    for (i = 1; i <= n; i++) {\\n      k = dfs(i);\\n      if (k == -1) {\\n        flag = 1;\\n        break;\\n      }\\n      val = max(val, k);\\n    }\\n    if (flag)\\n      printf(\\\"-1\\\\n\\\");\\n    else\\n      printf(\\\"%lld\\\\n\\\", val);\\n  }\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"During the programming classes Vasya was assigned a difficult problem. However, he doesn't know how to code and was unable to find the solution in the Internet, so he asks you to help.\\n\\nYou are given a sequence a, consisting of n distinct integers, that is used to construct the binary search tree. Below is the formal description of the construction process.\\n\\n  1. First element a_1 becomes the root of the tree. \\n  2. Elements a_2, a_3, \u2026, a_n are added one by one. To add element a_i one needs to traverse the tree starting from the root and using the following rules: \\n    1. The pointer to the current node is set to the root. \\n    2. If a_i is greater than the value in the current node, then its right child becomes the current node. Otherwise, the left child of the current node becomes the new current node. \\n    3. If at some point there is no required child, the new node is created, it is assigned value a_i and becomes the corresponding child of the current node. \\n\\nInput\\n\\nThe first line of the input contains a single integer n (2 \u2264 n \u2264 100 000) \u2014 the length of the sequence a.\\n\\nThe second line contains n distinct integers a_i (1 \u2264 a_i \u2264 10^9) \u2014 the sequence a itself.\\n\\nOutput\\n\\nOutput n - 1 integers. For all i > 1 print the value written in the node that is the parent of the node with value a_i in it.\\n\\nExamples\\n\\nInput\\n\\n3\\n1 2 3\\n\\n\\nOutput\\n\\n1 2\\n\\n\\nInput\\n\\n5\\n4 2 3 1 6\\n\\n\\nOutput\\n\\n4 2 2 4\\nUsing cpp can you solve the prior task?\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\ninline long long get_num(char ch) {\\n  if (ch == '-')\\n    return 0;\\n  else if (ch >= 'a' && ch <= 'z') {\\n    return 1 + (ch - 'a');\\n  } else if (ch >= 'A' && ch <= 'Z') {\\n    return 27 + (ch - 'A');\\n  } else if (ch >= '0' && ch <= '9') {\\n    return 53 + (ch - '0');\\n  }\\n}\\nint dx[] = {1, 0, -1, 0}, dy[] = {0, 1, 0, -1};\\ninline int GA(long long n, vector<long long>& vec) {\\n  for (long long i = 0; i < n; ++i) {\\n    long long x;\\n    cin >> x;\\n    vec.push_back(x);\\n  }\\n}\\ninline int GAEG(long long m, vector<long long> vec[]) {\\n  for (long long i = 0; i < m; ++i) {\\n    long long x, y;\\n    cin >> x >> y;\\n    x--, y--;\\n    vec[x].push_back(y);\\n    vec[y].push_back(x);\\n  }\\n}\\nset<long long> st;\\nset<long long>::iterator it;\\nmap<long long, bool> ri;\\nmap<long long, bool> le;\\nlong long ans[100001];\\nint main() {\\n  long long n;\\n  cin >> n;\\n  for (long long i = 0; i < n; ++i) {\\n    long long x;\\n    cin >> x;\\n    it = st.upper_bound(x);\\n    if (it != st.end() && !le[*it]) {\\n      le[*it] = true;\\n      ans[i] = *it;\\n    } else {\\n      if (!st.empty()) it--;\\n      ri[*(it)] = true;\\n      ans[i] = *it;\\n    }\\n    st.insert(x);\\n  }\\n  for (long long i = 1; i < n; ++i) cout << ans[i] << \\\" \\\";\\n  cout << endl;\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"An altar enshrines N stones arranged in a row from left to right. The color of the i-th stone from the left (1 \\\\leq i \\\\leq N) is given to you as a character c_i; `R` stands for red and `W` stands for white.\\n\\nYou can do the following two kinds of operations any number of times in any order:\\n\\n* Choose two stones (not necessarily adjacent) and swap them.\\n* Choose one stone and change its color (from red to white and vice versa).\\n\\n\\n\\nAccording to a fortune-teller, a white stone placed to the immediate left of a red stone will bring a disaster. At least how many operations are needed to reach a situation without such a white stone?\\n\\nConstraints\\n\\n* 2 \\\\leq N \\\\leq 200000\\n* c_i is `R` or `W`.\\n\\nInput\\n\\nInput is given from Standard Input in the following format:\\n\\n\\nN\\nc_{1}c_{2}...c_{N}\\n\\n\\nOutput\\n\\nPrint an integer representing the minimum number of operations needed.\\n\\nExamples\\n\\nInput\\n\\n4\\nWWRR\\n\\n\\nOutput\\n\\n2\\n\\n\\nInput\\n\\n2\\nRR\\n\\n\\nOutput\\n\\n0\\n\\n\\nInput\\n\\n8\\nWRWWRWRR\\n\\n\\nOutput\\n\\n3\\nThe above is tricky. Write me a correct solution in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\ntypedef long long ll;\\n#define rep(k,i,n) for(ll i=k;i<n;++i)\\nint main(void){\\n    ll n;\\n    cin>>n;\\n    string s;\\n    cin>>s;\\n    ll c=0,l=0;\\n    rep(0,i,n)if(s[i]=='W')++c;\\n    rep(0,i,c)if(s[n-1-i]=='W')++l;\\n    cout<<c-l;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"PYTHON3 solution for \\\"You are given two positive integers n and s. Find the maximum possible median of an array of n non-negative integers (not necessarily distinct), such that the sum of its elements is equal to s.\\n\\nA median of an array of integers of length m is the number standing on the \u2308 {m\\/2} \u2309-th (rounding up) position in the non-decreasing ordering of its elements. Positions are numbered starting from 1. For example, a median of the array [20,40,20,50,50,30] is the \u2308 m\\/2 \u2309-th element of [20,20,30,40,50,50], so it is 30. There exist other definitions of the median, but in this problem we use the described definition.\\n\\nInput\\n\\nThe input consists of multiple test cases. The first line contains a single integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases. Description of the test cases follows.\\n\\nEach test case contains a single line with two integers n and s (1 \u2264 n, s \u2264 10^9) \u2014 the length of the array and the required sum of the elements.\\n\\nOutput\\n\\nFor each test case print a single integer \u2014 the maximum possible median.\\n\\nExample\\n\\nInput\\n\\n\\n8\\n1 5\\n2 5\\n3 5\\n2 1\\n7 17\\n4 14\\n1 1000000000\\n1000000000 1\\n\\n\\nOutput\\n\\n\\n5\\n2\\n2\\n0\\n4\\n4\\n1000000000\\n0\\n\\nNote\\n\\nPossible arrays for the first three test cases (in each array the median is underlined):\\n\\n  * In the first test case [\\\\underline{5}] \\n  * In the second test case [\\\\underline{2}, 3] \\n  * In the third test case [1, \\\\underline{2}, 2] \\\":\",\"targets\":\"import math\\nfor t in range(int(input())):\\n\\tlen, sum = map(int, input().split())\\n\\tmedian = math.floor(len\\/2) + 1\\n\\tmaxMedian = math.floor(sum\\/median)\\n\\tprint(maxMedian)\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Ezzat has an array of n integers (maybe negative). He wants to split it into two non-empty subsequences a and b, such that every element from the array belongs to exactly one subsequence, and the value of f(a) + f(b) is the maximum possible value, where f(x) is the average of the subsequence x. \\n\\nA sequence x is a subsequence of a sequence y if x can be obtained from y by deletion of several (possibly, zero or all) elements.\\n\\nThe average of a subsequence is the sum of the numbers of this subsequence divided by the size of the subsequence.\\n\\nFor example, the average of [1,5,6] is (1+5+6)\\/3 = 12\\/3 = 4, so f([1,5,6]) = 4.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 10^3)\u2014 the number of test cases. Each test case consists of two lines.\\n\\nThe first line contains a single integer n (2 \u2264 n \u2264 10^5).\\n\\nThe second line contains n integers a_1, a_2, \u2026, a_n (-10^9 \u2264 a_i \u2264 10^9).\\n\\nIt is guaranteed that the sum of n over all test cases does not exceed 3\u22c510^5.\\n\\nOutput\\n\\nFor each test case, print a single value \u2014 the maximum value that Ezzat can achieve.\\n\\nYour answer is considered correct if its absolute or relative error does not exceed 10^{-6}.\\n\\nFormally, let your answer be a, and the jury's answer be b. Your answer is accepted if and only if \\\\frac{|a - b|}{max{(1, |b|)}} \u2264 10^{-6}.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n3\\n3 1 2\\n3\\n-7 -6 -6\\n3\\n2 2 2\\n4\\n17 3 5 -3\\n\\n\\nOutput\\n\\n\\n4.500000000\\n-12.500000000\\n4.000000000\\n18.666666667\\n\\nNote\\n\\nIn the first test case, the array is [3, 1, 2]. These are all the possible ways to split this array: \\n\\n  * a = [3], b = [1,2], so the value of f(a) + f(b) = 3 + 1.5 = 4.5. \\n  * a = [3,1], b = [2], so the value of f(a) + f(b) = 2 + 2 = 4. \\n  * a = [3,2], b = [1], so the value of f(a) + f(b) = 2.5 + 1 = 3.5. \\n\\nTherefore, the maximum possible value 4.5.\\n\\nIn the second test case, the array is [-7, -6, -6]. These are all the possible ways to split this array: \\n\\n  * a = [-7], b = [-6,-6], so the value of f(a) + f(b) = (-7) + (-6) = -13. \\n  * a = [-7,-6], b = [-6], so the value of f(a) + f(b) = (-6.5) + (-6) =...\",\"targets\":\"def solve():\\n    n = int(input())\\n    a = list(map(int,input().split()))\\n    a.sort()\\n    sumi = 0\\n    suma = sum(a)\\n    ans = -10 ** 18\\n    for i in range(n - 1):\\n        sumi += a[i]\\n        if sumi \\/ (i + 1) + (suma - sumi) \\/ (n - i - 1) > ans:\\n            ans = sumi \\/ (i + 1) + (suma - sumi) \\/ (n - i - 1)\\n    print(ans)\\n\\nt = int(input())\\n\\nfor _ in range(t):\\n    solve()\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Polycarp had an array a of 3 positive integers. He wrote out the sums of all non-empty subsequences of this array, sorted them in non-decreasing order, and got an array b of 7 integers.\\n\\nFor example, if a = \\\\{1, 4, 3\\\\}, then Polycarp wrote out 1, 4, 3, 1 + 4 = 5, 1 + 3 = 4, 4 + 3 = 7, 1 + 4 + 3 = 8. After sorting, he got an array b = \\\\{1, 3, 4, 4, 5, 7, 8\\\\}.\\n\\nUnfortunately, Polycarp lost the array a. He only has the array b left. Help him to restore the array a.\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 5000) \u2014 the number of test cases.\\n\\nEach test case consists of one line which contains 7 integers b_1, b_2, ..., b_7 (1 \u2264 b_i \u2264 10^9; b_i \u2264 b_{i+1}). \\n\\nAdditional constraint on the input: there exists at least one array a which yields this array b as described in the statement.\\n\\nOutput\\n\\nFor each test case, print 3 integers \u2014 a_1, a_2 and a_3. If there can be several answers, print any of them.\\n\\nExample\\n\\nInput\\n\\n\\n5\\n1 3 4 4 5 7 8\\n1 2 3 4 5 6 7\\n300000000 300000000 300000000 600000000 600000000 600000000 900000000\\n1 1 2 999999998 999999999 999999999 1000000000\\n1 2 2 3 3 4 5\\n\\n\\nOutput\\n\\n\\n1 4 3\\n4 1 2\\n300000000 300000000 300000000\\n999999998 1 1\\n1 2 2\\n\\nNote\\n\\nThe subsequence of the array a is a sequence that can be obtained from a by removing zero or more of its elements.\\n\\nTwo subsequences are considered different if index sets of elements included in them are different. That is, the values of the elements don't matter in the comparison of subsequences. In particular, any array of length 3 has exactly 7 different non-empty subsequences.\\nUsing cpp can you solve the prior task?\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint _t = 1;\\ntemplate <typename... T, typename Q>\\nvoid outputs(Q x, T&&... args) {\\n  cout << \\\"Case \\\" << _t++ << \\\": \\\" << x;\\n  ((cout << \\\" \\\" << args), ...);\\n  cout << '\\\\n';\\n}\\ntemplate <typename... T, typename Q>\\nvoid output(Q x, T&&... args) {\\n  cout << x;\\n  ((cout << \\\" \\\" << args), ...);\\n  cout << '\\\\n';\\n}\\nvoid solve() {\\n  int v[7];\\n  for (int i = 0; i < 7; i++) cin >> v[i];\\n  sort(v, v + 7);\\n  output(v[0], v[1], v[6] - v[1] - v[0]);\\n}\\nint main() {\\n  int t = 1;\\n  cin >> t;\\n  while (t--) solve();\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Alice wants to send an email to Miku on her mobile phone.\\n\\nThe only buttons that can be used for input on mobile phones are number buttons. Therefore, in order to input characters, the number buttons are pressed several times to input characters. The following characters are assigned to the number buttons of the mobile phone, and the confirmation button is assigned to button 0. With this mobile phone, you are supposed to press the confirm button after you finish entering one character.\\n\\n* 1:.,!? (Space)\\n* 2: a b c\\n* 3: d e f\\n* 4: g h i\\n* 5: j k l\\n* 6: m n o\\n* 7: p q r s\\n* 8: t u v\\n* 9: w x y z\\n* 0: Confirm button\\n\\n\\nFor example, if you press button 2, button 2, or button 0, the letter changes from'a'to'b', and the confirm button is pressed here, so the letter b is output. If you enter the same number in succession, the changing characters will loop. That is, if you press button 2 five times and then button 0, the letters change from'a'\u2192' b'\u2192'c' \u2192'a' \u2192'b', and the confirm button is pressed here. 'b' is output.\\n\\nYou can press the confirm button when no button is pressed, but in that case no characters are output.\\n\\nYour job is to recreate the message Alice created from a row of buttons pressed by Alice.\\n\\n\\n\\nInput\\n\\nThe first line gives the number of test cases. Each test case is then given a string of digits up to 1024 in length in one row.\\n\\nOutput\\n\\nPrint the string of Alice's message line by line for each test case. However, you can assume that the output is one or more and less than 76 characters.\\n\\nExample\\n\\nInput\\n\\n5\\n20\\n220\\n222220\\n44033055505550666011011111090666077705550301110\\n000555555550000330000444000080000200004440000\\n\\n\\nOutput\\n\\na\\nb\\nb\\nhello, world!\\nkeitai\\nThe above is tricky. Write me a correct solution in PYTHON3.\",\"targets\":\"def solve(mm, cmd):\\n\\tbf = cmd[0]\\n\\tc = 0\\n\\tans = \\\"\\\"\\n\\tfor s in cmd[1::]:\\n\\t\\t\\tif bf == s:\\n\\t\\t\\t\\tc += 1\\n\\t\\t\\telse:\\n\\t\\t\\t\\tif s == '0':\\n\\t\\t\\t\\t\\tans += mm[bf][c%len(mm[bf])]\\n\\t\\t\\t\\tc = 0\\n\\t\\t\\t\\tbf = s\\n\\treturn ans\\n\\ndef main():\\n\\tN = int(input())\\n\\tcc = [\\n\\t\\t[\\\".\\\",\\\",\\\",\\\"!\\\",\\\"?\\\",\\\" \\\"],\\n\\t\\t[\\\"a\\\",\\\"b\\\",\\\"c\\\"],\\n\\t\\t[\\\"d\\\",\\\"e\\\",\\\"f\\\"],\\n\\t\\t[\\\"g\\\",\\\"h\\\",\\\"i\\\"],\\n\\t\\t[\\\"j\\\",\\\"k\\\",\\\"l\\\"],\\n\\t\\t[\\\"m\\\",\\\"n\\\",\\\"o\\\"],\\n\\t\\t[\\\"p\\\",\\\"q\\\",\\\"r\\\",\\\"s\\\"],\\n\\t\\t[\\\"t\\\",\\\"u\\\",\\\"v\\\"],\\n\\t\\t[\\\"w\\\",\\\"x\\\",\\\"y\\\",\\\"z\\\"]]\\n\\tmm = dict(zip(\\n\\t\\t[str(i) for i in range(1,10)],\\n\\t\\tcc\\n\\t))\\n\\tfor _ in range(N):\\n\\t\\tcmd = input()\\n\\t\\tprint(solve(mm,cmd))\\n\\nif __name__ == '__main__':\\n\\tmain()\",\"language\":\"python\",\"split\":\"train\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Mr. Chanek has a new game called Dropping Balls. Initially, Mr. Chanek has a grid a of size n \u00d7 m\\n\\nEach cell (x,y) contains an integer a_{x,y} denoting the direction of how the ball will move.\\n\\n  * a_{x,y}=1 \u2014 the ball will move to the right (the next cell is (x, y + 1)); \\n  * a_{x,y}=2 \u2014 the ball will move to the bottom (the next cell is (x + 1, y)); \\n  * a_{x,y}=3 \u2014 the ball will move to the left (the next cell is (x, y - 1)). \\n\\n\\n\\nEvery time a ball leaves a cell (x,y), the integer a_{x,y} will change to 2. Mr. Chanek will drop k balls sequentially, each starting from the first row, and on the c_1, c_2, ..., c_k-th (1 \u2264 c_i \u2264 m) columns.\\n\\nDetermine in which column each ball will end up in (position of the ball after leaving the grid).\\n\\nInput\\n\\nThe first line contains three integers n, m, and k (1 \u2264 n, m \u2264 1000, 1 \u2264 k \u2264 10^5) \u2014 the size of the grid and the number of balls dropped by Mr. Chanek.\\n\\nThe i-th of the next n lines contains m integers a_{i,1},a_{i,2},\u2026,a_{i,m} (1 \u2264 a_{i,j} \u2264 3). It will satisfy a_{i, 1} \u2260 3 and a_{i, m} \u2260 1.\\n\\nThe next line contains k integers c_1, c_2, \u2026, c_k (1 \u2264 c_i \u2264 m) \u2014 the balls' column positions dropped by Mr. Chanek sequentially.\\n\\nOutput\\n\\nOutput k integers \u2014 the i-th integer denoting the column where the i-th ball will end.\\n\\nExamples\\n\\nInput\\n\\n\\n5 5 3\\n1 2 3 3 3\\n2 2 2 2 2\\n2 2 2 2 2\\n2 2 2 2 2\\n2 2 2 2 2\\n1 2 1\\n\\n\\nOutput\\n\\n\\n2 2 1 \\n\\n\\nInput\\n\\n\\n1 2 2\\n1 3\\n1 2\\n\\n\\nOutput\\n\\n\\n1 2 \\n\\nNote\\n\\nIn the first example, the first ball will drop as follows. Note that the cell (1, 1) will change direction to the bottom direction.\\n\\n<image>\\n\\nThe second and third balls will drop as follows. \\n\\n<image>\\n\\nAll balls will be dropped from the first row and on the c_1, c_2, ..., c_k-th columns respectively. A ball will stop dropping once it leaves the grid.\\nUsing java can you solve the prior task?\",\"targets\":\"\\/*\\n                       _oo0oo_\\n                      o8888888o\\n                      88\\\" . \\\"88\\n                      (| -_- |)\\n                      0\\\\  =  \\/0\\n                    ___\\/`---'\\\\___\\n                  .' \\\\\\\\|     |\\/\\/ '.\\n                 \\/ \\\\\\\\|||  :  |||\\/\\/ \\\\\\n                \\/ _||||| -:- |||||- \\\\\\n               |   | \\\\\\\\\\\\  -  \\/\\/\\/ |   |\\n               | \\\\_|  ''\\\\---\\/''  |_\\/ |\\n               \\\\  .-\\\\__  '-'  ___\\/-. \\/\\n             ___'. .'  \\/--.--\\\\  `. .'___\\n          .\\\"\\\" '<  `.___\\\\_<|>_\\/___.' >' \\\"\\\".\\n         | | :  `- \\\\`.;`\\\\ _ \\/`;.`\\/ - ` : | |\\n         \\\\  \\\\ `_.   \\\\_ __\\\\ \\/__ _\\/   .-` \\/  \\/\\n     =====`-.____`.___ \\\\_____\\/___.-`___.-'=====\\n                       `=---='\\n \\n*\\/\\n\\nimport java.util.*;\\nimport java.math.*;\\nimport java.io.*;\\nimport java.lang.Math.*;\\n\\n\\/\\/ @author : dhruvil_8803\\n\\npublic class KickStart2020 {\\n\\t static class FastReader {\\n\\t\\tBufferedReader br;\\n\\t\\tStringTokenizer st;\\n\\n\\t\\tpublic FastReader() {\\n\\t\\t\\tbr = new BufferedReader(new InputStreamReader(System.in));\\n\\t\\t}\\n\\n\\t\\tString next() {\\n\\t\\t\\twhile (st == null || !st.hasMoreElements()) {\\n\\t\\t\\t\\ttry {\\n\\t\\t\\t\\t\\tst = new StringTokenizer(br.readLine());\\n\\t\\t\\t\\t} catch (IOException e) {\\n\\t\\t\\t\\t\\te.printStackTrace();\\n\\t\\t\\t\\t}\\n\\t\\t\\t}\\n\\t\\t\\treturn st.nextToken();\\n\\t\\t}\\n\\n\\t\\tint nextInt() {\\n\\t\\t\\treturn Integer.parseInt(next());\\n\\t\\t}\\n\\n\\t\\tlong nextLong() {\\n\\t\\t\\treturn Long.parseLong(next());\\n\\t\\t}\\n\\n\\t\\tdouble nextDouble() {\\n\\t\\t\\treturn Double.parseDouble(next());\\n\\t\\t}\\n\\n\\t\\tfloat nextFloat() {\\n\\t\\t\\treturn Float.parseFloat(next());\\n\\t\\t}\\n\\n\\t\\tString nextLine() {\\n\\t\\t\\tString str = \\\"\\\";\\n\\t\\t\\ttry {\\n\\t\\t\\t\\tstr = br.readLine();\\n\\t\\t\\t} catch (IOException e) {\\n\\t\\t\\t\\te.printStackTrace();\\n\\t\\t\\t}\\n\\t\\t\\treturn str;\\n\\t\\t}\\n\\t}\\n\\n\\tstatic long gcd(long a, long b) {\\n\\t\\tif (b == 0)\\n\\t\\t\\treturn a;\\n\\t\\treturn gcd(b, a % b);\\n\\n\\t}\\n\\n\\tstatic long lcm(long a, long b) {\\n\\t\\treturn a \\/ gcd(a, b) * b;\\n\\t}\\n\\n\\tpublic static class Pair implements Comparable<Pair> {\\n\\t\\tpublic long index;\\n\\t\\tpublic long value;\\n\\n\\t\\tpublic Pair(long index, long value) {\\n\\t\\t\\tthis.index =...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in JAVA?\\nYou are given an array a consisting of n positive integers. You have to choose a positive integer d and paint all elements into two colors. All elements which are divisible by d will be painted red, and all other elements will be painted blue.\\n\\nThe coloring is called beautiful if there are no pairs of adjacent elements with the same color in the array. Your task is to find any value of d which yields a beautiful coloring, or report that it is impossible.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 1000) \u2014 the number of testcases.\\n\\nThe first line of each testcase contains one integer n (2 \u2264 n \u2264 100) \u2014 the number of elements of the array.\\n\\nThe second line of each testcase contains n integers a_1, a_2, ..., a_n (1 \u2264 a_i \u2264 10^{18}).\\n\\nOutput\\n\\nFor each testcase print a single integer. If there is no such value of d that yields a beautiful coloring, print 0. Otherwise, print any suitable value of d (1 \u2264 d \u2264 10^{18}).\\n\\nExample\\n\\nInput\\n\\n\\n5\\n5\\n1 2 3 4 5\\n3\\n10 5 15\\n3\\n100 10 200\\n10\\n9 8 2 6 6 2 8 6 5 4\\n2\\n1 3\\n\\n\\nOutput\\n\\n\\n2\\n0\\n100\\n0\\n3\",\"targets\":\"import java.util.*;\\npublic class Solution {\\n\\tpublic static long gcd(long a,long b) {\\n\\t\\tif(b==0)\\n\\t\\t\\treturn a;\\n\\t\\treturn gcd(b,a%b);\\n\\t}\\n\\tpublic static void main(String[] args) {\\n\\t\\tScanner sc=new Scanner(System.in);\\n\\t\\tint t=sc.nextInt();\\n\\t\\twhile(t--!=0) {\\n\\t\\t\\tint n=sc.nextInt();\\n\\t\\t\\tlong []a=new long[n];\\n\\t\\t\\t\\n\\t\\t\\tfor(int i=0;i<n;i++) {\\n\\t\\t\\t\\ta[i]=sc.nextLong();\\n\\t\\t\\t}\\n\\t\\t\\tlong d=0;\\n\\t\\t\\tlong gcd1=a[0];\\n\\t\\t\\tlong gcd2=a[1];\\n\\t\\t\\tfor(int i=2;i<n;i+=2) {\\n\\t\\t\\t\\tgcd1=gcd(gcd1,a[i]);\\n\\t\\t\\t}\\n\\t\\t\\tfor(int i=3;i<n;i+=2) {\\n\\t\\t\\t\\tgcd2=gcd(gcd2,a[i]);\\n\\t\\t\\t}\\n\\t\\t\\tint check=-1;\\n\\t\\t\\tif(gcd1!=1) {\\n\\t\\t\\t\\td=gcd1;\\n\\t\\t\\t\\tcheck=1;\\n\\t\\t\\t\\twhile(check<n) {\\n\\t\\t\\t\\t\\tif(a[check]%gcd1==0) {\\n\\t\\t\\t\\t\\t\\td=0;\\n\\t\\t\\t\\t\\t\\tbreak;\\n\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\t\\tcheck+=2;\\n\\t\\t\\t\\t}\\n\\t\\t\\t\\t\\n\\t\\t\\t}\\n\\t\\t\\tif(gcd2!=1 && d==0) {\\n\\t\\t\\t\\td=gcd2;\\n\\t\\t\\t\\tcheck=0;\\n\\t\\t\\t\\twhile(check<n) {\\n\\t\\t\\t\\t\\tif(a[check]%gcd2==0) {\\n\\t\\t\\t\\t\\t\\td=0;\\n\\t\\t\\t\\t\\t\\tbreak;\\n\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\t\\tcheck+=2;\\n\\t\\t\\t\\t}\\n\\t\\t\\t\\t\\n\\t\\t\\t}\\n\\t\\t\\tSystem.out.println(d );\\n\\t\\t}\\n\\t}\\n\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in PYTHON3?\\nA robot cleaner is placed on the floor of a rectangle room, surrounded by walls. The floor consists of n rows and m columns. The rows of the floor are numbered from 1 to n from top to bottom, and columns of the floor are numbered from 1 to m from left to right. The cell on the intersection of the r-th row and the c-th column is denoted as (r,c). The initial position of the robot is (r_b, c_b).\\n\\nIn one second, the robot moves by dr rows and dc columns, that is, after one second, the robot moves from the cell (r, c) to (r + dr, c + dc). Initially dr = 1, dc = 1. If there is a vertical wall (the left or the right walls) in the movement direction, dc is reflected before the movement, so the new value of dc is -dc. And if there is a horizontal wall (the upper or lower walls), dr is reflected before the movement, so the new value of dr is -dr.\\n\\nEach second (including the moment before the robot starts moving), the robot cleans every cell lying in the same row or the same column as its position. There is only one dirty cell at (r_d, c_d). The job of the robot is to clean that dirty cell.\\n\\n<image> Illustration for the first example. The blue arc is the robot. The red star is the target dirty cell. Each second the robot cleans a row and a column, denoted by yellow stripes.\\n\\nGiven the floor size n and m, the robot's initial position (r_b, c_b) and the dirty cell's position (r_d, c_d), find the time for the robot to do its job.\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 10^4). Description of the test cases follows.\\n\\nA test case consists of only one line, containing six integers n, m, r_b, c_b, r_d, and c_d (1 \u2264 n, m \u2264 100, 1 \u2264 r_b, r_d \u2264 n, 1 \u2264 c_b, c_d \u2264 m) \u2014 the sizes of the room, the initial position of the robot and the position of the dirt cell.\\n\\nOutput\\n\\nFor each test case, print an integer \u2014 the time for the robot to clean the dirty cell. We can show that the robot always cleans the dirty cell eventually.\\n\\nExample\\n\\nInput\\n\\n\\n5\\n10 10 6 1 2 8\\n10 10 9 9 1...\",\"targets\":\"a = int(input())\\nfor i in range(a):\\n    n , m, rb, cb, rd, cd = map(int, input().split())\\n    rk=1\\n    ck=1\\n    t=0\\n    while True:\\n        if rd==rb or cb==cd:\\n            break\\n        if rb==n or rd==0:\\n            rk*=-1\\n        if cb==m or cd==0:\\n            ck*=-1\\n        rb+=rk\\n        cb+=ck\\n        t+=1\\n    print(t)\",\"language\":\"python\",\"split\":\"test\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"There are n heaps of stone. The i-th heap has h_i stones. You want to change the number of stones in the heap by performing the following process once: \\n\\n  * You go through the heaps from the 3-rd heap to the n-th heap, in this order. \\n  * Let i be the number of the current heap. \\n  * You can choose a number d (0 \u2264 3 \u22c5 d \u2264 h_i), move d stones from the i-th heap to the (i - 1)-th heap, and 2 \u22c5 d stones from the i-th heap to the (i - 2)-th heap. \\n  * So after that h_i is decreased by 3 \u22c5 d, h_{i - 1} is increased by d, and h_{i - 2} is increased by 2 \u22c5 d. \\n  * You can choose different or same d for different operations. Some heaps may become empty, but they still count as heaps. \\n\\n\\n\\nWhat is the maximum number of stones in the smallest heap after the process?\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 2\u22c5 10^5). Description of the test cases follows.\\n\\nThe first line of each test case contains a single integer n (3 \u2264 n \u2264 2 \u22c5 10^5).\\n\\nThe second lines of each test case contains n integers h_1, h_2, h_3, \u2026, h_n (1 \u2264 h_i \u2264 10^9).\\n\\nIt is guaranteed that the sum of n over all test cases does not exceed 2 \u22c5 10^5.\\n\\nOutput\\n\\nFor each test case, print the maximum number of stones that the smallest heap can contain.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n4\\n1 2 10 100\\n4\\n100 100 100 1\\n5\\n5 1 1 1 8\\n6\\n1 2 3 4 5 6\\n\\n\\nOutput\\n\\n\\n7\\n1\\n1\\n3\\n\\nNote\\n\\nIn the first test case, the initial heap sizes are [1, 2, 10, 100]. We can move the stones as follows. \\n\\n  * move 3 stones and 6 from the 3-rd heap to the 2-nd and 1 heap respectively. The heap sizes will be [7, 5, 1, 100]; \\n  * move 6 stones and 12 stones from the last heap to the 3-rd and 2-nd heap respectively. The heap sizes will be [7, 17, 7, 82]. \\n\\n\\n\\nIn the second test case, the last heap is 1, and we can not increase its size.\\n\\nIn the third test case, it is better not to move any stones.\\n\\nIn the last test case, the final achievable configuration of the heaps can be [3, 5, 3, 4, 3, 3].\",\"targets\":\"import java.io.BufferedReader;\\nimport java.io.IOException;\\nimport java.io.InputStreamReader;\\nimport java.util.*;\\n\\npublic class Main {\\n    public static boolean check(int[] pile, int ans) {\\n        int[] cpy = new int[pile.length];\\n        for(int i =0;i< pile.length;i++) cpy[i] = pile[i];\\n        for(int i= cpy.length-1;i>=2;i--) {\\n            if(cpy[i] > ans) {\\n                int diff = (cpy[i] - ans);\\n                int d = Math.min(diff, pile[i])\\/3;\\n                cpy[i] -= 3*d;\\n                cpy[i-1] += d;\\n                cpy[i-2] += 2*d;\\n            }\\n            if(cpy[i] < ans) return false;\\n        }\\n        return cpy[0] >= ans && cpy[1] >= ans;\\n    }\\n    public static void main(String[] args) throws IOException {\\n        var br = new BufferedReader(new InputStreamReader(System.in));\\n        var t = Integer.parseInt(br.readLine());\\n        while(t-->0){\\n            int l=Integer.MAX_VALUE,h=1;\\n            int n = Integer.parseInt(br.readLine());\\n            var st = new StringTokenizer(br.readLine());\\n            int[] p = new int[n];\\n            for(int i =0;i<n;i++) {\\n                p[i] = Integer.parseInt(st.nextToken());\\n                l = Math.min(l, p[i]);\\n                h = Math.max(h, p[i]);\\n            }\\n            int ans = l;\\n            while(l<=h) {\\n                int m = l + (h-l)\\/2;\\n                if(check(p, m)) {\\n                    l = m + 1;\\n                    ans = m;\\n                } else {\\n                    h = m-1;\\n                }\\n            }\\n            System.out.println(ans);\\n        }\\n    }\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in CPP?\\nOnce upon a time in the galaxy of far, far away...\\n\\nDarth Wader found out the location of a rebels' base. Now he is going to destroy the base (and the whole planet that the base is located at), using the Death Star.\\n\\nWhen the rebels learnt that the Death Star was coming, they decided to use their new secret weapon \u2014 space mines. Let's describe a space mine's build.\\n\\nEach space mine is shaped like a ball (we'll call it the mine body) of a certain radius r with the center in the point O. Several spikes protrude from the center. Each spike can be represented as a segment, connecting the center of the mine with some point P, such that <image> (transporting long-spiked mines is problematic), where |OP| is the length of the segment connecting O and P. It is convenient to describe the point P by a vector p such that P = O + p.\\n\\nThe Death Star is shaped like a ball with the radius of R (R exceeds any mine's radius). It moves at a constant speed along the v vector at the speed equal to |v|. At the moment the rebels noticed the Star of Death, it was located in the point A.\\n\\nThe rebels located n space mines along the Death Star's way. You may regard the mines as being idle. The Death Star does not know about the mines' existence and cannot notice them, which is why it doesn't change the direction of its movement. As soon as the Star of Death touched the mine (its body or one of the spikes), the mine bursts and destroys the Star of Death. A touching is the situation when there is a point in space which belongs both to the mine and to the Death Star. It is considered that Death Star will not be destroyed if it can move infinitely long time without touching the mines.\\n\\nHelp the rebels determine whether they will succeed in destroying the Death Star using space mines or not. If they will succeed, determine the moment of time when it will happen (starting from the moment the Death Star was noticed).\\n\\nInput\\n\\nThe first input data line contains 7 integers Ax, Ay, Az, vx, vy, vz, R. They are the Death Star's initial position,...\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst double eps = 1e-7;\\ndouble A[3], V[3], R;\\ndouble O[3], R2, P[3];\\nint N, M;\\ndouble calc(double t) {\\n  double D[3];\\n  for (int i = 0; i < 3; i++) D[i] = A[i] + V[i] * t;\\n  double s = 0;\\n  for (int i = 0; i < 3; i++) s += (D[i] - O[i]) * (D[i] - O[i]);\\n  return sqrt(fabs(s));\\n}\\nvoid det(double A[3], double B[3], double C[3]) {\\n  C[0] = A[1] * B[2] - A[2] * B[1];\\n  C[1] = A[2] * B[0] - A[0] * B[2];\\n  C[2] = A[0] * B[1] - A[1] * B[0];\\n}\\ndouble det2(double A[2], double B[2], double C[2]) {\\n  return (B[0] - A[0]) * (C[1] - A[1]) - (B[1] - A[1]) * (C[0] - A[0]);\\n}\\ndouble dot(double A[3], double B[3]) {\\n  return A[0] * B[0] + A[1] * B[1] + A[2] * B[2];\\n}\\ndouble dot2(double A[2], double B[2], double C[2]) {\\n  return (B[0] - A[0]) * (C[0] - A[0]) + (B[1] - A[1]) * (C[1] - A[1]);\\n}\\ndouble dist(double A[2], double B[2]) {\\n  return sqrt(\\n      fabs((A[0] - B[0]) * (A[0] - B[0]) + (A[1] - B[1]) * (A[1] - B[1])));\\n}\\ndouble dalc(double t) {\\n  double D[3];\\n  for (int i = 0; i < 3; i++) D[i] = A[i] + V[i] * t;\\n  for (int i = 0; i < 3; i++) D[i] -= O[i];\\n  double X[3], Y[3], N[3];\\n  for (int i = 0; i < 3; i++) X[i] = P[i];\\n  det(P, D, N);\\n  det(P, N, Y);\\n  double s = 0;\\n  for (int i = 0; i < 3; i++) s += X[i] * X[i];\\n  s = sqrt(fabs(s));\\n  for (int i = 0; i < 3; i++) X[i] \\/= s;\\n  s = 0;\\n  for (int i = 0; i < 3; i++) s += Y[i] * Y[i];\\n  s = sqrt(fabs(s));\\n  for (int i = 0; i < 3; i++) Y[i] \\/= s;\\n  double W[2] = {0, 0}, U[2], V[2];\\n  U[0] = dot(X, P);\\n  U[1] = dot(Y, P);\\n  V[0] = dot(X, D);\\n  V[1] = dot(Y, D);\\n  if (dot2(W, U, V) >= 0 && dot2(U, W, V) >= 0)\\n    return fabs(det2(W, U, V)) \\/ dist(W, U);\\n  return min(dist(W, V), dist(U, V));\\n}\\nint main() {\\n  for (int i = 0; i < 3; i++) scanf(\\\"%lf\\\", &A[i]);\\n  for (int i = 0; i < 3; i++) scanf(\\\"%lf\\\", &V[i]);\\n  scanf(\\\"%lf\\\", &R);\\n  double res = 1e10;\\n  for (scanf(\\\"%d\\\", &N); N--;) {\\n    for (int i = 0; i < 3; i++) scanf(\\\"%lf\\\", &O[i]);\\n    scanf(\\\"%lf\\\", &R2);\\n    double l = 0, r = res;\\n    for (int t = 0; t < 1000; t++) {\\n      double m1 =...\",\"language\":\"python\",\"split\":\"train\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"In some other world, today is the day before Christmas Eve.\\n\\nMr. Takaha is buying N items at a department store. The regular price of the i-th item (1 \\\\leq i \\\\leq N) is p_i yen (the currency of Japan).\\n\\nHe has a discount coupon, and can buy one item with the highest price for half the regular price. The remaining N-1 items cost their regular prices. What is the total amount he will pay?\\n\\nConstraints\\n\\n* 2 \\\\leq N \\\\leq 10\\n* 100 \\\\leq p_i \\\\leq 10000\\n* p_i is an even number.\\n\\nInput\\n\\nInput is given from Standard Input in the following format:\\n\\n\\nN\\np_1\\np_2\\n:\\np_N\\n\\n\\nOutput\\n\\nPrint the total amount Mr. Takaha will pay.\\n\\nExamples\\n\\nInput\\n\\n3\\n4980\\n7980\\n6980\\n\\n\\nOutput\\n\\n15950\\n\\n\\nInput\\n\\n4\\n4320\\n4320\\n4320\\n4320\\n\\n\\nOutput\\n\\n15120\\\":\",\"targets\":\"#include <iostream>\\nusing namespace std;\\n\\nint main()\\n{\\n\\tint n,mx = 0,s = 0;\\n\\tcin >> n;\\n\\twhile(n--){\\n\\t\\tint t;\\n\\t\\tcin >> t;\\n\\t\\tif(t > mx)\\n\\t\\t\\tmx = t;\\n\\t\\ts += t;\\n\\t}\\n\\ts -= mx \\/ 2;\\n\\tcout << s << endl;\\n\\treturn 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You are given an integer n. In 1 move, you can do one of the following actions:\\n\\n  * erase any digit of the number (it's acceptable that the number before the operation has exactly one digit and after the operation, it is \\\"empty\\\"); \\n  * add one digit to the right. \\n\\n\\n\\nThe actions may be performed in any order any number of times.\\n\\nNote that if, after deleting some digit from a number, it will contain leading zeroes, they will not be deleted. E.g. if you delete from the number 301 the digit 3, the result is the number 01 (not 1).\\n\\nYou need to perform the minimum number of actions to make the number any power of 2 (i.e. there's an integer k (k \u2265 0) such that the resulting number is equal to 2^k). The resulting number must not have leading zeroes.\\n\\nE.g. consider n=1052. The answer is equal to 2. First, let's add to the right one digit 4 (the result will be 10524). Then let's erase the digit 5, so the result will be 1024 which is a power of 2.\\n\\nE.g. consider n=8888. The answer is equal to 3. Let's erase any of the digits 8 three times. The result will be 8 which is a power of 2.\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases. Then t test cases follow.\\n\\nEach test case consists of one line containing one integer n (1 \u2264 n \u2264 10^9).\\n\\nOutput\\n\\nFor each test case, output in a separate line one integer m \u2014 the minimum number of moves to transform the number into any power of 2.\\n\\nExample\\n\\nInput\\n\\n\\n12\\n1052\\n8888\\n6\\n75\\n128\\n1\\n301\\n12048\\n1504\\n6656\\n1000000000\\n687194767\\n\\n\\nOutput\\n\\n\\n2\\n3\\n1\\n3\\n0\\n0\\n2\\n1\\n3\\n4\\n9\\n2\\n\\nNote\\n\\nThe answer for the first test case was considered above.\\n\\nThe answer for the second test case was considered above.\\n\\nIn the third test case, it's enough to add to the right the digit 4 \u2014 the number 6 will turn into 64.\\n\\nIn the fourth test case, let's add to the right the digit 8 and then erase 7 and 5 \u2014 the taken number will turn into 8.\\n\\nThe numbers of the fifth and the sixth test cases are already powers of two so there's no need to make any move.\\n\\nIn the seventh test case, you can...\\nUsing python3 can you solve the prior task?\",\"targets\":\"def ras(a, b):\\n    ans = 0\\n    i = 0\\n    while i < len(b) and ans < len(a):\\n        if a[ans] == b[i]:\\n            ans += 1\\n        i += 1\\n    return len(a) + len(b) - ans * 2\\n\\na = [1, 2]\\nwhile a[-1] < 10 ** 19:\\n    a.append(a[-1] * 2)\\nfor _ in range(int(input())):\\n    ans = 11\\n    n = input()\\n    for i in range(len(a)):\\n        ans = min(ans, ras(str(a[i]), n))\\n    print(ans)\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"A binary tree of n nodes is given. Nodes of the tree are numbered from 1 to n and the root is the node 1. Each node can have no child, only one left child, only one right child, or both children. For convenience, let's denote l_u and r_u as the left and the right child of the node u respectively, l_u = 0 if u does not have the left child, and r_u = 0 if the node u does not have the right child.\\n\\nEach node has a string label, initially is a single character c_u. Let's define the string representation of the binary tree as the concatenation of the labels of the nodes in the in-order. Formally, let f(u) be the string representation of the tree rooted at the node u. f(u) is defined as follows: $$$ f(u) = \\\\begin{cases} <empty string>, & if u = 0; \\\\\\\\\\\\ f(l_u) + c_u + f(r_u) & otherwise, \\\\end{cases}  where +$$$ denotes the string concatenation operation.\\n\\nThis way, the string representation of the tree is f(1).\\n\\nFor each node, we can duplicate its label at most once, that is, assign c_u with c_u + c_u, but only if u is the root of the tree, or if its parent also has its label duplicated.\\n\\nYou are given the tree and an integer k. What is the lexicographically smallest string representation of the tree, if we can duplicate labels of at most k nodes?\\n\\nA string a is lexicographically smaller than a string b if and only if one of the following holds: \\n\\n  * a is a prefix of b, but a \u2260 b; \\n  * in the first position where a and b differ, the string a has a letter that appears earlier in the alphabet than the corresponding letter in b. \\n\\nInput\\n\\nThe first line contains two integers n and k (1 \u2264 k \u2264 n \u2264 2 \u22c5 10^5).\\n\\nThe second line contains a string c of n lower-case English letters, where c_i is the initial label of the node i for 1 \u2264 i \u2264 n. Note that the given string c is not the initial string representation of the tree.\\n\\nThe i-th of the next n lines contains two integers l_i and r_i (0 \u2264 l_i, r_i \u2264 n). If the node i does not have the left child, l_i = 0, and if the node i does not have the right child, r_i = 0.\\n\\nIt is...\\nUsing cpp can you solve the prior task?\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint T[200010][2], tid[200010], deep[200010];\\nchar s[200010], t[200010];\\nbool mark[200010], mark2[200010];\\nint n, k, idx;\\nvoid DFS(int u) {\\n  if (T[u][0]) {\\n    deep[T[u][0]] = deep[u] + 1;\\n    DFS(T[u][0]);\\n  }\\n  tid[++idx] = u;\\n  t[idx] = s[u];\\n  if (T[u][1]) {\\n    deep[T[u][1]] = deep[u] + 1;\\n    DFS(T[u][1]);\\n  }\\n}\\nbool DFS2(int u, int top) {\\n  bool flag = false;\\n  if (T[u][0]) {\\n    if (DFS2(T[u][0], top)) flag = true;\\n  }\\n  if (flag) mark2[u] = true;\\n  if (mark[u] && !flag) {\\n    if (deep[u] - deep[top] + 1 <= k) {\\n      k -= (deep[u] - deep[top] + 1);\\n      mark2[u] = true;\\n      flag = true;\\n    }\\n  }\\n  if (T[u][1] && flag) DFS2(T[u][1], T[u][1]);\\n  return flag;\\n}\\nint main() {\\n  scanf(\\\"%d%d\\\", &n, &k);\\n  scanf(\\\"%s\\\", s + 1);\\n  for (int i = 1; i <= n; ++i) scanf(\\\"%d%d\\\", &T[i][0], &T[i][1]);\\n  DFS(1);\\n  int p = n;\\n  for (int i = n; i >= 1; --i) {\\n    if (t[p] > t[i]) mark[tid[i]] = true;\\n    if (t[i - 1] != t[i]) p = i;\\n  }\\n  DFS2(1, 1);\\n  for (int i = 1; i <= n; ++i) {\\n    printf(\\\"%c\\\", t[i]);\\n    if (mark2[tid[i]]) printf(\\\"%c\\\", t[i]);\\n  }\\n  printf(\\\"\\\\n\\\");\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Ayrat is looking for the perfect code. He decided to start his search from an infinite field tiled by hexagons. For convenience the coordinate system is introduced, take a look at the picture to see how the coordinates of hexagon are defined: \\n\\n<image> <image> Ayrat is searching through the field. He started at point (0, 0) and is moving along the spiral (see second picture). Sometimes he forgets where he is now. Help Ayrat determine his location after n moves.\\n\\nInput\\n\\nThe only line of the input contains integer n (0 \u2264 n \u2264 1018) \u2014 the number of Ayrat's moves.\\n\\nOutput\\n\\nPrint two integers x and y \u2014 current coordinates of Ayrat coordinates.\\n\\nExamples\\n\\nInput\\n\\n3\\n\\n\\nOutput\\n\\n-2 0\\n\\n\\nInput\\n\\n7\\n\\n\\nOutput\\n\\n3 2\\nThe above is tricky. Write me a correct solution in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nlong long n, m, second, r, a, z;\\nlong long dx[] = {2, 1, -1, -2, -1, 1};\\nlong long dy[] = {0, 2, 2, 0, -2, -2};\\nlong long cx = 0, cy = 0;\\nvoid go(long long dir, long long times = 1) {\\n  times = max(0LL, min(times, n));\\n  cx += dx[dir] * times;\\n  cy += dy[dir] * times;\\n  n -= times;\\n}\\nint main() {\\n  ios_base::sync_with_stdio(0);\\n  cin >> n;\\n  long long le = 0, ri = 1000000000;\\n  while (le < ri) {\\n    long long mid = (le + ri + 1) \\/ 2;\\n    if (3LL * mid * (mid + 1) > n)\\n      ri = mid - 1;\\n    else\\n      le = mid;\\n  }\\n  go(0, le);\\n  n += le;\\n  n -= 3 * le * (le + 1);\\n  go(1);\\n  go(2, le);\\n  go(3, le + 1);\\n  go(4, le + 1);\\n  go(5, le + 1);\\n  go(0, le + 1);\\n  go(1, le + 1);\\n  cout << cx << \\\" \\\" << cy << endl;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"JAVA solution for \\\"Moamen and Ezzat are playing a game. They create an array a of n non-negative integers where every element is less than 2^k.\\n\\nMoamen wins if a_1  \\\\&  a_2  \\\\&  a_3  \\\\&  \u2026  \\\\&  a_n \u2265 a_1 \u2295 a_2 \u2295 a_3 \u2295 \u2026 \u2295 a_n.\\n\\nHere \\\\& denotes the [bitwise AND operation](https:\\/\\/en.wikipedia.org\\/wiki\\/Bitwise_operation#AND), and \u2295 denotes the [bitwise XOR operation](https:\\/\\/en.wikipedia.org\\/wiki\\/Bitwise_operation#XOR).\\n\\nPlease calculate the number of winning for Moamen arrays a.\\n\\nAs the result may be very large, print the value modulo 1 000 000 007 (10^9 + 7).\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 5)\u2014 the number of test cases. \\n\\nEach test case consists of one line containing two integers n and k (1 \u2264 n\u2264 2\u22c5 10^5, 0 \u2264 k \u2264 2\u22c5 10^5).\\n\\nOutput\\n\\nFor each test case, print a single value \u2014 the number of different arrays that Moamen wins with.\\n\\nPrint the result modulo 1 000 000 007 (10^9 + 7).\\n\\nExample\\n\\nInput\\n\\n\\n3\\n3 1\\n2 1\\n4 0\\n\\n\\nOutput\\n\\n\\n5\\n2\\n1\\n\\nNote\\n\\nIn the first example, n = 3, k = 1. As a result, all the possible arrays are [0,0,0], [0,0,1], [0,1,0], [1,0,0], [1,1,0], [0,1,1], [1,0,1], and [1,1,1].\\n\\nMoamen wins in only 5 of them: [0,0,0], [1,1,0], [0,1,1], [1,0,1], and [1,1,1].\\\":\",\"targets\":\"import java.io.BufferedReader; \\nimport java.io.IOException; \\nimport java.io.InputStreamReader; \\nimport java.util.Scanner; \\nimport java.util.StringTokenizer;\\nimport java.util.*;\\npublic class codeforcesA{\\n   static class FastReader \\n    { \\n        BufferedReader br; \\n        StringTokenizer st; \\n \\n        public FastReader() \\n        { \\n            br = new BufferedReader(new\\n                     InputStreamReader(System.in)); \\n        } \\n \\n        String next() \\n        { \\n            while (st == null || !st.hasMoreElements()) \\n            { \\n                try\\n                { \\n                    st = new StringTokenizer(br.readLine()); \\n                } \\n                catch (IOException  e) \\n                { \\n                    e.printStackTrace(); \\n                } \\n            } \\n            return st.nextToken(); \\n        } \\n \\n        int nextInt() \\n        { \\n            return Integer.parseInt(next()); \\n        } \\n \\n        long nextLong() \\n        { \\n            return Long.parseLong(next()); \\n        } \\n \\n        double nextDouble() \\n        { \\n            return Double.parseDouble(next()); \\n        } \\n \\n        String nextLine() \\n        { \\n            String str = \\\"\\\"; \\n            try\\n            { \\n                str = br.readLine(); \\n            } \\n            catch (IOException e) \\n            { \\n                e.printStackTrace(); \\n            } \\n            return str; \\n        } \\n   } \\n   static long Modpow(long a,long p,long m){long res=1;while(p>0){if((p&1)!=0){res=(res*a)%m;}p >>=1;a=(a*a)%m;}return res;}\\n   static long Modmul(long a,long b,long m){return ((a%m)*(b%m))%m;}\\n   static long ModInv(long a,long m){return Modpow(a,m-2,m);}\\n   static long nck(int n,int r,long m){if(r>n){return 0l;}return Modmul(f[n],ModInv(Modmul(f[n-r],f[r],m),m),m);}\\n   static long[] f;\\n   public static void main(String args[]){\\n     FastReader sc=new FastReader();\\n     int t=sc.nextInt();\\n     while(t-->0){\\n        long mod=1000000007;\\n        int n=sc.nextInt();\\n        int k=sc.nextInt();\\n       ...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in JAVA?\\nYouKn0wWho has two even integers x and y. Help him to find an integer n such that 1 \u2264 n \u2264 2 \u22c5 10^{18} and n mod x = y mod n. Here, a mod b denotes the remainder of a after division by b. If there are multiple such integers, output any. It can be shown that such an integer always exists under the given constraints.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 10^5) \u2014 the number of test cases.\\n\\nThe first and only line of each test case contains two integers x and y (2 \u2264 x, y \u2264 10^9, both are even).\\n\\nOutput\\n\\nFor each test case, print a single integer n (1 \u2264 n \u2264 2 \u22c5 10^{18}) that satisfies the condition mentioned in the statement. If there are multiple such integers, output any. It can be shown that such an integer always exists under the given constraints.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n4 8\\n4 2\\n420 420\\n69420 42068\\n\\n\\nOutput\\n\\n\\n4\\n10\\n420\\n9969128\\n\\nNote\\n\\nIn the first test case, 4 mod 4 = 8 mod 4 = 0.\\n\\nIn the second test case, 10 mod 4 = 2 mod 10 = 2.\\n\\nIn the third test case, 420 mod 420 = 420 mod 420 = 0.\",\"targets\":\"import java.util.*;\\nimport java.io.*;\\n \\npublic  class SolutionD{\\n       public static void main(String[] args) throws Exception{\\n               Fast sc=new Fast();\\n        PrintWriter out=new PrintWriter(System.out);\\n          int t=sc.nextInt();\\n        \\n          while(t-->0){\\n                      long x=sc.nextLong();\\n                      long y=sc.nextLong();\\n                      if(x==y){\\n                        out.println(x);\\n                      }\\n                      else if(x<y){\\n                                if(y%x==0){\\n                                  out.println(x);\\n                                }\\n                                else{\\n                                  long ans=y\\/x;\\n                                  ans=ans*x;\\n                                  ans=y-ans;\\n                                  ans=ans\\/2;\\n                                  out.println(y-ans);\\n                                }\\n                      }\\n                      else{\\n                               out.println(y+x);\\n                      }\\n          \\n        \\n          }   \\n        out.close();  \\n  }\\n\\n\\nstatic void Sort(int[] ar){\\n    ArrayList<Integer> al=new ArrayList<>();\\n    for(int i=0;i<ar.length;i++){al.add(ar[i]);}\\n    Collections.sort(al);\\n    for(int i=0;i<al.size();i++)ar[i]=al.get(i);\\n  }\\nstatic int gcd(int a,int b){\\n    if(b==0) return a;\\n    else return  gcd(b,a%b);\\n}\\n}\\nclass Pair{\\n    int x, y;\\n     Pair(int x,int y){\\n        this.x=x;\\n        this.y=y;\\n     }\\n}\\nclass Fast{\\n  BufferedReader br; \\n  StringTokenizer st;\\n  public Fast(){ br=new BufferedReader(new InputStreamReader(System.in)); }\\n  String next() \\n        {  while (st == null || !st.hasMoreElements()) \\n            {   try\\n                {     st = new StringTokenizer(br.readLine()); } \\n                catch (IOException  e) \\n                {    e.printStackTrace(); } \\n            } \\n            return st.nextToken(); \\n        }\\n  int nextInt(){  return Integer.parseInt(next()); }\\n  long nextLong(){     return...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Theofanis has a riddle for you and if you manage to solve it, he will give you a Cypriot snack halloumi for free (Cypriot cheese).\\n\\nYou are given an integer n. You need to find two integers l and r such that -10^{18} \u2264 l < r \u2264 10^{18} and l + (l + 1) + \u2026 + (r - 1) + r = n.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases.\\n\\nThe first and only line of each test case contains a single integer n (1 \u2264 n \u2264 10^{18}).\\n\\nOutput\\n\\nFor each test case, print the two integers l and r such that -10^{18} \u2264 l < r \u2264 10^{18} and l + (l + 1) + \u2026 + (r - 1) + r = n. \\n\\nIt can be proven that an answer always exists. If there are multiple answers, print any.\\n\\nExample\\n\\nInput\\n\\n\\n7\\n1\\n2\\n3\\n6\\n100\\n25\\n3000000000000\\n\\n\\nOutput\\n\\n\\n0 1\\n-1 2 \\n1 2 \\n1 3 \\n18 22\\n-2 7\\n999999999999 1000000000001\\n\\nNote\\n\\nIn the first test case, 0 + 1 = 1.\\n\\nIn the second test case, (-1) + 0 + 1 + 2 = 2.\\n\\nIn the fourth test case, 1 + 2 + 3 = 6.\\n\\nIn the fifth test case, 18 + 19 + 20 + 21 + 22 = 100.\\n\\nIn the sixth test case, (-2) + (-1) + 0 + 1 + 2 + 3 + 4 + 5 + 6 + 7 = 25.\\nUsing cpp can you solve the prior task?\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst int N = 2e5 + 5;\\nconst long long inf = 2e9 + 5;\\nvoid solve() {\\n  int64_t n;\\n  cin >> n;\\n  cout << -n + 1 << ' ' << n << '\\\\n';\\n}\\nint main() {\\n  ios_base::sync_with_stdio(0);\\n  cin.tie(0);\\n  cout.tie(0);\\n  int t;\\n  cin >> t;\\n  while (t--) {\\n    solve();\\n  }\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"A dragon symbolizes wisdom, power and wealth. On Lunar New Year's Day, people model a dragon with bamboo strips and clothes, raise them with rods, and hold the rods high and low to resemble a flying dragon.\\n\\nA performer holding the rod low is represented by a 1, while one holding it high is represented by a 2. Thus, the line of performers can be represented by a sequence a1, a2, ..., an.\\n\\nLittle Tommy is among them. He would like to choose an interval [l, r] (1 \u2264 l \u2264 r \u2264 n), then reverse al, al + 1, ..., ar so that the length of the longest non-decreasing subsequence of the new sequence is maximum.\\n\\nA non-decreasing subsequence is a sequence of indices p1, p2, ..., pk, such that p1 < p2 < ... < pk and ap1 \u2264 ap2 \u2264 ... \u2264 apk. The length of the subsequence is k.\\n\\nInput\\n\\nThe first line contains an integer n (1 \u2264 n \u2264 2000), denoting the length of the original sequence.\\n\\nThe second line contains n space-separated integers, describing the original sequence a1, a2, ..., an (1 \u2264 ai \u2264 2, i = 1, 2, ..., n).\\n\\nOutput\\n\\nPrint a single integer, which means the maximum possible length of the longest non-decreasing subsequence of the new sequence.\\n\\nExamples\\n\\nInput\\n\\n4\\n1 2 1 2\\n\\n\\nOutput\\n\\n4\\n\\n\\nInput\\n\\n10\\n1 1 2 2 2 1 1 2 2 1\\n\\n\\nOutput\\n\\n9\\n\\nNote\\n\\nIn the first example, after reversing [2, 3], the array will become [1, 1, 2, 2], where the length of the longest non-decreasing subsequence is 4.\\n\\nIn the second example, after reversing [3, 7], the array will become [1, 1, 1, 1, 2, 2, 2, 2, 2, 1], where the length of the longest non-decreasing subsequence is 9.\\\":\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint setBit(int n, int pos) { return n = n | (1 << pos); }\\nint resetBit(int n, int pos) { return n = n & ~(1 << pos); }\\nbool checkBit(long long n, long long pos) { return (bool)(n & (1LL << pos)); }\\nconst int MAX = 2010;\\nint ara[MAX];\\nint dp[MAX][MAX][4];\\nint call(int pos, int n, int last) {\\n  if (pos < n) return 0;\\n  if (dp[pos][n][last] != -1) return dp[pos][n][last];\\n  int ret = call(pos - 1, n, last);\\n  if (ara[pos] >= last) {\\n    ret = max(ret, 1 + call(pos - 1, n, ara[pos]));\\n  }\\n  return dp[pos][n][last] = ret;\\n}\\nint cum1[MAX], cum2[MAX];\\nint main() {\\n  int n, cnt1 = 0, cnt2 = 0;\\n  scanf(\\\"%d\\\", &n);\\n  for (int i = 1; i <= n; i++) {\\n    scanf(\\\"%d\\\", &ara[i]);\\n  }\\n  for (int i = 1; i <= n; i++) {\\n    cum1[i] = cum1[i - 1];\\n    cum2[i] = cum2[i - 1];\\n    if (ara[i] == 1) {\\n      cum1[i]++;\\n      cnt1++;\\n    } else {\\n      cum2[i]++;\\n      cnt2++;\\n    }\\n  }\\n  memset(dp, -1, sizeof(dp));\\n  reverse(ara + 1, ara + n + 1);\\n  int mx = call(n, 1, 1), lala;\\n  memset(dp, -1, sizeof(dp));\\n  reverse(ara + 1, ara + n + 1);\\n  for (int i = 1; i <= n; i++) {\\n    for (int j = i + 1; j <= n; j++) {\\n      lala = cum1[i - 1];\\n      lala += call(j, i, 1);\\n      lala += cnt2 - cum2[j];\\n      mx = max(mx, lala);\\n    }\\n  }\\n  printf(\\\"%d\\\\n\\\", mx);\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"<image>\\n\\nWilliam has two numbers a and b initially both equal to zero. William mastered performing three different operations with them quickly. Before performing each operation some positive integer k is picked, which is then used to perform one of the following operations: (note, that for each operation you can choose a new positive integer k)\\n\\n  1. add number k to both a and b, or \\n  2. add number k to a and subtract k from b, or \\n  3. add number k to b and subtract k from a. \\n\\n\\n\\nNote that after performing operations, numbers a and b may become negative as well.\\n\\nWilliam wants to find out the minimal number of operations he would have to perform to make a equal to his favorite number c and b equal to his second favorite number d.\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 10^4). Description of the test cases follows.\\n\\nThe only line of each test case contains two integers c and d (0 \u2264 c, d \u2264 10^9), which are William's favorite numbers and which he wants a and b to be transformed into.\\n\\nOutput\\n\\nFor each test case output a single number, which is the minimal number of operations which William would have to perform to make a equal to c and b equal to d, or -1 if it is impossible to achieve this using the described operations.\\n\\nExample\\n\\nInput\\n\\n\\n6\\n1 2\\n3 5\\n5 3\\n6 6\\n8 0\\n0 0\\n\\n\\nOutput\\n\\n\\n-1\\n2\\n2\\n1\\n2\\n0\\n\\nNote\\n\\nLet us demonstrate one of the suboptimal ways of getting a pair (3, 5):\\n\\n  * Using an operation of the first type with k=1, the current pair would be equal to (1, 1). \\n  * Using an operation of the third type with k=8, the current pair would be equal to (-7, 9). \\n  * Using an operation of the second type with k=7, the current pair would be equal to (0, 2). \\n  * Using an operation of the first type with k=3, the current pair would be equal to (3, 5).\",\"targets\":\"t=int(input())\\nfor i in range(t):\\n  l=[int(i) for i in input().split()]\\n  if (abs(l[0]-l[1])%2==1):\\n    print(-1)\\n  elif (l[0]==l[1])and (l[0]==0):\\n    print(0)\\n  elif (l[0]==l[1]):\\n    print(1)\\n  else :\\n    print(2)\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Monocarp is playing a computer game. Now he wants to complete the first level of this game.\\n\\nA level is a rectangular grid of 2 rows and n columns. Monocarp controls a character, which starts in cell (1, 1) \u2014 at the intersection of the 1-st row and the 1-st column.\\n\\nMonocarp's character can move from one cell to another in one step if the cells are adjacent by side and\\/or corner. Formally, it is possible to move from cell (x_1, y_1) to cell (x_2, y_2) in one step if |x_1 - x_2| \u2264 1 and |y_1 - y_2| \u2264 1. Obviously, it is prohibited to go outside the grid.\\n\\nThere are traps in some cells. If Monocarp's character finds himself in such a cell, he dies, and the game ends.\\n\\nTo complete a level, Monocarp's character should reach cell (2, n) \u2014 at the intersection of row 2 and column n.\\n\\nHelp Monocarp determine if it is possible to complete the level.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 100) \u2014 the number of test cases. Then the test cases follow. Each test case consists of three lines.\\n\\nThe first line contains a single integer n (3 \u2264 n \u2264 100) \u2014 the number of columns.\\n\\nThe next two lines describe the level. The i-th of these lines describes the i-th line of the level \u2014 the line consists of the characters '0' and '1'. The character '0' corresponds to a safe cell, the character '1' corresponds to a trap cell.\\n\\nAdditional constraint on the input: cells (1, 1) and (2, n) are safe.\\n\\nOutput\\n\\nFor each test case, output YES if it is possible to complete the level, and NO otherwise.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n3\\n000\\n000\\n4\\n0011\\n1100\\n4\\n0111\\n1110\\n6\\n010101\\n101010\\n\\n\\nOutput\\n\\n\\nYES\\nYES\\nNO\\nYES\\n\\nNote\\n\\nConsider the example from the statement.\\n\\nIn the first test case, one of the possible paths is (1, 1) \u2192 (2, 2) \u2192 (2, 3).\\n\\nIn the second test case, one of the possible paths is (1, 1) \u2192 (1, 2) \u2192 (2, 3) \u2192 (2, 4).\\n\\nIn the fourth test case, one of the possible paths is (1, 1) \u2192 (2, 2) \u2192 (1, 3) \u2192 (2, 4) \u2192 (1, 5) \u2192 (2, 6).\",\"targets\":\"for _ in range(int(input())):\\n    n = int(input())\\n    arr = []\\n    for x in range(2):\\n        arr.append(input())\\n    flag = 0\\n    for i in range(len(arr[0])):\\n        if int(arr[0][i])+int(arr[1][i]) == 2:\\n            flag = 1\\n            break\\n    if flag == 1:\\n        print('NO')\\n    else:\\n        print('YES')\",\"language\":\"python\",\"split\":\"test\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in CPP?\\nIt is the easy version of the problem. The only difference is that in this version n = 1.\\n\\nIn the cinema seats can be represented as the table with n rows and m columns. The rows are numbered with integers from 1 to n. The seats in each row are numbered with consecutive integers from left to right: in the k-th row from m (k - 1) + 1 to m k for all rows 1 \u2264 k \u2264 n.\\n\\n1| 2| \u22c5\u22c5\u22c5| m - 1| m  \\n---|---|---|---|---  \\nm + 1| m + 2| \u22c5\u22c5\u22c5| 2 m - 1| 2 m  \\n2m + 1| 2m + 2| \u22c5\u22c5\u22c5| 3 m - 1| 3 m  \\n\\\\vdots| \\\\vdots| \\\\ddots| \\\\vdots| \\\\vdots  \\nm (n - 1) + 1| m (n - 1) + 2| \u22c5\u22c5\u22c5| n m - 1| n m  \\nThe table with seats indices\\n\\nThere are nm people who want to go to the cinema to watch a new film. They are numbered with integers from 1 to nm. You should give exactly one seat to each person.\\n\\nIt is known, that in this cinema as lower seat index you have as better you can see everything happening on the screen. i-th person has the level of sight a_i. Let's define s_i as the seat index, that will be given to i-th person. You want to give better places for people with lower sight levels, so for any two people i, j such that a_i < a_j it should be satisfied that s_i < s_j.\\n\\nAfter you will give seats to all people they will start coming to their seats. In the order from 1 to nm, each person will enter the hall and sit in their seat. To get to their place, the person will go to their seat's row and start moving from the first seat in this row to theirs from left to right. While moving some places will be free, some will be occupied with people already seated. The inconvenience of the person is equal to the number of occupied seats he or she will go through.\\n\\nLet's consider an example: m = 5, the person has the seat 4 in the first row, the seats 1, 3, 5 in the first row are already occupied, the seats 2 and 4 are free. The inconvenience of this person will be 2, because he will go through occupied seats 1 and 3.\\n\\nFind the minimal total inconvenience (the sum of inconveniences of all people), that is possible to have by giving places for all people...\",\"targets\":\"#include <bits\\/stdc++.h>\\n#pragma GCC optimize(\\\"Ofast\\\", \\\"unroll-loops\\\")\\nusing namespace std;\\nusing pii = pair<long long, long long>;\\ntemplate <typename T>\\nusing Prior = std::priority_queue<T>;\\ntemplate <typename T>\\nusing prior = std::priority_queue<T, vector<T>, greater<T>>;\\nmt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());\\ninline long long getRand(long long L, long long R) {\\n  if (L > R) swap(L, R);\\n  return (long long)(rng() % ((uint64_t)R - L + 1) + L);\\n}\\ntemplate <typename T1, typename T2>\\nostream &operator<<(ostream &os, pair<T1, T2> &p) {\\n  os << \\\"(\\\" << p.first << \\\",\\\" << p.second << \\\")\\\";\\n  return os;\\n}\\ntemplate <typename T>\\nostream &operator<<(ostream &os, vector<T> &vec) {\\n  for (long long i = 0; i < vec.size(); ++i) {\\n    if (i) os << \\\" \\\";\\n    os << vec[i];\\n  }\\n  return os;\\n}\\ntemplate <typename T>\\nbool chmin(T &lhs, T rhs) {\\n  return lhs <= rhs ? 0 : (lhs = rhs, 1);\\n}\\ntemplate <typename T>\\nbool chmax(T &lhs, T rhs) {\\n  return lhs >= rhs ? 0 : (lhs = rhs, 1);\\n}\\nvoid solve() {\\n  long long N, M;\\n  cin >> N >> M;\\n  vector<long long> A(M);\\n  for (auto &x : A) cin >> x;\\n  long long ans = 0;\\n  for (long long i = 0; i < M; ++i) {\\n    for (long long j = i + 1; j < M; ++j) {\\n      ans += A[i] < A[j];\\n    }\\n  }\\n  cout << ans << \\\"\\\\n\\\";\\n}\\nint32_t main() {\\n  ios_base::sync_with_stdio(0), cin.tie(0);\\n  long long t = 1;\\n  cin >> t;\\n  for (long long _ = 1; _ <= t; ++_) {\\n    solve();\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"A new agent called Killjoy invented a virus COVID-2069 that infects accounts on Codeforces. Each account has a rating, described by an integer (it can possibly be negative or very large).\\n\\nKilljoy's account is already infected and has a rating equal to x. Its rating is constant. There are n accounts except hers, numbered from 1 to n. The i-th account's initial rating is a_i. Any infected account (initially the only infected account is Killjoy's) instantly infects any uninfected account if their ratings are equal. This can happen at the beginning (before any rating changes) and after each contest. If an account is infected, it can not be healed.\\n\\nContests are regularly held on Codeforces. In each contest, any of these n accounts (including infected ones) can participate. Killjoy can't participate. After each contest ratings are changed this way: each participant's rating is changed by an integer, but the sum of all changes must be equal to zero. New ratings can be any integer.\\n\\nFind out the minimal number of contests needed to infect all accounts. You can choose which accounts will participate in each contest and how the ratings will change.\\n\\nIt can be proven that all accounts can be infected in some finite number of contests.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 100) \u2014 the number of test cases. The next 2t lines contain the descriptions of all test cases.\\n\\nThe first line of each test case contains two integers n and x (2 \u2264 n \u2264 10^3, -4000 \u2264 x \u2264 4000) \u2014 the number of accounts on Codeforces and the rating of Killjoy's account.\\n\\nThe second line of each test case contains n integers a_1, a_2, ..., a_n (-4000 \u2264 a_i \u2264 4000) \u2014 the ratings of other accounts.\\n\\nOutput\\n\\nFor each test case output the minimal number of contests needed to infect all accounts.\\n\\nExample\\n\\nInput\\n\\n\\n3\\n2 69\\n68 70\\n6 4\\n4 4 4 4 4 4\\n9 38\\n-21 83 50 -59 -77 15 -71 -78 20\\n\\n\\nOutput\\n\\n\\n1\\n0\\n2\\n\\nNote\\n\\nIn the first test case it's possible to make all ratings equal to 69. First account's rating will increase by 1, and second account's...\\nSolve the task in PYTHON3.\",\"targets\":\"import math,sys,bisect,heapq\\nfrom collections import defaultdict,Counter,deque\\nfrom itertools import groupby,accumulate\\n#sys.setrecursionlimit(200000000)\\nint1 = lambda x: int(x) - 1\\n#input = iter(sys.stdin.buffer.read().decode().splitlines()).__next__\\nilele = lambda: map(int,input().split())\\nalele = lambda: list(map(int, input().split()))\\nilelec = lambda: map(int1,input().split())\\nalelec = lambda: list(map(int1, input().split()))\\ndef list2d(a, b, c): return [[c] * b for i in range(a)]\\ndef list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]\\n#MOD = 1000000000 + 7\\ndef Y(c):  print([\\\"NO\\\",\\\"YES\\\"][c])\\ndef y(c):  print([\\\"no\\\",\\\"yes\\\"][c])\\ndef Yy(c):  print([\\\"No\\\",\\\"Yes\\\"][c])\\n\\nfor _ in range(int(input())):\\n    n,x = ilele()\\n    A = alele()\\n    if len(set(A)) == 1 and A[0] == x:\\n        print(0);continue\\n    dif = sum([i-x for i in A])\\n    if dif == 0 or x in A:\\n        print(1)\\n    else:\\n        print(2)\",\"language\":\"python\",\"split\":\"train\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"During her tantrums the princess usually smashes some collectable porcelain. Every furious shriek is accompanied with one item smashed.\\n\\nThe collection of porcelain is arranged neatly on n shelves. Within each shelf the items are placed in one row, so that one can access only the outermost items \u2014 the leftmost or the rightmost item, not the ones in the middle of the shelf. Once an item is taken, the next item on that side of the shelf can be accessed (see example). Once an item is taken, it can't be returned to the shelves.\\n\\nYou are given the values of all items. Your task is to find the maximal damage the princess' tantrum of m shrieks can inflict on the collection of porcelain.\\n\\nInput\\n\\nThe first line of input data contains two integers n (1 \u2264 n \u2264 100) and m (1 \u2264 m \u2264 10000). The next n lines contain the values of the items on the shelves: the first number gives the number of items on this shelf (an integer between 1 and 100, inclusive), followed by the values of the items (integers between 1 and 100, inclusive), in the order in which they appear on the shelf (the first number corresponds to the leftmost item, the last one \u2014 to the rightmost one). The total number of items is guaranteed to be at least m.\\n\\nOutput\\n\\nOutput the maximal total value of a tantrum of m shrieks.\\n\\nExamples\\n\\nInput\\n\\n2 3\\n3 3 7 2\\n3 4 1 5\\n\\n\\nOutput\\n\\n15\\n\\n\\nInput\\n\\n1 3\\n4 4 3 1 2\\n\\n\\nOutput\\n\\n9\\n\\nNote\\n\\nIn the first case there are two shelves, each with three items. To maximize the total value of the items chosen, one can take two items from the left side of the first shelf and one item from the right side of the second shelf.\\n\\nIn the second case there is only one shelf, so all three items are taken from it \u2014 two from the left side and one from the right side.\\\":\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst int N = 100 + 100;\\nconst int M = 10000 + 100;\\nint a[N], psum[N], ssum[N], mx[N];\\nint mxtot[M];\\nint main() {\\n  ios_base::sync_with_stdio(0);\\n  cin.tie(0);\\n  cout.tie(0);\\n  int n, m;\\n  cin >> n >> m;\\n  for (int i = 0; i < n; ++i) {\\n    int k;\\n    cin >> k;\\n    for (int j = 1; j <= k; ++j) cin >> a[j];\\n    psum[0] = 0;\\n    for (int j = 1; j <= k; ++j) psum[j] = psum[j - 1] + a[j];\\n    ssum[k + 1] = 0;\\n    for (int j = k; j >= 0; --j) ssum[j] = ssum[j + 1] + a[j];\\n    for (int j = 0; j <= k; ++j) mx[j] = 0;\\n    for (int l = 0; l <= k; ++l) {\\n      int cnt = l;\\n      for (int r = k + 1; r > 0 and l < r; --r, ++cnt) {\\n        mx[cnt] = max(mx[cnt], psum[l] + ssum[r]);\\n      }\\n    }\\n    for (int j = m; j >= 0; --j) {\\n      for (int p = 1; p <= k and j - p >= 0; ++p) {\\n        mxtot[j] = max(mxtot[j], mxtot[j - p] + mx[p]);\\n      }\\n    }\\n  }\\n  cout << mxtot[m] << '\\\\n';\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"JAVA solution for \\\"There are n block towers in a row, where tower i has a height of a_i. You're part of a building crew, and you want to make the buildings look as nice as possible. In a single day, you can perform the following operation:\\n\\n  * Choose two indices i and j (1 \u2264 i, j \u2264 n; i \u2260 j), and move a block from tower i to tower j. This essentially decreases a_i by 1 and increases a_j by 1. \\n\\n\\n\\nYou think the ugliness of the buildings is the height difference between the tallest and shortest buildings. Formally, the ugliness is defined as max(a)-min(a). \\n\\nWhat's the minimum possible ugliness you can achieve, after any number of days?\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 1000) \u2014 the number of test cases. Then t cases follow.\\n\\nThe first line of each test case contains one integer n (2 \u2264 n \u2264 100) \u2014 the number of buildings.\\n\\nThe second line of each test case contains n space separated integers a_1, a_2, \u2026, a_n (1 \u2264 a_i \u2264 10^7) \u2014 the heights of the buildings.\\n\\nOutput\\n\\nFor each test case, output a single integer \u2014 the minimum possible ugliness of the buildings.\\n\\nExample\\n\\nInput\\n\\n\\n3\\n3\\n10 10 10\\n4\\n3 2 1 2\\n5\\n1 2 3 1 5\\n\\n\\nOutput\\n\\n\\n0\\n0\\n1\\n\\nNote\\n\\nIn the first test case, the ugliness is already 0.\\n\\nIn the second test case, you should do one operation, with i = 1 and j = 3. The new heights will now be [2, 2, 2, 2], with an ugliness of 0.\\n\\nIn the third test case, you may do three operations: \\n\\n  1. with i = 3 and j = 1. The new array will now be [2, 2, 2, 1, 5], \\n  2. with i = 5 and j = 4. The new array will now be [2, 2, 2, 2, 4], \\n  3. with i = 5 and j = 3. The new array will now be [2, 2, 3, 2, 3]. \\n\\nThe resulting ugliness is 1. It can be proven that this is the minimum possible ugliness for this test.\\\":\",\"targets\":\"\\/\\/ HOPE\\n\\n\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\n\\/\\/----------------------------------------------------------------------------------------------------------------------\\n\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\n\\/\\/----------------------------------------------------------------------------------------------------------------------\\n\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\n\\/\\/\\/\\/\\/\\/\\/                                                                                                       \\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\n\\/\\/\\/\\/\\/\\/\\/                                                                                                       \\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\n\\/\\/\\/\\/\\/\\/\\/            RRRRRRRRRRRRR     YY          YY         AA               NN          NN                   \\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\n\\/\\/\\/\\/\\/\\/\\/            RR         RR      YY        YY        AA  AA             NN NN       NN                   \\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\n\\/\\/\\/\\/\\/\\/\\/            RR        RR         YY     YY        AA    AA            NN  NN      NN                   \\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\n\\/\\/\\/\\/\\/\\/\\/            RRRRRRRRRR            YY   YY       AAAAAAAAAAAA          NN    NN    NN                   \\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\n\\/\\/\\/\\/\\/\\/\\/            RR RR                   YY         AAAAAAAAAAAAAA         NN      NN  NN                   \\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\n\\/\\/\\/\\/\\/\\/\\/            RR   RR                 YY        AA            AA        NN       NN NN                   \\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\n\\/\\/\\/\\/\\/\\/\\/            RR     RR               YY       AA              AA       NN          NN                   \\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\n\\/\\/\\/\\/\\/\\/\\/            RR       RR_____________________________________________________________________________   \\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\n\\/\\/\\/\\/\\/\\/\\/\\/                                                                                                     ...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in JAVA?\\nThe new generation external memory contains an array of integers a[1 \u2026 n] = [a_1, a_2, \u2026, a_n].\\n\\nThis type of memory does not support changing the value of an arbitrary element. Instead, it allows you to cut out any segment of the given array, cyclically shift (rotate) it by any offset and insert it back into the same place.\\n\\nTechnically, each cyclic shift consists of two consecutive actions: \\n\\n  1. You may select arbitrary indices l and r (1 \u2264 l < r \u2264 n) as the boundaries of the segment. \\n  2. Then you replace the segment a[l \u2026 r] with it's cyclic shift to the left by an arbitrary offset d. The concept of a cyclic shift can be also explained by following relations: the sequence [1, 4, 1, 3] is a cyclic shift of the sequence [3, 1, 4, 1] to the left by the offset 1 and the sequence [4, 1, 3, 1] is a cyclic shift of the sequence [3, 1, 4, 1] to the left by the offset 2. \\n\\n\\n\\nFor example, if a = [1, \\\\color{blue}{3, 2, 8}, 5], then choosing l = 2, r = 4 and d = 2 yields a segment a[2 \u2026 4] = [3, 2, 8]. This segment is then shifted by the offset d = 2 to the left, and you get a segment [8, 3, 2] which then takes the place of of the original elements of the segment. In the end you get a = [1, \\\\color{blue}{8, 3, 2}, 5].\\n\\nSort the given array a using no more than n cyclic shifts of any of its segments. Note that you don't need to minimize the number of cyclic shifts. Any method that requires n or less cyclic shifts will be accepted.\\n\\nInput\\n\\nThe first line contains an integer t (1 \u2264 t \u2264 1000) \u2014 the number of test cases.\\n\\nThe next 2t lines contain the descriptions of the test cases. \\n\\nThe first line of each test case description contains an integer n (2 \u2264 n \u2264 50) \u2014 the length of the array. The second line consists of space-separated elements of the array a_i (-10^9 \u2264 a_i \u2264 10^9). Elements of array a may repeat and don't have to be unique.\\n\\nOutput\\n\\nPrint t answers to all input test cases. \\n\\nThe first line of the answer of each test case should contain an integer k (0 \u2264 k \u2264 n) \u2014 the number of actions to sort the array....\",\"targets\":\"import java.io.*;\\nimport java.util.*;\\n\\npublic class A {\\n    static final Reader s = new Reader();\\n    static final PrintWriter out = new PrintWriter(System.out);\\n\\n    public static void main(String[] args) throws IOException {\\n        int t  = s.nextInt();\\n        for(int i=1; i<=t; ++i) {\\n\\/\\/            out.print(\\\"Case #\\\"+i+\\\": \\\");\\n            new Solver();\\n        }\\n        out.close();\\n    }\\n    static class Solver {\\n        Solver() {\\n            int n = s.nextInt();\\n            int[] a = new int[n];\\n            for(int i=0;i<n;i++) a[i] =  s.nextInt();\\n            int[] b = a.clone();\\n            Arrays.sort(b);\\n            int[][] ans = new int[n][3];\\n            int k=0;\\n            boolean f=false;\\n            for(int i=0;i<n;i++){\\n                if(a[i]==b[i]){\\n                    continue;\\n                }\\n                int g  = -1;\\n                for(int j=i;j<n;j++){\\n                    if(a[j]==b[i]){\\n                        g=j;\\n                        break;\\n                    }\\n                }\\n                ans[k][0]=i+1;\\n                ans[k][1]=g+1;\\n                ans[k++][2]=g-i;\\n                for(int j=g;j>i;j--){\\n                    int temp=a[j];\\n                    a[j]=a[j-1];\\n                    a[j-1]=temp;\\n                }\\n            }\\n            out.println(k);\\n            for(int i=0;i<k;i++){\\n                out.println(ans[i][0]+\\\" \\\"+ans[i][1]+\\\" \\\"+ans[i][2]);\\n            }\\n        }\\n    }\\n    static class Reader {\\n        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));\\n        StringTokenizer st;\\n        String next() {\\n            while(st==null||!st.hasMoreTokens()) {\\n                try {\\n                    st=new StringTokenizer(in.readLine());\\n                } catch(Exception e) {}\\n            }\\n            return st.nextToken();\\n        }\\n        int nextInt() {\\n            return Integer.parseInt(next());\\n        }\\n        long nextLong() {\\n            return Long.parseLong(next());\\n        }\\n    }\\n\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"DLS and JLS are bored with a Math lesson. In order to entertain themselves, DLS took a sheet of paper and drew n distinct lines, given by equations y = x + p_i for some distinct p_1, p_2, \u2026, p_n.\\n\\nThen JLS drew on the same paper sheet m distinct lines given by equations y = -x + q_i for some distinct q_1, q_2, \u2026, q_m.\\n\\nDLS and JLS are interested in counting how many line pairs have integer intersection points, i.e. points with both coordinates that are integers. Unfortunately, the lesson will end up soon, so DLS and JLS are asking for your help.\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 1000), the number of test cases in the input. Then follow the test case descriptions.\\n\\nThe first line of a test case contains an integer n (1 \u2264 n \u2264 10^5), the number of lines drawn by DLS.\\n\\nThe second line of a test case contains n distinct integers p_i (0 \u2264 p_i \u2264 10^9) describing the lines drawn by DLS. The integer p_i describes a line given by the equation y = x + p_i.\\n\\nThe third line of a test case contains an integer m (1 \u2264 m \u2264 10^5), the number of lines drawn by JLS.\\n\\nThe fourth line of a test case contains m distinct integers q_i (0 \u2264 q_i \u2264 10^9) describing the lines drawn by JLS. The integer q_i describes a line given by the equation y = -x + q_i.\\n\\nThe sum of the values of n over all test cases in the input does not exceed 10^5. Similarly, the sum of the values of m over all test cases in the input does not exceed 10^5.\\n\\nIn hacks it is allowed to use only one test case in the input, so t=1 should be satisfied.\\n\\nOutput\\n\\nFor each test case in the input print a single integer \u2014 the number of line pairs with integer intersection points. \\n\\nExample\\n\\nInput\\n\\n\\n3\\n3\\n1 3 2\\n2\\n0 3\\n1\\n1\\n1\\n1\\n1\\n2\\n1\\n1\\n\\n\\nOutput\\n\\n\\n3\\n1\\n0\\n\\nNote\\n\\nThe picture shows the lines from the first test case of the example. Black circles denote intersection points with integer coordinates.\\n\\n<image>\\nfor _\",\"targets\":\"in range(int(input())):\\n\\tn1=int(input())\\n\\ta=list(map(int,input().split()))\\n\\tn2=int(input())\\n\\tb=list(map(int,input().split()))\\n\\te1,e2=0,0\\n\\to1,o2=0,0\\n\\tfor i in a:\\n\\t\\tif i%2==0:\\n\\t\\t\\te1+=1\\n\\t\\telse:\\n\\t\\t\\to1+=1\\n\\tfor i in b:\\n\\t\\tif i%2==0:\\n\\t\\t\\te2+=1\\n\\t\\telse:\\n\\t\\t\\to2+=1\\n\\tprint(e1*e2+o1*o2)\",\"language\":\"python\",\"split\":\"train\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"The grasshopper is located on the numeric axis at the point with coordinate x_0.\\n\\nHaving nothing else to do he starts jumping between integer points on the axis. Making a jump from a point with coordinate x with a distance d to the left moves the grasshopper to a point with a coordinate x - d, while jumping to the right moves him to a point with a coordinate x + d.\\n\\nThe grasshopper is very fond of positive integers, so for each integer i starting with 1 the following holds: exactly i minutes after the start he makes a jump with a distance of exactly i. So, in the first minutes he jumps by 1, then by 2, and so on.\\n\\nThe direction of a jump is determined as follows: if the point where the grasshopper was before the jump has an even coordinate, the grasshopper jumps to the left, otherwise he jumps to the right.\\n\\nFor example, if after 18 consecutive jumps he arrives at the point with a coordinate 7, he will jump by a distance of 19 to the right, since 7 is an odd number, and will end up at a point 7 + 19 = 26. Since 26 is an even number, the next jump the grasshopper will make to the left by a distance of 20, and it will move him to the point 26 - 20 = 6.\\n\\nFind exactly which point the grasshopper will be at after exactly n jumps.\\n\\nInput\\n\\nThe first line of input contains an integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases.\\n\\nEach of the following t lines contains two integers x_0 (-10^{14} \u2264 x_0 \u2264 10^{14}) and n (0 \u2264 n \u2264 10^{14}) \u2014 the coordinate of the grasshopper's initial position and the number of jumps.\\n\\nOutput\\n\\nPrint exactly t lines. On the i-th line print one integer \u2014 the answer to the i-th test case \u2014 the coordinate of the point the grasshopper will be at after making n jumps from the point x_0.\\n\\nExample\\n\\nInput\\n\\n\\n9\\n0 1\\n0 2\\n10 10\\n10 99\\n177 13\\n10000000000 987654321\\n-433494437 87178291199\\n1 0\\n-1 1\\n\\n\\nOutput\\n\\n\\n-1\\n1\\n11\\n110\\n190\\n9012345679\\n-87611785637\\n1\\n0\\n\\nNote\\n\\nThe first two test cases in the example correspond to the first two jumps from the point x_0 = 0. \\n\\nSince 0 is an even number, the first jump of length...\\nSolve the task in PYTHON3.\",\"targets\":\"#1\\n# for _ in range(int(input())):\\n#     k=input()\\n#     s=input()\\n#     ans=0\\n#     dic={}\\n#     for i,elm in enumerate(k):\\n#         dic[elm]=i\\n#     prev=dic[s[0]]\\n#     for elm in s[1:]:\\n#         ans+=(abs(dic[elm]-prev))\\n#         prev=dic[elm]\\n#     print(ans)\\n\\n#2\\nfor _ in range(int(input())):\\n    x,n=map(int,input().split())\\n    n-=1\\n    q,r=n\\/\\/4,n%4\\n    if x%2==0:\\n        x-=1\\n        x-=q*4\\n    else:\\n        x+=1\\n        x+=q*4\\n    n+=1\\n    for i in range(n-r+1,n+1):\\n        if x%2==0:\\n            x-=i\\n        else:\\n            x+=i\\n    print(x)\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n# def solution(arr):\\n#     n=len(arr)\\n#     dp=arr[:]\\n#     for i in range(2,n):\\n#         if i-3>-1:\\n#             dp[i]=max(dp[i-3]+dp[i],dp[i],dp[i-2]+dp[i])\\n#         else:\\n#             dp[i]=max(dp[i],dp[i-2]+dp[i])\\n#     return max(dp)\\n# arr=list(map(int,input().split()))\\n# print(max(solution(arr[:-1]),solution(arr[1:])))\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n##group marbles\\n\\n# def solution(g1,g2,g3):\\n#     g1=set(g1)\\n#     g2=set(g2)\\n#     g3=set(g3)\\n#     n=len(g1)+len(g2)+len(g3)\\n#     dp=[[0,0,0] for _ in range(n+1)]\\n#     dp[1][0]=1 if 1 not in g1 else 0\\n#     dp[1][1]=1 if 1 not in g2 else 0\\n#     dp[1][2]=1 if 1 not in g3 else 0\\n\\n#     for i in range(2,n+1):\\n#         dp[i][0]+=(1 if i not in g1 else 0)\\n#         dp[i][0]+=dp[i-1][0]\\n#         dp[i][1]+=(1 if i not in g2 else 0)\\n#         dp[i][1]+=min(dp[i-1][0],dp[i-1][1])\\n#         dp[i][2]+=(1 if i not in g3 else 0)\\n#         dp[i][2]+=min(dp[i-1][0],dp[i-1][1],dp[i-1][2])\\n\\n#     print(dp)\\n#     return min(dp[n])\\n\\n# g1=list(map(int,input().split()))\\n# g2=list(map(int,input().split()))\\n# g3=list(map(int,input().split()))\\n# print(solution(g1,g2,g3))\\n\\n\\n\\n\\n\\n\\n# def solution(lb,ub,diff):\\n#     pre=diff[:]\\n#     for i in range(1,len(diff)):\\n#         pre[i]+=pre[i-1]\\n\\n#     maxi=max(pre)\\n#     mini=min(pre)\\n#     if maxi>0:\\n#         lb=lb+maxi\\n#     if mini<0:\\n#         ub=ub-abs(mini)\\n#     print(pre,lb,ub)\\n#     return max(ub-lb+1,0)\\n\\n# arr=list(map(int,input().split()))\\n#...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"Polycarp had an array a of 3 positive integers. He wrote out the sums of all non-empty subsequences of this array, sorted them in non-decreasing order, and got an array b of 7 integers.\\n\\nFor example, if a = \\\\{1, 4, 3\\\\}, then Polycarp wrote out 1, 4, 3, 1 + 4 = 5, 1 + 3 = 4, 4 + 3 = 7, 1 + 4 + 3 = 8. After sorting, he got an array b = \\\\{1, 3, 4, 4, 5, 7, 8\\\\}.\\n\\nUnfortunately, Polycarp lost the array a. He only has the array b left. Help him to restore the array a.\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 5000) \u2014 the number of test cases.\\n\\nEach test case consists of one line which contains 7 integers b_1, b_2, ..., b_7 (1 \u2264 b_i \u2264 10^9; b_i \u2264 b_{i+1}). \\n\\nAdditional constraint on the input: there exists at least one array a which yields this array b as described in the statement.\\n\\nOutput\\n\\nFor each test case, print 3 integers \u2014 a_1, a_2 and a_3. If there can be several answers, print any of them.\\n\\nExample\\n\\nInput\\n\\n\\n5\\n1 3 4 4 5 7 8\\n1 2 3 4 5 6 7\\n300000000 300000000 300000000 600000000 600000000 600000000 900000000\\n1 1 2 999999998 999999999 999999999 1000000000\\n1 2 2 3 3 4 5\\n\\n\\nOutput\\n\\n\\n1 4 3\\n4 1 2\\n300000000 300000000 300000000\\n999999998 1 1\\n1 2 2\\n\\nNote\\n\\nThe subsequence of the array a is a sequence that can be obtained from a by removing zero or more of its elements.\\n\\nTwo subsequences are considered different if index sets of elements included in them are different. That is, the values of the elements don't matter in the comparison of subsequences. In particular, any array of length 3 has exactly 7 different non-empty subsequences.\\\":\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nlong long a[10];\\nvoid solve() {\\n  for (long long i = 1; i <= 7; i++) cin >> a[i];\\n  sort(a + 1, a + 8);\\n  cout << a[1] << \\\" \\\" << a[2] << \\\" \\\" << a[7] - a[1] - a[2] << endl;\\n}\\nsigned main() {\\n  ios::sync_with_stdio(0);\\n  long long t = 1;\\n  cin >> t;\\n  while (t--) solve();\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"In a certain video game, the player controls a hero characterized by a single integer value: power. The hero will have to beat monsters that are also characterized by a single integer value: armor.\\n\\nOn the current level, the hero is facing n caves. To pass the level, the hero must enter all the caves in some order, each cave exactly once, and exit every cave safe and sound. When the hero enters cave i, he will have to fight k_i monsters in a row: first a monster with armor a_{i, 1}, then a monster with armor a_{i, 2} and so on, finally, a monster with armor a_{i, k_i}.\\n\\nThe hero can beat a monster if and only if the hero's power is strictly greater than the monster's armor. If the hero can't beat the monster he's fighting, the game ends and the player loses. Note that once the hero enters a cave, he can't exit it before he fights all the monsters in it, strictly in the given order.\\n\\nEach time the hero beats a monster, the hero's power increases by 1.\\n\\nFind the smallest possible power the hero must start the level with to be able to enter all the caves in some order and beat all the monsters.\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 10^5). Description of the test cases follows.\\n\\nThe first line of each test case contains a single integer n (1 \u2264 n \u2264 10^5) \u2014 the number of caves.\\n\\nThe i-th of the next n lines contains an integer k_i (1 \u2264 k_i \u2264 10^5) \u2014 the number of monsters in the i-th cave, followed by k_i integers a_{i, 1}, a_{i, 2}, \u2026, a_{i, k_i} (1 \u2264 a_{i, j} \u2264 10^9) \u2014 armor levels of the monsters in cave i in order the hero has to fight them.\\n\\nIt is guaranteed that the sum of k_i over all test cases does not exceed 10^5.\\n\\nOutput\\n\\nFor each test case print a single integer \u2014 the smallest possible power the hero must start the level with to be able to enter all the caves in some order and beat all the monsters.\\n\\nExample\\n\\nInput\\n\\n\\n2\\n1\\n1 42\\n2\\n3 10 15 8\\n2 12 11\\n\\n\\nOutput\\n\\n\\n43\\n13\\n\\nNote\\n\\nIn the first test case, the hero has to beat a single monster with...\\nSolve the task in JAVA.\",\"targets\":\"\\/*==========================================================================\\n*   \\tAUTHOR:    RonWonWon\\n*   \\tCREATED:   25.08.2021 22:45:05        \\n\\/*==========================================================================*\\/\\nimport java.io.*;\\nimport java.util.*;\\n\\npublic class C {\\n\\t\\n\\tpublic static void main(String[] args) throws IOException {\\n\\t\\t\\/*\\n    in.ini();\\n    PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter(\\\"output.txt\\\")));\\n    *\\/\\n    long startTime = System.nanoTime();\\n    int t = in.nextInt(), T = 1;  \\n    while(t-->0) { \\n      int n = in.nextInt();\\n      Pair a[] = new Pair[n];\\n      for(int i=0;i<n;i++){\\n\\t\\t\\t\\tint k = in.nextInt();\\n\\t\\t\\t\\tint minus = -1, mx = 0;\\n\\t\\t\\t\\tfor(int j=0;j<k;j++){\\n\\t\\t\\t\\t\\tint x = in.nextInt();\\n\\t\\t\\t\\t\\tmx = Math.max(mx,x-minus);\\n\\t\\t\\t\\t\\tminus++;\\n\\t\\t\\t\\t}\\n\\t\\t\\t\\ta[i] = new Pair(k,mx);\\n\\t\\t\\t}\\n\\t\\t\\tArrays.sort(a);\\n\\t\\t\\tint ans = 0, cur = 0, add = 0;\\n\\t\\t\\tfor(int i=0;i<n;i++){\\n\\t\\t\\t\\tif(a[i].y>cur){\\n\\t\\t\\t\\t\\tans = a[i].y - add;\\n\\t\\t\\t\\t\\tcur = a[i].y;\\n\\t\\t\\t\\t}\\n\\t\\t\\t\\tcur += a[i].x;\\n\\t\\t\\t\\tadd += a[i].x;\\n\\t\\t\\t}\\n      out.println(ans);\\n   \\t\\t\\/\\/out.println(\\\"Case #\\\"+T+\\\": \\\"+ans); T++;\\n    }\\n    \\/*\\n    startTime = System.nanoTime() - startTime;\\n    System.err.println(\\\"Time: \\\"+(startTime\\/1000000));\\n    *\\/\\n    out.flush();\\n\\t}\\n\\t\\n\\tstatic class Pair implements Comparable<Pair> {\\n\\t\\tint x, y;\\n\\t\\tPair(int a, int b){ x = a; y = b; }\\t\\t\\n\\t\\t@Override\\n\\t\\tpublic int compareTo(Pair o) {\\n\\t\\t\\tif(o.y - this.y>0)\\n\\t\\t\\t\\treturn -1;\\n\\t\\t\\telse if(o.y - this.y<0)\\n\\t\\t\\t\\treturn 1;\\n\\t\\t\\telse \\n\\t\\t\\t\\treturn 0;\\n\\t\\t}\\n\\t}\\n\\t\\n\\tstatic FastScanner in = new FastScanner();\\n  static PrintWriter out = new PrintWriter(System.out);\\n\\tstatic int oo = Integer.MAX_VALUE;\\n\\tstatic long ooo = Long.MAX_VALUE;\\n\\t\\n\\tstatic class FastScanner {\\n\\t\\tBufferedReader br = new BufferedReader(new InputStreamReader(System.in));\\n\\t\\tStringTokenizer st = new StringTokenizer(\\\"\\\");\\n\\t\\t\\n\\t\\tvoid ini() throws FileNotFoundException {\\n\\t\\t\\tbr = new BufferedReader(new FileReader(\\\"input.txt\\\"));\\n\\t\\t}\\n\\t\\t\\n\\t\\tString next() {\\n\\t\\t\\twhile(!st.hasMoreTokens())\\n\\t\\t\\t\\ttry { st = new StringTokenizer(br.readLine());...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"PYTHON3 solution for \\\"You are given an integer k and a string s that consists only of characters 'a' (a lowercase Latin letter) and '*' (an asterisk).\\n\\nEach asterisk should be replaced with several (from 0 to k inclusive) lowercase Latin letters 'b'. Different asterisk can be replaced with different counts of letter 'b'.\\n\\nThe result of the replacement is called a BA-string.\\n\\nTwo strings a and b are different if they either have different lengths or there exists such a position i that a_i \u2260 b_i.\\n\\nA string a is lexicographically smaller than a string b if and only if one of the following holds: \\n\\n  * a is a prefix of b, but a \u2260 b; \\n  * in the first position where a and b differ, the string a has a letter that appears earlier in the alphabet than the corresponding letter in b. \\n\\n\\n\\nNow consider all different BA-strings and find the x-th lexicographically smallest of them.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 2000) \u2014 the number of testcases.\\n\\nThe first line of each testcase contains three integers n, k and x (1 \u2264 n \u2264 2000; 0 \u2264 k \u2264 2000; 1 \u2264 x \u2264 10^{18}). n is the length of string s.\\n\\nThe second line of each testcase is a string s. It consists of n characters, each of them is either 'a' (a lowercase Latin letter) or '*' (an asterisk).\\n\\nThe sum of n over all testcases doesn't exceed 2000. For each testcase x doesn't exceed the total number of different BA-strings. String s contains at least one character 'a'.\\n\\nOutput\\n\\nFor each testcase, print a single string, consisting only of characters 'b' and 'a' (lowercase Latin letters) \u2014 the x-th lexicographically smallest BA-string.\\n\\nExample\\n\\nInput\\n\\n\\n3\\n2 4 3\\na*\\n4 1 3\\na**a\\n6 3 20\\n**a***\\n\\n\\nOutput\\n\\n\\nabb\\nabba\\nbabbbbbbbbb\\n\\nNote\\n\\nIn the first testcase of the example, BA-strings ordered lexicographically are: \\n\\n  1. a\\n  2. ab\\n  3. abb\\n  4. abbb\\n  5. abbbb\\n\\n\\n\\nIn the second testcase of the example, BA-strings ordered lexicographically are: \\n\\n  1. aa\\n  2. aba\\n  3. abba\\n\\n\\n\\nNote that string \\\"aba\\\" is only counted once, even though there are two ways to replace asterisks with characters...\\\":\",\"targets\":\"t=int(input())\\nfor i in range(t):\\n n,k,x=map(int,input().split())\\n s=input()\\n aa,ab=[],[]\\n if s[0]==\\\"*\\\":\\n  aa.append(0)\\n c=0\\n for j in range(n):\\n  if s[j]==\\\"a\\\":\\n   c+=1\\n  elif c!=0:\\n   aa.append(c)\\n   c=0\\n if c!=0:\\n  aa.append(c)\\n c=0\\n for j in range(n):\\n  if s[j]==\\\"*\\\":\\n   c+=1\\n  elif c!=0:\\n   ab.append(c)\\n   c=0\\n if ab!=0:\\n  ab.append(c)\\n y=x\\n y-=1\\n nb=ab[:]\\n for i in range(len(ab)-1,-1,-1):\\n  nb[i]=y%(ab[i]*k+1)\\n  y=y\\/\\/(ab[i]*k+1)\\n for i in range(len(aa)):\\n  print(\\\"a\\\"*aa[i],end=\\\"\\\")\\n  if i<len(nb):\\n   print(\\\"b\\\"*nb[i],end=\\\"\\\")\\n print(\\\"\\\")\",\"language\":\"python\",\"split\":\"test\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Monocarp has got an array a consisting of n integers. Let's denote k as the mathematic mean of these elements (note that it's possible that k is not an integer). \\n\\nThe mathematic mean of an array of n elements is the sum of elements divided by the number of these elements (i. e. sum divided by n).\\n\\nMonocarp wants to delete exactly two elements from a so that the mathematic mean of the remaining (n - 2) elements is still equal to k.\\n\\nYour task is to calculate the number of pairs of positions [i, j] (i < j) such that if the elements on these positions are deleted, the mathematic mean of (n - 2) remaining elements is equal to k (that is, it is equal to the mathematic mean of n elements of the original array a).\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 10^4) \u2014 the number of testcases.\\n\\nThe first line of each testcase contains one integer n (3 \u2264 n \u2264 2 \u22c5 10^5) \u2014 the number of elements in the array.\\n\\nThe second line contains a sequence of integers a_1, a_2, ..., a_n (0 \u2264 a_i \u2264 10^{9}), where a_i is the i-th element of the array.\\n\\nThe sum of n over all testcases doesn't exceed 2 \u22c5 10^5.\\n\\nOutput\\n\\nPrint one integer \u2014 the number of pairs of positions [i, j] (i < j) such that if the elements on these positions are deleted, the mathematic mean of (n - 2) remaining elements is equal to k (that is, it is equal to the mathematic mean of n elements of the original array a).\\n\\nExample\\n\\nInput\\n\\n\\n4\\n4\\n8 8 8 8\\n3\\n50 20 10\\n5\\n1 4 7 3 5\\n7\\n1 2 3 4 5 6 7\\n\\n\\nOutput\\n\\n\\n6\\n0\\n2\\n3\\n\\nNote\\n\\nIn the first example, any pair of elements can be removed since all of them are equal.\\n\\nIn the second example, there is no way to delete two elements so the mathematic mean doesn't change.\\n\\nIn the third example, it is possible to delete the elements on positions 1 and 3, or the elements on positions 4 and 5.\\nThe above is tricky. Write me a correct solution in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nusing ll = long long int;\\nusing vi = vector<int>;\\nusing ii = pair<int, int>;\\nusing vii = vector<ii>;\\nconst int MOD = 1000000007;\\nint main() {\\n  ios_base::sync_with_stdio(false);\\n  cin.tie(NULL);\\n  int t;\\n  cin >> t;\\n  while (t--) {\\n    int n;\\n    cin >> n;\\n    vi a(n);\\n    ll s = 0;\\n    for (int i = 0; i < n; i++) {\\n      cin >> a[i];\\n      s += (ll)a[i];\\n    }\\n    ll c = 0;\\n    sort(a.begin(), a.end());\\n    for (int i = 0; i < n; i++) {\\n      ll ai = a[i];\\n      if ((2 * s) % n == 0) {\\n        ll aj = (2 * s - 2 * ai - (n - 2) * ai) \\/ n;\\n        c += upper_bound(a.begin() + i + 1, a.end(), aj) -\\n             lower_bound(a.begin() + i + 1, a.end(), aj);\\n      }\\n    }\\n    cout << c << endl;\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"On a circle lie 2n distinct points, with the following property: however you choose 3 chords that connect 3 disjoint pairs of points, no point strictly inside the circle belongs to all 3 chords. The points are numbered 1,   2,   ...,   2n in clockwise order.\\n\\nInitially, k chords connect k pairs of points, in such a way that all the 2k endpoints of these chords are distinct.\\n\\nYou want to draw n - k additional chords that connect the remaining 2(n - k) points (each point must be an endpoint of exactly one chord).\\n\\nIn the end, let x be the total number of intersections among all n chords. Compute the maximum value that x can attain if you choose the n - k chords optimally.\\n\\nNote that the exact position of the 2n points is not relevant, as long as the property stated in the first paragraph holds.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 100) \u2014 the number of test cases. Then t test cases follow.\\n\\nThe first line of each test case contains two integers n and k (1 \u2264 n \u2264 100, 0 \u2264 k \u2264 n) \u2014 half the number of points and the number of chords initially drawn.\\n\\nThen k lines follow. The i-th of them contains two integers x_i and y_i (1 \u2264 x_i,   y_i \u2264 2n, x_i \u2260 y_i) \u2014 the endpoints of the i-th chord. It is guaranteed that the 2k numbers x_1,   y_1,   x_2,   y_2,   ...,   x_k,   y_k are all distinct.\\n\\nOutput\\n\\nFor each test case, output the maximum number of intersections that can be obtained by drawing n - k additional chords.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n4 2\\n8 2\\n1 5\\n1 1\\n2 1\\n2 0\\n10 6\\n14 6\\n2 20\\n9 10\\n13 18\\n15 12\\n11 7\\n\\n\\nOutput\\n\\n\\n4\\n0\\n1\\n14\\n\\nNote\\n\\nIn the first test case, there are three ways to draw the 2 additional chords, shown below (black chords are the ones initially drawn, while red chords are the new ones):\\n\\n<image>\\n\\nWe see that the third way gives the maximum number of intersections, namely 4.\\n\\nIn the second test case, there are no more chords to draw. Of course, with only one chord present there are no intersections.\\n\\nIn the third test case, we can make at most one intersection by drawing chords 1-3 and 2-4, as...\",\"targets\":\"#include <bits\\/stdc++.h>\\n#pragma GCC optimize(\\\"Ofast\\\")\\nusing namespace std;\\ninline long long read() {\\n  long long x = 0, f = 1;\\n  char ch = getchar();\\n  while (ch < '0' || ch > '9') {\\n    if (ch == '-') f = -1;\\n    ch = getchar();\\n  }\\n  while (ch >= '0' && ch <= '9') {\\n    x = x * 10 + ch - '0';\\n    ch = getchar();\\n  }\\n  return x * f;\\n}\\nvoid write(long long x) {\\n  if (x < 0) putchar('-'), x = -x;\\n  if (x >= 10) write(x \\/ 10);\\n  putchar(x % 10 + '0');\\n}\\nconst long long N = 1010, mod = 31607;\\nlong long a[N], x[N], y[N], mark[N], q[N];\\nlong long n, fl, k;\\nint main() {\\n  for (long long T = read(); T--;) {\\n    n = read();\\n    k = read();\\n    memset(mark, 0, sizeof mark);\\n    memset(x, 0, sizeof x);\\n    memset(y, 0, sizeof y);\\n    for (long long i = (long long)(1); i <= (long long)(k); ++i)\\n      x[i] = read(), y[i] = read(), mark[x[i]] = mark[y[i]] = 1;\\n    long long pos = 1, sm = 0;\\n    *q = 0;\\n    for (long long i = (long long)(1); i <= (long long)(2 * n); ++i)\\n      if (!mark[i]) q[++*q] = i;\\n    for (long long i = (long long)(1); i <= (long long)(*q \\/ 2); ++i) {\\n      x[++k] = q[i];\\n      y[k] = q[i + *q \\/ 2];\\n    }\\n    for (long long i = (long long)(1); i <= (long long)(n); ++i)\\n      if (x[i] > y[i]) swap(x[i], y[i]);\\n    long long ans = 0;\\n    for (long long i = (long long)(1); i <= (long long)(n); ++i)\\n      for (long long j = (long long)(1); j <= (long long)(n); ++j)\\n        ans += x[i] < x[j] && x[j] < y[i] && y[i] < y[j];\\n    cout << ans << endl;\\n  }\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"n people gathered to hold a jury meeting of the upcoming competition, the i-th member of the jury came up with a_i tasks, which they want to share with each other.\\n\\nFirst, the jury decides on the order which they will follow while describing the tasks. Let that be a permutation p of numbers from 1 to n (an array of size n where each integer from 1 to n occurs exactly once).\\n\\nThen the discussion goes as follows:\\n\\n  * If a jury member p_1 has some tasks left to tell, then they tell one task to others. Otherwise, they are skipped. \\n  * If a jury member p_2 has some tasks left to tell, then they tell one task to others. Otherwise, they are skipped. \\n  * ... \\n  * If a jury member p_n has some tasks left to tell, then they tell one task to others. Otherwise, they are skipped. \\n  * If there are still members with tasks left, then the process repeats from the start. Otherwise, the discussion ends. \\n\\n\\n\\nA permutation p is nice if none of the jury members tell two or more of their own tasks in a row. \\n\\nCount the number of nice permutations. The answer may be really large, so print it modulo 998 244 353.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases.\\n\\nThe first line of the test case contains a single integer n (2 \u2264 n \u2264 2 \u22c5 10^5) \u2014 number of jury members.\\n\\nThe second line contains n integers a_1, a_2, ..., a_n (1 \u2264 a_i \u2264 10^9) \u2014 the number of problems that the i-th member of the jury came up with.\\n\\nThe sum of n over all test cases does not exceed 2 \u22c5 10^5.\\n\\nOutput\\n\\nFor each test case, print one integer \u2014 the number of nice permutations, taken modulo 998 244 353.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n2\\n1 2\\n3\\n5 5 5\\n4\\n1 3 3 7\\n6\\n3 4 2 1 3 3\\n\\n\\nOutput\\n\\n\\n1\\n6\\n0\\n540\\n\\nNote\\n\\nExplanation of the first test case from the example:\\n\\nThere are two possible permutations, p = [1, 2] and p = [2, 1]. For p = [1, 2], the process is the following:\\n\\n  1. the first jury member tells a task; \\n  2. the second jury member tells a task; \\n  3. the first jury member doesn't have any tasks left to tell, so they are skipped;...\\nimpor\",\"targets\":\"t java.io.BufferedReader;\\nimport java.io.InputStreamReader;\\nimport java.util.ArrayList;\\nimport java.util.Arrays;\\nimport java.util.Collections;\\n\\n\\npublic class JuryMeeting {\\n\\n    private static final long MOD=998244353;\\n    private static final int mx = 2 * 100001;\\n    private static final long[] fact = new long[mx];\\n    private static final long[] inv = new long[mx];\\n    private static final long[] invfact = new long[mx];\\n    private static InputStreamReader ina = new InputStreamReader(System.in);\\n    private static BufferedReader in = new BufferedReader(ina);\\n\\n    public static void main(String[] args )throws Exception {\\n\\n        fillFactorials();\\n        int teste = Integer.parseInt(in.readLine());\\n        while (teste-- > 0) {\\n            solve();\\n        }\\n    }\\n\\n    private static void fillFactorials() {\\n        fact[0] = fact[1] = inv[1] = invfact[0] = invfact[1] = 1;\\n        for (int i = 2; i < mx; i++) {\\n            fact[i] = (fact[i-1]*i) % MOD;\\n            inv[i] = MOD - MOD\\/i*inv[(int)MOD%i]%MOD;\\n            invfact[i] = inv[i]*invfact[i-1]%MOD;\\n        }\\n    }\\n\\n    private static void solve() throws Exception {\\n        int inimesi = Integer.parseInt(in.readLine());\\n        String[] tasks_str = in.readLine().split(\\\" \\\");\\n        ArrayList<Long> tasks = new ArrayList<>();\\n        for (int i = 0; i < inimesi; i++) {\\n            tasks.add(Long.valueOf(tasks_str[i]));\\n        }\\n\\n        long max_tasks = Collections.max(tasks);\\n        int max_taskide_arv = Collections.frequency(tasks, max_tasks);\\n        int max_miinus_1_taskide_arv = Collections.frequency(tasks, max_tasks-1);\\n        int ylejaanud = tasks.size() - max_taskide_arv - max_miinus_1_taskide_arv;\\n\\n        \\/\\/ Kui max_taskide arvuga inimesi on rohkem kui 1 siis on k\u00f5ik permutatsiooni ilusad, sest nad omavahel saavad hakkama\\n        if(max_taskide_arv > 1){\\n            System.out.println(fact[tasks.size()]);\\n        } else if (max_miinus_1_taskide_arv == 0){ \\/\\/ Kui max_taskidega on 1 inimene, siis peab leiduma v\u00e4hemnalt 1 inimene kellel on taske...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"A non-empty string s is called binary, if it consists only of characters \\\"0\\\" and \\\"1\\\". Let's number the characters of binary string s from 1 to the string's length and let's denote the i-th character in string s as si.\\n\\nBinary string s with length n is periodical, if there is an integer 1 \u2264 k < n such that: \\n\\n  * k is a divisor of number n\\n  * for all 1 \u2264 i \u2264 n - k, the following condition fulfills: si = si + k\\n\\n\\n\\nFor example, binary strings \\\"101010\\\" and \\\"11\\\" are periodical and \\\"10\\\" and \\\"10010\\\" are not.\\n\\nA positive integer x is periodical, if its binary representation (without leading zeroes) is a periodic string.\\n\\nYour task is to calculate, how many periodic numbers are in the interval from l to r (both ends are included).\\n\\nInput\\n\\nThe single input line contains two integers l and r (1 \u2264 l \u2264 r \u2264 1018). The numbers are separated by a space.\\n\\nPlease, do not use the %lld specifier to read or write 64-bit integers in \u0421++. It is preferred to use the cin, cout streams or the %I64d specifier.\\n\\nOutput\\n\\nPrint a single integer, showing how many periodic numbers are in the interval from l to r (both ends are included).\\n\\nExamples\\n\\nInput\\n\\n1 10\\n\\n\\nOutput\\n\\n3\\n\\n\\nInput\\n\\n25 38\\n\\n\\nOutput\\n\\n2\\n\\nNote\\n\\nIn the first sample periodic numbers are 3, 7 and 10.\\n\\nIn the second sample periodic numbers are 31 and 36.\\nUsing cpp can you solve the prior task?\",\"targets\":\"#include <bits\\/stdc++.h>\\nconst double PI = 3.1415926535897932384626433;\\nconst int KL = 1e6;\\nconst long long MOD = 1e9 + 7;\\nusing namespace std;\\nlong long l, r, p[100];\\nvector<int> vec;\\nlong long mem[35][70][70][2];\\nint vis[35][70][70][2], timer;\\nlong long dp(int i, int fs, int fg, bool ok, int k) {\\n  if (i == k) {\\n    if (ok || fg == 0 || (fg > 0 && fs != 0 && fs < fg)) return 1;\\n    return 0;\\n  }\\n  if (vis[i][fs][fg][ok] == timer) return mem[i][fs][fg][ok];\\n  vis[i][fs][fg][ok] = timer;\\n  if (i == 0) {\\n    int ffg = 0;\\n    for (int j = k; j < vec.size(); j += k)\\n      if (vec[j] < 1) {\\n        ffg = j;\\n        break;\\n      }\\n    return mem[i][fs][fg][ok] = dp(i + 1, fs, ffg, ok, k);\\n  }\\n  if (ok) {\\n    return mem[i][fs][fg][ok] = 2 * dp(i + 1, fs, fg, ok, k);\\n  }\\n  long long path = 0;\\n  int ffs = 0;\\n  for (int j = i + k; j < vec.size(); j += k)\\n    if (vec[j] > 0) {\\n      ffs = j;\\n      break;\\n    }\\n  if (fs > 0 && ffs > 0)\\n    ffs = min(ffs, fs);\\n  else if (fs > 0 && ffs == 0)\\n    ffs = fs;\\n  path += dp(i + 1, ffs, fg, (vec[i] == 1), k);\\n  if (vec[i] == 1) {\\n    int ffg = 0;\\n    for (int j = i + k; j < vec.size(); j += k)\\n      if (vec[j] < 1) {\\n        ffg = j;\\n        break;\\n      }\\n    if (fg > 0 && ffg > 0)\\n      ffg = min(ffg, fg);\\n    else if (fg > 0 && ffg == 0)\\n      ffg = fg;\\n    path += dp(i + 1, fs, ffg, ok, k);\\n  }\\n  return mem[i][fs][fg][ok] = path;\\n}\\nlong long solve(long long n) {\\n  if (n < 3) return 0;\\n  vec.clear();\\n  while (n != 0) {\\n    vec.push_back(n % 2);\\n    n \\/= 2;\\n  }\\n  reverse(vec.begin(), vec.end());\\n  long long ret = 0;\\n  for (int i = 1; i <= vec.size(); i++) p[i] = 0;\\n  for (int i = 2; i < vec.size(); i++) {\\n    long long sz = i;\\n    vector<int> dv;\\n    for (int j = 1; j < sz; j++) {\\n      if (sz % j == 0) dv.push_back(j);\\n    }\\n    for (auto v : dv) {\\n      p[i] += ((1 << (v - 1)) - p[v]);\\n    }\\n    ret += p[i];\\n  }\\n  for (int i = 1; i <= vec.size(); i++) p[i] = 0;\\n  for (int i = 2; i <= vec.size(); i++) {\\n    long long sz = i;\\n    vector<int> dv;\\n    for (int j = 1; j < sz;...\",\"language\":\"python\",\"split\":\"train\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"A guy named Vasya attends the final grade of a high school. One day Vasya decided to watch a match of his favorite hockey team. And, as the boy loves hockey very much, even more than physics, he forgot to do the homework. Specifically, he forgot to complete his physics tasks. Next day the teacher got very angry at Vasya and decided to teach him a lesson. He gave the lazy student a seemingly easy task: You are given an idle body in space and the forces that affect it. The body can be considered as a material point with coordinates (0; 0; 0). Vasya had only to answer whether it is in equilibrium. \\\"Piece of cake\\\" \u2014 thought Vasya, we need only to check if the sum of all vectors is equal to 0. So, Vasya began to solve the problem. But later it turned out that there can be lots and lots of these forces, and Vasya can not cope without your help. Help him. Write a program that determines whether a body is idle or is moving by the given vectors of forces.\\n\\nInput\\n\\nThe first line contains a positive integer n (1 \u2264 n \u2264 100), then follow n lines containing three integers each: the xi coordinate, the yi coordinate and the zi coordinate of the force vector, applied to the body ( - 100 \u2264 xi, yi, zi \u2264 100).\\n\\nOutput\\n\\nPrint the word \\\"YES\\\" if the body is in equilibrium, or the word \\\"NO\\\" if it is not.\\n\\nExamples\\n\\nInput\\n\\n3\\n4 1 7\\n-2 4 -1\\n1 -5 -3\\n\\n\\nOutput\\n\\nNO\\n\\nInput\\n\\n3\\n3 -1 7\\n-5 2 -4\\n2 -1 -3\\n\\n\\nOutput\\n\\nYES\\na=int\",\"targets\":\"(input())\\nx=0\\ny=0\\nz=0\\nfor i in range(a):\\n    xx,yy,zz=map(int,input().split())\\n    x+=xx\\n    y+=yy\\n    z+=z\\n    \\nif x==y==z==0:\\n    print(\\\"YES\\\")\\nelse:\\n    print(\\\"NO\\\")\",\"language\":\"python\",\"split\":\"train\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Polycarp likes squares and cubes of positive integers. Here is the beginning of the sequence of numbers he likes: 1, 4, 8, 9, ....\\n\\nFor a given number n, count the number of integers from 1 to n that Polycarp likes. In other words, find the number of such x that x is a square of a positive integer number or a cube of a positive integer number (or both a square and a cube simultaneously).\\n\\nInput\\n\\nThe first line contains an integer t (1 \u2264 t \u2264 20) \u2014 the number of test cases.\\n\\nThen t lines contain the test cases, one per line. Each of the lines contains one integer n (1 \u2264 n \u2264 10^9).\\n\\nOutput\\n\\nFor each test case, print the answer you are looking for \u2014 the number of integers from 1 to n that Polycarp likes.\\n\\nExample\\n\\nInput\\n\\n\\n6\\n10\\n1\\n25\\n1000000000\\n999999999\\n500000000\\n\\n\\nOutput\\n\\n\\n4\\n1\\n6\\n32591\\n32590\\n23125\",\"targets\":\"n = int(input())\\nanswer = []\\nk = []\\nfor i in range(n):\\n    s = int(input())\\n    answer.append(s)\\nfor j in answer:\\n    ans = {1: 1}\\n    if j < 4:\\n        k.append(1)\\n    elif j < 8:\\n        k.append(2)\\n    else:\\n        for i in range(2, j \\/\\/ 2 + 1):\\n            if i ** 3 <= j:\\n                ans[i ** 3] = ans.get(i ** 3, 0) + 1\\n                ans[i ** 2] = ans.get(i ** 2, 0) + 1\\n            elif i ** 2 <= j:\\n                ans[i ** 2] = ans.get(i ** 2, 0) + 1\\n            else:\\n                k.append(len(ans))\\n                break\\nfor i in k:\\n    print(i)\\n\\n'''\\n20\\n511987557\\n940318563\\n397150475\\n454087385\\n354269461\\n613861695\\n211176104\\n419833326\\n505148301\\n319706849\\n213732674\\n655143258\\n485034974\\n341893134\\n696107438\\n892474645\\n801724293\\n205267813\\n941783222\\n940658655\\n'''\",\"language\":\"python\",\"split\":\"test\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Andre has very specific tastes. Recently he started falling in love with arrays.\\n\\nAndre calls an nonempty array b good, if sum of its elements is divisible by the length of this array. For example, array [2, 3, 1] is good, as sum of its elements \u2014 6 \u2014 is divisible by 3, but array [1, 1, 2, 3] isn't good, as 7 isn't divisible by 4. \\n\\nAndre calls an array a of length n perfect if the following conditions hold: \\n\\n  * Every nonempty subarray of this array is good. \\n  * For every i (1 \u2264 i \u2264 n), 1 \u2264 a_i \u2264 100. \\n\\n\\n\\nGiven a positive integer n, output any perfect array of length n. We can show that for the given constraints such an array always exists.\\n\\nAn array c is a subarray of an array d if c can be obtained from d by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 100). Description of the test cases follows.\\n\\nThe first and only line of every test case contains a single integer n (1 \u2264 n \u2264 100).\\n\\nOutput\\n\\nFor every test, output any perfect array of length n on a separate line. \\n\\nExample\\n\\nInput\\n\\n\\n3\\n1\\n2\\n4\\n\\n\\nOutput\\n\\n\\n24\\n19 33\\n7 37 79 49\\n\\nNote\\n\\nArray [19, 33] is perfect as all 3 its subarrays: [19], [33], [19, 33], have sums divisible by their lengths, and therefore are good.\",\"targets\":\"import java.util.*;\\nimport java.io.*;\\npublic class Solution{\\n    public static void main(String arg[]){\\n        Scanner scan = new Scanner(System.in);\\n        int t = scan.nextInt();\\n        while (t > 0)\\n        {\\n\\t\\t    int i, n = scan.nextInt();\\n\\t\\t\\tSystem.out.print(\\\"1\\\");\\n\\t\\t\\tfor (i = 1; i < n; ++i)\\n\\t\\t\\t{\\n\\t\\t\\tSystem.out.print(\\\" 1\\\");\\n\\t\\t\\t}\\n\\t        System.out.println(\\\"\\\");\\n            t--;\\n        }\\n    }\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"The Olympic Games have just started and Federico is eager to watch the marathon race.\\n\\nThere will be n athletes, numbered from 1 to n, competing in the marathon, and all of them have taken part in 5 important marathons, numbered from 1 to 5, in the past. For each 1\u2264 i\u2264 n and 1\u2264 j\u2264 5, Federico remembers that athlete i ranked r_{i,j}-th in marathon j (e.g., r_{2,4}=3 means that athlete 2 was third in marathon 4).\\n\\nFederico considers athlete x superior to athlete y if athlete x ranked better than athlete y in at least 3 past marathons, i.e., r_{x,j}<r_{y,j} for at least 3 distinct values of j.\\n\\nFederico believes that an athlete is likely to get the gold medal at the Olympics if he is superior to all other athletes.\\n\\nFind any athlete who is likely to get the gold medal (that is, an athlete who is superior to all other athletes), or determine that there is no such athlete.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 1000) \u2014 the number of test cases. Then t test cases follow.\\n\\nThe first line of each test case contains a single integer n (1\u2264 n\u2264 50 000) \u2014 the number of athletes.\\n\\nThen n lines follow, each describing the ranking positions of one athlete.\\n\\nThe i-th of these lines contains the 5 integers r_{i,1},\\\\,r_{i,2},\\\\,r_{i,3},\\\\,r_{i,4},  r_{i,5} (1\u2264 r_{i,j}\u2264 50 000) \u2014 the ranking positions of athlete i in the past 5 marathons. It is guaranteed that, in each of the 5 past marathons, the n athletes have distinct ranking positions, i.e., for each 1\u2264 j\u2264 5, the n values r_{1,j},  r_{2, j},  ...,  r_{n, j} are distinct.\\n\\nIt is guaranteed that the sum of n over all test cases does not exceed 50 000.\\n\\nOutput\\n\\nFor each test case, print a single integer \u2014 the number of an athlete who is likely to get the gold medal (that is, an athlete who is superior to all other athletes). If there are no such athletes, print -1. If there is more than such one athlete, print any of them.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n1\\n50000 1 50000 50000 50000\\n3\\n10 10 20 30 30\\n20 20 30 10 10\\n30 30 10 20 20\\n3\\n1 1 1 1 1\\n2 2 2 2 2\\n3 3 3 3 3\\n6\\n9 5 3 7...\\nUsing python3 can you solve the prior task?\",\"targets\":\"# link: https:\\/\\/codeforces.com\\/contest\\/1552\\/problem\\/B\\n\\nimport os, sys\\nfrom io import BytesIO, IOBase\\n \\nBUFSIZE = 8192\\n \\n \\nclass FastIO(IOBase):\\n    newlines = 0\\n \\n    def __init__(self, file):\\n        self._fd = file.fileno()\\n        self.buffer = BytesIO()\\n        self.writable = \\\"x\\\" in file.mode or \\\"r\\\" not in file.mode\\n        self.write = self.buffer.write if self.writable else None\\n \\n    def read(self):\\n        while True:\\n            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))\\n            if not b:\\n                break\\n            ptr = self.buffer.tell()\\n            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)\\n        self.newlines = 0\\n        return self.buffer.read()\\n \\n    def readline(self):\\n        while self.newlines == 0:\\n            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))\\n            self.newlines = b.count(b\\\"\\\\n\\\") + (not b)\\n            ptr = self.buffer.tell()\\n            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)\\n        self.newlines -= 1\\n        return self.buffer.readline()\\n \\n    def flush(self):\\n        if self.writable:\\n            os.write(self._fd, self.buffer.getvalue())\\n            self.buffer.truncate(0), self.buffer.seek(0)\\n \\n \\nclass IOWrapper(IOBase):\\n    def __init__(self, file):\\n        self.buffer = FastIO(file)\\n        self.flush = self.buffer.flush\\n        self.writable = self.buffer.writable\\n        self.write = lambda s: self.buffer.write(s.encode(\\\"ascii\\\"))\\n        self.read = lambda: self.buffer.read().decode(\\\"ascii\\\")\\n        self.readline = lambda: self.buffer.readline().decode(\\\"ascii\\\")\\n \\n \\nsys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)\\ninput = lambda: sys.stdin.readline().rstrip(\\\"\\\\r\\\\n\\\")\\nfrom math import ceil\\nmod = 10 ** 9 + 7 \\n\\n# number of test cases\\nfor _ in range(int(input())):\\n    n = int(input())\\n    info = [] \\n    # positions = [[0 for i in range(n)] for j in range(5)]\\n    index = 0\\n    for i in range(n):\\n        l = list(map(int, input().split()))\\n       ...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"A famous sculptor Cicasso goes to a world tour!\\n\\nWell, it is not actually a world-wide. But not everyone should have the opportunity to see works of sculptor, shouldn't he? Otherwise there will be no any exclusivity. So Cicasso will entirely hold the world tour in his native country \u2014 Berland.\\n\\nCicasso is very devoted to his work and he wants to be distracted as little as possible. Therefore he will visit only four cities. These cities will be different, so no one could think that he has \\\"favourites\\\". Of course, to save money, he will chose the shortest paths between these cities. But as you have probably guessed, Cicasso is a weird person. Although he doesn't like to organize exhibitions, he likes to travel around the country and enjoy its scenery. So he wants the total distance which he will travel to be as large as possible. However, the sculptor is bad in planning, so he asks you for help. \\n\\nThere are n cities and m one-way roads in Berland. You have to choose four different cities, which Cicasso will visit and also determine the order in which he will visit them. So that the total distance he will travel, if he visits cities in your order, starting from the first city in your list, and ending in the last, choosing each time the shortest route between a pair of cities \u2014 will be the largest. \\n\\nNote that intermediate routes may pass through the cities, which are assigned to the tour, as well as pass twice through the same city. For example, the tour can look like that: <image>. Four cities in the order of visiting marked as overlines: [1, 5, 2, 4].\\n\\nNote that Berland is a high-tech country. So using nanotechnologies all roads were altered so that they have the same length. For the same reason moving using regular cars is not very popular in the country, and it can happen that there are such pairs of cities, one of which generally can not be reached by car from the other one. However, Cicasso is very conservative and cannot travel without the car. Choose cities so that the sculptor can make the tour using...\\\":\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst int MAX = 3005;\\nconst int UNLINKED = INT_MAX;\\nint dist[MAX][MAX];\\nvector<int> route[MAX];\\nint n, m;\\nstruct Link {\\n  int point;\\n  int dis;\\n  Link(int p, int d) : point(p), dis(d){};\\n};\\nvector<Link> firTosec[MAX];\\nvector<Link> secTofir[MAX];\\nvoid spfa(int x) {\\n  int inq[MAX];\\n  memset(inq, 0, sizeof(inq));\\n  for (int i = 1; i <= n; i++) dist[x][i] = UNLINKED;\\n  dist[x][x] = 0;\\n  queue<int> Q;\\n  Q.push(x);\\n  inq[x] = 1;\\n  while (!Q.empty()) {\\n    int now = Q.front();\\n    Q.pop();\\n    inq[now] = 0;\\n    for (int i = 0; i < route[now].size(); i++) {\\n      int next = route[now][i];\\n      if (dist[x][next] > dist[x][now] + 1) {\\n        dist[x][next] = dist[x][now] + 1;\\n        if (!inq[next]) {\\n          inq[next] = 1;\\n          Q.push(next);\\n        }\\n      }\\n    }\\n  }\\n}\\nbool cmp(Link a, Link b) { return a.dis > b.dis; }\\nint main() {\\n  cin >> n >> m;\\n  for (int i = 0; i < m; i++) {\\n    int a, b;\\n    scanf(\\\"%d%d\\\", &a, &b);\\n    route[a].push_back(b);\\n  }\\n  for (int i = 1; i <= n; i++) spfa(i);\\n  for (int i = 1; i <= n; i++) {\\n    for (int j = 1; j <= n; j++) {\\n      if (dist[i][j] != UNLINKED) firTosec[i].push_back(Link(j, dist[i][j]));\\n      if (dist[j][i] != UNLINKED) secTofir[i].push_back(Link(j, dist[j][i]));\\n    }\\n  }\\n  for (int i = 1; i <= n; i++) {\\n    sort(firTosec[i].begin(), firTosec[i].end(), cmp);\\n    sort(secTofir[i].begin(), secTofir[i].end(), cmp);\\n  }\\n  int a = -1, b = -1, c = -1, d = -1, ans = 0;\\n  for (int u = 1; u <= n; u++) {\\n    for (int v = 1; v <= n; v++) {\\n      if (v == u) continue;\\n      for (int i = 0; i < 3 && i < secTofir[u].size(); i++) {\\n        int s = secTofir[u][i].point;\\n        if (s == u || s == v) continue;\\n        for (int j = 0; j < 3 && j < firTosec[v].size(); j++) {\\n          int t = firTosec[v][j].point;\\n          if (t == u || t == v) continue;\\n          if (s == t) continue;\\n          int tmp = dist[u][v] + secTofir[u][i].dis + firTosec[v][j].dis;\\n          if (tmp > ans) {\\n            ans = tmp;\\n            a = s;\\n       ...\",\"language\":\"python\",\"split\":\"train\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"JAVA solution for \\\"Berland State University has received a new update for the operating system. Initially it is installed only on the 1-st computer.\\n\\nUpdate files should be copied to all n computers. The computers are not connected to the internet, so the only way to transfer update files from one computer to another is to copy them using a patch cable (a cable connecting two computers directly). Only one patch cable can be connected to a computer at a time. Thus, from any computer where the update files are installed, they can be copied to some other computer in exactly one hour.\\n\\nYour task is to find the minimum number of hours required to copy the update files to all n computers if there are only k patch cables in Berland State University.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 10^5) \u2014 the number of test cases.\\n\\nEach test case consists of a single line that contains two integers n and k (1 \u2264 k \u2264 n \u2264 10^{18}) \u2014 the number of computers and the number of patch cables.\\n\\nOutput\\n\\nFor each test case print one integer \u2014 the minimum number of hours required to copy the update files to all n computers.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n8 3\\n6 6\\n7 1\\n1 1\\n\\n\\nOutput\\n\\n\\n4\\n3\\n6\\n0\\n\\nNote\\n\\nLet's consider the test cases of the example:\\n\\n  * n=8, k=3: \\n    1. during the first hour, we copy the update files from the computer 1 to the computer 2; \\n    2. during the second hour, we copy the update files from the computer 1 to the computer 3, and from the computer 2 to the computer 4; \\n    3. during the third hour, we copy the update files from the computer 1 to the computer 5, from the computer 2 to the computer 6, and from the computer 3 to the computer 7; \\n    4. during the fourth hour, we copy the update files from the computer 2 to the computer 8. \\n  * n=6, k=6: \\n    1. during the first hour, we copy the update files from the computer 1 to the computer 2; \\n    2. during the second hour, we copy the update files from the computer 1 to the computer 3, and from the computer 2 to the computer 4; \\n    3. during the third hour, we copy the update...\\\":\",\"targets\":\"import java.io.BufferedReader;\\nimport java.io.IOException;\\nimport java.io.InputStreamReader;\\nimport java.util.ArrayList;\\nimport java.util.Collections;\\nimport java.util.StringTokenizer;\\n \\/\\/ snippet\\npublic class UpdateFiles {\\n \\/\\/ Question Link :\\n\\tpublic static void main(String[] args) {\\n\\t\\tFastScanner sc=new FastScanner();\\n\\t\\tint T=sc.nextInt();\\n\\t\\tfor (int tt=0; tt<T; tt++) {\\n\\t\\t\\tlong n = sc.nextLong();\\n\\t\\t\\tlong k = sc.nextLong();\\n\\t\\t\\tlong x =1;\\n\\t\\t\\tlong ans =0;\\n\\t\\t\\twhile(x<=k&&x<n) {\\n\\t\\t\\t\\tx=x*2;\\n\\t\\t\\t\\tans++;\\n\\t\\t\\t}\\n\\t\\t\\tif(x<n) {\\n\\t\\t\\t\\tans+=(n-x+k-1)\\/k;\\n\\t\\t\\t}\\n\\t\\t\\tSystem.out.println(ans);\\n\\t\\t}\\n\\t}\\n \\n\\tstatic void sort(int[] a) {\\n\\t\\tArrayList<Integer> l=new ArrayList<>();\\n\\t\\tfor (int i:a) l.add(i);\\n\\t\\tCollections.sort(l);\\n\\t\\tfor (int i=0; i<a.length; i++) a[i]=l.get(i);\\n\\t}\\n\\t\\n\\tstatic class FastScanner {\\n\\t\\tBufferedReader br=new BufferedReader(new InputStreamReader(System.in));\\n\\t\\tStringTokenizer st=new StringTokenizer(\\\"\\\");\\n\\t\\tString next() {\\n\\t\\t\\twhile (!st.hasMoreTokens())\\n\\t\\t\\t\\ttry {\\n\\t\\t\\t\\t\\tst=new StringTokenizer(br.readLine());\\n\\t\\t\\t\\t} catch (IOException e) {\\n\\t\\t\\t\\t\\te.printStackTrace();\\n\\t\\t\\t\\t}\\n\\t\\t\\treturn st.nextToken();\\n\\t\\t}\\n\\t\\t\\n\\t\\tint nextInt() {\\n\\t\\t\\treturn Integer.parseInt(next());\\n\\t\\t}\\n\\t\\tint[] readArray(int n) {\\n\\t\\t\\tint[] a=new int[n];\\n\\t\\t\\tfor (int i=0; i<n; i++) a[i]=nextInt();\\n\\t\\t\\treturn a;\\n\\t\\t}\\n\\t\\tlong nextLong() {\\n\\t\\t\\treturn Long.parseLong(next());\\n\\t\\t}\\n\\t}\\n \\n\\t\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in CPP?\\nPetya and Vasya decided to play a game. They have n cards (n is an even number). A single integer is written on each card.\\n\\nBefore the game Petya will choose an integer and after that Vasya will choose another integer (different from the number that Petya chose). During the game each player takes all the cards with number he chose. For example, if Petya chose number 5 before the game he will take all cards on which 5 is written and if Vasya chose number 10 before the game he will take all cards on which 10 is written.\\n\\nThe game is considered fair if Petya and Vasya can take all n cards, and the number of cards each player gets is the same.\\n\\nDetermine whether Petya and Vasya can choose integer numbers before the game so that the game is fair. \\n\\nInput\\n\\nThe first line contains a single integer n (2 \u2264 n \u2264 100) \u2014 number of cards. It is guaranteed that n is an even number.\\n\\nThe following n lines contain a sequence of integers a1, a2, ..., an (one integer per line, 1 \u2264 ai \u2264 100) \u2014 numbers written on the n cards.\\n\\nOutput\\n\\nIf it is impossible for Petya and Vasya to choose numbers in such a way that the game will be fair, print \\\"NO\\\" (without quotes) in the first line. In this case you should not print anything more.\\n\\nIn the other case print \\\"YES\\\" (without quotes) in the first line. In the second line print two distinct integers \u2014 number that Petya should choose and the number that Vasya should choose to make the game fair. If there are several solutions, print any of them.\\n\\nExamples\\n\\nInput\\n\\n4\\n11\\n27\\n27\\n11\\n\\n\\nOutput\\n\\nYES\\n11 27\\n\\n\\nInput\\n\\n2\\n6\\n6\\n\\n\\nOutput\\n\\nNO\\n\\n\\nInput\\n\\n6\\n10\\n20\\n30\\n20\\n10\\n20\\n\\n\\nOutput\\n\\nNO\\n\\n\\nInput\\n\\n6\\n1\\n1\\n2\\n2\\n3\\n3\\n\\n\\nOutput\\n\\nNO\\n\\nNote\\n\\nIn the first example the game will be fair if, for example, Petya chooses number 11, and Vasya chooses number 27. Then the will take all cards \u2014 Petya will take cards 1 and 4, and Vasya will take cards 2 and 3. Thus, each of them will take exactly two cards.\\n\\nIn the second example fair game is impossible because the numbers written on the cards are equal, but the numbers that Petya and...\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\n#pragma GCC push_options\\n#pragma GCC optimize(\\\"unroll-loops\\\")\\nint main() {\\n  ios_base::sync_with_stdio(false);\\n  cin.tie(0);\\n  cout.tie(0);\\n  long long n;\\n  cin >> n;\\n  map<long long, long long> m;\\n  for (int i = 0; i < n; i++) {\\n    long long temp;\\n    cin >> temp;\\n    m[temp]++;\\n  }\\n  if (m.size() != 2) {\\n    cout << \\\"NO\\\\n\\\";\\n    return 0;\\n  }\\n  long long val1 = (m.begin())->second;\\n  long long val2 = (++m.begin())->second;\\n  if (val1 == val2) {\\n    cout << \\\"YES\\\\n\\\"\\n         << (m.begin())->first << \\\" \\\" << (++m.begin())->first << \\\"\\\\n\\\";\\n  } else\\n    cout << \\\"NO\\\\n\\\";\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You are given a sequence a_1, a_2, ..., a_n consisting of n pairwise distinct positive integers.\\n\\nFind \\\\left\u230a \\\\frac n 2 \\\\right\u230b different pairs of integers x and y such that: \\n\\n  * x \u2260 y; \\n  * x and y appear in a; \\n  * x~mod~y doesn't appear in a. \\n\\n\\n\\nNote that some x or y can belong to multiple pairs.\\n\\n\u230a x \u230b denotes the floor function \u2014 the largest integer less than or equal to x. x~mod~y denotes the remainder from dividing x by y.\\n\\nIf there are multiple solutions, print any of them. It can be shown that at least one solution always exists.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 10^4) \u2014 the number of testcases.\\n\\nThe first line of each testcase contains a single integer n (2 \u2264 n \u2264 2 \u22c5 10^5) \u2014 the length of the sequence.\\n\\nThe second line of each testcase contains n integers a_1, a_2, ..., a_n (1 \u2264 a_i \u2264 10^6).\\n\\nAll numbers in the sequence are pairwise distinct. The sum of n over all testcases doesn't exceed 2 \u22c5 10^5.\\n\\nOutput\\n\\nThe answer for each testcase should contain \\\\left\u230a \\\\frac n 2 \\\\right\u230b different pairs of integers x and y such that x \u2260 y, x and y appear in a and x~mod~y doesn't appear in a. Print the pairs one after another.\\n\\nYou can print the pairs in any order. However, the order of numbers in the pair should be exactly such that the first number is x and the second number is y. All pairs should be pairwise distinct.\\n\\nIf there are multiple solutions, print any of them.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n2\\n1 4\\n4\\n2 8 3 4\\n5\\n3 8 5 9 7\\n6\\n2 7 5 3 4 8\\n\\n\\nOutput\\n\\n\\n4 1\\n8 2\\n8 4\\n9 5\\n7 5\\n8 7\\n4 3\\n5 2\\n\\nNote\\n\\nIn the first testcase there are only two pairs: (1, 4) and (4, 1). \\\\left\u230a \\\\frac 2 2 \\\\right\u230b=1, so we have to find one pair. 1~mod~4=1, and 1 appears in a, so that pair is invalid. Thus, the only possible answer is a pair (4, 1).\\n\\nIn the second testcase, we chose pairs 8~mod~2=0 and 8~mod~4=0. 0 doesn't appear in a, so that answer is valid. There are multiple possible answers for that testcase.\\n\\nIn the third testcase, the chosen pairs are 9~mod~5=4 and 7~mod~5=2. Neither 4, nor 2, appears in a, so that...\\nThe above is tricky. Write me a correct solution in PYTHON3.\",\"targets\":\"t = int(input())\\nfor q in range(0, t):\\n\\tn = int(input())\\n\\tli = list(map(int, input().split()))\\n\\t\\n\\tli.sort()\\n\\t\\n\\trequirement = n \\/\\/ 2\\n\\ttemp = 1\\n\\n\\tfor i in range(0, requirement):\\n\\t\\tprint(li[temp], li[0])\\n\\t\\ttemp += 1\",\"language\":\"python\",\"split\":\"test\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in CPP?\\nMocha is a young girl from high school. She has learned so much interesting knowledge from her teachers, especially her math teacher. Recently, Mocha is learning about binary system and very interested in bitwise operation.\\n\\nThis day, Mocha got a sequence a of length n. In each operation, she can select an arbitrary interval [l, r] and for all values i (0\u2264 i \u2264 r-l), replace a_{l+i} with a_{l+i}  \\\\&  a_{r-i} at the same time, where \\\\& denotes the [bitwise AND operation](https:\\/\\/en.wikipedia.org\\/wiki\\/Bitwise_operation#AND). This operation can be performed any number of times.\\n\\nFor example, if n=5, the array is [a_1,a_2,a_3,a_4,a_5], and Mocha selects the interval [2,5], then the new array is [a_1,a_2 \\\\&  a_5, a_3 \\\\&  a_4, a_4 \\\\&  a_3, a_5 \\\\&  a_2].\\n\\nNow Mocha wants to minimize the maximum value in the sequence. As her best friend, can you help her to get the answer?\\n\\nInput\\n\\nEach test contains multiple test cases. \\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 100) \u2014 the number of test cases. Each test case consists of two lines.\\n\\nThe first line of each test case contains a single integer n (1 \u2264 n \u2264 100) \u2014 the length of the sequence.\\n\\nThe second line of each test case contains n integers a_1, a_2, \u2026, a_n (0 \u2264 a_i \u2264 10^9).\\n\\nOutput\\n\\nFor each test case, print one integer \u2014 the minimal value of the maximum value in the sequence.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n2\\n1 2\\n3\\n1 1 3\\n4\\n3 11 3 7\\n5\\n11 7 15 3 7\\n\\n\\nOutput\\n\\n\\n0\\n1\\n3\\n3\\n\\nNote\\n\\nIn the first test case, Mocha can choose the interval [1,2], then the sequence becomes [ 0, 0], where the first element is 1 \\\\& 2, and the second element is 2 \\\\& 1.\\n\\nIn the second test case, Mocha can choose the interval [1,3], then the sequence becomes [ 1,1,1], where the first element is 1 \\\\& 3, the second element is 1 \\\\& 1, and the third element is 3 \\\\& 1.\",\"targets\":\"#include <bits\\/stdc++.h>\\n#pragma GCC optimize(\\\"Ofast\\\")\\nusing namespace std;\\nvoid solve() {\\n  long long int n;\\n  cin >> n;\\n  int i;\\n  vector<long long int> a(n);\\n  for (i = 0; i < n; i++) cin >> a[i];\\n  int ans = 0;\\n  for (i = 31; i >= 0; i--) {\\n    int f = 0;\\n    for (int j = 0; j < n; j++) {\\n      if (((a[j] >> i) & 1) == 0) f = 1;\\n    }\\n    if (f == 0) ans = ans + pow(2, i);\\n  }\\n  cout << ans << \\\"\\\\n\\\";\\n}\\nint main() {\\n  ios_base::sync_with_stdio(false);\\n  cin.tie(NULL);\\n  int T;\\n  cin >> T;\\n  while (T--) solve();\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Casimir has a rectangular piece of paper with a checkered field of size n \u00d7 m. Initially, all cells of the field are white.\\n\\nLet us denote the cell with coordinates i vertically and j horizontally by (i, j). The upper left cell will be referred to as (1, 1) and the lower right cell as (n, m).\\n\\nCasimir draws ticks of different sizes on the field. A tick of size d (d > 0) with its center in cell (i, j) is drawn as follows: \\n\\n  1. First, the center cell (i, j) is painted black. \\n  2. Then exactly d cells on the top-left diagonally to the center and exactly d cells on the top-right diagonally to the center are also painted black. \\n  3. That is all the cells with coordinates (i - h, j \u00b1 h) for all h between 0 and d are painted. In particular, a tick consists of 2d + 1 black cells. \\n\\n\\n\\nAn already painted cell will remain black if painted again. Below you can find an example of the 4 \u00d7 9 box, with two ticks of sizes 2 and 3.\\n\\n<image>\\n\\nYou are given a description of a checkered field of size n \u00d7 m. Casimir claims that this field came about after he drew some (possibly 0) ticks on it. The ticks could be of different sizes, but the size of each tick is at least k (that is, d \u2265 k for all the ticks).\\n\\nDetermine whether this field can indeed be obtained by drawing some (possibly none) ticks of sizes d \u2265 k or not.\\n\\nInput\\n\\nThe first line contains an integer t (1 \u2264 t \u2264 100) \u2014 the number test cases.\\n\\nThe following lines contain the descriptions of the test cases. \\n\\nThe first line of the test case description contains the integers n, m, and k (1 \u2264 k \u2264 n \u2264 10; 1 \u2264 m \u2264 19) \u2014 the field size and the minimum size of the ticks that Casimir drew. The following n lines describe the field: each line consists of m characters either being '.' if the corresponding cell is not yet painted or '*' otherwise.\\n\\nOutput\\n\\nPrint t lines, each line containing the answer to the corresponding test case. The answer to a test case should be YES if the given field can be obtained by drawing ticks of at least the given size and NO otherwise.\\n\\nYou may...\\nSolve the task in PYTHON3.\",\"targets\":\"# cook your dish here\\nimport sys\\ninput = sys.stdin.readline\\nt=int(input())\\nfor _ in range(t):\\n    n,m,k=map(int,input().split())\\n    g=[]\\n    visited=[]\\n    for i in range(n):\\n        g.append(input())\\n        visited.append([0]*m)\\n    c=[]\\n    for i in range(n):\\n        for j in range(m):\\n            if g[i][j]=='*':\\n                if i-1>=0 and j+1<m and j-1>=0 and g[i-1][j+1]=='*' and g[i-1][j-1]=='*':\\n                    c.append([i,j])\\n    # print(c)\\n    f=0\\n    for i in range(len(c)):\\n        x,y=c[i]\\n        x1,y1,x2,y2=x,y,x,y\\n        l1=0\\n        while x1>=0 and y1>=0 and g[x1][y1]=='*':\\n            l1+=1\\n            x1-=1\\n            y1-=1\\n        l2=0\\n        while x2>=0 and y2<m and g[x2][y2]=='*':\\n            l2+=1\\n            x2-=1\\n            y2+=1\\n        d=min(l1-1,l2-1)\\n        if d>=k:\\n            x1,y1,x2,y2=x,y,x,y\\n            l1=0\\n            while x1>=0 and y1>=0 and g[x1][y1]=='*':\\n                visited[x1][y1]=1\\n                l1+=1\\n                x1-=1\\n                y1-=1\\n                if l1==d+1:\\n                    break\\n            l2=0\\n            while x2>=0 and y2<m and g[x2][y2]=='*':\\n                visited[x2][y2]=1\\n                l2+=1\\n                x2-=1\\n                y2+=1\\n                if l2==d+1:\\n                    break\\n    for i in range(n):\\n        for j in range(m):\\n            if g[i][j]=='*' and visited[i][j]==0:\\n                f=1\\n                break\\n        if f:\\n            break\\n    if f:\\n        print(\\\"NO\\\")\\n    else:\\n        print(\\\"YES\\\")\",\"language\":\"python\",\"split\":\"test\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"The robot is located on a checkered rectangular board of size n \u00d7 m (n rows, m columns). The rows in the board are numbered from 1 to n from top to bottom, and the columns \u2014 from 1 to m from left to right.\\n\\nThe robot is able to move from the current cell to one of the four cells adjacent by side.\\n\\nThe sequence of commands s executed by the robot is given. Each command is denoted by one of the symbols 'L', 'R', 'D' or 'U', and triggers the movement to left, right, down or up, respectively.\\n\\nThe robot can start its movement in any cell. The robot executes the commands starting from the first one, strictly in the order in which they are listed in s. If the robot moves beyond the edge of the board, it falls and breaks. A command that causes the robot to break is not considered successfully executed.\\n\\nThe robot's task is to execute as many commands as possible without falling off the board. For example, on board 3 \u00d7 3, if the robot starts a sequence of actions s=\\\"RRDLUU\\\" (\\\"right\\\", \\\"right\\\", \\\"down\\\", \\\"left\\\", \\\"up\\\", \\\"up\\\") from the central cell, the robot will perform one command, then the next command will force him to cross the edge. If the robot starts moving from the cell (2, 1) (second row, first column) then all commands will be executed successfully and the robot will stop at the cell (1, 2) (first row, second column).\\n\\n<image> The robot starts from cell (2, 1) (second row, first column). It moves right, right, down, left, up, and up. In this case it ends in the cell (1, 2) (first row, second column).\\n\\nDetermine the cell from which the robot should start its movement in order to execute as many commands as possible.\\n\\nInput\\n\\nThe first line contains an integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases.\\n\\nThe next 2t lines contain descriptions of the test cases.\\n\\nIn the description of each test case, the first line contains two integers n and m (1 \u2264 n, m \u2264 10^6) \u2014 the height and width of the field that the robot is located on. The second line of the description is a string s consisting solely of characters 'L',...\\nimpor\",\"targets\":\"t java.io.*;\\nimport java.util.*;\\n\\npublic class E {\\n\\t\\n\\tpublic static void main(String[] args)throws IOException {\\n\\t\\n\\t\\tFastScanner scan = new FastScanner();\\n\\t\\tPrintWriter output = new PrintWriter(System.out);\\n\\t\\tint t = scan.nextInt();\\n\\t\\tfor(int tt = 0;tt<t;tt++) {\\n\\t\\t\\tint n = scan.nextInt(), m = scan.nextInt();\\n\\t\\t\\tchar arr[] = scan.next().toCharArray();\\n\\t\\t\\tint len = arr.length;\\n\\t\\t\\tint hori = 0, vert = 0;\\n\\t\\t\\tint lmax = 0, rmax = 0, umax = 0, dmax = 0;\\n\\t\\t\\tfor(int i = 0;i<len;i++) {\\n\\t\\t\\t\\tif(arr[i] == 'R') hori++;\\n\\t\\t\\t\\telse if(arr[i] == 'L') hori--;\\n\\t\\t\\t\\telse if(arr[i] == 'U') vert++;\\n\\t\\t\\t\\telse if(arr[i] == 'D') vert--;\\n\\n\\t\\t\\t\\tint tlmax = Math.max(lmax, -hori);\\n\\t\\t\\t\\tint trmax = Math.max(rmax, hori);\\n\\t\\t\\t\\tint tdmax = Math.max(dmax, -vert);\\n\\t\\t\\t\\tint tumax = Math.max(umax, vert);\\n\\t\\t\\t\\tif((tlmax+trmax) >= m || (tumax+tdmax) >= n) break;\\n\\t\\t\\t\\tlmax = tlmax;\\n\\t\\t\\t\\trmax = trmax;\\n\\t\\t\\t\\tumax = tumax;\\n\\t\\t\\t\\tdmax = tdmax;\\n\\t\\t\\t\\t\\n\\t\\t\\t}\\n\\/\\/\\t\\t\\tSystem.out.println(\\\"l r u d \\\" + lmax + \\\" \\\" + rmax + \\\" \\\" + umax + \\\" \\\" + dmax);\\n\\t\\t\\tint x, y;\\n\\t\\t\\tif(lmax >= rmax) y = lmax+1;\\n\\t\\t\\telse y = m-rmax;\\n\\t\\t\\tif(umax >= dmax) x = umax+1;\\n\\t\\t\\telse x = n-dmax;\\n\\t\\t\\toutput.println(x + \\\" \\\" + y);\\n\\t\\t}\\n\\t\\toutput.flush();\\n\\n\\t}\\n\\t\\n\\tpublic static int[] sort(int arr[]) {\\n\\t\\tList<Integer> list = new ArrayList<>();\\n\\t\\tfor(int i:arr) list.add(i);\\n\\t\\tCollections.sort(list);\\n\\t\\tfor(int i = 0;i<list.size();i++) arr[i] = list.get(i);\\n\\t\\treturn arr;\\n\\t}\\n\\t\\n\\tpublic static int gcd(int a, int b) {\\n\\t\\tif(a == 0) return b;\\n\\t\\treturn gcd(b%a, a);\\n\\t}\\n\\t\\n\\tstatic boolean isPrime(int n) {\\n        if (n <= 1) return false;\\n        else if (n == 2) return true;\\n        else if (n % 2 == 0) return false;\\n        for (int i = 3; i <= Math.sqrt(n); i += 2) if (n % i == 0) return false;\\n        return true;\\n    }\\n\\t\\n\\tpublic static void printArray(int arr[]) {\\n\\t\\tfor(int i:arr) System.out.print(i+\\\" \\\");\\n\\t\\tSystem.out.println();\\n\\t}\\n\\t\\n\\tstatic class FastScanner {\\n\\t\\tBufferedReader br=new BufferedReader(new InputStreamReader(System.in));\\n\\t\\tStringTokenizer st=new StringTokenizer(\\\"\\\");\\n\\t\\tString next() {\\n\\t\\t\\twhile...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Gregor is learning about RSA cryptography, and although he doesn't understand how RSA works, he is now fascinated with prime numbers and factoring them.\\n\\nGregor's favorite prime number is P. Gregor wants to find two bases of P. Formally, Gregor is looking for two integers a and b which satisfy both of the following properties.\\n\\n  * P mod a = P mod b, where x mod y denotes the remainder when x is divided by y, and \\n  * 2 \u2264 a < b \u2264 P. \\n\\n\\n\\nHelp Gregor find two bases of his favorite prime number!\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 1000).\\n\\nEach subsequent line contains the integer P (5 \u2264 P \u2264 {10}^9), with P guaranteed to be prime.\\n\\nOutput\\n\\nYour output should consist of t lines. Each line should consist of two integers a and b (2 \u2264 a < b \u2264 P). If there are multiple possible solutions, print any.\\n\\nExample\\n\\nInput\\n\\n\\n2\\n17\\n5\\n\\n\\nOutput\\n\\n\\n3 5\\n2 4\\n\\nNote\\n\\nThe first query is P=17. a=3 and b=5 are valid bases in this case, because 17 mod 3 = 17 mod 5 = 2. There are other pairs which work as well.\\n\\nIn the second query, with P=5, the only solution is a=2 and b=4.\\nUsing python3 can you solve the prior task?\",\"targets\":\"def fun(n):\\n    print(2,n-1)\\n\\nT = int(input())\\n# T=1\\nfor i in range(T):\\n    n=int(input())\\n    # ks= list(map(int, input().split()))  \\n    # ls= list(map(int, input().split()))   \\n    # print(ls) \\n    # st=input()\\n    # ts=input()\\n    # ls= list(map(int, input().split()))\\n    fun(n)\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"A new cottage village called \u00abFlatville\u00bb is being built in Flatland. By now they have already built in \u00abFlatville\u00bb n square houses with the centres on the \u041ex-axis. The houses' sides are parallel to the coordinate axes. It's known that no two houses overlap, but they can touch each other.\\n\\nThe architect bureau, where Peter works, was commissioned to build a new house in \u00abFlatville\u00bb. The customer wants his future house to be on the \u041ex-axis, to be square in shape, have a side t, and touch at least one of the already built houses. For sure, its sides should be parallel to the coordinate axes, its centre should be on the Ox-axis and it shouldn't overlap any of the houses in the village.\\n\\nPeter was given a list of all the houses in \u00abFlatville\u00bb. Would you help him find the amount of possible positions of the new house?\\n\\nInput\\n\\nThe first line of the input data contains numbers n and t (1 \u2264 n, t \u2264 1000). Then there follow n lines, each of them contains two space-separated integer numbers: xi ai, where xi \u2014 x-coordinate of the centre of the i-th house, and ai \u2014 length of its side ( - 1000 \u2264 xi \u2264 1000, 1 \u2264 ai \u2264 1000).\\n\\nOutput\\n\\nOutput the amount of possible positions of the new house.\\n\\nExamples\\n\\nInput\\n\\n2 2\\n0 4\\n6 2\\n\\n\\nOutput\\n\\n4\\n\\n\\nInput\\n\\n2 2\\n0 4\\n5 2\\n\\n\\nOutput\\n\\n3\\n\\n\\nInput\\n\\n2 3\\n0 4\\n5 2\\n\\n\\nOutput\\n\\n2\\n\\nNote\\n\\nIt is possible for the x-coordinate of the new house to have non-integer value.\\nimpor\",\"targets\":\"t java.util.*;\\n\\npublic class Solution {\\n    public static void main(String[] args) {\\n        Scanner s = new Scanner(System.in);\\n\\n        int n = s.nextInt();\\n        int t = s.nextInt();\\n\\n        int[][] intv = new int[n][2];\\n\\n        for (int i = 0; i < n; i++) {\\n            intv[i][0] = s.nextInt();\\n            intv[i][1] = s.nextInt();\\n        }\\n\\n        Arrays.sort(intv, (a,b) -> a[0] - b[0]);\\n\\n        int res = 2; \\/\\/ leftmost and rightmost pos\\n\\n        for (int i = 1; i < n; i++) {\\n            \\/\\/ compare gap from current start pt - previous end pt\\n            if (intv[i][0] - (double) intv[i][1] \\/ 2 - (intv[i - 1][0] + (double) intv[i - 1][1] \\/ 2) == t)\\n                res++;\\n            else if (intv[i][0] - (double) intv[i][1] \\/ 2 - (intv[i - 1][0] + (double) intv[i - 1][1] \\/ 2) > t)\\n                res += 2; \\n        }\\n\\n        System.out.println(res);\\n\\n        s.close();\\n    }\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in CPP?\\nThe problem statement looms below, filling you with determination.\\n\\nConsider a grid in which some cells are empty and some cells are filled. Call a cell in this grid exitable if, starting at that cell, you can exit the grid by moving up and left through only empty cells. This includes the cell itself, so all filled in cells are not exitable. Note that you can exit the grid from any leftmost empty cell (cell in the first column) by going left, and from any topmost empty cell (cell in the first row) by going up.\\n\\nLet's call a grid determinable if, given only which cells are exitable, we can exactly determine which cells are filled in and which aren't.\\n\\nYou are given a grid a of dimensions n \u00d7 m , i. e. a grid with n rows and m columns. You need to answer q queries (1 \u2264 q \u2264 2 \u22c5 10^5). Each query gives two integers x_1, x_2 (1 \u2264 x_1 \u2264 x_2 \u2264 m) and asks whether the subgrid of a consisting of the columns x_1, x_1 + 1, \u2026, x_2 - 1, x_2 is determinable.\\n\\nInput\\n\\nThe first line contains two integers n, m (1 \u2264 n, m \u2264 10^6, nm \u2264 10^6) \u2014 the dimensions of the grid a.\\n\\nn lines follow. The y-th line contains m characters, the x-th of which is 'X' if the cell on the intersection of the the y-th row and x-th column is filled and \\\".\\\" if it is empty.\\n\\nThe next line contains a single integer q (1 \u2264 q \u2264 2 \u22c5 10^5) \u2014 the number of queries.\\n\\nq lines follow. Each line contains two integers x_1 and x_2 (1 \u2264 x_1 \u2264 x_2 \u2264 m), representing a query asking whether the subgrid of a containing the columns x_1, x_1 + 1, \u2026, x_2 - 1, x_2 is determinable.\\n\\nOutput\\n\\nFor each query, output one line containing \\\"YES\\\" if the subgrid specified by the query is determinable and \\\"NO\\\" otherwise. The output is case insensitive (so \\\"yEs\\\" and \\\"No\\\" will also be accepted).\\n\\nExample\\n\\nInput\\n\\n\\n4 5\\n..XXX\\n...X.\\n...X.\\n...X.\\n5\\n1 3\\n3 3\\n4 5\\n5 5\\n1 5\\n\\n\\nOutput\\n\\n\\nYES\\nYES\\nNO\\nYES\\nNO\\n\\nNote\\n\\nFor each query of the example, the corresponding subgrid is displayed twice below: first in its input format, then with each cell marked as \\\"E\\\" if it is exitable and \\\"N\\\" otherwise.\\n\\nFor the...\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint main() {\\n  ios::sync_with_stdio(false);\\n  cin.tie(0);\\n  int n, m;\\n  cin >> n >> m;\\n  vector<string> a(n);\\n  for (int i = 0; i < n; i++) {\\n    cin >> a[i];\\n  }\\n  vector<vector<int>> s(n - 1, vector<int>(m - 1));\\n  for (int i = 0; i < n - 1; i++) {\\n    for (int j = 0; j < m - 1; j++) {\\n      s[i][j] = (a[i + 1][j] == 'X' && a[i][j + 1] == 'X') +\\n                (i ? s[i - 1][j] : 0) + (j ? s[i][j - 1] : 0) -\\n                (i && j ? s[i - 1][j - 1] : 0);\\n    }\\n  }\\n  auto sum = [&](int c, int cc) {\\n    return (n - 2 >= 0\\n                ? ((cc ? s[n - 2][cc - 1] : 0) - (c ? s[n - 2][c - 1] : 0))\\n                : 0);\\n  };\\n  int q;\\n  cin >> q;\\n  while (q--) {\\n    int c, cc;\\n    cin >> c >> cc;\\n    --c;\\n    --cc;\\n    cout << (sum(c, cc) > 0 ? \\\"NO\\\" : \\\"YES\\\") << '\\\\n';\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Absent-minded Masha got set of n cubes for her birthday.\\n\\nAt each of 6 faces of each cube, there is exactly one digit from 0 to 9. Masha became interested what is the largest natural x such she can make using her new cubes all integers from 1 to x.\\n\\nTo make a number Masha can rotate her cubes and put them in a row. After that, she looks at upper faces of cubes from left to right and reads the number.\\n\\nThe number can't contain leading zeros. It's not required to use all cubes to build a number.\\n\\nPay attention: Masha can't make digit 6 from digit 9 and vice-versa using cube rotations.\\n\\nInput\\n\\nIn first line integer n is given (1 \u2264 n \u2264 3) \u2014 the number of cubes, Masha got for her birthday.\\n\\nEach of next n lines contains 6 integers aij (0 \u2264 aij \u2264 9) \u2014 number on j-th face of i-th cube.\\n\\nOutput\\n\\nPrint single integer \u2014 maximum number x such Masha can make any integers from 1 to x using her cubes or 0 if Masha can't make even 1.\\n\\nExamples\\n\\nInput\\n\\n3\\n0 1 2 3 4 5\\n6 7 8 9 0 1\\n2 3 4 5 6 7\\n\\n\\nOutput\\n\\n87\\n\\nInput\\n\\n3\\n0 1 3 5 6 8\\n1 2 4 5 7 8\\n2 3 4 6 7 9\\n\\n\\nOutput\\n\\n98\\n\\nNote\\n\\nIn the first test case, Masha can build all numbers from 1 to 87, but she can't make 88 because there are no two cubes with digit 8.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint main() {\\n  int n, a;\\n  cin >> n;\\n  int f = 0;\\n  vector<vector<int> > A(4, vector<int>(10, 0));\\n  for (int i = 0; i < n; i++) {\\n    f = 0;\\n    for (int j = 0; j < 6; j++) {\\n      cin >> a;\\n      A[i][a] = 1;\\n    }\\n  }\\n  int maxi = 0, x, g = 0;\\n  vector<int> B, C(3, 0);\\n  int z = pow(10, n);\\n  for (int i = 1; i < z; i++) {\\n    x = i;\\n    B.clear();\\n    while (x > 0) {\\n      B.push_back(x % 10);\\n      x \\/= 10;\\n    }\\n    f = 0;\\n    g = 0;\\n    for (int k = 0; k < 3; k++) {\\n      C[0] = k;\\n      for (int j = 0; j < 3; j++) {\\n        C[1] = j;\\n        for (int l = 0; l < 3; l++) {\\n          C[2] = l;\\n          if (k != j && k != l && j != l) {\\n            g = 1;\\n            for (int m = 0; m < B.size(); m++) {\\n              if (A[C[m]][B[m]] == 0) {\\n                g = 0;\\n                break;\\n              }\\n            }\\n            if (g == 1) {\\n              f = 1;\\n              break;\\n            }\\n          }\\n        }\\n      }\\n    }\\n    if (f == 0) {\\n      break;\\n    } else {\\n      maxi = i;\\n    }\\n  }\\n  cout << maxi << endl;\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You are given an array a[0 \u2026 n - 1] = [a_0, a_1, \u2026, a_{n - 1}] of zeroes and ones only. Note that in this problem, unlike the others, the array indexes are numbered from zero, not from one.\\n\\nIn one step, the array a is replaced by another array of length n according to the following rules: \\n\\n  1. First, a new array a^{\u2192 d} is defined as a cyclic shift of the array a to the right by d cells. The elements of this array can be defined as a^{\u2192 d}_i = a_{(i + n - d) mod n}, where (i + n - d) mod n is the remainder of integer division of i + n - d by n. \\n\\nIt means that the whole array a^{\u2192 d} can be represented as a sequence $$$a^{\u2192 d} = [a_{n - d}, a_{n - d + 1}, \u2026, a_{n - 1}, a_0, a_1, \u2026, a_{n - d - 1}]$$$\\n\\n  2. Then each element of the array a_i is replaced by a_i  \\\\&  a^{\u2192 d}_i, where \\\\& is a logical \\\"AND\\\" operator. \\n\\n\\n\\nFor example, if a = [0, 0, 1, 1] and d = 1, then a^{\u2192 d} = [1, 0, 0, 1] and the value of a after the first step will be [0  \\\\&  1, 0  \\\\&  0, 1  \\\\&  0, 1  \\\\&  1], that is [0, 0, 0, 1].\\n\\nThe process ends when the array stops changing. For a given array a, determine whether it will consist of only zeros at the end of the process. If yes, also find the number of steps the process will take before it finishes.\\n\\nInput\\n\\nThe first line contains an integer t (1 \u2264 t \u2264 1000) \u2014 the number of test cases.\\n\\nThe next 2t lines contain descriptions of the test cases. \\n\\nThe first line of each test case description contains two integers: n (1 \u2264 n \u2264 10^6) \u2014 array size and d (1 \u2264 d \u2264 n) \u2014 cyclic shift offset. The second line of the description contains n space-separated integers a_i (0 \u2264 a_i \u2264 1) \u2014 elements of the array.\\n\\nIt is guaranteed that the sum of n over all test cases does not exceed 10^6.\\n\\nOutput\\n\\nPrint t lines, each line containing the answer to the corresponding test case. The answer to a test case should be a single integer \u2014 the number of steps after which the array will contain only zeros for the first time. If there are still elements equal to 1 in the array after the end of the process, print...\\nSolve the task in JAVA.\",\"targets\":\"import java.io.BufferedReader;\\nimport java.io.IOException;\\nimport java.io.InputStreamReader;\\nimport java.io.PrintWriter;\\nimport java.util.StringTokenizer;\\n\\npublic class F {\\n    static int[] dp;\\n\\n    static int solve(int i,int n,int d,int[] a,boolean[] vis){\\n        if(a[i]==0){\\n            return 0;\\n        }\\n        if(dp[i]!=0){\\n            return dp[i];\\n        }\\n        if(vis[i]){\\n            return -1;\\n        }\\n        vis[i]=true;\\n        int next=(i+n-d)%n;\\n        int ans=0;\\n        int val=solve(next,n,d,a,vis);\\n        if(val==-1){\\n            ans=val;\\n        } else {\\n            ans=1+val;\\n        }\\n        return dp[i]=ans;\\n    }\\n\\n    public static void main(String[] args)\\n    {\\n        FastScanner sc=new FastScanner();\\n        int t=sc.nextInt();\\n        PrintWriter pw=new PrintWriter(System.out);\\n        while(t-->0) {\\n            int n=sc.nextInt();\\n            int d=sc.nextInt();\\n            int[] a=sc.readArray(n);\\n            dp=new int[n+1];\\n            boolean[] vis=new boolean[n+1];\\n            boolean ok=true;\\n            for(int i=0;i<n;i++){\\n                if(a[i]==1){\\n                    int next=solve(i,n,d,a,vis);\\n                    if(next==-1){\\n                        ok=false;\\n                        break;\\n                    }\\n                }\\n            }\\n            if(!ok){\\n                pw.println(-1);\\n            } else {\\n                int ans=0;\\n                for(int x:dp){\\n                    ans=Math.max(ans,x);\\n                }\\n                pw.println(ans);\\n            }\\n\\n\\n        }\\n        pw.flush();\\n    }\\n\\n    static class FastScanner {\\n        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));\\n        StringTokenizer st=new StringTokenizer(\\\"\\\");\\n        String next() {\\n            while (!st.hasMoreTokens())\\n                try {\\n                    st=new StringTokenizer(br.readLine());\\n                } catch (IOException e) {\\n                    e.printStackTrace();\\n                }\\n            return st.nextToken();\\n       ...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Fedya studies in a gymnasium. Fedya's maths hometask is to calculate the following expression:\\n\\n(1n + 2n + 3n + 4n) mod 5\\n\\nfor given value of n. Fedya managed to complete the task. Can you? Note that given number n can be extremely large (e.g. it can exceed any integer type of your programming language).\\n\\nInput\\n\\nThe single line contains a single integer n (0 \u2264 n \u2264 10105). The number doesn't contain any leading zeroes.\\n\\nOutput\\n\\nPrint the value of the expression without leading zeros.\\n\\nExamples\\n\\nInput\\n\\n4\\n\\n\\nOutput\\n\\n4\\n\\n\\nInput\\n\\n124356983594583453458888889\\n\\n\\nOutput\\n\\n0\\n\\nNote\\n\\nOperation x mod y means taking remainder after division x by y.\\n\\nNote to the first sample:\\n\\n<image>\\nSolve the task in PYTHON.\",\"targets\":\"n=long(raw_input())\\nn=n%4\\nprint ((1**n)%5+(2**n)%5+(3**n)%5+(4**n)%5)%5\",\"language\":\"python\",\"split\":\"train\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Grandma Capa has decided to knit a scarf and asked Grandpa Sher to make a pattern for it, a pattern is a string consisting of lowercase English letters. Grandpa Sher wrote a string s of length n.\\n\\nGrandma Capa wants to knit a beautiful scarf, and in her opinion, a beautiful scarf can only be knit from a string that is a palindrome. She wants to change the pattern written by Grandpa Sher, but to avoid offending him, she will choose one lowercase English letter and erase some (at her choice, possibly none or all) occurrences of that letter in string s.\\n\\nShe also wants to minimize the number of erased symbols from the pattern. Please help her and find the minimum number of symbols she can erase to make string s a palindrome, or tell her that it's impossible. Notice that she can only erase symbols equal to the one letter she chose.\\n\\nA string is a palindrome if it is the same from the left to the right and from the right to the left. For example, the strings 'kek', 'abacaba', 'r' and 'papicipap' are palindromes, while the strings 'abb' and 'iq' are not.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 100) \u2014 the number of test cases. The next 2 \u22c5 t lines contain the description of test cases. The description of each test case consists of two lines.\\n\\nThe first line of each test case contains a single integer n (1 \u2264 n \u2264 10^5) \u2014 the length of the string.\\n\\nThe second line of each test case contains the string s consisting of n lowercase English letters.\\n\\nIt is guaranteed that the sum of n over all test cases does not exceed 2 \u22c5 10^5.\\n\\nOutput\\n\\nFor each test case print the minimum number of erased symbols required to make the string a palindrome, if it is possible, and -1, if it is impossible.\\n\\nExample\\n\\nInput\\n\\n\\n5\\n8\\nabcaacab\\n6\\nxyzxyz\\n4\\nabba\\n8\\nrprarlap\\n10\\nkhyyhhyhky\\n\\n\\nOutput\\n\\n\\n2\\n-1\\n0\\n3\\n2\\n\\nNote\\n\\nIn the first test case, you can choose a letter 'a' and erase its first and last occurrences, you will get a string 'bcaacb', which is a palindrome. You can also choose a letter 'b' and erase all its occurrences, you...\\nSolve the task in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nlong long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }\\nlong long lg(long long x) { return __builtin_clzll(1ll) - __builtin_clzll(x); }\\nlong long vlg(long long x) { return 1ll << lg(x); }\\nvoid google() {\\n  static long long _gtest_ = 1;\\n  cout << \\\"Case #\\\" << _gtest_++ << \\\": \\\";\\n}\\nconst long long mod = 1e9 + 7;\\nvoid solve() {\\n  long long n;\\n  cin >> n;\\n  string s;\\n  cin >> s;\\n  long long ans = n + 5;\\n  for (char c = 'a'; c <= 'z'; c++) {\\n    long long cnt = 0;\\n    vector<long long> v;\\n    string s2;\\n    for (long long i = 0; i < n; i++) {\\n      if (s[i] != c) {\\n        s2 += s[i];\\n        v.push_back(cnt);\\n        cnt = 0;\\n      } else\\n        cnt++;\\n    }\\n    v.push_back(cnt);\\n    string s3 = s2;\\n    reverse((s3).begin(), (s3).end());\\n    if (s3 == s2) {\\n      long long cnt = (long long)((s2).size());\\n      long long m = (long long)((v).size());\\n      for (long long i = 0; i < m \\/ 2; i++) {\\n        cnt += 2 * min(v[i], v[m - i - 1]);\\n      }\\n      if (m % 2) {\\n        cnt += v[m \\/ 2];\\n      }\\n      ans = min(ans, n - cnt);\\n    }\\n  }\\n  if (ans == n + 5) ans = -1;\\n  cout << ans << '\\\\n';\\n}\\nsigned main() {\\n  ios_base::sync_with_stdio(false);\\n  cin.tie(0);\\n  cout.tie(0);\\n  long long t = 1;\\n  cin >> t;\\n  while (t--) solve();\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"Dreamoon likes sequences very much. So he created a problem about the sequence that you can't find in OEIS: \\n\\nYou are given two integers d, m, find the number of arrays a, satisfying the following constraints:\\n\\n  * The length of a is n, n \u2265 1 \\n  * 1 \u2264 a_1 < a_2 < ... < a_n \u2264 d \\n  * Define an array b of length n as follows: b_1 = a_1, \u2200 i > 1, b_i = b_{i - 1} \u2295 a_i, where \u2295 is the bitwise exclusive-or (xor). After constructing an array b, the constraint b_1 < b_2 < ... < b_{n - 1} < b_n should hold. \\n\\n\\n\\nSince the number of possible arrays may be too large, you need to find the answer modulo m.\\n\\nInput\\n\\nThe first line contains an integer t (1 \u2264 t \u2264 100) denoting the number of test cases in the input.\\n\\nEach of the next t lines contains two integers d, m (1 \u2264 d, m \u2264 10^9).\\n\\nNote that m is not necessary the prime!\\n\\nOutput\\n\\nFor each test case, print the number of arrays a, satisfying all given constrains, modulo m.\\n\\nExample\\n\\nInput\\n\\n\\n10\\n1 1000000000\\n2 999999999\\n3 99999998\\n4 9999997\\n5 999996\\n6 99995\\n7 9994\\n8 993\\n9 92\\n10 1\\n\\n\\nOutput\\n\\n\\n1\\n3\\n5\\n11\\n17\\n23\\n29\\n59\\n89\\n0\\\":\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nlong long n, mod, t;\\nint main() {\\n  scanf(\\\"%lld\\\", &t);\\n  while (t--) {\\n    scanf(\\\"%lld%lld\\\", &n, &mod);\\n    long long ans = 1 % mod, x = 1;\\n    while (x <= n) {\\n      ans = (ans * (min(x, n - x + 1) + 1)) % mod;\\n      x <<= 1;\\n    }\\n    ans--;\\n    ans %= mod;\\n    while (ans < 0) ans += mod;\\n    printf(\\\"%lld\\\\n\\\", ans);\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"A company has n employees numbered from 1 to n. Each employee either has no immediate manager or exactly one immediate manager, who is another employee with a different number. An employee A is said to be the superior of another employee B if at least one of the following is true:\\n\\n  * Employee A is the immediate manager of employee B\\n  * Employee B has an immediate manager employee C such that employee A is the superior of employee C. \\n\\n\\n\\nThe company will not have a managerial cycle. That is, there will not exist an employee who is the superior of his\\/her own immediate manager.\\n\\nToday the company is going to arrange a party. This involves dividing all n employees into several groups: every employee must belong to exactly one group. Furthermore, within any single group, there must not be two employees A and B such that A is the superior of B.\\n\\nWhat is the minimum number of groups that must be formed?\\n\\nInput\\n\\nThe first line contains integer n (1 \u2264 n \u2264 2000) \u2014 the number of employees.\\n\\nThe next n lines contain the integers pi (1 \u2264 pi \u2264 n or pi = -1). Every pi denotes the immediate manager for the i-th employee. If pi is -1, that means that the i-th employee does not have an immediate manager. \\n\\nIt is guaranteed, that no employee will be the immediate manager of him\\/herself (pi \u2260 i). Also, there will be no managerial cycles.\\n\\nOutput\\n\\nPrint a single integer denoting the minimum number of groups that will be formed in the party.\\n\\nExamples\\n\\nInput\\n\\n5\\n-1\\n1\\n2\\n1\\n-1\\n\\n\\nOutput\\n\\n3\\n\\nNote\\n\\nFor the first example, three groups are sufficient, for example: \\n\\n  * Employee 1 \\n  * Employees 2 and 4 \\n  * Employees 3 and 5 \\nSolve the task in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nvector<int> v[2001];\\nint visited[2001];\\nint a[2001];\\nint j = 0;\\nvoid dfs(int i, int& maxcount, int count) {\\n  visited[i] = 1;\\n  count++;\\n  for (int k = 0; k < v[i].size(); k++) {\\n    if (v[i][k] != -1 && !visited[v[i][k]]) {\\n      if (count > maxcount) {\\n        maxcount = count;\\n        a[j] = maxcount;\\n      }\\n      dfs(v[i][k], maxcount, count);\\n    }\\n  }\\n}\\nint main() {\\n  int n, i, p;\\n  cin >> n;\\n  for (i = 0; i < n; i++) {\\n    cin >> p;\\n    if (p != -1) {\\n      v[i].push_back(p - 1);\\n      v[p - 1].push_back(i);\\n    } else if (p == -1) {\\n      v[i].push_back(-1);\\n    }\\n  }\\n  int maxcount;\\n  for (i = 0; i < n; i++) {\\n    maxcount = 0;\\n    if (find(v[i].begin(), v[i].end(), -1) != v[i].end()) {\\n      dfs(i, maxcount, 0);\\n      j++;\\n    }\\n  }\\n  cout << *max_element(a, a + n) + 1;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Let's define S(x) to be the sum of digits of number x written in decimal system. For example, S(5) = 5, S(10) = 1, S(322) = 7.\\n\\nWe will call an integer x interesting if S(x + 1) < S(x). In each test you will be given one integer n. Your task is to calculate the number of integers x such that 1 \u2264 x \u2264 n and x is interesting.\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 1000) \u2014 number of test cases.\\n\\nThen t lines follow, the i-th line contains one integer n (1 \u2264 n \u2264 10^9) for the i-th test case.\\n\\nOutput\\n\\nPrint t integers, the i-th should be the answer for the i-th test case.\\n\\nExample\\n\\nInput\\n\\n\\n5\\n1\\n9\\n10\\n34\\n880055535\\n\\n\\nOutput\\n\\n\\n0\\n1\\n1\\n3\\n88005553\\n\\nNote\\n\\nThe first interesting number is equal to 9.\\nUsing java can you solve the prior task?\",\"targets\":\"import java.util.Scanner;\\n\\npublic class ASkll {\\n    public static void main(String[] args) {\\n        Scanner obj =new Scanner(System.in);\\n          int t = obj.nextInt();\\n          while (t != 0)\\n          {\\n               int n= obj.nextInt();\\n                 n =n+1;\\n               int x = n\\/10;\\n               System.out.println(x);\\n\\n              t--;\\n\\n          }\\n    }\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"A robot cleaner is placed on the floor of a rectangle room, surrounded by walls. The floor consists of n rows and m columns. The rows of the floor are numbered from 1 to n from top to bottom, and columns of the floor are numbered from 1 to m from left to right. The cell on the intersection of the r-th row and the c-th column is denoted as (r,c). The initial position of the robot is (r_b, c_b).\\n\\nIn one second, the robot moves by dr rows and dc columns, that is, after one second, the robot moves from the cell (r, c) to (r + dr, c + dc). Initially dr = 1, dc = 1. If there is a vertical wall (the left or the right walls) in the movement direction, dc is reflected before the movement, so the new value of dc is -dc. And if there is a horizontal wall (the upper or lower walls), dr is reflected before the movement, so the new value of dr is -dr.\\n\\nEach second (including the moment before the robot starts moving), the robot cleans every cell lying in the same row or the same column as its position. There is only one dirty cell at (r_d, c_d). The job of the robot is to clean that dirty cell.\\n\\n<image> Illustration for the first example. The blue arc is the robot. The red star is the target dirty cell. Each second the robot cleans a row and a column, denoted by yellow stripes.\\n\\nGiven the floor size n and m, the robot's initial position (r_b, c_b) and the dirty cell's position (r_d, c_d), find the time for the robot to do its job.\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 10^4). Description of the test cases follows.\\n\\nA test case consists of only one line, containing six integers n, m, r_b, c_b, r_d, and c_d (1 \u2264 n, m \u2264 100, 1 \u2264 r_b, r_d \u2264 n, 1 \u2264 c_b, c_d \u2264 m) \u2014 the sizes of the room, the initial position of the robot and the position of the dirt cell.\\n\\nOutput\\n\\nFor each test case, print an integer \u2014 the time for the robot to clean the dirty cell. We can show that the robot always cleans the dirty cell eventually.\\n\\nExample\\n\\nInput\\n\\n\\n5\\n10 10 6 1 2 8\\n10 10 9 9 1...\\nSolve the task in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nvector<string> vec_splitter(string s) {\\n  s += ',';\\n  vector<string> res;\\n  while (!s.empty()) {\\n    res.push_back(s.substr(0, s.find(',')));\\n    s = s.substr(s.find(',') + 1);\\n  }\\n  return res;\\n}\\nvoid debug_out(vector<string> __attribute__((unused)) args,\\n               __attribute__((unused)) int idx,\\n               __attribute__((unused)) int LINE_NUM) {\\n  cerr << endl;\\n}\\ntemplate <typename Head, typename... Tail>\\nvoid debug_out(vector<string> args, int idx, int LINE_NUM, Head H, Tail... T) {\\n  if (idx > 0)\\n    cerr << \\\", \\\";\\n  else\\n    cerr << \\\"Line(\\\" << LINE_NUM << \\\") \\\";\\n  stringstream ss;\\n  ss << H;\\n  cerr << args[idx] << \\\" = \\\" << ss.str();\\n  debug_out(args, idx + 1, LINE_NUM, T...);\\n}\\ntemplate <class T>\\nbool ckmin(T& a, T& b) {\\n  bool r = a > b;\\n  a = min(a, b);\\n  return r;\\n}\\ntemplate <class T>\\nbool ckmax(T& a, T& b) {\\n  bool r = a < b;\\n  a = max(a, b);\\n  return r;\\n}\\nconst int MOD = 1e9 + 7;\\nconst long long INF = 1e18;\\nint main() {\\n  ios::sync_with_stdio(false);\\n  cin.tie(0);\\n  int t;\\n  cin >> t;\\n  while (t--) {\\n    int n, m, rb, cb, rd, cd;\\n    cin >> n >> m >> rb >> cb >> rd >> cd;\\n    int rowtm = 0;\\n    if (rb <= rd) {\\n      rowtm = rd - rb;\\n    } else {\\n      rowtm = n - rb + n - rd;\\n    }\\n    int coltm = 0;\\n    if (cb <= cd) {\\n      coltm = cd - cb;\\n    } else {\\n      coltm = m - cb + m - cd;\\n    }\\n    42;\\n    cout << min(rowtm, coltm) << '\\\\n';\\n    ;\\n  }\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"n people gathered to hold a jury meeting of the upcoming competition, the i-th member of the jury came up with a_i tasks, which they want to share with each other.\\n\\nFirst, the jury decides on the order which they will follow while describing the tasks. Let that be a permutation p of numbers from 1 to n (an array of size n where each integer from 1 to n occurs exactly once).\\n\\nThen the discussion goes as follows:\\n\\n  * If a jury member p_1 has some tasks left to tell, then they tell one task to others. Otherwise, they are skipped. \\n  * If a jury member p_2 has some tasks left to tell, then they tell one task to others. Otherwise, they are skipped. \\n  * ... \\n  * If a jury member p_n has some tasks left to tell, then they tell one task to others. Otherwise, they are skipped. \\n  * If there are still members with tasks left, then the process repeats from the start. Otherwise, the discussion ends. \\n\\n\\n\\nA permutation p is nice if none of the jury members tell two or more of their own tasks in a row. \\n\\nCount the number of nice permutations. The answer may be really large, so print it modulo 998 244 353.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases.\\n\\nThe first line of the test case contains a single integer n (2 \u2264 n \u2264 2 \u22c5 10^5) \u2014 number of jury members.\\n\\nThe second line contains n integers a_1, a_2, ..., a_n (1 \u2264 a_i \u2264 10^9) \u2014 the number of problems that the i-th member of the jury came up with.\\n\\nThe sum of n over all test cases does not exceed 2 \u22c5 10^5.\\n\\nOutput\\n\\nFor each test case, print one integer \u2014 the number of nice permutations, taken modulo 998 244 353.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n2\\n1 2\\n3\\n5 5 5\\n4\\n1 3 3 7\\n6\\n3 4 2 1 3 3\\n\\n\\nOutput\\n\\n\\n1\\n6\\n0\\n540\\n\\nNote\\n\\nExplanation of the first test case from the example:\\n\\nThere are two possible permutations, p = [1, 2] and p = [2, 1]. For p = [1, 2], the process is the following:\\n\\n  1. the first jury member tells a task; \\n  2. the second jury member tells a task; \\n  3. the first jury member doesn't have any tasks left to tell, so they are skipped;...\\nUsing cpp can you solve the prior task?\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nlong long f[200005];\\nint a[200005], n;\\nlong long getmod(long long x) {\\n  long long res = 1;\\n  int t = 998244353 - 2;\\n  for (; t; t \\/= 2, x = (x * x) % 998244353)\\n    if (t & 1) res = (res * x) % 998244353;\\n  return res;\\n}\\nlong long C(int k, int n) {\\n  long long res = f[n];\\n  res = (res * getmod(f[k])) % 998244353;\\n  res = (res * getmod(f[n - k])) % 998244353;\\n  return res;\\n}\\nvoid Solve() {\\n  cin >> n;\\n  for (int i = 1; i <= n; ++i) cin >> a[i];\\n  sort(a + 1, a + n + 1, greater<int>());\\n  if (a[1] == a[2]) {\\n    cout << f[n] << '\\\\n';\\n    return;\\n  }\\n  if (a[1] - a[2] > 1) {\\n    cout << 0 << '\\\\n';\\n    return;\\n  }\\n  int cnt = 0;\\n  for (int i = 2; i <= n; ++i)\\n    if (a[i] == a[2]) ++cnt;\\n  long long ans = 0;\\n  for (int i = 1; i < n; ++i) {\\n    if (cnt >= i)\\n      ans = (ans + f[n - 1]) % 998244353;\\n    else {\\n      ans = (ans + (f[n - 1] -\\n                    ((f[cnt] * C(cnt, i - 1) % 998244353) * f[n - cnt - 1] %\\n                     998244353) +\\n                    998244353)) %\\n            998244353;\\n    }\\n  }\\n  cout << ans << '\\\\n';\\n}\\nint main() {\\n  ios_base::sync_with_stdio(NULL);\\n  cin.tie(NULL);\\n  cout.tie(NULL);\\n  if (fopen(\\\"D:\\\\\\\\C++\\\\\\\\clion\\\\\\\\\\\"\\n            \\\".inp\\\",\\n            \\\"r\\\")) {\\n    freopen(\\n        \\\"D:\\\\\\\\C++\\\\\\\\clion\\\\\\\\\\\"\\n        \\\".inp\\\",\\n        \\\"r\\\", stdin);\\n    freopen(\\n        \\\"D:\\\\\\\\C++\\\\\\\\clion\\\\\\\\\\\"\\n        \\\".out\\\",\\n        \\\"w\\\", stdout);\\n  }\\n  f[0] = 1;\\n  for (int i = 1; i < 200005; ++i) f[i] = f[i - 1] * i % 998244353;\\n  int t;\\n  cin >> t;\\n  while (t--) {\\n    Solve();\\n  }\\n  cerr << \\\"Time collapse : \\\" << fixed << setprecision(3)\\n       << 1.000 * clock() \\/ CLOCKS_PER_SEC;\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Balph is learning to play a game called Buma. In this game, he is given a row of colored balls. He has to choose the color of one new ball and the place to insert it (between two balls, or to the left of all the balls, or to the right of all the balls).\\n\\nWhen the ball is inserted the following happens repeatedly: if some segment of balls of the same color became longer as a result of a previous action and its length became at least 3, then all the balls of this segment are eliminated. \\n\\nConsider, for example, a row of balls 'AAABBBWWBB'. Suppose Balph chooses a ball of color 'W' and the place to insert it after the sixth ball, i. e. to the left of the two 'W's. After Balph inserts this ball, the balls of color 'W' are eliminated, since this segment was made longer and has length 3 now, so the row becomes 'AAABBBBB'. The balls of color 'B' are eliminated now, because the segment of balls of color 'B' became longer and has length 5 now. Thus, the row becomes 'AAA'. However, none of the balls are eliminated now, because there is no elongated segment.\\n\\nHelp Balph count the number of possible ways to choose a color of a new ball and a place to insert it that leads to the elimination of all the balls.\\n\\nInput\\n\\nThe only line contains a non-empty string of uppercase English letters of length at most 3 \u22c5 10^5. Each letter represents a ball with the corresponding color.\\n\\nOutput\\n\\nOutput the number of ways to choose a color and a position of a new ball in order to eliminate all the balls.\\n\\nExamples\\n\\nInput\\n\\n\\nBBWWBB\\n\\n\\nOutput\\n\\n\\n3\\n\\n\\nInput\\n\\n\\nBWWB\\n\\n\\nOutput\\n\\n\\n0\\n\\n\\nInput\\n\\n\\nBBWBB\\n\\n\\nOutput\\n\\n\\n0\\n\\n\\nInput\\n\\n\\nOOOWWW\\n\\n\\nOutput\\n\\n\\n0\\n\\n\\nInput\\n\\n\\nWWWOOOOOOWWW\\n\\n\\nOutput\\n\\n\\n7\",\"targets\":\"import java.util.Scanner;\\n\\npublic class _1267B_ACM_Semifinal {\\n    public static void main(String args[]){\\n        Scanner in = new Scanner(System.in);\\n        String s = in.next();\\n        int n = s.length();\\n        int left = 0;\\n        int right = n - 1;\\n        int result = 0;\\n        while(true){\\n            char a = s.charAt(left);\\n            char b = s.charAt(right);\\n            int cleft = left;\\n            int cright = right;\\n            while(cleft < n && a == s.charAt(cleft)) cleft++;\\n            while(cright >= 0 && b == s.charAt(cright)) cright--;\\n            if(a != b || (cleft - left + right - cright < 3)) break;\\n            if(cleft > cright){\\n                if(cleft - left >= 2) result = cleft - left + 1;\\n                break;\\n            }\\n            left = cleft;\\n            right = cright;\\n        }\\n        System.out.println(result);\\n    }\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"A string s of length n, consisting of lowercase letters of the English alphabet, is given.\\n\\nYou must choose some number k between 0 and n. Then, you select k characters of s and permute them however you want. In this process, the positions of the other n-k characters remain unchanged. You have to perform this operation exactly once.\\n\\nFor example, if s=\\\"andrea\\\", you can choose the k=4 characters \\\"a_d_ea\\\" and permute them into \\\"d_e_aa\\\" so that after the operation the string becomes \\\"dneraa\\\".\\n\\nDetermine the minimum k so that it is possible to sort s alphabetically (that is, after the operation its characters appear in alphabetical order).\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 1000) \u2014 the number of test cases. Then t test cases follow.\\n\\nThe first line of each test case contains one integer n (1 \u2264 n \u2264 40) \u2014 the length of the string.\\n\\nThe second line of each test case contains the string s. It is guaranteed that s contains only lowercase letters of the English alphabet.\\n\\nOutput\\n\\nFor each test case, output the minimum k that allows you to obtain a string sorted alphabetically, through the operation described above.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n3\\nlol\\n10\\ncodeforces\\n5\\naaaaa\\n4\\ndcba\\n\\n\\nOutput\\n\\n\\n2\\n6\\n0\\n4\\n\\nNote\\n\\nIn the first test case, we can choose the k=2 characters \\\"_ol\\\" and rearrange them as \\\"_lo\\\" (so the resulting string is \\\"llo\\\"). It is not possible to sort the string choosing strictly less than 2 characters.\\n\\nIn the second test case, one possible way to sort s is to consider the k=6 characters \\\"_o__force_\\\" and rearrange them as \\\"_c__efoor_\\\" (so the resulting string is \\\"ccdeefoors\\\"). One can show that it is not possible to sort the string choosing strictly less than 6 characters.\\n\\nIn the third test case, string s is already sorted (so we can choose k=0 characters).\\n\\nIn the fourth test case, we can choose all k=4 characters \\\"dcba\\\" and reverse the whole string (so the resulting string is \\\"abcd\\\").\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst int MAXN = 45;\\nchar a[MAXN];\\nchar b[MAXN];\\nint main() {\\n  ios::sync_with_stdio(0);\\n  cin.tie(0);\\n  cout.tie(0);\\n  int t;\\n  cin >> t;\\n  while (t--) {\\n    int n;\\n    cin >> n;\\n    cin >> a;\\n    for (int i = 0; i < n; i++) b[i] = a[i];\\n    sort(b, b + n);\\n    int cnt = 0;\\n    for (int i = 0; i < n; i++) {\\n      if (a[i] != b[i]) cnt++;\\n    }\\n    cout << cnt << endl;\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You are given a matrix, consisting of n rows and m columns. The rows are numbered top to bottom, the columns are numbered left to right.\\n\\nEach cell of the matrix can be either free or locked.\\n\\nLet's call a path in the matrix a staircase if it: \\n\\n  * starts and ends in the free cell; \\n  * visits only free cells; \\n  * has one of the two following structures: \\n    1. the second cell is 1 to the right from the first one, the third cell is 1 to the bottom from the second one, the fourth cell is 1 to the right from the third one, and so on; \\n    2. the second cell is 1 to the bottom from the first one, the third cell is 1 to the right from the second one, the fourth cell is 1 to the bottom from the third one, and so on. \\n\\n\\n\\nIn particular, a path, consisting of a single cell, is considered to be a staircase.\\n\\nHere are some examples of staircases:\\n\\n<image>\\n\\nInitially all the cells of the matrix are free.\\n\\nYou have to process q queries, each of them flips the state of a single cell. So, if a cell is currently free, it makes it locked, and if a cell is currently locked, it makes it free.\\n\\nPrint the number of different staircases after each query. Two staircases are considered different if there exists such a cell that appears in one path and doesn't appear in the other path.\\n\\nInput\\n\\nThe first line contains three integers n, m and q (1 \u2264 n, m \u2264 1000; 1 \u2264 q \u2264 10^4) \u2014 the sizes of the matrix and the number of queries.\\n\\nEach of the next q lines contains two integers x and y (1 \u2264 x \u2264 n; 1 \u2264 y \u2264 m) \u2014 the description of each query.\\n\\nOutput\\n\\nPrint q integers \u2014 the i-th value should be equal to the number of different staircases after i queries. Two staircases are considered different if there exists such a cell that appears in one path and doesn't appear in the other path.\\n\\nExamples\\n\\nInput\\n\\n\\n2 2 8\\n1 1\\n1 1\\n1 1\\n2 2\\n1 1\\n1 2\\n2 1\\n1 1\\n\\n\\nOutput\\n\\n\\n5\\n10\\n5\\n2\\n5\\n3\\n1\\n0\\n\\n\\nInput\\n\\n\\n3 4 10\\n1 4\\n1 2\\n2 3\\n1 2\\n2 3\\n3 2\\n1 3\\n3 4\\n1 3\\n3 1\\n\\n\\nOutput\\n\\n\\n49\\n35\\n24\\n29\\n49\\n39\\n31\\n23\\n29\\n27\\n\\n\\nInput\\n\\n\\n1000 1000 2\\n239 634\\n239 634\\n\\n\\nOutput\\n\\n\\n1332632508\\n1333333000\\nThe above is tricky. Write me a correct solution in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nlong long int arr[1001][1001];\\nlong long int dp[1001][1001];\\nint main() {\\n  ios::sync_with_stdio(0);\\n  cin.tie(0);\\n  cout.tie(0);\\n  long long int n, m, q;\\n  cin >> n >> m >> q;\\n  for (int i = 0; i <= n; i++)\\n    for (int j = 0; j <= m; j++) arr[i][j] = 1, dp[i][j] = 0;\\n  for (int i = 1; i <= n; i++) {\\n    for (int j = 1; j <= m; j++) {\\n      long long int d = n - i, r = m - j;\\n      arr[i][j] += (4 * min(d, r));\\n      if (d != r) arr[i][j]++;\\n    }\\n  }\\n  long long int sum = 0;\\n  for (int i = 1; i <= n; i++) {\\n    for (int j = 1; j <= m; j++) {\\n      sum += arr[i][j];\\n    }\\n  }\\n  while (q--) {\\n    long long int x, y;\\n    cin >> x >> y;\\n    long long int r = x, c = y;\\n    if (dp[r][c] == 0) {\\n      long long int temp = 0;\\n      long long int cnt = 0;\\n      while (r <= n && c <= m && dp[r][c] == 0) {\\n        temp++;\\n        if (cnt % 2 == 0)\\n          r++;\\n        else\\n          c++;\\n        cnt++;\\n      }\\n      r = x, c = y;\\n      cnt = 0;\\n      while (r >= 1 && c >= 1 && dp[r][c] == 0) {\\n        arr[r][c] -= temp;\\n        sum -= temp;\\n        if (cnt % 2 == 0)\\n          c--;\\n        else\\n          r--;\\n        cnt++;\\n      }\\n      temp = 0;\\n      cnt = 0;\\n      r = x, c = y;\\n      while (r <= n && c <= m && dp[r][c] == 0) {\\n        temp++;\\n        if (cnt % 2 == 0)\\n          c++;\\n        else\\n          r++;\\n        cnt++;\\n      }\\n      r = x, c = y;\\n      cnt = 0;\\n      while (r >= 1 && c >= 1 && dp[r][c] == 0) {\\n        arr[r][c] -= temp;\\n        sum -= temp;\\n        if (cnt % 2 == 0)\\n          r--;\\n        else\\n          c--;\\n        cnt++;\\n      }\\n      arr[x][y]++;\\n      sum += 1;\\n      dp[x][y] = 1;\\n      cout << sum << endl;\\n    } else {\\n      dp[x][y] = 0;\\n      long long int temp = 0;\\n      long long int cnt = 0;\\n      while (r <= n && c <= m && dp[r][c] == 0) {\\n        temp++;\\n        if (cnt % 2 == 0)\\n          r++;\\n        else\\n          c++;\\n        cnt++;\\n      }\\n      r = x, c = y;\\n      cnt = 0;\\n      while (r >= 1 && c >= 1 && dp[r][c] == 0) {\\n     ...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"You are given a matrix, consisting of n rows and m columns. The j-th cell of the i-th row contains an integer a_{ij}.\\n\\nFirst, you have to color each row of the matrix either red or blue in such a way that at least one row is colored red and at least one row is colored blue.\\n\\nThen, you have to choose an integer k (1 \u2264 k < m) and cut the colored matrix in such a way that the first k columns become a separate matrix (the left matrix) and the last m-k columns become a separate matrix (the right matrix).\\n\\nThe coloring and the cut are called perfect if two properties hold: \\n\\n  * every red cell in the left matrix contains an integer greater than every blue cell in the left matrix; \\n  * every blue cell in the right matrix contains an integer greater than every red cell in the right matrix. \\n\\n\\n\\nFind any perfect coloring and cut, or report that there are none.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 1000) \u2014 the number of testcases.\\n\\nThen the descriptions of t testcases follow.\\n\\nThe first line of each testcase contains two integers n and m (2 \u2264 n, m \u2264 5 \u22c5 10^5; n \u22c5 m \u2264 10^6) \u2014 the number of rows and the number of columns in the matrix, respectively.\\n\\nThe i-th of the next n lines contains m integers a_{i1}, a_{i2}, ..., a_{im} (1 \u2264 a_{ij} \u2264 10^6).\\n\\nThe sum of n \u22c5 m over all testcases doesn't exceed 10^6.\\n\\nOutput\\n\\nFor each testcase print an answer. If there are no perfect colorings and cuts in the matrix, then print \\\"NO\\\".\\n\\nOtherwise, first, print \\\"YES\\\". Then a string, consisting of n characters: the i-th character should be 'R' if the i-th row is colored red and 'B' if it's colored blue. The string should contain at least one 'R' and at least one 'B'. Finally, print an integer k (1 \u2264 k < m) \u2014 the number of columns from the left that are cut.\\n\\nExample\\n\\nInput\\n\\n\\n3\\n5 5\\n1 5 8 8 7\\n5 2 1 4 3\\n1 6 9 7 5\\n9 3 3 3 2\\n1 7 9 9 8\\n3 3\\n8 9 8\\n1 5 3\\n7 5 7\\n2 6\\n3 3 3 2 2 2\\n1 1 1 4 4 4\\n\\n\\nOutput\\n\\n\\nYES\\nBRBRB 1\\nNO\\nYES\\nRB 3\\n\\nNote\\n\\nThe coloring and the cut for the first testcase:\\n\\n<image>\\\":\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nstruct poi {\\n  int val, tp, id;\\n} p[1000005];\\nint T, n, m, ans = 0;\\nint lmx[500005], lmn[500005], col[500005];\\nvector<int> g[500005];\\nmultiset<int> s[500005];\\nmultiset<int> grt;\\nbool cmp(poi a, poi b) {\\n  if (a.val == b.val) return a.tp < b.tp;\\n  return a.val < b.val;\\n}\\nvoid update(int x) {\\n  grt.clear();\\n  for (int i = 1; i <= n; i++) {\\n    int ele = g[i][x - 1];\\n    lmx[i] = max(lmx[i], ele);\\n    lmn[i] = min(lmn[i], ele);\\n    s[i].erase(s[i].find(ele));\\n    p[2 * i - 1].val = lmx[i];\\n    p[2 * i].val = lmn[i];\\n    p[2 * i - 1].tp = 1;\\n    p[2 * i].tp = 0;\\n    p[2 * i - 1].id = i;\\n    p[2 * i].id = i;\\n    col[i] = 0;\\n    grt.insert(*s[i].begin());\\n  }\\n  sort(p + 1, p + 2 * n + 1, cmp);\\n}\\nint main() {\\n  multiset<int>::iterator it;\\n  scanf(\\\"%d\\\", &T);\\n  while (T--) {\\n    ans = 0;\\n    scanf(\\\"%d%d\\\", &n, &m);\\n    for (int i = 1; i <= n; i++) {\\n      g[i].clear();\\n      s[i].clear();\\n      lmx[i] = 0;\\n      lmn[i] = 1e7;\\n      for (int j = 1; j <= m; j++) {\\n        int a;\\n        scanf(\\\"%d\\\", &a);\\n        g[i].push_back(a);\\n        s[i].insert(a);\\n      }\\n    }\\n    for (int i = 1; i < m; i++) {\\n      update(i);\\n      int top = 0, t = 0;\\n      for (int j = 2 * n; j >= 1; j--) {\\n        if (p[j].tp) t++;\\n        if (!p[j].tp) {\\n          t--;\\n          col[p[j].id] = 1;\\n          it = s[p[j].id].end();\\n          it--;\\n          top = max(top, *it);\\n          grt.erase(grt.find(*s[p[j].id].begin()));\\n        }\\n        if (t == 0 && !grt.empty()) {\\n          if (top < *grt.begin()) {\\n            ans = i;\\n            break;\\n          }\\n        }\\n      }\\n      if (ans) break;\\n    }\\n    if (ans) {\\n      printf(\\\"YES\\\\n\\\");\\n      for (int i = 1; i <= n; i++) {\\n        if (col[i])\\n          printf(\\\"R\\\");\\n        else\\n          printf(\\\"B\\\");\\n      }\\n      printf(\\\" %d\\\\n\\\", ans);\\n    } else\\n      printf(\\\"NO\\\\n\\\");\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"In Python, code blocks don't have explicit begin\\/end or curly braces to mark beginning and end of the block. Instead, code blocks are defined by indentation.\\n\\nWe will consider an extremely simplified subset of Python with only two types of statements.\\n\\nSimple statements are written in a single line, one per line. An example of a simple statement is assignment.\\n\\nFor statements are compound statements: they contain one or several other statements. For statement consists of a header written in a separate line which starts with \\\"for\\\" prefix, and loop body. Loop body is a block of statements indented one level further than the header of the loop. Loop body can contain both types of statements. Loop body can't be empty.\\n\\nYou are given a sequence of statements without indentation. Find the number of ways in which the statements can be indented to form a valid Python program.\\n\\nInput\\n\\nThe first line contains a single integer N (1 \u2264 N \u2264 5000) \u2014 the number of commands in the program. N lines of the program follow, each line describing a single command. Each command is either \\\"f\\\" (denoting \\\"for statement\\\") or \\\"s\\\" (\\\"simple statement\\\"). It is guaranteed that the last line is a simple statement.\\n\\nOutput\\n\\nOutput one line containing an integer - the number of ways the given sequence of statements can be indented modulo 109 + 7. \\n\\nExamples\\n\\nInput\\n\\n4\\ns\\nf\\nf\\ns\\n\\n\\nOutput\\n\\n1\\n\\n\\nInput\\n\\n4\\nf\\ns\\nf\\ns\\n\\n\\nOutput\\n\\n2\\n\\nNote\\n\\nIn the first test case, there is only one way to indent the program: the second for statement must be part of the body of the first one.\\n    \\n    \\n      \\n    simple statement  \\n    for statement  \\n        for statement  \\n            simple statement  \\n    \\n\\nIn the second test case, there are two ways to indent the program: the second for statement can either be part of the first one's body or a separate statement following the first one.\\n    \\n    \\n      \\n    for statement  \\n        simple statement  \\n        for statement  \\n            simple statement  \\n    \\n\\nor\\n    \\n    \\n      \\n    for statement  \\n        simple statement ...\\\":\",\"targets\":\"#include <bits\\/stdc++.h>\\nlong long int pow(long long int a, long long int b, long long int m) {\\n  long long int x = 1, y = a;\\n  while (b > 0) {\\n    if (b % 2 == 1) {\\n      x = (x * y);\\n      if (x > m) x %= m;\\n    }\\n    y = (y * y);\\n    if (y > m) y %= m;\\n    b \\/= 2;\\n  }\\n  return x % m;\\n}\\nlong long int gcd(long long int a, long long int b) {\\n  if (b == 0)\\n    return a;\\n  else\\n    return gcd(b, a % b);\\n}\\nlong long int gen(long long int start, long long int end) {\\n  long long int diff = end - start;\\n  long long int temp = rand() % start;\\n  return temp + diff;\\n}\\nusing namespace std;\\nlong long int dp[5001][5001];\\nint n;\\nchar a[1000001];\\nint main() {\\n  ios_base::sync_with_stdio(0);\\n  cin >> n;\\n  long long int tillnow[n + 1];\\n  tillnow[0] = 0;\\n  for (int i = 1; i <= n; i++) {\\n    cin >> a[i];\\n    tillnow[i] = tillnow[i - 1];\\n    if (a[i] == 1) tillnow[i]++;\\n  }\\n  long long int temp, prev = 0;\\n  dp[1][1] = 1;\\n  long long int psum[n + 1];\\n  long long int ppsum[n + 1];\\n  ppsum[0] = 0;\\n  for (int i = 1; i <= n; i++) ppsum[i] = 1;\\n  ppsum[1] = 1;\\n  psum[0] = 0;\\n  for (int i = 2; i <= n; i++) {\\n    temp = 0;\\n    for (int j = 1; j <= n; j++) {\\n      if (a[i - 1] == 'f') {\\n        dp[i][j] = dp[i - 1][j - 1];\\n      } else {\\n        dp[i][j] = (ppsum[n] - ppsum[j - 1] + 1000000007) % 1000000007;\\n      }\\n      psum[j] = psum[j - 1] + dp[i][j];\\n      dp[i][j] %= 1000000007;\\n    }\\n    for (int i = 1; i <= n; i++) ppsum[i] = psum[i];\\n  }\\n  long long int ans = 0;\\n  for (int i = 1; i <= n; i++) {\\n    ans = ans + dp[n][i];\\n    ans %= 1000000007;\\n  }\\n  cout << ans;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"You are given an integer n. Find any string s of length n consisting only of English lowercase letters such that each non-empty substring of s occurs in s an odd number of times. If there are multiple such strings, output any. It can be shown that such string always exists under the given constraints.\\n\\nA string a is a substring of a string b if a can be obtained from b by deletion of several (possibly, zero or all) characters from the beginning and several (possibly, zero or all) characters from the end.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 500) \u2014 the number of test cases.\\n\\nThe first line of each test case contains a single integer n (1 \u2264 n \u2264 10^5).\\n\\nIt is guaranteed that the sum of n over all test cases doesn't exceed 3 \u22c5 10^5.\\n\\nOutput\\n\\nFor each test case, print a single line containing the string s. If there are multiple such strings, output any. It can be shown that such string always exists under the given constraints.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n3\\n5\\n9\\n19\\n\\n\\nOutput\\n\\n\\nabc\\ndiane\\nbbcaabbba\\nyouarethecutestuwuu\\n\\nNote\\n\\nIn the first test case, each substring of \\\"abc\\\" occurs exactly once.\\n\\nIn the third test case, each substring of \\\"bbcaabbba\\\" occurs an odd number of times. In particular, \\\"b\\\" occurs 5 times, \\\"a\\\" and \\\"bb\\\" occur 3 times each, and each of the remaining substrings occurs exactly once.\\\":\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint main() {\\n  ios_base::sync_with_stdio(false);\\n  cin.tie(NULL);\\n  cout.tie(NULL);\\n  int t;\\n  cin >> t;\\n  while (t--) {\\n    long long n;\\n    cin >> n;\\n    if (n == 1) {\\n      cout << \\\"v\\\\n\\\";\\n      continue;\\n    }\\n    cout << string(n \\/ 2, 'a') + (n & 1 ? \\\"bv\\\" : \\\"b\\\") + string(n \\/ 2 - 1, 'a')\\n         << \\\"\\\\n\\\";\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"In fact, the problems E1 and E2 do not have much in common. You should probably think of them as two separate problems.\\n\\nYou are given an integer array a[1 \u2026 n] = [a_1, a_2, \u2026, a_n].\\n\\nLet us consider an empty [deque](https:\\/\\/tinyurl.com\\/pfeucbux) (double-ended queue). A deque is a data structure that supports adding elements to both the beginning and the end. So, if there are elements [3, 4, 4] currently in the deque, adding an element 1 to the beginning will produce the sequence [\\\\color{red}{1}, 3, 4, 4], and adding the same element to the end will produce [3, 4, 4, \\\\color{red}{1}].\\n\\nThe elements of the array are sequentially added to the initially empty deque, starting with a_1 and finishing with a_n. Before adding each element to the deque, you may choose whether to add it to the beginning or to the end.\\n\\nFor example, if we consider an array a = [3, 7, 5, 5], one of the possible sequences of actions looks like this:    1. |  add 3 to the beginning of the deque: |  deque has a sequence [\\\\color{red}{3}] in it;   \\n---|---|---  \\n  2. |  add 7 to the end of the deque: |  deque has a sequence [3, \\\\color{red}{7}] in it;   \\n  3. |  add 5 to the end of the deque: |  deque has a sequence [3, 7, \\\\color{red}{5}] in it;   \\n  4. |  add 5 to the beginning of the deque: |  deque has a sequence [\\\\color{red}{5}, 3, 7, 5] in it;   \\n  \\nFind the minimal possible number of inversions in the deque after the whole array is processed. \\n\\nAn inversion in sequence d is a pair of indices (i, j) such that i < j and d_i > d_j. For example, the array d = [5, 3, 7, 5] has exactly two inversions \u2014 (1, 2) and (3, 4), since d_1 = 5 > 3 = d_2 and d_3 = 7 > 5 = d_4.\\n\\nInput\\n\\nThe first line contains an integer t (1 \u2264 t \u2264 1000) \u2014 the number of test cases.\\n\\nThe next 2t lines contain descriptions of the test cases. \\n\\nThe first line of each test case description contains an integer n (1 \u2264 n \u2264 2 \u22c5 10^5) \u2014 array size. The second line of the description contains n space-separated integers a_i (-10^9 \u2264 a_i \u2264 10^9) \u2014 elements of the array.\\n\\nIt is...\\nimpor\",\"targets\":\"t java.util.Scanner;\\n\\npublic class E2 {\\n    public static void main(String[] args) {\\n        Scanner sc = new Scanner(System.in);\\n        int t = sc.nextInt();\\n        while (t-->0){\\n            Integer n = sc.nextInt();\\n            NumWithRON[] numWithRONS = new NumWithRON[n];\\n            NumWithRON[] copy = new NumWithRON[n];\\n            for(int i = 0;i<n;i++){\\n                numWithRONS[i] = new NumWithRON();\\n                numWithRONS[i].num = sc.nextLong();\\n                copy[i] = numWithRONS[i];\\n            }\\n            sortAndCountRON(numWithRONS, 0, n-1);\\n            \\/\\/\u7edf\u8ba1\u76f8\u540c\u6570\u5b57\u6570\u91cf\\n            for(int i=1;i < n;i++){\\n                if(numWithRONS[i].num == numWithRONS[i-1].num){\\n                    numWithRONS[i].same = numWithRONS[i-1].same + 1;\\n                }\\n            }\\n            long count = 0;\\n            for(int i = 1;i<n;i++){\\n                int now = i - copy[i].same-copy[i].RON;\\n                if(now > copy[i].RON){\\n                    count += copy[i].RON;\\n                }else {\\n                    count += now;\\n                }\\n            }\\n            System.out.println(count);\\n        }\\n    }\\n\\n    static class NumWithRON{\\n        long num;\\n        \\/\\/\u9006\u5e8f\u6570\\n        int RON = 0;\\n        int same = 0;\\n    }\\n\\n    static void sortAndCountRON(NumWithRON[] a, int begin, int end){\\n        if(begin >= end){\\n            return;\\n        }\\n        int l = end - begin + 1, mid = (begin + end)\\/2;\\n        NumWithRON[] b = new NumWithRON[l];\\n        sortAndCountRON(a, begin, mid);\\n        sortAndCountRON(a, mid+1, end);\\n        for(int i = 0, top = begin, bottom = mid+1;i<l;i++){\\n            if(top > mid){\\n                b[i] = a[bottom++];\\n            }else if(bottom > end){\\n                b[i] = a[top++];\\n            }else {\\n                if(a[top].num > a[bottom].num){\\n                    b[i] = a[bottom++];\\n                    b[i].RON+=(mid - top + 1);\\n                }else {\\n                    b[i] = a[top++];\\n                }\\n            }\\n        }\\n        for(int i = begin; i <=...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Morning desert sun horizon\\n\\nRise above the sands of time...\\n\\nFates Warning, \\\"Exodus\\\"\\n\\nAfter crossing the Windswept Wastes, Ori has finally reached the Windtorn Ruins to find the Heart of the Forest! However, the ancient repository containing this priceless Willow light did not want to open!\\n\\nOri was taken aback, but the Voice of the Forest explained to him that the cunning Gorleks had decided to add protection to the repository.\\n\\nThe Gorleks were very fond of the \\\"string expansion\\\" operation. They were also very fond of increasing subsequences.\\n\\nSuppose a string s_1s_2s_3 \u2026 s_n is given. Then its \\\"expansion\\\" is defined as the sequence of strings s_1, s_1 s_2, ..., s_1 s_2 \u2026 s_n, s_2, s_2 s_3, ..., s_2 s_3 \u2026 s_n, s_3, s_3 s_4, ..., s_{n-1} s_n, s_n. For example, the \\\"expansion\\\" the string 'abcd' will be the following sequence of strings: 'a', 'ab', 'abc', 'abcd', 'b', 'bc', 'bcd', 'c', 'cd', 'd'. \\n\\nTo open the ancient repository, Ori must find the size of the largest increasing subsequence of the \\\"expansion\\\" of the string s. Here, strings are compared lexicographically.\\n\\nHelp Ori with this task!\\n\\nA string a is lexicographically smaller than a string b if and only if one of the following holds:\\n\\n  * a is a prefix of b, but a \u2260 b;\\n  * in the first position where a and b differ, the string a has a letter that appears earlier in the alphabet than the corresponding letter in b.\\n\\nInput\\n\\nEach test contains multiple test cases.\\n\\nThe first line contains one positive integer t (1 \u2264 t \u2264 10^3), denoting the number of test cases. Description of the test cases follows.\\n\\nThe first line of each test case contains one positive integer n (1 \u2264 n \u2264 5000) \u2014 length of the string.\\n\\nThe second line of each test case contains a non-empty string of length n, which consists of lowercase latin letters.\\n\\nIt is guaranteed that the sum of n over all test cases does not exceed 10^4.\\n\\nOutput\\n\\nFor every test case print one non-negative integer \u2014 the answer to the...\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nlong long func(string &s, long long i, long long j) {\\n  long long ind = 0;\\n  if (ind < 0) ind = 0;\\n  while (j + ind < s.length()) {\\n    if (s[i + ind] > s[j + ind]) return 1000000007;\\n    if (s[i + ind] < s[j + ind])\\n      return ind;\\n    else\\n      ind++;\\n  }\\n  return 1000000007;\\n}\\nvoid solve() {\\n  long long n;\\n  string s;\\n  cin >> n;\\n  cin >> s;\\n  long long arr[n + 1][n + 1];\\n  for (long long i = 1; i < n + 1; i++) {\\n    if (s[i - 1] == s[n - 1])\\n      arr[i][n] = 1;\\n    else\\n      arr[i][n] = 0;\\n  }\\n  for (long long i = n - 2; i >= 1; i--) {\\n    for (long long j = i + 1; j < n; j++) {\\n      if (s[i - 1] == s[j - 1])\\n        arr[i][j] = 1 + arr[i + 1][j + 1];\\n      else\\n        arr[i][j] = 0;\\n    }\\n  }\\n  long long dp[n + 1];\\n  for (long long i = 0; i < n + 1; i++) dp[i] = 0;\\n  dp[n] = 1;\\n  for (long long i = n - 1; i >= 1; i--) {\\n    long long t = 0;\\n    for (long long j = i + 1; j <= n; j++) {\\n      long long x = arr[i][j];\\n      if (j - 1 + x >= n) continue;\\n      bool y = s[i - 1 + x] > s[j - 1 + x];\\n      if (!y) t = max(t, dp[j] - x);\\n    }\\n    dp[i] = n - i + 1 + t;\\n  }\\n  sort(dp, dp + n + 1);\\n  cout << dp[n] << endl;\\n}\\nint32_t main() {\\n  ios_base::sync_with_stdio(false);\\n  cin.tie(0);\\n  long long T = 1;\\n  cin >> T;\\n  while (T--) solve();\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Arya has n opponents in the school. Each day he will fight with all opponents who are present this day. His opponents have some fighting plan that guarantees they will win, but implementing this plan requires presence of them all. That means if one day at least one of Arya's opponents is absent at the school, then Arya will beat all present opponents. Otherwise, if all opponents are present, then they will beat Arya.\\n\\nFor each opponent Arya knows his schedule \u2014 whether or not he is going to present on each particular day. Tell him the maximum number of consecutive days that he will beat all present opponents.\\n\\nNote, that if some day there are no opponents present, Arya still considers he beats all the present opponents.\\n\\nInput\\n\\nThe first line of the input contains two integers n and d (1 \u2264 n, d \u2264 100) \u2014 the number of opponents and the number of days, respectively.\\n\\nThe i-th of the following d lines contains a string of length n consisting of characters '0' and '1'. The j-th character of this string is '0' if the j-th opponent is going to be absent on the i-th day.\\n\\nOutput\\n\\nPrint the only integer \u2014 the maximum number of consecutive days that Arya will beat all present opponents.\\n\\nExamples\\n\\nInput\\n\\n2 2\\n10\\n00\\n\\n\\nOutput\\n\\n2\\n\\n\\nInput\\n\\n4 1\\n0100\\n\\n\\nOutput\\n\\n1\\n\\n\\nInput\\n\\n4 5\\n1101\\n1111\\n0110\\n1011\\n1111\\n\\n\\nOutput\\n\\n2\\n\\nNote\\n\\nIn the first and the second samples, Arya will beat all present opponents each of the d days.\\n\\nIn the third sample, Arya will beat his opponents on days 1, 3 and 4 and his opponents will beat him on days 2 and 5. Thus, the maximum number of consecutive winning days is 2, which happens on days 3 and 4.\\nThe above is tricky. Write me a correct solution in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint a[105][105];\\nint main() {\\n  int n, m;\\n  scanf(\\\"%d%d\\\", &n, &m);\\n  for (int i = 0; i < m; i++) {\\n    for (int j = 0; j < n; j++) {\\n      scanf(\\\"%1d\\\", &a[i][j]);\\n    }\\n  }\\n  int ans = 0;\\n  int t = 0;\\n  for (int i = 0; i < m; i++) {\\n    int flag = 0;\\n    for (int j = 0; j < n; j++) {\\n      if (a[i][j] == 0) {\\n        flag = 1;\\n        break;\\n      }\\n    }\\n    if (flag)\\n      t++;\\n    else\\n      t = 0;\\n    ans = max(ans, t);\\n  }\\n  printf(\\\"%d\\\\n\\\", ans);\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in JAVA?\\nThis problem is an extension of the problem \\\"Wonderful Coloring - 1\\\". It has quite many differences, so you should read this statement completely.\\n\\nRecently, Paul and Mary have found a new favorite sequence of integers a_1, a_2, ..., a_n. They want to paint it using pieces of chalk of k colors. The coloring of a sequence is called wonderful if the following conditions are met:\\n\\n  1. each element of the sequence is either painted in one of k colors or isn't painted; \\n  2. each two elements which are painted in the same color are different (i. e. there's no two equal values painted in the same color); \\n  3. let's calculate for each of k colors the number of elements painted in the color \u2014 all calculated numbers must be equal; \\n  4. the total number of painted elements of the sequence is the maximum among all colorings of the sequence which meet the first three conditions. \\n\\n\\n\\nE. g. consider a sequence a=[3, 1, 1, 1, 1, 10, 3, 10, 10, 2] and k=3. One of the wonderful colorings of the sequence is shown in the figure.\\n\\n<image> The example of a wonderful coloring of the sequence a=[3, 1, 1, 1, 1, 10, 3, 10, 10, 2] and k=3. Note that one of the elements isn't painted.\\n\\nHelp Paul and Mary to find a wonderful coloring of a given sequence a.\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 10000) \u2014 the number of test cases. Then t test cases follow.\\n\\nEach test case consists of two lines. The first one contains two integers n and k (1 \u2264 n \u2264 2\u22c510^5, 1 \u2264 k \u2264 n) \u2014 the length of a given sequence and the number of colors, respectively. The second one contains n integers a_1, a_2, ..., a_n (1 \u2264 a_i \u2264 n).\\n\\nIt is guaranteed that the sum of n over all test cases doesn't exceed 2 \u22c5 10^5.\\n\\nOutput\\n\\nOutput t lines, each of them must contain a description of a wonderful coloring for the corresponding test case.\\n\\nEach wonderful coloring must be printed as a sequence of n integers c_1, c_2, ..., c_n (0 \u2264 c_i \u2264 k) separated by spaces where\\n\\n  * c_i=0, if i-th element isn't painted; \\n  * c_i>0, if i-th element is painted in the...\",\"targets\":\"import java.util.*;\\nimport java.lang.*;\\nimport java.io.*;\\nimport java.awt.*;\\n\\n\\/*AUTHOR - SHIVAM GUPTA *\\/\\n\\n\\/\\/ U KNOW THAT IF THIS DAY WILL BE URS THEN NO ONE CAN DEFEAT U HERE ,JUst keep faith in ur strengths .................................................. \\n\\/\\/ ASCII = 48 + i ;\\/\\/ 2^28 = 268,435,456  > 2* 10^8 \\/\\/ log 10 base 2 = 3.3219 \\n\\/\\/ odd:: (x^2+1)\\/2 , (x^2-1)\\/2 ; x>=3\\/\\/ even:: (x^2\\/4)+1 ,(x^2\\/4)-1  x >=4 \\n\\/\\/ FOR ANY ODD NO N : N,N-1,N-2,ALL ARE PAIRWISE COPRIME,THEIR COMBINED LCM IS PRODUCT OF ALL THESE NOS\\n\\/\\/ two consecutive odds are always coprime to each other, two consecutive even have always gcd  = 2 ;\\n\\n\\/\\/ Rectangle r = new Rectangle(int x , int y,int widht,int height) \\n\\/\\/Creates a rect. with bottom left cordinates as (x, y) and top right as ((x+width),(y+height))\\n\\n\\/\\/BY DEFAULT Priority Queue is MIN in nature in java\\n\\/\\/to use as max , just push with negative sign and change sign after removal \\n\\n\\/\\/ We can make a sieve of max size 1e7 .(no time or space issue) \\n\\/\\/ In 1e7 starting nos we have about 66*1e4 prime nos\\n\\/\\/ In 1e6 starting nos we have about 78,498 prime nos\\n\\n public class Main\\n \\/\\/public class Solution\\n{\\n    static PrintWriter out;\\n    \\n\\tstatic class FastReader{\\n\\t\\tBufferedReader br;\\n\\t\\tStringTokenizer st;\\n\\t\\tpublic FastReader(){\\n\\t\\t\\tbr=new BufferedReader(new InputStreamReader(System.in));\\n\\t\\t\\tout=new PrintWriter(System.out);\\n\\t\\t}\\n\\t\\tString next(){\\n\\t\\t\\twhile(st==null || !st.hasMoreElements()){\\n\\t\\t\\t\\ttry{\\n\\t\\t\\t\\t\\tst= new StringTokenizer(br.readLine());\\n\\t\\t\\t\\t}\\n\\t\\t\\t\\tcatch (IOException e){\\n\\t\\t\\t\\t\\te.printStackTrace();\\n\\t\\t\\t\\t}\\n\\t\\t\\t}\\n\\t\\t\\treturn st.nextToken();\\n\\t\\t}\\n\\t\\tint nextInt(){\\n\\t\\t\\treturn Integer.parseInt(next());\\n\\t\\t}\\n\\t\\tlong nextLong(){\\n\\t\\t\\treturn Long.parseLong(next());\\n\\t\\t}\\n\\t\\tdouble nextDouble(){\\n\\t\\t\\treturn Double.parseDouble(next());\\n\\t\\t}\\n\\t\\tString nextLine(){\\n\\t\\t\\tString str = \\\"\\\";\\n\\t\\t\\ttry{\\n\\t\\t\\t\\tstr=br.readLine();\\n\\t\\t\\t}\\n\\t\\t\\tcatch(IOException e){\\n\\t\\t\\t\\te.printStackTrace();\\n\\t\\t\\t}\\n\\t\\t\\treturn str;\\n\\t\\t}\\n\\t}\\n\\t\\n\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\n public static int...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Everybody knows that we have been living in the Matrix for a long time. And in the new seventh Matrix the world is ruled by beavers.\\n\\nSo let's take beaver Neo. Neo has so-called \\\"deja vu\\\" outbursts when he gets visions of events in some places he's been at or is going to be at. Let's examine the phenomenon in more detail.\\n\\nWe can say that Neo's city is represented by a directed graph, consisting of n shops and m streets that connect the shops. No two streets connect the same pair of shops (besides, there can't be one street from A to B and one street from B to A). No street connects a shop with itself. As Neo passes some streets, he gets visions. No matter how many times he passes street k, every time he will get the same visions in the same order. A vision is a sequence of shops.\\n\\nWe know that Neo is going to get really shocked if he passes the way from some shop a to some shop b, possible coinciding with a, such that the list of visited shops in the real life and in the visions coincide.\\n\\nSuggest beaver Neo such path of non-zero length. Or maybe you can even count the number of such paths modulo 1000000007 (109 + 7)?..\\n\\nInput\\n\\nThe first line contains integers n and m \u2014 the number of shops and the number of streets, correspondingly, 1 \u2264 n \u2264 50, <image>. Next m lines contain the descriptions of the streets in the following format: xi yi ki v1 v2 ... vk, where xi and yi (1 \u2264 xi, yi \u2264 n, xi \u2260 yi) are numbers of shops connected by a street, ki (0 \u2264 ki \u2264 n) is the number of visions on the way from xi to yi; v1, v2, ..., vk (1 \u2264 vi \u2264 n) describe the visions: the numbers of the shops Neo saw. Note that the order of the visions matters.\\n\\nIt is guaranteed that the total number of visions on all streets doesn't exceed 105.\\n\\n  * to get 50 points, you need to find any (not necessarily simple) path of length at most 2\u00b7n, that meets the attributes described above (subproblem E1); \\n  * to get 50 more points, you need to count for each length from 1 to 2\u00b7n the number of paths that have the attribute described above...\\n#incl\",\"targets\":\"ude <bits\\/stdc++.h>\\nusing namespace std;\\ninline void read(int &x) {\\n  int v = 0, f = 1;\\n  char c = getchar();\\n  while (!isdigit(c) && c != '-') c = getchar();\\n  if (c == '-')\\n    f = -1;\\n  else\\n    v = (c & 15);\\n  while (isdigit(c = getchar())) v = (v << 1) + (v << 3) + (c & 15);\\n  x = v * f;\\n}\\ninline void read(long long &x) {\\n  long long v = 0ll, f = 1ll;\\n  char c = getchar();\\n  while (!isdigit(c) && c != '-') c = getchar();\\n  if (c == '-')\\n    f = -1;\\n  else\\n    v = (c & 15);\\n  while (isdigit(c = getchar())) v = (v << 1) + (v << 3) + (c & 15);\\n  x = v * f;\\n}\\ninline void readc(char &x) {\\n  char c;\\n  while (((c = getchar()) == ' ') || c == '\\\\n')\\n    ;\\n  x = c;\\n}\\nconst int mod = 1e9 + 7;\\nint n, m, i, j, a, b, c, d, f[2][55][105], e[55][55];\\nvector<int> g[55][55];\\nvector<int> trs[2][2][55][55];\\nvoid init() {\\n  int i, j, k;\\n  for (((i)) = (1); ((i)) <= ((n)); ((i))++)\\n    for (((j)) = (1); ((j)) <= ((n)); ((j))++) {\\n      if (e[i][j] && !g[i][j].empty() && g[i][j].back() == i) {\\n        int cnt = 1, lst = i;\\n        queue<int> qx;\\n        for (k = ((int)g[i][j].size()) - 2; k >= 0; k--) {\\n          qx.push(g[i][j][k]);\\n        }\\n        while (!qx.empty()) {\\n          int x = qx.front();\\n          qx.pop();\\n          cnt++;\\n          if (!e[x][lst] || cnt > n + n) {\\n            cnt = -1;\\n            break;\\n          }\\n          for (k = ((int)g[x][lst].size()) - 1; k >= 0; k--) {\\n            qx.push(g[x][lst][k]);\\n          }\\n          lst = x;\\n        }\\n        if (cnt != -1) trs[0][0][lst][j].push_back(cnt);\\n      }\\n    }\\n  for (((i)) = (1); ((i)) <= ((n)); ((i))++)\\n    for (((j)) = (1); ((j)) <= ((n)); ((j))++) {\\n      if (e[i][j] && !g[i][j].empty() && g[i][j][0] == j) {\\n        int cnt = 1, lst = j;\\n        queue<int> qx;\\n        for (k = 1; k < g[i][j].size(); k++) {\\n          qx.push(g[i][j][k]);\\n        }\\n        while (!qx.empty()) {\\n          int x = qx.front();\\n          qx.pop();\\n          cnt++;\\n          if (!e[lst][x] || cnt > n + n) {\\n            cnt = -1;\\n            break;\\n          }\\n         ...\",\"language\":\"python\",\"split\":\"train\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"YouKn0wWho has an integer sequence a_1, a_2, \u2026 a_n. Now he will split the sequence a into one or more consecutive subarrays so that each element of a belongs to exactly one subarray. Let k be the number of resulting subarrays, and h_1, h_2, \u2026, h_k be the lengths of the longest increasing subsequences of corresponding subarrays.\\n\\nFor example, if we split [2, 5, 3, 1, 4, 3, 2, 2, 5, 1] into [2, 5, 3, 1, 4], [3, 2, 2, 5], [1], then h = [3, 2, 1].\\n\\nYouKn0wWho wonders if it is possible to split the sequence a in such a way that the [bitwise XOR](https:\\/\\/en.wikipedia.org\\/wiki\\/Bitwise_operation#XOR) of h_1, h_2, \u2026, h_k is equal to 0. You have to tell whether it is possible.\\n\\nThe longest increasing subsequence (LIS) of a sequence b_1, b_2, \u2026, b_m is the longest sequence of valid indices i_1, i_2, \u2026, i_k such that i_1 < i_2 < \u2026 < i_k and b_{i_1} < b_{i_2} < \u2026 < b_{i_k}. For example, the LIS of [2, 5, 3, 3, 5] is [2, 3, 5], which has length 3.\\n\\nAn array c is a subarray of an array b if c can be obtained from b by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 10 000) \u2014 the number of test cases.\\n\\nThe first line of each test case contains a single integer n (2 \u2264 n \u2264 10^5).\\n\\nThe second line of each test case contains n integers a_1, a_2, \u2026, a_n (1 \u2264 a_i \u2264 10^9).\\n\\nIt is guaranteed that the sum of n over all test cases doesn't exceed 3 \u22c5 10^5.\\n\\nOutput\\n\\nFor each test case, print \\\"YES\\\" (without quotes) if it is possible to split into subarrays in the desired way, print \\\"NO\\\" (without quotes) otherwise. You can print each letter in any register (upper or lower).\\n\\nExample\\n\\nInput\\n\\n\\n4\\n7\\n1 3 4 2 2 1 5\\n3\\n1 3 4\\n5\\n1 3 2 4 2\\n4\\n4 3 2 1\\n\\n\\nOutput\\n\\n\\nYES\\nNO\\nYES\\nYES\\n\\nNote\\n\\nIn the first test case, YouKn0wWho can split the sequence in the following way: [1, 3, 4], [2, 2], [1, 5]. This way, the LIS lengths are h = [3, 1, 2], and the bitwise XOR of the LIS lengths is 3 \u2295 1 \u2295 2 = 0.\\n\\nIn the second test...\\nThe above is tricky. Write me a correct solution in JAVA.\",\"targets\":\"import java.util.*;\\npublic class class51 {\\n\\n\\tpublic static void main(String[] args) {\\n        Scanner input=new Scanner(System.in);\\n\\t\\tint l=input. nextInt ();\\n\\t\\twhile(l-->0)\\n\\t\\t{\\n\\t\\t\\tint n1 = input.nextInt ();\\n\\t\\t\\tint b[] = new int [ n1 ]; \\n\\t\\t\\tint i=0;\\n\\t\\t\\tfor ( i = 0 ; i < n1 ; i ++)\\n\\t\\t\\t{\\n\\t\\t\\t\\tint m=input.nextInt ();\\n\\t\\t\\tb[i]=m;\\n\\t\\t\\t}\\n\\t\\t\\tif(n1%2==0 )\\n\\t\\t\\t{\\n\\t\\t\\t\\tSystem . out . println ( \\\"YES\\\" );\\n\\t\\t\\t}\\n\\t\\t\\telse\\n\\t\\t\\t{\\n\\t\\t\\t\\tint flag = 0 ;\\n\\t\\t\\tfor ( i = 0 ; i < n1 - 1 ; i ++)\\n\\t\\t\\t{\\n\\t\\t\\t\\tif ( b[ i ]>= b[ i + 1 ])\\n\\t\\t\\t\\t{\\n\\t\\t\\t\\tflag = 1 ;\\t\\n\\t\\t\\t\\tbreak ;\\n\\t\\t\\t\\t}\\n\\t\\t\\t}\\n\\t\\t\\tif ( flag == 1 )\\n\\t\\t\\t{\\n\\t\\t\\t\\tSystem.out.println ( \\\"YES\\\" );\\n\\t\\t\\t}\\n\\t\\t\\telse\\n\\t\\t\\t{\\n\\t\\t\\t\\tSystem.out.println ( \\\"NO\\\" );\\n\\t\\t\\t}\\t\\t\\n\\t\\t}\\n\\t}\\n\\t}\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"After the lessons n groups of schoolchildren went outside and decided to visit Polycarpus to celebrate his birthday. We know that the i-th group consists of si friends (1 \u2264 si \u2264 4), and they want to go to Polycarpus together. They decided to get there by taxi. Each car can carry at most four passengers. What minimum number of cars will the children need if all members of each group should ride in the same taxi (but one taxi can take more than one group)?\\n\\nInput\\n\\nThe first line contains integer n (1 \u2264 n \u2264 105) \u2014 the number of groups of schoolchildren. The second line contains a sequence of integers s1, s2, ..., sn (1 \u2264 si \u2264 4). The integers are separated by a space, si is the number of children in the i-th group.\\n\\nOutput\\n\\nPrint the single number \u2014 the minimum number of taxis necessary to drive all children to Polycarpus.\\n\\nExamples\\n\\nInput\\n\\n5\\n1 2 4 3 3\\n\\n\\nOutput\\n\\n4\\n\\n\\nInput\\n\\n8\\n2 3 4 4 2 1 3 1\\n\\n\\nOutput\\n\\n5\\n\\nNote\\n\\nIn the first test we can sort the children into four cars like this:\\n\\n  * the third group (consisting of four children), \\n  * the fourth group (consisting of three children), \\n  * the fifth group (consisting of three children), \\n  * the first and the second group (consisting of one and two children, correspondingly). \\n\\n\\n\\nThere are other ways to sort the groups into four cars.\\nn = i\",\"targets\":\"nt(raw_input())\\ns = map(int, raw_input().split())\\nfreq_map = [0]*4\\nfor v in s:\\n    freq_map[v - 1] += 1\\n\\nans = freq_map[3]\\nans += freq_map[2]\\nfreq_map[0] -= freq_map[2]\\nans += (freq_map[1] + 1) \\/ 2\\nfreq_map[0] -= 2 if freq_map[1] % 2 == 1 else 0\\nfreq_map[0] = max(freq_map[0], 0)\\nans += (freq_map[0] + 3) \\/ 4\\n\\nprint ans\",\"language\":\"python\",\"split\":\"train\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Bishwock is a chess figure that consists of three squares resembling an \\\"L-bar\\\". This figure can be rotated by 90, 180 and 270 degrees so it can have four possible states:\\n    \\n    \\n      \\n    XX   XX   .X   X.  \\n    X.   .X   XX   XX  \\n    \\n\\nBishwocks don't attack any squares and can even occupy on the adjacent squares as long as they don't occupy the same square. \\n\\nVasya has a board with 2\u00d7 n squares onto which he wants to put some bishwocks. To his dismay, several squares on this board are already occupied by pawns and Vasya can't put bishwocks there. However, pawns also don't attack bishwocks and they can occupy adjacent squares peacefully.\\n\\nKnowing the positions of pawns on the board, help Vasya to determine the maximum amount of bishwocks he can put onto the board so that they wouldn't occupy the same squares and wouldn't occupy squares with pawns.\\n\\nInput\\n\\nThe input contains two nonempty strings that describe Vasya's board. Those strings contain only symbols \\\"0\\\" (zero) that denote the empty squares and symbols \\\"X\\\" (uppercase English letter) that denote the squares occupied by pawns. Strings are nonempty and are of the same length that does not exceed 100.\\n\\nOutput\\n\\nOutput a single integer \u2014 the maximum amount of bishwocks that can be placed onto the given board.\\n\\nExamples\\n\\nInput\\n\\n00\\n00\\n\\n\\nOutput\\n\\n1\\n\\nInput\\n\\n00X00X0XXX0\\n0XXX0X00X00\\n\\n\\nOutput\\n\\n4\\n\\nInput\\n\\n0X0X0\\n0X0X0\\n\\n\\nOutput\\n\\n0\\n\\nInput\\n\\n0XXX0\\n00000\\n\\n\\nOutput\\n\\n2\",\"targets\":\"#include <bits\\/stdc++.h>\\nlong long mod(long long x) {\\n  if (x < 0) return -x;\\n  return x;\\n}\\nlong long expo(long long x, long long y) {\\n  long long res = 1;\\n  while (y > 0) {\\n    if (y % 2 == 1) res = (res * x);\\n    y >> 1;\\n    x = x * x;\\n  }\\n  return res;\\n}\\nusing namespace std;\\nvector<long long> v;\\nlong long a[1000000], b[1000000];\\nint main() {\\n  ios_base::sync_with_stdio(false);\\n  long long n, t, x = 0, y = 0;\\n  string s[2];\\n  cin >> s[0];\\n  cin >> s[1];\\n  for (int i = 0; i < s[0].length(); ++i) {\\n    if (s[0][i] == '0' && s[0][i + 1] == '0') {\\n      if (s[1][i] == '0') {\\n        s[0][i] = 'X';\\n        s[0][i + 1] = 'X';\\n        s[1][i] = 'X';\\n        y++;\\n      }\\n    }\\n    if (s[0][i] == '0' && s[0][i + 1] == '0') {\\n      if (s[1][i + 1] == '0') {\\n        s[0][i] = 'X';\\n        s[0][i + 1] = 'X';\\n        s[1][i + 1] = 'X';\\n        y++;\\n      }\\n    }\\n    if (s[0][i] == '0') {\\n      if (s[1][i] == '0' && s[1][i + 1] == '0') {\\n        s[0][i] = 'X';\\n        s[1][i] = 'X';\\n        s[1][i + 1] = 'X';\\n        y++;\\n      }\\n    }\\n    if (s[0][i] == '0') {\\n      if (s[1][i] == '0' && s[1][i - 1] == '0') {\\n        s[0][i] = 'X';\\n        s[1][i] = 'X';\\n        s[1][i - 1] = 'X';\\n        y++;\\n      }\\n    }\\n    if (s[1][i] == '0' && s[1][i + 1] == '0') {\\n      if (s[0][i] == '0') {\\n        s[1][i] = 'X';\\n        s[1][i + 1] = 'X';\\n        s[0][i] = 'X';\\n        y++;\\n      }\\n    }\\n    if (s[1][i] == '0' && s[1][i + 1] == '0') {\\n      if (s[0][i + 1] == '0') {\\n        s[1][i] = 'X';\\n        s[1][i + 1] = 'X';\\n        s[0][i + 1] = 'X';\\n        y++;\\n      }\\n    }\\n    if (s[1][i] == '0') {\\n      if (s[0][i] == '0' && s[0][i + 1] == '0') {\\n        s[0][i] = 'X';\\n        s[0][i + 1] = 'X';\\n        s[1][i] = 'X';\\n        y++;\\n      }\\n    }\\n    if (s[1][i] == '0') {\\n      if (s[0][i] == '0' && s[0][i - 1] == '0') {\\n        s[0][i] = 'X';\\n        s[0][i - 1] = 'X';\\n        s[1][i] = 'X';\\n        y++;\\n      }\\n    }\\n  }\\n  cout << y << endl;\\n  ;\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Let's call the string beautiful if it does not contain a substring of length at least 2, which is a palindrome. Recall that a palindrome is a string that reads the same way from the first character to the last and from the last character to the first. For example, the strings a, bab, acca, bcabcbacb are palindromes, but the strings ab, abbbaa, cccb are not.\\n\\nLet's define cost of a string as the minimum number of operations so that the string becomes beautiful, if in one operation it is allowed to change any character of the string to one of the first 3 letters of the Latin alphabet (in lowercase).\\n\\nYou are given a string s of length n, each character of the string is one of the first 3 letters of the Latin alphabet (in lowercase).\\n\\nYou have to answer m queries \u2014 calculate the cost of the substring of the string s from l_i-th to r_i-th position, inclusive.\\n\\nInput\\n\\nThe first line contains two integers n and m (1 \u2264 n, m \u2264 2 \u22c5 10^5) \u2014 the length of the string s and the number of queries.\\n\\nThe second line contains the string s, it consists of n characters, each character one of the first 3 Latin letters.\\n\\nThe following m lines contain two integers l_i and r_i (1 \u2264 l_i \u2264 r_i \u2264 n) \u2014 parameters of the i-th query.\\n\\nOutput\\n\\nFor each query, print a single integer \u2014 the cost of the substring of the string s from l_i-th to r_i-th position, inclusive.\\n\\nExample\\n\\nInput\\n\\n\\n5 4\\nbaacb\\n1 3\\n1 5\\n4 5\\n2 3\\n\\n\\nOutput\\n\\n\\n1\\n2\\n0\\n1\\n\\nNote\\n\\nConsider the queries of the example test.\\n\\n  * in the first query, the substring is baa, which can be changed to bac in one operation; \\n  * in the second query, the substring is baacb, which can be changed to cbacb in two operations; \\n  * in the third query, the substring is cb, which can be left unchanged; \\n  * in the fourth query, the substring is aa, which can be changed to ba in one operation. \\nUsing cpp can you solve the prior task?\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst int maxn = 2e5 + 5;\\nint n, m;\\nconst string tpl[6] = {\\\"abc\\\", \\\"acb\\\", \\\"bac\\\", \\\"bca\\\", \\\"cab\\\", \\\"cba\\\"};\\nint mark[6][maxn];\\nint main() {\\n  ios::sync_with_stdio(false);\\n  while (cin >> n >> m) {\\n    string s;\\n    cin >> s;\\n    memset(mark, 0, sizeof(mark));\\n    for (int i = 0; i < 6; i++) {\\n      for (int j = 1; j <= n; j++) {\\n        if (tpl[i][(j - 1) % 3] != s[j - 1]) {\\n          mark[i][j] = mark[i][j - 1] + 1;\\n        } else {\\n          mark[i][j] = mark[i][j - 1];\\n        }\\n      }\\n    }\\n    while (m--) {\\n      int l, r;\\n      cin >> l >> r;\\n      int ans = INT_MAX;\\n      for (int i = 0; i < 6; i++) {\\n        ans = min(ans, mark[i][r] - mark[i][l - 1]);\\n      }\\n      cout << ans << endl;\\n    }\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Being a nonconformist, Volodya is displeased with the current state of things, particularly with the order of natural numbers (natural number is positive integer number). He is determined to rearrange them. But there are too many natural numbers, so Volodya decided to start with the first n. He writes down the following sequence of numbers: firstly all odd integers from 1 to n (in ascending order), then all even integers from 1 to n (also in ascending order). Help our hero to find out which number will stand at the position number k.\\n\\nInput\\n\\nThe only line of input contains integers n and k (1 \u2264 k \u2264 n \u2264 1012).\\n\\nPlease, do not use the %lld specifier to read or write 64-bit integers in C++. It is preferred to use the cin, cout streams or the %I64d specifier.\\n\\nOutput\\n\\nPrint the number that will stand at the position number k after Volodya's manipulations.\\n\\nExamples\\n\\nInput\\n\\n10 3\\n\\n\\nOutput\\n\\n5\\n\\nInput\\n\\n7 7\\n\\n\\nOutput\\n\\n6\\n\\nNote\\n\\nIn the first sample Volodya's sequence will look like this: {1, 3, 5, 7, 9, 2, 4, 6, 8, 10}. The third place in the sequence is therefore occupied by the number 5.\\nUsing java can you solve the prior task?\",\"targets\":\"import java.util.Scanner;\\npublic class Main{\\npublic static void main(String[] args)\\n{\\n  Scanner sc=new Scanner(System.in);\\n  long n=sc.nextLong();\\n  long k=sc.nextLong();\\n  System.out.print((k<=(n+1)\\/2)?2*k-1:((n%2==0)?2*k-n:2*k-n-1));\\n}\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in CPP?\\nA positive integer may be expressed as a sum of different prime numbers (primes), in one way or another. Given two positive integers n and k, you should count the number of ways to express n as a sum of k different primes. Here, two ways are considered to be the same if they sum up the same set of the primes. For example, 8 can be expressed as 3 + 5 and 5+ 3 but they are not distinguished.\\n\\nWhen n and k are 24 and 3 respectively, the answer is two because there are two sets {2, 3, 19} and {2, 5, 17} whose sums are equal to 24. There are no other sets of three primes that sum up to 24. For n = 24 and k = 2, the answer is three, because there are three sets {5, 19}, {7,17} and {11, 13}. For n = 2 and k = 1, the answer is one, because there is only one set {2} whose sum is 2. For n = 1 and k = 1, the answer is zero. As 1 is not a prime, you shouldn't count {1}. For n = 4 and k = 2, the answer is zero, because there are no sets of two diffrent primes whose sums are 4.\\n\\nYour job is to write a program that reports the number of such ways for the given n and k.\\n\\n\\n\\nInput\\n\\nThe input is a sequence of datasets followed by a line containing two zeros separated by a space. A dataset is a line containing two positive integers n and k separated by a space. You may assume that n \u2264 1120 and k \u2264 14.\\n\\nOutput\\n\\nThe output should be composed of lines, each corresponding to an input dataset. An output line should contain one non-negative integer indicating the number of ways for n and k specified in the corresponding dataset. You may assume that it is less than 231.\\n\\nExample\\n\\nInput\\n\\n24 3\\n24 2\\n2 1\\n1 1\\n4 2\\n18 3\\n17 1\\n17 3\\n17 4\\n100 5\\n1000 10\\n1120 14\\n0 0\\n\\n\\nOutput\\n\\n2\\n3\\n1\\n0\\n0\\n2\\n1\\n0\\n1\\n55\\n200102899\\n2079324314\",\"targets\":\"#include <cstdio>\\n#include <cstdlib>\\n#include <cstring>\\n#include <climits>\\n#include <cassert>\\n#include <iostream>\\n#include <iomanip>\\n#include <sstream>\\n#include <algorithm>\\n#include <numeric>\\n#include <complex>\\n#include <stack>\\n#include <queue>\\n#include <list>\\n#include <set>\\n#include <map>\\n#include <bitset>\\n#include <functional>\\n#include <iterator>\\n\\nusing namespace std;\\n\\n#define dump(n) cout<<\\\"# \\\"<<#n<<'='<<(n)<<endl\\n#define repi(i,a,b) for(int i=int(a);i<int(b);i++)\\n#define peri(i,a,b) for(int i=int(b);i-->int(a);)\\n#define rep(i,n) repi(i,0,n)\\n#define per(i,n) peri(i,0,n)\\n#define iter(c) __typeof__((c).begin())\\n#define foreach(i,c) for(iter(c) i=(c).begin();i!=(c).end();++i)\\n#define all(c) (c).begin(),(c).end()\\n#define mp make_pair\\n\\ntypedef unsigned int uint;\\ntypedef long long ll;\\ntypedef unsigned long long ull;\\ntypedef vector<int> vi;\\ntypedef vector<vi> vvi;\\ntypedef vector<double> vd;\\ntypedef vector<vd> vvd;\\ntypedef vector<string> vs;\\ntypedef pair<int,int> pii;\\n\\nconst int INFTY=1<<29;\\nconst double EPS=1e-9;\\n\\ntemplate<typename T1,typename T2>\\nostream& operator<<(ostream& os,const pair<T1,T2>& p){\\n\\treturn os<<'('<<p.first<<','<<p.second<<')';\\n}\\ntemplate<typename T>\\nostream& operator<<(ostream& os,const vector<T>& a){\\n\\tos<<'[';\\n\\trep(i,a.size()) os<<(i?\\\" \\\":\\\"\\\")<<a[i];\\n\\treturn os<<']';\\n}\\n\\nint main()\\n{\\n\\tvi isp(2000,1); isp[0]=isp[1]=0;\\n\\tfor(int i=2;i*i<isp.size();i++)\\n\\t\\tif(isp[i])\\n\\t\\t\\tfor(int j=i*i;j<isp.size();j+=i)\\n\\t\\t\\t\\tisp[j]=0;\\n\\tvi ps;\\n\\trep(i,isp.size()) if(isp[i])\\n\\t\\tps.push_back(i);\\n\\t\\n\\tfor(int n,k;cin>>n>>k,n|k;){\\n\\t\\tvvi dp(k+1,vi(n+1));\\n\\t\\tdp[0][0]=1;\\n\\t\\tfor(int p:ps){\\n\\t\\t\\tper(i,k) rep(j,n){\\n\\t\\t\\t\\tif(j+p>n) break;\\n\\t\\t\\t\\tdp[i+1][j+p]+=dp[i][j];\\n\\t\\t\\t}\\n\\t\\t}\\n\\t\\tcout<<dp[k][n]<<endl;\\n\\t}\\n\\t\\n\\treturn 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Petya is a math teacher. n of his students has written a test consisting of m questions. For each student, it is known which questions he has answered correctly and which he has not.\\n\\nIf the student answers the j-th question correctly, he gets p_j points (otherwise, he gets 0 points). Moreover, the points for the questions are distributed in such a way that the array p is a permutation of numbers from 1 to m.\\n\\nFor the i-th student, Petya knows that he expects to get x_i points for the test. Petya wonders how unexpected the results could be. Petya believes that the surprise value of the results for students is equal to \u2211_{i=1}^{n} |x_i - r_i|, where r_i is the number of points that the i-th student has got for the test.\\n\\nYour task is to help Petya find such a permutation p for which the surprise value of the results is maximum possible. If there are multiple answers, print any of them.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases.\\n\\nThe first line of each test case contains two integers n and m (1 \u2264 n \u2264 10; 1 \u2264 m \u2264 10^4) \u2014 the number of students and the number of questions, respectively.\\n\\nThe second line contains n integers x_1, x_2, ..., x_n (0 \u2264 x_i \u2264 (m(m+1))\\/(2)), where x_i is the number of points that the i-th student expects to get.\\n\\nThis is followed by n lines, the i-th line contains the string s_i (|s_i| = m; s_{i, j} \u2208 \\\\{0, 1\\\\}), where s_{i, j} is 1 if the i-th student has answered the j-th question correctly, and 0 otherwise.\\n\\nThe sum of m for all test cases does not exceed 10^4.\\n\\nOutput\\n\\nFor each test case, print m integers \u2014 a permutation p for which the surprise value of the results is maximum possible. If there are multiple answers, print any of them.\\n\\nExample\\n\\nInput\\n\\n\\n3\\n4 3\\n5 1 2 2\\n110\\n100\\n101\\n100\\n4 4\\n6 2 0 10\\n1001\\n0010\\n0110\\n0101\\n3 6\\n20 3 15\\n010110\\n000101\\n111111\\n\\n\\nOutput\\n\\n\\n3 1 2 \\n2 3 4 1 \\n3 1 4 5 2 6 \\n#incl\",\"targets\":\"ude <bits\\/stdc++.h>\\nusing namespace std;\\nvoid solve() {\\n  int n, m;\\n  cin >> n >> m;\\n  vector<long long int> a(n);\\n  for (int i = 0; i < n; i++) cin >> a[i];\\n  vector<string> s(n);\\n  for (int i = 0; i < n; i++) cin >> s[i];\\n  long long int sur = 0;\\n  vector<int> ans;\\n  for (int mask = 0; mask < (1 << (n - 1)); mask++) {\\n    int lo = 1, hi = m;\\n    int lo2 = 1, hi2 = m;\\n    vector<int> cnt(m, 0);\\n    vector<bool> stat(n);\\n    for (int i = 0; i < n; i++) {\\n      if (mask & (1 << i))\\n        stat[i] = true;\\n      else\\n        stat[i] = false;\\n    }\\n    for (int i = 0; i < n; i++) {\\n      for (int j = 0; j < m; j++) {\\n        if (s[i][j] == '1') {\\n          cnt[j] += (stat[i] ? 1 : -1);\\n        }\\n      }\\n    }\\n    set<pair<int, int>> temp1, temp2;\\n    vector<int> tempAns(m, -1), tempAns2(m, -1);\\n    for (int i = 0; i < m; i++) {\\n      if (cnt[i] > 0)\\n        temp1.insert(make_pair(-cnt[i], i));\\n      else if (cnt[i] < 0)\\n        temp2.insert(make_pair(cnt[i], i));\\n    }\\n    for (auto it : temp1) {\\n      int index = it.second;\\n      tempAns[index] = hi--;\\n      tempAns2[index] = lo2++;\\n    }\\n    for (auto it : temp2) {\\n      int index = it.second;\\n      tempAns[index] = lo++;\\n      tempAns2[index] = hi2--;\\n    }\\n    for (int i = 0; i < m; i++) {\\n      if (tempAns[i] == -1) {\\n        tempAns[i] = lo++;\\n        tempAns2[i] = lo2++;\\n      }\\n    }\\n    long long int checkSur = 0, checkSur2 = 0;\\n    for (int i = 0; i < n; i++) {\\n      long long int score = 0;\\n      long long int score2 = 0;\\n      for (int j = 0; j < m; j++) {\\n        if (s[i][j] == '1') {\\n          score += tempAns[j];\\n          score2 += tempAns2[j];\\n        }\\n      }\\n      checkSur += abs(a[i] - score);\\n      checkSur2 += abs(a[i] - score2);\\n    }\\n    if (checkSur > sur || mask == 0) {\\n      sur = checkSur;\\n      ans = move(tempAns);\\n    }\\n    if (checkSur2 > sur) {\\n      sur = checkSur2;\\n      ans = move(tempAns2);\\n    }\\n  }\\n  for (int i = 0; i < m; i++) {\\n    cout << ans[i] << ' ';\\n  }\\n  cout << '\\\\n';\\n}\\nint main() {\\n  ios::sync_with_stdio(false);\\n ...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"A number is ternary if it contains only digits 0, 1 and 2. For example, the following numbers are ternary: 1022, 11, 21, 2002.\\n\\nYou are given a long ternary number x. The first (leftmost) digit of x is guaranteed to be 2, the other digits of x can be 0, 1 or 2.\\n\\nLet's define the ternary XOR operation \u2299 of two ternary numbers a and b (both of length n) as a number c = a \u2299 b of length n, where c_i = (a_i + b_i) \\\\% 3 (where \\\\% is modulo operation). In other words, add the corresponding digits and take the remainders of the sums when divided by 3. For example, 10222 \u2299 11021 = 21210.\\n\\nYour task is to find such ternary numbers a and b both of length n and both without leading zeros that a \u2299 b = x and max(a, b) is the minimum possible.\\n\\nYou have to answer t independent test cases.\\n\\nInput\\n\\nThe first line of the input contains one integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases. Then t test cases follow. The first line of the test case contains one integer n (1 \u2264 n \u2264 5 \u22c5 10^4) \u2014 the length of x. The second line of the test case contains ternary number x consisting of n digits 0, 1 or 2. It is guaranteed that the first digit of x is 2. It is guaranteed that the sum of n over all test cases does not exceed 5 \u22c5 10^4 (\u2211 n \u2264 5 \u22c5 10^4).\\n\\nOutput\\n\\nFor each test case, print the answer \u2014 two ternary integers a and b both of length n and both without leading zeros such that a \u2299 b = x and max(a, b) is the minimum possible. If there are several answers, you can print any.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n5\\n22222\\n5\\n21211\\n1\\n2\\n9\\n220222021\\n\\n\\nOutput\\n\\n\\n11111\\n11111\\n11000\\n10211\\n1\\n1\\n110111011\\n110111010\\nSolve the task in PYTHON3.\",\"targets\":\"T = int (input ())\\n\\nfor I in range (0, T):\\n\\n    N = int (input ())\\n    X = input ()\\n    A = '1'\\n    B = '1'\\n    R = True\\n\\n    for I in X [1 : ]:\\n\\n        if I == '0':\\n\\n            A += '0'\\n            B += '0'\\n\\n        else:\\n\\n            if R:\\n\\n                if I == '1':\\n\\n                    A += '1'\\n                    B += '0'\\n                    R = False\\n\\n                else:\\n\\n                    A += '1'\\n                    B += '1'\\n\\n            else:\\n\\n                if I == '1':\\n\\n                    A += '0'\\n                    B += '1'\\n                    R = False\\n\\n                else:\\n\\n                    A += '0'\\n                    B += '2'\\n                    R = False\\n\\n    print (A)\\n    print (B)\",\"language\":\"python\",\"split\":\"train\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"Amidakuji is a traditional method of lottery in Japan.\\n\\nTo make an amidakuji, we first draw W parallel vertical lines, and then draw horizontal lines that connect them. The length of each vertical line is H+1 [cm], and the endpoints of the horizontal lines must be at 1, 2, 3, ..., or H [cm] from the top of a vertical line.\\n\\nA valid amidakuji is an amidakuji that satisfies the following conditions:\\n\\n* No two horizontal lines share an endpoint.\\n* The two endpoints of each horizontal lines must be at the same height.\\n* A horizontal line must connect adjacent vertical lines.\\n\\n\\n\\n<image>\\n\\nFind the number of the valid amidakuji that satisfy the following condition, modulo 1\\\\ 000\\\\ 000\\\\ 007: if we trace the path from the top of the leftmost vertical line to the bottom, always following horizontal lines when we encounter them, we reach the bottom of the K-th vertical line from the left.\\n\\nFor example, in the following amidakuji, we will reach the bottom of the fourth vertical line from the left.\\n\\n<image>\\n\\nConstraints\\n\\n* H is an integer between 1 and 100 (inclusive).\\n* W is an integer between 1 and 8 (inclusive).\\n* K is an integer between 1 and W (inclusive).\\n\\nInput\\n\\nInput is given from Standard Input in the following format:\\n\\n\\nH W K\\n\\n\\nOutput\\n\\nPrint the number of the amidakuji that satisfy the condition, modulo 1\\\\ 000\\\\ 000\\\\ 007.\\n\\nExamples\\n\\nInput\\n\\n1 3 2\\n\\n\\nOutput\\n\\n1\\n\\n\\nInput\\n\\n1 3 1\\n\\n\\nOutput\\n\\n2\\n\\n\\nInput\\n\\n2 3 3\\n\\n\\nOutput\\n\\n1\\n\\n\\nInput\\n\\n2 3 1\\n\\n\\nOutput\\n\\n5\\n\\n\\nInput\\n\\n7 1 1\\n\\n\\nOutput\\n\\n1\\n\\n\\nInput\\n\\n15 8 5\\n\\n\\nOutput\\n\\n437760187\\\":\",\"targets\":\"#include<cstdio>\\n#include<cmath>\\n#include<algorithm>\\n#define mod 1000000007LL\\nusing namespace std;\\ntypedef long long ll;\\nll f[105][10][150],sum[10][2];\\nint main()\\n{\\n\\tint n,m,k;scanf(\\\"%d%d%d\\\",&n,&m,&k);\\n\\tsum[1][0]=1;\\n\\tfor(int i=1;i<=n;i++)\\n\\t{\\n\\t\\tfor(int j=1;j<=m;j++) sum[j][i&1]=0;\\n\\t\\tfor(int j=1;j<=m;j++)\\n\\t\\tfor(int s=0;s<(1<<(m-1));s++)\\n\\t\\t{\\n\\t\\t\\tint fg=0;\\n\\t\\t\\tfor(int k=0;k<m-2;k++)\\n\\t\\t\\tif((s&(1<<k))&&(s&(1<<(k+1)))) fg=1;\\n\\t\\t\\tif(fg) continue;\\n\\t\\t\\tint pre=j;\\n\\t\\t\\tif(s&(1<<(j-1))) pre++;\\n\\t\\t\\telse if(s&(1<<(j-2))) pre--;\\n\\t\\t\\tf[i][j][s]+=sum[pre][(i-1)&1];f[i][j][s]%=mod;\\n\\t\\t\\tsum[j][i&1]+=f[i][j][s];sum[j][i&1]%=mod;\\n\\t\\t}\\n\\t}\\n\\t\\n\\tprintf(\\\"%lld\\\\n\\\",sum[k][n&1]);\\n\\treturn 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in JAVA?\\nThe only difference between this problem and D2 is that you don't have to provide the way to construct the answer in this problem, but you have to do it in D2.\\n\\nThere's a table of n \u00d7 m cells (n rows and m columns). The value of n \u22c5 m is even.\\n\\nA domino is a figure that consists of two cells having a common side. It may be horizontal (one of the cells is to the right of the other) or vertical (one of the cells is above the other).\\n\\nYou need to find out whether it is possible to place nm\\/2 dominoes on the table so that exactly k of them are horizontal and all the other dominoes are vertical. The dominoes cannot overlap and must fill the whole table.\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 10) \u2014 the number of test cases. Then t test cases follow.\\n\\nEach test case consists of a single line. The line contains three integers n, m, k (1 \u2264 n,m \u2264 100, 0 \u2264 k \u2264 nm\\/2, n \u22c5 m is even) \u2014 the number of rows, columns and horizontal dominoes, respectively.\\n\\nOutput\\n\\nFor each test case output \\\"YES\\\", if it is possible to place dominoes in the desired way, or \\\"NO\\\" otherwise.\\n\\nYou may print each letter in any case (YES, yes, Yes will all be recognized as positive answer, NO, no and nO will all be recognized as negative answer).\\n\\nExample\\n\\nInput\\n\\n\\n8\\n4 4 2\\n2 3 0\\n3 2 3\\n1 2 0\\n2 4 2\\n5 2 2\\n2 17 16\\n2 1 1\\n\\n\\nOutput\\n\\n\\nYES\\nYES\\nYES\\nNO\\nYES\\nNO\\nYES\\nNO\",\"targets\":\"import java.io.*;\\nimport java.util.*;\\n\\npublic class D {\\n\\t\\n\\tpublic static void main(String[] args) {\\n\\t\\t\\n\\t\\tFastReader f = new FastReader();\\n\\t\\tStringBuffer sb=new StringBuffer();\\n\\t\\t\\n\\t\\tint test=f.nextInt();\\n\\t\\twhile(test-->0)\\n\\t\\t{\\n\\t\\t\\tint n=f.nextInt();\\n\\t\\t\\tint m=f.nextInt();\\n\\t\\t\\tint k=f.nextInt();\\n\\t\\t\\tint y=((n*m)\\/2)-k;\\n\\t\\t\\t\\n\\t\\t\\tif(m==1 && k>0)\\n\\t\\t\\t{\\n\\t\\t\\t\\tsb.append(\\\"No\\\\n\\\");\\n\\t\\t\\t\\tcontinue;\\n\\t\\t\\t}\\n\\t\\t\\tif(n==1 && y>0)\\n\\t\\t\\t{\\n\\t\\t\\t\\tsb.append(\\\"No\\\\n\\\");\\n\\t\\t\\t\\tcontinue;\\n\\t\\t\\t}\\n\\t\\t\\t\\n\\t\\t\\tif(n%2!=0)\\n\\t\\t\\t{\\n\\t\\t\\t\\tint min=m\\/2;\\n\\t\\t\\t\\tif(k<min)\\n\\t\\t\\t\\t{\\n\\t\\t\\t\\t\\tsb.append(\\\"No\\\\n\\\");\\n\\t\\t\\t\\t\\tcontinue;\\n\\t\\t\\t\\t}\\n\\t\\t\\t\\tk-=min;\\n\\t\\t\\t\\tn--;\\n\\t\\t\\t}\\n\\t\\t\\tif(m%2!=0)\\n\\t\\t\\t{\\n\\t\\t\\t\\tint min=n\\/2;\\n\\t\\t\\t\\tif(y<min)\\n\\t\\t\\t\\t{\\n\\t\\t\\t\\t\\tsb.append(\\\"No\\\\n\\\");\\n\\t\\t\\t\\t\\tcontinue;\\n\\t\\t\\t\\t}\\n\\t\\t\\t\\ty-=min;\\n\\t\\t\\t\\tm--;\\n\\t\\t\\t}\\n\\t\\t\\tif(k%2==0)\\n\\t\\t\\t\\tsb.append(\\\"Yes\\\\n\\\");\\n\\t\\t\\telse\\n\\t\\t\\t\\tsb.append(\\\"No\\\\n\\\");\\n\\t\\t}\\n\\t\\tSystem.out.println(sb);\\n\\t\\t\\n\\t}\\n\\tstatic class FastReader \\n\\t{ \\n\\t    BufferedReader br; \\n\\t    StringTokenizer st; \\n \\n\\t    public FastReader() {\\n\\t    \\tbr = new BufferedReader(new\\n\\t                 InputStreamReader(System.in)); \\n\\t    }\\n\\t    String next() { \\n\\t        while (st == null || !st.hasMoreElements()) { \\n\\t            try{ \\n\\t                st = new StringTokenizer(br.readLine()); \\n\\t            } \\n\\t            catch (IOException  e) { \\n\\t                e.printStackTrace(); \\n\\t            } \\n\\t        } \\n\\t        return st.nextToken(); \\n\\t    } \\n\\t    int nextInt() { \\n\\t        return Integer.parseInt(next()); \\n\\t    } \\n\\t    long nextLong() { \\n\\t        return Long.parseLong(next()); \\n\\t    } \\n\\t    double nextDouble() { \\n\\t        return Double.parseDouble(next()); \\n\\t    } \\n\\t    String nextLine() { \\n\\t        String str = \\\"\\\"; \\n\\t        try{ \\n\\t            str = br.readLine(); \\n\\t        } \\n\\t        catch (IOException e) { \\n\\t            e.printStackTrace(); \\n\\t        } \\n\\t        return str; \\n\\t    } \\n\\t} \\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"A chess tournament will be held soon, where n chess players will take part. Every participant will play one game against every other participant. Each game ends in either a win for one player and a loss for another player, or a draw for both players.\\n\\nEach of the players has their own expectations about the tournament, they can be one of two types:\\n\\n  1. a player wants not to lose any game (i. e. finish the tournament with zero losses); \\n  2. a player wants to win at least one game. \\n\\n\\n\\nYou have to determine if there exists an outcome for all the matches such that all the players meet their expectations. If there are several possible outcomes, print any of them. If there are none, report that it's impossible.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 200) \u2014 the number of test cases.\\n\\nThe first line of each test case contains one integer n (2 \u2264 n \u2264 50) \u2014 the number of chess players.\\n\\nThe second line contains the string s (|s| = n; s_i \u2208 \\\\{1, 2\\\\}). If s_i = 1, then the i-th player has expectations of the first type, otherwise of the second type.\\n\\nOutput\\n\\nFor each test case, print the answer in the following format:\\n\\nIn the first line, print NO if it is impossible to meet the expectations of all players.\\n\\nOtherwise, print YES, and the matrix of size n \u00d7 n in the next n lines.\\n\\nThe matrix element in the i-th row and j-th column should be equal to:\\n\\n  * +, if the i-th player won in a game against the j-th player; \\n  * -, if the i-th player lost in a game against the j-th player; \\n  * =, if the i-th and j-th players' game resulted in a draw; \\n  * X, if i = j. \\n\\nExample\\n\\nInput\\n\\n\\n3\\n3\\n111\\n2\\n21\\n4\\n2122\\n\\n\\nOutput\\n\\n\\nYES\\nX==\\n=X=\\n==X\\nNO\\nYES\\nX--+\\n+X++\\n+-X-\\n--+X\\nSolve the task in JAVA.\",\"targets\":\"import java.util.*;\\nimport java.lang.*;\\nimport java.io.*;\\n\\npublic class B_Chess_Tournament\\n{\\n    \\n\\tpublic static void main (String[] args) throws java.lang.Exception\\n\\t{\\n\\t\\tFastReader sc =new FastReader();\\n\\t\\t\\n\\t    int t=sc.nextInt();\\n\\t    \\n\\t    while(t-->0)\\n\\t    {\\n            int n=sc.nextInt();\\n            String s=sc.next();\\n            char c[]=s.toCharArray();\\n            ArrayList<Character> al=new ArrayList<Character>();\\n            for(int i=0; i<n;i++){\\n                if(s.charAt(i)=='2'){\\n                    al.add(s.charAt(i));\\n                }\\n            }\\n            if(al.size()==1 || al.size()==2){\\n                System.out.println(\\\"NO\\\");\\n                continue;\\n            }\\n\\n            System.out.println(\\\"YES\\\");\\n                char[][] ans=new char[n][n];\\n                for(int i=0; i<n; i++){\\n                    for(int j=0; j<n; j++){\\n                        if(i==j){\\n                            ans[i][j]='X';\\n                        }\\n                        else{\\n                            ans[i][j]='=';\\n                        }\\n                    }\\n                }\\n\\n                for (int i = 0; i < n; i++) {\\n                    if (c[i] == '2') {\\n                        for (int j = i + 1; j < n + i; j++) {\\n                            if (c[j%n] == '2') {\\n                                ans[i][j%n] = '+';\\n                                ans[j%n][i] = '-';\\n                                break;\\n                            }\\n                        }\\n                    }\\n                }\\n                \\n                for (int i = 0; i < n; i++) {\\n                    for (int j = 0; j < n; j++) {\\n                        System.out.print(ans[i][j]);\\n                    }\\n                    System.out.println();\\n                }\\n            \\n         \\n         \\n      \\n\\n        \\n          \\n\\t    }\\n\\t    \\n\\t}\\n\\t\\n\\t\\n\\t\\n\\tstatic class FastReader {\\n        BufferedReader br;\\n        StringTokenizer st;\\n \\n        public FastReader()\\n        {\\n            br = new BufferedReader(\\n     ...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"During the programming classes Vasya was assigned a difficult problem. However, he doesn't know how to code and was unable to find the solution in the Internet, so he asks you to help.\\n\\nYou are given a sequence a, consisting of n distinct integers, that is used to construct the binary search tree. Below is the formal description of the construction process.\\n\\n  1. First element a_1 becomes the root of the tree. \\n  2. Elements a_2, a_3, \u2026, a_n are added one by one. To add element a_i one needs to traverse the tree starting from the root and using the following rules: \\n    1. The pointer to the current node is set to the root. \\n    2. If a_i is greater than the value in the current node, then its right child becomes the current node. Otherwise, the left child of the current node becomes the new current node. \\n    3. If at some point there is no required child, the new node is created, it is assigned value a_i and becomes the corresponding child of the current node. \\n\\nInput\\n\\nThe first line of the input contains a single integer n (2 \u2264 n \u2264 100 000) \u2014 the length of the sequence a.\\n\\nThe second line contains n distinct integers a_i (1 \u2264 a_i \u2264 10^9) \u2014 the sequence a itself.\\n\\nOutput\\n\\nOutput n - 1 integers. For all i > 1 print the value written in the node that is the parent of the node with value a_i in it.\\n\\nExamples\\n\\nInput\\n\\n3\\n1 2 3\\n\\n\\nOutput\\n\\n1 2\\n\\n\\nInput\\n\\n5\\n4 2 3 1 6\\n\\n\\nOutput\\n\\n4 2 2 4\\\":\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint seq[110000];\\nint par[110000];\\nint dn[110000];\\nint up[110000];\\nstruct node {\\n  node *left, *right;\\n  int l, r;\\n  int vl;\\n} typedef node;\\nnode* root;\\nvoid build(node* cur, int l, int r) {\\n  cur->l = l;\\n  cur->r = r;\\n  cur->vl = 11000000;\\n}\\nvoid expand(node* cur) {\\n  if (cur->left == NULL) {\\n    cur->left = new node();\\n    cur->right = new node();\\n    int m = (cur->l + cur->r) \\/ 2;\\n    build(cur->left, cur->l, m);\\n    build(cur->right, m + 1, cur->r);\\n  }\\n}\\nvoid update(node* cur, int p, int vl) {\\n  if (cur->l == p && cur->r == p) {\\n    cur->vl = vl;\\n    return;\\n  }\\n  if (cur->l > p || cur->r < p) return;\\n  expand(cur);\\n  update(cur->left, p, vl);\\n  update(cur->right, p, vl);\\n  cur->vl = min(cur->left->vl, cur->right->vl);\\n}\\nint query(node* cur, int l, int r) {\\n  if (cur == NULL) return 11000000;\\n  if (cur->r < l || cur->l > r) return 11000000;\\n  if (cur->l >= l && cur->r <= r) return cur->vl;\\n  return min(query(cur->left, l, r), query(cur->right, l, r));\\n}\\nint main() {\\n  int i;\\n  int n;\\n  scanf(\\\"%d\\\", &n);\\n  root = new node();\\n  build(root, 0, 1000000002);\\n  for (i = 0; i < n; i++) {\\n    scanf(\\\"%d\\\", &seq[i]);\\n    dn[i] = 0;\\n    up[i] = 1000000002;\\n    if (i) update(root, seq[i], i);\\n  }\\n  for (i = 0; i < n; i++) {\\n    int lo = query(root, dn[i], seq[i] - 1);\\n    int hi = query(root, seq[i] + 1, up[i]);\\n    if (lo != 11000000) {\\n      par[lo] = seq[i];\\n      up[lo] = min(seq[i], up[i]);\\n      dn[lo] = dn[i];\\n      update(root, seq[lo], 11000000);\\n    }\\n    if (hi != 11000000) {\\n      par[hi] = seq[i];\\n      up[hi] = up[i];\\n      dn[hi] = max(seq[i], dn[i]);\\n      update(root, seq[hi], 11000000);\\n    }\\n  }\\n  for (i = 1; i < n; i++) {\\n    printf(\\\"%d\\\", par[i]);\\n    if (i != n - 1)\\n      printf(\\\" \\\");\\n    else\\n      printf(\\\"\\\\n\\\");\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"YouKn0wWho has an integer sequence a_1, a_2, \u2026, a_n. He will perform the following operation until the sequence becomes empty: select an index i such that 1 \u2264 i \u2264 |a| and a_i is not divisible by (i + 1), and erase this element from the sequence. Here |a| is the length of sequence a at the moment of operation. Note that the sequence a changes and the next operation is performed on this changed sequence.\\n\\nFor example, if a=[3,5,4,5], then he can select i = 2, because a_2 = 5 is not divisible by i+1 = 3. After this operation the sequence is [3,4,5].\\n\\nHelp YouKn0wWho determine if it is possible to erase the whole sequence using the aforementioned operation.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 10 000) \u2014 the number of test cases.\\n\\nThe first line of each test case contains a single integer n (1 \u2264 n \u2264 10^5).\\n\\nThe second line of each test case contains n integers a_1, a_2, \u2026, a_n (1 \u2264 a_i \u2264 10^9).\\n\\nIt is guaranteed that the sum of n over all test cases doesn't exceed 3 \u22c5 10^5.\\n\\nOutput\\n\\nFor each test case, print \\\"YES\\\" (without quotes) if it is possible to erase the whole sequence using the aforementioned operation, print \\\"NO\\\" (without quotes) otherwise. You can print each letter in any register (upper or lower).\\n\\nExample\\n\\nInput\\n\\n\\n5\\n3\\n1 2 3\\n1\\n2\\n2\\n7 7\\n10\\n384836991 191890310 576823355 782177068 404011431 818008580 954291757 160449218 155374934 840594328\\n8\\n6 69 696 69696 696969 6969696 69696969 696969696\\n\\n\\nOutput\\n\\n\\nYES\\nNO\\nYES\\nYES\\nNO\\n\\nNote\\n\\nIn the first test case, YouKn0wWho can perform the following operations (the erased elements are underlined): [1, \\\\underline{2}, 3] \u2192 [\\\\underline{1}, 3] \u2192 [\\\\underline{3}] \u2192 [ ].\\n\\nIn the second test case, it is impossible to erase the sequence as i can only be 1, and when i=1, a_1 = 2 is divisible by i + 1 = 2.\",\"targets\":\"import java.util.*;\\n\\nimport javax.swing.text.Segment;\\n\\nimport java.io.*;\\nimport java.math.*;\\nimport java.sql.Array;\\n\\n\\n\\npublic class Main {\\n\\t  static class Scanner{\\n\\t\\t  \\n\\t\\t\\tBufferedReader br;\\n\\t\\t\\tStringTokenizer st;\\n\\t\\t\\tpublic Scanner() {\\n\\t\\t\\t\\tbr = new BufferedReader(new InputStreamReader(System.in));\\n\\t\\t\\t}\\n\\t\\t\\tString next() \\n\\t\\t    { \\n\\t\\t        while (st == null || !st.hasMoreElements()) \\n\\t\\t        { \\n\\t\\t            try\\n\\t\\t            { \\n\\t\\t                st = new StringTokenizer(br.readLine()); \\n\\t\\t            } \\n\\t\\t            catch (IOException  e) \\n\\t\\t            { \\n\\t\\t                e.printStackTrace(); \\n\\t\\t            } \\n\\t\\t        } \\n\\t\\t        return st.nextToken(); \\n\\t\\t    } \\n\\n\\t\\t    int nextInt() \\n\\t\\t    { \\n\\t\\t        return Integer.parseInt(next()); \\n\\t\\t    } \\n\\n\\t\\t    long nextLong() \\n\\t\\t    { \\n\\t\\t        return Long.parseLong(next()); \\n\\t\\t    } \\n\\n\\t\\t    double nextDouble() \\n\\t\\t    { \\n\\t\\t        return Double.parseDouble(next()); \\n\\t\\t    } \\n\\n\\t\\t    String nextLine() \\n\\t\\t    { \\n\\t\\t        String str = \\\"\\\"; \\n\\t\\t        try\\n\\t\\t        { \\n\\t\\t            str = br.readLine(); \\n\\t\\t        } \\n\\t\\t        catch (IOException e) \\n\\t\\t        { \\n\\t\\t            e.printStackTrace(); \\n\\t\\t        } \\n\\t\\t        return str; \\n\\t\\t    } \\n\\t\\t}\\n\\t \\n\\t  static long mod = (long)(1e9 + 7);\\n\\t \\n\\tstatic void sort(long[] arr ) {\\n\\t\\t ArrayList<Long> al = new ArrayList<>();\\n\\t\\t for(long e:arr) al.add(e);\\n\\t\\t Collections.sort(al);\\n\\t\\t for(int i = 0 ; i<al.size(); i++) arr[i] = al.get(i);\\n\\t }\\n\\tstatic void sort(int[] arr ) {\\n\\t\\t ArrayList<Integer> al = new ArrayList<>();\\n\\t\\t for(int e:arr) al.add(e);\\n\\t\\t Collections.sort(al);\\n\\t\\t for(int i = 0 ; i<al.size(); i++) arr[i] = al.get(i);\\n\\t }\\n\\tstatic void sort(char[] arr) {\\n\\t\\tArrayList<Character> al = new ArrayList<Character>();\\n\\t\\tfor(char cc:arr) al.add(cc);\\n\\t\\tCollections.sort(al);\\n\\t\\tfor(int i = 0 ;i<arr.length ;i++) arr[i] = al.get(i);\\n\\t}\\n\\tstatic void rvrs(int[] arr) {\\n\\t\\tint i =0 , j = arr.length-1;\\n\\t\\twhile(i>=j) {\\n\\t\\t\\tint temp = arr[i];\\n\\t\\t\\tarr[i] = arr[j];\\n\\t\\t\\tarr[j] = temp;\\n\\t\\t\\ti++;\\n\\t\\t\\tj--;\\n\\t\\t}\\n\\t}\\n\\tstatic void rvrs(long[] arr) {\\n\\t\\tint i =0...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"PYTHON3 solution for \\\"The city where Mocha lives in is called Zhijiang. There are n+1 villages and 2n-1 directed roads in this city. \\n\\nThere are two kinds of roads:\\n\\n  * n-1 roads are from village i to village i+1, for all 1\u2264 i \u2264 n-1. \\n  * n roads can be described by a sequence a_1,\u2026,a_n. If a_i=0, the i-th of these roads goes from village i to village n+1, otherwise it goes from village n+1 to village i, for all 1\u2264 i\u2264 n. \\n\\n\\n\\nMocha plans to go hiking with Taki this weekend. To avoid the trip being boring, they plan to go through every village exactly once. They can start and finish at any villages. Can you help them to draw up a plan? \\n\\nInput\\n\\nEach test contains multiple test cases. \\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 20) \u2014 the number of test cases. Each test case consists of two lines.\\n\\nThe first line of each test case contains a single integer n (1 \u2264 n \u2264 10^4) \u2014 indicates that the number of villages is n+1.\\n\\nThe second line of each test case contains n integers a_1, a_2, \u2026, a_n (0 \u2264 a_i \u2264 1). If a_i=0, it means that there is a road from village i to village n+1. If a_i=1, it means that there is a road from village n+1 to village i.\\n\\nIt is guaranteed that the sum of n over all test cases does not exceed 10^4.\\n\\nOutput\\n\\nFor each test case, print a line with n+1 integers, where the i-th number is the i-th village they will go through. If the answer doesn't exist, print -1.\\n\\nIf there are multiple correct answers, you can print any one of them.\\n\\nExample\\n\\nInput\\n\\n\\n2\\n3\\n0 1 0\\n3\\n1 1 0\\n\\n\\nOutput\\n\\n\\n1 4 2 3 \\n4 1 2 3 \\n\\nNote\\n\\nIn the first test case, the city looks like the following graph:\\n\\n<image>\\n\\nSo all possible answers are (1 \u2192 4 \u2192 2 \u2192 3), (1 \u2192 2 \u2192 3 \u2192 4).\\n\\nIn the second test case, the city looks like the following graph:\\n\\n<image>\\n\\nSo all possible answers are (4 \u2192 1 \u2192 2 \u2192 3), (1 \u2192 2 \u2192 3 \u2192 4), (3 \u2192 4 \u2192 1 \u2192 2), (2 \u2192 3 \u2192 4 \u2192 1).\\\":\",\"targets\":\"# python\\nimport os\\nimport sys; import math\\nfrom io import BytesIO, IOBase\\n\\n#----------------------------Manual Functions Begin----------------------------------------#\\ndef upperbound(arr,val):\\n    start = 0; end = len(arr) - 1; ans = -1\\n    while (start <= end):\\n        mid = (start + end) \\/\\/ 2\\n        if (arr[mid] <= val):\\n            start = mid + 1\\n        else:\\n            ans = mid\\n            end = mid - 1\\n    return ans\\ndef lowerbound(arr,val):\\n    length = len(arr); answer = -1; start = 0; end = length - 1    \\n    while start <= end:\\n        middle = (start + end)\\/\\/2    \\n        if arr[middle] == val:\\n            answer = middle\\n            end = middle - 1\\n        elif arr[middle] > val:\\n            end = middle - 1    \\n        else:\\n            start = middle + 1\\n    return answer\\ndef D2B(n):\\n    arr = []\\n    while (n > 0):\\n        temp = n; m = 0; p = 1\\n        while (temp):\\n            rem = temp % 10; temp = int(temp\\/10)\\n            if (rem != 0):\\n                m += p;\\n            p *= 10;\\n        arr.append(m); n = n - m;\\n    return arr\\ndef sort2D(arr,axis):\\n    arr = sorted(arr, key = lambda x:x[axis]); return arr\\ndef DD(rows,cols):\\n    arr = [[0 for i in range(cols)] for j in range(rows)]; return arr\\n\\n#----------------------------Manual Functions End----------------------------------------#\\n\\n# region fastio\\n\\nBUFSIZE = 8192\\n\\n\\nclass FastIO(IOBase):\\n    newlines = 0\\n\\n    def __init__(self, file):\\n        self._fd = file.fileno()\\n        self.buffer = BytesIO()\\n        self.writable = \\\"x\\\" in file.mode or \\\"r\\\" not in file.mode\\n        self.write = self.buffer.write if self.writable else None\\n\\n    def read(self):\\n        while True:\\n            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))\\n            if not b:\\n                break\\n            ptr = self.buffer.tell()\\n            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)\\n        self.newlines = 0\\n        return self.buffer.read()\\n\\n    def readline(self):\\n        while self.newlines == 0:\\n            b =...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"n towns are arranged in a circle sequentially. The towns are numbered from 1 to n in clockwise order. In the i-th town, there lives a singer with a repertoire of a_i minutes for each i \u2208 [1, n].\\n\\nEach singer visited all n towns in clockwise order, starting with the town he lives in, and gave exactly one concert in each town. In addition, in each town, the i-th singer got inspired and came up with a song that lasts a_i minutes. The song was added to his repertoire so that he could perform it in the rest of the cities.\\n\\nHence, for the i-th singer, the concert in the i-th town will last a_i minutes, in the (i + 1)-th town the concert will last 2 \u22c5 a_i minutes, ..., in the ((i + k) mod n + 1)-th town the duration of the concert will be (k + 2) \u22c5 a_i, ..., in the town ((i + n - 2) mod n + 1) \u2014 n \u22c5 a_i minutes.\\n\\nYou are given an array of b integer numbers, where b_i is the total duration of concerts in the i-th town. Reconstruct any correct sequence of positive integers a or say that it is impossible.\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 10^3) \u2014 the number of test cases. Then the test cases follow.\\n\\nEach test case consists of two lines. The first line contains a single integer n (1 \u2264 n \u2264 4 \u22c5 10^4) \u2014 the number of cities. The second line contains n integers b_1, b_2, ..., b_n (1 \u2264 b_i \u2264 10^{9}) \u2014 the total duration of concerts in i-th city.\\n\\nThe sum of n over all test cases does not exceed 2 \u22c5 10^5.\\n\\nOutput\\n\\nFor each test case, print the answer as follows:\\n\\nIf there is no suitable sequence a, print NO. Otherwise, on the first line print YES, on the next line print the sequence a_1, a_2, ..., a_n of n integers, where a_i (1 \u2264 a_i \u2264 10^{9}) is the initial duration of repertoire of the i-th singer. If there are multiple answers, print any of them.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n3\\n12 16 14\\n1\\n1\\n3\\n1 2 3\\n6\\n81 75 75 93 93 87\\n\\n\\nOutput\\n\\n\\nYES\\n3 1 3 \\nYES\\n1 \\nNO\\nYES\\n5 5 4 1 4 5 \\n\\nNote\\n\\nLet's consider the 1-st test case of the example:\\n\\n  1. the 1-st singer in the 1-st city will give a concert for 3 minutes, in the 2-nd \u2014...\\nUsing python3 can you solve the prior task?\",\"targets\":\"#Fast I\\/O\\nimport sys,os\\nimport math\\n# To enable the file I\\/O i the below 2 lines are uncommented.\\n# read from in.txt if uncommented\\nif os.path.exists('in.txt'): sys.stdin=open('in.txt','r')\\n# will print on Console if file I\\/O is not activated\\n#if os.path.exists('out.txt'): sys.stdout=open('out.txt', 'w')\\n \\n# inputs template\\nfrom io import BytesIO, IOBase\\nfrom heapq import *\\nfrom bisect import *\\nfrom collections import *\\n\\ndef main():\\n    for _ in range(mi()):\\n        n = mi()\\n        a = list(MI())\\n        ans = []\\n        s = sum(a)\\/(n*(n+1)\\/\\/2)\\n        if s%1 != 0 : print(\\\"NO\\\"); continue\\n        s = int(s)\\n        flag = 0\\n        for i in range(n):\\n            t = s + a[(i+n-1)%n] - a[i]\\n            if t <= 0 or (t\\/n)%1 !=0:flag =1 ; break\\n            ans.append(t\\/\\/n)\\n\\n        if flag:\\n            print(\\\"NO\\\")\\n        else:\\n            print(\\\"YES\\\")\\n            print(*ans)\\n\\n# Sample Inputs\\/Output \\n \\n# region fastio\\n \\nBUFSIZE = 8192\\n \\nclass FastIO(IOBase):\\n    newlines = 0\\n \\n    def __init__(self, file):\\n        self._fd = file.fileno()\\n        self.buffer = BytesIO()\\n        self.writable = \\\"x\\\" in file.mode or \\\"r\\\" not in file.mode\\n        self.write = self.buffer.write if self.writable else None\\n \\n    def read(self):\\n        while True:\\n            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))\\n            if not b:\\n                break\\n            ptr = self.buffer.tell()\\n            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)\\n        self.newlines = 0\\n        return self.buffer.read()\\n \\n    def readline(self):\\n        while self.newlines == 0:\\n            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))\\n            self.newlines = b.count(b\\\"\\\\n\\\") + (not b)\\n            ptr = self.buffer.tell()\\n            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)\\n        self.newlines -= 1\\n        return self.buffer.readline()\\n \\n    def flush(self):\\n        if self.writable:\\n            os.write(self._fd, self.buffer.getvalue())\\n           ...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Luntik came out for a morning stroll and found an array a of length n. He calculated the sum s of the elements of the array (s= \u2211_{i=1}^{n} a_i). Luntik calls a subsequence of the array a nearly full if the sum of the numbers in that subsequence is equal to s-1.\\n\\nLuntik really wants to know the number of nearly full subsequences of the array a. But he needs to come home so he asks you to solve that problem!\\n\\nA sequence x is a subsequence of a sequence y if x can be obtained from y by deletion of several (possibly, zero or all) elements.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 1000) \u2014 the number of test cases. The next 2 \u22c5 t lines contain descriptions of test cases. The description of each test case consists of two lines.\\n\\nThe first line of each test case contains a single integer n (1 \u2264 n \u2264 60) \u2014 the length of the array.\\n\\nThe second line contains n integers a_1, a_2, \u2026, a_n (0 \u2264 a_i \u2264 10^9) \u2014 the elements of the array a.\\n\\nOutput\\n\\nFor each test case print the number of nearly full subsequences of the array.\\n\\nExample\\n\\nInput\\n\\n\\n5\\n5\\n1 2 3 4 5\\n2\\n1000 1000\\n2\\n1 0\\n5\\n3 0 2 1 1\\n5\\n2 1 0 3 0\\n\\n\\nOutput\\n\\n\\n1\\n0\\n2\\n4\\n4\\n\\nNote\\n\\nIn the first test case, s=1+2+3+4+5=15, only (2,3,4,5) is a nearly full subsequence among all subsequences, the sum in it is equal to 2+3+4+5=14=15-1.\\n\\nIn the second test case, there are no nearly full subsequences.\\n\\nIn the third test case, s=1+0=1, the nearly full subsequences are (0) and () (the sum of an empty subsequence is 0).\\nSolve the task in JAVA.\",\"targets\":\"import java.util.*;\\nimport java.io.*;\\npublic class MyClass {\\n    public static long power(long a,long b) {\\n        if(b==0) {\\n            return 1;\\n        }\\n        long p = power(a,b\\/2);\\n        p*=p;\\n        if(b%2!=0) {\\n            p*=a;\\n        }\\n        return p;\\n    }\\n    public static void main(String args[]) throws IOException {\\n        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));\\n        int t = Integer.parseInt(br.readLine());\\n        while(t-->0) {\\n            int n = Integer.parseInt(br.readLine());\\n            String[] s = br.readLine().split(\\\" \\\");\\n            int[] a = new int[n];\\n            long sum=0;\\n            long ct0=0;\\n            long ct1=0;\\n            for(int i=0;i<n;i++) {\\n                a[i] = Integer.parseInt(s[i]);\\n                sum+=(long)a[i];\\n                if(a[i]==1) {\\n                    ct1++;\\n                }\\n                if(a[i]==0) {\\n                    ct0++;\\n                }\\n            }\\n            if(ct1==0) {\\n                System.out.println(\\\"0\\\");\\n            } else {\\n                if(sum==1) {\\n                    long ans = (long)1<<ct0;\\n                    System.out.println(ans);\\n                } else {\\n                    if(ct1==1) {\\n                        long ans = (long)1<<ct0;\\n                        System.out.println(ans);\\n                    } else {\\n                        long ans = (long)1<<ct0;\\n                        ans--;\\n                        ans*=ct1;\\n                        System.out.println(ans+ct1);\\n                    }\\n                }\\n            }\\n        }\\n    }\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in CPP?\\nYou are given an array of integers a of length n. The elements of the array can be either different or the same. \\n\\nEach element of the array is colored either blue or red. There are no unpainted elements in the array. One of the two operations described below can be applied to an array in a single step:\\n\\n  * either you can select any blue element and decrease its value by 1; \\n  * or you can select any red element and increase its value by 1. \\n\\n\\n\\nSituations in which there are no elements of some color at all are also possible. For example, if the whole array is colored blue or red, one of the operations becomes unavailable.\\n\\nDetermine whether it is possible to make 0 or more steps such that the resulting array is a permutation of numbers from 1 to n?\\n\\nIn other words, check whether there exists a sequence of steps (possibly empty) such that after applying it, the array a contains in some order all numbers from 1 to n (inclusive), each exactly once.\\n\\nInput\\n\\nThe first line contains an integer t (1 \u2264 t \u2264 10^4) \u2014 the number of input data sets in the test.\\n\\nThe description of each set of input data consists of three lines. The first line contains an integer n (1 \u2264 n \u2264 2 \u22c5 10^5) \u2014 the length of the original array a. The second line contains n integers a_1, a_2, ..., a_n (-10^9 \u2264 a_i \u2264 10^9) \u2014 the array elements themselves.\\n\\nThe third line has length n and consists exclusively of the letters 'B' and\\/or 'R': ith character is 'B' if a_i is colored blue, and is 'R' if colored red.\\n\\nIt is guaranteed that the sum of n over all input sets does not exceed 2 \u22c5 10^5.\\n\\nOutput\\n\\nPrint t lines, each of which contains the answer to the corresponding test case of the input. Print YES as an answer if the corresponding array can be transformed into a permutation, and NO otherwise.\\n\\nYou can print the answer in any case (for example, the strings yEs, yes, Yes, and YES will be recognized as a positive answer).\\n\\nExample\\n\\nInput\\n\\n\\n8\\n4\\n1 2 5 2\\nBRBR\\n2\\n1 1\\nBB\\n5\\n3 1 4 2 5\\nRBRRB\\n5\\n3 1 3 1 3\\nRBRRB\\n5\\n5 1 5 1 5\\nRBRRB\\n4\\n2 2 2 2\\nBRBR\\n2\\n1 -2\\nBR\\n4\\n-2...\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint main() {\\n  int t;\\n  cin >> t;\\n  while (t--) {\\n    int n;\\n    cin >> n;\\n    vector<int> a(n);\\n    for (int i = 0; i < n; i++) {\\n      cin >> a[i];\\n    }\\n    vector<int> b;\\n    vector<int> r;\\n    string s;\\n    cin >> s;\\n    for (int i = 0; i < n; i++) {\\n      char ch = s[i];\\n      if (ch == 'B') {\\n        b.push_back(a[i]);\\n      } else {\\n        r.push_back(a[i]);\\n      }\\n    }\\n    bool flg = true;\\n    sort(b.begin(), b.end());\\n    sort(r.begin(), r.end());\\n    cout << \\\"\\\\n\\\";\\n    int i = 0, j = 0, c = 1;\\n    while (i < b.size()) {\\n      if (b[i] < c) {\\n        flg = false;\\n        cout << \\\"NO\\\";\\n        break;\\n      }\\n      i++;\\n      c++;\\n    }\\n    while (j < r.size() && flg) {\\n      if (r[j] > c) {\\n        flg = false;\\n        cout << \\\"NO\\\";\\n        break;\\n      }\\n      j++;\\n      c++;\\n    }\\n    if (flg) {\\n      cout << \\\"YES\\\";\\n    }\\n  }\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You are given an array a consisting of n distinct elements and an integer k. Each element in the array is a non-negative integer not exceeding 2^k-1.\\n\\nLet's define the XOR distance for a number x as the value of \\n\\n$$$f(x) = min_{i = 1}^{n} min_{j = i + 1}^{n} |(a_i \u2295 x) - (a_j \u2295 x)|,$$$\\n\\nwhere \u2295 denotes [the bitwise XOR operation](https:\\/\\/en.wikipedia.org\\/wiki\\/Bitwise_operation#XOR).\\n\\nFor every integer x from 0 to 2^k-1, you have to calculate f(x).\\n\\nInput\\n\\nThe first line contains two integers n and k (1 \u2264 k \u2264 19; 2 \u2264 n \u2264 2^k).\\n\\nThe second line contains n integers a_1, a_2, ..., a_n (0 \u2264 a_i \u2264 2^k-1). All these integers are distinct.\\n\\nOutput\\n\\nPrint 2^k integers. The i-th of them should be equal to f(i-1).\\n\\nExamples\\n\\nInput\\n\\n\\n3 3\\n6 0 3\\n\\n\\nOutput\\n\\n\\n3 1 1 2 2 1 1 3 \\n\\n\\nInput\\n\\n\\n3 4\\n13 4 2\\n\\n\\nOutput\\n\\n\\n2 2 6 6 3 1 2 2 2 2 1 3 6 6 2 2 \\n\\nNote\\n\\nConsider the first example:\\n\\n  * for x = 0, if we apply bitwise XOR to the elements of the array with x, we get the array [6, 0, 3], and the minimum absolute difference of two elements is 3; \\n  * for x = 1, if we apply bitwise XOR to the elements of the array with x, we get the array [7, 1, 2], and the minimum absolute difference of two elements is 1; \\n  * for x = 2, if we apply bitwise XOR to the elements of the array with x, we get the array [4, 2, 1], and the minimum absolute difference of two elements is 1; \\n  * for x = 3, if we apply bitwise XOR to the elements of the array with x, we get the array [5, 3, 0], and the minimum absolute difference of two elements is 2; \\n  * for x = 4, if we apply bitwise XOR to the elements of the array with x, we get the array [2, 4, 7], and the minimum absolute difference of two elements is 2; \\n  * for x = 5, if we apply bitwise XOR to the elements of the array with x, we get the array [3, 5, 6], and the minimum absolute difference of two elements is 1; \\n  * for x = 6, if we apply bitwise XOR to the elements of the array with x, we get the array [0, 6, 5], and the minimum absolute difference of two elements is 1; \\n  * for x = 7, if we apply...\\nUsing cpp can you solve the prior task?\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint n, m, a[1000005], tans[22][1000005], b[1000005], c[1000005];\\nvoid solve(int k, int l, int r) {\\n  if (l >= r) return;\\n  int lim = (1 << (k - 1));\\n  for (int i = 0; i < (1 << k); i++) b[i] = -1e9, c[i] = 1e9;\\n  int mid = l - 1;\\n  while (mid < r && ((a[mid + 1] >> (k - 1)) & 1) == 0) mid++;\\n  int mn = max(0, lim - m), mx = min((1 << k) - 1, lim + m);\\n  for (int i = l; i <= r; i++) {\\n    int u = a[i] & ((1 << k) - 1);\\n    for (int j = mn; j < lim; j++) b[u ^ j] = max(b[u ^ j], j);\\n    for (int j = lim; j <= mx; j++) c[u ^ j] = min(c[u ^ j], j);\\n  }\\n  for (int i = 0; i < (1 << k); i++) tans[k][i] = min(tans[k][i], c[i] - b[i]);\\n  solve(k - 1, l, mid);\\n  solve(k - 1, mid + 1, r);\\n}\\nint k;\\nint main() {\\n  scanf(\\\"%d%d\\\", &n, &k);\\n  m = ((1 << k) - 1) \\/ (n - 1);\\n  for (int j = 1; j <= k; j++)\\n    for (int i = 0; i < (1 << j); i++) tans[j][i] = m;\\n  for (int i = 1; i <= n; i++) scanf(\\\"%d\\\", &a[i]);\\n  sort(a + 1, a + n + 1);\\n  solve(k, 1, n);\\n  for (int i = 0; i < (1 << k); i++) {\\n    int ans = 1e9;\\n    for (int j = 1; j <= k; j++) ans = min(ans, tans[j][i & ((1 << j) - 1)]);\\n    printf(\\\"%d \\\", ans);\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"PYTHON3 solution for \\\"A robot cleaner is placed on the floor of a rectangle room, surrounded by walls. The floor consists of n rows and m columns. The rows of the floor are numbered from 1 to n from top to bottom, and columns of the floor are numbered from 1 to m from left to right. The cell on the intersection of the r-th row and the c-th column is denoted as (r,c). The initial position of the robot is (r_b, c_b).\\n\\nIn one second, the robot moves by dr rows and dc columns, that is, after one second, the robot moves from the cell (r, c) to (r + dr, c + dc). Initially dr = 1, dc = 1. If there is a vertical wall (the left or the right walls) in the movement direction, dc is reflected before the movement, so the new value of dc is -dc. And if there is a horizontal wall (the upper or lower walls), dr is reflected before the movement, so the new value of dr is -dr.\\n\\nEach second (including the moment before the robot starts moving), the robot cleans every cell lying in the same row or the same column as its position. There is only one dirty cell at (r_d, c_d). The job of the robot is to clean that dirty cell.\\n\\n<image> Illustration for the first example. The blue arc is the robot. The red star is the target dirty cell. Each second the robot cleans a row and a column, denoted by yellow stripes.\\n\\nGiven the floor size n and m, the robot's initial position (r_b, c_b) and the dirty cell's position (r_d, c_d), find the time for the robot to do its job.\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 10^4). Description of the test cases follows.\\n\\nA test case consists of only one line, containing six integers n, m, r_b, c_b, r_d, and c_d (1 \u2264 n, m \u2264 100, 1 \u2264 r_b, r_d \u2264 n, 1 \u2264 c_b, c_d \u2264 m) \u2014 the sizes of the room, the initial position of the robot and the position of the dirt cell.\\n\\nOutput\\n\\nFor each test case, print an integer \u2014 the time for the robot to clean the dirty cell. We can show that the robot always cleans the dirty cell eventually.\\n\\nExample\\n\\nInput\\n\\n\\n5\\n10 10 6 1 2 8\\n10 10 9 9 1...\\\":\",\"targets\":\"n = int(input())\\n\\n\\ndef canClean(rn, cn, rd, cd):\\n    if (rn == rd or cn == cd):\\n        return True\\n    else:\\n        return False\\n\\n\\nli = []\\nfor _ in range(n):\\n    n, m, rn, cn, rd, cd = map(int, input().split())\\n    dx = 1\\n    dy = 1\\n    t = 0\\n    while(not canClean(rn, cn, rd, cd)):\\n        if (rn + dy > n or rn + dy < 1):\\n            dy *= -1\\n        if (cn + dx > m or cn + dx < 1):\\n            dx *= -1\\n        rn = rn + dy\\n        cn = cn + dx\\n        t += 1\\n    li.append(t)\\nfor i in li:\\n    print(i)\",\"language\":\"python\",\"split\":\"test\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Bob recently read about bitwise operations used in computers: AND, OR and XOR. He have studied their properties and invented a new game.\\n\\nInitially, Bob chooses integer m, bit depth of the game, which means that all numbers in the game will consist of m bits. Then he asks Peter to choose some m-bit number. After that, Bob computes the values of n variables. Each variable is assigned either a constant m-bit number or result of bitwise operation. Operands of the operation may be either variables defined before, or the number, chosen by Peter. After that, Peter's score equals to the sum of all variable values.\\n\\nBob wants to know, what number Peter needs to choose to get the minimum possible score, and what number he needs to choose to get the maximum possible score. In both cases, if there are several ways to get the same score, find the minimum number, which he can choose.\\n\\nInput\\n\\nThe first line contains two integers n and m, the number of variables and bit depth, respectively (1 \u2264 n \u2264 5000; 1 \u2264 m \u2264 1000). \\n\\nThe following n lines contain descriptions of the variables. Each line describes exactly one variable. Description has the following format: name of a new variable, space, sign \\\":=\\\", space, followed by one of:\\n\\n  1. Binary number of exactly m bits. \\n  2. The first operand, space, bitwise operation (\\\"AND\\\", \\\"OR\\\" or \\\"XOR\\\"), space, the second operand. Each operand is either the name of variable defined before or symbol '?', indicating the number chosen by Peter. \\n\\n\\n\\nVariable names are strings consisting of lowercase Latin letters with length at most 10. All variable names are different.\\n\\nOutput\\n\\nIn the first line output the minimum number that should be chosen by Peter, to make the sum of all variable values minimum possible, in the second line output the minimum number that should be chosen by Peter, to make the sum of all variable values maximum possible. Both numbers should be printed as m-bit binary numbers.\\n\\nExamples\\n\\nInput\\n\\n3 3\\na := 101\\nb := 011\\nc := ? XOR b\\n\\n\\nOutput\\n\\n011\\n100\\n\\n\\nInput\\n\\n5 1\\na := 1\\nbb :=...\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst int N = 5010, M = 1010;\\nmap<string, int> id;\\nint l = 0;\\nchar s[1010], s1[N][M], s2[N][M], op[N][20];\\nint a[N], b[N];\\nchar a1[M], a2[M];\\nint val[N];\\nint calc(char *s, int j, int d, int a) {\\n  if (s[0] == '?')\\n    return d;\\n  else if ('a' <= s[0] && s[0] <= 'z')\\n    return val[a];\\n  else\\n    return s[j] - '0';\\n}\\nint n, m;\\nint get(int j, int d) {\\n  int sum = 0;\\n  for (int i = 1; i <= n; i++) {\\n    int A = calc(s1[i], j, d, a[i]);\\n    if (!op[i][0])\\n      val[i] = A;\\n    else {\\n      int B = calc(s2[i], j, d, b[i]);\\n      if (op[i][0] == 'O')\\n        val[i] = A | B;\\n      else if (op[i][0] == 'X')\\n        val[i] = A ^ B;\\n      else if (op[i][0] == 'A')\\n        val[i] = A & B;\\n    }\\n    sum += val[i];\\n  }\\n  return sum;\\n}\\nint main() {\\n  scanf(\\\"%d%d\\\", &n, &m);\\n  scanf(\\\"%s\\\", s);\\n  for (int i = 1; i <= n; i++) {\\n    id[s] = i;\\n    scanf(\\\"%s\\\", s);\\n    scanf(\\\"%s\\\", s1[i]);\\n    if ('a' <= s1[i][0] && s1[i][0] <= 'z') a[i] = id[s1[i]];\\n    scanf(\\\"%s\\\", s);\\n    if ('A' <= s[0] && s[0] <= 'Z') {\\n      op[i][0] = s[0];\\n      scanf(\\\"%s\\\", s2[i]);\\n      if ('a' <= s2[i][0] && s2[i][0] <= 'z') b[i] = id[s2[i]];\\n      if (i < n) scanf(\\\"%s\\\", s);\\n    } else\\n      op[i][0] = 0;\\n  }\\n  for (int i = 0; i < m; i++) {\\n    int t1 = get(i, 0), t2 = get(i, 1);\\n    if (t1 == t2)\\n      a1[i] = a2[i] = '0';\\n    else if (t1 < t2)\\n      a1[i] = '0', a2[i] = '1';\\n    else\\n      a1[i] = '1', a2[i] = '0';\\n  }\\n  printf(\\\"%s\\\\n\\\", a1);\\n  printf(\\\"%s\\\\n\\\", a2);\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"It is the easy version of the problem. The difference is that in this version, there are no nodes with already chosen colors.\\n\\nTheofanis is starving, and he wants to eat his favorite food, sheftalia. However, he should first finish his homework. Can you help him with this problem?\\n\\nYou have a perfect binary tree of 2^k - 1 nodes \u2014 a binary tree where all vertices i from 1 to 2^{k - 1} - 1 have exactly two children: vertices 2i and 2i + 1. Vertices from 2^{k - 1} to 2^k - 1 don't have any children. You want to color its vertices with the 6 Rubik's cube colors (White, Green, Red, Blue, Orange and Yellow).\\n\\nLet's call a coloring good when all edges connect nodes with colors that are neighboring sides in the Rubik's cube.\\n\\n<image>| <image>  \\n---|---  \\nA picture of Rubik's cube and its 2D map.\\n\\nMore formally: \\n\\n  * a white node can not be neighboring with white and yellow nodes; \\n  * a yellow node can not be neighboring with white and yellow nodes; \\n  * a green node can not be neighboring with green and blue nodes; \\n  * a blue node can not be neighboring with green and blue nodes; \\n  * a red node can not be neighboring with red and orange nodes; \\n  * an orange node can not be neighboring with red and orange nodes; \\n\\n\\n\\nYou want to calculate the number of the good colorings of the binary tree. Two colorings are considered different if at least one node is colored with a different color.\\n\\nThe answer may be too large, so output the answer modulo 10^9+7.\\n\\nInput\\n\\nThe first and only line contains the integers k (1 \u2264 k \u2264 60) \u2014 the number of levels in the perfect binary tree you need to color.\\n\\nOutput\\n\\nPrint one integer \u2014 the number of the different colorings modulo 10^9+7.\\n\\nExamples\\n\\nInput\\n\\n\\n3\\n\\n\\nOutput\\n\\n\\n24576\\n\\n\\nInput\\n\\n\\n14\\n\\n\\nOutput\\n\\n\\n934234\\n\\nNote\\n\\nIn the picture below, you can see one of the correct colorings of the first example.\\n\\n<image>\\n\\\"\\\"\\\"\",\"targets\":\"Author : Ashish Sasmal\\n    Python3 \\/ PyPy3\\n\\\"\\\"\\\"\\n\\nfrom sys import stdin as sin\\ndef aint():return int(input())\\ndef amap():return map(int,sin.readline().split())\\ndef alist():return list(map(int,sin.readline().split()))\\ndef astr():return input()\\n\\n#https:\\/\\/stackoverflow.com\\/questions\\/29452478\\/fastest-method-to-calculate-2n-mod-m-where-n-and-m-are-random-integers\\n\\ndef rec(n, m):\\n    g = 4\\n    ans = 1\\n    while n > 0:\\n        if n % 2 == 1:\\n            ans = (ans * g) % m\\n        g = (g * g) % m\\n        n >>= 1\\n    return ans\\n\\nmod = 10**9 + 7\\n\\nn = aint()\\nif n==1:\\n    print(6)\\nelse:\\n    ans = rec(2**n - 2, 10**9 + 7)\\n    ans = ans*6\\n    print(ans%(10**9 + 7))\\n    # print((4**(2**n - 2)*6)%mod)\",\"language\":\"python\",\"split\":\"test\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Alice has a cute cat. To keep her cat fit, Alice wants to design an exercising walk for her cat! \\n\\nInitially, Alice's cat is located in a cell (x,y) of an infinite grid. According to Alice's theory, cat needs to move: \\n\\n  * exactly a steps left: from (u,v) to (u-1,v); \\n  * exactly b steps right: from (u,v) to (u+1,v); \\n  * exactly c steps down: from (u,v) to (u,v-1); \\n  * exactly d steps up: from (u,v) to (u,v+1). \\n\\n\\n\\nNote that the moves can be performed in an arbitrary order. For example, if the cat has to move 1 step left, 3 steps right and 2 steps down, then the walk right, down, left, right, right, down is valid.\\n\\nAlice, however, is worrying that her cat might get lost if it moves far away from her. So she hopes that her cat is always in the area [x_1,x_2]\u00d7 [y_1,y_2], i.e. for every cat's position (u,v) of a walk x_1 \u2264 u \u2264 x_2 and y_1 \u2264 v \u2264 y_2 holds.\\n\\nAlso, note that the cat can visit the same cell multiple times.\\n\\nCan you help Alice find out if there exists a walk satisfying her wishes?\\n\\nFormally, the walk should contain exactly a+b+c+d unit moves (a to the left, b to the right, c to the down, d to the up). Alice can do the moves in any order. Her current position (u, v) should always satisfy the constraints: x_1 \u2264 u \u2264 x_2, y_1 \u2264 v \u2264 y_2. The staring point is (x, y).\\n\\nYou are required to answer t test cases independently.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 10^3) \u2014 the number of testcases. \\n\\nThe first line of each test case contains four integers a, b, c, d (0 \u2264 a,b,c,d \u2264 10^8, a+b+c+d \u2265 1).\\n\\nThe second line of the test case contains six integers x, y, x_1, y_1, x_2, y_2 (-10^8 \u2264 x_1\u2264 x \u2264 x_2 \u2264 10^8, -10^8 \u2264 y_1 \u2264 y \u2264 y_2 \u2264 10^8).\\n\\nOutput\\n\\nFor each test case, output \\\"YES\\\" in a separate line, if there exists a walk satisfying her wishes. Otherwise, output \\\"NO\\\" in a separate line. \\n\\nYou can print each letter in any case (upper or lower).\\n\\nExample\\n\\nInput\\n\\n\\n6\\n3 2 2 2\\n0 0 -2 -2 2 2\\n3 1 4 1\\n0 0 -1 -1 1 1\\n1 1 1 1\\n1 1 1 1 1 1\\n0 0 0 1\\n0 0 0 0 0 1\\n5 1 1 1\\n0 0 -100 -100 0 100\\n1 1 5 1\\n0 0...\\nThe above is tricky. Write me a correct solution in PYTHON3.\",\"targets\":\"q = int(input())\\nfor t in range(q):\\n    a, b, c, d = list(map(int, input().split()))\\n    x, y, x1, y1, x2, y2 = list(map(int, input().split()))\\n    if x1 == x2 and (a > 0 or b > 0):\\n        print(\\\"No\\\")\\n        continue\\n    if a < b:\\n        if b - a > x2 - x:\\n            print(\\\"No\\\")\\n            continue\\n    else:\\n        if a - b > x - x1:\\n            print(\\\"No\\\")\\n            continue\\n    if y1 == y2 and (c > 0 or d > 0):\\n        print(\\\"No\\\")\\n        continue\\n    if c < d:\\n        if d - c > y2 - y:\\n            print(\\\"No\\\")\\n            continue\\n    else:\\n        if c - d > y - y1:\\n            print(\\\"No\\\")\\n            continue\\n    print(\\\"Yes\\\")\",\"language\":\"python\",\"split\":\"train\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in CPP?\\nAlice gave Bob two integers a and b (a > 0 and b \u2265 0). Being a curious boy, Bob wrote down an array of non-negative integers with \\\\operatorname{MEX} value of all elements equal to a and \\\\operatorname{XOR} value of all elements equal to b.\\n\\nWhat is the shortest possible length of the array Bob wrote?\\n\\nRecall that the \\\\operatorname{MEX} (Minimum EXcluded) of an array is the minimum non-negative integer that does not belong to the array and the \\\\operatorname{XOR} of an array is the [bitwise XOR](https:\\/\\/en.wikipedia.org\\/wiki\\/Bitwise_operation#XOR) of all the elements of the array.\\n\\nInput\\n\\nThe input consists of multiple test cases. The first line contains an integer t (1 \u2264 t \u2264 5 \u22c5 10^4) \u2014 the number of test cases. The description of the test cases follows.\\n\\nThe only line of each test case contains two integers a and b (1 \u2264 a \u2264 3 \u22c5 10^5; 0 \u2264 b \u2264 3 \u22c5 10^5) \u2014 the \\\\operatorname{MEX} and \\\\operatorname{XOR} of the array, respectively.\\n\\nOutput\\n\\nFor each test case, output one (positive) integer \u2014 the length of the shortest array with \\\\operatorname{MEX} a and \\\\operatorname{XOR} b. We can show that such an array always exists.\\n\\nExample\\n\\nInput\\n\\n\\n5\\n1 1\\n2 1\\n2 0\\n1 10000\\n2 10000\\n\\n\\nOutput\\n\\n\\n3\\n2\\n3\\n2\\n3\\n\\nNote\\n\\nIn the first test case, one of the shortest arrays with \\\\operatorname{MEX} 1 and \\\\operatorname{XOR} 1 is [0, 2020, 2021].\\n\\nIn the second test case, one of the shortest arrays with \\\\operatorname{MEX} 2 and \\\\operatorname{XOR} 1 is [0, 1].\\n\\nIt can be shown that these arrays are the shortest arrays possible.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint xorr[300005];\\nvoid solve() {\\n  int a, b;\\n  cin >> a >> b;\\n  if (xorr[a - 1] == b)\\n    cout << a << \\\"\\\\n\\\";\\n  else\\n    cout << ((xorr[a - 1] ^ b) == a ? a + 2 : a + 1) << \\\"\\\\n\\\";\\n}\\nvoid _pre() {\\n  xorr[0] = 0;\\n  for (int i = 1; i <= 300000; i++) xorr[i] = i ^ xorr[i - 1];\\n}\\nint main() {\\n  _pre();\\n  int _ = 1;\\n  cin >> _;\\n  for (int t = 1; t <= _; t++) {\\n    solve();\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"A number is called almost prime if it has exactly two distinct prime divisors. For example, numbers 6, 18, 24 are almost prime, while 4, 8, 9, 42 are not. Find the amount of almost prime numbers which are between 1 and n, inclusive.\\n\\nInput\\n\\nInput contains one integer number n (1 \u2264 n \u2264 3000).\\n\\nOutput\\n\\nOutput the amount of almost prime numbers between 1 and n, inclusive.\\n\\nExamples\\n\\nInput\\n\\n10\\n\\n\\nOutput\\n\\n2\\n\\n\\nInput\\n\\n21\\n\\n\\nOutput\\n\\n8\\nimpor\",\"targets\":\"t math\\n\\n\\ndef is_prime(n):\\n    if n == 2:\\n        return True\\n    if n < 2 or n % 2 == 0:\\n        return False\\n    limiter = math.isqrt(n)\\n    for i in range(3, limiter + 1, 2):\\n        if n % i == 0:\\n            return False\\n    return True\\n\\n\\ndef two_prime_divs(n):\\n    counter = 0\\n    for i in range(2, n \\/\\/ 2 + 1):\\n        if n % i == 0 and is_prime(i):\\n            counter += 1\\n    return counter == 2\\n\\n\\nn, ans = int(input()), 0\\n\\nfor i in range(6, n + 1):\\n    # if two_prime_divs(i):\\n    #   ans += 1\\n    ans += two_prime_divs(i)\\n\\nprint(ans)\",\"language\":\"python\",\"split\":\"train\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Given a positive integer n. Find three distinct positive integers a, b, c such that a + b + c = n and \\\\operatorname{gcd}(a, b) = c, where \\\\operatorname{gcd}(x, y) denotes the [greatest common divisor (GCD)](https:\\/\\/en.wikipedia.org\\/wiki\\/Greatest_common_divisor) of integers x and y.\\n\\nInput\\n\\nThe input consists of multiple test cases. The first line contains a single integer t (1 \u2264 t \u2264 10^5) \u2014 the number of test cases. Description of the test cases follows.\\n\\nThe first and only line of each test case contains a single integer n (10 \u2264 n \u2264 10^9).\\n\\nOutput\\n\\nFor each test case, output three distinct positive integers a, b, c satisfying the requirements. If there are multiple solutions, you can print any. We can show that an answer always exists.\\n\\nExample\\n\\nInput\\n\\n\\n6\\n18\\n63\\n73\\n91\\n438\\n122690412\\n\\n\\nOutput\\n\\n\\n6 9 3\\n21 39 3\\n29 43 1\\n49 35 7\\n146 219 73\\n28622 122661788 2\\n\\nNote\\n\\nIn the first test case, 6 + 9 + 3 = 18 and \\\\operatorname{gcd}(6, 9) = 3.\\n\\nIn the second test case, 21 + 39 + 3 = 63 and \\\\operatorname{gcd}(21, 39) = 3.\\n\\nIn the third test case, 29 + 43 + 1 = 73 and \\\\operatorname{gcd}(29, 43) = 1.\\nUsing python3 can you solve the prior task?\",\"targets\":\"for _ in range(int(input())):\\n    n=int(input())\\n    if not n%2:\\n        print(n-3,2,1)\\n    else:\\n        z=n\\/\\/2\\n        if z%2:\\n            print(z-2,z+2,1)\\n        else:\\n            print(z-1,z+1,1)\",\"language\":\"python\",\"split\":\"test\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Chanek Jones is back, helping his long-lost relative Indiana Jones, to find a secret treasure in a maze buried below a desert full of illusions.\\n\\nThe map of the labyrinth forms a tree with n rooms numbered from 1 to n and n - 1 tunnels connecting them such that it is possible to travel between each pair of rooms through several tunnels.\\n\\nThe i-th room (1 \u2264 i \u2264 n) has a_i illusion rate. To go from the x-th room to the y-th room, there must exist a tunnel between x and y, and it takes max(|a_x + a_y|, |a_x - a_y|) energy. |z| denotes the absolute value of z.\\n\\nTo prevent grave robbers, the maze can change the illusion rate of any room in it. Chanek and Indiana would ask q queries.\\n\\nThere are two types of queries to be done:\\n\\n  * 1\\\\ u\\\\ c \u2014 The illusion rate of the x-th room is changed to c (1 \u2264 u \u2264 n, 0 \u2264 |c| \u2264 10^9). \\n  * 2\\\\ u\\\\ v \u2014 Chanek and Indiana ask you the minimum sum of energy needed to take the secret treasure at room v if they are initially at room u (1 \u2264 u, v \u2264 n). \\n\\n\\n\\nHelp them, so you can get a portion of the treasure!\\n\\nInput\\n\\nThe first line contains two integers n and q (2 \u2264 n \u2264 10^5, 1 \u2264 q \u2264 10^5) \u2014 the number of rooms in the maze and the number of queries.\\n\\nThe second line contains n integers a_1, a_2, \u2026, a_n (0 \u2264 |a_i| \u2264 10^9) \u2014 inital illusion rate of each room.\\n\\nThe i-th of the next n-1 lines contains two integers s_i and t_i (1 \u2264 s_i, t_i \u2264 n), meaning there is a tunnel connecting s_i-th room and t_i-th room. The given edges form a tree.\\n\\nThe next q lines contain the query as described. The given queries are valid.\\n\\nOutput\\n\\nFor each type 2 query, output a line containing an integer \u2014 the minimum sum of energy needed for Chanek and Indiana to take the secret treasure.\\n\\nExample\\n\\nInput\\n\\n\\n6 4\\n10 -9 2 -1 4 -6\\n1 5\\n5 4\\n5 6\\n6 2\\n6 3\\n2 1 2\\n1 1 -3\\n2 1 2\\n2 3 3\\n\\n\\nOutput\\n\\n\\n39\\n32\\n0\\n\\nNote\\n\\n<image>\\n\\nIn the first query, their movement from the 1-st to the 2-nd room is as follows.\\n\\n  * 1 \u2192 5 \u2014 takes max(|10 + 4|, |10 - 4|) = 14 energy. \\n  * 5 \u2192 6 \u2014 takes max(|4 + (-6)|, |4 - (-6)|) = 10 energy. \\n  * 6 \u2192 2 \u2014...\\nSolve the task in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nmt19937 rnd(time(0));\\nconst bool hld_type = 0;\\nconst int N = 1e5 + 10;\\nconst int L = 20;\\nconst long long good_value = 0;\\nlong long merge(long long a, long long b) { return a + b; }\\nstruct segment_tree {\\n  long long t[2 * N + 5];\\n  void build() {\\n    for (int i = N - 1; i > 0; i--) {\\n      t[i] = merge(t[i << 1], t[i << 1 | 1]);\\n    }\\n  }\\n  void update(int pos, long long val) {\\n    for (t[pos += N] = val; pos > 1; pos >>= 1) {\\n      t[pos >> 1] = merge(t[pos], t[pos ^ 1]);\\n    }\\n  }\\n  long long get(int l, int r) {\\n    long long res = good_value;\\n    for (l += N, r += N; l <= r; l >>= 1, r >>= 1) {\\n      if (l & 1) res = merge(res, t[l++]);\\n      if (!(r & 1)) res = merge(res, t[r--]);\\n    }\\n    return res;\\n  }\\n} tree;\\nint timer, tree_ptr;\\nvector<int> g[N];\\nint in[N], out[N];\\nint up[N][L], down[N];\\nint sz[N], depth[N];\\nint start[N], st_ptr;\\nint path_st[N], pos[N];\\nbool is_heavy(int v, int to) { return sz[to] >= (sz[v] + 1) \\/ 2; }\\nvoid dfs_hld(int v = 1, int p = 1) {\\n  in[v] = ++timer;\\n  up[v][0] = p;\\n  for (int i = 1; i < L; i++) {\\n    up[v][i] = up[up[v][i - 1]][i - 1];\\n  }\\n  sz[v] = 1;\\n  for (int to : g[v]) {\\n    if (to != p) {\\n      depth[to] = depth[v] + 1;\\n      dfs_hld(to, v);\\n      sz[v] += sz[to];\\n    }\\n  }\\n  bool light = 1;\\n  for (int to : g[v]) {\\n    if (to != p && is_heavy(v, to)) {\\n      light = 0;\\n      break;\\n    }\\n  }\\n  if (light) {\\n    start[st_ptr++] = v;\\n  }\\n  out[v] = ++timer;\\n}\\nbool is_anc(int u, int v) { return in[u] <= in[v] && in[v] <= out[u]; }\\nint lca(int u, int v) {\\n  if (is_anc(u, v))\\n    return u;\\n  else if (is_anc(v, u))\\n    return v;\\n  for (int i = L - 1; i >= 0; i--) {\\n    if (!is_anc(up[u][i], v)) u = up[u][i];\\n  }\\n  return up[u][0];\\n}\\nint dist(int u, int v) { return depth[u] + depth[v] - 2 * depth[lca(u, v)]; }\\nvoid heavy_light_decomposition(int root = 1) {\\n  int mem = st_ptr;\\n  dfs_hld(root, root);\\n  for (int i = mem; i < st_ptr; i++) {\\n    int v = start[i];\\n    while (v != root && is_heavy(up[v][0], v)) {\\n      down[up[v][0]] = v;\\n...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Boboniu gives you\\n\\n  * r red balls, \\n  * g green balls, \\n  * b blue balls, \\n  * w white balls. \\n\\n\\n\\nHe allows you to do the following operation as many times as you want: \\n\\n  * Pick a red ball, a green ball, and a blue ball and then change their color to white. \\n\\n\\n\\nYou should answer if it's possible to arrange all the balls into a palindrome after several (possibly zero) number of described operations. \\n\\nInput\\n\\nThe first line contains one integer T (1\u2264 T\u2264 100) denoting the number of test cases.\\n\\nFor each of the next T cases, the first line contains four integers r, g, b and w (0\u2264 r,g,b,w\u2264 10^9).\\n\\nOutput\\n\\nFor each test case, print \\\"Yes\\\" if it's possible to arrange all the balls into a palindrome after doing several (possibly zero) number of described operations. Otherwise, print \\\"No\\\".\\n\\nExample\\n\\nInput\\n\\n\\n4\\n0 1 1 1\\n8 1 9 3\\n0 0 0 0\\n1000000000 1000000000 1000000000 1000000000\\n\\n\\nOutput\\n\\n\\nNo\\nYes\\nYes\\nYes\\n\\nNote\\n\\nIn the first test case, you're not able to do any operation and you can never arrange three balls of distinct colors into a palindrome.\\n\\nIn the second test case, after doing one operation, changing (8,1,9,3) to (7,0,8,6), one of those possible palindromes may be \\\"rrrwwwbbbbrbbbbwwwrrr\\\".\\n\\nA palindrome is a word, phrase, or sequence that reads the same backwards as forwards. For example, \\\"rggbwbggr\\\", \\\"b\\\", \\\"gg\\\" are palindromes while \\\"rgbb\\\", \\\"gbbgr\\\" are not. Notice that an empty word, phrase, or sequence is palindrome.\\nSolve the task in PYTHON3.\",\"targets\":\"for i in range(int(input())):\\n    r,g,b,w=map(int,input().split())\\n    if r%2+g%2+b%2+w%2<=1:\\n        print(\\\"Yes\\\")\\n    elif (r>0 and g>0 and b>0) and ((r-1)%2+(g-1)%2+(b-1)%2+(w+1)%2<=1):\\n        print(\\\"Yes\\\")\\n    else:\\n        print(\\\"No\\\")\",\"language\":\"python\",\"split\":\"train\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"PYTHON3 solution for \\\"A binary string is a string that consists of characters 0 and 1.\\n\\nLet \\\\operatorname{MEX} of a binary string be the smallest digit among 0, 1, or 2 that does not occur in the string. For example, \\\\operatorname{MEX} of 001011 is 2, because 0 and 1 occur in the string at least once, \\\\operatorname{MEX} of 1111 is 0, because 0 and 2 do not occur in the string and 0 < 2.\\n\\nA binary string s is given. You should cut it into any number of substrings such that each character is in exactly one substring. It is possible to cut the string into a single substring \u2014 the whole string.\\n\\nA string a is a substring of a string b if a can be obtained from b by deletion of several (possibly, zero or all) characters from the beginning and several (possibly, zero or all) characters from the end.\\n\\nWhat is the minimal sum of \\\\operatorname{MEX} of all substrings pieces can be?\\n\\nInput\\n\\nThe input consists of multiple test cases. The first line contains a single integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases. Description of the test cases follows.\\n\\nEach test case contains a single binary string s (1 \u2264 |s| \u2264 10^5).\\n\\nIt's guaranteed that the sum of lengths of s over all test cases does not exceed 10^5.\\n\\nOutput\\n\\nFor each test case print a single integer \u2014 the minimal sum of \\\\operatorname{MEX} of all substrings that it is possible to get by cutting s optimally.\\n\\nExample\\n\\nInput\\n\\n\\n6\\n01\\n1111\\n01100\\n101\\n0000\\n01010\\n\\n\\nOutput\\n\\n\\n1\\n0\\n2\\n1\\n1\\n2\\n\\nNote\\n\\nIn the first test case the minimal sum is \\\\operatorname{MEX}(0) + \\\\operatorname{MEX}(1) = 1 + 0 = 1.\\n\\nIn the second test case the minimal sum is \\\\operatorname{MEX}(1111) = 0.\\n\\nIn the third test case the minimal sum is \\\\operatorname{MEX}(01100) = 2.\\\":\",\"targets\":\"MEX=lambda s: 0 if '0'not in s else 1 if '1'not in s else 2 if '2'not in s else 3\\n\\nfor s in[*open(0)][1:]:\\n    S = 0\\n    is_zero = False\\n    for c in s.strip():\\n        if c == '0':\\n            if is_zero:\\n                # Keep taking '0'\\n                continue\\n            else:\\n                is_zero = True\\n        else:\\n            if is_zero:\\n                S += 1\\n                is_zero = False\\n            else:\\n                continue\\n    if is_zero:\\n        S += 1\\n    print(min(S, MEX(s)))\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"There is a chessboard of size n by n. The square in the i-th row from top and j-th column from the left is labelled (i,j).\\n\\nCurrently, Gregor has some pawns in the n-th row. There are also enemy pawns in the 1-st row. On one turn, Gregor moves one of his pawns. A pawn can move one square up (from (i,j) to (i-1,j)) if there is no pawn in the destination square. Additionally, a pawn can move one square diagonally up (from (i,j) to either (i-1,j-1) or (i-1,j+1)) if and only if there is an enemy pawn in that square. The enemy pawn is also removed.\\n\\nGregor wants to know what is the maximum number of his pawns that can reach row 1?\\n\\nNote that only Gregor takes turns in this game, and the enemy pawns never move. Also, when Gregor's pawn reaches row 1, it is stuck and cannot make any further moves.\\n\\nInput\\n\\nThe first line of the input contains one integer t (1\u2264 t\u2264 2\u22c5 10^4) \u2014 the number of test cases. Then t test cases follow.\\n\\nEach test case consists of three lines. The first line contains a single integer n (2\u2264 n\u2264 2\u22c5{10}^{5}) \u2014 the size of the chessboard.\\n\\nThe second line consists of a string of binary digits of length n, where a 1 in the i-th position corresponds to an enemy pawn in the i-th cell from the left, and 0 corresponds to an empty cell.\\n\\nThe third line consists of a string of binary digits of length n, where a 1 in the i-th position corresponds to a Gregor's pawn in the i-th cell from the left, and 0 corresponds to an empty cell.\\n\\nIt is guaranteed that the sum of n across all test cases is less than 2\u22c5{10}^{5}.\\n\\nOutput\\n\\nFor each test case, print one integer: the maximum number of Gregor's pawns which can reach the 1-st row.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n3\\n000\\n111\\n4\\n1111\\n1111\\n3\\n010\\n010\\n5\\n11001\\n00000\\n\\n\\nOutput\\n\\n\\n3\\n4\\n0\\n0\\n\\nNote\\n\\nIn the first example, Gregor can simply advance all 3 of his pawns forward. Thus, the answer is 3.\\n\\nIn the second example, Gregor can guarantee that all 4 of his pawns reach the enemy row, by following the colored paths as demonstrated in the diagram below. Remember, only Gregor takes turns in...\\nUsing java can you solve the prior task?\",\"targets\":\"r=readline;s=()=>r().split(\\\"\\\");for(r();n=r();print(c)){c=0;b=s();a=s()\\nwhile(n--)a[n]&1?!-b[n]||b[n+1]&1?++c:b[n-1]++&1?++c:b[n-1]--:0}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"Fast Forwarding\\n\\nMr. Anderson frequently rents video tapes of his favorite classic films. Watching the films so many times, he has learned the precise start times of his favorite scenes in all such films. He now wants to find how to wind the tape to watch his favorite scene as quickly as possible on his video player.\\n\\nWhen the [play] button is pressed, the film starts at the normal playback speed. The video player has two buttons to control the playback speed: The [3x] button triples the speed, while the [1\\/3x] button reduces the speed to one third. These speed control buttons, however, do not take effect on the instance they are pressed. Exactly one second after playback starts and every second thereafter, the states of these speed control buttons are checked. If the [3x] button is pressed on the timing of the check, the playback speed becomes three times the current speed. If the [1\\/3x] button is pressed, the playback speed becomes one third of the current speed, unless it is already the normal speed.\\n\\nFor instance, assume that his favorite scene starts at 19 seconds from the start of the film. When the [3x] button is on at one second and at two seconds after the playback starts, and the [1\\/3x] button is on at three seconds and at five seconds after the start, the desired scene can be watched in the normal speed five seconds after starting the playback, as depicted in the following chart.\\n\\n<image>\\n\\nYour task is to compute the shortest possible time period after the playback starts until the desired scene starts. The playback of the scene, of course, should be in the normal speed.\\n\\nInput\\n\\nThe input consists of a single test case of the following format.\\n\\n\\n$t$\\n\\n\\nThe given single integer $t$ ($0 \\\\leq t < 2^{50}$) is the start time of the target scene.\\n\\nOutput\\n\\nPrint an integer that is the minimum possible time in seconds before he can start watching the target scene in the normal speed.\\n\\nSample Input 1\\n\\n\\n19\\n\\n\\nSample Output 1\\n\\n\\n5\\n\\n\\nSample Input 2\\n\\n\\n13\\n\\n\\nSample Output 2\\n\\n\\n5\\n\\n\\nSample Input...\\\":\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\ntypedef long long ll;\\n#define P pair<ll,ll>\\n#define FOR(I,A,B) for(ll I = ll(A); I < ll(B); ++I)\\n#define FORR(I,A,B) for(ll I = ll((B)-1); I >= ll(A); --I)\\n#define TO(x,t,f) ((x)?(t):(f))\\n#define SORT(x) (sort(x.begin(),x.end())) \\/\\/ 0 2 2 3 4 5 8 9\\n#define POSL(x,v) (lower_bound(x.begin(),x.end(),v)-x.begin()) \\/\\/xi>=v  x is sorted\\n#define POSU(x,v) (upper_bound(x.begin(),x.end(),v)-x.begin()) \\/\\/xi>v  x is sorted\\n#define NUM(x,v) (POSU(x,v)-POSL(x,v))  \\/\\/x is sorted\\n#define REV(x) (reverse(x.begin(),x.end())) \\/\\/reverse\\nll gcd(ll a,ll b){if(a%b==0)return b;return gcd(b,a%b);}\\nll lcm(ll a,ll b){ll c=gcd(a,b);return ((a\\/c)*(b\\/c)*c);}\\n#define NEXTP(x) next_permutation(x.begin(),x.end())\\nconst ll INF=ll(1e18)+ll(7);\\nconst ll MOD=1000000007LL;\\n\\nvector<ll> three;\\nll calc(ll T,ll V){\\n\\tif(T==0)return 0;\\n\\tll ans=0;\\n\\tif(T-V*4>=0){\\n\\t\\tans = 2 + calc(T-V*4,V*3);\\n\\t}else if(T==V){\\n\\t\\tans = 1;\\n\\t}else{\\n\\t\\tint ind = upper_bound(three.begin(),three.end(),T)-three.begin();\\n\\t\\tind--;\\n\\t\\tif(three[ind]>V)ans = 1+calc(T-V,V);\\n\\t\\telse ans = 1 + calc(T-three[ind],V);\\n\\t}\\n\\treturn ans;\\n}\\n\\n\\nint main(){\\n\\tll t,ans=0;\\n\\tcin >> t;\\n\\tans = t;\\n\\tll th = 1;\\n\\tFOR(i,0,34){\\n\\t\\tthree.push_back(th);\\n\\t\\tth*=3;\\n\\t}\\n\\tif(t==4) ans=2;\\n\\tif(t>=5)ans = min(ans,calc(t-4,3)+2);\\n\\tcout << ans << endl;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"During the lesson small girl Alyona works with one famous spreadsheet computer program and learns how to edit tables.\\n\\nNow she has a table filled with integers. The table consists of n rows and m columns. By ai, j we will denote the integer located at the i-th row and the j-th column. We say that the table is sorted in non-decreasing order in the column j if ai, j \u2264 ai + 1, j for all i from 1 to n - 1.\\n\\nTeacher gave Alyona k tasks. For each of the tasks two integers l and r are given and Alyona has to answer the following question: if one keeps the rows from l to r inclusive and deletes all others, will the table be sorted in non-decreasing order in at least one column? Formally, does there exist such j that ai, j \u2264 ai + 1, j for all i from l to r - 1 inclusive.\\n\\nAlyona is too small to deal with this task and asks you to help!\\n\\nInput\\n\\nThe first line of the input contains two positive integers n and m (1 \u2264 n\u00b7m \u2264 100 000) \u2014 the number of rows and the number of columns in the table respectively. Note that your are given a constraint that bound the product of these two integers, i.e. the number of elements in the table.\\n\\nEach of the following n lines contains m integers. The j-th integers in the i of these lines stands for ai, j (1 \u2264 ai, j \u2264 109).\\n\\nThe next line of the input contains an integer k (1 \u2264 k \u2264 100 000) \u2014 the number of task that teacher gave to Alyona.\\n\\nThe i-th of the next k lines contains two integers li and ri (1 \u2264 li \u2264 ri \u2264 n).\\n\\nOutput\\n\\nPrint \\\"Yes\\\" to the i-th line of the output if the table consisting of rows from li to ri inclusive is sorted in non-decreasing order in at least one column. Otherwise, print \\\"No\\\".\\n\\nExample\\n\\nInput\\n\\n5 4\\n1 2 3 5\\n3 1 3 2\\n4 5 2 3\\n5 5 3 2\\n4 4 3 4\\n6\\n1 1\\n2 5\\n4 5\\n3 5\\n1 3\\n1 5\\n\\n\\nOutput\\n\\nYes\\nNo\\nYes\\nYes\\nYes\\nNo\\n\\nNote\\n\\nIn the sample, the whole table is not sorted in any column. However, rows 1\u20133 are sorted in column 1, while rows 4\u20135 are sorted in column 3.\\nThe above is tricky. Write me a correct solution in JAVA.\",\"targets\":\"import java.util.*;\\nimport java.io.*;\\n\\npublic class C\\n{\\n\\n    Reader in;\\n    PrintWriter out;\\n    int i = 0, j = 0;\\n    void solve()\\n    {\\n        \\n        \\/\\/START\\/\\/\\n        int r = in.nextInt(), c = in.nextInt();\\n        int[][] arr = new int[r][c];\\n        int[][] min = new int[r][c];\\n        for (i = 0; i < r; i++)\\n        {\\n            for (j = 0; j < c; j++)\\n            {\\n                arr[i][j] = in.nextInt();\\n            }\\n        }\\n        int[] mins = new int[r];\\n        for (i = 1; i < r; i++)\\n        {\\n            mins[i] = i;\\n            for (j = 0; j < c; j++)\\n            {\\n                if (arr[i][j] >= arr[i-1][j])\\n                {\\n                    min[i][j] = min[i-1][j];\\n                    mins[i] = Math.min(mins[i], min[i][j]);\\n                }\\n                else\\n                {\\n                    min[i][j] = i;\\n                }\\n            }\\n        }\\n        int k = in.nextInt();\\n        for (i = 0; i < k; i++)\\n        {\\n            int left = in.nextInt()-1, right = in.nextInt()-1;\\n            if (mins[right] <= left)\\n            {\\n                out.println(\\\"Yes\\\");\\n            }\\n            else\\n            {\\n                out.println(\\\"No\\\");\\n            }\\n\\n        }\\n        \\n\\n        \\n\\n\\n\\n\\n\\n\\n\\n        \\/\\/END\\n        \\n    }\\n    void runIO()\\n    {\\n        in = new Reader();\\n        out = new PrintWriter(System.out, false);\\n        solve();\\n        out.close();\\n    }\\n\\n    public static void main(String[] args)\\n    {\\n        new C().runIO();\\n    }\\n\\n\\n    \\/\\/ input\\/output\\n    static class Reader\\n    {\\n        final private int BUFFER_SIZE = 1 << 16;\\n        private DataInputStream din;\\n        private byte[] buffer;\\n        private int bufferPointer, bytesRead;\\n\\n        public Reader()\\n        {\\n            din = new DataInputStream(System.in);\\n            \\n            buffer = new byte[BUFFER_SIZE];\\n            bufferPointer = bytesRead = 0;\\n        }\\n\\n        \\n\\n        public final String next()\\n        {\\n            int c = read();\\n            while (isSpaceChar(c))\\n          ...\",\"language\":\"python\",\"split\":\"train\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"There are n candles on a Hanukkah menorah, and some of its candles are initially lit. We can describe which candles are lit with a binary string s, where the i-th candle is lit if and only if s_i=1.\\n\\n<image>\\n\\nInitially, the candle lights are described by a string a. In an operation, you select a candle that is currently lit. By doing so, the candle you selected will remain lit, and every other candle will change (if it was lit, it will become unlit and if it was unlit, it will become lit).\\n\\nYou would like to make the candles look the same as string b. Your task is to determine if it is possible, and if it is, find the minimum number of operations required.\\n\\nInput\\n\\nThe first line contains an integer t (1\u2264 t\u2264 10^4) \u2014 the number of test cases. Then t cases follow.\\n\\nThe first line of each test case contains a single integer n (1\u2264 n\u2264 10^5) \u2014 the number of candles.\\n\\nThe second line contains a string a of length n consisting of symbols 0 and 1 \u2014 the initial pattern of lights.\\n\\nThe third line contains a string b of length n consisting of symbols 0 and 1 \u2014 the desired pattern of lights.\\n\\nIt is guaranteed that the sum of n does not exceed 10^5.\\n\\nOutput\\n\\nFor each test case, output the minimum number of operations required to transform a to b, or -1 if it's impossible.\\n\\nExample\\n\\nInput\\n\\n\\n5\\n5\\n11010\\n11010\\n2\\n01\\n11\\n3\\n000\\n101\\n9\\n100010111\\n101101100\\n9\\n001011011\\n011010101\\n\\n\\nOutput\\n\\n\\n0\\n1\\n-1\\n3\\n4\\n\\nNote\\n\\nIn the first test case, the two strings are already equal, so we don't have to perform any operations.\\n\\nIn the second test case, we can perform a single operation selecting the second candle to transform 01 into 11.\\n\\nIn the third test case, it's impossible to perform any operations because there are no lit candles to select.\\n\\nIn the fourth test case, we can perform the following operations to transform a into b: \\n\\n  1. Select the 7-th candle: 100010{\\\\color{red}1}11\u2192 011101{\\\\color{red} 1}00. \\n  2. Select the 2-nd candle: 0{\\\\color{red} 1}1101100\u2192 1{\\\\color{red} 1}0010011. \\n  3. Select the 1-st candle: {\\\\color{red}1}10010011\u2192...\\nUsing java can you solve the prior task?\",\"targets\":\"\\/\\/ package c1615;\\n\\nimport java.io.File;\\nimport java.lang.invoke.MethodHandles;\\nimport java.util.Random;\\nimport java.util.Scanner;\\n\\n\\/\\/\\n\\/\\/ Codeforces Global Round 18 2021-12-24 06:35\\n\\/\\/ C. Menorah\\n\\/\\/ https:\\/\\/codeforces.com\\/contest\\/1615\\/problem\\/C\\n\\/\\/ time limit per test 2 seconds; memory limit per test 256 megabytes\\n\\/\\/ public class Pseudo for 'Source should satisfy regex [^{}]*public\\\\s+(final)?\\\\s*class\\\\s+(\\\\w+).*'\\n\\/\\/\\n\\/\\/ There are n candles on a Hanukkah menorah, and some of its candles are initially lit. We can\\n\\/\\/ describe which candles are lit with a binary string s, where the i-th candle is lit if and only\\n\\/\\/ if s_i=1. https:\\/\\/espresso.codeforces.com\\/22a0f099b7bc8ff23b838529f43c7378bbfb511c.png\\n\\/\\/\\n\\/\\/ Initially, the candle lights are described by a string a. In an operation, you select a candle\\n\\/\\/ that is . By doing so, the candle you selected will remain lit, and every other candle will\\n\\/\\/ change (if it was lit, it will become unlit and if it was unlit, it will become lit).\\n\\/\\/\\n\\/\\/ You would like to make the candles look the same as string b. Your task is to determine if it is\\n\\/\\/ possible, and if it is, find the minimum number of operations required.\\n\\/\\/\\n\\/\\/ Input\\n\\/\\/\\n\\/\\/ The first line contains an integer t (1<= t<= 10^4)-- the number of test cases. Then t cases\\n\\/\\/ follow.\\n\\/\\/\\n\\/\\/ The first line of each test case contains a single integer n (1<= n<= 10^5)-- the number of\\n\\/\\/ candles.\\n\\/\\/\\n\\/\\/ The second line contains a string a of length n consisting of symbols and -- the initial pattern\\n\\/\\/ of lights.\\n\\/\\/\\n\\/\\/ The third line contains a string b of length n consisting of symbols and -- the desired pattern\\n\\/\\/ of lights.\\n\\/\\/\\n\\/\\/ It is guaranteed that the sum of n does not exceed 10^5.\\n\\/\\/\\n\\/\\/ Output\\n\\/\\/\\n\\/\\/ For each test case, output the minimum number of operations required to transform a to b, or -1\\n\\/\\/ if it's impossible.\\n\\/\\/\\n\\/\\/ Example\\n\\/*\\ninput:\\n5\\n5\\n11010\\n11010\\n2\\n01\\n11\\n3\\n000\\n101\\n9\\n100010111\\n101101100\\n9\\n001011011\\n011010101\\n\\noutput:\\n0\\n1\\n-1\\n3\\n4\\n*\\/\\n\\/\\/ Note\\n\\/\\/\\n\\/\\/ In the first test case, the two strings are already equal, so we don't have...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"This is the easy version of the problem. The only difference from the hard version is that in this version all coordinates are even.\\n\\nThere are n fence-posts at distinct coordinates on a plane. It is guaranteed that no three fence posts lie on the same line.\\n\\nThere are an infinite number of cows on the plane, one at every point with integer coordinates.\\n\\nGregor is a member of the Illuminati, and wants to build a triangular fence, connecting 3 distinct existing fence posts. A cow strictly inside the fence is said to be enclosed. If there are an odd number of enclosed cows and the area of the fence is an integer, the fence is said to be interesting.\\n\\nFind the number of interesting fences.\\n\\nInput\\n\\nThe first line contains the integer n (3 \u2264 n \u2264 6000), the number of fence posts which Gregor can choose to form the vertices of a fence.\\n\\nEach of the next n line contains two integers x and y (0 \u2264 x,y \u2264 10^7, x and y are even), where (x,y) is the coordinate of a fence post. All fence posts lie at distinct coordinates. No three fence posts are on the same line.\\n\\nOutput\\n\\nPrint a single integer, the number of interesting fences. Two fences are considered different if they are constructed with a different set of three fence posts.\\n\\nExamples\\n\\nInput\\n\\n\\n3\\n0 0\\n2 0\\n0 4\\n\\n\\nOutput\\n\\n\\n1\\n\\n\\nInput\\n\\n\\n5\\n0 0\\n2 16\\n30 14\\n4 6\\n2 10\\n\\n\\nOutput\\n\\n\\n3\\n\\nNote\\n\\nIn the first example, there is only 1 fence. That fence is interesting since its area is 4 and there is 1 enclosed cow, marked in red.\\n\\n<image>\\n\\nIn the second example, there are 3 interesting fences. \\n\\n  * (0,0) \u2014 (30,14) \u2014 (2,10) \\n  * (2,16) \u2014 (30,14) \u2014 (2,10) \\n  * (30,14) \u2014 (4,6) \u2014 (2,10) \\nThe above is tricky. Write me a correct solution in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst int MAXN = 6 * 1050;\\nint n;\\nint x[MAXN], y[MAXN];\\nint xmd4[MAXN], ymd4[MAXN];\\nint cnt[4][4];\\nlong long ans = 0;\\nlong long fours = 0, fourTwos = 0;\\nvoid add(int pos) { cnt[xmd4[pos]][ymd4[pos]]++; }\\nvoid rmv(int pos) { cnt[xmd4[pos]][ymd4[pos]]--; }\\nint main() {\\n  scanf(\\\"%d\\\", &n);\\n  for (int i = 0; i < n; i++) {\\n    scanf(\\\"%d %d\\\", &x[i], &y[i]);\\n    xmd4[i] = x[i] % 4;\\n    ymd4[i] = y[i] % 4;\\n    add(i);\\n  }\\n  for (int i = 0; i < n; i++) {\\n    rmv(i);\\n    for (int j = 0; j < n; j++) {\\n      if (j == i) continue;\\n      rmv(j);\\n      if (xmd4[i] == xmd4[j] && ymd4[i] == ymd4[j]) {\\n        for (int ii = 0; ii < 4; ii += 2)\\n          for (int jj = 0; jj < 4; jj += 2) {\\n            int fi = (ii == xmd4[i]) && (jj == ymd4[i]);\\n            int fj = (ii == xmd4[j]) && (jj == ymd4[j]);\\n            if (fi == 1 && fj == 1)\\n              fours += cnt[ii][jj];\\n            else if (fi == 0 && fj == 0)\\n              fourTwos += cnt[ii][jj];\\n          }\\n      }\\n      add(j);\\n    }\\n    add(i);\\n  }\\n  ans = fours \\/ 6 + fourTwos \\/ 2;\\n  cout << ans << endl;\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in PYTHON3?\\nYou are given n integers a_1, a_2, \u2026, a_n and an integer k. Find the maximum value of i \u22c5 j - k \u22c5 (a_i | a_j) over all pairs (i, j) of integers with 1 \u2264 i < j \u2264 n. Here, | is the [bitwise OR operator](https:\\/\\/en.wikipedia.org\\/wiki\\/Bitwise_operation#OR).\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 10 000) \u2014 the number of test cases.\\n\\nThe first line of each test case contains two integers n (2 \u2264 n \u2264 10^5) and k (1 \u2264 k \u2264 min(n, 100)).\\n\\nThe second line of each test case contains n integers a_1, a_2, \u2026, a_n (0 \u2264 a_i \u2264 n).\\n\\nIt is guaranteed that the sum of n over all test cases doesn't exceed 3 \u22c5 10^5.\\n\\nOutput\\n\\nFor each test case, print a single integer \u2014 the maximum possible value of i \u22c5 j - k \u22c5 (a_i | a_j).\\n\\nExample\\n\\nInput\\n\\n\\n4\\n3 3\\n1 1 3\\n2 2\\n1 2\\n4 3\\n0 1 2 3\\n6 6\\n3 2 0 0 5 6\\n\\n\\nOutput\\n\\n\\n-1\\n-4\\n3\\n12\\n\\nNote\\n\\nLet f(i, j) = i \u22c5 j - k \u22c5 (a_i | a_j).\\n\\nIn the first test case, \\n\\n  * f(1, 2) = 1 \u22c5 2 - k \u22c5 (a_1 | a_2) = 2 - 3 \u22c5 (1 | 1) = -1. \\n  * f(1, 3) = 1 \u22c5 3 - k \u22c5 (a_1 | a_3) = 3 - 3 \u22c5 (1 | 3) = -6. \\n  * f(2, 3) = 2 \u22c5 3 - k \u22c5 (a_2 | a_3) = 6 - 3 \u22c5 (1 | 3) = -3. \\n\\n\\n\\nSo the maximum is f(1, 2) = -1.\\n\\nIn the fourth test case, the maximum is f(3, 4) = 12.\",\"targets\":\"import sys\\ninput = sys.stdin.readline\\n\\nfor _ in range(int(input())):\\n    n, k = map(int, input().split())\\n    A = list(map(int, input().split()))\\n    x = max(0, n - 2 * k - 1)\\n    ans = float(\\\"-inf\\\")\\n    for i in range(x, n):\\n        for j in range(i + 1, n):\\n            ans = max(ans, (i + 1) * (j + 1) - k * (A[i] | A[j]))\\n    print(ans)\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Polycarp had an array a of 3 positive integers. He wrote out the sums of all non-empty subsequences of this array, sorted them in non-decreasing order, and got an array b of 7 integers.\\n\\nFor example, if a = \\\\{1, 4, 3\\\\}, then Polycarp wrote out 1, 4, 3, 1 + 4 = 5, 1 + 3 = 4, 4 + 3 = 7, 1 + 4 + 3 = 8. After sorting, he got an array b = \\\\{1, 3, 4, 4, 5, 7, 8\\\\}.\\n\\nUnfortunately, Polycarp lost the array a. He only has the array b left. Help him to restore the array a.\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 5000) \u2014 the number of test cases.\\n\\nEach test case consists of one line which contains 7 integers b_1, b_2, ..., b_7 (1 \u2264 b_i \u2264 10^9; b_i \u2264 b_{i+1}). \\n\\nAdditional constraint on the input: there exists at least one array a which yields this array b as described in the statement.\\n\\nOutput\\n\\nFor each test case, print 3 integers \u2014 a_1, a_2 and a_3. If there can be several answers, print any of them.\\n\\nExample\\n\\nInput\\n\\n\\n5\\n1 3 4 4 5 7 8\\n1 2 3 4 5 6 7\\n300000000 300000000 300000000 600000000 600000000 600000000 900000000\\n1 1 2 999999998 999999999 999999999 1000000000\\n1 2 2 3 3 4 5\\n\\n\\nOutput\\n\\n\\n1 4 3\\n4 1 2\\n300000000 300000000 300000000\\n999999998 1 1\\n1 2 2\\n\\nNote\\n\\nThe subsequence of the array a is a sequence that can be obtained from a by removing zero or more of its elements.\\n\\nTwo subsequences are considered different if index sets of elements included in them are different. That is, the values of the elements don't matter in the comparison of subsequences. In particular, any array of length 3 has exactly 7 different non-empty subsequences.\\nUsing java can you solve the prior task?\",\"targets\":\"import java.util.Scanner;\\n \\npublic class JavaApplication27 {\\n \\n    public static void main(String[] args) {\\n        Scanner sc = new Scanner(System.in);\\n        int n = sc.nextInt();\\n        for(int i=0;i<n;i++){\\n            int x1 = sc.nextInt();\\n            int x2 = sc.nextInt();\\n            int x3 = sc.nextInt();\\n            int x4 = sc.nextInt();\\n            int x5 = sc.nextInt();\\n            int x6 = sc.nextInt();\\n            int x7 = sc.nextInt();\\n            int sum = x6-x2;\\n            System.out.println(x7-x6 + \\\" \\\" + x2 + \\\" \\\" + sum);\\n        }\\n    }\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"An ant moves on the real line with constant speed of 1 unit per second. It starts at 0 and always moves to the right (so its position increases by 1 each second).\\n\\nThere are n portals, the i-th of which is located at position x_i and teleports to position y_i < x_i. Each portal can be either active or inactive. The initial state of the i-th portal is determined by s_i: if s_i=0 then the i-th portal is initially inactive, if s_i=1 then the i-th portal is initially active. When the ant travels through a portal (i.e., when its position coincides with the position of a portal): \\n\\n  * if the portal is inactive, it becomes active (in this case the path of the ant is not affected); \\n  * if the portal is active, it becomes inactive and the ant is instantly teleported to the position y_i, where it keeps on moving as normal. \\n\\n\\n\\nHow long (from the instant it starts moving) does it take for the ant to reach the position x_n + 1? It can be shown that this happens in a finite amount of time. Since the answer may be very large, compute it modulo 998 244 353.\\n\\nInput\\n\\nThe first line contains the integer n (1\u2264 n\u2264 2\u22c5 10^5) \u2014 the number of portals.\\n\\nThe i-th of the next n lines contains three integers x_i, y_i and s_i (1\u2264 y_i < x_i\u2264 10^9, s_i\u2208\\\\{0,1\\\\}) \u2014 the position of the i-th portal, the position where the ant is teleported when it travels through the i-th portal (if it is active), and the initial state of the i-th portal.\\n\\nThe positions of the portals are strictly increasing, that is x_1<x_2<\u22c5\u22c5\u22c5<x_n. It is guaranteed that the 2n integers x_1,   x_2,   ...,   x_n,   y_1,   y_2,   ...,   y_n are all distinct.\\n\\nOutput\\n\\nOutput the amount of time elapsed, in seconds, from the instant the ant starts moving to the instant it reaches the position x_n+1. Since the answer may be very large, output it modulo 998 244 353.\\n\\nExamples\\n\\nInput\\n\\n\\n4\\n3 2 0\\n6 5 1\\n7 4 0\\n8 1 1\\n\\n\\nOutput\\n\\n\\n23\\n\\n\\nInput\\n\\n\\n1\\n454971987 406874902 1\\n\\n\\nOutput\\n\\n\\n503069073\\n\\n\\nInput\\n\\n\\n5\\n243385510 42245605 0\\n644426565 574769163 0\\n708622105 208990040 0\\n786625660 616437691...\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nvoid dbg_out() { cerr << endl; }\\ntemplate <typename Head, typename... Tail>\\nvoid dbg_out(Head H, Tail... T) {\\n  cerr << ' ' << H;\\n  dbg_out(T...);\\n}\\ntemplate <const int &MOD>\\nstruct _m_int {\\n  int val;\\n  _m_int(int64_t v = 0) {\\n    if (v < 0) v = v % MOD + MOD;\\n    if (v >= MOD) v %= MOD;\\n    val = int(v);\\n  }\\n  _m_int(uint64_t v) {\\n    if (v >= MOD) v %= MOD;\\n    val = int(v);\\n  }\\n  _m_int(int v) : _m_int(int64_t(v)) {}\\n  _m_int(unsigned v) : _m_int(uint64_t(v)) {}\\n  explicit operator int() const { return val; }\\n  explicit operator unsigned() const { return val; }\\n  explicit operator int64_t() const { return val; }\\n  explicit operator uint64_t() const { return val; }\\n  explicit operator double() const { return val; }\\n  explicit operator long double() const { return val; }\\n  _m_int &operator+=(const _m_int &other) {\\n    val -= MOD - other.val;\\n    if (val < 0) val += MOD;\\n    return *this;\\n  }\\n  _m_int &operator-=(const _m_int &other) {\\n    val -= other.val;\\n    if (val < 0) val += MOD;\\n    return *this;\\n  }\\n  static unsigned fast_mod(uint64_t x, unsigned m = MOD) {\\n    return unsigned(x % m);\\n    unsigned x_high = unsigned(x >> 32), x_low = unsigned(x);\\n    unsigned quot, rem;\\n    asm(\\\"divl %4\\\\n\\\" : \\\"=a\\\"(quot), \\\"=d\\\"(rem) : \\\"d\\\"(x_high), \\\"a\\\"(x_low), \\\"r\\\"(m));\\n    return rem;\\n  }\\n  _m_int &operator*=(const _m_int &other) {\\n    val = fast_mod(uint64_t(val) * other.val);\\n    return *this;\\n  }\\n  _m_int &operator\\/=(const _m_int &other) { return *this *= other.inv(); }\\n  friend _m_int operator+(const _m_int &a, const _m_int &b) {\\n    return _m_int(a) += b;\\n  }\\n  friend _m_int operator-(const _m_int &a, const _m_int &b) {\\n    return _m_int(a) -= b;\\n  }\\n  friend _m_int operator*(const _m_int &a, const _m_int &b) {\\n    return _m_int(a) *= b;\\n  }\\n  friend _m_int operator\\/(const _m_int &a, const _m_int &b) {\\n    return _m_int(a) \\/= b;\\n  }\\n  _m_int &operator++() {\\n    val = val == MOD - 1 ? 0 : val + 1;\\n    return *this;\\n  }\\n  _m_int &operator--() {\\n    val = val == 0 ? MOD - 1...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in CPP?\\nYou have a permutation: an array a = [a_1, a_2, \u2026, a_n] of distinct integers from 1 to n. The length of the permutation n is odd.\\n\\nYou need to sort the permutation in increasing order.\\n\\nIn one step, you can choose any prefix of the permutation with an odd length and reverse it. Formally, if a = [a_1, a_2, \u2026, a_n], you can choose any odd integer p between 1 and n, inclusive, and set a to [a_p, a_{p-1}, \u2026, a_1, a_{p+1}, a_{p+2}, \u2026, a_n].\\n\\nFind a way to sort a using no more than 5n\\/2 reversals of the above kind, or determine that such a way doesn't exist. The number of reversals doesn't have to be minimized.\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 100). Description of the test cases follows.\\n\\nThe first line of each test case contains a single integer n (3 \u2264 n \u2264 2021; n is odd) \u2014 the length of the permutation.\\n\\nThe second line contains n distinct integers a_1, a_2, \u2026, a_n (1 \u2264 a_i \u2264 n) \u2014 the permutation itself. \\n\\nIt is guaranteed that the sum of n over all test cases does not exceed 2021.\\n\\nOutput\\n\\nFor each test case, if it's impossible to sort the given permutation in at most 5n\\/2 reversals, print a single integer -1.\\n\\nOtherwise, print an integer m (0 \u2264 m \u2264 5n\\/2), denoting the number of reversals in your sequence of steps, followed by m integers p_i (1 \u2264 p_i \u2264 n; p_i is odd), denoting the lengths of the prefixes of a to be reversed, in chronological order.\\n\\nNote that m doesn't have to be minimized. If there are multiple answers, print any.\\n\\nExample\\n\\nInput\\n\\n\\n3\\n3\\n1 2 3\\n5\\n3 4 5 2 1\\n3\\n2 1 3\\n\\n\\nOutput\\n\\n\\n4\\n3 3 3 3\\n2\\n3 5\\n-1\\n\\nNote\\n\\nIn the first test case, the permutation is already sorted. Any even number of reversals of the length 3 prefix doesn't change that fact.\\n\\nIn the second test case, after reversing the prefix of length 3 the permutation will change to [5, 4, 3, 2, 1], and then after reversing the prefix of length 5 the permutation will change to [1, 2, 3, 4, 5].\\n\\nIn the third test case, it's impossible to sort the permutation.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint a[2222], now[2222];\\nvector<int> ans;\\nvoid rev(int n) {\\n  reverse(a + 1, a + n + 1);\\n  for (int i = 1; i <= n; i++) now[a[i]] = i;\\n}\\nvoid f(int n) {\\n  if (n == 1) return;\\n  if (a[n] == n && a[n - 1] == n - 1) return f(n - 2);\\n  ans.push_back(now[n]);\\n  rev(now[n]);\\n  ans.push_back(now[n - 1] - 1);\\n  rev(now[n - 1] - 1);\\n  ans.push_back(now[n - 1] + 1);\\n  rev(now[n - 1] + 1);\\n  ans.push_back(3);\\n  rev(3);\\n  ans.push_back(n);\\n  rev(n);\\n  f(n - 2);\\n}\\nint main() {\\n  ios_base::sync_with_stdio(false);\\n  cin.tie(0);\\n  int T;\\n  cin >> T;\\n  while (T--) {\\n    int i, N, flag = 0;\\n    cin >> N;\\n    for (i = 1; i <= N; i++) {\\n      cin >> a[i];\\n      now[a[i]] = i;\\n      flag |= (a[i] - i) & 1;\\n    }\\n    if (flag) {\\n      cout << -1 << \\\"\\\\n\\\";\\n      continue;\\n    }\\n    ans.clear();\\n    f(N);\\n    cout << ans.size() << \\\"\\\\n\\\";\\n    for (i = 0; i < ans.size(); i++) cout << ans[i] << \\\" \\\";\\n    cout << \\\"\\\\n\\\";\\n  }\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Due to the coronavirus pandemic, city authorities obligated citizens to keep a social distance. The mayor of the city Semyon wants to light up Gluharniki park so that people could see each other even at night to keep the social distance.\\n\\nThe park is a rectangular table with n rows and m columns, where the cells of the table are squares, and the boundaries between the cells are streets. External borders are also streets. Every street has length 1. For example, park with n=m=2 has 12 streets.\\n\\nYou were assigned to develop a plan for lighting the park. You can put lanterns in the middle of the streets. The lamp lights two squares near it (or only one square if it stands on the border of the park).\\n\\n<image> The park sizes are: n=4, m=5. The lighted squares are marked yellow. Please note that all streets have length 1. Lanterns are placed in the middle of the streets. In the picture not all the squares are lit.\\n\\nSemyon wants to spend the least possible amount of money on lighting but also wants people throughout the park to keep a social distance. So he asks you to find the minimum number of lanterns that are required to light all the squares.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases in the input. Then t test cases follow.\\n\\nEach test case is a line containing two integers n, m (1 \u2264 n, m \u2264 10^4) \u2014 park sizes.\\n\\nOutput\\n\\nPrint t answers to the test cases. Each answer must be a single integer \u2014 the minimum number of lanterns that are required to light all the squares.\\n\\nExample\\n\\nInput\\n\\n\\n5\\n1 1\\n1 3\\n2 2\\n3 3\\n5 3\\n\\n\\nOutput\\n\\n\\n1\\n2\\n2\\n5\\n8\\n\\nNote\\n\\nPossible optimal arrangement of the lanterns for the 2-nd test case of input data example: <image>\\n\\nPossible optimal arrangement of the lanterns for the 3-rd test case of input data example: <image>\",\"targets\":\"t = int(input())\\n\\nfor T in range(t):\\n    n , m = map(int , input().split(\\\" \\\"))\\n    ans = (m*n)\\/\\/2 + (m*n)%2\\n    # ans += (n%2)*(m\\/\\/2 + (m%2))\\n\\n    print(ans)\",\"language\":\"python\",\"split\":\"train\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Anton likes to play chess, and so does his friend Danik.\\n\\nOnce they have played n games in a row. For each game it's known who was the winner \u2014 Anton or Danik. None of the games ended with a tie.\\n\\nNow Anton wonders, who won more games, he or Danik? Help him determine this.\\n\\nInput\\n\\nThe first line of the input contains a single integer n (1 \u2264 n \u2264 100 000) \u2014 the number of games played.\\n\\nThe second line contains a string s, consisting of n uppercase English letters 'A' and 'D' \u2014 the outcome of each of the games. The i-th character of the string is equal to 'A' if the Anton won the i-th game and 'D' if Danik won the i-th game.\\n\\nOutput\\n\\nIf Anton won more games than Danik, print \\\"Anton\\\" (without quotes) in the only line of the output.\\n\\nIf Danik won more games than Anton, print \\\"Danik\\\" (without quotes) in the only line of the output.\\n\\nIf Anton and Danik won the same number of games, print \\\"Friendship\\\" (without quotes).\\n\\nExamples\\n\\nInput\\n\\n6\\nADAAAA\\n\\n\\nOutput\\n\\nAnton\\n\\n\\nInput\\n\\n7\\nDDDAADA\\n\\n\\nOutput\\n\\nDanik\\n\\n\\nInput\\n\\n6\\nDADADA\\n\\n\\nOutput\\n\\nFriendship\\n\\nNote\\n\\nIn the first sample, Anton won 6 games, while Danik \u2014 only 1. Hence, the answer is \\\"Anton\\\".\\n\\nIn the second sample, Anton won 3 games and Danik won 4 games, so the answer is \\\"Danik\\\".\\n\\nIn the third sample, both Anton and Danik won 3 games and the answer is \\\"Friendship\\\".\",\"targets\":\"m = int(raw_input())\\nn = str(raw_input())\\nif n.count(\\\"A\\\") > n.count(\\\"D\\\"):\\n    print \\\"Anton\\\"\\nelif n.count(\\\"A\\\") < n.count(\\\"D\\\"):\\n    print \\\"Danik\\\"\\nelse:\\n    print \\\"Friendship\\\"\",\"language\":\"python\",\"split\":\"train\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You are given two positive integers n and s. Find the maximum possible median of an array of n non-negative integers (not necessarily distinct), such that the sum of its elements is equal to s.\\n\\nA median of an array of integers of length m is the number standing on the \u2308 {m\\/2} \u2309-th (rounding up) position in the non-decreasing ordering of its elements. Positions are numbered starting from 1. For example, a median of the array [20,40,20,50,50,30] is the \u2308 m\\/2 \u2309-th element of [20,20,30,40,50,50], so it is 30. There exist other definitions of the median, but in this problem we use the described definition.\\n\\nInput\\n\\nThe input consists of multiple test cases. The first line contains a single integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases. Description of the test cases follows.\\n\\nEach test case contains a single line with two integers n and s (1 \u2264 n, s \u2264 10^9) \u2014 the length of the array and the required sum of the elements.\\n\\nOutput\\n\\nFor each test case print a single integer \u2014 the maximum possible median.\\n\\nExample\\n\\nInput\\n\\n\\n8\\n1 5\\n2 5\\n3 5\\n2 1\\n7 17\\n4 14\\n1 1000000000\\n1000000000 1\\n\\n\\nOutput\\n\\n\\n5\\n2\\n2\\n0\\n4\\n4\\n1000000000\\n0\\n\\nNote\\n\\nPossible arrays for the first three test cases (in each array the median is underlined):\\n\\n  * In the first test case [\\\\underline{5}] \\n  * In the second test case [\\\\underline{2}, 3] \\n  * In the third test case [1, \\\\underline{2}, 2] \\nSolve the task in PYTHON3.\",\"targets\":\"import sys\\n\\ndef input(): return sys.stdin.readline().rstrip(\\\"\\\\r\\\\n\\\")\\n\\ndef maps():return [int(i) for i in input().split()]\\n\\n#lOOKOUT FOR THE EDGE CASES\\nfrom math import ceil\\nfor i in range(*maps()):\\n\\tn , s = maps()\\n\\tif n == 1:\\n\\t\\tprint(s)\\n\\t\\tcontinue\\n\\tif s == n :\\n\\t\\tprint(1)\\n\\t\\tcontinue\\n\\n\\t# N = n - 1\\n\\t# if s < N*(N+1)\\/\\/2 :\\n\\t# \\tprint()\\n\\tm = ceil(n\\/2) + (1 if n%2 == 0 else 0)\\n\\t\\n\\tprint(s\\/\\/m)\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"n players are playing a game. \\n\\nThere are two different maps in the game. For each player, we know his strength on each map. When two players fight on a specific map, the player with higher strength on that map always wins. No two players have the same strength on the same map. \\n\\nYou are the game master and want to organize a tournament. There will be a total of n-1 battles. While there is more than one player in the tournament, choose any map and any two remaining players to fight on it. The player who loses will be eliminated from the tournament. \\n\\nIn the end, exactly one player will remain, and he is declared the winner of the tournament. For each player determine if he can win the tournament.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 100) \u2014 the number of test cases. The description of test cases follows.\\n\\nThe first line of each test case contains a single integer n (1 \u2264 n \u2264 10^5) \u2014 the number of players.\\n\\nThe second line of each test case contains n integers a_1, a_2, ..., a_n (1 \u2264 a_i \u2264 10^9, a_i \u2260 a_j for i \u2260 j), where a_i is the strength of the i-th player on the first map. \\n\\nThe third line of each test case contains n integers b_1, b_2, ..., b_n (1 \u2264 b_i \u2264 10^9, b_i \u2260 b_j for i \u2260 j), where b_i is the strength of the i-th player on the second map. \\n\\nIt is guaranteed that the sum of n over all test cases does not exceed 10^5.\\n\\nOutput\\n\\nFor each test case print a string of length n. i-th character should be \\\"1\\\" if the i-th player can win the tournament, or \\\"0\\\" otherwise.\\n\\nExample\\n\\nInput\\n\\n\\n3\\n4\\n1 2 3 4\\n1 2 3 4\\n4\\n11 12 20 21\\n44 22 11 30\\n1\\n1000000000\\n1000000000\\n\\n\\nOutput\\n\\n\\n0001\\n1111\\n1\\n\\nNote\\n\\nIn the first test case, the 4-th player will beat any other player on any game, so he will definitely win the tournament.\\n\\nIn the second test case, everyone can be a winner. \\n\\nIn the third test case, there is only one player. Clearly, he will win the tournament.\\nUsing cpp can you solve the prior task?\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint main() {\\n  ios::sync_with_stdio(false);\\n  int T, n;\\n  cin >> T;\\n  while (T--) {\\n    cin >> n;\\n    vector<pair<int, int>> a(n);\\n    vector<vector<int>> e(n);\\n    vector<int> ans(n);\\n    int maxa = 0, maxb = 0;\\n    for (int i = 0; i < n; i++) {\\n      cin >> a[i].first;\\n      a[i].second = i;\\n    }\\n    sort(a.begin(), a.end());\\n    for (int i = 1; i < n; i++) {\\n      e[a[i - 1].second].push_back(a[i].second);\\n    }\\n    for (int i = 0; i < n; i++) {\\n      cin >> a[i].first;\\n      a[i].second = i;\\n    }\\n    sort(a.begin(), a.end());\\n    for (int i = 1; i < n; i++) {\\n      e[a[i - 1].second].push_back(a[i].second);\\n    }\\n    queue<int> q;\\n    ans[a[n - 1].second] = 1;\\n    q.push(a[n - 1].second);\\n    while (!q.empty()) {\\n      int now = q.front();\\n      q.pop();\\n      for (auto &t : e[now]) {\\n        if (ans[t] == 0) {\\n          ans[t] = 1;\\n          q.push(t);\\n        }\\n      }\\n    }\\n    for (int i = 0; i < n; i++) cout << ans[i];\\n    cout << '\\\\n';\\n  }\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Alice gave Bob two integers a and b (a > 0 and b \u2265 0). Being a curious boy, Bob wrote down an array of non-negative integers with \\\\operatorname{MEX} value of all elements equal to a and \\\\operatorname{XOR} value of all elements equal to b.\\n\\nWhat is the shortest possible length of the array Bob wrote?\\n\\nRecall that the \\\\operatorname{MEX} (Minimum EXcluded) of an array is the minimum non-negative integer that does not belong to the array and the \\\\operatorname{XOR} of an array is the [bitwise XOR](https:\\/\\/en.wikipedia.org\\/wiki\\/Bitwise_operation#XOR) of all the elements of the array.\\n\\nInput\\n\\nThe input consists of multiple test cases. The first line contains an integer t (1 \u2264 t \u2264 5 \u22c5 10^4) \u2014 the number of test cases. The description of the test cases follows.\\n\\nThe only line of each test case contains two integers a and b (1 \u2264 a \u2264 3 \u22c5 10^5; 0 \u2264 b \u2264 3 \u22c5 10^5) \u2014 the \\\\operatorname{MEX} and \\\\operatorname{XOR} of the array, respectively.\\n\\nOutput\\n\\nFor each test case, output one (positive) integer \u2014 the length of the shortest array with \\\\operatorname{MEX} a and \\\\operatorname{XOR} b. We can show that such an array always exists.\\n\\nExample\\n\\nInput\\n\\n\\n5\\n1 1\\n2 1\\n2 0\\n1 10000\\n2 10000\\n\\n\\nOutput\\n\\n\\n3\\n2\\n3\\n2\\n3\\n\\nNote\\n\\nIn the first test case, one of the shortest arrays with \\\\operatorname{MEX} 1 and \\\\operatorname{XOR} 1 is [0, 2020, 2021].\\n\\nIn the second test case, one of the shortest arrays with \\\\operatorname{MEX} 2 and \\\\operatorname{XOR} 1 is [0, 1].\\n\\nIt can be shown that these arrays are the shortest arrays possible.\\nSolve the task in JAVA.\",\"targets\":\"import java.util.*;\\npublic class A {\\n \\n\\t\\n\\tpublic static void main(String[] args) {\\n\\t\\t\\n\\t\\t\\n\\t\\tScanner obj = new Scanner(System.in);\\n\\t\\tint t = obj.nextInt();\\n\\t\\twhile(t-->0)\\n\\t\\t{\\n\\t\\t\\tint a = obj.nextInt();\\n\\t\\t\\tint k=a;\\n\\t\\t\\tint b = obj.nextInt();\\n\\t\\t\\ta--;\\n\\t\\t\\tif(a%4==0)\\n\\t\\t\\t\\ta=a;\\n\\t\\t\\telse if(a%4==1)\\n\\t\\t\\t\\ta=1;\\n\\t\\t\\telse if(a%4==2)\\n\\t\\t\\t\\ta=a+1;\\n\\t\\t\\telse if(a%4==3)\\n\\t\\t\\t    a=0;\\n\\t\\t\\tint p =a^k;\\n\\t\\t\\tif(a==b)\\n\\t\\t\\t\\t{System.out.println(k);\\n\\t\\t\\t\\t continue;\\n\\t\\t\\t\\t}\\n\\t\\t\\tif(p==b)\\n\\t\\t\\t\\tSystem.out.println(k+2);\\n\\t\\t\\telse\\n\\t\\t\\t\\tSystem.out.println(k+1);\\n\\t\\t\\t\\n\\t\\t\\t\\n\\t\\t}\\n\\t\\n\\t}\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Lord Omkar would like to have a tree with n nodes (3 \u2264 n \u2264 10^5) and has asked his disciples to construct the tree. However, Lord Omkar has created m (1 \u2264 m < n) restrictions to ensure that the tree will be as heavenly as possible. \\n\\nA tree with n nodes is an connected undirected graph with n nodes and n-1 edges. Note that for any two nodes, there is exactly one simple path between them, where a simple path is a path between two nodes that does not contain any node more than once.\\n\\nHere is an example of a tree: \\n\\n<image>\\n\\nA restriction consists of 3 pairwise distinct integers, a, b, and c (1 \u2264 a,b,c \u2264 n). It signifies that node b cannot lie on the simple path between node a and node c. \\n\\nCan you help Lord Omkar and become his most trusted disciple? You will need to find heavenly trees for multiple sets of restrictions. It can be shown that a heavenly tree will always exist for any set of restrictions under the given constraints.\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 10^4). Description of the test cases follows.\\n\\nThe first line of each test case contains two integers, n and m (3 \u2264 n \u2264 10^5, 1 \u2264 m < n), representing the size of the tree and the number of restrictions.\\n\\nThe i-th of the next m lines contains three integers a_i, b_i, c_i (1 \u2264 a_i, b_i, c_i \u2264 n, a, b, c are distinct), signifying that node b_i cannot lie on the simple path between nodes a_i and c_i. \\n\\nIt is guaranteed that the sum of n across all test cases will not exceed 10^5.\\n\\nOutput\\n\\nFor each test case, output n-1 lines representing the n-1 edges in the tree. On each line, output two integers u and v (1 \u2264 u, v \u2264 n, u \u2260 v) signifying that there is an edge between nodes u and v. Given edges have to form a tree that satisfies Omkar's restrictions.\\n\\nExample\\n\\nInput\\n\\n\\n2\\n7 4\\n1 2 3\\n3 4 5\\n5 6 7\\n6 5 4\\n5 3\\n1 2 3\\n2 3 4\\n3 4 5\\n\\n\\nOutput\\n\\n\\n1 2\\n1 3\\n3 5\\n3 4\\n2 7\\n7 6\\n5 1\\n1 3\\n3 2\\n2 4\\n\\nNote\\n\\nThe output of the first sample case corresponds to the following tree: \\n\\n<image> For the first restriction,...\\nSolve the task in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst int N = 1e5 + 100;\\nint vis[N], n, m, pos;\\nint main() {\\n  register int T;\\n  scanf(\\\"%d\\\", &T);\\n  while (T--) {\\n    memset(vis, 0, sizeof vis);\\n    scanf(\\\"%d%d\\\", &n, &m);\\n    for (register int i = 1, b; i <= m; ++i) scanf(\\\"%*d%d%*d\\\", &b), vis[b] = 1;\\n    for (register int i = 1; i <= n; ++i)\\n      if (!vis[i]) {\\n        pos = i;\\n        break;\\n      }\\n    for (register int i = 1; i <= n; ++i) {\\n      if (i == pos) continue;\\n      printf(\\\"%d %d\\\\n\\\", i, pos);\\n    }\\n  }\\n  getchar(), getchar();\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"JAVA solution for \\\"A rectangle with its opposite corners in (0, 0) and (w, h) and sides parallel to the axes is drawn on a plane.\\n\\nYou are given a list of lattice points such that each point lies on a side of a rectangle but not in its corner. Also, there are at least two points on every side of a rectangle.\\n\\nYour task is to choose three points in such a way that: \\n\\n  * exactly two of them belong to the same side of a rectangle; \\n  * the area of a triangle formed by them is maximum possible. \\n\\n\\n\\nPrint the doubled area of this triangle. It can be shown that the doubled area of any triangle formed by lattice points is always an integer.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 10^4) \u2014 the number of testcases.\\n\\nThe first line of each testcase contains two integers w and h (3 \u2264 w, h \u2264 10^6) \u2014 the coordinates of the corner of a rectangle.\\n\\nThe next two lines contain the description of the points on two horizontal sides. First, an integer k (2 \u2264 k \u2264 2 \u22c5 10^5) \u2014 the number of points. Then, k integers x_1 < x_2 < ... < x_k (0 < x_i < w) \u2014 the x coordinates of the points in the ascending order. The y coordinate for the first line is 0 and for the second line is h.\\n\\nThe next two lines contain the description of the points on two vertical sides. First, an integer k (2 \u2264 k \u2264 2 \u22c5 10^5) \u2014 the number of points. Then, k integers y_1 < y_2 < ... < y_k (0 < y_i < h) \u2014 the y coordinates of the points in the ascending order. The x coordinate for the first line is 0 and for the second line is w.\\n\\nThe total number of points on all sides in all testcases doesn't exceed 2 \u22c5 10^5.\\n\\nOutput\\n\\nFor each testcase print a single integer \u2014 the doubled maximum area of a triangle formed by such three points that exactly two of them belong to the same side.\\n\\nExample\\n\\nInput\\n\\n\\n3\\n5 8\\n2 1 2\\n3 2 3 4\\n3 1 4 6\\n2 4 5\\n10 7\\n2 3 9\\n2 1 7\\n3 1 3 4\\n3 4 5 6\\n11 5\\n3 1 6 8\\n3 3 6 8\\n3 1 3 4\\n2 2 4\\n\\n\\nOutput\\n\\n\\n25\\n42\\n35\\n\\nNote\\n\\nThe points in the first testcase of the example: \\n\\n  * (1, 0), (2, 0); \\n  * (2, 8), (3, 8), (4, 8); \\n  * (0, 1), (0, 4), (0, 6); \\n  * (5, 4), (5,...\\\":\",\"targets\":\"import java.lang.reflect.Array;\\nimport java.util.Arrays;\\nimport java.util.Scanner;\\n\\npublic class pb2 {\\n    public static void main(String[] args) {\\n        Scanner sc = new Scanner(System.in);\\n        int t = sc.nextInt();\\n        while (t-->0){\\n\\n            long w  = sc.nextLong();\\n            long h = sc.nextLong();\\n\\n            int x = sc.nextInt();\\n            long[] arr1 = new long[x];\\n            for (int i =0; i< x ; i++){\\n                arr1[i] = sc.nextLong();\\n            }\\n\\/\\/            Arrays.sort(arr1);\\n            int y = sc.nextInt();\\n            long[] arr2 = new long[y];\\n            for (int i =0; i< y ; i++){\\n                arr2[i] = sc.nextLong();\\n            }\\n\\/\\/            Arrays.sort(arr2);\\n\\n            int z = sc.nextInt();\\n            long[] arr3 = new long[z];\\n            for (int i =0; i< z ; i++){\\n                arr3[i] = sc.nextLong();\\n            }\\n\\n\\/\\/            Arrays.sort(arr3);\\n            int zz = sc.nextInt();\\n            long[] arr4 = new long[zz];\\n            for (int i =0; i< zz ; i++){\\n                arr4[i] = sc.nextLong();\\n            }\\n\\n\\/\\/            Arrays.sort(arr4);\\n\\n\\/\\/            int max = Integer.MIN_VALUE;\\n            long area = 0;\\n            long num = (arr1[x-1] - arr1[0]) * h;\\n            if (num > area)\\n                area = num;\\n            num = (arr2[y-1] - arr2[0]) * h;\\n            if (num > area)\\n                area = num;\\n\\n            num = (arr3[z-1] - arr3[0]) * w;\\n            if (num > area)\\n                area = num;\\n\\n            num = (arr4[zz-1] - arr4[0]) * w;\\n            if (num > area)\\n                area = num;\\n\\n\\/\\/\\n\\/\\/           area = Math.max(area , (arr1[x-1] - arr1[0]) * h);\\n\\/\\/           area = Math.max(area , (arr2[y-1] - arr2[0]) * h);\\n\\/\\/           area = Math.max(area , (arr3[z-1] - arr3[0]) * w);\\n\\/\\/           area = Math.max(area , (arr4[zz-1] - arr4[0]) * w);\\n\\n            System.out.println(area);\\n\\n\\n        }\\n    }\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Alice likes word \\\"nineteen\\\" very much. She has a string s and wants the string to contain as many such words as possible. For that reason she can rearrange the letters of the string.\\n\\nFor example, if she has string \\\"xiineteenppnnnewtnee\\\", she can get string \\\"xnineteenppnineteenw\\\", containing (the occurrences marked) two such words. More formally, word \\\"nineteen\\\" occurs in the string the number of times you can read it starting from some letter of the string. Of course, you shouldn't skip letters.\\n\\nHelp her to find the maximum number of \\\"nineteen\\\"s that she can get in her string.\\n\\nInput\\n\\nThe first line contains a non-empty string s, consisting only of lowercase English letters. The length of string s doesn't exceed 100.\\n\\nOutput\\n\\nPrint a single integer \u2014 the maximum number of \\\"nineteen\\\"s that she can get in her string.\\n\\nExamples\\n\\nInput\\n\\nnniinneetteeeenn\\n\\n\\nOutput\\n\\n2\\n\\nInput\\n\\nnneteenabcnneteenabcnneteenabcnneteenabcnneteenabcii\\n\\n\\nOutput\\n\\n2\\n\\nInput\\n\\nnineteenineteen\\n\\n\\nOutput\\n\\n2\\nUsing java can you solve the prior task?\",\"targets\":\"import java.util.Scanner;\\nimport java.io.PrintWriter;\\n\\n\\/\\/import java.util.Arrays;\\n\\/\\/import java.lang.Comparable;\\n\\n\\/\\/import java.lang.StringBuffer;\\n\\n\\/\\/import java.util.LinkedList;\\n\\n\\/\\/import java.util.HashMap;\\n\\npublic class Main {\\n    \\n    static Scanner in = new Scanner(System.in);\\n    static PrintWriter out = new PrintWriter(System.out);\\n    \\/\\/static StringBuffer sb = new StringBuffer();\\n    \\/\\/static LinkedList<Integer> list = new LinkedList<Integer>();\\n    \\/\\/static HashMap<Integer, Boolean> map = new HashMap<>();\\n    \\n    public static void main(String[] args) {\\n        char[] c = in.next().toCharArray();\\n        int n = c.length, l[] = new int[5];\\n        for(int i = 0; i < n; i++)\\n            l[(c[i] == 'n' ? 0 : (c[i] == 'i' ? 1 : (c[i] == 'e' ? 2 : (c[i] == 't' ? 3 : 4))))]++;\\n        out.print(Math.min(Math.min(Math.min(l[1], l[3]), (l[0]-1) \\/ 2), l[2] \\/ 3));\\n        out.close();\\n    }\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"A binary string is a string that consists of characters 0 and 1.\\n\\nLet \\\\operatorname{MEX} of a binary string be the smallest digit among 0, 1, or 2 that does not occur in the string. For example, \\\\operatorname{MEX} of 001011 is 2, because 0 and 1 occur in the string at least once, \\\\operatorname{MEX} of 1111 is 0, because 0 and 2 do not occur in the string and 0 < 2.\\n\\nA binary string s is given. You should cut it into any number of substrings such that each character is in exactly one substring. It is possible to cut the string into a single substring \u2014 the whole string.\\n\\nA string a is a substring of a string b if a can be obtained from b by deletion of several (possibly, zero or all) characters from the beginning and several (possibly, zero or all) characters from the end.\\n\\nWhat is the minimal sum of \\\\operatorname{MEX} of all substrings pieces can be?\\n\\nInput\\n\\nThe input consists of multiple test cases. The first line contains a single integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases. Description of the test cases follows.\\n\\nEach test case contains a single binary string s (1 \u2264 |s| \u2264 10^5).\\n\\nIt's guaranteed that the sum of lengths of s over all test cases does not exceed 10^5.\\n\\nOutput\\n\\nFor each test case print a single integer \u2014 the minimal sum of \\\\operatorname{MEX} of all substrings that it is possible to get by cutting s optimally.\\n\\nExample\\n\\nInput\\n\\n\\n6\\n01\\n1111\\n01100\\n101\\n0000\\n01010\\n\\n\\nOutput\\n\\n\\n1\\n0\\n2\\n1\\n1\\n2\\n\\nNote\\n\\nIn the first test case the minimal sum is \\\\operatorname{MEX}(0) + \\\\operatorname{MEX}(1) = 1 + 0 = 1.\\n\\nIn the second test case the minimal sum is \\\\operatorname{MEX}(1111) = 0.\\n\\nIn the third test case the minimal sum is \\\\operatorname{MEX}(01100) = 2.\\nThe above is tricky. Write me a correct solution in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst int N = 1e6 + 5;\\nconst int MOD = 1e9 + 7;\\nvoid solve() {\\n  string s;\\n  cin >> s;\\n  int n = s.size(), ans = 0;\\n  s = ' ' + s;\\n  for (int i = 1; i <= n; ++i) {\\n    char x = s[i];\\n    while (s[i] == x and i <= n) ++i;\\n    --i;\\n    if (x == '0') ++ans;\\n  }\\n  cout << min(2, ans) << '\\\\n';\\n}\\nint main() {\\n  ios_base::sync_with_stdio(0);\\n  cin.tie(NULL);\\n  cout.tie(NULL);\\n  int t = 1;\\n  cin >> t;\\n  while (t--) solve();\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CQXYM is counting permutations length of 2n.\\n\\nA permutation is an array consisting of n distinct integers from 1 to n in arbitrary order. For example, [2,3,1,5,4] is a permutation, but [1,2,2] is not a permutation (2 appears twice in the array) and [1,3,4] is also not a permutation (n=3 but there is 4 in the array).\\n\\nA permutation p(length of 2n) will be counted only if the number of i satisfying p_i<p_{i+1} is no less than n. For example:\\n\\n  * Permutation [1, 2, 3, 4] will count, because the number of such i that p_i<p_{i+1} equals 3 (i = 1, i = 2, i = 3).\\n  * Permutation [3, 2, 1, 4] won't count, because the number of such i that p_i<p_{i+1} equals 1 (i = 3). \\n\\n\\n\\nCQXYM wants you to help him to count the number of such permutations modulo 1000000007 (10^9+7).\\n\\nIn addition, [modulo operation](https:\\/\\/en.wikipedia.org\\/wiki\\/Modulo_operation) is to get the remainder. For example:\\n\\n  * 7 mod 3=1, because 7 = 3 \u22c5 2 + 1, \\n  * 15 mod 4=3, because 15 = 4 \u22c5 3 + 3. \\n\\nInput\\n\\nThe input consists of multiple test cases. \\n\\nThe first line contains an integer t (t \u2265 1) \u2014 the number of test cases. The description of the test cases follows.\\n\\nOnly one line of each test case contains an integer n(1 \u2264 n \u2264 10^5).\\n\\nIt is guaranteed that the sum of n over all test cases does not exceed 10^5\\n\\nOutput\\n\\nFor each test case, print the answer in a single line.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n1\\n2\\n9\\n91234\\n\\n\\nOutput\\n\\n\\n1\\n12\\n830455698\\n890287984\\n\\nNote\\n\\nn=1, there is only one permutation that satisfies the condition: [1,2].\\n\\nIn permutation [1,2], p_1<p_2, and there is one i=1 satisfy the condition. Since 1 \u2265 n, this permutation should be counted. In permutation [2,1], p_1>p_2. Because 0<n, this permutation should not be counted.\\n\\nn=2, there are 12 permutations: [1,2,3,4],[1,2,4,3],[1,3,2,4],[1,3,4,2],[1,4,2,3],[2,1,3,4],[2,3,1,4],[2,3,4,1],[2,4,1,3],[3,1,2,4],[3,4,1,2],[4,1,2,3].\",\"targets\":\"import sys,os,io\\ninput = sys.stdin.readline # for strings\\n# input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline # for non-strings\\n\\nPI = 3.141592653589793238460\\nINF =  float('inf')\\nMOD  = 1000000007\\n# MOD = 998244353\\n\\n\\ndef bin32(num):\\n\\treturn '{0:032b}'.format(num)\\n\\ndef add(x,y):\\n\\treturn (x+y)%MOD\\n\\ndef sub(x,y):\\n\\treturn (x-y+MOD)%MOD\\n\\ndef mul(x,y):\\n\\treturn (x*y)%MOD\\n\\ndef gcd(x,y):\\n\\tif y == 0:\\n\\t\\treturn x\\n\\treturn gcd(y,x%y)\\n\\ndef lcm(x,y):\\n\\treturn (x*y)\\/\\/gcd(x,y)\\n\\ndef power(x,y):\\n\\tres = 1\\n\\tx%=MOD\\n\\twhile y!=0:\\n\\t\\tif y&1 :\\n\\t\\t\\tres = mul(res,x)\\n\\t\\ty>>=1\\n\\t\\tx = mul(x,x)\\n\\t\\t\\n\\treturn res\\n\\t\\t\\ndef mod_inv(n):\\n\\treturn power(n,MOD-2)\\n\\ndef prob(p,q):\\n\\treturn mul(p,power(q,MOD-2))    \\n  \\ndef ii():\\n\\treturn int(input())\\n\\ndef li():\\n\\treturn [int(i) for i in input().split()]\\n\\ndef ls():\\n\\treturn [i for i in input().split()]\\n\\nfact = [1]\\nfor i in range(1 , 2*(10**5) + 5):\\n\\tfact.append(mul(fact[-1] , i))\\n\\n\\nfor t in range(ii()):\\n\\tn = ii()\\n\\tprint((fact[2*n]*mod_inv(2))%MOD)\",\"language\":\"python\",\"split\":\"test\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You are given two integers l and r, l\u2264 r. Find the largest possible value of a mod b over all pairs (a, b) of integers for which r\u2265 a \u2265 b \u2265 l.\\n\\nAs a reminder, a mod b is a remainder we get when dividing a by b. For example, 26 mod 8 = 2.\\n\\nInput\\n\\nEach test contains multiple test cases.\\n\\nThe first line contains one positive integer t (1\u2264 t\u2264 10^4), denoting the number of test cases. Description of the test cases follows.\\n\\nThe only line of each test case contains two integers l, r (1\u2264 l \u2264 r \u2264 10^9).\\n\\nOutput\\n\\nFor every test case, output the largest possible value of a mod b over all pairs (a, b) of integers for which r\u2265 a \u2265 b \u2265 l.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n1 1\\n999999999 1000000000\\n8 26\\n1 999999999\\n\\n\\nOutput\\n\\n\\n0\\n1\\n12\\n499999999\\n\\nNote\\n\\nIn the first test case, the only allowed pair is (a, b) = (1, 1), for which a mod b = 1 mod 1 = 0.\\n\\nIn the second test case, the optimal choice is pair (a, b) = (1000000000, 999999999), for which a mod b = 1.\\nThe above is tricky. Write me a correct solution in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint test, l, r;\\nint main() {\\n  ios_base::sync_with_stdio(false);\\n  cin.tie(NULL);\\n  cout.tie(NULL);\\n  cin >> test;\\n  while (test--) {\\n    cin >> l >> r;\\n    if (2 * l <= r + 1) {\\n      cout << (r + 1) \\/ 2 - 1 << '\\\\n';\\n    } else\\n      cout << r - l << '\\\\n';\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You have an array a consisting of n distinct positive integers, numbered from 1 to n. Define p_k as $$$p_k = \u2211_{1 \u2264 i, j \u2264 k} a_i mod a_j, where x \\\\bmod y denotes the remainder when x is divided by y. You have to find and print p_1, p_2, \\\\ldots, p_n$$$. \\n\\nInput\\n\\nThe first line contains n \u2014 the length of the array (2 \u2264 n \u2264 2 \u22c5 10^5).\\n\\nThe second line contains n space-separated distinct integers a_1, \u2026, a_n (1 \u2264 a_i \u2264 3 \u22c5 10^5, a_i \u2260 a_j if i \u2260 j). \\n\\nOutput\\n\\nPrint n integers p_1, p_2, \u2026, p_n. \\n\\nExamples\\n\\nInput\\n\\n\\n4\\n6 2 7 3\\n\\n\\nOutput\\n\\n\\n0 2 12 22\\n\\n\\nInput\\n\\n\\n3\\n3 2 1\\n\\n\\nOutput\\n\\n\\n0 3 5\\nSolve the task in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\n#pragma GCC optimize(\\\"O3\\\")\\n#pragma GCC target(\\\"sse4\\\")\\nusing namespace std;\\nusing ll = long long;\\nusing vi = vector<int>;\\nusing pi = pair<int, int>;\\nusing vpi = vector<pair<int, int>>;\\nusing pl = pair<ll, ll>;\\nusing vl = vector<ll>;\\nusing vpl = vector<pl>;\\nusing ld = long double;\\ntemplate <typename T>\\nusing pqg = priority_queue<T, vector<T>, greater<T>>;\\ntemplate <typename A, typename B>\\nostream &operator<<(ostream &os, const pair<A, B> &p) {\\n  return os << '(' << p.first << \\\", \\\" << p.second << ')';\\n}\\ntemplate <typename T_container, typename T = typename enable_if<\\n                                    !is_same<T_container, string>::value,\\n                                    typename T_container::value_type>::type>\\nostream &operator<<(ostream &os, const T_container &v) {\\n  os << '{';\\n  string sep;\\n  for (const T &x : v) os << sep << x, sep = \\\", \\\";\\n  return os << '}';\\n}\\nvoid dbg_out() { cerr << endl; }\\ntemplate <typename Head, typename... Tail>\\nvoid dbg_out(Head H, Tail... T) {\\n  cerr << ' ' << H;\\n  dbg_out(T...);\\n}\\nstruct custom_hash {\\n  static uint64_t splitmix64(uint64_t x) {\\n    x += 0x9e3779b97f4a7c15;\\n    x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;\\n    x = (x ^ (x >> 27)) * 0x94d049bb133111eb;\\n    return x ^ (x >> 31);\\n  }\\n  size_t operator()(uint64_t x) const {\\n    static const uint64_t FIXED_RANDOM =\\n        chrono::steady_clock::now().time_since_epoch().count();\\n    return splitmix64(x + FIXED_RANDOM);\\n  }\\n};\\nvoid setIO(string s) {\\n  freopen((s + \\\".in\\\").c_str(), \\\"r\\\", stdin);\\n  freopen((s + \\\".out\\\").c_str(), \\\"w\\\", stdout);\\n}\\nmt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\\nconst int INF = 1e9;\\nconst ll LINF = 1e18;\\nconst int MOD = 1e9 + 7;\\ntemplate <typename T, int N>\\nstruct BIT {\\n  T bit[N + 1];\\n  BIT() { memset(bit, 0, sizeof(bit)); }\\n  void upd(int i, T v) {\\n    for (; i <= N; i += i & -i) bit[i] += v;\\n  }\\n  T query(int i) {\\n    T res = 0;\\n    for (; i > 0; i -= i & -i) res += bit[i];\\n    return res;\\n  }\\n};\\nconst int MX = 3e5;\\nvoid solve() {\\n  int N;\\n  cin >>...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"<image>\\n\\nWilliam is not only interested in trading but also in betting on sports matches. n teams participate in each match. Each team is characterized by strength a_i. Each two teams i < j play with each other exactly once. Team i wins with probability (a_i)\\/(a_i + a_j) and team j wins with probability (a_j)\\/(a_i + a_j).\\n\\nThe team is called a winner if it directly or indirectly defeated all other teams. Team a defeated (directly or indirectly) team b if there is a sequence of teams c_1, c_2, ... c_k such that c_1 = a, c_k = b and team c_i defeated team c_{i + 1} for all i from 1 to k - 1. Note that it is possible that team a defeated team b and in the same time team b defeated team a.\\n\\nWilliam wants you to find the expected value of the number of winners.\\n\\nInput\\n\\nThe first line contains a single integer n (1 \u2264 n \u2264 14), which is the total number of teams participating in a match.\\n\\nThe second line contains n integers a_1, a_2, ..., a_n (1 \u2264 a_i \u2264 10^6) \u2014 the strengths of teams participating in a match.\\n\\nOutput\\n\\nOutput a single integer \u2014 the expected value of the number of winners of the tournament modulo 10^9 + 7.\\n\\nFormally, let M = 10^9+7. It can be demonstrated that the answer can be presented as a irreducible fraction p\\/q, where p and q are integers and q not \u2261 0 \\\\pmod{M}. Output a single integer equal to p \u22c5 q^{-1} mod M. In other words, output an integer x such that 0 \u2264 x < M and x \u22c5 q \u2261 p \\\\pmod{M}.\\n\\nExamples\\n\\nInput\\n\\n\\n2\\n1 2\\n\\n\\nOutput\\n\\n\\n1\\n\\n\\nInput\\n\\n\\n5\\n1 5 2 11 14\\n\\n\\nOutput\\n\\n\\n642377629\\n\\nNote\\n\\nTo better understand in which situation several winners are possible let's examine the second test:\\n\\nOne possible result of the tournament is as follows (a \u2192 b means that a defeated b):\\n\\n  * 1 \u2192 2 \\n  * 2 \u2192 3 \\n  * 3 \u2192 1 \\n  * 1 \u2192 4 \\n  * 1 \u2192 5 \\n  * 2 \u2192 4 \\n  * 2 \u2192 5 \\n  * 3 \u2192 4 \\n  * 3 \u2192 5 \\n  * 4 \u2192 5 \\n\\n\\n\\nOr more clearly in the picture:\\n\\n<image>\\n\\nIn this case every team from the set \\\\{ 1, 2, 3 \\\\} directly or indirectly defeated everyone. I.e.:\\n\\n  * 1st defeated everyone because they can get to everyone else in the following way...\\n#incl\",\"targets\":\"ude <bits\\/stdc++.h>\\nusing namespace std;\\nlong long read() {\\n  long long x = 0, f = 1;\\n  char ch = ' ';\\n  while (!isdigit(ch)) {\\n    ch = getchar();\\n    if (ch == '-') f = -1;\\n  }\\n  while (isdigit(ch)) x = (x << 3) + (x << 1) + ch - '0', ch = getchar();\\n  return x * f;\\n}\\nconst int mod = 1e9 + 7;\\nint n, a[15], f[1 << 14], g[1 << 14];\\nint ni[15][15];\\nint P(int s, int t) {\\n  int res = 1;\\n  for (int i = 0; i < n; i++) {\\n    if (!(s & (1 << i))) continue;\\n    for (int j = 0; j < n; j++) {\\n      if (!(t & (1 << j))) continue;\\n      res = 1ll * res * ni[i][j] % mod;\\n    }\\n  }\\n  return res;\\n}\\nint fpow(int n) {\\n  int res = 1, m = mod - 2;\\n  while (m) {\\n    if (m & 1) res = 1ll * res * n % mod;\\n    n = 1ll * n * n % mod;\\n    m >>= 1;\\n  }\\n  return res;\\n}\\nint main() {\\n  cin >> n;\\n  for (int i = 0; i < n; i++) a[i] = read();\\n  for (int i = 0; i < n; i++) {\\n    for (int j = 0; j < n; j++) {\\n      ni[i][j] = 1ll * a[i] * fpow(a[i] + a[j]) % mod;\\n    }\\n  }\\n  for (int i = 0; i < (1 << n); i++) {\\n    long long s = (1 << n) - 1 - i;\\n    g[i] = P(i, s);\\n  }\\n  int ans = 0;\\n  for (int i = 0; i < (1 << n); i++) {\\n    int cur = g[i];\\n    for (int j = (i - 1) & i; j; j = (j - 1) & i) {\\n      int res = 1;\\n      for (int p = 0; p < n; p++) {\\n        if (!((i - j) & (1 << p))) continue;\\n        for (int q = 0; q < n; q++) {\\n          if (!(j & (1 << q))) continue;\\n          res = 1ll * res * ni[p][q] % mod;\\n        }\\n      }\\n      cur -= 1ll * f[j] * g[i - j] % mod * fpow(res) % mod;\\n      if (cur < 0) cur += mod;\\n    }\\n    f[i] = cur;\\n    int num = 0;\\n    for (int j = 0; j < n; j++) {\\n      if (i & (1 << j)) num++;\\n    }\\n    ans += 1ll * cur * num % mod;\\n    if (ans > mod) ans -= mod;\\n  }\\n  cout << ans;\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"Pasha loves to send strictly positive integers to his friends. Pasha cares about security, therefore when he wants to send an integer n, he encrypts it in the following way: he picks three integers a, b and c such that l \u2264 a,b,c \u2264 r, and then he computes the encrypted value m = n \u22c5 a + b - c.\\n\\nUnfortunately, an adversary intercepted the values l, r and m. Is it possible to recover the original values of a, b and c from this information? More formally, you are asked to find any values of a, b and c such that\\n\\n  * a, b and c are integers, \\n  * l \u2264 a, b, c \u2264 r, \\n  * there exists a strictly positive integer n, such that n \u22c5 a + b - c = m. \\n\\nInput\\n\\nThe first line contains the only integer t (1 \u2264 t \u2264 20) \u2014 the number of test cases. The following t lines describe one test case each.\\n\\nEach test case consists of three integers l, r and m (1 \u2264 l \u2264 r \u2264 500 000, 1 \u2264 m \u2264 10^{10}). The numbers are such that the answer to the problem exists.\\n\\nOutput\\n\\nFor each test case output three integers a, b and c such that, l \u2264 a, b, c \u2264 r and there exists a strictly positive integer n such that n \u22c5 a + b - c = m. It is guaranteed that there is at least one possible solution, and you can output any possible combination if there are multiple solutions.\\n\\nExample\\n\\nInput\\n\\n\\n2\\n4 6 13\\n2 3 1\\n\\n\\nOutput\\n\\n\\n4 6 5\\n2 2 3\\n\\nNote\\n\\nIn the first example n = 3 is possible, then n \u22c5 4 + 6 - 5 = 13 = m. Other possible solutions include: a = 4, b = 5, c = 4 (when n = 3); a = 5, b = 4, c = 6 (when n = 3); a = 6, b = 6, c = 5 (when n = 2); a = 6, b = 5, c = 4 (when n = 2).\\n\\nIn the second example the only possible case is n = 1: in this case n \u22c5 2 + 2 - 3 = 1 = m. Note that, n = 0 is not possible, since in that case n is not a strictly positive integer.\\\":\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint main() {\\n  long long t = 0;\\n  cin >> t;\\n  while (t--) {\\n    long long l = 0, r = 0, m = 0;\\n    cin >> l >> r >> m;\\n    for (long long i = l; i <= r; i++) {\\n      long long bc = m % i, n = m \\/ i;\\n      if (n >= 1 && bc <= r - l) {\\n        cout << i << ' ' << l + bc << ' ' << l << endl;\\n        break;\\n      } else {\\n        bc = bc - i;\\n        if (bc >= l - r) {\\n          cout << i << ' ' << r + bc << ' ' << r << endl;\\n          break;\\n        }\\n      }\\n    }\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You are given an undirected weighted graph, consisting of n vertices and m edges.\\n\\nSome queries happen with this graph:\\n\\n  * Delete an existing edge from the graph. \\n  * Add a non-existing edge to the graph. \\n\\n\\n\\nAt the beginning and after each query, you should find four different vertices a, b, c, d such that there exists a path between a and b, there exists a path between c and d, and the sum of lengths of two shortest paths from a to b and from c to d is minimal. The answer to the query is the sum of the lengths of these two shortest paths. The length of the path is equal to the sum of weights of edges in this path.\\n\\nInput\\n\\nThe first line contains two integers n and m (4 \u2264 n, m \u2264 10^5) \u2014 the number of vertices and edges in the graph respectively.\\n\\nEach of the next m lines contain three integers v, u, w (1 \u2264 v, u \u2264 n, v \u2260 u, 1 \u2264 w \u2264 10^9) \u2014 this triple means that there is an edge between vertices v and u with weight w.\\n\\nThe next line contains a single integer q (0 \u2264 q \u2264 10^5) \u2014 the number of queries.\\n\\nThe next q lines contain the queries of two types:\\n\\n  * 0 v u \u2014 this query means deleting an edge between v and u (1 \u2264 v, u \u2264 n, v \u2260 u). It is guaranteed that such edge exists in the graph. \\n  * 1 v u w \u2014 this query means adding an edge between vertices v and u with weight w (1 \u2264 v, u \u2264 n, v \u2260 u, 1 \u2264 w \u2264 10^9). It is guaranteed that there was no such edge in the graph. \\n\\n\\n\\nIt is guaranteed that the initial graph does not contain multiple edges.\\n\\nAt the beginning and after each query, the graph doesn't need to be connected.\\n\\nIt is guaranteed that at each moment the number of edges will be at least 4. It can be proven, that at each moment there exist some four vertices a, b, c, d such that there exists a path between vertices a and b, and there exists a path between vertices c and d.\\n\\nOutput\\n\\nPrint q + 1 integers \u2014 the minimal sum of lengths of shortest paths between chosen pairs of vertices before the queries and after each of them.\\n\\nExample\\n\\nInput\\n\\n\\n6 6\\n1 3 6\\n4 3 1\\n1 4 1\\n2 6 4\\n2 4 2\\n5 4 3\\n4\\n1 2 5 2\\n0 1 4\\n0 3...\\n#incl\",\"targets\":\"ude <bits\\/stdc++.h>\\nusing namespace std;\\nmt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\\ntemplate <class T>\\nT rand(T a, T b) {\\n  return uniform_int_distribution<T>(a, b)(rng);\\n}\\nconst int c = 100005, k = 140, sok = 2e9;\\nint n, m, q;\\nbool t[c][k];\\nmap<pair<int, int>, int> el;\\nmultiset<int> s1[c];\\npriority_queue<int, vector<int>, greater<int> > aa[k][2], bb[k][2];\\nmultiset<long long> r;\\nlong long res(int a) {\\n  long long ans = 0;\\n  int cnt = 0;\\n  for (auto x : s1[a]) {\\n    ans += x;\\n    cnt++;\\n    if (cnt == 3) {\\n      return ans;\\n    }\\n  }\\n}\\nvoid valt(int id) {\\n  int a, b, suly;\\n  cin >> a >> b;\\n  if (a > b) {\\n    swap(a, b);\\n  }\\n  if (id) {\\n    cin >> el[{a, b}];\\n  }\\n  suly = el[{a, b}];\\n  if (!id) {\\n    el.erase({a, b});\\n  }\\n  r.erase(r.find(res(a))), r.erase(r.find(res(b)));\\n  if (id) {\\n    s1[a].insert(suly), s1[b].insert(suly);\\n  } else {\\n    s1[a].erase(s1[a].find(suly)), s1[b].erase(s1[b].find(suly));\\n  }\\n  r.insert(res(a)), r.insert(res(b));\\n  for (int i = 0; i < k; i++) {\\n    if (t[a][i] == t[b][i]) {\\n      int h = t[a][i];\\n      if (id) {\\n        aa[i][h].push(suly);\\n      } else {\\n        bb[i][h].push(suly);\\n      }\\n    }\\n  }\\n}\\nvoid calc() {\\n  long long mini = *(r.begin());\\n  for (int i = 0; i < k; i++) {\\n    long long sum = 0;\\n    for (int j = 0; j < 2; j++) {\\n      while (aa[i][j].top() == bb[i][j].top()) {\\n        aa[i][j].pop(), bb[i][j].pop();\\n      }\\n      sum += aa[i][j].top();\\n    }\\n    mini = min(mini, sum);\\n  }\\n  cout << mini << \\\"\\\\n\\\";\\n}\\nint main() {\\n  ios_base::sync_with_stdio(false);\\n  cin.tie(0);\\n  cin >> n >> m;\\n  for (int i = 1; i <= n; i++) {\\n    for (int j = 1; j <= 3; j++) {\\n      s1[i].insert(sok);\\n    }\\n    r.insert(res(i));\\n  }\\n  for (int j = 0; j < k; j++) {\\n    for (int i = 1; i <= n; i++) {\\n      t[i][j] = rand(0, 1);\\n    }\\n    aa[j][0].push(sok), aa[j][1].push(sok);\\n    bb[j][0].push(sok + 1), bb[j][1].push(sok + 1);\\n  }\\n  for (int i = 1; i <= m; i++) {\\n    valt(1);\\n  }\\n  calc();\\n  cin >> q;\\n  for (int i = 1; i <= q; i++) {\\n    int id;\\n    cin >> id;\\n   ...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Anton and Dasha like to play different games during breaks on checkered paper. By the 11th grade they managed to play all the games of this type and asked Vova the programmer to come up with a new game. Vova suggested to them to play a game under the code name \\\"dot\\\" with the following rules: \\n\\n  * On the checkered paper a coordinate system is drawn. A dot is initially put in the position (x, y). \\n  * A move is shifting a dot to one of the pre-selected vectors. Also each player can once per game symmetrically reflect a dot relatively to the line y = x. \\n  * Anton and Dasha take turns. Anton goes first. \\n  * The player after whose move the distance from the dot to the coordinates' origin exceeds d, loses. \\n\\n\\n\\nHelp them to determine the winner.\\n\\nInput\\n\\nThe first line of the input file contains 4 integers x, y, n, d ( - 200 \u2264 x, y \u2264 200, 1 \u2264 d \u2264 200, 1 \u2264 n \u2264 20) \u2014 the initial coordinates of the dot, the distance d and the number of vectors. It is guaranteed that the initial dot is at the distance less than d from the origin of the coordinates. The following n lines each contain two non-negative numbers xi and yi (0 \u2264 xi, yi \u2264 200) \u2014 the coordinates of the i-th vector. It is guaranteed that all the vectors are nonzero and different.\\n\\nOutput\\n\\nYou should print \\\"Anton\\\", if the winner is Anton in case of both players play the game optimally, and \\\"Dasha\\\" otherwise.\\n\\nExamples\\n\\nInput\\n\\n0 0 2 3\\n1 1\\n1 2\\n\\n\\nOutput\\n\\nAnton\\n\\nInput\\n\\n0 0 2 4\\n1 1\\n1 2\\n\\n\\nOutput\\n\\nDasha\\n\\nNote\\n\\nIn the first test, Anton goes to the vector (1;2), and Dasha loses. In the second test Dasha with her first move shifts the dot so that its coordinates are (2;3), and Anton loses, as he has the only possible move \u2014 to reflect relatively to the line y = x. Dasha will respond to it with the same move and return the dot in position (2;3).\\n#incl\",\"targets\":\"ude <bits\\/stdc++.h>\\nusing namespace std;\\nint x, y, n, d, dx[20], dy[20];\\nmap<pair<int, int>, bool> mem;\\nbool gao(int x, int y) {\\n  if (mem.count(pair<int, int>(x, y))) return mem[pair<int, int>(x, y)];\\n  if (x * x + y * y > d * d) return mem[pair<int, int>(x, y)] = true;\\n  for (int i = 0; i < n; i++)\\n    if (!gao(x + dx[i], y + dy[i])) return mem[pair<int, int>(x, y)] = true;\\n  return mem[pair<int, int>(x, y)] = false;\\n}\\nint main() {\\n  scanf(\\\"%d%d%d%d\\\", &x, &y, &n, &d);\\n  for (int i = 0; i < n; i++) scanf(\\\"%d%d\\\", &dx[i], &dy[i]);\\n  puts(gao(x, y) ? \\\"Anton\\\" : \\\"Dasha\\\");\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"JAVA solution for \\\"Petya has got an interesting flower. Petya is a busy person, so he sometimes forgets to water it. You are given n days from Petya's live and you have to determine what happened with his flower in the end.\\n\\nThe flower grows as follows: \\n\\n  * If the flower isn't watered for two days in a row, it dies. \\n  * If the flower is watered in the i-th day, it grows by 1 centimeter. \\n  * If the flower is watered in the i-th and in the (i-1)-th day (i > 1), then it grows by 5 centimeters instead of 1. \\n  * If the flower is not watered in the i-th day, it does not grow. \\n\\n\\n\\nAt the beginning of the 1-st day the flower is 1 centimeter tall. What is its height after n days?\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 100). Description of the test cases follows.\\n\\nThe first line of each test case contains the only integer n (1 \u2264 n \u2264 100).\\n\\nThe second line of each test case contains n integers a_1, a_2, ..., a_n (a_i = 0 or a_i = 1). If a_i = 1, the flower is watered in the i-th day, otherwise it is not watered.\\n\\nOutput\\n\\nFor each test case print a single integer k \u2014 the flower's height after n days, or -1, if the flower dies.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n3\\n1 0 1\\n3\\n0 1 1\\n4\\n1 0 0 1\\n1\\n0\\n\\n\\nOutput\\n\\n\\n3\\n7\\n-1\\n1\\\":\",\"targets\":\"import java.util.Scanner;\\n\\npublic class Flower {\\n    public static void main(String args[]) {\\n        Scanner sc=new Scanner(System.in);\\n        int t=sc.nextInt();\\n        while(t-->0) {\\n            int n=sc.nextInt();\\n            int curr=1;\\n            int arr[]=new int[n];\\n            for(int i=0;i<n;i++)\\n                arr[i]=sc.nextInt();\\n            for(int i=0;i<n;i++) {\\n                if(arr[i]==1 && i>0 && arr[i-1]==1)\\n                    curr+=5;\\n                else if(arr[i]==0 && i>0 && arr[i-1]==0) {\\n                    curr=-1;\\n                    break;\\n                }\\n                else if(arr[i]==1)\\n                    curr++;\\n                \\/\\/System.out.println(curr+\\\" \\\"+x+\\\" \\\"+prev);\\n                \\/\\/prev=x;\\n                if(curr==-1) {\\n                    break;\\n                }\\n            }\\n            System.out.println(curr);\\n        }\\n    }\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"A string is called bracket sequence if it does not contain any characters other than \\\"(\\\" and \\\")\\\". A bracket sequence is called regular if it it is possible to obtain correct arithmetic expression by inserting characters \\\"+\\\" and \\\"1\\\" into this sequence. For example, \\\"\\\", \\\"(())\\\" and \\\"()()\\\" are regular bracket sequences; \\\"))\\\" and \\\")((\\\" are bracket sequences (but not regular ones), and \\\"(a)\\\" and \\\"(1)+(1)\\\" are not bracket sequences at all.\\n\\nYou have a number of strings; each string is a bracket sequence of length 2. So, overall you have cnt_1 strings \\\"((\\\", cnt_2 strings \\\"()\\\", cnt_3 strings \\\")(\\\" and cnt_4 strings \\\"))\\\". You want to write all these strings in some order, one after another; after that, you will get a long bracket sequence of length 2(cnt_1 + cnt_2 + cnt_3 + cnt_4). You wonder: is it possible to choose some order of the strings you have such that you will get a regular bracket sequence? Note that you may not remove any characters or strings, and you may not add anything either.\\n\\nInput\\n\\nThe input consists of four lines, i-th of them contains one integer cnt_i (0 \u2264 cnt_i \u2264 10^9).\\n\\nOutput\\n\\nPrint one integer: 1 if it is possible to form a regular bracket sequence by choosing the correct order of the given strings, 0 otherwise.\\n\\nExamples\\n\\nInput\\n\\n\\n3\\n1\\n4\\n3\\n\\n\\nOutput\\n\\n\\n1\\n\\n\\nInput\\n\\n\\n0\\n0\\n0\\n0\\n\\n\\nOutput\\n\\n\\n1\\n\\n\\nInput\\n\\n\\n1\\n2\\n3\\n4\\n\\n\\nOutput\\n\\n\\n0\\n\\nNote\\n\\nIn the first example it is possible to construct a string \\\"(())()(()((()()()())))\\\", which is a regular bracket sequence.\\n\\nIn the second example it is possible to construct a string \\\"\\\", which is a regular bracket sequence.\",\"targets\":\"import java.util.Scanner;\\n\\npublic class Sir {\\n    public static void main(String[] args) {\\n        Scanner in = new Scanner(System.in);\\n        int a1 = in.nextInt();\\n        int a2 = in.nextInt();\\n        int a3 = in.nextInt();\\n        int a4 = in.nextInt();\\n        if((a1 != a4) || (a1 == 0 && a3 != 0)){\\n            System.out.println(0);\\n        }else{\\n            System.out.println(1);\\n        }\\n    }\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"JAVA solution for \\\"Frodo was caught by Saruman. He tore a pouch from Frodo's neck, shook out its contents \u2014there was a pile of different rings: gold and silver...\\n\\n\\\"How am I to tell which is the One?!\\\" the mage howled.\\n\\n\\\"Throw them one by one into the Cracks of Doom and watch when Mordor falls!\\\" \\n\\nSomewhere in a parallel Middle-earth, when Saruman caught Frodo, he only found n rings. And the i-th ring was either gold or silver. For convenience Saruman wrote down a binary string s of n characters, where the i-th character was 0 if the i-th ring was gold, and 1 if it was silver.\\n\\nSaruman has a magic function f, which takes a binary string and returns a number obtained by converting the string into a binary number and then converting the binary number into a decimal number. For example, f(001010) = 10, f(111) = 7, f(11011101) = 221.\\n\\nSaruman, however, thinks that the order of the rings plays some important role. He wants to find 2 pairs of integers (l_1, r_1), (l_2, r_2), such that:\\n\\n  * 1 \u2264 l_1 \u2264 n, 1 \u2264 r_1 \u2264 n, r_1-l_1+1\u2265 \u230a n\\/2 \u230b \\n  * 1 \u2264 l_2 \u2264 n, 1 \u2264 r_2 \u2264 n, r_2-l_2+1\u2265 \u230a n\\/2 \u230b \\n  * Pairs (l_1, r_1) and (l_2, r_2) are distinct. That is, at least one of l_1 \u2260 l_2 and r_1 \u2260 r_2 must hold.\\n  * Let t be the substring s[l_1:r_1] of s, and w be the substring s[l_2:r_2] of s. Then there exists non-negative integer k, such that f(t) = f(w) \u22c5 k.\\n\\n\\n\\nHere substring s[l:r] denotes s_ls_{l+1}\u2026 s_{r-1}s_r, and \u230a x \u230b denotes rounding the number down to the nearest integer.\\n\\nHelp Saruman solve this problem! It is guaranteed that under the constraints of the problem at least one solution exists.\\n\\nInput\\n\\nEach test contains multiple test cases.\\n\\nThe first line contains one positive integer t (1 \u2264 t \u2264 10^3), denoting the number of test cases. Description of the test cases follows.\\n\\nThe first line of each test case contains one positive integer n (2 \u2264 n \u2264 2 \u22c5 10^4) \u2014 length of the string.\\n\\nThe second line of each test case contains a non-empty binary string of length n.\\n\\nIt is guaranteed that the sum of n over all test cases does not exceed...\\\":\",\"targets\":\"import java.util.Scanner;\\n\\npublic class Main {\\n    static Scanner in = new Scanner(System.in);\\n    public static void main(String[] args) {\\n\\n        int t = in.nextInt();\\n\\n        while (t-- > 0){\\n           solve();\\n\\n        }\\n    }\\n\\n    private static void solve() {\\n\\n        int n = in.nextInt();\\n        char []chs = in.next().toCharArray();\\n        int []nums = new int[chs.length];\\n        int ans = 0;\\n        for(int i=0; i<chs.length; i++){\\n            nums[i] = chs[i]-'0';\\n            ans += nums[i];\\n        }\\n        if (ans == n){\\n            System.out.printf(\\\"%d %d %d %d\\\\n\\\", 1, n\\/2, 2, n\\/2+1);\\n            return;\\n        }\\n\\n        for (int i = 0; i < n\\/2; i++) {\\n            if(nums[i] == 0){\\n                System.out.printf(\\\"%d %d %d %d\\\\n\\\", i+1, n, i+2, n);\\n                return;\\n            }\\n        }\\n\\n        for (int i = n\\/2; i < n; i++) {\\n            if(nums[i] == 0){\\n                System.out.printf(\\\"%d %d %d %d\\\\n\\\", 1, i+1, 1, i);\\n                return;\\n            }\\n        }\\n\\n    }\\n\\n\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"The only difference between this problem and D2 is that you don't have to provide the way to construct the answer in this problem, but you have to do it in D2.\\n\\nThere's a table of n \u00d7 m cells (n rows and m columns). The value of n \u22c5 m is even.\\n\\nA domino is a figure that consists of two cells having a common side. It may be horizontal (one of the cells is to the right of the other) or vertical (one of the cells is above the other).\\n\\nYou need to find out whether it is possible to place nm\\/2 dominoes on the table so that exactly k of them are horizontal and all the other dominoes are vertical. The dominoes cannot overlap and must fill the whole table.\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 10) \u2014 the number of test cases. Then t test cases follow.\\n\\nEach test case consists of a single line. The line contains three integers n, m, k (1 \u2264 n,m \u2264 100, 0 \u2264 k \u2264 nm\\/2, n \u22c5 m is even) \u2014 the number of rows, columns and horizontal dominoes, respectively.\\n\\nOutput\\n\\nFor each test case output \\\"YES\\\", if it is possible to place dominoes in the desired way, or \\\"NO\\\" otherwise.\\n\\nYou may print each letter in any case (YES, yes, Yes will all be recognized as positive answer, NO, no and nO will all be recognized as negative answer).\\n\\nExample\\n\\nInput\\n\\n\\n8\\n4 4 2\\n2 3 0\\n3 2 3\\n1 2 0\\n2 4 2\\n5 2 2\\n2 17 16\\n2 1 1\\n\\n\\nOutput\\n\\n\\nYES\\nYES\\nYES\\nNO\\nYES\\nNO\\nYES\\nNO\\nUsing cpp can you solve the prior task?\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint n, M;\\nchar s[105][105];\\nvoid H(int x, int y) { s[x][y] = (x + y \\/ 2) % 2 == 0 ? 'a' : 'b'; }\\nvoid V(int x, int y) { s[x][y] = (x \\/ 2 + y) % 2 == 0 ? 'c' : 'd'; }\\nchar vv(int x, int y) { return (x \\/ 2 + y) % 2 == 0 ? 'c' : 'd'; }\\nint main() {\\n  cin.tie(0);\\n  cout.tie(0);\\n  ios::sync_with_stdio(0);\\n  int tc, m, k;\\n  cin >> tc;\\n  while (tc--) {\\n    cin >> n >> m >> k;\\n    M = m;\\n    for (int i = 0; i < n; i++)\\n      for (int j = 0; j < m; j++) V(i, j);\\n    if (n % 2) {\\n      k -= m \\/ 2;\\n      if (k < 0 || k % 2)\\n        cout << \\\"NO\\\" << endl;\\n      else {\\n        cout << \\\"YES\\\" << endl;\\n        for (int i = 0; i < n; i++)\\n          for (int j = 0; j < m; j++) s[i][j] = vv(i - 1, j);\\n        for (int i = 0; i < m; i++) {\\n          H(0, i);\\n        }\\n        for (int i = 1; i < n && k > 0; i += 2) {\\n          for (int j = 0; j < m && k > 0; j += 2) {\\n            k -= 2;\\n            H(i, j);\\n            H(i + 1, j);\\n            H(i + 1, j + 1);\\n            H(i, j + 1);\\n          }\\n        }\\n      }\\n      continue;\\n    } else if (m % 2) {\\n      m--;\\n    }\\n    if (n * m \\/ 2 < k || k % 2)\\n      cout << \\\"NO\\\" << endl;\\n    else {\\n      cout << \\\"YES\\\" << endl;\\n      for (int i = 0; i < n && k > 0; i += 2) {\\n        for (int j = 0; j < m && k > 0; j += 2) {\\n          k -= 2;\\n          H(i, j);\\n          H(i + 1, j);\\n          H(i + 1, j + 1);\\n          H(i, j + 1);\\n        }\\n      }\\n    }\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in CPP?\\nLet's analyze a program written on some strange programming language. The variables in this language have names consisting of 1 to 4 characters, and each character is a lowercase or an uppercase Latin letter, or a digit. There is an extra constraint that the first character should not be a digit.\\n\\nThere are four types of operations in the program, each denoted by one of the characters: $, ^, # or &.\\n\\nEach line of the program has one of the following formats: \\n\\n  * <lvalue>=<rvalue>, where <lvalue> and <rvalue> are valid variable names; \\n  * <lvalue>=<arg1><op><arg2>, where <lvalue>, <arg1> and <arg2> are valid variable names, and <op> is an operation character. \\n\\n\\n\\nThe program is executed line-by-line, and the result of execution is stored in a variable having the name res. If res is never assigned in the program, then the result will be equal to the value of res before running the program.\\n\\nTwo programs are called equivalent if no matter which operations do characters $, ^, # and & denote (but, obviously, performing the same operation on the same arguments gives the same result) and which values do variables have before execution of program, the value of res after running the first program is equal to the value of res after running the second program (the programs are executed independently).\\n\\nYou are given a program consisting of n lines. Your task is to write a program consisting of minimum possible number of lines that is equivalent to the program you are given.\\n\\nInput\\n\\nThe first line contains one integer n (1 \u2264 n \u2264 1000) \u2014 the number of lines in the program.\\n\\nThen n lines follow \u2014 the program itself. Each line corresponds to the format described in the statement and has no extra whitespaces.\\n\\nOutput\\n\\nIn the first line print k \u2014 the minimum number of lines in the equivalent program.\\n\\nThen print k lines without any whitespaces \u2014 an equivalent program having exactly k lines, in the same format it is described in the...\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nusing ll = long long;\\nusing ld = long double;\\nusing ull = unsigned long long;\\nusing pii = pair<int, int>;\\nusing vpii = vector<pii>;\\nusing unt = unsigned int;\\nint popc(unt a) { return __builtin_popcount(a); }\\nint popc(int a) { return __builtin_popcount(a); }\\nint popc(ll a) { return __builtin_popcountll(a); }\\nint popc(ull a) { return __builtin_popcountll(a); }\\nint ctz(unt a) { return __builtin_ctz(a); }\\nint ctz(int a) { return __builtin_ctz(a); }\\nint ctz(ll a) { return __builtin_ctzll(a); }\\nint ctz(ull a) { return __builtin_ctzll(a); }\\nint clz(unt a) { return __builtin_clz(a); }\\nint clz(int a) { return __builtin_clz(a); }\\nint clz(ll a) { return __builtin_clzll(a); }\\nint clz(ull a) { return __builtin_clzll(a); }\\ntemplate <class c, class N>\\nbool mini(c &o, N h) {\\n  if (o > h) return o = h, 1;\\n  return 0;\\n}\\ntemplate <class c, class N>\\nbool maxi(c &o, N h) {\\n  if (o < h) return o = h, 1;\\n  return 0;\\n}\\ntemplate <class c, class d, class e, class f>\\nauto operator+(pair<c, d> a, pair<e, f> b)\\n    -> decltype(make_pair(a.first + b.first, a.second + b.second)) {\\n  return {a.first + b.first, a.second + b.second};\\n}\\ntemplate <class c, class d, class e,\\n          class = typename enable_if<!is_base_of<ios_base, c>::value>::type>\\nauto operator+(c a, pair<d, e> b)\\n    -> decltype(make_pair(a + b.first, a + b.second)) {\\n  return {a + b.first, a + b.second};\\n}\\ntemplate <class c, class d, class e>\\nauto operator+(pair<c, d> a, e b)\\n    -> decltype(make_pair(a.first + b, a.second + b)) {\\n  return {a.first + b, a.second + b};\\n}\\ntemplate <class c, class d, class e>\\nvoid operator+=(pair<c, d> &a, e b) {\\n  a.first += b;\\n  a.second += b;\\n}\\ntemplate <class c, class d, class e, class f>\\nvoid operator+=(pair<c, d> &a, pair<e, f> b) {\\n  a.first += b.first;\\n  a.second += b.second;\\n}\\ntemplate <class c, class d, class e, class f>\\nauto operator-(pair<c, d> a, pair<e, f> b)\\n    -> decltype(make_pair(a.first - b.first, a.second - b.second)) {\\n  return {a.first - b.first, a.second -...\",\"language\":\"python\",\"split\":\"train\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Three little pigs from all over the world are meeting for a convention! Every minute, a triple of 3 new pigs arrives on the convention floor. After the n-th minute, the convention ends.\\n\\nThe big bad wolf has learned about this convention, and he has an attack plan. At some minute in the convention, he will arrive and eat exactly x pigs. Then he will get away.\\n\\nThe wolf wants Gregor to help him figure out the number of possible attack plans that involve eating exactly x pigs for various values of x (1 \u2264 x \u2264 3n). Two attack plans are considered different, if they occur at different times or if the sets of little pigs to eat are different.\\n\\nNote that all queries are independent, that is, the wolf does not eat the little pigs, he only makes plans!\\n\\nInput\\n\\nThe first line of input contains two integers n and q (1 \u2264 n \u2264 10^6, 1 \u2264 q \u2264 2\u22c5 10^5), the number of minutes the convention lasts and the number of queries the wolf asks.\\n\\nEach of the next q lines contains a single integer x_i (1 \u2264 x_i \u2264 3n), the number of pigs the wolf will eat in the i-th query.\\n\\nOutput\\n\\nYou should print q lines, with line i representing the number of attack plans if the wolf wants to eat x_i pigs. Since each query answer can be large, output each answer modulo 10^9+7.\\n\\nExamples\\n\\nInput\\n\\n\\n2 3\\n1\\n5\\n6\\n\\n\\nOutput\\n\\n\\n9\\n6\\n1\\n\\n\\nInput\\n\\n\\n5 4\\n2\\n4\\n6\\n8\\n\\n\\nOutput\\n\\n\\n225\\n2001\\n6014\\n6939\\n\\nNote\\n\\nIn the example test, n=2. Thus, there are 3 pigs at minute 1, and 6 pigs at minute 2. There are three queries: x=1, x=5, and x=6.\\n\\nIf the wolf wants to eat 1 pig, he can do so in 3+6=9 possible attack plans, depending on whether he arrives at minute 1 or 2.\\n\\nIf the wolf wants to eat 5 pigs, the wolf cannot arrive at minute 1, since there aren't enough pigs at that time. Therefore, the wolf has to arrive at minute 2, and there are 6 possible attack plans.\\n\\nIf the wolf wants to eat 6 pigs, his only plan is to arrive at the end of the convention and devour everybody.\\n\\nRemember to output your answers modulo 10^9+7!\\nThe above is tricky. Write me a correct solution in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing std::cin;\\nusing std::cout;\\nconst int N = 1000054, mod = 1000000007, iv3 = (mod + 1) \\/ 3;\\ntypedef int vec[3 * N];\\nint n, q;\\nvec f, g, fact, finv;\\nlong long PowerMod(long long a, int n, long long c = 1) {\\n  for (; n; n >>= 1, a = a * a % mod)\\n    if (n & 1) c = c * a % mod;\\n  return c;\\n}\\nvoid init(int n) {\\n  int i;\\n  for (*fact = i = 1; i <= n; ++i) fact[i] = (long long)fact[i - 1] * i % mod;\\n  finv[n] = PowerMod(fact[n], mod - 2);\\n  for (i = n; i; --i) finv[i - 1] = (long long)finv[i] * i % mod;\\n}\\ninline long long C(int n, int r) {\\n  return (long long)fact[n] * finv[r] % mod * finv[n - r] % mod;\\n}\\nvoid work() {\\n  int i, m = 3 * (n + 1);\\n  init(m);\\n  for (i = 0; i < m; ++i) f[i] = C(m, i + 1);\\n  *g = n + 1, g[1] = n * (n + 1ll) \\/ 2 * 3 % mod;\\n  for (i = 2; i < m; ++i)\\n    g[i] = (long long(f[i] - g[i - 2] + mod) * iv3 + mod - g[i - 1]) % mod;\\n}\\nint main() {\\n  int i;\\n  std::ios::sync_with_stdio(false), cin.tie(nullptr);\\n  cin >> n >> q, work();\\n  for (; q; --q) cin >> i, cout << g[i] << '\\\\n';\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in JAVA?\\nAlice and Bob are playing a game on a matrix, consisting of 2 rows and m columns. The cell in the i-th row in the j-th column contains a_{i, j} coins in it.\\n\\nInitially, both Alice and Bob are standing in a cell (1, 1). They are going to perform a sequence of moves to reach a cell (2, m).\\n\\nThe possible moves are: \\n\\n  * Move right \u2014 from some cell (x, y) to (x, y + 1); \\n  * Move down \u2014 from some cell (x, y) to (x + 1, y). \\n\\n\\n\\nFirst, Alice makes all her moves until she reaches (2, m). She collects the coins in all cells she visit (including the starting cell).\\n\\nWhen Alice finishes, Bob starts his journey. He also performs the moves to reach (2, m) and collects the coins in all cells that he visited, but Alice didn't.\\n\\nThe score of the game is the total number of coins Bob collects.\\n\\nAlice wants to minimize the score. Bob wants to maximize the score. What will the score of the game be if both players play optimally?\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 10^4) \u2014 the number of testcases.\\n\\nThen the descriptions of t testcases follow.\\n\\nThe first line of the testcase contains a single integer m (1 \u2264 m \u2264 10^5) \u2014 the number of columns of the matrix.\\n\\nThe i-th of the next 2 lines contain m integers a_{i,1}, a_{i,2}, ..., a_{i,m} (1 \u2264 a_{i,j} \u2264 10^4) \u2014 the number of coins in the cell in the i-th row in the j-th column of the matrix.\\n\\nThe sum of m over all testcases doesn't exceed 10^5.\\n\\nOutput\\n\\nFor each testcase print a single integer \u2014 the score of the game if both players play optimally.\\n\\nExample\\n\\nInput\\n\\n\\n3\\n3\\n1 3 7\\n3 5 1\\n3\\n1 3 9\\n3 5 1\\n1\\n4\\n7\\n\\n\\nOutput\\n\\n\\n7\\n8\\n0\\n\\nNote\\n\\nThe paths for the testcases are shown on the following pictures. Alice's path is depicted in red and Bob's path is depicted in blue.\\n\\n<image>\",\"targets\":\"import java.util.*;\\n\\npublic class B {\\n\\n\\n    public static void main(String[] args) {\\n        Scanner sc = new Scanner(System.in);\\n       \\/\\/ System.out.println(1|3);\\n\\n        int t = sc.nextInt();\\n        while (t-- > 0) {\\n            int n=sc.nextInt();\\n\\n            int [][]a=new int[2][n];\\n                    int y=0;\\n                    int ans=Integer.MAX_VALUE;\\n                    int x=0;\\n            for(int i=0;i<2;i++){\\n                for(int j=0;j<n;j++){\\n                   a[i][j]=sc.nextInt();\\n                    if(i==0)y+=a[i][j];\\n                }\\n            }\\n            for(int i=0;i<n;i++){\\n                y-=a[0][i];\\n                ans=Math.min(ans,Math.max(x,y));\\n                x+=a[1][i];\\n            }\\n            System.out.println(ans);\\n\\n        }\\n    }\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"This is the easy version of the problem. The only difference between the two versions is the constraint on n. You can make hacks only if all versions of the problem are solved.\\n\\nA forest is an undirected graph without cycles (not necessarily connected).\\n\\nMocha and Diana are friends in Zhijiang, both of them have a forest with nodes numbered from 1 to n, and they would like to add edges to their forests such that: \\n\\n  * After adding edges, both of their graphs are still forests. \\n  * They add the same edges. That is, if an edge (u, v) is added to Mocha's forest, then an edge (u, v) is added to Diana's forest, and vice versa. \\n\\n\\n\\nMocha and Diana want to know the maximum number of edges they can add, and which edges to add.\\n\\nInput\\n\\nThe first line contains three integers n, m_1 and m_2 (1 \u2264 n \u2264 1000, 0 \u2264 m_1, m_2 < n) \u2014 the number of nodes and the number of initial edges in Mocha's forest and Diana's forest.\\n\\nEach of the next m_1 lines contains two integers u and v (1 \u2264 u, v \u2264 n, u \u2260 v) \u2014 the edges in Mocha's forest.\\n\\nEach of the next m_2 lines contains two integers u and v (1 \u2264 u, v \u2264 n, u \u2260 v) \u2014 the edges in Diana's forest.\\n\\nOutput\\n\\nThe first line contains only one integer h, the maximum number of edges Mocha and Diana can add (in each forest).\\n\\nEach of the next h lines contains two integers u and v (1 \u2264 u, v \u2264 n, u \u2260 v) \u2014 the edge you add each time.\\n\\nIf there are multiple correct answers, you can print any one of them.\\n\\nExamples\\n\\nInput\\n\\n\\n3 2 2\\n1 2\\n2 3\\n1 2\\n1 3\\n\\n\\nOutput\\n\\n\\n0\\n\\n\\nInput\\n\\n\\n5 3 2\\n5 4\\n2 1\\n4 3\\n4 3\\n1 4\\n\\n\\nOutput\\n\\n\\n1\\n2 4\\n\\n\\nInput\\n\\n\\n8 1 2\\n1 7\\n2 6\\n1 5\\n\\n\\nOutput\\n\\n\\n5\\n5 2\\n2 3\\n3 4\\n4 7\\n6 8\\n\\nNote\\n\\nIn the first example, we cannot add any edge.\\n\\nIn the second example, the initial forests are as follows.\\n\\n<image>\\n\\nWe can add an edge (2, 4).\\n\\n<image>\\nimpor\",\"targets\":\"t java.io.BufferedReader;\\nimport java.io.BufferedWriter;\\nimport java.io.IOException;\\nimport java.io.InputStreamReader;\\nimport java.io.OutputStreamWriter;\\nimport java.util.*;\\npublic class mocha {\\n\\n\\tpublic static void main(String[] args) throws IOException {\\n\\n\\t\\t\\n\\/\\/\\t\\tScanner sc = new Scanner(System.in);\\n\\t\\tFastReader sc = new FastReader();\\n\\t\\tBufferedWriter output = new BufferedWriter(\\n\\t            new OutputStreamWriter(System.out));\\n\\t\\tint n = sc.nextInt();\\n\\t\\tint a = sc.nextInt();\\n\\t\\tint b = sc.nextInt();\\n\\/\\/\\t\\tArrayList<Integer>[] al1 = new ArrayList[n];\\n\\/\\/\\t\\tArrayList<Integer>[] al2 = new ArrayList[n];\\n\\/\\/\\t\\tfor(int i =0 ; i<n;i++)\\n\\/\\/\\t\\t\\tal1[i] = new ArrayList<Integer>();\\n\\/\\/\\t\\t\\t\\n\\/\\/\\t\\tfor(int i =0 ; i<n;i++)\\n\\/\\/\\t\\t\\tal2[i] = new ArrayList<Integer>();\\t\\n\\t\\t\\n\\t\\tint [] arr1 = new int[n];\\n\\t\\tArrays.fill(arr1, -1);\\n\\t\\tint [] arr2 = new int[n];\\n\\t\\tArrays.fill(arr2, -1);\\n\\t\\t\\t\\n\\t\\tfor(int i =0 ; i<a;i++) {\\n\\t\\t\\tint x = sc.nextInt()-1;\\n\\t\\t\\tint y= sc.nextInt()-1;\\n\\t\\t\\tunion(arr1,x,y);\\n\\/\\/\\t\\t\\tal1[x].add(y); \\n\\t\\t}\\n\\t\\tfor(int i =0 ; i<b;i++) {\\n\\t\\t\\tint x = sc.nextInt()-1;\\n\\t\\t\\tint y= sc.nextInt()-1;\\n\\t\\t\\tunion(arr2,x,y);\\n\\/\\/\\t\\t\\tal2[x].add(y); \\n\\t\\t}\\t\\n\\/\\/\\tfor(int i = 0 ; i<n;i++) {\\n\\/\\/\\t\\tSystem.out.print(arr1[i] + \\\" \\\");\\n\\/\\/\\t}\\n\\/\\/\\tSystem.out.println();\\n\\/\\/\\tfor(int i = 0 ; i<n;i++) {\\n\\/\\/\\t\\tSystem.out.print(arr2[i] + \\\" \\\");\\n\\/\\/\\t}\\n\\t\\n\\t\\tint ans = 0;\\n\\t\\t\\n\\t\\tArrayList<xp> ar = new ArrayList<xp>();\\n\\t\\tfor(int i = 0 ; i<n;i++) {\\n\\t\\t\\tfor(int j = i+1; j<n;j++) {\\n\\t\\t\\t\\t\\n\\t\\t\\tif((find(arr1, i)!=find(arr1,j)) && (find(arr2,i)!=find(arr2,j))) {\\n\\t\\t\\t\\tint x = i +1;\\n\\t\\t\\t\\tint y = j +1;\\n\\/\\/\\t\\t\\t\\tSystem.out.println(x + \\\" \\\" + y);\\n\\t\\t\\tar.add(new xp(x,y));\\n\\t\\t\\t\\tunion(arr1,i,j);\\n\\t\\t\\tunion(arr2,i,j);\\n\\t\\t\\tans++;\\n\\t\\t\\t}\\n\\t\\t\\t\\n\\t\\t\\t\\n\\t\\t\\t\\n\\t\\t\\t}\\n\\t\\t}\\n\\/\\/\\t\\tSystem.out.println(ans);\\n\\t\\toutput.write(ans + \\\"\\\\n\\\");\\n\\t\\tfor(int i = 0 ; i<ar.size();i++) {\\n\\/\\/\\t\\t\\tSystem.out.println(ar.get(i).a + \\\" \\\" + ar.get(i).b);\\n\\t\\t\\toutput.write(ar.get(i).a + \\\" \\\" + ar.get(i).b + \\\"\\\\n\\\");\\n\\t\\t}\\n\\t\\t\\n\\t\\t\\n\\toutput.flush();\\n\\t\\n\\t\\n\\t}\\n\\n\\tpublic static int find(int[] arr , int v) {\\n\\/\\/\\t\\tif(arr[v] == -1) {\\n\\/\\/\\t\\t\\treturn v;\\n\\/\\/\\t\\t}\\n\\/\\/\\t\\t\\n\\/\\/\\t\\treturn find(arr,arr[v]);\\n\\t\\n\\t\\treturn arr[v] ==...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"Petya loves football very much, especially when his parents aren't home. Each morning he comes to the yard, gathers his friends and they play all day. From time to time they have a break to have some food or do some chores (for example, water the flowers).\\n\\nThe key in football is to divide into teams fairly before the game begins. There are n boys playing football in the yard (including Petya), each boy's football playing skill is expressed with a non-negative characteristic ai (the larger it is, the better the boy plays). \\n\\nLet's denote the number of players in the first team as x, the number of players in the second team as y, the individual numbers of boys who play for the first team as pi and the individual numbers of boys who play for the second team as qi. Division n boys into two teams is considered fair if three conditions are fulfilled:\\n\\n  * Each boy plays for exactly one team (x + y = n). \\n  * The sizes of teams differ in no more than one (|x - y| \u2264 1). \\n  * The total football playing skills for two teams differ in no more than by the value of skill the best player in the yard has. More formally: <image>\\n\\n\\n\\nYour task is to help guys divide into two teams fairly. It is guaranteed that a fair division into two teams always exists.\\n\\nInput\\n\\nThe first line contains the only integer n (2 \u2264 n \u2264 105) which represents the number of guys in the yard. The next line contains n positive space-separated integers, ai (1 \u2264 ai \u2264 104), the i-th number represents the i-th boy's playing skills. \\n\\nOutput\\n\\nOn the first line print an integer x \u2014 the number of boys playing for the first team. On the second line print x integers \u2014 the individual numbers of boys playing for the first team. On the third line print an integer y \u2014 the number of boys playing for the second team, on the fourth line print y integers \u2014 the individual numbers of boys playing for the second team. Don't forget that you should fulfil all three conditions: x + y = n, |x - y| \u2264 1, and the condition that limits the total skills.\\n\\nIf there are multiple...\\\":\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nvoid qSort(int *A, int low, int high, int *ii) {\\n  int i = low;\\n  int j = high;\\n  int x = A[(low + high) \\/ 2];\\n  do {\\n    while (A[i] < x) ++i;\\n    while (A[j] > x) --j;\\n    if (i <= j) {\\n      int temp = A[i];\\n      int buf = ii[i];\\n      ii[i] = ii[j];\\n      ii[j] = buf;\\n      A[i] = A[j];\\n      A[j] = temp;\\n      i++;\\n      j--;\\n    }\\n  } while (i <= j);\\n  if (low < j) qSort(A, low, j, ii);\\n  if (i < high) qSort(A, i, high, ii);\\n}\\nint gcd(int a, int b) {\\n  if (b == 0) {\\n    return a;\\n  } else {\\n    return gcd(b, a % b);\\n  }\\n}\\nint lcm(int a, int b) { return a \\/ gcd(a, b) * b; }\\nint main() {\\n  int n;\\n  cin >> n;\\n  int *mas = new int[n];\\n  int *ii = new int[n];\\n  for (int i = 0; i < n; i++) {\\n    cin >> mas[i];\\n    ii[i] = i;\\n  }\\n  qSort(mas, 0, n - 1, ii);\\n  if (n % 2 == 0) {\\n    cout << n \\/ 2 << endl;\\n  } else {\\n    cout << n \\/ 2 + 1 << endl;\\n  }\\n  for (int i = 0; i < n; i += 2) {\\n    cout << ii[i] + 1 << \\\" \\\";\\n  }\\n  cout << endl;\\n  if (n % 2 == 0) {\\n    cout << n \\/ 2 << endl;\\n  } else {\\n    cout << n \\/ 2 << endl;\\n  }\\n  for (int i = 1; i < n; i += 2) {\\n    cout << ii[i] + 1 << \\\" \\\";\\n  }\\n  cout << endl;\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"A soldier wants to buy w bananas in the shop. He has to pay k dollars for the first banana, 2k dollars for the second one and so on (in other words, he has to pay i\u00b7k dollars for the i-th banana). \\n\\nHe has n dollars. How many dollars does he have to borrow from his friend soldier to buy w bananas?\\n\\nInput\\n\\nThe first line contains three positive integers k, n, w (1 \u2264 k, w \u2264 1000, 0 \u2264 n \u2264 109), the cost of the first banana, initial number of dollars the soldier has and number of bananas he wants. \\n\\nOutput\\n\\nOutput one integer \u2014 the amount of dollars that the soldier must borrow from his friend. If he doesn't have to borrow money, output 0.\\n\\nExamples\\n\\nInput\\n\\n3 17 4\\n\\n\\nOutput\\n\\n13\\nSolve the task in PYTHON.\",\"targets\":\"import re\\nk , n , w = map(int , raw_input().split())\\nprint max(0 , (w*(w+1)\\/2)*k - n)\",\"language\":\"python\",\"split\":\"train\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in CPP?\\nIn 2012, human beings have been exposed to fierce onslaught of unidentified mysterious extra-terrestrial creatures. We have exhaused because of the long war and can't regist against them any longer. Only you, an excellent wizard, can save us. Yes, it's time to stand up!\\n\\nThe enemies are dispatched to the earth with being aligned like an n * n square. Appearently some of them have already lost their fighting capabilities for some unexpected reason. You have invented a highest grade magic spell 'MYON' to defeat them all. An attack of this magic covers any rectangles (which is parallel to axis). Once you cast a spell \\\"myon,\\\" then all the enemies which the magic covers will lose their fighting capabilities because of tremendous power of the magic. However, the magic seems to activate enemies' self-repairing circuit. Therefore if any enemy which have already lost its fighting capability is exposed to the magic, the enemy repossesses its fighting capability. You will win the war when all the enemies will lose their fighting capabilities.\\n\\nLet me show an example. An array of enemies below have dispatched:\\n\\n\\n1 1 1 1 1\\n1 0 0 0 1\\n1 0 1 0 1\\n1 0 0 0 1\\n1 1 1 1 1\\n\\n\\nHere, '0' means an enemy that doesn't possess fighting capability, and '1' means an enemy that possesses. First, you cast a spell \\\"myon\\\" with covering all the enemies, which results in;\\n\\n\\n0 0 0 0 0\\n0 1 1 1 0\\n0 1 0 1 0\\n0 1 1 1 0\\n0 0 0 0 0\\n\\n\\nNext, cast once again with covering central 3 * 3 enemies.\\n\\n\\n0 0 0 0 0\\n0 0 0 0 0\\n0 0 1 0 0\\n0 0 0 0 0\\n0 0 0 0 0\\n\\n\\nNow you can defeat them all by casting a spell covers remaining one. Therefore you can cast \\\"myonmyonmyon,\\\" which is the shortest spell for this case.\\n\\nYou are given the information of the array. Please write a program that generates the shortest spell that can defeat them all.\\n\\nConstraints\\n\\n* 1 \u2264 n \u2264 5\\n\\nInput\\n\\nThe first line of each test case has an integer n. Following n lines are information of an array of enemies. The format is same as described in the problem statement.\\n\\nInput terminates when n = 0. You may...\",\"targets\":\"#include<iostream>\\n#include<cmath>\\n#include<vector>\\n#include<algorithm>\\n#include<cassert>\\n#include<bitset>\\n#include<queue>\\n#define REP(i,s,n) for(int i=s;i<n;i++)\\n#define rep(i,n) REP(i,0,n)\\n#define inf (1<<29)\\n#define MAX (1<<20)\\nusing namespace std;\\n\\nstruct P\\n{\\n  int state,cost;\\n  P(int state=inf,int cost=inf):state(state),cost(cost){}\\n  bool operator < (const P& a)const\\n  {\\n    return cost > a.cost;\\n  }\\n};\\n\\nshort mincost[MAX];\\nshort mincost5[1<<5];\\nint rect[5][5][5][5];\\n\\n\\nvoid init()\\n{\\n  rep(i,MAX)mincost[i] = 25;\\n  rep(i,5)rep(j,5)rep(k,5)rep(l,5)rect[i][j][k][l] = 0;\\n}\\n\\nvoid makeRect()\\n{\\n  rep(y1,5)rep(x1,5)\\/\\/top-left\\n    REP(y2,y1,5)REP(x2,x1,5)\\/\\/bottom-right\\n      REP(y,y1,y2+1)REP(x,x1,x2+1)\\n        rect[y1][x1][y2][x2] |= (1<<(y*5+x));\\n}\\n\\nvoid makeMincost()\\n{\\n  mincost[0] = 0;\\n  priority_queue<P> que;\\n  que.push(P(0,0));\\n\\n  while(!que.empty())\\n    {\\n      P p = que.top(); que.pop();\\n\\n      rep(y1,4)rep(x1,5)\\n\\tREP(y2,y1,4)REP(x2,x1,5)\\n\\t{\\n\\t  int nstate = p.state ^ rect[y1][x1][y2][x2];\\n\\t  if(mincost[nstate] > p.cost + 1)\\n\\t    {\\n\\t      mincost[nstate] = p.cost + 1;\\n\\t      que.push(P(nstate,p.cost+1));\\n\\t    }\\n\\t}\\n    }\\n\\n}\\n\\nvoid print(int f)\\n{\\n  bitset<25> ff(f);\\n  rep(i,5)\\n    {\\n      cout << i << \\\" : \\\";\\n      rep(j,5)\\n\\t{\\n\\t  cout << ff[i*5+j] << \\\" \\\";\\n\\t}\\n      cout << endl;\\n    }\\n  cout << endl;\\n}\\n\\nvoid dfs(int state,int cur,int cost,int &ans)\\n{\\n  if(state < (1<<20))ans = min(ans,cost + mincost[state]);\\n  if(cost >= ans)return;\\n  if(cur >= 3)return;\\n\\n  rep(y1,5)rep(x1,5)REP(x,x1,5)\\n    {\\n      int nstate = state ^ rect[y1][x1][4][x];\\n      int nstate5 = (nstate>>20);      \\n\\n      \\/\\/cout << \\\"ns = \\\" << endl;\\n      \\/\\/print(nstate);\\n\\n      dfs(nstate,cur+1,cost+1,ans);\\n\\t\\n    }\\n  \\n}\\n\\nint compute(int field)\\n{\\n  int bf = (field>>20);\\n  int nfield = field & (1<<20)-1;\\n  int ret = __builtin_popcount(bf) + mincost[nfield];\\n\\n  \\/\\/cout << \\\"start dfs\\\" << endl;\\n  dfs(field,0,0,ret);\\n  \\/\\/cout << \\\"end dfs\\\" << endl;\\n  \\/\\/cout << \\\"ret = \\\" << ret << endl;\\n  return ret;\\n}\\n\\nint main()\\n{\\n  int n,field;\\n  init();\\n  makeRect();\\n ...\",\"language\":\"python\",\"split\":\"train\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"PYTHON3 solution for \\\"Berland Music is a music streaming service built specifically to support Berland local artist. Its developers are currently working on a song recommendation module.\\n\\nSo imagine Monocarp got recommended n songs, numbered from 1 to n. The i-th song had its predicted rating equal to p_i, where 1 \u2264 p_i \u2264 n and every integer from 1 to n appears exactly once. In other words, p is a permutation.\\n\\nAfter listening to each of them, Monocarp pressed either a like or a dislike button. Let his vote sequence be represented with a string s, such that s_i=0 means that he disliked the i-th song, and s_i=1 means that he liked it.\\n\\nNow the service has to re-evaluate the song ratings in such a way that:\\n\\n  * the new ratings q_1, q_2, ..., q_n still form a permutation (1 \u2264 q_i \u2264 n; each integer from 1 to n appears exactly once); \\n  * every song that Monocarp liked should have a greater rating than every song that Monocarp disliked (formally, for all i, j such that s_i=1 and s_j=0, q_i>q_j should hold). \\n\\n\\n\\nAmong all valid permutations q find the one that has the smallest value of \u2211_{i=1}^n |p_i-q_i|, where |x| is an absolute value of x.\\n\\nPrint the permutation q_1, q_2, ..., q_n. If there are multiple answers, you can print any of them.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 10^4) \u2014 the number of testcases.\\n\\nThe first line of each testcase contains a single integer n (1 \u2264 n \u2264 2 \u22c5 10^5) \u2014 the number of songs.\\n\\nThe second line of each testcase contains n integers p_1, p_2, ..., p_n (1 \u2264 p_i \u2264 n) \u2014 the permutation of the predicted ratings.\\n\\nThe third line contains a single string s, consisting of n characters. Each character is either a 0 or a 1. 0 means that Monocarp disliked the song, and 1 means that he liked it.\\n\\nThe sum of n over all testcases doesn't exceed 2 \u22c5 10^5.\\n\\nOutput\\n\\nFor each testcase, print a permutation q \u2014 the re-evaluated ratings of the songs. If there are multiple answers such that \u2211_{i=1}^n |p_i-q_i| is minimum possible, you can print any of them.\\n\\nExample\\n\\nInput\\n\\n\\n3\\n2\\n1 2\\n10\\n3\\n3 1 2\\n111\\n8\\n2...\\\":\",\"targets\":\"# -*- coding: utf-8 -*-\\n\\\"\\\"\\\"\\nCreated on Tue Dec 28 00:14:43 2021\\n\\n@author: dinia\\n\\\"\\\"\\\"\\n\\n\\nimport sys\\n \\n############# READING ###############\\ninput = sys.stdin.readline\\n\\ndef gt() : return int(input())\\ndef gs() : return list(map(int, input().rstrip()))\\ndef gsn() : return  list(map(int, input().split()))\\ndef gst() : return str(input().rstrip())\\ndef gms() : return list(map(str, input().split()))\\n\\n\\n############# WRITING ###############\\noutput = sys.stdout.write\\ndef printst(s) : output(s+ \\\"\\\\n\\\")\\ndef prints(n) : output(str(n) + \\\"\\\\n\\\") \\ndef printm(l) :  output(\\\" \\\".join(map(str,l)) + \\\"\\\\n\\\")\\ndef printmm(l):\\n    for line in l:\\n        printm(line)\\n\\n\\n\\n        \\n    \\nt = gt()\\nfor _ in range(t):\\n    n = gt()\\n    p = gsn()\\n    s = gst()\\n    n_dislikes = s.count('0')\\n    \\n    disliked_change = set(filter(lambda idx : s[idx] == \\\"0\\\" and\\\\\\n                              p[idx]> n_dislikes , range(n))) \\n    liked_change = set(filter(lambda idx : s[idx] == \\\"1\\\" and\\\\\\n                              p[idx]<= n_dislikes , range(n))) \\n    \\n    for i, j in zip(liked_change, disliked_change) :\\n        p[i],p[j] = p[j], p[i]\\n    printm(p)\",\"language\":\"python\",\"split\":\"test\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in CPP?\\nAn identity permutation of length n is an array [1, 2, 3, ..., n].\\n\\nWe performed the following operations to an identity permutation of length n:\\n\\n  * firstly, we cyclically shifted it to the right by k positions, where k is unknown to you (the only thing you know is that 0 \u2264 k \u2264 n - 1). When an array is cyclically shifted to the right by k positions, the resulting array is formed by taking k last elements of the original array (without changing their relative order), and then appending n - k first elements to the right of them (without changing relative order of the first n - k elements as well). For example, if we cyclically shift the identity permutation of length 6 by 2 positions, we get the array [5, 6, 1, 2, 3, 4]; \\n  * secondly, we performed the following operation at most m times: pick any two elements of the array and swap them. \\n\\n\\n\\nYou are given the values of n and m, and the resulting array. Your task is to find all possible values of k in the cyclic shift operation.\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 10^5) \u2014 the number of test cases.\\n\\nEach test case consists of two lines. The first line contains two integers n and m (3 \u2264 n \u2264 3 \u22c5 10^5; 0 \u2264 m \u2264 n\\/3).\\n\\nThe second line contains n integers p_1, p_2, ..., p_n (1 \u2264 p_i \u2264 n, each integer from 1 to n appears in this sequence exactly once) \u2014 the resulting array.\\n\\nThe sum of n over all test cases does not exceed 3 \u22c5 10^5.\\n\\nOutput\\n\\nFor each test case, print the answer in the following way:\\n\\n  * firstly, print one integer r (0 \u2264 r \u2264 n) \u2014 the number of possible values of k for the cyclic shift operation; \\n  * secondly, print r integers k_1, k_2, ..., k_r (0 \u2264 k_i \u2264 n - 1) \u2014 all possible values of k in increasing order. \\n\\nExample\\n\\nInput\\n\\n\\n4\\n4 1\\n2 3 1 4\\n3 1\\n1 2 3\\n3 1\\n3 2 1\\n6 0\\n1 2 3 4 6 5\\n\\n\\nOutput\\n\\n\\n1 3\\n1 0\\n3 0 1 2\\n0\\n\\nNote\\n\\nConsider the example: \\n\\n  * in the first test case, the only possible value for the cyclic shift is 3. If we shift [1, 2, 3, 4] by 3 positions, we get [2, 3, 4, 1]. Then we can swap the 3-rd and the 4-th elements to get the...\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst long long DIM = 3e5 + 7;\\nconst long long DIMM = 5e4 + 7;\\nconst long long DDIM = 7;\\nconst long long INF = 1e18 + 7;\\nconst long long X = 1e5 + 7;\\nconst long long BS = 2e5 + 7;\\nconst long long AS = 26 + 7;\\nconst long long MODULO = 1e9 + 7;\\nlong long nt, n, m, k, q;\\nlong long val, s, n1;\\nlong long a[DIM], b[DIM], p[DIM], p1[DIM], c[DIM];\\nvector<long long> res, res1;\\nbool check(long long s) {\\n  long long m1 = m, v;\\n  for (int i = 1; i <= n; i++) {\\n    b[i] = a[i];\\n    p1[i] = p[i];\\n  }\\n  for (int i = 1; i <= n; i++) {\\n    v = ((i - s + n - 1) % n + 1);\\n    if (b[i] != v) {\\n      if (m1 > 0) {\\n        p1[b[i]] = p1[v];\\n        swap(b[i], b[p1[v]]);\\n        p1[v] = i;\\n        m1--;\\n      } else\\n        return false;\\n    }\\n  }\\n  return true;\\n}\\nint main() {\\n  ios_base::sync_with_stdio();\\n  cin.tie();\\n  cout.tie();\\n  ;\\n  cin >> nt;\\n  for (int tt = 1; tt <= nt; tt++) {\\n    cin >> n >> m;\\n    n1 = n - 2 * m;\\n    for (int i = 1; i <= n; i++) {\\n      cin >> a[i];\\n      p[a[i]] = i;\\n      if (i < a[i])\\n        s = n - a[i] + i;\\n      else\\n        s = i - a[i];\\n      c[s]++;\\n    }\\n    for (int i = 0; i < n; i++) {\\n      if (c[i] >= n1) res1.push_back(i);\\n      c[i] = 0;\\n    }\\n    for (auto to : res1) {\\n      if (check(to)) res.push_back(to);\\n    }\\n    cout << res.size() << ' ';\\n    for (auto to : res) cout << to << ' ';\\n    cout << endl;\\n    res.clear();\\n    res1.clear();\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"Given an integer x, find 2 integers a and b such that: \\n\\n  * 1 \u2264 a,b \u2264 x \\n  * b divides a (a is divisible by b). \\n  * a \u22c5 b>x. \\n  * a\\/b<x. \\n\\nInput\\n\\nThe only line contains the integer x (1 \u2264 x \u2264 100).\\n\\nOutput\\n\\nYou should output two integers a and b, satisfying the given conditions, separated by a space. If no pair of integers satisfy the conditions above, print \\\"-1\\\" (without quotes).\\n\\nExamples\\n\\nInput\\n\\n10\\n\\n\\nOutput\\n\\n6 3\\n\\nInput\\n\\n1\\n\\n\\nOutput\\n\\n-1\\\":\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint main() {\\n  ios_base::sync_with_stdio(false);\\n  cin.tie(NULL);\\n  long long t = 1;\\n  while (t--) {\\n    long long n;\\n    cin >> n;\\n    if (n <= 1) {\\n      cout << \\\"-1\\\";\\n      return 0;\\n    } else {\\n      cout << n << \\\" \\\" << n;\\n    }\\n  }\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in PYTHON3?\\nYou have a string s and a chip, which you can place onto any character of this string. \\n\\nAfter placing the chip, you move it to the right several (maybe zero) times, i. e. you perform the following operation several times: if the current position of the chip is i, you move it to the position i + 1. Of course, moving the chip to the right is impossible if it is already in the last position.\\n\\nAfter moving the chip to the right, you move it to the left several (maybe zero) times, i. e. you perform the following operation several times: if the current position of the chip is i, you move it to the position i - 1. Of course, moving the chip to the left is impossible if it is already in the first position.\\n\\nWhen you place a chip or move it, you write down the character where the chip ends up after your action. For example, if s is abcdef, you place the chip onto the 3-rd character, move it to the right 2 times and then move it to the left 3 times, you write down the string cdedcb.\\n\\nYou are given two strings s and t. Your task is to determine whether it's possible to perform the described operations with s so that you write down the string t as a result.\\n\\nInput\\n\\nThe first line contains one integer q (1 \u2264 q \u2264 500) \u2014 the number of test cases.\\n\\nEach test case consists of two lines. The first line contains the string s (1 \u2264 |s| \u2264 500), the second line contains the string t (1 \u2264 |t| \u2264 2 \u22c5 |s| - 1). Both strings consist of lowercase English characters.\\n\\nIt is guaranteed that the sum of |s| over all test cases does not exceed 500.\\n\\nOutput\\n\\nFor each test case, print \\\"YES\\\" if you can obtain the string t by performing the process mentioned in the statement with the string s, or \\\"NO\\\" if you cannot.\\n\\nYou may print each letter in any case (YES, yes, Yes will all be recognized as positive answer, NO, no and nO will all be recognized as negative answer).\\n\\nExample\\n\\nInput\\n\\n\\n6\\nabcdef\\ncdedcb\\naaa\\naaaaa\\naab\\nbaaa\\nab\\nb\\nabcdef\\nabcdef\\nba\\nbaa\\n\\n\\nOutput\\n\\n\\nYES\\nYES\\nNO\\nYES\\nYES\\nNO\\n\\nNote\\n\\nConsider the examples.\\n\\nThe first test case is described in...\",\"targets\":\"import os, sys\\nfrom io import BytesIO, IOBase\\nfrom math import log2, ceil, sqrt, gcd\\nfrom _collections import deque\\nimport heapq as hp\\nfrom bisect import bisect_left, bisect_right\\n\\nfrom math import cos, sin\\n\\nBUFSIZE = 8192\\n\\n\\nclass FastIO(IOBase):\\n    newlines = 0\\n\\n    def __init__(self, file):\\n        self._fd = file.fileno()\\n        self.buffer = BytesIO()\\n        self.writable = \\\"x\\\" in file.mode or \\\"r\\\" not in file.mode\\n        self.write = self.buffer.write if self.writable else None\\n\\n    def read(self):\\n        while True:\\n            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))\\n            if not b:\\n                break\\n            ptr = self.buffer.tell()\\n            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)\\n        self.newlines = 0\\n        return self.buffer.read()\\n\\n    def readline(self):\\n        while self.newlines == 0:\\n            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))\\n            self.newlines = b.count(b\\\"\\\\n\\\") + (not b)\\n            ptr = self.buffer.tell()\\n            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)\\n        self.newlines -= 1\\n        return self.buffer.readline()\\n\\n    def flush(self):\\n        if self.writable:\\n            os.write(self._fd, self.buffer.getvalue())\\n            self.buffer.truncate(0), self.buffer.seek(0)\\n\\n\\nclass IOWrapper(IOBase):\\n    def __init__(self, file):\\n        self.buffer = FastIO(file)\\n        self.flush = self.buffer.flush\\n        self.writable = self.buffer.writable\\n        self.write = lambda s: self.buffer.write(s.encode(\\\"ascii\\\"))\\n        self.read = lambda: self.buffer.read().decode(\\\"ascii\\\")\\n        self.readline = lambda: self.buffer.readline().decode(\\\"ascii\\\")\\n\\n\\nsys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)\\ninput = lambda: sys.stdin.readline().rstrip(\\\"\\\\r\\\\n\\\")\\n\\nmod = 10 ** 9 + 7\\n\\nfor _ in range(int(input())):\\n    a=[i for i in input()]\\n    b=[i for i in input()]\\n    n=len(b)\\n    bol=False\\n    for i in range(len(b)+1):\\n        for j in...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Monocarp wrote down two numbers on a whiteboard. Both numbers follow a specific format: a positive integer x with p zeros appended to its end.\\n\\nNow Monocarp asks you to compare these two numbers. Can you help him?\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 10^4) \u2014 the number of testcases.\\n\\nThe first line of each testcase contains two integers x_1 and p_1 (1 \u2264 x_1 \u2264 10^6; 0 \u2264 p_1 \u2264 10^6) \u2014 the description of the first number.\\n\\nThe second line of each testcase contains two integers x_2 and p_2 (1 \u2264 x_2 \u2264 10^6; 0 \u2264 p_2 \u2264 10^6) \u2014 the description of the second number.\\n\\nOutput\\n\\nFor each testcase print the result of the comparison of the given two numbers. If the first number is smaller than the second one, print '<'. If the first number is greater than the second one, print '>'. If they are equal, print '='.\\n\\nExample\\n\\nInput\\n\\n\\n5\\n2 1\\n19 0\\n10 2\\n100 1\\n1999 0\\n2 3\\n1 0\\n1 0\\n99 0\\n1 2\\n\\n\\nOutput\\n\\n\\n&gt;\\n=\\n&lt;\\n=\\n&lt;\\n\\nNote\\n\\nThe comparisons in the example are: 20 > 19, 1000 = 1000, 1999 < 2000, 1 = 1, 99 < 100.\\nfor i\",\"targets\":\"in range(int(input())):\\n    a, b = input().split()\\n    c, d = input().split()\\n    if len(a)+int(b) > len(c)+int(d):\\n        print(\\\">\\\")\\n    elif len(a)+int(b) < len(c)+int(d):\\n        print(\\\"<\\\")\\n    else:\\n        a = int(a)\\n        b = int(b)\\n        c = int(c)\\n        d = int(d)\\n        if int(a) > int(c):\\n            c *= 10**(d-b)\\n        else:\\n            a *= 10**(b-d)\\n        if a > c:\\n            print(\\\">\\\")\\n        elif a == c:\\n            print(\\\"=\\\")\\n        else:\\n            print(\\\"<\\\")\",\"language\":\"python\",\"split\":\"test\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You are given an integer k and a string s that consists only of characters 'a' (a lowercase Latin letter) and '*' (an asterisk).\\n\\nEach asterisk should be replaced with several (from 0 to k inclusive) lowercase Latin letters 'b'. Different asterisk can be replaced with different counts of letter 'b'.\\n\\nThe result of the replacement is called a BA-string.\\n\\nTwo strings a and b are different if they either have different lengths or there exists such a position i that a_i \u2260 b_i.\\n\\nA string a is lexicographically smaller than a string b if and only if one of the following holds: \\n\\n  * a is a prefix of b, but a \u2260 b; \\n  * in the first position where a and b differ, the string a has a letter that appears earlier in the alphabet than the corresponding letter in b. \\n\\n\\n\\nNow consider all different BA-strings and find the x-th lexicographically smallest of them.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 2000) \u2014 the number of testcases.\\n\\nThe first line of each testcase contains three integers n, k and x (1 \u2264 n \u2264 2000; 0 \u2264 k \u2264 2000; 1 \u2264 x \u2264 10^{18}). n is the length of string s.\\n\\nThe second line of each testcase is a string s. It consists of n characters, each of them is either 'a' (a lowercase Latin letter) or '*' (an asterisk).\\n\\nThe sum of n over all testcases doesn't exceed 2000. For each testcase x doesn't exceed the total number of different BA-strings. String s contains at least one character 'a'.\\n\\nOutput\\n\\nFor each testcase, print a single string, consisting only of characters 'b' and 'a' (lowercase Latin letters) \u2014 the x-th lexicographically smallest BA-string.\\n\\nExample\\n\\nInput\\n\\n\\n3\\n2 4 3\\na*\\n4 1 3\\na**a\\n6 3 20\\n**a***\\n\\n\\nOutput\\n\\n\\nabb\\nabba\\nbabbbbbbbbb\\n\\nNote\\n\\nIn the first testcase of the example, BA-strings ordered lexicographically are: \\n\\n  1. a\\n  2. ab\\n  3. abb\\n  4. abbb\\n  5. abbbb\\n\\n\\n\\nIn the second testcase of the example, BA-strings ordered lexicographically are: \\n\\n  1. aa\\n  2. aba\\n  3. abba\\n\\n\\n\\nNote that string \\\"aba\\\" is only counted once, even though there are two ways to replace asterisks with characters...\\nThe above is tricky. Write me a correct solution in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nstd::mt19937 rng(\\n    (int)std::chrono::steady_clock::now().time_since_epoch().count());\\nconst long long INF = 1ll << 60;\\nconst long long mod = 1000000007;\\nconst long double PI = acosl(-1);\\nlong long binpow(long long a, long long b) {\\n  if (b == 0) return 1;\\n  long long res = binpow(a, b \\/ 2);\\n  if (b % 2)\\n    return res * res * a;\\n  else\\n    return res * res;\\n}\\nvoid solve() {\\n  long long n, k, x, i, j, cnt = 0;\\n  cin >> n >> k >> x;\\n  long long auxx = 1;\\n  string s, resp = \\\"\\\";\\n  cin >> s;\\n  vector<long long> vet;\\n  for (i = 0; i < n; i++) {\\n    if (s[i] == '*')\\n      cnt++;\\n    else {\\n      if (cnt > 0) vet.push_back(cnt);\\n      cnt = 0;\\n      vet.push_back(cnt);\\n    }\\n  }\\n  if (cnt > 0) vet.push_back(cnt);\\n  reverse(vet.begin(), vet.end());\\n  x--;\\n  for (i = 0; i < vet.size(); i++) {\\n    if (vet[i] == 0)\\n      resp += 'a';\\n    else {\\n      long long aux = x % (vet[i] * k + 1);\\n      for (j = 0; j < aux; j++) {\\n        resp += 'b';\\n      }\\n      x \\/= (vet[i] * k + 1);\\n    }\\n  }\\n  reverse(resp.begin(), resp.end());\\n  cout << resp << endl;\\n}\\nint main() {\\n  ios_base::sync_with_stdio(false);\\n  cin.tie(NULL);\\n  cout.tie(NULL);\\n  long long t = 1;\\n  cin >> t;\\n  while (t--) {\\n    solve();\\n  }\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Vupsen and Pupsen were gifted an integer array. Since Vupsen doesn't like the number 0, he threw away all numbers equal to 0 from the array. As a result, he got an array a of length n.\\n\\nPupsen, on the contrary, likes the number 0 and he got upset when he saw the array without zeroes. To cheer Pupsen up, Vupsen decided to come up with another array b of length n such that \u2211_{i=1}^{n}a_i \u22c5 b_i=0. Since Vupsen doesn't like number 0, the array b must not contain numbers equal to 0. Also, the numbers in that array must not be huge, so the sum of their absolute values cannot exceed 10^9. Please help Vupsen to find any such array b!\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 100) \u2014 the number of test cases. The next 2 \u22c5 t lines contain the description of test cases. The description of each test case consists of two lines.\\n\\nThe first line of each test case contains a single integer n (2 \u2264 n \u2264 10^5) \u2014 the length of the array.\\n\\nThe second line contains n integers a_1, a_2, \u2026, a_n (-10^4 \u2264 a_i \u2264 10^4, a_i \u2260 0) \u2014 the elements of the array a.\\n\\nIt is guaranteed that the sum of n over all test cases does not exceed 2 \u22c5 10^5.\\n\\nOutput\\n\\nFor each test case print n integers b_1, b_2, \u2026, b_n \u2014 elements of the array b (|b_1|+|b_2|+\u2026 +|b_n| \u2264 10^9, b_i \u2260 0, \u2211_{i=1}^{n}a_i \u22c5 b_i=0).\\n\\nIt can be shown that the answer always exists.\\n\\nExample\\n\\nInput\\n\\n\\n3\\n2\\n5 5\\n5\\n5 -2 10 -9 4\\n7\\n1 2 3 4 5 6 7\\n\\n\\nOutput\\n\\n\\n1 -1\\n-1 5 1 -1 -1\\n-10 2 2 -3 5 -1 -1\\n\\nNote\\n\\nIn the first test case, 5 \u22c5 1 + 5 \u22c5 (-1)=5-5=0. You could also print 3 -3, for example, since 5 \u22c5 3 + 5 \u22c5 (-3)=15-15=0\\n\\nIn the second test case, 5 \u22c5 (-1) + (-2) \u22c5 5 + 10 \u22c5 1 + (-9) \u22c5 (-1) + 4 \u22c5 (-1)=-5-10+10+9-4=0.\\nSolve the task in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint t, n, a[100005], b[100005], wz[100005];\\nconst long long INF = 1e9;\\nlong long sum;\\nint jdz(int x) {\\n  if (x < 0) return -x;\\n  return x;\\n}\\nbool cmp(int x, int y) {\\n  if (jdz(a[x]) == jdz(a[y])) return a[x] < a[y];\\n  return jdz(a[x]) < jdz(a[y]);\\n}\\nint main() {\\n  scanf(\\\"%d\\\", &t);\\n  while (t--) {\\n    scanf(\\\"%d\\\", &n);\\n    for (int i = 1; i <= n; i++) {\\n      wz[i] = i;\\n      scanf(\\\"%d\\\", &a[i]);\\n    }\\n    sort(wz + 1, wz + n + 1, cmp);\\n    if (n & 1) {\\n      if ((a[wz[2]] + a[wz[3]]) == 0) swap(wz[1], wz[3]);\\n      b[wz[1]] = a[wz[2]] + a[wz[3]];\\n      b[wz[2]] = -a[wz[1]];\\n      b[wz[3]] = -a[wz[1]];\\n      for (int i = 4; i <= n; i += 2) {\\n        if (jdz(a[wz[i]]) == jdz(a[wz[i + 1]])) {\\n          if (a[wz[i]] == a[wz[i + 1]]) {\\n            b[wz[i]] = 1;\\n            b[wz[i + 1]] = -1;\\n          } else {\\n            b[wz[i]] = 1;\\n            b[wz[i + 1]] = 1;\\n          }\\n        } else {\\n          b[wz[i]] = -a[wz[i + 1]];\\n          b[wz[i + 1]] = a[wz[i]];\\n        }\\n      }\\n      sum = 0;\\n      for (int i = 1; i <= n; i++) {\\n        sum = sum + jdz(b[i]);\\n      }\\n      if (sum > INF) {\\n        for (int i = 5; i < n; i += 2) {\\n          if (jdz(a[wz[i]]) == jdz(a[wz[i + 1]])) {\\n            if (a[wz[i]] == a[wz[i + 1]]) {\\n              b[wz[i]] = 1;\\n              b[wz[i + 1]] = -1;\\n            } else {\\n              b[wz[i]] = 1;\\n              b[wz[i + 1]] = 1;\\n            }\\n          } else {\\n            b[wz[i]] = -a[wz[i + 1]];\\n            b[wz[i + 1]] = a[wz[i]];\\n          }\\n        }\\n        if (jdz(a[wz[4]]) == jdz(a[wz[n]])) {\\n          if (a[wz[4]] == a[wz[n]]) {\\n            b[wz[4]] = 1;\\n            b[wz[n]] = -1;\\n          } else {\\n            b[wz[4]] = 1;\\n            b[wz[n]] = 1;\\n          }\\n        } else {\\n          b[wz[4]] = -a[wz[n]];\\n          b[wz[n]] = a[wz[4]];\\n        }\\n      }\\n      for (int i = 1; i <= n; i++) printf(\\\"%d \\\", b[i]);\\n    } else {\\n      for (int i = 1; i <= n; i += 2) {\\n        printf(\\\"%d %d \\\", -a[i + 1], a[i]);\\n      }\\n    }\\n  ...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Luntik has decided to try singing. He has a one-minute songs, b two-minute songs and c three-minute songs. He wants to distribute all songs into two concerts such that every song should be included to exactly one concert.\\n\\nHe wants to make the absolute difference of durations of the concerts as small as possible. The duration of the concert is the sum of durations of all songs in that concert.\\n\\nPlease help Luntik and find the minimal possible difference in minutes between the concerts durations.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 1000) \u2014 the number of test cases.\\n\\nEach test case consists of one line containing three integers a, b, c (1 \u2264 a, b, c \u2264 10^9) \u2014 the number of one-minute, two-minute and three-minute songs.\\n\\nOutput\\n\\nFor each test case print the minimal possible difference in minutes between the concerts durations.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n1 1 1\\n2 1 3\\n5 5 5\\n1 1 2\\n\\n\\nOutput\\n\\n\\n0\\n1\\n0\\n1\\n\\nNote\\n\\nIn the first test case, Luntik can include a one-minute song and a two-minute song into the first concert, and a three-minute song into the second concert. Then the difference will be equal to 0.\\n\\nIn the second test case, Luntik can include two one-minute songs and a two-minute song and a three-minute song into the first concert, and two three-minute songs into the second concert. The duration of the first concert will be 1 + 1 + 2 + 3 = 7, the duration of the second concert will be 6. The difference of them is |7-6| = 1.\\nUsing java can you solve the prior task?\",\"targets\":\"import java.util.*;\\npublic class concerts {\\n\\n\\tpublic static void main(String[] args) {\\n\\t\\tScanner sc = new Scanner(System.in);\\n\\t\\tint n = sc.nextInt();\\n\\t\\tfor(int i=0; i<n; i++)\\n\\t\\t{\\t\\t\\t\\n\\t\\t\\tint fs = sc.nextInt();\\n\\t\\t\\tint ss = sc.nextInt();\\n\\t\\t\\tint thirdss = sc.nextInt();\\n\\t\\t\\tint duration = (fs*1 + ss*2 + thirdss*3) % 2 ==0 ? 0 : 1;\\n\\t\\t\\tSystem.out.println(duration);\\t\\t\\n\\t\\t}\\n\\n\\t}\\n\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"Another feature of Shakespeare language is that the variables are named after characters of plays by Shakespeare, and all operations on them (value assignment, output etc.) look like a dialog with other characters. New values of variables are defined in a rather lengthy way, so a programmer should try to minimize their usage.\\n\\nYou have to print the given sequence of n integers. To do this, you have m variables and two types of operations on them:\\n\\n  * variable=integer\\n  * print(variable)\\n\\n\\n\\nAny of the m variables can be used as variable. Variables are denoted by lowercase letters between \\\"a\\\" and \\\"z\\\", inclusive. Any integer number can be used as integer.\\n\\nLet's say that the penalty for using first type of operations equals to the number of set bits in the number integer. There is no penalty on using second type of operations. Find and output the program which minimizes the penalty for printing the given sequence of numbers.\\n\\nInput\\n\\nThe first line of input contains integers n and m (1 \u2264 n \u2264 250, 1 \u2264 m \u2264 26). The second line contains the sequence to be printed. Each element of the sequence is an integer between 1 and 109, inclusive. The sequence has to be printed in the given order (from left to right).\\n\\nOutput\\n\\nOutput the number of lines in the optimal program and the optimal penalty. Next, output the program itself, one command per line. If there are several programs with minimal penalty, output any of them (you have only to minimize the penalty).\\n\\nExamples\\n\\nInput\\n\\n7 2\\n1 2 2 4 2 1 2\\n\\n\\nOutput\\n\\n11 4\\nb=1\\nprint(b)\\na=2\\nprint(a)\\nprint(a)\\nb=4\\nprint(b)\\nprint(a)\\nb=1\\nprint(b)\\nprint(a)\\n\\n\\nInput\\n\\n6 3\\n1 2 3 1 2 3\\n\\n\\nOutput\\n\\n9 4\\nc=1\\nprint(c)\\nb=2\\nprint(b)\\na=3\\nprint(a)\\nprint(c)\\nprint(b)\\nprint(a)\\\":\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst int MAXN = 520;\\nconst int INF = 1000000000;\\nint mat[MAXN][MAXN], cost[MAXN][MAXN], flow[MAXN][MAXN];\\nint a[500], b[500];\\nint getV(int x) {\\n  int t = 0;\\n  while (x) {\\n    t += (x % 2);\\n    x \\/= 2;\\n  }\\n  return t;\\n}\\nint minCostMaxFlow(int n, const int mat[][MAXN], int cost[][MAXN], int source,\\n                   int sink, int flow[][MAXN], int& netcost) {\\n  int pre[MAXN], min[MAXN], d[MAXN], i, j, t, tag;\\n  if (source == sink) {\\n    return INF;\\n  }\\n  for (i = 0; i < n; i++) {\\n    for (j = 0; j < n; flow[i][j++] = 0)\\n      ;\\n  }\\n  for (netcost = 0;;) {\\n    for (i = 0; i < n; i++) {\\n      pre[i] = 0;\\n      min[i] = INF;\\n    }\\n    pre[source] = source + 1;\\n    min[source] = 0;\\n    d[source] = INF;\\n    for (tag = 1; tag;) {\\n      for (tag = t = 0; t < n; t++) {\\n        if (d[t]) {\\n          for (i = 0; i < n; i++) {\\n            if ((j = mat[t][i] - flow[t][i]) && min[t] + cost[t][i] < min[i]) {\\n              tag = 1;\\n              min[i] = min[t] + cost[t][i];\\n              pre[i] = t + 1;\\n              d[i] = d[t] < j ? d[t] : j;\\n            } else if ((j = flow[i][t]) && min[t] < INF &&\\n                       min[t] - cost[i][t] < min[i]) {\\n              tag = 1;\\n              min[i] = min[t] - cost[i][t];\\n              pre[i] = -t - 1;\\n              d[i] = d[t] < j ? d[t] : j;\\n            }\\n          }\\n        }\\n      }\\n    }\\n    if (!pre[sink]) {\\n      break;\\n    }\\n    for (netcost += min[sink] * d[i = sink]; i != source;) {\\n      if (pre[i] > 0) {\\n        flow[pre[i] - 1][i] += d[sink];\\n        i = pre[i] - 1;\\n      } else {\\n        flow[i][-pre[i] - 1] -= d[sink];\\n        i = -pre[i] - 1;\\n      }\\n    }\\n  }\\n  for (j = i = 0; i < n; j += flow[source][i++])\\n    ;\\n  return j;\\n}\\nint main() {\\n  int i, j, k, m, n, netcost;\\n  while (cin >> n >> m) {\\n    for (i = 1; i <= n; ++i) {\\n      scanf(\\\"%d\\\", &a[i]);\\n      b[i] = getV(a[i]);\\n    }\\n    memset(mat, 0, sizeof(mat));\\n    memset(cost, 0, sizeof(cost));\\n    mat[0][2 * n + 1] = m;\\n    for (i = 1; i <= n; ++i) {\\n     ...\",\"language\":\"python\",\"split\":\"train\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"After making bad dives into swimming pools, Wilbur wants to build a swimming pool in the shape of a rectangle in his backyard. He has set up coordinate axes, and he wants the sides of the rectangle to be parallel to them. Of course, the area of the rectangle must be positive. Wilbur had all four vertices of the planned pool written on a paper, until his friend came along and erased some of the vertices.\\n\\nNow Wilbur is wondering, if the remaining n vertices of the initial rectangle give enough information to restore the area of the planned swimming pool.\\n\\nInput\\n\\nThe first line of the input contains a single integer n (1 \u2264 n \u2264 4) \u2014 the number of vertices that were not erased by Wilbur's friend.\\n\\nEach of the following n lines contains two integers xi and yi ( - 1000 \u2264 xi, yi \u2264 1000) \u2014the coordinates of the i-th vertex that remains. Vertices are given in an arbitrary order.\\n\\nIt's guaranteed that these points are distinct vertices of some rectangle, that has positive area and which sides are parallel to the coordinate axes.\\n\\nOutput\\n\\nPrint the area of the initial rectangle if it could be uniquely determined by the points remaining. Otherwise, print  - 1. \\n\\nExamples\\n\\nInput\\n\\n2\\n0 0\\n1 1\\n\\n\\nOutput\\n\\n1\\n\\n\\nInput\\n\\n1\\n1 1\\n\\n\\nOutput\\n\\n-1\\n\\nNote\\n\\nIn the first sample, two opposite corners of the initial rectangle are given, and that gives enough information to say that the rectangle is actually a unit square.\\n\\nIn the second sample there is only one vertex left and this is definitely not enough to uniquely define the area.\\nSolve the task in PYTHON.\",\"targets\":\"import sys\\n\\ndef solve(points):\\n    if len(points) < 2:\\n        return -1\\n\\n    if len(points) == 2:\\n        dx = abs(points[0][0] - points[1][0])\\n        dy = abs(points[0][1] - points[1][1])\\n        if dx == 0 or dy == 0:\\n            return -1\\n        else:\\n            return dx*dy\\n    else:\\n        dx = abs(points[0][0] - points[1][0])\\n        if dx == 0:\\n            dx = abs(points[0][0] - points[2][0])\\n        \\n        dy = abs(points[0][1] - points[1][1])\\n        if dy == 0:\\n            dy = abs(points[0][1] - points[2][1])\\n\\n        return dx*dy\\n\\nif __name__=='__main__':\\n    lines = sys.stdin.readlines()\\n\\n    n = int(lines[0].strip().split()[0])\\n\\n    points = []\\n\\n    for i in range(n):\\n        x, y = [int(v) for v in lines[i+1].strip().split()]\\n        points.append([x, y])\\n\\n    print solve(points)\",\"language\":\"python\",\"split\":\"train\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in PYTHON3?\\nYou are given an integer array a_1, a_2, ..., a_n and integer k.\\n\\nIn one step you can \\n\\n  * either choose some index i and decrease a_i by one (make a_i = a_i - 1); \\n  * or choose two indices i and j and set a_i equal to a_j (make a_i = a_j). \\n\\n\\n\\nWhat is the minimum number of steps you need to make the sum of array \u2211_{i=1}^{n}{a_i} \u2264 k? (You are allowed to make values of array negative).\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases.\\n\\nThe first line of each test case contains two integers n and k (1 \u2264 n \u2264 2 \u22c5 10^5; 1 \u2264 k \u2264 10^{15}) \u2014 the size of array a and upper bound on its sum.\\n\\nThe second line of each test case contains n integers a_1, a_2, ..., a_n (1 \u2264 a_i \u2264 10^9) \u2014 the array itself.\\n\\nIt's guaranteed that the sum of n over all test cases doesn't exceed 2 \u22c5 10^5.\\n\\nOutput\\n\\nFor each test case, print one integer \u2014 the minimum number of steps to make \u2211_{i=1}^{n}{a_i} \u2264 k.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n1 10\\n20\\n2 69\\n6 9\\n7 8\\n1 2 1 3 1 2 1\\n10 1\\n1 2 3 1 2 6 1 6 8 10\\n\\n\\nOutput\\n\\n\\n10\\n0\\n2\\n7\\n\\nNote\\n\\nIn the first test case, you should decrease a_1 10 times to get the sum lower or equal to k = 10.\\n\\nIn the second test case, the sum of array a is already less or equal to 69, so you don't need to change it.\\n\\nIn the third test case, you can, for example: \\n\\n  1. set a_4 = a_3 = 1; \\n  2. decrease a_4 by one, and get a_4 = 0. \\n\\nAs a result, you'll get array [1, 2, 1, 0, 1, 2, 1] with sum less or equal to 8 in 1 + 1 = 2 steps.\\n\\nIn the fourth test case, you can, for example: \\n\\n  1. choose a_7 and decrease in by one 3 times; you'll get a_7 = -2; \\n  2. choose 4 elements a_6, a_8, a_9 and a_{10} and them equal to a_7 = -2. \\n\\nAs a result, you'll get array [1, 2, 3, 1, 2, -2, -2, -2, -2, -2] with sum less or equal to 1 in 3 + 4 = 7 steps.\",\"targets\":\"R=lambda:map(int,input().split())\\nt,=R()\\nwhile t:\\n t-=1;n,k=R();a=sorted(R());s=0;r=2e9\\n for x in a:s+=x;n-=1;r=min(r,n-min(0,k-s-a[0]*n)\\/\\/(n+1))\\n print(r)\",\"language\":\"python\",\"split\":\"test\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Bachgold problem is very easy to formulate. Given a positive integer n represent it as a sum of maximum possible number of prime numbers. One can prove that such representation exists for any integer greater than 1.\\n\\nRecall that integer k is called prime if it is greater than 1 and has exactly two positive integer divisors \u2014 1 and k. \\n\\nInput\\n\\nThe only line of the input contains a single integer n (2 \u2264 n \u2264 100 000).\\n\\nOutput\\n\\nThe first line of the output contains a single integer k \u2014 maximum possible number of primes in representation.\\n\\nThe second line should contain k primes with their sum equal to n. You can print them in any order. If there are several optimal solution, print any of them.\\n\\nExamples\\n\\nInput\\n\\n5\\n\\n\\nOutput\\n\\n2\\n2 3\\n\\n\\nInput\\n\\n6\\n\\n\\nOutput\\n\\n3\\n2 2 2\\nSolve the task in PYTHON.\",\"targets\":\"n=input()\\nprint (\\\"%d\\\"%(n\\/2))\\nfor i in range(0,n\\/2):\\n\\tif n==3:\\n\\t\\tprint 3,\\n\\t\\tn=n-3\\n\\telse:\\n\\t\\tprint 2,\\n\\t\\tn=n-2\",\"language\":\"python\",\"split\":\"train\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Despite urging requests of the townspeople, the municipal office cannot afford to improve many of the apparently deficient city amenities under this recession. The city swimming pool is one of the typical examples. It has only two swimming lanes. The Municipal Fitness Agency, under this circumstances, settled usage rules so that the limited facilities can be utilized fully.\\n\\nTwo lanes are to be used for one-way swimming of different directions. Swimmers are requested to start swimming in one of the lanes, from its one end to the other, and then change the lane to swim his\\/her way back. When he or she reaches the original starting end, he\\/she should return to his\\/her initial lane and starts swimming again.\\n\\nEach swimmer has his\\/her own natural constant pace. Swimmers, however, are not permitted to pass other swimmers except at the ends of the pool; as the lanes are not wide enough, that might cause accidents. If a swimmer is blocked by a slower swimmer, he\\/she has to follow the slower swimmer at the slower pace until the end of the lane is reached. Note that the blocking swimmer\u2019s natural pace may be faster than the blocked swimmer; the blocking swimmer might also be blocked by another swimmer ahead, whose natural pace is slower than the blocked swimmer. Blocking would have taken place whether or not a faster swimmer was between them.\\n\\nSwimmers can change their order if they reach the end of the lane simultaneously. They change their order so that ones with faster natural pace swim in front. When a group of two or more swimmers formed by a congestion reaches the end of the lane, they are considered to reach there simultaneously, and thus change their order there.\\n\\nThe number of swimmers, their natural paces in times to swim from one end to the other, and the numbers of laps they plan to swim are given. Note that here one \\\"lap\\\" means swimming from one end to the other and then swimming back to the original end. Your task is to calculate the time required for all the swimmers to finish their plans. All the...\\nSolve the task in CPP.\",\"targets\":\"#define __USE_MINGW_ANSI_STDIO 0\\n#include <bits\\/stdc++.h>\\n\\nusing namespace std;\\nusing ll = long long;\\n#define int ll\\nusing VI = vector<int>;\\nusing VVI = vector<VI>;\\nusing PII = pair<int, int>;\\n\\n#define FOR(i, a, n) for (ll i = (ll)a; i < (ll)n; ++i)\\n#define REP(i, n) FOR(i, 0, n)\\n#define ALL(x) x.begin(), x.end()\\n#define PB push_back\\n\\nconst ll LLINF = (1LL<<60);\\nconst int INF = (1LL<<30);\\nconst int MOD = 1000000007;\\n\\ntemplate <typename T> T &chmin(T &a, const T &b) { return a = min(a, b); }\\ntemplate <typename T> T &chmax(T &a, const T &b) { return a = max(a, b); }\\ntemplate <typename T> bool IN(T a, T b, T x) { return a<=x&&x<b; }\\ntemplate<typename T> T ceil(T a, T b) { return a\\/b + !!(a%b); }\\ntemplate<class S,class T>\\nostream &operator <<(ostream& out,const pair<S,T>& a){\\n  out<<'('<<a.first<<','<<a.second<<')';\\n  return out;\\n}\\ntemplate<class T>\\nostream &operator <<(ostream& out,const vector<T>& a){\\n  out<<'[';\\n  REP(i, a.size()) {out<<a[i];if(i!=a.size()-1)out<<',';}\\n  out<<']';\\n  return out;\\n}\\n\\nint dx[] = {0, 1, 0, -1}, dy[] = {1, 0, -1, 0};\\n\\nsigned main(void)\\n{\\n  cin.tie(0);\\n  ios::sync_with_stdio(false);\\n\\n  while(true) {\\n    int n; cin >> n;\\n    if(!n) break;\\n    VI t(n), c(n);\\n    vector<PII> p(n);\\n    REP(i, n) {\\n      cin >> t[i] >> c[i];\\n      p[i] = {t[i], i};\\n    }\\n    sort(ALL(p));\\n\\n    \\/\\/ (\u4ebai, \u6298\u308a\u8fd4\u3059\u307e\u3067\u306b\u304b\u304b\u308b\u6642\u9593, \u5468\u56de\u6570)\\n    queue<VI> que[2];\\n    REP(i, n) que[0].push({p[i].second, p[i].first, 0});\\n\\n    int ans = 0;\\n    while(que[0].size() || que[1].size()) {\\n      \\/\\/ cur\u306equeue\u304b\u3089\u53d6\u308a\u51fa\u3059\\n      int cur = 0;\\n      if(que[cur].empty()) cur ^= 1;\\n      else if(que[cur^1].size() && que[cur].front()[1] > que[cur^1].front()[1]) cur ^= 1;\\n\\n      \\/\\/ next\u4ee5\u4e0b\u306e\u3082\u306e\u3092\u53d6\u308a\u51fa\u3059\\n      VVI v;\\n      int next = que[cur].front()[1];\\n      while(que[cur].size() && que[cur].front()[1] <= next) {\\n        v.PB(que[cur].front());\\n        que[cur].pop();\\n      }\\n      \\/\\/ v\u306e\u4e2d\u8eab\u3092\u901f\u5ea6\u9806\u3067\u30bd\u30fc\u30c8\u3059\u308b\\n      sort(ALL(v), [&](const VI&a, const VI&b){\\n        return t[a[0]] < t[b[0]];\\n      });\\n      \\/\\/ v\u306e\u4e2d\u8eab\u3092\u6b21\u306equeue\u306b\u79fb\u3059\\n      REP(i, v.size()) {\\n        if(cur ==...\",\"language\":\"python\",\"split\":\"train\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"A magic island Geraldion, where Gerald lives, has its own currency system. It uses banknotes of several values. But the problem is, the system is not perfect and sometimes it happens that Geraldionians cannot express a certain sum of money with any set of banknotes. Of course, they can use any number of banknotes of each value. Such sum is called unfortunate. Gerald wondered: what is the minimum unfortunate sum?\\n\\nInput\\n\\nThe first line contains number n (1 \u2264 n \u2264 1000) \u2014 the number of values of the banknotes that used in Geraldion. \\n\\nThe second line contains n distinct space-separated numbers a1, a2, ..., an (1 \u2264 ai \u2264 106) \u2014 the values of the banknotes.\\n\\nOutput\\n\\nPrint a single line \u2014 the minimum unfortunate sum. If there are no unfortunate sums, print  - 1.\\n\\nExamples\\n\\nInput\\n\\n5\\n1 2 3 4 5\\n\\n\\nOutput\\n\\n-1\\n#incl\",\"targets\":\"ude <bits\\/stdc++.h>\\nusing namespace std;\\nconst int maxn = 105;\\nint a[maxn];\\nint main() {\\n  ios::sync_with_stdio(0);\\n  cin.tie(0);\\n  int n;\\n  cin >> n;\\n  bool can = false;\\n  for (int i = 0; i < n; i++) {\\n    int k;\\n    cin >> k;\\n    if (k == 1) can = true;\\n  }\\n  can ? cout << -1 : cout << 1;\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"A tree is an undirected connected graph without cycles.\\n\\nYou are given a tree of n vertices. Find the number of ways to choose exactly k vertices in this tree (i. e. a k-element subset of vertices) so that all pairwise distances between the selected vertices are equal (in other words, there exists an integer c such that for all u, v (u \u2260 v, u, v are in selected vertices) d_{u,v}=c, where d_{u,v} is the distance from u to v).\\n\\nSince the answer may be very large, you need to output it modulo 10^9 + 7.\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 10) \u2014 the number of test cases. Then t test cases follow.\\n\\nEach test case is preceded by an empty line.\\n\\nEach test case consists of several lines. The first line of the test case contains two integers n and k (2 \u2264 k \u2264 n \u2264 100) \u2014 the number of vertices in the tree and the number of vertices to be selected, respectively. Then n - 1 lines follow, each of them contains two integers u and v (1 \u2264 u, v \u2264 n, u \u2260 v) which describe a pair of vertices connected by an edge. It is guaranteed that the given graph is a tree and has no loops or multiple edges.\\n\\nOutput\\n\\nFor each test case output in a separate line a single integer \u2014 the number of ways to select exactly k vertices so that for all pairs of selected vertices the distances between the vertices in the pairs are equal, modulo 10^9 + 7 (in other words, print the remainder when divided by 1000000007).\\n\\nExample\\n\\nInput\\n\\n\\n3\\n\\n4 2\\n1 2\\n2 3\\n2 4\\n\\n3 3\\n1 2\\n2 3\\n\\n5 3\\n1 2\\n2 3\\n2 4\\n4 5\\n\\n\\nOutput\\n\\n\\n6\\n0\\n1\\n#incl\",\"targets\":\"ude <bits\\/stdc++.h>\\nusing namespace std;\\nconst int MAX_N = 128;\\nconst long long mod = 1000 * 1000 * 1000 + 7;\\nlong long add(long long x, long long y) { return (x + y) % mod; }\\nlong long mul(long long x, long long y) { return x * y % mod; }\\nvector<int> g[MAX_N];\\nbool used[MAX_N];\\nint cnt[MAX_N];\\nlong long dp[MAX_N][MAX_N];\\nlong long rundp(int m, int k) {\\n  for (int i = 0; i <= m; i++)\\n    for (int j = 0; j <= k; j++) dp[i][j] = 0;\\n  dp[0][0] = 1;\\n  for (int i = 0; i < m; i++)\\n    for (int j = 0; j <= k; j++) {\\n      dp[i + 1][j] = add(dp[i + 1][j], dp[i][j]);\\n      dp[i + 1][j + 1] = add(dp[i + 1][j + 1], mul(dp[i][j], cnt[i]));\\n    }\\n  return dp[m][k];\\n}\\nvoid solve() {\\n  int n, k;\\n  cin >> n >> k;\\n  for (int i = 0; i < n; i++) g[i].clear();\\n  for (int i = 1; i < n; i++) {\\n    int a, b;\\n    cin >> a >> b;\\n    g[--a].push_back(--b);\\n    g[b].push_back(a);\\n  }\\n  if (k == 2) {\\n    cout << n * (n - 1LL) \\/ 2 % mod << '\\\\n';\\n    return;\\n  }\\n  long long ans = 0;\\n  for (int center = 0; center < n; center++) {\\n    memset(used, 0, n);\\n    used[center] = true;\\n    vector<pair<int, int>> layer;\\n    int m = g[center].size();\\n    for (int i = 0; i < m; i++) {\\n      int y = g[center][i];\\n      layer.emplace_back(y, i);\\n      cnt[i] = 1;\\n      used[y] = true;\\n    }\\n    while (!layer.empty()) {\\n      ans = add(ans, rundp(m, k));\\n      vector<pair<int, int>> newlayer;\\n      for (auto p : layer) {\\n        cnt[p.second]--;\\n        for (auto y : g[p.first])\\n          if (!used[y]) {\\n            newlayer.emplace_back(y, p.second);\\n            used[y] = true;\\n            cnt[p.second]++;\\n          }\\n      }\\n      layer = newlayer;\\n    }\\n  }\\n  cout << ans << '\\\\n';\\n}\\nint main() {\\n  int t;\\n  cin >> t;\\n  while (t--) solve();\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"<image>\\n\\nWilliam has two numbers a and b initially both equal to zero. William mastered performing three different operations with them quickly. Before performing each operation some positive integer k is picked, which is then used to perform one of the following operations: (note, that for each operation you can choose a new positive integer k)\\n\\n  1. add number k to both a and b, or \\n  2. add number k to a and subtract k from b, or \\n  3. add number k to b and subtract k from a. \\n\\n\\n\\nNote that after performing operations, numbers a and b may become negative as well.\\n\\nWilliam wants to find out the minimal number of operations he would have to perform to make a equal to his favorite number c and b equal to his second favorite number d.\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 10^4). Description of the test cases follows.\\n\\nThe only line of each test case contains two integers c and d (0 \u2264 c, d \u2264 10^9), which are William's favorite numbers and which he wants a and b to be transformed into.\\n\\nOutput\\n\\nFor each test case output a single number, which is the minimal number of operations which William would have to perform to make a equal to c and b equal to d, or -1 if it is impossible to achieve this using the described operations.\\n\\nExample\\n\\nInput\\n\\n\\n6\\n1 2\\n3 5\\n5 3\\n6 6\\n8 0\\n0 0\\n\\n\\nOutput\\n\\n\\n-1\\n2\\n2\\n1\\n2\\n0\\n\\nNote\\n\\nLet us demonstrate one of the suboptimal ways of getting a pair (3, 5):\\n\\n  * Using an operation of the first type with k=1, the current pair would be equal to (1, 1). \\n  * Using an operation of the third type with k=8, the current pair would be equal to (-7, 9). \\n  * Using an operation of the second type with k=7, the current pair would be equal to (0, 2). \\n  * Using an operation of the first type with k=3, the current pair would be equal to (3, 5).\",\"targets\":\"t=int(raw_input())\\nfor _ in range(t):\\n    c,d=map(int,raw_input().strip().split())\\n    if c==d and c==0:\\n        print(0)\\n    elif c==d:\\n        print(1)\\n    elif (c-d)%2==1:\\n        print(-1)\\n    else:\\n        print(2)\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You are given a keyboard that consists of 26 keys. The keys are arranged sequentially in one row in a certain order. Each key corresponds to a unique lowercase Latin letter.\\n\\nYou have to type the word s on this keyboard. It also consists only of lowercase Latin letters.\\n\\nTo type a word, you need to type all its letters consecutively one by one. To type each letter you must position your hand exactly over the corresponding key and press it.\\n\\nMoving the hand between the keys takes time which is equal to the absolute value of the difference between positions of these keys (the keys are numbered from left to right). No time is spent on pressing the keys and on placing your hand over the first letter of the word.\\n\\nFor example, consider a keyboard where the letters from 'a' to 'z' are arranged in consecutive alphabetical order. The letters 'h', 'e', 'l' and 'o' then are on the positions 8, 5, 12 and 15, respectively. Therefore, it will take |5 - 8| + |12 - 5| + |12 - 12| + |15 - 12| = 13 units of time to type the word \\\"hello\\\". \\n\\nDetermine how long it will take to print the word s.\\n\\nInput\\n\\nThe first line contains an integer t (1 \u2264 t \u2264 1000) \u2014 the number of test cases.\\n\\nThe next 2t lines contain descriptions of the test cases.\\n\\nThe first line of a description contains a keyboard \u2014 a string of length 26, which consists only of lowercase Latin letters. Each of the letters from 'a' to 'z' appears exactly once on the keyboard.\\n\\nThe second line of the description contains the word s. The word has a length from 1 to 50 letters inclusive and consists of lowercase Latin letters.\\n\\nOutput\\n\\nPrint t lines, each line containing the answer to the corresponding test case. The answer to the test case is the minimal time it takes to type the word s on the given keyboard.\\n\\nExample\\n\\nInput\\n\\n\\n5\\nabcdefghijklmnopqrstuvwxyz\\nhello\\nabcdefghijklmnopqrstuvwxyz\\ni\\nabcdefghijklmnopqrstuvwxyz\\ncodeforces\\nqwertyuiopasdfghjklzxcvbnm\\nqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\nqwertyuiopasdfghjklzxcvbnm\\nabacaba\\n\\n\\nOutput\\n\\n\\n13\\n0\\n68\\n0\\n74\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint solve() {\\n  string s, word;\\n  cin >> s >> word;\\n  int sum = 0;\\n  char a = word[0];\\n  int indexO = s.find(a) + 1;\\n  for (char &c : word) {\\n    sum += abs(int(s.find(c) + 1 - indexO));\\n    indexO = s.find(c) + 1;\\n  }\\n  cout << sum << \\\"\\\\n\\\";\\n  return 0;\\n}\\nint main() {\\n  ios::sync_with_stdio(0);\\n  cin.tie(0);\\n  int n;\\n  cin >> n;\\n  for (int i = 0; i < n; i++) {\\n    solve();\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in CPP?\\n\\n\\nInput\\n\\nThe input contains a single integer a (1 \u2264 a \u2264 40).\\n\\nOutput\\n\\nOutput a single string.\\n\\nExamples\\n\\nInput\\n\\n2\\n\\n\\nOutput\\n\\nAdams\\n\\n\\nInput\\n\\n8\\n\\n\\nOutput\\n\\nVan Buren\\n\\n\\nInput\\n\\n29\\n\\n\\nOutput\\n\\nHarding\",\"targets\":\"#include <bits\\/stdc++.h>\\nint n, ans[1000] = {0,   1,  1, 1, 2,  1, 2,  1, 5,  2, 2,  1, 5,  1, 2, 1,\\n                    14,  1,  5, 1, 5,  2, 2,  1, 15, 2, 2,  5, 4,  1, 4, 1,\\n                    51,  1,  2, 1, 14, 1, 2,  2, 14, 1, 6,  1, 4,  2, 2, 1,\\n                    52,  2,  5, 1, 5,  1, 15, 2, 13, 2, 2,  1, 13, 1, 2, 4,\\n                    267, 1,  4, 1, 5,  1, 4,  1, 50, 1, 2,  3, 4,  1, 6, 1,\\n                    52,  15, 2, 1, 15, 1, 2,  1, 12, 1, 10, 1, 4,  2};\\nint main() {\\n  scanf(\\\"%d\\\", &n);\\n  printf(\\\"%d\\\", ans[n]);\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CQXYM wants to create a connected undirected graph with n nodes and m edges, and the diameter of the graph must be strictly less than k-1. Also, CQXYM doesn't want a graph that contains self-loops or multiple edges (i.e. each edge connects two different vertices and between each pair of vertices there is at most one edge).\\n\\nThe diameter of a graph is the maximum distance between any two nodes.\\n\\nThe distance between two nodes is the minimum number of the edges on the path which endpoints are the two nodes.\\n\\nCQXYM wonders whether it is possible to create such a graph.\\n\\nInput\\n\\nThe input consists of multiple test cases. \\n\\nThe first line contains an integer t (1 \u2264 t \u2264 10^5) \u2014 the number of test cases. The description of the test cases follows.\\n\\nOnly one line of each test case contains three integers n(1 \u2264 n \u2264 10^9), m, k (0 \u2264 m,k \u2264 10^9).\\n\\nOutput\\n\\nFor each test case, print YES if it is possible to create the graph, or print NO if it is impossible. You can print each letter in any case (upper or lower).\\n\\nExample\\n\\nInput\\n\\n\\n5\\n1 0 3\\n4 5 3\\n4 6 3\\n5 4 1\\n2 1 1\\n\\n\\nOutput\\n\\n\\nYES\\nNO\\nYES\\nNO\\nNO\\n\\nNote\\n\\nIn the first test case, the graph's diameter equal to 0.\\n\\nIn the second test case, the graph's diameter can only be 2.\\n\\nIn the third test case, the graph's diameter can only be 1.\\nimpor\",\"targets\":\"t math\\n \\nfor q in range(int(input())):\\n    #n = int(input())\\n    n, m, k= list(map(int, input().split()))                                       \\n    k-=1\\n    temp2 = n*(n-1)\\/\\/2\\n    temp =temp2-m\\n    temp = temp+1 if m!=n-1 else n-1\\n    #print(temp ,k)\\n    if n==1 and k>0 and m==0:\\n        print(\\\"YES\\\")\\n    elif m>temp2:\\n        print(\\\"NO\\\")\\n    \\n    elif m==temp2 and k>1:\\n        print(\\\"YES\\\")\\n    elif  m==n-1 and k>2:\\n        print(\\\"YES\\\")\\n    elif m<n-1:\\n        print(\\\"NO\\\")\\n    elif 2<k:\\n        print(\\\"YES\\\")\\n    else:\\n        \\n        \\n        print(\\\"NO\\\")\",\"language\":\"python\",\"split\":\"test\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Alex decided to try his luck in TV shows. He once went to the quiz named \\\"What's That Word?!\\\". After perfectly answering the questions \\\"How is a pseudonym commonly referred to in the Internet?\\\" (\\\"Um... a nick?\\\"), \\\"After which famous inventor we name the unit of the magnetic field strength?\\\" (\\\"Um... Nikola Tesla?\\\") and \\\"Which rock band performs \\\"How You Remind Me\\\"?\\\" (\\\"Um... Nickelback?\\\"), he decided to apply to a little bit more difficult TV show: \\\"What's in This Multiset?!\\\".\\n\\nThe rules of this TV show are as follows: there are n multisets numbered from 1 to n. Each of them is initially empty. Then, q events happen; each of them is in one of the four possible types:\\n\\n  * 1 x v \u2014 set the x-th multiset to a singleton \\\\\\\\{v\\\\}.\\n  * 2 x y z \u2014 set the x-th multiset to a union of the y-th and the z-th multiset. For example: \\\\{1, 3\\\\}\u222a\\\\{1, 4, 4\\\\}=\\\\{1, 1, 3, 4, 4\\\\}.\\n  * 3 x y z \u2014 set the x-th multiset to a product of the y-th and the z-th multiset. The product A \u00d7 B of two multisets A, B is defined as \\\\{ \\\\gcd(a, b)  \u2223  a \u2208 A,  b \u2208 B \\\\}, where \\\\gcd(p, q) is the greatest common divisor of p and q. For example: \\\\{2, 2, 3\\\\} \u00d7 \\\\{1, 4, 6\\\\}=\\\\{1, 2, 2, 1, 2, 2, 1, 1, 3\\\\}.\\n  * 4 x v \u2014 the participant is asked how many times number v occurs in the x-th multiset. As the quiz turned out to be too hard in the past, participants should now give the answers modulo 2 only. \\n\\n\\n\\nNote, that x, y and z described above are not necessarily different. In events of types 2 and 3, the sum or the product is computed first, and then the assignment is performed.\\n\\nAlex is confused by the complicated rules of the show. Can you help him answer the requests of the 4-th type?\\n\\nInput\\n\\nThe first line contains two integers n and q (1 \u2264 n \u2264 10^5, 1 \u2264 q \u2264 10^6) \u2014 the number of multisets and the number of events.\\n\\nEach of the following q lines describes next event in the format given in statement. It's guaranteed that 1 \u2264 x,y,z \u2264 n and 1 \u2264 v \u2264 7000 always holds.\\n\\nIt's guaranteed that there will be at least one event of the 4-th type.\\n\\nOutput\\n\\nPrint a string...\\nSolve the task in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst int N = 7001, MAXN = 100001;\\nint n, Q;\\nbitset<N> que[N], st[MAXN];\\nvector<int> d[N];\\nint pri[N + 233], mip[N + 233], mu[N + 233], pcn;\\nvoid first() {\\n  mu[1] = 1;\\n  for (int i = 2; i < N; i++) {\\n    if (!mip[i]) pri[++pcn] = i, mu[i] = -1;\\n    for (int j = 1; j <= pcn && i * pri[j] < N; j++) {\\n      mip[i * pri[j]] = pri[j];\\n      if (i % pri[j] == 0) break;\\n      mu[i * pri[j]] = -mu[i];\\n    }\\n  }\\n  for (int i = 1; i < N; i++)\\n    for (int j = i; j < N; j += i)\\n      if (mu[j \\/ i]) que[i][j] = 1;\\n  for (int i = 1; i < N; i++)\\n    for (int j = i; j < N; j += i) d[j].push_back(i);\\n}\\nint main() {\\n  first();\\n  scanf(\\\"%d%d\\\", &n, &Q);\\n  while (Q--) {\\n    int opt, x, y, z, v;\\n    scanf(\\\"%d\\\", &opt);\\n    switch (opt) {\\n      case 1:\\n        scanf(\\\"%d%d\\\", &x, &v);\\n        st[x].reset();\\n        for (int t : d[v]) st[x][t] = 1;\\n        break;\\n      case 2:\\n        scanf(\\\"%d%d%d\\\", &x, &y, &z);\\n        st[x] = st[y] ^ st[z];\\n        break;\\n      case 3:\\n        scanf(\\\"%d%d%d\\\", &x, &y, &z);\\n        st[x] = st[y] & st[z];\\n        break;\\n      case 4:\\n        scanf(\\\"%d%d\\\", &x, &v);\\n        putchar((st[x] & que[v]).count() & 1 ? '1' : '0');\\n        break;\\n    }\\n  }\\n  return puts(\\\"\\\"), 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Polycarp must pay exactly n burles at the checkout. He has coins of two nominal values: 1 burle and 2 burles. Polycarp likes both kinds of coins equally. So he doesn't want to pay with more coins of one type than with the other.\\n\\nThus, Polycarp wants to minimize the difference between the count of coins of 1 burle and 2 burles being used. Help him by determining two non-negative integer values c_1 and c_2 which are the number of coins of 1 burle and 2 burles, respectively, so that the total value of that number of coins is exactly n (i. e. c_1 + 2 \u22c5 c_2 = n), and the absolute value of the difference between c_1 and c_2 is as little as possible (i. e. you must minimize |c_1-c_2|).\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases. Then t test cases follow.\\n\\nEach test case consists of one line. This line contains one integer n (1 \u2264 n \u2264 10^9) \u2014 the number of burles to be paid by Polycarp.\\n\\nOutput\\n\\nFor each test case, output a separate line containing two integers c_1 and c_2 (c_1, c_2 \u2265 0) separated by a space where c_1 is the number of coins of 1 burle and c_2 is the number of coins of 2 burles. If there are multiple optimal solutions, print any one.\\n\\nExample\\n\\nInput\\n\\n\\n6\\n1000\\n30\\n1\\n32\\n1000000000\\n5\\n\\n\\nOutput\\n\\n\\n334 333\\n10 10\\n1 0\\n10 11\\n333333334 333333333\\n1 2\\n\\nNote\\n\\nThe answer for the first test case is \\\"334 333\\\". The sum of the nominal values of all coins is 334 \u22c5 1 + 333 \u22c5 2 = 1000, whereas |334 - 333| = 1. One can't get the better value because if |c_1 - c_2| = 0, then c_1 = c_2 and c_1 \u22c5 1 + c_1 \u22c5 2 = 1000, but then the value of c_1 isn't an integer.\\n\\nThe answer for the second test case is \\\"10 10\\\". The sum of the nominal values is 10 \u22c5 1 + 10 \u22c5 2 = 30 and |10 - 10| = 0, whereas there's no number having an absolute value less than 0.\\nt=int\",\"targets\":\"(input())\\nfor i in range(t):\\n\\tn=int(input())\\n\\tc1=int(n\\/3)\\n\\tc2=c1\\n\\tif abs(c1+2*c2-n)==1:\\n\\t\\tc1=c1+1\\n\\telif(c1+2*c2-n)==0:\\n\\t\\tc1=c2\\t\\n\\telse:\\n\\t\\tc2=c2+1\\t\\n\\tprint(c1,end=\\\" \\\")\\n\\tprint(c2)\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"El Psy Kongroo.\\n\\nOmkar is watching Steins;Gate.\\n\\nIn Steins;Gate, Okabe Rintarou needs to complete n tasks (1 \u2264 n \u2264 2 \u22c5 10^5). Unfortunately, he doesn't know when he needs to complete the tasks.\\n\\nInitially, the time is 0. Time travel will now happen according to the following rules:\\n\\n  * For each k = 1, 2, \u2026, n, Okabe will realize at time b_k that he was supposed to complete the k-th task at time a_k (a_k < b_k). \\n\\n  * When he realizes this, if k-th task was already completed at time a_k, Okabe keeps the usual flow of time. Otherwise, he time travels to time a_k then immediately completes the task.\\n\\n  * If Okabe time travels to time a_k, all tasks completed after this time will become incomplete again. That is, for every j, if a_j>a_k, the j-th task will become incomplete, if it was complete (if it was incomplete, nothing will change).\\n\\n  * Okabe has bad memory, so he can time travel to time a_k only immediately after getting to time b_k and learning that he was supposed to complete the k-th task at time a_k. That is, even if Okabe already had to perform k-th task before, he wouldn't remember it before stumbling on the info about this task at time b_k again.\\n\\n\\n\\n\\nPlease refer to the notes for an example of time travelling.\\n\\nThere is a certain set s of tasks such that the first moment that all of the tasks in s are simultaneously completed (regardless of whether any other tasks are currently completed), a funny scene will take place. Omkar loves this scene and wants to know how many times Okabe will time travel before this scene takes place. Find this number modulo 10^9 + 7. It can be proven that eventually all n tasks will be completed and so the answer always exists.\\n\\nInput\\n\\nThe first line contains an integer n (1 \u2264 n \u2264 2 \u22c5 10^5) \u2014 the number of tasks that Okabe needs to complete.\\n\\nn lines follow. The k-th of these lines contain two integers a_k and b_k (1 \u2264 a_k < b_k \u2264 2n) \u2014 the time at which Okabe needs to complete the k-th task and the time that he realizes this respectively. All 2n of these times are...\\nThe above is tricky. Write me a correct solution in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst int mod = 1000000007;\\nconst int mxn = 400001;\\nint n, m;\\nint a[mxn], b[mxn], first[mxn], d[mxn], ff[mxn], dp[mxn], bt[mxn];\\nmultiset<int, greater<int>> second;\\nvoid add(int x, int y) {\\n  for (; x <= 2 * n; x += x & -x) (bt[x] += y) %= mod;\\n}\\nint qry(int x) {\\n  int ret = 0;\\n  for (; x; x -= x & -x) (ret += bt[x]) %= mod;\\n  return ret;\\n}\\nint main() {\\n  ios::sync_with_stdio(0);\\n  cin.tie(0);\\n  cin >> n;\\n  for (int i = 0; i < n; i++) cin >> a[i] >> b[i], first[i] = i;\\n  sort(first, first + n, [&](int x, int y) { return a[x] < a[y]; });\\n  cin >> m;\\n  for (int i = 0, x; i < m; i++) cin >> x, d[--x] = 1, second.insert(b[x]);\\n  for (int i = 0; i < n; i++) {\\n    int x = first[i];\\n    ff[x] = !second.empty() && b[x] <= *second.begin();\\n    if (d[x]) second.erase(second.find(b[x]));\\n  }\\n  long long ret = 0;\\n  for (int i = 0; i < n; i++) {\\n    int x = first[i];\\n    add(b[x], dp[x] = (mod + ff[x] + qry(2 * n) - qry(b[x])) % mod);\\n    (ret += dp[x]) %= mod;\\n  }\\n  cout << ret << '\\\\n';\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"JAVA solution for \\\"You have an axis-aligned rectangle room with width W and height H, so the lower left corner is in point (0, 0) and the upper right corner is in (W, H).\\n\\nThere is a rectangular table standing in this room. The sides of the table are parallel to the walls, the lower left corner is in (x_1, y_1), and the upper right corner in (x_2, y_2).\\n\\nYou want to place another rectangular table in this room with width w and height h with the width of the table parallel to the width of the room.\\n\\nThe problem is that sometimes there is not enough space to place the second table without intersecting with the first one (there are no problems with tables touching, though).\\n\\nYou can't rotate any of the tables, but you can move the first table inside the room. \\n\\n<image> Example of how you may move the first table.\\n\\nWhat is the minimum distance you should move the first table to free enough space for the second one?\\n\\nInput\\n\\nThe first line contains the single integer t (1 \u2264 t \u2264 5000) \u2014 the number of the test cases.\\n\\nThe first line of each test case contains two integers W and H (1 \u2264 W, H \u2264 10^8) \u2014 the width and the height of the room.\\n\\nThe second line contains four integers x_1, y_1, x_2 and y_2 (0 \u2264 x_1 < x_2 \u2264 W; 0 \u2264 y_1 < y_2 \u2264 H) \u2014 the coordinates of the corners of the first table.\\n\\nThe third line contains two integers w and h (1 \u2264 w \u2264 W; 1 \u2264 h \u2264 H) \u2014 the width and the height of the second table.\\n\\nOutput\\n\\nFor each test case, print the minimum distance you should move the first table, or -1 if there is no way to free enough space for the second table.\\n\\nYour answer will be considered correct if its absolute or relative error doesn't exceed 10^{-6}.\\n\\nExample\\n\\nInput\\n\\n\\n5\\n8 5\\n2 1 7 4\\n4 2\\n5 4\\n2 2 5 4\\n3 3\\n1 8\\n0 3 1 6\\n1 5\\n8 1\\n3 0 6 1\\n5 1\\n8 10\\n4 5 7 8\\n8 5\\n\\n\\nOutput\\n\\n\\n1.000000000\\n-1\\n2.000000000\\n2.000000000\\n0.000000000\\n\\nNote\\n\\nThe configuration of the first test case is shown in the picture. But the movement of the first table is not optimal. One of the optimal movement, for example, is to move the table by (0, -1), so the lower left corner...\\\":\",\"targets\":\"import java.io.*;\\nimport java.util.*;\\n\\npublic class TwoTables {\\n\\tpublic static void main(String args[]) throws IOException {\\n\\t\\tBufferedReader br = new BufferedReader(new InputStreamReader(System.in));\\n\\t\\tint t = Integer.parseInt(br.readLine());\\n\\t\\twhile (t-- > 0) {\\n\\t\\t\\tString[] ip = br.readLine().trim().split(\\\" \\\");\\n\\t\\t\\tint W = Integer.parseInt(ip[0]);\\n\\t\\t\\tint H = Integer.parseInt(ip[1]);\\n\\n\\t\\t\\tString[] ip2 = br.readLine().trim().split(\\\" \\\");\\n\\t\\t\\tint x1 = Integer.parseInt(ip2[0]);\\n\\t\\t\\tint y1 = Integer.parseInt(ip2[1]);\\n\\t\\t\\tint x2 = Integer.parseInt(ip2[2]);\\n\\t\\t\\tint y2 = Integer.parseInt(ip2[3]);\\n\\n\\t\\t\\tString[] ip3 = br.readLine().trim().split(\\\" \\\");\\n\\t\\t\\tint wT = Integer.parseInt(ip3[0]);\\n\\t\\t\\tint hT = Integer.parseInt(ip3[1]);\\n\\n\\t\\t\\tif ((x2 - x1 + wT > W) && (y2 - y1 + hT > H)) {\\n\\t\\t\\t\\tSystem.out.println(\\\"-1\\\");\\n\\t\\t\\t} else {\\n\\t\\t\\t\\tint resH = Integer.MAX_VALUE;\\n\\t\\t\\t\\tint resV = Integer.MAX_VALUE;\\n\\t\\t\\t\\tif (x2 - x1 + wT <= W) {\\n\\t\\t\\t\\t\\tint r1 = wT - (W - x2);\\n\\t\\t\\t\\t\\tint r2 = wT - x1;\\n\\t\\t\\t\\t\\tresH = Math.min(r2, r1);\\n\\t\\t\\t\\t}\\n\\t\\t\\t\\tif (y2 - y1 + hT <= H) {\\n\\t\\t\\t\\t\\tint r1 = hT - (H - y2);\\n\\t\\t\\t\\t\\tint r2 = hT - y1;\\n\\t\\t\\t\\t\\tresV = Math.min(r2, r1);\\n\\t\\t\\t\\t}\\n\\t\\t\\t\\tSystem.out.println(Math.max(0, Math.min(resH, resV)) + \\\".00000\\\");\\n\\t\\t\\t}\\n\\t\\t\\t\\n\\t\\t}\\n\\t}\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"This is the hard version of the problem. The only difference from the easy version is that in this version the coordinates can be both odd and even.\\n\\nThere are n fence-posts at distinct coordinates on a plane. It is guaranteed that no three fence posts lie on the same line.\\n\\nThere are an infinite number of cows on the plane, one at every point with integer coordinates.\\n\\nGregor is a member of the Illuminati, and wants to build a triangular fence, connecting 3 distinct existing fence posts. A cow strictly inside the fence is said to be enclosed. If there are an odd number of enclosed cows and the area of the fence is an integer, the fence is said to be interesting.\\n\\nFind the number of interesting fences.\\n\\nInput\\n\\nThe first line contains the integer n (3 \u2264 n \u2264 6000), the number of fence posts which Gregor can choose to form the vertices of a fence.\\n\\nEach of the next n line contains two integers x and y (0 \u2264 x,y \u2264 10^7, where (x,y) is the coordinate of a fence post. All fence posts lie at distinct coordinates. No three fence posts are on the same line.\\n\\nOutput\\n\\nPrint a single integer, the number of interesting fences. Two fences are considered different if they are constructed with a different set of three fence posts.\\n\\nExamples\\n\\nInput\\n\\n\\n3\\n0 0\\n2 0\\n0 4\\n\\n\\nOutput\\n\\n\\n1\\n\\n\\nInput\\n\\n\\n4\\n1 8\\n0 6\\n5 2\\n5 6\\n\\n\\nOutput\\n\\n\\n1\\n\\n\\nInput\\n\\n\\n10\\n170 59\\n129 54\\n5 98\\n129 37\\n58 193\\n154 58\\n24 3\\n13 138\\n136 144\\n174 150\\n\\n\\nOutput\\n\\n\\n29\\n\\nNote\\n\\nIn the first example, there is only 1 fence. That fence is interesting since its area is 4 and there is 1 enclosed cow, marked in red.\\n\\n<image>\\n\\nIn the second example, there are 4 possible fences. Only one of them is interesting however. That fence has an area of 8 and 5 enclosed cows.\\n\\n<image>\\\":\",\"targets\":\"#include <bits\\/stdc++.h>\\ntemplate <class T1, class T2>\\ninline bool cmin(T1 &a, const T2 &b) {\\n  return b < a ? (a = b, true) : false;\\n}\\ntemplate <class T1, class T2>\\ninline bool cmax(T1 &a, const T2 &b) {\\n  return a < b ? (a = b, true) : false;\\n}\\ntemplate <class Type>\\nType read() {\\n  Type a;\\n  bool b;\\n  unsigned char c;\\n  while (c = getchar() - 48, (c > 9) & (c != 253))\\n    ;\\n  for (a = (b = c == 253) ? 0 : c; (c = getchar() - 48) <= 9; a = a * 10 + c)\\n    ;\\n  return b ? -a : a;\\n}\\nint (*rd)() = read<int>;\\nconst int P = 4;\\ninline int &inc(int &a, int b) { return (a += b) < P ? a : (a -= P); }\\ninline int &dec(int &a, int b) { return (a -= b) < 0 ? (a += P) : a; }\\ninline int add(int a, int b) { return (a += b) < P ? a : a - P; }\\ninline int sub(int a, int b) { return (a -= b) < 0 ? a + P : a; }\\nunsigned long long power(unsigned long long a, int b) {\\n  unsigned long long ans = 1;\\n  for (; b; a = a * a % P, b \\/= 2)\\n    if (b & 1) ans = ans * a % P;\\n  return ans;\\n}\\nconst int N = 6005;\\nint n, x[N], y[N], cnt[64];\\nint gcd(int x, int y) { return y ? gcd(y, x % y) : x; }\\nint main() {\\n  n = rd();\\n  for (int i = 1; i <= n; ++i) x[i] = rd(), y[i] = rd();\\n  long long ans = 0;\\n  for (int i = 1; i <= n; ++i) {\\n    memset(cnt, 0, sizeof(cnt));\\n    for (int j = 1; j <= n; ++j) {\\n      if (i == j) continue;\\n      int dd = gcd(abs(x[j] - x[i]), abs(y[j] - y[i])) % 4;\\n      int xx = (x[j] - x[i]) & 3;\\n      int yy = (y[j] - y[i]) & 3;\\n      ++cnt[dd << 4 | xx << 2 | yy];\\n    }\\n    for (int j = 0; j < 64; ++j) {\\n      if (!cnt[j]) continue;\\n      int jd = j >> 4, jx = j >> 2 & 3, jy = j & 3;\\n      for (int k = j; k < 64; ++k) {\\n        if (!cnt[k]) continue;\\n        int kd = k >> 4, kx = k >> 2 & 3, ky = k & 3;\\n        if (jd % 2 != kd % 2) continue;\\n        int dd = gcd(abs(jx - kx), abs(jy - ky)) % 4;\\n        if (dd % 2 != 0) continue;\\n        if (abs(jx * ky - jy * kx) % 4 == (jd + kd + dd) % 4)\\n          ans += (j == k ? cnt[j] * (cnt[j] - 1) \\/ 2 : cnt[j] * cnt[k]) *\\n                 (jd % 2 == 0 ? 1 : 3);\\n      }\\n    }\\n  }\\n ...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"PYTHON3 solution for \\\"The problem statement looms below, filling you with determination.\\n\\nConsider a grid in which some cells are empty and some cells are filled. Call a cell in this grid exitable if, starting at that cell, you can exit the grid by moving up and left through only empty cells. This includes the cell itself, so all filled in cells are not exitable. Note that you can exit the grid from any leftmost empty cell (cell in the first column) by going left, and from any topmost empty cell (cell in the first row) by going up.\\n\\nLet's call a grid determinable if, given only which cells are exitable, we can exactly determine which cells are filled in and which aren't.\\n\\nYou are given a grid a of dimensions n \u00d7 m , i. e. a grid with n rows and m columns. You need to answer q queries (1 \u2264 q \u2264 2 \u22c5 10^5). Each query gives two integers x_1, x_2 (1 \u2264 x_1 \u2264 x_2 \u2264 m) and asks whether the subgrid of a consisting of the columns x_1, x_1 + 1, \u2026, x_2 - 1, x_2 is determinable.\\n\\nInput\\n\\nThe first line contains two integers n, m (1 \u2264 n, m \u2264 10^6, nm \u2264 10^6) \u2014 the dimensions of the grid a.\\n\\nn lines follow. The y-th line contains m characters, the x-th of which is 'X' if the cell on the intersection of the the y-th row and x-th column is filled and \\\".\\\" if it is empty.\\n\\nThe next line contains a single integer q (1 \u2264 q \u2264 2 \u22c5 10^5) \u2014 the number of queries.\\n\\nq lines follow. Each line contains two integers x_1 and x_2 (1 \u2264 x_1 \u2264 x_2 \u2264 m), representing a query asking whether the subgrid of a containing the columns x_1, x_1 + 1, \u2026, x_2 - 1, x_2 is determinable.\\n\\nOutput\\n\\nFor each query, output one line containing \\\"YES\\\" if the subgrid specified by the query is determinable and \\\"NO\\\" otherwise. The output is case insensitive (so \\\"yEs\\\" and \\\"No\\\" will also be accepted).\\n\\nExample\\n\\nInput\\n\\n\\n4 5\\n..XXX\\n...X.\\n...X.\\n...X.\\n5\\n1 3\\n3 3\\n4 5\\n5 5\\n1 5\\n\\n\\nOutput\\n\\n\\nYES\\nYES\\nNO\\nYES\\nNO\\n\\nNote\\n\\nFor each query of the example, the corresponding subgrid is displayed twice below: first in its input format, then with each cell marked as \\\"E\\\" if it is exitable and \\\"N\\\" otherwise.\\n\\nFor the...\\\":\",\"targets\":\"import sys\\nfrom functools import lru_cache\\nfrom collections import defaultdict, deque \\nfrom types import GeneratorType\\ninput = sys.stdin.readline\\n\\n\\ndef prefix_sum(arr):\\n    \\n    prefix_arr = [0] * (len(arr) + 1)\\n    \\n    for i in range(len(arr)):\\n        prefix_arr[i+1] = prefix_arr[i] + arr[i]\\n        \\n    return prefix_arr\\n    \\ndef bfs(x, y, visited, grid, reachable_grid, n, m):\\n    \\n    stack = [(x, y)]\\n    while stack:\\n        x, y = stack.pop()\\n        if not visited[x][y]:\\n            visited[x][y] = True\\n            \\n            if grid[x][y] == '.':\\n                reachable_grid[x][y] = True\\n                \\n                if y + 1 < m:\\n                    stack.append((x, y+1))\\n                \\n                if x + 1 < n:\\n                    stack.append((x+1, y))\\n            \\n                \\n\\ndef get_reachable_grid(grid, n, m):\\n    \\n    reachable_grid = [[False] * m for _ in range(n)]\\n    visited = [[False] * m for _ in range(n)]\\n    \\n    y = 0\\n    for x in range(n):\\n        if not visited[x][y]:\\n            if grid[x][y] == '.':\\n                bfs(x, y, visited, grid, reachable_grid, n, m)\\n            visited[x][y] = True\\n    x = 0\\n    for y in range(m):\\n        if not visited[x][y]:\\n            if grid[x][y] == '.':\\n                bfs(x, y, visited, grid, reachable_grid, n, m)\\n            visited[x][y] = True\\n    \\n    return reachable_grid\\n    \\n\\ndef solve(grid, n, m):\\n\\n\\n    blocked = [0] * m\\n    for y in range(1, m):\\n        for x in range(1, n):\\n            if grid[x-1][y] == 'X' and grid[x][y-1] == 'X':\\n                blocked[y] = 1\\n                break\\n    blocked_prefix = prefix_sum(blocked)\\n    \\n    q = int(input())\\n    for _ in range(q): \\n        y1, y2 = [int(val)-1 for val in input().split()]\\n        if blocked_prefix[y2+1] - blocked_prefix[y1+1] == 0  if y1 != y2 else True:\\n            sys.stdout.write(\\\"YES\\\\n\\\")\\n        else:\\n            sys.stdout.write(\\\"NO\\\\n\\\")\\n    \\n    \\nif __name__ == \\\"__main__\\\":\\n    \\n    n, m = [int(val) for val in input().split()]\\n    \\n    grid = []\\n    for i...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"JAVA solution for \\\"Dmitry has an array of n non-negative integers a_1, a_2, ..., a_n.\\n\\nIn one operation, Dmitry can choose any index j (1 \u2264 j \u2264 n) and increase the value of the element a_j by 1. He can choose the same index j multiple times.\\n\\nFor each i from 0 to n, determine whether Dmitry can make the MEX of the array equal to exactly i. If it is possible, then determine the minimum number of operations to do it.\\n\\nThe MEX of the array is equal to the minimum non-negative integer that is not in the array. For example, the MEX of the array [3, 1, 0] is equal to 2, and the array [3, 3, 1, 4] is equal to 0.\\n\\nInput\\n\\nThe first line of input data contains a single integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases in the input. \\n\\nThe descriptions of the test cases follow.\\n\\nThe first line of the description of each test case contains a single integer n (1 \u2264 n \u2264 2 \u22c5 10^5) \u2014 the length of the array a.\\n\\nThe second line of the description of each test case contains n integers a_1, a_2, ..., a_n (0 \u2264 a_i \u2264 n) \u2014 elements of the array a.\\n\\nIt is guaranteed that the sum of the values n over all test cases in the test does not exceed 2\u22c510^5.\\n\\nOutput\\n\\nFor each test case, output n + 1 integer \u2014 i-th number is equal to the minimum number of operations for which you can make the array MEX equal to i (0 \u2264 i \u2264 n), or -1 if this cannot be done.\\n\\nExample\\n\\nInput\\n\\n\\n5\\n3\\n0 1 3\\n7\\n0 1 2 3 4 3 2\\n4\\n3 0 0 0\\n7\\n4 6 2 3 5 0 5\\n5\\n4 0 1 0 4\\n\\n\\nOutput\\n\\n\\n1 1 0 -1 \\n1 1 2 2 1 0 2 6 \\n3 0 1 4 3 \\n1 0 -1 -1 -1 -1 -1 -1 \\n2 1 0 2 -1 -1 \\n\\nNote\\n\\nIn the first set of example inputs, n=3:\\n\\n  * to get MEX=0, it is enough to perform one increment: a_1++; \\n  * to get MEX=1, it is enough to perform one increment: a_2++; \\n  * MEX=2 for a given array, so there is no need to perform increments; \\n  * it is impossible to get MEX=3 by performing increments. \\\":\",\"targets\":\"import java.util.*;\\nimport java.io.*;\\nimport java.math.*;\\n\\n\\n\\/**\\n * @author Naitik\\n * \\n *\\/\\npublic class Main\\n\\n{ \\n\\t static FastReader sc=new FastReader(); \\n\\t static int dp[][];\\n\\t \\/\\/static int v[][];\\n\\/\\/\\t static int mod=998244353;;\\n\\t static int mod=1000000007;\\n\\t static int max;\\n\\t static int bit[];\\n\\t \\/\\/static long fact[];\\n\\/\\/\\t static long A[];\\n\\t static TreeMap<Integer,Integer> map;\\n\\t \\/\\/static StringBuffer sb=new StringBuffer(\\\"\\\");\\n\\t \\/\\/static HashMap<Integer,Integer> map;\\n\\t   static PrintWriter out=new PrintWriter(System.out);\\n\\t  public static void main(String[] args)\\n\\t  {\\n\\t\\t \\/\\/  StringBuffer sb=new StringBuffer(\\\"\\\");\\n\\t\\t  int ttt=1;\\n\\t\\t       ttt =i();\\t\\n\\t        outer :while (ttt-- > 0) \\n\\t\\t\\t{\\n\\t        \\tint n=i();\\n\\t        \\tint A[]=input(n);\\n\\t        \\tint B[]=new int[n+1];\\n\\t        \\tfor(int i : A) {\\n\\t        \\t\\tB[i]++;\\n\\t        \\t}\\n\\t        \\tmap=tree(A);\\n\\t        \\tif(B[0]==0) {\\n\\t        \\t\\tout.print(\\\"0 \\\");\\n\\t        \\t\\tfor(int i=1;i<=n;i++) {\\n\\t        \\t\\t\\tout.print(\\\"-1 \\\");\\n\\t        \\t\\t}\\n\\t        \\t\\tout.println();\\n\\t        \\t\\tcontinue outer;\\n\\t        \\t}\\n\\t        \\tint C[]=new int[n+1];\\n\\t        \\tint j=0;\\n\\t        \\tint ind=n+1;\\n\\/\\/\\t        \\tfor(int i=0;i<=n;i++) {\\n\\/\\/\\t        \\t\\tif(B[i]==0) {\\n\\/\\/\\t        \\t\\t\\twhile(j<i && B[j]==0) {\\n\\/\\/\\t        \\t\\t\\t\\tj++;\\n\\/\\/\\t        \\t\\t\\t}\\n\\/\\/\\t        \\t\\t\\tif(j==i) {\\n\\/\\/\\t        \\t\\t\\t\\tind=i;\\n\\/\\/\\t        \\t\\t\\t\\tbreak;\\n\\/\\/\\t        \\t\\t\\t}\\n\\/\\/\\t        \\t\\t\\tC[i]=i-j;\\n\\/\\/\\t        \\t\\t\\tB[j]--;\\n\\/\\/\\t        \\t\\t}\\n\\/\\/\\t        \\t\\telse {\\n\\/\\/\\t        \\t\\t\\tB[i]--;\\n\\/\\/\\t        \\t\\t}\\n\\/\\/\\t        \\t}\\n\\t        \\tfor(int i=0;i<=n;i++) {\\n\\t        \\t\\tif(!map.containsKey(i)) {\\n\\t        \\t\\t\\tInteger y=map.floorKey(i);\\n\\t        \\t\\t\\tif(y==null) {\\n\\t        \\t\\t\\t\\tind=i;\\n\\t        \\t\\t\\t\\tbreak;\\n\\t        \\t\\t\\t}\\n\\t        \\t\\t\\tint z=y;\\n\\t        \\t\\t\\tC[i]=i-z;\\n\\t        \\t\\t\\tremove(y);\\n\\t        \\t\\t}\\n\\t        \\t\\telse {\\n\\t        \\t\\t\\tremove(i);\\n\\t        \\t\\t}\\n\\t        \\t}\\n\\t        \\tlong D[]=new long[n+1];\\n\\t        \\tD[0]=C[0];\\n\\t        \\tfor(int i=1;i<=n;i++) {\\n\\t        \\t\\tD[i]=D[i-1]+C[i];\\n\\t        \\t}\\n\\t        \\tArrays.fill(B, 0);\\n\\t        \\tfor(int i : A) {\\n\\t        \\t\\tB[i]++;\\n\\t        \\t}\\n\\t       ...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You are given an array a of n integers, and another integer k such that 2k \u2264 n.\\n\\nYou have to perform exactly k operations with this array. In one operation, you have to choose two elements of the array (let them be a_i and a_j; they can be equal or different, but their positions in the array must not be the same), remove them from the array, and add \u230a (a_i)\\/(a_j) \u230b to your score, where \u230a x\\/y \u230b is the maximum integer not exceeding x\\/y.\\n\\nInitially, your score is 0. After you perform exactly k operations, you add all the remaining elements of the array to the score.\\n\\nCalculate the minimum possible score you can get.\\n\\nInput\\n\\nThe first line of the input contains one integer t (1 \u2264 t \u2264 500) \u2014 the number of test cases.\\n\\nEach test case consists of two lines. The first line contains two integers n and k (1 \u2264 n \u2264 100; 0 \u2264 k \u2264 \u230a n\\/2 \u230b).\\n\\nThe second line contains n integers a_1, a_2, ..., a_n (1 \u2264 a_i \u2264 2 \u22c5 10^5).\\n\\nOutput\\n\\nPrint one integer \u2014 the minimum possible score you can get.\\n\\nExample\\n\\nInput\\n\\n\\n5\\n7 3\\n1 1 1 2 1 3 1\\n5 1\\n5 5 5 5 5\\n4 2\\n1 3 3 7\\n2 0\\n4 2\\n9 2\\n1 10 10 1 10 2 7 10 3\\n\\n\\nOutput\\n\\n\\n2\\n16\\n0\\n6\\n16\\n\\nNote\\n\\nLet's consider the example test.\\n\\nIn the first test case, one way to obtain a score of 2 is the following one:\\n\\n  1. choose a_7 = 1 and a_4 = 2 for the operation; the score becomes 0 + \u230a 1\\/2 \u230b = 0, the array becomes [1, 1, 1, 1, 3]; \\n  2. choose a_1 = 1 and a_5 = 3 for the operation; the score becomes 0 + \u230a 1\\/3 \u230b = 0, the array becomes [1, 1, 1]; \\n  3. choose a_1 = 1 and a_2 = 1 for the operation; the score becomes 0 + \u230a 1\\/1 \u230b = 1, the array becomes [1]; \\n  4. add the remaining element 1 to the score, so the resulting score is 2. \\n\\n\\n\\nIn the second test case, no matter which operations you choose, the resulting score is 16.\\n\\nIn the third test case, one way to obtain a score of 0 is the following one:\\n\\n  1. choose a_1 = 1 and a_2 = 3 for the operation; the score becomes 0 + \u230a 1\\/3 \u230b = 0, the array becomes [3, 7]; \\n  2. choose a_1 = 3 and a_2 = 7 for the operation; the score becomes 0 + \u230a 3\\/7 \u230b = 0, the array becomes...\\nUsing cpp can you solve the prior task?\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint arr[100];\\nint main() {\\n  ios_base::sync_with_stdio(0);\\n  cin.tie(0), cout.tie(0);\\n  int t;\\n  cin >> t;\\n  for (; t--;) {\\n    int n, k, ans = 0;\\n    cin >> n >> k;\\n    for (int i = 0; i != n; ++i) cin >> arr[i];\\n    sort(arr, arr + n, greater<int>());\\n    for (int i = 0; i != k; ++i) ans += arr[i + k] \\/ arr[i];\\n    for (int i = k << 1; i != n; ++i) ans += arr[i];\\n    cout << ans << '\\\\n';\\n  }\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"During the lunch break all n Berland State University students lined up in the food court. However, it turned out that the food court, too, has a lunch break and it temporarily stopped working.\\n\\nStanding in a queue that isn't being served is so boring! So, each of the students wrote down the number of the student ID of the student that stands in line directly in front of him, and the student that stands in line directly behind him. If no one stands before or after a student (that is, he is the first one or the last one), then he writes down number 0 instead (in Berland State University student IDs are numerated from 1).\\n\\nAfter that, all the students went about their business. When they returned, they found out that restoring the queue is not such an easy task.\\n\\nHelp the students to restore the state of the queue by the numbers of the student ID's of their neighbors in the queue.\\n\\nInput\\n\\nThe first line contains integer n (2 \u2264 n \u2264 2\u00b7105) \u2014 the number of students in the queue. \\n\\nThen n lines follow, i-th line contains the pair of integers ai, bi (0 \u2264 ai, bi \u2264 106), where ai is the ID number of a person in front of a student and bi is the ID number of a person behind a student. The lines are given in the arbitrary order. Value 0 is given instead of a neighbor's ID number if the neighbor doesn't exist.\\n\\nThe ID numbers of all students are distinct. It is guaranteed that the records correspond too the queue where all the students stand in some order.\\n\\nOutput\\n\\nPrint a sequence of n integers x1, x2, ..., xn \u2014 the sequence of ID numbers of all the students in the order they go in the queue from the first student to the last one.\\n\\nExamples\\n\\nInput\\n\\n4\\n92 31\\n0 7\\n31 0\\n7 141\\n\\n\\nOutput\\n\\n92 7 31 141 \\n\\nNote\\n\\nThe picture illustrates the queue for the first sample.\\n\\n<image>\\nUsing python3 can you solve the prior task?\",\"targets\":\"import sys, os, io\\n# input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline\\nn = int(input())\\nd = {}\\nddd = {}\\ndd = {}\\nfor i in range(n):\\n    a, b = map(int, input().split())\\n    d[a] = b\\n    dd[b] =a\\n    if(a in ddd):\\n        ddd.pop(a)\\n    else:\\n        ddd[a] = 1\\n    if(b in ddd):\\n        ddd.pop(b)\\n    else:\\n        ddd[b] = -1\\n\\ntemp = 0\\nind = 1\\na = [0]*n\\nwhile(temp in d):\\n    temp = d[temp]\\n    if(temp == 0):\\n        break\\n    a[ind] = temp\\n    ind+=2\\nif(len(a)&1):\\n    ind = len(a)-1\\n    temp = 0\\n    tempp = 0\\n    for x in ddd:\\n        if(ddd[x] ==-1):\\n            temp = x\\n        else:\\n            tempp = x\\n    # print(temp)\\n    while(temp in dd):\\n        \\n        a[ind] = temp\\n        temp = dd[temp]\\n        ind-=2\\n\\n    a[0] = tempp\\n    \\nelse:\\n    ind = len(a)-2\\n    temp = 0\\n    while(temp in dd):\\n        temp = dd[temp]\\n        if(temp == 0):\\n            break\\n        a[ind] = temp\\n        ind-=2\\n\\nprint(*a)\",\"language\":\"python\",\"split\":\"train\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"Long time ago Alex created an interesting problem about parallelogram. The input data for this problem contained four integer points on the Cartesian plane, that defined the set of vertices of some non-degenerate (positive area) parallelogram. Points not necessary were given in the order of clockwise or counterclockwise traversal.\\n\\nAlex had very nice test for this problem, but is somehow happened that the last line of the input was lost and now he has only three out of four points of the original parallelogram. He remembers that test was so good that he asks you to restore it given only these three points.\\n\\nInput\\n\\nThe input consists of three lines, each containing a pair of integer coordinates xi and yi ( - 1000 \u2264 xi, yi \u2264 1000). It's guaranteed that these three points do not lie on the same line and no two of them coincide.\\n\\nOutput\\n\\nFirst print integer k \u2014 the number of ways to add one new integer point such that the obtained set defines some parallelogram of positive area. There is no requirement for the points to be arranged in any special order (like traversal), they just define the set of vertices.\\n\\nThen print k lines, each containing a pair of integer \u2014 possible coordinates of the fourth point.\\n\\nExample\\n\\nInput\\n\\n0 0\\n1 0\\n0 1\\n\\n\\nOutput\\n\\n3\\n1 -1\\n-1 1\\n1 1\\n\\nNote\\n\\nIf you need clarification of what parallelogram is, please check Wikipedia page:\\n\\nhttps:\\/\\/en.wikipedia.org\\/wiki\\/Parallelogram\\\":\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst int max_n = 100005;\\nset<pair<int, int> > m;\\nint main() {\\n  int x[3];\\n  int y[3];\\n  for (int i = 0; i < 3; i++) {\\n    cin >> x[i] >> y[i];\\n  }\\n  m.insert(make_pair(x[2] + (x[1] - x[0]), y[2] + (y[1] - y[0])));\\n  m.insert(make_pair(x[2] + (x[0] - x[1]), y[2] + (y[0] - y[1])));\\n  m.insert(make_pair(x[1] + (x[0] - x[2]), y[1] + (y[0] - y[2])));\\n  m.insert(make_pair(x[1] + (x[2] - x[0]), y[1] + (y[2] - y[0])));\\n  m.insert(make_pair(x[0] + (x[1] - x[2]), y[0] + (y[1] - y[2])));\\n  m.insert(make_pair(x[0] + (x[2] - x[1]), y[0] + (y[2] - y[1])));\\n  set<pair<int, int> >::iterator it = m.begin();\\n  cout << m.size() << endl;\\n  while (it != m.end()) {\\n    cout << it->first << ' ' << it->second << endl;\\n    it++;\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Berland Music is a music streaming service built specifically to support Berland local artist. Its developers are currently working on a song recommendation module.\\n\\nSo imagine Monocarp got recommended n songs, numbered from 1 to n. The i-th song had its predicted rating equal to p_i, where 1 \u2264 p_i \u2264 n and every integer from 1 to n appears exactly once. In other words, p is a permutation.\\n\\nAfter listening to each of them, Monocarp pressed either a like or a dislike button. Let his vote sequence be represented with a string s, such that s_i=0 means that he disliked the i-th song, and s_i=1 means that he liked it.\\n\\nNow the service has to re-evaluate the song ratings in such a way that:\\n\\n  * the new ratings q_1, q_2, ..., q_n still form a permutation (1 \u2264 q_i \u2264 n; each integer from 1 to n appears exactly once); \\n  * every song that Monocarp liked should have a greater rating than every song that Monocarp disliked (formally, for all i, j such that s_i=1 and s_j=0, q_i>q_j should hold). \\n\\n\\n\\nAmong all valid permutations q find the one that has the smallest value of \u2211_{i=1}^n |p_i-q_i|, where |x| is an absolute value of x.\\n\\nPrint the permutation q_1, q_2, ..., q_n. If there are multiple answers, you can print any of them.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 10^4) \u2014 the number of testcases.\\n\\nThe first line of each testcase contains a single integer n (1 \u2264 n \u2264 2 \u22c5 10^5) \u2014 the number of songs.\\n\\nThe second line of each testcase contains n integers p_1, p_2, ..., p_n (1 \u2264 p_i \u2264 n) \u2014 the permutation of the predicted ratings.\\n\\nThe third line contains a single string s, consisting of n characters. Each character is either a 0 or a 1. 0 means that Monocarp disliked the song, and 1 means that he liked it.\\n\\nThe sum of n over all testcases doesn't exceed 2 \u22c5 10^5.\\n\\nOutput\\n\\nFor each testcase, print a permutation q \u2014 the re-evaluated ratings of the songs. If there are multiple answers such that \u2211_{i=1}^n |p_i-q_i| is minimum possible, you can print any of them.\\n\\nExample\\n\\nInput\\n\\n\\n3\\n2\\n1 2\\n10\\n3\\n3 1 2\\n111\\n8\\n2...\\nThe above is tricky. Write me a correct solution in PYTHON3.\",\"targets\":\"import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time, functools,copy,random\\nfrom functools import reduce \\nimport operator\\n \\n\\ninf = 10**9+7\\nmod = (10**9+7)\\ndef LI(): return [int(x) for x in sys.stdin.readline().split()]\\ndef LF(): return [float(x) for x in sys.stdin.readline().split()]\\ndef I(): return int(sys.stdin.readline())\\ndef F(): return float(sys.stdin.readline())\\ndef S(): return input()\\ndef LS(): return input().split()\\ndef endl(): return print('\\\\n')\\ndef lcm(a,b): return (a*b) \\/\\/ math.gcd(a,b)\\ndef grayCode (n): return n ^ (n >> 1);\\nsys.setrecursionlimit(20000)    # adjust numbers\\ngraph = collections.defaultdict(list)\\ngrid = []\\nvisited = set()\\nways = [\\\"D\\\",\\\"U\\\",\\\"R\\\",\\\"L\\\"]\\ndx =   [1,-1,0,0]\\ndy =   [0,0,1,-1]\\n#0\\ndef find(i) :\\n    if par[i] != i : par[i] = find(par[i]);\\n    return par[i]\\ndef union(a, b) :\\n    a = find(a)\\n    b = find(b)\\n    if a == b : return False\\n    par[a] = b\\n    return True\\n#par = [i for i in range(n)]\\ndef initGraph(m):\\n    for _ in range(m):\\n        u,v = LI()\\n        graph[u-1].append(v-1)\\n        graph[v-1].append(u-1)\\n    return graph\\ndef initGraphW(m):\\n    for _ in range(m):\\n        a,b,c = LI()\\n        graph[a-1].append((b-1,c))\\n        graph[b-1].append((a-1,c))\\n \\ndef initGrid(h,w):\\n    for i in range(h):\\n        s = S()\\n        grid.append(list(s))\\n    return grid\\n \\ndef soe(limit):\\n    a = [True] * limit                          # Initialize the primality list\\n    a[0] = a[1] = False\\n \\n    for (i, isprime) in enumerate(a):\\n        if isprime:\\n            yield i\\n            for n in range(i*i, limit, i):     # Mark factors non-prime\\n                a[n] = False\\n    return a\\n\\n################## Main (Author - 9th) ################## \\n\\nfor _ in range(I()):\\n    n = I()\\n    a = LI()\\n    b = S()\\n    b = [int(i) for i in b]\\n    newA = []\\n    for i in range(n):\\n        newA.append((a[i],b[i],i))\\n    newA.sort()\\n    ans = [0]*n\\n    i = 0\\n    cur = 1\\n    while i < n:\\n        if newA[i][1] == 0:\\n            ans[newA[i][2]] = cur\\n            cur+=1\\n       ...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Casimir has a rectangular piece of paper with a checkered field of size n \u00d7 m. Initially, all cells of the field are white.\\n\\nLet us denote the cell with coordinates i vertically and j horizontally by (i, j). The upper left cell will be referred to as (1, 1) and the lower right cell as (n, m).\\n\\nCasimir draws ticks of different sizes on the field. A tick of size d (d > 0) with its center in cell (i, j) is drawn as follows: \\n\\n  1. First, the center cell (i, j) is painted black. \\n  2. Then exactly d cells on the top-left diagonally to the center and exactly d cells on the top-right diagonally to the center are also painted black. \\n  3. That is all the cells with coordinates (i - h, j \u00b1 h) for all h between 0 and d are painted. In particular, a tick consists of 2d + 1 black cells. \\n\\n\\n\\nAn already painted cell will remain black if painted again. Below you can find an example of the 4 \u00d7 9 box, with two ticks of sizes 2 and 3.\\n\\n<image>\\n\\nYou are given a description of a checkered field of size n \u00d7 m. Casimir claims that this field came about after he drew some (possibly 0) ticks on it. The ticks could be of different sizes, but the size of each tick is at least k (that is, d \u2265 k for all the ticks).\\n\\nDetermine whether this field can indeed be obtained by drawing some (possibly none) ticks of sizes d \u2265 k or not.\\n\\nInput\\n\\nThe first line contains an integer t (1 \u2264 t \u2264 100) \u2014 the number test cases.\\n\\nThe following lines contain the descriptions of the test cases. \\n\\nThe first line of the test case description contains the integers n, m, and k (1 \u2264 k \u2264 n \u2264 10; 1 \u2264 m \u2264 19) \u2014 the field size and the minimum size of the ticks that Casimir drew. The following n lines describe the field: each line consists of m characters either being '.' if the corresponding cell is not yet painted or '*' otherwise.\\n\\nOutput\\n\\nPrint t lines, each line containing the answer to the corresponding test case. The answer to a test case should be YES if the given field can be obtained by drawing ticks of at least the given size and NO otherwise.\\n\\nYou may...\",\"targets\":\"from collections import deque, defaultdict\\nfrom math import sqrt, ceil, factorial, floor, inf, log2, sqrt, gcd\\nimport bisect\\nimport copy\\nfrom itertools import combinations\\nimport sys\\nimport heapq\\ndef get_array(): return list(map(int, sys.stdin.readline().strip().split()))\\ndef get_ints(): return map(int, sys.stdin.readline().strip().split())\\ndef input(): return sys.stdin.readline().strip()\\n\\n\\n# for _ in range(int(input())):\\n#         n=int(input())\\n#         arr=get_array()\\n#         val=[]\\n#         for i in range(len(arr)):\\n#             heapq.heappush(val,[-arr[i],i])\\n#\\n#         ans=[]\\n#         while True:\\n#             if len(val)==1:\\n#                 break\\n#             val1=heapq.heappop(val)\\n#             val2=heapq.heappop(val)\\n#\\n#             if -val1[0]<=0 or -val2[0]<=0:\\n#                 break\\n#             if abs(val1[0])>=abs(val2[0]):\\n#                 for k in range(abs(val2[0])):\\n#                         ans.append([val1[1]+1,val2[1]+1])\\n#                 rem=abs(val1[0])-abs(val2[0])\\n#                 heapq.heappush(val,[-rem,val1[1]])\\n#             else:\\n#                 for k in range(abs(val1[0])):\\n#                         ans.append([val2[1]+1,val1[1]+1])\\n#                 rem=abs(val2[0])-abs(val1[0])\\n#                 heapq.heappush(val,[-rem,val2[1]])\\n#\\n#         print(len(ans))\\n#         for i in range(len(ans)):\\n#             print(*ans[i])\\n#\\n\\n\\nfor _ in range(int(input())):\\n    n,m,k=get_ints()\\n    arr=[]\\n    for i in range(n):\\n        s=input()\\n        arr.append(s)\\n\\n    dp=[[False for i in range(m)]for j in range(n)]\\n\\n    for i in range(n):\\n        for j in range(m):\\n            if arr[i][j]==\\\"*\\\":\\n                p, q = i, j\\n                r, s = i, j\\n                tot=0\\n                while True:\\n                    p-=1\\n                    q-=1\\n                    r-=1\\n                    s+=1\\n                    if p>=0 and r>=0 and q>=0 and s<m and arr[p][q]==\\\"*\\\" and arr[r][s]==\\\"*\\\":\\n                        tot+=1\\n                    else:\\n                        break\\n...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"JAVA solution for \\\"Ezzat has an array of n integers (maybe negative). He wants to split it into two non-empty subsequences a and b, such that every element from the array belongs to exactly one subsequence, and the value of f(a) + f(b) is the maximum possible value, where f(x) is the average of the subsequence x. \\n\\nA sequence x is a subsequence of a sequence y if x can be obtained from y by deletion of several (possibly, zero or all) elements.\\n\\nThe average of a subsequence is the sum of the numbers of this subsequence divided by the size of the subsequence.\\n\\nFor example, the average of [1,5,6] is (1+5+6)\\/3 = 12\\/3 = 4, so f([1,5,6]) = 4.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 10^3)\u2014 the number of test cases. Each test case consists of two lines.\\n\\nThe first line contains a single integer n (2 \u2264 n \u2264 10^5).\\n\\nThe second line contains n integers a_1, a_2, \u2026, a_n (-10^9 \u2264 a_i \u2264 10^9).\\n\\nIt is guaranteed that the sum of n over all test cases does not exceed 3\u22c510^5.\\n\\nOutput\\n\\nFor each test case, print a single value \u2014 the maximum value that Ezzat can achieve.\\n\\nYour answer is considered correct if its absolute or relative error does not exceed 10^{-6}.\\n\\nFormally, let your answer be a, and the jury's answer be b. Your answer is accepted if and only if \\\\frac{|a - b|}{max{(1, |b|)}} \u2264 10^{-6}.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n3\\n3 1 2\\n3\\n-7 -6 -6\\n3\\n2 2 2\\n4\\n17 3 5 -3\\n\\n\\nOutput\\n\\n\\n4.500000000\\n-12.500000000\\n4.000000000\\n18.666666667\\n\\nNote\\n\\nIn the first test case, the array is [3, 1, 2]. These are all the possible ways to split this array: \\n\\n  * a = [3], b = [1,2], so the value of f(a) + f(b) = 3 + 1.5 = 4.5. \\n  * a = [3,1], b = [2], so the value of f(a) + f(b) = 2 + 2 = 4. \\n  * a = [3,2], b = [1], so the value of f(a) + f(b) = 2.5 + 1 = 3.5. \\n\\nTherefore, the maximum possible value 4.5.\\n\\nIn the second test case, the array is [-7, -6, -6]. These are all the possible ways to split this array: \\n\\n  * a = [-7], b = [-6,-6], so the value of f(a) + f(b) = (-7) + (-6) = -13. \\n  * a = [-7,-6], b = [-6], so the value of f(a) + f(b) = (-6.5) + (-6) =...\\\":\",\"targets\":\"import java.util.Scanner;\\n\\npublic class Ezzat_and_Two_Subsequences {\\n\\tpublic static void main (String args[]) {\\n\\t\\tScanner in = new Scanner (System.in);\\n\\t\\tint cases = in.nextInt();\\n\\t\\tin.nextLine();\\n\\t\\tint numbers;\\n\\t\\tString bruh = \\\"\\\";\\n\\t\\t\\n\\t\\tdouble avg= 0.0;\\n\\t\\tfor (int counter = 0; counter < cases; counter++) {\\n\\t\\t\\tint maximum ;\\n\\t\\t\\tnumbers = in.nextInt();\\n\\t\\t\\tin.nextLine();\\n\\t\\t\\tbruh = in.nextLine();\\n\\t\\t\\tString[] transfer = new String [numbers];\\n\\t\\t\\ttransfer = bruh.split(\\\" \\\");\\n\\t\\t\\tint [] cringe = new int [numbers];\\n\\t\\t\\tfor (int transfercounter = 0; transfercounter<numbers;transfercounter++) {\\n\\t\\t\\t\\tcringe [transfercounter] = Integer.parseInt (transfer[transfercounter]);\\n\\t\\t\\t}\\n\\t\\t\\t\\/\\/find largest number\\n\\t\\t\\tmaximum = cringe[0];\\n\\t\\t\\tfor (int maxc = 0; maxc<numbers;maxc++) {\\n\\t\\t\\t\\tif(cringe[maxc]>maximum) {\\n\\t\\t\\t\\t\\tmaximum = cringe[maxc];\\n\\t\\t\\t\\t}\\n\\t\\t\\t}\\n\\t\\t\\t\\/\\/find average of rest of the set\\n\\t\\t\\tfor (int avgc =0; avgc<numbers;avgc++) {\\n\\t\\t\\t\\tavg = avg + (double)(cringe[avgc]);\\n\\t\\t\\t}\\n\\t\\t\\tavg = avg - (double)maximum;\\n\\t\\t\\tavg = avg\\/(double)(numbers-1);\\n\\t\\t\\tSystem.out.println(((double)maximum+avg));\\n\\t\\t\\tmaximum = 0;\\n\\t\\t\\tavg = 0.0;\\n\\t\\t}\\n\\t}\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You are given an array of integers a of length n. The elements of the array can be either different or the same. \\n\\nEach element of the array is colored either blue or red. There are no unpainted elements in the array. One of the two operations described below can be applied to an array in a single step:\\n\\n  * either you can select any blue element and decrease its value by 1; \\n  * or you can select any red element and increase its value by 1. \\n\\n\\n\\nSituations in which there are no elements of some color at all are also possible. For example, if the whole array is colored blue or red, one of the operations becomes unavailable.\\n\\nDetermine whether it is possible to make 0 or more steps such that the resulting array is a permutation of numbers from 1 to n?\\n\\nIn other words, check whether there exists a sequence of steps (possibly empty) such that after applying it, the array a contains in some order all numbers from 1 to n (inclusive), each exactly once.\\n\\nInput\\n\\nThe first line contains an integer t (1 \u2264 t \u2264 10^4) \u2014 the number of input data sets in the test.\\n\\nThe description of each set of input data consists of three lines. The first line contains an integer n (1 \u2264 n \u2264 2 \u22c5 10^5) \u2014 the length of the original array a. The second line contains n integers a_1, a_2, ..., a_n (-10^9 \u2264 a_i \u2264 10^9) \u2014 the array elements themselves.\\n\\nThe third line has length n and consists exclusively of the letters 'B' and\\/or 'R': ith character is 'B' if a_i is colored blue, and is 'R' if colored red.\\n\\nIt is guaranteed that the sum of n over all input sets does not exceed 2 \u22c5 10^5.\\n\\nOutput\\n\\nPrint t lines, each of which contains the answer to the corresponding test case of the input. Print YES as an answer if the corresponding array can be transformed into a permutation, and NO otherwise.\\n\\nYou can print the answer in any case (for example, the strings yEs, yes, Yes, and YES will be recognized as a positive answer).\\n\\nExample\\n\\nInput\\n\\n\\n8\\n4\\n1 2 5 2\\nBRBR\\n2\\n1 1\\nBB\\n5\\n3 1 4 2 5\\nRBRRB\\n5\\n3 1 3 1 3\\nRBRRB\\n5\\n5 1 5 1 5\\nRBRRB\\n4\\n2 2 2 2\\nBRBR\\n2\\n1 -2\\nBR\\n4\\n-2...\\nThe above is tricky. Write me a correct solution in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nvoid fun() {\\n  int_fast32_t n;\\n  cin >> n;\\n  vector<int_fast32_t> a(n);\\n  for (int_fast32_t i = 0; i < n; ++i) cin >> a[i];\\n  string s;\\n  cin >> s;\\n  vector<int_fast32_t> bl, red;\\n  for (int_fast32_t i = 0; i < n; ++i) {\\n    if (s[i] == 'B')\\n      bl.push_back(a[i]);\\n    else\\n      red.push_back(a[i]);\\n  }\\n  int_fast32_t l = bl.size(), r = red.size();\\n  sort(bl.begin(), bl.end());\\n  for (int_fast32_t i = 0; i < l; ++i) {\\n    if (bl[i] < (i + 1)) {\\n      cout << \\\"NO\\\" << '\\\\n';\\n      return;\\n    }\\n  }\\n  sort(red.begin(), red.end());\\n  for (int_fast32_t i = 0; i < r; ++i) {\\n    if (red[i] > (i + 1 + l)) {\\n      cout << \\\"NO\\\" << '\\\\n';\\n      return;\\n    }\\n  }\\n  cout << \\\"YES\\\" << '\\\\n';\\n}\\nint32_t main() {\\n  ios::sync_with_stdio(0);\\n  cin.tie(nullptr);\\n  cout.tie(nullptr);\\n  int_fast32_t t;\\n  cin >> t;\\n  ++t;\\n  while (--t) fun();\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in CPP?\\nThe numbers 1,   2,   ...,   n \u22c5 k are colored with n colors. These colors are indexed by 1,   2,   ...,   n. For each 1 \u2264 i \u2264 n, there are exactly k numbers colored with color i.\\n\\nLet [a,   b] denote the interval of integers between a and b inclusive, that is, the set \\\\\\\\{a,   a + 1,   ...,   b\\\\}. You must choose n intervals [a_1,   b_1],   [a_2,   b_2],   ..., [a_n,   b_n] such that: \\n\\n  * for each 1 \u2264 i \u2264 n, it holds 1 \u2264 a_i < b_i \u2264 n \u22c5 k; \\n  * for each 1 \u2264 i \u2264 n, the numbers a_i and b_i are colored with color i; \\n  * each number 1 \u2264 x \u2264 n \u22c5 k belongs to at most \\\\left\u2308 (n)\\/(k - 1) \\\\right\u2309 intervals. \\n\\n\\n\\nOne can show that such a family of intervals always exists under the given constraints.\\n\\nInput\\n\\nThe first line contains two integers n and k (1 \u2264 n \u2264 100, 2 \u2264 k \u2264 100) \u2014 the number of colors and the number of occurrences of each color.\\n\\nThe second line contains n \u22c5 k integers c_1,   c_2,   ...,   c_{nk} (1 \u2264 c_j \u2264 n), where c_j is the color of number j. It is guaranteed that, for each 1 \u2264 i \u2264 n, it holds c_j = i for exactly k distinct indices j.\\n\\nOutput\\n\\nOutput n lines. The i-th line should contain the two integers a_i and b_i.\\n\\nIf there are multiple valid choices of the intervals, output any.\\n\\nExamples\\n\\nInput\\n\\n\\n4 3\\n2 4 3 1 1 4 2 3 2 1 3 4\\n\\n\\nOutput\\n\\n\\n4 5\\n1 7\\n8 11\\n6 12\\n\\nInput\\n\\n\\n1 2\\n1 1\\n\\n\\nOutput\\n\\n\\n1 2\\n\\n\\nInput\\n\\n\\n3 3\\n3 1 2 3 2 1 2 1 3\\n\\n\\nOutput\\n\\n\\n6 8\\n3 7\\n1 4\\n\\nInput\\n\\n\\n2 3\\n2 1 1 1 2 2\\n\\n\\nOutput\\n\\n\\n2 3\\n5 6\\n\\nNote\\n\\nIn the first sample, each number can be contained in at most \\\\left\u2308 (4)\\/(3 - 1) \\\\right\u2309 = 2 intervals. The output is described by the following picture:\\n\\n<image>\\n\\nIn the second sample, the only interval to be chosen is forced to be [1,   2], and each number is indeed contained in at most \\\\left\u2308 (1)\\/(2 - 1) \\\\right\u2309 = 1 interval.\\n\\nIn the third sample, each number can be contained in at most \\\\left\u2308 (3)\\/(3 - 1) \\\\right\u2309 = 2 intervals. The output is described by the following picture:\\n\\n<image>\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nclass SegTree {\\n  int leftMost, rightMost, toProp, mxVal;\\n  SegTree *lChild, *rChild;\\n\\n public:\\n  SegTree(int left, int right)\\n      : leftMost(left), rightMost(right), toProp(0), mxVal(0) {\\n    if (left != right) {\\n      int mid = (left + right) \\/ 2;\\n      lChild = new SegTree(left, mid);\\n      rChild = new SegTree(mid + 1, right);\\n    } else {\\n      lChild = rChild = NULL;\\n    }\\n  }\\n  int getMax() { return mxVal + toProp; }\\n  void update(int left, int right, int delta = 1) {\\n    if (left > rightMost || right < leftMost)\\n      return;\\n    else if (left <= leftMost && right >= rightMost) {\\n      toProp += delta;\\n      return;\\n    } else {\\n      prop();\\n      lChild->update(left, right, delta);\\n      rChild->update(left, right, delta);\\n      recalc();\\n    }\\n  }\\n  int query(int left, int right) {\\n    if (left > rightMost || right < leftMost)\\n      return -1;\\n    else if (left <= leftMost && right >= rightMost) {\\n      return getMax();\\n    } else {\\n      prop();\\n      return max(lChild->query(left, right), rChild->query(left, right));\\n    }\\n  }\\n  void prop() {\\n    if (lChild) {\\n      lChild->toProp += toProp;\\n      rChild->toProp += toProp;\\n      toProp = 0;\\n    }\\n    recalc();\\n  }\\n  void recalc() {\\n    if (lChild) mxVal = max(lChild->getMax(), rChild->getMax());\\n  }\\n};\\nint main() {\\n  int n, k;\\n  cin >> n >> k;\\n  vector<int> inp(n * k);\\n  for (auto& u : inp) {\\n    cin >> u;\\n    --u;\\n  }\\n  SegTree st(0, n * k - 1);\\n  vector<int> lastSeen(n, -1);\\n  vector<bool> done(n, false);\\n  vector<pair<int, int>> ans(n);\\n  int maxAllowed = (n + k - 2) \\/ (k - 1);\\n  for (int i = 0; i < n * k; i++) {\\n    if (lastSeen[inp[i]] == -1 || done[inp[i]]) {\\n      lastSeen[inp[i]] = i;\\n    } else {\\n      int chk = lastSeen[inp[i]];\\n      int getMost = st.query(chk, i);\\n      if (getMost < maxAllowed) {\\n        st.update(chk, i);\\n        done[inp[i]] = true;\\n        ans[inp[i]] = {chk + 1, i + 1};\\n      } else {\\n        lastSeen[inp[i]] = i;\\n      }\\n    }\\n  }\\n  for (auto u : ans) cout <<...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Alice likes word \\\"nineteen\\\" very much. She has a string s and wants the string to contain as many such words as possible. For that reason she can rearrange the letters of the string.\\n\\nFor example, if she has string \\\"xiineteenppnnnewtnee\\\", she can get string \\\"xnineteenppnineteenw\\\", containing (the occurrences marked) two such words. More formally, word \\\"nineteen\\\" occurs in the string the number of times you can read it starting from some letter of the string. Of course, you shouldn't skip letters.\\n\\nHelp her to find the maximum number of \\\"nineteen\\\"s that she can get in her string.\\n\\nInput\\n\\nThe first line contains a non-empty string s, consisting only of lowercase English letters. The length of string s doesn't exceed 100.\\n\\nOutput\\n\\nPrint a single integer \u2014 the maximum number of \\\"nineteen\\\"s that she can get in her string.\\n\\nExamples\\n\\nInput\\n\\nnniinneetteeeenn\\n\\n\\nOutput\\n\\n2\\n\\nInput\\n\\nnneteenabcnneteenabcnneteenabcnneteenabcnneteenabcii\\n\\n\\nOutput\\n\\n2\\n\\nInput\\n\\nnineteenineteen\\n\\n\\nOutput\\n\\n2\\n\\nimpo\",\"targets\":\"rt java.util.*;\\n\\n\\n\\npublic class Main{\\n\\n\\tpublic static void main(String[] args) {\\n        Scanner in=new Scanner(System.in);\\nString x = in.next();\\nint e=0,n=0,i=0,t=0;\\nfor (int j = 0; j < x.length(); j++) {\\n\\tif(x.charAt(j) == 'e') {e++;}\\n\\telse if(x.charAt(j) == 'n') {n++;}\\n\\telse if(x.charAt(j) == 'i') {i++;}\\n\\telse t++;\\n}\\ne = e\\/3;n = (n-1)\\/2;System.out.println(Math.min(Math.min(e, n), Math.min(i, t)));\\n\\t}\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"A matrix of size n \u00d7 m is called nice, if all rows and columns of the matrix are palindromes. A sequence of integers (a_1, a_2, ... , a_k) is a palindrome, if for any integer i (1 \u2264 i \u2264 k) the equality a_i = a_{k - i + 1} holds.\\n\\nSasha owns a matrix a of size n \u00d7 m. In one operation he can increase or decrease any number in the matrix by one. Sasha wants to make the matrix nice. He is interested what is the minimum number of operations he needs.\\n\\nHelp him!\\n\\nInput\\n\\nThe first line contains a single integer t \u2014 the number of test cases (1 \u2264 t \u2264 10). The t tests follow.\\n\\nThe first line of each test contains two integers n and m (1 \u2264 n, m \u2264 100) \u2014 the size of the matrix.\\n\\nEach of the next n lines contains m integers a_{i, j} (0 \u2264 a_{i, j} \u2264 10^9) \u2014 the elements of the matrix.\\n\\nOutput\\n\\nFor each test output the smallest number of operations required to make the matrix nice.\\n\\nExample\\n\\nInput\\n\\n\\n2\\n4 2\\n4 2\\n2 4\\n4 2\\n2 4\\n3 4\\n1 2 3 4\\n5 6 7 8\\n9 10 11 18\\n\\n\\nOutput\\n\\n\\n8\\n42\\n\\nNote\\n\\nIn the first test case we can, for example, obtain the following nice matrix in 8 operations:\\n    \\n    \\n      \\n    2 2  \\n    4 4  \\n    4 4  \\n    2 2  \\n    \\n\\nIn the second test case we can, for example, obtain the following nice matrix in 42 operations:\\n    \\n    \\n      \\n    5 6 6 5  \\n    6 6 6 6  \\n    5 6 6 5  \\n    \\nUsing python3 can you solve the prior task?\",\"targets\":\"import sys\\nread = lambda: sys.stdin.readline().strip()\\nreadi = lambda: map(int, read().split())\\nfrom collections import *\\nfrom math import ceil\\n\\nfor _ in range(int(read())):\\n    n, m = readi()\\n    mat = []\\n    for i in range(n):\\n        mat.append(list(readi()))\\n    visited = [[0 for _ in range(m)] for _ in range(n)]\\n    vals = [[0 for _ in range(m)] for _ in range(n)]\\n    totalSteps = 0\\n    for i in range(n):\\n        for j in range(m):\\n            if visited[i][j] == -1: continue\\n            x = i\\n            y = j\\n            ox = n - i - 1\\n            oy = m - j - 1\\n            l = sorted([mat[x][y], mat[x][oy], mat[ox][y], mat[ox][oy]])\\n            middleElm = l[2]\\n            cords = [(x, y), (x, oy), (ox, y), (ox, oy)]\\n            for (x, y) in cords:\\n                visited[x][y] = -1\\n                vals[x][y] = -middleElm\\n    for i in range(n):\\n        for j in range(m):\\n            totalSteps += abs(mat[i][j] + vals[i][j])\\n    print(totalSteps)\",\"language\":\"python\",\"split\":\"train\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"One day Nikita found the string containing letters \\\"a\\\" and \\\"b\\\" only. \\n\\nNikita thinks that string is beautiful if it can be cut into 3 strings (possibly empty) without changing the order of the letters, where the 1-st and the 3-rd one contain only letters \\\"a\\\" and the 2-nd contains only letters \\\"b\\\".\\n\\nNikita wants to make the string beautiful by removing some (possibly none) of its characters, but without changing their order. What is the maximum length of the string he can get?\\n\\nInput\\n\\nThe first line contains a non-empty string of length not greater than 5 000 containing only lowercase English letters \\\"a\\\" and \\\"b\\\". \\n\\nOutput\\n\\nPrint a single integer \u2014 the maximum possible size of beautiful string Nikita can get.\\n\\nExamples\\n\\nInput\\n\\nabba\\n\\n\\nOutput\\n\\n4\\n\\nInput\\n\\nbab\\n\\n\\nOutput\\n\\n2\\n\\nNote\\n\\nIt the first sample the string is already beautiful.\\n\\nIn the second sample he needs to delete one of \\\"b\\\" to make it beautiful.\\\":\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nchar p[] = {\\\"Danil\\\"};\\nchar p2[] = {\\\"Olya\\\"};\\nchar p3[] = {\\\"Slava\\\"};\\nchar p4[] = {\\\"Ann\\\"};\\nchar p5[] = {\\\"Nikita\\\"};\\nint cnt;\\nchar s[1000005];\\nint nxt[1000005];\\nint lens, lenp;\\nint d[5003][3];\\nint main() {\\n  scanf(\\\"%s\\\", s);\\n  memset(d, 0, sizeof(d));\\n  if (s[0] == 'a') {\\n    d[0][0] = 1;\\n    d[0][2] = 1;\\n  } else\\n    d[0][1] = 1;\\n  int len = strlen(s);\\n  int res = 1;\\n  for (int i = 1; i < len; i++) {\\n    for (int j = 0; j < i; j++) {\\n      if (s[i] == 'a') {\\n        d[i][0] = max(d[j][0] + 1, d[i][0]);\\n        d[i][2] = max(max(d[j][2] + 1, d[j][1] + 1), d[i][2]);\\n        res = max(res, max(d[i][0], d[i][2]));\\n      } else {\\n        d[i][1] = max(d[i][1], max(d[j][1] + 1, d[j][0] + 1));\\n        res = max(res, d[i][1]);\\n      }\\n    }\\n  }\\n  cout << res << endl;\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Berland Music is a music streaming service built specifically to support Berland local artist. Its developers are currently working on a song recommendation module.\\n\\nSo imagine Monocarp got recommended n songs, numbered from 1 to n. The i-th song had its predicted rating equal to p_i, where 1 \u2264 p_i \u2264 n and every integer from 1 to n appears exactly once. In other words, p is a permutation.\\n\\nAfter listening to each of them, Monocarp pressed either a like or a dislike button. Let his vote sequence be represented with a string s, such that s_i=0 means that he disliked the i-th song, and s_i=1 means that he liked it.\\n\\nNow the service has to re-evaluate the song ratings in such a way that:\\n\\n  * the new ratings q_1, q_2, ..., q_n still form a permutation (1 \u2264 q_i \u2264 n; each integer from 1 to n appears exactly once); \\n  * every song that Monocarp liked should have a greater rating than every song that Monocarp disliked (formally, for all i, j such that s_i=1 and s_j=0, q_i>q_j should hold). \\n\\n\\n\\nAmong all valid permutations q find the one that has the smallest value of \u2211_{i=1}^n |p_i-q_i|, where |x| is an absolute value of x.\\n\\nPrint the permutation q_1, q_2, ..., q_n. If there are multiple answers, you can print any of them.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 10^4) \u2014 the number of testcases.\\n\\nThe first line of each testcase contains a single integer n (1 \u2264 n \u2264 2 \u22c5 10^5) \u2014 the number of songs.\\n\\nThe second line of each testcase contains n integers p_1, p_2, ..., p_n (1 \u2264 p_i \u2264 n) \u2014 the permutation of the predicted ratings.\\n\\nThe third line contains a single string s, consisting of n characters. Each character is either a 0 or a 1. 0 means that Monocarp disliked the song, and 1 means that he liked it.\\n\\nThe sum of n over all testcases doesn't exceed 2 \u22c5 10^5.\\n\\nOutput\\n\\nFor each testcase, print a permutation q \u2014 the re-evaluated ratings of the songs. If there are multiple answers such that \u2211_{i=1}^n |p_i-q_i| is minimum possible, you can print any of them.\\n\\nExample\\n\\nInput\\n\\n\\n3\\n2\\n1 2\\n10\\n3\\n3 1 2\\n111\\n8\\n2...\\nSolve the task in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint s[200005];\\nstruct pp {\\n  int lev;\\n  int loc;\\n} s1[200005], s2[200005];\\nbool cmp(pp &a, pp &b) { return a.lev < b.lev; }\\nint main() {\\n  int t;\\n  cin >> t;\\n  for (int i = 0; i < t; i++) {\\n    int s1h = 0, s2h = 0;\\n    string test;\\n    int n;\\n    cin >> n;\\n    for (int j = 0; j < n; j++) {\\n      cin >> s[j];\\n    }\\n    cin >> test;\\n    for (int p = 0; p < test.length(); p++) {\\n      if (test[p] == '0')\\n        s1[s1h].lev = s[p], s1[s1h++].loc = p;\\n      else\\n        s2[s2h].lev = s[p], s2[s2h++].loc = p;\\n    }\\n    sort(s1, s1 + s1h, cmp);\\n    sort(s2, s2 + s2h, cmp);\\n    for (int j = 0; j < s1h; j++) {\\n      s[s1[j].loc] = j + 1;\\n    }\\n    for (int j = 0; j < s2h; j++) {\\n      s[s2[j].loc] = j + s1h + 1;\\n    }\\n    for (int j = 0; j < n; j++) cout << s[j] << \\\" \\\";\\n    cout << endl;\\n  }\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"A burglar got into a matches warehouse and wants to steal as many matches as possible. In the warehouse there are m containers, in the i-th container there are ai matchboxes, and each matchbox contains bi matches. All the matchboxes are of the same size. The burglar's rucksack can hold n matchboxes exactly. Your task is to find out the maximum amount of matches that a burglar can carry away. He has no time to rearrange matches in the matchboxes, that's why he just chooses not more than n matchboxes so that the total amount of matches in them is maximal.\\n\\nInput\\n\\nThe first line of the input contains integer n (1 \u2264 n \u2264 2\u00b7108) and integer m (1 \u2264 m \u2264 20). The i + 1-th line contains a pair of numbers ai and bi (1 \u2264 ai \u2264 108, 1 \u2264 bi \u2264 10). All the input numbers are integer.\\n\\nOutput\\n\\nOutput the only number \u2014 answer to the problem.\\n\\nExamples\\n\\nInput\\n\\n7 3\\n5 10\\n2 5\\n3 6\\n\\n\\nOutput\\n\\n62\\n\\n\\nInput\\n\\n3 3\\n1 3\\n2 2\\n3 1\\n\\n\\nOutput\\n\\n7\\nimpor\",\"targets\":\"t sys\\n\\ndef main(n, containers):\\n    containers.sort(key=lambda x: x[1], reverse=True)\\n    s = 0\\n    for e, cont in enumerate(containers):\\n        num, per_num = cont\\n        if num < n:\\n            n -= num\\n            s += num * per_num\\n        else:\\n            # Can't take all, but can take sum.\\n            s += n * per_num\\n\\n            # No more n left.\\n            break\\n    print(s)\\n\\n\\nif __name__ == \\\"__main__\\\":\\n    cases = []\\n    for e, line in enumerate(sys.stdin.readlines()):\\n        if e == 0:\\n            n, _ = map(int, line.strip().split())\\n            continue\\n        cases.append(list(map(int, line.strip().split())))\\n    main(n, cases)\",\"language\":\"python\",\"split\":\"train\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"A binary string is a string that consists of characters 0 and 1.\\n\\nLet \\\\operatorname{MEX} of a binary string be the smallest digit among 0, 1, or 2 that does not occur in the string. For example, \\\\operatorname{MEX} of 001011 is 2, because 0 and 1 occur in the string at least once, \\\\operatorname{MEX} of 1111 is 0, because 0 and 2 do not occur in the string and 0 < 2.\\n\\nA binary string s is given. You should cut it into any number of substrings such that each character is in exactly one substring. It is possible to cut the string into a single substring \u2014 the whole string.\\n\\nA string a is a substring of a string b if a can be obtained from b by deletion of several (possibly, zero or all) characters from the beginning and several (possibly, zero or all) characters from the end.\\n\\nWhat is the minimal sum of \\\\operatorname{MEX} of all substrings pieces can be?\\n\\nInput\\n\\nThe input consists of multiple test cases. The first line contains a single integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases. Description of the test cases follows.\\n\\nEach test case contains a single binary string s (1 \u2264 |s| \u2264 10^5).\\n\\nIt's guaranteed that the sum of lengths of s over all test cases does not exceed 10^5.\\n\\nOutput\\n\\nFor each test case print a single integer \u2014 the minimal sum of \\\\operatorname{MEX} of all substrings that it is possible to get by cutting s optimally.\\n\\nExample\\n\\nInput\\n\\n\\n6\\n01\\n1111\\n01100\\n101\\n0000\\n01010\\n\\n\\nOutput\\n\\n\\n1\\n0\\n2\\n1\\n1\\n2\\n\\nNote\\n\\nIn the first test case the minimal sum is \\\\operatorname{MEX}(0) + \\\\operatorname{MEX}(1) = 1 + 0 = 1.\\n\\nIn the second test case the minimal sum is \\\\operatorname{MEX}(1111) = 0.\\n\\nIn the third test case the minimal sum is \\\\operatorname{MEX}(01100) = 2.\\n\\nimpo\",\"targets\":\"rt java.util.*;\\npublic class Main{\\n\\tpublic static void main(String[] args){\\n\\t\\tScanner sc = new Scanner(System.in);\\n\\t\\tint t = sc.nextInt();\\n\\t\\twhile(t-- > 0){\\n\\t\\t    String s = sc.next();\\n\\t\\t    int n = s.length();\\n\\t\\t    int arr[] = new int[2];\\n\\t\\t    for(char ch : s.toCharArray()) {\\n\\t\\t        if(ch == '1'){\\n\\t\\t            arr[1]++;\\n\\t\\t        }\\n\\t\\t        else{\\n\\t\\t            arr[0]++;\\n\\t\\t        }\\n\\t\\t    }\\n\\t\\t    int min = 2;\\n\\t\\t    if(arr[0] == 0){\\n\\t\\t        min = 0;\\n\\t\\t    }\\n\\t\\t    else {\\n\\t\\t        int i= 0;\\n\\t\\t        while(i<n && s.charAt(i)!='0') {\\n\\t\\t            i++;\\n\\t\\t        }\\n\\t\\t        int count = 0;\\n\\t\\t        while(i<n && s.charAt(i)=='0'){\\n\\t\\t            count++;\\n\\t\\t            i++;\\n\\t\\t        }\\n\\t\\t        \\n\\t\\t        if(count == arr[0]){\\n\\t\\t            min=1;\\n\\t\\t        }\\n\\t\\t    }\\n\\t\\t     System.out.println(min);\\n\\t\\t    }\\n\\t\\t   \\n\\t        \\n\\t}\\n\\t\\n\\t\\n\\n\\n\\t\\t\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Blake is a CEO of a large company called \\\"Blake Technologies\\\". He loves his company very much and he thinks that his company should be the best. That is why every candidate needs to pass through the interview that consists of the following problem.\\n\\nWe define function f(x, l, r) as a bitwise OR of integers xl, xl + 1, ..., xr, where xi is the i-th element of the array x. You are given two arrays a and b of length n. You need to determine the maximum value of sum f(a, l, r) + f(b, l, r) among all possible 1 \u2264 l \u2264 r \u2264 n.\\n\\n<image>\\n\\nInput\\n\\nThe first line of the input contains a single integer n (1 \u2264 n \u2264 1000) \u2014 the length of the arrays.\\n\\nThe second line contains n integers ai (0 \u2264 ai \u2264 109).\\n\\nThe third line contains n integers bi (0 \u2264 bi \u2264 109).\\n\\nOutput\\n\\nPrint a single integer \u2014 the maximum value of sum f(a, l, r) + f(b, l, r) among all possible 1 \u2264 l \u2264 r \u2264 n.\\n\\nExamples\\n\\nInput\\n\\n5\\n1 2 4 3 2\\n2 3 3 12 1\\n\\n\\nOutput\\n\\n22\\n\\nInput\\n\\n10\\n13 2 7 11 8 4 9 8 5 1\\n5 7 18 9 2 3 0 11 8 6\\n\\n\\nOutput\\n\\n46\\n\\nNote\\n\\nBitwise OR of two non-negative integers a and b is the number c = a OR b, such that each of its digits in binary notation is 1 if and only if at least one of a or b have 1 in the corresponding position in binary notation.\\n\\nIn the first sample, one of the optimal answers is l = 2 and r = 4, because f(a, 2, 4) + f(b, 2, 4) = (2 OR 4 OR 3) + (3 OR 3 OR 12) = 7 + 15 = 22. Other ways to get maximum value is to choose l = 1 and r = 4, l = 1 and r = 5, l = 2 and r = 4, l = 2 and r = 5, l = 3 and r = 4, or l = 3 and r = 5.\\n\\nIn the second sample, the maximum value is obtained for l = 1 and r = 9.\\nSolve the task in JAVA.\",\"targets\":\"import java.util.Scanner;\\n\\npublic class Interview {\\n\\n    public static void main(String[] args) {\\n\\n        Scanner in = new Scanner(System.in);\\n        int n = Integer.parseInt(in.nextLine());\\n        int sumA = 0;\\n        int sumB = 0;\\n        for (int i = 0; i < n; i++) {\\n            sumA = sumA | in.nextInt();\\n        }\\n        for (int i = 0; i < n; i++) {\\n            sumB = sumB | in.nextInt();\\n        }\\n        System.out.println(sumA + sumB);\\n    }\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Alas, finding one's true love is not easy. Masha has been unsuccessful in that yet. Her friend Dasha told Masha about a way to determine the phone number of one's Prince Charming through arithmancy. \\n\\nThe phone number is divined like that. First one needs to write down one's own phone numbers. For example, let's suppose that Masha's phone number is 12345. After that one should write her favorite digit from 0 to 9 under the first digit of her number. That will be the first digit of the needed number. For example, Masha's favorite digit is 9. The second digit is determined as a half sum of the second digit of Masha's number and the already written down first digit from her beloved one's number. In this case the arithmetic average equals to (2 + 9) \\/ 2 = 5.5. Masha can round the number up or down, depending on her wishes. For example, she chooses the digit 5. Having written down the resulting digit under the second digit of her number, Masha moves to finding the third digit in the same way, i.e. finding the half sum the the third digit of her number and the second digit of the new number. The result is (5 + 3) \\/ 2 = 4. In this case the answer is unique. Thus, every i-th digit is determined as an arithmetic average of the i-th digit of Masha's number and the i - 1-th digit of her true love's number. If needed, the digit can be rounded up or down. For example, Masha can get: \\n\\n12345 95444 Unfortunately, when Masha tried dialing the number, she got disappointed: as it turned out, the number was unavailable or outside the coverage area. But Masha won't give up. Perhaps, she rounded to a wrong digit or chose the first digit badly. That's why she keeps finding more and more new numbers and calling them. Count the number of numbers Masha calls. Masha calls all the possible numbers that can be found by the described means of arithmancy, except for, perhaps, her own one.\\n\\nInput\\n\\nThe first line contains nonempty sequence consisting of digits from 0 to 9 \u2014 Masha's phone number. The sequence length does not exceed...\\nSolve the task in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint main() {\\n  string number;\\n  cin >> number;\\n  int n = (int)number.size();\\n  long long dp[51][10] = {0};\\n  for (int i = (0); i < ((10)); ++i) dp[0][i] = 1;\\n  for (int i = (0); i < ((n - 1)); ++i) {\\n    for (int j = (0); j < ((10)); ++j)\\n      if (dp[i][j]) {\\n        int sum = number[i + 1] - '0' + j;\\n        if (sum % 2 == 0) {\\n          sum \\/= 2;\\n          dp[i + 1][sum] += dp[i][j];\\n        } else {\\n          sum \\/= 2;\\n          dp[i + 1][sum] += dp[i][j];\\n          dp[i + 1][sum + 1] += dp[i][j];\\n        }\\n      }\\n  }\\n  bool mine = true;\\n  for (int i = (1); i < (n); ++i) {\\n    int d1 = number[i] - '0';\\n    int d2 = number[i - 1] - '0';\\n    mine &= ((d1 + d2) \\/ 2 == d1 || (d1 + d2 + 1) \\/ 2 == d1);\\n  }\\n  if (n == 1) mine = true;\\n  long long res = 0;\\n  for (int i = (0); i < ((10)); ++i) res += dp[n - 1][i];\\n  cout << res - mine << \\\"\\\\n\\\";\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Arpa is taking a geometry exam. Here is the last problem of the exam.\\n\\nYou are given three points a, b, c.\\n\\nFind a point and an angle such that if we rotate the page around the point by the angle, the new position of a is the same as the old position of b, and the new position of b is the same as the old position of c.\\n\\nArpa is doubting if the problem has a solution or not (i.e. if there exists a point and an angle satisfying the condition). Help Arpa determine if the question has a solution or not.\\n\\nInput\\n\\nThe only line contains six integers ax, ay, bx, by, cx, cy (|ax|, |ay|, |bx|, |by|, |cx|, |cy| \u2264 109). It's guaranteed that the points are distinct.\\n\\nOutput\\n\\nPrint \\\"Yes\\\" if the problem has a solution, \\\"No\\\" otherwise.\\n\\nYou can print each letter in any case (upper or lower).\\n\\nExamples\\n\\nInput\\n\\n0 1 1 1 1 0\\n\\n\\nOutput\\n\\nYes\\n\\n\\nInput\\n\\n1 1 0 0 1000 1000\\n\\n\\nOutput\\n\\nNo\\n\\nNote\\n\\nIn the first sample test, rotate the page around (0.5, 0.5) by <image>.\\n\\nIn the second sample test, you can't find any solution.\\n\\/**\",\"targets\":\"* Created by Aminul on 9\\/4\\/2017.\\n *\\/\\n\\nimport java.io.*;\\nimport java.util.Arrays;\\nimport java.util.StringTokenizer;\\n\\npublic class CF851B {\\n    public static int index;\\n    public static void main(String[] args)throws Exception {\\n        InputReader in = new InputReader(System.in);\\n        PrintWriter pw = new PrintWriter(new OutputStreamWriter(System.out));\\n        \\/\\/int n = in.nextInt();\\n        P a = new P(in.nextDouble(), in.nextDouble());\\n        P b = new P(in.nextDouble(), in.nextDouble());\\n        P c = new P(in.nextDouble(), in.nextDouble());\\n\\n        P center = findCenter(a, b, c);\\n\\n\\n        if(isNaN(center.x) || isNaN(center.y)) center = findCenter(a, c, b);\\n\\n    \\/\\/    debug(center);\\n\\n        if(isNaN(center.x) || isNaN(center.y)) center = findCenter(b, a, c);\\n\\n     \\/\\/   debug(center);\\n\\n        if(isNaN(center.x) || isNaN(center.y)) center = findCenter(b, c, a);\\n\\n   \\/\\/     debug(center);\\n\\n        if(isNaN(center.x) || isNaN(center.y)) center = findCenter(c, a, b);\\n\\n      \\/\\/  debug(center);\\n\\n        if(isNaN(center.x) || isNaN(center.y)) center = findCenter(c, b, a);\\n\\n      \\/\\/  debug(center);\\n        \\/\\/debug(center.x, center.y, center.x == 0.0\\/0.0, isNaN(center.x)) ;\\n\\n\\n        long d1 = a.distLongSq(b);\\n        long d2 = b.distLongSq(c);\\n       \\/\\/ double d3 = c.distSq(a);\\n\\n        double ang1 = fixAng(getAngle(center, a) - getAngle(center, b));\\n        double ang2 = fixAng( getAngle(center, b) - getAngle(center, c));\\n\\n      \\/\\/  debug(getAngle(center, a), getAngle2(center, a));\\n      \\/\\/  debug(getAngle(center, c), getAngle2(center, c));\\n\\n\\/\\/        debug(center, d1, d2, ang1, ang2, getAngle(center, a), ang1, ang2, getAngle(center,b), getAngle(center, c));\\n\\n        if(!isNaN(center.x) && !isNaN(center.y) && Math.abs(d1 - d2) <= EPS && Math.abs(ang1 - ang2) <= EPS ) pw.println(\\\"YES\\\");\\n        else pw.println(\\\"NO\\\");\\n\\n\\n        pw.close();\\n    }\\n\\n    static double fixAng(double a){\\n        if( a < 0){\\n            return 360+a;\\n        }\\n        return a;\\n    }\\n\\n    static public boolean isNaN(double v) {\\n   ...\",\"language\":\"python\",\"split\":\"train\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Theofanis has a string s_1 s_2 ... s_n and a character c. He wants to make all characters of the string equal to c using the minimum number of operations.\\n\\nIn one operation he can choose a number x (1 \u2264 x \u2264 n) and for every position i, where i is not divisible by x, replace s_i with c. \\n\\nFind the minimum number of operations required to make all the characters equal to c and the x-s that he should use in his operations.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases.\\n\\nThe first line of each test case contains the integer n (3 \u2264 n \u2264 3 \u22c5 10^5) and a lowercase Latin letter c \u2014 the length of the string s and the character the resulting string should consist of.\\n\\nThe second line of each test case contains a string s of lowercase Latin letters \u2014 the initial string.\\n\\nIt is guaranteed that the sum of n over all test cases does not exceed 3 \u22c5 10^5.\\n\\nOutput\\n\\nFor each test case, firstly print one integer m \u2014 the minimum number of operations required to make all the characters equal to c.\\n\\nNext, print m integers x_1, x_2, ..., x_m (1 \u2264 x_j \u2264 n) \u2014 the x-s that should be used in the order they are given.\\n\\nIt can be proved that under given constraints, an answer always exists. If there are multiple answers, print any.\\n\\nExample\\n\\nInput\\n\\n\\n3\\n4 a\\naaaa\\n4 a\\nbaaa\\n4 b\\nbzyx\\n\\n\\nOutput\\n\\n\\n0\\n1\\n2\\n2 \\n2 3\\n\\nNote\\n\\nLet's describe what happens in the third test case: \\n\\n  1. x_1 = 2: we choose all positions that are not divisible by 2 and replace them, i. e. bzyx \u2192 bzbx; \\n  2. x_2 = 3: we choose all positions that are not divisible by 3 and replace them, i. e. bzbx \u2192 bbbb. \\nimpor\",\"targets\":\"t java.util.ArrayList;\\nimport java.util.Collections;\\nimport java.util.HashMap;\\nimport java.util.HashSet;\\nimport java.util.PriorityQueue;\\nimport java.util.StringTokenizer;\\n\\n\\nimport java.io.*;\\n \\npublic class cf745 {\\n\\t\\n\\tprivate static class MyScanner {\\n\\t    BufferedReader br;\\n\\t    StringTokenizer st;\\n \\n\\t    public MyScanner() {\\n\\t       br = new BufferedReader(new InputStreamReader(System.in));\\n\\t    }\\n \\n\\t    String next() {\\n\\t        while (st == null || !st.hasMoreElements()) {\\n\\t            try {\\n\\t                st = new StringTokenizer(br.readLine());\\n\\t            } catch (IOException e) {\\n\\t                e.printStackTrace();\\n\\t            }\\n\\t        }\\n\\t        return st.nextToken();\\n\\t    }\\n \\n\\t    int nextInt() {\\n\\t        return Integer.parseInt(next());\\n\\t    }\\n \\n\\t    long nextLong() {\\n\\t        return Long.parseLong(next());\\n\\t    }\\n \\n\\t    double nextDouble() {\\n\\t        return Double.parseDouble(next());\\n\\t    }\\n \\n\\t    String nextLine(){\\n\\t        String str = \\\"\\\";\\n\\t\\t  try {\\n\\t\\t     str = br.readLine();\\n\\t\\t  } catch (IOException e) {\\n\\t\\t     e.printStackTrace();\\n\\t\\t  }\\n\\t\\t  return str;\\n\\t    }\\n \\n\\t }\\n\\t\\n\\/\\/\\n\\/\\/    public static int find(int[][] sq, int i, int j, int a, int b) {\\n\\/\\/\\t\\n\\/\\/\\tint x = sq[a][b];\\n\\/\\/\\tif(i-1>=0)\\n\\/\\/\\t\\tx-=sq[i-1][b];\\n\\/\\/\\tif(j-1>=0)\\n\\/\\/\\t\\tx-=sq[a][j-1];\\n\\/\\/\\tif(i-1>=0 && j-1>=0)\\n\\/\\/\\t\\tx+=sq[i-1][j-1];\\n\\/\\/\\treturn x;\\n\\/\\/\\t\\n\\/\\/    }\\n\\/\\/\\t\\n\\t\\n\\/\\/\\tint[][] sq = new int[n][m];\\n\\/\\/\\t\\n\\/\\/\\tfor(int i = 0; i<n; i++)\\n\\/\\/\\t{\\n\\/\\/\\t\\tfor(int j = 0; j<m; j++)\\n\\/\\/\\t\\t{  \\n\\/\\/\\t\\t\\tif(i-1>=0)\\n\\/\\/\\t\\t\\t\\tsq[i][j]+=sq[i-1][j];\\n\\/\\/\\t\\t\\t\\n\\/\\/\\t\\t\\tif(j-1>=0)\\n\\/\\/\\t\\t\\t\\tsq[i][j]+=sq[i][j-1];\\n\\/\\/\\t\\t\\t\\n\\/\\/\\t\\t\\tif(i-1>=0 && j-1>=0)\\n\\/\\/\\t\\t\\t\\t   sq[i][j]-=sq[i-1][j-1];\\t\\n\\/\\/\\n\\/\\/\\t\\t\\tif(arr[i][j]==1)\\n\\/\\/\\t\\t\\t\\tsq[i][j]++;\\n\\/\\/\\t\\t\\t\\n\\/\\/\\t\\t}\\n\\/\\/\\t}\\n\\t\\n\\t private static class Pair implements Comparable<Pair> {\\n\\t\\t\\t\\n\\t\\t\\tint x;\\n\\t\\t\\tint y;\\n\\t\\t\\n\\t\\t\\tPair(int x, int y)\\n\\t\\t\\t{\\n\\t\\t\\t\\tthis.x = x;\\n\\t\\t\\t\\tthis.y = y;\\n\\t\\t\\t}\\n\\t\\t\\t\\n\\t\\t\\tpublic int compareTo(Pair p)\\t\\n\\t\\t\\t{\\n\\t\\t\\t\\treturn ((Integer)this.x).compareTo(p.x);\\n\\t\\t\\t}\\n\\t\\t\\t\\n\\t\\t}\\n\\t\\n\\t\\n\\tpublic static void solution(int n, String c, String st)\\n\\t{\\t\\n\\t\\tHashSet<Integer> change = new HashSet<>();\\n\\t\\tint last...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"Frodo was caught by Saruman. He tore a pouch from Frodo's neck, shook out its contents \u2014there was a pile of different rings: gold and silver...\\n\\n\\\"How am I to tell which is the One?!\\\" the mage howled.\\n\\n\\\"Throw them one by one into the Cracks of Doom and watch when Mordor falls!\\\" \\n\\nSomewhere in a parallel Middle-earth, when Saruman caught Frodo, he only found n rings. And the i-th ring was either gold or silver. For convenience Saruman wrote down a binary string s of n characters, where the i-th character was 0 if the i-th ring was gold, and 1 if it was silver.\\n\\nSaruman has a magic function f, which takes a binary string and returns a number obtained by converting the string into a binary number and then converting the binary number into a decimal number. For example, f(001010) = 10, f(111) = 7, f(11011101) = 221.\\n\\nSaruman, however, thinks that the order of the rings plays some important role. He wants to find 2 pairs of integers (l_1, r_1), (l_2, r_2), such that:\\n\\n  * 1 \u2264 l_1 \u2264 n, 1 \u2264 r_1 \u2264 n, r_1-l_1+1\u2265 \u230a n\\/2 \u230b \\n  * 1 \u2264 l_2 \u2264 n, 1 \u2264 r_2 \u2264 n, r_2-l_2+1\u2265 \u230a n\\/2 \u230b \\n  * Pairs (l_1, r_1) and (l_2, r_2) are distinct. That is, at least one of l_1 \u2260 l_2 and r_1 \u2260 r_2 must hold.\\n  * Let t be the substring s[l_1:r_1] of s, and w be the substring s[l_2:r_2] of s. Then there exists non-negative integer k, such that f(t) = f(w) \u22c5 k.\\n\\n\\n\\nHere substring s[l:r] denotes s_ls_{l+1}\u2026 s_{r-1}s_r, and \u230a x \u230b denotes rounding the number down to the nearest integer.\\n\\nHelp Saruman solve this problem! It is guaranteed that under the constraints of the problem at least one solution exists.\\n\\nInput\\n\\nEach test contains multiple test cases.\\n\\nThe first line contains one positive integer t (1 \u2264 t \u2264 10^3), denoting the number of test cases. Description of the test cases follows.\\n\\nThe first line of each test case contains one positive integer n (2 \u2264 n \u2264 2 \u22c5 10^4) \u2014 length of the string.\\n\\nThe second line of each test case contains a non-empty binary string of length n.\\n\\nIt is guaranteed that the sum of n over all test cases does not exceed...\\\":\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nvoid solve();\\nint main() {\\n  ios_base::sync_with_stdio(false);\\n  cin.tie(NULL);\\n  int t = 1;\\n  cin >> t;\\n  while (t--) solve();\\n}\\nvoid solve() {\\n  int n;\\n  cin >> n;\\n  string s;\\n  cin >> s;\\n  int ind = -1;\\n  for (int i = 0; i < n; ++i) {\\n    if (s[i] == '0') {\\n      ind = i;\\n      break;\\n    }\\n  }\\n  if (ind != -1 and ind <= (n \\/ 2 - 1)) {\\n    cout << ind + 2 << \\\" \\\" << n << \\\" \\\" << ind + 1 << \\\" \\\" << n << \\\"\\\\n\\\";\\n  } else if (ind != -1) {\\n    cout << 1 << \\\" \\\" << ind + 1 << \\\" \\\" << 1 << \\\" \\\" << ind << \\\"\\\\n\\\";\\n  } else {\\n    cout << 1 << \\\" \\\" << (n) \\/ 2 << \\\" \\\" << (n + 1) \\/ 2 + 1 << \\\" \\\" << n << \\\"\\\\n\\\";\\n  }\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Lord Omkar would like to have a tree with n nodes (3 \u2264 n \u2264 10^5) and has asked his disciples to construct the tree. However, Lord Omkar has created m (1 \u2264 m < n) restrictions to ensure that the tree will be as heavenly as possible. \\n\\nA tree with n nodes is an connected undirected graph with n nodes and n-1 edges. Note that for any two nodes, there is exactly one simple path between them, where a simple path is a path between two nodes that does not contain any node more than once.\\n\\nHere is an example of a tree: \\n\\n<image>\\n\\nA restriction consists of 3 pairwise distinct integers, a, b, and c (1 \u2264 a,b,c \u2264 n). It signifies that node b cannot lie on the simple path between node a and node c. \\n\\nCan you help Lord Omkar and become his most trusted disciple? You will need to find heavenly trees for multiple sets of restrictions. It can be shown that a heavenly tree will always exist for any set of restrictions under the given constraints.\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 10^4). Description of the test cases follows.\\n\\nThe first line of each test case contains two integers, n and m (3 \u2264 n \u2264 10^5, 1 \u2264 m < n), representing the size of the tree and the number of restrictions.\\n\\nThe i-th of the next m lines contains three integers a_i, b_i, c_i (1 \u2264 a_i, b_i, c_i \u2264 n, a, b, c are distinct), signifying that node b_i cannot lie on the simple path between nodes a_i and c_i. \\n\\nIt is guaranteed that the sum of n across all test cases will not exceed 10^5.\\n\\nOutput\\n\\nFor each test case, output n-1 lines representing the n-1 edges in the tree. On each line, output two integers u and v (1 \u2264 u, v \u2264 n, u \u2260 v) signifying that there is an edge between nodes u and v. Given edges have to form a tree that satisfies Omkar's restrictions.\\n\\nExample\\n\\nInput\\n\\n\\n2\\n7 4\\n1 2 3\\n3 4 5\\n5 6 7\\n6 5 4\\n5 3\\n1 2 3\\n2 3 4\\n3 4 5\\n\\n\\nOutput\\n\\n\\n1 2\\n1 3\\n3 5\\n3 4\\n2 7\\n7 6\\n5 1\\n1 3\\n3 2\\n2 4\\n\\nNote\\n\\nThe output of the first sample case corresponds to the following tree: \\n\\n<image> For the first restriction,...\\nimpor\",\"targets\":\"t java.io.BufferedReader;\\nimport java.io.IOException;\\nimport java.io.InputStreamReader;\\nimport java.io.PrintWriter;\\nimport java.io.FileReader;\\nimport java.util.ArrayList;\\nimport java.util.Arrays;\\nimport java.util.Collections;\\nimport java.util.Map;\\nimport java.util.HashMap;\\nimport java.util.StringTokenizer;\\n \\n \\npublic class Main {\\n  \\n \\n  private static boolean IS_LOCAL=false;\\n  public static void main(String[] args) {\\n    \\n    FastScanner fs=new FastScanner();\\n    PrintWriter out=new PrintWriter(System.out);\\n    \\n    int t = fs.nextInt();\\n    while(t-->0) {\\n      int n = fs.nextInt();\\n      int m = fs.nextInt();\\n\\n      int[][] ret = new int[m][];\\n\\n      int c[] = new int[n];\\n      int x = 0;\\n      for(int i = 0; i < m; i++) {\\n        x = fs.nextInt()-1;\\n        c[fs.nextInt()-1]++;\\n        x = fs.nextInt()-1;\\n      }\\n\\n     int center = -1;\\n     for(int i = 0; i < n; i++) {\\n           if(c[i]==0) {\\n            center = i+1;\\n            break;\\n           }\\n     }\\n\\n\\n     for(int i = 1; i <= n; i++) {\\n      if(i!=center)\\n      out.println(center+\\\" \\\"+i);\\n     }\\n      \\n      \\n    }\\n\\n      \\n \\n    out.close();\\n    \\n  }\\n  \\n  \\n  static void sort(int[] a) {\\n    ArrayList<Integer> l=new ArrayList<>();\\n    for (int i:a) l.add(i);\\n    Collections.sort(l);\\n    for (int i=0; i<a.length; i++) a[i]=l.get(i);\\n  }\\n  \\n  static class FastScanner {\\n    BufferedReader br;\\n     public FastScanner() {\\n       try{\\n                br=IS_LOCAL? (new BufferedReader(new FileReader(\\\"input.txt\\\"))):(new BufferedReader(new InputStreamReader(System.in)));\\n            }\\n            catch(Exception e){\\n              throw new RuntimeException(e);\\n            }\\n     }\\n    StringTokenizer st=new StringTokenizer(\\\"\\\");\\n    String next() {\\n      while (!st.hasMoreTokens())\\n        try {\\n          st=new StringTokenizer(br.readLine());\\n        } catch (IOException e) {\\n          e.printStackTrace();\\n        }\\n      return st.nextToken();\\n    }\\n \\n    String nextLine() \\n    { \\n      String str=\\\"\\\"; \\n      try\\n      { \\n          str=br.readLine(); \\n      } \\n...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"It is a complicated version of problem F1. The difference between them is the constraints (F1: k \u2264 2, F2: k \u2264 10).\\n\\nYou are given an integer n. Find the minimum integer x such that x \u2265 n and the number x is k-beautiful.\\n\\nA number is called k-beautiful if its decimal representation having no leading zeroes contains no more than k different digits. E.g. if k = 2, the numbers 3434443, 55550, 777 and 21 are k-beautiful whereas the numbers 120, 445435 and 998244353 are not.\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases. Then t test cases follow.\\n\\nEach test case consists of one line containing two integers n and k (1 \u2264 n \u2264 10^9, 1 \u2264 k \u2264 10).\\n\\nOutput\\n\\nFor each test case output on a separate line x \u2014 the minimum k-beautiful integer such that x \u2265 n.\\n\\nExample\\n\\nInput\\n\\n\\n6\\n2021 3\\n177890 2\\n34512 3\\n724533 4\\n998244353 1\\n12345678 10\\n\\n\\nOutput\\n\\n\\n2021\\n181111\\n34533\\n724542\\n999999999\\n12345678\",\"targets\":\"import java.beans.VetoableChangeListener;\\nimport java.io.BufferedReader;\\nimport java.io.IOException;\\nimport java.io.InputStream;\\nimport java.io.InputStreamReader;\\nimport java.io.OutputStream;\\nimport java.io.PrintWriter;\\nimport java.util.ArrayList;\\nimport java.util.Arrays;\\nimport java.util.Collections;\\nimport java.util.Comparator;\\nimport java.util.List;\\nimport java.util.Map;\\nimport java.util.StringTokenizer;\\nimport java.util.TreeSet;\\n\\nimport javafx.util.Pair;\\n\\nimport static java.util.Arrays.binarySearch;\\nimport static java.util.Arrays.copyOfRange;\\nimport static java.util.Arrays.fill;\\n\\npublic class Main {\\n\\n    public static void main(String[] args) throws Exception {\\n        InputStream inputStream = System.in;\\n        OutputStream outputStream = System.out;\\n\\n        InputReader in = new InputReader(inputStream);\\n        PrintWriter out = new PrintWriter(outputStream);\\n\\n        Task solver = new Task();\\n        solver.solve(1, in, out);\\n        out.close();\\n    }\\n}\\n\\nclass Task {\\n\\n    long ans = Long.MAX_VALUE;\\n    long inf = Long.MAX_VALUE;\\n    int[] cnt = new int[1 << 10];\\n    int[] min = new int[1 << 10];\\n    long[] pre;\\n\\n    public void solve(int testNumber, InputReader in, PrintWriter out) {\\n        int T = in.nextInt();\\n        init();\\n        for (int tc = 1; tc <= T; tc++) {\\n            ans = Long.MAX_VALUE;\\n            String s = in.next();\\n            int k = in.nextInt();\\n            pre = new long[s.length() + 1];\\n            pre[0] = 0;\\n            for (int i = 0; i < s.length(); i++) {\\n                pre[i + 1] = pre[i] * 10 + s.charAt(i) - '0';\\n            }\\n            cal(s, k, 0, 0, 0);\\n            out.println(ans);\\n        }\\n    }\\n\\n    private void init() {\\n        cnt[0] = 0;\\n        for (int i = 1; i < (1 << 10); i++) {\\n            cnt[i] = cnt[i - (i & -i)] + 1;\\n            for (int j = 0; j <= 9; j++) {\\n                if (((i >> j) & 1) != 0) {\\n                    min[i] = j;\\n                    break;\\n                }\\n            }\\n        }\\n    }\\n\\n    private void cal(String s, int K,...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Capitalization is writing a word with its first letter as a capital letter. Your task is to capitalize the given word.\\n\\nNote, that during capitalization all the letters except the first one remains unchanged.\\n\\nInput\\n\\nA single line contains a non-empty word. This word consists of lowercase and uppercase English letters. The length of the word will not exceed 103.\\n\\nOutput\\n\\nOutput the given word after capitalization.\\n\\nExamples\\n\\nInput\\n\\nApPLe\\n\\n\\nOutput\\n\\nApPLe\\n\\n\\nInput\\n\\nkonjac\\n\\n\\nOutput\\n\\nKonjac\\nSolve the task in PYTHON3.\",\"targets\":\"word = input()\\n\\nprint(word[0].upper() + word[1:])\",\"language\":\"python\",\"split\":\"train\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Let's define S(x) to be the sum of digits of number x written in decimal system. For example, S(5) = 5, S(10) = 1, S(322) = 7.\\n\\nWe will call an integer x interesting if S(x + 1) < S(x). In each test you will be given one integer n. Your task is to calculate the number of integers x such that 1 \u2264 x \u2264 n and x is interesting.\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 1000) \u2014 number of test cases.\\n\\nThen t lines follow, the i-th line contains one integer n (1 \u2264 n \u2264 10^9) for the i-th test case.\\n\\nOutput\\n\\nPrint t integers, the i-th should be the answer for the i-th test case.\\n\\nExample\\n\\nInput\\n\\n\\n5\\n1\\n9\\n10\\n34\\n880055535\\n\\n\\nOutput\\n\\n\\n0\\n1\\n1\\n3\\n88005553\\n\\nNote\\n\\nThe first interesting number is equal to 9.\\nimpor\",\"targets\":\"t sys\\ntesting = len(sys.argv) == 4 and sys.argv[3] == \\\"myTest\\\"\\ninteractive = False\\nif testing:\\n    cmd = sys.stdout\\n    from time import time\\n    start_time = int(round(time() * 1000)) \\n    readAll = open(sys.argv[1], 'r').read\\n    sys.stdout = open(sys.argv[2], 'w')\\nelse:\\n    readAll = sys.stdin.read\\n\\n# ############ ---- I\\/O Functions ---- ############\\n\\nclass InputData:\\n    def __init__(self):\\n        self.lines = readAll().split('\\\\n')\\n        self.n = len(self.lines)\\n        self.ii = -1\\n    def input(self):\\n        self.ii += 1\\n        assert self.ii < self.n\\n        return self.lines[self.ii]\\n\\nflush = sys.stdout.flush\\nif interactive and not testing:\\n    input = sys.stdin.readline\\nelse:\\n    inputData = InputData()\\n    input = inputData.input\\n\\ndef intin():\\n    return(int(input()))\\ndef intlin():\\n    return(list(map(int,input().split())))\\ndef chrin():\\n    return(list(input()))\\ndef strin():\\n    return input()\\ndef lout(l, sep=\\\"\\\\n\\\", toStr=True):\\n    print(sep.join(map(str, l) if toStr else l))\\ndef dout(*args, **kargs):\\n    if not testing: return\\n    if args: print(args[0] if len(args)==1 else args)\\n    if kargs: print([(k,v) for k,v in kargs.items()])\\ndef ask(q):\\n    sys.stdout.write(str(q)+'\\\\n')\\n    flush()\\n    return intin()\\n    \\n# ############ ---- I\\/O Functions ---- ############\\n\\n# from math import ceil\\n# from collections import defaultdict as ddict, Counter\\n# from heapq import *\\n# from Queue import Queue\\n\\ndef main():\\n    n = intin()\\n    return (n+1)\\/10\\n\\nanss = []\\nfor _ in xrange(intin()):\\n    anss.append(main())\\n    # anss.append(\\\"YES\\\" if main() else \\\"NO\\\")\\nlout(anss)\\n\\nif testing:\\n    sys.stdout = cmd\\n    print(int(round(time() * 1000))  - start_time)\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"As the guys fried the radio station facilities, the school principal gave them tasks as a punishment. Dustin's task was to add comments to nginx configuration for school's website. The school has n servers. Each server has a name and an ip (names aren't necessarily unique, but ips are). Dustin knows the ip and name of each server. For simplicity, we'll assume that an nginx command is of form \\\"command ip;\\\" where command is a string consisting of English lowercase letter only, and ip is the ip of one of school servers.\\n\\n<image>\\n\\nEach ip is of form \\\"a.b.c.d\\\" where a, b, c and d are non-negative integers less than or equal to 255 (with no leading zeros). The nginx configuration file Dustin has to add comments to has m commands. Nobody ever memorizes the ips of servers, so to understand the configuration better, Dustin has to comment the name of server that the ip belongs to at the end of each line (after each command). More formally, if a line is \\\"command ip;\\\" Dustin has to replace it with \\\"command ip; #name\\\" where name is the name of the server with ip equal to ip.\\n\\nDustin doesn't know anything about nginx, so he panicked again and his friends asked you to do his task for him.\\n\\nInput\\n\\nThe first line of input contains two integers n and m (1 \u2264 n, m \u2264 1000).\\n\\nThe next n lines contain the names and ips of the servers. Each line contains a string name, name of the server and a string ip, ip of the server, separated by space (1 \u2264 |name| \u2264 10, name only consists of English lowercase letters). It is guaranteed that all ip are distinct.\\n\\nThe next m lines contain the commands in the configuration file. Each line is of form \\\"command ip;\\\" (1 \u2264 |command| \u2264 10, command only consists of English lowercase letters). It is guaranteed that ip belongs to one of the n school servers.\\n\\nOutput\\n\\nPrint m lines, the commands in the configuration file after Dustin did his task.\\n\\nExamples\\n\\nInput\\n\\n2 2\\nmain 192.168.0.2\\nreplica 192.168.0.1\\nblock 192.168.0.1;\\nproxy 192.168.0.2;\\n\\n\\nOutput\\n\\nblock 192.168.0.1; #replica\\nproxy 192.168.0.2;...\\nSolve the task in PYTHON3.\",\"targets\":\"m=[int(j) for j in input().split(' ')]\\na=[]\\nb=[]\\nfor i in range(m[0]):\\n    a.append(input().split(' '))\\nfor i in range(m[1]):\\n    b.append(input().split(' '))\\nfor i in range(m[1]):\\n    for j in range(m[0]):\\n        if b[i][1] == a[j][1]+';':\\n            print(b[i][0],b[i][1],'#'+a[j][0])\\n            break\\n    #print(b)\",\"language\":\"python\",\"split\":\"train\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You have received data from a Bubble bot. You know your task is to make factory facilities, but before you even start, you need to know how big the factory is and how many rooms it has. When you look at the data you see that you have the dimensions of the construction, which is in rectangle shape: N x M. \\n\\nThen in the next N lines you have M numbers. These numbers represent factory tiles and they can go from 0 to 15. Each of these numbers should be looked in its binary form. Because from each number you know on which side the tile has walls. For example number 10 in it's binary form is 1010, which means that it has a wall from the North side, it doesn't have a wall from the East, it has a wall on the South side and it doesn't have a wall on the West side. So it goes North, East, South, West. \\n\\nIt is guaranteed that the construction always has walls on it's edges. The input will be correct. \\n\\nYour task is to print the size of the rooms from biggest to smallest. \\n\\nInput\\n\\nThe first line has two numbers which are N and M, the size of the construction. Both are integers: \\n\\nn (1 \u2264 n \u2264 10^3)\\n\\nm (1 \u2264 m \u2264 10^3)\\n\\nNext N x M numbers represent each tile of construction.\\n\\nOutput\\n\\nOnce you finish processing the data your output consists of one line sorted from biggest to smallest room sizes. \\n\\nExample\\n\\nInput\\n\\n\\n4 5\\n9 14 11 12 13\\n5 15 11 6 7\\n5 9 14 9 14\\n3 2 14 3 14\\n\\n\\nOutput\\n\\n\\n9 4 4 2 1\",\"targets\":\"import java.util.*;\\nimport java.io.*;\\n\\npublic class Rextester {\\n    static final FS sc          = new FS();\\n    static final PrintWriter pw = new PrintWriter(System.out);\\n    static final Util u         = new Util();\\n    \\n    public static void main(String[] args) {\\n        int testCases = 1; \\/\\/ sc.nextInt();\\n        while(testCases-- > 0) {\\n            int n = sc.nextInt();\\n            int m = sc.nextInt();\\n            \\n            int[][] arr = new int[n][m];\\n            for(int i = 0; i<n; i++) {\\n                for(int j = 0; j<m; j++) {\\n                    arr[i][j] = sc.nextInt();\\n                }\\n            }\\n            \\n            List<Integer> ans = new ArrayList<>();\\n            boolean[][] visited = new boolean[n][m];\\n            for(int i = 0; i<n; i++) {\\n                for(int j = 0; j<m; j++) {\\n                    if(!visited[i][j])  ans.add(dfs(i, j, arr, visited, 'x'));\\n                }\\n            }\\n            Collections.sort(ans);\\n            Collections.reverse(ans);\\n            for(int i = 0; i<ans.size(); i++) pw.print(ans.get(i)+\\\" \\\");\\n            pw.println();\\n        }\\n        pw.flush();\\n    }\\n    \\n    static int dfs(int i, int j, int[][] arr, boolean[][] visited, char inComingDir) {\\n        if(visited[i][j]) return 0;\\n        \\n        visited[i][j] = true;\\n        \\n        \\/\\/ if(outOfZone(i,j, arr.length; arr[0].length)) no need given in question\\n        \\/\\/    return 0;\\n        \\n        if(inComingDir != 'x' && !isOpen(inComingDir, arr[i][j]))\\n            return 0;\\n        \\n        int ans = 1;\\n        if(isOpen('n', arr[i][j])) ans += dfs(i-1, j, arr, visited, 's');\\n        if(isOpen('s', arr[i][j])) ans += dfs(i+1, j, arr, visited, 'n');\\n        if(isOpen('e', arr[i][j])) ans += dfs(i, j+1, arr, visited, 'w');\\n        if(isOpen('w', arr[i][j])) ans += dfs(i, j-1, arr, visited, 'e');\\n        \\n        return ans;\\n    }\\n    \\n        \\n    \\n    static boolean isOpen(char inComingDir, int val) {\\n        int pos = -1;\\n        if(inComingDir == 'n') pos = 4;\\n        if(inComingDir...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"The robot is located on a checkered rectangular board of size n \u00d7 m (n rows, m columns). The rows in the board are numbered from 1 to n from top to bottom, and the columns \u2014 from 1 to m from left to right.\\n\\nThe robot is able to move from the current cell to one of the four cells adjacent by side.\\n\\nThe sequence of commands s executed by the robot is given. Each command is denoted by one of the symbols 'L', 'R', 'D' or 'U', and triggers the movement to left, right, down or up, respectively.\\n\\nThe robot can start its movement in any cell. The robot executes the commands starting from the first one, strictly in the order in which they are listed in s. If the robot moves beyond the edge of the board, it falls and breaks. A command that causes the robot to break is not considered successfully executed.\\n\\nThe robot's task is to execute as many commands as possible without falling off the board. For example, on board 3 \u00d7 3, if the robot starts a sequence of actions s=\\\"RRDLUU\\\" (\\\"right\\\", \\\"right\\\", \\\"down\\\", \\\"left\\\", \\\"up\\\", \\\"up\\\") from the central cell, the robot will perform one command, then the next command will force him to cross the edge. If the robot starts moving from the cell (2, 1) (second row, first column) then all commands will be executed successfully and the robot will stop at the cell (1, 2) (first row, second column).\\n\\n<image> The robot starts from cell (2, 1) (second row, first column). It moves right, right, down, left, up, and up. In this case it ends in the cell (1, 2) (first row, second column).\\n\\nDetermine the cell from which the robot should start its movement in order to execute as many commands as possible.\\n\\nInput\\n\\nThe first line contains an integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases.\\n\\nThe next 2t lines contain descriptions of the test cases.\\n\\nIn the description of each test case, the first line contains two integers n and m (1 \u2264 n, m \u2264 10^6) \u2014 the height and width of the field that the robot is located on. The second line of the description is a string s consisting solely of characters 'L',...\\nSolve the task in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst long double pi = acos(-1);\\nint32_t main() {\\n  ios_base::sync_with_stdio(false);\\n  cin.tie(NULL);\\n  long long int t;\\n  cin >> t;\\n  while (t--) {\\n    long long int n, m;\\n    cin >> n >> m;\\n    string s;\\n    cin >> s;\\n    long long int l = s.size();\\n    const long long int inf = 1e18;\\n    long long int h = 0, v = 0;\\n    long long int maxr = 0, maxu = 0, maxl = 0, maxd = 0;\\n    long long int hleeway = 0, vleeway = 0;\\n    long long int startx = 0, starty = 0;\\n    for (long long int i = 0; i < l; i++) {\\n      if (s[i] == 'L')\\n        h--;\\n      else if (s[i] == 'R')\\n        h++;\\n      else if (s[i] == 'U')\\n        v++;\\n      else\\n        v--;\\n      maxr = max(maxr, h);\\n      maxl = min(maxl, h);\\n      maxd = min(maxd, v);\\n      maxu = max(maxu, v);\\n      hleeway = max(hleeway, maxr - maxl);\\n      vleeway = max(vleeway, maxu - maxd);\\n      if (hleeway < m && vleeway < n) {\\n        startx = abs(maxl);\\n        starty = abs(maxu);\\n      } else {\\n        cout << starty + 1 << \\\" \\\" << startx + 1 << \\\"\\\\n\\\";\\n        goto done;\\n      }\\n    }\\n    cout << starty + 1 << \\\" \\\" << startx + 1 << \\\"\\\\n\\\";\\n  done:;\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"You are given a book with n chapters.\\n\\nEach chapter has a specified list of other chapters that need to be understood in order to understand this chapter. To understand a chapter, you must read it after you understand every chapter on its required list.\\n\\nCurrently you don't understand any of the chapters. You are going to read the book from the beginning till the end repeatedly until you understand the whole book. Note that if you read a chapter at a moment when you don't understand some of the required chapters, you don't understand this chapter.\\n\\nDetermine how many times you will read the book to understand every chapter, or determine that you will never understand every chapter no matter how many times you read the book.\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 2\u22c510^4).\\n\\nThe first line of each test case contains a single integer n (1 \u2264 n \u2264 2\u22c510^5) \u2014 number of chapters.\\n\\nThen n lines follow. The i-th line begins with an integer k_i (0 \u2264 k_i \u2264 n-1) \u2014 number of chapters required to understand the i-th chapter. Then k_i integers a_{i,1}, a_{i,2}, ..., a_{i, k_i} (1 \u2264 a_{i, j} \u2264 n, a_{i, j} \u2260 i, a_{i, j} \u2260 a_{i, l} for j \u2260 l) follow \u2014 the chapters required to understand the i-th chapter.\\n\\nIt is guaranteed that the sum of n and sum of k_i over all testcases do not exceed 2\u22c510^5.\\n\\nOutput\\n\\nFor each test case, if the entire book can be understood, print how many times you will read it, otherwise print -1.\\n\\nExample\\n\\nInput\\n\\n\\n5\\n4\\n1 2\\n0\\n2 1 4\\n1 2\\n5\\n1 5\\n1 1\\n1 2\\n1 3\\n1 4\\n5\\n0\\n0\\n2 1 2\\n1 2\\n2 2 1\\n4\\n2 2 3\\n0\\n0\\n2 3 2\\n5\\n1 2\\n1 3\\n1 4\\n1 5\\n0\\n\\n\\nOutput\\n\\n\\n2\\n-1\\n1\\n2\\n5\\n\\nNote\\n\\nIn the first example, we will understand chapters \\\\{2, 4\\\\} in the first reading and chapters \\\\{1, 3\\\\} in the second reading of the book.\\n\\nIn the second example, every chapter requires the understanding of some other chapter, so it is impossible to understand the book.\\n\\nIn the third example, every chapter requires only chapters that appear earlier in the book, so we can understand everything in one...\\\":\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nvoid test_case() {\\n  long long n;\\n  cin >> n;\\n  vector<long long> adj[n];\\n  vector<long long> indegree(n);\\n  for (long long v = 0; v < n; v++) {\\n    long long u, k;\\n    cin >> k;\\n    while (k--) {\\n      cin >> u;\\n      u--;\\n      adj[u].push_back(v);\\n      indegree[v]++;\\n    }\\n  }\\n  set<long long> s;\\n  for (long long i = 0; i < n; i++)\\n    if (indegree[i] == 0) s.insert(i);\\n  long long res = 0, cnt = 0;\\n  while (!s.empty()) {\\n    res++;\\n    long long curr = -1;\\n    while (true) {\\n      auto it = s.upper_bound(curr);\\n      if (it == s.end()) break;\\n      curr = *it;\\n      cnt++;\\n      s.erase(it);\\n      for (long long &v : adj[curr]) {\\n        indegree[v]--;\\n        if (indegree[v] == 0) s.insert(v);\\n      }\\n    }\\n  }\\n  cout << (cnt == n ? res : -1) << \\\"\\\\n\\\";\\n}\\nsigned main() {\\n  ios::sync_with_stdio(0);\\n  cin.tie(0);\\n  long long tc;\\n  cin >> tc;\\n  while (tc--) {\\n    test_case();\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CQXYM is counting permutations length of 2n.\\n\\nA permutation is an array consisting of n distinct integers from 1 to n in arbitrary order. For example, [2,3,1,5,4] is a permutation, but [1,2,2] is not a permutation (2 appears twice in the array) and [1,3,4] is also not a permutation (n=3 but there is 4 in the array).\\n\\nA permutation p(length of 2n) will be counted only if the number of i satisfying p_i<p_{i+1} is no less than n. For example:\\n\\n  * Permutation [1, 2, 3, 4] will count, because the number of such i that p_i<p_{i+1} equals 3 (i = 1, i = 2, i = 3).\\n  * Permutation [3, 2, 1, 4] won't count, because the number of such i that p_i<p_{i+1} equals 1 (i = 3). \\n\\n\\n\\nCQXYM wants you to help him to count the number of such permutations modulo 1000000007 (10^9+7).\\n\\nIn addition, [modulo operation](https:\\/\\/en.wikipedia.org\\/wiki\\/Modulo_operation) is to get the remainder. For example:\\n\\n  * 7 mod 3=1, because 7 = 3 \u22c5 2 + 1, \\n  * 15 mod 4=3, because 15 = 4 \u22c5 3 + 3. \\n\\nInput\\n\\nThe input consists of multiple test cases. \\n\\nThe first line contains an integer t (t \u2265 1) \u2014 the number of test cases. The description of the test cases follows.\\n\\nOnly one line of each test case contains an integer n(1 \u2264 n \u2264 10^5).\\n\\nIt is guaranteed that the sum of n over all test cases does not exceed 10^5\\n\\nOutput\\n\\nFor each test case, print the answer in a single line.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n1\\n2\\n9\\n91234\\n\\n\\nOutput\\n\\n\\n1\\n12\\n830455698\\n890287984\\n\\nNote\\n\\nn=1, there is only one permutation that satisfies the condition: [1,2].\\n\\nIn permutation [1,2], p_1<p_2, and there is one i=1 satisfy the condition. Since 1 \u2265 n, this permutation should be counted. In permutation [2,1], p_1>p_2. Because 0<n, this permutation should not be counted.\\n\\nn=2, there are 12 permutations: [1,2,3,4],[1,2,4,3],[1,3,2,4],[1,3,4,2],[1,4,2,3],[2,1,3,4],[2,3,1,4],[2,3,4,1],[2,4,1,3],[3,1,2,4],[3,4,1,2],[4,1,2,3].\\nSolve the task in JAVA.\",\"targets\":\"import java.util.Scanner;\\n \\n\\/**\\n *\\n * @author aliye\\n *\\/\\npublic class Main {\\n \\n    public static void main(String[] args) {\\n        Scanner sc = new Scanner(System.in);\\n        long a = sc.nextLong();\\n        long c = 0, res = 0;\\n        for (int i = 0; i < a; i++) {\\n            long b = sc.nextLong();\\n            c = b * 2;\\n            res = modFact(c);\\n            System.out.println(res);\\n        }\\n    }\\n \\n    static long modFact(long n) {\\n \\n        long result = 1;\\n        for (int i = 3; i <= n; i++) {\\n            result = (result * i) % 1000000007;\\n        }\\n \\n        result = result % 1000000007;\\n \\n        return result;\\n    }\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Despite urging requests of the townspeople, the municipal office cannot afford to improve many of the apparently deficient city amenities under this recession. The city swimming pool is one of the typical examples. It has only two swimming lanes. The Municipal Fitness Agency, under this circumstances, settled usage rules so that the limited facilities can be utilized fully.\\n\\nTwo lanes are to be used for one-way swimming of different directions. Swimmers are requested to start swimming in one of the lanes, from its one end to the other, and then change the lane to swim his\\/her way back. When he or she reaches the original starting end, he\\/she should return to his\\/her initial lane and starts swimming again.\\n\\nEach swimmer has his\\/her own natural constant pace. Swimmers, however, are not permitted to pass other swimmers except at the ends of the pool; as the lanes are not wide enough, that might cause accidents. If a swimmer is blocked by a slower swimmer, he\\/she has to follow the slower swimmer at the slower pace until the end of the lane is reached. Note that the blocking swimmer\u2019s natural pace may be faster than the blocked swimmer; the blocking swimmer might also be blocked by another swimmer ahead, whose natural pace is slower than the blocked swimmer. Blocking would have taken place whether or not a faster swimmer was between them.\\n\\nSwimmers can change their order if they reach the end of the lane simultaneously. They change their order so that ones with faster natural pace swim in front. When a group of two or more swimmers formed by a congestion reaches the end of the lane, they are considered to reach there simultaneously, and thus change their order there.\\n\\nThe number of swimmers, their natural paces in times to swim from one end to the other, and the numbers of laps they plan to swim are given. Note that here one \\\"lap\\\" means swimming from one end to the other and then swimming back to the original end. Your task is to calculate the time required for all the swimmers to finish their plans. All the...\",\"targets\":\"#include<bits\\/stdc++.h>\\nusing namespace std;\\ntypedef pair<int,int> P;\\n\\nint n;\\nP t[50];\\nint id[50];\\n\\nint a[50];\\nint b[50];\\nint c[50];\\nint ans[50];\\n\\nvoid solve(){\\n  \\n  priority_queue< P , vector< P > , greater< P > > Q;\\n  for(int i=0;i<n;i++){\\n    Q.push(P(0,i));\\n  }\\n\\n  while(!Q.empty()){\\n    P p=Q.top();Q.pop();\\n    int x=p.first,y=p.second;\\n    \\/\\/   cout<<x<<' '<<y<<' '<<a[y]<<' '<<b[y]<<' '<<c[y]<<endl;\\n\\n    if(c[y]==t[y].second){\\n      c[y]++;\\n      continue;\\n    }\\n    \\n    int next=x+t[y].first;\\n    for(int i=0;i<n;i++){\\n      if(c[i]>t[i].second)continue;\\n      if(i==y)continue;\\n      if(b[i]!=b[y]){\\n        next=max(next,a[i]);\\n      }\\n    }\\n    a[y]=next;\\n    b[y]=1-b[y];\\n    if(b[y]==0)c[y]++;\\n    \\n    Q.push(P(a[y],y));\\n  }\\n  \\n  for(int i=0;i<n;i++){\\n    ans[id[i]]=a[i];\\n  }\\n}\\n\\nvoid init(){\\n  for(int i=0;i<50;i++){\\n    a[i]=0;\\n    b[i]=0;\\n    c[i]=0;\\n  }\\n}\\n\\nint main(){\\n  while(1){\\n    cin>>n;\\n    if(n==0)break;\\n    init();\\n    for(int i=0;i<n;i++){\\n      cin>>t[i].first>>t[i].second;\\n      id[i]=i;\\n    }\\n    for(int i=n-1;i>0;i--){\\n      for(int j=0;j<i;j++){\\n        if(t[j]>t[j+1]){\\n          swap(t[j],t[j+1]);\\n          swap(id[j],id[j+1]);\\n        }\\n      }\\n    }\\n    solve();\\n    int ANS=0;\\n    for(int i=0;i<n;i++)\\n      ANS=max(ANS,ans[i]);\\n    cout<<ANS<<endl;\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"A group of n alpinists has just reached the foot of the mountain. The initial difficulty of climbing this mountain can be described as an integer d.\\n\\nEach alpinist can be described by two integers s and a, where s is his skill of climbing mountains and a is his neatness.\\n\\nAn alpinist of skill level s is able to climb a mountain of difficulty p only if p \u2264 s. As an alpinist climbs a mountain, they affect the path and thus may change mountain difficulty. Specifically, if an alpinist of neatness a climbs a mountain of difficulty p the difficulty of this mountain becomes max(p, a). \\n\\nAlpinists will climb the mountain one by one. And before the start, they wonder, what is the maximum number of alpinists who will be able to climb the mountain if they choose the right order. As you are the only person in the group who does programming, you are to answer the question.\\n\\nNote that after the order is chosen, each alpinist who can climb the mountain, must climb the mountain at that time. \\n\\nInput\\n\\nThe first line contains two integers n and d (1 \u2264 n \u2264 500 000; 0 \u2264 d \u2264 10^9) \u2014 the number of alpinists and the initial difficulty of the mountain.\\n\\nEach of the next n lines contains two integers s_i and a_i (0 \u2264 s_i, a_i \u2264 10^9) that define the skill of climbing and the neatness of the i-th alpinist.\\n\\nOutput\\n\\nPrint one integer equal to the maximum number of alpinists who can climb the mountain if they choose the right order to do so.\\n\\nExamples\\n\\nInput\\n\\n\\n3 2\\n2 6\\n3 5\\n5 7\\n\\n\\nOutput\\n\\n\\n2\\n\\n\\nInput\\n\\n\\n3 3\\n2 4\\n6 4\\n4 6\\n\\n\\nOutput\\n\\n\\n2\\n\\n\\nInput\\n\\n\\n5 0\\n1 5\\n4 8\\n2 7\\n7 6\\n3 2\\n\\n\\nOutput\\n\\n\\n3\\n\\nNote\\n\\nIn the first example, alpinists 2 and 3 can climb the mountain if they go in this order. There is no other way to achieve the answer of 2.\\n\\nIn the second example, alpinist 1 is not able to climb because of the initial difficulty of the mountain, while alpinists 2 and 3 can go up in any order.\\n\\nIn the third example, the mountain can be climbed by alpinists 5, 3 and 4 in this particular order. There is no other way to achieve optimal answer.\\nThe above is tricky. Write me a correct solution in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst int N = 1e6 + 100;\\nint Tree[4 * N];\\nint Tree1[4 * N];\\nvoid update1(int v, int l, int r, int idx) {\\n  if (l == r) {\\n    Tree1[v]++;\\n    return;\\n  }\\n  if (idx <= (r + l) \\/ 2) {\\n    update1(v * 2, l, (r + l) \\/ 2, idx);\\n  } else {\\n    update1(v * 2 + 1, (r + l) \\/ 2 + 1, r, idx);\\n  }\\n  Tree1[v]++;\\n}\\nint get1(int v, int l, int r, int al, int ar) {\\n  if (al > ar) {\\n    return 0;\\n  }\\n  if (l >= al && r <= ar) {\\n    return Tree1[v];\\n  }\\n  if (l <= ar && r >= al) {\\n    return get1(v * 2, l, (r + l) \\/ 2, al, ar) +\\n           get1(v * 2 + 1, (r + l) \\/ 2 + 1, r, al, ar);\\n  }\\n  return 0;\\n}\\nvoid update(int v, int l, int r, int idx, int x) {\\n  if (l == r) {\\n    Tree[v] = max(Tree[v], x);\\n    return;\\n  }\\n  if (idx <= (r + l) \\/ 2) {\\n    update(v * 2, l, (r + l) \\/ 2, idx, x);\\n  } else {\\n    update(v * 2 + 1, (r + l) \\/ 2 + 1, r, idx, x);\\n  }\\n  Tree[v] = max(Tree[v * 2], Tree[v * 2 + 1]);\\n}\\nint get(int v, int l, int r, int al, int ar) {\\n  if (l >= al && r <= ar) {\\n    return Tree[v];\\n  }\\n  if (l <= ar && r >= al) {\\n    return max(get(v * 2, l, (r + l) \\/ 2, al, ar),\\n               get(v * 2 + 1, (r + l) \\/ 2 + 1, r, al, ar));\\n  }\\n  return 0;\\n}\\nvector<pair<int, int> > vec;\\nvector<int> uniqa;\\nint n, d;\\nint genious() {\\n  fill(Tree1, Tree1 + 4 * (n + 1), 0);\\n  fill(Tree, Tree + 4 * (n + 1), 0);\\n  sort(uniqa.begin(), uniqa.end());\\n  uniqa.resize(unique(uniqa.begin(), uniqa.end()) - uniqa.begin());\\n  n = (int)uniqa.size() + 1;\\n  vector<vector<int> > a_vec((int)uniqa.size() + 1);\\n  for (int i = 0; i < (int)vec.size(); i++) {\\n    int j =\\n        upper_bound(uniqa.begin(), uniqa.end(), vec[i].first) - uniqa.begin();\\n    a_vec[j].push_back(vec[i].second);\\n  }\\n  vector<vector<int> > adds(n);\\n  for (int i = 0; i < n; i++) {\\n    sort(a_vec[i].begin(), a_vec[i].end());\\n    for (auto a : a_vec[i]) {\\n      int j = lower_bound(uniqa.begin(), uniqa.end(), a) - uniqa.begin();\\n      adds[j + 1].push_back(i);\\n    }\\n  }\\n  int ans1 = 0;\\n  for (int i = 0; i < n; i++) {\\n    for (auto v : adds[i]) {\\n     ...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Alice guesses the strings that Bob made for her.\\n\\nAt first, Bob came up with the secret string a consisting of lowercase English letters. The string a has a length of 2 or more characters. Then, from string a he builds a new string b and offers Alice the string b so that she can guess the string a.\\n\\nBob builds b from a as follows: he writes all the substrings of length 2 of the string a in the order from left to right, and then joins them in the same order into the string b.\\n\\nFor example, if Bob came up with the string a=\\\"abac\\\", then all the substrings of length 2 of the string a are: \\\"ab\\\", \\\"ba\\\", \\\"ac\\\". Therefore, the string b=\\\"abbaac\\\".\\n\\nYou are given the string b. Help Alice to guess the string a that Bob came up with. It is guaranteed that b was built according to the algorithm given above. It can be proved that the answer to the problem is unique.\\n\\nInput\\n\\nThe first line contains a single positive integer t (1 \u2264 t \u2264 1000) \u2014 the number of test cases in the test. Then t test cases follow.\\n\\nEach test case consists of one line in which the string b is written, consisting of lowercase English letters (2 \u2264 |b| \u2264 100) \u2014 the string Bob came up with, where |b| is the length of the string b. It is guaranteed that b was built according to the algorithm given above.\\n\\nOutput\\n\\nOutput t answers to test cases. Each answer is the secret string a, consisting of lowercase English letters, that Bob came up with.\\n\\nExample\\n\\nInput\\n\\n\\n4\\nabbaac\\nac\\nbccddaaf\\nzzzzzzzzzz\\n\\n\\nOutput\\n\\n\\nabac\\nac\\nbcdaf\\nzzzzzz\\n\\nNote\\n\\nThe first test case is explained in the statement.\\n\\nIn the second test case, Bob came up with the string a=\\\"ac\\\", the string a has a length 2, so the string b is equal to the string a.\\n\\nIn the third test case, Bob came up with the string a=\\\"bcdaf\\\", substrings of length 2 of string a are: \\\"bc\\\", \\\"cd\\\", \\\"da\\\", \\\"af\\\", so the string b=\\\"bccddaaf\\\".\\nThe above is tricky. Write me a correct solution in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nusing ll = long long;\\nusing vi = vector<int>;\\nusing vll = vector<long long>;\\nusing vvi = vector<vector<int> >;\\nusing vb = vector<bool>;\\nusing pii = pair<int, int>;\\nconst ll mod = 1e9 + 7;\\ntemplate <typename T>\\nvoid take_input(vector<T> &a, int size) {\\n  T tmp;\\n  for (int i = 0; i < size; i++) {\\n    cin >> tmp;\\n    a.push_back(tmp);\\n  }\\n}\\ntemplate <typename T>\\nvoid print_vector(vector<T> v) {\\n  for (int i = 0; i < v.size(); i++) {\\n    cout << v[i] << \\\" \\\";\\n  }\\n  cout << endl;\\n}\\nint main() {\\n  ios_base::sync_with_stdio(false);\\n  cin.tie(NULL);\\n  cout.tie(NULL);\\n  int t;\\n  cin >> t;\\n  while (t--) {\\n    string b;\\n    cin >> b;\\n    string a;\\n    for (int i = 0; i < b.size(); i++)\\n      if (i % 2 == 1 || i == 0) a.push_back(b[i]);\\n    cout << a << endl;\\n  }\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in PYTHON3?\\n<image>\\n\\nWilliam has an array of n integers a_1, a_2, ..., a_n. In one move he can swap two neighboring items. Two items a_i and a_j are considered neighboring if the condition |i - j| = 1 is satisfied.\\n\\nWilliam wants you to calculate the minimal number of swaps he would need to perform to make it so that the array does not contain two neighboring items with the same parity.\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 10^4). Description of the test cases follows.\\n\\nThe first line of each test case contains an integer n (1 \u2264 n \u2264 10^5) which is the total number of items in William's array.\\n\\nThe second line contains n integers a_1, a_2, ..., a_n (1 \u2264 a_i \u2264 10^9) which are William's array.\\n\\nIt is guaranteed that the sum of n over all test cases does not exceed 10^5.\\n\\nOutput\\n\\nFor each test case output the minimal number of operations needed or -1 if it is impossible to get the array to a state when no neighboring numbers have the same parity.\\n\\nExample\\n\\nInput\\n\\n\\n5\\n3\\n6 6 1\\n1\\n9\\n6\\n1 1 1 2 2 2\\n2\\n8 6\\n6\\n6 2 3 4 5 1\\n\\n\\nOutput\\n\\n\\n1\\n0\\n3\\n-1\\n2\\n\\nNote\\n\\nIn the first test case the following sequence of operations would satisfy the requirements: \\n\\n  1. swap(2, 3). Array after performing the operation: [6, 1, 6] \\n\\n\\n\\nIn the second test case the array initially does not contain two neighboring items of the same parity.\\n\\nIn the third test case the following sequence of operations would satisfy the requirements: \\n\\n  1. swap(3, 4). Array after performing the operation: [1, 1, 2, 1, 2, 2] \\n  2. swap(2, 3). Array after performing the operation: [1, 2, 1, 1, 2, 2] \\n  3. swap(4, 5). Array after performing the operation: [1, 2, 1, 2, 1, 2] \\n\\n\\n\\nIn the fourth test case it is impossible to satisfy the requirements.\\n\\nIn the fifth test case the following sequence of operations would satisfy the requirements: \\n\\n  1. swap(2, 3). Array after performing the operation: [6, 3, 2, 4, 5, 1] \\n  2. swap(4, 5). Array after performing the operation: [6, 3, 2, 5, 4, 1]\",\"targets\":\"import heapq,math\\nfrom collections import defaultdict,deque\\nfrom os import getcwd\\nfrom itertools import permutations\\n#from functools import cmp_to_key\\n\\nimport sys, os.path\\n#sys.setrecursionlimit(10000000)\\n\\nif(os.path.exists('C:\\/Users\\/Dhanush\\/Desktop\\/cp\\/input.txt')):\\n    sys.stdout = open('C:\\/Users\\/Dhanush\\/Desktop\\/cp\\/output.txt', 'w')\\n    sys.stdin = open('C:\\/Users\\/Dhanush\\/Desktop\\/cp\\/input.txt', 'r')\\n\\n#input=sys.stdin.readline\\n\\n\\n\\ndef solve(res):\\n    #convert temp to res\\n    i=0\\n    j=0\\n    f=1\\n    count=0\\n    temp=l[:]\\n    #print(temp,res)\\n    while(i<n and j<n):\\n        \\n        if(res[i]==temp[i]):\\n            #print(\\\"1=\\\",i,j)\\n            i+=1\\n        else:\\n            j=max(j,i)\\n            #print(\\\"2=\\\",i,j,l[i],l[j])\\n            cur=temp[i]\\n            #print(temp)\\n            while(j<n and temp[j]==cur):\\n                j+=1\\n            #print(\\\"3=\\\",i,j)\\n            if(j==n):\\n                #print('done')\\n                return float('inf')\\n            #print(temp)\\n            temp[i]=1-temp[1]\\n            temp[j]=1-temp[j]\\n            #print(temp)\\n            count+=j-i\\n            i+=1\\n    #print(res,count)\\n    return count\\n    \\n   \\ntc=int(input())\\nfor _ in range(tc):\\n    n=int(input())\\n    l1=list(map(int,input().split()))\\n    l=[]\\n    even,odd=0,0\\n    for i in l1:\\n        if(i%2==0):\\n            even+=1\\n            l.append(0)\\n        else:\\n            odd+=1\\n            l.append(1)\\n    if(abs(even-odd)>1):\\n        print(-1)\\n    else:\\n        l1=[]\\n        l2=[]\\n        f=0\\n        for i in range(n):\\n            if(f==0):\\n                l1.append(0)\\n                l2.append(1)\\n            else:\\n                l1.append(1)\\n                l2.append(0)\\n            f=1-f\\n        #print(l1,l2)\\n        print(min(solve(l1),solve(l2)))\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"George decided to prepare a Codesecrof round, so he has prepared m problems for the round. Let's number the problems with integers 1 through m. George estimates the i-th problem's complexity by integer bi.\\n\\nTo make the round good, he needs to put at least n problems there. Besides, he needs to have at least one problem with complexity exactly a1, at least one with complexity exactly a2, ..., and at least one with complexity exactly an. Of course, the round can also have problems with other complexities.\\n\\nGeorge has a poor imagination. It's easier for him to make some already prepared problem simpler than to come up with a new one and prepare it. George is magnificent at simplifying problems. He can simplify any already prepared problem with complexity c to any positive integer complexity d (c \u2265 d), by changing limits on the input data.\\n\\nHowever, nothing is so simple. George understood that even if he simplifies some problems, he can run out of problems for a good round. That's why he decided to find out the minimum number of problems he needs to come up with in addition to the m he's prepared in order to make a good round. Note that George can come up with a new problem of any complexity.\\n\\nInput\\n\\nThe first line contains two integers n and m (1 \u2264 n, m \u2264 3000) \u2014 the minimal number of problems in a good round and the number of problems George's prepared. The second line contains space-separated integers a1, a2, ..., an (1 \u2264 a1 < a2 < ... < an \u2264 106) \u2014 the requirements for the complexity of the problems in a good round. The third line contains space-separated integers b1, b2, ..., bm (1 \u2264 b1 \u2264 b2... \u2264 bm \u2264 106) \u2014 the complexities of the problems prepared by George. \\n\\nOutput\\n\\nPrint a single integer \u2014 the answer to the problem.\\n\\nExamples\\n\\nInput\\n\\n3 5\\n1 2 3\\n1 2 2 3 3\\n\\n\\nOutput\\n\\n0\\n\\n\\nInput\\n\\n3 5\\n1 2 3\\n1 1 1 1 1\\n\\n\\nOutput\\n\\n2\\n\\n\\nInput\\n\\n3 1\\n2 3 4\\n1\\n\\n\\nOutput\\n\\n3\\n\\nNote\\n\\nIn the first sample the set of the prepared problems meets the requirements for a good round.\\n\\nIn the second sample, it is enough to come up with and prepare two...\\\":\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint main() {\\n  int req[3001], pre[3001];\\n  int n, m, sum;\\n  cin >> n >> m;\\n  sum = n;\\n  for (int i = 0; i < n; i++) {\\n    cin >> req[i];\\n  }\\n  for (int i = 0; i < m; i++) {\\n    cin >> pre[i];\\n  }\\n  sort(pre, pre + m);\\n  sort(req, req + n);\\n  int i = 0, j = 0;\\n  while (i < n && j < m) {\\n    if (pre[j] >= req[i]) i++, sum--;\\n    j++;\\n  }\\n  cout << sum << endl;\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in CPP?\\nAlex decided to go on a touristic trip over the country.\\n\\nFor simplicity let's assume that the country has n cities and m bidirectional roads connecting them. Alex lives in city s and initially located in it. To compare different cities Alex assigned each city a score w_i which is as high as interesting city seems to Alex.\\n\\nAlex believes that his trip will be interesting only if he will not use any road twice in a row. That is if Alex came to city v from city u, he may choose as the next city in the trip any city connected with v by the road, except for the city u.\\n\\nYour task is to help Alex plan his city in a way that maximizes total score over all cities he visited. Note that for each city its score is counted at most once, even if Alex been there several times during his trip.\\n\\nInput\\n\\nFirst line of input contains two integers n and m, (1 \u2264 n \u2264 2 \u22c5 10^5, 0 \u2264 m \u2264 2 \u22c5 10^5) which are numbers of cities and roads in the country.\\n\\nSecond line contains n integers w_1, w_2, \u2026, w_n (0 \u2264 w_i \u2264 10^9) which are scores of all cities.\\n\\nThe following m lines contain description of the roads. Each of these m lines contains two integers u and v (1 \u2264 u, v \u2264 n) which are cities connected by this road.\\n\\nIt is guaranteed that there is at most one direct road between any two cities, no city is connected to itself by the road and, finally, it is possible to go from any city to any other one using only roads.\\n\\nThe last line contains single integer s (1 \u2264 s \u2264 n), which is the number of the initial city.\\n\\nOutput\\n\\nOutput single integer which is the maximum possible sum of scores of visited cities.\\n\\nExamples\\n\\nInput\\n\\n\\n5 7\\n2 2 8 6 9\\n1 2\\n1 3\\n2 4\\n3 2\\n4 5\\n2 5\\n1 5\\n2\\n\\n\\nOutput\\n\\n\\n27\\n\\n\\nInput\\n\\n\\n10 12\\n1 7 1 9 3 3 6 30 1 10\\n1 2\\n1 3\\n3 5\\n5 7\\n2 3\\n5 4\\n6 9\\n4 6\\n3 7\\n6 8\\n9 4\\n9 10\\n6\\n\\n\\nOutput\\n\\n\\n61\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst int MAXN = 2e5 + 5;\\nconst int MAXM = 4e5 + 5;\\nstruct Edge {\\n  int to, next;\\n  bool cut;\\n} edge[MAXM];\\nint head[MAXN], tot;\\nint Low[MAXN], DFN[MAXN], Stack[MAXN], Belong[MAXN];\\nint Index, top;\\nint block;\\nbool Instack[MAXN];\\nint bridge;\\nvoid addedge(int u, int v) {\\n  edge[tot].to = v;\\n  edge[tot].next = head[u];\\n  edge[tot].cut = false;\\n  head[u] = tot++;\\n}\\nvoid Tarjan(int u, int pre) {\\n  int v;\\n  bool flag = false;\\n  Low[u] = DFN[u] = ++Index;\\n  Stack[top++] = u;\\n  Instack[u] = true;\\n  for (int i = head[u]; ~i; i = edge[i].next) {\\n    v = edge[i].to;\\n    if (v == pre && (!flag)) {\\n      flag = true;\\n      continue;\\n    }\\n    if (!DFN[v]) {\\n      Tarjan(v, u);\\n      if (Low[u] > Low[v]) Low[u] = Low[v];\\n      if (Low[v] > DFN[u]) {\\n        bridge++;\\n        edge[i].cut = true;\\n        edge[i ^ 1].cut = true;\\n      }\\n    } else if (Instack[v] && Low[u] > DFN[v])\\n      Low[u] = DFN[v];\\n  }\\n  if (Low[u] == DFN[u]) {\\n    block++;\\n    do {\\n      v = Stack[--top];\\n      Instack[v] = false;\\n      Belong[v] = block;\\n    } while (v != u);\\n  }\\n}\\nvoid init() {\\n  tot = 0;\\n  memset(head, -1, sizeof(head));\\n}\\nvoid solve(int n) {\\n  memset(DFN, 0, sizeof(DFN));\\n  memset(Instack, false, sizeof(Instack));\\n  memset(Belong, 0, sizeof(Belong));\\n  Index = top = block = 0;\\n  for (int i = 1; i <= n; i++)\\n    if (DFN[i] == 0) Tarjan(i, 0);\\n}\\nint w[MAXN], sz[MAXN], fa[MAXN];\\nbool vis[MAXN];\\nlong long W[MAXN], ans;\\nvector<int> E[MAXN], G[MAXN];\\nvector<long long> Lf;\\nvoid dfs(int now, int f) {\\n  fa[now] = f;\\n  if (sz[now] > 1 || f == 0) {\\n    int u = now;\\n    while (!vis[u]) {\\n      ans += W[u];\\n      vis[u] = true;\\n      u = fa[u];\\n    }\\n  }\\n  for (int v : E[now]) {\\n    if (v == f) continue;\\n    dfs(v, now);\\n  }\\n}\\nvoid dfs2(int now, int f) {\\n  int u = vis[now] ? 0 : now;\\n  for (int v : E[now]) {\\n    if (v == f) continue;\\n    if (!vis[v]) G[u].push_back(v);\\n    dfs2(v, now);\\n  }\\n}\\nvoid dfs3(int now, int f, long long val, long long &mx) {\\n  mx = max(mx, val);\\n  for (int v : G[now]) {\\n   ...\",\"language\":\"python\",\"split\":\"train\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"\\\"Contestant who earns a score equal to or greater than the k-th place finisher's score will advance to the next round, as long as the contestant earns a positive score...\\\" \u2014 an excerpt from contest rules.\\n\\nA total of n participants took part in the contest (n \u2265 k), and you already know their scores. Calculate how many participants will advance to the next round.\\n\\nInput\\n\\nThe first line of the input contains two integers n and k (1 \u2264 k \u2264 n \u2264 50) separated by a single space.\\n\\nThe second line contains n space-separated integers a1, a2, ..., an (0 \u2264 ai \u2264 100), where ai is the score earned by the participant who got the i-th place. The given sequence is non-increasing (that is, for all i from 1 to n - 1 the following condition is fulfilled: ai \u2265 ai + 1).\\n\\nOutput\\n\\nOutput the number of participants who advance to the next round.\\n\\nExamples\\n\\nInput\\n\\n8 5\\n10 9 8 7 7 7 5 5\\n\\n\\nOutput\\n\\n6\\n\\n\\nInput\\n\\n4 2\\n0 0 0 0\\n\\n\\nOutput\\n\\n0\\n\\nNote\\n\\nIn the first example the participant on the 5th place earned 7 points. As the participant on the 6th place also earned 7 points, there are 6 advancers.\\n\\nIn the second example nobody got a positive score.\\\":\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint main() {\\n  int n, a, b = 0;\\n  cin >> n >> a;\\n  int k[n];\\n  for (int i = 0; i < n; i++) {\\n    cin >> k[i];\\n  }\\n  for (int j = 0; j < n; j++) {\\n    if (k[j] >= k[a - 1] && k[j] > 0) {\\n      b += 1;\\n    }\\n  }\\n  cout << b;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You are given a binary string (i. e. a string consisting of characters 0 and\\/or 1) s of length n. You can perform the following operation with the string s at most once: choose a substring (a contiguous subsequence) of s having exactly k characters 1 in it, and shuffle it (reorder the characters in the substring as you wish).\\n\\nCalculate the number of different strings which can be obtained from s by performing this operation at most once.\\n\\nInput\\n\\nThe first line contains two integers n and k (2 \u2264 n \u2264 5000; 0 \u2264 k \u2264 n).\\n\\nThe second line contains the string s of length n, consisting of characters 0 and\\/or 1.\\n\\nOutput\\n\\nPrint one integer \u2014 the number of different strings which can be obtained from s by performing the described operation at most once. Since the answer can be large, output it modulo 998244353.\\n\\nExamples\\n\\nInput\\n\\n\\n7 2\\n1100110\\n\\n\\nOutput\\n\\n\\n16\\n\\n\\nInput\\n\\n\\n5 0\\n10010\\n\\n\\nOutput\\n\\n\\n1\\n\\n\\nInput\\n\\n\\n8 1\\n10001000\\n\\n\\nOutput\\n\\n\\n10\\n\\n\\nInput\\n\\n\\n10 8\\n0010011000\\n\\n\\nOutput\\n\\n\\n1\\n\\nNote\\n\\nSome strings you can obtain in the first example:\\n\\n  * to obtain 0110110, you can take the substring from the 1-st character to the 4-th character, which is 1100, and reorder its characters to get 0110; \\n  * to obtain 1111000, you can take the substring from the 3-rd character to the 7-th character, which is 00110, and reorder its characters to get 11000; \\n  * to obtain 1100101, you can take the substring from the 5-th character to the 7-th character, which is 110, and reorder its characters to get 101. \\n\\n\\n\\nIn the second example, k = 0 so you can only choose the substrings consisting only of 0 characters. Reordering them doesn't change the string at all, so the only string you can obtain is 10010.\\nThe above is tricky. Write me a correct solution in PYTHON3.\",\"targets\":\"from sys import stdin, stdout\\n\\nN = 998244353\\n\\ndef egcd(a, b):\\n    \\\"\\\"\\\"return (g, x, y) such that a*x + b*y = g = gcd(a, b)\\\"\\\"\\\"\\n    if a == 0:\\n        return (b, 0, 1)\\n    else:\\n        g, y, x = egcd(b % a, a)\\n        return (g, x - (b \\/\\/ a) * y, y)\\n\\ndef modinv(a, m = N):\\n    \\\"\\\"\\\"return inverse of a mod m\\\"\\\"\\\"\\n    g, x, y = egcd(a, m)\\n    if g != 1:\\n        raise Exception('modular inverse does not exist')\\n    else:\\n        return x % m\\n\\nfact = [1]\\ninvfact = [1]\\n\\nfor i in range(1,5001):\\n    fact.append((fact[-1]*i)%N)\\n    invfact.append((invfact[-1]*modinv(i))%N)\\n\\nn, k = [int(x) for x in stdin.readline().split()]\\ns = stdin.readline().strip()\\n\\nlocations = []\\n\\nfor i in range(n):\\n    if s[i] == '1':\\n        locations.append(i)\\n\\nif k == 0 or len(locations) < k:\\n    stdout.write('1\\\\n')\\n\\nelse:\\n    answer = 0\\n    for i in range(len(locations)-k+1):\\n        if i == 0:\\n            lower = 0\\n        else:\\n            lower = locations[i-1]+1\\n\\n        if i == len(locations)-k:\\n            upper = n-1\\n        else:\\n            upper = locations[i+k]-1\\n\\n        answer = (answer + fact[upper-lower+1]*invfact[k]*invfact[upper-lower+1-k])%N\\n\\n    for i in range(len(locations)-k):\\n        lower = locations[i]+1\\n        upper = locations[i+k]-1\\n        answer = (answer - fact[upper-lower+1]*invfact[k-1]*invfact[upper-lower+1-k+1])%N\\n\\n    stdout.write(str(answer)+'\\\\n')\",\"language\":\"python\",\"split\":\"test\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Anatoly lives in the university dorm as many other students do. As you know, cockroaches are also living there together with students. Cockroaches might be of two colors: black and red. There are n cockroaches living in Anatoly's room.\\n\\nAnatoly just made all his cockroaches to form a single line. As he is a perfectionist, he would like the colors of cockroaches in the line to alternate. He has a can of black paint and a can of red paint. In one turn he can either swap any two cockroaches, or take any single cockroach and change it's color.\\n\\nHelp Anatoly find out the minimum number of turns he needs to make the colors of cockroaches in the line alternate.\\n\\nInput\\n\\nThe first line of the input contains a single integer n (1 \u2264 n \u2264 100 000) \u2014 the number of cockroaches.\\n\\nThe second line contains a string of length n, consisting of characters 'b' and 'r' that denote black cockroach and red cockroach respectively.\\n\\nOutput\\n\\nPrint one integer \u2014 the minimum number of moves Anatoly has to perform in order to make the colors of cockroaches in the line to alternate.\\n\\nExamples\\n\\nInput\\n\\n5\\nrbbrr\\n\\n\\nOutput\\n\\n1\\n\\n\\nInput\\n\\n5\\nbbbbb\\n\\n\\nOutput\\n\\n2\\n\\n\\nInput\\n\\n3\\nrbr\\n\\n\\nOutput\\n\\n0\\n\\nNote\\n\\nIn the first sample, Anatoly has to swap third and fourth cockroaches. He needs 1 turn to do this.\\n\\nIn the second sample, the optimum answer is to paint the second and the fourth cockroaches red. This requires 2 turns.\\n\\nIn the third sample, the colors of cockroaches in the line are alternating already, thus the answer is 0.\\n#incl\",\"targets\":\"ude <bits\\/stdc++.h>\\nchar s[1000100];\\nint n;\\nint check(int op) {\\n  int p = 0, q = 0;\\n  for (int i = 0; i < n; i++) {\\n    int num = (s[i] == 'r') ? 0 : 1;\\n    if (num != op) {\\n      if (num)\\n        p++;\\n      else\\n        q++;\\n    }\\n    op ^= 1;\\n  }\\n  return abs(p - q) + std::min(p, q);\\n}\\nint main() {\\n  scanf(\\\"%d\\\", &n);\\n  scanf(\\\"%s\\\", s);\\n  std::cout << std::min(check(0), check(1)) << std::endl;\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You have received data from a Bubble bot. You know your task is to make factory facilities, but before you even start, you need to know how big the factory is and how many rooms it has. When you look at the data you see that you have the dimensions of the construction, which is in rectangle shape: N x M. \\n\\nThen in the next N lines you have M numbers. These numbers represent factory tiles and they can go from 0 to 15. Each of these numbers should be looked in its binary form. Because from each number you know on which side the tile has walls. For example number 10 in it's binary form is 1010, which means that it has a wall from the North side, it doesn't have a wall from the East, it has a wall on the South side and it doesn't have a wall on the West side. So it goes North, East, South, West. \\n\\nIt is guaranteed that the construction always has walls on it's edges. The input will be correct. \\n\\nYour task is to print the size of the rooms from biggest to smallest. \\n\\nInput\\n\\nThe first line has two numbers which are N and M, the size of the construction. Both are integers: \\n\\nn (1 \u2264 n \u2264 10^3)\\n\\nm (1 \u2264 m \u2264 10^3)\\n\\nNext N x M numbers represent each tile of construction.\\n\\nOutput\\n\\nOnce you finish processing the data your output consists of one line sorted from biggest to smallest room sizes. \\n\\nExample\\n\\nInput\\n\\n\\n4 5\\n9 14 11 12 13\\n5 15 11 6 7\\n5 9 14 9 14\\n3 2 14 3 14\\n\\n\\nOutput\\n\\n\\n9 4 4 2 1 \\n\\/*\",\"targets\":\"_oo0oo_\\n                      o8888888o\\n                      88\\\" . \\\"88\\n                      (| -_- |)\\n                      0\\\\  =  \\/0\\n                    ___\\/`---'\\\\___\\n                  .' \\\\\\\\|     |\\/\\/ '.\\n                 \\/ \\\\\\\\|||  :  |||\\/\\/ \\\\\\n                \\/ _||||| -:- |||||- \\\\\\n               |   | \\\\\\\\\\\\  -  \\/\\/\\/ |   |\\n               | \\\\_|  ''\\\\---\\/''  |_\\/ |\\n               \\\\  .-\\\\__  '-'  ___\\/-. \\/\\n             ___'. .'  \\/--.--\\\\  `. .'___\\n          .\\\"\\\" '<  `.___\\\\_<|>_\\/___.' >' \\\"\\\".\\n         | | :  `- \\\\`.;`\\\\ _ \\/`;.`\\/ - ` : | |\\n         \\\\  \\\\ `_.   \\\\_ __\\\\ \\/__ _\\/   .-` \\/  \\/\\n     =====`-.____`.___ \\\\_____\\/___.-`___.-'=====\\n                       `=---='\\n \\n*\\/\\n\\nimport java.util.*;\\nimport java.math.*;\\nimport java.io.*;\\nimport java.lang.Math.*;\\n\\npublic class KickStart2020 {\\n\\t static class FastReader {\\n\\t\\tBufferedReader br;\\n\\t\\tStringTokenizer st;\\n\\n\\t\\tpublic FastReader() {\\n\\t\\t\\tbr = new BufferedReader(new InputStreamReader(System.in));\\n\\t\\t}\\n\\n\\t\\tString next() {\\n\\t\\t\\twhile (st == null || !st.hasMoreElements()) {\\n\\t\\t\\t\\ttry {\\n\\t\\t\\t\\t\\tst = new StringTokenizer(br.readLine());\\n\\t\\t\\t\\t} catch (IOException e) {\\n\\t\\t\\t\\t\\te.printStackTrace();\\n\\t\\t\\t\\t}\\n\\t\\t\\t}\\n\\t\\t\\treturn st.nextToken();\\n\\t\\t}\\n\\n\\t\\tint nextInt() {\\n\\t\\t\\treturn Integer.parseInt(next());\\n\\t\\t}\\n\\n\\t\\tlong nextLong() {\\n\\t\\t\\treturn Long.parseLong(next());\\n\\t\\t}\\n\\n\\t\\tdouble nextDouble() {\\n\\t\\t\\treturn Double.parseDouble(next());\\n\\t\\t}\\n\\n\\t\\tfloat nextFloat() {\\n\\t\\t\\treturn Float.parseFloat(next());\\n\\t\\t}\\n\\n\\t\\tString nextLine() {\\n\\t\\t\\tString str = \\\"\\\";\\n\\t\\t\\ttry {\\n\\t\\t\\t\\tstr = br.readLine();\\n\\t\\t\\t} catch (IOException e) {\\n\\t\\t\\t\\te.printStackTrace();\\n\\t\\t\\t}\\n\\t\\t\\treturn str;\\n\\t\\t}\\n\\t}\\n\\n\\tstatic long gcd(long a, long b) {\\n\\t\\tif (b == 0)\\n\\t\\t\\treturn a;\\n\\t\\treturn gcd(b, a % b);\\n\\n\\t}\\n\\n\\tstatic long lcm(long a, long b) {\\n\\t\\treturn a \\/ gcd(a, b) * b;\\n\\t}\\n\\n\\tpublic static class Pair implements Comparable<Pair> {\\n\\t\\tpublic int index;\\n\\t\\tpublic int value;\\n\\n\\t\\tpublic Pair(int index, int value) {\\n\\t\\t\\tthis.index = index;\\n\\t\\t\\tthis.value =...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in PYTHON3?\\nYou have a permutation: an array a = [a_1, a_2, \u2026, a_n] of distinct integers from 1 to n. The length of the permutation n is odd.\\n\\nConsider the following algorithm of sorting the permutation in increasing order.\\n\\nA helper procedure of the algorithm, f(i), takes a single argument i (1 \u2264 i \u2264 n-1) and does the following. If a_i > a_{i+1}, the values of a_i and a_{i+1} are exchanged. Otherwise, the permutation doesn't change.\\n\\nThe algorithm consists of iterations, numbered with consecutive integers starting with 1. On the i-th iteration, the algorithm does the following: \\n\\n  * if i is odd, call f(1), f(3), \u2026, f(n - 2); \\n  * if i is even, call f(2), f(4), \u2026, f(n - 1). \\n\\n\\n\\nIt can be proven that after a finite number of iterations the permutation will be sorted in increasing order.\\n\\nAfter how many iterations will this happen for the first time?\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 100). Description of the test cases follows.\\n\\nThe first line of each test case contains a single integer n (3 \u2264 n \u2264 999; n is odd) \u2014 the length of the permutation.\\n\\nThe second line contains n distinct integers a_1, a_2, \u2026, a_n (1 \u2264 a_i \u2264 n) \u2014 the permutation itself. \\n\\nIt is guaranteed that the sum of n over all test cases does not exceed 999.\\n\\nOutput\\n\\nFor each test case print the number of iterations after which the permutation will become sorted in increasing order for the first time.\\n\\nIf the given permutation is already sorted, print 0.\\n\\nExample\\n\\nInput\\n\\n\\n3\\n3\\n3 2 1\\n7\\n4 5 7 1 3 2 6\\n5\\n1 2 3 4 5\\n\\n\\nOutput\\n\\n\\n3\\n5\\n0\\n\\nNote\\n\\nIn the first test case, the permutation will be changing as follows: \\n\\n  * after the 1-st iteration: [2, 3, 1]; \\n  * after the 2-nd iteration: [2, 1, 3]; \\n  * after the 3-rd iteration: [1, 2, 3]. \\n\\n\\n\\nIn the second test case, the permutation will be changing as follows: \\n\\n  * after the 1-st iteration: [4, 5, 1, 7, 2, 3, 6]; \\n  * after the 2-nd iteration: [4, 1, 5, 2, 7, 3, 6]; \\n  * after the 3-rd iteration: [1, 4, 2, 5, 3, 7, 6]; \\n  * after the 4-th...\",\"targets\":\"def sort(arr,n):\\n    ans = True\\n    for i in range(0,n):\\n        if(arr[i]!=i+1):\\n            ans = False\\n            break\\n    return ans\\ndef itrodd(arr,n):\\n    \\n    for i in range(1,n-1,2):\\n        if(arr[i-1]>arr[i]):\\n            b = arr[i]\\n            h = arr[i-1]\\n            arr[i] = h\\n            arr[i-1] = b\\ndef itreven(arr,n):\\n    for i in range(2,n,2):\\n        if(arr[i-1]>arr[i]):\\n            b = arr[i]\\n            h = arr[i-1]\\n            arr[i] = h\\n            arr[i-1] = b\\ntest = int(input())\\nwhile(test>0):\\n    n = int(input());arr = list(map(int,input().split()))\\n    total= 0\\n    for i in range(1,n+1):\\n        if(sort(arr,n)):\\n            break\\n        else:\\n            if(i%2==0):\\n                itreven(arr,n)\\n                total+=1\\n            else:\\n                itrodd(arr,n) \\n                total+=1   \\n    print(total)\\n    test-=1\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"AtCoDeer the deer has N square tiles. The tiles are numbered 1 through N, and the number given to each tile is written on one side of the tile. Also, each corner of each tile is painted in one of the 1000 colors, which are represented by the integers 0 between 999. The top-left, top-right, bottom-right and bottom-left corner of the tile with the number i are painted in color C_{i,0}, C_{i,1}, C_{i,2} and C_{i,3}, respectively, when seen in the direction of the number written on the tile (See Figure 1).\\n\\n<image>\\n\\nFigure 1: The correspondence between the colors of a tile and the input\\n\\nAtCoDeer is constructing a cube using six of these tiles, under the following conditions:\\n\\n* For each tile, the side with the number must face outward.\\n* For each vertex of the cube, the three corners of the tiles that forms it must all be painted in the same color.\\n\\n\\n\\nHelp him by finding the number of the different cubes that can be constructed under the conditions. Since each tile has a number written on it, two cubes are considered different if the set of the used tiles are different, or the tiles are used in different directions, even if the formation of the colors are the same. (Each tile can be used in one of the four directions, obtained by 90\u00b0 rotations.) Two cubes are considered the same only if rotating one in the three dimensional space can obtain an exact copy of the other, including the directions of the tiles.\\n\\n<image>\\n\\nFigure 2: The four directions of a tile\\n\\nConstraints\\n\\n* 6\u2266N\u2266400\\n* 0\u2266C_{i,j}\u2266999 (1\u2266i\u2266N , 0\u2266j\u22663)\\n\\nInput\\n\\nThe input is given from Standard Input in the following format:\\n\\n\\nN\\nC_{1,0} C_{1,1} C_{1,2} C_{1,3}\\nC_{2,0} C_{2,1} C_{2,2} C_{2,3}\\n:\\nC_{N,0} C_{N,1} C_{N,2} C_{N,3}\\n\\n\\nOutput\\n\\nPrint the number of the different cubes that can be constructed under the conditions.\\n\\nExamples\\n\\nInput\\n\\n6\\n0 1 2 3\\n0 4 6 1\\n1 6 7 2\\n2 7 5 3\\n6 4 5 7\\n4 0 3 5\\n\\n\\nOutput\\n\\n1\\n\\n\\nInput\\n\\n8\\n0 0 0 0\\n0 0 1 1\\n0 1 0 1\\n0 1 1 0\\n1 0 0 1\\n1 0 1 0\\n1 1 0 0\\n1 1 1 1\\n\\n\\nOutput\\n\\n144\\n\\n\\nInput\\n\\n6\\n0 0 0 0\\n0 0 0 0\\n0 0 0 0\\n0 0 0 0\\n0 0 0 0\\n0 0 0 0\\n\\n\\nOutput\\n\\n122880\\nThe above is tricky. Write me a correct solution in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\n#define int long long \\nusing namespace std;\\n\\n\\nmap <vector <int>, int> mp;\\n\\n\\nint f(vector <vector <int> > v) {\\n\\tint res = 1;\\n\\tfor(auto &z: v) {\\n\\t\\tvector <int> x = z, y = z; int cnt = 0;\\n\\t\\tfor(int j = 0; j < 4; j++) {\\n\\t\\t\\trotate(x.begin(), x.begin() + 1, x.end());\\n\\t\\t\\tcnt += x == z;\\n\\t\\t\\ty = min(x, y);\\n\\t\\t}\\n\\t\\tres *= cnt * mp[y];\\n\\t\\tmp[y]--;\\n\\t\\tz = y;\\n\\t}\\n\\tfor(auto z: v) {\\n\\t\\tmp[z]++;\\n\\t}\\n\\n\\treturn res;\\n}\\n\\nint32_t main() {\\n\\tios_base :: sync_with_stdio(0); cin.tie(0); cout.tie(0);\\n\\tint n; cin >> n; vector <vector <int> > a(n, vector <int> (4));\\n\\tfor(int i = 0; i < n; i++) {\\n\\t\\tfor(int j = 0; j < 4; j++) {\\n\\t\\t\\tcin >> a[i][j];\\n\\t\\t}\\n\\t\\tvector <int> b = a[i];\\n\\t\\tfor(int j = 0; j < 4; j++) {\\n\\t\\t\\trotate(b.begin(), b.begin() + 1, b.end());\\n\\t\\t\\ta[i] = min(a[i], b);\\n\\t\\t}\\n\\t}\\n\\n\\t\\n\\tint ans = 0;\\n\\n\\tfor(int i = 0; i < n; i++) {\\n\\t\\tfor(int j = 0; j < i; j++) {\\n\\t\\t\\tmp[a[j]]--;\\n\\t\\t\\tfor(int k = 0; k < 4; k++) {\\n\\t\\t\\t\\trotate(a[j].begin(), a[j].begin() + 1, a[j].end());\\n\\t\\t\\t\\tvector <int> x = a[i], y = a[j]; \\n\\t\\t\\t\\ty = {y[1], y[0], y[3], y[2]};\\n\\t\\t\\t\\tvector <vector <int> > v = {\\n\\t\\t\\t\\t\\t{x[0], y[0], y[1], x[1]},\\n\\t\\t\\t\\t\\t{x[1], y[1], y[2], x[2]},\\n\\t\\t\\t\\t\\t{x[2], y[2], y[3], x[3]},\\n\\t\\t\\t\\t\\t{x[3], y[3], y[0], x[0]}\\n\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t};\\n\\t\\t\\t\\tans += f(v);\\n\\t\\t\\t}\\n\\t\\t\\tmp[a[j]]++;\\n\\t\\t}\\n\\t\\tmp[a[i]]++;\\n\\t}\\n\\n\\tcout << ans << endl;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"It turns out that the meaning of life is a permutation p_1, p_2, \u2026, p_n of the integers 1, 2, \u2026, n (2 \u2264 n \u2264 100). Omkar, having created all life, knows this permutation, and will allow you to figure it out using some queries.\\n\\nA query consists of an array a_1, a_2, \u2026, a_n of integers between 1 and n. a is not required to be a permutation. Omkar will first compute the pairwise sum of a and p, meaning that he will compute an array s where s_j = p_j + a_j for all j = 1, 2, \u2026, n. Then, he will find the smallest index k such that s_k occurs more than once in s, and answer with k. If there is no such index k, then he will answer with 0.\\n\\nYou can perform at most 2n queries. Figure out the meaning of life p.\\n\\nInteraction\\n\\nStart the interaction by reading single integer n (2 \u2264 n \u2264 100) \u2014 the length of the permutation p.\\n\\nYou can then make queries. A query consists of a single line \\\"? \\\\enspace a_1 \\\\enspace a_2 \\\\enspace \u2026 \\\\enspace a_n\\\" (1 \u2264 a_j \u2264 n).\\n\\nThe answer to each query will be a single integer k as described above (0 \u2264 k \u2264 n).\\n\\nAfter making 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:\\n\\n  * fflush(stdout) or cout.flush() in C++;\\n  * System.out.flush() in Java;\\n  * flush(output) in Pascal;\\n  * stdout.flush() in Python;\\n  * see documentation for other languages.\\n\\n\\n\\nTo output your answer, print a single line \\\"! \\\\enspace p_1 \\\\enspace p_2 \\\\enspace \u2026 \\\\enspace p_n\\\" then terminate.\\n\\nYou can make at most 2n queries. Outputting the answer does not count as a query.\\n\\nHack Format\\n\\nTo hack, first output a line containing n (2 \u2264 n \u2264 100), then output another line containing the hidden permutation p_1, p_2, \u2026, p_n of numbers from 1 to n.\\n\\nExample\\n\\nInput\\n\\n\\n5\\n\\n2\\n\\n0\\n\\n1\\n\\n\\nOutput\\n\\n\\n\\n? 4 4 2 3 2\\n\\n? 3 5 1 5 5\\n\\n? 5 2 4 3 1\\n\\n! 3 2 1 5 4\\n\\nNote\\n\\nIn the sample, the hidden permutation p is [3, 2, 1, 5, 4]. Three queries were made.\\n\\nThe first query is a = [4, 4, 2, 3, 2]. This yields s = [3 + 4, 2 + 4, 1 + 2, 5 + 3, 4 + 2] = [7, 6, 3, 8, 6]. 6 is the only...\\nimpor\",\"targets\":\"t java.io.*;\\n\\nimport java.util.*;\\n\\/*\\n\\n\\n\\n\\n*\\/\\n\\n \\n public class A{\\n\\tstatic FastReader sc=null;\\n\\t\\n\\tpublic static void main(String[] args) {\\n\\t\\tsc=new FastReader();\\n\\t\\tint n=sc.nextInt();\\n\\t\\t\\n\\t\\tint p[]=new int[n];\\n\\t\\tint last=-1;\\n\\t\\t\\n\\t\\t\\n\\t\\tfor(int i=0;i+1<n;i++) {\\n\\t\\t\\tint a[]=new int[n];\\n\\t\\t\\tArrays.fill(a, i+1);\\n\\t\\t\\ta[n-1]=n;\\n\\t\\t\\tint id=Query(a);\\n\\t\\t\\t\\n\\t\\t\\tif(id!=-1) {\\n\\t\\t\\t\\tlast=i+1;\\n\\t\\t\\t\\tbreak;\\n\\t\\t\\t}\\n\\t\\t}\\n\\t\\t\\n\\t\\t\\/\\/how to find the last element in N queries??\\n\\t\\t\\n\\t\\t\\n\\t\\tif(last==-1)last=n;\\n\\t\\tp[n-1]=last;\\n\\t\\t\\n\\t\\t\\n\\t\\t\\/\\/find the last value in n queries\\n\\t\\t\\n\\t\\t\\n\\t\\t\\/\\/? ? ? ? ?\\n\\t\\t\\/\\/N N N N 1\\n\\t\\t\\/\\/N N N N 2\\n\\t\\t\\/\\/N N N N 3\\n\\t\\t\\/\\/N N N N 4\\n\\t\\tfor(int i=0;i<n;i++) {\\n\\t\\t\\tif(i+1==last)continue;\\n\\t\\t\\t\\n\\t\\t\\tint a[]=new int[n];\\n\\t\\t\\tArrays.fill(a, last);\\n\\t\\t\\t\\n\\t\\t\\ta[n-1]=i+1;\\n\\t\\t\\tint id=Query(a);\\n\\t\\t\\t\\n\\t\\t\\tp[id]=i+1;\\n\\t\\t}\\n\\t\\t\\n\\t\\tprintQuery(p);\\n\\t\\t\\n\\t\\t\\n\\t\\n\\t\\t\\n\\t}\\n\\tstatic int Query(int a[]) {\\n\\t\\tSystem.out.print(\\\"? \\\");\\n\\t\\tfor(int e:a)System.out.print(e+\\\" \\\");\\n\\t\\tSystem.out.println();\\n\\t\\t\\n\\t\\tint id=sc.nextInt()-1;\\n\\t\\treturn id;\\n\\t}\\n\\t\\n\\tstatic void printQuery(int a[]) {\\n\\t\\tSystem.out.print(\\\"! \\\");\\n\\t\\tfor(int e:a)System.out.print(e+\\\" \\\");\\n\\t\\tSystem.out.println();\\n\\t}\\n\\t\\n\\tstatic int[] ruffleSort(int a[]) {\\n\\t\\tArrayList<Integer> al=new ArrayList<>();\\n\\t\\tfor(int i:a)al.add(i);\\n\\t\\tCollections.sort(al);\\n\\t\\tfor(int i=0;i<a.length;i++)a[i]=al.get(i);\\n\\t\\treturn a;\\n\\t}\\n\\t\\n\\tstatic void print(int a[]) {\\n\\t\\tfor(int e:a) {\\n\\t\\t\\tSystem.out.print(e+\\\" \\\");\\n\\t\\t}\\n\\t\\tSystem.out.println();\\n\\t}\\n\\t\\n\\tstatic class FastReader{\\n\\t\\t\\n\\t\\tStringTokenizer st=new StringTokenizer(\\\"\\\");\\n\\t\\tBufferedReader br=new BufferedReader(new InputStreamReader(System.in));\\n\\t\\t\\n\\t\\tString next() {\\n\\t\\t\\twhile(!st.hasMoreTokens()) \\n\\t\\t\\t\\ttry {\\n\\t\\t\\t\\t\\tst=new StringTokenizer(br.readLine());\\n\\t\\t\\t\\t}\\n\\t\\t\\t   catch(IOException e){\\n\\t\\t\\t\\t   e.printStackTrace();\\n\\t\\t\\t   }\\n\\t\\t\\treturn st.nextToken();\\n\\t\\t}\\n\\t\\t\\n\\t\\tint nextInt() {\\n\\t\\t\\treturn Integer.parseInt(next());\\n\\t\\t}\\n\\t\\t\\n\\t\\tlong nextLong() {\\n\\t\\t\\treturn Long.parseLong(next());\\n\\t\\t}\\n\\t\\t\\n\\t\\tint[] readArray(int n) {\\n\\t\\t\\tint a[]=new int[n];\\n\\t\\t\\tfor(int i=0;i<n;i++)a[i]=sc.nextInt();\\n\\t\\t\\treturn a;\\n\\t\\t}\\n\\t}\\n\\t\\n\\t\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"<image>\\n\\nWilliam has two numbers a and b initially both equal to zero. William mastered performing three different operations with them quickly. Before performing each operation some positive integer k is picked, which is then used to perform one of the following operations: (note, that for each operation you can choose a new positive integer k)\\n\\n  1. add number k to both a and b, or \\n  2. add number k to a and subtract k from b, or \\n  3. add number k to b and subtract k from a. \\n\\n\\n\\nNote that after performing operations, numbers a and b may become negative as well.\\n\\nWilliam wants to find out the minimal number of operations he would have to perform to make a equal to his favorite number c and b equal to his second favorite number d.\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 10^4). Description of the test cases follows.\\n\\nThe only line of each test case contains two integers c and d (0 \u2264 c, d \u2264 10^9), which are William's favorite numbers and which he wants a and b to be transformed into.\\n\\nOutput\\n\\nFor each test case output a single number, which is the minimal number of operations which William would have to perform to make a equal to c and b equal to d, or -1 if it is impossible to achieve this using the described operations.\\n\\nExample\\n\\nInput\\n\\n\\n6\\n1 2\\n3 5\\n5 3\\n6 6\\n8 0\\n0 0\\n\\n\\nOutput\\n\\n\\n-1\\n2\\n2\\n1\\n2\\n0\\n\\nNote\\n\\nLet us demonstrate one of the suboptimal ways of getting a pair (3, 5):\\n\\n  * Using an operation of the first type with k=1, the current pair would be equal to (1, 1). \\n  * Using an operation of the third type with k=8, the current pair would be equal to (-7, 9). \\n  * Using an operation of the second type with k=7, the current pair would be equal to (0, 2). \\n  * Using an operation of the first type with k=3, the current pair would be equal to (3, 5).\",\"targets\":\"for _ in range(int(input())):\\n    c,d = list(map(int, input().split()))\\n    \\n    if abs(c-d)%2 == 1:\\n        print(-1)\\n    elif c==0 and d==0:\\n        print(0)\\n    elif c == 0 or d == 0:\\n        print(2)\\n    elif c == d:\\n        print(1)\\n    else:\\n        print(2)\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"A guy named Vasya attends the final grade of a high school. One day Vasya decided to watch a match of his favorite hockey team. And, as the boy loves hockey very much, even more than physics, he forgot to do the homework. Specifically, he forgot to complete his physics tasks. Next day the teacher got very angry at Vasya and decided to teach him a lesson. He gave the lazy student a seemingly easy task: You are given an idle body in space and the forces that affect it. The body can be considered as a material point with coordinates (0; 0; 0). Vasya had only to answer whether it is in equilibrium. \\\"Piece of cake\\\" \u2014 thought Vasya, we need only to check if the sum of all vectors is equal to 0. So, Vasya began to solve the problem. But later it turned out that there can be lots and lots of these forces, and Vasya can not cope without your help. Help him. Write a program that determines whether a body is idle or is moving by the given vectors of forces.\\n\\nInput\\n\\nThe first line contains a positive integer n (1 \u2264 n \u2264 100), then follow n lines containing three integers each: the xi coordinate, the yi coordinate and the zi coordinate of the force vector, applied to the body ( - 100 \u2264 xi, yi, zi \u2264 100).\\n\\nOutput\\n\\nPrint the word \\\"YES\\\" if the body is in equilibrium, or the word \\\"NO\\\" if it is not.\\n\\nExamples\\n\\nInput\\n\\n3\\n4 1 7\\n-2 4 -1\\n1 -5 -3\\n\\n\\nOutput\\n\\nNO\\n\\nInput\\n\\n3\\n3 -1 7\\n-5 2 -4\\n2 -1 -3\\n\\n\\nOutput\\n\\nYES\",\"targets\":\"x = 0\\ny = 0\\nz = 0\\nfor i in range(int(raw_input())):\\n    x1, y1, z1 = map(int, raw_input().split())\\n    x += x1\\n    y += y1\\n    z += z1\\n\\nif (x == y == z == 0):\\n    print \\\"YES\\\"\\nelse:\\n    print \\\"NO\\\"\",\"language\":\"python\",\"split\":\"train\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in JAVA?\\nAlice and Bob are playing a game on a matrix, consisting of 2 rows and m columns. The cell in the i-th row in the j-th column contains a_{i, j} coins in it.\\n\\nInitially, both Alice and Bob are standing in a cell (1, 1). They are going to perform a sequence of moves to reach a cell (2, m).\\n\\nThe possible moves are: \\n\\n  * Move right \u2014 from some cell (x, y) to (x, y + 1); \\n  * Move down \u2014 from some cell (x, y) to (x + 1, y). \\n\\n\\n\\nFirst, Alice makes all her moves until she reaches (2, m). She collects the coins in all cells she visit (including the starting cell).\\n\\nWhen Alice finishes, Bob starts his journey. He also performs the moves to reach (2, m) and collects the coins in all cells that he visited, but Alice didn't.\\n\\nThe score of the game is the total number of coins Bob collects.\\n\\nAlice wants to minimize the score. Bob wants to maximize the score. What will the score of the game be if both players play optimally?\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 10^4) \u2014 the number of testcases.\\n\\nThen the descriptions of t testcases follow.\\n\\nThe first line of the testcase contains a single integer m (1 \u2264 m \u2264 10^5) \u2014 the number of columns of the matrix.\\n\\nThe i-th of the next 2 lines contain m integers a_{i,1}, a_{i,2}, ..., a_{i,m} (1 \u2264 a_{i,j} \u2264 10^4) \u2014 the number of coins in the cell in the i-th row in the j-th column of the matrix.\\n\\nThe sum of m over all testcases doesn't exceed 10^5.\\n\\nOutput\\n\\nFor each testcase print a single integer \u2014 the score of the game if both players play optimally.\\n\\nExample\\n\\nInput\\n\\n\\n3\\n3\\n1 3 7\\n3 5 1\\n3\\n1 3 9\\n3 5 1\\n1\\n4\\n7\\n\\n\\nOutput\\n\\n\\n7\\n8\\n0\\n\\nNote\\n\\nThe paths for the testcases are shown on the following pictures. Alice's path is depicted in red and Bob's path is depicted in blue.\\n\\n<image>\",\"targets\":\"import java.io.BufferedReader;\\nimport java.io.IOException;\\nimport java.io.InputStreamReader;\\nimport java.util.StringTokenizer;\\n\\npublic class C {\\n    static class FastReader {\\n        BufferedReader br;\\n        StringTokenizer st;\\n\\n        public FastReader()\\n        {\\n            br = new BufferedReader(\\n                    new InputStreamReader(System.in));\\n        }\\n\\n        String next()\\n        {\\n            while (st == null || !st.hasMoreElements()) {\\n                try {\\n                    st = new StringTokenizer(br.readLine());\\n                }\\n                catch (IOException e) {\\n                    e.printStackTrace();\\n                }\\n            }\\n            return st.nextToken();\\n        }\\n\\n        int nextInt() { return Integer.parseInt(next()); }\\n\\n        long nextLong() { return Long.parseLong(next()); }\\n\\n        double nextDouble()\\n        {\\n            return Double.parseDouble(next());\\n        }\\n\\n        String nextLine()\\n        {\\n            String str = \\\"\\\";\\n            try {\\n                str = br.readLine();\\n            }\\n            catch (IOException e) {\\n                e.printStackTrace();\\n            }\\n            return str;\\n        }\\n    }\\n    FastReader reader = new FastReader();\\n\\n    public static void main(String[] args) {\\n        new C().run();\\n    }\\n\\n    private void run() {\\n        int t = reader.nextInt();\\n        while (t-- > 0) {\\n            solve();\\n        }\\n    }\\n\\n    private void solve() {\\n        int m = reader.nextInt();\\n        int[][] field = new int[2][m];\\n        for (int i = 0; i < 2; i++) {\\n            for (int j = 0; j < m; j++) {\\n                field[i][j] = reader.nextInt();\\n            }\\n        }\\n        int s1 = 0;\\n        int s2 = 0;\\n        for (int i = 1; i < m; i++) {\\n            s1 += field[0][i];\\n        }\\n\\n        int min = s1;\\n\\n        for (int i = 1; i < m; i++) {\\n            s1 -= field[0][i];\\n            s2 += field[1][i - 1];\\n            min = Math.min(min, Math.max(s1, s2));\\n        }\\n        System.out.println(min);\\n\\n    }\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You are given two integers l and r, l\u2264 r. Find the largest possible value of a mod b over all pairs (a, b) of integers for which r\u2265 a \u2265 b \u2265 l.\\n\\nAs a reminder, a mod b is a remainder we get when dividing a by b. For example, 26 mod 8 = 2.\\n\\nInput\\n\\nEach test contains multiple test cases.\\n\\nThe first line contains one positive integer t (1\u2264 t\u2264 10^4), denoting the number of test cases. Description of the test cases follows.\\n\\nThe only line of each test case contains two integers l, r (1\u2264 l \u2264 r \u2264 10^9).\\n\\nOutput\\n\\nFor every test case, output the largest possible value of a mod b over all pairs (a, b) of integers for which r\u2265 a \u2265 b \u2265 l.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n1 1\\n999999999 1000000000\\n8 26\\n1 999999999\\n\\n\\nOutput\\n\\n\\n0\\n1\\n12\\n499999999\\n\\nNote\\n\\nIn the first test case, the only allowed pair is (a, b) = (1, 1), for which a mod b = 1 mod 1 = 0.\\n\\nIn the second test case, the optimal choice is pair (a, b) = (1000000000, 999999999), for which a mod b = 1.\",\"targets\":\"import java.io.*;\\nimport java.util.*;\\n\\npublic class A {\\n  public static void main(String[] args) throws IOException {\\n    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));\\n    PrintWriter pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));\\n\\n    int t = Integer.parseInt(br.readLine());\\n    for (int i = 0; i < t; i++) {\\n      String[] inputs = br.readLine().split(\\\" \\\");\\n      int l = Integer.parseInt(inputs[0]);\\n      int r = Integer.parseInt(inputs[1]);\\n      \\/\\/ r >= a >= b >= l\\n\\n      int mod2 = (r+2) % 2;\\n      int newR = r + mod2;\\n      int halfR = newR\\/2;\\n      if (l <= halfR) {\\n        pw.println(halfR - 1);\\n      } else {\\n        pw.println(r % l);\\n      }\\n    }\\n\\n    pw.flush();\\n  }\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"In this problem you will meet the simplified model of game King of Thieves.\\n\\nIn a new ZeptoLab game called \\\"King of Thieves\\\" your aim is to reach a chest with gold by controlling your character, avoiding traps and obstacles on your way.\\n\\n<image>\\n\\nAn interesting feature of the game is that you can design your own levels that will be available to other players. Let's consider the following simple design of a level.\\n\\nA dungeon consists of n segments located at a same vertical level, each segment is either a platform that character can stand on, or a pit with a trap that makes player lose if he falls into it. All segments have the same length, platforms on the scheme of the level are represented as '*' and pits are represented as '.'. \\n\\nOne of things that affects speedrun characteristics of the level is a possibility to perform a series of consecutive jumps of the same length. More formally, when the character is on the platform number i1, he can make a sequence of jumps through the platforms i1 < i2 < ... < ik, if i2 - i1 = i3 - i2 = ... = ik - ik - 1. Of course, all segments i1, i2, ... ik should be exactly the platforms, not pits. \\n\\nLet's call a level to be good if you can perform a sequence of four jumps of the same length or in the other words there must be a sequence i1, i2, ..., i5, consisting of five platforms so that the intervals between consecutive platforms are of the same length. Given the scheme of the level, check if it is good.\\n\\nInput\\n\\nThe first line contains integer n (1 \u2264 n \u2264 100) \u2014 the number of segments on the level.\\n\\nNext line contains the scheme of the level represented as a string of n characters '*' and '.'.\\n\\nOutput\\n\\nIf the level is good, print the word \\\"yes\\\" (without the quotes), otherwise print the word \\\"no\\\" (without the quotes).\\n\\nExamples\\n\\nInput\\n\\n16\\n.**.*..*.***.**.\\n\\n\\nOutput\\n\\nyes\\n\\nInput\\n\\n11\\n.*.*...*.*.\\n\\n\\nOutput\\n\\nno\\n\\nNote\\n\\nIn the first sample test you may perform a sequence of jumps through platforms 2, 5, 8, 11, 14.\\\":\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint n;\\nstring s;\\nint main() {\\n  cin >> n;\\n  cin >> s;\\n  for (int i = 0; i < n; i++) {\\n    if (s[i] == '.') continue;\\n    for (int j = i + 1; j < n; j++) {\\n      if (s[j] == '.') continue;\\n      int k = j - i;\\n      bool si = true;\\n      for (int p = 0; p < 3; p++) {\\n        si = si && (j + k + k * p < n) && s[j + k + k * p] == '*';\\n      }\\n      if (si) {\\n        cout << \\\"yes\\\" << endl;\\n        return 0;\\n      }\\n    }\\n  }\\n  cout << \\\"no\\\" << endl;\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You are given a book with n chapters.\\n\\nEach chapter has a specified list of other chapters that need to be understood in order to understand this chapter. To understand a chapter, you must read it after you understand every chapter on its required list.\\n\\nCurrently you don't understand any of the chapters. You are going to read the book from the beginning till the end repeatedly until you understand the whole book. Note that if you read a chapter at a moment when you don't understand some of the required chapters, you don't understand this chapter.\\n\\nDetermine how many times you will read the book to understand every chapter, or determine that you will never understand every chapter no matter how many times you read the book.\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 2\u22c510^4).\\n\\nThe first line of each test case contains a single integer n (1 \u2264 n \u2264 2\u22c510^5) \u2014 number of chapters.\\n\\nThen n lines follow. The i-th line begins with an integer k_i (0 \u2264 k_i \u2264 n-1) \u2014 number of chapters required to understand the i-th chapter. Then k_i integers a_{i,1}, a_{i,2}, ..., a_{i, k_i} (1 \u2264 a_{i, j} \u2264 n, a_{i, j} \u2260 i, a_{i, j} \u2260 a_{i, l} for j \u2260 l) follow \u2014 the chapters required to understand the i-th chapter.\\n\\nIt is guaranteed that the sum of n and sum of k_i over all testcases do not exceed 2\u22c510^5.\\n\\nOutput\\n\\nFor each test case, if the entire book can be understood, print how many times you will read it, otherwise print -1.\\n\\nExample\\n\\nInput\\n\\n\\n5\\n4\\n1 2\\n0\\n2 1 4\\n1 2\\n5\\n1 5\\n1 1\\n1 2\\n1 3\\n1 4\\n5\\n0\\n0\\n2 1 2\\n1 2\\n2 2 1\\n4\\n2 2 3\\n0\\n0\\n2 3 2\\n5\\n1 2\\n1 3\\n1 4\\n1 5\\n0\\n\\n\\nOutput\\n\\n\\n2\\n-1\\n1\\n2\\n5\\n\\nNote\\n\\nIn the first example, we will understand chapters \\\\{2, 4\\\\} in the first reading and chapters \\\\{1, 3\\\\} in the second reading of the book.\\n\\nIn the second example, every chapter requires the understanding of some other chapter, so it is impossible to understand the book.\\n\\nIn the third example, every chapter requires only chapters that appear earlier in the book, so we can understand everything in one...\\n#incl\",\"targets\":\"ude <bits\\/stdc++.h>\\nusing namespace std;\\nconst int maxn = 2e5 + 7;\\nint indeg[maxn];\\nvector<int> g[maxn];\\npriority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>>\\n    q;\\nint main() {\\n  int T;\\n  cin >> T;\\n  while (T--) {\\n    int n;\\n    cin >> n;\\n    while (!q.empty()) q.pop();\\n    for (int i = 1; i <= n; i++) g[i].clear();\\n    for (int i = 1; i <= n; i++) {\\n      cin >> indeg[i];\\n      if (!indeg[i]) q.push(make_pair(1, i));\\n      for (int j = 1; j <= indeg[i]; j++) {\\n        int k;\\n        cin >> k;\\n        g[k].push_back(i);\\n      }\\n    }\\n    int cnt = 0, ans = -1;\\n    while (!q.empty()) {\\n      auto tp = q.top();\\n      ans = tp.first;\\n      q.pop();\\n      cnt++;\\n      for (int i : g[tp.second]) {\\n        indeg[i]--;\\n        if (!indeg[i]) {\\n          if (i > tp.second)\\n            q.push(make_pair(ans, i));\\n          else\\n            q.push(make_pair(ans + 1, i));\\n        }\\n      }\\n    }\\n    if (cnt != n) ans = -1;\\n    cout << ans << \\\"\\\\n\\\";\\n  }\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You are given strings S and T, consisting of lowercase English letters. It is guaranteed that T is a permutation of the string abc. \\n\\nFind string S', the lexicographically smallest permutation of S such that T is not a subsequence of S'.\\n\\nString a is a permutation of string b if the number of occurrences of each distinct character is the same in both strings.\\n\\nA string a is a subsequence of a string b if a can be obtained from b by deletion of several (possibly, zero or all) elements.\\n\\nA string a is lexicographically smaller than a string b if and only if one of the following holds:\\n\\n  * a is a prefix of b, but a \u2260 b;\\n  * in the first position where a and b differ, the string a has a letter that appears earlier in the alphabet than the corresponding letter in b.\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains a single integer t (1 \u2264 t \u2264 1000) \u2014 the number of test cases. Description of the test cases follows.\\n\\nThe first line of each test case contains a string S (1 \u2264 |S| \u2264 100), consisting of lowercase English letters.\\n\\nThe second line of each test case contains a string T that is a permutation of the string abc. (Hence, |T| = 3).\\n\\nNote that there is no limit on the sum of |S| across all test cases.\\n\\nOutput\\n\\nFor each test case, output a single string S', the lexicographically smallest permutation of S such that T is not a subsequence of S'.\\n\\nExample\\n\\nInput\\n\\n\\n7\\nabacaba\\nabc\\ncccba\\nacb\\ndbsic\\nbac\\nabracadabra\\nabc\\ndddddddddddd\\ncba\\nbbc\\nabc\\nac\\nabc\\n\\n\\nOutput\\n\\n\\naaaacbb\\nabccc\\nbcdis\\naaaaacbbdrr\\ndddddddddddd\\nbbc\\nac\\n\\nNote\\n\\nIn the first test case, both aaaabbc and aaaabcb are lexicographically smaller than aaaacbb, but they contain abc as a subsequence.\\n\\nIn the second test case, abccc is the smallest permutation of cccba and does not contain acb as a subsequence.\\n\\nIn the third test case, bcdis is the smallest permutation of dbsic and does not contain bac as a subsequence.\\n#incl\",\"targets\":\"ude <bits\\/stdc++.h>\\nusing namespace std;\\nint main() {\\n  int t;\\n  cin >> t;\\n  while (t--) {\\n    string s;\\n    cin >> s;\\n    string t;\\n    cin >> t;\\n    set<char> set_s;\\n    map<char, int> m;\\n    for (int i = 0; i < s.size(); i++) {\\n      m[s[i]]++;\\n      set_s.insert(s[i]);\\n    }\\n    vector<char> v;\\n    sort(s.begin(), s.end());\\n    if (t != \\\"abc\\\") {\\n      cout << s << endl;\\n      ;\\n    } else {\\n      if (m['a'] != 0 && m['b'] != 0 && m['c'] != 0) {\\n        for (int i = 0; i < m['a']; i++) {\\n          v.push_back('a');\\n        }\\n        for (int i = 0; i < m['c']; i++) {\\n          v.push_back('c');\\n        }\\n        for (int i = 0; i < m['b']; i++) {\\n          v.push_back('b');\\n        }\\n        for (int i = 0; i < m['d']; i++) {\\n          v.push_back('d');\\n        }\\n        for (int i = 0; i < m['e']; i++) {\\n          v.push_back('e');\\n        }\\n        for (int i = 0; i < m['f']; i++) {\\n          v.push_back('f');\\n        }\\n        for (int i = 0; i < m['g']; i++) {\\n          v.push_back('g');\\n        }\\n        for (int i = 0; i < m['h']; i++) {\\n          v.push_back('h');\\n        }\\n        for (int i = 0; i < m['i']; i++) {\\n          v.push_back('i');\\n        }\\n        for (int i = 0; i < m['j']; i++) {\\n          v.push_back('j');\\n        }\\n        for (int i = 0; i < m['k']; i++) {\\n          v.push_back('k');\\n        }\\n        for (int i = 0; i < m['l']; i++) {\\n          v.push_back('l');\\n        }\\n        for (int i = 0; i < m['m']; i++) {\\n          v.push_back('m');\\n        }\\n        for (int i = 0; i < m['n']; i++) {\\n          v.push_back('n');\\n        }\\n        for (int i = 0; i < m['o']; i++) {\\n          v.push_back('o');\\n        }\\n        for (int i = 0; i < m['p']; i++) {\\n          v.push_back('p');\\n        }\\n        for (int i = 0; i < m['q']; i++) {\\n          v.push_back('q');\\n        }\\n        for (int i = 0; i < m['r']; i++) {\\n          v.push_back('r');\\n        }\\n        for (int i = 0; i < m['s']; i++) {\\n          v.push_back('s');\\n        }\\n        for (int i = 0; i < m['t']; i++) {\\n         ...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"It is the hard version of the problem. The only difference is that in this version 1 \u2264 n \u2264 300.\\n\\nIn the cinema seats can be represented as the table with n rows and m columns. The rows are numbered with integers from 1 to n. The seats in each row are numbered with consecutive integers from left to right: in the k-th row from m (k - 1) + 1 to m k for all rows 1 \u2264 k \u2264 n.\\n\\n1| 2| \u22c5\u22c5\u22c5| m - 1| m  \\n---|---|---|---|---  \\nm + 1| m + 2| \u22c5\u22c5\u22c5| 2 m - 1| 2 m  \\n2m + 1| 2m + 2| \u22c5\u22c5\u22c5| 3 m - 1| 3 m  \\n\\\\vdots| \\\\vdots| \\\\ddots| \\\\vdots| \\\\vdots  \\nm (n - 1) + 1| m (n - 1) + 2| \u22c5\u22c5\u22c5| n m - 1| n m  \\nThe table with seats indices\\n\\nThere are nm people who want to go to the cinema to watch a new film. They are numbered with integers from 1 to nm. You should give exactly one seat to each person.\\n\\nIt is known, that in this cinema as lower seat index you have as better you can see everything happening on the screen. i-th person has the level of sight a_i. Let's define s_i as the seat index, that will be given to i-th person. You want to give better places for people with lower sight levels, so for any two people i, j such that a_i < a_j it should be satisfied that s_i < s_j.\\n\\nAfter you will give seats to all people they will start coming to their seats. In the order from 1 to nm, each person will enter the hall and sit in their seat. To get to their place, the person will go to their seat's row and start moving from the first seat in this row to theirs from left to right. While moving some places will be free, some will be occupied with people already seated. The inconvenience of the person is equal to the number of occupied seats he or she will go through.\\n\\nLet's consider an example: m = 5, the person has the seat 4 in the first row, the seats 1, 3, 5 in the first row are already occupied, the seats 2 and 4 are free. The inconvenience of this person will be 2, because he will go through occupied seats 1 and 3.\\n\\nFind the minimal total inconvenience (the sum of inconveniences of all people), that is possible to have by giving places for all...\\nimpor\",\"targets\":\"t sys, math\\nfrom collections import Counter, deque\\ninput = sys.stdin.buffer.readline\\n\\nclass fenwick:\\n    def __init__(self, n):\\n        self.n = n\\n        self.fw = [0]*(n+1)\\n\\n    def add(self, u, val):\\n        while u <= self.n:\\n            self.fw[u] += val\\n            u += u & -u\\n    \\n    def psum(self, u):\\n        sm = 0\\n        while u > 0:\\n            sm += self.fw[u]\\n            u -= u & -u\\n        return sm\\n\\nT = int(input())\\nfor _ in range(T):\\n    n, m = map(int, input().split())\\n    ppl = list((a, i) for i, a in enumerate(map(int, input().split())))\\n    bd = [ [] for _ in range(n) ]\\n    for i, (a, p) in enumerate(sorted(ppl)):\\n        bd[i\\/\\/m].append((a, -p))\\n        if i%m == m-1: bd[i\\/\\/m].sort()\\n    \\n    fw, cc = fenwick(n*m), 0\\n    for i in range(n):\\n        for j in range(m):\\n            p = -bd[i][j][1]+1\\n            cc += fw.psum(p)\\n            fw.add(p, 1)\\n        for j in range(m):\\n            p = -bd[i][j][1]+1\\n            fw.add(p, -1)\\n    \\n    print(cc)\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You are given n integers a_1, a_2, \u2026, a_n. Find the maximum value of max(a_l, a_{l + 1}, \u2026, a_r) \u22c5 min(a_l, a_{l + 1}, \u2026, a_r) over all pairs (l, r) of integers for which 1 \u2264 l < r \u2264 n.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 10 000) \u2014 the number of test cases.\\n\\nThe first line of each test case contains a single integer n (2 \u2264 n \u2264 10^5).\\n\\nThe second line of each test case contains n integers a_1, a_2, \u2026, a_n (1 \u2264 a_i \u2264 10^6).\\n\\nIt is guaranteed that the sum of n over all test cases doesn't exceed 3 \u22c5 10^5.\\n\\nOutput\\n\\nFor each test case, print a single integer \u2014 the maximum possible value of the product from the statement.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n3\\n2 4 3\\n4\\n3 2 3 1\\n2\\n69 69\\n6\\n719313 273225 402638 473783 804745 323328\\n\\n\\nOutput\\n\\n\\n12\\n6\\n4761\\n381274500335\\n\\nNote\\n\\nLet f(l, r) = max(a_l, a_{l + 1}, \u2026, a_r) \u22c5 min(a_l, a_{l + 1}, \u2026, a_r).\\n\\nIn the first test case, \\n\\n  * f(1, 2) = max(a_1, a_2) \u22c5 min(a_1, a_2) = max(2, 4) \u22c5 min(2, 4) = 4 \u22c5 2 = 8. \\n  * f(1, 3) = max(a_1, a_2, a_3) \u22c5 min(a_1, a_2, a_3) = max(2, 4, 3) \u22c5 min(2, 4, 3) = 4 \u22c5 2 = 8. \\n  * f(2, 3) = max(a_2, a_3) \u22c5 min(a_2, a_3) = max(4, 3) \u22c5 min(4, 3) = 4 \u22c5 3 = 12. \\n\\n\\n\\nSo the maximum is f(2, 3) = 12.\\n\\nIn the second test case, the maximum is f(1, 2) = f(1, 3) = f(2, 3) = 6.\\nThe above is tricky. Write me a correct solution in JAVA.\",\"targets\":\"import java.util.Scanner;\\n\\npublic class A {\\n\\n\\tpublic static void main(String[] args) {\\n\\t\\t\\n\\t\\tint T;\\n\\t\\tScanner s = new Scanner(System.in);\\n\\t\\t\\n\\t\\t\\/\\/System.out.println(\\\"Enter Number of Test Cases:-\\\");\\n\\t\\tT = s.nextInt();\\n\\t\\t\\n\\t\\tint counter = 0;\\n\\t\\n\\t\\t\\n\\t\\twhile(T > counter)\\n\\t\\t{\\n\\t\\t\\tint n;\\n\\t\\t\\t\\n\\t\\t\\t\\/\\/System.out.println(\\\"Enter Size of Array (n):-\\\");\\n\\t\\t\\tn = s.nextInt();\\n\\t\\t\\t\\n\\t\\t\\tLong array[] = new Long[n];\\n\\t\\t\\t\\n\\t\\t\\tfor(int i=0; i<n; i++)\\n\\t\\t\\t{\\n\\t\\t\\t\\tarray[i] = s.nextLong();\\n\\t\\t\\t}\\n\\t\\t\\t\\n\\t\\t\\tLong result = 0L;\\n\\t\\t\\t\\n\\t\\t\\tfor(int i=0; i<n-1; i++)\\n\\t\\t\\t{\\n\\t\\t\\t\\tresult = Math.max(result, array[i]*array[i+1]);\\n\\t\\t\\t}\\n\\t\\t\\t\\n\\t\\t\\tSystem.out.println(result);\\n\\t\\t\\t\\n\\t\\t\\tcounter++;\\n\\t\\t}\\n\\n\\t}\\n\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"PYTHON3 solution for \\\"A binary string is a string that consists of characters 0 and 1.\\n\\nLet \\\\operatorname{MEX} of a binary string be the smallest digit among 0, 1, or 2 that does not occur in the string. For example, \\\\operatorname{MEX} of 001011 is 2, because 0 and 1 occur in the string at least once, \\\\operatorname{MEX} of 1111 is 0, because 0 and 2 do not occur in the string and 0 < 2.\\n\\nA binary string s is given. You should cut it into any number of substrings such that each character is in exactly one substring. It is possible to cut the string into a single substring \u2014 the whole string.\\n\\nA string a is a substring of a string b if a can be obtained from b by deletion of several (possibly, zero or all) characters from the beginning and several (possibly, zero or all) characters from the end.\\n\\nWhat is the minimal sum of \\\\operatorname{MEX} of all substrings pieces can be?\\n\\nInput\\n\\nThe input consists of multiple test cases. The first line contains a single integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases. Description of the test cases follows.\\n\\nEach test case contains a single binary string s (1 \u2264 |s| \u2264 10^5).\\n\\nIt's guaranteed that the sum of lengths of s over all test cases does not exceed 10^5.\\n\\nOutput\\n\\nFor each test case print a single integer \u2014 the minimal sum of \\\\operatorname{MEX} of all substrings that it is possible to get by cutting s optimally.\\n\\nExample\\n\\nInput\\n\\n\\n6\\n01\\n1111\\n01100\\n101\\n0000\\n01010\\n\\n\\nOutput\\n\\n\\n1\\n0\\n2\\n1\\n1\\n2\\n\\nNote\\n\\nIn the first test case the minimal sum is \\\\operatorname{MEX}(0) + \\\\operatorname{MEX}(1) = 1 + 0 = 1.\\n\\nIn the second test case the minimal sum is \\\\operatorname{MEX}(1111) = 0.\\n\\nIn the third test case the minimal sum is \\\\operatorname{MEX}(01100) = 2.\\\":\",\"targets\":\"for _ in range(int(input())):\\n    s = input()\\n    if '1' not in s:\\n        print(1)\\n    elif '0' not in s:\\n        print(0)\\n    else:\\n        zflag = False\\n        oflag = False\\n        flag = False\\n        for i in s:\\n\\n            if zflag and oflag and i == '0':\\n                flag = True\\n                break\\n            if i == '0':\\n                zflag = True\\n            if zflag and i == '1':\\n                oflag = True\\n        if flag:\\n            print(2)\\n        else:\\n            print(1)\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"It is a simplified version of problem F2. The difference between them is the constraints (F1: k \u2264 2, F2: k \u2264 10).\\n\\nYou are given an integer n. Find the minimum integer x such that x \u2265 n and the number x is k-beautiful.\\n\\nA number is called k-beautiful if its decimal representation having no leading zeroes contains no more than k different digits. E.g. if k = 2, the numbers 3434443, 55550, 777 and 21 are k-beautiful whereas the numbers 120, 445435 and 998244353 are not.\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases. Then t test cases follow.\\n\\nEach test case consists of one line containing two integers n and k (1 \u2264 n \u2264 10^9, 1 \u2264 k \u2264 2).\\n\\nOutput\\n\\nFor each test case output on a separate line x \u2014 the minimum k-beautiful integer such that x \u2265 n.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n1 1\\n221 2\\n177890 2\\n998244353 1\\n\\n\\nOutput\\n\\n\\n1\\n221\\n181111\\n999999999\\nSolve the task in PYTHON3.\",\"targets\":\"import sys\\n#import random\\nfrom bisect import bisect_right as lb\\nfrom collections import deque\\n#sys.setrecursionlimit(10**8)\\nfrom queue import PriorityQueue as pq\\n#from math import *\\ninput_ = lambda: sys.stdin.readline().strip(\\\"\\\\r\\\\n\\\")\\nii = lambda : int(input_())\\nil = lambda : list(map(int, input_().split()))\\nilf = lambda : list(map(float, input_().split()))\\nip = lambda : input_()\\nfi = lambda : float(input_())\\nap = lambda ab,bc,cd : ab[bc].append(cd)\\nli = lambda : list(input_())\\npr = lambda x : print(x)\\nprinT = lambda x : print(x)\\nf = lambda : sys.stdout.flush()\\ninv =lambda x:pow(x,mod-2,mod)\\nmod = 10**9 + 7\\n\\nfor _ in range (ii()) :\\n    n,k = il()\\n\\n    if (k == 1) :\\n        x = list(str(n))\\n\\n        for i in range (1,10) :\\n            y = str(i)*(len(x))\\n            if (int(y) >= n) :\\n                print(y)\\n                break\\n\\n    else :\\n        fl = 0\\n        x = list(str(n))\\n\\n        \\n        ans1 = []\\n        for i in range (1,10) :\\n            for j in range (10) :\\n                ans = []\\n                t = 1\\n                if (i == j) :\\n                    continue\\n                x1 = min(i,j)\\n                x2 = max(i,j)\\n                temp = 1\\n                y1 = 0\\n                y2 = 0\\n\\n                #print(i,j)\\n                \\n                for k in range (len(x)) :\\n                    if (temp == 0) :\\n                        ans.append(str(x1))\\n                        y1 = 1\\n                        continue\\n                    if (x1>=int(x[k])) :\\n                        ans.append(str(x1))\\n                        y1 = 1\\n                        if (x1 > int(x[k])) :\\n                            temp = 0\\n                    elif (x2 >= int(x[k])) :\\n                        ans.append(str(x2))\\n                        y2 = 1\\n                        \\n                        if (x2 > int(x[k])) :\\n                 #           print('a')\\n                            temp = 0\\n                    else :\\n                        k2 = -1\\n                        for k1 in range (k-1,-1,-1) :\\n       ...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in CPP?\\nLuntik came out for a morning stroll and found an array a of length n. He calculated the sum s of the elements of the array (s= \u2211_{i=1}^{n} a_i). Luntik calls a subsequence of the array a nearly full if the sum of the numbers in that subsequence is equal to s-1.\\n\\nLuntik really wants to know the number of nearly full subsequences of the array a. But he needs to come home so he asks you to solve that problem!\\n\\nA sequence x is a subsequence of a sequence y if x can be obtained from y by deletion of several (possibly, zero or all) elements.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 1000) \u2014 the number of test cases. The next 2 \u22c5 t lines contain descriptions of test cases. The description of each test case consists of two lines.\\n\\nThe first line of each test case contains a single integer n (1 \u2264 n \u2264 60) \u2014 the length of the array.\\n\\nThe second line contains n integers a_1, a_2, \u2026, a_n (0 \u2264 a_i \u2264 10^9) \u2014 the elements of the array a.\\n\\nOutput\\n\\nFor each test case print the number of nearly full subsequences of the array.\\n\\nExample\\n\\nInput\\n\\n\\n5\\n5\\n1 2 3 4 5\\n2\\n1000 1000\\n2\\n1 0\\n5\\n3 0 2 1 1\\n5\\n2 1 0 3 0\\n\\n\\nOutput\\n\\n\\n1\\n0\\n2\\n4\\n4\\n\\nNote\\n\\nIn the first test case, s=1+2+3+4+5=15, only (2,3,4,5) is a nearly full subsequence among all subsequences, the sum in it is equal to 2+3+4+5=14=15-1.\\n\\nIn the second test case, there are no nearly full subsequences.\\n\\nIn the third test case, s=1+0=1, the nearly full subsequences are (0) and () (the sum of an empty subsequence is 0).\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\ntemplate <typename T>\\nistream& operator>>(istream& is, vector<T>& v) {\\n  for (auto& i : v) is >> i;\\n  return is;\\n}\\ntemplate <typename T>\\nostream& operator<<(ostream& os, vector<T> v) {\\n  for (auto& i : v) os << i << ' ';\\n  return os;\\n}\\ntemplate <typename T, typename U>\\nistream& operator>>(istream& is, pair<T, U>& p) {\\n  is >> p.first >> p.second;\\n  return is;\\n}\\ntemplate <typename T, typename U>\\nostream& operator<<(ostream& os, pair<T, U> p) {\\n  os << p.first << ' ' << p.second;\\n  return os;\\n}\\ntemplate <typename T, typename U>\\nvoid cmin(T& a, U b) {\\n  if (a > b) a = b;\\n}\\ntemplate <typename T, typename U>\\nvoid cmax(T& a, U b) {\\n  if (a < b) a = b;\\n}\\nconst int N = 2e5 + 2, M = 1e9 + 7;\\nint tt = 1, n, k;\\nvoid solve() {\\n  cin >> n;\\n  map<int, int> m;\\n  for (auto i = 0; i < n; i++) {\\n    int x;\\n    cin >> x;\\n    m[x]++;\\n  }\\n  long long ans = m[1];\\n  for (auto i = 0; i < m[0]; i++) ans *= 2;\\n  cout << ans << '\\\\n';\\n}\\nint main() {\\n  ios_base::sync_with_stdio(0);\\n  cin.tie(0);\\n  cin >> tt;\\n  while (tt--) solve();\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Cat Furrier Transform is a popular algorithm among cat programmers to create longcats. As one of the greatest cat programmers ever exist, Neko wants to utilize this algorithm to create the perfect longcat.\\n\\nAssume that we have a cat with a number x. A perfect longcat is a cat with a number equal 2^m - 1 for some non-negative integer m. For example, the numbers 0, 1, 3, 7, 15 and so on are suitable for the perfect longcats.\\n\\nIn the Cat Furrier Transform, the following operations can be performed on x:\\n\\n  * (Operation A): you select any non-negative integer n and replace x with x \u2295 (2^n - 1), with \u2295 being a [bitwise XOR operator](https:\\/\\/en.wikipedia.org\\/wiki\\/Bitwise_operation#XOR).\\n  * (Operation B): replace x with x + 1. \\n\\n\\n\\nThe first applied operation must be of type A, the second of type B, the third of type A again, and so on. Formally, if we number operations from one in the order they are executed, then odd-numbered operations must be of type A and the even-numbered operations must be of type B.\\n\\nNeko wants to produce perfect longcats at industrial scale, thus for each cat Neko only wants to perform at most 40 operations. Can you help Neko writing a transformation plan?\\n\\nNote that it is not required to minimize the number of operations. You just need to use no more than 40 operations.\\n\\nInput\\n\\nThe only line contains a single integer x (1 \u2264 x \u2264 10^6).\\n\\nOutput\\n\\nThe first line should contain a single integer t (0 \u2264 t \u2264 40) \u2014 the number of operations to apply.\\n\\nThen for each odd-numbered operation print the corresponding number n_i in it. That is, print \u2308 t\\/2 \u2309 integers n_i (0 \u2264 n_i \u2264 30), denoting the replacement x with x \u2295 (2^{n_i} - 1) in the corresponding step.\\n\\nIf there are multiple possible answers, you can print any of them. It is possible to show, that there is at least one answer in the constraints of this problem.\\n\\nExamples\\n\\nInput\\n\\n\\n39\\n\\n\\nOutput\\n\\n\\n4\\n5 3 \\n\\nInput\\n\\n\\n1\\n\\n\\nOutput\\n\\n\\n0\\n\\n\\nInput\\n\\n\\n7\\n\\n\\nOutput\\n\\n\\n0\\n\\nNote\\n\\nIn the first test, one of the transforms might be as follows: 39 \u2192 56 \u2192 57 \u2192 62 \u2192 63. Or...\\n\\/\\/imp\",\"targets\":\"ort java.sql.SQLOutput;\\nimport java.util.ArrayList;\\nimport java.util.Random;\\nimport java.util.Scanner;\\n\\npublic class Main {\\n    static ArrayList<Integer> ans = new ArrayList<>();\\n    static int size =0;\\n    public static void main(String[] args) throws Exception{\\n        Scanner kb = new Scanner(System.in);\\n        int x = kb.nextInt();\\n\\/\\/        Random m = new Random();\\n\\/\\/        for(int i =0; i<342355523; i++){\\n\\/\\/            int xx = m.nextInt();\\n\\/\\/            if(xx<0 || xx > 10e6) continue;\\n\\/\\/            solve(xx);\\n\\/\\/            if(size > 40) {\\n\\/\\/                System.out.println(xx);\\n\\/\\/                throw new Exception(\\\"\\\"+size);\\n\\/\\/            }\\n\\/\\/\\n\\/\\/        }\\n\\/\\/\\n\\/\\/        \\/\\/solve(x);\\n        \\/\\/int x = 5591722;\\n\\n        solve(x);\\n    }\\n    static void solve(int x){\\n        ans = new ArrayList<>(); size =0;\\n        int v = boe(x);\\n\\n        if(v == 2 || v == 0){\\n            ans.add(1);\\n            size++;\\n        }\\n        System.out.println(size);\\n        for(int i: ans) System.out.print(i + \\\" \\\");\\n        System.out.println();\\n    }\\n    static int boe(int x){\\n        for(int pos = 30; pos >= 2; pos--){\\n            if( ((1<<pos) & x) == 0){\\n                continue;\\n            }\\n            int bit = (1<<(pos+1)) -1;\\n            x = x ^ bit; ans.add(pos+1); size++;\\n            if(x == (1<<pos) -1) break;\\n            x += 1; size++;\\n        }\\n        return x;\\n    }\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"A string is called square if it is some string written twice in a row. For example, the strings \\\"aa\\\", \\\"abcabc\\\", \\\"abab\\\" and \\\"baabaa\\\" are square. But the strings \\\"aaa\\\", \\\"abaaab\\\" and \\\"abcdabc\\\" are not square.\\n\\nFor a given string s determine if it is square.\\n\\nInput\\n\\nThe first line of input data contains an integer t (1 \u2264 t \u2264 100) \u2014the number of test cases.\\n\\nThis is followed by t lines, each containing a description of one test case. The given strings consist only of lowercase Latin letters and have lengths between 1 and 100 inclusive.\\n\\nOutput\\n\\nFor each test case, output on a separate line:\\n\\n  * YES if the string in the corresponding test case is square, \\n  * NO otherwise. \\n\\n\\n\\nYou can output YES and NO in any case (for example, strings yEs, yes, Yes and YES will be recognized as a positive response).\\n\\nExample\\n\\nInput\\n\\n\\n10\\na\\naa\\naaa\\naaaa\\nabab\\nabcabc\\nabacaba\\nxxyy\\nxyyx\\nxyxy\\n\\n\\nOutput\\n\\n\\nNO\\nYES\\nNO\\nYES\\nYES\\nYES\\nNO\\nNO\\nNO\\nYES\\nThe above is tricky. Write me a correct solution in JAVA.\",\"targets\":\"import java.util.*;\\nimport java.lang.*;\\nimport java.io.*;\\n public class Solution{\\n    public static void main (String[] args) throws java.lang.Exception {\\n        int t = sc.nextInt();\\n        while(t-->0){\\n            String str = sc.nextLine();\\n            if(str.length()%2==0){\\n                String s1 = str.substring(0, str.length()\\/2);\\n                String s2 = str.substring(str.length()\\/2, str.length());\\n                \\/\\/System.out.println(s1+\\\" \\\"+s2);\\n                if(s1.equals(s2)){\\n                    System.out.println(\\\"YES\\\");\\n                }else{\\n                    System.out.println(\\\"NO\\\");\\n                }\\n            }else{\\n                System.out.println(\\\"NO\\\");\\n            }\\n        }\\n    }\\n    \\/\\/ Fast Reader Class\\n    public static FastReader sc = new FastReader();\\n    public static BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));\\n    static class FastReader {\\n        BufferedReader br;\\n        StringTokenizer st;\\n        public FastReader() { br = new BufferedReader(new InputStreamReader(System.in));}\\n        String next() { while (st == null || !st.hasMoreElements()) { try { st = new StringTokenizer(br.readLine()); } catch (IOException e) { e.printStackTrace(); } }return st.nextToken(); }\\n        int nextInt() {\\n            return Integer.parseInt(next());\\n        }\\n        long nextLong() {\\n            return Long.parseLong(next());\\n        }\\n        double nextDouble() {\\n            return Double.parseDouble(next());\\n        }\\n        String nextLine() { String str = \\\"\\\"; try { str = br.readLine(); } catch (IOException e) { e.printStackTrace(); }return str; }\\n    }\\n}\\n\\/\\/    int n = sc.nextInt(), p = sc.nextInt(), k = sc.nextInt();\\n\\/\\/            if(p%k<=(n-1)%k){\\n\\/\\/                    n--;\\n\\/\\/                    long ans = (p%k)*((n+k)\\/k)-((p%k-1)*(p%k))\\/(2*k);\\n\\/\\/                    System.out.println(ans);\\n\\/\\/                    ans+=(p-(p%k))\\/k+1;\\n\\/\\/                    System.out.println(ans);\\n\\/\\/                    }else{\\n\\/\\/                    long...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Let's call the string beautiful if it does not contain a substring of length at least 2, which is a palindrome. Recall that a palindrome is a string that reads the same way from the first character to the last and from the last character to the first. For example, the strings a, bab, acca, bcabcbacb are palindromes, but the strings ab, abbbaa, cccb are not.\\n\\nLet's define cost of a string as the minimum number of operations so that the string becomes beautiful, if in one operation it is allowed to change any character of the string to one of the first 3 letters of the Latin alphabet (in lowercase).\\n\\nYou are given a string s of length n, each character of the string is one of the first 3 letters of the Latin alphabet (in lowercase).\\n\\nYou have to answer m queries \u2014 calculate the cost of the substring of the string s from l_i-th to r_i-th position, inclusive.\\n\\nInput\\n\\nThe first line contains two integers n and m (1 \u2264 n, m \u2264 2 \u22c5 10^5) \u2014 the length of the string s and the number of queries.\\n\\nThe second line contains the string s, it consists of n characters, each character one of the first 3 Latin letters.\\n\\nThe following m lines contain two integers l_i and r_i (1 \u2264 l_i \u2264 r_i \u2264 n) \u2014 parameters of the i-th query.\\n\\nOutput\\n\\nFor each query, print a single integer \u2014 the cost of the substring of the string s from l_i-th to r_i-th position, inclusive.\\n\\nExample\\n\\nInput\\n\\n\\n5 4\\nbaacb\\n1 3\\n1 5\\n4 5\\n2 3\\n\\n\\nOutput\\n\\n\\n1\\n2\\n0\\n1\\n\\nNote\\n\\nConsider the queries of the example test.\\n\\n  * in the first query, the substring is baa, which can be changed to bac in one operation; \\n  * in the second query, the substring is baacb, which can be changed to cbacb in two operations; \\n  * in the third query, the substring is cb, which can be left unchanged; \\n  * in the fourth query, the substring is aa, which can be changed to ba in one operation. \\nUsing python3 can you solve the prior task?\",\"targets\":\"import sys\\n\\nMOD = 3\\n\\n\\ndef get_next(start, delta):\\n    return (start + delta) % MOD\\n\\n\\ndef get_state(arr, start, dir):\\n    n = len(arr)\\n    state = []\\n    prev = 0\\n    cur = start\\n    for a in arr:\\n\\n        state.append(prev + int(a != cur))\\n        prev = state[-1]\\n        cur = get_next(cur, dir)\\n\\n    return state\\n\\n\\ndef preprocess(arr):\\n    arr = [ord(a) - ord('a') for a in arr]\\n    states = {(start, dir): [0] + get_state(arr, start, dir)\\n              for start in range(MOD) for dir in [-1, 1]}\\n    return states\\n\\n\\ndef solve(states, l, r):\\n    results = []\\n    for (start, dir), state in states.items():\\n        results.append(state[r] - state[l - 1])\\n    return min(results)\\n\\n\\ndef main():\\n    outputs = []\\n    fin = sys.stdin\\n    # fin = open('input.txt')\\n    n, m = map(int, fin.readline().split())\\n    arr = list(fin.readline().strip())\\n    states = preprocess(arr)\\n    requests = []\\n    for _ in range(m):\\n        l, r = map(int, fin.readline().split())\\n        outputs.append(solve(states, l, r))\\n\\n    print('\\\\n'.join(map(str, outputs)))\\n\\n\\nif __name__ == '__main__':\\n    main()\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in CPP?\\nA chess tournament will be held soon, where n chess players will take part. Every participant will play one game against every other participant. Each game ends in either a win for one player and a loss for another player, or a draw for both players.\\n\\nEach of the players has their own expectations about the tournament, they can be one of two types:\\n\\n  1. a player wants not to lose any game (i. e. finish the tournament with zero losses); \\n  2. a player wants to win at least one game. \\n\\n\\n\\nYou have to determine if there exists an outcome for all the matches such that all the players meet their expectations. If there are several possible outcomes, print any of them. If there are none, report that it's impossible.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 200) \u2014 the number of test cases.\\n\\nThe first line of each test case contains one integer n (2 \u2264 n \u2264 50) \u2014 the number of chess players.\\n\\nThe second line contains the string s (|s| = n; s_i \u2208 \\\\{1, 2\\\\}). If s_i = 1, then the i-th player has expectations of the first type, otherwise of the second type.\\n\\nOutput\\n\\nFor each test case, print the answer in the following format:\\n\\nIn the first line, print NO if it is impossible to meet the expectations of all players.\\n\\nOtherwise, print YES, and the matrix of size n \u00d7 n in the next n lines.\\n\\nThe matrix element in the i-th row and j-th column should be equal to:\\n\\n  * +, if the i-th player won in a game against the j-th player; \\n  * -, if the i-th player lost in a game against the j-th player; \\n  * =, if the i-th and j-th players' game resulted in a draw; \\n  * X, if i = j. \\n\\nExample\\n\\nInput\\n\\n\\n3\\n3\\n111\\n2\\n21\\n4\\n2122\\n\\n\\nOutput\\n\\n\\nYES\\nX==\\n=X=\\n==X\\nNO\\nYES\\nX--+\\n+X++\\n+-X-\\n--+X\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nsigned main() {\\n  ios_base::sync_with_stdio(0);\\n  cin.tie(0);\\n  cout.tie(0);\\n  int t;\\n  cin >> t;\\n  for (int k = 0; k < t; k++) {\\n    int n;\\n    cin >> n;\\n    string s;\\n    cin >> s;\\n    char result[n][n];\\n    int count_2 = 0;\\n    for (int i = 0; i < n; i++)\\n      if (s[i] == '2') count_2++;\\n    if (count_2 < 3 && count_2 != 0) {\\n      cout << \\\"NO\\\" << '\\\\n';\\n      continue;\\n    }\\n    cout << \\\"YES\\\" << '\\\\n';\\n    for (int i = 0; i < n; i++)\\n      for (int j = 0; j < n; j++)\\n        if (i == j)\\n          result[i][j] = 'X';\\n        else\\n          result[i][j] = '-';\\n    for (int i = 0; i < n; i++)\\n      if (s[i] == '1')\\n        for (int j = 0; j < n; j++) {\\n          if (i != j) {\\n            result[i][j] = '=';\\n            result[j][i] = '=';\\n          }\\n        }\\n      else\\n        for (int j = 0; j < n; j++) {\\n          if (s[j] == '2' && result[i][j] == '-' && result[j][i] == '-') {\\n            result[i][j] = '+';\\n            break;\\n          }\\n        }\\n    for (int i = 0; i < n; i++)\\n      for (int j = 0; j < n; j++)\\n        if (result[i][j] == '-' && result[j][i] == '-') result[i][j] = '+';\\n    for (int i = 0; i < n; i++) {\\n      for (int j = 0; j < n; j++) cout << result[i][j];\\n      cout << '\\\\n';\\n    }\\n  }\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Vupsen and Pupsen were gifted an integer array. Since Vupsen doesn't like the number 0, he threw away all numbers equal to 0 from the array. As a result, he got an array a of length n.\\n\\nPupsen, on the contrary, likes the number 0 and he got upset when he saw the array without zeroes. To cheer Pupsen up, Vupsen decided to come up with another array b of length n such that \u2211_{i=1}^{n}a_i \u22c5 b_i=0. Since Vupsen doesn't like number 0, the array b must not contain numbers equal to 0. Also, the numbers in that array must not be huge, so the sum of their absolute values cannot exceed 10^9. Please help Vupsen to find any such array b!\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 100) \u2014 the number of test cases. The next 2 \u22c5 t lines contain the description of test cases. The description of each test case consists of two lines.\\n\\nThe first line of each test case contains a single integer n (2 \u2264 n \u2264 10^5) \u2014 the length of the array.\\n\\nThe second line contains n integers a_1, a_2, \u2026, a_n (-10^4 \u2264 a_i \u2264 10^4, a_i \u2260 0) \u2014 the elements of the array a.\\n\\nIt is guaranteed that the sum of n over all test cases does not exceed 2 \u22c5 10^5.\\n\\nOutput\\n\\nFor each test case print n integers b_1, b_2, \u2026, b_n \u2014 elements of the array b (|b_1|+|b_2|+\u2026 +|b_n| \u2264 10^9, b_i \u2260 0, \u2211_{i=1}^{n}a_i \u22c5 b_i=0).\\n\\nIt can be shown that the answer always exists.\\n\\nExample\\n\\nInput\\n\\n\\n3\\n2\\n5 5\\n5\\n5 -2 10 -9 4\\n7\\n1 2 3 4 5 6 7\\n\\n\\nOutput\\n\\n\\n1 -1\\n-1 5 1 -1 -1\\n-10 2 2 -3 5 -1 -1\\n\\nNote\\n\\nIn the first test case, 5 \u22c5 1 + 5 \u22c5 (-1)=5-5=0. You could also print 3 -3, for example, since 5 \u22c5 3 + 5 \u22c5 (-3)=15-15=0\\n\\nIn the second test case, 5 \u22c5 (-1) + (-2) \u22c5 5 + 10 \u22c5 1 + (-9) \u22c5 (-1) + 4 \u22c5 (-1)=-5-10+10+9-4=0.\\nSolve the task in JAVA.\",\"targets\":\"import java.util.*;\\nimport java.io.*;\\n\\npublic class Main {\\n\\tstatic StringBuilder sb;\\n\\tstatic dsu dsu;\\n\\tstatic long fact[];\\n\\tstatic int mod = (int) (1e9 + 7);\\n\\n\\tstatic void solve() {\\n\\tint n=i();\\n\\tlong[]arr=new long[n];\\n\\tfor(int i=0;i<n;i++)arr[i]=l();\\n\\tlong[]ans=new long[n];\\n\\t\\n\\tif(n%2==0){\\n\\tfor(int i=1;i<n;i+=2){\\n\\t    long lcm=lcm(Math.abs(arr[i-1]),Math.abs(arr[i]));\\n\\t    long v1=lcm\\/Math.abs(arr[i]);\\n\\t    long v2=lcm\\/Math.abs(arr[i-1]);\\n\\t    if(arr[i]>0){\\n\\t        ans[i]=v1;\\n\\t    }\\n\\t    else{\\n\\t        ans[i]=-v1;\\n\\t    }\\n\\t    if(arr[i-1]>0){\\n\\t        ans[i-1]=-v2;\\n\\t    }\\n\\t    else{\\n\\t        ans[i-1]=v2;\\n\\t    }\\n\\t}    \\n\\t    \\n\\t}\\n\\t\\n\\telse{\\n\\t    \\tfor(int i=1;i<n-3;i+=2){\\n\\t    long lcm=lcm(Math.abs(arr[i-1]),Math.abs(arr[i]));\\n\\t    long v1=lcm\\/Math.abs(arr[i]);\\n\\t    long v2=lcm\\/Math.abs(arr[i-1]);\\n\\t  \\n\\t    if(arr[i]>0){\\n\\t        ans[i]=v1;\\n\\t    }\\n\\t    else{\\n\\t        ans[i]=-v1;\\n\\t    }\\n\\t    if(arr[i-1]>0){\\n\\t        ans[i-1]=-v2;\\n\\t    }\\n\\t    else{\\n\\t        ans[i-1]=v2;\\n\\t    }\\n  \\n\\t}  \\n\\t\\n long lcm=lcm(Math.abs(arr[n-2]),Math.abs(arr[n-3]));\\n long lcm1=lcm(lcm,Math.abs(arr[n-1]));\\n \\/\\/last-ve\\n if(arr[n-1]>0){\\n     ans[n-1]=(-lcm1*2\\/arr[n-1]);\\n }\\n else ans[n-1]=-(lcm1*2\\/arr[n-1]);\\n\\t\\/\\/+ve\\n\\t if(arr[n-2]>0){\\n     ans[n-2]=lcm1\\/arr[n-2];\\n }\\n else ans[n-2]=(lcm1\\/arr[n-2]);\\n\\n\\n if(arr[n-3]>0){\\n     ans[n-3]=lcm1\\/arr[n-3];\\n }\\n else ans[n-3]=(lcm1\\/arr[n-3]);\\n\\t\\n\\t\\n\\t\\n\\t\\n\\t\\n\\t\\n\\t\\n\\t\\n\\t}\\n\\tfor(int i=0;i<n;i++){\\n\\t    sb.append(ans[i]+\\\" \\\");\\n\\t}\\n\\tsb.append(\\\"\\\\n\\\");\\n\\t}\\n\\n\\tpublic static void main(String[] args) {\\n\\t\\tsb = new StringBuilder();\\n\\t\\tint test = i();\\n\\t\\twhile (test-- > 0) {\\n\\t\\t\\tsolve();\\n\\t\\t}\\n\\t\\tSystem.out.println(sb);\\n\\n\\t}\\n\\n\\t\\/*\\n\\t * fact=new long[(int)1e6+10]; fact[0]=fact[1]=1; for(int i=2;i<fact.length;i++)\\n\\t * { fact[i]=((long)(i%mod)1L(long)(fact[i-1]%mod))%mod; }\\n\\t *\\/\\n\\/\\/**************NCR%P******************\\t \\n\\tstatic long ncr(int n, int r) {\\n\\t\\tif (r > n)\\n\\t\\t\\treturn (long) 0;\\n\\n\\t\\tlong res = fact[n] % mod;\\n\\t\\t\\/\\/ System.out.println(res);\\n\\t\\tres = ((long) (res % mod) * (long) (p(fact[r], mod - 2) % mod)) % mod;\\n\\t\\tres = ((long) (res % mod) * (long)...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"You are given n dominoes. Each domino has a left and a right cell. Each cell can be colored either black or white. Some cells are already colored, while some aren't yet.\\n\\nThe coloring is said to be valid if and only if it is possible to rearrange the dominoes in some order such that for each 1 \u2264 i \u2264 n the color of the right cell of the i-th domino is different from the color of the left cell of the ((i mod n)+1)-st domino. \\n\\nNote that you can't rotate the dominoes, so the left cell always remains the left cell, and the right cell always remains the right cell.\\n\\nCount the number of valid ways to color the yet uncolored cells of dominoes. Two ways are considered different if there is a cell that is colored white in one way and black in the other. In particular, colorings BW WB and WB BW different (and both invalid).\\n\\nAs this number can be very big, output it modulo 998 244 353.\\n\\nInput\\n\\nThe first line of the input contains a single integer n (1 \u2264 n \u2264 10^5) \u2014 the number of dominoes.\\n\\nThe next n lines describe dominoes. Each line contains two characters which represent the left and the right cell. Character B means that the corresponding cell is black, character W means that the corresponding cell is white, and ? means that the cell is yet to be colored. \\n\\nOutput\\n\\nPrint a single integer \u2014 the answer to the problem.\\n\\nExamples\\n\\nInput\\n\\n\\n1\\n?W\\n\\n\\nOutput\\n\\n\\n1\\n\\n\\nInput\\n\\n\\n2\\n??\\nW?\\n\\n\\nOutput\\n\\n\\n2\\n\\n\\nInput\\n\\n\\n4\\nBB\\n??\\nW?\\n??\\n\\n\\nOutput\\n\\n\\n10\\n\\nNote\\n\\nIn the first test case, there is only one domino, and we need the color of its right cell to be different from the color of its left cell. There is only one way to achieve this.\\n\\nIn the second test case, there are only 2 such colorings:\\n\\nBB WW and WB WB.\\\":\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nchar ch[100010][5];\\nconst int mod = 998244353;\\nint fac[200010], facinv[200010];\\nlong long qpow(long long a, long long b) {\\n  long long m = 1;\\n  while (b) {\\n    if (b & 1) m = m * a % mod;\\n    b >>= 1;\\n    a = a * a % mod;\\n  }\\n  return m;\\n}\\nvoid init(int x) {\\n  fac[0] = 1;\\n  int i;\\n  for (i = 1; i <= x; ++i) fac[i] = (long long)fac[i - 1] * i % mod;\\n  facinv[x] = qpow(fac[x], mod - 2);\\n  for (i = x; i >= 1; --i) facinv[i - 1] = (long long)facinv[i] * i % mod;\\n}\\nlong long C(int a, int b) {\\n  if (b < 0 || b > a) return 0;\\n  return (long long)fac[a] * facinv[b] % mod * facinv[a - b] % mod;\\n}\\nint main() {\\n  init(200000);\\n  ios::sync_with_stdio(0);\\n  cin.tie(0);\\n  int n;\\n  cin >> n;\\n  int i, x = 0, x1 = 0;\\n  for (i = 1; i <= n; ++i) {\\n    cin >> ch[i];\\n    if (ch[i][0] == 'W') {\\n      if (ch[i][1] == 'W')\\n        ++x;\\n      else if (ch[i][1] == '?')\\n        ++x1;\\n    } else if (ch[i][0] == 'B') {\\n      if (ch[i][1] == 'B')\\n        --x;\\n      else if (ch[i][1] == '?')\\n        --x, ++x1;\\n    } else {\\n      if (ch[i][1] == 'W')\\n        ++x1;\\n      else if (ch[i][1] == 'B')\\n        ++x1, --x;\\n      else\\n        x1 += 2, --x;\\n    }\\n  }\\n  long long ans = C(x1, -x);\\n  bool flag = 0;\\n  for (i = 1; i <= n; ++i) {\\n    if (ch[i][0] == ch[i][1]) {\\n      if (ch[i][0] != '?') flag = 1;\\n    }\\n  }\\n  if (!flag) {\\n    int cnt1 = 0, cnt2 = 0, cnt = 0;\\n    for (i = 1; i <= n; ++i) {\\n      if (ch[i][0] == 'W')\\n        ++cnt1;\\n      else if (ch[i][0] == 'B')\\n        ++cnt2;\\n      else {\\n        if (ch[i][1] == 'W')\\n          ++cnt2;\\n        else if (ch[i][1] == 'B')\\n          ++cnt1;\\n        else\\n          ++cnt;\\n      }\\n    }\\n    if (!cnt1 || !cnt2) {\\n      if (!cnt1 && !cnt2)\\n        ans = (ans + mod - qpow(2, cnt) + 2) % mod;\\n      else\\n        ans = (ans + mod - qpow(2, cnt) + 1) % mod;\\n    } else\\n      ans = (ans + mod - qpow(2, cnt)) % mod;\\n  }\\n  cout << ans << '\\\\n';\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Dark is going to attend Motarack's birthday. Dark decided that the gift he is going to give to Motarack is an array a of n non-negative integers.\\n\\nDark created that array 1000 years ago, so some elements in that array disappeared. Dark knows that Motarack hates to see an array that has two adjacent elements with a high absolute difference between them. He doesn't have much time so he wants to choose an integer k (0 \u2264 k \u2264 10^{9}) and replaces all missing elements in the array a with k.\\n\\nLet m be the maximum absolute difference between all adjacent elements (i.e. the maximum value of |a_i - a_{i+1}| for all 1 \u2264 i \u2264 n - 1) in the array a after Dark replaces all missing elements with k.\\n\\nDark should choose an integer k so that m is minimized. Can you help him?\\n\\nInput\\n\\nThe input consists of multiple test cases. The first line contains a single integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases. The description of the test cases follows.\\n\\nThe first line of each test case contains one integer n (2 \u2264 n \u2264 10^{5}) \u2014 the size of the array a.\\n\\nThe second line of each test case contains n integers a_1, a_2, \u2026, a_n (-1 \u2264 a_i \u2264 10 ^ {9}). If a_i = -1, then the i-th integer is missing. It is guaranteed that at least one integer is missing in every test case.\\n\\nIt is guaranteed, that the sum of n for all test cases does not exceed 4 \u22c5 10 ^ {5}.\\n\\nOutput\\n\\nPrint the answers for each test case in the following format:\\n\\nYou should print two integers, the minimum possible value of m and an integer k (0 \u2264 k \u2264 10^{9}) that makes the maximum absolute difference between adjacent elements in the array a equal to m.\\n\\nMake sure that after replacing all the missing elements with k, the maximum absolute difference between adjacent elements becomes m.\\n\\nIf there is more than one possible k, you can print any of them.\\n\\nExample\\n\\nInput\\n\\n\\n7\\n5\\n-1 10 -1 12 -1\\n5\\n-1 40 35 -1 35\\n6\\n-1 -1 9 -1 3 -1\\n2\\n-1 -1\\n2\\n0 -1\\n4\\n1 -1 3 -1\\n7\\n1 -1 7 5 2 -1 5\\n\\n\\nOutput\\n\\n\\n1 11\\n5 35\\n3 6\\n0 42\\n0 0\\n1 2\\n3 4\\n\\nNote\\n\\nIn the first test case after replacing all missing elements...\\nUsing java can you solve the prior task?\",\"targets\":\"import java.io.*;\\nimport java.util.Arrays;\\nimport java.util.InputMismatchException;\\nimport java.util.Locale;\\n\\n\\npublic class B1301 implements Runnable {\\n    public InputReader in;\\n    public PrintWriter out;\\n\\n    public void solve() throws Exception {\\n\\n        \\/\\/ solution goes here\\n        int T = in.nextInt();\\n        for (int t = 0; t < T; t++) {\\n            int n = in.nextInt();\\n            int[] nums = in.nextInts(n);\\n            long minVal = 1_000_000_000;\\n            long maxVal = 0;\\n            boolean notAllMissing = false;\\n            for (int i = 0; i < n; i++) {\\n                if (nums[i] == -1) {\\n                    if (i-1 >= 0 && nums[i-1] != -1) {\\n                        minVal = min(minVal, nums[i-1]);\\n                        maxVal = max(maxVal, nums[i-1]);\\n                        notAllMissing = true;\\n                    }\\n                    if (i+1 < n && nums[i+1] != -1) {\\n                        minVal = min(minVal, nums[i+1]);\\n                        maxVal = max(maxVal, nums[i+1]);\\n                        notAllMissing = true;\\n                    }\\n                }\\n            }\\n            long max = 0;\\n            long max2 = 0;\\n\\n            long x = notAllMissing ? (minVal+maxVal)\\/2 : minVal;\\n            for (int i = 1; i < n; i++) {\\n                long a = nums[i-1] == -1 ? x : nums[i-1];\\n                long b = nums[i] == -1 ? x : nums[i];\\n                max = max(max, abs(a-b));\\n                long a2 = nums[i-1] == -1 ? x+1 : nums[i-1];\\n                long b2 = nums[i] == -1 ? x+1 : nums[i];\\n                max2 = max(max2, abs(a2-b2));\\n            }\\n            if (max2 < max) {\\n                out.println(max2 + \\\" \\\" + (x+1) );\\n            } else {\\n                out.println(max + \\\" \\\" + x);\\n            }\\n        }\\n    }\\n\\n    public void run() {\\n        try {\\n            in = new InputReader(System.in);\\n            out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));\\n            Locale.setDefault(Locale.US);\\n            int tests = 1;\\n         ...\",\"language\":\"python\",\"split\":\"train\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"A tree is a connected undirected graph consisting of n vertices and n - 1 edges. Vertices are numbered 1 through n.\\n\\nLimak is a little polar bear. He once had a tree with n vertices but he lost it. He still remembers something about the lost tree though.\\n\\nYou are given m pairs of vertices (a1, b1), (a2, b2), ..., (am, bm). Limak remembers that for each i there was no edge between ai and bi. He also remembers that vertex 1 was incident to exactly k edges (its degree was equal to k).\\n\\nIs it possible that Limak remembers everything correctly? Check whether there exists a tree satisfying the given conditions.\\n\\nInput\\n\\nThe first line of the input contains three integers n, m and k (<image>) \u2014 the number of vertices in Limak's tree, the number of forbidden pairs of vertices, and the degree of vertex 1, respectively.\\n\\nThe i-th of next m lines contains two distinct integers ai and bi (1 \u2264 ai, bi \u2264 n, ai \u2260 bi) \u2014 the i-th pair that is forbidden. It's guaranteed that each pair of vertices will appear at most once in the input.\\n\\nOutput\\n\\nPrint \\\"possible\\\" (without quotes) if there exists at least one tree satisfying the given conditions. Otherwise, print \\\"impossible\\\" (without quotes).\\n\\nExamples\\n\\nInput\\n\\n5 4 2\\n1 2\\n2 3\\n4 2\\n4 1\\n\\n\\nOutput\\n\\npossible\\n\\n\\nInput\\n\\n6 5 3\\n1 2\\n1 3\\n1 4\\n1 5\\n1 6\\n\\n\\nOutput\\n\\nimpossible\\n\\nNote\\n\\nIn the first sample, there are n = 5 vertices. The degree of vertex 1 should be k = 2. All conditions are satisfied for a tree with edges 1 - 5, 5 - 2, 1 - 3 and 3 - 4.\\n\\nIn the second sample, Limak remembers that none of the following edges existed: 1 - 2, 1 - 3, 1 - 4, 1 - 5 and 1 - 6. Hence, vertex 1 couldn't be connected to any other vertex and it implies that there is no suitable tree.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst int inf = 0x3f3f3f3f, mod = 1e9 + 7;\\nconst int maxn = 3e5 + 100;\\nconst long double PI = acos(-1.0);\\nlong long gcd(long long a, long long b) { return (a ? gcd(b % a, a) : b); }\\nlong long power(long long a, long long n) {\\n  long long p = 1;\\n  while (n > 0) {\\n    if (n % 2) {\\n      p = p * a;\\n    }\\n    n >>= 1;\\n    a *= a;\\n  }\\n  return p;\\n}\\nlong long power(long long a, long long n, long long mod) {\\n  long long p = 1;\\n  while (n > 0) {\\n    if (n % 2) {\\n      p = p * a;\\n      p %= mod;\\n    }\\n    n >>= 1;\\n    a *= a;\\n    a %= mod;\\n  }\\n  return p % mod;\\n}\\nint n, m, k;\\nint flag[maxn];\\nset<int> gg;\\nset<int>::iterator it;\\nvector<int> nex[maxn];\\nset<int> one, aa, bb;\\nint main() {\\n  while (~scanf(\\\"%d%d%d\\\", &n, &m, &k)) {\\n    one.clear();\\n    gg.clear();\\n    aa.clear();\\n    bb.clear();\\n    for (int i = 1; i <= n; i++) nex[i].clear();\\n    for (int i = 1; i <= m; i++) {\\n      int u, v;\\n      scanf(\\\"%d%d\\\", &u, &v);\\n      if (u == 1)\\n        one.insert(v);\\n      else if (v == 1)\\n        one.insert(u);\\n      else {\\n        nex[u].push_back(v);\\n        nex[v].push_back(u);\\n      }\\n    }\\n    memset(flag, 0, sizeof(flag));\\n    for (int i = 2; i <= n; i++) gg.insert(i);\\n    int ans = 1, flv = 0;\\n    for (int i = 0; i < nex[2].size(); i++) {\\n      flag[nex[2][i]] = 1;\\n      gg.erase(nex[2][i]);\\n      aa.insert(nex[2][i]);\\n    }\\n    gg.erase(2);\\n    do {\\n      if (aa.size() == 0) break;\\n      flv = 0;\\n      while (!gg.empty()) {\\n        it = gg.begin();\\n        int d = *it;\\n        flv = 0;\\n        bb.clear();\\n        for (int i = 0; i < nex[d].size(); i++)\\n          if (flag[nex[d][i]] == ans) {\\n            aa.erase(nex[d][i]);\\n            bb.insert(nex[d][i]);\\n          }\\n        for (it = aa.begin(); it != aa.end(); it++) {\\n          gg.insert(*it);\\n          flag[*it] = ans - 1;\\n        }\\n        if (bb.size() == 0) {\\n          flv = 1;\\n          break;\\n        }\\n        aa.clear();\\n        for (it = bb.begin(); it != bb.end(); it++) aa.insert(*it);\\n        gg.erase(d);\\n     ...\",\"language\":\"python\",\"split\":\"train\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in CPP?\\nPavel plays a famous computer game. A player is responsible for a whole country and he can travel there freely, complete quests and earn experience.\\n\\nThis country has n cities connected by m bidirectional roads of different lengths so that it is possible to get from any city to any other one. There are portals in k of these cities. At the beginning of the game all portals are closed. When a player visits a portal city, the portal opens. Strange as it is, one can teleport from an open portal to an open one. The teleportation takes no time and that enables the player to travel quickly between rather remote regions of the country.\\n\\nAt the beginning of the game Pavel is in city number 1. He wants to open all portals as quickly as possible. How much time will he need for that?\\n\\nInput\\n\\nThe first line contains two space-separated integers n and m (1 \u2264 n \u2264 105, 0 \u2264 m \u2264 105) that show how many cities and roads are in the game.\\n\\nEach of the next m lines contains the description of a road as three space-separated integers xi, yi, wi (1 \u2264 xi, yi \u2264 n, xi \u2260 yi, 1 \u2264 wi \u2264 109) \u2014 the numbers of the cities connected by the i-th road and the time needed to go from one city to the other one by this road. Any two cities are connected by no more than one road. It is guaranteed that we can get from any city to any other one, moving along the roads of the country.\\n\\nThe next line contains integer k (1 \u2264 k \u2264 n) \u2014 the number of portals.\\n\\nThe next line contains k space-separated integers p1, p2, ..., pk \u2014 numbers of the cities with installed portals. Each city has no more than one portal.\\n\\nOutput\\n\\nPrint a single number \u2014 the minimum time a player needs to open all portals.\\n\\nPlease, do not use the %lld specifier to read or write 64-bit integers in C++. It is preferred to use the cin, cout streams or the %I64d specifier.\\n\\nExamples\\n\\nInput\\n\\n3 3\\n1 2 1\\n1 3 1\\n2 3 1\\n3\\n1 2 3\\n\\n\\nOutput\\n\\n2\\n\\n\\nInput\\n\\n4 3\\n1 2 1\\n2 3 5\\n2 4 10\\n3\\n2 3 4\\n\\n\\nOutput\\n\\n16\\n\\n\\nInput\\n\\n4 3\\n1 2 1000000000\\n2 3 1000000000\\n3 4 1000000000\\n4\\n1 2 3 4\\n\\n\\nOutput\\n\\n3000000000\\n\\nNote\\n\\nIn the...\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\ntemplate <class T>\\ninline void read(T &x) {\\n  x = 0;\\n  long long f = 0;\\n  char ch = getchar();\\n  while (!isdigit(ch)) f = ch == '-', ch = getchar();\\n  while (isdigit(ch)) x = (x << 1) + (x << 3) + (ch ^ 48), ch = getchar();\\n  x = f ? -x : x;\\n}\\ntemplate <class T>\\ninline void write(T x) {\\n  if (x < 0) return putchar('-'), write(-x);\\n  if (x > 9) write(x \\/ 10);\\n  putchar('0' + x % 10);\\n}\\nconst long long N = 1e5 + 5;\\nstruct edge {\\n  long long next, from, to, w;\\n} e[N << 1];\\nstruct Edge {\\n  long long u, v, w;\\n  bool operator<(const Edge o) const { return w < o.w; }\\n} E[N];\\nlong long n, m, K, p[N], dis[N], fro[N], vis[N], fa[N], head[N], cnt, tot, ans;\\nvoid add(long long u, long long v, long long w) {\\n  e[++cnt] = {head[u], u, v, w};\\n  head[u] = cnt;\\n}\\nvoid Dij() {\\n  priority_queue<pair<long long, long long> > q;\\n  memset(dis, 0x3f, sizeof(dis));\\n  for (long long i = 1; i <= K; i++)\\n    q.push(make_pair(0, p[i])), dis[p[i]] = 0, fro[p[i]] = p[i];\\n  while (!q.empty()) {\\n    long long x = q.top().second;\\n    q.pop();\\n    if (vis[x]) continue;\\n    vis[x] = 1;\\n    for (long long i = head[x]; i; i = e[i].next) {\\n      long long y = e[i].to;\\n      if (dis[y] > dis[x] + e[i].w) {\\n        dis[y] = dis[x] + e[i].w, fro[y] = fro[x];\\n        q.push(make_pair(-dis[y], y));\\n      }\\n    }\\n  }\\n}\\nvoid init() {\\n  for (long long i = 1; i <= n; i++) fa[i] = i;\\n}\\nlong long find_fa(long long x) {\\n  return fa[x] == x ? x : fa[x] = find_fa(fa[x]);\\n}\\nvoid Kruskal() {\\n  init(), sort(E + 1, E + tot + 1);\\n  for (long long i = 1; i <= tot; i++) {\\n    long long x = find_fa(E[i].u), y = find_fa(E[i].v);\\n    if (x != y) fa[x] = y, ans += E[i].w;\\n  }\\n}\\nsigned main() {\\n  read(n), read(m);\\n  for (long long i = 1, u, v, w; i <= m; i++) {\\n    read(u), read(v), read(w);\\n    add(u, v, w), add(v, u, w);\\n  }\\n  read(K);\\n  for (long long i = 1; i <= K; i++) read(p[i]);\\n  Dij();\\n  for (long long i = 1; i <= cnt; i += 2) {\\n    long long x = fro[e[i].from], y = fro[e[i].to];\\n    if (x != y) E[++tot] = {x, y,...\",\"language\":\"python\",\"split\":\"train\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in CPP?\\nNote that the memory limit in this problem is lower than in others.\\n\\nYou have a vertical strip with n cells, numbered consecutively from 1 to n from top to bottom.\\n\\nYou also have a token that is initially placed in cell n. You will move the token up until it arrives at cell 1.\\n\\nLet the token be in cell x > 1 at some moment. One shift of the token can have either of the following kinds: \\n\\n  * Subtraction: you choose an integer y between 1 and x-1, inclusive, and move the token from cell x to cell x - y. \\n  * Floored division: you choose an integer z between 2 and x, inclusive, and move the token from cell x to cell \u230a x\\/z \u230b (x divided by z rounded down). \\n\\n\\n\\nFind the number of ways to move the token from cell n to cell 1 using one or more shifts, and print it modulo m. Note that if there are several ways to move the token from one cell to another in one shift, all these ways are considered distinct (check example explanation for a better understanding).\\n\\nInput\\n\\nThe only line contains two integers n and m (2 \u2264 n \u2264 4 \u22c5 10^6; 10^8 < m < 10^9; m is a prime number) \u2014 the length of the strip and the modulo.\\n\\nOutput\\n\\nPrint the number of ways to move the token from cell n to cell 1, modulo m.\\n\\nExamples\\n\\nInput\\n\\n\\n3 998244353\\n\\n\\nOutput\\n\\n\\n5\\n\\n\\nInput\\n\\n\\n5 998244353\\n\\n\\nOutput\\n\\n\\n25\\n\\n\\nInput\\n\\n\\n42 998244353\\n\\n\\nOutput\\n\\n\\n793019428\\n\\n\\nInput\\n\\n\\n787788 100000007\\n\\n\\nOutput\\n\\n\\n94810539\\n\\nNote\\n\\nIn the first test, there are three ways to move the token from cell 3 to cell 1 in one shift: using subtraction of y = 2, or using division by z = 2 or z = 3.\\n\\nThere are also two ways to move the token from cell 3 to cell 1 via cell 2: first subtract y = 1, and then either subtract y = 1 again or divide by z = 2.\\n\\nTherefore, there are five ways in total.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst long long inf = (1ll << 62) - 1;\\nlong long mod = 1e9 + 7;\\nconst long long N = 1e5 + 100;\\nconst long double pi = 3.14159265358979323846;\\nconst long double eps = 1e-7;\\nlong long dx[] = {-1, 0, 1, 0, -1, -1, 1, 1};\\nlong long dy[] = {0, 1, 0, -1, -1, 1, 1, -1};\\nchar dir[] = {'U', 'R', 'D', 'L'};\\nlong long bPow(long long a, long long b) {\\n  long long res = 1;\\n  while (b) {\\n    if (b & 1) {\\n      res = (res * a) % mod;\\n    }\\n    b >>= 1;\\n    a = (a * a) % mod;\\n  }\\n  return res % mod;\\n}\\nlong long gcd(long long a, long long b) {\\n  if (a < b) swap(a, b);\\n  if (b == 0) return a;\\n  return gcd(b, a % b);\\n}\\nvector<long long> fact(N, 0ll);\\nvoid factorial() {\\n  fact[0] = 1, fact[1] = 1;\\n  for (long long i = 2; i < N; i++) {\\n    fact[i] = (fact[i - 1] * i) % mod;\\n  }\\n}\\nlong long ncr(long long n, long long r) {\\n  if (r > n) return 0;\\n  long long ans = fact[n] % mod;\\n  ans *= bPow(fact[r], mod - 2) % mod;\\n  ans %= mod;\\n  ans *= bPow(fact[n - r], mod - 2) % mod;\\n  ans %= mod;\\n  return ans;\\n}\\nvector<long long> primes(N, -1);\\nvoid sieve() {\\n  iota(primes.begin(), primes.end(), 0);\\n  for (long long i = 2; i < N; ++i) {\\n    if (primes[i] == i) {\\n      for (long long j = i * 2; j < N; j += i) {\\n        primes[j] = i;\\n      }\\n    }\\n  }\\n}\\nlong long add(long long a, long long b) {\\n  a %= mod, b %= mod;\\n  return ((a + b) % mod + mod) % mod;\\n}\\nlong long mul(long long a, long long b) {\\n  a %= mod, b %= mod;\\n  return ((a * b) % mod + mod) % mod;\\n}\\nlong long sub(long long a, long long b) {\\n  a %= mod, b %= mod;\\n  return ((a - b + 2 * mod) % mod + mod) % mod;\\n}\\nvoid solve() {\\n  long long n;\\n  cin >> n >> mod;\\n  vector<long long> dp(n + 1, 0), pref(n + 2, 0);\\n  long long prev = 0;\\n  for (long long i = 1; i <= n; ++i) {\\n    pref[i] = add(pref[i], pref[i - 1]);\\n    dp[i] = add(dp[i], pref[i] + prev);\\n    if (i == 1) {\\n      dp[i] = add(dp[i], 1);\\n    }\\n    long long j = 2;\\n    while (i * j <= n) {\\n      long long x = i * j, y = min(n + 1, (i + 1) * j);\\n      pref[x] = add(pref[x], dp[i]);\\n    ...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Mocha wants to be an astrologer. There are n stars which can be seen in Zhijiang, and the brightness of the i-th star is a_i. \\n\\nMocha considers that these n stars form a constellation, and she uses (a_1,a_2,\u2026,a_n) to show its state. A state is called mathematical if all of the following three conditions are satisfied:\\n\\n  * For all i (1\u2264 i\u2264 n), a_i is an integer in the range [l_i, r_i].\\n  * \u2211  _{i=1} ^ n a_i \u2264 m.\\n  * \\\\gcd(a_1,a_2,\u2026,a_n)=1.\\n\\n\\n\\nHere, \\\\gcd(a_1,a_2,\u2026,a_n) denotes the [greatest common divisor (GCD)](https:\\/\\/en.wikipedia.org\\/wiki\\/Greatest_common_divisor) of integers a_1,a_2,\u2026,a_n.\\n\\nMocha is wondering how many different mathematical states of this constellation exist. Because the answer may be large, you must find it modulo 998 244 353.\\n\\nTwo states (a_1,a_2,\u2026,a_n) and (b_1,b_2,\u2026,b_n) are considered different if there exists i (1\u2264 i\u2264 n) such that a_i \u2260 b_i.\\n\\nInput\\n\\nThe first line contains two integers n and m (2 \u2264 n \u2264 50, 1 \u2264 m \u2264 10^5) \u2014 the number of stars and the upper bound of the sum of the brightness of stars.\\n\\nEach of the next n lines contains two integers l_i and r_i (1 \u2264 l_i \u2264 r_i \u2264 m) \u2014 the range of the brightness of the i-th star.\\n\\nOutput\\n\\nPrint a single integer \u2014 the number of different mathematical states of this constellation, modulo 998 244 353.\\n\\nExamples\\n\\nInput\\n\\n\\n2 4\\n1 3\\n1 2\\n\\n\\nOutput\\n\\n\\n4\\n\\nInput\\n\\n\\n5 10\\n1 10\\n1 10\\n1 10\\n1 10\\n1 10\\n\\n\\nOutput\\n\\n\\n251\\n\\nInput\\n\\n\\n5 100\\n1 94\\n1 96\\n1 91\\n4 96\\n6 97\\n\\n\\nOutput\\n\\n\\n47464146\\n\\nNote\\n\\nIn the first example, there are 4 different mathematical states of this constellation:\\n\\n  * a_1=1, a_2=1.\\n  * a_1=1, a_2=2.\\n  * a_1=2, a_2=1.\\n  * a_1=3, a_2=1.\\nThe above is tricky. Write me a correct solution in PYTHON3.\",\"targets\":\"import sys\\ninput=sys.stdin.readline\\n\\nmax_n=10**5+1\\nspf=[i for i in range(max_n)]\\nprime=[True for i in range(max_n)]\\nmobius=[0 for i in range(max_n)]\\nprime[0]=prime[1]=False\\nmobius[1]=1\\nprimes=[]\\nfor i in range(2,max_n):\\n    if(prime[i]):\\n        spf[i]=i\\n        mobius[i]=-1\\n        primes.append(i)\\n    for j in primes:\\n        prod=j*i\\n        if(j>spf[i] or prod>=max_n):\\n            break\\n        spf[prod]=j\\n        prime[prod]=False\\n        if(spf[i]==j):\\n            mobius[prod]=0\\n        else:\\n            mobius[prod]=-mobius[i]\\n\\nmod=998244353\\nn,m=map(int,input().split())\\nlower=[]\\nupper=[]\\nfor i in range(n):\\n    l,r=map(int,input().split())\\n    lower.append(l)\\n    upper.append(r)\\n    \\ndef calc(low,high,n,m):\\n    if(n>m):\\n        return(0)\\n    dp=[[0 for j in range(m+1)] for i in range(n+1)]\\n    dp_pref=[[0 for j in range(m+1)] for i in range(n+1)]\\n    for j in range(low[0],m+1):\\n        if(j<=high[0]):\\n            dp[1][j]=1\\n        dp_pref[1][j]=dp[1][j]+dp_pref[1][j-1]\\n    for i in range(2,n+1):\\n        for j in range(1,m+1):\\n            dp[i][j]=(dp_pref[i-1][max(j-low[i-1],0)]-dp_pref[i-1][max(j-high[i-1]-1,0)])%mod\\n            dp_pref[i][j]=(dp[i][j]+dp_pref[i][j-1])%mod\\n    return(sum(dp[n])%mod)\\n\\nans=calc(lower,upper,n,m)\\nfor i in range(2,m):\\n    low=[]\\n    high=[]\\n    for k in range(n):\\n        low.append((lower[k]+i-1)\\/\\/i)\\n        high.append(upper[k]\\/\\/i)\\n    val=calc(low,high,n,m\\/\\/i)\\n    ans=(ans+mobius[i]*val)%mod\\nprint(ans)\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"A known chef has prepared n dishes: the i-th dish consists of a_i grams of fish and b_i grams of meat. \\n\\nThe banquet organizers estimate the balance of n dishes as follows. The balance is equal to the absolute value of the difference between the total mass of fish and the total mass of meat.\\n\\nTechnically, the balance equals to \\\\left|\u2211_{i=1}^n a_i - \u2211_{i=1}^n b_i\\\\right|. The smaller the balance, the better.\\n\\nIn order to improve the balance, a taster was invited. He will eat exactly m grams of food from each dish. For each dish, the taster determines separately how much fish and how much meat he will eat. The only condition is that he should eat exactly m grams of each dish in total.\\n\\nDetermine how much of what type of food the taster should eat from each dish so that the value of the balance is as minimal as possible. If there are several correct answers, you may choose any of them.\\n\\nInput\\n\\nThe first line of input data contains an integer t (1 \u2264 t \u2264 10^4) \u2014 the number of the test cases.\\n\\nEach test case's description is preceded by a blank line. Next comes a line that contains integers n and m (1 \u2264 n \u2264 2 \u22c5 10^5; 0 \u2264 m \u2264 10^6). The next n lines describe dishes, the i-th of them contains a pair of integers a_i and b_i (0 \u2264 a_i, b_i \u2264 10^6) \u2014 the masses of fish and meat in the i-th dish.\\n\\nIt is guaranteed that it is possible to eat m grams of food from each dish. In other words, m \u2264 a_i+b_i for all i from 1 to n inclusive.\\n\\nThe sum of all n values over all test cases in the test does not exceed 2 \u22c5 10^5.\\n\\nOutput\\n\\nFor each test case, print on the first line the minimal balance value that can be achieved by eating exactly m grams of food from each dish.\\n\\nThen print n lines that describe a way to do this: the i-th line should contain two integers x_i and y_i (0 \u2264 x_i \u2264 a_i; 0 \u2264 y_i \u2264 b_i; x_i+y_i=m), where x_i is how many grams of fish taster should eat from the i-th meal and y_i is how many grams of meat.\\n\\nIf there are several ways to achieve a minimal balance, find any of them.\\n\\nExample\\n\\nInput\\n\\n\\n8\\n\\n1 5\\n3 4\\n\\n1 6\\n3...\\\":\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint main() {\\n  ios::sync_with_stdio(false);\\n  cin.tie(nullptr);\\n  int t;\\n  cin >> t;\\n  while (t--) {\\n    int n, m;\\n    cin >> n >> m;\\n    vector<int> a(n), b(n);\\n    for (int i = 0; i < n; i++) {\\n      cin >> a[i] >> b[i];\\n    }\\n    long long sum_a = accumulate(a.begin(), a.end(), 0ll);\\n    long long sum_b = accumulate(b.begin(), b.end(), 0ll);\\n    long long target = sum_a - sum_b + (long long)n * m;\\n    vector<int> l(n), r(n);\\n    for (int i = 0; i < n; i++) {\\n      l[i] = max(0, m - b[i]);\\n      r[i] = m - max(0, m - a[i]);\\n      target -= 2 * l[i];\\n    }\\n    for (int i = 0; i < n; i++) {\\n      if (target > 0) {\\n        int take = min(target \\/ 2, (long long)r[i] - l[i]);\\n        target -= 2 * take;\\n        l[i] += take;\\n      }\\n    }\\n    cout << abs(target) << '\\\\n';\\n    for (int i = 0; i < n; i++) {\\n      cout << l[i] << ' ' << m - l[i] << '\\\\n';\\n    }\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"Hanh is a famous biologist. He loves growing trees and doing experiments on his own garden.\\n\\nOne day, he got a tree consisting of n vertices. Vertices are numbered from 1 to n. A tree with n vertices is an undirected connected graph with n-1 edges. Initially, Hanh sets the value of every vertex to 0.\\n\\nNow, Hanh performs q operations, each is either of the following types: \\n\\n  * Type 1: Hanh selects a vertex v and an integer d. Then he chooses some vertex r uniformly at random, lists all vertices u such that the path from r to u passes through v. Hanh then increases the value of all such vertices u by d. \\n  * Type 2: Hanh selects a vertex v and calculates the expected value of v. \\n\\n\\n\\nSince Hanh is good at biology but not math, he needs your help on these operations.\\n\\nInput\\n\\nThe first line contains two integers n and q (1 \u2264 n, q \u2264 150 000) \u2014 the number of vertices on Hanh's tree and the number of operations he performs.\\n\\nEach of the next n - 1 lines contains two integers u and v (1 \u2264 u, v \u2264 n), denoting that there is an edge connecting two vertices u and v. It is guaranteed that these n - 1 edges form a tree.\\n\\nEach of the last q lines describes an operation in either formats: \\n\\n  * 1 v d (1 \u2264 v \u2264 n, 0 \u2264 d \u2264 10^7), representing a first-type operation. \\n  * 2 v (1 \u2264 v \u2264 n), representing a second-type operation. \\n\\n\\n\\nIt is guaranteed that there is at least one query of the second type.\\n\\nOutput\\n\\nFor each operation of the second type, write the expected value on a single line. \\n\\nLet M = 998244353, it can be shown that the expected value can be expressed as an irreducible fraction p\\/q, where p and q are integers and q not \u2261 0 \\\\pmod{M}. Output the integer equal to p \u22c5 q^{-1} mod M. In other words, output such an integer x that 0 \u2264 x < M and x \u22c5 q \u2261 p \\\\pmod{M}.\\n\\nExample\\n\\nInput\\n\\n\\n5 12\\n1 2\\n1 3\\n2 4\\n2 5\\n1 1 1\\n2 1\\n2 2\\n2 3\\n2 4\\n2 5\\n1 2 2\\n2 1\\n2 2\\n2 3\\n2 4\\n2 5\\n\\n\\nOutput\\n\\n\\n1\\n199648871\\n399297742\\n199648871\\n199648871\\n598946614\\n199648873\\n2\\n2\\n2\\n\\nNote\\n\\nThe image below shows the tree in the example:\\n\\n<image>\\n\\nFor the first query, where v...\\\":\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst int mod = 998244353;\\ninline void add(int &x, int y) {\\n  x += y;\\n  if (x >= mod) x -= mod;\\n}\\nstruct bit {\\n  int n;\\n  vector<int> b;\\n  bit(int n) : n(n), b(n + 1) {}\\n  void update(int l, int r, int x) {\\n    for (; l <= n; l += l & -l) add(b[l], x);\\n    for (++r; r <= n; r += r & -r) add(b[r], mod - x);\\n  }\\n  int query(int p) {\\n    int x = 0;\\n    for (; p > 0; p -= p & -p) add(x, b[p]);\\n    return x;\\n  }\\n};\\nint Pow(int a, int b) {\\n  int x = 1;\\n  for (; b > 0; b >>= 1) {\\n    if (b & 1) x = (long long)x * a % mod;\\n    a = (long long)a * a % mod;\\n  }\\n  return x;\\n}\\nint main() {\\n  ios_base::sync_with_stdio(0), cin.tie(0);\\n  int n, q;\\n  cin >> n >> q;\\n  vector<vector<int>> adj(n);\\n  for (int i = 1, u, v; i < n; ++i) {\\n    cin >> u >> v;\\n    adj[--u].push_back(--v);\\n    adj[v].push_back(u);\\n  }\\n  vector<int> size(n), heavy(n, -1), Q(1, 0), parent(n, -1), head(n);\\n  for (int i = 0, u; i < n; ++i) {\\n    size[u = Q[i]] = 1;\\n    for (auto v : adj[u])\\n      if (parent[u] != v) Q.push_back(v), parent[v] = u;\\n  }\\n  for (int i = n - 1, u; i >= 0; --i) {\\n    u = Q[i];\\n    for (auto v : adj[u])\\n      if (parent[u] != v) {\\n        size[u] += size[v];\\n        if (heavy[u] == -1 || size[v] > size[heavy[u]]) heavy[u] = v;\\n      }\\n  }\\n  for (int u = 0; u < n; ++u)\\n    if (u == 0 || heavy[parent[u]] != u)\\n      for (int v = u; v != -1; v = heavy[v]) head[v] = u;\\n  int t = 0;\\n  vector<int> dt(n), ft(n);\\n  function<void(int, int)> dfs = [&](int u, int p) {\\n    dt[u] = ++t;\\n    for (auto v : adj[u])\\n      if (v != p) dfs(v, u);\\n    ft[u] = t;\\n  };\\n  dfs(0, -1);\\n  const int inv = Pow(n, mod - 2);\\n  bit b(n);\\n  vector<int> sum(n);\\n  for (int type, v, d; q--;) {\\n    cin >> type >> v, --v;\\n    if (type == 1) {\\n      cin >> d;\\n      const int mul = (long long)inv * d % mod;\\n      b.update(dt[v], dt[v], d);\\n      b.update(dt[0], ft[0], (long long)size[v] * mul % mod);\\n      b.update(dt[v], ft[v], mod - (long long)size[v] * mul % mod);\\n      int h = heavy[v];\\n      if (h != -1) b.update(dt[h],...\",\"language\":\"python\",\"split\":\"train\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"Mr. A, who will graduate next spring, decided to move when he got a job. The company that finds a job has offices in several towns, and the offices that go to work differ depending on the day. So Mr. A decided to live in a town where he had a short time to go to any office.\\n\\nSo you decided to find the most convenient town to live in to help Mr. A.\\n\\n<image>\\n\\n\\nTowns are numbered starting with 0 and there is a road between towns. Commuting time is fixed for each road. If Mr. A lives in a town, the commuting time to the office in his town is 0. At this time, consider the total commuting time to all towns. For example, if the layout of towns and roads is as shown in the figure above and Mr. A lives in town 1, the commuting time to each town will be\\n\\nTown 0 to 80\\n0 to town 1\\nUp to town 2 20\\nUp to town 3 70\\nTown 4 to 90\\n\\nAnd the sum is 260.\\n\\nEnter the number of roads and information on all roads, calculate the total commuting time when living in each town, and output the number of the town that minimizes it and the total commuting time at that time. Create a program. However, if there are multiple towns with the smallest total commuting time, please output the number of the smallest town and the total commuting time at that time. The total number of towns is 10 or less, the total number of roads is 45 or less, all roads can move in both directions, and commuting time does not change depending on the direction. We also assume that there are routes from any town to all other towns.\\n\\n\\n\\nInput\\n\\nA sequence of multiple datasets is given as input. The end of the input is indicated by a single line of zeros. Each dataset is given in the following format:\\n\\n\\nn\\na1 b1 c1\\na2 b2 c2\\n::\\nan bn cn\\n\\n\\nThe number of roads n (1 \u2264 n \u2264 45) is given on the first line. The following n lines give information on the i-th way. ai, bi (0 \u2264 ai, bi \u2264 9) is the number of the town to which the i-th road connects, and ci (0 \u2264 ci \u2264 100) is the commute time for that road.\\n\\nOutput\\n\\nFor each data set, the town number that minimizes the total commuting...\\\":\",\"targets\":\"using namespace std;\\n#include <iostream>\\n#include <string>\\n#include <set>\\n#include <functional>\\n#include <vector>\\n#include <algorithm>\\n#include <stdio.h>\\n#define INF 1<<12\\ntypedef pair<int,int> p;\\nint main()\\n{\\n\\tint n,d[10][10];\\n\\twhile(cin>>n&&n){\\n\\t\\tfill(d[0],d[10],INF);\\n\\t\\tint a,b,c;\\n\\t\\tfor(int i=0;i<n;i++){\\n\\t\\t\\tcin>>a>>b>>c;\\n\\t\\t\\td[a][b]=d[b][a]=c;\\n\\t\\t}\\n\\t\\tfor(int i=0;i<10;i++)d[i][i]=0;\\n\\t\\tfor(int k=0;k<10;k++)\\n\\t\\t\\tfor(int i=0;i<10;i++)\\n\\t\\t\\t\\tfor(int j=0;j<10;j++)\\n\\t\\t\\t\\t\\td[i][j]=min(d[i][j],d[i][k]+d[k][j]);\\n\\t\\tint ans[10]={};\\n\\t\\tvector<p> res;\\n\\t\\tfor(int i=0;i<10;i++)\\n\\t\\t\\tfor(int j=0;j<10;j++)\\n\\t\\t\\t\\tif(d[i][j]<INF)ans[i]+=d[i][j];\\n\\t\\tfor(int i=0;i<10;i++){\\n\\t\\t\\tif(ans[i]!=0)res.push_back(p(ans[i],i));\\n\\t\\t\\t\\/\\/printf(\\\"ans[%d]:%d\\\\n\\\",i,ans[i]);\\n\\t\\t}\\n\\t\\tsort(res.begin(),res.end());\\n\\t\\tcout<<res.front().second<<\\\" \\\"<<res.front().first<<endl;\\n\\t}\\n\\n    return 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"As a German University in Cairo (GUC) student and a basketball player, Herr Wafa was delighted once he heard the news. GUC is finally participating in the Annual Basketball Competition (ABC). \\n\\nA team is to be formed of n players, all of which are GUC students. However, the team might have players belonging to different departments. There are m departments in GUC, numbered from 1 to m. Herr Wafa's department has number h. For each department i, Herr Wafa knows number si \u2014 how many students who play basketball belong to this department.\\n\\nHerr Wafa was also able to guarantee a spot on the team, using his special powers. But since he hates floating-point numbers, he needs your help at finding the probability that he will have at least one teammate belonging to his department. \\n\\nNote that every possible team containing Herr Wafa is equally probable. Consider all the students different from each other.\\n\\nInput\\n\\nThe first line contains three integers n, m and h (1 \u2264 n \u2264 100, 1 \u2264 m \u2264 1000, 1 \u2264 h \u2264 m) \u2014 the number of players on the team, the number of departments in GUC and Herr Wafa's department, correspondingly. \\n\\nThe second line contains a single-space-separated list of m integers si (1 \u2264 si \u2264 100), denoting the number of students in the i-th department. Note that sh includes Herr Wafa.\\n\\nOutput\\n\\nPrint the probability that Herr Wafa will have at least one teammate from his department. If there is not enough basketball players in GUC to participate in ABC, print -1. The answer will be accepted if it has absolute or relative error not exceeding 10 - 6.\\n\\nExamples\\n\\nInput\\n\\n3 2 1\\n2 1\\n\\n\\nOutput\\n\\n1\\n\\n\\nInput\\n\\n3 2 1\\n1 1\\n\\n\\nOutput\\n\\n-1\\n\\n\\nInput\\n\\n3 2 1\\n2 2\\n\\n\\nOutput\\n\\n0.666667\\n\\nNote\\n\\nIn the first example all 3 players (2 from department 1 and 1 from department 2) must be chosen for the team. Both players from Wafa's departments will be chosen, so he's guaranteed to have a teammate from his department.\\n\\nIn the second example, there are not enough players.\\n\\nIn the third example, there are three possibilities to compose the team...\\nUsing java can you solve the prior task?\",\"targets\":\"import java.util.*;\\nimport java.math.*;\\npublic class Main {\\n    static int s[]=new int[1000];\\n    static int n,m,h;\\n    static int all=0;\\n    \\/**\\n     * @param args\\n     *\\/\\n    public static BigInteger f(int a,int b){\\n        BigInteger res=BigInteger.ONE;\\n        BigInteger k=new BigInteger(Integer.toString(a));\\n        BigInteger q=k.subtract(new BigInteger(Integer.toString(b)));\\n        for(;k.compareTo(q)>0;k=k.subtract(BigInteger.ONE)){\\n            res=res.multiply(k);\\n        }\\n        return res;\\n    }\\n    public static void main(String[] args) {\\n        Scanner sn=new Scanner(System.in);\\n        n=sn.nextInt();\\n        m=sn.nextInt();\\n        h=sn.nextInt();\\n        h--;\\n        for(int i=0;i<m;i++){\\n            s[i]=sn.nextInt();\\n            all+=s[i];\\n        }\\n        if(all<n){\\n            System.out.printf(\\\"-1.0\\\\n\\\");\\n            return;\\n        }\\n        BigInteger bi1,bi2;\\n        all--;\\n        s[h]--;n--;\\n        int k=s[h];\\n        bi1=f(all-k,n);\\n        bi2=f(all,n);\\n        bi1=bi2.subtract(bi1);\\n        BigDecimal q=new BigDecimal(bi1);\\n        BigDecimal r=new BigDecimal(bi2);\\n\\n        System.out.printf(\\\"%s\\\\n\\\",q.divide(r,40,BigDecimal.ROUND_DOWN).toString());\\n\\n    }\\n\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You have a string s and a chip, which you can place onto any character of this string. \\n\\nAfter placing the chip, you move it to the right several (maybe zero) times, i. e. you perform the following operation several times: if the current position of the chip is i, you move it to the position i + 1. Of course, moving the chip to the right is impossible if it is already in the last position.\\n\\nAfter moving the chip to the right, you move it to the left several (maybe zero) times, i. e. you perform the following operation several times: if the current position of the chip is i, you move it to the position i - 1. Of course, moving the chip to the left is impossible if it is already in the first position.\\n\\nWhen you place a chip or move it, you write down the character where the chip ends up after your action. For example, if s is abcdef, you place the chip onto the 3-rd character, move it to the right 2 times and then move it to the left 3 times, you write down the string cdedcb.\\n\\nYou are given two strings s and t. Your task is to determine whether it's possible to perform the described operations with s so that you write down the string t as a result.\\n\\nInput\\n\\nThe first line contains one integer q (1 \u2264 q \u2264 500) \u2014 the number of test cases.\\n\\nEach test case consists of two lines. The first line contains the string s (1 \u2264 |s| \u2264 500), the second line contains the string t (1 \u2264 |t| \u2264 2 \u22c5 |s| - 1). Both strings consist of lowercase English characters.\\n\\nIt is guaranteed that the sum of |s| over all test cases does not exceed 500.\\n\\nOutput\\n\\nFor each test case, print \\\"YES\\\" if you can obtain the string t by performing the process mentioned in the statement with the string s, or \\\"NO\\\" if you cannot.\\n\\nYou may print each letter in any case (YES, yes, Yes will all be recognized as positive answer, NO, no and nO will all be recognized as negative answer).\\n\\nExample\\n\\nInput\\n\\n\\n6\\nabcdef\\ncdedcb\\naaa\\naaaaa\\naab\\nbaaa\\nab\\nb\\nabcdef\\nabcdef\\nba\\nbaa\\n\\n\\nOutput\\n\\n\\nYES\\nYES\\nNO\\nYES\\nYES\\nNO\\n\\nNote\\n\\nConsider the examples.\\n\\nThe first test case is described in...\\nThe above is tricky. Write me a correct solution in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst long long N = 100005;\\nvoid solve() {\\n  string s, t, r;\\n  cin >> s >> t;\\n  long long i, n = s.size(), m = t.size();\\n  r = t;\\n  reverse(r.begin(), r.end());\\n  for (i = 0; i < n; i++) {\\n    long long j, l = min(n - i, m);\\n    for (j = 1; j <= l; j++) {\\n      string x = s.substr(i, j);\\n      string y = t.substr(0, j);\\n      if (x == y) {\\n        x = s.substr(i + j - 1 - min(m - j, i + j - 1), min(m - j, i + j - 1));\\n        y = r.substr(0, m - j);\\n        if (x == y) {\\n          cout << \\\"Yes\\\"\\n               << \\\"\\\\n\\\";\\n          return;\\n        }\\n      }\\n    }\\n  }\\n  cout << \\\"No\\\"\\n       << \\\"\\\\n\\\";\\n}\\nint32_t main() {\\n  ios_base::sync_with_stdio(0);\\n  cin.tie(NULL);\\n  cout.tie(NULL);\\n  long long t = 1;\\n  cin >> t;\\n  for (long long i = 1; i <= t; i++) {\\n    solve();\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You are given a permutation p of n elements. A permutation of n elements is an array of length n containing each integer from 1 to n exactly once. For example, [1, 2, 3] and [4, 3, 5, 1, 2] are permutations, but [1, 2, 4] and [4, 3, 2, 1, 2] are not permutations. You should perform q queries.\\n\\nThere are two types of queries:\\n\\n  * 1 x y \u2014 swap p_x and p_y. \\n  * 2 i k \u2014 print the number that i will become if we assign i = p_i k times. \\n\\nInput\\n\\nThe first line contains two integers n and q (1 \u2264 n, q \u2264 10^5).\\n\\nThe second line contains n integers p_1, p_2, ..., p_n.\\n\\nEach of the next q lines contains three integers. The first integer is t (1 \u2264 t \u2264 2) \u2014 type of query. If t = 1, then the next two integers are x and y (1 \u2264 x, y \u2264 n; x \u2260 y) \u2014 first-type query. If t = 2, then the next two integers are i and k (1 \u2264 i, k \u2264 n) \u2014 second-type query.\\n\\nIt is guaranteed that there is at least one second-type query.\\n\\nOutput\\n\\nFor every second-type query, print one integer in a new line \u2014 answer to this query.\\n\\nExamples\\n\\nInput\\n\\n\\n5 4\\n5 3 4 2 1\\n2 3 1\\n2 1 2\\n1 1 3\\n2 1 2\\n\\n\\nOutput\\n\\n\\n4\\n1\\n2\\n\\n\\nInput\\n\\n\\n5 9\\n2 3 5 1 4\\n2 3 5\\n2 5 5\\n2 5 1\\n2 5 3\\n2 5 4\\n1 5 4\\n2 5 3\\n2 2 5\\n2 5 1\\n\\n\\nOutput\\n\\n\\n3\\n5\\n4\\n2\\n3\\n3\\n3\\n1\\n\\nNote\\n\\nIn the first example p = \\\\{5, 3, 4, 2, 1\\\\}. \\n\\nThe first query is to print p_3. The answer is 4.\\n\\nThe second query is to print p_{p_1}. The answer is 1.\\n\\nThe third query is to swap p_1 and p_3. Now p = \\\\{4, 3, 5, 2, 1\\\\}.\\n\\nThe fourth query is to print p_{p_1}. The answer is 2.\\nUsing cpp can you solve the prior task?\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst int N = 100010;\\nconst int sq = 320;\\nint n, q, p[N], r[N], dp[N];\\nint f(int x) {\\n  for (int i = 0; i < sq; i++) x = p[x];\\n  return x;\\n}\\nint main() {\\n  ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);\\n  cin >> n >> q;\\n  for (int i = 1; i <= n; i++) {\\n    cin >> p[i];\\n    r[p[i]] = i;\\n  }\\n  for (int i = 1; i <= n; i++) dp[i] = f(i);\\n  while (q--) {\\n    int t, x, y;\\n    cin >> t >> x >> y;\\n    if (t == 1) {\\n      swap(p[x], p[y]);\\n      swap(r[p[x]], r[p[y]]);\\n      vector<int> v = {x, y};\\n      for (int au : v) {\\n        int nxt = f(au);\\n        for (int i = 0; i < sq; i++) {\\n          dp[au] = nxt;\\n          au = r[au];\\n          nxt = r[nxt];\\n        }\\n      }\\n    } else {\\n      while (y >= sq) {\\n        y -= sq;\\n        x = dp[x];\\n      }\\n      while (y--) x = p[x];\\n      cout << x << '\\\\n';\\n    }\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You are given a 1 by n pixel image. The i-th pixel of the image has color a_i. For each color, the number of pixels of that color is at most 20.\\n\\nYou can perform the following operation, which works like the bucket tool in paint programs, on this image: \\n\\n  * pick a color \u2014 an integer from 1 to n; \\n  * choose a pixel in the image; \\n  * for all pixels connected to the selected pixel, change their colors to the selected color (two pixels of the same color are considered connected if all the pixels between them have the same color as those two pixels). \\n\\n\\n\\nCompute the minimum number of operations needed to make all the pixels in the image have the same color.\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 10^3).\\n\\nThe first line of each test case contains a single integer n (1 \u2264 n \u2264 3\u22c510^3) \u2014 the number of pixels in the image.\\n\\nThe second line of each test case contains n integers a_1, a_2, \u2026, a_n (1 \u2264 a_i \u2264 n) \u2014 the colors of the pixels in the image.\\n\\nNote: for each color, the number of pixels of that color is at most 20.\\n\\nIt is guaranteed that the sum of n over all test cases does not exceed 3\u22c510^3.\\n\\nOutput\\n\\nFor each test case, print one integer: the minimum number of operations needed to make all the pixels in the image have the same color.\\n\\nExample\\n\\nInput\\n\\n\\n3\\n5\\n1 2 3 2 1\\n4\\n1 1 2 2\\n5\\n1 2 1 4 2\\n\\n\\nOutput\\n\\n\\n2\\n1\\n3\\n\\nNote\\n\\nIn the first example, the optimal solution is to apply the operation on the third pixel changing its color to 2 and then to apply the operation on any pixel that has color 2 changing its color and the color of all pixels connected to it to 1. The sequence of operations is then: [1, 2, 3, 2, 1] \u2192 [1, 2, 2, 2, 1] \u2192 [1, 1, 1, 1, 1].\\n\\nIn the second example, we can either change the 1s to 2s in one operation or change the 2s to 1s also in one operation.\\n\\nIn the third example, one possible way to make all the pixels have the same color is to apply the operation on the first, third and the fourth pixel each time changing its color to 2.\\nUsing cpp can you solve the prior task?\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconstexpr int N = 3e3;\\nuint16_t a[N], lst[N], nxt[N], cnxt[20], dp[N][N + 1];\\nint main() {\\n  cin.tie(0), ios::sync_with_stdio(0);\\n  int t, n;\\n  cin >> t;\\n  while (t--) {\\n    cin >> n;\\n    for (int i = 0; i < n; ++i) {\\n      cin >> a[i], --a[i];\\n    }\\n    memset(lst, 0, n * sizeof *lst);\\n    for (int i = 0; i < n; ++i) {\\n      ++lst[a[i]];\\n    }\\n    int w = -1, r = 0, purged = 0;\\n    while (r < n) {\\n      if (w >= 0 && a[w] == a[r]) {\\n        if (--lst[a[r++]] == 1) {\\n          --w;\\n          ++purged;\\n        }\\n      } else if (lst[a[r]] == 1) {\\n        ++r;\\n        ++purged;\\n      } else {\\n        a[++w] = a[r++];\\n      }\\n    }\\n    memset(lst, -1, n * sizeof *lst);\\n    n = w + 1;\\n    memset(nxt, 127, n * sizeof *nxt);\\n    for (int i = 0; i < n; ++i) {\\n      if (lst[a[i]] != (uint16_t)-1) {\\n        nxt[lst[a[i]]] = i;\\n      }\\n      lst[a[i]] = i;\\n    }\\n    for (int i = n - 1; i > -1; --i) {\\n      auto* cnxte = cnxt;\\n      for (int z = nxt[i]; z < n; z = nxt[z]) {\\n        *cnxte++ = z;\\n      }\\n      *cnxte = n;\\n      cnxte = cnxt;\\n      for (int j = i + 2; j <= n; ++j) {\\n        if (a[j - 1] == a[i]) {\\n          ++cnxte;\\n        }\\n        int t = dp[i + 1][j] - 1;\\n        for (const auto* z = cnxt; z < cnxte; ++z) {\\n          t = max(t, dp[i + 1][*z] + dp[*z][j]);\\n        }\\n        dp[i][j] = t + 1;\\n      }\\n    }\\n    cout << (n ? n - dp[0][n] : 0) - 1 + purged << '\\\\n';\\n  }\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Ashish and Vivek play a game on a matrix consisting of n rows and m columns, where they take turns claiming cells. Unclaimed cells are represented by 0, while claimed cells are represented by 1. The initial state of the matrix is given. There can be some claimed cells in the initial state.\\n\\nIn each turn, a player must claim a cell. A cell may be claimed if it is unclaimed and does not share a row or column with any other already claimed cells. When a player is unable to make a move, he loses and the game ends.\\n\\nIf Ashish and Vivek take turns to move and Ashish goes first, determine the winner of the game if both of them are playing optimally.\\n\\nOptimal play between two players means that both players choose the best possible strategy to achieve the best possible outcome for themselves.\\n\\nInput\\n\\nThe first line consists of a single integer t (1 \u2264 t \u2264 50) \u2014 the number of test cases. The description of the test cases follows.\\n\\nThe first line of each test case consists of two space-separated integers n, m (1 \u2264 n, m \u2264 50) \u2014 the number of rows and columns in the matrix.\\n\\nThe following n lines consist of m integers each, the j-th integer on the i-th line denoting a_{i,j} (a_{i,j} \u2208 \\\\{0, 1\\\\}).\\n\\nOutput\\n\\nFor each test case if Ashish wins the game print \\\"Ashish\\\" otherwise print \\\"Vivek\\\" (without quotes).\\n\\nExample\\n\\nInput\\n\\n\\n4\\n2 2\\n0 0\\n0 0\\n2 2\\n0 0\\n0 1\\n2 3\\n1 0 1\\n1 1 0\\n3 3\\n1 0 0\\n0 0 0\\n1 0 0\\n\\n\\nOutput\\n\\n\\nVivek\\nAshish\\nVivek\\nAshish\\n\\nNote\\n\\nFor the first case: One possible scenario could be: Ashish claims cell (1, 1), Vivek then claims cell (2, 2). Ashish can neither claim cell (1, 2), nor cell (2, 1) as cells (1, 1) and (2, 2) are already claimed. Thus Ashish loses. It can be shown that no matter what Ashish plays in this case, Vivek will win. \\n\\nFor the second case: Ashish claims cell (1, 1), the only cell that can be claimed in the first move. After that Vivek has no moves left.\\n\\nFor the third case: Ashish cannot make a move, so Vivek wins.\\n\\nFor the fourth case: If Ashish claims cell (2, 3), Vivek will have no moves left.\\nThe above is tricky. Write me a correct solution in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nlong long pow(long long a, long long b, long long m = 1000000007) {\\n  long long ans = 1;\\n  while (b) {\\n    if (b & 1) ans = (ans * a) % m;\\n    b \\/= 2;\\n    a = (a * a) % m;\\n  }\\n  return ans;\\n}\\nconst long long N = 200005;\\nlong long modInv(long long a, long long m) {\\n  a = a % m;\\n  for (long long x = 1; x < m; x++)\\n    if ((a * x) % m == 1) return x;\\n}\\nlong long modinv(long long a, long long m) { return pow(a, m - 2, m); }\\nvector<long long> g[N];\\nlong long vis[N] = {0};\\nlong long cnt = 0;\\nvoid dfs(long long src) {\\n  vis[src] = 1;\\n  for (auto x : g[src]) {\\n    if (!vis[x]) dfs(x);\\n  }\\n  cnt++;\\n}\\nvoid solve() {\\n  long long n, m;\\n  cin >> n >> m;\\n  long long a[n][m];\\n  for (long long i = 0; i < n; ++i)\\n    for (long long j = 0; j < m; ++j) cin >> a[i][j];\\n  long long row = 0;\\n  for (long long i = 0; i < n; ++i) {\\n    bool done = true;\\n    for (long long j = 0; j < m; ++j) {\\n      if (a[i][j] == 1 and done) {\\n        row++;\\n        done = false;\\n      }\\n    }\\n  }\\n  long long col = 0;\\n  for (long long i = 0; i < m; ++i) {\\n    bool done = true;\\n    for (long long j = 0; j < n; ++j) {\\n      if (a[j][i] == 1 and done == true) {\\n        col++;\\n        done = false;\\n      }\\n    }\\n  }\\n  cerr << row << col << \\\"\\\\n\\\";\\n  long long temp = min(n - row, m - col);\\n  (temp & 1) ? cout << \\\"Ashish\\\" : cout << \\\"Vivek\\\";\\n  cout << \\\"\\\\n\\\";\\n}\\nint32_t main() {\\n  ios_base::sync_with_stdio(0);\\n  cin.tie(0);\\n  cout.tie(0);\\n  long long x;\\n  cin >> x;\\n  while (x--) {\\n    solve();\\n  }\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Alice and Bob play the following game. Alice has a set S of disjoint ranges of integers, initially containing only one range [1, n]. In one turn, Alice picks a range [l, r] from the set S and asks Bob to pick a number in the range. Bob chooses a number d (l \u2264 d \u2264 r). Then Alice removes [l, r] from S and puts into the set S the range [l, d - 1] (if l \u2264 d - 1) and the range [d + 1, r] (if d + 1 \u2264 r). The game ends when the set S is empty. We can show that the number of turns in each game is exactly n.\\n\\nAfter playing the game, Alice remembers all the ranges [l, r] she picked from the set S, but Bob does not remember any of the numbers that he picked. But Bob is smart, and he knows he can find out his numbers d from Alice's ranges, and so he asks you for help with your programming skill.\\n\\nGiven the list of ranges that Alice has picked ([l, r]), for each range, help Bob find the number d that Bob has picked.\\n\\nWe can show that there is always a unique way for Bob to choose his number for a list of valid ranges picked by Alice.\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 1000). Description of the test cases follows.\\n\\nThe first line of each test case contains a single integer n (1 \u2264 n \u2264 1000).\\n\\nEach of the next n lines contains two integers l and r (1 \u2264 l \u2264 r \u2264 n), denoting the range [l, r] that Alice picked at some point.\\n\\nNote that the ranges are given in no particular order.\\n\\nIt is guaranteed that the sum of n over all test cases does not exceed 1000, and the ranges for each test case are from a valid game.\\n\\nOutput\\n\\nFor each test case print n lines. Each line should contain three integers l, r, and d, denoting that for Alice's range [l, r] Bob picked the number d.\\n\\nYou can print the lines in any order. We can show that the answer is unique.\\n\\nIt is not required to print a new line after each test case. The new lines in the output of the example are for readability only. \\n\\nExample\\n\\nInput\\n\\n\\n4\\n1\\n1 1\\n3\\n1 3\\n2 3\\n2 2\\n6\\n1 1\\n3 5\\n4 4\\n3 6\\n4 5\\n1 6\\n5\\n1 5\\n1 2\\n4 5\\n2...\\nSolve the task in PYTHON3.\",\"targets\":\"for _ in range(int(input())):\\n    n = int(input())\\n    l = []\\n    for i in range(n):\\n        l.append(list(map(int, input().split())))\\n    if n == 1:\\n        print(1, 1, 1)\\n        print()\\n        continue\\n    l.sort(key= lambda x:abs(x[0] - x[1]))\\n    used = [0]*(n+1)\\n    for i in range(n):\\n        for ind in range(l[i][0], l[i][1]+1):\\n            if used[ind] == 0:\\n                used[ind] = 1\\n                l[i].append(ind)\\n                break\\n    for i in l:\\n        print(*i)\\n    print()\",\"language\":\"python\",\"split\":\"test\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"This is the easy version of the problem. The only difference between the two versions is the constraint on n. You can make hacks only if all versions of the problem are solved.\\n\\nA forest is an undirected graph without cycles (not necessarily connected).\\n\\nMocha and Diana are friends in Zhijiang, both of them have a forest with nodes numbered from 1 to n, and they would like to add edges to their forests such that: \\n\\n  * After adding edges, both of their graphs are still forests. \\n  * They add the same edges. That is, if an edge (u, v) is added to Mocha's forest, then an edge (u, v) is added to Diana's forest, and vice versa. \\n\\n\\n\\nMocha and Diana want to know the maximum number of edges they can add, and which edges to add.\\n\\nInput\\n\\nThe first line contains three integers n, m_1 and m_2 (1 \u2264 n \u2264 1000, 0 \u2264 m_1, m_2 < n) \u2014 the number of nodes and the number of initial edges in Mocha's forest and Diana's forest.\\n\\nEach of the next m_1 lines contains two integers u and v (1 \u2264 u, v \u2264 n, u \u2260 v) \u2014 the edges in Mocha's forest.\\n\\nEach of the next m_2 lines contains two integers u and v (1 \u2264 u, v \u2264 n, u \u2260 v) \u2014 the edges in Diana's forest.\\n\\nOutput\\n\\nThe first line contains only one integer h, the maximum number of edges Mocha and Diana can add (in each forest).\\n\\nEach of the next h lines contains two integers u and v (1 \u2264 u, v \u2264 n, u \u2260 v) \u2014 the edge you add each time.\\n\\nIf there are multiple correct answers, you can print any one of them.\\n\\nExamples\\n\\nInput\\n\\n\\n3 2 2\\n1 2\\n2 3\\n1 2\\n1 3\\n\\n\\nOutput\\n\\n\\n0\\n\\n\\nInput\\n\\n\\n5 3 2\\n5 4\\n2 1\\n4 3\\n4 3\\n1 4\\n\\n\\nOutput\\n\\n\\n1\\n2 4\\n\\n\\nInput\\n\\n\\n8 1 2\\n1 7\\n2 6\\n1 5\\n\\n\\nOutput\\n\\n\\n5\\n5 2\\n2 3\\n3 4\\n4 7\\n6 8\\n\\nNote\\n\\nIn the first example, we cannot add any edge.\\n\\nIn the second example, the initial forests are as follows.\\n\\n<image>\\n\\nWe can add an edge (2, 4).\\n\\n<image>\\n\\nimpo\",\"targets\":\"rt java.util.*;\\nimport java.util.Map.Entry;\\nimport java.lang.*;\\nimport java.io.*;\\nimport java.math.BigInteger;\\n\\npublic class CF {\\n\\tprivate static FS sc = new FS();\\n\\t\\n\\tprivate static class FS {\\n\\t\\tBufferedReader br = new BufferedReader(new InputStreamReader(System.in));\\n\\t\\tStringTokenizer st = new StringTokenizer(\\\"\\\");\\n\\t\\tString next() {\\n\\t\\t\\twhile (!st.hasMoreTokens())\\n\\t\\t\\t\\ttry {\\n\\t\\t\\t\\t\\tst=new StringTokenizer(br.readLine());\\t\\t\\t\\t               \\n\\t            } catch (IOException e) {}\\n\\t\\t\\treturn st.nextToken();\\n\\t\\t}\\n\\t\\t\\n\\t\\tint nextInt() {\\n\\t\\t\\treturn Integer.parseInt(next());\\n\\t\\t}\\n\\t\\tlong nextLong() {\\n\\t\\t\\treturn Long.parseLong(next());\\n\\t\\t}\\n\\t}\\n\\t\\n\\tprivate static class extra {\\n\\t\\t\\n\\t\\tstatic int[] intArr(int size) {\\n\\t\\t\\tint[] a = new int[size];\\n\\t\\t\\tfor(int i = 0; i < size; i++) a[i] = sc.nextInt();\\n\\t\\t\\treturn a;\\n\\t\\t}\\n\\t\\t\\n\\t\\tstatic long[] longArr(int size) {\\n\\t\\t\\tlong[] a = new long[size];\\n\\t\\t\\tfor(int i = 0; i < size; i++) a[i] = sc.nextLong();\\n\\t\\t\\treturn a;\\n\\t\\t}\\n\\t\\t\\n\\t\\tstatic long intSum(int[] a) {\\n\\t\\t\\tlong sum = 0; \\n\\t\\t\\tfor(int i = 0; i < a.length; i++) {\\n\\t\\t\\t\\tsum += a[i];\\n\\t\\t\\t}\\n\\t\\t\\treturn sum;\\n\\t\\t}\\n\\t\\t\\n\\t\\tstatic long longSum(long[] a) {\\n\\t\\t\\tlong sum = 0; \\n\\t\\t\\tfor(int i = 0; i < a.length; i++) {\\n\\t\\t\\t\\tsum += a[i];\\n\\t\\t\\t}\\n\\t\\t\\treturn sum;\\n\\t\\t}\\n\\t\\t\\n\\t\\tstatic LinkedList[] graphD(int vertices, int edges) {\\n\\t\\t\\tLinkedList<Integer>[] temp = new LinkedList[vertices+1];\\n\\t\\t\\tfor(int i = 0; i <= vertices; i++) temp[i] = new LinkedList<>();\\n\\t\\t\\tfor(int i = 0; i < edges; i++) {\\n\\t\\t\\t\\tint x = sc.nextInt();\\n\\t\\t\\t\\tint y = sc.nextInt();\\n\\t\\t\\t\\ttemp[x].add(y);\\n\\t\\t\\t}\\n\\t\\t\\treturn temp;\\n\\t\\t}\\n\\t\\t\\n\\t\\tstatic LinkedList[] graphUD(int vertices, int edges) {\\n\\t\\t\\tLinkedList<Integer>[] temp = new LinkedList[vertices+1];\\n\\t\\t\\tfor(int i = 0; i <= vertices; i++) temp[i] = new LinkedList<>();\\n\\t\\t\\tfor(int i = 0; i < edges; i++) {\\n\\t\\t\\t\\tint x = sc.nextInt();\\n\\t\\t\\t\\tint y = sc.nextInt();\\n\\t\\t\\t\\ttemp[x].add(y);\\n\\t\\t\\t\\ttemp[y].add(x);\\n\\t\\t\\t}\\n\\t\\t\\treturn temp;\\n\\t\\t}\\n\\t\\t\\n\\t\\tstatic void printG(LinkedList[] temp) {\\n\\t\\t\\tfor(LinkedList<Integer> aa:temp) System.out.println(aa);\\n\\t\\t}\\n\\t\\t\\n\\t\\tstatic long cal(long val, long pow) {\\n\\t\\t\\tif(pow == 0) return...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Anton likes to play chess, and so does his friend Danik.\\n\\nOnce they have played n games in a row. For each game it's known who was the winner \u2014 Anton or Danik. None of the games ended with a tie.\\n\\nNow Anton wonders, who won more games, he or Danik? Help him determine this.\\n\\nInput\\n\\nThe first line of the input contains a single integer n (1 \u2264 n \u2264 100 000) \u2014 the number of games played.\\n\\nThe second line contains a string s, consisting of n uppercase English letters 'A' and 'D' \u2014 the outcome of each of the games. The i-th character of the string is equal to 'A' if the Anton won the i-th game and 'D' if Danik won the i-th game.\\n\\nOutput\\n\\nIf Anton won more games than Danik, print \\\"Anton\\\" (without quotes) in the only line of the output.\\n\\nIf Danik won more games than Anton, print \\\"Danik\\\" (without quotes) in the only line of the output.\\n\\nIf Anton and Danik won the same number of games, print \\\"Friendship\\\" (without quotes).\\n\\nExamples\\n\\nInput\\n\\n6\\nADAAAA\\n\\n\\nOutput\\n\\nAnton\\n\\n\\nInput\\n\\n7\\nDDDAADA\\n\\n\\nOutput\\n\\nDanik\\n\\n\\nInput\\n\\n6\\nDADADA\\n\\n\\nOutput\\n\\nFriendship\\n\\nNote\\n\\nIn the first sample, Anton won 6 games, while Danik \u2014 only 1. Hence, the answer is \\\"Anton\\\".\\n\\nIn the second sample, Anton won 3 games and Danik won 4 games, so the answer is \\\"Danik\\\".\\n\\nIn the third sample, both Anton and Danik won 3 games and the answer is \\\"Friendship\\\".\\nUsing python3 can you solve the prior task?\",\"targets\":\"'''\\ndef main():\\n    from sys import stdin,stdout\\n    n=int(stdin.readline())\\nif __name__=='__main__':\\n    main()\\n'''\\n#372\\n#1\\n'''\\ndef main():\\n    from sys import stdin,stdout\\n    n,c=map(int,stdin.readline().split())\\n    tup=tuple(map(int,stdin.readline().split()))\\n    counter=1\\n    for i in range(1,n):\\n        if tup[i]-tup[i-1]<=c:\\n            counter+=1\\n        else:\\n            counter=1\\n    stdout.write(str(counter))\\nif __name__=='__main__':\\n    main()\\n'''\\n#2\\n'''\\ndef main():\\n    from sys import stdin,stdout\\n    s=stdin.readline().strip().lower()\\n    dic={}\\n    qcounter=0\\n    for i in 'qwertyuiopasdfghjklzxcvbnm':\\n        dic[i]=0\\n    if len(s)<26:\\n        stdout.write('-1')\\n    else:\\n        for i in s:\\n            if i=='?':\\n                qcounter+=1\\n            else:\\n                dic[i]+=1\\n        l=[]\\n        x=list(dic.values()).count(0)\\n        if qcounter==26 and x==26:\\n            stdout.write('qwertyuiopasdfghjklzxcvbnm'.upper())\\n        elif x==0 and qcounter==0:\\n            stdout.write(s.upper())\\n        elif qcounter>=x:\\n            for i in 'qwertyuiopasdfghjklzxcvbnm':\\n                if dic[i]==0:\\n                    l.append(i.upper())\\n            m=len(l)\\n            i=0\\n            t=''\\n            for j in range(len(s)):\\n                if s[j]=='?':\\n                    if i>=m:\\n                        i=0\\n                    t=t[:j]+l[i]\\n                    i+=1\\n                else:\\n                    t+=s[j].upper()\\n            stdout.write(t)\\n        else:\\n            stdout.write('-1')\\nif __name__=='__main__':\\n    main()\\n'''\\n#373\\n#1\\n'''\\ndef main():\\n    from sys import stdin,stdout\\n    n=int(stdin.readline())\\n    tup=tuple(map(int,stdin.readline().split()))\\n    if n==1:\\n        if tup[0]==0:\\n            stdout.write('UP')\\n        elif tup[0]==15:\\n            stdout.write('DOWN')\\n        else:\\n            stdout.write('-1')\\n    else:\\n        if tup[-1]-tup[-2]>0:\\n            if tup[-1]==15:\\n                stdout.write('DOWN')\\n            else:\\n               ...\",\"language\":\"python\",\"split\":\"train\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Akari has n kinds of flowers, one of each kind.\\n\\nShe is going to choose one or more of these flowers to make a bouquet.\\n\\nHowever, she hates two numbers a and b, so the number of flowers in the bouquet cannot be a or b.\\n\\nHow many different bouquets are there that Akari can make?\\n\\nFind the count modulo (10^9 + 7).\\n\\nHere, two bouquets are considered different when there is a flower that is used in one of the bouquets but not in the other bouquet.\\n\\nConstraints\\n\\n* All values in input are integers.\\n* 2 \\\\leq n \\\\leq 10^9\\n* 1 \\\\leq a < b \\\\leq \\\\textrm{min}(n, 2 \\\\times 10^5)\\n\\nInput\\n\\nInput is given from Standard Input in the following format:\\n\\n\\nn a b\\n\\n\\nOutput\\n\\nPrint the number of bouquets that Akari can make, modulo (10^9 + 7). (If there are no such bouquets, print `0`.)\\n\\nExamples\\n\\nInput\\n\\n4 1 3\\n\\n\\nOutput\\n\\n7\\n\\n\\nInput\\n\\n1000000000 141421 173205\\n\\n\\nOutput\\n\\n34076506\\nimpor\",\"targets\":\"t java.util.*;\\n\\npublic class Main{\\n  static int p = 1000000007;\\n  public static void main(String[] args){\\n    Scanner sc = new Scanner(System.in);\\n    int N = sc.nextInt();\\n    int a = sc.nextInt();\\n    int b = sc.nextInt();\\n\\n    long ans = 0;\\n    long n = inv(2, N);\\n    if(n != 0) n -= 1;\\n    long c = 1;\\n    long n1 = 1;\\n    for(int i = 0; i < a; i++){\\n      n1 *= N-i;\\n      n1 %= p;\\n      c *= a-i;\\n      c %= p;\\n    }\\n    \\n    long d = 1;\\n    long n2 = 1;\\n    for(int i = 0; i < b; i++){\\n      n2 *= N-i;\\n      n2 %= p;\\n      d *= b-i;\\n      d %= p;\\n    }\\n    \\n    \\n    n -= (n1 * inv(c,p-2) % p);\\n    n -= (n2 * inv(d,p-2) % p);\\n    while(n < 0){\\n      n += p;\\n    }\\n    System.out.println(n);\\n  }\\n  \\n  public static long inv(long n, int k){\\n    if(k == 0){\\n      return 1;\\n    }\\n    \\n    if(k%2 == 0){\\n      long l = inv(n, k\\/2);\\n      return l * l % p;\\n    }else{\\n      return n * inv(n, k-1) % p;\\n    }\\n  }\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Another programming contest is over. You got hold of the contest's final results table. The table has the following data. For each team we are shown two numbers: the number of problems and the total penalty time. However, for no team we are shown its final place.\\n\\nYou know the rules of comparing the results of two given teams very well. Let's say that team a solved pa problems with total penalty time ta and team b solved pb problems with total penalty time tb. Team a gets a higher place than team b in the end, if it either solved more problems on the contest, or solved the same number of problems but in less total time. In other words, team a gets a higher place than team b in the final results' table if either pa > pb, or pa = pb and ta < tb. \\n\\nIt is considered that the teams that solve the same number of problems with the same penalty time share all corresponding places. More formally, let's say there is a group of x teams that solved the same number of problems with the same penalty time. Let's also say that y teams performed better than the teams from this group. In this case all teams from the group share places y + 1, y + 2, ..., y + x. The teams that performed worse than the teams from this group, get their places in the results table starting from the y + x + 1-th place.\\n\\nYour task is to count what number of teams from the given list shared the k-th place. \\n\\nInput\\n\\nThe first line contains two integers n and k (1 \u2264 k \u2264 n \u2264 50). Then n lines contain the description of the teams: the i-th line contains two integers pi and ti (1 \u2264 pi, ti \u2264 50) \u2014 the number of solved problems and the total penalty time of the i-th team, correspondingly. All numbers in the lines are separated by spaces. \\n\\nOutput\\n\\nIn the only line print the sought number of teams that got the k-th place in the final results' table.\\n\\nExamples\\n\\nInput\\n\\n7 2\\n4 10\\n4 10\\n4 10\\n3 20\\n2 1\\n2 1\\n1 10\\n\\n\\nOutput\\n\\n3\\n\\n\\nInput\\n\\n5 4\\n3 1\\n3 1\\n5 3\\n3 1\\n3 1\\n\\n\\nOutput\\n\\n4\\n\\nNote\\n\\nThe final results' table for the first sample is: \\n\\n  * 1-3 places \u2014 4 solved problems, the...\\nUsing cpp can you solve the prior task?\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint main() {\\n  int n, k;\\n  cin >> n >> k;\\n  vector<pair<int, int> > vec;\\n  for (int i = 0; i < n; i++) {\\n    int a, b;\\n    cin >> a >> b;\\n    vec.push_back(make_pair(100 - a, b));\\n  }\\n  sort(vec.begin(), vec.end());\\n  pair<int, int> tmp;\\n  tmp = vec[k - 1];\\n  int cnt = 0;\\n  for (int i = 0; i < n; i++) {\\n    if (tmp == vec[i]) {\\n      cnt++;\\n    }\\n  }\\n  cout << cnt;\\n  cin >> cnt;\\n  return 0;\\n};\",\"language\":\"python\",\"split\":\"train\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You are given n integers a_1, a_2, \u2026, a_n. Find the maximum value of max(a_l, a_{l + 1}, \u2026, a_r) \u22c5 min(a_l, a_{l + 1}, \u2026, a_r) over all pairs (l, r) of integers for which 1 \u2264 l < r \u2264 n.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 10 000) \u2014 the number of test cases.\\n\\nThe first line of each test case contains a single integer n (2 \u2264 n \u2264 10^5).\\n\\nThe second line of each test case contains n integers a_1, a_2, \u2026, a_n (1 \u2264 a_i \u2264 10^6).\\n\\nIt is guaranteed that the sum of n over all test cases doesn't exceed 3 \u22c5 10^5.\\n\\nOutput\\n\\nFor each test case, print a single integer \u2014 the maximum possible value of the product from the statement.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n3\\n2 4 3\\n4\\n3 2 3 1\\n2\\n69 69\\n6\\n719313 273225 402638 473783 804745 323328\\n\\n\\nOutput\\n\\n\\n12\\n6\\n4761\\n381274500335\\n\\nNote\\n\\nLet f(l, r) = max(a_l, a_{l + 1}, \u2026, a_r) \u22c5 min(a_l, a_{l + 1}, \u2026, a_r).\\n\\nIn the first test case, \\n\\n  * f(1, 2) = max(a_1, a_2) \u22c5 min(a_1, a_2) = max(2, 4) \u22c5 min(2, 4) = 4 \u22c5 2 = 8. \\n  * f(1, 3) = max(a_1, a_2, a_3) \u22c5 min(a_1, a_2, a_3) = max(2, 4, 3) \u22c5 min(2, 4, 3) = 4 \u22c5 2 = 8. \\n  * f(2, 3) = max(a_2, a_3) \u22c5 min(a_2, a_3) = max(4, 3) \u22c5 min(4, 3) = 4 \u22c5 3 = 12. \\n\\n\\n\\nSo the maximum is f(2, 3) = 12.\\n\\nIn the second test case, the maximum is f(1, 2) = f(1, 3) = f(2, 3) = 6.\\n#----\",\"targets\":\"------FASTIOSTART-----------#\\n\\nfrom __future__ import division, print_function\\nimport os\\nimport sys\\nfrom io import BytesIO, IOBase\\nif sys.version_info[0] < 3:\\n\\tfrom __builtin__ import xrange as range\\n\\tfrom future_builtins import ascii, filter, hex, map, oct, zip\\nBUFSIZE = 8192\\nclass FastIO(IOBase):\\n\\tnewlines = 0\\n\\tdef __init__(self, file):\\n\\t\\tself._fd = file.fileno()\\n\\t\\tself.buffer = BytesIO()\\n\\t\\tself.writable = \\\"x\\\" in file.mode or \\\"r\\\" not in file.mode\\n\\t\\tself.write = self.buffer.write if self.writable else None\\n\\tdef read(self):\\n\\t\\twhile True:\\n\\t\\t\\tb = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))\\n\\t\\t\\tif not b:\\n\\t\\t\\t\\tbreak\\n\\t\\t\\tptr = self.buffer.tell()\\n\\t\\t\\tself.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)\\n\\t\\tself.newlines = 0\\n\\t\\treturn self.buffer.read()\\n\\tdef readline(self):\\n\\t\\twhile self.newlines == 0:\\n\\t\\t\\tb = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))\\n\\t\\t\\tself.newlines = b.count(b\\\"\\\\n\\\") + (not b)\\n\\t\\t\\tptr = self.buffer.tell()\\n\\t\\t\\tself.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)\\n\\t\\tself.newlines -= 1\\n\\t\\treturn self.buffer.readline()\\n\\tdef flush(self):\\n\\t\\tif self.writable:\\n\\t\\t\\tos.write(self._fd, self.buffer.getvalue())\\n\\t\\t\\tself.buffer.truncate(0), self.buffer.seek(0)\\nclass IOWrapper(IOBase):\\n\\tdef __init__(self, file):\\n\\t\\tself.buffer = FastIO(file)\\n\\t\\tself.flush = self.buffer.flush\\n\\t\\tself.writable = self.buffer.writable\\n\\t\\tself.write = lambda s: self.buffer.write(s.encode(\\\"ascii\\\"))\\n\\t\\tself.read = lambda: self.buffer.read().decode(\\\"ascii\\\")\\n\\t\\tself.readline = lambda: self.buffer.readline().decode(\\\"ascii\\\")\\ndef print(*args, **kwargs):\\n\\tsep, file = kwargs.pop(\\\"sep\\\", \\\" \\\"), kwargs.pop(\\\"file\\\", sys.stdout)\\n\\tat_start = True\\n\\tfor x in args:\\n\\t\\tif not at_start:\\n\\t\\t\\tfile.write(sep)\\n\\t\\tfile.write(str(x))\\n\\t\\tat_start = False\\n\\tfile.write(kwargs.pop(\\\"end\\\", \\\"\\\\n\\\"))\\n\\tif kwargs.pop(\\\"flush\\\", False):\\n\\t\\tfile.flush()\\nif sys.version_info[0] < 3:\\n\\tsys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)\\nelse:\\n\\tsys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)\\ninput = lambda:...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Bash has set out on a journey to become the greatest Pokemon master. To get his first Pokemon, he went to Professor Zulu's Lab. Since Bash is Professor Zulu's favourite student, Zulu allows him to take as many Pokemon from his lab as he pleases.\\n\\nBut Zulu warns him that a group of k > 1 Pokemon with strengths {s1, s2, s3, ..., sk} tend to fight among each other if gcd(s1, s2, s3, ..., sk) = 1 (see notes for gcd definition).\\n\\nBash, being smart, does not want his Pokemon to fight among each other. However, he also wants to maximize the number of Pokemon he takes from the lab. Can you help Bash find out the maximum number of Pokemon he can take? \\n\\nNote: A Pokemon cannot fight with itself.\\n\\nInput\\n\\nThe input consists of two lines.\\n\\nThe first line contains an integer n (1 \u2264 n \u2264 105), the number of Pokemon in the lab.\\n\\nThe next line contains n space separated integers, where the i-th of them denotes si (1 \u2264 si \u2264 105), the strength of the i-th Pokemon.\\n\\nOutput\\n\\nPrint single integer \u2014 the maximum number of Pokemons Bash can take.\\n\\nExamples\\n\\nInput\\n\\n3\\n2 3 4\\n\\n\\nOutput\\n\\n2\\n\\n\\nInput\\n\\n5\\n2 3 4 6 7\\n\\n\\nOutput\\n\\n3\\n\\nNote\\n\\ngcd (greatest common divisor) of positive integers set {a1, a2, ..., an} is the maximum positive integer that divides all the integers {a1, a2, ..., an}.\\n\\nIn the first sample, we can take Pokemons with strengths {2, 4} since gcd(2, 4) = 2.\\n\\nIn the second sample, we can take Pokemons with strengths {2, 4, 6}, and there is no larger group with gcd \u2260 1.\\nThe above is tricky. Write me a correct solution in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst int MAXN = 1e5 + 5;\\nbool seive[MAXN + 4];\\nint m[MAXN];\\nvector<vector<int> > g(MAXN + 4);\\nvoid func() {\\n  for (int i = 2; i <= MAXN; i++)\\n    if (!seive[i])\\n      for (int j = 2; j * i <= MAXN; j++) {\\n        seive[i * j] = true;\\n        g[i * j].push_back(i);\\n      }\\n  for (int i = 2; i <= MAXN; i++) {\\n    if (!seive[i]) g[i].push_back(i);\\n  }\\n}\\nint main() {\\n  func();\\n  int n;\\n  cin >> n;\\n  vector<int> a(n);\\n  for (int i = 0; i < n; i++) scanf(\\\"%d\\\", &a[i]);\\n  for (int i = 0; i < n; i++)\\n    for (int j = 0; j < g[a[i]].size(); j++) {\\n      m[g[a[i]][j]]++;\\n    }\\n  int ans = 0;\\n  for (int i = 0; i < MAXN; i++) ans = max(ans, m[i]);\\n  cout << max(1, ans);\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in CPP?\\nImagine a real contest or exam of n participants. Every participant will get a particular score. We can predict the standings board more or less, if we do some statistics on their previous performance.\\n\\n<image>\\n\\nLet's say the score of the participants will be uniformly distributed in interval [li, ri] (the score can be a real number). Can you predict the standings board according to these data? In other words you should say for each participant the probability that he gets some fixed place in the scoreboard. The participants are sorted by increasing of their scores in the scoreboard. So, the participant with the largest score gets the last place.\\n\\nInput\\n\\nThe first line contains integer n (1 \u2264 n \u2264 80), showing how many participants we have. Each of the next n lines contains our predictions, the i-th line contains a pair of integers li, ri (0 \u2264 li < ri \u2264 109) as the distributed interval for participant i.\\n\\nConsider the participants numbered from 1 to n in some way.\\n\\nOutput\\n\\nOutput a distributed matrix a of order n. The element aij of the matrix is the probability that participant i has rank j.\\n\\nYour answer will considered correct if it has at most 10 - 6 absolute or relative error.\\n\\nExamples\\n\\nInput\\n\\n2\\n1 6\\n4 9\\n\\n\\nOutput\\n\\n0.9200000000 0.080 \\n0.080 0.9200000000 \\n\\n\\nInput\\n\\n8\\n0 2\\n1 3\\n2 4\\n3 5\\n4 6\\n5 7\\n6 8\\n7 9\\n\\n\\nOutput\\n\\n0.875 0.125 0 0 0 0 0 0 \\n0.125 0.750 0.125 0 0 0 0 0 \\n0 0.125 0.750 0.125 0 0 0 0 \\n0 0 0.125 0.750 0.125 0 0 0 \\n0 0 0 0.125 0.750 0.125 0 0 \\n0 0 0 0 0.125 0.750 0.125 0 \\n0 0 0 0 0 0.125 0.750 0.125 \\n0 0 0 0 0 0 0.125 0.875 \\n\\nNote\\n\\nThe score probability distribution is continuous, which means, there is no possibility for a draw.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst int N = 85;\\nint n, V, now;\\nint sl[N], sr[N], lens[N], h[N * 2];\\ndouble ans[N][N];\\nvoid add(int x, int l, int r, double y) {\\n  ans[x][l] += y;\\n  ans[x][r + 1] -= y;\\n}\\nvoid trans(int x, int c, double F[N][N]) {\\n  double g0 =\\n      sr[x] > now + 1 ? 1.0 * (h[sr[x]] - h[max(now + 1, sl[x])]) \\/ lens[x] : 0;\\n  double g1 = sl[x] < now ? 1.0 * (h[min(now, sr[x])] - h[sl[x]]) \\/ lens[x] : 0;\\n  double g2 =\\n      sl[x] <= now && sr[x] > now ? 1.0 * (h[now + 1] - h[now]) \\/ lens[x] : 0;\\n  for (int k = c + 1; k >= 1; k--) {\\n    for (int t = c + 1 - k; t >= 1; t--)\\n      F[k][t] = F[k][t] * g0 + F[k - 1][t] * g1 + F[k][t - 1] * g2;\\n    F[k][0] = F[k][0] * g0 + F[k - 1][0] * g1;\\n  }\\n  for (int t = c + 1; t >= 1; t--) F[0][t] = F[0][t] * g0 + F[0][t - 1] * g2;\\n  F[0][0] *= g0;\\n}\\nvoid solve(int l, int r, double F[N][N]) {\\n  bool intersect = 0;\\n  for (int i = l; i <= r; i++)\\n    if (sl[i] <= now && sr[i] > now) {\\n      intersect = 1;\\n      break;\\n    }\\n  if (!intersect) return;\\n  if (l == r) {\\n    double pn = 1.0 * (h[now + 1] - h[now]) \\/ lens[l];\\n    for (int k = 0; k < n; k++)\\n      for (int t = 0; k + t < n; t++)\\n        add(l, k + 1, k + t + 1, F[k][t] * pn \\/ (t + 1));\\n    return;\\n  }\\n  int mid = (l + r) >> 1;\\n  double FH[N][N];\\n  memcpy(FH, F, sizeof(FH));\\n  for (int i = r; i > mid; i--) trans(i, n - (i - l + 1), F);\\n  solve(l, mid, F);\\n  for (int i = l; i <= mid; i++) trans(i, n - (r - i + 1), FH);\\n  solve(mid + 1, r, FH);\\n}\\nint main() {\\n  scanf(\\\"%d\\\", &n);\\n  for (int i = 1; i <= n; i++) scanf(\\\"%d%d\\\", sl + i, sr + i);\\n  for (int i = 1; i <= n; i++)\\n    lens[i] = sr[i] - sl[i], h[++V] = sl[i], h[++V] = sr[i];\\n  sort(h + 1, h + V + 1);\\n  V = unique(h + 1, h + V + 1) - (h + 1);\\n  for (int i = 1; i <= n; i++)\\n    sl[i] = lower_bound(h + 1, h + V + 1, sl[i]) - h,\\n    sr[i] = lower_bound(h + 1, h + V + 1, sr[i]) - h;\\n  for (now = 1; now < V; now++) {\\n    double tmpf[N][N];\\n    memset(tmpf, 0, sizeof(tmpf));\\n    tmpf[0][0] = 1;\\n    solve(1, n, tmpf);\\n  }\\n  for (int i = 1; i <= n;...\",\"language\":\"python\",\"split\":\"train\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"There are n points and m segments on the coordinate line. The initial coordinate of the i-th point is a_i. The endpoints of the j-th segment are l_j and r_j \u2014 left and right endpoints, respectively.\\n\\nYou can move the points. In one move you can move any point from its current coordinate x to the coordinate x - 1 or the coordinate x + 1. The cost of this move is 1.\\n\\nYou should move the points in such a way that each segment is visited by at least one point. A point visits the segment [l, r] if there is a moment when its coordinate was on the segment [l, r] (including endpoints).\\n\\nYou should find the minimal possible total cost of all moves such that all segments are visited.\\n\\nInput\\n\\nThe input consists of multiple test cases. The first line contains a single integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases. Description of the test cases follows.\\n\\nThe first line of each test case contains two integers n and m (1 \u2264 n, m \u2264 2 \u22c5 10^5) \u2014 the number of points and segments respectively.\\n\\nThe next line contains n distinct integers a_1, a_2, \u2026, a_n (-10^9 \u2264 a_i \u2264 10^9) \u2014 the initial coordinates of the points.\\n\\nEach of the next m lines contains two integers l_j, r_j (-10^9 \u2264 l_j \u2264 r_j \u2264 10^9) \u2014 the left and the right endpoints of the j-th segment.\\n\\nIt's guaranteed that the sum of n and the sum of m over all test cases does not exceed 2 \u22c5 10^5.\\n\\nOutput\\n\\nFor each test case print a single integer \u2014 the minimal total cost of all moves such that all segments are visited.\\n\\nExample\\n\\nInput\\n\\n\\n2\\n4 11\\n2 6 14 18\\n0 3\\n4 5\\n11 15\\n3 5\\n10 13\\n16 16\\n1 4\\n8 12\\n17 19\\n7 13\\n14 19\\n4 12\\n-9 -16 12 3\\n-20 -18\\n-14 -13\\n-10 -7\\n-3 -1\\n0 4\\n6 11\\n7 9\\n8 10\\n13 15\\n14 18\\n16 17\\n18 19\\n\\n\\nOutput\\n\\n\\n5\\n22\\n\\nNote\\n\\nIn the first test case the points can be moved as follows:\\n\\n  * Move the second point from the coordinate 6 to the coordinate 5. \\n  * Move the third point from the coordinate 14 to the coordinate 13. \\n  * Move the fourth point from the coordinate 18 to the coordinate 17. \\n  * Move the third point from the coordinate 13 to the coordinate 12. \\n  * Move the...\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst int MAXN = (int)2e5 + 5;\\nlong long mem[MAXN][2];\\nlong long dp[MAXN];\\npair<int, int> seg[MAXN];\\nint X[MAXN];\\nint n, m;\\nvoid filter() {\\n  sort(seg + 1, seg + m + 1);\\n  vector<pair<int, int>> vec;\\n  for (int i = 1; i <= m; i++) {\\n    while (!vec.empty() && vec.back().second > seg[i].second) {\\n      vec.pop_back();\\n    }\\n    vec.push_back(seg[i]);\\n  }\\n  for (int i = 0; i < (int)(vec).size(); i++) {\\n    seg[i + 1] = vec[i];\\n  }\\n  m = (int)(vec).size();\\n}\\nint f(int l, int x, int r) {\\n  l = min(l, x);\\n  r = max(r, x);\\n  return r - l + min(x - l, r - x);\\n}\\nvoid solve() {\\n  cin >> n >> m;\\n  for (int i = 1; i <= n; i++) {\\n    cin >> X[i];\\n  }\\n  sort(X + 1, X + n + 1);\\n  for (int i = 1; i <= m; i++) {\\n    int l, r;\\n    cin >> l >> r;\\n    int p = lower_bound(X + 1, X + n + 1, l) - X;\\n    if (p <= n && X[p] <= r) {\\n      --i;\\n      --m;\\n      continue;\\n    }\\n    seg[i] = {l, r};\\n  }\\n  filter();\\n  dp[0] = 0;\\n  fill(dp + 1, dp + m + 1, (long long)1e18);\\n  int p = 0, q = 0, t = 0;\\n  X[0] = (int)-2e9;\\n  X[n + 1] = (int)2e9;\\n  for (int i = 1; i <= n; i++) {\\n    while (t + 1 <= m && seg[t + 1].second < X[i - 1]) {\\n      ++t;\\n    }\\n    while (p + 1 <= m && seg[p + 1].second < X[i]) {\\n      p++;\\n    }\\n    while (q + 1 <= m && seg[q + 1].second < X[i + 1]) {\\n      q++;\\n    }\\n    long long mem0 = (long long)1e18, mem1 = (long long)1e18;\\n    for (int l = t + 1; l <= p; l++) {\\n      int A = X[i] - seg[l].second;\\n      mem0 = min(mem0, dp[l - 1] + A * 2);\\n      mem1 = min(mem1, dp[l - 1] + A);\\n    }\\n    for (int r = p + 1; r <= q; r++) {\\n      int B = seg[r].first - X[i];\\n      dp[r] = min(dp[r], mem0 + B);\\n      dp[r] = min(dp[r], mem1 + B * 2);\\n    }\\n    for (int r = p + 1; r <= q; r++) {\\n      dp[r] = min(dp[r], dp[p] + seg[r].first - X[i]);\\n    }\\n    for (int l = t + 1; l <= p; l++) {\\n      dp[p] = min(dp[p], dp[l - 1] + X[i] - seg[l].second);\\n    }\\n  }\\n  cout << dp[m] << '\\\\n';\\n}\\nint main() {\\n  ios::sync_with_stdio(0);\\n  cin.tie(0);\\n  cout.tie(0);\\n  int tt;\\n  cin >> tt;\\n  while...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Consider sequences \\\\\\\\{A_1,...,A_N\\\\\\\\} of length N consisting of integers between 1 and K (inclusive).\\n\\nThere are K^N such sequences. Find the sum of \\\\gcd(A_1, ..., A_N) over all of them.\\n\\nSince this sum can be enormous, print the value modulo (10^9+7).\\n\\nHere \\\\gcd(A_1, ..., A_N) denotes the greatest common divisor of A_1, ..., A_N.\\n\\nConstraints\\n\\n* 2 \\\\leq N \\\\leq 10^5\\n* 1 \\\\leq K \\\\leq 10^5\\n* All values in input are integers.\\n\\nInput\\n\\nInput is given from Standard Input in the following format:\\n\\n\\nN K\\n\\n\\nOutput\\n\\nPrint the sum of \\\\gcd(A_1, ..., A_N) over all K^N sequences, modulo (10^9+7).\\n\\nExamples\\n\\nInput\\n\\n3 2\\n\\n\\nOutput\\n\\n9\\n\\n\\nInput\\n\\n3 200\\n\\n\\nOutput\\n\\n10813692\\n\\n\\nInput\\n\\n100000 100000\\n\\n\\nOutput\\n\\n742202979\\n#incl\",\"targets\":\"ude<bits\\/stdc++.h>\\nusing namespace std;\\n#define ll long long \\n\\nconst ll m=1e9+7;\\n\\nll power(ll a,ll b)\\n{\\n\\tif(b==0)\\n\\t\\treturn 1;\\n\\n\\telse if(b%2==0)\\n\\t\\treturn power((a%m*a%m)%m,b\\/2);\\n\\telse\\n\\t\\treturn (a*power((a%m*a%m)%m,(b-1)\\/2))%m;\\n}\\n\\nint main()\\n{\\n\\tint n,k;\\n\\tcin>>n>>k;\\n\\n\\tll dp[k+1];\\n\\n\\n\\tfor(int i=k;i>=1;i--)\\n\\t{\\n\\t\\tdp[i]=power((k\\/i),n);\\n\\n\\t\\tfor(int j=2*i;j<=k;j=j+i)\\n\\t\\t{\\n\\t\\t\\tdp[i]=dp[i]-dp[j];\\n\\t\\t}\\n\\t}\\n\\n\\tll ans=0;\\n\\tfor(int i=1;i<=k;i++)\\n\\t{\\n\\t\\tans=ans+dp[i]*i;\\n\\t}\\n\\tcout<<ans%m<<endl;\\n\\n\\treturn 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"A bracket sequence is a string containing only characters \\\"(\\\" and \\\")\\\". 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 \\\"()()\\\" and \\\"(())\\\" are regular (the resulting expressions are: \\\"(1)+(1)\\\" and \\\"((1+1)+1)\\\"), and \\\")(\\\", \\\"(\\\" and \\\")\\\" are not.\\n\\nYou are given an integer n. Your goal is to construct and print exactly n different regular bracket sequences of length 2n.\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 50) \u2014 the number of test cases.\\n\\nEach test case consists of one line containing one integer n (1 \u2264 n \u2264 50).\\n\\nOutput\\n\\nFor each test case, print n lines, each containing a regular bracket sequence of length exactly 2n. All bracket sequences you output for a testcase should be different (though they may repeat in different test cases). If there are multiple answers, print any of them. It can be shown that it's always possible.\\n\\nExample\\n\\nInput\\n\\n\\n3\\n3\\n1\\n3\\n\\n\\nOutput\\n\\n\\n()()()\\n((()))\\n(()())\\n()\\n((()))\\n(())()\\n()(())\\nThe above is tricky. Write me a correct solution in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint main() {\\n  int t, n;\\n  cin >> t;\\n  int x, sum2 = 0;\\n  char s1 = '(', s2 = ')';\\n  string temp;\\n  for (int i = 0; i < t; i++) {\\n    cin >> n;\\n    string sum[2 * n];\\n    if (n == 1) {\\n      cout << s1 << s2 << endl;\\n    } else if (n > 1) {\\n      for (int j = 0; j < n; j++) {\\n        for (int i = 0; i < n; i++) {\\n          sum[i] = s1;\\n        }\\n        for (int i = n; i < 2 * n; i++) {\\n          sum[i] = s2;\\n        }\\n      }\\n      do {\\n        for (int i = 0; i < 2 * n; i++) {\\n          cout << sum[i];\\n        }\\n        sum2 += 1;\\n        for (int i = n - 1; i >= 0; i--) {\\n          for (int j = n; j < 2 * n; j++) {\\n            temp = sum[i];\\n            sum[i] = sum[j];\\n            sum[j] = temp;\\n            break;\\n          }\\n        }\\n        cout << endl;\\n      } while (sum2 < n);\\n    }\\n    sum2 = 0;\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Andrew, Fedor and Alex are inventive guys. Now they invent the game with strings for two players.\\n\\nGiven a group of n non-empty strings. During the game two players build the word together, initially the word is empty. The players move in turns. On his step player must add a single letter in the end of the word, the resulting word must be prefix of at least one string from the group. A player loses if he cannot move.\\n\\nAndrew and Alex decided to play this game k times. The player who is the loser of the i-th game makes the first move in the (i + 1)-th game. Guys decided that the winner of all games is the player who wins the last (k-th) game. Andrew and Alex already started the game. Fedor wants to know who wins the game if both players will play optimally. Help him.\\n\\nInput\\n\\nThe first line contains two integers, n and k (1 \u2264 n \u2264 105; 1 \u2264 k \u2264 109).\\n\\nEach of the next n lines contains a single non-empty string from the given group. The total length of all strings from the group doesn't exceed 105. Each string of the group consists only of lowercase English letters.\\n\\nOutput\\n\\nIf the player who moves first wins, print \\\"First\\\", otherwise print \\\"Second\\\" (without the quotes).\\n\\nExamples\\n\\nInput\\n\\n2 3\\na\\nb\\n\\n\\nOutput\\n\\nFirst\\n\\n\\nInput\\n\\n3 1\\na\\nb\\nc\\n\\n\\nOutput\\n\\nFirst\\n\\n\\nInput\\n\\n1 2\\nab\\n\\n\\nOutput\\n\\nSecond\\nUsing cpp can you solve the prior task?\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst int MAX_N = int(1e6) + 10;\\nconst long long int MOD = 998244353;\\nconst long long int INF = 1e18;\\ninline long long int mul(long long int a, long long int b) {\\n  a = (a + MOD) % MOD;\\n  b = (b + MOD) % MOD;\\n  long long int c = a * b;\\n  c = (c + MOD) % MOD;\\n  return c;\\n}\\ninline long long int add(long long int a, long long int b) {\\n  a = (a + MOD) % MOD;\\n  b = (b + MOD) % MOD;\\n  long long int ans = (a + b);\\n  ans = (ans + MOD) % MOD;\\n  return ans;\\n}\\nlong long int power(long long int a, long long int b, long long int c = 0) {\\n  long long int ans = 1;\\n  while (b) {\\n    if (b & 1) {\\n      ans = mul(ans, a);\\n    }\\n    a = mul(a, a);\\n    b = b \\/ 2;\\n  }\\n  return ans;\\n}\\nint n, k;\\nint arr[100005][26];\\nint nxt;\\nbool win[100005];\\nbool loose[100005];\\nvoid add(string &s) {\\n  int node = 0;\\n  for (int i = 0; i < s.size(); i++) {\\n    if (arr[node][s[i] - 'a'] == -1) arr[node][s[i] - 'a'] = nxt++;\\n    node = arr[node][s[i] - 'a'];\\n  }\\n}\\nvoid dfs(int x) {\\n  bool f = true;\\n  for (int i = 0; i < 26; i++) {\\n    if (arr[x][i] != -1) {\\n      dfs(arr[x][i]);\\n      f = false;\\n      win[x] |= (!win[arr[x][i]]);\\n      loose[x] |= (!loose[arr[x][i]]);\\n    }\\n  }\\n  if (f) {\\n    win[x] = false;\\n    loose[x] = true;\\n  }\\n}\\nint main() {\\n  ios_base::sync_with_stdio(false);\\n  cin.tie(NULL);\\n  cout.tie(NULL);\\n  memset(arr, -1, sizeof(arr));\\n  nxt = 1;\\n  cin >> n >> k;\\n  for (int i = 1; i <= n; i++) {\\n    string s;\\n    cin >> s;\\n    add(s);\\n  }\\n  dfs(0);\\n  if (win[0] == false)\\n    cout << \\\"Second\\\"\\n         << \\\"\\\\n\\\";\\n  else if (win[0] == true && loose[0] == true)\\n    cout << \\\"First\\\"\\n         << \\\"\\\\n\\\";\\n  else if (win[0] == true && loose[0] == false) {\\n    if (k % 2 == 1)\\n      cout << \\\"First\\\"\\n           << \\\"\\\\n\\\";\\n    else\\n      cout << \\\"Second\\\"\\n           << \\\"\\\\n\\\";\\n  }\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"JAVA solution for \\\"Let's call a sequence of integers x_1, x_2, ..., x_k MEX-correct if for all i (1 \u2264 i \u2264 k) |x_i - \\\\operatorname{MEX}(x_1, x_2, ..., x_i)| \u2264 1 holds. Where \\\\operatorname{MEX}(x_1, ..., x_k) is the minimum non-negative integer that doesn't belong to the set x_1, ..., x_k. For example, \\\\operatorname{MEX}(1, 0, 1, 3) = 2 and \\\\operatorname{MEX}(2, 1, 5) = 0.\\n\\nYou are given an array a consisting of n non-negative integers. Calculate the number of non-empty MEX-correct subsequences of a given array. The number of subsequences can be very large, so print it modulo 998244353. \\n\\nNote: a subsequence of an array a is a sequence [a_{i_1}, a_{i_2}, ..., a_{i_m}] meeting the constraints 1 \u2264 i_1 < i_2 < ... < i_m \u2264 n. If two different ways to choose the sequence of indices [i_1, i_2, ..., i_m] yield the same subsequence, the resulting subsequence should be counted twice (i. e. two subsequences are different if their sequences of indices [i_1, i_2, ..., i_m] are not the same).\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 10^5) \u2014 the number of test cases.\\n\\nThe first line of each test case contains a single integer n (1 \u2264 n \u2264 5 \u22c5 10^5).\\n\\nThe second line contains n integers a_1, a_2, ..., a_n (0 \u2264 a_i \u2264 n).\\n\\nThe sum of n over all test cases doesn't exceed 5 \u22c5 10^5.\\n\\nOutput\\n\\nFor each test case, print a single integer \u2014 the number of non-empty MEX-correct subsequences of a given array, taken modulo 998244353.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n3\\n0 2 1\\n2\\n1 0\\n5\\n0 0 0 0 0\\n4\\n0 1 2 3\\n\\n\\nOutput\\n\\n\\n4\\n2\\n31\\n7\\n\\nNote\\n\\nIn the first example, the valid subsequences are [0], [1], [0,1] and [0,2].\\n\\nIn the second example, the valid subsequences are [0] and [1].\\n\\nIn the third example, any non-empty subsequence is valid. \\\":\",\"targets\":\"import java.util.*;\\nimport java.io.*;\\n \\npublic class D {\\n\\t\\n\\tstatic final long MOD = 998244353;\\n \\n\\tpublic static void main(String[] args) {\\n\\t\\tFastScanner fs = new FastScanner();\\n\\t\\tPrintWriter pw = new PrintWriter(System.out);\\n\\t\\tStringBuilder sb = new StringBuilder(\\\"\\\");\\n\\t\\tint t = fs.nextInt();\\n\\t\\tfor (int tt = 1; tt <= t; tt++) {\\n\\t\\t\\tint n = fs.nextInt();\\n\\t\\t\\tint[] a = fs.readArray(n);\\n\\t\\t\\tlong[] dp1 = new long[n + 2];\\n\\t\\t\\tlong[] dp2 = new long[n + 2];\\n\\t\\t\\tdp1[0] = 1;\\n\\t\\t\\tfor (int i = 0; i < n; i++) {\\n\\t\\t\\t\\tdp1[a[i] + 1] = (2 * dp1[a[i] + 1] + dp1[a[i]]) % MOD;\\n\\t\\t\\t\\tif (a[i] > 0) dp2[a[i] - 1] = (2 * dp2[a[i] - 1] + dp1[a[i] - 1]) % MOD;\\n\\t\\t\\t\\tdp2[a[i] + 1] = (2 * dp2[a[i] + 1]) % MOD;\\n\\t\\t\\t}\\n\\t\\t\\tlong ans = MOD - 1;\\n\\t\\t\\tfor (long x : dp1) ans = (ans + x) % MOD;\\n\\t\\t\\tfor (long x : dp2) ans = (ans + x) % MOD;\\n\\t\\t\\tsb.append(ans + \\\"\\\\n\\\");\\n\\t\\t}\\n\\t\\tpw.print(sb.toString());\\n\\t\\tpw.close();\\n\\t}\\n \\n\\tstatic class FastScanner {\\n\\t\\tBufferedReader br = new BufferedReader(new InputStreamReader(System.in));\\n\\t\\tStringTokenizer st = new StringTokenizer(\\\"\\\");\\n\\t\\tString next() {while (!st.hasMoreTokens())try {st = new StringTokenizer(br.readLine());} catch (IOException e) {}return st.nextToken();}\\n\\t\\tint nextInt() {return Integer.parseInt(next());}\\n\\t\\tlong nextLong() {return Long.parseLong(next());}\\n\\t\\tdouble nextDouble() {return Double.parseDouble(next());}\\n\\t\\tint[] readArray(int n) { int[] a = new int[n]; for (int i = 0; i < n; i++) {a[i] = nextInt();} return a;}\\n\\t}\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in CPP?\\nFor months Maxim has been coming to work on his favorite bicycle. And quite recently he decided that he is ready to take part in a cyclists' competitions.\\n\\nHe knows that this year n competitions will take place. During the i-th competition the participant must as quickly as possible complete a ride along a straight line from point si to point fi (si < fi).\\n\\nMeasuring time is a complex process related to usage of a special sensor and a time counter. Think of the front wheel of a bicycle as a circle of radius r. Let's neglect the thickness of a tire, the size of the sensor, and all physical effects. The sensor is placed on the rim of the wheel, that is, on some fixed point on a circle of radius r. After that the counter moves just like the chosen point of the circle, i.e. moves forward and rotates around the center of the circle.\\n\\nAt the beginning each participant can choose any point bi, such that his bike is fully behind the starting line, that is, bi < si - r. After that, he starts the movement, instantly accelerates to his maximum speed and at time tsi, when the coordinate of the sensor is equal to the coordinate of the start, the time counter starts. The cyclist makes a complete ride, moving with his maximum speed and at the moment the sensor's coordinate is equal to the coordinate of the finish (moment of time tfi), the time counter deactivates and records the final time. Thus, the counter records that the participant made a complete ride in time tfi - tsi.\\n\\n<image>\\n\\nMaxim is good at math and he suspects that the total result doesn't only depend on his maximum speed v, but also on his choice of the initial point bi. Now Maxim is asking you to calculate for each of n competitions the minimum possible time that can be measured by the time counter. The radius of the wheel of his bike is equal to r.\\n\\nInput\\n\\nThe first line contains three integers n, r and v (1 \u2264 n \u2264 100 000, 1 \u2264 r, v \u2264 109) \u2014 the number of competitions, the radius of the front wheel of Max's bike and his maximum speed, respectively. \\n\\nNext n...\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint N;\\ndouble R, V, W;\\ndouble s, f;\\nint main() {\\n  scanf(\\\"%d%lf%lf\\\", &N, &R, &V);\\n  W = V \\/ R;\\n  for (int i = 0; i < N; i++) {\\n    cin >> s >> f;\\n    double x = (f - s) \\/ 2;\\n    double lb = 0, rb = 1E10;\\n    for (int j = 0; j < 60; j++) {\\n      double mb = (lb + rb) \\/ 2;\\n      double val = V * mb + R * fabs(sin(W * mb));\\n      if (val < x)\\n        lb = mb;\\n      else\\n        rb = mb;\\n    }\\n    printf(\\\"%.10f\\\\n\\\", lb + rb);\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"A positive integer X is said to be a lunlun number if and only if the following condition is satisfied:\\n\\n* In the base ten representation of X (without leading zeros), for every pair of two adjacent digits, the absolute difference of those digits is at most 1.\\n\\n\\n\\nFor example, 1234, 1, and 334 are lunlun numbers, while none of 31415, 119, or 13579 is.\\n\\nYou are given a positive integer K. Find the K-th smallest lunlun number.\\n\\nConstraints\\n\\n* 1 \\\\leq K \\\\leq 10^5\\n* All values in input are integers.\\n\\nInput\\n\\nInput is given from Standard Input in the following format:\\n\\n\\nK\\n\\n\\nOutput\\n\\nPrint the answer.\\n\\nExamples\\n\\nInput\\n\\n15\\n\\n\\nOutput\\n\\n23\\n\\n\\nInput\\n\\n1\\n\\n\\nOutput\\n\\n1\\n\\n\\nInput\\n\\n13\\n\\n\\nOutput\\n\\n21\\n\\n\\nInput\\n\\n100000\\n\\n\\nOutput\\n\\n3234566667\\nSolve the task in CPP.\",\"targets\":\"#include<bits\\/stdc++.h>\\nusing namespace std;\\nint main()\\n{\\n\\tlong long k;\\n\\tcin>>k;\\n\\tqueue<long long> q;\\n\\tfor(int i=1;i<=9;i++)\\n\\t\\tq.push(i);\\n\\twhile(!q.empty()){\\n\\t\\tlong long x=q.front();\\n\\t\\tq.pop();\\n\\t\\tk--;\\n\\t\\tif(k==0){\\n\\t\\t\\tcout<<x<<endl;\\n\\t\\t\\tbreak;\\n\\t\\t}\\n\\t\\tfor(int i=x%10-1;i<=x%10+1;i++){\\n\\t\\t\\tif(i>9||i<0)\\n\\t\\t\\t\\tcontinue;\\n\\t\\t\\tq.push(x*10+i);\\n\\t\\t}\\n\\t} \\n\\treturn 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"A New Year party is not a New Year party without lemonade! As usual, you are expecting a lot of guests, and buying lemonade has already become a pleasant necessity.\\n\\nYour favorite store sells lemonade in bottles of n different volumes at different costs. A single bottle of type i has volume 2i - 1 liters and costs ci roubles. The number of bottles of each type in the store can be considered infinite.\\n\\nYou want to buy at least L liters of lemonade. How many roubles do you have to spend?\\n\\nInput\\n\\nThe first line contains two integers n and L (1 \u2264 n \u2264 30; 1 \u2264 L \u2264 109) \u2014 the number of types of bottles in the store and the required amount of lemonade in liters, respectively.\\n\\nThe second line contains n integers c1, c2, ..., cn (1 \u2264 ci \u2264 109) \u2014 the costs of bottles of different types.\\n\\nOutput\\n\\nOutput a single integer \u2014 the smallest number of roubles you have to pay in order to buy at least L liters of lemonade.\\n\\nExamples\\n\\nInput\\n\\n4 12\\n20 30 70 90\\n\\n\\nOutput\\n\\n150\\n\\n\\nInput\\n\\n4 3\\n10000 1000 100 10\\n\\n\\nOutput\\n\\n10\\n\\n\\nInput\\n\\n4 3\\n10 100 1000 10000\\n\\n\\nOutput\\n\\n30\\n\\n\\nInput\\n\\n5 787787787\\n123456789 234567890 345678901 456789012 987654321\\n\\n\\nOutput\\n\\n44981600785557577\\n\\nNote\\n\\nIn the first example you should buy one 8-liter bottle for 90 roubles and two 2-liter bottles for 30 roubles each. In total you'll get 12 liters of lemonade for just 150 roubles.\\n\\nIn the second example, even though you need only 3 liters, it's cheaper to buy a single 8-liter bottle for 10 roubles.\\n\\nIn the third example it's best to buy three 1-liter bottles for 10 roubles each, getting three liters for 30 roubles.\\nThe above is tricky. Write me a correct solution in PYTHON3.\",\"targets\":\"R = lambda: map(int, input().split())\\n\\ndef get_cost(num):\\n    res = 0\\n    for i in range(32):\\n        if num & (1 << i):\\n            res += cs[i]\\n    return res\\n\\nn, l = R()\\ncs = list(R())\\nfor i in range(1, 32):\\n    if i >= len(cs):\\n        cs.append(2 * cs[i - 1])\\n    elif cs[i] > 2 * cs[i - 1]:\\n        cs[i] = 2 * cs[i - 1]\\nres = get_cost(l)\\nwhile l <= (1 << 31):\\n    res = min(res, get_cost(l))\\n    l += l & -l\\nprint(res)\",\"language\":\"python\",\"split\":\"train\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in PYTHON3?\\nTheofanis started playing the new online game called \\\"Among them\\\". However, he always plays with Cypriot players, and they all have the same name: \\\"Andreas\\\" (the most common name in Cyprus).\\n\\nIn each game, Theofanis plays with n other players. Since they all have the same name, they are numbered from 1 to n.\\n\\nThe players write m comments in the chat. A comment has the structure of \\\"i j c\\\" where i and j are two distinct integers and c is a string (1 \u2264 i, j \u2264 n; i \u2260 j; c is either imposter or crewmate). The comment means that player i said that player j has the role c.\\n\\nAn imposter always lies, and a crewmate always tells the truth. \\n\\nHelp Theofanis find the maximum possible number of imposters among all the other Cypriot players, or determine that the comments contradict each other (see the notes for further explanation).\\n\\nNote that each player has exactly one role: either imposter or crewmate.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases. Description of each test case follows.\\n\\nThe first line of each test case contains two integers n and m (1 \u2264 n \u2264 2 \u22c5 10^5; 0 \u2264 m \u2264 5 \u22c5 10^5) \u2014 the number of players except Theofanis and the number of comments.\\n\\nEach of the next m lines contains a comment made by the players of the structure \\\"i j c\\\" where i and j are two distinct integers and c is a string (1 \u2264 i, j \u2264 n; i \u2260 j; c is either imposter or crewmate).\\n\\nThere can be multiple comments for the same pair of (i, j).\\n\\nIt is guaranteed that the sum of all n does not exceed 2 \u22c5 10^5 and the sum of all m does not exceed 5 \u22c5 10^5.\\n\\nOutput\\n\\nFor each test case, print one integer \u2014 the maximum possible number of imposters. If the comments contradict each other, print -1.\\n\\nExample\\n\\nInput\\n\\n\\n5\\n3 2\\n1 2 imposter\\n2 3 crewmate\\n5 4\\n1 3 crewmate\\n2 5 crewmate\\n2 4 imposter\\n3 4 imposter\\n2 2\\n1 2 imposter\\n2 1 crewmate\\n3 5\\n1 2 imposter\\n1 2 imposter\\n3 2 crewmate\\n3 2 crewmate\\n1 3 imposter\\n5 0\\n\\n\\nOutput\\n\\n\\n2\\n4\\n-1\\n2\\n5\\n\\nNote\\n\\nIn the first test case, imposters can be Andreas 2 and 3.\\n\\nIn the second test...\",\"targets\":\"###pyrival template for fast IO\\nimport os\\nimport sys\\nfrom io import BytesIO, IOBase\\n##########region fastio\\nBUFSIZE = 8192\\n###pyrival template for fast IO\\nclass FastIO(IOBase):\\n    newlines = 0\\n    ###pyrival template for fast IO\\n    def __init__(self, file):\\n        self._fd = file.fileno()\\n        self.buffer = BytesIO()\\n        self.writable = \\\"x\\\" in file.mode or \\\"r\\\" not in file.mode\\n        self.write = self.buffer.write if self.writable else None\\n    ###pyrival template for fast IO\\n    def read(self):\\n        while True:\\n            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))\\n            if not b:\\n                break\\n            ptr = self.buffer.tell()\\n            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)\\n        self.newlines = 0\\n        return self.buffer.read()\\n    ###pyrival template for fast IO\\n    def readline(self):\\n        while self.newlines == 0:\\n            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))\\n            self.newlines = b.count(b\\\"\\\\n\\\") + (not b)\\n            ptr = self.buffer.tell()\\n            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)\\n        self.newlines -= 1\\n        return self.buffer.readline()\\n    ###pyrival template for fast IO\\n    def flush(self):\\n        if self.writable:\\n            os.write(self._fd, self.buffer.getvalue())\\n            self.buffer.truncate(0), self.buffer.seek(0)\\nclass IOWrapper(IOBase):\\n    ###pyrival template for fast IO\\n    def __init__(self, file):\\n        self.buffer = FastIO(file)\\n        self.flush = self.buffer.flush\\n        self.writable = self.buffer.writable\\n        self.write = lambda s: self.buffer.write(s.encode(\\\"ascii\\\"))\\n        self.read = lambda: self.buffer.read().decode(\\\"ascii\\\")\\n        self.readline = lambda: self.buffer.readline().decode(\\\"ascii\\\")\\n###pyrival template for fast IO\\nsys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)\\ninput = lambda: sys.stdin.readline().rstrip(\\\"\\\\r\\\\n\\\")\\n\\nfrom collections import deque\\nt=int(input())\\ndef...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CQXYM wants to create a connected undirected graph with n nodes and m edges, and the diameter of the graph must be strictly less than k-1. Also, CQXYM doesn't want a graph that contains self-loops or multiple edges (i.e. each edge connects two different vertices and between each pair of vertices there is at most one edge).\\n\\nThe diameter of a graph is the maximum distance between any two nodes.\\n\\nThe distance between two nodes is the minimum number of the edges on the path which endpoints are the two nodes.\\n\\nCQXYM wonders whether it is possible to create such a graph.\\n\\nInput\\n\\nThe input consists of multiple test cases. \\n\\nThe first line contains an integer t (1 \u2264 t \u2264 10^5) \u2014 the number of test cases. The description of the test cases follows.\\n\\nOnly one line of each test case contains three integers n(1 \u2264 n \u2264 10^9), m, k (0 \u2264 m,k \u2264 10^9).\\n\\nOutput\\n\\nFor each test case, print YES if it is possible to create the graph, or print NO if it is impossible. You can print each letter in any case (upper or lower).\\n\\nExample\\n\\nInput\\n\\n\\n5\\n1 0 3\\n4 5 3\\n4 6 3\\n5 4 1\\n2 1 1\\n\\n\\nOutput\\n\\n\\nYES\\nNO\\nYES\\nNO\\nNO\\n\\nNote\\n\\nIn the first test case, the graph's diameter equal to 0.\\n\\nIn the second test case, the graph's diameter can only be 2.\\n\\nIn the third test case, the graph's diameter can only be 1.\",\"targets\":\"for _ in range(int(input())):\\n    n,m,k=map(int,input().split())\\n    if m<n-1 or m>n*(n-1)\\/\\/2:\\n        print('NO')\\n        continue\\n    if n==1:\\n        if 0<k-1:\\n            print('YES')\\n        else:\\n            print('NO')\\n    else:\\n        if m==n*(n-1)\\/\\/2:\\n            r=1\\n        else:\\n            r=2\\n        if r<k-1:\\n            print('YES')\\n        else:\\n            print('NO')\",\"language\":\"python\",\"split\":\"test\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"In Berland, n different types of banknotes are used. Banknotes of the i-th type have denomination 10^{a_i} burles (burles are the currency used in Berland); the denomination of banknotes of the first type is exactly 1.\\n\\nLet's denote f(s) as the minimum number of banknotes required to represent exactly s burles. For example, if the denominations of banknotes used in Berland are 1, 10 and 100, then f(59) = 14: 9 banknotes with denomination of 1 burle and 5 banknotes with denomination of 10 burles can be used to represent exactly 9 \u22c5 1 + 5 \u22c5 10 = 59 burles, and there's no way to do it with fewer banknotes.\\n\\nFor a given integer k, find the minimum positive number of burles s that cannot be represented with k or fewer banknotes (that is, f(s) > k).\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 10^4) \u2014 number of test cases.\\n\\nThe first line of each test case contains two integers n and k (1 \u2264 n \u2264 10; 1 \u2264 k \u2264 10^9).\\n\\nThe next line contains n integers a_1, a_2, ..., a_n (0 = a_1 < a_2 < ... < a_n \u2264 9).\\n\\nOutput\\n\\nFor each test case, print one integer \u2014 the minimum positive number of burles s that cannot be represented with k or fewer banknotes.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n3 13\\n0 1 2\\n2 777\\n0 4\\n3 255\\n0 1 3\\n10 1000000000\\n0 1 2 3 4 5 6 7 8 9\\n\\n\\nOutput\\n\\n\\n59\\n778\\n148999\\n999999920999999999\",\"targets\":\"import java.util.*;\\nimport java.io.*;\\nimport java.math.BigDecimal;\\nimport java.math.RoundingMode;\\n \\npublic class Main implements Runnable {\\n \\n    static FastReader sc;\\n    static PrintWriter out;\\n    static int mod = 1000000007, inf = (int) 1e9, minf = -(int) 1e9;\\n    static long infL = (long) 1e18, minfL = -(long) 1e18;\\n    static final Random random = new Random();\\n \\n    public static void main(String[] args) {\\n        new Thread(null, new Main(), \\\"coderrohan14\\\", 1 << 26).start();\\n    }\\n \\n    @Override\\n    public void run() {\\n        try {\\n            ioSetup();\\n        } catch (IOException e) {\\n            return;\\n        }\\n    }\\n \\n    public static void ioSetup() throws IOException {\\n        if (System.getProperty(\\\"ONLINE_JUDGE\\\") == null) {\\n            File f1 = new File(\\\"input.txt\\\");\\n            File f2 = new File(\\\"output.txt\\\");\\n            Reader r = new FileReader(f1);\\n            sc = new FastReader(r);\\n            out = new PrintWriter(f2);\\n            double prev = System.currentTimeMillis();\\n            solve();\\n            out.println(\\\"\\\\n\\\\nExecuted in : \\\" + ((System.currentTimeMillis() - prev) \\/ 1e3) + \\\" sec\\\");\\n        } else {\\n            sc = new FastReader(new InputStreamReader(System.in));\\n            out = new PrintWriter(System.out);\\n            solve();\\n        }\\n        out.flush();\\n        out.close();\\n    }\\n \\n    static int n;\\n    static long k,arr[];\\n\\n    static void solve() {\\n        int t = sc.nextInt();\\n        StringBuilder ans = new StringBuilder(\\\"\\\");\\n        while (t-- > 0) {\\n            n = sc.nextInt();\\n            k = sc.nextLong()+1;\\n            arr = new long[n];\\n            for(int i=0;i<n;i++){\\n                arr[i] = (long)Math.pow((double)10,(double)sc.nextInt());\\n            }\\n            long res=0;\\n            for(int i=0;i<n;i++){\\n                long cnt = k;\\n                if (i + 1 < n) cnt = Math.min(cnt, arr[i + 1] \\/ arr[i] - 1);\\n                res += arr[i] * cnt;\\n                k -= cnt;\\n            }\\n            ans.append(res+\\\"\\\\n\\\");\\n        }\\n       ...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"During a New Year special offer the \\\"Sudislavl Bars\\\" offered n promo codes. Each promo code consists of exactly six digits and gives right to one free cocktail at the bar \\\"Mosquito Shelter\\\". Of course, all the promocodes differ.\\n\\nAs the \\\"Mosquito Shelter\\\" opens only at 9, and partying in Sudislavl usually begins at as early as 6, many problems may arise as to how to type a promotional code without errors. It is necessary to calculate such maximum k, that the promotional code could be uniquely identified if it was typed with no more than k errors. At that, k = 0 means that the promotional codes must be entered exactly.\\n\\nA mistake in this problem should be considered as entering the wrong numbers. For example, value \\\"123465\\\" contains two errors relative to promocode \\\"123456\\\". Regardless of the number of errors the entered value consists of exactly six digits.\\n\\nInput\\n\\nThe first line of the output contains number n (1 \u2264 n \u2264 1000) \u2014 the number of promocodes.\\n\\nEach of the next n lines contains a single promocode, consisting of exactly 6 digits. It is guaranteed that all the promocodes are distinct. Promocodes can start from digit \\\"0\\\".\\n\\nOutput\\n\\nPrint the maximum k (naturally, not exceeding the length of the promocode), such that any promocode can be uniquely identified if it is typed with at most k mistakes.\\n\\nExamples\\n\\nInput\\n\\n2\\n000000\\n999999\\n\\n\\nOutput\\n\\n2\\n\\n\\nInput\\n\\n6\\n211111\\n212111\\n222111\\n111111\\n112111\\n121111\\n\\n\\nOutput\\n\\n0\\n\\nNote\\n\\nIn the first sample k < 3, so if a bar customer types in value \\\"090909\\\", then it will be impossible to define which promocode exactly corresponds to it.\\nSolve the task in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nconst double EPS = 1e-24;\\nconst long long mod = 1000000007ll;\\nconst long long mod1 = 1000000009ll;\\nconst long long mod2 = 1100000009ll;\\nconst double PI = 3.14159265359;\\nint INF = 2147483645;\\nlong long INFINF = 9223372036854775807;\\ntemplate <class T>\\nT Max2(T a, T b) {\\n  return a < b ? b : a;\\n}\\ntemplate <class T>\\nT Min2(T a, T b) {\\n  return a < b ? a : b;\\n}\\ntemplate <class T>\\nT Max3(T a, T b, T c) {\\n  return Max2(Max2(a, b), c);\\n}\\ntemplate <class T>\\nT Min3(T a, T b, T c) {\\n  return Min2(Min2(a, b), c);\\n}\\ntemplate <class T>\\nT Max4(T a, T b, T c, T d) {\\n  return Max2(Max2(a, b), Max2(c, d));\\n}\\ntemplate <class T>\\nT Min4(T a, T b, T c, T d) {\\n  return Min2(Min2(a, b), Max2(c, d));\\n}\\nusing namespace std;\\nlong long bit_count(long long _x) {\\n  long long _ret = 0;\\n  while (_x) {\\n    if (_x % 2 == 1) _ret++;\\n    _x \\/= 2;\\n  }\\n  return _ret;\\n}\\nlong long bit(long long _mask, long long _i) {\\n  return (_mask & (1 << _i)) == 0 ? 0 : 1;\\n}\\nlong long powermod(long long _a, long long _b, long long _m) {\\n  long long _r = 1;\\n  while (_b) {\\n    if (_b % 2 == 1) _r = (_r * _a) % _m;\\n    _b \\/= 2;\\n    _a = (_a * _a) % _m;\\n  }\\n  return _r;\\n}\\nlong long add(long long a, long long b, long long m) {\\n  long long x = a + b;\\n  while (x >= m) x -= m;\\n  return x;\\n}\\nlong long sub(long long a, long long b, long long m) {\\n  long long x = a - b;\\n  while (x < 0) x += m;\\n  return x;\\n}\\nlong long mul(long long a, long long b, long long m) {\\n  long long x = a * b;\\n  x %= m;\\n  return x;\\n}\\nint xori(int b, int a) {\\n  int c = 0, p = 1;\\n  for (int i = 0; i < int(6); i++) {\\n    if (a % 10 == b % 10)\\n      c += 0;\\n    else\\n      c += p;\\n    a \\/= 10;\\n    b \\/= 10;\\n    p *= 10;\\n  }\\n  return c;\\n}\\nint count(int a) {\\n  int cnt = 0;\\n  for (int i = 0; i < int(6); i++) {\\n    if (a % 10 == 1) cnt++;\\n    a \\/= 10;\\n  }\\n  return cnt;\\n}\\nint main() {\\n  ios::sync_with_stdio(false);\\n  cin.tie(NULL);\\n  int n, a = 0, b = 0, cnt = INF;\\n  cin >> n;\\n  vector<int> p;\\n  if (n == 1)\\n    cout << \\\"6\\\";\\n  else {\\n    for (int i = 0; i < int(n); i++) {\\n      cin >>...\",\"language\":\"python\",\"split\":\"train\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"DZY has a sequence a, consisting of n integers.\\n\\nWe'll call a sequence ai, ai + 1, ..., aj (1 \u2264 i \u2264 j \u2264 n) a subsegment of the sequence a. The value (j - i + 1) denotes the length of the subsegment.\\n\\nYour task is to find the longest subsegment of a, such that it is possible to change at most one number (change one number to any integer you want) from the subsegment to make the subsegment strictly increasing.\\n\\nYou only need to output the length of the subsegment you find.\\n\\nInput\\n\\nThe first line contains integer n (1 \u2264 n \u2264 105). The next line contains n integers a1, a2, ..., an (1 \u2264 ai \u2264 109).\\n\\nOutput\\n\\nIn a single line print the answer to the problem \u2014 the maximum length of the required subsegment.\\n\\nExamples\\n\\nInput\\n\\n6\\n7 2 3 1 5 6\\n\\n\\nOutput\\n\\n5\\n\\nNote\\n\\nYou can choose subsegment a2, a3, a4, a5, a6 and change its 3rd element (that is a4) to 4.\\nThe above is tricky. Write me a correct solution in PYTHON3.\",\"targets\":\"n=int(input())\\n\\ns=input()\\ns1=s.split()\\nl=[int(i) for i in s1]\\n\\ndp1=[1 for i in range(len(l))]\\n\\n\\nfor i in range(1,len(l)):\\n\\n    if l[i]>l[i-1]:\\n\\n        dp1[i]=dp1[i-1]+1\\n\\ndp2=[1 for i in range(len(l))]\\n\\nfor i in range(len(l)-2,-1,-1):\\n\\n    if l[i]<l[i+1]:\\n\\n        dp2[i]=dp2[i+1]+1\\nmaxlen=max(dp1)\\n\\nfor i in range(0,len(l)):\\n\\n    if i+1<len(l) and i-1>=0 and l[i+1]>l[i-1]+1:\\n\\n        maxlen=max(dp1[i-1]+dp2[i+1]+1,maxlen)\\n        \\n    if i-1>=0 and l[i]<=l[i-1]:\\n        \\n        maxlen=max(maxlen,dp1[i-1]+1)\\n\\n    if i+1<len(l) and l[i]>=l[i+1]:\\n\\n        maxlen=max(maxlen,dp2[i+1]+1)\\n\\n    \\n\\nprint(maxlen)\",\"language\":\"python\",\"split\":\"train\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Dawid has four bags of candies. The i-th of them contains a_i candies. Also, Dawid has two friends. He wants to give each bag to one of his two friends. Is it possible to distribute the bags in such a way that each friend receives the same amount of candies in total?\\n\\nNote, that you can't keep bags for yourself or throw them away, each bag should be given to one of the friends.\\n\\nInput\\n\\nThe only line contains four integers a_1, a_2, a_3 and a_4 (1 \u2264 a_i \u2264 100) \u2014 the numbers of candies in each bag.\\n\\nOutput\\n\\nOutput YES if it's possible to give the bags to Dawid's friends so that both friends receive the same amount of candies, or NO otherwise. Each character can be printed in any case (either uppercase or lowercase).\\n\\nExamples\\n\\nInput\\n\\n\\n1 7 11 5\\n\\n\\nOutput\\n\\n\\nYES\\n\\n\\nInput\\n\\n\\n7 3 2 5\\n\\n\\nOutput\\n\\n\\nNO\\n\\nNote\\n\\nIn the first sample test, Dawid can give the first and the third bag to the first friend, and the second and the fourth bag to the second friend. This way, each friend will receive 12 candies.\\n\\nIn the second sample test, it's impossible to distribute the bags.\\nThe above is tricky. Write me a correct solution in PYTHON3.\",\"targets\":\"s=input()\\nlist=s.split()\\nfor i in range(4):\\n    list[i]=int(list[i])\\nlist.sort()\\nif list[0]+list[3]==list[2]+list[1] or list[0]+list[1]+list[2]==list[3]:\\n    print(\\\"YES\\\")\\nelse:\\n    print(\\\"NO\\\")\",\"language\":\"python\",\"split\":\"train\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in CPP?\\nAnfisa the monkey learns to type. She is yet unfamiliar with the \\\"space\\\" key and can only type in lower-case Latin letters. Having typed for a fairly long line, Anfisa understood that it would be great to divide what she has written into k lines not shorter than a and not longer than b, for the text to resemble human speech more. Help Anfisa.\\n\\nInput\\n\\nThe first line contains three integers k, a and b (1 \u2264 k \u2264 200, 1 \u2264 a \u2264 b \u2264 200). The second line contains a sequence of lowercase Latin letters \u2014 the text typed by Anfisa. It is guaranteed that the given line is not empty and its length does not exceed 200 symbols.\\n\\nOutput\\n\\nPrint k lines, each of which contains no less than a and no more than b symbols \u2014 Anfisa's text divided into lines. It is not allowed to perform any changes in the text, such as: deleting or adding symbols, changing their order, etc. If the solution is not unique, print any of them. If there is no solution, print \\\"No solution\\\" (without quotes). \\n\\nExamples\\n\\nInput\\n\\n3 2 5\\nabrakadabra\\n\\n\\nOutput\\n\\nab\\nrakad\\nabra\\n\\n\\nInput\\n\\n4 1 2\\nabrakadabra\\n\\n\\nOutput\\n\\nNo solution\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nbool sortin(const pair<long long int, long long int> &e,\\n            const pair<long long int, long long int> &f) {\\n  return (e.first < f.first);\\n}\\nlong long int i, j, k, l, m, n, c, p, q, ts, mn = 10e17, mod = 10e8 + 7;\\nlong long int a[250002], b[250002], x[250002];\\nint main() {\\n  {\\n    ios_base::sync_with_stdio(false);\\n    cin.tie(0);\\n    cout.tie(0);\\n  };\\n  cin >> n >> p >> q;\\n  string s;\\n  cin >> s;\\n  l = s.size();\\n  c = l % n;\\n  if (q * n < l or p * n > l) {\\n    cout << \\\"No solution\\\";\\n    return 0;\\n  }\\n  for (long long int i = 0; i <= n - 1; i++) {\\n    if (c)\\n      cout << s.substr(k, l \\/ n + 1), c--, k += l \\/ n + 1;\\n    else\\n      cout << s.substr(k, l \\/ n), k += l \\/ n;\\n    cout << endl;\\n  }\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Alice and Borys are playing tennis.\\n\\nA tennis match consists of games. In each game, one of the players is serving and the other one is receiving.\\n\\nPlayers serve in turns: after a game where Alice is serving follows a game where Borys is serving, and vice versa.\\n\\nEach game ends with a victory of one of the players. If a game is won by the serving player, it's said that this player holds serve. If a game is won by the receiving player, it's said that this player breaks serve.\\n\\nIt is known that Alice won a games and Borys won b games during the match. It is unknown who served first and who won which games.\\n\\nFind all values of k such that exactly k breaks could happen during the match between Alice and Borys in total.\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 10^3). Description of the test cases follows.\\n\\nEach of the next t lines describes one test case and contains two integers a and b (0 \u2264 a, b \u2264 10^5; a + b > 0) \u2014 the number of games won by Alice and Borys, respectively.\\n\\nIt is guaranteed that the sum of a + b over all test cases does not exceed 2 \u22c5 10^5.\\n\\nOutput\\n\\nFor each test case print two lines.\\n\\nIn the first line, print a single integer m (1 \u2264 m \u2264 a + b + 1) \u2014 the number of values of k such that exactly k breaks could happen during the match.\\n\\nIn the second line, print m distinct integers k_1, k_2, \u2026, k_m (0 \u2264 k_1 < k_2 < \u2026 < k_m \u2264 a + b) \u2014 the sought values of k in increasing order.\\n\\nExample\\n\\nInput\\n\\n\\n3\\n2 1\\n1 1\\n0 5\\n\\n\\nOutput\\n\\n\\n4\\n0 1 2 3\\n2\\n0 2\\n2\\n2 3\\n\\nNote\\n\\nIn the first test case, any number of breaks between 0 and 3 could happen during the match: \\n\\n  * Alice holds serve, Borys holds serve, Alice holds serve: 0 breaks; \\n  * Borys holds serve, Alice holds serve, Alice breaks serve: 1 break; \\n  * Borys breaks serve, Alice breaks serve, Alice holds serve: 2 breaks; \\n  * Alice breaks serve, Borys breaks serve, Alice breaks serve: 3 breaks. \\n\\n\\n\\nIn the second test case, the players could either both hold serves (0 breaks) or both break serves (2...\\nt=int\",\"targets\":\"(input())\\ndef solve(a,bseat,nseat):\\n    bsarr=0\\n    nsarr=0\\n    if a>nseat:\\n        nsarr=nseat\\n        bsarr=a-nsarr\\n    else:\\n        nsarr=a\\n    ans.add(bsarr+nseat-nsarr)\\n    curr=bsarr+nseat-nsarr\\n    while nsarr and bsarr<bseat:\\n        bsarr+=1\\n        nsarr-=1\\n        curr+=2\\n        if curr<=total:\\n            ans.add(curr)\\n\\nwhile t:\\n    t-=1\\n    a,b=[int(x) for x in input().split()]\\n    total=a+b\\n    bseat=total\\/\\/2\\n    nseat=total-bseat\\n    ans=set()\\n    solve(a,bseat,nseat)\\n    solve(a,nseat,bseat)\\n    solve(b,bseat,nseat)\\n    solve(b,nseat,bseat)\\n    print(len(ans))\\n    print(*sorted(ans))\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"Consider a sequence of integers a_1, a_2, \u2026, a_n. In one move, you can select any element of the sequence and delete it. After an element is deleted, all elements to the right are shifted to the left by 1 position, so there are no empty spaces in the sequence. So after you make a move, the sequence's length decreases by 1. The indices of the elements after the move are recalculated.\\n\\nE. g. let the sequence be a=[3, 2, 2, 1, 5]. Let's select the element a_3=2 in a move. Then after the move the sequence will be equal to a=[3, 2, 1, 5], so the 3-rd element of the new sequence will be a_3=1 and the 4-th element will be a_4=5.\\n\\nYou are given a sequence a_1, a_2, \u2026, a_n and a number k. You need to find the minimum number of moves you have to make so that in the resulting sequence there will be at least k elements that are equal to their indices, i. e. the resulting sequence b_1, b_2, \u2026, b_m will contain at least k indices i such that b_i = i.\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 100) \u2014 the number of test cases. Then t test cases follow.\\n\\nEach test case consists of two consecutive lines. The first line contains two integers n and k (1 \u2264 k \u2264 n \u2264 2000). The second line contains a sequence of integers a_1, a_2, \u2026, a_n (1 \u2264 a_i \u2264 n). The numbers in the sequence are not necessarily different.\\n\\nIt is guaranteed that the sum of n over all test cases doesn't exceed 2000.\\n\\nOutput\\n\\nFor each test case output in a single line:\\n\\n  * -1 if there's no desired move sequence; \\n  * otherwise, the integer x (0 \u2264 x \u2264 n) \u2014 the minimum number of the moves to be made so that the resulting sequence will contain at least k elements that are equal to their indices. \\n\\nExample\\n\\nInput\\n\\n\\n4\\n7 6\\n1 1 2 3 4 5 6\\n5 2\\n5 1 3 2 3\\n5 2\\n5 5 5 5 4\\n8 4\\n1 2 3 3 2 2 5 5\\n\\n\\nOutput\\n\\n\\n1\\n2\\n-1\\n2\\n\\nNote\\n\\nIn the first test case the sequence doesn't satisfy the desired condition, but it can be provided by deleting the first element, hence the sequence will be [1, 2, 3, 4, 5, 6] and 6 elements will be equal to their indices.\\n\\nIn the second test case...\\\":\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst long long maxn = 2e5 + 50;\\nlong long n, dp[maxn], k, a[maxn], b[maxn], tp[maxn];\\nvoid solve() {\\n  for (long long i = 1; i <= n; i++) b[i] = i - a[i];\\n  long long pos = 1, ans = 1e18;\\n  for (long long i = 1; i <= n; i++) {\\n    dp[i] = (b[i] >= 0);\\n    for (long long j = 1; j <= i - 1; j++) {\\n      if (b[i] >= 0 and a[i] > a[j] and b[j] <= b[i]) {\\n        dp[i] = max(dp[i], dp[j] + 1);\\n      }\\n    }\\n    if (dp[i] >= k and b[i] >= 0) {\\n      ans = min(ans, b[i]);\\n    }\\n  }\\n  if (ans != 1e18)\\n    cout << ans << '\\\\n';\\n  else\\n    cout << -1 << '\\\\n';\\n}\\nvoid input() {\\n  cin >> n >> k;\\n  for (long long i = 1; i <= n; i++) cin >> a[i], dp[i] = 0;\\n}\\nsigned main() {\\n  ios_base::sync_with_stdio(false), cin.tie(0);\\n  ;\\n  long long tt;\\n  cin >> tt;\\n  while (tt--) {\\n    input();\\n    solve();\\n  }\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"This is the hard version of the problem. The difference between the versions is that the hard version does require you to output the numbers of the rods to be removed. You can make hacks only if all versions of the problem are solved.\\n\\nStitch likes experimenting with different machines with his friend Sparky. Today they built another machine.\\n\\nThe main element of this machine are n rods arranged along one straight line and numbered from 1 to n inclusive. Each of these rods must carry an electric charge quantitatively equal to either 1 or -1 (otherwise the machine will not work). Another condition for this machine to work is that the sign-variable sum of the charge on all rods must be zero.\\n\\nMore formally, the rods can be represented as an array of n numbers characterizing the charge: either 1 or -1. Then the condition must hold: a_1 - a_2 + a_3 - a_4 + \u2026 = 0, or \u2211_{i=1}^n (-1)^{i-1} \u22c5 a_i = 0.\\n\\nSparky charged all n rods with an electric current, but unfortunately it happened that the rods were not charged correctly (the sign-variable sum of the charge is not zero). The friends decided to leave only some of the rods in the machine. Sparky has q questions. In the ith question Sparky asks: if the machine consisted only of rods with numbers l_i to r_i inclusive, what minimal number of rods could be removed from the machine so that the sign-variable sum of charges on the remaining ones would be zero? Also Sparky wants to know the numbers of these rods. Perhaps the friends got something wrong, and the sign-variable sum is already zero. In that case, you don't have to remove the rods at all.\\n\\nIf the number of rods is zero, we will assume that the sign-variable sum of charges is zero, that is, we can always remove all rods.\\n\\nHelp your friends and answer all of Sparky's questions!\\n\\nInput\\n\\nEach test contains multiple test cases.\\n\\nThe first line contains one positive integer t (1 \u2264 t \u2264 10^3), denoting the number of test cases. Description of the test cases follows.\\n\\nThe first line of each test case contains two positive...\\nSolve the task in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst int INF = 0x3f3f3f3f, N = 1e5 + 10;\\nconst int MOD = 1e9 + 7;\\nconst double eps = 1e-6;\\nconst double PI = acos(-1);\\ninline int lowbit(int x) { return x & (-x); }\\ninline void solve() {\\n  int n, m;\\n  cin >> n >> m;\\n  string s;\\n  cin >> s;\\n  s = '#' + s;\\n  vector<int> pre(n + 1, 0);\\n  map<int, vector<int>> f;\\n  for (int i = 1; i <= n; i++) {\\n    int now = ((s[i] == '+') ^ (i & 1) ? -1 : 1);\\n    pre[i] = pre[i - 1] + now;\\n    f[pre[i] + pre[i - 1]].push_back(i);\\n  }\\n  while (m--) {\\n    int ll, rr;\\n    cin >> ll >> rr;\\n    int val = pre[rr] - pre[ll - 1];\\n    if (val == 0)\\n      cout << 0 << '\\\\n';\\n    else {\\n      if (val & 1) {\\n        cout << 1 << '\\\\n';\\n        int now = pre[rr] + pre[ll - 1];\\n        int l = 0, r = (int)f[now].size() - 1;\\n        while (l < r) {\\n          int mid = (l + r + 1) >> 1;\\n          if (f[now][mid] >= ll && f[now][mid] <= rr) {\\n            l = mid;\\n            break;\\n          } else {\\n            if (f[now][mid] < ll)\\n              l = mid;\\n            else\\n              r = mid - 1;\\n          }\\n        }\\n        cout << f[now][l] << '\\\\n';\\n      } else {\\n        cout << 2 << '\\\\n';\\n        if (rr - ll == 1)\\n          cout << ll << ' ' << rr << '\\\\n';\\n        else {\\n          for (int i = ll; i < rr; i++) {\\n            int now = val + pre[i] + pre[i - 1];\\n            if (f[now].empty()) continue;\\n            int l = 0, r = (int)f[now].size() - 1;\\n            while (l < r) {\\n              int mid = (l + r + 1) >> 1;\\n              if (f[now][mid] > i && f[now][mid] <= rr) {\\n                l = mid;\\n                break;\\n              } else {\\n                if (f[now][mid] < ll)\\n                  l = mid;\\n                else\\n                  r = mid - 1;\\n              }\\n            }\\n            if (f[now][l] > i && f[now][l] <= rr) {\\n              cout << i << ' ' << f[now][l] << '\\\\n';\\n              break;\\n            }\\n          }\\n        }\\n      }\\n    }\\n  }\\n}\\nint main() {\\n  ios::sync_with_stdio(false), cin.tie(nullptr);\\n  cout <<...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Ezzat has an array of n integers (maybe negative). He wants to split it into two non-empty subsequences a and b, such that every element from the array belongs to exactly one subsequence, and the value of f(a) + f(b) is the maximum possible value, where f(x) is the average of the subsequence x. \\n\\nA sequence x is a subsequence of a sequence y if x can be obtained from y by deletion of several (possibly, zero or all) elements.\\n\\nThe average of a subsequence is the sum of the numbers of this subsequence divided by the size of the subsequence.\\n\\nFor example, the average of [1,5,6] is (1+5+6)\\/3 = 12\\/3 = 4, so f([1,5,6]) = 4.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 10^3)\u2014 the number of test cases. Each test case consists of two lines.\\n\\nThe first line contains a single integer n (2 \u2264 n \u2264 10^5).\\n\\nThe second line contains n integers a_1, a_2, \u2026, a_n (-10^9 \u2264 a_i \u2264 10^9).\\n\\nIt is guaranteed that the sum of n over all test cases does not exceed 3\u22c510^5.\\n\\nOutput\\n\\nFor each test case, print a single value \u2014 the maximum value that Ezzat can achieve.\\n\\nYour answer is considered correct if its absolute or relative error does not exceed 10^{-6}.\\n\\nFormally, let your answer be a, and the jury's answer be b. Your answer is accepted if and only if \\\\frac{|a - b|}{max{(1, |b|)}} \u2264 10^{-6}.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n3\\n3 1 2\\n3\\n-7 -6 -6\\n3\\n2 2 2\\n4\\n17 3 5 -3\\n\\n\\nOutput\\n\\n\\n4.500000000\\n-12.500000000\\n4.000000000\\n18.666666667\\n\\nNote\\n\\nIn the first test case, the array is [3, 1, 2]. These are all the possible ways to split this array: \\n\\n  * a = [3], b = [1,2], so the value of f(a) + f(b) = 3 + 1.5 = 4.5. \\n  * a = [3,1], b = [2], so the value of f(a) + f(b) = 2 + 2 = 4. \\n  * a = [3,2], b = [1], so the value of f(a) + f(b) = 2.5 + 1 = 3.5. \\n\\nTherefore, the maximum possible value 4.5.\\n\\nIn the second test case, the array is [-7, -6, -6]. These are all the possible ways to split this array: \\n\\n  * a = [-7], b = [-6,-6], so the value of f(a) + f(b) = (-7) + (-6) = -13. \\n  * a = [-7,-6], b = [-6], so the value of f(a) + f(b) = (-6.5) + (-6) =...\\nThe above is tricky. Write me a correct solution in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\ntemplate <class T>\\nvoid _print(T a) {\\n  cerr << a;\\n}\\ntemplate <class T>\\nvoid _print(vector<T> v) {\\n  cerr << \\\"[\\\";\\n  for (T i : v) {\\n    _print(i);\\n    cerr << \\\" \\\";\\n  }\\n  cerr << \\\"]\\\";\\n}\\ntemplate <class T, class V>\\nvoid _print(pair<T, V> p) {\\n  cerr << \\\"{\\\";\\n  _print(p.first);\\n  cerr << \\\",\\\";\\n  _print(p.second);\\n  cerr << \\\"}\\\";\\n}\\ntemplate <class T>\\nvoid _print(set<T> s) {\\n  cerr << \\\"[\\\";\\n  for (T i : s) {\\n    _print(i);\\n    cerr << \\\" \\\";\\n  }\\n  cerr << \\\"]\\\";\\n}\\ntemplate <class T>\\nvoid _print(multiset<T> s) {\\n  cerr << \\\"[\\\";\\n  for (T i : s) {\\n    _print(i);\\n    cerr << \\\" \\\";\\n  }\\n  cerr << \\\"]\\\";\\n}\\ntemplate <class T, class V>\\nvoid _print(map<T, V> v) {\\n  cerr << \\\"[ \\\";\\n  for (auto i : v) {\\n    _print(i);\\n    cerr << \\\" \\\";\\n  }\\n  cerr << \\\"]\\\";\\n}\\ntemplate <class T, class V>\\nvoid _print(unordered_map<T, V> v) {\\n  cerr << \\\"[ \\\";\\n  for (auto i : v) {\\n    _print(i);\\n    cerr << \\\" \\\";\\n  }\\n  cerr << \\\"]\\\";\\n}\\nvoid solve() {\\n  float n;\\n  cin >> n;\\n  vector<double> a(n);\\n  double sum = 0;\\n  for (double i = 0; i < n; i++) {\\n    cin >> a[i];\\n    sum += a[i];\\n  }\\n  sort(a.begin(), a.end(), greater<double>());\\n  double curr = 0;\\n  double ans = INT_MIN;\\n  for (float i = 0; i < n - 1; i++) {\\n    curr += a[i];\\n    double aa = (curr) \\/ (i + 1);\\n    double bb = (sum - curr) \\/ (n - i - 1);\\n    double cc = aa + bb;\\n    ans = max(ans, cc);\\n  }\\n  cout << fixed << setprecision(6) << ans << endl;\\n}\\nsigned main() {\\n  ios_base::sync_with_stdio(false);\\n  cin.tie(NULL);\\n  long long int t = 1;\\n  cin >> t;\\n  for (long long int i = 1; i <= t; i++) {\\n    solve();\\n  }\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in JAVA?\\n<image>\\n\\nThis is an interactive task\\n\\nWilliam has a certain sequence of integers a_1, a_2, ..., a_n in his mind, but due to security concerns, he does not want to reveal it to you completely. William is ready to respond to no more than 2 \u22c5 n of the following questions:\\n\\n  * What is the result of a [bitwise AND](https:\\/\\/en.wikipedia.org\\/wiki\\/Bitwise_operation#AND) of two items with indices i and j (i \u2260 j) \\n  * What is the result of a [bitwise OR](https:\\/\\/en.wikipedia.org\\/wiki\\/Bitwise_operation#OR) of two items with indices i and j (i \u2260 j) \\n\\n\\n\\nYou can ask William these questions and you need to find the k-th smallest number of the sequence.\\n\\nFormally the k-th smallest number is equal to the number at the k-th place in a 1-indexed array sorted in non-decreasing order. For example in array [5, 3, 3, 10, 1] 4th smallest number is equal to 5, and 2nd and 3rd are 3.\\n\\nInput\\n\\nIt is guaranteed that for each element in a sequence the condition 0 \u2264 a_i \u2264 10^9 is satisfied.\\n\\nInteraction\\n\\nIn the first line you will be given two integers n and k (3 \u2264 n \u2264 10^4, 1 \u2264 k \u2264 n), which are the number of items in the sequence a and the number k.\\n\\nAfter that, you can ask no more than 2 \u22c5 n questions (not including the \\\"finish\\\" operation).\\n\\nEach line of your output may be of one of the following types: \\n\\n  * \\\"or i j\\\" (1 \u2264 i, j \u2264 n, i \u2260 j), where i and j are indices of items for which you want to calculate the bitwise OR. \\n  * \\\"and i j\\\" (1 \u2264 i, j \u2264 n, i \u2260 j), where i and j are indices of items for which you want to calculate the bitwise AND. \\n  * \\\"finish res\\\", where res is the kth smallest number in the sequence. After outputting this line the program execution must conclude. \\n\\n\\n\\nIn response to the first two types of queries, you will get an integer x, the result of the operation for the numbers you have selected.\\n\\nAfter outputting a line do not forget to output a new line character and flush the output buffer. Otherwise you will get the \\\"Idleness limit exceeded\\\". To flush the buffer use:\\n\\n  * fflush(stdout) in C++ \\n  *...\",\"targets\":\"import java.io.OutputStream;\\nimport java.io.IOException;\\nimport java.io.InputStream;\\nimport java.io.OutputStream;\\nimport java.io.PrintWriter;\\nimport java.util.Arrays;\\nimport java.io.BufferedWriter;\\nimport java.io.Writer;\\nimport java.io.OutputStreamWriter;\\nimport java.util.InputMismatchException;\\nimport java.io.IOException;\\nimport java.io.InputStream;\\n\\n\\/**\\n * Built using CHelper plug-in\\n * Actual solution is at the top\\n *\\/\\npublic class Main {\\n    public static void main(String[] args) {\\n        InputStream inputStream = System.in;\\n        OutputStream outputStream = System.out;\\n        InputReader in = new InputReader(inputStream);\\n        OutputWriter out = new OutputWriter(outputStream);\\n        DTakeAGuess solver = new DTakeAGuess();\\n        solver.solve(1, in, out);\\n        out.close();\\n    }\\n\\n    static class DTakeAGuess {\\n        InputReader in;\\n        OutputWriter out;\\n\\n        public void solve(int testNumber, InputReader in, OutputWriter out) {\\n            this.in = in;\\n            this.out = out;\\n            int n = in.nextInt();\\n            int k = in.nextInt();\\n            int[] a = new int[n];\\n            int s12 = add(1, 2) + or(1, 2);\\n            int s13 = add(1, 3) + or(1, 3);\\n            int s23 = add(2, 3) + or(2, 3);\\n            a[0] = (s12 + s13 - s23) \\/ 2;\\n            a[1] = s13 - a[0];\\n            a[2] = s23 - a[1];\\n\\n            for (int i = 3; i < n; i++) {\\n                int s = add(1, i + 1) + or(1, i + 1);\\n                a[i] = s - a[0];\\n            }\\n            Arrays.sort(a);\\n            finish(a[k - 1]);\\n        }\\n\\n        int add(int x, int y) {\\n            out.println(\\\"and \\\" + x + \\\" \\\" + y);\\n            out.flush();\\n            return in.nextInt();\\n        }\\n\\n        int or(int x, int y) {\\n            out.println(\\\"or \\\" + x + \\\" \\\" + y);\\n            out.flush();\\n            return in.nextInt();\\n        }\\n\\n        void finish(int x) {\\n            out.println(\\\"finish \\\" + x);\\n            out.flush();\\n        }\\n\\n    }\\n\\n    static class OutputWriter {\\n        private final PrintWriter...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Note that the memory limit in this problem is lower than in others.\\n\\nYou have a vertical strip with n cells, numbered consecutively from 1 to n from top to bottom.\\n\\nYou also have a token that is initially placed in cell n. You will move the token up until it arrives at cell 1.\\n\\nLet the token be in cell x > 1 at some moment. One shift of the token can have either of the following kinds: \\n\\n  * Subtraction: you choose an integer y between 1 and x-1, inclusive, and move the token from cell x to cell x - y. \\n  * Floored division: you choose an integer z between 2 and x, inclusive, and move the token from cell x to cell \u230a x\\/z \u230b (x divided by z rounded down). \\n\\n\\n\\nFind the number of ways to move the token from cell n to cell 1 using one or more shifts, and print it modulo m. Note that if there are several ways to move the token from one cell to another in one shift, all these ways are considered distinct (check example explanation for a better understanding).\\n\\nInput\\n\\nThe only line contains two integers n and m (2 \u2264 n \u2264 4 \u22c5 10^6; 10^8 < m < 10^9; m is a prime number) \u2014 the length of the strip and the modulo.\\n\\nOutput\\n\\nPrint the number of ways to move the token from cell n to cell 1, modulo m.\\n\\nExamples\\n\\nInput\\n\\n\\n3 998244353\\n\\n\\nOutput\\n\\n\\n5\\n\\n\\nInput\\n\\n\\n5 998244353\\n\\n\\nOutput\\n\\n\\n25\\n\\n\\nInput\\n\\n\\n42 998244353\\n\\n\\nOutput\\n\\n\\n793019428\\n\\n\\nInput\\n\\n\\n787788 100000007\\n\\n\\nOutput\\n\\n\\n94810539\\n\\nNote\\n\\nIn the first test, there are three ways to move the token from cell 3 to cell 1 in one shift: using subtraction of y = 2, or using division by z = 2 or z = 3.\\n\\nThere are also two ways to move the token from cell 3 to cell 1 via cell 2: first subtract y = 1, and then either subtract y = 1 again or divide by z = 2.\\n\\nTherefore, there are five ways in total.\\nThe above is tricky. Write me a correct solution in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint f[4000001];\\nint n, m;\\nint main() {\\n  cin >> n >> m;\\n  f[1] = 1;\\n  for (int i = 2; i <= n; i++) {\\n    f[i] = (i == 2) ? 2 : (f[i] + ((f[i - 1] * 2) % m) + 1) % m;\\n    for (int j = 2; j * i <= n; j++) {\\n      int dif = f[i] - f[i - 1];\\n      if (dif < 0) dif = m + dif;\\n      f[i * j] = (f[i * j] + dif) % m;\\n    }\\n  }\\n  cout << f[n];\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"A permutation of length n is a sequence of integers from 1 to n of length n containing each number exactly once. For example, [1], [4, 3, 5, 1, 2], [3, 2, 1] are permutations, and [1, 1], [0, 1], [2, 2, 1, 4] are not.\\n\\nThere was a permutation p[1 ... n]. It was merged with itself. In other words, let's take two instances of p and insert elements of the second p into the first maintaining relative order of elements. The result is a sequence of the length 2n.\\n\\nFor example, if p=[3, 1, 2] some possible results are: [3, 1, 2, 3, 1, 2], [3, 3, 1, 1, 2, 2], [3, 1, 3, 1, 2, 2]. The following sequences are not possible results of a merging: [1, 3, 2, 1, 2, 3], [3, 1, 2, 3, 2, 1], [3, 3, 1, 2, 2, 1].\\n\\nFor example, if p=[2, 1] the possible results are: [2, 2, 1, 1], [2, 1, 2, 1]. The following sequences are not possible results of a merging: [1, 1, 2, 2], [2, 1, 1, 2], [1, 2, 2, 1].\\n\\nYour task is to restore the permutation p by the given resulting sequence a. It is guaranteed that the answer exists and is unique.\\n\\nYou have to answer t independent test cases.\\n\\nInput\\n\\nThe first line of the input contains one integer t (1 \u2264 t \u2264 400) \u2014 the number of test cases. Then t test cases follow.\\n\\nThe first line of the test case contains one integer n (1 \u2264 n \u2264 50) \u2014 the length of permutation. The second line of the test case contains 2n integers a_1, a_2, ..., a_{2n} (1 \u2264 a_i \u2264 n), where a_i is the i-th element of a. It is guaranteed that the array a represents the result of merging of some permutation p with the same permutation p.\\n\\nOutput\\n\\nFor each test case, print the answer: n integers p_1, p_2, ..., p_n (1 \u2264 p_i \u2264 n), representing the initial permutation. It is guaranteed that the answer exists and is unique.\\n\\nExample\\n\\nInput\\n\\n\\n5\\n2\\n1 1 2 2\\n4\\n1 3 1 4 3 4 2 2\\n5\\n1 2 1 2 3 4 3 5 4 5\\n3\\n1 2 3 1 2 3\\n4\\n2 3 2 4 1 3 4 1\\n\\n\\nOutput\\n\\n\\n1 2 \\n1 3 4 2 \\n1 2 3 4 5 \\n1 2 3 \\n2 3 4 1 \\nThe above is tricky. Write me a correct solution in PYTHON3.\",\"targets\":\"import sys,collections,math\\n######################################\\ndef in_out():\\n    sys.stdin = open('input.txt', 'r')  \\n    sys.stdout = open('output.txt', 'w')\\n#in_out()\\n######################################\\n\\nfor _ in range(int(input())):\\n      n = int(input())\\n      arr=list(map(int,input().split()))\\n      visit = set()\\n      res=[]\\n      for ele in arr:\\n        if ele not in visit:\\n            visit.add(ele)\\n            res.append(ele)\\n      \\n      print(*res)\",\"language\":\"python\",\"split\":\"train\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Anton's favourite geometric figures are regular polyhedrons. Note that there are five kinds of regular polyhedrons: \\n\\n  * Tetrahedron. Tetrahedron has 4 triangular faces. \\n  * Cube. Cube has 6 square faces. \\n  * Octahedron. Octahedron has 8 triangular faces. \\n  * Dodecahedron. Dodecahedron has 12 pentagonal faces. \\n  * Icosahedron. Icosahedron has 20 triangular faces. \\n\\n\\n\\nAll five kinds of polyhedrons are shown on the picture below:\\n\\n<image>\\n\\nAnton has a collection of n polyhedrons. One day he decided to know, how many faces his polyhedrons have in total. Help Anton and find this number!\\n\\nInput\\n\\nThe first line of the input contains a single integer n (1 \u2264 n \u2264 200 000) \u2014 the number of polyhedrons in Anton's collection.\\n\\nEach of the following n lines of the input contains a string si \u2014 the name of the i-th polyhedron in Anton's collection. The string can look like this:\\n\\n  * \\\"Tetrahedron\\\" (without quotes), if the i-th polyhedron in Anton's collection is a tetrahedron. \\n  * \\\"Cube\\\" (without quotes), if the i-th polyhedron in Anton's collection is a cube. \\n  * \\\"Octahedron\\\" (without quotes), if the i-th polyhedron in Anton's collection is an octahedron. \\n  * \\\"Dodecahedron\\\" (without quotes), if the i-th polyhedron in Anton's collection is a dodecahedron. \\n  * \\\"Icosahedron\\\" (without quotes), if the i-th polyhedron in Anton's collection is an icosahedron. \\n\\nOutput\\n\\nOutput one number \u2014 the total number of faces in all the polyhedrons in Anton's collection.\\n\\nExamples\\n\\nInput\\n\\n4\\nIcosahedron\\nCube\\nTetrahedron\\nDodecahedron\\n\\n\\nOutput\\n\\n42\\n\\n\\nInput\\n\\n3\\nDodecahedron\\nOctahedron\\nOctahedron\\n\\n\\nOutput\\n\\n28\\n\\nNote\\n\\nIn the first sample Anton has one icosahedron, one cube, one tetrahedron and one dodecahedron. Icosahedron has 20 faces, cube has 6 faces, tetrahedron has 4 faces and dodecahedron has 12 faces. In total, they have 20 + 6 + 4 + 12 = 42 faces.\\ndef p\",\"targets\":\"oly():\\n    poly = {'Tetrahedron': 4, 'Cube': 6, 'Octahedron': 8, 'Dodecahedron': 12, 'Icosahedron': 20}\\n    count = 0\\n    n = int(raw_input())\\n    while n > 0:\\n        shape = raw_input()\\n        count += poly.get(shape)\\n        n -= 1\\n\\n    return count\\n\\n\\nprint poly()\",\"language\":\"python\",\"split\":\"train\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"Due to the increase in the number of students of Berland State University it was decided to equip a new computer room. You were given the task of buying mouses, and you have to spend as little as possible. After all, the country is in crisis!\\n\\nThe computers bought for the room were different. Some of them had only USB ports, some \u2014 only PS\\/2 ports, and some had both options.\\n\\nYou have found a price list of a certain computer shop. In it, for m mouses it is specified the cost and the type of the port that is required to plug the mouse in (USB or PS\\/2). Each mouse from the list can be bought at most once.\\n\\nYou want to buy some set of mouses from the given price list in such a way so that you maximize the number of computers equipped with mouses (it is not guaranteed that you will be able to equip all of the computers), and in case of equality of this value you want to minimize the total cost of mouses you will buy.\\n\\nInput\\n\\nThe first line contains three integers a, b and c (0 \u2264 a, b, c \u2264 105) \u2014 the number of computers that only have USB ports, the number of computers, that only have PS\\/2 ports, and the number of computers, that have both options, respectively.\\n\\nThe next line contains one integer m (0 \u2264 m \u2264 3\u00b7105) \u2014 the number of mouses in the price list.\\n\\nThe next m lines each describe another mouse. The i-th line contains first integer vali (1 \u2264 vali \u2264 109) \u2014 the cost of the i-th mouse, then the type of port (USB or PS\\/2) that is required to plug the mouse in.\\n\\nOutput\\n\\nOutput two integers separated by space \u2014 the number of equipped computers and the total cost of the mouses you will buy.\\n\\nExample\\n\\nInput\\n\\n2 1 1\\n4\\n5 USB\\n6 PS\\/2\\n3 PS\\/2\\n7 PS\\/2\\n\\n\\nOutput\\n\\n3 14\\n\\nNote\\n\\nIn the first example you can buy the first three mouses. This way you will equip one of the computers that has only a USB port with a USB mouse, and the two PS\\/2 mouses you will plug into the computer with PS\\/2 port and the computer with both ports.\\\":\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint main() {\\n  int a, b, c, m, ans = 0;\\n  long long cost = 0;\\n  cin >> a >> b >> c >> m;\\n  vector<pair<int, string> > ms;\\n  ms.resize(m);\\n  for (int i = 0; i < m; i++) {\\n    cin >> ms[i].first >> ms[i].second;\\n  }\\n  sort(ms.begin(), ms.end());\\n  for (int i = 0; i < m; i++) {\\n    if (a && ms[i].second[0] == 'U') {\\n      a--;\\n      ans++;\\n      cost += ms[i].first;\\n    } else if (b && ms[i].second[0] == 'P') {\\n      b--;\\n      ans++;\\n      cost += ms[i].first;\\n    } else if (c) {\\n      c--;\\n      ans++;\\n      cost += ms[i].first;\\n    } else\\n      continue;\\n  }\\n  cout << ans << \\\" \\\" << cost << endl;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"When you play the game of thrones, you win, or you die. There is no middle ground.\\n\\nCersei Lannister, A Game of Thrones by George R. R. Martin\\n\\nThere are n nobles, numbered from 1 to n. Noble i has a power of i. There are also m \\\"friendships\\\". A friendship between nobles a and b is always mutual.\\n\\nA noble is defined to be vulnerable if both of the following conditions are satisfied: \\n\\n  * the noble has at least one friend, and \\n  * all of that noble's friends have a higher power. \\n\\n\\n\\nYou will have to process the following three types of queries. \\n\\n  1. Add a friendship between nobles u and v. \\n  2. Remove a friendship between nobles u and v. \\n  3. Calculate the answer to the following process. \\n\\n\\n\\nThe process: all vulnerable nobles are simultaneously killed, and all their friendships end. Then, it is possible that new nobles become vulnerable. The process repeats itself until no nobles are vulnerable. It can be proven that the process will end in finite time. After the process is complete, you need to calculate the number of remaining nobles.\\n\\nNote that the results of the process are not carried over between queries, that is, every process starts with all nobles being alive!\\n\\nInput\\n\\nThe first line contains the integers n and m (1 \u2264 n \u2264 2\u22c5 10^5, 0 \u2264 m \u2264 2\u22c5 10^5) \u2014 the number of nobles and number of original friendships respectively.\\n\\nThe next m lines each contain the integers u and v (1 \u2264 u,v \u2264 n, u \u2260 v), describing a friendship. No friendship is listed twice.\\n\\nThe next line contains the integer q (1 \u2264 q \u2264 2\u22c5 {10}^{5}) \u2014 the number of queries. \\n\\nThe next q lines contain the queries themselves, each query has one of the following three formats. \\n\\n  * 1 u v (1 \u2264 u,v \u2264 n, u \u2260 v) \u2014 add a friendship between u and v. It is guaranteed that u and v are not friends at this moment. \\n  * 2 u v (1 \u2264 u,v \u2264 n, u \u2260 v) \u2014 remove a friendship between u and v. It is guaranteed that u and v are friends at this moment. \\n  * 3 \u2014 print the answer to the process described in the statement. \\n\\nOutput\\n\\nFor each type 3 query print one...\\\":\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst int N = 2e5 + 10;\\nset<int> grf[N];\\nbool rem[N];\\nint asd(int u) {\\n  ;\\n  bool ok = grf[u].lower_bound(u) != grf[u].end();\\n  return rem[u] ? (ok ? 0 : (rem[u] = false, -1)) : (ok ? rem[u] = ok : 0);\\n}\\nvoid run() {\\n  int n, m, ans;\\n  cin >> n >> m;\\n  ans = n;\\n  for (int i = 0, u, v; i < m; i++) {\\n    cin >> u >> v;\\n    grf[u].insert(v);\\n    grf[v].insert(u);\\n    ans -= asd(u);\\n    ans -= asd(v);\\n  }\\n  int q;\\n  cin >> q;\\n  while (q--) {\\n    int o, u, v;\\n    cin >> o;\\n    if (o == 1) {\\n      cin >> u >> v;\\n      grf[u].insert(v);\\n      grf[v].insert(u);\\n      ans -= asd(u);\\n      ans -= asd(v);\\n    } else if (o == 2) {\\n      cin >> u >> v;\\n      grf[u].erase(v);\\n      grf[v].erase(u);\\n      ans -= asd(u);\\n      ans -= asd(v);\\n    } else {\\n      cout << ans << endl;\\n    }\\n  }\\n}\\nint main(int argc, char const *argv[]) {\\n  ios_base::sync_with_stdio(false);\\n  cin.tie(NULL);\\n  cout.tie(NULL);\\n  int t = 1;\\n  while (t--) {\\n    run();\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"Consider a simplified penalty phase at the end of a football match.\\n\\nA penalty phase consists of at most 10 kicks, the first team takes the first kick, the second team takes the second kick, then the first team takes the third kick, and so on. The team that scores more goals wins; if both teams score the same number of goals, the game results in a tie (note that it goes against the usual football rules). The penalty phase is stopped if one team has scored more goals than the other team could reach with all of its remaining kicks. For example, if after the 7-th kick the first team has scored 1 goal, and the second team has scored 3 goals, the penalty phase ends \u2014 the first team cannot reach 3 goals.\\n\\nYou know which player will be taking each kick, so you have your predictions for each of the 10 kicks. These predictions are represented by a string s consisting of 10 characters. Each character can either be 1, 0, or ?. This string represents your predictions in the following way:\\n\\n  * if s_i is 1, then the i-th kick will definitely score a goal; \\n  * if s_i is 0, then the i-th kick definitely won't score a goal; \\n  * if s_i is ?, then the i-th kick could go either way. \\n\\n\\n\\nBased on your predictions, you have to calculate the minimum possible number of kicks there can be in the penalty phase (that means, the earliest moment when the penalty phase is stopped, considering all possible ways it could go). Note that the referee doesn't take into account any predictions when deciding to stop the penalty phase \u2014 you may know that some kick will\\/won't be scored, but the referee doesn't.\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 1 000) \u2014 the number of test cases.\\n\\nEach test case is represented by one line containing the string s, consisting of exactly 10 characters. Each character is either 1, 0, or ?.\\n\\nOutput\\n\\nFor each test case, print one integer \u2014 the minimum possible number of kicks in the penalty phase.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n1?0???1001\\n1111111111\\n??????????\\n0100000000\\n\\n\\nOutput\\n\\n\\n7\\n10\\n6\\n9\\n\\nNote\\n\\nConsider...\\\":\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint main() {\\n  int t;\\n  cin >> t;\\n  while (t--) {\\n    string s;\\n    cin >> s;\\n    int count1 = 0, count2 = 0, unknown1 = 0, unknown2 = 0;\\n    for (int i = 0; i < s.length(); i++) {\\n      int remaining = 9 - i, remaining1, remaining2;\\n      if (i % 2 == 0) {\\n        s[i] == '1' ? count1++ : s[i] == '?' && unknown1++;\\n        remaining1 = remaining \\/ 2;\\n        remaining2 = remaining - remaining1;\\n      } else {\\n        s[i] == '1' ? count2++ : s[i] == '?' && unknown2++;\\n        remaining2 = remaining \\/ 2;\\n        remaining1 = remaining - remaining2;\\n      }\\n      if (count1 + unknown1 > count2 + remaining2) {\\n        cout << i + 1 << '\\\\n';\\n        break;\\n      } else if (count2 + unknown2 > count1 + remaining1) {\\n        cout << i + 1 << '\\\\n';\\n        break;\\n      }\\n      if (i == 9) {\\n        cout << 10 << '\\\\n';\\n      }\\n    }\\n  }\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"After getting bored by playing with crayons, you decided to switch to Legos! Today, you're working with a long strip, with height 1 and length n, some positions of which are occupied by 1 by 1 Lego pieces.\\n\\nIn one second, you can either remove two adjacent Lego pieces from the strip (if both are present), or add two Lego pieces to adjacent positions (if both are absent). You can only add or remove Lego's at two adjacent positions at the same time, as otherwise your chubby fingers run into precision issues.\\n\\nYou want to know exactly how much time you'll spend playing with Legos. You value efficiency, so given some starting state and some ending state, you'll always spend the least number of seconds to transform the starting state into the ending state. If it's impossible to transform the starting state into the ending state, you just skip it (so you spend 0 seconds).\\n\\nThe issue is that, for some positions, you don't remember whether there were Legos there or not (in either the starting state, the ending state, or both). Over all pairs of (starting state, ending state) that are consistent with your memory, find the total amount of time it will take to transform the starting state to the ending state. Print this value modulo 1 000 000 007 (10^9 + 7). \\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 1000) \u2014 the number of test cases. Then t cases follow.\\n\\nThe first line of each test case contains one integer n (2 \u2264 n \u2264 2000) \u2014 the size of the Lego strip.\\n\\nThe second line of each test case contains a string s of length n, consisting of the characters 0, 1, and ? \u2014 your memory of the starting state: \\n\\n  * 1 represents a position that definitely has a Lego piece, \\n  * 0 represents a position that definitely does not have a Lego piece, \\n  * and ? represents a position that you don't remember. \\n\\n\\n\\nThe third line of each test case contains a string t of length n, consisting of the characters 0, 1, and ? \u2014 your memory of the ending state. It follows a similar format to the starting state.\\n\\nIt's guaranteed that the...\\nUsing cpp can you solve the prior task?\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst int inf = (int)1.01e9;\\nconst long long infll = (long long)1.01e18;\\nconst long double eps = 1e-9;\\nconst long double pi = acos((long double)-1);\\nmt19937 mrand(chrono::steady_clock::now().time_since_epoch().count());\\nint rnd(int x) { return mrand() % x; }\\nvoid precalc() {}\\nconst int mod = (int)1e9 + 7;\\nint mul(int a, int b) { return (long long)a * b % mod; }\\nvoid add(int &a, int b) {\\n  a += b;\\n  if (a >= mod) {\\n    a -= mod;\\n  }\\n}\\nconst int maxn = 2005;\\nchar tmp[maxn];\\nint n;\\nint a[maxn], b[maxn];\\nbool read() {\\n  if (scanf(\\\"%d\\\", &n) < 1) {\\n    return false;\\n  }\\n  scanf(\\\"%s\\\", tmp);\\n  for (int i = 0; i < n; ++i) {\\n    if (tmp[i] == '?') {\\n      a[i] = -1;\\n      continue;\\n    }\\n    a[i] = ((tmp[i] - '0') ^ (i & 1));\\n  }\\n  scanf(\\\"%s\\\", tmp);\\n  for (int i = 0; i < n; ++i) {\\n    if (tmp[i] == '?') {\\n      b[i] = -1;\\n      continue;\\n    }\\n    b[i] = ((tmp[i] - '0') ^ (i & 1));\\n  }\\n  return true;\\n}\\nint dp[maxn][maxn][2], cnt[maxn][maxn][2];\\nvoid solve() {\\n  for (int i = 0; i <= n; ++i) {\\n    for (int j = 0; j <= n; ++j) {\\n      for (int t = 0; t < 2; ++t) {\\n        dp[i][j][t] = 0;\\n        cnt[i][j][t] = 0;\\n      }\\n    }\\n  }\\n  cnt[0][0][0] = 1;\\n  for (int i = 0; i <= n; ++i) {\\n    for (int j = 0; j <= n; ++j) {\\n      for (int t = 0; t < 2; ++t) {\\n        auto cur = dp[i][j][t], curcnt = cnt[i][j][t];\\n        if (!cur && !curcnt) {\\n          continue;\\n        }\\n        if (!t) {\\n          if (i < n && a[i] != 1) {\\n            add(dp[i + 1][j][t], cur);\\n            add(cnt[i + 1][j][t], curcnt);\\n          }\\n          if (i < n && a[i] != 0) {\\n            add(dp[i][j][1], cur);\\n            add(cnt[i][j][1], curcnt);\\n          }\\n          if (i >= n) {\\n            if (j < n && b[j] != 1) {\\n              add(dp[i][j + 1][t], cur);\\n              add(cnt[i][j + 1][t], curcnt);\\n            }\\n          }\\n        } else {\\n          if (j < n && b[j] != 1) {\\n            add(dp[i][j + 1][t], cur);\\n            add(cnt[i][j + 1][t], curcnt);\\n          }\\n          if (j < n && b[j] !=...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"Petya loves hockey very much. One day, as he was watching a hockey match, he fell asleep. Petya dreamt of being appointed to change a hockey team's name. Thus, Petya was given the original team name w and the collection of forbidden substrings s1, s2, ..., sn. All those strings consist of uppercase and lowercase Latin letters. String w has the length of |w|, its characters are numbered from 1 to |w|.\\n\\nFirst Petya should find all the occurrences of forbidden substrings in the w string. During the search of substrings the case of letter shouldn't be taken into consideration. That is, strings \\\"aBC\\\" and \\\"ABc\\\" are considered equal.\\n\\nAfter that Petya should perform the replacement of all letters covered by the occurrences. More formally: a letter in the position i should be replaced by any other one if for position i in string w there exist pair of indices l, r (1 \u2264 l \u2264 i \u2264 r \u2264 |w|) such that substring w[l ... r] is contained in the collection s1, s2, ..., sn, when using case insensitive comparison. During the replacement the letter's case should remain the same. Petya is not allowed to replace the letters that aren't covered by any forbidden substring.\\n\\nLetter letter (uppercase or lowercase) is considered lucky for the hockey players. That's why Petya should perform the changes so that the letter occurred in the resulting string as many times as possible. Help Petya to find such resulting string. If there are several such strings, find the one that comes first lexicographically.\\n\\nNote that the process of replacements is not repeated, it occurs only once. That is, if after Petya's replacements the string started to contain new occurrences of bad substrings, Petya pays no attention to them.\\n\\nInput\\n\\nThe first line contains the only integer n (1 \u2264 n \u2264 100) \u2014 the number of forbidden substrings in the collection. Next n lines contain these substrings. The next line contains string w. All those n + 1 lines are non-empty strings consisting of uppercase and lowercase Latin letters whose length does not exceed 100. The last...\\\":\",\"targets\":\"#include <bits\\/stdc++.h>\\nint main(int argc, char** argv) {\\n  int n = 1;\\n  std::cin >> n;\\n  std::string subs[n];\\n  for (int i = 0; i < n; i++) {\\n    std::cin >> subs[i];\\n    for (unsigned int j = 0; j < subs[i].size(); j++)\\n      if (subs[i][j] <= 'Z') subs[i][j] += ('z' - 'Z');\\n  }\\n  std::string source;\\n  std::cin >> source;\\n  std::string str = source;\\n  for (unsigned int i = 0; i < str.size(); i++)\\n    if (str[i] <= 'Z') str[i] += ('z' - 'Z');\\n  char ch, ch2;\\n  std::cin >> ch;\\n  ch2 = (ch == 'a' ? 'b' : 'a');\\n  bool is_need_to_change[str.size()];\\n  for (unsigned int i = 0; i < str.size(); i++) is_need_to_change[i] = false;\\n  for (int k = 0; k < n; k++) {\\n    int id = 0;\\n    while (true) {\\n      std::size_t found;\\n      found = str.find(subs[k], id);\\n      if (found == std::string::npos) break;\\n      id = found + 1;\\n      for (unsigned int j = 0; j < subs[k].size(); j++)\\n        is_need_to_change[found + j] = true;\\n    }\\n  }\\n  for (unsigned int i = 0; i < source.size(); i++) {\\n    if (is_need_to_change[i]) {\\n      if (source[i] <= 'Z') {\\n        if (source[i] + 'z' - 'Z' == ch)\\n          source[i] = ch2 - 'z' + 'Z';\\n        else\\n          source[i] = ch - 'z' + 'Z';\\n      } else {\\n        if (source[i] == ch)\\n          source[i] = ch2;\\n        else\\n          source[i] = ch;\\n      }\\n    }\\n  }\\n  std::cout << source;\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"Compare given two sequence $A = \\\\\\\\{a_0, a_1, ..., a_{n-1}\\\\\\\\}$ and $B = \\\\\\\\{b_0, b_1, ..., b_{m-1}$ lexicographically.\\n\\nConstraints\\n\\n* $1 \\\\leq n, m \\\\leq 1,000$\\n* $0 \\\\leq a_i, b_i \\\\leq 1,000$\\n\\nInput\\n\\nThe input is given in the following format.\\n\\n\\n$n$\\n$a_0 \\\\; a_1, ..., \\\\; a_{n-1}$\\n$m$\\n$b_0 \\\\; b_1, ..., \\\\; b_{m-1}$\\n\\n\\nThe number of elements in $A$ and its elements $a_i$ are given in the first and second lines respectively. The number of elements in $B$ and its elements $b_i$ are given in the third and fourth lines respectively. All input are given in integers.\\n\\nOutput\\n\\nPrint 1 $B$ is greater than $A$, otherwise 0.\\n\\nExamples\\n\\nInput\\n\\n3\\n1 2 3\\n2\\n2 4\\n\\n\\nOutput\\n\\n1\\n\\n\\nInput\\n\\n4\\n5 4 7 0\\n5\\n1 2 3 4 5\\n\\n\\nOutput\\n\\n0\\n\\n\\nInput\\n\\n3\\n1 1 2\\n4\\n1 1 2 2\\n\\n\\nOutput\\n\\n1\\\":\",\"targets\":\"#include <iostream>\\n#include<string>\\nusing namespace std;\\n\\nint main()\\n{\\n    int n,m,i,j,k,x;\\n    cin>>n;\\n    string A(n+1,'\\\\0');\\n    for(i=0;i<n;i++)\\n    {\\n        cin>>x;\\n        A+=x;\\n    }\\n    cin>>m;\\n    string B(n+1,'\\\\0');\\n    for(i=0;i<m;i++)\\n    {\\n        cin>>x;\\n        B+=x;\\n    }\\n    if(B>A)cout<<\\\"1\\\"<<endl;\\n    else cout<<\\\"0\\\"<<endl;\\n    return 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Alice has a string s. She really likes the letter \\\"a\\\". She calls a string good if strictly more than half of the characters in that string are \\\"a\\\"s. For example \\\"aaabb\\\", \\\"axaa\\\" are good strings, and \\\"baca\\\", \\\"awwwa\\\", \\\"\\\" (empty string) are not.\\n\\nAlice can erase some characters from her string s. She would like to know what is the longest string remaining after erasing some characters (possibly zero) to get a good string. It is guaranteed that the string has at least one \\\"a\\\" in it, so the answer always exists.\\n\\nInput\\n\\nThe first line contains a string s (1 \u2264 |s| \u2264 50) consisting of lowercase English letters. It is guaranteed that there is at least one \\\"a\\\" in s.\\n\\nOutput\\n\\nPrint a single integer, the length of the longest good string that Alice can get after erasing some characters from s.\\n\\nExamples\\n\\nInput\\n\\n\\nxaxxxxa\\n\\n\\nOutput\\n\\n\\n3\\n\\n\\nInput\\n\\n\\naaabaa\\n\\n\\nOutput\\n\\n\\n6\\n\\nNote\\n\\nIn the first example, it's enough to erase any four of the \\\"x\\\"s. The answer is 3 since that is the maximum number of characters that can remain.\\n\\nIn the second example, we don't need to erase any characters.\",\"targets\":\"s = input()\\n\\nnba = s.count(\\\"a\\\")\\nnbo = len(s) - nba\\n\\nprint(min(len(s) - (nbo - nba + 1), len(s)))\",\"language\":\"python\",\"split\":\"train\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Vupsen and Pupsen were gifted an integer array. Since Vupsen doesn't like the number 0, he threw away all numbers equal to 0 from the array. As a result, he got an array a of length n.\\n\\nPupsen, on the contrary, likes the number 0 and he got upset when he saw the array without zeroes. To cheer Pupsen up, Vupsen decided to come up with another array b of length n such that \u2211_{i=1}^{n}a_i \u22c5 b_i=0. Since Vupsen doesn't like number 0, the array b must not contain numbers equal to 0. Also, the numbers in that array must not be huge, so the sum of their absolute values cannot exceed 10^9. Please help Vupsen to find any such array b!\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 100) \u2014 the number of test cases. The next 2 \u22c5 t lines contain the description of test cases. The description of each test case consists of two lines.\\n\\nThe first line of each test case contains a single integer n (2 \u2264 n \u2264 10^5) \u2014 the length of the array.\\n\\nThe second line contains n integers a_1, a_2, \u2026, a_n (-10^4 \u2264 a_i \u2264 10^4, a_i \u2260 0) \u2014 the elements of the array a.\\n\\nIt is guaranteed that the sum of n over all test cases does not exceed 2 \u22c5 10^5.\\n\\nOutput\\n\\nFor each test case print n integers b_1, b_2, \u2026, b_n \u2014 elements of the array b (|b_1|+|b_2|+\u2026 +|b_n| \u2264 10^9, b_i \u2260 0, \u2211_{i=1}^{n}a_i \u22c5 b_i=0).\\n\\nIt can be shown that the answer always exists.\\n\\nExample\\n\\nInput\\n\\n\\n3\\n2\\n5 5\\n5\\n5 -2 10 -9 4\\n7\\n1 2 3 4 5 6 7\\n\\n\\nOutput\\n\\n\\n1 -1\\n-1 5 1 -1 -1\\n-10 2 2 -3 5 -1 -1\\n\\nNote\\n\\nIn the first test case, 5 \u22c5 1 + 5 \u22c5 (-1)=5-5=0. You could also print 3 -3, for example, since 5 \u22c5 3 + 5 \u22c5 (-3)=15-15=0\\n\\nIn the second test case, 5 \u22c5 (-1) + (-2) \u22c5 5 + 10 \u22c5 1 + (-9) \u22c5 (-1) + 4 \u22c5 (-1)=-5-10+10+9-4=0.\\nSolve the task in JAVA.\",\"targets\":\"import java.io.BufferedReader;\\nimport java.io.InputStreamReader;\\nimport java.util.StringTokenizer;\\nimport java.util.*;\\nimport java.io.*;\\npublic class Main {\\n    \\/\\/ Graph\\n    \\/\\/ prefix sums\\n    \\/\\/inputs\\n    public static void main(String args[])throws Exception{\\n        Input sc=new Input();\\n        precalculates p=new precalculates();\\n        StringBuilder sb=new StringBuilder();\\n        int t=sc.readInt();\\n        for(int f=0;f<t;f++){\\n            int n=sc.readInt();\\n            long a[]=sc.readArrayLong();\\n            if(n%2==0){\\n                for(int i=0;i<n;i+=2){\\n                    long v1=a[i];\\n                    long v2=a[i+1];\\n                    long mul=v1*v2;\\n                    if(mul>0){\\n                        sb.append((-(v2)+\\\" \\\"+(v1)+\\\" \\\"));\\n                    }else {\\n                        if(v1<0)\\n                            sb.append(v2+\\\" \\\"+-v1 +\\\" \\\");\\n                        else\\n                            sb.append(-v2+\\\" \\\"+v1+\\\" \\\");\\n                    }\\n                }\\n            }else{\\n                for(int i=0;i<n-3;i+=2){\\n                    long v1=a[i];\\n                    long v2=a[i+1];\\n                    long mul=v1*v2;\\n                    if(mul>0){\\n                        sb.append((-(v2)+\\\" \\\"+(v1)+\\\" \\\"));\\n                    }else {\\n                        mul = Math.abs(mul);\\n                        if(v1<0)\\n                        sb.append(v2+\\\" \\\"+-v1 +\\\" \\\");\\n                        else\\n                            sb.append(-v2+\\\" \\\"+v1+\\\" \\\");\\n                    }\\n                }\\n                long v1=a[n-3];\\n                long v2=a[n-2];\\n                long v3=a[n-1];\\n                long mul=v1*v2*v3;\\n                if(mul>0){\\n                    sb.append(v3*(v1\\/Math.abs(v1))+\\\" \\\"+v3*(v2\\/Math.abs(v2))+\\\" \\\"+(-(Math.abs(v1)+Math.abs(v2))));\\n                }else{\\n                    mul=Math.abs(mul);\\n                    sb.append(v3*(v1\\/Math.abs(v1))+\\\" \\\"+v3*(v2\\/Math.abs(v2))+\\\" \\\"+(-(Math.abs(v1)+Math.abs(v2))));\\n\\/\\/                    if(v1<0 && v2+v3>0) {\\n\\/\\/    ...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"During the hypnosis session, Nicholas suddenly remembered a positive integer n, which doesn't contain zeros in decimal notation. \\n\\nSoon, when he returned home, he got curious: what is the maximum number of digits that can be removed from the number so that the number becomes not prime, that is, either composite or equal to one?\\n\\nFor some numbers doing so is impossible: for example, for number 53 it's impossible to delete some of its digits to obtain a not prime integer. However, for all n in the test cases of this problem, it's guaranteed that it's possible to delete some of their digits to obtain a not prime number.\\n\\nNote that you cannot remove all the digits from the number.\\n\\nA prime number is a number that has no divisors except one and itself. A composite is a number that has more than two divisors. 1 is neither a prime nor a composite number.\\n\\nInput\\n\\nEach test contains multiple test cases.\\n\\nThe first line contains one positive integer t (1 \u2264 t \u2264 10^3), denoting the number of test cases. Description of the test cases follows.\\n\\nThe first line of each test case contains one positive integer k (1 \u2264 k \u2264 50) \u2014 the number of digits in the number.\\n\\nThe second line of each test case contains a positive integer n, which doesn't contain zeros in decimal notation (10^{k-1} \u2264 n < 10^{k}). It is guaranteed that it is always possible to remove less than k digits to make the number not prime.\\n\\nIt is guaranteed that the sum of k over all test cases does not exceed 10^4.\\n\\nOutput\\n\\nFor every test case, print two numbers in two lines. In the first line print the number of digits, that you have left in the number. In the second line print the digits left after all delitions. \\n\\nIf there are multiple solutions, print any.\\n\\nExample\\n\\nInput\\n\\n\\n7\\n3\\n237\\n5\\n44444\\n3\\n221\\n2\\n35\\n3\\n773\\n1\\n4\\n30\\n626221626221626221626221626221\\n\\n\\nOutput\\n\\n\\n2\\n27\\n1\\n4\\n1\\n1\\n2\\n35\\n2\\n77\\n1\\n4\\n1\\n6\\n\\nNote\\n\\nIn the first test case, you can't delete 2 digits from the number 237, as all the numbers 2, 3, and 7 are prime. However, you can delete 1 digit, obtaining a number 27 =...\\nThe above is tricky. Write me a correct solution in PYTHON3.\",\"targets\":\"#import collections\\n# import random\\n# import math\\n#import itertools\\n#import math\\n#mport math\\nfrom collections import defaultdict\\n# import itertools\\n# from sys import stdin, stdout\\n#import math\\n#import math\\nimport sys\\n# import bisect\\n# import operator\\n# from decimal import Decimal\\n\\n# sys.setrecursionlimit(10**6)\\n\\np2D = lambda x: print(*x, sep=\\\"\\\\n\\\")\\ndef II(): return int(sys.stdin.buffer.readline())\\ndef MI(): return map(int, sys.stdin.buffer.readline().split())\\ndef LI(): return list(map(int, sys.stdin.buffer.readline().split()))\\ndef LLI(rows_number): return [LI() for _ in range(rows_number)]\\ndef BI(): return sys.stdin.buffer.readline().rstrip()\\ndef SI(): return sys.stdin.buffer.readline().rstrip().decode()\\ndef li(): return [int(i) for i in input().split()]\\ndef lli(rows): return [li() for _ in range(rows)]\\ndef si(): return input()\\ndef ii(): return int(input())\\ndef ins(): return input().split()\\n\\n\\ndef solve():\\n    k = II()\\n    s = SI()\\n    d = defaultdict(int)\\n    app = map(str,[1,4,6,8,9])\\n    for a in app:\\n        if a in s:\\n            return '1'+ '\\\\n'+ str(a)\\n    for i in range(len(s)):\\n        d[s[i]]+=1\\n        if d[s[i]] == 2:\\n            return '2\\\\n'+s[i]*2\\n    if d['2']!=0 and s[0]!='2':\\n        return '2\\\\n'+s[0]+'2'\\n    elif d['5']!=0 and s[0]!='5':\\n        return '2\\\\n'+s[0]+'5'\\n    elif s[0]=='2':\\n        return '2\\\\n'+'27'\\n    elif s[0] == '5':\\n        return '2\\\\n'+ '57'\\n\\ndef main():\\n    for _ in range(II()):\\n        sys.stdout.write(str(solve()) + \\\"\\\\n\\\")\\n\\n    #     z += str(ans) + '\\\\n'\\n    # print(len(ans), ' '.join(map(str, ans)), sep='\\\\n')\\n    # stdout.write(z)\\n\\n\\n# for interactive problems\\n# print(\\\"? {} {}\\\".format(l,m), flush=True)\\n# or print this after each print statement\\n# sys.stdout.flush()\\n\\n\\nif __name__ == \\\"__main__\\\":\\n    main()\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in CPP?\\nPolycarp must pay exactly n burles at the checkout. He has coins of two nominal values: 1 burle and 2 burles. Polycarp likes both kinds of coins equally. So he doesn't want to pay with more coins of one type than with the other.\\n\\nThus, Polycarp wants to minimize the difference between the count of coins of 1 burle and 2 burles being used. Help him by determining two non-negative integer values c_1 and c_2 which are the number of coins of 1 burle and 2 burles, respectively, so that the total value of that number of coins is exactly n (i. e. c_1 + 2 \u22c5 c_2 = n), and the absolute value of the difference between c_1 and c_2 is as little as possible (i. e. you must minimize |c_1-c_2|).\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases. Then t test cases follow.\\n\\nEach test case consists of one line. This line contains one integer n (1 \u2264 n \u2264 10^9) \u2014 the number of burles to be paid by Polycarp.\\n\\nOutput\\n\\nFor each test case, output a separate line containing two integers c_1 and c_2 (c_1, c_2 \u2265 0) separated by a space where c_1 is the number of coins of 1 burle and c_2 is the number of coins of 2 burles. If there are multiple optimal solutions, print any one.\\n\\nExample\\n\\nInput\\n\\n\\n6\\n1000\\n30\\n1\\n32\\n1000000000\\n5\\n\\n\\nOutput\\n\\n\\n334 333\\n10 10\\n1 0\\n10 11\\n333333334 333333333\\n1 2\\n\\nNote\\n\\nThe answer for the first test case is \\\"334 333\\\". The sum of the nominal values of all coins is 334 \u22c5 1 + 333 \u22c5 2 = 1000, whereas |334 - 333| = 1. One can't get the better value because if |c_1 - c_2| = 0, then c_1 = c_2 and c_1 \u22c5 1 + c_1 \u22c5 2 = 1000, but then the value of c_1 isn't an integer.\\n\\nThe answer for the second test case is \\\"10 10\\\". The sum of the nominal values is 10 \u22c5 1 + 10 \u22c5 2 = 30 and |10 - 10| = 0, whereas there's no number having an absolute value less than 0.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nvoid Solve() {\\n  int n;\\n  cin >> n;\\n  int tmp = n \\/ 3;\\n  cout << (tmp + ((n % 3) == 1)) << \\\" \\\" << tmp + ((n % 3) == 2) << endl;\\n}\\nint main() {\\n  int t;\\n  cin >> t;\\n  while (t--) {\\n    Solve();\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"PYTHON3 solution for \\\"Theofanis has a riddle for you and if you manage to solve it, he will give you a Cypriot snack halloumi for free (Cypriot cheese).\\n\\nYou are given an integer n. You need to find two integers l and r such that -10^{18} \u2264 l < r \u2264 10^{18} and l + (l + 1) + \u2026 + (r - 1) + r = n.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases.\\n\\nThe first and only line of each test case contains a single integer n (1 \u2264 n \u2264 10^{18}).\\n\\nOutput\\n\\nFor each test case, print the two integers l and r such that -10^{18} \u2264 l < r \u2264 10^{18} and l + (l + 1) + \u2026 + (r - 1) + r = n. \\n\\nIt can be proven that an answer always exists. If there are multiple answers, print any.\\n\\nExample\\n\\nInput\\n\\n\\n7\\n1\\n2\\n3\\n6\\n100\\n25\\n3000000000000\\n\\n\\nOutput\\n\\n\\n0 1\\n-1 2 \\n1 2 \\n1 3 \\n18 22\\n-2 7\\n999999999999 1000000000001\\n\\nNote\\n\\nIn the first test case, 0 + 1 = 1.\\n\\nIn the second test case, (-1) + 0 + 1 + 2 = 2.\\n\\nIn the fourth test case, 1 + 2 + 3 = 6.\\n\\nIn the fifth test case, 18 + 19 + 20 + 21 + 22 = 100.\\n\\nIn the sixth test case, (-2) + (-1) + 0 + 1 + 2 + 3 + 4 + 5 + 6 + 7 = 25.\\\":\",\"targets\":\"t = int(input())\\nfor i in range(t):\\n    n = int(input())\\n    print(-n + 1, n)\",\"language\":\"python\",\"split\":\"test\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"After many years of research, Ikta has acquired the ability to predict the future! The time and money he spent on this research was enormous, but it's finally time to be rewarded. To get the money back, Ikta decided to start investing in stocks.\\n\\nIkta does not currently own any shares, but owns x yen. He has invested in n stocks, and has succeeded in predicting the stock price for d days from today. As a result, it was surprisingly found that there was no intraday stock price fluctuation for d days from today. In other words, we know the stock price pi, j yen of the stock j (1 \u2264 j \u2264 n) on the i (1 \u2264 i \u2264 d) day when today is the first day. Ikta is free to buy and sell stocks each day. That is, the following operations (purchase \\/ sale) can be performed at any time in any order and any number of times. However, the amount of money held and the number of units held of shares before and after each operation must be non-negative integers.\\n\\n* Purchase: On day i, select one stock type j (1 \u2264 j \u2264 n) and pay pi, j yen in possession to obtain 1 unit of stock j.\\n* Sale: On day i, select one stock type j (1 \u2264 j \u2264 n) and pay 1 unit of stock j to get pi, j yen.\\n\\n\\n\\n(While he was absorbed in his research, the securities trading system made great progress and there were no transaction fees.)\\n\\nIkta had studied information science at university, but had forgotten everything he had learned at university before he could devote himself to future prediction research. Instead of him, write a program that maximizes your money on the final day.\\n\\n\\n\\nInput\\n\\nThe input is given in the following format.\\n\\n\\nn d x\\np1,1 ... p1, n\\n...\\npd, 1 ... pd, n\\n\\n\\n* n: Number of stock types\\n* d: days\\n* x: Money on the first day\\n* pi, j: Stock price of stock j on day i (today is the first day)\\n\\n\\n\\nConstraints\\n\\nEach variable being input is an integer that satisfies the following constraints.\\n\\n* 1 \u2264 n \u2264 10\\n* 1 \u2264 d \u2264 10\\n* 1 \u2264 x, pi, j \u2264 105\\n* It is guaranteed that the amount of money you have on the last day will be 105 or less.\\n\\nOutput\\n\\nOutput the last day's...\",\"targets\":\"#include<bits\\/stdc++.h>\\nusing namespace std;\\ntypedef long long ll;\\n#define i_7 (ll)(1E9+7)\\n#define i_5 (ll)(1E9+5)\\nll mod(ll a){\\n    ll c=a%i_7;\\n    if(c>=0)return c;\\n    else return c+i_7;\\n}\\ntypedef pair<int,int> i_i;\\ntypedef pair<ll,ll> l_l;\\nll inf=(ll)1E12;\\/\\/10^12\\n#define rep(i,l,r) for(ll i=l;i<=r;i++)\\n#define pb push_back\\nll max(ll a,ll b){if(a<b)return b;else return a;}\\nll min(ll a,ll b){if(a>b)return b;else return a;}\\nconst double EPS=1E-8;\\n\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\n\\n\\nint main(){\\n    ios::sync_with_stdio(false);cin.tie(0);\\n    \\n    int n,d,x;cin>>n>>d>>x;\\n    int p[d][n];\\n    rep(i,0,d-1)rep(j,0,n-1)cin>>p[i][j];\\n    int del[d-1][n];\\n    rep(i,0,d-2)rep(j,0,n-1)del[i][j]=p[i+1][j]-p[i][j];\\n    \\n    int dp[d][100005][n];memset(dp,0,sizeof(dp));\\n    rep(k,0,d-2){\\n        rep(i,0,x){\\n            rep(j,0,n-1){\\n                if(j>=1)dp[k][i][j]=dp[k][i][j-1];\\n                if(i-p[k][j]>=0)dp[k][i][j]=max(dp[k][i][j],dp[k][i-p[k][j]][j]+del[k][j]);\\n            }\\n        }\\n        int maxpro=dp[k][0][n-1];\\n        rep(i,1,x)maxpro=max(maxpro,dp[k][i][n-1]);\\n        x+=maxpro;\\n    }\\n    cout<<x<<endl;\\n    \\n    return 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"During the programming classes Vasya was assigned a difficult problem. However, he doesn't know how to code and was unable to find the solution in the Internet, so he asks you to help.\\n\\nYou are given a sequence a, consisting of n distinct integers, that is used to construct the binary search tree. Below is the formal description of the construction process.\\n\\n  1. First element a_1 becomes the root of the tree. \\n  2. Elements a_2, a_3, \u2026, a_n are added one by one. To add element a_i one needs to traverse the tree starting from the root and using the following rules: \\n    1. The pointer to the current node is set to the root. \\n    2. If a_i is greater than the value in the current node, then its right child becomes the current node. Otherwise, the left child of the current node becomes the new current node. \\n    3. If at some point there is no required child, the new node is created, it is assigned value a_i and becomes the corresponding child of the current node. \\n\\nInput\\n\\nThe first line of the input contains a single integer n (2 \u2264 n \u2264 100 000) \u2014 the length of the sequence a.\\n\\nThe second line contains n distinct integers a_i (1 \u2264 a_i \u2264 10^9) \u2014 the sequence a itself.\\n\\nOutput\\n\\nOutput n - 1 integers. For all i > 1 print the value written in the node that is the parent of the node with value a_i in it.\\n\\nExamples\\n\\nInput\\n\\n3\\n1 2 3\\n\\n\\nOutput\\n\\n1 2\\n\\n\\nInput\\n\\n5\\n4 2 3 1 6\\n\\n\\nOutput\\n\\n4 2 2 4\\nimpor\",\"targets\":\"t java.io.*;\\nimport java.util.*;\\n\\npublic final class Main {\\n    static char[] chars = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'};\\n    static char[] chars1 = {'#', '*', '&'};\\n    static char[] chars2 = {'1', '2', '3', '4', '5', '6', '7', '8', '9', '0'};\\n\\n    static boolean oneColor = true;\\n\\n    \\/\\/ x1<0\\n    \\/\\/ x1+k*2>0;\\n    \\/\\/ k*2>-x1;\\n    \\/\\/ k=-x1\\/2\\n    public void solve() {\\n        int n = in.nextInt();\\n        TreeSet<Integer> set = new TreeSet<>();\\n        HashMap<Integer, Integer> rights = new HashMap<>();\\n        HashMap<Integer, Integer> lefts = new HashMap<>();\\n        set.add(in.nextInt());\\n        for (int i = 1; i < n; i++) {\\n            int tmp = in.nextInt();\\n            Integer p = set.higher(tmp);\\n            if (p == null || lefts.containsKey(p)) {\\n                p = set.lower(tmp);\\n                rights.put(p, tmp);\\n            } else {\\n                lefts.put(p, tmp);\\n            }\\n            out.print(p + \\\" \\\");\\n            set.add(tmp);\\n        }\\n    }\\n\\n    static class Library {\\n        static boolean isPrime(int a) {\\n            if (a == 1) {\\n                return false;\\n            }\\n            for (int i = 2; i * i <= a; i++) {\\n                if (a % i == 0)\\n                    return false;\\n            }\\n            return true;\\n        }\\n\\n        static long bpow(long x, long n, long m) {\\n            long count = 1;\\n            if (n == 0) {\\n                return 1;\\n            }\\n            while (n > 0) {\\n                if ((n & 1) == 1) {\\n                    count *= x;\\n                    count %= m;\\n                }\\n                x *= x;\\n                x %= m;\\n                n >>= 1;\\n            }\\n            return count % m;\\n        }\\n\\n        static long GCD(long a, long b) {\\n            if (b == 0) return a;\\n            return GCD(b, a % b);\\n        }\\n\\n        static long lcm(long a, long b) {\\n            return (a * b) \\/ Library.GCD(a, b);\\n        }\\n    }\\n\\n    class Pair<X,...\",\"language\":\"python\",\"split\":\"train\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You are given n dominoes. Each domino has a left and a right cell. Each cell can be colored either black or white. Some cells are already colored, while some aren't yet.\\n\\nThe coloring is said to be valid if and only if it is possible to rearrange the dominoes in some order such that for each 1 \u2264 i \u2264 n the color of the right cell of the i-th domino is different from the color of the left cell of the ((i mod n)+1)-st domino. \\n\\nNote that you can't rotate the dominoes, so the left cell always remains the left cell, and the right cell always remains the right cell.\\n\\nCount the number of valid ways to color the yet uncolored cells of dominoes. Two ways are considered different if there is a cell that is colored white in one way and black in the other. In particular, colorings BW WB and WB BW different (and both invalid).\\n\\nAs this number can be very big, output it modulo 998 244 353.\\n\\nInput\\n\\nThe first line of the input contains a single integer n (1 \u2264 n \u2264 10^5) \u2014 the number of dominoes.\\n\\nThe next n lines describe dominoes. Each line contains two characters which represent the left and the right cell. Character B means that the corresponding cell is black, character W means that the corresponding cell is white, and ? means that the cell is yet to be colored. \\n\\nOutput\\n\\nPrint a single integer \u2014 the answer to the problem.\\n\\nExamples\\n\\nInput\\n\\n\\n1\\n?W\\n\\n\\nOutput\\n\\n\\n1\\n\\n\\nInput\\n\\n\\n2\\n??\\nW?\\n\\n\\nOutput\\n\\n\\n2\\n\\n\\nInput\\n\\n\\n4\\nBB\\n??\\nW?\\n??\\n\\n\\nOutput\\n\\n\\n10\\n\\nNote\\n\\nIn the first test case, there is only one domino, and we need the color of its right cell to be different from the color of its left cell. There is only one way to achieve this.\\n\\nIn the second test case, there are only 2 such colorings:\\n\\nBB WW and WB WB.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst int dx[9] = {0, 0, -1, 1, -1, -1, 1, 1, 0};\\nconst int dy[9] = {-1, 1, 0, 0, -1, 1, -1, 1, 0};\\nconst long long MOD = 998244353;\\nconst int N = 1e5 + 10;\\nint n;\\nstring va[N];\\nlong long fac[N];\\nlong long qsm(long long x, long long y) {\\n  long long res = 1;\\n  while (y) {\\n    if (y & 1) res = (res * x) % MOD;\\n    x = (x * x) % MOD;\\n    y >>= 1;\\n  }\\n  return res;\\n}\\nlong long inv(long long x) { return qsm(x, MOD - 2); }\\nlong long C(long long x, long long y) {\\n  return fac[x] * inv(fac[y]) % MOD * inv(fac[x - y]) % MOD;\\n}\\nvoid init() {\\n  fac[0] = 1;\\n  for (int i = 1; i < N; i++) fac[i] = (fac[i - 1] * i) % MOD;\\n}\\nvoid solve() {\\n  init();\\n  long long b1 = 0, w2 = 0, q1 = 0, q2 = 0, x = 0, y = 0, z = 0;\\n  for (int i = 1; i <= n; i++) {\\n    b1 += va[i][0] == 'B';\\n    w2 += va[i][1] == 'W';\\n    q1 += va[i][0] == '?';\\n    q2 += va[i][1] == '?';\\n    x += va[i] == \\\"WB\\\" || va[i] == \\\"W?\\\" || va[i] == \\\"?B\\\";\\n    y += va[i] == \\\"BW\\\" || va[i] == \\\"B?\\\" || va[i] == \\\"?W\\\";\\n    z += va[i] == \\\"??\\\";\\n  }\\n  long long ans = 0;\\n  for (long long i = 0; i <= q1; i++) {\\n    long long j = b1 + i - w2;\\n    if (j >= 0 && j <= q2) {\\n      ans = (ans + C(q1, i) * C(q2, j) % MOD) % MOD;\\n    }\\n  }\\n  for (long long i = 0; i <= z; i++) {\\n    if (x + y + z == n && x + i >= 1 && y + z - i >= 1) {\\n      ans = (ans - C(z, i) + MOD) % MOD;\\n    }\\n  }\\n  cout << ans << \\\"\\\\n\\\";\\n}\\nint main() {\\n  ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);\\n  cin >> n;\\n  for (int i = 1; i <= n; i++) cin >> va[i];\\n  solve();\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Bear Limak wants to become the largest of bears, or at least to become larger than his brother Bob.\\n\\nRight now, Limak and Bob weigh a and b respectively. It's guaranteed that Limak's weight is smaller than or equal to his brother's weight.\\n\\nLimak eats a lot and his weight is tripled after every year, while Bob's weight is doubled after every year.\\n\\nAfter how many full years will Limak become strictly larger (strictly heavier) than Bob?\\n\\nInput\\n\\nThe only line of the input contains two integers a and b (1 \u2264 a \u2264 b \u2264 10) \u2014 the weight of Limak and the weight of Bob respectively.\\n\\nOutput\\n\\nPrint one integer, denoting the integer number of years after which Limak will become strictly larger than Bob.\\n\\nExamples\\n\\nInput\\n\\n4 7\\n\\n\\nOutput\\n\\n2\\n\\n\\nInput\\n\\n4 9\\n\\n\\nOutput\\n\\n3\\n\\n\\nInput\\n\\n1 1\\n\\n\\nOutput\\n\\n1\\n\\nNote\\n\\nIn the first sample, Limak weighs 4 and Bob weighs 7 initially. After one year their weights are 4\u00b73 = 12 and 7\u00b72 = 14 respectively (one weight is tripled while the other one is doubled). Limak isn't larger than Bob yet. After the second year weights are 36 and 28, so the first weight is greater than the second one. Limak became larger than Bob after two years so you should print 2.\\n\\nIn the second sample, Limak's and Bob's weights in next years are: 12 and 18, then 36 and 36, and finally 108 and 72 (after three years). The answer is 3. Remember that Limak wants to be larger than Bob and he won't be satisfied with equal weights.\\n\\nIn the third sample, Limak becomes larger than Bob after the first year. Their weights will be 3 and 2 then.\",\"targets\":\"a, l = map(int, input().split() )\\n\\ni = 0\\n\\nwhile a <= l:\\n    a*=3\\n    l*=2\\n    i+=1\\nprint(i)\",\"language\":\"python\",\"split\":\"train\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"There are three sticks with integer lengths l_1, l_2 and l_3.\\n\\nYou are asked to break exactly one of them into two pieces in such a way that: \\n\\n  * both pieces have positive (strictly greater than 0) integer length; \\n  * the total length of the pieces is equal to the original length of the stick; \\n  * it's possible to construct a rectangle from the resulting four sticks such that each stick is used as exactly one of its sides. \\n\\n\\n\\nA square is also considered a rectangle.\\n\\nDetermine if it's possible to do that.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 10^4) \u2014 the number of testcases.\\n\\nThe only line of each testcase contains three integers l_1, l_2, l_3 (1 \u2264 l_i \u2264 10^8) \u2014 the lengths of the sticks.\\n\\nOutput\\n\\nFor each testcase, print \\\"YES\\\" if it's possible to break one of the sticks into two pieces with positive integer length in such a way that it's possible to construct a rectangle from the resulting four sticks. Otherwise, print \\\"NO\\\".\\n\\nYou may print every letter in any case you want (so, for example, the strings yEs, yes, Yes and YES are all recognized as a positive answer).\\n\\nExample\\n\\nInput\\n\\n\\n4\\n6 1 5\\n2 5 2\\n2 4 2\\n5 5 4\\n\\n\\nOutput\\n\\n\\nYES\\nNO\\nYES\\nYES\\n\\nNote\\n\\nIn the first testcase, the first stick can be broken into parts of length 1 and 5. We can construct a rectangle with opposite sides of length 1 and 5.\\n\\nIn the second testcase, breaking the stick of length 2 can only result in sticks of lengths 1, 1, 2, 5, which can't be made into a rectangle. Breaking the stick of length 5 can produce results 2, 3 or 1, 4 but neither of them can't be put into a rectangle.\\n\\nIn the third testcase, the second stick can be broken into parts of length 2 and 2. The resulting rectangle has opposite sides 2 and 2 (which is a square).\\n\\nIn the fourth testcase, the third stick can be broken into parts of length 2 and 2. The resulting rectangle has opposite sides 2 and 5.\\nUsing cpp can you solve the prior task?\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint main() {\\n  long long int t;\\n  cin >> t;\\n  while (t--) {\\n    long long int a[3];\\n    for (long long int i = 0; i < 3; i++) {\\n      cin >> a[i];\\n    }\\n    sort(a, a + 3);\\n    if (a[2] == (a[0] + a[1])) {\\n      cout << \\\"YES\\\" << '\\\\n';\\n    } else if (a[0] == a[1] && a[2] % 2 == 0)\\n      cout << \\\"YES\\\" << '\\\\n';\\n    else if (a[1] == a[2] && a[0] % 2 == 0)\\n      cout << \\\"YES\\\" << '\\\\n';\\n    else if (a[0] == a[2] && a[1] % 2 == 0)\\n      cout << \\\"YES\\\" << '\\\\n';\\n    else\\n      cout << \\\"NO\\\" << '\\\\n';\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"You are given n dominoes. Each domino has a left and a right cell. Each cell can be colored either black or white. Some cells are already colored, while some aren't yet.\\n\\nThe coloring is said to be valid if and only if it is possible to rearrange the dominoes in some order such that for each 1 \u2264 i \u2264 n the color of the right cell of the i-th domino is different from the color of the left cell of the ((i mod n)+1)-st domino. \\n\\nNote that you can't rotate the dominoes, so the left cell always remains the left cell, and the right cell always remains the right cell.\\n\\nCount the number of valid ways to color the yet uncolored cells of dominoes. Two ways are considered different if there is a cell that is colored white in one way and black in the other. In particular, colorings BW WB and WB BW different (and both invalid).\\n\\nAs this number can be very big, output it modulo 998 244 353.\\n\\nInput\\n\\nThe first line of the input contains a single integer n (1 \u2264 n \u2264 10^5) \u2014 the number of dominoes.\\n\\nThe next n lines describe dominoes. Each line contains two characters which represent the left and the right cell. Character B means that the corresponding cell is black, character W means that the corresponding cell is white, and ? means that the cell is yet to be colored. \\n\\nOutput\\n\\nPrint a single integer \u2014 the answer to the problem.\\n\\nExamples\\n\\nInput\\n\\n\\n1\\n?W\\n\\n\\nOutput\\n\\n\\n1\\n\\n\\nInput\\n\\n\\n2\\n??\\nW?\\n\\n\\nOutput\\n\\n\\n2\\n\\n\\nInput\\n\\n\\n4\\nBB\\n??\\nW?\\n??\\n\\n\\nOutput\\n\\n\\n10\\n\\nNote\\n\\nIn the first test case, there is only one domino, and we need the color of its right cell to be different from the color of its left cell. There is only one way to achieve this.\\n\\nIn the second test case, there are only 2 such colorings:\\n\\nBB WW and WB WB.\\\":\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nlong long int gcd(long long int a, long long int b) {\\n  return (b == 0LL ? a : gcd(b, a % b));\\n}\\nlong double dist(long double x, long double arayikhalatyan, long double x2,\\n                 long double y2) {\\n  return sqrt((x - x2) * (x - x2) +\\n              (arayikhalatyan - y2) * (arayikhalatyan - y2));\\n}\\nlong long int S(long long int a) { return (a * (a + 1LL)) \\/ 2; }\\nmt19937 rnd(363542);\\nchar vow[] = {'a', 'e', 'i', 'o', 'u'};\\nint dx[] = {0, -1, 0, 1, -1, -1, 1, 1, 0};\\nint dy[] = {-1, 0, 1, 0, -1, 1, -1, 1, 0};\\nconst int N = 1e5 + 20;\\nconst long long int mod = 998244353;\\nconst long double pi = acos(-1);\\nconst int T = 200;\\nlong long int bp(long long int a, long long int b = mod - 2LL) {\\n  long long int ret = 1;\\n  while (b) {\\n    if (b & 1) ret *= a, ret %= mod;\\n    a *= a;\\n    a %= mod;\\n    b >>= 1;\\n  }\\n  return ret;\\n}\\nostream& operator<<(ostream& c, pair<int, int> a) {\\n  c << a.first << \\\" \\\" << a.second;\\n  return c;\\n}\\ntemplate <class T>\\nvoid maxi(T& a, T b) {\\n  a = max(a, b);\\n}\\ntemplate <class T>\\nvoid mini(T& a, T b) {\\n  a = min(a, b);\\n}\\nint n;\\nint r0, r1, l0, l1;\\nstring s[N];\\nlong long int f[N], ans;\\nlong long int c(int n, int k) {\\n  long long int ret = f[n] * bp(f[k]);\\n  ret %= mod;\\n  ret *= bp(f[n - k]);\\n  ret %= mod;\\n  return ret;\\n}\\nlong long int ss() {\\n  int sm = 0, a = 0, b = 0;\\n  for (int i = 0; i < n; i++) {\\n    if (s[i][0] == s[i][1] && s[i][0] == '?')\\n      sm++;\\n    else if (s[i][0] == s[i][1])\\n      return 0;\\n    if (s[i][0] == 'W' || s[i][1] == 'B')\\n      a++;\\n    else if (s[i][0] == 'B' || s[i][1] == 'W')\\n      b++;\\n  }\\n  long long int ret = bp(2, sm);\\n  if (a == 0) ret--;\\n  if (b == 0) ret--;\\n  return ret;\\n}\\nint main() {\\n  ios_base::sync_with_stdio(false);\\n  cin.tie(0);\\n  cout.tie(0);\\n  ;\\n  cin >> n;\\n  f[0] = 1;\\n  for (long long int i = 1; i <= n; i++) {\\n    f[i] = f[i - 1] * 1LL * i;\\n    f[i] %= mod;\\n  }\\n  for (int i = 0; i < n; i++) {\\n    cin >> s[i];\\n    if (s[i][0] == 'W')\\n      l0++;\\n    else if (s[i][0] == 'B')\\n      l1++;\\n    if (s[i][1] ==...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Bearland is a dangerous place. Limak can\u2019t travel on foot. Instead, he has k magic teleportation stones. Each stone can be used at most once. The i-th stone allows to teleport to a point (axi, ayi). Limak can use stones in any order.\\n\\nThere are n monsters in Bearland. The i-th of them stands at (mxi, myi).\\n\\nThe given k + n points are pairwise distinct.\\n\\nAfter each teleportation, Limak can shoot an arrow in some direction. An arrow will hit the first monster in the chosen direction. Then, both an arrow and a monster disappear. It\u2019s dangerous to stay in one place for long, so Limak can shoot only one arrow from one place.\\n\\nA monster should be afraid if it\u2019s possible that Limak will hit it. How many monsters should be afraid of Limak?\\n\\nInput\\n\\nThe first line of the input contains two integers k and n (1 \u2264 k \u2264 7, 1 \u2264 n \u2264 1000) \u2014 the number of stones and the number of monsters.\\n\\nThe i-th of following k lines contains two integers axi and ayi ( - 109 \u2264 axi, ayi \u2264 109) \u2014 coordinates to which Limak can teleport using the i-th stone.\\n\\nThe i-th of last n lines contains two integers mxi and myi ( - 109 \u2264 mxi, myi \u2264 109) \u2014 coordinates of the i-th monster.\\n\\nThe given k + n points are pairwise distinct.\\n\\nOutput\\n\\nPrint the number of monsters which should be afraid of Limak.\\n\\nExamples\\n\\nInput\\n\\n2 4\\n-2 -1\\n4 5\\n4 2\\n2 1\\n4 -1\\n1 -1\\n\\n\\nOutput\\n\\n3\\n\\n\\nInput\\n\\n3 8\\n10 20\\n0 0\\n20 40\\n300 600\\n30 60\\n170 340\\n50 100\\n28 56\\n90 180\\n-4 -8\\n-1 -2\\n\\n\\nOutput\\n\\n5\\n\\nNote\\n\\nIn the first sample, there are two stones and four monsters. Stones allow to teleport to points ( - 2, - 1) and (4, 5), marked blue in the drawing below. Monsters are at (4, 2), (2, 1), (4, - 1) and (1, - 1), marked red. A monster at (4, - 1) shouldn't be afraid because it's impossible that Limak will hit it with an arrow. Other three monsters can be hit and thus the answer is 3.\\n\\n<image>\\n\\nIn the second sample, five monsters should be afraid. Safe monsters are those at (300, 600), (170, 340) and (90, 180).\\nUsing cpp can you solve the prior task?\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\ninline int read() {\\n  int x = 0, f = 1;\\n  char c = getchar();\\n  while (!isdigit(c)) {\\n    if (c == '-') f = -1;\\n    c = getchar();\\n  }\\n  while (isdigit(c)) {\\n    x = x * 10 + c - '0', c = getchar();\\n  }\\n  return x * f;\\n}\\nstruct Point {\\n  int x, y;\\n  Point() {}\\n  Point(int x, int y) : x(x), y(y) {}\\n  inline Point operator+(Point rhs) { return Point(x + rhs.x, y + rhs.y); }\\n  inline Point operator-(Point rhs) { return Point(x - rhs.x, y - rhs.y); }\\n  inline long long operator*(Point rhs) {\\n    return 1ll * x * rhs.x + 1ll * y * rhs.y;\\n  }\\n} a[10], b[1005];\\ninline long long Cross(Point a, Point b) {\\n  return 1ll * a.x * b.y - 1ll * a.y * b.x;\\n}\\nint k, n, p[10];\\nvector<int> block[8][1005];\\ninline bool check(Point a, Point b, Point c) {\\n  return Cross(a - c, c - b) == 0 && (b - a) * (c - a) > 0 &&\\n         (c - a) * (b - c) > 0;\\n}\\nbool cover[1005];\\nvector<int> foo;\\nint now;\\ninline bool dfs(int x) {\\n  if (cover[x]) return 1;\\n  if (now < 1) return 0;\\n  int np = p[now--];\\n  for (int cur : block[np][x])\\n    if (!dfs(cur)) return 0;\\n  cover[x] = 1, foo.push_back(x);\\n  return 1;\\n}\\ninline void clear() {\\n  for (int cur : foo) cover[cur] = 0;\\n  foo.clear();\\n}\\nint main() {\\n  k = read(), n = read();\\n  for (int i = 1; i <= k; i++) a[i].x = read(), a[i].y = read();\\n  for (int i = 1; i <= n; i++) b[i].x = read(), b[i].y = read();\\n  for (int i = 1; i <= k; i++)\\n    for (int a = 1; a <= n; a++)\\n      for (int b = 1; b <= n; b++)\\n        if (a != b && check(::a[i], ::b[a], ::b[b])) block[i][a].push_back(b);\\n  int ans = 0;\\n  for (int i = 1; i <= n; i++) {\\n    for (int j = 1; j <= k; j++) p[j] = j;\\n    bool flag = 0;\\n    do {\\n      clear();\\n      now = k;\\n      if (dfs(i)) {\\n        flag = 1;\\n        break;\\n      }\\n    } while (next_permutation(p + 1, p + 1 + k));\\n    if (flag) ++ans;\\n  }\\n  printf(\\\"%d\\\\n\\\", ans);\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"The only difference between this problem and D2 is that you don't have to provide the way to construct the answer in this problem, but you have to do it in D2.\\n\\nThere's a table of n \u00d7 m cells (n rows and m columns). The value of n \u22c5 m is even.\\n\\nA domino is a figure that consists of two cells having a common side. It may be horizontal (one of the cells is to the right of the other) or vertical (one of the cells is above the other).\\n\\nYou need to find out whether it is possible to place nm\\/2 dominoes on the table so that exactly k of them are horizontal and all the other dominoes are vertical. The dominoes cannot overlap and must fill the whole table.\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 10) \u2014 the number of test cases. Then t test cases follow.\\n\\nEach test case consists of a single line. The line contains three integers n, m, k (1 \u2264 n,m \u2264 100, 0 \u2264 k \u2264 nm\\/2, n \u22c5 m is even) \u2014 the number of rows, columns and horizontal dominoes, respectively.\\n\\nOutput\\n\\nFor each test case output \\\"YES\\\", if it is possible to place dominoes in the desired way, or \\\"NO\\\" otherwise.\\n\\nYou may print each letter in any case (YES, yes, Yes will all be recognized as positive answer, NO, no and nO will all be recognized as negative answer).\\n\\nExample\\n\\nInput\\n\\n\\n8\\n4 4 2\\n2 3 0\\n3 2 3\\n1 2 0\\n2 4 2\\n5 2 2\\n2 17 16\\n2 1 1\\n\\n\\nOutput\\n\\n\\nYES\\nYES\\nYES\\nNO\\nYES\\nNO\\nYES\\nNO\\nUsing java can you solve the prior task?\",\"targets\":\"import java.io.OutputStream;\\nimport java.io.IOException;\\nimport java.io.InputStream;\\nimport java.io.PrintWriter;\\nimport java.io.PrintStream;\\nimport java.util.Random;\\nimport java.util.TreeSet;\\nimport java.io.InputStream;\\n\\n\\/**\\n * Built using CHelper plug-in\\n * Actual solution is at the top\\n *\\n * @author sarthakmanna\\n *\\/\\npublic class Main {\\n    public static void main(String[] args) {\\n        InputStream inputStream = System.in;\\n        OutputStream outputStream = System.out;\\n        FastReader in = new FastReader(inputStream);\\n        PrintWriter out = new PrintWriter(outputStream);\\n        D2DominoHardVersion solver = new D2DominoHardVersion();\\n        int testCount = Integer.parseInt(in.next());\\n        for (int i = 1; i <= testCount; i++)\\n            solver.solve(i, in, out);\\n        out.close();\\n    }\\n\\n    static class D2DominoHardVersion {\\n        final static Helper hp = new Helper();\\n        int N;\\n        int M;\\n        int K;\\n        char[][] G;\\n\\n        public void solve(int testNumber, FastReader in, PrintWriter out) {\\n            int i, j, k;\\n\\n            N = in.nextInt();\\n            M = in.nextInt();\\n            K = in.nextInt();\\n            G = new char[N][M];\\n\\n            \\/\\/Comparator<Pair<Integer, Integer>> com = (a, b) -> Integer.compare(a.getSecond(), b.getSecond());\\n            TreeSet<Pair<Integer, Integer>> oddHeight = new TreeSet<>();\\n            TreeSet<Pair<Integer, Integer>> evenHeight = new TreeSet<>();\\n            for (j = 0; j < M; ++j) {\\n                if (N % 2 == 0) evenHeight.add(new Pair<>(j, 0));\\n                else oddHeight.add(new Pair<>(j, 0));\\n            }\\n\\n            while (K-- > 0) {\\n                if (!oddHeight.isEmpty()) {\\n                    Pair<Integer, Integer> top = oddHeight.pollFirst();\\n                    int td = top.getSecond(), lr = top.getFirst();\\n                    Pair<Integer, Integer> expected = new Pair<>(lr + 1, td);\\n\\n                    if (oddHeight.contains(expected)) {\\n                        oddHeight.remove(expected);\\n\\n                  ...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"It turns out that the meaning of life is a permutation p_1, p_2, \u2026, p_n of the integers 1, 2, \u2026, n (2 \u2264 n \u2264 100). Omkar, having created all life, knows this permutation, and will allow you to figure it out using some queries.\\n\\nA query consists of an array a_1, a_2, \u2026, a_n of integers between 1 and n. a is not required to be a permutation. Omkar will first compute the pairwise sum of a and p, meaning that he will compute an array s where s_j = p_j + a_j for all j = 1, 2, \u2026, n. Then, he will find the smallest index k such that s_k occurs more than once in s, and answer with k. If there is no such index k, then he will answer with 0.\\n\\nYou can perform at most 2n queries. Figure out the meaning of life p.\\n\\nInteraction\\n\\nStart the interaction by reading single integer n (2 \u2264 n \u2264 100) \u2014 the length of the permutation p.\\n\\nYou can then make queries. A query consists of a single line \\\"? \\\\enspace a_1 \\\\enspace a_2 \\\\enspace \u2026 \\\\enspace a_n\\\" (1 \u2264 a_j \u2264 n).\\n\\nThe answer to each query will be a single integer k as described above (0 \u2264 k \u2264 n).\\n\\nAfter making 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:\\n\\n  * fflush(stdout) or cout.flush() in C++;\\n  * System.out.flush() in Java;\\n  * flush(output) in Pascal;\\n  * stdout.flush() in Python;\\n  * see documentation for other languages.\\n\\n\\n\\nTo output your answer, print a single line \\\"! \\\\enspace p_1 \\\\enspace p_2 \\\\enspace \u2026 \\\\enspace p_n\\\" then terminate.\\n\\nYou can make at most 2n queries. Outputting the answer does not count as a query.\\n\\nHack Format\\n\\nTo hack, first output a line containing n (2 \u2264 n \u2264 100), then output another line containing the hidden permutation p_1, p_2, \u2026, p_n of numbers from 1 to n.\\n\\nExample\\n\\nInput\\n\\n\\n5\\n\\n2\\n\\n0\\n\\n1\\n\\n\\nOutput\\n\\n\\n\\n? 4 4 2 3 2\\n\\n? 3 5 1 5 5\\n\\n? 5 2 4 3 1\\n\\n! 3 2 1 5 4\\n\\nNote\\n\\nIn the sample, the hidden permutation p is [3, 2, 1, 5, 4]. Three queries were made.\\n\\nThe first query is a = [4, 4, 2, 3, 2]. This yields s = [3 + 4, 2 + 4, 1 + 2, 5 + 3, 4 + 2] = [7, 6, 3, 8, 6]. 6 is the only...\\nThe above is tricky. Write me a correct solution in JAVA.\",\"targets\":\"import java.util.*;\\n\\npublic class Solution{\\n    static Scanner sc;\\n\\tpublic static void main(String[] args) {\\n\\t\\t sc=new Scanner(System.in);\\n\\t\\tint n=sc.nextInt();\\n\\t\\tint[] ar=new int[n];\\n\\t\\tfor (int i=1; true;i++) {\\n\\t\\t\\tint index=search(i, n);\\n\\t\\t\\tif (index==-1) break;\\n\\t\\t\\tar[index]=i;\\n\\t\\t}\\n\\t\\tfor (int i=-1; true; i--) {\\n\\t\\t\\tint index=search(i, n);\\n\\t\\t\\tif (index==-1) break;\\n\\t\\t\\tar[index]=i;\\n\\t\\t}\\n\\t\\tint min=0;\\n\\t\\tfor (int i:ar) min=Math.min(min, i);\\n\\t\\tSystem.out.print(\\\"! \\\");\\n\\t\\tfor (int i:ar) System.out.print(i-min+1+\\\" \\\");\\n\\t\\tSystem.out.println();\\n\\t}\\n\\tstatic int search(int x, int n) {\\n\\t\\tif (x==n) return -1;\\n\\t\\tif (x==-n) return -1;\\n\\t\\tif (x==0) throw null;\\n\\t\\tif (x>0) {\\n\\t\\t\\tStringBuilder sb=new StringBuilder();\\n\\t\\t\\tsb.append(\\\"? \\\");\\n\\t\\t\\tfor (int i=1; i<n; i++) sb.append(\\\"1 \\\");\\n\\t\\t\\tsb.append(x+1);\\n\\t\\t\\tSystem.out.println(sb.toString());\\n\\t\\t}\\n\\t\\telse {\\n\\t\\t\\tStringBuilder sb=new StringBuilder();\\n\\t\\t\\tsb.append(\\\"? \\\");\\n\\t\\t\\tfor (int i=1; i<n; i++) sb.append((-x+1)+\\\" \\\");\\n\\t\\t\\tsb.append(1);\\n\\t\\t\\tSystem.out.println(sb.toString());\\n\\t\\t}\\n\\t\\tint ans=sc.nextInt()-1;\\n\\t\\treturn ans;\\n\\t}\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"<image>\\n\\nWalking through the streets of Marshmallow City, Slastyona have spotted some merchants selling a kind of useless toy which is very popular nowadays \u2013 caramel spinner! Wanting to join the craze, she has immediately bought the strange contraption.\\n\\nSpinners in Sweetland have the form of V-shaped pieces of caramel. Each spinner can, well, spin around an invisible magic axis. At a specific point in time, a spinner can take 4 positions shown below (each one rotated 90 degrees relative to the previous, with the fourth one followed by the first one):\\n\\n<image>\\n\\nAfter the spinner was spun, it starts its rotation, which is described by a following algorithm: the spinner maintains its position for a second then majestically switches to the next position in clockwise or counter-clockwise order, depending on the direction the spinner was spun in.\\n\\nSlastyona managed to have spinner rotating for exactly n seconds. Being fascinated by elegance of the process, she completely forgot the direction the spinner was spun in! Lucky for her, she managed to recall the starting position, and wants to deduct the direction given the information she knows. Help her do this.\\n\\nInput\\n\\nThere are two characters in the first string \u2013 the starting and the ending position of a spinner. The position is encoded with one of the following characters: v (ASCII code 118, lowercase v), < (ASCII code 60), ^ (ASCII code 94) or > (ASCII code 62) (see the picture above for reference). Characters are separated by a single space.\\n\\nIn the second strings, a single number n is given (0 \u2264 n \u2264 109) \u2013 the duration of the rotation.\\n\\nIt is guaranteed that the ending position of a spinner is a result of a n second spin in any of the directions, assuming the given starting position.\\n\\nOutput\\n\\nOutput cw, if the direction is clockwise, ccw \u2013 if counter-clockwise, and undefined otherwise.\\n\\nExamples\\n\\nInput\\n\\n^ &gt;\\n1\\n\\n\\nOutput\\n\\ncw\\n\\n\\nInput\\n\\n&lt; ^\\n3\\n\\n\\nOutput\\n\\nccw\\n\\n\\nInput\\n\\n^ v\\n6\\n\\n\\nOutput\\n\\nundefined\\n#incl\",\"targets\":\"ude <bits\\/stdc++.h>\\nusing namespace std;\\nint main() {\\n  string A, B;\\n  int n, f1, f2, f3, f4;\\n  cin >> A >> B;\\n  cin >> n;\\n  n = n % 4;\\n  if (A == \\\"v\\\") f1 = 1;\\n  if (A == \\\"<\\\") f1 = 2;\\n  if (A == \\\"^\\\") f1 = 3;\\n  if (A == \\\">\\\") f1 = 4;\\n  if (B == \\\"v\\\") f2 = 1;\\n  if (B == \\\"<\\\") f2 = 2;\\n  if (B == \\\"^\\\") f2 = 3;\\n  if (B == \\\">\\\") f2 = 4;\\n  int cnt = f1;\\n  for (int i = 1; i <= n; i++) {\\n    if (cnt + 1 > 4)\\n      cnt = 1;\\n    else\\n      cnt++;\\n  }\\n  int fl = 0, fl1 = 0;\\n  if (cnt == f2) fl = 1;\\n  cnt = f1;\\n  for (int i = 1; i <= n; i++) {\\n    if (cnt - 1 < 1)\\n      cnt = 4;\\n    else\\n      cnt--;\\n  }\\n  if (cnt == f2) fl1 = 1;\\n  if (fl1 == 1 && fl == 1) cout << \\\"undefined\\\" << endl;\\n  if (fl == 1 && fl1 == 0) cout << \\\"cw\\\" << endl;\\n  if (fl == 0 && fl1 == 1) cout << \\\"ccw\\\" << endl;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"<image>\\n\\nWilliam really wants to get a pet. Since his childhood he dreamt about getting a pet grasshopper. William is being very responsible about choosing his pet, so he wants to set up a trial for the grasshopper!\\n\\nThe trial takes place on an array a of length n, which defines lengths of hops for each of n cells. A grasshopper can hop around the sells according to the following rule: from a cell with index i it can jump to any cell with indices from i to i+a_i inclusive.\\n\\nLet's call the k-grasshopper value of some array the smallest number of hops it would take a grasshopper to hop from the first cell to the last, but before starting you can select no more than k cells and remove them from the array. When a cell is removed all other cells are renumbered but the values of a_i for each cell remains the same. During this the first and the last cells may not be removed.\\n\\nIt is required to process q queries of the following format: you are given three numbers l, r, k. You are required to find the k-grasshopper value for an array, which is a subarray of the array a with elements from l to r inclusive.\\n\\nInput\\n\\nThe first line contains two integers n and q (1 \u2264 n, q \u2264 20000), the length of the array and the number of queries respectively.\\n\\nThe second line contains n integers a_1, a_2, \u2026, a_n (1 \u2264 a_i \u2264 n) \u2013 the elements of the array.\\n\\nThe following q lines contain queries: each line contains three integers l, r and k (1 \u2264 l \u2264 r \u2264 n, 0 \u2264 k \u2264 min(30, r-l)), which are the edges of the subarray and the number of the grasshopper value respectively.\\n\\nOutput\\n\\nFor each query print a single number in a new line \u2014 the response to a query.\\n\\nExample\\n\\nInput\\n\\n\\n9 5\\n1 1 2 1 3 1 2 1 1\\n1 1 0\\n2 5 1\\n5 9 1\\n2 8 2\\n1 9 4\\n\\n\\nOutput\\n\\n\\n0\\n2\\n1\\n2\\n2\\n\\nNote\\n\\nFor the second query the process occurs like this: <image>\\n\\nFor the third query the process occurs like this: <image>\\nThe above is tricky. Write me a correct solution in CPP.\",\"targets\":\"#ifdef DEBUG\\n#define _GLIBCXX_DEBUG\\n#endif\\n#include <bits\\/stdc++.h>\\nusing namespace std;typedef long double ld;typedef long long ll;int n, q;const int LOG = 17;const int maxK = 31;const int maxN = 20 * 1000 + 10;\\nint dp[LOG][maxK][maxN];int lg[maxN];int a[maxN];int sparse[maxK][LOG][maxN];\\nint getMax(int l, int r, int id_k) {  int k = lg[r - l + 1]; return max(sparse[id_k][k][l], sparse[id_k][k][r - (1 << k) + 1]);}\\nint cur_dp[maxN][maxK];int ans[maxN];int l[maxN], r[maxN], k[maxN];int new_dp[maxK];\\nint main() {\\n    ios_base::sync_with_stdio(false);\\n    cin.tie(nullptr);\\n\\/\\/    freopen(\\\"input.txt\\\", \\\"r\\\", stdin);\\n    lg[1] = 0;\\n    cin >> n >> q;\\n    for (int i = 2; i < maxN; i++) {\\n        lg[i] = lg[i - 1];\\n        if (!(i & (i - 1))) lg[i]++;\\n    }\\n    for (int i = 0; i < n; i++) {\\n        cin >> a[i];\\n    }\\n    \\/\\/build\\n    for (int i = 0; i < n; i++) {\\n        for (int j = 0; j < maxK; j++) {\\n            dp[0][j][i] = min(i + a[i] + j, n - 1);\\n        }\\n    }\\n    for (int i = 0; i + 1 < LOG; i++) {\\n        \\/\\/build sparse\\n        for (int x = 0; x < maxK; x++) {\\n            for (int y = 0; y < n; y++) {\\n                sparse[x][0][y] = dp[i][x][y];\\n            }\\n            for (int z = 0; z + 1 < LOG; z++) {\\n                for (int y = 0; y + (1 << (z + 1)) <= n; y++) {\\n                    sparse[x][z + 1][y] = max(sparse[x][z][y], sparse[x][z][y + (1 << z)]);\\n                }\\n            }\\n        }\\n        \\/\\/calc\\n        for (int k1 = 0; k1 < maxK; k1++) {\\n            for (int k2 = 0; k2 + k1 < maxK; k2++) {\\n                for (int x = 0; x < n; x++) {\\n                    dp[i + 1][k1 + k2][x] = max(dp[i + 1][k1 + k2][x], getMax(x, dp[i][k1][x], k2));\\n                }\\n            }\\n        }\\n    }\\n    for (int i = 0; i < q; i++) {    cin >> l[i] >> r[i] >> k[i];   l[i]--;r[i]--;\\n        if (l[i] == r[i]) {  ans[i] = -1;  continue;  }   for (int z = 0; z <= k[i]; z++)  cur_dp[i][z] = l[i]; }\\n    for (int i = LOG - 1; i >= 0; i--) { for (int x = 0; x < maxK; x++) {   for (int y = 0; y < n; y++)  ...\",\"language\":\"python\",\"split\":\"train\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"There are n block towers in a row, where tower i has a height of a_i. You're part of a building crew, and you want to make the buildings look as nice as possible. In a single day, you can perform the following operation:\\n\\n  * Choose two indices i and j (1 \u2264 i, j \u2264 n; i \u2260 j), and move a block from tower i to tower j. This essentially decreases a_i by 1 and increases a_j by 1. \\n\\n\\n\\nYou think the ugliness of the buildings is the height difference between the tallest and shortest buildings. Formally, the ugliness is defined as max(a)-min(a). \\n\\nWhat's the minimum possible ugliness you can achieve, after any number of days?\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 1000) \u2014 the number of test cases. Then t cases follow.\\n\\nThe first line of each test case contains one integer n (2 \u2264 n \u2264 100) \u2014 the number of buildings.\\n\\nThe second line of each test case contains n space separated integers a_1, a_2, \u2026, a_n (1 \u2264 a_i \u2264 10^7) \u2014 the heights of the buildings.\\n\\nOutput\\n\\nFor each test case, output a single integer \u2014 the minimum possible ugliness of the buildings.\\n\\nExample\\n\\nInput\\n\\n\\n3\\n3\\n10 10 10\\n4\\n3 2 1 2\\n5\\n1 2 3 1 5\\n\\n\\nOutput\\n\\n\\n0\\n0\\n1\\n\\nNote\\n\\nIn the first test case, the ugliness is already 0.\\n\\nIn the second test case, you should do one operation, with i = 1 and j = 3. The new heights will now be [2, 2, 2, 2], with an ugliness of 0.\\n\\nIn the third test case, you may do three operations: \\n\\n  1. with i = 3 and j = 1. The new array will now be [2, 2, 2, 1, 5], \\n  2. with i = 5 and j = 4. The new array will now be [2, 2, 2, 2, 4], \\n  3. with i = 5 and j = 3. The new array will now be [2, 2, 3, 2, 3]. \\n\\nThe resulting ugliness is 1. It can be proven that this is the minimum possible ugliness for this test.\\nSolve the task in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint solve(int n) {\\n  int sum = 0;\\n  int ax;\\n  for (int i = 0; i < n; i++) {\\n    cin >> ax;\\n    sum += ax;\\n  }\\n  if (sum % n == 0)\\n    return 0;\\n  else\\n    return 1;\\n}\\nint main() {\\n  int t;\\n  cin >> t;\\n  while (t--) {\\n    int n;\\n    cin >> n;\\n    cout << solve(n) << endl;\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You are given an array a consisting of n positive integers. You have to choose a positive integer d and paint all elements into two colors. All elements which are divisible by d will be painted red, and all other elements will be painted blue.\\n\\nThe coloring is called beautiful if there are no pairs of adjacent elements with the same color in the array. Your task is to find any value of d which yields a beautiful coloring, or report that it is impossible.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 1000) \u2014 the number of testcases.\\n\\nThe first line of each testcase contains one integer n (2 \u2264 n \u2264 100) \u2014 the number of elements of the array.\\n\\nThe second line of each testcase contains n integers a_1, a_2, ..., a_n (1 \u2264 a_i \u2264 10^{18}).\\n\\nOutput\\n\\nFor each testcase print a single integer. If there is no such value of d that yields a beautiful coloring, print 0. Otherwise, print any suitable value of d (1 \u2264 d \u2264 10^{18}).\\n\\nExample\\n\\nInput\\n\\n\\n5\\n5\\n1 2 3 4 5\\n3\\n10 5 15\\n3\\n100 10 200\\n10\\n9 8 2 6 6 2 8 6 5 4\\n2\\n1 3\\n\\n\\nOutput\\n\\n\\n2\\n0\\n100\\n0\\n3\\n\\n\\nimp\",\"targets\":\"ort java.util.*;\\nimport java.lang.*;\\nimport java.io.*;\\n\\n\\/* Name of the class has to be \\\"Main\\\" only if the class is public. *\\/\\npublic class paintarray {\\n    public static void main(String[] args) throws java.lang.Exception {\\n\\n        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));\\n        PrintWriter ino = new PrintWriter(System.out, true);\\n        int t = Integer.parseInt(in.readLine().trim());\\n\\n        for (int i = 1; i <= t; i++) {\\n            int n = Integer.parseInt(in.readLine().trim());\\n            long a[] = new long[n];\\n            String k[] = in.readLine().trim().split(\\\" \\\");\\n            for (int j = 0; j < n; j++)\\n                a[j] = Long.parseLong(k[j]);\\n            ino.print(op(a, n)+\\\"\\\\n\\\");\\n        }\\n        ino.close();\\n    }\\n\\n    static long op(long a[], int n) {\\n       boolean f1=true;boolean f2=true;\\n       long a1=a[0];\\n       long a2=a[1];\\n       for(int i=2;i<n;i+=2)\\n           a1=gcd(a1,a[i]);\\n        for(int i=3;i<n;i+=2)\\n            a2=gcd(a2,a[i]);\\n\\n        for(int i=1;i<n;i+=2)\\n        {\\n            if(a[i]%a1==0) {\\n                f1 = false;\\n                break;\\n            }\\n        }\\n        for(int i=0;i<n;i+=2)\\n        {\\n            if(a[i]%a2==0)\\n            {\\n                f2 = false;\\n                break;\\n            }\\n        }\\n        if((f1==false)&&(f2==false))\\n            return 0;\\n        else if(f1==false)\\n            return a2;\\n        else return a1;\\n    }\\n    static long gcd(long a, long b)\\n    {\\n        if (b == 0)\\n            return a;\\n        return gcd(b, a % b);\\n    }\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Theofanis has a riddle for you and if you manage to solve it, he will give you a Cypriot snack halloumi for free (Cypriot cheese).\\n\\nYou are given an integer n. You need to find two integers l and r such that -10^{18} \u2264 l < r \u2264 10^{18} and l + (l + 1) + \u2026 + (r - 1) + r = n.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases.\\n\\nThe first and only line of each test case contains a single integer n (1 \u2264 n \u2264 10^{18}).\\n\\nOutput\\n\\nFor each test case, print the two integers l and r such that -10^{18} \u2264 l < r \u2264 10^{18} and l + (l + 1) + \u2026 + (r - 1) + r = n. \\n\\nIt can be proven that an answer always exists. If there are multiple answers, print any.\\n\\nExample\\n\\nInput\\n\\n\\n7\\n1\\n2\\n3\\n6\\n100\\n25\\n3000000000000\\n\\n\\nOutput\\n\\n\\n0 1\\n-1 2 \\n1 2 \\n1 3 \\n18 22\\n-2 7\\n999999999999 1000000000001\\n\\nNote\\n\\nIn the first test case, 0 + 1 = 1.\\n\\nIn the second test case, (-1) + 0 + 1 + 2 = 2.\\n\\nIn the fourth test case, 1 + 2 + 3 = 6.\\n\\nIn the fifth test case, 18 + 19 + 20 + 21 + 22 = 100.\\n\\nIn the sixth test case, (-2) + (-1) + 0 + 1 + 2 + 3 + 4 + 5 + 6 + 7 = 25.\\nUsing python3 can you solve the prior task?\",\"targets\":\"t0 = int(input())\\nfor t in range(t0):\\n    n = int(input())\\n    print(\\\"{} {}\\\".format(-n+1, n))\",\"language\":\"python\",\"split\":\"test\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You are given two strings s and t, both consisting of lowercase English letters. You are going to type the string s character by character, from the first character to the last one.\\n\\nWhen typing a character, instead of pressing the button corresponding to it, you can press the \\\"Backspace\\\" button. It deletes the last character you have typed among those that aren't deleted yet (or does nothing if there are no characters in the current string). For example, if s is \\\"abcbd\\\" and you press Backspace instead of typing the first and the fourth characters, you will get the string \\\"bd\\\" (the first press of Backspace deletes no character, and the second press deletes the character 'c'). Another example, if s is \\\"abcaa\\\" and you press Backspace instead of the last two letters, then the resulting text is \\\"a\\\".\\n\\nYour task is to determine whether you can obtain the string t, if you type the string s and press \\\"Backspace\\\" instead of typing several (maybe zero) characters of s.\\n\\nInput\\n\\nThe first line contains a single integer q (1 \u2264 q \u2264 10^5) \u2014 the number of test cases.\\n\\nThe first line of each test case contains the string s (1 \u2264 |s| \u2264 10^5). Each character of s is a lowercase English letter.\\n\\nThe second line of each test case contains the string t (1 \u2264 |t| \u2264 10^5). Each character of t is a lowercase English letter.\\n\\nIt is guaranteed that the total number of characters in the strings over all test cases does not exceed 2 \u22c5 10^5.\\n\\nOutput\\n\\nFor each test case, print \\\"YES\\\" if you can obtain the string t by typing the string s and replacing some characters with presses of \\\"Backspace\\\" button, or \\\"NO\\\" if you cannot.\\n\\nYou may print each letter in any case (YES, yes, Yes will all be recognized as positive answer, NO, no and nO will all be recognized as negative answer).\\n\\nExample\\n\\nInput\\n\\n\\n4\\nababa\\nba\\nababa\\nbb\\naaa\\naaaa\\naababa\\nababa\\n\\n\\nOutput\\n\\n\\nYES\\nNO\\nNO\\nYES\\n\\nNote\\n\\nConsider the example test from the statement.\\n\\nIn order to obtain \\\"ba\\\" from \\\"ababa\\\", you may press Backspace instead of typing the first and the fourth characters.\\n\\nThere's no way...\\nThe above is tricky. Write me a correct solution in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\ntemplate <typename A, typename B>\\nostream &operator<<(ostream &os, const pair<A, B> &p) {\\n  return os << '(' << p.first << \\\", \\\" << p.second << ')';\\n}\\ntemplate <typename T_container, typename T = typename enable_if<\\n                                    !is_same<T_container, string>::value,\\n                                    typename T_container::value_type>::type>\\nostream &operator<<(ostream &os, const T_container &v) {\\n  os << '{';\\n  string sep;\\n  for (const T &x : v) os << sep << x, sep = \\\", \\\";\\n  return os << '}';\\n}\\nvoid dbg_out() { cerr << \\\"\\\\b\\\\b]\\\\n\\\"; }\\ntemplate <typename Head, typename... Tail>\\nvoid dbg_out(Head H, Tail... T) {\\n  cerr << H << \\\", \\\";\\n  dbg_out(T...);\\n}\\nvoid solve() {\\n  string a, b;\\n  cin >> a >> b;\\n  int n = (int)a.size(), m = (int)b.size();\\n  for (int i = n - 1, j = m - 1; i >= 0; i--) {\\n    if (a[i] == b[j]) {\\n      j--;\\n    } else {\\n      i--;\\n    }\\n    if (j < 0) {\\n      cout << \\\"YES\\\\n\\\";\\n      return;\\n    }\\n  }\\n  cout << \\\"NO\\\\n\\\";\\n}\\nint main() {\\n  ios_base::sync_with_stdio(false);\\n  cin.tie(nullptr);\\n  int t;\\n  cin >> t;\\n  while (t--) {\\n    solve();\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Find an n \u00d7 n matrix with different numbers from 1 to n2, so the sum in each row, column and both main diagonals are odd.\\n\\nInput\\n\\nThe only line contains odd integer n (1 \u2264 n \u2264 49).\\n\\nOutput\\n\\nPrint n lines with n integers. All the integers should be different and from 1 to n2. The sum in each row, column and both main diagonals should be odd.\\n\\nExamples\\n\\nInput\\n\\n1\\n\\n\\nOutput\\n\\n1\\n\\n\\nInput\\n\\n3\\n\\n\\nOutput\\n\\n2 1 4\\n3 5 7\\n6 9 8\\nThe above is tricky. Write me a correct solution in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint main() {\\n  int n, l, r, odd, row = 0, even = 0, f[50][50];\\n  cin >> n;\\n  l = n \\/ 2 + 1;\\n  r = n \\/ 2 + 1;\\n  odd = -1;\\n  memset(f, 0, sizeof(f));\\n  while (r <= n) {\\n    ++row;\\n    for (int i = l; i <= r; i++) {\\n      odd += 2;\\n      f[row][i] = odd;\\n    }\\n    --l;\\n    ++r;\\n  }\\n  ++l;\\n  --r;\\n  while (l <= r) {\\n    ++l;\\n    --r;\\n    if (l > r) break;\\n    ++row;\\n    for (int i = l; i <= r; i++) {\\n      odd += 2;\\n      f[row][i] = odd;\\n    }\\n  }\\n  even = 0;\\n  for (int i = 1; i <= n; i++) {\\n    for (int j = 1; j <= n; j++)\\n      if (f[i][j] == 0) {\\n        even += 2;\\n        f[i][j] = even;\\n      }\\n  }\\n  for (int i = 1; i <= n; i++) {\\n    for (int j = 1; j <= n; j++)\\n      if (j < n)\\n        cout << f[i][j] << ' ';\\n      else\\n        cout << f[i][j] << endl;\\n  }\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Ivan is playing yet another roguelike computer game. He controls a single hero in the game. The hero has n equipment slots. There is a list of c_i items for the i-th slot, the j-th of them increases the hero strength by a_{i,j}. The items for each slot are pairwise distinct and are listed in the increasing order of their strength increase. So, a_{i,1} < a_{i,2} < ... < a_{i,c_i}.\\n\\nFor each slot Ivan chooses exactly one item. Let the chosen item for the i-th slot be the b_i-th item in the corresponding list. The sequence of choices [b_1, b_2, ..., b_n] is called a build.\\n\\nThe strength of a build is the sum of the strength increases of the items in it. Some builds are banned from the game. There is a list of m pairwise distinct banned builds. It's guaranteed that there's at least one build that's not banned.\\n\\nWhat is the build with the maximum strength that is not banned from the game? If there are multiple builds with maximum strength, print any of them.\\n\\nInput\\n\\nThe first line contains a single integer n (1 \u2264 n \u2264 10) \u2014 the number of equipment slots.\\n\\nThe i-th of the next n lines contains the description of the items for the i-th slot. First, one integer c_i (1 \u2264 c_i \u2264 2 \u22c5 10^5) \u2014 the number of items for the i-th slot. Then c_i integers a_{i,1}, a_{i,2}, ..., a_{i,c_i} (1 \u2264 a_{i,1} < a_{i,2} < ... < a_{i,c_i} \u2264 10^8).\\n\\nThe sum of c_i doesn't exceed 2 \u22c5 10^5.\\n\\nThe next line contains a single integer m (0 \u2264 m \u2264 10^5) \u2014 the number of banned builds.\\n\\nEach of the next m lines contains a description of a banned build \u2014 a sequence of n integers b_1, b_2, ..., b_n (1 \u2264 b_i \u2264 c_i).\\n\\nThe builds are pairwise distinct, and there's at least one build that's not banned.\\n\\nOutput\\n\\nPrint the build with the maximum strength that is not banned from the game. If there are multiple builds with maximum strength, print any of them.\\n\\nExamples\\n\\nInput\\n\\n\\n3\\n3 1 2 3\\n2 1 5\\n3 2 4 6\\n2\\n3 2 3\\n3 2 2\\n\\n\\nOutput\\n\\n\\n2 2 3 \\n\\n\\nInput\\n\\n\\n3\\n3 1 2 3\\n2 1 5\\n3 2 4 6\\n2\\n3 2 3\\n2 2 3\\n\\n\\nOutput\\n\\n\\n1 2 3\\n\\n\\nInput\\n\\n\\n3\\n3 1 2 3\\n2 1 5\\n3 2 4 6\\n2\\n3 2 3\\n2 2 3\\n\\n\\nOutput\\n\\n\\n3 2...\\nSolve the task in PYTHON3.\",\"targets\":\"'''Author- Akshit Monga'''\\nimport os,sys\\nfrom io import BytesIO,IOBase\\nimport heapq\\n\\ndef solve():\\n    n=int(input())\\n    vals=[[] for i in range(n)]\\n    for i in range(n):\\n        vals[i]=[int(x) for x in input().split()]\\n    m=int(input())\\n    banned=set()\\n    vis=set()\\n    for i in range(m):\\n        banned.add(tuple([int(x) for x in input().split()]))\\n    val=0\\n    ideal=[]\\n    for i in range(n):\\n        val+=vals[i][-1]\\n        ideal.append(vals[i][0])\\n    all=[(-val,ideal)]\\n    heapq.heapify(all)\\n    while len(all):\\n        top=heapq.heappop(all)\\n        ss=-top[0]\\n        lis=top[1]\\n        # print(top)\\n        vis.add(tuple(lis))\\n        if tuple(lis) not in banned:\\n            print(*lis)\\n            break\\n        for i in range(n):\\n            if lis[i]-1>=1:\\n                lis[i]-=1\\n                if tuple(lis) in vis:\\n                    #arrrghh\\n                    lis[i]+=1 \\n                    continue\\n                heapq.heappush(all,(-(ss-vals[i][lis[i]+1]+vals[i][lis[i]]),lis.copy()))\\n                vis.add(tuple(lis))\\n                lis[i]+=1\\n\\n\\ndef main():\\n    t=1\\n    # t=int(input())\\n    for _ in range(t):\\n        solve()\\n\\n# Fast IO Region\\nBUFSIZE = 8192\\nclass FastIO(IOBase):\\n    newlines = 0\\n    def __init__(self,file):\\n        self._fd = file.fileno()\\n        self.buffer = BytesIO()\\n        self.writable = \\\"x\\\" in file.mode or \\\"r\\\" not in file.mode\\n        self.write = self.buffer.write if self.writable else None\\n    def read(self):\\n        while True:\\n            b = os.read(self._fd,max(os.fstat(self._fd).st_size,BUFSIZE))\\n            if not b:\\n                break\\n            ptr = self.buffer.tell()\\n            self.buffer.seek(0,2),self.buffer.write(b),self.buffer.seek(ptr)\\n        self.newlines = 0\\n        return self.buffer.read()\\n    def readline(self):\\n        while self.newlines == 0:\\n            b = os.read(self._fd,max(os.fstat(self._fd).st_size,BUFSIZE))\\n            self.newlines = b.count(b\\\"\\\\n\\\")+(not b)\\n            ptr = self.buffer.tell()\\n           ...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Polycarp likes squares and cubes of positive integers. Here is the beginning of the sequence of numbers he likes: 1, 4, 8, 9, ....\\n\\nFor a given number n, count the number of integers from 1 to n that Polycarp likes. In other words, find the number of such x that x is a square of a positive integer number or a cube of a positive integer number (or both a square and a cube simultaneously).\\n\\nInput\\n\\nThe first line contains an integer t (1 \u2264 t \u2264 20) \u2014 the number of test cases.\\n\\nThen t lines contain the test cases, one per line. Each of the lines contains one integer n (1 \u2264 n \u2264 10^9).\\n\\nOutput\\n\\nFor each test case, print the answer you are looking for \u2014 the number of integers from 1 to n that Polycarp likes.\\n\\nExample\\n\\nInput\\n\\n\\n6\\n10\\n1\\n25\\n1000000000\\n999999999\\n500000000\\n\\n\\nOutput\\n\\n\\n4\\n1\\n6\\n32591\\n32590\\n23125\\nUsing cpp can you solve the prior task?\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst int dx[9] = {-1, 0, 1, 0, -1, -1, 1, 1, 0};\\nconst int dy[9] = {0, 1, 0, -1, -1, 1, -1, 1, 0};\\nlong long n;\\nvoid solve() {\\n  n += 0.5;\\n  int a = sqrt(n);\\n  int b = cbrt(n);\\n  int c = sqrt(cbrt(n));\\n  cout << a + b - c << \\\"\\\\n\\\";\\n}\\nint main() {\\n  ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);\\n  int T;\\n  cin >> T;\\n  while (T--) {\\n    cin >> n;\\n    solve();\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Alice's hair is growing by leaps and bounds. Maybe the cause of it is the excess of vitamins, or maybe it is some black magic...\\n\\nTo prevent this, Alice decided to go to the hairdresser. She wants for her hair length to be at most l centimeters after haircut, where l is her favorite number. Suppose, that the Alice's head is a straight line on which n hairlines grow. Let's number them from 1 to n. With one swing of the scissors the hairdresser can shorten all hairlines on any segment to the length l, given that all hairlines on that segment had length strictly greater than l. The hairdresser wants to complete his job as fast as possible, so he will make the least possible number of swings of scissors, since each swing of scissors takes one second.\\n\\nAlice hasn't decided yet when she would go to the hairdresser, so she asked you to calculate how much time the haircut would take depending on the time she would go to the hairdresser. In particular, you need to process queries of two types:\\n\\n  * 0 \u2014 Alice asks how much time the haircut would take if she would go to the hairdresser now. \\n  * 1 p d \u2014 p-th hairline grows by d centimeters. \\n\\n\\n\\nNote, that in the request 0 Alice is interested in hypothetical scenario of taking a haircut now, so no hairlines change their length.\\n\\nInput\\n\\nThe first line contains three integers n, m and l (1 \u2264 n, m \u2264 100 000, 1 \u2264 l \u2264 10^9) \u2014 the number of hairlines, the number of requests and the favorite number of Alice.\\n\\nThe second line contains n integers a_i (1 \u2264 a_i \u2264 10^9) \u2014 the initial lengths of all hairlines of Alice.\\n\\nEach of the following m lines contains a request in the format described in the statement.\\n\\nThe request description starts with an integer t_i. If t_i = 0, then you need to find the time the haircut would take. Otherwise, t_i = 1 and in this moment one hairline grows. The rest of the line than contains two more integers: p_i and d_i (1 \u2264 p_i \u2264 n, 1 \u2264 d_i \u2264 10^9) \u2014 the number of the hairline and the length it grows by.\\n\\nOutput\\n\\nFor each query of type 0 print the time...\",\"targets\":\"n,m,l = map(int,input().split())\\n\\n\\nres = []\\ntim =0\\na=list(map(int,input().split()))\\ni=0\\n\\nwhile(i<n):\\n    while(i<n and a[i] <= l):\\n        i +=1\\n    if(i == n):\\n        break\\n    tim += 1\\n    while(i < n and a[i] > l):\\n        i+=1\\n\\nfor i in range(m):\\n    s = input()\\n    if(s=='0'):\\n        res.append(str(tim))\\n        continue\\n    w,p,d = map(int,s.split())\\n    \\n    p-=1\\n    \\n    if(a[p] > l):\\n        continue\\n    a[p] += d\\n    if(a[p] <= l):\\n        continue\\n    if(p > 0 and a[p-1] > l and p < n-1 and a[p+1] > l):\\n        tim -= 1\\n    elif((p > 0 and a[p-1] > l) or (p < n-1 and a[p+1] > l)):\\n        continue\\n    else:\\n        tim += 1\\ns = '\\\\n'.join(res)\\n\\nprint(s)\",\"language\":\"python\",\"split\":\"train\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"A bracket sequence is a string containing only characters \\\"(\\\" and \\\")\\\". 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 \\\"()()\\\" and \\\"(())\\\" are regular (the resulting expressions are: \\\"(1)+(1)\\\" and \\\"((1+1)+1)\\\"), and \\\")(\\\", \\\"(\\\" and \\\")\\\" are not.\\n\\nYou are given an integer n. Your goal is to construct and print exactly n different regular bracket sequences of length 2n.\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 50) \u2014 the number of test cases.\\n\\nEach test case consists of one line containing one integer n (1 \u2264 n \u2264 50).\\n\\nOutput\\n\\nFor each test case, print n lines, each containing a regular bracket sequence of length exactly 2n. All bracket sequences you output for a testcase should be different (though they may repeat in different test cases). If there are multiple answers, print any of them. It can be shown that it's always possible.\\n\\nExample\\n\\nInput\\n\\n\\n3\\n3\\n1\\n3\\n\\n\\nOutput\\n\\n\\n()()()\\n((()))\\n(()())\\n()\\n((()))\\n(())()\\n()(())\\nThe above is tricky. Write me a correct solution in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint main() {\\n  int t;\\n  cin >> t;\\n  while (t--) {\\n    int n;\\n    cin >> n;\\n    string s = \\\"\\\";\\n    for (int i = 0; i < n; i++) {\\n      s += '(';\\n    }\\n    for (int i = 0; i < n; i++) {\\n      s += ')';\\n    }\\n    cout << s << endl;\\n    for (int i = n - 1; i < 2 * n - 2; i++) {\\n      swap(s[i], s[i + 1]);\\n      cout << s << endl;\\n    }\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You are given n integers a_1, a_2, \u2026, a_n. Find the maximum value of max(a_l, a_{l + 1}, \u2026, a_r) \u22c5 min(a_l, a_{l + 1}, \u2026, a_r) over all pairs (l, r) of integers for which 1 \u2264 l < r \u2264 n.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 10 000) \u2014 the number of test cases.\\n\\nThe first line of each test case contains a single integer n (2 \u2264 n \u2264 10^5).\\n\\nThe second line of each test case contains n integers a_1, a_2, \u2026, a_n (1 \u2264 a_i \u2264 10^6).\\n\\nIt is guaranteed that the sum of n over all test cases doesn't exceed 3 \u22c5 10^5.\\n\\nOutput\\n\\nFor each test case, print a single integer \u2014 the maximum possible value of the product from the statement.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n3\\n2 4 3\\n4\\n3 2 3 1\\n2\\n69 69\\n6\\n719313 273225 402638 473783 804745 323328\\n\\n\\nOutput\\n\\n\\n12\\n6\\n4761\\n381274500335\\n\\nNote\\n\\nLet f(l, r) = max(a_l, a_{l + 1}, \u2026, a_r) \u22c5 min(a_l, a_{l + 1}, \u2026, a_r).\\n\\nIn the first test case, \\n\\n  * f(1, 2) = max(a_1, a_2) \u22c5 min(a_1, a_2) = max(2, 4) \u22c5 min(2, 4) = 4 \u22c5 2 = 8. \\n  * f(1, 3) = max(a_1, a_2, a_3) \u22c5 min(a_1, a_2, a_3) = max(2, 4, 3) \u22c5 min(2, 4, 3) = 4 \u22c5 2 = 8. \\n  * f(2, 3) = max(a_2, a_3) \u22c5 min(a_2, a_3) = max(4, 3) \u22c5 min(4, 3) = 4 \u22c5 3 = 12. \\n\\n\\n\\nSo the maximum is f(2, 3) = 12.\\n\\nIn the second test case, the maximum is f(1, 2) = f(1, 3) = f(2, 3) = 6.\\nThe above is tricky. Write me a correct solution in JAVA.\",\"targets\":\"import java.util.*;\\nimport static java.lang.Math.toIntExact;\\n\\npublic class Cherry {\\n    public static void main(String[] args) {\\n        Scanner sc = new Scanner(System.in);\\n        long k = sc.nextLong();\\n\\n        for (int i=0; i<k; i++) {\\n            long n = sc.nextLong();\\n            long[] arr = new long[toIntExact(n)];\\n            for(long j=0; j<n; j++){\\n                arr[toIntExact(j)] = sc.nextLong();\\n            }\\n\\n            long l = 0;\\n            long r = l + 1;\\n            long[] arr2 = new long[toIntExact(n)-1];\\n            for (long j=0; j<n-1; j++){\\n                arr2[toIntExact(j)] = arr[toIntExact(l)]*arr[toIntExact(r)];\\n                l++;\\n                r++;\\n            }\\n            System.out.println(Arrays.stream(arr2).max().getAsLong());\\n        }\\n    }\\n}\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n           \\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n           \\n\\n\\n\\n\\n\\n\\n\\n        \\/*Scanner sc = new Scanner(System.in);\\n        int k = sc.nextInt();\\n        \\n\\n        for (int i=0; i<k; i++) {\\n\\n            int n = sc.nextInt();\\n            int[] dummekackzahlen = new int[n];\\n            for (int j=0; j<n; j++){\\n                dummekackzahlen[j] = sc.nextInt();\\n            }\\n\\n            BigInteger momentanderkingindembiz= BigInteger.valueOf(0);\\n            for (int x=0; x<n-1; x++){\\n                for (int y=x+1; y<n; y++){\\n                    momentanderkingindembiz = (f(dummekackzahlen,x,y).compareTo(momentanderkingindembiz)==1)?f(dummekackzahlen,x,y):momentanderkingindembiz;\\n                }\\n            } \\n            \\n            System.out.println(momentanderkingindembiz);\\n        }\\n    }\\n\\n\\n    public static int max(int[] a, int links, int rechts){\\n        int max=0;\\n        for (int i=links; i<=rechts; i++){\\n            max = max<a[i]?a[i]:max;\\n        }\\n        return max;\\n    }\\n\\n    public static int min(int[] a, int links, int rechts){\\n        int min=a[links];\\n        for (int i=links; i<=rechts; i++){\\n            min= min>a[i]?a[i]:min;\\n        }\\n        return min;\\n    }\\n\\n    public static...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Monocarp is playing a computer game. Now he wants to complete the first level of this game.\\n\\nA level is a rectangular grid of 2 rows and n columns. Monocarp controls a character, which starts in cell (1, 1) \u2014 at the intersection of the 1-st row and the 1-st column.\\n\\nMonocarp's character can move from one cell to another in one step if the cells are adjacent by side and\\/or corner. Formally, it is possible to move from cell (x_1, y_1) to cell (x_2, y_2) in one step if |x_1 - x_2| \u2264 1 and |y_1 - y_2| \u2264 1. Obviously, it is prohibited to go outside the grid.\\n\\nThere are traps in some cells. If Monocarp's character finds himself in such a cell, he dies, and the game ends.\\n\\nTo complete a level, Monocarp's character should reach cell (2, n) \u2014 at the intersection of row 2 and column n.\\n\\nHelp Monocarp determine if it is possible to complete the level.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 100) \u2014 the number of test cases. Then the test cases follow. Each test case consists of three lines.\\n\\nThe first line contains a single integer n (3 \u2264 n \u2264 100) \u2014 the number of columns.\\n\\nThe next two lines describe the level. The i-th of these lines describes the i-th line of the level \u2014 the line consists of the characters '0' and '1'. The character '0' corresponds to a safe cell, the character '1' corresponds to a trap cell.\\n\\nAdditional constraint on the input: cells (1, 1) and (2, n) are safe.\\n\\nOutput\\n\\nFor each test case, output YES if it is possible to complete the level, and NO otherwise.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n3\\n000\\n000\\n4\\n0011\\n1100\\n4\\n0111\\n1110\\n6\\n010101\\n101010\\n\\n\\nOutput\\n\\n\\nYES\\nYES\\nNO\\nYES\\n\\nNote\\n\\nConsider the example from the statement.\\n\\nIn the first test case, one of the possible paths is (1, 1) \u2192 (2, 2) \u2192 (2, 3).\\n\\nIn the second test case, one of the possible paths is (1, 1) \u2192 (1, 2) \u2192 (2, 3) \u2192 (2, 4).\\n\\nIn the fourth test case, one of the possible paths is (1, 1) \u2192 (2, 2) \u2192 (1, 3) \u2192 (2, 4) \u2192 (1, 5) \u2192 (2, 6).\\nUsing python3 can you solve the prior task?\",\"targets\":\"t=int(input())\\nfinal=[]\\nfor j in range(0,t):\\n    n=int(input())\\n    rows=[]\\n    for i in range(0,2):\\n        num=input()\\n        v=list(map(int, str(num)))\\n        rows.append(v)\\n    pos_y=0\\n    pos_x=0\\n    ans=''\\n    while pos_x<n-1:\\n        x=True\\n        if pos_y==0 and rows[1][pos_x+1]==0:\\n            pos_x=pos_x+1 \\n            pos_y=1\\n        elif pos_y==1 and rows[0][pos_x+1]==0:\\n            pos_x=pos_x+1 \\n            pos_y=0\\n        elif rows[pos_y][pos_x+1]==0:\\n            pos_x=pos_x+1   \\n        else:\\n            x=False\\n            ans=\\\"NO\\\"\\n            break\\n    if x==True:\\n        if pos_y==1:\\n            ans=\\\"YES\\\"\\n        elif pos_y==0 and rows[1][n-1]==0:\\n            ans=\\\"YES\\\"\\n        else:\\n            ans=\\\"NO\\\"\\n    final.append(ans)\\nfor i in range (0,t):\\n    print(final[i])\",\"language\":\"python\",\"split\":\"test\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in CPP?\\nAlice and Bob are playing a game. They are given an array A of length N. The array consists of integers. They are building a sequence together. In the beginning, the sequence is empty. In one turn a player can remove a number from the left or right side of the array and append it to the sequence. The rule is that the sequence they are building must be strictly increasing. The winner is the player that makes the last move. Alice is playing first. Given the starting array, under the assumption that they both play optimally, who wins the game?\\n\\nInput\\n\\nThe first line contains one integer N (1 \u2264 N \u2264 2*10^5) - the length of the array A.\\n\\nThe second line contains N integers A_1, A_2,...,A_N (0 \u2264 A_i \u2264 10^9)\\n\\nOutput\\n\\nThe first and only line of output consists of one string, the name of the winner. If Alice won, print \\\"Alice\\\", otherwise, print \\\"Bob\\\".\\n\\nExamples\\n\\nInput\\n\\n\\n1\\n5\\n\\n\\nOutput\\n\\n\\nAlice\\n\\n\\nInput\\n\\n\\n3\\n5 4 5\\n\\n\\nOutput\\n\\n\\nAlice\\n\\n\\nInput\\n\\n\\n6\\n5 8 2 1 10 9\\n\\n\\nOutput\\n\\n\\nBob\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nvoid __print(int x) { cerr << x; }\\nvoid __print(long x) { cerr << x; }\\nvoid __print(long long x) { cerr << x; }\\nvoid __print(unsigned x) { cerr << x; }\\nvoid __print(unsigned long x) { cerr << x; }\\nvoid __print(unsigned long long x) { cerr << x; }\\nvoid __print(float x) { cerr << x; }\\nvoid __print(double x) { cerr << x; }\\nvoid __print(long double x) { cerr << x; }\\nvoid __print(char x) { cerr << '\\\\'' << x << '\\\\''; }\\nvoid __print(const char* x) { cerr << '\\\\\\\"' << x << '\\\\\\\"'; }\\nvoid __print(const string& x) { cerr << '\\\\\\\"' << x << '\\\\\\\"'; }\\nvoid __print(bool x) { cerr << (x ? \\\"true\\\" : \\\"false\\\"); }\\ntemplate <typename T, typename V>\\nvoid __print(const pair<T, V>& x) {\\n  cerr << '{';\\n  __print(x.first);\\n  cerr << ',';\\n  __print(x.second);\\n  cerr << '}';\\n}\\ntemplate <typename T>\\nvoid __print(const T& x) {\\n  int f = 0;\\n  cerr << '{';\\n  for (auto& i : x) cerr << (f++ ? \\\",\\\" : \\\"\\\"), __print(i);\\n  cerr << \\\"}\\\";\\n}\\nvoid _print() { cerr << \\\"]\\\\n\\\"; }\\ntemplate <typename T, typename... V>\\nvoid _print(T t, V... v) {\\n  __print(t);\\n  if (sizeof...(v)) cerr << \\\", \\\";\\n  _print(v...);\\n}\\ntemplate <int MOD_>\\nstruct modnum {\\n  static constexpr int MOD = MOD_;\\n  static_assert(MOD_ > 0, \\\"MOD must be positive\\\");\\n\\n private:\\n  using ll = long long;\\n  int v;\\n  static int minv(int a, int m) {\\n    a %= m;\\n    assert(a);\\n    return a == 1 ? 1 : int(m - ll(minv(m, a)) * ll(m) \\/ a);\\n  }\\n\\n public:\\n  modnum() : v(0) {}\\n  modnum(ll v_) : v(int(v_ % MOD)) {\\n    if (v < 0) v += MOD;\\n  }\\n  explicit operator int() const { return v; }\\n  friend std::ostream& operator<<(std::ostream& out, const modnum& n) {\\n    return out << int(n);\\n  }\\n  friend std::istream& operator>>(std::istream& in, modnum& n) {\\n    ll v_;\\n    in >> v_;\\n    n = modnum(v_);\\n    return in;\\n  }\\n  friend bool operator==(const modnum& a, const modnum& b) {\\n    return a.v == b.v;\\n  }\\n  friend bool operator!=(const modnum& a, const modnum& b) {\\n    return a.v != b.v;\\n  }\\n  modnum inv() const {\\n    modnum res;\\n    res.v = minv(v, MOD);\\n    return res;\\n  }\\n ...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Chanek Jones is back, helping his long-lost relative Indiana Jones, to find a secret treasure in a maze buried below a desert full of illusions.\\n\\nThe map of the labyrinth forms a tree with n rooms numbered from 1 to n and n - 1 tunnels connecting them such that it is possible to travel between each pair of rooms through several tunnels.\\n\\nThe i-th room (1 \u2264 i \u2264 n) has a_i illusion rate. To go from the x-th room to the y-th room, there must exist a tunnel between x and y, and it takes max(|a_x + a_y|, |a_x - a_y|) energy. |z| denotes the absolute value of z.\\n\\nTo prevent grave robbers, the maze can change the illusion rate of any room in it. Chanek and Indiana would ask q queries.\\n\\nThere are two types of queries to be done:\\n\\n  * 1\\\\ u\\\\ c \u2014 The illusion rate of the x-th room is changed to c (1 \u2264 u \u2264 n, 0 \u2264 |c| \u2264 10^9). \\n  * 2\\\\ u\\\\ v \u2014 Chanek and Indiana ask you the minimum sum of energy needed to take the secret treasure at room v if they are initially at room u (1 \u2264 u, v \u2264 n). \\n\\n\\n\\nHelp them, so you can get a portion of the treasure!\\n\\nInput\\n\\nThe first line contains two integers n and q (2 \u2264 n \u2264 10^5, 1 \u2264 q \u2264 10^5) \u2014 the number of rooms in the maze and the number of queries.\\n\\nThe second line contains n integers a_1, a_2, \u2026, a_n (0 \u2264 |a_i| \u2264 10^9) \u2014 inital illusion rate of each room.\\n\\nThe i-th of the next n-1 lines contains two integers s_i and t_i (1 \u2264 s_i, t_i \u2264 n), meaning there is a tunnel connecting s_i-th room and t_i-th room. The given edges form a tree.\\n\\nThe next q lines contain the query as described. The given queries are valid.\\n\\nOutput\\n\\nFor each type 2 query, output a line containing an integer \u2014 the minimum sum of energy needed for Chanek and Indiana to take the secret treasure.\\n\\nExample\\n\\nInput\\n\\n\\n6 4\\n10 -9 2 -1 4 -6\\n1 5\\n5 4\\n5 6\\n6 2\\n6 3\\n2 1 2\\n1 1 -3\\n2 1 2\\n2 3 3\\n\\n\\nOutput\\n\\n\\n39\\n32\\n0\\n\\nNote\\n\\n<image>\\n\\nIn the first query, their movement from the 1-st to the 2-nd room is as follows.\\n\\n  * 1 \u2192 5 \u2014 takes max(|10 + 4|, |10 - 4|) = 14 energy. \\n  * 5 \u2192 6 \u2014 takes max(|4 + (-6)|, |4 - (-6)|) = 10 energy. \\n  * 6 \u2192 2 \u2014...\\nThe above is tricky. Write me a correct solution in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing ll = long long;\\nusing std::cin;\\nusing std::cout;\\nusing std::endl;\\nstd::mt19937 rnd(std::chrono::steady_clock::now().time_since_epoch().count());\\ntemplate <class T>\\ninline bool chmax(T &a, T b) {\\n  if (a < b) {\\n    a = b;\\n    return 1;\\n  }\\n  return 0;\\n}\\ntemplate <class T>\\ninline bool chmin(T &a, T b) {\\n  if (a > b) {\\n    a = b;\\n    return 1;\\n  }\\n  return 0;\\n}\\nconst int inf = (int)1e9 + 7;\\nconst long long INF = 1LL << 60;\\nnamespace KKT89 {\\nstruct HLD {\\n  std::vector<std::vector<int>> g;\\n  std::vector<int> sz, in, out, head, par;\\n  HLD() {}\\n  HLD(std::vector<std::vector<int>> &_g)\\n      : g(_g),\\n        sz(_g.size()),\\n        in(_g.size()),\\n        out(_g.size()),\\n        head(_g.size()),\\n        par(_g.size()) {\\n    build();\\n  }\\n  void dfs_sz(int cur, int pre) {\\n    sz[cur] = 1;\\n    for (int &next : g[cur]) {\\n      if (next == pre) continue;\\n      dfs_sz(next, cur);\\n      par[next] = cur;\\n      sz[cur] += sz[next];\\n      if (sz[next] > sz[g[cur][0]]) std::swap(next, g[cur][0]);\\n    }\\n  }\\n  void dfs_hld(int cur, int pre, int &idx) {\\n    in[cur] = idx++;\\n    for (int &next : g[cur]) {\\n      if (next == pre) continue;\\n      if (next == g[cur][0])\\n        head[next] = head[cur];\\n      else\\n        head[next] = next;\\n      dfs_hld(next, cur, idx);\\n    }\\n    out[cur] = idx;\\n  }\\n  void build() {\\n    dfs_sz(0, -1);\\n    int idx = 0;\\n    dfs_hld(0, -1, idx);\\n  }\\n  void build(std::vector<std::vector<int>> &_g) {\\n    g = _g;\\n    sz.resize(g.size());\\n    in.resize(g.size());\\n    out.resize(g.size());\\n    head.resize(g.size());\\n    par.resize(g.size());\\n    dfs_sz(0, -1);\\n    int idx = 0;\\n    dfs_hld(0, -1, idx);\\n  }\\n  int lca(int u, int v) {\\n    for (;; v = par[head[v]]) {\\n      if (in[u] > in[v]) std::swap(u, v);\\n      if (head[u] == head[v]) return u;\\n    }\\n  }\\n  std::vector<std::pair<int, int>> path_query(int u, int v, bool edge = false) {\\n    std::vector<std::pair<int, int>> ret;\\n    for (;; v = par[head[v]]) {\\n      if (in[u] > in[v]) std::swap(u, v);\\n      if (head[u] == head[v]) break;\\n...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You are given two integers l and r, l\u2264 r. Find the largest possible value of a mod b over all pairs (a, b) of integers for which r\u2265 a \u2265 b \u2265 l.\\n\\nAs a reminder, a mod b is a remainder we get when dividing a by b. For example, 26 mod 8 = 2.\\n\\nInput\\n\\nEach test contains multiple test cases.\\n\\nThe first line contains one positive integer t (1\u2264 t\u2264 10^4), denoting the number of test cases. Description of the test cases follows.\\n\\nThe only line of each test case contains two integers l, r (1\u2264 l \u2264 r \u2264 10^9).\\n\\nOutput\\n\\nFor every test case, output the largest possible value of a mod b over all pairs (a, b) of integers for which r\u2265 a \u2265 b \u2265 l.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n1 1\\n999999999 1000000000\\n8 26\\n1 999999999\\n\\n\\nOutput\\n\\n\\n0\\n1\\n12\\n499999999\\n\\nNote\\n\\nIn the first test case, the only allowed pair is (a, b) = (1, 1), for which a mod b = 1 mod 1 = 0.\\n\\nIn the second test case, the optimal choice is pair (a, b) = (1000000000, 999999999), for which a mod b = 1.\\nSolve the task in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nusing namespace chrono;\\nvoid _print(long long t) { cerr << t; }\\nvoid _print(int t) { cerr << t; }\\nvoid _print(string t) { cerr << t; }\\nvoid _print(char t) { cerr << t; }\\nvoid _print(long double t) { cerr << t; }\\nvoid _print(double t) { cerr << t; }\\nvoid _print(unsigned long long t) { cerr << t; }\\ntemplate <class T, class V>\\nvoid _print(pair<T, V> p);\\ntemplate <class T>\\nvoid _print(vector<T> v);\\ntemplate <class T>\\nvoid _print(set<T> v);\\ntemplate <class T, class V>\\nvoid _print(map<T, V> v);\\ntemplate <class T>\\nvoid _print(multiset<T> v);\\ntemplate <class T, class V>\\nvoid _print(pair<T, V> p) {\\n  cerr << \\\"{\\\";\\n  _print(p.ff);\\n  cerr << \\\",\\\";\\n  _print(p.ss);\\n  cerr << \\\"}\\\";\\n}\\ntemplate <class T>\\nvoid _print(vector<T> v) {\\n  cerr << \\\"[ \\\";\\n  for (T i : v) {\\n    _print(i);\\n    cerr << \\\" \\\";\\n  }\\n  cerr << \\\"]\\\";\\n}\\ntemplate <class T>\\nvoid _print(set<T> v) {\\n  cerr << \\\"[ \\\";\\n  for (T i : v) {\\n    _print(i);\\n    cerr << \\\" \\\";\\n  }\\n  cerr << \\\"]\\\";\\n}\\ntemplate <class T>\\nvoid _print(multiset<T> v) {\\n  cerr << \\\"[ \\\";\\n  for (T i : v) {\\n    _print(i);\\n    cerr << \\\" \\\";\\n  }\\n  cerr << \\\"]\\\";\\n}\\ntemplate <class T, class V>\\nvoid _print(map<T, V> v) {\\n  cerr << \\\"[ \\\";\\n  for (auto i : v) {\\n    _print(i);\\n    cerr << \\\" \\\";\\n  }\\n  cerr << \\\"]\\\";\\n}\\nlong long gcd(long long a, long long b) {\\n  if (b > a) {\\n    return gcd(b, a);\\n  }\\n  if (b == 0) {\\n    return a;\\n  }\\n  return gcd(b, a % b);\\n}\\nlong long expo(long long a, long long b, long long mod) {\\n  long long res = 1;\\n  while (b > 0) {\\n    if (b & 1) res = (res * a) % mod;\\n    a = (a * a) % mod;\\n    b = b >> 1;\\n  }\\n  return res;\\n}\\nvoid extendgcd(long long a, long long b, long long *v) {\\n  if (b == 0) {\\n    v[0] = 1;\\n    v[1] = 0;\\n    v[2] = a;\\n    return;\\n  }\\n  extendgcd(b, a % b, v);\\n  long long x = v[1];\\n  v[1] = v[0] - v[1] * (a \\/ b);\\n  v[0] = x;\\n  return;\\n}\\nlong long mminv(long long a, long long b) {\\n  long long arr[3];\\n  extendgcd(a, b, arr);\\n  return arr[0];\\n}\\nlong long mminvprime(long long a, long long b) { return expo(a, b - 2, b); }\\nbool revsort(long long...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"'Twas the night before Christmas, and Santa's frantically setting up his new Christmas tree! There are n nodes in the tree, connected by n-1 edges. On each edge of the tree, there's a set of Christmas lights, which can be represented by an integer in binary representation.\\n\\n<image>\\n\\nHe has m elves come over and admire his tree. Each elf is assigned two nodes, a and b, and that elf looks at all lights on the simple path between the two nodes. After this, the elf's favorite number becomes the [bitwise XOR](https:\\/\\/en.wikipedia.org\\/wiki\\/Bitwise_operation#XOR) of the values of the lights on the edges in that path.\\n\\nHowever, the North Pole has been recovering from a nasty bout of flu. Because of this, Santa forgot some of the configurations of lights he had put on the tree, and he has already left the North Pole! Fortunately, the elves came to the rescue, and each one told Santa what pair of nodes he was assigned (a_i, b_i), as well as the parity of the number of set bits in his favorite number. In other words, he remembers whether the number of 1's when his favorite number is written in binary is odd or even.\\n\\nHelp Santa determine if it's possible that the memories are consistent, and if it is, remember what his tree looked like, and maybe you'll go down in history!\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 2 \u22c5 10^4) \u2014 the number of test cases. Then t cases follow.\\n\\nThe first line of each test case contains two integers, n and m (2 \u2264 n \u2264 2 \u22c5 10^5; 1 \u2264 m \u2264 2 \u22c5 10^5) \u2014 the size of tree and the number of elves respectively.\\n\\nThe next n-1 lines of each test case each contains three integers, x, y, and v (1 \u2264 x, y \u2264 n; -1 \u2264 v < 2^{30}) \u2014 meaning that there's an edge between nodes x and y. If \\n\\n  * v = -1: Santa doesn't remember what the set of lights were on for this edge. \\n  * v \u2265 0: The set of lights on the edge is v. \\n\\n\\n\\nThe next m lines of each test case each contains three integers, a, b, and p (1 \u2264 a, b \u2264 n; a \u2260 b; 0 \u2264 p \u2264 1) \u2014 the nodes that the elf was assigned to, and the parity of the number of...\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst int N = 200010;\\nint n, m;\\nint col[N];\\nbool vis[N];\\nstruct Edge {\\n  int a, b, c;\\n  Edge() {}\\n  Edge(int a, int b, int c) : a(a), b(b), c(c) {}\\n} edge[N << 1];\\nvoid dfs(int u, int c, bool &flag, vector<pair<int, bool> > *G) {\\n  vis[u] = true;\\n  col[u] = c;\\n  for (pair<int, bool> i : G[u]) {\\n    if (vis[i.first])\\n      flag &= (c ^ i.second) == col[i.first];\\n    else\\n      dfs(i.first, c ^ i.second, flag, G);\\n  }\\n}\\ninline void solve() {\\n  scanf(\\\"%d%d\\\", &n, &m);\\n  vector<pair<int, bool> > G[n + 10];\\n  for (int i = 1; i < n; i++) {\\n    int a, b, c;\\n    scanf(\\\"%d%d%d\\\", &a, &b, &c);\\n    edge[i] = Edge(a, b, c);\\n    if (c == -1) continue;\\n    int p = __builtin_popcount(c) % 2;\\n    G[a].push_back(make_pair(b, p));\\n    G[b].push_back(make_pair(a, p));\\n  }\\n  for (int i = 1; i <= m; i++) {\\n    int a, b, c;\\n    scanf(\\\"%d%d%d\\\", &a, &b, &c);\\n    int p = __builtin_popcount(c) % 2;\\n    G[a].push_back(make_pair(b, p));\\n    G[b].push_back(make_pair(a, p));\\n  }\\n  bool flag = true;\\n  memset(col, 0, sizeof(col));\\n  memset(vis, 0, sizeof(vis));\\n  for (int i = 1; i <= n; i++) {\\n    if (!vis[i]) dfs(i, 0, flag, G);\\n  }\\n  if (!flag)\\n    puts(\\\"NO\\\");\\n  else {\\n    puts(\\\"YES\\\");\\n    for (int i = 1; i < n; i++) {\\n      Edge e = edge[i];\\n      if (~e.c)\\n        printf(\\\"%d %d %d\\\\n\\\", e.a, e.b, e.c);\\n      else\\n        printf(\\\"%d %d %d\\\\n\\\", e.a, e.b, col[e.a] ^ col[e.b]);\\n    }\\n  }\\n}\\nint main() {\\n  int T;\\n  scanf(\\\"%d\\\", &T);\\n  while (T--) {\\n    solve();\\n  }\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"PYTHON3 solution for \\\"Polycarp has a string s. Polycarp performs the following actions until the string s is empty (t is initially an empty string):\\n\\n  * he adds to the right to the string t the string s, i.e. he does t = t + s, where t + s is a concatenation of the strings t and s; \\n  * he selects an arbitrary letter of s and removes from s all its occurrences (the selected letter must occur in the string s at the moment of performing this action). \\n\\n\\n\\nPolycarp performs this sequence of actions strictly in this order.\\n\\nNote that after Polycarp finishes the actions, the string s will be empty and the string t will be equal to some value (that is undefined and depends on the order of removing).\\n\\nE.g. consider s=\\\"abacaba\\\" so the actions may be performed as follows:\\n\\n  * t=\\\"abacaba\\\", the letter 'b' is selected, then s=\\\"aacaa\\\"; \\n  * t=\\\"abacabaaacaa\\\", the letter 'a' is selected, then s=\\\"c\\\"; \\n  * t=\\\"abacabaaacaac\\\", the letter 'c' is selected, then s=\\\"\\\" (the empty string). \\n\\n\\n\\nYou need to restore the initial value of the string s using only the final value of t and find the order of removing letters from s.\\n\\nInput\\n\\nThe first line contains one integer T (1 \u2264 T \u2264 10^4) \u2014 the number of test cases. Then T test cases follow.\\n\\nEach test case contains one string t consisting of lowercase letters of the Latin alphabet. The length of t doesn't exceed 5 \u22c5 10^5. The sum of lengths of all strings t in the test cases doesn't exceed 5 \u22c5 10^5.\\n\\nOutput\\n\\nFor each test case output in a separate line:\\n\\n  * -1, if the answer doesn't exist; \\n  * two strings separated by spaces. The first one must contain a possible initial value of s. The second one must contain a sequence of letters \u2014 it's in what order one needs to remove letters from s to make the string t. E.g. if the string \\\"bac\\\" is outputted, then, first, all occurrences of the letter 'b' were deleted, then all occurrences of 'a', and then, finally, all occurrences of 'c'. If there are multiple solutions, print any one....\\\":\",\"targets\":\"import sys\\nimport math\\nimport bisect\\nfrom collections import *\\nimport heapq\\nfrom sys import stdin,stdout\\nfrom math import gcd,floor,sqrt,log\\nfrom collections import defaultdict as dd\\nfrom bisect import bisect_left as bl,bisect_right as br\\nfrom itertools import *\\nfrom functools import *\\nimport random\\n\\nsys.setrecursionlimit(100000000)\\n\\ninp    =lambda: int(input())\\nstrng  =lambda: input().strip()\\njn     =lambda x,l: x.join(map(str,l))\\nstrl   =lambda: list(input().strip())\\nmul    =lambda: map(int,input().strip().split())\\nmulf   =lambda: map(float,input().strip().split())\\nseq    =lambda: list(map(int,input().strip().split()))\\n\\nceil   =lambda x: int(x) if(x==int(x)) else int(x)+1\\nceildiv=lambda x,d: x\\/\\/d if(x%d==0) else x\\/\\/d+1\\n\\nflush  =lambda: stdout.flush()\\nstdstr =lambda: stdin.readline()\\nstdint =lambda: int(stdin.readline())\\nstdpr  =lambda x: stdout.write(str(x))\\nINF = float('inf')\\nMOD =1000000007\\n\\n\\n#main code\\ndef solve(s,n):\\n    temp = s[:]\\n    s = s[::-1]\\n    cnt = Counter()\\n    order = \\\"\\\"\\n    for c in s:\\n        if c not in cnt:\\n            order += c\\n        cnt[c] += 1\\n    m = len(order)\\n    truelen = 0\\n    for i in range(m):\\n        truelen += cnt[order[i]]\\/\\/(m-i)\\n    order = order[::-1]\\n    return (temp[:truelen], order)\\n\\ndef encrypt(string, order):\\n    res = string[:]\\n    for c in order:\\n        temp = \\\"\\\"\\n        for d in string:\\n            if d != c:\\n                temp += d\\n                res += d\\n        string = temp[:]\\n    return res\\n\\n\\nfor _ in range(inp()):\\n    s = strng()\\n    n = len(s)\\n    original, order = solve(s,n)\\n    check = encrypt(original, order)\\n    if s == check:\\n        print(original, order)\\n    else:\\n        print(-1)\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Paprika loves permutations. She has an array a_1, a_2, ..., a_n. She wants to make the array a permutation of integers 1 to n.\\n\\nIn order to achieve this goal, she can perform operations on the array. In each operation she can choose two integers i (1 \u2264 i \u2264 n) and x (x > 0), then perform a_i := a_i mod x (that is, replace a_i by the remainder of a_i divided by x). In different operations, the chosen i and x can be different.\\n\\nDetermine the minimum number of operations needed to make the array a permutation of integers 1 to n. If it is impossible, output -1.\\n\\nA permutation is an array consisting of n distinct integers from 1 to n in arbitrary order. For example, [2,3,1,5,4] is a permutation, but [1,2,2] is not a permutation (2 appears twice in the array) and [1,3,4] is also not a permutation (n=3 but there is 4 in the array).\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains a single integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases. Description of the test cases follows.\\n\\nThe first line of each test case contains an integer n (1 \u2264 n \u2264 10^5).\\n\\nThe second line of each test case contains n integers a_1, a_2, ..., a_n. (1 \u2264 a_i \u2264 10^9).\\n\\nIt is guaranteed that the sum of n over all test cases does not exceed 2 \u22c5 10^5.\\n\\nOutput\\n\\nFor each test case, output the minimum number of operations needed to make the array a permutation of integers 1 to n, or -1 if it is impossible.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n2\\n1 7\\n3\\n1 5 4\\n4\\n12345678 87654321 20211218 23571113\\n9\\n1 2 3 4 18 19 5 6 7\\n\\n\\nOutput\\n\\n\\n1\\n-1\\n4\\n2\\n\\nNote\\n\\nFor the first test, the only possible sequence of operations which minimizes the number of operations is: \\n\\n  * Choose i=2, x=5. Perform a_2 := a_2 mod 5 = 2. \\n\\n\\n\\nFor the second test, it is impossible to obtain a permutation of integers from 1 to n.\\nSolve the task in JAVA.\",\"targets\":\"import java.util.*;\\nimport java.io.*;\\npublic class C_Paprika_and_Permutation{\\n    public static void solve(int a[],int n){\\n        TreeSet<Integer> set=new TreeSet<>();\\n        for(int i=1;i<=n;i++){\\n            set.add(i);\\n        }\\n        for(int i=0;i<n;i++){\\n            if(set.contains(a[i])){\\n                set.remove(a[i]);\\n                a[i]=-1;\\n            }\\n        }\\n       \\/\\/ System.out.println(set);\\n        Arrays.sort(a);\\n        int ans=0;\\n        for(int i=0;i<n;i++){\\n            if(a[i]!=-1){\\n                 if(set.floor((a[i]-1)\\/2)!=null){\\n                     ans++;\\n                     set.remove(set.floor((a[i]-1)\\/2));\\n                 }else {\\n                     System.out.println(-1);return;\\n                 }\\n            }\\n        }\\n        System.out.println(ans);\\n        \\n    }\\n    public static void main(String args[]){\\n        Scanner sc=new Scanner(System.in);\\n        int t=sc.nextInt();\\n        while(t-->0){\\n            int n=sc.nextInt();\\n            int a[]=new int[n];\\n            for(int i=0;i<n;i++){\\n                a[i]=sc.nextInt();\\n            }\\n            solve(a,n);\\n        }\\n    }\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"This is a simplified version of the problem B2. Perhaps you should read the problem B2 before you start solving B1.\\n\\nPaul and Mary have a favorite string s which consists of lowercase letters of the Latin alphabet. They want to paint it using pieces of chalk of two colors: red and green. Let's call a coloring of a string wonderful if the following conditions are met:\\n\\n  1. each letter of the string is either painted in exactly one color (red or green) or isn't painted; \\n  2. each two letters which are painted in the same color are different; \\n  3. the number of letters painted in red is equal to the number of letters painted in green; \\n  4. the number of painted letters of this coloring is maximum among all colorings of the string which meet the first three conditions. \\n\\n\\n\\nE. g. consider a string s equal to \\\"kzaaa\\\". One of the wonderful colorings of the string is shown in the figure.\\n\\n<image> The example of a wonderful coloring of the string \\\"kzaaa\\\".\\n\\nPaul and Mary want to learn by themselves how to find a wonderful coloring of the string. But they are very young, so they need a hint. Help them find k \u2014 the number of red (or green, these numbers are equal) letters in a wonderful coloring.\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 1000) \u2014 the number of test cases. Then t test cases follow.\\n\\nEach test case consists of one non-empty string s which consists of lowercase letters of the Latin alphabet. The number of characters in the string doesn't exceed 50.\\n\\nOutput\\n\\nFor each test case, output a separate line containing one non-negative integer k \u2014 the number of letters which will be painted in red in a wonderful coloring.\\n\\nExample\\n\\nInput\\n\\n\\n5\\nkzaaa\\ncodeforces\\narchive\\ny\\nxxxxxx\\n\\n\\nOutput\\n\\n\\n2\\n5\\n3\\n0\\n1\\n\\nNote\\n\\nThe first test case contains the string from the statement. One of the wonderful colorings is shown in the figure. There's no wonderful coloring containing 3 or more red letters because the total number of painted symbols will exceed the string's length.\\n\\nThe string from the second test case can be...\",\"targets\":\"import sys,os.path\\nfrom collections import defaultdict as dd\\nimport os\\nimport sys\\nfrom io import BytesIO, IOBase\\n \\nBUFSIZE = 8192\\n \\n \\nclass FastIO(IOBase):\\n    newlines = 0\\n \\n    def __init__(self, file):\\n        self._fd = file.fileno()\\n        self.buffer = BytesIO()\\n        self.writable = \\\"x\\\" in file.mode or \\\"r\\\" not in file.mode\\n        self.write = self.buffer.write if self.writable else None\\n \\n    def read(self):\\n        while True:\\n            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))\\n            if not b:\\n                break\\n            ptr = self.buffer.tell()\\n            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)\\n        self.newlines = 0\\n        return self.buffer.read()\\n \\n    def readline(self):\\n        while self.newlines == 0:\\n            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))\\n            self.newlines = b.count(b\\\"\\\\n\\\") + (not b)\\n            ptr = self.buffer.tell()\\n            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)\\n        self.newlines -= 1\\n        return self.buffer.readline()\\n \\n    def flush(self):\\n        if self.writable:\\n            os.write(self._fd, self.buffer.getvalue())\\n            self.buffer.truncate(0), self.buffer.seek(0)\\n \\n \\nclass IOWrapper(IOBase):\\n    def __init__(self, file):\\n        self.buffer = FastIO(file)\\n        self.flush = self.buffer.flush\\n        self.writable = self.buffer.writable\\n        self.write = lambda s: self.buffer.write(s.encode(\\\"ascii\\\"))\\n        self.read = lambda: self.buffer.read().decode(\\\"ascii\\\")\\n        self.readline = lambda: self.buffer.readline().decode(\\\"ascii\\\")\\n \\n \\nsys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)\\ninput = lambda: sys.stdin.readline().rstrip(\\\"\\\\r\\\\n\\\")\\nif __name__ == '__main__':\\n    if(os.path.exists('input.txt')):\\n        sys.stdin = open(\\\"input.txt\\\",\\\"r\\\")\\n        sys.stdout = open(\\\"output.txt\\\",\\\"w\\\")\\n    for _ in range(int(input())):\\n        s = input()\\n        n = len(s)\\n        d = dd(int)\\n        for i in...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Bike loves looking for the second maximum element in the sequence. The second maximum element in the sequence of distinct numbers x1, x2, ..., xk (k > 1) is such maximum element xj, that the following inequality holds: <image>.\\n\\nThe lucky number of the sequence of distinct positive integers x1, x2, ..., xk (k > 1) is the number that is equal to the bitwise excluding OR of the maximum element of the sequence and the second maximum element of the sequence.\\n\\nYou've got a sequence of distinct positive integers s1, s2, ..., sn (n > 1). Let's denote sequence sl, sl + 1, ..., sr as s[l..r] (1 \u2264 l < r \u2264 n). Your task is to find the maximum number among all lucky numbers of sequences s[l..r].\\n\\nNote that as all numbers in sequence s are distinct, all the given definitions make sence.\\n\\nInput\\n\\nThe first line contains integer n (1 < n \u2264 105). The second line contains n distinct integers s1, s2, ..., sn (1 \u2264 si \u2264 109).\\n\\nOutput\\n\\nPrint a single integer \u2014 the maximum lucky number among all lucky numbers of sequences s[l..r].\\n\\nExamples\\n\\nInput\\n\\n5\\n5 2 1 4 3\\n\\n\\nOutput\\n\\n7\\n\\n\\nInput\\n\\n5\\n9 8 3 5 7\\n\\n\\nOutput\\n\\n15\\n\\nNote\\n\\nFor the first sample you can choose s[4..5] = {4, 3} and its lucky number is (4 xor 3) = 7. You can also choose s[1..2].\\n\\nFor the second sample you must choose s[2..5] = {8, 3, 5, 7}.\\nUsing cpp can you solve the prior task?\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst long long LLMAX = 0x7fffffffffffffffLL;\\nconst long long LLMIN = 0x8000000000000000LL;\\nconst int IMAX = 0x7fffffff;\\nconst int IMIN = 0x80000000;\\nconst double eps = 10e-7;\\nconst int maxn = 100000 + 10;\\nint n;\\nint num[maxn], L[maxn], R[maxn];\\nconst int maxnum = 1000000001;\\nint main() {\\n  while (~scanf(\\\"%d\\\", &n)) {\\n    for (int i = 1; i <= n; i++) {\\n      scanf(\\\"%d\\\", &num[i]);\\n      L[i] = R[i] = i;\\n    }\\n    num[0] = num[n + 1] = maxnum;\\n    L[0] = R[n + 1] = -1;\\n    for (int i = 1; i <= n; i++) {\\n      while (num[L[i] - 1] < num[i]) L[i] = L[L[i] - 1];\\n    }\\n    for (int i = n; i >= 1; i--) {\\n      while (num[R[i] + 1] < num[i]) R[i] = R[R[i] + 1];\\n    }\\n    int ans = (num[1] ^ num[2]);\\n    for (int i = 1; i <= n; i++) {\\n      if (L[i] - 1 >= 1) ans = max(ans, num[i] ^ num[L[i] - 1]);\\n      if (R[i] + 1 <= n) ans = max(ans, num[i] ^ num[R[i] + 1]);\\n    }\\n    printf(\\\"%d\\\\n\\\", ans);\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"PYTHON3 solution for \\\"You have a permutation: an array a = [a_1, a_2, \u2026, a_n] of distinct integers from 1 to n. The length of the permutation n is odd.\\n\\nConsider the following algorithm of sorting the permutation in increasing order.\\n\\nA helper procedure of the algorithm, f(i), takes a single argument i (1 \u2264 i \u2264 n-1) and does the following. If a_i > a_{i+1}, the values of a_i and a_{i+1} are exchanged. Otherwise, the permutation doesn't change.\\n\\nThe algorithm consists of iterations, numbered with consecutive integers starting with 1. On the i-th iteration, the algorithm does the following: \\n\\n  * if i is odd, call f(1), f(3), \u2026, f(n - 2); \\n  * if i is even, call f(2), f(4), \u2026, f(n - 1). \\n\\n\\n\\nIt can be proven that after a finite number of iterations the permutation will be sorted in increasing order.\\n\\nAfter how many iterations will this happen for the first time?\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 100). Description of the test cases follows.\\n\\nThe first line of each test case contains a single integer n (3 \u2264 n \u2264 999; n is odd) \u2014 the length of the permutation.\\n\\nThe second line contains n distinct integers a_1, a_2, \u2026, a_n (1 \u2264 a_i \u2264 n) \u2014 the permutation itself. \\n\\nIt is guaranteed that the sum of n over all test cases does not exceed 999.\\n\\nOutput\\n\\nFor each test case print the number of iterations after which the permutation will become sorted in increasing order for the first time.\\n\\nIf the given permutation is already sorted, print 0.\\n\\nExample\\n\\nInput\\n\\n\\n3\\n3\\n3 2 1\\n7\\n4 5 7 1 3 2 6\\n5\\n1 2 3 4 5\\n\\n\\nOutput\\n\\n\\n3\\n5\\n0\\n\\nNote\\n\\nIn the first test case, the permutation will be changing as follows: \\n\\n  * after the 1-st iteration: [2, 3, 1]; \\n  * after the 2-nd iteration: [2, 1, 3]; \\n  * after the 3-rd iteration: [1, 2, 3]. \\n\\n\\n\\nIn the second test case, the permutation will be changing as follows: \\n\\n  * after the 1-st iteration: [4, 5, 1, 7, 2, 3, 6]; \\n  * after the 2-nd iteration: [4, 1, 5, 2, 7, 3, 6]; \\n  * after the 3-rd iteration: [1, 4, 2, 5, 3, 7, 6]; \\n  * after the 4-th...\\\":\",\"targets\":\"from collections import deque\\nT = int(input())\\n\\ndef solve():\\n    n = int(input())\\n    nums = [int(x) for x in input().split()]\\n    mask = 0\\n    i = 1\\n    for index in range(n):\\n        if nums[index] == index+1:\\n            mask |= (1 << index)\\n    if mask == (1 << n)-1:\\n        print(0)\\n        return\\n    while True:\\n        mask = 0\\n        for index in range(n):\\n            if index != n-1:\\n                if (i%2!=0 and index%2==0) or (i%2==0 and index%2!=0):\\n                    if nums[index] > nums[index+1]:\\n                        nums[index], nums[index+1] = nums[index+1], nums[index]\\n            if nums[index] == index+1:\\n                mask |= (1 << index)\\n        if mask == (1 << n)-1:\\n            break\\n        i += 1\\n    print(i)\\n        \\nfor _ in range(T):\\n    solve()\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"Mike and Ann are sitting in the classroom. The lesson is boring, so they decided to play an interesting game. Fortunately, all they need to play this game is a string s and a number k (0 \u2264 k < |s|).\\n\\nAt the beginning of the game, players are given a substring of s with left border l and right border r, both equal to k (i.e. initially l=r=k). Then players start to make moves one by one, according to the following rules:\\n\\n  * A player chooses l^{\\\\prime} and r^{\\\\prime} so that l^{\\\\prime} \u2264 l, r^{\\\\prime} \u2265 r and s[l^{\\\\prime}, r^{\\\\prime}] is lexicographically less than s[l, r]. Then the player changes l and r in this way: l := l^{\\\\prime}, r := r^{\\\\prime}.\\n  * Ann moves first.\\n  * The player, that can't make a move loses.\\n\\n\\n\\nRecall that a substring s[l, r] (l \u2264 r) of a string s is a continuous segment of letters from s that starts at position l and ends at position r. For example, \\\"ehn\\\" is a substring (s[3, 5]) of \\\"aaaehnsvz\\\" and \\\"ahz\\\" is not.\\n\\nMike and Ann were playing so enthusiastically that they did not notice the teacher approached them. Surprisingly, the teacher didn't scold them, instead of that he said, that he can figure out the winner of the game before it starts, even if he knows only s and k.\\n\\nUnfortunately, Mike and Ann are not so keen in the game theory, so they ask you to write a program, that takes s and determines the winner for all possible k.\\n\\nInput\\n\\nThe first line of the input contains a single string s (1 \u2264 |s| \u2264 5 \u22c5 10^5) consisting of lowercase English letters.\\n\\nOutput\\n\\nPrint |s| lines.\\n\\nIn the line i write the name of the winner (print Mike or Ann) in the game with string s and k = i, if both play optimally\\n\\nExamples\\n\\nInput\\n\\n\\nabba\\n\\n\\nOutput\\n\\n\\nMike\\nAnn\\nAnn\\nMike\\n\\n\\nInput\\n\\n\\ncba\\n\\n\\nOutput\\n\\n\\nMike\\nMike\\nMike\\\":\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint n, id;\\nchar s[500005], Min;\\nint l[500005];\\nint main() {\\n  scanf(\\\"%s\\\", s + 1);\\n  n = strlen(s + 1);\\n  l[1] = 1, Min = s[1], id = 1;\\n  ;\\n  for (int i = 2; i <= n; i++) {\\n    if (s[i] <= s[id]) Min = s[i], id = i;\\n    l[i] = id;\\n  }\\n  for (int i = 1; i <= n; i++) {\\n    if (l[i] == i)\\n      printf(\\\"Mike\\\\n\\\");\\n    else\\n      printf(\\\"Ann\\\\n\\\");\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"On the great island of Baltia, there live N people, numbered from 1 to N. There are exactly M pairs of people that are friends with each other. The people of Baltia want to organize a successful party, but they have very strict rules on what a party is and when the party is successful. On the island of Baltia, a party is a gathering of exactly 5 people. The party is considered to be successful if either all the people at the party are friends with each other (so that they can all talk to each other without having to worry about talking to someone they are not friends with) or no two people at the party are friends with each other (so that everyone can just be on their phones without anyone else bothering them). Please help the people of Baltia organize a successful party or tell them that it's impossible to do so.\\n\\nInput\\n\\nThe first line contains two integer numbers, N (5 \u2264 N \u2264 2*10^5) and M (0 \u2264 M \u2264 2*10^5) \u2013 the number of people that live in Baltia, and the number of friendships. The next M lines each contains two integers U_i and V_i (1 \u2264 U_i,V_i \u2264 N) \u2013 meaning that person U_i is friends with person V_i. Two friends can not be in the list of friends twice (no pairs are repeated) and a person can be friends with themselves (U_i \u2260 V_i).\\n\\nOutput\\n\\nIf it's possible to organize a successful party, print 5 numbers indicating which 5 people should be invited to the party. If it's not possible to organize a successful party, print -1 instead. If there are multiple successful parties possible, print any.\\n\\nExamples\\n\\nInput\\n\\n\\n6 3\\n1 4\\n4 2\\n5 4\\n\\n\\nOutput\\n\\n\\n1 2 3 5 6\\n\\n\\nInput\\n\\n\\n5 4\\n1 2\\n2 3\\n3 4\\n4 5\\n\\n\\nOutput\\n\\n\\n-1\\nimpor\",\"targets\":\"t java.io.*;\\nimport java.util.*;\\n\\npublic class Main{ \\n\\tstatic class Point{\\n\\t\\tint x,y;\\n\\t\\tPoint(int nx, int ny){\\n\\t\\t\\tx = nx; y = ny;\\n\\t\\t}\\n\\t\\tpublic int hashCode() {\\n\\t\\t\\treturn (x << 10) ^ y;\\n\\t\\t}\\n\\t\\tpublic boolean equals(Object o) {\\n\\t\\t\\tPoint p = (Point)o;\\n\\t\\t\\treturn p.x == x && p.y == y;\\n\\t\\t}\\n\\t}\\n\\tpublic static void main(String[] args) throws IOException{\\n        long start = System.currentTimeMillis();\\n\\t\\tIn in = new In();\\n\\t\\tin.tokenize();\\n\\t\\tint n = in.pint(), m = in.pint();\\n\\t\\tHashSet<Point> set = new HashSet<Point>();\\n\\t\\tfor(int i = 0; i < m; i++) {\\n\\t\\t\\tin.tokenize();\\n            int x = in.pint(), y = in.pint();\\n            set.add(new Point(x,y));\\n            set.add(new Point(y,x));\\n\\t\\t}\\n        int[] v = new int[n + 1];\\n        int t = 0;\\n        while(t < 500000) {\\n        \\tt++;\\n            int[] test = new int[5];\\n            for(int k = 0; k < 5; k++){\\n                test[k] = (int)(Math.random() * n) + 1;\\n                while(v[test[k]] == t){\\n                    test[k] = (int)(Math.random() * n) + 1;\\n                }\\n                v[test[k]] = t;\\n            }\\n            boolean all = true, none = true;\\n            for(int i = 0; i < 4 && (all || none); i++){\\n                for(int j = i + 1; j < 5 && (all || none); j++){\\n                \\tboolean ok = set.contains(new Point(test[i], test[j]));\\n                \\tall &= ok;\\n                \\tnone &= !ok;\\n                }   \\n            }\\n            if(all || none){\\n                for(int i : test){\\n                    System.out.print(i + \\\" \\\");\\n                }\\n                System.out.println();\\n                return;\\n            }\\n        }\\n        System.out.println(-1);\\n\\t}\\t\\n}   \\n\\n\\nclass In{\\n    private BufferedReader in;\\n    private StringTokenizer st = new StringTokenizer(\\\"\\\");\\n    public In(){\\n        in = new BufferedReader(new InputStreamReader(System.in));\\n    }\\n    \\n    int pint() throws IOException{\\n        if(st.hasMoreTokens()) {return Integer.parseInt(st.nextToken());}\\n        else {return Integer.parseInt(in.readLine());}\\n    } \\n   ...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Bear Limak wants to become the largest of bears, or at least to become larger than his brother Bob.\\n\\nRight now, Limak and Bob weigh a and b respectively. It's guaranteed that Limak's weight is smaller than or equal to his brother's weight.\\n\\nLimak eats a lot and his weight is tripled after every year, while Bob's weight is doubled after every year.\\n\\nAfter how many full years will Limak become strictly larger (strictly heavier) than Bob?\\n\\nInput\\n\\nThe only line of the input contains two integers a and b (1 \u2264 a \u2264 b \u2264 10) \u2014 the weight of Limak and the weight of Bob respectively.\\n\\nOutput\\n\\nPrint one integer, denoting the integer number of years after which Limak will become strictly larger than Bob.\\n\\nExamples\\n\\nInput\\n\\n4 7\\n\\n\\nOutput\\n\\n2\\n\\n\\nInput\\n\\n4 9\\n\\n\\nOutput\\n\\n3\\n\\n\\nInput\\n\\n1 1\\n\\n\\nOutput\\n\\n1\\n\\nNote\\n\\nIn the first sample, Limak weighs 4 and Bob weighs 7 initially. After one year their weights are 4\u00b73 = 12 and 7\u00b72 = 14 respectively (one weight is tripled while the other one is doubled). Limak isn't larger than Bob yet. After the second year weights are 36 and 28, so the first weight is greater than the second one. Limak became larger than Bob after two years so you should print 2.\\n\\nIn the second sample, Limak's and Bob's weights in next years are: 12 and 18, then 36 and 36, and finally 108 and 72 (after three years). The answer is 3. Remember that Limak wants to be larger than Bob and he won't be satisfied with equal weights.\\n\\nIn the third sample, Limak becomes larger than Bob after the first year. Their weights will be 3 and 2 then.\",\"targets\":\"def solve(a,b):\\n    counter = 0\\n    while(a<=b):\\n        a *= 3\\n        b *= 2\\n        counter += 1\\n    print(counter)\\n\\nn,h = input().split()\\nn = int(n)\\nh = int(h)\\nsolve(n,h)\",\"language\":\"python\",\"split\":\"train\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Polycarp must pay exactly n burles at the checkout. He has coins of two nominal values: 1 burle and 2 burles. Polycarp likes both kinds of coins equally. So he doesn't want to pay with more coins of one type than with the other.\\n\\nThus, Polycarp wants to minimize the difference between the count of coins of 1 burle and 2 burles being used. Help him by determining two non-negative integer values c_1 and c_2 which are the number of coins of 1 burle and 2 burles, respectively, so that the total value of that number of coins is exactly n (i. e. c_1 + 2 \u22c5 c_2 = n), and the absolute value of the difference between c_1 and c_2 is as little as possible (i. e. you must minimize |c_1-c_2|).\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases. Then t test cases follow.\\n\\nEach test case consists of one line. This line contains one integer n (1 \u2264 n \u2264 10^9) \u2014 the number of burles to be paid by Polycarp.\\n\\nOutput\\n\\nFor each test case, output a separate line containing two integers c_1 and c_2 (c_1, c_2 \u2265 0) separated by a space where c_1 is the number of coins of 1 burle and c_2 is the number of coins of 2 burles. If there are multiple optimal solutions, print any one.\\n\\nExample\\n\\nInput\\n\\n\\n6\\n1000\\n30\\n1\\n32\\n1000000000\\n5\\n\\n\\nOutput\\n\\n\\n334 333\\n10 10\\n1 0\\n10 11\\n333333334 333333333\\n1 2\\n\\nNote\\n\\nThe answer for the first test case is \\\"334 333\\\". The sum of the nominal values of all coins is 334 \u22c5 1 + 333 \u22c5 2 = 1000, whereas |334 - 333| = 1. One can't get the better value because if |c_1 - c_2| = 0, then c_1 = c_2 and c_1 \u22c5 1 + c_1 \u22c5 2 = 1000, but then the value of c_1 isn't an integer.\\n\\nThe answer for the second test case is \\\"10 10\\\". The sum of the nominal values is 10 \u22c5 1 + 10 \u22c5 2 = 30 and |10 - 10| = 0, whereas there's no number having an absolute value less than 0.\\n'''\",\"targets\":\"Welcome to GDB Online.\\nGDB online is an online compiler and debugger tool for C, C++, Python, Java, PHP, Ruby, Perl,\\nC#, VB, Swift, Pascal, Fortran, Haskell, Objective-C, Assembly, HTML, CSS, JS, SQLite, Prolog.\\nCode, Compile, Run and Debug online from anywhere in world.\\n\\n'''\\nt=int(input());k=[]\\nfor i in range(t):\\n    n=int(input())\\n    if n%3==0:\\n        k.append([n\\/\\/3,n\\/\\/3])\\n    elif n%3==1:\\n        r=n-1\\n        k.append([r\\/\\/3+1,r\\/\\/3])\\n    else:\\n        r=n-2\\n        k.append([r\\/\\/3,r\\/\\/3+1])\\nfor i in k:\\n    for j in i:\\n        print(j,end=' ')\\n    print('\\\\n')\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in CPP?\\nLet's consider a simplified version of order book of some stock. The order book is a list of orders (offers) from people that want to buy or sell one unit of the stock, each order is described by direction (BUY or SELL) and price.\\n\\nAt every moment of time, every SELL offer has higher price than every BUY offer. \\n\\nIn this problem no two ever existed orders will have the same price.\\n\\nThe lowest-price SELL order and the highest-price BUY order are called the best offers, marked with black frames on the picture below.\\n\\n<image> The presented order book says that someone wants to sell the product at price 12 and it's the best SELL offer because the other two have higher prices. The best BUY offer has price 10.\\n\\nThere are two possible actions in this orderbook: \\n\\n  1. Somebody adds a new order of some direction with some price.\\n  2. Somebody accepts the best possible SELL or BUY offer (makes a deal). It's impossible to accept not the best SELL or BUY offer (to make a deal at worse price). After someone accepts the offer, it is removed from the orderbook forever.\\n\\n\\n\\nIt is allowed to add new BUY order only with prices less than the best SELL offer (if you want to buy stock for higher price, then instead of adding an order you should accept the best SELL offer). Similarly, one couldn't add a new SELL order with price less or equal to the best BUY offer. For example, you can't add a new offer \\\"SELL 20\\\" if there is already an offer \\\"BUY 20\\\" or \\\"BUY 25\\\" \u2014 in this case you just accept the best BUY offer.\\n\\nYou have a damaged order book log (in the beginning the are no orders in book). Every action has one of the two types:\\n\\n  1. \\\"ADD p\\\" denotes adding a new order with price p and unknown direction. The order must not contradict with orders still not removed from the order book. \\n  2. \\\"ACCEPT p\\\" denotes accepting an existing best offer with price p and unknown direction.\\n\\n\\n\\nThe directions of all actions are lost. Information from the log isn't always enough to determine these directions. Count the number of ways to correctly...\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nlong long powm(long long base, long long exp, long long mod = 1000000007) {\\n  long long ans = 1;\\n  while (exp) {\\n    if (exp & 1) ans = (ans * base) % mod;\\n    exp >>= 1, base = (base * base) % mod;\\n  }\\n  return ans;\\n}\\nlong long ctl(char x, char an = 'a') { return (long long)(x - an); }\\nchar ltc(long long x, char an = 'a') { return (char)(x + an); }\\nlong long buy = -1000111000111000111LL, sell = 1000111000111000111LL;\\nset<long long> rem;\\nint main() {\\n  long long n, p, tot = 0, ans = 1;\\n  string second;\\n  cin >> n;\\n  for (long long i = 1; i < n + 1; i++) {\\n    cin >> second >> p;\\n    if (second == \\\"ADD\\\") {\\n      if (p > buy and p < sell) tot++;\\n      rem.insert(p);\\n    } else {\\n      if (p > buy and p < sell)\\n        ans = (ans * 2LL) % 1000000007;\\n      else if (p != buy and p != sell)\\n        ans = 0;\\n      auto it1 = rem.lower_bound(p);\\n      if (it1 == rem.begin())\\n        buy = -1000111000111000111LL;\\n      else\\n        buy = *(--it1);\\n      auto it2 = rem.upper_bound(p);\\n      if (it2 == rem.end())\\n        sell = 1000111000111000111LL;\\n      else\\n        sell = *(it2);\\n      rem.erase(p), tot = 0;\\n    }\\n  }\\n  ans = (ans * (tot + 1) % 1000000007) % 1000000007;\\n  cout << ans;\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"JAVA solution for \\\"Theofanis has a riddle for you and if you manage to solve it, he will give you a Cypriot snack halloumi for free (Cypriot cheese).\\n\\nYou are given an integer n. You need to find two integers l and r such that -10^{18} \u2264 l < r \u2264 10^{18} and l + (l + 1) + \u2026 + (r - 1) + r = n.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases.\\n\\nThe first and only line of each test case contains a single integer n (1 \u2264 n \u2264 10^{18}).\\n\\nOutput\\n\\nFor each test case, print the two integers l and r such that -10^{18} \u2264 l < r \u2264 10^{18} and l + (l + 1) + \u2026 + (r - 1) + r = n. \\n\\nIt can be proven that an answer always exists. If there are multiple answers, print any.\\n\\nExample\\n\\nInput\\n\\n\\n7\\n1\\n2\\n3\\n6\\n100\\n25\\n3000000000000\\n\\n\\nOutput\\n\\n\\n0 1\\n-1 2 \\n1 2 \\n1 3 \\n18 22\\n-2 7\\n999999999999 1000000000001\\n\\nNote\\n\\nIn the first test case, 0 + 1 = 1.\\n\\nIn the second test case, (-1) + 0 + 1 + 2 = 2.\\n\\nIn the fourth test case, 1 + 2 + 3 = 6.\\n\\nIn the fifth test case, 18 + 19 + 20 + 21 + 22 = 100.\\n\\nIn the sixth test case, (-2) + (-1) + 0 + 1 + 2 + 3 + 4 + 5 + 6 + 7 = 25.\\\":\",\"targets\":\"import java.util.Scanner;\\n\\npublic class ConsecutiveSumRiddle_CF1594_A{\\n\\n static void solve(long x){\\n  if(x>0){\\n   System.out.print(-x+1);\\n   System.out.print(\\\" \\\");\\n   System.out.print(x);\\n   System.out.println();\\n }\\n  else if(x<0){\\n   System.out.print(x);\\n   System.out.print(\\\" \\\");\\n   System.out.print(-x-1);\\n   System.out.println();\\n  }\\n  else{\\n   System.out.print(-1);\\n   System.out.print(\\\" \\\");\\n   System.out.print(1);\\n   System.out.println();\\n  }\\n }\\n\\n\\n public static void main(String[] args) {\\n\\n  Scanner scan = new Scanner(System.in);\\n  int n = scan.nextInt();\\n  while(n>0){\\n   long p = scan.nextLong();\\n   solve(p);\\n   n--;\\n  }\\n \\n }\\n\\n\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Monocarp is playing a computer game. Now he wants to complete the first level of this game.\\n\\nA level is a rectangular grid of 2 rows and n columns. Monocarp controls a character, which starts in cell (1, 1) \u2014 at the intersection of the 1-st row and the 1-st column.\\n\\nMonocarp's character can move from one cell to another in one step if the cells are adjacent by side and\\/or corner. Formally, it is possible to move from cell (x_1, y_1) to cell (x_2, y_2) in one step if |x_1 - x_2| \u2264 1 and |y_1 - y_2| \u2264 1. Obviously, it is prohibited to go outside the grid.\\n\\nThere are traps in some cells. If Monocarp's character finds himself in such a cell, he dies, and the game ends.\\n\\nTo complete a level, Monocarp's character should reach cell (2, n) \u2014 at the intersection of row 2 and column n.\\n\\nHelp Monocarp determine if it is possible to complete the level.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 100) \u2014 the number of test cases. Then the test cases follow. Each test case consists of three lines.\\n\\nThe first line contains a single integer n (3 \u2264 n \u2264 100) \u2014 the number of columns.\\n\\nThe next two lines describe the level. The i-th of these lines describes the i-th line of the level \u2014 the line consists of the characters '0' and '1'. The character '0' corresponds to a safe cell, the character '1' corresponds to a trap cell.\\n\\nAdditional constraint on the input: cells (1, 1) and (2, n) are safe.\\n\\nOutput\\n\\nFor each test case, output YES if it is possible to complete the level, and NO otherwise.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n3\\n000\\n000\\n4\\n0011\\n1100\\n4\\n0111\\n1110\\n6\\n010101\\n101010\\n\\n\\nOutput\\n\\n\\nYES\\nYES\\nNO\\nYES\\n\\nNote\\n\\nConsider the example from the statement.\\n\\nIn the first test case, one of the possible paths is (1, 1) \u2192 (2, 2) \u2192 (2, 3).\\n\\nIn the second test case, one of the possible paths is (1, 1) \u2192 (1, 2) \u2192 (2, 3) \u2192 (2, 4).\\n\\nIn the fourth test case, one of the possible paths is (1, 1) \u2192 (2, 2) \u2192 (1, 3) \u2192 (2, 4) \u2192 (1, 5) \u2192 (2, 6).\\nThe above is tricky. Write me a correct solution in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nconst int mod = 998244353;\\nconst int maxn = 2e5 + 5;\\nconst long long int INF = 2e5 + 5;\\nusing namespace std;\\nint main() {\\n  ios::sync_with_stdio(false);\\n  cin.tie(0);\\n  cout.tie(0);\\n  int tc;\\n  cin >> tc;\\n  while (tc--) {\\n    int n;\\n    cin >> n;\\n    vector<vector<char> > str(3, vector<char>(n + 1));\\n    for (int i = 1; i <= 2; i++) {\\n      for (int j = 1; j <= n; j++) {\\n        cin >> str[i][j];\\n      }\\n    }\\n    vector<vector<int> > dp(4, vector<int>(n + 4));\\n    dp[1][1] = 1;\\n    if (str[2][1] == '0') dp[2][1] = 1;\\n    for (int i = 2; i <= n; i++) {\\n      if (str[1][i] == '0') {\\n        dp[1][i] = (dp[1][i - 1] || dp[2][i - 1]);\\n      }\\n      if (str[2][i] == '0') {\\n        dp[2][i] = (dp[2][i - 1] || dp[1][i - 1]);\\n      }\\n    }\\n    if (dp[2][n])\\n      cout << \\\"YES\\\\n\\\";\\n    else\\n      cout << \\\"NO\\\\n\\\";\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Ezzat has an array of n integers (maybe negative). He wants to split it into two non-empty subsequences a and b, such that every element from the array belongs to exactly one subsequence, and the value of f(a) + f(b) is the maximum possible value, where f(x) is the average of the subsequence x. \\n\\nA sequence x is a subsequence of a sequence y if x can be obtained from y by deletion of several (possibly, zero or all) elements.\\n\\nThe average of a subsequence is the sum of the numbers of this subsequence divided by the size of the subsequence.\\n\\nFor example, the average of [1,5,6] is (1+5+6)\\/3 = 12\\/3 = 4, so f([1,5,6]) = 4.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 10^3)\u2014 the number of test cases. Each test case consists of two lines.\\n\\nThe first line contains a single integer n (2 \u2264 n \u2264 10^5).\\n\\nThe second line contains n integers a_1, a_2, \u2026, a_n (-10^9 \u2264 a_i \u2264 10^9).\\n\\nIt is guaranteed that the sum of n over all test cases does not exceed 3\u22c510^5.\\n\\nOutput\\n\\nFor each test case, print a single value \u2014 the maximum value that Ezzat can achieve.\\n\\nYour answer is considered correct if its absolute or relative error does not exceed 10^{-6}.\\n\\nFormally, let your answer be a, and the jury's answer be b. Your answer is accepted if and only if \\\\frac{|a - b|}{max{(1, |b|)}} \u2264 10^{-6}.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n3\\n3 1 2\\n3\\n-7 -6 -6\\n3\\n2 2 2\\n4\\n17 3 5 -3\\n\\n\\nOutput\\n\\n\\n4.500000000\\n-12.500000000\\n4.000000000\\n18.666666667\\n\\nNote\\n\\nIn the first test case, the array is [3, 1, 2]. These are all the possible ways to split this array: \\n\\n  * a = [3], b = [1,2], so the value of f(a) + f(b) = 3 + 1.5 = 4.5. \\n  * a = [3,1], b = [2], so the value of f(a) + f(b) = 2 + 2 = 4. \\n  * a = [3,2], b = [1], so the value of f(a) + f(b) = 2.5 + 1 = 3.5. \\n\\nTherefore, the maximum possible value 4.5.\\n\\nIn the second test case, the array is [-7, -6, -6]. These are all the possible ways to split this array: \\n\\n  * a = [-7], b = [-6,-6], so the value of f(a) + f(b) = (-7) + (-6) = -13. \\n  * a = [-7,-6], b = [-6], so the value of f(a) + f(b) = (-6.5) + (-6) =...\\nThe above is tricky. Write me a correct solution in JAVA.\",\"targets\":\"import java.util.*;\\n\\npublic class contest737 {\\n\\n\\tpublic static void main(String[] args) {\\n\\t\\tScanner scn = new Scanner(System.in);\\n\\t\\tint t = scn.nextInt();\\n\\n\\t\\tfor (int i = 0; i < t; i++) {\\n\\t\\t\\tHashMap<Integer, Integer> map = new HashMap<>();\\n\\t\\t\\tint n = scn.nextInt();\\n\\t\\t\\tint[] arr = new int[n];\\n\\t\\t\\tint max = Integer.MIN_VALUE;\\n\\t\\t\\tfor (int j = 0; j < n; j++) {\\n\\t\\t\\t\\tarr[j] = scn.nextInt();\\n\\t\\t\\t\\tif (arr[j] > max) {\\n\\t\\t\\t\\t\\tmap.remove(max);\\n\\t\\t\\t\\t\\tmax = arr[j];\\n\\t\\t\\t\\t\\tmap.put(max, j);\\n\\t\\t\\t\\t}\\n\\t\\t\\t}\\n\\/\\/\\t\\t\\t\\n\\/\\/\\t\\t\\tfor(int a=0;a<arr.length;a++) {\\n\\/\\/\\t\\t\\t\\tSystem.out.print(arr[a]+\\\" \\\");\\n\\/\\/\\t\\t\\t}\\n\\t\\t\\t\\n\\t\\t\\t\\n\\t\\t\\tdouble sum = 0;\\n\\t\\t\\tfor (int k = 0; k < n; k++) {\\n\\/\\/\\t\\t\\t\\tSystem.out.println(arr[k]);\\n\\t\\t\\t\\tif (arr[k] == max) {\\n\\t\\t\\t\\t\\tif (map.isEmpty() == false) {\\n\\t\\t\\t\\t\\t\\tmap.remove(max);\\n                        continue;\\n\\t\\t\\t\\t\\t}else {\\n\\/\\/\\t\\t\\t\\t\\t\\tSystem.out.println(\\\"==============\\\");\\n\\/\\/\\t\\t\\t\\t\\t\\tSystem.out.println(arr[k]);\\n\\t\\t\\t\\t\\t\\tsum+=arr[k];\\n\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\t}else {\\n\\/\\/\\t\\t\\t\\t\\tSystem.out.println(\\\"-----------\\\");\\n\\/\\/\\t\\t\\t\\t\\tSystem.out.println(arr[k]);System.out.println(\\\"----------------bsdhbfbqfjdnc\\\");\\n\\t\\t\\t\\t\\tsum+=arr[k];\\n\\t\\t\\t\\t}\\n\\t\\t\\t}\\n\\t\\t\\t\\n\\t\\t\\tint a=n-1;\\n\\t\\t\\t\\n\\t\\t\\t\\n\\t\\t\\tSystem.out.println(Double.valueOf(max)+sum\\/a);\\n\\n\\t\\t}\\n\\n\\t}\\n\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"A matrix of size n \u00d7 m, such that each cell of it contains either 0 or 1, is considered beautiful if the sum in every contiguous submatrix of size 2 \u00d7 2 is exactly 2, i. e. every \\\"square\\\" of size 2 \u00d7 2 contains exactly two 1's and exactly two 0's.\\n\\nYou are given a matrix of size n \u00d7 m. Initially each cell of this matrix is empty. Let's denote the cell on the intersection of the x-th row and the y-th column as (x, y). You have to process the queries of three types:\\n\\n  * x y -1 \u2014 clear the cell (x, y), if there was a number in it; \\n  * x y 0 \u2014 write the number 0 in the cell (x, y), overwriting the number that was there previously (if any); \\n  * x y 1 \u2014 write the number 1 in the cell (x, y), overwriting the number that was there previously (if any). \\n\\n\\n\\nAfter each query, print the number of ways to fill the empty cells of the matrix so that the resulting matrix is beautiful. Since the answers can be large, print them modulo 998244353.\\n\\nInput\\n\\nThe first line contains three integers n, m and k (2 \u2264 n, m \u2264 10^6; 1 \u2264 k \u2264 3 \u22c5 10^5) \u2014 the number of rows in the matrix, the number of columns, and the number of queries, respectively.\\n\\nThen k lines follow, the i-th of them contains three integers x_i, y_i, t_i (1 \u2264 x_i \u2264 n; 1 \u2264 y_i \u2264 m; -1 \u2264 t_i \u2264 1) \u2014 the parameters for the i-th query.\\n\\nOutput\\n\\nFor each query, print one integer \u2014 the number of ways to fill the empty cells of the matrix after the respective query, taken modulo 998244353.\\n\\nExample\\n\\nInput\\n\\n\\n2 2 7\\n1 1 1\\n1 2 1\\n2 1 1\\n1 1 0\\n1 2 -1\\n2 1 -1\\n1 1 -1\\n\\n\\nOutput\\n\\n\\n3\\n1\\n0\\n1\\n2\\n3\\n6\\n#incl\",\"targets\":\"ude <bits\\/stdc++.h>\\nusing namespace std;\\nconst int mod = 998244353;\\nconst int maxn = 1e6 + 5;\\nmap<pair<int, int>, int> a;\\nint cnt[2][2][maxn][3], sum[2][4][4], pw[maxn], ct[2][2][2][2];\\nvoid cgsta(int op, int id, int x, int val) {\\n  sum[op][cnt[op][0][x][2]][cnt[op][1][x][2]]--;\\n  if (cnt[op][id][x][2] == 2 || cnt[op][id][x][2] == 1)\\n    ct[op][id][cnt[op][id][x][2] - 1][x & 1]--;\\n  cnt[op][id][x][2] = val;\\n  sum[op][cnt[op][0][x][2]][cnt[op][1][x][2]]++;\\n  if (cnt[op][id][x][2] == 2 || cnt[op][id][x][2] == 1)\\n    ct[op][id][cnt[op][id][x][2] - 1][x & 1]++;\\n}\\nint judgesta(int op, int id, int x) {\\n  int v0 = cnt[op][id][x][0], v1 = cnt[op][id][x][1];\\n  if (!v0 && !v1) return 0;\\n  if (v0 && !v1) return 1;\\n  if (!v0 && v1) return 2;\\n  return 3;\\n}\\nbool ok(int op) {\\n  for (int i = 0; i < 4; ++i) {\\n    for (int j = 0; j < 4; ++j) {\\n      if (!sum[op][i][j]) continue;\\n      if (i == 3 || j == 3) return false;\\n      if (i == j && i > 0) return false;\\n    }\\n  }\\n  return true;\\n}\\nint cal(int op) {\\n  if (!ok(op)) return 0;\\n  return pw[sum[op][0][0]];\\n}\\nint judge(int op) {\\n  if (!ok(op)) return false;\\n  int ans = 3, fg = -1;\\n  for (int i = 0; i < 2; ++i) {\\n    for (int j = 0; j < 2; ++j) {\\n      if (ct[op][i][j][0] && ct[op][i][j][1] ||\\n          ct[op][i][0][j] && ct[op][i][1][j])\\n        return false;\\n      for (int k = 0; k < 2; ++k) {\\n        if (!ct[op][i][j][k]) continue;\\n        int now = (i + j + k) % 2 + 1;\\n        if (ans != 3 && now != ans) return false;\\n        ans = now;\\n      }\\n    }\\n  }\\n  return ans;\\n}\\nint getans() {\\n  int ans = (cal(0) + cal(1)) % mod;\\n  int r = judge(0), c = judge(1);\\n  for (int i = 0; i < 2; ++i) {\\n    if (((r >> i) & 1) && ((c >> i) & 1)) {\\n      ans--;\\n    }\\n  }\\n  ans = (ans + mod) % mod;\\n  return ans;\\n}\\nvoid del(int x, int y) {\\n  if (!a[{x, y}]) return;\\n  int val = a[{x, y}] - 1;\\n  for (int i = 0; i < 2; ++i) {\\n    cnt[i][x & 1][y][val]--;\\n    int nowsta = judgesta(i, x & 1, y);\\n    cgsta(i, x & 1, y, nowsta);\\n    swap(x, y);\\n  }\\n  a[{x, y}] = 0;\\n}\\nvoid add(int x, int y, int val) {\\n ...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"JAVA solution for \\\"The new generation external memory contains an array of integers a[1 \u2026 n] = [a_1, a_2, \u2026, a_n].\\n\\nThis type of memory does not support changing the value of an arbitrary element. Instead, it allows you to cut out any segment of the given array, cyclically shift (rotate) it by any offset and insert it back into the same place.\\n\\nTechnically, each cyclic shift consists of two consecutive actions: \\n\\n  1. You may select arbitrary indices l and r (1 \u2264 l < r \u2264 n) as the boundaries of the segment. \\n  2. Then you replace the segment a[l \u2026 r] with it's cyclic shift to the left by an arbitrary offset d. The concept of a cyclic shift can be also explained by following relations: the sequence [1, 4, 1, 3] is a cyclic shift of the sequence [3, 1, 4, 1] to the left by the offset 1 and the sequence [4, 1, 3, 1] is a cyclic shift of the sequence [3, 1, 4, 1] to the left by the offset 2. \\n\\n\\n\\nFor example, if a = [1, \\\\color{blue}{3, 2, 8}, 5], then choosing l = 2, r = 4 and d = 2 yields a segment a[2 \u2026 4] = [3, 2, 8]. This segment is then shifted by the offset d = 2 to the left, and you get a segment [8, 3, 2] which then takes the place of of the original elements of the segment. In the end you get a = [1, \\\\color{blue}{8, 3, 2}, 5].\\n\\nSort the given array a using no more than n cyclic shifts of any of its segments. Note that you don't need to minimize the number of cyclic shifts. Any method that requires n or less cyclic shifts will be accepted.\\n\\nInput\\n\\nThe first line contains an integer t (1 \u2264 t \u2264 1000) \u2014 the number of test cases.\\n\\nThe next 2t lines contain the descriptions of the test cases. \\n\\nThe first line of each test case description contains an integer n (2 \u2264 n \u2264 50) \u2014 the length of the array. The second line consists of space-separated elements of the array a_i (-10^9 \u2264 a_i \u2264 10^9). Elements of array a may repeat and don't have to be unique.\\n\\nOutput\\n\\nPrint t answers to all input test cases. \\n\\nThe first line of the answer of each test case should contain an integer k (0 \u2264 k \u2264 n) \u2014 the number of actions to sort the array....\\\":\",\"targets\":\"import java.io.BufferedReader;\\nimport java.io.IOException;\\nimport java.io.InputStreamReader;\\nimport java.io.PrintWriter;\\nimport java.util.*;\\n\\npublic class ProblemB1579 {\\n\\n    public static void main(String[] args){\\n        FastReader sc=new FastReader();\\n        PrintWriter pw=new PrintWriter(System.out);\\n\\n        int t=Integer.valueOf(sc.nextInt());\\n\\n        for(int i=0;i<t;i++){\\n            int n=Integer.valueOf(sc.nextInt());\\n            int[] arr=new int[n];\\n            for(int j=0;j<n;j++){\\n                arr[j]=sc.nextInt();\\n            }\\n            List<Pair> ls=new ArrayList<Pair>();\\n            for(int k=0;k<arr.length;k++) {\\n                Pair p=solve(arr,k);\\n                if(p!=null)\\n                    ls.add(p);\\n            }\\n            pw.println(ls.size());\\n            for(int l=0;l<ls.size();l++){\\n                Pair p=ls.get(l);\\n                pw.println((p.l+1)+\\\" \\\"+(p.r+1)+\\\" \\\"+p.d);\\n            }\\n            \\/\\/pw.println(\\\"sajal\\\"+Arrays.toString(arr));\\n        }\\n        pw.flush();\\n    }\\n\\n    static Pair solve(int[] arr,int start){\\n        int min=arr[start];\\n        int mini=start;\\n        for(int i=start+1;i<arr.length;i++){\\n            if(arr[i]<min){\\n                min=arr[i];\\n                mini=i;\\n            }\\n        }\\n        if(mini==start){\\n            return null;\\n        }\\n        swap(arr,start,mini);\\n        return new Pair(start,mini,mini-start);\\n    }\\n\\n    static void swap(int[] arr,int start,int end){\\n        \\/\\/0,2\\n        int temp=arr[start];\\n        for(int i=start+1;i<=end;i++){\\n            int temp1=arr[i];\\n            arr[i]=temp;\\n            temp=temp1;\\n        }\\n        arr[start]=temp;\\n    }\\n\\n    static class FastReader\\n    {\\n        BufferedReader br;\\n        StringTokenizer st;\\n        public FastReader()\\n        {\\n            br = new BufferedReader(new InputStreamReader(System.in));\\n        }\\n        String next()\\n        {\\n            while (st == null || !st.hasMoreElements())\\n            {\\n                try\\n                {\\n                    st...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Consider the following arithmetic progression with n terms:\\n\\n* x, x + d, x + 2d, \\\\ldots, x + (n-1)d\\n\\n\\n\\nWhat is the product of all terms in this sequence? Compute the answer modulo 1\\\\ 000\\\\ 003.\\n\\nYou are given Q queries of this form. In the i-th query, compute the answer in case x = x_i, d = d_i, n = n_i.\\n\\nConstraints\\n\\n* 1 \\\\leq Q \\\\leq 10^5\\n* 0 \\\\leq x_i, d_i \\\\leq 1\\\\ 000\\\\ 002\\n* 1 \\\\leq n_i \\\\leq 10^9\\n* All values in input are integers.\\n\\nInput\\n\\nInput is given from Standard Input in the following format:\\n\\n\\nQ\\nx_1 d_1 n_1\\n:\\nx_Q d_Q n_Q\\n\\n\\nOutput\\n\\nPrint Q lines.\\n\\nIn the i-th line, print the answer for the i-th query.\\n\\nExample\\n\\nInput\\n\\n2\\n7 2 4\\n12345 67890 2019\\n\\n\\nOutput\\n\\n9009\\n916936\\nThe above is tricky. Write me a correct solution in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\n#define int long long\\n#define rep(i, n) for(int i = 0; i < (int)(n); i++)\\n#define all(x) (x).begin(),(x).end()\\n#define pb push_back\\n#define F first\\n#define S second\\n\\nusing namespace std;\\ntypedef pair<int,int> P;\\ntypedef long long LL;\\nconst int MOD=1000003;\\nint INF=100100100100100;\\n\\nint add(int a,int b){\\n  return (a+b)%MOD;\\n}\\nint prod(int a,int b){\\n  return (a*b)%MOD;\\n}\\n\\nLL beki(LL a,LL b)\\n{\\n\\tif(b==0)return 1;\\n\\tLL x=beki(a,b\\/2);\\n\\tif(b%2==0)return (x*x)%MOD;\\n\\telse return (((a*x)%MOD)*x)%MOD;\\n}\\n\\nLL inv(LL a)\\n{\\n\\treturn beki(a,MOD-2);\\n}\\n\\nLL kaijou(LL a)\\n{\\n\\tLL ans=1;\\n\\tfor(LL i=1;i<=a;i++)\\n\\t{\\n\\t\\tans=(ans*i)%MOD;\\n\\t}\\t\\t\\t\\n\\treturn ans;\\n}\\n\\nLL combi(LL a,LL b)\\n{\\n\\tLL ret=1;\\n\\tfor(LL i=1;i<=b;i++)\\n\\t{\\n\\t\\tret=(((ret*(a+1-i))%MOD)*inv(i))%MOD;\\n\\t}\\n\\treturn ret;\\n}\\nint po[1001001];\\nsigned main(){\\n  rep(i,1001001){\\n    if(i==0)po[i]=1;\\n    else po[i]=prod(i,po[i-1]);\\n  }\\n  int q;cin>>q;\\n  rep(i,q){\\n    int ans=1;\\n    int x,d,n;cin>>x>>d>>n;\\n    int y=prod(x,inv(d));\\n    if(d==0)ans=beki(x,n);\\n    else if(y==0 || y+n-1>=MOD)ans=0;\\n    else{\\n      ans=beki(d,n);\\n      int hoge=prod(po[y+n-1],inv(po[y-1]));\\n      ans=prod(ans,hoge);\\n    }\\n    cout<<ans<<endl;\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"<image>\\n\\nWilliam has an array of n integers a_1, a_2, ..., a_n. In one move he can swap two neighboring items. Two items a_i and a_j are considered neighboring if the condition |i - j| = 1 is satisfied.\\n\\nWilliam wants you to calculate the minimal number of swaps he would need to perform to make it so that the array does not contain two neighboring items with the same parity.\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 10^4). Description of the test cases follows.\\n\\nThe first line of each test case contains an integer n (1 \u2264 n \u2264 10^5) which is the total number of items in William's array.\\n\\nThe second line contains n integers a_1, a_2, ..., a_n (1 \u2264 a_i \u2264 10^9) which are William's array.\\n\\nIt is guaranteed that the sum of n over all test cases does not exceed 10^5.\\n\\nOutput\\n\\nFor each test case output the minimal number of operations needed or -1 if it is impossible to get the array to a state when no neighboring numbers have the same parity.\\n\\nExample\\n\\nInput\\n\\n\\n5\\n3\\n6 6 1\\n1\\n9\\n6\\n1 1 1 2 2 2\\n2\\n8 6\\n6\\n6 2 3 4 5 1\\n\\n\\nOutput\\n\\n\\n1\\n0\\n3\\n-1\\n2\\n\\nNote\\n\\nIn the first test case the following sequence of operations would satisfy the requirements: \\n\\n  1. swap(2, 3). Array after performing the operation: [6, 1, 6] \\n\\n\\n\\nIn the second test case the array initially does not contain two neighboring items of the same parity.\\n\\nIn the third test case the following sequence of operations would satisfy the requirements: \\n\\n  1. swap(3, 4). Array after performing the operation: [1, 1, 2, 1, 2, 2] \\n  2. swap(2, 3). Array after performing the operation: [1, 2, 1, 1, 2, 2] \\n  3. swap(4, 5). Array after performing the operation: [1, 2, 1, 2, 1, 2] \\n\\n\\n\\nIn the fourth test case it is impossible to satisfy the requirements.\\n\\nIn the fifth test case the following sequence of operations would satisfy the requirements: \\n\\n  1. swap(2, 3). Array after performing the operation: [6, 3, 2, 4, 5, 1] \\n  2. swap(4, 5). Array after performing the operation: [6, 3, 2, 5, 4, 1] \\nSolve the task in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nstruct hash_pair {\\n  template <class T1, class T2>\\n  size_t operator()(const pair<T1, T2> &p) const {\\n    auto hash1 = hash<T1>{}(p.first);\\n    auto hash2 = hash<T2>{}(p.second);\\n    return hash1 ^ hash2;\\n  }\\n};\\nlong long int n, m;\\nvector<long long int> adj[1];\\nbool visited[1];\\nlong long int start[1];\\nlong long int end[1];\\nlong long int parent[1];\\nlong long int level[1];\\nvector<long long int> dfs_order;\\nvoid dfs(long long int node) {\\n  visited[node] = true;\\n  for (long long int next : adj[node]) {\\n    if (!visited[next]) {\\n      parent[next] = node;\\n      level[next] = level[node] + 1;\\n      dfs(next);\\n    }\\n  }\\n}\\nlong long int dist[1];\\nvoid bfs(long long int start) {\\n  memset(dist, -1, sizeof dist);\\n  queue<long long int> q;\\n  dist[start] = 0;\\n  q.push(start);\\n  while (!q.empty()) {\\n    long long int v = q.front();\\n    q.pop();\\n    for (long long int e : adj[v]) {\\n      if (dist[e] == -1) {\\n        dist[e] = dist[v] + 1;\\n        q.push(e);\\n      }\\n    }\\n  }\\n}\\nlong long int lift(long long int a, long long int dist,\\n                   vector<vector<long long int>> &up) {\\n  for (long long int i = 0; i < 20; i++) {\\n    if (dist & (1 << i)) {\\n      a = up[a][i];\\n    }\\n  }\\n  return a;\\n}\\nvoid preprocesslift(vector<vector<long long int>> &up) {\\n  for (long long int j = 1; j < 20; j++) {\\n    for (long long int i = 1; i <= n; i++) {\\n      if (up[i][j - 1] != -1) {\\n        up[i][j] = up[up[i][j - 1]][j - 1];\\n      }\\n    }\\n  }\\n}\\nint32_t main() {\\n  ios_base::sync_with_stdio(false);\\n  cin.tie(NULL);\\n  long long int t;\\n  cin >> t;\\n  while (t > 0) {\\n    long long int n;\\n    cin >> n;\\n    long long int a[n];\\n    long long int ans1 = 0;\\n    queue<long long int> even;\\n    queue<long long int> odd;\\n    for (long long int i = 0; i < n; i++) {\\n      cin >> a[i];\\n      if (a[i] % 2 == 0)\\n        even.push(i);\\n      else\\n        odd.push(i);\\n    }\\n    long long int x = odd.size();\\n    long long int y = even.size();\\n    if (abs(x - y) > 1)\\n      cout << -1;\\n    else {\\n      long long int...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in JAVA?\\nPolycarp has a string s. Polycarp performs the following actions until the string s is empty (t is initially an empty string):\\n\\n  * he adds to the right to the string t the string s, i.e. he does t = t + s, where t + s is a concatenation of the strings t and s; \\n  * he selects an arbitrary letter of s and removes from s all its occurrences (the selected letter must occur in the string s at the moment of performing this action). \\n\\n\\n\\nPolycarp performs this sequence of actions strictly in this order.\\n\\nNote that after Polycarp finishes the actions, the string s will be empty and the string t will be equal to some value (that is undefined and depends on the order of removing).\\n\\nE.g. consider s=\\\"abacaba\\\" so the actions may be performed as follows:\\n\\n  * t=\\\"abacaba\\\", the letter 'b' is selected, then s=\\\"aacaa\\\"; \\n  * t=\\\"abacabaaacaa\\\", the letter 'a' is selected, then s=\\\"c\\\"; \\n  * t=\\\"abacabaaacaac\\\", the letter 'c' is selected, then s=\\\"\\\" (the empty string). \\n\\n\\n\\nYou need to restore the initial value of the string s using only the final value of t and find the order of removing letters from s.\\n\\nInput\\n\\nThe first line contains one integer T (1 \u2264 T \u2264 10^4) \u2014 the number of test cases. Then T test cases follow.\\n\\nEach test case contains one string t consisting of lowercase letters of the Latin alphabet. The length of t doesn't exceed 5 \u22c5 10^5. The sum of lengths of all strings t in the test cases doesn't exceed 5 \u22c5 10^5.\\n\\nOutput\\n\\nFor each test case output in a separate line:\\n\\n  * -1, if the answer doesn't exist; \\n  * two strings separated by spaces. The first one must contain a possible initial value of s. The second one must contain a sequence of letters \u2014 it's in what order one needs to remove letters from s to make the string t. E.g. if the string \\\"bac\\\" is outputted, then, first, all occurrences of the letter 'b' were deleted, then all occurrences of 'a', and then, finally, all occurrences of 'c'. If there are multiple solutions, print any one....\",\"targets\":\"import java.io.OutputStream;\\nimport java.io.IOException;\\nimport java.io.InputStream;\\nimport java.io.OutputStream;\\nimport java.io.PrintWriter;\\nimport java.io.BufferedWriter;\\nimport java.io.IOException;\\nimport java.io.InputStreamReader;\\nimport java.util.ArrayList;\\nimport java.util.HashSet;\\nimport java.util.StringTokenizer;\\nimport java.io.Writer;\\nimport java.io.OutputStreamWriter;\\nimport java.io.BufferedReader;\\nimport java.util.Collections;\\nimport java.io.InputStream;\\n\\n\\/**\\n * Built using CHelper plug-in\\n * Actual solution is at the top\\n *\\/\\npublic class Main {\\n    public static void main(String[] args) {\\n        InputStream inputStream = System.in;\\n        OutputStream outputStream = System.out;\\n        InputReader in = new InputReader(inputStream);\\n        OutputWriter out = new OutputWriter(outputStream);\\n        EPolycarpAndStringTransformation solver = new EPolycarpAndStringTransformation();\\n        int testCount = Integer.parseInt(in.next());\\n        for (int i = 1; i <= testCount; i++)\\n            solver.solve(i, in, out);\\n        out.close();\\n    }\\n\\n    static class EPolycarpAndStringTransformation {\\n        static String s;\\n        static int n;\\n\\n        public void solve(int testNumber, InputReader in, OutputWriter out) {\\n            s = in.next();\\n            n = s.length();\\n            ArrayList<Integer> order = new ArrayList<>();\\n            HashSet<Character> set = new HashSet<>();\\n            for (int i = n - 1; i >= 0; i--) {\\n                if (set.contains(s.charAt(i))) continue;\\n                order.add(i);\\n                set.add(s.charAt(i));\\n            }\\n            Collections.reverse(order);\\n            if (order.size() == 1) {\\n                out.println(s + \\\" \\\" + s.charAt(0));\\n                return;\\n            }\\n            int[] pref = new int[26];\\n            for (int i = 0; i < order.get(0); i++) {\\n                pref[s.charAt(i) - 'a']++;\\n            }\\n            boolean found = false;\\n            int sum = 0;\\n            int ind = -1;\\n            for (int i = order.get(0); i <...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in CPP?\\nA little girl loves problems on bitwise operations very much. Here's one of them.\\n\\nYou are given two integers l and r. Let's consider the values of <image> for all pairs of integers a and b (l \u2264 a \u2264 b \u2264 r). Your task is to find the maximum value among all considered ones.\\n\\nExpression <image> means applying bitwise excluding or operation to integers x and y. The given operation exists in all modern programming languages, for example, in languages C++ and Java it is represented as \\\"^\\\", in Pascal \u2014 as \\\"xor\\\".\\n\\nInput\\n\\nThe single line contains space-separated integers l and r (1 \u2264 l \u2264 r \u2264 1018).\\n\\nPlease, do not use the %lld specifier to read or write 64-bit integers in C++. It is preferred to use the cin, cout streams or the %I64d specifier.\\n\\nOutput\\n\\nIn a single line print a single integer \u2014 the maximum value of <image> for all pairs of integers a, b (l \u2264 a \u2264 b \u2264 r).\\n\\nExamples\\n\\nInput\\n\\n1 2\\n\\n\\nOutput\\n\\n3\\n\\n\\nInput\\n\\n8 16\\n\\n\\nOutput\\n\\n31\\n\\n\\nInput\\n\\n1 1\\n\\n\\nOutput\\n\\n0\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint main() {\\n  long long L, R, x, res;\\n  while (cin >> L >> R) {\\n    x = -1;\\n    for (long long i = 63; i >= 0; --i) {\\n      if ((L & (1LL << i)) ^ (R & (1LL << i))) {\\n        x = i;\\n        break;\\n      }\\n    }\\n    res = 0;\\n    for (long long i = x; i >= 0; --i) {\\n      res |= (1LL << i);\\n    }\\n    cout << res << endl;\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"A tree is a connected graph without cycles. A rooted tree has a special vertex called the root. The parent of a vertex v (different from root) is the previous to v vertex on the shortest path from the root to the vertex v. Children of the vertex v are all vertices for which v is the parent.\\n\\nA vertex is a leaf if it has no children. We call a vertex a bud, if the following three conditions are satisfied: \\n\\n  * it is not a root, \\n  * it has at least one child, and \\n  * all its children are leaves. \\n\\n\\n\\nYou are given a rooted tree with n vertices. The vertex 1 is the root. In one operation you can choose any bud with all its children (they are leaves) and re-hang them to any other vertex of the tree. By doing that you delete the edge connecting the bud and its parent and add an edge between the bud and the chosen vertex of the tree. The chosen vertex cannot be the bud itself or any of its children. All children of the bud stay connected to the bud.\\n\\nWhat is the minimum number of leaves it is possible to get if you can make any number of the above-mentioned operations (possibly zero)?\\n\\nInput\\n\\nThe input consists of multiple test cases. The first line contains a single integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases. Description of the test cases follows.\\n\\nThe first line of each test case contains a single integer n (2 \u2264 n \u2264 2 \u22c5 10^5) \u2014 the number of the vertices in the given tree.\\n\\nEach of the next n-1 lines contains two integers u and v (1 \u2264 u, v \u2264 n, u \u2260 v) meaning that there is an edge between vertices u and v in the tree.\\n\\nIt is guaranteed that the given graph is a tree.\\n\\nIt is guaranteed that the sum of n over all test cases doesn't exceed 2 \u22c5 10^5.\\n\\nOutput\\n\\nFor each test case print a single integer \u2014 the minimal number of leaves that is possible to get after some operations.\\n\\nExample\\n\\nInput\\n\\n\\n5\\n7\\n1 2\\n1 3\\n1 4\\n2 5\\n2 6\\n4 7\\n6\\n1 2\\n1 3\\n2 4\\n2 5\\n3 6\\n2\\n1 2\\n7\\n7 3\\n1 5\\n1 3\\n4 6\\n4 7\\n2 1\\n6\\n2 1\\n2 3\\n4 5\\n3 4\\n3 6\\n\\n\\nOutput\\n\\n\\n2\\n2\\n1\\n2\\n1\\n\\nNote\\n\\nIn the first test case the tree looks as follows:\\n\\n<image>\\n\\nFirstly you can choose...\\nThe above is tricky. Write me a correct solution in JAVA.\",\"targets\":\"import java.io.OutputStream;\\nimport java.io.IOException;\\nimport java.io.InputStream;\\nimport java.io.OutputStream;\\nimport java.io.PrintWriter;\\nimport java.io.BufferedWriter;\\nimport java.util.InputMismatchException;\\nimport java.util.HashMap;\\nimport java.io.IOException;\\nimport java.io.Writer;\\nimport java.io.OutputStreamWriter;\\nimport java.io.InputStream;\\n\\n\\/**\\n * Built using CHelper plug-in\\n * Actual solution is at the top\\n *\\/\\npublic class Main {\\n    public static void main(String[] args) {\\n        InputStream inputStream = System.in;\\n        OutputStream outputStream = System.out;\\n        InputReader in = new InputReader(inputStream);\\n        OutputWriter out = new OutputWriter(outputStream);\\n        EBudsReHanging solver = new EBudsReHanging();\\n        solver.solve(1, in, out);\\n        out.close();\\n    }\\n\\n    static class EBudsReHanging {\\n        public void solve(int testNumber, InputReader in, OutputWriter out) {\\n            int tc = in.nextInt();\\n            for (; tc > 0; tc--) {\\n                int size = in.nextInt();\\n                UndirectedTree t = new UndirectedTree(size);\\n                for (int i = 0; i < size - 1; i++) {\\n                    int a = in.nextInt();\\n                    int b = in.nextInt();\\n                    t.addEdge(a, b);\\n                }\\n\\n                out.println(maxNumLeaf(t, 1, -1).first);\\n            }\\n\\n        }\\n\\n        EzIntIntPair maxNumLeaf(UndirectedTree t, int me, int parent) {\\n            var n = t.getNode(me);\\n            if (n.edges.size() == 1 && me != 1) {\\n                return new EzIntIntPair(1, 1);\\n            }\\n\\n            int numLeafs = 0;\\n            int maxDepth = 0;\\n            int evens = 0;\\n            int odds = 0;\\n            for (int e : n.edges.keySet()) {\\n                if (e != parent) {\\n                    var p = maxNumLeaf(t, e, me);\\n                    numLeafs += p.first;\\n                    maxDepth = Math.max(maxDepth, p.second);\\n                    if (p.second % 2 == 0) {\\n                        evens++;\\n                    } else...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"There are n candles on a Hanukkah menorah, and some of its candles are initially lit. We can describe which candles are lit with a binary string s, where the i-th candle is lit if and only if s_i=1.\\n\\n<image>\\n\\nInitially, the candle lights are described by a string a. In an operation, you select a candle that is currently lit. By doing so, the candle you selected will remain lit, and every other candle will change (if it was lit, it will become unlit and if it was unlit, it will become lit).\\n\\nYou would like to make the candles look the same as string b. Your task is to determine if it is possible, and if it is, find the minimum number of operations required.\\n\\nInput\\n\\nThe first line contains an integer t (1\u2264 t\u2264 10^4) \u2014 the number of test cases. Then t cases follow.\\n\\nThe first line of each test case contains a single integer n (1\u2264 n\u2264 10^5) \u2014 the number of candles.\\n\\nThe second line contains a string a of length n consisting of symbols 0 and 1 \u2014 the initial pattern of lights.\\n\\nThe third line contains a string b of length n consisting of symbols 0 and 1 \u2014 the desired pattern of lights.\\n\\nIt is guaranteed that the sum of n does not exceed 10^5.\\n\\nOutput\\n\\nFor each test case, output the minimum number of operations required to transform a to b, or -1 if it's impossible.\\n\\nExample\\n\\nInput\\n\\n\\n5\\n5\\n11010\\n11010\\n2\\n01\\n11\\n3\\n000\\n101\\n9\\n100010111\\n101101100\\n9\\n001011011\\n011010101\\n\\n\\nOutput\\n\\n\\n0\\n1\\n-1\\n3\\n4\\n\\nNote\\n\\nIn the first test case, the two strings are already equal, so we don't have to perform any operations.\\n\\nIn the second test case, we can perform a single operation selecting the second candle to transform 01 into 11.\\n\\nIn the third test case, it's impossible to perform any operations because there are no lit candles to select.\\n\\nIn the fourth test case, we can perform the following operations to transform a into b: \\n\\n  1. Select the 7-th candle: 100010{\\\\color{red}1}11\u2192 011101{\\\\color{red} 1}00. \\n  2. Select the 2-nd candle: 0{\\\\color{red} 1}1101100\u2192 1{\\\\color{red} 1}0010011. \\n  3. Select the 1-st candle: {\\\\color{red}1}10010011\u2192...\\nThe above is tricky. Write me a correct solution in PYTHON3.\",\"targets\":\"import os\\nimport sys\\nfrom io import BytesIO, IOBase\\n\\nfrom collections import defaultdict, Counter\\nfrom typing import AsyncIterator\\n\\ninput = lambda: sys.stdin.readline().rstrip(\\\"\\\\r\\\\n\\\")\\nimport math\\n\\ndef I():\\n    return(int(input()))\\ndef lint():\\n    return(list(map(int,input().split())))\\ndef insr():\\n    s = input().strip()\\n    return(list(s[:len(s)]))\\ndef invr():\\n    return(map(int,input().split()))\\n# Python program to print all\\n# primes smaller than or equal to\\n# n using Sieve of Eratosthenes\\n\\nimport heapq\\n\\ndef ask(a,b,c):\\n    print(f\\\"? {a} {b} {c}\\\")\\n    sys.stdout.flush()\\n    res=int(input())\\n    sys.stdout.flush()\\n    return res\\n\\n\\n\\n# t=  I()\\n# for _ in range(t):\\n#     l,r=lint()\\n#     tmp=int(math.log(r,2))\\n#     tmp=2**tmp\\n#     ans=0\\n  \\n#     ans=max(ans,max(r-tmp+1,tmp-max(tmp\\/\\/2,l)))\\n    \\n#     if l%2==0:\\n#         ans=max(ans,(r-l+1)\\/\\/2)\\n#     else:\\n#         ans=max(ans,(r-l+2)\\/\\/2)\\n#     print((r-l+1)-ans)\\n\\nt=  I()\\nfor _ in range(t):\\n    n=I()\\n    a=list(map(int,input().strip()))\\n    b=list(map(int,input().strip()))\\n    # print(a,b)\\n    if a==b:\\n        print(0)\\n        continue\\n    o,e,o2,e2=0,0,0,0\\n    for i in range(n):\\n        if a[i]!=b[i]:\\n\\n            if a[i]==1:\\n                o+=1\\n            else:\\n                e+=1\\n        else:\\n            if a[i]==1:\\n                o2+=1\\n            else:\\n                e2+=1\\n   \\n    ans=-1\\n    if o==e:\\n        ans=o+e\\n    if o2-e2==1:\\n      \\n        if ans==-1:\\n            ans=o2+e2\\n        else:\\n            ans=min(o2+e2,ans)\\n    print(ans)\",\"language\":\"python\",\"split\":\"test\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"When you play the game of thrones, you win, or you die. There is no middle ground.\\n\\nCersei Lannister, A Game of Thrones by George R. R. Martin\\n\\nThere are n nobles, numbered from 1 to n. Noble i has a power of i. There are also m \\\"friendships\\\". A friendship between nobles a and b is always mutual.\\n\\nA noble is defined to be vulnerable if both of the following conditions are satisfied: \\n\\n  * the noble has at least one friend, and \\n  * all of that noble's friends have a higher power. \\n\\n\\n\\nYou will have to process the following three types of queries. \\n\\n  1. Add a friendship between nobles u and v. \\n  2. Remove a friendship between nobles u and v. \\n  3. Calculate the answer to the following process. \\n\\n\\n\\nThe process: all vulnerable nobles are simultaneously killed, and all their friendships end. Then, it is possible that new nobles become vulnerable. The process repeats itself until no nobles are vulnerable. It can be proven that the process will end in finite time. After the process is complete, you need to calculate the number of remaining nobles.\\n\\nNote that the results of the process are not carried over between queries, that is, every process starts with all nobles being alive!\\n\\nInput\\n\\nThe first line contains the integers n and m (1 \u2264 n \u2264 2\u22c5 10^5, 0 \u2264 m \u2264 2\u22c5 10^5) \u2014 the number of nobles and number of original friendships respectively.\\n\\nThe next m lines each contain the integers u and v (1 \u2264 u,v \u2264 n, u \u2260 v), describing a friendship. No friendship is listed twice.\\n\\nThe next line contains the integer q (1 \u2264 q \u2264 2\u22c5 {10}^{5}) \u2014 the number of queries. \\n\\nThe next q lines contain the queries themselves, each query has one of the following three formats. \\n\\n  * 1 u v (1 \u2264 u,v \u2264 n, u \u2260 v) \u2014 add a friendship between u and v. It is guaranteed that u and v are not friends at this moment. \\n  * 2 u v (1 \u2264 u,v \u2264 n, u \u2260 v) \u2014 remove a friendship between u and v. It is guaranteed that u and v are friends at this moment. \\n  * 3 \u2014 print the answer to the process described in the statement. \\n\\nOutput\\n\\nFor each type 3 query print one...\\nThe above is tricky. Write me a correct solution in JAVA.\",\"targets\":\"import java.io.*;\\nimport java.util.*;\\n\\npublic final class Main {\\n\\n    static PrintWriter out = new PrintWriter(System.out);\\n    static FastReader in = new FastReader();\\n    static Pair[] moves = new Pair[]{new Pair(-1, 0), new Pair(1, 0), new Pair(0, -1), new Pair(0, 1)};\\n\\n    public static void main(String[] args) {\\n        int tt = 1;\\n        int mod = 998244353;\\n\\n        loop:\\n        while (tt-- > 0) {\\n            int n = i();\\n            int m = i();\\n\\n            TreeSet<Integer>[] pq = new TreeSet[n];\\n            for (int i = 0; i < n; i++) {\\n                pq[i] = new TreeSet<>();\\n            }\\n            while (m-- > 0) {\\n                int u = i() - 1;\\n                int v = i() - 1;\\n                pq[u].add(v);\\n                pq[v].add(u);\\n            }\\n\\n            int cnt = 0;\\n            for (int i = 0; i < n; i++) {\\n                if (qualified(pq, i)) {\\n                    cnt++;\\n                }\\n            }\\n\\n            int q = i();\\n            while (q-- > 0) {\\n                int t = i();\\n                if (t == 1) {\\n                    int u = i() - 1;\\n                    int v = i() - 1;\\n                    int diff = 0;\\n                    if (qualified(pq, u)) {\\n                        diff++;\\n                    }\\n                    if (qualified(pq, v)) {\\n                        diff++;\\n                    }\\n                    pq[u].add(v);\\n                    pq[v].add(u);\\n                    if (qualified(pq, u)) {\\n                        diff--;\\n                    }\\n                    if (qualified(pq, v)) {\\n                        diff--;\\n                    }\\n                    cnt -= diff;\\n                } else if (t == 2) {\\n                    int u = i() - 1;\\n                    int v = i() - 1;\\n                    int diff = 0;\\n                    if (qualified(pq, u)) {\\n                        diff++;\\n                    }\\n                    if (qualified(pq, v)) {\\n                        diff++;\\n                    }\\n                    pq[u].remove(v);\\n   ...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in CPP?\\nTwo players, Red and Blue, are at it again, and this time they're playing with crayons! The mischievous duo is now vandalizing a rooted tree, by coloring the nodes while playing their favorite game.\\n\\nThe game works as follows: there is a tree of size n, rooted at node 1, where each node is initially white. Red and Blue get one turn each. Red goes first. \\n\\nIn Red's turn, he can do the following operation any number of times: \\n\\n  * Pick any subtree of the rooted tree, and color every node in the subtree red. \\n\\nHowever, to make the game fair, Red is only allowed to color k nodes of the tree. In other words, after Red's turn, at most k of the nodes can be colored red.\\n\\nThen, it's Blue's turn. Blue can do the following operation any number of times: \\n\\n  * Pick any subtree of the rooted tree, and color every node in the subtree blue. However, he's not allowed to choose a subtree that contains a node already colored red, as that would make the node purple and no one likes purple crayon. \\n\\nNote: there's no restriction on the number of nodes Blue can color, as long as he doesn't color a node that Red has already colored.\\n\\nAfter the two turns, the score of the game is determined as follows: let w be the number of white nodes, r be the number of red nodes, and b be the number of blue nodes. The score of the game is w \u22c5 (r - b).\\n\\nRed wants to maximize this score, and Blue wants to minimize it. If both players play optimally, what will the final score of the game be?\\n\\nInput\\n\\nThe first line contains two integers n and k (2 \u2264 n \u2264 2 \u22c5 10^5; 1 \u2264 k \u2264 n) \u2014 the number of vertices in the tree and the maximum number of red nodes.\\n\\nNext n - 1 lines contains description of edges. The i-th line contains two space separated integers u_i and v_i (1 \u2264 u_i, v_i \u2264 n; u_i \u2260 v_i) \u2014 the i-th edge of the tree.\\n\\nIt's guaranteed that given edges form a tree.\\n\\nOutput\\n\\nPrint one integer \u2014 the resulting score if both Red and Blue play optimally.\\n\\nExamples\\n\\nInput\\n\\n\\n4 2\\n1 2\\n1 3\\n1 4\\n\\n\\nOutput\\n\\n\\n1\\n\\n\\nInput\\n\\n\\n5 2\\n1 2\\n2 3\\n3 4\\n4 5\\n\\n\\nOutput\\n\\n\\n6\\n\\n\\nInput\\n\\n\\n7...\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst int N = 200005;\\nint n, k;\\nvector<int> to[N];\\nint top[N], h[N], son[N];\\nint st[N], s;\\nvoid dfs1(int i, int fa) {\\n  for (int j : to[i]) {\\n    if (j == fa) continue;\\n    dfs1(j, i);\\n    if (h[i] < h[j]) h[i] = h[j], son[i] = j;\\n  }\\n  h[i]++;\\n}\\nvoid dfs2(int i, int len, int fa) {\\n  if (!son[i]) {\\n    st[++s] = len;\\n    return;\\n  }\\n  dfs2(son[i], len + 1, i);\\n  for (int j : to[i])\\n    if (j != fa && j != son[i]) dfs2(j, 1, i);\\n}\\nint main() {\\n  ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);\\n  cin >> n >> k;\\n  for (int i = 1; i < n; i++) {\\n    int x, y;\\n    cin >> x >> y;\\n    to[x].push_back(y), to[y].push_back(x);\\n  }\\n  dfs1(1, 0), dfs2(1, 1, 0);\\n  sort(st + 1, st + s + 1, greater<int>());\\n  if (s > k) {\\n    long long ans = -(1ll << 60);\\n    for (int i = 1, t = 0; i <= k; i++) {\\n      t += st[i];\\n      int lim = n - t, w = n - i;\\n      int tp = n \\/ 2;\\n      if (lim >= tp)\\n        ans = max(ans, 1ll * (w - tp) * (i - tp));\\n      else\\n        ans = max(ans, 1ll * (w - lim) * (i - lim));\\n    }\\n    cout << ans;\\n    return 0;\\n  }\\n  long long ans = 0;\\n  for (int i = s; i <= k; i++) ans = max(ans, 1ll * i * (n - i));\\n  cout << ans;\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You are given an array consisting of all integers from [l, r] inclusive. For example, if l = 2 and r = 5, the array would be [2, 3, 4, 5]. What's the minimum number of elements you can delete to make the [bitwise AND](https:\\/\\/en.wikipedia.org\\/wiki\\/Bitwise_operation#AND) of the array non-zero?\\n\\nA bitwise AND is a binary operation that takes two equal-length binary representations and performs the AND operation on each pair of the corresponding bits.\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases. Then t cases follow.\\n\\nThe first line of each test case contains two integers l and r (1 \u2264 l \u2264 r \u2264 2 \u22c5 10^5) \u2014 the description of the array.\\n\\nOutput\\n\\nFor each test case, output a single integer \u2014 the answer to the problem.\\n\\nExample\\n\\nInput\\n\\n\\n5\\n1 2\\n2 8\\n4 5\\n1 5\\n100000 200000\\n\\n\\nOutput\\n\\n\\n1\\n3\\n0\\n2\\n31072\\n\\nNote\\n\\nIn the first test case, the array is [1, 2]. Currently, the bitwise AND is 0, as 1\\\\ \\\\& \\\\ 2 = 0. However, after deleting 1 (or 2), the array becomes [2] (or [1]), and the bitwise AND becomes 2 (or 1). This can be proven to be the optimal, so the answer is 1.\\n\\nIn the second test case, the array is [2, 3, 4, 5, 6, 7, 8]. Currently, the bitwise AND is 0. However, after deleting 4, 5, and 8, the array becomes [2, 3, 6, 7], and the bitwise AND becomes 2. This can be proven to be the optimal, so the answer is 3. Note that there may be other ways to delete 3 elements.\\nUsing cpp can you solve the prior task?\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst int N = 2e5 + 5;\\nint cnt[N][30];\\nint main() {\\n  ios_base::sync_with_stdio(false);\\n  cin.tie(0);\\n  cout.tie(0);\\n  for (int i = 1; i < N; ++i) {\\n    for (int j = 0; j < 30; ++j) {\\n      cnt[i][j] = cnt[i - 1][j];\\n      if (i & (1 << j)) cnt[i][j]++;\\n    }\\n  }\\n  int ttt;\\n  cin >> ttt;\\n  while (ttt--) {\\n    int l, r;\\n    cin >> l >> r;\\n    int mx = 0;\\n    for (int j = 0; j < 30; ++j) {\\n      mx = max(mx, cnt[r][j] - cnt[l - 1][j]);\\n    }\\n    cout << r - l + 1 - mx << '\\\\n';\\n  }\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You are given two arrays of integers a_1, a_2, \u2026, a_n and b_1, b_2, \u2026, b_m.\\n\\nYou need to insert all elements of b into a in an arbitrary way. As a result you will get an array c_1, c_2, \u2026, c_{n+m} of size n + m.\\n\\nNote that you are not allowed to change the order of elements in a, while you can insert elements of b at arbitrary positions. They can be inserted at the beginning, between any elements of a, or at the end. Moreover, elements of b can appear in the resulting array in any order.\\n\\nWhat is the minimum possible number of inversions in the resulting array c? Recall that an inversion is a pair of indices (i, j) such that i < j and c_i > c_j.\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 10^4). Description of the test cases follows.\\n\\nThe first line of each test case contains two integers n and m (1 \u2264 n, m \u2264 10^6).\\n\\nThe second line of each test case contains n integers a_1, a_2, \u2026, a_n (1 \u2264 a_i \u2264 10^9).\\n\\nThe third line of each test case contains m integers b_1, b_2, \u2026, b_m (1 \u2264 b_i \u2264 10^9).\\n\\nIt is guaranteed that the sum of n for all tests cases in one input doesn't exceed 10^6. The sum of m for all tests cases doesn't exceed 10^6 as well.\\n\\nOutput\\n\\nFor each test case, print one integer \u2014 the minimum possible number of inversions in the resulting array c.\\n\\nExample\\n\\nInput\\n\\n\\n3\\n3 4\\n1 2 3\\n4 3 2 1\\n3 3\\n3 2 1\\n1 2 3\\n5 4\\n1 3 5 3 1\\n4 3 6 1\\n\\n\\nOutput\\n\\n\\n0\\n4\\n6\\n\\nNote\\n\\nBelow is given the solution to get the optimal answer for each of the example test cases (elements of a are underscored).\\n\\n  * In the first test case, c = [\\\\underline{1}, 1, \\\\underline{2}, 2, \\\\underline{3}, 3, 4]. \\n  * In the second test case, c = [1, 2, \\\\underline{3}, \\\\underline{2}, \\\\underline{1}, 3]. \\n  * In the third test case, c = [\\\\underline{1}, 1, 3, \\\\underline{3}, \\\\underline{5}, \\\\underline{3}, \\\\underline{1}, 4, 6]. \\n#incl\",\"targets\":\"ude <bits\\/stdc++.h>\\nusing namespace std;\\nconst double pi = 3.14159265358979323846, eps = 1e-9;\\nconst long long M = 1e9 + 7, I = 1e18;\\nconst int mxn = 1e6, mxn1 = 2e6, lg = 20;\\nint t, n, m, a[mxn], b[mxn], sml[mxn + 1], smr[mxn + 1], tree[mxn1 * 4],\\n    pos[mxn];\\nvector<int> v;\\nunordered_map<int, int> mp;\\nvoid build(int v, int l, int r) {\\n  if (r - l == 1) {\\n    tree[v] = 0;\\n    return;\\n  }\\n  build(v * 2 + 1, l, (r + l) \\/ 2);\\n  build(v * 2 + 2, (r + l) \\/ 2, r);\\n  tree[v] = 0;\\n}\\nvoid upd(int v, int l, int r, int pos) {\\n  if (l > pos or r <= pos) return;\\n  if (r - l == 1) {\\n    tree[v]++;\\n    return;\\n  }\\n  upd(v * 2 + 1, l, (r + l) \\/ 2, pos);\\n  upd(v * 2 + 2, (r + l) \\/ 2, r, pos);\\n  tree[v] = tree[v * 2 + 1] + tree[v * 2 + 2];\\n}\\nint get(int v, int l, int r, int ql, int qr) {\\n  if (l >= qr or r <= ql) return 0;\\n  if (l >= ql and r <= qr) return tree[v];\\n  return get(v * 2 + 1, l, (r + l) \\/ 2, ql, qr) +\\n         get(v * 2 + 2, (r + l) \\/ 2, r, ql, qr);\\n}\\nvoid f(int al, int ar, int bl, int br) {\\n  if (bl == br) return;\\n  int cur = b[(bl + br) \\/ 2], ind = -1, mn = M, curl = -1, curr = -1;\\n  sml[al] = 0;\\n  for (int i = al + 1; i <= ar; i++) {\\n    sml[i] = sml[i - 1];\\n    if (a[i - 1] > cur) sml[i]++;\\n  }\\n  smr[ar] = 0;\\n  for (int i = ar - 1; i >= al; i--) {\\n    smr[i] = smr[i + 1];\\n    if (cur > a[i]) smr[i]++;\\n  }\\n  for (int i = al; i <= ar; i++) {\\n    if (smr[i] + sml[i] < mn) {\\n      mn = smr[i] + sml[i];\\n      curl = sml[i];\\n      curr = smr[i];\\n      ind = i;\\n    }\\n  }\\n  pos[(bl + br) \\/ 2] = ind;\\n  f(al, ind, bl, (bl + br) \\/ 2);\\n  f(ind, ar, (bl + br) \\/ 2 + 1, br);\\n}\\nvoid solve() {\\n  v.clear();\\n  mp.clear();\\n  cin >> n >> m;\\n  for (int i = 0; i < n; i++) {\\n    cin >> a[i];\\n    v.push_back(a[i]);\\n  }\\n  for (int i = 0; i < m; i++) {\\n    cin >> b[i];\\n    v.push_back(b[i]);\\n  }\\n  sort(v.begin(), v.end());\\n  int ln = (int)(unique(v.begin(), v.end()) - v.begin());\\n  for (int i = 0; i < ln; i++) {\\n    mp[v[i]] = i;\\n  }\\n  for (int i = 0; i < n; i++) a[i] = mp[a[i]];\\n  for (int i = 0; i < m; i++) b[i] = mp[b[i]];\\n ...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Grandma Capa has decided to knit a scarf and asked Grandpa Sher to make a pattern for it, a pattern is a string consisting of lowercase English letters. Grandpa Sher wrote a string s of length n.\\n\\nGrandma Capa wants to knit a beautiful scarf, and in her opinion, a beautiful scarf can only be knit from a string that is a palindrome. She wants to change the pattern written by Grandpa Sher, but to avoid offending him, she will choose one lowercase English letter and erase some (at her choice, possibly none or all) occurrences of that letter in string s.\\n\\nShe also wants to minimize the number of erased symbols from the pattern. Please help her and find the minimum number of symbols she can erase to make string s a palindrome, or tell her that it's impossible. Notice that she can only erase symbols equal to the one letter she chose.\\n\\nA string is a palindrome if it is the same from the left to the right and from the right to the left. For example, the strings 'kek', 'abacaba', 'r' and 'papicipap' are palindromes, while the strings 'abb' and 'iq' are not.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 100) \u2014 the number of test cases. The next 2 \u22c5 t lines contain the description of test cases. The description of each test case consists of two lines.\\n\\nThe first line of each test case contains a single integer n (1 \u2264 n \u2264 10^5) \u2014 the length of the string.\\n\\nThe second line of each test case contains the string s consisting of n lowercase English letters.\\n\\nIt is guaranteed that the sum of n over all test cases does not exceed 2 \u22c5 10^5.\\n\\nOutput\\n\\nFor each test case print the minimum number of erased symbols required to make the string a palindrome, if it is possible, and -1, if it is impossible.\\n\\nExample\\n\\nInput\\n\\n\\n5\\n8\\nabcaacab\\n6\\nxyzxyz\\n4\\nabba\\n8\\nrprarlap\\n10\\nkhyyhhyhky\\n\\n\\nOutput\\n\\n\\n2\\n-1\\n0\\n3\\n2\\n\\nNote\\n\\nIn the first test case, you can choose a letter 'a' and erase its first and last occurrences, you will get a string 'bcaacb', which is a palindrome. You can also choose a letter 'b' and erase all its occurrences, you...\\n\\/**\",\"targets\":\"* check out my youtube channel sh0rkyboy\\n * https:\\/\\/tinyurl.com\\/zdxe2y4z\\n * I do screencasts, solutions, and other fun stuff in the future\\n *\\/\\n\\nimport java.util.*;\\nimport java.io.*;\\nimport static java.lang.Math.min;\\nimport static java.lang.Math.abs;\\nimport static java.lang.Math.max;\\npublic class EdA {\\n\\tstatic long[] mods = {1000000007, 998244353, 1000000009};\\n\\tstatic long mod = mods[0];\\n\\tpublic static MyScanner sc;\\n    public static PrintWriter out;\\n\\tpublic static void main(String[] largewang) throws Exception{\\n\\t\\t\\/\\/ TODO Auto-generated method stub\\n \\t\\tsc = new MyScanner();\\n \\t\\tout = new PrintWriter(System.out);\\n \\t\\tint t = sc.nextInt();\\n \\t\\twhile (t-->0) {\\n \\t\\t\\tint n = sc.nextInt();\\n \\t\\t\\tint min = Integer.MAX_VALUE;\\n \\t\\t\\tchar[] arr = sc.next().toCharArray();\\n \\t\\t\\tfor(char j = 'a';j<='z';j++){\\n \\t\\t\\t\\tArrayList<Character> val = new ArrayList<>();\\n \\t\\t\\t\\tfor(int s = 0;s<n;s++){\\n \\t\\t\\t\\t\\tif (arr[s] == j)\\n \\t\\t\\t\\t\\t\\tcontinue;\\n \\t\\t\\t\\t\\tval.add(arr[s]);\\n \\t\\t\\t\\t}boolean found = true;\\n \\t\\t\\t\\tfor(int i = 0;i<val.size();i++){\\n \\t\\t\\t\\t\\tif (!val.get(i).equals(val.get(val.size()-i-1))){\\n \\t\\t\\t\\t\\t\\tfound = false;\\n \\t\\t\\t\\t\\t\\tbreak;\\n \\t\\t\\t\\t\\t}\\n \\t\\t\\t\\t}\\n \\t\\t\\t\\tif (found){\\n \\t\\t\\t\\t\\tint[] vals = new int[val.size()+1];\\n \\t\\t\\t\\t\\tint count = 0;\\n \\t\\t\\t\\t\\tfor(int i = 0;i<n;i++){\\n \\t\\t\\t\\t\\t\\tif (arr[i] != j)\\n \\t\\t\\t\\t\\t\\t\\tcount++;\\n \\t\\t\\t\\t\\t\\telse {\\n \\t\\t\\t\\t\\t\\t\\tvals[count]++;\\n \\t\\t\\t\\t\\t\\t}\\n \\t\\t\\t\\t\\t\\t\\n \\t\\t\\t\\t\\t}\\n \\t\\t\\t\\t\\tint temp = val.size();\\n \\t\\t\\t\\t\\tfor(int i=0;i<vals.length\\/2;i++){\\n \\t\\t\\t\\t\\t\\ttemp+=2*min(vals[i], vals[vals.length-i-1]);\\n \\t\\t\\t\\t\\t}\\n \\t\\t\\t\\t\\tif (vals.length%2 == 1){\\n \\t\\t\\t\\t\\t\\ttemp += (vals[vals.length\\/2]);\\n \\t\\t\\t\\t\\t}\\n \\t\\t\\t\\t\\tmin = min(min, n-temp);\\n \\t\\t\\t\\t}\\n \\t\\t\\t\\t\\n \\t\\t\\t\\t\\n \\t\\t\\t}\\n \\t\\t\\tout.println(min == Integer.MAX_VALUE ? -1 : min);\\n \\t\\t}\\n \\t\\tout.close();\\n \\t\\t\\n \\t}\\n\\t\\n\\tpublic static void sort(int[] array){\\n\\t\\tArrayList<Integer> copy = new ArrayList<>();\\n\\t\\tfor (int i : array)\\n\\t\\t\\tcopy.add(i);\\n\\t\\tCollections.sort(copy);\\n\\t\\tfor(int i = 0;i<array.length;i++)\\n\\t\\t\\tarray[i] = copy.get(i);\\n\\t}\\n\\tstatic String[] readArrayString(int n){\\n\\t\\tString[] array = new String[n];\\n\\t\\tfor(int j =0 ;j<n;j++)\\n\\t\\t\\tarray[j] = sc.next();\\n\\t\\treturn array;\\n\\t}\\n\\tstatic int[]...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Polycarp has found a table having an infinite number of rows and columns. The rows are numbered from 1, starting from the topmost one. The columns are numbered from 1, starting from the leftmost one.\\n\\nInitially, the table hasn't been filled and Polycarp wants to fix it. He writes integers from 1 and so on to the table as follows.\\n\\n<image> The figure shows the placement of the numbers from 1 to 10. The following actions are denoted by the arrows.\\n\\nThe leftmost topmost cell of the table is filled with the number 1. Then he writes in the table all positive integers beginning from 2 sequentially using the following algorithm.\\n\\nFirst, Polycarp selects the leftmost non-filled cell in the first row and fills it. Then, while the left neighbor of the last filled cell is filled, he goes down and fills the next cell. So he goes down until the last filled cell has a non-filled neighbor to the left (look at the vertical arrow going down in the figure above).\\n\\nAfter that, he fills the cells from the right to the left until he stops at the first column (look at the horizontal row in the figure above). Then Polycarp selects the leftmost non-filled cell in the first row, goes down, and so on.\\n\\nA friend of Polycarp has a favorite number k. He wants to know which cell will contain the number. Help him to find the indices of the row and the column, such that the intersection of the row and the column is the cell containing the number k.\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 100) \u2014 the number of test cases. Then t test cases follow.\\n\\nEach test case consists of one line containing one integer k (1 \u2264 k \u2264 10^9) which location must be found.\\n\\nOutput\\n\\nFor each test case, output in a separate line two integers r and c (r, c \u2265 1) separated by spaces \u2014 the indices of the row and the column containing the cell filled by the number k, respectively.\\n\\nExample\\n\\nInput\\n\\n\\n7\\n11\\n14\\n5\\n4\\n1\\n2\\n1000000000\\n\\n\\nOutput\\n\\n\\n2 4\\n4 3\\n1 3\\n2 1\\n1 1\\n1 2\\n31623 14130\\nThe above is tricky. Write me a correct solution in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint abs(int a) { return a > 0 ? a : -a; }\\nint main() {\\n  int t;\\n  cin >> t;\\n  while (t--) {\\n    long long int sq = 1;\\n    long long int cnt = 1;\\n    long long int k;\\n    cin >> k;\\n    while (k > sq) {\\n      cnt++;\\n      sq = cnt * cnt;\\n    }\\n    int r = cnt;\\n    int c = 0;\\n    int leftOver = 0;\\n    int cdispAllowed = cnt - 1;\\n    if (cdispAllowed >= sq - k) {\\n      c = sq - k + 1;\\n    } else {\\n      c = cnt;\\n      leftOver = (sq - k) - cdispAllowed;\\n    }\\n    r -= leftOver;\\n    cout << r << \\\" \\\" << c << endl;\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"A binary heap which satisfies max-heap property is called max-heap. In a max-heap, for every node $i$ other than the root, $A[i] \\\\leq A[parent(i)]$, that is, the value of a node is at most the value of its parent. The largest element in a max-heap is stored at the root, and the subtree rooted at a node contains values no larger than that contained at the node itself.\\n\\nHere is an example of a max-heap.\\n\\n<image>\\n\\n\\nWrite a program which reads an array and constructs a max-heap from the array based on the following pseudo code.\\n\\n$maxHeapify(A, i)$ move the value of $A[i]$ down to leaves to make a sub-tree of node $i$ a max-heap. Here, $H$ is the size of the heap.\\n\\n\\n1  maxHeapify(A, i)\\n2      l = left(i)\\n3      r = right(i)\\n4      \\/\\/ select the node which has the maximum value\\n5      if l \u2264 H and A[l] > A[i]\\n6          largest = l\\n7      else\\n8          largest = i\\n9      if r \u2264 H and A[r] > A[largest]\\n10         largest = r\\n11\\n12     if largest \u2260 i\u3000\\/\\/ value of children is larger than that of i\\n13         swap A[i] and A[largest]\\n14         maxHeapify(A, largest) \\/\\/ call recursively\\n\\n\\nThe following procedure buildMaxHeap(A) makes $A$ a max-heap by performing maxHeapify in a bottom-up manner.\\n\\n\\n1 buildMaxHeap(A)\\n2    for i = H\\/2 downto 1\\n3        maxHeapify(A, i)\\n\\n\\n\\n\\nInput\\n\\nIn the first line, an integer $H$ is given. In the second line, $H$ integers which represent elements in the binary heap are given in order of node id (from $1$ to $H$).\\n\\nOutput\\n\\nPrint values of nodes in the max-heap in order of their id (from $1$ to $H$). Print a single space character before each value.\\n\\nExample\\n\\nInput\\n\\n10\\n4 1 3 2 16 9 10 14 8 7\\n\\n\\nOutput\\n\\n16 14 10 8 7 9 3 2 4 1\\\":\",\"targets\":\"#include <iostream>\\n#include <vector>\\n#include <algorithm>\\nusing namespace std;\\n\\nint h = 0;\\nconst long long nil = -2000000001;\\nvector<long long> a;\\n\\nvoid mH(vector<long long> &a, int i) {\\n\\tint lg = 0;\\n\\tint l = 2 * i + 1;\\n\\tint r = 2 * i + 2;\\n\\n\\tif (l < h && a[l] > a[i])\\n\\t\\tlg = l;\\n\\telse\\n\\t\\tlg = i;\\n\\tif (r < h && a[r] > a[lg])\\n\\t\\tlg = r;\\n\\n\\tif (lg != i) {\\n\\t\\tswap(a[i], a[lg]);\\n\\t\\tmH(a, lg);\\n\\t}\\n}\\n\\nint main()\\n{\\n\\tcin >> h;\\n\\n\\ta.assign(h, nil);\\n\\n\\tfor (int i = 0; i < h; i++)\\n\\t\\tcin >> a[i];\\n\\n\\tfor (int i = h \\/ 2 - 1; i > -1; i--)\\n\\t\\tmH(a, i);\\n\\n\\tfor (int i = 0; i < h; i++)\\n\\t\\tcout << \\\" \\\" << a[i];\\n\\tcout << endl;\\n\\n\\treturn 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Consider a simplified penalty phase at the end of a football match.\\n\\nA penalty phase consists of at most 10 kicks, the first team takes the first kick, the second team takes the second kick, then the first team takes the third kick, and so on. The team that scores more goals wins; if both teams score the same number of goals, the game results in a tie (note that it goes against the usual football rules). The penalty phase is stopped if one team has scored more goals than the other team could reach with all of its remaining kicks. For example, if after the 7-th kick the first team has scored 1 goal, and the second team has scored 3 goals, the penalty phase ends \u2014 the first team cannot reach 3 goals.\\n\\nYou know which player will be taking each kick, so you have your predictions for each of the 10 kicks. These predictions are represented by a string s consisting of 10 characters. Each character can either be 1, 0, or ?. This string represents your predictions in the following way:\\n\\n  * if s_i is 1, then the i-th kick will definitely score a goal; \\n  * if s_i is 0, then the i-th kick definitely won't score a goal; \\n  * if s_i is ?, then the i-th kick could go either way. \\n\\n\\n\\nBased on your predictions, you have to calculate the minimum possible number of kicks there can be in the penalty phase (that means, the earliest moment when the penalty phase is stopped, considering all possible ways it could go). Note that the referee doesn't take into account any predictions when deciding to stop the penalty phase \u2014 you may know that some kick will\\/won't be scored, but the referee doesn't.\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 1 000) \u2014 the number of test cases.\\n\\nEach test case is represented by one line containing the string s, consisting of exactly 10 characters. Each character is either 1, 0, or ?.\\n\\nOutput\\n\\nFor each test case, print one integer \u2014 the minimum possible number of kicks in the penalty phase.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n1?0???1001\\n1111111111\\n??????????\\n0100000000\\n\\n\\nOutput\\n\\n\\n7\\n10\\n6\\n9\\n\\nNote\\n\\nConsider...\\ntestn\",\"targets\":\"= input()\\n\\ntests = []\\n\\nfor n in range(0,int(testn)):\\n    tests += [input()]\\n\\ndef check_done(s1,s2,k1,k2):\\n    return (s1 > s2 + k2) or (s2 > s1 + k1)\\n\\ndef odd(n):\\n    return (n % 2) != 0\\n\\ndef t1 (test):\\n    s1 = 0\\n    s2 = 0\\n    k1 = 5\\n    k2 = 5\\n    n = 1\\n    for x in test:\\n        if odd(n):\\n            if x == \\\"1\\\" or x == \\\"?\\\":\\n                s1 += 1\\n                k1 += -1\\n            else:\\n                k1 += -1\\n        else:\\n            if x == \\\"1\\\":\\n                s2 += 1\\n                k2 += -1\\n            else:\\n                k2 += -1\\n        if check_done(s1,s2,k1,k2) == True:\\n            return n\\n        n += 1\\n    return 10\\n\\ndef t2 (test):\\n    s1 = 0\\n    s2 = 0\\n    k1 = 5\\n    k2 = 5\\n    n = 1\\n    for x in test:\\n        if odd(n):\\n            if x == \\\"1\\\":\\n                s1 += 1\\n                k1 += -1\\n            else:\\n                k1 += -1\\n        else:\\n            if x == \\\"1\\\" or x == \\\"?\\\":\\n                s2 += 1\\n                k2 += -1\\n            else:\\n                k2 += -1\\n        if check_done(s1,s2,k1,k2) == True:\\n            return n\\n        n += 1\\n    return 10\\n\\nfor test in tests:\\n    print (min([t1(test),t2(test)]))\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"After a hard day Vitaly got very hungry and he wants to eat his favorite potato pie. But it's not that simple. Vitaly is in the first room of the house with n room located in a line and numbered starting from one from left to right. You can go from the first room to the second room, from the second room to the third room and so on \u2014 you can go from the (n - 1)-th room to the n-th room. Thus, you can go to room x only from room x - 1.\\n\\nThe potato pie is located in the n-th room and Vitaly needs to go there. \\n\\nEach pair of consecutive rooms has a door between them. In order to go to room x from room x - 1, you need to open the door between the rooms with the corresponding key. \\n\\nIn total the house has several types of doors (represented by uppercase Latin letters) and several types of keys (represented by lowercase Latin letters). The key of type t can open the door of type T if and only if t and T are the same letter, written in different cases. For example, key f can open door F.\\n\\nEach of the first n - 1 rooms contains exactly one key of some type that Vitaly can use to get to next rooms. Once the door is open with some key, Vitaly won't get the key from the keyhole but he will immediately run into the next room. In other words, each key can open no more than one door.\\n\\nVitaly realizes that he may end up in some room without the key that opens the door to the next room. Before the start his run for the potato pie Vitaly can buy any number of keys of any type that is guaranteed to get to room n.\\n\\nGiven the plan of the house, Vitaly wants to know what is the minimum number of keys he needs to buy to surely get to the room n, which has a delicious potato pie. Write a program that will help Vitaly find out this number.\\n\\nInput\\n\\nThe first line of the input contains a positive integer n (2 \u2264 n \u2264 105) \u2014 the number of rooms in the house.\\n\\nThe second line of the input contains string s of length 2\u00b7n - 2. Let's number the elements of the string from left to right, starting from one. \\n\\nThe odd positions in the given...\",\"targets\":\"room = input()\\nstring = input()\\nkeys = {}\\nrooms = {}\\nneed = 0\\n\\nfor c in string:\\n    if c.islower():\\n        if c in keys:\\n            keys[c] += 1\\n        else:\\n            keys[c] = 1\\n    elif c.isupper():\\n        if c in rooms:\\n            rooms[c] += 1\\n        else:\\n            rooms[c] = 1\\n\\n        try:\\n            if keys[c.lower()] > 0:\\n                keys[c.lower()] -= 1\\n            elif keys[c.lower()] == 0:\\n                need += 1\\n        except KeyError:\\n            need += 1\\n\\nprint(need)\",\"language\":\"python\",\"split\":\"train\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"You are given an integer n. In 1 move, you can do one of the following actions:\\n\\n  * erase any digit of the number (it's acceptable that the number before the operation has exactly one digit and after the operation, it is \\\"empty\\\"); \\n  * add one digit to the right. \\n\\n\\n\\nThe actions may be performed in any order any number of times.\\n\\nNote that if, after deleting some digit from a number, it will contain leading zeroes, they will not be deleted. E.g. if you delete from the number 301 the digit 3, the result is the number 01 (not 1).\\n\\nYou need to perform the minimum number of actions to make the number any power of 2 (i.e. there's an integer k (k \u2265 0) such that the resulting number is equal to 2^k). The resulting number must not have leading zeroes.\\n\\nE.g. consider n=1052. The answer is equal to 2. First, let's add to the right one digit 4 (the result will be 10524). Then let's erase the digit 5, so the result will be 1024 which is a power of 2.\\n\\nE.g. consider n=8888. The answer is equal to 3. Let's erase any of the digits 8 three times. The result will be 8 which is a power of 2.\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases. Then t test cases follow.\\n\\nEach test case consists of one line containing one integer n (1 \u2264 n \u2264 10^9).\\n\\nOutput\\n\\nFor each test case, output in a separate line one integer m \u2014 the minimum number of moves to transform the number into any power of 2.\\n\\nExample\\n\\nInput\\n\\n\\n12\\n1052\\n8888\\n6\\n75\\n128\\n1\\n301\\n12048\\n1504\\n6656\\n1000000000\\n687194767\\n\\n\\nOutput\\n\\n\\n2\\n3\\n1\\n3\\n0\\n0\\n2\\n1\\n3\\n4\\n9\\n2\\n\\nNote\\n\\nThe answer for the first test case was considered above.\\n\\nThe answer for the second test case was considered above.\\n\\nIn the third test case, it's enough to add to the right the digit 4 \u2014 the number 6 will turn into 64.\\n\\nIn the fourth test case, let's add to the right the digit 8 and then erase 7 and 5 \u2014 the taken number will turn into 8.\\n\\nThe numbers of the fifth and the sixth test cases are already powers of two so there's no need to make any move.\\n\\nIn the seventh test case, you can...\\\":\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst long long inf = 0x3f3f3f3f;\\nconst long long INF = 0x3f3f3f3f3f3f3f3f;\\nconst long long mod = 1e9 + 7;\\nconst long long MOD = 998244353;\\nconst long long N = 70;\\nlong long ans;\\nstring s, fj[N];\\ninline void INIT() {\\n  long long p = 1;\\n  for (long long i = 0; i <= 62; i++) {\\n    long long x = p;\\n    while (x) {\\n      long long tmp = x % 10;\\n      fj[i] = (char)(tmp + '0') + fj[i];\\n      x \\/= 10;\\n    }\\n    p *= 2;\\n  }\\n}\\ninline void init() { ans = INF; }\\ninline void solve() {\\n  cin >> s;\\n  for (long long i = 0; i <= 62; i++) {\\n    long long sum = 0;\\n    for (long long j = 0; j < s.size(); j++) {\\n      if (fj[i][sum] == s[j]) {\\n        sum++;\\n      }\\n      if (sum > fj[i].size()) {\\n        break;\\n      }\\n    }\\n    ans = min(ans, (long long)(s.size() + fj[i].size() - 2 * sum));\\n  }\\n  cout << ans << endl;\\n}\\nsigned main() {\\n  ios::sync_with_stdio(false);\\n  cout.tie(NULL);\\n  INIT();\\n  long long Time = 1;\\n  cin >> Time;\\n  while (Time--) {\\n    init();\\n    solve();\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"Given are a sequence of N positive integers A_1, A_2, \\\\ldots, A_N and another positive integer S.\\nFor a non-empty subset T of the set \\\\\\\\{1, 2, \\\\ldots , N \\\\\\\\}, let us define f(T) as follows:\\n\\n\\n* f(T) is the number of different non-empty subsets \\\\\\\\{x_1, x_2, \\\\ldots , x_k \\\\\\\\} of T such that A_{x_1}+A_{x_2}+\\\\cdots +A_{x_k} = S.\\n\\n\\n\\nFind the sum of f(T) over all 2^N-1 subsets T of \\\\\\\\{1, 2, \\\\ldots , N \\\\\\\\}. Since the sum can be enormous, print it modulo 998244353.\\n\\nConstraints\\n\\n* All values in input are integers.\\n* 1 \\\\leq N \\\\leq 3000\\n* 1 \\\\leq S \\\\leq 3000\\n* 1 \\\\leq A_i \\\\leq 3000\\n\\nInput\\n\\nInput is given from Standard Input in the following format:\\n\\n\\nN S\\nA_1 A_2 ... A_N\\n\\n\\nOutput\\n\\nPrint the sum of f(T) modulo 998244353.\\n\\nExamples\\n\\nInput\\n\\n3 4\\n2 2 4\\n\\n\\nOutput\\n\\n6\\n\\n\\nInput\\n\\n5 8\\n9 9 9 9 9\\n\\n\\nOutput\\n\\n0\\n\\n\\nInput\\n\\n10 10\\n3 1 4 1 5 9 2 6 5 3\\n\\n\\nOutput\\n\\n3296\\\":\",\"targets\":\"#include <bits\\/stdc++.h>\\n\\nint main(){\\n    using namespace std;\\n    constexpr unsigned long MOD = 998244353;\\n    unsigned long N, S;\\n    cin >> N >> S;\\n    vector<unsigned long> A(N);\\n    for(auto&& i : A)cin >> i;\\n\\n    vector<unsigned long> dp(S + 1);\\n    dp[0] = [](unsigned long n){unsigned long r{1}, a{2}; while(n){if(n & 1)(r *= a) %= MOD; (a *= a) %= MOD; n >>= 1;}return r;}(N);\\n\\n    for(const auto& i : A)for(unsigned long j{S}; j >= i; --j)(dp[j] += (dp[j - i] + (dp[j - i] & 1) * MOD) \\/ 2) %= MOD;\\n\\n    cout << dp.back() << endl;\\n\\n    return 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"On the great island of Baltia, there live N people, numbered from 1 to N. There are exactly M pairs of people that are friends with each other. The people of Baltia want to organize a successful party, but they have very strict rules on what a party is and when the party is successful. On the island of Baltia, a party is a gathering of exactly 5 people. The party is considered to be successful if either all the people at the party are friends with each other (so that they can all talk to each other without having to worry about talking to someone they are not friends with) or no two people at the party are friends with each other (so that everyone can just be on their phones without anyone else bothering them). Please help the people of Baltia organize a successful party or tell them that it's impossible to do so.\\n\\nInput\\n\\nThe first line contains two integer numbers, N (5 \u2264 N \u2264 2*10^5) and M (0 \u2264 M \u2264 2*10^5) \u2013 the number of people that live in Baltia, and the number of friendships. The next M lines each contains two integers U_i and V_i (1 \u2264 U_i,V_i \u2264 N) \u2013 meaning that person U_i is friends with person V_i. Two friends can not be in the list of friends twice (no pairs are repeated) and a person can be friends with themselves (U_i \u2260 V_i).\\n\\nOutput\\n\\nIf it's possible to organize a successful party, print 5 numbers indicating which 5 people should be invited to the party. If it's not possible to organize a successful party, print -1 instead. If there are multiple successful parties possible, print any.\\n\\nExamples\\n\\nInput\\n\\n\\n6 3\\n1 4\\n4 2\\n5 4\\n\\n\\nOutput\\n\\n\\n1 2 3 5 6\\n\\n\\nInput\\n\\n\\n5 4\\n1 2\\n2 3\\n3 4\\n4 5\\n\\n\\nOutput\\n\\n\\n-1\\\":\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst int N = 2e5 + 10, M = 4e6 + 10, mod = 1e9 + 7;\\nint n, m;\\nset<int> s[N];\\nint main() {\\n  cin >> n >> m;\\n  srand(time(NULL));\\n  for (int i = 0; i < m; i++) {\\n    int a, b;\\n    scanf(\\\"%d%d\\\", &a, &b);\\n    s[a].insert(b);\\n    s[b].insert(a);\\n  }\\n  for (int i = 0; i < (int)1e6; i++) {\\n    int a[6];\\n    for (int i = 0; i < 5; i++) a[i] = rand() % n + 1;\\n    bool ff = false;\\n    int k = s[a[0]].count(a[1]);\\n    for (int j = 0; j < 5; j++)\\n      for (int p = j + 1; p < 5; p++)\\n        if (a[j] == a[p] || s[a[j]].count(a[p]) != k) {\\n          ff = true;\\n          break;\\n        }\\n    if (!ff) {\\n      for (int j = 0; j < 5; j++) cout << a[j] << \\\" \\\";\\n      return 0;\\n    }\\n  }\\n  cout << -1;\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You are given a binary string (i. e. a string consisting of characters 0 and\\/or 1) s of length n. You can perform the following operation with the string s at most once: choose a substring (a contiguous subsequence) of s having exactly k characters 1 in it, and shuffle it (reorder the characters in the substring as you wish).\\n\\nCalculate the number of different strings which can be obtained from s by performing this operation at most once.\\n\\nInput\\n\\nThe first line contains two integers n and k (2 \u2264 n \u2264 5000; 0 \u2264 k \u2264 n).\\n\\nThe second line contains the string s of length n, consisting of characters 0 and\\/or 1.\\n\\nOutput\\n\\nPrint one integer \u2014 the number of different strings which can be obtained from s by performing the described operation at most once. Since the answer can be large, output it modulo 998244353.\\n\\nExamples\\n\\nInput\\n\\n\\n7 2\\n1100110\\n\\n\\nOutput\\n\\n\\n16\\n\\n\\nInput\\n\\n\\n5 0\\n10010\\n\\n\\nOutput\\n\\n\\n1\\n\\n\\nInput\\n\\n\\n8 1\\n10001000\\n\\n\\nOutput\\n\\n\\n10\\n\\n\\nInput\\n\\n\\n10 8\\n0010011000\\n\\n\\nOutput\\n\\n\\n1\\n\\nNote\\n\\nSome strings you can obtain in the first example:\\n\\n  * to obtain 0110110, you can take the substring from the 1-st character to the 4-th character, which is 1100, and reorder its characters to get 0110; \\n  * to obtain 1111000, you can take the substring from the 3-rd character to the 7-th character, which is 00110, and reorder its characters to get 11000; \\n  * to obtain 1100101, you can take the substring from the 5-th character to the 7-th character, which is 110, and reorder its characters to get 101. \\n\\n\\n\\nIn the second example, k = 0 so you can only choose the substrings consisting only of 0 characters. Reordering them doesn't change the string at all, so the only string you can obtain is 10010.\\nUsing cpp can you solve the prior task?\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst int N = 2 * 1e5 + 10;\\nconst int mod = 998244353;\\ninline int add(int a, int b) { return a + b >= mod ? a + b - mod : a + b; }\\ninline int mul(int a, int b) { return a * 1ll * b % mod; }\\nlong long f[N];\\nlong long fp(long long b, long long p) {\\n  if (p == 0) return 1;\\n  return fp(b * b % mod, p \\/ 2) * (p & 1 ? b : 1) % mod;\\n}\\nlong long inv(long long x) { return fp(x, mod - 2); }\\nlong long nCk(long long n, long long k) {\\n  return f[n] * inv(f[n - k]) % mod * inv(f[k]) % mod;\\n}\\nvoid Ineedhelp() {\\n  f[0] = 1;\\n  for (int i = 1; i < N; ++i) {\\n    f[i] = f[i - 1] * i % mod;\\n  }\\n  int n, k;\\n  string s;\\n  cin >> n >> k >> s;\\n  int i = 0, j = -1, cnt1 = 0, last1 = -1;\\n  while (j < n - 1 && cnt1 + (s[j + 1] == '1') <= k) {\\n    ++j;\\n    cnt1 += s[j] == '1';\\n    if (s[j] == '1') last1 = j;\\n  }\\n  if (cnt1 < k || k == 0) {\\n    cout << \\\"1\\\\n\\\";\\n    return;\\n  }\\n  long long ways = nCk(j - i + 1, k);\\n  while (j < n - 1) {\\n    int jj = j;\\n    ++j;\\n    while (j < n - 1 && s[j + 1] == '0') ++j;\\n    while (i < j && s[i] == '0') ++i;\\n    ++i;\\n    ways = ways - nCk(jj - i + 1, k - 1) + mod;\\n    ways %= mod;\\n    ways += nCk(j - i + 1, k);\\n    ways %= mod;\\n  }\\n  cout << ways << '\\\\n';\\n}\\nint main() {\\n  ios::sync_with_stdio(0);\\n  cin.tie(0);\\n  int t = 1;\\n  while (t--) Ineedhelp();\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Casimir has a rectangular piece of paper with a checkered field of size n \u00d7 m. Initially, all cells of the field are white.\\n\\nLet us denote the cell with coordinates i vertically and j horizontally by (i, j). The upper left cell will be referred to as (1, 1) and the lower right cell as (n, m).\\n\\nCasimir draws ticks of different sizes on the field. A tick of size d (d > 0) with its center in cell (i, j) is drawn as follows: \\n\\n  1. First, the center cell (i, j) is painted black. \\n  2. Then exactly d cells on the top-left diagonally to the center and exactly d cells on the top-right diagonally to the center are also painted black. \\n  3. That is all the cells with coordinates (i - h, j \u00b1 h) for all h between 0 and d are painted. In particular, a tick consists of 2d + 1 black cells. \\n\\n\\n\\nAn already painted cell will remain black if painted again. Below you can find an example of the 4 \u00d7 9 box, with two ticks of sizes 2 and 3.\\n\\n<image>\\n\\nYou are given a description of a checkered field of size n \u00d7 m. Casimir claims that this field came about after he drew some (possibly 0) ticks on it. The ticks could be of different sizes, but the size of each tick is at least k (that is, d \u2265 k for all the ticks).\\n\\nDetermine whether this field can indeed be obtained by drawing some (possibly none) ticks of sizes d \u2265 k or not.\\n\\nInput\\n\\nThe first line contains an integer t (1 \u2264 t \u2264 100) \u2014 the number test cases.\\n\\nThe following lines contain the descriptions of the test cases. \\n\\nThe first line of the test case description contains the integers n, m, and k (1 \u2264 k \u2264 n \u2264 10; 1 \u2264 m \u2264 19) \u2014 the field size and the minimum size of the ticks that Casimir drew. The following n lines describe the field: each line consists of m characters either being '.' if the corresponding cell is not yet painted or '*' otherwise.\\n\\nOutput\\n\\nPrint t lines, each line containing the answer to the corresponding test case. The answer to a test case should be YES if the given field can be obtained by drawing ticks of at least the given size and NO otherwise.\\n\\nYou may...\",\"targets\":\"import os, sys\\nfrom io import BytesIO, IOBase\\nfrom types import GeneratorType\\nfrom bisect import *\\nfrom collections import defaultdict, deque, Counter\\nimport math, string\\nfrom heapq import *\\nfrom operator import add\\nfrom itertools import accumulate\\n\\nBUFSIZE = 8192\\nsys.setrecursionlimit(10 ** 5)\\n\\n\\nclass FastIO(IOBase):\\n    newlines = 0\\n\\n    def __init__(self, file):\\n        import os\\n\\n        self.os = os\\n        self._fd = file.fileno()\\n        self.buffer = BytesIO()\\n        self.writable = \\\"x\\\" in file.mode or \\\"r\\\" not in file.mode\\n        self.write = self.buffer.write if self.writable else None\\n\\n    def read(self):\\n        while True:\\n            b = self.os.read(self._fd, max(self.os.fstat(self._fd).st_size, BUFSIZE))\\n            if not b:\\n                break\\n            ptr = self.buffer.tell()\\n            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)\\n        self.newlines = 0\\n        return self.buffer.read()\\n\\n    def readline(self):\\n        while self.newlines == 0:\\n            b = self.os.read(self._fd, max(self.os.fstat(self._fd).st_size, BUFSIZE))\\n            self.newlines = b.count(b\\\"\\\\n\\\") + (not b)\\n            ptr = self.buffer.tell()\\n            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)\\n        self.newlines -= 1\\n        return self.buffer.readline()\\n\\n    def flush(self):\\n        if self.writable:\\n            self.os.write(self._fd, self.buffer.getvalue())\\n            self.buffer.truncate(0), self.buffer.seek(0)\\n\\n\\nclass IOWrapper(IOBase):\\n    def __init__(self, file):\\n        self.buffer = FastIO(file)\\n        self.flush = self.buffer.flush\\n        self.writable = self.buffer.writable\\n        self.write = lambda s: self.buffer.write(s.encode(\\\"ascii\\\"))\\n        self.read = lambda: self.buffer.read().decode(\\\"ascii\\\")\\n        self.readline = lambda: self.buffer.readline().decode(\\\"ascii\\\")\\n\\n\\nsys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)\\ninput = lambda: sys.stdin.readline().rstrip(\\\"\\\\r\\\\n\\\")\\n\\n\\ninf = float(\\\"inf\\\")\\nen = lambda x:...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"During the hypnosis session, Nicholas suddenly remembered a positive integer n, which doesn't contain zeros in decimal notation. \\n\\nSoon, when he returned home, he got curious: what is the maximum number of digits that can be removed from the number so that the number becomes not prime, that is, either composite or equal to one?\\n\\nFor some numbers doing so is impossible: for example, for number 53 it's impossible to delete some of its digits to obtain a not prime integer. However, for all n in the test cases of this problem, it's guaranteed that it's possible to delete some of their digits to obtain a not prime number.\\n\\nNote that you cannot remove all the digits from the number.\\n\\nA prime number is a number that has no divisors except one and itself. A composite is a number that has more than two divisors. 1 is neither a prime nor a composite number.\\n\\nInput\\n\\nEach test contains multiple test cases.\\n\\nThe first line contains one positive integer t (1 \u2264 t \u2264 10^3), denoting the number of test cases. Description of the test cases follows.\\n\\nThe first line of each test case contains one positive integer k (1 \u2264 k \u2264 50) \u2014 the number of digits in the number.\\n\\nThe second line of each test case contains a positive integer n, which doesn't contain zeros in decimal notation (10^{k-1} \u2264 n < 10^{k}). It is guaranteed that it is always possible to remove less than k digits to make the number not prime.\\n\\nIt is guaranteed that the sum of k over all test cases does not exceed 10^4.\\n\\nOutput\\n\\nFor every test case, print two numbers in two lines. In the first line print the number of digits, that you have left in the number. In the second line print the digits left after all delitions. \\n\\nIf there are multiple solutions, print any.\\n\\nExample\\n\\nInput\\n\\n\\n7\\n3\\n237\\n5\\n44444\\n3\\n221\\n2\\n35\\n3\\n773\\n1\\n4\\n30\\n626221626221626221626221626221\\n\\n\\nOutput\\n\\n\\n2\\n27\\n1\\n4\\n1\\n1\\n2\\n35\\n2\\n77\\n1\\n4\\n1\\n6\\n\\nNote\\n\\nIn the first test case, you can't delete 2 digits from the number 237, as all the numbers 2, 3, and 7 are prime. However, you can delete 1 digit, obtaining a number 27 =...\\\":\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst long long INF = 1e18;\\nconst int32_t mod = 1e9 + 7;\\nconst int32_t MM = 998244353;\\nconst long long N = 0;\\nlong long power(long long x, long long y) {\\n  long long res = 1;\\n  while (y) {\\n    if (y % 2 == 1) res = (res * x);\\n    y = y >> 1;\\n    x = (x * x);\\n  }\\n  return res;\\n}\\nlong long modpower(long long x, long long y, long long p) {\\n  long long res = 1;\\n  x = x % p;\\n  if (x == 0) return 0;\\n  while (y > 0) {\\n    if (y & 1) res = (res * x) % p;\\n    y = y >> 1;\\n    x = (x * x) % p;\\n  }\\n  return res;\\n}\\nbool checksq(long long num) {\\n  return floor((double)sqrt(num)) == ceil((double)sqrt(num));\\n}\\nbool ispoweroftwo(long long n) {\\n  if (n == 0) return false;\\n  return (ceil(log2(n)) == floor(log2(n)));\\n}\\nbool isprime(long long n) {\\n  if (n <= 1) return false;\\n  if (n <= 3) return true;\\n  if (n % 2 == 0 || n % 3 == 0) return false;\\n  for (long long i = 5; i * i <= n; i = i + 6)\\n    if (n % i == 0 || n % (i + 2) == 0) return false;\\n  return true;\\n}\\nvoid sieve(long long n) {\\n  bool prime[n + 1];\\n  memset(prime, true, sizeof(prime));\\n  for (long long p = 2; p * p <= n; p++) {\\n    if (prime[p] == true) {\\n      for (long long i = p * p; i <= n; i += p) prime[i] = false;\\n    }\\n  }\\n  for (long long p = 2; p <= n; p++)\\n    if (prime[p]) cout << p << \\\" \\\";\\n}\\nvoid ghost() {\\n  cout << \\\"Apun Red Coder banega\\\"\\n       << \\\"\\\\n\\\";\\n}\\nvoid solve() {\\n  long long n;\\n  cin >> n;\\n  string s;\\n  cin >> s;\\n  for (long long i = 0; i < n; i++) {\\n    if (s[i] == '1' || s[i] == '4' || s[i] == '6' || s[i] == '8' ||\\n        s[i] == '9') {\\n      cout << 1 << \\\"\\\\n\\\";\\n      cout << s[i] << \\\"\\\\n\\\";\\n      return;\\n    }\\n  }\\n  for (long long i = 0; i < n; i++) {\\n    string str;\\n    str += s[i];\\n    for (long long j = i + 1; j < n; j++) {\\n      str += s[j];\\n      if (!isprime(stoi(str))) {\\n        cout << 2 << \\\"\\\\n\\\";\\n        cout << str << \\\"\\\\n\\\";\\n        return;\\n      }\\n      str.pop_back();\\n    }\\n  }\\n}\\nsigned main() {\\n  ios_base::sync_with_stdio(false);\\n  cin.tie(0);\\n  cout.tie(0);\\n  long long t = 1;\\n  cin >> t;\\n ...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"For a given array $a_1, a_2, a_3, ... , a_N$ of $N$ elements and $Q$ integers $x_i$ as queries, for each query, print the number of combinations of two integers $(l, r)$ which satisfies the condition: $1 \\\\leq l \\\\leq r \\\\leq N$ and $a_l + a_{l+1} + ... + a_{r-1} + a_r \\\\leq x_i$.\\n\\nConstraints\\n\\n* $1 \\\\leq N \\\\leq 10^5$\\n* $1 \\\\leq Q \\\\leq 500$\\n* $1 \\\\leq a_i \\\\leq 10^9$\\n* $1 \\\\leq x_i \\\\leq 10^{14}$\\n\\nInput\\n\\nThe input is given in the following format.\\n\\n$N$ $Q$\\n$a_1$ $a_2$ ... $a_N$\\n$x_1$ $x_2$ ... $x_Q$\\n\\nOutput\\n\\nFor each query, print the number of combinations in a line.\\n\\nExample\\n\\nInput\\n\\n6 5\\n1 2 3 4 5 6\\n6 9 12 21 15\\n\\n\\nOutput\\n\\n9\\n12\\n15\\n21\\n18\\\":\",\"targets\":\"#include \\\"bits\\/stdc++.h\\\"\\n\\nusing namespace std;\\n\\nvoid solve()\\n{\\n\\tint N, Q;\\n\\tcin >> N >> Q;\\n\\tvector<long> as(N);\\n\\tfor (int i = 0; i < N; i++) cin >> as[i];\\n\\n\\twhile(Q--)\\n\\t{\\n\\t\\tlong ans = 0, r = 0, s = 0, x;\\n\\t\\tcin >> x;\\n\\t\\tfor (int l = 0; l < N; l++)\\n\\t\\t{\\n\\t\\t\\twhile(r < N && s+as[r] <= x)\\n\\t\\t\\t{\\n\\t\\t\\t\\ts += as[r++];\\n\\t\\t\\t}\\n\\t\\t\\tans += r-l;\\n\\t\\t\\tif (l == r) r++;\\n\\t\\t\\telse s -= as[l];\\n\\t\\t}\\n\\t\\tcout << ans << endl;\\n\\t}\\n\\n}\\n\\nint main(void)\\n{\\n\\tsolve();\\n\\t\\/\\/cout << \\\"yui(*-v\u30fb)yui\\\" << endl;\\n\\treturn 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"This is the easy version of the problem. The difference between the versions is that the easy version does not require you to output the numbers of the rods to be removed. You can make hacks only if all versions of the problem are solved.\\n\\nStitch likes experimenting with different machines with his friend Sparky. Today they built another machine.\\n\\nThe main element of this machine are n rods arranged along one straight line and numbered from 1 to n inclusive. Each of these rods must carry an electric charge quantitatively equal to either 1 or -1 (otherwise the machine will not work). Another condition for this machine to work is that the sign-variable sum of the charge on all rods must be zero.\\n\\nMore formally, the rods can be represented as an array of n numbers characterizing the charge: either 1 or -1. Then the condition must hold: a_1 - a_2 + a_3 - a_4 + \u2026 = 0, or \u2211_{i=1}^n (-1)^{i-1} \u22c5 a_i = 0.\\n\\nSparky charged all n rods with an electric current, but unfortunately it happened that the rods were not charged correctly (the sign-variable sum of the charge is not zero). The friends decided to leave only some of the rods in the machine. Sparky has q questions. In the ith question Sparky asks: if the machine consisted only of rods with numbers l_i to r_i inclusive, what minimal number of rods could be removed from the machine so that the sign-variable sum of charges on the remaining ones would be zero? Perhaps the friends got something wrong, and the sign-variable sum is already zero. In that case, you don't have to remove the rods at all.\\n\\nIf the number of rods is zero, we will assume that the sign-variable sum of charges is zero, that is, we can always remove all rods.\\n\\nHelp your friends and answer all of Sparky's questions!\\n\\nInput\\n\\nEach test contains multiple test cases.\\n\\nThe first line contains one positive integer t (1 \u2264 t \u2264 10^3), denoting the number of test cases. Description of the test cases follows.\\n\\nThe first line of each test case contains two positive integers n and q (1 \u2264 n, q \u2264 3 \u22c5 10^5) \u2014 the...\",\"targets\":\"import java.io.*;\\nimport java.util.*;\\n \\npublic class Codeforces {\\n\\tstatic long f[], M = 1000000007;\\n\\tpublic static void main(String[] args) throws IOException {\\n\\t\\tBufferedReader br = new BufferedReader(new InputStreamReader(System.in));\\n\\t\\tint cases = Integer.parseInt(br.readLine());\\n\\t\\to:while(cases-- > 0) {\\n\\t\\t\\tString[] str = br.readLine().split(\\\" \\\");\\n\\t\\t\\tint n = Integer.parseInt(str[0]);\\n\\t\\t\\tint q = Integer.parseInt(str[1]);\\n\\t\\t\\tString s = br.readLine();\\n\\t\\t\\tint[] p = new int[n+1];\\n\\t\\t\\tint[] a = new int[n+1];\\n\\t\\t\\tfor(int i=1; i<=n; i++) {\\n\\t\\t\\t\\ta[i] = s.charAt(i-1) == '+'? 1 : -1;\\n\\t\\t\\t}\\n\\t\\t\\tfor(int i=1; i<=n; i++) {\\n\\t\\t\\t\\tp[i] = p[i-1] + ((i % 2 == 1) ? a[i] : -a[i]);\\n\\t\\t\\t}\\n\\t\\t\\tStringBuffer buf = new StringBuffer();\\n\\t\\t\\twhile(q-- > 0) {\\n\\t\\t\\t\\tstr = br.readLine().split(\\\" \\\");\\n\\t\\t\\t\\tint l = Integer.parseInt(str[0]);\\n\\t\\t\\t\\tint r = Integer.parseInt(str[1]);\\n\\t\\t\\t\\tif(sum(p, l, r) == 0) {\\n\\t\\t\\t\\t\\tbuf.append(\\\"0\\\\n\\\");\\n\\t\\t\\t\\t\\tcontinue;\\n\\t\\t\\t\\t}\\n\\t\\t\\t\\tif((r - l + 1) % 2 == 0) {\\n\\t\\t\\t\\t\\tbuf.append(\\\"2\\\\n\\\");\\n\\t\\t\\t\\t}else {\\n\\t\\t\\t\\t\\tbuf.append(\\\"1\\\\n\\\");\\n\\t\\t\\t\\t}\\n\\t\\t\\t}\\n\\t\\t\\tSystem.out.print(buf);\\n\\t\\t}\\n\\t}\\n\\tpublic static int sum(int[] p, int l, int r) {\\n\\t\\tif(l > r) {\\n\\t\\t\\treturn 0;\\n\\t\\t}\\n\\t\\tif(l % 2 == 1) {\\n\\t\\t\\treturn p[r] - p[l-1];\\n\\t\\t}else {\\n\\t\\t\\treturn p[l-1] - p[r];\\n\\t\\t}\\n\\t}\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"JAVA solution for \\\"The new generation external memory contains an array of integers a[1 \u2026 n] = [a_1, a_2, \u2026, a_n].\\n\\nThis type of memory does not support changing the value of an arbitrary element. Instead, it allows you to cut out any segment of the given array, cyclically shift (rotate) it by any offset and insert it back into the same place.\\n\\nTechnically, each cyclic shift consists of two consecutive actions: \\n\\n  1. You may select arbitrary indices l and r (1 \u2264 l < r \u2264 n) as the boundaries of the segment. \\n  2. Then you replace the segment a[l \u2026 r] with it's cyclic shift to the left by an arbitrary offset d. The concept of a cyclic shift can be also explained by following relations: the sequence [1, 4, 1, 3] is a cyclic shift of the sequence [3, 1, 4, 1] to the left by the offset 1 and the sequence [4, 1, 3, 1] is a cyclic shift of the sequence [3, 1, 4, 1] to the left by the offset 2. \\n\\n\\n\\nFor example, if a = [1, \\\\color{blue}{3, 2, 8}, 5], then choosing l = 2, r = 4 and d = 2 yields a segment a[2 \u2026 4] = [3, 2, 8]. This segment is then shifted by the offset d = 2 to the left, and you get a segment [8, 3, 2] which then takes the place of of the original elements of the segment. In the end you get a = [1, \\\\color{blue}{8, 3, 2}, 5].\\n\\nSort the given array a using no more than n cyclic shifts of any of its segments. Note that you don't need to minimize the number of cyclic shifts. Any method that requires n or less cyclic shifts will be accepted.\\n\\nInput\\n\\nThe first line contains an integer t (1 \u2264 t \u2264 1000) \u2014 the number of test cases.\\n\\nThe next 2t lines contain the descriptions of the test cases. \\n\\nThe first line of each test case description contains an integer n (2 \u2264 n \u2264 50) \u2014 the length of the array. The second line consists of space-separated elements of the array a_i (-10^9 \u2264 a_i \u2264 10^9). Elements of array a may repeat and don't have to be unique.\\n\\nOutput\\n\\nPrint t answers to all input test cases. \\n\\nThe first line of the answer of each test case should contain an integer k (0 \u2264 k \u2264 n) \u2014 the number of actions to sort the array....\\\":\",\"targets\":\"import java.util.*;\\nimport java.io.*;\\nimport java.math.*;\\n\\npublic class B {\\n\\tpublic static FastScanner sc;\\n    public static int MOD= 1000000007;\\n\\tpublic static class FastScanner {\\n\\t\\tBufferedReader br=new BufferedReader(new InputStreamReader(System.in));\\n\\t\\tStringTokenizer st=new StringTokenizer(\\\"\\\");\\n\\t\\tString next() {\\n\\t\\t\\twhile (!st.hasMoreTokens())\\n\\t\\t\\t\\ttry { \\n\\t\\t\\t\\t\\tst=new StringTokenizer(br.readLine());\\t\\t\\t\\t               \\n\\t             } catch (IOException e) {}\\n\\t\\t\\t\\treturn st.nextToken();\\n\\t\\t\\t}\\n\\t\\t\\n\\t\\tint nextInt() {\\n\\t\\t\\treturn Integer.parseInt(next());\\n\\t\\t}\\n\\t\\tlong nextLong() {\\n\\t\\t\\treturn Long.parseLong(next());\\n\\t\\t}\\n    }\\n    \\n    public static int gcd(int a, int b) {\\n\\t\\tif(b==0) return a;\\n\\t\\treturn gcd(b,a%b);\\n\\t}\\n\\t\\n\\tpublic static int lcm(int a, int b) {\\n\\t\\treturn((a*b)\\/gcd(a,b));\\n\\t}\\n\\t\\n\\tpublic static void decreasingOrder(ArrayList<Integer> al) {\\n\\t\\tComparator<Integer> c = Collections.reverseOrder();\\n\\t    Collections.sort(al,c);\\n\\t}\\n    \\n    public static boolean[] sieveOfEratosthenes(int n) {\\n\\t\\tboolean isPrime[] = new boolean[n+1];\\n\\t\\tArrays.fill(isPrime, true);\\n\\t\\tisPrime[0]=false;\\n\\t\\tisPrime[1]=false;\\t\\n\\t\\tfor(int i=2;i*i<n;i++) {\\n\\t\\t\\tfor(int j=2*i;j<n;j+=i) {\\n\\t\\t\\t\\tisPrime[j]=false;\\n\\t\\t\\t}\\n\\t\\t}\\n\\t\\treturn isPrime;\\n\\t}\\n    \\n    public static  int nCr(int N, int R) {\\n        double result=1;\\n    \\tfor(int i=1;i<=R;i++){\\n            result=((result*(N-R+i))\\/i);\\n        }\\n    \\treturn (int) result;\\n    }\\n    \\n    public static void solve(int t) {\\n    \\tint n=sc.nextInt();\\n    \\tint[] arr = new int[n];\\n    \\tint[] arr2= new int[n];\\n    \\tfor(int i=0;i<n;i++) {\\n    \\t\\tarr[i]=sc.nextInt();\\n    \\t\\tarr2[i]=arr[i];\\n    \\t}\\n    \\tArrays.sort(arr2);\\n    \\tMap<Integer, List<Integer>> hm = new HashMap<>();\\n    \\t\\n    \\tfor(int i=0;i<n;i++) {\\n    \\t\\tif(hm.containsKey(arr[i])==true) {\\n    \\t\\t\\thm.get(arr[i]).add(i);\\n    \\t\\t}\\n    \\t\\telse {\\n    \\t\\t\\tList<Integer> ll= new LinkedList<Integer>();\\n    \\t\\t\\tll.add(i);\\n    \\t\\t\\thm.put(arr[i],ll);\\n    \\t\\t}\\n    \\t}\\n    \\t\\n    \\tint main=0;\\n    \\t\\n    \\tArrayList<Integer> al1= new ArrayList<>();\\n    \\tArrayList<Integer> al2= new...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"JAVA solution for \\\"Moamen has an array of n distinct integers. He wants to sort that array in non-decreasing order by doing the following operations in order exactly once:\\n\\n  1. Split the array into exactly k non-empty subarrays such that each element belongs to exactly one subarray. \\n  2. Reorder these subarrays arbitrary. \\n  3. Merge the subarrays in their new order. \\n\\n\\n\\nA sequence a is a subarray of a sequence b if a can be obtained from b by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.\\n\\nCan you tell Moamen if there is a way to sort the array in non-decreasing order using the operations written above?\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 10^3) \u2014 the number of test cases. The description of the test cases follows.\\n\\nThe first line of each test case contains two integers n and k (1 \u2264 k \u2264 n \u2264 10^5).\\n\\nThe second line contains n integers a_1, a_2, \u2026, a_n (0 \u2264 |a_i| \u2264 10^9). It is guaranteed that all numbers are distinct.\\n\\nIt is guaranteed that the sum of n over all test cases does not exceed 3\u22c510^5.\\n\\nOutput\\n\\nFor each test case, you should output a single string.\\n\\nIf Moamen can sort the array in non-decreasing order, output \\\"YES\\\" (without quotes). Otherwise, output \\\"NO\\\" (without quotes).\\n\\nYou can print each letter of \\\"YES\\\" and \\\"NO\\\" in any case (upper or lower).\\n\\nExample\\n\\nInput\\n\\n\\n3\\n5 4\\n6 3 4 2 1\\n4 2\\n1 -4 0 -2\\n5 1\\n1 2 3 4 5\\n\\n\\nOutput\\n\\n\\nYes\\nNo\\nYes\\n\\nNote\\n\\nIn the first test case, a = [6, 3, 4, 2, 1], and k = 4, so we can do the operations as follows: \\n\\n  1. Split a into \\\\{ [6], [3, 4], [2], [1] \\\\}. \\n  2. Reorder them: \\\\{ [1], [2], [3,4], [6] \\\\}. \\n  3. Merge them: [1, 2, 3, 4, 6], so now the array is sorted. \\n\\n\\n\\nIn the second test case, there is no way to sort the array by splitting it into only 2 subarrays.\\n\\nAs an example, if we split it into \\\\{ [1, -4], [0, -2] \\\\}, we can reorder them into \\\\{ [1, -4], [0, -2] \\\\} or \\\\{ [0, -2], [1, -4] \\\\}. However, after merging the subarrays, it is impossible to get a sorted array.\\\":\",\"targets\":\"import java.io.BufferedReader;\\nimport java.io.IOException;\\nimport java.io.InputStreamReader;\\nimport java.util.ArrayList;\\nimport java.util.Collections;\\nimport java.util.StringTokenizer;\\nimport java.util.*;\\n\\npublic class B {\\n \\n    public static void main(String[] args) {\\n        FastScanner fs=new FastScanner();\\n        int T=fs.nextInt();\\n        int t=1;\\n        for (int tt=0; tt<T; tt++){\\n            int n=fs.nextInt();\\n            int k=fs.nextInt();\\n            int a[]=fs.readArray(n);\\n            int b[]=a.clone();\\n            Arrays.sort(b);\\n            int cnt=0;\\n            for(int i=1;i<n;i++){\\n                if(a[i-1]>a[i])\\n                    cnt++;\\n                else{\\n                    int j=Arrays.binarySearch(b,a[i-1]);\\n                    if(j==n-1||b[j+1]!=a[i])\\n                        cnt++;\\n                }\\n            }\\n            if(cnt>=k)\\n                System.out.println(\\\"No\\\");\\n            else\\n                System.out.println(\\\"Yes\\\");\\n        }\\n    }\\n \\n    static void sort(int[] a) {\\n        ArrayList<Integer> l=new ArrayList<>();\\n        for (int i:a) l.add(i);\\n        Collections.sort(l);\\n        for (int i=0; i<a.length; i++) a[i]=l.get(i);\\n    }\\n    \\n    static class FastScanner {\\n        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));\\n        StringTokenizer st=new StringTokenizer(\\\"\\\");\\n        String next() {\\n            while (!st.hasMoreTokens())\\n                try {\\n                    st=new StringTokenizer(br.readLine());\\n                } catch (IOException e) {\\n                    e.printStackTrace();\\n                }\\n            return st.nextToken();\\n        }\\n        \\n        int nextInt() {\\n            return Integer.parseInt(next());\\n        }\\n        int[] readArray(int n) {\\n            int[] a=new int[n];\\n            for (int i=0; i<n; i++) a[i]=nextInt();\\n            return a;\\n        }\\n        long nextLong() {\\n            return Long.parseLong(next());\\n        }\\n    }\\n \\n    \\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You are given a sequence a_1, a_2, ..., a_n consisting of n pairwise distinct positive integers.\\n\\nFind \\\\left\u230a \\\\frac n 2 \\\\right\u230b different pairs of integers x and y such that: \\n\\n  * x \u2260 y; \\n  * x and y appear in a; \\n  * x~mod~y doesn't appear in a. \\n\\n\\n\\nNote that some x or y can belong to multiple pairs.\\n\\n\u230a x \u230b denotes the floor function \u2014 the largest integer less than or equal to x. x~mod~y denotes the remainder from dividing x by y.\\n\\nIf there are multiple solutions, print any of them. It can be shown that at least one solution always exists.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 10^4) \u2014 the number of testcases.\\n\\nThe first line of each testcase contains a single integer n (2 \u2264 n \u2264 2 \u22c5 10^5) \u2014 the length of the sequence.\\n\\nThe second line of each testcase contains n integers a_1, a_2, ..., a_n (1 \u2264 a_i \u2264 10^6).\\n\\nAll numbers in the sequence are pairwise distinct. The sum of n over all testcases doesn't exceed 2 \u22c5 10^5.\\n\\nOutput\\n\\nThe answer for each testcase should contain \\\\left\u230a \\\\frac n 2 \\\\right\u230b different pairs of integers x and y such that x \u2260 y, x and y appear in a and x~mod~y doesn't appear in a. Print the pairs one after another.\\n\\nYou can print the pairs in any order. However, the order of numbers in the pair should be exactly such that the first number is x and the second number is y. All pairs should be pairwise distinct.\\n\\nIf there are multiple solutions, print any of them.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n2\\n1 4\\n4\\n2 8 3 4\\n5\\n3 8 5 9 7\\n6\\n2 7 5 3 4 8\\n\\n\\nOutput\\n\\n\\n4 1\\n8 2\\n8 4\\n9 5\\n7 5\\n8 7\\n4 3\\n5 2\\n\\nNote\\n\\nIn the first testcase there are only two pairs: (1, 4) and (4, 1). \\\\left\u230a \\\\frac 2 2 \\\\right\u230b=1, so we have to find one pair. 1~mod~4=1, and 1 appears in a, so that pair is invalid. Thus, the only possible answer is a pair (4, 1).\\n\\nIn the second testcase, we chose pairs 8~mod~2=0 and 8~mod~4=0. 0 doesn't appear in a, so that answer is valid. There are multiple possible answers for that testcase.\\n\\nIn the third testcase, the chosen pairs are 9~mod~5=4 and 7~mod~5=2. Neither 4, nor 2, appears in a, so that...\\nThe above is tricky. Write me a correct solution in JAVA.\",\"targets\":\"import java.util.*;\\nimport java.io.*;\\npublic class Solution {\\nstatic class FastReader {\\n        BufferedReader br;\\n        StringTokenizer st;\\n \\n        public FastReader()\\n        {\\n            br = new BufferedReader(\\n                new InputStreamReader(System.in));\\n        }\\n \\n        String next()\\n        {\\n            while (st == null || !st.hasMoreElements()) {\\n                try {\\n                    st = new StringTokenizer(br.readLine());\\n                }\\n                catch (IOException e) {\\n                    e.printStackTrace();\\n                }\\n            }\\n            return st.nextToken();\\n        }\\n \\n        int nextInt() { return Integer.parseInt(next()); }\\n \\n        long nextLong() { return Long.parseLong(next()); }\\n \\n        double nextDouble()\\n        {\\n            return Double.parseDouble(next());\\n        }\\n \\n        String nextLine()\\n        {\\n            String str = \\\"\\\";\\n            try {\\n                str = br.readLine();\\n            }\\n            catch (IOException e) {\\n                e.printStackTrace();\\n            }\\n            return str;\\n        }\\n    }\\npublic static void main(String[] args) {\\nFastReader s= new FastReader();\\nint t=s.nextInt();\\nwhile(t-->0)\\n{\\nint n=s.nextInt();\\nint arr[]= new int[n];\\n \\nint min=Integer.MAX_VALUE;\\nfor(int i=0;i<n;i++)\\n{\\narr[i]=s.nextInt();\\nmin=Math.min(min, arr[i]);\\n \\n}\\nint pairs=0;\\nfor(int i=0;i<n;i++) {\\nif(arr[i]!=min) {\\nSystem.out.println(arr[i]+\\\" \\\"+min);\\npairs++;}\\nif(pairs== n\\/2)\\nbreak;\\n}\\n}\\n \\n}\\n \\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"n students attended the first meeting of the Berland SU programming course (n is even). All students will be divided into two groups. Each group will be attending exactly one lesson each week during one of the five working days (Monday, Tuesday, Wednesday, Thursday and Friday), and the days chosen for the groups must be different. Furthermore, both groups should contain the same number of students.\\n\\nEach student has filled a survey in which they told which days of the week are convenient for them to attend a lesson, and which are not. \\n\\nYour task is to determine if it is possible to choose two different week days to schedule the lessons for the group (the first group will attend the lesson on the first chosen day, the second group will attend the lesson on the second chosen day), and divide the students into two groups, so the groups have equal sizes, and for each student, the chosen lesson day for their group is convenient.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 10^4) \u2014 the number of testcases.\\n\\nThen the descriptions of t testcases follow.\\n\\nThe first line of each testcase contains one integer n (2 \u2264 n \u2264 1 000) \u2014 the number of students.\\n\\nThe i-th of the next n lines contains 5 integers, each of them is 0 or 1. If the j-th integer is 1, then the i-th student can attend the lessons on the j-th day of the week. If the j-th integer is 0, then the i-th student cannot attend the lessons on the j-th day of the week. \\n\\nAdditional constraints on the input: for each student, at least one of the days of the week is convenient, the total number of students over all testcases doesn't exceed 10^5.\\n\\nOutput\\n\\nFor each testcase print an answer. If it's possible to divide the students into two groups of equal sizes and choose different days for the groups so each student can attend the lesson in the chosen day of their group, print \\\"YES\\\" (without quotes). Otherwise, print \\\"NO\\\" (without quotes). \\n\\nExample\\n\\nInput\\n\\n\\n2\\n4\\n1 0 0 1 0\\n0 1 0 0 1\\n0 0 0 1 0\\n0 1 0 1 0\\n2\\n0 0 0 1 0\\n0 0 0 1 0\\n\\n\\nOutput\\n\\n\\nYES\\nNO\\n\\nNote\\n\\nIn...\\nThe above is tricky. Write me a correct solution in JAVA.\",\"targets\":\"import java.math.*;\\nimport java.util.*;\\nimport java.io.*;\\n \\n \\n \\npublic class main\\n{\\n  static Map<String,Integer> map=new HashMap<>();\\n             static int[] parent;\\n         static  int[] size;\\n    public static void main(String[] args)\\n    {\\n        InputReader in = new InputReader(System.in);\\n        PrintWriter pw = new PrintWriter(System.out);\\n        \\n\\/\\/         FileReader fr=new FileReader(\\\"\\/sagar.txt\\\");\\n\\/\\/        InputStreamReader isr=new InputStreamReader(fr);\\n        \\n\\/\\/         BufferedReader isr=new BufferedReader(fr);\\n        \\n\\/\\/         FileWriter fw=new FileWriter(\\\"ProblemA1_ans.txt\\\");\\n\\/\\/         BufferedWriter bw=new BufferedWriter(fw);\\n         final int mod=1000000007;\\n       \\/\\/ int test_case =Integer.parseInt(isr.read());\\n          int test_case=in.nextInt();\\n       \\/\\/ int test_case=1;\\n                    StringBuilder sb=new StringBuilder();\\n      \\/\\/  long mod=998244353;\\n        long[] fact=new long[100001];\\n        fact[0]=1;\\n        fact[1]=1;\\n        fact[2]=1;\\n        for(int i=3;i<fact.length;i++)\\n        {\\n            fact[i]=((fact[i-1])%mod*(i%mod))%mod;\\n            \\/\\/System.out.println(fact[i]);\\n        }\\n        \\n      for(int t1=0;t1<test_case;t1++)\\n      {\\n          int n=in.nextInt();\\n          String[] s=new String[n];\\n          for(int i=0;i<n;i++)\\n          {\\n              s[i]=in.nextLine();\\n          }\\n          int c1=0;\\n          int c2=0;\\n          int c3=0;\\n          boolean f=false;\\n          for(int i=0;i<9;i++)\\n          {\\n              \\n              for(int j=i+1;j<9;j++)\\n              {\\n                  \\n                  if(i%2==1&&j%2==1)\\n                  {\\n                      continue;\\n                  }\\n                  \\n                  c1=0;\\n                  c2=0;\\n                  c3=0;\\n                  for(int k=0;k<n;k++)\\n                  {\\n                   \\/\\/   System.out.println(i+\\\" \\\"+j+\\\" \\\"+k);\\n                      \\n                      if(s[k].charAt(i)=='1'&&s[k].charAt(j)=='0')\\n                      {\\n                         ...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"An elephant decided to visit his friend. It turned out that the elephant's house is located at point 0 and his friend's house is located at point x(x > 0) of the coordinate line. In one step the elephant can move 1, 2, 3, 4 or 5 positions forward. Determine, what is the minimum number of steps he need to make in order to get to his friend's house.\\n\\nInput\\n\\nThe first line of the input contains an integer x (1 \u2264 x \u2264 1 000 000) \u2014 The coordinate of the friend's house.\\n\\nOutput\\n\\nPrint the minimum number of steps that elephant needs to make to get from point 0 to point x.\\n\\nExamples\\n\\nInput\\n\\n5\\n\\n\\nOutput\\n\\n1\\n\\n\\nInput\\n\\n12\\n\\n\\nOutput\\n\\n3\\n\\nNote\\n\\nIn the first sample the elephant needs to make one step of length 5 to reach the point x.\\n\\nIn the second sample the elephant can get to point x if he moves by 3, 5 and 4. There are other ways to get the optimal answer but the elephant cannot reach x in less than three moves.\",\"targets\":\"n = int(input())\\npath = 0\\nfor i in range(n):\\n    if n >= 5:\\n        n = n - 5\\n        path += 1\\n        if n == 0:\\n            print(path)\\n            exit(0)\\n    elif n >= 4:\\n        n = n - 4\\n        path += 1\\n        if n == 0:\\n            print(path)\\n            exit(0)\\n    elif n >= 3:\\n        n = n - 3\\n        path += 1\\n        if n == 0:\\n            print(path)\\n            exit(0)\\n    elif n >= 2:\\n        n = n - 2\\n        path += 1\\n        if n == 0:\\n            print(path)\\n            exit(0)\\n    else:\\n        n = n - 1\\n        path += 1\\n        if n == 0:\\n            print(path)\\n            exit(0)\",\"language\":\"python\",\"split\":\"train\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in CPP?\\nAlice and Bob are playing chess on a huge chessboard with dimensions n \u00d7 n. Alice has a single piece left \u2014 a queen, located at (a_x, a_y), while Bob has only the king standing at (b_x, b_y). Alice thinks that as her queen is dominating the chessboard, victory is hers. \\n\\nBut Bob has made a devious plan to seize the victory for himself \u2014 he needs to march his king to (c_x, c_y) in order to claim the victory for himself. As Alice is distracted by her sense of superiority, she no longer moves any pieces around, and it is only Bob who makes any turns.\\n\\nBob will win if he can move his king from (b_x, b_y) to (c_x, c_y) without ever getting in check. Remember that a king can move to any of the 8 adjacent squares. A king is in check if it is on the same rank (i.e. row), file (i.e. column), or diagonal as the enemy queen. \\n\\nFind whether Bob can win or not.\\n\\nInput\\n\\nThe first line contains a single integer n (3 \u2264 n \u2264 1000) \u2014 the dimensions of the chessboard.\\n\\nThe second line contains two integers a_x and a_y (1 \u2264 a_x, a_y \u2264 n) \u2014 the coordinates of Alice's queen.\\n\\nThe third line contains two integers b_x and b_y (1 \u2264 b_x, b_y \u2264 n) \u2014 the coordinates of Bob's king.\\n\\nThe fourth line contains two integers c_x and c_y (1 \u2264 c_x, c_y \u2264 n) \u2014 the coordinates of the location that Bob wants to get to.\\n\\nIt is guaranteed that Bob's king is currently not in check and the target location is not in check either.\\n\\nFurthermore, the king is not located on the same square as the queen (i.e. a_x \u2260 b_x or a_y \u2260 b_y), and the target does coincide neither with the queen's position (i.e. c_x \u2260 a_x or c_y \u2260 a_y) nor with the king's position (i.e. c_x \u2260 b_x or c_y \u2260 b_y).\\n\\nOutput\\n\\nPrint \\\"YES\\\" (without quotes) if Bob can get from (b_x, b_y) to (c_x, c_y) without ever getting in check, otherwise print \\\"NO\\\".\\n\\nYou can print each letter in any case (upper or lower).\\n\\nExamples\\n\\nInput\\n\\n8\\n4 4\\n1 3\\n3 1\\n\\n\\nOutput\\n\\nYES\\n\\n\\nInput\\n\\n8\\n4 4\\n2 3\\n1 6\\n\\n\\nOutput\\n\\nNO\\n\\n\\nInput\\n\\n8\\n3 5\\n1 2\\n6 1\\n\\n\\nOutput\\n\\nNO\\n\\nNote\\n\\nIn the diagrams below, the squares controlled by the black...\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint main() {\\n  ios_base::sync_with_stdio(false);\\n  cin.tie(NULL);\\n  long long int n, ax, ay, bx, by, cx, cy, k = 0;\\n  cin >> n >> ax >> ay >> bx >> by >> cx >> cy;\\n  if ((cx < ax && bx < ax) || (cx > ax && bx > ax)) k++;\\n  if ((cy < ay && by < ay) || (cy > ay && by > ay)) k++;\\n  if (k == 2)\\n    cout << \\\"YES\\\\n\\\";\\n  else\\n    cout << \\\"NO\\\\n\\\";\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Vlad has n friends, for each of whom he wants to buy one gift for the New Year.\\n\\nThere are m shops in the city, in each of which he can buy a gift for any of his friends. If the j-th friend (1 \u2264 j \u2264 n) receives a gift bought in the shop with the number i (1 \u2264 i \u2264 m), then the friend receives p_{ij} units of joy. The rectangular table p_{ij} is given in the input.\\n\\nVlad has time to visit at most n-1 shops (where n is the number of friends). He chooses which shops he will visit and for which friends he will buy gifts in each of them.\\n\\nLet the j-th friend receive a_j units of joy from Vlad's gift. Let's find the value \u03b1=min\\\\\\\\{a_1, a_2, ..., a_n\\\\}. Vlad's goal is to buy gifts so that the value of \u03b1 is as large as possible. In other words, Vlad wants to maximize the minimum of the joys of his friends.\\n\\nFor example, let m = 2, n = 2. Let the joy from the gifts that we can buy in the first shop: p_{11} = 1, p_{12}=2, in the second shop: p_{21} = 3, p_{22}=4.\\n\\nThen it is enough for Vlad to go only to the second shop and buy a gift for the first friend, bringing joy 3, and for the second \u2014 bringing joy 4. In this case, the value \u03b1 will be equal to min\\\\{3, 4\\\\} = 3\\n\\nHelp Vlad choose gifts for his friends so that the value of \u03b1 is as high as possible. Please note that each friend must receive one gift. Vlad can visit at most n-1 shops (where n is the number of friends). In the shop, he can buy any number of gifts.\\n\\nInput\\n\\nThe first line of the input contains an integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases in the input.\\n\\nAn empty line is written before each test case. Then there is a line containing integers m and n (2 \u2264 n, 2 \u2264 n \u22c5 m \u2264 10^5) separated by a space \u2014 the number of shops and the number of friends, where n \u22c5 m is the product of n and m.\\n\\nThen m lines follow, each containing n numbers. The number in the i-th row of the j-th column p_{ij} (1 \u2264 p_{ij} \u2264 10^9) is the joy of the product intended for friend number j in shop number i.\\n\\nIt is guaranteed that the sum of the values n \u22c5 m over all test cases in...\\nSolve the task in JAVA.\",\"targets\":\"\\/*\\n  Challenge 1: Newbie to CM in 1year (Dec 2021 - Nov 2022)   \ud83d\udd25 5* Codechef\\n  Challenge 2: CM to IM in 1 year (Dec 2022 - Nov 2023)    \ud83d\udd25\ud83d\udd25 6* Codechef\\n  Challenge 3: IM to GM in 1 year (Dec 2023 - Nov 2024)  \ud83d\udd25\ud83d\udd25\ud83d\udd25 7* Codechef\\n  Goal: Become better in CP!\\n  Key: Consistency!\\n*\\/\\n\\nimport java.util.*;\\nimport java.io.*;\\nimport java.math.*;\\n\\npublic class Coder {\\n\\n  static int n,m;\\n  static int mat[][];\\n  static int p[][];\\n  static StringBuffer str=new StringBuffer();\\n\\n  static void solve(){\\n    int res[]=new int[n];\\n    for(int i=0;i<n;i++){\\n      int mx=1;\\n      for(int j=0;j<m;j++){\\n        mx=Math.max(mx, p[j][i]);\\n      }\\n      res[i]=mx;\\n    }\\n    long min=Integer.MAX_VALUE;\\n    for(int i=0;i<n;i++) min=Math.min(res[i], min);\\n    if(m<n) str.append(min).append(\\\"\\\\n\\\");\\n    else{\\n      long max=0;\\n      for(int i=0;i<m;i++){\\n        max=Math.max(max, mat[i][n-2]);\\n      }\\n      str.append(Math.min(max, min)).append(\\\"\\\\n\\\");\\n    }\\n  }\\n\\n  public static void main(String[] args) throws java.lang.Exception {\\n    BufferedReader bf;\\n    PrintWriter pw;\\n    boolean lenv=false;\\n    if(lenv){\\n      bf = new BufferedReader(\\n                          new FileReader(\\\"input.txt\\\"));\\n      pw=new PrintWriter(new\\n            BufferedWriter(new FileWriter(\\\"output.txt\\\")));\\n    }else{\\n      bf = new BufferedReader(new InputStreamReader(System.in));\\n      pw = new PrintWriter(new OutputStreamWriter(System.out));\\n    }\\n    \\n    int q = Integer.parseInt(bf.readLine().trim());\\n    while (q-- > 0) {\\n      bf.readLine();\\n      String s[]=bf.readLine().trim().split(\\\"\\\\\\\\s+\\\");\\n      m=Integer.parseInt(s[0]);\\n      n=Integer.parseInt(s[1]);\\n      mat=new int[m][n];\\n      p=new int[m][n];\\n      for(int i=0;i<m;i++){\\n        s=bf.readLine().trim().split(\\\"\\\\\\\\s+\\\");\\n        List<Integer> l=new ArrayList<>();\\n        for(int j=0;j<n;j++){\\n          p[i][j]=Integer.parseInt(s[j]);\\n          l.add(p[i][j]);\\n        }\\n        Collections.sort(l);\\n        for(int j=0;j<n;j++){\\n          mat[i][j]=l.get(j);\\n        }\\n      }\\n      solve();\\n    }\\n   ...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Andrea has come up with what he believes to be a novel sorting algorithm for arrays of length n. The algorithm works as follows.\\n\\nInitially there is an array of n integers a_1,  a_2,  ...,  a_n. Then, k steps are executed.\\n\\nFor each 1\u2264 i\u2264 k, during the i-th step the subsequence of the array a with indexes j_{i,1}< j_{i,2}< ...< j_{i, q_i} is sorted, without changing the values with the remaining indexes. So, the subsequence a_{j_{i,1}},  a_{j_{i,2}},  ...,  a_{j_{i,q_i}} is sorted and all other elements of a are left untouched.\\n\\nAndrea, being eager to share his discovery with the academic community, sent a short paper describing his algorithm to the journal \\\"Annals of Sorting Algorithms\\\" and you are the referee of the paper (that is, the person who must judge the correctness of the paper). You must decide whether Andrea's algorithm is correct, that is, if it sorts any array a of n integers.\\n\\nInput\\n\\nThe first line contains two integers n and k (1\u2264 n\u2264 40, 0\u2264 k\u2264 10) \u2014 the length of the arrays handled by Andrea's algorithm and the number of steps of Andrea's algorithm.\\n\\nThen k lines follow, each describing the subsequence considered in a step of Andrea's algorithm.\\n\\nThe i-th of these lines contains the integer q_i (1\u2264 q_i\u2264 n) followed by q_i integers j_{i,1},\\\\,j_{i,2}, ...,  j_{i,q_i} (1\u2264 j_{i,1}<j_{i,2}<\u22c5\u22c5\u22c5<j_{i,q_i}\u2264 n) \u2014 the length of the subsequence considered in the i-th step and the indexes of the subsequence.\\n\\nOutput\\n\\nIf Andrea's algorithm is correct print ACCEPTED, otherwise print REJECTED.\\n\\nExamples\\n\\nInput\\n\\n\\n4 3\\n3 1 2 3\\n3 2 3 4\\n2 1 2\\n\\n\\nOutput\\n\\n\\nACCEPTED\\n\\n\\nInput\\n\\n\\n4 3\\n3 1 2 3\\n3 2 3 4\\n3 1 3 4\\n\\n\\nOutput\\n\\n\\nREJECTED\\n\\n\\nInput\\n\\n\\n3 4\\n1 1\\n1 2\\n1 3\\n2 1 3\\n\\n\\nOutput\\n\\n\\nREJECTED\\n\\n\\nInput\\n\\n\\n5 2\\n3 2 3 4\\n5 1 2 3 4 5\\n\\n\\nOutput\\n\\n\\nACCEPTED\\n\\nNote\\n\\nExplanation of the first sample: The algorithm consists of 3 steps. The first one sorts the subsequence [a_1, a_2, a_3], the second one sorts the subsequence [a_2, a_3, a_4], the third one sorts the subsequence [a_1,a_2]. For example, if initially a=[6, 5, 6, 3], the algorithm transforms...\\nUsing cpp can you solve the prior task?\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint dx[] = {0, 1, 1, -1, 0, -1, 1, -1};\\nint dy[] = {1, 0, 1, 0, -1, -1, -1, 1};\\nlong long int power(long long int x, long long int y, long long int m) {\\n  if (y == 0) return 1;\\n  long long int a = power(x, y \\/ 2, m);\\n  if (y % 2) {\\n    return (a * ((a * x) % m)) % m;\\n  } else {\\n    return (a * a) % m;\\n  }\\n}\\nlong long int mod_inverse(long long int x, long long int m) {\\n  return power(x, m - 2, m);\\n}\\nlong long int fact(long long int n, long long int m) {\\n  if (n <= 1) return 1;\\n  return (fact(n - 1, m) * n) % m;\\n}\\nlong long int ncr(long long int n, long long int r, long long int m) {\\n  if (r > n || r < 0) return 0;\\n  if (n < 0) return 0;\\n  long long int n1 = 1, d1 = 1, d2 = 1;\\n  n1 = fact(n, m);\\n  d1 = fact(r, m);\\n  d2 = fact(n - r, m);\\n  long long int ans = mod_inverse((d1 * d2) % m, m);\\n  ans = (ans * n1) % m;\\n  return ans;\\n}\\nclass solver {\\n public:\\n  int n, k;\\n  vector<vector<int> > q;\\n  vector<vector<long long int> > mask_dp;\\n  long long int a, masku;\\n  long long int maskn;\\n  bool check(int i) {\\n    if (i > k) {\\n      if (masku != maskn) return false;\\n      int tm = __builtin_popcountll(a);\\n      if ((a >> tm) == 0) return true;\\n      return false;\\n    }\\n    long long int prv = a;\\n    long long int prv_m = masku;\\n    int len = q[i].size() - 1;\\n    long long int tmp = (masku & mask_dp[i][len]);\\n    int cnt1 = 0, cnt0 = 0;\\n    cnt1 = __builtin_popcountll(tmp & a);\\n    cnt0 = __builtin_popcountll(tmp) - cnt1;\\n    a = (a & (~mask_dp[i][len]));\\n    a = (a | mask_dp[i][cnt1]);\\n    masku |= mask_dp[i][len];\\n    if (!check(i + 1)) return false;\\n    for (int j = cnt1 + 1; j <= len - cnt0; ++j) {\\n      a |= (1ll << q[i][j]);\\n      if (!check(i + 1)) return false;\\n    }\\n    a = prv;\\n    masku = prv_m;\\n    return true;\\n  }\\n  void solve() {\\n    cin >> n >> k;\\n    q.resize(k + 1);\\n    mask_dp.resize(k + 1);\\n    for (int i = 1; i <= k; ++i) {\\n      int len;\\n      cin >> len;\\n      q[i].resize(len + 1);\\n      mask_dp[i].resize(len + 1);\\n      long long int m = 0ll;\\n     ...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"JAVA solution for \\\"You are given an array a of n integers, and another integer k such that 2k \u2264 n.\\n\\nYou have to perform exactly k operations with this array. In one operation, you have to choose two elements of the array (let them be a_i and a_j; they can be equal or different, but their positions in the array must not be the same), remove them from the array, and add \u230a (a_i)\\/(a_j) \u230b to your score, where \u230a x\\/y \u230b is the maximum integer not exceeding x\\/y.\\n\\nInitially, your score is 0. After you perform exactly k operations, you add all the remaining elements of the array to the score.\\n\\nCalculate the minimum possible score you can get.\\n\\nInput\\n\\nThe first line of the input contains one integer t (1 \u2264 t \u2264 500) \u2014 the number of test cases.\\n\\nEach test case consists of two lines. The first line contains two integers n and k (1 \u2264 n \u2264 100; 0 \u2264 k \u2264 \u230a n\\/2 \u230b).\\n\\nThe second line contains n integers a_1, a_2, ..., a_n (1 \u2264 a_i \u2264 2 \u22c5 10^5).\\n\\nOutput\\n\\nPrint one integer \u2014 the minimum possible score you can get.\\n\\nExample\\n\\nInput\\n\\n\\n5\\n7 3\\n1 1 1 2 1 3 1\\n5 1\\n5 5 5 5 5\\n4 2\\n1 3 3 7\\n2 0\\n4 2\\n9 2\\n1 10 10 1 10 2 7 10 3\\n\\n\\nOutput\\n\\n\\n2\\n16\\n0\\n6\\n16\\n\\nNote\\n\\nLet's consider the example test.\\n\\nIn the first test case, one way to obtain a score of 2 is the following one:\\n\\n  1. choose a_7 = 1 and a_4 = 2 for the operation; the score becomes 0 + \u230a 1\\/2 \u230b = 0, the array becomes [1, 1, 1, 1, 3]; \\n  2. choose a_1 = 1 and a_5 = 3 for the operation; the score becomes 0 + \u230a 1\\/3 \u230b = 0, the array becomes [1, 1, 1]; \\n  3. choose a_1 = 1 and a_2 = 1 for the operation; the score becomes 0 + \u230a 1\\/1 \u230b = 1, the array becomes [1]; \\n  4. add the remaining element 1 to the score, so the resulting score is 2. \\n\\n\\n\\nIn the second test case, no matter which operations you choose, the resulting score is 16.\\n\\nIn the third test case, one way to obtain a score of 0 is the following one:\\n\\n  1. choose a_1 = 1 and a_2 = 3 for the operation; the score becomes 0 + \u230a 1\\/3 \u230b = 0, the array becomes [3, 7]; \\n  2. choose a_1 = 3 and a_2 = 7 for the operation; the score becomes 0 + \u230a 3\\/7 \u230b = 0, the array becomes...\\\":\",\"targets\":\"import java.io.FileInputStream;\\nimport java.io.FileWriter;\\nimport java.io.IOException;\\nimport java.io.InputStream;\\nimport java.io.OutputStream;\\nimport java.io.PrintWriter;\\nimport java.util.ArrayList;\\nimport java.util.Collections;\\nimport java.util.InputMismatchException;\\n\\npublic class Main {\\n\\n    public static void main(String[] args) throws Exception {\\n        int tc = io.nextInt();\\n        for (int i = 0; i < tc; i++) {\\n            solve();\\n        }\\n        io.close();\\n    }\\n\\n    private static void solve() throws Exception {\\n        int n = io.nextInt();\\n        int k = io.nextInt();\\n        int[] data = new int[n];\\n        for (int i = 0; i < n; i++) {\\n            data[i] = io.nextInt();\\n        }\\n        sort(data);\\n        int start = n - k * 2;\\n        int output = 0;\\n        for (int i = 0; i < start; i++) {\\n            output += data[i];\\n        }\\n        for (int i = 0; i < k; i++) {\\n            int index1 = start + i;\\n            int index2 = start + k + i;\\n            output += data[index1] \\/ data[index2];\\n        }\\n        io.println(output);\\n    }\\n\\n    static void sort(int[] a) {\\n        ArrayList<Integer> l = new ArrayList<>(a.length);\\n        for (int i : a) {\\n            l.add(i);\\n        }\\n        Collections.sort(l);\\n        for (int i = 0; i < a.length; i++) {\\n            a[i] = l.get(i);\\n        }\\n    }\\n\\n    \\/\\/-----------PrintWriter for faster output---------------------------------\\n    public static FastIO io = new FastIO();\\n\\n    \\/\\/-----------MyScanner class for faster input----------\\n    static class FastIO extends PrintWriter {\\n        private InputStream stream;\\n        private byte[] buf = new byte[1 << 16];\\n        private int curChar, numChars;\\n\\n        \\/\\/ standard input\\n        public FastIO() {\\n            this(System.in, System.out);\\n        }\\n\\n        public FastIO(InputStream i, OutputStream o) {\\n            super(o);\\n            stream = i;\\n        }\\n\\n        \\/\\/ file input\\n        public FastIO(String i, String o) throws IOException {\\n            super(new FileWriter(o));\\n   ...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"PYTHON solution for \\\"As their story unravels, a timeless tale is told once again...\\n\\nShirahime, a friend of Mocha's, is keen on playing the music game Arcaea and sharing Mocha interesting puzzles to solve. This day, Shirahime comes up with a new simple puzzle and wants Mocha to solve them. However, these puzzles are too easy for Mocha to solve, so she wants you to solve them and tell her the answers. The puzzles are described as follow.\\n\\nThere are n squares arranged in a row, and each of them can be painted either red or blue.\\n\\nAmong these squares, some of them have been painted already, and the others are blank. You can decide which color to paint on each blank square.\\n\\nSome pairs of adjacent squares may have the same color, which is imperfect. We define the imperfectness as the number of pairs of adjacent squares that share the same color.\\n\\nFor example, the imperfectness of \\\"BRRRBBR\\\" is 3, with \\\"BB\\\" occurred once and \\\"RR\\\" occurred twice.\\n\\nYour goal is to minimize the imperfectness and print out the colors of the squares after painting. \\n\\nInput\\n\\nEach test contains multiple test cases. \\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 100) \u2014 the number of test cases. Each test case consists of two lines.\\n\\nThe first line of each test case contains an integer n (1\u2264 n\u2264 100) \u2014 the length of the squares row.\\n\\nThe second line of each test case contains a string s with length n, containing characters 'B', 'R' and '?'. Here 'B' stands for a blue square, 'R' for a red square, and '?' for a blank square.\\n\\nOutput\\n\\nFor each test case, print a line with a string only containing 'B' and 'R', the colors of the squares after painting, which imperfectness is minimized. If there are multiple solutions, print any of them.\\n\\nExample\\n\\nInput\\n\\n\\n5\\n7\\n?R???BR\\n7\\n???R???\\n1\\n?\\n1\\nB\\n10\\n?R??RB??B?\\n\\n\\nOutput\\n\\n\\nBRRBRBR\\nBRBRBRB\\nB\\nB\\nBRRBRBBRBR\\n\\nNote\\n\\nIn the first test case, if the squares are painted \\\"BRRBRBR\\\", the imperfectness is 1 (since squares 2 and 3 have the same color), which is the minimum possible imperfectness.\\\":\",\"targets\":\"from collections import Counter, defaultdict, deque\\nimport bisect\\nfrom sys import stdin, stdout\\nfrom itertools import repeat, permutations\\nimport math\\nimport heapq\\n\\n\\nMOD = int(1e9+7)\\n\\ndef inp(force_list=False):\\n    re = map(int, raw_input().split())\\n    if len(re) == 1 and not force_list:\\n        return re[0]\\n    return re\\n\\ndef inpf(force_list=False):\\n    re = map(float, raw_input().split())\\n    if len(re) == 1 and not force_list:\\n        return re[0]\\n    return re\\n\\ndef inst():\\n    return raw_input().strip()\\n\\ndef gcd(x, y):\\n   while(y):\\n       x, y = y, x % y\\n   return x\\n\\ndef lcm(x, y):\\n    return x*y\\/(gcd(x,y))\\n\\ndef qmod(a, b, mod=MOD):\\n    res = 1\\n    while b:\\n        if b&1:\\n            res = (res*a)%mod\\n        b >>= 1\\n        a = (a*a)%mod\\n        # print b\\n    return res\\n\\ndef inv(a):\\n    return qmod(a, MOD-2)\\n\\ndef query(num):\\n    print num\\n    stdout.flush()\\n    return inp()\\n\\nfac = [1]\\nfor i in range(1, 210000):\\n    fac.append(fac[-1]*i%MOD)\\n\\ndef C(n, k):\\n    return fac[n] * inv((fac[k]*fac[n-k])%MOD)%MOD\\n\\ndef my_main():\\n    kase = inp()\\n    pans = []\\n    cur = []\\n    for _ in range(kase):\\n        n = inp()\\n        da = list(inst())\\n        st = -1\\n        for i in range(n):\\n            if da[i] != '?':\\n                st = i\\n                break\\n        if st==-1:\\n            da[0] = 'B'\\n            st = 0\\n        last = da[st]\\n        for i in range(st, -1, -1):\\n            if da[i] == '?':\\n                if last=='B':\\n                    da[i] = 'R'\\n                else:\\n                    da[i] = 'B'\\n            last = da[i]\\n        last = da[st]\\n        for i in range(st, n):\\n            if da[i] == '?':\\n                if last=='B':\\n                    da[i] = 'R'\\n                else:\\n                    da[i] = 'B'\\n            last = da[i]\\n        pans.append(''.join(da))\\n\\n    print '\\\\n'.join(pans)\\n\\nmy_main()\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Petya has got an interesting flower. Petya is a busy person, so he sometimes forgets to water it. You are given n days from Petya's live and you have to determine what happened with his flower in the end.\\n\\nThe flower grows as follows: \\n\\n  * If the flower isn't watered for two days in a row, it dies. \\n  * If the flower is watered in the i-th day, it grows by 1 centimeter. \\n  * If the flower is watered in the i-th and in the (i-1)-th day (i > 1), then it grows by 5 centimeters instead of 1. \\n  * If the flower is not watered in the i-th day, it does not grow. \\n\\n\\n\\nAt the beginning of the 1-st day the flower is 1 centimeter tall. What is its height after n days?\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 100). Description of the test cases follows.\\n\\nThe first line of each test case contains the only integer n (1 \u2264 n \u2264 100).\\n\\nThe second line of each test case contains n integers a_1, a_2, ..., a_n (a_i = 0 or a_i = 1). If a_i = 1, the flower is watered in the i-th day, otherwise it is not watered.\\n\\nOutput\\n\\nFor each test case print a single integer k \u2014 the flower's height after n days, or -1, if the flower dies.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n3\\n1 0 1\\n3\\n0 1 1\\n4\\n1 0 0 1\\n1\\n0\\n\\n\\nOutput\\n\\n\\n3\\n7\\n-1\\n1\\nSolve the task in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint main() {\\n  int t;\\n  cin >> t;\\n  while (t--) {\\n    int n;\\n    cin >> n;\\n    int a[n];\\n    for (int i = 0; i < n; i++) {\\n      cin >> a[i];\\n    }\\n    int height = 1;\\n    if (a[0] == 1) {\\n      height++;\\n    }\\n    for (int i = 1; i < n; i++) {\\n      if (a[i - 1] & a[i]) {\\n        height += 5;\\n      } else if (a[i] == 1) {\\n        height += 1;\\n      } else if (a[i - 1] == 0 & a[i] == 0) {\\n        height = -1;\\n        break;\\n      }\\n    }\\n    cout << height << endl;\\n  }\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You are given an array a[0 \u2026 n - 1] = [a_0, a_1, \u2026, a_{n - 1}] of zeroes and ones only. Note that in this problem, unlike the others, the array indexes are numbered from zero, not from one.\\n\\nIn one step, the array a is replaced by another array of length n according to the following rules: \\n\\n  1. First, a new array a^{\u2192 d} is defined as a cyclic shift of the array a to the right by d cells. The elements of this array can be defined as a^{\u2192 d}_i = a_{(i + n - d) mod n}, where (i + n - d) mod n is the remainder of integer division of i + n - d by n. \\n\\nIt means that the whole array a^{\u2192 d} can be represented as a sequence $$$a^{\u2192 d} = [a_{n - d}, a_{n - d + 1}, \u2026, a_{n - 1}, a_0, a_1, \u2026, a_{n - d - 1}]$$$\\n\\n  2. Then each element of the array a_i is replaced by a_i  \\\\&  a^{\u2192 d}_i, where \\\\& is a logical \\\"AND\\\" operator. \\n\\n\\n\\nFor example, if a = [0, 0, 1, 1] and d = 1, then a^{\u2192 d} = [1, 0, 0, 1] and the value of a after the first step will be [0  \\\\&  1, 0  \\\\&  0, 1  \\\\&  0, 1  \\\\&  1], that is [0, 0, 0, 1].\\n\\nThe process ends when the array stops changing. For a given array a, determine whether it will consist of only zeros at the end of the process. If yes, also find the number of steps the process will take before it finishes.\\n\\nInput\\n\\nThe first line contains an integer t (1 \u2264 t \u2264 1000) \u2014 the number of test cases.\\n\\nThe next 2t lines contain descriptions of the test cases. \\n\\nThe first line of each test case description contains two integers: n (1 \u2264 n \u2264 10^6) \u2014 array size and d (1 \u2264 d \u2264 n) \u2014 cyclic shift offset. The second line of the description contains n space-separated integers a_i (0 \u2264 a_i \u2264 1) \u2014 elements of the array.\\n\\nIt is guaranteed that the sum of n over all test cases does not exceed 10^6.\\n\\nOutput\\n\\nPrint t lines, each line containing the answer to the corresponding test case. The answer to a test case should be a single integer \u2014 the number of steps after which the array will contain only zeros for the first time. If there are still elements equal to 1 in the array after the end of the process, print...\\n#incl\",\"targets\":\"ude <bits\\/stdc++.h>\\nusing namespace std;\\nstring int_to_string(long long n) {\\n  string s = \\\"\\\";\\n  while (n) {\\n    long long now = n % 10;\\n    s += now + '0';\\n    n \\/= 10;\\n  }\\n  reverse(s.begin(), s.end());\\n  return s;\\n}\\nlong long string_to_int(string s) {\\n  long long n = 0;\\n  for (int i = 0; i < (int)(s.size()); i++) {\\n    n *= 10;\\n    n += s[i] - '0';\\n  }\\n  return n;\\n}\\nvoid chmin(int &a, int b) {\\n  if (b < a) {\\n    a = b;\\n  }\\n}\\nvoid chmax(int &a, int b) {\\n  if (b > a) {\\n    a = b;\\n  }\\n}\\nconst int dx[] = {-1, 0, 1, 0};\\nconst int dy[] = {0, -1, 0, 1};\\nconst int month[2][12] = {{31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31},\\n                          {31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}};\\nconst int MAXN = 1e6 + 10;\\nint a[MAXN];\\nint dist[MAXN];\\nint n, d;\\nint nxt(int now) { return (now - d + n) % n; }\\nvoid dijkstra() {\\n  priority_queue<pair<int, int>, vector<pair<int, int> >,\\n                 greater<pair<int, int> > >\\n      pq;\\n  for (int i = 0; i < (int)(n); i++) {\\n    if (a[i] == 0) {\\n      dist[i] = 0;\\n      pq.push(pair<int, int>(0, i));\\n    }\\n  }\\n  while (!pq.empty()) {\\n    int now = pq.top().second;\\n    pq.pop();\\n    if (dist[nxt(now)] > dist[now] + 1) {\\n      dist[nxt(now)] = dist[now] + 1;\\n      pq.push(pair<int, int>(dist[nxt(now)], nxt(now)));\\n    }\\n  }\\n}\\nvoid solve() {\\n  cin >> n >> d;\\n  for (int i = 0; i < (int)(n); i++) {\\n    cin >> a[i];\\n    dist[i] = 1e9;\\n  }\\n  dijkstra();\\n  int ans = 0;\\n  for (int i = 0; i < (int)(n); i++) {\\n    chmax(ans, dist[i]);\\n  }\\n  if (ans == 1e9) {\\n    cout << -1 << endl;\\n  } else {\\n    cout << ans << endl;\\n  }\\n}\\nsigned main() {\\n  std::ios::sync_with_stdio(false);\\n  int t = 1;\\n  cin >> t;\\n  while (t--) {\\n    solve();\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"This is the hard version of the problem. The only difference between the two versions is the constraint on n. You can make hacks only if all versions of the problem are solved.\\n\\nA forest is an undirected graph without cycles (not necessarily connected).\\n\\nMocha and Diana are friends in Zhijiang, both of them have a forest with nodes numbered from 1 to n, and they would like to add edges to their forests such that: \\n\\n  * After adding edges, both of their graphs are still forests. \\n  * They add the same edges. That is, if an edge (u, v) is added to Mocha's forest, then an edge (u, v) is added to Diana's forest, and vice versa. \\n\\n\\n\\nMocha and Diana want to know the maximum number of edges they can add, and which edges to add.\\n\\nInput\\n\\nThe first line contains three integers n, m_1 and m_2 (1 \u2264 n \u2264 10^5, 0 \u2264 m_1, m_2 < n) \u2014 the number of nodes and the number of initial edges in Mocha's forest and Diana's forest.\\n\\nEach of the next m_1 lines contains two integers u and v (1 \u2264 u, v \u2264 n, u \u2260 v) \u2014 the edges in Mocha's forest.\\n\\nEach of the next m_2 lines contains two integers u and v (1 \u2264 u, v \u2264 n, u \u2260 v) \u2014 the edges in Diana's forest.\\n\\nOutput\\n\\nThe first line contains only one integer h, the maximum number of edges Mocha and Diana can add.\\n\\nEach of the next h lines contains two integers u and v (1 \u2264 u, v \u2264 n, u \u2260 v) \u2014 the edge you add each time.\\n\\nIf there are multiple correct answers, you can print any one of them.\\n\\nExamples\\n\\nInput\\n\\n\\n3 2 2\\n1 2\\n2 3\\n1 2\\n1 3\\n\\n\\nOutput\\n\\n\\n0\\n\\n\\nInput\\n\\n\\n5 3 2\\n5 4\\n2 1\\n4 3\\n4 3\\n1 4\\n\\n\\nOutput\\n\\n\\n1\\n2 4\\n\\n\\nInput\\n\\n\\n8 1 2\\n1 7\\n2 6\\n1 5\\n\\n\\nOutput\\n\\n\\n5\\n5 2\\n2 3\\n3 4\\n4 7\\n6 8\\n\\nNote\\n\\nIn the first example, we cannot add any edge.\\n\\nIn the second example, the initial forests are as follows.\\n\\n<image>\\n\\nWe can add an edge (2, 4).\\n\\n<image>\\n#incl\",\"targets\":\"ude <bits\\/stdc++.h>\\n#pragma GCC target(\\\"avx2\\\")\\n#pragma GCC optimization(\\\"O3\\\")\\n#pragma GCC optimization(\\\"unroll-loops\\\")\\nusing ll = long long int;\\nusing namespace std;\\nvector<int> par, par1;\\nint find_par(int n) {\\n  if (n == par[n]) return n;\\n  return par[n] = find_par(par[n]);\\n}\\nvoid mer(int a, int b) {\\n  int x = find_par(a);\\n  int y = find_par(b);\\n  par[x] = par[y];\\n}\\nint find_par1(int n) {\\n  if (n == par1[n]) return n;\\n  return par1[n] = find_par1(par1[n]);\\n}\\nvoid mer1(int a, int b) {\\n  int x = find_par1(a);\\n  int y = find_par1(b);\\n  par1[x] = par1[y];\\n}\\nvoid solve() {\\n  int n, e1, e2;\\n  cin >> n >> e1 >> e2;\\n  par.resize(n + 1), par1.resize(n + 1);\\n  for (int i = 1; i <= n; ++i) par[i] = par1[i] = i;\\n  while (e1--) {\\n    int a, b;\\n    cin >> a >> b;\\n    mer(a, b);\\n  }\\n  while (e2--) {\\n    int a, b;\\n    cin >> a >> b;\\n    mer1(a, b);\\n  }\\n  vector<pair<int, int>> ans;\\n  for (int i = 1; i <= n; ++i) {\\n    if (find_par(i) != find_par(1) && find_par1(i) != find_par1(1)) {\\n      mer(1, i);\\n      mer1(1, i);\\n      ans.push_back({1, i});\\n    }\\n  }\\n  int l = 1, r = 1;\\n  while (l <= n && r <= n) {\\n    int f = l, s = r;\\n    while (f <= n && find_par(1) == find_par(f)) ++f;\\n    while (s <= n && find_par1(1) == find_par1(s)) ++s;\\n    l = f, r = s;\\n    if (l <= n && r <= n && find_par(l) != find_par(r) &&\\n        find_par1(l) != find_par1(r)) {\\n      ans.push_back({l, r});\\n      mer(l, r);\\n      mer1(l, r);\\n    }\\n  }\\n  cout << ans.size() << \\\"\\\\n\\\";\\n  for (auto i : ans) {\\n    cout << i.first << \\\" \\\" << i.second << \\\"\\\\n\\\";\\n  }\\n}\\nint32_t main() {\\n  ios_base::sync_with_stdio(false);\\n  cin.tie(0);\\n  cout.tie(0);\\n  int t = 1;\\n  while (t--) {\\n    solve();\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Petya has an array of integers a_1, a_2, \u2026, a_n. He only likes sorted arrays. Unfortunately, the given array could be arbitrary, so Petya wants to sort it.\\n\\nPetya likes to challenge himself, so he wants to sort array using only 3-cycles. More formally, in one operation he can pick 3 pairwise distinct indices i, j, and k (1 \u2264 i, j, k \u2264 n) and apply i \u2192 j \u2192 k \u2192 i cycle to the array a. It simultaneously places a_i on position j, a_j on position k, and a_k on position i, without changing any other element.\\n\\nFor example, if a is [10, 50, 20, 30, 40, 60] and he chooses i = 2, j = 1, k = 5, then the array becomes [\\\\underline{50}, \\\\underline{40}, 20, 30, \\\\underline{10}, 60].\\n\\nPetya can apply arbitrary number of 3-cycles (possibly, zero). You are to determine if Petya can sort his array a, i. e. make it non-decreasing.\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 5 \u22c5 10^5). Description of the test cases follows.\\n\\nThe first line of each test case contains a single integer n (1 \u2264 n \u2264 5 \u22c5 10^5) \u2014 the length of the array a.\\n\\nThe second line of each test case contains n integers a_1, a_2, \u2026, a_n (1 \u2264 a_i \u2264 n).\\n\\nIt is guaranteed that the sum of n over all test cases does not exceed 5 \u22c5 10^5.\\n\\nOutput\\n\\nFor each test case, print \\\"YES\\\" (without quotes) if Petya can sort the array a using 3-cycles, and \\\"NO\\\" (without quotes) otherwise. You can print each letter in any case (upper or lower).\\n\\nExample\\n\\nInput\\n\\n\\n7\\n1\\n1\\n2\\n2 2\\n2\\n2 1\\n3\\n1 2 3\\n3\\n2 1 3\\n3\\n3 1 2\\n4\\n2 1 4 3\\n\\n\\nOutput\\n\\n\\nYES\\nYES\\nNO\\nYES\\nNO\\nYES\\nYES\\n\\nNote\\n\\nIn the 6-th test case Petya can use the 3-cycle 1 \u2192 3 \u2192 2 \u2192 1 to sort the array.\\n\\nIn the 7-th test case Petya can apply 1 \u2192 3 \u2192 2 \u2192 1 and make a = [1, 4, 2, 3]. Then he can apply 2 \u2192 4 \u2192 3 \u2192 2 and finally sort the array.\\nimpor\",\"targets\":\"t java.util.*;\\nimport java.io.*;\\n\\n\\/\\/\\/\\/***************************************************************************\\n \\/* public class E_Gardener_and_Tree implements Runnable{\\n\\n       public static void main(String[] args) throws Exception {\\n        new Thread(null, new E_Gardener_and_Tree(), \\\"E_Gardener_and_Tree\\\", 1<<28).start();\\n       }\\n    public void run(){\\n         WRITE YOUR CODE HERE!!!!\\n         JUST WRITE EVERYTHING HERE WHICH YOU WRITE IN MAIN!!!\\n       }\\n\\n  }\\n*\\/\\n\\/\\/\\/\\/\\/**************************************************************************\\n\\n\\npublic class D_Yet_Another_Sorting_Problem{\\n    public static void main(String[] args) {\\n        FastScanner s= new FastScanner();\\n        \\/\\/PrintWriter out=new PrintWriter(System.out);\\n        \\/\\/end of program\\n        \\/\\/out.println(answer);\\n        \\/\\/out.close();\\n        StringBuilder res = new StringBuilder();\\n        int t=s.nextInt();\\n        int p=0;\\n        while(p<t){\\n        int n=s.nextInt();\\n        long array[]= new long[n];\\n        long nice[]= new long[n+4];\\n        ArrayList<Long> list = new ArrayList<Long>();\\n        for(int i=0;i<n;i++){\\n            array[i]=s.nextLong();\\n            nice[(int)array[i]]++;\\n            list.add(array[i]);\\n        }\\n        Collections.sort(list);\\n        if(n<3){\\n            int check=0;\\n            for(int i=0;i<n;i++){\\n                long a=array[i];\\n                long b=list.get(i);\\n                if(a!=b){\\n                    check=1;\\n                    break;\\n                }\\n            }\\n            if(check==0){\\n                res.append(\\\"YES \\\\n\\\");\\n            }\\n            else{\\n                res.append(\\\"NO \\\\n\\\");\\n            }\\n        }\\n        else{\\n          \\/\\/  System.out.println(\\\"jj\\\");\\n            int flag=0;\\n            for(int i=0;i<n+4;i++){\\n               \\/\\/ System.out.println(nice[i]);\\n                if(nice[i]>1){\\n                    flag=1;\\n                    \\n                }\\n            }\\n            if(flag==1){\\n               \\/\\/ System.out.println(\\\"jj\\\");\\n               ...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Omkar is hosting tours of his country, Omkarland! There are n cities in Omkarland, and, rather curiously, there are exactly n-1 bidirectional roads connecting the cities to each other. It is guaranteed that you can reach any city from any other city through the road network.\\n\\nEvery city has an enjoyment value e. Each road has a capacity c, denoting the maximum number of vehicles that can be on it, and an associated toll t. However, the toll system in Omkarland has an interesting quirk: if a vehicle travels on multiple roads on a single journey, they pay only the highest toll of any single road on which they traveled. (In other words, they pay max t over all the roads on which they traveled.) If a vehicle traverses no roads, they pay 0 toll.\\n\\nOmkar has decided to host q tour groups. Each tour group consists of v vehicles starting at city x. (Keep in mind that a tour group with v vehicles can travel only on roads with capacity \u2265 v.) Being the tour organizer, Omkar wants his groups to have as much fun as they possibly can, but also must reimburse his groups for the tolls that they have to pay. Thus, for each tour group, Omkar wants to know two things: first, what is the enjoyment value of the city y with maximum enjoyment value that the tour group can reach from their starting city, and second, how much per vehicle will Omkar have to pay to reimburse the entire group for their trip from x to y? (This trip from x to y will always be on the shortest path from x to y.)\\n\\nIn the case that there are multiple reachable cities with the maximum enjoyment value, Omkar will let his tour group choose which one they want to go to. Therefore, to prepare for all possible scenarios, he wants to know the amount of money per vehicle that he needs to guarantee that he can reimburse the group regardless of which city they choose.\\n\\nInput\\n\\nThe first line contains two integers n and q (2 \u2264 n \u2264 2 \u22c5 10^5, 1 \u2264 q \u2264 2 \u22c5 10^5), representing the number of cities and the number of groups, respectively.\\n\\nThe next line contains n integers e_1,...\\nThe above is tricky. Write me a correct solution in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst int N = (2e5 + 5) * 2;\\nint n, q, a[N];\\nstruct Edge {\\n  int u, v, w1, w2;\\n} e[N];\\ntypedef bool (*op)(const int &, const int &);\\nstruct Kruskal {\\n  int f[N << 1];\\n  int getf(int x) { return f[x] == x ? x : f[x] = getf(f[x]); }\\n  int bz[N << 1][20], ch[N << 1][2], id[N], rt;\\n  void prepare(op cmp) {\\n    for (int i = (1); i < (n); ++i) id[i] = i;\\n    sort(id + 1, id + n, cmp);\\n    for (int i = (1); i < (n * 2); ++i) f[i] = i;\\n    for (int i = (1); i <= (n - 1); ++i) {\\n      int u = getf(e[id[i]].u), v = getf(e[id[i]].v);\\n      f[u] = f[v] = n + id[i];\\n      ch[n + id[i]][0] = u;\\n      ch[n + id[i]][1] = v;\\n      bz[u][0] = bz[v][0] = n + id[i];\\n    }\\n    for (int i = (2 * n - 1); i >= (1); --i) {\\n      if (i > n) {\\n        int u = id[i - n] + n;\\n        for (int j = (1); j <= (18); ++j) bz[u][j] = bz[bz[u][j - 1]][j - 1];\\n      } else\\n        for (int j = (1); j <= (18); ++j) bz[i][j] = bz[bz[i][j - 1]][j - 1];\\n    }\\n    rt = id[n - 1] + n;\\n  }\\n} T1, T2;\\nint dp[N][3], L[N], R[N], dfc;\\nvoid dfs1(int u) {\\n  if (T2.ch[u][0]) {\\n    int lc = T2.ch[u][0], rc = T2.ch[u][1];\\n    dfs1(lc), dfs1(rc);\\n    L[u] = L[lc], R[u] = R[rc];\\n  } else\\n    L[u] = R[u] = ++dfc;\\n}\\nvoid dfs2(int u) {\\n  if (T1.ch[u][0]) {\\n    int lc = T1.ch[u][0], rc = T1.ch[u][1];\\n    dfs2(lc), dfs2(rc);\\n    if (dp[lc][2] == dp[rc][2]) {\\n      dp[u][0] = min(dp[lc][0], dp[rc][0]);\\n      dp[u][1] = max(dp[lc][1], dp[rc][1]);\\n    } else if (dp[lc][2] > dp[rc][2]) {\\n      dp[u][0] = dp[lc][0];\\n      dp[u][1] = dp[lc][1];\\n    } else {\\n      dp[u][0] = dp[rc][0];\\n      dp[u][1] = dp[rc][1];\\n    }\\n    dp[u][2] = max(dp[lc][2], dp[rc][2]);\\n  } else {\\n    dp[u][0] = dp[u][1] = L[u];\\n    dp[u][2] = a[u];\\n  }\\n}\\nint getval(int x, int v) {\\n  if (L[x] == v) return 0;\\n  for (int i = (18); i >= (0); --i) {\\n    int y = T2.bz[x][i];\\n    if (y && (L[y] > v || v > R[y])) x = y;\\n  }\\n  return e[T2.bz[x][0] - n].w2;\\n}\\nint main() {\\n  scanf(\\\"%d%d\\\", &n, &q);\\n  for (int i = (1); i <= (n); ++i) scanf(\\\"%d\\\", a + i);\\n  for (int i =...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"She does her utmost to flawlessly carry out a person's last rites and preserve the world's balance of yin and yang.\\n\\nHu Tao, being the little prankster she is, has tried to scare you with this graph problem! You are given a connected undirected graph of n nodes with m edges. You also have q queries. Each query consists of two nodes a and b.\\n\\nInitially, all edges in the graph have a weight of 0. For each query, you must choose a simple path starting from a and ending at b. Then you add 1 to every edge along this path. Determine if it's possible, after processing all q queries, for all edges in this graph to have an even weight. If so, output the choice of paths for each query. \\n\\nIf it is not possible, determine the smallest number of extra queries you could add to make it possible. It can be shown that this number will not exceed 10^{18} under the given constraints.\\n\\nA simple path is defined as any path that does not visit a node more than once.\\n\\nAn edge is said to have an even weight if its value is divisible by 2.\\n\\nInput\\n\\nThe first line contains two integers n and m (2 \u2264 n \u2264 3 \u22c5 10^5, n-1 \u2264 m \u2264 min{\\\\left((n(n-1))\\/(2), 3 \u22c5 10^5\\\\right)}).\\n\\nEach of the next m lines contains two integers x and y (1 \u2264 x, y \u2264 n, x\u2260 y) indicating an undirected edge between node x and y. The input will not contain self-loops or duplicate edges, and the provided graph will be connected.\\n\\nThe next line contains a single integer q (1 \u2264 q \u2264 3 \u22c5 10^5).\\n\\nEach of the next q lines contains two integers a and b (1 \u2264 a, b \u2264 n, a \u2260 b), the description of each query.\\n\\nIt is guaranteed that nq \u2264 3 \u22c5 10^5.\\n\\nOutput\\n\\nIf it is possible to force all edge weights to be even, print \\\"YES\\\" on the first line, followed by 2q lines indicating the choice of path for each query in the same order the queries are given. For each query, the first line should contain a single integer x: the number of nodes in the chosen path. The next line should then contain x spaced separated integers p_i indicating the path you take (p_1 = a, p_x = b and all numbers should...\\nSolve the task in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst int N = 3e5 + 10;\\nint n, m, qq;\\nvector<int> to[N], res[N];\\nint sum[N], up[N], dep[N];\\nvoid dfs(int u, int fa) {\\n  dep[u] = dep[fa] + 1;\\n  up[u] = fa;\\n  for (int v : to[u])\\n    if (v != fa && !dep[v]) dfs(v, u);\\n}\\nint ss = 0;\\nvoid sol(int u, int fa) {\\n  if (sum[u] % 2) ++ss;\\n  for (int v : to[u]) {\\n    if (v != fa && dep[v] == dep[u] + 1) {\\n      sol(v, u);\\n    }\\n  }\\n}\\nint main() {\\n  ios::sync_with_stdio(false);\\n  cin.tie(0);\\n  cout.tie(0);\\n  cin >> n >> m;\\n  int u, v;\\n  for (int i = 1; i <= m; i++) {\\n    cin >> u >> v;\\n    to[u].push_back(v);\\n    to[v].push_back(u);\\n  }\\n  dfs(1, 1);\\n  cin >> qq;\\n  for (int i = 1; i <= qq; i++) {\\n    cin >> u >> v;\\n    vector<int> tmp;\\n    while (dep[v] > dep[u]) {\\n      tmp.push_back(v);\\n      v = up[v];\\n    }\\n    while (dep[u] > dep[v]) {\\n      res[i].push_back(u);\\n      u = up[u];\\n    }\\n    while (u != v) {\\n      res[i].push_back(u);\\n      tmp.push_back(v);\\n      u = up[u];\\n      v = up[v];\\n    }\\n    res[i].push_back(u);\\n    for (int j = tmp.size() - 1; j >= 0; j--) res[i].push_back(tmp[j]);\\n    for (int j = 0; j < res[i].size(); j++) {\\n      if (j != 0 && j != res[i].size() - 1) ++sum[res[i][j]];\\n      ++sum[res[i][j]];\\n    }\\n  }\\n  sol(1, 1);\\n  if (ss == 0) {\\n    cout << \\\"YES\\\" << endl;\\n    for (int i = 1; i <= qq; i++) {\\n      cout << res[i].size() << endl;\\n      for (int j : res[i]) cout << j << ' ';\\n      cout << endl;\\n    }\\n  } else {\\n    cout << \\\"NO\\\" << endl;\\n    cout << ss \\/ 2 << endl;\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Polycarp has found a table having an infinite number of rows and columns. The rows are numbered from 1, starting from the topmost one. The columns are numbered from 1, starting from the leftmost one.\\n\\nInitially, the table hasn't been filled and Polycarp wants to fix it. He writes integers from 1 and so on to the table as follows.\\n\\n<image> The figure shows the placement of the numbers from 1 to 10. The following actions are denoted by the arrows.\\n\\nThe leftmost topmost cell of the table is filled with the number 1. Then he writes in the table all positive integers beginning from 2 sequentially using the following algorithm.\\n\\nFirst, Polycarp selects the leftmost non-filled cell in the first row and fills it. Then, while the left neighbor of the last filled cell is filled, he goes down and fills the next cell. So he goes down until the last filled cell has a non-filled neighbor to the left (look at the vertical arrow going down in the figure above).\\n\\nAfter that, he fills the cells from the right to the left until he stops at the first column (look at the horizontal row in the figure above). Then Polycarp selects the leftmost non-filled cell in the first row, goes down, and so on.\\n\\nA friend of Polycarp has a favorite number k. He wants to know which cell will contain the number. Help him to find the indices of the row and the column, such that the intersection of the row and the column is the cell containing the number k.\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 100) \u2014 the number of test cases. Then t test cases follow.\\n\\nEach test case consists of one line containing one integer k (1 \u2264 k \u2264 10^9) which location must be found.\\n\\nOutput\\n\\nFor each test case, output in a separate line two integers r and c (r, c \u2265 1) separated by spaces \u2014 the indices of the row and the column containing the cell filled by the number k, respectively.\\n\\nExample\\n\\nInput\\n\\n\\n7\\n11\\n14\\n5\\n4\\n1\\n2\\n1000000000\\n\\n\\nOutput\\n\\n\\n2 4\\n4 3\\n1 3\\n2 1\\n1 1\\n1 2\\n31623 14130\\nimpor\",\"targets\":\"t java.io.BufferedReader;\\nimport java.io.IOException;\\nimport java.io.InputStreamReader;\\nimport java.util.*;\\n\\n\\tpublic class practice{\\n\\t\\tpublic static void main(String[] args){\\n\\t\\t\\tFastScanner r = new FastScanner();\\t\\t\\t\\t\\t\\n\\t\\t\\tint t = r.i() ,n;\\n\\t\\t\\tStringBuffer ans = new StringBuffer(\\\"\\\");\\n\\t\\t\\tint min,max;\\n\\t\\t\\tint avg;\\n\\t\\t\\tint x,y;\\n\\t\\t\\twhile(t-->0) {\\n\\t\\t\\t\\tn  =r.i();\\n\\t\\t\\t\\tmin  = (int)Math.sqrt(n);\\n\\t\\t\\t\\tmax = min;\\n\\t\\t\\t\\t\\n\\t\\t\\t\\tif(min*min != n) max++; \\n\\t\\t\\t\\t\\n\\t\\t\\t\\tavg  = (min*min+1 + max*max)\\/2;\\n\\t\\t\\t\\t\\n\\t\\t\\t\\t\\n\\t\\t\\t\\t\\n\\t\\t\\t\\tif(n>=avg) {\\n\\t\\t\\t\\t\\tx = max;\\n\\t\\t\\t\\t\\ty = max*max -n+1;\\n\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t}\\n\\t\\t\\t\\telse {\\n\\t\\t\\t\\t\\ty  =max;\\n\\t\\t\\t\\t\\tx = n - min*min;\\n\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t}\\n\\t\\t\\t\\t\\tans.append(x + \\\" \\\" + y + \\\"\\\\n\\\");\\n\\t\\t\\t\\t\\n\\t\\t\\t\\t\\n\\t\\t\\t}\\t\\t\\t\\t\\n\\t\\t\\tp(ans);\\n\\t\\t}\\n\\n\\t\\tstatic  boolean  isPrime(int n) {\\n\\t\\t\\tif(n <=1 )return false;\\n\\t\\t\\tif(n==2) return true;\\n\\t\\t\\tif(n%2==0) return false;\\n\\t\\t\\tfor(int i=3;i<=Math.sqrt(n);i+=2)\\n\\t\\t\\t\\tif(n%i==0) return false;\\n\\t\\t\\treturn true;\\n\\t\\t}\\n\\t\\t\\n\\t\\tstatic <T> void incrementCount(HashMap<T,Integer> map, T key) {\\n\\t\\t\\tif(map.containsKey(key))\\n\\t\\t\\t\\tmap.put(key, map.get(key) +1);\\n\\t\\t\\telse\\n\\t\\t\\t\\tmap.put(key, 1);\\n\\t\\t}\\n\\t\\t\\n\\t\\tprivate static int countDigits(int l) {\\n\\t\\t\\t\\tif (l >= 1000000000) return 10;\\n\\t\\t\\t\\tif (l >= 100000000) return 9;\\n\\t\\t\\t\\tif (l >= 10000000) return 8;\\n\\t\\t\\t\\tif (l >= 1000000) return 7;\\n\\t\\t\\t\\tif (l >= 100000) return 6;\\n\\t\\t\\t\\tif (l >= 10000) return 5;\\n\\t\\t\\t\\tif (l >= 1000) return 4;\\n\\t\\t\\t\\tif (l >= 100) return 3;\\n\\t\\t\\t\\tif (l >= 10) return 2;\\n\\t\\t\\t\\treturn 1;\\n\\t\\t\\t}\\n\\t\\tprivate static int countDigits(long l) {\\n\\t\\t\\t\\tif (l >= 1000000000000000000L) return 19;\\n\\t\\t\\t\\tif (l >= 100000000000000000L) return 18;\\n\\t\\t\\t\\tif (l >= 10000000000000000L) return 17;\\n\\t\\t\\t\\tif (l >= 1000000000000000L) return 16;\\n\\t\\t\\t\\tif (l >= 100000000000000L) return 15;\\n\\t\\t\\t\\tif (l >= 10000000000000L) return 14;\\n\\t\\t\\t\\tif (l >= 1000000000000L) return 13;\\n\\t\\t\\t\\tif (l >= 100000000000L) return 12;\\n\\t\\t\\t\\tif (l >= 10000000000L) return 11;\\n\\t\\t\\t\\tif (l >= 1000000000L) return 10;\\n\\t\\t\\t\\tif (l >= 100000000L) return 9;\\n\\t\\t\\t\\tif (l >= 10000000L) return 8;\\n\\t\\t\\t\\tif (l >= 1000000L) return 7;\\n\\t\\t\\t\\tif (l >= 100000L) return 6;\\n\\t\\t\\t\\tif (l >= 10000L) return 5;\\n\\t\\t\\t\\tif (l >= 1000L)...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"This is the hard version of the problem. The difference between the versions is that the hard version does require you to output the numbers of the rods to be removed. You can make hacks only if all versions of the problem are solved.\\n\\nStitch likes experimenting with different machines with his friend Sparky. Today they built another machine.\\n\\nThe main element of this machine are n rods arranged along one straight line and numbered from 1 to n inclusive. Each of these rods must carry an electric charge quantitatively equal to either 1 or -1 (otherwise the machine will not work). Another condition for this machine to work is that the sign-variable sum of the charge on all rods must be zero.\\n\\nMore formally, the rods can be represented as an array of n numbers characterizing the charge: either 1 or -1. Then the condition must hold: a_1 - a_2 + a_3 - a_4 + \u2026 = 0, or \u2211_{i=1}^n (-1)^{i-1} \u22c5 a_i = 0.\\n\\nSparky charged all n rods with an electric current, but unfortunately it happened that the rods were not charged correctly (the sign-variable sum of the charge is not zero). The friends decided to leave only some of the rods in the machine. Sparky has q questions. In the ith question Sparky asks: if the machine consisted only of rods with numbers l_i to r_i inclusive, what minimal number of rods could be removed from the machine so that the sign-variable sum of charges on the remaining ones would be zero? Also Sparky wants to know the numbers of these rods. Perhaps the friends got something wrong, and the sign-variable sum is already zero. In that case, you don't have to remove the rods at all.\\n\\nIf the number of rods is zero, we will assume that the sign-variable sum of charges is zero, that is, we can always remove all rods.\\n\\nHelp your friends and answer all of Sparky's questions!\\n\\nInput\\n\\nEach test contains multiple test cases.\\n\\nThe first line contains one positive integer t (1 \u2264 t \u2264 10^3), denoting the number of test cases. Description of the test cases follows.\\n\\nThe first line of each test case contains two positive...\\nSolve the task in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst int mod = 998244353;\\nconst int maxn = 200005;\\nmap<int, vector<int>> mp;\\nvoid go() {\\n  int n, k;\\n  cin >> n >> k;\\n  int pre[n + 5];\\n  pre[0] = 0;\\n  string s;\\n  cin >> s;\\n  s = \\\" \\\" + s;\\n  mp.clear();\\n  auto solve = [&](int l, int r) {\\n    int sum = pre[r] + pre[l - 1];\\n    return *lower_bound(mp[sum].begin(), mp[sum].end(), l);\\n  };\\n  for (int i = 1; i < n + 1; i++) {\\n    pre[i] = pre[i - 1] + (i % 2 ? 1 : -1) * (s[i] == '+' ? 1 : -1);\\n    mp[pre[i] + pre[i - 1]].push_back(i);\\n  }\\n  while (k--) {\\n    int l, r;\\n    cin >> l >> r;\\n    if (pre[r] == pre[l - 1]) {\\n      cout << 0 << '\\\\n';\\n    } else if (r % 2 - l % 2) {\\n      cout << 2 << '\\\\n';\\n      cout << l << ' ' << solve(l + 1, r) << '\\\\n';\\n    } else {\\n      cout << 1 << '\\\\n' << solve(l, r) << '\\\\n';\\n    }\\n  }\\n}\\nint main() {\\n  ios_base::sync_with_stdio(0);\\n  cin.tie(0);\\n  int c = 1;\\n  int t;\\n  if (!c) {\\n    t = 1;\\n  } else {\\n    cin >> t;\\n  }\\n  while (t--) {\\n    go();\\n  }\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"A number is called quasibinary if its decimal representation contains only digits 0 or 1. For example, numbers 0, 1, 101, 110011 \u2014 are quasibinary and numbers 2, 12, 900 are not.\\n\\nYou are given a positive integer n. Represent it as a sum of minimum number of quasibinary numbers.\\n\\nInput\\n\\nThe first line contains a single integer n (1 \u2264 n \u2264 106).\\n\\nOutput\\n\\nIn the first line print a single integer k \u2014 the minimum number of numbers in the representation of number n as a sum of quasibinary numbers.\\n\\nIn the second line print k numbers \u2014 the elements of the sum. All these numbers should be quasibinary according to the definition above, their sum should equal n. Do not have to print the leading zeroes in the numbers. The order of numbers doesn't matter. If there are multiple possible representations, you are allowed to print any of them.\\n\\nExamples\\n\\nInput\\n\\n9\\n\\n\\nOutput\\n\\n9\\n1 1 1 1 1 1 1 1 1 \\n\\n\\nInput\\n\\n32\\n\\n\\nOutput\\n\\n3\\n10 11 11 \\nThe above is tricky. Write me a correct solution in PYTHON3.\",\"targets\":\"import sys\\nMOD = 1000000007\\nii = lambda :  int(input())\\nsi = lambda :  input()\\ndgl = lambda : list(map(int, input()))\\nf = lambda :   map(int, input().split())\\nil = lambda :  list(map(int, input().split()))\\nls = lambda :  list(input())\\nfrom collections import *\\nnm=ii()\\ndef decimalToBinary(n):  \\n    return bin(n).replace(\\\"0b\\\", \\\"\\\")\\nk=[]\\nfor i in range(1,65):\\n    k.append(int(decimalToBinary(i)))\\ndp=[sys.maxsize]*(nm+1)\\ntb=[0]*(nm+1)\\ndp[0]=0\\nfor i in range(1,nm+1):\\n    for j in range(0,64):\\n        if(k[j]<=i):\\n            dp[i]=min(dp[i],dp[i-k[j]]+1)\\n            if(dp[i]==dp[i-k[j]]+1):\\n                tb[i]=k[j]\\nprint(dp[nm])\\ncurr=nm\\nwhile(curr >0):\\n    print(tb[curr],end=\\\" \\\")\\n    curr=curr-tb[curr]\",\"language\":\"python\",\"split\":\"train\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You are given an array a of n integers, and another integer k such that 2k \u2264 n.\\n\\nYou have to perform exactly k operations with this array. In one operation, you have to choose two elements of the array (let them be a_i and a_j; they can be equal or different, but their positions in the array must not be the same), remove them from the array, and add \u230a (a_i)\\/(a_j) \u230b to your score, where \u230a x\\/y \u230b is the maximum integer not exceeding x\\/y.\\n\\nInitially, your score is 0. After you perform exactly k operations, you add all the remaining elements of the array to the score.\\n\\nCalculate the minimum possible score you can get.\\n\\nInput\\n\\nThe first line of the input contains one integer t (1 \u2264 t \u2264 500) \u2014 the number of test cases.\\n\\nEach test case consists of two lines. The first line contains two integers n and k (1 \u2264 n \u2264 100; 0 \u2264 k \u2264 \u230a n\\/2 \u230b).\\n\\nThe second line contains n integers a_1, a_2, ..., a_n (1 \u2264 a_i \u2264 2 \u22c5 10^5).\\n\\nOutput\\n\\nPrint one integer \u2014 the minimum possible score you can get.\\n\\nExample\\n\\nInput\\n\\n\\n5\\n7 3\\n1 1 1 2 1 3 1\\n5 1\\n5 5 5 5 5\\n4 2\\n1 3 3 7\\n2 0\\n4 2\\n9 2\\n1 10 10 1 10 2 7 10 3\\n\\n\\nOutput\\n\\n\\n2\\n16\\n0\\n6\\n16\\n\\nNote\\n\\nLet's consider the example test.\\n\\nIn the first test case, one way to obtain a score of 2 is the following one:\\n\\n  1. choose a_7 = 1 and a_4 = 2 for the operation; the score becomes 0 + \u230a 1\\/2 \u230b = 0, the array becomes [1, 1, 1, 1, 3]; \\n  2. choose a_1 = 1 and a_5 = 3 for the operation; the score becomes 0 + \u230a 1\\/3 \u230b = 0, the array becomes [1, 1, 1]; \\n  3. choose a_1 = 1 and a_2 = 1 for the operation; the score becomes 0 + \u230a 1\\/1 \u230b = 1, the array becomes [1]; \\n  4. add the remaining element 1 to the score, so the resulting score is 2. \\n\\n\\n\\nIn the second test case, no matter which operations you choose, the resulting score is 16.\\n\\nIn the third test case, one way to obtain a score of 0 is the following one:\\n\\n  1. choose a_1 = 1 and a_2 = 3 for the operation; the score becomes 0 + \u230a 1\\/3 \u230b = 0, the array becomes [3, 7]; \\n  2. choose a_1 = 3 and a_2 = 7 for the operation; the score becomes 0 + \u230a 3\\/7 \u230b = 0, the array becomes...\\nimpor\",\"targets\":\"t sys\\nfrom collections import deque\\ninput = sys.stdin.readline\\n\\nfor __ in range(int(input())):\\n  n, k = map(int, input().split())\\n  arr = list(sorted(map(int, input().split())))\\n  big = arr[n-k:]\\n  small = arr[:n-k]\\n  answer = small[:len(small)-len(big)]\\n  # print(answer)\\n  for x, y in zip(big, small[len(small)-len(big):]):\\n    # print(x, y)\\n    if y == x:\\n      answer.append(1)\\n  print(sum(answer))\",\"language\":\"python\",\"split\":\"test\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Ari the monster always wakes up very early with the first ray of the sun and the first thing she does is feeding her squirrel.\\n\\nAri draws a regular convex polygon on the floor and numbers it's vertices 1, 2, ..., n in clockwise order. Then starting from the vertex 1 she draws a ray in the direction of each other vertex. The ray stops when it reaches a vertex or intersects with another ray drawn before. Ari repeats this process for vertex 2, 3, ..., n (in this particular order). And then she puts a walnut in each region inside the polygon.\\n\\n<image>\\n\\nAda the squirrel wants to collect all the walnuts, but she is not allowed to step on the lines drawn by Ari. That means Ada have to perform a small jump if she wants to go from one region to another. Ada can jump from one region P to another region Q if and only if P and Q share a side or a corner.\\n\\nAssuming that Ada starts from outside of the picture, what is the minimum number of jumps she has to perform in order to collect all the walnuts?\\n\\nInput\\n\\nThe first and only line of the input contains a single integer n (3 \u2264 n \u2264 54321) - the number of vertices of the regular polygon drawn by Ari.\\n\\nOutput\\n\\nPrint the minimum number of jumps Ada should make to collect all the walnuts. Note, that she doesn't need to leave the polygon after.\\n\\nExamples\\n\\nInput\\n\\n5\\n\\n\\nOutput\\n\\n9\\n\\n\\nInput\\n\\n3\\n\\n\\nOutput\\n\\n1\\n\\nNote\\n\\nOne of the possible solutions for the first sample is shown on the picture above.\\nimpor\",\"targets\":\"t java.util.Scanner;\\n\\npublic class P592B {\\n\\n\\tpublic static void main(String[] args) {\\n\\t\\t\\/\\/ TODO Auto-generated method stub\\n\\t\\tScanner sc = new Scanner(System.in);\\n\\t\\tlong n = sc.nextLong();\\n\\t\\t\\n\\t\\tSystem.out.println(((n-2)*(n-2)));\\n\\t}\\n\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"<image>\\n\\nWilliam has an array of n integers a_1, a_2, ..., a_n. In one move he can swap two neighboring items. Two items a_i and a_j are considered neighboring if the condition |i - j| = 1 is satisfied.\\n\\nWilliam wants you to calculate the minimal number of swaps he would need to perform to make it so that the array does not contain two neighboring items with the same parity.\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 10^4). Description of the test cases follows.\\n\\nThe first line of each test case contains an integer n (1 \u2264 n \u2264 10^5) which is the total number of items in William's array.\\n\\nThe second line contains n integers a_1, a_2, ..., a_n (1 \u2264 a_i \u2264 10^9) which are William's array.\\n\\nIt is guaranteed that the sum of n over all test cases does not exceed 10^5.\\n\\nOutput\\n\\nFor each test case output the minimal number of operations needed or -1 if it is impossible to get the array to a state when no neighboring numbers have the same parity.\\n\\nExample\\n\\nInput\\n\\n\\n5\\n3\\n6 6 1\\n1\\n9\\n6\\n1 1 1 2 2 2\\n2\\n8 6\\n6\\n6 2 3 4 5 1\\n\\n\\nOutput\\n\\n\\n1\\n0\\n3\\n-1\\n2\\n\\nNote\\n\\nIn the first test case the following sequence of operations would satisfy the requirements: \\n\\n  1. swap(2, 3). Array after performing the operation: [6, 1, 6] \\n\\n\\n\\nIn the second test case the array initially does not contain two neighboring items of the same parity.\\n\\nIn the third test case the following sequence of operations would satisfy the requirements: \\n\\n  1. swap(3, 4). Array after performing the operation: [1, 1, 2, 1, 2, 2] \\n  2. swap(2, 3). Array after performing the operation: [1, 2, 1, 1, 2, 2] \\n  3. swap(4, 5). Array after performing the operation: [1, 2, 1, 2, 1, 2] \\n\\n\\n\\nIn the fourth test case it is impossible to satisfy the requirements.\\n\\nIn the fifth test case the following sequence of operations would satisfy the requirements: \\n\\n  1. swap(2, 3). Array after performing the operation: [6, 3, 2, 4, 5, 1] \\n  2. swap(4, 5). Array after performing the operation: [6, 3, 2, 5, 4, 1] \\nUsing python3 can you solve the prior task?\",\"targets\":\"def main():\\n    n = int(input())\\n\\n    for i in range(n):\\n        l = int(input())\\n        arr = list(map(int, input().split()))\\n\\n        even = odd = 0\\n        evens = []\\n        odds = []\\n        for j in arr:\\n            if j % 2 == 0:\\n                even += 1\\n                evens.append(j)\\n            else:\\n                odds.append(j)\\n                odd += 1\\n\\n        if abs(odd - even) > 1:\\n            print(-1)\\n        else:\\n\\n            if even < odd:\\n                pos = 0\\n                ans = 0\\n                for p, j in enumerate(arr):\\n                    if j % 2 != 0:\\n                        ans += abs(p - pos)\\n                        pos += 2\\n                print(ans)\\n            elif even > odd:\\n                pos = 0\\n                ans = 0\\n                for p, j in enumerate(arr):\\n                    if (j & 1) == 0:\\n                        ans += abs(p - pos)\\n                        pos += 2\\n                print(ans)\\n            else:\\n                pos = 0\\n                ans = 0\\n                pos2 = 0\\n                ans2 = 0\\n                for p, j in enumerate(arr):\\n                    if (j & 1) == 0:\\n                        ans += abs(p - pos)\\n                        pos += 2\\n                for p, j in enumerate(arr):\\n                    if (j & 1) == 1:\\n                        ans2 += abs(p - pos2)\\n                        pos2 += 2\\n                print(min(ans2, ans))\\n\\nmain()\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in PYTHON3?\\nn people gathered to hold a jury meeting of the upcoming competition, the i-th member of the jury came up with a_i tasks, which they want to share with each other.\\n\\nFirst, the jury decides on the order which they will follow while describing the tasks. Let that be a permutation p of numbers from 1 to n (an array of size n where each integer from 1 to n occurs exactly once).\\n\\nThen the discussion goes as follows:\\n\\n  * If a jury member p_1 has some tasks left to tell, then they tell one task to others. Otherwise, they are skipped. \\n  * If a jury member p_2 has some tasks left to tell, then they tell one task to others. Otherwise, they are skipped. \\n  * ... \\n  * If a jury member p_n has some tasks left to tell, then they tell one task to others. Otherwise, they are skipped. \\n  * If there are still members with tasks left, then the process repeats from the start. Otherwise, the discussion ends. \\n\\n\\n\\nA permutation p is nice if none of the jury members tell two or more of their own tasks in a row. \\n\\nCount the number of nice permutations. The answer may be really large, so print it modulo 998 244 353.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases.\\n\\nThe first line of the test case contains a single integer n (2 \u2264 n \u2264 2 \u22c5 10^5) \u2014 number of jury members.\\n\\nThe second line contains n integers a_1, a_2, ..., a_n (1 \u2264 a_i \u2264 10^9) \u2014 the number of problems that the i-th member of the jury came up with.\\n\\nThe sum of n over all test cases does not exceed 2 \u22c5 10^5.\\n\\nOutput\\n\\nFor each test case, print one integer \u2014 the number of nice permutations, taken modulo 998 244 353.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n2\\n1 2\\n3\\n5 5 5\\n4\\n1 3 3 7\\n6\\n3 4 2 1 3 3\\n\\n\\nOutput\\n\\n\\n1\\n6\\n0\\n540\\n\\nNote\\n\\nExplanation of the first test case from the example:\\n\\nThere are two possible permutations, p = [1, 2] and p = [2, 1]. For p = [1, 2], the process is the following:\\n\\n  1. the first jury member tells a task; \\n  2. the second jury member tells a task; \\n  3. the first jury member doesn't have any tasks left to tell, so they are skipped;...\",\"targets\":\"#!\\/usr\\/bin\\/env python3\\n\\nimport math\\n\\nMOD = 998244353\\n\\n\\ndef solve(arr):\\n    n = len(arr)\\n    max_val = max(arr)\\n    max_count = arr.count(max_val)\\n    prev_count = arr.count(max_val - 1)\\n    res = 1\\n    extra = 1\\n\\n    for i in range(1, n + 1):\\n        res = res * i % MOD\\n        if i != prev_count + 1:\\n            extra = extra * i % MOD\\n    return res - (max_count == 1) * extra\\n\\n\\nfor _ in \\\"_\\\" * int(input()):\\n    input()\\n    print(solve(sorted([*map(int, input().split())])) % 998244353)\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"In Berland, n different types of banknotes are used. Banknotes of the i-th type have denomination 10^{a_i} burles (burles are the currency used in Berland); the denomination of banknotes of the first type is exactly 1.\\n\\nLet's denote f(s) as the minimum number of banknotes required to represent exactly s burles. For example, if the denominations of banknotes used in Berland are 1, 10 and 100, then f(59) = 14: 9 banknotes with denomination of 1 burle and 5 banknotes with denomination of 10 burles can be used to represent exactly 9 \u22c5 1 + 5 \u22c5 10 = 59 burles, and there's no way to do it with fewer banknotes.\\n\\nFor a given integer k, find the minimum positive number of burles s that cannot be represented with k or fewer banknotes (that is, f(s) > k).\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 10^4) \u2014 number of test cases.\\n\\nThe first line of each test case contains two integers n and k (1 \u2264 n \u2264 10; 1 \u2264 k \u2264 10^9).\\n\\nThe next line contains n integers a_1, a_2, ..., a_n (0 = a_1 < a_2 < ... < a_n \u2264 9).\\n\\nOutput\\n\\nFor each test case, print one integer \u2014 the minimum positive number of burles s that cannot be represented with k or fewer banknotes.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n3 13\\n0 1 2\\n2 777\\n0 4\\n3 255\\n0 1 3\\n10 1000000000\\n0 1 2 3 4 5 6 7 8 9\\n\\n\\nOutput\\n\\n\\n59\\n778\\n148999\\n999999920999999999\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint main() {\\n  int t;\\n  cin >> t;\\n  while (t--) {\\n    long long n, k;\\n    cin >> n >> k;\\n    vector<long long> den;\\n    for (int i = 0; i < n; i++) {\\n      long long a;\\n      cin >> a;\\n      den.push_back(pow(10, a));\\n    }\\n    long long ans = 0;\\n    k++;\\n    for (int i = 0; i < n; i++) {\\n      if (i == n - 1) {\\n        ans += (k * den[i]);\\n      } else {\\n        long long ct = den[i + 1] \\/ den[i];\\n        ct--;\\n        ans += den[i] * min(ct, k);\\n        k -= min(ct, k);\\n      }\\n    }\\n    if (den[0] != 1) {\\n      cout << 1 << \\\"\\\\n\\\";\\n    } else {\\n      cout << ans << \\\"\\\\n\\\";\\n    }\\n  }\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"Let N be a positive integer. You are given a string s of length N - 1, consisting of `<` and `>`.\\n\\nFind the number of permutations (p_1, p_2, \\\\ldots, p_N) of (1, 2, \\\\ldots, N) that satisfy the following condition, modulo 10^9 + 7:\\n\\n* For each i (1 \\\\leq i \\\\leq N - 1), p_i < p_{i + 1} if the i-th character in s is `<`, and p_i > p_{i + 1} if the i-th character in s is `>`.\\n\\nConstraints\\n\\n* N is an integer.\\n* 2 \\\\leq N \\\\leq 3000\\n* s is a string of length N - 1.\\n* s consists of `<` and `>`.\\n\\nInput\\n\\nInput is given from Standard Input in the following format:\\n\\n\\nN\\ns\\n\\n\\nOutput\\n\\nPrint the number of permutations that satisfy the condition, modulo 10^9 + 7.\\n\\nExamples\\n\\nInput\\n\\n4\\n<><\\n\\n\\nOutput\\n\\n5\\n\\n\\nInput\\n\\n5\\n<<<<\\n\\n\\nOutput\\n\\n1\\n\\n\\nInput\\n\\n20\\n>>>><>>><>><>>><<>>\\n\\n\\nOutput\\n\\n217136290\\\":\",\"targets\":\"#include <bits\\/stdc++.h>\\n#define mk make_pair\\nusing namespace std;\\ntypedef long long ll;\\nconst int N = 3e5;\\nconst int mod = 1e9 + 7;\\nint n;\\nchar str[N];\\nint dp[3003][3003], s[3003];\\nint main() {\\n\\tcin >> n;\\n\\tscanf(\\\"%s\\\", str + 2);\\n\\tdp[1][1] = 1;\\n\\tfor (int i = 2; i <= n; ++i) {\\n\\t\\tfor (int j = 1; j < i; ++j) \\n\\t\\t\\ts[j] = (s[j - 1] + dp[i - 1][j]) % mod; \\n\\t\\ts[i] = s[i - 1];\\n\\t\\tfor (int j = 1; j <= n; ++j) {\\n\\t\\t\\tif (str[i] == '<') {\\n\\t\\t\\t\\tdp[i][j] = s[j - 1];\\n\\t\\t\\t} else {\\n\\t\\t\\t\\tdp[i][j] = (s[i - 1] - s[j - 1] + mod) % mod;\\n\\t\\t\\t}\\n\\t\\t}\\n\\t}\\n\\tint ans = 0;\\n\\tfor (int i = 1; i <= n; ++i) (ans += dp[n][i]) %= mod;\\n\\tcout << ans;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"A famous Berland's painter Kalevitch likes to shock the public. One of his last obsessions is chess. For more than a thousand years people have been playing this old game on uninteresting, monotonous boards. Kalevitch decided to put an end to this tradition and to introduce a new attitude to chessboards.\\n\\nAs before, the chessboard is a square-checkered board with the squares arranged in a 8 \u00d7 8 grid, each square is painted black or white. Kalevitch suggests that chessboards should be painted in the following manner: there should be chosen a horizontal or a vertical line of 8 squares (i.e. a row or a column), and painted black. Initially the whole chessboard is white, and it can be painted in the above described way one or more times. It is allowed to paint a square many times, but after the first time it does not change its colour any more and remains black. Kalevitch paints chessboards neatly, and it is impossible to judge by an individual square if it was painted with a vertical or a horizontal stroke.\\n\\nKalevitch hopes that such chessboards will gain popularity, and he will be commissioned to paint chessboards, which will help him ensure a comfortable old age. The clients will inform him what chessboard they want to have, and the painter will paint a white chessboard meeting the client's requirements.\\n\\nIt goes without saying that in such business one should economize on everything \u2014 for each commission he wants to know the minimum amount of strokes that he has to paint to fulfill the client's needs. You are asked to help Kalevitch with this task.\\n\\nInput\\n\\nThe input file contains 8 lines, each of the lines contains 8 characters. The given matrix describes the client's requirements, W character stands for a white square, and B character \u2014 for a square painted black.\\n\\nIt is guaranteed that client's requirments can be fulfilled with a sequence of allowed strokes (vertical\\/column or horizontal\\/row).\\n\\nOutput\\n\\nOutput the only number \u2014 the minimum amount of rows and columns that Kalevitch has to paint on the white...\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nchar s[10][10];\\nint main() {\\n  char s1[8];\\n  int sum = 0;\\n  strcpy(s1, \\\"BBBBBBBB\\\");\\n  for (int i = 0; i < 8; i++) {\\n    cin >> s[i];\\n    if (strcmp(s[i], s1) == 0) sum++;\\n  }\\n  if (sum < 8) {\\n    for (int i = 0; i < 8; i++) {\\n      int f = 0;\\n      for (int j = 0; j < 8; j++) {\\n        if (s[j][i] == 'W') {\\n          f = 1;\\n          break;\\n        }\\n      }\\n      if (!f) sum++;\\n    }\\n    cout << sum << endl;\\n  } else\\n    cout << 8 << endl;\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"YouKn0wWho has an integer sequence a_1, a_2, \u2026, a_n. He will perform the following operation until the sequence becomes empty: select an index i such that 1 \u2264 i \u2264 |a| and a_i is not divisible by (i + 1), and erase this element from the sequence. Here |a| is the length of sequence a at the moment of operation. Note that the sequence a changes and the next operation is performed on this changed sequence.\\n\\nFor example, if a=[3,5,4,5], then he can select i = 2, because a_2 = 5 is not divisible by i+1 = 3. After this operation the sequence is [3,4,5].\\n\\nHelp YouKn0wWho determine if it is possible to erase the whole sequence using the aforementioned operation.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 10 000) \u2014 the number of test cases.\\n\\nThe first line of each test case contains a single integer n (1 \u2264 n \u2264 10^5).\\n\\nThe second line of each test case contains n integers a_1, a_2, \u2026, a_n (1 \u2264 a_i \u2264 10^9).\\n\\nIt is guaranteed that the sum of n over all test cases doesn't exceed 3 \u22c5 10^5.\\n\\nOutput\\n\\nFor each test case, print \\\"YES\\\" (without quotes) if it is possible to erase the whole sequence using the aforementioned operation, print \\\"NO\\\" (without quotes) otherwise. You can print each letter in any register (upper or lower).\\n\\nExample\\n\\nInput\\n\\n\\n5\\n3\\n1 2 3\\n1\\n2\\n2\\n7 7\\n10\\n384836991 191890310 576823355 782177068 404011431 818008580 954291757 160449218 155374934 840594328\\n8\\n6 69 696 69696 696969 6969696 69696969 696969696\\n\\n\\nOutput\\n\\n\\nYES\\nNO\\nYES\\nYES\\nNO\\n\\nNote\\n\\nIn the first test case, YouKn0wWho can perform the following operations (the erased elements are underlined): [1, \\\\underline{2}, 3] \u2192 [\\\\underline{1}, 3] \u2192 [\\\\underline{3}] \u2192 [ ].\\n\\nIn the second test case, it is impossible to erase the sequence as i can only be 1, and when i=1, a_1 = 2 is divisible by i + 1 = 2.\\nUsing cpp can you solve the prior task?\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nvoid solve() {\\n  long long int n;\\n  cin >> n;\\n  vector<long long int> v(n);\\n  for (auto &i : v) {\\n    cin >> i;\\n  }\\n  bool is = true;\\n  while (is) {\\n    is = false;\\n    n = v.size();\\n    for (long long int i = n - 1; i >= 0; --i) {\\n      if (v[i] % (i + 2) != 0) {\\n        v.erase(next(v.begin(), i));\\n        is = true;\\n        break;\\n      }\\n    }\\n  }\\n  if (v.empty()) {\\n    cout << \\\"YES\\\" << '\\\\n';\\n    ;\\n    ;\\n    return;\\n  }\\n  cout << \\\"NO\\\" << '\\\\n';\\n  ;\\n  ;\\n}\\nint32_t main() {\\n  ios_base::sync_with_stdio(false);\\n  cin.tie(0);\\n  cout.tie(0);\\n  long long int t;\\n  cin >> t;\\n  while (t--) {\\n    solve();\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"During the last Sereja's Codesecrof round the server crashed many times, so the round was decided to be made unrated for some participants. \\n\\nLet's assume that n people took part in the contest. Let's assume that the participant who got the first place has rating a1, the second place participant has rating a2, ..., the n-th place participant has rating an. Then changing the rating on the Codesecrof site is calculated by the formula <image>.\\n\\nAfter the round was over, the Codesecrof management published the participants' results table. They decided that if for a participant di < k, then the round can be considered unrated for him. But imagine the management's surprise when they found out that the participants' rating table is dynamic. In other words, when some participant is removed from the rating, he is removed from the results' table and the rating is recalculated according to the new table. And of course, all applications for exclusion from the rating are considered in view of the current table.\\n\\nWe know that among all the applications for exclusion from the rating the first application to consider is from the participant with the best rank (the rank with the minimum number), for who di < k. We also know that the applications for exclusion from rating were submitted by all participants.\\n\\nNow Sereja wonders, what is the number of participants to be excluded from the contest rating, and the numbers of the participants in the original table in the order of their exclusion from the rating. Pay attention to the analysis of the first test case for a better understanding of the statement.\\n\\nInput\\n\\nThe first line contains two integers n, k (1 \u2264 n \u2264 2\u00b7105, - 109 \u2264 k \u2264 0). The second line contains n space-separated integers a1, a2, ..., an (1 \u2264 ai \u2264 109) \u2014 ratings of the participants in the initial table.\\n\\nOutput\\n\\nPrint the numbers of participants in the order in which they were removed from the table. Print the initial numbers of the participants, that is, the numbers that the participants had in the initial...\\nUsing cpp can you solve the prior task?\",\"targets\":\"#include <bits\\/stdc++.h>\\nconst double pi = acos(-1.0), eps = 1e-9;\\nconst int dx[8] = {1, -1, 0, 0, 1, 1, -1, -1};\\nconst int dy[8] = {0, 0, 1, -1, 1, -1, -1, 1};\\nconst int MO = (int)(1e9 + 7);\\nusing namespace std;\\nint n, k;\\nlong long co;\\nlong long sum, d;\\nint main() {\\n  scanf(\\\"%d%d\\\", &n, &k);\\n  int tot = n;\\n  for (int i = 1; i <= n; i++) {\\n    int a;\\n    scanf(\\\"%d\\\", &a);\\n    long double t = (long double)(tot - co - 1) * (long double)a * co;\\n    if (t < 1e18) d = sum - (long long)(tot - co - 1) * (long long)a * co;\\n    if (t > 1e18 || d < k) {\\n      printf(\\\"%d\\\\n\\\", i);\\n      --tot;\\n      continue;\\n    }\\n    sum += co * a;\\n    ++co;\\n  }\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Andrea has come up with what he believes to be a novel sorting algorithm for arrays of length n. The algorithm works as follows.\\n\\nInitially there is an array of n integers a_1,  a_2,  ...,  a_n. Then, k steps are executed.\\n\\nFor each 1\u2264 i\u2264 k, during the i-th step the subsequence of the array a with indexes j_{i,1}< j_{i,2}< ...< j_{i, q_i} is sorted, without changing the values with the remaining indexes. So, the subsequence a_{j_{i,1}},  a_{j_{i,2}},  ...,  a_{j_{i,q_i}} is sorted and all other elements of a are left untouched.\\n\\nAndrea, being eager to share his discovery with the academic community, sent a short paper describing his algorithm to the journal \\\"Annals of Sorting Algorithms\\\" and you are the referee of the paper (that is, the person who must judge the correctness of the paper). You must decide whether Andrea's algorithm is correct, that is, if it sorts any array a of n integers.\\n\\nInput\\n\\nThe first line contains two integers n and k (1\u2264 n\u2264 40, 0\u2264 k\u2264 10) \u2014 the length of the arrays handled by Andrea's algorithm and the number of steps of Andrea's algorithm.\\n\\nThen k lines follow, each describing the subsequence considered in a step of Andrea's algorithm.\\n\\nThe i-th of these lines contains the integer q_i (1\u2264 q_i\u2264 n) followed by q_i integers j_{i,1},\\\\,j_{i,2}, ...,  j_{i,q_i} (1\u2264 j_{i,1}<j_{i,2}<\u22c5\u22c5\u22c5<j_{i,q_i}\u2264 n) \u2014 the length of the subsequence considered in the i-th step and the indexes of the subsequence.\\n\\nOutput\\n\\nIf Andrea's algorithm is correct print ACCEPTED, otherwise print REJECTED.\\n\\nExamples\\n\\nInput\\n\\n\\n4 3\\n3 1 2 3\\n3 2 3 4\\n2 1 2\\n\\n\\nOutput\\n\\n\\nACCEPTED\\n\\n\\nInput\\n\\n\\n4 3\\n3 1 2 3\\n3 2 3 4\\n3 1 3 4\\n\\n\\nOutput\\n\\n\\nREJECTED\\n\\n\\nInput\\n\\n\\n3 4\\n1 1\\n1 2\\n1 3\\n2 1 3\\n\\n\\nOutput\\n\\n\\nREJECTED\\n\\n\\nInput\\n\\n\\n5 2\\n3 2 3 4\\n5 1 2 3 4 5\\n\\n\\nOutput\\n\\n\\nACCEPTED\\n\\nNote\\n\\nExplanation of the first sample: The algorithm consists of 3 steps. The first one sorts the subsequence [a_1, a_2, a_3], the second one sorts the subsequence [a_2, a_3, a_4], the third one sorts the subsequence [a_1,a_2]. For example, if initially a=[6, 5, 6, 3], the algorithm transforms...\\n#incl\",\"targets\":\"ude <bits\\/stdc++.h>\\nusing namespace std;\\nusing bit = unsigned long long;\\nint N, K;\\nbit I[10];\\nbit msk[10][41];\\nint cnt[10];\\nint usd[40];\\nvoid ans(bool flag) {\\n  cout << (flag ? \\\"ACCEPTED\\\" : \\\"REJECTED\\\") << endl;\\n  exit(0);\\n}\\nvoid dfs(int k, bit now) {\\n  if (k == K) {\\n    now++;\\n    bit low = now & -now;\\n    if (low != now) ans(false);\\n  } else {\\n    int nc = __builtin_popcountll(now & I[k]);\\n    now &= ~I[k];\\n    for (int i = 0; i <= cnt[k]; i++) dfs(k + 1, now | msk[k][nc + i]);\\n  }\\n}\\nint main() {\\n  cin >> N >> K;\\n  for (int i = 0; i < N; i++) usd[i] = -1;\\n  for (int i = 0; i < K; i++) {\\n    int q;\\n    cin >> q;\\n    vector<int> id(q);\\n    for (int j = 0; j < q; j++) {\\n      cin >> id[j];\\n      id[j]--;\\n      I[i] |= 1LL << id[j];\\n      if (usd[id[j]] == -1) {\\n        usd[id[j]] = i;\\n        cnt[i]++;\\n      }\\n    }\\n    msk[i][0] = 0;\\n    for (int j = 0; j < q; j++) msk[i][j + 1] = msk[i][j] | 1LL << id[j];\\n  }\\n  if (N == 1) ans(true);\\n  for (int i = 0; i < N; i++)\\n    if (usd[i] == -1) ans(false);\\n  dfs(0, 0);\\n  ans(true);\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Polycarp has come up with a new game to play with you. He calls it \\\"A missing bigram\\\".\\n\\nA bigram of a word is a sequence of two adjacent letters in it.\\n\\nFor example, word \\\"abbaaba\\\" contains bigrams \\\"ab\\\", \\\"bb\\\", \\\"ba\\\", \\\"aa\\\", \\\"ab\\\" and \\\"ba\\\".\\n\\nThe game goes as follows. First, Polycarp comes up with a word, consisting only of lowercase letters 'a' and 'b'. Then, he writes down all its bigrams on a whiteboard in the same order as they appear in the word. After that, he wipes one of them off the whiteboard.\\n\\nFinally, Polycarp invites you to guess what the word that he has come up with was.\\n\\nYour goal is to find any word such that it's possible to write down all its bigrams and remove one of them, so that the resulting sequence of bigrams is the same as the one Polycarp ended up with.\\n\\nThe tests are generated in such a way that the answer exists. If there are multiple answers, you can print any of them.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 2000) \u2014 the number of testcases.\\n\\nThe first line of each testcase contains a single integer n (3 \u2264 n \u2264 100) \u2014 the length of the word Polycarp has come up with.\\n\\nThe second line of each testcase contains n-2 bigrams of that word, separated by a single space. Each bigram consists of two letters, each of them is either 'a' or 'b'.\\n\\nAdditional constraint on the input: there exists at least one string such that it is possible to write down all its bigrams, except one, so that the resulting sequence is the same as the sequence in the input. In other words, the answer exists.\\n\\nOutput\\n\\nFor each testcase print a word, consisting of n letters, each of them should be either 'a' or 'b'. It should be possible to write down all its bigrams and remove one of them, so that the resulting sequence of bigrams is the same as the one Polycarp ended up with.\\n\\nThe tests are generated in such a way that the answer exists. If there are multiple answers, you can print any of them. \\n\\nExample\\n\\nInput\\n\\n\\n4\\n7\\nab bb ba aa ba\\n7\\nab ba aa ab ba\\n3\\naa\\n5\\nbb ab...\\nSolve the task in JAVA.\",\"targets\":\"import java.io.*;\\nimport java.util.*;\\n\\npublic class B {\\n    public static void main(String[] args) {\\n        for (int i = 0; i < N; i++) {\\n            solve();\\n        }\\n        out.close();\\n    }\\n\\n    public static void solve() {\\n        int M = sc.nextInt();\\n        String str = sc.nextLine();\\n        String[] biGram = str.split(\\\" \\\");\\n        int lost = M-3;\\n        for (int i = 0; i < M - 3; i++) {\\n            if(biGram[i].charAt(1) != biGram[i+1].charAt(0)){\\n                lost = i;\\n                break;\\n            }\\n        }\\n        for (int i = 0; i < M - 2; i++){\\n            out.print(biGram[i].charAt(0));\\n            if(lost == i){\\n                out.print(biGram[i].charAt(1));\\n            }\\n        }\\n        out.print(biGram[M-3].charAt(1));\\n        out.println();\\n    }\\n\\n    private static PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));\\n\\n    private static MyScanner sc = new MyScanner();\\n\\n    private static int N = sc.nextInt();\\n\\n    private static class MyScanner {\\n        BufferedReader br;\\n        StringTokenizer st;\\n\\n        public MyScanner() {\\n            br = new BufferedReader(new InputStreamReader(System.in));\\n        }\\n\\n        String next() {\\n            while (st == null || !st.hasMoreElements()) {\\n                try {\\n                    st = new StringTokenizer(br.readLine());\\n                } catch (IOException e) {\\n                    e.printStackTrace();\\n                }\\n            }\\n            return st.nextToken();\\n        }\\n\\n        int nextInt() {\\n            return Integer.parseInt(next());\\n        }\\n\\n        long nextLong() {\\n            return Long.parseLong(next());\\n        }\\n\\n        double nextDouble() {\\n            return Double.parseDouble(next());\\n        }\\n\\n        String nextLine() {\\n            String str = \\\"\\\";\\n            try {\\n                str = br.readLine();\\n            } catch (IOException e) {\\n                e.printStackTrace();\\n            }\\n            return str;\\n        }\\n    }\\n\\n    private static String build(List...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Alice has just learned addition. However, she hasn't learned the concept of \\\"carrying\\\" fully \u2014 instead of carrying to the next column, she carries to the column two columns to the left.\\n\\nFor example, the regular way to evaluate the sum 2039 + 2976 would be as shown: \\n\\n<image>\\n\\nHowever, Alice evaluates it as shown: \\n\\n<image>\\n\\nIn particular, this is what she does: \\n\\n  * add 9 and 6 to make 15, and carry the 1 to the column two columns to the left, i. e. to the column \\\"0 9\\\"; \\n  * add 3 and 7 to make 10 and carry the 1 to the column two columns to the left, i. e. to the column \\\"2 2\\\"; \\n  * add 1, 0, and 9 to make 10 and carry the 1 to the column two columns to the left, i. e. to the column above the plus sign; \\n  * add 1, 2 and 2 to make 5; \\n  * add 1 to make 1. \\n\\nThus, she ends up with the incorrect result of 15005.\\n\\nAlice comes up to Bob and says that she has added two numbers to get a result of n. However, Bob knows that Alice adds in her own way. Help Bob find the number of ordered pairs of positive integers such that when Alice adds them, she will get a result of n. Note that pairs (a, b) and (b, a) are considered different if a \u2260 b.\\n\\nInput\\n\\nThe input consists of multiple test cases. The first line contains an integer t (1 \u2264 t \u2264 1000) \u2014 the number of test cases. The description of the test cases follows.\\n\\nThe only line of each test case contains an integer n (2 \u2264 n \u2264 10^9) \u2014 the number Alice shows Bob.\\n\\nOutput\\n\\nFor each test case, output one integer \u2014 the number of ordered pairs of positive integers such that when Alice adds them, she will get a result of n. \\n\\nExample\\n\\nInput\\n\\n\\n5\\n100\\n12\\n8\\n2021\\n10000\\n\\n\\nOutput\\n\\n\\n9\\n4\\n7\\n44\\n99\\n\\nNote\\n\\nIn the first test case, when Alice evaluates any of the sums 1 + 9, 2 + 8, 3 + 7, 4 + 6, 5 + 5, 6 + 4, 7 + 3, 8 + 2, or 9 + 1, she will get a result of 100. The picture below shows how Alice evaluates 6 + 4: \\n\\n<image>\\nSolve the task in JAVA.\",\"targets\":\"import java.io.BufferedReader;\\nimport java.io.IOException;\\nimport java.io.InputStreamReader;\\nimport java.io.File;\\nimport java.io.*;\\nimport java.util.*;\\n\\npublic class Main {\\n\\n    \\/\\/ static final File ip = new File(\\\"input.txt\\\");\\n    \\/\\/ static final File op = new File(\\\"output.txt\\\");\\n    \\/\\/ static {\\n    \\/\\/     try {\\n    \\/\\/         System.setOut(new PrintStream(op));\\n    \\/\\/         System.setIn(new FileInputStream(ip));\\n    \\/\\/     } catch (Exception e) {\\n    \\/\\/     }\\n    \\/\\/ }\\n\\n    public static void main(String[] args) {\\n        FastReader sc = new FastReader();\\n        int test = sc.nextInt();\\n        while (test-- != 0) {\\n            long n = sc.nextLong();\\n            if(n\\/10 == 0)\\n            {\\n                System.out.println(n-1);\\n                continue;\\n            }\\n            StringBuilder f = new StringBuilder(\\\"\\\");\\n            StringBuilder s = new StringBuilder(\\\"\\\");\\n            int c = 0;\\n            while (n != 0) {\\n                char ch = (char) (n % 10 + '0');\\n                n \\/= 10;\\n                if (c == 0)\\n                    f.append(ch);\\n                else\\n                    s.append(ch);\\n                c^=1;\\n            }\\n            int num1 = Integer.parseInt(f.reverse().toString());\\n            int num2 = Integer.parseInt(s.reverse().toString());\\n            System.out.println((num1+1)*(num2+1) - 2);\\n        }\\n    }\\n\\n    static long power(long x, long y, long p) {\\n        long res = 1;\\n        x = x % p;\\n        if (x == 0)\\n            return 0;\\n        while (y > 0) {\\n            if ((y & 1) != 0)\\n                res = (res * x) % p;\\n            y = y >> 1;\\n            x = (x * x) % p;\\n        }\\n        return res;\\n    }\\n\\n    public static int countSetBits(long number) {\\n        int count = 0;\\n        while (number > 0) {\\n            ++count;\\n            number &= number - 1;\\n        }\\n        return count;\\n    }\\n\\n    private static <T> void swap(int[] a, int i, int j) {\\n        int tmp = a[i];\\n        a[i] = a[j];\\n        a[j] = tmp;\\n    }\\n\\n    static class pair {\\n       ...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Consider a sequence of integers a_1, a_2, \u2026, a_n. In one move, you can select any element of the sequence and delete it. After an element is deleted, all elements to the right are shifted to the left by 1 position, so there are no empty spaces in the sequence. So after you make a move, the sequence's length decreases by 1. The indices of the elements after the move are recalculated.\\n\\nE. g. let the sequence be a=[3, 2, 2, 1, 5]. Let's select the element a_3=2 in a move. Then after the move the sequence will be equal to a=[3, 2, 1, 5], so the 3-rd element of the new sequence will be a_3=1 and the 4-th element will be a_4=5.\\n\\nYou are given a sequence a_1, a_2, \u2026, a_n and a number k. You need to find the minimum number of moves you have to make so that in the resulting sequence there will be at least k elements that are equal to their indices, i. e. the resulting sequence b_1, b_2, \u2026, b_m will contain at least k indices i such that b_i = i.\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 100) \u2014 the number of test cases. Then t test cases follow.\\n\\nEach test case consists of two consecutive lines. The first line contains two integers n and k (1 \u2264 k \u2264 n \u2264 2000). The second line contains a sequence of integers a_1, a_2, \u2026, a_n (1 \u2264 a_i \u2264 n). The numbers in the sequence are not necessarily different.\\n\\nIt is guaranteed that the sum of n over all test cases doesn't exceed 2000.\\n\\nOutput\\n\\nFor each test case output in a single line:\\n\\n  * -1 if there's no desired move sequence; \\n  * otherwise, the integer x (0 \u2264 x \u2264 n) \u2014 the minimum number of the moves to be made so that the resulting sequence will contain at least k elements that are equal to their indices. \\n\\nExample\\n\\nInput\\n\\n\\n4\\n7 6\\n1 1 2 3 4 5 6\\n5 2\\n5 1 3 2 3\\n5 2\\n5 5 5 5 4\\n8 4\\n1 2 3 3 2 2 5 5\\n\\n\\nOutput\\n\\n\\n1\\n2\\n-1\\n2\\n\\nNote\\n\\nIn the first test case the sequence doesn't satisfy the desired condition, but it can be provided by deleting the first element, hence the sequence will be [1, 2, 3, 4, 5, 6] and 6 elements will be equal to their indices.\\n\\nIn the second test case...\\nThe above is tricky. Write me a correct solution in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nmt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());\\nmt19937 rnf(2106);\\nconst int N = 2003, INF = 1000000009;\\nint n, k;\\nint a[N];\\nint dp[N][N];\\nvoid solv() {\\n  cin >> n >> k;\\n  for (int i = 1; i <= n; ++i) cin >> a[i];\\n  for (int i = 0; i <= n; ++i) {\\n    for (int j = 0; j <= n; ++j) {\\n      dp[i][j] = -INF;\\n    }\\n  }\\n  dp[0][0] = 0;\\n  for (int i = 1; i <= n; ++i) {\\n    for (int j = 0; j <= n; ++j) {\\n      if (i - j == a[i])\\n        dp[i][j] = max(dp[i][j], dp[i - 1][j] + 1);\\n      else\\n        dp[i][j] = max(dp[i][j], dp[i - 1][j]);\\n      if (j > 0) dp[i][j] = max(dp[i][j], dp[i - 1][j - 1]);\\n    }\\n  }\\n  for (int j = 0; j <= n; ++j) {\\n    if (dp[n][j] >= k) {\\n      cout << j << \\\"\\\\n\\\";\\n      return;\\n    }\\n  }\\n  cout << \\\"-1\\\\n\\\";\\n}\\nint main() {\\n  ios_base::sync_with_stdio(false), cin.tie(0);\\n  int tt = 1;\\n  cin >> tt;\\n  while (tt--) {\\n    solv();\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in CPP?\\nLimak is a little polar bear. He doesn't have many toys and thus he often plays with polynomials.\\n\\nHe considers a polynomial valid if its degree is n and its coefficients are integers not exceeding k by the absolute value. More formally:\\n\\nLet a0, a1, ..., an denote the coefficients, so <image>. Then, a polynomial P(x) is valid if all the following conditions are satisfied:\\n\\n  * ai is integer for every i; \\n  * |ai| \u2264 k for every i; \\n  * an \u2260 0. \\n\\n\\n\\nLimak has recently got a valid polynomial P with coefficients a0, a1, a2, ..., an. He noticed that P(2) \u2260 0 and he wants to change it. He is going to change one coefficient to get a valid polynomial Q of degree n that Q(2) = 0. Count the number of ways to do so. You should count two ways as a distinct if coefficients of target polynoms differ.\\n\\nInput\\n\\nThe first line contains two integers n and k (1 \u2264 n \u2264 200 000, 1 \u2264 k \u2264 109) \u2014 the degree of the polynomial and the limit for absolute values of coefficients.\\n\\nThe second line contains n + 1 integers a0, a1, ..., an (|ai| \u2264 k, an \u2260 0) \u2014 describing a valid polynomial <image>. It's guaranteed that P(2) \u2260 0.\\n\\nOutput\\n\\nPrint the number of ways to change one coefficient to get a valid polynomial Q that Q(2) = 0.\\n\\nExamples\\n\\nInput\\n\\n3 1000000000\\n10 -9 -3 5\\n\\n\\nOutput\\n\\n3\\n\\n\\nInput\\n\\n3 12\\n10 -9 -3 5\\n\\n\\nOutput\\n\\n2\\n\\n\\nInput\\n\\n2 20\\n14 -7 19\\n\\n\\nOutput\\n\\n0\\n\\nNote\\n\\nIn the first sample, we are given a polynomial P(x) = 10 - 9x - 3x2 + 5x3.\\n\\nLimak can change one coefficient in three ways:\\n\\n  1. He can set a0 = - 10. Then he would get Q(x) = - 10 - 9x - 3x2 + 5x3 and indeed Q(2) = - 10 - 18 - 12 + 40 = 0. \\n  2. Or he can set a2 = - 8. Then Q(x) = 10 - 9x - 8x2 + 5x3 and indeed Q(2) = 10 - 18 - 32 + 40 = 0. \\n  3. Or he can set a1 = - 19. Then Q(x) = 10 - 19x - 3x2 + 5x3 and indeed Q(2) = 10 - 38 - 12 + 40 = 0. \\n\\n\\n\\nIn the second sample, we are given the same polynomial. This time though, k is equal to 12 instead of 109. Two first of ways listed above are still valid but in the third way we would get |a1| > k what is not allowed. Thus, the answer is 2 this time.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst int N = 200005;\\nint x[N], a[N];\\nint main() {\\n  int j, n, i, k, ans = 0;\\n  cin >> n >> k;\\n  for (i = 0; i <= n; ++i) {\\n    int num;\\n    scanf(\\\"%d\\\", &num);\\n    x[i] += num;\\n    a[i] = num;\\n    x[i + 1] += x[i] \\/ 2;\\n    x[i] %= 2;\\n  }\\n  long long cur = x[n + 1];\\n  int pos;\\n  for (i = 0; i <= n; ++i) {\\n    pos = i;\\n    if (x[i] != 0) break;\\n  }\\n  for (i = n; i >= 0; --i) {\\n    cur = cur * 2;\\n    cur += x[i];\\n    if (abs(cur) > k * 2) break;\\n    if (pos < i) continue;\\n    if (abs(cur - a[i]) <= k && (i != n || cur != a[i])) ans++;\\n  }\\n  cout << ans << endl;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"JAVA solution for \\\"Alice has an empty grid with n rows and m columns. Some of the cells are marked, and no marked cells are adjacent to the edge of the grid. (Two squares are adjacent if they share a side.) \\n\\nAlice wants to fill each cell with a number such that the following statements are true: \\n\\n  * every unmarked cell contains either the number 1 or 4; \\n  * every marked cell contains the sum of the numbers in all unmarked cells adjacent to it (if a marked cell is not adjacent to any unmarked cell, this sum is 0); \\n  * every marked cell contains a multiple of 5. \\n\\nAlice couldn't figure it out, so she asks Bob to help her. Help Bob find any such grid, or state that no such grid exists.\\n\\nInput\\n\\nThe first line of input contains two integers n and m (1 \u2264 n, m \u2264 500) \u2014 the number of rows and the number of columns in the grid, respectively.\\n\\nThen n lines follow, each containing m characters. Each of these characters is either '.' or 'X' \u2014 an unmarked and a marked cell, respectively. No marked cells are adjacent to the edge of the grid.\\n\\nOutput\\n\\nOutput \\\"'NO\\\" if no suitable grid exists. Otherwise, output \\\"'YES\\\"'. Then output n lines of m space-separated integers \u2014 the integers in the grid.\\n\\nExamples\\n\\nInput\\n\\n\\n5 5\\n.....\\n.XXX.\\n.X.X.\\n.XXX.\\n.....\\n\\n\\nOutput\\n\\n\\nYES\\n4 1 4 4 1\\n4 5 5 5 1\\n4 5 1 5 4\\n1 5 5 5 4\\n1 4 4 1 4\\n\\n\\nInput\\n\\n\\n5 5\\n.....\\n.XXX.\\n.XXX.\\n.XXX.\\n.....\\n\\n\\nOutput\\n\\n\\nNO\\n\\n\\nInput\\n\\n\\n3 2\\n..\\n..\\n..\\n\\n\\nOutput\\n\\n\\nYES\\n4 1\\n4 1\\n1 4\\n\\n\\nInput\\n\\n\\n9 9\\n.........\\n.XXXXX.X.\\n.X...X...\\n.X.XXXXX.\\n.X.X.X.X.\\n.X.XXX.X.\\n.X.....X.\\n.XXXXXXX.\\n.........\\n\\n\\nOutput\\n\\n\\nYES\\n4 4 4 1 4 1 4 1 4\\n1 5 5 5 5 5 4 10 1\\n4 5 1 4 1 5 4 4 4\\n4 5 1 5 5 0 5 5 1\\n4 5 1 5 4 5 1 5 4\\n4 5 1 5 5 5 4 5 1\\n1 5 4 4 1 1 4 5 1\\n4 5 5 5 5 5 5 5 4\\n1 1 1 1 4 4 1 1 4\\n\\nNote\\n\\nIt can be shown that no such grid exists for the second test.\\\":\",\"targets\":\"import javafx.util.Pair;\\n\\nimport java.util.*;\\n\\npublic class F {\\n  private static final Scanner scanner = new Scanner(System.in);\\n\\n  public static void main(String[] args) {\\n\\n    int[] dx = new int[]{-1, 0, 1, 0};\\n    int[] dy = new int[]{0, 1, 0, -1};\\n    String[] nm = scanner.nextLine().split(\\\" \\\");\\n    int n = Integer.parseInt(nm[0]);\\n    int m = Integer.parseInt(nm[1]);\\n\\n    String[][] input = new String[n][m];\\n\\n    for (int i = 0; i < n; i++) {\\n      String[] row = scanner.nextLine().split(\\\"\\\");\\n      for (int j = 0; j < m; j++) {\\n        input[i][j] = row[j];\\n      }\\n    }\\n\\n    ArrayList<ArrayList<Integer>> aroundXs = new ArrayList<>(n*m);\\n\\n    for (int i = 0; i < n * m; i++) {\\n      aroundXs.add(new ArrayList<>());\\n    }\\n\\n    for (int i = 1; i < n - 1; i++) {\\n      for (int j = 1; j < m - 1; j++) {\\n        if (input[i][j].equals(\\\"X\\\")) {\\n          List<Integer> aroundX = new ArrayList<>();\\n          for (int k = 0; k < 4; k++) {\\n            int x = i + dx[k];\\n            int y = j + dy[k];\\n\\n            if (input[x][y].equals(\\\".\\\")) {\\n              aroundX.add(x*m + y);\\n            }\\n          }\\n\\n          if (aroundX.size() % 2 != 0) {\\n            System.out.println(\\\"NO\\\");\\n            return;\\n          } else if (aroundX.size() == 2) {\\n            aroundXs.get(aroundX.get(0)).add(aroundX.get(1));\\n            aroundXs.get(aroundX.get(1)).add(aroundX.get(0));\\n          } else if (aroundX.size() == 4) {\\n            aroundXs.get(aroundX.get(0)).add(aroundX.get(1));\\n            aroundXs.get(aroundX.get(1)).add(aroundX.get(0));\\n            aroundXs.get(aroundX.get(2)).add(aroundX.get(3));\\n            aroundXs.get(aroundX.get(3)).add(aroundX.get(2));\\n          }\\n        }\\n      }\\n    }\\n\\n    ArrayList<ArrayList<Integer>> finalVector = new ArrayList<>();\\n\\n    for (int i = 0; i < n; i++) {\\n      ArrayList<Integer> temp = new ArrayList<>();\\n      for (int j = 0; j < m; j++) {\\n        temp.add(-1);\\n      }\\n      finalVector.add(temp);\\n    }\\n\\n    for (int i = 0; i < n; i++) {\\n      for (int j = 0; j < m; j++) {\\n       ...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Codehorses has just hosted the second Codehorses Cup. This year, the same as the previous one, organizers are giving T-shirts for the winners.\\n\\nThe valid sizes of T-shirts are either \\\"M\\\" or from 0 to 3 \\\"X\\\" followed by \\\"S\\\" or \\\"L\\\". For example, sizes \\\"M\\\", \\\"XXS\\\", \\\"L\\\", \\\"XXXL\\\" are valid and \\\"XM\\\", \\\"Z\\\", \\\"XXXXL\\\" are not.\\n\\nThere are n winners to the cup for both the previous year and the current year. Ksenia has a list with the T-shirt sizes printed for the last year cup and is yet to send the new list to the printing office. \\n\\nOrganizers want to distribute the prizes as soon as possible, so now Ksenia is required not to write the whole list from the scratch but just make some changes to the list of the previous year. In one second she can choose arbitrary position in any word and replace its character with some uppercase Latin letter. Ksenia can't remove or add letters in any of the words.\\n\\nWhat is the minimal number of seconds Ksenia is required to spend to change the last year list to the current one?\\n\\nThe lists are unordered. That means, two lists are considered equal if and only if the number of occurrences of any string is the same in both lists.\\n\\nInput\\n\\nThe first line contains one integer n (1 \u2264 n \u2264 100) \u2014 the number of T-shirts.\\n\\nThe i-th of the next n lines contains a_i \u2014 the size of the i-th T-shirt of the list for the previous year.\\n\\nThe i-th of the next n lines contains b_i \u2014 the size of the i-th T-shirt of the list for the current year.\\n\\nIt is guaranteed that all the sizes in the input are valid. It is also guaranteed that Ksenia can produce list b from the list a.\\n\\nOutput\\n\\nPrint the minimal number of seconds Ksenia is required to spend to change the last year list to the current one. If the lists are already equal, print 0.\\n\\nExamples\\n\\nInput\\n\\n3\\nXS\\nXS\\nM\\nXL\\nS\\nXS\\n\\n\\nOutput\\n\\n2\\n\\n\\nInput\\n\\n2\\nXXXL\\nXXL\\nXXL\\nXXXS\\n\\n\\nOutput\\n\\n1\\n\\n\\nInput\\n\\n2\\nM\\nXS\\nXS\\nM\\n\\n\\nOutput\\n\\n0\\n\\nNote\\n\\nIn the first example Ksenia can replace \\\"M\\\" with \\\"S\\\" and \\\"S\\\" in one of the occurrences of \\\"XS\\\" with \\\"L\\\".\\n\\nIn the second example Ksenia should replace \\\"L\\\" in...\\n#incl\",\"targets\":\"ude <bits\\/stdc++.h>\\nusing namespace std;\\nint main() {\\n  ios_base::sync_with_stdio(false);\\n  cin.tie(NULL);\\n  cout.tie(NULL);\\n  long long int n;\\n  cin >> n;\\n  long long int k = 2 * n;\\n  string s[k];\\n  long long int i;\\n  vector<string> v[5], v1[5];\\n  for (i = 0; i < k; i++) {\\n    cin >> s[i];\\n  }\\n  for (i = 0; i < n; i++) {\\n    v[s[i].length()].push_back(s[i]);\\n  }\\n  for (i = n; i < k; i++) {\\n    v1[s[i].length()].push_back(s[i]);\\n  }\\n  string s1 = \\\"SLM\\\";\\n  long long int c = 0, j;\\n  for (i = 1; i <= 4; i++) {\\n    map<char, long long int> m, m1;\\n    for (j = 0; j < v[i].size(); j++) {\\n      string s2 = v[i][j];\\n      m[s2[i - 1]]++;\\n    }\\n    for (j = 0; j < v1[i].size(); j++) {\\n      string s2 = v1[i][j];\\n      m1[s2[i - 1]]++;\\n    }\\n    for (j = 0; j < 3; j++) {\\n      if (m[s1[j]] - m1[s1[j]] > 0) {\\n        c += m[s1[j]] - m1[s1[j]];\\n      }\\n    }\\n  }\\n  cout << c << endl;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in PYTHON3?\\nA bow adorned with nameless flowers that bears the earnest hopes of an equally nameless person.\\n\\nYou have obtained the elegant bow known as the Windblume Ode. Inscribed in the weapon is an array of n (n \u2265 3) positive distinct integers (i.e. different, no duplicates are allowed).\\n\\nFind the largest subset (i.e. having the maximum number of elements) of this array such that its sum is a composite number. A positive integer x is called composite if there exists a positive integer y such that 1 < y < x and x is divisible by y.\\n\\nIf there are multiple subsets with this largest size with the composite sum, you can output any of them. It can be proven that under the constraints of the problem such a non-empty subset always exists.\\n\\nInput\\n\\nEach test consists of multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 100). Description of the test cases follows.\\n\\nThe first line of each test case contains an integer n (3 \u2264 n \u2264 100) \u2014 the length of the array.\\n\\nThe second line of each test case contains n distinct integers a_{1},a_{2},...,a_{n} (1 \u2264 a_{i} \u2264 200) \u2014 the elements of the array.\\n\\nOutput\\n\\nEach test case should have two lines of output.\\n\\nThe first line should contain a single integer x: the size of the largest subset with composite sum. The next line should contain x space separated integers representing the indices of the subset of the initial array.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n3\\n8 1 2\\n4\\n6 9 4 2\\n9\\n1 2 3 4 5 6 7 8 9\\n3\\n200 199 198\\n\\n\\nOutput\\n\\n\\n2\\n2 1\\n4\\n2 1 4 3\\n9\\n6 9 1 2 3 4 5 7 8\\n3\\n1 2 3 \\n\\nNote\\n\\nIn the first test case, the subset \\\\\\\\{a_2, a_1\\\\} has a sum of 9, which is a composite number. The only subset of size 3 has a prime sum equal to 11. Note that you could also have selected the subset \\\\\\\\{a_1, a_3\\\\} with sum 8 + 2 = 10, which is composite as it's divisible by 2.\\n\\nIn the second test case, the sum of all elements equals to 21, which is a composite number. Here we simply take the whole array as our subset.\",\"targets\":\"def p(n):\\n    if n<=1:\\n        return 0\\n    for i in range(2,int(n**.5)+1):\\n        if n%i==0:\\n            return 0\\n    return 1\\nfor _ in range(int(input())):\\n    n=int(input())\\n    l=list(map(int,input().split()))\\n    ans=[i for i in range(1,n+1)]\\n    s=sum(l)\\n    if not p(s):\\n        print(n)\\n        print(*ans)\\n    else:\\n        for i in range(n):\\n            if l[i]%2!=0:\\n                ans.remove(i+1)\\n                break\\n        print(n-1)\\n        print(*ans)\",\"language\":\"python\",\"split\":\"test\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"The only difference between this problem and D2 is that you don't have to provide the way to construct the answer in this problem, but you have to do it in D2.\\n\\nThere's a table of n \u00d7 m cells (n rows and m columns). The value of n \u22c5 m is even.\\n\\nA domino is a figure that consists of two cells having a common side. It may be horizontal (one of the cells is to the right of the other) or vertical (one of the cells is above the other).\\n\\nYou need to find out whether it is possible to place nm\\/2 dominoes on the table so that exactly k of them are horizontal and all the other dominoes are vertical. The dominoes cannot overlap and must fill the whole table.\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 10) \u2014 the number of test cases. Then t test cases follow.\\n\\nEach test case consists of a single line. The line contains three integers n, m, k (1 \u2264 n,m \u2264 100, 0 \u2264 k \u2264 nm\\/2, n \u22c5 m is even) \u2014 the number of rows, columns and horizontal dominoes, respectively.\\n\\nOutput\\n\\nFor each test case output \\\"YES\\\", if it is possible to place dominoes in the desired way, or \\\"NO\\\" otherwise.\\n\\nYou may print each letter in any case (YES, yes, Yes will all be recognized as positive answer, NO, no and nO will all be recognized as negative answer).\\n\\nExample\\n\\nInput\\n\\n\\n8\\n4 4 2\\n2 3 0\\n3 2 3\\n1 2 0\\n2 4 2\\n5 2 2\\n2 17 16\\n2 1 1\\n\\n\\nOutput\\n\\n\\nYES\\nYES\\nYES\\nNO\\nYES\\nNO\\nYES\\nNO\\\":\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nnamespace my {\\ntemplate <typename T>\\nclass vector : public std::vector<T> {\\n public:\\n  vector() {}\\n  vector(int n) { this->reserve(n); }\\n  vector(std::initializer_list<T> ls) {\\n    for (auto i : ls) this->push_back(i);\\n  }\\n  void push_input(size_t n) {\\n    for (size_t i{0ULL}; i != n; ++i) {\\n      T store;\\n      cin >> store;\\n      this->push_back(store);\\n    }\\n  }\\n};\\n}  \\/\\/ namespace my\\nint recur_depth = 0;\\ntemplate <typename Ostream, typename Cont>\\ntypename enable_if<is_same<Ostream, ostream>::value, Ostream&>::type operator<<(\\n    Ostream& os, const Cont& v) {\\n  os << \\\"[\\\";\\n  for (auto& x : v) {\\n    os << x << \\\", \\\";\\n  }\\n  return os << \\\"]\\\";\\n}\\ntemplate <typename T1, typename T2>\\nstd::istream& operator>>(std::istream& in, pair<T1, T2>& P) {\\n  in >> P.first >> P.second;\\n  return in;\\n}\\ntemplate <typename Ostream, typename... Ts>\\nOstream& operator<<(Ostream& os, const pair<Ts...>& p) {\\n  return os << \\\"{\\\" << p.first << \\\", \\\" << p.second << \\\"}\\\";\\n}\\ntemplate <typename T>\\ninline bool compare_float(T a, T b) {\\n  return (abs(a - b) < 1e-9) ? true : false;\\n}\\ntemplate <typename T>\\nistream& operator>>(istream& os, vector<T>& v) {\\n  T store;\\n  os >> store;\\n  v.push_back(store);\\n  return os;\\n}\\ntemplate <typename T>\\nvoid print(T container, string sep = \\\" \\\", string end = \\\"\\\\n\\\") {\\n  for (const auto& i : container) std::cout << i << sep;\\n  cout << end;\\n}\\nconst std::string sp{\\\" \\\"};\\nconst std::string nl{\\\"\\\\n\\\"};\\nclass solution {\\n  int T = 1;\\n  int N;\\n  int M;\\n  int k;\\n\\n public:\\n  solution() {}\\n  void solve() {\\n    cin >> N >> M >> k;\\n    bool yes{true};\\n    if (not(M & 1) and not(N & 1)) {\\n      if (k & 1) {\\n        k = k * 2;\\n        int row{k \\/ M};\\n        int left{(k % M) \\/ 2};\\n        if (row & 1) {\\n          left += (M \\/ 2);\\n          if (left & 1) {\\n            yes = false;\\n          }\\n        } else {\\n          if (left & 1) {\\n            yes = false;\\n          }\\n        }\\n      }\\n    } else if (N & 1) {\\n      k *= 2;\\n      int row{k \\/ M};\\n      int left{(k % M) \\/ 2};\\n      if (row &...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Petya has got an interesting flower. Petya is a busy person, so he sometimes forgets to water it. You are given n days from Petya's live and you have to determine what happened with his flower in the end.\\n\\nThe flower grows as follows: \\n\\n  * If the flower isn't watered for two days in a row, it dies. \\n  * If the flower is watered in the i-th day, it grows by 1 centimeter. \\n  * If the flower is watered in the i-th and in the (i-1)-th day (i > 1), then it grows by 5 centimeters instead of 1. \\n  * If the flower is not watered in the i-th day, it does not grow. \\n\\n\\n\\nAt the beginning of the 1-st day the flower is 1 centimeter tall. What is its height after n days?\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 100). Description of the test cases follows.\\n\\nThe first line of each test case contains the only integer n (1 \u2264 n \u2264 100).\\n\\nThe second line of each test case contains n integers a_1, a_2, ..., a_n (a_i = 0 or a_i = 1). If a_i = 1, the flower is watered in the i-th day, otherwise it is not watered.\\n\\nOutput\\n\\nFor each test case print a single integer k \u2014 the flower's height after n days, or -1, if the flower dies.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n3\\n1 0 1\\n3\\n0 1 1\\n4\\n1 0 0 1\\n1\\n0\\n\\n\\nOutput\\n\\n\\n3\\n7\\n-1\\n1\\nimpor\",\"targets\":\"t java.io.*;\\n\\nimport java.util.*;\\n\\/*\\n\\n\\n\\n\\n*\\/\\n\\n \\n public class A{\\n\\tstatic FastReader sc=null;\\n\\t\\n\\tpublic static void main(String[] args) {\\n\\t\\tsc=new FastReader();\\n\\t\\tint t=sc.nextInt();\\n\\t\\t\\n\\t\\tfor(int tt=0;tt<t;tt++) {\\n\\t\\t\\tint n=sc.nextInt();\\n\\t\\t\\tint a[]=sc.readArray(n);\\n\\t\\t\\tint h=1;\\n\\t\\t\\tfor(int i=0;i<n;i++) {\\n\\t\\t\\t\\tif(a[i]==0) {\\n\\t\\t\\t\\t\\tif(i>0 && a[i-1]==0) {\\n\\t\\t\\t\\t\\t\\th=-1;\\n\\t\\t\\t\\t\\t\\tbreak;\\n\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\t}\\n\\t\\t\\t\\telse {\\n\\t\\t\\t\\t\\tif(i>0 && a[i-1]==1) {\\n\\t\\t\\t\\t\\t\\th+=5;\\n\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\t\\telse h++;\\n\\t\\t\\t\\t}\\n\\t\\t\\t}\\n\\t\\t\\tSystem.out.println(h);\\n\\t\\t}\\n\\t}\\n\\t\\n\\tstatic int[] ruffleSort(int a[]) {\\n\\t\\tArrayList<Integer> al=new ArrayList<>();\\n\\t\\tfor(int i:a)al.add(i);\\n\\t\\tCollections.sort(al);\\n\\t\\tfor(int i=0;i<a.length;i++)a[i]=al.get(i);\\n\\t\\treturn a;\\n\\t}\\n\\t\\n\\tstatic void print(int a[]) {\\n\\t\\tfor(int e:a) {\\n\\t\\t\\tSystem.out.print(e+\\\" \\\");\\n\\t\\t}\\n\\t\\tSystem.out.println();\\n\\t}\\n\\t\\n\\tstatic class FastReader{\\n\\t\\t\\n\\t\\tStringTokenizer st=new StringTokenizer(\\\"\\\");\\n\\t\\tBufferedReader br=new BufferedReader(new InputStreamReader(System.in));\\n\\t\\t\\n\\t\\tString next() {\\n\\t\\t\\twhile(!st.hasMoreTokens()) \\n\\t\\t\\t\\ttry {\\n\\t\\t\\t\\t\\tst=new StringTokenizer(br.readLine());\\n\\t\\t\\t\\t}\\n\\t\\t\\t   catch(IOException e){\\n\\t\\t\\t\\t   e.printStackTrace();\\n\\t\\t\\t   }\\n\\t\\t\\treturn st.nextToken();\\n\\t\\t}\\n\\t\\t\\n\\t\\tint nextInt() {\\n\\t\\t\\treturn Integer.parseInt(next());\\n\\t\\t}\\n\\t\\t\\n\\t\\tlong nextLong() {\\n\\t\\t\\treturn Long.parseLong(next());\\n\\t\\t}\\n\\t\\t\\n\\t\\tint[] readArray(int n) {\\n\\t\\t\\tint a[]=new int[n];\\n\\t\\t\\tfor(int i=0;i<n;i++)a[i]=sc.nextInt();\\n\\t\\t\\treturn a;\\n\\t\\t}\\n\\t}\\n\\t\\n\\t\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You are given two positive integers n and s. Find the maximum possible median of an array of n non-negative integers (not necessarily distinct), such that the sum of its elements is equal to s.\\n\\nA median of an array of integers of length m is the number standing on the \u2308 {m\\/2} \u2309-th (rounding up) position in the non-decreasing ordering of its elements. Positions are numbered starting from 1. For example, a median of the array [20,40,20,50,50,30] is the \u2308 m\\/2 \u2309-th element of [20,20,30,40,50,50], so it is 30. There exist other definitions of the median, but in this problem we use the described definition.\\n\\nInput\\n\\nThe input consists of multiple test cases. The first line contains a single integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases. Description of the test cases follows.\\n\\nEach test case contains a single line with two integers n and s (1 \u2264 n, s \u2264 10^9) \u2014 the length of the array and the required sum of the elements.\\n\\nOutput\\n\\nFor each test case print a single integer \u2014 the maximum possible median.\\n\\nExample\\n\\nInput\\n\\n\\n8\\n1 5\\n2 5\\n3 5\\n2 1\\n7 17\\n4 14\\n1 1000000000\\n1000000000 1\\n\\n\\nOutput\\n\\n\\n5\\n2\\n2\\n0\\n4\\n4\\n1000000000\\n0\\n\\nNote\\n\\nPossible arrays for the first three test cases (in each array the median is underlined):\\n\\n  * In the first test case [\\\\underline{5}] \\n  * In the second test case [\\\\underline{2}, 3] \\n  * In the third test case [1, \\\\underline{2}, 2] \\nSolve the task in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint main() {\\n  int t;\\n  cin >> t;\\n  while (t--) {\\n    long long n, s;\\n    cin >> n >> s;\\n    if (n <= 2)\\n      cout << (s \\/ n);\\n    else {\\n      n = n - ((n + 1) \\/ 2) + 1;\\n      cout << (s \\/ n);\\n    }\\n    cout << endl;\\n  }\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Even the most successful company can go through a crisis period when you have to make a hard decision \u2014 to restructure, discard and merge departments, fire employees and do other unpleasant stuff. Let's consider the following model of a company.\\n\\nThere are n people working for the Large Software Company. Each person belongs to some department. Initially, each person works on his own project in his own department (thus, each company initially consists of n departments, one person in each).\\n\\nHowever, harsh times have come to the company and the management had to hire a crisis manager who would rebuild the working process in order to boost efficiency. Let's use team(person) to represent a team where person person works. A crisis manager can make decisions of two types:\\n\\n  1. Merge departments team(x) and team(y) into one large department containing all the employees of team(x) and team(y), where x and y (1 \u2264 x, y \u2264 n) \u2014 are numbers of two of some company employees. If team(x) matches team(y), then nothing happens. \\n  2. Merge departments team(x), team(x + 1), ..., team(y), where x and y (1 \u2264 x \u2264 y \u2264 n) \u2014 the numbers of some two employees of the company. \\n\\n\\n\\nAt that the crisis manager can sometimes wonder whether employees x and y (1 \u2264 x, y \u2264 n) work at the same department.\\n\\nHelp the crisis manager and answer all of his queries.\\n\\nInput\\n\\nThe first line of the input contains two integers n and q (1 \u2264 n \u2264 200 000, 1 \u2264 q \u2264 500 000) \u2014 the number of the employees of the company and the number of queries the crisis manager has.\\n\\nNext q lines contain the queries of the crisis manager. Each query looks like type x y, where <image>. If type = 1 or type = 2, then the query represents the decision of a crisis manager about merging departments of the first and second types respectively. If type = 3, then your task is to determine whether employees x and y work at the same department. Note that x can be equal to y in the query of any type.\\n\\nOutput\\n\\nFor each question of type 3 print \\\"YES\\\" or \\\"NO\\\" (without the quotes), depending...\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst long long I1 = 1e9;\\nconst long long I2 = 1e18;\\nconst int32_t M1 = 1e9 + 7;\\nconst int32_t M2 = 998244353;\\ntemplate <typename T, typename T1>\\nT maxn(T &a, T1 b) {\\n  if (b > a) a = b;\\n  return a;\\n}\\ntemplate <typename T, typename T1>\\nT minn(T &a, T1 b) {\\n  if (b < a) a = b;\\n  return a;\\n}\\nvector<long long int> par(200005), ord(200005);\\nset<long long int> s;\\nlong long int parent(long long int i) {\\n  if (par[i] == i)\\n    return i;\\n  else\\n    return par[i] = parent(par[i]);\\n}\\nbool pfind(long long int x, long long int y) { return parent(x) == parent(y); }\\nvoid merge(long long int x, long long int y) {\\n  x = parent(x);\\n  y = parent(y);\\n  if (x == y) return;\\n  if (ord[x] > ord[y]) {\\n    par[y] = x;\\n    ord[x] += ord[y];\\n  } else {\\n    par[x] = y;\\n    ord[y] += ord[x];\\n  }\\n}\\nvoid clear_dsu(int n) {\\n  for (long long int i = 0; i < n; i++) par[i] = i;\\n}\\nvoid solve() {\\n  int n, q;\\n  cin >> n >> q;\\n  for (long long int i = 0; i < n; i++) s.insert(i);\\n  s.insert(I1);\\n  clear_dsu(n);\\n  while (q--) {\\n    int p, a, b;\\n    cin >> p >> a >> b;\\n    a--;\\n    b--;\\n    if (p == 1) {\\n      merge(a, b);\\n    } else if (p == 2) {\\n      auto it = s.lower_bound(a);\\n      vector<int> v;\\n      while (*it <= b) {\\n        v.push_back(*it);\\n        it++;\\n      }\\n      for (int i = 1; i < (long long int)v.size() - 1; i++) s.erase(v[i]);\\n      for (long long int i = 1; i <= (long long int)v.size() - 1; i++)\\n        merge(v[i - 1], v[i]);\\n    } else {\\n      cout << (pfind(a, b) ? \\\"YES\\\" : \\\"NO\\\") << '\\\\n';\\n    }\\n  }\\n}\\nsigned main() {\\n  ios_base::sync_with_stdio(0);\\n  cin.tie(0);\\n  cout.tie(0);\\n  int testcase = 1;\\n  while (testcase--) solve();\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Paprika loves permutations. She has an array a_1, a_2, ..., a_n. She wants to make the array a permutation of integers 1 to n.\\n\\nIn order to achieve this goal, she can perform operations on the array. In each operation she can choose two integers i (1 \u2264 i \u2264 n) and x (x > 0), then perform a_i := a_i mod x (that is, replace a_i by the remainder of a_i divided by x). In different operations, the chosen i and x can be different.\\n\\nDetermine the minimum number of operations needed to make the array a permutation of integers 1 to n. If it is impossible, output -1.\\n\\nA permutation is an array consisting of n distinct integers from 1 to n in arbitrary order. For example, [2,3,1,5,4] is a permutation, but [1,2,2] is not a permutation (2 appears twice in the array) and [1,3,4] is also not a permutation (n=3 but there is 4 in the array).\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains a single integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases. Description of the test cases follows.\\n\\nThe first line of each test case contains an integer n (1 \u2264 n \u2264 10^5).\\n\\nThe second line of each test case contains n integers a_1, a_2, ..., a_n. (1 \u2264 a_i \u2264 10^9).\\n\\nIt is guaranteed that the sum of n over all test cases does not exceed 2 \u22c5 10^5.\\n\\nOutput\\n\\nFor each test case, output the minimum number of operations needed to make the array a permutation of integers 1 to n, or -1 if it is impossible.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n2\\n1 7\\n3\\n1 5 4\\n4\\n12345678 87654321 20211218 23571113\\n9\\n1 2 3 4 18 19 5 6 7\\n\\n\\nOutput\\n\\n\\n1\\n-1\\n4\\n2\\n\\nNote\\n\\nFor the first test, the only possible sequence of operations which minimizes the number of operations is: \\n\\n  * Choose i=2, x=5. Perform a_2 := a_2 mod 5 = 2. \\n\\n\\n\\nFor the second test, it is impossible to obtain a permutation of integers from 1 to n.\\nUsing python3 can you solve the prior task?\",\"targets\":\"import math,sys;input=sys.stdin.readline;S=lambda:input().rstrip();I=lambda:int(S());M=lambda:map(int,S().split());L=lambda:list(M());mod1=1000000007;mod2=998244353\\n\\nfor _ in range(I()):\\n\\tn=I()\\n\\ta=L()\\n\\tl=[0]*(n+1);f=0\\n\\tb=[0]*(n+1)\\n\\tfor i in range(n):\\n\\t\\tif 1<=a[i]<=n and b[a[i]]==0:b[a[i]]+=1;continue\\n\\t\\tl[min(n,a[i]- (a[i]\\/\\/2) -1)]+=1\\n\\ts=set(a);c=0\\n\\tfor i in range(n-1,0,-1):\\n\\t\\tif i+1 in s:\\n\\t\\t\\tl[i]+=(l[i+1])\\n\\t\\telse:\\n\\t\\t\\tl[i]+=(l[i+1]-1)\\n\\tfor i in range(1,n+1):\\n\\t\\tif l[i]==0 and i not in s:\\n\\t\\t\\tf=1;break\\n\\tif f==1:\\n\\t\\tprint(-1);continue\\n\\tfor i in range(1,n+1):\\n\\t\\tif i not in s:c+=1\\n\\tprint(c)\",\"language\":\"python\",\"split\":\"test\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"JAVA solution for \\\"It is the easy version of the problem. The only difference is that in this version n = 1.\\n\\nIn the cinema seats can be represented as the table with n rows and m columns. The rows are numbered with integers from 1 to n. The seats in each row are numbered with consecutive integers from left to right: in the k-th row from m (k - 1) + 1 to m k for all rows 1 \u2264 k \u2264 n.\\n\\n1| 2| \u22c5\u22c5\u22c5| m - 1| m  \\n---|---|---|---|---  \\nm + 1| m + 2| \u22c5\u22c5\u22c5| 2 m - 1| 2 m  \\n2m + 1| 2m + 2| \u22c5\u22c5\u22c5| 3 m - 1| 3 m  \\n\\\\vdots| \\\\vdots| \\\\ddots| \\\\vdots| \\\\vdots  \\nm (n - 1) + 1| m (n - 1) + 2| \u22c5\u22c5\u22c5| n m - 1| n m  \\nThe table with seats indices\\n\\nThere are nm people who want to go to the cinema to watch a new film. They are numbered with integers from 1 to nm. You should give exactly one seat to each person.\\n\\nIt is known, that in this cinema as lower seat index you have as better you can see everything happening on the screen. i-th person has the level of sight a_i. Let's define s_i as the seat index, that will be given to i-th person. You want to give better places for people with lower sight levels, so for any two people i, j such that a_i < a_j it should be satisfied that s_i < s_j.\\n\\nAfter you will give seats to all people they will start coming to their seats. In the order from 1 to nm, each person will enter the hall and sit in their seat. To get to their place, the person will go to their seat's row and start moving from the first seat in this row to theirs from left to right. While moving some places will be free, some will be occupied with people already seated. The inconvenience of the person is equal to the number of occupied seats he or she will go through.\\n\\nLet's consider an example: m = 5, the person has the seat 4 in the first row, the seats 1, 3, 5 in the first row are already occupied, the seats 2 and 4 are free. The inconvenience of this person will be 2, because he will go through occupied seats 1 and 3.\\n\\nFind the minimal total inconvenience (the sum of inconveniences of all people), that is possible to have by giving places for all people...\\\":\",\"targets\":\"import java.util.*;\\nimport java.io.*;\\nimport java.io.BufferedReader;\\nimport java.io.IOException;\\nimport java.io.InputStreamReader;\\nimport java.util.Scanner;\\nimport java.util.StringTokenizer;\\n\\npublic class Test{\\n\\n        static FastReader scan;\\n\\n        static void solve(){\\n            scan.nextInt();\\n            int n=scan.nextInt();\\n            int []arr=new int[n];\\n            for(int i=0;i<n;i++){\\n                arr[i]=scan.nextInt();\\n            }\\n            int []brr=arr.clone();\\n            Arrays.sort(brr);\\n            int ans=0;\\n            int []dum=new int[n];\\n\\n            for(int i=0;i<n;i++){\\n                int temp=arr[i];\\n                int j=0;\\n                while(j<n){\\n                    if(brr[j]==temp&&dum[j]==0){\\n                        while(j+1<n&&brr[j+1]==temp&&dum[j+1]==0)j++;\\n                        dum[j]=1;\\n                        break;\\n                    }\\n                    else{\\n                        if(dum[j]==1)\\n                        ans++;\\n                        j++;\\n                    }\\n                }\\n                \\/\\/ System.out.println(Arrays.toString(dum)+\\\" \\\"+ans);\\n            }\\n            System.out.println(ans);\\n            \\n\\n        }\\n\\n        public static void main (String[] args) throws java.lang.Exception{\\n            scan=new FastReader();\\n            int t=scan.nextInt();\\n            while(t-->0){\\n                solve();\\n            }\\n        }\\n\\n        static class FastReader {\\n            BufferedReader br;\\n            StringTokenizer st;\\n\\n            public FastReader()\\n            {\\n                br = new BufferedReader(\\n                    new InputStreamReader(System.in));\\n            }\\n\\n            String next()\\n            {\\n                while (st == null || !st.hasMoreElements()) {\\n                    try {\\n                        st = new StringTokenizer(br.readLine());\\n                    }\\n                    catch (IOException e) {\\n                        e.printStackTrace();\\n                    }\\n                }\\n         ...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"A bitstring is a string consisting only of the characters 0 and 1. A bitstring is called k-balanced if every substring of size k of this bitstring has an equal amount of 0 and 1 characters (k\\/2 of each).\\n\\nYou are given an integer k and a string s which is composed only of characters 0, 1, and ?. You need to determine whether you can make a k-balanced bitstring by replacing every ? characters in s with either 0 or 1.\\n\\nA string a is a substring of a string b if a can be obtained from b by deletion of several (possibly, zero or all) characters from the beginning and several (possibly, zero or all) characters from the end.\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 10^4). Description of the test cases follows.\\n\\nThe first line of each test case contains two integers n and k (2 \u2264 k \u2264 n \u2264 3 \u22c5 10^5, k is even) \u2014 the length of the string and the parameter for a balanced bitstring.\\n\\nThe next line contains the string s (|s| = n). It is given that s consists of only 0, 1, and ?.\\n\\nIt is guaranteed that the sum of n over all test cases does not exceed 3 \u22c5 10^5.\\n\\nOutput\\n\\nFor each test case, print YES if we can replace every ? in s with 0 or 1 such that the resulting bitstring is k-balanced, or NO if it is not possible.\\n\\nExample\\n\\nInput\\n\\n\\n9\\n6 4\\n100110\\n3 2\\n1?1\\n3 2\\n1?0\\n4 4\\n????\\n7 4\\n1?0??1?\\n10 10\\n11??11??11\\n4 2\\n1??1\\n4 4\\n?0?0\\n6 2\\n????00\\n\\n\\nOutput\\n\\n\\nYES\\nYES\\nNO\\nYES\\nYES\\nNO\\nNO\\nYES\\nNO\\n\\nNote\\n\\nFor the first test case, the string is already a 4-balanced bitstring.\\n\\nFor the second test case, the string can be transformed into 101.\\n\\nFor the fourth test case, the string can be transformed into 0110.\\n\\nFor the fifth test case, the string can be transformed into 1100110.\\nThe above is tricky. Write me a correct solution in JAVA.\",\"targets\":\"import java.util.*;\\n\\nimport javax.lang.model.util.ElementScanner6;\\n\\nimport java.io.*;\\npublic class C{\\n    static class InputReader {\\n\\n        private final InputStream stream;\\n        private final byte[] buf = new byte[8192];\\n        private int curChar, snumChars;\\n        private SpaceCharFilter filter;\\n\\n        public InputReader(InputStream stream) {\\n            this.stream = stream;\\n        }\\n\\n        public int snext() {\\n            if (snumChars == -1)\\n                throw new InputMismatchException();\\n            if (curChar >= snumChars) {\\n                curChar = 0;\\n                try {\\n                    snumChars = stream.read(buf);\\n                } catch (IOException e) {\\n                    throw new InputMismatchException();\\n                }\\n                if (snumChars <= 0)\\n                    return -1;\\n            }\\n            return buf[curChar++];\\n        }\\n\\n        public int nextInt() {\\n            int c = snext();\\n            while (isSpaceChar(c)) {\\n                c = snext();\\n            }\\n            int sgn = 1;\\n            if (c == '-') {\\n                sgn = -1;\\n                c = snext();\\n            }\\n            int res = 0;\\n            do {\\n                if (c < '0' || c > '9')\\n                    throw new InputMismatchException();\\n                res *= 10;\\n                res += c - '0';\\n                c = snext();\\n            } while (!isSpaceChar(c));\\n            return res * sgn;\\n        }\\n\\n        public long nextLong() {\\n            int c = snext();\\n            while (isSpaceChar(c)) {\\n                c = snext();\\n            }\\n            int sgn = 1;\\n            if (c == '-') {\\n                sgn = -1;\\n                c = snext();\\n            }\\n            long res = 0;\\n            do {\\n                if (c < '0' || c > '9')\\n                    throw new InputMismatchException();\\n                res *= 10;\\n                res += c - '0';\\n                c = snext();\\n            } while (!isSpaceChar(c));\\n            return res * sgn;\\n        }\\n\\n     ...\",\"language\":\"python\",\"split\":\"train\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in CPP?\\nMedicine faculty of Berland State University has just finished their admission campaign. As usual, about 80\\\\% of applicants are girls and majority of them are going to live in the university dormitory for the next 4 (hopefully) years.\\n\\nThe dormitory consists of n rooms and a single mouse! Girls decided to set mouse traps in some rooms to get rid of the horrible monster. Setting a trap in room number i costs c_i burles. Rooms are numbered from 1 to n.\\n\\nMouse doesn't sit in place all the time, it constantly runs. If it is in room i in second t then it will run to room a_i in second t + 1 without visiting any other rooms inbetween (i = a_i means that mouse won't leave room i). It's second 0 in the start. If the mouse is in some room with a mouse trap in it, then the mouse get caught into this trap.\\n\\nThat would have been so easy if the girls actually knew where the mouse at. Unfortunately, that's not the case, mouse can be in any room from 1 to n at second 0.\\n\\nWhat it the minimal total amount of burles girls can spend to set the traps in order to guarantee that the mouse will eventually be caught no matter the room it started from?\\n\\nInput\\n\\nThe first line contains as single integers n (1 \u2264 n \u2264 2 \u22c5 10^5) \u2014 the number of rooms in the dormitory.\\n\\nThe second line contains n integers c_1, c_2, ..., c_n (1 \u2264 c_i \u2264 10^4) \u2014 c_i is the cost of setting the trap in room number i.\\n\\nThe third line contains n integers a_1, a_2, ..., a_n (1 \u2264 a_i \u2264 n) \u2014 a_i is the room the mouse will run to the next second after being in room i.\\n\\nOutput\\n\\nPrint a single integer \u2014 the minimal total amount of burles girls can spend to set the traps in order to guarantee that the mouse will eventually be caught no matter the room it started from.\\n\\nExamples\\n\\nInput\\n\\n5\\n1 2 3 2 10\\n1 3 4 3 3\\n\\n\\nOutput\\n\\n3\\n\\n\\nInput\\n\\n4\\n1 10 2 10\\n2 4 2 2\\n\\n\\nOutput\\n\\n10\\n\\n\\nInput\\n\\n7\\n1 1 1 1 1 1 1\\n2 2 2 3 6 7 6\\n\\n\\nOutput\\n\\n2\\n\\nNote\\n\\nIn the first example it is enough to set mouse trap in rooms 1 and 4. If mouse starts in room 1 then it gets caught immideately. If mouse starts in any...\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nmap<int, int> g;\\nbool vis[200001];\\nint cy[200001];\\nint st[200001];\\nvoid dfs(int u, int s) {\\n  vis[u] = true;\\n  st[u] = s;\\n  int v = g[u];\\n  if (vis[v] and st[v] == s) {\\n    cy[s] = v;\\n    return;\\n  } else if (vis[v] and st[v] != s) {\\n    cy[s] = cy[st[v]];\\n    return;\\n  } else {\\n    dfs(v, s);\\n  }\\n  return;\\n}\\nint main() {\\n  int n, i, v, s = -1, total = 0, cost;\\n  cin >> n;\\n  int c[n + 1];\\n  for (i = 0; i < n; i++) {\\n    cin >> c[i + 1];\\n  }\\n  for (i = 1; i <= n; i++) {\\n    cin >> v;\\n    g[i] = v;\\n  }\\n  memset(vis, false, sizeof(vis));\\n  for (int i = 1; i <= n; i++) {\\n    if (vis[i]) {\\n      continue;\\n    } else {\\n      s++;\\n      dfs(i, s);\\n    }\\n    if (s == st[cy[s]]) {\\n      cost = INT_MAX;\\n      int u = cy[s];\\n      v = g[u];\\n      cost = min(cost, c[v]);\\n      while (v != u) {\\n        v = g[v];\\n        cost = min(cost, c[v]);\\n      }\\n      total += cost;\\n    }\\n  }\\n  cout << total << endl;\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You are given a binary string (i. e. a string consisting of characters 0 and\\/or 1) s of length n. You can perform the following operation with the string s at most once: choose a substring (a contiguous subsequence) of s having exactly k characters 1 in it, and shuffle it (reorder the characters in the substring as you wish).\\n\\nCalculate the number of different strings which can be obtained from s by performing this operation at most once.\\n\\nInput\\n\\nThe first line contains two integers n and k (2 \u2264 n \u2264 5000; 0 \u2264 k \u2264 n).\\n\\nThe second line contains the string s of length n, consisting of characters 0 and\\/or 1.\\n\\nOutput\\n\\nPrint one integer \u2014 the number of different strings which can be obtained from s by performing the described operation at most once. Since the answer can be large, output it modulo 998244353.\\n\\nExamples\\n\\nInput\\n\\n\\n7 2\\n1100110\\n\\n\\nOutput\\n\\n\\n16\\n\\n\\nInput\\n\\n\\n5 0\\n10010\\n\\n\\nOutput\\n\\n\\n1\\n\\n\\nInput\\n\\n\\n8 1\\n10001000\\n\\n\\nOutput\\n\\n\\n10\\n\\n\\nInput\\n\\n\\n10 8\\n0010011000\\n\\n\\nOutput\\n\\n\\n1\\n\\nNote\\n\\nSome strings you can obtain in the first example:\\n\\n  * to obtain 0110110, you can take the substring from the 1-st character to the 4-th character, which is 1100, and reorder its characters to get 0110; \\n  * to obtain 1111000, you can take the substring from the 3-rd character to the 7-th character, which is 00110, and reorder its characters to get 11000; \\n  * to obtain 1100101, you can take the substring from the 5-th character to the 7-th character, which is 110, and reorder its characters to get 101. \\n\\n\\n\\nIn the second example, k = 0 so you can only choose the substrings consisting only of 0 characters. Reordering them doesn't change the string at all, so the only string you can obtain is 10010.\\nUsing cpp can you solve the prior task?\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst int N = 1e5 + 1;\\nbool notPrime[N];\\nvector<int> primes;\\nvoid calc_prime() {\\n  notPrime[1] = true;\\n  notPrime[2] = false;\\n  for (int i = 2; i * i < N; ++i) {\\n    if (!notPrime[i]) {\\n      primes.push_back(i);\\n      int j = i * i;\\n      while (j < N) {\\n        notPrime[j] = true;\\n        j += i;\\n      }\\n    }\\n  }\\n}\\nlong long mod = 998244353;\\nlong long cnk[5001][5001];\\nvoid prep(int k) {\\n  cnk[0][0] = 1;\\n  for (int j = 1; j <= k; ++j) {\\n    cnk[j][0] = 1;\\n    for (int i = 1; i <= j; ++i) {\\n      cnk[j][i] = (cnk[j - 1][i - 1] + cnk[j - 1][i]) % mod;\\n    }\\n  }\\n}\\nint main() {\\n  int n, k;\\n  cin >> n >> k;\\n  if (k == 0) {\\n    cout << 1 << endl;\\n    return 0;\\n  }\\n  prep(n);\\n  string s;\\n  cin >> s;\\n  long long ans = 0;\\n  vector<long long> p(n);\\n  long long pref = 0;\\n  for (int i = 0; i < n; ++i) {\\n    p[i] = pref;\\n    if (s[i] == '1') {\\n      ++p[i];\\n    }\\n    pref = p[i];\\n  }\\n  int l = -1, r = -1;\\n  for (int(i) = 0; (i) < (n); ++(i)) {\\n    if (p[i] == k) {\\n      r = i;\\n      l = 0;\\n    }\\n  }\\n  if (l == -1) {\\n    cout << 1 << endl;\\n    return 0;\\n  }\\n  ans += cnk[r - l + 1][k];\\n  int pr = r, pl = l;\\n  vector<long long> a;\\n  a.push_back(ans);\\n  while (r < n - 1) {\\n    ++r;\\n    while (r < n - 1 && s[r + 1] == '0') {\\n      ++r;\\n    }\\n    while (s[l] != '1') {\\n      ++l;\\n    }\\n    ++l;\\n    if (l > pr) {\\n      ans = (ans + cnk[r - l + 1][k]) % mod;\\n      ans = (ans + mod - 1) % mod;\\n      a.push_back(ans);\\n      pr = r;\\n      pl = l;\\n      continue;\\n    }\\n    long long cur = cnk[pr - l + 1][k - 1];\\n    long long nw = cnk[r - l + 1][k];\\n    ans += (nw - cur + mod) % mod;\\n    ans %= mod;\\n    pr = r;\\n    pl = l;\\n  }\\n  cout << ans << endl;\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Shohag has an integer sequence a_1, a_2, \u2026, a_n. He can perform the following operation any number of times (possibly, zero):\\n\\n  * Select any positive integer k (it can be different in different operations). \\n  * Choose any position in the sequence (possibly the beginning or end of the sequence, or in between any two elements) and insert k into the sequence at this position. \\n  * This way, the sequence a changes, and the next operation is performed on this changed sequence. \\n\\n\\n\\nFor example, if a=[3,3,4] and he selects k = 2, then after the operation he can obtain one of the sequences [\\\\underline{2},3,3,4], [3,\\\\underline{2},3,4], [3,3,\\\\underline{2},4], or [3,3,4,\\\\underline{2}].\\n\\nShohag wants this sequence to satisfy the following condition: for each 1 \u2264 i \u2264 |a|, a_i \u2264 i. Here, |a| denotes the size of a.\\n\\nHelp him to find the minimum number of operations that he has to perform to achieve this goal. We can show that under the constraints of the problem it's always possible to achieve this goal in a finite number of operations.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 200) \u2014 the number of test cases.\\n\\nThe first line of each test case contains a single integer n (1 \u2264 n \u2264 100) \u2014 the initial length of the sequence.\\n\\nThe second line of each test case contains n integers a_1, a_2, \u2026, a_n (1 \u2264 a_i \u2264 10^9) \u2014 the elements of the sequence.\\n\\nOutput\\n\\nFor each test case, print a single integer \u2014 the minimum number of operations needed to perform to achieve the goal mentioned in the statement.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n3\\n1 3 4\\n5\\n1 2 5 7 4\\n1\\n1\\n3\\n69 6969 696969\\n\\n\\nOutput\\n\\n\\n1\\n3\\n0\\n696966\\n\\nNote\\n\\nIn the first test case, we have to perform at least one operation, as a_2=3>2. We can perform the operation [1, 3, 4] \u2192 [1, \\\\underline{2}, 3, 4] (the newly inserted element is underlined), now the condition is satisfied.\\n\\nIn the second test case, Shohag can perform the following operations:\\n\\n[1, 2, 5, 7, 4] \u2192 [1, 2, \\\\underline{3}, 5, 7, 4] \u2192 [1, 2, 3, \\\\underline{4}, 5, 7, 4] \u2192 [1, 2, 3, 4, 5, \\\\underline{3}, 7, 4].\\n\\nIn the third...\",\"targets\":\"import java.util.*;\\npublic class Main\\n{\\n    public static void main(String[] args)\\n    {\\n        Scanner sc = new Scanner(System.in);\\n        long t = sc.nextLong();\\n        while(t-- >0)\\n        {\\n            long n = sc.nextLong();\\n            long[] ar = new long[(int) n];\\n            long ans=0, fina=0;\\n            for(long i=0; i<n; i++)\\n            {\\n                ar[(int) i] = sc.nextLong();\\n                if(ar[(int) i]>(i+1))\\n                {\\n                    ans = ar[(int) i] - (i+1) - fina;\\n                    if(ans>0)\\n                    fina += ans;\\n                }\\n            }\\n            System.out.println(fina);\\n        }\\n    }\\n\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Anton's favourite geometric figures are regular polyhedrons. Note that there are five kinds of regular polyhedrons: \\n\\n  * Tetrahedron. Tetrahedron has 4 triangular faces. \\n  * Cube. Cube has 6 square faces. \\n  * Octahedron. Octahedron has 8 triangular faces. \\n  * Dodecahedron. Dodecahedron has 12 pentagonal faces. \\n  * Icosahedron. Icosahedron has 20 triangular faces. \\n\\n\\n\\nAll five kinds of polyhedrons are shown on the picture below:\\n\\n<image>\\n\\nAnton has a collection of n polyhedrons. One day he decided to know, how many faces his polyhedrons have in total. Help Anton and find this number!\\n\\nInput\\n\\nThe first line of the input contains a single integer n (1 \u2264 n \u2264 200 000) \u2014 the number of polyhedrons in Anton's collection.\\n\\nEach of the following n lines of the input contains a string si \u2014 the name of the i-th polyhedron in Anton's collection. The string can look like this:\\n\\n  * \\\"Tetrahedron\\\" (without quotes), if the i-th polyhedron in Anton's collection is a tetrahedron. \\n  * \\\"Cube\\\" (without quotes), if the i-th polyhedron in Anton's collection is a cube. \\n  * \\\"Octahedron\\\" (without quotes), if the i-th polyhedron in Anton's collection is an octahedron. \\n  * \\\"Dodecahedron\\\" (without quotes), if the i-th polyhedron in Anton's collection is a dodecahedron. \\n  * \\\"Icosahedron\\\" (without quotes), if the i-th polyhedron in Anton's collection is an icosahedron. \\n\\nOutput\\n\\nOutput one number \u2014 the total number of faces in all the polyhedrons in Anton's collection.\\n\\nExamples\\n\\nInput\\n\\n4\\nIcosahedron\\nCube\\nTetrahedron\\nDodecahedron\\n\\n\\nOutput\\n\\n42\\n\\n\\nInput\\n\\n3\\nDodecahedron\\nOctahedron\\nOctahedron\\n\\n\\nOutput\\n\\n28\\n\\nNote\\n\\nIn the first sample Anton has one icosahedron, one cube, one tetrahedron and one dodecahedron. Icosahedron has 20 faces, cube has 6 faces, tetrahedron has 4 faces and dodecahedron has 12 faces. In total, they have 20 + 6 + 4 + 12 = 42 faces.\\nUsing python3 can you solve the prior task?\",\"targets\":\"n = int(input())\\nsm = 0\\nfor i in range(n):\\n    s = input()\\n    if s == \\\"Tetrahedron\\\":\\n        sm += 4\\n    if s == \\\"Cube\\\":\\n        sm += 6\\n    if s == \\\"Octahedron\\\":\\n        sm += 8\\n    if s == \\\"Dodecahedron\\\":\\n        sm += 12\\n    if s == \\\"Icosahedron\\\":\\n        sm += 20\\nprint(sm)\",\"language\":\"python\",\"split\":\"train\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Arpa is researching the Mexican wave.\\n\\nThere are n spectators in the stadium, labeled from 1 to n. They start the Mexican wave at time 0. \\n\\n  * At time 1, the first spectator stands. \\n  * At time 2, the second spectator stands. \\n  * ...\\n  * At time k, the k-th spectator stands. \\n  * At time k + 1, the (k + 1)-th spectator stands and the first spectator sits. \\n  * At time k + 2, the (k + 2)-th spectator stands and the second spectator sits. \\n  * ...\\n  * At time n, the n-th spectator stands and the (n - k)-th spectator sits. \\n  * At time n + 1, the (n + 1 - k)-th spectator sits. \\n  * ...\\n  * At time n + k, the n-th spectator sits. \\n\\n\\n\\nArpa wants to know how many spectators are standing at time t.\\n\\nInput\\n\\nThe first line contains three integers n, k, t (1 \u2264 n \u2264 109, 1 \u2264 k \u2264 n, 1 \u2264 t < n + k).\\n\\nOutput\\n\\nPrint single integer: how many spectators are standing at time t.\\n\\nExamples\\n\\nInput\\n\\n10 5 3\\n\\n\\nOutput\\n\\n3\\n\\n\\nInput\\n\\n10 5 7\\n\\n\\nOutput\\n\\n5\\n\\n\\nInput\\n\\n10 5 12\\n\\n\\nOutput\\n\\n3\\n\\nNote\\n\\nIn the following a sitting spectator is represented as -, a standing spectator is represented as ^.\\n\\n  * At t = 0  ---------- <image> number of standing spectators = 0. \\n  * At t = 1  ^--------- <image> number of standing spectators = 1. \\n  * At t = 2  ^^-------- <image> number of standing spectators = 2. \\n  * At t = 3  ^^^------- <image> number of standing spectators = 3. \\n  * At t = 4  ^^^^------ <image> number of standing spectators = 4. \\n  * At t = 5  ^^^^^----- <image> number of standing spectators = 5. \\n  * At t = 6  -^^^^^---- <image> number of standing spectators = 5. \\n  * At t = 7  --^^^^^--- <image> number of standing spectators = 5. \\n  * At t = 8  ---^^^^^-- <image> number of standing spectators = 5. \\n  * At t = 9  ----^^^^^- <image> number of standing spectators = 5. \\n  * At t = 10 -----^^^^^ <image> number of standing spectators = 5. \\n  * At t = 11 ------^^^^ <image> number of standing spectators = 4. \\n  * At t = 12 -------^^^ <image> number of standing spectators = 3. \\n  * At t = 13 --------^^ <image> number of standing spectators = 2. \\n ...\\nUsing java can you solve the prior task?\",\"targets\":\"import java.io.*;\\nimport java.util.*;\\nimport java.math.*;\\nimport static java.lang.System.out;\\n\\npublic class A\\n{\\n    public static void main(String[] args) throws IOException\\n    {\\n        \\/\\/BufferedReader f = new BufferedReader(new FileReader(\\\"\\/Users\\/spencersharp\\/Desktop\\/input.txt\\\"));\\n        \\n        BufferedReader f = new BufferedReader(new InputStreamReader(System.in));\\n        PrintWriter writer = new PrintWriter(new BufferedOutputStream(System.out));\\n        \\n        String output = \\\"\\\"; \\/\\/Write all output to this string\\n\\n        \\/\\/Code here\\n        StringTokenizer st = new StringTokenizer(f.readLine());\\n        int n = Integer.parseInt(st.nextToken());\\n        int k = Integer.parseInt(st.nextToken());\\n        int t = Integer.parseInt(st.nextToken());\\n        \\n        if(t <= k)\\n            output = \\\"\\\"+t;\\n        else if(t <= n)\\n            output = \\\"\\\"+k;\\n        else\\n            output = \\\"\\\"+((n+k)-t);\\n        \\/\\/Code here\\n\\n        \\/\\/out.println(output);\\n        \\n        writer.println(output);\\n        writer.close();\\n        System.exit(0);\\n        \\n    }\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"Just in case somebody missed it: this winter is totally cold in Nvodsk! It is so cold that one gets funny thoughts. For example, let's say there are strings with the length exactly n, based on the alphabet of size m. Any its substring with length equal to k is a palindrome. How many such strings exist? Your task is to find their quantity modulo 1000000007 (109 + 7). Be careful and don't miss a string or two!\\n\\nLet us remind you that a string is a palindrome if it can be read the same way in either direction, from the left to the right and from the right to the left.\\n\\nInput\\n\\nThe first and only line contains three integers: n, m and k (1 \u2264 n, m, k \u2264 2000).\\n\\nOutput\\n\\nPrint a single integer \u2014 the number of strings of the described type modulo 1000000007 (109 + 7).\\n\\nExamples\\n\\nInput\\n\\n1 1 1\\n\\n\\nOutput\\n\\n1\\n\\n\\nInput\\n\\n5 2 4\\n\\n\\nOutput\\n\\n2\\n\\nNote\\n\\nIn the first sample only one string is valid: \\\"a\\\" (let's denote the only letter of our alphabet as \\\"a\\\").\\n\\nIn the second sample (if we denote the alphabet letters as \\\"a\\\" and \\\"b\\\") the following strings are valid: \\\"aaaaa\\\" and \\\"bbbbb\\\".\\\":\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nlong long int power(long long int a, long long int b, long long int mod) {\\n  if (b == 1) return a % mod;\\n  if (b == 0) return 1;\\n  long long int z = power((a * a) % mod, b \\/ 2, mod);\\n  if (b % 2) return (z * a) % mod;\\n  return z % mod;\\n}\\nint main() {\\n  long long int n, m, k;\\n  cin >> n >> m >> k;\\n  long long int mod = 1000000007;\\n  if (k == 1 || k > n)\\n    cout << power(m, n, mod) << endl;\\n  else if (k == n)\\n    cout << power(m, (n + 1) \\/ 2, mod) << endl;\\n  else if (k % 2 == 0)\\n    cout << m % mod << endl;\\n  else\\n    cout << (m * m) % mod << endl;\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Polycarp must pay exactly n burles at the checkout. He has coins of two nominal values: 1 burle and 2 burles. Polycarp likes both kinds of coins equally. So he doesn't want to pay with more coins of one type than with the other.\\n\\nThus, Polycarp wants to minimize the difference between the count of coins of 1 burle and 2 burles being used. Help him by determining two non-negative integer values c_1 and c_2 which are the number of coins of 1 burle and 2 burles, respectively, so that the total value of that number of coins is exactly n (i. e. c_1 + 2 \u22c5 c_2 = n), and the absolute value of the difference between c_1 and c_2 is as little as possible (i. e. you must minimize |c_1-c_2|).\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases. Then t test cases follow.\\n\\nEach test case consists of one line. This line contains one integer n (1 \u2264 n \u2264 10^9) \u2014 the number of burles to be paid by Polycarp.\\n\\nOutput\\n\\nFor each test case, output a separate line containing two integers c_1 and c_2 (c_1, c_2 \u2265 0) separated by a space where c_1 is the number of coins of 1 burle and c_2 is the number of coins of 2 burles. If there are multiple optimal solutions, print any one.\\n\\nExample\\n\\nInput\\n\\n\\n6\\n1000\\n30\\n1\\n32\\n1000000000\\n5\\n\\n\\nOutput\\n\\n\\n334 333\\n10 10\\n1 0\\n10 11\\n333333334 333333333\\n1 2\\n\\nNote\\n\\nThe answer for the first test case is \\\"334 333\\\". The sum of the nominal values of all coins is 334 \u22c5 1 + 333 \u22c5 2 = 1000, whereas |334 - 333| = 1. One can't get the better value because if |c_1 - c_2| = 0, then c_1 = c_2 and c_1 \u22c5 1 + c_1 \u22c5 2 = 1000, but then the value of c_1 isn't an integer.\\n\\nThe answer for the second test case is \\\"10 10\\\". The sum of the nominal values is 10 \u22c5 1 + 10 \u22c5 2 = 30 and |10 - 10| = 0, whereas there's no number having an absolute value less than 0.\\nThe above is tricky. Write me a correct solution in JAVA.\",\"targets\":\"import java.util.*;\\nimport java.io.*;\\n\\/\\/import java.math.BigInteger;\\npublic class Main{\\n\\t\\t\\n\\tstatic class FastReader {\\n        BufferedReader br;\\n        StringTokenizer st;\\n \\n        public FastReader()\\n        {\\n            br = new BufferedReader(\\n                new InputStreamReader(System.in));\\n        }\\n \\n        String next()\\n        {\\n            while (st == null || !st.hasMoreElements()) {\\n                try {\\n                    st = new StringTokenizer(br.readLine());\\n                }\\n                catch (IOException e) {\\n                    e.printStackTrace();\\n                }\\n            }\\n            return st.nextToken();\\n        }\\n \\n        int nextInt() { return Integer.parseInt(next()); }\\n \\n        long nextLong() { return Long.parseLong(next()); }\\n \\n        double nextDouble()\\n        {\\n            return Double.parseDouble(next());\\n        }\\n \\n        String nextLine()\\n        {\\n            String str = \\\"\\\";\\n            try {\\n                str = br.readLine();\\n            }\\n            catch (IOException e) {\\n                e.printStackTrace();\\n            }\\n            return str;\\n        }\\n    }\\n\\t\\n\\t\\n\\t    \\n\\t\\n public static void main(String[] args) throws IOException{\\n\\t FastReader fr=new FastReader();\\n\\t int t=fr.nextInt();\\n\\twhile(t-->0) {\\n\\t\\t int n=fr.nextInt();\\n\\t\\t int c = (n+1)\\/3;\\n\\t\\t\\tint c2 = n - c*2;\\n\\t\\t\\tSystem.out.println(c2 + \\\" \\\" + c);\\n\\t}\\n\\t \\n \\t}\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in CPP?\\nIt's the year 4527 and the tanks game that we all know and love still exists. There also exists Great Gena's code, written in 2016. The problem this code solves is: given the number of tanks that go into the battle from each country, find their product. If it is turns to be too large, then the servers might have not enough time to assign tanks into teams and the whole game will collapse!\\n\\nThere are exactly n distinct countries in the world and the i-th country added ai tanks to the game. As the developers of the game are perfectionists, the number of tanks from each country is beautiful. A beautiful number, according to the developers, is such number that its decimal representation consists only of digits '1' and '0', moreover it contains at most one digit '1'. However, due to complaints from players, some number of tanks of one country was removed from the game, hence the number of tanks of this country may not remain beautiful.\\n\\nYour task is to write the program that solves exactly the same problem in order to verify Gena's code correctness. Just in case.\\n\\nInput\\n\\nThe first line of the input contains the number of countries n (1 \u2264 n \u2264 100 000). The second line contains n non-negative integers ai without leading zeroes \u2014 the number of tanks of the i-th country.\\n\\nIt is guaranteed that the second line contains at least n - 1 beautiful numbers and the total length of all these number's representations doesn't exceed 100 000.\\n\\nOutput\\n\\nPrint a single number without leading zeroes \u2014 the product of the number of tanks presented by each country.\\n\\nExamples\\n\\nInput\\n\\n3\\n5 10 1\\n\\n\\nOutput\\n\\n50\\n\\nInput\\n\\n4\\n1 1 10 11\\n\\n\\nOutput\\n\\n110\\n\\nInput\\n\\n5\\n0 3 1 100 1\\n\\n\\nOutput\\n\\n0\\n\\nNote\\n\\nIn sample 1 numbers 10 and 1 are beautiful, number 5 is not not.\\n\\nIn sample 2 number 11 is not beautiful (contains two '1's), all others are beautiful.\\n\\nIn sample 3 number 3 is not beautiful, all others are beautiful.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\ndouble EPS = 1e-8;\\nint main() {\\n  ios_base::sync_with_stdio(0);\\n  cin.tie(0);\\n  cout.tie(0);\\n  int n;\\n  cin >> n;\\n  vector<string> v(n);\\n  string result = \\\"1\\\";\\n  int zerocount = 0;\\n  for (int i = 0; i < n; i++) {\\n    bool beautiful = 1;\\n    cin >> v[i];\\n    if (v[i] == \\\"0\\\") {\\n      cout << 0;\\n      return 0;\\n    }\\n    int temp = 0;\\n    if (v[i][0] == '1')\\n      for (size_t j = 1; j < v[i].size(); j++) {\\n        if (v[i][j] != '0') beautiful = 0;\\n        temp++;\\n      }\\n    else\\n      beautiful = 0;\\n    if (beautiful)\\n      zerocount += temp;\\n    else\\n      result = v[i];\\n  }\\n  for (int i = 0; i < zerocount; i++) {\\n    result += '0';\\n  }\\n  cout << result;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"Petr is a detective in Braginsk. Somebody stole a huge amount of money from a bank and Petr is to catch him. Somebody told Petr that some luxurious car moves along the roads without stopping.\\n\\nPetr knows that it is the robbers who drive the car. The roads in Braginsk are one-directional and each of them connects two intersections. Petr wants to select one intersection such that if the robbers continue to drive the roads indefinitely, they will sooner or later come to that intersection. The initial position of the robbers is unknown. Find such an intersection that fits the requirements.\\n\\nInput\\n\\nThe first line of the input contains two integers n and m (2 \u2264 n \u2264 10^5, 2 \u2264 m \u2264 5 \u22c5 10^5) \u2014 the number of intersections and the number of directed roads in Braginsk, respectively.\\n\\nEach of the next m lines contains two integers u_i and v_i (1 \u2264 u_i, v_i \u2264 n, u_i \u2260 v_i) \u2014 the start and finish of the i-th directed road. It is guaranteed that the robbers can move along the roads indefinitely.\\n\\nOutput\\n\\nPrint a single integer k \u2014 the intersection Petr needs to choose. If there are multiple answers, print any. If there are no such intersections, print -1.\\n\\nExamples\\n\\nInput\\n\\n5 6\\n1 2\\n2 3\\n3 1\\n3 4\\n4 5\\n5 3\\n\\n\\nOutput\\n\\n3\\n\\nInput\\n\\n3 3\\n1 2\\n2 3\\n3 1\\n\\n\\nOutput\\n\\n1\\n\\nNote\\n\\nIn the first example the robbers can move, for example, along the following routes: (1-2-3-1), (3-4-5-3), (1-2-3-4-5-3-1). We can show that if Petr chooses the 3-rd intersection, he will eventually meet the robbers independently of their route.\\\":\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst double pi =\\n    3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342;\\nvector<int> g[500010];\\nchar done[500010];\\nint topoSort[500010];\\nint wsk;\\nvoid dfsSCC(int nr) {\\n  done[nr] = 1;\\n  for (int i = 0; i < ((int)g[nr].size()); ++i)\\n    if (!done[g[nr][i]]) dfsSCC(g[nr][i]);\\n  topoSort[wsk++] = nr;\\n}\\nint sCC, ktoraSCC[500010], ileSCC[500010];\\nvoid findSCC(int nr) {\\n  ktoraSCC[nr] = sCC;\\n  for (int i = 0; i < ((int)g[nr].size()); ++i)\\n    if (!ktoraSCC[g[nr][i]]) findSCC(g[nr][i]);\\n}\\nbool found;\\nvector<int> S;\\nlist<int> cykl;\\nlist<int>::iterator head, posCykl[500010];\\nbool wCyklu[500010];\\nvector<int> res;\\nvoid findFirst(int nr) {\\n  if (found) return;\\n  done[nr] = 1;\\n  S.push_back(nr);\\n  for (int i = 0; i < ((int)g[nr].size()); ++i)\\n    if (!done[g[nr][i]])\\n      findFirst(g[nr][i]);\\n    else if (done[g[nr][i]] == 1 && !found) {\\n      found = 1;\\n      for (int j = ((int)S.size()) - 1; j >= (0); --j) {\\n        cykl.push_front(S[j]);\\n        if (S[j] == g[nr][i]) break;\\n      }\\n      head = cykl.begin();\\n      for (list<int>::iterator it = cykl.begin(); it != cykl.end(); it++) {\\n        posCykl[*it] = it;\\n        wCyklu[*it] = 1;\\n      }\\n    }\\n  S.pop_back();\\n  done[nr] = 2;\\n}\\nvoid remove(list<int>::iterator it) {\\n  if (it == head) head++;\\n  cykl.erase(it);\\n}\\nlist<int>::iterator next(list<int>::iterator it) {\\n  it++;\\n  if (it == cykl.end()) it = head;\\n  return it;\\n}\\nvoid wycieciwuj(int nr) {\\n  for (int i = 0; i < ((int)g[nr].size()); ++i)\\n    if (wCyklu[g[nr][i]]) {\\n      list<int>::iterator pom = posCykl[nr];\\n      list<int>::iterator nast = next(pom);\\n      while (!cykl.empty()) {\\n        if (*nast == g[nr][i]) break;\\n        pom = next(nast);\\n        wCyklu[*nast] = 0;\\n        remove(nast);\\n        nast = pom;\\n      }\\n    }\\n}\\nint gdzieNaCykl[500010];\\nbool removed[500010];\\nint nextNaCyklu[500010];\\nint initialPos[500010];\\nint originalNext[500010];\\nint lengthC;\\nvoid szamajCykl(int p, int k) {\\n  if (cykl.empty()) return;\\n ...\",\"language\":\"python\",\"split\":\"train\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You have received data from a Bubble bot. You know your task is to make factory facilities, but before you even start, you need to know how big the factory is and how many rooms it has. When you look at the data you see that you have the dimensions of the construction, which is in rectangle shape: N x M. \\n\\nThen in the next N lines you have M numbers. These numbers represent factory tiles and they can go from 0 to 15. Each of these numbers should be looked in its binary form. Because from each number you know on which side the tile has walls. For example number 10 in it's binary form is 1010, which means that it has a wall from the North side, it doesn't have a wall from the East, it has a wall on the South side and it doesn't have a wall on the West side. So it goes North, East, South, West. \\n\\nIt is guaranteed that the construction always has walls on it's edges. The input will be correct. \\n\\nYour task is to print the size of the rooms from biggest to smallest. \\n\\nInput\\n\\nThe first line has two numbers which are N and M, the size of the construction. Both are integers: \\n\\nn (1 \u2264 n \u2264 10^3)\\n\\nm (1 \u2264 m \u2264 10^3)\\n\\nNext N x M numbers represent each tile of construction.\\n\\nOutput\\n\\nOnce you finish processing the data your output consists of one line sorted from biggest to smallest room sizes. \\n\\nExample\\n\\nInput\\n\\n\\n4 5\\n9 14 11 12 13\\n5 15 11 6 7\\n5 9 14 9 14\\n3 2 14 3 14\\n\\n\\nOutput\\n\\n\\n9 4 4 2 1\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint a[1005][1005], vis[1005][1005];\\nint ans[10000005];\\nint dx[] = {-1, 0, 1, 0}, dy[] = {0, 1, 0, -1};\\nint w[] = {8, 4, 2, 1};\\nint n, m;\\nint dfs(int x, int y) {\\n  int sum = 1;\\n  if (vis[x][y] || x < 1 || y < 1 || x > n || y > m) return 0;\\n  vis[x][y] = 1;\\n  for (int i = 0; i < 4; i++) {\\n    if (a[x][y] & w[i])\\n      continue;\\n    else\\n      sum += dfs(x + dx[i], y + dy[i]);\\n  }\\n  return sum;\\n}\\nint main() {\\n  cin >> n >> m;\\n  for (int i = 1; i <= n; i++) {\\n    for (int j = 1; j <= m; j++) {\\n      cin >> a[i][j];\\n    }\\n  }\\n  int tot = 1;\\n  for (int i = 1; i <= n; i++) {\\n    for (int j = 1; j <= m; j++) {\\n      if (!vis[i][j]) ans[tot++] = dfs(i, j);\\n    }\\n  }\\n  sort(ans + 1, ans + tot);\\n  for (int i = tot - 1; i >= 1; i--) cout << ans[i] << \\\" \\\";\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"A line on the plane is described by an equation Ax + By + C = 0. You are to find any point on this line, whose coordinates are integer numbers from  - 5\u00b71018 to 5\u00b71018 inclusive, or to find out that such points do not exist.\\n\\nInput\\n\\nThe first line contains three integers A, B and C ( - 2\u00b7109 \u2264 A, B, C \u2264 2\u00b7109) \u2014 corresponding coefficients of the line equation. It is guaranteed that A2 + B2 > 0.\\n\\nOutput\\n\\nIf the required point exists, output its coordinates, otherwise output -1.\\n\\nExamples\\n\\nInput\\n\\n2 5 3\\n\\n\\nOutput\\n\\n6 -3\\n#incl\",\"targets\":\"ude <bits\\/stdc++.h>\\nusing namespace std;\\nconst int INF = 0x3f3f3f3f;\\nconst long long LINF = 0x3f3f3f3f3f3f3f3fLL;\\nconst double PI = acos(-1.0);\\nconst double EPS = 1e-8;\\nconst int MOD = 1e9 + 7;\\ntemplate <typename T>\\nvoid cmin(T &x, T y) {\\n  if (y < x) x = y;\\n}\\ntemplate <typename T>\\nvoid cmax(T &x, T y) {\\n  if (y > x) x = y;\\n}\\nlong long qpow(long long x, long long n, long long mod = MOD) {\\n  long long res = 1;\\n  while (n) {\\n    if (n & 1) res = res * x % mod;\\n    x = x * x % mod;\\n    n >>= 1;\\n  }\\n  return res;\\n}\\nlong long sq(long long x) { return x * x; }\\nnamespace Solver {\\nvoid InitOnce() { int t; }\\nlong long a, b, c;\\nnamespace ExtendedEuclidAlgorithm {\\nlong long exgcd(long long a, long long b, long long &x, long long &y) {\\n  if (b == 0) {\\n    x = 1, y = 0;\\n    return a;\\n  }\\n  long long d = exgcd(b, a % b, x, y), t;\\n  t = x, x = y, y = t - a \\/ b * y;\\n  return d;\\n}\\npair<long long, long long> res;\\nint LCE1(long long a, long long b, long long c) {\\n  long long x, y, d = exgcd(a, b, x, y), t = b \\/ d;\\n  if (c % d != 0) return -1;\\n  long long x0 = ((x % t) * (c \\/ d % t) % t + t) % t, y0 = (c - a * x0) \\/ b;\\n  res = pair<long long, long long>(x0, y0);\\n  return 1;\\n}\\nlong long LCE2(long long a, long long r, long long m) {\\n  long long x, y, d = exgcd(a, m, x, y), t = m \\/ d;\\n  if (r % d != 0) return -1;\\n  long long x0 = ((x % t) * (r \\/ d % t) % t + t) % t;\\n  return x0;\\n}\\nlong long inv(long long a, long long m) {\\n  long long x, y, d = exgcd(a, m, x, y);\\n  if (d != 1) return -1;\\n  long long x0 = (x % m + m) % m;\\n  return x0;\\n}\\n}  \\/\\/ namespace ExtendedEuclidAlgorithm\\nvoid Read() {\\n  int res = scanf(\\\"%lld%lld%lld\\\", &a, &b, &c);\\n  if (res == -1) exit(0);\\n}\\nvoid Solve() {\\n  if (b == 0) {\\n    if (-c % a != 0) {\\n      puts(\\\"-1\\\");\\n      return;\\n    }\\n    printf(\\\"%lld 0\\\\n\\\", (-c) \\/ a);\\n    return;\\n  }\\n  if (a == 0) {\\n    if (-c % b != 0) {\\n      puts(\\\"-1\\\");\\n      return;\\n    }\\n    printf(\\\"0 %lld\\\\n\\\", (-c) \\/ b);\\n    return;\\n  }\\n  int res1 = ExtendedEuclidAlgorithm::LCE1(a, b, -c);\\n  if (res1 == -1) {\\n    puts(\\\"-1\\\");\\n    return;\\n  }\\n ...\",\"language\":\"python\",\"split\":\"train\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You are given an integer array a_1, a_2, ..., a_n and integer k.\\n\\nIn one step you can \\n\\n  * either choose some index i and decrease a_i by one (make a_i = a_i - 1); \\n  * or choose two indices i and j and set a_i equal to a_j (make a_i = a_j). \\n\\n\\n\\nWhat is the minimum number of steps you need to make the sum of array \u2211_{i=1}^{n}{a_i} \u2264 k? (You are allowed to make values of array negative).\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases.\\n\\nThe first line of each test case contains two integers n and k (1 \u2264 n \u2264 2 \u22c5 10^5; 1 \u2264 k \u2264 10^{15}) \u2014 the size of array a and upper bound on its sum.\\n\\nThe second line of each test case contains n integers a_1, a_2, ..., a_n (1 \u2264 a_i \u2264 10^9) \u2014 the array itself.\\n\\nIt's guaranteed that the sum of n over all test cases doesn't exceed 2 \u22c5 10^5.\\n\\nOutput\\n\\nFor each test case, print one integer \u2014 the minimum number of steps to make \u2211_{i=1}^{n}{a_i} \u2264 k.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n1 10\\n20\\n2 69\\n6 9\\n7 8\\n1 2 1 3 1 2 1\\n10 1\\n1 2 3 1 2 6 1 6 8 10\\n\\n\\nOutput\\n\\n\\n10\\n0\\n2\\n7\\n\\nNote\\n\\nIn the first test case, you should decrease a_1 10 times to get the sum lower or equal to k = 10.\\n\\nIn the second test case, the sum of array a is already less or equal to 69, so you don't need to change it.\\n\\nIn the third test case, you can, for example: \\n\\n  1. set a_4 = a_3 = 1; \\n  2. decrease a_4 by one, and get a_4 = 0. \\n\\nAs a result, you'll get array [1, 2, 1, 0, 1, 2, 1] with sum less or equal to 8 in 1 + 1 = 2 steps.\\n\\nIn the fourth test case, you can, for example: \\n\\n  1. choose a_7 and decrease in by one 3 times; you'll get a_7 = -2; \\n  2. choose 4 elements a_6, a_8, a_9 and a_{10} and them equal to a_7 = -2. \\n\\nAs a result, you'll get array [1, 2, 3, 1, 2, -2, -2, -2, -2, -2] with sum less or equal to 1 in 3 + 4 = 7 steps.\",\"targets\":\"import math\\nfor i in range(int(input())):\\n    n,k=map(int,input().split())\\n    a=[int(j) for j in input().split()]\\n    a.sort()\\n    if sum(a)<=k:\\n        print('0')\\n    elif n==1:\\n        print(a[0]-k)\\n    else:\\n        sumi,cnt=0,0\\n        cost=[]\\n        for j in range(1,n):\\n            sumi+=a[j]\\n            cnt+=1\\n            x=math.floor((k-sumi)\\/(n-cnt))\\n            cost.append(n-cnt-1+max(a[0]-x,0))\\n        cost.append(max(a[0]-(k\\/\\/n),0)+n-1)\\n        #print(cost)\\n        print(min(cost))\",\"language\":\"python\",\"split\":\"test\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Polycarp must pay exactly n burles at the checkout. He has coins of two nominal values: 1 burle and 2 burles. Polycarp likes both kinds of coins equally. So he doesn't want to pay with more coins of one type than with the other.\\n\\nThus, Polycarp wants to minimize the difference between the count of coins of 1 burle and 2 burles being used. Help him by determining two non-negative integer values c_1 and c_2 which are the number of coins of 1 burle and 2 burles, respectively, so that the total value of that number of coins is exactly n (i. e. c_1 + 2 \u22c5 c_2 = n), and the absolute value of the difference between c_1 and c_2 is as little as possible (i. e. you must minimize |c_1-c_2|).\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases. Then t test cases follow.\\n\\nEach test case consists of one line. This line contains one integer n (1 \u2264 n \u2264 10^9) \u2014 the number of burles to be paid by Polycarp.\\n\\nOutput\\n\\nFor each test case, output a separate line containing two integers c_1 and c_2 (c_1, c_2 \u2265 0) separated by a space where c_1 is the number of coins of 1 burle and c_2 is the number of coins of 2 burles. If there are multiple optimal solutions, print any one.\\n\\nExample\\n\\nInput\\n\\n\\n6\\n1000\\n30\\n1\\n32\\n1000000000\\n5\\n\\n\\nOutput\\n\\n\\n334 333\\n10 10\\n1 0\\n10 11\\n333333334 333333333\\n1 2\\n\\nNote\\n\\nThe answer for the first test case is \\\"334 333\\\". The sum of the nominal values of all coins is 334 \u22c5 1 + 333 \u22c5 2 = 1000, whereas |334 - 333| = 1. One can't get the better value because if |c_1 - c_2| = 0, then c_1 = c_2 and c_1 \u22c5 1 + c_1 \u22c5 2 = 1000, but then the value of c_1 isn't an integer.\\n\\nThe answer for the second test case is \\\"10 10\\\". The sum of the nominal values is 10 \u22c5 1 + 10 \u22c5 2 = 30 and |10 - 10| = 0, whereas there's no number having an absolute value less than 0.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint main() {\\n  long long t, n, c1, c2;\\n  cin >> t;\\n  for (int i = 0; i < t; ++i) {\\n    cin >> n;\\n    c1 = n \\/ 3;\\n    c2 = n \\/ 3;\\n    if (n % 3 == 1) {\\n      c1++;\\n    } else if (n % 3 == 2) {\\n      c2++;\\n    }\\n    cout << c1 << \\\" \\\" << c2 << \\\"\\\\n\\\";\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"A total of n depots are located on a number line. Depot i lies at the point x_i for 1 \u2264 i \u2264 n.\\n\\nYou are a salesman with n bags of goods, attempting to deliver one bag to each of the n depots. You and the n bags are initially at the origin 0. You can carry up to k bags at a time. You must collect the required number of goods from the origin, deliver them to the respective depots, and then return to the origin to collect your next batch of goods.\\n\\nCalculate the minimum distance you need to cover to deliver all the bags of goods to the depots. You do not have to return to the origin after you have delivered all the bags.\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 10 500). Description of the test cases follows.\\n\\nThe first line of each test case contains two integers n and k (1 \u2264 k \u2264 n \u2264 2 \u22c5 10^5).\\n\\nThe second line of each test case contains n integers x_1, x_2, \u2026, x_n (-10^9 \u2264 x_i \u2264 10^9). It is possible that some depots share the same position.\\n\\nIt is guaranteed that the sum of n over all test cases does not exceed 2 \u22c5 10^5.\\n\\nOutput\\n\\nFor each test case, output a single integer denoting the minimum distance you need to cover to deliver all the bags of goods to the depots. \\n\\nExample\\n\\nInput\\n\\n\\n4\\n5 1\\n1 2 3 4 5\\n9 3\\n-5 -10 -15 6 5 8 3 7 4\\n5 3\\n2 2 3 3 3\\n4 2\\n1000000000 1000000000 1000000000 1000000000\\n\\n\\nOutput\\n\\n\\n25\\n41\\n7\\n3000000000\\n\\nNote\\n\\nIn the first test case, you can carry only one bag at a time. Thus, the following is a solution sequence that gives a minimum travel distance: 0 \u2192 2 \u2192 0 \u2192 4 \u2192 0 \u2192 3 \u2192 0 \u2192 1 \u2192 0 \u2192 5, where each 0 means you go the origin and grab one bag, and each positive integer means you deliver the bag to a depot at this coordinate, giving a total distance of 25 units. It must be noted that there are other sequences that give the same distance.\\n\\nIn the second test case, you can follow the following sequence, among multiple such sequences, to travel minimum distance: 0 \u2192 6 \u2192 8 \u2192 7 \u2192 0 \u2192 5 \u2192 4 \u2192 3 \u2192 0 \u2192 (-5) \u2192 (-10) \u2192 (-15), with distance...\\n# SHR\",\"targets\":\"i GANESHA    author: Kunal Verma #\\n\\nimport os\\nimport random\\nimport sys\\n\\nfrom itertools import *\\n\\nfrom io import BytesIO, IOBase\\nfrom math import inf\\n\\n\\ndef lcm(a, b):\\n    return (a * b) \\/\\/ gcd(a, b)\\n\\n\\n'''\\n    mod = 10 ** 9 + 7\\n    fac = [1]\\n    for i in range(1, 2 * 10 ** 5 + 1):\\n        fac.append((fac[-1] * i) % mod)\\n    fac_in = [pow(fac[-1], mod - 2, mod)]\\n    for i in range(2 * 10 ** 5, 0, -1):\\n        fac_in.append((fac_in[-1] * i) % mod)\\n    fac_in.reverse()\\n    def comb(a, b):\\n        if a < b:\\n            return 0\\n        return (fac[a] * fac_in[b] * fac_in[a - b]) % mod\\n'''\\n\\n\\n# MAXN = 10000004\\n# spf = [0 for i in range(MAXN)]\\n# adj = [[] for i in range(MAXN)]\\ndef sieve():\\n    global spf, adj, MAXN\\n    spf[1] = 1\\n    for i in range(2, MAXN):\\n        spf[i] = i\\n\\n    for i in range(2, MAXN):\\n        if i * i > MAXN:\\n            break\\n        if (spf[i] == i):\\n            for j in range(i * i, MAXN, i):\\n                if (spf[j] == j):\\n                    spf[j] = i\\n\\n\\ndef getdistinctFactorization(n):\\n    global adj, spf, MAXN\\n    for i in range(1, n + 1):\\n        index = 1\\n        x = i\\n        if (x != 1):\\n            adj[i].append(spf[x])\\n        x = x \\/\\/ spf[x]\\n        while (x != 1):\\n            if (adj[i][index - 1] != spf[x]):\\n                adj[i].append(spf[x])\\n                index += 1\\n            x = x \\/\\/ spf[x]\\n\\n\\ndef printDivisors(n):\\n    i = 2\\n    z = [1, n]\\n    while i <= sqrt(n):\\n        if (n % i == 0):\\n            if (n \\/ i == i):\\n                z.append(i)\\n            else:\\n                z.append(i)\\n                z.append(n \\/\\/ i)\\n        i = i + 1\\n    return z\\n\\n\\ndef create(n, x, f):\\n    pq = len(bin(n)[2:])\\n    if f == 0:\\n        tt = min\\n    else:\\n        tt = max\\n    dp = [[inf] * n for _ in range(pq)]\\n    dp[0] = x\\n    for i in range(1, pq):\\n        for j in range(n - (1 << i) + 1):\\n            dp[i][j] = tt(dp[i - 1][j], dp[i - 1][j + (1 << (i - 1))])\\n    return dp\\n\\n\\ndef enquiry(l, r, dp, f):\\n    if l > r:\\n        return inf if not f else -inf\\n    if f == 1:\\n        tt = max\\n...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You are given n integers a_1, a_2, \u2026, a_n and an integer k. Find the maximum value of i \u22c5 j - k \u22c5 (a_i | a_j) over all pairs (i, j) of integers with 1 \u2264 i < j \u2264 n. Here, | is the [bitwise OR operator](https:\\/\\/en.wikipedia.org\\/wiki\\/Bitwise_operation#OR).\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 10 000) \u2014 the number of test cases.\\n\\nThe first line of each test case contains two integers n (2 \u2264 n \u2264 10^5) and k (1 \u2264 k \u2264 min(n, 100)).\\n\\nThe second line of each test case contains n integers a_1, a_2, \u2026, a_n (0 \u2264 a_i \u2264 n).\\n\\nIt is guaranteed that the sum of n over all test cases doesn't exceed 3 \u22c5 10^5.\\n\\nOutput\\n\\nFor each test case, print a single integer \u2014 the maximum possible value of i \u22c5 j - k \u22c5 (a_i | a_j).\\n\\nExample\\n\\nInput\\n\\n\\n4\\n3 3\\n1 1 3\\n2 2\\n1 2\\n4 3\\n0 1 2 3\\n6 6\\n3 2 0 0 5 6\\n\\n\\nOutput\\n\\n\\n-1\\n-4\\n3\\n12\\n\\nNote\\n\\nLet f(i, j) = i \u22c5 j - k \u22c5 (a_i | a_j).\\n\\nIn the first test case, \\n\\n  * f(1, 2) = 1 \u22c5 2 - k \u22c5 (a_1 | a_2) = 2 - 3 \u22c5 (1 | 1) = -1. \\n  * f(1, 3) = 1 \u22c5 3 - k \u22c5 (a_1 | a_3) = 3 - 3 \u22c5 (1 | 3) = -6. \\n  * f(2, 3) = 2 \u22c5 3 - k \u22c5 (a_2 | a_3) = 6 - 3 \u22c5 (1 | 3) = -3. \\n\\n\\n\\nSo the maximum is f(1, 2) = -1.\\n\\nIn the fourth test case, the maximum is f(3, 4) = 12.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst int maxn = 3e5 + 5;\\nint a[maxn];\\nint main() {\\n  ios::sync_with_stdio(false);\\n  cin.tie(0), cout.tie(0);\\n  int t;\\n  cin >> t;\\n  while (t--) {\\n    int n, k;\\n    cin >> n >> k;\\n    memset(a, 0, sizeof(a));\\n    for (long long i = 1; i <= n; ++i) cin >> a[i];\\n    long long temp = -1e18;\\n    for (long long i = n; i >= 1; --i) {\\n      for (long long j = i - 1; j >= 1; --j) {\\n        if (long long(i * j) < temp) break;\\n        temp = max(long long(i * j - k * (a[i] | a[j])), temp);\\n      }\\n    }\\n    cout << temp << endl;\\n  }\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Monocarp is playing a computer game. Now he wants to complete the first level of this game.\\n\\nA level is a rectangular grid of 2 rows and n columns. Monocarp controls a character, which starts in cell (1, 1) \u2014 at the intersection of the 1-st row and the 1-st column.\\n\\nMonocarp's character can move from one cell to another in one step if the cells are adjacent by side and\\/or corner. Formally, it is possible to move from cell (x_1, y_1) to cell (x_2, y_2) in one step if |x_1 - x_2| \u2264 1 and |y_1 - y_2| \u2264 1. Obviously, it is prohibited to go outside the grid.\\n\\nThere are traps in some cells. If Monocarp's character finds himself in such a cell, he dies, and the game ends.\\n\\nTo complete a level, Monocarp's character should reach cell (2, n) \u2014 at the intersection of row 2 and column n.\\n\\nHelp Monocarp determine if it is possible to complete the level.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 100) \u2014 the number of test cases. Then the test cases follow. Each test case consists of three lines.\\n\\nThe first line contains a single integer n (3 \u2264 n \u2264 100) \u2014 the number of columns.\\n\\nThe next two lines describe the level. The i-th of these lines describes the i-th line of the level \u2014 the line consists of the characters '0' and '1'. The character '0' corresponds to a safe cell, the character '1' corresponds to a trap cell.\\n\\nAdditional constraint on the input: cells (1, 1) and (2, n) are safe.\\n\\nOutput\\n\\nFor each test case, output YES if it is possible to complete the level, and NO otherwise.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n3\\n000\\n000\\n4\\n0011\\n1100\\n4\\n0111\\n1110\\n6\\n010101\\n101010\\n\\n\\nOutput\\n\\n\\nYES\\nYES\\nNO\\nYES\\n\\nNote\\n\\nConsider the example from the statement.\\n\\nIn the first test case, one of the possible paths is (1, 1) \u2192 (2, 2) \u2192 (2, 3).\\n\\nIn the second test case, one of the possible paths is (1, 1) \u2192 (1, 2) \u2192 (2, 3) \u2192 (2, 4).\\n\\nIn the fourth test case, one of the possible paths is (1, 1) \u2192 (2, 2) \u2192 (1, 3) \u2192 (2, 4) \u2192 (1, 5) \u2192 (2, 6).\\nThe above is tricky. Write me a correct solution in PYTHON3.\",\"targets\":\"#!\\/usr\\/bin\\/env python\\nfrom __future__ import division, print_function\\nimport os\\nimport sys\\nfrom io import BytesIO, IOBase\\nfrom collections import *\\nfrom bisect import *\\nfrom string import *\\nfrom itertools import * \\nfrom statistics import *\\nfrom math import *\\nfrom re import *\\nfrom queue import *\\nmod  = int(1e9+7)\\nmod1 = 998244353\\nimax = float(\\\"inf\\\")\\nimin = float(\\\"-inf\\\")\\ntrue = True\\nfalse= False\\nN \\t = 10**5\\nnone = None\\ninp  = lambda : input()\\nI    = lambda : int(inp())\\nM    = lambda : map(int,inp().split())\\nMS   = lambda : map(str,inp().split())\\nS    = lambda : list(MS())\\nL    = lambda : list(M())\\ntest_case_run__ = false;\\ndef case():global test_case_run__;test_case_run__ = true;\\nif sys.version_info[0] < 3:\\n    from __builtin__ import xrange as range\\n    from future_builtins import ascii, filter, hex, map, oct, zip\\n#-------------------------------------------------------------------------------------------------------------------------------------\\n\\n\\ncase()\\ndef main():\\n    n=I()\\n    \\n    s=inp()\\n    t=inp()\\n    def find():\\n        for i in range(n):\\n            if s[i] == '1' and t[i] == '1':\\n                return false\\n        return true;\\n    a=find()\\n    print(\\\"YES\\\" if a else \\\"NO\\\")\\n\\n\\n#-------------------------------------------------------------------------------------------------------------------------------------\\nBUFSIZE = 8192\\nclass FastIO(IOBase):\\n    newlines = 0\\n    def __init__(self, file):\\n        self._fd = file.fileno()\\n        self.buffer = BytesIO()\\n        self.writable = \\\"x\\\" in file.mode or \\\"r\\\" not in file.mode\\n        self.write = self.buffer.write if self.writable else None\\n    def read(self):\\n        while true:\\n            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))\\n            if not b:\\n                break\\n            ptr = self.buffer.tell()\\n            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)\\n        self.newlines = 0\\n        return self.buffer.read()\\n    def readline(self):\\n        while self.newlines == 0:\\n            b =...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"Interest rates are attached to the money deposited in banks, and the calculation method and interest rates vary from bank to bank. The combination of interest and principal is called principal and interest, but as a method of calculating principal and interest, there are \\\"single interest\\\" that calculates without incorporating interest into the principal and \\\"compound interest\\\" that calculates by incorporating interest into the principal. Yes, you must understand this difference in order to get more principal and interest. The calculation method of principal and interest is as follows.\\n\\n<image>\\n\\n<image>\\n\\n\\nEnter the number of banks, the number of years to deposit money, and the information of each bank (bank number, interest rate type, annual interest rate (percentage)), and create a program that outputs the bank number with the highest principal and interest. However, only one bank has the highest principal and interest.\\n\\n\\n\\ninput\\n\\nGiven multiple datasets. The end of the input is indicated by a single zero. Each dataset is given in the following format:\\n\\n\\nn\\ny\\nb1 r1 t1\\nb2 r2 t2\\n::\\nbn rn tn\\n\\n\\nThe first line gives the number of banks n (1 \u2264 n \u2264 50) and the second line gives the number of years to deposit money y (1 \u2264 y \u2264 30). The next n lines are given the bank number bi of the i-th bank, the integer ri (1 \u2264 ri \u2264 100) representing the annual interest rate, and the interest rate type ti (1 or 2). The interest rate type ti is given as 1 for simple interest and 2 for compound interest.\\n\\nThe number of datasets does not exceed 100.\\n\\noutput\\n\\nFor each dataset, the bank number with the highest principal and interest is output on one line.\\n\\nExample\\n\\nInput\\n\\n2\\n8\\n1 5 2\\n2 6 1\\n2\\n9\\n1 5 2\\n2 6 1\\n0\\n\\n\\nOutput\\n\\n2\\n1\\\":\",\"targets\":\"#include<iostream>\\nusing namespace std;\\nint main(){\\n  double n,y;\\n  while(cin>>n){\\n    if(n==0) break;\\n    cin >> y;\\n    double b,r,t,ans=0,ansb;\\n    for(int i=0;i<n;i++){\\n      cin >> b >> r >> t;\\n      if(t==1){\\n\\tif(ans<1+y*(r\\/100)){\\n\\t  ans = 1+y*(r\\/100);\\n\\t  ansb = b;\\n\\t}\\n      }\\n      else if(t==2){\\n\\tdouble k = 1+r\\/100;\\n\\tfor(int i=1;i<y;i++) k *= 1+r\\/100;\\n\\tif(ans<k){\\n\\t  ans = k;\\n\\t  ansb = b;\\n\\t}\\n      }\\n    }\\n    cout << ansb << endl;\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Let's define S(x) to be the sum of digits of number x written in decimal system. For example, S(5) = 5, S(10) = 1, S(322) = 7.\\n\\nWe will call an integer x interesting if S(x + 1) < S(x). In each test you will be given one integer n. Your task is to calculate the number of integers x such that 1 \u2264 x \u2264 n and x is interesting.\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 1000) \u2014 number of test cases.\\n\\nThen t lines follow, the i-th line contains one integer n (1 \u2264 n \u2264 10^9) for the i-th test case.\\n\\nOutput\\n\\nPrint t integers, the i-th should be the answer for the i-th test case.\\n\\nExample\\n\\nInput\\n\\n\\n5\\n1\\n9\\n10\\n34\\n880055535\\n\\n\\nOutput\\n\\n\\n0\\n1\\n1\\n3\\n88005553\\n\\nNote\\n\\nThe first interesting number is equal to 9.\\nUsing python3 can you solve the prior task?\",\"targets\":\"for _ in range(int(input())):\\n    n = int(input())\\n    print(int((n+1)\\/10))\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You are given a matrix, consisting of n rows and m columns. The rows are numbered top to bottom, the columns are numbered left to right.\\n\\nEach cell of the matrix can be either free or locked.\\n\\nLet's call a path in the matrix a staircase if it: \\n\\n  * starts and ends in the free cell; \\n  * visits only free cells; \\n  * has one of the two following structures: \\n    1. the second cell is 1 to the right from the first one, the third cell is 1 to the bottom from the second one, the fourth cell is 1 to the right from the third one, and so on; \\n    2. the second cell is 1 to the bottom from the first one, the third cell is 1 to the right from the second one, the fourth cell is 1 to the bottom from the third one, and so on. \\n\\n\\n\\nIn particular, a path, consisting of a single cell, is considered to be a staircase.\\n\\nHere are some examples of staircases:\\n\\n<image>\\n\\nInitially all the cells of the matrix are free.\\n\\nYou have to process q queries, each of them flips the state of a single cell. So, if a cell is currently free, it makes it locked, and if a cell is currently locked, it makes it free.\\n\\nPrint the number of different staircases after each query. Two staircases are considered different if there exists such a cell that appears in one path and doesn't appear in the other path.\\n\\nInput\\n\\nThe first line contains three integers n, m and q (1 \u2264 n, m \u2264 1000; 1 \u2264 q \u2264 10^4) \u2014 the sizes of the matrix and the number of queries.\\n\\nEach of the next q lines contains two integers x and y (1 \u2264 x \u2264 n; 1 \u2264 y \u2264 m) \u2014 the description of each query.\\n\\nOutput\\n\\nPrint q integers \u2014 the i-th value should be equal to the number of different staircases after i queries. Two staircases are considered different if there exists such a cell that appears in one path and doesn't appear in the other path.\\n\\nExamples\\n\\nInput\\n\\n\\n2 2 8\\n1 1\\n1 1\\n1 1\\n2 2\\n1 1\\n1 2\\n2 1\\n1 1\\n\\n\\nOutput\\n\\n\\n5\\n10\\n5\\n2\\n5\\n3\\n1\\n0\\n\\n\\nInput\\n\\n\\n3 4 10\\n1 4\\n1 2\\n2 3\\n1 2\\n2 3\\n3 2\\n1 3\\n3 4\\n1 3\\n3 1\\n\\n\\nOutput\\n\\n\\n49\\n35\\n24\\n29\\n49\\n39\\n31\\n23\\n29\\n27\\n\\n\\nInput\\n\\n\\n1000 1000 2\\n239 634\\n239 634\\n\\n\\nOutput\\n\\n\\n1332632508\\n1333333000\\n#incl\",\"targets\":\"ude <bits\\/stdc++.h>\\nusing namespace std;\\nmt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\\ntemplate <typename T>\\nistream &operator>>(istream &in, vector<T> &v) {\\n  for (auto &x : v) in >> x;\\n  return in;\\n}\\ntemplate <typename T>\\nostream &operator<<(ostream &out, const vector<T> &v) {\\n  for (auto &x : v) out << x << ' ';\\n  return out;\\n}\\ntemplate <typename T1, typename T2>\\nistream &operator>>(istream &in, pair<T1, T2> &p) {\\n  in >> p.first >> p.second;\\n  return in;\\n}\\ntemplate <typename T1, typename T2>\\nostream &operator<<(ostream &out, const pair<T1, T2> &p) {\\n  out << p.first << ' ' << p.second;\\n  return out;\\n}\\nlong long n, m;\\nvector<vector<long long> > a;\\nlong long solve(long long x, long long y) {\\n  long long ans = 0;\\n  long long c1 = 0, c2 = 0;\\n  pair<long long, long long> p = {x, y};\\n  bool turn = 1;\\n  while (true) {\\n    if (turn)\\n      p.first--;\\n    else\\n      p.second--;\\n    turn = 1 - turn;\\n    if (p.first < 0 || p.second < 0) break;\\n    if (a[p.first][p.second] == 1) break;\\n    c1++;\\n  }\\n  p = {x, y};\\n  turn = 1;\\n  while (true) {\\n    if (turn)\\n      p.second++;\\n    else\\n      p.first++;\\n    turn = 1 - turn;\\n    if (p.first >= n || p.second >= m) break;\\n    if (a[p.first][p.second] == 1) break;\\n    c2++;\\n  }\\n  ans += c2 * c1 + c1 + c2;\\n  c1 = 0, c2 = 0;\\n  p = {x, y};\\n  turn = 1;\\n  while (true) {\\n    if (turn)\\n      p.second--;\\n    else\\n      p.first--;\\n    turn = 1 - turn;\\n    if (p.first < 0 || p.second < 0) break;\\n    if (a[p.first][p.second] == 1) break;\\n    c2++;\\n  }\\n  p = {x, y};\\n  turn = 1;\\n  while (true) {\\n    if (turn)\\n      p.first++;\\n    else\\n      p.second++;\\n    turn = 1 - turn;\\n    if (p.first >= n || p.second >= m) break;\\n    if (a[p.first][p.second] == 1) break;\\n    c1++;\\n  }\\n  ans += c2 * c1 + c1 + c2;\\n  return ans;\\n}\\nlong long nC2(long long x) { return x * (x - 1) \\/ 2; }\\nlong long calc() {\\n  long long ans = 0;\\n  for (int i = 0; i < m; i++) {\\n    if (n >= m - i)\\n      ans += nC2(2 * (m - i - 1) + 1);\\n    else\\n      ans += nC2(2 * n);\\n  }\\n  swap(n, m);\\n  for (int i = 0;...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"The only difference between this problem and D2 is that you don't have to provide the way to construct the answer in this problem, but you have to do it in D2.\\n\\nThere's a table of n \u00d7 m cells (n rows and m columns). The value of n \u22c5 m is even.\\n\\nA domino is a figure that consists of two cells having a common side. It may be horizontal (one of the cells is to the right of the other) or vertical (one of the cells is above the other).\\n\\nYou need to find out whether it is possible to place nm\\/2 dominoes on the table so that exactly k of them are horizontal and all the other dominoes are vertical. The dominoes cannot overlap and must fill the whole table.\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 10) \u2014 the number of test cases. Then t test cases follow.\\n\\nEach test case consists of a single line. The line contains three integers n, m, k (1 \u2264 n,m \u2264 100, 0 \u2264 k \u2264 nm\\/2, n \u22c5 m is even) \u2014 the number of rows, columns and horizontal dominoes, respectively.\\n\\nOutput\\n\\nFor each test case output \\\"YES\\\", if it is possible to place dominoes in the desired way, or \\\"NO\\\" otherwise.\\n\\nYou may print each letter in any case (YES, yes, Yes will all be recognized as positive answer, NO, no and nO will all be recognized as negative answer).\\n\\nExample\\n\\nInput\\n\\n\\n8\\n4 4 2\\n2 3 0\\n3 2 3\\n1 2 0\\n2 4 2\\n5 2 2\\n2 17 16\\n2 1 1\\n\\n\\nOutput\\n\\n\\nYES\\nYES\\nYES\\nNO\\nYES\\nNO\\nYES\\nNO\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst long long mod = 1000000007;\\nconst long long inf = 1LL << 62;\\nconst long long mx = 100005;\\nconst double eps = 1e-10;\\nlong long dx[10] = {1, 0, -1, 0}, dy[10] = {0, -1, 0, 1};\\nlong long power(long long a, long long b) {\\n  if (b == 0) return 1;\\n  long long x = power(a, b \\/ 2);\\n  x = x * x;\\n  if (b % 2) x = x * a;\\n  return x;\\n}\\nlong long bigmod(long long a, long long b) {\\n  if (b == 0) return 1;\\n  long long x = bigmod(a, b \\/ 2) % mod;\\n  x = (x * x) % mod;\\n  if (b % 2) x = (x * a) % mod;\\n  return x;\\n}\\nlong long Set(long long N, long long pos) { return N = N | (1LL << pos); }\\nlong long reset(long long N, long long pos) { return N = N & ~(1LL << pos); }\\nbool check(long long N, long long pos) { return (bool)(N & (1LL << pos)); }\\nint main() {\\n  long long tst, a, b, c, k, n, m, res = 0, ans = 0, t = 0;\\n  scanf(\\\"%lld\\\", &tst);\\n  while (tst--) {\\n    scanf(\\\"%lld\\\", &n), scanf(\\\"%lld\\\", &m), scanf(\\\"%lld\\\", &k);\\n    a = (n * m) \\/ 2 - k;\\n    if (n % 2 == 0 and m % 2 == 0) {\\n      if (k % 2 == 0) {\\n        cout << \\\"YES\\\"\\n             << \\\"\\\\n\\\";\\n      } else {\\n        cout << \\\"NO\\\"\\n             << \\\"\\\\n\\\";\\n      }\\n      continue;\\n    }\\n    if (m & 1) {\\n      if (a < n \\/ 2) {\\n        cout << \\\"NO\\\"\\n             << \\\"\\\\n\\\";\\n        continue;\\n      }\\n      a = a - n \\/ 2;\\n      if (a % 2 == 0) {\\n        cout << \\\"YES\\\"\\n             << \\\"\\\\n\\\";\\n      } else {\\n        cout << \\\"NO\\\"\\n             << \\\"\\\\n\\\";\\n      }\\n      continue;\\n    }\\n    if (n & 1) {\\n      if (k < m \\/ 2) {\\n        cout << \\\"NO\\\"\\n             << \\\"\\\\n\\\";\\n        continue;\\n      }\\n      k = k - m \\/ 2;\\n      if (k % 2 == 0) {\\n        cout << \\\"YES\\\"\\n             << \\\"\\\\n\\\";\\n      } else {\\n        cout << \\\"NO\\\"\\n             << \\\"\\\\n\\\";\\n      }\\n      continue;\\n    }\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You have an undirected graph consisting of n vertices with weighted edges.\\n\\nA simple cycle is a cycle of the graph without repeated vertices. Let the weight of the cycle be the [XOR](https:\\/\\/en.wikipedia.org\\/wiki\\/Bitwise_operation#XOR) of weights of edges it consists of.\\n\\nLet's say the graph is good if all its simple cycles have weight 1. A graph is bad if it's not good.\\n\\nInitially, the graph is empty. Then q queries follow. Each query has the next type: \\n\\n  * u v x \u2014 add edge between vertices u and v of weight x if it doesn't make the graph bad. \\n\\n\\n\\nFor each query print, was the edge added or not.\\n\\nInput\\n\\nThe first line contains two integers n and q (3 \u2264 n \u2264 3 \u22c5 10^5; 1 \u2264 q \u2264 5 \u22c5 10^5) \u2014 the number of vertices and queries.\\n\\nNext q lines contain queries \u2014 one per line. Each query contains three integers u, v and x (1 \u2264 u, v \u2264 n; u \u2260 v; 0 \u2264 x \u2264 1) \u2014 the vertices of the edge and its weight.\\n\\nIt's guaranteed that there are no multiple edges in the input.\\n\\nOutput\\n\\nFor each query, print YES if the edge was added to the graph, or NO otherwise (both case-insensitive).\\n\\nExample\\n\\nInput\\n\\n\\n9 12\\n6 1 0\\n1 3 1\\n3 6 0\\n6 2 0\\n6 4 1\\n3 4 1\\n2 4 0\\n2 5 0\\n4 5 0\\n7 8 1\\n8 9 1\\n9 7 0\\n\\n\\nOutput\\n\\n\\nYES\\nYES\\nYES\\nYES\\nYES\\nNO\\nYES\\nYES\\nNO\\nYES\\nYES\\nNO\\nUsing cpp can you solve the prior task?\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst int INF = 0x3f3f3f3f;\\nconst long long INFF = 0x3f3f3f3f3f3f3f3fll;\\nconst long long M = 998244353;\\nconst long long maxn = 3e5 + 107;\\nconst long long maxm = 5e5 + 107;\\nconst double pi = acos(-1.0);\\nconst double eps = 0.0000000001;\\nlong long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }\\ntemplate <typename T>\\ninline void pr2(T x, unsigned long long k = 64) {\\n  unsigned long long i;\\n  for (i = 0; i < k; i++) fprintf(stderr, \\\"%d\\\", (int)((x >> i) & 1));\\n  putchar(' ');\\n}\\ntemplate <typename T>\\ninline void add_(T &A, int B, long long MOD = M) {\\n  A += B;\\n  (A >= MOD) && (A -= MOD);\\n}\\ntemplate <typename T>\\ninline void mul_(T &A, long long B, long long MOD = M) {\\n  A = (A * B) % MOD;\\n}\\ntemplate <typename T>\\ninline void mod_(T &A, long long MOD = M) {\\n  A %= MOD;\\n  A += MOD;\\n  A %= MOD;\\n}\\ntemplate <typename T>\\ninline void max_(T &A, T B) {\\n  (A < B) && (A = B);\\n}\\ntemplate <typename T>\\ninline void min_(T &A, T B) {\\n  (A > B) && (A = B);\\n}\\ntemplate <typename T>\\ninline T abs(T a) {\\n  return a > 0 ? a : -a;\\n}\\ninline long long powMM(long long a, long long b, long long mod = M) {\\n  long long ret = 1;\\n  for (; b; b >>= 1ll, a = a * a % mod)\\n    if (b & 1) ret = ret * a % mod;\\n  return ret;\\n}\\nint startTime;\\nvoid startTimer() { startTime = clock(); }\\nvoid printTimer() {\\n  fprintf(stderr, \\\"\\/--- Time: %ld milliseconds ---\\/\\\\n\\\", clock() - startTime);\\n}\\nint MAX[maxn * 4];\\nvoid update(int x, int l, int r, int value, int L, int R) {\\n  if (l <= L && R <= r) {\\n    MAX[x] = max(MAX[x], value);\\n    return;\\n  }\\n  int mid = (L + R) \\/ 2;\\n  if (l <= mid) update(x << 1, l, r, value, L, mid);\\n  if (mid < r) update(x << 1 | 1, l, r, value, mid + 1, R);\\n}\\nint query(int x, int pos, int L, int R) {\\n  if (L == R) return MAX[x];\\n  int mid = (L + R) \\/ 2, ret = MAX[x];\\n  if (pos <= mid) max_(ret, query(x << 1, pos, L, mid));\\n  if (mid < pos) max_(ret, query(x << 1 | 1, pos, mid + 1, R));\\n  return ret;\\n}\\nint in[maxn], out[maxn], tot;\\nvector<pair<int, int> > edge[maxn];\\nint fa[maxn],...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Dima is a beginner programmer. During his working process, he regularly has to repeat the following operation again and again: to remove every second element from the array. One day he has been bored with easy solutions of this problem, and he has come up with the following extravagant algorithm.\\n\\nLet's consider that initially array contains n numbers from 1 to n and the number i is located in the cell with the index 2i - 1 (Indices are numbered starting from one) and other cells of the array are empty. Each step Dima selects a non-empty array cell with the maximum index and moves the number written in it to the nearest empty cell to the left of the selected one. The process continues until all n numbers will appear in the first n cells of the array. For example if n = 4, the array is changing as follows:\\n\\n<image>\\n\\nYou have to write a program that allows you to determine what number will be in the cell with index x (1 \u2264 x \u2264 n) after Dima's algorithm finishes.\\n\\nInput\\n\\nThe first line contains two integers n and q (1 \u2264 n \u2264 1018, 1 \u2264 q \u2264 200 000), the number of elements in the array and the number of queries for which it is needed to find the answer.\\n\\nNext q lines contain integers xi (1 \u2264 xi \u2264 n), the indices of cells for which it is necessary to output their content after Dima's algorithm finishes.\\n\\nOutput\\n\\nFor each of q queries output one integer number, the value that will appear in the corresponding array cell after Dima's algorithm finishes.\\n\\nExamples\\n\\nInput\\n\\n4 3\\n2\\n3\\n4\\n\\n\\nOutput\\n\\n3\\n2\\n4\\n\\n\\nInput\\n\\n13 4\\n10\\n5\\n4\\n8\\n\\n\\nOutput\\n\\n13\\n3\\n8\\n9\\n\\nNote\\n\\nThe first example is shown in the picture.\\n\\nIn the second example the final array is [1, 12, 2, 8, 3, 11, 4, 9, 5, 13, 6, 10, 7].\\nimpor\",\"targets\":\"t java.util.Scanner;\\n\\npublic class Frog {\\n\\t\\n\\tpublic static long f(long ind, long n) {\\n\\t\\tif (ind % 2 != 0)\\n\\t\\t\\treturn n - ind \\/ 2;\\n\\t\\telse {\\n\\t\\t\\treturn f(ind \\/ 2, n);\\n\\t\\t}\\n\\t}\\n\\t\\n\\tpublic static void main(String[] args) {\\n\\t\\tScanner scan = new Scanner(System.in);\\n\\n\\t\\tlong n = scan.nextLong();\\n\\t\\tint q = scan.nextInt();\\n\\t\\t\\n\\t\\tfor(int i = 0; i < q; ++i) {\\n\\t\\t\\tlong qI = scan.nextLong();\\n\\t\\t\\tif(qI%2 == 1) {\\n\\t\\t\\t\\tSystem.out.println(qI\\/2 + 1);\\n\\t\\t\\t}\\n\\t\\t\\telse System.out.println(f(n -qI\\/2,n));\\n\\t\\t}\\n\\t}\\n\\t\\n\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You are given two integers l and r, l\u2264 r. Find the largest possible value of a mod b over all pairs (a, b) of integers for which r\u2265 a \u2265 b \u2265 l.\\n\\nAs a reminder, a mod b is a remainder we get when dividing a by b. For example, 26 mod 8 = 2.\\n\\nInput\\n\\nEach test contains multiple test cases.\\n\\nThe first line contains one positive integer t (1\u2264 t\u2264 10^4), denoting the number of test cases. Description of the test cases follows.\\n\\nThe only line of each test case contains two integers l, r (1\u2264 l \u2264 r \u2264 10^9).\\n\\nOutput\\n\\nFor every test case, output the largest possible value of a mod b over all pairs (a, b) of integers for which r\u2265 a \u2265 b \u2265 l.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n1 1\\n999999999 1000000000\\n8 26\\n1 999999999\\n\\n\\nOutput\\n\\n\\n0\\n1\\n12\\n499999999\\n\\nNote\\n\\nIn the first test case, the only allowed pair is (a, b) = (1, 1), for which a mod b = 1 mod 1 = 0.\\n\\nIn the second test case, the optimal choice is pair (a, b) = (1000000000, 999999999), for which a mod b = 1.\",\"targets\":\"#include <bits\\/stdc++.h>\\nbool ispoweroftwo(long long int n) { return n & (!(n & (n - 1))); }\\nusing namespace std;\\nvoid solve() {\\n  int l, r;\\n  cin >> l >> r;\\n  int a, b = r;\\n  a = r \\/ 2 + 1;\\n  if (a < l) a = l;\\n  if (a > r) a = r;\\n  cout << b % a << \\\"\\\\n\\\";\\n}\\nint main() {\\n  ios_base::sync_with_stdio(false);\\n  cin.tie();\\n  cout.tie();\\n  int n = 1;\\n  cin >> n;\\n  while (n--) solve();\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"Monocarp is playing a computer game. Now he wants to complete the first level of this game.\\n\\nA level is a rectangular grid of 2 rows and n columns. Monocarp controls a character, which starts in cell (1, 1) \u2014 at the intersection of the 1-st row and the 1-st column.\\n\\nMonocarp's character can move from one cell to another in one step if the cells are adjacent by side and\\/or corner. Formally, it is possible to move from cell (x_1, y_1) to cell (x_2, y_2) in one step if |x_1 - x_2| \u2264 1 and |y_1 - y_2| \u2264 1. Obviously, it is prohibited to go outside the grid.\\n\\nThere are traps in some cells. If Monocarp's character finds himself in such a cell, he dies, and the game ends.\\n\\nTo complete a level, Monocarp's character should reach cell (2, n) \u2014 at the intersection of row 2 and column n.\\n\\nHelp Monocarp determine if it is possible to complete the level.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 100) \u2014 the number of test cases. Then the test cases follow. Each test case consists of three lines.\\n\\nThe first line contains a single integer n (3 \u2264 n \u2264 100) \u2014 the number of columns.\\n\\nThe next two lines describe the level. The i-th of these lines describes the i-th line of the level \u2014 the line consists of the characters '0' and '1'. The character '0' corresponds to a safe cell, the character '1' corresponds to a trap cell.\\n\\nAdditional constraint on the input: cells (1, 1) and (2, n) are safe.\\n\\nOutput\\n\\nFor each test case, output YES if it is possible to complete the level, and NO otherwise.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n3\\n000\\n000\\n4\\n0011\\n1100\\n4\\n0111\\n1110\\n6\\n010101\\n101010\\n\\n\\nOutput\\n\\n\\nYES\\nYES\\nNO\\nYES\\n\\nNote\\n\\nConsider the example from the statement.\\n\\nIn the first test case, one of the possible paths is (1, 1) \u2192 (2, 2) \u2192 (2, 3).\\n\\nIn the second test case, one of the possible paths is (1, 1) \u2192 (1, 2) \u2192 (2, 3) \u2192 (2, 4).\\n\\nIn the fourth test case, one of the possible paths is (1, 1) \u2192 (2, 2) \u2192 (1, 3) \u2192 (2, 4) \u2192 (1, 5) \u2192 (2, 6).\\\":\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nvoid initial_code() {\\n  ios_base::sync_with_stdio(false);\\n  cin.tie(NULL);\\n}\\nint main() {\\n  initial_code();\\n  long long t;\\n  cin >> t;\\n  while (t--) {\\n    long long n;\\n    cin >> n;\\n    string a, b;\\n    cin >> a >> b;\\n    long long cnt = 0;\\n    bool bt = 1;\\n    for (long long i = 0; i < n - 1; i++) {\\n      cnt = 0;\\n      if (a[i] == '1') cnt++;\\n      if (b[i] == '1') cnt++;\\n      if (cnt >= 2) {\\n        bt = 0;\\n        cout << \\\"NO\\\" << endl;\\n        break;\\n      }\\n    }\\n    if (bt == 1) {\\n      cout << \\\"YES\\\" << endl;\\n    }\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"An ant moves on the real line with constant speed of 1 unit per second. It starts at 0 and always moves to the right (so its position increases by 1 each second).\\n\\nThere are n portals, the i-th of which is located at position x_i and teleports to position y_i < x_i. Each portal can be either active or inactive. The initial state of the i-th portal is determined by s_i: if s_i=0 then the i-th portal is initially inactive, if s_i=1 then the i-th portal is initially active. When the ant travels through a portal (i.e., when its position coincides with the position of a portal): \\n\\n  * if the portal is inactive, it becomes active (in this case the path of the ant is not affected); \\n  * if the portal is active, it becomes inactive and the ant is instantly teleported to the position y_i, where it keeps on moving as normal. \\n\\n\\n\\nHow long (from the instant it starts moving) does it take for the ant to reach the position x_n + 1? It can be shown that this happens in a finite amount of time. Since the answer may be very large, compute it modulo 998 244 353.\\n\\nInput\\n\\nThe first line contains the integer n (1\u2264 n\u2264 2\u22c5 10^5) \u2014 the number of portals.\\n\\nThe i-th of the next n lines contains three integers x_i, y_i and s_i (1\u2264 y_i < x_i\u2264 10^9, s_i\u2208\\\\{0,1\\\\}) \u2014 the position of the i-th portal, the position where the ant is teleported when it travels through the i-th portal (if it is active), and the initial state of the i-th portal.\\n\\nThe positions of the portals are strictly increasing, that is x_1<x_2<\u22c5\u22c5\u22c5<x_n. It is guaranteed that the 2n integers x_1,   x_2,   ...,   x_n,   y_1,   y_2,   ...,   y_n are all distinct.\\n\\nOutput\\n\\nOutput the amount of time elapsed, in seconds, from the instant the ant starts moving to the instant it reaches the position x_n+1. Since the answer may be very large, output it modulo 998 244 353.\\n\\nExamples\\n\\nInput\\n\\n\\n4\\n3 2 0\\n6 5 1\\n7 4 0\\n8 1 1\\n\\n\\nOutput\\n\\n\\n23\\n\\n\\nInput\\n\\n\\n1\\n454971987 406874902 1\\n\\n\\nOutput\\n\\n\\n503069073\\n\\n\\nInput\\n\\n\\n5\\n243385510 42245605 0\\n644426565 574769163 0\\n708622105 208990040 0\\n786625660 616437691...\",\"targets\":\"\\/*\\nstream Butter!\\neggyHide eggyVengeance\\nI need U\\nxiao rerun when\\n *\\/\\nimport static java.lang.Math.*;\\nimport java.util.*;\\nimport java.io.*;\\nimport java.math.*;\\n\\npublic class x1552F\\n{\\n    static final long MOD = 998244353L;\\n    public static void main(String hi[]) throws Exception\\n    {\\n        BufferedReader infile = new BufferedReader(new InputStreamReader(System.in));\\n        StringTokenizer st = new StringTokenizer(infile.readLine());\\n        int N = Integer.parseInt(st.nextToken());\\n        int[] left = new int[N];\\n        int[] right = new int[N];\\n        boolean[] on = new boolean[N];\\n        for(int i=0; i < N; i++)\\n        {\\n            st = new StringTokenizer(infile.readLine());\\n            right[i] = Integer.parseInt(st.nextToken());\\n            left[i] = Integer.parseInt(st.nextToken());\\n            on[i] = st.nextToken().charAt(0) == '1';\\n        }\\n        long[] dp = new long[N];\\n        dp[0] = (right[0]-left[0])%MOD;\\n        long[] prefix = new long[N];\\n        prefix[0] = dp[0];\\n        for(int i=1; i < N; i++)\\n        {\\n            dp[i] = right[i]-left[i];\\n            if(dp[i] >= MOD)\\n                dp[i] -= MOD;\\n            if(left[i] < right[i-1])\\n            {\\n                int low = 0;\\n                int high = i-1;\\n                while(low != high)\\n                {\\n                    int mid = (low+high)>>1;\\n                    if(left[i] < right[mid])\\n                        high = mid;\\n                    else\\n                        low = mid+1;\\n                }\\n                long addon = prefix[i-1];\\n                if(low > 0)\\n                {\\n                    addon -= prefix[low-1];\\n                    if(addon < 0)\\n                        addon += MOD;\\n                }\\n                dp[i] += addon;\\n                if(dp[i] >= MOD)\\n                    dp[i] -= MOD;\\n            }\\n            prefix[i] = prefix[i-1]+dp[i];\\n            if(prefix[i] >= MOD)\\n                prefix[i] -= MOD;\\n        }\\n        long res = right[N-1]+1;\\n        for(int i=0; i < N; i++)\\n ...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in PYTHON3?\\nAn important meeting is to be held and there are exactly n people invited. At any moment, any two people can step back and talk in private. The same two people can talk several (as many as they want) times per meeting.\\n\\nEach person has limited sociability. The sociability of the i-th person is a non-negative integer a_i. This means that after exactly a_i talks this person leaves the meeting (and does not talk to anyone else anymore). If a_i = 0, the i-th person leaves the meeting immediately after it starts.\\n\\nA meeting is considered most productive if the maximum possible number of talks took place during it.\\n\\nYou are given an array of sociability a, determine which people should talk to each other so that the total number of talks is as large as possible.\\n\\nInput\\n\\nThe first line contains an integer t (1 \u2264 t \u2264 1000) \u2014 the number of test cases.\\n\\nThe next 2t lines contain descriptions of the test cases.\\n\\nThe first line of each test case description contains an integer n (2 \u2264 n \u2264 2 \u22c5 10^5) \u2014the number of people in the meeting. The second line consists of n space-separated integers a_1, a_2, ..., a_n (0 \u2264 a_i \u2264 2 \u22c5 10^5) \u2014 the sociability parameters of all people. \\n\\nIt is guaranteed that the sum of n over all test cases does not exceed 2 \u22c5 10^5. It is also guaranteed that the sum of all a_i (over all test cases and all i) does not exceed 2 \u22c5 10^5.\\n\\nOutput\\n\\nPrint t answers to all test cases.\\n\\nOn the first line of each answer print the number k \u2014 the maximum number of talks possible in a meeting.\\n\\nOn each of the next k lines print two integers i and j (1 \u2264 i, j \u2264 n and i \u2260 j) \u2014 the numbers of people who will have another talk.\\n\\nIf there are several possible answers, you may print any of them.\\n\\nExample\\n\\nInput\\n\\n\\n8\\n2\\n2 3\\n3\\n1 2 3\\n4\\n1 2 3 4\\n3\\n0 0 2\\n2\\n6 2\\n3\\n0 0 2\\n5\\n8 2 0 1 1\\n5\\n0 1 0 0 6\\n\\n\\nOutput\\n\\n\\n2\\n1 2\\n1 2\\n3\\n1 3\\n2 3\\n2 3\\n5\\n1 3\\n2 4\\n2 4\\n3 4\\n3 4\\n0\\n2\\n1 2\\n1 2\\n0\\n4\\n1 2\\n1 5\\n1 4\\n1 2\\n1\\n5 2\",\"targets\":\"#!\\/usr\\/bin\\/env python\\nimport collections\\nimport os\\nimport sys\\nfrom io import BytesIO, IOBase\\nfrom bisect import bisect_left\\nfrom math import gcd,log,ceil\\nfrom collections import Counter\\nfrom pprint import pprint\\nimport heapq\\nBUFSIZE = 8192\\nclass FastIO(IOBase):\\n    newlines = 0\\n    def __init__(self, file):\\n        self._fd = file.fileno()\\n        self.buffer = BytesIO()\\n        self.writable = \\\"x\\\" in file.mode or \\\"r\\\" not in file.mode\\n        self.write = self.buffer.write if self.writable else None\\n    def read(self):\\n        while True:\\n            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))\\n            if not b:\\n                break\\n            ptr = self.buffer.tell()\\n            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)\\n        self.newlines = 0\\n        return self.buffer.read()\\n    def readline(self):\\n        while self.newlines == 0:\\n            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))\\n            self.newlines = b.count(b\\\"\\\\n\\\") + (not b)\\n            ptr = self.buffer.tell()\\n            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)\\n        self.newlines -= 1\\n        return self.buffer.readline()\\n    def flush(self):\\n        if self.writable:\\n            os.write(self._fd, self.buffer.getvalue())\\n            self.buffer.truncate(0), self.buffer.seek(0)\\nclass IOWrapper(IOBase):\\n    def __init__(self, file):\\n        self.buffer = FastIO(file)\\n        self.flush = self.buffer.flush\\n        self.writable = self.buffer.writable\\n        self.write = lambda s: self.buffer.write(s.encode(\\\"ascii\\\"))\\n        self.read = lambda: self.buffer.read().decode(\\\"ascii\\\")\\n        self.readline = lambda: self.buffer.readline().decode(\\\"ascii\\\")\\nsys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)\\ninput = lambda: sys.stdin.readline().rstrip(\\\"\\\\r\\\\n\\\")\\n # endregion\\n \\n\\n\\ndef solve():\\n    n = input()\\n    arr = list(map(int,input().split()))\\n    \\n    hq = []\\n\\n    for i,ele in enumerate(arr):\\n        heapq.heappush(hq,(-ele,i))\\n   ...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"<image>\\n\\nAs mentioned previously William really likes playing video games. In one of his favorite games, the player character is in a universe where every planet is designated by a binary number from 0 to 2^n - 1. On each planet, there are gates that allow the player to move from planet i to planet j if the binary representations of i and j differ in exactly one bit.\\n\\nWilliam wants to test you and see how you can handle processing the following queries in this game universe:\\n\\n  * Destroy planets with numbers from l to r inclusively. These planets cannot be moved to anymore.\\n  * Figure out if it is possible to reach planet b from planet a using some number of planetary gates. It is guaranteed that the planets a and b are not destroyed. \\n\\nInput\\n\\nThe first line contains two integers n, m (1 \u2264 n \u2264 50, 1 \u2264 m \u2264 5 \u22c5 10^4), which are the number of bits in binary representation of each planets' designation and the number of queries, respectively.\\n\\nEach of the next m lines contains a query of two types:\\n\\nblock l r \u2014 query for destruction of planets with numbers from l to r inclusively (0 \u2264 l \u2264 r < 2^n). It's guaranteed that no planet will be destroyed twice.\\n\\nask a b \u2014 query for reachability between planets a and b (0 \u2264 a, b < 2^n). It's guaranteed that planets a and b hasn't been destroyed yet.\\n\\nOutput\\n\\nFor each query of type ask you must output \\\"1\\\" in a new line, if it is possible to reach planet b from planet a and \\\"0\\\" otherwise (without quotation marks).\\n\\nExamples\\n\\nInput\\n\\n\\n3 3\\nask 0 7\\nblock 3 6\\nask 0 7\\n\\n\\nOutput\\n\\n\\n1\\n0\\n\\n\\nInput\\n\\n\\n6 10\\nblock 12 26\\nask 44 63\\nblock 32 46\\nask 1 54\\nblock 27 30\\nask 10 31\\nask 11 31\\nask 49 31\\nblock 31 31\\nask 2 51\\n\\n\\nOutput\\n\\n\\n1\\n1\\n0\\n0\\n1\\n0\\n\\nNote\\n\\nThe first example test can be visualized in the following way:\\n\\n<image>\\n\\nResponse to a query ask 0 7 is positive.\\n\\nNext after query block 3 6 the graph will look the following way (destroyed vertices are highlighted):\\n\\n<image>\\n\\nResponse to a query ask 0 7 is negative, since any path from vertex 0 to vertex 7 must go through one of the destroyed vertices.\\nThe above is tricky. Write me a correct solution in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst int MAXQ = 5e4;\\nconst int MAXN = 50;\\nint n, q;\\nint m, par[MAXQ * MAXN + 10], w[MAXQ * MAXN + 10], curBlockIdx;\\nbool isBlock[MAXQ * MAXN + 10];\\nvector<int> adj[MAXQ * MAXN + 10];\\nvector<pair<long long, long long> > blockRanges;\\nchar s[10];\\nenum QueryType {\\n  ASK,\\n  BLOCK,\\n};\\nstruct Query {\\n  QueryType queryType;\\n  long long u, v;\\n  vector<int> vertexIdx;\\n  int res;\\n};\\nQuery queries[MAXQ];\\nstruct Vertex {\\n  pair<long long, long long> range;\\n  int idx;\\n  Vertex() {}\\n  Vertex(const pair<long long, long long>& range, const int& idx)\\n      : range(range), idx(idx) {}\\n  bool operator<(const Vertex& other) const {\\n    return this->range < other.range;\\n  }\\n};\\nstruct Node {\\n  list<Vertex> vertices;\\n  Node *lef, *rig;\\n  Node() : lef(NULL), rig(NULL) {}\\n};\\nNode* root = NULL;\\nvoid insert(const long long& u, const long long& v, Node*& node = root,\\n            const long long& lef = 0, const long long& rig = (1LL << n) - 1) {\\n  if (node == NULL) node = new Node;\\n  if (u == lef && v == rig) {\\n    node->vertices.push_back(Vertex(pair<long long, long long>(lef, rig), ++m));\\n    if (curBlockIdx != -1) {\\n      isBlock[m] = true;\\n      queries[curBlockIdx].vertexIdx.push_back(m);\\n    }\\n    return;\\n  }\\n  long long mid = (lef + rig) >> 1;\\n  if (v <= mid)\\n    insert(u, v, node->lef, lef, mid);\\n  else if (u > mid)\\n    insert(u, v, node->rig, mid + 1, rig);\\n  else {\\n    insert(u, mid, node->lef, lef, mid);\\n    insert(mid + 1, v, node->rig, mid + 1, rig);\\n  }\\n}\\nvoid merge(Node*& node, const long long& len) {\\n  list<Vertex>::iterator iterU = node->lef->vertices.begin(),\\n                         iterV = node->rig->vertices.begin(), iterUU, iterVV;\\n  do {\\n    iterUU = iterU, iterVV = iterV;\\n    adj[iterU->idx].push_back(iterV->idx);\\n    adj[iterV->idx].push_back(iterU->idx);\\n    if (iterU->range.second + len <= iterV->range.second) ++iterUU;\\n    if (iterV->range.second <= iterU->range.second + len) ++iterVV;\\n    iterU = iterUU, iterV = iterVV;\\n  } while (iterU !=...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CQXYM wants to create a connected undirected graph with n nodes and m edges, and the diameter of the graph must be strictly less than k-1. Also, CQXYM doesn't want a graph that contains self-loops or multiple edges (i.e. each edge connects two different vertices and between each pair of vertices there is at most one edge).\\n\\nThe diameter of a graph is the maximum distance between any two nodes.\\n\\nThe distance between two nodes is the minimum number of the edges on the path which endpoints are the two nodes.\\n\\nCQXYM wonders whether it is possible to create such a graph.\\n\\nInput\\n\\nThe input consists of multiple test cases. \\n\\nThe first line contains an integer t (1 \u2264 t \u2264 10^5) \u2014 the number of test cases. The description of the test cases follows.\\n\\nOnly one line of each test case contains three integers n(1 \u2264 n \u2264 10^9), m, k (0 \u2264 m,k \u2264 10^9).\\n\\nOutput\\n\\nFor each test case, print YES if it is possible to create the graph, or print NO if it is impossible. You can print each letter in any case (upper or lower).\\n\\nExample\\n\\nInput\\n\\n\\n5\\n1 0 3\\n4 5 3\\n4 6 3\\n5 4 1\\n2 1 1\\n\\n\\nOutput\\n\\n\\nYES\\nNO\\nYES\\nNO\\nNO\\n\\nNote\\n\\nIn the first test case, the graph's diameter equal to 0.\\n\\nIn the second test case, the graph's diameter can only be 2.\\n\\nIn the third test case, the graph's diameter can only be 1.\\nSolve the task in JAVA.\",\"targets\":\"import java.util.ArrayList;\\nimport java.util.Collections;\\nimport java.util.HashMap;\\nimport java.util.PriorityQueue;\\nimport java.util.StringTokenizer;\\nimport java.io.*;\\n \\npublic class cf745 {\\n\\t\\n\\tprivate static class MyScanner {\\n\\t    BufferedReader br;\\n\\t    StringTokenizer st;\\n\\n\\t    public MyScanner() {\\n\\t       br = new BufferedReader(new InputStreamReader(System.in));\\n\\t    }\\n\\n\\t    String next() {\\n\\t        while (st == null || !st.hasMoreElements()) {\\n\\t            try {\\n\\t                st = new StringTokenizer(br.readLine());\\n\\t            } catch (IOException e) {\\n\\t                e.printStackTrace();\\n\\t            }\\n\\t        }\\n\\t        return st.nextToken();\\n\\t    }\\n\\n\\t    int nextInt() {\\n\\t        return Integer.parseInt(next());\\n\\t    }\\n\\n\\t    long nextLong() {\\n\\t        return Long.parseLong(next());\\n\\t    }\\n\\n\\t    double nextDouble() {\\n\\t        return Double.parseDouble(next());\\n\\t    }\\n\\n\\t    String nextLine(){\\n\\t        String str = \\\"\\\";\\n\\t\\t  try {\\n\\t\\t     str = br.readLine();\\n\\t\\t  } catch (IOException e) {\\n\\t\\t     e.printStackTrace();\\n\\t\\t  }\\n\\t\\t  return str;\\n\\t    }\\n\\n\\t }\\n\\t\\n\\n\\n\\t\\n\\tpublic static String solution(long n, long m, long k)\\n\\t\\t\\t\\n\\t{\\n\\t\\tlong max = (n*(n-1))\\/2;\\n\\t\\tlong min = n-1;\\n\\t\\t\\n\\t\\tif(m<min || m>max)\\n\\t\\t\\treturn \\\"NO\\\";\\n\\t\\t\\n\\t\\tif(k<2)\\n\\t\\t\\treturn \\\"NO\\\";\\n\\t\\t\\n\\t\\tif(k==2)\\n\\t\\t{\\n\\t\\t\\tif(n==1)\\n\\t\\t\\t\\treturn \\\"YES\\\";\\n\\t\\t\\treturn \\\"NO\\\";\\n\\t\\t}\\n\\t\\t\\t\\n\\t\\t\\n\\t\\tif(k==3)\\n\\t\\t{\\n\\t\\t\\tif(m==max)\\n\\t\\t\\t\\treturn \\\"YES\\\";\\n\\t\\t\\t\\n\\t\\t\\treturn \\\"NO\\\";\\n\\t\\t\\t\\n\\t\\t}\\n\\t\\t\\t\\n\\t\\treturn \\\"YES\\\";\\n\\t\\t\\n\\t}\\n        \\nprivate static PrintWriter out = new PrintWriter(System.out);\\n\\npublic static void main (String[] args)\\n{\\n\\tMyScanner s =  new MyScanner();\\n     \\n    int t = s.nextInt();\\n    \\n    for(int j = 0; j<t ; j++)\\n    {\\n    \\tlong n = s.nextLong();\\n    \\tlong m = s.nextLong();\\n    \\tlong k = s.nextLong();\\n    \\tout.println(solution(n,m,k));\\n    }\\n    \\n    out.flush();\\n    out.close();\\n    \\n}\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"An important meeting is to be held and there are exactly n people invited. At any moment, any two people can step back and talk in private. The same two people can talk several (as many as they want) times per meeting.\\n\\nEach person has limited sociability. The sociability of the i-th person is a non-negative integer a_i. This means that after exactly a_i talks this person leaves the meeting (and does not talk to anyone else anymore). If a_i = 0, the i-th person leaves the meeting immediately after it starts.\\n\\nA meeting is considered most productive if the maximum possible number of talks took place during it.\\n\\nYou are given an array of sociability a, determine which people should talk to each other so that the total number of talks is as large as possible.\\n\\nInput\\n\\nThe first line contains an integer t (1 \u2264 t \u2264 1000) \u2014 the number of test cases.\\n\\nThe next 2t lines contain descriptions of the test cases.\\n\\nThe first line of each test case description contains an integer n (2 \u2264 n \u2264 2 \u22c5 10^5) \u2014the number of people in the meeting. The second line consists of n space-separated integers a_1, a_2, ..., a_n (0 \u2264 a_i \u2264 2 \u22c5 10^5) \u2014 the sociability parameters of all people. \\n\\nIt is guaranteed that the sum of n over all test cases does not exceed 2 \u22c5 10^5. It is also guaranteed that the sum of all a_i (over all test cases and all i) does not exceed 2 \u22c5 10^5.\\n\\nOutput\\n\\nPrint t answers to all test cases.\\n\\nOn the first line of each answer print the number k \u2014 the maximum number of talks possible in a meeting.\\n\\nOn each of the next k lines print two integers i and j (1 \u2264 i, j \u2264 n and i \u2260 j) \u2014 the numbers of people who will have another talk.\\n\\nIf there are several possible answers, you may print any of them.\\n\\nExample\\n\\nInput\\n\\n\\n8\\n2\\n2 3\\n3\\n1 2 3\\n4\\n1 2 3 4\\n3\\n0 0 2\\n2\\n6 2\\n3\\n0 0 2\\n5\\n8 2 0 1 1\\n5\\n0 1 0 0 6\\n\\n\\nOutput\\n\\n\\n2\\n1 2\\n1 2\\n3\\n1 3\\n2 3\\n2 3\\n5\\n1 3\\n2 4\\n2 4\\n3 4\\n3 4\\n0\\n2\\n1 2\\n1 2\\n0\\n4\\n1 2\\n1 5\\n1 4\\n1 2\\n1\\n5 2\\n#incl\",\"targets\":\"ude <bits\\/stdc++.h>\\nusing namespace std;\\nlong long dx[4] = {1, 0, -1, 0};\\nlong long dy[4] = {0, 1, 0, -1};\\nstruct myComp {\\n  constexpr bool operator()(\\n      pair<long long, long long> const& a,\\n      pair<long long, long long> const& b) const noexcept {\\n    return a.first < b.first;\\n  }\\n};\\nint main() {\\n  cin.tie(0);\\n  ios::sync_with_stdio(false);\\n  long long c, d, m, n, k, x, y, maxi = 0, f = 0, mini = LLONG_MAX, sum = 0,\\n                                 loop;\\n  string str;\\n  cin >> loop;\\n  for (long long _ = (long long)(0); _ < (long long)(loop); _++) {\\n    cin >> n;\\n    vector<long long> v(n);\\n    for (long long i = (long long)(0); i < (long long)(n); i++) cin >> v[i];\\n    priority_queue<pair<long long, long long>,\\n                   vector<pair<long long, long long>>, myComp>\\n        q;\\n    for (long long i = (long long)(0); i < (long long)(n); i++)\\n      if (v[i] != 0) q.push(pair<long long, long long>(v[i], i + 1));\\n    pair<long long, long long> a = pair<long long, long long>(0, 0);\\n    pair<long long, long long> b = pair<long long, long long>(0, 0);\\n    vector<long long> aq;\\n    vector<long long> bq;\\n    while (!q.empty()) {\\n      if (q.top().first == 0) {\\n        q.pop();\\n      } else if (a.first == 0) {\\n        a = q.top();\\n        q.pop();\\n      } else if (b.first == 0) {\\n        b = q.top();\\n        q.pop();\\n      } else {\\n        a.first--;\\n        b.first--;\\n        aq.push_back(a.second);\\n        bq.push_back(b.second);\\n        q.push(a);\\n        q.push(b);\\n        a = pair<long long, long long>(0, 0);\\n        b = pair<long long, long long>(0, 0);\\n      }\\n    }\\n    while (a.first > 0 && b.first > 0) {\\n      a.first--;\\n      b.first--;\\n      aq.push_back(a.second);\\n      bq.push_back(b.second);\\n    }\\n    cout << bq.size() << endl;\\n    for (long long i = (long long)(0); i < (long long)(bq.size()); i++)\\n      cout << bq[i] << \\\" \\\" << aq[i] << endl;\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Polycarp must pay exactly n burles at the checkout. He has coins of two nominal values: 1 burle and 2 burles. Polycarp likes both kinds of coins equally. So he doesn't want to pay with more coins of one type than with the other.\\n\\nThus, Polycarp wants to minimize the difference between the count of coins of 1 burle and 2 burles being used. Help him by determining two non-negative integer values c_1 and c_2 which are the number of coins of 1 burle and 2 burles, respectively, so that the total value of that number of coins is exactly n (i. e. c_1 + 2 \u22c5 c_2 = n), and the absolute value of the difference between c_1 and c_2 is as little as possible (i. e. you must minimize |c_1-c_2|).\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases. Then t test cases follow.\\n\\nEach test case consists of one line. This line contains one integer n (1 \u2264 n \u2264 10^9) \u2014 the number of burles to be paid by Polycarp.\\n\\nOutput\\n\\nFor each test case, output a separate line containing two integers c_1 and c_2 (c_1, c_2 \u2265 0) separated by a space where c_1 is the number of coins of 1 burle and c_2 is the number of coins of 2 burles. If there are multiple optimal solutions, print any one.\\n\\nExample\\n\\nInput\\n\\n\\n6\\n1000\\n30\\n1\\n32\\n1000000000\\n5\\n\\n\\nOutput\\n\\n\\n334 333\\n10 10\\n1 0\\n10 11\\n333333334 333333333\\n1 2\\n\\nNote\\n\\nThe answer for the first test case is \\\"334 333\\\". The sum of the nominal values of all coins is 334 \u22c5 1 + 333 \u22c5 2 = 1000, whereas |334 - 333| = 1. One can't get the better value because if |c_1 - c_2| = 0, then c_1 = c_2 and c_1 \u22c5 1 + c_1 \u22c5 2 = 1000, but then the value of c_1 isn't an integer.\\n\\nThe answer for the second test case is \\\"10 10\\\". The sum of the nominal values is 10 \u22c5 1 + 10 \u22c5 2 = 30 and |10 - 10| = 0, whereas there's no number having an absolute value less than 0.\\nThe above is tricky. Write me a correct solution in JAVA.\",\"targets\":\"import java.util.*;\\n\\npublic class P1 {\\n    public static void main(String[] args) {\\n        Scanner sc = new Scanner(System.in);\\n        int t = sc.nextInt();\\n        while (t-- > 0) {\\n            int n = sc.nextInt();\\n            if (n % 3 == 0)\\n                System.out.println((n \\/ 3) + \\\" \\\" + (n \\/ 3));\\n            else if (n % 3 == 1)\\n                System.out.println((n \\/ 3 + 1) + \\\" \\\" + (n \\/ 3));\\n            else\\n                System.out.println((n \\/ 3) + \\\" \\\" + (n \\/ 3 + 1));\\n        }\\n    }\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"A soldier wants to buy w bananas in the shop. He has to pay k dollars for the first banana, 2k dollars for the second one and so on (in other words, he has to pay i\u00b7k dollars for the i-th banana). \\n\\nHe has n dollars. How many dollars does he have to borrow from his friend soldier to buy w bananas?\\n\\nInput\\n\\nThe first line contains three positive integers k, n, w (1 \u2264 k, w \u2264 1000, 0 \u2264 n \u2264 109), the cost of the first banana, initial number of dollars the soldier has and number of bananas he wants. \\n\\nOutput\\n\\nOutput one integer \u2014 the amount of dollars that the soldier must borrow from his friend. If he doesn't have to borrow money, output 0.\\n\\nExamples\\n\\nInput\\n\\n3 17 4\\n\\n\\nOutput\\n\\n13\\nSolve the task in PYTHON3.\",\"targets\":\"# Soldier and Bananas\\ndata = input()\\nk, n, w = [int(x) for x in data.split()]\\nsum = 0\\nfor i in range(1,w + 1):\\n    sum += i * k\\nif(n < sum):\\n    print(sum - n)\\nelse:\\n    print('0')\",\"language\":\"python\",\"split\":\"train\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in CPP?\\nAlice and Bob play the following game. Alice has a set S of disjoint ranges of integers, initially containing only one range [1, n]. In one turn, Alice picks a range [l, r] from the set S and asks Bob to pick a number in the range. Bob chooses a number d (l \u2264 d \u2264 r). Then Alice removes [l, r] from S and puts into the set S the range [l, d - 1] (if l \u2264 d - 1) and the range [d + 1, r] (if d + 1 \u2264 r). The game ends when the set S is empty. We can show that the number of turns in each game is exactly n.\\n\\nAfter playing the game, Alice remembers all the ranges [l, r] she picked from the set S, but Bob does not remember any of the numbers that he picked. But Bob is smart, and he knows he can find out his numbers d from Alice's ranges, and so he asks you for help with your programming skill.\\n\\nGiven the list of ranges that Alice has picked ([l, r]), for each range, help Bob find the number d that Bob has picked.\\n\\nWe can show that there is always a unique way for Bob to choose his number for a list of valid ranges picked by Alice.\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 1000). Description of the test cases follows.\\n\\nThe first line of each test case contains a single integer n (1 \u2264 n \u2264 1000).\\n\\nEach of the next n lines contains two integers l and r (1 \u2264 l \u2264 r \u2264 n), denoting the range [l, r] that Alice picked at some point.\\n\\nNote that the ranges are given in no particular order.\\n\\nIt is guaranteed that the sum of n over all test cases does not exceed 1000, and the ranges for each test case are from a valid game.\\n\\nOutput\\n\\nFor each test case print n lines. Each line should contain three integers l, r, and d, denoting that for Alice's range [l, r] Bob picked the number d.\\n\\nYou can print the lines in any order. We can show that the answer is unique.\\n\\nIt is not required to print a new line after each test case. The new lines in the output of the example are for readability only. \\n\\nExample\\n\\nInput\\n\\n\\n4\\n1\\n1 1\\n3\\n1 3\\n2 3\\n2 2\\n6\\n1 1\\n3 5\\n4 4\\n3 6\\n4 5\\n1 6\\n5\\n1 5\\n1 2\\n4 5\\n2...\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint N;\\nint L[1003], R[1003];\\nint main() {\\n  int T;\\n  scanf(\\\"%d\\\", &T);\\n  while (T--) {\\n    scanf(\\\"%d\\\", &N);\\n    for (int i = 1; i <= N; ++i) scanf(\\\"%d %d\\\", L + i, R + i);\\n    for (int i = 1; i <= N; ++i) {\\n      int d = L[i];\\n      for (int j = 1; j <= N; ++j)\\n        if (L[j] == L[i] && R[j] < R[i]) d = max(d, R[j] + 1);\\n      printf(\\\"%d %d %d\\\\n\\\", L[i], R[i], d);\\n    }\\n    puts(\\\"\\\");\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"You are given two integers l and r, l\u2264 r. Find the largest possible value of a mod b over all pairs (a, b) of integers for which r\u2265 a \u2265 b \u2265 l.\\n\\nAs a reminder, a mod b is a remainder we get when dividing a by b. For example, 26 mod 8 = 2.\\n\\nInput\\n\\nEach test contains multiple test cases.\\n\\nThe first line contains one positive integer t (1\u2264 t\u2264 10^4), denoting the number of test cases. Description of the test cases follows.\\n\\nThe only line of each test case contains two integers l, r (1\u2264 l \u2264 r \u2264 10^9).\\n\\nOutput\\n\\nFor every test case, output the largest possible value of a mod b over all pairs (a, b) of integers for which r\u2265 a \u2265 b \u2265 l.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n1 1\\n999999999 1000000000\\n8 26\\n1 999999999\\n\\n\\nOutput\\n\\n\\n0\\n1\\n12\\n499999999\\n\\nNote\\n\\nIn the first test case, the only allowed pair is (a, b) = (1, 1), for which a mod b = 1 mod 1 = 0.\\n\\nIn the second test case, the optimal choice is pair (a, b) = (1000000000, 999999999), for which a mod b = 1.\\\":\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint main() {\\n  int t;\\n  cin >> t;\\n  while (t--) {\\n    long int l, r;\\n    cin >> l >> r;\\n    if (l == r)\\n      cout << 0 << endl;\\n    else if ((r) \\/ 2 + 1 >= l)\\n      cout << r % ((r) \\/ 2 + 1) << endl;\\n    else\\n      cout << r % l << endl;\\n  }\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You are given n lengths of segments that need to be placed on an infinite axis with coordinates.\\n\\nThe first segment is placed on the axis so that one of its endpoints lies at the point with coordinate 0. Let's call this endpoint the \\\"start\\\" of the first segment and let's call its \\\"end\\\" as that endpoint that is not the start. \\n\\nThe \\\"start\\\" of each following segment must coincide with the \\\"end\\\" of the previous one. Thus, if the length of the next segment is d and the \\\"end\\\" of the previous one has the coordinate x, the segment can be placed either on the coordinates [x-d, x], and then the coordinate of its \\\"end\\\" is x - d, or on the coordinates [x, x+d], in which case its \\\"end\\\" coordinate is x + d.\\n\\nThe total coverage of the axis by these segments is defined as their overall union which is basically the set of points covered by at least one of the segments. It's easy to show that the coverage will also be a segment on the axis. Determine the minimal possible length of the coverage that can be obtained by placing all the segments on the axis without changing their order.\\n\\nInput\\n\\nThe first line contains an integer t (1 \u2264 t \u2264 1000) \u2014 the number of test cases.\\n\\nThe next 2t lines contain descriptions of the test cases. \\n\\nThe first line of each test case description contains an integer n (1 \u2264 n \u2264 10^4) \u2014 the number of segments. The second line of the description contains n space-separated integers a_i (1 \u2264 a_i \u2264 1000) \u2014 lengths of the segments in the same order they should be placed on the axis.\\n\\nIt is guaranteed that the sum of n over all test cases does not exceed 10^4.\\n\\nOutput\\n\\nPrint t lines, each line containing the answer to the corresponding test case. The answer to a test case should be a single integer \u2014 the minimal possible length of the axis coverage.\\n\\nExample\\n\\nInput\\n\\n\\n6\\n2\\n1 3\\n3\\n1 2 3\\n4\\n6 2 3 9\\n4\\n6 8 4 5\\n7\\n1 2 4 6 7 7 3\\n8\\n8 6 5 1 2 2 3 6\\n\\n\\nOutput\\n\\n\\n3\\n3\\n9\\n9\\n7\\n8\\n\\nNote\\n\\nIn the third sample test case the segments should be arranged as follows: [0, 6] \u2192 [4, 6] \u2192 [4, 7] \u2192 [-2, 7]. As you can see, the last segment...\",\"targets\":\"def Bisect_Int(ok,ng,is_ok):\\n    while abs(ok-ng)>1:\\n        mid=(ok+ng)\\/\\/2\\n        if is_ok(mid):\\n            ok=mid\\n        else:\\n            ng=mid\\n    return ok\\n\\nfor t in range(int(input())):\\n    N=int(input())\\n    A=list(map(int,input().split()))\\n    def is_ok(n):\\n        bit=(1<<n+1)-1\\n        dp=bit\\n        for a in A:\\n            dp=dp<<a|dp>>a\\n            dp&=bit\\n        return dp!=0\\n    ans=Bisect_Int(max(A)*2+1,-1,is_ok)\\n    print(ans)\",\"language\":\"python\",\"split\":\"test\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in CPP?\\nIahub accidentally discovered a secret lab. He found there n devices ordered in a line, numbered from 1 to n from left to right. Each device i (1 \u2264 i \u2264 n) can create either ai units of matter or ai units of antimatter. \\n\\nIahub wants to choose some contiguous subarray of devices in the lab, specify the production mode for each of them (produce matter or antimatter) and finally take a photo of it. However he will be successful only if the amounts of matter and antimatter produced in the selected subarray will be the same (otherwise there would be overflowing matter or antimatter in the photo). \\n\\nYou are requested to compute the number of different ways Iahub can successful take a photo. A photo is different than another if it represents another subarray, or if at least one device of the subarray is set to produce matter in one of the photos and antimatter in the other one.\\n\\nInput\\n\\nThe first line contains an integer n (1 \u2264 n \u2264 1000). The second line contains n integers a1, a2, ..., an (1 \u2264 ai \u2264 1000).\\n\\nThe sum a1 + a2 + ... + an will be less than or equal to 10000.\\n\\nOutput\\n\\nOutput a single integer, the number of ways Iahub can take a photo, modulo 1000000007 (109 + 7).\\n\\nExamples\\n\\nInput\\n\\n4\\n1 1 1 1\\n\\n\\nOutput\\n\\n12\\n\\nNote\\n\\nThe possible photos are [1+, 2-], [1-, 2+], [2+, 3-], [2-, 3+], [3+, 4-], [3-, 4+], [1+, 2+, 3-, 4-], [1+, 2-, 3+, 4-], [1+, 2-, 3-, 4+], [1-, 2+, 3+, 4-], [1-, 2+, 3-, 4+] and [1-, 2-, 3+, 4+], where \\\"i+\\\" means that the i-th element produces matter, and \\\"i-\\\" means that the i-th element produces antimatter.\",\"targets\":\"#include <bits\\/stdc++.h>\\n#pragma comment(linker, \\\"\\/STACK:640000000\\\")\\nusing namespace std;\\nconst double eps = 1e-9;\\nconst double pi = acos(-1.0);\\ntemplate <class T>\\nT sqr(T x) {\\n  return x * x;\\n}\\nconst int mod = (int)(1e9) + 7;\\nconst int zero = 10250;\\nint n;\\nint a[1050];\\nint dp[1050][20500];\\nint main() {\\n  scanf(\\\"%d\\\", &n);\\n  for (int i = 0; i < n; i++) {\\n    scanf(\\\"%d\\\", &a[i]);\\n  }\\n  dp[0][zero] = 1;\\n  int res = 0;\\n  for (int i = 0; i < n; i++) {\\n    for (int j = 0; j < 20500; j++) {\\n      if (j - a[i] >= 0) {\\n        dp[i + 1][j - a[i]] += dp[i][j];\\n        dp[i + 1][j - a[i]] %= mod;\\n      }\\n      if (j + a[i] < 20500) {\\n        dp[i + 1][j + a[i]] += dp[i][j];\\n        dp[i + 1][j + a[i]] %= mod;\\n      }\\n    }\\n    res = (res + dp[i + 1][zero]) % mod;\\n    dp[i + 1][zero] += 1;\\n  }\\n  cout << res << endl;\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Artem is building a new robot. He has a matrix a consisting of n rows and m columns. The cell located on the i-th row from the top and the j-th column from the left has a value a_{i,j} written in it. \\n\\nIf two adjacent cells contain the same value, the robot will break. A matrix is called good if no two adjacent cells contain the same value, where two cells are called adjacent if they share a side. \\n\\nArtem wants to increment the values in some cells by one to make a good.\\n\\nMore formally, find a good matrix b that satisfies the following condition \u2014 \\n\\n  * For all valid (i,j), either b_{i,j} = a_{i,j} or b_{i,j} = a_{i,j}+1. \\n\\n\\n\\nFor the constraints of this problem, it can be shown that such a matrix b always exists. If there are several such tables, you can output any of them. Please note that you do not have to minimize the number of increments.\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 10). Description of the test cases follows.\\n\\nThe first line of each test case contains two integers n, m (1 \u2264 n \u2264 100, 1 \u2264 m \u2264 100) \u2014 the number of rows and columns, respectively.\\n\\nThe following n lines each contain m integers. The j-th integer in the i-th line is a_{i,j} (1 \u2264 a_{i,j} \u2264 10^9).\\n\\nOutput\\n\\nFor each case, output n lines each containing m integers. The j-th integer in the i-th line is b_{i,j}.\\n\\nExample\\n\\nInput\\n\\n\\n3\\n3 2\\n1 2\\n4 5\\n7 8\\n2 2\\n1 1\\n3 3\\n2 2\\n1 3\\n2 2\\n\\n\\nOutput\\n\\n\\n1 2\\n5 6\\n7 8\\n2 1\\n4 3\\n2 4\\n3 2\\n\\nNote\\n\\nIn all the cases, you can verify that no two adjacent cells have the same value and that b is the same as a with some values incremented by one. \\nThe above is tricky. Write me a correct solution in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\ntemplate <class T>\\nbool ckmin(T& a, const T& b) {\\n  return b < a ? a = b, 1 : 0;\\n}\\ntemplate <class T>\\nbool ckmax(T& a, const T& b) {\\n  return a < b ? a = b, 1 : 0;\\n}\\nmt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\\nstruct UF {\\n  vector<int> e;\\n  UF(int n) : e(n, -1) {}\\n  bool sameSet(int a, int b) { return find(a) == find(b); }\\n  int size(int x) { return -e[find(x)]; }\\n  int find(int x) { return e[x] < 0 ? x : e[x] = find(e[x]); }\\n  bool join(int a, int b) {\\n    a = find(a), b = find(b);\\n    if (a == b) return false;\\n    if (e[a] > e[b]) swap(a, b);\\n    e[a] += e[b];\\n    e[b] = a;\\n    return true;\\n  }\\n};\\nint main() {\\n  cin.tie(0)->sync_with_stdio(0);\\n  cin.exceptions(cin.failbit);\\n  int te;\\n  cin >> te;\\n  while (te--) {\\n    int n, m;\\n    cin >> n >> m;\\n    vector<vector<int> > a(n, vector<int>(m));\\n    for (int i = (0); i < (n); ++i)\\n      for (int j = (0); j < (m); ++j) cin >> a[i][j];\\n    UF uf(n * m);\\n    vector<pair<int, int> > ed;\\n    for (int i = (0); i < (n); ++i) {\\n      for (int j = (0); j < (m); ++j) {\\n        if (i + 1 < n) {\\n          if (a[i + 1][j] == a[i][j]) {\\n            ed.emplace_back(((i)*m + (j)), ((i + 1) * m + (j)));\\n          } else if (abs(a[i + 1][j] - a[i][j]) == 1) {\\n            uf.join(((i)*m + (j)), ((i + 1) * m + (j)));\\n          }\\n        }\\n        if (j + 1 < m) {\\n          if (a[i][j + 1] == a[i][j]) {\\n            ed.emplace_back(((i)*m + (j)), ((i)*m + (j + 1)));\\n          } else if (abs(a[i][j + 1] - a[i][j]) == 1) {\\n            uf.join(((i)*m + (j)), ((i)*m + (j + 1)));\\n          }\\n        }\\n      }\\n    }\\n    vector<vector<int> > g(n * m);\\n    for (auto [a, b] : ed) {\\n      g[uf.find(a)].push_back(uf.find(b));\\n      g[uf.find(b)].push_back(uf.find(a));\\n    }\\n    vector<int> col(n * m, -1);\\n    vector<int> vis(n * m);\\n    auto go = [&](int x) {\\n      queue<int> q;\\n      q.push(uf.find(x));\\n      col[uf.find(x)] = 0;\\n      while (not q.empty()) {\\n        int u = q.front();\\n        q.pop();\\n        for (auto v...\",\"language\":\"python\",\"split\":\"train\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"A chess tournament will be held soon, where n chess players will take part. Every participant will play one game against every other participant. Each game ends in either a win for one player and a loss for another player, or a draw for both players.\\n\\nEach of the players has their own expectations about the tournament, they can be one of two types:\\n\\n  1. a player wants not to lose any game (i. e. finish the tournament with zero losses); \\n  2. a player wants to win at least one game. \\n\\n\\n\\nYou have to determine if there exists an outcome for all the matches such that all the players meet their expectations. If there are several possible outcomes, print any of them. If there are none, report that it's impossible.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 200) \u2014 the number of test cases.\\n\\nThe first line of each test case contains one integer n (2 \u2264 n \u2264 50) \u2014 the number of chess players.\\n\\nThe second line contains the string s (|s| = n; s_i \u2208 \\\\{1, 2\\\\}). If s_i = 1, then the i-th player has expectations of the first type, otherwise of the second type.\\n\\nOutput\\n\\nFor each test case, print the answer in the following format:\\n\\nIn the first line, print NO if it is impossible to meet the expectations of all players.\\n\\nOtherwise, print YES, and the matrix of size n \u00d7 n in the next n lines.\\n\\nThe matrix element in the i-th row and j-th column should be equal to:\\n\\n  * +, if the i-th player won in a game against the j-th player; \\n  * -, if the i-th player lost in a game against the j-th player; \\n  * =, if the i-th and j-th players' game resulted in a draw; \\n  * X, if i = j. \\n\\nExample\\n\\nInput\\n\\n\\n3\\n3\\n111\\n2\\n21\\n4\\n2122\\n\\n\\nOutput\\n\\n\\nYES\\nX==\\n=X=\\n==X\\nNO\\nYES\\nX--+\\n+X++\\n+-X-\\n--+X\",\"targets\":\"from collections import defaultdict, Counter,deque\\nfrom math import sqrt, log10, log, floor, factorial,gcd\\nfrom bisect import bisect_left, bisect_right\\nfrom itertools import permutations,combinations\\nimport sys, io, os\\ninput = sys.stdin.readline\\n# input=io.BytesIO(os.read(0,os.fstat(0).st_size)).readline\\n# sys.setrecursionlimit(10000)\\ninf = float('inf')\\nmod = 10 ** 9 + 7\\ndef yn(a): print(\\\"YES\\\" if a else \\\"NO\\\")\\nceil = lambda a, b: (a + b - 1) \\/\\/ b\\nimport os\\nimport sys\\nfrom io import BytesIO, IOBase\\n\\nBUFSIZE = 8192\\n\\n\\nclass FastIO(IOBase):\\n    newlines = 0\\n\\n    def __init__(self, file):\\n        self._fd = file.fileno()\\n        self.buffer = BytesIO()\\n        self.writable = \\\"x\\\" in file.mode or \\\"r\\\" not in file.mode\\n        self.write = self.buffer.write if self.writable else None\\n\\n    def read(self):\\n        while True:\\n            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))\\n            if not b:\\n                break\\n            ptr = self.buffer.tell()\\n            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)\\n        self.newlines = 0\\n        return self.buffer.read()\\n\\n    def readline(self):\\n        while self.newlines == 0:\\n            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))\\n            self.newlines = b.count(b\\\"\\\\n\\\") + (not b)\\n            ptr = self.buffer.tell()\\n            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)\\n        self.newlines -= 1\\n        return self.buffer.readline()\\n\\n    def flush(self):\\n        if self.writable:\\n            os.write(self._fd, self.buffer.getvalue())\\n            self.buffer.truncate(0), self.buffer.seek(0)\\n\\n\\nclass IOWrapper(IOBase):\\n    def __init__(self, file):\\n        self.buffer = FastIO(file)\\n        self.flush = self.buffer.flush\\n        self.writable = self.buffer.writable\\n        self.write = lambda s: self.buffer.write(s.encode(\\\"ascii\\\"))\\n        self.read = lambda: self.buffer.read().decode(\\\"ascii\\\")\\n        self.readline = lambda: self.buffer.readline().decode(\\\"ascii\\\")\\n\\n\\nsys.stdin,...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Polycarp likes squares and cubes of positive integers. Here is the beginning of the sequence of numbers he likes: 1, 4, 8, 9, ....\\n\\nFor a given number n, count the number of integers from 1 to n that Polycarp likes. In other words, find the number of such x that x is a square of a positive integer number or a cube of a positive integer number (or both a square and a cube simultaneously).\\n\\nInput\\n\\nThe first line contains an integer t (1 \u2264 t \u2264 20) \u2014 the number of test cases.\\n\\nThen t lines contain the test cases, one per line. Each of the lines contains one integer n (1 \u2264 n \u2264 10^9).\\n\\nOutput\\n\\nFor each test case, print the answer you are looking for \u2014 the number of integers from 1 to n that Polycarp likes.\\n\\nExample\\n\\nInput\\n\\n\\n6\\n10\\n1\\n25\\n1000000000\\n999999999\\n500000000\\n\\n\\nOutput\\n\\n\\n4\\n1\\n6\\n32591\\n32590\\n23125\\nSolve the task in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\n#pragma GCC optimize(\\\"03\\\")\\nstatic const long long INFL = 0x3f3f3f3f3f3f3f3fLL;\\nusing namespace std;\\nint main() {\\n  long long int t;\\n  cin >> t;\\n  while (t--) {\\n    long long int n;\\n    cin >> n;\\n    set<long long int> a;\\n    for (int i = 1; i * i <= n; i++) {\\n      a.insert(i * i);\\n    }\\n    for (int i = 1; i * i * i <= n; i++) {\\n      a.insert(i * i * i);\\n    }\\n    cout << a.size();\\n    cout << endl;\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Alice and Borys are playing tennis.\\n\\nA tennis match consists of games. In each game, one of the players is serving and the other one is receiving.\\n\\nPlayers serve in turns: after a game where Alice is serving follows a game where Borys is serving, and vice versa.\\n\\nEach game ends with a victory of one of the players. If a game is won by the serving player, it's said that this player holds serve. If a game is won by the receiving player, it's said that this player breaks serve.\\n\\nIt is known that Alice won a games and Borys won b games during the match. It is unknown who served first and who won which games.\\n\\nFind all values of k such that exactly k breaks could happen during the match between Alice and Borys in total.\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 10^3). Description of the test cases follows.\\n\\nEach of the next t lines describes one test case and contains two integers a and b (0 \u2264 a, b \u2264 10^5; a + b > 0) \u2014 the number of games won by Alice and Borys, respectively.\\n\\nIt is guaranteed that the sum of a + b over all test cases does not exceed 2 \u22c5 10^5.\\n\\nOutput\\n\\nFor each test case print two lines.\\n\\nIn the first line, print a single integer m (1 \u2264 m \u2264 a + b + 1) \u2014 the number of values of k such that exactly k breaks could happen during the match.\\n\\nIn the second line, print m distinct integers k_1, k_2, \u2026, k_m (0 \u2264 k_1 < k_2 < \u2026 < k_m \u2264 a + b) \u2014 the sought values of k in increasing order.\\n\\nExample\\n\\nInput\\n\\n\\n3\\n2 1\\n1 1\\n0 5\\n\\n\\nOutput\\n\\n\\n4\\n0 1 2 3\\n2\\n0 2\\n2\\n2 3\\n\\nNote\\n\\nIn the first test case, any number of breaks between 0 and 3 could happen during the match: \\n\\n  * Alice holds serve, Borys holds serve, Alice holds serve: 0 breaks; \\n  * Borys holds serve, Alice holds serve, Alice breaks serve: 1 break; \\n  * Borys breaks serve, Alice breaks serve, Alice holds serve: 2 breaks; \\n  * Alice breaks serve, Borys breaks serve, Alice breaks serve: 3 breaks. \\n\\n\\n\\nIn the second test case, the players could either both hold serves (0 breaks) or both break serves (2...\\nSolve the task in PYTHON3.\",\"targets\":\"import os\\nimport sys\\nfrom io import BytesIO, IOBase\\n \\nBUFSIZE = 8192\\n \\n \\nclass FastIO(IOBase):\\n    newlines = 0\\n \\n    def __init__(self, file):\\n        self._fd = file.fileno()\\n        self.buffer = BytesIO()\\n        self.writable = \\\"x\\\" in file.mode or \\\"r\\\" not in file.mode\\n        self.write = self.buffer.write if self.writable else None\\n \\n    def read(self):\\n        while True:\\n            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))\\n            if not b:\\n                break\\n            ptr = self.buffer.tell()\\n            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)\\n        self.newlines = 0\\n        return self.buffer.read()\\n \\n    def readline(self):\\n        while self.newlines == 0:\\n            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))\\n            self.newlines = b.count(b\\\"\\\\n\\\") + (not b)\\n            ptr = self.buffer.tell()\\n            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)\\n        self.newlines -= 1\\n        return self.buffer.readline()\\n \\n    def flush(self):\\n        if self.writable:\\n            os.write(self._fd, self.buffer.getvalue())\\n            self.buffer.truncate(0), self.buffer.seek(0)\\n                      \\n            \\nclass IOWrapper(IOBase):\\n    def __init__(self, file):\\n        self.buffer = FastIO(file)\\n        self.flush = self.buffer.flush\\n        self.writable = self.buffer.writable\\n        self.write = lambda s: self.buffer.write(s.encode(\\\"ascii\\\"))\\n        self.read = lambda: self.buffer.read().decode(\\\"ascii\\\")\\n        self.readline = lambda: self.buffer.readline().decode(\\\"ascii\\\")\\n        \\nclass RangeQuery:\\n    def __init__(self, data, func=min):\\n        self.func = func\\n        self._data = _data = [list(data)]\\n        i, n = 1, len(_data[0])\\n        while 2 * i <= n:\\n            prev = _data[-1]\\n            _data.append([func(prev[j], prev[j + i]) for j in range(n - 2 * i + 1)])\\n            i <<= 1\\n \\n    def query(self, start, stop):\\n        \\\"\\\"\\\"func of data[start, stop)\\\"\\\"\\\"\\n        depth =...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"For a sequence of strings [t_1, t_2, ..., t_m], let's define the function f([t_1, t_2, ..., t_m]) as the number of different strings (including the empty string) that are subsequences of at least one string t_i. f([]) = 0 (i. e. the number of such strings for an empty sequence is 0).\\n\\nYou are given a sequence of strings [s_1, s_2, ..., s_n]. Every string in this sequence consists of lowercase Latin letters and is sorted (i. e., each string begins with several (maybe zero) characters a, then several (maybe zero) characters b, ..., ends with several (maybe zero) characters z).\\n\\nFor each of 2^n subsequences of [s_1, s_2, ..., s_n], calculate the value of the function f modulo 998244353.\\n\\nInput\\n\\nThe first line contains one integer n (1 \u2264 n \u2264 23) \u2014 the number of strings.\\n\\nThen n lines follow. The i-th line contains the string s_i (1 \u2264 |s_i| \u2264 2 \u22c5 10^4), consisting of lowercase Latin letters. Each string s_i is sorted.\\n\\nOutput\\n\\nSince printing up to 2^{23} integers would be really slow, you should do the following:\\n\\nFor each of the 2^n subsequences (which we denote as [s_{i_1}, s_{i_2}, ..., s_{i_k}]), calculate f([s_{i_1}, s_{i_2}, ..., s_{i_k}]), take it modulo 998244353, then multiply it by k \u22c5 (i_1 + i_2 + ... + i_k). Print the XOR of all 2^n integers you get.\\n\\nThe indices i_1, i_2, ..., i_k in the description of each subsequences are 1-indexed (i. e. are from 1 to n).\\n\\nExamples\\n\\nInput\\n\\n\\n3\\na\\nb\\nc\\n\\n\\nOutput\\n\\n\\n92\\n\\n\\nInput\\n\\n\\n2\\naa\\na\\n\\n\\nOutput\\n\\n\\n21\\n\\n\\nInput\\n\\n\\n2\\na\\na\\n\\n\\nOutput\\n\\n\\n10\\n\\n\\nInput\\n\\n\\n2\\nabcd\\naabb\\n\\n\\nOutput\\n\\n\\n124\\n\\n\\nInput\\n\\n\\n3\\nddd\\naaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\naaaaaaaabbbbbbbbbbbcccccccccccciiiiiiiiiiiiiiiiiiiiiiooooooooooqqqqqqqqqqqqqqqqqqvvvvvzzzzzzzzzzzz\\n\\n\\nOutput\\n\\n\\n15706243380\\nSolve the task in JAVA.\",\"targets\":\"import java.util.*;\\n\\npublic class G {\\n\\n    public static final int MOD998 = 998244353;\\n    public static final int MOD100 = 1000000007;\\n\\n    public static void main(String[] args) throws Exception {\\n        ContestScanner sc = new ContestScanner();\\n        ContestPrinter cp = new ContestPrinter();\\n        int N = sc.nextInt();\\n        int[][] data = new int[N][26];\\n        for (int n = 0; n < N; n++) {\\n            String s = sc.next();\\n            for (char c : s.toCharArray()) {\\n                data[n][c - 'a']++;\\n            }\\n        }\\n        long[] raw = new long[1 << N];\\n        \\/\\/ raw[0] = 1;\\n        \\/\\/ System.out.println(\\\"check1\\\");\\n        for (int n = 1; n < (1 << N); n++) {\\n            int[] min = new int[26];\\n            Arrays.fill(min, 20000);\\n            int count = 0;\\n            for (int m = 0; m < N; m++) {\\n                if ((n >> m & 1) == 1) {\\n                    for (int k = 0; k < 26; k++) {\\n                        if (min[k] > data[m][k]) {\\n                            min[k] = data[m][k];\\n                        }\\n                    }\\n                    count++;\\n                }\\n            }\\n            long mul = 1;\\n            for (int i : min) {\\n                mul *= i + 1;\\n                if (mul > 100000000000000L) {\\n                    mul %= MOD998;\\n                }\\n            }\\n            raw[n] = mul;\\n            if (count % 2 == 0) {\\n                raw[n] = MOD998 - raw[n];\\n            }\\n        }\\n        \\/\\/ System.out.println(\\\"check2\\\");\\n        \\/\\/ cp.println(Arrays.toString(raw));\\n        \\/\\/ long[] trans = new long[1 << N];\\n        for (int n = 0; n < N; n++) {\\n            for (int m = 0; m < (1 << N); m++) {\\n                if ((m >> n & 1) == 1) {\\n                    raw[m] += raw[m - (1 << n)];\\n                    if (raw[m] >= MOD998) {\\n                        raw[m] -= MOD998;\\n                    }\\n                }\\n            }\\n        }\\n        \\/\\/ System.out.println(\\\"check3\\\");\\n        \\/\\/ cp.println(Arrays.toString(raw));\\n        long ans = 0;\\n        for...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Find \\\\displaystyle{\\\\sum_{a=1}^{K}\\\\sum_{b=1}^{K}\\\\sum_{c=1}^{K} \\\\gcd(a,b,c)}.\\n\\nHere \\\\gcd(a,b,c) denotes the greatest common divisor of a, b, and c.\\n\\nConstraints\\n\\n* 1 \\\\leq K \\\\leq 200\\n* K is an integer.\\n\\nInput\\n\\nInput is given from Standard Input in the following format:\\n\\n\\nK\\n\\n\\nOutput\\n\\nPrint the value of \\\\displaystyle{\\\\sum_{a=1}^{K}\\\\sum_{b=1}^{K}\\\\sum_{c=1}^{K} \\\\gcd(a,b,c)}.\\n\\nExamples\\n\\nInput\\n\\n2\\n\\n\\nOutput\\n\\n9\\n\\n\\nInput\\n\\n200\\n\\n\\nOutput\\n\\n10813692\\nSolve the task in JAVA.\",\"targets\":\"import java.util.*;\\npublic class Main {\\n\\tpublic static void main(String args[]) {\\n\\t\\tScanner sc = new Scanner(System.in);\\n\\t\\tint K = sc.nextInt();\\n\\t\\tlong ans = 0;\\n\\t\\tfor(int i = 1; i <= K; i++) {\\n\\t\\t\\tfor(int j = 1; j <= K; j++) {\\n\\t\\t\\t\\tfor(int k = 1; k <= K; k++) {\\n\\t\\t\\t\\t\\tans += gcd(i, gcd(j, k));\\n\\t\\t\\t\\t}\\n\\t\\t\\t}\\n\\t\\t}\\n\\t\\tSystem.out.println(ans);\\n\\t}\\n\\t\\n\\tstatic int gcd (int a, int b) {\\n\\t\\treturn b > 0 ? gcd(b, a % b) : a;\\n\\t}\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Consider the following equation: \\n\\n<image> where sign [a] represents the integer part of number a.\\n\\nLet's find all integer z (z > 0), for which this equation is unsolvable in positive integers. The phrase \\\"unsolvable in positive integers\\\" means that there are no such positive integers x and y (x, y > 0), for which the given above equation holds.\\n\\nLet's write out all such z in the increasing order: z1, z2, z3, and so on (zi < zi + 1). Your task is: given the number n, find the number zn.\\n\\nInput\\n\\nThe first line contains a single integer n (1 \u2264 n \u2264 40).\\n\\nOutput\\n\\nPrint a single integer \u2014 the number zn modulo 1000000007 (109 + 7). It is guaranteed that the answer exists.\\n\\nExamples\\n\\nInput\\n\\n1\\n\\n\\nOutput\\n\\n1\\n\\nInput\\n\\n2\\n\\n\\nOutput\\n\\n3\\n\\nInput\\n\\n3\\n\\n\\nOutput\\n\\n15\\nSolve the task in PYTHON.\",\"targets\":\"def is_prime(n):\\n    if n==1:return True\\n    k=2\\n    while True:\\n        if n%k==0:\\n            return False\\n        if k*k>n:return True\\n        k+=1\\n\\nm=[2, 3, 5, 7, 13, 17, 19, 31, 61, 89, 107, 127, 521, 607, 1279, 2203, 2281, 3217, 4253, 4423, 9689, 9941, 11213, 19937, 21701, 23209, 44497, 86243, 110503, 132049, 216091, 756839, 859433, 1257787, 1398269, 2976221, 3021377, 6972593, 13466917, 20996011]\\n\\ndef main():\\n    n=input()\\n    k=m[n-1]\\n    mod=10**9+7\\n    print pow(2,k-1,10**9+7)-1\\n\\nmain()\",\"language\":\"python\",\"split\":\"train\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Being tired of participating in too many Codeforces rounds, Gildong decided to take some rest in a park. He sat down on a bench, and soon he found two rabbits hopping around. One of the rabbits was taller than the other.\\n\\nHe noticed that the two rabbits were hopping towards each other. The positions of the two rabbits can be represented as integer coordinates on a horizontal line. The taller rabbit is currently on position x, and the shorter rabbit is currently on position y (x < y). Every second, each rabbit hops to another position. The taller rabbit hops to the positive direction by a, and the shorter rabbit hops to the negative direction by b.\\n\\n<image>\\n\\nFor example, let's say x=0, y=10, a=2, and b=3. At the 1-st second, each rabbit will be at position 2 and 7. At the 2-nd second, both rabbits will be at position 4.\\n\\nGildong is now wondering: Will the two rabbits be at the same position at the same moment? If so, how long will it take? Let's find a moment in time (in seconds) after which the rabbits will be at the same point.\\n\\nInput\\n\\nEach test contains one or more test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 1000).\\n\\nEach test case contains exactly one line. The line consists of four integers x, y, a, b (0 \u2264 x < y \u2264 10^9, 1 \u2264 a,b \u2264 10^9) \u2014 the current position of the taller rabbit, the current position of the shorter rabbit, the hopping distance of the taller rabbit, and the hopping distance of the shorter rabbit, respectively.\\n\\nOutput\\n\\nFor each test case, print the single integer: number of seconds the two rabbits will take to be at the same position.\\n\\nIf the two rabbits will never be at the same position simultaneously, print -1.\\n\\nExample\\n\\nInput\\n\\n\\n5\\n0 10 2 3\\n0 10 3 3\\n900000000 1000000000 1 9999999\\n1 2 1 1\\n1 3 1 1\\n\\n\\nOutput\\n\\n\\n2\\n-1\\n10\\n-1\\n1\\n\\nNote\\n\\nThe first case is explained in the description.\\n\\nIn the second case, each rabbit will be at position 3 and 7 respectively at the 1-st second. But in the 2-nd second they will be at 6 and 4 respectively, and we can see that they will never...\\nUsing cpp can you solve the prior task?\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint main() {\\n  int x, y, a, b, n;\\n  scanf(\\\"%d\\\", &n);\\n  for (int i = 0; i < n; i++) {\\n    scanf(\\\"%d %d %d %d\\\", &x, &y, &a, &b);\\n    if ((y - x) % (a + b) == 0) {\\n      printf(\\\"%d\\\\n\\\", (y - x) \\/ (a + b));\\n    } else {\\n      printf(\\\"-1\\\\n\\\");\\n    }\\n  }\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"PYTHON3 solution for \\\"Gregor is learning about RSA cryptography, and although he doesn't understand how RSA works, he is now fascinated with prime numbers and factoring them.\\n\\nGregor's favorite prime number is P. Gregor wants to find two bases of P. Formally, Gregor is looking for two integers a and b which satisfy both of the following properties.\\n\\n  * P mod a = P mod b, where x mod y denotes the remainder when x is divided by y, and \\n  * 2 \u2264 a < b \u2264 P. \\n\\n\\n\\nHelp Gregor find two bases of his favorite prime number!\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 1000).\\n\\nEach subsequent line contains the integer P (5 \u2264 P \u2264 {10}^9), with P guaranteed to be prime.\\n\\nOutput\\n\\nYour output should consist of t lines. Each line should consist of two integers a and b (2 \u2264 a < b \u2264 P). If there are multiple possible solutions, print any.\\n\\nExample\\n\\nInput\\n\\n\\n2\\n17\\n5\\n\\n\\nOutput\\n\\n\\n3 5\\n2 4\\n\\nNote\\n\\nThe first query is P=17. a=3 and b=5 are valid bases in this case, because 17 mod 3 = 17 mod 5 = 2. There are other pairs which work as well.\\n\\nIn the second query, with P=5, the only solution is a=2 and b=4.\\\":\",\"targets\":\"num = int(input())\\nvar1 = 0\\nvar2 = 1\\nfor x in range(num):\\n    test = int(input())\\n    a = test\\/\\/2\\n    b = a*2 \\n    print(a,b)\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Efim just received his grade for the last test. He studies in a special school and his grade can be equal to any positive decimal fraction. First he got disappointed, as he expected a way more pleasant result. Then, he developed a tricky plan. Each second, he can ask his teacher to round the grade at any place after the decimal point (also, he can ask to round to the nearest integer). \\n\\nThere are t seconds left till the end of the break, so Efim has to act fast. Help him find what is the maximum grade he can get in no more than t seconds. Note, that he can choose to not use all t seconds. Moreover, he can even choose to not round the grade at all.\\n\\nIn this problem, classic rounding rules are used: while rounding number to the n-th digit one has to take a look at the digit n + 1. If it is less than 5 than the n-th digit remain unchanged while all subsequent digits are replaced with 0. Otherwise, if the n + 1 digit is greater or equal to 5, the digit at the position n is increased by 1 (this might also change some other digits, if this one was equal to 9) and all subsequent digits are replaced with 0. At the end, all trailing zeroes are thrown away.\\n\\nFor example, if the number 1.14 is rounded to the first decimal place, the result is 1.1, while if we round 1.5 to the nearest integer, the result is 2. Rounding number 1.299996121 in the fifth decimal place will result in number 1.3.\\n\\nInput\\n\\nThe first line of the input contains two integers n and t (1 \u2264 n \u2264 200 000, 1 \u2264 t \u2264 109) \u2014 the length of Efim's grade and the number of seconds till the end of the break respectively.\\n\\nThe second line contains the grade itself. It's guaranteed that the grade is a positive number, containing at least one digit after the decimal points, and it's representation doesn't finish with 0.\\n\\nOutput\\n\\nPrint the maximum grade that Efim can get in t seconds. Do not print trailing zeroes.\\n\\nExamples\\n\\nInput\\n\\n6 1\\n10.245\\n\\n\\nOutput\\n\\n10.25\\n\\n\\nInput\\n\\n6 2\\n10.245\\n\\n\\nOutput\\n\\n10.3\\n\\n\\nInput\\n\\n3 100\\n9.2\\n\\n\\nOutput\\n\\n9.2\\n\\nNote\\n\\nIn the first two samples Efim...\\n(n, t\",\"targets\":\") = [int(x) for x in input().split()]\\n(a, s) = input().split('.')\\n\\ns = list(s)\\n\\npos = len(s) - 1\\nfor i in range(len(s)):\\n\\tif ord(s[i]) > ord('4'):\\n\\t\\tpos = i\\n\\t\\tbreak\\n\\nwhile t > 0 and pos > 0:\\n\\tif ord(s[pos]) > ord('4'):\\n\\t\\tpos -= 1\\n\\t\\ts[pos] = chr(ord(s[pos]) + 1)\\n\\t\\tt -= 1\\n\\telse:\\n\\t\\tbreak\\n\\nif t > 0 and pos == 0 and s[0] > '4':\\n\\tit = len(a) - 1\\n\\tA = [ord(ch) - ord('0') for ch in a]\\n\\tA[it] += 1\\n\\twhile it > 0:\\n\\t\\tif A[it] == 10:\\n\\t\\t\\tA[it] = 0\\n\\t\\t\\tA[it - 1] += 1\\n\\t\\t\\tit -= 1\\n\\t\\telse:\\n\\t\\t\\tbreak\\n\\tres = \\\"\\\".join([str(x) for x in A])\\n\\tprint(res)\\nelse:\\n\\t\\n\\tres = a + '.' + \\\"\\\".join(s[:pos + 1])\\n\\t\\n\\tprint(res)\",\"language\":\"python\",\"split\":\"train\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Polycarp must pay exactly n burles at the checkout. He has coins of two nominal values: 1 burle and 2 burles. Polycarp likes both kinds of coins equally. So he doesn't want to pay with more coins of one type than with the other.\\n\\nThus, Polycarp wants to minimize the difference between the count of coins of 1 burle and 2 burles being used. Help him by determining two non-negative integer values c_1 and c_2 which are the number of coins of 1 burle and 2 burles, respectively, so that the total value of that number of coins is exactly n (i. e. c_1 + 2 \u22c5 c_2 = n), and the absolute value of the difference between c_1 and c_2 is as little as possible (i. e. you must minimize |c_1-c_2|).\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases. Then t test cases follow.\\n\\nEach test case consists of one line. This line contains one integer n (1 \u2264 n \u2264 10^9) \u2014 the number of burles to be paid by Polycarp.\\n\\nOutput\\n\\nFor each test case, output a separate line containing two integers c_1 and c_2 (c_1, c_2 \u2265 0) separated by a space where c_1 is the number of coins of 1 burle and c_2 is the number of coins of 2 burles. If there are multiple optimal solutions, print any one.\\n\\nExample\\n\\nInput\\n\\n\\n6\\n1000\\n30\\n1\\n32\\n1000000000\\n5\\n\\n\\nOutput\\n\\n\\n334 333\\n10 10\\n1 0\\n10 11\\n333333334 333333333\\n1 2\\n\\nNote\\n\\nThe answer for the first test case is \\\"334 333\\\". The sum of the nominal values of all coins is 334 \u22c5 1 + 333 \u22c5 2 = 1000, whereas |334 - 333| = 1. One can't get the better value because if |c_1 - c_2| = 0, then c_1 = c_2 and c_1 \u22c5 1 + c_1 \u22c5 2 = 1000, but then the value of c_1 isn't an integer.\\n\\nThe answer for the second test case is \\\"10 10\\\". The sum of the nominal values is 10 \u22c5 1 + 10 \u22c5 2 = 30 and |10 - 10| = 0, whereas there's no number having an absolute value less than 0.\\nUsing python3 can you solve the prior task?\",\"targets\":\"import sys\\n \\ninput = sys.stdin.readline\\n \\n \\ndef S(): return input()\\ndef I(): return int(S())\\ndef M(): return map(int, S().split())\\ndef L(): return list(M())\\n \\n \\nt = int(input())\\nfor p in range(t):\\n    n = I()\\n    if n == 1:\\n        print(1, 0)\\n    elif n == 2:\\n        print(0, 1)\\n    else:\\n        a = n\\/\\/3\\n        b = n % 3\\n        if b == 0:\\n            print(a, a)\\n        elif b == 1:\\n            print(a+1, a)\\n        else:\\n            print(a, a+1)\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You are given an array consisting of all integers from [l, r] inclusive. For example, if l = 2 and r = 5, the array would be [2, 3, 4, 5]. What's the minimum number of elements you can delete to make the [bitwise AND](https:\\/\\/en.wikipedia.org\\/wiki\\/Bitwise_operation#AND) of the array non-zero?\\n\\nA bitwise AND is a binary operation that takes two equal-length binary representations and performs the AND operation on each pair of the corresponding bits.\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases. Then t cases follow.\\n\\nThe first line of each test case contains two integers l and r (1 \u2264 l \u2264 r \u2264 2 \u22c5 10^5) \u2014 the description of the array.\\n\\nOutput\\n\\nFor each test case, output a single integer \u2014 the answer to the problem.\\n\\nExample\\n\\nInput\\n\\n\\n5\\n1 2\\n2 8\\n4 5\\n1 5\\n100000 200000\\n\\n\\nOutput\\n\\n\\n1\\n3\\n0\\n2\\n31072\\n\\nNote\\n\\nIn the first test case, the array is [1, 2]. Currently, the bitwise AND is 0, as 1\\\\ \\\\& \\\\ 2 = 0. However, after deleting 1 (or 2), the array becomes [2] (or [1]), and the bitwise AND becomes 2 (or 1). This can be proven to be the optimal, so the answer is 1.\\n\\nIn the second test case, the array is [2, 3, 4, 5, 6, 7, 8]. Currently, the bitwise AND is 0. However, after deleting 4, 5, and 8, the array becomes [2, 3, 6, 7], and the bitwise AND becomes 2. This can be proven to be the optimal, so the answer is 3. Note that there may be other ways to delete 3 elements.\\nUsing cpp can you solve the prior task?\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst int mod = (int)(1e9 + 7);\\nconst int N = 200010;\\nconst int inf = (int)(1e9);\\nlong long cnt[21][N];\\nvoid solve() {\\n  long long l, r;\\n  cin >> l >> r;\\n  long long ans = INT_MIN;\\n  for (long long i = 1; i <= 20; i++) {\\n    ans = max(ans, cnt[i][r] - cnt[i][l - 1]);\\n  }\\n  cout << r - l + 1 - ans << \\\"\\\\n\\\";\\n}\\nsigned main() {\\n  long long fact = 2;\\n  long long rem = 1;\\n  for (long long i = 1; i <= 20; i++) {\\n    cnt[i][0] = 0;\\n    for (long long j = 1; j < N; j++) {\\n      if (j % fact >= rem) {\\n        cnt[i][j] = 1;\\n      }\\n      cnt[i][j] += cnt[i][j - 1];\\n    }\\n    fact *= 2;\\n    rem *= 2;\\n  }\\n  ios_base::sync_with_stdio(0);\\n  cin.tie(0);\\n  cout.tie(0);\\n  long long tt = 1;\\n  cin >> tt;\\n  while (tt--) solve();\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"A permutation of length n is an integer sequence such that each integer from 0 to (n - 1) appears exactly once in it. For example, sequence [0, 2, 1] is a permutation of length 3 while both [0, 2, 2] and [1, 2, 3] are not.\\n\\nA fixed point of a function is a point that is mapped to itself by the function. A permutation can be regarded as a bijective function. We'll get a definition of a fixed point in a permutation. An integer i is a fixed point of permutation a0, a1, ..., an - 1 if and only if ai = i. For example, permutation [0, 2, 1] has 1 fixed point and permutation [0, 1, 2] has 3 fixed points.\\n\\nYou are given permutation a. You are allowed to swap two elements of the permutation at most once. Your task is to maximize the number of fixed points in the resulting permutation. Note that you are allowed to make at most one swap operation.\\n\\nInput\\n\\nThe first line contains a single integer n (1 \u2264 n \u2264 105). The second line contains n integers a0, a1, ..., an - 1 \u2014 the given permutation.\\n\\nOutput\\n\\nPrint a single integer \u2014 the maximum possible number of fixed points in the permutation after at most one swap operation.\\n\\nExamples\\n\\nInput\\n\\n5\\n0 1 3 4 2\\n\\n\\nOutput\\n\\n3\\nUsing cpp can you solve the prior task?\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint main() {\\n  int n, a[100005], b[100005] = {0}, one = 0, cnt = 0, i;\\n  scanf(\\\"%d\\\", &n);\\n  for (i = 0; i < n; i++) scanf(\\\"%d\\\", &a[i]);\\n  for (i = 0; i < n; i++)\\n    if (i == a[i]) {\\n      b[i] = 1;\\n      cnt++;\\n    }\\n  for (i = 0; i < n; i++)\\n    if (b[i] == 0) {\\n      one = 1;\\n      if (a[a[i]] == i) {\\n        printf(\\\"%d\\\\n\\\", cnt + 2);\\n        return 0;\\n      }\\n    }\\n  printf(\\\"%d\\\\n\\\", cnt + one);\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Monocarp wrote down two numbers on a whiteboard. Both numbers follow a specific format: a positive integer x with p zeros appended to its end.\\n\\nNow Monocarp asks you to compare these two numbers. Can you help him?\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 10^4) \u2014 the number of testcases.\\n\\nThe first line of each testcase contains two integers x_1 and p_1 (1 \u2264 x_1 \u2264 10^6; 0 \u2264 p_1 \u2264 10^6) \u2014 the description of the first number.\\n\\nThe second line of each testcase contains two integers x_2 and p_2 (1 \u2264 x_2 \u2264 10^6; 0 \u2264 p_2 \u2264 10^6) \u2014 the description of the second number.\\n\\nOutput\\n\\nFor each testcase print the result of the comparison of the given two numbers. If the first number is smaller than the second one, print '<'. If the first number is greater than the second one, print '>'. If they are equal, print '='.\\n\\nExample\\n\\nInput\\n\\n\\n5\\n2 1\\n19 0\\n10 2\\n100 1\\n1999 0\\n2 3\\n1 0\\n1 0\\n99 0\\n1 2\\n\\n\\nOutput\\n\\n\\n&gt;\\n=\\n&lt;\\n=\\n&lt;\\n\\nNote\\n\\nThe comparisons in the example are: 20 > 19, 1000 = 1000, 1999 < 2000, 1 = 1, 99 < 100.\\nSolve the task in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nvoid hyuga(int T) {\\n  int x1, p1, x2, p2;\\n  cin >> x1 >> p1 >> x2 >> p2;\\n  long double x = x1 \\/ long double(x2);\\n  long long int p = p2 - p1;\\n  if (log10f(x) > p2 - p1)\\n    cout << \\\">\\\\n\\\";\\n  else if (log10f(x) < p2 - p1)\\n    cout << \\\"<\\\\n\\\";\\n  else\\n    cout << \\\"=\\\\n\\\";\\n}\\nint main() {\\n  ios_base::sync_with_stdio(false);\\n  cin.tie(NULL);\\n  cout.tie(NULL);\\n  int T = 1;\\n  cin >> T;\\n  while (T--) {\\n    hyuga(T);\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Petya has got an interesting flower. Petya is a busy person, so he sometimes forgets to water it. You are given n days from Petya's live and you have to determine what happened with his flower in the end.\\n\\nThe flower grows as follows: \\n\\n  * If the flower isn't watered for two days in a row, it dies. \\n  * If the flower is watered in the i-th day, it grows by 1 centimeter. \\n  * If the flower is watered in the i-th and in the (i-1)-th day (i > 1), then it grows by 5 centimeters instead of 1. \\n  * If the flower is not watered in the i-th day, it does not grow. \\n\\n\\n\\nAt the beginning of the 1-st day the flower is 1 centimeter tall. What is its height after n days?\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 100). Description of the test cases follows.\\n\\nThe first line of each test case contains the only integer n (1 \u2264 n \u2264 100).\\n\\nThe second line of each test case contains n integers a_1, a_2, ..., a_n (a_i = 0 or a_i = 1). If a_i = 1, the flower is watered in the i-th day, otherwise it is not watered.\\n\\nOutput\\n\\nFor each test case print a single integer k \u2014 the flower's height after n days, or -1, if the flower dies.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n3\\n1 0 1\\n3\\n0 1 1\\n4\\n1 0 0 1\\n1\\n0\\n\\n\\nOutput\\n\\n\\n3\\n7\\n-1\\n1\\nThe above is tricky. Write me a correct solution in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint main() {\\n  int t;\\n  cin >> t;\\n  while (t--) {\\n    int n;\\n    cin >> n;\\n    int c = 1;\\n    bool nw = false;\\n    bool d = false;\\n    for (int i = 0; i < n; ++i) {\\n      int s;\\n      cin >> s;\\n      if (d) {\\n        continue;\\n      }\\n      if (s == 1) {\\n        if (i > 0 && !nw) {\\n          c += 5;\\n        } else {\\n          c += 1;\\n        }\\n        nw = false;\\n      } else {\\n        if (nw) {\\n          d = true;\\n        }\\n        nw = true;\\n      }\\n    }\\n    cout << (d ? -1 : c) << endl;\\n  }\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Cowboy Vlad has a birthday today! There are n children who came to the celebration. In order to greet Vlad, the children decided to form a circle around him. Among the children who came, there are both tall and low, so if they stand in a circle arbitrarily, it may turn out, that there is a tall and low child standing next to each other, and it will be difficult for them to hold hands. Therefore, children want to stand in a circle so that the maximum difference between the growth of two neighboring children would be minimal possible.\\n\\nFormally, let's number children from 1 to n in a circle order, that is, for every i child with number i will stand next to the child with number i+1, also the child with number 1 stands next to the child with number n. Then we will call the discomfort of the circle the maximum absolute difference of heights of the children, who stand next to each other.\\n\\nPlease help children to find out how they should reorder themselves, so that the resulting discomfort is smallest possible.\\n\\nInput\\n\\nThe first line contains a single integer n (2 \u2264 n \u2264 100) \u2014 the number of the children who came to the cowboy Vlad's birthday.\\n\\nThe second line contains integers a_1, a_2, \u2026, a_n (1 \u2264 a_i \u2264 10^9) denoting heights of every child.\\n\\nOutput\\n\\nPrint exactly n integers \u2014 heights of the children in the order in which they should stand in a circle. You can start printing a circle with any child.\\n\\nIf there are multiple possible answers, print any of them.\\n\\nExamples\\n\\nInput\\n\\n\\n5\\n2 1 1 3 2\\n\\n\\nOutput\\n\\n\\n1 2 3 2 1\\n\\n\\nInput\\n\\n\\n3\\n30 10 20\\n\\n\\nOutput\\n\\n\\n10 20 30\\n\\nNote\\n\\nIn the first example, the discomfort of the circle is equal to 1, since the corresponding absolute differences are 1, 1, 1 and 0. Note, that sequences [2, 3, 2, 1, 1] and [3, 2, 1, 1, 2] form the same circles and differ only by the selection of the starting point.\\n\\nIn the second example, the discomfort of the circle is equal to 20, since the absolute difference of 10 and 30 is equal to 20.\\nUsing java can you solve the prior task?\",\"targets\":\"import java.io.PrintWriter;\\nimport java.util.Arrays;\\nimport java.util.Scanner;\\n\\npublic class Main {\\n    \\n    public static void main(String[] args) {\\n        Scanner scanner = new Scanner(System.in);\\n        PrintWriter out = new PrintWriter(System.out);\\n\\n        int n = scanner.nextInt();\\n        Integer[] a = new Integer[n];\\n         \\n        for (int i = 0; i < n; i++) {\\n            a[i] = scanner.nextInt();\\n        }\\n\\n        Arrays.sort(a);\\n\\n        for (int i = 0; i < n; i += 2) {\\n            out.print(a[i] + \\\" \\\");\\n        }\\n\\n        int k = n - 1;\\n        if (k % 2 == 0) {\\n            k--;\\n        }\\n\\n        for (int i = k; i >= 1; i -= 2) {\\n            out.print(a[i] + \\\" \\\");\\n        }\\n\\n        out.flush();\\n    }\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"The only difference between this problem and D1 is that you don't have to provide the way to construct the answer in D1, but you have to do it in this problem.\\n\\nThere's a table of n \u00d7 m cells (n rows and m columns). The value of n \u22c5 m is even.\\n\\nA domino is a figure that consists of two cells having a common side. It may be horizontal (one of the cells is to the right of the other) or vertical (one of the cells is above the other).\\n\\nYou need to place nm\\/2 dominoes on the table so that exactly k of them are horizontal and all the other dominoes are vertical. The dominoes cannot overlap and must fill the whole table.\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 10) \u2014 the number of test cases. Then t test cases follow.\\n\\nEach test case consists of a single line. The line contains three integers n, m, k (1 \u2264 n,m \u2264 100, 0 \u2264 k \u2264 nm\\/2, n \u22c5 m is even) \u2014 the count of rows, columns and horizontal dominoes, respectively.\\n\\nOutput\\n\\nFor each test case:\\n\\n  * print \\\"NO\\\" if it's not possible to place the dominoes on the table in the described way; \\n  * otherwise, print \\\"YES\\\" on a separate line, then print n lines so that each of them contains m lowercase letters of the Latin alphabet \u2014 the layout of the dominoes on the table. Each cell of the table must be marked by the letter so that for every two cells having a common side, they are marked by the same letters if and only if they are occupied by the same domino. I.e. both cells of the same domino must be marked with the same letter, but two dominoes that share a side must be marked with different letters. If there are multiple solutions, print any of them. \\n\\nExample\\n\\nInput\\n\\n\\n8\\n4 4 2\\n2 3 0\\n3 2 3\\n1 2 0\\n2 4 2\\n5 2 2\\n2 17 16\\n2 1 1\\n\\n\\nOutput\\n\\n\\nYES\\naccx\\naegx\\nbega\\nbdda\\nYES\\naha\\naha\\nYES\\nzz\\naa\\nzz\\nNO\\nYES\\naaza\\nbbza\\nNO\\nYES\\nbbaabbaabbaabbaay\\nddccddccddccddccy\\nNO\",\"targets\":\"#include <bits\\/stdc++.h>\\nint t, n, m, k;\\nchar res[106][106];\\nint main() {\\n  for (scanf(\\\"%d\\\", &t); t--;) {\\n    scanf(\\\"%d%d%d\\\", &n, &m, &k);\\n    if (n % 2 == 0 && m % 2 == 0) {\\n      if (k % 2 == 0) {\\n        puts(\\\"YES\\\");\\n        int cnt = 0;\\n        for (int i = 0; i < n; i += 2)\\n          for (int j = 0; j < m; j += 2) {\\n            if (cnt < k) {\\n              cnt += 2;\\n              res[i][j] = res[i][j + 1] = (i \\/ 2 % 2 ^ j \\/ 2 % 2 ? 'a' : 'c');\\n              res[i + 1][j] = res[i + 1][j + 1] =\\n                  (i \\/ 2 % 2 ^ j \\/ 2 % 2 ? 'b' : 'd');\\n            } else {\\n              res[i][j] = res[i + 1][j] = (i \\/ 2 % 2 ^ j \\/ 2 % 2 ? 'a' : 'c');\\n              res[i][j + 1] = res[i + 1][j + 1] =\\n                  (i \\/ 2 % 2 ^ j \\/ 2 % 2 ? 'b' : 'd');\\n            }\\n          }\\n        for (int i = 0; i < n; i++) {\\n          for (int j = 0; j < m; j++) printf(\\\"%c\\\", res[i][j]);\\n          puts(\\\"\\\");\\n        }\\n      } else\\n        puts(\\\"NO\\\");\\n    }\\n    if (n % 2 == 0 && m % 2 == 1) {\\n      if (k <= n * (m - 1) \\/ 2 && k % 2 == n * (m - 1) \\/ 2 % 2) {\\n        puts(\\\"YES\\\");\\n        int cnt = 0;\\n        for (int i = 0; i < n; i += 2)\\n          res[i][m - 1] = res[i + 1][m - 1] = (i \\/ 2 % 2 ? 'e' : 'f');\\n        for (int i = 0; i < n; i += 2)\\n          for (int j = 0; j < m - 1; j += 2) {\\n            if (cnt < k) {\\n              cnt += 2;\\n              res[i][j] = res[i][j + 1] = (i \\/ 2 % 2 ^ j \\/ 2 % 2 ? 'a' : 'c');\\n              res[i + 1][j] = res[i + 1][j + 1] =\\n                  (i \\/ 2 % 2 ^ j \\/ 2 % 2 ? 'b' : 'd');\\n            } else {\\n              res[i][j] = res[i + 1][j] = (i \\/ 2 % 2 ^ j \\/ 2 % 2 ? 'a' : 'c');\\n              res[i][j + 1] = res[i + 1][j + 1] =\\n                  (i \\/ 2 % 2 ^ j \\/ 2 % 2 ? 'b' : 'd');\\n            }\\n          }\\n        for (int i = 0; i < n; i++) {\\n          for (int j = 0; j < m; j++) printf(\\\"%c\\\", res[i][j]);\\n          puts(\\\"\\\");\\n        }\\n      } else\\n        puts(\\\"NO\\\");\\n    }\\n    if (n % 2 == 1 && m % 2 == 0) {\\n      if (n * m \\/ 2 - k <= (n - 1) * m \\/ 2 && k % 2 == m \\/ 2 % 2) {\\n     ...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You are given a digital clock with n digits. Each digit shows an integer from 0 to 9, so the whole clock shows an integer from 0 to 10^n-1. The clock will show leading zeroes if the number is smaller than 10^{n-1}.\\n\\nYou want the clock to show 0 with as few operations as possible. In an operation, you can do one of the following: \\n\\n  * decrease the number on the clock by 1, or \\n  * swap two digits (you can choose which digits to swap, and they don't have to be adjacent). \\n\\n\\n\\nYour task is to determine the minimum number of operations needed to make the clock show 0.\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 10^3).\\n\\nThe first line of each test case contains a single integer n (1 \u2264 n \u2264 100) \u2014 number of digits on the clock.\\n\\nThe second line of each test case contains a string of n digits s_1, s_2, \u2026, s_n (0 \u2264 s_1, s_2, \u2026, s_n \u2264 9) \u2014 the number on the clock.\\n\\nNote: If the number is smaller than 10^{n-1} the clock will show leading zeroes.\\n\\nOutput\\n\\nFor each test case, print one integer: the minimum number of operations needed to make the clock show 0.\\n\\nExample\\n\\nInput\\n\\n\\n7\\n3\\n007\\n4\\n1000\\n5\\n00000\\n3\\n103\\n4\\n2020\\n9\\n123456789\\n30\\n001678294039710047203946100020\\n\\n\\nOutput\\n\\n\\n7\\n2\\n0\\n5\\n6\\n53\\n115\\n\\nNote\\n\\nIn the first example, it's optimal to just decrease the number 7 times.\\n\\nIn the second example, we can first swap the first and last position and then decrease the number by 1.\\n\\nIn the third example, the clock already shows 0, so we don't have to perform any operations.\\nUsing cpp can you solve the prior task?\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst int mod = 1e9 + 7;\\nvoid solve() {\\n  int n;\\n  cin >> n;\\n  string s;\\n  cin >> s;\\n  int cnt = 0;\\n  for (int i = 0; i < n; i++) {\\n    if (s[i] != '0') {\\n      if (i == n - 1) {\\n        cnt += s[i] - '0';\\n      } else {\\n        cnt += s[i] - '0';\\n        cnt++;\\n      }\\n    }\\n  }\\n  cout << cnt << endl;\\n}\\nint main() {\\n  ios::sync_with_stdio(0);\\n  cin.tie(0);\\n  int t;\\n  cin >> t;\\n  while (t--) {\\n    solve();\\n  }\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"A permutation of length n is a sequence of integers from 1 to n of length n containing each number exactly once. For example, [1], [4, 3, 5, 1, 2], [3, 2, 1] are permutations, and [1, 1], [0, 1], [2, 2, 1, 4] are not.\\n\\nThere was a permutation p[1 ... n]. It was merged with itself. In other words, let's take two instances of p and insert elements of the second p into the first maintaining relative order of elements. The result is a sequence of the length 2n.\\n\\nFor example, if p=[3, 1, 2] some possible results are: [3, 1, 2, 3, 1, 2], [3, 3, 1, 1, 2, 2], [3, 1, 3, 1, 2, 2]. The following sequences are not possible results of a merging: [1, 3, 2, 1, 2, 3], [3, 1, 2, 3, 2, 1], [3, 3, 1, 2, 2, 1].\\n\\nFor example, if p=[2, 1] the possible results are: [2, 2, 1, 1], [2, 1, 2, 1]. The following sequences are not possible results of a merging: [1, 1, 2, 2], [2, 1, 1, 2], [1, 2, 2, 1].\\n\\nYour task is to restore the permutation p by the given resulting sequence a. It is guaranteed that the answer exists and is unique.\\n\\nYou have to answer t independent test cases.\\n\\nInput\\n\\nThe first line of the input contains one integer t (1 \u2264 t \u2264 400) \u2014 the number of test cases. Then t test cases follow.\\n\\nThe first line of the test case contains one integer n (1 \u2264 n \u2264 50) \u2014 the length of permutation. The second line of the test case contains 2n integers a_1, a_2, ..., a_{2n} (1 \u2264 a_i \u2264 n), where a_i is the i-th element of a. It is guaranteed that the array a represents the result of merging of some permutation p with the same permutation p.\\n\\nOutput\\n\\nFor each test case, print the answer: n integers p_1, p_2, ..., p_n (1 \u2264 p_i \u2264 n), representing the initial permutation. It is guaranteed that the answer exists and is unique.\\n\\nExample\\n\\nInput\\n\\n\\n5\\n2\\n1 1 2 2\\n4\\n1 3 1 4 3 4 2 2\\n5\\n1 2 1 2 3 4 3 5 4 5\\n3\\n1 2 3 1 2 3\\n4\\n2 3 2 4 1 3 4 1\\n\\n\\nOutput\\n\\n\\n1 2 \\n1 3 4 2 \\n1 2 3 4 5 \\n1 2 3 \\n2 3 4 1 \\nfor _\",\"targets\":\"in range(int(input())):\\n    n=int(input())\\n    b=[True]*n\\n    a=list(map(int,input().split()))\\n    for i in a:\\n        if(b[i-1]):\\n           print(i,end=\\\" \\\")\\n           b[i-1]=False\\n    print()\",\"language\":\"python\",\"split\":\"train\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"There is a city park represented as a tree with n attractions as its vertices and n - 1 rails as its edges. The i-th attraction has happiness value a_i.\\n\\nEach rail has a color. It is either black if t_i = 0, or white if t_i = 1. Black trains only operate on a black rail track, and white trains only operate on a white rail track. If you are previously on a black train and want to ride a white train, or you are previously on a white train and want to ride a black train, you need to use 1 ticket.\\n\\nThe path of a tour must be a simple path \u2014 it must not visit an attraction more than once. You do not need a ticket the first time you board a train. You only have k tickets, meaning you can only switch train types at most k times. In particular, you do not need a ticket to go through a path consisting of one rail color.\\n\\nDefine f(u, v) as the sum of happiness values of the attractions in the tour (u, v), which is a simple path that starts at the u-th attraction and ends at the v-th attraction. Find the sum of f(u,v) for all valid tours (u, v) (1 \u2264 u \u2264 v \u2264 n) that does not need more than k tickets, modulo 10^9 + 7.\\n\\nInput\\n\\nThe first line contains two integers n and k (2 \u2264 n \u2264 2 \u22c5 10^5, 0 \u2264 k \u2264 n-1) \u2014 the number of attractions in the city park and the number of tickets you have.\\n\\nThe second line contains n integers a_1, a_2,\u2026, a_n (0 \u2264 a_i \u2264 10^9) \u2014 the happiness value of each attraction.\\n\\nThe i-th of the next n - 1 lines contains three integers u_i, v_i, and t_i (1 \u2264 u_i, v_i \u2264 n, 0 \u2264 t_i \u2264 1) \u2014 an edge between vertices u_i and v_i with color t_i. The given edges form a tree.\\n\\nOutput\\n\\nOutput an integer denoting the total happiness value for all valid tours (u, v) (1 \u2264 u \u2264 v \u2264 n), modulo 10^9 + 7.\\n\\nExamples\\n\\nInput\\n\\n\\n5 0\\n1 3 2 6 4\\n1 2 1\\n1 4 0\\n3 2 1\\n2 5 0\\n\\n\\nOutput\\n\\n\\n45\\n\\n\\nInput\\n\\n\\n3 1\\n1 1 1\\n1 2 1\\n3 2 0\\n\\n\\nOutput\\n\\n\\n10\\nUsing cpp can you solve the prior task?\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nlong long const mod = 1e9 + 7, MAXN = 2e5 + 5, oo = 3e18;\\nclass fenwick {\\n private:\\n  vector<long long> ft;\\n\\n public:\\n  vector<pair<long long, long long> > save;\\n  fenwick(long long n) { ft.assign(n + 5, 0); }\\n  long long ls(long long x) { return x & (-x); }\\n  void reset() {\\n    for (long long &cur : ft) {\\n      cur = 0;\\n    }\\n    save.clear();\\n  }\\n  void inc(long long pos, long long val) {\\n    pos++;\\n    if (pos <= 0) return;\\n    for (; pos < ft.size(); pos += ls(pos)) {\\n      ft[pos] = (ft[pos] + val + mod) % mod;\\n    }\\n  }\\n  long long rsq(long long pos) {\\n    pos++;\\n    if (pos <= 0) return 0;\\n    long long res = 0;\\n    for (; pos; pos -= ls(pos)) {\\n      res = (res + ft[pos] + mod) % mod;\\n    }\\n    return res;\\n  }\\n  void update(long long pos, long long val) {\\n    save.push_back(make_pair(pos, val));\\n    inc(pos, val);\\n  }\\n  void rollback(long long sz) {\\n    while (save.size() > sz) {\\n      pair<long long, long long> cur = save.back();\\n      save.pop_back();\\n      inc(cur.first, -cur.second);\\n    }\\n  }\\n};\\nfenwick black(MAXN);\\nfenwick white(MAXN);\\nfenwick cum_black(MAXN);\\nfenwick cum_white(MAXN);\\nlong long tc, n, m;\\nlong long a[MAXN], sum[MAXN];\\nvector<pair<long long, long long> > g[MAXN];\\nlong long ANS;\\nlong long sz[MAXN];\\nbool re[MAXN];\\nlong long find_size(long long u, long long p = -1) {\\n  sz[u] = 1;\\n  for (auto cur : g[u]) {\\n    long long v = cur.first;\\n    if (v == p || re[v]) continue;\\n    sz[u] += find_size(v, u);\\n  }\\n  return sz[u];\\n}\\nlong long find_centroid(long long u, long long sub, long long p = -1) {\\n  for (auto cur : g[u]) {\\n    long long v = cur.first;\\n    if (v == p || re[v]) continue;\\n    if (sz[v] > sub \\/ 2) return find_centroid(v, sub, u);\\n  }\\n  return u;\\n}\\nlong long cur_cen;\\nvoid dfs(long long u, long long p, long long col, long long trans,\\n         long long cur_down, bool filling) {\\n  if (trans > m) return;\\n  if (!filling) {\\n    sum[u] = (sum[p] + a[u] + mod) % mod;\\n  }\\n  if (filling) {\\n    long long exc = (sum[u] + mod - a[cur_cen]) %...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"JAVA solution for \\\"Polycarp has come up with a new game to play with you. He calls it \\\"A missing bigram\\\".\\n\\nA bigram of a word is a sequence of two adjacent letters in it.\\n\\nFor example, word \\\"abbaaba\\\" contains bigrams \\\"ab\\\", \\\"bb\\\", \\\"ba\\\", \\\"aa\\\", \\\"ab\\\" and \\\"ba\\\".\\n\\nThe game goes as follows. First, Polycarp comes up with a word, consisting only of lowercase letters 'a' and 'b'. Then, he writes down all its bigrams on a whiteboard in the same order as they appear in the word. After that, he wipes one of them off the whiteboard.\\n\\nFinally, Polycarp invites you to guess what the word that he has come up with was.\\n\\nYour goal is to find any word such that it's possible to write down all its bigrams and remove one of them, so that the resulting sequence of bigrams is the same as the one Polycarp ended up with.\\n\\nThe tests are generated in such a way that the answer exists. If there are multiple answers, you can print any of them.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 2000) \u2014 the number of testcases.\\n\\nThe first line of each testcase contains a single integer n (3 \u2264 n \u2264 100) \u2014 the length of the word Polycarp has come up with.\\n\\nThe second line of each testcase contains n-2 bigrams of that word, separated by a single space. Each bigram consists of two letters, each of them is either 'a' or 'b'.\\n\\nAdditional constraint on the input: there exists at least one string such that it is possible to write down all its bigrams, except one, so that the resulting sequence is the same as the sequence in the input. In other words, the answer exists.\\n\\nOutput\\n\\nFor each testcase print a word, consisting of n letters, each of them should be either 'a' or 'b'. It should be possible to write down all its bigrams and remove one of them, so that the resulting sequence of bigrams is the same as the one Polycarp ended up with.\\n\\nThe tests are generated in such a way that the answer exists. If there are multiple answers, you can print any of them. \\n\\nExample\\n\\nInput\\n\\n\\n4\\n7\\nab bb ba aa ba\\n7\\nab ba aa ab ba\\n3\\naa\\n5\\nbb ab...\\\":\",\"targets\":\"import java.io.BufferedReader;\\nimport java.io.BufferedWriter;\\nimport java.io.IOException;\\nimport java.io.InputStreamReader;\\nimport java.io.OutputStreamWriter;\\nimport java.util.StringTokenizer;\\n\\n\\/**\\n *\\n * @author eslam\\n *\\/\\npublic class MissingBigram {\\n\\n    static class FastReader {\\n\\n        BufferedReader br;\\n        StringTokenizer st;\\n\\n        public FastReader() {\\n            br = new BufferedReader(\\n                    new InputStreamReader(System.in));\\n        }\\n\\n        String next() {\\n            while (st == null || !st.hasMoreElements()) {\\n                try {\\n                    st = new StringTokenizer(br.readLine());\\n                } catch (IOException e) {\\n                    e.printStackTrace();\\n                }\\n            }\\n            return st.nextToken();\\n        }\\n\\n        int nextInt() {\\n            return Integer.parseInt(next());\\n        }\\n\\n        long nextLong() {\\n            return Long.parseLong(next());\\n        }\\n\\n        double nextDouble() {\\n            return Double.parseDouble(next());\\n        }\\n\\n        String nextLine() {\\n            String str = \\\"\\\";\\n            try {\\n                str = br.readLine();\\n            } catch (IOException e) {\\n                e.printStackTrace();\\n            }\\n            return str;\\n        }\\n    }\\n\\n    public static void main(String[] args) {\\n        FastReader input = new FastReader();\\n        BufferedWriter log = new BufferedWriter(new OutputStreamWriter(System.out));\\n        int t = input.nextInt();\\n        while (t-- > 0) {\\n            int n = input.nextInt();\\n            String w[] = new String[n];\\n            for (int i = 0; i < n - 2; i++) {\\n                w[i] = input.next();\\n            }\\n            boolean ca = true;\\n            String ans = \\\"\\\";\\n            ans += w[0].charAt(0);\\n            for (int i = 1; i < n - 2; i++) {\\n                if (w[i].charAt(0) != w[i - 1].charAt(1)) {\\n                    ans+=w[i - 1].charAt(1);\\n                    ca = false;\\n                }\\n                ans += w[i].charAt(0);\\n           ...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"An array of integers p_1, p_2, ..., p_n is called a permutation if it contains each number from 1 to n exactly once. For example, the following arrays are permutations: [3, 1, 2], [1], [1, 2, 3, 4, 5] and [4, 3, 1, 2]. The following arrays are not permutations: [2], [1, 1], [2, 3, 4].\\n\\nPolycarp invented a really cool permutation p_1, p_2, ..., p_n of length n. It is very disappointing, but he forgot this permutation. He only remembers the array q_1, q_2, ..., q_{n-1} of length n-1, where q_i=p_{i+1}-p_i.\\n\\nGiven n and q=q_1, q_2, ..., q_{n-1}, help Polycarp restore the invented permutation.\\n\\nInput\\n\\nThe first line contains the integer n (2 \u2264 n \u2264 2\u22c510^5) \u2014 the length of the permutation to restore. The second line contains n-1 integers q_1, q_2, ..., q_{n-1} (-n < q_i < n).\\n\\nOutput\\n\\nPrint the integer -1 if there is no such permutation of length n which corresponds to the given array q. Otherwise, if it exists, print p_1, p_2, ..., p_n. Print any such permutation if there are many of them.\\n\\nExamples\\n\\nInput\\n\\n\\n3\\n-2 1\\n\\n\\nOutput\\n\\n\\n3 1 2 \\n\\nInput\\n\\n\\n5\\n1 1 1 1\\n\\n\\nOutput\\n\\n\\n1 2 3 4 5 \\n\\nInput\\n\\n\\n4\\n-1 2 2\\n\\n\\nOutput\\n\\n\\n-1\\nUsing python3 can you solve the prior task?\",\"targets\":\"n=(int)(input())\\nl=list(map(int,input().split()))\\nar=[0]*n\\nr=[0]*n\\nd=0\\nfor i in range(1,n):\\n    d=d+l[i-1]\\n    ar[i]=d\\naar=sorted(ar)\\nk=n-aar[n-1]\\nfor i in range(n):\\n    ar[i]+=k\\nart=sorted(ar)\\nf=True\\nfor i in range(n):\\n    r[i]=i+1\\n    if(r[i]!=art[i]):\\n        f=False\\n        break\\nif(f):\\n    print(*ar,end=' ')\\nelse:\\n    print(-1)\",\"language\":\"python\",\"split\":\"train\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"An integer X is called a Harshad number if X is divisible by f(X), where f(X) is the sum of the digits in X when written in base 10.\\n\\nGiven an integer N, determine whether it is a Harshad number.\\n\\nConstraints\\n\\n* 1?N?10^8\\n* N is an integer.\\n\\nInput\\n\\nInput is given from Standard Input in the following format:\\n\\n\\nN\\n\\n\\nOutput\\n\\nPrint `Yes` if N is a Harshad number; print `No` otherwise.\\n\\nExamples\\n\\nInput\\n\\n12\\n\\n\\nOutput\\n\\nYes\\n\\n\\nInput\\n\\n57\\n\\n\\nOutput\\n\\nNo\\n\\n\\nInput\\n\\n148\\n\\n\\nOutput\\n\\nNo\",\"targets\":\"n=input();print(\\\"YNeos\\\"[int(n)%sum([int(i)for i in n])!=0::2])\",\"language\":\"python\",\"split\":\"train\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"A prime number is a natural number which has exactly two distinct natural number divisors: 1 and itself. For example, the first four prime numbers are: 2, 3, 5 and 7.\\n\\nWrite a program which reads a list of N integers and prints the number of prime numbers in the list.\\n\\nConstraints\\n\\n1 \u2264 N \u2264 10000\\n\\n2 \u2264 an element of the list \u2264 108\\n\\nInput\\n\\nThe first line contains an integer N, the number of elements in the list.\\n\\nN numbers are given in the following lines.\\n\\nOutput\\n\\nPrint the number of prime numbers in the given list.\\n\\nExamples\\n\\nInput\\n\\n5\\n2\\n3\\n4\\n5\\n6\\n\\n\\nOutput\\n\\n3\\n\\n\\nInput\\n\\n11\\n7\\n8\\n9\\n10\\n11\\n12\\n13\\n14\\n15\\n16\\n17\\n\\n\\nOutput\\n\\n4\",\"targets\":\"import math\\n\\ndef isprime(x):\\n\\tif x == 2:\\n\\t\\treturn 1\\n\\tif x <2 or x%2 ==0:\\n\\t\\treturn 0\\n\\ti=3\\n\\twhile i <= math.sqrt(x):\\n\\t\\tif x%i==0:\\n\\t\\t\\treturn 0\\n\\t\\ti+=2\\n\\treturn 1\\n\\t\\nn=int(input())\\nnum=0\\n\\nfor i in range(n):\\n\\tx=int(input())\\n\\tnum+=isprime(x)\\nprint(num)\",\"language\":\"python\",\"split\":\"train\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"<image>\\n\\nWilliam has an array of n integers a_1, a_2, ..., a_n. In one move he can swap two neighboring items. Two items a_i and a_j are considered neighboring if the condition |i - j| = 1 is satisfied.\\n\\nWilliam wants you to calculate the minimal number of swaps he would need to perform to make it so that the array does not contain two neighboring items with the same parity.\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 10^4). Description of the test cases follows.\\n\\nThe first line of each test case contains an integer n (1 \u2264 n \u2264 10^5) which is the total number of items in William's array.\\n\\nThe second line contains n integers a_1, a_2, ..., a_n (1 \u2264 a_i \u2264 10^9) which are William's array.\\n\\nIt is guaranteed that the sum of n over all test cases does not exceed 10^5.\\n\\nOutput\\n\\nFor each test case output the minimal number of operations needed or -1 if it is impossible to get the array to a state when no neighboring numbers have the same parity.\\n\\nExample\\n\\nInput\\n\\n\\n5\\n3\\n6 6 1\\n1\\n9\\n6\\n1 1 1 2 2 2\\n2\\n8 6\\n6\\n6 2 3 4 5 1\\n\\n\\nOutput\\n\\n\\n1\\n0\\n3\\n-1\\n2\\n\\nNote\\n\\nIn the first test case the following sequence of operations would satisfy the requirements: \\n\\n  1. swap(2, 3). Array after performing the operation: [6, 1, 6] \\n\\n\\n\\nIn the second test case the array initially does not contain two neighboring items of the same parity.\\n\\nIn the third test case the following sequence of operations would satisfy the requirements: \\n\\n  1. swap(3, 4). Array after performing the operation: [1, 1, 2, 1, 2, 2] \\n  2. swap(2, 3). Array after performing the operation: [1, 2, 1, 1, 2, 2] \\n  3. swap(4, 5). Array after performing the operation: [1, 2, 1, 2, 1, 2] \\n\\n\\n\\nIn the fourth test case it is impossible to satisfy the requirements.\\n\\nIn the fifth test case the following sequence of operations would satisfy the requirements: \\n\\n  1. swap(2, 3). Array after performing the operation: [6, 3, 2, 4, 5, 1] \\n  2. swap(4, 5). Array after performing the operation: [6, 3, 2, 5, 4, 1] \\\":\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst long long MAXN = 2e5 + 5;\\nlong long a[MAXN];\\nlong long b[MAXN];\\nint main() {\\n  long long t;\\n  cin >> t;\\n  while (t--) {\\n    long long n;\\n    cin >> n;\\n    long long pos = 0;\\n    long long kk1 = 1;\\n    long long kk2 = 2;\\n    long long ans = 0;\\n    long long num1 = 0;\\n    long long num2 = 0;\\n    long long ans1 = 0;\\n    long long ans2 = 0;\\n    for (int i = 1; i <= n; ++i) {\\n      cin >> a[i], num1 += a[i] & 1, num2 += 1 - a[i] & 1;\\n      if (a[i] & 1) {\\n        ans1 += abs(kk1 - i), kk1 += 2;\\n        ans2 += abs(kk2 - i), kk2 += 2;\\n      }\\n    }\\n    if (abs(num1 - num2) > 1) {\\n      cout << -1 << endl;\\n      continue;\\n    }\\n    if (n % 2 == 1) {\\n      if (num1 > num2) {\\n        cout << ans1 << endl;\\n      } else\\n        cout << ans2 << endl;\\n      continue;\\n    }\\n    cout << min(ans1, ans2) << endl;\\n  }\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"A string is called square if it is some string written twice in a row. For example, the strings \\\"aa\\\", \\\"abcabc\\\", \\\"abab\\\" and \\\"baabaa\\\" are square. But the strings \\\"aaa\\\", \\\"abaaab\\\" and \\\"abcdabc\\\" are not square.\\n\\nFor a given string s determine if it is square.\\n\\nInput\\n\\nThe first line of input data contains an integer t (1 \u2264 t \u2264 100) \u2014the number of test cases.\\n\\nThis is followed by t lines, each containing a description of one test case. The given strings consist only of lowercase Latin letters and have lengths between 1 and 100 inclusive.\\n\\nOutput\\n\\nFor each test case, output on a separate line:\\n\\n  * YES if the string in the corresponding test case is square, \\n  * NO otherwise. \\n\\n\\n\\nYou can output YES and NO in any case (for example, strings yEs, yes, Yes and YES will be recognized as a positive response).\\n\\nExample\\n\\nInput\\n\\n\\n10\\na\\naa\\naaa\\naaaa\\nabab\\nabcabc\\nabacaba\\nxxyy\\nxyyx\\nxyxy\\n\\n\\nOutput\\n\\n\\nNO\\nYES\\nNO\\nYES\\nYES\\nYES\\nNO\\nNO\\nNO\\nYES\\n\\n\\/***\",\"targets\":\"**  --->         :)    Vijender  Srivastava      (:       <---       *****\\/\\n\\n\\nimport java.util.*;\\nimport java.lang.*;\\nimport java.io.*;\\npublic class Main\\n{\\n    static FastReader sc =new FastReader();\\n    static PrintWriter out=new PrintWriter(System.out);\\n    static int mod=10000007;\\n    \\/* start *\\/\\n    public static void main(String [] args)throws Exception {\\n        int t = i();\\n        while(t-->0)\\n        {\\n            String s = s();\\n            if(s.length()%2==1)\\n                pl(\\\"NO\\\");\\n            else {\\n                int mid = s.length()\\/2;\\n                String x = s.substring(0,mid);\\n                String y = s.substring(mid);\\n                if(x.equals(y))\\n                    pl(\\\"YES\\\");\\n                else pl(\\\"NO\\\");\\n            }\\n        }\\n\\n        out.close();\\n    }\\n\\n    \\/* end *\\/\\n    static class FastReader\\n    {\\n        BufferedReader br;\\n        StringTokenizer st;\\n\\n        public FastReader()\\n        {\\n            br = new BufferedReader(new\\n                    InputStreamReader(System.in));\\n        }\\n\\n        String next()\\n        {\\n            while (st == null || !st.hasMoreElements())\\n            {\\n                try\\n                {\\n                    st = new StringTokenizer(br.readLine());\\n                }\\n                catch (IOException  e)\\n                {\\n                    e.printStackTrace();\\n                }\\n            }\\n            return st.nextToken();\\n        }\\n\\n        int nextInt()\\n        {\\n            return Integer.parseInt(next());\\n        }\\n\\n        long nextLong()\\n        {\\n            return Long.parseLong(next());\\n        }\\n\\n        double nextDouble()\\n        {\\n            return Double.parseDouble(next());\\n        }\\n\\n        String nextLine()\\n        {\\n            String str = \\\"\\\";\\n            try\\n            {\\n                str = br.readLine();\\n            }\\n            catch (IOException e)\\n            {\\n                e.printStackTrace();\\n            }\\n            return str;\\n        }\\n    }\\n\\n    static void p(Object o)\\n    {\\n       ...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You are given an array of integers a of length n. The elements of the array can be either different or the same. \\n\\nEach element of the array is colored either blue or red. There are no unpainted elements in the array. One of the two operations described below can be applied to an array in a single step:\\n\\n  * either you can select any blue element and decrease its value by 1; \\n  * or you can select any red element and increase its value by 1. \\n\\n\\n\\nSituations in which there are no elements of some color at all are also possible. For example, if the whole array is colored blue or red, one of the operations becomes unavailable.\\n\\nDetermine whether it is possible to make 0 or more steps such that the resulting array is a permutation of numbers from 1 to n?\\n\\nIn other words, check whether there exists a sequence of steps (possibly empty) such that after applying it, the array a contains in some order all numbers from 1 to n (inclusive), each exactly once.\\n\\nInput\\n\\nThe first line contains an integer t (1 \u2264 t \u2264 10^4) \u2014 the number of input data sets in the test.\\n\\nThe description of each set of input data consists of three lines. The first line contains an integer n (1 \u2264 n \u2264 2 \u22c5 10^5) \u2014 the length of the original array a. The second line contains n integers a_1, a_2, ..., a_n (-10^9 \u2264 a_i \u2264 10^9) \u2014 the array elements themselves.\\n\\nThe third line has length n and consists exclusively of the letters 'B' and\\/or 'R': ith character is 'B' if a_i is colored blue, and is 'R' if colored red.\\n\\nIt is guaranteed that the sum of n over all input sets does not exceed 2 \u22c5 10^5.\\n\\nOutput\\n\\nPrint t lines, each of which contains the answer to the corresponding test case of the input. Print YES as an answer if the corresponding array can be transformed into a permutation, and NO otherwise.\\n\\nYou can print the answer in any case (for example, the strings yEs, yes, Yes, and YES will be recognized as a positive answer).\\n\\nExample\\n\\nInput\\n\\n\\n8\\n4\\n1 2 5 2\\nBRBR\\n2\\n1 1\\nBB\\n5\\n3 1 4 2 5\\nRBRRB\\n5\\n3 1 3 1 3\\nRBRRB\\n5\\n5 1 5 1 5\\nRBRRB\\n4\\n2 2 2 2\\nBRBR\\n2\\n1 -2\\nBR\\n4\\n-2...\\nThe above is tricky. Write me a correct solution in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nvoid repeat() {\\n  long long n;\\n  cin >> n;\\n  long long arr[n];\\n  char a[n];\\n  for (long long i = 0; i < n; i++) {\\n    cin >> arr[i];\\n  }\\n  for (long long i = 0; i < n; i++) cin >> a[i];\\n  long long B[n], R[n];\\n  long long b = 0, r = 0;\\n  for (long long i = 0; i < n; i++) {\\n    if (a[i] == 'B') {\\n      B[b] = arr[i];\\n      b++;\\n    } else {\\n      R[r] = arr[i];\\n      r++;\\n    }\\n  }\\n  sort(B, B + b);\\n  sort(R, R + r);\\n  long long p = 1, q = n;\\n  for (long long i = 0; i < b; i++) {\\n    if (B[i] >= p)\\n      p++;\\n    else {\\n      cout << \\\"NO\\\" << endl;\\n      return;\\n    }\\n  }\\n  for (long long i = r - 1; i >= 0; i--) {\\n    if (R[i] <= q)\\n      q--;\\n    else {\\n      cout << \\\"NO\\\" << endl;\\n      return;\\n    }\\n  }\\n  cout << \\\"YES\\\" << endl;\\n}\\nint32_t main() {\\n  ios_base::sync_with_stdio(false);\\n  cin.tie(0);\\n  cout.tie(0);\\n  long long t = 1;\\n  cin >> t;\\n  while (t--) {\\n    repeat();\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in CPP?\\nEzzat has an array of n integers (maybe negative). He wants to split it into two non-empty subsequences a and b, such that every element from the array belongs to exactly one subsequence, and the value of f(a) + f(b) is the maximum possible value, where f(x) is the average of the subsequence x. \\n\\nA sequence x is a subsequence of a sequence y if x can be obtained from y by deletion of several (possibly, zero or all) elements.\\n\\nThe average of a subsequence is the sum of the numbers of this subsequence divided by the size of the subsequence.\\n\\nFor example, the average of [1,5,6] is (1+5+6)\\/3 = 12\\/3 = 4, so f([1,5,6]) = 4.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 10^3)\u2014 the number of test cases. Each test case consists of two lines.\\n\\nThe first line contains a single integer n (2 \u2264 n \u2264 10^5).\\n\\nThe second line contains n integers a_1, a_2, \u2026, a_n (-10^9 \u2264 a_i \u2264 10^9).\\n\\nIt is guaranteed that the sum of n over all test cases does not exceed 3\u22c510^5.\\n\\nOutput\\n\\nFor each test case, print a single value \u2014 the maximum value that Ezzat can achieve.\\n\\nYour answer is considered correct if its absolute or relative error does not exceed 10^{-6}.\\n\\nFormally, let your answer be a, and the jury's answer be b. Your answer is accepted if and only if \\\\frac{|a - b|}{max{(1, |b|)}} \u2264 10^{-6}.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n3\\n3 1 2\\n3\\n-7 -6 -6\\n3\\n2 2 2\\n4\\n17 3 5 -3\\n\\n\\nOutput\\n\\n\\n4.500000000\\n-12.500000000\\n4.000000000\\n18.666666667\\n\\nNote\\n\\nIn the first test case, the array is [3, 1, 2]. These are all the possible ways to split this array: \\n\\n  * a = [3], b = [1,2], so the value of f(a) + f(b) = 3 + 1.5 = 4.5. \\n  * a = [3,1], b = [2], so the value of f(a) + f(b) = 2 + 2 = 4. \\n  * a = [3,2], b = [1], so the value of f(a) + f(b) = 2.5 + 1 = 3.5. \\n\\nTherefore, the maximum possible value 4.5.\\n\\nIn the second test case, the array is [-7, -6, -6]. These are all the possible ways to split this array: \\n\\n  * a = [-7], b = [-6,-6], so the value of f(a) + f(b) = (-7) + (-6) = -13. \\n  * a = [-7,-6], b = [-6], so the value of f(a) + f(b) = (-6.5) + (-6) =...\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst int N = 1e3 + 5;\\nvoid solve() {\\n  int n;\\n  cin >> n;\\n  vector<double> z(n);\\n  for (double &it : z) {\\n    cin >> it;\\n  }\\n  sort(z.begin(), z.end());\\n  double x = 0;\\n  for (int i = 0; i < n - 1; i++) {\\n    x += z[i];\\n  }\\n  double ans = z.back() + (x \\/ ((n - 1) * 1.0));\\n  cout << fixed << setprecision(6) << ans << \\\"\\\\n\\\";\\n}\\nint32_t main() {\\n  ios::sync_with_stdio(false);\\n  cin.tie(nullptr);\\n  cout.tie(nullptr);\\n  int tq = 1;\\n  cin >> tq;\\n  for (; tq; tq--) {\\n    solve();\\n  }\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Some number of people (this number is even) have stood in a circle. The people stand in the circle evenly. They are numbered clockwise starting from a person with the number 1. Each person is looking through the circle's center at the opposite person.\\n\\n<image> A sample of a circle of 6 persons. The orange arrows indicate who is looking at whom.\\n\\nYou don't know the exact number of people standing in the circle (but this number is even, no doubt). It is known that the person with the number a is looking at the person with the number b (and vice versa, of course). What is the number associated with a person being looked at by the person with the number c? If, for the specified a, b, and c, no such circle exists, output -1.\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases. Then t test cases follow.\\n\\nEach test case consists of one line containing three distinct integers a, b, c (1 \u2264 a,b,c \u2264 10^8).\\n\\nOutput\\n\\nFor each test case output in a separate line a single integer d \u2014 the number of the person being looked at by the person with the number c in a circle such that the person with the number a is looking at the person with the number b. If there are multiple solutions, print any of them. Output -1 if there's no circle meeting the given conditions.\\n\\nExample\\n\\nInput\\n\\n\\n7\\n6 2 4\\n2 3 1\\n2 4 10\\n5 3 4\\n1 3 2\\n2 5 4\\n4 3 2\\n\\n\\nOutput\\n\\n\\n8\\n-1\\n-1\\n-1\\n4\\n1\\n-1\\n\\nNote\\n\\nIn the first test case, there's a desired circle of 8 people. The person with the number 6 will look at the person with the number 2 and the person with the number 8 will look at the person with the number 4.\\n\\nIn the second test case, there's no circle meeting the conditions. If the person with the number 2 is looking at the person with the number 3, the circle consists of 2 people because these persons are neighbors. But, in this case, they must have the numbers 1 and 2, but it doesn't meet the problem's conditions.\\n\\nIn the third test case, the only circle with the persons with the numbers 2 and 4 looking at each other consists of 4...\\nUsing python3 can you solve the prior task?\",\"targets\":\"t = int(input())\\n\\nfor i in range(t):\\n    a, b, c = input().split()\\n    a, b, c = int(a), int(b), int(c)\\n    \\n    d = -1\\n    \\n    dif = abs(a-b)\\n    \\n    limit = 2*dif\\n    \\n    \\n    if limit < max(a,b) or c > limit:\\n        print(d)\\n        continue\\n    \\n    elif c + dif <= limit:\\n        d = c+dif\\n        \\n    elif c-dif > 0:\\n        d = c-dif\\n        \\n    print(d)\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"This problem is an extension of the problem \\\"Wonderful Coloring - 1\\\". It has quite many differences, so you should read this statement completely.\\n\\nRecently, Paul and Mary have found a new favorite sequence of integers a_1, a_2, ..., a_n. They want to paint it using pieces of chalk of k colors. The coloring of a sequence is called wonderful if the following conditions are met:\\n\\n  1. each element of the sequence is either painted in one of k colors or isn't painted; \\n  2. each two elements which are painted in the same color are different (i. e. there's no two equal values painted in the same color); \\n  3. let's calculate for each of k colors the number of elements painted in the color \u2014 all calculated numbers must be equal; \\n  4. the total number of painted elements of the sequence is the maximum among all colorings of the sequence which meet the first three conditions. \\n\\n\\n\\nE. g. consider a sequence a=[3, 1, 1, 1, 1, 10, 3, 10, 10, 2] and k=3. One of the wonderful colorings of the sequence is shown in the figure.\\n\\n<image> The example of a wonderful coloring of the sequence a=[3, 1, 1, 1, 1, 10, 3, 10, 10, 2] and k=3. Note that one of the elements isn't painted.\\n\\nHelp Paul and Mary to find a wonderful coloring of a given sequence a.\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 10000) \u2014 the number of test cases. Then t test cases follow.\\n\\nEach test case consists of two lines. The first one contains two integers n and k (1 \u2264 n \u2264 2\u22c510^5, 1 \u2264 k \u2264 n) \u2014 the length of a given sequence and the number of colors, respectively. The second one contains n integers a_1, a_2, ..., a_n (1 \u2264 a_i \u2264 n).\\n\\nIt is guaranteed that the sum of n over all test cases doesn't exceed 2 \u22c5 10^5.\\n\\nOutput\\n\\nOutput t lines, each of them must contain a description of a wonderful coloring for the corresponding test case.\\n\\nEach wonderful coloring must be printed as a sequence of n integers c_1, c_2, ..., c_n (0 \u2264 c_i \u2264 k) separated by spaces where\\n\\n  * c_i=0, if i-th element isn't painted; \\n  * c_i>0, if i-th element is painted in the...\\\":\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nstruct node {\\n  int pos, val;\\n} s[200005];\\nint colored[200005];\\nint cnt[200005];\\nvector<int> color;\\nvector<int> position[200005];\\nvector<int> tocolor;\\nbool cmp(node i, node k) { return i.val < k.val; }\\nint main() {\\n  int t;\\n  scanf(\\\"%d\\\", &t);\\n  while (t--) {\\n    int n, m;\\n    scanf(\\\"%d%d\\\", &n, &m);\\n    color.clear();\\n    tocolor.clear();\\n    memset(colored, 0, sizeof(colored));\\n    for (int i = 0; i < n; i++) {\\n      scanf(\\\"%d\\\", &s[i].val);\\n      s[i].pos = i;\\n    }\\n    sort(s, s + n, cmp);\\n    int cnt1 = 0, cnt2 = 0, num = 0;\\n    position[num].clear();\\n    position[num].push_back(s[0].pos);\\n    color.push_back(s[0].val);\\n    cnt[0] = 1;\\n    for (int i = 1; i < n; i++) {\\n      if (s[i].val == s[i - 1].val)\\n        cnt[num]++;\\n      else {\\n        color.push_back(s[i].val);\\n        if (cnt[num] >= m) {\\n          cnt1++;\\n        } else {\\n          cnt2 += cnt[num];\\n        }\\n        num++;\\n        position[num].clear();\\n        cnt[num] = 1;\\n      }\\n      position[num].push_back(s[i].pos);\\n    }\\n    if (cnt[num] >= m) {\\n      cnt1++;\\n    } else\\n      cnt2 += cnt[num];\\n    for (int i = 0; i < color.size(); i++) {\\n      if (cnt[i] >= m) {\\n        for (int j = 0; j < m; j++) {\\n          colored[position[i][j]] = j + 1;\\n        }\\n      } else {\\n        for (int j = 0; j < position[i].size(); j++) {\\n          tocolor.push_back(position[i][j]);\\n        }\\n      }\\n    }\\n    for (int i = 0; i < tocolor.size() \\/ m; i++) {\\n      for (int j = 0; j < m; j++) {\\n        colored[tocolor[i * m + j]] = j + 1;\\n      }\\n    }\\n    for (int i = 0; i < n; i++) printf(\\\"%d \\\", colored[i]);\\n    printf(\\\"\\\\n\\\");\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"As you may know, MemSQL has American offices in both San Francisco and Seattle. Being a manager in the company, you travel a lot between the two cities, always by plane.\\n\\nYou prefer flying from Seattle to San Francisco than in the other direction, because it's warmer in San Francisco. You are so busy that you don't remember the number of flights you have made in either direction. However, for each of the last n days you know whether you were in San Francisco office or in Seattle office. You always fly at nights, so you never were at both offices on the same day. Given this information, determine if you flew more times from Seattle to San Francisco during the last n days, or not.\\n\\nInput\\n\\nThe first line of input contains single integer n (2 \u2264 n \u2264 100) \u2014 the number of days.\\n\\nThe second line contains a string of length n consisting of only capital 'S' and 'F' letters. If the i-th letter is 'S', then you were in Seattle office on that day. Otherwise you were in San Francisco. The days are given in chronological order, i.e. today is the last day in this sequence.\\n\\nOutput\\n\\nPrint \\\"YES\\\" if you flew more times from Seattle to San Francisco, and \\\"NO\\\" otherwise.\\n\\nYou can print each letter in any case (upper or lower).\\n\\nExamples\\n\\nInput\\n\\n4\\nFSSF\\n\\n\\nOutput\\n\\nNO\\n\\n\\nInput\\n\\n2\\nSF\\n\\n\\nOutput\\n\\nYES\\n\\n\\nInput\\n\\n10\\nFFFFFFFFFF\\n\\n\\nOutput\\n\\nNO\\n\\n\\nInput\\n\\n10\\nSSFFSFFSFF\\n\\n\\nOutput\\n\\nYES\\n\\nNote\\n\\nIn the first example you were initially at San Francisco, then flew to Seattle, were there for two days and returned to San Francisco. You made one flight in each direction, so the answer is \\\"NO\\\".\\n\\nIn the second example you just flew from Seattle to San Francisco, so the answer is \\\"YES\\\".\\n\\nIn the third example you stayed the whole period in San Francisco, so the answer is \\\"NO\\\".\\n\\nIn the fourth example if you replace 'S' with ones, and 'F' with zeros, you'll get the first few digits of \u03c0 in binary representation. Not very useful information though.\\nUsing python3 can you solve the prior task?\",\"targets\":\"n = int(input())\\nm = str(input())\\na = list(m)\\nstof = 0\\nftos = 0\\nfor i in range(0,len(a)-1):\\n    if(a[i] == \\\"F\\\" and a[i+1]==\\\"S\\\"):\\n        ftos +=1\\n    elif(a[i] == \\\"S\\\" and a[i+1]==\\\"F\\\"):\\n        stof +=1\\nif(stof>ftos):\\n    print(\\\"YES\\\")\\nelse:\\n    print(\\\"NO\\\")\",\"language\":\"python\",\"split\":\"train\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Ashish has n elements arranged in a line. \\n\\nThese elements are represented by two integers a_i \u2014 the value of the element and b_i \u2014 the type of the element (there are only two possible types: 0 and 1). He wants to sort the elements in non-decreasing values of a_i.\\n\\nHe can perform the following operation any number of times: \\n\\n  * Select any two elements i and j such that b_i \u2260 b_j and swap them. That is, he can only swap two elements of different types in one move. \\n\\n\\n\\nTell him if he can sort the elements in non-decreasing values of a_i after performing any number of operations.\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 100) \u2014 the number of test cases. The description of the test cases follows.\\n\\nThe first line of each test case contains one integer n (1 \u2264 n \u2264 500) \u2014 the size of the arrays.\\n\\nThe second line contains n integers a_i (1 \u2264 a_i \u2264 10^5) \u2014 the value of the i-th element.\\n\\nThe third line containts n integers b_i (b_i \u2208 \\\\{0, 1\\\\}) \u2014 the type of the i-th element.\\n\\nOutput\\n\\nFor each test case, print \\\"Yes\\\" or \\\"No\\\" (without quotes) depending on whether it is possible to sort elements in non-decreasing order of their value.\\n\\nYou may print each letter in any case (upper or lower).\\n\\nExample\\n\\nInput\\n\\n\\n5\\n4\\n10 20 20 30\\n0 1 0 1\\n3\\n3 1 2\\n0 1 1\\n4\\n2 2 4 8\\n1 1 1 1\\n3\\n5 15 4\\n0 0 0\\n4\\n20 10 100 50\\n1 0 0 1\\n\\n\\nOutput\\n\\n\\nYes\\nYes\\nYes\\nNo\\nYes\\n\\nNote\\n\\nFor the first case: The elements are already in sorted order.\\n\\nFor the second case: Ashish may first swap elements at positions 1 and 2, then swap elements at positions 2 and 3.\\n\\nFor the third case: The elements are already in sorted order.\\n\\nFor the fourth case: No swap operations may be performed as there is no pair of elements i and j such that b_i \u2260 b_j. The elements cannot be sorted.\\n\\nFor the fifth case: Ashish may swap elements at positions 3 and 4, then elements at positions 1 and 2.\\nt = i\",\"targets\":\"nt(input())\\nwhile t:\\n    t-=1\\n    n = int(input())\\n    a = list(map(int, input().split()))\\n    b = list(map(int, input().split()))\\n    if sum(b) == n:\\n        if sorted(a) == a:\\n            print(\\\"Yes\\\")\\n        else:\\n            print(\\\"No\\\")\\n    elif sum(b) == 0:\\n        if sorted(a) == a:\\n            print(\\\"Yes\\\")\\n        else:\\n            print(\\\"No\\\")\\n    elif sum(b) >= 1:\\n        print(\\\"Yes\\\")\\n    else:\\n        print(\\\"No\\\")\",\"language\":\"python\",\"split\":\"train\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"A decimal representation of an integer can be transformed to another integer by rearranging the order of digits. Let us make a sequence using this fact.\\n\\nA non-negative integer a0 and the number of digits L are given first. Applying the following rules, we obtain ai+1 from ai.\\n\\n1. Express the integer ai in decimal notation with L digits. Leading zeros are added if necessary. For example, the decimal notation with six digits of the number 2012 is 002012.\\n2. Rearranging the digits, find the largest possible integer and the smallest possible integer; In the example above, the largest possible integer is 221000 and the smallest is 000122 = 122.\\n3. A new integer ai+1 is obtained by subtracting the smallest possible integer from the largest. In the example above, we obtain 220878 subtracting 122 from 221000.\\n\\n\\n\\nWhen you repeat this calculation, you will get a sequence of integers a0 , a1 , a2 , ... .\\n\\nFor example, starting with the integer 83268 and with the number of digits 6, you will get the following sequence of integers a0 , a1 , a2 , ... .\\n\\n> a0 = 083268\\n>  a1 = 886320 \u2212 023688 = 862632\\n>  a2 = 866322 \u2212 223668 = 642654\\n>  a3 = 665442 \u2212 244566 = 420876\\n>  a4 = 876420 \u2212 024678 = 851742\\n>  a5 = 875421 \u2212 124578 = 750843\\n>  a6 = 875430 \u2212 034578 = 840852\\n>  a7 = 885420 \u2212 024588 = 860832\\n>  a8 = 886320 \u2212 023688 = 862632\\n>     \u2026\\n>\\n\\nBecause the number of digits to express integers is fixed, you will encounter occurrences of the same integer in the sequence a0 , a1 , a2 , ... eventually. Therefore you can always find a pair of i  and j  that satisfies the condition ai = aj   (i  > j  ). In the example above, the pair (i = 8, j = 1) satisfies the condition because a8 = a1 = 862632.\\n\\nWrite a program that, given an initial integer a0 and a number of digits L, finds the smallest i that satisfies the condition ai = aj   (i  > j  ).\\n\\nInput\\n\\nThe input consists of multiple datasets. A dataset is a line containing two integers a0  and L  separated by a space. a0  and L  represent the initial integer of the sequence and the...\\nUsing cpp can you solve the prior task?\",\"targets\":\"#include <iostream>\\n#include <algorithm>\\n#include <vector>\\n#include <set>\\n#include <math.h>\\n#include <map>\\n#include <numeric>\\nusing namespace std;\\ntypedef long long int ll;\\n\\nint main(){\\n\\tcin.tie(nullptr);\\n\\tios::sync_with_stdio(false);\\n    while(1){\\n        int a,b,l; cin >> a >> l;\\n        if(a==0&&l==0)break;\\n        map<int,int> mp;\\n        mp[a]=1;\\n        int num=2;\\n        string s,t;\\n        s=to_string(a);\\n        while(1){\\n            while(s.size()<l)s+='0';\\n            t=s;\\n            sort(t.begin(),t.end());\\n            b=stoi(t);\\n            reverse(t.begin(),t.end());\\n            a=stoi(t);\\n            if(mp[a-b]!=0){\\n                cout << mp[a-b]-1 << \\\" \\\" << a-b << \\\" \\\" << num-mp[a-b] << endl;\\n                break;\\n            }\\n            mp[a-b]=num;\\n            num++;\\n            s=to_string(a-b);\\n        }\\n    }\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in CPP?\\nAlice has an integer sequence a of length n and all elements are different. She will choose a subsequence of a of length m, and defines the value of a subsequence a_{b_1},a_{b_2},\u2026,a_{b_m} as $$$\u2211_{i = 1}^m (m \u22c5 a_{b_i}) - \u2211_{i = 1}^m \u2211_{j = 1}^m f(min(b_i, b_j), max(b_i, b_j)), where f(i, j) denotes \\\\min(a_i, a_{i + 1}, \\\\ldots, a_j)$$$.\\n\\nAlice wants you to help her to maximize the value of the subsequence she choose.\\n\\nA sequence s is a subsequence of a sequence t if s can be obtained from t by deletion of several (possibly, zero or all) elements.\\n\\nInput\\n\\nThe first line contains two integers n and m (1 \u2264 m \u2264 n \u2264 4000).\\n\\nThe second line contains n distinct integers a_1, a_2, \u2026, a_n (1 \u2264 a_i < 2^{31}).\\n\\nOutput\\n\\nPrint the maximal value Alice can get.\\n\\nExamples\\n\\nInput\\n\\n\\n6 4\\n15 2 18 12 13 4\\n\\n\\nOutput\\n\\n\\n100\\n\\n\\nInput\\n\\n\\n11 5\\n9 3 7 1 8 12 10 20 15 18 5\\n\\n\\nOutput\\n\\n\\n176\\n\\n\\nInput\\n\\n\\n1 1\\n114514\\n\\n\\nOutput\\n\\n\\n0\\n\\n\\nInput\\n\\n\\n2 1\\n666 888\\n\\n\\nOutput\\n\\n\\n0\\n\\nNote\\n\\nIn the first example, Alice can choose the subsequence [15, 2, 18, 13], which has the value 4 \u22c5 (15 + 2 + 18 + 13) - (15 + 2 + 2 + 2) - (2 + 2 + 2 + 2) - (2 + 2 + 18 + 12) - (2 + 2 + 12 + 13) = 100. In the second example, there are a variety of subsequences with value 176, and one of them is [9, 7, 12, 20, 18].\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint a[4010], n, m, sta[4010], top, s[4010][2], sz[4010];\\nlong long dp[4010][4010];\\nvoid DP(int x) {\\n  sz[x] = 1;\\n  for (int i = 0; i < 2; i++) {\\n    if (s[x][i]) {\\n      DP(s[x][i]);\\n      for (int t = min(m, sz[x]); t >= 0; t--)\\n        for (int j = min(sz[s[x][i]], m); j >= 1; j--)\\n          dp[x][t + j] = max(dp[x][t] + dp[s[x][i]][j] +\\n                                 1ll * (a[s[x][i]] - a[x]) * j * (m - j),\\n                             dp[x][t + j]);\\n      sz[x] += sz[s[x][i]];\\n    }\\n  }\\n  return;\\n}\\nint main() {\\n  scanf(\\\"%d%d\\\", &n, &m);\\n  for (int i = 1; i <= n; i++) scanf(\\\"%d\\\", &a[i]);\\n  for (int i = 1; i <= n; i++) {\\n    while (top && a[sta[top]] > a[i]) s[i][0] = sta[top--];\\n    if (top) s[sta[top]][1] = i;\\n    sta[++top] = i;\\n  }\\n  int rt = 0;\\n  for (int i = 1; i <= n; i++)\\n    if (!rt || a[i] < a[rt]) rt = i;\\n  DP(rt);\\n  printf(\\\"%lld\\\\n\\\", dp[rt][m]);\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in JAVA?\\nYou are given a digital clock with n digits. Each digit shows an integer from 0 to 9, so the whole clock shows an integer from 0 to 10^n-1. The clock will show leading zeroes if the number is smaller than 10^{n-1}.\\n\\nYou want the clock to show 0 with as few operations as possible. In an operation, you can do one of the following: \\n\\n  * decrease the number on the clock by 1, or \\n  * swap two digits (you can choose which digits to swap, and they don't have to be adjacent). \\n\\n\\n\\nYour task is to determine the minimum number of operations needed to make the clock show 0.\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 10^3).\\n\\nThe first line of each test case contains a single integer n (1 \u2264 n \u2264 100) \u2014 number of digits on the clock.\\n\\nThe second line of each test case contains a string of n digits s_1, s_2, \u2026, s_n (0 \u2264 s_1, s_2, \u2026, s_n \u2264 9) \u2014 the number on the clock.\\n\\nNote: If the number is smaller than 10^{n-1} the clock will show leading zeroes.\\n\\nOutput\\n\\nFor each test case, print one integer: the minimum number of operations needed to make the clock show 0.\\n\\nExample\\n\\nInput\\n\\n\\n7\\n3\\n007\\n4\\n1000\\n5\\n00000\\n3\\n103\\n4\\n2020\\n9\\n123456789\\n30\\n001678294039710047203946100020\\n\\n\\nOutput\\n\\n\\n7\\n2\\n0\\n5\\n6\\n53\\n115\\n\\nNote\\n\\nIn the first example, it's optimal to just decrease the number 7 times.\\n\\nIn the second example, we can first swap the first and last position and then decrease the number by 1.\\n\\nIn the third example, the clock already shows 0, so we don't have to perform any operations.\",\"targets\":\"import java.io.*;\\nimport java.util.*;\\n\\npublic class Main {\\n\\tstatic BufferedReader br = new BufferedReader(new InputStreamReader(System.in));\\n\\tstatic BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));\\n\\n\\tpublic static void main(String[] args) throws IOException {\\n\\n\\t\\tint T = Integer.parseInt(br.readLine());\\n\\t\\twhile(T-- > 0) {\\n\\t\\t\\tint n = Integer.parseInt(br.readLine());\\n\\t\\t\\tString input = br.readLine();\\n\\t\\t\\tint ans = 0;\\n\\t\\t\\tfor(int i = 0; i<n; i++) {\\n\\t\\t\\t\\tif(input.charAt(i) - '0' != 0) {\\n\\t\\t\\t\\t\\tif(i == n - 1) {\\n\\t\\t\\t\\t\\t\\tans += input.charAt(i) - '0';\\n\\t\\t\\t\\t\\t\\tbreak;\\n\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\t\\tans++;\\n\\t\\t\\t\\t\\tans += input.charAt(i) - '0';\\n\\t\\t\\t\\t}\\n\\t\\t\\t}\\n\\t\\t\\t\\n\\t\\t\\t\\/\\/ 0\uc774 \uc544\ub2cc \uc218\uc758 \ud569 + 0\uc774 \uc544\ub2cc \uc218\uc758 \uce78\uc218\uc758 \ud569\\n\\t\\t\\tbw.write(ans+\\\"\\\\n\\\");\\n\\t\\t\\t\\n\\t\\t}\\n\\t\\tbw.flush();\\n\\t}\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Depth-first search (DFS) follows the strategy to search \u201ddeeper\u201d in the graph whenever possible. In DFS, edges are recursively explored out of the most recently discovered vertex $v$ that still has unexplored edges leaving it. When all of $v$'s edges have been explored, the search \u201dbacktracks\u201d to explore edges leaving the vertex from which $v$ was discovered.\\n\\nThis process continues until all the vertices that are reachable from the original source vertex have been discovered. If any undiscovered vertices remain, then one of them is selected as a new source and the search is repeated from that source.\\n\\nDFS timestamps each vertex as follows:\\n\\n* $d[v]$ records when $v$ is first discovered.\\n* $f[v]$ records when the search finishes examining $v$\u2019s adjacency list.\\n\\n\\n\\nWrite a program which reads a directed graph $G = (V, E)$ and demonstrates DFS on the graph based on the following rules:\\n\\n* $G$ is given in an adjacency-list. Vertices are identified by IDs $1, 2,... n$ respectively.\\n* IDs in the adjacency list are arranged in ascending order.\\n* The program should report the discover time and the finish time for each vertex.\\n* When there are several candidates to visit during DFS, the algorithm should select the vertex with the smallest ID.\\n* The timestamp starts with 1.\\n\\nConstraints\\n\\n* $1 \\\\leq n \\\\leq 100$\\n\\nInput\\n\\nIn the first line, an integer $n$ denoting the number of vertices of $G$ is given. In the next $n$ lines, adjacency lists of $u$ are given in the following format:\\n\\n$u$ $k$ $v_1$ $v_2$ ... $v_k$\\n\\n$u$ is ID of the vertex and $k$ denotes its degree. $v_i$ are IDs of vertices adjacent to $u$.\\n\\nOutput\\n\\nFor each vertex, print $id$, $d$ and $f$ separated by a space character in a line. $id$ is ID of the vertex, $d$ and $f$ is the discover time and the finish time respectively. Print in order of vertex IDs.\\n\\nExamples\\n\\nInput\\n\\n4\\n1 1 2\\n2 1 4\\n3 0\\n4 1 3\\n\\n\\nOutput\\n\\n1 1 8\\n2 2 7\\n3 4 5\\n4 3 6\\n\\n\\nInput\\n\\n6\\n1 2 2 3\\n2 2 3 4\\n3 1 5\\n4 1 6\\n5 1 6\\n6 0\\n\\n\\nOutput\\n\\n1 1 12\\n2 2 11\\n3 3 8\\n4 9 10\\n5 4 7\\n6 5 6\\n#incl\",\"targets\":\"ude <bits\\/stdc++.h>\\n\\nusing namespace std;\\ntypedef pair<int, int> P;\\n\\nint n, u, k, v, t = 0, G[110][110], used[110];\\nP p[110];\\n\\nvoid dfs(int u) {\\n    used[u] = 1;\\n    p[u].first = ++t;\\n    for (int i = 1; i <= n; i++) {\\n        if (!G[u][i] || used[i]) continue;\\n        used[i] = 1;\\n        dfs(i);\\n    }\\n    p[u].second = ++t;\\n}\\n\\nint main(void) {\\n    cin >> n;\\n    for (int i = 0; i < n; i++) {\\n        cin >> u >> k;\\n        for (int j = 0; j < k; j++) {\\n            cin >> v;\\n            G[u][v] = 1;\\n        }\\n    }\\n\\n    for (int i = 1; i <= n; i++) {\\n        if (used[i]) continue;\\n        dfs(i);\\n    }\\n\\n    for (int i = 1; i <= n; i++)\\n        cout << i << \\\" \\\" << p[i].first << \\\" \\\" << p[i].second << endl;\\n\\n    return 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Draw a frame which has a height of H cm and a width of W cm. For example, the following figure shows a frame which has a height of 6 cm and a width of 10 cm.\\n\\n\\n\\n........#\\n........#\\n........#\\n........#\\n\\n\\n\\nConstraints\\n\\n* 3 \u2264 H \u2264 300\\n* 3 \u2264 W \u2264 300\\n\\nInput\\n\\nThe input consists of multiple datasets. Each dataset consists of two integers H and W separated by a single space.\\n\\nThe input ends with two 0 (when both H and W are zero).\\n\\nOutput\\n\\nFor each dataset, print the frame made of '#' and '.'.\\n\\nPrint a blank line after each dataset.\\n\\nExample\\n\\nInput\\n\\n3 4\\n5 6\\n3 3\\n0 0\\n\\n\\nOutput\\n\\n####\\n#..#\\n####\\n\\n######\\n#....#\\n#....#\\n#....#\\n######\\n\\n###\\n#.#\\n###\\nUsing python3 can you solve the prior task?\",\"targets\":\"while True:\\n    h, w = map(int, input().split())\\n    if (h, w) == (0, 0):\\n        break\\n    print('#' * w)\\n    for i in range(h - 2):\\n        print('#' + '.' * (w - 2) + '#')\\n    print('#' * w + '\\\\n')\",\"language\":\"python\",\"split\":\"train\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"There are three sticks with integer lengths l_1, l_2 and l_3.\\n\\nYou are asked to break exactly one of them into two pieces in such a way that: \\n\\n  * both pieces have positive (strictly greater than 0) integer length; \\n  * the total length of the pieces is equal to the original length of the stick; \\n  * it's possible to construct a rectangle from the resulting four sticks such that each stick is used as exactly one of its sides. \\n\\n\\n\\nA square is also considered a rectangle.\\n\\nDetermine if it's possible to do that.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 10^4) \u2014 the number of testcases.\\n\\nThe only line of each testcase contains three integers l_1, l_2, l_3 (1 \u2264 l_i \u2264 10^8) \u2014 the lengths of the sticks.\\n\\nOutput\\n\\nFor each testcase, print \\\"YES\\\" if it's possible to break one of the sticks into two pieces with positive integer length in such a way that it's possible to construct a rectangle from the resulting four sticks. Otherwise, print \\\"NO\\\".\\n\\nYou may print every letter in any case you want (so, for example, the strings yEs, yes, Yes and YES are all recognized as a positive answer).\\n\\nExample\\n\\nInput\\n\\n\\n4\\n6 1 5\\n2 5 2\\n2 4 2\\n5 5 4\\n\\n\\nOutput\\n\\n\\nYES\\nNO\\nYES\\nYES\\n\\nNote\\n\\nIn the first testcase, the first stick can be broken into parts of length 1 and 5. We can construct a rectangle with opposite sides of length 1 and 5.\\n\\nIn the second testcase, breaking the stick of length 2 can only result in sticks of lengths 1, 1, 2, 5, which can't be made into a rectangle. Breaking the stick of length 5 can produce results 2, 3 or 1, 4 but neither of them can't be put into a rectangle.\\n\\nIn the third testcase, the second stick can be broken into parts of length 2 and 2. The resulting rectangle has opposite sides 2 and 2 (which is a square).\\n\\nIn the fourth testcase, the third stick can be broken into parts of length 2 and 2. The resulting rectangle has opposite sides 2 and 5.\\nThe above is tricky. Write me a correct solution in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst long long INF = 1e9 + 7;\\nvoid solve() {\\n  int a, b, c;\\n  cin >> a >> b >> c;\\n  if (a == b) {\\n    if (c % 2 == 0)\\n      cout << \\\"YES\\\\n\\\";\\n    else\\n      cout << \\\"NO\\\\n\\\";\\n  } else if (a == c) {\\n    if (b % 2 == 0)\\n      cout << \\\"YES\\\\n\\\";\\n    else\\n      cout << \\\"NO\\\\n\\\";\\n  } else if (b == c) {\\n    if (a % 2 == 0)\\n      cout << \\\"YES\\\\n\\\";\\n    else\\n      cout << \\\"NO\\\\n\\\";\\n  } else {\\n    int arr[3];\\n    arr[0] = a, arr[1] = b, arr[2] = c;\\n    sort(arr, arr + 3);\\n    if (arr[2] - arr[1] == arr[0])\\n      cout << \\\"YES\\\\n\\\";\\n    else if (arr[2] - arr[0] == arr[1])\\n      cout << \\\"YES\\\\n\\\";\\n    else\\n      cout << \\\"NO\\\\n\\\";\\n  }\\n}\\nint main() {\\n  ios::sync_with_stdio(false);\\n  cin.tie(nullptr);\\n  cout.tie(nullptr);\\n  int t;\\n  cin >> t;\\n  while (t--) solve();\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in PYTHON?\\nIt is a simplified version of problem F2. The difference between them is the constraints (F1: k \u2264 2, F2: k \u2264 10).\\n\\nYou are given an integer n. Find the minimum integer x such that x \u2265 n and the number x is k-beautiful.\\n\\nA number is called k-beautiful if its decimal representation having no leading zeroes contains no more than k different digits. E.g. if k = 2, the numbers 3434443, 55550, 777 and 21 are k-beautiful whereas the numbers 120, 445435 and 998244353 are not.\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases. Then t test cases follow.\\n\\nEach test case consists of one line containing two integers n and k (1 \u2264 n \u2264 10^9, 1 \u2264 k \u2264 2).\\n\\nOutput\\n\\nFor each test case output on a separate line x \u2014 the minimum k-beautiful integer such that x \u2265 n.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n1 1\\n221 2\\n177890 2\\n998244353 1\\n\\n\\nOutput\\n\\n\\n1\\n221\\n181111\\n999999999\",\"targets\":\"\\\"\\\"\\\"\\n\\/\\/ Author : snape_here - Susanta Mukherjee\\n     \\n \\\"\\\"\\\"\\n\\nfrom __future__ import division, print_function\\n \\nimport os,sys\\nfrom io import BytesIO, IOBase\\n \\nif sys.version_info[0] < 3:\\n    from __builtin__ import xrange as range\\n    from future_builtins import ascii, filter, hex, map, oct, zip\\n \\ndef ii(): return int(input())\\ndef fi(): return float(input())\\ndef si(): return input()\\ndef msi(): return map(str,input().split())\\ndef mi(): return map(int,input().split())\\ndef li(): return list(mi())\\ndef lsi(): return list(msi())\\n \\ndef read():\\n    sys.stdin = open('input.txt', 'r')  \\n    sys.stdout = open('output.txt', 'w') \\n \\ndef gcd(x, y):\\n    while y:\\n        x, y = y, x % y\\n    return x\\n\\ndef lcm(x, y):\\n    return (x*y)\\/\\/(gcd(x,y))\\n\\nmod=1000000007\\n\\ndef modInverse(b,m): \\n    g = gcd(b, m)  \\n    if (g != 1):         \\n        return -1\\n    else:          \\n        return pow(b, m - 2, m) \\n\\ndef ceil2(x,y):\\n    if x%y==0:\\n        return x\\/\\/y\\n    else:\\n        return x\\/\\/y+1\\n\\ndef modu(a,b,m): \\n\\n    a = a % m \\n    inv = modInverse(b,m) \\n    if(inv == -1): \\n        return -999999999\\n    else: \\n        return (inv*a)%m\\n\\nfrom math import log,factorial,cos,tan,sin,radians,floor,sqrt,ceil\\n\\nimport bisect\\nimport random\\nimport string \\nimport itertools\\n\\nfrom decimal import *\\n\\ngetcontext().prec = 50\\n\\nabc=\\\"abcdefghijklmnopqrstuvwxyz\\\"\\n\\npi=3.141592653589793238\\n\\ndef gcd1(a):\\n    if len(a) == 1:\\n        return a[0]\\n    ans = a[0]\\n    for i in range(1,len(a)):\\n        ans = gcd(ans,a[i])\\n    return ans\\n\\ndef mykey(x):\\n    return len(x)\\n\\ndef check(y,n,k):\\n    ln = len(set(y))\\n    if int(y)>=n and ln<=k:\\n        return True \\n    return False\\n\\nst = set()\\n\\n#taken from GFG:- https:\\/\\/www.geeksforgeeks.org\\/print-all-numbers-less-than-n-with-at-most-2-unique-digits\\/\\n# Function to generate all possible numbers\\ndef generateNumbers(n, num, a, b):\\n     \\n    # If the number is less than n\\n    if (num > 0 and num < n):\\n        st.add(num)\\n \\n    # If the number exceeds\\n    if (num >= n):\\n        return\\n \\n    # Check if it is not the same number\\n    if (num...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"Over time, Alexey's mail box got littered with too many letters. Some of them are read, while others are unread.\\n\\nAlexey's mail program can either show a list of all letters or show the content of a single letter. As soon as the program shows the content of an unread letter, it becomes read letter (if the program shows the content of a read letter nothing happens). In one click he can do any of the following operations:\\n\\n  * Move from the list of letters to the content of any single letter.\\n  * Return to the list of letters from single letter viewing mode.\\n  * In single letter viewing mode, move to the next or to the previous letter in the list. You cannot move from the first letter to the previous one or from the last letter to the next one.\\n\\n\\n\\nThe program cannot delete the letters from the list or rearrange them.\\n\\nAlexey wants to read all the unread letters and go watch football. Now he is viewing the list of all letters and for each letter he can see if it is read or unread. What minimum number of operations does Alexey need to perform to read all unread letters?\\n\\nInput\\n\\nThe first line contains a single integer n (1 \u2264 n \u2264 1000) \u2014 the number of letters in the mailbox.\\n\\nThe second line contains n space-separated integers (zeros and ones) \u2014 the state of the letter list. The i-th number equals either 1, if the i-th number is unread, or 0, if the i-th letter is read.\\n\\nOutput\\n\\nPrint a single number \u2014 the minimum number of operations needed to make all the letters read.\\n\\nExamples\\n\\nInput\\n\\n5\\n0 1 0 1 0\\n\\n\\nOutput\\n\\n3\\n\\n\\nInput\\n\\n5\\n1 1 0 0 1\\n\\n\\nOutput\\n\\n4\\n\\n\\nInput\\n\\n2\\n0 0\\n\\n\\nOutput\\n\\n0\\n\\nNote\\n\\nIn the first sample Alexey needs three operations to cope with the task: open the second letter, move to the third one, move to the fourth one.\\n\\nIn the second sample the action plan: open the first letter, move to the second letter, return to the list, open the fifth letter.\\n\\nIn the third sample all letters are already read.\\\":\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nlong long a[1000000], b[1000000], c[1000000], n, m, t,\\n    flag = 0, flag2 = 0, cnt = 0, cnt1 = 0, ans = 0;\\nstring s, s1, s2;\\nint main() {\\n  cin >> n;\\n  vector<int> v;\\n  for (int i = 0; i < n; i++) {\\n    cin >> m;\\n    if (m) v.push_back(i);\\n  }\\n  int sz = v.size();\\n  if (sz) ans = 1;\\n  for (int i = 0; i < sz - 1; i++) {\\n    if (v[i + 1] - v[i] == 1)\\n      ans++;\\n    else\\n      ans += 2;\\n  }\\n  cout << ans;\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"A telephone number is a sequence of exactly 11 digits such that its first digit is 8.\\n\\nVasya and Petya are playing a game. Initially they have a string s of length n (n is odd) consisting of digits. Vasya makes the first move, then players alternate turns. In one move the player must choose a character and erase it from the current string. For example, if the current string 1121, after the player's move it may be 112, 111 or 121. The game ends when the length of string s becomes 11. If the resulting string is a telephone number, Vasya wins, otherwise Petya wins.\\n\\nYou have to determine if Vasya has a winning strategy (that is, if Vasya can win the game no matter which characters Petya chooses during his moves).\\n\\nInput\\n\\nThe first line contains one integer n (13 \u2264 n < 10^5, n is odd) \u2014 the length of string s.\\n\\nThe second line contains the string s (|s| = n) consisting only of decimal digits.\\n\\nOutput\\n\\nIf Vasya has a strategy that guarantees him victory, print YES.\\n\\nOtherwise print NO.\\n\\nExamples\\n\\nInput\\n\\n\\n13\\n8380011223344\\n\\n\\nOutput\\n\\n\\nYES\\n\\n\\nInput\\n\\n\\n15\\n807345619350641\\n\\n\\nOutput\\n\\n\\nNO\\n\\nNote\\n\\nIn the first example Vasya needs to erase the second character. Then Petya cannot erase a character from the remaining string 880011223344 so that it does not become a telephone number.\\n\\nIn the second example after Vasya's turn Petya can erase one character character 8. The resulting string can't be a telephone number, because there is no digit 8 at all.\\nimpor\",\"targets\":\"t java.io.*;\\nimport java.io.PrintStream;\\nimport java.util.*;\\n\\n\\npublic class Main{\\n\\n    Scanner in = new Scanner(System.in);\\n    PrintStream out = new PrintStream(System.out);\\n    int n;\\n    String s;\\n\\n\\n    public void main() {\\n        n = in.nextInt();\\n        s = in.next();\\n        boolean f = true;\\n        int count = 0;\\n        for(int i = 0; i < n; ++i) {\\n            if (n - i >= 11 && s.charAt(i) == '8') count++;\\n        }\\n        int v = (n - 11);\\n        int p = v\\/2;\\n        v = v - p;\\n        String ans = \\\"YES\\\";\\n        if (count <= p) ans = \\\"NO\\\";\\n        out.print(ans);\\n    }\\n\\n\\n    public static void main(String[] $) throws IOException {\\n        new Main().main();\\n    }\\n\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"Polycarp has found a table having an infinite number of rows and columns. The rows are numbered from 1, starting from the topmost one. The columns are numbered from 1, starting from the leftmost one.\\n\\nInitially, the table hasn't been filled and Polycarp wants to fix it. He writes integers from 1 and so on to the table as follows.\\n\\n<image> The figure shows the placement of the numbers from 1 to 10. The following actions are denoted by the arrows.\\n\\nThe leftmost topmost cell of the table is filled with the number 1. Then he writes in the table all positive integers beginning from 2 sequentially using the following algorithm.\\n\\nFirst, Polycarp selects the leftmost non-filled cell in the first row and fills it. Then, while the left neighbor of the last filled cell is filled, he goes down and fills the next cell. So he goes down until the last filled cell has a non-filled neighbor to the left (look at the vertical arrow going down in the figure above).\\n\\nAfter that, he fills the cells from the right to the left until he stops at the first column (look at the horizontal row in the figure above). Then Polycarp selects the leftmost non-filled cell in the first row, goes down, and so on.\\n\\nA friend of Polycarp has a favorite number k. He wants to know which cell will contain the number. Help him to find the indices of the row and the column, such that the intersection of the row and the column is the cell containing the number k.\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 100) \u2014 the number of test cases. Then t test cases follow.\\n\\nEach test case consists of one line containing one integer k (1 \u2264 k \u2264 10^9) which location must be found.\\n\\nOutput\\n\\nFor each test case, output in a separate line two integers r and c (r, c \u2265 1) separated by spaces \u2014 the indices of the row and the column containing the cell filled by the number k, respectively.\\n\\nExample\\n\\nInput\\n\\n\\n7\\n11\\n14\\n5\\n4\\n1\\n2\\n1000000000\\n\\n\\nOutput\\n\\n\\n2 4\\n4 3\\n1 3\\n2 1\\n1 1\\n1 2\\n31623 14130\\\":\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nvoid solve() {\\n  int n;\\n  cin >> n;\\n  double c = sqrt(n);\\n  if (floor(c) == ceil(c)) {\\n    cout << c << \\\" \\\" << 1 << \\\"\\\\n\\\";\\n    return;\\n  }\\n  int a = c;\\n  long long p = pow(a + 1, 2);\\n  if (p - n > a) {\\n    cout << n - pow(a, 2) << \\\" \\\" << a + 1 << \\\"\\\\n\\\";\\n    return;\\n  }\\n  cout << a + 1 << \\\" \\\" << p - n + 1 << \\\"\\\\n\\\";\\n  return;\\n}\\nint main() {\\n  int t;\\n  cin >> t;\\n  while (t--) solve();\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Polycarp had an array a of 3 positive integers. He wrote out the sums of all non-empty subsequences of this array, sorted them in non-decreasing order, and got an array b of 7 integers.\\n\\nFor example, if a = \\\\{1, 4, 3\\\\}, then Polycarp wrote out 1, 4, 3, 1 + 4 = 5, 1 + 3 = 4, 4 + 3 = 7, 1 + 4 + 3 = 8. After sorting, he got an array b = \\\\{1, 3, 4, 4, 5, 7, 8\\\\}.\\n\\nUnfortunately, Polycarp lost the array a. He only has the array b left. Help him to restore the array a.\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 5000) \u2014 the number of test cases.\\n\\nEach test case consists of one line which contains 7 integers b_1, b_2, ..., b_7 (1 \u2264 b_i \u2264 10^9; b_i \u2264 b_{i+1}). \\n\\nAdditional constraint on the input: there exists at least one array a which yields this array b as described in the statement.\\n\\nOutput\\n\\nFor each test case, print 3 integers \u2014 a_1, a_2 and a_3. If there can be several answers, print any of them.\\n\\nExample\\n\\nInput\\n\\n\\n5\\n1 3 4 4 5 7 8\\n1 2 3 4 5 6 7\\n300000000 300000000 300000000 600000000 600000000 600000000 900000000\\n1 1 2 999999998 999999999 999999999 1000000000\\n1 2 2 3 3 4 5\\n\\n\\nOutput\\n\\n\\n1 4 3\\n4 1 2\\n300000000 300000000 300000000\\n999999998 1 1\\n1 2 2\\n\\nNote\\n\\nThe subsequence of the array a is a sequence that can be obtained from a by removing zero or more of its elements.\\n\\nTwo subsequences are considered different if index sets of elements included in them are different. That is, the values of the elements don't matter in the comparison of subsequences. In particular, any array of length 3 has exactly 7 different non-empty subsequences.\\nUsing cpp can you solve the prior task?\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint main() {\\n  int a[8], t;\\n  long long c;\\n  cin >> t;\\n  while (t--) {\\n    bool f = 1;\\n    for (int i = 0; i < 7; i++) {\\n      cin >> a[i];\\n    }\\n    for (int i = 0; i < 7; i++) {\\n      for (int j = 0; j < 7; j++) {\\n        for (int k = 0; k < 7; k++) {\\n          if ((a[i] + a[j] + a[k]) == a[6] && i != j && i != k) {\\n            cout << a[i] << \\\" \\\" << a[j] << \\\" \\\" << a[k] << endl;\\n            f = 0;\\n            break;\\n          }\\n        }\\n        if (f == 0) break;\\n      }\\n      if (f == 0) break;\\n    }\\n  }\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"A total of n depots are located on a number line. Depot i lies at the point x_i for 1 \u2264 i \u2264 n.\\n\\nYou are a salesman with n bags of goods, attempting to deliver one bag to each of the n depots. You and the n bags are initially at the origin 0. You can carry up to k bags at a time. You must collect the required number of goods from the origin, deliver them to the respective depots, and then return to the origin to collect your next batch of goods.\\n\\nCalculate the minimum distance you need to cover to deliver all the bags of goods to the depots. You do not have to return to the origin after you have delivered all the bags.\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 10 500). Description of the test cases follows.\\n\\nThe first line of each test case contains two integers n and k (1 \u2264 k \u2264 n \u2264 2 \u22c5 10^5).\\n\\nThe second line of each test case contains n integers x_1, x_2, \u2026, x_n (-10^9 \u2264 x_i \u2264 10^9). It is possible that some depots share the same position.\\n\\nIt is guaranteed that the sum of n over all test cases does not exceed 2 \u22c5 10^5.\\n\\nOutput\\n\\nFor each test case, output a single integer denoting the minimum distance you need to cover to deliver all the bags of goods to the depots. \\n\\nExample\\n\\nInput\\n\\n\\n4\\n5 1\\n1 2 3 4 5\\n9 3\\n-5 -10 -15 6 5 8 3 7 4\\n5 3\\n2 2 3 3 3\\n4 2\\n1000000000 1000000000 1000000000 1000000000\\n\\n\\nOutput\\n\\n\\n25\\n41\\n7\\n3000000000\\n\\nNote\\n\\nIn the first test case, you can carry only one bag at a time. Thus, the following is a solution sequence that gives a minimum travel distance: 0 \u2192 2 \u2192 0 \u2192 4 \u2192 0 \u2192 3 \u2192 0 \u2192 1 \u2192 0 \u2192 5, where each 0 means you go the origin and grab one bag, and each positive integer means you deliver the bag to a depot at this coordinate, giving a total distance of 25 units. It must be noted that there are other sequences that give the same distance.\\n\\nIn the second test case, you can follow the following sequence, among multiple such sequences, to travel minimum distance: 0 \u2192 6 \u2192 8 \u2192 7 \u2192 0 \u2192 5 \u2192 4 \u2192 3 \u2192 0 \u2192 (-5) \u2192 (-10) \u2192 (-15), with distance...\\nSolve the task in PYTHON3.\",\"targets\":\"def solve(a):\\n    global ans, k\\n    last = 0\\n    m = len(a)\\n    for i in range(m-1, -1, -1):\\n        ans += abs(a[i] - last)\\n        last = a[i]\\n        if i % k == 0:\\n            ans += abs(a[i])\\n            last = 0\\n\\nt = int(input())\\nfor _ in range(t):\\n    n, k = map(int, input().split())\\n    x = list(map(int, input().split()))\\n    x.sort(reverse=True)\\n    ans = 0\\n    x = [i for i in x if i != 0]\\n    n = len(x)\\n    neg = [i for i in x if i < 0]\\n    pos = [i for i in x if i > 0]\\n    neg = neg[::-1]\\n    solve(neg)\\n    solve(pos)\\n    if pos and neg:\\n        sub = max(abs(pos[0]), abs(neg[0]))\\n        ans -= sub\\n    elif pos:\\n        ans -= pos[0]\\n    elif neg:\\n        ans -= -neg[0]\\n    print(ans)\",\"language\":\"python\",\"split\":\"test\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You have a permutation: an array a = [a_1, a_2, \u2026, a_n] of distinct integers from 1 to n. The length of the permutation n is odd.\\n\\nYou need to sort the permutation in increasing order.\\n\\nIn one step, you can choose any prefix of the permutation with an odd length and reverse it. Formally, if a = [a_1, a_2, \u2026, a_n], you can choose any odd integer p between 1 and n, inclusive, and set a to [a_p, a_{p-1}, \u2026, a_1, a_{p+1}, a_{p+2}, \u2026, a_n].\\n\\nFind a way to sort a using no more than 5n\\/2 reversals of the above kind, or determine that such a way doesn't exist. The number of reversals doesn't have to be minimized.\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 100). Description of the test cases follows.\\n\\nThe first line of each test case contains a single integer n (3 \u2264 n \u2264 2021; n is odd) \u2014 the length of the permutation.\\n\\nThe second line contains n distinct integers a_1, a_2, \u2026, a_n (1 \u2264 a_i \u2264 n) \u2014 the permutation itself. \\n\\nIt is guaranteed that the sum of n over all test cases does not exceed 2021.\\n\\nOutput\\n\\nFor each test case, if it's impossible to sort the given permutation in at most 5n\\/2 reversals, print a single integer -1.\\n\\nOtherwise, print an integer m (0 \u2264 m \u2264 5n\\/2), denoting the number of reversals in your sequence of steps, followed by m integers p_i (1 \u2264 p_i \u2264 n; p_i is odd), denoting the lengths of the prefixes of a to be reversed, in chronological order.\\n\\nNote that m doesn't have to be minimized. If there are multiple answers, print any.\\n\\nExample\\n\\nInput\\n\\n\\n3\\n3\\n1 2 3\\n5\\n3 4 5 2 1\\n3\\n2 1 3\\n\\n\\nOutput\\n\\n\\n4\\n3 3 3 3\\n2\\n3 5\\n-1\\n\\nNote\\n\\nIn the first test case, the permutation is already sorted. Any even number of reversals of the length 3 prefix doesn't change that fact.\\n\\nIn the second test case, after reversing the prefix of length 3 the permutation will change to [5, 4, 3, 2, 1], and then after reversing the prefix of length 5 the permutation will change to [1, 2, 3, 4, 5].\\n\\nIn the third test case, it's impossible to sort the permutation.\\nUsing java can you solve the prior task?\",\"targets\":\"import java.io.OutputStream;\\nimport java.io.IOException;\\nimport java.io.InputStream;\\nimport java.io.OutputStream;\\nimport java.io.PrintWriter;\\nimport java.io.BufferedWriter;\\nimport java.util.InputMismatchException;\\nimport java.io.IOException;\\nimport java.util.ArrayList;\\nimport java.io.Writer;\\nimport java.io.OutputStreamWriter;\\nimport java.io.InputStream;\\n\\n\\/**\\n * Built using CHelper plug-in\\n * Actual solution is at the top\\n *\\/\\npublic class Main {\\n    public static void main(String[] args) {\\n        InputStream inputStream = System.in;\\n        OutputStream outputStream = System.out;\\n        InputReader in = new InputReader(inputStream);\\n        OutputWriter out = new OutputWriter(outputStream);\\n        BottomTierReversals solver = new BottomTierReversals();\\n        int testCount = Integer.parseInt(in.next());\\n        for (int i = 1; i <= testCount; i++)\\n            solver.solve(i, in, out);\\n        out.close();\\n    }\\n\\n    static class BottomTierReversals {\\n        int getPos(int[] a, int x) {\\n            for (int i = 0; i < a.length; i++) if (a[i] == x) return i;\\n            return -1;\\n        }\\n\\n        void reverse(int[] a, int p, ArrayList<Integer> ops) {\\n            int n = p + 1;\\n            if (n == 1) return;\\n            ops.add(n);\\n            for (int i = 0; 2 * i < n; i++) {\\n                int temp = a[i];\\n                a[i] = a[n - 1 - i];\\n                a[n - 1 - i] = temp;\\n            }\\n        }\\n\\n        public void solve(int testNumber, InputReader in, OutputWriter out) {\\n            ArrayList<Integer> ops = new ArrayList<>();\\n            int n = in.nextInt();\\n            int[] a = in.readIntArray(n);\\n            for (int i = 0; i < n; i++) {\\n                a[i]--;\\n                if (Math.abs(a[i] - i) % 2 != 0) {\\n                    out.println(-1);\\n                    return;\\n                }\\n            }\\n\\n            for (int i = n - 1; i >= 1; i -= 2) {\\n                int x = i - 1, y = i;\\n                int p_y = getPos(a, y);\\n                reverse(a, p_y, ops);\\n               ...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"PYTHON3 solution for \\\"Yelisey has an array a of n integers.\\n\\nIf a has length strictly greater than 1, then Yelisei can apply an operation called minimum extraction to it: \\n\\n  1. First, Yelisei finds the minimal number m in the array. If there are several identical minima, Yelisey can choose any of them. \\n  2. Then the selected minimal element is removed from the array. After that, m is subtracted from each remaining element. \\n\\n\\n\\nThus, after each operation, the length of the array is reduced by 1.\\n\\nFor example, if a = [1, 6, -4, -2, -4], then the minimum element in it is a_3 = -4, which means that after this operation the array will be equal to a=[1 {- (-4)}, 6 {- (-4)}, -2 {- (-4)}, -4 {- (-4)}] = [5, 10, 2, 0].\\n\\nSince Yelisey likes big numbers, he wants the numbers in the array a to be as big as possible.\\n\\nFormally speaking, he wants to make the minimum of the numbers in array a to be maximal possible (i.e. he want to maximize a minimum). To do this, Yelisey can apply the minimum extraction operation to the array as many times as he wants (possibly, zero). Note that the operation cannot be applied to an array of length 1.\\n\\nHelp him find what maximal value can the minimal element of the array have after applying several (possibly, zero) minimum extraction operations to the array.\\n\\nInput\\n\\nThe first line contains an integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases.\\n\\nThe next 2t lines contain descriptions of the test cases.\\n\\nIn the description of each test case, the first line contains an integer n (1 \u2264 n \u2264 2 \u22c5 10^5) \u2014 the original length of the array a. The second line of the description lists n space-separated integers a_i (-10^9 \u2264 a_i \u2264 10^9) \u2014 elements of the array a.\\n\\nIt is guaranteed that the sum of n over all test cases does not exceed 2 \u22c5 10^5.\\n\\nOutput\\n\\nPrint t lines, each of them containing the answer to the corresponding test case. The answer to the test case is a single integer \u2014 the maximal possible minimum in a, which can be obtained by several applications of the described operation to...\\\":\",\"targets\":\"def solve():\\n    n = int(input())\\n    l = input()\\n    l = [int(i) for i in l.split()]\\n    try:\\n      if (n == 1):\\n        print(l[0])\\n        return\\n      elif(n == 2):\\n        a = min(l)\\n        l.remove(a)\\n        a = max(a, l[0] - a)\\n        print(a)\\n        return\\n      else:\\n        l.sort()\\n        mx = l[0]\\n        for i in range(n - 1):\\n          mx = max(mx, l[i + 1] - l[i])\\n        print(mx)\\n    \\n    except EOFError as e:\\n      print(\\\"Error\\\")\\n\\n#cases\\nfor case in range(int(input())):\\n  solve()\",\"language\":\"python\",\"split\":\"test\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Given a positive integer n. Find three distinct positive integers a, b, c such that a + b + c = n and \\\\operatorname{gcd}(a, b) = c, where \\\\operatorname{gcd}(x, y) denotes the [greatest common divisor (GCD)](https:\\/\\/en.wikipedia.org\\/wiki\\/Greatest_common_divisor) of integers x and y.\\n\\nInput\\n\\nThe input consists of multiple test cases. The first line contains a single integer t (1 \u2264 t \u2264 10^5) \u2014 the number of test cases. Description of the test cases follows.\\n\\nThe first and only line of each test case contains a single integer n (10 \u2264 n \u2264 10^9).\\n\\nOutput\\n\\nFor each test case, output three distinct positive integers a, b, c satisfying the requirements. If there are multiple solutions, you can print any. We can show that an answer always exists.\\n\\nExample\\n\\nInput\\n\\n\\n6\\n18\\n63\\n73\\n91\\n438\\n122690412\\n\\n\\nOutput\\n\\n\\n6 9 3\\n21 39 3\\n29 43 1\\n49 35 7\\n146 219 73\\n28622 122661788 2\\n\\nNote\\n\\nIn the first test case, 6 + 9 + 3 = 18 and \\\\operatorname{gcd}(6, 9) = 3.\\n\\nIn the second test case, 21 + 39 + 3 = 63 and \\\\operatorname{gcd}(21, 39) = 3.\\n\\nIn the third test case, 29 + 43 + 1 = 73 and \\\\operatorname{gcd}(29, 43) = 1.\",\"targets\":\"\\/* package codechef; \\/\\/ don't place package name! *\\/\\n\\nimport java.util.*;\\nimport java.lang.*;\\nimport java.io.*;\\n\\n\\/* Name of the class has to be \\\"Main\\\" only if the class is public. *\\/\\npublic class Main\\n{\\n    static class FastReader {\\n        BufferedReader br;\\n        StringTokenizer st;\\n \\n        public FastReader()\\n        {\\n            br = new BufferedReader(\\n                new InputStreamReader(System.in));\\n        }\\n \\n        String next()\\n        {\\n            while (st == null || !st.hasMoreElements()) {\\n                try {\\n                    st = new StringTokenizer(br.readLine());\\n                }\\n                catch (IOException e) {\\n                    e.printStackTrace();\\n                }\\n            }\\n            return st.nextToken();\\n        }\\n \\n        int nextInt() { return Integer.parseInt(next()); }\\n \\n        long nextLong() { return Long.parseLong(next()); }\\n \\n        double nextDouble()\\n        {\\n            return Double.parseDouble(next());\\n        }\\n \\n        String nextLine()\\n        {\\n            String str = \\\"\\\";\\n            try {\\n                str = br.readLine();\\n            }\\n            catch (IOException e) {\\n                e.printStackTrace();\\n            }\\n            return str;\\n        }\\n    }\\n    public static boolean isPrime(int num) {\\n           if (num <= 1) {\\n               return false;\\n           }\\n           for (int i = 2; i <= Math.sqrt(num); i++) {\\n               if (num % i == 0) {\\n                   return false;\\n               }\\n           }\\n           return true;\\n    }\\n    static long modPow(long var, long num) {\\n    long m = 1;\\n    while (num > 0) {\\n        m = (m * var) %1000000007;\\n        --num;\\n    }\\n    return m;}\\n\\tpublic static void main (String[] args) throws java.lang.Exception\\n\\t{\\n\\t\\tFastReader s = new FastReader();\\n\\t\\t BufferedWriter output = new BufferedWriter(\\n            new OutputStreamWriter(System.out));\\n\\t\\tint t=s.nextInt();\\n\\t\\tfor(int w=0;w<t;w++)\\n\\t\\t{\\n\\t\\t    int n=s.nextInt();\\n\\t\\t    n=n-1;\\n\\t\\t    if(n%2!=0)\\n\\t\\t    {\\n\\t\\t       ...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in CPP?\\nThis is a harder version of the problem with bigger constraints.\\n\\nKorney Korneevich dag up an array a of length n. Korney Korneevich has recently read about the operation [bitwise XOR](https:\\/\\/en.wikipedia.org\\/wiki\\/Bitwise_operation#XOR), so he wished to experiment with it. For this purpose, he decided to find all integers x \u2265 0 such that there exists an increasing subsequence of the array a, in which the bitwise XOR of numbers is equal to x.\\n\\nIt didn't take a long time for Korney Korneevich to find all such x, and he wants to check his result. That's why he asked you to solve this problem!\\n\\nA sequence s is a subsequence of a sequence b if s can be obtained from b by deletion of several (possibly, zero or all) elements.\\n\\nA sequence s_1, s_2, \u2026 , s_m is called increasing if s_1 < s_2 < \u2026 < s_m.\\n\\nInput\\n\\nThe first line contains a single integer n (1 \u2264 n \u2264 10^6).\\n\\nThe second line contains n integers a_1, a_2, \u2026, a_n (0 \u2264 a_i \u2264 5000) \u2014 the elements of the array a.\\n\\nOutput\\n\\nIn the first line print a single integer k \u2014 the number of found x values.\\n\\nIn the second line print k integers in increasing order x_1, x_2, \u2026 x_k (0 \u2264 x_1 < \u2026 < x_k) \u2014 found x values.\\n\\nExamples\\n\\nInput\\n\\n\\n4\\n4 2 2 4\\n\\n\\nOutput\\n\\n\\n4\\n0 2 4 6 \\n\\n\\nInput\\n\\n\\n8\\n1 0 1 7 12 5 3 2\\n\\n\\nOutput\\n\\n\\n12\\n0 1 2 3 4 5 6 7 10 11 12 13 \\n\\nNote\\n\\nIn the first test case:\\n\\n  * To get value x = 0 it is possible to choose and empty subsequence \\n  * To get value x = 2 it is possible to choose a subsequence [2] \\n  * To get value x = 4 it is possible to choose a subsequence [4] \\n  * To get value x = 6 it is possible to choose a subsequence [2, 4]\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst int N = 1e6 + 11;\\nint n, a[N], pos[N];\\nvector<int> li[5011];\\nint solve() {\\n  cin >> n;\\n  for (int i = 1; i <= n; i++) {\\n    cin >> a[i];\\n    li[a[i]].push_back(i);\\n  }\\n  for (int i = 0; i < 8192; i++) pos[i] = n + 1;\\n  pos[0] = 0;\\n  for (int x = 1; x <= 5000; x++) {\\n    if (li[x].size() == 0) continue;\\n    for (int y = 0; y < 8192; y++) {\\n      int z = x ^ y;\\n      if (pos[z] == n + 1 || pos[y] <= li[x][0]) {\\n        continue;\\n      }\\n      int id =\\n          lower_bound(li[x].begin(), li[x].end(), pos[z] + 1) - li[x].begin();\\n      if (id == li[x].size()) continue;\\n      pos[y] = min(pos[y], li[x][id]);\\n    }\\n  }\\n  int res = 0;\\n  for (int i = 0; i < 8192; i++)\\n    if (pos[i] <= n) res++;\\n  cout << res << '\\\\n';\\n  for (int i = 0; i < 8192; i++)\\n    if (pos[i] <= n) cout << i << ' ';\\n  return 0;\\n}\\nint main() {\\n  int ntest = 1;\\n  while (ntest--) {\\n    solve();\\n  }\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in JAVA?\\nThe only difference between this problem and D2 is that you don't have to provide the way to construct the answer in this problem, but you have to do it in D2.\\n\\nThere's a table of n \u00d7 m cells (n rows and m columns). The value of n \u22c5 m is even.\\n\\nA domino is a figure that consists of two cells having a common side. It may be horizontal (one of the cells is to the right of the other) or vertical (one of the cells is above the other).\\n\\nYou need to find out whether it is possible to place nm\\/2 dominoes on the table so that exactly k of them are horizontal and all the other dominoes are vertical. The dominoes cannot overlap and must fill the whole table.\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 10) \u2014 the number of test cases. Then t test cases follow.\\n\\nEach test case consists of a single line. The line contains three integers n, m, k (1 \u2264 n,m \u2264 100, 0 \u2264 k \u2264 nm\\/2, n \u22c5 m is even) \u2014 the number of rows, columns and horizontal dominoes, respectively.\\n\\nOutput\\n\\nFor each test case output \\\"YES\\\", if it is possible to place dominoes in the desired way, or \\\"NO\\\" otherwise.\\n\\nYou may print each letter in any case (YES, yes, Yes will all be recognized as positive answer, NO, no and nO will all be recognized as negative answer).\\n\\nExample\\n\\nInput\\n\\n\\n8\\n4 4 2\\n2 3 0\\n3 2 3\\n1 2 0\\n2 4 2\\n5 2 2\\n2 17 16\\n2 1 1\\n\\n\\nOutput\\n\\n\\nYES\\nYES\\nYES\\nNO\\nYES\\nNO\\nYES\\nNO\",\"targets\":\"import java.io.ByteArrayInputStream;\\nimport java.io.IOException;\\nimport java.io.InputStream;\\nimport java.io.PrintWriter;\\nimport java.util.Arrays;\\nimport java.util.InputMismatchException;\\n\\npublic class Main {\\n\\n\\tprivate static final String NO = \\\"No\\\";\\n\\tprivate static final String YES = \\\"Yes\\\";\\n\\tInputStream is;\\n\\tPrintWriter out;\\n\\tString INPUT = \\\"\\\";\\n\\n\\tprivate static final long MOD = (long) (1e9 + 7);\\n\\n\\tvoid solve() {\\n\\t\\tint T = ni();\\n\\t\\tfor (int i = 0; i < T; i++)\\n\\t\\t\\tsolve(i);\\n\\t}\\n\\n\\tvoid solve(int nth) {\\n\\t\\tint n = ni();\\n\\t\\tint m = ni();\\n\\t\\tint h = ni();\\n\\t\\tint total = n * m \\/ 2;\\n\\t\\tint v = total - h;\\n\\t\\tboolean yes = false;\\n\\t\\tif (n % 2 == 1) {\\n\\t\\t\\tint h0 = m \\/ 2;\\n\\t\\t\\tyes = (h >= h0 && (h - h0) % 2 == 0);\\n\\t\\t} else if (m % 2 == 1) {\\n\\t\\t\\tint v0 = n \\/ 2;\\n\\t\\t\\tyes = (v >= v0 && (v - v0) % 2 == 0);\\n\\t\\t} else\\n\\t\\t\\tyes = h % 2 == 0;\\n\\n\\t\\tout.println(yes ? YES : NO);\\n\\n\\t}\\n\\n\\tvoid run() throws Exception {\\n\\t\\tis = INPUT.isEmpty() ? System.in : new ByteArrayInputStream(INPUT.getBytes());\\n\\t\\tout = new PrintWriter(System.out);\\n\\n\\t\\tlong s = System.currentTimeMillis();\\n\\t\\tsolve();\\n\\t\\tout.flush();\\n\\t\\tif (!INPUT.isEmpty())\\n\\t\\t\\ttr(System.currentTimeMillis() - s + \\\"ms\\\");\\n\\t}\\n\\n\\tpublic static void main(String[] args) throws Exception {\\n\\t\\tnew Main().run();\\n\\t}\\n\\n\\tprivate byte[] inbuf = new byte[1024];\\n\\tpublic int lenbuf = 0, ptrbuf = 0;\\n\\n\\tprivate int readByte() {\\n\\t\\tif (lenbuf == -1)\\n\\t\\t\\tthrow new InputMismatchException();\\n\\t\\tif (ptrbuf >= lenbuf) {\\n\\t\\t\\tptrbuf = 0;\\n\\t\\t\\ttry {\\n\\t\\t\\t\\tlenbuf = is.read(inbuf);\\n\\t\\t\\t} catch (IOException e) {\\n\\t\\t\\t\\tthrow new InputMismatchException();\\n\\t\\t\\t}\\n\\t\\t\\tif (lenbuf <= 0)\\n\\t\\t\\t\\treturn -1;\\n\\t\\t}\\n\\t\\treturn inbuf[ptrbuf++];\\n\\t}\\n\\n\\tprivate boolean isSpaceChar(int c) {\\n\\t\\treturn !(c >= 33 && c <= 126);\\n\\t}\\n\\n\\tprivate int skip() {\\n\\t\\tint b;\\n\\t\\twhile ((b = readByte()) != -1 && isSpaceChar(b))\\n\\t\\t\\t;\\n\\t\\treturn b;\\n\\t}\\n\\n\\tprivate double nd() {\\n\\t\\treturn Double.parseDouble(ns());\\n\\t}\\n\\n\\tprivate char nc() {\\n\\t\\treturn (char) skip();\\n\\t}\\n\\n\\tprivate char[] nc(int n) {\\n\\t\\tchar[] ret = new char[n];\\n\\t\\tfor (int i = 0; i < n; i++)\\n\\t\\t\\tret[i] = nc();\\n\\t\\treturn ret;\\n\\t}\\n\\n\\tprivate String ns()...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in CPP?\\nFox 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.\\n\\nA 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.\\n\\nYour 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 ('#').\\n\\nConsider sample tests in order to understand the snake pattern.\\n\\nInput\\n\\nThe only line contains two integers: n and m (3 \u2264 n, m \u2264 50). \\n\\nn is an odd number.\\n\\nOutput\\n\\nOutput n lines. Each line should contain a string consisting of m characters. Do not output spaces.\\n\\nExamples\\n\\nInput\\n\\n3 3\\n\\n\\nOutput\\n\\n###\\n..#\\n###\\n\\n\\nInput\\n\\n3 4\\n\\n\\nOutput\\n\\n####\\n...#\\n####\\n\\n\\nInput\\n\\n5 3\\n\\n\\nOutput\\n\\n###\\n..#\\n###\\n#..\\n###\\n\\n\\nInput\\n\\n9 9\\n\\n\\nOutput\\n\\n#########\\n........#\\n#########\\n#........\\n#########\\n........#\\n#########\\n#........\\n#########\",\"targets\":\"#include <bits\\/stdc++.h>\\n#pragma comment(linker, \\\"\\/STACK:256000000\\\")\\nusing namespace std;\\nconst double PI = acos(-1.0);\\nint main() {\\n  int n, m;\\n  scanf(\\\"%d%d\\\", &n, &m);\\n  int ok = 1;\\n  for (int i = 0; i < n; puts(\\\"\\\"), i++) {\\n    for (int j = 0; j < m; j++) {\\n      char ch = i & 1 ? '.' : '#';\\n      if (i & 1 && j == m - 1 && ok) ch = '#';\\n      if (i & 1 && j == 0 && !ok) ch = '#';\\n      printf(\\\"%c\\\", ch);\\n    }\\n    ok ^= i & 1;\\n  }\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"A ball will bounce along a number line, making N + 1 bounces. It will make the first bounce at coordinate D_1 = 0, and the i-th bounce (2 \\\\leq i \\\\leq N+1) at coordinate D_i = D_{i-1} + L_{i-1}.\\n\\nHow many times will the ball make a bounce where the coordinate is at most X?\\n\\nConstraints\\n\\n* 1 \\\\leq N \\\\leq 100\\n* 1 \\\\leq L_i \\\\leq 100\\n* 1 \\\\leq X \\\\leq 10000\\n* All values in input are integers.\\n\\nInput\\n\\nInput is given from Standard Input in the following format:\\n\\n\\nN X\\nL_1 L_2 ... L_{N-1} L_N\\n\\n\\nOutput\\n\\nPrint the number of times the ball will make a bounce where the coordinate is at most X.\\n\\nExamples\\n\\nInput\\n\\n3 6\\n3 4 5\\n\\n\\nOutput\\n\\n2\\n\\n\\nInput\\n\\n4 9\\n3 3 3 3\\n\\n\\nOutput\\n\\n4\\nThe above is tricky. Write me a correct solution in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint main(){\\n  int N,X;\\n  cin>>N>>X;\\n  int Z=1,A=0;\\n  for(int i=0;i<N;i++){\\n    int a;\\n    cin>>a;\\n    A+=a;\\n    if(A>X){\\n      break;\\n    }\\n    Z++;\\n  }\\n  cout<<Z<<endl;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Bob really likes playing with arrays of numbers. That's why for his birthday, his friends bought him a really interesting machine \u2013 an array beautifier. \\n\\nThe array beautifier takes an array A consisting of N integers, and it outputs a new array B of length N that it constructed based on the array given to it. The array beautifier constructs the new array in the following way: it takes two numbers at different indices from the original array and writes their sum to the end of the new array. It does this step N times - resulting in an output array of length N. During this process, the machine can take the same index multiple times in different steps. \\n\\nBob was very excited about the gift that his friends gave him, so he put his favorite array in the machine. However, when the machine finished, Bob was not happy with the resulting array. He misses his favorite array very much, and hopes to get it back. \\n\\nGiven the array that the machine outputted, help Bob find an array that could be the original array that he put in the machine. Sometimes the machine makes mistakes, so it is possible that no appropriate input array exists for the array it has outputted. In such case, let Bob know that his array is forever lost.\\n\\nInput\\n\\nThe first line contains one positive integer N (2 \u2264 N \u2264 10^3) \u2013 the length of Bob's array.\\n\\nThe second line contains N integers B_1, B_2, ..., B_N (1 \u2264 B_i \u2264 10^6) \u2013 the elements of the array the machine outputted.\\n\\nOutput\\n\\nIf an appropriate input array exists, print \\\"YES\\\", followed by the input array A_1, A_2, ..., A_N (-10^9 \u2264 A_i \u2264 10^9) in the next line. Otherwise, print \\\"NO\\\".\\n\\nExamples\\n\\nInput\\n\\n\\n2\\n5 5\\n\\n\\nOutput\\n\\n\\nYES\\n2 3\\n\\n\\nInput\\n\\n\\n3\\n1 2 3\\n\\n\\nOutput\\n\\n\\nYES\\n0 1 2\\n\\n\\nInput\\n\\n\\n3\\n2 4 5\\n\\n\\nOutput\\n\\n\\nNO\\n\\n\\nInput\\n\\n\\n4\\n1 3 5 7\\n\\n\\nOutput\\n\\n\\nYES\\n6 -3 4 1\\n#incl\",\"targets\":\"ude <bits\\/stdc++.h>\\nusing namespace std;\\nconst int N = 1005;\\nconst int M = 1.3e7 + 5;\\ntemplate <typename T>\\nvoid read(T &x) {\\n  x = 0;\\n  int f = 1;\\n  char c = getchar();\\n  for (; !isdigit(c); c = getchar())\\n    if (c == '-') f = -1;\\n  for (; isdigit(c); c = getchar()) x = (x << 1) + (x << 3) + c - '0';\\n  x *= f;\\n}\\nint n, m;\\nint a[N], b[N];\\nint vis[M];\\nint v[2][N], g[N];\\nint main() {\\n  read(n);\\n  for (int i = 1; i <= n; i++) read(b[i]);\\n  sort(b + 1, b + n + 1);\\n  int tot = unique(b + 1, b + n + 1) - b - 1;\\n  if (tot < n) {\\n    for (int i = 1; i <= tot; i++) a[i] = b[i];\\n    puts(\\\"YES\\\");\\n    for (int i = 1; i <= n; i++) printf(\\\"%d \\\", a[i]);\\n    puts(\\\"\\\");\\n    return 0;\\n  }\\n  for (int i = 1; i <= n; i++)\\n    if (b[i] & 1) {\\n      int p1 = 0, p2 = 0;\\n      for (int j = 1; j <= n; j++)\\n        if (i != j && (b[j] & 1)) p1 = j;\\n      for (int j = 1; j <= n; j++)\\n        if (i != j && (b[j] & 1 ^ 1)) p2 = j;\\n      if (!p1 || !p2) continue;\\n      a[i] = (-b[i] + b[p1] + b[p2]) \\/ 2;\\n      for (int j = 1; j <= n; j++)\\n        if (i != j) a[j] = b[j] - a[i];\\n      puts(\\\"YES\\\");\\n      for (int i = 1; i <= n; i++) printf(\\\"%d \\\", a[i]);\\n      puts(\\\"\\\");\\n      return 0;\\n    } else {\\n      int p1 = 0, p2 = 0;\\n      for (int j = 1; j <= n; j++)\\n        if (i != j && (b[j] & 1)) {\\n          p1 = j;\\n          break;\\n        }\\n      for (int j = p1 + 1; j <= n; j++)\\n        if (i != j && (b[j] & 1)) {\\n          p2 = j;\\n          break;\\n        }\\n      if (!p1 || !p2) {\\n        p1 = 0, p2 = 0;\\n        for (int j = 1; j <= n; j++)\\n          if (i != j && (b[j] & 1 ^ 1)) {\\n            p1 = j;\\n            break;\\n          }\\n        for (int j = p1 + 1; j <= n; j++)\\n          if (i != j && (b[j] & 1 ^ 1)) {\\n            p2 = j;\\n            break;\\n          }\\n      }\\n      if (!p1 || !p2) continue;\\n      a[i] = (-b[i] + b[p1] + b[p2]) \\/ 2;\\n      for (int j = 1; j <= n; j++)\\n        if (i != j) a[j] = b[j] - a[i];\\n      puts(\\\"YES\\\");\\n      for (int i = 1; i <= n; i++) printf(\\\"%d \\\", a[i]);\\n      puts(\\\"\\\");\\n      return 0;\\n    }\\n  m = min(n,...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"After you had helped George and Alex to move in the dorm, they went to help their friend Fedor play a new computer game \u00abCall of Soldiers 3\u00bb.\\n\\nThe game has (m + 1) players and n types of soldiers in total. Players \u00abCall of Soldiers 3\u00bb are numbered form 1 to (m + 1). Types of soldiers are numbered from 0 to n - 1. Each player has an army. Army of the i-th player can be described by non-negative integer xi. Consider binary representation of xi: if the j-th bit of number xi equal to one, then the army of the i-th player has soldiers of the j-th type. \\n\\nFedor is the (m + 1)-th player of the game. He assume that two players can become friends if their armies differ in at most k types of soldiers (in other words, binary representations of the corresponding numbers differ in at most k bits). Help Fedor and count how many players can become his friends.\\n\\nInput\\n\\nThe first line contains three integers n, m, k (1 \u2264 k \u2264 n \u2264 20; 1 \u2264 m \u2264 1000).\\n\\nThe i-th of the next (m + 1) lines contains a single integer xi (1 \u2264 xi \u2264 2n - 1), that describes the i-th player's army. We remind you that Fedor is the (m + 1)-th player.\\n\\nOutput\\n\\nPrint a single integer \u2014 the number of Fedor's potential friends.\\n\\nExamples\\n\\nInput\\n\\n7 3 1\\n8\\n5\\n111\\n17\\n\\n\\nOutput\\n\\n0\\n\\n\\nInput\\n\\n3 3 3\\n1\\n2\\n3\\n4\\n\\n\\nOutput\\n\\n3\\nimpor\",\"targets\":\"t java.util.Scanner;\\npublic class A { \\n\\t\\t    public static void main(String[] args) {\\n\\t\\t      Scanner sc=new Scanner(System.in);\\n\\t\\t      int n=sc.nextInt();\\n\\t\\t      int m=sc.nextInt();\\n\\t          int k=sc.nextInt();\\n\\t          String s[]=new String[m+1];\\n\\t          \\n\\t          for(int i=0;i<m+1;i++){\\n\\t        \\t  int a=sc.nextInt();\\n\\t        \\t s[i]=Integer.toBinaryString(a);\\n\\t          }\\n\\t          String s1=s[m];\\n\\t          int count=0,c=0;\\n\\t          for(int i=0;i<m;i++){\\tc=0;      \\n\\t          String s2=\\\"\\\";\\n\\t          String s3=\\\"\\\";\\n\\t          if(s1.length()>=s[i].length()) { s2=s1.substring(s1.length()-s[i].length(),s1.length()); s3=s1.substring(0, s1.length()-s[i].length()); }\\n\\t          else if(s[i].length()>s1.length()) { s2=s[i].substring(s[i].length()-s1.length(), s[i].length()); s3=s[i].substring(0, s[i].length()-s1.length()); }\\n\\t            for(int l=0;l<s3.length();l++) if(s3.charAt(l)=='1') c++;  \\n\\t            for(int j=s2.length()-1;j>=0;j--){\\t   \\n\\t            \\t if(s1.length()>=s[i].length() && s2.charAt(j)!=s[i].charAt(j)) c++;\\n\\t            \\t if(s[i].length()>s1.length() && s2.charAt(j)!=s1.charAt(j)) c++;\\n\\t            \\t}\\n\\t            if(c<=k) count++;\\n\\t          }\\n\\t          System.out.println(count);\\n    }\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"n players are playing a game. \\n\\nThere are two different maps in the game. For each player, we know his strength on each map. When two players fight on a specific map, the player with higher strength on that map always wins. No two players have the same strength on the same map. \\n\\nYou are the game master and want to organize a tournament. There will be a total of n-1 battles. While there is more than one player in the tournament, choose any map and any two remaining players to fight on it. The player who loses will be eliminated from the tournament. \\n\\nIn the end, exactly one player will remain, and he is declared the winner of the tournament. For each player determine if he can win the tournament.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 100) \u2014 the number of test cases. The description of test cases follows.\\n\\nThe first line of each test case contains a single integer n (1 \u2264 n \u2264 10^5) \u2014 the number of players.\\n\\nThe second line of each test case contains n integers a_1, a_2, ..., a_n (1 \u2264 a_i \u2264 10^9, a_i \u2260 a_j for i \u2260 j), where a_i is the strength of the i-th player on the first map. \\n\\nThe third line of each test case contains n integers b_1, b_2, ..., b_n (1 \u2264 b_i \u2264 10^9, b_i \u2260 b_j for i \u2260 j), where b_i is the strength of the i-th player on the second map. \\n\\nIt is guaranteed that the sum of n over all test cases does not exceed 10^5.\\n\\nOutput\\n\\nFor each test case print a string of length n. i-th character should be \\\"1\\\" if the i-th player can win the tournament, or \\\"0\\\" otherwise.\\n\\nExample\\n\\nInput\\n\\n\\n3\\n4\\n1 2 3 4\\n1 2 3 4\\n4\\n11 12 20 21\\n44 22 11 30\\n1\\n1000000000\\n1000000000\\n\\n\\nOutput\\n\\n\\n0001\\n1111\\n1\\n\\nNote\\n\\nIn the first test case, the 4-th player will beat any other player on any game, so he will definitely win the tournament.\\n\\nIn the second test case, everyone can be a winner. \\n\\nIn the third test case, there is only one player. Clearly, he will win the tournament.\\nThe above is tricky. Write me a correct solution in JAVA.\",\"targets\":\"import java.io.*;\\nimport java.util.*;\\npublic class solution {\\n\\npublic static void main(String[] args)  {\\n\\tFScanner sc = new FScanner();\\n\\t\\/\\/Arrays.fill(prime, true);\\n\\t\\/\\/sieve();\\n\\t\\n\\tint t=sc.nextInt();\\n\\t StringBuilder sb = new StringBuilder();\\n\\twhile(t-->0) {\\t\\n\\tint n=sc.nextInt();\\n\\tArrayList<pair> a=new ArrayList<>();\\n\\tArrayList<pair> b=new ArrayList<>();\\n     for(int i=0;i<n;i++)\\n     {\\n    \\t a.add(new pair(sc.nextInt(),i));\\n     }\\n     for(int i=0;i<n;i++)\\n     {\\n    \\t b.add(new pair(sc.nextInt(),i));\\n     }\\n     Collections.sort(a,new Comparator<pair>() {\\n    \\t public int compare(pair p1,pair p2)\\n    \\t {\\n    \\t\\t return p1.val-p2.val;\\n    \\t }\\n     });\\n     Collections.sort(b,new Comparator<pair>() {\\n    \\t public int compare(pair p1,pair p2)\\n    \\t {\\n    \\t\\t return p1.val-p2.val;\\n    \\t }\\n     });\\n    \\n\\t HashSet<Integer> hs=new HashSet<>();\\n\\t hs.add(a.get(n-1).ind);hs.add(b.get(n-1).ind);\\n\\tfor(int i=n-2;i>=0;i--)\\n\\t{\\n\\t\\tif(hs.size()>=n-i)\\n\\t\\t\\t{hs.add(b.get(i).ind);\\n\\t\\t\\ths.add(a.get(i).ind);}\\n\\t\\telse\\n\\t\\t\\tbreak;\\n\\t\\t\\n\\t}\\n\\tchar c[]=new char[n];\\n\\tfor(int i=0;i<n;i++)\\n\\t{    if(hs.contains(i))\\n\\t\\tc[i]='1';\\n\\telse\\n\\t\\tc[i]='0';\\n\\t}\\n\\tsb.append(String.valueOf(c)+\\\"\\\\n\\\");\\n\\t}\\n\\t\\n\\tSystem.out.println(sb.toString());\\n\\t\\n}\\n\\n\\n        \\n \\/* public static void sieve()\\n{   prime[0]=prime[1]=false;\\nint n=1000000;\\n\\tfor(int p = 2; p*p <=n; p++)\\n    {\\n        if(prime[p] == true)\\n        {\\n          \\n            for(int i = p*p; i <= n; i += p)\\n                prime[i] = false;\\n        }\\n    }\\n   *\\/\\n}\\n \\n  class pair {\\n\\tint val;int ind;\\n\\t pair(int val,int ind)\\n\\t{\\n\\t\\tthis.val=val;\\n\\t\\tthis.ind=ind;\\n\\t}\\n\\t\\n\\t\\n}  \\n \\n class FScanner {\\n\\tBufferedReader br = new BufferedReader(new InputStreamReader(System.in));\\n\\tStringTokenizer sb = new StringTokenizer(\\\"\\\");\\n \\n\\tString next(){\\n\\t\\twhile(!sb.hasMoreTokens()){\\n\\t\\t\\ttry{\\n\\t\\t\\t\\tsb = new StringTokenizer(br.readLine());\\n\\t\\t\\t} catch(IOException e){ }\\n\\t\\t}\\n\\t\\treturn sb.nextToken();\\n\\t}\\n\\tString nextLine(){\\n\\t\\ttry{ return br.readLine(); } \\n\\t\\tcatch(IOException e) { } return \\\"\\\";\\n\\t}\\n \\n\\tint nextInt(){\\n\\t\\treturn Integer.parseInt(next());\\n\\t}\\n...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in CPP?\\nMonocarp is the coach of the Berland State University programming teams. He decided to compose a problemset for a training session for his teams.\\n\\nMonocarp has n problems that none of his students have seen yet. The i-th problem has a topic a_i (an integer from 1 to n) and a difficulty b_i (an integer from 1 to n). All problems are different, that is, there are no two tasks that have the same topic and difficulty at the same time.\\n\\nMonocarp decided to select exactly 3 problems from n problems for the problemset. The problems should satisfy at least one of two conditions (possibly, both):\\n\\n  * the topics of all three selected problems are different; \\n  * the difficulties of all three selected problems are different. \\n\\n\\n\\nYour task is to determine the number of ways to select three problems for the problemset.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 50000) \u2014 the number of testcases.\\n\\nThe first line of each testcase contains an integer n (3 \u2264 n \u2264 2 \u22c5 10^5) \u2014 the number of problems that Monocarp have.\\n\\nIn the i-th of the following n lines, there are two integers a_i and b_i (1 \u2264 a_i, b_i \u2264 n) \u2014 the topic and the difficulty of the i-th problem.\\n\\nIt is guaranteed that there are no two problems that have the same topic and difficulty at the same time.\\n\\nThe sum of n over all testcases doesn't exceed 2 \u22c5 10^5.\\n\\nOutput\\n\\nPrint the number of ways to select three training problems that meet either of the requirements described in the statement.\\n\\nExample\\n\\nInput\\n\\n\\n2\\n4\\n2 4\\n3 4\\n2 1\\n1 3\\n5\\n1 5\\n2 4\\n3 3\\n4 2\\n5 1\\n\\n\\nOutput\\n\\n\\n3\\n10\\n\\nNote\\n\\nIn the first example, you can take the following sets of three problems:\\n\\n  * problems 1, 2, 4; \\n  * problems 1, 3, 4; \\n  * problems 2, 3, 4. \\n\\n\\n\\nThus, the number of ways is equal to three.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst long long Mod = 1000000007;\\nconst long long INF = 999999999999999999;\\nconst long long NN = (long long)(1e6 + 5);\\ntemplate <typename T>\\nT Min(T x, T y) {\\n  if (x < y) return x;\\n  return y;\\n}\\ntemplate <typename T>\\nT Max(T x, T y) {\\n  if (x > y) return x;\\n  return y;\\n}\\nlong long power(long long x, unsigned long long y, long long mod = Mod) {\\n  long long res = 1;\\n  x = x % mod;\\n  if (x == 0) return 0;\\n  while (y > 0) {\\n    if (y & 1) res = (res * x) % mod;\\n    y = y >> 1LL;\\n    x = (x * x) % mod;\\n  }\\n  return res % mod;\\n}\\ntemplate <typename T>\\nT hcf(T a, T b) {\\n  if (b == 0) return a;\\n  return hcf(b, a % b);\\n}\\nlong long c3(long long n) { return (n * (n - 1) * (n - 2)) \\/ 6; }\\nlong long c2(long long n) { return (n * (n - 1)) \\/ 2; }\\nvoid solve() {\\n  long long n;\\n  cin >> n;\\n  vector<pair<long long, long long> > v(n);\\n  map<long long, long long> x, y;\\n  for (auto &u : v) cin >> u.first >> u.second, x[u.first]++, y[u.second]++;\\n  long long i, ans = 0, tot = c3(n);\\n  for (i = 0; i < n; i++) {\\n    tot -= (x[v[i].first] - 1) * (y[v[i].second] - 1);\\n  }\\n  cout << tot << \\\"\\\\n\\\";\\n}\\nint main() {\\n  ios_base::sync_with_stdio(0);\\n  cin.tie(NULL);\\n  cout.tie(NULL);\\n  ;\\n  long long TT = 1;\\n  cin >> TT;\\n  for (long long tt = 1; tt <= TT; tt++) {\\n    solve();\\n  }\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"<image>\\n\\nWilliam has a favorite bracket sequence. Since his favorite sequence is quite big he provided it to you as a sequence of positive integers c_1, c_2, ..., c_n where c_i is the number of consecutive brackets \\\"(\\\" if i is an odd number or the number of consecutive brackets \\\")\\\" if i is an even number.\\n\\nFor example for a bracket sequence \\\"((())()))\\\" a corresponding sequence of numbers is [3, 2, 1, 3].\\n\\nYou need to find the total number of continuous subsequences (subsegments) [l, r] (l \u2264 r) of the original bracket sequence, which are regular bracket sequences.\\n\\nA bracket sequence is called regular if it is possible to obtain correct arithmetic expression by inserting characters \\\"+\\\" and \\\"1\\\" into this sequence. For example, sequences \\\"(())()\\\", \\\"()\\\" and \\\"(()(()))\\\" are regular, while \\\")(\\\", \\\"(()\\\" and \\\"(()))(\\\" are not.\\n\\nInput\\n\\nThe first line contains a single integer n (1 \u2264 n \u2264 1000), the size of the compressed sequence.\\n\\nThe second line contains a sequence of integers c_1, c_2, ..., c_n (1 \u2264 c_i \u2264 10^9), the compressed sequence.\\n\\nOutput\\n\\nOutput a single integer \u2014 the total number of subsegments of the original bracket sequence, which are regular bracket sequences.\\n\\nIt can be proved that the answer fits in the signed 64-bit integer data type.\\n\\nExamples\\n\\nInput\\n\\n\\n5\\n4 1 2 3 1\\n\\n\\nOutput\\n\\n\\n5\\n\\n\\nInput\\n\\n\\n6\\n1 3 2 1 2 4\\n\\n\\nOutput\\n\\n\\n6\\n\\n\\nInput\\n\\n\\n6\\n1 1 1 1 2 2\\n\\n\\nOutput\\n\\n\\n7\\n\\nNote\\n\\nIn the first example a sequence (((()(()))( is described. This bracket sequence contains 5 subsegments which form regular bracket sequences:\\n\\n  1. Subsequence from the 3rd to 10th character: (()(()))\\n  2. Subsequence from the 4th to 5th character: ()\\n  3. Subsequence from the 4th to 9th character: ()(())\\n  4. Subsequence from the 6th to 9th character: (())\\n  5. Subsequence from the 7th to 8th character: ()\\n\\n\\n\\nIn the second example a sequence ()))(()(()))) is described.\\n\\nIn the third example a sequence ()()(()) is described.\\nUsing java can you solve the prior task?\",\"targets\":\"import java.io.OutputStream;\\nimport java.io.IOException;\\nimport java.io.InputStream;\\nimport java.io.OutputStream;\\nimport java.io.PrintWriter;\\nimport java.io.BufferedWriter;\\nimport java.io.Writer;\\nimport java.io.OutputStreamWriter;\\nimport java.util.InputMismatchException;\\nimport java.io.IOException;\\nimport java.io.InputStream;\\n\\n\\/**\\n * Built using CHelper plug-in\\n * Actual solution is at the top\\n *\\/\\npublic class Main {\\n    public static void main(String[] args) {\\n        InputStream inputStream = System.in;\\n        OutputStream outputStream = System.out;\\n        InputReader in = new InputReader(inputStream);\\n        OutputWriter out = new OutputWriter(outputStream);\\n        CCompressedBracketSequence solver = new CCompressedBracketSequence();\\n        solver.solve(1, in, out);\\n        out.close();\\n    }\\n\\n    static class CCompressedBracketSequence {\\n        public void solve(int testNumber, InputReader in, OutputWriter out) {\\n            int n = in.nextInt();\\n            long[] a = in.nextLongArray(n);\\n            long res = 0;\\n\\n            for (int i = 0; i < n; i += 2) {\\n                long begin = a[i];\\n                long sum = 0;\\n                boolean first = true;\\n                for (int j = i + 1; j < n; j++) {\\n                    if (j % 2 == 0) {\\n                        sum += a[j];\\n                    } else {\\n                        if (a[j] < sum) {\\n                            sum -= a[j];\\n                        } else {\\n                            res += Math.min(begin, a[j] - sum);\\n                            if (first) {\\n                                first = false;\\n                            } else {\\n                                res++;\\n                            }\\n                            begin -= a[j] - sum;\\n                            sum = 0;\\n                            if (begin < 0) {\\n                                break;\\n                            }\\n                        }\\n                    }\\n                }\\n            }\\n            out.println(res);\\n        }\\n\\n   ...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Some number of people (this number is even) have stood in a circle. The people stand in the circle evenly. They are numbered clockwise starting from a person with the number 1. Each person is looking through the circle's center at the opposite person.\\n\\n<image> A sample of a circle of 6 persons. The orange arrows indicate who is looking at whom.\\n\\nYou don't know the exact number of people standing in the circle (but this number is even, no doubt). It is known that the person with the number a is looking at the person with the number b (and vice versa, of course). What is the number associated with a person being looked at by the person with the number c? If, for the specified a, b, and c, no such circle exists, output -1.\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases. Then t test cases follow.\\n\\nEach test case consists of one line containing three distinct integers a, b, c (1 \u2264 a,b,c \u2264 10^8).\\n\\nOutput\\n\\nFor each test case output in a separate line a single integer d \u2014 the number of the person being looked at by the person with the number c in a circle such that the person with the number a is looking at the person with the number b. If there are multiple solutions, print any of them. Output -1 if there's no circle meeting the given conditions.\\n\\nExample\\n\\nInput\\n\\n\\n7\\n6 2 4\\n2 3 1\\n2 4 10\\n5 3 4\\n1 3 2\\n2 5 4\\n4 3 2\\n\\n\\nOutput\\n\\n\\n8\\n-1\\n-1\\n-1\\n4\\n1\\n-1\\n\\nNote\\n\\nIn the first test case, there's a desired circle of 8 people. The person with the number 6 will look at the person with the number 2 and the person with the number 8 will look at the person with the number 4.\\n\\nIn the second test case, there's no circle meeting the conditions. If the person with the number 2 is looking at the person with the number 3, the circle consists of 2 people because these persons are neighbors. But, in this case, they must have the numbers 1 and 2, but it doesn't meet the problem's conditions.\\n\\nIn the third test case, the only circle with the persons with the numbers 2 and 4 looking at each other consists of 4...\\nSolve the task in JAVA.\",\"targets\":\"\\/\\/package godiji;\\n\\nimport java.util.Scanner;\\nimport java.util.Stack;\\nimport java.util.StringTokenizer;\\nimport java.util.TreeMap;\\n\\nimport java.io.BufferedReader;\\nimport java.io.BufferedWriter;\\nimport java.io.FileWriter;\\nimport java.io.IOException;\\nimport java.io.InputStreamReader;\\nimport java.math.BigInteger;\\nimport java.util.ArrayList;\\nimport java.util.Arrays;\\nimport java.util.Collections;\\nimport java.util.Comparator;\\nimport java.util.HashMap;\\nimport java.util.HashSet;\\nimport java.util.Iterator;\\nimport java.util.LinkedList;\\nimport java.util.PriorityQueue;\\n\\npublic class pac1 {\\n\\tstatic Scanner scn = new Scanner(System.in);\\n\\tstatic long mod = 1000000007;\\n\\n\\tpublic static void main(String[] args) {\\n\\t\\tint t = scn.nextInt();\\n\\t\\twhile (t-- > 0) \\n\\t\\t{\\n\\t\\t\\tint a=scn.nextInt(),b=scn.nextInt(),c=scn.nextInt();\\n\\t\\t\\tint diff=Math.abs(b-a),k=diff;\\n\\t\\t\\tdiff*=2;\\n\\t\\t\\tif(a>diff||b>diff||c>diff)\\n\\t\\t\\t\\tSystem.out.println(\\\"-1\\\");\\n\\t\\t\\telse\\n\\t\\t\\t{\\tif(c+k<=diff)\\n\\t\\t\\t\\tSystem.out.println((c+k));\\n\\t\\t\\t\\telse\\n\\t\\t\\t\\t\\tSystem.out.println((c+k)%diff);\\n\\t\\t\\t}\\n\\t\\t}\\n\\n\\t}\\n\\n\\tpublic static long coin(int arr[], int i, int j, int count) {\\n\\t\\tif (count == arr.length || i == arr.length) {\\n\\t\\t\\treturn 0;\\n\\t\\t}\\n\\t\\tif (i > arr.length || j < 0)\\n\\t\\t\\treturn Integer.MIN_VALUE;\\n\\n\\t\\tlong a = 0, b = 0, c = 0, d = 0;\\n\\t\\tif (count % 2 == 0)\\n\\t\\t\\ta = coin(arr, i + 1, j, count + 1) + arr[i];\\n\\t\\tif (count % 2 == 0)\\n\\t\\t\\tb = coin(arr, i, j - 1, count + 1) + arr[j];\\n\\n\\t\\tif (count % 2 != 0)\\n\\t\\t\\tc = coin(arr, i + 1, j, count + 1);\\n\\t\\tif (count % 2 != 0)\\n\\t\\t\\td = coin(arr, i, j - 1, count + 1);\\n\\n\\t\\treturn Math.max(a, Math.max(b, Math.max(c, d)));\\n\\n\\t}\\n\\n\\tpublic static int gcd(int a, int n) {\\n\\n\\t\\tif (a == 0)\\n\\t\\t\\treturn n;\\n\\t\\treturn gcd(n % a, a);\\n\\t}\\n\\n\\tpublic static boolean[] sieveOfEratosthenes(int n) {\\n\\n\\t\\tboolean prime[] = new boolean[n + 1];\\n\\t\\tfor (int i = 0; i < n; i++)\\n\\t\\t\\tprime[i] = true;\\n\\n\\t\\tfor (int p = 2; p * p <= n; p++) {\\n\\t\\t\\t\\/\\/ If prime[p] is not changed, then it is a prime\\n\\t\\t\\tif (prime[p] == true) {\\n\\t\\t\\t\\t\\/\\/ Update all multiples of p\\n\\t\\t\\t\\tfor (int i = p * p; i <= n; i += p)\\n\\t\\t\\t\\t\\tprime[i] = false;\\n\\t\\t\\t}\\n\\t\\t}\\n\\n\\t\\tfor...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Arseniy is already grown-up and independent. His mother decided to leave him alone for m days and left on a vacation. She have prepared a lot of food, left some money and washed all Arseniy's clothes. \\n\\nTen minutes before her leave she realized that it would be also useful to prepare instruction of which particular clothes to wear on each of the days she will be absent. Arseniy's family is a bit weird so all the clothes is enumerated. For example, each of Arseniy's n socks is assigned a unique integer from 1 to n. Thus, the only thing his mother had to do was to write down two integers li and ri for each of the days \u2014 the indices of socks to wear on the day i (obviously, li stands for the left foot and ri for the right). Each sock is painted in one of k colors.\\n\\nWhen mother already left Arseniy noticed that according to instruction he would wear the socks of different colors on some days. Of course, that is a terrible mistake cause by a rush. Arseniy is a smart boy, and, by some magical coincidence, he posses k jars with the paint \u2014 one for each of k colors.\\n\\nArseniy wants to repaint some of the socks in such a way, that for each of m days he can follow the mother's instructions and wear the socks of the same color. As he is going to be very busy these days he will have no time to change the colors of any socks so he has to finalize the colors now.\\n\\nThe new computer game Bota-3 was just realised and Arseniy can't wait to play it. What is the minimum number of socks that need their color to be changed in order to make it possible to follow mother's instructions and wear the socks of the same color during each of m days.\\n\\nInput\\n\\nThe first line of input contains three integers n, m and k (2 \u2264 n \u2264 200 000, 0 \u2264 m \u2264 200 000, 1 \u2264 k \u2264 200 000) \u2014 the number of socks, the number of days and the number of available colors respectively.\\n\\nThe second line contain n integers c1, c2, ..., cn (1 \u2264 ci \u2264 k) \u2014 current colors of Arseniy's socks.\\n\\nEach of the following m lines contains two integers li and ri (1 \u2264 li, ri \u2264 n, li \u2260...\\nSolve the task in JAVA.\",\"targets\":\"\\/\\/package Codeforces_contest;\\n\\/**\\n *\\n * @author Abhishek\\n *\\/\\nimport java.io.*;\\nimport java.util.*;\\n\\npublic class R376Divison2C {\\n\\n    InputStream obj;\\n    PrintWriter out;\\n    String check = \\\"\\\";\\n\\n    \\/\\/Solution !!\\n    void solution() {\\n        int n = inti(), m = inti(), k = inti();\\n        int color[] = arri(n);\\n        int from[] = new int[m];\\n        int to[] = new int[m];\\n        for (int i = 0; i < m; i++) {\\n            from[i] = inti() - 1;\\n            to[i] = inti() - 1;\\n        }\\n        visit = new boolean[n];\\n        int g[][] = packU(n, from, to);\\n        int sum = 0;\\n        for (int i = 0; i < n; i++) {\\n            int max = 0;\\n            if (!visit[i]) {\\n                al = new ArrayList<>();\\n                bfs(g, i);\\n\\/\\/                pa(visit);\\n                HashMap<Integer, Integer> hm = new HashMap<>();\\n\\/\\/                System.out.println(al);\\n                for (int j = 0; j < al.size(); j++) {\\n                    if (hm.containsKey(color[al.get(j)])) {\\n                        int u = hm.get(color[al.get(j)]);\\n                        hm.put(color[al.get(j)], u + 1);\\n                        max = Math.max(max, u + 1);\\n                    } else {\\n                        hm.put(color[al.get(j)], 1);\\n                        max = Math.max(max, 1);\\n                    }\\n                }\\n                sum += max;\\n            }\\n        }\\n        out.println(n - sum);\\n    }\\n\\n    static int[][] packU(int n, int[] from, int[] to) {\\n        int[][] g = new int[n][];\\n        int[] p = new int[n];\\n        for (int f : from) {\\n            p[f]++;\\n        }\\n        for (int t : to) {\\n            p[t]++;\\n        }\\n        for (int i = 0; i < n; i++) {\\n            g[i] = new int[p[i]];\\n        }\\n        for (int i = 0; i < from.length; i++) {\\n            g[from[i]][--p[from[i]]] = to[i];\\n            g[to[i]][--p[to[i]]] = from[i];\\n        }\\n        return g;\\n    }\\n    ArrayList<Integer> al;\\n    boolean visit[];\\n\\n    void bfs(int[][] graph, int source) {\\n        visit[source] = true;\\n       ...\",\"language\":\"python\",\"split\":\"train\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in CPP?\\nAccording to the last order issued by the president of Berland every city of the country must have its own Ministry Defense building (their own Pentagon). A megapolis Berbourg was not an exception. This city has n junctions, some pairs of which are connected by two-way roads. Overall there are m roads in the city, no more than one between each pair of junctions.\\n\\nAt the moment choosing a location place for Pentagon in Berbourg is being discussed. It has been decided that Pentagon should cover the territory of five different junctions which are joined into a cycle by roads. In the order to build Pentagon a special wall will be built along the roads (with high-tension razor, high-voltage wire and other attributes). Thus, the number of possible ways of building Pentagon in the city is equal to the number of different cycles at lengths of 5, composed of junctions and roads.\\n\\nYour task is to prints the number of ways of building Pentagon in Berbourg. Only well-optimized solutions will be accepted. Please, test your code on the maximal testcase.\\n\\nInput\\n\\nThe first line contains two integers n and m (1 \u2264 n \u2264 700;0 \u2264 m \u2264 n\u00b7(n - 1) \\/ 2), where n represents the number of junctions and m is the number of roads in the city. Then follow m lines containing the road descriptions, one in each line. Every road is set by a number of integers ai, bi (1 \u2264 ai, bi \u2264 n;ai \u2260 bi), where ai and bi represent the numbers of junctions, connected by the road. The junctions are numbered from 1 to n. It is not guaranteed that from any junction one can get to any other one moving along the roads.\\n\\nOutput\\n\\nPrint the single number which represents the required number of ways. Please, do not use %lld specificator to read or write 64-bit integers in C++. It is preffered to use cout (also you may use %I64d).\\n\\nExamples\\n\\nInput\\n\\n5 5\\n1 2\\n2 3\\n3 4\\n4 5\\n5 1\\n\\n\\nOutput\\n\\n1\\n\\n\\nInput\\n\\n5 10\\n1 2\\n1 3\\n1 4\\n1 5\\n2 3\\n2 4\\n2 5\\n3 4\\n3 5\\n4 5\\n\\n\\nOutput\\n\\n12\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\ntemplate <class T>\\nT abs(T x) {\\n  return x > 0 ? x : (-x);\\n}\\ntemplate <class T>\\nT sqr(T x) {\\n  return x * x;\\n}\\nconst int maxn = 710;\\nlong long a[6][maxn][maxn];\\nint n;\\nvector<vector<int> > vt;\\nint main() {\\n  memset(a, 0, sizeof(a));\\n  int m;\\n  cin >> n >> m;\\n  for (int i = 0; i < m; ++i) {\\n    int x, y;\\n    scanf(\\\"%d%d\\\", &x, &y);\\n    --x, --y;\\n    a[0][x][y] = a[0][y][x] = 1;\\n  }\\n  for (int t = 1; t < 5; ++t) {\\n    for (int i = 0; i < n; ++i)\\n      for (int j = i; j < n; ++j) {\\n        for (int k = 0; k < n; ++k) a[t][i][j] += a[t - 1][i][k] * a[0][j][k];\\n        a[t][j][i] = a[t][i][j];\\n      }\\n  }\\n  long long res = 0;\\n  for (int i = 0; i < n; ++i) res += a[4][i][i];\\n  res \\/= 5LL;\\n  for (int i = 0; i < 2; ++i)\\n    for (int t = 0; t < n; ++t) res -= a[i][t][t] * a[3 - i][t][t];\\n  for (int i = 0; i < n; ++i)\\n    for (int j = 0; j < n; ++j)\\n      for (int k = 0; k < n; ++k)\\n        if (a[0][i][j] && a[0][i][k] && a[0][j][k]) ++res;\\n  res \\/= 2LL;\\n  cout << res << \\\"\\\\n\\\";\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"El Psy Kongroo.\\n\\nOmkar is watching Steins;Gate.\\n\\nIn Steins;Gate, Okabe Rintarou needs to complete n tasks (1 \u2264 n \u2264 2 \u22c5 10^5). Unfortunately, he doesn't know when he needs to complete the tasks.\\n\\nInitially, the time is 0. Time travel will now happen according to the following rules:\\n\\n  * For each k = 1, 2, \u2026, n, Okabe will realize at time b_k that he was supposed to complete the k-th task at time a_k (a_k < b_k). \\n\\n  * When he realizes this, if k-th task was already completed at time a_k, Okabe keeps the usual flow of time. Otherwise, he time travels to time a_k then immediately completes the task.\\n\\n  * If Okabe time travels to time a_k, all tasks completed after this time will become incomplete again. That is, for every j, if a_j>a_k, the j-th task will become incomplete, if it was complete (if it was incomplete, nothing will change).\\n\\n  * Okabe has bad memory, so he can time travel to time a_k only immediately after getting to time b_k and learning that he was supposed to complete the k-th task at time a_k. That is, even if Okabe already had to perform k-th task before, he wouldn't remember it before stumbling on the info about this task at time b_k again.\\n\\n\\n\\n\\nPlease refer to the notes for an example of time travelling.\\n\\nThere is a certain set s of tasks such that the first moment that all of the tasks in s are simultaneously completed (regardless of whether any other tasks are currently completed), a funny scene will take place. Omkar loves this scene and wants to know how many times Okabe will time travel before this scene takes place. Find this number modulo 10^9 + 7. It can be proven that eventually all n tasks will be completed and so the answer always exists.\\n\\nInput\\n\\nThe first line contains an integer n (1 \u2264 n \u2264 2 \u22c5 10^5) \u2014 the number of tasks that Okabe needs to complete.\\n\\nn lines follow. The k-th of these lines contain two integers a_k and b_k (1 \u2264 a_k < b_k \u2264 2n) \u2014 the time at which Okabe needs to complete the k-th task and the time that he realizes this respectively. All 2n of these times are...\\\":\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nchar buf[1 << 20], *p1, *p2;\\ninline int read() {\\n  int s = 0, f = 1;\\n  char x = getchar();\\n  while (!isdigit(x)) f = (x == '-' ? -1 : 1), x = getchar();\\n  while (isdigit(x)) s = s * 10 + x - '0', x = getchar();\\n  return s * f;\\n}\\npair<int, int> a[200005];\\nint s[200005];\\nint c[400005];\\nconst int p = 1e9 + 7;\\nint n;\\nvoid mdf(int x, int k) {\\n  for (int i = x; i <= 2 * n; i += (i & -i)) c[i] = (c[i] + k) % p;\\n}\\nint query(int x) {\\n  int ans = 0;\\n  for (int i = x; i; i -= (i & -i)) ans = (ans + c[i]) % p;\\n  return ans;\\n}\\nbool ins[400005];\\nint main() {\\n  n = read();\\n  for (int i = 1; i <= n; i++) {\\n    int x = read(), y = read();\\n    a[i] = make_pair(x, y);\\n  }\\n  int m = read();\\n  for (int i = 1; i <= m; i++) s[i] = read(), ins[a[s[i]].first] = 1;\\n  sort(s + 1, s + m + 1,\\n       [](int x, int y) { return a[x].second < a[y].second; });\\n  int las = a[s[1]].first, mx = a[s[n]].second;\\n  sort(a + 1, a + n + 1,\\n       [](pair<int, int> x, pair<int, int> y) { return x.second < y.second; });\\n  for (int i = n; i >= 1; i--) {\\n    if (!ins[a[i].first]) {\\n      if (query(2 * n - a[i].first + 1)) ins[a[i].first] = 1;\\n    } else\\n      mdf(2 * n - a[i].first + 1, 1);\\n  }\\n  memset(c, 0, sizeof(c));\\n  for (int i = 1; i <= n; i++) {\\n    int f = (query(2 * n) - query(a[i].first) + p) % p;\\n    mdf(a[i].first, (f + 1) % p);\\n  }\\n  int ans = 0;\\n  for (int i = 1; i <= 2 * n; i++)\\n    if (ins[i]) ans = (ans + query(i) - query(i - 1)) % p, ans = (ans + p) % p;\\n  printf(\\\"%d\\\\n\\\", ans);\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"Andi and Budi were given an assignment to tidy up their bookshelf of n books. Each book is represented by the book title \u2014 a string s_i numbered from 1 to n, each with length m. Andi really wants to sort the book lexicographically ascending, while Budi wants to sort it lexicographically descending.\\n\\nSettling their fight, they decided to combine their idea and sort it asc-desc-endingly, where the odd-indexed characters will be compared ascendingly, and the even-indexed characters will be compared descendingly.\\n\\nA string a occurs before a string b in asc-desc-ending order if and only if in the first position where a and b differ, the following holds:\\n\\n  * if it is an odd position, the string a has a letter that appears earlier in the alphabet than the corresponding letter in b; \\n  * if it is an even position, the string a has a letter that appears later in the alphabet than the corresponding letter in b. \\n\\nInput\\n\\nThe first line contains two integers n and m (1 \u2264 n \u22c5 m \u2264 10^6).\\n\\nThe i-th of the next n lines contains a string s_i consisting of m uppercase Latin letters \u2014 the book title. The strings are pairwise distinct.\\n\\nOutput\\n\\nOutput n integers \u2014 the indices of the strings after they are sorted asc-desc-endingly.\\n\\nExample\\n\\nInput\\n\\n\\n5 2\\nAA\\nAB\\nBB\\nBA\\nAZ\\n\\n\\nOutput\\n\\n\\n5 2 1 3 4\\n\\nNote\\n\\nThe following illustrates the first example.\\n\\n<image>\\\":\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nvoid fast() {\\n  cin.tie(0);\\n  ios_base::sync_with_stdio(false);\\n}\\nlong long md = 1000000007;\\nbool fn(string l, string r) {\\n  for (int i = 1; i <= l.size(); i++) {\\n    if (l[i - 1] != r[i - 1]) {\\n      return (i % 2 && r[i - 1] < l[i - 1] ||\\n              i % 2 == 0 && r[i - 1] > l[i - 1]);\\n    }\\n  }\\n}\\nint main() {\\n  fast();\\n  int n, k;\\n  cin >> n >> k;\\n  vector<string> s;\\n  map<string, int> m;\\n  for (int i = 0; i < n; i++) {\\n    string a;\\n    cin >> a;\\n    s.push_back(a);\\n    m[a] = i + 1;\\n  }\\n  sort(s.begin(), s.end(), fn);\\n  reverse(s.begin(), s.end());\\n  for (auto i : s) {\\n    cout << m[i] << \\\" \\\";\\n  }\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You have an array of integers (initially empty).\\n\\nYou have to perform q queries. Each query is of one of two types: \\n\\n  * \\\"1 x\\\" \u2014 add the element x to the end of the array; \\n  * \\\"2 x y\\\" \u2014 replace all occurrences of x in the array with y. \\n\\n\\n\\nFind the resulting array after performing all the queries.\\n\\nInput\\n\\nThe first line contains a single integer q (1 \u2264 q \u2264 5 \u22c5 10^5) \u2014 the number of queries.\\n\\nNext q lines contain queries (one per line). Each query is of one of two types: \\n\\n  * \\\"1 x\\\" (1 \u2264 x \u2264 5 \u22c5 10^5); \\n  * \\\"2 x y\\\" (1 \u2264 x, y \u2264 5 \u22c5 10^5). \\n\\n\\n\\nIt's guaranteed that there is at least one query of the first type.\\n\\nOutput\\n\\nIn a single line, print k integers \u2014 the resulting array after performing all the queries, where k is the number of queries of the first type.\\n\\nExamples\\n\\nInput\\n\\n\\n7\\n1 3\\n1 1\\n2 1 2\\n1 2\\n1 1\\n1 2\\n2 1 3\\n\\n\\nOutput\\n\\n\\n3 2 2 3 2 \\n\\nInput\\n\\n\\n4\\n1 1\\n1 2\\n1 1\\n2 2 2\\n\\n\\nOutput\\n\\n\\n1 2 1 \\n\\nInput\\n\\n\\n8\\n2 1 4\\n1 1\\n1 4\\n1 2\\n2 2 4\\n2 4 3\\n1 2\\n2 2 7\\n\\n\\nOutput\\n\\n\\n1 3 3 7 \\n\\nNote\\n\\nIn the first example, the array changes as follows:\\n\\n[] \u2192 [3] \u2192 [3, 1] \u2192 [3, 2] \u2192 [3, 2, 2] \u2192 [3, 2, 2, 1] \u2192 [3, 2, 2, 1, 2] \u2192 [3, 2, 2, 3, 2].\\n\\nIn the second example, the array changes as follows:\\n\\n[] \u2192 [1] \u2192 [1, 2] \u2192 [1, 2, 1] \u2192 [1, 2, 1].\\n\\nIn the third example, the array changes as follows:\\n\\n[] \u2192 [] \u2192 [1] \u2192 [1, 4] \u2192 [1, 4, 2] \u2192 [1, 4, 4] \u2192 [1, 3, 3] \u2192 [1, 3, 3, 2] \u2192 [1, 3, 3, 7].\",\"targets\":\"import java.io.BufferedReader;\\nimport java.io.IOException;\\nimport java.io.InputStreamReader;\\nimport java.util.ArrayList;\\nimport java.util.StringTokenizer;\\n\\npublic class ReplaceTheNumbers {\\n\\t\\n\\tstatic class FastReader {\\n\\t\\t\\n        BufferedReader br;\\n        StringTokenizer st;\\n \\n        public FastReader()\\n        {\\n            br = new BufferedReader(\\n                new InputStreamReader(System.in));\\n        }\\n \\n        String next()\\n        {\\n            while (st == null || !st.hasMoreElements()) {\\n                try {\\n                    st = new StringTokenizer(br.readLine());\\n                }\\n                catch (IOException e) {\\n                    e.printStackTrace();\\n                }\\n            }\\n            return st.nextToken();\\n        }\\n \\n        int nextInt() { return Integer.parseInt(next()); }\\n \\n        long nextLong() { return Long.parseLong(next()); }\\n        \\n        double nextFloat() { return Float.parseFloat(next()); }\\n \\n        double nextDouble() { return Double.parseDouble(next()); }\\n \\n        String nextLine()\\n        {\\n            String str = \\\"\\\";\\n            try {\\n                str = br.readLine();\\n            }\\n            catch (IOException e) {\\n                e.printStackTrace();\\n            }\\n            return str;\\n        }\\n        \\n        int[] nextArray(int n)\\n        {\\n        \\tint[] a = new int[n];\\n        \\tfor (int i=0; i<n; i++) {\\n        \\t\\ta[i] = this.nextInt();\\n        \\t}\\n        \\treturn a;\\n        }\\n        \\n        long[] nextArrayLong(int n)\\n        {\\n        \\tlong[] a = new long[n];\\n        \\tfor (int i=0; i<n; i++) {\\n        \\t\\ta[i] = this.nextLong();\\n        \\t}\\n        \\treturn a;\\n        }\\n        \\n    }\\n\\n\\tpublic static void solve(int q, String[] s) {\\n\\t\\t\\n\\t\\tArrayList<Integer> list = new ArrayList<Integer>();\\n\\t\\tint[] hm = new int[500001];\\n\\t\\tfor (int i=0; i<500001; i++) {\\n\\t\\t\\thm[i] = i;\\n\\t\\t}\\n\\t\\tStringBuilder ans = new StringBuilder();\\n\\t\\tfor (int i=q-1; i>=0 ;i--) {\\n\\t\\t\\tString[] query = s[i].split(\\\" \\\");\\n\\t\\t\\tif (Integer.parseInt(query[0]) == 1) {\\n\\t\\t\\t\\tint num =...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Let's define S(x) to be the sum of digits of number x written in decimal system. For example, S(5) = 5, S(10) = 1, S(322) = 7.\\n\\nWe will call an integer x interesting if S(x + 1) < S(x). In each test you will be given one integer n. Your task is to calculate the number of integers x such that 1 \u2264 x \u2264 n and x is interesting.\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 1000) \u2014 number of test cases.\\n\\nThen t lines follow, the i-th line contains one integer n (1 \u2264 n \u2264 10^9) for the i-th test case.\\n\\nOutput\\n\\nPrint t integers, the i-th should be the answer for the i-th test case.\\n\\nExample\\n\\nInput\\n\\n\\n5\\n1\\n9\\n10\\n34\\n880055535\\n\\n\\nOutput\\n\\n\\n0\\n1\\n1\\n3\\n88005553\\n\\nNote\\n\\nThe first interesting number is equal to 9.\\nt=int\",\"targets\":\"(input())\\na=[]\\nfor i in range(t):\\n    a.append(int(input()))\\nfor elem in a:\\n    z=int(elem) +1\\n    y=int(z\\/10)\\n    print(y)\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"There are n heaps of stone. The i-th heap has h_i stones. You want to change the number of stones in the heap by performing the following process once: \\n\\n  * You go through the heaps from the 3-rd heap to the n-th heap, in this order. \\n  * Let i be the number of the current heap. \\n  * You can choose a number d (0 \u2264 3 \u22c5 d \u2264 h_i), move d stones from the i-th heap to the (i - 1)-th heap, and 2 \u22c5 d stones from the i-th heap to the (i - 2)-th heap. \\n  * So after that h_i is decreased by 3 \u22c5 d, h_{i - 1} is increased by d, and h_{i - 2} is increased by 2 \u22c5 d. \\n  * You can choose different or same d for different operations. Some heaps may become empty, but they still count as heaps. \\n\\n\\n\\nWhat is the maximum number of stones in the smallest heap after the process?\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 2\u22c5 10^5). Description of the test cases follows.\\n\\nThe first line of each test case contains a single integer n (3 \u2264 n \u2264 2 \u22c5 10^5).\\n\\nThe second lines of each test case contains n integers h_1, h_2, h_3, \u2026, h_n (1 \u2264 h_i \u2264 10^9).\\n\\nIt is guaranteed that the sum of n over all test cases does not exceed 2 \u22c5 10^5.\\n\\nOutput\\n\\nFor each test case, print the maximum number of stones that the smallest heap can contain.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n4\\n1 2 10 100\\n4\\n100 100 100 1\\n5\\n5 1 1 1 8\\n6\\n1 2 3 4 5 6\\n\\n\\nOutput\\n\\n\\n7\\n1\\n1\\n3\\n\\nNote\\n\\nIn the first test case, the initial heap sizes are [1, 2, 10, 100]. We can move the stones as follows. \\n\\n  * move 3 stones and 6 from the 3-rd heap to the 2-nd and 1 heap respectively. The heap sizes will be [7, 5, 1, 100]; \\n  * move 6 stones and 12 stones from the last heap to the 3-rd and 2-nd heap respectively. The heap sizes will be [7, 17, 7, 82]. \\n\\n\\n\\nIn the second test case, the last heap is 1, and we can not increase its size.\\n\\nIn the third test case, it is better not to move any stones.\\n\\nIn the last test case, the final achievable configuration of the heaps can be [3, 5, 3, 4, 3, 3].\\n\\/\\/ \u0939\u0930\",\"targets\":\"\u0939\u0930 \u092e\u0939\u093e\u0926\u0947\u0935\\nimport java.util.*;\\nimport java.lang.*;\\nimport java.io.*;\\nimport java.math.BigInteger;\\nimport java.text.DecimalFormat;\\n\\npublic final class Solution {\\n\\n    static int inf = Integer.MAX_VALUE;\\n    static long mod = 1000000000 + 7;\\n  \\n static void ne(Scanner sc, BufferedWriter op) throws Exception {\\n      int n=sc.nextInt();\\n      long[] arr= new long[n];\\n      for(int i=0;i<n;i++){\\n          arr[i]=sc.nextLong();\\n\\n      }\\n    \\/\\/   int[] arr= new int[n];\\n      long l=0;\\n      long r=1000000000;\\n      long ans=0;\\n      while(l<=r){\\n         long mid=(l+r)\\/2;\\n        \\/\\/  print(mid);\\n         if(check(mid,arr)){\\n            \\/\\/  print(mid);\\n             ans=mid;\\n             l=mid+1;\\n         }else{\\n             r=mid-1;\\n         }\\n      }\\n     \\n     op.write(ans+\\\"\\\\n\\\");\\n     \\n\\n }\\n\\n static boolean check(long val , long[] values){\\n    int n=values.length;\\n    long[] arr= new long[n];\\n    for(int i=0;i<n;i++){\\n        arr[i]=values[i];\\n    }\\n    for(int i=n-1;i>=2;i--){\\n        long d=(arr[i]-val)\\/3;\\n        if(d<0){\\n            continue;\\n        }\\n        if(values[i]>=3*d){\\n          arr[i]-=(3*d);\\n          arr[i-1]+=d;\\n          arr[i-2]+=(2*d);\\n\\n        }else{\\n            long dd=(values[i])\\/3;\\n            arr[i]-=(3*dd);\\n            arr[i-1]+=(dd);\\n            arr[i-2]+=(2*dd);\\n        }\\n\\n    }\\n    long min=(long)inf;\\n    for(int i=0;i<n;i++){\\n      min=Math.min(arr[i],min);\\n    }\\n    if(min>=val){\\n        return true;\\n    }\\n    return false;\\n\\n\\n\\n }\\n\\n\\n\\n  \\n    \\n  \\n\\n    public static void main(String[] args) throws Exception {\\n        BufferedWriter op = new BufferedWriter(new OutputStreamWriter(System.out));\\n        \\/\\/ Reader sc = new Reader();\\n     \\n        Scanner sc= new Scanner(System.in);\\n        int t = sc.nextInt();\\n        while (t-->0){ ne(sc, op); }\\n        \\n        \\/\\/ ne(sc,op);\\n           \\n                   \\n        op.flush();\\n    }\\n\\n    static void print(Object o) {\\n        System.out.println(String.valueOf(o));\\n    }\\n    static int[] toIntArr(String s){\\n        int[] val= new...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Petya has a rooted tree with an integer written on each vertex. The vertex 1 is the root. You are to answer some questions about the tree.\\n\\nA tree is a connected graph without cycles. A rooted tree has a special vertex called the root. The parent of a node v is the next vertex on the shortest path from v to the root.\\n\\nEach question is defined by three integers v, l, and k. To get the answer to the question, you need to perform the following steps: \\n\\n  * First, write down the sequence of all integers written on the shortest path from the vertex v to the root (including those written in the v and the root). \\n  * Count the number of times each integer occurs. Remove all integers with less than l occurrences. \\n  * Replace the sequence, removing all duplicates and ordering the elements by the number of occurrences in the original list in increasing order. In case of a tie, you can choose the order of these elements arbitrary. \\n  * The answer to the question is the k-th number in the remaining sequence. Note that the answer is not always uniquely determined, because there could be several orderings. Also, it is possible that the length of the sequence on this step is less than k, in this case the answer is -1. \\n\\n\\n\\nFor example, if the sequence of integers on the path from v to the root is [2, 2, 1, 7, 1, 1, 4, 4, 4, 4], l = 2 and k = 2, then the answer is 1.\\n\\nPlease answer all questions about the tree.\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 10^6). Description of the test cases follows.\\n\\nThe first line of each test case contains two integers n, q (1 \u2264 n, q \u2264 10^6) \u2014 the number of vertices in the tree and the number of questions.\\n\\nThe second line contains n integers a_1, a_2, \u2026, a_n (1 \u2264 a_i \u2264 n), where a_i is the number written on the i-th vertex.\\n\\nThe third line contains n-1 integers p_2, p_3, \u2026, p_n (1 \u2264 p_i \u2264 n), where p_i is the parent of node i. It's guaranteed that the values p define a correct tree.\\n\\nEach of the next q lines contains three...\\n#incl\",\"targets\":\"ude <bits\\/stdc++.h>\\nusing namespace std;\\nusing ull = unsigned long long;\\nusing ll = long long;\\nusing pii = pair<int, int>;\\nusing vi = vector<int>;\\ntemplate <typename T>\\nusing min_heap = priority_queue<T, vector<T>, greater<T>>;\\nconst int N = 1e6 + 6;\\nint n, q, a[N], p[N], inv[N], lb[N], cnt[N], ans[N];\\nvector<int> g[N];\\nvector<tuple<int, int, int>> queries[N];\\nvoid increase(int x) {\\n  int y = inv[lb[cnt[x] + 1] - 1];\\n  swap(p[x], p[y]);\\n  swap(inv[p[x]], inv[p[y]]);\\n  ++cnt[x];\\n  --lb[cnt[x]];\\n}\\nvoid decrease(int x) {\\n  int y = inv[lb[cnt[x]]];\\n  swap(p[x], p[y]);\\n  swap(inv[p[x]], inv[p[y]]);\\n  ++lb[cnt[x]];\\n  --cnt[x];\\n}\\nvoid dfs(int u) {\\n  increase(a[u]);\\n  for (auto [id, l, k] : queries[u]) {\\n    int x = lb[l] + k - 1;\\n    ans[id] = (x > n) ? -1 : inv[x];\\n  }\\n  for (int v : g[u]) {\\n    dfs(v);\\n  }\\n  decrease(a[u]);\\n}\\nvoid solve() {\\n  cin >> n >> q;\\n  for (int i = 1; i <= n; ++i) {\\n    cin >> a[i];\\n    g[i].clear();\\n    queries[i].clear();\\n    p[i] = i;\\n    inv[i] = i;\\n    lb[i] = n + 1;\\n    cnt[i] = 0;\\n  }\\n  for (int i = 2, p; i <= n; ++i) {\\n    cin >> p;\\n    g[p].emplace_back(i);\\n  }\\n  for (int i = 1, v, l, k; i <= q; ++i) {\\n    cin >> v >> l >> k;\\n    queries[v].emplace_back(i, l, k);\\n  }\\n  dfs(1);\\n  for (int i = 1; i <= q; ++i) {\\n    cout << ans[i] << \\\" \\\\n\\\"[i == q];\\n  }\\n}\\nint main() {\\n  ios::sync_with_stdio(false);\\n  cin.tie(0);\\n  int T;\\n  cin >> T;\\n  while (T--) {\\n    solve();\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"As their story unravels, a timeless tale is told once again...\\n\\nShirahime, a friend of Mocha's, is keen on playing the music game Arcaea and sharing Mocha interesting puzzles to solve. This day, Shirahime comes up with a new simple puzzle and wants Mocha to solve them. However, these puzzles are too easy for Mocha to solve, so she wants you to solve them and tell her the answers. The puzzles are described as follow.\\n\\nThere are n squares arranged in a row, and each of them can be painted either red or blue.\\n\\nAmong these squares, some of them have been painted already, and the others are blank. You can decide which color to paint on each blank square.\\n\\nSome pairs of adjacent squares may have the same color, which is imperfect. We define the imperfectness as the number of pairs of adjacent squares that share the same color.\\n\\nFor example, the imperfectness of \\\"BRRRBBR\\\" is 3, with \\\"BB\\\" occurred once and \\\"RR\\\" occurred twice.\\n\\nYour goal is to minimize the imperfectness and print out the colors of the squares after painting. \\n\\nInput\\n\\nEach test contains multiple test cases. \\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 100) \u2014 the number of test cases. Each test case consists of two lines.\\n\\nThe first line of each test case contains an integer n (1\u2264 n\u2264 100) \u2014 the length of the squares row.\\n\\nThe second line of each test case contains a string s with length n, containing characters 'B', 'R' and '?'. Here 'B' stands for a blue square, 'R' for a red square, and '?' for a blank square.\\n\\nOutput\\n\\nFor each test case, print a line with a string only containing 'B' and 'R', the colors of the squares after painting, which imperfectness is minimized. If there are multiple solutions, print any of them.\\n\\nExample\\n\\nInput\\n\\n\\n5\\n7\\n?R???BR\\n7\\n???R???\\n1\\n?\\n1\\nB\\n10\\n?R??RB??B?\\n\\n\\nOutput\\n\\n\\nBRRBRBR\\nBRBRBRB\\nB\\nB\\nBRRBRBBRBR\\n\\nNote\\n\\nIn the first test case, if the squares are painted \\\"BRRBRBR\\\", the imperfectness is 1 (since squares 2 and 3 have the same color), which is the minimum possible imperfectness.\\nThe above is tricky. Write me a correct solution in PYTHON3.\",\"targets\":\"numcases = int(input(\\\"\\\"))\\ncase = 'BRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBRBR'\\nfor i in range(numcases):\\n    n = int(input(\\\"\\\"))\\n    squares = input('')\\n    squares = [i for i in squares]\\n    numSym = 0\\n    res = ''\\n\\n    for i in squares:\\n        if i == '?':\\n            numSym += 1\\n\\n    if numSym == n:\\n        res = case[:n]\\n        numSym = 0\\n\\n    while numSym != 0:\\n        for i in range(n):\\n            if i == 0:\\n                if squares[i] == 'B' and squares[i+1] == '?':\\n                    squares[i+1] = 'R'\\n                    numSym -= 1\\n                elif squares[i] == 'R' and squares[i+1] == '?':\\n\\n                    squares[i+1] = 'B'\\n                    numSym -= 1\\n            elif i == n-1:\\n                if squares[i] == 'B' and squares[i-1] == '?':\\n                 ...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"'In Boolean logic, a formula is in conjunctive normal form (CNF) or clausal normal form if it is a conjunction of clauses, where a clause is a disjunction of literals' (cited from https:\\/\\/en.wikipedia.org\\/wiki\\/Conjunctive_normal_form)\\n\\nIn the other words, CNF is a formula of type <image>, where & represents a logical \\\"AND\\\" (conjunction), <image> represents a logical \\\"OR\\\" (disjunction), and vij are some boolean variables or their negations. Each statement in brackets is called a clause, and vij are called literals.\\n\\nYou are given a CNF containing variables x1, ..., xm and their negations. We know that each variable occurs in at most two clauses (with negation and without negation in total). Your task is to determine whether this CNF is satisfiable, that is, whether there are such values of variables where the CNF value is true. If CNF is satisfiable, then you also need to determine the values of the variables at which the CNF is true. \\n\\nIt is guaranteed that each variable occurs at most once in each clause.\\n\\nInput\\n\\nThe first line contains integers n and m (1 \u2264 n, m \u2264 2\u00b7105) \u2014 the number of clauses and the number variables, correspondingly.\\n\\nNext n lines contain the descriptions of each clause. The i-th line first contains first number ki (ki \u2265 1) \u2014 the number of literals in the i-th clauses. Then follow space-separated literals vij (1 \u2264 |vij| \u2264 m). A literal that corresponds to vij is x|vij| either with negation, if vij is negative, or without negation otherwise.\\n\\nOutput\\n\\nIf CNF is not satisfiable, print a single line \\\"NO\\\" (without the quotes), otherwise print two strings: string \\\"YES\\\" (without the quotes), and then a string of m numbers zero or one \u2014 the values of variables in satisfying assignment in the order from x1 to xm.\\n\\nExamples\\n\\nInput\\n\\n2 2\\n2 1 -2\\n2 2 -1\\n\\n\\nOutput\\n\\nYES\\n11\\n\\n\\nInput\\n\\n4 3\\n1 1\\n1 2\\n3 -1 -2 3\\n1 -3\\n\\n\\nOutput\\n\\nNO\\n\\n\\nInput\\n\\n5 6\\n2 1 2\\n3 1 -2 3\\n4 -3 5 4 6\\n2 -6 -4\\n1 5\\n\\n\\nOutput\\n\\nYES\\n100010\\n\\nNote\\n\\nIn the first sample test formula is <image>. One of possible answer is x1 = TRUE, x2 = TRUE.\\n#incl\",\"targets\":\"ude <bits\\/stdc++.h>\\n#pragma GCC optimize(\\\"O3\\\")\\n#pragma GCC target(\\\"sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx\\\")\\nusing namespace std;\\nint a, b, c, d, n, m, k;\\nvector<int> dis[200002];\\nvector<pair<int, int> > pos[200002];\\nvector<pair<int, int> > sm[200002];\\nbool cool[200002];\\nint ans[200002];\\nbool used[200002];\\ninline int gv(int v, int t) {\\n  int p = 0;\\n  if (pos[t][0].first != v) {\\n    p = 1;\\n  }\\n  return pos[t][p].second;\\n}\\nvoid dfs(int v) {\\n  if (used[v]) return;\\n  used[v] = 1;\\n  for (int _n(((int)((sm[v]).size())) - 1), i(0); i <= _n; i++) {\\n    int w = sm[v][i].first;\\n    if (used[w]) continue;\\n    if (cool[w]) {\\n      dfs(w);\\n      continue;\\n    }\\n    int t = sm[v][i].second;\\n    if (ans[t] != -1) {\\n      dfs(w);\\n      continue;\\n    }\\n    if (gv(v, t)) {\\n      ans[t] = 0;\\n    } else {\\n      ans[t] = 1;\\n    }\\n    dfs(w);\\n  }\\n}\\nvector<int> was;\\nbool dfs2(int v, vector<int>& cycle, int pr = -1) {\\n  if (used[v]) return 0;\\n  used[v] = 1;\\n  cycle.push_back(v);\\n  was.push_back(v);\\n  for (int _n(((int)((sm[v]).size())) - 1), i(0); i <= _n; i++) {\\n    int w = sm[v][i].first;\\n    if (sm[v][i].second == pr) continue;\\n    if (used[w]) {\\n      for (int _n(((int)((was).size())) - 1), j(0); j <= _n; j++)\\n        used[was[j]] = 0;\\n      reverse((cycle).begin(), (cycle).end());\\n      while (cycle.back() != w) {\\n        cycle.pop_back();\\n      }\\n      return 1;\\n    }\\n    if (dfs2(w, cycle, sm[v][i].second)) return 1;\\n  }\\n  cycle.pop_back();\\n  return 0;\\n}\\nint main() {\\n  memset(ans, -1, sizeof(ans));\\n  scanf(\\\"%d%d\\\", &n, &m);\\n  for (int _n((n)-1), i(0); i <= _n; i++) {\\n    scanf(\\\"%d\\\", &c);\\n    for (int _n((c)-1), j(0); j <= _n; j++) {\\n      scanf(\\\"%d\\\", &a);\\n      dis[i].push_back(a);\\n      pos[abs(a)].push_back(make_pair(i, a > 0));\\n    }\\n  }\\n  for (int _n((m)), i(1); i <= _n; i++) {\\n    if ((int)((pos[i]).size()) == 0) continue;\\n    if ((int)((pos[i]).size()) == 1) {\\n      cool[pos[i][0].first] = 1;\\n      if (pos[i][0].second == 1)\\n        ans[i] = 1;\\n      else\\n        ans[i] = 0;\\n      continue;\\n    }\\n    if (pos[i][0].second...\",\"language\":\"python\",\"split\":\"train\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Alice wants to send an important message to Bob. Message a = (a1, ..., an) is a sequence of positive integers (characters).\\n\\nTo compress the message Alice wants to use binary Huffman coding. We recall that binary Huffman code, or binary prefix code is a function f, that maps each letter that appears in the string to some binary string (that is, string consisting of characters '0' and '1' only) such that for each pair of different characters ai and aj string f(ai) is not a prefix of f(aj) (and vice versa). The result of the encoding of the message a1, a2, ..., an is the concatenation of the encoding of each character, that is the string f(a1)f(a2)... f(an). Huffman codes are very useful, as the compressed message can be easily and uniquely decompressed, if the function f is given. Code is usually chosen in order to minimize the total length of the compressed message, i.e. the length of the string f(a1)f(a2)... f(an).\\n\\nBecause of security issues Alice doesn't want to send the whole message. Instead, she picks some substrings of the message and wants to send them separately. For each of the given substrings ali... ari she wants to know the minimum possible length of the Huffman coding. Help her solve this problem.\\n\\nInput\\n\\nThe first line of the input contains the single integer n (1 \u2264 n \u2264 100 000) \u2014 the length of the initial message. The second line contains n integers a1, a2, ..., an (1 \u2264 ai \u2264 100 000) \u2014 characters of the message.\\n\\nNext line contains the single integer q (1 \u2264 q \u2264 100 000) \u2014 the number of queries.\\n\\nThen follow q lines with queries descriptions. The i-th of these lines contains two integers li and ri (1 \u2264 li \u2264 ri \u2264 n) \u2014 the position of the left and right ends of the i-th substring respectively. Positions are numbered from 1. Substrings may overlap in any way. The same substring may appear in the input more than once.\\n\\nOutput\\n\\nPrint q lines. Each line should contain a single integer \u2014 the minimum possible length of the Huffman encoding of the substring ali... ari.\\n\\nExample\\n\\nInput\\n\\n7\\n1 2 1 3 1 2...\\nSolve the task in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst int mx = 100009;\\nvector<int> fof;\\nvector<int> nf;\\nvector<int> nxt, pv;\\nvector<int> adp, ada;\\nvector<int> hvp, hva;\\nint mkans() {\\n  adp.clear();\\n  ada.clear();\\n  hvp.clear();\\n  hva.clear();\\n  int u = 0;\\n  int sm = 0;\\n  while (u != mx) {\\n    if (u != 0) {\\n      hvp.push_back(u);\\n      hva.push_back(nf[u]);\\n      assert(nf[u]);\\n    }\\n    u = nxt[u];\\n  }\\n  int ai = 0;\\n  int hi = 0;\\n  int mp;\\n  while (1) {\\n    if (ai == (int((adp).size())) && hi == (int((hvp).size()))) break;\\n    if (ai == (int((adp).size()))) {\\n      adp.push_back(hvp[hi]);\\n      ada.push_back(hva[hi]);\\n      ++hi;\\n      continue;\\n    }\\n    if (ai + 1 == (int((adp).size())) && ada[ai] == 1) {\\n      if (hi == (int((hvp).size()))) break;\\n      adp.push_back(hvp[hi]);\\n      ada.push_back(hva[hi]);\\n      ++hi;\\n      continue;\\n    }\\n    if (ai + 1 < (int((adp).size())) && adp[ai + 1] == adp[ai]) {\\n      ada[ai + 1] += ada[ai];\\n      ++ai;\\n      continue;\\n    }\\n    if (ada[ai] >= 2) {\\n      mp = ada[ai] \\/ 2;\\n      sm += mp * 2 * adp[ai];\\n      while (hi != (int((hvp).size())) && hvp[hi] <= 2 * adp[ai]) {\\n        adp.push_back(hvp[hi]);\\n        ada.push_back(hva[hi]);\\n        ++hi;\\n      }\\n      adp.push_back(2 * adp[ai]);\\n      ada.push_back(mp);\\n      ada[ai] -= 2 * mp;\\n      if (ada[ai] == 0) ++ai;\\n      continue;\\n    }\\n    sm += adp[ai] + adp[ai + 1];\\n    while (hi != (int((hvp).size())) && hvp[hi] <= adp[ai] + adp[ai + 1]) {\\n      adp.push_back(hvp[hi]);\\n      ada.push_back(hva[hi]);\\n      ++hi;\\n    }\\n    adp.push_back(adp[ai] + adp[ai + 1]);\\n    ada.push_back(1);\\n    --ada[ai + 1];\\n    ++ai;\\n    if (ada[ai] == 0) ++ai;\\n  }\\n  return sm;\\n}\\nvoid ad(int u) {\\n  int ct = fof[u];\\n  ++fof[u];\\n  if (nf[ct + 1] == 0) {\\n    nxt[ct + 1] = nxt[ct];\\n    pv[nxt[ct]] = ct + 1;\\n    nxt[ct] = ct + 1;\\n    pv[ct + 1] = ct;\\n  }\\n  if (nf[ct] == 1) {\\n    pv[ct + 1] = pv[ct];\\n    nxt[pv[ct]] = ct + 1;\\n  }\\n  --nf[ct];\\n  ++nf[ct + 1];\\n}\\nvoid rm(int u) {\\n  int ct = fof[u];\\n  assert(ct);\\n  --fof[u];\\n  if (nf[ct - 1] == 0)...\",\"language\":\"python\",\"split\":\"train\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Petya has got an interesting flower. Petya is a busy person, so he sometimes forgets to water it. You are given n days from Petya's live and you have to determine what happened with his flower in the end.\\n\\nThe flower grows as follows: \\n\\n  * If the flower isn't watered for two days in a row, it dies. \\n  * If the flower is watered in the i-th day, it grows by 1 centimeter. \\n  * If the flower is watered in the i-th and in the (i-1)-th day (i > 1), then it grows by 5 centimeters instead of 1. \\n  * If the flower is not watered in the i-th day, it does not grow. \\n\\n\\n\\nAt the beginning of the 1-st day the flower is 1 centimeter tall. What is its height after n days?\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 100). Description of the test cases follows.\\n\\nThe first line of each test case contains the only integer n (1 \u2264 n \u2264 100).\\n\\nThe second line of each test case contains n integers a_1, a_2, ..., a_n (a_i = 0 or a_i = 1). If a_i = 1, the flower is watered in the i-th day, otherwise it is not watered.\\n\\nOutput\\n\\nFor each test case print a single integer k \u2014 the flower's height after n days, or -1, if the flower dies.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n3\\n1 0 1\\n3\\n0 1 1\\n4\\n1 0 0 1\\n1\\n0\\n\\n\\nOutput\\n\\n\\n3\\n7\\n-1\\n1\",\"targets\":\"import java.util.*;\\npublic class Main{\\n     public static void main(String args[]){\\n          Scanner sc=new Scanner(System.in);\\n          int t=sc.nextInt();\\n          for(int q=0;q<t;q++){\\n               int growth=1;\\n               int n=sc.nextInt();\\n               int a[]=new int[n];\\n               for(int i=0;i<n;i++)\\n                 a[i]=sc.nextInt();\\n               for(int i=0;i<n;i++){\\n                    if(a[i]==0){\\n                        if(i+1<a.length&&a[i+1]==0){\\n                            growth=-1;\\n                            break;\\n                        }\\n                    }\\n                      \\n                     else if(a[i]==1){\\n                          if(i-1>=0&&a[i-1]==1){\\n                               growth+=5;\\n                               \\n                          }\\n                          else\\n                              growth+=1;\\n                     }\\n               }\\n               System.out.println(growth);\\n          }\\n     }\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"The numbers 1,   2,   ...,   n \u22c5 k are colored with n colors. These colors are indexed by 1,   2,   ...,   n. For each 1 \u2264 i \u2264 n, there are exactly k numbers colored with color i.\\n\\nLet [a,   b] denote the interval of integers between a and b inclusive, that is, the set \\\\\\\\{a,   a + 1,   ...,   b\\\\}. You must choose n intervals [a_1,   b_1],   [a_2,   b_2],   ..., [a_n,   b_n] such that: \\n\\n  * for each 1 \u2264 i \u2264 n, it holds 1 \u2264 a_i < b_i \u2264 n \u22c5 k; \\n  * for each 1 \u2264 i \u2264 n, the numbers a_i and b_i are colored with color i; \\n  * each number 1 \u2264 x \u2264 n \u22c5 k belongs to at most \\\\left\u2308 (n)\\/(k - 1) \\\\right\u2309 intervals. \\n\\n\\n\\nOne can show that such a family of intervals always exists under the given constraints.\\n\\nInput\\n\\nThe first line contains two integers n and k (1 \u2264 n \u2264 100, 2 \u2264 k \u2264 100) \u2014 the number of colors and the number of occurrences of each color.\\n\\nThe second line contains n \u22c5 k integers c_1,   c_2,   ...,   c_{nk} (1 \u2264 c_j \u2264 n), where c_j is the color of number j. It is guaranteed that, for each 1 \u2264 i \u2264 n, it holds c_j = i for exactly k distinct indices j.\\n\\nOutput\\n\\nOutput n lines. The i-th line should contain the two integers a_i and b_i.\\n\\nIf there are multiple valid choices of the intervals, output any.\\n\\nExamples\\n\\nInput\\n\\n\\n4 3\\n2 4 3 1 1 4 2 3 2 1 3 4\\n\\n\\nOutput\\n\\n\\n4 5\\n1 7\\n8 11\\n6 12\\n\\nInput\\n\\n\\n1 2\\n1 1\\n\\n\\nOutput\\n\\n\\n1 2\\n\\n\\nInput\\n\\n\\n3 3\\n3 1 2 3 2 1 2 1 3\\n\\n\\nOutput\\n\\n\\n6 8\\n3 7\\n1 4\\n\\nInput\\n\\n\\n2 3\\n2 1 1 1 2 2\\n\\n\\nOutput\\n\\n\\n2 3\\n5 6\\n\\nNote\\n\\nIn the first sample, each number can be contained in at most \\\\left\u2308 (4)\\/(3 - 1) \\\\right\u2309 = 2 intervals. The output is described by the following picture:\\n\\n<image>\\n\\nIn the second sample, the only interval to be chosen is forced to be [1,   2], and each number is indeed contained in at most \\\\left\u2308 (1)\\/(2 - 1) \\\\right\u2309 = 1 interval.\\n\\nIn the third sample, each number can be contained in at most \\\\left\u2308 (3)\\/(3 - 1) \\\\right\u2309 = 2 intervals. The output is described by the following picture:\\n\\n<image>\\nUsing cpp can you solve the prior task?\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nvoid ProGamerMove() {\\n  int n, k;\\n  cin >> n >> k;\\n  vector<int> f(n * k), lst(n, -1), tmp((n + k - 2) \\/ (k - 1)), done(n);\\n  vector<pair<int, int>> res(n);\\n  multiset<int> can(tmp.begin(), tmp.end());\\n  int i = 0;\\n  for (int& v : f) {\\n    cin >> v;\\n    --v;\\n    if (~lst[v] && !done[v]) {\\n      int l = lst[v], r = i + 1;\\n      if (*can.begin() <= l) {\\n        res[v] = {l, r};\\n        can.erase(prev(can.lower_bound(l + 1)));\\n        can.insert(r);\\n        done[v] = true;\\n      }\\n    }\\n    lst[v] = i;\\n    ++i;\\n  }\\n  for (auto [l, r] : res) cout << l + 1 << \\\" \\\" << r << \\\"\\\\n\\\";\\n}\\nsigned main() {\\n  cin.tie(0)->sync_with_stdio(0);\\n  cin.exceptions(cin.failbit);\\n  int tc = 1;\\n  while (tc--) ProGamerMove();\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"A subarray of array a from index l to the index r is the array [a_l, a_{l+1}, ..., a_{r}]. The number of occurrences of the array b in the array a is the number of subarrays of a such that they are equal to b.\\n\\nYou are given n arrays A_1, A_2, ..., A_n; the elements of these arrays are integers from 1 to k. You have to build an array a consisting of m integers from 1 to k in such a way that, for every given subarray A_i, the number of occurrences of A_i in the array a is not less than the number of occurrences of each non-empty subarray of A_i in a. Note that if A_i doesn't occur in a, and no subarray of A_i occurs in a, this condition is still met for A_i.\\n\\nYour task is to calculate the number of different arrays a you can build, and print it modulo 998244353.\\n\\nInput\\n\\nThe first line contains three integers n, m and k (1 \u2264 n, m, k \u2264 3 \u22c5 10^5) \u2014 the number of the given arrays, the desired length of the array a, and the upper bound on the values in the arrays.\\n\\nThen n lines follow. The i-th line represents the array A_i. The first integer in the i-th line is c_i (1 \u2264 c_i \u2264 m) \u2014 the number of elements in A_i; then, c_i integers from 1 to k follow \u2014 the elements of the array A_i.\\n\\nAdditional constraint on the input: \u2211_{i=1}^n c_i \u2264 3 \u22c5 10^5; i. e., the number of elements in the given arrays in total does not exceed 3 \u22c5 10^5.\\n\\nOutput\\n\\nPrint one integer \u2014 the number of different arrays a you can build, taken modulo 998244353.\\n\\nExamples\\n\\nInput\\n\\n\\n2 4 3\\n2 1 2\\n1 3\\n\\n\\nOutput\\n\\n\\n5\\n\\n\\nInput\\n\\n\\n2 4 3\\n2 1 2\\n3 3 2 1\\n\\n\\nOutput\\n\\n\\n0\\n\\n\\nInput\\n\\n\\n1 42 1337\\n2 13 31\\n\\n\\nOutput\\n\\n\\n721234447\\nThe above is tricky. Write me a correct solution in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nauto rng = bind(uniform_int_distribution<int>(1, 10000), mt19937(time(0)));\\ntemplate <class T>\\nbool umin(T &a, const T &b) {\\n  return (a > b ? a = b, 1 : 0);\\n}\\ntemplate <class T>\\nbool umax(T &a, const T &b) {\\n  return (a < b ? a = b, 1 : 0);\\n}\\nconst int M = 998244353;\\nvoid add(int &a, int b) {\\n  a += b;\\n  if (a >= M)\\n    a -= M;\\n  else if (a < 0)\\n    a += M;\\n}\\nint mult(int a, int b) { return 1ll * a * b % M; }\\nint binpow(int a, int b) {\\n  int ans = 1;\\n  while (b) {\\n    if (b & 1) ans = mult(ans, a);\\n    b >>= 1;\\n    a = mult(a, a);\\n  }\\n  return ans;\\n}\\nconst int N = 3e5 + 1;\\nbool used[N];\\nint lft[N], rgt[N];\\nbool isr[N];\\nvector<int> pos[N];\\nbool bad[N];\\nvector<int> lengs;\\nint ways[N];\\nsigned main() {\\n  ios_base::sync_with_stdio(false);\\n  cin.tie(0);\\n  cout.tie(0);\\n  ;\\n  int n, m, k;\\n  cin >> n >> m >> k;\\n  vector<vector<int>> vc(n, vector<int>());\\n  for (int i = 0; i < n; i++) {\\n    int c;\\n    cin >> c;\\n    vector<int> a(c);\\n    for (int j = 0; j < c; j++) {\\n      cin >> a[j], used[a[j]] = 1;\\n      if ((int)pos[a[j]].size() && pos[a[j]].back() == i) {\\n        bad[a[j]] = 1;\\n      }\\n      pos[a[j]].push_back(i);\\n    }\\n    vc[i] = a;\\n    for (int j = 0; j < c; j++) {\\n      if (j > 0) {\\n        if (!lft[a[j]] || lft[a[j]] == a[j - 1]) {\\n          lft[a[j]] = a[j - 1];\\n        } else\\n          bad[a[j]] = 1;\\n      }\\n      if (j + 1 < c) {\\n        if (!rgt[a[j]] || rgt[a[j]] == a[j + 1]) {\\n          rgt[a[j]] = a[j + 1];\\n          continue;\\n        } else\\n          bad[a[j]] = 1;\\n      }\\n    }\\n  }\\n  queue<int> q;\\n  for (int i = 1; i <= k; i++) {\\n    if (bad[i]) q.push(i);\\n  }\\n  while (!q.empty()) {\\n    int x = q.front();\\n    q.pop();\\n    for (auto &j : pos[x]) {\\n      if (isr[j]) continue;\\n      isr[j] = 1;\\n      for (auto &v : vc[j]) {\\n        if (!bad[v]) {\\n          bad[v] = 1;\\n          q.push(v);\\n        }\\n      }\\n    }\\n  }\\n  for (int i = 1; i <= k; i++) {\\n    if (bad[i]) continue;\\n    if (!lft[i]) {\\n      int v = i;\\n      int cnt = 0;\\n      while (v) {\\n       ...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in CPP?\\nMocha wants to be an astrologer. There are n stars which can be seen in Zhijiang, and the brightness of the i-th star is a_i. \\n\\nMocha considers that these n stars form a constellation, and she uses (a_1,a_2,\u2026,a_n) to show its state. A state is called mathematical if all of the following three conditions are satisfied:\\n\\n  * For all i (1\u2264 i\u2264 n), a_i is an integer in the range [l_i, r_i].\\n  * \u2211  _{i=1} ^ n a_i \u2264 m.\\n  * \\\\gcd(a_1,a_2,\u2026,a_n)=1.\\n\\n\\n\\nHere, \\\\gcd(a_1,a_2,\u2026,a_n) denotes the [greatest common divisor (GCD)](https:\\/\\/en.wikipedia.org\\/wiki\\/Greatest_common_divisor) of integers a_1,a_2,\u2026,a_n.\\n\\nMocha is wondering how many different mathematical states of this constellation exist. Because the answer may be large, you must find it modulo 998 244 353.\\n\\nTwo states (a_1,a_2,\u2026,a_n) and (b_1,b_2,\u2026,b_n) are considered different if there exists i (1\u2264 i\u2264 n) such that a_i \u2260 b_i.\\n\\nInput\\n\\nThe first line contains two integers n and m (2 \u2264 n \u2264 50, 1 \u2264 m \u2264 10^5) \u2014 the number of stars and the upper bound of the sum of the brightness of stars.\\n\\nEach of the next n lines contains two integers l_i and r_i (1 \u2264 l_i \u2264 r_i \u2264 m) \u2014 the range of the brightness of the i-th star.\\n\\nOutput\\n\\nPrint a single integer \u2014 the number of different mathematical states of this constellation, modulo 998 244 353.\\n\\nExamples\\n\\nInput\\n\\n\\n2 4\\n1 3\\n1 2\\n\\n\\nOutput\\n\\n\\n4\\n\\nInput\\n\\n\\n5 10\\n1 10\\n1 10\\n1 10\\n1 10\\n1 10\\n\\n\\nOutput\\n\\n\\n251\\n\\nInput\\n\\n\\n5 100\\n1 94\\n1 96\\n1 91\\n4 96\\n6 97\\n\\n\\nOutput\\n\\n\\n47464146\\n\\nNote\\n\\nIn the first example, there are 4 different mathematical states of this constellation:\\n\\n  * a_1=1, a_2=1.\\n  * a_1=1, a_2=2.\\n  * a_1=2, a_2=1.\\n  * a_1=3, a_2=1.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst int max_m = 1e5 + 5;\\nbool mark_p[max_m];\\nint mu[max_m];\\nconst int max_cnt = 9592 + 5;\\nint prime[max_cnt], cnt;\\nconst int max_n = 50 + 5;\\nint l[max_n], r[max_n], L[max_n], R[max_n], dp[max_n][max_m], pre[max_n][max_m];\\nconst int mod = 998244353;\\ninline void add(int &a, int b) { a = a + b - (a + b >= mod ? mod : 0); }\\ninline void sub(int &a, int b) { a = a - b + (a < b ? mod : 0); }\\nint main() {\\n  int n, m;\\n  scanf(\\\"%d%d\\\", &n, &m);\\n  for (int i = 2; i <= m; ++i) mark_p[i] = true;\\n  mu[1] = 1;\\n  for (int i = 2; i <= m; ++i) {\\n    if (mark_p[i]) {\\n      prime[++cnt] = i;\\n      mu[i] = -1;\\n    }\\n    for (int j = 1; j <= cnt && 1ll * i * prime[j] <= m; ++j) {\\n      mark_p[i * prime[j]] = false;\\n      if (i % prime[j] == 0) {\\n        mu[i * prime[j]] = 0;\\n        break;\\n      }\\n      mu[i * prime[j]] = -mu[i];\\n    }\\n  }\\n  for (int i = 1; i <= n; ++i) scanf(\\\"%d%d\\\", l + i, r + i);\\n  int ans = 0;\\n  for (int d = 1; d <= m; ++d) {\\n    if (!mu[d]) continue;\\n    bool flag_break = false;\\n    int sL = 0;\\n    for (int i = 1; i <= n; ++i) {\\n      L[i] = (l[i] + d - 1) \\/ d;\\n      R[i] = r[i] \\/ d;\\n      if (L[i] > R[i]) {\\n        flag_break = true;\\n        break;\\n      }\\n      sL += L[i];\\n    }\\n    if (flag_break) continue;\\n    int M = m \\/ d;\\n    if (M < sL) continue;\\n    dp[0][0] = 1;\\n    for (int i = 0; i <= M; ++i) pre[0][i] = 1;\\n    for (int i = 1; i <= n; ++i)\\n      for (int j = 1; j <= M; ++j) {\\n        int l = j - R[i], r = j - L[i];\\n        if (r >= 0) dp[i][j] = pre[i - 1][r];\\n        if (l >= 1) sub(dp[i][j], pre[i - 1][l - 1]);\\n        pre[i][j] = pre[i][j - 1];\\n        add(pre[i][j], dp[i][j]);\\n      }\\n    int res = pre[n][M];\\n    if (mu[d] == 1)\\n      add(ans, res);\\n    else\\n      sub(ans, res);\\n  }\\n  printf(\\\"%d\\\\n\\\", ans);\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Polycarp has a string s. Polycarp performs the following actions until the string s is empty (t is initially an empty string):\\n\\n  * he adds to the right to the string t the string s, i.e. he does t = t + s, where t + s is a concatenation of the strings t and s; \\n  * he selects an arbitrary letter of s and removes from s all its occurrences (the selected letter must occur in the string s at the moment of performing this action). \\n\\n\\n\\nPolycarp performs this sequence of actions strictly in this order.\\n\\nNote that after Polycarp finishes the actions, the string s will be empty and the string t will be equal to some value (that is undefined and depends on the order of removing).\\n\\nE.g. consider s=\\\"abacaba\\\" so the actions may be performed as follows:\\n\\n  * t=\\\"abacaba\\\", the letter 'b' is selected, then s=\\\"aacaa\\\"; \\n  * t=\\\"abacabaaacaa\\\", the letter 'a' is selected, then s=\\\"c\\\"; \\n  * t=\\\"abacabaaacaac\\\", the letter 'c' is selected, then s=\\\"\\\" (the empty string). \\n\\n\\n\\nYou need to restore the initial value of the string s using only the final value of t and find the order of removing letters from s.\\n\\nInput\\n\\nThe first line contains one integer T (1 \u2264 T \u2264 10^4) \u2014 the number of test cases. Then T test cases follow.\\n\\nEach test case contains one string t consisting of lowercase letters of the Latin alphabet. The length of t doesn't exceed 5 \u22c5 10^5. The sum of lengths of all strings t in the test cases doesn't exceed 5 \u22c5 10^5.\\n\\nOutput\\n\\nFor each test case output in a separate line:\\n\\n  * -1, if the answer doesn't exist; \\n  * two strings separated by spaces. The first one must contain a possible initial value of s. The second one must contain a sequence of letters \u2014 it's in what order one needs to remove letters from s to make the string t. E.g. if the string \\\"bac\\\" is outputted, then, first, all occurrences of the letter 'b' were deleted, then all occurrences of 'a', and then, finally, all occurrences of 'c'. If there are multiple solutions, print any one....\\nUsing python3 can you solve the prior task?\",\"targets\":\"for input_number in range(int(input())):\\n    s = input()\\n    s = s[::-1]\\n    d = dict()\\n    for i in range(len(s)):\\n        d[s[i]] = d.get(s[i], 0) + 1\\n        \\n    s1 = ''.join([x for x in d])\\n    k = 0\\n    s2 = ''\\n    #print(s1, d)\\n    for i in range(len(d)):\\n        #print(i)\\n        if d[s1[i]] % (len(d) - i) != 0:\\n            print(-1)\\n            break\\n        c = 0\\n        #print(k)\\n        count = 0\\n        s3 = ''\\n        for j in range(len(s2) + d[s1[i]]\\/\\/(len(d) - i)):\\n            #print(s3, c)\\n            if s[k + j] == s1[i]:\\n                #print(1)\\n                s3 += s[k + j]\\n                count += 1\\n                if count > d[s1[i]]\\/\\/(len(d) - i):\\n                    break\\n            else:\\n                if c >= len(s2) or s[k + j] != s2[c]: break\\n                s3 += s[k + j]\\n                c += 1\\n                \\n        else:\\n            k += len(s2) + d[s1[i]] \\/\\/ (len(d) - i)\\n            s2 = s3\\n            continue\\n        print(-1)\\n        break\\n                \\n    else:\\n        print(s2[::-1], s1[::-1])\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"Mr. Chanek has an array a of n integers. The prettiness value of a is denoted as:\\n\\n$$$\u2211_{i=1}^{n} {\u2211_{j=1}^{n} {\\\\gcd(a_i, a_j) \u22c5 \\\\gcd(i, j)}}$$$\\n\\nwhere \\\\gcd(x, y) denotes the greatest common divisor (GCD) of integers x and y.\\n\\nIn other words, the prettiness value of an array a is the total sum of \\\\gcd(a_i, a_j) \u22c5 \\\\gcd(i, j) for all pairs (i, j).\\n\\nHelp Mr. Chanek find the prettiness value of a, and output the result modulo 10^9 + 7!\\n\\nInput\\n\\nThe first line contains an integer n (2 \u2264 n \u2264 10^5).\\n\\nThe second line contains n integers a_1, a_2, \u2026, a_n (1 \u2264 a_i \u2264 10^5).\\n\\nOutput\\n\\nOutput an integer denoting the prettiness value of a modulo 10^9 + 7.\\n\\nExample\\n\\nInput\\n\\n\\n5\\n3 6 2 1 4\\n\\n\\nOutput\\n\\n\\n77\\\":\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\ntemplate <typename T>\\nvoid _do(vector<T> x) {\\n  for (auto i : x) cerr << i << ' ';\\n  cerr << \\\"\\\\n\\\";\\n}\\ntemplate <typename T>\\nvoid _do(set<T> x) {\\n  for (auto i : x) cerr << i << ' ';\\n  cerr << \\\"\\\\n\\\";\\n}\\ntemplate <typename T>\\nvoid _do(unordered_set<T> x) {\\n  for (auto i : x) cerr << i << ' ';\\n  cerr << \\\"\\\\n\\\";\\n}\\ntemplate <typename T>\\nvoid _do(T&& x) {\\n  cerr << x << endl;\\n}\\ntemplate <typename T, typename... S>\\nvoid _do(T&& x, S&&... y) {\\n  cerr << x << \\\", \\\";\\n  _do(y...);\\n}\\ntemplate <typename T>\\nvoid print(T&& x) {\\n  cout << x << \\\"\\\\n\\\";\\n}\\ntemplate <typename T, typename... S>\\nvoid print(T&& x, S&&... y) {\\n  cout << x << ' ';\\n  print(y...);\\n}\\nvoid solve() {\\n  const int M = 1e5 + 1, MOD = 1e9 + 7;\\n  vector<int> phi(M);\\n  vector<int> primes;\\n  phi[1] = 1;\\n  for (int i = 2; i < M; i++) {\\n    if (phi[i] == 0) {\\n      primes.push_back(i);\\n      phi[i] = i - 1;\\n    }\\n    for (int p : primes) {\\n      if (i * p >= M) break;\\n      if (i % p == 0) {\\n        phi[i * p] = phi[i] * p;\\n        break;\\n      }\\n      phi[i * p] = 1LL * phi[i] * (p - 1) % MOD;\\n    }\\n  }\\n  vector<vector<int>> factors(M);\\n  for (int i = 1; i < M; i++)\\n    for (int j = i; j < M; j += i) factors[j].push_back(i);\\n  int n;\\n  cin >> n;\\n  vector<int> a(n + 1);\\n  for (int i = 1; i <= n; i++) {\\n    cin >> a[i];\\n  }\\n  vector<int> cnt(M);\\n  int ans = 0;\\n  for (int T = 1; T <= n; T++) {\\n    int G = 0;\\n    vector<int> vec;\\n    for (int i = T; i <= n; i += T)\\n      for (int p : factors[a[i]])\\n        if (cnt[p]++ == 0) vec.push_back(p);\\n    for (int p : vec) G = (G + 1LL * phi[p] * cnt[p] % MOD * cnt[p]) % MOD;\\n    for (int i = T; i <= n; i += T)\\n      for (int p : factors[a[i]]) cnt[p]--;\\n    ans = (ans + 1LL * G * phi[T]) % MOD;\\n  }\\n  if (ans < 0) ans += MOD;\\n  cout << ans << endl;\\n}\\nint main() {\\n  cin.tie(0), cout.tie(0);\\n  ios::sync_with_stdio(false);\\n  solve();\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"You have an undirected graph consisting of n vertices with weighted edges.\\n\\nA simple cycle is a cycle of the graph without repeated vertices. Let the weight of the cycle be the [XOR](https:\\/\\/en.wikipedia.org\\/wiki\\/Bitwise_operation#XOR) of weights of edges it consists of.\\n\\nLet's say the graph is good if all its simple cycles have weight 1. A graph is bad if it's not good.\\n\\nInitially, the graph is empty. Then q queries follow. Each query has the next type: \\n\\n  * u v x \u2014 add edge between vertices u and v of weight x if it doesn't make the graph bad. \\n\\n\\n\\nFor each query print, was the edge added or not.\\n\\nInput\\n\\nThe first line contains two integers n and q (3 \u2264 n \u2264 3 \u22c5 10^5; 1 \u2264 q \u2264 5 \u22c5 10^5) \u2014 the number of vertices and queries.\\n\\nNext q lines contain queries \u2014 one per line. Each query contains three integers u, v and x (1 \u2264 u, v \u2264 n; u \u2260 v; 0 \u2264 x \u2264 1) \u2014 the vertices of the edge and its weight.\\n\\nIt's guaranteed that there are no multiple edges in the input.\\n\\nOutput\\n\\nFor each query, print YES if the edge was added to the graph, or NO otherwise (both case-insensitive).\\n\\nExample\\n\\nInput\\n\\n\\n9 12\\n6 1 0\\n1 3 1\\n3 6 0\\n6 2 0\\n6 4 1\\n3 4 1\\n2 4 0\\n2 5 0\\n4 5 0\\n7 8 1\\n8 9 1\\n9 7 0\\n\\n\\nOutput\\n\\n\\nYES\\nYES\\nYES\\nYES\\nYES\\nNO\\nYES\\nYES\\nNO\\nYES\\nYES\\nNO\\\":\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst int maxn = 300010;\\nint Fir[maxn], Nxt[maxn << 1], Too[maxn << 1], w[maxn << 1], tot;\\nint n, q, root[maxn], fa[maxn], siz[maxn], dfn[maxn], son[maxn], ts, mp[maxn],\\n    top[maxn], vv[maxn], dep[maxn];\\nint adu[maxn << 1], adv[maxn << 1], adw[maxn << 1], in_tr[maxn << 1];\\ninline void Init() {\\n  for (int i = 1; i <= n; ++i) root[i] = i;\\n}\\ninline int find(int x) { return root[x] == x ? x : root[x] = find(root[x]); }\\ninline void merge(int x, int y) {\\n  x = find(x);\\n  y = find(y);\\n  root[x] = y;\\n}\\ninline bool connect(int x, int y) { return find(x) == find(y); }\\ninline void add(int a, int b, int c) {\\n  Too[++tot] = b;\\n  w[tot] = c;\\n  Nxt[tot] = Fir[a];\\n  Fir[a] = tot;\\n}\\ninline void dfs1(int u, int f) {\\n  fa[u] = f;\\n  siz[u] = 1;\\n  dep[u] = dep[f] + 1;\\n  for (int i = Fir[u]; i; i = Nxt[i]) {\\n    int v = Too[i];\\n    if (v == f) continue;\\n    dfs1(v, u);\\n    siz[u] += siz[v];\\n    vv[v] = w[i];\\n    if (siz[v] > siz[son[u]]) son[u] = v;\\n  }\\n}\\ninline void dfs2(int u, int tp) {\\n  top[u] = tp;\\n  dfn[u] = ++ts;\\n  mp[ts] = u;\\n  if (son[u]) dfs2(son[u], tp);\\n  for (int i = Fir[u]; i; i = Nxt[i]) {\\n    int v = Too[i];\\n    if (v != fa[u] && v != son[u]) dfs2(v, v);\\n  }\\n}\\nstruct SegmentTree {\\n  int l, r, v, s, tag;\\n} tr[maxn << 2];\\ninline void pushup(int u) {\\n  tr[u].v = tr[(u << 1)].v ^ tr[(u << 1 | 1)].v;\\n  tr[u].s = tr[(u << 1)].s + tr[(u << 1 | 1)].s;\\n}\\ninline void change(int u) {\\n  tr[u].s = tr[u].r - tr[u].l + 1;\\n  tr[u].tag = 1;\\n}\\ninline void pushdown(int u) {\\n  if (tr[u].tag) {\\n    change((u << 1));\\n    change((u << 1 | 1));\\n    tr[u].tag = 0;\\n  }\\n}\\ninline void build(int u, int l, int r) {\\n  tr[u].l = l;\\n  tr[u].r = r;\\n  if (l == r) {\\n    tr[u].v = vv[mp[l]];\\n    return;\\n  }\\n  int mid = (l + r) >> 1;\\n  build((u << 1), l, mid);\\n  build((u << 1 | 1), mid + 1, r);\\n  pushup(u);\\n}\\ninline void modify(int u, int l, int r) {\\n  if (l <= tr[u].l && tr[u].r <= r) {\\n    change(u);\\n    return;\\n  }\\n  pushdown(u);\\n  int mid = (tr[u].l + tr[u].r) >> 1;\\n  if (l <= mid) modify((u << 1), l,...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Draw a chessboard which has a height of H cm and a width of W cm. For example, the following figure shows a chessboard which has a height of 6 cm and a width of 10 cm.\\n\\n\\n.#.#.#.#.\\n.#.#.#.#.#\\n.#.#.#.#.\\n.#.#.#.#.#\\n.#.#.#.#.\\n.#.#.#.#.#\\n\\n\\nNote that the top left corner should be drawn by '#'.\\n\\nConstraints\\n\\n* 1 \u2264 H \u2264 300\\n* 1 \u2264 W \u2264 300\\n\\nInput\\n\\nThe input consists of multiple datasets. Each dataset consists of two integers H and W separated by a single space.\\n\\nThe input ends with two 0 (when both H and W are zero).\\n\\nOutput\\n\\nFor each dataset, print the chessboard made of '#' and '.'.\\n\\nPrint a blank line after each dataset.\\n\\nExample\\n\\nInput\\n\\n3 4\\n5 6\\n3 3\\n2 2\\n1 1\\n0 0\\n\\n\\nOutput\\n\\n#.#.\\n.#.#\\n#.#.\\n\\n#.#.#.\\n.#.#.#\\n#.#.#.\\n.#.#.#\\n#.#.#.\\n\\n#.#\\n.#.\\n#.#\\n\\n#.\\n.#\\n\\n#\\nSolve the task in JAVA.\",\"targets\":\"import java.util.Scanner;\\n\\npublic class Main {\\n\\tpublic static void main(String[] args) {\\n\\t\\tScanner sc = new Scanner(System.in);\\n\\t\\twhile (sc.hasNext()) {\\n\\t\\t\\tString input = sc.nextLine();\\n\\t\\t\\tString[] array = input.split(\\\" \\\");\\n\\t\\t\\tint h = Integer.parseInt(array[0]);\\n\\t\\t\\tint w = Integer.parseInt(array[1]);\\n\\t\\t\\tif (h == 0 && w == 0) {\\n\\t\\t\\t\\tSystem.exit(0);\\n\\t\\t\\t}\\n\\t\\t\\tfor (int i = 0; i < h; i++) {\\n\\t\\t\\t\\tfor (int j = 0; j < w; j++) {\\n\\t\\t\\t\\t\\tif ((i + j) % 2 == 0) {\\n\\t\\t\\t\\t\\t\\tSystem.out.print(\\\"#\\\");\\n\\t\\t\\t\\t\\t} else {\\n\\t\\t\\t\\t\\t\\tSystem.out.print(\\\".\\\");\\n\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\t}\\n\\t\\t\\t\\tSystem.out.print(\\\"\\\\n\\\");\\n\\t\\t\\t}\\n\\t\\t\\tSystem.out.print(\\\"\\\\n\\\");\\n\\n\\t\\t}\\n\\t}\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Alice and Borys are playing tennis.\\n\\nA tennis match consists of games. In each game, one of the players is serving and the other one is receiving.\\n\\nPlayers serve in turns: after a game where Alice is serving follows a game where Borys is serving, and vice versa.\\n\\nEach game ends with a victory of one of the players. If a game is won by the serving player, it's said that this player holds serve. If a game is won by the receiving player, it's said that this player breaks serve.\\n\\nIt is known that Alice won a games and Borys won b games during the match. It is unknown who served first and who won which games.\\n\\nFind all values of k such that exactly k breaks could happen during the match between Alice and Borys in total.\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 10^3). Description of the test cases follows.\\n\\nEach of the next t lines describes one test case and contains two integers a and b (0 \u2264 a, b \u2264 10^5; a + b > 0) \u2014 the number of games won by Alice and Borys, respectively.\\n\\nIt is guaranteed that the sum of a + b over all test cases does not exceed 2 \u22c5 10^5.\\n\\nOutput\\n\\nFor each test case print two lines.\\n\\nIn the first line, print a single integer m (1 \u2264 m \u2264 a + b + 1) \u2014 the number of values of k such that exactly k breaks could happen during the match.\\n\\nIn the second line, print m distinct integers k_1, k_2, \u2026, k_m (0 \u2264 k_1 < k_2 < \u2026 < k_m \u2264 a + b) \u2014 the sought values of k in increasing order.\\n\\nExample\\n\\nInput\\n\\n\\n3\\n2 1\\n1 1\\n0 5\\n\\n\\nOutput\\n\\n\\n4\\n0 1 2 3\\n2\\n0 2\\n2\\n2 3\\n\\nNote\\n\\nIn the first test case, any number of breaks between 0 and 3 could happen during the match: \\n\\n  * Alice holds serve, Borys holds serve, Alice holds serve: 0 breaks; \\n  * Borys holds serve, Alice holds serve, Alice breaks serve: 1 break; \\n  * Borys breaks serve, Alice breaks serve, Alice holds serve: 2 breaks; \\n  * Alice breaks serve, Borys breaks serve, Alice breaks serve: 3 breaks. \\n\\n\\n\\nIn the second test case, the players could either both hold serves (0 breaks) or both break serves (2...\\nimpor\",\"targets\":\"t os, sys\\nfrom io import BytesIO, IOBase\\nfrom math import log2, ceil, sqrt, gcd\\nfrom _collections import deque\\nimport heapq as hp\\nfrom bisect import bisect_left, bisect_right\\nfrom math import cos, sin\\nfrom itertools import permutations\\n\\nBUFSIZE = 8192\\n\\n\\nclass FastIO(IOBase):\\n    newlines = 0\\n\\n    def __init__(self, file):\\n        self._fd = file.fileno()\\n        self.buffer = BytesIO()\\n        self.writable = \\\"x\\\" in file.mode or \\\"r\\\" not in file.mode\\n        self.write = self.buffer.write if self.writable else None\\n\\n    def read(self):\\n        while True:\\n            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))\\n            if not b:\\n                break\\n            ptr = self.buffer.tell()\\n            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)\\n        self.newlines = 0\\n        return self.buffer.read()\\n\\n    def readline(self):\\n        while self.newlines == 0:\\n            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))\\n            self.newlines = b.count(b\\\"\\\\n\\\") + (not b)\\n            ptr = self.buffer.tell()\\n            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)\\n        self.newlines -= 1\\n        return self.buffer.readline()\\n\\n    def flush(self):\\n        if self.writable:\\n            os.write(self._fd, self.buffer.getvalue())\\n            self.buffer.truncate(0), self.buffer.seek(0)\\n\\n\\nclass IOWrapper(IOBase):\\n    def __init__(self, file):\\n        self.buffer = FastIO(file)\\n        self.flush = self.buffer.flush\\n        self.writable = self.buffer.writable\\n        self.write = lambda s: self.buffer.write(s.encode(\\\"ascii\\\"))\\n        self.read = lambda: self.buffer.read().decode(\\\"ascii\\\")\\n        self.readline = lambda: self.buffer.readline().decode(\\\"ascii\\\")\\n\\n\\nsys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)\\ninput = lambda: sys.stdin.readline().rstrip(\\\"\\\\r\\\\n\\\")\\n\\nmod = 10**9+7\\n\\nfor _ in range(int(input())):\\n    n,m=map(int,input().split())\\n    ans=set()\\n    if (n+m)%2==0:\\n        x=(n+m)\\/\\/2\\n        for i in...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in JAVA?\\nYou have an array of integers (initially empty).\\n\\nYou have to perform q queries. Each query is of one of two types: \\n\\n  * \\\"1 x\\\" \u2014 add the element x to the end of the array; \\n  * \\\"2 x y\\\" \u2014 replace all occurrences of x in the array with y. \\n\\n\\n\\nFind the resulting array after performing all the queries.\\n\\nInput\\n\\nThe first line contains a single integer q (1 \u2264 q \u2264 5 \u22c5 10^5) \u2014 the number of queries.\\n\\nNext q lines contain queries (one per line). Each query is of one of two types: \\n\\n  * \\\"1 x\\\" (1 \u2264 x \u2264 5 \u22c5 10^5); \\n  * \\\"2 x y\\\" (1 \u2264 x, y \u2264 5 \u22c5 10^5). \\n\\n\\n\\nIt's guaranteed that there is at least one query of the first type.\\n\\nOutput\\n\\nIn a single line, print k integers \u2014 the resulting array after performing all the queries, where k is the number of queries of the first type.\\n\\nExamples\\n\\nInput\\n\\n\\n7\\n1 3\\n1 1\\n2 1 2\\n1 2\\n1 1\\n1 2\\n2 1 3\\n\\n\\nOutput\\n\\n\\n3 2 2 3 2 \\n\\nInput\\n\\n\\n4\\n1 1\\n1 2\\n1 1\\n2 2 2\\n\\n\\nOutput\\n\\n\\n1 2 1 \\n\\nInput\\n\\n\\n8\\n2 1 4\\n1 1\\n1 4\\n1 2\\n2 2 4\\n2 4 3\\n1 2\\n2 2 7\\n\\n\\nOutput\\n\\n\\n1 3 3 7 \\n\\nNote\\n\\nIn the first example, the array changes as follows:\\n\\n[] \u2192 [3] \u2192 [3, 1] \u2192 [3, 2] \u2192 [3, 2, 2] \u2192 [3, 2, 2, 1] \u2192 [3, 2, 2, 1, 2] \u2192 [3, 2, 2, 3, 2].\\n\\nIn the second example, the array changes as follows:\\n\\n[] \u2192 [1] \u2192 [1, 2] \u2192 [1, 2, 1] \u2192 [1, 2, 1].\\n\\nIn the third example, the array changes as follows:\\n\\n[] \u2192 [] \u2192 [1] \u2192 [1, 4] \u2192 [1, 4, 2] \u2192 [1, 4, 4] \u2192 [1, 3, 3] \u2192 [1, 3, 3, 2] \u2192 [1, 3, 3, 7].\",\"targets\":\"import java.io.*;\\nimport java.util.*;\\n\\npublic class E {\\n    static int n;\\n    static int[][] input;\\n    public static void main(String[] args) throws IOException{\\n        FastIO file = new FastIO();\\n        n = file.nextInt();\\n        input = new int[n][3];\\n        int count = 0;\\n        for (int i=0; i<n; i++){\\n            int t = file.nextInt();\\n            if (t == 1){\\n                input[i] = new int[] {t, file.nextInt(), count++};\\n            }else{\\n                input[i] = new int[] {t, file.nextInt(), file.nextInt()};\\n            }\\n        }\\n        DSU dsu = new DSU(count);\\n        HashMap<Integer, Integer> map = new HashMap<>();\\n        int[] ans = new int[n];\\n        for (int i=0; i<n; i++){\\n            if (input[i][0] == 1){\\n                if (map.containsKey(input[i][1])){\\n                    dsu.union(map.get(input[i][1]), input[i][2]);\\n                }else{\\n                    map.put(input[i][1], input[i][2]);\\n                }\\n                ans[dsu.find(input[i][2])] = input[i][1];\\n            }else{\\n                if (input[i][1] == input[i][2]){\\n                    continue;\\n                }\\n                if (map.containsKey(input[i][1])){\\n                    if (map.containsKey(input[i][2])){\\n                        dsu.union(map.get(input[i][1]), map.get(input[i][2]));\\n                    }else{\\n                        map.put(input[i][2], map.get(input[i][1]));\\n                    }\\n                    ans[dsu.find(map.get(input[i][2]))] = input[i][2];\\n                    map.remove(input[i][1]);\\n                }\\n            }\\n        }\\n        for (int i=0; i<count; i++){\\n            file.print(ans[dsu.find(i)]+ \\\" \\\");\\n        }\\n        file.close();\\n    }\\n    static class DSU {\\n        int[] parent, depth;\\n        public DSU(int n){\\n            parent = new int[n];\\n            depth = new int[n];\\n            for (int i=0; i<n; i++){\\n                depth[i] = 1;\\n                parent[i] = i;\\n            }\\n        }\\n        public int find(int a){\\n            if (parent[a]...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Comrade Dujikov is busy choosing artists for Timofey's birthday and is recieving calls from Taymyr from Ilia-alpinist.\\n\\nIlia-alpinist calls every n minutes, i.e. in minutes n, 2n, 3n and so on. Artists come to the comrade every m minutes, i.e. in minutes m, 2m, 3m and so on. The day is z minutes long, i.e. the day consists of minutes 1, 2, ..., z. How many artists should be killed so that there are no artists in the room when Ilia calls? Consider that a call and a talk with an artist take exactly one minute.\\n\\nInput\\n\\nThe only string contains three integers \u2014 n, m and z (1 \u2264 n, m, z \u2264 104).\\n\\nOutput\\n\\nPrint single integer \u2014 the minimum number of artists that should be killed so that there are no artists in the room when Ilia calls.\\n\\nExamples\\n\\nInput\\n\\n1 1 10\\n\\n\\nOutput\\n\\n10\\n\\n\\nInput\\n\\n1 2 5\\n\\n\\nOutput\\n\\n2\\n\\n\\nInput\\n\\n2 3 9\\n\\n\\nOutput\\n\\n1\\n\\nNote\\n\\nTaymyr is a place in the north of Russia.\\n\\nIn the first test the artists come each minute, as well as the calls, so we need to kill all of them.\\n\\nIn the second test we need to kill artists which come on the second and the fourth minutes.\\n\\nIn the third test \u2014 only the artist which comes on the sixth minute. \\nn,m,z\",\"targets\":\"=map(int,input().split())\\ndic1={}\\ndic2={}\\nres=[]\\ncnt=0\\nif(n==m and m==z):\\n    print(1)\\nelse:\\n    for i in range(1,(z\\/\\/n)+1):\\n        dic1[i]=i*n\\n    for i in range(1,(z\\/\\/m)+1):\\n        dic2[i]=i*m\\n    \\n\\n    print(len(set(dic1.values()) & set(dic2.values())))\",\"language\":\"python\",\"split\":\"train\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"CQXYM found a rectangle A of size n \u00d7 m. There are n rows and m columns of blocks. Each block of the rectangle is an obsidian block or empty. CQXYM can change an obsidian block to an empty block or an empty block to an obsidian block in one operation.\\n\\nA rectangle M size of a \u00d7 b is called a portal if and only if it satisfies the following conditions:\\n\\n  * a \u2265 5,b \u2265 4. \\n  * For all 1 < x < a, blocks M_{x,1} and M_{x,b} are obsidian blocks. \\n  * For all 1 < x < b, blocks M_{1,x} and M_{a,x} are obsidian blocks. \\n  * For all 1<x<a,1<y<b, block M_{x,y} is an empty block. \\n  * M_{1, 1}, M_{1, b}, M_{a, 1}, M_{a, b} can be any type. \\n\\nNote that the there must be a rows and b columns, not b rows and a columns.\\n\\nNote that corners can be any type\\n\\nCQXYM wants to know the minimum number of operations he needs to make at least one sub-rectangle a portal.\\n\\nInput\\n\\nThe first line contains an integer t (t \u2265 1), which is the number of test cases.\\n\\nFor each test case, the first line contains two integers n and m (5 \u2264 n \u2264 400, 4 \u2264 m \u2264 400). \\n\\nThen n lines follow, each line contains m characters 0 or 1. If the j-th character of i-th line is 0, block A_{i,j} is an empty block. Otherwise, block A_{i,j} is an obsidian block.\\n\\nIt is guaranteed that the sum of n over all test cases does not exceed 400.\\n\\nIt is guaranteed that the sum of m over all test cases does not exceed 400.\\n\\nOutput\\n\\nOutput t answers, and each answer in a line.\\n\\nExamples\\n\\nInput\\n\\n\\n1\\n5 4\\n1000\\n0000\\n0110\\n0000\\n0001\\n\\n\\nOutput\\n\\n\\n12\\n\\n\\nInput\\n\\n\\n1\\n9 9\\n001010001\\n101110100\\n000010011\\n100000001\\n101010101\\n110001111\\n000001111\\n111100000\\n000110000\\n\\n\\nOutput\\n\\n\\n5\\n\\nNote\\n\\nIn the first test case, the final portal is like this:\\n    \\n    \\n      \\n    1110  \\n    1001  \\n    1001  \\n    1001  \\n    0111  \\n    \\\":\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst double PI = acos(-1);\\nconst int INF = INT_MAX;\\nconst long long LLINF = 1000000000000000000LL;\\nconst long long MAX = 405;\\nconst long long MOD = 998244353;\\nlong long N, M;\\nlong long sum[MAX][MAX];\\nlong long getsum(long long y1, long long x1, long long y2, long long x2) {\\n  if (y1 > y2 || x1 > x2) {\\n    return 0;\\n  }\\n  return sum[y2][x2] - sum[y2][x1 - 1] - sum[y1 - 1][x2] + sum[y1 - 1][x1 - 1];\\n}\\nvoid solve() {\\n  cin >> N >> M;\\n  for (int j = 1; j <= N; j++) {\\n    for (int i = 1; i <= M; i++) {\\n      sum[j][i] = 0;\\n    }\\n  }\\n  for (int j = 1; j <= N; j++) {\\n    string s;\\n    cin >> s;\\n    for (int i = 1; i <= M; i++) {\\n      if (s[i - 1] == '1') {\\n        sum[j][i] = 1;\\n      }\\n    }\\n  }\\n  for (int j = 1; j <= N; j++) {\\n    for (int i = 1; i <= M; i++) {\\n      sum[j][i] += sum[j][i - 1] + sum[j - 1][i] - sum[j - 1][i - 1];\\n    }\\n  }\\n  long long ans = LLINF;\\n  for (int j = 1; j <= N; j++) {\\n    for (int i = j + 4; i <= N; i++) {\\n      long long F[MAX];\\n      memset(F, 0, sizeof(F));\\n      for (int k = 4; k <= M; k++) {\\n        long long x = getsum(j + 1, 1, i - 1, k - 1) + k - 1 -\\n                      getsum(j, 1, j, k - 1) + k - 1 - getsum(i, 1, i, k - 1) +\\n                      i - j - 1 - getsum(j + 1, k, i - 1, k);\\n        F[k] = x;\\n      }\\n      for (int k = M; k >= 5; k--) {\\n        if (F[k] < F[k - 1]) {\\n          F[k - 1] = F[k];\\n        }\\n      }\\n      for (int k = 1; k <= M - 3; k++) {\\n        long long x = F[k + 3] - (k - getsum(j, 1, j, k)) -\\n                      (k - getsum(i, 1, i, k)) - getsum(j + 1, 1, i - 1, k) +\\n                      (i - j - 1 - getsum(j + 1, k, i - 1, k));\\n        ans = min(ans, x);\\n      }\\n    }\\n  }\\n  cout << ans << \\\"\\\\n\\\";\\n}\\nint main() {\\n  std::ios_base::sync_with_stdio(false);\\n  cin.tie(NULL);\\n  cout.tie(NULL);\\n  ;\\n  int tc;\\n  cin >> tc;\\n  while (tc--) {\\n    solve();\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"In a certain video game, the player controls a hero characterized by a single integer value: power.\\n\\nOn the current level, the hero got into a system of n caves numbered from 1 to n, and m tunnels between them. Each tunnel connects two distinct caves. Any two caves are connected with at most one tunnel. Any cave can be reached from any other cave by moving via tunnels.\\n\\nThe hero starts the level in cave 1, and every other cave contains a monster.\\n\\nThe hero can move between caves via tunnels. If the hero leaves a cave and enters a tunnel, he must finish his movement and arrive at the opposite end of the tunnel.\\n\\nThe hero can use each tunnel to move in both directions. However, the hero can not use the same tunnel twice in a row. Formally, if the hero has just moved from cave i to cave j via a tunnel, he can not head back to cave i immediately after, but he can head to any other cave connected to cave j with a tunnel.\\n\\nIt is known that at least two tunnels come out of every cave, thus, the hero will never find himself in a dead end even considering the above requirement.\\n\\nTo pass the level, the hero must beat the monsters in all the caves. When the hero enters a cave for the first time, he will have to fight the monster in it. The hero can beat the monster in cave i if and only if the hero's power is strictly greater than a_i. In case of beating the monster, the hero's power increases by b_i. If the hero can't beat the monster he's fighting, the game ends and the player loses.\\n\\nAfter the hero beats the monster in cave i, all subsequent visits to cave i won't have any consequences: the cave won't have any monsters, and the hero's power won't change either.\\n\\nFind the smallest possible power the hero must start the level with to be able to beat all the monsters and pass the level.\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 100). Description of the test cases follows.\\n\\nThe first line of each test case contains two integers n and m (3 \u2264 n \u2264 1000; n \u2264 m...\\n#incl\",\"targets\":\"ude <bits\\/stdc++.h>\\nconst int N = 1005;\\nint n, m, a[N], b[N];\\nstd::vector<int> adj[N];\\nbool used[N];\\nstd::vector<int> store;\\nint pre[N];\\nstd::pair<int, long long> que[N];\\nint l, r;\\nbool check(int init) {\\n  std::fill(used + 1, used + 1 + n, false);\\n  used[1] = 1;\\n  store.clear();\\n  store.push_back(1);\\n  long long power = init;\\n  while ((int)store.size() != n) {\\n    l = 1, r = 0;\\n    for (int i = 0; i < (int)store.size(); i++)\\n      que[++r] = std::make_pair(-store[i], power);\\n    std::fill(pre + 1, pre + 1 + n, false);\\n    int s = 0, t = 0;\\n    while (l <= r) {\\n      int x = que[l].first;\\n      bool f = x > 0;\\n      x = std::abs(x);\\n      long long p = que[l++].second;\\n      for (int e = 0; e < (int)adj[x].size(); e++) {\\n        int y = adj[x][e];\\n        if (pre[x] == y || a[y] >= p) continue;\\n        if (pre[y] || (used[y] && f)) {\\n          s = x, t = y;\\n          break;\\n        }\\n        if (used[y]) continue;\\n        pre[y] = x;\\n        que[++r] = std::make_pair(y, p + b[y]);\\n      }\\n      if (s && t) break;\\n    }\\n    if (!s && !t) break;\\n    do {\\n      if (!used[s]) {\\n        store.push_back(s);\\n        used[s] = 1, power += b[s];\\n      }\\n    } while (s = pre[s]);\\n    do {\\n      if (!used[t]) {\\n        store.push_back(t);\\n        used[t] = 1, power += b[t];\\n      }\\n    } while (t = pre[t]);\\n  }\\n  if ((int)store.size() != n) return false;\\n  return true;\\n}\\nvoid solve() {\\n  scanf(\\\"%d%d\\\", &n, &m);\\n  for (int i = 2; i <= n; i++) scanf(\\\"%d\\\", a + i);\\n  for (int i = 2; i <= n; i++) scanf(\\\"%d\\\", b + i);\\n  for (int i = 1, u, v; i <= m; i++) {\\n    scanf(\\\"%d%d\\\", &u, &v);\\n    adj[u].push_back(v), adj[v].push_back(u);\\n  }\\n  int lb = 0, ub = 1e9 + 1, best = -1;\\n  while (lb <= ub) {\\n    int mid = (lb + ub) >> 1;\\n    if (check(mid))\\n      ub = mid - 1, best = mid;\\n    else\\n      lb = mid + 1;\\n  }\\n  printf(\\\"%d\\\\n\\\", best);\\n  for (int i = 1; i <= n; i++) adj[i].clear();\\n}\\nsigned main() {\\n  int t;\\n  scanf(\\\"%d\\\", &t);\\n  while (t--) solve();\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Arkady invited Anna for a dinner to a sushi restaurant. The restaurant is a bit unusual: it offers n pieces of sushi aligned in a row, and a customer has to choose a continuous subsegment of these sushi to buy.\\n\\nThe pieces of sushi are of two types: either with tuna or with eel. Let's denote the type of the i-th from the left sushi as t_i, where t_i = 1 means it is with tuna, and t_i = 2 means it is with eel.\\n\\nArkady does not like tuna, Anna does not like eel. Arkady wants to choose such a continuous subsegment of sushi that it has equal number of sushi of each type and each half of the subsegment has only sushi of one type. For example, subsegment [2, 2, 2, 1, 1, 1] is valid, but subsegment [1, 2, 1, 2, 1, 2] is not, because both halves contain both types of sushi.\\n\\nFind the length of the longest continuous subsegment of sushi Arkady can buy.\\n\\nInput\\n\\nThe first line contains a single integer n (2 \u2264 n \u2264 100 000) \u2014 the number of pieces of sushi.\\n\\nThe second line contains n integers t_1, t_2, ..., t_n (t_i = 1, denoting a sushi with tuna or t_i = 2, denoting a sushi with eel), representing the types of sushi from left to right.\\n\\nIt is guaranteed that there is at least one piece of sushi of each type. Note that it means that there is at least one valid continuous segment.\\n\\nOutput\\n\\nPrint a single integer \u2014 the maximum length of a valid continuous segment.\\n\\nExamples\\n\\nInput\\n\\n\\n7\\n2 2 2 1 1 2 2\\n\\n\\nOutput\\n\\n\\n4\\n\\n\\nInput\\n\\n\\n6\\n1 2 1 2 1 2\\n\\n\\nOutput\\n\\n\\n2\\n\\n\\nInput\\n\\n\\n9\\n2 2 1 1 1 2 2 2 2\\n\\n\\nOutput\\n\\n\\n6\\n\\nNote\\n\\nIn the first example Arkady can choose the subsegment [2, 2, 1, 1] or the subsegment [1, 1, 2, 2] with length 4.\\n\\nIn the second example there is no way but to choose one of the subsegments [2, 1] or [1, 2] with length 2.\\n\\nIn the third example Arkady's best choice is the subsegment [1, 1, 1, 2, 2, 2].\\nThe above is tricky. Write me a correct solution in PYTHON3.\",\"targets\":\"from sys import stdin, stdout\\n\\nn = int(stdin.readline().strip())\\nls = list(map(int, stdin.readline().strip().split()))\\n\\nresult = one_count = two_count = 0\\nprev_item = 0\\n\\nfor i in range(n):\\n    if ls[i] == 1:\\n        if prev_item != 1:\\n            one_count = 0\\n        one_count += 1\\n        prev_item = 1\\n    else:\\n        if prev_item != 2:\\n            two_count = 0\\n        two_count += 1\\n        prev_item = 2\\n\\n    result = max(result, min(one_count, two_count))\\nstdout.write(\\\"%d\\\\n\\\" % (result*2))\",\"language\":\"python\",\"split\":\"train\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"A telephone number is a sequence of exactly 11 digits such that its first digit is 8.\\n\\nVasya and Petya are playing a game. Initially they have a string s of length n (n is odd) consisting of digits. Vasya makes the first move, then players alternate turns. In one move the player must choose a character and erase it from the current string. For example, if the current string 1121, after the player's move it may be 112, 111 or 121. The game ends when the length of string s becomes 11. If the resulting string is a telephone number, Vasya wins, otherwise Petya wins.\\n\\nYou have to determine if Vasya has a winning strategy (that is, if Vasya can win the game no matter which characters Petya chooses during his moves).\\n\\nInput\\n\\nThe first line contains one integer n (13 \u2264 n < 10^5, n is odd) \u2014 the length of string s.\\n\\nThe second line contains the string s (|s| = n) consisting only of decimal digits.\\n\\nOutput\\n\\nIf Vasya has a strategy that guarantees him victory, print YES.\\n\\nOtherwise print NO.\\n\\nExamples\\n\\nInput\\n\\n\\n13\\n8380011223344\\n\\n\\nOutput\\n\\n\\nYES\\n\\n\\nInput\\n\\n\\n15\\n807345619350641\\n\\n\\nOutput\\n\\n\\nNO\\n\\nNote\\n\\nIn the first example Vasya needs to erase the second character. Then Petya cannot erase a character from the remaining string 880011223344 so that it does not become a telephone number.\\n\\nIn the second example after Vasya's turn Petya can erase one character character 8. The resulting string can't be a telephone number, because there is no digit 8 at all.\",\"targets\":\"N = int(input())\\n\\nstring = list(map(int, input()))\\n\\nt = N - 10\\ncounter = string[0:t].count(8)\\n\\nif counter >= (t + 1) \\/\\/ 2:\\n    print(\\\"YES\\\")\\nelse:\\n    print(\\\"NO\\\")\",\"language\":\"python\",\"split\":\"train\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Let's define S(x) to be the sum of digits of number x written in decimal system. For example, S(5) = 5, S(10) = 1, S(322) = 7.\\n\\nWe will call an integer x interesting if S(x + 1) < S(x). In each test you will be given one integer n. Your task is to calculate the number of integers x such that 1 \u2264 x \u2264 n and x is interesting.\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 1000) \u2014 number of test cases.\\n\\nThen t lines follow, the i-th line contains one integer n (1 \u2264 n \u2264 10^9) for the i-th test case.\\n\\nOutput\\n\\nPrint t integers, the i-th should be the answer for the i-th test case.\\n\\nExample\\n\\nInput\\n\\n\\n5\\n1\\n9\\n10\\n34\\n880055535\\n\\n\\nOutput\\n\\n\\n0\\n1\\n1\\n3\\n88005553\\n\\nNote\\n\\nThe first interesting number is equal to 9.\\nUsing cpp can you solve the prior task?\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nusing ll = long long;\\nint main() {\\n  ios::sync_with_stdio(false);\\n  int t;\\n  cin >> t;\\n  while (t--) {\\n    int n;\\n    cin >> n;\\n    cout << (n + 1) \\/ 10 << \\\"\\\\n\\\";\\n  }\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You are given a string s of length n consisting of characters a and\\/or b.\\n\\nLet \\\\operatorname{AB}(s) be the number of occurrences of string ab in s as a substring. Analogically, \\\\operatorname{BA}(s) is the number of occurrences of ba in s as a substring.\\n\\nIn one step, you can choose any index i and replace s_i with character a or b.\\n\\nWhat is the minimum number of steps you need to make to achieve \\\\operatorname{AB}(s) = \\\\operatorname{BA}(s)?\\n\\nReminder:\\n\\nThe number of occurrences of string d in s as substring is the number of indices i (1 \u2264 i \u2264 |s| - |d| + 1) such that substring s_i s_{i + 1} ... s_{i + |d| - 1} is equal to d. For example, \\\\operatorname{AB}(aabbbabaa) = 2 since there are two indices i: i = 2 where aabbbabaa and i = 6 where aabbbabaa.\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 1000). Description of the test cases follows.\\n\\nThe first and only line of each test case contains a single string s (1 \u2264 |s| \u2264 100, where |s| is the length of the string s), consisting only of characters a and\\/or b.\\n\\nOutput\\n\\nFor each test case, print the resulting string s with \\\\operatorname{AB}(s) = \\\\operatorname{BA}(s) you'll get making the minimum number of steps.\\n\\nIf there are multiple answers, print any of them.\\n\\nExample\\n\\nInput\\n\\n\\n4\\nb\\naabbbabaa\\nabbb\\nabbaab\\n\\n\\nOutput\\n\\n\\nb\\naabbbabaa\\nbbbb\\nabbaaa\\n\\nNote\\n\\nIn the first test case, both \\\\operatorname{AB}(s) = 0 and \\\\operatorname{BA}(s) = 0 (there are no occurrences of ab (ba) in b), so can leave s untouched.\\n\\nIn the second test case, \\\\operatorname{AB}(s) = 2 and \\\\operatorname{BA}(s) = 2, so you can leave s untouched. \\n\\nIn the third test case, \\\\operatorname{AB}(s) = 1 and \\\\operatorname{BA}(s) = 0. For example, we can change s_1 to b and make both values zero.\\n\\nIn the fourth test case, \\\\operatorname{AB}(s) = 2 and \\\\operatorname{BA}(s) = 1. For example, we can change s_6 to a and make both values equal to 1.\\nThe above is tricky. Write me a correct solution in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nvoid solve() {\\n  string s;\\n  cin >> s;\\n  int a = 0, b = 0;\\n  int i, j;\\n  int n = s.size();\\n  for (i = 1; i < n; ++i) {\\n    if (s[i] == 'b' && s[i - 1] == 'a') {\\n      ++a;\\n    }\\n    if (s[i] == 'a' && s[i - 1] == 'b') {\\n      ++b;\\n    }\\n  }\\n  if (a != b) {\\n    if (s[0] == 'a')\\n      s[0] = 'b';\\n    else\\n      s[0] = 'a';\\n  }\\n  cout << s << '\\\\n';\\n}\\nint main() {\\n  ios_base::sync_with_stdio(false);\\n  cin.tie(NULL);\\n  int test_case = 1;\\n  cin >> test_case;\\n  while (test_case-- > 0) solve();\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"A car moves from point A to point B at speed v meters per second. The action takes place on the X-axis. At the distance d meters from A there are traffic lights. Starting from time 0, for the first g seconds the green light is on, then for the following r seconds the red light is on, then again the green light is on for the g seconds, and so on.\\n\\nThe car can be instantly accelerated from 0 to v and vice versa, can instantly slow down from the v to 0. Consider that it passes the traffic lights at the green light instantly. If the car approaches the traffic lights at the moment when the red light has just turned on, it doesn't have time to pass it. But if it approaches the traffic lights at the moment when the green light has just turned on, it can move. The car leaves point A at the time 0.\\n\\nWhat is the minimum time for the car to get from point A to point B without breaking the traffic rules?\\n\\nInput\\n\\nThe first line contains integers l, d, v, g, r (1 \u2264 l, d, v, g, r \u2264 1000, d < l) \u2014 the distance between A and B (in meters), the distance from A to the traffic lights, car's speed, the duration of green light and the duration of red light.\\n\\nOutput\\n\\nOutput a single number \u2014 the minimum time that the car needs to get from point A to point B. Your output must have relative or absolute error less than 10 - 6.\\n\\nExamples\\n\\nInput\\n\\n2 1 3 4 5\\n\\n\\nOutput\\n\\n0.66666667\\n\\n\\nInput\\n\\n5 4 3 1 1\\n\\n\\nOutput\\n\\n2.33333333\\nThe above is tricky. Write me a correct solution in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint main() {\\n  int l, g, v, d, r;\\n  cin >> l >> d >> v >> g >> r;\\n  double time = (d \\/ (v * (g + r))) * (g + r);\\n  int t = d % (v * (g + r));\\n  double tt = t \\/ (v * 1.0);\\n  if (tt >= g) {\\n    time = time + g + r;\\n  } else {\\n    time = time + tt;\\n  }\\n  time += (l - d) \\/ (v * 1.0);\\n  printf(\\\"%.9f\\\\n\\\", time);\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in CPP?\\nA bracket sequence is a string containing only characters \\\"(\\\" and \\\")\\\". 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 \\\"()()\\\" and \\\"(())\\\" are regular (the resulting expressions are: \\\"(1)+(1)\\\" and \\\"((1+1)+1)\\\"), and \\\")(\\\", \\\"(\\\" and \\\")\\\" are not.\\n\\nYou are given an integer n. Your goal is to construct and print exactly n different regular bracket sequences of length 2n.\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 50) \u2014 the number of test cases.\\n\\nEach test case consists of one line containing one integer n (1 \u2264 n \u2264 50).\\n\\nOutput\\n\\nFor each test case, print n lines, each containing a regular bracket sequence of length exactly 2n. All bracket sequences you output for a testcase should be different (though they may repeat in different test cases). If there are multiple answers, print any of them. It can be shown that it's always possible.\\n\\nExample\\n\\nInput\\n\\n\\n3\\n3\\n1\\n3\\n\\n\\nOutput\\n\\n\\n()()()\\n((()))\\n(()())\\n()\\n((()))\\n(())()\\n()(())\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\ndouble EPS = 1e-9;\\nint INF = 1000000005;\\nlong long INFF = 1000000000000000005LL;\\ndouble PI = acos(-1);\\nint dirx[8] = {-1, 0, 0, 1, -1, -1, 1, 1};\\nint diry[8] = {0, 1, -1, 0, -1, 1, -1, 1};\\nint INFH = 2e9 + 10;\\nint binarySearch(int arr[], int l, int r, int x) {\\n  if (r >= l) {\\n    int mid = l + (r - l) \\/ 2;\\n    if (arr[mid] == x) return mid;\\n    if (arr[mid] > x) return binarySearch(arr, l, mid - 1, x);\\n    return binarySearch(arr, mid + 1, r, x);\\n  }\\n  return -1;\\n}\\nint binexp(long long a, long long b) {\\n  if (b == 0) return 1;\\n  long long res = binexp(a, b \\/ 2);\\n  if (b & 1)\\n    return a * res * res;\\n  else\\n    return res * res;\\n}\\nint factorial(int i) { return i ? factorial(i - 1) * i : 1; }\\nbool prime(int n) {\\n  if (n <= 1) return false;\\n  for (int i = 2; i * i <= n; i++) {\\n    if (n % i == 0) return false;\\n  }\\n  return true;\\n}\\nvoid solved() {\\n  int n;\\n  cin >> n;\\n  for (int i = 0; i < n; i++) {\\n    for (int j = 0; j < n - i; j++) {\\n      cout << \\\"(\\\";\\n    }\\n    for (int j = 0; j < n - i; j++) {\\n      cout << \\\")\\\";\\n    }\\n    for (int j = 0; j < i; j++) {\\n      cout << \\\"()\\\";\\n    }\\n    cout << endl;\\n  }\\n}\\nint main() {\\n  int t;\\n  cin >> t;\\n  while (t--) {\\n    solved();\\n  }\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"The Hat is a game of speedy explanation\\/guessing words (similar to Alias). It's fun. Try it! In this problem, we are talking about a variant of the game when the players are sitting at the table and everyone plays individually (i.e. not teams, but individual gamers play).\\n\\nn people gathered in a room with m tables (n \u2265 2m). They want to play the Hat k times. Thus, k games will be played at each table. Each player will play in k games.\\n\\nTo do this, they are distributed among the tables for each game. During each game, one player plays at exactly one table. A player can play at different tables.\\n\\nPlayers want to have the most \\\"fair\\\" schedule of games. For this reason, they are looking for a schedule (table distribution for each game) such that:\\n\\n  * At any table in each game there are either \u230an\\/m\u230b people or \u2308n\\/m\u2309 people (that is, either n\\/m rounded down, or n\\/m rounded up). Different numbers of people can play different games at the same table.\\n  * Let's calculate for each player the value b_i \u2014 the number of times the i-th player played at a table with \u2308n\\/m\u2309 persons (n\\/m rounded up). Any two values of b_imust differ by no more than 1. In other words, for any two players i and j, it must be true |b_i - b_j| \u2264 1. \\n\\n\\n\\nFor example, if n=5, m=2 and k=2, then at the request of the first item either two players or three players should play at each table. Consider the following schedules:\\n\\n  * First game: 1, 2, 3 are played at the first table, and 4, 5 at the second one. The second game: at the first table they play 5, 1, and at the second \u2014 2, 3, 4. This schedule is not \\\"fair\\\" since b_2=2 (the second player played twice at a big table) and b_5=0 (the fifth player did not play at a big table).\\n  * First game: 1, 2, 3 are played at the first table, and 4, 5 at the second one. The second game: at the first table they play 4, 5, 2, and at the second one \u2014 1, 3. This schedule is \\\"fair\\\": b=[1,2,1,1,1] (any two values of b_i differ by no more than 1). \\n\\n\\n\\nFind any \\\"fair\\\" game schedule for n people if they play on the m...\\nThe above is tricky. Write me a correct solution in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\ntemplate <typename T>\\nvoid rd(T& x) {\\n  int f = 0, c;\\n  while (!isdigit(c = getchar())) f ^= !(c ^ 45);\\n  x = (c & 15);\\n  while (isdigit(c = getchar())) x = x * 10 + (c & 15);\\n  if (f) x = -x;\\n}\\ntemplate <typename T>\\nvoid pt(T x, int c = 10) {\\n  if (x < 0) putchar('-'), x = -x;\\n  if (x > 9) pt(x \\/ 10, -1);\\n  putchar(x % 10 + 48);\\n  if (c != -1) putchar(c);\\n}\\ntemplate <typename T>\\nvoid umax(T& x, const T& y) {\\n  if (x < y) x = y;\\n}\\ntemplate <typename T>\\nvoid umin(T& x, const T& y) {\\n  if (x > y) x = y;\\n}\\nusing vi = vector<int>;\\nusing ll = long long;\\nusing ld = long double;\\nusing pii = pair<int, int>;\\nusing pll = pair<long, long>;\\nconst int inf = 0x3f3f3f3f;\\nconst int maxn = 1e5 + 5;\\nconst int mod = 1e9 + 7;\\nint last, h;\\nint n, m, k;\\nvoid show(int d) {\\n  cout << d;\\n  while (d--) {\\n    cout << \\\" \\\" << h;\\n    h++;\\n    if (h > n) h = 1;\\n  }\\n  cout << \\\"\\\\n\\\";\\n}\\nint main() {\\n  ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);\\n  int T;\\n  cin >> T;\\n  while (T--) {\\n    cin >> n >> m >> k;\\n    int x = (n + m - 1) \\/ m, y = n \\/ m;\\n    int r = n % m;\\n    last = 1;\\n    while (k--) {\\n      h = last;\\n      for (int i = 1; i <= r; i++) show(x);\\n      last = h;\\n      for (int i = 1; i <= m - r; i++) show(y);\\n    }\\n    cout << \\\"\\\\n\\\";\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"A binary string is a string that consists of characters 0 and 1. A bi-table is a table that has exactly two rows of equal length, each being a binary string.\\n\\nLet \\\\operatorname{MEX} of a bi-table be the smallest digit among 0, 1, or 2 that does not occur in the bi-table. For example, \\\\operatorname{MEX} for \\\\begin{bmatrix} 0011\\\\\\\\\\\\ 1010 \\\\end{bmatrix} is 2, because 0 and 1 occur in the bi-table at least once. \\\\operatorname{MEX} for \\\\begin{bmatrix} 111\\\\\\\\\\\\ 111 \\\\end{bmatrix} is 0, because 0 and 2 do not occur in the bi-table, and 0 < 2.\\n\\nYou are given a bi-table with n columns. You should cut it into any number of bi-tables (each consisting of consecutive columns) so that each column is in exactly one bi-table. It is possible to cut the bi-table into a single bi-table \u2014 the whole bi-table.\\n\\nWhat is the maximal sum of \\\\operatorname{MEX} of all resulting bi-tables can be?\\n\\nInput\\n\\nThe input consists of multiple test cases. The first line contains a single integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases. Description of the test cases follows.\\n\\nThe first line of the description of each test case contains a single integer n (1 \u2264 n \u2264 10^5) \u2014 the number of columns in the bi-table.\\n\\nEach of the next two lines contains a binary string of length n \u2014 the rows of the bi-table.\\n\\nIt's guaranteed that the sum of n over all test cases does not exceed 10^5.\\n\\nOutput\\n\\nFor each test case print a single integer \u2014 the maximal sum of \\\\operatorname{MEX} of all bi-tables that it is possible to get by cutting the given bi-table optimally.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n7\\n0101000\\n1101100\\n5\\n01100\\n10101\\n2\\n01\\n01\\n6\\n000000\\n111111\\n\\n\\nOutput\\n\\n\\n8\\n8\\n2\\n12\\n\\nNote\\n\\nIn the first test case you can cut the bi-table as follows:\\n\\n  * \\\\begin{bmatrix} 0\\\\\\\\\\\\ 1 \\\\end{bmatrix}, its \\\\operatorname{MEX} is 2.\\n  * \\\\begin{bmatrix} 10\\\\\\\\\\\\ 10 \\\\end{bmatrix}, its \\\\operatorname{MEX} is 2.\\n  * \\\\begin{bmatrix} 1\\\\\\\\\\\\ 1 \\\\end{bmatrix}, its \\\\operatorname{MEX} is 0.\\n  * \\\\begin{bmatrix} 0\\\\\\\\\\\\ 1 \\\\end{bmatrix}, its \\\\operatorname{MEX} is 2.\\n  * \\\\begin{bmatrix} 0\\\\\\\\\\\\ 0 \\\\end{bmatrix}, its...\\\":\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconstexpr int MaxN = 1000000 + 5;\\nchar s[MaxN], t[MaxN];\\nint a[MaxN], b[MaxN];\\nint main() {\\n  ios::sync_with_stdio(false), cin.tie(nullptr);\\n  int T;\\n  cin >> T;\\n  int n;\\n  while (T--) {\\n    cin >> n >> (s + 1) >> (t + 1);\\n    for (register int i = (1); i <= (n); ++i)\\n      if (s[i] != t[i]) s[i] = '*';\\n    int l0 = 0, l1 = 0;\\n    for (register int i = (1); i <= (n); ++i) {\\n      if (s[i] == '*') {\\n        a[i] = (a[i - 1] + 2);\\n        l0 = l1 = i;\\n      } else if (s[i] == '0') {\\n        a[i] = (a[i - 1] + 1);\\n        if (l1) a[i] = max(a[i], a[l1 - 1] + 2);\\n        l0 = i;\\n      } else if (s[i] == '1') {\\n        a[i] = a[i - 1];\\n        if (l0) a[i] = max(a[i], a[l0 - 1] + 2);\\n        l1 = i;\\n      }\\n    }\\n    cout << a[n] << endl;\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Anton's favourite geometric figures are regular polyhedrons. Note that there are five kinds of regular polyhedrons: \\n\\n  * Tetrahedron. Tetrahedron has 4 triangular faces. \\n  * Cube. Cube has 6 square faces. \\n  * Octahedron. Octahedron has 8 triangular faces. \\n  * Dodecahedron. Dodecahedron has 12 pentagonal faces. \\n  * Icosahedron. Icosahedron has 20 triangular faces. \\n\\n\\n\\nAll five kinds of polyhedrons are shown on the picture below:\\n\\n<image>\\n\\nAnton has a collection of n polyhedrons. One day he decided to know, how many faces his polyhedrons have in total. Help Anton and find this number!\\n\\nInput\\n\\nThe first line of the input contains a single integer n (1 \u2264 n \u2264 200 000) \u2014 the number of polyhedrons in Anton's collection.\\n\\nEach of the following n lines of the input contains a string si \u2014 the name of the i-th polyhedron in Anton's collection. The string can look like this:\\n\\n  * \\\"Tetrahedron\\\" (without quotes), if the i-th polyhedron in Anton's collection is a tetrahedron. \\n  * \\\"Cube\\\" (without quotes), if the i-th polyhedron in Anton's collection is a cube. \\n  * \\\"Octahedron\\\" (without quotes), if the i-th polyhedron in Anton's collection is an octahedron. \\n  * \\\"Dodecahedron\\\" (without quotes), if the i-th polyhedron in Anton's collection is a dodecahedron. \\n  * \\\"Icosahedron\\\" (without quotes), if the i-th polyhedron in Anton's collection is an icosahedron. \\n\\nOutput\\n\\nOutput one number \u2014 the total number of faces in all the polyhedrons in Anton's collection.\\n\\nExamples\\n\\nInput\\n\\n4\\nIcosahedron\\nCube\\nTetrahedron\\nDodecahedron\\n\\n\\nOutput\\n\\n42\\n\\n\\nInput\\n\\n3\\nDodecahedron\\nOctahedron\\nOctahedron\\n\\n\\nOutput\\n\\n28\\n\\nNote\\n\\nIn the first sample Anton has one icosahedron, one cube, one tetrahedron and one dodecahedron. Icosahedron has 20 faces, cube has 6 faces, tetrahedron has 4 faces and dodecahedron has 12 faces. In total, they have 20 + 6 + 4 + 12 = 42 faces.\\nfaces\",\"targets\":\"= {\\\"Tetrahedron\\\": 4,\\n         \\\"Cube\\\": 6,\\n         \\\"Octahedron\\\": 8,\\n         \\\"Dodecahedron\\\": 12,\\n         \\\"Icosahedron\\\": 20}\\n\\nn = int(input())\\n\\ns = 0\\n\\nfor i in range(n):\\n    s += faces[input()]\\n\\nprint(s)\",\"language\":\"python\",\"split\":\"train\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"Jabber ID on the national Berland service \u00abBabber\u00bb has a form <username>@<hostname>[\\/resource], where \\n\\n  * <username> \u2014 is a sequence of Latin letters (lowercase or uppercase), digits or underscores characters \u00ab_\u00bb, the length of <username> is between 1 and 16, inclusive. \\n  * <hostname> \u2014 is a sequence of word separated by periods (characters \u00ab.\u00bb), where each word should contain only characters allowed for <username>, the length of each word is between 1 and 16, inclusive. The length of <hostname> is between 1 and 32, inclusive. \\n  * <resource> \u2014 is a sequence of Latin letters (lowercase or uppercase), digits or underscores characters \u00ab_\u00bb, the length of <resource> is between 1 and 16, inclusive. \\n\\n\\n\\nThe content of square brackets is optional \u2014 it can be present or can be absent.\\n\\nThere are the samples of correct Jabber IDs: mike@codeforces.com, 007@en.codeforces.com\\/contest.\\n\\nYour task is to write program which checks if given string is a correct Jabber ID.\\n\\nInput\\n\\nThe input contains of a single line. The line has the length between 1 and 100 characters, inclusive. Each characters has ASCII-code between 33 and 127, inclusive.\\n\\nOutput\\n\\nPrint YES or NO.\\n\\nExamples\\n\\nInput\\n\\nmike@codeforces.com\\n\\n\\nOutput\\n\\nYES\\n\\n\\nInput\\n\\njohn.smith@codeforces.ru\\/contest.icpc\\/12\\n\\n\\nOutput\\n\\nNO\\\":\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nstatic const double EPS = 1e-8;\\nint main() {\\n  istream &fin = cin;\\n  FILE *fpin = stdin;\\n  string s;\\n  fin >> s;\\n  int state = 0;\\n  int ps = 0, ps2 = 0;\\n  int n = s.size();\\n  for (int i = 0; i < n; i++) {\\n    if (state == 0) {\\n      if (s[i] == '@') {\\n        if (i - ps < 1 || i - ps > 16) {\\n          cout << \\\"NO\\\" << endl;\\n          return 0;\\n        }\\n        state++;\\n        ps = i + 1;\\n        ps2 = i + 1;\\n      } else {\\n        if (!isalnum(s[i]) && s[i] != '_') {\\n          cout << \\\"NO\\\" << endl;\\n          return 0;\\n        }\\n      }\\n    } else if (state == 1) {\\n      if (s[i] == '\\/') {\\n        if (i - ps < 1 || i - ps > 32 || i - ps2 < 1 || i - ps2 > 16) {\\n          cout << \\\"NO\\\" << endl;\\n          return 0;\\n        }\\n        state++;\\n        ps = i + 1;\\n      } else if (s[i] == '.') {\\n        if (i - ps2 < 1 || i - ps2 > 16) {\\n          cout << \\\"NO\\\" << endl;\\n          return 0;\\n        }\\n        ps2 = i + 1;\\n      } else {\\n        if (!isalnum(s[i]) && s[i] != '_') {\\n          cout << \\\"NO\\\" << endl;\\n          return 0;\\n        }\\n      }\\n    } else if (state == 2) {\\n      if (!isalnum(s[i]) && s[i] != '_') {\\n        cout << \\\"NO\\\" << endl;\\n        return 0;\\n      }\\n    }\\n  }\\n  if (state == 0) {\\n    cout << \\\"NO\\\" << endl;\\n    return 0;\\n  } else if (state == 1) {\\n    if (n - ps < 1 || n - ps > 32 || n - ps2 < 1 || n - ps2 > 16) {\\n      cout << \\\"NO\\\" << endl;\\n      return 0;\\n    }\\n  } else if (state == 2) {\\n    if (n - ps < 1 || n - ps > 16) {\\n      cout << \\\"NO\\\" << endl;\\n      return 0;\\n    }\\n  }\\n  cout << \\\"YES\\\" << endl;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Polycarp likes squares and cubes of positive integers. Here is the beginning of the sequence of numbers he likes: 1, 4, 8, 9, ....\\n\\nFor a given number n, count the number of integers from 1 to n that Polycarp likes. In other words, find the number of such x that x is a square of a positive integer number or a cube of a positive integer number (or both a square and a cube simultaneously).\\n\\nInput\\n\\nThe first line contains an integer t (1 \u2264 t \u2264 20) \u2014 the number of test cases.\\n\\nThen t lines contain the test cases, one per line. Each of the lines contains one integer n (1 \u2264 n \u2264 10^9).\\n\\nOutput\\n\\nFor each test case, print the answer you are looking for \u2014 the number of integers from 1 to n that Polycarp likes.\\n\\nExample\\n\\nInput\\n\\n\\n6\\n10\\n1\\n25\\n1000000000\\n999999999\\n500000000\\n\\n\\nOutput\\n\\n\\n4\\n1\\n6\\n32591\\n32590\\n23125\\nUsing cpp can you solve the prior task?\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst int dx[9] = {-1, 0, 1, 0, -1, -1, 1, 1, 0};\\nconst int dy[9] = {0, 1, 0, -1, -1, 1, -1, 1, 0};\\nlong long n;\\nvoid solve() {\\n  long long a, b, c;\\n  {\\n    long long left = 0, right = 1e5;\\n    while (left < right) {\\n      long long mid = left + right + 1 >> 1;\\n      long long y = mid * mid;\\n      if (y <= n)\\n        left = mid;\\n      else\\n        right = mid - 1;\\n    }\\n    a = left;\\n  }\\n  {\\n    long long left = 0, right = 1e5;\\n    while (left < right) {\\n      long long mid = left + right + 1 >> 1;\\n      long long y = mid * mid * mid;\\n      if (y <= n)\\n        left = mid;\\n      else\\n        right = mid - 1;\\n    }\\n    b = left;\\n  }\\n  {\\n    long long left = 0, right = 1e3;\\n    while (left < right) {\\n      long long mid = left + right + 1 >> 1;\\n      long long y = mid * mid * mid * mid * mid * mid;\\n      if (y <= n)\\n        left = mid;\\n      else\\n        right = mid - 1;\\n    }\\n    c = left;\\n  }\\n  cout << a + b - c << \\\"\\\\n\\\";\\n}\\nint main() {\\n  ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);\\n  int T;\\n  cin >> T;\\n  while (T--) {\\n    cin >> n;\\n    solve();\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"<image>\\n\\nWilliam has two numbers a and b initially both equal to zero. William mastered performing three different operations with them quickly. Before performing each operation some positive integer k is picked, which is then used to perform one of the following operations: (note, that for each operation you can choose a new positive integer k)\\n\\n  1. add number k to both a and b, or \\n  2. add number k to a and subtract k from b, or \\n  3. add number k to b and subtract k from a. \\n\\n\\n\\nNote that after performing operations, numbers a and b may become negative as well.\\n\\nWilliam wants to find out the minimal number of operations he would have to perform to make a equal to his favorite number c and b equal to his second favorite number d.\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 10^4). Description of the test cases follows.\\n\\nThe only line of each test case contains two integers c and d (0 \u2264 c, d \u2264 10^9), which are William's favorite numbers and which he wants a and b to be transformed into.\\n\\nOutput\\n\\nFor each test case output a single number, which is the minimal number of operations which William would have to perform to make a equal to c and b equal to d, or -1 if it is impossible to achieve this using the described operations.\\n\\nExample\\n\\nInput\\n\\n\\n6\\n1 2\\n3 5\\n5 3\\n6 6\\n8 0\\n0 0\\n\\n\\nOutput\\n\\n\\n-1\\n2\\n2\\n1\\n2\\n0\\n\\nNote\\n\\nLet us demonstrate one of the suboptimal ways of getting a pair (3, 5):\\n\\n  * Using an operation of the first type with k=1, the current pair would be equal to (1, 1). \\n  * Using an operation of the third type with k=8, the current pair would be equal to (-7, 9). \\n  * Using an operation of the second type with k=7, the current pair would be equal to (0, 2). \\n  * Using an operation of the first type with k=3, the current pair would be equal to (3, 5). \\nSolve the task in PYTHON3.\",\"targets\":\"for i in range(int(input())):\\n    a, b = map(int, input().split())\\n    ans = 2\\n    if (a+b)%2:\\n        ans -= 3\\n    else:\\n        if not (a + b):\\n            ans -= 1\\n        if not (a - b):\\n            ans -= 1\\n    print(ans)\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in CPP?\\nIn Berland, n different types of banknotes are used. Banknotes of the i-th type have denomination 10^{a_i} burles (burles are the currency used in Berland); the denomination of banknotes of the first type is exactly 1.\\n\\nLet's denote f(s) as the minimum number of banknotes required to represent exactly s burles. For example, if the denominations of banknotes used in Berland are 1, 10 and 100, then f(59) = 14: 9 banknotes with denomination of 1 burle and 5 banknotes with denomination of 10 burles can be used to represent exactly 9 \u22c5 1 + 5 \u22c5 10 = 59 burles, and there's no way to do it with fewer banknotes.\\n\\nFor a given integer k, find the minimum positive number of burles s that cannot be represented with k or fewer banknotes (that is, f(s) > k).\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 10^4) \u2014 number of test cases.\\n\\nThe first line of each test case contains two integers n and k (1 \u2264 n \u2264 10; 1 \u2264 k \u2264 10^9).\\n\\nThe next line contains n integers a_1, a_2, ..., a_n (0 = a_1 < a_2 < ... < a_n \u2264 9).\\n\\nOutput\\n\\nFor each test case, print one integer \u2014 the minimum positive number of burles s that cannot be represented with k or fewer banknotes.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n3 13\\n0 1 2\\n2 777\\n0 4\\n3 255\\n0 1 3\\n10 1000000000\\n0 1 2 3 4 5 6 7 8 9\\n\\n\\nOutput\\n\\n\\n59\\n778\\n148999\\n999999920999999999\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst int N = 1e5 + 10;\\nint n, k;\\nint a[12];\\nlong long fastpow(long long a, long long b) {\\n  long long sum = 1;\\n  while (b) {\\n    if (b & 1) sum *= a;\\n    a *= a;\\n    b >>= 1;\\n  }\\n  return sum;\\n}\\nint main() {\\n  int t;\\n  cin >> t;\\n  while (t--) {\\n    cin >> n >> k;\\n    long long sum = 0;\\n    for (int i = 0; i < n; i++) cin >> a[i];\\n    int flag = 0;\\n    for (int i = 0; i < n - 1; i++) {\\n      long long temp = fastpow(10, a[i + 1] - a[i]) - 1;\\n      if (k - temp < 0) {\\n        sum += (k + 1) * fastpow(10, a[i]);\\n        flag = 1;\\n        break;\\n      } else {\\n        sum += temp * fastpow(10, a[i]);\\n        k -= temp;\\n      }\\n    }\\n    if (flag == 1)\\n      cout << sum << endl;\\n    else {\\n      sum += (k + 1) * fastpow(10, a[n - 1]);\\n      cout << sum << endl;\\n    }\\n  }\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in CPP?\\nStudents of one unknown college don't have PE courses. That's why q of them decided to visit a gym nearby by themselves. The gym is open for n days and has a ticket system. At the i-th day, the cost of one ticket is equal to a_i. You are free to buy more than one ticket per day.\\n\\nYou can activate a ticket purchased at day i either at day i or any day later. Each activated ticket is valid only for k days. In other words, if you activate ticket at day t, it will be valid only at days t, t + 1, ..., t + k - 1. \\n\\nYou know that the j-th student wants to visit the gym at each day from l_j to r_j inclusive. Each student will use the following strategy of visiting the gym at any day i (l_j \u2264 i \u2264 r_j):\\n\\n  1. person comes to a desk selling tickets placed near the entrance and buy several tickets with cost a_i apiece (possibly, zero tickets); \\n  2. if the person has at least one activated and still valid ticket, they just go in. Otherwise, they activate one of tickets purchased today or earlier and go in. \\n\\n\\n\\nNote that each student will visit gym only starting l_j, so each student has to buy at least one ticket at day l_j.\\n\\nHelp students to calculate the minimum amount of money they have to spend in order to go to the gym.\\n\\nInput\\n\\nThe first line contains three integers n, q and k (1 \u2264 n, q \u2264 300 000; 1 \u2264 k \u2264 n) \u2014 the number of days, the number of students and the number of days each ticket is still valid. \\n\\nThe second line contains n integers a_1, a_2, ..., a_n (1 \u2264 a_i \u2264 10^9) \u2014 the cost of one ticket at the corresponding day.\\n\\nEach of the next q lines contains two integers l_i and r_i (1 \u2264 l_i \u2264 r_i \u2264 n) \u2014 the segment of days the corresponding student want to visit the gym.\\n\\nOutput\\n\\nFor each student, print the minimum possible amount of money they have to spend in order to go to the gym at desired days.\\n\\nExample\\n\\nInput\\n\\n\\n7 5 2\\n2 15 6 3 7 5 6\\n1 2\\n3 7\\n5 5\\n7 7\\n3 5\\n\\n\\nOutput\\n\\n\\n2\\n12\\n7\\n6\\n9\\n\\nNote\\n\\nLet's see how each student have to spend their money: \\n\\n  * The first student should buy one ticket at day 1. \\n  * The second...\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nstd::pair<long long int, long long int> operator+(\\n    const std::pair<long long int, long long int>& x,\\n    const std::pair<long long int, long long int>& y) {\\n  return std::make_pair(x.first + y.first, x.second + y.second);\\n}\\nconst int nax = 3e5 + 5;\\nint t[nax][18], a[nax];\\nvoid build(int n) {\\n  for (int i = 1; i <= n; ++i) t[i][0] = a[i];\\n  for (int k = 1; k < 18; ++k) {\\n    for (int i = 1; i + (1 << k) - 1 <= n; ++i) {\\n      t[i][k] = min(t[i][k - 1], t[i + (1 << (k - 1))][k - 1]);\\n    }\\n  }\\n}\\nint query(int l, int r) {\\n  int k = 31 - __builtin_clz(r - l + 1);\\n  return min(t[l][k], t[r - (1 << k) + 1][k]);\\n}\\nint n, q, k;\\nconst int roz = (1 << 20);\\nlong long int tree[roz];\\npair<long long, long long> lazy[roz];\\nbool mark[roz];\\nint sz[roz];\\nlong long int ary(long long int lo, long long int prog, long long int cnt) {\\n  return (lo + (lo + (cnt - 1) * prog)) * cnt \\/ 2;\\n}\\nvoid push(long long int v) {\\n  if (mark[v]) {\\n    lazy[v * 2] = lazy[v * 2] + lazy[v];\\n    lazy[v * 2 + 1] = lazy[v * 2 + 1] + lazy[v];\\n    lazy[v * 2 + 1].first += lazy[v].second * sz[v * 2];\\n    mark[v * 2] = mark[v * 2 + 1] = true;\\n    tree[v * 2] += ary(lazy[v].first, lazy[v].second, sz[v * 2]);\\n    tree[v * 2 + 1] += ary(lazy[v].first + lazy[v].second * sz[v * 2],\\n                           lazy[v].second, sz[v * 2 + 1]);\\n    mark[v] = false;\\n    lazy[v] = make_pair(0, 0);\\n  }\\n}\\nvoid upd(int lo, int hi, int u, int a, int b, pair<long long, long long> val) {\\n  if (lo == a && b == hi) {\\n    lazy[u] = lazy[u] + val;\\n    tree[u] += ary(val.first, val.second, hi - lo);\\n    mark[u] = true;\\n    return;\\n  }\\n  if (b <= a) return;\\n  push(u);\\n  int mid = (lo + hi) \\/ 2;\\n  upd(lo, mid, u * 2, a, min(b, mid), val);\\n  pair<long long, long long> go =\\n      make_pair(val.first + val.second * max(0, mid - a), val.second);\\n  upd(mid, hi, u * 2 + 1, max(a, mid), b, go);\\n  tree[u] = tree[u * 2] + tree[u * 2 + 1];\\n}\\nlong long int ask(int lo, int hi, int u, int a, int b) {\\n  if (lo == a && b == hi) {\\n    return...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"During a recent research Berland scientists found out that there were n cities in Ancient Berland, joined by two-way paths. Any two cities are joined by no more than one path. No path joins a city with itself. According to a well-known tradition, the road network was built so that it would be impossible to choose three cities from each of which one can get to any other one directly. That is, there was no cycle exactly as long as 3. Unfortunately, the road map has not been preserved till nowadays. Now the scientists are interested how much developed a country Ancient Berland was. Help them - find, what maximal number of roads could be in the country. You also have to restore any of the possible road maps.\\n\\nInput\\n\\nThe first line contains an integer n (1 \u2264 n \u2264 100) \u2014 the number of cities in Berland.\\n\\nOutput\\n\\nOn the first line must be printed number m \u2014 the maximal number of roads in Berland. Then print m lines containing two numbers each \u2014 the numbers of cities that the given road joins. The cities are numbered with integers from 1 to n. If there are several variants of solving the problem, print any of them.\\n\\nExamples\\n\\nInput\\n\\n3\\n\\n\\nOutput\\n\\n2\\n1 2\\n2 3\\n\\n\\nInput\\n\\n4\\n\\n\\nOutput\\n\\n4\\n1 2\\n2 3\\n3 4\\n4 1\\nThe above is tricky. Write me a correct solution in JAVA.\",\"targets\":\"import java.io.BufferedReader;\\nimport java.io.IOException;\\nimport java.io.InputStreamReader;\\nimport java.io.PrintWriter;\\nimport java.util.ArrayList;\\nimport java.util.Arrays;\\nimport java.util.List;\\nimport java.util.PriorityQueue;\\n\\npublic class Main {\\n\\tpublic static BufferedReader in;\\n\\tpublic static PrintWriter out;\\n\\n\\tpublic static void main(String[] args) throws IOException {\\n\\t\\tin = new BufferedReader(new InputStreamReader(System.in));\\n\\t\\tout = new PrintWriter(System.out);\\n\\n\\t\\tboolean showLineError = true;\\n\\t\\tif (showLineError) {\\n\\t\\t\\tsolve();\\n\\t\\t\\tout.close();\\n\\t\\t} else {\\n\\t\\t\\ttry {\\n\\t\\t\\t\\tsolve();\\n\\t\\t\\t} catch (Exception e) {\\n\\t\\t\\t} finally {\\n\\t\\t\\t\\tout.close();\\n\\t\\t\\t}\\n\\t\\t}\\n\\n\\t}\\n\\n\\tstatic void debug(Object... os) {\\n\\t\\tout.println(Arrays.deepToString(os));\\n\\t}\\n\\n\\tprivate static void solve() throws IOException {\\n\\t\\tint n = ni();\\n\\t\\tout.println( (n\\/2)*( (n+1)\\/2) );\\n\\t\\tfor(int i =0;i<n\\/2;i++)\\n\\t\\t\\tfor(int j =n\\/2;j<n;j++)\\n\\t\\t\\t\\tout.println((i+1)+\\\" \\\"+(j+1));\\n\\t}\\n\\n\\tprivate static String[] nss() throws IOException {\\n\\t\\treturn in.readLine().split(\\\" \\\");\\n\\t}\\n\\n\\tprivate static int ni() throws NumberFormatException, IOException {\\n\\t\\treturn Integer.parseInt(in.readLine());\\n\\t}\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Alice and Bob are playing chess on a huge chessboard with dimensions n \u00d7 n. Alice has a single piece left \u2014 a queen, located at (a_x, a_y), while Bob has only the king standing at (b_x, b_y). Alice thinks that as her queen is dominating the chessboard, victory is hers. \\n\\nBut Bob has made a devious plan to seize the victory for himself \u2014 he needs to march his king to (c_x, c_y) in order to claim the victory for himself. As Alice is distracted by her sense of superiority, she no longer moves any pieces around, and it is only Bob who makes any turns.\\n\\nBob will win if he can move his king from (b_x, b_y) to (c_x, c_y) without ever getting in check. Remember that a king can move to any of the 8 adjacent squares. A king is in check if it is on the same rank (i.e. row), file (i.e. column), or diagonal as the enemy queen. \\n\\nFind whether Bob can win or not.\\n\\nInput\\n\\nThe first line contains a single integer n (3 \u2264 n \u2264 1000) \u2014 the dimensions of the chessboard.\\n\\nThe second line contains two integers a_x and a_y (1 \u2264 a_x, a_y \u2264 n) \u2014 the coordinates of Alice's queen.\\n\\nThe third line contains two integers b_x and b_y (1 \u2264 b_x, b_y \u2264 n) \u2014 the coordinates of Bob's king.\\n\\nThe fourth line contains two integers c_x and c_y (1 \u2264 c_x, c_y \u2264 n) \u2014 the coordinates of the location that Bob wants to get to.\\n\\nIt is guaranteed that Bob's king is currently not in check and the target location is not in check either.\\n\\nFurthermore, the king is not located on the same square as the queen (i.e. a_x \u2260 b_x or a_y \u2260 b_y), and the target does coincide neither with the queen's position (i.e. c_x \u2260 a_x or c_y \u2260 a_y) nor with the king's position (i.e. c_x \u2260 b_x or c_y \u2260 b_y).\\n\\nOutput\\n\\nPrint \\\"YES\\\" (without quotes) if Bob can get from (b_x, b_y) to (c_x, c_y) without ever getting in check, otherwise print \\\"NO\\\".\\n\\nYou can print each letter in any case (upper or lower).\\n\\nExamples\\n\\nInput\\n\\n8\\n4 4\\n1 3\\n3 1\\n\\n\\nOutput\\n\\nYES\\n\\n\\nInput\\n\\n8\\n4 4\\n2 3\\n1 6\\n\\n\\nOutput\\n\\nNO\\n\\n\\nInput\\n\\n8\\n3 5\\n1 2\\n6 1\\n\\n\\nOutput\\n\\nNO\\n\\nNote\\n\\nIn the diagrams below, the squares controlled by the black...\\n#incl\",\"targets\":\"ude <bits\\/stdc++.h>\\nusing namespace std;\\nint main() {\\n  int N, x, y, x1, y1, x2, y2, n, m, p1, p2;\\n  cin >> N;\\n  cin >> m >> n;\\n  cin >> x >> y;\\n  cin >> p1 >> p2;\\n  if (x < m && y < n) {\\n    m = m - 1;\\n    n = n - 1;\\n    x1 = 1;\\n    x2 = m;\\n    y1 = 1;\\n    y2 = n;\\n  } else if (x < m && y > n) {\\n    m = m - 1;\\n    n = n + 1;\\n    x1 = 1;\\n    x2 = m;\\n    y1 = n;\\n    y2 = N;\\n  } else if (x > m && y < n) {\\n    m = m + 1;\\n    n = n - 1;\\n    x1 = m;\\n    x2 = N;\\n    y1 = 1;\\n    y2 = n;\\n  } else if (x > m && y > n) {\\n    m = m + 1;\\n    n = n + 1;\\n    x1 = m;\\n    x2 = N;\\n    y1 = n;\\n    y2 = N;\\n  }\\n  if (p1 >= x1 && p1 <= x2 && p2 >= y1 && p2 <= y2)\\n    puts(\\\"YES\\\");\\n  else\\n    puts(\\\"NO\\\");\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Polycarp must pay exactly n burles at the checkout. He has coins of two nominal values: 1 burle and 2 burles. Polycarp likes both kinds of coins equally. So he doesn't want to pay with more coins of one type than with the other.\\n\\nThus, Polycarp wants to minimize the difference between the count of coins of 1 burle and 2 burles being used. Help him by determining two non-negative integer values c_1 and c_2 which are the number of coins of 1 burle and 2 burles, respectively, so that the total value of that number of coins is exactly n (i. e. c_1 + 2 \u22c5 c_2 = n), and the absolute value of the difference between c_1 and c_2 is as little as possible (i. e. you must minimize |c_1-c_2|).\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases. Then t test cases follow.\\n\\nEach test case consists of one line. This line contains one integer n (1 \u2264 n \u2264 10^9) \u2014 the number of burles to be paid by Polycarp.\\n\\nOutput\\n\\nFor each test case, output a separate line containing two integers c_1 and c_2 (c_1, c_2 \u2265 0) separated by a space where c_1 is the number of coins of 1 burle and c_2 is the number of coins of 2 burles. If there are multiple optimal solutions, print any one.\\n\\nExample\\n\\nInput\\n\\n\\n6\\n1000\\n30\\n1\\n32\\n1000000000\\n5\\n\\n\\nOutput\\n\\n\\n334 333\\n10 10\\n1 0\\n10 11\\n333333334 333333333\\n1 2\\n\\nNote\\n\\nThe answer for the first test case is \\\"334 333\\\". The sum of the nominal values of all coins is 334 \u22c5 1 + 333 \u22c5 2 = 1000, whereas |334 - 333| = 1. One can't get the better value because if |c_1 - c_2| = 0, then c_1 = c_2 and c_1 \u22c5 1 + c_1 \u22c5 2 = 1000, but then the value of c_1 isn't an integer.\\n\\nThe answer for the second test case is \\\"10 10\\\". The sum of the nominal values is 10 \u22c5 1 + 10 \u22c5 2 = 30 and |10 - 10| = 0, whereas there's no number having an absolute value less than 0.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint which_coin_more(int n) { return (n % 3); }\\nvoid solve() {\\n  int n;\\n  cin >> n;\\n  int a[2] = {n \\/ 3, n \\/ 3};\\n  if (which_coin_more(n) == 1)\\n    a[0]++;\\n  else if (which_coin_more(n) == 2)\\n    a[1]++;\\n  cout << a[0] << \\\" \\\" << a[1] << \\\"\\\\n\\\";\\n}\\nint main() {\\n  cin.tie(0)->sync_with_stdio(0);\\n  cin.exceptions(cin.failbit);\\n  int n;\\n  cin >> n;\\n  while (n--) {\\n    solve();\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Bear Limak examines a social network. Its main functionality is that two members can become friends (then they can talk with each other and share funny pictures).\\n\\nThere are n members, numbered 1 through n. m pairs of members are friends. Of course, a member can't be a friend with themselves.\\n\\nLet A-B denote that members A and B are friends. Limak thinks that a network is reasonable if and only if the following condition is satisfied: For every three distinct members (X, Y, Z), if X-Y and Y-Z then also X-Z.\\n\\nFor example: if Alan and Bob are friends, and Bob and Ciri are friends, then Alan and Ciri should be friends as well.\\n\\nCan you help Limak and check if the network is reasonable? Print \\\"YES\\\" or \\\"NO\\\" accordingly, without the quotes.\\n\\nInput\\n\\nThe first line of the input contain two integers n and m (3 \u2264 n \u2264 150 000, <image>) \u2014 the number of members and the number of pairs of members that are friends.\\n\\nThe i-th of the next m lines contains two distinct integers ai and bi (1 \u2264 ai, bi \u2264 n, ai \u2260 bi). Members ai and bi are friends with each other. No pair of members will appear more than once in the input.\\n\\nOutput\\n\\nIf the given network is reasonable, print \\\"YES\\\" in a single line (without the quotes). Otherwise, print \\\"NO\\\" in a single line (without the quotes).\\n\\nExamples\\n\\nInput\\n\\n4 3\\n1 3\\n3 4\\n1 4\\n\\n\\nOutput\\n\\nYES\\n\\n\\nInput\\n\\n4 4\\n3 1\\n2 3\\n3 4\\n1 2\\n\\n\\nOutput\\n\\nNO\\n\\n\\nInput\\n\\n10 4\\n4 3\\n5 10\\n8 9\\n1 2\\n\\n\\nOutput\\n\\nYES\\n\\n\\nInput\\n\\n3 2\\n1 2\\n2 3\\n\\n\\nOutput\\n\\nNO\\n\\nNote\\n\\nThe drawings below show the situation in the first sample (on the left) and in the second sample (on the right). Each edge represents two members that are friends. The answer is \\\"NO\\\" in the second sample because members (2, 3) are friends and members (3, 4) are friends, while members (2, 4) are not.\\n\\n<image>\\nUsing java can you solve the prior task?\",\"targets\":\"import java.io.*;\\nimport java.lang.reflect.Array;\\nimport java.math.BigInteger;\\nimport java.util.*;\\n\\n\\npublic class Main {\\n    private static Scanner sc;\\n    private static Printer pr;\\n    static boolean []visited;\\n    static int []color;\\n    static int []pow=new int[(int)3e5+1];\\n    static int []count;\\n    static boolean check=true;\\n    static boolean checkBip=true;\\n    static ArrayList<Integer>[]list;\\n    private static long aLong=(long)(Math.pow(10,9)+7);\\n    static final long div=998244353;\\n    static  int answer=0;\\n    private static void solve() throws IOException {\\n        int n=sc.nextInt(),m=sc.nextInt();\\n        list=new ArrayList[n+1];\\n        for (int i=1;i<=n;i++)\\n            list[i]=new ArrayList<>();\\n        \\/\\/color=new int[n+1];\\n        visited=new boolean[n+1];\\n        for (int i=1;i<=m;i++){\\n            int a=sc.nextInt();\\n            int b=sc.nextInt();\\n            list[a].add(b);\\n            list[b].add(a);\\n        }\\n        \\/*color[1]=1;\\n        bfsColor(1,-1);\\n        for (int s:color)\\n            System.out.println(\\\"clolr:\\\"+s);*\\/\\n        for (int i=1;i<=n;i++){\\n            if (!visited[i]){\\n                \\/\\/System.out.println(\\\"i:\\\"+i);\\n                visited[i]=true;\\n                if (!bfs(i)){\\n                    System.out.println(\\\"NO\\\");\\n                    System.exit(0);\\n                }\\n            }\\n        }\\n        System.out.println(\\\"YES\\\");\\n\\n    }\\n    public static boolean bfs(int src){\\n        Queue<Integer>queue=new ArrayDeque<>();\\n        ArrayList<Integer>com=new ArrayList<>();\\n        com.add(src);\\n        queue.add(src);\\n        while (!queue.isEmpty()){\\n            int node=queue.remove();\\n            for (int v:list[node]) {\\n                if (!visited[v]){\\n                    visited[v]=true;\\n                    com.add(v);\\n                    queue.add(v);\\n                }\\n            }\\n        }\\n        \\/\\/System.out.println(\\\"size:\\\"+com.size());\\n        \\/\\/for (int h:com){\\n         \\/\\/   System.out.println(\\\"v:\\\"+h);\\n        \\/\\/}\\n        for (int s:com){\\n           ...\",\"language\":\"python\",\"split\":\"train\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"You are given a binary string (i. e. a string consisting of characters 0 and\\/or 1) s of length n. You can perform the following operation with the string s at most once: choose a substring (a contiguous subsequence) of s having exactly k characters 1 in it, and shuffle it (reorder the characters in the substring as you wish).\\n\\nCalculate the number of different strings which can be obtained from s by performing this operation at most once.\\n\\nInput\\n\\nThe first line contains two integers n and k (2 \u2264 n \u2264 5000; 0 \u2264 k \u2264 n).\\n\\nThe second line contains the string s of length n, consisting of characters 0 and\\/or 1.\\n\\nOutput\\n\\nPrint one integer \u2014 the number of different strings which can be obtained from s by performing the described operation at most once. Since the answer can be large, output it modulo 998244353.\\n\\nExamples\\n\\nInput\\n\\n\\n7 2\\n1100110\\n\\n\\nOutput\\n\\n\\n16\\n\\n\\nInput\\n\\n\\n5 0\\n10010\\n\\n\\nOutput\\n\\n\\n1\\n\\n\\nInput\\n\\n\\n8 1\\n10001000\\n\\n\\nOutput\\n\\n\\n10\\n\\n\\nInput\\n\\n\\n10 8\\n0010011000\\n\\n\\nOutput\\n\\n\\n1\\n\\nNote\\n\\nSome strings you can obtain in the first example:\\n\\n  * to obtain 0110110, you can take the substring from the 1-st character to the 4-th character, which is 1100, and reorder its characters to get 0110; \\n  * to obtain 1111000, you can take the substring from the 3-rd character to the 7-th character, which is 00110, and reorder its characters to get 11000; \\n  * to obtain 1100101, you can take the substring from the 5-th character to the 7-th character, which is 110, and reorder its characters to get 101. \\n\\n\\n\\nIn the second example, k = 0 so you can only choose the substrings consisting only of 0 characters. Reordering them doesn't change the string at all, so the only string you can obtain is 10010.\\\":\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst int N = 5005;\\nconst int mod = 998244353;\\nvoid bmod(int &x) { x -= mod, x += x >> 31 & mod; }\\nint norm(int x) { return x < 0 ? x + mod : x; }\\nvoid Add(int &x, int y) { x += y - mod, x += x >> 31 & mod; }\\nvoid Sub(int &x, int y) { x -= y, x += x >> 31 & mod; }\\nint inv(int x, int k = mod - 2) {\\n  int r = 1;\\n  while (k) {\\n    if (k & 1) r = (long long)x * r % mod;\\n    x = (long long)x * x % mod;\\n    k >>= 1;\\n  }\\n  return r;\\n}\\nconst int Flen = N;\\nint fact[Flen], infact[Flen];\\nvoid preF(int n = Flen - 1) {\\n  fact[0] = 1;\\n  for (int i = 1; i <= n; ++i) fact[i] = (long long)fact[i - 1] * i % mod;\\n  infact[n] = inv(fact[n]);\\n  for (int i = n; i; --i) infact[i - 1] = (long long)infact[i] * i % mod;\\n}\\nint C(int x, int y) {\\n  return y < 0 || x < y\\n             ? 0\\n             : (long long)fact[x] * infact[y] % mod * infact[x - y] % mod;\\n}\\nint n, m;\\nchar str[N];\\nint f[N], s[N];\\nint main() {\\n  preF();\\n  scanf(\\\"%d%d%s\\\", &n, &m, str + 1);\\n  if (!m) return puts(\\\"1\\\"), 0;\\n  f[0] = 1;\\n  for (int i = 1; i <= n; ++i) {\\n    s[i] = s[i - 1] + (str[i] -= 48);\\n  }\\n  for (int i = 1, j = 0; i <= n; ++i) {\\n    f[i] = f[i - 1];\\n    if (str[i]) {\\n      while (j < i && s[i] - s[j] > m) ++j;\\n      if (s[i] - s[j] != m) continue;\\n      if (s[j])\\n        Add(f[i], C(i - j - 1, m));\\n      else\\n        Add(f[i], C(i - j, m) - 1);\\n    } else {\\n      if (s[i] - s[j] != m) continue;\\n      Add(f[i], C(i - j - 1, m - 1));\\n    }\\n  }\\n  printf(\\\"%d\\\\n\\\", f[n]);\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in CPP?\\nLee is used to finish his stories in a stylish way, this time he barely failed it, but Ice Bear came and helped him. Lee is so grateful for it, so he decided to show Ice Bear his new game called \\\"Critic\\\"...\\n\\nThe game is a one versus one game. It has t rounds, each round has two integers s_i and e_i (which are determined and are known before the game begins, s_i and e_i may differ from round to round). The integer s_i is written on the board at the beginning of the corresponding round. \\n\\nThe players will take turns. Each player will erase the number on the board (let's say it was a) and will choose to write either 2 \u22c5 a or a + 1 instead. Whoever writes a number strictly greater than e_i loses that round and the other one wins that round.\\n\\nNow Lee wants to play \\\"Critic\\\" against Ice Bear, for each round he has chosen the round's s_i and e_i in advance. Lee will start the first round, the loser of each round will start the next round.\\n\\nThe winner of the last round is the winner of the game, and the loser of the last round is the loser of the game.\\n\\nDetermine if Lee can be the winner independent of Ice Bear's moves or not. Also, determine if Lee can be the loser independent of Ice Bear's moves or not.\\n\\nInput\\n\\nThe first line contains the integer t (1 \u2264 t \u2264 10^5) \u2014 the number of rounds the game has. \\n\\nThen t lines follow, each contains two integers s_i and e_i (1 \u2264 s_i \u2264 e_i \u2264 10^{18}) \u2014 the i-th round's information.\\n\\nThe rounds are played in the same order as given in input, s_i and e_i for all rounds are known to everyone before the game starts.\\n\\nOutput\\n\\nPrint two integers.\\n\\nThe first one should be 1 if Lee can be the winner independent of Ice Bear's moves, and 0 otherwise.\\n\\nThe second one should be 1 if Lee can be the loser independent of Ice Bear's moves, and 0 otherwise.\\n\\nExamples\\n\\nInput\\n\\n\\n3\\n5 8\\n1 4\\n3 10\\n\\n\\nOutput\\n\\n\\n1 1\\n\\n\\nInput\\n\\n\\n4\\n1 2\\n2 3\\n3 4\\n4 5\\n\\n\\nOutput\\n\\n\\n0 0\\n\\n\\nInput\\n\\n\\n1\\n1 1\\n\\n\\nOutput\\n\\n\\n0 1\\n\\n\\nInput\\n\\n\\n2\\n1 9\\n4 5\\n\\n\\nOutput\\n\\n\\n0 0\\n\\n\\nInput\\n\\n\\n2\\n1 2\\n2 8\\n\\n\\nOutput\\n\\n\\n1 0\\n\\n\\nInput\\n\\n\\n6\\n216986951114298167...\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nlong long s[200005], e[200005];\\nlong long win(long long s, long long e) {\\n  if (e & 1) {\\n    if (s & 1) return 0;\\n    return 1;\\n  }\\n  if (s > e \\/ 2) {\\n    if (s & 1) return 1;\\n    return 0;\\n  }\\n  if (s > e \\/ 4) return 1;\\n  return win(s, e >> 2);\\n}\\nlong long lose(long long s, long long e) {\\n  if (s > e \\/ 2) return 1;\\n  return win(s, e >> 1);\\n}\\nint main() {\\n  long long i, n, j, k, t, m, w, l, cur = 0;\\n  scanf(\\\"%lld\\\", &t);\\n  for (i = 1; i <= t; i++) scanf(\\\"%lld%lld\\\", &s[i], &e[i]);\\n  for (i = 1; i <= t; i++) {\\n    w = win(s[i], e[i]);\\n    l = lose(s[i], e[i]);\\n    w ^= cur;\\n    l ^= cur;\\n    if (w == l) break;\\n    if (w)\\n      cur = 1;\\n    else\\n      cur = 0;\\n  }\\n  printf(\\\"%lld %lld\\\\n\\\", w, l);\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"In fact, the problems E1 and E2 do not have much in common. You should probably think of them as two separate problems.\\n\\nYou are given an integer array a[1 \u2026 n] = [a_1, a_2, \u2026, a_n].\\n\\nLet us consider an empty [deque](https:\\/\\/tinyurl.com\\/pfeucbux) (double-ended queue). A deque is a data structure that supports adding elements to both the beginning and the end. So, if there are elements [3, 4, 4] currently in the deque, adding an element 1 to the beginning will produce the sequence [\\\\color{red}{1}, 3, 4, 4], and adding the same element to the end will produce [3, 4, 4, \\\\color{red}{1}].\\n\\nThe elements of the array are sequentially added to the initially empty deque, starting with a_1 and finishing with a_n. Before adding each element to the deque, you may choose whether to add it to the beginning or to the end.\\n\\nFor example, if we consider an array a = [3, 7, 5, 5], one of the possible sequences of actions looks like this:    1. |  add 3 to the beginning of the deque: |  deque has a sequence [\\\\color{red}{3}] in it;   \\n---|---|---  \\n  2. |  add 7 to the end of the deque: |  deque has a sequence [3, \\\\color{red}{7}] in it;   \\n  3. |  add 5 to the end of the deque: |  deque has a sequence [3, 7, \\\\color{red}{5}] in it;   \\n  4. |  add 5 to the beginning of the deque: |  deque has a sequence [\\\\color{red}{5}, 3, 7, 5] in it;   \\n  \\nFind the minimal possible number of inversions in the deque after the whole array is processed. \\n\\nAn inversion in sequence d is a pair of indices (i, j) such that i < j and d_i > d_j. For example, the array d = [5, 3, 7, 5] has exactly two inversions \u2014 (1, 2) and (3, 4), since d_1 = 5 > 3 = d_2 and d_3 = 7 > 5 = d_4.\\n\\nInput\\n\\nThe first line contains an integer t (1 \u2264 t \u2264 1000) \u2014 the number of test cases.\\n\\nThe next 2t lines contain descriptions of the test cases. \\n\\nThe first line of each test case description contains an integer n (1 \u2264 n \u2264 2 \u22c5 10^5) \u2014 array size. The second line of the description contains n space-separated integers a_i (-10^9 \u2264 a_i \u2264 10^9) \u2014 elements of the array.\\n\\nIt is...\\nUsing cpp can you solve the prior task?\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst int N = 2e5 + 10, M = 1e5 + 29;\\nint a[N], b[N];\\nint c[N];\\nint n;\\nint cnt;\\nvoid add(int x) {\\n  while (x <= n) {\\n    c[x] += 1;\\n    x += x & -x;\\n  }\\n}\\nint get(int x) {\\n  int ans = 0;\\n  while (x) {\\n    ans += c[x];\\n    x -= x & -x;\\n  }\\n  return ans;\\n}\\nvoid solve() {\\n  cin >> n;\\n  for (int i = 1; i <= n; i++) {\\n    c[i] = 0;\\n    scanf(\\\"%d\\\", &a[i]);\\n    b[i] = a[i];\\n  }\\n  sort(b + 1, b + 1 + n);\\n  cnt = unique(b + 1, b + 1 + n) - b - 1;\\n  long long ans = 0;\\n  for (int i = 1; i <= n; i++) {\\n    int p = lower_bound(b + 1, b + 1 + n, a[i]) - b;\\n    int x = get(p - 1);\\n    int y = get(n) - get(p);\\n    ans += min(x, y);\\n    add(p);\\n  }\\n  cout << ans << endl;\\n}\\nint main() {\\n  int t;\\n  cin >> t;\\n  while (t--) {\\n    solve();\\n  }\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"You are given n integers a_1, a_2, \u2026, a_n. Find the maximum value of max(a_l, a_{l + 1}, \u2026, a_r) \u22c5 min(a_l, a_{l + 1}, \u2026, a_r) over all pairs (l, r) of integers for which 1 \u2264 l < r \u2264 n.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 10 000) \u2014 the number of test cases.\\n\\nThe first line of each test case contains a single integer n (2 \u2264 n \u2264 10^5).\\n\\nThe second line of each test case contains n integers a_1, a_2, \u2026, a_n (1 \u2264 a_i \u2264 10^6).\\n\\nIt is guaranteed that the sum of n over all test cases doesn't exceed 3 \u22c5 10^5.\\n\\nOutput\\n\\nFor each test case, print a single integer \u2014 the maximum possible value of the product from the statement.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n3\\n2 4 3\\n4\\n3 2 3 1\\n2\\n69 69\\n6\\n719313 273225 402638 473783 804745 323328\\n\\n\\nOutput\\n\\n\\n12\\n6\\n4761\\n381274500335\\n\\nNote\\n\\nLet f(l, r) = max(a_l, a_{l + 1}, \u2026, a_r) \u22c5 min(a_l, a_{l + 1}, \u2026, a_r).\\n\\nIn the first test case, \\n\\n  * f(1, 2) = max(a_1, a_2) \u22c5 min(a_1, a_2) = max(2, 4) \u22c5 min(2, 4) = 4 \u22c5 2 = 8. \\n  * f(1, 3) = max(a_1, a_2, a_3) \u22c5 min(a_1, a_2, a_3) = max(2, 4, 3) \u22c5 min(2, 4, 3) = 4 \u22c5 2 = 8. \\n  * f(2, 3) = max(a_2, a_3) \u22c5 min(a_2, a_3) = max(4, 3) \u22c5 min(4, 3) = 4 \u22c5 3 = 12. \\n\\n\\n\\nSo the maximum is f(2, 3) = 12.\\n\\nIn the second test case, the maximum is f(1, 2) = f(1, 3) = f(2, 3) = 6.\\\":\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nvoid solve() {\\n  int64_t n, last, mx = 0, val;\\n  cin >> n;\\n  cin >> last;\\n  while (--n) {\\n    cin >> val;\\n    mx = max(mx, last * val);\\n    last = val;\\n  }\\n  cout << mx << endl;\\n}\\nint main() {\\n  int t;\\n  cin >> t;\\n  while (t--) solve();\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Mocha wants to be an astrologer. There are n stars which can be seen in Zhijiang, and the brightness of the i-th star is a_i. \\n\\nMocha considers that these n stars form a constellation, and she uses (a_1,a_2,\u2026,a_n) to show its state. A state is called mathematical if all of the following three conditions are satisfied:\\n\\n  * For all i (1\u2264 i\u2264 n), a_i is an integer in the range [l_i, r_i].\\n  * \u2211  _{i=1} ^ n a_i \u2264 m.\\n  * \\\\gcd(a_1,a_2,\u2026,a_n)=1.\\n\\n\\n\\nHere, \\\\gcd(a_1,a_2,\u2026,a_n) denotes the [greatest common divisor (GCD)](https:\\/\\/en.wikipedia.org\\/wiki\\/Greatest_common_divisor) of integers a_1,a_2,\u2026,a_n.\\n\\nMocha is wondering how many different mathematical states of this constellation exist. Because the answer may be large, you must find it modulo 998 244 353.\\n\\nTwo states (a_1,a_2,\u2026,a_n) and (b_1,b_2,\u2026,b_n) are considered different if there exists i (1\u2264 i\u2264 n) such that a_i \u2260 b_i.\\n\\nInput\\n\\nThe first line contains two integers n and m (2 \u2264 n \u2264 50, 1 \u2264 m \u2264 10^5) \u2014 the number of stars and the upper bound of the sum of the brightness of stars.\\n\\nEach of the next n lines contains two integers l_i and r_i (1 \u2264 l_i \u2264 r_i \u2264 m) \u2014 the range of the brightness of the i-th star.\\n\\nOutput\\n\\nPrint a single integer \u2014 the number of different mathematical states of this constellation, modulo 998 244 353.\\n\\nExamples\\n\\nInput\\n\\n\\n2 4\\n1 3\\n1 2\\n\\n\\nOutput\\n\\n\\n4\\n\\nInput\\n\\n\\n5 10\\n1 10\\n1 10\\n1 10\\n1 10\\n1 10\\n\\n\\nOutput\\n\\n\\n251\\n\\nInput\\n\\n\\n5 100\\n1 94\\n1 96\\n1 91\\n4 96\\n6 97\\n\\n\\nOutput\\n\\n\\n47464146\\n\\nNote\\n\\nIn the first example, there are 4 different mathematical states of this constellation:\\n\\n  * a_1=1, a_2=1.\\n  * a_1=1, a_2=2.\\n  * a_1=2, a_2=1.\\n  * a_1=3, a_2=1.\\nSolve the task in JAVA.\",\"targets\":\"import java.io.*;\\nimport java.util.*;\\npublic class Main {\\n\\tpublic static void main(String[] args) throws IOException \\n\\t{ \\n\\t\\tFastScanner f= new FastScanner(); \\n\\t\\tint ttt=1;\\n\\/\\/\\t\\tttt=f.nextInt();\\n\\t\\tPrintWriter out=new PrintWriter(System.out);\\n\\t\\tfor(int tt=0;tt<ttt;tt++) {\\n\\t        int N = f.nextInt();\\n\\t        int M = f.nextInt();\\n\\t        int MOD=998244353;\\n\\t        int[] left = new int[N];\\n\\t        int[] right = new int[N];\\n\\t        for(int i=0; i < N; i++)\\n\\t        {\\n\\t            left[i] = f.nextInt();\\n\\t            right[i] =f.nextInt();\\n\\t        }\\n\\t        long[] ways = new long[M+1];\\n\\t        outer:for(int v=1; v <= M; v++)\\n\\t        {\\n\\t            int CAP = M\\/v;\\n\\t            long[] dp = new long[CAP+1];\\n\\t            dp[0] = 1L;\\n\\t            for(int t=0; t < N; t++)\\n\\t            {\\n\\t                int min = Integer.MAX_VALUE;\\n\\t                int max = 0;\\n\\t                for(int i=v; i <= right[t]; i+=v)\\n\\t                    if(i >= left[t])\\n\\t                    {\\n\\t                        min = Math.min(min, i\\/v);\\n\\t                        max = i\\/v;\\n\\t                    }\\n\\t                if(min == Integer.MAX_VALUE)\\n\\t                    continue outer;\\n\\t                long[] psums = new long[CAP+1];\\n\\t                psums[0] = dp[0];\\n\\t                for(int i=1; i <= CAP; i++)\\n\\t                {\\n\\t                    psums[i] = psums[i-1]+dp[i];\\n\\t                    if(psums[i] >= MOD)\\n\\t                        psums[i] -= MOD;\\n\\t                }\\n\\t                long[] next = new long[CAP+1];\\n\\t                for(int i=min; i <= CAP; i++)\\n\\t                {\\n\\t                    int r = i-min;\\n\\t                    int l = Math.max(0, i-max);\\n\\t                    next[i] = psums[r];\\n\\t                    if(l > 0)\\n\\t                        next[i] -= psums[l-1];\\n\\t                    if(next[i] < 0)\\n\\t                        next[i] += MOD;\\n\\t                }\\n\\t                dp = next;\\n\\t            }\\n\\t            for(long x: dp)\\n\\t            {\\n\\t                ways[v] += x;\\n\\t                if(ways[v] >=...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Mr. Chanek lives in a city represented as a plane. He wants to build an amusement park in the shape of a circle of radius r. The circle must touch the origin (point (0, 0)).\\n\\nThere are n bird habitats that can be a photo spot for the tourists in the park. The i-th bird habitat is at point p_i = (x_i, y_i). \\n\\nFind the minimum radius r of a park with at least k bird habitats inside. \\n\\nA point is considered to be inside the park if and only if the distance between p_i and the center of the park is less than or equal to the radius of the park. Note that the center and the radius of the park do not need to be integers.\\n\\nIn this problem, it is guaranteed that the given input always has a solution with r \u2264 2 \u22c5 10^5.\\n\\nInput\\n\\nThe first line contains two integers n and k (1 \u2264 n \u2264 10^5, 1 \u2264 k \u2264 n) \u2014 the number of bird habitats in the city and the number of bird habitats required to be inside the park.\\n\\nThe i-th of the next n lines contains two integers x_i and y_i (0 \u2264 |x_i|, |y_i| \u2264 10^5) \u2014 the position of the i-th bird habitat.\\n\\nOutput\\n\\nOutput a single real number r denoting the minimum radius of a park with at least k bird habitats inside. It is guaranteed that the given input always has a solution with r \u2264 2 \u22c5 10^5.\\n\\nYour answer is considered correct if its absolute or relative error does not exceed 10^{-4}.\\n\\nFormally, let your answer be a, and the jury's answer be b. Your answer is accepted if and only if \\\\frac{|a - b|}{max{(1, |b|)}} \u2264 10^{-4}.\\n\\nExamples\\n\\nInput\\n\\n\\n8 4\\n-3 1\\n-4 4\\n1 5\\n2 2\\n2 -2\\n-2 -4\\n-1 -1\\n-6 0\\n\\n\\nOutput\\n\\n\\n3.1622776589\\n\\n\\nInput\\n\\n\\n1 1\\n0 0\\n\\n\\nOutput\\n\\n\\n0.0000000000\\n\\nNote\\n\\nIn the first example, Mr. Chanek can put the center of the park at (-3, -1) with radius \u221a{10} \u2248 3.162. It can be proven this is the minimum r.\\n\\nThe following illustrates the first example. The blue points represent bird habitats and the red circle represents the amusement park.\\n\\n<image>\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst long double e = 1e-8;\\nconst long double pi = acos(-1);\\nlong double polar_ang(pair<long long, long long> vec) {\\n  long double ang = atan2(vec.second, vec.first);\\n  if (ang < 0) {\\n    ang += 2 * pi;\\n  }\\n  return ang;\\n}\\nlong double dist(pair<long long, long long> lol) {\\n  return hypot(lol.first, lol.second);\\n}\\nbool check(long double rad, vector<pair<long long, long long>> &a,\\n           long long k) {\\n  vector<pair<long double, long double>> lol;\\n  long long cnt = 0;\\n  for (auto el : a) {\\n    if (el.first == 0 && el.second == 0) {\\n      cnt++;\\n      continue;\\n    }\\n    long double d = dist(el);\\n    if (d + e > 2 * rad) {\\n      continue;\\n    }\\n    long double ang = acos(d \\/ (2 * rad));\\n    long double pol = polar_ang(el);\\n    long double a1 = pol - ang, a2 = pol + ang;\\n    if (a1 < 0) {\\n      a1 += 2 * pi;\\n    }\\n    if (a2 > 2 * pi) {\\n      a2 -= 2 * pi;\\n    }\\n    if (a1 < a2) {\\n      lol.emplace_back(a1 - e, a2 + e);\\n    } else {\\n      lol.emplace_back(a1 - e, 2 * pi + e);\\n      lol.emplace_back(0 - e, a2 + e);\\n    }\\n  }\\n  vector<pair<long double, long long>> evs;\\n  for (auto el : lol) {\\n    evs.emplace_back(el.first, 0);\\n    evs.emplace_back(el.second, 1);\\n  }\\n  sort(evs.begin(), evs.end());\\n  if (cnt >= k) {\\n    return true;\\n  }\\n  for (auto el : evs) {\\n    if (el.second == 0) {\\n      cnt++;\\n    } else {\\n      cnt--;\\n    }\\n    if (cnt >= k) {\\n      return true;\\n    }\\n  }\\n  return false;\\n}\\nsigned main() {\\n  ios::sync_with_stdio(false);\\n  cin.tie(nullptr);\\n  cout.tie(nullptr);\\n  long long n, k;\\n  cin >> n >> k;\\n  vector<pair<long long, long long>> pts(n);\\n  for (auto &el : pts) {\\n    cin >> el.first >> el.second;\\n  }\\n  long double L = 0.0, R = 2.3e5, eps = 1e-5;\\n  while (R - L > eps) {\\n    long double r = (L + R) \\/ 2;\\n    if (check(r, pts, k)) {\\n      R = r;\\n    } else {\\n      L = r;\\n    }\\n  }\\n  cout << fixed << setprecision(20) << L << '\\\\n';\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Andryusha is an orderly boy and likes to keep things in their place.\\n\\nToday he faced a problem to put his socks in the wardrobe. He has n distinct pairs of socks which are initially in a bag. The pairs are numbered from 1 to n. Andryusha wants to put paired socks together and put them in the wardrobe. He takes the socks one by one from the bag, and for each sock he looks whether the pair of this sock has been already took out of the bag, or not. If not (that means the pair of this sock is still in the bag), he puts the current socks on the table in front of him. Otherwise, he puts both socks from the pair to the wardrobe.\\n\\nAndryusha remembers the order in which he took the socks from the bag. Can you tell him what is the maximum number of socks that were on the table at the same time? \\n\\nInput\\n\\nThe first line contains the single integer n (1 \u2264 n \u2264 105) \u2014 the number of sock pairs.\\n\\nThe second line contains 2n integers x1, x2, ..., x2n (1 \u2264 xi \u2264 n), which describe the order in which Andryusha took the socks from the bag. More precisely, xi means that the i-th sock Andryusha took out was from pair xi.\\n\\nIt is guaranteed that Andryusha took exactly two socks of each pair.\\n\\nOutput\\n\\nPrint single integer \u2014 the maximum number of socks that were on the table at the same time.\\n\\nExamples\\n\\nInput\\n\\n1\\n1 1\\n\\n\\nOutput\\n\\n1\\n\\n\\nInput\\n\\n3\\n2 1 1 3 2 3\\n\\n\\nOutput\\n\\n2\\n\\nNote\\n\\nIn the first example Andryusha took a sock from the first pair and put it on the table. Then he took the next sock which is from the first pair as well, so he immediately puts both socks to the wardrobe. Thus, at most one sock was on the table at the same time.\\n\\nIn the second example Andryusha behaved as follows: \\n\\n  * Initially the table was empty, he took out a sock from pair 2 and put it on the table. \\n  * Sock (2) was on the table. Andryusha took out a sock from pair 1 and put it on the table. \\n  * Socks (1, 2) were on the table. Andryusha took out a sock from pair 1, and put this pair into the wardrobe. \\n  * Sock (2) was on the table. Andryusha took out a sock from...\\nUsing java can you solve the prior task?\",\"targets\":\"import java.util.HashMap;\\nimport java.util.Scanner;\\n\\npublic class AndryushaandSocks_780A {\\n\\tpublic static void main(String[] args) {\\n\\t\\tScanner input = new Scanner(System.in);\\n\\t\\tint n = input.nextInt()*2, max = 0;\\n\\t\\tHashMap<Integer, Integer> map = new HashMap<Integer, Integer>();\\n\\t\\twhile (n-- > 0) {\\n\\t\\t\\tint x = input.nextInt();\\n\\t\\t\\tif (!map.containsKey(x))\\n\\t\\t\\t\\tmap.put(x, 1);\\n\\t\\t\\telse {\\n\\t\\t\\t\\tmap.remove(x);\\n\\t\\t\\t}\\n\\t\\t\\tmax = Math.max(max, map.size());\\n\\t\\t}\\n\\t\\tSystem.out.println(max);\\n\\t\\tinput.close();\\n\\t}\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You are given array a_1, a_2, \u2026, a_n, consisting of non-negative integers.\\n\\nLet's define operation of \\\"elimination\\\" with integer parameter k (1 \u2264 k \u2264 n) as follows:\\n\\n  * Choose k distinct array indices 1 \u2264 i_1 < i_2 < \u2026 < i_k \u2264 n. \\n  * Calculate x = a_{i_1} ~ \\\\& ~ a_{i_2} ~ \\\\& ~ \u2026 ~ \\\\& ~ a_{i_k}, where \\\\& denotes the [bitwise AND operation](https:\\/\\/en.wikipedia.org\\/wiki\\/Bitwise_operation#AND) (notes section contains formal definition). \\n  * Subtract x from each of a_{i_1}, a_{i_2}, \u2026, a_{i_k}; all other elements remain untouched. \\n\\n\\n\\nFind all possible values of k, such that it's possible to make all elements of array a equal to 0 using a finite number of elimination operations with parameter k. It can be proven that exists at least one possible k for any array a.\\n\\nNote that you firstly choose k and only after that perform elimination operations with value k you've chosen initially.\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 10^4). Description of the test cases follows.\\n\\nThe first line of each test case contains one integer n (1 \u2264 n \u2264 200 000) \u2014 the length of array a.\\n\\nThe second line of each test case contains n integers a_1, a_2, \u2026, a_n (0 \u2264 a_i < 2^{30}) \u2014 array a itself.\\n\\nIt's guaranteed that the sum of n over all test cases doesn't exceed 200 000.\\n\\nOutput\\n\\nFor each test case, print all values k, such that it's possible to make all elements of a equal to 0 in a finite number of elimination operations with the given parameter k.\\n\\nPrint them in increasing order.\\n\\nExample\\n\\nInput\\n\\n\\n5\\n4\\n4 4 4 4\\n4\\n13 7 25 19\\n6\\n3 5 3 1 7 1\\n1\\n1\\n5\\n0 0 0 0 0\\n\\n\\nOutput\\n\\n\\n1 2 4\\n1 2\\n1\\n1\\n1 2 3 4 5\\n\\nNote\\n\\nIn the first test case:\\n\\n  * If k = 1, we can make four elimination operations with sets of indices \\\\{1\\\\}, \\\\{2\\\\}, \\\\{3\\\\}, \\\\{4\\\\}. Since \\\\& of one element is equal to the element itself, then for each operation x = a_i, so a_i - x = a_i - a_i = 0. \\n  * If k = 2, we can make two elimination operations with, for example, sets of indices \\\\{1, 3\\\\} and \\\\{2, 4\\\\}: x = a_1 ~ \\\\& ~ a_3...\\nThe above is tricky. Write me a correct solution in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nlong long cnt[35];\\nsigned main() {\\n  ios_base::sync_with_stdio(false);\\n  cin.tie(NULL);\\n  cout.tie(NULL);\\n  long long t;\\n  cin >> t;\\n  while (t--) {\\n    long long n;\\n    cin >> n;\\n    memset(cnt, 0, sizeof(cnt));\\n    for (long long i = 1; i <= n; i++) {\\n      long long a;\\n      cin >> a;\\n      for (long long j = 0; j <= 31; j++)\\n        if (a & (1 << j)) cnt[j]++;\\n    }\\n    for (long long i = 1; i <= n; i++) {\\n      bool f = 1;\\n      for (long long j = 0; j <= 31; j++)\\n        if (cnt[j] % i != 0) f = 0;\\n      if (f) cout << i << \\\" \\\";\\n    }\\n    cout << \\\"\\\\n\\\";\\n  }\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in CPP?\\nThree little pigs from all over the world are meeting for a convention! Every minute, a triple of 3 new pigs arrives on the convention floor. After the n-th minute, the convention ends.\\n\\nThe big bad wolf has learned about this convention, and he has an attack plan. At some minute in the convention, he will arrive and eat exactly x pigs. Then he will get away.\\n\\nThe wolf wants Gregor to help him figure out the number of possible attack plans that involve eating exactly x pigs for various values of x (1 \u2264 x \u2264 3n). Two attack plans are considered different, if they occur at different times or if the sets of little pigs to eat are different.\\n\\nNote that all queries are independent, that is, the wolf does not eat the little pigs, he only makes plans!\\n\\nInput\\n\\nThe first line of input contains two integers n and q (1 \u2264 n \u2264 10^6, 1 \u2264 q \u2264 2\u22c5 10^5), the number of minutes the convention lasts and the number of queries the wolf asks.\\n\\nEach of the next q lines contains a single integer x_i (1 \u2264 x_i \u2264 3n), the number of pigs the wolf will eat in the i-th query.\\n\\nOutput\\n\\nYou should print q lines, with line i representing the number of attack plans if the wolf wants to eat x_i pigs. Since each query answer can be large, output each answer modulo 10^9+7.\\n\\nExamples\\n\\nInput\\n\\n\\n2 3\\n1\\n5\\n6\\n\\n\\nOutput\\n\\n\\n9\\n6\\n1\\n\\n\\nInput\\n\\n\\n5 4\\n2\\n4\\n6\\n8\\n\\n\\nOutput\\n\\n\\n225\\n2001\\n6014\\n6939\\n\\nNote\\n\\nIn the example test, n=2. Thus, there are 3 pigs at minute 1, and 6 pigs at minute 2. There are three queries: x=1, x=5, and x=6.\\n\\nIf the wolf wants to eat 1 pig, he can do so in 3+6=9 possible attack plans, depending on whether he arrives at minute 1 or 2.\\n\\nIf the wolf wants to eat 5 pigs, the wolf cannot arrive at minute 1, since there aren't enough pigs at that time. Therefore, the wolf has to arrive at minute 2, and there are 6 possible attack plans.\\n\\nIf the wolf wants to eat 6 pigs, his only plan is to arrive at the end of the convention and devour everybody.\\n\\nRemember to output your answers modulo 10^9+7!\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst int N = 3e6 + 5;\\nconst int mod = 1e9 + 7;\\nint n, m;\\nint fac[N], invf[N];\\ninline int po(int x, int k) {\\n  int res = 1;\\n  while (k) {\\n    if (k & 1) res = 1ll * res * x % mod;\\n    x = 1ll * x * x % mod;\\n    k >>= 1;\\n  }\\n  return res;\\n}\\ninline int C(int x, int y) {\\n  if (x < y) return 0;\\n  return 1ll * fac[x] * invf[y] % mod * invf[x - y] % mod;\\n}\\nlong long row[N], ans[N];\\nint main() {\\n  ios::sync_with_stdio(0);\\n  int i, j;\\n  fac[0] = 1;\\n  for (i = 1; i < N; i++) fac[i] = 1ll * fac[i - 1] * i % mod;\\n  invf[N - 1] = po(fac[N - 1], mod - 2);\\n  for (i = N - 2; i >= 0; i--) invf[i] = long long(i + 1) * invf[i + 1] % mod;\\n  int iv3 = po(3, mod - 2);\\n  cin >> n >> m;\\n  n *= 3;\\n  ans[0] = n \\/ 3 + 1;\\n  ans[1] = (long long(3 + n) * n \\/ 6) % mod;\\n  for (i = 0; i <= n; i++) row[i] = C(n + 1, i + 1);\\n  for (i = 2; i <= n; i++) {\\n    long long w =\\n        row[i] + 2 * row[i - 1] + row[i - 2] - 3 * ans[i - 1] - ans[i - 2];\\n    w = (w % mod + mod) % mod;\\n    ans[i] = iv3 * w % mod;\\n  }\\n  while (m--) {\\n    int x;\\n    cin >> x;\\n    cout << ans[x] << endl;\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in JAVA?\\nPolycarp has come up with a new game to play with you. He calls it \\\"A missing bigram\\\".\\n\\nA bigram of a word is a sequence of two adjacent letters in it.\\n\\nFor example, word \\\"abbaaba\\\" contains bigrams \\\"ab\\\", \\\"bb\\\", \\\"ba\\\", \\\"aa\\\", \\\"ab\\\" and \\\"ba\\\".\\n\\nThe game goes as follows. First, Polycarp comes up with a word, consisting only of lowercase letters 'a' and 'b'. Then, he writes down all its bigrams on a whiteboard in the same order as they appear in the word. After that, he wipes one of them off the whiteboard.\\n\\nFinally, Polycarp invites you to guess what the word that he has come up with was.\\n\\nYour goal is to find any word such that it's possible to write down all its bigrams and remove one of them, so that the resulting sequence of bigrams is the same as the one Polycarp ended up with.\\n\\nThe tests are generated in such a way that the answer exists. If there are multiple answers, you can print any of them.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 2000) \u2014 the number of testcases.\\n\\nThe first line of each testcase contains a single integer n (3 \u2264 n \u2264 100) \u2014 the length of the word Polycarp has come up with.\\n\\nThe second line of each testcase contains n-2 bigrams of that word, separated by a single space. Each bigram consists of two letters, each of them is either 'a' or 'b'.\\n\\nAdditional constraint on the input: there exists at least one string such that it is possible to write down all its bigrams, except one, so that the resulting sequence is the same as the sequence in the input. In other words, the answer exists.\\n\\nOutput\\n\\nFor each testcase print a word, consisting of n letters, each of them should be either 'a' or 'b'. It should be possible to write down all its bigrams and remove one of them, so that the resulting sequence of bigrams is the same as the one Polycarp ended up with.\\n\\nThe tests are generated in such a way that the answer exists. If there are multiple answers, you can print any of them. \\n\\nExample\\n\\nInput\\n\\n\\n4\\n7\\nab bb ba aa ba\\n7\\nab ba aa ab ba\\n3\\naa\\n5\\nbb ab...\",\"targets\":\"import java.io.OutputStream;\\nimport java.io.IOException;\\nimport java.io.InputStream;\\nimport java.io.PrintWriter;\\nimport java.util.Scanner;\\n\\n\\/**\\n * Built using CHelper plug-in\\n * Actual solution is at the top\\n *\\/\\npublic class Main {\\n    public static void main(String[] args) {\\n        InputStream inputStream = System.in;\\n        OutputStream outputStream = System.out;\\n        Scanner in = new Scanner(inputStream);\\n        PrintWriter out = new PrintWriter(outputStream);\\n        TaskB solver = new TaskB();\\n        solver.solve(1, in, out);\\n        out.close();\\n    }\\n\\n    static class TaskB {\\n        public void solve(int testNumber, Scanner in, PrintWriter out) {\\n            int T = in.nextInt();\\n            while (T-- > 0) {\\n                solveOne(in, out);\\n            }\\n        }\\n\\n        private void solveOne(Scanner in, PrintWriter out) {\\n            int N = in.nextInt() - 2;\\n            int size = N + 2;\\n            StringBuilder sb = new StringBuilder();\\n            while (N-- > 0) {\\n                sb.append(in.next());\\n            }\\n            String s = sb.toString();\\n            sb = new StringBuilder();\\n            sb.append(s.charAt(0));\\n            for (int i = 1; i <= s.length() - 2; i++) {\\n                int cnt = 1;\\n                boolean found = false;\\n                while (i < s.length() - 2 && s.charAt(i) == s.charAt(i + 1)) {\\n                    cnt++;\\n                    if (cnt % 2 == 0) sb.append(s.charAt(i));\\n                    i++;\\n                    found = true;\\n                }\\n                if (cnt % 2 == 1) sb.append(found ? s.charAt(i - 1) : s.charAt(i));\\n            }\\n            sb.append(s.charAt(s.length() - 1));\\n            if (sb.length() != size) sb.append('a');\\n            out.println(sb);\\n        }\\n\\n    }\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You are given a 1 by n pixel image. The i-th pixel of the image has color a_i. For each color, the number of pixels of that color is at most 20.\\n\\nYou can perform the following operation, which works like the bucket tool in paint programs, on this image: \\n\\n  * pick a color \u2014 an integer from 1 to n; \\n  * choose a pixel in the image; \\n  * for all pixels connected to the selected pixel, change their colors to the selected color (two pixels of the same color are considered connected if all the pixels between them have the same color as those two pixels). \\n\\n\\n\\nCompute the minimum number of operations needed to make all the pixels in the image have the same color.\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 10^3).\\n\\nThe first line of each test case contains a single integer n (1 \u2264 n \u2264 3\u22c510^3) \u2014 the number of pixels in the image.\\n\\nThe second line of each test case contains n integers a_1, a_2, \u2026, a_n (1 \u2264 a_i \u2264 n) \u2014 the colors of the pixels in the image.\\n\\nNote: for each color, the number of pixels of that color is at most 20.\\n\\nIt is guaranteed that the sum of n over all test cases does not exceed 3\u22c510^3.\\n\\nOutput\\n\\nFor each test case, print one integer: the minimum number of operations needed to make all the pixels in the image have the same color.\\n\\nExample\\n\\nInput\\n\\n\\n3\\n5\\n1 2 3 2 1\\n4\\n1 1 2 2\\n5\\n1 2 1 4 2\\n\\n\\nOutput\\n\\n\\n2\\n1\\n3\\n\\nNote\\n\\nIn the first example, the optimal solution is to apply the operation on the third pixel changing its color to 2 and then to apply the operation on any pixel that has color 2 changing its color and the color of all pixels connected to it to 1. The sequence of operations is then: [1, 2, 3, 2, 1] \u2192 [1, 2, 2, 2, 1] \u2192 [1, 1, 1, 1, 1].\\n\\nIn the second example, we can either change the 1s to 2s in one operation or change the 2s to 1s also in one operation.\\n\\nIn the third example, one possible way to make all the pixels have the same color is to apply the operation on the first, third and the fourth pixel each time changing its color to 2.\\nThe above is tricky. Write me a correct solution in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconstexpr int N = 3e3;\\nuint16_t a[N], lst[N], nxt[N], cnxt[19], dp[N][N];\\nint main() {\\n  cin.tie(0), ios::sync_with_stdio(0);\\n  int t, n;\\n  cin >> t;\\n  while (t--) {\\n    cin >> n;\\n    for (int i = 0; i < n; ++i) {\\n      cin >> a[i], --a[i];\\n    }\\n    memset(lst, 0, n * sizeof *lst);\\n    for (int i = 0; i < n; ++i) {\\n      ++lst[a[i]];\\n    }\\n    int w = -1, r = 0, purged = 0;\\n    while (r < n) {\\n      if (w >= 0 && a[w] == a[r]) {\\n        if (--lst[a[r++]] == 1) {\\n          --w;\\n          ++purged;\\n        }\\n      } else if (lst[a[r]] == 1) {\\n        ++r;\\n        ++purged;\\n      } else {\\n        a[++w] = a[r++];\\n      }\\n    }\\n    memset(lst, -1, n * sizeof *lst);\\n    n = w + 1;\\n    memset(nxt, 127, n * sizeof *nxt);\\n    for (int i = 0; i < n; ++i) {\\n      if (lst[a[i]] != (uint16_t)-1) {\\n        nxt[lst[a[i]]] = i;\\n      }\\n      lst[a[i]] = i;\\n    }\\n    for (int i = n - 1; i > -1; --i) {\\n      {\\n        auto* cnxte = cnxt;\\n        for (int z = nxt[i]; z < n; z = nxt[z]) {\\n          *cnxte++ = z;\\n        }\\n        cnxte = cnxt;\\n      }\\n      int cs = sizeof cnxt \\/ sizeof *cnxt;\\n      for (int j = i + 1; j < n && cs >= 0; ++j) {\\n        if (a[j] == a[i]) {\\n          --cs;\\n        }\\n        int t = dp[i + 1][j] - 1;\\n        const auto* z = cnxt;\\n        enum R {\\n          _00 = 0,\\n          _01,\\n          _02,\\n          _03,\\n          _04,\\n          _05,\\n          _06,\\n          _07,\\n          _08,\\n          _09,\\n          _10,\\n          _11,\\n          _12,\\n          _13,\\n          _14,\\n          _15,\\n          _16,\\n          _17,\\n          _18,\\n          _19\\n        };\\n        switch (static_cast<R>(cs)) {\\n          case _00:\\n            t = max(t, dp[i + 1][*z - 1] + dp[*z][j]), ++z;\\n            [[fallthrough]];\\n          case _01:\\n            t = max(t, dp[i + 1][*z - 1] + dp[*z][j]), ++z;\\n            [[fallthrough]];\\n          case _02:\\n            t = max(t, dp[i + 1][*z - 1] + dp[*z][j]), ++z;\\n            [[fallthrough]];\\n          case _03:\\n            t =...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"\\\"Contestant who earns a score equal to or greater than the k-th place finisher's score will advance to the next round, as long as the contestant earns a positive score...\\\" \u2014 an excerpt from contest rules.\\n\\nA total of n participants took part in the contest (n \u2265 k), and you already know their scores. Calculate how many participants will advance to the next round.\\n\\nInput\\n\\nThe first line of the input contains two integers n and k (1 \u2264 k \u2264 n \u2264 50) separated by a single space.\\n\\nThe second line contains n space-separated integers a1, a2, ..., an (0 \u2264 ai \u2264 100), where ai is the score earned by the participant who got the i-th place. The given sequence is non-increasing (that is, for all i from 1 to n - 1 the following condition is fulfilled: ai \u2265 ai + 1).\\n\\nOutput\\n\\nOutput the number of participants who advance to the next round.\\n\\nExamples\\n\\nInput\\n\\n8 5\\n10 9 8 7 7 7 5 5\\n\\n\\nOutput\\n\\n6\\n\\n\\nInput\\n\\n4 2\\n0 0 0 0\\n\\n\\nOutput\\n\\n0\\n\\nNote\\n\\nIn the first example the participant on the 5th place earned 7 points. As the participant on the 6th place also earned 7 points, there are 6 advancers.\\n\\nIn the second example nobody got a positive score.\\nUsing python3 can you solve the prior task?\",\"targets\":\"n,k=map(int,input().split())\\nscores=list(map(int,input().split()))\\ncount=0\\nlimit=scores[k-1]\\nfor i in range(n):\\n    if scores[i]>0 and scores[i]>=limit:\\n        count+=1\\nprint(count)\",\"language\":\"python\",\"split\":\"train\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"Fox Ciel is playing a game. In this game there is an infinite long tape with cells indexed by integers (positive, negative and zero). At the beginning she is standing at the cell 0.\\n\\nThere are also n cards, each card has 2 attributes: length li and cost ci. If she pays ci dollars then she can apply i-th card. After applying i-th card she becomes able to make jumps of length li, i. e. from cell x to cell (x - li) or cell (x + li).\\n\\nShe wants to be able to jump to any cell on the tape (possibly, visiting some intermediate cells). For achieving this goal, she wants to buy some cards, paying as little money as possible. \\n\\nIf this is possible, calculate the minimal cost.\\n\\nInput\\n\\nThe first line contains an integer n (1 \u2264 n \u2264 300), number of cards.\\n\\nThe second line contains n numbers li (1 \u2264 li \u2264 109), the jump lengths of cards.\\n\\nThe third line contains n numbers ci (1 \u2264 ci \u2264 105), the costs of cards.\\n\\nOutput\\n\\nIf it is impossible to buy some cards and become able to jump to any cell, output -1. Otherwise output the minimal cost of buying such set of cards.\\n\\nExamples\\n\\nInput\\n\\n3\\n100 99 9900\\n1 1 1\\n\\n\\nOutput\\n\\n2\\n\\n\\nInput\\n\\n5\\n10 20 30 40 50\\n1 1 1 1 1\\n\\n\\nOutput\\n\\n-1\\n\\n\\nInput\\n\\n7\\n15015 10010 6006 4290 2730 2310 1\\n1 1 1 1 1 1 10\\n\\n\\nOutput\\n\\n6\\n\\n\\nInput\\n\\n8\\n4264 4921 6321 6984 2316 8432 6120 1026\\n4264 4921 6321 6984 2316 8432 6120 1026\\n\\n\\nOutput\\n\\n7237\\n\\nNote\\n\\nIn first sample test, buying one card is not enough: for example, if you buy a card with length 100, you can't jump to any cell whose index is not a multiple of 100. The best way is to buy first and second card, that will make you be able to jump to any cell.\\n\\nIn the second sample test, even if you buy all cards, you can't jump to any cell whose index is not a multiple of 10, so you should output -1.\\\":\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst int inf = 0x3f3f3f3f;\\nconst long long INF = 0x3f3f3f3f3f3f3f3f;\\nlong long mul(long long x, long long y, long long Z) {\\n  long long tmp = x \\/ (long double)Z * y + 1e-3;\\n  return (x * y + Z - tmp * Z) % Z;\\n}\\nlong long MUL(long long x, long long p, long long Z) {\\n  long long y = 1;\\n  while (p) {\\n    if (p & 1) y = mul(y, x, Z);\\n    x = mul(x, x, Z);\\n    p >>= 1;\\n  }\\n  return y;\\n}\\nbool miller_rabin(long long n) {\\n  if (n <= 1) return 0;\\n  if (n == 2) return 1;\\n  if (n % 2 == 0) return 0;\\n  long long p = n - 1;\\n  srand(time(NULL));\\n  int TIMES = 8;\\n  for (int i = 1; i <= TIMES; i++) {\\n    long long x = rand() % (n - 1) + 1;\\n    if (MUL(x, p, n) != 1) return 0;\\n  }\\n  return 1;\\n}\\nlong long gcd(long long a, long long b) {\\n  if (a < b) {\\n    swap(a, b);\\n  }\\n  while (a % b) {\\n    long long r = a % b;\\n    a = b;\\n    b = r;\\n  }\\n  return b;\\n}\\nint a[400], c[400];\\nint main() {\\n  ios_base::sync_with_stdio(false);\\n  cin.tie(NULL);\\n  cout.tie(NULL);\\n  int n;\\n  while (cin >> n) {\\n    map<int, int> dp;\\n    for (int i = 0; i < n; i++) {\\n      cin >> a[i];\\n    }\\n    for (int i = 0; i < n; i++) {\\n      cin >> c[i];\\n      if (dp.find(a[i]) == dp.end())\\n        dp[a[i]] = c[i];\\n      else\\n        dp[a[i]] = min(dp[a[i]], c[i]);\\n    }\\n    map<int, int>::iterator it;\\n    for (int i = 0; i < n; i++) {\\n      for (it = dp.begin(); it != dp.end(); it++) {\\n        long long t = gcd(it->first, a[i]);\\n        if (dp.find(t) == dp.end())\\n          dp[t] = c[i] + it->second;\\n        else\\n          dp[t] = min(dp[t], c[i] + it->second);\\n      }\\n    }\\n    if (dp.find(1) != dp.end())\\n      cout << dp[1] << endl;\\n    else\\n      cout << -1 << endl;\\n  }\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Luntik has decided to try singing. He has a one-minute songs, b two-minute songs and c three-minute songs. He wants to distribute all songs into two concerts such that every song should be included to exactly one concert.\\n\\nHe wants to make the absolute difference of durations of the concerts as small as possible. The duration of the concert is the sum of durations of all songs in that concert.\\n\\nPlease help Luntik and find the minimal possible difference in minutes between the concerts durations.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 1000) \u2014 the number of test cases.\\n\\nEach test case consists of one line containing three integers a, b, c (1 \u2264 a, b, c \u2264 10^9) \u2014 the number of one-minute, two-minute and three-minute songs.\\n\\nOutput\\n\\nFor each test case print the minimal possible difference in minutes between the concerts durations.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n1 1 1\\n2 1 3\\n5 5 5\\n1 1 2\\n\\n\\nOutput\\n\\n\\n0\\n1\\n0\\n1\\n\\nNote\\n\\nIn the first test case, Luntik can include a one-minute song and a two-minute song into the first concert, and a three-minute song into the second concert. Then the difference will be equal to 0.\\n\\nIn the second test case, Luntik can include two one-minute songs and a two-minute song and a three-minute song into the first concert, and two three-minute songs into the second concert. The duration of the first concert will be 1 + 1 + 2 + 3 = 7, the duration of the second concert will be 6. The difference of them is |7-6| = 1.\\nSolve the task in PYTHON3.\",\"targets\":\"t = int(input(\\\"\\\"))\\nfor i in range(t):\\n    numbers = list(map(int, input(\\\"\\\").split(\\\" \\\")))\\n    if(((numbers[0]) + (numbers[1]*2) + (numbers[2]*3)) % 2 == 0):\\n        print(0)\\n    else:\\n        print(1)\",\"language\":\"python\",\"split\":\"test\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Stephen Queen wants to write a story. He is a very unusual writer, he uses only letters 'a', 'b', 'c', 'd' and 'e'!\\n\\nTo compose a story, Stephen wrote out n words consisting of the first 5 lowercase letters of the Latin alphabet. He wants to select the maximum number of words to make an interesting story.\\n\\nLet a story be a sequence of words that are not necessarily different. A story is called interesting if there exists a letter which occurs among all words of the story more times than all other letters together.\\n\\nFor example, the story consisting of three words \\\"bac\\\", \\\"aaada\\\", \\\"e\\\" is interesting (the letter 'a' occurs 5 times, all other letters occur 4 times in total). But the story consisting of two words \\\"aba\\\", \\\"abcde\\\" is not (no such letter that it occurs more than all other letters in total).\\n\\nYou are given a sequence of n words consisting of letters 'a', 'b', 'c', 'd' and 'e'. Your task is to choose the maximum number of them to make an interesting story. If there's no way to make a non-empty story, output 0.\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 5000) \u2014 the number of test cases. Then t test cases follow.\\n\\nThe first line of each test case contains one integer n (1 \u2264 n \u2264 2 \u22c5 10^5) \u2014 the number of the words in the sequence. Then n lines follow, each of them contains a word \u2014 a non-empty string consisting of lowercase letters of the Latin alphabet. The words in the sequence may be non-distinct (i. e. duplicates are allowed). Only the letters 'a', 'b', 'c', 'd' and 'e' may occur in the words.\\n\\nIt is guaranteed that the sum of n over all test cases doesn't exceed 2 \u22c5 10^5; the sum of the lengths of all words over all test cases doesn't exceed 4 \u22c5 10^5.\\n\\nOutput\\n\\nFor each test case, output the maximum number of words that compose an interesting story. Print 0 if there's no way to make a non-empty interesting story.\\n\\nExample\\n\\nInput\\n\\n\\n6\\n3\\nbac\\naaada\\ne\\n3\\naba\\nabcde\\naba\\n2\\nbaba\\nbaba\\n4\\nab\\nab\\nc\\nbc\\n5\\ncbdca\\nd\\na\\nd\\ne\\n3\\nb\\nc\\nca\\n\\n\\nOutput\\n\\n\\n3\\n2\\n0\\n2\\n3\\n2\\n\\nNote\\n\\nIn the first test case of the example, all 3 words...\\nSolve the task in PYTHON3.\",\"targets\":\"# Author Name: Ajay Meena\\n# Codeforce : https:\\/\\/codeforces.com\\/profile\\/majay1638\\nimport sys\\nimport math\\nimport bisect\\nimport heapq\\nfrom bisect import bisect_right\\nfrom sys import stdin, stdout\\n\\n# -------------- INPUT FUNCTIONS ------------------\\n\\n\\ndef get_ints_in_variables(): return map(\\n    int, sys.stdin.readline().strip().split())\\n\\n\\ndef get_int(): return int(sys.stdin.readline())\\n\\n\\ndef get_ints_in_list(): return list(\\n    map(int, sys.stdin.readline().strip().split()))\\ndef get_list_of_list(n): return [list(\\n    map(int, sys.stdin.readline().strip().split())) for _ in range(n)]\\n\\n\\ndef get_string(): return sys.stdin.readline().strip()\\n\\n# -------- SOME CUSTOMIZED FUNCTIONS-----------\\n\\n\\ndef myceil(x, y): return (x + y - 1) \\/\\/ y\\n\\n# -------------- SOLUTION FUNCTION ------------------\\n\\n\\ndef Solution(arr, n):\\n    # Write Your Code Here\\n\\n    freq = []\\n    ans = 0\\n    for s in arr:\\n        hm = [0, 0, 0, 0, 0]\\n        for c in s:\\n            hm[ord(c)-97] += 1\\n        freq.append(hm)\\n    for i in range(5):\\n        queue = []\\n        for j in range(n):\\n            itm = freq[j]\\n            sm = sum(itm)\\n            heapq.heappush(queue, -1*(itm[i]-(sm-itm[i])))\\n        sm = 0\\n        tmpAns = 0\\n        # print(queue)\\n        while len(queue):\\n            v = -1*heapq.heappop(queue)\\n            if sm+v > 0:\\n                tmpAns += 1\\n                sm += v\\n            else:\\n                break\\n\\n        ans = max(ans, tmpAns)\\n    print(ans)\\n\\n\\ndef main():\\n    # Take input Here and Call solution function\\n    for _ in range(get_int()):\\n        n = get_int()\\n        arr = [get_string() for _ in range(n)]\\n        Solution(arr, n)\\n\\n\\n# calling main Function\\nif __name__ == '__main__':\\n    main()\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"An array b is called to be a subarray of a if it forms a continuous subsequence of a, that is, if it is equal to a_l, a_{l + 1}, \u2026, a_r for some l, r.\\n\\nSuppose m is some known constant. For any array, having m or more elements, let's define it's beauty as the sum of m largest elements of that array. For example: \\n\\n  * For array x = [4, 3, 1, 5, 2] and m = 3, the 3 largest elements of x are 5, 4 and 3, so the beauty of x is 5 + 4 + 3 = 12.\\n  * For array x = [10, 10, 10] and m = 2, the beauty of x is 10 + 10 = 20.\\n\\n\\n\\nYou are given an array a_1, a_2, \u2026, a_n, the value of the said constant m and an integer k. Your need to split the array a into exactly k subarrays such that:\\n\\n  * Each element from a belongs to exactly one subarray.\\n  * Each subarray has at least m elements.\\n  * The sum of all beauties of k subarrays is maximum possible.\\n\\nInput\\n\\nThe first line contains three integers n, m and k (2 \u2264 n \u2264 2 \u22c5 10^5, 1 \u2264 m, 2 \u2264 k, m \u22c5 k \u2264 n) \u2014 the number of elements in a, the constant m in the definition of beauty and the number of subarrays to split to.\\n\\nThe second line contains n integers a_1, a_2, \u2026, a_n (-10^9 \u2264 a_i \u2264 10^9).\\n\\nOutput\\n\\nIn the first line, print the maximum possible sum of the beauties of the subarrays in the optimal partition.\\n\\nIn the second line, print k-1 integers p_1, p_2, \u2026, p_{k-1} (1 \u2264 p_1 < p_2 < \u2026 < p_{k-1} < n) representing the partition of the array, in which:\\n\\n  * All elements with indices from 1 to p_1 belong to the first subarray.\\n  * All elements with indices from p_1 + 1 to p_2 belong to the second subarray.\\n  * \u2026.\\n  * All elements with indices from p_{k-1} + 1 to n belong to the last, k-th subarray.\\n\\n\\n\\nIf there are several optimal partitions, print any of them.\\n\\nExamples\\n\\nInput\\n\\n\\n9 2 3\\n5 2 5 2 4 1 1 3 2\\n\\n\\nOutput\\n\\n\\n21\\n3 5 \\n\\nInput\\n\\n\\n6 1 4\\n4 1 3 2 2 3\\n\\n\\nOutput\\n\\n\\n12\\n1 3 5 \\n\\nInput\\n\\n\\n2 1 2\\n-1000000000 1000000000\\n\\n\\nOutput\\n\\n\\n0\\n1 \\n\\nNote\\n\\nIn the first example, one of the optimal partitions is [5, 2, 5], [2, 4], [1, 1, 3, 2].\\n\\n  * The beauty of the subarray [5, 2, 5] is 5 + 5 = 10. \\n  * The...\\nSolve the task in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nsigned main() {\\n  ios_base::sync_with_stdio(false);\\n  cin.tie(0);\\n  long long n, m, k;\\n  cin >> n >> m >> k;\\n  vector<long long> a(n);\\n  for (auto &t : a) {\\n    cin >> t;\\n  }\\n  vector<long long> ind;\\n  for (long long i = 0; i < n; i++) {\\n    ind.push_back(i);\\n  }\\n  sort(ind.rbegin(), ind.rend(),\\n       [&](long long i, long long j) { return a[i] < a[j]; });\\n  long long ans = 0;\\n  vector<long long> cut(m * k);\\n  for (long long i = 0; i < m * k; i++) {\\n    ans += a[ind[i]];\\n    cut[i] = ind[i];\\n  }\\n  sort(cut.begin(), cut.end());\\n  cout << ans << '\\\\n';\\n  long long cnt = 0;\\n  long long uu = 0;\\n  for (long long i = 0; i < n; i++) {\\n    auto it = lower_bound(cut.begin(), cut.end(), i);\\n    bool fl = false;\\n    if (it != cut.end() && *(it) == i) {\\n      fl = true;\\n    }\\n    if (fl) {\\n      cnt++;\\n    }\\n    if (cnt == m && uu < k - 1) {\\n      uu++;\\n      cnt = 0;\\n      cout << i + 1 << ' ';\\n    }\\n  }\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in PYTHON3?\\n<image>\\n\\nWilliam has two numbers a and b initially both equal to zero. William mastered performing three different operations with them quickly. Before performing each operation some positive integer k is picked, which is then used to perform one of the following operations: (note, that for each operation you can choose a new positive integer k)\\n\\n  1. add number k to both a and b, or \\n  2. add number k to a and subtract k from b, or \\n  3. add number k to b and subtract k from a. \\n\\n\\n\\nNote that after performing operations, numbers a and b may become negative as well.\\n\\nWilliam wants to find out the minimal number of operations he would have to perform to make a equal to his favorite number c and b equal to his second favorite number d.\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 10^4). Description of the test cases follows.\\n\\nThe only line of each test case contains two integers c and d (0 \u2264 c, d \u2264 10^9), which are William's favorite numbers and which he wants a and b to be transformed into.\\n\\nOutput\\n\\nFor each test case output a single number, which is the minimal number of operations which William would have to perform to make a equal to c and b equal to d, or -1 if it is impossible to achieve this using the described operations.\\n\\nExample\\n\\nInput\\n\\n\\n6\\n1 2\\n3 5\\n5 3\\n6 6\\n8 0\\n0 0\\n\\n\\nOutput\\n\\n\\n-1\\n2\\n2\\n1\\n2\\n0\\n\\nNote\\n\\nLet us demonstrate one of the suboptimal ways of getting a pair (3, 5):\\n\\n  * Using an operation of the first type with k=1, the current pair would be equal to (1, 1). \\n  * Using an operation of the third type with k=8, the current pair would be equal to (-7, 9). \\n  * Using an operation of the second type with k=7, the current pair would be equal to (0, 2). \\n  * Using an operation of the first type with k=3, the current pair would be equal to (3, 5).\",\"targets\":\"t=int(input())\\nfor k in range(t):\\n  a,b=map(int,input().split())\\n  c=(a+b)\\/2\\n  if c==int(c) and b!=a:\\n    print(2)\\n  elif b==a and b!=0:\\n    print(1)\\n  elif a==0 and b==0:\\n    print(0)\\n  else:\\n    print(-1)\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Stephen Queen wants to write a story. He is a very unusual writer, he uses only letters 'a', 'b', 'c', 'd' and 'e'!\\n\\nTo compose a story, Stephen wrote out n words consisting of the first 5 lowercase letters of the Latin alphabet. He wants to select the maximum number of words to make an interesting story.\\n\\nLet a story be a sequence of words that are not necessarily different. A story is called interesting if there exists a letter which occurs among all words of the story more times than all other letters together.\\n\\nFor example, the story consisting of three words \\\"bac\\\", \\\"aaada\\\", \\\"e\\\" is interesting (the letter 'a' occurs 5 times, all other letters occur 4 times in total). But the story consisting of two words \\\"aba\\\", \\\"abcde\\\" is not (no such letter that it occurs more than all other letters in total).\\n\\nYou are given a sequence of n words consisting of letters 'a', 'b', 'c', 'd' and 'e'. Your task is to choose the maximum number of them to make an interesting story. If there's no way to make a non-empty story, output 0.\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 5000) \u2014 the number of test cases. Then t test cases follow.\\n\\nThe first line of each test case contains one integer n (1 \u2264 n \u2264 2 \u22c5 10^5) \u2014 the number of the words in the sequence. Then n lines follow, each of them contains a word \u2014 a non-empty string consisting of lowercase letters of the Latin alphabet. The words in the sequence may be non-distinct (i. e. duplicates are allowed). Only the letters 'a', 'b', 'c', 'd' and 'e' may occur in the words.\\n\\nIt is guaranteed that the sum of n over all test cases doesn't exceed 2 \u22c5 10^5; the sum of the lengths of all words over all test cases doesn't exceed 4 \u22c5 10^5.\\n\\nOutput\\n\\nFor each test case, output the maximum number of words that compose an interesting story. Print 0 if there's no way to make a non-empty interesting story.\\n\\nExample\\n\\nInput\\n\\n\\n6\\n3\\nbac\\naaada\\ne\\n3\\naba\\nabcde\\naba\\n2\\nbaba\\nbaba\\n4\\nab\\nab\\nc\\nbc\\n5\\ncbdca\\nd\\na\\nd\\ne\\n3\\nb\\nc\\nca\\n\\n\\nOutput\\n\\n\\n3\\n2\\n0\\n2\\n3\\n2\\n\\nNote\\n\\nIn the first test case of the example, all 3 words...\\n#incl\",\"targets\":\"ude <bits\\/stdc++.h>\\nusing namespace std;\\nlong long mod = 1e9 + 7;\\nint main() {\\n  ios_base::sync_with_stdio(false);\\n  cin.tie(0);\\n  cout.tie(0);\\n  long long t;\\n  t = 1;\\n  cin >> t;\\n  long long t1 = t;\\n  while (t1--) {\\n    long long n;\\n    cin >> n;\\n    vector<long long> a1;\\n    vector<long long> b1;\\n    vector<long long> c1, d1, e1;\\n    for (long long i = 0; i < n; i++) {\\n      string s;\\n      cin >> s;\\n      long long c_a = 0, c_b = 0, c_c = 0, c_d = 0, c_e = 0;\\n      for (long long j = 0; j < s.length(); j++) {\\n        if (s[j] == 'a') c_a++;\\n        if (s[j] == 'b') c_b++;\\n        if (s[j] == 'c') c_c++;\\n        if (s[j] == 'd') c_d++;\\n        if (s[j] == 'e') c_e++;\\n      }\\n      long long len = s.length();\\n      a1.push_back(2 * c_a - len);\\n      b1.push_back(2 * c_b - len);\\n      c1.push_back(2 * c_c - len);\\n      d1.push_back(2 * c_d - len);\\n      e1.push_back(2 * c_e - len);\\n    }\\n    sort(a1.begin(), a1.end());\\n    sort(b1.begin(), b1.end());\\n    sort(c1.begin(), c1.end());\\n    sort(d1.begin(), d1.end());\\n    sort(e1.begin(), e1.end());\\n    long long ans = 0;\\n    long long sum = 0;\\n    long long per = 0;\\n    for (long long i = a1.size() - 1; i >= 0; i--) {\\n      sum += a1[i];\\n      if (sum <= 0) break;\\n      per++;\\n    }\\n    ans = max(ans, per);\\n    sum = 0;\\n    per = 0;\\n    for (long long i = b1.size() - 1; i >= 0; i--) {\\n      sum += b1[i];\\n      if (sum <= 0) break;\\n      per++;\\n    }\\n    ans = max(ans, per);\\n    sum = 0;\\n    per = 0;\\n    for (long long i = c1.size() - 1; i >= 0; i--) {\\n      sum += c1[i];\\n      if (sum <= 0) break;\\n      per++;\\n    }\\n    ans = max(ans, per);\\n    sum = 0;\\n    per = 0;\\n    for (long long i = d1.size() - 1; i >= 0; i--) {\\n      sum += d1[i];\\n      if (sum <= 0) break;\\n      per++;\\n    }\\n    ans = max(ans, per);\\n    sum = 0;\\n    per = 0;\\n    for (long long i = e1.size() - 1; i >= 0; i--) {\\n      sum += e1[i];\\n      if (sum <= 0) break;\\n      per++;\\n    }\\n    ans = max(ans, per);\\n    cout << ans << endl;\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in CPP?\\nCasimir has a string s which consists of capital Latin letters 'A', 'B', and 'C' only. Each turn he can choose to do one of the two following actions:\\n\\n  * he can either erase exactly one letter 'A' and exactly one letter 'B' from arbitrary places of the string (these letters don't have to be adjacent); \\n  * or he can erase exactly one letter 'B' and exactly one letter 'C' from arbitrary places in the string (these letters don't have to be adjacent). \\n\\n\\n\\nTherefore, each turn the length of the string is decreased exactly by 2. All turns are independent so for each turn, Casimir can choose any of two possible actions.\\n\\nFor example, with s = \\\"ABCABC\\\" he can obtain a string s = \\\"ACBC\\\" in one turn (by erasing the first occurrence of 'B' and the second occurrence of 'A'). There are also many other options for a turn aside from this particular example.\\n\\nFor a given string s determine whether there is a sequence of actions leading to an empty string. In other words, Casimir's goal is to erase all letters from the string. Is there a way to do this?\\n\\nInput\\n\\nThe first line contains an integer t (1 \u2264 t \u2264 1000) \u2014 the number of test cases.\\n\\nEach test case is described by one string s, for which you need to determine if it can be fully erased by some sequence of turns. The string s consists of capital letters 'A', 'B', 'C' and has a length from 1 to 50 letters, inclusive.\\n\\nOutput\\n\\nPrint t lines, each line containing the answer to the corresponding test case. The answer to a test case should be YES if there is a way to fully erase the corresponding string and NO otherwise.\\n\\nYou may print every letter in any case you want (so, for example, the strings yEs, yes, Yes, and YES will all be recognized as positive answers).\\n\\nExample\\n\\nInput\\n\\n\\n6\\nABACAB\\nABBA\\nAC\\nABC\\nCABCBB\\nBCBCBCBCBCBCBCBC\\n\\n\\nOutput\\n\\n\\nNO\\nYES\\nNO\\nNO\\nYES\\nYES\",\"targets\":\"#include <bits\\/stdc++.h>\\nint main(void) {\\n  std::ios::sync_with_stdio(false);\\n  std::cin.tie(nullptr);\\n  std::cout.tie(nullptr);\\n  int testCase = 1;\\n  std::cin >> testCase;\\n  while (testCase--) {\\n    std::string A;\\n    std::cin >> A;\\n    std::vector<int> c(3, 0);\\n    for (auto x : A) ++c[x - 'A'];\\n    puts((c[0] + c[2] == c[1]) ? \\\"YES\\\" : \\\"NO\\\");\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Alice and Bob are playing a game. They are given an array A of length N. The array consists of integers. They are building a sequence together. In the beginning, the sequence is empty. In one turn a player can remove a number from the left or right side of the array and append it to the sequence. The rule is that the sequence they are building must be strictly increasing. The winner is the player that makes the last move. Alice is playing first. Given the starting array, under the assumption that they both play optimally, who wins the game?\\n\\nInput\\n\\nThe first line contains one integer N (1 \u2264 N \u2264 2*10^5) - the length of the array A.\\n\\nThe second line contains N integers A_1, A_2,...,A_N (0 \u2264 A_i \u2264 10^9)\\n\\nOutput\\n\\nThe first and only line of output consists of one string, the name of the winner. If Alice won, print \\\"Alice\\\", otherwise, print \\\"Bob\\\".\\n\\nExamples\\n\\nInput\\n\\n\\n1\\n5\\n\\n\\nOutput\\n\\n\\nAlice\\n\\n\\nInput\\n\\n\\n3\\n5 4 5\\n\\n\\nOutput\\n\\n\\nAlice\\n\\n\\nInput\\n\\n\\n6\\n5 8 2 1 10 9\\n\\n\\nOutput\\n\\n\\nBob\\nSolve the task in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst long long maxn = 2e6 + 15, inf = 2e9, lg = 26, M = 1e9 + 7;\\nint main() {\\n  int n, ans = 0, l = 1, r, lindex, rindex, cnt = 0;\\n  string s[2] = {\\\"Alice\\\", \\\"Bob\\\"};\\n  cin >> n;\\n  r = n;\\n  int a[n + 2];\\n  for (int i = 1; i < n + 1; i++) cin >> a[i];\\n  a[0] = a[n + 1] = -1;\\n  for (int i = 1; i < n + 1; i++) {\\n    if (a[i] <= a[i - 1]) {\\n      lindex = i - 1;\\n      break;\\n    }\\n  }\\n  for (int i = n; i > 0; i--) {\\n    if (a[i] >= a[i - 1]) {\\n      rindex = i;\\n      break;\\n    }\\n  }\\n  if (n == 1) {\\n    cout << \\\"Alice\\\";\\n    return 0;\\n  }\\n  while (true) {\\n    if ((a[l] >= a[r] && (lindex - l + 1) % 2) ||\\n        (a[r] >= a[l] && (r - rindex + 1) % 2)) {\\n      cout << s[ans];\\n      break;\\n    }\\n    if (a[l] == a[r]) {\\n      ans = 1 - ans;\\n      cout << s[ans];\\n      break;\\n    }\\n    if (a[l] < a[r]) {\\n      while (a[l] < a[r] && l < lindex) {\\n        l++;\\n        ans = 1 - ans;\\n      }\\n    } else {\\n      while (a[r] < a[l] && r > rindex) {\\n        r--;\\n        ans = 1 - ans;\\n      }\\n    }\\n    if (l == lindex) {\\n      ans = ((r - rindex + 1) % 2) - ans;\\n      cout << s[abs(ans)];\\n      break;\\n    }\\n    if (r == rindex) {\\n      ans = ((lindex - l + 1) % 2) - ans;\\n      cout << s[abs(ans)];\\n      break;\\n    }\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You are given two integers n and m. Find the \\\\operatorname{MEX} of the sequence n \u2295 0, n \u2295 1, \u2026, n \u2295 m. Here, \u2295 is the [bitwise XOR operator](https:\\/\\/en.wikipedia.org\\/wiki\\/Bitwise_operation#XOR).\\n\\n\\\\operatorname{MEX} of the sequence of non-negative integers is the smallest non-negative integer that doesn't appear in this sequence. For example, \\\\operatorname{MEX}(0, 1, 2, 4) = 3, and \\\\operatorname{MEX}(1, 2021) = 0. \\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 30 000) \u2014 the number of test cases.\\n\\nThe first and only line of each test case contains two integers n and m (0 \u2264 n, m \u2264 10^9).\\n\\nOutput\\n\\nFor each test case, print a single integer \u2014 the answer to the problem.\\n\\nExample\\n\\nInput\\n\\n\\n5\\n3 5\\n4 6\\n3 2\\n69 696\\n123456 654321\\n\\n\\nOutput\\n\\n\\n4\\n3\\n0\\n640\\n530866\\n\\nNote\\n\\nIn the first test case, the sequence is 3 \u2295 0, 3 \u2295 1, 3 \u2295 2, 3 \u2295 3, 3 \u2295 4, 3 \u2295 5, or 3, 2, 1, 0, 7, 6. The smallest non-negative integer which isn't present in the sequence i. e. the \\\\operatorname{MEX} of the sequence is 4.\\n\\nIn the second test case, the sequence is 4 \u2295 0, 4 \u2295 1, 4 \u2295 2, 4 \u2295 3, 4 \u2295 4, 4 \u2295 5, 4 \u2295 6, or 4, 5, 6, 7, 0, 1, 2. The smallest non-negative integer which isn't present in the sequence i. e. the \\\\operatorname{MEX} of the sequence is 3.\\n\\nIn the third test case, the sequence is 3 \u2295 0, 3 \u2295 1, 3 \u2295 2, or 3, 2, 1. The smallest non-negative integer which isn't present in the sequence i. e. the \\\\operatorname{MEX} of the sequence is 0.\\nUsing python3 can you solve the prior task?\",\"targets\":\"import sys\\nfrom math import *\\nimport builtins\\nimport string\\nimport bisect\\n\\nalphabets = list(string.ascii_lowercase)\\nALPHABETS = list(string.ascii_uppercase)\\n\\n# # For getting input from input.txt file\\n# sys.stdin = open('input.txt', 'r')\\n#\\n# # Printing the Output to output.txt file\\n# sys.stdout = open('output.txt', 'w')\\n\\n# input = sys.stdin.readline\\n\\n\\ndef print(x, end='\\\\n'):\\n    sys.stdout.write(str(x) + end)\\n\\n\\n# IO helpers\\ndef get_int():\\n    return int(input())\\n\\n\\ndef get_list_ints():\\n    return list(map(int, input().split()))\\n\\n\\ndef get_char_list():\\n    s = input()\\n    return list(s[:len(s)])\\n\\n\\ndef get_tuple_ints():\\n    return tuple(map(int, input().split()))\\n\\n\\ndef print_iterable(p):\\n    print(\\\" \\\".join(map(str, p)))\\n\\n\\ndef floorSearch(arr, low, high, x):\\n    if low > high:\\n        return -1\\n    if x >= arr[high]:\\n        return high\\n    mid = int((low + high) \\/ 2)\\n    if arr[mid] == x:\\n        return mid\\n    if mid > 0 and arr[mid - 1] <= x < arr[mid]:\\n        return mid - 1\\n    if x < arr[mid]:\\n        return floorSearch(arr, low, mid - 1, x)\\n    return floorSearch(arr, mid + 1, high, x)\\n\\n\\ndef binary_search(arr, x):\\n    low = 0\\n    high = len(arr) - 1\\n    mid = 0\\n    while low <= high:\\n        mid = (high + low) \\/\\/ 2\\n        if arr[mid] < x:\\n            low = mid + 1\\n        elif arr[mid] > x:\\n            high = mid - 1\\n        else:\\n            return mid\\n    return high\\n\\n\\ndef main():\\n    p = get_int()\\n    for q in range(p):\\n        n, m = get_list_ints()\\n        ans = 0\\n        m += 1\\n        for k in range(30, -1, -1):\\n            if n >= m:\\n                break\\n            if (n >> k & 1) == (m >> k & 1):\\n                pass\\n            elif (m >> k & 1) == 1:\\n                ans |= 1 << k\\n                n |= 1 << k\\n                m |= 1 << k\\n        print(ans)\\n    pass\\n\\n\\nif __name__ == '__main__':\\n    main()\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You are given an array a of length n.\\n\\nLet's define the eversion operation. Let x = a_n. Then array a is partitioned into two parts: left and right. The left part contains the elements of a that are not greater than x (\u2264 x). The right part contains the elements of a that are strictly greater than x (> x). The order of elements in each part is kept the same as before the operation, i. e. the partition is stable. Then the array is replaced with the concatenation of the left and the right parts.\\n\\nFor example, if the array a is [2, 4, 1, 5, 3], the eversion goes like this: [2, 4, 1, 5, 3] \u2192 [2, 1, 3], [4, 5] \u2192 [2, 1, 3, 4, 5].\\n\\nWe start with the array a and perform eversions on this array. We can prove that after several eversions the array a stops changing. Output the minimum number k such that the array stops changing after k eversions.\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 100). Description of the test cases follows.\\n\\nThe first line contains a single integer n (1 \u2264 n \u2264 2 \u22c5 10^5).\\n\\nThe second line contains n integers a_1, a_2, ..., a_n (1 \u2264 a_i \u2264 10^9).\\n\\nIt is guaranteed that the sum of n over all test cases does not exceed 2 \u22c5 10^5.\\n\\nOutput\\n\\nFor each test case print a single integer k \u2014 the number of eversions after which the array stops changing.\\n\\nExample\\n\\nInput\\n\\n\\n3\\n5\\n2 4 1 5 3\\n5\\n5 3 2 4 1\\n4\\n1 1 1 1\\n\\n\\nOutput\\n\\n\\n1\\n2\\n0\\n\\nNote\\n\\nConsider the fist example.\\n\\n  * The first eversion: a = [1, 4, 2, 5, 3], x = 3. [2, 4, 1, 5, 3] \u2192 [2, 1, 3], [4, 5] \u2192 [2, 1, 3, 4, 5]. \\n  * The second and following eversions: a = [2, 1, 3, 4, 5], x = 5. [2, 1, 3, 4, 5] \u2192 [2, 1, 3, 4, 5], [] \u2192 [2, 1, 3, 4, 5]. This eversion does not change the array, so the answer is 1. \\n\\n\\n\\nConsider the second example. \\n\\n  * The first eversion: a = [5, 3, 2, 4, 1], x = 1. [5, 3, 2, 4, 1] \u2192 [1], [5, 3, 2, 4] \u2192 [1, 5, 3, 2, 4]. \\n  * The second eversion: a = [1, 5, 3, 2, 4], x = 4. [1, 5, 3, 2, 4] \u2192 [1, 3, 2, 4], [5] \u2192 [1, 3, 2, 4, 5]. \\n  * The third and following eversions: a = [1, 3, 2, 4,...\\nThe above is tricky. Write me a correct solution in JAVA.\",\"targets\":\"import java.util.*;\\nimport java.io.*;\\n\\npublic class B {\\n\\tpublic static void main(String[] args) {\\n\\t\\tScanner sc = new Scanner(System.in);\\n\\t\\tPrintWriter out = new PrintWriter(System.out);\\n\\n\\t\\tint t = sc.nextInt();\\n\\t\\tfor (; t > 0; t--) {\\n\\t\\t\\tint n = sc.nextInt();\\n\\t\\t\\tvar a = new int[n];\\n\\n\\t\\t\\tint max = 0;\\n\\t\\t\\tfor (int i = 0; i < n; i++) {\\n\\t\\t\\t\\ta[i] = sc.nextInt();\\n\\t\\t\\t\\tmax = Math.max(max, a[i]);\\n\\t\\t\\t}\\n\\n\\t\\t\\tif (a[n-1] == max) {\\n\\t\\t\\t\\tout.println(0);\\n\\t\\t\\t\\tcontinue;\\n\\t\\t\\t}\\n\\n\\t\\t\\tint prev = a[n-1];\\n\\t\\t\\tint cnt = 0;\\n\\n\\t\\t\\tfor (int i = n-2; i >= 0; i--) {\\n\\t\\t\\t\\tif (a[i] > prev) {\\n\\t\\t\\t\\t\\tprev = a[i];\\n\\t\\t\\t\\t\\tcnt++;\\n\\n\\t\\t\\t\\t\\tif (a[i] == max) \\n\\t\\t\\t\\t\\t\\tbreak;\\n\\t\\t\\t\\t}\\n\\t\\t\\t}\\n\\n\\t\\t\\tout.println(cnt);\\n\\t\\t}\\n\\n\\t\\tout.close();\\n\\t\\tsc.close();\\n\\t}\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in PYTHON3?\\nPolycarp must pay exactly n burles at the checkout. He has coins of two nominal values: 1 burle and 2 burles. Polycarp likes both kinds of coins equally. So he doesn't want to pay with more coins of one type than with the other.\\n\\nThus, Polycarp wants to minimize the difference between the count of coins of 1 burle and 2 burles being used. Help him by determining two non-negative integer values c_1 and c_2 which are the number of coins of 1 burle and 2 burles, respectively, so that the total value of that number of coins is exactly n (i. e. c_1 + 2 \u22c5 c_2 = n), and the absolute value of the difference between c_1 and c_2 is as little as possible (i. e. you must minimize |c_1-c_2|).\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases. Then t test cases follow.\\n\\nEach test case consists of one line. This line contains one integer n (1 \u2264 n \u2264 10^9) \u2014 the number of burles to be paid by Polycarp.\\n\\nOutput\\n\\nFor each test case, output a separate line containing two integers c_1 and c_2 (c_1, c_2 \u2265 0) separated by a space where c_1 is the number of coins of 1 burle and c_2 is the number of coins of 2 burles. If there are multiple optimal solutions, print any one.\\n\\nExample\\n\\nInput\\n\\n\\n6\\n1000\\n30\\n1\\n32\\n1000000000\\n5\\n\\n\\nOutput\\n\\n\\n334 333\\n10 10\\n1 0\\n10 11\\n333333334 333333333\\n1 2\\n\\nNote\\n\\nThe answer for the first test case is \\\"334 333\\\". The sum of the nominal values of all coins is 334 \u22c5 1 + 333 \u22c5 2 = 1000, whereas |334 - 333| = 1. One can't get the better value because if |c_1 - c_2| = 0, then c_1 = c_2 and c_1 \u22c5 1 + c_1 \u22c5 2 = 1000, but then the value of c_1 isn't an integer.\\n\\nThe answer for the second test case is \\\"10 10\\\". The sum of the nominal values is 10 \u22c5 1 + 10 \u22c5 2 = 30 and |10 - 10| = 0, whereas there's no number having an absolute value less than 0.\",\"targets\":\"from math import *\\nt=int(input())\\nfor _ in range(t):\\n    n=int(input())\\n    if(n%3==0):\\n        print(str(int(n\\/3))+\\\" \\\"+ str(int(n\\/3)))\\n    elif(n%3==1):\\n        print(str(int(n\\/3)+1)+\\\" \\\"+str(int(n\\/3)))\\n    else:\\n        print(str(int(n\\/3))+\\\" \\\"+str(int(n\\/3)+1))\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Example\\n\\nInput\\n\\n2 4\\n%.@\\\\$\\n..\\\\$\\\\$\\n\\n\\nOutput\\n\\nYes\\n#incl\",\"targets\":\"ude <bits\\/stdc++.h>\\nusing namespace std;\\nconst int INF=1e9;\\nconst int dx[4]={1,0,-1,0};\\nconst int dy[4]={0,1,0,-1};\\n\\nint main(){\\n    cin.tie(0);\\n    ios::sync_with_stdio(false);\\n    int H,W; cin >> H >> W;\\n    vector<string> f(H);\\n    for (int i=0;i<H;++i) cin >> f[i];\\n    int sx,sy;\\n    for (int i=0;i<H;++i)\\n        for (int j=0;j<W;++j)\\n            if (f[i][j]=='%')\\n                sx=i,sy=j;\\n    vector<vector<int>> dist(H,vector<int>(W,-1));\\n    queue<pair<int,int>> que;\\n    dist[sx][sy]=0; que.emplace(sx,sy);\\n    int princess,soldiar=INF;\\n    while(!que.empty()){\\n        auto p=que.front(); que.pop();\\n        int x=p.first,y=p.second;\\n        for (int i=0;i<4;++i){\\n            int nx=x+dx[i],ny=y+dy[i];\\n            if (nx<0||H<=nx||ny<0||W<=ny) continue;\\n            if (f[nx][ny]=='#') continue;\\n            if (dist[nx][ny]!=-1) continue;\\n            dist[nx][ny]=dist[x][y]+1;\\n            que.emplace(nx,ny);\\n            if (f[nx][ny]=='@') princess=dist[nx][ny];\\n            if (f[nx][ny]=='$') soldiar=min(soldiar,dist[nx][ny]);\\n        }\\n    }\\n    cout << (princess<soldiar?\\\"Yes\\\":\\\"No\\\") << '\\\\n';\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"After being invaded by the Kingdom of AlDebaran, bombs are planted throughout our country, AtCoder Kingdom.\\n\\nFortunately, our military team called ABC has managed to obtain a device that is a part of the system controlling the bombs.\\n\\nThere are N bombs, numbered 1 to N, planted in our country. Bomb i is planted at the coordinate A_i. It is currently activated if B_i=1, and deactivated if B_i=0.\\n\\nThe device has M cords numbered 1 to M. If we cut Cord j, the states of all the bombs planted between the coordinates L_j and R_j (inclusive) will be switched - from activated to deactivated, and vice versa.\\n\\nDetermine whether it is possible to deactivate all the bombs at the same time. If the answer is yes, output a set of cords that should be cut.\\n\\nConstraints\\n\\n* All values in input are integers.\\n* 1 \\\\leq N \\\\leq 10^5\\n* 1 \\\\leq A_i \\\\leq 10^9\\\\ (1 \\\\leq i \\\\leq N)\\n* A_i are pairwise distinct.\\n* B_i is 0 or 1. (1 \\\\leq i \\\\leq N)\\n* 1 \\\\leq M \\\\leq 2 \\\\times 10^5\\n* 1 \\\\leq L_j \\\\leq R_j \\\\leq 10^9\\\\ (1 \\\\leq j \\\\leq M)\\n\\nInput\\n\\nInput is given from Standard Input in the following format:\\n\\n\\nN M\\nA_1 B_1\\n:\\nA_N B_N\\nL_1 R_1\\n:\\nL_M R_M\\n\\n\\nOutput\\n\\nIf it is impossible to deactivate all the bombs at the same time, print `-1`. If it is possible to do so, print a set of cords that should be cut, as follows:\\n\\n\\nk\\nc_1 c_2 \\\\dots c_k\\n\\n\\nHere, k is the number of cords (possibly 0), and c_1, c_2, \\\\dots, c_k represent the cords that should be cut. 1 \\\\leq c_1 < c_2 < \\\\dots < c_k \\\\leq M must hold.\\n\\nExamples\\n\\nInput\\n\\n3 4\\n5 1\\n10 1\\n8 0\\n1 10\\n4 5\\n6 7\\n8 9\\n\\n\\nOutput\\n\\n2\\n1 4\\n\\n\\nInput\\n\\n4 2\\n2 0\\n3 1\\n5 1\\n7 0\\n1 4\\n4 7\\n\\n\\nOutput\\n\\n-1\\n\\n\\nInput\\n\\n3 2\\n5 0\\n10 0\\n8 0\\n6 9\\n66 99\\n\\n\\nOutput\\n\\n0\\n\\n\\nInput\\n\\n12 20\\n536130100 1\\n150049660 1\\n79245447 1\\n132551741 0\\n89484841 1\\n328129089 0\\n623467741 0\\n248785745 0\\n421631475 0\\n498966877 0\\n43768791 1\\n112237273 0\\n21499042 142460201\\n58176487 384985131\\n88563042 144788076\\n120198276 497115965\\n134867387 563350571\\n211946499 458996604\\n233934566 297258009\\n335674184 555985828\\n414601661 520203502\\n101135608 501051309\\n90972258 300372385\\n255474956 630621190\\n436210625...\",\"targets\":\"import bisect\\nimport sys\\ninput = sys.stdin.readline\\nsys.setrecursionlimit(10**6)\\n\\n\\ndef dfs(v, x, g, used, ans):\\n    used[v] = True\\n    res = x[v]\\n    for e in g[v]:\\n        if used[e[0]]:\\n            continue\\n        r = dfs(e[0], x, g, used, ans)\\n        if r:\\n            ans.append(e[1])\\n        res ^= r\\n    return res\\n\\n\\ndef main():\\n    n, m = map(int, input().split())\\n    ab = [[] for _ in range(n)]\\n    ans = []\\n    g = [[] for _ in range(n+1)]\\n    used = [False] * (n+1)\\n\\n    for i in range(n):\\n        ab[i] = list(map(int, input().split()))\\n    ab = sorted(ab, key=lambda x: x[0])\\n    al = list(map(lambda x: x[0], ab))\\n    for i in range(m):\\n        l, r = map(int, input().split())\\n        l = bisect.bisect_left(al, l)\\n        r = bisect.bisect_right(al, r)\\n        g[l].append((r, i+1))\\n        g[r].append((l, i+1))\\n\\n    x = [0] * (n+1)\\n    x[0] = ab[0][1]\\n    for i in range(n-1):\\n        x[i+1] = ab[i][1] ^ ab[i+1][1]\\n    x[n] = ab[n-1][1]\\n\\n    for i in range(n+1):\\n        if used[i]:\\n            continue\\n        if dfs(i, x, g, used, ans):\\n            print(-1)\\n            return\\n\\n    ans.sort()\\n    print(len(ans))\\n    print(*ans)\\n\\n\\nmain()\",\"language\":\"python\",\"split\":\"train\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"A chess tournament will be held soon, where n chess players will take part. Every participant will play one game against every other participant. Each game ends in either a win for one player and a loss for another player, or a draw for both players.\\n\\nEach of the players has their own expectations about the tournament, they can be one of two types:\\n\\n  1. a player wants not to lose any game (i. e. finish the tournament with zero losses); \\n  2. a player wants to win at least one game. \\n\\n\\n\\nYou have to determine if there exists an outcome for all the matches such that all the players meet their expectations. If there are several possible outcomes, print any of them. If there are none, report that it's impossible.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 200) \u2014 the number of test cases.\\n\\nThe first line of each test case contains one integer n (2 \u2264 n \u2264 50) \u2014 the number of chess players.\\n\\nThe second line contains the string s (|s| = n; s_i \u2208 \\\\{1, 2\\\\}). If s_i = 1, then the i-th player has expectations of the first type, otherwise of the second type.\\n\\nOutput\\n\\nFor each test case, print the answer in the following format:\\n\\nIn the first line, print NO if it is impossible to meet the expectations of all players.\\n\\nOtherwise, print YES, and the matrix of size n \u00d7 n in the next n lines.\\n\\nThe matrix element in the i-th row and j-th column should be equal to:\\n\\n  * +, if the i-th player won in a game against the j-th player; \\n  * -, if the i-th player lost in a game against the j-th player; \\n  * =, if the i-th and j-th players' game resulted in a draw; \\n  * X, if i = j. \\n\\nExample\\n\\nInput\\n\\n\\n3\\n3\\n111\\n2\\n21\\n4\\n2122\\n\\n\\nOutput\\n\\n\\nYES\\nX==\\n=X=\\n==X\\nNO\\nYES\\nX--+\\n+X++\\n+-X-\\n--+X\\nSolve the task in JAVA.\",\"targets\":\"\\/\\/ Working program with FastReader\\nimport java.io.BufferedReader;\\nimport java.io.IOException;\\nimport java.io.InputStreamReader;\\nimport java.util.*;\\nimport java.util.StringTokenizer;\\n\\npublic class Main {\\n    static class FastReader {\\n        BufferedReader br;\\n        StringTokenizer st;\\n\\n        public FastReader()\\n        {\\n            br = new BufferedReader(\\n                    new InputStreamReader(System.in));\\n        }\\n\\n        String next()\\n        {\\n            while (st == null || !st.hasMoreElements()) {\\n                try {\\n                    st = new StringTokenizer(br.readLine());\\n                }\\n                catch (IOException e) {\\n                    e.printStackTrace();\\n                }\\n            }\\n            return st.nextToken();\\n        }\\n\\n        int nextInt() { return Integer.parseInt(next()); }\\n\\n        long nextLong() { return Long.parseLong(next()); }\\n\\n        double nextDouble()\\n        {\\n            return Double.parseDouble(next());\\n        }\\n\\n        String nextLine()\\n        {\\n            String str = \\\"\\\";\\n            try {\\n                str = br.readLine();\\n            }\\n            catch (IOException e) {\\n                e.printStackTrace();\\n            }\\n            return str;\\n        }\\n    }\\n\\n    public static int CompareTo(String a, String b, Map<Character, Integer> map){\\n        if(a.length() < b.length()){\\n            return 1;\\n        }else if(a.length() == b.length()){\\n            for(int i=0; i<a.length(); i++){\\n                if(map.get(a.charAt(i)) > map.get(b.charAt(i))){\\n                    return 1;\\n                }\\n            }\\n        }\\n\\n        return 0;\\n    }\\n\\n    public static void main(String[] args)\\n    {\\n        FastReader fs = new FastReader();\\n        int t = fs.nextInt();\\n\\/\\/        int t = 1;\\n        while(t-- != 0) {\\n            int n = fs.nextInt();\\n            String s = fs.next();\\n\\n            int count1 = 0; int count2 = 0;\\n            for(int i = 0; i < n; i++) {\\n                if(s.charAt(i) == '1'){\\n                    count1++;\\n ...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"PYTHON3 solution for \\\"This version of the problem differs from the next one only in the constraint on n.\\n\\nNote that the memory limit in this problem is lower than in others.\\n\\nYou have a vertical strip with n cells, numbered consecutively from 1 to n from top to bottom.\\n\\nYou also have a token that is initially placed in cell n. You will move the token up until it arrives at cell 1.\\n\\nLet the token be in cell x > 1 at some moment. One shift of the token can have either of the following kinds: \\n\\n  * Subtraction: you choose an integer y between 1 and x-1, inclusive, and move the token from cell x to cell x - y. \\n  * Floored division: you choose an integer z between 2 and x, inclusive, and move the token from cell x to cell \u230a x\\/z \u230b (x divided by z rounded down). \\n\\n\\n\\nFind the number of ways to move the token from cell n to cell 1 using one or more shifts, and print it modulo m. Note that if there are several ways to move the token from one cell to another in one shift, all these ways are considered distinct (check example explanation for a better understanding).\\n\\nInput\\n\\nThe only line contains two integers n and m (2 \u2264 n \u2264 2 \u22c5 10^5; 10^8 < m < 10^9; m is a prime number) \u2014 the length of the strip and the modulo.\\n\\nOutput\\n\\nPrint the number of ways to move the token from cell n to cell 1, modulo m.\\n\\nExamples\\n\\nInput\\n\\n\\n3 998244353\\n\\n\\nOutput\\n\\n\\n5\\n\\n\\nInput\\n\\n\\n5 998244353\\n\\n\\nOutput\\n\\n\\n25\\n\\n\\nInput\\n\\n\\n42 998244353\\n\\n\\nOutput\\n\\n\\n793019428\\n\\nNote\\n\\nIn the first test, there are three ways to move the token from cell 3 to cell 1 in one shift: using subtraction of y = 2, or using division by z = 2 or z = 3.\\n\\nThere are also two ways to move the token from cell 3 to cell 1 via cell 2: first subtract y = 1, and then either subtract y = 1 again or divide by z = 2.\\n\\nTherefore, there are five ways in total.\\\":\",\"targets\":\"n, m = map(int, input().split())\\nc = [0]*n + [1] + [0]*n\\nfor i in range(n-1, 0, -1):\\n    c[i] = 2*c[i+1] % m\\n    for j in range(2, n\\/\\/i + 1):\\n        c[i] = (c[i] + c[i*j] - c[(i+1)*j]) % m\\n \\nprint((c[1] - c[2]) % m)\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in JAVA?\\nPolycarp must pay exactly n burles at the checkout. He has coins of two nominal values: 1 burle and 2 burles. Polycarp likes both kinds of coins equally. So he doesn't want to pay with more coins of one type than with the other.\\n\\nThus, Polycarp wants to minimize the difference between the count of coins of 1 burle and 2 burles being used. Help him by determining two non-negative integer values c_1 and c_2 which are the number of coins of 1 burle and 2 burles, respectively, so that the total value of that number of coins is exactly n (i. e. c_1 + 2 \u22c5 c_2 = n), and the absolute value of the difference between c_1 and c_2 is as little as possible (i. e. you must minimize |c_1-c_2|).\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases. Then t test cases follow.\\n\\nEach test case consists of one line. This line contains one integer n (1 \u2264 n \u2264 10^9) \u2014 the number of burles to be paid by Polycarp.\\n\\nOutput\\n\\nFor each test case, output a separate line containing two integers c_1 and c_2 (c_1, c_2 \u2265 0) separated by a space where c_1 is the number of coins of 1 burle and c_2 is the number of coins of 2 burles. If there are multiple optimal solutions, print any one.\\n\\nExample\\n\\nInput\\n\\n\\n6\\n1000\\n30\\n1\\n32\\n1000000000\\n5\\n\\n\\nOutput\\n\\n\\n334 333\\n10 10\\n1 0\\n10 11\\n333333334 333333333\\n1 2\\n\\nNote\\n\\nThe answer for the first test case is \\\"334 333\\\". The sum of the nominal values of all coins is 334 \u22c5 1 + 333 \u22c5 2 = 1000, whereas |334 - 333| = 1. One can't get the better value because if |c_1 - c_2| = 0, then c_1 = c_2 and c_1 \u22c5 1 + c_1 \u22c5 2 = 1000, but then the value of c_1 isn't an integer.\\n\\nThe answer for the second test case is \\\"10 10\\\". The sum of the nominal values is 10 \u22c5 1 + 10 \u22c5 2 = 30 and |10 - 10| = 0, whereas there's no number having an absolute value less than 0.\",\"targets\":\"import java.util.ArrayList;\\nimport java.util.Collections;\\nimport java.util.Comparator;\\nimport java.util.PriorityQueue;\\nimport java.util.Stack;\\nimport java.util.StringTokenizer;\\nimport java.util.TreeSet;\\n\\nimport java.io.IOException;\\nimport java.io.BufferedOutputStream;\\nimport java.io.BufferedReader;\\nimport java.io.InputStream;\\nimport java.io.InputStreamReader;\\nimport java.io.OutputStream;\\nimport java.io.PrintWriter;\\n\\npublic class S2 {\\n\\t\\n\\tpublic static class Reader {\\n\\t\\t\\n\\t\\tstatic BufferedReader reader;\\n\\t\\tstatic StringTokenizer tokenizer;\\n\\t\\t\\n\\t\\tstatic void init(InputStream input) {\\n\\t\\t\\treader = new BufferedReader(new InputStreamReader(input));\\n\\t\\t\\ttokenizer = new StringTokenizer(\\\"\\\");\\n\\t\\t}\\n\\t\\t\\n\\t\\tstatic String next() throws IOException {\\n\\t\\t\\twhile(!tokenizer.hasMoreTokens()) {\\n\\t\\t\\t\\ttokenizer = new StringTokenizer(reader.readLine());\\n\\t\\t\\t}\\n\\t\\t\\treturn tokenizer.nextToken();\\n\\t\\t}\\n\\t\\t\\n\\t\\tstatic int nextInt() throws IOException {\\n\\t\\t\\treturn Integer.parseInt(next());\\n\\t\\t}\\n\\t\\t\\n\\t\\tstatic long nextLong() throws IOException {\\n\\t\\t\\treturn Long.parseLong(next());\\n\\t\\t}\\n\\t\\t\\n\\t}\\n\\n\\tprivate static int n;\\n\\tprivate static int m;\\n\\tprivate static long nl;\\n\\tprivate static long ans;\\n\\tprivate static boolean[][] safe;\\n\\t\\n\\tprivate final static long fd = 998244353;\\n\\tprivate final static long mod1 = 1000000007;\\n\\t\\t\\n\\tprivate final static int sz = 100000;\\n\\tprivate static long[] arr;\\n\\tprivate static int[] arri;\\n\\t\\n\\tpublic static void main(String[] args) throws IOException {\\n\\t\\t\\n\\t\\tReader.init(System.in);\\n\\t\\t\\n\\t\\tPrintWriter out = new PrintWriter(System.out);\\n\\t\\t\\n\\t\\tint tc=1;\\n\\t\\ttc = Reader.nextInt();\\n\\t\\t\\n\\t\\tmain_loop:\\n\\t\\t\\tfor(int tn=0; tn<tc; tn++) {\\n\\t\\t\\t\\t\\n\\t\\t\\t\\tans=0;\\n\\t\\t\\t\\tn = Reader.nextInt();\\n\\t\\t\\t\\t\\n\\t\\t\\t\\tint q = n\\/3;\\n\\t\\t\\t\\tint r = n%3;\\n\\t\\t\\t\\t\\n\\t\\t\\t\\tint c1,c2;\\n\\t\\t\\t\\t\\n\\t\\t\\t\\tif(r==0) {\\n\\t\\t\\t\\t\\tc1=q;\\n\\t\\t\\t\\t\\tc2=q;\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t}\\n\\t\\t\\t\\telse if(r==1) {\\n\\t\\t\\t\\t\\tc1=q+1;\\n\\t\\t\\t\\t\\tc2=q;\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t}\\n\\t\\t\\t\\telse {\\n\\t\\t\\t\\t\\tc1=q;\\n\\t\\t\\t\\t\\tc2=q+1;\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t}\\n\\t\\t\\t\\t\\n\\t\\t\\t\\tout.print(c1);\\n\\t\\t\\t\\tout.print(\\\"...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"A matrix of size n \u00d7 m, such that each cell of it contains either 0 or 1, is considered beautiful if the sum in every contiguous submatrix of size 2 \u00d7 2 is exactly 2, i. e. every \\\"square\\\" of size 2 \u00d7 2 contains exactly two 1's and exactly two 0's.\\n\\nYou are given a matrix of size n \u00d7 m. Initially each cell of this matrix is empty. Let's denote the cell on the intersection of the x-th row and the y-th column as (x, y). You have to process the queries of three types:\\n\\n  * x y -1 \u2014 clear the cell (x, y), if there was a number in it; \\n  * x y 0 \u2014 write the number 0 in the cell (x, y), overwriting the number that was there previously (if any); \\n  * x y 1 \u2014 write the number 1 in the cell (x, y), overwriting the number that was there previously (if any). \\n\\n\\n\\nAfter each query, print the number of ways to fill the empty cells of the matrix so that the resulting matrix is beautiful. Since the answers can be large, print them modulo 998244353.\\n\\nInput\\n\\nThe first line contains three integers n, m and k (2 \u2264 n, m \u2264 10^6; 1 \u2264 k \u2264 3 \u22c5 10^5) \u2014 the number of rows in the matrix, the number of columns, and the number of queries, respectively.\\n\\nThen k lines follow, the i-th of them contains three integers x_i, y_i, t_i (1 \u2264 x_i \u2264 n; 1 \u2264 y_i \u2264 m; -1 \u2264 t_i \u2264 1) \u2014 the parameters for the i-th query.\\n\\nOutput\\n\\nFor each query, print one integer \u2014 the number of ways to fill the empty cells of the matrix after the respective query, taken modulo 998244353.\\n\\nExample\\n\\nInput\\n\\n\\n2 2 7\\n1 1 1\\n1 2 1\\n2 1 1\\n1 1 0\\n1 2 -1\\n2 1 -1\\n1 1 -1\\n\\n\\nOutput\\n\\n\\n3\\n1\\n0\\n1\\n2\\n3\\n6\\nUsing cpp can you solve the prior task?\",\"targets\":\"#include <bits\\/stdc++.h>\\nconstexpr int kMod = 998244353;\\ntemplate <typename T>\\nT add(T a, T b) {\\n  return (a + b) % kMod;\\n}\\ntemplate <typename T, typename... Args>\\nT add(T a, T b, Args... args) {\\n  return add(add(a, b), args...);\\n}\\ntemplate <typename T>\\nT sub(T a, T b) {\\n  return (a + kMod - b) % kMod;\\n}\\ntemplate <typename T>\\nT mul(T a, T b) {\\n  return a * static_cast<long long>(b) % kMod;\\n}\\ntemplate <typename T, typename... Args>\\nT mul(T a, T b, Args... args) {\\n  return mul(mul(a, b), args...);\\n}\\ntemplate <typename T>\\nvoid Add(T &a, T b) {\\n  a = add(a, b);\\n}\\ntemplate <typename T, typename... Args>\\nvoid Add(T &a, T b, Args... args) {\\n  Add(a, add(b, args...));\\n}\\ntemplate <typename T>\\nvoid Sub(T &a, T b) {\\n  a = sub(a, b);\\n}\\ntemplate <typename T>\\nvoid Mul(T &a, T b) {\\n  a = mul(a, b);\\n}\\ntemplate <typename T, typename... Args>\\nvoid Mul(T &a, T b, Args... args) {\\n  Mul(a, mul(b, args...));\\n}\\ntemplate <typename T1, typename T2>\\nT1 Ksm(T1 a, T2 b) {\\n  T1 s = 1;\\n  while (b) {\\n    if (b & 1) Mul(s, a);\\n    Mul(a, a);\\n    b >>= 1;\\n  }\\n  return s;\\n}\\nint fac[100001], inv[100001];\\nvoid Init(int n) {\\n  fac[0] = 1;\\n  for (int i = 1; i <= n; i++) fac[i] = mul(fac[i - 1], i);\\n  inv[n] = Ksm(fac[n], kMod - 2);\\n  for (int i = n - 1; i >= 0; i--) inv[i] = mul(inv[i + 1], i + 1);\\n}\\nint C(int x, int y) {\\n  if (x < y || y < 0) return 0;\\n  return mul(fac[x], inv[x - y], inv[y]);\\n}\\ntemplate <typename T>\\nvoid checkmax(T &x, T y) {\\n  if (x < y) x = y;\\n}\\ntemplate <typename T>\\nvoid checkmin(T &x, T y) {\\n  if (x > y) x = y;\\n}\\nint n, m, q, pw[1000001], cnt[2];\\nstd::map<std::pair<int, int>, int> mp;\\nclass E {\\n public:\\n  E() {}\\n  void Init(int n) { cnt_ = n; }\\n  int Calc() { return c0_ ? 0 : pw[cnt_]; }\\n  void Insert(int x, int y, int op) {\\n    int col = (x + op) & 1;\\n    a_[y][col]++;\\n    if (a_[y][col] == 1 && a_[y][col ^ 1]) c0_++;\\n    if (a_[y][col] == 1 && !a_[y][col ^ 1]) cnt_--;\\n  }\\n  void Erase(int x, int y, int op) {\\n    int col = (x + op) & 1;\\n    a_[y][col]--;\\n    if (!a_[y][col] && a_[y][col ^ 1]) c0_--;\\n    if (!a_[y][col] &&...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"An important meeting is to be held and there are exactly n people invited. At any moment, any two people can step back and talk in private. The same two people can talk several (as many as they want) times per meeting.\\n\\nEach person has limited sociability. The sociability of the i-th person is a non-negative integer a_i. This means that after exactly a_i talks this person leaves the meeting (and does not talk to anyone else anymore). If a_i = 0, the i-th person leaves the meeting immediately after it starts.\\n\\nA meeting is considered most productive if the maximum possible number of talks took place during it.\\n\\nYou are given an array of sociability a, determine which people should talk to each other so that the total number of talks is as large as possible.\\n\\nInput\\n\\nThe first line contains an integer t (1 \u2264 t \u2264 1000) \u2014 the number of test cases.\\n\\nThe next 2t lines contain descriptions of the test cases.\\n\\nThe first line of each test case description contains an integer n (2 \u2264 n \u2264 2 \u22c5 10^5) \u2014the number of people in the meeting. The second line consists of n space-separated integers a_1, a_2, ..., a_n (0 \u2264 a_i \u2264 2 \u22c5 10^5) \u2014 the sociability parameters of all people. \\n\\nIt is guaranteed that the sum of n over all test cases does not exceed 2 \u22c5 10^5. It is also guaranteed that the sum of all a_i (over all test cases and all i) does not exceed 2 \u22c5 10^5.\\n\\nOutput\\n\\nPrint t answers to all test cases.\\n\\nOn the first line of each answer print the number k \u2014 the maximum number of talks possible in a meeting.\\n\\nOn each of the next k lines print two integers i and j (1 \u2264 i, j \u2264 n and i \u2260 j) \u2014 the numbers of people who will have another talk.\\n\\nIf there are several possible answers, you may print any of them.\\n\\nExample\\n\\nInput\\n\\n\\n8\\n2\\n2 3\\n3\\n1 2 3\\n4\\n1 2 3 4\\n3\\n0 0 2\\n2\\n6 2\\n3\\n0 0 2\\n5\\n8 2 0 1 1\\n5\\n0 1 0 0 6\\n\\n\\nOutput\\n\\n\\n2\\n1 2\\n1 2\\n3\\n1 3\\n2 3\\n2 3\\n5\\n1 3\\n2 4\\n2 4\\n3 4\\n3 4\\n0\\n2\\n1 2\\n1 2\\n0\\n4\\n1 2\\n1 5\\n1 4\\n1 2\\n1\\n5 2\\nUsing java can you solve the prior task?\",\"targets\":\"import java.util.*;\\nimport java.io.*;\\n\\npublic class D_1579 {\\n\\tpublic static void main(String[] args) throws Exception {\\n\\t\\tScanner sc = new Scanner(System.in);\\n\\t\\tPrintWriter pw = new PrintWriter(System.out);\\n\\t\\t\\n\\t\\tint t = sc.nextInt();\\n\\t\\twhile(t-->0) {\\n\\t\\t\\tint n = sc.nextInt();\\n\\t\\t\\tPriorityQueue<Pair> pq = new PriorityQueue<>(Collections.reverseOrder());\\n\\t\\t\\tfor(int i = 0; i < n; i++)\\n\\t\\t\\t\\tpq.add(new Pair(i + 1, sc.nextInt()));\\n\\t\\t\\tArrayList<String> ans = new ArrayList<>();\\n\\t\\t\\twhile(pq.size() >= 2) {\\n\\t\\t\\t\\tPair p1 = pq.poll(), p2 = pq.poll();\\n\\t\\t\\t\\tif(p2.n == 0) {\\n\\t\\t\\t\\t\\tpq.add(p1);\\n\\t\\t\\t\\t\\tcontinue;\\n\\t\\t\\t\\t}\\n\\t\\t\\t\\tp1.n--;\\n\\t\\t\\t\\tp2.n--;\\n\\t\\t\\t\\tans.add(p1.i + \\\" \\\" + p2.i);\\n\\t\\t\\t\\tif(p1.n > 0)\\n\\t\\t\\t\\t\\tpq.add(p1);\\n\\t\\t\\t\\tif(p2.n > 0)\\n\\t\\t\\t\\t\\tpq.add(p2);\\n\\t\\t\\t}\\n\\t\\t\\t\\n\\t\\t\\tpw.println(ans.size());\\n\\t\\t\\tfor(String s : ans)\\n\\t\\t\\t\\tpw.println(s);\\n\\t\\t}\\n\\t\\t\\n\\t\\tpw.flush();\\n\\t}\\n\\t\\n\\tpublic static class Pair implements Comparable<Pair> {\\n\\t\\tint i, n;\\n\\t\\t\\n\\t\\tpublic Pair(int i, int n) {\\n\\t\\t\\tthis.i = i;\\n\\t\\t\\tthis.n = n;\\n\\t\\t}\\n\\t\\t\\n\\t\\tpublic int compareTo(Pair p) {\\n\\t\\t\\tif(this.n == p.n)\\n\\t\\t\\t\\treturn this.i - p.i;\\n\\t\\t\\treturn this.n - p.n;\\n\\t\\t}\\n\\t}\\n\\n\\tpublic static class Scanner {\\n\\t\\tStringTokenizer st;\\n\\t\\tBufferedReader br;\\n\\n\\t\\tpublic Scanner(InputStream system) {\\n\\t\\t\\tbr = new BufferedReader(new InputStreamReader(system));\\n\\t\\t}\\n\\n\\t\\tpublic Scanner(String file) throws Exception {\\n\\t\\t\\tbr = new BufferedReader(new FileReader(file));\\n\\t\\t}\\n\\n\\t\\tpublic String next() throws IOException {\\n\\t\\t\\twhile (st == null || !st.hasMoreTokens())\\n\\t\\t\\t\\tst = new StringTokenizer(br.readLine());\\n\\t\\t\\treturn st.nextToken();\\n\\t\\t}\\n\\n\\t\\tpublic String nextLine() throws IOException {\\n\\t\\t\\treturn br.readLine();\\n\\t\\t}\\n\\n\\t\\tpublic int nextInt() throws IOException {\\n\\t\\t\\treturn Integer.parseInt(next());\\n\\t\\t}\\n\\n\\t\\tpublic double nextDouble() throws IOException {\\n\\t\\t\\treturn Double.parseDouble(next());\\n\\t\\t}\\n\\n\\t\\tpublic char nextChar() throws IOException {\\n\\t\\t\\treturn next().charAt(0);\\n\\t\\t}\\n\\n\\t\\tpublic long nextLong() throws IOException {\\n\\t\\t\\treturn Long.parseLong(next());\\n\\t\\t}\\n\\n\\t\\tpublic int[] nextIntArray(int n) throws IOException {\\n\\t\\t\\tint[] array = new int[n];\\n\\t\\t\\tfor (int i =...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in CPP?\\nA very unusual citizen lives in a far away kingdom \u2014 Dwarf Gracula. However, his unusual name is not the weirdest thing (besides, everyone long ago got used to calling him simply Dwarf Greg). What is special about Dwarf Greg \u2014 he's been living for over 200 years; besides, he lives in a crypt on an abandoned cemetery and nobody has ever seen him out in daytime. Moreover, nobody has ever seen Greg buy himself any food. That's why nobody got particularly surprised when after the infernal dragon's tragic death cattle continued to disappear from fields. The people in the neighborhood were long sure that the harmless dragon was never responsible for disappearing cattle (considering that the dragon used to be sincere about his vegetarian views). But even that's not the worst part of the whole story.\\n\\nThe worst part is that merely several minutes ago Dwarf Greg in some unintelligible way got inside your house and asked you to help him solve a problem. The point is that a short time ago Greg decided to order a new coffin (knowing his peculiar character, you are not surprised at all). But the problem is: a very long in both directions L-shaped corridor leads to Greg's crypt, and you can't drag just any coffin through that corridor. That's why he asked you to help.\\n\\n<image>\\n\\nYou've formalized the task on a plane like this: let the corridor's width before and after the turn be equal to a and b correspondingly (see the picture). The corridor turns directly at a right angle, the coffin is a rectangle whose length and width are equal to l and w (l \u2265 w) correspondingly. Dwarf Greg has already determined the coffin's length (l), which is based on his height; your task is to determine the coffin's maximally possible width (w), at which it can be brought to the crypt. Besides, due to its large mass (pure marble!) the coffin is equipped with rotating wheels; therefore it is impossible to lift it off the ground, however, arbitrary moves and rotations of the coffin in the plane become possible. The coffin may be rotated...\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nstatic const double EPS = 1e-11;\\nconst double pi = acos(-1);\\nint dx[] = {0, 1, 0, -1, 1, 1, -1, -1}, dy[] = {1, 0, -1, 0, 1, -1, 1, -1};\\ndouble a, b, l;\\ndouble getw(double th) {\\n  return ((tan(th) * b + a - l * sin(th)) \\/ sqrt(tan(th) * tan(th) + 1));\\n}\\nint main() {\\n  cin >> a >> b >> l;\\n  if (a > b) swap(a, b);\\n  if (l <= b) {\\n    cout << min(a, l) << endl;\\n    return 0;\\n  }\\n  double lt = 0, ht = pi \\/ 2;\\n  while (abs(ht - lt) > EPS) {\\n    double mid1 = lt + (ht - lt) \\/ 3;\\n    double mid2 = mid1 + (ht - lt) \\/ 3;\\n    double wm1 = getw(mid1);\\n    double wm2 = getw(mid2);\\n    if (wm1 >= wm2)\\n      lt = mid1;\\n    else\\n      ht = mid2;\\n    if (wm2 < EPS || wm1 < EPS) {\\n      cout << \\\"My poor head =(\\\" << endl;\\n      return 0;\\n    }\\n  }\\n  printf(\\\"%.10f\\\\n\\\", min(l, getw(lt)));\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Polycarp is very fond of playing the game Minesweeper. Recently he found a similar game and there are such rules.\\n\\nThere are mines on the field, for each the coordinates of its location are known (x_i, y_i). Each mine has a lifetime in seconds, after which it will explode. After the explosion, the mine also detonates all mines vertically and horizontally at a distance of k (two perpendicular lines). As a result, we get an explosion on the field in the form of a \\\"plus\\\" symbol ('+'). Thus, one explosion can cause new explosions, and so on.\\n\\nAlso, Polycarp can detonate anyone mine every second, starting from zero seconds. After that, a chain reaction of explosions also takes place. Mines explode instantly and also instantly detonate other mines according to the rules described above.\\n\\nPolycarp wants to set a new record and asks you to help him calculate in what minimum number of seconds all mines can be detonated.\\n\\nInput\\n\\nThe first line of the input contains an integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases in the test.\\n\\nAn empty line is written in front of each test suite.\\n\\nNext comes a line that contains integers n and k (1 \u2264 n \u2264 2 \u22c5 10^5, 0 \u2264 k \u2264 10^9) \u2014 the number of mines and the distance that hit by mines during the explosion, respectively.\\n\\nThen n lines follow, the i-th of which describes the x and y coordinates of the i-th mine and the time until its explosion (-10^9 \u2264 x, y \u2264 10^9, 0 \u2264 timer \u2264 10^9). It is guaranteed that all mines have different coordinates.\\n\\nIt is guaranteed that the sum of the values n over all test cases in the test does not exceed 2 \u22c5 10^5.\\n\\nOutput\\n\\nPrint t lines, each of the lines must contain the answer to the corresponding set of input data \u2014 the minimum number of seconds it takes to explode all the mines.\\n\\nExample\\n\\nInput\\n\\n\\n3\\n\\n5 0\\n0 0 1\\n0 1 4\\n1 0 2\\n1 1 3\\n2 2 9\\n\\n5 2\\n0 0 1\\n0 1 4\\n1 0 2\\n1 1 3\\n2 2 9\\n\\n6 1\\n1 -1 3\\n0 -1 9\\n0 1 7\\n-1 0 1\\n-1 1 9\\n-1 -1 7\\n\\n\\nOutput\\n\\n\\n2\\n1\\n0\\n\\nNote\\n\\n<image> Picture from examples\\n\\nFirst example: \\n\\n  * 0 second: we explode a mine at the cell (2, 2), it does not...\\nUsing cpp can you solve the prior task?\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst long long mod = 1e9 + 7;\\nconst long long inf = 1e18;\\nconst double eps = 1e-7;\\nconst int N = 2e5 + 5, M = 3e5 + 5;\\nint r[N], par[N];\\nint find_set(int a) {\\n  while (par[a] != a) a = par[a];\\n  return a;\\n}\\nvoid union_set(int a, int b) {\\n  a = find_set(a);\\n  b = find_set(b);\\n  if (a == b) return;\\n  par[a] = b;\\n  r[b] = min(r[b], r[a]);\\n}\\nvoid test() {\\n  int n, k;\\n  cin >> n >> k;\\n  for (int i = 0; i < n; i++) {\\n    par[i] = i;\\n  }\\n  vector<pair<int, int> > edg(n);\\n  map<int, vector<pair<int, int> > > row, col;\\n  for (int i = 0; i < n; i++) {\\n    cin >> edg[i].first >> edg[i].second >> r[i];\\n    row[edg[i].first].push_back({edg[i].second, i});\\n    col[edg[i].second].push_back({edg[i].first, i});\\n  }\\n  for (auto v : row) {\\n    sort(v.second.begin(), v.second.end());\\n    for (int i = 1; i < v.second.size(); i++) {\\n      int c1 = v.second[i].first, c2 = v.second[i - 1].first;\\n      if (c1 - c2 > k) continue;\\n      union_set(v.second[i].second, v.second[i - 1].second);\\n    }\\n  }\\n  for (auto c : col) {\\n    sort(c.second.begin(), c.second.end());\\n    for (int i = 1; i < c.second.size(); i++) {\\n      int r1 = c.second[i].first, r2 = c.second[i - 1].first;\\n      if (r1 - r2 > k) continue;\\n      union_set(c.second[i].second, c.second[i - 1].second);\\n    }\\n  }\\n  set<int> s2;\\n  multiset<int> s;\\n  for (int i = 0; i < n; i++) {\\n    s2.insert(find_set(i));\\n  }\\n  for (auto a : s2) s.insert(r[a]);\\n  auto it = s.end(), it2 = s.begin();\\n  it--;\\n  int sec = 0;\\n  while (it != it2) {\\n    it--;\\n    while (it2 != s.end() && *it2 <= sec) it2++;\\n    if (*it < *it2) break;\\n    sec++;\\n  }\\n  cout << sec << '\\\\n';\\n}\\nint main() {\\n  ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);\\n  int cases = 1;\\n  cin >> cases;\\n  while (cases--) test();\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"This is a simplified version of the problem B2. Perhaps you should read the problem B2 before you start solving B1.\\n\\nPaul and Mary have a favorite string s which consists of lowercase letters of the Latin alphabet. They want to paint it using pieces of chalk of two colors: red and green. Let's call a coloring of a string wonderful if the following conditions are met:\\n\\n  1. each letter of the string is either painted in exactly one color (red or green) or isn't painted; \\n  2. each two letters which are painted in the same color are different; \\n  3. the number of letters painted in red is equal to the number of letters painted in green; \\n  4. the number of painted letters of this coloring is maximum among all colorings of the string which meet the first three conditions. \\n\\n\\n\\nE. g. consider a string s equal to \\\"kzaaa\\\". One of the wonderful colorings of the string is shown in the figure.\\n\\n<image> The example of a wonderful coloring of the string \\\"kzaaa\\\".\\n\\nPaul and Mary want to learn by themselves how to find a wonderful coloring of the string. But they are very young, so they need a hint. Help them find k \u2014 the number of red (or green, these numbers are equal) letters in a wonderful coloring.\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 1000) \u2014 the number of test cases. Then t test cases follow.\\n\\nEach test case consists of one non-empty string s which consists of lowercase letters of the Latin alphabet. The number of characters in the string doesn't exceed 50.\\n\\nOutput\\n\\nFor each test case, output a separate line containing one non-negative integer k \u2014 the number of letters which will be painted in red in a wonderful coloring.\\n\\nExample\\n\\nInput\\n\\n\\n5\\nkzaaa\\ncodeforces\\narchive\\ny\\nxxxxxx\\n\\n\\nOutput\\n\\n\\n2\\n5\\n3\\n0\\n1\\n\\nNote\\n\\nThe first test case contains the string from the statement. One of the wonderful colorings is shown in the figure. There's no wonderful coloring containing 3 or more red letters because the total number of painted symbols will exceed the string's length.\\n\\nThe string from the second test case can be...\\nUsing java can you solve the prior task?\",\"targets\":\"import java.io.OutputStream;\\nimport java.io.IOException;\\nimport java.io.InputStream;\\nimport java.io.PrintStream;\\nimport java.util.Arrays;\\nimport java.io.UncheckedIOException;\\nimport java.io.Closeable;\\nimport java.io.Writer;\\nimport java.io.OutputStreamWriter;\\nimport java.util.HashMap;\\nimport java.util.HashSet;\\nimport java.util.InputMismatchException;\\n\\n\\/*\\n@author : sanskarXrawat\\n@date   : 7\\/23\\/2021\\n@time   : 8:01 PM\\n *\\/\\n\\npublic class A {\\n\\n\\n    public static void main(String[] args) throws Throwable {\\n        Thread thread = new Thread (null, new TaskAdapter (), \\\"\\\", 1 << 29);\\n        thread.start ();\\n        thread.join ();\\n    }\\n\\n    static class TaskAdapter implements Runnable {\\n        @Override\\n        public void run() {\\n            InputStream inputStream = System.in;\\n            OutputStream outputStream = System.out;\\n            FastInput in = new FastInput (inputStream);\\n            FastOutput out = new FastOutput (outputStream);\\n            Solution solver = new Solution ();\\n            solver.solve (1, in, out);\\n            out.close ();\\n        }\\n    }\\n\\n    static class Solution {\\n        static final Debug debug = new Debug (true);\\n\\n        public void solve(int testNumber, FastInput in, FastOutput out) {\\n\\n            int test= in.ri ();\\n\\n            while (test-->0){\\n                char[] s=in.readString ().toCharArray ();\\n\\n                HashMap<Integer,Integer> map=new HashMap<> ();\\n\\n                for (char c : s) map.merge (c - '0', 1, Integer::sum);\\n\\n                    int G = 0,ans=0;\\n                    for(Integer o:map.values ()){\\n                        if((o^1)==0) G++;\\n                        else ans++;\\n                    }\\n                    out.prtl (ans+=G>>>1);\\n            }\\n\\n        }\\n\\n    }\\n\\n\\n    static class FastOutput implements AutoCloseable, Closeable, Appendable {\\n        private final StringBuilder cache = new StringBuilder (THRESHOLD * 2);\\n        private static final int THRESHOLD = 32 << 10;\\n        private final Writer os;\\n\\n        public FastOutput...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Alex doesn't like boredom. That's why whenever he gets bored, he comes up with games. One long winter evening he came up with a game and decided to play it.\\n\\nGiven a sequence a consisting of n integers. The player can make several steps. In a single step he can choose an element of the sequence (let's denote it ak) and delete it, at that all elements equal to ak + 1 and ak - 1 also must be deleted from the sequence. That step brings ak points to the player. \\n\\nAlex is a perfectionist, so he decided to get as many points as possible. Help him.\\n\\nInput\\n\\nThe first line contains integer n (1 \u2264 n \u2264 105) that shows how many numbers are in Alex's sequence. \\n\\nThe second line contains n integers a1, a2, ..., an (1 \u2264 ai \u2264 105).\\n\\nOutput\\n\\nPrint a single integer \u2014 the maximum number of points that Alex can earn.\\n\\nExamples\\n\\nInput\\n\\n2\\n1 2\\n\\n\\nOutput\\n\\n2\\n\\n\\nInput\\n\\n3\\n1 2 3\\n\\n\\nOutput\\n\\n4\\n\\n\\nInput\\n\\n9\\n1 2 1 3 2 2 2 2 3\\n\\n\\nOutput\\n\\n10\\n\\nNote\\n\\nConsider the third test example. At first step we need to choose any element equal to 2. After that step our sequence looks like this [2, 2, 2, 2]. Then we do 4 steps, on each step we choose any element equals to 2. In total we earn 10 points.\\nThe above is tricky. Write me a correct solution in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nvoid read_frequency(int[], int, int *);\\nlong long max(long long, long long);\\nlong long find_maximum_score(int[], int);\\nint main() {\\n  int frequency[100000 + 1] = {0}, no_of_numbers, max_in_array = 0;\\n  long long maximum_score;\\n  scanf(\\\"%d\\\", &no_of_numbers);\\n  read_frequency(frequency, no_of_numbers, &max_in_array);\\n  maximum_score = find_maximum_score(frequency, max_in_array);\\n  printf(\\\"%I64d\\\\n\\\", maximum_score);\\n  return 0;\\n}\\nlong long find_maximum_score(int frequency[], int max_in_array) {\\n  int i;\\n  long long maximum_score_i_minus_2 = 0, maximum_score_i_minus_1 = frequency[1],\\n            maximum_score_i = frequency[1];\\n  for (i = 2; i <= 1e5; i++) {\\n    maximum_score_i = max(maximum_score_i_minus_1,\\n                          maximum_score_i_minus_2 + frequency[i] * 1LL * i);\\n    maximum_score_i_minus_2 = maximum_score_i_minus_1;\\n    maximum_score_i_minus_1 = maximum_score_i;\\n  }\\n  return maximum_score_i;\\n}\\nvoid read_frequency(int frequency[], int no_of_numbers, int *max_in_array) {\\n  int i, current_number;\\n  for (i = 0; i < no_of_numbers; i++) {\\n    scanf(\\\"%d\\\", &current_number);\\n    frequency[current_number]++;\\n    *max_in_array = max(*max_in_array, current_number);\\n  }\\n}\\nlong long max(long long a, long long b) { return (a > b ? a : b); }\",\"language\":\"python\",\"split\":\"train\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"A binary string is a string that consists of characters 0 and 1. A bi-table is a table that has exactly two rows of equal length, each being a binary string.\\n\\nLet \\\\operatorname{MEX} of a bi-table be the smallest digit among 0, 1, or 2 that does not occur in the bi-table. For example, \\\\operatorname{MEX} for \\\\begin{bmatrix} 0011\\\\\\\\\\\\ 1010 \\\\end{bmatrix} is 2, because 0 and 1 occur in the bi-table at least once. \\\\operatorname{MEX} for \\\\begin{bmatrix} 111\\\\\\\\\\\\ 111 \\\\end{bmatrix} is 0, because 0 and 2 do not occur in the bi-table, and 0 < 2.\\n\\nYou are given a bi-table with n columns. You should cut it into any number of bi-tables (each consisting of consecutive columns) so that each column is in exactly one bi-table. It is possible to cut the bi-table into a single bi-table \u2014 the whole bi-table.\\n\\nWhat is the maximal sum of \\\\operatorname{MEX} of all resulting bi-tables can be?\\n\\nInput\\n\\nThe input consists of multiple test cases. The first line contains a single integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases. Description of the test cases follows.\\n\\nThe first line of the description of each test case contains a single integer n (1 \u2264 n \u2264 10^5) \u2014 the number of columns in the bi-table.\\n\\nEach of the next two lines contains a binary string of length n \u2014 the rows of the bi-table.\\n\\nIt's guaranteed that the sum of n over all test cases does not exceed 10^5.\\n\\nOutput\\n\\nFor each test case print a single integer \u2014 the maximal sum of \\\\operatorname{MEX} of all bi-tables that it is possible to get by cutting the given bi-table optimally.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n7\\n0101000\\n1101100\\n5\\n01100\\n10101\\n2\\n01\\n01\\n6\\n000000\\n111111\\n\\n\\nOutput\\n\\n\\n8\\n8\\n2\\n12\\n\\nNote\\n\\nIn the first test case you can cut the bi-table as follows:\\n\\n  * \\\\begin{bmatrix} 0\\\\\\\\\\\\ 1 \\\\end{bmatrix}, its \\\\operatorname{MEX} is 2.\\n  * \\\\begin{bmatrix} 10\\\\\\\\\\\\ 10 \\\\end{bmatrix}, its \\\\operatorname{MEX} is 2.\\n  * \\\\begin{bmatrix} 1\\\\\\\\\\\\ 1 \\\\end{bmatrix}, its \\\\operatorname{MEX} is 0.\\n  * \\\\begin{bmatrix} 0\\\\\\\\\\\\ 1 \\\\end{bmatrix}, its \\\\operatorname{MEX} is 2.\\n  * \\\\begin{bmatrix} 0\\\\\\\\\\\\ 0 \\\\end{bmatrix}, its...\\n#incl\",\"targets\":\"ude <bits\\/stdc++.h>\\nusing namespace std;\\nvoid solve() {\\n  int n;\\n  string a, b;\\n  cin >> n >> a >> b;\\n  int ans = 0;\\n  for (int i = 0; i < n; i++) {\\n    if (a[i] != b[i]) {\\n      ans += 2;\\n    } else {\\n      if (a[i] == '1') {\\n        if (i < n - 1) {\\n          if (a[i + 1] == '0' || b[i + 1] == '0') ans += 2, i++;\\n        }\\n      } else {\\n        if (i < n - 1) {\\n          if (a[i + 1] == '1' && b[i + 1] == '1')\\n            ans += 2, i++;\\n          else\\n            ans++;\\n        } else\\n          ans++;\\n      }\\n    }\\n  }\\n  cout << ans << endl;\\n}\\nint main() {\\n  ios::sync_with_stdio(false);\\n  cin.tie(0);\\n  cout.tie(0);\\n  int t;\\n  cin >> t;\\n  while (t--) solve();\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"A robot cleaner is placed on the floor of a rectangle room, surrounded by walls. The floor consists of n rows and m columns. The rows of the floor are numbered from 1 to n from top to bottom, and columns of the floor are numbered from 1 to m from left to right. The cell on the intersection of the r-th row and the c-th column is denoted as (r,c). The initial position of the robot is (r_b, c_b).\\n\\nIn one second, the robot moves by dr rows and dc columns, that is, after one second, the robot moves from the cell (r, c) to (r + dr, c + dc). Initially dr = 1, dc = 1. If there is a vertical wall (the left or the right walls) in the movement direction, dc is reflected before the movement, so the new value of dc is -dc. And if there is a horizontal wall (the upper or lower walls), dr is reflected before the movement, so the new value of dr is -dr.\\n\\nEach second (including the moment before the robot starts moving), the robot cleans every cell lying in the same row or the same column as its position. There is only one dirty cell at (r_d, c_d). The job of the robot is to clean that dirty cell.\\n\\n<image> Illustration for the first example. The blue arc is the robot. The red star is the target dirty cell. Each second the robot cleans a row and a column, denoted by yellow stripes.\\n\\nGiven the floor size n and m, the robot's initial position (r_b, c_b) and the dirty cell's position (r_d, c_d), find the time for the robot to do its job.\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 10^4). Description of the test cases follows.\\n\\nA test case consists of only one line, containing six integers n, m, r_b, c_b, r_d, and c_d (1 \u2264 n, m \u2264 100, 1 \u2264 r_b, r_d \u2264 n, 1 \u2264 c_b, c_d \u2264 m) \u2014 the sizes of the room, the initial position of the robot and the position of the dirt cell.\\n\\nOutput\\n\\nFor each test case, print an integer \u2014 the time for the robot to clean the dirty cell. We can show that the robot always cleans the dirty cell eventually.\\n\\nExample\\n\\nInput\\n\\n\\n5\\n10 10 6 1 2 8\\n10 10 9 9 1...\",\"targets\":\"import math\\n\\ncs = int(input())\\nfor i in range(cs):\\n    n, m, rb, cb, rd, cd = input().split()\\n    n = int(n)\\n    cd = int(cd)\\n    m = int(m)\\n    rb = int(rb)\\n    cb = int(cb)\\n    rd = int(rd)\\n    sol = min(rd - rb if rd >= rb else n - rb + n - rd, cd - cb if cd >= cb else m - cb + m - cd)\\n    print(sol)\",\"language\":\"python\",\"split\":\"test\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in CPP?\\nPetya is a math teacher. n of his students has written a test consisting of m questions. For each student, it is known which questions he has answered correctly and which he has not.\\n\\nIf the student answers the j-th question correctly, he gets p_j points (otherwise, he gets 0 points). Moreover, the points for the questions are distributed in such a way that the array p is a permutation of numbers from 1 to m.\\n\\nFor the i-th student, Petya knows that he expects to get x_i points for the test. Petya wonders how unexpected the results could be. Petya believes that the surprise value of the results for students is equal to \u2211_{i=1}^{n} |x_i - r_i|, where r_i is the number of points that the i-th student has got for the test.\\n\\nYour task is to help Petya find such a permutation p for which the surprise value of the results is maximum possible. If there are multiple answers, print any of them.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases.\\n\\nThe first line of each test case contains two integers n and m (1 \u2264 n \u2264 10; 1 \u2264 m \u2264 10^4) \u2014 the number of students and the number of questions, respectively.\\n\\nThe second line contains n integers x_1, x_2, ..., x_n (0 \u2264 x_i \u2264 (m(m+1))\\/(2)), where x_i is the number of points that the i-th student expects to get.\\n\\nThis is followed by n lines, the i-th line contains the string s_i (|s_i| = m; s_{i, j} \u2208 \\\\{0, 1\\\\}), where s_{i, j} is 1 if the i-th student has answered the j-th question correctly, and 0 otherwise.\\n\\nThe sum of m for all test cases does not exceed 10^4.\\n\\nOutput\\n\\nFor each test case, print m integers \u2014 a permutation p for which the surprise value of the results is maximum possible. If there are multiple answers, print any of them.\\n\\nExample\\n\\nInput\\n\\n\\n3\\n4 3\\n5 1 2 2\\n110\\n100\\n101\\n100\\n4 4\\n6 2 0 10\\n1001\\n0010\\n0110\\n0101\\n3 6\\n20 3 15\\n010110\\n000101\\n111111\\n\\n\\nOutput\\n\\n\\n3 1 2 \\n2 3 4 1 \\n3 1 4 5 2 6\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint T, n, m;\\nint x[15];\\nchar s[15][10005];\\nint v[10005], cnt[25], tmp[25];\\nint P[10005];\\nint ans;\\nvoid dfs(int p, int sum) {\\n  if (p == n + 1) {\\n    int cur = m, res = sum;\\n    for (int i = 20; i >= 0; i--) {\\n      res += (i - 10) * (cur * 2 - cnt[i] + 1) * cnt[i] \\/ 2;\\n      cur -= cnt[i];\\n    }\\n    tmp[0] = cnt[0];\\n    for (int i = 1; i <= 20; i++) tmp[i] = tmp[i - 1] + cnt[i];\\n    if (ans <= res) {\\n      ans = res;\\n      for (int i = 1; i <= m; i++) {\\n        P[i] = tmp[v[i] + 10]--;\\n      }\\n    }\\n    return;\\n  }\\n  for (int i = 1; i <= m; i++) {\\n    if (s[p][i] == '1') {\\n      cnt[v[i] + 10]--;\\n      v[i]++;\\n      cnt[v[i] + 10]++;\\n    }\\n  }\\n  dfs(p + 1, sum - x[p]);\\n  for (int i = 1; i <= m; i++) {\\n    if (s[p][i] == '1') {\\n      cnt[v[i] + 10]--;\\n      v[i] -= 2;\\n      cnt[v[i] + 10]++;\\n    }\\n  }\\n  dfs(p + 1, sum + x[p]);\\n  for (int i = 1; i <= m; i++) {\\n    if (s[p][i] == '1') {\\n      cnt[v[i] + 10]--;\\n      v[i]++;\\n      cnt[v[i] + 10]++;\\n    }\\n  }\\n}\\nvoid solve() {\\n  scanf(\\\"%d%d\\\", &n, &m);\\n  for (int i = 1; i <= n; i++) scanf(\\\"%d\\\", &x[i]);\\n  for (int i = 1; i <= n; i++) {\\n    scanf(\\\"%s\\\", &s[i][1]);\\n  }\\n  for (int i = 1; i <= m; i++) v[i] = 0;\\n  for (int i = 0; i <= 20; i++) cnt[i] = 0;\\n  cnt[10] = m;\\n  ans = 0;\\n  dfs(1, 0);\\n  for (int i = 1; i <= m; i++) printf(\\\"%d \\\", P[i]);\\n  printf(\\\"\\\\n\\\");\\n}\\nint main() {\\n  scanf(\\\"%d\\\", &T);\\n  while (T--) solve();\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"A binary string is a string that consists of characters 0 and 1.\\n\\nLet \\\\operatorname{MEX} of a binary string be the smallest digit among 0, 1, or 2 that does not occur in the string. For example, \\\\operatorname{MEX} of 001011 is 2, because 0 and 1 occur in the string at least once, \\\\operatorname{MEX} of 1111 is 0, because 0 and 2 do not occur in the string and 0 < 2.\\n\\nA binary string s is given. You should cut it into any number of substrings such that each character is in exactly one substring. It is possible to cut the string into a single substring \u2014 the whole string.\\n\\nA string a is a substring of a string b if a can be obtained from b by deletion of several (possibly, zero or all) characters from the beginning and several (possibly, zero or all) characters from the end.\\n\\nWhat is the minimal sum of \\\\operatorname{MEX} of all substrings pieces can be?\\n\\nInput\\n\\nThe input consists of multiple test cases. The first line contains a single integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases. Description of the test cases follows.\\n\\nEach test case contains a single binary string s (1 \u2264 |s| \u2264 10^5).\\n\\nIt's guaranteed that the sum of lengths of s over all test cases does not exceed 10^5.\\n\\nOutput\\n\\nFor each test case print a single integer \u2014 the minimal sum of \\\\operatorname{MEX} of all substrings that it is possible to get by cutting s optimally.\\n\\nExample\\n\\nInput\\n\\n\\n6\\n01\\n1111\\n01100\\n101\\n0000\\n01010\\n\\n\\nOutput\\n\\n\\n1\\n0\\n2\\n1\\n1\\n2\\n\\nNote\\n\\nIn the first test case the minimal sum is \\\\operatorname{MEX}(0) + \\\\operatorname{MEX}(1) = 1 + 0 = 1.\\n\\nIn the second test case the minimal sum is \\\\operatorname{MEX}(1111) = 0.\\n\\nIn the third test case the minimal sum is \\\\operatorname{MEX}(01100) = 2.\\nSolve the task in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nchar a[100005];\\nint main() {\\n  int t;\\n  scanf(\\\"%d\\\", &t);\\n  getchar();\\n  while (t--) {\\n    int flag0 = 0, flag1 = 0, flag2 = 0, cnt = 0;\\n    gets(a);\\n    for (int i = 0; i < strlen(a); i++) {\\n      if (a[i] == '1') flag1 = 1;\\n      if (a[i] == '0') flag0 = 1;\\n      if (a[i] == '2') flag2 = 1;\\n      if (a[i] == '0') {\\n        cnt++;\\n        while (i < strlen(a) && a[i] == '0') i++;\\n        i--;\\n      }\\n    }\\n    if (!flag0)\\n      printf(\\\"0\\\\n\\\");\\n    else if (flag1 == 0 && flag2 == 0)\\n      printf(\\\"1\\\\n\\\");\\n    else if (cnt >= 2)\\n      printf(\\\"2\\\\n\\\");\\n    else\\n      printf(\\\"1\\\\n\\\");\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Petya has got an interesting flower. Petya is a busy person, so he sometimes forgets to water it. You are given n days from Petya's live and you have to determine what happened with his flower in the end.\\n\\nThe flower grows as follows: \\n\\n  * If the flower isn't watered for two days in a row, it dies. \\n  * If the flower is watered in the i-th day, it grows by 1 centimeter. \\n  * If the flower is watered in the i-th and in the (i-1)-th day (i > 1), then it grows by 5 centimeters instead of 1. \\n  * If the flower is not watered in the i-th day, it does not grow. \\n\\n\\n\\nAt the beginning of the 1-st day the flower is 1 centimeter tall. What is its height after n days?\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 100). Description of the test cases follows.\\n\\nThe first line of each test case contains the only integer n (1 \u2264 n \u2264 100).\\n\\nThe second line of each test case contains n integers a_1, a_2, ..., a_n (a_i = 0 or a_i = 1). If a_i = 1, the flower is watered in the i-th day, otherwise it is not watered.\\n\\nOutput\\n\\nFor each test case print a single integer k \u2014 the flower's height after n days, or -1, if the flower dies.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n3\\n1 0 1\\n3\\n0 1 1\\n4\\n1 0 0 1\\n1\\n0\\n\\n\\nOutput\\n\\n\\n3\\n7\\n-1\\n1\",\"targets\":\"t = int(input())\\n\\nwhile t != 0:\\n    n = int(input())\\n    arr = [2]\\n    height = 1\\n    for i in input().split():\\n        arr.append(int(i))\\n\\n    for i in range(1, n+1):\\n        if arr[i] == 1 and arr[i-1] == 1:\\n            height += 5\\n        elif arr[i] == 1 and (arr[i-1] == 0 or arr[i-1] == 2):\\n            height += 1\\n        elif arr[i] == 0 and arr[i-1] == 0:\\n            height = -1\\n            break\\n    print(height)\\n    t -= 1\",\"language\":\"python\",\"split\":\"test\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in CPP?\\nN Snukes called Snuke 1, Snuke 2, ..., Snuke N live in a town.\\n\\nThere are K kinds of snacks sold in this town, called Snack 1, Snack 2, ..., Snack K. The following d_i Snukes have Snack i: Snuke A_{i, 1}, A_{i, 2}, \\\\cdots, A_{i, {d_i}}.\\n\\nTakahashi will walk around this town and make mischief on the Snukes who have no snacks. How many Snukes will fall victim to Takahashi's mischief?\\n\\nConstraints\\n\\n* All values in input are integers.\\n* 1 \\\\leq N \\\\leq 100\\n* 1 \\\\leq K \\\\leq 100\\n* 1 \\\\leq d_i \\\\leq N\\n* 1 \\\\leq A_{i, 1} < \\\\cdots < A_{i, d_i} \\\\leq N\\n\\nInput\\n\\nInput is given from Standard Input in the following format:\\n\\n\\nN K\\nd_1\\nA_{1, 1} \\\\cdots A_{1, d_1}\\n\\\\vdots\\nd_K\\nA_{K, 1} \\\\cdots A_{K, d_K}\\n\\n\\nOutput\\n\\nPrint the answer.\\n\\nExamples\\n\\nInput\\n\\n3 2\\n2\\n1 3\\n1\\n3\\n\\n\\nOutput\\n\\n1\\n\\n\\nInput\\n\\n3 3\\n1\\n3\\n1\\n3\\n1\\n3\\n\\n\\nOutput\\n\\n2\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\n\\nint main(){\\n  int N,K;\\n  cin>>N>>K;\\n  set<int> A;\\n  for(int i=0;i<K;i++){\\n    int d;\\n    cin>>d;\\n    for(int j=0;j<d;j++){\\n      int a;\\n      cin>>a;\\n      A.insert(a);\\n    }\\n  }\\n  cout<<N-A.size()<<endl;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"You are given array a_1, a_2, \u2026, a_n, consisting of non-negative integers.\\n\\nLet's define operation of \\\"elimination\\\" with integer parameter k (1 \u2264 k \u2264 n) as follows:\\n\\n  * Choose k distinct array indices 1 \u2264 i_1 < i_2 < \u2026 < i_k \u2264 n. \\n  * Calculate x = a_{i_1} ~ \\\\& ~ a_{i_2} ~ \\\\& ~ \u2026 ~ \\\\& ~ a_{i_k}, where \\\\& denotes the [bitwise AND operation](https:\\/\\/en.wikipedia.org\\/wiki\\/Bitwise_operation#AND) (notes section contains formal definition). \\n  * Subtract x from each of a_{i_1}, a_{i_2}, \u2026, a_{i_k}; all other elements remain untouched. \\n\\n\\n\\nFind all possible values of k, such that it's possible to make all elements of array a equal to 0 using a finite number of elimination operations with parameter k. It can be proven that exists at least one possible k for any array a.\\n\\nNote that you firstly choose k and only after that perform elimination operations with value k you've chosen initially.\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 10^4). Description of the test cases follows.\\n\\nThe first line of each test case contains one integer n (1 \u2264 n \u2264 200 000) \u2014 the length of array a.\\n\\nThe second line of each test case contains n integers a_1, a_2, \u2026, a_n (0 \u2264 a_i < 2^{30}) \u2014 array a itself.\\n\\nIt's guaranteed that the sum of n over all test cases doesn't exceed 200 000.\\n\\nOutput\\n\\nFor each test case, print all values k, such that it's possible to make all elements of a equal to 0 in a finite number of elimination operations with the given parameter k.\\n\\nPrint them in increasing order.\\n\\nExample\\n\\nInput\\n\\n\\n5\\n4\\n4 4 4 4\\n4\\n13 7 25 19\\n6\\n3 5 3 1 7 1\\n1\\n1\\n5\\n0 0 0 0 0\\n\\n\\nOutput\\n\\n\\n1 2 4\\n1 2\\n1\\n1\\n1 2 3 4 5\\n\\nNote\\n\\nIn the first test case:\\n\\n  * If k = 1, we can make four elimination operations with sets of indices \\\\{1\\\\}, \\\\{2\\\\}, \\\\{3\\\\}, \\\\{4\\\\}. Since \\\\& of one element is equal to the element itself, then for each operation x = a_i, so a_i - x = a_i - a_i = 0. \\n  * If k = 2, we can make two elimination operations with, for example, sets of indices \\\\{1, 3\\\\} and \\\\{2, 4\\\\}: x = a_1 ~ \\\\& ~ a_3...\\\":\",\"targets\":\"#include <bits\\/stdc++.h>\\n#pragma GCC optimize(\\\"Ofast,no-stack-protector,unroll-loops,fast-math\\\")\\nusing namespace std;\\ntemplate <class T>\\nusing rque = priority_queue<T, vector<T>, greater<T>>;\\ntemplate <class T>\\nbool chmin(T &a, const T &b) {\\n  if (b < a) {\\n    a = b;\\n    return 1;\\n  }\\n  return 0;\\n}\\ntemplate <class T>\\nbool chmax(T &a, const T &b) {\\n  if (b > a) {\\n    a = b;\\n    return 1;\\n  }\\n  return 0;\\n}\\nlong long gcd(long long a, long long b) {\\n  if (a == 0) return b;\\n  if (b == 0) return a;\\n  long long cnt = a % b;\\n  while (cnt != 0) {\\n    a = b;\\n    b = cnt;\\n    cnt = a % b;\\n  }\\n  return b;\\n}\\nlong long extGCD(long long a, long long b, long long &x, long long &y) {\\n  if (b == 0) {\\n    x = 1;\\n    y = 0;\\n    return a;\\n  }\\n  long long d = extGCD(b, a % b, y, x);\\n  y -= a \\/ b * x;\\n  return d;\\n}\\nstruct UnionFind {\\n  vector<long long> data;\\n  int num;\\n  UnionFind(int sz) {\\n    data.assign(sz, -1);\\n    num = sz;\\n  }\\n  bool unite(int x, int y) {\\n    x = find(x), y = find(y);\\n    if (x == y) return (false);\\n    if (data[x] > data[y]) swap(x, y);\\n    data[x] += data[y];\\n    data[y] = x;\\n    num--;\\n    return (true);\\n  }\\n  int find(int k) {\\n    if (data[k] < 0) return (k);\\n    return (data[k] = find(data[k]));\\n  }\\n  long long size(int k) { return (-data[find(k)]); }\\n  bool same(int x, int y) { return find(x) == find(y); }\\n};\\ntemplate <int mod>\\nstruct ModInt {\\n  int x;\\n  ModInt() : x(0) {}\\n  ModInt(int64_t y) : x(y >= 0 ? y % mod : (mod - (-y) % mod) % mod) {}\\n  ModInt &operator+=(const ModInt &p) {\\n    if ((x += p.x) >= mod) x -= mod;\\n    return *this;\\n  }\\n  ModInt &operator-=(const ModInt &p) {\\n    if ((x += mod - p.x) >= mod) x -= mod;\\n    return *this;\\n  }\\n  ModInt &operator*=(const ModInt &p) {\\n    x = (int)(1LL * x * p.x % mod);\\n    return *this;\\n  }\\n  ModInt &operator\\/=(const ModInt &p) {\\n    *this *= p.inverse();\\n    return *this;\\n  }\\n  ModInt operator-() const { return ModInt(-x); }\\n  ModInt operator+(const ModInt &p) const { return ModInt(*this) += p; }\\n  ModInt operator-(const ModInt &p) const { return...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"PYTHON3 solution for \\\"You are given three integers n, a, b. Determine if there exists a permutation p_1, p_2, \u2026, p_n of integers from 1 to n, such that:\\n\\n  * There are exactly a integers i with 2 \u2264 i \u2264 n-1 such that p_{i-1} < p_i > p_{i+1} (in other words, there are exactly a local maximums).\\n\\n  * There are exactly b integers i with 2 \u2264 i \u2264 n-1 such that p_{i-1} > p_i < p_{i+1} (in other words, there are exactly b local minimums).\\n\\n\\n\\n\\nIf such permutations exist, find any such permutation.\\n\\nInput\\n\\nThe first line of the input contains a single integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases. The description of test cases follows.\\n\\nThe only line of each test case contains three integers n, a and b (2 \u2264 n \u2264 10^5, 0 \u2264 a,b \u2264 n).\\n\\nThe sum of n over all test cases doesn't exceed 10^5.\\n\\nOutput\\n\\nFor each test case, if there is no permutation with the requested properties, output -1.\\n\\nOtherwise, print the permutation that you are found. If there are several such permutations, you may print any of them.\\n\\nExample\\n\\nInput\\n\\n\\n3\\n4 1 1\\n6 1 2\\n6 4 0\\n\\n\\nOutput\\n\\n\\n1 3 2 4\\n4 2 3 1 5 6\\n-1\\n\\nNote\\n\\nIn the first test case, one example of such permutations is [1, 3, 2, 4]. In it p_1 < p_2 > p_3, and 2 is the only such index, and p_2> p_3 < p_4, and 3 the only such index.\\n\\nOne can show that there is no such permutation for the third test case.\\\":\",\"targets\":\"n = int(input())\\n\\nfor i in range(n):\\n    # kolvo chicel a - max b - min\\n    kolvo, max, min = map(int, input().split())\\n    answer = str()\\n    # no answer\\n    if abs(max-min) > 1 or max + min > kolvo - 2:\\n        print('-1')\\n    #\\n    else:\\n        #min == max\\n        if max == min:\\n            i = 2\\n            answer += '1' + ' '\\n\\n            while max > 0:\\n                max -= 1\\n                answer += str(i+1) + ' ' + str(i) + ' '\\n                i += 2\\n\\n            while i <= kolvo:\\n                answer += str(i) + ' '\\n                i += 1\\n\\n            print(answer)\\n        #max>min\\n        elif max > min:\\n            i = 2\\n            answer += '1' + ' '\\n\\n            while min > 0:\\n                min -= 1\\n                answer += str(i+1) + ' ' + str(i) + ' '\\n                i += 2\\n\\n            while kolvo >= i:\\n                answer += str(kolvo) + ' '\\n                kolvo -= 1\\n\\n            print(answer)\\n        else:\\n            i = kolvo - 1\\n            answer += str(kolvo) + ' '\\n\\n            while max > 0:\\n                max -= 1\\n                answer += str(i-1) + ' ' + str(i) + ' '\\n                i -= 2\\n            kolvo = 1\\n\\n            while kolvo <= i:\\n                answer += str(kolvo) + ' '\\n                kolvo += 1\\n\\n            print(answer)\",\"language\":\"python\",\"split\":\"test\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"On the great island of Baltia, there live N people, numbered from 1 to N. There are exactly M pairs of people that are friends with each other. The people of Baltia want to organize a successful party, but they have very strict rules on what a party is and when the party is successful. On the island of Baltia, a party is a gathering of exactly 5 people. The party is considered to be successful if either all the people at the party are friends with each other (so that they can all talk to each other without having to worry about talking to someone they are not friends with) or no two people at the party are friends with each other (so that everyone can just be on their phones without anyone else bothering them). Please help the people of Baltia organize a successful party or tell them that it's impossible to do so.\\n\\nInput\\n\\nThe first line contains two integer numbers, N (5 \u2264 N \u2264 2*10^5) and M (0 \u2264 M \u2264 2*10^5) \u2013 the number of people that live in Baltia, and the number of friendships. The next M lines each contains two integers U_i and V_i (1 \u2264 U_i,V_i \u2264 N) \u2013 meaning that person U_i is friends with person V_i. Two friends can not be in the list of friends twice (no pairs are repeated) and a person can be friends with themselves (U_i \u2260 V_i).\\n\\nOutput\\n\\nIf it's possible to organize a successful party, print 5 numbers indicating which 5 people should be invited to the party. If it's not possible to organize a successful party, print -1 instead. If there are multiple successful parties possible, print any.\\n\\nExamples\\n\\nInput\\n\\n\\n6 3\\n1 4\\n4 2\\n5 4\\n\\n\\nOutput\\n\\n\\n1 2 3 5 6\\n\\n\\nInput\\n\\n\\n5 4\\n1 2\\n2 3\\n3 4\\n4 5\\n\\n\\nOutput\\n\\n\\n-1\\\":\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\ntemplate <typename T>\\ninline void read(T& x) {\\n  char c;\\n  int sign = 1;\\n  x = 0;\\n  do {\\n    c = getchar();\\n    if (c == '-') c = getchar();\\n  } while (!isdigit(c));\\n  do {\\n    x = x * 10 + c - '0';\\n    c = getchar();\\n  } while (isdigit(c));\\n  x *= sign;\\n}\\nconst int N = 2e5 + 50;\\nint n, m, a[6];\\nset<int> s[N];\\nint main() {\\n  read(n);\\n  read(m);\\n  for (register int i = 1; i <= m; ++i) {\\n    int u, v;\\n    read(u);\\n    read(v);\\n    s[u].insert(v);\\n    s[v].insert(u);\\n  }\\n  for (register int qqqq = 1; qqqq <= 1000000; ++qqqq) {\\n    for (register int i = 1; i <= 5; ++i) a[i] = rand() % n + 1;\\n    bool flag = 1;\\n    int k = s[a[1]].count(a[2]);\\n    for (register int i = 1; i <= 5; ++i)\\n      for (register int j = i + 1; j <= 5; ++j)\\n        if (a[i] == a[j] || k != s[a[i]].count(a[j])) {\\n          flag = 0;\\n          break;\\n        }\\n    if (flag) {\\n      sort(a + 1, a + 1 + 5);\\n      for (register int i = 1; i <= 5; ++i) printf(\\\"%d \\\", a[i]);\\n      return 0;\\n    }\\n  }\\n  puts(\\\"-1\\\");\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Array of integers is unimodal, if:\\n\\n  * it is strictly increasing in the beginning; \\n  * after that it is constant; \\n  * after that it is strictly decreasing. \\n\\n\\n\\nThe first block (increasing) and the last block (decreasing) may be absent. It is allowed that both of this blocks are absent.\\n\\nFor example, the following three arrays are unimodal: [5, 7, 11, 11, 2, 1], [4, 4, 2], [7], but the following three are not unimodal: [5, 5, 6, 6, 1], [1, 2, 1, 2], [4, 5, 5, 6].\\n\\nWrite a program that checks if an array is unimodal.\\n\\nInput\\n\\nThe first line contains integer n (1 \u2264 n \u2264 100) \u2014 the number of elements in the array.\\n\\nThe second line contains n integers a1, a2, ..., an (1 \u2264 ai \u2264 1 000) \u2014 the elements of the array.\\n\\nOutput\\n\\nPrint \\\"YES\\\" if the given array is unimodal. Otherwise, print \\\"NO\\\".\\n\\nYou can output each letter in any case (upper or lower).\\n\\nExamples\\n\\nInput\\n\\n6\\n1 5 5 5 4 2\\n\\n\\nOutput\\n\\nYES\\n\\n\\nInput\\n\\n5\\n10 20 30 20 10\\n\\n\\nOutput\\n\\nYES\\n\\n\\nInput\\n\\n4\\n1 2 1 2\\n\\n\\nOutput\\n\\nNO\\n\\n\\nInput\\n\\n7\\n3 3 3 3 3 3 3\\n\\n\\nOutput\\n\\nYES\\n\\nNote\\n\\nIn the first example the array is unimodal, because it is strictly increasing in the beginning (from position 1 to position 2, inclusively), that it is constant (from position 2 to position 4, inclusively) and then it is strictly decreasing (from position 4 to position 6, inclusively).\",\"targets\":\"n = int(input())\\n\\n\\nt = list(map(int,input().split()))\\n\\n\\nif len(set(t))==1:\\n    print('YES')\\nelif t == sorted(t) and len(set(t))==n:\\n    print('YES')\\nelif t == sorted(t)[::-1] and len(set(t))==n:\\n    print('YES')\\nelse:\\n\\n    u = max(t)\\n    \\n\\n    x=t.index(u)\\n    h=0\\n    for j in range(1,x):\\n        if t[j]>t[j-1]:\\n            pass\\n        else:\\n            print('NO')\\n            h+=1\\n            break\\n    if h==0:\\n        for y in range(x+t.count(u),n):\\n            if t[y]<t[y-1]:\\n                pass\\n            else:\\n                print('NO')\\n                h+=1\\n                break\\n        \\n        if h==0:\\n            print('YES')\",\"language\":\"python\",\"split\":\"train\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in PYTHON3?\\nYou are given an array a of length n.\\n\\nLet's define the eversion operation. Let x = a_n. Then array a is partitioned into two parts: left and right. The left part contains the elements of a that are not greater than x (\u2264 x). The right part contains the elements of a that are strictly greater than x (> x). The order of elements in each part is kept the same as before the operation, i. e. the partition is stable. Then the array is replaced with the concatenation of the left and the right parts.\\n\\nFor example, if the array a is [2, 4, 1, 5, 3], the eversion goes like this: [2, 4, 1, 5, 3] \u2192 [2, 1, 3], [4, 5] \u2192 [2, 1, 3, 4, 5].\\n\\nWe start with the array a and perform eversions on this array. We can prove that after several eversions the array a stops changing. Output the minimum number k such that the array stops changing after k eversions.\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 100). Description of the test cases follows.\\n\\nThe first line contains a single integer n (1 \u2264 n \u2264 2 \u22c5 10^5).\\n\\nThe second line contains n integers a_1, a_2, ..., a_n (1 \u2264 a_i \u2264 10^9).\\n\\nIt is guaranteed that the sum of n over all test cases does not exceed 2 \u22c5 10^5.\\n\\nOutput\\n\\nFor each test case print a single integer k \u2014 the number of eversions after which the array stops changing.\\n\\nExample\\n\\nInput\\n\\n\\n3\\n5\\n2 4 1 5 3\\n5\\n5 3 2 4 1\\n4\\n1 1 1 1\\n\\n\\nOutput\\n\\n\\n1\\n2\\n0\\n\\nNote\\n\\nConsider the fist example.\\n\\n  * The first eversion: a = [1, 4, 2, 5, 3], x = 3. [2, 4, 1, 5, 3] \u2192 [2, 1, 3], [4, 5] \u2192 [2, 1, 3, 4, 5]. \\n  * The second and following eversions: a = [2, 1, 3, 4, 5], x = 5. [2, 1, 3, 4, 5] \u2192 [2, 1, 3, 4, 5], [] \u2192 [2, 1, 3, 4, 5]. This eversion does not change the array, so the answer is 1. \\n\\n\\n\\nConsider the second example. \\n\\n  * The first eversion: a = [5, 3, 2, 4, 1], x = 1. [5, 3, 2, 4, 1] \u2192 [1], [5, 3, 2, 4] \u2192 [1, 5, 3, 2, 4]. \\n  * The second eversion: a = [1, 5, 3, 2, 4], x = 4. [1, 5, 3, 2, 4] \u2192 [1, 3, 2, 4], [5] \u2192 [1, 3, 2, 4, 5]. \\n  * The third and following eversions: a = [1, 3, 2, 4,...\",\"targets\":\"# cook your dish here\\nimport math\\ndef modInverse(p, q):\\n\\t\\n\\t    mod = 998244353\\n\\t    expo = 0\\n\\t    expo = mod - 2\\n\\n\\t    # Loop to find the value\\n\\t    # until the expo is not zero\\n\\t    while (expo):\\n\\t        if (expo & 1):\\n\\t            p = (p * q) % mod\\n\\t        q = (q * q) % mod\\n\\t        expo >>= 1\\n\\t    return p\\n\\t    \\ndef answer(x,y,li):\\n    s=[]\\n    for p in range(0,len(li)-1):\\n        s.append(li[p+1]-li[p])\\n    s.append(int(1e18))\\n    \\n    def solu(s,fi,y):\\n        m=0\\n        for j in range(0,len(s)):\\n            m=m+min(s[j],fi)\\n        return(m>=y)\\n        \\n    low=1\\n    high=int(1e18)\\n    ans=0\\n    while (low<high):\\n        fi=(low+high)\\/\\/2\\n        if solu(s,fi,y):\\n            high=fi\\n            ans=fi\\n        else:\\n            low=fi+1\\n    \\n    return ans\\n    \\n    \\nt=int(input())\\nfor i in range (0,t):\\n    x=int(input())\\n    s=input()\\n    r=-1;m=0\\n    for x in map(int,s.split()[::-1]):\\n        \\n        if x>m:\\n            r+=1\\n            m=x\\n    print(r)\",\"language\":\"python\",\"split\":\"test\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"A bracketed sequence is called correct (regular) if by inserting \\\"+\\\" and \\\"1\\\" you can get a well-formed mathematical expression from it. For example, sequences \\\"(())()\\\", \\\"()\\\" and \\\"(()(()))\\\" are correct, while \\\")(\\\", \\\"(()\\\" and \\\"(()))(\\\" are not.\\n\\nThe teacher gave Dmitry's class a very strange task \u2014 she asked every student to come up with a sequence of arbitrary length, consisting only of opening and closing brackets. After that all the students took turns naming the sequences they had invented. When Dima's turn came, he suddenly realized that all his classmates got the correct bracketed sequence, and whether he got the correct bracketed sequence, he did not know.\\n\\nDima suspects now that he simply missed the word \\\"correct\\\" in the task statement, so now he wants to save the situation by modifying his sequence slightly. More precisely, he can the arbitrary number of times (possibly zero) perform the reorder operation.\\n\\nThe reorder operation consists of choosing an arbitrary consecutive subsegment (substring) of the sequence and then reordering all the characters in it in an arbitrary way. Such operation takes l nanoseconds, where l is the length of the subsegment being reordered. It's easy to see that reorder operation doesn't change the number of opening and closing brackets. For example for \\\"))((\\\" he can choose the substring \\\")(\\\" and do reorder \\\")()(\\\" (this operation will take 2 nanoseconds).\\n\\nSince Dima will soon have to answer, he wants to make his sequence correct as fast as possible. Help him to do this, or determine that it's impossible.\\n\\nInput\\n\\nThe first line contains a single integer n (1 \u2264 n \u2264 10^6) \u2014 the length of Dima's sequence.\\n\\nThe second line contains string of length n, consisting of characters \\\"(\\\" and \\\")\\\" only.\\n\\nOutput\\n\\nPrint a single integer \u2014 the minimum number of nanoseconds to make the sequence correct or \\\"-1\\\" if it is impossible to do so.\\n\\nExamples\\n\\nInput\\n\\n\\n8\\n))((())(\\n\\n\\nOutput\\n\\n\\n6\\n\\n\\nInput\\n\\n\\n3\\n(()\\n\\n\\nOutput\\n\\n\\n-1\\n\\nNote\\n\\nIn the first example we can firstly reorder the segment from first to the...\\nSolve the task in JAVA.\",\"targets\":\"import java.util.ArrayList;\\nimport java.util.Arrays;\\nimport java.util.LinkedList;\\nimport java.util.Queue;\\nimport java.io.BufferedReader;\\nimport java.io.FileReader;\\nimport java.io.IOException;\\nimport java.io.InputStreamReader;\\nimport java.util.StringTokenizer;\\nimport java.util.Random;\\nimport java.io.FileWriter;\\nimport java.io.PrintWriter;\\n\\/*\\n    Solution Created: 12:46:35 07\\/03\\/2020\\n    Custom Competitive programming helper.\\n*\\/\\npublic class Main {\\n\\tpublic static void solve(Reader in, Writer out) {\\n\\t\\tint n = in.nextInt();\\n\\t\\tchar[] a = in.next().toCharArray();\\n\\t\\tint bal = 0;\\n\\t\\tint li = -1;\\n\\t\\tlong ans = 0;\\n\\t\\tfor(int i = 0; i<n; i++) {\\n\\t\\t\\tif(a[i]=='(') bal++; else bal--;\\n\\t\\t\\tif(bal<0) {\\n\\t\\t\\t\\tif(li==-1) li = i;\\n\\t\\t\\t}else if(bal == 0) {\\n\\t\\t\\t\\tif(li!=-1) {\\n\\t\\t\\t\\t\\tans+= (i-li+1);\\n\\t\\t\\t\\t\\tli = -1;\\n\\t\\t\\t\\t}\\n\\t\\t\\t}\\n\\t\\t}\\n\\t\\tif(bal!=0) {\\n\\t\\t\\tout.println(-1);\\n\\t\\t\\treturn;\\n\\t\\t}\\n\\t\\tout.println(ans);\\n\\t}\\n\\t\\n\\tpublic static void main(String[] args) {\\n\\t\\tReader in = new Reader();\\n\\t\\tWriter out = new Writer();\\n\\t\\tsolve(in, out);\\n\\t\\tout.exit();\\n\\t}\\n\\nstatic class Graph {\\n\\tprivate ArrayList<Integer> con[];\\n\\tprivate boolean[] visited;\\n\\n\\tpublic Graph(int n) {\\n\\t\\tcon = new ArrayList[n];\\n\\t\\tfor (int i = 0; i < n; ++i)\\n\\t\\t\\tcon[i] = new ArrayList();\\n\\t\\tvisited = new boolean[n];\\n\\t}\\n\\n\\tpublic void reset() {\\n\\t\\tArrays.fill(visited, false);\\n\\t}\\n\\n\\tpublic void addEdge(int v, int w) {\\n\\t\\tcon[v].add(w);\\n\\t}\\n\\n\\tpublic void dfs(int cur) {\\n\\t\\tvisited[cur] = true;\\n\\t\\tfor (Integer v : con[cur]) {\\n\\t\\t\\tif (!visited[v]) {\\n\\t\\t\\t\\tdfs(v);\\n\\t\\t\\t}\\n\\t\\t}\\n\\t}\\n\\n\\tpublic void bfs(int cur) {\\n\\t\\tQueue<Integer> q = new LinkedList<>();\\n\\t\\tq.add(cur);\\n\\t\\tvisited[cur] = true;\\n\\t\\twhile (!q.isEmpty()) {\\n\\t\\t\\tcur = q.poll();\\n\\t\\t\\tfor (Integer v : con[cur]) {\\n\\t\\t\\t\\tif (!visited[v]) {\\n\\t\\t\\t\\t\\tvisited[v] = true;\\n\\t\\t\\t\\t\\tq.add(v);\\n\\t\\t\\t\\t}\\n\\t\\t\\t}\\n\\t\\t}\\n\\t}\\n}\\n\\nstatic class Reader {\\n\\tstatic BufferedReader br;\\n\\tstatic StringTokenizer st;\\n\\tprivate int charIdx = 0;\\n\\tprivate String s;\\n\\n\\tpublic Reader() {\\n\\t\\tthis.br = new BufferedReader(new InputStreamReader(System.in));\\n\\t}\\n\\t\\n\\tpublic Reader(String f){\\n\\t\\ttry {\\n\\t\\t\\tthis.br = new BufferedReader(new...\",\"language\":\"python\",\"split\":\"train\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"As you know, every birthday party has a cake! This time, Babaei is going to prepare the very special birthday party's cake.\\n\\nSimple cake is a cylinder of some radius and height. The volume of the simple cake is equal to the volume of corresponding cylinder. Babaei has n simple cakes and he is going to make a special cake placing some cylinders on each other.\\n\\nHowever, there are some additional culinary restrictions. The cakes are numbered in such a way that the cake number i can be placed only on the table or on some cake number j where j < i. Moreover, in order to impress friends Babaei will put the cake i on top of the cake j only if the volume of the cake i is strictly greater than the volume of the cake j.\\n\\nBabaei wants to prepare a birthday cake that has a maximum possible total volume. Help him find this value.\\n\\nInput\\n\\nThe first line of the input contains a single integer n (1 \u2264 n \u2264 100 000) \u2014 the number of simple cakes Babaei has.\\n\\nEach of the following n lines contains two integers ri and hi (1 \u2264 ri, hi \u2264 10 000), giving the radius and height of the i-th cake.\\n\\nOutput\\n\\nPrint the maximum volume of the cake that Babaei can make. Your answer will be considered correct if its absolute or relative error does not exceed 10 - 6.\\n\\nNamely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct, if <image>.\\n\\nExamples\\n\\nInput\\n\\n2\\n100 30\\n40 10\\n\\n\\nOutput\\n\\n942477.796077000\\n\\n\\nInput\\n\\n4\\n1 1\\n9 7\\n1 4\\n10 7\\n\\n\\nOutput\\n\\n3983.539484752\\n\\nNote\\n\\nIn first sample, the optimal way is to choose the cake number 1.\\n\\nIn second sample, the way to get the maximum volume is to use cakes with indices 1, 2 and 4.\\nSolve the task in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst int N = 1e5 + 100;\\nconst long double EPS = 1e-9;\\nconst long long int mod = 1e9 + 7;\\nconst long long int inf = 1e16;\\nlong double seg[N * 4], mx[N];\\nvector<pair<long double, int>> v;\\nint n;\\nlong double pi = 2 * acos(0.0);\\nlong double get(int l, int r, int b = 0, int e = n, int ind = 1) {\\n  if (l <= b && r >= e) return seg[ind];\\n  int mid = (b + e) \\/ 2;\\n  long double res = 0;\\n  if (l < mid) res = max(res, get(l, r, b, mid, ind * 2));\\n  if (r > mid) res = max(res, get(l, r, mid, e, ind * 2 + 1));\\n  return res;\\n}\\nvoid add(int x, int b = 0, int e = n, int ind = 1) {\\n  seg[ind] = max(seg[ind], mx[x]);\\n  if (b + 1 == e) return;\\n  int mid = (b + e) \\/ 2;\\n  if (v[x].second < mid)\\n    add(x, b, mid, ind * 2);\\n  else\\n    add(x, mid, e, ind * 2 + 1);\\n  return;\\n}\\nint main() {\\n  ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);\\n  cout << fixed << setprecision(6);\\n  cin >> n;\\n  for (int i = 0; i < n; i++) {\\n    long double r, h;\\n    cin >> r >> h;\\n    long double vol = h * r * r * pi;\\n    v.push_back({vol, i});\\n  }\\n  sort(v.begin(), v.end());\\n  long double ans = 0;\\n  int i = 0;\\n  while (i < n) {\\n    int j = i;\\n    while (j < n && v[j].first - v[i].first <= EPS) {\\n      mx[j] = v[j].first;\\n      if (v[j].second != 0) mx[j] += get(0, v[j].second);\\n      ans = max(ans, mx[j]);\\n      j++;\\n    }\\n    while (i < j) {\\n      add(i);\\n      i++;\\n    }\\n  }\\n  cout << ans << endl;\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Each evening Roma plays online poker on his favourite website. The rules of poker on this website are a bit strange: there are always two players in a hand, there are no bets, and the winner takes 1 virtual bourle from the loser.\\n\\nLast evening Roma started to play poker. He decided to spend no more than k virtual bourles \u2014 he will stop immediately if the number of his loses exceeds the number of his wins by k. Also Roma will leave the game if he wins enough money for the evening, i.e. if the number of wins exceeds the number of loses by k.\\n\\nNext morning Roma found a piece of paper with a sequence on it representing his results. Roma doesn't remember the results exactly, and some characters in the sequence are written in a way such that it's impossible to recognize this character, so Roma can't recall whether he won k bourles or he lost.\\n\\nThe sequence written by Roma is a string s consisting of characters W (Roma won the corresponding hand), L (Roma lost), D (draw) and ? (unknown result). Roma wants to restore any valid sequence by changing all ? characters to W, L or D. The sequence is called valid if all these conditions are met: \\n\\n  * In the end the absolute difference between the number of wins and loses is equal to k; \\n  * There is no hand such that the absolute difference before this hand was equal to k. \\n\\n\\n\\nHelp Roma to restore any such sequence.\\n\\nInput\\n\\nThe first line contains two numbers n (the length of Roma's sequence) and k (1 \u2264 n, k \u2264 1000).\\n\\nThe second line contains the sequence s consisting of characters W, L, D and ?. There are exactly n characters in this sequence.\\n\\nOutput\\n\\nIf there is no valid sequence that can be obtained from s by replacing all ? characters by W, L or D, print NO.\\n\\nOtherwise print this sequence. If there are multiple answers, print any of them.\\n\\nExamples\\n\\nInput\\n\\n3 2\\nL??\\n\\n\\nOutput\\n\\nLDL\\n\\n\\nInput\\n\\n3 1\\nW??\\n\\n\\nOutput\\n\\nNO\\n\\n\\nInput\\n\\n20 5\\n?LLLLLWWWWW?????????\\n\\n\\nOutput\\n\\nWLLLLLWWWWWWWWLWLWDW\\nUsing cpp can you solve the prior task?\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nlong long n, k, dp[1009][2009], ans;\\nstring s;\\nlong long f(int i, int j) {\\n  if (i >= n) return (abs(1000 - j) == k);\\n  if (abs(1000 - j) >= k) return 0;\\n  long long &ret = dp[i][j];\\n  if (ret + 1) return ret;\\n  ret = 0;\\n  if (s[i] == 'L') ret |= f(i + 1, j - 1);\\n  if (s[i] == 'W') ret |= f(i + 1, j + 1);\\n  if (s[i] == 'D') ret |= f(i + 1, j);\\n  if (s[i] == '?') ret |= (f(i + 1, j + 1) | f(i + 1, j - 1) | f(i + 1, j));\\n  return ret;\\n}\\nvoid pr(int i, int j) {\\n  if (i >= n) return;\\n  if (s[i] == 'L') {\\n    cout << 'L';\\n    pr(i + 1, j - 1);\\n  }\\n  if (s[i] == 'W') {\\n    cout << 'W';\\n    pr(i + 1, j + 1);\\n  }\\n  if (s[i] == 'D') {\\n    cout << 'D';\\n    pr(i + 1, j);\\n  }\\n  if (s[i] == '?') {\\n    if (f(i + 1, j + 1) >= f(i + 1, j - 1) && f(i + 1, j + 1) >= f(i + 1, j)) {\\n      cout << 'W';\\n      pr(i + 1, j + 1);\\n    } else if (f(i + 1, j - 1) >= f(i + 1, j + 1) &&\\n               f(i + 1, j - 1) >= f(i + 1, j)) {\\n      cout << 'L';\\n      pr(i + 1, j - 1);\\n    } else if (f(i + 1, j) >= f(i + 1, j - 1) &&\\n               f(i + 1, j) >= f(i + 1, j + 1)) {\\n      cout << 'D';\\n      pr(i + 1, j);\\n    }\\n  }\\n}\\nint main() {\\n  ios::sync_with_stdio(NULL);\\n  cin.tie(0);\\n  cout.tie(0);\\n  ;\\n  cin >> n >> k >> s;\\n  memset(dp, -1, sizeof dp);\\n  ans = f(0, 1000);\\n  if (!ans) {\\n    cout << \\\"NO\\\";\\n  } else {\\n    pr(0, 1000);\\n  }\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Amer cabs has released a scheme through which a user gets a free drive when he shares a reference code with another Amer app user. Given N number of app users, output total number of free drives gained by all of them. Two same users cannot share reference code more than once.  \\n\\nInput Format \\nThe first line contains the number of test cases T, T lines follow. \\nEach line then contains an integer N, the total number of Amer App Users.\\n\\nOutput Format\\n\\nPrint the number of Free Drives for each test-case in a new line.\\n\\nConstraints\\n\\n1 \u2264 T \u2264 1000\\n0 < N < 10^6\\n\\nSAMPLE INPUT\\n2\\n1\\n2\\n\\nSAMPLE OUTPUT\\n0\\n1\\n\\nExplanation\\n\\nCase 1 : Single user shares no reference code, hence 0 free drives. \\nCase 2 : There are 2 app users, so reference code is shared once, hence 1 free drive.\\nif __\",\"targets\":\"name__=='__main__':\\n    for i in range(0,int(input())):\\n        n = int(input())\\n        print((n*(n-1))\\/\\/2)\",\"language\":\"python\",\"split\":\"train\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Polycarp has found a table having an infinite number of rows and columns. The rows are numbered from 1, starting from the topmost one. The columns are numbered from 1, starting from the leftmost one.\\n\\nInitially, the table hasn't been filled and Polycarp wants to fix it. He writes integers from 1 and so on to the table as follows.\\n\\n<image> The figure shows the placement of the numbers from 1 to 10. The following actions are denoted by the arrows.\\n\\nThe leftmost topmost cell of the table is filled with the number 1. Then he writes in the table all positive integers beginning from 2 sequentially using the following algorithm.\\n\\nFirst, Polycarp selects the leftmost non-filled cell in the first row and fills it. Then, while the left neighbor of the last filled cell is filled, he goes down and fills the next cell. So he goes down until the last filled cell has a non-filled neighbor to the left (look at the vertical arrow going down in the figure above).\\n\\nAfter that, he fills the cells from the right to the left until he stops at the first column (look at the horizontal row in the figure above). Then Polycarp selects the leftmost non-filled cell in the first row, goes down, and so on.\\n\\nA friend of Polycarp has a favorite number k. He wants to know which cell will contain the number. Help him to find the indices of the row and the column, such that the intersection of the row and the column is the cell containing the number k.\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 100) \u2014 the number of test cases. Then t test cases follow.\\n\\nEach test case consists of one line containing one integer k (1 \u2264 k \u2264 10^9) which location must be found.\\n\\nOutput\\n\\nFor each test case, output in a separate line two integers r and c (r, c \u2265 1) separated by spaces \u2014 the indices of the row and the column containing the cell filled by the number k, respectively.\\n\\nExample\\n\\nInput\\n\\n\\n7\\n11\\n14\\n5\\n4\\n1\\n2\\n1000000000\\n\\n\\nOutput\\n\\n\\n2 4\\n4 3\\n1 3\\n2 1\\n1 1\\n1 2\\n31623 14130\\nSolve the task in JAVA.\",\"targets\":\"import java.util.Scanner;\\n\\npublic class infinity_table {\\n    public static void main(String args[]) {\\n        Scanner sc = new Scanner(System.in);\\n        int t = sc.nextInt();\\n        for (int i = 0; i < t; i++) {\\n            int find = sc.nextInt();\\n            int flag = 1;\\n            while(find>flag*flag){\\n                flag++;\\n            }\\n            int row=flag;\\n            int col=1;\\n            int big=flag*flag;\\n            while(big>find){\\n                big--;\\n                if(col<flag)\\n                    col++;\\n                else\\n                    row--;\\n            }\\n            System.out.println(row+\\\" \\\"+col);\\n        }\\n    }\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Edogawa Conan got tired of solving cases, and invited his friend, Professor Agasa, over. They decided to play a game of cards. Conan has n cards, and the i-th card has a number ai written on it.\\n\\nThey take turns playing, starting with Conan. In each turn, the player chooses a card and removes it. Also, he removes all cards having a number strictly lesser than the number on the chosen card. Formally, if the player chooses the i-th card, he removes that card and removes the j-th card for all j such that aj < ai.\\n\\nA player loses if he cannot make a move on his turn, that is, he loses if there are no cards left. Predict the outcome of the game, assuming both players play optimally.\\n\\nInput\\n\\nThe first line contains an integer n (1 \u2264 n \u2264 105) \u2014 the number of cards Conan has. \\n\\nThe next line contains n integers a1, a2, ..., an (1 \u2264 ai \u2264 105), where ai is the number on the i-th card.\\n\\nOutput\\n\\nIf Conan wins, print \\\"Conan\\\" (without quotes), otherwise print \\\"Agasa\\\" (without quotes).\\n\\nExamples\\n\\nInput\\n\\n3\\n4 5 7\\n\\n\\nOutput\\n\\nConan\\n\\n\\nInput\\n\\n2\\n1 1\\n\\n\\nOutput\\n\\nAgasa\\n\\nNote\\n\\nIn the first example, Conan can just choose the card having number 7 on it and hence remove all the cards. After that, there are no cards left on Agasa's turn.\\n\\nIn the second example, no matter which card Conan chooses, there will be one one card left, which Agasa can choose. After that, there are no cards left when it becomes Conan's turn again.\\nUsing java can you solve the prior task?\",\"targets\":\"\\/\\/package com.company;\\n\\nimport java.util.Scanner;\\n\\npublic class Main\\n{\\n    public static void main(String[] args)\\n    {\\n        Scanner s = new Scanner(System.in);\\n\\n        int totalCards = s.nextInt();\\n\\n        int hash[] = new int[100001];\\n\\n        while(totalCards --> 0)\\n        {\\n            hash[s.nextInt()]++;\\n        }\\n\\n        int i;\\n        for(i = 1;i <= 100000;i++)\\n        {\\n            if(hash[i]%2 != 0)\\n                break;\\n        }\\n\\n        if(i != 100001)\\n        {\\n            System.out.println(\\\"Conan\\\");\\n        }\\n        else\\n            System.out.println(\\\"Agasa\\\");\\n    }\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Polycarp must pay exactly n burles at the checkout. He has coins of two nominal values: 1 burle and 2 burles. Polycarp likes both kinds of coins equally. So he doesn't want to pay with more coins of one type than with the other.\\n\\nThus, Polycarp wants to minimize the difference between the count of coins of 1 burle and 2 burles being used. Help him by determining two non-negative integer values c_1 and c_2 which are the number of coins of 1 burle and 2 burles, respectively, so that the total value of that number of coins is exactly n (i. e. c_1 + 2 \u22c5 c_2 = n), and the absolute value of the difference between c_1 and c_2 is as little as possible (i. e. you must minimize |c_1-c_2|).\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases. Then t test cases follow.\\n\\nEach test case consists of one line. This line contains one integer n (1 \u2264 n \u2264 10^9) \u2014 the number of burles to be paid by Polycarp.\\n\\nOutput\\n\\nFor each test case, output a separate line containing two integers c_1 and c_2 (c_1, c_2 \u2265 0) separated by a space where c_1 is the number of coins of 1 burle and c_2 is the number of coins of 2 burles. If there are multiple optimal solutions, print any one.\\n\\nExample\\n\\nInput\\n\\n\\n6\\n1000\\n30\\n1\\n32\\n1000000000\\n5\\n\\n\\nOutput\\n\\n\\n334 333\\n10 10\\n1 0\\n10 11\\n333333334 333333333\\n1 2\\n\\nNote\\n\\nThe answer for the first test case is \\\"334 333\\\". The sum of the nominal values of all coins is 334 \u22c5 1 + 333 \u22c5 2 = 1000, whereas |334 - 333| = 1. One can't get the better value because if |c_1 - c_2| = 0, then c_1 = c_2 and c_1 \u22c5 1 + c_1 \u22c5 2 = 1000, but then the value of c_1 isn't an integer.\\n\\nThe answer for the second test case is \\\"10 10\\\". The sum of the nominal values is 10 \u22c5 1 + 10 \u22c5 2 = 30 and |10 - 10| = 0, whereas there's no number having an absolute value less than 0.\\nThe above is tricky. Write me a correct solution in JAVA.\",\"targets\":\"import java.util.*;\\nimport java.lang.*;\\n\\npublic class A {\\n    private static Scanner ler = new Scanner(System.in);\\n    \\n    private static void solve() {\\n\\tint n = ler.nextInt();\\n\\tint c1 = n\\/3, c2 = n\\/3;\\n\\n\\tif     (n%3 == 1) c1++;\\n\\telse if(n%3 == 2) c2++;\\n\\n\\tSystem.out.println(c1 + \\\" \\\" + c2);\\n    }\\n\\n    public static void main(String[] args) {\\n\\tint t = ler.nextInt();\\n\\n\\twhile(t-- > 0)\\n\\t    solve();\\n    }\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Colossal! \u2014 exclaimed Hawk-nose. \u2014 A programmer! That's exactly what we are looking for.\\n\\nArkadi and Boris Strugatsky. Monday starts on Saturday\\n\\nReading the book \\\"Equations of Mathematical Magic\\\" Roman Oira-Oira and Cristobal Junta found an interesting equation: a - (a \u2295 x) - x = 0 for some given a, where \u2295 stands for a bitwise exclusive or (XOR) of two integers (this operation is denoted as ^ or xor in many modern programming languages). Oira-Oira quickly found some x, which is the solution of the equation, but Cristobal Junta decided that Oira-Oira's result is not interesting enough, so he asked his colleague how many non-negative solutions of this equation exist. This task turned out to be too difficult for Oira-Oira, so he asks you to help.\\n\\nInput\\n\\nEach test contains several possible values of a and your task is to find the number of equation's solution for each of them. The first line contains an integer t (1 \u2264 t \u2264 1000) \u2014 the number of these values.\\n\\nThe following t lines contain the values of parameter a, each value is an integer from 0 to 2^{30} - 1 inclusive.\\n\\nOutput\\n\\nFor each value of a print exactly one integer \u2014 the number of non-negative solutions of the equation for the given value of the parameter. Print answers in the same order as values of a appear in the input.\\n\\nOne can show that the number of solutions is always finite.\\n\\nExample\\n\\nInput\\n\\n3\\n0\\n2\\n1073741823\\n\\n\\nOutput\\n\\n1\\n2\\n1073741824\\n\\nNote\\n\\nLet's define the bitwise exclusive OR (XOR) operation. Given two integers x and y, consider their binary representations (possibly with leading zeroes): x_k ... x_2 x_1 x_0 and y_k ... y_2 y_1 y_0. Here, x_i is the i-th bit of the number x and y_i is the i-th bit of the number y. Let r = x \u2295 y be the result of the XOR operation of x and y. Then r is defined as r_k ... r_2 r_1 r_0 where:\\n\\n$$$ r_i = \\\\left\\\\{ \\\\begin{aligned} 1, ~ if ~ x_i \u2260 y_i \\\\\\\\\\\\ 0, ~ if ~ x_i = y_i \\\\end{aligned} \\\\right. $$$\\n\\nFor the first value of the parameter, only x = 0 is a solution of the equation.\\n\\nFor the second value of the parameter,...\\nUsing cpp can you solve the prior task?\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst int N = 1e6 + 10;\\nconst int oo = 1e9;\\nconst int PI = acos(-1);\\nint t;\\nint n;\\nint ans(int n) {\\n  int x = n;\\n  int ans = 0;\\n  while (x) {\\n    ans += (x & 1);\\n    x >>= 1;\\n  }\\n  return (1 << ans);\\n}\\nint main() {\\n  cin >> t;\\n  while (t--) {\\n    cin >> n;\\n    cout << ans(n) << endl;\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"On the board, Bob wrote n positive integers in [base](https:\\/\\/en.wikipedia.org\\/wiki\\/Positional_notation#Base_of_the_numeral_system) 10 with sum s (i. e. in decimal numeral system). Alice sees the board, but accidentally interprets the numbers on the board as base-11 integers and adds them up (in base 11).\\n\\nWhat numbers should Bob write on the board, so Alice's sum is as large as possible?\\n\\nInput\\n\\nThe input consists of multiple test cases. The first line contains an integer t (1 \u2264 t \u2264 100) \u2014 the number of test cases. The description of the test cases follows.\\n\\nThe only line of each test case contains two integers s and n (1 \u2264 s \u2264 10^9; 1 \u2264 n \u2264 min(100, s)) \u2014 the sum and amount of numbers on the board, respectively. Numbers s and n are given in decimal notation (base 10).\\n\\nOutput\\n\\nFor each test case, output n positive integers \u2014 the numbers Bob should write on the board, so Alice's sum is as large as possible. If there are multiple answers, print any of them.\\n\\nExample\\n\\nInput\\n\\n\\n6\\n97 2\\n17 1\\n111 4\\n100 2\\n10 9\\n999999 3\\n\\n\\nOutput\\n\\n\\n70 27 \\n17 \\n3 4 100 4\\n10 90\\n1 1 2 1 1 1 1 1 1 \\n999900 90 9\\n\\nNote\\n\\nIn the first test case, 70_{10} + 27_{10} = 97_{10}, and Alice's sum is $$$70_{11} + 27_{11} = 97_{11} = 9 \u22c5 11 + 7 = 106_{10}. (Here x_b represents the number x in base b.) It can be shown that it is impossible for Alice to get a larger sum than 106_{10}$$$.\\n\\nIn the second test case, Bob can only write a single number on the board, so he must write 17.\\n\\nIn the third test case, 3_{10} + 4_{10} + 100_{10} + 4_{10} = 111_{10}, and Alice's sum is $$$3_{11} + 4_{11} + 100_{11} + 4_{11} = 110_{11} = 1 \u22c5 11^2 + 1 \u22c5 11 = 132_{10}. It can be shown that it is impossible for Alice to get a larger sum than 132_{10}$$$.\",\"targets\":\"import os\\nimport sys\\nfrom io import BytesIO, IOBase\\nBUFSIZE = 8192\\nclass FastIO(IOBase):\\n    newlines = 0\\n    def __init__(self, file):\\n        self._fd = file.fileno()\\n        self.buffer = BytesIO()\\n        self.writable = 'x' in file.mode or 'r' not in file.mode\\n        self.write = self.buffer.write if self.writable else None\\n    def read(self):\\n        while True:\\n            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))\\n            if not b:break\\n            ptr = self.buffer.tell()\\n            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)\\n        self.newlines = 0\\n        return self.buffer.read()\\n    def readline(self):\\n        while self.newlines == 0:\\n            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))\\n            self.newlines = b.count(b'\\\\n') + (not b)\\n            ptr = self.buffer.tell()\\n            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)\\n        self.newlines -= 1\\n        return self.buffer.readline()\\n    def flush(self):\\n        if self.writable:\\n            os.write(self._fd, self.buffer.getvalue())\\n            self.buffer.truncate(0), self.buffer.seek(0)\\nclass IOWrapper(IOBase):\\n    def __init__(self, file):\\n        self.buffer = FastIO(file)\\n        self.flush = self.buffer.flush\\n        self.writable = self.buffer.writable\\n        self.write = lambda s: self.buffer.write(s.encode('ascii'))\\n        self.read = lambda: self.buffer.read().decode('ascii')\\n        self.readline = lambda: self.buffer.readline().decode('ascii')\\nsys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)\\ninput = lambda: sys.stdin.readline().rstrip('\\\\r\\\\n')\\n\\ndef val(isa):\\n\\tm = 1\\n\\tv = 0\\n\\tfor i in range(len(isa)):\\n\\t\\tv += isa[-(i + 1)] * m\\n\\t\\tm *= 10\\n\\treturn v\\n\\nfrom collections import Counter\\ndef intact(s, i, n, isa):\\n\\tif i == len(s) - 1:\\n\\t\\tif isa[i] >= n:\\n\\t\\t\\treturn True\\n\\t\\telse:\\n\\t\\t\\treturn RuntimeError\\n\\tif int(s[i + 1:]) >= n - isa[i]:\\n\\t\\treturn True\\n\\treturn val(isa[i + 1:]) >= n - isa[i]\\n\\n\\nfor _ in range(int(input())):\\n\\ts,...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Vupsen and Pupsen were gifted an integer array. Since Vupsen doesn't like the number 0, he threw away all numbers equal to 0 from the array. As a result, he got an array a of length n.\\n\\nPupsen, on the contrary, likes the number 0 and he got upset when he saw the array without zeroes. To cheer Pupsen up, Vupsen decided to come up with another array b of length n such that \u2211_{i=1}^{n}a_i \u22c5 b_i=0. Since Vupsen doesn't like number 0, the array b must not contain numbers equal to 0. Also, the numbers in that array must not be huge, so the sum of their absolute values cannot exceed 10^9. Please help Vupsen to find any such array b!\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 100) \u2014 the number of test cases. The next 2 \u22c5 t lines contain the description of test cases. The description of each test case consists of two lines.\\n\\nThe first line of each test case contains a single integer n (2 \u2264 n \u2264 10^5) \u2014 the length of the array.\\n\\nThe second line contains n integers a_1, a_2, \u2026, a_n (-10^4 \u2264 a_i \u2264 10^4, a_i \u2260 0) \u2014 the elements of the array a.\\n\\nIt is guaranteed that the sum of n over all test cases does not exceed 2 \u22c5 10^5.\\n\\nOutput\\n\\nFor each test case print n integers b_1, b_2, \u2026, b_n \u2014 elements of the array b (|b_1|+|b_2|+\u2026 +|b_n| \u2264 10^9, b_i \u2260 0, \u2211_{i=1}^{n}a_i \u22c5 b_i=0).\\n\\nIt can be shown that the answer always exists.\\n\\nExample\\n\\nInput\\n\\n\\n3\\n2\\n5 5\\n5\\n5 -2 10 -9 4\\n7\\n1 2 3 4 5 6 7\\n\\n\\nOutput\\n\\n\\n1 -1\\n-1 5 1 -1 -1\\n-10 2 2 -3 5 -1 -1\\n\\nNote\\n\\nIn the first test case, 5 \u22c5 1 + 5 \u22c5 (-1)=5-5=0. You could also print 3 -3, for example, since 5 \u22c5 3 + 5 \u22c5 (-3)=15-15=0\\n\\nIn the second test case, 5 \u22c5 (-1) + (-2) \u22c5 5 + 10 \u22c5 1 + (-9) \u22c5 (-1) + 4 \u22c5 (-1)=-5-10+10+9-4=0.\\nSolve the task in JAVA.\",\"targets\":\"import java.util.Scanner;\\n\\npublic class VupsenPupsenand0 {\\n\\n    public static void main(String args[]) {\\n        Scanner scan = new Scanner(System.in);\\n        int t = scan.nextInt();\\n        while (t-- > 0) {\\n            int n = scan.nextInt();\\n            int[] a = new int[n];\\n            for (int i = 0; i < n; i++) {\\n                a[i] = scan.nextInt();\\n            }\\n            if (n % 2 == 0) {\\n                for (int i = 0; i < n; i += 2) {\\n                    System.out.print(a[i + 1] + \\\" \\\" + -a[i] + \\\" \\\");\\n                }\\n                System.out.println();\\n            } else {\\n                for (int i = 0; i < n - 3; i += 2) {\\n                    System.out.print(a[i + 1] + \\\" \\\" + -a[i] + \\\" \\\");\\n                }\\n                int x = a[n - 3];\\n                int y = a[n - 2];\\n                int z = a[n - 1];\\n                if (x + y != 0) {\\n                    System.out.println(-z + \\\" \\\" + (-z) + \\\" \\\" + (x + y));\\n                } else if (y + z != 0) {\\n                    System.out.println((y + z) + \\\" \\\" + (-x) + \\\" \\\" + (-x));\\n                } else {\\n                    System.out.println(-y + \\\" \\\" + (x + z) + \\\" \\\" + (-y));\\n                }\\n            }\\n        }\\n    }\\n\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Dreamoon loves summing up something for no reason. One day he obtains two integers a and b occasionally. He wants to calculate the sum of all nice integers. Positive integer x is called nice if <image> and <image>, where k is some integer number in range [1, a].\\n\\nBy <image> we denote the quotient of integer division of x and y. By <image> we denote the remainder of integer division of x and y. You can read more about these operations here: http:\\/\\/goo.gl\\/AcsXhT.\\n\\nThe answer may be large, so please print its remainder modulo 1 000 000 007 (109 + 7). Can you compute it faster than Dreamoon?\\n\\nInput\\n\\nThe single line of the input contains two integers a, b (1 \u2264 a, b \u2264 107).\\n\\nOutput\\n\\nPrint a single integer representing the answer modulo 1 000 000 007 (109 + 7).\\n\\nExamples\\n\\nInput\\n\\n1 1\\n\\n\\nOutput\\n\\n0\\n\\n\\nInput\\n\\n2 2\\n\\n\\nOutput\\n\\n8\\n\\nNote\\n\\nFor the first sample, there are no nice integers because <image> is always zero.\\n\\nFor the second sample, the set of nice integers is {3, 5}.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nvoid solve() {\\n  long long int a, b;\\n  cin >> a >> b;\\n  if (b == 1)\\n    cout << \\\"0\\\\n\\\";\\n  else {\\n    long long int ans = ((a * (a + 1)) \\/ 2) % 1000000007;\\n    ans *= b;\\n    ans %= 1000000007;\\n    ans += a;\\n    ans %= 1000000007;\\n    ans *= ((b * (b - 1)) \\/ 2) % 1000000007;\\n    ans %= 1000000007;\\n    cout << ans << '\\\\n';\\n  }\\n}\\nint main() {\\n  ios_base::sync_with_stdio(false);\\n  cin.tie(NULL);\\n  cout.tie(NULL);\\n  int T = 1;\\n  while (T--) solve();\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Little Johnny Bubbles enjoys spending hours in front of his computer playing video games. His favorite game is Bubble Strike, fast-paced bubble shooting online game for two players.\\n\\nEach game is set in one of the N maps, each having different terrain configuration. First phase of each game decides on which map the game will be played. The game system randomly selects three maps and shows them to the players. Each player must pick one of those three maps to be discarded. The game system then randomly selects one of the maps that were not picked by any of the players and starts the game.\\n\\nJohnny is deeply enthusiastic about the game and wants to spend some time studying maps, thus increasing chances to win games played on those maps. However, he also needs to do his homework, so he does not have time to study all the maps. That is why he asked himself the following question: \\\"What is the minimum number of maps I have to study, so that the probability to play one of those maps is at least P\\\"?\\n\\nCan you help Johnny find the answer for this question? You can assume Johnny's opponents do not know him, and they will randomly pick maps.\\n\\nInput\\n\\nThe first line contains two integers N (3 \u2264 N \u2264 10^{3}) and P (0 \u2264 P \u2264 1) \u2013 total number of maps in the game and probability to play map Johnny has studied. P will have at most four digits after the decimal point.\\n\\nOutput\\n\\nOutput contains one integer number \u2013 minimum number of maps Johnny has to study.\\n\\nExample\\n\\nInput\\n\\n\\n7 1.0000\\n\\n\\nOutput\\n\\n\\n6\",\"targets\":\"#include <bits\\/stdc++.h>\\ntemplate <class T>\\nbool chmax(T &a, const T &b) {\\n  if (a < b) {\\n    a = b;\\n    return 1;\\n  }\\n  return 0;\\n}\\ntemplate <class T>\\nbool chmin(T &a, const T &b) {\\n  if (b < a) {\\n    a = b;\\n    return 1;\\n  }\\n  return 0;\\n}\\nusing namespace std;\\nstring to_string(const string &s) { return '\\\"' + s + '\\\"'; }\\nstring to_string(const char *s) { return to_string((string)s); }\\ntemplate <typename A, typename B>\\nstring to_string(pair<A, B> p) {\\n  return \\\"(\\\" + to_string(p.first) + \\\", \\\" + to_string(p.second) + \\\")\\\";\\n}\\nvoid debug_out() { cerr << endl; }\\ntemplate <typename Head, typename... Tail>\\nvoid debug_out(Head H, Tail... T) {\\n  cerr << \\\" \\\" << to_string(H);\\n  debug_out(T...);\\n}\\nusing ll = long long;\\nusing LL = __int128;\\nusing pii = pair<int, int>;\\nusing vi = vector<int>;\\nusing db = double;\\nusing ldb = long double;\\nconst int maxn = 100000;\\nconst int mod = 998244353;\\nconst int inf = 0x3f3f3f3f;\\nint main() {\\n  int n;\\n  db p;\\n  scanf(\\\"%d%lf\\\", &n, &p);\\n  int P = p * 10000 + 0.5;\\n  auto binom = [](int n, int m) {\\n    if (m < 0 || n - m < 0) return 0ll;\\n    ll res = 1;\\n    for (auto i = 0; i <= m - 1; i++) res *= (n - i);\\n    for (auto i = 1; i <= m; i++) res \\/= i;\\n    return res;\\n  };\\n  auto check = [&](int x) {\\n    ll A = 0, B = binom(n, 3) * 2;\\n    A += binom(x, 3) * binom(n - x, 0) * 2;\\n    A += binom(x, 2) * binom(n - x, 1) * 2;\\n    A += binom(x, 1) * binom(n - x, 2);\\n    return A * 10000 >= B * P;\\n  };\\n  int l = 0, r = n + 1;\\n  while (l < r) {\\n    int mid = (l + r) >> 1;\\n    if (check(mid))\\n      r = mid;\\n    else\\n      l = mid + 1;\\n  }\\n  printf(\\\"%d\\\\n\\\", l);\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"On a circle lie 2n distinct points, with the following property: however you choose 3 chords that connect 3 disjoint pairs of points, no point strictly inside the circle belongs to all 3 chords. The points are numbered 1,   2,   ...,   2n in clockwise order.\\n\\nInitially, k chords connect k pairs of points, in such a way that all the 2k endpoints of these chords are distinct.\\n\\nYou want to draw n - k additional chords that connect the remaining 2(n - k) points (each point must be an endpoint of exactly one chord).\\n\\nIn the end, let x be the total number of intersections among all n chords. Compute the maximum value that x can attain if you choose the n - k chords optimally.\\n\\nNote that the exact position of the 2n points is not relevant, as long as the property stated in the first paragraph holds.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 100) \u2014 the number of test cases. Then t test cases follow.\\n\\nThe first line of each test case contains two integers n and k (1 \u2264 n \u2264 100, 0 \u2264 k \u2264 n) \u2014 half the number of points and the number of chords initially drawn.\\n\\nThen k lines follow. The i-th of them contains two integers x_i and y_i (1 \u2264 x_i,   y_i \u2264 2n, x_i \u2260 y_i) \u2014 the endpoints of the i-th chord. It is guaranteed that the 2k numbers x_1,   y_1,   x_2,   y_2,   ...,   x_k,   y_k are all distinct.\\n\\nOutput\\n\\nFor each test case, output the maximum number of intersections that can be obtained by drawing n - k additional chords.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n4 2\\n8 2\\n1 5\\n1 1\\n2 1\\n2 0\\n10 6\\n14 6\\n2 20\\n9 10\\n13 18\\n15 12\\n11 7\\n\\n\\nOutput\\n\\n\\n4\\n0\\n1\\n14\\n\\nNote\\n\\nIn the first test case, there are three ways to draw the 2 additional chords, shown below (black chords are the ones initially drawn, while red chords are the new ones):\\n\\n<image>\\n\\nWe see that the third way gives the maximum number of intersections, namely 4.\\n\\nIn the second test case, there are no more chords to draw. Of course, with only one chord present there are no intersections.\\n\\nIn the third test case, we can make at most one intersection by drawing chords 1-3 and 2-4, as...\\nUsing python3 can you solve the prior task?\",\"targets\":\"def check(x, y):\\n    return (y[0] < x[0] < y[1]) != (y[0] < x[1] < y[1])\\n\\nt = int(input())\\nfor _ in range(t):\\n    n, k = map(int, input().split())\\n    f = [False] * (n * 2 + 1)\\n    c = []\\n    for i in range(k):\\n        x, y = map(int, input().split())\\n        if x > y:\\n            x, y = y, x\\n        c.append((x, y))\\n        f[x] = True\\n        f[y] = True\\n    a = []\\n    for i in range(1, 2 * n + 1):\\n        if not f[i]:\\n            a.append(i)\\n    k = len(a) \\/\\/ 2\\n    for i in range(k):\\n        c.append((a[i], a[i + k]))\\n    res = 0\\n    for i in range(n):\\n        for j in range(i + 1, n):\\n            if check(c[i], c[j]):\\n                res += 1\\n    print(res)\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You are given an integer n. Find any string s of length n consisting only of English lowercase letters such that each non-empty substring of s occurs in s an odd number of times. If there are multiple such strings, output any. It can be shown that such string always exists under the given constraints.\\n\\nA string a is a substring of a string b if a can be obtained from b by deletion of several (possibly, zero or all) characters from the beginning and several (possibly, zero or all) characters from the end.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 500) \u2014 the number of test cases.\\n\\nThe first line of each test case contains a single integer n (1 \u2264 n \u2264 10^5).\\n\\nIt is guaranteed that the sum of n over all test cases doesn't exceed 3 \u22c5 10^5.\\n\\nOutput\\n\\nFor each test case, print a single line containing the string s. If there are multiple such strings, output any. It can be shown that such string always exists under the given constraints.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n3\\n5\\n9\\n19\\n\\n\\nOutput\\n\\n\\nabc\\ndiane\\nbbcaabbba\\nyouarethecutestuwuu\\n\\nNote\\n\\nIn the first test case, each substring of \\\"abc\\\" occurs exactly once.\\n\\nIn the third test case, each substring of \\\"bbcaabbba\\\" occurs an odd number of times. In particular, \\\"b\\\" occurs 5 times, \\\"a\\\" and \\\"bb\\\" occur 3 times each, and each of the remaining substrings occurs exactly once.\\nimpor\",\"targets\":\"t java.util.*;\\nimport java.io.*;\\n\\npublic class D {\\n\\tstatic StringBuilder sb;\\n\\tstatic dsu dsu;\\n\\tstatic long fact[];\\n\\tstatic int mod = (int) (1e9 + 7);\\n\\n\\tstatic void solve() {\\n\\t\\tint n = i();\\n\\t\\t\\n\\t\\tif(n <= 26){\\n\\t\\t    for(int i=0;i<n;i++){\\n\\t\\t        sb.append((char)('a'+i));\\n\\t\\t    }\\n\\t\\t    sb.append(\\\"\\\\n\\\");\\n\\t\\t    return;\\n\\t\\t}\\n\\t\\t\\n\\t\\tStringBuilder mid = new StringBuilder();\\n\\t\\tif(n%2 == 0){\\n\\t\\t    mid.append(\\\"b\\\");\\n\\t\\t}else{\\n\\t\\t    mid.append(\\\"bc\\\");\\n\\t\\t}\\n\\t\\t\\n\\t\\t\\n\\t\\tStringBuilder ans = new StringBuilder();\\n\\t\\tint ndash = n\\/2;\\n\\t\\t\\n\\t\\tfor(int i=0;i<ndash;i++){\\n\\t\\t    ans.append(\\\"a\\\");\\n\\t\\t}\\n\\t\\t\\n\\t\\tans.append(mid);\\n\\t\\t\\n\\t\\tfor(int i=0;i<ndash-1;i++){\\n\\t\\t    ans.append(\\\"a\\\");\\n\\t\\t}\\n\\t\\t\\n\\t\\tsb.append(ans);\\n\\t\\tsb.append(\\\"\\\\n\\\");\\n\\n\\t}\\n\\n\\tpublic static void main(String[] args) {\\n\\t\\tsb = new StringBuilder();\\n\\t\\tint test = i();\\n\\t\\twhile (test-- > 0) {\\n\\t\\t\\tsolve();\\n\\t\\t}\\n\\t\\tSystem.out.println(sb);\\n\\n\\t}\\n\\n\\t\\/*\\n\\t * fact=new long[(int)1e6+10]; fact[0]=fact[1]=1; for(int i=2;i<fact.length;i++)\\n\\t * { fact[i]=((long)(i%mod)1L(long)(fact[i-1]%mod))%mod; }\\n\\t *\\/\\n\\/\\/**************NCR%P******************\\t \\n\\tstatic long ncr(int n, int r) {\\n\\t\\tif (r > n)\\n\\t\\t\\treturn (long) 0;\\n\\n\\t\\tlong res = fact[n] % mod;\\n\\t\\t\\/\\/ System.out.println(res);\\n\\t\\tres = ((long) (res % mod) * (long) (p(fact[r], mod - 2) % mod)) % mod;\\n\\t\\tres = ((long) (res % mod) * (long) (p(fact[n - r], mod - 2) % mod)) % mod;\\n\\t\\t\\/\\/ System.out.println(res);\\n\\t\\treturn res;\\n\\n\\t}\\n\\n\\tstatic long p(long x, long y)\\/\\/ POWER FXN \\/\\/\\n\\t{\\n\\t\\tif (y == 0)\\n\\t\\t\\treturn 1;\\n\\n\\t\\tlong res = 1;\\n\\t\\twhile (y > 0) {\\n\\t\\t\\tif (y % 2 == 1) {\\n\\t\\t\\t\\tres = (res * x) % mod;\\n\\t\\t\\t\\ty--;\\n\\t\\t\\t}\\n\\n\\t\\t\\tx = (x * x) % mod;\\n\\t\\t\\ty = y \\/ 2;\\n\\n\\t\\t}\\n\\t\\treturn res;\\n\\t}\\n\\n\\/\\/**************END******************\\n\\n\\t\\/\\/ *************Disjoint set\\n\\t\\/\\/ union*********\\/\\/\\n\\tstatic class dsu {\\n\\t\\tint parent[];\\n\\n\\t\\tdsu(int n) {\\n\\t\\t\\tparent = new int[n];\\n\\t\\t\\tfor (int i = 0; i < n; i++)\\n\\t\\t\\t\\tparent[i] = -1;\\n\\t\\t}\\n\\n\\t\\tint find(int a) {\\n\\t\\t\\tif (parent[a] < 0)\\n\\t\\t\\t\\treturn a;\\n\\t\\t\\telse {\\n\\t\\t\\t\\tint x = find(parent[a]);\\n\\t\\t\\t\\tparent[a] = x;\\n\\t\\t\\t\\treturn x;\\n\\t\\t\\t}\\n\\t\\t}\\n\\n\\t\\tvoid merge(int a, int b) {\\n\\t\\t\\ta = find(a);\\n\\t\\t\\tb = find(b);\\n\\t\\t\\tif (a ==...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Artem is building a new robot. He has a matrix a consisting of n rows and m columns. The cell located on the i-th row from the top and the j-th column from the left has a value a_{i,j} written in it. \\n\\nIf two adjacent cells contain the same value, the robot will break. A matrix is called good if no two adjacent cells contain the same value, where two cells are called adjacent if they share a side. \\n\\nArtem wants to increment the values in some cells by one to make a good.\\n\\nMore formally, find a good matrix b that satisfies the following condition \u2014 \\n\\n  * For all valid (i,j), either b_{i,j} = a_{i,j} or b_{i,j} = a_{i,j}+1. \\n\\n\\n\\nFor the constraints of this problem, it can be shown that such a matrix b always exists. If there are several such tables, you can output any of them. Please note that you do not have to minimize the number of increments.\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 10). Description of the test cases follows.\\n\\nThe first line of each test case contains two integers n, m (1 \u2264 n \u2264 100, 1 \u2264 m \u2264 100) \u2014 the number of rows and columns, respectively.\\n\\nThe following n lines each contain m integers. The j-th integer in the i-th line is a_{i,j} (1 \u2264 a_{i,j} \u2264 10^9).\\n\\nOutput\\n\\nFor each case, output n lines each containing m integers. The j-th integer in the i-th line is b_{i,j}.\\n\\nExample\\n\\nInput\\n\\n\\n3\\n3 2\\n1 2\\n4 5\\n7 8\\n2 2\\n1 1\\n3 3\\n2 2\\n1 3\\n2 2\\n\\n\\nOutput\\n\\n\\n1 2\\n5 6\\n7 8\\n2 1\\n4 3\\n2 4\\n3 2\\n\\nNote\\n\\nIn all the cases, you can verify that no two adjacent cells have the same value and that b is the same as a with some values incremented by one.\",\"targets\":\"import java.io.*;\\nimport java.util.*;\\n\\n\\/*\\npolyakoff\\n*\\/\\n\\npublic class Main {\\n\\n    static FastReader in;\\n    static PrintWriter out;\\n    static Random rand = new Random();\\n    static final int oo = (int) 1e9 + 10;\\n    static final long OO = (long) 2e18 + 20;\\n    static final int MOD = (int) 1e9 + 7;\\n\\n    static void solve() {\\n        int n = in.nextInt();\\n        int m = in.nextInt();\\n\\n        int[][] a = new int[n][m];\\n        for (int i = 0; i < n; i++) {\\n            for (int j = 0; j < m; j++) {\\n                a[i][j] = in.nextInt();\\n                if ((i + j) % 2 == 1 && a[i][j] % 2 == 0)\\n                    a[i][j]++;\\n                else if ((i + j) % 2 == 0 && a[i][j] % 2 == 1)\\n                    a[i][j]++;\\n            }\\n        }\\n\\n        for (int i = 0; i < n; i++) {\\n            for (int j = 0; j < m; j++) {\\n                out.print(a[i][j] + \\\" \\\");\\n            }\\n            out.println();\\n        }\\n\\n\\n\\n\\n    }\\n\\n\\n    public static void main(String[] args) {\\n        in = new FastReader();\\n        out = new PrintWriter(System.out);\\n\\/\\/        fileInputOutput();\\n\\n        int T = 1;\\n        T = in.nextInt();\\n        while (T-- > 0)\\n            solve();\\n\\n        out.flush();\\n        out.close();\\n    }\\n\\n    static void fileInputOutput() {\\n        try {\\n            in = new FastReader(\\\"input.txt\\\");\\n            out = new PrintWriter(new FileOutputStream(\\\"output.txt\\\"));\\n        } catch (FileNotFoundException e) {\\n            throw new RuntimeException(e);\\n        }\\n    }\\n\\n    static void runInThread() {\\n        Thread thread = new Thread(null, () -> {\\n            int T = 1;\\n\\/\\/            T = in.nextInt();\\n            while (T-- > 0)\\n                solve();\\n        }, \\\"thread1\\\", 1 << 28);\\n        thread.start();\\n        try {\\n            thread.join();\\n        } catch (InterruptedException e) {\\n            throw new RuntimeException(e);\\n        }\\n    }\\n\\n    static class FastReader {\\n        BufferedReader br;\\n        StringTokenizer st;\\n\\n        FastReader() {\\n            this(System.in);\\n        }\\n       ...\",\"language\":\"python\",\"split\":\"train\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Shohag has an integer sequence a_1, a_2, \u2026, a_n. He can perform the following operation any number of times (possibly, zero):\\n\\n  * Select any positive integer k (it can be different in different operations). \\n  * Choose any position in the sequence (possibly the beginning or end of the sequence, or in between any two elements) and insert k into the sequence at this position. \\n  * This way, the sequence a changes, and the next operation is performed on this changed sequence. \\n\\n\\n\\nFor example, if a=[3,3,4] and he selects k = 2, then after the operation he can obtain one of the sequences [\\\\underline{2},3,3,4], [3,\\\\underline{2},3,4], [3,3,\\\\underline{2},4], or [3,3,4,\\\\underline{2}].\\n\\nShohag wants this sequence to satisfy the following condition: for each 1 \u2264 i \u2264 |a|, a_i \u2264 i. Here, |a| denotes the size of a.\\n\\nHelp him to find the minimum number of operations that he has to perform to achieve this goal. We can show that under the constraints of the problem it's always possible to achieve this goal in a finite number of operations.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 200) \u2014 the number of test cases.\\n\\nThe first line of each test case contains a single integer n (1 \u2264 n \u2264 100) \u2014 the initial length of the sequence.\\n\\nThe second line of each test case contains n integers a_1, a_2, \u2026, a_n (1 \u2264 a_i \u2264 10^9) \u2014 the elements of the sequence.\\n\\nOutput\\n\\nFor each test case, print a single integer \u2014 the minimum number of operations needed to perform to achieve the goal mentioned in the statement.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n3\\n1 3 4\\n5\\n1 2 5 7 4\\n1\\n1\\n3\\n69 6969 696969\\n\\n\\nOutput\\n\\n\\n1\\n3\\n0\\n696966\\n\\nNote\\n\\nIn the first test case, we have to perform at least one operation, as a_2=3>2. We can perform the operation [1, 3, 4] \u2192 [1, \\\\underline{2}, 3, 4] (the newly inserted element is underlined), now the condition is satisfied.\\n\\nIn the second test case, Shohag can perform the following operations:\\n\\n[1, 2, 5, 7, 4] \u2192 [1, 2, \\\\underline{3}, 5, 7, 4] \u2192 [1, 2, 3, \\\\underline{4}, 5, 7, 4] \u2192 [1, 2, 3, 4, 5, \\\\underline{3}, 7, 4].\\n\\nIn the third...\\nSolve the task in JAVA.\",\"targets\":\"import java.util.*;\\nimport java.io.*;\\nimport java.math.BigInteger;\\n\\n\\/\\/code by tishrah_\\npublic class _practise {\\n\\t\\n\\tstatic class FastReader\\n\\t{ \\n\\t\\t\\n\\t\\tBufferedReader br; \\n\\t\\tStringTokenizer st; \\n\\n\\t\\tpublic FastReader() \\n\\t\\t{ \\n\\t\\t\\tbr = new BufferedReader(new InputStreamReader(System.in)); \\n\\t\\t} \\n\\n\\t\\tString next() \\n\\t\\t{ \\n\\t\\t\\twhile (st == null || !st.hasMoreElements()) \\n\\t\\t\\t{ \\n\\t\\t\\t\\ttry\\n\\t\\t\\t\\t{ \\n\\t\\t\\t\\t\\tst = new StringTokenizer(br.readLine()); \\n\\t\\t\\t\\t} \\n\\t\\t\\t\\tcatch (IOException  e) \\n\\t\\t\\t\\t{ \\n\\t\\t\\t\\t\\te.printStackTrace(); \\n\\t\\t\\t\\t} \\n\\t\\t\\t} \\n\\t\\t\\treturn st.nextToken(); \\n\\t\\t} \\n\\n\\t\\tint nextInt() \\n\\t\\t{ \\n\\t\\t\\treturn Integer.parseInt(next()); \\n\\t\\t} \\n\\n\\t\\tlong nextLong() \\n\\t\\t{ \\n\\t\\t\\treturn Long.parseLong(next()); \\n\\t\\t} \\n\\n\\t\\tdouble nextDouble() \\n\\t\\t{ \\n\\t\\t\\treturn Double.parseDouble(next()); \\n\\t\\t} \\n\\n\\t\\t int[] ia(int n)\\n\\t\\t{\\n\\t\\t\\tint a[]=new int[n];\\n\\t\\t\\tfor(int i=0;i<n;i++)a[i]=nextInt();\\n\\t\\t\\treturn a;\\n\\t\\t}\\n\\t\\t int[][] ia(int n , int m)\\n\\t\\t\\t{\\n\\t\\t\\t\\tint a[][]=new int[n][m];\\n\\t\\t\\t\\tfor(int i=0;i<n;i++) for(int j=0;j<m ;j++) a[i][j]=nextInt();\\n\\t\\t\\t\\treturn a;\\n\\t\\t\\t}\\n\\t\\t long[][] la(int n , int m)\\n\\t\\t\\t{\\n\\t\\t\\t\\tlong a[][]=new long[n][m];\\n\\t\\t\\t\\tfor(int i=0;i<n;i++) for(int j=0;j<m ;j++) a[i][j]=nextLong();\\n\\t\\t\\t\\treturn a;\\n\\t\\t\\t}\\n\\t\\t char[][] ca(int n , int m)\\n\\t\\t\\t{\\n\\t\\t\\t\\tchar a[][]=new char[n][m];\\n\\t\\t\\t\\tfor(int i=0;i<n;i++)\\n\\t\\t\\t\\t\\t{\\n\\t\\t\\t\\t\\tString x =next();\\n\\t\\t\\t\\t\\tfor(int j=0;j<m ;j++) a[i][j]=x.charAt(j);\\n\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\treturn a;\\n\\t\\t\\t}\\n\\n\\t\\tlong[] la(int n)\\n\\t\\t{\\n\\t\\t\\tlong a[]=new long[n];\\n\\t\\t\\tfor(int i=0;i<n;i++)a[i]=nextLong();\\n\\t\\t\\treturn a;\\n\\t\\t}\\n\\n\\t\\tString nextLine() \\n\\t\\t{ \\n\\t\\t\\tString str = \\\"\\\"; \\n\\t\\t\\ttry\\n\\t\\t\\t{ \\n\\t\\t\\t\\tstr = br.readLine(); \\n\\t\\t\\t} \\n\\t\\t\\tcatch (IOException e) \\n\\t\\t\\t{ \\n\\t\\t\\t\\te.printStackTrace(); \\n\\t\\t\\t} \\n\\t\\t\\treturn str; \\n\\t\\t} \\n\\t}\\n\\tstatic void sort(long[] a) \\n\\t{int n=a.length;Random r=new Random();for (int i=0; i<a.length; i++) {long oi=r.nextInt(n), temp=a[i];a[i]=a[(int)oi];a[(int)oi]=temp;}Arrays.sort(a);}\\n    static void sort(int[] a) \\n    {int n=a.length;Random r=new Random();for (int i=0; i<a.length; i++) {int oi=r.nextInt(n), temp=a[i];a[i]=a[oi];a[oi]=temp;}Arrays.sort(a);}\\n\\tpublic static long sum(long a[])\\n\\t{long sum=0; for(long...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Theofanis has a riddle for you and if you manage to solve it, he will give you a Cypriot snack halloumi for free (Cypriot cheese).\\n\\nYou are given an integer n. You need to find two integers l and r such that -10^{18} \u2264 l < r \u2264 10^{18} and l + (l + 1) + \u2026 + (r - 1) + r = n.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases.\\n\\nThe first and only line of each test case contains a single integer n (1 \u2264 n \u2264 10^{18}).\\n\\nOutput\\n\\nFor each test case, print the two integers l and r such that -10^{18} \u2264 l < r \u2264 10^{18} and l + (l + 1) + \u2026 + (r - 1) + r = n. \\n\\nIt can be proven that an answer always exists. If there are multiple answers, print any.\\n\\nExample\\n\\nInput\\n\\n\\n7\\n1\\n2\\n3\\n6\\n100\\n25\\n3000000000000\\n\\n\\nOutput\\n\\n\\n0 1\\n-1 2 \\n1 2 \\n1 3 \\n18 22\\n-2 7\\n999999999999 1000000000001\\n\\nNote\\n\\nIn the first test case, 0 + 1 = 1.\\n\\nIn the second test case, (-1) + 0 + 1 + 2 = 2.\\n\\nIn the fourth test case, 1 + 2 + 3 = 6.\\n\\nIn the fifth test case, 18 + 19 + 20 + 21 + 22 = 100.\\n\\nIn the sixth test case, (-2) + (-1) + 0 + 1 + 2 + 3 + 4 + 5 + 6 + 7 = 25.\\nThe above is tricky. Write me a correct solution in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint mod = 1000000000 + 7;\\nvoid solve() {\\n  long long n;\\n  cin >> n;\\n  cout << -(n - 1) << \\\" \\\" << n << \\\"\\\\n\\\";\\n}\\nint main() {\\n  ios_base::sync_with_stdio(false);\\n  cin.tie(NULL);\\n  cout.tie(NULL);\\n  int t = 1;\\n  cin >> t;\\n  while (t--) {\\n    solve();\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in CPP?\\nGregor is learning about RSA cryptography, and although he doesn't understand how RSA works, he is now fascinated with prime numbers and factoring them.\\n\\nGregor's favorite prime number is P. Gregor wants to find two bases of P. Formally, Gregor is looking for two integers a and b which satisfy both of the following properties.\\n\\n  * P mod a = P mod b, where x mod y denotes the remainder when x is divided by y, and \\n  * 2 \u2264 a < b \u2264 P. \\n\\n\\n\\nHelp Gregor find two bases of his favorite prime number!\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 1000).\\n\\nEach subsequent line contains the integer P (5 \u2264 P \u2264 {10}^9), with P guaranteed to be prime.\\n\\nOutput\\n\\nYour output should consist of t lines. Each line should consist of two integers a and b (2 \u2264 a < b \u2264 P). If there are multiple possible solutions, print any.\\n\\nExample\\n\\nInput\\n\\n\\n2\\n17\\n5\\n\\n\\nOutput\\n\\n\\n3 5\\n2 4\\n\\nNote\\n\\nThe first query is P=17. a=3 and b=5 are valid bases in this case, because 17 mod 3 = 17 mod 5 = 2. There are other pairs which work as well.\\n\\nIn the second query, with P=5, the only solution is a=2 and b=4.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint solve(int i, int j, string s, string s1, vector<vector<int> > &cal) {\\n  if (i >= s.size() || j >= s1.size()) return 0;\\n  if (cal[i][j] != -1) return cal[i][j];\\n  cal[i][j] = 0;\\n  if (s[i] == s1[j]) {\\n    cal[i][j] = 1 + solve(i + 1, j + 1, s, s1, cal);\\n  }\\n  cal[i][j] = max(\\n      cal[i][j], max(solve(i, j + 1, s, s1, cal), solve(i + 1, j, s, s1, cal)));\\n  return cal[i][j];\\n}\\nint main() {\\n  int t;\\n  cin >> t;\\n  while (t--) {\\n    long long int n;\\n    cin >> n;\\n    if (n % 2 != 0) {\\n      cout << (n - 1) \\/ 2 << \\\" \\\" << (n - 1) << endl;\\n    } else\\n      cout << 2 << \\\" \\\" << n \\/ 2 << endl;\\n  }\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Mocha is a young girl from high school. She has learned so much interesting knowledge from her teachers, especially her math teacher. Recently, Mocha is learning about binary system and very interested in bitwise operation.\\n\\nThis day, Mocha got a sequence a of length n. In each operation, she can select an arbitrary interval [l, r] and for all values i (0\u2264 i \u2264 r-l), replace a_{l+i} with a_{l+i}  \\\\&  a_{r-i} at the same time, where \\\\& denotes the [bitwise AND operation](https:\\/\\/en.wikipedia.org\\/wiki\\/Bitwise_operation#AND). This operation can be performed any number of times.\\n\\nFor example, if n=5, the array is [a_1,a_2,a_3,a_4,a_5], and Mocha selects the interval [2,5], then the new array is [a_1,a_2 \\\\&  a_5, a_3 \\\\&  a_4, a_4 \\\\&  a_3, a_5 \\\\&  a_2].\\n\\nNow Mocha wants to minimize the maximum value in the sequence. As her best friend, can you help her to get the answer?\\n\\nInput\\n\\nEach test contains multiple test cases. \\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 100) \u2014 the number of test cases. Each test case consists of two lines.\\n\\nThe first line of each test case contains a single integer n (1 \u2264 n \u2264 100) \u2014 the length of the sequence.\\n\\nThe second line of each test case contains n integers a_1, a_2, \u2026, a_n (0 \u2264 a_i \u2264 10^9).\\n\\nOutput\\n\\nFor each test case, print one integer \u2014 the minimal value of the maximum value in the sequence.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n2\\n1 2\\n3\\n1 1 3\\n4\\n3 11 3 7\\n5\\n11 7 15 3 7\\n\\n\\nOutput\\n\\n\\n0\\n1\\n3\\n3\\n\\nNote\\n\\nIn the first test case, Mocha can choose the interval [1,2], then the sequence becomes [ 0, 0], where the first element is 1 \\\\& 2, and the second element is 2 \\\\& 1.\\n\\nIn the second test case, Mocha can choose the interval [1,3], then the sequence becomes [ 1,1,1], where the first element is 1 \\\\& 3, the second element is 1 \\\\& 1, and the third element is 3 \\\\& 1.\\nSolve the task in PYTHON3.\",\"targets\":\"for t in range(int(input())):\\n    n = int(input())\\n    l = list(map(int, input().split()))\\n    ans = l[0]\\n    for i in l[1:]:\\n        ans &=i\\n    print(ans)\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"PizzaForces is Petya's favorite pizzeria. PizzaForces makes and sells pizzas of three sizes: small pizzas consist of 6 slices, medium ones consist of 8 slices, and large pizzas consist of 10 slices each. Baking them takes 15, 20 and 25 minutes, respectively.\\n\\nPetya's birthday is today, and n of his friends will come, so he decided to make an order from his favorite pizzeria. Petya wants to order so much pizza that each of his friends gets at least one slice of pizza. The cooking time of the order is the total baking time of all the pizzas in the order.\\n\\nYour task is to determine the minimum number of minutes that is needed to make pizzas containing at least n slices in total. For example: \\n\\n  * if 12 friends come to Petya's birthday, he has to order pizzas containing at least 12 slices in total. He can order two small pizzas, containing exactly 12 slices, and the time to bake them is 30 minutes; \\n  * if 15 friends come to Petya's birthday, he has to order pizzas containing at least 15 slices in total. He can order a small pizza and a large pizza, containing 16 slices, and the time to bake them is 40 minutes; \\n  * if 300 friends come to Petya's birthday, he has to order pizzas containing at least 300 slices in total. He can order 15 small pizzas, 10 medium pizzas and 13 large pizzas, in total they contain 15 \u22c5 6 + 10 \u22c5 8 + 13 \u22c5 10 = 300 slices, and the total time to bake them is 15 \u22c5 15 + 10 \u22c5 20 + 13 \u22c5 25 = 750 minutes; \\n  * if only one friend comes to Petya's birthday, he can order a small pizza, and the time to bake it is 15 minutes. \\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 10^4) \u2014 the number of testcases.\\n\\nEach testcase consists of a single line that contains a single integer n (1 \u2264 n \u2264 10^{16}) \u2014 the number of Petya's friends.\\n\\nOutput\\n\\nFor each testcase, print one integer \u2014 the minimum number of minutes that is needed to bake pizzas containing at least n slices in total.\\n\\nExample\\n\\nInput\\n\\n\\n6\\n12\\n15\\n300\\n1\\n9999999999999999\\n3\\n\\n\\nOutput\\n\\n\\n30\\n40\\n750\\n15\\n25000000000000000\\n15\\nUsing python can you solve the prior task?\",\"targets\":\"from sys import stdin\\nraw_input = lambda: stdin.readline().rstrip()\\ninput = lambda: int(raw_input())\\nI=lambda: map(int, raw_input().split())\\n\\ndef ceilDiv(x, d):\\n\\tr, q = divmod(x, d)\\n\\treturn r + (1 if q else 0)\\n\\nt = input()\\nfor _ in xrange(t):\\n\\tn = input()\\n\\tif n <= 6:\\n\\t\\tprint 15\\n\\t\\tcontinue\\n\\tr = ceilDiv(n, 2)*5\\n\\tprint r\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in CPP?\\nOn the great island of Baltia, there live N people, numbered from 1 to N. There are exactly M pairs of people that are friends with each other. The people of Baltia want to organize a successful party, but they have very strict rules on what a party is and when the party is successful. On the island of Baltia, a party is a gathering of exactly 5 people. The party is considered to be successful if either all the people at the party are friends with each other (so that they can all talk to each other without having to worry about talking to someone they are not friends with) or no two people at the party are friends with each other (so that everyone can just be on their phones without anyone else bothering them). Please help the people of Baltia organize a successful party or tell them that it's impossible to do so.\\n\\nInput\\n\\nThe first line contains two integer numbers, N (5 \u2264 N \u2264 2*10^5) and M (0 \u2264 M \u2264 2*10^5) \u2013 the number of people that live in Baltia, and the number of friendships. The next M lines each contains two integers U_i and V_i (1 \u2264 U_i,V_i \u2264 N) \u2013 meaning that person U_i is friends with person V_i. Two friends can not be in the list of friends twice (no pairs are repeated) and a person can be friends with themselves (U_i \u2260 V_i).\\n\\nOutput\\n\\nIf it's possible to organize a successful party, print 5 numbers indicating which 5 people should be invited to the party. If it's not possible to organize a successful party, print -1 instead. If there are multiple successful parties possible, print any.\\n\\nExamples\\n\\nInput\\n\\n\\n6 3\\n1 4\\n4 2\\n5 4\\n\\n\\nOutput\\n\\n\\n1 2 3 5 6\\n\\n\\nInput\\n\\n\\n5 4\\n1 2\\n2 3\\n3 4\\n4 5\\n\\n\\nOutput\\n\\n\\n-1\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nbool ok[51][51];\\nsigned main() {\\n  long long n, m;\\n  cin >> n >> m;\\n  n = min(n, 50ll);\\n  for (long long i = 0; i < m; i++) {\\n    long long u, v;\\n    cin >> u >> v;\\n    if (u <= n && v <= n) {\\n      ok[u][v] = 1;\\n      ok[v][u] = 1;\\n    }\\n  }\\n  for (long long i = 1; i <= n; i++) {\\n    for (long long j = i + 1; j <= n; j++) {\\n      for (long long k = j + 1; k <= n; k++) {\\n        for (long long l = k + 1; l <= n; l++) {\\n          for (long long o = l + 1; o <= n; o++) {\\n            vector<long long> v = {i, j, k, l, o};\\n            bool can = 1;\\n            for (long long p = 0; p < 5; p++) {\\n              for (long long q = p + 1; q < 5; q++) {\\n                if (ok[v[p]][v[q]] != ok[v[0]][v[1]]) can = 0;\\n              }\\n            }\\n            if (can) {\\n              cout << i << ' ' << j << ' ' << k << ' ' << l << ' ' << o << '\\\\n';\\n              return 0;\\n            }\\n          }\\n        }\\n      }\\n    }\\n  }\\n  cout << \\\"-1\\\\n\\\";\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Mr. Chanek lives in a city represented as a plane. He wants to build an amusement park in the shape of a circle of radius r. The circle must touch the origin (point (0, 0)).\\n\\nThere are n bird habitats that can be a photo spot for the tourists in the park. The i-th bird habitat is at point p_i = (x_i, y_i). \\n\\nFind the minimum radius r of a park with at least k bird habitats inside. \\n\\nA point is considered to be inside the park if and only if the distance between p_i and the center of the park is less than or equal to the radius of the park. Note that the center and the radius of the park do not need to be integers.\\n\\nIn this problem, it is guaranteed that the given input always has a solution with r \u2264 2 \u22c5 10^5.\\n\\nInput\\n\\nThe first line contains two integers n and k (1 \u2264 n \u2264 10^5, 1 \u2264 k \u2264 n) \u2014 the number of bird habitats in the city and the number of bird habitats required to be inside the park.\\n\\nThe i-th of the next n lines contains two integers x_i and y_i (0 \u2264 |x_i|, |y_i| \u2264 10^5) \u2014 the position of the i-th bird habitat.\\n\\nOutput\\n\\nOutput a single real number r denoting the minimum radius of a park with at least k bird habitats inside. It is guaranteed that the given input always has a solution with r \u2264 2 \u22c5 10^5.\\n\\nYour answer is considered correct if its absolute or relative error does not exceed 10^{-4}.\\n\\nFormally, let your answer be a, and the jury's answer be b. Your answer is accepted if and only if \\\\frac{|a - b|}{max{(1, |b|)}} \u2264 10^{-4}.\\n\\nExamples\\n\\nInput\\n\\n\\n8 4\\n-3 1\\n-4 4\\n1 5\\n2 2\\n2 -2\\n-2 -4\\n-1 -1\\n-6 0\\n\\n\\nOutput\\n\\n\\n3.1622776589\\n\\n\\nInput\\n\\n\\n1 1\\n0 0\\n\\n\\nOutput\\n\\n\\n0.0000000000\\n\\nNote\\n\\nIn the first example, Mr. Chanek can put the center of the park at (-3, -1) with radius \u221a{10} \u2248 3.162. It can be proven this is the minimum r.\\n\\nThe following illustrates the first example. The blue points represent bird habitats and the red circle represents the amusement park.\\n\\n<image>\\nUsing cpp can you solve the prior task?\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nusing ll = long long;\\nusing ld = long double;\\nusing pii = pair<int, int>;\\nusing cd = complex<ld>;\\nstruct pt {\\n  ld x, y;\\n  pt(ld x, ld y) : x(x), y(y) {}\\n  pt() = default;\\n  ld dist2() { return x * x + y * y; }\\n};\\nstruct line {\\n  ld a, b, c;\\n  line(const pt &p, const pt &q) {\\n    a = q.y - p.y;\\n    b = p.x - q.x;\\n    c = -(a * p.x + b * p.y);\\n  }\\n  line(ld a, ld b, ld c) : a(a), b(b), c(c) {}\\n  line perp(const pt &p) { return line(-b, a, -(-b * p.x + a * p.y)); }\\n};\\nconst ld EPS = 1e-8;\\nvector<pt> intersect(ld r, const line &l) {\\n  ld a = l.a;\\n  ld b = l.b;\\n  ld c = l.c;\\n  ld x0 = -a * c \\/ (a * a + b * b), y0 = -b * c \\/ (a * a + b * b);\\n  if (c * c > r * r * (a * a + b * b) + EPS)\\n    return {};\\n  else if (abs(c * c - r * r * (a * a + b * b)) < EPS) {\\n    return {pt(x0, y0)};\\n  } else {\\n    ld d = r * r - c * c \\/ (a * a + b * b);\\n    ld mult = sqrt(d \\/ (a * a + b * b));\\n    ld ax, ay, bx, by;\\n    ax = x0 + b * mult;\\n    bx = x0 - b * mult;\\n    ay = y0 - a * mult;\\n    by = y0 + a * mult;\\n    return {pt(ax, ay), pt(bx, by)};\\n  }\\n}\\nld ang(const pt &p) { return atan2(p.y, p.x); }\\nconst ld PI = acos(-1);\\nconst bool DEBUG = false;\\nvoid print_crl(const pt &p, ld r) {\\n  if (DEBUG) {\\n    cout << \\\"(x-\\\" << p.x << \\\")^2+(y-\\\" << p.y << \\\")^2=\\\" << r << \\\"^2\\\" << endl;\\n  }\\n}\\nbool ok(ld r, const vector<pt> &pts, const vector<line> &lines, int k) {\\n  map<ld, int> evs;\\n  ld r2 = r * r * 4;\\n  int cnt = 0;\\n  for (int i = 0; i < (int)lines.size(); i++) {\\n    auto p = pts[i];\\n    if (p.dist2() > r2) {\\n      if (DEBUG) {\\n        cout << \\\"Skip (\\\" << p.x << \\\", \\\" << p.y << \\\")\\\" << endl;\\n      }\\n      continue;\\n    }\\n    if (p.dist2() < EPS) {\\n      cnt += 1;\\n      continue;\\n    }\\n    vector<pt> inter = intersect(r, lines[i]);\\n    if (DEBUG) {\\n      cout << \\\"For (\\\" << p.x << \\\", \\\" << p.y << \\\")\\\" << endl;\\n    }\\n    if (inter.size() == 1) {\\n      ld ang1 = ang(inter[0]);\\n      evs[ang1 - EPS] += 1;\\n      evs[ang1 + EPS] -= 1;\\n      print_crl(inter[0], r);\\n    } else if (inter.size() == 2) {\\n      ld...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Polycarp must pay exactly n burles at the checkout. He has coins of two nominal values: 1 burle and 2 burles. Polycarp likes both kinds of coins equally. So he doesn't want to pay with more coins of one type than with the other.\\n\\nThus, Polycarp wants to minimize the difference between the count of coins of 1 burle and 2 burles being used. Help him by determining two non-negative integer values c_1 and c_2 which are the number of coins of 1 burle and 2 burles, respectively, so that the total value of that number of coins is exactly n (i. e. c_1 + 2 \u22c5 c_2 = n), and the absolute value of the difference between c_1 and c_2 is as little as possible (i. e. you must minimize |c_1-c_2|).\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases. Then t test cases follow.\\n\\nEach test case consists of one line. This line contains one integer n (1 \u2264 n \u2264 10^9) \u2014 the number of burles to be paid by Polycarp.\\n\\nOutput\\n\\nFor each test case, output a separate line containing two integers c_1 and c_2 (c_1, c_2 \u2265 0) separated by a space where c_1 is the number of coins of 1 burle and c_2 is the number of coins of 2 burles. If there are multiple optimal solutions, print any one.\\n\\nExample\\n\\nInput\\n\\n\\n6\\n1000\\n30\\n1\\n32\\n1000000000\\n5\\n\\n\\nOutput\\n\\n\\n334 333\\n10 10\\n1 0\\n10 11\\n333333334 333333333\\n1 2\\n\\nNote\\n\\nThe answer for the first test case is \\\"334 333\\\". The sum of the nominal values of all coins is 334 \u22c5 1 + 333 \u22c5 2 = 1000, whereas |334 - 333| = 1. One can't get the better value because if |c_1 - c_2| = 0, then c_1 = c_2 and c_1 \u22c5 1 + c_1 \u22c5 2 = 1000, but then the value of c_1 isn't an integer.\\n\\nThe answer for the second test case is \\\"10 10\\\". The sum of the nominal values is 10 \u22c5 1 + 10 \u22c5 2 = 30 and |10 - 10| = 0, whereas there's no number having an absolute value less than 0.\\nSolve the task in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nsigned main() {\\n  ios_base::sync_with_stdio(false);\\n  cin.tie(NULL);\\n  cout.tie(NULL);\\n  long long t;\\n  cin >> t;\\n  while (t--) {\\n    long long n;\\n    cin >> n;\\n    long long ceilVal = 1 + ((n - 1) \\/ 3);\\n    long long floatt = n \\/ 3;\\n    if (floatt + 2 * ceilVal == n) {\\n      cout << floatt << \\\" \\\" << ceilVal % 1000000007 << endl;\\n    } else {\\n      cout << ceilVal % 1000000007 << \\\" \\\" << floatt << endl;\\n    }\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"It is a simplified version of problem F2. The difference between them is the constraints (F1: k \u2264 2, F2: k \u2264 10).\\n\\nYou are given an integer n. Find the minimum integer x such that x \u2265 n and the number x is k-beautiful.\\n\\nA number is called k-beautiful if its decimal representation having no leading zeroes contains no more than k different digits. E.g. if k = 2, the numbers 3434443, 55550, 777 and 21 are k-beautiful whereas the numbers 120, 445435 and 998244353 are not.\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases. Then t test cases follow.\\n\\nEach test case consists of one line containing two integers n and k (1 \u2264 n \u2264 10^9, 1 \u2264 k \u2264 2).\\n\\nOutput\\n\\nFor each test case output on a separate line x \u2014 the minimum k-beautiful integer such that x \u2265 n.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n1 1\\n221 2\\n177890 2\\n998244353 1\\n\\n\\nOutput\\n\\n\\n1\\n221\\n181111\\n999999999\\nSolve the task in PYTHON3.\",\"targets\":\"import collections\\nimport bisect\\nfrom itertools import combinations\\n\\nt = int(input())\\n\\nall_cur = set()\\nfor x in combinations(['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'], 2):\\n    for l in range(1, 10):\\n        cur = list(range(l))\\n        for i in range(l+1):\\n            for y in combinations(cur, i):\\n                cur_res = ''\\n                for j in range(l):\\n                    if j in y:\\n                        cur_res += x[0]\\n                    else:\\n                        cur_res += x[1]\\n                if cur_res[0] == '0' and cur_res != '0':\\n                    continue\\n                all_cur.add(int(cur_res))\\n\\nall_cur = list(all_cur)\\nall_cur.sort()\\n# print(len(all_cur))\\n# print(all_cur)\\n\\nfor case in range(t):\\n    n, k = list(map(int, input().split()))\\n    if n == 1000000000:\\n        if k == 2:\\n            print(1000000000)\\n        else:\\n            print(1111111111)\\n        continue\\n    if k == 1:\\n        cur = []\\n        for i in range(0, 10):\\n            cur.append(str(i) * len(str(n)))\\n        res = float('inf')\\n        for x in cur:\\n            if len(str(int(x))) != len(x):\\n                continue\\n            if int(x) >= n:\\n                res = min(res, int(x))\\n        print(res)\\n    else:\\n        index = bisect.bisect_left(all_cur, n)\\n        # print(index, all_cur[index], n)\\n        print(all_cur[index])\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in PYTHON3?\\nYou have a permutation: an array a = [a_1, a_2, \u2026, a_n] of distinct integers from 1 to n. The length of the permutation n is odd.\\n\\nConsider the following algorithm of sorting the permutation in increasing order.\\n\\nA helper procedure of the algorithm, f(i), takes a single argument i (1 \u2264 i \u2264 n-1) and does the following. If a_i > a_{i+1}, the values of a_i and a_{i+1} are exchanged. Otherwise, the permutation doesn't change.\\n\\nThe algorithm consists of iterations, numbered with consecutive integers starting with 1. On the i-th iteration, the algorithm does the following: \\n\\n  * if i is odd, call f(1), f(3), \u2026, f(n - 2); \\n  * if i is even, call f(2), f(4), \u2026, f(n - 1). \\n\\n\\n\\nIt can be proven that after a finite number of iterations the permutation will be sorted in increasing order.\\n\\nAfter how many iterations will this happen for the first time?\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 100). Description of the test cases follows.\\n\\nThe first line of each test case contains a single integer n (3 \u2264 n \u2264 999; n is odd) \u2014 the length of the permutation.\\n\\nThe second line contains n distinct integers a_1, a_2, \u2026, a_n (1 \u2264 a_i \u2264 n) \u2014 the permutation itself. \\n\\nIt is guaranteed that the sum of n over all test cases does not exceed 999.\\n\\nOutput\\n\\nFor each test case print the number of iterations after which the permutation will become sorted in increasing order for the first time.\\n\\nIf the given permutation is already sorted, print 0.\\n\\nExample\\n\\nInput\\n\\n\\n3\\n3\\n3 2 1\\n7\\n4 5 7 1 3 2 6\\n5\\n1 2 3 4 5\\n\\n\\nOutput\\n\\n\\n3\\n5\\n0\\n\\nNote\\n\\nIn the first test case, the permutation will be changing as follows: \\n\\n  * after the 1-st iteration: [2, 3, 1]; \\n  * after the 2-nd iteration: [2, 1, 3]; \\n  * after the 3-rd iteration: [1, 2, 3]. \\n\\n\\n\\nIn the second test case, the permutation will be changing as follows: \\n\\n  * after the 1-st iteration: [4, 5, 1, 7, 2, 3, 6]; \\n  * after the 2-nd iteration: [4, 1, 5, 2, 7, 3, 6]; \\n  * after the 3-rd iteration: [1, 4, 2, 5, 3, 7, 6]; \\n  * after the 4-th...\",\"targets\":\"def main():\\n    test = int(input())\\n\\n    for _ in range(test):\\n        n = int(input())\\n        a = list(map(int, input().split()))\\n        tar = [i for i in range(1, n + 1)]\\n        ans = 0\\n        if a == tar:\\n            print(ans)\\n            continue\\n            \\n        i = 0\\n        # for i in range(100):\\n        while True:\\n            st = 0 if i % 2 == 0 else 1\\n            for j in range(n):\\n                if j % 2 == st and j + 1 < n and a[j] > a[j + 1]:\\n                    a[j], a[j + 1] = a[j + 1], a[j]\\n            ans += 1\\n            if a == tar:\\n                print(ans)\\n                break\\n            i += 1\\n    return\\n\\n\\n\\nmain()\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in CPP?\\nYou are given two positive integers n and s. Find the maximum possible median of an array of n non-negative integers (not necessarily distinct), such that the sum of its elements is equal to s.\\n\\nA median of an array of integers of length m is the number standing on the \u2308 {m\\/2} \u2309-th (rounding up) position in the non-decreasing ordering of its elements. Positions are numbered starting from 1. For example, a median of the array [20,40,20,50,50,30] is the \u2308 m\\/2 \u2309-th element of [20,20,30,40,50,50], so it is 30. There exist other definitions of the median, but in this problem we use the described definition.\\n\\nInput\\n\\nThe input consists of multiple test cases. The first line contains a single integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases. Description of the test cases follows.\\n\\nEach test case contains a single line with two integers n and s (1 \u2264 n, s \u2264 10^9) \u2014 the length of the array and the required sum of the elements.\\n\\nOutput\\n\\nFor each test case print a single integer \u2014 the maximum possible median.\\n\\nExample\\n\\nInput\\n\\n\\n8\\n1 5\\n2 5\\n3 5\\n2 1\\n7 17\\n4 14\\n1 1000000000\\n1000000000 1\\n\\n\\nOutput\\n\\n\\n5\\n2\\n2\\n0\\n4\\n4\\n1000000000\\n0\\n\\nNote\\n\\nPossible arrays for the first three test cases (in each array the median is underlined):\\n\\n  * In the first test case [\\\\underline{5}] \\n  * In the second test case [\\\\underline{2}, 3] \\n  * In the third test case [1, \\\\underline{2}, 2]\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint main() {\\n  int t;\\n  cin >> t;\\n  while (t--) {\\n    long long n, s;\\n    cin >> n >> s;\\n    double n1 = n;\\n    long long i = ceil(n1 \\/ 2);\\n    cout << s \\/ (n - i + 1) << \\\"\\\\n\\\";\\n  }\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Polycarp has come up with a new game to play with you. He calls it \\\"A missing bigram\\\".\\n\\nA bigram of a word is a sequence of two adjacent letters in it.\\n\\nFor example, word \\\"abbaaba\\\" contains bigrams \\\"ab\\\", \\\"bb\\\", \\\"ba\\\", \\\"aa\\\", \\\"ab\\\" and \\\"ba\\\".\\n\\nThe game goes as follows. First, Polycarp comes up with a word, consisting only of lowercase letters 'a' and 'b'. Then, he writes down all its bigrams on a whiteboard in the same order as they appear in the word. After that, he wipes one of them off the whiteboard.\\n\\nFinally, Polycarp invites you to guess what the word that he has come up with was.\\n\\nYour goal is to find any word such that it's possible to write down all its bigrams and remove one of them, so that the resulting sequence of bigrams is the same as the one Polycarp ended up with.\\n\\nThe tests are generated in such a way that the answer exists. If there are multiple answers, you can print any of them.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 2000) \u2014 the number of testcases.\\n\\nThe first line of each testcase contains a single integer n (3 \u2264 n \u2264 100) \u2014 the length of the word Polycarp has come up with.\\n\\nThe second line of each testcase contains n-2 bigrams of that word, separated by a single space. Each bigram consists of two letters, each of them is either 'a' or 'b'.\\n\\nAdditional constraint on the input: there exists at least one string such that it is possible to write down all its bigrams, except one, so that the resulting sequence is the same as the sequence in the input. In other words, the answer exists.\\n\\nOutput\\n\\nFor each testcase print a word, consisting of n letters, each of them should be either 'a' or 'b'. It should be possible to write down all its bigrams and remove one of them, so that the resulting sequence of bigrams is the same as the one Polycarp ended up with.\\n\\nThe tests are generated in such a way that the answer exists. If there are multiple answers, you can print any of them. \\n\\nExample\\n\\nInput\\n\\n\\n4\\n7\\nab bb ba aa ba\\n7\\nab ba aa ab ba\\n3\\naa\\n5\\nbb ab...\\nThe above is tricky. Write me a correct solution in JAVA.\",\"targets\":\"import java.util.ArrayList;\\nimport java.util.Scanner;\\n\\npublic class checher {\\n    public static void main(String[] args) {\\n        Scanner scan = new Scanner(System.in);\\n        int t = scan.nextInt();\\n\\n        while (t-- > 0) {\\n            int n = scan.nextInt();\\n            ArrayList<Character> res = new ArrayList<>();\\n            n = n - 2;\\n            int x=0;\\n            while (n-- > 0) {\\n                String str = scan.next();\\n                if(res.isEmpty()){\\n                    res.add(str.charAt(0));\\n                    res.add(str.charAt(1));\\n                }\\n                    else{\\n                    if(res.get(res.size()-1)==str.charAt(0)){\\n                        res.add(str.charAt(1));\\n                    }else{\\n                        x++;\\n                        res.add(str.charAt(0));\\n                        res.add(str.charAt(1));\\n                    }\\n\\n                }\\n\\n            }\\n            if(res.size()==2){\\n                String otvet=\\\"\\\";\\n                for(char e:res){\\n                    otvet+=e;\\n                }\\n                otvet+=res.get(1);\\n                System.out.println(otvet);\\n            }else{\\n            String otvet=\\\"\\\";\\n            for(char e:res){\\n                otvet+=e;\\n            }\\n            if(x==0){\\n                otvet+=res.get(res.size()-1);\\n            }\\n            System.out.println(otvet);\\n        }\\n        }\\n    }\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"A burglar got into a matches warehouse and wants to steal as many matches as possible. In the warehouse there are m containers, in the i-th container there are ai matchboxes, and each matchbox contains bi matches. All the matchboxes are of the same size. The burglar's rucksack can hold n matchboxes exactly. Your task is to find out the maximum amount of matches that a burglar can carry away. He has no time to rearrange matches in the matchboxes, that's why he just chooses not more than n matchboxes so that the total amount of matches in them is maximal.\\n\\nInput\\n\\nThe first line of the input contains integer n (1 \u2264 n \u2264 2\u00b7108) and integer m (1 \u2264 m \u2264 20). The i + 1-th line contains a pair of numbers ai and bi (1 \u2264 ai \u2264 108, 1 \u2264 bi \u2264 10). All the input numbers are integer.\\n\\nOutput\\n\\nOutput the only number \u2014 answer to the problem.\\n\\nExamples\\n\\nInput\\n\\n7 3\\n5 10\\n2 5\\n3 6\\n\\n\\nOutput\\n\\n62\\n\\n\\nInput\\n\\n3 3\\n1 3\\n2 2\\n3 1\\n\\n\\nOutput\\n\\n7\\nSolve the task in PYTHON3.\",\"targets\":\"R = lambda:map(int,input().split())\\n\\nn, m  = R()\\narr = sorted([[*R()] for i in range(m)], key=lambda x: x[1], reverse=True)\\nans = 0\\nfor i in arr:\\n    v = min(n, i[0])\\n    ans += v*i[1]\\n    n -= v\\n    if n < 1:\\n        break\\nprint(ans)\",\"language\":\"python\",\"split\":\"train\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"<image>\\n\\nWilliam is not only interested in trading but also in betting on sports matches. n teams participate in each match. Each team is characterized by strength a_i. Each two teams i < j play with each other exactly once. Team i wins with probability (a_i)\\/(a_i + a_j) and team j wins with probability (a_j)\\/(a_i + a_j).\\n\\nThe team is called a winner if it directly or indirectly defeated all other teams. Team a defeated (directly or indirectly) team b if there is a sequence of teams c_1, c_2, ... c_k such that c_1 = a, c_k = b and team c_i defeated team c_{i + 1} for all i from 1 to k - 1. Note that it is possible that team a defeated team b and in the same time team b defeated team a.\\n\\nWilliam wants you to find the expected value of the number of winners.\\n\\nInput\\n\\nThe first line contains a single integer n (1 \u2264 n \u2264 14), which is the total number of teams participating in a match.\\n\\nThe second line contains n integers a_1, a_2, ..., a_n (1 \u2264 a_i \u2264 10^6) \u2014 the strengths of teams participating in a match.\\n\\nOutput\\n\\nOutput a single integer \u2014 the expected value of the number of winners of the tournament modulo 10^9 + 7.\\n\\nFormally, let M = 10^9+7. It can be demonstrated that the answer can be presented as a irreducible fraction p\\/q, where p and q are integers and q not \u2261 0 \\\\pmod{M}. Output a single integer equal to p \u22c5 q^{-1} mod M. In other words, output an integer x such that 0 \u2264 x < M and x \u22c5 q \u2261 p \\\\pmod{M}.\\n\\nExamples\\n\\nInput\\n\\n\\n2\\n1 2\\n\\n\\nOutput\\n\\n\\n1\\n\\n\\nInput\\n\\n\\n5\\n1 5 2 11 14\\n\\n\\nOutput\\n\\n\\n642377629\\n\\nNote\\n\\nTo better understand in which situation several winners are possible let's examine the second test:\\n\\nOne possible result of the tournament is as follows (a \u2192 b means that a defeated b):\\n\\n  * 1 \u2192 2 \\n  * 2 \u2192 3 \\n  * 3 \u2192 1 \\n  * 1 \u2192 4 \\n  * 1 \u2192 5 \\n  * 2 \u2192 4 \\n  * 2 \u2192 5 \\n  * 3 \u2192 4 \\n  * 3 \u2192 5 \\n  * 4 \u2192 5 \\n\\n\\n\\nOr more clearly in the picture:\\n\\n<image>\\n\\nIn this case every team from the set \\\\{ 1, 2, 3 \\\\} directly or indirectly defeated everyone. I.e.:\\n\\n  * 1st defeated everyone because they can get to everyone else in the following way...\\nSolve the task in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst int MX = (1 << 15) + 2, md = 1000000007;\\nint n, m, i, j, k, msk, a[15], b[MX], pos[15];\\nlong long rp, rq, zp, zq, curp, curq, cp[MX], cq[MX], p[15][15], q[15][15];\\nlong long pw(long long a, int b) {\\n  if (b == 0) return 1LL;\\n  if (b & 1) return (pw(a, b - 1) * a) % md;\\n  long long x = pw(a, b \\/ 2);\\n  return (x * x) % md;\\n}\\nvoid mul(long long& xp, long long& xq, long long yp, long long yq) {\\n  xp = (xp * yp) % md;\\n  xq = (xq * yq) % md;\\n}\\nvoid sub(long long& xp, long long& xq, long long yp, long long yq) {\\n  xp = (xp * yq + md - ((xq * yp) % md)) % md;\\n  xq = (xq * yq) % md;\\n}\\nvoid inc(long long& xp, long long& xq, long long yp, long long yq) {\\n  xp = (xp * yq + xq * yp) % md;\\n  xq = (xq * yq) % md;\\n}\\nint main() {\\n  scanf(\\\"%d\\\", &n);\\n  for (i = 0; i < n; i++) {\\n    scanf(\\\"%d\\\", &a[i]);\\n    for (j = 0; j < i; j++) {\\n      p[i][j] = a[i];\\n      p[j][i] = a[j];\\n      q[i][j] = q[j][i] = a[i] + a[j];\\n    }\\n  }\\n  rp = 0;\\n  rq = 1;\\n  for (i = 1; i < (1 << n); i++) {\\n    b[i] = b[i \\/ 2] + (i & 1);\\n    cp[i] = zp = 1;\\n    cq[i] = zq = 1;\\n    for (m = j = 0; j < n; j++)\\n      if ((i >> j) & 1) {\\n        pos[m++] = j;\\n        for (k = 0; k < n; k++)\\n          if (((i >> k) & 1) == 0) mul(zp, zq, p[j][k], q[j][k]);\\n      }\\n    for (msk = (i & (i - 1)); msk > 0; msk = ((msk - 1) & i)) {\\n      curp = cp[msk];\\n      curq = cq[msk];\\n      for (j = 0; j < m; j++)\\n        if ((msk >> pos[j]) & 1)\\n          for (k = 0; k < m; k++)\\n            if (((msk >> pos[k]) & 1) == 0)\\n              mul(curp, curq, p[pos[j]][pos[k]], q[pos[j]][pos[k]]);\\n      sub(cp[i], cq[i], curp, curq);\\n    }\\n    inc(rp, rq, (((b[i] * cp[i]) % md) * zp) % md, (cq[i] * zq) % md);\\n  }\\n  printf(\\\"%lld\\\\n\\\", (rp * pw(rq, md - 2)) % md);\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in PYTHON3?\\nDmitry has an array of n non-negative integers a_1, a_2, ..., a_n.\\n\\nIn one operation, Dmitry can choose any index j (1 \u2264 j \u2264 n) and increase the value of the element a_j by 1. He can choose the same index j multiple times.\\n\\nFor each i from 0 to n, determine whether Dmitry can make the MEX of the array equal to exactly i. If it is possible, then determine the minimum number of operations to do it.\\n\\nThe MEX of the array is equal to the minimum non-negative integer that is not in the array. For example, the MEX of the array [3, 1, 0] is equal to 2, and the array [3, 3, 1, 4] is equal to 0.\\n\\nInput\\n\\nThe first line of input data contains a single integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases in the input. \\n\\nThe descriptions of the test cases follow.\\n\\nThe first line of the description of each test case contains a single integer n (1 \u2264 n \u2264 2 \u22c5 10^5) \u2014 the length of the array a.\\n\\nThe second line of the description of each test case contains n integers a_1, a_2, ..., a_n (0 \u2264 a_i \u2264 n) \u2014 elements of the array a.\\n\\nIt is guaranteed that the sum of the values n over all test cases in the test does not exceed 2\u22c510^5.\\n\\nOutput\\n\\nFor each test case, output n + 1 integer \u2014 i-th number is equal to the minimum number of operations for which you can make the array MEX equal to i (0 \u2264 i \u2264 n), or -1 if this cannot be done.\\n\\nExample\\n\\nInput\\n\\n\\n5\\n3\\n0 1 3\\n7\\n0 1 2 3 4 3 2\\n4\\n3 0 0 0\\n7\\n4 6 2 3 5 0 5\\n5\\n4 0 1 0 4\\n\\n\\nOutput\\n\\n\\n1 1 0 -1 \\n1 1 2 2 1 0 2 6 \\n3 0 1 4 3 \\n1 0 -1 -1 -1 -1 -1 -1 \\n2 1 0 2 -1 -1 \\n\\nNote\\n\\nIn the first set of example inputs, n=3:\\n\\n  * to get MEX=0, it is enough to perform one increment: a_1++; \\n  * to get MEX=1, it is enough to perform one increment: a_2++; \\n  * MEX=2 for a given array, so there is no need to perform increments; \\n  * it is impossible to get MEX=3 by performing increments.\",\"targets\":\"import sys\\ninput = lambda: sys.stdin.readline().rstrip()\\nINF = 10 ** 19\\nimport heapq\\ndef solve():\\n    n = int(input())\\n    a = list(map(int,input().split()))\\n    buc = [0] * (n + 1)\\n    for i in range(n):\\n        buc[a[i]] += 1\\n    ans = [buc[0]]\\n    tw = []\\n    if buc[0] == 0:\\n        ans.append(-1)\\n    else:\\n        ans.append(buc[1])\\n    if buc[0] >= 2:\\n        heapq.heappush(tw, 0)\\n    if buc[1] >= 2:\\n        heapq.heappush(tw, -1)\\n    cost = 0\\n    for i in range(2, n + 1):\\n        if ans[-1] == -1:\\n            ans.append(-1)\\n            continue\\n        elif buc[i - 1] == 0:\\n            if len(tw) == 0:\\n                ans.append(-1)\\n                continue\\n            now = heapq.heappop(tw)\\n            now = -now\\n            buc[now] -= 1\\n            buc[i - 1] += 1\\n            cost += abs(now - i + 1)\\n            if buc[now] >= 2:\\n                heapq.heappush(tw, -now)\\n        if buc[i] >= 2:\\n            heapq.heappush(tw, -i)\\n        ans.append(cost + buc[i])\\n    print(*ans)\\n\\n        \\n\\n\\n\\n\\nt = int(input())\\nfor _ in range(t):\\n    solve()\",\"language\":\"python\",\"split\":\"test\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Alice has a string consisting of characters 'A', 'B' and 'C'. Bob can use the following transitions on any substring of our string in any order any number of times: \\n\\n  * A <image> BC\\n  * B <image> AC\\n  * C <image> AB\\n  * AAA <image> empty string \\n\\n\\n\\nNote that a substring is one or more consecutive characters. For given queries, determine whether it is possible to obtain the target string from source.\\n\\nInput\\n\\nThe first line contains a string S (1 \u2264 |S| \u2264 105). The second line contains a string T (1 \u2264 |T| \u2264 105), each of these strings consists only of uppercase English letters 'A', 'B' and 'C'.\\n\\nThe third line contains the number of queries Q (1 \u2264 Q \u2264 105).\\n\\nThe following Q lines describe queries. The i-th of these lines contains four space separated integers ai, bi, ci, di. These represent the i-th query: is it possible to create T[ci..di] from S[ai..bi] by applying the above transitions finite amount of times?\\n\\nHere, U[x..y] is a substring of U that begins at index x (indexed from 1) and ends at index y. In particular, U[1..|U|] is the whole string U.\\n\\nIt is guaranteed that 1 \u2264 a \u2264 b \u2264 |S| and 1 \u2264 c \u2264 d \u2264 |T|.\\n\\nOutput\\n\\nPrint a string of Q characters, where the i-th character is '1' if the answer to the i-th query is positive, and '0' otherwise.\\n\\nExample\\n\\nInput\\n\\nAABCCBAAB\\nABCB\\n5\\n1 3 1 2\\n2 2 2 4\\n7 9 1 1\\n3 4 2 3\\n4 5 1 3\\n\\n\\nOutput\\n\\n10011\\n\\nNote\\n\\nIn the first query we can achieve the result, for instance, by using transitions <image>.\\n\\nThe third query asks for changing AAB to A \u2014 but in this case we are not able to get rid of the character 'B'.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst int maxn = 1e5 + 14;\\nint n, m;\\nstruct S {\\n  string s;\\n  int n;\\n  int preA[maxn], cntB[maxn];\\n  void build() {\\n    for (auto &c : s)\\n      if (c == 'C') c = 'B';\\n    n = s.size();\\n    for (int i = 0; i < n; i++) cntB[i + 1] = cntB[i] + (s[i] == 'B');\\n    for (int i = 0; i < n; i++)\\n      if (s[i] == 'A') preA[i + 1] = 1 + preA[i];\\n  }\\n} s, p;\\nint main() {\\n  ios::sync_with_stdio(0), cin.tie(0);\\n  cin >> s.s >> p.s;\\n  s.build();\\n  p.build();\\n  int q;\\n  cin >> q;\\n  while (q--) {\\n    int sl, sr, pl, pr;\\n    cin >> sl >> sr >> pl >> pr;\\n    sl--, pl--;\\n    int sb = s.cntB[sr] - s.cntB[sl];\\n    if (min(sr - sl, s.preA[sr]) % 3 != min(pr - pl, p.preA[pr]) % 3) sb += 2;\\n    if (min(sr - sl, s.preA[sr]) < min(pr - pl, p.preA[pr]) ||\\n        sb > p.cntB[pr] - p.cntB[pl] ||\\n        sb % 2 != (p.cntB[pr] - p.cntB[pl]) % 2 ||\\n        min(sr - sl, s.preA[sr]) == sr - sl &&\\n            sr - sl == min(pr - pl, p.preA[pr]) && sr - sl < pr - pl)\\n      cout << 0;\\n    else\\n      cout << 1;\\n  }\\n  cout << '\\\\n';\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"Shohag has an integer sequence a_1, a_2, \u2026, a_n. He can perform the following operation any number of times (possibly, zero):\\n\\n  * Select any positive integer k (it can be different in different operations). \\n  * Choose any position in the sequence (possibly the beginning or end of the sequence, or in between any two elements) and insert k into the sequence at this position. \\n  * This way, the sequence a changes, and the next operation is performed on this changed sequence. \\n\\n\\n\\nFor example, if a=[3,3,4] and he selects k = 2, then after the operation he can obtain one of the sequences [\\\\underline{2},3,3,4], [3,\\\\underline{2},3,4], [3,3,\\\\underline{2},4], or [3,3,4,\\\\underline{2}].\\n\\nShohag wants this sequence to satisfy the following condition: for each 1 \u2264 i \u2264 |a|, a_i \u2264 i. Here, |a| denotes the size of a.\\n\\nHelp him to find the minimum number of operations that he has to perform to achieve this goal. We can show that under the constraints of the problem it's always possible to achieve this goal in a finite number of operations.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 200) \u2014 the number of test cases.\\n\\nThe first line of each test case contains a single integer n (1 \u2264 n \u2264 100) \u2014 the initial length of the sequence.\\n\\nThe second line of each test case contains n integers a_1, a_2, \u2026, a_n (1 \u2264 a_i \u2264 10^9) \u2014 the elements of the sequence.\\n\\nOutput\\n\\nFor each test case, print a single integer \u2014 the minimum number of operations needed to perform to achieve the goal mentioned in the statement.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n3\\n1 3 4\\n5\\n1 2 5 7 4\\n1\\n1\\n3\\n69 6969 696969\\n\\n\\nOutput\\n\\n\\n1\\n3\\n0\\n696966\\n\\nNote\\n\\nIn the first test case, we have to perform at least one operation, as a_2=3>2. We can perform the operation [1, 3, 4] \u2192 [1, \\\\underline{2}, 3, 4] (the newly inserted element is underlined), now the condition is satisfied.\\n\\nIn the second test case, Shohag can perform the following operations:\\n\\n[1, 2, 5, 7, 4] \u2192 [1, 2, \\\\underline{3}, 5, 7, 4] \u2192 [1, 2, 3, \\\\underline{4}, 5, 7, 4] \u2192 [1, 2, 3, 4, 5, \\\\underline{3}, 7, 4].\\n\\nIn the third...\\\":\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint main() {\\n  ios_base::sync_with_stdio(false);\\n  cin.tie(NULL);\\n  cout.tie(NULL);\\n  long long t;\\n  cin >> t;\\n  while (t--) {\\n    long long n;\\n    cin >> n;\\n    long long a[n];\\n    long long k = 0;\\n    long long m = 0;\\n    for (long long i = 0; i < n; i++) {\\n      cin >> a[i];\\n      if (a[i] >= i + 1 + k) {\\n        long long p = k;\\n        k += a[i] - (i + 1 + p);\\n      }\\n    }\\n    cout << k << endl;\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Polycarp has come up with a new game to play with you. He calls it \\\"A missing bigram\\\".\\n\\nA bigram of a word is a sequence of two adjacent letters in it.\\n\\nFor example, word \\\"abbaaba\\\" contains bigrams \\\"ab\\\", \\\"bb\\\", \\\"ba\\\", \\\"aa\\\", \\\"ab\\\" and \\\"ba\\\".\\n\\nThe game goes as follows. First, Polycarp comes up with a word, consisting only of lowercase letters 'a' and 'b'. Then, he writes down all its bigrams on a whiteboard in the same order as they appear in the word. After that, he wipes one of them off the whiteboard.\\n\\nFinally, Polycarp invites you to guess what the word that he has come up with was.\\n\\nYour goal is to find any word such that it's possible to write down all its bigrams and remove one of them, so that the resulting sequence of bigrams is the same as the one Polycarp ended up with.\\n\\nThe tests are generated in such a way that the answer exists. If there are multiple answers, you can print any of them.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 2000) \u2014 the number of testcases.\\n\\nThe first line of each testcase contains a single integer n (3 \u2264 n \u2264 100) \u2014 the length of the word Polycarp has come up with.\\n\\nThe second line of each testcase contains n-2 bigrams of that word, separated by a single space. Each bigram consists of two letters, each of them is either 'a' or 'b'.\\n\\nAdditional constraint on the input: there exists at least one string such that it is possible to write down all its bigrams, except one, so that the resulting sequence is the same as the sequence in the input. In other words, the answer exists.\\n\\nOutput\\n\\nFor each testcase print a word, consisting of n letters, each of them should be either 'a' or 'b'. It should be possible to write down all its bigrams and remove one of them, so that the resulting sequence of bigrams is the same as the one Polycarp ended up with.\\n\\nThe tests are generated in such a way that the answer exists. If there are multiple answers, you can print any of them. \\n\\nExample\\n\\nInput\\n\\n\\n4\\n7\\nab bb ba aa ba\\n7\\nab ba aa ab ba\\n3\\naa\\n5\\nbb ab...\",\"targets\":\"testcase=int(input())\\ng=0\\nwhile(testcase>0):\\n  length_of_word=int(input())\\n  bigram=input().split()\\n  polycarp=bigram[0]\\n  for i in bigram[1:]:\\n    if(polycarp[-1]!=i[0]):\\n      polycarp+=i\\n    else:\\n      polycarp+=i[1]\\n  if(len(polycarp)!=length_of_word):\\n    polycarp+='a'\\n  print(polycarp)\\n  testcase-=1\\n  g+=1\",\"language\":\"python\",\"split\":\"test\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"This is the easy version of the problem. The difference between the versions is that the easy version does not require you to output the numbers of the rods to be removed. You can make hacks only if all versions of the problem are solved.\\n\\nStitch likes experimenting with different machines with his friend Sparky. Today they built another machine.\\n\\nThe main element of this machine are n rods arranged along one straight line and numbered from 1 to n inclusive. Each of these rods must carry an electric charge quantitatively equal to either 1 or -1 (otherwise the machine will not work). Another condition for this machine to work is that the sign-variable sum of the charge on all rods must be zero.\\n\\nMore formally, the rods can be represented as an array of n numbers characterizing the charge: either 1 or -1. Then the condition must hold: a_1 - a_2 + a_3 - a_4 + \u2026 = 0, or \u2211_{i=1}^n (-1)^{i-1} \u22c5 a_i = 0.\\n\\nSparky charged all n rods with an electric current, but unfortunately it happened that the rods were not charged correctly (the sign-variable sum of the charge is not zero). The friends decided to leave only some of the rods in the machine. Sparky has q questions. In the ith question Sparky asks: if the machine consisted only of rods with numbers l_i to r_i inclusive, what minimal number of rods could be removed from the machine so that the sign-variable sum of charges on the remaining ones would be zero? Perhaps the friends got something wrong, and the sign-variable sum is already zero. In that case, you don't have to remove the rods at all.\\n\\nIf the number of rods is zero, we will assume that the sign-variable sum of charges is zero, that is, we can always remove all rods.\\n\\nHelp your friends and answer all of Sparky's questions!\\n\\nInput\\n\\nEach test contains multiple test cases.\\n\\nThe first line contains one positive integer t (1 \u2264 t \u2264 10^3), denoting the number of test cases. Description of the test cases follows.\\n\\nThe first line of each test case contains two positive integers n and q (1 \u2264 n, q \u2264 3 \u22c5 10^5) \u2014 the...\\\":\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\n#pragma GCC optimize(\\\"Ofast\\\")\\n#pragma GCC target(\\\"avx,avx2,fma\\\")\\nvoid solve() {\\n  long long n, k;\\n  cin >> n >> k;\\n  string s;\\n  cin >> s;\\n  vector<long long> p(n + 1, 0);\\n  for (long long i = 1; i <= n; i++) {\\n    if (s[i - 1] == '+') {\\n      p[i] = -1;\\n    } else {\\n      p[i] = 1;\\n    }\\n    if (i % 2 == 0) {\\n      p[i] *= -1;\\n    }\\n    p[i] += p[i - 1];\\n  }\\n  while (k--) {\\n    long long a, b;\\n    cin >> a >> b;\\n    long long pos = p[b] - p[a - 1];\\n    if (pos == 0) {\\n      cout << 0 << endl;\\n    } else {\\n      if ((b - a + 1) & 1) {\\n        cout << 1 << endl;\\n      } else {\\n        cout << 2 << endl;\\n      }\\n    }\\n  }\\n}\\nint32_t main() {\\n  ios_base::sync_with_stdio(0);\\n  cin.tie(0);\\n  cout.tie(0);\\n  long long t = 1;\\n  cin >> t;\\n  while (t--) {\\n    solve();\\n  }\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"C: Short-circuit evaluation\\n\\nproblem\\n\\nNaodai-kun and Hokkaido University-kun are playing games. Hokkaido University first generates the following logical formula represented by BNF.\\n\\n\\n<formula> :: = <or-expr>\\n<or-expr> :: = <and-expr>\\n| <or-expr> \\\"|\\\" <and-expr>\\n<and-expr> :: = <term>\\n| <and-expr> \\\"&\\\" <term>\\n<term> :: = \\\"(\\\" <or-expr> \\\")\\\" | \\\"?\\\"\\n\\n\\n`&` represents the logical product, `|` represents the logical sum, and `&` is evaluated before `|`.\\n\\nNaodai reads this formula from the left (as a string), and when he finds a `?`, He does the following:\\n\\n* If it is certain that the evaluation result of the formula does not change regardless of whether the `?` Is `0` or` 1`, read it without doing anything.\\n* If not, pay 1 yen to Hokkaido University and replace the `?` With `0` or` 1`.\\n\\n\\n\\nThe logical expression is evaluated as follows. It is a so-called ordinary formula.\\n\\n\\n(0 &?) == 0\\n(1 & 0) == 0\\n(1 & 1) == 1\\n(0 | 0) == 0\\n(0 | 1) == 1\\n(1 |?) == 1\\n\\n\\nWhat is the minimum amount Naodai has to pay to finalize the evaluation result of a well-formed formula? Obtain the evaluation result depending on whether it is set to `0` or` 1`.\\n\\nInput format\\n\\nA formula that follows the BNF above is given in one line.\\n\\nConstraint\\n\\nThe length of the formula does not exceed 2 \\\\ times 10 ^ 5.\\n\\nOutput format\\n\\nOutput the minimum amount required to make the evaluation result `0`,` 1`, separated by blanks.\\n\\nInput example 1\\n\\n\\n? &? |? &? |? &?\\n\\nOutput example 1\\n\\n\\n3 2\\n\\nIf you want to make it `0`, rewrite it with` 0 0 0` to make it `0 &? | 0 &? | 0 &?`, If you want to make it `1`, rewrite it with` 1 1` and make it `1 & 1 |? &? |? & It is best to use? `.\\n\\nInput example 2\\n\\n\\n? &? &? |? &? &?\\n\\nOutput example 2\\n\\n\\ntwenty three\\n\\nThey are `0 &? &? | 0 &? &?` And `1 & 1 & 1 |? &? &?`, Respectively.\\n\\nInput example 3\\n\\n\\n(? |? |?) &? &? &? &? |? &? |? &?\\n\\nOutput example 3\\n\\n\\n4 4\\n\\n\\n\\n\\n\\nExample\\n\\nInput\\n\\n?&?|?&?|?&?\\n\\n\\nOutput\\n\\n3 2\\nSolve the task in CPP.\",\"targets\":\"#pragma GCC optimize(\\\"O2\\\")\\n#include <algorithm>\\n#include <bitset>\\n#include <cassert>\\n#include <cmath>\\n#include <cstdarg>\\n#include <cstdio>\\n#include <cstring>\\n#include <ctime>\\n#include <deque>\\n#include <iomanip>\\n#include <iostream>\\n#include <iterator>\\n#include <map>\\n#include <numeric>\\n#include <queue>\\n#include <random>\\n#include <set>\\n#include <stack>\\n#include <string>\\n#include <utility>\\n#include <vector>\\n\\n#define whlie while\\n#define retunr return\\n#define reutrn return\\n#define reutnr return\\n#define mp make_pair\\n#define pb push_back\\n#define eb emplace_back\\n#define fi first\\n#define se second\\n#define inf 1001001001\\n#define infLL (1LL << 61)\\n#define MOD 1000000007\\n#define FOR(i,a,b) for(int (i)=(int)(a); (i)<(int)(b); (i)++) \\/\\/ [a,b)\\n#define rep(i,N) FOR((i), 0, (int)(N)) \\/\\/ [0,N)\\n#define FORR(i,a,b) for(int (i)=(int)(b) - 1; (i)>=(int)(a); (i)--)\\n#define repr(i,N) FORR((i), 0, (int)(N))\\n#define each(x,v) for(auto &x : v)\\n#define all(v) (v).begin(),(v).end()\\n#define sz(v) ((int)(v).size())\\n#define vrep(v,it) for(auto it=v.begin();it!=v.end();it++)\\n#define vrepr(v,it) for(auto it=v.rbegin();it!=v.rend();it++)\\n#define ini(...) int __VA_ARGS__; in(__VA_ARGS__)\\n#define inl(...) ll __VA_ARGS__; in(__VA_ARGS__)\\n#define inc(...) char __VA_ARGS__; in(__VA_ARGS__)\\n#define ins(...) string __VA_ARGS__; in(__VA_ARGS__)\\n#define ind(...) double __VA_ARGS__; in(__VA_ARGS__)\\n#define inpii(...) pii __VA_ARGS__; in(__VA_ARGS__)\\n#define rand mtrand\\n#define randinit random_device seed_gen; mt19937 mtrand(seed_gen()+2)\\n\\n#ifdef LOCAL  \\n  #define trc(...) do { cout << #__VA_ARGS__ << \\\" = \\\"; dbg_out(__VA_ARGS__);} while(0)\\n  #define stopif(val) assert( !(val) )\\n  #define trcv(v,...) do { cout << #v << \\\" = \\\"; vector_debug(v , ##__VA_ARGS__);cout << endl;} while(0)\\n#else\\n  #define trc(...)\\n  #define stopif(...)\\n  #define trcv(...)\\n#endif\\n\\nusing namespace std;\\nusing ll = long long;\\nusing pii = pair<int,int>;\\nusing pll = pair<ll,ll>;\\nusing vi = vector<int>;\\nusing vl = vector<ll>;\\nusing vs = vector<string>;\\nusing vpii = vector<pii>;\\nusing vvi...\",\"language\":\"python\",\"split\":\"train\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"PizzaForces is Petya's favorite pizzeria. PizzaForces makes and sells pizzas of three sizes: small pizzas consist of 6 slices, medium ones consist of 8 slices, and large pizzas consist of 10 slices each. Baking them takes 15, 20 and 25 minutes, respectively.\\n\\nPetya's birthday is today, and n of his friends will come, so he decided to make an order from his favorite pizzeria. Petya wants to order so much pizza that each of his friends gets at least one slice of pizza. The cooking time of the order is the total baking time of all the pizzas in the order.\\n\\nYour task is to determine the minimum number of minutes that is needed to make pizzas containing at least n slices in total. For example: \\n\\n  * if 12 friends come to Petya's birthday, he has to order pizzas containing at least 12 slices in total. He can order two small pizzas, containing exactly 12 slices, and the time to bake them is 30 minutes; \\n  * if 15 friends come to Petya's birthday, he has to order pizzas containing at least 15 slices in total. He can order a small pizza and a large pizza, containing 16 slices, and the time to bake them is 40 minutes; \\n  * if 300 friends come to Petya's birthday, he has to order pizzas containing at least 300 slices in total. He can order 15 small pizzas, 10 medium pizzas and 13 large pizzas, in total they contain 15 \u22c5 6 + 10 \u22c5 8 + 13 \u22c5 10 = 300 slices, and the total time to bake them is 15 \u22c5 15 + 10 \u22c5 20 + 13 \u22c5 25 = 750 minutes; \\n  * if only one friend comes to Petya's birthday, he can order a small pizza, and the time to bake it is 15 minutes. \\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 10^4) \u2014 the number of testcases.\\n\\nEach testcase consists of a single line that contains a single integer n (1 \u2264 n \u2264 10^{16}) \u2014 the number of Petya's friends.\\n\\nOutput\\n\\nFor each testcase, print one integer \u2014 the minimum number of minutes that is needed to bake pizzas containing at least n slices in total.\\n\\nExample\\n\\nInput\\n\\n\\n6\\n12\\n15\\n300\\n1\\n9999999999999999\\n3\\n\\n\\nOutput\\n\\n\\n30\\n40\\n750\\n15\\n25000000000000000\\n15\",\"targets\":\"t=int(input())\\nfor i in range(t):\\n    n=int(input())\\n    if(n<=6):\\n        print(15)\\n    else:\\n        if(n%2!=0):\\n            n+=1\\n        print((n*5)\\/\\/2)\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"There is a city that can be represented as a square grid with corner points in (0, 0) and (10^6, 10^6).\\n\\nThe city has n vertical and m horizontal streets that goes across the whole city, i. e. the i-th vertical streets goes from (x_i, 0) to (x_i, 10^6) and the j-th horizontal street goes from (0, y_j) to (10^6, y_j). \\n\\nAll streets are bidirectional. Borders of the city are streets as well.\\n\\nThere are k persons staying on the streets: the p-th person at point (x_p, y_p) (so either x_p equal to some x_i or y_p equal to some y_j, or both).\\n\\nLet's say that a pair of persons form an inconvenient pair if the shortest path from one person to another going only by streets is strictly greater than the Manhattan distance between them.\\n\\nCalculate the number of inconvenient pairs of persons (pairs (x, y) and (y, x) are the same pair).\\n\\nLet's recall that Manhattan distance between points (x_1, y_1) and (x_2, y_2) is |x_1 - x_2| + |y_1 - y_2|.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 1000) \u2014 the number of test cases.\\n\\nThe first line of each test case contains three integers n, m and k (2 \u2264 n, m \u2264 2 \u22c5 10^5; 2 \u2264 k \u2264 3 \u22c5 10^5) \u2014 the number of vertical and horizontal streets and the number of persons.\\n\\nThe second line of each test case contains n integers x_1, x_2, ..., x_n (0 = x_1 < x_2 < ... < x_{n - 1} < x_n = 10^6) \u2014 the x-coordinates of vertical streets.\\n\\nThe third line contains m integers y_1, y_2, ..., y_m (0 = y_1 < y_2 < ... < y_{m - 1} < y_m = 10^6) \u2014 the y-coordinates of horizontal streets.\\n\\nNext k lines contains description of people. The p-th line contains two integers x_p and y_p (0 \u2264 x_p, y_p \u2264 10^6; x_p \u2208 \\\\\\\\{x_1, ..., x_n\\\\} or y_p \u2208 \\\\\\\\{y_1, ..., y_m\\\\}) \u2014 the coordinates of the p-th person. All points are distinct.\\n\\nIt guaranteed that sum of n doesn't exceed 2 \u22c5 10^5, sum of m doesn't exceed 2 \u22c5 10^5 and sum of k doesn't exceed 3 \u22c5 10^5.\\n\\nOutput\\n\\nFor each test case, print the number of inconvenient pairs.\\n\\nExample\\n\\nInput\\n\\n\\n2\\n2 2 4\\n0 1000000\\n0 1000000\\n1 0\\n1000000 1\\n999999 1000000\\n0 999999\\n5 4...\\nThe above is tricky. Write me a correct solution in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nconst int N = 1e6 + 10;\\nconst int M = 1e6;\\nusing namespace std;\\nlong long n, m, t, k;\\ninline long long read() {\\n  long long x = 0, f = 1;\\n  char c = getchar();\\n  while (c < '0' || c > '9') {\\n    if (c == '-') f = -1;\\n    c = getchar();\\n  }\\n  while (c >= '0' && c <= '9') {\\n    x = x * 10 + c - '0';\\n    c = getchar();\\n  }\\n  return x * f;\\n}\\nlong long vertical[N], horizontal[N], sum = 0, v[N];\\nstruct node {\\n  long long x, y;\\n} a[N];\\nlong long cmp1(node x, node y) { return x.x < y.x; }\\nlong long cmp2(node x, node y) { return x.y < y.y; }\\nlong long ANS = 0;\\nsigned main() {\\n  t = read();\\n  while (t--) {\\n    n = read(), m = read(), k = read();\\n    ANS = 0;\\n    for (long long i = 1; i <= n; i++) vertical[i] = read();\\n    for (long long i = 1; i <= m; i++) horizontal[i] = read();\\n    for (long long i = 1; i <= k; i++) {\\n      a[i].x = read(), a[i].y = read();\\n    }\\n    sort(a + 1, a + k + 1, cmp1);\\n    long long fst = 1;\\n    for (long long i = 1; i <= k; i) {\\n      set<long long> ans;\\n      ans.clear();\\n      while (a[i].x < vertical[fst] && i <= k) {\\n        ans.insert(a[i].y);\\n        sum++;\\n        v[a[i].y]++;\\n        i++;\\n      }\\n      while (a[i].x == vertical[fst]) i++;\\n      fst++;\\n      for (auto a : ans) {\\n        ANS += (v[a]) * (sum -= v[a]);\\n        v[a] = 0;\\n      }\\n    }\\n    fst = 1;\\n    sort(a + 1, a + k + 1, cmp2);\\n    for (long long i = 1; i <= k; i) {\\n      set<long long> ans;\\n      ans.clear();\\n      while (a[i].y < horizontal[fst] && i <= k) {\\n        ans.insert(a[i].x);\\n        v[a[i].x]++;\\n        i++;\\n        sum++;\\n      }\\n      while (a[i].y == horizontal[fst]) i++;\\n      fst++;\\n      for (auto a : ans) {\\n        ANS += (v[a]) * (sum -= v[a]);\\n        v[a] = 0;\\n      }\\n    }\\n    cout << ANS << endl;\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Capitalization is writing a word with its first letter as a capital letter. Your task is to capitalize the given word.\\n\\nNote, that during capitalization all the letters except the first one remains unchanged.\\n\\nInput\\n\\nA single line contains a non-empty word. This word consists of lowercase and uppercase English letters. The length of the word will not exceed 103.\\n\\nOutput\\n\\nOutput the given word after capitalization.\\n\\nExamples\\n\\nInput\\n\\nApPLe\\n\\n\\nOutput\\n\\nApPLe\\n\\n\\nInput\\n\\nkonjac\\n\\n\\nOutput\\n\\nKonjac\\nThe above is tricky. Write me a correct solution in PYTHON3.\",\"targets\":\"def main():\\n\\n    s = input()\\n\\n    ans = s[0].upper()\\n    ans += \\\"\\\".join(s[1:])\\n\\n    print(ans)\\n\\nmain()\",\"language\":\"python\",\"split\":\"train\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Alice and Bob are playing a game on a matrix, consisting of 2 rows and m columns. The cell in the i-th row in the j-th column contains a_{i, j} coins in it.\\n\\nInitially, both Alice and Bob are standing in a cell (1, 1). They are going to perform a sequence of moves to reach a cell (2, m).\\n\\nThe possible moves are: \\n\\n  * Move right \u2014 from some cell (x, y) to (x, y + 1); \\n  * Move down \u2014 from some cell (x, y) to (x + 1, y). \\n\\n\\n\\nFirst, Alice makes all her moves until she reaches (2, m). She collects the coins in all cells she visit (including the starting cell).\\n\\nWhen Alice finishes, Bob starts his journey. He also performs the moves to reach (2, m) and collects the coins in all cells that he visited, but Alice didn't.\\n\\nThe score of the game is the total number of coins Bob collects.\\n\\nAlice wants to minimize the score. Bob wants to maximize the score. What will the score of the game be if both players play optimally?\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 10^4) \u2014 the number of testcases.\\n\\nThen the descriptions of t testcases follow.\\n\\nThe first line of the testcase contains a single integer m (1 \u2264 m \u2264 10^5) \u2014 the number of columns of the matrix.\\n\\nThe i-th of the next 2 lines contain m integers a_{i,1}, a_{i,2}, ..., a_{i,m} (1 \u2264 a_{i,j} \u2264 10^4) \u2014 the number of coins in the cell in the i-th row in the j-th column of the matrix.\\n\\nThe sum of m over all testcases doesn't exceed 10^5.\\n\\nOutput\\n\\nFor each testcase print a single integer \u2014 the score of the game if both players play optimally.\\n\\nExample\\n\\nInput\\n\\n\\n3\\n3\\n1 3 7\\n3 5 1\\n3\\n1 3 9\\n3 5 1\\n1\\n4\\n7\\n\\n\\nOutput\\n\\n\\n7\\n8\\n0\\n\\nNote\\n\\nThe paths for the testcases are shown on the following pictures. Alice's path is depicted in red and Bob's path is depicted in blue.\\n\\n<image>\\nSolve the task in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst int INF = 0x3f3f3f3f;\\nconst long long LINF = 0x3f3f3f3f3f3f3f3fll;\\nconst int MAX = 1e5 + 10;\\nint arr[MAX], arr2[MAX];\\nint main() {\\n  int t;\\n  cin >> t;\\n  while (t--) {\\n    int n;\\n    cin >> n;\\n    cin >> arr[0];\\n    for (int i = 1; i < n; ++i) {\\n      cin >> arr[i];\\n      arr[i] += arr[i - 1];\\n    }\\n    arr2[0] = 0;\\n    for (int i = 1; i < n + 1; ++i) {\\n      cin >> arr2[i];\\n      arr2[i] += arr2[i - 1];\\n    }\\n    int ans = arr[n - 1];\\n    for (int i = 0; i < n; ++i)\\n      ans = min(ans, max(arr[n - 1] - arr[i], arr2[i]));\\n    cout << ans << '\\\\n';\\n  }\\n  exit(0);\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"A string is called square if it is some string written twice in a row. For example, the strings \\\"aa\\\", \\\"abcabc\\\", \\\"abab\\\" and \\\"baabaa\\\" are square. But the strings \\\"aaa\\\", \\\"abaaab\\\" and \\\"abcdabc\\\" are not square.\\n\\nFor a given string s determine if it is square.\\n\\nInput\\n\\nThe first line of input data contains an integer t (1 \u2264 t \u2264 100) \u2014the number of test cases.\\n\\nThis is followed by t lines, each containing a description of one test case. The given strings consist only of lowercase Latin letters and have lengths between 1 and 100 inclusive.\\n\\nOutput\\n\\nFor each test case, output on a separate line:\\n\\n  * YES if the string in the corresponding test case is square, \\n  * NO otherwise. \\n\\n\\n\\nYou can output YES and NO in any case (for example, strings yEs, yes, Yes and YES will be recognized as a positive response).\\n\\nExample\\n\\nInput\\n\\n\\n10\\na\\naa\\naaa\\naaaa\\nabab\\nabcabc\\nabacaba\\nxxyy\\nxyyx\\nxyxy\\n\\n\\nOutput\\n\\n\\nNO\\nYES\\nNO\\nYES\\nYES\\nYES\\nNO\\nNO\\nNO\\nYES\",\"targets\":\"import java.util.Scanner;\\n\\npublic class Main2 {\\n    public static void main(String [] args){\\n        Scanner sc = new Scanner(System.in);\\n        int n = sc.nextInt();\\n        String []arr = new String[n+2];\\n        for(int i = 1;i<=n;i++){\\n            String x = sc.next();\\n            if(x.length()%2==1){\\n                arr[i] = \\\"NO\\\";\\n            }else{\\n                if(x.substring(0,x.length()\\/2).equals(x.substring(x.length()\\/2))){\\n                    arr[i] = \\\"YES\\\";\\n                }else{\\n                    arr[i] = \\\"NO\\\";\\n                }\\n            }\\n        }\\n        for(int i = 1;i<=n;i++){\\n            System.out.println(arr[i]);\\n        }\\n    }\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"YouKn0wWho has an integer sequence a_1, a_2, \u2026, a_n. He will perform the following operation until the sequence becomes empty: select an index i such that 1 \u2264 i \u2264 |a| and a_i is not divisible by (i + 1), and erase this element from the sequence. Here |a| is the length of sequence a at the moment of operation. Note that the sequence a changes and the next operation is performed on this changed sequence.\\n\\nFor example, if a=[3,5,4,5], then he can select i = 2, because a_2 = 5 is not divisible by i+1 = 3. After this operation the sequence is [3,4,5].\\n\\nHelp YouKn0wWho determine if it is possible to erase the whole sequence using the aforementioned operation.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 10 000) \u2014 the number of test cases.\\n\\nThe first line of each test case contains a single integer n (1 \u2264 n \u2264 10^5).\\n\\nThe second line of each test case contains n integers a_1, a_2, \u2026, a_n (1 \u2264 a_i \u2264 10^9).\\n\\nIt is guaranteed that the sum of n over all test cases doesn't exceed 3 \u22c5 10^5.\\n\\nOutput\\n\\nFor each test case, print \\\"YES\\\" (without quotes) if it is possible to erase the whole sequence using the aforementioned operation, print \\\"NO\\\" (without quotes) otherwise. You can print each letter in any register (upper or lower).\\n\\nExample\\n\\nInput\\n\\n\\n5\\n3\\n1 2 3\\n1\\n2\\n2\\n7 7\\n10\\n384836991 191890310 576823355 782177068 404011431 818008580 954291757 160449218 155374934 840594328\\n8\\n6 69 696 69696 696969 6969696 69696969 696969696\\n\\n\\nOutput\\n\\n\\nYES\\nNO\\nYES\\nYES\\nNO\\n\\nNote\\n\\nIn the first test case, YouKn0wWho can perform the following operations (the erased elements are underlined): [1, \\\\underline{2}, 3] \u2192 [\\\\underline{1}, 3] \u2192 [\\\\underline{3}] \u2192 [ ].\\n\\nIn the second test case, it is impossible to erase the sequence as i can only be 1, and when i=1, a_1 = 2 is divisible by i + 1 = 2.\\nSolve the task in JAVA.\",\"targets\":\"import java.io.OutputStream;\\nimport java.io.IOException;\\nimport java.io.InputStream;\\nimport java.io.OutputStream;\\nimport java.io.PrintWriter;\\nimport java.io.BufferedWriter;\\nimport java.io.Writer;\\nimport java.io.OutputStreamWriter;\\nimport java.util.InputMismatchException;\\nimport java.io.IOException;\\nimport java.io.InputStream;\\n\\n\\/**\\n * Built using CHelper plug-in\\n * Actual solution is at the top\\n *\\/\\npublic class Main {\\n    public static void main(String[] args) {\\n        InputStream inputStream = System.in;\\n        OutputStream outputStream = System.out;\\n        InputReader in = new InputReader(inputStream);\\n        OutputWriter out = new OutputWriter(outputStream);\\n        CDiVisibleConfusion solver = new CDiVisibleConfusion();\\n        int testCount = Integer.parseInt(in.next());\\n        for (int i = 1; i <= testCount; i++)\\n            solver.solve(i, in, out);\\n        out.close();\\n    }\\n\\n    static class CDiVisibleConfusion {\\n        public void solve(int testNumber, InputReader in, OutputWriter out) {\\n            int n = in.nextInt();\\n            int[] arr = in.nextIntArray(n);\\n            for (int i = 0; i < 23 && i < n; i++) {\\n                int cur = arr[i];\\n                boolean fail = true;\\n                for (int j = 1; j < i + 3; j++) {\\n                    if (cur % j != 0) {\\n                        fail = false;\\n                        break;\\n                    }\\n                }\\n                if (fail) {\\n                    out.println(\\\"NO\\\");\\n                    return;\\n                }\\n            }\\n            out.println(\\\"YES\\\");\\n        }\\n\\n    }\\n\\n    static class OutputWriter {\\n        private final PrintWriter writer;\\n\\n        public OutputWriter(OutputStream outputStream) {\\n            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));\\n        }\\n\\n        public OutputWriter(Writer writer) {\\n            this.writer = new PrintWriter(writer);\\n        }\\n\\n        public void print(Object... objects) {\\n            print(\\\" \\\", objects);\\n        }\\n\\n       ...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"A necklace can be described as a string of links ('-') and pearls ('o'), with the last link or pearl connected to the first one.\\n\\n<image>\\n\\nYou can remove a link or a pearl and insert it between two other existing links or pearls (or between a link and a pearl) on the necklace. This process can be repeated as many times as you like, but you can't throw away any parts.\\n\\nCan you make the number of links between every two adjacent pearls equal? Two pearls are considered to be adjacent if there is no other pearl between them.\\n\\nNote that the final necklace should remain as one circular part of the same length as the initial necklace.\\n\\nInput\\n\\nThe only line of input contains a string s (3 \u2264 |s| \u2264 100), representing the necklace, where a dash '-' represents a link and the lowercase English letter 'o' represents a pearl.\\n\\nOutput\\n\\nPrint \\\"YES\\\" if the links and pearls can be rejoined such that the number of links between adjacent pearls is equal. Otherwise print \\\"NO\\\".\\n\\nYou can print each letter in any case (upper or lower).\\n\\nExamples\\n\\nInput\\n\\n<span class=\\\"tex-font-style-tt\\\">-o-o--<\\/span>\\n\\nOutput\\n\\nYES\\n\\nInput\\n\\n<span class=\\\"tex-font-style-tt\\\">-o---<\\/span>\\n\\n\\nOutput\\n\\nYES\\n\\nInput\\n\\n<span class=\\\"tex-font-style-tt\\\">-o---o-<\\/span>\\n\\n\\nOutput\\n\\nNO\\n\\nInput\\n\\nooo\\n\\n\\nOutput\\n\\nYES\\nUsing cpp can you solve the prior task?\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint main() {\\n  string s;\\n  getline(cin, s);\\n  int links = 0;\\n  int peals = 0;\\n  for (int i = 0; i < s.size(); i++) {\\n    if (s[i] == '-')\\n      links++;\\n    else\\n      peals++;\\n  }\\n  if (peals <= 1)\\n    cout << \\\"YES\\\";\\n  else if (links % peals == 0)\\n    cout << \\\"YES\\\";\\n  else\\n    cout << \\\"NO\\\";\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in PYTHON3?\\nPolycarp must pay exactly n burles at the checkout. He has coins of two nominal values: 1 burle and 2 burles. Polycarp likes both kinds of coins equally. So he doesn't want to pay with more coins of one type than with the other.\\n\\nThus, Polycarp wants to minimize the difference between the count of coins of 1 burle and 2 burles being used. Help him by determining two non-negative integer values c_1 and c_2 which are the number of coins of 1 burle and 2 burles, respectively, so that the total value of that number of coins is exactly n (i. e. c_1 + 2 \u22c5 c_2 = n), and the absolute value of the difference between c_1 and c_2 is as little as possible (i. e. you must minimize |c_1-c_2|).\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases. Then t test cases follow.\\n\\nEach test case consists of one line. This line contains one integer n (1 \u2264 n \u2264 10^9) \u2014 the number of burles to be paid by Polycarp.\\n\\nOutput\\n\\nFor each test case, output a separate line containing two integers c_1 and c_2 (c_1, c_2 \u2265 0) separated by a space where c_1 is the number of coins of 1 burle and c_2 is the number of coins of 2 burles. If there are multiple optimal solutions, print any one.\\n\\nExample\\n\\nInput\\n\\n\\n6\\n1000\\n30\\n1\\n32\\n1000000000\\n5\\n\\n\\nOutput\\n\\n\\n334 333\\n10 10\\n1 0\\n10 11\\n333333334 333333333\\n1 2\\n\\nNote\\n\\nThe answer for the first test case is \\\"334 333\\\". The sum of the nominal values of all coins is 334 \u22c5 1 + 333 \u22c5 2 = 1000, whereas |334 - 333| = 1. One can't get the better value because if |c_1 - c_2| = 0, then c_1 = c_2 and c_1 \u22c5 1 + c_1 \u22c5 2 = 1000, but then the value of c_1 isn't an integer.\\n\\nThe answer for the second test case is \\\"10 10\\\". The sum of the nominal values is 10 \u22c5 1 + 10 \u22c5 2 = 30 and |10 - 10| = 0, whereas there's no number having an absolute value less than 0.\",\"targets\":\"t = int(input())\\n\\nfor i in range(t):\\n    n = int(input())\\n\\n    c1 = n \\/\\/ 3\\n    c2 = (n - c1) \\/\\/ 2\\n\\n    if c1 + c2 * 2 != n:\\n        c1 += 1\\n\\n    print(\\\"{} {}\\\".format(c1, c2))\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"It is the easy version of the problem. The only difference is that in this version n = 1.\\n\\nIn the cinema seats can be represented as the table with n rows and m columns. The rows are numbered with integers from 1 to n. The seats in each row are numbered with consecutive integers from left to right: in the k-th row from m (k - 1) + 1 to m k for all rows 1 \u2264 k \u2264 n.\\n\\n1| 2| \u22c5\u22c5\u22c5| m - 1| m  \\n---|---|---|---|---  \\nm + 1| m + 2| \u22c5\u22c5\u22c5| 2 m - 1| 2 m  \\n2m + 1| 2m + 2| \u22c5\u22c5\u22c5| 3 m - 1| 3 m  \\n\\\\vdots| \\\\vdots| \\\\ddots| \\\\vdots| \\\\vdots  \\nm (n - 1) + 1| m (n - 1) + 2| \u22c5\u22c5\u22c5| n m - 1| n m  \\nThe table with seats indices\\n\\nThere are nm people who want to go to the cinema to watch a new film. They are numbered with integers from 1 to nm. You should give exactly one seat to each person.\\n\\nIt is known, that in this cinema as lower seat index you have as better you can see everything happening on the screen. i-th person has the level of sight a_i. Let's define s_i as the seat index, that will be given to i-th person. You want to give better places for people with lower sight levels, so for any two people i, j such that a_i < a_j it should be satisfied that s_i < s_j.\\n\\nAfter you will give seats to all people they will start coming to their seats. In the order from 1 to nm, each person will enter the hall and sit in their seat. To get to their place, the person will go to their seat's row and start moving from the first seat in this row to theirs from left to right. While moving some places will be free, some will be occupied with people already seated. The inconvenience of the person is equal to the number of occupied seats he or she will go through.\\n\\nLet's consider an example: m = 5, the person has the seat 4 in the first row, the seats 1, 3, 5 in the first row are already occupied, the seats 2 and 4 are free. The inconvenience of this person will be 2, because he will go through occupied seats 1 and 3.\\n\\nFind the minimal total inconvenience (the sum of inconveniences of all people), that is possible to have by giving places for all people...\\ndef m\",\"targets\":\"ain():\\n    t = int(input())\\n\\n    for i in range(t):\\n\\n        n, m = map(int, input().split())\\n        arr = list(map(int, input().split()))\\n\\n\\n        start = 0\\n        total = 0\\n\\n        while start < m:\\n            for j in range(start):\\n                if arr[j] < arr[start]:\\n                    total += 1\\n            start += 1\\n\\n        print(total)\\nmain()\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Casimir has a string s which consists of capital Latin letters 'A', 'B', and 'C' only. Each turn he can choose to do one of the two following actions:\\n\\n  * he can either erase exactly one letter 'A' and exactly one letter 'B' from arbitrary places of the string (these letters don't have to be adjacent); \\n  * or he can erase exactly one letter 'B' and exactly one letter 'C' from arbitrary places in the string (these letters don't have to be adjacent). \\n\\n\\n\\nTherefore, each turn the length of the string is decreased exactly by 2. All turns are independent so for each turn, Casimir can choose any of two possible actions.\\n\\nFor example, with s = \\\"ABCABC\\\" he can obtain a string s = \\\"ACBC\\\" in one turn (by erasing the first occurrence of 'B' and the second occurrence of 'A'). There are also many other options for a turn aside from this particular example.\\n\\nFor a given string s determine whether there is a sequence of actions leading to an empty string. In other words, Casimir's goal is to erase all letters from the string. Is there a way to do this?\\n\\nInput\\n\\nThe first line contains an integer t (1 \u2264 t \u2264 1000) \u2014 the number of test cases.\\n\\nEach test case is described by one string s, for which you need to determine if it can be fully erased by some sequence of turns. The string s consists of capital letters 'A', 'B', 'C' and has a length from 1 to 50 letters, inclusive.\\n\\nOutput\\n\\nPrint t lines, each line containing the answer to the corresponding test case. The answer to a test case should be YES if there is a way to fully erase the corresponding string and NO otherwise.\\n\\nYou may print every letter in any case you want (so, for example, the strings yEs, yes, Yes, and YES will all be recognized as positive answers).\\n\\nExample\\n\\nInput\\n\\n\\n6\\nABACAB\\nABBA\\nAC\\nABC\\nCABCBB\\nBCBCBCBCBCBCBCBC\\n\\n\\nOutput\\n\\n\\nNO\\nYES\\nNO\\nNO\\nYES\\nYES\",\"targets\":\"import java.util.*;\\npublic class Round744 {\\n\\tpublic static void main(String[]args) {\\n\\t\\tScanner scan = new Scanner(System.in);\\n\\t\\tint t= scan.nextInt();\\n\\t\\tfor(int i=0;i<t;i++) {\\n\\t\\t\\tString s = scan.next();\\n\\t\\t\\tint n = s.length();\\n\\t\\t\\tint a =0,b=0,c=0;\\n\\t\\t\\tfor(int j=0 ;j<n;j++) {\\n\\t\\t\\t\\tif(s.charAt(j)=='A') {\\n\\t\\t\\t\\t\\ta++;\\n\\t\\t\\t\\t}\\n\\t\\t\\t\\telse if(s.charAt(j)=='B') {\\n\\t\\t\\t\\t\\tb++;\\n\\t\\t\\t\\t}\\n\\t\\t\\t\\telse {\\n\\t\\t\\t\\t\\tc++;\\n\\t\\t\\t\\t}\\n\\t\\t\\t}\\n\\t\\t\\tif((a+c)==b) {\\n\\t\\t\\t\\tSystem.out.println(\\\"YES\\\");\\n\\t\\t\\t}\\n\\t\\t\\telse {\\n\\t\\t\\t\\tSystem.out.println(\\\"NO\\\");\\n\\t\\t\\t}\\n\\t\\t}\\n\\t}\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"An important meeting is to be held and there are exactly n people invited. At any moment, any two people can step back and talk in private. The same two people can talk several (as many as they want) times per meeting.\\n\\nEach person has limited sociability. The sociability of the i-th person is a non-negative integer a_i. This means that after exactly a_i talks this person leaves the meeting (and does not talk to anyone else anymore). If a_i = 0, the i-th person leaves the meeting immediately after it starts.\\n\\nA meeting is considered most productive if the maximum possible number of talks took place during it.\\n\\nYou are given an array of sociability a, determine which people should talk to each other so that the total number of talks is as large as possible.\\n\\nInput\\n\\nThe first line contains an integer t (1 \u2264 t \u2264 1000) \u2014 the number of test cases.\\n\\nThe next 2t lines contain descriptions of the test cases.\\n\\nThe first line of each test case description contains an integer n (2 \u2264 n \u2264 2 \u22c5 10^5) \u2014the number of people in the meeting. The second line consists of n space-separated integers a_1, a_2, ..., a_n (0 \u2264 a_i \u2264 2 \u22c5 10^5) \u2014 the sociability parameters of all people. \\n\\nIt is guaranteed that the sum of n over all test cases does not exceed 2 \u22c5 10^5. It is also guaranteed that the sum of all a_i (over all test cases and all i) does not exceed 2 \u22c5 10^5.\\n\\nOutput\\n\\nPrint t answers to all test cases.\\n\\nOn the first line of each answer print the number k \u2014 the maximum number of talks possible in a meeting.\\n\\nOn each of the next k lines print two integers i and j (1 \u2264 i, j \u2264 n and i \u2260 j) \u2014 the numbers of people who will have another talk.\\n\\nIf there are several possible answers, you may print any of them.\\n\\nExample\\n\\nInput\\n\\n\\n8\\n2\\n2 3\\n3\\n1 2 3\\n4\\n1 2 3 4\\n3\\n0 0 2\\n2\\n6 2\\n3\\n0 0 2\\n5\\n8 2 0 1 1\\n5\\n0 1 0 0 6\\n\\n\\nOutput\\n\\n\\n2\\n1 2\\n1 2\\n3\\n1 3\\n2 3\\n2 3\\n5\\n1 3\\n2 4\\n2 4\\n3 4\\n3 4\\n0\\n2\\n1 2\\n1 2\\n0\\n4\\n1 2\\n1 5\\n1 4\\n1 2\\n1\\n5 2\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nusing namespace std;\\nint main() {\\n  ios_base::sync_with_stdio(0);\\n  cin.tie(0);\\n  ;\\n  int t;\\n  cin >> t;\\n  while (t--) {\\n    int i, j, k, x, n;\\n    cin >> n;\\n    vector<pair<int, int>> ans;\\n    priority_queue<pair<int, int>> p;\\n    for (i = 0; i < n; i++) {\\n      cin >> x;\\n      if (x > 0) p.push({x, i + 1});\\n    }\\n    while (p.size() > 1) {\\n      pair<int, int> x, y;\\n      x = p.top();\\n      p.pop();\\n      y = p.top();\\n      p.pop();\\n      ans.push_back({x.second, y.second});\\n      if (x.first > 1) p.push({x.first - 1, x.second});\\n      if (y.first > 1) p.push({y.first - 1, y.second});\\n    }\\n    cout << ans.size() << \\\"\\\\n\\\";\\n    for (i = 0; i < ans.size(); i++) {\\n      cout << ans[i].first << \\\" \\\" << ans[i].second << \\\"\\\\n\\\";\\n    }\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in PYTHON3?\\nPolycarp had an array a of 3 positive integers. He wrote out the sums of all non-empty subsequences of this array, sorted them in non-decreasing order, and got an array b of 7 integers.\\n\\nFor example, if a = \\\\{1, 4, 3\\\\}, then Polycarp wrote out 1, 4, 3, 1 + 4 = 5, 1 + 3 = 4, 4 + 3 = 7, 1 + 4 + 3 = 8. After sorting, he got an array b = \\\\{1, 3, 4, 4, 5, 7, 8\\\\}.\\n\\nUnfortunately, Polycarp lost the array a. He only has the array b left. Help him to restore the array a.\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 5000) \u2014 the number of test cases.\\n\\nEach test case consists of one line which contains 7 integers b_1, b_2, ..., b_7 (1 \u2264 b_i \u2264 10^9; b_i \u2264 b_{i+1}). \\n\\nAdditional constraint on the input: there exists at least one array a which yields this array b as described in the statement.\\n\\nOutput\\n\\nFor each test case, print 3 integers \u2014 a_1, a_2 and a_3. If there can be several answers, print any of them.\\n\\nExample\\n\\nInput\\n\\n\\n5\\n1 3 4 4 5 7 8\\n1 2 3 4 5 6 7\\n300000000 300000000 300000000 600000000 600000000 600000000 900000000\\n1 1 2 999999998 999999999 999999999 1000000000\\n1 2 2 3 3 4 5\\n\\n\\nOutput\\n\\n\\n1 4 3\\n4 1 2\\n300000000 300000000 300000000\\n999999998 1 1\\n1 2 2\\n\\nNote\\n\\nThe subsequence of the array a is a sequence that can be obtained from a by removing zero or more of its elements.\\n\\nTwo subsequences are considered different if index sets of elements included in them are different. That is, the values of the elements don't matter in the comparison of subsequences. In particular, any array of length 3 has exactly 7 different non-empty subsequences.\",\"targets\":\"for _ in range(int(input())):\\n    b=list(map(int,input().split()))\\n    pranith=len(b)\\n    s=max(b)\\n    p1=0\\n    p2=0\\n    p3=0\\n    for i in range(pranith-2):\\n            for j in range(i+1, pranith-1):\\n                for k in range(j+1, pranith):\\n                    if b[i]+b[j]+b[k]==s:\\n                        p1=b[i]\\n                        p2=b[j]\\n                        p3=b[k]\\n    print (str(p1)+\\\" \\\"+str(p2)+\\\" \\\"+str(p3))\",\"language\":\"python\",\"split\":\"test\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in CPP?\\nAn IPv6-address is a 128-bit number. For convenience, this number is recorded in blocks of 16 bits in hexadecimal record, the blocks are separated by colons \u2014 8 blocks in total, each block has four hexadecimal digits. Here is an example of the correct record of a IPv6 address: \\\"0124:5678:90ab:cdef:0124:5678:90ab:cdef\\\". We'll call such format of recording an IPv6-address full.\\n\\nBesides the full record of an IPv6 address there is a short record format. The record of an IPv6 address can be shortened by removing one or more leading zeroes at the beginning of each block. However, each block should contain at least one digit in the short format. For example, the leading zeroes can be removed like that: \\\"a56f:00d3:0000:0124:0001:f19a:1000:0000\\\"  \u2192  \\\"a56f:d3:0:0124:01:f19a:1000:00\\\". There are more ways to shorten zeroes in this IPv6 address.\\n\\nSome IPv6 addresses contain long sequences of zeroes. Continuous sequences of 16-bit zero blocks can be shortened to \\\"::\\\". A sequence can consist of one or several consecutive blocks, with all 16 bits equal to 0. \\n\\nYou can see examples of zero block shortenings below:\\n\\n  * \\\"a56f:00d3:0000:0124:0001:0000:0000:0000\\\"  \u2192  \\\"a56f:00d3:0000:0124:0001::\\\"; \\n  * \\\"a56f:0000:0000:0124:0001:0000:1234:0ff0\\\"  \u2192  \\\"a56f::0124:0001:0000:1234:0ff0\\\"; \\n  * \\\"a56f:0000:0000:0000:0001:0000:1234:0ff0\\\"  \u2192  \\\"a56f:0000::0000:0001:0000:1234:0ff0\\\"; \\n  * \\\"a56f:00d3:0000:0124:0001:0000:0000:0000\\\"  \u2192  \\\"a56f:00d3:0000:0124:0001::0000\\\"; \\n  * \\\"0000:0000:0000:0000:0000:0000:0000:0000\\\"  \u2192  \\\"::\\\". \\n\\n\\n\\nIt is not allowed to shorten zero blocks in the address more than once. This means that the short record can't contain the sequence of characters \\\"::\\\" more than once. Otherwise, it will sometimes be impossible to determine the number of zero blocks, each represented by a double colon.\\n\\nThe format of the record of the IPv6 address after removing the leading zeroes and shortening the zero blocks is called short.\\n\\nYou've got several short records of IPv6 addresses. Restore their full record.\\n\\nInput\\n\\nThe first line contains...\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\ntemplate <class T>\\nbool checkMin(T &a, T b) {\\n  if (a > b) {\\n    a = b;\\n    return 1;\\n  }\\n  return 0;\\n}\\ntemplate <class T>\\nbool checkMax(T &a, T b) {\\n  if (a < b) {\\n    a = b;\\n    return 1;\\n  }\\n  return 0;\\n}\\nconst int INF = 1e9;\\nconst int MN = -1;\\nstring ipv6;\\nvector<string> &split(const string &s, char delim, vector<string> &elems) {\\n  stringstream ss(s);\\n  string item;\\n  while (getline(ss, item, delim)) {\\n    elems.push_back(item);\\n  }\\n  return elems;\\n}\\nvector<string> split(const string &s, char delim) {\\n  vector<string> elems;\\n  return split(s, delim, elems);\\n}\\nstring cc(const string &s) {\\n  int n = ((int)(s).size());\\n  string f = s;\\n  for (int i = 0; i < (4 - n); i++) {\\n    f = '0' + f;\\n  }\\n  return f;\\n}\\nstring convert() {\\n  int n = ((int)(ipv6).size());\\n  vector<string> v(split(ipv6, ':'));\\n  int nblock = ((int)(v).size());\\n  int shortened = 8 - nblock + 1;\\n  string res = \\\"\\\";\\n  bool used = 0;\\n  for (int i = 0; i < (((int)(v).size())); i++) {\\n    if (v[i] == \\\"\\\" && !used) {\\n      used = 1;\\n      for (int j = 0; j < (shortened); j++) {\\n        res += \\\"0000:\\\";\\n      }\\n    } else\\n      res += cc(v[i]) + \\\":\\\";\\n  }\\n  return res.substr(0, ((int)(res).size()) - 1);\\n}\\nint main() {\\n  int n;\\n  cin >> n;\\n  while (n--) {\\n    cin >> ipv6;\\n    cout << convert() << endl;\\n  }\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"()\\n\\nProblem Statement\\n\\nThere is a string S. Initially, S is an empty string.\\nPerform the following processing in order of n.\\n\\n* Add x_i p_i (=\\\" (\\\" or\\\") \\\") to the end of S.\\n\\n\\n\\nAfter processing, determine if S is a well-balanced string.\\n\\n\\\"The string is balanced\\\" is defined as follows.\\n\\n* The empty string is well-balanced.\\n* For balanced strings a and b, a + b (+ represents a concatenation of strings) is balanced.\\n* For a balanced string a, \\\"(\\\" + a + \\\")\\\" is balanced.\\n\\nConstraints\\n\\n* 1 \u2264 n \u2264 1,000\\n* 1 \u2264 x_i \u2264 10 ^ 6\\n* p_i is \\\"(\\\" or \\\")\\\"\\n\\nInput\\n\\nInput follows the following format. All given numbers are integers.\\n\\n\\nn\\np_1 x_1\\n.. ..\\np_n x_n\\n\\nOutput\\n\\nOutput \\\"YES\\\" if balanced, otherwise output \\\"NO\\\" on one line.\\n\\nExamples\\n\\nInput\\n\\n3\\n( 5\\n) 4\\n) 1\\n\\n\\nOutput\\n\\nYES\\n\\n\\nInput\\n\\n5\\n( 2\\n) 2\\n( 3\\n) 1\\n) 2\\n\\n\\nOutput\\n\\nYES\\n\\n\\nInput\\n\\n2\\n) 1\\n( 1\\n\\n\\nOutput\\n\\nNO\",\"targets\":\"#include <iostream>\\nusing namespace std;\\n\\nint main(){\\n  int n;\\n\\n  while(cin >> n){\\n    int level = 0;\\n    bool flg = true;\\n\\n    for(int i = 0; i < n; i++){\\n      char ch;\\n      int m;\\n      cin >> ch >> m;\\n\\n      if(ch == '('){\\n        level += m;\\n      }\\n      else{\\n        level -= m;\\n      }\\n\\n      if(level < 0){\\n        flg = false;\\n      }\\n    }\\n\\n    if(level != 0) flg = false;\\n\\n    cout << (flg ? \\\"YES\\\" : \\\"NO\\\") << endl;\\n  }\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"A tree is an undirected connected graph without cycles.\\n\\nYou are given a tree of n vertices. Find the number of ways to choose exactly k vertices in this tree (i. e. a k-element subset of vertices) so that all pairwise distances between the selected vertices are equal (in other words, there exists an integer c such that for all u, v (u \u2260 v, u, v are in selected vertices) d_{u,v}=c, where d_{u,v} is the distance from u to v).\\n\\nSince the answer may be very large, you need to output it modulo 10^9 + 7.\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 10) \u2014 the number of test cases. Then t test cases follow.\\n\\nEach test case is preceded by an empty line.\\n\\nEach test case consists of several lines. The first line of the test case contains two integers n and k (2 \u2264 k \u2264 n \u2264 100) \u2014 the number of vertices in the tree and the number of vertices to be selected, respectively. Then n - 1 lines follow, each of them contains two integers u and v (1 \u2264 u, v \u2264 n, u \u2260 v) which describe a pair of vertices connected by an edge. It is guaranteed that the given graph is a tree and has no loops or multiple edges.\\n\\nOutput\\n\\nFor each test case output in a separate line a single integer \u2014 the number of ways to select exactly k vertices so that for all pairs of selected vertices the distances between the vertices in the pairs are equal, modulo 10^9 + 7 (in other words, print the remainder when divided by 1000000007).\\n\\nExample\\n\\nInput\\n\\n\\n3\\n\\n4 2\\n1 2\\n2 3\\n2 4\\n\\n3 3\\n1 2\\n2 3\\n\\n5 3\\n1 2\\n2 3\\n2 4\\n4 5\\n\\n\\nOutput\\n\\n\\n6\\n0\\n1\\nThe above is tricky. Write me a correct solution in JAVA.\",\"targets\":\"\\/\\/ Don't place your source in a package\\n\\n\\nimport javax.swing.*;\\nimport java.lang.reflect.Array;\\nimport java.text.DecimalFormat;\\nimport java.util.*;\\nimport java.lang.*;\\nimport java.io.*;\\nimport java.math.*;\\nimport java.util.stream.Stream;\\n\\n\\n\\n\\/\\/ Please name your class Main\\npublic class Main {\\n    static FastScanner fs=new FastScanner();\\n    static class FastScanner {\\n        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));\\n        StringTokenizer st=new StringTokenizer(\\\"\\\");\\n        public String next() {\\n            while (!st.hasMoreElements())\\n                try {\\n                    st=new StringTokenizer(br.readLine());\\n                } catch (IOException e) {\\n                    e.printStackTrace();\\n                }\\n            return st.nextToken();\\n        }\\n        int Int() {\\n            return Integer.parseInt(next());\\n        }\\n\\n        long Long() {\\n            return Long.parseLong(next());\\n        }\\n\\n        String Str(){\\n            return next();\\n        }\\n    }\\n\\n\\n    public static void main (String[] args) throws java.lang.Exception {\\n        PrintWriter out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));\\n        \\/\\/reading \\/writing file\\n        \\/\\/Scanner sc=new Scanner(new File(\\\"input.txt\\\"));\\n        \\/\\/PrintWriter pr=new PrintWriter(\\\"output.txt\\\");\\n\\n\\n        int T=Int();\\n        for(int t=0;t<T;t++){\\n            int n=Int();\\n            int k=Int();\\n            int edges[][]=new int[n-1][2];\\n            for(int i=0;i<edges.length;i++){\\n                edges[i][0]=Int()-1;\\n                edges[i][1]=Int()-1;\\n            }\\n            Solution sol=new Solution(out);\\n            sol.solution(n,k,edges);\\n        }\\n        out.close();\\n\\n    }\\n\\n\\n\\n\\n    public static int[] Arr(int n){\\n        int A[]=new int[n];\\n        for(int i=0;i<n;i++)A[i]=Int();\\n        return A;\\n    }\\n    public static int Int(){\\n        return fs.Int();\\n    }\\n    public static long Long(){\\n        return fs.Long();\\n    }\\n    public static String Str(){\\n        return...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You are given four integer values a, b, c and m.\\n\\nCheck if there exists a string that contains: \\n\\n  * a letters 'A'; \\n  * b letters 'B'; \\n  * c letters 'C'; \\n  * no other letters; \\n  * exactly m pairs of adjacent equal letters (exactly m such positions i that the i-th letter is equal to the (i+1)-th one). \\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 10^4) \u2014 the number of testcases.\\n\\nEach of the next t lines contains the description of the testcase \u2014 four integers a, b, c and m (1 \u2264 a, b, c \u2264 10^8; 0 \u2264 m \u2264 10^8).\\n\\nOutput\\n\\nFor each testcase print \\\"YES\\\" if there exists a string that satisfies all the requirements. Print \\\"NO\\\" if there are no such strings.\\n\\nYou may print every letter in any case you want (so, for example, the strings yEs, yes, Yes and YES will all be recognized as positive answer).\\n\\nExample\\n\\nInput\\n\\n\\n3\\n2 2 1 0\\n1 1 1 1\\n1 2 3 2\\n\\n\\nOutput\\n\\n\\nYES\\nNO\\nYES\\n\\nNote\\n\\nIn the first testcase strings \\\"ABCAB\\\" or \\\"BCABA\\\" satisfy the requirements. There exist other possible strings.\\n\\nIn the second testcase there's no way to put adjacent equal letters if there's no letter that appears at least twice.\\n\\nIn the third testcase string \\\"CABBCC\\\" satisfies the requirements. There exist other possible strings.\\nThe above is tricky. Write me a correct solution in JAVA.\",\"targets\":\"\\/\\/package Codeforces;\\n\\nimport java.io.*;\\nimport java.util.*;\\n\\npublic class Ed114B {\\n\\tpublic static void solve(IO io) {\\n\\n\\t\\tint a = io.getInt();\\n\\t\\tint b = io.getInt();\\n\\t\\tint c = io.getInt();\\n\\t\\tint m = io.getInt();\\n\\n\\t\\tif (m > a + b + c - 3) {\\n\\t\\t\\tio.println(\\\"NO\\\");\\n\\t\\t\\treturn;\\n\\t\\t}\\n\\n\\t\\tif (a + b + 1 < c) {\\n\\t\\t\\tif (m >= c - 1 - a - b) {\\n\\t\\t\\t\\tio.println(\\\"YES\\\");\\n\\t\\t\\t} else {\\n\\t\\t\\t\\tio.println(\\\"NO\\\");\\n\\t\\t\\t}\\n\\t\\t} else if (c + b + 1 < a) {\\n\\t\\t\\tif (m >= a - 1 - c - b) {\\n\\t\\t\\t\\tio.println(\\\"YES\\\");\\n\\t\\t\\t} else {\\n\\t\\t\\t\\tio.println(\\\"NO\\\");\\n\\t\\t\\t}\\n\\t\\t} else if (a + c + 1 < b) {\\n\\t\\t\\tif (m >= b - 1 - a - c) {\\n\\t\\t\\t\\tio.println(\\\"YES\\\");\\n\\t\\t\\t} else {\\n\\t\\t\\t\\tio.println(\\\"NO\\\");\\n\\t\\t\\t}\\n\\t\\t} else {\\n\\t\\t\\tio.println(\\\"YES\\\");\\n\\t\\t}\\n\\n\\t}\\n\\n\\tpublic static void main(String[] args) {\\n\\t\\tIO io = new IO();\\n\\t\\tint t = io.getInt();\\n\\t\\tfor (int testIndex = 0; testIndex < t; testIndex++) {\\n\\t\\t\\tsolve(io);\\n\\t\\t}\\n\\t\\tio.close();\\n\\t}\\n\\n\\tstatic class IO extends PrintWriter {\\n\\n\\t\\tpublic IO() {\\n\\t\\t\\tsuper(new BufferedOutputStream(System.out));\\n\\t\\t\\tr = new BufferedReader(new InputStreamReader(System.in));\\n\\t\\t}\\n\\n\\t\\tpublic IO(InputStream i) {\\n\\t\\t\\tsuper(new BufferedOutputStream(System.out));\\n\\t\\t\\tr = new BufferedReader(new InputStreamReader(i));\\n\\t\\t}\\n\\n\\t\\tpublic IO(InputStream i, OutputStream o) {\\n\\t\\t\\tsuper(new BufferedOutputStream(o));\\n\\t\\t\\tr = new BufferedReader(new InputStreamReader(i));\\n\\t\\t}\\n\\n\\t\\tpublic boolean hasMoreTokens() {\\n\\t\\t\\treturn peekToken() != null;\\n\\t\\t}\\n\\n\\t\\tpublic int getInt() {\\n\\t\\t\\treturn Integer.parseInt(nextToken());\\n\\t\\t}\\n\\n\\t\\tpublic double getDouble() {\\n\\t\\t\\treturn Double.parseDouble(nextToken());\\n\\t\\t}\\n\\n\\t\\tpublic long getLong() {\\n\\t\\t\\treturn Long.parseLong(nextToken());\\n\\t\\t}\\n\\n\\t\\tpublic String getWord() {\\n\\t\\t\\treturn nextToken();\\n\\t\\t}\\n\\n\\t\\tprivate BufferedReader r;\\n\\t\\tprivate String line;\\n\\t\\tprivate StringTokenizer st;\\n\\t\\tprivate String token;\\n\\n\\t\\tprivate String peekToken() {\\n\\t\\t\\tif (token == null)\\n\\t\\t\\t\\ttry {\\n\\t\\t\\t\\t\\twhile (st == null || !st.hasMoreTokens()) {\\n\\t\\t\\t\\t\\t\\tline = r.readLine();\\n\\t\\t\\t\\t\\t\\tif (line == null)\\n\\t\\t\\t\\t\\t\\t\\treturn null;\\n\\t\\t\\t\\t\\t\\tst = new StringTokenizer(line);\\n\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\t\\ttoken = st.nextToken();\\n\\t\\t\\t\\t} catch (IOException e)...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Polycarp is very fond of playing the game Minesweeper. Recently he found a similar game and there are such rules.\\n\\nThere are mines on the field, for each the coordinates of its location are known (x_i, y_i). Each mine has a lifetime in seconds, after which it will explode. After the explosion, the mine also detonates all mines vertically and horizontally at a distance of k (two perpendicular lines). As a result, we get an explosion on the field in the form of a \\\"plus\\\" symbol ('+'). Thus, one explosion can cause new explosions, and so on.\\n\\nAlso, Polycarp can detonate anyone mine every second, starting from zero seconds. After that, a chain reaction of explosions also takes place. Mines explode instantly and also instantly detonate other mines according to the rules described above.\\n\\nPolycarp wants to set a new record and asks you to help him calculate in what minimum number of seconds all mines can be detonated.\\n\\nInput\\n\\nThe first line of the input contains an integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases in the test.\\n\\nAn empty line is written in front of each test suite.\\n\\nNext comes a line that contains integers n and k (1 \u2264 n \u2264 2 \u22c5 10^5, 0 \u2264 k \u2264 10^9) \u2014 the number of mines and the distance that hit by mines during the explosion, respectively.\\n\\nThen n lines follow, the i-th of which describes the x and y coordinates of the i-th mine and the time until its explosion (-10^9 \u2264 x, y \u2264 10^9, 0 \u2264 timer \u2264 10^9). It is guaranteed that all mines have different coordinates.\\n\\nIt is guaranteed that the sum of the values n over all test cases in the test does not exceed 2 \u22c5 10^5.\\n\\nOutput\\n\\nPrint t lines, each of the lines must contain the answer to the corresponding set of input data \u2014 the minimum number of seconds it takes to explode all the mines.\\n\\nExample\\n\\nInput\\n\\n\\n3\\n\\n5 0\\n0 0 1\\n0 1 4\\n1 0 2\\n1 1 3\\n2 2 9\\n\\n5 2\\n0 0 1\\n0 1 4\\n1 0 2\\n1 1 3\\n2 2 9\\n\\n6 1\\n1 -1 3\\n0 -1 9\\n0 1 7\\n-1 0 1\\n-1 1 9\\n-1 -1 7\\n\\n\\nOutput\\n\\n\\n2\\n1\\n0\\n\\nNote\\n\\n<image> Picture from examples\\n\\nFirst example: \\n\\n  * 0 second: we explode a mine at the cell (2, 2), it does not...\\nThe above is tricky. Write me a correct solution in PYTHON3.\",\"targets\":\"# Codeforces Round #762 (Div. 3)\\n# G. Unusual Minesweeper\\n\\nimport collections\\n\\n\\nclass DisjointSet:\\n\\n    def __init__(self, init):\\n        # Dictionary where d[x] = [x.parent, x.size]\\n        self.d = {}\\n\\n        for x in init:\\n            self.make_set(x)\\n\\n    def make_set(self, x):\\n        if x in self.d:\\n            return\\n\\n        self.d[x] = [x, 1]\\n\\n    def find(self, x):\\n        if self.d[x][0] != x:\\n            self.d[x][0] = self.find(self.d[x][0])\\n            return self.d[x][0]\\n        return x\\n\\n    def union(self, x, y):\\n        x = self.find(x)\\n        y = self.find(y)\\n\\n        if x == y:\\n            return\\n\\n        if self.d[x][1] < self.d[y][1]:\\n            x, y = y, x\\n\\n        self.d[y][0] = x\\n        self.d[x][1] += self.d[y][1]\\n\\n    def __str__(self):\\n        return f\\\"Disjoint set with elements {self.d}\\\"\\n\\n    def __repr__(self):\\n        return str(self)\\n\\n\\ndef solve():\\n    input()\\n\\n    n, k = list(map(int, input().split()))\\n    points = []\\n    for _ in range(n):\\n        points += [list(map(int, input().split()))]\\n\\n    # Store all points by their x and y coordinates\\n    xs = collections.defaultdict(list)\\n    ys = collections.defaultdict(list)\\n    times = collections.defaultdict(int)\\n    for i, (x, y, timer) in enumerate(points):\\n        xs[x] += [(y, i)]\\n        ys[y] += [(x, i)]\\n        times[i] = timer\\n\\n    # Create disjoint set, join points if their x or y coords differ by <= k\\n    DS = DisjointSet(range(n))\\n    for x in xs:\\n        xs[x].sort()\\n        for i in range(1, len(xs[x])):\\n            if xs[x][i][0] - xs[x][i - 1][0] > k:\\n                continue\\n            DS.union(xs[x][i][1], xs[x][i - 1][1])\\n    for y in ys:\\n        ys[y].sort()\\n        for i in range(1, len(ys[y])):\\n            if ys[y][i][0] - ys[y][i - 1][0] > k:\\n                continue\\n            DS.union(ys[y][i][1], ys[y][i - 1][1])\\n\\n    # Map of index i -> min timer in component i\\n    comp_time = collections.defaultdict(lambda: 1e10)\\n    for i in range(n):\\n        f = DS.find(i)\\n        comp_time[f] =...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You are given n integers a_1, a_2, \u2026, a_n. Find the maximum value of max(a_l, a_{l + 1}, \u2026, a_r) \u22c5 min(a_l, a_{l + 1}, \u2026, a_r) over all pairs (l, r) of integers for which 1 \u2264 l < r \u2264 n.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 10 000) \u2014 the number of test cases.\\n\\nThe first line of each test case contains a single integer n (2 \u2264 n \u2264 10^5).\\n\\nThe second line of each test case contains n integers a_1, a_2, \u2026, a_n (1 \u2264 a_i \u2264 10^6).\\n\\nIt is guaranteed that the sum of n over all test cases doesn't exceed 3 \u22c5 10^5.\\n\\nOutput\\n\\nFor each test case, print a single integer \u2014 the maximum possible value of the product from the statement.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n3\\n2 4 3\\n4\\n3 2 3 1\\n2\\n69 69\\n6\\n719313 273225 402638 473783 804745 323328\\n\\n\\nOutput\\n\\n\\n12\\n6\\n4761\\n381274500335\\n\\nNote\\n\\nLet f(l, r) = max(a_l, a_{l + 1}, \u2026, a_r) \u22c5 min(a_l, a_{l + 1}, \u2026, a_r).\\n\\nIn the first test case, \\n\\n  * f(1, 2) = max(a_1, a_2) \u22c5 min(a_1, a_2) = max(2, 4) \u22c5 min(2, 4) = 4 \u22c5 2 = 8. \\n  * f(1, 3) = max(a_1, a_2, a_3) \u22c5 min(a_1, a_2, a_3) = max(2, 4, 3) \u22c5 min(2, 4, 3) = 4 \u22c5 2 = 8. \\n  * f(2, 3) = max(a_2, a_3) \u22c5 min(a_2, a_3) = max(4, 3) \u22c5 min(4, 3) = 4 \u22c5 3 = 12. \\n\\n\\n\\nSo the maximum is f(2, 3) = 12.\\n\\nIn the second test case, the maximum is f(1, 2) = f(1, 3) = f(2, 3) = 6.\\nUsing cpp can you solve the prior task?\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint main() {\\n  int t;\\n  cin >> t;\\n  while (t--) {\\n    int n;\\n    cin >> n;\\n    vector<long long> arr(n);\\n    for (int i = 0; i < n; i++) cin >> arr[i];\\n    long long m = LLONG_MIN;\\n    for (int i = 0; i < n - 1; i++) m = max(m, arr[i] * arr[i + 1]);\\n    cout << m << endl;\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You are given two positive integers x and y. You can perform the following operation with x: write it in its binary form without leading zeros, add 0 or 1 to the right of it, reverse the binary form and turn it into a decimal number which is assigned as the new value of x.\\n\\nFor example: \\n\\n  * 34 can be turned into 81 via one operation: the binary form of 34 is 100010, if you add 1, reverse it and remove leading zeros, you will get 1010001, which is the binary form of 81. \\n  * 34 can be turned into 17 via one operation: the binary form of 34 is 100010, if you add 0, reverse it and remove leading zeros, you will get 10001, which is the binary form of 17. \\n  * 81 can be turned into 69 via one operation: the binary form of 81 is 1010001, if you add 0, reverse it and remove leading zeros, you will get 1000101, which is the binary form of 69. \\n  * 34 can be turned into 69 via two operations: first you turn 34 into 81 and then 81 into 69. \\n\\n\\n\\nYour task is to find out whether x can be turned into y after a certain number of operations (possibly zero).\\n\\nInput\\n\\nThe only line of the input contains two integers x and y (1 \u2264 x, y \u2264 10^{18}).\\n\\nOutput\\n\\nPrint YES if you can make x equal to y and NO if you can't.\\n\\nExamples\\n\\nInput\\n\\n\\n3 3\\n\\n\\nOutput\\n\\n\\nYES\\n\\n\\nInput\\n\\n\\n7 4\\n\\n\\nOutput\\n\\n\\nNO\\n\\n\\nInput\\n\\n\\n2 8\\n\\n\\nOutput\\n\\n\\nNO\\n\\n\\nInput\\n\\n\\n34 69\\n\\n\\nOutput\\n\\n\\nYES\\n\\n\\nInput\\n\\n\\n8935891487501725 71487131900013807\\n\\n\\nOutput\\n\\n\\nYES\\n\\nNote\\n\\nIn the first example, you don't even need to do anything.\\n\\nThe fourth example is described in the statement.\\nThe above is tricky. Write me a correct solution in JAVA.\",\"targets\":\"\\/\\/ package codeforces;\\nimport java.io.*;\\nimport java.util.*;\\n\\t\\npublic class practice {\\n\\t\\n\\tstatic FastScanner fs = new FastScanner();\\n\\t\\t\\n\\tpublic static void main(String[] args) {\\n\\t\\tint t = 1;\\n\\/\\/\\t\\tt = fs.nextInt();\\n\\t\\tfor(int i=1;i<=t;i++) {\\n\\t\\t\\tsolve(t);\\n\\t\\t}\\n\\t}\\n\\t\\t\\n\\tpublic static String toBin(long a) {\\n\\t\\tif (a == 0)\\n\\t\\t\\treturn \\\"\\\";\\n\\t\\tString S = toBin(a\\/2);\\n\\t\\tS+=Long.toString(a%2);\\n\\t\\treturn S;\\n\\t}\\n\\t\\n\\tpublic static String Reverse(String S) {\\n\\t\\tString str=\\\"\\\";\\n\\t\\tfor(int i=0;i<S.length();i++) {\\n\\t\\t\\tstr=S.charAt(i)+str;\\n\\t\\t}\\n\\t\\treturn str;\\n\\t}\\n\\t\\n\\tpublic static long OP(String s,char ch) {\\n\\t\\tlong ans=0;\\n\\t\\ts = s + ch;\\n\\t\\tString nz = Reverse(s);\\n\\t\\tlong p = 1;\\n\\t\\tfor(int i=nz.length()-1;i>=0;i--) {\\n\\t\\t\\tans = ans + (nz.charAt(i)=='0'?0:1)*p;\\n\\t\\t\\tp*=2;\\n\\t\\t}\\n\\t\\treturn ans;\\n\\t}\\n\\tpublic static void solve(int t) {\\n\\t\\tlong a = fs.nextLong();\\n\\t\\tlong b = fs.nextLong();\\n\\t\\tif (a == b) {\\n\\t\\t\\tSystem.out.println(\\\"YES\\\");return;\\n\\t\\t} else {\\n\\t\\t\\tHashSet<Long> H = new HashSet<Long>();\\n\\t\\t\\tQueue<Long> Q = new LinkedList<Long>();\\n\\t\\t\\tH.add(a);\\n\\t\\t\\tQ.add(a);\\n\\t\\t\\twhile(Q.isEmpty() == false) {\\n\\t\\t\\t\\tlong x = Q.peek();Q.remove();\\n\\t\\t\\t\\tString s = Long.toBinaryString(x);\\n\\t\\t\\t\\tif(s.length()>61)continue;\\n\\t\\t\\t\\tfor(int i=0;i<2;i++) {\\n\\t\\t\\t\\t\\tchar ch = (i==0?'0':'1');\\n\\t\\t\\t\\t\\tlong ok = OP(s,ch);\\n\\t\\t\\t\\t\\tif(H.contains(ok)==false) {\\n\\t\\t\\t\\t\\t\\tH.add(ok);Q.add(ok);\\n\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\t}\\n\\t\\t\\t}\\n\\t\\t\\tif(H.contains(b) == true) {\\n\\t\\t\\t\\tSystem.out.println(\\\"YES\\\");\\n\\t\\t\\t} else {\\n\\t\\t\\t\\tSystem.out.println(\\\"NO\\\");\\n\\t\\t\\t}\\n\\t\\t}\\n\\t\\treturn;\\n\\t}\\n\\t\\t\\n\\tstatic class FastScanner {\\n\\t\\tBufferedReader br=new BufferedReader(new InputStreamReader(System.in));\\n\\t\\tStringTokenizer st=new StringTokenizer(\\\"\\\");\\n\\t\\tString next() {\\n\\t\\t\\twhile (!st.hasMoreTokens())\\n\\t\\t\\t\\ttry {\\n\\t\\t\\t\\t\\tst=new StringTokenizer(br.readLine());\\n\\t\\t\\t\\t} catch (IOException e) {\\n\\t\\t\\t\\t\\te.printStackTrace();\\n\\t\\t\\t\\t}\\n\\t\\t\\treturn st.nextToken();\\n\\t\\t}\\n\\t\\t\\t\\n\\t\\tint nextInt() {\\n\\t\\t\\treturn Integer.parseInt(next());\\n\\t\\t}\\n\\t\\tint[] readArray(int n) {\\n\\t\\t\\tint[] a=new int[n];\\n\\t\\t\\tfor (int i=0; i<n; i++) a[i]=nextInt();\\n\\t\\t\\treturn a;\\n\\t\\t}\\n\\t\\tArrayList<Integer> readList(int n) {\\n\\t\\t\\tArrayList<Integer> a = new...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Alice and Bob decided to eat some fruit. In the kitchen they found a large bag of oranges and apples. Alice immediately took an orange for herself, Bob took an apple. To make the process of sharing the remaining fruit more fun, the friends decided to play a game. They put multiple cards and on each one they wrote a letter, either 'A', or the letter 'B'. Then they began to remove the cards one by one from left to right, every time they removed a card with the letter 'A', Alice gave Bob all the fruits she had at that moment and took out of the bag as many apples and as many oranges as she had before. Thus the number of oranges and apples Alice had, did not change. If the card had written letter 'B', then Bob did the same, that is, he gave Alice all the fruit that he had, and took from the bag the same set of fruit. After the last card way removed, all the fruit in the bag were over.\\n\\nYou know how many oranges and apples was in the bag at first. Your task is to find any sequence of cards that Alice and Bob could have played with.\\n\\nInput\\n\\nThe first line of the input contains two integers, x, y (1 \u2264 x, y \u2264 1018, xy > 1) \u2014 the number of oranges and apples that were initially in the bag.\\n\\nOutput\\n\\nPrint any sequence of cards that would meet the problem conditions as a compressed string of characters 'A' and 'B. That means that you need to replace the segments of identical consecutive characters by the number of repetitions of the characters and the actual character. For example, string AAABAABBB should be replaced by string 3A1B2A3B, but cannot be replaced by 2A1A1B2A3B or by 3AB2A3B. See the samples for clarifications of the output format. The string that you print should consist of at most 106 characters. It is guaranteed that if the answer exists, its compressed representation exists, consisting of at most 106 characters. If there are several possible answers, you are allowed to print any of them.\\n\\nIf the sequence of cards that meet the problem statement does not not exist, print a single word...\\nSolve the task in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nlong long a, b;\\nlong long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }\\nint main() {\\n  while (~scanf(\\\"%I64d%I64d\\\", &a, &b)) {\\n    if (gcd(a, b) != 1)\\n      printf(\\\"Impossible\\\");\\n    else {\\n      while (a && b) {\\n        if (a > b) {\\n          if (a % b)\\n            printf(\\\"%I64d\\\", a \\/ b);\\n          else\\n            printf(\\\"%I64d\\\", a \\/ b - 1);\\n          printf(\\\"A\\\");\\n          a -= (a \\/ b) * b;\\n        } else {\\n          if (b % a)\\n            printf(\\\"%I64d\\\", b \\/ a);\\n          else\\n            printf(\\\"%I64d\\\", b \\/ a - 1);\\n          printf(\\\"B\\\");\\n          b -= (b \\/ a) * a;\\n        }\\n      }\\n    }\\n    printf(\\\"\\\\n\\\");\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You are given two integers l and r, l\u2264 r. Find the largest possible value of a mod b over all pairs (a, b) of integers for which r\u2265 a \u2265 b \u2265 l.\\n\\nAs a reminder, a mod b is a remainder we get when dividing a by b. For example, 26 mod 8 = 2.\\n\\nInput\\n\\nEach test contains multiple test cases.\\n\\nThe first line contains one positive integer t (1\u2264 t\u2264 10^4), denoting the number of test cases. Description of the test cases follows.\\n\\nThe only line of each test case contains two integers l, r (1\u2264 l \u2264 r \u2264 10^9).\\n\\nOutput\\n\\nFor every test case, output the largest possible value of a mod b over all pairs (a, b) of integers for which r\u2265 a \u2265 b \u2265 l.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n1 1\\n999999999 1000000000\\n8 26\\n1 999999999\\n\\n\\nOutput\\n\\n\\n0\\n1\\n12\\n499999999\\n\\nNote\\n\\nIn the first test case, the only allowed pair is (a, b) = (1, 1), for which a mod b = 1 mod 1 = 0.\\n\\nIn the second test case, the optimal choice is pair (a, b) = (1000000000, 999999999), for which a mod b = 1.\\nimpor\",\"targets\":\"t bisect\\nimport math\\n\\nmod =  998244353\\nN = 200005\\n\\ndef mul(a, b):\\n\\treturn (a*b)%mod\\n\\ndef add(a, b):\\n\\treturn (a+b) if (a+b<mod) else (a+b)-mod\\n\\ndef sub(a, b):\\n\\treturn (a-b) if (a-b>0) else (a-b)+mod\\n\\ndef powr(a, b):\\n\\tans = 1\\n\\twhile b>0:\\n\\t\\tif b & 1:\\n\\t\\t\\tans=mul(ans,a)\\n\\t\\ta = mul(a,a) \\n\\t\\tb\\/\\/=2\\n\\treturn ans\\n\\ndef inv(n):\\n\\treturn powr(n, mod-2)\\n\\ndef factlist():\\n\\tfact = [1]\\n\\tfor i in range(1, N):\\n\\t\\tfact.append(mul(fact[i-1],i))\\n\\treturn fact\\n\\ndef invfactlist(fact):\\n\\tinvfact=[0]*N\\n\\tinvfact[0]=1\\n\\tinvfact[N-1]= inv(fact[N-1])\\n\\tfor i in range(N-2, 0, -1):\\n\\t\\tinvfact[i]= mul(invfact[i+1],(i+1))\\n\\t\\n\\treturn invfact\\n\\ndef rot(S):\\n\\treturn list(zip(*S[::-1]))\\n\\ndef gcd(a, b):\\n\\tif b==0:\\n\\t\\treturn a\\n\\treturn gcd(b, a%b)\\n\\n\\ndef main():\\n\\tt = int(input())\\n\\twhile t:\\n\\t\\tt-=1 \\n\\n\\t\\tl, r = map(int, input().split())\\n\\t\\tif l == r:\\n\\t\\t\\tprint('0')\\n\\t\\t\\tcontinue\\n\\t\\tif l>(r+1)\\/\\/2:\\n\\t\\t\\tprint(r-l)\\n\\t\\t\\tcontinue\\n\\t\\telse:\\n\\t\\t\\tk = (r+1)\\/\\/2\\n\\t\\t\\tprint(k-1)\\n\\n\\t\\n\\nif __name__ == \\\"__main__\\\":\\n\\tmain()\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in CPP?\\nEven if you just leave them be, they will fall to pieces all by themselves. So, someone has to protect them, right?\\n\\nYou find yourself playing with Teucer again in the city of Liyue. As you take the eccentric little kid around, you notice something interesting about the structure of the city.\\n\\nLiyue can be represented as a directed graph containing n nodes. Nodes are labeled from 1 to n. There is a directed edge from node a to node b if and only if a < b.\\n\\nA path between nodes a and b is defined as a sequence of edges such that you can start at a, travel along all of these edges in the corresponding direction, and end at b. The length of a path is defined by the number of edges. A rainbow path of length x is defined as a path in the graph such that there exists at least 2 distinct colors among the set of x edges.\\n\\nTeucer's favorite number is k. You are curious about the following scenario: If you were to label each edge with a color, what is the minimum number of colors needed to ensure that all paths of length k or longer are rainbow paths?\\n\\nTeucer wants to surprise his older brother with a map of Liyue. He also wants to know a valid coloring of edges that uses the minimum number of colors. Please help him with this task!\\n\\nInput\\n\\nThe only line of input contains two integers n and k (2 \u2264 k < n \u2264 1000). \\n\\nOutput\\n\\nOn the first line, output c, the minimum colors you need to satisfy the above requirements.\\n\\nOn the second line, print a valid edge coloring as an array of (n(n-1))\\/(2) integers ranging from 1 to c. Exactly c distinct colors should exist in the construction. Print the edges in increasing order by the start node first, then by the second node.\\n\\nFor example, if n=4, the edge colors will correspond to this order of edges: (1, 2), (1, 3), (1, 4), (2, 3), (2, 4), (3, 4)\\n\\nExamples\\n\\nInput\\n\\n\\n5 3\\n\\n\\nOutput\\n\\n\\n2\\n1 2 2 2 2 2 2 1 1 1\\n\\n\\nInput\\n\\n\\n5 2\\n\\n\\nOutput\\n\\n\\n3\\n3 2 2 1 2 2 1 3 1 1 \\n\\n\\nInput\\n\\n\\n8 7\\n\\n\\nOutput\\n\\n\\n2\\n2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1\\n\\n\\nInput\\n\\n\\n3 2\\n\\n\\nOutput\\n\\n\\n2\\n1 2 2 \\n\\nNote\\n\\nThe...\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint ans[1001][1001];\\nint n, k, mx;\\nvoid solve(int l, int r, int c) {\\n  int s = r - l + 1;\\n  mx = max(mx, c);\\n  if (s <= k) {\\n    for (int i = l; i < r; i++) {\\n      for (int j = i + 1; j <= r; j++) {\\n        ans[i][j] = c;\\n      }\\n    }\\n    return;\\n  }\\n  int x = s % k;\\n  vector<int> a(k, s \\/ k), p(k + 1, 0);\\n  for (int i = 0; i < x; i++) a[i]++;\\n  int i = l;\\n  for (int x : a) {\\n    solve(i, i + x - 1, c + 1);\\n    i += x;\\n  }\\n  p[0] = l;\\n  for (int i = 1; i <= k; i++) {\\n    p[i] = a[i - 1] + p[i - 1];\\n  }\\n  for (int i = 0; i < k; i++) {\\n    for (int j = i + 1; j < k; j++) {\\n      for (int ii = p[i]; ii <= p[i + 1] - 1; ii++) {\\n        for (int jj = p[j]; jj <= p[j + 1] - 1; jj++) {\\n          ans[ii][jj] = c;\\n        }\\n      }\\n    }\\n  }\\n}\\nint main() {\\n  ios_base::sync_with_stdio(0);\\n  cin.tie(0);\\n  cin >> n >> k;\\n  solve(1, n, 1);\\n  cout << mx << '\\\\n';\\n  for (int i = 1; i <= n; i++)\\n    for (int j = i + 1; j <= n; j++) cout << ans[i][j] << \\\" \\\";\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"It is a complicated version of problem F1. The difference between them is the constraints (F1: k \u2264 2, F2: k \u2264 10).\\n\\nYou are given an integer n. Find the minimum integer x such that x \u2265 n and the number x is k-beautiful.\\n\\nA number is called k-beautiful if its decimal representation having no leading zeroes contains no more than k different digits. E.g. if k = 2, the numbers 3434443, 55550, 777 and 21 are k-beautiful whereas the numbers 120, 445435 and 998244353 are not.\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases. Then t test cases follow.\\n\\nEach test case consists of one line containing two integers n and k (1 \u2264 n \u2264 10^9, 1 \u2264 k \u2264 10).\\n\\nOutput\\n\\nFor each test case output on a separate line x \u2014 the minimum k-beautiful integer such that x \u2265 n.\\n\\nExample\\n\\nInput\\n\\n\\n6\\n2021 3\\n177890 2\\n34512 3\\n724533 4\\n998244353 1\\n12345678 10\\n\\n\\nOutput\\n\\n\\n2021\\n181111\\n34533\\n724542\\n999999999\\n12345678\\nUsing python3 can you solve the prior task?\",\"targets\":\"from collections import Counter\\n\\ndef solve():\\n    n, k = input().split()\\n    k = int(k)\\n\\n    cnt = Counter(n)\\n    if len(cnt) <= k:\\n        print(n)\\n        return\\n    \\n    cnt = Counter()\\n\\n    ans = []\\n    for c in n:\\n        if c in cnt:\\n            cnt[c] += 1\\n            ans.append(c)\\n            continue\\n        if len(cnt) == k: break\\n        cnt[c] += 1\\n        ans.append(c)\\n    \\n    i = len(ans)\\n    for j in range(int(n[i])+1, 10):\\n        if str(j) in cnt:\\n            ans.append(str(j))\\n            m = min(cnt.keys())\\n            while len(ans) < len(n):\\n                ans.append(m)\\n            print(\\\"\\\".join(ans))\\n            return\\n    \\n    while i >= 0:\\n        i -= 1\\n        c = ans[i]\\n        cnt[c] -= 1\\n        if cnt[c] == 0:\\n            del cnt[c]\\n        \\n        for nxt in range(int(c)+1, 10):\\n            nxt = str(nxt)\\n            if nxt not in cnt:\\n                if len(cnt) == k: continue\\n            cnt[nxt] += 1\\n            ans[i] = nxt\\n            if len(cnt) < k:\\n                cnt[\\\"0\\\"] += 1\\n            m = min(cnt.keys())\\n            for j in range(i+1, len(ans)):\\n                ans[j] = m\\n            while len(ans) < len(n):\\n                ans.append(m)\\n            print(\\\"\\\".join(ans))\\n            return\\n    assert 1 < 0\\n\\n\\n\\nfor _ in range(int(input()) ):\\n    solve()\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"A median in an array with the length of n is an element which occupies position number <image> after we sort the elements in the non-decreasing order (the array elements are numbered starting with 1). A median of an array (2, 6, 1, 2, 3) is the number 2, and a median of array (0, 96, 17, 23) \u2014 the number 17.\\n\\nWe define an expression <image> as the integer part of dividing number a by number b.\\n\\nOne day Vasya showed Petya an array consisting of n integers and suggested finding the array's median. Petya didn't even look at the array and said that it equals x. Petya is a very honest boy, so he decided to add several numbers to the given array so that the median of the resulting array would be equal to x.\\n\\nPetya can add any integers from 1 to 105 to the array, including the same numbers. Of course, he can add nothing to the array. If a number is added multiple times, then we should consider it the number of times it occurs. It is not allowed to delete of change initial numbers of the array. \\n\\nWhile Petya is busy distracting Vasya, your task is to find the minimum number of elements he will need.\\n\\nInput\\n\\nThe first input line contains two space-separated integers n and x (1 \u2264 n \u2264 500, 1 \u2264 x \u2264 105) \u2014 the initial array's length and the required median's value. The second line contains n space-separated numbers \u2014 the initial array. The elements of the array are integers from 1 to 105. The array elements are not necessarily different.\\n\\nOutput\\n\\nPrint the only integer \u2014 the minimum number of elements Petya needs to add to the array so that its median equals x.\\n\\nExamples\\n\\nInput\\n\\n3 10\\n10 20 30\\n\\n\\nOutput\\n\\n1\\n\\n\\nInput\\n\\n3 4\\n1 2 3\\n\\n\\nOutput\\n\\n4\\n\\nNote\\n\\nIn the first sample we can add number 9 to array (10, 20, 30). The resulting array (9, 10, 20, 30) will have a median in position <image>, that is, 10.\\n\\nIn the second sample you should add numbers 4, 5, 5, 5. The resulting array has median equal to 4.\\nSolve the task in JAVA.\",\"targets\":\"import java.util.*;\\nimport java.io.*;\\nimport java.math.*;\\n\\/*\\n\\n11 3\\n1 2 2 2 2 2 3 3 3 3 3\\n\\n\\n13 1\\n1 1 1 1 2 2 3 3 3 3 3 3 3\\n\\n13 2\\n1 1 1 1 2 2 3 3 3 3 3 3 3\\n\\n12 3\\n1 1 1 1 2 2 3 3 3 3 3 3\\n\\n7 3\\n2 2 4 4 5 6 7\\n\\n7 8\\n2 2 4 4 5 6 7\\n\\n *\\/\\npublic class Main {\\n\\tpublic static Scanner scan = new Scanner(System.in);\\n\\tpublic static boolean bg = false;\\n\\n\\tpublic static void main(String[] args) throws Exception {\\n\\t\\tint n = Integer.parseInt(scan.next());\\n\\t\\tint x = Integer.parseInt(scan.next());\\n\\t\\tHashMap<Integer,Integer> m1 = new HashMap();\\n\\t\\tArrayList<Integer> l1 = new ArrayList();\\n\\t\\tint[] l2 = new int[n];\\n\\t\\tfor (int i=0;i<n;i++){\\n\\t\\t\\tint cur =Integer.parseInt(scan.next());\\n\\t\\t\\tint count = 0;\\n\\t\\t\\tif (m1.containsKey(cur)) count = m1.get(cur);\\n\\t\\t\\tif (!m1.containsKey(cur)) l1 .add(cur);\\n\\t\\t\\tm1.put(cur, count+1);\\n\\t\\t\\tl2[i]=cur;\\n\\t\\t}\\n\\t\\tArrays.sort(l2);\\n\\t\\tif (bg) System.out.println(Arrays.toString(l2));\\n\\t\\tif (l2[(n+1)\\/2-1]==x){\\n\\t\\t\\tSystem.out.println(0);\\n\\t\\t\\tSystem.exit(0);\\n\\t\\t}\\n\\t\\t\\n\\t\\tArrayList<Integer> cu1 = new ArrayList();\\n\\t\\tCollections.sort(l1);\\n\\t\\tint total = 0;\\n\\t\\tfor (int i=0;i<l1.size();i++){\\n\\t\\t\\ttotal+=m1.get(l1.get(i));\\n\\t\\t\\tcu1.add(total);\\n\\t\\t}\\n\\t\\t\\n\\t\\tint id = Collections.binarySearch(l1, x);\\n\\t\\tif (bg) System.out.println(m1);\\n\\t\\tif (bg) System.out.println(l1);\\n\\t\\tif (bg) System.out.println(cu1);\\n\\t\\t\\n\\t\\tif (id>=0){\\n\\t\\t\\tif (bg) System.out.println(\\\"exist\\\");\\n\\t\\t\\tint above = 0;\\n\\t\\t\\tint below = 0;\\n\\t\\t\\tbelow = cu1.get(id);\\n\\t\\t\\tabove = total-cu1.get(id);\\n\\t\\t\\tif (bg) System.out.println(below +\\\" \\\"+above);\\n\\t\\t\\tif (below<above){\\n\\t\\t\\t\\tint top = above;\\n\\t\\t\\t\\tint low = below-1;\\n\\t\\t\\t\\tif (bg) System.out.println(\\\"top \\\"+top+\\\" low \\\"+low);\\n\\t\\t\\t\\tSystem.out.println(top-low-1);\\n\\t\\t\\t}\\n\\t\\t\\telse {\\n\\t\\t\\t\\tint top = total-1;\\n\\t\\t\\t\\tif (id!=0) top = total-cu1.get(id-1)-1;\\n\\t\\t\\t\\tint low = 0;\\n\\t\\t\\t\\tif (id!=0) low = cu1.get(id-1);\\n\\t\\t\\t\\tif (bg) System.out.println(\\\"top \\\"+top+\\\" low \\\"+low);\\n\\t\\t\\t\\tSystem.out.println(low-top);\\n\\t\\t\\t}\\n\\t\\t}\\n\\t\\telse {\\n\\t\\t\\tif (bg) System.out.println(\\\"exist\\\");\\n\\t\\t\\tint above = 0;\\n\\t\\t\\tint below = 0;\\n\\t\\t\\tint xid = -id-1;\\n\\t\\t\\tif (bg) System.out.println(\\\"xid \\\"+xid);\\n\\t\\t\\tif (xid!=0) below =...\",\"language\":\"python\",\"split\":\"train\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You are given two positive integers n and s. Find the maximum possible median of an array of n non-negative integers (not necessarily distinct), such that the sum of its elements is equal to s.\\n\\nA median of an array of integers of length m is the number standing on the \u2308 {m\\/2} \u2309-th (rounding up) position in the non-decreasing ordering of its elements. Positions are numbered starting from 1. For example, a median of the array [20,40,20,50,50,30] is the \u2308 m\\/2 \u2309-th element of [20,20,30,40,50,50], so it is 30. There exist other definitions of the median, but in this problem we use the described definition.\\n\\nInput\\n\\nThe input consists of multiple test cases. The first line contains a single integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases. Description of the test cases follows.\\n\\nEach test case contains a single line with two integers n and s (1 \u2264 n, s \u2264 10^9) \u2014 the length of the array and the required sum of the elements.\\n\\nOutput\\n\\nFor each test case print a single integer \u2014 the maximum possible median.\\n\\nExample\\n\\nInput\\n\\n\\n8\\n1 5\\n2 5\\n3 5\\n2 1\\n7 17\\n4 14\\n1 1000000000\\n1000000000 1\\n\\n\\nOutput\\n\\n\\n5\\n2\\n2\\n0\\n4\\n4\\n1000000000\\n0\\n\\nNote\\n\\nPossible arrays for the first three test cases (in each array the median is underlined):\\n\\n  * In the first test case [\\\\underline{5}] \\n  * In the second test case [\\\\underline{2}, 3] \\n  * In the third test case [1, \\\\underline{2}, 2]\",\"targets\":\"for t in range(int(input())):\\n\\n    n,s = map(int,input().split())\\n    print(s\\/\\/((n\\/\\/2)+1))\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Eighth-grader Vova is on duty today in the class. After classes, he went into the office to wash the board, and found on it the number n. He asked what is this number and the teacher of mathematics Inna Petrovna answered Vova that n is the answer to the arithmetic task for first-graders. In the textbook, a certain positive integer x was given. The task was to add x to the sum of the digits of the number x written in decimal numeral system.\\n\\nSince the number n on the board was small, Vova quickly guessed which x could be in the textbook. Now he wants to get a program which will search for arbitrary values of the number n for all suitable values of x or determine that such x does not exist. Write such a program for Vova.\\n\\nInput\\n\\nThe first line contains integer n (1 \u2264 n \u2264 109).\\n\\nOutput\\n\\nIn the first line print one integer k \u2014 number of different values of x satisfying the condition. \\n\\nIn next k lines print these values in ascending order.\\n\\nExamples\\n\\nInput\\n\\n21\\n\\n\\nOutput\\n\\n1\\n15\\n\\n\\nInput\\n\\n20\\n\\n\\nOutput\\n\\n0\\n\\nNote\\n\\nIn the first test case x = 15 there is only one variant: 15 + 1 + 5 = 21.\\n\\nIn the second test case there are no such x.\\n#incl\",\"targets\":\"ude <bits\\/stdc++.h>\\nusing namespace std;\\nconst int N = 1e6 + 10, MOD = 1e9 + 7;\\nvector<int> vec;\\nlong long int n;\\nlong long int check(long long int x) {\\n  long long int sum = 0, tmp = x;\\n  while (x) {\\n    sum += x % 10;\\n    x \\/= 10;\\n  }\\n  return tmp + sum;\\n}\\nint main() {\\n  scanf(\\\"%lld\\\", &n);\\n  for (int i = n - 82; i <= n; i++) {\\n    if (check(i) == n) vec.push_back(i);\\n  }\\n  printf(\\\"%d\\\\n\\\", (int)vec.size());\\n  for (int x : vec) printf(\\\"%d\\\\n\\\", x);\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You are given an array a[0 \u2026 n - 1] = [a_0, a_1, \u2026, a_{n - 1}] of zeroes and ones only. Note that in this problem, unlike the others, the array indexes are numbered from zero, not from one.\\n\\nIn one step, the array a is replaced by another array of length n according to the following rules: \\n\\n  1. First, a new array a^{\u2192 d} is defined as a cyclic shift of the array a to the right by d cells. The elements of this array can be defined as a^{\u2192 d}_i = a_{(i + n - d) mod n}, where (i + n - d) mod n is the remainder of integer division of i + n - d by n. \\n\\nIt means that the whole array a^{\u2192 d} can be represented as a sequence $$$a^{\u2192 d} = [a_{n - d}, a_{n - d + 1}, \u2026, a_{n - 1}, a_0, a_1, \u2026, a_{n - d - 1}]$$$\\n\\n  2. Then each element of the array a_i is replaced by a_i  \\\\&  a^{\u2192 d}_i, where \\\\& is a logical \\\"AND\\\" operator. \\n\\n\\n\\nFor example, if a = [0, 0, 1, 1] and d = 1, then a^{\u2192 d} = [1, 0, 0, 1] and the value of a after the first step will be [0  \\\\&  1, 0  \\\\&  0, 1  \\\\&  0, 1  \\\\&  1], that is [0, 0, 0, 1].\\n\\nThe process ends when the array stops changing. For a given array a, determine whether it will consist of only zeros at the end of the process. If yes, also find the number of steps the process will take before it finishes.\\n\\nInput\\n\\nThe first line contains an integer t (1 \u2264 t \u2264 1000) \u2014 the number of test cases.\\n\\nThe next 2t lines contain descriptions of the test cases. \\n\\nThe first line of each test case description contains two integers: n (1 \u2264 n \u2264 10^6) \u2014 array size and d (1 \u2264 d \u2264 n) \u2014 cyclic shift offset. The second line of the description contains n space-separated integers a_i (0 \u2264 a_i \u2264 1) \u2014 elements of the array.\\n\\nIt is guaranteed that the sum of n over all test cases does not exceed 10^6.\\n\\nOutput\\n\\nPrint t lines, each line containing the answer to the corresponding test case. The answer to a test case should be a single integer \u2014 the number of steps after which the array will contain only zeros for the first time. If there are still elements equal to 1 in the array after the end of the process, print...\\nSolve the task in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\n#pragma warning(disable : 4996)\\nconst long long MOD = 998244353;\\nusing namespace std;\\nvoid solve() {\\n  int n, d;\\n  scanf(\\\"%d%d\\\", &n, &d);\\n  vector<int> a(n);\\n  for (int i = 0; i < n; i++) {\\n    scanf(\\\"%d\\\", &a[i]);\\n  }\\n  vector<int> f(n);\\n  vector<vector<int>> vv;\\n  for (int i = 0; i < n; i++) {\\n    if (f[i]) continue;\\n    int curr = i;\\n    vv.push_back(vector<int>());\\n    vector<int>& v = vv.back();\\n    v.push_back(curr);\\n    f[curr] = 1;\\n    while (1) {\\n      curr = (curr + d) % n;\\n      if (f[curr]) break;\\n      v.push_back(curr);\\n      f[curr] = 1;\\n    }\\n  }\\n  int bad = 0;\\n  int ans = 0;\\n  for (int i = 0; i < (int)vv.size(); i++) {\\n    vector<int>& v = vv[i];\\n    int num = (int)v.size();\\n    int M = 0;\\n    int cnt = 0;\\n    for (int k = 0; k < num * 2; k++) {\\n      if (a[v[k % num]])\\n        cnt++;\\n      else\\n        cnt = 0;\\n      M = max(M, cnt);\\n    }\\n    if (M >= num) bad = 1;\\n    ans = max(ans, M);\\n  }\\n  if (bad) {\\n    printf(\\\"-1\\\\n\\\");\\n  } else {\\n    printf(\\\"%d\\\\n\\\", ans);\\n  }\\n  return;\\n}\\nint main() {\\n  int T, t;\\n  scanf(\\\"%d\\\", &T);\\n  for (t = 0; t < T; t++) {\\n    solve();\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You are given a tree with n nodes. As a reminder, a tree is a connected undirected graph without cycles.\\n\\nLet a_1, a_2, \u2026, a_n be a sequence of integers. Perform the following operation exactly n times: \\n\\n  * Select an unerased node u. Assign a_u := number of unerased nodes adjacent to u. Then, erase the node u along with all edges that have it as an endpoint. \\n\\n\\n\\nFor each integer k from 1 to n, find the number, modulo 998 244 353, of different sequences a_1, a_2, \u2026, a_n that satisfy the following conditions:\\n\\n  * it is possible to obtain a by performing the aforementioned operations exactly n times in some order. \\n  * \\\\operatorname{gcd}(a_1, a_2, \u2026, a_n) = k. Here, \\\\operatorname{gcd} means the greatest common divisor of the elements in a. \\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 10 000) \u2014 the number of test cases.\\n\\nThe first line of each test case contains a single integer n (2 \u2264 n \u2264 10^5).\\n\\nEach of the next n - 1 lines contains two integers u and v (1 \u2264 u, v \u2264 n) indicating there is an edge between vertices u and v. It is guaranteed that the given edges form a tree.\\n\\nIt is guaranteed that the sum of n over all test cases doesn't exceed 3 \u22c5 10^5.\\n\\nOutput\\n\\nFor each test case, print n integers in a single line, where for each k from 1 to n, the k-th integer denotes the answer when \\\\operatorname{gcd} equals to k.\\n\\nExample\\n\\nInput\\n\\n\\n2\\n3\\n2 1\\n1 3\\n2\\n1 2\\n\\n\\nOutput\\n\\n\\n3 1 0\\n2 0\\n\\nNote\\n\\nIn the first test case, \\n\\n<image>\\n\\n  * If we delete the nodes in order 1 \u2192 2 \u2192 3 or 1 \u2192 3 \u2192 2, then the obtained sequence will be a = [2, 0, 0] which has \\\\operatorname{gcd} equals to 2. \\n  * If we delete the nodes in order 2 \u2192 1 \u2192 3, then the obtained sequence will be a = [1, 1, 0] which has \\\\operatorname{gcd} equals to 1. \\n  * If we delete the nodes in order 3 \u2192 1 \u2192 2, then the obtained sequence will be a = [1, 0, 1] which has \\\\operatorname{gcd} equals to 1. \\n  * If we delete the nodes in order 2 \u2192 3 \u2192 1 or 3 \u2192 2 \u2192 1, then the obtained sequence will be a = [0, 1, 1] which has \\\\operatorname{gcd} equals to 1. \\n\\n\\n\\nNote...\\nSolve the task in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst int N = 1e5 + 5;\\nconst int mod = 998244353;\\nint n;\\nvector<int> dsk[N];\\nlong long f[N];\\nint cur[N];\\nbool ok = 1;\\nvoid dfs(int u, int pre, int val) {\\n  if (((int)(dsk[u]).size()) == 1 && u != 1) {\\n    cur[u] = 1;\\n    return;\\n  }\\n  for (int v : dsk[u])\\n    if (v != pre) {\\n      dfs(v, u, val);\\n      cur[u] += cur[v];\\n    }\\n  if (cur[u] % val == 0)\\n    cur[u] = 1;\\n  else if (u != pre && (cur[u] + 1) % val == 0)\\n    cur[u] = 0;\\n  else\\n    ok = 0;\\n}\\nint solve(int val) {\\n  for (int i = 1; i <= n; ++i) cur[i] = 0;\\n  ok = 1;\\n  dfs(1, 1, val);\\n  return ok;\\n}\\nvoid gogo() {\\n  cin >> n;\\n  for (int i = 1; i <= n; ++i) dsk[i].clear();\\n  for (int i = 1; i < n; ++i) {\\n    int u, v;\\n    cin >> u >> v;\\n    dsk[u].push_back(v);\\n    dsk[v].push_back(u);\\n  }\\n  for (int i = 1; i <= n; ++i) f[i] = 0;\\n  f[1] = 1;\\n  for (int i = 1; i < n; ++i) (f[1] *= 2) %= mod;\\n  for (int i = 2; i <= n - 1; ++i)\\n    if ((n - 1) % i == 0) f[i] = solve(i);\\n  for (int i = n; i >= 1; --i)\\n    for (int j = 2 * i; j <= n; j += i) f[i] = (f[i] - f[j] + mod) % mod;\\n  for (int i = 1; i <= n; ++i) {\\n    if (i >= 2) assert(f[i] <= 1);\\n    cout << f[i] << ' ';\\n  }\\n  cout << '\\\\n';\\n}\\nint main() {\\n  ios_base::sync_with_stdio(0);\\n  cin.tie(0);\\n  if (fopen(\\\"sol\\\"\\n            \\\".inp\\\",\\n            \\\"r\\\")) {\\n    freopen(\\n        \\\"sol\\\"\\n        \\\".inp\\\",\\n        \\\"r\\\", stdin);\\n    freopen(\\n        \\\"sol\\\"\\n        \\\".out\\\",\\n        \\\"w\\\", stdout);\\n  }\\n  int t;\\n  cin >> t;\\n  while (t--) gogo();\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Dr. Bruce Banner hates his enemies (like others don't). As we all know, he can barely talk when he turns into the incredible Hulk. That's why he asked you to help him to express his feelings.\\n\\nHulk likes the Inception so much, and like that his feelings are complicated. They have n layers. The first layer is hate, second one is love, third one is hate and so on...\\n\\nFor example if n = 1, then his feeling is \\\"I hate it\\\" or if n = 2 it's \\\"I hate that I love it\\\", and if n = 3 it's \\\"I hate that I love that I hate it\\\" and so on.\\n\\nPlease help Dr. Banner.\\n\\nInput\\n\\nThe only line of the input contains a single integer n (1 \u2264 n \u2264 100) \u2014 the number of layers of love and hate.\\n\\nOutput\\n\\nPrint Dr.Banner's feeling in one line.\\n\\nExamples\\n\\nInput\\n\\n1\\n\\n\\nOutput\\n\\nI hate it\\n\\n\\nInput\\n\\n2\\n\\n\\nOutput\\n\\nI hate that I love it\\n\\n\\nInput\\n\\n3\\n\\n\\nOutput\\n\\nI hate that I love that I hate it\\nUsing python3 can you solve the prior task?\",\"targets\":\"n=int(input())\\nif n==1:\\n    print(\\\"I hate it\\\",end=\\\" \\\")\\n    exit()\\ncount=1\\nwhile n!=0:\\n    if count%2!=0:\\n        if n==1:\\n            print(\\\"I hate it\\\")\\n        else:\\n            print(\\\"I hate that\\\",end=\\\" \\\")\\n    else:\\n        if n==1:\\n            print(\\\"I love it\\\")\\n        else:\\n            print(\\\"I love that\\\",end=\\\" \\\")\\n    n=n-1\\n    count+=1\",\"language\":\"python\",\"split\":\"train\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Given a positive integer n. Find three distinct positive integers a, b, c such that a + b + c = n and \\\\operatorname{gcd}(a, b) = c, where \\\\operatorname{gcd}(x, y) denotes the [greatest common divisor (GCD)](https:\\/\\/en.wikipedia.org\\/wiki\\/Greatest_common_divisor) of integers x and y.\\n\\nInput\\n\\nThe input consists of multiple test cases. The first line contains a single integer t (1 \u2264 t \u2264 10^5) \u2014 the number of test cases. Description of the test cases follows.\\n\\nThe first and only line of each test case contains a single integer n (10 \u2264 n \u2264 10^9).\\n\\nOutput\\n\\nFor each test case, output three distinct positive integers a, b, c satisfying the requirements. If there are multiple solutions, you can print any. We can show that an answer always exists.\\n\\nExample\\n\\nInput\\n\\n\\n6\\n18\\n63\\n73\\n91\\n438\\n122690412\\n\\n\\nOutput\\n\\n\\n6 9 3\\n21 39 3\\n29 43 1\\n49 35 7\\n146 219 73\\n28622 122661788 2\\n\\nNote\\n\\nIn the first test case, 6 + 9 + 3 = 18 and \\\\operatorname{gcd}(6, 9) = 3.\\n\\nIn the second test case, 21 + 39 + 3 = 63 and \\\\operatorname{gcd}(21, 39) = 3.\\n\\nIn the third test case, 29 + 43 + 1 = 73 and \\\\operatorname{gcd}(29, 43) = 1.\\n\\/**\",\"targets\":\"* 12\\/16\\/21 morning\\n * https:\\/\\/codeforces.com\\/contest\\/1617\\/problem\\/B\\n *\\/\\n\\/\\/ package codeforce.cf.div2.r761;\\n\\nimport java.util.*;\\nimport java.io.*;\\n\\npublic class B {\\n    static PrintWriter pw;\\n\\n    void solve(int n) {\\n        \\/\\/ tr(\\\"n\\\", n);\\n        if (n % 2 != 0) { \\/\\/ odd + even + even\\n            int f = n \\/ 2;\\n            if (f % 2 == 0) {\\n                int a = f - 1, b = f + 1, c = 1;\\n                \\/\\/ tr(\\\"f\\\", f, a, b, c, test(a, b, c, n));\\n                pr(a + \\\" \\\" + b + \\\" \\\" + c);\\n            } else {\\n                int a = f - 2, b = f + 2, c = 1;\\n                \\/\\/ tr(\\\"f\\\", f, a, b, c, test(a, b, c, n));\\n                pr(a + \\\" \\\" + b + \\\" \\\" + c);\\n            }\\n        } else {\\n            int sum = n - 1;\\n            int f = sum \\/ 2;\\n            \\/\\/ tr(test(f, f + 1, 1, n));\\n            pr(f + \\\" \\\" + (f + 1) + \\\" \\\" + 1);\\n        }\\n    }\\n\\n    boolean test(int a, int b, int c, int n) {\\n        \\/\\/ tr(\\\"sum\\\", a + b + c, \\\"expect\\\", n, \\\"gcd\\\", gcd(a, b), \\\"expect\\\", c);\\n        if (a + b + c != n) return false;\\n        if (gcd(a, b) != c) return false;\\n        return true;\\n    }\\n\\n    int gcd(int a, int b) {\\n        return b == 0 ? a : gcd(b, a % b);\\n    }\\n\\n    private void run() {\\n        \\/\\/ read_write_file(); \\/\\/ comment this before submission\\n        FastScanner fs = new FastScanner();\\n        int t = fs.nextInt();\\n        while (t-- > 0) {\\n            int n = fs.nextInt();\\n            solve(n);\\n        }\\n    }\\n\\n    private final String INPUT = \\\"input.txt\\\";\\n    private final String OUTPUT = \\\"output.txt\\\";\\n\\n    void read_write_file() {\\n        FileInputStream instream = null;\\n        PrintStream outstream = null;\\n        try {\\n            instream = new FileInputStream(INPUT);\\n            outstream = new PrintStream(new FileOutputStream(OUTPUT));\\n            System.setIn(instream);\\n            System.setOut(outstream);\\n        } catch (Exception e) {\\n        }\\n    }\\n\\n    public static void main(String[] args) {\\n        pw = new PrintWriter(System.out);\\n        new B().run();\\n        pw.close();\\n    }\\n\\n    void...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You are given a string s, consisting of n letters, each letter is either 'a' or 'b'. The letters in the string are numbered from 1 to n.\\n\\ns[l; r] is a continuous substring of letters from index l to r of the string inclusive. \\n\\nA string is called balanced if the number of letters 'a' in it is equal to the number of letters 'b'. For example, strings \\\"baba\\\" and \\\"aabbab\\\" are balanced and strings \\\"aaab\\\" and \\\"b\\\" are not.\\n\\nFind any non-empty balanced substring s[l; r] of string s. Print its l and r (1 \u2264 l \u2264 r \u2264 n). If there is no such substring, then print -1 -1.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 1000) \u2014 the number of testcases.\\n\\nThen the descriptions of t testcases follow.\\n\\nThe first line of the testcase contains a single integer n (1 \u2264 n \u2264 50) \u2014 the length of the string.\\n\\nThe second line of the testcase contains a string s, consisting of n letters, each letter is either 'a' or 'b'.\\n\\nOutput\\n\\nFor each testcase print two integers. If there exists a non-empty balanced substring s[l; r], then print l r (1 \u2264 l \u2264 r \u2264 n). Otherwise, print -1 -1.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n1\\na\\n6\\nabbaba\\n6\\nabbaba\\n9\\nbabbabbaa\\n\\n\\nOutput\\n\\n\\n-1 -1\\n1 6\\n3 6\\n2 5\\n\\nNote\\n\\nIn the first testcase there are no non-empty balanced subtrings.\\n\\nIn the second and third testcases there are multiple balanced substrings, including the entire string \\\"abbaba\\\" and substring \\\"baba\\\".\\nSolve the task in PYTHON3.\",\"targets\":\"t=int(input())\\nwhile t>0:\\n    n=int(input())\\n    s=input()\\n    for i in range(n-1):\\n        if s[i]!=s[i+1]:\\n            print(i+1,i+2)\\n            break\\n    else:\\n        print(\\\"-1 -1\\\")\\n        \\n    t-=1\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"A tree is an undirected connected graph without cycles.\\n\\nYou are given a tree of n vertices. Find the number of ways to choose exactly k vertices in this tree (i. e. a k-element subset of vertices) so that all pairwise distances between the selected vertices are equal (in other words, there exists an integer c such that for all u, v (u \u2260 v, u, v are in selected vertices) d_{u,v}=c, where d_{u,v} is the distance from u to v).\\n\\nSince the answer may be very large, you need to output it modulo 10^9 + 7.\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 10) \u2014 the number of test cases. Then t test cases follow.\\n\\nEach test case is preceded by an empty line.\\n\\nEach test case consists of several lines. The first line of the test case contains two integers n and k (2 \u2264 k \u2264 n \u2264 100) \u2014 the number of vertices in the tree and the number of vertices to be selected, respectively. Then n - 1 lines follow, each of them contains two integers u and v (1 \u2264 u, v \u2264 n, u \u2260 v) which describe a pair of vertices connected by an edge. It is guaranteed that the given graph is a tree and has no loops or multiple edges.\\n\\nOutput\\n\\nFor each test case output in a separate line a single integer \u2014 the number of ways to select exactly k vertices so that for all pairs of selected vertices the distances between the vertices in the pairs are equal, modulo 10^9 + 7 (in other words, print the remainder when divided by 1000000007).\\n\\nExample\\n\\nInput\\n\\n\\n3\\n\\n4 2\\n1 2\\n2 3\\n2 4\\n\\n3 3\\n1 2\\n2 3\\n\\n5 3\\n1 2\\n2 3\\n2 4\\n4 5\\n\\n\\nOutput\\n\\n\\n6\\n0\\n1\\nSolve the task in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst long long mod = 1e9 + 7;\\nlong long n, k, nr[105][105], dp[105][105], t;\\nvector<int> muchii[200005];\\nbool use[200005];\\nvoid dfs(int nod) {\\n  use[nod] = 1;\\n  nr[nod][0] = 1;\\n  for (auto i : muchii[nod])\\n    if (!use[i]) {\\n      dfs(i);\\n      for (int dist = 1; dist <= n; dist++)\\n        nr[nod][dist] = (nr[nod][dist] + nr[i][dist - 1]) % mod;\\n    }\\n}\\nvoid solve() {\\n  cin >> n >> k;\\n  for (int i = 1; i <= n; i++) muchii[i].clear();\\n  for (int i = 1; i < n; i++) {\\n    int a, b;\\n    cin >> a >> b;\\n    muchii[a].push_back(b);\\n    muchii[b].push_back(a);\\n  }\\n  if (k == 2) {\\n    cout << n * (n - 1) \\/ 2 << '\\\\n';\\n    return;\\n  }\\n  long long ans = 0;\\n  for (int i = 1; i <= n; i++) {\\n    for (int j = 1; j <= n; j++) {\\n      use[j] = 0;\\n      for (int dist = 0; dist <= n; dist++) nr[j][dist] = 0;\\n    }\\n    dfs(i);\\n    for (int dist = 0; dist <= n; dist++) {\\n      dp[0][0] = 1;\\n      for (int j = 0; j < muchii[i].size(); j++) {\\n        dp[j + 1][0] = 1;\\n        for (int x = 1; x <= k; x++)\\n          dp[j + 1][x] =\\n              (dp[j][x] + dp[j][x - 1] * nr[muchii[i][j]][dist]) % mod;\\n      }\\n      ans = (ans + dp[muchii[i].size()][k]) % mod;\\n    }\\n  }\\n  cout << ans << '\\\\n';\\n}\\nint main() {\\n  cin >> t;\\n  while (t--) solve();\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"During the hypnosis session, Nicholas suddenly remembered a positive integer n, which doesn't contain zeros in decimal notation. \\n\\nSoon, when he returned home, he got curious: what is the maximum number of digits that can be removed from the number so that the number becomes not prime, that is, either composite or equal to one?\\n\\nFor some numbers doing so is impossible: for example, for number 53 it's impossible to delete some of its digits to obtain a not prime integer. However, for all n in the test cases of this problem, it's guaranteed that it's possible to delete some of their digits to obtain a not prime number.\\n\\nNote that you cannot remove all the digits from the number.\\n\\nA prime number is a number that has no divisors except one and itself. A composite is a number that has more than two divisors. 1 is neither a prime nor a composite number.\\n\\nInput\\n\\nEach test contains multiple test cases.\\n\\nThe first line contains one positive integer t (1 \u2264 t \u2264 10^3), denoting the number of test cases. Description of the test cases follows.\\n\\nThe first line of each test case contains one positive integer k (1 \u2264 k \u2264 50) \u2014 the number of digits in the number.\\n\\nThe second line of each test case contains a positive integer n, which doesn't contain zeros in decimal notation (10^{k-1} \u2264 n < 10^{k}). It is guaranteed that it is always possible to remove less than k digits to make the number not prime.\\n\\nIt is guaranteed that the sum of k over all test cases does not exceed 10^4.\\n\\nOutput\\n\\nFor every test case, print two numbers in two lines. In the first line print the number of digits, that you have left in the number. In the second line print the digits left after all delitions. \\n\\nIf there are multiple solutions, print any.\\n\\nExample\\n\\nInput\\n\\n\\n7\\n3\\n237\\n5\\n44444\\n3\\n221\\n2\\n35\\n3\\n773\\n1\\n4\\n30\\n626221626221626221626221626221\\n\\n\\nOutput\\n\\n\\n2\\n27\\n1\\n4\\n1\\n1\\n2\\n35\\n2\\n77\\n1\\n4\\n1\\n6\\n\\nNote\\n\\nIn the first test case, you can't delete 2 digits from the number 237, as all the numbers 2, 3, and 7 are prime. However, you can delete 1 digit, obtaining a number 27 =...\\nUsing java can you solve the prior task?\",\"targets\":\"import java.util.Arrays;\\nimport java.util.HashMap;\\nimport java.util.LinkedList;\\nimport java.util.Map;\\nimport java.util.Queue;\\nimport java.util.Scanner;\\npublic class Main\\n{\\n\\tstatic boolean isprime[]=new boolean[110];\\n\\tstatic int prime[]=new int[110];\\n\\tstatic int cnt=0;\\n\\tstatic String d[]={\\\"1\\\",\\\"4\\\",\\\"6\\\",\\\"8\\\",\\\"9\\\"};\\n\\tpublic static void main(String[] args)\\n\\t{\\n\\t\\tScanner in = new Scanner(System.in);\\n\\t\\tint t=in.nextInt();\\n\\t\\tfor(int i=2;i<100;i++)\\n\\t    {\\n\\t        if(!isprime[i])\\n\\t        {\\n\\t            prime[++cnt]=i;\\n\\t        }\\n\\t        for(int j=1;j<=cnt&&i*prime[j]<100;j++)\\n\\t        {\\n\\t            isprime[i*prime[j]]=true;\\n\\t            if(i%prime[j]==0)break;\\n\\t        }\\n\\t    }\\n\\t\\tMap<String,Integer>m=new HashMap<String, Integer>();\\n\\t\\tm.put(String.valueOf(1),1);\\n\\t\\tfor(int i=2;i<100;i++)\\n\\t\\t{\\n\\t\\t\\tif(isprime[i]==true)\\n\\t\\t\\t{\\n\\t\\t\\t\\tm.put(String.valueOf(i),1);\\n\\t\\t\\t}\\n\\t\\t}\\n\\t\\twhile(t-->0)\\n\\t\\t{\\n\\t\\t\\tint n=in.nextInt();\\n\\t\\t\\tString zifu=in.next();\\n\\t\\t\\tint min=0x3f3f3f3f;\\n\\t\\t\\tboolean flag1=false;\\n\\t\\t\\tboolean flag2=false;\\n\\t\\t\\tfor(int i=0;i<d.length;i++)\\n\\t\\t\\t{\\n\\t\\t\\t\\tif(zifu.contains(d[i]))\\n\\t\\t\\t\\t{\\n\\t\\t\\t\\t\\tSystem.out.println(1);\\n\\t\\t\\t\\t\\tSystem.out.println(d[i]);\\n\\t\\t\\t\\t\\tflag1=true;\\n\\t\\t\\t\\t\\tbreak;\\n\\t\\t\\t\\t}\\n\\t\\t\\t}\\n\\t\\t\\tif(!flag1)\\n\\t\\t\\t{\\n\\t\\t\\t\\tfor(int i=0;i<n;i++)\\n\\t\\t\\t\\t{\\n\\t\\t\\t\\t\\tfor(int j=i+1;j<n;j++)\\n\\t\\t\\t\\t\\t{\\n\\t\\t\\t\\t\\t\\tString z=zifu.substring(i,i+1)+zifu.substring(j,j+1);\\n\\t\\t\\t\\t\\t\\tif(m.containsKey(z))\\n\\t\\t\\t\\t\\t\\t{\\n\\t\\t\\t\\t\\t\\t\\tSystem.out.println(2);\\n\\t\\t\\t\\t\\t\\t\\tSystem.out.println(z);\\n\\t\\t\\t\\t\\t\\t\\tflag2=true;\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\t\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\t\\tif(flag2)break;\\n\\t\\t\\t\\t}\\n\\t\\t\\t}\\n\\t\\t\\t\\n\\t\\t}\\n\\t}\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"A frog lives on the axis Ox and needs to reach home which is in the point n. She starts from the point 1. The frog can jump to the right at a distance not more than d. So, after she jumped from the point x she can reach the point x + a, where a is an integer from 1 to d.\\n\\nFor each point from 1 to n is known if there is a lily flower in it. The frog can jump only in points with a lilies. Guaranteed that there are lilies in the points 1 and n.\\n\\nDetermine the minimal number of jumps that the frog needs to reach home which is in the point n from the point 1. Consider that initially the frog is in the point 1. If the frog can not reach home, print -1.\\n\\nInput\\n\\nThe first line contains two integers n and d (2 \u2264 n \u2264 100, 1 \u2264 d \u2264 n - 1) \u2014 the point, which the frog wants to reach, and the maximal length of the frog jump.\\n\\nThe second line contains a string s of length n, consisting of zeros and ones. If a character of the string s equals to zero, then in the corresponding point there is no lily flower. In the other case, in the corresponding point there is a lily flower. Guaranteed that the first and the last characters of the string s equal to one.\\n\\nOutput\\n\\nIf the frog can not reach the home, print -1.\\n\\nIn the other case, print the minimal number of jumps that the frog needs to reach the home which is in the point n from the point 1.\\n\\nExamples\\n\\nInput\\n\\n8 4\\n10010101\\n\\n\\nOutput\\n\\n2\\n\\n\\nInput\\n\\n4 2\\n1001\\n\\n\\nOutput\\n\\n-1\\n\\n\\nInput\\n\\n8 4\\n11100101\\n\\n\\nOutput\\n\\n3\\n\\n\\nInput\\n\\n12 3\\n101111100101\\n\\n\\nOutput\\n\\n4\\n\\nNote\\n\\nIn the first example the from can reach home in two jumps: the first jump from the point 1 to the point 4 (the length of the jump is three), and the second jump from the point 4 to the point 8 (the length of the jump is four).\\n\\nIn the second example the frog can not reach home, because to make it she need to jump on a distance three, but the maximum length of her jump equals to two.\\nimpor\",\"targets\":\"t java.util.*;\\nimport java.io.*;\\nimport java.math.*;\\nimport java.awt.geom.*;\\n\\nimport static java.lang.Math.*;\\n\\npublic class Solution implements Runnable {\\n\\tint min=(int)1e9;\\n\\tint dp[];\\n    public void solve() throws Exception {\\n\\/\\/        int t=sc.nextInt();\\n\\/\\/        for(int ii=1;ii<=t;ii++)\\n\\/\\/        {\\n        \\t\\/\\/System.out.print(\\\"Case #\\\"+ii+\\\": \\\");\\n    \\t\\n    \\tint n=sc.nextInt();\\n    \\tint d=sc.nextInt();\\n    \\tdp=new int[n+1];\\n    \\tArrays.fill(dp, -1);\\n    \\t\\n    \\tchar temp[]=sc.nextToken().toCharArray();\\n    \\tdfs(0,temp,d,n);\\n    \\tSystem.out.println(dp[0]<=0?-1:dp[0]);\\n\\/\\/    \\tfor(int i=0;i<n;i++)\\n    \\t\\/\\/System.out.println(dp[i]);\\n        \\n        \\n    }\\n    \\n    \\n    public int dfs(int pos,char[] temp,int d,int n) throws Exception\\n    {\\n    \\tif(pos>=n || temp[pos]=='0')\\n    \\t\\treturn 0;\\n    \\tif(pos==n-1)\\n    \\t{\\n    \\t\\tdp[pos]=0;\\n    \\t\\treturn 0;\\n    \\t\\t\\n    \\t}\\n    \\tif(dp[pos]!=-1)\\n    \\t\\treturn dp[pos];\\n    \\tfor(int i=1;i<=d;i++)\\n    \\t{\\n    \\t\\tif(pos+i==n-1)\\n    \\t\\t{\\n    \\t\\t\\tdp[pos]=1;\\n    \\t\\t\\tbreak;\\n    \\t\\t}\\n    \\t\\t\\n    \\t\\tif(dfs(pos+i,temp,d,n)!=0)\\n    \\t\\t{\\n    \\t\\t\\tif(dp[pos]==-1)\\n    \\t\\t\\tdp[pos]=dp[pos+i]+1;\\n    \\t\\t\\telse \\n    \\t\\t\\t\\tdp[pos]=Math.min(dp[pos], dp[pos+i]+1);\\n    \\t\\t\\t\\t\\n    \\t\\t}\\n    \\t}\\n    \\tif(dp[pos]==-1)\\n    \\t\\tdp[pos]=0;\\n    \\treturn dp[pos];\\n    }\\n    \\n   \\n\\n    static Throwable uncaught;\\n\\n    BufferedReader in;\\n    FastScanner sc;\\n    PrintWriter out;\\n\\n    @Override\\n    public void run() {\\n        try {\\n            in = new BufferedReader(new InputStreamReader(System.in));\\n            out = new PrintWriter(System.out);\\n            sc = new FastScanner(in);\\n            solve();\\n        } catch (Throwable uncaught) {\\n            Solution.uncaught = uncaught;\\n        } finally {\\n            out.close();\\n        }\\n    }\\n\\n    public static void main(String[] args) throws Throwable {\\n        Thread thread = new Thread(null, new Solution(), \\\"\\\", (1 << 26));\\n        thread.start();\\n        thread.join();\\n        if (Solution.uncaught != null) {\\n            throw Solution.uncaught;\\n        }\\n    }\\n\\n}\\n\\nclass FastScanner {\\n\\n ...\",\"language\":\"python\",\"split\":\"train\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You are given four integer values a, b, c and m.\\n\\nCheck if there exists a string that contains: \\n\\n  * a letters 'A'; \\n  * b letters 'B'; \\n  * c letters 'C'; \\n  * no other letters; \\n  * exactly m pairs of adjacent equal letters (exactly m such positions i that the i-th letter is equal to the (i+1)-th one). \\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 10^4) \u2014 the number of testcases.\\n\\nEach of the next t lines contains the description of the testcase \u2014 four integers a, b, c and m (1 \u2264 a, b, c \u2264 10^8; 0 \u2264 m \u2264 10^8).\\n\\nOutput\\n\\nFor each testcase print \\\"YES\\\" if there exists a string that satisfies all the requirements. Print \\\"NO\\\" if there are no such strings.\\n\\nYou may print every letter in any case you want (so, for example, the strings yEs, yes, Yes and YES will all be recognized as positive answer).\\n\\nExample\\n\\nInput\\n\\n\\n3\\n2 2 1 0\\n1 1 1 1\\n1 2 3 2\\n\\n\\nOutput\\n\\n\\nYES\\nNO\\nYES\\n\\nNote\\n\\nIn the first testcase strings \\\"ABCAB\\\" or \\\"BCABA\\\" satisfy the requirements. There exist other possible strings.\\n\\nIn the second testcase there's no way to put adjacent equal letters if there's no letter that appears at least twice.\\n\\nIn the third testcase string \\\"CABBCC\\\" satisfies the requirements. There exist other possible strings.\\nSolve the task in JAVA.\",\"targets\":\"\\/*===============================\\nAuthor   :   Shadman Shariar   ||\\n===============================*\\/\\nimport java.io.*;\\nimport java.util.*;\\n\\/\\/import java.math.BigInteger;\\n\\/\\/import java.text.DecimalFormat;\\npublic class Main {\\npublic static Main obj = new Main();\\npublic static int [] dx = {-1, 1, 0, 0, -1, -1, 1, 1};\\npublic static int [] dy = {0, 0, -1, 1, -1, 1, -1, 1};\\n\\/\\/public static FastReader fr = new FastReader();\\n\\/\\/public static Scanner input = new Scanner(System.in);\\n\\/\\/public static PrintWriter pw = new PrintWriter(System.out);\\n\\/\\/public static DecimalFormat df = new DecimalFormat(\\\".000\\\");\\n\\/\\/public static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));\\npublic static void main (String[] args) throws Exception{Scanner input=new Scanner(System.in);\\n\\/\\/===========================================================================================\\/\\/\\n\\/\\/BigInteger bi = new BigInteger(\\\"000\\\");\\n\\/\\/StringBuilder sb = new StringBuilder();\\n\\/\\/StringBuffer sbf = new StringBuffer();\\n\\/\\/StringTokenizer st = new StringTokenizer(\\\"string\\\",\\\"split\\\");\\n\\/\\/Vector vc = new Vector();\\n\\/\\/ArrayList<Integer> al= new ArrayList<Integer>();\\n\\/\\/LinkedList<Integer> ll= new LinkedList<Integer>();\\n\\/\\/Stack <Integer> stk = new Stack <Integer>();\\n\\/\\/Queue <Integer> q = new LinkedList<Integer>();\\n\\/\\/ArrayDeque<Integer> ad = new ArrayDeque<Integer>();\\n\\/\\/PriorityQueue <Integer> pq = new PriorityQueue<Integer>();\\n\\/\\/PriorityQueue <Integer> pqr = new PriorityQueue<Integer>(Comparator.reverseOrder());\\n\\/\\/HashSet<Integer> hs = new HashSet<Integer>();\\n\\/\\/LinkedHashSet<Integer> lhs = new LinkedHashSet<Integer>();\\n\\/\\/TreeSet<Integer> ts = new TreeSet<Integer>();\\n\\/\\/TreeSet<Integer> tsr = new TreeSet<Integer>(Comparator.reverseOrder());\\n\\/\\/Hashtable<Integer,Integer> ht = new Hashtable<Integer,Integer>();\\n\\/\\/HashMap<Integer,Integer> hm = new HashMap<Integer,Integer>();\\n\\/\\/LinkedHashMap<Integer,Integer> lhm = new LinkedHashMap<Integer,Integer>();\\n\\/\\/TreeMap<Integer,Integer> tm = new TreeMap<Integer,Integer>();\\n\\/\\/TreeMap<Integer,Integer> tmr = new...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"DLS and JLS are bored with a Math lesson. In order to entertain themselves, DLS took a sheet of paper and drew n distinct lines, given by equations y = x + p_i for some distinct p_1, p_2, \u2026, p_n.\\n\\nThen JLS drew on the same paper sheet m distinct lines given by equations y = -x + q_i for some distinct q_1, q_2, \u2026, q_m.\\n\\nDLS and JLS are interested in counting how many line pairs have integer intersection points, i.e. points with both coordinates that are integers. Unfortunately, the lesson will end up soon, so DLS and JLS are asking for your help.\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 1000), the number of test cases in the input. Then follow the test case descriptions.\\n\\nThe first line of a test case contains an integer n (1 \u2264 n \u2264 10^5), the number of lines drawn by DLS.\\n\\nThe second line of a test case contains n distinct integers p_i (0 \u2264 p_i \u2264 10^9) describing the lines drawn by DLS. The integer p_i describes a line given by the equation y = x + p_i.\\n\\nThe third line of a test case contains an integer m (1 \u2264 m \u2264 10^5), the number of lines drawn by JLS.\\n\\nThe fourth line of a test case contains m distinct integers q_i (0 \u2264 q_i \u2264 10^9) describing the lines drawn by JLS. The integer q_i describes a line given by the equation y = -x + q_i.\\n\\nThe sum of the values of n over all test cases in the input does not exceed 10^5. Similarly, the sum of the values of m over all test cases in the input does not exceed 10^5.\\n\\nIn hacks it is allowed to use only one test case in the input, so t=1 should be satisfied.\\n\\nOutput\\n\\nFor each test case in the input print a single integer \u2014 the number of line pairs with integer intersection points. \\n\\nExample\\n\\nInput\\n\\n\\n3\\n3\\n1 3 2\\n2\\n0 3\\n1\\n1\\n1\\n1\\n1\\n2\\n1\\n1\\n\\n\\nOutput\\n\\n\\n3\\n1\\n0\\n\\nNote\\n\\nThe picture shows the lines from the first test case of the example. Black circles denote intersection points with integer coordinates.\\n\\n<image>\\nUsing python3 can you solve the prior task?\",\"targets\":\"n = int(input())\\nfor i in range(n):\\n    cl, cr, dl, dr = 0, 0, 0, 0\\n    q = int(input())\\n    a = list(map(int, input().split()))\\n    w = int(input())\\n    b = list(map(int, input().split()))\\n    for j in range(q):\\n        if a[j] % 2 != 0:\\n            cl += 1\\n        else:\\n            cr += 1\\n    for j in range(w):\\n        if b[j] % 2 != 0:\\n            dl += 1\\n        else:\\n            dr += 1\\n    print((cl * dl) + (cr * dr))\",\"language\":\"python\",\"split\":\"train\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Creatnx has n mirrors, numbered from 1 to n. Every day, Creatnx asks exactly one mirror \\\"Am I beautiful?\\\". The i-th mirror will tell Creatnx that he is beautiful with probability (p_i)\\/(100) for all 1 \u2264 i \u2264 n.\\n\\nCreatnx asks the mirrors one by one, starting from the 1-st mirror. Every day, if he asks i-th mirror, there are two possibilities:\\n\\n  * The i-th mirror tells Creatnx that he is beautiful. In this case, if i = n Creatnx will stop and become happy, otherwise he will continue asking the i+1-th mirror next day; \\n  * In the other case, Creatnx will feel upset. The next day, Creatnx will start asking from the 1-st mirror again. \\n\\n\\n\\nYou need to calculate [the expected number](https:\\/\\/en.wikipedia.org\\/wiki\\/Expected_value) of days until Creatnx becomes happy.\\n\\nThis number should be found by modulo 998244353. Formally, let M = 998244353. It can be shown that the answer can be expressed as an irreducible fraction p\\/q, where p and q are integers and q not \u2261 0 \\\\pmod{M}. Output the integer equal to p \u22c5 q^{-1} mod M. In other words, output such an integer x that 0 \u2264 x < M and x \u22c5 q \u2261 p \\\\pmod{M}.\\n\\nInput\\n\\nThe first line contains one integer n (1\u2264 n\u2264 2\u22c5 10^5) \u2014 the number of mirrors.\\n\\nThe second line contains n integers p_1, p_2, \u2026, p_n (1 \u2264 p_i \u2264 100).\\n\\nOutput\\n\\nPrint the answer modulo 998244353 in a single line.\\n\\nExamples\\n\\nInput\\n\\n\\n1\\n50\\n\\n\\nOutput\\n\\n\\n2\\n\\n\\nInput\\n\\n\\n3\\n10 20 50\\n\\n\\nOutput\\n\\n\\n112\\n\\nNote\\n\\nIn the first test, there is only one mirror and it tells, that Creatnx is beautiful with probability 1\\/2. So, the expected number of days until Creatnx becomes happy is 2.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst int maxn = 2e5 + 10;\\nconst int mod = 998244353;\\nint n;\\nlong long dp[maxn], Mod;\\nlong long p[maxn];\\nlong long Pow(long long x, int y) {\\n  long long ans = 1, cnt = x % mod;\\n  while (y) {\\n    if (y & 1) ans = ans * cnt % mod;\\n    cnt = cnt * cnt % mod;\\n    y >>= 1;\\n  }\\n  return ans;\\n}\\nint main() {\\n  scanf(\\\"%d\\\", &n);\\n  long long fm = 1, ans = 1;\\n  Mod = Pow(100, mod - 2);\\n  for (int i = 1; i <= n; ++i) {\\n    scanf(\\\"%lld\\\", &p[i]), p[i] = p[i] * Mod % mod;\\n    fm = fm * p[i] % mod;\\n    if (i != n) ans = (ans + fm) % mod;\\n  }\\n  printf(\\\"%lld\\\\n\\\", ans * Pow(fm, mod - 2) % mod);\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"B: Twice as own\\n\\nproblem\\n\\nYou will be given Q queries. Since one positive integer N is given for each query, find the number of positive integers M that satisfy the following two conditions.\\n\\n* 2 Satisfy \\\\ leq M \\\\ leq N\\n* Of the divisors of M, excluding M, the total product is more than twice that of M\\n\\n\\n\\nInput format\\n\\nThe input is given in the following format:\\n\\n\\nQ\\nN_1_1\\nN_2\\n::\\nN_Q\\n\\n\\n* The first line gives the number of queries Q.\\n* Lines 2 through N + 1 are given one positive integer N given for each query.\\n\\n\\n\\nConstraint\\n\\n* 1 \\\\ leq Q \\\\ leq 10 ^ 5\\n* 2 \\\\ leq N_i \\\\ leq 10 ^ 5 (1 \\\\ leq i \\\\ leq Q)\\n\\n\\n\\nOutput format\\n\\nOutput the number of positive integers that satisfy the above two conditions for each N_i, separated by line breaks.\\n\\nInput example\\n\\n\\n3\\n43\\n9\\ntwenty four\\n\\n\\nOutput example\\n\\n\\n11\\n0\\nFive\\n\\n\\n* When N = 24, there are five types of M that can be considered as 12, 16, 18, 20, 24.\\n\\n\\n\\n\\n\\nExample\\n\\nInput\\n\\n3\\n43\\n9\\n24\\n\\n\\nOutput\\n\\n11\\n0\\n5\",\"targets\":\"#include <algorithm>\\n#include <iostream>\\n#include <vector>\\n\\n#define rep(i, n) for (int i = 0; i < (int)(n); i++)\\nusing namespace std;\\n\\nint main() {\\n\\n  int q;\\n  cin >> q;\\n\\n  vector<int> a(100005);\\n  const int64_t inf = 1e9;\\n  for (int m = 2; m < (int)a.size(); m++) {\\n    int64_t p = 1;\\n    for (int x = 2; x * x <= m; x++) {\\n      if (m % x == 0) {\\n        p *= x;\\n        p = min(p, inf);\\n        if (m % x != x) {\\n          p *= (m \\/ x);\\n          p = min(p, inf);\\n        }\\n      }\\n    }\\n    if (p >= m * 2) { a[m] += 1; }\\n  }\\n  rep(i, a.size() - 1) a[i + 1] += a[i];\\n\\n  while (q--) {\\n    int n;\\n    cin >> n;\\n    cout << a[n] << endl;\\n  }\\n\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"PYTHON3 solution for \\\"CQXYM wants to create a connected undirected graph with n nodes and m edges, and the diameter of the graph must be strictly less than k-1. Also, CQXYM doesn't want a graph that contains self-loops or multiple edges (i.e. each edge connects two different vertices and between each pair of vertices there is at most one edge).\\n\\nThe diameter of a graph is the maximum distance between any two nodes.\\n\\nThe distance between two nodes is the minimum number of the edges on the path which endpoints are the two nodes.\\n\\nCQXYM wonders whether it is possible to create such a graph.\\n\\nInput\\n\\nThe input consists of multiple test cases. \\n\\nThe first line contains an integer t (1 \u2264 t \u2264 10^5) \u2014 the number of test cases. The description of the test cases follows.\\n\\nOnly one line of each test case contains three integers n(1 \u2264 n \u2264 10^9), m, k (0 \u2264 m,k \u2264 10^9).\\n\\nOutput\\n\\nFor each test case, print YES if it is possible to create the graph, or print NO if it is impossible. You can print each letter in any case (upper or lower).\\n\\nExample\\n\\nInput\\n\\n\\n5\\n1 0 3\\n4 5 3\\n4 6 3\\n5 4 1\\n2 1 1\\n\\n\\nOutput\\n\\n\\nYES\\nNO\\nYES\\nNO\\nNO\\n\\nNote\\n\\nIn the first test case, the graph's diameter equal to 0.\\n\\nIn the second test case, the graph's diameter can only be 2.\\n\\nIn the third test case, the graph's diameter can only be 1.\\\":\",\"targets\":\"def solve(n, m, k):\\n    if n * (n - 1) \\/\\/ 2 < m or m < n - 1:\\n        return False\\n    if n == 1:\\n        if k > 1:\\n            return True\\n        else:\\n            return False\\n    elif m < n * (n - 1) \\/\\/ 2:\\n        if k > 3:\\n            return True\\n        else:\\n            return False\\n    else:\\n        if k > 2:\\n            return True\\n        else:\\n            return False\\n\\n\\nt = int(input())\\nfor i in range(t):\\n    n, m, k = map(int, input().split())\\n    ans = solve(n, m, k)\\n    if ans:\\n        print(\\\"YES\\\")\\n    else:\\n        print(\\\"NO\\\")\",\"language\":\"python\",\"split\":\"test\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"This is the easy version of the problem. The difference between the versions is that the easy version does not require you to output the numbers of the rods to be removed. You can make hacks only if all versions of the problem are solved.\\n\\nStitch likes experimenting with different machines with his friend Sparky. Today they built another machine.\\n\\nThe main element of this machine are n rods arranged along one straight line and numbered from 1 to n inclusive. Each of these rods must carry an electric charge quantitatively equal to either 1 or -1 (otherwise the machine will not work). Another condition for this machine to work is that the sign-variable sum of the charge on all rods must be zero.\\n\\nMore formally, the rods can be represented as an array of n numbers characterizing the charge: either 1 or -1. Then the condition must hold: a_1 - a_2 + a_3 - a_4 + \u2026 = 0, or \u2211_{i=1}^n (-1)^{i-1} \u22c5 a_i = 0.\\n\\nSparky charged all n rods with an electric current, but unfortunately it happened that the rods were not charged correctly (the sign-variable sum of the charge is not zero). The friends decided to leave only some of the rods in the machine. Sparky has q questions. In the ith question Sparky asks: if the machine consisted only of rods with numbers l_i to r_i inclusive, what minimal number of rods could be removed from the machine so that the sign-variable sum of charges on the remaining ones would be zero? Perhaps the friends got something wrong, and the sign-variable sum is already zero. In that case, you don't have to remove the rods at all.\\n\\nIf the number of rods is zero, we will assume that the sign-variable sum of charges is zero, that is, we can always remove all rods.\\n\\nHelp your friends and answer all of Sparky's questions!\\n\\nInput\\n\\nEach test contains multiple test cases.\\n\\nThe first line contains one positive integer t (1 \u2264 t \u2264 10^3), denoting the number of test cases. Description of the test cases follows.\\n\\nThe first line of each test case contains two positive integers n and q (1 \u2264 n, q \u2264 3 \u22c5 10^5) \u2014 the...\\n#incl\",\"targets\":\"ude <bits\\/stdc++.h>\\nusing ll = long long int;\\nconst int INF = (1 << 30);\\nconst ll INFLL = (1ll << 60);\\nconst ll MOD = (ll)(1e9 + 7);\\nvoid mul_mod(ll& a, ll b) {\\n  a *= b;\\n  a %= MOD;\\n}\\nvoid add_mod(ll& a, ll b) {\\n  a = (a < MOD) ? a : (a - MOD);\\n  b = (b < MOD) ? b : (b - MOD);\\n  a += b;\\n  a = (a < MOD) ? a : (a - MOD);\\n}\\nstd::string s;\\nint a[334334];\\nint main(void) {\\n  int t, n, q, i, l, r;\\n  std::cin >> t;\\n  while (t--) {\\n    std::cin >> n >> q;\\n    std::cin >> s;\\n    for (i = 0; i < n; ++i) {\\n      if ((s[i] == '+') ^ (i % 2)) {\\n        a[i + 1] = a[i] + 1;\\n      } else {\\n        a[i + 1] = a[i] - 1;\\n      }\\n    }\\n    for (i = 0; i < q; ++i) {\\n      std::cin >> l >> r;\\n      --l;\\n      if (a[r] - a[l] == 0) {\\n        std::cout << 0 << std::endl;\\n      } else {\\n        std::cout << (2 - std::abs(a[r] - a[l]) % 2) << std::endl;\\n      }\\n    }\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Theofanis has a riddle for you and if you manage to solve it, he will give you a Cypriot snack halloumi for free (Cypriot cheese).\\n\\nYou are given an integer n. You need to find two integers l and r such that -10^{18} \u2264 l < r \u2264 10^{18} and l + (l + 1) + \u2026 + (r - 1) + r = n.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 10^4) \u2014 the number of test cases.\\n\\nThe first and only line of each test case contains a single integer n (1 \u2264 n \u2264 10^{18}).\\n\\nOutput\\n\\nFor each test case, print the two integers l and r such that -10^{18} \u2264 l < r \u2264 10^{18} and l + (l + 1) + \u2026 + (r - 1) + r = n. \\n\\nIt can be proven that an answer always exists. If there are multiple answers, print any.\\n\\nExample\\n\\nInput\\n\\n\\n7\\n1\\n2\\n3\\n6\\n100\\n25\\n3000000000000\\n\\n\\nOutput\\n\\n\\n0 1\\n-1 2 \\n1 2 \\n1 3 \\n18 22\\n-2 7\\n999999999999 1000000000001\\n\\nNote\\n\\nIn the first test case, 0 + 1 = 1.\\n\\nIn the second test case, (-1) + 0 + 1 + 2 = 2.\\n\\nIn the fourth test case, 1 + 2 + 3 = 6.\\n\\nIn the fifth test case, 18 + 19 + 20 + 21 + 22 = 100.\\n\\nIn the sixth test case, (-2) + (-1) + 0 + 1 + 2 + 3 + 4 + 5 + 6 + 7 = 25.\",\"targets\":\"import java.util.*;\\nimport java.util.Scanner;\\npublic class CSR {\\n    public static void main(String[] args) throws Exception {\\n        Scanner r=new Scanner(System.in);\\n        int T=r.nextInt();\\n        while(T-->0) {\\n            long p = r.nextLong();\\n            GetAnswer(p);\\n        }\\n    }\\n        public static void GetAnswer ( long n){\\n            long r = 0;\\n            long l = 0;\\n            if ((n % 2) == 1) {\\n                l = (n - 1) \\/ 2;\\n                r = l + 1;\\n            } else {\\n                r = n;\\n                l = 1 - n;\\n            }\\n            System.out.printf(\\\"%d %d\\\\n\\\", l, r);\\n        }\\n    }\",\"language\":\"python\",\"split\":\"test\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Mocha wants to be an astrologer. There are n stars which can be seen in Zhijiang, and the brightness of the i-th star is a_i. \\n\\nMocha considers that these n stars form a constellation, and she uses (a_1,a_2,\u2026,a_n) to show its state. A state is called mathematical if all of the following three conditions are satisfied:\\n\\n  * For all i (1\u2264 i\u2264 n), a_i is an integer in the range [l_i, r_i].\\n  * \u2211  _{i=1} ^ n a_i \u2264 m.\\n  * \\\\gcd(a_1,a_2,\u2026,a_n)=1.\\n\\n\\n\\nHere, \\\\gcd(a_1,a_2,\u2026,a_n) denotes the [greatest common divisor (GCD)](https:\\/\\/en.wikipedia.org\\/wiki\\/Greatest_common_divisor) of integers a_1,a_2,\u2026,a_n.\\n\\nMocha is wondering how many different mathematical states of this constellation exist. Because the answer may be large, you must find it modulo 998 244 353.\\n\\nTwo states (a_1,a_2,\u2026,a_n) and (b_1,b_2,\u2026,b_n) are considered different if there exists i (1\u2264 i\u2264 n) such that a_i \u2260 b_i.\\n\\nInput\\n\\nThe first line contains two integers n and m (2 \u2264 n \u2264 50, 1 \u2264 m \u2264 10^5) \u2014 the number of stars and the upper bound of the sum of the brightness of stars.\\n\\nEach of the next n lines contains two integers l_i and r_i (1 \u2264 l_i \u2264 r_i \u2264 m) \u2014 the range of the brightness of the i-th star.\\n\\nOutput\\n\\nPrint a single integer \u2014 the number of different mathematical states of this constellation, modulo 998 244 353.\\n\\nExamples\\n\\nInput\\n\\n\\n2 4\\n1 3\\n1 2\\n\\n\\nOutput\\n\\n\\n4\\n\\nInput\\n\\n\\n5 10\\n1 10\\n1 10\\n1 10\\n1 10\\n1 10\\n\\n\\nOutput\\n\\n\\n251\\n\\nInput\\n\\n\\n5 100\\n1 94\\n1 96\\n1 91\\n4 96\\n6 97\\n\\n\\nOutput\\n\\n\\n47464146\\n\\nNote\\n\\nIn the first example, there are 4 different mathematical states of this constellation:\\n\\n  * a_1=1, a_2=1.\\n  * a_1=1, a_2=2.\\n  * a_1=2, a_2=1.\\n  * a_1=3, a_2=1.\\n#incl\",\"targets\":\"ude <bits\\/stdc++.h>\\nusing namespace std;\\nconst int N = 50 + 5;\\nconst long long M = 1e5 + 5;\\nconst long long mod = 998244353;\\nconst int inf = 1e9;\\nconst double eps = 1e-9;\\nconst double PI = acos(-1.0);\\nconst pair<int, int> NIL = {0, 0};\\nint n, m;\\nlong long l[N], r[N], mu[M], sum[M], f[M];\\nlong long deal(long long d) {\\n  long long lim = m \\/ d;\\n  f[0] = 1;\\n  for (long long i = 1; i <= lim; ++i) f[i] = 0;\\n  for (long long i = 1; i <= n; ++i) {\\n    long long L = (l[i] + d - 1) \\/ d, R = r[i] \\/ d;\\n    if (L > R) return 0;\\n    sum[0] = f[0];\\n    for (long long j = 1; j <= lim; ++j) sum[j] = (f[j] + sum[j - 1]) % mod;\\n    for (long long j = 0; j <= lim; ++j) {\\n      if (j > R)\\n        f[j] = (sum[j - L] - sum[j - R - 1] + mod) % mod;\\n      else if (j >= L)\\n        f[j] = sum[j - L];\\n      else\\n        f[j] = 0;\\n    }\\n  }\\n  long long ans = 0;\\n  for (long long i = 1; i <= lim; ++i) ans = (ans + f[i]) % mod;\\n  return ans;\\n}\\nvoid solve() {\\n  mu[1] = 1;\\n  cin >> n >> m;\\n  for (long long i = 1; i <= m; ++i)\\n    for (int j = i + i; j <= m; j += i) mu[j] = (mu[j] + mod - mu[i]) % mod;\\n  for (long long i = 1; i <= n; ++i) cin >> l[i] >> r[i];\\n  long long ans = 0;\\n  for (long long i = 1; i <= m; ++i) {\\n    ans = (mu[i] * deal(i) + ans + mod) % mod;\\n  }\\n  cout << ans << \\\"\\\\n\\\";\\n}\\nint main() {\\n  solve();\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in JAVA?\\nGregor is learning about RSA cryptography, and although he doesn't understand how RSA works, he is now fascinated with prime numbers and factoring them.\\n\\nGregor's favorite prime number is P. Gregor wants to find two bases of P. Formally, Gregor is looking for two integers a and b which satisfy both of the following properties.\\n\\n  * P mod a = P mod b, where x mod y denotes the remainder when x is divided by y, and \\n  * 2 \u2264 a < b \u2264 P. \\n\\n\\n\\nHelp Gregor find two bases of his favorite prime number!\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 1000).\\n\\nEach subsequent line contains the integer P (5 \u2264 P \u2264 {10}^9), with P guaranteed to be prime.\\n\\nOutput\\n\\nYour output should consist of t lines. Each line should consist of two integers a and b (2 \u2264 a < b \u2264 P). If there are multiple possible solutions, print any.\\n\\nExample\\n\\nInput\\n\\n\\n2\\n17\\n5\\n\\n\\nOutput\\n\\n\\n3 5\\n2 4\\n\\nNote\\n\\nThe first query is P=17. a=3 and b=5 are valid bases in this case, because 17 mod 3 = 17 mod 5 = 2. There are other pairs which work as well.\\n\\nIn the second query, with P=5, the only solution is a=2 and b=4.\",\"targets\":\"import java.util.HashMap;\\nimport java.util.Map;\\nimport java.util.Scanner;\\n\\npublic class GregorandCrypotgraphyCodeforces {\\n\\n\\tpublic static void main(String[] args) {\\n\\t\\t\\/\\/ TODO Auto-generated method stub\\n\\t\\tScanner scn=new Scanner(System.in);\\n\\t\\tint t=scn.nextInt();\\n\\t\\twhile(t-->0) {\\n\\t\\t\\t\\n\\t\\t\\t\\n\\t\\t\\tint n=scn.nextInt();\\n\\t\\t\\t\\n\\t\\t\\tMap<Integer,Integer> hm=new HashMap<>();\\n\\t\\t\\tfor(int i =2;i<n;i++) {\\n\\t\\t\\t\\tif(hm.get(n%i)!=null) {\\n\\t\\t\\t\\t\\tSystem.out.println(hm.get(n%i)+\\\" \\\"+i);\\n\\t\\t\\t\\t\\tbreak;\\n\\t\\t\\t\\t}\\n\\t\\t\\t\\thm.put(n%i,i);\\n\\t\\t\\t}\\n\\t\\t}\\n\\n\\t}\\t\\n\\t}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in JAVA?\\nYou are given an array of integers a of length n. The elements of the array can be either different or the same. \\n\\nEach element of the array is colored either blue or red. There are no unpainted elements in the array. One of the two operations described below can be applied to an array in a single step:\\n\\n  * either you can select any blue element and decrease its value by 1; \\n  * or you can select any red element and increase its value by 1. \\n\\n\\n\\nSituations in which there are no elements of some color at all are also possible. For example, if the whole array is colored blue or red, one of the operations becomes unavailable.\\n\\nDetermine whether it is possible to make 0 or more steps such that the resulting array is a permutation of numbers from 1 to n?\\n\\nIn other words, check whether there exists a sequence of steps (possibly empty) such that after applying it, the array a contains in some order all numbers from 1 to n (inclusive), each exactly once.\\n\\nInput\\n\\nThe first line contains an integer t (1 \u2264 t \u2264 10^4) \u2014 the number of input data sets in the test.\\n\\nThe description of each set of input data consists of three lines. The first line contains an integer n (1 \u2264 n \u2264 2 \u22c5 10^5) \u2014 the length of the original array a. The second line contains n integers a_1, a_2, ..., a_n (-10^9 \u2264 a_i \u2264 10^9) \u2014 the array elements themselves.\\n\\nThe third line has length n and consists exclusively of the letters 'B' and\\/or 'R': ith character is 'B' if a_i is colored blue, and is 'R' if colored red.\\n\\nIt is guaranteed that the sum of n over all input sets does not exceed 2 \u22c5 10^5.\\n\\nOutput\\n\\nPrint t lines, each of which contains the answer to the corresponding test case of the input. Print YES as an answer if the corresponding array can be transformed into a permutation, and NO otherwise.\\n\\nYou can print the answer in any case (for example, the strings yEs, yes, Yes, and YES will be recognized as a positive answer).\\n\\nExample\\n\\nInput\\n\\n\\n8\\n4\\n1 2 5 2\\nBRBR\\n2\\n1 1\\nBB\\n5\\n3 1 4 2 5\\nRBRRB\\n5\\n3 1 3 1 3\\nRBRRB\\n5\\n5 1 5 1 5\\nRBRRB\\n4\\n2 2 2 2\\nBRBR\\n2\\n1 -2\\nBR\\n4\\n-2...\",\"targets\":\"import java.util.*;\\n\\npublic class BlueRedPermutation {\\n\\n\\tpublic static void main(String[] args) {\\n\\t\\t\\/\\/ TODO Auto-generated method stub\\n\\t\\tScanner sc = new Scanner(System.in);\\n\\t\\tStringBuffer sb = new StringBuffer();\\n\\t\\t\\n\\t\\tint t = sc.nextInt();\\n\\t\\twhile(t-->0) {\\n\\t\\t\\tint n = sc.nextInt();\\n\\t\\t\\tint arr[] = new int[n];\\n\\t\\t\\tfor(int i = 0; i<n; i++) {\\n\\t\\t\\t\\tarr[i] = sc.nextInt();\\n\\t\\t\\t}\\n\\t\\t\\tString s = sc.next();\\n\\n\\t\\t\\tArrayList<Integer> b = new ArrayList<>();\\n\\t\\t\\tArrayList<Integer> r = new ArrayList<>();\\n\\t\\t\\t\\n\\t\\t\\tfor(int i = 0; i<n; i++) {\\n\\t\\t\\t\\tif(s.charAt(i)=='B') {\\n\\t\\t\\t\\t\\tb.add(arr[i]);\\n\\t\\t\\t\\t}\\n\\t\\t\\t\\telse {\\n\\t\\t\\t\\t\\tr.add(arr[i]);\\n\\t\\t\\t\\t}\\n\\t\\t\\t}\\n\\t\\t\\t\\n\\t\\t\\tCollections.sort(b);\\n\\t\\t\\tCollections.sort(r);\\n\\t\\t\\t\\n\\t\\t\\tboolean ans = true;\\n\\t\\t\\t\\n\\t\\t\\tint i =0 , j = 0;\\n\\t\\t\\tfor(int k = 1; k<=n; k++) {\\n\\t\\t\\t\\tif(i<b.size() && b.get(i)>=k) {\\n\\t\\t\\t\\t\\ti++;\\n\\t\\t\\t\\t}\\n\\t\\t\\t\\telse if(j<r.size() && r.get(j)<=k) {\\n\\t\\t\\t\\t\\tj++;\\n\\t\\t\\t\\t}\\n\\t\\t\\t\\telse {\\n\\t\\t\\t\\t\\tans = false;\\n\\t\\t\\t\\t\\tbreak;\\n\\t\\t\\t\\t}\\n\\t\\t\\t}\\n\\t\\t\\tif(ans) {\\n\\t\\t\\t\\tsb.append(\\\"YES\\\\n\\\");\\n\\t\\t\\t}\\n\\t\\t\\telse {\\n\\t\\t\\t\\tsb.append(\\\"NO\\\\n\\\");\\n\\t\\t\\t}\\n\\t\\t\\t\\n\\t\\t}\\n\\t\\tSystem.out.println(sb);\\n\\n\\t}\\n\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"You are given a simple undirected graph with n vertices, n is even. You are going to write a letter on each vertex. Each letter should be one of the first k letters of the Latin alphabet.\\n\\nA path in the graph is called Hamiltonian if it visits each vertex exactly once. A string is called palindromic if it reads the same from left to right and from right to left. A path in the graph is called palindromic if the letters on the vertices in it spell a palindromic string without changing the order.\\n\\nA string of length n is good if: \\n\\n  * each letter is one of the first k lowercase Latin letters; \\n  * if you write the i-th letter of the string on the i-th vertex of the graph, there will exist a palindromic Hamiltonian path in the graph. \\n\\n\\n\\nNote that the path doesn't necesserily go through the vertices in order 1, 2, ..., n.\\n\\nCount the number of good strings.\\n\\nInput\\n\\nThe first line contains three integers n, m and k (2 \u2264 n \u2264 12; n is even; 0 \u2264 m \u2264 (n \u22c5 (n-1))\\/(2); 1 \u2264 k \u2264 12) \u2014 the number of vertices in the graph, the number of edges in the graph and the number of first letters of the Latin alphabet that can be used.\\n\\nEach of the next m lines contains two integers v and u (1 \u2264 v, u \u2264 n; v \u2260 u) \u2014 the edges of the graph. The graph doesn't contain multiple edges and self-loops.\\n\\nOutput\\n\\nPrint a single integer \u2014 number of good strings.\\n\\nExamples\\n\\nInput\\n\\n\\n4 3 3\\n1 2\\n2 3\\n3 4\\n\\n\\nOutput\\n\\n\\n9\\n\\n\\nInput\\n\\n\\n4 6 3\\n1 2\\n1 3\\n1 4\\n2 3\\n2 4\\n3 4\\n\\n\\nOutput\\n\\n\\n21\\n\\n\\nInput\\n\\n\\n12 19 12\\n1 3\\n2 6\\n3 6\\n3 7\\n4 8\\n8 5\\n8 7\\n9 4\\n5 9\\n10 1\\n10 4\\n10 6\\n9 10\\n11 1\\n5 11\\n7 11\\n12 2\\n12 5\\n12 11\\n\\n\\nOutput\\n\\n\\n456165084\\\":\",\"targets\":\"#include <bits\\/stdc++.h>\\nint n, m, K;\\nbool adj[15][15];\\nstd::set<std::vector<int> > ans;\\nint p2[15][2];\\nint col[15];\\nvoid dfs1(int id, int max) {\\n  if (id == n \\/ 2) {\\n    static int last[15];\\n    for (int i = 0; i < (int)(n); ++i) last[i] = -1;\\n    int cnt = 0;\\n    for (int i = 0; i < (int)(n); ++i)\\n      if (last[col[i]] == -1) last[col[i]] = cnt++;\\n    std::vector<int> ovo(n);\\n    for (int i = 0; i < (int)(n); ++i) ovo[i] = last[col[i]];\\n    ans.insert(ovo);\\n    return;\\n  }\\n  for (int c = 0; c < (int)(max + 1); ++c) {\\n    col[p2[id][0]] = col[p2[id][1]] = c;\\n    dfs1(id + 1, std::max(c + 1, max));\\n  }\\n}\\nbool check() {\\n  static bool dp[1 << 6][10];\\n  memset(dp, 0, sizeof(dp));\\n  for (int i = 0; i < (int)(n \\/ 2); ++i)\\n    if (adj[p2[i][0]][p2[i][1]]) dp[1 << i][i] = true;\\n  for (int mask = 0; mask < (int)(1 << (n \\/ 2)); ++mask)\\n    for (int cur = 0; cur < (int)(n \\/ 2); ++cur)\\n      if (mask >> cur & 1) {\\n        int nmask = mask ^ 1 << cur;\\n        if (nmask) {\\n          for (int last = 0; last < (int)(n \\/ 2); ++last)\\n            if (nmask >> last & 1) {\\n              if ((adj[p2[cur][0]][p2[last][0]] &&\\n                   adj[p2[last][1]][p2[cur][1]]) ||\\n                  (adj[p2[cur][0]][p2[last][1]] &&\\n                   adj[p2[last][0]][p2[cur][1]])) {\\n                dp[mask][cur] |= dp[nmask][last];\\n              }\\n            }\\n        }\\n      }\\n  for (int i = 0; i < (int)(n \\/ 2); ++i)\\n    if (dp[(1 << (n \\/ 2)) - 1][i]) return true;\\n  return false;\\n}\\nvoid dfs0(int mask, int id) {\\n  if (!mask) {\\n    for (int i = 0; i < (int)(n \\/ 2); ++i) col[p2[i][0]] = col[p2[i][1]] = i;\\n    if (check()) dfs1(0, 0);\\n    return;\\n  }\\n  int u = __builtin_ctz(mask);\\n  int nmask = mask ^ 1 << u;\\n  for (int v = 0; v < (int)(n); ++v)\\n    if (nmask >> v & 1) {\\n      p2[id][0] = u, p2[id][1] = v;\\n      dfs0(nmask ^ 1 << v, id + 1);\\n    }\\n}\\nint main() {\\n  scanf(\\\"%d %d %d\\\", &n, &m, &K);\\n  for (int i = 0; i < (int)(m); ++i) {\\n    int u, v;\\n    scanf(\\\"%d %d\\\", &u, &v);\\n    --u, --v;\\n    adj[u][v] = adj[v][u] = true;\\n  }\\n  dfs0((1 <<...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Alice and Bob are playing a game on a matrix, consisting of 2 rows and m columns. The cell in the i-th row in the j-th column contains a_{i, j} coins in it.\\n\\nInitially, both Alice and Bob are standing in a cell (1, 1). They are going to perform a sequence of moves to reach a cell (2, m).\\n\\nThe possible moves are: \\n\\n  * Move right \u2014 from some cell (x, y) to (x, y + 1); \\n  * Move down \u2014 from some cell (x, y) to (x + 1, y). \\n\\n\\n\\nFirst, Alice makes all her moves until she reaches (2, m). She collects the coins in all cells she visit (including the starting cell).\\n\\nWhen Alice finishes, Bob starts his journey. He also performs the moves to reach (2, m) and collects the coins in all cells that he visited, but Alice didn't.\\n\\nThe score of the game is the total number of coins Bob collects.\\n\\nAlice wants to minimize the score. Bob wants to maximize the score. What will the score of the game be if both players play optimally?\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 10^4) \u2014 the number of testcases.\\n\\nThen the descriptions of t testcases follow.\\n\\nThe first line of the testcase contains a single integer m (1 \u2264 m \u2264 10^5) \u2014 the number of columns of the matrix.\\n\\nThe i-th of the next 2 lines contain m integers a_{i,1}, a_{i,2}, ..., a_{i,m} (1 \u2264 a_{i,j} \u2264 10^4) \u2014 the number of coins in the cell in the i-th row in the j-th column of the matrix.\\n\\nThe sum of m over all testcases doesn't exceed 10^5.\\n\\nOutput\\n\\nFor each testcase print a single integer \u2014 the score of the game if both players play optimally.\\n\\nExample\\n\\nInput\\n\\n\\n3\\n3\\n1 3 7\\n3 5 1\\n3\\n1 3 9\\n3 5 1\\n1\\n4\\n7\\n\\n\\nOutput\\n\\n\\n7\\n8\\n0\\n\\nNote\\n\\nThe paths for the testcases are shown on the following pictures. Alice's path is depicted in red and Bob's path is depicted in blue.\\n\\n<image>\\nThe above is tricky. Write me a correct solution in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint main() {\\n  int t;\\n  cin >> t;\\n  while (t--) {\\n    int m;\\n    cin >> m;\\n    vector<vector<int>> board(2, vector<int>(m));\\n    for (int i = 0; i < 2; i++) {\\n      for (int j = 0; j < m; j++) {\\n        int tmp;\\n        cin >> tmp;\\n        board[i][j] = tmp;\\n      }\\n    }\\n    vector<int> prefix_bot(m + 1), suffix_top(m + 1);\\n    for (int i = 1; i <= m; i++) {\\n      suffix_top[i] = suffix_top[i - 1] + board[0][m - i];\\n    }\\n    for (int i = 1; i <= m; i++) {\\n      prefix_bot[i] = prefix_bot[i - 1] + board[1][i - 1];\\n    }\\n    int an = 1e9 + 5;\\n    for (int down = 0; down < m; down++) {\\n      int atake = down;\\n      int btake = m - 1 - down;\\n      an = min(an, max(prefix_bot[atake], suffix_top[btake]));\\n    }\\n    cout << an << endl;\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in CPP?\\nAlice and Bob are playing yet another card game. This time the rules are the following. There are n cards lying in a row in front of them. The i-th card has value a_i. \\n\\nFirst, Alice chooses a non-empty consecutive segment of cards [l; r] (l \u2264 r). After that Bob removes a single card j from that segment (l \u2264 j \u2264 r). The score of the game is the total value of the remaining cards on the segment (a_l + a_{l + 1} + ... + a_{j - 1} + a_{j + 1} + ... + a_{r - 1} + a_r). In particular, if Alice chooses a segment with just one element, then the score after Bob removes the only card is 0.\\n\\nAlice wants to make the score as big as possible. Bob takes such a card that the score is as small as possible.\\n\\nWhat segment should Alice choose so that the score is maximum possible? Output the maximum score.\\n\\nInput\\n\\nThe first line contains a single integer n (1 \u2264 n \u2264 10^5) \u2014 the number of cards.\\n\\nThe second line contains n integers a_1, a_2, ..., a_n (-30 \u2264 a_i \u2264 30) \u2014 the values on the cards.\\n\\nOutput\\n\\nPrint a single integer \u2014 the final score of the game.\\n\\nExamples\\n\\nInput\\n\\n\\n5\\n5 -2 10 -1 4\\n\\n\\nOutput\\n\\n\\n6\\n\\n\\nInput\\n\\n\\n8\\n5 2 5 3 -30 -30 6 9\\n\\n\\nOutput\\n\\n\\n10\\n\\n\\nInput\\n\\n\\n3\\n-10 6 -15\\n\\n\\nOutput\\n\\n\\n0\\n\\nNote\\n\\nIn the first example Alice chooses a segment [1;5] \u2014 the entire row of cards. Bob removes card 3 with the value 10 from the segment. Thus, the final score is 5 + (-2) + (-1) + 4 = 6.\\n\\nIn the second example Alice chooses a segment [1;4], so that Bob removes either card 1 or 3 with the value 5, making the answer 5 + 2 + 3 = 10.\\n\\nIn the third example Alice can choose any of the segments of length 1: [1;1], [2;2] or [3;3]. Bob removes the only card, so the score is 0. If Alice chooses some other segment then the answer will be less than 0.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nvector<long long> mint, maxt;\\nvector<long long> dp;\\nvoid build(long long v, long long l, long long r) {\\n  if (l + 1 == r) {\\n    mint[v] = maxt[v] = dp[l];\\n    return;\\n  }\\n  long long m = (r + l) \\/ 2;\\n  build(2 * v + 1, l, m);\\n  build(2 * v + 2, m, r);\\n  mint[v] = min(mint[2 * v + 1], mint[2 * v + 2]);\\n  maxt[v] = max(maxt[2 * v + 1], maxt[2 * v + 2]);\\n}\\nlong long maxi(long long v, long long l, long long r, long long L,\\n               long long R) {\\n  if (l >= L && r <= R) {\\n    return maxt[v];\\n  }\\n  if (l >= R || r <= L) {\\n    return -1e18;\\n  }\\n  long long m = (r + l) \\/ 2;\\n  return max(maxi(2 * v + 1, l, m, L, R), maxi(2 * v + 2, m, r, L, R));\\n}\\nlong long mini(long long v, long long l, long long r, long long L,\\n               long long R) {\\n  if (l >= L && r <= R) {\\n    return mint[v];\\n  }\\n  if (l >= R || r <= L) {\\n    return 1e18;\\n  }\\n  long long m = (r + l) \\/ 2;\\n  return min(mini(2 * v + 1, l, m, L, R), mini(2 * v + 2, m, r, L, R));\\n}\\nsigned main() {\\n  ios_base::sync_with_stdio(false);\\n  cin.tie(NULL);\\n  cout.tie(NULL);\\n  long long n;\\n  cin >> n;\\n  vector<long long> p(n);\\n  for (auto &x : p) {\\n    cin >> x;\\n  }\\n  dp.assign(n + 1, 0);\\n  for (int i = 0; i < n; i++) {\\n    dp[i + 1] = dp[i] + p[i];\\n  }\\n  mint.resize(4 * (dp.size()));\\n  maxt.resize(4 * (dp.size()));\\n  build(0, 0, dp.size());\\n  vector<map<long long, long long> > left(n + 1), right(n + 1);\\n  map<long long, long long> last;\\n  for (int i = -30; i <= 30; i++) {\\n    last[i] = -1;\\n  }\\n  for (int i = 0; i < n; i++) {\\n    left[i + 1] = last;\\n    last[p[i]] = i + 1;\\n  }\\n  for (int i = -30; i <= 30; i++) {\\n    last[i] = dp.size();\\n  }\\n  for (int i = n - 1; i >= 0; i--) {\\n    right[i + 1] = last;\\n    last[p[i]] = i + 1;\\n  }\\n  long long ans = 0;\\n  for (int i = 0; i < n; i++) {\\n    long long l = -1;\\n    for (int j = p[i] + 1; j <= 30; j++) {\\n      l = max(l, left[i + 1][j]);\\n    }\\n    long long r = dp.size();\\n    for (int j = p[i] + 1; j <= 30; j++) {\\n      r = min(r, right[i + 1][j]);\\n    }\\n    long long maxx =...\",\"language\":\"python\",\"split\":\"train\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in CPP?\\nOn a circle lie 2n distinct points, with the following property: however you choose 3 chords that connect 3 disjoint pairs of points, no point strictly inside the circle belongs to all 3 chords. The points are numbered 1,   2,   ...,   2n in clockwise order.\\n\\nInitially, k chords connect k pairs of points, in such a way that all the 2k endpoints of these chords are distinct.\\n\\nYou want to draw n - k additional chords that connect the remaining 2(n - k) points (each point must be an endpoint of exactly one chord).\\n\\nIn the end, let x be the total number of intersections among all n chords. Compute the maximum value that x can attain if you choose the n - k chords optimally.\\n\\nNote that the exact position of the 2n points is not relevant, as long as the property stated in the first paragraph holds.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 100) \u2014 the number of test cases. Then t test cases follow.\\n\\nThe first line of each test case contains two integers n and k (1 \u2264 n \u2264 100, 0 \u2264 k \u2264 n) \u2014 half the number of points and the number of chords initially drawn.\\n\\nThen k lines follow. The i-th of them contains two integers x_i and y_i (1 \u2264 x_i,   y_i \u2264 2n, x_i \u2260 y_i) \u2014 the endpoints of the i-th chord. It is guaranteed that the 2k numbers x_1,   y_1,   x_2,   y_2,   ...,   x_k,   y_k are all distinct.\\n\\nOutput\\n\\nFor each test case, output the maximum number of intersections that can be obtained by drawing n - k additional chords.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n4 2\\n8 2\\n1 5\\n1 1\\n2 1\\n2 0\\n10 6\\n14 6\\n2 20\\n9 10\\n13 18\\n15 12\\n11 7\\n\\n\\nOutput\\n\\n\\n4\\n0\\n1\\n14\\n\\nNote\\n\\nIn the first test case, there are three ways to draw the 2 additional chords, shown below (black chords are the ones initially drawn, while red chords are the new ones):\\n\\n<image>\\n\\nWe see that the third way gives the maximum number of intersections, namely 4.\\n\\nIn the second test case, there are no more chords to draw. Of course, with only one chord present there are no intersections.\\n\\nIn the third test case, we can make at most one intersection by drawing chords 1-3 and 2-4, as...\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\ntemplate <class T>\\nint size(const T& x) {\\n  return x.size();\\n}\\nconst int INF_INT = numeric_limits<int>::max();\\nvoid CMaximizeTheIntersections(std::istream& in, std::ostream& out) {\\n  int n, k;\\n  in >> n >> k;\\n  vector<int> x(k), y(k);\\n  vector<pair<int, int> > chords(k);\\n  vector<int> occ(2 * n, 0);\\n  for (int i = 0; i < k; i++) {\\n    in >> x[i] >> y[i];\\n    x[i]--;\\n    y[i]--;\\n    if (x[i] > y[i]) swap(x[i], y[i]);\\n    chords[i] = {x[i], y[i]};\\n    occ[x[i]] = occ[y[i]] = 1;\\n  }\\n  vector<int> mapfree;\\n  for (int i = 0; i < 2 * n; i++) {\\n    if (!occ[i]) mapfree.push_back(i);\\n  }\\n  for (int i = 0; i < (n - k); i++) {\\n    chords.push_back({mapfree[i], mapfree[i + (n - k)]});\\n  }\\n  auto chords_conn = [&](pair<int, int> c1, pair<int, int> c2) {\\n    if (c1.first > c2.first) swap(c1, c2);\\n    int c1x = c1.first, c1y = c1.second;\\n    int c2x = c2.first, c2y = c2.second;\\n    if (c2x < c1y && c2y > c1y)\\n      return true;\\n    else\\n      return false;\\n  };\\n  int ret = 0;\\n  for (int i = 0; i < n; i++)\\n    for (int j = i + 1; j < n; ++j) ret += chords_conn(chords[i], chords[j]);\\n  out << ret << '\\\\n';\\n}\\nstruct Solver {\\n  void solve(std::istream& in, std::ostream& out) {\\n    return CMaximizeTheIntersections(in, out);\\n  }\\n};\\nint main() {\\n  std::ios_base::sync_with_stdio(false), std::cin.tie(NULL),\\n      std::cout.tie(NULL);\\n  Solver solver;\\n  std::istream& in(std::cin);\\n  std::ostream& out(std::cout);\\n  int n;\\n  in >> n;\\n  for (int i = 0; i < n; ++i) {\\n    solver.solve(in, out);\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"A robot cleaner is placed on the floor of a rectangle room, surrounded by walls. The floor consists of n rows and m columns. The rows of the floor are numbered from 1 to n from top to bottom, and columns of the floor are numbered from 1 to m from left to right. The cell on the intersection of the r-th row and the c-th column is denoted as (r,c). The initial position of the robot is (r_b, c_b).\\n\\nIn one second, the robot moves by dr rows and dc columns, that is, after one second, the robot moves from the cell (r, c) to (r + dr, c + dc). Initially dr = 1, dc = 1. If there is a vertical wall (the left or the right walls) in the movement direction, dc is reflected before the movement, so the new value of dc is -dc. And if there is a horizontal wall (the upper or lower walls), dr is reflected before the movement, so the new value of dr is -dr.\\n\\nEach second (including the moment before the robot starts moving), the robot cleans every cell lying in the same row or the same column as its position. There is only one dirty cell at (r_d, c_d). The job of the robot is to clean that dirty cell.\\n\\n<image> Illustration for the first example. The blue arc is the robot. The red star is the target dirty cell. Each second the robot cleans a row and a column, denoted by yellow stripes.\\n\\nGiven the floor size n and m, the robot's initial position (r_b, c_b) and the dirty cell's position (r_d, c_d), find the time for the robot to do its job.\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 10^4). Description of the test cases follows.\\n\\nA test case consists of only one line, containing six integers n, m, r_b, c_b, r_d, and c_d (1 \u2264 n, m \u2264 100, 1 \u2264 r_b, r_d \u2264 n, 1 \u2264 c_b, c_d \u2264 m) \u2014 the sizes of the room, the initial position of the robot and the position of the dirt cell.\\n\\nOutput\\n\\nFor each test case, print an integer \u2014 the time for the robot to clean the dirty cell. We can show that the robot always cleans the dirty cell eventually.\\n\\nExample\\n\\nInput\\n\\n\\n5\\n10 10 6 1 2 8\\n10 10 9 9 1...\\nUsing python3 can you solve the prior task?\",\"targets\":\"n = int(input())\\n\\nfor i in range(0, n):\\n    x = 1\\n    y = 1\\n    n, m, rb, cb, rd, cd = map(int, input().split())\\n    c = 0\\n    while True:\\n        if rb == rd or cb == cd:\\n            print(c)\\n            break\\n        if rb == 1:\\n            y = 1\\n        if rb == n:\\n            y = -1\\n        if cb == 1:\\n            x = 1\\n        if cb == m:\\n            x = -1\\n\\n        rb += y\\n        cb += x\\n\\n        c += 1\",\"language\":\"python\",\"split\":\"test\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"A coordinate line has n segments, the i-th segment starts at the position li and ends at the position ri. We will denote such a segment as [li, ri].\\n\\nYou have suggested that one of the defined segments covers all others. In other words, there is such segment in the given set, which contains all other ones. Now you want to test your assumption. Find in the given set the segment which covers all other segments, and print its number. If such a segment doesn't exist, print -1.\\n\\nFormally we will assume that segment [a, b] covers segment [c, d], if they meet this condition a \u2264 c \u2264 d \u2264 b. \\n\\nInput\\n\\nThe first line contains integer n (1 \u2264 n \u2264 105) \u2014 the number of segments. Next n lines contain the descriptions of the segments. The i-th line contains two space-separated integers li, ri (1 \u2264 li \u2264 ri \u2264 109) \u2014 the borders of the i-th segment.\\n\\nIt is guaranteed that no two segments coincide.\\n\\nOutput\\n\\nPrint a single integer \u2014 the number of the segment that covers all other segments in the set. If there's no solution, print -1.\\n\\nThe segments are numbered starting from 1 in the order in which they appear in the input.\\n\\nExamples\\n\\nInput\\n\\n3\\n1 1\\n2 2\\n3 3\\n\\n\\nOutput\\n\\n-1\\n\\n\\nInput\\n\\n6\\n1 5\\n2 3\\n1 10\\n7 10\\n7 7\\n10 10\\n\\n\\nOutput\\n\\n3\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint main() {\\n  int n, left, right;\\n  vector<vector<int>> vii;\\n  vector<int> v;\\n  cin >> n;\\n  for (int i = 0; i < n; i++) {\\n    cin >> left >> right;\\n    v.push_back(left);\\n    v.push_back(right);\\n    vii.push_back(v);\\n    v.clear();\\n  }\\n  int minLeft = vii[0][0], maxRight = vii[0][1];\\n  for (int i = 1; i < vii.size(); i++) {\\n    if (minLeft > vii[i][0]) {\\n      minLeft = vii[i][0];\\n    }\\n    if (maxRight < vii[i][1]) {\\n      maxRight = vii[i][1];\\n    }\\n  }\\n  for (int i = 0; i < vii.size(); i++) {\\n    if (vii[i][0] == minLeft && vii[i][1] == maxRight) {\\n      cout << i + 1;\\n      return 0;\\n    }\\n  }\\n  cout << -1;\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You are given an array a of length n.\\n\\nLet's define the eversion operation. Let x = a_n. Then array a is partitioned into two parts: left and right. The left part contains the elements of a that are not greater than x (\u2264 x). The right part contains the elements of a that are strictly greater than x (> x). The order of elements in each part is kept the same as before the operation, i. e. the partition is stable. Then the array is replaced with the concatenation of the left and the right parts.\\n\\nFor example, if the array a is [2, 4, 1, 5, 3], the eversion goes like this: [2, 4, 1, 5, 3] \u2192 [2, 1, 3], [4, 5] \u2192 [2, 1, 3, 4, 5].\\n\\nWe start with the array a and perform eversions on this array. We can prove that after several eversions the array a stops changing. Output the minimum number k such that the array stops changing after k eversions.\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 100). Description of the test cases follows.\\n\\nThe first line contains a single integer n (1 \u2264 n \u2264 2 \u22c5 10^5).\\n\\nThe second line contains n integers a_1, a_2, ..., a_n (1 \u2264 a_i \u2264 10^9).\\n\\nIt is guaranteed that the sum of n over all test cases does not exceed 2 \u22c5 10^5.\\n\\nOutput\\n\\nFor each test case print a single integer k \u2014 the number of eversions after which the array stops changing.\\n\\nExample\\n\\nInput\\n\\n\\n3\\n5\\n2 4 1 5 3\\n5\\n5 3 2 4 1\\n4\\n1 1 1 1\\n\\n\\nOutput\\n\\n\\n1\\n2\\n0\\n\\nNote\\n\\nConsider the fist example.\\n\\n  * The first eversion: a = [1, 4, 2, 5, 3], x = 3. [2, 4, 1, 5, 3] \u2192 [2, 1, 3], [4, 5] \u2192 [2, 1, 3, 4, 5]. \\n  * The second and following eversions: a = [2, 1, 3, 4, 5], x = 5. [2, 1, 3, 4, 5] \u2192 [2, 1, 3, 4, 5], [] \u2192 [2, 1, 3, 4, 5]. This eversion does not change the array, so the answer is 1. \\n\\n\\n\\nConsider the second example. \\n\\n  * The first eversion: a = [5, 3, 2, 4, 1], x = 1. [5, 3, 2, 4, 1] \u2192 [1], [5, 3, 2, 4] \u2192 [1, 5, 3, 2, 4]. \\n  * The second eversion: a = [1, 5, 3, 2, 4], x = 4. [1, 5, 3, 2, 4] \u2192 [1, 3, 2, 4], [5] \u2192 [1, 3, 2, 4, 5]. \\n  * The third and following eversions: a = [1, 3, 2, 4,...\\nSolve the task in PYTHON3.\",\"targets\":\"t=int(input())\\nfor i in range(t):\\n    n=int(input())\\n    a=list(map(int,input().split()))\\n    b=a[::-1]\\n    m=b[0]\\n    ans=0\\n    for j in range(n):\\n        if m<b[j]:\\n            ans+=1\\n            m=b[j]\\n    print(ans)\",\"language\":\"python\",\"split\":\"test\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Polycarp doesn't like integers that are divisible by 3 or end with the digit 3 in their decimal representation. Integers that meet both conditions are disliked by Polycarp, too.\\n\\nPolycarp starts to write out the positive (greater than 0) integers which he likes: 1, 2, 4, 5, 7, 8, 10, 11, 14, 16, .... Output the k-th element of this sequence (the elements are numbered from 1).\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 100) \u2014 the number of test cases. Then t test cases follow.\\n\\nEach test case consists of one line containing one integer k (1 \u2264 k \u2264 1000).\\n\\nOutput\\n\\nFor each test case, output in a separate line one integer x \u2014 the k-th element of the sequence that was written out by Polycarp.\\n\\nExample\\n\\nInput\\n\\n\\n10\\n1\\n2\\n3\\n4\\n5\\n6\\n7\\n8\\n9\\n1000\\n\\n\\nOutput\\n\\n\\n1\\n2\\n4\\n5\\n7\\n8\\n10\\n11\\n14\\n1666\",\"targets\":\"import java.util.Scanner;\\n\\npublic class A9 {\\n    public static void main(String[] args)\\n    {\\n        Scanner sc = new Scanner(System.in);\\n        int [] array= new int[2005];\\n        int num = 0;\\n        for(int i=1;i<=2000;i++)\\n        {\\n            int count=i;\\n            if(count % 3 == 0) continue;\\n            int p = count%10;\\n            if(p == 3) {\\n                    continue;\\n            }\\n             array[++ num] = i;\\n        }\\n\\n        int size = sc.nextInt();\\n        while(size > 0)\\n        {\\n            int k;\\n            k = sc.nextInt();\\n            int ans = array[k];\\n            System.out.println(ans);\\n            size--;\\n        }\\n\\n    }\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"This is a simplified version of the problem B2. Perhaps you should read the problem B2 before you start solving B1.\\n\\nPaul and Mary have a favorite string s which consists of lowercase letters of the Latin alphabet. They want to paint it using pieces of chalk of two colors: red and green. Let's call a coloring of a string wonderful if the following conditions are met:\\n\\n  1. each letter of the string is either painted in exactly one color (red or green) or isn't painted; \\n  2. each two letters which are painted in the same color are different; \\n  3. the number of letters painted in red is equal to the number of letters painted in green; \\n  4. the number of painted letters of this coloring is maximum among all colorings of the string which meet the first three conditions. \\n\\n\\n\\nE. g. consider a string s equal to \\\"kzaaa\\\". One of the wonderful colorings of the string is shown in the figure.\\n\\n<image> The example of a wonderful coloring of the string \\\"kzaaa\\\".\\n\\nPaul and Mary want to learn by themselves how to find a wonderful coloring of the string. But they are very young, so they need a hint. Help them find k \u2014 the number of red (or green, these numbers are equal) letters in a wonderful coloring.\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 1000) \u2014 the number of test cases. Then t test cases follow.\\n\\nEach test case consists of one non-empty string s which consists of lowercase letters of the Latin alphabet. The number of characters in the string doesn't exceed 50.\\n\\nOutput\\n\\nFor each test case, output a separate line containing one non-negative integer k \u2014 the number of letters which will be painted in red in a wonderful coloring.\\n\\nExample\\n\\nInput\\n\\n\\n5\\nkzaaa\\ncodeforces\\narchive\\ny\\nxxxxxx\\n\\n\\nOutput\\n\\n\\n2\\n5\\n3\\n0\\n1\\n\\nNote\\n\\nThe first test case contains the string from the statement. One of the wonderful colorings is shown in the figure. There's no wonderful coloring containing 3 or more red letters because the total number of painted symbols will exceed the string's length.\\n\\nThe string from the second test case can be...\",\"targets\":\"import java.util.*;\\n\\npublic class coloring {\\n    \\n    public static int color (String a) {\\n        \\n        int answer = 0;\\n        int single = 0;\\n        int array [] = new int [26];\\n        \\n        for (int i = 0; i < 26; i++) {\\n            array[i] = 0;\\n        }\\n        \\n        for (int i = 0; i < a.length(); i++){\\n            array[ a.charAt(i) - 'a' ]++;\\n        }\\n        \\n        for (int i = 0; i < array.length; i++) {\\n            if (array[i] >= 2) {\\n                answer++;\\n            } else if (array[i] == 1) {\\n                single++;\\n            } \\n        }\\n        \\n        answer = answer + (single\\/2);\\n        return (answer);\\n    }\\n\\n    \\n    public static void main (String args[]) {\\n        \\n        Scanner scan = new Scanner (System.in);\\n        \\n        scan.nextLine();\\n        \\n        while (scan.hasNext()) {\\n            String n = scan.nextLine();\\n            System.out.println(color(n));\\n        }\\n    }\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"This is the easy version of the problem. The difference between the versions is that the easy version does not require you to output the numbers of the rods to be removed. You can make hacks only if all versions of the problem are solved.\\n\\nStitch likes experimenting with different machines with his friend Sparky. Today they built another machine.\\n\\nThe main element of this machine are n rods arranged along one straight line and numbered from 1 to n inclusive. Each of these rods must carry an electric charge quantitatively equal to either 1 or -1 (otherwise the machine will not work). Another condition for this machine to work is that the sign-variable sum of the charge on all rods must be zero.\\n\\nMore formally, the rods can be represented as an array of n numbers characterizing the charge: either 1 or -1. Then the condition must hold: a_1 - a_2 + a_3 - a_4 + \u2026 = 0, or \u2211_{i=1}^n (-1)^{i-1} \u22c5 a_i = 0.\\n\\nSparky charged all n rods with an electric current, but unfortunately it happened that the rods were not charged correctly (the sign-variable sum of the charge is not zero). The friends decided to leave only some of the rods in the machine. Sparky has q questions. In the ith question Sparky asks: if the machine consisted only of rods with numbers l_i to r_i inclusive, what minimal number of rods could be removed from the machine so that the sign-variable sum of charges on the remaining ones would be zero? Perhaps the friends got something wrong, and the sign-variable sum is already zero. In that case, you don't have to remove the rods at all.\\n\\nIf the number of rods is zero, we will assume that the sign-variable sum of charges is zero, that is, we can always remove all rods.\\n\\nHelp your friends and answer all of Sparky's questions!\\n\\nInput\\n\\nEach test contains multiple test cases.\\n\\nThe first line contains one positive integer t (1 \u2264 t \u2264 10^3), denoting the number of test cases. Description of the test cases follows.\\n\\nThe first line of each test case contains two positive integers n and q (1 \u2264 n, q \u2264 3 \u22c5 10^5) \u2014 the...\\nSolve the task in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\ntemplate <typename T>\\nostream& operator<<(ostream& os, const vector<T>& v) {\\n  os << \\\"[\\\";\\n  for (int i = 0; i < (int)v.size(); ++i) {\\n    os << v[i];\\n    if (i != (int)v.size() - 1) os << \\\", \\\";\\n  }\\n  os << \\\"]\\\\n\\\";\\n  return os;\\n}\\ntemplate <typename T, typename U>\\nostream& operator<<(ostream& os, const pair<T, U>& p) {\\n  os << \\\"[\\\";\\n  os << p.first;\\n  os << \\\", \\\";\\n  os << p.second;\\n  os << \\\"]\\\";\\n  return os;\\n}\\nconst int N = 2e5 + 5;\\nconst int mod = 1e9 + 7;\\nlong long binpow(long long a, long long b, long long p) {\\n  if (b == 0) return 1;\\n  long long t = binpow(a, b \\/ 2, p);\\n  if (b % 2)\\n    return (((a * t) % p) * t) % p;\\n  else\\n    return ((t * t) % p);\\n}\\nvoid solve() {\\n  int n, q;\\n  string s;\\n  cin >> n >> q >> s;\\n  vector<int> od(n + 1, 0), ev(n + 1, 0);\\n  for (int i = 0; i < n; i++) {\\n    if ((i + 1) % 2) {\\n      od[i + 1] = od[i] + (s[i] == '+' ? 1 : -1);\\n      ev[i + 1] = ev[i];\\n    } else {\\n      ev[i + 1] = ev[i] + (s[i] == '+' ? 1 : -1);\\n      od[i + 1] = od[i];\\n    }\\n  }\\n  42;\\n  while (q--) {\\n    int l, r;\\n    cin >> l >> r;\\n    if (l == r) {\\n      cout << \\\"1\\\\n\\\";\\n      continue;\\n    }\\n    long long x, y;\\n    if (l % 2) {\\n      x = od[r] - od[l - 1], y = ev[r] - ev[l - 1];\\n    } else {\\n      y = od[r] - od[l - 1], x = ev[r] - ev[l - 1];\\n    }\\n    if (x - y == 0)\\n      cout << \\\"0\\\\n\\\";\\n    else if (abs(x - y) % 2 == 1)\\n      cout << \\\"1\\\\n\\\";\\n    else\\n      cout << \\\"2\\\\n\\\";\\n  }\\n}\\nint main() {\\n  ios_base::sync_with_stdio(0);\\n  cin.tie(0);\\n  cout.tie(0);\\n  int t = 1;\\n  cin >> t;\\n  for (int i = 1; i <= t; i++) {\\n    solve();\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Monocarp has got an array a consisting of n integers. Let's denote k as the mathematic mean of these elements (note that it's possible that k is not an integer). \\n\\nThe mathematic mean of an array of n elements is the sum of elements divided by the number of these elements (i. e. sum divided by n).\\n\\nMonocarp wants to delete exactly two elements from a so that the mathematic mean of the remaining (n - 2) elements is still equal to k.\\n\\nYour task is to calculate the number of pairs of positions [i, j] (i < j) such that if the elements on these positions are deleted, the mathematic mean of (n - 2) remaining elements is equal to k (that is, it is equal to the mathematic mean of n elements of the original array a).\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 10^4) \u2014 the number of testcases.\\n\\nThe first line of each testcase contains one integer n (3 \u2264 n \u2264 2 \u22c5 10^5) \u2014 the number of elements in the array.\\n\\nThe second line contains a sequence of integers a_1, a_2, ..., a_n (0 \u2264 a_i \u2264 10^{9}), where a_i is the i-th element of the array.\\n\\nThe sum of n over all testcases doesn't exceed 2 \u22c5 10^5.\\n\\nOutput\\n\\nPrint one integer \u2014 the number of pairs of positions [i, j] (i < j) such that if the elements on these positions are deleted, the mathematic mean of (n - 2) remaining elements is equal to k (that is, it is equal to the mathematic mean of n elements of the original array a).\\n\\nExample\\n\\nInput\\n\\n\\n4\\n4\\n8 8 8 8\\n3\\n50 20 10\\n5\\n1 4 7 3 5\\n7\\n1 2 3 4 5 6 7\\n\\n\\nOutput\\n\\n\\n6\\n0\\n2\\n3\\n\\nNote\\n\\nIn the first example, any pair of elements can be removed since all of them are equal.\\n\\nIn the second example, there is no way to delete two elements so the mathematic mean doesn't change.\\n\\nIn the third example, it is possible to delete the elements on positions 1 and 3, or the elements on positions 4 and 5.\\nSolve the task in JAVA.\",\"targets\":\"import java.io.*;\\nimport java.util.HashMap;\\nimport java.util.StringTokenizer;\\n\\npublic class C {\\n\\n    static FastScanner sc = new FastScanner();\\n    static PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));\\n\\n    static void solve(){\\n        int n = sc.nextInt();\\n        long[]arr = new long[n];\\n        long sum = 0;\\n        HashMap<Long,Long>map = new HashMap<>();\\n        for (int i = 0; i < n; i++) {\\n            arr[i] = sc.nextLong();\\n            sum += arr[i];\\n            map.put(arr[i],map.getOrDefault(arr[i],0l) + 1);\\n        }\\n        if((2 * sum % n) != 0){\\n            System.out.println(0);\\n            return;\\n        }\\n        long target = 2 * sum \\/ n;\\n        long ans = 0;\\n        for (int i = 0; i < n; i++) {\\n            long l = arr[i],r = target - arr[i];\\n            if(l == r){\\n                Long cnt = map.getOrDefault(arr[i], 0l);\\n                if(cnt > 0){\\n                    ans += cnt * (cnt - 1) \\/ 2;\\n                }\\n            }else{\\n                ans += map.getOrDefault(target - arr[i],0l) * map.getOrDefault(arr[i],0l);\\n            }\\n            map.put(l,0l);\\n            map.put(r,0l);\\n        }\\n        System.out.println(ans);\\n    }\\n\\n    public static void main(String[] args) {\\n        int n = sc.nextInt();\\n        for(int i = 0;i < n;i++){\\n            solve();\\n        }\\n    }\\n\\n\\n    static class FastScanner {\\n        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));\\n        StringTokenizer st=new StringTokenizer(\\\"\\\");\\n        String next() {\\n            while (!st.hasMoreTokens())\\n                try {\\n                    st=new StringTokenizer(br.readLine());\\n                } catch (IOException e) {\\n                    e.printStackTrace();\\n                }\\n            return st.nextToken();\\n        }\\n\\n        int nextInt() {\\n            return Integer.parseInt(next());\\n        }\\n        int[] readArray(int n) {\\n            int[] a=new int[n];\\n            for (int i=0; i<n; i++) a[i]=nextInt();\\n            return a;\\n        }\\n       ...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Berland Football Cup starts really soon! Commentators from all over the world come to the event.\\n\\nOrganizers have already built n commentary boxes. m regional delegations will come to the Cup. Every delegation should get the same number of the commentary boxes. If any box is left unoccupied then the delegations will be upset. So each box should be occupied by exactly one delegation.\\n\\nIf n is not divisible by m, it is impossible to distribute the boxes to the delegations at the moment.\\n\\nOrganizers can build a new commentary box paying a burles and demolish a commentary box paying b burles. They can both build and demolish boxes arbitrary number of times (each time paying a corresponding fee). It is allowed to demolish all the existing boxes.\\n\\nWhat is the minimal amount of burles organizers should pay to satisfy all the delegations (i.e. to make the number of the boxes be divisible by m)?\\n\\nInput\\n\\nThe only line contains four integer numbers n, m, a and b (1 \u2264 n, m \u2264 10^{12}, 1 \u2264 a, b \u2264 100), where n is the initial number of the commentary boxes, m is the number of delegations to come, a is the fee to build a box and b is the fee to demolish a box.\\n\\nOutput\\n\\nOutput the minimal amount of burles organizers should pay to satisfy all the delegations (i.e. to make the number of the boxes be divisible by m). It is allowed that the final number of the boxes is equal to 0.\\n\\nExamples\\n\\nInput\\n\\n9 7 3 8\\n\\n\\nOutput\\n\\n15\\n\\n\\nInput\\n\\n2 7 3 7\\n\\n\\nOutput\\n\\n14\\n\\n\\nInput\\n\\n30 6 17 19\\n\\n\\nOutput\\n\\n0\\n\\nNote\\n\\nIn the first example organizers can build 5 boxes to make the total of 14 paying 3 burles for the each of them.\\n\\nIn the second example organizers can demolish 2 boxes to make the total of 0 paying 7 burles for the each of them.\\n\\nIn the third example organizers are already able to distribute all the boxes equally among the delegations, each one get 5 boxes.\\nSolve the task in JAVA.\",\"targets\":\"import java.util.*;\\npublic class first{\\n\\tpublic static void main(String args[]){\\n\\t\\tlong n, m, a, b;\\n\\t\\tScanner scan = new Scanner(System.in);\\n\\t\\tn = scan.nextLong();\\n\\t\\tm = scan.nextLong();\\n\\t\\ta = scan.nextLong();\\n\\t\\tb = scan.nextLong();\\n\\t\\tif(n%m==0){\\n\\t\\t\\tSystem.out.println(\\\"0\\\");\\n\\t\\t}\\n\\t\\telse{\\n\\t\\t\\tif(n>m){\\n\\t\\t\\t\\tlong k = n\\/m;\\n\\t\\t\\t\\tlong u = m*k;\\n\\t\\t\\t\\tlong d = m*(k+1);\\n\\t\\t\\t\\tlong cost_u, cost_d;\\n\\t\\t\\t\\tcost_u= (n-u)*b;\\n\\t\\t\\t\\tcost_d= (d-n)*a;\\n\\t\\t\\t\\tif(cost_u < cost_d){\\n\\t\\t\\t\\t\\tSystem.out.println(cost_u);\\n\\t\\t\\t\\t}\\n\\t\\t\\t\\telse{\\n\\t\\t\\t\\t\\tSystem.out.println(cost_d);\\n\\t\\t\\t\\t}\\n\\t\\t\\t}\\n\\t\\t\\telse{\\n\\t\\t\\t\\tlong cost_u = (m-n)*a;\\n\\t\\t\\t\\tlong cost_d = n*b;\\n\\t\\t\\t\\tif(cost_u < cost_d){\\n                                        System.out.println(cost_u);\\n                                }\\n                                else{\\n                                        System.out.println(cost_d);\\n                                }\\n\\t\\t\\t}\\n\\t\\t}\\n\\t}\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Given a positive integer n. Find three distinct positive integers a, b, c such that a + b + c = n and \\\\operatorname{gcd}(a, b) = c, where \\\\operatorname{gcd}(x, y) denotes the [greatest common divisor (GCD)](https:\\/\\/en.wikipedia.org\\/wiki\\/Greatest_common_divisor) of integers x and y.\\n\\nInput\\n\\nThe input consists of multiple test cases. The first line contains a single integer t (1 \u2264 t \u2264 10^5) \u2014 the number of test cases. Description of the test cases follows.\\n\\nThe first and only line of each test case contains a single integer n (10 \u2264 n \u2264 10^9).\\n\\nOutput\\n\\nFor each test case, output three distinct positive integers a, b, c satisfying the requirements. If there are multiple solutions, you can print any. We can show that an answer always exists.\\n\\nExample\\n\\nInput\\n\\n\\n6\\n18\\n63\\n73\\n91\\n438\\n122690412\\n\\n\\nOutput\\n\\n\\n6 9 3\\n21 39 3\\n29 43 1\\n49 35 7\\n146 219 73\\n28622 122661788 2\\n\\nNote\\n\\nIn the first test case, 6 + 9 + 3 = 18 and \\\\operatorname{gcd}(6, 9) = 3.\\n\\nIn the second test case, 21 + 39 + 3 = 63 and \\\\operatorname{gcd}(21, 39) = 3.\\n\\nIn the third test case, 29 + 43 + 1 = 73 and \\\\operatorname{gcd}(29, 43) = 1.\\nimpor\",\"targets\":\"t math\\ndef isprime(x):\\n    i=2\\n    while(i*i<=x):\\n        if x%i==0:\\n            return 0\\n        i=i+1\\n    return 1\\ndef abc(n):\\n    if (n-1)%2!=0:\\n        return str((n-1)\\/\\/2)+' '+str(((n-1)\\/\\/2)+1)+' '+str(1)\\n    else:\\n        h=(n-1)\\/\\/2\\n        if h%2==0:\\n            return str(h-1)+' '+str(h+1)+' '+str(1)\\n        else:\\n            return str(h-2)+' '+str(h+2)+' '+str(1)\\n            \\nt=int(input())\\nl=[]\\nfor x in range(t):\\n    n=int(input())\\n    l.append(n)\\nop=[]\\nfor x in l:\\n    ans=abc(x)\\n    op.append(ans)\\nfor o in op:\\n    print(o)\",\"language\":\"python\",\"split\":\"test\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"When you play the game of thrones, you win, or you die. There is no middle ground.\\n\\nCersei Lannister, A Game of Thrones by George R. R. Martin\\n\\nThere are n nobles, numbered from 1 to n. Noble i has a power of i. There are also m \\\"friendships\\\". A friendship between nobles a and b is always mutual.\\n\\nA noble is defined to be vulnerable if both of the following conditions are satisfied: \\n\\n  * the noble has at least one friend, and \\n  * all of that noble's friends have a higher power. \\n\\n\\n\\nYou will have to process the following three types of queries. \\n\\n  1. Add a friendship between nobles u and v. \\n  2. Remove a friendship between nobles u and v. \\n  3. Calculate the answer to the following process. \\n\\n\\n\\nThe process: all vulnerable nobles are simultaneously killed, and all their friendships end. Then, it is possible that new nobles become vulnerable. The process repeats itself until no nobles are vulnerable. It can be proven that the process will end in finite time. After the process is complete, you need to calculate the number of remaining nobles.\\n\\nNote that the results of the process are not carried over between queries, that is, every process starts with all nobles being alive!\\n\\nInput\\n\\nThe first line contains the integers n and m (1 \u2264 n \u2264 2\u22c5 10^5, 0 \u2264 m \u2264 2\u22c5 10^5) \u2014 the number of nobles and number of original friendships respectively.\\n\\nThe next m lines each contain the integers u and v (1 \u2264 u,v \u2264 n, u \u2260 v), describing a friendship. No friendship is listed twice.\\n\\nThe next line contains the integer q (1 \u2264 q \u2264 2\u22c5 {10}^{5}) \u2014 the number of queries. \\n\\nThe next q lines contain the queries themselves, each query has one of the following three formats. \\n\\n  * 1 u v (1 \u2264 u,v \u2264 n, u \u2260 v) \u2014 add a friendship between u and v. It is guaranteed that u and v are not friends at this moment. \\n  * 2 u v (1 \u2264 u,v \u2264 n, u \u2260 v) \u2014 remove a friendship between u and v. It is guaranteed that u and v are friends at this moment. \\n  * 3 \u2014 print the answer to the process described in the statement. \\n\\nOutput\\n\\nFor each type 3 query print one...\\nfrom\",\"targets\":\"sys import stdin, stdout\\n\\ndef get_ints():\\n    return map(int, stdin.readline().strip().split())\\n\\ndef get_list_ints():\\n    return list(map(int, stdin.readline().strip().split()))\\n\\ndef get_string():\\n    return stdin.readline().strip()\\n\\n##def println(s):\\n##    stdout.write(str(s) + '\\\\n')\\n##\\n##def print(s):\\n##    stdout.write(str(s))\\n\\ndef main():\\n    ans = 0\\n    n, m = get_ints()\\n    cnt = [0] * (n + 1)\\n    for i in range(m):\\n        u, v = get_ints()\\n        if(u > v):\\n            u, v = v, u\\n        cnt[u] += 1\\n    for i in range(1, n + 1):\\n        if(cnt[i] == 0):\\n            ans += 1\\n    q = int(input())\\n    for i in range(q):\\n        query = get_list_ints()\\n        if(query[0] == 3):\\n            print(ans)\\n        else:\\n            u, v = query[1], query[2]\\n            if(u > v):\\n                u, v = v, u\\n            if(query[0] == 1):\\n                if(cnt[u] == 0):\\n                    ans -= 1\\n                cnt[u] += 1\\n            else:\\n                cnt[u] -= 1\\n                if(cnt[u] == 0):\\n                    ans += 1\\n\\n\\nmain()\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"You are given a keyboard that consists of 26 keys. The keys are arranged sequentially in one row in a certain order. Each key corresponds to a unique lowercase Latin letter.\\n\\nYou have to type the word s on this keyboard. It also consists only of lowercase Latin letters.\\n\\nTo type a word, you need to type all its letters consecutively one by one. To type each letter you must position your hand exactly over the corresponding key and press it.\\n\\nMoving the hand between the keys takes time which is equal to the absolute value of the difference between positions of these keys (the keys are numbered from left to right). No time is spent on pressing the keys and on placing your hand over the first letter of the word.\\n\\nFor example, consider a keyboard where the letters from 'a' to 'z' are arranged in consecutive alphabetical order. The letters 'h', 'e', 'l' and 'o' then are on the positions 8, 5, 12 and 15, respectively. Therefore, it will take |5 - 8| + |12 - 5| + |12 - 12| + |15 - 12| = 13 units of time to type the word \\\"hello\\\". \\n\\nDetermine how long it will take to print the word s.\\n\\nInput\\n\\nThe first line contains an integer t (1 \u2264 t \u2264 1000) \u2014 the number of test cases.\\n\\nThe next 2t lines contain descriptions of the test cases.\\n\\nThe first line of a description contains a keyboard \u2014 a string of length 26, which consists only of lowercase Latin letters. Each of the letters from 'a' to 'z' appears exactly once on the keyboard.\\n\\nThe second line of the description contains the word s. The word has a length from 1 to 50 letters inclusive and consists of lowercase Latin letters.\\n\\nOutput\\n\\nPrint t lines, each line containing the answer to the corresponding test case. The answer to the test case is the minimal time it takes to type the word s on the given keyboard.\\n\\nExample\\n\\nInput\\n\\n\\n5\\nabcdefghijklmnopqrstuvwxyz\\nhello\\nabcdefghijklmnopqrstuvwxyz\\ni\\nabcdefghijklmnopqrstuvwxyz\\ncodeforces\\nqwertyuiopasdfghjklzxcvbnm\\nqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\nqwertyuiopasdfghjklzxcvbnm\\nabacaba\\n\\n\\nOutput\\n\\n\\n13\\n0\\n68\\n0\\n74\\nThe above is tricky. Write me a correct solution in JAVA.\",\"targets\":\"import java.util.Scanner;\\n\\npublic class A {\\n    public static void main(String[] args) {\\n        Scanner s = new Scanner(System.in);\\n        int lines = s.nextInt();\\n\\n        s.nextLine();\\n\\n        for (int i = 0; i < lines; i += 1) {\\n            solve(s.next(), s.next());\\n        }\\n    }\\n\\n\\n    public static void solve(String kb, String s) {\\n        int cost = 0;\\n        for (int i = 1; i < s.length(); i++) {\\n            cost += Math.abs(kb.indexOf(s.charAt(i)) - kb.indexOf(s.charAt(i - 1)));\\n        }\\n        System.out.println(cost);\\n    }\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in JAVA?\\nMonocarp is playing yet another computer game. In this game, his character has to kill a dragon. The battle with the dragon lasts 100^{500} seconds, during which Monocarp attacks the dragon with a poisoned dagger. The i-th attack is performed at the beginning of the a_i-th second from the battle start. The dagger itself does not deal damage, but it applies a poison effect on the dragon, which deals 1 damage during each of the next k seconds (starting with the same second when the dragon was stabbed by the dagger). However, if the dragon has already been poisoned, then the dagger updates the poison effect (i.e. cancels the current poison effect and applies a new one).\\n\\nFor example, suppose k = 4, and Monocarp stabs the dragon during the seconds 2, 4 and 10. Then the poison effect is applied at the start of the 2-nd second and deals 1 damage during the 2-nd and 3-rd seconds; then, at the beginning of the 4-th second, the poison effect is reapplied, so it deals exactly 1 damage during the seconds 4, 5, 6 and 7; then, during the 10-th second, the poison effect is applied again, and it deals 1 damage during the seconds 10, 11, 12 and 13. In total, the dragon receives 10 damage.\\n\\nMonocarp knows that the dragon has h hit points, and if he deals at least h damage to the dragon during the battle \u2014 he slays the dragon. Monocarp has not decided on the strength of the poison he will use during the battle, so he wants to find the minimum possible value of k (the number of seconds the poison effect lasts) that is enough to deal at least h damage to the dragon.\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 1000) \u2014 the number of test cases.\\n\\nThe first line of the test case contains two integers n and h (1 \u2264 n \u2264 100; 1 \u2264 h \u2264 10^{18}) \u2014 the number of Monocarp's attacks and the amount of damage that needs to be dealt.\\n\\nThe second line contains n integers a_1, a_2, ..., a_n (1 \u2264 a_i \u2264 10^9; a_i < a_{i + 1}), where a_i is the second when the i-th attack is performed.\\n\\nOutput\\n\\nFor each test case, print a single...\",\"targets\":\"import java.io.BufferedReader;\\nimport java.util.StringTokenizer;\\nimport java.io.InputStreamReader;\\nimport java.io.IOException;\\nimport java.io.PrintWriter;\\nimport java.util.*;\\npublic class C {\\n\\n\\n   \\n\\n    public static void main(String[] args) {\\n        FastReader fr = new FastReader();\\n        PrintWriter out = new PrintWriter(System.out, true);\\n        int cases = fr.nextInt();\\n        for(int c = 0; c < cases; c++) {\\n            int turns = fr.nextInt();\\n            long life = fr.nextLong();\\n            long[] nums = new long[turns];\\n            for(int i = 0; i < turns; i++) {\\n                nums[i] = fr.nextLong();\\n            }\\n            if(turns >= life) {\\n                out.write(1 + \\\"\\\\n\\\");\\n            } else {\\n                long mink = 1;\\n                long maxk = life;\\n                long found = -1;\\n                while(mink < maxk) {\\n                    long mid = mink + ((maxk-mink)\\/2);\\n                    long left = lifeleft(nums, mid, life);\\n                    if(left > 0) {\\n                        mink = mid+1;\\n                    } else if (left < 0) {\\n                        maxk = mid-1;\\n                    } else {\\n                        found = mid;\\n                        break;\\n                    }\\n                }\\n              \\n                if(found > 0) {\\n                    out.write(found + \\\"\\\\n\\\");\\n                } else {\\n                    long l = lifeleft(nums, mink, life);\\n                    if(l > 0) {\\n                        out.write((mink + 1) + \\\"\\\\n\\\");\\n                    } else {\\n                        out.write(mink + \\\"\\\\n\\\");\\n                    }\\n                }\\n            }\\n        }\\n        out.close();\\n    }\\n\\n    static long lifeleft(long nums[], long k, long life) {\\n        long temp = life;\\n        for(int i = 1; i < nums.length; i++) {\\n            temp -= Math.min(k, nums[i] - nums[i-1]);\\n        }\\n        temp -= k;\\n        return temp;\\n    }\\n\\n\\n\\n    static class FastReader {\\n\\n        BufferedReader br;\\n        StringTokenizer st;\\n\\n       ...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"In Berland, n different types of banknotes are used. Banknotes of the i-th type have denomination 10^{a_i} burles (burles are the currency used in Berland); the denomination of banknotes of the first type is exactly 1.\\n\\nLet's denote f(s) as the minimum number of banknotes required to represent exactly s burles. For example, if the denominations of banknotes used in Berland are 1, 10 and 100, then f(59) = 14: 9 banknotes with denomination of 1 burle and 5 banknotes with denomination of 10 burles can be used to represent exactly 9 \u22c5 1 + 5 \u22c5 10 = 59 burles, and there's no way to do it with fewer banknotes.\\n\\nFor a given integer k, find the minimum positive number of burles s that cannot be represented with k or fewer banknotes (that is, f(s) > k).\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 10^4) \u2014 number of test cases.\\n\\nThe first line of each test case contains two integers n and k (1 \u2264 n \u2264 10; 1 \u2264 k \u2264 10^9).\\n\\nThe next line contains n integers a_1, a_2, ..., a_n (0 = a_1 < a_2 < ... < a_n \u2264 9).\\n\\nOutput\\n\\nFor each test case, print one integer \u2014 the minimum positive number of burles s that cannot be represented with k or fewer banknotes.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n3 13\\n0 1 2\\n2 777\\n0 4\\n3 255\\n0 1 3\\n10 1000000000\\n0 1 2 3 4 5 6 7 8 9\\n\\n\\nOutput\\n\\n\\n59\\n778\\n148999\\n999999920999999999\\nt = i\",\"targets\":\"nt(input())\\nfor _ in range(t):\\n    n, k = map(int, input().split())\\n    a = list(map(int, input().split()))\\n    m = [0 for i in range(n-1)]\\n    for i in range(n-1):\\n        m[i] = 10**(a[i+1]-a[i]) - 1\\n    #if k < sum(m):\\n    ans = 0\\n    for i in range(n-1):\\n        if k >= m[i]:\\n            ans += m[i] * (10**a[i])\\n            k -= m[i]\\n        else:\\n            ans += (k+1) * (10**a[i])\\n            k = -1\\n            break\\n    if k >= 0:\\n        ans += (k+1) * (10**a[n-1])\\n    print(ans)\",\"language\":\"python\",\"split\":\"test\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Can you solve the below in CPP?\\nIn Japan, temperature is usually expressed using the Celsius (\u2103) scale. In America, they used the Fahrenheit (\u2109) scale instead. $20$ degrees Celsius is roughly equal to $68$ degrees Fahrenheit. A phrase such as \\\"Today\u2019s temperature is $68$ degrees\\\" is commonly encountered while you are in America.\\n\\nA value in Fahrenheit can be converted to Celsius by first subtracting $32$ and then multiplying by $\\\\frac{5}{9}$. A simplified method may be used to produce a rough estimate: first subtract $30$ and then divide by $2$. Using the latter method, $68$ Fahrenheit is converted to $19$ Centigrade, i.e., $\\\\frac{(68-30)}{2}$.\\n\\nMake a program to convert Fahrenheit to Celsius using the simplified method: $C = \\\\frac{F - 30}{2}$.\\n\\n\\n\\nInput\\n\\nThe input is given in the following format.\\n\\n\\n$F$\\n\\n\\nThe input line provides a temperature in Fahrenheit $F$ ($30 \\\\leq F \\\\leq 100$), which is an integer divisible by $2$.\\n\\nOutput\\n\\nOutput the converted Celsius temperature in a line.\\n\\nExamples\\n\\nInput\\n\\n68\\n\\n\\nOutput\\n\\n19\\n\\n\\nInput\\n\\n50\\n\\n\\nOutput\\n\\n10\",\"targets\":\"#include <stdio.h>\\n#include <iostream>\\n\\nusing namespace std;\\n\\nint main(void)\\n{\\n\\tint input, output;\\n\\n\\tcin >> input;\\n\\n\\toutput = (input - 30) \\/ 2;\\n\\n\\tcout << output << endl;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"langsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"After Fox Ciel won an onsite round of a programming contest, she took a bus to return to her castle. The fee of the bus was 220 yen. She met Rabbit Hanako in the bus. They decided to play the following game because they got bored in the bus.\\n\\n  * Initially, there is a pile that contains x 100-yen coins and y 10-yen coins. \\n  * They take turns alternatively. Ciel takes the first turn. \\n  * In each turn, they must take exactly 220 yen from the pile. In Ciel's turn, if there are multiple ways to take 220 yen, she will choose the way that contains the maximal number of 100-yen coins. In Hanako's turn, if there are multiple ways to take 220 yen, she will choose the way that contains the maximal number of 10-yen coins. \\n  * If Ciel or Hanako can't take exactly 220 yen from the pile, she loses. \\n\\n\\n\\nDetermine the winner of the game.\\n\\nInput\\n\\nThe first line contains two integers x (0 \u2264 x \u2264 106) and y (0 \u2264 y \u2264 106), separated by a single space.\\n\\nOutput\\n\\nIf Ciel wins, print \\\"Ciel\\\". Otherwise, print \\\"Hanako\\\".\\n\\nExamples\\n\\nInput\\n\\n2 2\\n\\n\\nOutput\\n\\nCiel\\n\\n\\nInput\\n\\n3 22\\n\\n\\nOutput\\n\\nHanako\\n\\nNote\\n\\nIn the first turn (Ciel's turn), she will choose 2 100-yen coins and 2 10-yen coins. In the second turn (Hanako's turn), she will choose 1 100-yen coin and 12 10-yen coins. In the third turn (Ciel's turn), she can't pay exactly 220 yen, so Ciel will lose.\\nThe above is tricky. Write me a correct solution in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint fun(int x) {\\n  if (x >= 22)\\n    return 22;\\n  else if (x >= 12)\\n    return 12;\\n  else\\n    return 2;\\n}\\nint main() {\\n  int x, y;\\n  cin >> x >> y;\\n  int t1 = min(x \\/ 2, y \\/ 2);\\n  int t2 = y \\/ 24;\\n  int t = min(t1, t2);\\n  x -= 2 * t;\\n  y -= 24 * t;\\n  int turn = 0;\\n  while (1) {\\n    if (turn) {\\n      int k = fun(y);\\n      x -= (220 - 10 * k) \\/ 100;\\n      y -= k;\\n    } else {\\n      int k = min(x, 2);\\n      x -= k;\\n      y -= 22 - 10 * k;\\n    }\\n    if (x < 0 || y < 0) break;\\n    turn = (turn + 1) % 2;\\n  }\\n  cout << (turn ? \\\"Ciel\\\" : \\\"Hanako\\\") << endl;\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"train\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"PYTHON3 solution for \\\"A total of n depots are located on a number line. Depot i lies at the point x_i for 1 \u2264 i \u2264 n.\\n\\nYou are a salesman with n bags of goods, attempting to deliver one bag to each of the n depots. You and the n bags are initially at the origin 0. You can carry up to k bags at a time. You must collect the required number of goods from the origin, deliver them to the respective depots, and then return to the origin to collect your next batch of goods.\\n\\nCalculate the minimum distance you need to cover to deliver all the bags of goods to the depots. You do not have to return to the origin after you have delivered all the bags.\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 10 500). Description of the test cases follows.\\n\\nThe first line of each test case contains two integers n and k (1 \u2264 k \u2264 n \u2264 2 \u22c5 10^5).\\n\\nThe second line of each test case contains n integers x_1, x_2, \u2026, x_n (-10^9 \u2264 x_i \u2264 10^9). It is possible that some depots share the same position.\\n\\nIt is guaranteed that the sum of n over all test cases does not exceed 2 \u22c5 10^5.\\n\\nOutput\\n\\nFor each test case, output a single integer denoting the minimum distance you need to cover to deliver all the bags of goods to the depots. \\n\\nExample\\n\\nInput\\n\\n\\n4\\n5 1\\n1 2 3 4 5\\n9 3\\n-5 -10 -15 6 5 8 3 7 4\\n5 3\\n2 2 3 3 3\\n4 2\\n1000000000 1000000000 1000000000 1000000000\\n\\n\\nOutput\\n\\n\\n25\\n41\\n7\\n3000000000\\n\\nNote\\n\\nIn the first test case, you can carry only one bag at a time. Thus, the following is a solution sequence that gives a minimum travel distance: 0 \u2192 2 \u2192 0 \u2192 4 \u2192 0 \u2192 3 \u2192 0 \u2192 1 \u2192 0 \u2192 5, where each 0 means you go the origin and grab one bag, and each positive integer means you deliver the bag to a depot at this coordinate, giving a total distance of 25 units. It must be noted that there are other sequences that give the same distance.\\n\\nIn the second test case, you can follow the following sequence, among multiple such sequences, to travel minimum distance: 0 \u2192 6 \u2192 8 \u2192 7 \u2192 0 \u2192 5 \u2192 4 \u2192 3 \u2192 0 \u2192 (-5) \u2192 (-10) \u2192 (-15), with distance...\\\":\",\"targets\":\"import sys\\ninput = sys.stdin.readline\\n\\ndef positive_dist(x, n, k, last):\\n    cur = n - 1\\n    total = 0\\n    while cur >= 0 and x[cur] > 0:\\n        total += 2*x[cur]\\n        cur -= k\\n    if last and x[-1] > 0:\\n        total -= x[-1]\\n    return total\\n\\ndef negative_dist(x, n, k, last):\\n    cur = 0\\n    total = 0\\n    while cur < n and x[cur] < 0:\\n        total -= 2*(x[cur])\\n        cur += k\\n    if last and x[0] < 0:\\n        total += x[0]\\n    return total\\n\\nt = int(input())\\nfor _ in range(t):\\n    n, k = map(int, input().split())\\n    x = [int(i) for i in input().split()]\\n    x.sort()\\n    if x[0] >= 0:\\n        print(positive_dist(x, n, k, True))\\n    elif x[-1] <= 0:\\n        print(negative_dist(x, n, k, True))\\n    elif abs(x[0]) > abs(x[-1]):\\n        print(positive_dist(x, n, k, False) + negative_dist(x, n, k, True))\\n    else:\\n        print(positive_dist(x, n, k, True) + negative_dist(x, n, k, False))\",\"language\":\"python\",\"split\":\"test\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"You are given a rooted tree consisting of n vertices numbered from 1 to n. The root of the tree is the vertex 1.\\n\\nYou have to color all vertices of the tree into n colors (also numbered from 1 to n) so that there is exactly one vertex for each color. Let c_i be the color of vertex i, and p_i be the parent of vertex i in the rooted tree. The coloring is considered beautiful if there is no vertex k (k > 1) such that c_k = c_{p_k} - 1, i. e. no vertex such that its color is less than the color of its parent by exactly 1.\\n\\nCalculate the number of beautiful colorings, and print it modulo 998244353.\\n\\nInput\\n\\nThe first line contains one integer n (2 \u2264 n \u2264 250000) \u2014 the number of vertices in the tree.\\n\\nThen n-1 lines follow, the i-th line contains two integers x_i and y_i (1 \u2264 x_i, y_i \u2264 n; x_i \u2260 y_i) denoting an edge between the vertex x_i and the vertex y_i. These edges form a tree.\\n\\nOutput\\n\\nPrint one integer \u2014 the number of beautiful colorings, taken modulo 998244353.\\n\\nExamples\\n\\nInput\\n\\n\\n5\\n1 2\\n3 2\\n4 2\\n2 5\\n\\n\\nOutput\\n\\n\\n42\\n\\n\\nInput\\n\\n\\n5\\n1 2\\n2 3\\n3 4\\n4 5\\n\\n\\nOutput\\n\\n\\n53\\n\\n\\nInput\\n\\n\\n20\\n20 19\\n20 4\\n12 4\\n5 8\\n1 2\\n20 7\\n3 10\\n7 18\\n11 8\\n9 10\\n17 10\\n1 15\\n11 16\\n14 11\\n18 10\\n10 1\\n14 2\\n13 17\\n20 6\\n\\n\\nOutput\\n\\n\\n955085064\\\":\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nchar buf[1 << 21], *p1 = buf, *p2 = buf;\\ninline int read() {\\n  char c =\\n      (p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1 << 21, stdin), p1 == p2)\\n           ? EOF\\n           : *p1++);\\n  int x = 0;\\n  bool f = 0;\\n  for (; !isdigit(c);\\n       c = (p1 == p2 &&\\n                    (p2 = (p1 = buf) + fread(buf, 1, 1 << 21, stdin), p1 == p2)\\n                ? EOF\\n                : *p1++))\\n    f ^= !(c ^ 45);\\n  for (; isdigit(c);\\n       c = (p1 == p2 &&\\n                    (p2 = (p1 = buf) + fread(buf, 1, 1 << 21, stdin), p1 == p2)\\n                ? EOF\\n                : *p1++))\\n    x = (x << 1) + (x << 3) + (c ^ 48);\\n  if (f) x = -x;\\n  return x;\\n}\\nconst int mod = 998244353, _G = 3, N = 1 << 20;\\ninline int qpow(int x, int y = mod - 2) {\\n  int res = 1;\\n  for (; y; x = (long long)x * x % mod, y >>= 1)\\n    if (y & 1) res = (long long)res * x % mod;\\n  return res;\\n}\\nint rt[N], mg[N], Lim;\\nint fac[N], ifac[N], inv[N];\\nvoid init(int x) {\\n  fac[0] = ifac[0] = inv[1] = 1;\\n  for (int i = (2); i <= (x); ++i)\\n    inv[i] = (long long)(mod - mod \\/ i) * inv[mod % i] % mod;\\n  for (int i = (1); i <= (x); ++i)\\n    fac[i] = (long long)fac[i - 1] * i % mod,\\n    ifac[i] = (long long)ifac[i - 1] * inv[i] % mod;\\n}\\nint C(int x, int y) {\\n  return x < y || y < 0 ? 0\\n                        : (long long)fac[x] * ifac[y] % mod * ifac[x - y] % mod;\\n}\\nvoid Pinit(int x) {\\n  for (Lim = 1; Lim <= x; Lim <<= 1)\\n    ;\\n  int w = qpow(_G, (mod - 1) \\/ Lim);\\n  mg[0] = 1;\\n  for (int i = (1); i <= (Lim - 1); ++i) mg[i] = (long long)mg[i - 1] * w % mod;\\n  for (int i = 1; i < Lim; i <<= 1) {\\n    int sG = qpow(_G, (mod - 1) \\/ (i << 1));\\n    rt[i] = 1;\\n    for (int j = (i + 1); j <= (i * 2 - 1); ++j)\\n      rt[j] = (long long)rt[j - 1] * sG % mod;\\n  }\\n}\\nint rev[N], a[N], b[N];\\nvoid dft(int *a, int n, int op) {\\n  for (int i = (0); i <= (n - 1); ++i)\\n    rev[i] = (rev[i >> 1] >> 1) | ((i & 1) * (n >> 1));\\n  for (int i = (0); i <= (n - 1); ++i)\\n    if (i < rev[i]) a[i] ^= a[rev[i]] ^= a[i] ^= a[rev[i]];\\n  for (int...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Morning desert sun horizon\\n\\nRise above the sands of time...\\n\\nFates Warning, \\\"Exodus\\\"\\n\\nAfter crossing the Windswept Wastes, Ori has finally reached the Windtorn Ruins to find the Heart of the Forest! However, the ancient repository containing this priceless Willow light did not want to open!\\n\\nOri was taken aback, but the Voice of the Forest explained to him that the cunning Gorleks had decided to add protection to the repository.\\n\\nThe Gorleks were very fond of the \\\"string expansion\\\" operation. They were also very fond of increasing subsequences.\\n\\nSuppose a string s_1s_2s_3 \u2026 s_n is given. Then its \\\"expansion\\\" is defined as the sequence of strings s_1, s_1 s_2, ..., s_1 s_2 \u2026 s_n, s_2, s_2 s_3, ..., s_2 s_3 \u2026 s_n, s_3, s_3 s_4, ..., s_{n-1} s_n, s_n. For example, the \\\"expansion\\\" the string 'abcd' will be the following sequence of strings: 'a', 'ab', 'abc', 'abcd', 'b', 'bc', 'bcd', 'c', 'cd', 'd'. \\n\\nTo open the ancient repository, Ori must find the size of the largest increasing subsequence of the \\\"expansion\\\" of the string s. Here, strings are compared lexicographically.\\n\\nHelp Ori with this task!\\n\\nA string a is lexicographically smaller than a string b if and only if one of the following holds:\\n\\n  * a is a prefix of b, but a \u2260 b;\\n  * in the first position where a and b differ, the string a has a letter that appears earlier in the alphabet than the corresponding letter in b.\\n\\nInput\\n\\nEach test contains multiple test cases.\\n\\nThe first line contains one positive integer t (1 \u2264 t \u2264 10^3), denoting the number of test cases. Description of the test cases follows.\\n\\nThe first line of each test case contains one positive integer n (1 \u2264 n \u2264 5000) \u2014 length of the string.\\n\\nThe second line of each test case contains a non-empty string of length n, which consists of lowercase latin letters.\\n\\nIt is guaranteed that the sum of n over all test cases does not exceed 10^4.\\n\\nOutput\\n\\nFor every test case print one non-negative integer \u2014 the answer to the...\\nSolve the task in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst int INF = 0x3f3f3f3f;\\nconst long long INF64 = 0x3f3f3f3f3f3f3f3f;\\nconst double PI = acos(-1);\\ntypedef std::priority_queue<int, vector<int>, greater<int>> small_pq;\\ntypedef std::priority_queue<int, vector<int>, less<int>> big_pq;\\ntemplate <typename A, typename B>\\nostream &operator<<(ostream &os, const pair<A, B> &p) {\\n  return os << '(' << p.first << \\\", \\\" << p.second << ')';\\n}\\ntemplate <typename T_container, typename T = typename enable_if<\\n                                    !is_same<T_container, string>::value,\\n                                    typename T_container::value_type>::type>\\nostream &operator<<(ostream &os, const T_container &v) {\\n  os << '{';\\n  string sep;\\n  for (const T &x : v) os << sep << x, sep = \\\", \\\";\\n  return os << '}';\\n}\\nvoid dbg_out() {}\\ntemplate <typename Head, typename... Tail>\\nvoid dbg_out(Head H, Tail... T) {\\n  cerr << \\\" \\\" << H;\\n  if (sizeof...(T) > 0) cerr << \\\" ,\\\";\\n  dbg_out(T...);\\n}\\nvoid dbg_name(const string &s) {\\n  string ss = s;\\n  replace(ss.begin(), ss.end(), ',', ' ');\\n  cerr << \\\"  ( \\\" << ss << \\\" )  \\\";\\n}\\ntemplate <typename T>\\ninline void setmin(T &a, const T &b) {\\n  if (b < a) a = b;\\n}\\ntemplate <typename T>\\ninline void setmax(T &a, const T &b) {\\n  if (b > a) a = b;\\n}\\nstruct custom_hash {\\n  static uint64_t splitmix64(uint64_t x) {\\n    x += 0x9e3779b97f4a7c15;\\n    x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;\\n    x = (x ^ (x >> 27)) * 0x94d049bb133111eb;\\n    return x ^ (x >> 31);\\n  }\\n  size_t operator()(uint64_t x) const {\\n    static const uint64_t FIXED_RANDOM =\\n        chrono::steady_clock::now().time_since_epoch().count();\\n    return splitmix64(x + FIXED_RANDOM);\\n  }\\n};\\nunordered_map<long long, int, custom_hash> safe_map;\\nmt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());\\nmt19937_64 rnd64(chrono::steady_clock::now().time_since_epoch().count());\\nconst int MOD = 998244353;\\nint mul(int x, int y) { return 1ll * x * y % MOD; }\\nint add(int x, int y) { return ((x + y) % MOD + MOD) % MOD; }\\nint sub(int x, int y) {...\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"soltask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"Consider a regular Codeforces round consisting of three problems that uses dynamic scoring.\\n\\nYou are given an almost final scoreboard. For each participant (including yourself), the time of the accepted submission for each of the problems is given. Also, for each solution you already know whether you are able to hack it or not. The only changes in the scoreboard that will happen before the end of the round are your challenges.\\n\\nWhat is the best place you may take at the end?\\n\\nMore formally, n people are participating (including yourself). For any problem, if it was solved by exactly k people at the end of the round, the maximum score for this problem is defined as: \\n\\n  1. If n < 2k \u2264 2n, then the maximum possible score is 500; \\n  2. If n < 4k \u2264 2n, then the maximum possible score is 1000; \\n  3. If n < 8k \u2264 2n, then the maximum possible score is 1500; \\n  4. If n < 16k \u2264 2n, then the maximum possible score is 2000; \\n  5. If n < 32k \u2264 2n, then the maximum possible score is 2500; \\n  6. If 32k \u2264 n, then the maximum possible score is 3000. \\n\\n\\n\\nLet the maximum possible score for some problem be equal to s. Then a contestant who didn't manage to get it accepted (or his solution was hacked) earns 0 points for this problem. If he got the the solution accepted t minutes after the beginning of the round (and his solution wasn't hacked), he earns <image> points for this problem.\\n\\nThe overall score of a participant is equal to the sum of points he earns for each problem plus 100 points for each successful hack (only you make hacks).\\n\\nThe resulting place you get is equal to one plus the number of participants who's overall score is strictly greater than yours.\\n\\nInput\\n\\nThe first line of the input contains a single integer n (1 \u2264 n \u2264 5000) \u2014 the number of participants. You are the participant number 1.\\n\\nEach of the following n lines contains three integers ai, bi and ci. Here ai = 0 means that the participant number i didn't manage to accept first problem. If 1 \u2264 ai \u2264 120, then the participant number i got the first problem...\\\":\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst int N = 5050, M = 92, oo = 1000000000;\\nint pa, pb, pc, ia, ib, ic, ja, jb, jc, i, j, k, n, ch, ff, t, sa, sb, sc, ans,\\n    ka, kb, kc, na, nb, nc, ma, mb, mc, la, lb, lc, ra, rb, rc, ta, tb, tc, tt,\\n    tmp, maxa, maxb, maxc, ttt, num;\\nint f[M][M][M];\\nstruct cc {\\n  int a, b, c;\\n} A[N];\\nvoid R(int &x) {\\n  x = ff = 0;\\n  ch = getchar();\\n  while (ch < '0' || '9' < ch) {\\n    if (ch == '-') ff = 1;\\n    ch = getchar();\\n  }\\n  while ('0' <= ch && ch <= '9') x = x * 10 + ch - '0', ch = getchar();\\n  if (ff) x = -x;\\n}\\nint abs(int x) {\\n  if (x < 0) return -x;\\n  return x;\\n}\\nint max(int x, int y) {\\n  if (x > y) return x;\\n  return y;\\n}\\nint main() {\\n  R(n);\\n  for (i = 1; i <= n; i++) {\\n    R(A[i].a);\\n    R(A[i].b);\\n    R(A[i].c);\\n    if (A[i].a > 0) na++;\\n    if (A[i].b > 0) nb++;\\n    if (A[i].c > 0) nc++;\\n    if (A[i].a < 0) ma++;\\n    if (A[i].b < 0) mb++;\\n    if (A[i].c < 0) mc++;\\n  }\\n  t = (ma + mb + mc) * 100;\\n  ra = 1;\\n  while (ra < 6 && (1 << ra) * na <= n) ra++;\\n  sa = 500 * ra;\\n  rb = 1;\\n  while (rb < 6 && (1 << rb) * nb <= n) rb++;\\n  sb = 500 * rb;\\n  rc = 1;\\n  while (rc < 6 && (1 << rc) * nc <= n) rc++;\\n  sc = 500 * rc;\\n  if (A[1].a) t += sa * (250 - A[1].a) \\/ 250;\\n  if (A[1].b) t += sb * (250 - A[1].b) \\/ 250;\\n  if (A[1].c) t += sc * (250 - A[1].c) \\/ 250;\\n  ans = 1;\\n  for (i = 2; i <= n; i++) {\\n    tt = 0;\\n    if (A[i].a > 0) tt += sa * (250 - A[i].a) \\/ 250;\\n    if (A[i].b > 0) tt += sb * (250 - A[i].b) \\/ 250;\\n    if (A[i].c > 0) tt += sc * (250 - A[i].c) \\/ 250;\\n    if (tt > t) ans++;\\n  }\\n  if (ans == 1) return puts(\\\"1\\\"), 0;\\n  la = 1;\\n  while (la < 6 && (1 << la) * (na + ma) <= n) la++;\\n  lb = 1;\\n  while (lb < 6 && (1 << lb) * (nb + mb) <= n) lb++;\\n  lc = 1;\\n  while (lc < 6 && (1 << lc) * (nc + mc) <= n) lc++;\\n  for (ka = la; ka <= ra; ka++) {\\n    sa = ka * 500;\\n    ta = n \\/ (1 << ka) + 1;\\n    if (ka == 6) ta = 0;\\n    if (ta < na) ta = na;\\n    ta = na + ma - ta;\\n    for (kb = lb; kb <= rb; kb++) {\\n      sb = kb * 500;\\n      tb = n \\/ (1 << kb) + 1;\\n      if (kb == 6)...\",\"language\":\"python\",\"split\":\"train\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"A flow network is a directed graph which has a $source$ and a $sink$. In a flow network, each edge $(u, v)$ has a capacity $c(u, v)$. Each edge receives a flow, but the amount of flow on the edge can not exceed the corresponding capacity. Find the maximum flow from the $source$ to the $sink$.\\n\\nConstraints\\n\\n* $2 \\\\leq |V| \\\\leq 100$\\n* $1 \\\\leq |E| \\\\leq 1000$\\n* $0 \\\\leq c_i \\\\leq 10000$\\n\\nInput\\n\\nA flow network is given in the following format.\\n\\n$|V|\\\\;|E|$\\n$u_0\\\\;v_0\\\\;c_0$\\n$u_1\\\\;v_1\\\\;c_1$\\n:\\n$u_{|E|-1}\\\\;v_{|E|-1}\\\\;c_{|E|-1}$\\n\\n\\n\\n$|V|$, $|E|$ is the number of vertices and edges of the flow network respectively. The vertices in $G$ are named with the numbers 0, 1,..., $|V|-1$. The source is 0 and the sink is $|V|-1$.\\n\\n$u_i$, $v_i$, $c_i$ represent $i$-th edge of the flow network. A pair of $u_i$ and $v_i$ denotes that there is an edge from $u_i$ to $v_i$ and $c_i$ is the capacity of $i$-th edge.\\n\\nOutput\\n\\nPrint the maximum flow.\\n\\nExample\\n\\nInput\\n\\n4 5\\n0 1 2\\n0 2 1\\n1 2 1\\n1 3 1\\n2 3 2\\n\\n\\nOutput\\n\\n3\",\"targets\":\"def main():\\n    nvertices, nedges = map(int, input().split())\\n    adj = [[0 for i in range(nvertices)] for j in range(nvertices)]\\n    for i in range(nedges):\\n        u, v, c = map(int, input().split())\\n        adj[u][v] = c\\n\\n    INF = float('inf')\\n    ans = 0\\n    while True:\\n        parents = bfs(0, nvertices - 1, adj)\\n        if parents is None:\\n            break\\n        v = nvertices - 1\\n        f = INF\\n        while parents[v] != -1:\\n            f = min(f, adj[parents[v]][v])\\n            v = parents[v]\\n\\n        ans += f\\n        v = nvertices - 1\\n        while parents[v] != -1:\\n            adj[parents[v]][v] -= f\\n            adj[v][parents[v]] += f\\n            v = parents[v]\\n\\n    print(ans)\\n\\n\\ndef bfs(s, t, adj):\\n    visited = [False] * len(adj)\\n    que = [s]\\n    parents = [-1] * len(adj)\\n    while que:\\n        u = que.pop(0)\\n        visited[u] = True\\n        if u == t:\\n            return parents\\n\\n        for v in range(len(adj)):\\n            if not visited[v] and adj[u][v] > 0:\\n                parents[v] = u\\n                que.append(v)\\n\\n    return None\\n\\n\\nmain()\",\"language\":\"python\",\"split\":\"train\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Boboniu gives you\\n\\n  * r red balls, \\n  * g green balls, \\n  * b blue balls, \\n  * w white balls. \\n\\n\\n\\nHe allows you to do the following operation as many times as you want: \\n\\n  * Pick a red ball, a green ball, and a blue ball and then change their color to white. \\n\\n\\n\\nYou should answer if it's possible to arrange all the balls into a palindrome after several (possibly zero) number of described operations. \\n\\nInput\\n\\nThe first line contains one integer T (1\u2264 T\u2264 100) denoting the number of test cases.\\n\\nFor each of the next T cases, the first line contains four integers r, g, b and w (0\u2264 r,g,b,w\u2264 10^9).\\n\\nOutput\\n\\nFor each test case, print \\\"Yes\\\" if it's possible to arrange all the balls into a palindrome after doing several (possibly zero) number of described operations. Otherwise, print \\\"No\\\".\\n\\nExample\\n\\nInput\\n\\n\\n4\\n0 1 1 1\\n8 1 9 3\\n0 0 0 0\\n1000000000 1000000000 1000000000 1000000000\\n\\n\\nOutput\\n\\n\\nNo\\nYes\\nYes\\nYes\\n\\nNote\\n\\nIn the first test case, you're not able to do any operation and you can never arrange three balls of distinct colors into a palindrome.\\n\\nIn the second test case, after doing one operation, changing (8,1,9,3) to (7,0,8,6), one of those possible palindromes may be \\\"rrrwwwbbbbrbbbbwwwrrr\\\".\\n\\nA palindrome is a word, phrase, or sequence that reads the same backwards as forwards. For example, \\\"rggbwbggr\\\", \\\"b\\\", \\\"gg\\\" are palindromes while \\\"rgbb\\\", \\\"gbbgr\\\" are not. Notice that an empty word, phrase, or sequence is palindrome.\\nUsing python3 can you solve the prior task?\",\"targets\":\"T = int(input())\\n \\ndef Is_Palin(r, g, b, w):\\n    \\n    Odd = 0\\n    if r % 2 != 0:\\n        Odd += 1\\n    if g % 2 != 0:\\n        Odd += 1\\n    if b % 2 != 0:\\n        Odd += 1\\n    if w % 2 != 0:\\n        Odd += 1\\n        \\n    if Odd > 1:\\n        return False\\n    return True\\n \\nfor i in range(T):\\n    r, g, b, w = map(int, input().split())\\n    \\n    if Is_Palin(r, g, b, w):\\n        print('Yes')\\n    \\n    else:\\n        Palin = False\\n        \\n        if r>0 and b>0 and g>0:\\n            \\n            r, g, b, w = r-1, g-1, b-1, w+1\\n        \\n        if Is_Palin(r, g, b, w):\\n            Palin = True\\n            \\n        if Palin:\\n            print('Yes')\\n        else:\\n            print('No')\",\"language\":\"python\",\"split\":\"train\",\"template\":\"priortask\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"There is a chessboard of size n by n. The square in the i-th row from top and j-th column from the left is labelled (i,j).\\n\\nCurrently, Gregor has some pawns in the n-th row. There are also enemy pawns in the 1-st row. On one turn, Gregor moves one of his pawns. A pawn can move one square up (from (i,j) to (i-1,j)) if there is no pawn in the destination square. Additionally, a pawn can move one square diagonally up (from (i,j) to either (i-1,j-1) or (i-1,j+1)) if and only if there is an enemy pawn in that square. The enemy pawn is also removed.\\n\\nGregor wants to know what is the maximum number of his pawns that can reach row 1?\\n\\nNote that only Gregor takes turns in this game, and the enemy pawns never move. Also, when Gregor's pawn reaches row 1, it is stuck and cannot make any further moves.\\n\\nInput\\n\\nThe first line of the input contains one integer t (1\u2264 t\u2264 2\u22c5 10^4) \u2014 the number of test cases. Then t test cases follow.\\n\\nEach test case consists of three lines. The first line contains a single integer n (2\u2264 n\u2264 2\u22c5{10}^{5}) \u2014 the size of the chessboard.\\n\\nThe second line consists of a string of binary digits of length n, where a 1 in the i-th position corresponds to an enemy pawn in the i-th cell from the left, and 0 corresponds to an empty cell.\\n\\nThe third line consists of a string of binary digits of length n, where a 1 in the i-th position corresponds to a Gregor's pawn in the i-th cell from the left, and 0 corresponds to an empty cell.\\n\\nIt is guaranteed that the sum of n across all test cases is less than 2\u22c5{10}^{5}.\\n\\nOutput\\n\\nFor each test case, print one integer: the maximum number of Gregor's pawns which can reach the 1-st row.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n3\\n000\\n111\\n4\\n1111\\n1111\\n3\\n010\\n010\\n5\\n11001\\n00000\\n\\n\\nOutput\\n\\n\\n3\\n4\\n0\\n0\\n\\nNote\\n\\nIn the first example, Gregor can simply advance all 3 of his pawns forward. Thus, the answer is 3.\\n\\nIn the second example, Gregor can guarantee that all 4 of his pawns reach the enemy row, by following the colored paths as demonstrated in the diagram below. Remember, only Gregor takes turns in...\\n  imp\",\"targets\":\"ort java.util.*;\\n   public class Solution {\\n      static Scanner sc=new Scanner(System.in);\\n      public static void main(String[] args) {\\n          int t=sc.nextInt();\\n          while (t-->0){\\n            int n=sc.nextInt();\\n            String en=sc.next();\\n            String my=sc.next();\\n            int ans=0;\\n            boolean[] vis=new boolean[n+5];\\n            for(int i=1;i<=n;i++){\\n              if(en.charAt(i-1)=='0')\\n                vis[i]=true;\\n            }\\n            vis[0]=true;\\n            vis[n+1]=true;\\n            for (int i=1;i<=n;i++) {\\n              if(my.charAt(i-1)=='0')\\n                continue;\\n              if(en.charAt(i-1)=='0'){\\n                ans++;\\n                vis[i]=true;\\n                continue;\\n              }\\n              if (!vis[i-1]){\\n                ans++;\\n                vis[i-1]=true;\\n                continue;\\n              }\\n              if (!vis[i+1]) {\\n                ans++;\\n                vis[i+1]=true;\\n                continue;\\n              }\\n            }\\n            System.out.println(ans);\\n          }\\n        }\\n    }\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"contsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"JAVA solution for \\\"Mocha is a young girl from high school. She has learned so much interesting knowledge from her teachers, especially her math teacher. Recently, Mocha is learning about binary system and very interested in bitwise operation.\\n\\nThis day, Mocha got a sequence a of length n. In each operation, she can select an arbitrary interval [l, r] and for all values i (0\u2264 i \u2264 r-l), replace a_{l+i} with a_{l+i}  \\\\&  a_{r-i} at the same time, where \\\\& denotes the [bitwise AND operation](https:\\/\\/en.wikipedia.org\\/wiki\\/Bitwise_operation#AND). This operation can be performed any number of times.\\n\\nFor example, if n=5, the array is [a_1,a_2,a_3,a_4,a_5], and Mocha selects the interval [2,5], then the new array is [a_1,a_2 \\\\&  a_5, a_3 \\\\&  a_4, a_4 \\\\&  a_3, a_5 \\\\&  a_2].\\n\\nNow Mocha wants to minimize the maximum value in the sequence. As her best friend, can you help her to get the answer?\\n\\nInput\\n\\nEach test contains multiple test cases. \\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 100) \u2014 the number of test cases. Each test case consists of two lines.\\n\\nThe first line of each test case contains a single integer n (1 \u2264 n \u2264 100) \u2014 the length of the sequence.\\n\\nThe second line of each test case contains n integers a_1, a_2, \u2026, a_n (0 \u2264 a_i \u2264 10^9).\\n\\nOutput\\n\\nFor each test case, print one integer \u2014 the minimal value of the maximum value in the sequence.\\n\\nExample\\n\\nInput\\n\\n\\n4\\n2\\n1 2\\n3\\n1 1 3\\n4\\n3 11 3 7\\n5\\n11 7 15 3 7\\n\\n\\nOutput\\n\\n\\n0\\n1\\n3\\n3\\n\\nNote\\n\\nIn the first test case, Mocha can choose the interval [1,2], then the sequence becomes [ 0, 0], where the first element is 1 \\\\& 2, and the second element is 2 \\\\& 1.\\n\\nIn the second test case, Mocha can choose the interval [1,3], then the sequence becomes [ 1,1,1], where the first element is 1 \\\\& 3, the second element is 1 \\\\& 1, and the third element is 3 \\\\& 1.\\\":\",\"targets\":\"import java.io.*;\\nimport java.util.*;\\n\\npublic class Main {\\n    \\n    public static void main(String args[]) {\\n        \\n        StringBuilder fo = new StringBuilder();\\n        Scanner sc = new Scanner(System.in);\\n    int t =sc.nextInt();\\n    while(t-->0)\\n    {\\n\\n      int n = sc.nextInt();\\n\\n      Set<Integer> set = new TreeSet<>();\\n\\nfor(int i=0;i<n;i++)\\nset.add(sc.nextInt());\\n\\n    while(set.size()>1)\\n    {\\n        int min =-1;\\n        for(int i :set)\\n        {\\n            min = i;\\n            break;\\n        }\\n        Set<Integer> ns = new TreeSet<>();\\n        for(int i:set)\\n        {\\n            ns.add(i&min);\\n        }\\n        set = ns;\\n    }\\nint ans =-1;\\nfor(int i:set)\\nans =i;\\n        System.out.println(ans);\\n      \\n      \\n      }\\n    }\\n\\n\\n\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"CPP solution for \\\"Vupsen and Pupsen were gifted an integer array. Since Vupsen doesn't like the number 0, he threw away all numbers equal to 0 from the array. As a result, he got an array a of length n.\\n\\nPupsen, on the contrary, likes the number 0 and he got upset when he saw the array without zeroes. To cheer Pupsen up, Vupsen decided to come up with another array b of length n such that \u2211_{i=1}^{n}a_i \u22c5 b_i=0. Since Vupsen doesn't like number 0, the array b must not contain numbers equal to 0. Also, the numbers in that array must not be huge, so the sum of their absolute values cannot exceed 10^9. Please help Vupsen to find any such array b!\\n\\nInput\\n\\nThe first line contains a single integer t (1 \u2264 t \u2264 100) \u2014 the number of test cases. The next 2 \u22c5 t lines contain the description of test cases. The description of each test case consists of two lines.\\n\\nThe first line of each test case contains a single integer n (2 \u2264 n \u2264 10^5) \u2014 the length of the array.\\n\\nThe second line contains n integers a_1, a_2, \u2026, a_n (-10^4 \u2264 a_i \u2264 10^4, a_i \u2260 0) \u2014 the elements of the array a.\\n\\nIt is guaranteed that the sum of n over all test cases does not exceed 2 \u22c5 10^5.\\n\\nOutput\\n\\nFor each test case print n integers b_1, b_2, \u2026, b_n \u2014 elements of the array b (|b_1|+|b_2|+\u2026 +|b_n| \u2264 10^9, b_i \u2260 0, \u2211_{i=1}^{n}a_i \u22c5 b_i=0).\\n\\nIt can be shown that the answer always exists.\\n\\nExample\\n\\nInput\\n\\n\\n3\\n2\\n5 5\\n5\\n5 -2 10 -9 4\\n7\\n1 2 3 4 5 6 7\\n\\n\\nOutput\\n\\n\\n1 -1\\n-1 5 1 -1 -1\\n-10 2 2 -3 5 -1 -1\\n\\nNote\\n\\nIn the first test case, 5 \u22c5 1 + 5 \u22c5 (-1)=5-5=0. You could also print 3 -3, for example, since 5 \u22c5 3 + 5 \u22c5 (-3)=15-15=0\\n\\nIn the second test case, 5 \u22c5 (-1) + (-2) \u22c5 5 + 10 \u22c5 1 + (-9) \u22c5 (-1) + 4 \u22c5 (-1)=-5-10+10+9-4=0.\\\":\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint main() {\\n  long long n, t;\\n  cin >> t;\\n  while (t--) {\\n    cin >> n;\\n    long long a[n + 1];\\n    for (long long i = 0; i < n; ++i) cin >> a[i];\\n    long long k = 0;\\n    if (n % 2) k = 3;\\n    for (long long i = 0; i < n - k; i += 2)\\n      cout << -a[i + 1] << \\\" \\\" << a[i] << \\\" \\\";\\n    if (n % 2) {\\n      if (a[n - 1] != a[n - 2])\\n        cout << a[n - 1] - a[n - 2] << \\\" \\\" << a[n - 3] << \\\" \\\" << -a[n - 3]\\n             << endl;\\n      else\\n        cout << a[n - 1] + a[n - 2] << \\\" \\\" << -a[n - 3] << \\\" \\\" << -a[n - 3]\\n             << endl;\\n    }\\n  }\\n}\",\"language\":\"python\",\"split\":\"test\",\"template\":\"solfor\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"This is a simplified version of the problem B2. Perhaps you should read the problem B2 before you start solving B1.\\n\\nPaul and Mary have a favorite string s which consists of lowercase letters of the Latin alphabet. They want to paint it using pieces of chalk of two colors: red and green. Let's call a coloring of a string wonderful if the following conditions are met:\\n\\n  1. each letter of the string is either painted in exactly one color (red or green) or isn't painted; \\n  2. each two letters which are painted in the same color are different; \\n  3. the number of letters painted in red is equal to the number of letters painted in green; \\n  4. the number of painted letters of this coloring is maximum among all colorings of the string which meet the first three conditions. \\n\\n\\n\\nE. g. consider a string s equal to \\\"kzaaa\\\". One of the wonderful colorings of the string is shown in the figure.\\n\\n<image> The example of a wonderful coloring of the string \\\"kzaaa\\\".\\n\\nPaul and Mary want to learn by themselves how to find a wonderful coloring of the string. But they are very young, so they need a hint. Help them find k \u2014 the number of red (or green, these numbers are equal) letters in a wonderful coloring.\\n\\nInput\\n\\nThe first line contains one integer t (1 \u2264 t \u2264 1000) \u2014 the number of test cases. Then t test cases follow.\\n\\nEach test case consists of one non-empty string s which consists of lowercase letters of the Latin alphabet. The number of characters in the string doesn't exceed 50.\\n\\nOutput\\n\\nFor each test case, output a separate line containing one non-negative integer k \u2014 the number of letters which will be painted in red in a wonderful coloring.\\n\\nExample\\n\\nInput\\n\\n\\n5\\nkzaaa\\ncodeforces\\narchive\\ny\\nxxxxxx\\n\\n\\nOutput\\n\\n\\n2\\n5\\n3\\n0\\n1\\n\\nNote\\n\\nThe first test case contains the string from the statement. One of the wonderful colorings is shown in the figure. There's no wonderful coloring containing 3 or more red letters because the total number of painted symbols will exceed the string's length.\\n\\nThe string from the second test case can be...\\nThe above is tricky. Write me a correct solution in CPP.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nconst double EPS = 1e-9;\\nvoid solve() {\\n  string s;\\n  cin >> s;\\n  vector<long long> v(26, 0);\\n  for (long long i = 0; i < s.size(); i++) v[s[i] - 'a']++;\\n  long long cnt1 = 0, cnt2 = 0;\\n  for (long long i = 0; i < 26; i++) {\\n    if (v[i] >= 2)\\n      cnt2++;\\n    else if (v[i] == 1)\\n      cnt1++;\\n  }\\n  long long ans = cnt1 \\/ 2 + cnt2;\\n  cout << ans << \\\"\\\\n\\\";\\n}\\nint32_t main() {\\n  ios_base::sync_with_stdio(0);\\n  cin.tie(0);\\n  long long t;\\n  cin >> t;\\n  while (t--) {\\n    solve();\\n  }\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"abovesol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"A robot cleaner is placed on the floor of a rectangle room, surrounded by walls. The floor consists of n rows and m columns. The rows of the floor are numbered from 1 to n from top to bottom, and columns of the floor are numbered from 1 to m from left to right. The cell on the intersection of the r-th row and the c-th column is denoted as (r,c). The initial position of the robot is (r_b, c_b).\\n\\nIn one second, the robot moves by dr rows and dc columns, that is, after one second, the robot moves from the cell (r, c) to (r + dr, c + dc). Initially dr = 1, dc = 1. If there is a vertical wall (the left or the right walls) in the movement direction, dc is reflected before the movement, so the new value of dc is -dc. And if there is a horizontal wall (the upper or lower walls), dr is reflected before the movement, so the new value of dr is -dr.\\n\\nEach second (including the moment before the robot starts moving), the robot cleans every cell lying in the same row or the same column as its position. There is only one dirty cell at (r_d, c_d). The job of the robot is to clean that dirty cell.\\n\\n<image> Illustration for the first example. The blue arc is the robot. The red star is the target dirty cell. Each second the robot cleans a row and a column, denoted by yellow stripes.\\n\\nGiven the floor size n and m, the robot's initial position (r_b, c_b) and the dirty cell's position (r_d, c_d), find the time for the robot to do its job.\\n\\nInput\\n\\nEach test contains multiple test cases. The first line contains the number of test cases t (1 \u2264 t \u2264 10^4). Description of the test cases follows.\\n\\nA test case consists of only one line, containing six integers n, m, r_b, c_b, r_d, and c_d (1 \u2264 n, m \u2264 100, 1 \u2264 r_b, r_d \u2264 n, 1 \u2264 c_b, c_d \u2264 m) \u2014 the sizes of the room, the initial position of the robot and the position of the dirt cell.\\n\\nOutput\\n\\nFor each test case, print an integer \u2014 the time for the robot to clean the dirty cell. We can show that the robot always cleans the dirty cell eventually.\\n\\nExample\\n\\nInput\\n\\n\\n5\\n10 10 6 1 2 8\\n10 10 9 9 1...\",\"targets\":\"from __future__ import division, print_function\\n\\nimport os\\nimport sys\\nfrom io import BytesIO, IOBase\\n\\nif sys.version_info[0] < 3:\\n    from __builtin__ import xrange as range\\n    from future_builtins import ascii, filter, hex, map, oct, zip\\n\\nBUFSIZE = 8192\\n\\n\\nclass FastIO(IOBase):\\n    newlines = 0\\n\\n    def __init__(self, file):\\n        self._fd = file.fileno()\\n        self.buffer = BytesIO()\\n        self.writable = \\\"x\\\" in file.mode or \\\"r\\\" not in file.mode\\n        self.write = self.buffer.write if self.writable else None\\n\\n    def read(self):\\n        while True:\\n            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))\\n            if not b:\\n                break\\n            ptr = self.buffer.tell()\\n            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)\\n        self.newlines = 0\\n        return self.buffer.read()\\n\\n    def readline(self):\\n        while self.newlines == 0:\\n            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))\\n            self.newlines = b.count(b\\\"\\\\n\\\") + (not b)\\n            ptr = self.buffer.tell()\\n            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)\\n        self.newlines -= 1\\n        return self.buffer.readline()\\n\\n    def flush(self):\\n        if self.writable:\\n            os.write(self._fd, self.buffer.getvalue())\\n            self.buffer.truncate(0), self.buffer.seek(0)\\n\\n\\nclass IOWrapper(IOBase):\\n    def __init__(self, file):\\n        self.buffer = FastIO(file)\\n        self.flush = self.buffer.flush\\n        self.writable = self.buffer.writable\\n        self.write = lambda s: self.buffer.write(s.encode(\\\"ascii\\\"))\\n        self.read = lambda: self.buffer.read().decode(\\\"ascii\\\")\\n        self.readline = lambda: self.buffer.readline().decode(\\\"ascii\\\")\\n\\n\\ndef print(*args, **kwargs):\\n    \\\"\\\"\\\"Prints the values to a stream, or to sys.stdout by default.\\\"\\\"\\\"\\n    sep, file = kwargs.pop(\\\"sep\\\", \\\" \\\"), kwargs.pop(\\\"file\\\", sys.stdout)\\n    at_start = True\\n    for x in args:\\n        if not at_start:\\n            file.write(sep)\\n       ...\",\"language\":\"python\",\"split\":\"test\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"
"{\"inputs\":\"Note that the memory limit in this problem is lower than in others.\\n\\nYou have a vertical strip with n cells, numbered consecutively from 1 to n from top to bottom.\\n\\nYou also have a token that is initially placed in cell n. You will move the token up until it arrives at cell 1.\\n\\nLet the token be in cell x > 1 at some moment. One shift of the token can have either of the following kinds: \\n\\n  * Subtraction: you choose an integer y between 1 and x-1, inclusive, and move the token from cell x to cell x - y. \\n  * Floored division: you choose an integer z between 2 and x, inclusive, and move the token from cell x to cell \u230a x\\/z \u230b (x divided by z rounded down). \\n\\n\\n\\nFind the number of ways to move the token from cell n to cell 1 using one or more shifts, and print it modulo m. Note that if there are several ways to move the token from one cell to another in one shift, all these ways are considered distinct (check example explanation for a better understanding).\\n\\nInput\\n\\nThe only line contains two integers n and m (2 \u2264 n \u2264 4 \u22c5 10^6; 10^8 < m < 10^9; m is a prime number) \u2014 the length of the strip and the modulo.\\n\\nOutput\\n\\nPrint the number of ways to move the token from cell n to cell 1, modulo m.\\n\\nExamples\\n\\nInput\\n\\n\\n3 998244353\\n\\n\\nOutput\\n\\n\\n5\\n\\n\\nInput\\n\\n\\n5 998244353\\n\\n\\nOutput\\n\\n\\n25\\n\\n\\nInput\\n\\n\\n42 998244353\\n\\n\\nOutput\\n\\n\\n793019428\\n\\n\\nInput\\n\\n\\n787788 100000007\\n\\n\\nOutput\\n\\n\\n94810539\\n\\nNote\\n\\nIn the first test, there are three ways to move the token from cell 3 to cell 1 in one shift: using subtraction of y = 2, or using division by z = 2 or z = 3.\\n\\nThere are also two ways to move the token from cell 3 to cell 1 via cell 2: first subtract y = 1, and then either subtract y = 1 again or divide by z = 2.\\n\\nTherefore, there are five ways in total.\",\"targets\":\"#include <bits\\/stdc++.h>\\nusing namespace std;\\nint dp[4000001];\\nint s[8000001];\\nint main() {\\n  int n, m, i, j;\\n  cin >> n >> m;\\n  dp[n] = 1;\\n  s[n] = 1;\\n  for (i = n - 1; i >= 1; i--) {\\n    dp[i] = s[i + 1];\\n    for (j = 2; i * j <= n; j++)\\n      dp[i] = (1ll * dp[i] + s[i * j] - s[(i + 1) * j] + m) % m;\\n    s[i] = (s[i + 1] + dp[i]) % m;\\n  }\\n  cout << dp[1];\\n  return 0;\\n}\",\"language\":\"python\",\"split\":\"valid\",\"template\":\"descsol\",\"dataset\":\"teven\\/code_contests\",\"config\":null}\n"