diff --git "a/test.csv" "b/test.csv"
new file mode 100644--- /dev/null
+++ "b/test.csv"
@@ -0,0 +1,204463 @@
+F1,F2,text_1,text_2,label
+464a03b8,ff1fc018,"import java.util.*;
+
+public class Soltion{
+ 
+     public static void main(String []args){
+        Scanner sc = new Scanner(System.in);
+        int t = sc.nextInt();
+        
+        while(t-->0){
+            int n = sc.nextInt();
+            Integer[] arr = new Integer[n];
+            for(int i=0;i<n;i++){
+                arr[i] = sc.nextInt();
+            }
+            String s = sc.next();
+            
+            List<Integer> blue = new ArrayList<>();
+            List<Integer> red = new ArrayList<>();
+            
+            for(int i=0;i<s.length();i++){
+                if(s.charAt(i)=='B'){
+                    blue.add(arr[i]);
+                }
+                else{
+                    red.add(arr[i]);
+                }
+            }
+            
+            Collections.sort(blue);
+            Collections.sort(red);
+            int p=1,q=n;
+            
+            boolean flag = true;
+            for(int i=red.size()-1;i>=0;i--){
+                if(red.get(i)>q){
+                    flag = false;
+                    break;
+                }
+                q--;
+            }
+            
+            for(int i=0;i<blue.size();i++){
+                if(blue.get(i)<p){
+                    flag = false;
+                    break;
+                }
+                p++;
+            }
+            
+            System.out.println(flag? ""Yes"" : ""No"");
+        }
+     }
+}
+","import java.util.*;
+
+public class mentor1 {
+    public static boolean solve(int n, String color, int[] arr){
+        List<Integer> Barr = new ArrayList<Integer>();
+        List<Integer> Rarr = new ArrayList<Integer>();
+        for (int i = 0; i < n; i++) {
+            if(color.charAt(i) == 'B')Barr.add(arr[i]);
+            else Rarr.add(arr[i]);
+        }
+        Barr.sort(Comparator.naturalOrder());
+        Rarr.sort(Comparator.reverseOrder());
+        for (int i = 0; i < Barr.size(); i++) {
+            if(Barr.get(i)< i + 1)return false;
+        }
+        for (int i = 0; i < Rarr.size(); i++) {
+            int expect = n-i;
+            if(Rarr.get(i) > expect)return false;
+        }
+        return true;
+    }
+    public static void main(String[] args) {
+        Scanner input = new Scanner(System.in);
+        int n = input.nextInt();
+        for (int i = 0; i < n; i++) {
+            int m = input.nextInt();
+            int[] arr = new int[m];
+            for(int j = 0;j<m; j++)arr[j] = input.nextInt();
+            String color = input.next();
+            if(solve(m,color,arr)) System.out.println(""YES"");
+            else System.out.println(""NO"");
+        }
+    }
+}
+",0
+3e6def38,548ffb07,"import java.io.*;
+import java.util.*;
+
+public class D_Java {
+	public static final int MOD = 998244353;
+	
+	public static int mul(int a, int b) {
+		return (int)((long)a * (long)b % MOD);
+	}
+	
+	int[] f;
+	int[] rf;
+	
+	public int C(int n, int k) {
+		return (k < 0 || k > n) ? 0 : mul(f[n], mul(rf[n-k], rf[k]));
+	}
+	
+	public static int pow(int a, int n) {
+		int res = 1;
+		while (n != 0) {
+			if ((n & 1) == 1) {
+				res = mul(res, a);
+			}
+			a = mul(a, a);
+			n >>= 1;
+		}
+		return res;
+	}
+	
+	static void shuffleArray(int[] a) {
+		Random rnd = new Random();
+		for (int i = a.length-1; i > 0; i--) {
+			int index = rnd.nextInt(i + 1);
+			int tmp = a[index];
+			a[index] = a[i];
+			a[i] = tmp;
+		}
+	}
+	
+	public static int inv(int a) {
+		return pow(a, MOD-2);
+	}
+	
+	public void doIt() throws IOException {
+		BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
+		
+		StringTokenizer tok = new StringTokenizer(in.readLine());
+		int n = Integer.parseInt(tok.nextToken());
+		int k = Integer.parseInt(tok.nextToken());
+		
+		f = new int[n+42];
+		rf = new int[n+42];
+		f[0] = rf[0] = 1;
+		for (int i = 1; i < f.length; ++i) {
+			f[i] = mul(f[i-1], i);
+			rf[i] = mul(rf[i-1], inv(i));
+		}
+		
+		int[] events = new int[2*n];
+		for (int i = 0; i < n; ++i) {
+			tok = new StringTokenizer(in.readLine());
+			int le = Integer.parseInt(tok.nextToken());
+			int ri = Integer.parseInt(tok.nextToken());
+			events[i] = le*2;
+			events[i + n] = ri*2 + 1;
+		}
+		shuffleArray(events);
+		Arrays.sort(events);
+		
+		int ans = 0;
+		int balance = 0;
+		for (int r = 0; r < 2*n;) {
+			int l = r;
+			while (r < 2*n && events[l] == events[r]) {
+				++r;
+			}
+			int added = r - l;
+			if (events[l] % 2 == 0) {
+				// Open event
+				ans += C(balance + added, k);
+				if (ans >= MOD) ans -= MOD;
+				ans += MOD - C(balance, k);
+				if (ans >= MOD) ans -= MOD;
+				balance += added;
+			} else {
+				// Close event
+				balance -= added;
+			}
+		}
+		
+		in.close();
+		System.out.println(ans);
+	}
+	
+	public static void main(String[] args) throws IOException {
+		(new D_Java()).doIt();
+	}
+}","import java.io.*;
+import java.util.*;
+
+public class D_Java {
+	public static final int MOD = 998244353;
+	
+	public static int mul(int a, int b) {
+		return (int)((long)a * (long)b % MOD);
+	}
+	
+	int[] f;
+	int[] rf;
+	
+	public int C(int n, int k) {
+		return (k < 0 || k > n) ? 0 : mul(f[n], mul(rf[n-k], rf[k]));
+	}
+	
+	public static int pow(int a, int n) {
+		int res = 1;
+		while (n != 0) {
+			if ((n & 1) == 1) {
+				res = mul(res, a);
+			}
+			a = mul(a, a);
+			n >>= 1;
+		}
+		return res;
+	}
+	
+	static void shuffleArray(int[] a) {
+		Random rnd = new Random();
+		for (int i = a.length-1; i > 0; i--) {
+			int index = rnd.nextInt(i + 1);
+			int tmp = a[index];
+			a[index] = a[i];
+			a[i] = tmp;
+		}
+	}
+	
+	public static int inv(int a) {
+		return pow(a, MOD-2);
+	}
+	
+	public void doIt() throws IOException {
+		BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
+		
+		StringTokenizer tok = new StringTokenizer(in.readLine());
+		int n = Integer.parseInt(tok.nextToken());
+		int k = Integer.parseInt(tok.nextToken());
+		
+		f = new int[n+42];
+		rf = new int[n+42];
+		f[0] = rf[0] = 1;
+		for (int i = 1; i < f.length; ++i) {
+			f[i] = mul(f[i-1], i);
+			rf[i] = mul(rf[i-1], inv(i));
+		}
+		
+		int[] events = new int[2*n];
+		for (int i = 0; i < n; ++i) {
+			tok = new StringTokenizer(in.readLine());
+			int le = Integer.parseInt(tok.nextToken());
+			int ri = Integer.parseInt(tok.nextToken());
+			events[i] = le*2;
+			events[i + n] = ri*2 + 1;
+		}
+		shuffleArray(events);
+		Arrays.sort(events);
+		
+		int ans = 0;
+		int balance = 0;
+		for (int r = 0; r < 2*n;) {
+			int l = r;
+			while (r < 2*n && events[l] == events[r]) {
+				++r;
+			}
+			int added = r - l;
+			if (events[l] % 2 == 0) {
+				// Open event
+				ans += C(balance + added, k);
+				if (ans >= MOD) ans -= MOD;
+				ans += MOD - C(balance, k);
+				if (ans >= MOD) ans -= MOD;
+				balance += added;
+			} else {
+				// Close event
+				balance -= added;
+			}
+		}
+		
+		in.close();
+		System.out.println(ans);
+	}
+	
+	public static void main(String[] args) throws IOException {
+		(new D_Java()).doIt();
+	}
+}
+",1
+213340b3,35f0c004,"import java.util.*;
+import java.io.*;
+public class Solution {
+    static class FastReader {
+        BufferedReader br;
+        StringTokenizer st;
+        public FastReader() {
+            br = new BufferedReader(new InputStreamReader(System.in));
+        }
+        String next() {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+        String nextLine() {
+            String str = """";
+            try {
+                str = br.readLine();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+        }
+    }
+    static void sort(int a[]){ // int -> long
+        ArrayList<Integer> arr=new ArrayList<>(); // Integer -> Long
+        for(int i=0;i<a.length;i++)
+        arr.add(a[i]);
+        Collections.sort(arr);
+        for(int i=0;i<a.length;i++)
+        a[i]=arr.get(i);
+        
+    }
+    private static long gcd(long a, long b){
+        if(b==0)return a;
+        return gcd(b,a%b);
+    }
+    private static long pow(long x,long y){
+        if(y==0)return 1;
+        long temp = pow(x, y/2);
+        if(y%2==1){
+            return x*temp*temp;
+        }
+        else{
+            return temp*temp;
+        }
+    }
+    static int log(long n){
+        int res = 0;
+        while(n>0){
+            res++;
+            n/=2;
+        }
+        return res;
+    }
+
+    static int mod = (int)1e9+7;
+    static int INF = Integer.MAX_VALUE;
+    static PrintWriter out;
+    static FastReader sc ;
+    public static void main(String[] args) throws IOException {
+        sc = new FastReader();
+        out = new PrintWriter(System.out);
+        // primes();
+        // ================================ //
+        int test = sc.nextInt();
+        while (test-- > 0) {
+            int n = sc.nextInt();
+            String s = sc.nextLine();
+            String t = sc.nextLine();
+            solver(s,t, n);
+        }
+        // ================================ //
+        // int n = sc.nextInt();
+        // solver();
+        // ================================ //
+        out.flush();
+    }
+
+    public static void solver(String s, String t, int n) {
+        int diff = 0;
+        int one = 0;
+        int zero = 0;
+        for(int i=0;i<n;i++){
+            if(s.charAt(i)!=t.charAt(i)){
+                diff++;
+                if(s.charAt(i)=='1')one++;
+            }
+            else{
+                if(s.charAt(i)=='1')zero++;
+            }
+        }
+        if(diff==0){
+            out.println(0);
+            return;
+        }
+        int res = INF;
+        if(diff%2==0 && one==(diff-one)){
+            res = diff;
+        }
+        if(n-diff-1>=0 && (n-diff-1)%2==0 && zero>0 && (n-diff-zero)==zero-1){
+            res = Math.min(res, (n-diff-1)+1);
+        }
+        out.println(res==INF?-1:res);
+    }
+}
+","import java.io.*;
+import java.util.*;
+public class Main {
+    public static void main(String args[])
+    {
+        FastReader input=new FastReader();
+        PrintWriter out=new PrintWriter(System.out);
+        int T=input.nextInt();
+        while(T-->0)
+        {
+            int n=input.nextInt();
+            String a=input.next();
+            String b=input.next();
+            int same1=0,same0=0,opp1=0,opp0=0;
+            for(int i=0;i<n;i++)
+            {
+                if(a.charAt(i)==b.charAt(i))
+                {
+                    if(a.charAt(i)=='1') same1++;
+                    else same0++;
+                }
+                else
+                {
+                    if(a.charAt(i)=='1') opp1++;
+                    else opp0++;
+                }
+            }
+            if(same0+same1==n)
+            {
+                out.println(0);
+            }
+            else
+            {
+                int x=same1+opp1;
+                int y=same1+opp0;
+                int z=same0+opp0;
+                if(x==y || (z+1)==y)
+                {
+                    int min=Integer.MAX_VALUE;
+                    if((same0+same1)%2!=0 && same0==(same0+same1)/2)
+                    {
+                        min=Math.min(min,same0+same1);
+                    }
+                    if((opp0+opp1)%2==0 && opp0==(opp0+opp1)/2)
+                    {
+                        min=Math.min(min,opp0+opp1);
+                    }
+                    out.println(min);
+                }
+                else
+                {
+                    out.println(-1);
+                }
+            }
+        }
+        out.close();
+    }
+    static class FastReader
+    {
+        BufferedReader br;
+        StringTokenizer st;
+        public FastReader()
+        {
+            br = new BufferedReader(new InputStreamReader(System.in));
+        }
+        String next()
+        {
+            while (st == null || !st.hasMoreElements())
+            {
+                try
+                {
+                    st = new StringTokenizer(br.readLine());
+                }
+                catch (IOException e)
+                {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+        int nextInt()
+        {
+            return Integer.parseInt(next());
+        }
+        long nextLong()
+        {
+            return Long.parseLong(next());
+        }
+        double nextDouble()
+        {
+            return Double.parseDouble(next());
+        }
+        String nextLine()
+        {
+            String str="""";
+            try
+            {
+                str=br.readLine();
+            }
+            catch (IOException e)
+            {
+                e.printStackTrace();
+            }
+            return str;
+        }
+    }
+}",0
+7bc92b7f,9028caf7,"import java.util.*;
+import java.io.*;
+
+
+public class Main{
+
+    public static void main(String[] args) throws java.io.IOException {
+        Scanner sc = new Scanner(System.in);
+        int n=sc.nextInt();
+        int[] arr=new int[n];
+        int[][] dp=new int[n][n];
+        int[][] min=new int[n][n];
+        ArrayList<Integer> ones=new ArrayList<>();
+        ArrayList<Integer> zero=new ArrayList<>();
+        for(int i=0;i<n;++i) {
+            arr[i] = sc.nextInt();
+            if(arr[i]==1)
+                ones.add(i);
+            else
+                zero.add(i);
+        }
+        for(int i=0;i<n;++i)
+            for(int j=0;j<n;++j) {
+                min[i][j] = Integer.MAX_VALUE;
+                dp[i][j] = Integer.MAX_VALUE;
+            }
+        int len=ones.size();
+        int zlen=zero.size();
+        int minn=0;
+        for(int i=0;i<len;++i)
+        {
+            int cur = ones.get(i);
+            for(int j=i;j<zlen;j++)
+            {
+                int curz = zero.get(j);
+                int cost = Math.abs(cur-curz);
+                if(i!=0 && curz-1>=0)
+                {
+                    cost+=min[i-1][curz-1];
+                }
+                dp[i][curz]=cost;
+            }
+            minn=Integer.MAX_VALUE;
+            for(int j=0;j<n;++j)
+            {
+                if(dp[i][j]<minn)
+                    minn=dp[i][j];
+                min[i][j]=minn;
+            }
+        }
+        System.out.println(minn);
+    }
+}
+// 1 0 1 1 0 0 1","import java.io.*;
+import java.util.*;
+public class Main {
+    public static void main(String args[])
+    {
+        FastReader input=new FastReader();
+        PrintWriter out=new PrintWriter(System.out);
+        int T=1;
+        while(T-->0)
+        {
+            int n=input.nextInt();
+            int a[]=new int[n];
+            ArrayList<Integer> list=new ArrayList<>();
+            ArrayList<Integer> space=new ArrayList<>();
+            for(int i=0;i<n;i++)
+            {
+                a[i]=input.nextInt();
+                if(a[i]==1)
+                {
+                    list.add(i);
+                }
+                else
+                {
+                    space.add(i);
+                }
+            }
+            int pre[]=new int[space.size()];
+            for(int i=0;i<list.size();i++)
+            {
+                if(i==0)
+                {
+                    int min=Integer.MAX_VALUE;
+                    for(int j=0;j<space.size();j++)
+                    {
+                        pre[j]=Math.abs(list.get(i)-space.get(j));
+                        min=Math.min(min,pre[j]);
+                        pre[j]=min;
+                    }
+                }
+                else
+                {
+                    int arr[]=new int[space.size()];
+                    for(int j=0;j<i;j++)
+                    {
+                        arr[j]=Integer.MAX_VALUE;
+                    }
+
+                    int min=Integer.MAX_VALUE;
+                    for(int j=i;j<space.size();j++)
+                    {
+                        int v=Math.abs(list.get(i)-space.get(j));
+                        v+=pre[j-1];
+                        arr[j]=v;
+                        min=Math.min(min,v);
+                        arr[j]=min;
+                    }
+                    for(int j=0;j<space.size();j++)
+                    {
+                        pre[j]=arr[j];
+                    }
+                }
+            }
+            out.println(pre[space.size()-1]);
+        }
+        out.close();
+    }
+    static class FastReader
+    {
+        BufferedReader br;
+        StringTokenizer st;
+        public FastReader()
+        {
+            br = new BufferedReader(new InputStreamReader(System.in));
+        }
+        String next()
+        {
+            while (st == null || !st.hasMoreElements())
+            {
+                try
+                {
+                    st = new StringTokenizer(br.readLine());
+                }
+                catch (IOException e)
+                {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+        int nextInt()
+        {
+            return Integer.parseInt(next());
+        }
+        long nextLong()
+        {
+            return Long.parseLong(next());
+        }
+        double nextDouble()
+        {
+            return Double.parseDouble(next());
+        }
+        String nextLine()
+        {
+            String str="""";
+            try
+            {
+                str=br.readLine();
+            }
+            catch (IOException e)
+            {
+                e.printStackTrace();
+            }
+            return str;
+        }
+    }
+}",0
+6f393cfe,b185d034,"import java.io.*;
+import java.util.*;
+
+public class C {
+
+    public static void main(String[] args) throws Exception{
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
+        try{
+            int t = Integer.parseInt(br.readLine());
+            while(t-->0){
+                int n = Integer.parseInt(br.readLine());
+                int lst[][] = new int[n][5];
+                for(int i=0; i<n; i++){
+                    String s = br.readLine();
+                    for(int j=0; j<s.length(); j++){
+                        lst[i][s.charAt(j)-'a']++;
+                    }
+                }
+                int fans = Integer.MIN_VALUE;
+                for(int i=0; i<5; i++){
+                    int val[] = new int[n];
+                    for(int k=0; k<n; k++){
+                        int sum = 0;
+                        for(int j=0; j<5; j++){
+                            if(i==j){
+                                sum += lst[k][j];
+                            }else{
+                                sum -= lst[k][j];
+                            }
+                        }
+                        val[k] = sum;
+                    }
+                    Arrays.sort(val);
+                    int sum = 0;
+                    int ans = 0;
+                    for(int x = n-1; x>=0; x--){
+                        sum+=val[x];
+                        if(sum>0){
+                            ans++;
+                        }else{
+                            break;
+                        }
+                    }
+                    fans = Math.max(fans, ans);
+                }
+                bw.write(fans+""\n"");
+            }
+            bw.flush();
+        }catch(Exception e){
+            return;
+        }
+    }
+    
+}","import java.io.*;
+import java.util.*;
+public class A734C {
+    public static void main(String[] args) {
+        JS scan = new JS();
+        int t = scan.nextInt();
+        loop:while(t-->0){
+            int n = scan.nextInt();
+            String[] arr= new String[n];
+            Integer[][] counts = new Integer[5][n];
+            for(int i = 0;i<5;i++){
+                for(int j = 0;j<n;j++){
+                    counts[i][j] = 0;
+                }
+            }
+            for(int i =0;i<n;i++){
+                arr[i] = scan.next();
+                int[] freq =new int[5];
+                for(int j = 0;j<arr[i].length();j++){
+                    freq[arr[i].charAt(j)-'a']++;
+                }
+                for(int j = 0;j<5;j++){
+                    counts[j][i] = freq[j]-(arr[i].length()-freq[j]);
+                }
+            }
+            int best = 0;
+            for(int i = 0;i<5;i++){
+                Arrays.sort(counts[i]);
+                int curr = 0;
+                int extra = 0;
+                for(int j = n-1;j>=0;j--){
+                    extra+=counts[i][j];
+                    if(extra>0)curr++;
+                }
+                best = Math.max(best,curr);
+            }
+            System.out.println(best);
+
+        }
+    }
+    static class JS {
+        public int BS = 1 << 16;
+        public char NC = (char) 0;
+        byte[] buf = new byte[BS];
+        int bId = 0, size = 0;
+        char c = NC;
+        double num = 1;
+        BufferedInputStream in;
+
+        public JS() {
+            in = new BufferedInputStream(System.in, BS);
+        }
+
+        public JS(String s) throws FileNotFoundException {
+            in = new BufferedInputStream(new FileInputStream(new File(s)), BS);
+        }
+
+        public char nextChar() {
+            while (bId == size) {
+                try {
+                    size = in.read(buf);
+                } catch (Exception e) {
+                    return NC;
+                }
+                if (size == -1) return NC;
+                bId = 0;
+            }
+            return (char) buf[bId++];
+        }
+
+        public int nextInt() {
+            return (int) nextLong();
+        }
+
+        public long nextLong() {
+            num = 1;
+            boolean neg = false;
+            if (c == NC) c = nextChar();
+            for (; (c < '0' || c > '9'); c = nextChar()) {
+                if (c == '-') neg = true;
+            }
+            long res = 0;
+            for (; c >= '0' && c <= '9'; c = nextChar()) {
+                res = (res << 3) + (res << 1) + c - '0';
+                num *= 10;
+            }
+            return neg ? -res : res;
+        }
+
+        public double nextDouble() {
+            double cur = nextLong();
+            return c != '.' ? cur : cur + nextLong() / num;
+        }
+
+        public String next() {
+            StringBuilder res = new StringBuilder();
+            while (c <= 32) c = nextChar();
+            while (c > 32) {
+                res.append(c);
+                c = nextChar();
+            }
+            return res.toString();
+        }
+
+        public String nextLine() {
+            StringBuilder res = new StringBuilder();
+            while (c <= 32) c = nextChar();
+            while (c != '\n') {
+                res.append(c);
+                c = nextChar();
+            }
+            return res.toString();
+        }
+
+        public boolean hasNext() {
+            if (c > 32) return true;
+            while (true) {
+                c = nextChar();
+                if (c == NC) return false;
+                else if (c > 32) return true;
+            }
+        }
+    }
+}
+",0
+1dab88fb,bac616ee,"import java.util.*;
+
+public class Main
+{
+    static class Edge{
+        public int node;
+        public int index;
+        public Edge(int n, int i){
+            node=n;
+            index=i;
+        }
+    }
+    static Scanner sc=new Scanner(System.in);
+	public static void main(String[] args) {
+	    
+	    int test=sc.nextInt();
+	    while(test-->0){
+	        
+	        solve();
+	    }
+	}
+	
+	static void solve(){
+	    int n=sc.nextInt();
+	        ArrayList<ArrayList<Edge>> graph= new ArrayList<ArrayList<Edge>>();
+	        for(int i=0;i<n;i++){
+	            graph.add(new ArrayList<>());
+	        }
+	        for (int i = 0; i < n - 1; i++) {
+	            int u = sc.nextInt();
+	            int v = sc.nextInt();
+	            u--; v--;
+	            
+	            graph.get(u).add(new Edge(v, i));
+	            graph.get(v).add(new Edge(u, i));
+            }
+            
+            int start = 0;
+            for (int i = 0; i < n; i++) {
+                if (graph.get(i).size() > 2) {
+                    System.out.println(""-1"");
+                    return;
+                } else if (graph.get(i).size() == 1) {
+                    start = i;
+                }
+            }
+            int[] weight = new int[n - 1];
+            
+            int prevNode = -1;
+            int curNode = start;
+            int curWeight = 2;
+            
+            while (true) {
+                ArrayList<Edge> edges = graph.get(curNode);
+                Edge next = edges.get(0);
+                
+                if (next.node == prevNode) {
+                    if (edges.size() == 1) {
+                        break;
+                    } else {
+                        next = edges.get(1);
+                    }
+                }
+                weight[next.index] = curWeight;
+                
+                prevNode = curNode;
+                curNode = next.node;
+                curWeight = 5 - curWeight;
+            }
+            for (int i = 0; i < n - 1; i++) {
+                System.out.print(weight[i]);
+                System.out.print("" "");
+            }
+            System.out.println();
+	}
+}
+","import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+import java.util.StringTokenizer;
+
+public class NotAssigning {
+	
+	static class FastReader {
+		
+        BufferedReader br;
+        StringTokenizer st;
+ 
+        public FastReader() {
+        	
+            br = new BufferedReader(new InputStreamReader(System.in));
+            
+        }
+ 
+        String next() {
+        	
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                }
+                catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+            
+        }
+ 
+        int nextInt() {
+        	
+        	return Integer.parseInt(next());
+        	
+        }
+ 
+        long nextLong() {
+        	
+        	return Long.parseLong(next());
+        	
+        }
+        
+        double nextFloat() {
+        	
+        	return Float.parseFloat(next());
+        
+        }
+ 
+        double nextDouble() {
+        	
+        	return Double.parseDouble(next());
+        	
+        }
+ 
+        String nextLine() {
+        	
+            String str = """";
+            try {
+                str = br.readLine();
+            }
+            catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+            
+        }
+        
+        int[] nextArray(int n) {
+        	
+        	int[] a = new int[n];
+        	for (int i=0; i<n; i++) {
+        		a[i] = this.nextInt();
+        	}
+        	return a;
+        	
+        }
+        
+        long[] nextArrayLong(int n) {
+        	
+        	long[] a = new long[n];
+        	for (int i=0; i<n; i++) {
+        		a[i] = this.nextLong();
+        	}
+        	return a;
+        	
+        }
+        
+    }
+	
+	static class Pair {
+		
+		int a, b;
+
+		public Pair(int a, int b) {
+			
+			this.a = a;
+			this.b = b;
+			
+		}
+
+	}
+	
+	static boolean vis[];
+	public static void dfs(ArrayList<ArrayList<Pair>> t, int cur, boolean mode, int[] w) {
+		vis[cur] = true;
+		for (Pair p : t.get(cur)) {
+			if (!vis[p.a]) {
+				if (mode) {
+					w[p.b] = 3;
+				}
+				else {
+					w[p.b] = 2;
+				}
+				dfs(t, p.a, !mode, w);
+			}
+		}
+	}
+	
+	public static void solve(int n, int[] u, int[] v) {
+		
+		ArrayList<ArrayList<Pair>> t = new ArrayList<ArrayList<Pair>>(n);
+		for (int i=0; i<n; i++) {
+			t.add(new ArrayList<Pair>());
+		}
+		for (int i=0; i<n-1; i++) {
+			t.get(u[i]).add(new Pair(v[i], i));
+			t.get(v[i]).add(new Pair(u[i], i));
+		}
+		int start = 0;
+		for (int i=0; i<n; i++) {
+			if (t.get(i).size() > 2) {
+				System.out.println(""-1"");
+				return;
+			}
+			if (t.get(i).size() == 1) {
+				start = i;
+			}
+		}
+		vis = new boolean[n];
+		int[] w = new int[n-1];
+		dfs(t, start, false, w);
+		StringBuilder ans = new StringBuilder();
+		for (int i=0; i<n-1; i++) {
+			ans.append(w[i]).append("" "");
+		}
+		System.out.println(ans);
+		
+	}
+
+	public static void main(String[] args) {
+		
+		FastReader in = new FastReader();
+		int t = in.nextInt();
+		while (t-- > 0) {
+			int n = in.nextInt();
+			int[] u = new int[n-1];
+			int[] v = new int[n-1];
+			for (int i=0; i<n-1; i++) {
+				u[i] = in.nextInt()-1;
+				v[i] = in.nextInt()-1;
+			}
+			solve(n, u, v);
+		}
+
+	}
+
+}
+",0
+115c99cb,921b6e4a,"import java.io.*;
+import java.util.*;
+
+public class D_Java {
+	public static final int MOD = 998244353;
+	
+	public static int mul(int a, int b) {
+		return (int)((long)a * (long)b % MOD);
+	}
+	
+	int[] f;
+	int[] rf;
+	
+	public int C(int n, int k) {
+		return (k < 0 || k > n) ? 0 : mul(f[n], mul(rf[n-k], rf[k]));
+	}
+	
+	public static int pow(int a, int n) {
+		int res = 1;
+		while (n != 0) {
+			if ((n & 1) == 1) {
+				res = mul(res, a);
+			}
+			a = mul(a, a);
+			n >>= 1;
+		}
+		return res;
+	}
+	
+	static void shuffleArray(int[] a) {
+		Random rnd = new Random();
+		for (int i = a.length-1; i > 0; i--) {
+			int index = rnd.nextInt(i + 1);
+			int tmp = a[index];
+			a[index] = a[i];
+			a[i] = tmp;
+		}
+	}
+	
+	public static int inv(int a) {
+		return pow(a, MOD-2);
+	}
+	
+	public void doIt() throws IOException {
+		BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
+		
+		StringTokenizer tok = new StringTokenizer(in.readLine());
+		int n = Integer.parseInt(tok.nextToken());
+		int k = Integer.parseInt(tok.nextToken());
+		
+		f = new int[n+42];
+		rf = new int[n+42];
+		f[0] = rf[0] = 1;
+		for (int i = 1; i < f.length; ++i) {
+			f[i] = mul(f[i-1], i);
+			rf[i] = mul(rf[i-1], inv(i));
+		}
+		
+		int[] events = new int[2*n];
+		for (int i = 0; i < n; ++i) {
+			tok = new StringTokenizer(in.readLine());
+			int le = Integer.parseInt(tok.nextToken());
+			int ri = Integer.parseInt(tok.nextToken());
+			events[i] = le*2;
+			events[i + n] = ri*2 + 1;
+		}
+		shuffleArray(events);
+		Arrays.sort(events);
+		
+		int ans = 0;
+		int balance = 0;
+		for (int r = 0; r < 2*n;) {
+			int l = r;
+			while (r < 2*n && events[l] == events[r]) {
+				++r;
+			}
+			int added = r - l;
+			if (events[l] % 2 == 0) {
+				// Open event
+				ans += C(balance + added, k);
+				if (ans >= MOD) ans -= MOD;
+				ans += MOD - C(balance, k);
+				if (ans >= MOD) ans -= MOD;
+				balance += added;
+			} else {
+				// Close event
+				balance -= added;
+			}
+		}
+		
+		in.close();
+		System.out.println(ans);
+	}
+	
+	public static void main(String[] args) throws IOException {
+		(new D_Java()).doIt();
+	}
+}","import java.io.*;
+import java.util.*;
+
+public class D_Java {
+	public static final int MOD = 998244353;
+	
+	public static int mul(int a, int b) {
+		return (int)((long)a * (long)b % MOD);
+	}
+	
+	int[] f;
+	int[] rf;
+	
+	public int C(int n, int k) {
+		return (k < 0 || k > n) ? 0 : mul(f[n], mul(rf[n-k], rf[k]));
+	}
+	
+	public static int pow(int a, int n) {
+		int res = 1;
+		while (n != 0) {
+			if ((n & 1) == 1) {
+				res = mul(res, a);
+			}
+			a = mul(a, a);
+			n >>= 1;
+		}
+		return res;
+	}
+	
+	static void shuffleArray(int[] a) {
+		Random rnd = new Random();
+		for (int i = a.length-1; i > 0; i--) {
+			int index = rnd.nextInt(i + 1);
+			int tmp = a[index];
+			a[index] = a[i];
+			a[i] = tmp;
+		}
+	}
+	
+	public static int inv(int a) {
+		return pow(a, MOD-2);
+	}
+	
+	public void doIt() throws IOException {
+		BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
+		
+		StringTokenizer tok = new StringTokenizer(in.readLine());
+		int n = Integer.parseInt(tok.nextToken());
+		int k = Integer.parseInt(tok.nextToken());
+		
+		f = new int[n+42];
+		rf = new int[n+42];
+		f[0] = rf[0] = 1;
+		for (int i = 1; i < f.length; ++i) {
+			f[i] = mul(f[i-1], i);
+			rf[i] = mul(rf[i-1], inv(i));
+		}
+		
+		int[] events = new int[2*n];
+		for (int i = 0; i < n; ++i) {
+			tok = new StringTokenizer(in.readLine());
+			int le = Integer.parseInt(tok.nextToken());
+			int ri = Integer.parseInt(tok.nextToken());
+			events[i] = le*2;
+			events[i + n] = ri*2 + 1;
+		}
+		shuffleArray(events);
+		Arrays.sort(events);
+		
+		int ans = 0;
+		int balance = 0;
+		for (int r = 0; r < 2*n;) {
+			int l = r;
+			while (r < 2*n && events[l] == events[r]) {
+				++r;
+			}
+			int added = r - l;
+			if (events[l] % 2 == 0) {
+				// Open event
+				ans += C(balance + added, k);
+				if (ans >= MOD) ans -= MOD;
+				ans += MOD - C(balance, k);
+				if (ans >= MOD) ans -= MOD;
+				balance += added;
+			} else {
+				// Close event
+				balance -= added;
+			}
+		}
+		
+		in.close();
+		System.out.println(ans);
+	}
+	
+	public static void main(String[] args) throws IOException {
+		(new D_Java()).doIt();
+	}
+}",1
+5be7547e,cb032314,"// package codeforces;
+import java.io.*;
+import java.util.*;
+		
+public class practice {
+	
+	static FastScanner fs = new FastScanner();
+
+	public static void main(String[] args) {
+		int t = 1;
+		t = fs.nextInt();   
+		for(int i=1;i<=t;i++) {
+			solve(t);
+		}
+	}
+	
+	public static void dfs(int u, boolean visited[], ArrayList<ArrayList<Integer>> g[], int ans[], int x) {
+		visited[u] = true;
+		for(ArrayList<Integer> v:g[u]) {
+			if(!visited[v.get(0)]) {
+				ans[v.get(1)]=x;
+				dfs(v.get(0),visited,g,ans,x^1);
+			}
+		}
+		return;
+	}
+	
+	@SuppressWarnings(""unused"")
+	public static void solve(int tt) {
+		int n = fs.nextInt();
+		@SuppressWarnings(""unchecked"")
+		ArrayList<ArrayList<Integer>> g[] = new ArrayList[n];
+		for(int i=0;i<n;i++)g[i]=new ArrayList<ArrayList<Integer>>();
+		int ans[] = new int[n];
+		boolean visited[] = new boolean[n];
+		int deg[] = new int[n];
+		for(int i=0;i<n;i++)deg[i]=0;
+		for(int i=0;i<n-1;i++) {
+			int u = fs.nextInt() - 1;int v = fs.nextInt() - 1;
+			ArrayList<Integer> L1=new ArrayList<Integer>();
+			L1.add(v);L1.add(i);
+			g[u].add(L1);
+			ArrayList<Integer> L2=new ArrayList<Integer>();
+			L2.add(u);L2.add(i);
+			g[v].add(L2);
+			deg[u]++;
+			deg[v]++;
+		}
+		// degree must be <=2 cause if greater than that then sum will be always non prime
+		// there will be exactly 2 leafs, we start dfs from one of them
+		int leaf=-1;
+		boolean notcool=false;
+		for(int i=0;i<n;i++) {
+			if(deg[i]>2) {
+				System.out.println(-1);
+				return;
+			}
+		}
+		for(int i=0;i<n;i++) {
+			if(deg[i]==1) {
+				leaf=i;
+				break;
+			}
+		}
+		dfs(leaf,visited,g,ans,2);
+		for(int i=0;i<n-1;i++)System.out.print(ans[i]+"" "");
+		System.out.println();
+		return;
+	}
+	
+	public static int [] sortarray(int a[]) {
+		ArrayList<Integer> L = new ArrayList<Integer>();
+		for(int i:a) {
+			L.add(i);
+		}
+		Collections.sort(L);
+		for(int i=0;i<L.size();i++)a[i]=L.get(i);
+		return a;
+	}
+	
+	static class FastScanner {
+		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st=new StringTokenizer("""");
+		String next() {
+			while (!st.hasMoreTokens())
+				try {
+					st=new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			return st.nextToken();
+		}
+			
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+		int[] readArray(int n) {
+			int[] a=new int[n];
+			for (int i=0; i<n; i++) a[i]=nextInt();
+			return a;
+		}
+		ArrayList<Integer> readList(int n) {
+			ArrayList<Integer> a = new ArrayList<Integer>();
+			int x;
+			for(int i=0;i<n;i++) {
+				x=fs.nextInt();
+				a.add(x);
+			}
+			return a;
+		}
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+	}
+}
+","
+
+import java.io.*;
+import java.util.*;
+
+public class C {
+
+    static FastScanner sc = new FastScanner();
+    static PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
+    static class pair{
+        public pair(int x, int y) {
+            this.x = x;
+            this.y = y;
+        }
+
+        int x;
+        int y;
+        @Override
+        public boolean equals(Object o) {
+            if (this == o) return true;
+            if (o == null || getClass() != o.getClass()) return false;
+            pair pair = (pair) o;
+            return x == pair.x && y == pair.y;
+        }
+
+        @Override
+        public int hashCode() {
+            return Objects.hash(x, y);
+        }
+    }
+    static void solve(){
+        int n = sc.nextInt();
+        int[]degree = new int[n];
+        List<Integer>[]grid = new List[n];
+        for (int i = 0; i < n; i++) {
+            grid[i] = new ArrayList();
+        }
+        List<pair>list = new ArrayList<>();
+        for (int i = 0; i < n - 1; i++) {
+            int x = sc.nextInt() - 1;
+            int y = sc.nextInt() - 1;
+            grid[x].add(y);
+            grid[y].add(x);
+            degree[x]++;
+            degree[y]++;
+            list.add(new pair(Math.min(x,y),Math.max(x,y)));
+        }
+        int begin = 0;
+        for(int i = 0;i < degree.length;i++){
+            if(degree[i] > 2){
+                System.out.println(-1);
+                return;
+            }
+            if(degree[i] == 1){
+                begin = i;
+            }
+        }
+        boolean[]used = new boolean[n];
+        int[]p = new int[]{5,2,11,2};
+        int idx = 0;
+        HashMap<pair,Integer>map = new HashMap<>();
+        while (!used[begin]){
+            used[begin] = true;
+            for(int next : grid[begin]){
+                if(used[next])
+                    continue;
+                map.put(new pair(Math.min(begin,next),Math.max(begin,next)),p[idx % 4]);
+                idx++;
+                begin = next;
+            }
+        }
+        StringBuilder bd = new StringBuilder();
+        for(pair pp : list){
+            bd.append(map.get(pp) + "" "");
+        }
+        System.out.println(bd.toString().trim());
+    }
+
+    public static void main(String[] args) {
+        int n = sc.nextInt();
+        for(int i = 0;i < n;i++){
+            solve();
+        }
+    }
+
+    static class FastScanner {
+        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st=new StringTokenizer("""");
+        String next() {
+            while (!st.hasMoreTokens())
+                try {
+                    st=new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+        int[] readArray(int n) {
+            int[] a=new int[n];
+            for (int i=0; i<n; i++) a[i]=nextInt();
+            return a;
+        }
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+    }
+}
+
+",0
+4e9c4bf9,7011024d,"import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Scanner;
+
+public class E1525D {
+    public static void main(String[] args) {
+        Scanner scn = new Scanner(System.in);
+        int n = scn.nextInt();
+        int[] arr = new int[n];
+        ArrayList<Integer> occupied = new ArrayList<>();
+        for (int i = 0; i < n; i++) {
+            arr[i] = scn.nextInt();
+            if (arr[i] == 1) occupied.add(i);
+        }
+        int[][] dp = new int[n + 1][occupied.size() + 1];
+        for (int[] row : dp) Arrays.fill(row, (int) 1e9);
+        dp[0][0] = 0;
+        for (int i = 1; i <= n; i++) {
+            dp[i][0] = 0;
+            for (int j = 1; j <= occupied.size(); j++) {
+                dp[i][j] = dp[i - 1][j];
+                if (arr[i - 1] == 0)
+                    dp[i][j] = Math.min(dp[i][j], dp[i - 1][j - 1] + Math.abs(i - 1 - occupied.get(j - 1)));
+            }
+        }
+        System.out.println(dp[n][occupied.size()]);
+
+
+    }
+}
+","import java.util.*;
+
+public class D {
+
+    public static void main(String[] args) {
+        Scanner scanner = new Scanner(System.in);
+        int n = scanner.nextInt();
+        ArrayList<Integer> occupied = new ArrayList<>();
+        ArrayList<Integer> vacant = new ArrayList<>();
+        for (int i = 0; i < n; i++) {
+            int x = scanner.nextInt();
+            if (x == 1)
+                occupied.add(i);
+            else
+                vacant.add(i);
+        }
+
+        Solution Solution = new Solution(occupied, vacant);
+
+//        System.out.println(Solution.tabulation());
+        System.out.println(Solution.memoization());
+    }
+}
+
+class Solution {
+
+    ArrayList<Integer> occupied, vacant;
+    int x, y;
+
+    public Solution(ArrayList<Integer> occupied, ArrayList<Integer> vacant) {
+        this.occupied = occupied;
+        this.vacant = vacant;
+        x = occupied.size(); y = vacant.size();
+    }
+
+    int tabulation() {
+        return tabulation(x, y);
+    }
+
+    int tabulation(int x, int y) {
+        int[][] dp = new int[x+1][y+1];
+        for (int i = 0; i <= x; i++) {
+            Arrays.fill(dp[i], Integer.MAX_VALUE/2);
+        }
+        for (int i = 0; i <= x; i++) {
+            dp[i][0] = 0;
+        }
+        for (int i = 0; i <= y; i++) {
+            dp[0][i] = 0;
+        }
+        
+        for (int i = 1; i <= x; i++) {
+            for (int j = 1; j <= y; j++) {
+                if(i == j) {
+                    dp[i][j] = dp[i-1][j-1] + Math.abs(occupied.get(i-1) - vacant.get(j-1));
+                }
+                else {
+                    dp[i][j] = Math.min(dp[i][j-1], dp[i-1][j-1] + Math.abs(occupied.get(i-1) - vacant.get(j-1)));
+                }
+            }
+        }
+        return dp[x][y];
+    }
+
+    int memoization() {
+        int[][] dp = new int[x][y];
+        for (int i = 0; i < x; i++) {
+            Arrays.fill(dp[i], -1);
+        }
+        return memoization(dp, x-1, y-1);
+    }
+
+    int memoization(int[][] dp, int n, int m) {
+        if(n < 0) {
+            return 0;
+        }
+        if(m < n) {
+            return Integer.MAX_VALUE;
+        }
+        if(dp[n][m] != -1) {
+            return dp[n][m];
+        }
+        int first = memoization(dp, n, m-1);
+        int second = memoization(dp, n-1, m-1) + Math.abs(occupied.get(n) - vacant.get(m));
+        dp[n][m] = Math.min(first, second);
+        return dp[n][m];
+    }
+}",0
+680ba922,6e207cbf,"import java.util.*;
+import java.io.*;
+
+public class Solution
+{
+    static class Reader {
+        final private int BUFFER_SIZE = 1 << 16;
+        private DataInputStream din;
+        private byte[] buffer;
+        private int bufferPointer, bytesRead;
+ 
+        public Reader()
+        {
+            din = new DataInputStream(System.in);
+            buffer = new byte[BUFFER_SIZE];
+            bufferPointer = bytesRead = 0;
+        }
+ 
+        public Reader(String file_name) throws IOException
+        {
+            din = new DataInputStream(
+                new FileInputStream(file_name));
+            buffer = new byte[BUFFER_SIZE];
+            bufferPointer = bytesRead = 0;
+        }
+ 
+        public String readLine() throws IOException
+        {
+            byte[] buf = new byte[64]; // line length
+            int cnt = 0, c;
+            while ((c = read()) != -1) {
+                if (c == '\n') {
+                    if (cnt != 0) {
+                        break;
+                    }
+                    else {
+                        continue;
+                    }
+                }
+                buf[cnt++] = (byte)c;
+            }
+            return new String(buf, 0, cnt);
+        }
+ 
+        public int nextInt() throws IOException
+        {
+            int ret = 0;
+            byte c = read();
+            while (c <= ' ') {
+                c = read();
+            }
+            boolean neg = (c == '-');
+            if (neg)
+                c = read();
+            do {
+                ret = ret * 10 + c - '0';
+            } while ((c = read()) >= '0' && c <= '9');
+ 
+            if (neg)
+                return -ret;
+            return ret;
+        }
+ 
+        public long nextLong() throws IOException
+        {
+            long ret = 0;
+            byte c = read();
+            while (c <= ' ')
+                c = read();
+            boolean neg = (c == '-');
+            if (neg)
+                c = read();
+            do {
+                ret = ret * 10 + c - '0';
+            } while ((c = read()) >= '0' && c <= '9');
+            if (neg)
+                return -ret;
+            return ret;
+        }
+ 
+        public double nextDouble() throws IOException
+        {
+            double ret = 0, div = 1;
+            byte c = read();
+            while (c <= ' ')
+                c = read();
+            boolean neg = (c == '-');
+            if (neg)
+                c = read();
+ 
+            do {
+                ret = ret * 10 + c - '0';
+            } while ((c = read()) >= '0' && c <= '9');
+ 
+            if (c == '.') {
+                while ((c = read()) >= '0' && c <= '9') {
+                    ret += (c - '0') / (div *= 10);
+                }
+            }
+ 
+            if (neg)
+                return -ret;
+            return ret;
+        }
+ 
+        private void fillBuffer() throws IOException
+        {
+            bytesRead = din.read(buffer, bufferPointer = 0,
+                                 BUFFER_SIZE);
+            if (bytesRead == -1)
+                buffer[0] = -1;
+        }
+ 
+        private byte read() throws IOException
+        {
+            if (bufferPointer == bytesRead)
+                fillBuffer();
+            return buffer[bufferPointer++];
+        }
+ 
+        public void close() throws IOException
+        {
+            if (din == null)
+                return;
+            din.close();
+        }
+    }
+    
+   
+  static int parent(int a , int p[])
+  {
+      if(a == p[a])
+      return a;
+      
+      return p[a] = parent(p[a],p);
+  }
+  
+  static void union(int a , int b , int p[] , int size[])
+  {
+      a = parent(a,p);
+      b = parent(b,p);
+      
+      if(a == b)
+      return;
+      
+      if(size[a] < size[b])
+      {
+          int temp = a;
+          a = b;
+          b = temp;
+      }
+      
+      p[b] = a;
+      size[a] += size[b];
+  }
+  
+  
+  
+  
+ static long getSum(int index , long BITree[])
+    {
+        long sum = 0; // Iniialize result
+      
+        // index in BITree[] is 1 more than
+        // the index in arr[]
+       // index = index + 1;
+      
+        // Traverse ancestors of BITree[index]
+        while(index>0)
+        {
+            // Add current element of BITree 
+            // to sum
+            sum += BITree[index];
+      
+            // Move index to parent node in 
+            // getSum View
+            index -= index & (-index);
+        }
+        return sum;
+    }
+  
+    // Updates a node in Binary Index Tree (BITree)
+    // at given index in BITree. The given value 
+    // 'val' is added to BITree[i] and all of 
+    // its ancestors in tree.
+    public static void updateBIT(int n, int index, 
+                                        long val , long BITree[])
+    {
+        // index in BITree[] is 1 more than 
+        // the index in arr[]
+      //  index = index + 1;
+      
+        // Traverse all ancestors and add 'val'
+        while(index <= n)
+        {
+        // Add 'val' to current node of BIT Tree
+        BITree[index] += val;
+      
+        // Update index to that of parent 
+        // in update View
+        index += index & (-index);
+        }
+    }
+    
+    
+   static int gcd(int a, int b)
+{
+    if (a == 0)
+        return b;
+    return gcd(b % a, a);
+}
+
+static int dp[][];
+
+
+static int f(int pos , int take , int arr[])
+{
+    if(pos == -1)
+    {
+        if(take == 0)
+    return 0;
+    
+    return -10000000;
+    
+    }
+    
+    
+    if(dp[pos][take] != -1)
+    return dp[pos][take];
+    
+    
+    if(pos+1-take == arr[pos])
+    dp[pos][take] = Math.max(dp[pos][take],1 + f(pos-1,take,arr));
+    
+    
+    dp[pos][take] = Math.max(dp[pos][take],f(pos-1,take,arr));
+    
+    
+    if(take > 0)
+    dp[pos][take] = Math.max(dp[pos][take],f(pos-1,take-1,arr));
+    
+    return dp[pos][take];
+}
+    public static void main(String []args) throws IOException
+    {
+        Scanner sc = new Scanner(System.in);
+        int t = sc.nextInt();
+        while(t-- > 0)
+        {
+            int n = sc.nextInt();
+            sc.nextLine();
+            String a = sc.nextLine();
+            String b = sc.nextLine();
+            int same = 0 , zo = 0 , oz = 0 , oo = 0 , zz = 0;
+            for(int i = 0 ; i < n ; i++)
+            {
+                if(a.charAt(i) == '0' && b.charAt(i) == '1')
+                oz++;
+                
+                else if(a.charAt(i) == '1' && b.charAt(i) == '0')
+                zo++;
+                
+                else if(a.charAt(i) == '1' && b.charAt(i) == '1')
+                oo++;
+                
+                else
+                zz++;
+            }
+            
+            if(oz == zo || (zz == oo-1))
+            {
+                int mx = Integer.MAX_VALUE;
+                if(oz == zo)
+                mx = Math.min(mx,2*oz);
+                
+                if(oo-1 == zz)
+                mx = Math.min(mx,zz+oo);
+                
+                System.out.println(mx);
+            }
+            
+            else
+            {
+                System.out.println(-1);
+            }
+        }
+    }
+}","import java.util.*;
+import java.lang.*;
+import java.io.*;
+
+public class Codechef
+{
+	public static void main (String[] args) throws java.lang.Exception
+	{
+        Scanner sc = new Scanner(System.in);
+        int t = sc.nextInt();
+        int sm, n;
+        while(t > 0) {
+            t--;
+            n = sc.nextInt();
+            String s1,s2;
+            s1 = sc.next();
+            s2 = sc.next();
+            int a[] = new int[4];
+            a[0] = 0; a[1] = 0; a[2] = 0; a[3] = 0;
+            for(int i = 0 ; i < n ; i++) {
+                if(s1.charAt(i) == '0'&& s2.charAt(i) == '1') a[0]++;
+                else if(s1.charAt(i) == '1'&& s2.charAt(i) == '0') a[1]++;
+                else if(s1.charAt(i) == '1'&& s2.charAt(i) == '1') a[2]++;
+                else a[3]++;
+            }
+            // System.out.println(a[0] + "" "" + a[1] + "" "" + a[2] + "" "" + a[3]);
+            int n1 = Integer.MAX_VALUE, n2 = Integer.MAX_VALUE, n3 = Integer.MAX_VALUE;
+            
+            if (a[0] == a[1]) {
+                n1 = 2*a[0];
+            }
+            if((a[2] - 1) == a[3]) {
+                // System.out.println(a[3] + 1);
+                n2 = 2*a[3] + 1;
+            } 
+            if((a[3] + 1) == a[2]) {
+                // System.out.println(a[2] + 1);
+                n3 = 2*a[2] + 1;
+            } 
+            int ans = Math.min(n1, Math.min(n2,n3));
+            if(ans == Integer.MAX_VALUE) {
+                System.out.println(""-1"");
+            } else {
+                System.out.println(ans);
+            }
+        }
+	}
+}
+",0
+14b0fb8e,8ddb5587,"import java.io.*;
+
+import java.util.*;
+ public class Solution {
+	 
+	static long res;
+	public static void main(String[] args) throws Exception
+    {
+		FastReader fr=new FastReader();
+        int n=fr.nextInt();
+        ArrayList<Integer> oc=new ArrayList<>();
+        ArrayList<Integer> em=new ArrayList<>();
+        res=Long.MAX_VALUE;
+        for(int i=0;i<n;i++) {
+        	int v=fr.nextInt();
+        	if(v==1)
+        		oc.add(i);
+        	else
+        		em.add(i);
+        }
+        Collections.sort(oc);
+        Collections.sort(em);
+        long dp[][]=new long[5001][5001];
+        for(int i=0;i<dp.length;i++) {
+        	for(int j=0;j<dp[i].length;j++) {
+        		dp[i][j]=-1;
+        	}
+        }
+        System.out.println(getMin(oc,em,0,0,dp));
+        
+        
+		
+    }
+	public static long getMin(ArrayList<Integer> oc,ArrayList<Integer> em,int idx,int j,long dp[][]) {
+	   if(idx==oc.size())
+		   return 0;
+		long available=em.size()-j;
+		long req=oc.size()-idx;
+		if(available<req)
+			return Integer.MAX_VALUE;
+		if(dp[idx][j]!=-1)
+			return dp[idx][j];
+		
+		long ch1=getMin(oc,em,idx,j+1,dp);
+		long ch2=getMin(oc,em,idx+1,j+1,dp)+Math.abs(em.get(j)-oc.get(idx));
+		
+		return dp[idx][j]=Math.min(ch1,ch2);
+		
+	}
+	
+		
+	
+	 
+public static String lcs(String a,String b) {
+		int dp[][]=new int[a.length()+1][b.length()+1];
+		for(int i=0;i<=a.length();i++)
+		{
+			for(int j=0;j<=b.length();j++)
+			{
+				if(i==0||j==0)
+					dp[i][j]=0;
+			}
+		}
+		
+		for(int i=1;i<=a.length();i++)
+		{
+			for(int j=1;j<=b.length();j++)
+			{
+				if(a.charAt(i-1)==b.charAt(j-1))
+					dp[i][j]=1+dp[i-1][j-1];
+				else
+					dp[i][j]=Math.max(dp[i-1][j],dp[i][j-1]);
+			}
+		}
+		
+		int i=a.length();
+		int j=b.length();
+		String lcs="""";
+		while(i>0&&j>0)
+		{
+			if(a.charAt(i-1)==b.charAt(j-1)) {
+				lcs=a.charAt(i-1)+lcs;
+				i--;
+				j--;
+			}
+			else 
+			{
+				if(dp[i-1][j]>dp[i][j-1])
+					i--;
+				else
+					j--;
+			}
+		}
+		
+		return lcs;
+            
+	}
+	
+	 
+	 
+	 
+	 public static long facto(long n) {
+		 if(n==1||n==0)
+			 return 1;
+		 return n*facto(n-1);
+	 }
+	 public static long gcd(long n1,long n2) {
+		 if (n2 == 0) {
+		        return n1;
+		    }
+		    return gcd(n2, n1 % n2);
+	}
+	 public static boolean isPali(String s) {
+		 int i=0;
+		 int j=s.length()-1;
+		 while(i<=j) {
+			 if(s.charAt(i)!=s.charAt(j))
+				 return false;
+			 i++;
+			 j--;
+		 }
+		 return true;
+	 }
+	 public static String reverse(String s) {
+		 String res="""";
+		 for(int i=0;i<s.length();i++) {
+			 res+=s.charAt(i);
+		 }
+		 return res;
+	 }
+	
+		
+	 
+	 public static int bsearch(long suf[],long val) {
+		 int i=0;
+		 int j=suf.length-1;
+		 while(i<=j) {
+			 int mid=(i+j)/2;
+			 if(suf[mid]==val)
+				 return mid;
+			 else if(suf[mid]<val)
+				 j=mid-1;
+			 else
+				 i=mid+1;
+		 }
+		 return -1;
+	 }
+	 
+	 
+	 
+	
+	 
+	 
+	public static int[] getFreq(String s) {
+		int a[]=new int[26];
+		for(int i=0;i<s.length();i++) {
+			a[s.charAt(i)-'a']++;
+		}
+		return a;
+		
+	}
+	 
+	 public static boolean isPrime(int n) {
+		 
+		 for(int i=2;(i*i)<=n;i++) {
+			 if(n%i==0)
+				 return false;
+		 }
+		 return true;
+	 }
+            	  
+             
+             
+    }
+class Pair{
+	long i;
+	long j;
+	
+	Pair(long num,long freq){
+		this.i=num;
+		
+		this.j=freq;
+	}
+	
+}
+
+	
+	 
+	
+	
+
+	 
+ 
+  
+
+class FastReader
+{
+    BufferedReader br;
+    StringTokenizer st;
+ 
+    public FastReader()
+    {
+        br = new BufferedReader(new
+                InputStreamReader(System.in));
+    }
+ 
+    String next()
+    {
+        while (st == null || !st.hasMoreElements())
+        {
+            try
+            {
+                st = new StringTokenizer(br.readLine());
+            }
+            catch (IOException e)
+            {
+                e.printStackTrace();
+            }
+        }
+        return st.nextToken();
+    }
+ 
+    int nextInt()
+    {
+        return Integer.parseInt(next());
+    }
+ 
+    long nextLong()
+    {
+        return Long.parseLong(next());
+    }
+ 
+    double nextDouble()
+    {
+        return Double.parseDouble(next());
+    }
+ 
+    String nextLine()
+    {
+        String str = """";
+        try
+        {
+            str = br.readLine();
+        }
+        catch (IOException e)
+        {
+            e.printStackTrace();
+        }
+        return str;
+    }
+}
+
+","import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.StringTokenizer;
+ 
+public class taskd {
+    public static void main(String[] args) {
+        FastScanner in = new FastScanner();
+        PrintWriter out = new PrintWriter(System.out);
+        taskd sol = new taskd();
+        sol.solve(in, out);
+        out.flush();
+    }
+
+    void solve(FastScanner in, PrintWriter out) {
+        int n = in.nextInt();
+        ArrayList<Integer> a = new ArrayList<>();
+        ArrayList<Integer> b = new ArrayList<>();
+        for (int i = 0; i < n; i++) {
+            int x = in.nextInt();
+            if (x == 1) {
+                a.add(i);
+            } else {
+                b.add(i);
+            }
+        }
+
+        long dp[][] = new long[a.size() + 5][b.size() + 5];
+        for (int i = a.size()-1; i >= 0; i--) {
+            dp[i][b.size()] = Integer.MAX_VALUE;
+            for (int j = b.size()-1; j >= 0; j--) {
+                dp[i][j] = dp[i][j + 1];
+                dp[i][j] = Math.min(dp[i][j], Math.abs(a.get(i) - b.get(j)) + dp[i + 1][j + 1]);
+            }
+        }
+        out.println(dp[0][0]);
+    }
+
+    static class FastScanner {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st = new StringTokenizer("""");
+        String next() {
+            while (!st.hasMoreTokens()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+        int nextInt() { return Integer.parseInt(next()); }
+        long nextLong() { return Long.parseLong(next()); }
+        float nextFloat() { return Float.parseFloat(next()); }
+        double nextDouble() { return Double.parseDouble(next()); }
+    }
+}",0
+16a2a867,3951966f,"import java.util.*;
+import java.io.*;
+public class Armchairs{
+    public static void main(String[] args) {
+        FastReader fr = new FastReader();
+        PrintWriter out = new PrintWriter(System.out);
+        Scanner sc= new Scanner (System.in);
+        
+        //Code From Here----
+        int t =fr.nextInt();
+        ArrayList <Integer> chairs= new ArrayList<>();
+        ArrayList <Integer> free= new ArrayList<>();
+
+        for (int i = 0; i < t; i++) {
+            int state =fr.nextInt();
+            if(state==1)
+            {
+                chairs.add(i);
+            }
+            else{
+                free.add(i);
+            }
+        }
+        int [][] dp=new int [t][t];
+        for (int[] is : dp) {
+            Arrays.fill(is, -1);
+        }
+        int ans=solve(chairs,free,0,0,chairs.size(),dp);
+        out.println(ans);
+        
+    
+        out.flush();
+        sc.close();
+    }
+
+    //This RadixSort() is for long method
+
+   
+
+    private static int solve(ArrayList<Integer> chairs, ArrayList<Integer> free, int i, int j, int size,int [][] dp) {
+        if (dp[i][j]!=-1) {
+            return dp[i][j];
+        }
+        if (size==0) {
+            return 0;
+        }
+        if (j==free.size()) {
+            return 10000000;
+        }
+        int a=solve(chairs, free, i, j+1, size,dp);
+        int b=Math.abs(chairs.get(i)-free.get(j))+solve(chairs, free, i+1, j+1, size-1,dp);
+        dp[i][j]=Math.min(a, b);
+        return dp[i][j];
+    }
+
+    public static long[] radixSort(long[] f){ return radixSort(f, f.length); }
+	public static long[] radixSort(long[] f, int n)
+	{
+		long[] to = new long[n];
+		{
+			int[] b = new int[65537];
+			for(int i = 0;i < n;i++)b[1+(int)(f[i]&0xffff)]++;
+			for(int i = 1;i <= 65536;i++)b[i]+=b[i-1];
+			for(int i = 0;i < n;i++)to[b[(int)(f[i]&0xffff)]++] = f[i];
+			long[] d = f; f = to;to = d;
+		}
+		{
+			int[] b = new int[65537];
+			for(int i = 0;i < n;i++)b[1+(int)(f[i]>>>16&0xffff)]++;
+			for(int i = 1;i <= 65536;i++)b[i]+=b[i-1];
+			for(int i = 0;i < n;i++)to[b[(int)(f[i]>>>16&0xffff)]++] = f[i];
+			long[] d = f; f = to;to = d;
+		}
+		{
+			int[] b = new int[65537];
+			for(int i = 0;i < n;i++)b[1+(int)(f[i]>>>32&0xffff)]++;
+			for(int i = 1;i <= 65536;i++)b[i]+=b[i-1];
+			for(int i = 0;i < n;i++)to[b[(int)(f[i]>>>32&0xffff)]++] = f[i];
+			long[] d = f; f = to;to = d;
+		}
+		{
+			int[] b = new int[65537];
+			for(int i = 0;i < n;i++)b[1+(int)(f[i]>>>48&0xffff)]++;
+			for(int i = 1;i <= 65536;i++)b[i]+=b[i-1];
+			for(int i = 0;i < n;i++)to[b[(int)(f[i]>>>48&0xffff)]++] = f[i];
+			long[] d = f; f = to; to = d;
+		}
+		return f;
+	}
+
+	
+
+	public static int[] radixSort2(int[] a)
+	{
+		int n = a.length;
+		int[] c0 = new int[0x101];
+		int[] c1 = new int[0x101];
+		int[] c2 = new int[0x101];
+		int[] c3 = new int[0x101];
+		for(int v : a) {
+			c0[(v&0xff)+1]++;
+			c1[(v>>>8&0xff)+1]++;
+			c2[(v>>>16&0xff)+1]++;
+			c3[(v>>>24^0x80)+1]++;
+		}
+		for(int i = 0;i < 0xff;i++) {
+			c0[i+1] += c0[i];
+			c1[i+1] += c1[i];
+			c2[i+1] += c2[i];
+			c3[i+1] += c3[i];
+		}
+		int[] t = new int[n];
+		for(int v : a)t[c0[v&0xff]++] = v;
+		for(int v : t)a[c1[v>>>8&0xff]++] = v;
+		for(int v : a)t[c2[v>>>16&0xff]++] = v;
+		for(int v : t)a[c3[v>>>24^0x80]++] = v;
+		return a;
+	}
+
+
+	
+    static int lowerBound(long a[], long x) { // x is the target value or key
+        int l = -1, r = a.length;
+        while (l + 1 < r) {
+            int m = (l + r) >>> 1;
+            if (a[m] >= x) r = m;
+            else l = m;
+        }
+        return r;
+    }
+
+    static int upperBound(long a[], long x) {// x is the key or target value
+        int l = -1, r = a.length;
+        while (l + 1 < r) {
+            int m = (l + r) >>> 1L;
+            if (a[m] <= x) l = m;
+            else r = m;
+        }
+        return l + 1;
+    }
+
+    static int upperBound(long[] arr, int start, int end, long k) {
+        int N = end;
+        while (start < end) {
+            int mid = start + (end - start) / 2;
+            if (k >= arr[mid]) {
+                start = mid + 1;
+            } else {
+                end = mid;
+            }
+        }
+        if (start < N && arr[start] <= k) {
+            start++;
+        }
+        return start;
+    }
+
+    static long lowerBound(long[] arr, int start, int end, long k) {
+        int N = end;
+        while (start < end) {
+            int mid = start + (end - start) / 2;
+            if (k <= arr[mid]) {
+                end = mid;
+            } else {
+                start = mid + 1;
+            }
+        }
+        if (start < N && arr[start] < k) {
+            start++;
+        }
+        return start;
+    }
+
+
+	// For Fast Input  ----
+    
+    
+	static class FastReader {
+		BufferedReader br;
+		StringTokenizer st;
+
+		public FastReader()
+		{
+			br = new BufferedReader(
+				new InputStreamReader(System.in));
+		}
+
+		String next()
+		{
+			while (st == null || !st.hasMoreElements()) {
+				try {
+					st = new StringTokenizer(br.readLine());
+				}
+				catch (IOException e) {
+					e.printStackTrace();
+				}
+			}
+			return st.nextToken();
+		}
+
+		int nextInt() { return Integer.parseInt(next()); }
+
+		long nextLong() { return Long.parseLong(next()); }
+
+		double nextDouble()
+		{
+			return Double.parseDouble(next());
+		}
+
+		String nextLine()
+		{
+			String str = """";
+			try {
+				str = br.readLine();
+			}
+			catch (IOException e) {
+				e.printStackTrace();
+			}
+			return str;
+		}
+	}
+
+
+
+    
+}
+","
+import java.io.DataInputStream;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+
+public class Armchairs {
+    static  ArrayList<Integer> f;
+    static ArrayList<Integer> u;
+    static int dp[][];
+    static int fun(int i, int j){
+        if(i == f.size()) return 0;
+        if(j == u.size()) return 99999999;
+        if(dp[i][j] != -1) return dp[i][j];
+        int ans1 = fun(i, j+1);
+        int ans2 = fun(i+1, j+1) + Math.abs(f.get(i)-u.get(j));
+        return dp[i][j] = Math.min(ans1, ans2);
+    }
+    private static int solve(int n, int a[]) {
+        for (int i = 0; i < n; i++) {
+            if (a[i]==0)
+                u.add(i);
+            else
+                f.add(i);
+        }
+
+        return fun(0,0);
+    }
+
+    public static void main(String[] args)
+            throws IOException {
+        Scanner s = new Scanner();
+        int t = 1;
+        StringBuilder ans = new StringBuilder();
+        int count = 0;
+        while (t-- > 0) {
+            int n = s.nextInt();
+            int a[] = new int[n];
+            dp=new int[n][n];
+            for (int i = 0; i < n; i++) {
+                a[i]=s.nextInt();
+            }
+            f=new ArrayList<>();
+            u=new ArrayList<>();
+            for( int i=0; i<n; i++) Arrays.fill(dp[i],-1);
+
+            ans.append(solve(n, a)).append(""\n"");
+        }
+        System.out.println(ans.toString());
+    }
+
+    static class Scanner {
+        final private int BUFFER_SIZE = 1 << 16;
+        private DataInputStream din;
+        private byte[] buffer;
+        private int bufferPointer, bytesRead;
+
+        public Scanner() {
+            din = new DataInputStream(System.in);
+            buffer = new byte[BUFFER_SIZE];
+            bufferPointer = bytesRead = 0;
+        }
+
+        public Scanner(String file_name) throws IOException {
+            din = new DataInputStream(
+                    new FileInputStream(file_name));
+            buffer = new byte[BUFFER_SIZE];
+            bufferPointer = bytesRead = 0;
+        }
+
+        public String readLine() throws IOException {
+            byte[] buf = new byte[64]; // line length
+            int cnt = 0, c;
+            while ((c = read()) != -1) {
+                if (c == '\n') {
+                    if (cnt != 0) {
+                        break;
+                    } else {
+                        continue;
+                    }
+                }
+                buf[cnt++] = (byte) c;
+            }
+            return new String(buf, 0, cnt);
+        }
+
+        public int nextInt() throws IOException {
+            int ret = 0;
+            byte c = read();
+            while (c <= ' ') {
+                c = read();
+            }
+            boolean neg = (c == '-');
+            if (neg)
+                c = read();
+            do {
+                ret = ret * 10 + c - '0';
+            } while ((c = read()) >= '0' && c <= '9');
+
+            if (neg)
+                return -ret;
+            return ret;
+        }
+
+        public long nextLong() throws IOException {
+            long ret = 0;
+            byte c = read();
+            while (c <= ' ')
+                c = read();
+            boolean neg = (c == '-');
+            if (neg)
+                c = read();
+            do {
+                ret = ret * 10 + c - '0';
+            } while ((c = read()) >= '0' && c <= '9');
+            if (neg)
+                return -ret;
+            return ret;
+        }
+
+        public double nextDouble() throws IOException {
+            double ret = 0, div = 1;
+            byte c = read();
+            while (c <= ' ')
+                c = read();
+            boolean neg = (c == '-');
+            if (neg)
+                c = read();
+
+            do {
+                ret = ret * 10 + c - '0';
+            } while ((c = read()) >= '0' && c <= '9');
+
+            if (c == '.') {
+                while ((c = read()) >= '0' && c <= '9') {
+                    ret += (c - '0') / (div *= 10);
+                }
+            }
+
+            if (neg)
+                return -ret;
+            return ret;
+        }
+
+        private void fillBuffer() throws IOException {
+            bytesRead = din.read(buffer, bufferPointer = 0,
+                    BUFFER_SIZE);
+            if (bytesRead == -1)
+                buffer[0] = -1;
+        }
+
+        private byte read() throws IOException {
+            if (bufferPointer == bytesRead)
+                fillBuffer();
+            return buffer[bufferPointer++];
+        }
+
+        public void close() throws IOException {
+            if (din == null)
+                return;
+            din.close();
+        }
+    }
+
+    public static long norm(long a, long MOD) {
+        return ((a % MOD) + MOD) % MOD;
+    }
+
+    public static long msub(long a, long b, long MOD) {
+        return norm(norm(a, MOD) - norm(b, MOD), MOD);
+
+    }
+
+    public static long madd(long a, long b, long MOD) {
+        return norm(norm(a, MOD) + norm(b, MOD), MOD);
+
+    }
+
+    public static long mMul(long a, long b, long MOD) {
+        return norm(norm(a, MOD) * norm(b, MOD), MOD);
+
+
+    }
+
+    public static long mDiv(long a, long b, long MOD) {
+        return norm(norm(a, MOD) / norm(b, MOD), MOD);
+    }
+}
+",0
+bf0df1d5,ea899386,"import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.util.*;
+import java.io.IOException;
+
+public class C_Phoenix_and_Towers {
+    public static class FastReader {
+        BufferedReader br;
+        StringTokenizer st;
+
+        public FastReader() {
+            br = new BufferedReader(new InputStreamReader(System.in));
+        }
+
+        String next() {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+
+        String nextLine() {
+            String str = """";
+            try {
+                str = br.readLine();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+        }
+    }
+
+    public static class Pair implements Comparable<Pair> {
+        int id, h;
+
+        public Pair(int id, int h) {
+            this.id = id;
+            this.h = h;
+        }
+
+        public int compareTo(Pair o) {
+            return this.h - o.h;
+        }
+    }
+
+    public static void main(String[] args) throws java.lang.Exception {
+        FastReader sc = new FastReader();
+        int t = sc.nextInt();
+
+        while (t-- > 0) {
+            int n = sc.nextInt();
+            int m = sc.nextInt();
+            int x = sc.nextInt();
+            int tow[] = new int[n];
+            int ans[] = new int[n];
+            PriorityQueue<Pair> pq = new PriorityQueue<>();
+            for (int i = 0; i < n; i++) {
+                tow[i] = sc.nextInt();
+            }
+            for (int i = 0; i < m; i++) {
+                ans[i] = i + 1;
+                pq.add(new Pair(i + 1, tow[i]));
+            }
+            for (int i = m; i < n; i++) {
+                Pair p = pq.poll();
+                p.h = p.h + tow[i];
+                ans[i] = p.id;
+                pq.add(p);
+            }
+            System.out.println(""YES"");
+            for (int i = 0; i < n; i++) {
+                System.out.print(ans[i] + "" "");
+            }
+            System.out.println();
+        }
+    }
+}","import java.io.*;
+import java.util.*;
+ 
+public class Codeforces {
+	public static class Tower implements Comparable<Tower>{
+		int val;
+		int index;
+		public Tower(int ind, int v) {
+			val = v;
+			index = ind;
+		}
+		@Override
+		public int compareTo(Tower o) {
+			return Integer.compare(val, o.val);
+		}
+	}
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		int cases = Integer.parseInt(br.readLine());
+		while(cases-- > 0) {
+			String[] str = br.readLine().split("" "");
+			int n = Integer.parseInt(str[0]);
+			int m = Integer.parseInt(str[1]);
+			int x = Integer.parseInt(str[2]);
+			int[] h = new int[n];
+			str = br.readLine().split("" "");
+			for(int i=0; i<n; i++) {
+				h[i] = Integer.parseInt(str[i]);
+			}
+			PriorityQueue<Tower> q = new PriorityQueue<>(m);
+			int[] ans = new int[n];
+			for(int i=0; i<m; i++) {
+				q.add(new Tower(i, h[i]));
+				ans[i] = i;
+			}
+			for(int i=m; i<n; i++) {
+				Tower lowest = q.poll();
+				lowest.val += h[i];
+				ans[i] = lowest.index;
+				q.add(lowest);
+			}
+			System.out.println(""YES"");
+			for(int i=0; i<n; i++) {
+				System.out.print((ans[i]+1) + "" "");
+			}
+			System.out.println();
+		}
+	}
+}
+",1
+b2001d68,ba468e1f,"
+/*
+                                      بسم الله الرحمن الرحيم
+ 
+    /$$$$$  /$$$$$$  /$$    /$$  /$$$$$$                                                                  
+   |__  $$ /$$__  $$ |$$    |$$ /$$__  $$                                                                 
+          | $$| $$  \ $$|    $$|$$| $$  \ $$                                                                 
+          | $$| $$$$$$$$|  $$ / $$/| $$$$$$$$                                                                 
+/ $$  | $$| $$__  $$ \  $$ $$/ | $$__  $$                                                                 
+| $$  | $$| $$  | $$  \  $$$/  | $$  | $$                                                                 
+|  $$$$$$/| $$  | $$   \  $/   | $$  | $$                                                                 
+ \______/ |__/  |__/    \_/    |__/  |__/    
+ 
+/$$$$$$$  /$$$$$$$   /$$$$$$   /$$$$$$  /$$$$$$$   /$$$$$$  /$$      /$$ /$$      /$$ /$$$$$$$$ /$$$$$$$ 
+| $$__  $$| $$__  $$ /$$__  $$ /$$__  $$| $$__  $$ /$$__  $$| $$$    /$$$| $$$    /$$$| $$_____/| $$__  $$
+| $$  \ $$| $$  \ $$| $$  \ $$| $$  \__/| $$  \ $$| $$  \ $$| $$$$  /$$$$| $$$$  /$$$$| $$      | $$  \ $$
+| $$$$$$$/| $$$$$$$/| $$  | $$| $$ /$$$$| $$$$$$$/| $$$$$$$$| $$ $$/$$ $$| $$ $$/$$ $$| $$$$$   | $$$$$$$/
+| $$____/ | $$__  $$| $$  | $$| $$|_  $$| $$__  $$| $$__  $$| $$  $$$| $$| $$  $$$| $$| $$__/   | $$__  $$
+| $$      | $$  \ $$| $$  | $$| $$  \ $$| $$  \ $$| $$  | $$| $$\  $ | $$| $$\  $ | $$| $$      | $$  \ $$
+| $$      | $$  | $$|  $$$$$$/|  $$$$$$/| $$  | $$| $$  | $$| $$ \/  | $$| $$ \/  | $$| $$$$$$$$| $$  | $$
+|__/      |__/  |__/ \______/  \______/ |__/  |__/|__/  |__/|__/     |__/|__/     |__/|________/|__/  |__/
+                                                                                                                                                                                                                
+                                                                                                                                                                                                                
+ 
+*/
+
+import java.util.*;
+import java.lang.*;
+import java.io.*;
+
+public class D753 {
+    public static void main(String[] args) throws java.lang.Exception {
+        // your code goes here
+        try {
+            // Scanner sc=new Scanner(System.in);
+            FastReader sc = new FastReader();
+            int t = sc.nextInt();
+            while (t-- > 0) {
+                int n=sc.nextInt();
+                int[] arr=new int[n];
+                for(int i=0;i<n;i++){
+                    arr[i]=sc.nextInt();
+                }
+                
+                char[] color=sc.next().toCharArray();
+                ArrayList<Integer> b=new ArrayList<>();
+                ArrayList<Integer> r=new ArrayList<>();
+                for(int i=0;i<n;i++){
+                    if(color[i]=='B')b.add(arr[i]);
+                    else r.add(arr[i]);
+                }
+                Collections.sort(b);
+                Collections.sort(r);
+                boolean ok=true;
+                int cur=1;
+                for(int i:b){
+                    if(i>=cur)cur++;
+                    else{
+                        ok=false;
+                        break;
+                    }
+                    //cur++;
+                }
+                for(int i:r){
+                    if(i<=cur)cur++;
+                    else{
+                        ok=false;
+                        break;
+                    }
+                }
+                if(ok)System.out.println(""YES"");
+                else System.out.println(""NO"");
+            }
+        } catch (Exception e) {
+            return;
+        }
+
+    }
+    public static int lowerbound(long[] ar,int k)
+{
+    int s=0;
+    int e=ar.length;
+    while (s !=e)
+    {
+        int mid = s+e>>1;
+        if (ar[mid] <k)
+        {
+            s=mid+1;
+        }
+        else
+        {
+            e=mid;
+        }
+    }
+    if(s==ar.length)
+    {
+        return -1;
+    }
+    return s;
+}
+
+    public static class pair {
+        int ff;
+        char ss;
+
+        pair(int ff, char ss) {
+            this.ff = ff;
+            this.ss = ss;
+        }
+    }
+
+    static int BS(int[] arr, int l, int r, int element) {
+        int low = l;
+        int high = r;
+        while (high - low > 1) {
+            int mid = low + (high - low) / 2;
+            if (arr[mid] < element) {
+                low = mid + 1;
+            } else {
+                high = mid;
+            }
+        }
+        if (arr[low] == element) {
+            return low;
+        } else if (arr[high] == element) {
+            return high;
+        }
+        return -1;
+    }
+
+    static int lower_bound(int[] arr, int l, int r, int element) {
+        int low = l;
+        int high = r;
+        while (high - low > 1) {
+            int mid = low + (high - low) / 2;
+            if (arr[mid] < element) {
+                low = mid + 1;
+            } else {
+                high = mid;
+            }
+        }
+        if (arr[low] >= element) {
+            return low;
+        } else if (arr[high] >= element) {
+            return high;
+        }
+        return -1;
+    }
+
+    static int upper_bound(int[] arr, int l, int r, int element) {
+        int low = l;
+        int high = r;
+        while (high - low > 1) {
+            int mid = low + (high - low) / 2;
+            if (arr[mid] <= element) {
+                low = mid + 1;
+            } else {
+                high = mid;
+            }
+        }
+        if (arr[low] > element) {
+            return low;
+        } else if (arr[high] > element) {
+            return high;
+        }
+        return -1;
+    }
+
+    public static int upperbound(long[] arr, int k) {
+        int s = 0;
+        int e = arr.length;
+        while (s != e) {
+            int mid = s + e >> 1;
+            if (arr[mid] <= k) {
+                s = mid + 1;
+            } else {
+                e = mid;
+            }
+        }
+        if (s == arr.length) {
+            return -1;
+        }
+        return s;
+    }
+    public static long pow(long x,long y,long mod){
+        if(x==0)return 0l;
+        if(y==0)return 1l;
+        //(x^y)%mod
+        if(y%2l==1l){
+            return ((x%mod)*(pow(x,y-1l,mod)%mod))%mod;
+        }
+        return pow(((x%mod)*(x%mod))%mod,y/2l,mod);
+    }
+
+    public static long gcd_long(long a, long b) {
+        // a/b,a-> dividant b-> divisor
+        if (b == 0)
+            return a;
+        return gcd_long(b, a % b);
+    }
+
+    public static int gcd_int(int a, int b) {
+        // a/b,a-> dividant b-> divisor
+        if (b == 0)
+            return a;
+        return gcd_int(b, a % b);
+    }
+
+    public static int lcm(int a, int b) {
+        int gcd = gcd_int(a, b);
+        return (a * b) / gcd;
+    }
+
+    static class FastReader {
+        BufferedReader br;
+        StringTokenizer st;
+
+        public FastReader() {
+            br = new BufferedReader(new InputStreamReader(System.in));
+        }
+
+        String next() {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        String nextLine() {
+            String s = """";
+            try {
+                s = br.readLine();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            return s;
+        }
+
+        Long nextLong() {
+            return Long.parseLong(next());
+        }
+    }
+}
+
+/*
+ * public static boolean lie(int n,int m,int k){ if(n==1 && m==1 && k==0){
+ * return true; } if(n<1 || m<1 || k<0){ return false; } boolean
+ * tc=lie(n-1,m,k-m); boolean lc=lie(n,m-1,k-n); if(tc || lc){ return true; }
+ * return false; }
+ */
+","import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.*;
+
+public class Codeforces {
+    public static void main(String[] args) {
+        FastReader fastReader = new FastReader();
+        int t = fastReader.nextInt();
+        while (t-- > 0) {
+            int n = fastReader.nextInt();
+
+            int a[] = new int[n];
+            for (int i = 0; i < n; i++) {
+                a[i] = fastReader.nextInt();
+            }
+            ArrayList<Integer> b = new ArrayList<>();
+            ArrayList<Integer> r = new ArrayList<>();
+            char c[] = fastReader.next().toCharArray();
+            for (int i = 0; i < n; i++) {
+                if (c[i] == 'B') {
+                    b.add(a[i]);
+                } else {
+                    r.add(a[i]);
+                }
+            }
+
+            Collections.sort(b);
+            Collections.sort(r);
+            int sizeb = b.size();
+
+            boolean isValid = true;
+            for (int i = 1 , j = 0; i <=sizeb; i++ , j++){
+                if (b.get(j) <  i){
+                    isValid =false;
+                }
+            }
+
+            for (int i = sizeb+1 , j = 0; i <=n && j < r.size(); i++ , j++){
+                if (r.get(j) >  i){
+                    isValid =false;
+                }
+            }
+
+            if (isValid){
+                System.out.println(""YES"");
+            }else{
+                System.out.println(""NO"");
+            }
+        }
+
+
+    }
+
+    static class FastReader {
+
+
+        BufferedReader br;
+        StringTokenizer st;
+
+        public FastReader() {
+            br = new BufferedReader(
+                    new InputStreamReader(System.in));
+        }
+
+        String next() {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+
+        String nextLine() {
+            String str = """";
+            try {
+                str = br.readLine();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+        }
+    }
+}
+",0
+35eb27da,64ce7b1e,"/* package codechef; // don't place package name! */
+
+import java.util.*;
+import java.lang.*;
+import java.io.*;
+
+/* Name of the class has to be ""Main"" only if the class is public. */
+public class Codechef
+{
+	public static void main (String[] args) throws java.lang.Exception
+	{
+		Scanner sc = new Scanner(System.in);
+		int t = sc.nextInt();
+		while(t-- > 0)
+		{
+		    int n = sc.nextInt();
+		    sc.nextLine();
+		    int a[][] = new int[26][26];
+		    int b[][][] = new int[26][26][26];
+		    
+		    boolean bl = false;
+		    String arr[] = new String[n];
+		    for(int i = 0 ; i < n ; i++)
+		    {
+		        arr[i] = sc.nextLine();
+		        
+		        if(arr[i].length() == 1)
+		        {
+		            bl = true;
+		        }
+		        
+		        else if(arr[i].length() == 2)
+		        {
+		            //a[arr[i].charAt(0)-'a'][arr[i].charAt(1)-'a'] = 1;
+		            if(arr[i].charAt(0)==arr[i].charAt(1))
+		            bl = true;
+		        }
+		        
+		        else
+		        {
+		           //b[arr[i].charAt(0)-'a'][arr[i].charAt(1)-'a'][arr[i].charAt(2)-'a'] = 1; 
+		           if(arr[i].charAt(0) == arr[i].charAt(2))
+		           bl = true;
+		        }
+		    }
+		    
+		    if(bl)
+		    System.out.println(""YES"");
+		    
+		    else
+		    {
+		        for(int i = 0; i < n ; i++)
+		        {
+		            if(arr[i].length() == 2)
+		            {
+		                int p1 = arr[i].charAt(0)-'a';
+		                int p2 = arr[i].charAt(1)-'a';
+		                
+		                if(a[p2][p1] == 1)
+		                bl = true;
+		                
+		                for(int j = 0;  j < 26 ; j++)
+		                {
+		                    if(b[p2][p1][j] == 1)
+		                    bl = true;
+		                }
+		                a[p1][p2] = 1;
+		            }
+		            
+		            else
+		            {
+		                 int p1 = arr[i].charAt(0)-'a';
+		                int p2 = arr[i].charAt(1)-'a';
+		                int p3 = arr[i].charAt(2)-'a';
+		                
+		                if(a[p3][p2] == 1)
+		                bl = true;
+		                
+		                if(b[p3][p2][p1] == 1)
+		                bl = true;
+		                
+		                b[p1][p2][p3] = 1;
+		            }
+		        }
+		        if(bl)
+		        System.out.println(""YES"");
+		        
+		        else
+		        System.out.println(""NO"");
+		    }
+		}
+	}
+}","import java.io.*;
+import java.util.*;
+public class new1{
+	
+    static int gcd(int a, int b)
+    {
+      if (b == 0)
+        return a;
+      return gcd(b, a % b);
+    }
+    
+
+	public static void main(String[] args)  throws IOException{
+
+		BufferedWriter output = new BufferedWriter(new OutputStreamWriter(System.out));
+		FastReader s = new FastReader();
+		int t = s.nextInt();
+		for(int z = 0; z < t; z++) {
+			int n = s.nextInt();
+			Set<String> st = new HashSet<String>();
+			String[] arr = new String[n];
+			boolean pos = false;
+			for(int i = 0; i < n; i++) {
+				String str = s.next();
+				st.add(str); arr[i] = str;
+				if(str.length() == 1) pos = true;
+			}
+			if(pos) {
+				System.out.println(""YES"");
+				continue;
+			}
+			for(int i = 0; i < n; i++) {
+				String str = arr[i];
+				st.remove(str);
+				if(str.charAt(0) == str.charAt(str.length() - 1)) pos = true;
+				if(str.length() == 3) {
+					String str1 = Character.toString(str.charAt(1)) + Character.toString(str.charAt(0));
+					if(st.contains(str1)) pos = true;
+					String str2 = Character.toString(str.charAt(2)) + str1;
+					if(st.contains(str2)) pos = true;
+				}
+				else {
+					String str1 = Character.toString(str.charAt(1)) + Character.toString(str.charAt(0));
+					if(st.contains(str1)) pos = true;;
+					for(int j = 0; j < 26; j++) {
+						char ch = (char) ((int)'a' + j);
+						String str2 = Character.toString(ch) + str1;
+						if(st.contains(str2)) pos = true;;
+					}
+					
+					
+				}
+			}
+			//System.out.println(st.toString());
+			if(pos) System.out.println(""YES"");
+			else System.out.println(""NO"");
+			//System.out.println(st.contains(""ba""));
+		}
+			
+	  }
+}
+
+
+ 
+	class FastReader {
+	    BufferedReader br;
+	    StringTokenizer st;
+	    public FastReader() {
+	        br = new BufferedReader(new InputStreamReader(System.in));
+	    }
+	    String next() {
+	        while (st == null || !st.hasMoreElements()) {
+	            try {
+	                st = new StringTokenizer(br.readLine());
+	            } catch (IOException e) {
+	                e.printStackTrace();
+	            }
+	        }
+	        return st.nextToken();
+	    }
+	 
+	    public int nextInt() {
+	        return Integer.parseInt(next());
+	    }
+	 
+	    long nextLong() {
+	        return Long.parseLong(next());
+	    }
+	 
+	    double nextDouble() {
+	        return Double.parseDouble(next());
+	    }
+	 
+	    String nextLine() {
+	        String str = """";
+	        try {
+	            str = br.readLine();
+	        } catch (IOException e) {
+	            e.printStackTrace();
+	        }
+	        return str;
+	}}",0
+5aebbb1b,e647bef7,"import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.Arrays;
+import java.util.LinkedList;
+import java.util.Queue;
+import java.util.StringTokenizer;
+
+public class Learning {
+    static LinkedList<Integer>[] adj;
+
+    public static void main(String[] args) throws Exception {
+        FastInput in = new FastInput();
+        StringBuilder sb = new StringBuilder();
+        int t = in.nextInt();
+        while (t-- > 0) {
+            int n = in.nextInt();
+            int a = in.nextInt() - 1;
+            int b = in.nextInt() - 1;
+            int da = in.nextInt();
+            int db = in.nextInt();
+            adj = new LinkedList[n];
+            for (int i = 0; i < n; i++) {
+                adj[i] = new LinkedList<>();
+            }
+            for (int i = 0; i < n - 1; i++) {
+                int u = in.nextInt() - 1;
+                int v = in.nextInt() - 1;
+                adj[u].add(v);
+                adj[v].add(u);
+            }
+            boolean f = solve(n, a, b, da, db);
+            if (f) {
+                sb.append(""Bob"");
+            } else {
+                sb.append(""Alice"");
+
+            }
+            sb.append(""\n"");
+        }
+        System.out.println(sb.toString());
+    }
+
+    private static boolean solve(int n, int a, int b, int da, int db) {
+        if (db <= da * 2) {
+            return false;
+        }
+        Queue<Integer> que = new LinkedList<>();
+        que.add(a);
+        int[] dist = new int[n];
+        Arrays.fill(dist, -1);
+        dist[a] = 0;
+        while (!que.isEmpty()) {
+            int t = que.poll();
+            for (int i : adj[t]) {
+                if (dist[i] == -1) {
+                    que.add(i);
+                    dist[i] = dist[t] + 1;
+                }
+            }
+        }
+        if (dist[b] <= da) {
+            return false;
+        }
+        int maxPath = 0;
+        for (int i = 0; i < n; i++) {
+            maxPath = Math.max(maxPath, dfs(i, new boolean[n]));
+        }
+        if (2 * da >= maxPath-1) {
+            return false;
+        }
+        return true;
+    }
+
+    private static int dfs(int i, boolean[] vis) {
+        vis[i] = true;
+        int max = 0;
+        for (int v : adj[i]) {
+            if (!vis[v]) {
+                max = Math.max(dfs(v, vis), max);
+            }
+        }
+        return max + 1;
+    }
+
+    static long calculate(int[] arr, int x) {
+        long val = 0L;
+        long p = 1;
+        for (int value : arr) {
+
+            val += Math.abs(value - p);
+            p *= x;
+        }
+        return val;
+    }
+}
+
+
+class FastInput {
+    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+    StringTokenizer st;
+
+    String next() throws IOException {
+        if (st == null || !st.hasMoreTokens())
+            st = new StringTokenizer(br.readLine());
+        return st.nextToken();
+    }
+
+    Integer nextInt() throws IOException {
+        return Integer.parseInt(next());
+    }
+
+    Long nextLong() throws IOException {
+        return Long.parseLong(next());
+    }
+}","
+import java.io.*;
+import java.util.*;
+
+public class Main {
+    private static final boolean N_CASE = true;
+    private List<List<Integer>> g;
+    private int a;
+    private int b;
+    private int da;
+    private int db;
+    private int max;
+    private int ab;
+
+    private int dfs(int u, int fa, int depth) {
+        if (u == a) {
+            ab = depth;
+        }
+
+        int m1 = 0, m2 = 0;
+        for (int v : g.get(u)) {
+            if (v != fa) {
+                int m = dfs(v, u, depth + 1) + 1;
+                if (m > m1) { m2 = m1; m1 = m; }
+                else if (m > m2) { m2 = m; }
+            }
+        }
+        max = Math.max(max, m1 + m2);
+        int cmax = Math.max(m1, m2);
+        max = Math.max(max, cmax + depth);
+        return cmax;
+    }
+
+    private void solve() {
+        int n = sc.nextInt();
+        a = sc.nextInt() - 1; b = sc.nextInt() - 1;
+        da = sc.nextInt(); db = sc.nextInt();
+
+        g = createGraph(n);
+        for (int i = 0; i < n - 1; ++i) {
+            int u = sc.nextInt() - 1, v = sc.nextInt() - 1;
+            g.get(u).add(v);
+            g.get(v).add(u);
+        }
+        max = 0;
+        dfs(b, -1, 0);
+        db = Math.min(max, db);
+
+        boolean win = true;
+        if (ab > da) {
+            if (db > da * 2) {
+                win = false;
+            }
+        }
+
+        out.println(win ? ""Alice"" : ""Bob"");
+    }
+
+    private void run() {
+        int T = N_CASE ? sc.nextInt() : 1;
+        for (int t = 0; t < T; ++t) {
+            solve();
+        }
+    }
+
+    private static MyWriter out;
+    private static MyScanner sc;
+
+    private static class MyScanner {
+        BufferedReader br;
+        StringTokenizer st;
+
+        private MyScanner() {
+            br = new BufferedReader(new InputStreamReader(System.in));
+        }
+
+        String next() {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+
+        int[] nextIntArray(int n) {
+            int[] a = new int[n];
+            for (int i = 0; i < n; i++) {
+                a[i] = nextInt();
+            }
+            return a;
+        }
+
+        int[][] nextIntArray(int n, int m) {
+            int[][] a = new int[n][m];
+            for (int i = 0; i < n; i++) {
+                for (int j = 0; j < m; j++) {
+                    a[i][j] = sc.nextInt();
+                }
+            }
+            return a;
+        }
+
+        long[] nextLongArray(int n) {
+            long[] a = new long[n];
+            for (int i = 0; i < n; i++) {
+                a[i] = nextLong();
+            }
+            return a;
+        }
+
+        long[][] nextLongArray(int n, int m) {
+            long[][] a = new long[n][m];
+            for (int i = 0; i < n; i++) {
+                for (int j = 0; j < m; j++) {
+                    a[i][j] = nextLong();
+                }
+            }
+            return a;
+        }
+
+        List<Integer> nextList(int n) {
+            List<Integer> list = new ArrayList<>();
+            for (int i = 0; i < n; i++) {
+                list.add(nextInt());
+            }
+            return list;
+        }
+
+        List<Long> nextLongList(int n) {
+            List<Long> list = new ArrayList<>();
+            for (int i = 0; i < n; i++) {
+                list.add(nextLong());
+            }
+            return list;
+        }
+
+        char[] nextCharArray(int n) {
+            return sc.next().toCharArray();
+        }
+
+        char[][] nextCharArray(int n, int m) {
+            char[][] c = new char[n][m];
+            for (int i = 0; i < n; i++) {
+                String s = sc.next();
+                for (int j = 0; j < m; j++) {
+                    c[i][j] = s.charAt(j);
+                }
+            }
+            return c;
+        }
+    }
+
+    private static class MyWriter extends PrintWriter {
+        private MyWriter(OutputStream outputStream) {
+            super(outputStream);
+        }
+
+        void printArray(int[] a) {
+            for (int i = 0; i < a.length; ++i) {
+                print(a[i]);
+                print(i == a.length - 1 ? '\n' : ' ');
+            }
+        }
+
+        void printArray(long[] a) {
+            for (int i = 0; i < a.length; ++i) {
+                print(a[i]);
+                print(i == a.length - 1 ? '\n' : ' ');
+            }
+        }
+
+        void println(int[] a) {
+            for (int v : a) {
+                println(v);
+            }
+        }
+
+        void print(List<Integer> list) {
+            for (int i = 0; i < list.size(); ++i) {
+                print(list.get(i));
+                print(i == list.size() - 1 ? '\n' : ' ');
+            }
+        }
+
+        void println(List<Integer> list) {
+            list.forEach(this::println);
+        }
+    }
+
+    private <T> List<List<T>> createGraph(int n) {
+        List<List<T>> g = new ArrayList<>();
+        for (int i = 0; i < n; ++i) {
+            g.add(new ArrayList<>());
+        }
+        return g;
+    }
+
+    private void fill(int[][] a, int value) {
+        for (int[] row : a) {
+            fill(row, value);
+        }
+    }
+
+    private void fill(int[] a, int value) {
+        Arrays.fill(a, value);
+    }
+
+    public static void main(String[] args) {
+        out = new MyWriter(new BufferedOutputStream(System.out));
+        sc = new MyScanner();
+        new Main().run();
+        out.close();
+    }
+}",0
+30e0cc81,b55888de,"import java.io.*;
+import java.util.*;
+import java.math.BigInteger; 
+import java.lang.*;
+
+
+
+
+public class Main {
+    
+    static class sortLong implements Comparator<long[]>{
+        public int compare(long[] a,long[] b){
+          if(a[0] > b[0]) return 1;return -1;
+        }
+    }
+    static class sortInt implements Comparator<int[]>{
+        public int compare(int[] a,int[] b){
+          if(a[1] > b[1]) return 1;return -1;
+        }
+    }
+    
+   public static String[] F(BufferedReader bf) throws Exception
+    {
+        return (bf.readLine().split("" ""));
+    }
+    
+   public static void pr(PrintWriter out,Object o)
+   {
+      
+    out.println(o.toString());//out.flush();
+    
+   }
+   public static void prW(PrintWriter out,Object o)
+   {
+      
+    out.print(o.toString());//out.flush();
+    
+   }
+   public static int intIn(String st)
+   {
+      return Integer.parseInt(st);
+   }
+   
+   
+    
+    public static void pr(Object o)
+    {
+        System.out.println(o.toString());
+    }
+    public static void prW(Object o)
+    {
+        System.out.print(o.toString());
+    }
+    
+   
+    public static int inInt(String s)
+    {
+        return Integer.parseInt(s);
+    }
+    public static long in(String s)
+    {
+        return Long.parseLong(s);
+    }
+ 
+ 
+    static int[] toIntArray(String[] m) 
+    { 
+        int[] p=new int[m.length];
+        for(int o=0;o<m.length;o++)
+        {
+            p[o]= inInt(m[o]);
+        }
+        return p;
+    }
+    static double[] toDArray(String[] m) 
+    { 
+        double[] p=new double[m.length];
+        for(int o=0;o<m.length;o=0)
+        {
+            p[o]= Double.parseDouble(m[o]);
+        }
+        return p;
+    }
+    static long[] toLArray(String[] m) 
+    { 
+       long[] p=new long[m.length];
+        for(int o=0;o<m.length;o++)
+        {
+            p[o]= in(m[o]);
+        }
+        return p;
+    }
+   
+     static long gcd(long a, long b)
+        {
+          if (b == 0)
+            return a;
+          return gcd(b, a % b); 
+        }
+     
+        static long pow(long x, long y, long p)
+      {
+        if(y == 0) return 1l;
+        long res = 1; // Initialize result
+     
+        x = x % p; // Update x if it is more than or
+        // equal to p
+     
+        if (x == 0)
+          return 0l; // In case x is divisible by p;
+     
+        while (y > 0)
+        {
+     
+          // If y is odd, multiply x with result
+          if ((y & 1) != 0)
+            res = (res * x) % p;
+     
+          // y must be even now
+          y = y >> 1; // y = y/2
+          x = (x * x) % p;
+        }
+        return res;
+      }
+    
+   
+    
+
+   
+   
+
+   
+    static long __gcd(long n1, long n2)
+    {
+
+        if(n1==0l) return n2;
+        if(n2==0l) return n1;
+        if(n1==1l || n2==1l) return 1l;
+       // long gcd = 1;
+        if(n1 == n2)  return n1;
+        if(n1>n2) return __gcd(n1%n2,n2);
+        return __gcd(n1,n2%n1);
+        
+    }
+    
+   
+    public static int F(String[] arr,char ch){
+
+
+      int[] nums = new int[arr.length];
+
+      for(int i=0;i<arr.length;i++){
+        String str = arr[i];int a=0;
+        for(int j=0;j<str.length();j++){
+              if(str.charAt(j) == ch){
+                a++;
+              }
+        }
+        //int b = (str.length()/2);
+       // if((str.length()%2) != 0) b++;
+        nums[i] = (2*a - (str.length()));
+      }
+
+      Arrays.sort(nums);
+      int sum = 0;
+      
+   
+      for(int i=arr.length-1;i>=0;i--){
+        if((sum+nums[i]) <= 0){
+          return  arr.length-1-i;
+        }
+        sum += nums[i];
+      }
+
+      return arr.length;
+    }
+    public static void main (String[] args) throws Exception {
+        
+        BufferedReader bf=new BufferedReader(new InputStreamReader(System.in));
+        PrintWriter out = new PrintWriter(System.out);;;//
+        
+        //int[] map=new int[1000001];
+      
+       int yy=inInt(bf.readLine());
+       
+
+
+        
+
+        for(int w=0;w<yy;w++)
+        {
+             //String str = bf.readLine();
+          out.flush();
+         
+            String[] xlp = bf.readLine().split("" "");
+            
+            //String st = bf.readLine();
+      int n;//boolean bol=false;
+           //  m;//long a,b,c;
+           long k;long l;
+          // int l;
+           //int double avg  k;//pr(out,""vbc"");
+       // boolean bol = false;
+           //long mod=1000000000+7
+      n =inInt(xlp[0]);//int m = inInt(xlp[1]);//long b=in(xlp[3]);//long k=in(xlp[4]);
+      String[] arr = new String[n];
+
+      for(int i=0;i<n;i++){
+        arr[i] = bf.readLine();
+      }
+      int ans=0;
+      for(int i=0;i<5;i++){
+        int v = F(arr,(char)(i+'a'));
+       // pr(out,v+"" ""+i);
+        ans = Math.max(ans,F(arr,(char)(i+'a')));
+
+      }
+
+      pr(out,ans);
+      
+
+
+      
+
+   }
+    out.close();//
+   bf.close();//
+       
+}}
+
+
+/*
+
+
+Kickstart
+ String rp;
+            rp = ""Case #""+(w+1)+"": ""+(n-ans)+"" "";
+static int[][] dir={{0,1},{1,0},{-1,0},{0,-1}};
+
+static class SegmentTreeRMQ 
+    { 
+    int st[]; 
+    int minVal(int x, int y) { 
+        return (x > y) ? x : y; 
+    } 
+  
+    
+    int getMid(int s, int e) { 
+        return s + (e - s) / 2; 
+    } 
+  
+    
+    int RMQUtil(int ss, int se, int qs, int qe, int index) 
+    { 
+        
+        if (qs <= ss && qe >= se) 
+            return st[index]; 
+  
+        // If segment of this node is outside the given range 
+        if (se < qs || ss > qe) 
+            return Integer.MIN_VALUE; 
+  
+        // If a part of this segment overlaps with the given range 
+        int mid = getMid(ss, se); 
+        return minVal(RMQUtil(ss, mid, qs, qe, 2 * index + 1), 
+                RMQUtil(mid + 1, se, qs, qe, 2 * index + 2)); 
+    } 
+  
+    // Return minimum of elements in range from index qs (query 
+    // start) to qe (query end).  It mainly uses RMQUtil() 
+    int RMQ(int n, int qs, int qe) 
+    { 
+        // Check for erroneous input values 
+        
+  
+        return RMQUtil(0, n - 1, qs, qe, 0); 
+    } 
+  
+    // A recursive function that constructs Segment Tree for 
+    // array[ss..se]. si is index of current node in segment tree st 
+    int constructSTUtil(int arr[], int ss, int se, int si) 
+    { 
+        // If there is one element in array, store it in current 
+        //  node of segment tree and return 
+        if (ss == se) { 
+            st[si] = arr[ss]; 
+            return arr[ss]; 
+        } 
+  
+        // If there are more than one elements, then recur for left and 
+        // right subtrees and store the minimum of two values in this node 
+        int mid = getMid(ss, se); 
+        st[si] = minVal(constructSTUtil(arr, ss, mid, si * 2 + 1), 
+                constructSTUtil(arr, mid + 1, se, si * 2 + 2)); 
+        return st[si]; 
+    } 
+  
+    
+    void con(int arr[]) 
+    { 
+        // Allocate memory for segment tree 
+  
+        //Height of segment tree 
+        int n = (arr.length);
+        int x = (int) (Math.ceil(Math.log(n) / Math.log(2))); 
+  
+        //Maximum size of segment tree 
+        int max_size = 2 * (int) Math.pow(2, x) - 1; 
+        st = new int[max_size]; // allocate memory 
+  
+        // Fill the allocated memory st 
+        constructSTUtil(arr, 0, n - 1, 0); 
+    }
+    }
+     static class DSU {
+    
+    int[] p;int[] sz;int op;int c;;
+    int[] last;
+    public void G(int n)
+    {
+        last=new int[n];
+        p=new int[n];
+        sz=new int[n];c=n;
+        op=n;
+        for(int h=0;h<n;h++)
+        {
+            sz[h]=1;p[h]=h;
+            last[h]=h;
+        }
+    }
+    public int find(int x)
+    {
+        int y=x;
+        while(x!=p[x]) x=p[x];
+        while(y!=p[y])
+        {
+            int tem=p[y];
+            p[y]=x;y=tem;
+        }
+        return p[y];
+    }
+    public void union(int a,int b)
+    {
+        int x,y;
+        x=find(a);y=find(b);
+        if(x==y) return;
+        if(sz[x]>sz[y])
+        {
+            p[y] = x;
+            sz[x]+=sz[y];
+            last[x]=Math.max(last[x],last[y]);
+        }
+        else
+        {
+            p[x]=y;sz[y]+=sz[x];
+            last[y]=Math.max(last[y],last[x]);
+        }
+        c--;
+        
+    }}
+
+    static long pow(long x, long y, long p)
+      {
+        long res = 1; // Initialize result
+     
+        x = x % p; // Update x if it is more than or
+        // equal to p
+     
+        if (x == 0)
+          return 0l; // In case x is divisible by p;
+     
+        while (y > 0)
+        {
+     
+          // If y is odd, multiply x with result
+          if ((y & 1) != 0)
+            res = (res * x) % p;
+     
+          // y must be even now
+          y = y >> 1; // y = y/2
+          x = (x * x) % p;
+        }
+        return res;
+      }
+      static long gcd(long a, long b)
+        {
+          if (b == 0)
+            return a;
+          return gcd(b, a % b); 
+        }
+        static int gcd(int a, int b,int o)
+        {
+          if (b == 0)
+            return a;
+          return gcd(b, a % b,o); 
+        }
+
+Geometric median
+
+public static double F(double[] x,double[] w)
+    {
+        double d1,d2;
+        double S=0.00;
+        for(double dp : w) S += dp;
+        int k = 0;
+        double sum = S - w[0]; // sum is the total weight of all `x[i] > x[k]`
+
+        while(sum > S/2)
+        {
+            ++k;
+            sum -= w[k];
+        }
+        d1=x[k];
+        return d1;
+        k = w.length-1;
+       sum = S - w[k]; // sum is the total weight of all `x[i] > x[k]`
+
+        while(sum > S/2)
+        {
+            --k;
+            sum -= w[k];
+        }
+        d2=x[k];
+        return new double[]{d1,d2};
+    }
+*/","import java.lang.reflect.Array;
+import java.util.*;
+public class Rough {
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);   
+        int t = sc.nextInt();
+        while (t-->0) {
+            int n = sc.nextInt();
+            sc.nextLine();
+            String s[] = new String[n];
+            int f[][] = new int[n][5];
+            for (int i = 0; i < n; i++) {
+                s[i]  = sc.nextLine();
+
+                for (int j = 0; j < s[i].length(); j++) {
+                    f[i][s[i].charAt(j)-'a']++;
+                }
+            }
+
+            int ans = 0;
+            for ( int i = 0; i < 5; i++) {
+                ArrayList<Integer> al = new ArrayList<>();
+
+                for (int j = 0; j < n; j++) {
+                    int o = 0;
+                    for (int k = 0; k < 5; k++) {
+                        if(k != i)
+                            o+=f[j][k];
+                    }
+                    al.add(f[j][i]-o);
+                }
+
+                Collections.sort(al,Collections.reverseOrder());
+
+                int max = 0;
+                int x = 0;
+                for (int j = 0; j < n; j++) {
+                    x+=al.get(j);
+                    if(x<=0)break;
+                    max++;
+                }
+                ans = Math.max(max,ans);
+            }
+
+            System.out.println(ans);
+        }
+        sc.close();
+    }
+}",0
+05f939b3,e647bef7,"
+//package cf;
+import java.io.*;
+import java.util.*;
+public class D_668 {
+    static int p=1000000007;
+    static  int dia=Integer.MIN_VALUE;
+    public static void main(String[] args) throws Exception{
+        BufferedWriter out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(java.io.FileDescriptor.out), ""ASCII""), 512);
+        FastReader sc=new FastReader();
+        int t=sc.nextInt();
+       StringBuilder sb=new StringBuilder();
+        while(t-->0)
+        {
+            int n=sc.nextInt();
+            int a=sc.nextInt();
+            int b=sc.nextInt();
+            int da=sc.nextInt();
+            int db=sc.nextInt();
+            dia=Integer.MIN_VALUE;
+            int dp[]=new int[(int) n+1];
+            List<Integer> adj[]=new ArrayList[n+1];
+            for(int i=0;i<=n;i++)
+            {
+                adj[i]=new ArrayList<>();
+            }
+            Set<Integer> s=new HashSet<>();
+            for(int i=1;i<n;i++)
+            {
+                int u=sc.nextInt();
+                int v=sc.nextInt();
+                adj[u].add(v);
+                adj[v].add(u);
+            }
+            dfs(dp,adj,a,-1,0);
+           // System.out.println(dia+"" ""+dp[b]);
+            if(2*da>=db||2*da>=dia||da>=dp[b])
+                sb.append(""Alice\n"");
+            else
+                sb.append(""Bob\n"");
+
+        }
+        System.out.println(sb.toString());
+        out.flush();
+    }
+    public static int dfs(int dp[],List<Integer> adj[],int i,int p,int d)
+    {
+        dp[i]=d;
+        int last_max=0;
+        for(int v:adj[i])
+        {
+            if(p!=v&&dp[v]==0)
+            {
+                int max=1+dfs(dp,adj,v,i,d+1);
+                dia=Math.max(dia,max+last_max);
+                last_max=Math.max(last_max,max);
+            }
+        }
+        return last_max;
+    }
+    public static int binary_Search_upper(int ar[],int x)
+    {
+        int res=-1;
+        int l=0;int r=ar.length-1;
+        while(l<=r)
+        {
+            int mid=(l+r)>>1;
+            if(ar[mid]==x)
+            {
+                res=mid;
+                l=mid+1;
+            }
+            else if(ar[mid]>x)
+            {
+                r=mid-1;
+            }
+            else
+            {
+                l=mid+1;
+            }
+        }
+        return res;
+    }
+    public static int binary_Search_lower(int ar[],int x)
+    {
+        int res=-1;
+        int l=0;int r=ar.length-1;
+        while(l<=r)
+        {
+            int mid=(l+r)>>1;
+            if(ar[mid]==x)
+            {
+                res=mid;
+                r=mid-1;
+            }
+            else if(ar[mid]>x)
+            {
+                r=mid-1;
+            }
+            else
+            {
+                l=mid+1;
+            }
+        }
+        return res;
+    }
+    int bit[]=new int[(int)1e6];
+    public void update(int n,int val,int i)
+    {
+        i++;
+        while(i<n)
+        {
+            bit[i]+=val;
+            i+=(i)&(-i);
+        }
+
+    }
+    public long query(int n,int i)
+    {
+        i++;
+        long sum=0;
+        while(i>0)
+        {
+            sum+=bit[i];
+            i-=(i)&(-i);
+        }
+        return sum;
+    }
+
+
+    ///////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////
+    static class FastReader {
+
+        BufferedReader br;
+        StringTokenizer st;
+
+        public FastReader() {
+            br = new BufferedReader(new InputStreamReader(System.in));
+        }
+
+        String next() {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+
+        String nextLine() {
+            String str = """";
+            try {
+                str = br.readLine();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+        }
+    }
+
+
+}
+","
+import java.io.*;
+import java.util.*;
+
+public class Main {
+    private static final boolean N_CASE = true;
+    private List<List<Integer>> g;
+    private int a;
+    private int b;
+    private int da;
+    private int db;
+    private int max;
+    private int ab;
+
+    private int dfs(int u, int fa, int depth) {
+        if (u == a) {
+            ab = depth;
+        }
+
+        int m1 = 0, m2 = 0;
+        for (int v : g.get(u)) {
+            if (v != fa) {
+                int m = dfs(v, u, depth + 1) + 1;
+                if (m > m1) { m2 = m1; m1 = m; }
+                else if (m > m2) { m2 = m; }
+            }
+        }
+        max = Math.max(max, m1 + m2);
+        int cmax = Math.max(m1, m2);
+        max = Math.max(max, cmax + depth);
+        return cmax;
+    }
+
+    private void solve() {
+        int n = sc.nextInt();
+        a = sc.nextInt() - 1; b = sc.nextInt() - 1;
+        da = sc.nextInt(); db = sc.nextInt();
+
+        g = createGraph(n);
+        for (int i = 0; i < n - 1; ++i) {
+            int u = sc.nextInt() - 1, v = sc.nextInt() - 1;
+            g.get(u).add(v);
+            g.get(v).add(u);
+        }
+        max = 0;
+        dfs(b, -1, 0);
+        db = Math.min(max, db);
+
+        boolean win = true;
+        if (ab > da) {
+            if (db > da * 2) {
+                win = false;
+            }
+        }
+
+        out.println(win ? ""Alice"" : ""Bob"");
+    }
+
+    private void run() {
+        int T = N_CASE ? sc.nextInt() : 1;
+        for (int t = 0; t < T; ++t) {
+            solve();
+        }
+    }
+
+    private static MyWriter out;
+    private static MyScanner sc;
+
+    private static class MyScanner {
+        BufferedReader br;
+        StringTokenizer st;
+
+        private MyScanner() {
+            br = new BufferedReader(new InputStreamReader(System.in));
+        }
+
+        String next() {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+
+        int[] nextIntArray(int n) {
+            int[] a = new int[n];
+            for (int i = 0; i < n; i++) {
+                a[i] = nextInt();
+            }
+            return a;
+        }
+
+        int[][] nextIntArray(int n, int m) {
+            int[][] a = new int[n][m];
+            for (int i = 0; i < n; i++) {
+                for (int j = 0; j < m; j++) {
+                    a[i][j] = sc.nextInt();
+                }
+            }
+            return a;
+        }
+
+        long[] nextLongArray(int n) {
+            long[] a = new long[n];
+            for (int i = 0; i < n; i++) {
+                a[i] = nextLong();
+            }
+            return a;
+        }
+
+        long[][] nextLongArray(int n, int m) {
+            long[][] a = new long[n][m];
+            for (int i = 0; i < n; i++) {
+                for (int j = 0; j < m; j++) {
+                    a[i][j] = nextLong();
+                }
+            }
+            return a;
+        }
+
+        List<Integer> nextList(int n) {
+            List<Integer> list = new ArrayList<>();
+            for (int i = 0; i < n; i++) {
+                list.add(nextInt());
+            }
+            return list;
+        }
+
+        List<Long> nextLongList(int n) {
+            List<Long> list = new ArrayList<>();
+            for (int i = 0; i < n; i++) {
+                list.add(nextLong());
+            }
+            return list;
+        }
+
+        char[] nextCharArray(int n) {
+            return sc.next().toCharArray();
+        }
+
+        char[][] nextCharArray(int n, int m) {
+            char[][] c = new char[n][m];
+            for (int i = 0; i < n; i++) {
+                String s = sc.next();
+                for (int j = 0; j < m; j++) {
+                    c[i][j] = s.charAt(j);
+                }
+            }
+            return c;
+        }
+    }
+
+    private static class MyWriter extends PrintWriter {
+        private MyWriter(OutputStream outputStream) {
+            super(outputStream);
+        }
+
+        void printArray(int[] a) {
+            for (int i = 0; i < a.length; ++i) {
+                print(a[i]);
+                print(i == a.length - 1 ? '\n' : ' ');
+            }
+        }
+
+        void printArray(long[] a) {
+            for (int i = 0; i < a.length; ++i) {
+                print(a[i]);
+                print(i == a.length - 1 ? '\n' : ' ');
+            }
+        }
+
+        void println(int[] a) {
+            for (int v : a) {
+                println(v);
+            }
+        }
+
+        void print(List<Integer> list) {
+            for (int i = 0; i < list.size(); ++i) {
+                print(list.get(i));
+                print(i == list.size() - 1 ? '\n' : ' ');
+            }
+        }
+
+        void println(List<Integer> list) {
+            list.forEach(this::println);
+        }
+    }
+
+    private <T> List<List<T>> createGraph(int n) {
+        List<List<T>> g = new ArrayList<>();
+        for (int i = 0; i < n; ++i) {
+            g.add(new ArrayList<>());
+        }
+        return g;
+    }
+
+    private void fill(int[][] a, int value) {
+        for (int[] row : a) {
+            fill(row, value);
+        }
+    }
+
+    private void fill(int[] a, int value) {
+        Arrays.fill(a, value);
+    }
+
+    public static void main(String[] args) {
+        out = new MyWriter(new BufferedOutputStream(System.out));
+        sc = new MyScanner();
+        new Main().run();
+        out.close();
+    }
+}",0
+a4d6775d,cb87df79,"import java.io.*;
+import java.util.*;
+ 
+public class ArmChairs {
+    
+ 
+    public static int solution(int n, int[] arr) {
+ 
+        ArrayList<Integer> one = new ArrayList<Integer>();
+        ArrayList<Integer> zero = new ArrayList<Integer>();
+ 
+        for (int i = 0; i < n; i++) {
+            if (arr[i] == 1) {
+                one.add(i);
+            } else {
+                zero.add(i);
+            }
+        }
+ 
+        int[][] dp = new int[one.size() + 1][zero.size() + 1];
+ 
+        for (int i = 1; i <= one.size(); i++) {
+            dp[i][i] = dp[i - 1][i - 1] + Math.abs(one.get(i - 1) - zero.get(i - 1));
+            for (int j = i + 1; j <= zero.size(); j++) {
+                dp[i][j] = Math.min(dp[i][j - 1], dp[i - 1][j - 1] + Math.abs(one.get(i - 1) - zero.get(j - 1)));
+            }
+        }
+ 
+        return dp[one.size()][zero.size()];
+    }
+ 
+ 
+    public static void main(String[] args) throws IOException{
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        BufferedWriter log = new BufferedWriter(new OutputStreamWriter(System.out));
+ 
+        int n = Integer.parseInt(br.readLine());
+ 
+        String[] s = br.readLine().split("" "");
+        int[] arr = new int[n];
+        for (int i = 0; i < n; i++) {
+            arr[i] = Integer.parseInt(s[i]);
+        } 
+ 
+        log.write(Integer.toString(solution(n, arr)) + ""\n"");
+        log.flush();
+        
+    }
+ 
+}","import java.util.*;
+
+public class Longjumps {
+	 public static void main(String[] args){
+		 Scanner sc=new Scanner(System.in);
+			ArrayList<Integer> o=new ArrayList<Integer>(), e=new ArrayList<Integer>();
+			int n = sc.nextInt();
+			for(int i=1;i<=n;i++){
+				int x=sc.nextInt();
+				if(x==1)o.add(i);
+				else e.add(i);
+			}
+			int dp[][]=new int[o.size()+1][e.size()+1];
+			for(int i=1;i<=o.size();i++){
+				dp[i][i]=dp[i-1][i-1]+Math.abs(o.get(i-1)-e.get(i-1));
+				for(int j=i+1;j<=e.size();j++)
+					dp[i][j]=Math.min(dp[i][j-1],dp[i-1][j-1]+Math.abs(o.get(i-1)-e.get(j-1)));
+			}
+			System.out.println(dp[o.size()][e.size()]);
+	 }
+}",1
+317a209c,6b97058e,"import java.io.*;
+import java.util.*;
+
+public class D_Java {
+	public static final int MOD = 998244353;
+	
+	public static int mul(int a, int b) {
+		return (int)((long)a * (long)b % MOD);
+	}
+	
+	int[] f;
+	int[] rf;
+	
+	public int C(int n, int k) {
+		return (k < 0 || k > n) ? 0 : mul(f[n], mul(rf[n-k], rf[k]));
+	}
+	
+	public static int pow(int a, int n) {
+		int res = 1;
+		while (n != 0) {
+			if ((n & 1) == 1) {
+				res = mul(res, a);
+			}
+			a = mul(a, a);
+			n >>= 1;
+		}
+		return res;
+	}
+	
+	static void shuffleArray(int[] a) {
+		Random rnd = new Random();
+		for (int i = a.length-1; i > 0; i--) {
+			int index = rnd.nextInt(i + 1);
+			int tmp = a[index];
+			a[index] = a[i];
+			a[i] = tmp;
+		}
+	}
+	
+	public static int inv(int a) {
+		return pow(a, MOD-2);
+	}
+	
+	public void doIt() throws IOException {
+		BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
+		
+		StringTokenizer tok = new StringTokenizer(in.readLine());
+		int n = Integer.parseInt(tok.nextToken());
+		int k = Integer.parseInt(tok.nextToken());
+		
+		f = new int[n+42];
+		rf = new int[n+42];
+		f[0] = rf[0] = 1;
+		for (int i = 1; i < f.length; ++i) {
+			f[i] = mul(f[i-1], i);
+			rf[i] = mul(rf[i-1], inv(i));
+		}
+		
+		int[] events = new int[2*n];
+		for (int i = 0; i < n; ++i) {
+			tok = new StringTokenizer(in.readLine());
+			int le = Integer.parseInt(tok.nextToken());
+			int ri = Integer.parseInt(tok.nextToken());
+			events[i] = le*2;
+			events[i + n] = ri*2 + 1;
+		}
+		shuffleArray(events);
+		Arrays.sort(events);
+		
+		int ans = 0;
+		int balance = 0;
+		for (int r = 0; r < 2*n;) {
+			int l = r;
+			while (r < 2*n && events[l] == events[r]) {
+				++r;
+			}
+			int added = r - l;
+			if (events[l] % 2 == 0) {
+				// Open event
+				ans += C(balance + added, k);
+				if (ans >= MOD) ans -= MOD;
+				ans += MOD - C(balance, k);
+				if (ans >= MOD) ans -= MOD;
+				balance += added;
+			} else {
+				// Close event
+				balance -= added;
+			}
+		}
+		
+		in.close();
+		System.out.println(ans);
+	}
+	
+	public static void main(String[] args) throws IOException {
+		(new D_Java()).doIt();
+	}
+}","import java.io.*;
+import java.util.*;
+
+public class D_Java {
+	public static final int MOD = 998244353;
+	
+	public static int mul(int a, int b) {
+		return (int)((long)a * (long)b % MOD);
+	}
+	
+	int[] f;
+	int[] rf;
+	
+	public int C(int n, int k) {
+		return (k < 0 || k > n) ? 0 : mul(f[n], mul(rf[n-k], rf[k]));
+	}
+	
+	public static int pow(int a, int n) {
+		int res = 1;
+		while (n != 0) {
+			if ((n & 1) == 1) {
+				res = mul(res, a);
+			}
+			a = mul(a, a);
+			n >>= 1;
+		}
+		return res;
+	}
+	
+	static void shuffleArray(int[] a) {
+		Random rnd = new Random();
+		for (int i = a.length-1; i > 0; i--) {
+			int index = rnd.nextInt(i + 1);
+			int tmp = a[index];
+			a[index] = a[i];
+			a[i] = tmp;
+		}
+	}
+	
+	public static int inv(int a) {
+		return pow(a, MOD-2);
+	}
+	
+	public void doIt() throws IOException {
+		BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
+		
+		StringTokenizer tok = new StringTokenizer(in.readLine());
+		int n = Integer.parseInt(tok.nextToken());
+		int k = Integer.parseInt(tok.nextToken());
+		
+		f = new int[n+42];
+		rf = new int[n+42];
+		f[0] = rf[0] = 1;
+		for (int i = 1; i < f.length; ++i) {
+			f[i] = mul(f[i-1], i);
+			rf[i] = mul(rf[i-1], inv(i));
+		}
+		
+		int[] events = new int[2*n];
+		for (int i = 0; i < n; ++i) {
+			tok = new StringTokenizer(in.readLine());
+			int le = Integer.parseInt(tok.nextToken());
+			int ri = Integer.parseInt(tok.nextToken());
+			events[i] = le*2;
+			events[i + n] = ri*2 + 1;
+		}
+		shuffleArray(events);
+		Arrays.sort(events);
+		
+		int ans = 0;
+		int balance = 0;
+		for (int r = 0; r < 2*n;) {
+			int l = r;
+			while (r < 2*n && events[l] == events[r]) {
+				++r;
+			}
+			int added = r - l;
+			if (events[l] % 2 == 0) {
+				// Open event
+				ans += C(balance + added, k);
+				if (ans >= MOD) ans -= MOD;
+				ans += MOD - C(balance, k);
+				if (ans >= MOD) ans -= MOD;
+				balance += added;
+			} else {
+				// Close event
+				balance -= added;
+			}
+		}
+		
+		in.close();
+		System.out.println(ans);
+	}
+	
+	public static void main(String[] args) throws IOException {
+		(new D_Java()).doIt();
+	}
+}
+",1
+3088ca9c,7a9c69d8,"import java.util.*;
+import java.io.*;
+
+
+public class MyClass {
+    public static void main(String args[]) {
+     Scanner sc = new Scanner(System.in);
+     int t = sc.nextInt();
+     while(t>0)
+     {
+         int n = sc.nextInt();
+         sc.nextLine();
+         String [] str = new String[n];
+         int res = 0;
+         for(int i=0;i<n;i++)
+         {
+             str[i]=sc.nextLine();
+         }
+         int [][] freq = new int [n][5];
+         for(int i=0;i<n;i++)
+         {
+             for(int j=0;j<str[i].length();j++)
+             {
+                 int k = str[i].charAt(j)-'a';
+                 freq[i][k]++;
+             }
+         }
+         for(int i=0;i<5;i++)
+         {
+             int [] arr = new int[n];
+             for(int j=0;j<n;j++)
+             {
+                 int pos = freq[j][i];
+                 int sum=0;
+                 for(int k = 0;k<5;k++)
+                 {
+                     sum+=freq[j][k];
+                 }
+                 sum-=pos;
+                 arr[j]=(pos-sum);
+             }
+             Arrays.sort(arr);
+            //  int p = n-1;
+             int count=0;
+             int sum=0;
+             for(int p=n-1;p>=0;p--)
+             {
+                 sum+=arr[p];
+                 if(sum>0)
+                 {
+                     count++;
+                 }
+                 else
+                 {
+                     break;
+                 }
+             }
+             res=Math.max(count , res);
+         }
+         
+         System.out.println(res);
+         t--;
+         
+     }
+    }
+}","import java.io.*;
+import java.util.*;
+
+public class C {
+
+    public static void main(String[] args) throws Exception{
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
+        try{
+            int t = Integer.parseInt(br.readLine());
+            while(t-->0){
+                int n = Integer.parseInt(br.readLine());
+                int lst[][] = new int[n][5];
+                for(int i=0; i<n; i++){
+                    String s = br.readLine();
+                    for(int j=0; j<s.length(); j++){
+                        lst[i][s.charAt(j)-'a']++;
+                    }
+                }
+                int fans = Integer.MIN_VALUE;
+                for(int i=0; i<5; i++){
+                    int val[] = new int[n];
+                    for(int k=0; k<n; k++){
+                        int sum = 0;
+                        for(int j=0; j<5; j++){
+                            if(i==j){
+                                sum += lst[k][j];
+                            }else{
+                                sum -= lst[k][j];
+                            }
+                        }
+                        val[k] = sum;
+                    }
+                    Arrays.sort(val);
+                    int sum = 0;
+                    int ans = 0;
+                    for(int x = n-1; x>=0; x--){
+                        sum+=val[x];
+                        if(sum>0){
+                            ans++;
+                        }else{
+                            break;
+                        }
+                    }
+                    fans = Math.max(fans, ans);
+                }
+                bw.write(fans+""\n"");
+            }
+            bw.flush();
+        }catch(Exception e){
+            return;
+        }
+    }
+    
+}
+",1
+6946f466,ce7027ee,"import java.util.*;
+
+public class A {
+
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        StringBuilder sb = new StringBuilder();
+        int testCases = sc.nextInt();
+
+        for (int t = 0; t < testCases; t++) {
+            int n = sc.nextInt();
+            int m = sc.nextInt();
+
+            char c[][] = new char[n][m];
+
+            for (int i = 0; i < n; i++) {
+                String str = sc.next();
+                c[i] = str.toCharArray();
+            }
+
+            int count = 0;
+            StringBuilder ans = new StringBuilder();
+
+            for (int i = 0; i < m - 2; i++) {
+                for (int j = 0; j < n; j++) {
+
+                    if (c[j][i] == '0') {
+                        continue;
+                    }
+                    count++;
+
+                    if (j == n - 1) {
+
+                        c[j][i] = '0';
+                        c[j][i + 1] = (c[j][i + 1] == '0' ? '1' : '0');
+                        c[j - 1][i + 1] = (c[j - 1][i + 1] == '0' ? '1' : '0');
+
+                        ans.append((j + 1) + "" "" + (i + 1) + "" "" + (j + 1) + "" "" + (i + 2) + "" "" + (j) + "" "" + (i + 2))
+                                .append(""\n"");
+                        continue;
+                    }
+
+                    c[j][i] = '0';
+                    c[j][i + 1] = (c[j][i + 1] == '0' ? '1' : '0');
+                    c[j + 1][i + 1] = (c[j + 1][i + 1] == '0' ? '1' : '0');
+
+                    ans.append((j + 1) + "" "" + (i + 1) + "" "" + (j + 1) + "" "" + (i + 2) + "" "" + (j + 2) + "" "" + (i + 2))
+                            .append(""\n"");
+
+                }
+            }
+
+            for (int i = 0; i < n - 2; i++) {
+                for (int j = m - 2; j < m; j++) {
+                    if (c[i][j] == '0') {
+                        continue;
+                    }
+                    count++;
+
+                    if (j == m - 1) {
+                        c[i][j] = '0';
+                        c[i + 1][j] = (c[i + 1][j] == '0' ? '1' : '0');
+                        c[i + 1][j - 1] = (c[i + 1][j - 1] == '0' ? '1' : '0');
+
+                        ans.append((i + 1) + "" "" + (j + 1) + "" "" + (i + 2) + "" "" + (j + 1) + "" "" + (i + 2) + "" "" + (j))
+                                .append(""\n"");
+
+                        continue;
+                    }
+
+                    c[i][j] = '0';
+                    c[i + 1][j] = (c[i + 1][j] == '0' ? '1' : '0');
+                    c[i + 1][j + 1] = (c[i + 1][j + 1] == '0' ? '1' : '0');
+
+                    ans.append((i + 1) + "" "" + (j + 1) + "" "" + (i + 2) + "" "" + (j + 1) + "" "" + (i + 2) + "" "" + (j + 2))
+                            .append(""\n"");
+                }
+            }
+
+            ArrayList<String> al = new ArrayList<>();
+
+            int count_one = 0;
+
+            for (int i = n - 2; i < n; i++) {
+                for (int j = m - 2; j < m; j++) {
+
+                    if (c[i][j] == '0') {
+                        al.add((i + 1) + "" "" + (j + 1));
+                    } else {
+                        count_one++;
+                        al.add(0, (i + 1) + "" "" + (j + 1));
+                    }
+
+                }
+            }
+
+            if (count_one == 0) {
+                sb.append(count).append(""\n"");
+                sb.append(ans).append(""\n"");
+                continue;
+            }
+
+            if (count_one == 1) {
+                ans.append(al.get(0) + "" "" + al.get(1) + "" "" + al.get(2)).append(""\n"");
+                ans.append(al.get(0) + "" "" + al.get(2) + "" "" + al.get(3)).append(""\n"");
+                ans.append(al.get(0) + "" "" + al.get(1) + "" "" + al.get(3)).append(""\n"");
+
+                count = count + 3;
+
+                sb.append(count).append(""\n"");
+                sb.append(ans).append(""\n"");
+                continue;
+            }
+
+            if (count_one == 2) {
+                ans.append(al.get(0) + "" "" + al.get(2) + "" "" + al.get(3)).append(""\n"");
+                ans.append(al.get(1) + "" "" + al.get(2) + "" "" + al.get(3)).append(""\n"");
+
+                count = count + 2;
+                sb.append(count).append(""\n"");
+                sb.append(ans).append(""\n"");
+                continue;
+            }
+
+            if (count_one == 3) {
+                ans.append(al.get(0) + "" "" + al.get(1) + "" "" + al.get(2)).append(""\n"");
+
+                count = count + 1;
+                sb.append(count).append(""\n"");
+                sb.append(ans).append(""\n"");
+                continue;
+            }
+
+            if (count_one == 4) {
+                ans.append(al.get(1) + "" "" + al.get(2) + "" "" + al.get(3)).append(""\n"");
+
+                ans.append(al.get(0) + "" "" + al.get(1) + "" "" + al.get(2)).append(""\n"");
+                ans.append(al.get(0) + "" "" + al.get(2) + "" "" + al.get(3)).append(""\n"");
+                ans.append(al.get(0) + "" "" + al.get(1) + "" "" + al.get(3)).append(""\n"");
+
+                count = count + 4;
+
+                sb.append(count).append(""\n"");
+                sb.append(ans).append(""\n"");
+                continue;
+
+            }
+
+        }
+
+        System.out.print(sb);
+    }
+}
+","import java.util.*;
+ 
+public class A {
+ 
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        StringBuilder sb = new StringBuilder();
+        int testCases = sc.nextInt();
+ 
+        for (int t = 0; t < testCases; t++) {
+            int n = sc.nextInt();
+            int m = sc.nextInt();
+ 
+            char c[][] = new char[n][m];
+ 
+            for (int i = 0; i < n; i++) {
+                String str = sc.next();
+                c[i] = str.toCharArray();
+            }
+ 
+            int count = 0;
+            StringBuilder ans = new StringBuilder();
+ 
+            for (int i = 0; i < m - 2; i++) {
+                for (int j = 0; j < n; j++) {
+ 
+                    if (c[j][i] == '0') {
+                        continue;
+                    }
+                    count++;
+ 
+                    if (j == n - 1) {
+ 
+                        c[j][i] = '0';
+                        c[j][i + 1] = (c[j][i + 1] == '0' ? '1' : '0');
+                        c[j - 1][i + 1] = (c[j - 1][i + 1] == '0' ? '1' : '0');
+ 
+                        ans.append((j + 1) + "" "" + (i + 1) + "" "" + (j + 1) + "" "" + (i + 2) + "" "" + (j) + "" "" + (i + 2))
+                                .append(""\n"");
+                        continue;
+                    }
+ 
+                    c[j][i] = '0';
+                    c[j][i + 1] = (c[j][i + 1] == '0' ? '1' : '0');
+                    c[j + 1][i + 1] = (c[j + 1][i + 1] == '0' ? '1' : '0');
+ 
+                    ans.append((j + 1) + "" "" + (i + 1) + "" "" + (j + 1) + "" "" + (i + 2) + "" "" + (j + 2) + "" "" + (i + 2))
+                            .append(""\n"");
+ 
+                }
+            }
+ 
+            for (int i = 0; i < n - 2; i++) {
+                for (int j = m - 2; j < m; j++) {
+                    if (c[i][j] == '0') {
+                        continue;
+                    }
+                    count++;
+ 
+                    if (j == m - 1) {
+                        c[i][j] = '0';
+                        c[i + 1][j] = (c[i + 1][j] == '0' ? '1' : '0');
+                        c[i + 1][j - 1] = (c[i + 1][j - 1] == '0' ? '1' : '0');
+ 
+                        ans.append((i + 1) + "" "" + (j + 1) + "" "" + (i + 2) + "" "" + (j + 1) + "" "" + (i + 2) + "" "" + (j))
+                                .append(""\n"");
+ 
+                        continue;
+                    }
+ 
+                    c[i][j] = '0';
+                    c[i + 1][j] = (c[i + 1][j] == '0' ? '1' : '0');
+                    c[i + 1][j + 1] = (c[i + 1][j + 1] == '0' ? '1' : '0');
+ 
+                    ans.append((i + 1) + "" "" + (j + 1) + "" "" + (i + 2) + "" "" + (j + 1) + "" "" + (i + 2) + "" "" + (j + 2))
+                            .append(""\n"");
+                }
+            }
+ 
+            ArrayList<String> al = new ArrayList<>();
+ 
+            int count_one = 0;
+ 
+            for (int i = n - 2; i < n; i++) {
+                for (int j = m - 2; j < m; j++) {
+ 
+                    if (c[i][j] == '0') {
+                        al.add((i + 1) + "" "" + (j + 1));
+                    } else {
+                        count_one++;
+                        al.add(0, (i + 1) + "" "" + (j + 1));
+                    }
+ 
+                }
+            }
+ 
+            if (count_one == 0) {
+                sb.append(count).append(""\n"");
+                sb.append(ans).append(""\n"");
+                continue;
+            }
+ 
+            if (count_one == 1) {
+                ans.append(al.get(0) + "" "" + al.get(1) + "" "" + al.get(2)).append(""\n"");
+                ans.append(al.get(0) + "" "" + al.get(2) + "" "" + al.get(3)).append(""\n"");
+                ans.append(al.get(0) + "" "" + al.get(1) + "" "" + al.get(3)).append(""\n"");
+ 
+                count = count + 3;
+ 
+                sb.append(count).append(""\n"");
+                sb.append(ans).append(""\n"");
+                continue;
+            }
+ 
+            if (count_one == 2) {
+                ans.append(al.get(0) + "" "" + al.get(2) + "" "" + al.get(3)).append(""\n"");
+                ans.append(al.get(1) + "" "" + al.get(2) + "" "" + al.get(3)).append(""\n"");
+ 
+                count = count + 2;
+                sb.append(count).append(""\n"");
+                sb.append(ans).append(""\n"");
+                continue;
+            }
+ 
+            if (count_one == 3) {
+                ans.append(al.get(0) + "" "" + al.get(1) + "" "" + al.get(2)).append(""\n"");
+ 
+                count = count + 1;
+                sb.append(count).append(""\n"");
+                sb.append(ans).append(""\n"");
+                continue;
+            }
+ 
+            if (count_one == 4) {
+                ans.append(al.get(1) + "" "" + al.get(2) + "" "" + al.get(3)).append(""\n"");
+ 
+                ans.append(al.get(0) + "" "" + al.get(1) + "" "" + al.get(2)).append(""\n"");
+                ans.append(al.get(0) + "" "" + al.get(2) + "" "" + al.get(3)).append(""\n"");
+                ans.append(al.get(0) + "" "" + al.get(1) + "" "" + al.get(3)).append(""\n"");
+ 
+                count = count + 4;
+ 
+                sb.append(count).append(""\n"");
+                sb.append(ans).append(""\n"");
+                continue;
+ 
+            }
+ 
+        }
+ 
+        System.out.print(sb);
+    }
+//
+}
+",1
+80881cae,9555b9d1,"//package Codeforces;
+import java.io.*;
+import java.util.*;
+
+
+public class CP
+{
+	static Scanner sc=new Scanner(System.in);
+	public static void main(String[] args) throws IOException, CloneNotSupportedException
+	{
+		int t=sc.nextInt();
+		while(t-->0)
+		{
+			int n=sc.nextInt();
+			int k[]=new int[n];
+			int h[]=new int[n];
+			for(int i=0;i<n;i++)
+				k[i]=sc.nextInt();
+			for(int i=0;i<n;i++)
+				h[i]=sc.nextInt();
+			ArrayList<Pair> interval=new ArrayList<Pair>();
+			ArrayList<Pair> act=new ArrayList<Pair>();
+			for(int i=0;i<n;i++)
+				interval.add(new Pair(k[i]-h[i]+1,k[i]));
+			Collections.sort(interval);
+//			out.println(interval);
+			act.add(interval.get(0).clone());
+			for(int i=1;i<n;i++)
+			{
+				Pair p=act.get(act.size()-1);
+				if(p.y<interval.get(i).x)
+					act.add(interval.get(i).clone());
+				else
+					p.y=Math.max(p.y, interval.get(i).y);
+			}
+//			out.println(act);
+			long mana=0;
+			for(Pair p: act)
+			{
+				long x=p.y-p.x+1;
+				mana+=(x*(x+1))/2;
+			}
+			System.out.println(mana);		
+ 		}
+	}
+	static class Pair implements Cloneable, Comparable<Pair>
+	{
+		int x,y;
+		Pair(int a,int b)
+		{
+			this.x=a;
+			this.y=b;
+		}
+//		@Override
+//		public boolean equals(Object obj) 
+//		{
+//			if(obj instanceof  Pair)
+//			{
+//				Pair p=(Pair)obj;
+//				return p.x==this.x && p.y==this.y;
+//			}
+//			return false;
+//		}
+//		@Override
+//		public int hashCode() 
+//		{
+//			return Math.abs(x)+500*Math.abs(y);
+//		}
+//		@Override
+//		public String toString() 
+//		{
+//			return ""(""+x+"" ""+y+"")"";
+//		}
+		@Override
+		protected Pair clone() throws CloneNotSupportedException {
+			return new Pair(this.x,this.y);
+		}
+		@Override
+		public int compareTo(Pair a) 
+		{
+			long t=(this.x-a.x);
+			if(t!=0)
+				return t>0?1:-1;
+			else
+				return (int)(this.y-a.y);
+		}
+//		public void swap()
+//		{
+//			this.y=this.y+this.x;
+//			this.x=this.y-this.x;
+//			this.y=this.y-this.x;			
+//		}
+	}
+}","import java.io.OutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.PrintWriter;
+import java.util.HashSet;
+import java.util.Scanner;
+import java.util.Set;
+
+/**
+ * Built using CHelper plug-in
+ * Actual solution is at the top
+ */
+public class Main {
+    public static void main(String[] args) {
+        InputStream inputStream = System.in;
+        OutputStream outputStream = System.out;
+        Scanner in = new Scanner(inputStream);
+        PrintWriter out = new PrintWriter(outputStream);
+        TaskC solver = new TaskC();
+        solver.solve(1, in, out);
+        out.close();
+    }
+
+    static class TaskC {
+        public void solve(int testNumber, Scanner in, PrintWriter out) {
+            int T = in.nextInt();
+            while (T-- > 0) {
+                solveOne(in, out);
+            }
+        }
+
+        private void solveOne(Scanner in, PrintWriter out) {
+            int N = in.nextInt();
+            int[] k = L.readIntArray(N, in), h = L.readIntArray(N, in);
+            Set<Integer> toRemove = new HashSet<>();
+
+            int prevCost = h[0], prevX = k[0];
+            for (int i = 1; i < N; i++) {
+                for (int j = i; j < N; j++) {
+                    int currCost = h[j], currX = k[j];
+                    if (currX - currCost + 1 <= prevX) {
+                        if (prevCost + (currX - prevX) > h[j]) h[j] = prevCost + (currX - prevX);
+                    }
+                }
+                prevX = k[i];
+                prevCost = h[i];
+            }
+
+            int nextCost = h[N - 1], nextX = k[N - 1];
+            for (int i = N - 2; i >= 0; i--) {
+                int currCost = h[i], currX = k[i];
+                if ((nextCost - currCost) >= (nextX - currX)) {
+                    toRemove.add(i);
+                    continue;
+                }
+                nextCost = currCost;
+                nextX = currX;
+            }
+            long cost = 0;
+            for (int i = N - 1; i >= 0; i--)
+                if (!toRemove.contains(i)) cost += (h[i] * ((long) h[i] + 1)) / 2;
+            out.println(cost);
+        }
+
+    }
+
+    static class L {
+        public static int[] readIntArray(int size, Scanner in) {
+            int[] array = new int[size];
+            for (int i = 0; i < size; i++) {
+                array[i] = in.nextInt();
+            }
+            return array;
+        }
+
+    }
+}
+
+",0
+24afd00e,810fd282,"/*
+    JAI MATA DI
+ */
+
+import java.util.*;
+import java.io.*;
+import java.math.BigInteger;
+import java.sql.Array;
+public class CP {
+	  static class FR{
+			BufferedReader br;
+			StringTokenizer st;
+			public FR() {
+				br = new BufferedReader(new InputStreamReader(System.in));
+			}
+			String next() 
+		    { 
+		        while (st == null || !st.hasMoreElements()) 
+		        { 
+		            try
+		            { 
+		                st = new StringTokenizer(br.readLine()); 
+		            } 
+		            catch (IOException  e) 
+		            { 
+		                e.printStackTrace(); 
+		            } 
+		        } 
+		        return st.nextToken(); 
+		    } 
+
+		    int nextInt() 
+		    { 
+		        return Integer.parseInt(next()); 
+		    } 
+
+		    long nextLong() 
+		    { 
+		        return Long.parseLong(next()); 
+		    } 
+
+		    double nextDouble() 
+		    { 
+		        return Double.parseDouble(next()); 
+		    } 
+
+		    String nextLine() 
+		    { 
+		        String str = """"; 
+		        try
+		        { 
+		            str = br.readLine(); 
+		        } 
+		        catch (IOException e) 
+		        { 
+		            e.printStackTrace(); 
+		        } 
+		        return str; 
+		    } 
+		}
+	 static int mod  = 1000000007;
+	 static int gcd(int a, int b)
+	  {      
+	     if (b == 0)
+	        return a;
+	     return gcd(b, a % b); 
+	  }
+	 static long gcd(long a, long b)
+	  {      
+	     if (b == 0)
+	        return a;
+	     return gcd(b, a % b); 
+	  }
+	 static boolean[] prime(int num) {
+			boolean[] bool = new boolean[num];
+		     
+		      for (int i = 0; i< bool.length; i++) {
+		         bool[i] = true;
+		      }
+		      for (int i = 2; i< Math.sqrt(num); i++) {
+		         if(bool[i] == true) {
+		            for(int j = (i*i); j<num; j = j+i) {
+		               bool[j] = false;
+		            }
+		         }
+		      }
+		      if(num >= 0) {
+		    	  bool[0] = false;
+		    	  bool[1] = false;
+		      }
+		      
+		      return bool;
+		}
+	
+	 
+
+/* ***************************************************************************************************************************************************/	 
+	 static FR sc = new FR();
+	 static StringBuilder sb = new StringBuilder();
+	 public static void main(String args[]) {
+		 int tc = sc.nextInt();
+	
+		 while(tc-- > 0) {
+			 TEST_CASE();
+		 }
+			System.out.println(sb);
+		 }		
+
+		static void TEST_CASE() {
+		int n = sc.nextInt();
+		 lr = new long[n][2];
+		for(int  i =0 ; i < n ; i ++) {
+			lr[i][0] = sc.nextLong();
+			lr[i][1] = sc.nextLong();
+		}
+		 adj = new ArrayList<ArrayList<Integer>>();
+		for(int i = 0 ; i <n ; i++) adj.add(new ArrayList<Integer>());
+		
+		for(int i = 0 ; i<n-1 ; i++) {
+			int u = sc.nextInt()-1 , v = sc.nextInt()-1;
+			adj.get(u).add(v);
+			adj.get(v).add(u);
+		}
+		min = new long[n];
+		max = new long[n];
+		dfs(0,-1);
+		sb.append(Math.max(min[0], max[0])).append(""\n"");
+		
+		}
+		static long[] min , max , lr[];
+		static ArrayList<ArrayList<Integer>> adj;
+		static void dfs(int u , int p  ) {
+			
+			for(int child:adj.get(u)) {
+				if(child == p) continue;
+				dfs(child , u);
+			}
+			long left = lr[u][0] , right = lr[u][1];
+			
+			long ansl = 0 , ansr = 0;
+			for(int child:adj.get(u)) {
+				if(child == p) continue;
+				long leftc = lr[child][0] , rightc = lr[child][1];
+				ansl += Math.max( min[child] + Math.abs(left - leftc)  ,
+						max[child] +Math.abs(left - rightc)      );
+			}
+			for(int child:adj.get(u)) {
+				if(child == p) continue;
+				long leftc = lr[child][0] , rightc = lr[child][1];
+				ansr += Math.max( min[child] + Math.abs(right - leftc)  ,
+						max[child] +Math.abs(right - rightc)      );
+			}
+			min[u] = ansl;
+			max[u] = ansr;
+			
+		}
+		
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+","import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+
+public class Main
+{
+	static int N=(int)2e5+10;
+	static long[][] dp=new long[2][N];
+	static int[][] A=new int[2][N];
+	static ArrayList<ArrayList<Integer>> adj=new ArrayList<>(N);
+	static
+	{
+		for(int i=0;i<N;i++)
+			adj.add(new ArrayList<>());
+	}
+	
+	public static void dfs(int v,int p)
+	{
+		dp[0][v]=dp[1][v]=0;
+		for(Integer u:adj.get(v))
+		{
+			if(u==p)
+				continue;
+			dfs(u, v);
+			dp[0][v]+=Math.max(Math.abs(A[0][v]-A[1][u])+dp[1][u], dp[0][u]+Math.abs(A[0][v]-A[0][u]));
+			dp[1][v]+=Math.max(Math.abs(A[1][v]-A[1][u])+dp[1][u], dp[0][u]+Math.abs(A[1][v]-A[0][u]));
+		}
+	}
+	
+	public static void main(String[] args) throws Exception
+	{
+		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+		int t=Integer.parseInt(br.readLine());
+		while(t-->0)
+		{
+			int n=Integer.parseInt(br.readLine());
+			for(int i=1;i<=n;i++)
+			{
+				String[] ss1=br.readLine().split("" "");
+				A[0][i]=Integer.parseInt(ss1[0]);
+				A[1][i]=Integer.parseInt(ss1[1]);
+				adj.set(i, new ArrayList<>());
+			}
+			for(int i=1;i<n;i++)
+			{
+				String[] ss2=br.readLine().split("" "");
+				int u=Integer.parseInt(ss2[0]);
+				int v=Integer.parseInt(ss2[1]);
+				adj.get(u).add(v);
+				adj.get(v).add(u);
+			}
+			dfs(1, -1);
+			System.out.println(Math.max(dp[0][1], dp[1][1]));
+		}
+    }
+}",0
+6bcc5afd,734a94be,"import java.util.*;
+public class MyClass {
+    public static void main(String args[]) {
+     Scanner s=new Scanner(System.in);
+     int n=s.nextInt();
+     int a[]=new int[n];
+     ArrayList<Integer> lt1=new ArrayList<>();
+     ArrayList<Integer> lt0=new ArrayList<>();
+     for(int i=0;i<n;i++)
+     {
+         int l=s.nextInt();
+         if(l==0)
+         lt0.add(i+1);
+         else
+         lt1.add(i+1);
+     }
+     int dp[][]=new int[lt1.size()+1][lt0.size()+1];
+     for(int i=1;i<=lt1.size();i++)
+     {
+         dp[i][i]=dp[i-1][i-1]+Math.abs(lt0.get(i-1)-lt1.get(i-1));
+         for(int j=i+1;j<=lt0.size();j++)
+         {
+             dp[i][j]=Math.min(dp[i][j-1],dp[i-1][j-1]+Math.abs(lt1.get(i-1)-lt0.get(j-1)));
+         }
+     }
+     System.out.println(dp[lt1.size()][lt0.size()]);
+     
+    }
+}","
+
+import java.io.*;
+import java.math.*;
+import java.util.*;
+
+
+
+public class test {
+	 
+	   static class Pair{ 
+		   long x;
+		   long y;
+		   
+		   Pair(long x,long y){ 
+			   this.x = x;
+			   this.y = y;
+			   
+		   }
+	   }
+	  
+	   static class Compare { 
+		   
+		     void compare(Pair arr[], int n) 
+		    { 
+		        // Comparator to sort the pair according to second element 
+		        Arrays.sort(arr, new Comparator<Pair>() { 
+		            @Override public int compare(Pair p1, Pair p2) 
+		            { 
+		            	if(p1.x!=p2.x) {
+		                return (int)(p1.x - p2.x); 
+		            	}
+		            	else { 
+		            		return (int)(p1.y - p2.y);
+		            	}
+		            } 
+		        }); 
+		  
+//		        for (int i = 0; i < n; i++) { 
+//		            System.out.print(arr[i].x + "" "" + arr[i].y + "" ""); 
+//		        } 
+//		        System.out.println(); 
+		    } 
+		} 
+	 
+	   static class Scanner {
+	        BufferedReader br;
+	        StringTokenizer st;
+	 
+	        public Scanner()
+	        {
+	            br = new BufferedReader(
+	                new InputStreamReader(System.in));
+	        }
+	 
+	        String next()
+	        {
+	            while (st == null || !st.hasMoreElements()) {
+	                try {
+	                    st = new StringTokenizer(br.readLine());
+	                }
+	                catch (IOException e) {
+	                    e.printStackTrace();
+	                }
+	            }
+	            return st.nextToken();
+	        }
+	 
+	        int nextInt() { return Integer.parseInt(next()); }
+	 
+	        long nextLong() { return Long.parseLong(next()); }
+	 
+	        double nextDouble()
+	        {
+	            return Double.parseDouble(next());
+	        }
+	 
+	        String nextLine()
+	        {
+	            String str = """";
+	            try {
+	                str = br.readLine();
+	            }
+	            catch (IOException e) {
+	                e.printStackTrace();
+	            }
+	            return str;
+	        }
+	    }
+	
+	   static int solve(int dp[][] , ArrayList<Integer> one , ArrayList<Integer> zero , int i,int j)
+	   {
+	       int n=one.size();
+	       int m=zero.size();
+	       
+	       if(i>=n)
+	           return 0;
+	       
+	       else if(j>=m)
+	           return Integer.MAX_VALUE;
+	       
+	       else if(dp[i][j]!=-1)
+	           return dp[i][j];
+	       
+	       int val1 = Math.abs(one.get(i)-zero.get(j))+solve(dp, one ,zero ,i+1,j+1);
+	       int val2 = solve(dp , one , zero , i,j+1);
+	       
+	        dp[i][j]= Math.min(val1,val2);
+	        
+	        return dp[i][j];
+	   }
+	     
+	   public static void main(String args[]) throws Exception { 
+		
+		   Scanner sc = new Scanner();
+		   StringBuffer res = new StringBuffer();
+		   
+		   int tc = 1;
+		   
+		   while(tc-->0) { 
+			
+			    int n = sc.nextInt();
+			    
+			    ArrayList<Integer> one = new ArrayList<>();
+			    ArrayList<Integer> zero = new ArrayList<>();
+			    
+			    for(int i=0;i<n;i++) { 
+			    	
+			    	int x = sc.nextInt();
+			    	
+			    	if(x==1) { 
+			    		one.add(i);
+			    	}
+			    	else { 
+			    		zero.add(i);
+			    	}
+			    }
+			    
+			    int dp[][] = new int[one.size()+1][zero.size()+1];
+			    
+			     for(int i=1;i<=one.size();i++)
+			     {
+			         dp[i][i]=dp[i-1][i-1]+Math.abs(zero.get(i-1)-one.get(i-1));
+			         for(int j=i+1;j<=zero.size();j++)
+			         {
+			             dp[i][j]=Math.min(dp[i][j-1],dp[i-1][j-1]+Math.abs(one.get(i-1)-zero.get(j-1)));
+			         }
+			     }
+			     System.out.println(dp[one.size()][zero.size()]);
+		   }
+			System.out.println(res);
+	   }
+}  
+
+
+
+
+",1
+04ed33a5,6b83b22e,"import java.util.Scanner;
+
+public class Subsequence {
+	private static Scanner sc = new Scanner(System.in);
+	
+	public static void main(String args[]) {
+		int t = sc.nextInt();
+		
+		while(t-->0) {
+			int n = sc.nextInt();
+			
+			int a[] = new int[n];
+			int b[] =  new int[n];
+			
+			for(int i=0;i<n;i++) {
+				a[i]= sc.nextInt();
+				
+			}
+			
+			if(n%2==0) {
+				calculateB(a,b,n);
+			}
+			else {
+				calculateB(a,b,n-3);
+				if (a[n - 2] + a[n - 3] != 0) {
+					b[n - 3] = -a[n - 1];
+					b[n - 2] = -a[n - 1];
+					b[n - 1] = a[n - 2] + a[n - 3];
+				} else if (a[n - 2] + a[n - 1] != 0) {
+					b[n - 3] = a[n - 2] + a[n - 1];
+					b[n - 2] = -a[n - 3];
+					b[n - 1] = -a[n - 3];
+				} else {
+					b[n - 3] = -a[n - 2];
+					b[n - 2] = a[n - 3] + a[n - 1];
+					b[n - 1] = -a[n - 2];
+				}
+			}
+			
+			for(int i=0;i<n;i++) {
+				System.out.print(b[i] + "" "");
+			}
+			System.out.println();
+		}
+
+	}
+
+	private static void calculateB(int[] a, int[] b, int n) {
+		
+		for(int i=0;i<n-1;i=i+2) {
+			b[i] = -a[i+1];
+			b[i+1] = a[i];
+		}
+		
+	}
+}
+","import java.util.Scanner;
+
+public class Subsequence {
+	private static Scanner sc = new Scanner(System.in);
+	
+	public static void main(String args[]) {
+		int t = sc.nextInt();
+		
+		while(t-->0) {
+			int n = sc.nextInt();
+			
+			int a[] = new int[n];
+			int b[] =  new int[n];
+			
+			for(int i=0;i<n;i++) {
+				a[i]= sc.nextInt();
+				
+			}
+			
+			if(n%2==0) {
+				calculateB(a,b,n);
+			}
+			else {
+				calculateB(a,b,n-3);
+				if (a[n - 2] + a[n - 3] != 0) {
+					b[n - 3] = -a[n - 1];
+					b[n - 2] = -a[n - 1];
+					b[n - 1] = a[n - 2] + a[n - 3];
+				} else if (a[n - 2] + a[n - 1] != 0) {
+					b[n - 3] = a[n - 2] + a[n - 1];
+					b[n - 2] = -a[n - 3];
+					b[n - 1] = -a[n - 3];
+				} else {
+					b[n - 3] = -a[n - 2];
+					b[n - 2] = a[n - 3] + a[n - 1];
+					b[n - 1] = -a[n - 2];
+				}
+			}
+			
+			for(int i=0;i<n;i++) {
+				System.out.print(b[i] + "" "");
+			}
+			System.out.println();
+		}
+
+	}
+
+	private static void calculateB(int[] a, int[] b, int n) {
+		
+		for(int i=0;i<n-1;i=i+2) {
+			b[i] = -a[i+1];
+			b[i+1] = a[i];
+		}
+		
+	}
+}
+",1
+c1fef98f,f870e76b,"import java.util.*;
+import java.io.*;
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.Scanner;
+import java.util.StringTokenizer;
+
+public class Test{
+
+        static FastReader scan;
+
+        static void solve(){
+            scan.nextLine();
+            int n=scan.nextInt();
+            int k=scan.nextInt();
+            int []arr=new int[n+1];
+
+            int []block=new int[k];
+            int []temp=new int[k];
+
+            for(int i=0;i<k;i++){
+                block[i]=scan.nextInt();
+            }
+
+            for(int i=0;i<k;i++){
+                temp[i]=scan.nextInt();
+            }
+
+            for(int i=0;i<k;i++){
+                arr[block[i]]=temp[i];
+            }
+            int []dp=new  int[n+1];
+            int prev=Integer.MAX_VALUE-1000;
+            for(int i=1;i<=n;i++){
+                if(arr[i]==0){
+                    if(prev==Integer.MAX_VALUE-1000){
+                        dp[i]=prev;
+                    }
+                    else{
+                        prev=prev+1;
+                        dp[i]=prev;
+                    }
+                }
+                else{
+                    prev=Math.min(prev+1,arr[i]);
+                    dp[i]=prev;
+                }
+            }
+
+            prev=Integer.MAX_VALUE-1000;
+            for(int i=n;i>=1;i--){
+                if(arr[i]==0){
+                    if(prev==Integer.MAX_VALUE-1000){
+                        dp[i]=Math.min(prev,dp[i]);
+                    }
+                    else{
+                        prev=prev+1;
+                        dp[i]=Math.min(prev,dp[i]);
+                    }
+                }
+                else{
+                    prev=Math.min(prev+1,arr[i]);
+                    dp[i]=Math.min(prev,dp[i]);
+                }
+            }
+
+            for(int i=1;i<=n;i++){
+                System.out.print(dp[i]+"" "");
+            }
+            System.out.println();
+
+        }
+
+        public static void main (String[] args) throws java.lang.Exception{
+            scan=new FastReader();
+            int t=scan.nextInt();
+            while(t-->0){
+                solve();                  
+            }
+        }
+
+        static class FastReader {
+            BufferedReader br;
+            StringTokenizer st;
+
+            public FastReader()
+            {
+                br = new BufferedReader(
+                    new InputStreamReader(System.in));
+            }
+
+            String next()
+            {
+                while (st == null || !st.hasMoreElements()) {
+                    try {
+                        st = new StringTokenizer(br.readLine());
+                    }
+                    catch (IOException e) {
+                        e.printStackTrace();
+                    }
+                }
+                return st.nextToken();
+            }
+
+            int nextInt() { return Integer.parseInt(next()); }
+
+            long nextLong() { return Long.parseLong(next()); }
+
+            double nextDouble() { return Double.parseDouble(next()); }
+
+            String nextLine()
+            {
+                String str = """";
+                try {
+                    str = br.readLine();
+                }
+                catch (IOException e) {
+                    e.printStackTrace();
+                }
+                return str;
+            }
+        }
+
+        static class Pair implements Comparable<Pair>{
+            long wt;
+            long idx;
+            Pair(long x,long y){
+                this.wt=x;
+                this.idx=y;
+            }
+            @Override
+            public int compareTo(Pair x){
+                return (int)(this.wt-x.wt);
+            }
+
+            public String toString(){
+                return ""( ""+wt+"" ""+idx+"" )"";
+            }
+        }        
+
+        static void printLong(long []arr){
+            for(long x:arr)System.out.print(x+"" "");
+        }
+
+        static void printInt(int []arr){
+            for(int x:arr)System.out.print(x+"" "");
+        }
+
+        static void scanInt(int []arr){
+            for(int i=0;i<arr.length;i++){
+                arr[i]=scan.nextInt();
+            }
+        }
+
+        static void scanLong(long []arr){
+            for(int i=0;i<arr.length;i++){
+                arr[i]=scan.nextLong();
+            }
+        }
+
+        static long gcd(long a, long b){
+            if (b == 0)
+                return a;
+            
+            return gcd(b, a % b);
+        }   
+
+        static long power(long x, long y, long mod){
+            long res = 1; 
+        
+            x = x % mod; 
+         
+            if (x == 0)
+              return 0; 
+         
+            while (y > 0){              
+                if ((y & 1) != 0)
+                res = (res * x) % mod;
+              
+                y = y >> 1; 
+                x = (x * x) % mod;
+            }
+                return res;
+        }
+
+        static long add(long a,long b,long mod){
+            a = a % mod; 
+            b = b % mod; 
+            return (((a + b) % mod) + mod) % mod;
+        }
+
+        static long sub(long a, long b,long mod){
+            a = a % mod; 
+            b = b % mod; 
+            return (((a - b) % mod) + mod) % mod;
+        }
+
+        static long mul(long a, long b,long mod){
+            a = a % mod; 
+            b = b % mod; 
+            return (((a * b) % mod) + mod) % mod;
+        }
+        
+
+        static long mminvprime(long a, long b,long mod) {
+            return power(a, b - 2,mod);
+        }
+}
+","
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.OutputStream;
+import java.io.PrintWriter;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Stack;
+import java.util.StringTokenizer;
+import java.util.Vector;
+
+public class Main {
+
+	static InputStream inputStream = System.in;
+	static OutputStream outputStream = System.out;
+	static InputReader in = new InputReader(inputStream);
+	static PrintWriter out = new PrintWriter(outputStream);
+
+	public static void main(String[] args) {
+
+		int t = in.nextInt();
+
+		while (t-- > 0) {
+
+			int n = in.nextInt();
+
+			int k = in.nextInt();
+
+			int[] v1 = new int[k];
+			int[] v2 = new int[k];
+
+			for (int i = 0; i < k; i++) {
+				v1[i] = in.nextInt();
+			}
+
+			for (int i = 0; i < k; i++) {
+				v2[i] = in.nextInt();
+			}
+			
+			
+			
+			//wejhfduiwehiofhw
+
+			int[] res = new int[n + 2];
+
+			Arrays.fill(res, 2000000000);
+
+			for (int i = 0; i < k; i++) {
+				res[v1[i]] = v2[i];
+
+			}
+
+			for (int i = 1; i <= n; i++) {
+
+				int val = Math.min(res[i], res[i - 1] + 1);
+
+				res[i] = val;
+
+			}
+			
+			//ewhfowiejp
+			
+			
+			
+			
+			
+			
+			
+			
+			
+			//wedhciuwahidochqowi
+			
+			
+			
+			
+			
+			
+			
+			
+			//wjdhoiqwnlidhqw
+			for (int i = n; i >= 1; i--) {
+				int val1 = Math.min(res[i], res[i + 1] + 1);
+				res[i] = val1;
+				// out.println(res[i]);
+			}
+
+			for (int i = 1; i <= n; i++) {
+				int r = res[i];
+				out.print(r + "" "");
+
+			}
+
+			out.println();
+
+		}
+
+		out.close();
+	}
+
+	private static void takeinput(int[] arr, int k) {
+		for (int i = 0; i < k; i++) {
+			arr[i] = in.nextInt();
+		}
+
+	}
+
+	static class InputReader {
+		public BufferedReader reader;
+		public StringTokenizer tokenizer;
+
+		public InputReader(InputStream stream) {
+			reader = new BufferedReader(new InputStreamReader(stream), 32768);
+			tokenizer = null;
+		}
+
+		public String next() {
+			while (tokenizer == null || !tokenizer.hasMoreTokens()) {
+				try {
+					tokenizer = new StringTokenizer(reader.readLine());
+				} catch (IOException e) {
+					throw new RuntimeException(e);
+				}
+			}
+			return tokenizer.nextToken();
+		}
+
+		public long nextLong() {
+			return Long.parseLong(next());
+		}
+
+		public int nextInt() {
+			return Integer.parseInt(next());
+		}
+
+		public String nextLine() throws IOException {
+			return reader.readLine().trim();
+		}
+	}
+
+}
+",0
+949502c2,9fc811f7,"import static java.lang.Math.max;
+import static java.lang.Math.min;
+import static java.lang.Math.abs;
+import static java.lang.System.out;
+import java.util.*;
+import java.io.*;
+import java.math.*;
+
+public class Template {
+
+	static int mod = 1000000007;
+
+	public static void main(String[] args) {
+		FastScanner sc = new FastScanner();
+		int yo = sc.nextInt();
+		while (yo-- > 0) {
+			int n = sc.nextInt();
+            int a = sc.nextInt()-1;
+            int b = sc.nextInt()-1;
+            int da = sc.nextInt();
+            int db = sc.nextInt();
+            
+            List<List<Integer>> list = new ArrayList<>();
+            for(int i = 0; i < n; i++) list.add(new ArrayList<>());
+            
+            for(int i = 0; i < n-1; i++){
+                int x = sc.nextInt()-1;
+                int y = sc.nextInt()-1;
+                list.get(x).add(y);
+                list.get(y).add(x);
+            }
+            
+            for(int i = 0; i <= n; i++) depth[i] = 0;
+            diam = 0;
+            dfs(a,-1,list);
+            
+            if(2 * da >= min(diam, db) || depth[b] <= da){
+                out.println(""Alice"");
+            }
+            else {
+                out.println(""Bob"");
+            }
+            
+		}
+	}
+    
+    static int[] depth = new int[200001];
+    static int diam = 0;
+    static int dfs(int x, int p, List<List<Integer>> list) {
+        int len = 0;
+        List<Integer> ne = list.get(x);
+        for(int y : ne) {
+            if(y != p) {
+                depth[y] = depth[x] + 1;
+                int cur = 1 + dfs(y, x,list);
+                diam = max(diam, cur + len);
+                len = max(len, cur);
+            }
+        }
+        return len;
+    }
+   
+
+	public static class Pair {
+		int x;
+		int y;
+
+		public Pair(int x, int y) {
+			this.x = x;
+			this.y = y;
+		}
+	}
+
+	public static void sort(int[] arr) {
+		ArrayList<Integer> ls = new ArrayList<Integer>();
+		for (int x : arr)
+			ls.add(x);
+		Collections.sort(ls);
+		for (int i = 0; i < arr.length; i++)
+			arr[i] = ls.get(i);
+	}
+
+	public static long gcd(long a, long b) {
+		if (b == 0)
+			return a;
+		return gcd(b, a % b);
+	}
+
+	static boolean[] sieve(int N) {
+		boolean[] sieve = new boolean[N + 1];
+		for (int i = 2; i <= N; i++)
+			sieve[i] = true;
+
+		for (int i = 2; i <= N; i++) {
+			if (sieve[i]) {
+				for (int j = 2 * i; j <= N; j += i) {
+					sieve[j] = false;
+				}
+			}
+		}
+		return sieve;
+	}
+
+	public static long power(long x, long y, long p) {
+		long res = 1L;
+		x = x % p;
+		while (y > 0) {
+			if ((y & 1) == 1)
+				res = (res * x) % p;
+			y >>= 1;
+			x = (x * x) % p;
+		}
+		return res;
+	}
+
+	public static void print(int[] arr) {
+		//for debugging only
+		for (int x : arr)
+			out.print(x + "" "");
+		out.println();
+	}
+
+	static class FastScanner {
+		private int BS = 1 << 16;
+		private char NC = (char) 0;
+		private byte[] buf = new byte[BS];
+		private int bId = 0, size = 0;
+		private char c = NC;
+		private double cnt = 1;
+		private BufferedInputStream in;
+
+		public FastScanner() {
+			in = new BufferedInputStream(System.in, BS);
+		}
+
+		public FastScanner(String s) {
+			try {
+				in = new BufferedInputStream(new FileInputStream(new File(s)), BS);
+			} catch (Exception e) {
+				in = new BufferedInputStream(System.in, BS);
+			}
+		}
+
+		private char getChar() {
+			while (bId == size) {
+				try {
+					size = in.read(buf);
+				} catch (Exception e) {
+					return NC;
+				}
+				if (size == -1)
+					return NC;
+				bId = 0;
+			}
+			return (char) buf[bId++];
+		}
+
+		public int nextInt() {
+			return (int) nextLong();
+		}
+
+		public int[] readInts(int N) {
+			int[] res = new int[N];
+			for (int i = 0; i < N; i++) {
+				res[i] = (int) nextLong();
+			}
+			return res;
+		}
+
+		public long[] readLongs(int N) {
+			long[] res = new long[N];
+			for (int i = 0; i < N; i++) {
+				res[i] = nextLong();
+			}
+			return res;
+		}
+
+		public long nextLong() {
+			cnt = 1;
+			boolean neg = false;
+			if (c == NC)
+				c = getChar();
+			for (; (c < '0' || c > '9'); c = getChar()) {
+				if (c == '-')
+					neg = true;
+			}
+			long res = 0;
+			for (; c >= '0' && c <= '9'; c = getChar()) {
+				res = (res << 3) + (res << 1) + c - '0';
+				cnt *= 10;
+			}
+			return neg ? -res : res;
+		}
+
+		public double nextDouble() {
+			double cur = nextLong();
+			return c != '.' ? cur : cur + nextLong() / cnt;
+		}
+
+		public double[] readDoubles(int N) {
+			double[] res = new double[N];
+			for (int i = 0; i < N; i++) {
+				res[i] = nextDouble();
+			}
+			return res;
+		}
+
+		public String next() {
+			StringBuilder res = new StringBuilder();
+			while (c <= 32)
+				c = getChar();
+			while (c > 32) {
+				res.append(c);
+				c = getChar();
+			}
+			return res.toString();
+		}
+
+		public String nextLine() {
+			StringBuilder res = new StringBuilder();
+			while (c <= 32)
+				c = getChar();
+			while (c != '\n') {
+				res.append(c);
+				c = getChar();
+			}
+			return res.toString();
+		}
+
+		public boolean hasNext() {
+			if (c > 32)
+				return true;
+			while (true) {
+				c = getChar();
+				if (c == NC)
+					return false;
+				else if (c > 32)
+					return true;
+			}
+		}
+	}
+
+	//	For Input.txt and Output.txt	
+	//	FileInputStream in = new FileInputStream(""input.txt"");
+	//	FileOutputStream out = new FileOutputStream(""output.txt"");
+	//	PrintWriter pw = new PrintWriter(out);
+	//	Scanner sc = new Scanner(in);
+}","import java.io.OutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.PrintWriter;
+import java.util.StringTokenizer;
+import java.io.IOException;
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+import java.io.InputStream;
+
+public class Main {
+    public static void main(String[] args) {
+        InputStream inputStream = System.in;
+        OutputStream outputStream = System.out;
+        InputReader in = new InputReader(inputStream);
+        PrintWriter out = new PrintWriter(outputStream);
+        DTreeTag solver = new DTreeTag();
+        int testCount = Integer.parseInt(in.next());
+        for (int i = 1; i <= testCount; i++)
+            solver.solve(i, in, out);
+        out.close();
+    }
+
+    static class DTreeTag {
+        int diam = 0;
+
+        public int dfs(ArrayList<Integer> g[], int x, int depth[], int p) {
+            int len = 0;
+            for (int y : g[x]) {
+                if (y != p) {
+                    depth[y] = depth[x] + 1;
+                    int cur = 1 + dfs(g, y, depth, x);
+                    diam = Math.max(diam, cur + len);
+                    len = Math.max(len, cur);
+                }
+            }
+            return len;
+        }
+
+        public void solve(int testNumber, InputReader in, PrintWriter out) {
+            int n = in.nextInt();
+            int a = in.nextInt() - 1;
+            int b = in.nextInt() - 1;
+            int da = in.nextInt();
+            int db = in.nextInt();
+            int dis[] = new int[n];
+            ArrayList<Integer> g[] = new ArrayList[n];
+            for (int i = 0; i < n; i++) g[i] = new ArrayList<>();
+            for (int i = 0; i < n - 1; i++) {
+                int u = in.nextInt() - 1;
+                int v = in.nextInt() - 1;
+                g[u].add(v);
+                g[v].add(u);
+            }
+            diam = 0;
+            dfs(g, a, dis, -1);
+            int disb = dis[b];
+            if (2 * da >= Math.min(diam, db) || disb <= da) {
+                out.println(""Alice"");
+            } else {
+                out.println(""Bob"");
+            }
+
+        }
+
+    }
+
+    static class InputReader {
+        public BufferedReader reader;
+        public StringTokenizer tokenizer;
+
+        public InputReader(InputStream stream) {
+            reader = new BufferedReader(new InputStreamReader(stream), 32768);
+            tokenizer = null;
+        }
+
+        public String next() {
+            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
+                try {
+                    tokenizer = new StringTokenizer(reader.readLine());
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+            }
+            return tokenizer.nextToken();
+        }
+
+        public int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+    }
+}
+
+",1
+4ea10951,66e74577,"import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.*;
+
+public class Main {
+    static String f1(String s, int index) {
+        StringBuffer sb = new StringBuffer();
+        for(int i =0;i<s.length();i++){
+            if( i == index) sb.append(s.charAt(i));
+            else if (s.charAt(i) == '0') sb.append('1');
+            else sb.append('0');
+        }
+        return sb.toString();
+    }
+    static long solve(String s1, String s2) {
+        if(s1.equals(s2)) return 0;
+        int o1 = 0, o2 = 0, diff = 0;
+        for (int i = 0; i < s1.length(); i++) {
+            if (s1.charAt(i) == '1') o1++;
+            if (s2.charAt(i) == '1') o2++;
+            if (s1.charAt(i) != s2.charAt(i)) diff++;
+        }
+        return o1 == o2? diff : Integer.MAX_VALUE;
+    }
+    public static void main(String[] args) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        int t = Integer.parseInt(br.readLine());
+        while (t-- > 0) {
+            int n = Integer.parseInt(br.readLine());
+            String s1 = br.readLine();
+            String s2 = br.readLine();
+            long res = solve(s1, s2);
+            for(int i=0;i<s1.length();i++) {
+                if(s1.charAt(i) == '1' && s2.charAt(i) == '1') {
+                    res = Math.min(res, 1 + solve(f1(s1, i), s2));
+                    break;
+                }
+            }
+            for(int i=0;i<s1.length();i++) {
+                if(s1.charAt(i) == '1' && s2.charAt(i) == '0') {
+                    res = Math.min(res,1 + solve(f1(s1, i), s2));
+                    break;
+                }
+            }
+            if(res == Integer.MAX_VALUE) System.out.println(""-1"");
+            else System.out.println(res);
+        }
+    }
+}","import java.io.*;
+import java.util.*;
+
+public class Menorah {
+	public static void main(String[] args) throws Exception {
+		FastIO in = new FastIO();
+		int t = in.nextInt();
+		for (int tc=0; tc<t; tc++) {
+			int n = in.nextInt();
+			String original = in.next();
+			String target = in.next();
+			int numDiff = 0;
+			int original1 = 0;
+			int target1 = 0;
+			for (int i=0; i<n; i++) {
+				if (original.charAt(i)!=target.charAt(i)) {
+					numDiff++;
+				}
+				if (original.charAt(i)=='1') original1++;
+				if (target.charAt(i)=='1') target1++;
+			}
+			int evenAns = Integer.MAX_VALUE;
+			int oddAns = Integer.MAX_VALUE;
+			if (original1==target1) {
+				evenAns = numDiff;
+			}
+			for (int i=0; i<n; i++) {
+				if (original.charAt(i)=='1' && target.charAt(i)=='1') {
+					int ones = (n-original1)+1;
+					if (ones==target1) {
+						oddAns = n-numDiff;
+					}
+					break;
+				}
+			}
+			for (int i=0; i<n; i++) {
+				if (original.charAt(i)=='1' && target.charAt(i)=='0') {
+					int ones = (n-original1)+1;
+					if (ones==target1) {
+						oddAns = Math.min(n-numDiff+1, oddAns);
+					}
+					break;
+				}
+			}
+			int ans = Math.min(evenAns, oddAns);
+			if (ans==Integer.MAX_VALUE) System.out.println(-1);
+			else System.out.println(ans);
+		}
+	}
+	static class FastIO {
+		BufferedReader br;
+	    StringTokenizer st;
+	    public FastIO() throws IOException
+	    {
+	        br = new BufferedReader(
+	            new InputStreamReader(System.in));
+
+	    }
+	    
+
+	    public String next() throws IOException
+	    {
+	        while (st == null || !st.hasMoreElements()) {
+	           
+	            st = new StringTokenizer(br.readLine());
+	        }
+	        return st.nextToken();
+	    }
+
+	    public int nextInt() throws NumberFormatException, IOException { return Integer.parseInt(next()); }
+
+	    public long nextLong() throws NumberFormatException, IOException { return Long.parseLong(next()); }
+
+	    public double nextDouble() throws NumberFormatException, IOException
+	    {
+	        return Double.parseDouble(next());
+	    }
+
+	    public String nextLine() throws IOException
+	    {
+	        String str = br.readLine();
+	        return str;
+	    }
+	}
+}
+",0
+cdb801a1,ed610dc9,"//package codeforces;	
+import java.io.*;
+import java.util.*;
+public class Solution {
+	static class FastReader {
+		BufferedReader br;
+		StringTokenizer st;
+
+		public FastReader() {
+			br = new BufferedReader(new InputStreamReader(System.in));
+		}
+
+		String next() {
+			while (st == null || !st.hasMoreElements()) {
+				try {
+					st = new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			}
+			return st.nextToken();
+		}
+
+		int ni() {
+			return Integer.parseInt(next());
+		}
+
+		long nl() {
+			return Long.parseLong(next());
+		}
+
+		double nd() {
+			return Double.parseDouble(next());
+		}
+
+		String nextLine() {
+			String str = """";
+			try {
+				str = br.readLine();
+			} catch (IOException e) {
+				e.printStackTrace();
+			}
+			return str;
+		}
+	}
+
+	
+	public static void main(String[] args) throws java.lang.Exception {
+		FastReader fr = new FastReader();
+		PrintWriter out = new PrintWriter(System.out);
+		int t = fr.ni();
+		while(t-->0) {
+			
+			int n = fr.ni();
+			long arr [] = new long[n];
+			for(int i = 0 ; i < n ; i++) arr[i]= fr.nl();
+			long even = arr[0];
+			long odd = arr[1];
+			long minEven = arr[0];
+			long minOdd = arr[1];
+			long ans = (minEven*n) + (minOdd*n);
+			for(int i = 2 ; i < n ; i++) {
+				if((i&1) == 0) {
+					even += arr[i];
+					minEven = Math.min(minEven, arr[i]);
+					long a = (i+2)/2;
+					long b = (i+1)-a;
+					long temp = (even + (minEven*(n - a)));
+					temp += (odd + (minOdd*(n - b)));
+					ans = Math.min(ans, temp);
+				}else {
+					odd += arr[i];
+					minOdd = Math.min(minOdd, arr[i]);
+					long a = (i+2)/2;
+					long b = (i+1)-a;
+					long temp = (even + (minEven*(n - a)));
+					temp += (odd + (minOdd*(n - b)));
+					ans = Math.min(ans, temp);
+					
+				}
+			}
+			out.println(ans);
+		}
+		out.close();
+	}
+}","/*
+ * akshaygupta26
+ */
+import java.io.BufferedReader; 
+import java.io.IOException; 
+import java.io.InputStreamReader; 
+import java.util.Scanner; 
+import java.util.Random;
+import java.util.Arrays;
+import java.util.StringTokenizer; 
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Collections;
+import java.util.*;
+public class C 
+{ 
+    public static void main(String[] args) 
+	{ 
+		FastReader sc=new FastReader(); 
+		StringBuffer ans=new StringBuffer();
+		int test=sc.nextInt();
+		while(test-->0)
+		{
+			int n=sc.nextInt();
+			long arr[]=new long[n];
+			for(int i=0;i<n;i++) {
+				arr[i]=sc.nextLong();
+			}
+			long nn=n;
+			long ep=1;
+			long op=1;
+			
+			long se=arr[0];
+			long so=arr[1];
+			
+			long sume=se;long sumo=so;
+			long minm = (se*nn) +(so*nn);
+			
+			for(int i=2;i<n;i++) {
+				if(i%2 == 0) {
+					++ep;
+					sume+=arr[i];
+					se=Math.min(se, arr[i]);
+				}
+				else {
+					++op;
+					sumo+=arr[i];
+					so=Math.min(so, arr[i]);
+				}
+				
+				long cost = (sume)+(se*(nn-ep));
+				cost+=((sumo)+(so*(nn-op)));
+				minm=Math.min(cost, minm);
+			}
+			ans.append(minm+""\n"");
+		
+		}
+		
+	    System.out.print(ans);
+	} 
+        
+    static final Random random=new Random();
+    
+	static void ruffleSort(int[] a) {
+		int n=a.length;//shuffle, then sort 
+		for (int i=0; i<n; i++) {
+			int oi=random.nextInt(n), temp=a[oi];
+			a[oi]=a[i]; a[i]=temp;
+		}
+		Arrays.sort(a);
+	}
+	
+	static void ruffleSort(long[] a) {
+		int n=a.length;//shuffle, then sort 
+		for (int i=0; i<n; i++) {
+			int oi=random.nextInt(n);
+			long temp=a[oi];
+			a[oi]=a[i]; a[i]=temp;
+		}
+		Arrays.sort(a);
+	}
+	
+	static class FastReader 
+	{ 
+		BufferedReader br; 
+		StringTokenizer st; 
+
+		public FastReader() 
+		{ 
+			br = new BufferedReader(new
+					InputStreamReader(System.in)); 
+		} 
+
+		String next() 
+		{ 
+			while (st == null || !st.hasMoreElements()) 
+			{ 
+				try
+				{ 
+					st = new StringTokenizer(br.readLine()); 
+				} 
+				catch (IOException e) 
+				{ 
+					e.printStackTrace(); 
+				} 
+			} 
+			return st.nextToken(); 
+		} 
+
+		int nextInt() 
+		{ 
+			return Integer.parseInt(next()); 
+		} 
+
+		long nextLong() 
+		{ 
+			return Long.parseLong(next()); 
+		} 
+
+		double nextDouble() 
+		{ 
+			return Double.parseDouble(next()); 
+		} 
+
+		String nextLine() 
+		{ 
+			String str = """"; 
+			try
+			{ 
+				str = br.readLine(); 
+			} 
+			catch (IOException e) 
+			{ 
+				e.printStackTrace(); 
+			} 
+			return str; 
+		} 
+	} 
+
+
+} 
+",0
+752ea9a5,b2ec0eff,"//package Codeforces;
+
+import java.io.*;
+import java.util.*;
+
+public class PheonixAndTowers
+{
+	public static void main(String[] args)throws Exception{ new PheonixAndTowers().run();} 
+	long mod=1000000000+7;
+//	int[][] ar;
+	void solve() throws Exception
+	{
+		
+		
+		for(int tt=ni();tt>0;tt--){
+
+			//int n = ni();
+			
+			
+			int n = ni();
+			int m =ni();
+			int x =ni();
+			
+			int[] a = new int[n];
+			for(int i=0;i<n;i++){
+				a[i] =ni();
+			}
+			PriorityQueue<Pair> pq = new PriorityQueue<>();
+			
+			for(int i=1;i<=m;i++) pq.add(new Pair(i));
+			out.println(""YES"");
+			for(int i:a){
+				
+				Pair r = pq.remove();
+				r.sum+=i;
+				pq.add(r);
+				out.print(r.id+"" "");
+				
+			}
+			out.println();
+			
+			
+			
+			
+			
+			
+			
+		}
+		
+	}
+	
+	class Pair implements Comparable<Pair>{
+		int id;
+		long sum=0;
+		public Pair(int i){
+			this.id=i;
+		}
+		@Override
+		public int compareTo(Pair o) {
+			
+			return Long.compare(this.sum, o.sum);
+		}
+		
+		
+	}
+	boolean issubset(int[] a,int k){
+		int n = a.length;
+		boolean[][]dp = new boolean[n+1][k+1];
+		
+		for(int i=0;i<=n;i++){
+			for(int j=0;j<=k;j++){
+				if(i==0) {dp[i][j] = false;continue;}
+				if(j==0){dp[i][j]= true; continue;}
+				if(a[i-1]<=j){
+					dp[i][j] = dp[i][j-a[i-1]] || dp[i-1][j];
+				}else{
+					dp[i][j] = dp[i-1][j];
+				}
+			}
+		}
+		
+		return dp[n][k];
+	}
+	
+	 void ruffleSort(int[] a) {
+		//ruffle
+		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;
+		}
+		
+		//then sort
+		Arrays.sort(a);
+	}
+
+	
+	/*FAST INPUT OUTPUT & METHODS BELOW*/
+	
+	private byte[] buf=new byte[1024];
+	private int index;
+	private InputStream in;
+	private int total;
+	private SpaceCharFilter filter;
+	PrintWriter out;
+	
+	int min(int... ar){int min=Integer.MAX_VALUE;for(int i:ar)min=Math.min(min, i);return min;}
+	long min(long... ar){long min=Long.MAX_VALUE;for(long i:ar)min=Math.min(min, i);return min;}
+	int max(int... ar) {int max=Integer.MIN_VALUE;for(int i:ar)max=Math.max(max, i);return max;}
+	long max(long... ar) {long max=Long.MIN_VALUE;for(long i:ar)max=Math.max(max, i);return max;}
+	
+	void shuffle(int a[]) {
+		ArrayList<Integer> al = new ArrayList<>();
+		for(int i=0;i<a.length;i++) 
+			al.add(a[i]);
+		
+		Collections.sort(al);
+		for(int i=0;i<a.length;i++) 
+			a[i]=al.get(i);
+	}
+	long lcm(long a,long b)
+	{
+		return (a*b)/(gcd(a,b));
+	}
+	
+	int gcd(int a, int b) 
+	{ 
+		if (a == 0) 
+			return b; 
+		return gcd(b%a, a); 
+	} 
+	long gcd(long a, long b) 
+	{ 
+		if (a == 0) 
+			return b; 
+		return gcd(b%a, a); 
+	}
+	/* for (1/a)%mod = ( a^(mod-2) )%mod  ----> use expo to calc -->(a^(mod-2)) */
+	long expo(long p,long q)  /*  (p^q)%mod   */
+	{
+		long z = 1;
+		while (q>0) {
+			if (q%2 == 1) {
+				z = (z * p)%mod;
+			}
+			p = (p*p)%mod;
+			q >>= 1;
+		}
+		return z;
+	}
+	void run()throws Exception
+	{
+		in=System.in; out = new PrintWriter(System.out);
+		solve();
+		out.flush();
+	}
+	private int scan()throws IOException
+	{
+		if(total<0)
+			throw new InputMismatchException();
+		if(index>=total)
+		{
+			index=0;
+			total=in.read(buf);
+			if(total<=0)
+				return -1;
+		}
+		return buf[index++];
+	}
+	private int ni() throws IOException 
+	{
+		int c = scan();
+		while (isSpaceChar(c))
+			c = scan();
+		int sgn = 1;
+		if (c == '-') {
+			sgn = -1;
+			c = scan();
+		}
+		int res = 0;
+		do {
+			if (c < '0' || c > '9')
+				throw new InputMismatchException();
+			res *= 10;
+			res += c - '0';
+			c = scan();
+		} while (!isSpaceChar(c));
+		return res * sgn;
+	}
+	private long nl() throws IOException 
+	{
+		long num = 0;
+		int b;
+		boolean minus = false;
+		while ((b = scan()) != -1 && !((b >= '0' && b <= '9') || b == '-'))
+			;
+		if (b == '-') {
+			minus = true;
+			b = scan();
+		}
+		
+		while (true) {
+			if (b >= '0' && b <= '9') {
+				num = num * 10 + (b - '0');
+			} else {
+				return minus ? -num : num;
+			}
+			b = scan();
+		}
+	}
+	private double nd() throws IOException{
+		return Double.parseDouble(ns());
+	}
+	private String ns() throws IOException {
+		int c = scan();
+		while (isSpaceChar(c))
+			c = scan();
+		StringBuilder res = new StringBuilder();
+		do {
+			if (Character.isValidCodePoint(c))
+				res.appendCodePoint(c);
+			c = scan();
+		} while (!isSpaceChar(c));
+		return res.toString();
+	}
+	private String nss() throws IOException
+	{
+		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+		return br.readLine();
+	}
+	private char nc() throws IOException 
+	{
+		int c = scan();
+		while (isSpaceChar(c))
+			c = scan();
+		return (char) c;
+	}
+	private boolean isWhiteSpace(int n)
+	{
+		if(n==' '||n=='\n'||n=='\r'||n=='\t'||n==-1)
+			return true;
+		return false;
+	}
+	private boolean isSpaceChar(int c) {
+		if (filter != null)
+			return filter.isSpaceChar(c);
+		return isWhiteSpace(c);
+	}
+	private interface SpaceCharFilter {
+		public boolean isSpaceChar(int ch);
+	}
+}
+
+
+
+","//Implemented By Aman Kotiyal Date:-02-May-2021  Time:-7:58:39 pm
+import java.io.*;
+import java.util.*;
+
+public class ques3
+{
+	public static void main(String[] args)throws Exception{ new ques3().run();} 
+	long mod=1000000000+7;
+	
+	void solve() throws Exception
+	{
+		for(int ii=ni();ii>0;ii--)
+		{
+			int n=ni();
+			int m=ni();
+			int x=ni();
+			long h[]=new long[n];
+			for (int i = 0; i <n; i++) 
+				h[i]=nl();
+			int dp[]=new int[n];
+			
+			PriorityQueue<long[]> pq=new PriorityQueue<long[]>(new Comparator<long[]>() {
+				public int compare(long[] x, long[] y) {
+					if(x[1]-y[1]>0)return 1;
+					if(x[1]-y[1]<0)return -1;
+					return 0;
+				}
+			});
+			for (int i = 1; i <=m; i++) 
+				pq.add(new long[] {i,0});
+			
+			for(int i=0;i<n;i++)
+			{
+				long tem[]=pq.poll();
+				tem[1]+=h[i];
+				dp[i]=(int)tem[0];
+				pq.add(tem);
+			}
+			long min=Integer.MAX_VALUE;
+			long max=Integer.MIN_VALUE;
+			while(!pq.isEmpty())
+			{
+				long tem[]=pq.poll();
+				min=min(min,tem[1]);
+				max=max(max,tem[1]);
+			}
+			if(max-min>x)
+			{
+				out.println(""NO"");
+			}
+			else
+			{
+				out.println(""YES"");
+				for (int i = 0; i < dp.length; i++) {
+					out.print(dp[i]+"" "");
+				}
+				out.println();
+			}
+		}
+	}
+	
+	
+	/*FAST INPUT OUTPUT & METHODS BELOW*/
+	
+	private byte[] buf=new byte[1024];
+	private int index;
+	private InputStream in;
+	private int total;
+	private SpaceCharFilter filter;
+	PrintWriter out;
+	
+	int min(int... ar){int min=Integer.MAX_VALUE;for(int i:ar)min=Math.min(min, i);return min;}
+	long min(long... ar){long min=Long.MAX_VALUE;for(long i:ar)min=Math.min(min, i);return min;}
+	int max(int... ar) {int max=Integer.MIN_VALUE;for(int i:ar)max=Math.max(max, i);return max;}
+	long max(long... ar) {long max=Long.MIN_VALUE;for(long i:ar)max=Math.max(max, i);return max;}
+	void reverse(int a[]){for(int i=0;i<a.length>>1;i++){int tem=a[i];a[i]=a[a.length-1-i];a[a.length-1-i]=tem;}}
+	void reverse(long a[]){for(int i=0;i<a.length>>1;i++){long tem=a[i];a[i]=a[a.length-1-i];a[a.length-1-i]=tem;}}
+	String reverse(String s){StringBuilder sb=new StringBuilder(s);sb.reverse();return sb.toString();}
+	
+	void shuffle(int a[]) {
+		ArrayList<Integer> al = new ArrayList<>();
+		for(int i=0;i<a.length;i++) 
+			al.add(a[i]);
+		
+		Collections.sort(al);
+		for(int i=0;i<a.length;i++) 
+			a[i]=al.get(i);
+	}
+	long lcm(long a,long b)
+	{
+		return (a*b)/(gcd(a,b));
+	}
+	
+	int gcd(int a, int b) 
+	{ 
+		if (a == 0) 
+			return b; 
+		return gcd(b%a, a); 
+	} 
+	long gcd(long a, long b) 
+	{ 
+		if (a == 0) 
+			return b; 
+		return gcd(b%a, a); 
+	}
+	/* for (1/a)%mod = ( a^(mod-2) )%mod  ----> use expo to calc -->(a^(mod-2)) */
+	long expo(long p,long q)  /*  (p^q)%mod   */
+	{
+		long z = 1;
+		while (q>0) {
+			if (q%2 == 1) {
+				z = (z * p)%mod;
+			}
+			p = (p*p)%mod;
+			q >>= 1;
+		}
+		return z;
+	}
+	void run()throws Exception
+	{
+		in=System.in; out = new PrintWriter(System.out);
+		solve();
+		out.flush();
+	}
+	private int scan()throws IOException
+	{
+		if(total<0)
+			throw new InputMismatchException();
+		if(index>=total)
+		{
+			index=0;
+			total=in.read(buf);
+			if(total<=0)
+				return -1;
+		}
+		return buf[index++];
+	}
+	private int ni() throws IOException 
+	{
+		int c = scan();
+		while (isSpaceChar(c))
+			c = scan();
+		int sgn = 1;
+		if (c == '-') {
+			sgn = -1;
+			c = scan();
+		}
+		int res = 0;
+		do {
+			if (c < '0' || c > '9')
+				throw new InputMismatchException();
+			res *= 10;
+			res += c - '0';
+			c = scan();
+		} while (!isSpaceChar(c));
+		return res * sgn;
+	}
+	private long nl() throws IOException 
+	{
+		long num = 0;
+		int b;
+		boolean minus = false;
+		while ((b = scan()) != -1 && !((b >= '0' && b <= '9') || b == '-'))
+			;
+		if (b == '-') {
+			minus = true;
+			b = scan();
+		}
+		
+		while (true) {
+			if (b >= '0' && b <= '9') {
+				num = num * 10 + (b - '0');
+			} else {
+				return minus ? -num : num;
+			}
+			b = scan();
+		}
+	}
+	private double nd() throws IOException{
+		return Double.parseDouble(ns());
+	}
+	private String ns() throws IOException {
+		int c = scan();
+		while (isSpaceChar(c))
+			c = scan();
+		StringBuilder res = new StringBuilder();
+		do {
+			if (Character.isValidCodePoint(c))
+				res.appendCodePoint(c);
+			c = scan();
+		} while (!isSpaceChar(c));
+		return res.toString();
+	}
+	private String nss() throws IOException
+	{
+		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+		return br.readLine();
+	}
+	private char nc() throws IOException 
+	{
+		int c = scan();
+		while (isSpaceChar(c))
+			c = scan();
+		return (char) c;
+	}
+	private boolean isWhiteSpace(int n)
+	{
+		if(n==' '||n=='\n'||n=='\r'||n=='\t'||n==-1)
+			return true;
+		return false;
+	}
+	private boolean isSpaceChar(int c) {
+		if (filter != null)
+			return filter.isSpaceChar(c);
+		return isWhiteSpace(c);
+	}
+	private interface SpaceCharFilter {
+		public boolean isSpaceChar(int ch);
+	}
+}
+",0
+6f02c6d9,ff34fab2,"
+import java.io.*;
+import java.util.*;
+
+public class Main {
+
+
+    static long mod = 1000000007;
+
+    static long inv(long a, long b) {
+        return 1 < a ? b - inv(b % a, a) * b / a : 1;
+    }
+
+    static long mi(long a) {
+        return inv(a, mod);
+    }
+
+    static InputReader sc = new InputReader(System.in);
+    static PrintWriter out = new PrintWriter(System.out);
+
+    public static void main(String[] args) throws IOException {
+
+        int t = sc.nextInt();
+        while (t-- > 0) {
+
+            int n = sc.nextInt();
+            int[] A = new int[n];
+
+            for (int i = 0; i < A.length; i++) {
+                A[i] = sc.nextInt();
+            }
+            String word = sc.next();
+            ArrayList<Integer> blue = new ArrayList<>();
+            ArrayList<Integer> red = new ArrayList<>();
+
+            for (int i = 0; i < word.length(); i++) {
+                if (word.charAt(i) == 'R') {
+                    red.add(A[i]);
+                } else {
+                    blue.add(A[i]);
+                }
+            }
+            Collections.sort(blue);
+            Collections.sort(red);
+
+            boolean possible = true;
+
+            int a = 1;
+            for (int i = 0; i < blue.size(); i++, a++) {
+                if (blue.get(i) < a) {
+                    possible = false;
+                    break;
+                }
+            }
+
+            for (int i = 0; i < red.size(); i++, a++) {
+                if (red.get(i) > a) {
+                    possible = false;
+                    break;
+                }
+            }
+
+            if (possible) out.println(""YES"");
+            else out.println(""NO"");
+
+
+        }
+        out.flush();
+        out.close();
+    }
+
+    static class InputReader {
+        BufferedReader reader;
+        StringTokenizer tokenizer;
+
+        public InputReader(InputStream stream) {
+            reader = new BufferedReader(new InputStreamReader(stream), 32768);
+            tokenizer = null;
+        }
+
+
+        String next() {
+            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
+                try {
+                    tokenizer = new StringTokenizer(reader.readLine());
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+            }
+            return tokenizer.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+
+        String nextLine() {
+            String str = """";
+            try {
+                str = reader.readLine();
+            } catch (IOException e) {
+                throw new RuntimeException(e);
+            }
+            return str;
+        }
+    }
+
+    public static void shuffle(int[] a) {
+        Random get = new Random();
+        for (int i = 0; i < a.length; i++) {
+            int r = get.nextInt(a.length);
+            int temp = a[i];
+            a[i] = a[r];
+            a[r] = temp;
+        }
+    }
+
+    public static void shuffle(long[] a) {
+        Random get = new Random();
+        for (int i = 0; i < a.length; i++) {
+            int r = get.nextInt(a.length);
+            long temp = a[i];
+            a[i] = a[r];
+            a[r] = temp;
+        }
+    }
+
+}
+","import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.PriorityQueue;
+import java.util.Queue;
+import java.util.Stack;
+import java.util.StringTokenizer;
+import java.util.TreeMap;
+import java.util.TreeSet;
+
+import java.io.*;
+ 
+public class Div2 {
+	
+	private static class MyScanner {
+	    BufferedReader br;
+	    StringTokenizer st;
+
+	    public MyScanner() {
+	       br = new BufferedReader(new InputStreamReader(System.in));
+	    }
+
+	    String next() {
+	        while (st == null || !st.hasMoreElements()) {
+	            try {
+	                st = new StringTokenizer(br.readLine());
+	            } catch (IOException e) {
+	                e.printStackTrace();
+	            }
+	        }
+	        return st.nextToken();
+	    }
+
+	    int nextInt() {
+	        return Integer.parseInt(next());
+	    }
+
+	    long nextLong() {
+	        return Long.parseLong(next());
+	    }
+
+	    double nextDouble() {
+	        return Double.parseDouble(next());
+	    }
+
+	    String nextLine(){
+	        String str = """";
+		  try {
+		     str = br.readLine();
+		  } catch (IOException e) {
+		     e.printStackTrace();
+		  }
+		  return str;
+	    }
+
+	 }
+
+	 public static String solution(int [] arr, int n, String st) 
+	 {
+        ArrayList<Integer> red = new ArrayList<>();
+        ArrayList<Integer> blue = new ArrayList<>();
+        
+        for(int i = 0; i<n; i++)
+        {
+        	if(st.charAt(i)=='R')
+        		red.add(arr[i]);
+        	else
+        		blue.add(arr[i]);
+        }
+	    	
+        Collections.sort(red);
+        Collections.sort(blue);
+        int cb = 1;
+        
+        for(int j = 0; j<blue.size(); j++)
+        {
+            if(blue.get(j)<cb)
+            	return ""NO"";
+            cb++;
+        }
+        
+        int cr = n;
+        for(int j = red.size()-1; j>=0; j--)
+        {
+            if(red.get(j)>cr)
+            	return ""NO"";
+            cr--;
+        }
+        
+        return ""YES"";
+
+	 }
+        
+private static PrintWriter out = new PrintWriter(System.out);
+
+public static void main (String[] args)
+{
+	MyScanner s =  new MyScanner();
+	  
+    int t = s.nextInt();
+    
+    for(int j = 0; j<t ; j++)
+    {
+    	int n = s.nextInt();
+    	int[] arr = new int[n];
+    	for(int i =0; i<n; i++)
+    		arr[i] = s.nextInt();
+    	
+    	String st = s.next();
+   
+    	out.println(solution(arr,n, st));
+    }
+    
+		     
+    out.flush();
+    out.close();
+    
+}
+}
+
+",1
+1be078c4,bb0949b3,"import java.util.*;
+import java.io.*;
+
+public class E_1547 {
+	public static void main(String[] args) throws Exception {
+		Scanner sc = new Scanner(System.in);
+		PrintWriter pw = new PrintWriter(System.out);
+		
+		int T = sc.nextInt();
+		while(T-->0) {
+			int n = sc.nextInt(), k = sc.nextInt();
+			int[] a = sc.nextIntArray(k);
+			int[] t = sc.nextIntArray(k);
+			
+			int[] array = new int[n];
+			Arrays.fill(array, Integer.MAX_VALUE);
+			for(int i = 0; i < k; i++)
+				array[a[i] - 1] = t[i];
+			
+			int[] pre = new int[n];
+			int[] post = new int[n];
+			
+			int prev = (int)2e9;
+			for(int i = 0; i < n; i++)
+				prev = pre[i] = Math.min(prev + 1, array[i]);
+			
+			prev = (int)2e9;
+			for(int i = n - 1; i >= 0; i--)
+				prev = post[i] = Math.min(prev + 1, array[i]);
+			
+			for(int i = 0; i < n; i++)
+				array[i] = Math.min(pre[i], post[i]);
+			
+			for(int i = 0; i < n; i++)
+				pw.print(array[i] + (i == n - 1 ? ""\n"" : "" ""));
+		}
+		
+		pw.flush();
+	}
+
+	public static class Scanner {
+		StringTokenizer st;
+		BufferedReader br;
+
+		public Scanner(InputStream system) {
+			br = new BufferedReader(new InputStreamReader(system));
+		}
+
+		public Scanner(String file) throws Exception {
+			br = new BufferedReader(new FileReader(file));
+		}
+
+		public String next() throws IOException {
+			while (st == null || !st.hasMoreTokens())
+				st = new StringTokenizer(br.readLine());
+			return st.nextToken();
+		}
+
+		public String nextLine() throws IOException {
+			return br.readLine();
+		}
+
+		public int nextInt() throws IOException {
+			return Integer.parseInt(next());
+		}
+
+		public double nextDouble() throws IOException {
+			return Double.parseDouble(next());
+		}
+
+		public char nextChar() throws IOException {
+			return next().charAt(0);
+		}
+
+		public long nextLong() throws IOException {
+			return Long.parseLong(next());
+		}
+
+		public int[] nextIntArray(int n) throws IOException {
+			int[] array = new int[n];
+			for (int i = 0; i < n; i++)
+				array[i] = nextInt();
+			return array;
+		}
+
+		public Integer[] nextIntegerArray(int n) throws IOException {
+			Integer[] array = new Integer[n];
+			for (int i = 0; i < n; i++)
+				array[i] = new Integer(nextInt());
+			return array;
+		}
+
+		public long[] nextLongArray(int n) throws IOException {
+			long[] array = new long[n];
+			for (int i = 0; i < n; i++)
+				array[i] = nextLong();
+			return array;
+		}
+
+		public double[] nextDoubleArray(int n) throws IOException {
+			double[] array = new double[n];
+			for (int i = 0; i < n; i++)
+				array[i] = nextDouble();
+			return array;
+		}
+
+		public static int[] shuffle(int[] a) {
+			int n = a.length;
+			Random rand = new Random();
+			for (int i = 0; i < n; i++) {
+				int tmpIdx = rand.nextInt(n);
+				int tmp = a[i];
+				a[i] = a[tmpIdx];
+				a[tmpIdx] = tmp;
+			}
+			return a;
+		}
+
+		public boolean ready() throws IOException {
+			return br.ready();
+		}
+
+		public void waitForInput() throws InterruptedException {
+			Thread.sleep(3000);
+		}
+	}
+}
+","import java.util.*;
+
+public class file
+{
+    public static void main(String[] args)
+    {
+        Scanner sc = new Scanner(System.in);
+        int t = sc.nextInt();
+        while(t!=0)
+        {
+            sc.nextLine();
+            int n = sc.nextInt();
+            int k = sc.nextInt();
+            int[] position = new int[k];
+            for(int i = 0;i < k;i++)
+            {
+                position[i] = sc.nextInt();
+            }
+            int[] temprature = new int[k];
+            for(int i = 0;i < k;i++)
+            {
+                temprature[i] = sc.nextInt();
+            }
+            int[] left = new int[n];
+            int[] right = new int[n];
+            int c[] = new int[n];
+            Arrays.fill(c, Integer.MAX_VALUE);
+            for(int i = 0;i < k;i++)
+            {
+                c[position[i]-1] = temprature[i];
+            }
+            long min = Integer.MAX_VALUE - 1;
+            for(int i = 0;i < n;i++)
+            {
+                min = Math.min(min+1, c[i]);
+                left[i] = (int)min;
+
+            }
+            min = Integer.MAX_VALUE - 1;
+            for(int i = n-1;i >= 0;i--)
+            {
+                min = Math.min(min+1, c[i]);
+                right[i] = (int)min;
+            }
+            for(int i = 0;i < n;i++)
+            {
+                System.out.print(Math.min(left[i], right[i])+"" "");
+            }
+            System.out.println();
+            t--;
+        }
+    }
+}",0
+01c915a2,480de7be,"			/*
+			TO LEARN
+			1-segment trees
+			2-euler tour
+		
+			*/
+			/*
+			TO SOLVE 
+			uva 1103
+			codeforces 722 kavi on pairing duty
+			*/
+			/*
+			bit manipulation shit
+			1-Computer Systems: A Programmer's Perspective
+			2-hacker's delight
+			3-(02-03-bits-ints)
+			4-machine-basics
+			5-Bits Manipulation tutorialspoint
+			*/
+			/*
+			TO WATCH
+			1-what is bitmasking by kartik arora youtube
+			*/
+			            import java.util.*;
+					    import java.math.*;
+					    import java.io.*; 
+					    import java.util.stream.Collectors;
+
+					       public class A{
+					     
+					  static InputStream inputStream = System.in;
+			            static FastScanner scan=new FastScanner();
+					     public static PrintWriter out = new PrintWriter (new BufferedOutputStream(System.out));
+	static final long p=29;
+	static final long mod=(long)1e9+9;
+	static int n,m;
+	static String spotty[],plain[];
+	static boolean check(int l)
+	{
+		 Map<Long,Set<Pair>>hashes=new HashMap<Long,Set<Pair>>();
+					    HashSet<Long>hashes2=new HashSet<Long>();
+					    long pow_p[]=new long[m];
+					    pow_p[0]=1;
+					    for(int i=1;i<m;i++)
+					    	pow_p[i]=(pow_p[i-1]*p);
+					    for(int i=0;i<n;i++)
+					    {
+					    	String s=plain[i];
+					    	long h[]=new long[m+1];
+					    	for(int j=0;j<m;j++)
+					    	{
+					    		h[j+1]=(h[j]+(s.charAt(j)-'a'+1)*pow_p[j]);
+					    	}
+					    	
+					    		for(int j=0;j<=m-l;j++)
+					    		{
+					    			long cur_h=(h[j+l]-h[j]);
+					    			cur_h=(cur_h*pow_p[m-j-1]);
+					    			if(hashes.containsKey(cur_h))
+					    				hashes.get(cur_h).add(new Pair(j,j+l));
+					    			else 
+					    			{
+					    				hashes.put(cur_h,new HashSet());
+					    				hashes.get(cur_h).add(new Pair(j,j+l));
+					    			}
+					    			//map.getOrDefault(cur_h,new ArrayList()).add(new Pair(j,j+1));
+					    			//hashes.put(cur_h,);
+					    		//	out.println(""FIR ""+cur_h);
+					    		}				    	
+					    }
+
+					        for(int i=0;i<n;i++)
+					    {
+					    	String s=spotty[i];
+					    	long h[]=new long[m+1];
+					    	for(int j=0;j<m;j++)
+					    	{
+					    		h[j+1]=(h[j]+(s.charAt(j)-'a'+1)*pow_p[j]);
+					    	}
+					    	
+					    		for(int j=0;j<=m-l;j++)
+					    		{
+					    			long cur_h=(h[j+l]-h[j]);
+					    			cur_h=(cur_h*pow_p[m-j-1]);
+
+					    			if(hashes.containsKey(cur_h)){
+					    				if(!hashes.get(cur_h).contains(new Pair(j,j+l)))
+					    					return true;
+					    			}
+					    			else{
+					    				out.println(j+"" ""+i);
+					    			 return true;
+					    			}
+					    		
+					    		}
+					    	
+					    }	
+					    return false;
+	}
+
+				public static void main(String[] args)  throws Exception 
+			      {
+				
+						///scan=new FastScanner(""cownomics.in"");
+					//out = new PrintWriter(""cownomics.out"");
+					 
+					 /*
+					 currently doing 
+					 1-digit dp
+					 2-ds like fenwick and interval tree and sparse table 
+					 */
+					 /*
+					 READING 
+					 1-Everything About Dynamic Programming codeforces
+					 2-DYNAMIC PROGRAMMING: FROM NOVICE TO ADVANCED topcoder
+					 3-Introduction to DP with Bitmasking codefoces
+					 4-Bit Manipulation hackerearth
+					 5-read more about mobious and inculsion-exclusion 
+					 */
+		
+
+
+
+					    int tt=1;
+					tt=scan.nextInt();
+					int T=tt;
+					/*Map<Integer,Pair>map=new HashMap<Integer,Pair>();
+					for(int i=1;i<=333333334;i++)
+					{
+						map.put(i+2*i,new Pair(i,2*i));
+						map.put(i+(2*(i+1)),new Pair(i,i+1));
+						map.put(i+1+(2*i),new Pair(i+1,i));
+					}*/
+
+				 outer:while(tt-->0)
+					    {
+					    int n=scan.nextInt();
+					   int cnt[][]=new int[n][5];
+					   String arr[]=new String[n];
+					   int sumlens=0;
+					   for(int i=0;i<n;i++)
+					   {
+					   	String s=scan.next();
+					   	sumlens+=s.length();
+					   	arr[i]=s;
+					   	for(int j=0;j<s.length();j++)
+					   		cnt[i][s.charAt(j)-'a']++;
+					   }
+					   int res=0;
+					   for(int to=0;to<5;to++)
+					   {
+					   	ArrayList<Pair>tmp=new ArrayList<Pair>();
+					   	int sumall=0;
+					   	for(int i=0;i<n;i++)
+					   		sumall+=cnt[i][to];
+					   	for(int i=0;i<n;i++)
+					   	{
+					   		int sum=0;
+					   		for(int j=0;j<5;j++)
+					   		{
+					   			if(j!=to)
+					   			{
+					   				sum+=cnt[i][j];
+					   			}
+					   		}
+					   		tmp.add(new Pair(arr[i].length()-sum,sum));
+					   	}
+					   	Collections.sort(tmp);
+					   	int THIS=sumall,THAT=sumlens-sumall;
+					   	//if(to==3)
+					  // 		out.println(tmp);
+					   	for(int i=0;i<tmp.size();i++)
+					   	{
+					   		if(THIS>THAT)
+					   		{
+					   		//	if(to==3)
+					   		//		out.println(""AHA ""+(n-i));
+					   			res=Math.max(res,n-i);
+					   			break;
+					   		}
+					   		THIS-=tmp.get(i).x;
+					   		THAT-=tmp.get(i).y;
+					   	}
+					   }
+					   out.println(res);
+					   
+					    
+
+					   
+
+					   
+					    	
+					    	
+			}
+			   out.close();
+		}
+		  	 
+			 		  
+					   
+					
+					static class special{
+						boolean bool;
+						int n;
+						//int id;
+						special(boolean bool,int n)
+						{
+							this.bool=bool;
+							this.n=n;
+						}
+						@Override
+						    public int hashCode() {
+					                int hash = 7;
+		    hash = 31 * hash + (int) n;
+		   
+		    return hash;
+					            }
+					              @Override
+					            public boolean equals(Object o){
+					                if (o == this) return true;
+					                if (o.getClass() != getClass()) return false;
+					                special t = (special)o;
+					                return t.bool == bool && t.n == n;
+					            }
+					}
+
+					   
+					     static long binexp(long a,long n)
+					    {
+					        if(n==0)
+					            return 1;
+					        long res=binexp(a,n/2);
+					        if(n%2==1)
+					            return res*res*a;
+					        else 
+					            return res*res;
+					    }
+					     
+					    static long powMod(long base, long exp, long mod) {
+					           if (base == 0 || base == 1) return base;
+					           if (exp == 0) return 1;
+					           if (exp == 1) return (base % mod+mod)%mod;
+					           long R = (powMod(base, exp/2, mod) % mod+mod)%mod;
+					           R *= R;
+					           R %= mod;
+					           if ((exp & 1) == 1) {
+					               return (base * R % mod+mod)%mod;
+					           }
+					           else return (R %mod+mod)%mod;
+					       }
+					    static double dis(double x1,double y1,double x2,double y2)
+					    {
+					        return Math.sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2));
+					    }
+					    static long mod(long x,long y)
+					        {
+					            if(x<0)
+					                x=x+(-x/y+1)*y;
+					            return x%y;
+					        }
+					     public static  long pow(long b, long e) {
+					                long r = 1;
+					                while (e > 0) {
+					                    if (e % 2 == 1) r = r * b ;
+					                    b = b * b;
+					                    e >>= 1;
+					                }
+					                return r;
+					            }
+					    private static void sort(long[] arr) {
+					            List<Long> list = new ArrayList<>();
+					            for (long object : arr) list.add(object);
+					            Collections.sort(list);
+					        //Collections.reverse(list);
+					            for (int i = 0; i < list.size(); ++i) arr[i] = list.get(i);
+					        }
+					    private static void sort2(long[] arr) {
+					            List<Long> list = new ArrayList<>();
+					            for (Long object : arr) list.add(object);
+					            Collections.sort(list);
+					        Collections.reverse(list);
+					            for (int i = 0; i < list.size(); ++i) arr[i] = list.get(i);
+					        }
+					     static class FastScanner
+			{
+			    private int BS = 1 << 16;
+			    private char NC = (char) 0;
+			    private byte[] buf = new byte[BS];
+			    private int bId = 0, size = 0;
+			    private char c = NC;
+			    private double cnt = 1;
+			    private BufferedInputStream in;
+			 
+			    public FastScanner() {
+			        in = new BufferedInputStream(System.in, BS);
+			    }
+			 
+			    public FastScanner(String s) {
+			        try {
+			            in = new BufferedInputStream(new FileInputStream(new File(s)), BS);
+			        } catch (Exception e) {
+			            in = new BufferedInputStream(System.in, BS);
+			        }
+			    }
+			 
+			    private char getChar() {
+			        while (bId == size) {
+			            try {
+			                size = in.read(buf);
+			            } catch (Exception e) {
+			                return NC;
+			            }
+			            if (size == -1) return NC;
+			            bId = 0;
+			        }
+			        return (char) buf[bId++];
+			    }
+			 
+			    public int nextInt() {
+			        return (int) nextLong();
+			    }
+			 
+			    public int[] nextInts(int N) {
+			        int[] res = new int[N];
+			        for (int i = 0; i < N; i++) {
+			            res[i] = (int) nextLong();
+			        }
+			        return res;
+			    }
+			 
+			    public long[] nextLongs(int N) {
+			        long[] res = new long[N];
+			        for (int i = 0; i < N; i++) {
+			            res[i] = nextLong();
+			        }
+			        return res;
+			    }
+			 
+			    public long nextLong() {
+			        cnt = 1;
+			        boolean neg = false;
+			        if (c == NC) c = getChar();
+			        for (; (c < '0' || c > '9'); c = getChar()) {
+			            if (c == '-') neg = true;
+			        }
+			        long res = 0;
+			        for (; c >= '0' && c <= '9'; c = getChar()) {
+			            res = (res << 3) + (res << 1) + c - '0';
+			            cnt *= 10;
+			        }
+			        return neg ? -res : res;
+			    }
+			 
+			    public double nextDouble() {
+			        double cur = nextLong();
+			        return c != '.' ? cur : cur + nextLong() / cnt;
+			    }
+			 
+			    public double[] nextDoubles(int N) {
+			        double[] res = new double[N];
+			        for (int i = 0; i < N; i++) {
+			            res[i] = nextDouble();
+			        }
+			        return res;
+			    }
+			 
+			    public String next() {
+			        StringBuilder res = new StringBuilder();
+			        while (c <= 32) c = getChar();
+			        while (c > 32) {
+			            res.append(c);
+			            c = getChar();
+			        }
+			        return res.toString();
+			    }
+			 
+			    public String nextLine() {
+			        StringBuilder res = new StringBuilder();
+			        while (c <= 32) c = getChar();
+			        while (c != '\n') {
+			            res.append(c);
+			            c = getChar();
+			        }
+			        return res.toString();
+			    }
+			 
+			    public boolean hasNext() {
+			        if (c > 32) return true;
+			        while (true) {
+			            c = getChar();
+			            if (c == NC) return false;
+			            else if (c > 32) return true;
+			        }
+			    }
+			}
+
+					     static class Pair implements Comparable<Pair>{
+					            public long x, y,z;
+					            public Pair(long x1, long y1,long z1) {
+					                x=x1;
+					                y=y1;
+					                z=z1;
+					            }
+					             public Pair(long x1, long y1) {
+					                x=x1;
+					                y=y1;
+					    
+					            }
+					            
+					            @Override
+					            public int hashCode() {
+					                return (int)(x + 31 * y);
+					            }
+					            public String toString() {
+					                return x + "" "" + y+"" ""+z;
+					            }
+					            @Override
+					            public boolean equals(Object o){
+					                if (o == this) return true;
+					                if (o.getClass() != getClass()) return false;
+					                Pair t = (Pair)o;
+					                return t.x == x && t.y == y&&t.z==z;
+					            }
+					    public int compareTo(Pair o)
+					    {
+					    	
+					    
+					    	return (int)((o.y-o.x)-(y-x));
+					     
+					        }
+					     
+					    }
+					    
+					    }
+
+					     
+","import java.util.StringTokenizer;
+import java.io.*;
+
+public class CF_1551c{
+    public static final void main(String[] args){
+        Kattio io= new Kattio();
+        int t= io.getInt();
+        while(t-->0){
+            int n= io.getInt();
+            int[][] ps= new int[5][n];
+            for(int i=0; i<n; i++){
+                String w= io.getWord();
+                int len= w.length();
+                // count letters
+                for(int j=0; j<len; j++)
+                    ps[w.charAt(j)-'a'][i]++;   
+                // calculate diffs letter-!letter
+                // e.g. a-!a = a-(a+b+c+d+e-a) = a-(len-a) = a + (a-len) = 2a-len
+                for(int k=0; k<5; k++)
+                    ps[k][i]+= ps[k][i]-len;   
+            }
+            //sort diffs
+            for(int k=0; k<5; k++)
+                mergeSort(ps[k]);
+            //calculate prefix sums of diffs (until they're non-positive)
+            //start from the end as sort is ascending
+            //pick largest index out of 5 letter at which sum of diffs is positive
+            int max= 0;
+            for(int k=0; k<5; k++){
+                if(ps[k][n-1]<=0) continue;
+                if(max==0) max= 1;
+                for(int i=2; i<=n; i++){
+                    ps[k][n-i]+= ps[k][n-i+1];
+                    if(ps[k][n-i]<=0) break;
+                    if(i>max) max= i;
+                }
+            }
+            io.println(max);
+        }
+        io.close();
+    }
+
+    // using mergeSort to avoid Java quicksort TLE hacks
+    static void mergeSort(int arr[]){
+        int n= arr.length;
+        for (int sz= 1; sz<=n-1; sz=2*sz){
+            for (int l= 0; l<n-1; l+=2*sz){
+                int m= Math.min(l + sz-1, n-1);
+                int r= Math.min(l + 2*sz-1, n-1);
+                int n1= m-l+1, n2= r-m;
+                int L[] = new int[n1];
+                for (int i= 0; i<n1; i++) L[i]= arr[l+i];
+                int R[] = new int[n2];
+                for (int j= 0; j<n2; j++) R[j]= arr[m+1+j];
+                int i= 0, j= 0, k= l;
+                for(;i<n1 && j<n2; k++){
+                    if(L[i]<=R[j]){arr[k]= L[i]; i++;}
+                    else{arr[k] = R[j]; j++;}
+                }
+                for(;i<n1; i++, k++) arr[k]= L[i];
+                for(;j<n2; j++, k++) arr[k]= R[j];
+            }
+        }
+    }    
+    
+    static class Kattio extends PrintWriter {
+        private BufferedReader r;
+        private String line, token;
+        private StringTokenizer st;
+    
+        public Kattio(){this(System.in);}
+        public Kattio(InputStream i){
+        super(new BufferedOutputStream(System.out));
+            r= new BufferedReader(new InputStreamReader(i));
+        }
+        public Kattio(InputStream i, OutputStream o){
+        super(new BufferedOutputStream(o));
+            r= new BufferedReader(new InputStreamReader(i));
+        }
+        public boolean isLineEnd(){
+            return !st.hasMoreTokens();
+        }
+        public boolean hasMoreTokens(){
+            return peekToken()!=null;
+        }
+        public int getInt(){
+            return Integer.parseInt(nextToken());
+        }
+        public double getDouble(){ 
+            return Double.parseDouble(nextToken());
+        }
+        public long getLong(){
+            return Long.parseLong(nextToken());
+        }
+        public String getWord(){
+            return nextToken();
+        }
+        public String getLine(){
+            try{if(!st.hasMoreTokens())
+                return r.readLine();
+            }catch(IOException e){}
+            return null;
+        }
+        private String peekToken(){
+            if(token==null) try {
+                while(st==null || !st.hasMoreTokens()) {
+                    line= r.readLine();
+                    if(line==null) return null;
+                    st= new StringTokenizer(line);
+                }
+                token= st.nextToken();
+            }catch(IOException e){}
+            return token;
+        }
+        private String nextToken() {
+            String ans= peekToken();
+            token= null;
+            return ans;
+        }
+    }
+}
+",0
+6be98ece,e1c4f3db,"import java.util.*;
+
+public class CF763C {
+	private static final int MAX = 1000000001;
+	private static final int MIN = 0;
+
+	public static final void main(String ...args) {
+		Scanner sc = new Scanner(System.in);
+
+		int t = sc.nextInt();
+
+		while (t-- > 0) {
+			int n = sc.nextInt();
+			int[] h = new int[n];
+			int i, b = MAX, e = MIN;
+			for (i = 0; i < n; i++) {
+				h[i] = sc.nextInt();
+				if (b > h[i])
+					b = h[i];
+				if (e < h[i])
+					e = h[i];
+			}
+
+			int[] s = new int[n];
+			int c, d, ans = b;
+
+			// System.out.println(b + "" "" + e);
+
+			while (b <= e) {
+				c = (b + e) / 2;
+				// System.out.println(c);
+				// sc.next();
+				for (i = 0; i < n; i++) {
+					s[i] = 0;
+				}
+
+				for (i = n - 1; i >= 2; i--) {
+					if (h[i] + s[i] < c) {
+						e = c - 1;
+						break;
+					} else {
+						d = Math.min(h[i], h[i] + s[i] - c) / 3;
+						s[i - 1] += d;
+						s[i - 2] += 2 * d;
+					}
+				}
+				// System.out.println(i);
+				if (i == 1) {
+					if (h[i] + s[i] < c || h[i - 1] + s[i - 1] < c) {
+						e = c - 1;
+					} else {
+						ans = c;
+						b = c + 1;	
+					}
+				}
+			}
+			System.out.println(ans);
+		}
+	}
+}","import java.util.*;
+
+public class BalancedStoneHeaps {
+
+    public static boolean check(int n, int x, int[] h) {
+        int[] c_h = new int[n];
+        for (int i = 0; i < n; i++)
+            c_h[i] = h[i];
+        for (int i = n - 1; i >= 2; i--) {
+            if (c_h[i] < x)
+                return false;
+            int d = Math.min(h[i], c_h[i] - x) / 3;
+            c_h[i - 1] += d;
+            c_h[i - 2] += 2 * d;
+        }
+        return c_h[0] >= x && c_h[1] >= x;
+    }
+
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        int t = sc.nextInt();
+        while (t-- > 0) {
+            int n = sc.nextInt();
+            int[] h = new int[n];
+            int max = Integer.MIN_VALUE;
+            for (int i = 0; i < n; i++) {
+                h[i] = sc.nextInt();
+                if (h[i] > max) {
+                    max = h[i];
+                }
+            }
+            int l = 0;
+            int r = max;
+            while (l < r) {
+                int mid = l + (r - l + 1) / 2;
+                if (check(n, mid, h)) {
+                    l = mid;
+                } else {
+                    r = mid - 1;
+                }
+            }
+            System.out.println(l);
+        }
+    }
+}",0
+2e1109d7,e7000ac2,"import java.io.OutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.PrintWriter;
+import java.util.Arrays;
+import java.util.InputMismatchException;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.io.InputStream;
+
+
+public class Main {
+    public static void main(String[] args) {
+        InputStream inputStream = System.in;
+        OutputStream outputStream = System.out;
+        FastReader in = new FastReader(inputStream);
+        PrintWriter out = new PrintWriter(outputStream);
+        DArmchairs solver = new DArmchairs();
+        solver.solve(1, in, out);
+        out.close();
+    }
+
+    static class DArmchairs {
+        ArrayList<Integer>[] arr;
+        long[][] dp;
+
+        public void solve(int testNumber, FastReader in, PrintWriter out) {
+            int n = in.nextInt();
+            int[] a = in.readArray(n);
+
+            int mx = 5001;
+            dp = new long[mx][mx];
+            for (int i = 0; i < mx; ++i) {
+                Arrays.fill(dp[i], -1);
+            }
+
+            arr = new ArrayList[2];
+            for (int i = 0; i < 2; ++i) {
+                arr[i] = new ArrayList<>();
+            }
+
+            for (int i = 0; i < n; ++i) {
+                arr[a[i]].add(i);
+            }
+
+            out.println(go(0, 0));
+        }
+
+        long go(int i, int j) {
+            if (i == arr[1].size()) return 0;
+            if (j == arr[0].size()) return (long) 1e9;
+            if (dp[i][j] != -1) return dp[i][j];
+            long pick = Math.abs(arr[0].get(j) - arr[1].get(i)) + go(i + 1, j + 1);
+            long leave = go(i, j + 1);
+            dp[i][j] = Math.min(leave, pick);
+            return dp[i][j];
+        }
+
+    }
+
+    static class FastReader {
+        private InputStream stream;
+        private byte[] buf = new byte[1024];
+        private int curChar;
+        private int numChars;
+        private FastReader.SpaceCharFilter filter;
+
+        public FastReader(InputStream stream) {
+            this.stream = stream;
+        }
+
+        public int read() {
+            if (numChars == -1) throw new InputMismatchException();
+            if (curChar >= numChars) {
+                curChar = 0;
+                try {
+                    numChars = stream.read(buf);
+                } catch (IOException e) {
+                    throw new InputMismatchException();
+                }
+                if (numChars <= 0) return -1;
+            }
+            return buf[curChar++];
+        }
+
+        public int nextInt() {
+            int c = read();
+            while (isSpaceChar(c)) c = read();
+            int sgn = 1;
+            if (c == '-') {
+                sgn = -1;
+                c = read();
+            }
+            int res = 0;
+            do {
+                if (c < '0' || c > '9') throw new InputMismatchException();
+                res *= 10;
+                res += c - '0';
+                c = read();
+            }
+            while (!isSpaceChar(c));
+            return res * sgn;
+        }
+
+        public boolean isSpaceChar(int c) {
+            if (filter != null) return filter.isSpaceChar(c);
+            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
+        }
+
+        public int[] readArray(int size) {
+            int[] array = new int[size];
+            for (int i = 0; i < size; i++) array[i] = nextInt();
+            return array;
+        }
+
+        public interface SpaceCharFilter {
+            public boolean isSpaceChar(int ch);
+
+        }
+
+    }
+}
+
+","import java.io.OutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.PrintWriter;
+import java.util.Arrays;
+import java.util.InputMismatchException;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.io.InputStream;
+
+public class Main {
+    public static void main(String[] args) {
+        InputStream inputStream = System.in;
+        OutputStream outputStream = System.out;
+        FastReader in = new FastReader(inputStream);
+        PrintWriter out = new PrintWriter(outputStream);
+        DArmchairs solver = new DArmchairs();
+        solver.solve(1, in, out);
+        out.close();
+    }
+
+    static class DArmchairs {
+        ArrayList<Integer>[] arr;
+        long[][] dp;
+
+        public void solve(int testNumber, FastReader in, PrintWriter out) {
+            int n = in.nextInt();
+            int[] a = in.readArray(n);
+
+            int mx = 5001;
+            dp = new long[mx][mx];
+            for (int i = 0; i < mx; ++i) {
+                Arrays.fill(dp[i], -1);
+            }
+
+            arr = new ArrayList[2];
+            for (int i = 0; i < 2; ++i) {
+                arr[i] = new ArrayList<>();
+            }
+
+            for (int i = 0; i < n; ++i) {
+                arr[a[i]].add(i);
+            }
+
+            out.println(go(0, 0));
+        }
+
+        long go(int i, int j) {
+            if (i == arr[1].size()) return 0;
+            if (j == arr[0].size()) return (long) 1e9;
+            if (dp[i][j] != -1) return dp[i][j];
+            long pick = Math.abs(arr[0].get(j) - arr[1].get(i)) + go(i + 1, j + 1);
+            long leave = go(i, j + 1);
+            dp[i][j] = Math.min(leave, pick);
+            return dp[i][j];
+        }
+
+    }
+
+    static class FastReader {
+        private InputStream stream;
+        private byte[] buf = new byte[1024];
+        private int curChar;
+        private int numChars;
+        private FastReader.SpaceCharFilter filter;
+
+        public FastReader(InputStream stream) {
+            this.stream = stream;
+        }
+
+        public int read() {
+            if (numChars == -1) throw new InputMismatchException();
+            if (curChar >= numChars) {
+                curChar = 0;
+                try {
+                    numChars = stream.read(buf);
+                } catch (IOException e) {
+                    throw new InputMismatchException();
+                }
+                if (numChars <= 0) return -1;
+            }
+            return buf[curChar++];
+        }
+
+        public int nextInt() {
+            int c = read();
+            while (isSpaceChar(c)) c = read();
+            int sgn = 1;
+            if (c == '-') {
+                sgn = -1;
+                c = read();
+            }
+            int res = 0;
+            do {
+                if (c < '0' || c > '9') throw new InputMismatchException();
+                res *= 10;
+                res += c - '0';
+                c = read();
+            }
+            while (!isSpaceChar(c));
+            return res * sgn;
+        }
+
+        public boolean isSpaceChar(int c) {
+            if (filter != null) return filter.isSpaceChar(c);
+            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
+        }
+
+        public int[] readArray(int size) {
+            int[] array = new int[size];
+            for (int i = 0; i < size; i++) array[i] = nextInt();
+            return array;
+        }
+
+        public interface SpaceCharFilter {
+            public boolean isSpaceChar(int ch);
+
+        }
+
+    }
+}
+
+",1
+1097b326,a60fba84,"// package com.company;
+
+import java.util.Scanner;
+
+public class Main {
+
+    public static void solution1(){
+        Scanner scanner = new Scanner(System.in);
+        int t = scanner.nextInt();
+        while (t-- != 0){
+            int n, k1, k2, w, b;
+            n = scanner.nextInt();
+            k1 = scanner.nextInt();
+            k2 = scanner.nextInt();
+            w = scanner.nextInt();
+            b = scanner.nextInt();
+            if (k1 < k2){
+                int temp = k1;
+                k1 = k2;
+                k2 = temp;
+            }
+            int white_dominoes = k2 + (k1 - k2) / 2;
+            int black_dominoes = (n - k1) + (k1 - k2) / 2;
+            if (white_dominoes >= w && black_dominoes >= b)
+            {
+                System.out.println(""YES"");
+            }
+            else
+                System.out.println(""NO"");
+        }
+        scanner.close();
+    }
+
+    public static void solution2(){
+        Scanner scanner = new Scanner(System.in);
+        int t = scanner.nextInt();
+        scanner.nextLine();
+        while (t-- != 0) {
+            String s;
+            s = scanner.nextLine();
+            boolean flag = true;
+            int first_ones = -1, last_zeroes = -1;
+            for (int i=0; i<s.length() - 1; i++){
+                if (s.charAt(i) == '1' && s.charAt(i+1) == '1'){
+                    first_ones = i;
+                    break;
+                }
+            }
+            for (int i=s.length() - 1; i>0; i--){
+                if (s.charAt(i) == '0' && s.charAt(i-1) == '0'){
+                    last_zeroes = i-1;
+                    break;
+                }
+            }
+            if (first_ones != -1 && last_zeroes != -1 && first_ones < last_zeroes) flag = false;
+            if (flag) System.out.println(""YES"");
+            else System.out.println(""NO"");
+        }
+        scanner.close();
+    }
+
+    public static void solution3(){
+        Scanner scanner = new Scanner(System.in);
+        int t = scanner.nextInt();
+        while (t-- > 0){
+            int n;
+            n = scanner.nextInt();
+            int[] costs = new int[n];
+            for (int i=0; i<n; i++) costs[i] = scanner.nextInt();
+            //starts with Even index 0
+            long minEven = costs[0];
+            long minOdd = costs[1];
+            long totalEven = minEven;
+            long totalOdd = minOdd;
+            long minCost = minEven * n + minOdd * n;
+            for (int i=2; i<n; i++){
+                if (i%2 == 1){
+                    minOdd = Math.min(minOdd, costs[i]);
+                    totalOdd += costs[i];
+                }
+                else{
+                    minEven = Math.min(minEven, costs[i]);
+                    totalEven += costs[i];
+                }
+                long this_cost = totalEven - minEven + minEven * (n - (i+2)/2 + 1) + totalOdd - minOdd + minOdd * (n - (i+1)/2 + 1);
+                minCost = Math.min(minCost, this_cost);
+            }
+            System.out.println(minCost);
+        }
+        scanner.close();
+    }
+
+    public static long power(int a, int b){
+        long ans = 1;
+        while (b > 0){
+            if (b%2 == 1){
+                ans *= a;
+            }
+            a *= a;
+            b >>= 1;
+        }
+        return ans;
+    }
+
+    public static void main(String[] args) {
+        solution3();
+    }
+}","/*input
+3
+2
+13 88
+3
+2 3 1
+5
+4 3 2 1 4
+
+*/
+import java.util.*;
+import java.lang.*;
+import java.io.*;
+
+public class Main
+{
+	static PrintWriter out;
+	static int MOD = 1000000007;
+	static FastReader scan;
+
+    /*-------- I/O using short named function ---------*/
+	public static String ns(){return scan.next();}
+	public static int ni(){return scan.nextInt();}
+	public static long nl(){return scan.nextLong();}
+	public static double nd(){return scan.nextDouble();}
+	public static String nln(){return scan.nextLine();}
+	public static void p(Object o){out.print(o);}
+	public static void ps(Object o){out.print(o + "" "");}
+	public static void pn(Object o){out.println(o);}
+    /*-------- for output of an array ---------------------*/
+     static void iPA(int arr []){
+     	 StringBuilder output = new StringBuilder();
+	     for(int i=0; i<arr.length; i++)output.append(arr[i] + "" "");out.println(output);
+	}
+	static void lPA(long arr []){
+	     StringBuilder output = new StringBuilder();
+	     for(int i=0; i<arr.length; i++)output.append(arr[i] + "" "");out.println(output);
+	}
+	static void sPA(String arr []){
+	     StringBuilder output = new StringBuilder();
+	     for(int i=0; i<arr.length; i++)output.append(arr[i] + "" "");out.println(output);
+	}
+	static void dPA(double arr []){
+	     StringBuilder output = new StringBuilder();
+	     for(int i=0; i<arr.length; i++)output.append(arr[i] + "" "");out.println(output);
+	}
+    /*-------------- for input in an array ---------------------*/
+	static void iIA(int arr[]){
+	     for(int i=0; i<arr.length; i++)arr[i] = ni();
+	}
+	static void lIA(long arr[]){
+	     for(int i=0; i<arr.length; i++)arr[i] = nl(); 
+	}
+	static void sIA(String arr[]){
+	     for(int i=0; i<arr.length; i++)arr[i] = ns(); 
+	}
+	static void dIA(double arr[]){
+	     for(int i=0; i<arr.length; i++)arr[i] = nd();
+	}
+	/*------------ for taking input faster ----------------*/
+     static class FastReader
+	{
+		BufferedReader br;
+		StringTokenizer st;
+
+		public FastReader()
+		{
+			br = new BufferedReader(new InputStreamReader(System.in));
+		}
+
+		String next()
+		{
+			while (st == null || !st.hasMoreElements())
+			{
+				try
+				{
+					st = new StringTokenizer(br.readLine());
+				}
+				catch (IOException e)
+				{
+					e.printStackTrace();
+				}
+			}
+			return st.nextToken();
+		}
+
+		int nextInt()
+		{
+			return Integer.parseInt(next());
+		}
+
+		long nextLong()
+		{
+			return Long.parseLong(next());
+		}
+
+		double nextDouble()
+		{
+			return Double.parseDouble(next());
+		}
+
+		String nextLine()
+		{
+			String str = """";
+			try
+			{
+				str = br.readLine();
+			}
+			catch (IOException e)
+			{
+				e.printStackTrace();
+			}
+			return str;
+		}
+	}
+
+	// Method to check if x is power of 2
+    static boolean isPowerOfTwo (int x) { return x!=0 && ((x&(x-1)) == 0);}
+    //Method to return lcm of two numbers
+    static int gcd(int a, int b){return a==0?b:gcd(b % a, a); }
+    //Method to count digit of a number
+    static int countDigit(long n){return (int)Math.floor(Math.log10(n) + 1);}
+
+    //Method for sorting
+	static void ruffle_sort(int[] a) {
+		//shandom_ruffle
+		Random r=new Random();
+		int n=a.length;
+		for (int i=0; i<n; i++) {
+			int oi=r.nextInt(n);
+			int temp=a[i];
+			a[i]=a[oi];
+			a[oi]=temp;
+		}
+		//sort
+		Arrays.sort(a);
+	}
+	//Method for checking if a number is prime or not
+	static boolean isPrime(int n) { 
+        if (n <= 1) return false; 
+        if (n <= 3) return true; 
+        if (n % 2 == 0 || n % 3 == 0) return false; 
+        for (int i = 5; i * i <= n; i = i + 6) 
+            if (n % i == 0 || n % (i + 2) == 0) 
+            return false; 
+        return true; 
+    } 
+
+	public static void main (String[] args) throws java.lang.Exception
+	{
+		OutputStream outputStream =System.out;
+        out =new PrintWriter(outputStream);
+        scan =new FastReader();
+		//for fast output sometimes
+		StringBuilder sb = new StringBuilder();
+		int t = ni();
+		while(t-->0){
+			int n = ni();
+			long arr[] = new long[n];
+			lIA(arr);
+			long ans = (long)(n*(arr[0] + arr[1]));
+			long sum = arr[0] + arr[1];
+			long emin = arr[0], omin = arr[1];
+			
+			for(int i=2; i<n; i++){
+				sum += arr[i];
+				if(i%2==0){
+					emin = Math.min(arr[i], emin);
+				}
+				else{
+					omin = Math.min(arr[i], omin);
+				}
+				long temp = sum - emin - omin;
+				if(i%2==0)
+					temp += (n-i/2)*emin + (n-i/2+1)*omin;
+				else
+					temp += (n-(i-1)/2)*(emin + omin);
+				ans = Math.min(ans, temp);
+
+			}
+			pn(ans);
+        }
+        out.flush();
+		out.close();
+	}
+	
+}
+
+",0
+3d06b643,6bcc5afd,"import java.io.*;
+import java.util.*;
+
+public class ArmChairs {
+    
+
+    public static int solution(int n, int[] arr) {
+
+        ArrayList<Integer> one = new ArrayList<Integer>();
+        ArrayList<Integer> zero = new ArrayList<Integer>();
+
+        for (int i = 0; i < n; i++) {
+            if (arr[i] == 1) {
+                one.add(i);
+            } else {
+                zero.add(i);
+            }
+        }
+
+        int[][] dp = new int[one.size() + 1][zero.size() + 1];
+
+        for (int i = 1; i <= one.size(); i++) {
+            dp[i][i] = dp[i - 1][i - 1] + Math.abs(one.get(i - 1) - zero.get(i - 1));
+            for (int j = i + 1; j <= zero.size(); j++) {
+                dp[i][j] = Math.min(dp[i][j - 1], dp[i - 1][j - 1] + Math.abs(one.get(i - 1) - zero.get(j - 1)));
+            }
+        }
+
+        return dp[one.size()][zero.size()];
+    }
+
+
+    public static void main(String[] args) throws IOException{
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        BufferedWriter log = new BufferedWriter(new OutputStreamWriter(System.out));
+
+        int n = Integer.parseInt(br.readLine());
+
+        String[] s = br.readLine().split("" "");
+        int[] arr = new int[n];
+        for (int i = 0; i < n; i++) {
+            arr[i] = Integer.parseInt(s[i]);
+        } 
+
+        log.write(Integer.toString(solution(n, arr)) + ""\n"");
+        log.flush();
+        
+    }
+
+}
+","import java.util.*;
+public class MyClass {
+    public static void main(String args[]) {
+     Scanner s=new Scanner(System.in);
+     int n=s.nextInt();
+     int a[]=new int[n];
+     ArrayList<Integer> lt1=new ArrayList<>();
+     ArrayList<Integer> lt0=new ArrayList<>();
+     for(int i=0;i<n;i++)
+     {
+         int l=s.nextInt();
+         if(l==0)
+         lt0.add(i+1);
+         else
+         lt1.add(i+1);
+     }
+     int dp[][]=new int[lt1.size()+1][lt0.size()+1];
+     for(int i=1;i<=lt1.size();i++)
+     {
+         dp[i][i]=dp[i-1][i-1]+Math.abs(lt0.get(i-1)-lt1.get(i-1));
+         for(int j=i+1;j<=lt0.size();j++)
+         {
+             dp[i][j]=Math.min(dp[i][j-1],dp[i-1][j-1]+Math.abs(lt1.get(i-1)-lt0.get(j-1)));
+         }
+     }
+     System.out.println(dp[lt1.size()][lt0.size()]);
+     
+    }
+}",1
+6f02c6d9,884f5678,"
+import java.io.*;
+import java.util.*;
+
+public class Main {
+
+
+    static long mod = 1000000007;
+
+    static long inv(long a, long b) {
+        return 1 < a ? b - inv(b % a, a) * b / a : 1;
+    }
+
+    static long mi(long a) {
+        return inv(a, mod);
+    }
+
+    static InputReader sc = new InputReader(System.in);
+    static PrintWriter out = new PrintWriter(System.out);
+
+    public static void main(String[] args) throws IOException {
+
+        int t = sc.nextInt();
+        while (t-- > 0) {
+
+            int n = sc.nextInt();
+            int[] A = new int[n];
+
+            for (int i = 0; i < A.length; i++) {
+                A[i] = sc.nextInt();
+            }
+            String word = sc.next();
+            ArrayList<Integer> blue = new ArrayList<>();
+            ArrayList<Integer> red = new ArrayList<>();
+
+            for (int i = 0; i < word.length(); i++) {
+                if (word.charAt(i) == 'R') {
+                    red.add(A[i]);
+                } else {
+                    blue.add(A[i]);
+                }
+            }
+            Collections.sort(blue);
+            Collections.sort(red);
+
+            boolean possible = true;
+
+            int a = 1;
+            for (int i = 0; i < blue.size(); i++, a++) {
+                if (blue.get(i) < a) {
+                    possible = false;
+                    break;
+                }
+            }
+
+            for (int i = 0; i < red.size(); i++, a++) {
+                if (red.get(i) > a) {
+                    possible = false;
+                    break;
+                }
+            }
+
+            if (possible) out.println(""YES"");
+            else out.println(""NO"");
+
+
+        }
+        out.flush();
+        out.close();
+    }
+
+    static class InputReader {
+        BufferedReader reader;
+        StringTokenizer tokenizer;
+
+        public InputReader(InputStream stream) {
+            reader = new BufferedReader(new InputStreamReader(stream), 32768);
+            tokenizer = null;
+        }
+
+
+        String next() {
+            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
+                try {
+                    tokenizer = new StringTokenizer(reader.readLine());
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+            }
+            return tokenizer.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+
+        String nextLine() {
+            String str = """";
+            try {
+                str = reader.readLine();
+            } catch (IOException e) {
+                throw new RuntimeException(e);
+            }
+            return str;
+        }
+    }
+
+    public static void shuffle(int[] a) {
+        Random get = new Random();
+        for (int i = 0; i < a.length; i++) {
+            int r = get.nextInt(a.length);
+            int temp = a[i];
+            a[i] = a[r];
+            a[r] = temp;
+        }
+    }
+
+    public static void shuffle(long[] a) {
+        Random get = new Random();
+        for (int i = 0; i < a.length; i++) {
+            int r = get.nextInt(a.length);
+            long temp = a[i];
+            a[i] = a[r];
+            a[r] = temp;
+        }
+    }
+
+}
+","import java.io.*;
+import java.util.*;
+import java.text.*;
+import java.math.*;
+import java.util.regex.*;
+
+public class JaiShreeRam{
+	static Scanner in=new Scanner();
+	static long mod = 1000000007;
+	static ArrayList<ArrayList<Integer>> adj;
+	public static void main(String[] args) throws Exception{
+		class Element{
+			int x;
+			char c;
+			public Element(int y,char k) {
+				x=y;
+				c=k;
+			}
+		}
+		int z=in.readInt();
+		while(z-->0) {
+			int n=in.readInt();
+			int a[]=nia(n);
+			char c[]=in.readString().toCharArray();
+			ArrayList<Integer> d=new ArrayList<>();
+			ArrayList<Integer> in=new ArrayList<>();
+			for(int i=0;i<n;i++) {
+				if(c[i]=='R') {
+					in.add(a[i]);
+				}
+				else {
+					d.add(a[i]);
+				}
+			}
+			String ans=""YES"";
+			Collections.sort(d);
+			int k=1;
+			for(int i:d) {
+				if(i<k) {
+					ans=""NO"";
+				}
+				k++;
+			}
+			Collections.sort(in);
+			for(int i=in.size()-1;i>=0;i--) {
+				if(in.get(i)>n) {
+					ans=""NO"";
+					break;
+				}
+				n--;
+			}
+			System.out.println(ans);
+		}
+	}
+	static long ans(long l,long r,long x,long y) {
+		long mid=(r-l)/2+l;
+		long a=mid%x;
+		long b=y%mid;
+		long c=0;
+		if(l>r) {
+			return 0;
+		}
+		if(a==b) {
+			return mid;
+		}
+		else if(a<b) {
+			c=ans(l,mid-1,x,y);
+			if(c==0) {
+				c=ans(mid+1,r,x,y);
+			}
+		}
+		else{
+			c=ans(l,mid-1,x,y);
+			if(c==0) {
+				c=ans(mid+1,r,x,y);
+			}
+		}
+		return c;
+	}
+	static int[] nia(int n){
+		int[] arr= new int[n];
+		int i=0;
+		while(i<n){
+			arr[i++]=in.readInt();
+		}
+		return arr;
+	}
+	static long[] nla(int n){
+		long[] arr= new long[n];
+		int i=0;
+		while(i<n){
+			arr[i++]=in.readLong();
+		}
+		return arr;
+	}
+	static int[] nia1(int n){
+		int[] arr= new int[n+1];
+		int i=1;
+		while(i<=n){
+			arr[i++]=in.readInt();
+		}
+		return arr;
+	}
+	static long gcd(long a, long b) {
+		if (b==0) return a;
+		return gcd(b, a%b);
+	}
+	static class Scanner{
+		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st=new StringTokenizer("""");
+		String readString() {
+			while (!st.hasMoreTokens())
+				try {
+					st=new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			return st.nextToken();
+		}
+		double readDouble() {
+			return Double.parseDouble(readString());
+		}
+		int readInt() {
+			return Integer.parseInt(readString());
+		}
+		long readLong() {
+			return Long.parseLong(readString());
+		}
+	}	
+}",1
+0d4d22e0,f898cee0,"
+
+import java.util.*;
+public class CodeForces {
+	static ArrayList<String>res;
+	public static void main(String[] args) {
+		Scanner input = new Scanner(System.in);
+		int test = input.nextInt();
+		while(test-->0){
+			int n = input.nextInt();
+			int m = input.nextInt();
+			char arr[][] = new char[n][m];
+			res = new ArrayList<>();
+			for(int i =0;i<n;i++){
+				for(int j =0;j<1;j++){
+					arr[i] = input.next().toCharArray();
+				}
+			}
+			for(int i =0;i<n-1;i++){
+				for(int j =0;j<m-1;j++){
+					int count =0;
+					if(arr[i+1][j] == '1')count++;
+					if(arr[i][j+1] == '1')count++;
+					if(arr[i][j] == '1')count++;
+					if(arr[i+1][j+1] == '1')count++;
+					if(count == 0)continue;
+					if(count == 1)one(arr,i,j);
+					if(count == 2)two(arr,i,j);
+					if(count == 3)three(arr,i,j);
+					if(count == 4)four(arr,i,j);
+				}
+			}
+			System.out.println(res.size());
+			for(String it:res)System.out.println(it);
+		}	
+	}
+	public static void one(char arr[][],int i,int j){
+		int row = i+2;
+		int col = j+2;
+		int count =0;
+		StringBuilder sb = new StringBuilder();
+		for(int x=i;x<row;x++){
+			for(int y = j;y<col;y++){
+				if(arr[x][y] == '1' ){
+					sb.append(x+1);
+					sb.append("" "");
+					sb.append(y+1);
+					arr[x][y] = '0';
+					sb.append("" "");
+				}else if(arr[x][y] == '0' && count<2){
+					sb.append(x+1);
+					sb.append("" "");
+					sb.append(y+1);
+					arr[x][y] = '1';
+					sb.append("" "");
+					count++;
+				}
+			}
+		}
+		res.add(sb.toString());
+		two(arr,i,j);
+	}
+	public static void two(char arr[][],int i,int j){
+			int row = i+2;
+			int col = j+2;
+			boolean ok = true;
+			StringBuilder sb = new StringBuilder();
+			for(int x=i;x<row;x++){
+				for(int y = j;y<col;y++){
+					if(arr[x][y] == '1' && ok){
+						sb.append(x+1);
+						sb.append("" "");
+						sb.append(y+1);
+						arr[x][y] = '0';
+						sb.append("" "");
+						ok = false;
+					}else if(arr[x][y] == '0'){
+						sb.append(x+1);
+						sb.append("" "");
+						sb.append(y+1);
+						arr[x][y] = '1';
+						sb.append("" "");
+					}
+				}
+			}
+			res.add(sb.toString());
+			three(arr,i,j);
+		}
+	public static void three(char arr[][],int i,int j){
+		StringBuilder sb = new StringBuilder();
+		if(arr[i][j] == '1'){
+			sb.append(i+1);
+			sb.append("" "");
+			sb.append(j+1);
+			arr[i][j] = '0';
+			sb.append("" "");
+		}
+		if(arr[i+1][j] == '1'){
+			sb.append(i+2);
+			sb.append("" "");
+			sb.append(j+1);
+			arr[i+1][j] = '0';
+			sb.append("" "");
+		}
+		if(arr[i][j+1] == '1'){
+			arr[i][j+1] ='0';
+			sb.append(i+1);
+			sb.append("" "");
+			sb.append(j+2);
+			sb.append("" "");
+		}
+		if(arr[i+1][j+1] == '1'){
+			arr[i+1][j+1] = '0';
+			sb.append(i+2);
+			sb.append("" "");
+			sb.append(j+2);
+		}
+		res.add(sb.toString());
+	}
+	public static void four(char arr[][],int i,int j){
+		int row = i+2;
+		int col = j+2;
+		int count =0;
+		StringBuilder sb = new StringBuilder();
+		for(int x=i;x<row;x++){
+			for(int y = j;y<col;y++){
+				if(count<3){
+					sb.append(x+1);
+					sb.append("" "");
+					sb.append(y+1);
+					arr[x][y] = '0';
+					sb.append("" "");
+					count++;
+				}
+			}
+		}
+		res.add(sb.toString());
+		one(arr,i,j);
+	}
+}
+
+
+
+/*
+1.make sure to include continue or return if u are handling a specific case separately!!!!
+and check the constraints of every alphabet(missed to check for case 0)!!!!!!!!!
+
+2.when u have transitions between states and its not dp try dfs (also think of topo sort)
+ */
+","import java.util.*;
+import java.io.*;
+public class C{
+    static class InputReader {
+
+        private final InputStream stream;
+        private final byte[] buf = new byte[8192];
+        private int curChar, snumChars;
+        private SpaceCharFilter filter;
+
+        public InputReader(InputStream stream) {
+            this.stream = stream;
+        }
+
+        public int snext() {
+            if (snumChars == -1)
+                throw new InputMismatchException();
+            if (curChar >= snumChars) {
+                curChar = 0;
+                try {
+                    snumChars = stream.read(buf);
+                } catch (IOException e) {
+                    throw new InputMismatchException();
+                }
+                if (snumChars <= 0)
+                    return -1;
+            }
+            return buf[curChar++];
+        }
+
+        public int nextInt() {
+            int c = snext();
+            while (isSpaceChar(c)) {
+                c = snext();
+            }
+            int sgn = 1;
+            if (c == '-') {
+                sgn = -1;
+                c = snext();
+            }
+            int res = 0;
+            do {
+                if (c < '0' || c > '9')
+                    throw new InputMismatchException();
+                res *= 10;
+                res += c - '0';
+                c = snext();
+            } while (!isSpaceChar(c));
+            return res * sgn;
+        }
+
+        public long nextLong() {
+            int c = snext();
+            while (isSpaceChar(c)) {
+                c = snext();
+            }
+            int sgn = 1;
+            if (c == '-') {
+                sgn = -1;
+                c = snext();
+            }
+            long res = 0;
+            do {
+                if (c < '0' || c > '9')
+                    throw new InputMismatchException();
+                res *= 10;
+                res += c - '0';
+                c = snext();
+            } while (!isSpaceChar(c));
+            return res * sgn;
+        }
+
+        public int[] nextIntArray(int n) {
+            int a[] = new int[n];
+            for (int i = 0; i < n; i++) {
+                a[i] = nextInt();
+            }
+            return a;
+        }
+
+        public String readString() {
+            int c = snext();
+            while (isSpaceChar(c)) {
+                c = snext();
+            }
+            StringBuilder res = new StringBuilder();
+            do {
+                res.appendCodePoint(c);
+                c = snext();
+            } while (!isSpaceChar(c));
+            return res.toString();
+        }
+
+        public String nextLine() {
+            int c = snext();
+            while (isSpaceChar(c))
+                c = snext();
+            StringBuilder res = new StringBuilder();
+            do {
+                res.appendCodePoint(c);
+                c = snext();
+            } while (!isEndOfLine(c));
+            return res.toString();
+        }
+
+        public boolean isSpaceChar(int c) {
+            if (filter != null)
+                return filter.isSpaceChar(c);
+            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
+        }
+
+        private boolean isEndOfLine(int c) {
+            return c == '\n' || c == '\r' || c == -1;
+        }
+
+        public interface SpaceCharFilter {
+            public boolean isSpaceChar(int ch);
+        }
+
+    }
+    static class OutputWriter {
+		private final PrintWriter writer;
+ 
+		public OutputWriter(OutputStream outputStream) {
+			writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
+		}
+ 
+		public OutputWriter(Writer writer) {
+			this.writer = new PrintWriter(writer);
+		}
+ 
+		public void print(Object...objects) {
+			for (int i = 0; i < objects.length; i++) {
+				if (i != 0)
+					writer.print(' ');
+				writer.print(objects[i]);
+			}
+		}
+ 
+		public void printLine(Object...objects) {
+			print(objects);
+			writer.println();
+		}
+ 
+		public void close() {
+			writer.close();
+		}
+ 
+		public void flush() {
+			writer.flush();
+		}
+ 
+		}
+    static int gcd(int a, int b) 
+    { 
+        if (a == 0) 
+            return b; 
+        return gcd(b % a, a); 
+    } 
+    static int mod = (int)(1e9+7);
+    public static long pow(long a,long b)
+    {
+        long ans = 1;
+        while(b> 0)
+        {
+            if((b & 1)==1){
+                ans = (ans*a) % mod; 
+            }
+            a = (a*a) % mod;
+            b = b>>1;
+        }
+        return ans;
+    }
+    static void sort(int[] a) {
+		ArrayList<Integer> l=new ArrayList<>();
+		for (int i:a) l.add(i);
+		Collections.sort(l);
+		for (int i=0; i<a.length; i++) a[i]=l.get(i);
+    }
+    static void flip(char[][] arr,int i,int j)
+    {
+        if(arr[i][j]=='1')
+            arr[i][j] = '0';
+        else
+            arr[i][j] = '1';
+    }
+    static void add2s(StringBuilder sb,int n,int m)
+    {
+        sb.append((n) +"" "" + (m-1) + "" ""  +(n-1) + "" "" + (m) + "" ""  +(n) + "" "" + (m)+""\n"");
+        sb.append((n-1) +"" "" + (m-1) + "" ""  +(n-1) + "" "" + (m) + "" ""  +(n) + "" "" + (m)+""\n"");
+    }
+    static void add3s(StringBuilder sb,int n,int m)
+    {
+        sb.append((n) +"" "" + (m-1) + "" ""  +(n-1) + "" "" + (m-1) + "" ""  +(n) + "" "" + (m)+""\n"");
+        sb.append((n-1) +"" "" + (m-1) + "" ""  +(n) + "" "" + (m-1) + "" ""  +(n-1) + "" "" + (m)+""\n"");
+    }
+    public static void main(String[] args) {
+        InputReader in = new InputReader(System.in);
+        OutputWriter out = new OutputWriter(System.out);
+        int t = in.nextInt();
+        while(t-- >0)
+        {
+            // out.printLine(""UAShd"");
+            int n = in.nextInt(),m = in.nextInt();
+            char[][] arr = new char[n][m];
+            for(int i=0;i<n;i++)
+                arr[i] = in.nextLine().toCharArray();
+            // boolean[][] flip = new boolean[n][m];
+            int nops = 0;
+            StringBuilder res = new StringBuilder();
+            //do till row n-1
+            for(int i=0;i<n-1;i++)
+            {
+                for(int j=0;j<m;j++)
+                {
+                    if(arr[i][j]=='1')
+                    {
+                        nops++;
+                        if(j==m-1)
+                        {
+                            res.append((i+1) + "" "" + (j+1) + "" "" + (i+2) + "" "" + (j+1) + "" "" + (i+2) + "" "" + (j) + ""\n"");
+                            flip(arr,i,j);
+                            flip(arr,i+1,j);
+                            flip(arr,i+1,j-1);
+                        }
+                        else
+                        {
+                            res.append((i+1) + "" "" + (j+1) + "" "" + (i+2) + "" "" + (j+1) + "" "" + (i+2) + "" "" + (j+2) + ""\n"");
+                            flip(arr,i,j);
+                            flip(arr,i+1,j);
+                            flip(arr,i+1,j+1);
+                        }
+                    }
+                }
+            }
+            // out.printLine(nops);
+            int i = n-2;
+            for(int j=0;j<m-1;j++)
+            {
+                char a = arr[i][j],b = arr[i+1][j];
+                if(a=='0' && b=='0')
+                {
+                    continue;
+                }
+                else if(a=='0' && b=='1')
+                {
+                    nops++;
+                    res.append((i+2) + "" "" + (j+1) + "" "" + (i+1) + "" "" + (j+2) + "" "" + (i+2) + "" "" + (j+2) + ""\n"");
+                    flip(arr,i+1,j);
+                    flip(arr,i,j+1);
+                    flip(arr,i+1,j+1);
+                }
+                else if(a=='1' && b=='0')
+                {
+                    nops++;
+                    res.append((i+1) + "" "" + (j+1) + "" "" + (i+1) + "" "" + (j+2) + "" "" + (i+2) + "" "" + (j+2) + ""\n"");
+                    flip(arr,i,j);
+                    flip(arr,i,j+1);
+                    flip(arr,i+1,j+1);
+                }
+                else
+                {
+                    nops++;
+                    res.append((i+2) + "" "" + (j+1) + "" "" + (i+1) + "" "" + (j+1) + "" "" + (i+2) + "" "" + (j+2) + ""\n"");
+                    flip(arr,i+1,j);
+                    flip(arr,i,j);
+                    flip(arr,i+1,j+1);
+                }
+            }
+            // out.printLine(nops);
+            char a = arr[n-2][m-1];
+            char b = arr[n-1][m-1];
+            if(a=='0' && b=='0')
+            {
+
+            }
+            else if(a=='1' && b=='0')
+            {
+                nops+=3;
+                res.append((n-1) + "" "" + (m) + "" "" + (n-1) + "" "" + (m-1) + "" "" + (n) + "" "" + (m-1)+""\n"");
+                add2s(res,n,m);
+            }
+            else if(a=='0' && b=='1')
+            {
+                nops+=3;
+                res.append((n) + "" "" + (m) + "" "" + (n-1) + "" "" + (m-1) + "" "" + (n) + "" "" + (m-1)+""\n"");
+                add2s(res,n,m);
+            }
+            else
+            {
+                nops+=2;
+                add3s(res,n,m);
+            }
+            // out.printLine(""UAShd"");
+            // for(i=0;i<n;i++)
+                // out.printLine(new String(arr[i]));
+            // if(nops>0)
+                // res.deleteCharAt(res.length()-1);
+            out.printLine(nops);
+            if(nops>0)
+                out.print(res);
+        }
+        out.flush();
+        out.close();
+    }
+}",0
+3dd65549,f229aa7f,"import java.util.*;
+import java.io.*;
+
+public class codeforces {
+	public static void main(String[] args) throws Exception {
+		int t=sc.nextInt();
+		while(t-->0) {
+			int n=sc.nextInt();
+			char[] a=sc.next().toCharArray();
+			char[] b=sc.next().toCharArray();
+			int e0=0;
+			int e1=0;
+			int o0=0;
+			int o1=0;
+			for(int i=0;i<n;i++) {
+				if(a[i]!=b[i]) {
+					if(a[i]=='1') {
+						e1++;
+					}else {
+						e0++;
+					}
+				}else {
+					if(a[i]=='1') {
+						o1++;
+					}else {
+						o0++;
+					}
+				}
+			}
+			int ans=Integer.MAX_VALUE;
+			
+			if(e1==e0) {
+				ans=Math.min(ans, e1+e0);
+			}
+			if(o1==o0+1) {
+				ans=Math.min(ans, o1+o0);
+			}
+//			pw.println(e0+"" ""+e1+"" ""+o0+"" ""+o1);
+			pw.println(ans==Integer.MAX_VALUE?-1:ans);
+		}
+		pw.close();
+	}
+
+	static class Scanner {
+		StringTokenizer st;
+		BufferedReader br;
+
+		public Scanner(InputStream s) {
+			br = new BufferedReader(new InputStreamReader(s));
+		}
+
+		public Scanner(FileReader r) {
+			br = new BufferedReader(r);
+		}
+
+		public String next() throws IOException {
+			while (st == null || !st.hasMoreTokens())
+				st = new StringTokenizer(br.readLine());
+			return st.nextToken();
+		}
+
+		public int nextInt() throws IOException {
+			return Integer.parseInt(next());
+		}
+
+		public long nextLong() throws IOException {
+			return Long.parseLong(next());
+		}
+
+		public String nextLine() throws IOException {
+			return br.readLine();
+		}
+
+		public double nextDouble() throws IOException {
+			String x = next();
+			StringBuilder sb = new StringBuilder(""0"");
+			double res = 0, f = 1;
+			boolean dec = false, neg = false;
+			int start = 0;
+			if (x.charAt(0) == '-') {
+				neg = true;
+				start++;
+			}
+			for (int i = start; i < x.length(); i++)
+				if (x.charAt(i) == '.') {
+					res = Long.parseLong(sb.toString());
+					sb = new StringBuilder(""0"");
+					dec = true;
+				} else {
+					sb.append(x.charAt(i));
+					if (dec)
+						f *= 10;
+				}
+			res += Long.parseLong(sb.toString()) / f;
+			return res * (neg ? -1 : 1);
+		}
+
+		public long[] nextlongArray(int n) throws IOException {
+			long[] a = new long[n];
+			for (int i = 0; i < n; i++)
+				a[i] = nextLong();
+			return a;
+		}
+
+		public Long[] nextLongArray(int n) throws IOException {
+			Long[] a = new Long[n];
+			for (int i = 0; i < n; i++)
+				a[i] = nextLong();
+			return a;
+		}
+
+		public int[] nextIntArray(int n) throws IOException {
+			int[] a = new int[n];
+			for (int i = 0; i < n; i++)
+				a[i] = nextInt();
+			return a;
+		}
+
+		public Integer[] nextIntegerArray(int n) throws IOException {
+			Integer[] a = new Integer[n];
+			for (int i = 0; i < n; i++)
+				a[i] = nextInt();
+			return a;
+		}
+
+		public boolean ready() throws IOException {
+			return br.ready();
+		}
+
+	}
+
+	static class pair implements Comparable<pair> {
+		long x;
+		long y;
+
+		public pair(long x, long y) {
+			this.x = x;
+			this.y = y;
+		}
+
+		public String toString() {
+			return x + "" "" + y;
+		}
+
+		public boolean equals(Object o) {
+			if (o instanceof pair) {
+				pair p = (pair) o;
+				return p.x == x && p.y == y;
+			}
+			return false;
+		}
+
+		public int hashCode() {
+			return new Long(x).hashCode() * 31 + new Long(y).hashCode();
+		}
+
+		public int compareTo(pair other) {
+			if (this.x == other.x) {
+				return Long.compare(this.y, other.y);
+			}
+			return Long.compare(this.x, other.x);
+		}
+	}
+
+	static class tuble implements Comparable<tuble> {
+		int x;
+		int y;
+		int z;
+
+		public tuble(int x, int y, int z) {
+			this.x = x;
+			this.y = y;
+			this.z = z;
+		}
+
+		public String toString() {
+			return x + "" "" + y + "" "" + z;
+		}
+
+		public int compareTo(tuble other) {
+			if (this.x == other.x) {
+				if (this.y == other.y) {
+					return this.z - other.z;
+				}
+				return this.y - other.y;
+			} else {
+				return this.x - other.x;
+			}
+		}
+	}
+
+	static long mod = 1000000007;
+	static Random rn = new Random();
+	static Scanner sc = new Scanner(System.in);
+	static PrintWriter pw = new PrintWriter(System.out);
+}","import java.util.*;
+import java.io.*;
+import java.math.*;
+
+public class cf {
+	static PrintWriter pw = new PrintWriter(System.out);
+
+	public static void main(String[] args) throws IOException, InterruptedException {
+		Scanner sc = new Scanner(System.in);
+		int t = sc.nextInt();
+		while (t-- > 0) {
+			int n = sc.nextInt();
+			char[] a = sc.next().toCharArray();
+			char[] b = sc.next().toCharArray();
+			int x = 0, y = 0, lit = 0,lit2 = 0;
+			for (int i = 0; i < n; i++) {
+				if (a[i] == '1')
+					lit++;
+				if (b[i] == '1')
+					lit2++;
+				if (a[i] == b[i])
+					x++;
+				else
+					y++;
+			}
+			if(lit == lit2 || n - lit + 1 == lit2) {
+				if (lit == lit2 && n - lit + 1 == lit2) {
+					pw.println(Math.min(x,y));
+				}else if(lit == lit2) {
+					pw.println(y);
+				}else {
+					pw.println(x);
+				}
+			}else {
+				pw.println(-1);
+			}
+		}
+		pw.close();
+	}
+
+	public static class tuble implements Comparable<tuble> {
+		int x;
+		int y;
+		int z;
+
+		public tuble(int x, int y, int z) {
+			this.x = x;
+			this.y = y;
+			this.z = z;
+		}
+
+		public String toString() {
+			return x + "" "" + y + "" "" + z;
+		}
+
+		public int compareTo(tuble other) {
+			if (this.x == other.x) {
+				if (this.y == other.y)
+					return this.z - other.z;
+				return this.y - other.y;
+			} else {
+				return this.x - other.x;
+			}
+		}
+	}
+
+	public static class pair implements Comparable<pair> {
+		int x;
+		int y;
+
+		public pair(int x, int y) {
+			this.x = x;
+			this.y = y;
+		}
+
+		public String toString() {
+			return x + "" "" + y;
+		}
+
+		public boolean equals(Object o) {
+			if (o instanceof pair) {
+				pair p = (pair) o;
+				return p.x == x && p.y == y;
+			}
+			return false;
+		}
+
+		public int hashCode() {
+			return new Integer(x).hashCode() * 31 + new Integer(y).hashCode();
+		}
+
+		public int compareTo(pair other) {
+			if (this.x == other.x) {
+				return Long.compare(this.y, other.y);
+			}
+			return Long.compare(this.x, other.x);
+		}
+	}
+
+	static class Scanner {
+		StringTokenizer st;
+		BufferedReader br;
+
+		public Scanner(InputStream s) {
+			br = new BufferedReader(new InputStreamReader(s));
+		}
+
+		public Scanner(FileReader r) {
+			br = new BufferedReader(r);
+		}
+
+		public String next() throws IOException {
+			while (st == null || !st.hasMoreTokens())
+				st = new StringTokenizer(br.readLine());
+			return st.nextToken();
+		}
+
+		public int nextInt() throws IOException {
+			return Integer.parseInt(next());
+		}
+
+		public long nextLong() throws IOException {
+			return Long.parseLong(next());
+		}
+
+		public String nextLine() throws IOException {
+			return br.readLine();
+		}
+
+		public double nextDouble() throws IOException {
+			return Double.parseDouble(next());
+		}
+
+		public boolean ready() throws IOException {
+			return br.ready();
+		}
+
+	}
+
+}",0
+44428e63,9debf95c,"import java.util.*;
+import java.io.*;
+
+public class C_Minimum_Grid_Path{
+    public static void main(String[] args) {
+        FastScanner s= new FastScanner();
+        StringBuilder res = new StringBuilder();
+        int t=s.nextInt();
+        int p=0;
+        while(p<t){
+       int n=s.nextInt();
+       int array[]= new int[n];
+       long sumodd[]= new long[n];
+       long sumeven []= new long[n];
+       long minodd[]= new long[n];
+       long mineven[]= new long[n];
+       long sume=0;
+       long sumo=0;
+       for(int i=0;i<n;i++){
+           array[i]=s.nextInt();
+           if(i%2==0){
+               sume+=array[i];
+               sumeven[i]=sume;
+               if(i==0){
+                   mineven[i]=array[i];
+               }
+               else{
+                   mineven[i]=Math.min(array[i],mineven[i-2]);
+               }
+           }
+           else{
+               sumo+=array[i];
+               sumodd[i]=sumo;
+               if(i==1){
+                minodd[i]=array[i];
+            }
+            else{
+                minodd[i]=Math.min(array[i],minodd[i-2]);
+            }
+           }
+       }
+       long ans=Long.MAX_VALUE;
+       for(int i=1;i<n;i++){
+           long temp=0;
+           if(i%2==0){
+               int num=i/2;
+              temp=(mineven[i]*(n-num))+(sumeven[i]-mineven[i])+(minodd[i-1]*(n-(num-1)))+(sumodd[i-1]-minodd[i-1]);
+              ans=Math.min(ans,temp);
+           }
+           else{
+               int num=i/2;
+               temp=(minodd[i]*(n-num))+(sumodd[i]-minodd[i])+(mineven[i-1]*(n-num))+(sumeven[i-1]-mineven[i-1]);
+               ans=Math.min(ans,temp);
+           }
+       }
+       res.append(ans+""\n"");
+       p++;
+    }
+    System.out.println(res);
+
+
+
+    }
+    static class FastScanner {
+		BufferedReader br;
+		StringTokenizer st;
+ 
+		public FastScanner(String s) {
+			try {
+				br = new BufferedReader(new FileReader(s));
+			} catch (FileNotFoundException e) {
+				// TODO Auto-generated catch block
+				e.printStackTrace();
+			}
+		}
+ 
+		public FastScanner() {
+			br = new BufferedReader(new InputStreamReader(System.in));
+		}
+ 
+		String nextToken() {
+			while (st == null || !st.hasMoreElements()) {
+				try {
+					st = new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					// TODO Auto-generated catch block
+					e.printStackTrace();
+				}
+			}
+			return st.nextToken();
+		}
+ 
+		int nextInt() {
+			return Integer.parseInt(nextToken());
+		}
+ 
+		long nextLong() {
+			return Long.parseLong(nextToken());
+		}
+ 
+		double nextDouble() {
+			return Double.parseDouble(nextToken());
+		}
+	}
+
+
+
+
+}","//    A Computer is Like a mischievous genie.
+//    It will give you exactly what you ask for,
+//    but not always what you want
+//    A code by Rahul Verma
+
+
+import java.io.BufferedOutputStream;
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.PriorityQueue;
+import java.util.Queue;
+import java.util.Stack;
+import java.util.StringTokenizer;
+import java.util.TreeMap;
+
+
+public class Main {
+
+
+    static class Clock {
+
+        protected long start, stop;
+
+        public void start() {
+            start = System.currentTimeMillis();
+        }
+
+        public void stop() {
+            stop = System.currentTimeMillis();
+        }
+
+        public String getTime() {
+            return ((stop - start) + "" ms"");
+        }
+    }
+
+
+    public static PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
+
+    static class FastReader {
+
+        BufferedReader br;
+        StringTokenizer st;
+
+        public FastReader() {
+            br = new BufferedReader(new
+                InputStreamReader(System.in));
+        }
+
+        String next() {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+
+        String[] nextSArray() {
+            String sr[] = null;
+            try {
+                sr = br.readLine().trim().split("" "");
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            return sr;
+        }
+
+        String nextLine() {
+            String str = """";
+            try {
+                str = br.readLine();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+
+            return str;
+        }
+    }
+
+
+    static long powmodulo(long a, long p) {
+        if (p == 0) {
+            return 1 % mod;
+        }
+        if (p == 1) {
+            return a % mod;
+        }
+        long ans = 1;
+        while (p > 0) {
+            if ((p & 1) > 0) {
+                ans = (ans * a) % mod;
+            }
+            a = (a * a) % mod;
+            p = p >> 1;
+        }
+        return ans % mod;
+    }
+
+
+    static long mod = 1000000007;
+
+    static long gcd(long a, long b) {
+        if (a == 0) {
+            return b;
+        }
+        return gcd(b % a, a);
+    }
+
+    static long fast_powerNumbers(long a, long n) {
+        if (n == 1) {
+            return a;
+        }
+        long ans = fast_powerNumbers(a, n / 2);
+        if (n % 2 == 0) {
+            return (ans * ans);
+        } else {
+            return ((ans * ans) * (a));
+        }
+    }
+
+
+    static void dfs_helper(int[][] arr, int i, int j, int team, int n, int m) {
+        arr[i][j] = team;
+        if (i - 1 >= 0 && arr[i - 1][j] == 1) {
+            dfs(arr, i - 1, j, team, n, m);
+        }
+        if (j - 1 >= 0 && arr[i][j - 1] == 1) {
+            dfs(arr, i, j - 1, team, n, m);
+        }
+        if (i + 1 < n && arr[i + 1][j] == 1) {
+            dfs(arr, i + 1, j, team, n, m);
+        }
+        if (j + 1 < m && arr[i][j + 1] == 1) {
+            dfs(arr, i, j + 1, team, n, m);
+        }
+
+    }
+
+    static void dfs(int[][] arr, int i, int j, int team, int n, int m) {
+        dfs_helper(arr, i, j, team, n, m);
+
+    }
+
+    static int parent[];
+    static int rank[];
+
+    static int find(int i) {
+        if (parent[i] == -1) {
+            parent[i] = i;
+            return i;
+        }
+
+        if (parent[i] == i) {
+            return i;
+        } else {
+            parent[i] = find(parent[i]);
+        }
+        return parent[i];
+
+    }
+
+    static void unite(int s1, int s2) {
+
+        if (rank[s1] > rank[s2]) {
+            parent[s2] = s1;
+            rank[s1] += rank[s2];
+        } else {
+            parent[s1] = s2;
+            rank[s2] += rank[s1];
+        }
+    }
+
+
+    public static long arr[];
+    public static int arr1[];
+
+//    static void seive(int n) {
+//        arr = new int[n + 1];
+//        arr[0] = arr[1] = 1;
+//        for (int i = 4; i <= n; i = i + 2) {
+//            arr[i] = 1;
+//        }
+//        for (int i = 3; i * i <= n; i = i + 2) {
+//            if (arr[i] == 0) {
+//                for (int j = i * i; j <= n; j = j + i) {
+//                    arr[j] = 1;
+//                }
+//
+//            }
+//        }
+//    }
+
+    static  void seive(int n)
+    {
+        arr1=new int[n+1];
+        arr1[0]=arr1[1]=1;
+        for (int i = 4; i <=n ; i+=2) {
+            arr1[i]=1;
+        }
+        for (int i = 3; i*i <=n ; i+=2) {
+            if (arr1[i] == 0)
+            {
+                for (int j = i*i; j <=n ; j+=i) {
+                    arr1[j]=1;
+                }
+            }
+        }
+
+    }
+
+    public static boolean ccw(Point a,Point b,Point c)
+    {
+        long s1=(c.x-b.x)*(b.y-a.y) ;
+        long s2 = (c.y-b.y)*(b.x-a.x);
+        if(s1<s2)
+            return true;
+        else
+            return false;
+
+    }
+    public static boolean col(Point a,Point b,Point c)
+    {
+        long s1=(c.x-b.x)*(b.y-a.y) ;
+        long s2 = (c.y-b.y)*(b.x-a.x);
+        if(s1==s2)
+            return true;
+        else
+            return false;
+    }
+    static class Point
+    {
+        long x,y;
+        Point(long x,long y)
+        {
+            this.x=x;
+            this.y=y;
+        }
+    }
+
+    public static void main(String[] args) throws Exception {
+        FastReader sc = new FastReader();
+
+        Clock clock = new Clock();
+        clock.start();
+       int t1=sc.nextInt();
+        for (int t = 0; t <t1 ; t++) {
+          int n=sc.nextInt();
+          long arr[]=new long[n];
+            for (int i = 0; i < n; i++) {
+                arr[i]=sc.nextLong();
+            }
+          long sum1=0;
+          long sum2=0;
+          long min1 =Long.MAX_VALUE;
+          long min2 =Long.MAX_VALUE;
+          long brr[]=new long[n];
+            for (int i = 0; i <n ; i+=2) {
+
+                int nn =i/2;
+                min1=Math.min(arr[i],min1);
+                sum1+=arr[i];
+                long x =(sum1-min1) + min1*(n-nn);
+               // System.out.println(x);
+               brr[i]=x;
+
+            }
+            for (int i = 1; i <n ; i+=2) {
+                int nn =i/2;
+
+                //System.out.println(x);
+                min2=Math.min(arr[i],min2);
+                sum2+=arr[i];
+                long x =(sum2-min2) + min2*(n-nn);
+                brr[i]=x;
+            }
+            long min=Long.MAX_VALUE;
+            for (int i = 1; i < n; i++) {
+                min=Math.min(brr[i]+brr[i-1],min);
+            }
+            out.println(min);
+            //out.println(Arrays.toString(brr));
+
+           // System.out.println(min1+"" ""+min2);
+
+        }
+        out.close();
+
+
+    }
+
+
+}
+
+class Trio{
+    int a,i1,i2;
+    Trio(int a,int i1,int i2)
+    {
+        this.a=a;
+        this.i1=i1;
+        this.i2=i2;
+    }
+}
+
+class Pair{
+
+    int a,b;
+    Pair(int a,int b)
+    {
+        this.a=a;
+        this.b=b;
+    }
+}
+class DSU
+{
+    int parent[];
+    int rank[];
+    long arr[] = Main.arr;
+    long sum[] ;
+    DSU(int n)
+    {
+        this.parent=new int[n];
+        this.rank=new int[n];
+        sum=new long[n];
+        Arrays.fill(parent,-1);
+        Arrays.fill(rank,1);
+        for (int i = 0; i <n ; i++) {
+            sum[i]=arr[i];
+        }
+    }
+
+    int find(int s1)
+    {
+        if(parent[s1]==-1)
+            return s1;
+        return parent[s1]=find(parent[s1]);
+    }
+
+    void unite(int s1,int s2)
+    {
+        int p1=this.find(s1);
+        int p2=this.find(s2);
+        if(p1==p2)
+            return;
+        if(rank[p1]>rank[p2])
+        {
+            parent[p2]=p1;
+            rank[p1]+=rank[p2];
+            // System.out.println(arr[p2]);
+
+            sum[p1]+=sum[p2];
+            //sum[p2]+=sum[p1];
+
+        }
+        else
+        {
+            parent[p1]=p2;
+            rank[p2]+=rank[p1];
+            //System.out.println(arr[p1]);
+            sum[p2]+=sum[p1];
+            //sum[p1]+=sum[p2];
+        }
+    }
+
+
+}
+
+class Gaph {
+
+    HashMap<Integer, ArrayList<Integer>> hm;
+
+    Gaph() {
+        hm = new HashMap<>();
+    }
+
+    Gaph(int n) {
+
+        hm = new HashMap<>();
+        for (int i = 0; i < n; i++) {
+            hm.put(i, new ArrayList<Integer>());
+        }
+    }
+
+    // function for adding an edge.................................................
+    public void addEdge(int a, int b, boolean isDir) {
+        if (isDir) {
+            if (hm.containsKey(a)) {
+                hm.get(a).add(b);
+            } else {
+                hm.put(a, new ArrayList<>(Arrays.asList(b)));
+            }
+        } else {
+            if (hm.containsKey(a)) {
+                hm.get(a).add(b);
+            } else if (!hm.containsKey(a)) {
+                hm.put(a, new ArrayList<>(Arrays.asList(b)));
+            }
+
+            if (hm.containsKey(b)) {
+                hm.get(b).add(a);
+            } else if (!hm.containsKey(b)) {
+                hm.put(b, new ArrayList<>(Arrays.asList(a)));
+            }
+        }
+    }
+
+
+}
+
+// out.println(al.toString().replaceAll(""[\\[|\\]|,]"",""""));
+
+
+",0
+18e2441c,43b10dec," 
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.OutputStream;
+import java.io.PrintWriter;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.StringTokenizer;
+import java.util.TreeMap;
+import java.util.Map;
+import java.util.HashMap;
+
+public class cf1515 {
+
+	public static void main(String[] args) {
+		InputStream inputStream = System.in;
+		OutputStream outputStream = System.out;
+		InputReader in = new InputReader(inputStream);
+		PrintWriter out = new PrintWriter(outputStream);
+		Task solver = new Task();
+		solver.solve(in, out);
+		out.close();
+	}
+
+	static class Task {
+		public void solve(InputReader in, PrintWriter out) {
+			int t = in.nextInt();
+			while (t-- != 0) {
+				int n = in.nextInt();
+				int m = in.nextInt();
+				int x = in.nextInt();
+				TreeMap<Integer, ArrayList<Integer>> map = new TreeMap<>();
+				for (int i = 0; i < n; i++) {
+					int j = in.nextInt();
+					if (!map.containsKey(j)) {
+						map.put(j, new ArrayList<Integer>());
+					}
+					map.get(j).add(i);
+				}
+				out.println(""YES"");
+				int[] ans = new int[n];
+				int sta = 0;
+				for (int s : map.keySet()) {
+					for (int i = 0; i < map.get(s).size(); i++) {
+						ans[map.get(s).get(i)] = (sta++) % m + 1;
+					}
+				}
+				for(int i=0;i<n;i++) {
+					out.print(ans[i]+"" "");
+				}
+				out.println();
+			}
+
+		}
+	}
+
+	static class InputReader {
+		public BufferedReader reader;
+		public StringTokenizer tokenizer;
+
+		public InputReader(InputStream stream) {
+			reader = new BufferedReader(new InputStreamReader(stream));
+			tokenizer = null;
+		}
+
+		public String next() {
+			while (tokenizer == null || !tokenizer.hasMoreElements()) {
+				try {
+					tokenizer = new StringTokenizer(reader.readLine());
+				} catch (IOException e) {
+					throw new RuntimeException(e);
+				}
+			}
+			return tokenizer.nextToken();
+		}
+
+		public int nextInt() {
+			return Integer.parseInt(next());
+		}
+
+		public long nextLong() {
+			return Long.parseLong(next());
+		}
+
+		public double nextDouble() {
+			return Double.parseDouble(next());
+		}
+	}
+}
+
+","// package eround101;
+
+import java.util.*;
+import java.io.*;
+import java.lang.*;
+import java.util.StringTokenizer;
+import java.util.concurrent.TimeUnit;
+
+public class C101 {
+
+    static HritikScanner sc = new HritikScanner();
+    static PrintWriter pw = new PrintWriter(System.out, true);
+    final static int MOD = (int) 1e9 + 7;
+    static StringBuilder sb = new StringBuilder();
+
+    public static void main(String[] args) {
+
+        int t = ni();
+        while (t-- > 0) {
+            solve();
+        }
+    }
+
+     static void solve() {
+         int n = ni();
+         int m = ni(), x = ni();
+         Map<Integer, ArrayList<Integer>> map = new TreeMap<>();
+         pl(""YES"");
+         for(int i = 0; i < n; i++)
+         {
+             int num = ni();
+             if(!map.containsKey(num))
+             {
+                 map.put(num, new ArrayList<Integer>());
+             }
+             map.get(num).add(i);
+         }
+         int[] ans = new int[n];
+         int q = 0;
+         for(int block : map.keySet())
+         {
+             for(int i = 0; i < map.get(block).size(); i++)
+             {
+                 ans[map.get(block).get(i)] = (q++)%m+1;
+             }
+         }
+         for(int ele : ans)
+         {
+             p(ele + "" "");
+         }
+         pl();
+     }
+    
+    
+    /////////////////////////////////////////////////////////////////////////////////
+    static int[] nextIntArray(int n) {
+        int[] arr = new int[n];
+        int i = 0;
+        while (i < n) {
+            arr[i++] = ni();
+        }
+        return arr;
+    }
+
+    static long[] nextLongArray(int n) {
+        long[] arr = new long[n];
+        int i = 0;
+        while (i < n) {
+            arr[i++] = nl();
+        }
+        return arr;
+    }
+
+    static int[] nextIntArray1(int n) {
+        int[] arr = new int[n + 1];
+        int i = 1;
+        while (i <= n) {
+            arr[i++] = ni();
+        }
+        return arr;
+    }
+
+    /////////////////////////////////////////////////////////////////////////////////
+    static int ni() {
+        return sc.nextInt();
+    }
+
+    static long nl() {
+        return sc.nextLong();
+    }
+
+    static double nd() {
+        return sc.nextDouble();
+    }
+
+    /////////////////////////////////////////////////////////////////////////////////
+    static void pl() {
+        pw.println();
+    }
+
+    static void p(Object o) {
+        pw.print(o);
+    }
+
+    static void pl(Object o) {
+        pw.println(o);
+    }
+
+    static void psb(StringBuilder sb) {
+        pw.print(sb);
+    }
+
+    static void pa(Object arr[]) {
+        for (Object o : arr) {
+            p(o);
+        }
+        pl();
+    }
+
+    static void pa(int arr[]) {
+        for (int o : arr) {
+            p(o);
+        }
+        pl();
+    }
+
+    static void pa(long arr[]) {
+        for (long o : arr) {
+            p(o);
+        }
+        pl();
+    }
+
+    static void pa(double arr[]) {
+        for (double o : arr) {
+            p(o);
+        }
+        pl();
+    }
+
+    static void pa(char arr[]) {
+        for (char o : arr) {
+            p(o);
+        }
+        pl();
+    }
+
+    static void pa(List list) {
+        for (Object o : list) {
+            p(o);
+        }
+        pl();
+    }
+
+    static void pa(Object[][] arr) {
+
+        for (int i = 0; i < arr.length; ++i) {
+            for (Object o : arr[i]) {
+                p(o);
+            }
+            pl();
+        }
+    }
+
+    static void pa(int[][] arr) {
+        for (int i = 0; i < arr.length; ++i) {
+            for (int o : arr[i]) {
+                p(o);
+            }
+            pl();
+        }
+    }
+
+    static void pa(long[][] arr) {
+        for (int i = 0; i < arr.length; ++i) {
+            for (long o : arr[i]) {
+                p(o);
+            }
+            pl();
+        }
+    }
+
+    static void pa(char[][] arr) {
+        for (int i = 0; i < arr.length; ++i) {
+            for (char o : arr[i]) {
+                p(o);
+            }
+            pl();
+        }
+    }
+
+    static void pa(double[][] arr) {
+        for (int i = 0; i < arr.length; ++i) {
+            for (double o : arr[i]) {
+                p(o);
+            }
+            pl();
+        }
+    }
+
+/////////////////////////////////////////////////////////////////////////////////
+    static void print(Object s) {
+        System.out.println(s);
+    }
+
+    /////////////////////////////////////////////////////////////////////////////////
+    //-----------HritikScanner class for faster input----------//
+    static class HritikScanner {
+
+        BufferedReader br;
+        StringTokenizer st;
+
+        public HritikScanner() {
+            br = new BufferedReader(new InputStreamReader(System.in));
+        }
+
+        String next() {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+
+        String nextLine() {
+            String str = """";
+            try {
+                str = br.readLine();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+        }
+    }
+
+    //////////////////////////////////////////////////////////////////
+    public static class Pair implements Comparable<Pair> {
+
+        int num, row,col;
+
+        Pair(int num, int row, int col) {
+            this.num = num;
+            this.row = row;
+            this.col = col;
+        }
+
+        public int get1() {
+            return num;
+        }
+
+        public int get2() {
+            return row;
+        }
+
+        public int compareTo(Pair A) {
+            return this.num - A.num;
+        }
+        
+        public String toString()
+        {
+            return num +"" ""+ row+"" ""+col;
+        }
+    }
+
+    //////////////////////////////////////////////////////////////////
+    // Function to return gcd of a and b time complexity O(log(a+b))
+    static long gcd(long a, long b) {
+        if (a == 0) {
+            return b;
+        }
+        return gcd(b % a, a);
+    }
+
+    // method to return LCM of two numbers 
+    static long lcm(int a, int b) {
+        return (a / gcd(a, b)) * b;
+    }
+
+    //////////////////////////////////////////////////////////////////
+    static boolean isPrime(long n) {
+        // Corner cases 
+        if (n <= 1) {
+            return false;
+        }
+        if (n <= 3) {
+            return true;
+        }
+
+        // This is checked so that we can skip  
+        // middle five numbers in below loop 
+        if (n % 2 == 0 || n % 3 == 0) {
+            return false;
+        }
+
+        for (long i = 5; i * i <= n; i = i + 6) {
+            if (n % i == 0 || n % (i + 2) == 0) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+    //////////////////////////////////////////////////////////////////
+
+    static boolean isPowerOfTwo(long n) {
+        if (n == 0) {
+            return false;
+        }
+
+        return (long) (Math.ceil((Math.log(n) / Math.log(2))))
+                == (long) (Math.floor(((Math.log(n) / Math.log(2)))));
+    }
+
+    public static long getFact(int n) {
+        long ans = 1;
+        while (n > 0) {
+            ans *= n;
+            ans %= MOD;
+            n--;
+        }
+        return ans;
+    }
+
+    public static long pow(long n, int pow) {
+        if (pow == 0) {
+            return 1;
+        }
+        long temp = pow(n, pow / 2) % MOD;
+        temp *= temp;
+        temp %= MOD;
+        if (pow % 2 == 1) {
+            temp *= n;
+        }
+        temp %= MOD;
+        return temp;
+
+    }
+
+    public static long nCr(int n, int r) {
+        long ans = 1;
+        int temp = n - r;
+        while (n > temp) {
+            ans *= n;
+            ans %= MOD;
+            n--;
+        }
+        ans *= pow(getFact(r) % MOD, MOD - 2) % MOD;
+        ans %= MOD;
+        return ans;
+    }
+
+    //////////////////////////////////////////////////////////////////
+    // method returns Nth power of A 
+    static double nthRoot(int A, int N) {
+
+        // intially guessing a random number between 
+        // 0 and 9 
+        double xPre = Math.random() % 10;
+
+        // smaller eps, denotes more accuracy 
+        double eps = 0.001;
+
+        // initializing difference between two 
+        // roots by INT_MAX 
+        double delX = 2147483647;
+
+        // xK denotes current value of x 
+        double xK = 0.0;
+
+        // loop untill we reach desired accuracy 
+        while (delX > eps) {
+            // calculating current value from previous 
+            // value by newton's method 
+            xK = ((N - 1.0) * xPre
+                    + (double) A / Math.pow(xPre, N - 1)) / (double) N;
+            delX = Math.abs(xK - xPre);
+            xPre = xK;
+        }
+
+        return xK;
+    }
+
+}
+",1
+3a318b43,90b71536,"import java.lang.reflect.Array;
+import java.util.*;
+import java.io.*;
+import java.util.regex.Pattern;
+
+public class B2 {
+
+    public static int getBit(int pos,int num){
+        int no = 1 << pos;
+        return no & num;
+    }
+    public static boolean palindrome(String s){
+        StringBuilder s1 = new StringBuilder();
+        for(int i=s.length();i>=0;i--){
+            s1.append(s.charAt(i));
+        }
+        String s2 = s1.toString();
+        if(s.equals(s2)){
+            return true;
+        }
+        return false;
+    }
+
+    public static void permutation(ArrayList<String> arr,int l, int r,String ans,HashMap<Character,Integer> map,char[] temp){
+        if(l>r){
+            //System.out.println(ans);
+            arr.add(ans);
+            return;
+        }
+        for(char c:temp) {
+            if (map.get(c) > 0) {
+                map.put(c, map.get(c) - 1);
+                permutation(arr, l + 1, r, ans + c, map,temp);
+                map.put(c, map.get(c) + 1);
+            }
+        }
+
+    }
+    public static long[] maxBeauty(HashMap[] arr, long[] lv,long[] rv,int start,int parent,boolean[] vis){
+        vis[start] = true;
+        long[] ans  = new long[2];
+       // System.out.println(start);
+        ArrayList<Integer> list = new ArrayList<Integer>(arr[start].keySet());
+        for(int node:list){
+            if(vis[node]==false) {
+                long[] curr = maxBeauty(arr,lv,rv,node,start,vis);
+                ans[0] += Math.max(curr[0] + Math.abs(lv[start]-lv[node]),curr[1] + Math.abs(lv[start]-rv[node]));
+                ans[1]  += Math.max(curr[0] + Math.abs(rv[start]-lv[node]),curr[1] + Math.abs(rv[start]-rv[node]));
+            }
+        }
+        return ans;
+    }
+
+    public static void main(String args[]) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        PrintWriter pw = new PrintWriter(System.out);
+        int tc = Integer.parseInt(br.readLine());
+        while (tc > 0) {
+            int n = Integer.parseInt(br.readLine());
+            boolean[] vis = new boolean[n+1];
+            HashMap[] arr = new HashMap[n+1];
+            for(int i=0;i<=n;i++){
+                arr[i] = new HashMap<Integer,Long>();
+            }
+            long[] lv = new long[n+1];
+            long[] rv = new long[n+1];
+            for(int i=1;i<=n;i++){
+                String[] s1 = br.readLine().split("" "");
+                lv[i] = Long.valueOf(s1[0]);
+                rv[i] = Long.valueOf(s1[1]);
+            }
+            for(int i=0;i<n-1;i++){
+                String[] s1 = br.readLine().split("" "");
+                int u = Integer.valueOf(s1[0]);
+                int v = Integer.valueOf(s1[1]);
+                arr[u].put(v,1);
+                arr[v].put(u,1);
+            }
+
+            long[] ans  = maxBeauty(arr,lv,rv,1,0,vis);
+
+            //System.out.println(maxBeauty(graph,lvrv,1,0,0));
+            //System.out.println(maxBeauty(graph,lvrv,1,1,0));
+
+            pw.println(Math.max(ans[1],ans[0]));
+            tc--;
+        }
+        pw.close();
+    }
+}","import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.util.InputMismatchException;
+import java.util.*;
+import java.io.*;
+import java.lang.*;
+public class Main{
+    public static class InputReader {
+        private InputStream stream;
+        private byte[] buf = new byte[1024];
+        private int curChar;
+        private int numChars;
+        private InputReader.SpaceCharFilter filter;
+        private BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+     
+        public InputReader(InputStream stream) {
+            this.stream = stream;
+        }
+     
+        public int read() {
+            if (numChars==-1)
+                throw new InputMismatchException();
+     
+            if (curChar >= numChars) {
+                curChar = 0;
+                try {
+                    numChars = stream.read(buf);
+                }
+                catch (IOException e) {
+                    throw new InputMismatchException();
+                }
+     
+                if(numChars <= 0)
+                    return -1;
+            }
+            return buf[curChar++];
+        }
+     
+        public String nextLine() {
+            String str = """";
+            try {
+                str = br.readLine();
+            }
+            catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+        }
+        public int nextInt() {
+            int c = read();
+     
+            while(isSpaceChar(c))
+                c = read();
+     
+            int sgn = 1;
+     
+            if (c == '-') {
+                sgn = -1;
+                c = read();
+            }
+     
+            int res = 0;
+            do {
+                if(c<'0'||c>'9')
+                    throw new InputMismatchException();
+                res *= 10;
+                res += c - '0';
+                c = read();
+            }
+            while (!isSpaceChar(c));
+     
+            return res * sgn;
+        }
+     
+        public long nextLong() {
+            int c = read();
+            while (isSpaceChar(c))
+                c = read();
+            int sgn = 1;
+            if (c == '-') {
+                sgn = -1;
+                c = read();
+            }
+            long res = 0;
+     
+            do {
+                if (c < '0' || c > '9')
+                    throw new InputMismatchException();
+                res *= 10;
+                res += c - '0';
+                c = read();
+            }
+            while (!isSpaceChar(c));
+            return res * sgn;
+        }
+     
+        public double nextDouble() {
+            int c = read();
+            while (isSpaceChar(c))
+                c = read();
+            int sgn = 1;
+            if (c == '-') {
+                sgn = -1;
+                c = read();
+            }
+            double res = 0;
+            while (!isSpaceChar(c) && c != '.') {
+                if (c == 'e' || c == 'E')
+                    return res * Math.pow(10, nextInt());
+                if (c < '0' || c > '9')
+                    throw new InputMismatchException();
+                res *= 10;
+                res += c - '0';
+                c = read();
+            }
+            if (c == '.') {
+                c = read();
+                double m = 1;
+                while (!isSpaceChar(c)) {
+                    if (c == 'e' || c == 'E')
+                        return res * Math.pow(10, nextInt());
+                    if (c < '0' || c > '9')
+                        throw new InputMismatchException();
+                    m /= 10;
+                    res += (c - '0') * m;
+                    c = read();
+                }
+            }
+            return res * sgn;
+        }
+     
+        public String readString() {
+            int c = read();
+            while (isSpaceChar(c))
+                c = read();
+            StringBuilder res = new StringBuilder();
+            do {
+                res.appendCodePoint(c);
+                c = read();
+            }
+            while (!isSpaceChar(c));
+     
+            return res.toString();
+        }
+     
+        public boolean isSpaceChar(int c) {
+            if (filter != null)
+                return filter.isSpaceChar(c);
+            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
+        }
+     
+        public String next() {
+            return readString();
+        }
+     
+        public interface SpaceCharFilter {
+            public boolean isSpaceChar(int ch);
+        }
+    }
+ 
+    static long gcd(long a, long b){
+        if (a == 0)
+            return b;  
+        return gcd(b % a, a);  
+    }
+    static long lcm(long a, long b)  {
+        return (a*b)/gcd(a, b);  
+    }
+    public static void sortbyColumn(int arr[][], int col) 
+    { 
+        
+        Arrays.sort(arr, new Comparator<int[]>() { 
+            
+          @Override              
+          
+          public int compare(final int[] entry1,  
+                             final int[] entry2) { 
+  
+            
+            if (entry1[col] > entry2[col]) 
+                return 1; 
+            else
+                return -1; 
+          } 
+        });  
+    } 
+    static long func(long a[],int size,int s){
+        long max1=a[s];
+        long maxc=a[s];
+        for(int i=s+1;i<size;i++){
+            maxc=Math.max(a[i],maxc+a[i]);
+            max1=Math.max(maxc,max1);
+        }
+        return max1;
+    }
+    public static class Pair<U extends Comparable<U>, V extends Comparable<V>> implements Comparable<Pair<U, V>> {
+        public U x;
+        public V y;
+    
+        public Pair(U x, V y) {
+            this.x = x;
+            this.y = y;
+        }
+    
+        public int hashCode() {
+            return (x == null ? 0 : x.hashCode() * 31) + (y == null ? 0 : y.hashCode());
+        }
+    
+        public boolean equals(Object o) {
+            if (this == o)
+                return true;
+            if (o == null || getClass() != o.getClass())
+                return false;
+            Pair<U, V> p = (Pair<U, V>) o;
+            return (x == null ? p.x == null : x.equals(p.x)) && (y == null ? p.y == null : y.equals(p.y));
+        }
+    
+        public int compareTo(Pair<U, V> b) {
+            int cmpU = x.compareTo(b.x);
+            return cmpU != 0 ? cmpU : y.compareTo(b.y);
+        }
+    
+        public String toString() {
+            return String.format(""(%s, %s)"", x.toString(), y.toString());
+        }
+    
+    }
+    static class MultiSet<U extends Comparable<U>> {
+        public int sz = 0;
+        public TreeMap<U, Integer> t;
+ 
+        public MultiSet() {
+            t = new TreeMap<>();
+        }
+ 
+        public void add(U x) {
+            t.put(x, t.getOrDefault(x, 0) + 1);
+            sz++;
+        }
+ 
+        public void remove(U x) {
+            if (t.get(x) == 1) t.remove(x);
+            else t.put(x, t.get(x) - 1);
+            sz--;
+        }
+ 
+    }
+    static void shuffle(long[] a) {
+        Random get = new Random();
+        for (int i = 0; i < a.length; i++) {
+            int r = get.nextInt(a.length);
+            long temp = a[i];
+            a[i] = a[r];
+            a[r] = temp;
+        }
+    }
+    static long myceil(long a, long b){
+        return (a+b-1)/b;
+    }
+    
+    static long C(long n,long r){
+        long count=0,temp=n;
+        long ans=1;
+        long num=n-r+1,div=1;
+        while(num<=n){
+            ans*=num;
+            //ans+=MOD;
+            ans%=MOD;
+            ans*=mypow(div,MOD-2);
+            //ans+=MOD;
+            ans%=MOD;
+            num++;
+            div++;
+        }
+        
+        ans+=MOD;
+        return ans%MOD;
+    }
+    static long fact(long a){
+        long i,ans=1;
+        for(i=1;i<=a;i++){
+            ans*=i;
+            ans%=MOD;
+        }
+        return ans%=MOD;
+    }
+    static void sieve(int n){
+        is_sieve[0]=1;
+        is_sieve[1]=1;
+        int i,j,k;
+        for(i=2;i<n;i++){
+            if(is_sieve[i]==0){
+                sieve[i]=i;
+                tr.add(i);
+                for(j=i*i;j<n;j+=i){
+                    if(j>n||j<0){
+                        break;
+                    }
+                    is_sieve[j]=1;
+                    sieve[j]=i;
+                }
+            }
+        }
+    }
+    // static void calc(int n){
+    //     int i,j;
+    //     dp[n-1]=0;
+    //     if(n>1)
+    //     dp[n-2]=1;
+    //     for(i=n-3;i>=0;i--){
+    //         long ind=n-i-1;
+    //         dp[i]=((ind*(long)mypow(10,ind-1))%MOD+dp[i+1])%MOD;
+    //     }
+    // }
+    static long mypow(long x,long y){
+        long temp; 
+        if( y == 0) 
+            return 1; 
+        temp = mypow(x, y/2); 
+        if (y%2 == 0) 
+            return (temp*temp)%MOD; 
+        else
+            return ((x*temp)%MOD*(temp)%MOD)%MOD; 
+    }
+    static long dist[],dp[][],left[],right[];
+    static int visited[],isit[];
+    static ArrayList<Pair<Integer,Pair<Long,Long>>> adj[],li;
+    //static int dp[][][];
+    static int MOD=1000000007;
+    static char ch[];
+    static int[] sieve,is_sieve;
+    static TreeSet<Integer> tr;
+    static long mat[][];
+    
+    // static void bfs(int node,int par,Pair<Long,Long> p[],long taken){
+    //     LinkedList<Integer> li=new LinkedList<>();
+    //     li.add(node);
+        
+    //     while(!li.isEmpty()){
+    //         int x=li.pollFirst();
+    //         long lowNode=p[x-1].x;
+    //         long highNode=p[x-1].y;
+    //         int left=0,right=0;
+    //         visited[x]=1;
+    //         for(Pair<Integer,Pair<Long,Long>> pp:adj[x]){
+                    
+    //                 long max=0;
+                    
+    //                 if(selected[pp.x]==0){
+    //                     max=Math.max(Math.abs(lowNode-pp.y.y),Math.abs(highNode-pp.y.x));
+                        
+    //                     if(max==Math.abs(lowNode-pp.y.y)){
+                            
+    //                         left++;
+    //                     }else{
+                            
+    //                         right++;
+    //                     }
+    //                 }else{
+    //                     max=Math.max(Math.abs(lowNode-selected[pp.x]),Math.abs(highNode-selected[pp.x]));
+    //                     if(max==Math.abs(lowNode-selected[pp.x])){
+                            
+    //                         left++;
+    //                     }else{
+                            
+    //                         right++;
+    //                     }
+    //                 }
+    //                 if(visited[pp.x]==0)
+    //                 li.add(pp.x);
+                
+    //         }
+    //         if(left>=right){
+    //             selected[x]=lowNode;
+    //         }else{
+    //             selected[x]=highNode;
+    //         }
+    //     }
+    // }
+    static void dfs(int node,int par, Pair<Long,Long> p[]){
+        for(Pair<Integer,Pair<Long,Long>> pp:adj[node]){
+            if(pp.x!=par){
+                //sum+=Math.abs(selected[node]-selected[pp.x]);
+                dfs(pp.x,node,p);
+                //System.out.println(node+"" ""+pp.x);
+                long x=Math.abs(p[node].x-p[pp.x].x);
+                long y=Math.abs(p[node].x-p[pp.x].y);
+                long z=Math.abs(p[node].y-p[pp.x].x);
+                long w=Math.abs(p[node].y-p[pp.x].y);
+                
+                left[node]+=Math.max(x+left[pp.x],y+right[pp.x]);
+                right[node]+=Math.max(z+left[pp.x],w+right[pp.x]);
+                
+            }
+        }
+    }
+    
+    public static void main(String args[]){
+        InputStream inputStream = System.in;
+        OutputStream outputStream = System.out;
+        InputReader in = new InputReader(inputStream);
+        PrintWriter w = new PrintWriter(outputStream);
+        int t,i,j,tno=0,tte;
+        
+        t=in.nextInt();
+        //t=1;
+        //tte=t;
+        
+        while(t-->0){
+            //sum=0;
+            int n=in.nextInt();
+            adj=new ArrayList[n+1];
+            left=new long[n+1];
+            right=new long[n+1];
+            visited=new int[n+1];
+            for(i=0;i<n+1;i++){
+                adj[i]=new ArrayList<>();
+            }
+            Pair<Long,Long> p[]=new Pair[n+1];
+            for(i=1;i<=n;i++){
+                p[i]=new Pair<>(in.nextLong(),in.nextLong());
+            } 
+            for(i=0;i<n-1;i++){
+                int u,v;
+                u=in.nextInt();
+                v=in.nextInt();
+                adj[u].add(new Pair<>(v,p[v]));
+                adj[v].add(new Pair<>(u,p[u]));
+            }
+            //bfs(1,-1,p,Long.MAX_VALUE);
+            dfs(1,-1,p);
+            // for(i=0;i<n+1;i++){
+            //     w.print(selected[i]+"" "");
+            // }
+            // w.println();
+            w.println((long)Math.max(left[1],right[1]));
+        }
+        w.close();
+    }
+}",0
+3e6def38,e7dce35b,"import java.io.*;
+import java.util.*;
+
+public class D_Java {
+	public static final int MOD = 998244353;
+	
+	public static int mul(int a, int b) {
+		return (int)((long)a * (long)b % MOD);
+	}
+	
+	int[] f;
+	int[] rf;
+	
+	public int C(int n, int k) {
+		return (k < 0 || k > n) ? 0 : mul(f[n], mul(rf[n-k], rf[k]));
+	}
+	
+	public static int pow(int a, int n) {
+		int res = 1;
+		while (n != 0) {
+			if ((n & 1) == 1) {
+				res = mul(res, a);
+			}
+			a = mul(a, a);
+			n >>= 1;
+		}
+		return res;
+	}
+	
+	static void shuffleArray(int[] a) {
+		Random rnd = new Random();
+		for (int i = a.length-1; i > 0; i--) {
+			int index = rnd.nextInt(i + 1);
+			int tmp = a[index];
+			a[index] = a[i];
+			a[i] = tmp;
+		}
+	}
+	
+	public static int inv(int a) {
+		return pow(a, MOD-2);
+	}
+	
+	public void doIt() throws IOException {
+		BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
+		
+		StringTokenizer tok = new StringTokenizer(in.readLine());
+		int n = Integer.parseInt(tok.nextToken());
+		int k = Integer.parseInt(tok.nextToken());
+		
+		f = new int[n+42];
+		rf = new int[n+42];
+		f[0] = rf[0] = 1;
+		for (int i = 1; i < f.length; ++i) {
+			f[i] = mul(f[i-1], i);
+			rf[i] = mul(rf[i-1], inv(i));
+		}
+		
+		int[] events = new int[2*n];
+		for (int i = 0; i < n; ++i) {
+			tok = new StringTokenizer(in.readLine());
+			int le = Integer.parseInt(tok.nextToken());
+			int ri = Integer.parseInt(tok.nextToken());
+			events[i] = le*2;
+			events[i + n] = ri*2 + 1;
+		}
+		shuffleArray(events);
+		Arrays.sort(events);
+		
+		int ans = 0;
+		int balance = 0;
+		for (int r = 0; r < 2*n;) {
+			int l = r;
+			while (r < 2*n && events[l] == events[r]) {
+				++r;
+			}
+			int added = r - l;
+			if (events[l] % 2 == 0) {
+				// Open event
+				ans += C(balance + added, k);
+				if (ans >= MOD) ans -= MOD;
+				ans += MOD - C(balance, k);
+				if (ans >= MOD) ans -= MOD;
+				balance += added;
+			} else {
+				// Close event
+				balance -= added;
+			}
+		}
+		
+		in.close();
+		System.out.println(ans);
+	}
+	
+	public static void main(String[] args) throws IOException {
+		(new D_Java()).doIt();
+	}
+}","import java.io.*;
+import java.util.*;
+
+public class Main {
+    public static void main(String[] args) throws IOException {
+        br = new BufferedReader(new InputStreamReader(System.in));
+        PrintWriter pw = new PrintWriter(System.out);
+        int n = nextInt();
+        int k = nextInt();
+
+        f = new int[n + 42];
+        rf = new int[n + 42];
+        f[0] = 1;
+        rf[0] = 1;
+        for (int i = 1; i < f.length; i++) {
+            f[i] = mul(f[i - 1], i);
+            rf[i] = mul(rf[i - 1], inv(i));
+        }
+
+        int[] a = new int[n * 2];
+        for (int i = 0; i < n; i++) {
+            a[i] = nextInt() * 2;
+            a[i + n] = nextInt() * 2 + 1;
+        }
+        Arrays.sort(a);
+
+        int ans = 0;
+        int curOpen = 0;
+        for (int r = 0; r < 2 * n;) {
+            int l = r;
+            while (r < 2 * n && a[l] == a[r]) r++;
+            int intersections = r - l;
+            if (a[l] % 2 == 0) {
+                ans += C(curOpen + intersections, k);
+                if (ans >= mod) ans -= mod;
+                ans += mod - C(curOpen, k);
+                if (ans >= mod) ans -= mod;
+                curOpen += intersections;
+            } else {
+                curOpen -= intersections;
+            }
+        }
+
+        pw.println(ans);
+        pw.close();
+    }
+
+    static int mod = 998244353;
+
+    static int mul(int a, int b) {
+        return (int) ((long) a * (long) b % mod);
+    }
+
+    static int[] f;
+    static int[] rf;
+
+    static int C(int n, int k) {
+        return (k < 0 || k > n) ? 0 : mul(f[n], mul(rf[n - k], rf[k]));
+    }
+
+    static int pow(int a, int n) {
+        int res = 1;
+        while (n != 0) {
+            if ((n & 1) == 1) {
+                res = mul(res, a);
+            }
+            a = mul(a, a);
+            n >>= 1;
+        }
+        return res;
+    }
+
+    static int inv(int a) {
+        return pow(a, mod - 2);
+    }
+
+    static StringTokenizer st = new StringTokenizer("""");
+    static BufferedReader br;
+
+    static String next() throws IOException {
+        while (st == null || !st.hasMoreTokens()) st = new StringTokenizer(br.readLine());
+        return st.nextToken();
+    }
+
+    static int nextInt() throws IOException {
+        return Integer.parseInt(next());
+    }
+
+    static long nextLong() throws IOException {
+        return Long.parseLong(next());
+    }
+
+    static double nextDouble() throws IOException {
+        return Double.parseDouble(next());
+    }
+}
+
+class Coordinates {
+    int l;
+    int r;
+
+    public Coordinates(int l, int r) {
+        this.l = l;
+        this.r = r;
+    }
+}
+
+class CoordinatesComparator implements Comparator<Coordinates> {
+
+    @Override
+    public int compare(Coordinates o1, Coordinates o2) {
+        if (o1.l == o2.l) return Integer.compare(o1.r, o2.r);
+        return Integer.compare(o1.l, o2.l);
+    }
+}",1
+6bcc5afd,f6ca6fc8,"import java.util.*;
+public class MyClass {
+    public static void main(String args[]) {
+     Scanner s=new Scanner(System.in);
+     int n=s.nextInt();
+     int a[]=new int[n];
+     ArrayList<Integer> lt1=new ArrayList<>();
+     ArrayList<Integer> lt0=new ArrayList<>();
+     for(int i=0;i<n;i++)
+     {
+         int l=s.nextInt();
+         if(l==0)
+         lt0.add(i+1);
+         else
+         lt1.add(i+1);
+     }
+     int dp[][]=new int[lt1.size()+1][lt0.size()+1];
+     for(int i=1;i<=lt1.size();i++)
+     {
+         dp[i][i]=dp[i-1][i-1]+Math.abs(lt0.get(i-1)-lt1.get(i-1));
+         for(int j=i+1;j<=lt0.size();j++)
+         {
+             dp[i][j]=Math.min(dp[i][j-1],dp[i-1][j-1]+Math.abs(lt1.get(i-1)-lt0.get(j-1)));
+         }
+     }
+     System.out.println(dp[lt1.size()][lt0.size()]);
+     
+    }
+}","import java.util.*;
+import java.io.*;
+
+public class D {
+	public static void main(String[] args) {
+		Scanner sc=new Scanner(System.in);
+		int n = sc.nextInt();
+		ArrayList<Integer>  o=new ArrayList<Integer>();
+		ArrayList<Integer>  e=new ArrayList<Integer>();
+		for(int i=1;i<=n;i++){
+			int x=sc.nextInt();
+			if(x==1)o.add(i);
+			else e.add(i);
+		}
+		int dp[][]=new int[o.size()+1][e.size()+1];
+		for(int i=1;i<=o.size();i++){
+			dp[i][i]=dp[i-1][i-1]+Math.abs(o.get(i-1)-e.get(i-1));
+			for(int j=i+1;j<=e.size();j++){
+				dp[i][j]=Math.min(dp[i][j-1],dp[i-1][j-1]+Math.abs(o.get(i-1)-e.get(j-1)));
+			}
+		}
+		System.out.println(dp[o.size()][e.size()]);
+	}
+}
+",1
+7c11511f,ca8f11a4,"import java.io.*;
+import java.util.*;
+
+public class Solution {
+
+    public static void main(String[] args) throws Exception {
+        int tc = io.nextInt();
+        for (int i = 0; i < tc; i++) {
+            solve();
+        }
+        io.close();
+    }
+
+    private static void solve() throws Exception {
+        int n = io.nextInt();
+        String a = io.next();
+        String b = io.next();
+        int zz = 0;
+        int zo = 0;
+        int oo = 0;
+        int oz = 0;
+        for (int i = 0; i < a.length(); i++) {
+            if (a.charAt(i) == '1' && b.charAt(i) == '0') {
+                oz++;
+            }
+            if (a.charAt(i) == '0' && b.charAt(i) == '0') {
+                zz++;
+            }
+            if (a.charAt(i) == '1' && b.charAt(i) == '1') {
+                oo++;
+            }
+            if (a.charAt(i) == '0' && b.charAt(i) == '1') {
+                zo++;
+            }
+        }
+        int ans = Integer.MAX_VALUE;
+        if (oz == zo) {
+            ans = Math.min(ans, oz + zo);
+        }
+        if (oo - 1 == zz) {
+            ans = Math.min(ans, oo + zz);
+        }
+        if (ans == Integer.MAX_VALUE) {
+            ans = -1;
+        }
+        io.println(ans);
+    }
+
+    static void sort(int[] a) {
+        ArrayList<Integer> l = new ArrayList<>(a.length);
+        for (int i : a) l.add(i);
+        Collections.sort(l);
+        for (int i = 0; i < a.length; i++) a[i] = l.get(i);
+    }
+
+    //-----------PrintWriter for faster output---------------------------------
+    public static FastIO io = new FastIO();
+
+    //-----------MyScanner class for faster input----------
+    static class FastIO extends PrintWriter {
+        private InputStream stream;
+        private byte[] buf = new byte[1 << 16];
+        private int curChar, numChars;
+
+        // standard input
+        public FastIO() {
+            this(System.in, System.out);
+        }
+
+        public FastIO(InputStream i, OutputStream o) {
+            super(o);
+            stream = i;
+        }
+
+        // file input
+        public FastIO(String i, String o) throws IOException {
+            super(new FileWriter(o));
+            stream = new FileInputStream(i);
+        }
+
+        // throws InputMismatchException() if previously detected end of file
+        private int nextByte() {
+            if (numChars == -1) throw new InputMismatchException();
+            if (curChar >= numChars) {
+                curChar = 0;
+                try {
+                    numChars = stream.read(buf);
+                } catch (IOException e) {
+                    throw new InputMismatchException();
+                }
+                if (numChars == -1) return -1; // end of file
+            }
+            return buf[curChar++];
+        }
+
+        // to read in entire lines, replace c <= ' '
+        // with a function that checks whether c is a line break
+        public String next() {
+            int c;
+            do {
+                c = nextByte();
+            } while (c <= ' ');
+            StringBuilder res = new StringBuilder();
+            do {
+                res.appendCodePoint(c);
+                c = nextByte();
+            } while (c > ' ');
+            return res.toString();
+        }
+
+        public String nextLine() {
+            int c;
+            do {
+                c = nextByte();
+            } while (c < '\n');
+            StringBuilder res = new StringBuilder();
+            do {
+                res.appendCodePoint(c);
+                c = nextByte();
+            } while (c > '\n');
+            return res.toString();
+        }
+
+        public int nextInt() {
+            int c;
+            do {
+                c = nextByte();
+            } while (c <= ' ');
+            int sgn = 1;
+            if (c == '-') {
+                sgn = -1;
+                c = nextByte();
+            }
+            int res = 0;
+            do {
+                if (c < '0' || c > '9')
+                    throw new InputMismatchException();
+                res = 10 * res + c - '0';
+                c = nextByte();
+            } while (c > ' ');
+            return res * sgn;
+        }
+
+        public long nextLong() {
+            int c;
+            do {
+                c = nextByte();
+            } while (c <= ' ');
+            int sgn = 1;
+            if (c == '-') {
+                sgn = -1;
+                c = nextByte();
+            }
+            long res = 0;
+            do {
+                if (c < '0' || c > '9')
+                    throw new InputMismatchException();
+                res = 10 * res + c - '0';
+                c = nextByte();
+            } while (c > ' ');
+            return res * sgn;
+        }
+
+
+        public double nextDouble() {
+            return Double.parseDouble(next());
+        }
+    }
+    //--------------------------------------------------------
+}","
+import java.util.*;
+import java.util.stream.Collectors;
+import java.io.*;
+import java.math.*;
+
+public class GR18_C2 {
+	public static FastScanner sc;
+	public static StringBuilder sb ;public static int MOD= 1000000007;
+	public static class FastScanner {
+		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st=new StringTokenizer("""");
+		String next() {
+			while (!st.hasMoreTokens())
+				try { 
+					st=new StringTokenizer(br.readLine());				               
+	             } catch (IOException e) {}
+				return st.nextToken();
+			}
+		
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+		String nextLine() throws IOException {
+			return br.readLine();
+		}
+    }
+
+    public static void solve(int t) throws IOException {
+    	int n=sc.nextInt();
+    	String a=sc.next();
+    	String b=sc.next();
+    	
+    	int _00=0;
+    	int _01=0;
+    	int _10=0;
+    	int _11=0;
+    	
+    	for(int i=0;i<n;i++) {
+    		if(a.charAt(i)=='0' && b.charAt(i)=='0') _00++;
+    		if(a.charAt(i)=='0' && b.charAt(i)=='1') _01++;
+    		if(a.charAt(i)=='1' && b.charAt(i)=='0') _10++;
+    		if(a.charAt(i)=='1' && b.charAt(i)=='1') _11++;
+    	}
+    	
+    	int ans=Integer.MAX_VALUE;
+    	
+    	
+    	// All _01 and _10 can be converted to _11 and _00 by swapping and this requires to operations
+    	if(_01==_10) {
+    		ans=Math.min(ans, _10*2);
+    	}
+    	// By performing one operation, we get _01==_10 and then even operations can be done.
+    	// Possible when _11=_00 and one additional _11 for odd operation
+    	if(_00+1==_11) {
+    		ans=Math.min(ans, (_11-1)*2+1);
+    	}
+    	if(ans==Integer.MAX_VALUE) sb.append(-1).append('\n');
+    	else sb.append(ans).append('\n');
+    }
+    
+	public static void main(String[] args) throws IOException {
+		sb = new StringBuilder("""");
+		sc = new FastScanner();
+		int t=sc.nextInt();
+		for(int i=1;i<=t;i++){
+			solve(i);
+		}
+		System.out.println(sb);
+	}
+	
+	
+}
+",1
+1984bef1,2063ba3e,"import java.util.*;
+import java.io.*;
+public class stoneheaps {
+	public static void main(String[] args) throws Exception{
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		
+		int t = Integer.parseInt(br.readLine());
+		for(int i = 0; i < t; i ++) {
+			int n = Integer.parseInt(br.readLine());
+			String[] tokens = br.readLine().split("" "");
+			int[] arr = new int[n];
+			for(int j = 0; j < n; j++) {
+				arr[j] = Integer.parseInt(tokens[j]);
+			}
+			
+			int l = 1;
+			int r = 1000000000;
+			while(l < r) {
+				int mid  = l + (r-l+1)/2;
+				if(check(arr, mid)) {
+					l = mid;
+				}
+				else {
+					r = mid-1;
+				}
+			}
+			System.out.println(l);
+		}
+	}
+	
+	static boolean check(int[] arr, int x) {
+		int[] changed = new int[arr.length];
+		
+		for(int i = 0; i < arr.length; i ++) {
+			changed[i] = arr[i];
+		}
+		
+		int n = arr.length;
+		for(int i = n-1; i >= 0; i--) {
+			if(changed[i] < x) {
+				return false;
+			}
+			else if(i > 1){
+				int change = Math.min(changed[i]-x, arr[i])/3;
+				changed[i-1] = changed[i-1]+change;
+				changed[i-2] = changed[i-2] +change*2;
+			}
+		}
+		return true;
+	}
+}
+","import java.io.*;
+import java.util.*;
+
+public class c {
+    public static void main(String[] args) throws Exception {
+        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
+        PrintWriter out = new PrintWriter(System.out);
+        int numCases = Integer.parseInt(in.readLine());
+        for (int casenum = 0; casenum < numCases; casenum++) {
+            int n = Integer.parseInt(in.readLine());
+            long[] arr = new long[n];
+            StringTokenizer tokenizer = new StringTokenizer(in.readLine());
+            for (int i = 0; i < n; i++) {
+                arr[i] = Long.parseLong(tokenizer.nextToken());
+            }
+            long low = 0;
+            long high = 1000000000;
+            low--;
+            while (low < high) {
+                long mid = low + (high - low + 1) / 2;
+                boolean works = test(arr, mid);
+                if (works) {
+                    low = mid;
+                } else {
+                    high = mid - 1;
+                }
+                //System.out.println(mid + "" "" + works);
+            }
+            System.out.println(low);
+        }
+        in.close();
+        out.close();
+    }
+
+    public static boolean test(long[] arr, long k) {
+        long[] h = new long[arr.length];
+        for (int i = 0; i < arr.length; i++) {
+            h[i] = arr[i];
+        }
+        for (int i = h.length - 1; i - 2 >= 0; i--) {
+            if (h[i] < k)
+                break;
+            long d = Math.min((h[i]-k) / 3, arr[i]/3);
+            h[i] -= 3 * d;
+            h[i - 1] += d;
+            h[i-+ 2] += 2 * d;
+        }
+        for (int i = 0; i < h.length; i++) {
+            if (h[i] < k)
+                return false;
+        }
+        //System.out.println(Arrays.toString(h));
+        return true;
+    }
+}",0
+0df4050e,f5fde094,"import java.io.*;
+import java.util.*;
+
+public class MainClass {
+    public static void main(String[] args) {
+        Reader in = new Reader(System.in);
+        int t = in.nextInt();
+        StringBuilder stringBuilder = new StringBuilder();
+        while (t-- > 0) {
+            ArrayList<Integer> reds = new ArrayList<>();
+            ArrayList<Integer> blue = new ArrayList<>();
+            int n = in.nextInt();
+            int[] a = new int[n];
+            for (int i = 0; i < n; i++) {
+                a[i] = in.nextInt() - 1;
+            }
+            char[] s = in.next().toCharArray();
+            for (int i = 0; i < n; i++) {
+                if (s[i] == 'R') {
+                    reds.add(a[i]);
+                } else {
+                    blue.add(a[i]);
+                }
+            }
+            Collections.sort(reds, Collections.reverseOrder());
+            Collections.sort(blue);
+            boolean ff = true;
+            int start = 0;
+            for (int i = 0; i < blue.size(); i++) {
+                if (blue.get(i) < start) {
+                    ff = false;
+                    break;
+                }
+                start++;
+            }
+            start = n - 1;
+            for (int i = 0; i < reds.size(); i++) {
+                if (reds.get(i) > start) {
+                    ff = false;
+                    break;
+                }
+                start--;
+            }
+            stringBuilder.append(ff?""YES"":""NO"").append(""\n"");
+        }
+        System.out.println(stringBuilder);
+    }
+}
+class Reader {
+    public BufferedReader reader;
+    public StringTokenizer tokenizer;
+
+    public Reader(InputStream stream) {
+        reader = new BufferedReader(new InputStreamReader(stream), 32768);
+        tokenizer = null;
+    }
+
+    public String next() {
+        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
+            try {
+                tokenizer = new StringTokenizer(reader.readLine());
+            } catch (IOException e) {
+                throw new RuntimeException(e);
+            }
+        }
+        return tokenizer.nextToken();
+    }
+
+    public int nextInt() {
+        return Integer.parseInt(next());
+    }
+
+    public long nextLong() {
+        return Long.parseLong(next());
+    }
+
+}"," //package eround101;
+
+import java.util.*;
+import java.io.*;
+import java.lang.*;
+import java.util.StringTokenizer;
+
+public class Solution {
+
+    static HritikScanner sc = new HritikScanner();
+    static PrintWriter pw = new PrintWriter(System.out, true);
+    final static int MOD = 1000000007;
+    static StringBuilder sb = new StringBuilder();
+
+    public static void main(String[] args) {
+
+        int t = ni();
+        while (t-- > 0) {
+            solve();
+        }
+    }
+
+    static void solve() {
+        int n = ni();
+        int[] arr = nextIntArray(n);
+        char[] col = sc.next().toCharArray();
+        int[] cB = new int[n+1];
+        int[] cR = new int[n+1];
+        for(int i = 0; i < n; i++)
+        {
+//            pl((col[i] == 'R' && arr[i] > n));
+//            pl((col[i] == 'B' && arr[i] < 1));
+            if((col[i] == 'R' && arr[i] > n)||(col[i] == 'B' && arr[i] < 1))
+            {
+                pl(""NO"");
+                return;
+            }
+            if(col[i] == 'B')
+            {
+                if(arr[i] > n)
+                    continue;
+                cB[arr[i]]++;
+                if(cB[arr[i]] > arr[i])
+                {
+                    pl(""NO"");
+                    return;
+                }
+            }
+            else
+            {
+                if(arr[i] < 1)
+                    continue;
+                cR[arr[i]]++;
+                if(cR[arr[i]] > (n-(arr[i]-1)))
+                {
+                    pl(""NO"");
+                    return;
+                }
+            }
+//            pa(cB);
+//            pa(cR);
+        }
+//        pa(cB);
+//        pa(cR);
+        int[] psum = new int[n+1];
+        for(int i = 1; i<= n; i++)
+        {
+            psum[i] = psum[i-1]+cB[i];
+            if(psum[i] > i)
+            {
+                pl(""NO"");
+                return;
+            }
+        }
+//        pa(psum);
+        int[] psum1 = new int[n+1];
+        psum1[n] = cR[n];
+        for(int i = n-1; i>= 0; i--)
+        {
+            psum1[i] = psum1[i+1]+cR[i];
+            if(psum1[i] > (n-(i-1)))
+            {
+                pl(""NO"");
+                return;
+            }
+        }
+//        pa(psum1);
+        
+        pl(""YES"");
+        
+    }
+        /////////////////////////////////////////////////////////////////////////////////
+    static class FenwickTree { // Binary Index Tree
+        int[] tree;
+        static int size;
+
+        public FenwickTree(int size) {
+            this.size = size;
+            tree = new int[size + 5];
+        }
+
+        public void add(int i, int val) {
+            while (i <= size) {
+                tree[i] += val;
+                i += i & -i;  // adding the decimal value of the last set bit.
+            }
+        }
+
+        public int sum(int i) {
+            int res = 0;
+            while (i >= 1) {
+                res += tree[i];
+                i -= i & -i; // deleting the last set bit
+            }
+            return res;
+        }
+
+        public int sum(int l, int r) {
+            return sum(r) - sum(l - 1);
+        }
+    }
+
+    /////////////////////////////////////////////////////////////////////////////////
+    static int[] nextIntArray(int n) {
+        int[] arr = new int[n];
+        int i = 0;
+        while (i < n) {
+            arr[i++] = ni();
+        }
+        return arr;
+    }
+
+    static long[] nextLongArray(int n) {
+        long[] arr = new long[n];
+        int i = 0;
+        while (i < n) {
+            arr[i++] = nl();
+        }
+        return arr;
+    }
+
+    static int[] nextIntArray1(int n) {
+        int[] arr = new int[n + 1];
+        int i = 1;
+        while (i <= n) {
+            arr[i++] = ni();
+        }
+        return arr;
+    }
+
+    /////////////////////////////////////////////////////////////////////////////////
+    static int ni() {
+        return sc.nextInt();
+    }
+
+    static long nl() {
+        return sc.nextLong();
+    }
+
+    static double nd() {
+        return sc.nextDouble();
+    }
+
+    /////////////////////////////////////////////////////////////////////////////////
+    static void pl() {
+        pw.println();
+    }
+
+    static void p(Object o) {
+        pw.print(o + "" "");
+    }
+
+    static void pl(Object o) {
+        pw.println(o);
+    }
+
+    static void psb(StringBuilder sb) {
+        pw.print(sb);
+    }
+
+    static void pa(Object arr[]) {
+        for (Object o : arr) {
+            p(o);
+        }
+        pl();
+    }
+
+    static void pa(int arr[]) {
+        for (int o : arr) {
+            p(o);
+        }
+        pl();
+    }
+
+    static void pa(long arr[]) {
+        for (long o : arr) {
+            p(o);
+        }
+        pl();
+    }
+
+    static void pa(double arr[]) {
+        for (double o : arr) {
+            p(o);
+        }
+        pl();
+    }
+
+    static void pa(char arr[]) {
+        for (char o : arr) {
+            p(o);
+        }
+        pl();
+    }
+
+    static void pa(List list) {
+        for (Object o : list) {
+            p(o);
+        }
+        pl();
+    }
+
+    static void pa(Object[][] arr) {
+
+        for (int i = 0; i < arr.length; ++i) {
+            for (Object o : arr[i]) {
+                p(o);
+            }
+            pl();
+        }
+    }
+
+    static void pa(int[][] arr) {
+        for (int i = 0; i < arr.length; ++i) {
+            for (int o : arr[i]) {
+                p(o);
+            }
+            pl();
+        }
+    }
+
+    static void pa(long[][] arr) {
+        for (int i = 0; i < arr.length; ++i) {
+            for (long o : arr[i]) {
+                p(o);
+            }
+            pl();
+        }
+    }
+
+    static void pa(char[][] arr) {
+        for (int i = 0; i < arr.length; ++i) {
+            for (char o : arr[i]) {
+                p(o);
+            }
+            pl();
+        }
+    }
+
+    static void pa(double[][] arr) {
+        for (int i = 0; i < arr.length; ++i) {
+            for (double o : arr[i]) {
+                p(o);
+            }
+            pl();
+        }
+    }
+
+/////////////////////////////////////////////////////////////////////////////////
+    static void print(Object s) {
+        System.out.println(s);
+    }
+
+    /////////////////////////////////////////////////////////////////////////////////
+    //-----------HritikScanner class for faster input----------//
+    static class HritikScanner {
+
+        BufferedReader br;
+        StringTokenizer st;
+
+        public HritikScanner() {
+            br = new BufferedReader(new InputStreamReader(System.in));
+        }
+
+        String next() {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+
+        String nextLine() {
+            String str = """";
+            try {
+                str = br.readLine();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+        }
+    }
+
+    //////////////////////////////////////////////////////////////////
+    public static class Pair implements Comparable<Pair> {
+
+        int num, row, col;
+
+        Pair(int num, int row, int col) {
+            this.num = num;
+            this.row = row;
+            this.col = col;
+        }
+
+        public int get1() {
+            return num;
+        }
+
+        public int get2() {
+            return row;
+        }
+
+        public int compareTo(Pair A) {
+            return this.num - A.num;
+        }
+
+        public String toString() {
+            return num + "" "" + row + "" "" + col;
+        }
+    }
+
+    //////////////////////////////////////////////////////////////////
+    // Function to return gcd of a and b time complexity O(log(a+b))
+    static long gcd(long a, long b) {
+        if (a == 0) {
+            return b;
+        }
+        return gcd(b % a, a);
+    }
+
+    // method to return LCM of two numbers 
+    static long lcm(long a, long b) {
+        return (a / gcd(a, b)) * b;
+    }
+
+    //////////////////////////////////////////////////////////////////
+    static boolean isPrime(long n) {
+        // Corner cases 
+        if (n <= 1) {
+            return false;
+        }
+        if (n <= 3) {
+            return true;
+        }
+
+        // This is checked so that we can skip  
+        // middle five numbers in below loop 
+        if (n % 2 == 0 || n % 3 == 0) {
+            return false;
+        }
+
+        for (long i = 5; i * i <= n; i = i + 6) {
+            if (n % i == 0 || n % (i + 2) == 0) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+    //////////////////////////////////////////////////////////////////
+
+    static boolean isPowerOfTwo(long n) {
+        if (n == 0) {
+            return false;
+        }
+
+        return (long) (Math.ceil((Math.log(n) / Math.log(2))))
+                == (long) (Math.floor(((Math.log(n) / Math.log(2)))));
+    }
+
+    public static long getFact(int n) {
+        long ans = 1;
+        while (n > 0) {
+            ans *= n;
+            ans %= MOD;
+            n--;
+        }
+        return ans;
+    }
+
+    public static long pow(long n, int pow) {
+        if (pow == 0) {
+            return 1;
+        }
+        long temp = pow(n, pow / 2) % MOD;
+        temp *= temp;
+        temp %= MOD;
+        if (pow % 2 == 1) {
+            temp *= n;
+        }
+        temp %= MOD;
+        return temp;
+
+    }
+
+    public static long nCr(int n, int r) {
+        long ans = 1;
+        int temp = n - r;
+        while (n > temp) {
+            ans *= n;
+            ans %= MOD;
+            n--;
+        }
+        ans *= pow(getFact(r) % MOD, MOD - 2) % MOD;
+        ans %= MOD;
+        return ans;
+    }
+
+    //////////////////////////////////////////////////////////////////
+    // method returns Nth power of A 
+    static double nthRoot(int A, int N) {
+
+        // intially guessing a random number between 
+        // 0 and 9 
+        double xPre = Math.random() % 10;
+
+        // smaller eps, denotes more accuracy 
+        double eps = 0.001;
+
+        // initializing difference between two 
+        // roots by INT_MAX 
+        double delX = 2147483647;
+
+        // xK denotes current value of x 
+        double xK = 0.0;
+
+        // loop untill we reach desired accuracy 
+        while (delX > eps) {
+            // calculating current value from previous 
+            // value by newton's method 
+            xK = ((N - 1.0) * xPre
+                    + (double) A / Math.pow(xPre, N - 1)) / (double) N;
+            delX = Math.abs(xK - xPre);
+            xPre = xK;
+        }
+
+        return xK;
+    }
+
+}
+",0
+6e7cd58b,cfba313d,"import java.util.*;
+import java.io.*;
+
+public class CodeforcesRound734 {
+	static FastReader sc = new FastReader();
+
+	public static void main(String[] args) throws IOException {
+		try {
+			int t = sc.nextInt();
+			while (t-- > 0) {
+//				A();
+//				B1();
+//				B2();
+				C();
+			}
+		} catch (Exception e) {
+//			return;
+			e.printStackTrace();
+		}
+	}
+
+	static void C() {
+		int n = sc.nextInt();
+		int a[][] = new int[5][n];
+		for (int i = 0; i < n; i++) {
+			String s = sc.next();
+			for (int j = 0; j < s.length(); j++) {
+				if (s.charAt(j) == 'a')
+					a[0][i]++;
+				else
+					a[0][i]--;
+				if (s.charAt(j) == 'b')
+					a[1][i]++;
+				else
+					a[1][i]--;
+				if (s.charAt(j) == 'c')
+					a[2][i]++;
+				else
+					a[2][i]--;
+				if (s.charAt(j) == 'd')
+					a[3][i]++;
+				else
+					a[3][i]--;
+				if (s.charAt(j) == 'e')
+					a[4][i]++;
+				else
+					a[4][i]--;
+			}
+		}
+		for (int x[] : a) {
+			Arrays.sort(x);
+		}
+		int ans = 0;
+		for (int i = 0; i < 5; i++) {
+			int temp = 0, cnt = 0;
+			for (int j = n - 1; j >= 0; j--) {
+				temp += a[i][j];
+				if (temp <= 0)
+					break;
+				else
+					cnt++;
+			}
+			ans = Math.max(ans, cnt);
+		}
+		System.out.println(ans);
+	}
+
+	static void B2() {
+		int n = sc.nextInt();
+		int k = sc.nextInt();
+		ArrayList<ArrayList<Integer>> al = new ArrayList<>();
+		for (int i = 0; i <= n; i++) {
+			al.add(new ArrayList<>());
+		}
+		int ans[] = new int[n + 1];
+		for (int i = 0; i < n; i++) {
+			int x = sc.nextInt();
+			al.get(x).add(i + 1);
+		}
+		ArrayList<Integer> temp = new ArrayList<>();
+		for (ArrayList<Integer> ind : al) {
+			if (ind.size() >= k) {
+				for (int i = 0; i < k; i++) {
+					ans[ind.get(i)] = i + 1;
+				}
+			} else {
+				temp.addAll(ind);
+			}
+		}
+		int color = 0;
+		for (int i = 0; i < temp.size() / k; i++) {
+			for (int j = i * k; j < i * k + k; j++) {
+				ans[temp.get(j)] = ++color;
+				if (color == k)
+					color = 0;
+			}
+		}
+		for (int i = 1; i <= n; i++) {
+			System.out.print(ans[i] + "" "");
+		}
+		System.out.println();
+	}
+
+	static void B1() {
+		String s = sc.next();
+		HashMap<Character, Integer> map = new HashMap<>();
+		for (char ch : s.toCharArray()) {
+			map.put(ch, map.getOrDefault(ch, 0) + 1);
+		}
+		if (s.length() < 2) {
+			System.out.println(0);
+			return;
+		}
+		int s1 = 0;
+		for (int v : map.values()) {
+			if (v > 2) {
+				s1 += 2;
+			} else {
+				s1 += v;
+			}
+		}
+		System.out.println(s1 / 2);
+	}
+
+	static void A() {
+		int n = sc.nextInt();
+		if (n % 3 == 0) {
+			System.out.println(n / 3 + "" "" + n / 3);
+		} else if (n % 3 == 1) {
+			System.out.println((n / 3 + 1) + "" "" + (n / 3));
+		} else {
+			System.out.println((n / 3) + "" "" + (n / 3 + 1));
+		}
+	}
+
+	static boolean[] seiveOfEratosthenes(int n) {
+		boolean[] isPrime = new boolean[n + 1];
+		Arrays.fill(isPrime, true);
+		for (int i = 2; i * i <= n; i++) {
+			for (int j = i * i; j <= n; j += i) {
+				isPrime[j] = false;
+			}
+		}
+		return isPrime;
+	}
+
+	static int gcd(int a, int b) {
+		if (b == 0)
+			return a;
+		return gcd(b, a % b);
+	}
+
+	static boolean isPrime(long n) {
+		if (n < 2)
+			return false;
+		for (int i = 2; i * i <= n; i++) {
+			if (n % i == 0)
+				return false;
+		}
+		return true;
+	}
+
+}
+
+class FastReader {
+	BufferedReader br;
+	StringTokenizer st;
+
+	public FastReader() {
+		br = new BufferedReader(new InputStreamReader(System.in));
+	}
+
+	String next() {
+		while (st == null || !st.hasMoreElements()) {
+			try {
+				st = new StringTokenizer(br.readLine());
+			} catch (IOException e) {
+				e.printStackTrace();
+			}
+		}
+		return st.nextToken();
+	}
+
+	int nextInt() {
+		return Integer.parseInt(next());
+	}
+
+	long nextLong() {
+		return Long.parseLong(next());
+	}
+
+	int[] readIntArray(int n) {
+		int a[] = new int[n];
+		for (int i = 0; i < n; i++) {
+			a[i] = Integer.parseInt(next());
+		}
+		return a;
+	}
+
+	void printIntArray(int a[]) {
+		for (int i = 0; i < a.length; i++) {
+			System.out.print(a[i] + "" "");
+		}
+	}
+
+	long[] readLongArray(int n) {
+		long a[] = new long[n];
+		for (int i = 0; i < n; i++) {
+			a[i] = Long.parseLong(next());
+		}
+		return a;
+	}
+
+	void printLongArray(long a[]) {
+		for (int i = 0; i < a.length; i++) {
+			System.out.print(a[i] + "" "");
+		}
+	}
+
+	double nextDouble() {
+		return Double.parseDouble(next());
+	}
+
+	String nextLine() {
+		String str = """";
+		try {
+			str = br.readLine();
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+		return str;
+	}
+}
+","import java.io.*;
+import java.util.*;
+
+
+public class C {//Any Class Name
+	
+	static class Code {
+		
+		private void solve(InputReader in, OutputWriter out) throws IOException {
+			
+			ArrayOpn o= new ArrayOpn();
+			int t = in.readInt();
+			while(t -- > 0) {
+			
+				int n=in.readInt();
+				
+				
+				int[][] freq= new int[5][n];
+				
+				for(int i=0; i<n; i++) {
+					char s[]= in.readString().toCharArray();
+					
+					
+					for(char e: s) {
+						if(e=='a') {
+							freq[0][i]++;
+						}
+						else {
+							freq[0][i]--;
+						}
+						if(e=='b') {
+							freq[1][i]++;
+						}
+						else {
+							freq[1][i]--;
+						}
+						
+						if(e=='c') {
+							freq[2][i]++;
+						}
+						else {
+							freq[2][i]--;
+						}
+						if(e=='d') {
+							freq[3][i]++;
+						}
+						else {
+							freq[3][i]--;
+						}
+						if(e=='e') {
+							freq[4][i]++;
+						}
+						else {
+							freq[4][i]--;
+						}
+							
+					}
+				}
+				
+				
+				for(int i=0; i<5; i++) {
+					Arrays.sort(freq[i]);
+				}
+				
+				int ans=0;
+				for(int i=0; i<5; i++) {
+					int temp=0, count=0;
+					for(int j=n-1; j>=0; j--) {
+						temp+=freq[i][j];
+						if(temp<=0) {
+							break;
+						}
+						count++;
+					}
+					ans=Math.max(ans, count);
+				}
+				
+				out.printLine(ans);
+				
+			}
+			out.close();
+		}
+	}
+	
+	static class ArrayOpn{
+		private int[] aI(InputReader in, int n) {
+			int A[]= new int[n];
+			for(int i=0; i<n; i++) {
+				A[i]=in.readInt();
+			}
+			return A;
+		}
+		
+		static final Random random = new Random();
+		
+		private void sort(int A[]) {
+			int n = A.length;
+			for(int i=0; i<n; i++)
+			{
+				int j = random.nextInt(n),temp = A[j];
+				A[j] = A[i];
+				A[i] = temp;
+			}
+			Arrays.sort(A);
+//            return A;
+		}
+		
+		private int[][] mI(InputReader in, int n, int m){
+			int A[][]= new int[n][m];
+			for(int i=0; i<n; i++) {
+				for(int j=0; j<m; j++) {
+					A[i][j]=in.readInt();
+				}
+			}
+			return A;
+		}
+		
+		private int minEl(int A[]) {
+			int min=Integer.MAX_VALUE;
+			for(int e: A) {
+				min=Math.min(e, min);
+			}
+			return min;
+		}
+		private int maxEl(int A[]) {
+			int max=Integer.MIN_VALUE;
+			for(int e: A) {
+				max=Math.max(e, max);
+			}
+			return max;
+		}
+		
+		private int occurence(int A[], int e) {
+			int c=0;
+			for(int k: A) {
+				if(k==e) {
+					c++;
+				}
+			}
+			return c;
+		}
+		
+		public int linears(int A[], int e) {
+			
+			for(int i=0; i<A.length; i++) {
+				if(A[i]==e) {
+					return i;
+				}
+			}
+			return -1;
+		}
+		
+		public int binarys(int A[], int e) {
+			int low=0, high=A.length-1;
+			while(low<=high) {
+				int mid=(low+high)/2;
+				if(A[mid]==e) {
+					return mid;
+				}
+				else if(A[mid]<e) {
+					low=mid+1;
+				}
+				else {
+					high=mid-1;
+				}
+			}
+			return -1;
+		}
+		
+		public void printAr(OutputWriter out, int A[]) {
+			for(int e: A) {
+				out.print(e+"" "");
+			}
+		}
+	}
+	
+	static class Pair<F, S>{
+		private final F first; //first member of pair
+		private final S second; //second member of pair
+		
+		private Pair(F first, S second) {
+			this.first = first;
+			this.second = second;
+		}
+		
+		@Override
+		public boolean equals(Object o) {
+			if (this == o) {
+				return true;
+			}
+			
+			if (o == null || getClass() != o.getClass())
+				return false;
+			
+			Pair<? , ?> pair = (Pair<?, ?>) o;
+			if(!first.equals(pair.first))
+				return false;
+			return second.equals(pair.second);
+		}
+		
+		@Override
+		public int hashCode() {
+			return 31 * first.hashCode() + second.hashCode();
+		}
+		
+		@Override
+		public String toString() {
+			return ""("" + first +"", ""+ second +"")"";
+		}
+		
+		
+		public static <F,S> Pair<F,S> of(F a, S b) {
+			return new Pair<>(a,b);
+		}
+		public F getFirst() {
+			return first;
+		}
+		
+		public S getSecond() {
+			return second;
+		}
+	}
+	
+	// Comparator for using in Sorting On integers
+	static class PairCompare implements Comparator<Pair<Integer, Integer>> {
+		@Override
+		public int compare(Pair<Integer, Integer> p1, Pair<Integer, Integer> p2) {
+			int diff = Integer.compare(p1.first, p2.first);
+			if(diff == 0) {
+				return Integer.compare(p1.second, p2.second);
+			}
+			else return diff;
+		}
+	}
+	
+	
+	
+	public static void main(String[] args) throws IOException {
+		//initialize
+		InputStream inputStream = System.in;
+		OutputStream outputStream = System.out;
+		InputReader in = new InputReader(inputStream);
+		OutputWriter out = new OutputWriter(outputStream);
+		Code solver = new Code();
+		solver.solve(in, out);
+		out.flush();
+		out.close();
+	}
+	
+	
+	static class InputReader {
+		private InputStream stream;
+		private byte[] buf = new byte[1024];
+		private int curChar;
+		private int numChars;
+		private SpaceCharFilter filter;
+		
+		private InputReader(InputStream stream) {
+			this.stream = stream;
+		}
+		
+		private int read() {
+			if (numChars == -1)
+				throw new InputMismatchException();
+			if (curChar >= numChars) {
+				curChar = 0;
+				try {
+					numChars = stream.read(buf);
+				} catch (IOException e) {
+					throw new InputMismatchException();
+				}
+				if (numChars <= 0)
+					return -1;
+			}
+			return buf[curChar++];
+		}
+		
+		private String readString() {
+			int c = read();
+			while (isSpaceChar(c))
+				c = read();
+			StringBuilder res = new StringBuilder();
+			do {
+				if (Character.isValidCodePoint(c))
+					res.appendCodePoint(c);
+				c = read();
+			} while (!isSpaceChar(c));
+			return res.toString();
+		}
+		
+		private int readInt() {
+			int c = read();
+			while (isSpaceChar(c))
+				c = read();
+			int sgn = 1;
+			if (c == '-') {
+				sgn = -1;
+				c = read();
+			}
+			int res = 0;
+			do {
+				if (c < '0' || c > '9')
+					throw new InputMismatchException();
+				res *= 10;
+				res += c - '0';
+				c = read();
+			} while (!isSpaceChar(c));
+			return res * sgn;
+		}
+		
+		private long readLong() {
+			int c = read();
+			while (isSpaceChar(c)) {
+				c = read();
+			}
+			int sgn = 1;
+			if (c == '-') {
+				sgn = -1;
+				c = read();
+			}
+			long res = 0;
+			do {
+				if (c < '0' || c > '9') {
+					throw new InputMismatchException();
+				}
+				res *= 10;
+				res += c - '0';
+				c = read();
+			} while (!isSpaceChar(c));
+			return res * sgn;
+		}
+		
+		private double readDouble() {
+			int c = read();
+			while (isSpaceChar(c)) {
+				c = read();
+			}
+			int sgn = 1;
+			if (c == '-') {
+				sgn = -1;
+				c = read();
+			}
+			double res = 0;
+			while (!isSpaceChar(c) && c != '.') {
+				if (c == 'e' || c == 'E') {
+					return res * Math.pow(10, readInt());
+				}
+				if (c < '0' || c > '9') {
+					throw new InputMismatchException();
+				}
+				res *= 10;
+				res += c - '0';
+				c = read();
+			}
+			if (c == '.') {
+				c = read();
+				double m = 1;
+				while (!isSpaceChar(c)) {
+					if (c == 'e' || c == 'E') {
+						return res * Math.pow(10, readInt());
+					}
+					if (c < '0' || c > '9') {
+						throw new InputMismatchException();
+					}
+					m /= 10;
+					res += (c - '0') * m;
+					c = read();
+				}
+			}
+			return res * sgn;
+		}
+		
+		private boolean isSpaceChar(int c) {
+			if (filter != null)
+				return filter.isSpaceChar(c);
+			return isWhitespace(c);
+		}
+		
+		public String next() {
+			return readString();
+		}
+		
+		
+		private static boolean isWhitespace(int c) {
+			return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
+		}
+		
+		private char readCharacter() {
+			int c = read();
+			while (isSpaceChar(c))
+				c = read();
+			return (char) c;
+		}
+		
+		public interface SpaceCharFilter {
+			boolean isSpaceChar(int ch);
+		}
+	}
+	
+	static class OutputWriter {
+		private final PrintWriter writer;
+		
+		private OutputWriter(OutputStream outputStream) {
+			writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(
+					outputStream)));
+		}
+		
+		private OutputWriter(Writer writer) {
+			this.writer = new PrintWriter(writer);
+		}
+		
+		private void print(Object... objects) {
+			for (int i = 0; i < objects.length; i++) {
+				if (i != 0) {
+					writer.print(' ');
+				}
+				writer.print(objects[i]);
+			}
+			writer.flush();
+		}
+		
+		private void printLine(Object... objects) {
+			print(objects);
+			writer.println();
+			writer.flush();
+		}
+		
+		private void printLine(int i) {
+			writer.println(i);
+		}
+		
+		
+		private void close() {
+			writer.close();
+		}
+		
+		private void flush() {
+			writer.flush();
+		}
+		
+		
+	}
+	
+	static class IOUtils {
+		
+		private static int[] readIntArray(InputReader in, int size) {
+			int[] array = new int[size];
+			for (int i = 0; i < size; i++)
+				array[i] = in.readInt();
+			return array;
+		}
+		
+		private static long[] readLongArray(InputReader in, int size) {
+			long[] array = new long[size];
+			for (int i = 0; i < size; i++)
+				array[i] = in.readLong();
+			return array;
+		}
+		
+		private static char[] readCharArray(InputReader in, int size) {
+			char[] array = new char[size];
+			for (int i = 0; i < size; i++)
+				array[i] = in.readCharacter();
+			return array;
+		}
+		
+		private static char[][] readTable(InputReader in, int rowCount,
+				int columnCount) {
+			char[][] table = new char[rowCount][];
+			for (int i = 0; i < rowCount; i++)
+				table[i] = readCharArray(in, columnCount);
+			return table;
+		}
+		
+	}
+	
+	static class ArrayUtils {
+		
+		private static void fill(int[][] array, int value) {
+			for (int[] row : array)
+				Arrays.fill(row, value);
+		}
+		
+	}
+	
+	static class MiscUtils {
+		private static final int[] DX4 = {1, 0, -1, 0};
+		private static final int[] DY4 = {0, -1, 0, 1};
+		
+		private static boolean isValidCell(int row, int column, int rowCount,
+				int columnCount) {
+			return row >= 0 && row < rowCount && column >= 0
+					&& column < columnCount;
+		}
+		
+	}
+}",1
+2f8c3bf3,a3abac01,"import java.util.*;
+public class Main
+{
+	public static void main(String[] args) {
+		Scanner sc=new Scanner(System.in);
+		int t=sc.nextInt();
+		while(t-->0){
+		    int n=sc.nextInt();
+		    int k=sc.nextInt();
+		    
+		    int idx[]=new int[k];
+		    
+		    for(int i=0;i<k;i++){
+		        idx[i]=sc.nextInt();
+		    }
+		    
+		    long arr[]=new long[n];
+		    Arrays.fill(arr,Integer.MAX_VALUE);
+		    for(int i=0;i<k;i++){
+		        long temp=sc.nextLong();
+		        arr[idx[i]-1]=temp;
+		    }
+		    
+		    long left[]=new long[n];
+		    long right[]=new long[n];
+		    
+		    Arrays.fill(left,Integer.MAX_VALUE);
+		    Arrays.fill(right,Integer.MAX_VALUE);
+		    
+		    
+		    left[0]=arr[0];
+		    
+		    for(int i=1;i<n;i++){
+		       left[i]=Math.min(left[i-1]+1,arr[i]);
+		    }
+		    
+		    right[arr.length-1]=arr[arr.length-1];
+		    
+		    for(int i=n-2;i>=0;i--){
+		        right[i]=Math.min(right[i+1]+1,arr[i]);
+		    }
+		    
+		    for(int i=0;i<n;i++){
+		      //  System.out.print(left[i]+""--""+right[i]+""\\"");
+		       
+		       
+		       System.out.print(Math.min(left[i],right[i])+"" "");
+		    }
+		    System.out.println();
+		  
+		}
+	}
+}
+","
+//package com.company;
+
+import  java.math.*;
+import java.util.*;
+import java.lang.*;
+import java.io.*;
+
+
+
+public final class Main {
+
+    FastReader s;
+
+
+    public static void main (String[] args) throws java.lang.Exception
+    {
+
+        new Main().run();
+
+    }
+    void run()
+    {
+        s = new FastReader();
+        solve();
+    }
+   StringBuffer sb;
+    void solve()
+    {
+         sb = new StringBuffer();
+        for(int T = s.nextInt();T > 0;T--)
+            start();
+       // System.out.print(sb);
+
+    }
+
+
+    void start()
+    {
+        int n = s.nextInt();
+        int m = s.nextInt();
+        long arr[] = longArr(m);
+        long arr2[] = longArr(m);
+        long ans [] = new long[n];
+        Arrays.fill(ans,Integer.MAX_VALUE);
+        for(int i = 0; i<m; i++)
+        {
+            ans[(int)arr[i]-1] = arr2[i];
+        }
+        long left [] = new long[n];
+        long right [] = new long[n];
+        left[0] = ans[0];
+        for(int i = 1; i<n; i++)
+        {
+            left[i] = Math.min(ans[i], left[i-1]+1);
+        }
+        right[n-1] = ans[n-1];
+        for(int i = n-2; i>=0; i--)
+        {
+            right[i] = Math.min(right[i+1]+1, ans[i]);
+        }
+        StringBuffer x = new StringBuffer();
+        for(int i =0; i<n; i++)
+        {
+            long p = Math.min(left[i],right[i]);
+            x.append(p+"" "");
+        }
+        System.out.println(x);
+
+    }
+    long log(long m)
+    {
+        long y = 0;
+        while(m>0)
+        {
+            m/=2;
+            y++;
+        }
+        return y;
+
+    }
+    long gcd(long a, long b)
+    {
+        if (b == 0)
+            return a;
+        return gcd(b, a % b);
+    }
+    long power(long x, long y, long p)
+    {
+        long res = 1; // Initialize result
+
+        // Update x if it is more
+        // than or equal to p
+        x = x % p;
+
+        while (y > 0)
+        {
+            // If y is odd, multiply
+            // x with the result
+            if ((y & 1) > 0)
+                res = (res * x) % p;
+
+            // y must be even now
+            y = y >> 1; // y = y/2
+            x = (x * x) % p;
+        }
+        return res;
+    }
+
+    int lower_bound(int [] arr , int key)
+    {
+
+        int i = 0;
+        int j = arr.length-1;
+          //if(arr[i] > key)return -1;
+         if(arr[j] < key)return -1;
+
+        while(i<j)
+        {
+            int mid = (i+j)/2;
+
+            if(arr[mid] == key)
+            {
+                j = mid;
+            }
+
+            else if(arr[mid] < key)
+            {
+                i = mid+1;
+            }
+            else
+                j = mid-1;
+      }
+
+        return i;
+    }
+
+    int upper_bound(int [] arr , int key)
+    {
+
+        int i = 0;
+        int j = arr.length-1;
+        if(arr[j] <= key)return j+1;
+
+        while(i<j)
+        {
+            int mid = (i+j)/2;
+
+
+
+             if(arr[mid] <= key)
+            {
+                i = mid+1;
+            }
+            else
+                j = mid;
+        }
+
+        return i;
+    }
+
+
+    static void sort(int[] A){
+        int n = A.length;
+        Random rnd = new Random();
+        for(int i=0; i<n; ++i){
+            int tmp = A[i];
+            int randomPos = i + rnd.nextInt(n-i);
+            A[i] = A[randomPos];
+            A[randomPos] = tmp;
+        }
+        Arrays.sort(A);
+    }
+    static void sort(long[] A){
+        int n = A.length;
+        Random rnd = new Random();
+        for(int i=0; i<n; ++i){
+            long tmp = A[i];
+            int randomPos = i + rnd.nextInt(n-i);
+            A[i] = A[randomPos];
+            A[randomPos] = tmp;
+        }
+        Arrays.sort(A);
+    }
+    static String sort(String s) {
+        Character ch[]=new Character[s.length()];
+        for(int i=0;i<s.length();i++) {
+            ch[i]=s.charAt(i);
+        }
+        Arrays.sort(ch);
+        StringBuffer st=new StringBuffer("""");
+        for(int i=0;i<s.length();i++) {
+            st.append(ch[i]);
+        }
+        return st.toString();
+    }
+
+    //long array input
+    public long [] longArr(int len)
+    {
+        // long arr input
+        long [] arr = new long[len];
+        String [] strs =  s.nextLine().trim().split(""\\s+"");
+        for(int i =0; i<len; i++)
+        {
+            arr[i] = Long.parseLong(strs[i]);
+
+        }
+        return arr;
+    }
+    // int arr input
+    public int [] intArr(int len)
+    {
+        // long arr input
+        int [] arr = new int[len];
+        String [] strs =  s.nextLine().trim().split(""\\s+"");
+        for(int i =0; i<len; i++)
+        {
+            arr[i] = Integer.parseInt(strs[i]);
+
+        }
+        return arr;
+    }
+
+    static class FastReader
+    {
+        BufferedReader br;
+        StringTokenizer st;
+
+        public FastReader()
+        {
+            br = new BufferedReader(new
+                    InputStreamReader(System.in));
+        }
+
+        String next()
+        {
+            while (st == null || !st.hasMoreElements())
+            {
+                try
+                {
+                    st = new StringTokenizer(br.readLine());
+                }
+                catch (IOException  e)
+                {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt()
+        {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong()
+        {
+            return Long.parseLong(next());
+        }
+
+        double nextDouble()
+        {
+            return Double.parseDouble(next());
+        }
+
+        String nextLine()
+        {
+            String str = """";
+            try
+            {
+                str = br.readLine();
+            }
+            catch (IOException e)
+            {
+                e.printStackTrace();
+            }
+            return str;
+        }
+    }
+
+}
+",1
+66e74577,6e207cbf,"import java.io.*;
+import java.util.*;
+
+public class Menorah {
+	public static void main(String[] args) throws Exception {
+		FastIO in = new FastIO();
+		int t = in.nextInt();
+		for (int tc=0; tc<t; tc++) {
+			int n = in.nextInt();
+			String original = in.next();
+			String target = in.next();
+			int numDiff = 0;
+			int original1 = 0;
+			int target1 = 0;
+			for (int i=0; i<n; i++) {
+				if (original.charAt(i)!=target.charAt(i)) {
+					numDiff++;
+				}
+				if (original.charAt(i)=='1') original1++;
+				if (target.charAt(i)=='1') target1++;
+			}
+			int evenAns = Integer.MAX_VALUE;
+			int oddAns = Integer.MAX_VALUE;
+			if (original1==target1) {
+				evenAns = numDiff;
+			}
+			for (int i=0; i<n; i++) {
+				if (original.charAt(i)=='1' && target.charAt(i)=='1') {
+					int ones = (n-original1)+1;
+					if (ones==target1) {
+						oddAns = n-numDiff;
+					}
+					break;
+				}
+			}
+			for (int i=0; i<n; i++) {
+				if (original.charAt(i)=='1' && target.charAt(i)=='0') {
+					int ones = (n-original1)+1;
+					if (ones==target1) {
+						oddAns = Math.min(n-numDiff+1, oddAns);
+					}
+					break;
+				}
+			}
+			int ans = Math.min(evenAns, oddAns);
+			if (ans==Integer.MAX_VALUE) System.out.println(-1);
+			else System.out.println(ans);
+		}
+	}
+	static class FastIO {
+		BufferedReader br;
+	    StringTokenizer st;
+	    public FastIO() throws IOException
+	    {
+	        br = new BufferedReader(
+	            new InputStreamReader(System.in));
+
+	    }
+	    
+
+	    public String next() throws IOException
+	    {
+	        while (st == null || !st.hasMoreElements()) {
+	           
+	            st = new StringTokenizer(br.readLine());
+	        }
+	        return st.nextToken();
+	    }
+
+	    public int nextInt() throws NumberFormatException, IOException { return Integer.parseInt(next()); }
+
+	    public long nextLong() throws NumberFormatException, IOException { return Long.parseLong(next()); }
+
+	    public double nextDouble() throws NumberFormatException, IOException
+	    {
+	        return Double.parseDouble(next());
+	    }
+
+	    public String nextLine() throws IOException
+	    {
+	        String str = br.readLine();
+	        return str;
+	    }
+	}
+}
+","import java.util.*;
+import java.lang.*;
+import java.io.*;
+
+public class Codechef
+{
+	public static void main (String[] args) throws java.lang.Exception
+	{
+        Scanner sc = new Scanner(System.in);
+        int t = sc.nextInt();
+        int sm, n;
+        while(t > 0) {
+            t--;
+            n = sc.nextInt();
+            String s1,s2;
+            s1 = sc.next();
+            s2 = sc.next();
+            int a[] = new int[4];
+            a[0] = 0; a[1] = 0; a[2] = 0; a[3] = 0;
+            for(int i = 0 ; i < n ; i++) {
+                if(s1.charAt(i) == '0'&& s2.charAt(i) == '1') a[0]++;
+                else if(s1.charAt(i) == '1'&& s2.charAt(i) == '0') a[1]++;
+                else if(s1.charAt(i) == '1'&& s2.charAt(i) == '1') a[2]++;
+                else a[3]++;
+            }
+            // System.out.println(a[0] + "" "" + a[1] + "" "" + a[2] + "" "" + a[3]);
+            int n1 = Integer.MAX_VALUE, n2 = Integer.MAX_VALUE, n3 = Integer.MAX_VALUE;
+            
+            if (a[0] == a[1]) {
+                n1 = 2*a[0];
+            }
+            if((a[2] - 1) == a[3]) {
+                // System.out.println(a[3] + 1);
+                n2 = 2*a[3] + 1;
+            } 
+            if((a[3] + 1) == a[2]) {
+                // System.out.println(a[2] + 1);
+                n3 = 2*a[2] + 1;
+            } 
+            int ans = Math.min(n1, Math.min(n2,n3));
+            if(ans == Integer.MAX_VALUE) {
+                System.out.println(""-1"");
+            } else {
+                System.out.println(ans);
+            }
+        }
+	}
+}
+",0
+0017d438,9852706b,"import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.util.*;
+
+public class A {
+    static List<Integer> [] adj;
+    static ArrayList<Integer> temp;
+    static int mod = (int) 1e9+7;
+    static boolean[] vis = new boolean[(int)1e5];
+    static List<Integer> l = new ArrayList<>();
+    static final Reader s = new Reader();
+
+    public static void main(String[] args) throws IOException {
+        int t = s.nextInt();
+//        int t=1;
+       while(t-->0) {
+           int n = s.nextInt();
+           int m = s.nextInt();
+           int d = s.nextInt();
+           System.out.println(""YES"");
+           PriorityQueue<Pair> pq = new PriorityQueue<>();
+            for(int i=1;i<=m;i++){
+               pq.add(new Pair(i));
+            }
+            for(int i=0;i<n;i++){
+                int v = s.nextInt();
+                Pair p = pq.poll();
+                p.sum+=v;
+                pq.add(p);
+                System.out.print(p.id+"" "");
+            }
+           System.out.println();
+       }
+    }
+    static class Pair implements Comparable<Pair> {
+        int id;
+        long sum=0;
+        public Pair(int id) {
+            this.id=id;
+        }
+        public int compareTo(Pair o) {
+            return Long.compare(sum, o.sum);
+        }
+    }
+    //Important
+    //Dont't stick on same approach
+    //Check long
+    static void dfs(int i){
+        vis[i]=true;
+        l.add(i);
+        List<Integer> Y = adj[i];
+        for(int x:Y){
+            if(!vis[x])dfs(x);
+        }
+    }
+
+    static long gcd(long a, long b) throws IOException {
+        return (b == 0) ? a : gcd(b, a % b);
+    }
+
+    static int gcd(int a, int b) throws IOException {
+        return (b == 0) ? a : gcd(b, a % b);
+    }
+
+    static void sortr(int[] a) {
+        ArrayList<Integer> l = new ArrayList<>();
+        for (int i : a)
+            l.add(i);
+        Collections.sort(l, Collections.reverseOrder());
+        for (int i = 0; i < a.length; i++)
+            a[i] = l.get(i);
+    }
+
+    static void sort(int[] a) {
+        ArrayList<Integer> l = new ArrayList<>();
+        for (int i : a)
+            l.add(i);
+        Collections.sort(l);
+        for (int i = 0; i < a.length; i++)
+            a[i] = l.get(i);
+    }
+
+    static void sort(long[] a) {
+        ArrayList<Long> l = new ArrayList<>();
+        for (long i : a)
+            l.add(i);
+        Collections.sort(l);
+        for (int i = 0; i < a.length; i++)
+            a[i] = l.get(i);
+    }
+
+    static class Reader {
+        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st;
+        String next() {
+            while(st==null||!st.hasMoreTokens()) {
+                try {
+                    st=new StringTokenizer(in.readLine());
+                } catch(Exception e) {}
+            }
+            return st.nextToken();
+        }
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+    }
+
+}","import java.io.BufferedReader;
+import java.io.DataInputStream;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.*;
+public class Main {
+    static int modulo=998244353;
+    public static void main(String[] args) {
+       
+        FastScanner in = new FastScanner();
+        int test=in.nextInt();
+        while(test-->0){
+            int n=in.nextInt();
+            int m=in.nextInt();
+            int x=in.nextInt();
+             PriorityQueue<pair> pq=new PriorityQueue<>();
+            int arr[]=new int[n];
+            for(int i=1;i<=m;i++){
+                pq.add(new pair(i,0));
+            }
+            System.out.println(""YES"");
+            for(int i=0;i<n;i++){
+                pair p=pq.poll();
+                int a=in.nextInt();
+                p.y+=a;
+                pq.add(p);
+                System.out.print(p.x+"" "");
+            }
+            
+            
+            
+            System.out.println();
+        }
+        
+        
+       
+        
+        
+//        int sum=in.nextInt();
+//        
+//        boolean dp[][]=new boolean[n+1][sum+1];
+//        
+//        for(int i=0;i<=n;i++){
+//            for(int j=0;j<=sum;j++){
+//                if(i==0)
+//                    dp[i][j]=false;
+//                if(j==0)
+//                    dp[i][j]=true;
+//                    
+//            }
+//        }
+//        
+//        for(int i=1;i<=n;i++){
+//            for(int j=1;j<=sum;j++){
+//                if(arr[i-1]<=j)
+//                    dp[i][j]=(dp[i-1][j])||(dp[i-1][j-arr[i-1]]);
+//                else
+//                    dp[i][j]=dp[i-1][j];
+//                
+//            }
+//        }
+//         boolean flag=false;
+//        for(int i=0;i<=n;i++){
+//            if(dp[i][sum]==true){
+//                flag=true;
+//                System.out.println(1);
+//                break;
+//            }
+//            
+//        }
+//        if(!flag)
+//            System.out.println(0);
+    }
+    public static void solve1(int n,int arr[]){
+        int b[]=new int[2*n+1];
+        for(int i=0;i<n;i++){
+            b[arr[i]]=i+1;
+        }
+        int count=0;
+        for(int i=3;i<2*n;i++){
+        for(int j=1;j*j<i;j++){
+            if(i%j==0 && i!=j*j){
+                if(b[j]+b[i/j]==i){
+                    count++;
+                }
+            }
+        }
+    }
+        System.out.println(count);
+    }
+    public static long modpow(long a, long b){
+	    if(b==0){
+	        return 1;
+	    }
+	    long x = modpow(a, b/2);
+	    x = (x*x)%modulo;
+	    if(b%2==1){
+	        return (x*a)%modulo;
+	    }
+	    return x;
+	}
+    public static long factorial(long n){
+        if(n==1) return 1;
+        if(n==2) return 2;
+        if(n==3) return 6;
+        return n*factorial(n-1);
+    }
+    public static long benches(int n){
+        return ncr(n,5)*n*(n-1)*(n-2)*(n-3)*(n-4);
+    }
+    public static long ncr(int n,int r){
+        long dp[][]=new long[n+1][r+1];
+        
+        for(int i=0;i<=n;i++){
+            for(int j=0;j<=Math.min(i,r);j++){
+                if(j==0 ||j==i)
+                    dp[i][j]=1;
+                else{
+                    dp[i][j]=dp[i-1][j]+dp[i-1][j-1];
+                }
+            }
+        }
+        
+        return dp[n][r];
+    }
+    public static  long select(int n){
+    return ncr(n,5)+ncr(n,6)+ncr(n,7);
+
+    }
+    public static long ncr1(int n,int r){
+        long k=Math.max(r,n-r);
+        long num=1;
+        long den=1;
+        long j=1;
+        
+        for(long i=n;i>k;i--){
+            num*=i;
+            den*=j;
+            j++;
+        }
+        return num/den;
+    }
+    public static int countDiff(int arr[],int n,int diff){
+        int sum=0;
+       
+        for(int i=0;i<n;i++){
+            
+            sum+=arr[i];
+        }
+        
+        int max=sum/2;
+        
+        boolean dp[][]=new boolean[n+1][max+1];
+        
+        for(int i=0;i<=n;i++){
+            for(int j=0;j<=max;j++){
+                if(i==0)
+                    dp[i][j]=false;
+                if(j==0)
+                    dp[i][j]=true;
+            }
+        }
+        
+        for(int i=1;i<=n;i++){
+            for(int j=1;j<=max;j++){
+                if(arr[i-1]<=j)
+                    dp[i][j]=dp[i-1][j]||dp[i-1][j-arr[i-1]];
+                else
+                    dp[i][j]=dp[i-1][j];
+            }
+        }
+        int min=0;
+        int count=0;
+        for(int j=0;j<=max;j++){
+            min=0;
+            if(dp[n][j]==true){
+                min=sum-2*j;
+                if(min==diff)
+                    count++;
+            }
+        }
+        
+        return count;
+    }
+    public static int minimumDiff(int arr[],int n){
+        int sum=0;
+       
+        for(int i=0;i<n;i++){
+            
+            sum+=arr[i];
+        }
+        
+        int max=sum/2;
+        
+        boolean dp[][]=new boolean[n+1][max+1];
+        
+        for(int i=0;i<=n;i++){
+            for(int j=0;j<=max;j++){
+                if(i==0)
+                    dp[i][j]=false;
+                if(j==0)
+                    dp[i][j]=true;
+            }
+        }
+        
+        for(int i=1;i<=n;i++){
+            for(int j=1;j<=max;j++){
+                if(arr[i-1]<=j)
+                    dp[i][j]=dp[i-1][j]||dp[i-1][j-arr[i-1]];
+                else
+                    dp[i][j]=dp[i-1][j];
+            }
+        }
+        int min=Integer.MAX_VALUE;
+        for(int j=0;j<=max;j++){
+            if(dp[n][j]==true){
+                min=Math.min(min,sum-2*j);
+            }
+        }
+        
+        return min;
+    }
+    public static int findTargetSumWays(int[] nums, int target) {
+        int n=nums.length;
+         int dp[][]=new int[n+1][target+1];
+         
+         for(int i=0;i<=n;i++){
+             for(int j=0;j<=target;j++){
+                 if(i==0)
+                 dp[i][j]=0;
+                 
+                 if(j==0)
+                     dp[i][j]=1;
+             }
+         }
+         
+         for(int i=1;i<=n;i++){
+             for(int j=1;j<=target;j++){
+                 if(nums[i-1]<=j)
+                     dp[i][j]=dp[i-1][j]+dp[i-1][j-nums[i-1]];
+                 else
+                     dp[i][j]=dp[i-1][j];
+             }
+         }
+         
+//         for(int i=0;i<=n;i++){
+//             for(int j=0;j<=target;j++){
+//                 System.out.print(dp[i][j]+"" "");
+//             }
+//             System.out.println();
+//         }
+         
+         return dp[n][target];
+         
+    }
+    static int equalPartition(int n, int arr[],int sum)
+    {
+       
+       
+      
+           int max=sum;
+           boolean dp[][]=new boolean[n+1][max+1];
+           
+           for(int i=0;i<=n;i++){
+               for(int j=0;j<=max;j++){
+                   if(i==0)
+                   dp[i][j]=false;
+                   if(j==0)
+                   dp[i][j]=true;
+               }
+           }
+           
+           for(int i=1;i<=n;i++){
+               for(int j=1;j<=max;j++){
+                   if(arr[i-1]<=j){
+                       dp[i][j]=(dp[i-1][j]||dp[i-1][j-arr[i-1]]);
+                   }
+                   else{
+                       dp[i][j]=dp[i-1][j];
+                   }
+               }
+           }
+           
+           for(int i=0;i<=n;i++){
+               for(int j=0;j<=max;j++){
+                   System.out.print(dp[i][j]+"" "");
+               }
+               System.out.println();
+           }
+           int count=0;
+           for(int i=0;i<=n;i++){
+            if(dp[i][max]==true){
+               
+                count++;
+            }
+            
+        }
+        return count;
+       }
+    
+    public static long power(long base,long power){
+        long res=1;
+        while(power!=0){
+            if(power%2==0){
+                power/=2;
+                base=(base*base);
+            }
+            else{
+                power--;
+                res=(res*base);
+            }
+            
+        }
+        return res;
+    }
+}
+class FastScanner {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st = new StringTokenizer("""");
+ 
+		String next() {
+			while (!st.hasMoreTokens())
+				try {
+					st = new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			return st.nextToken();
+		}
+ 
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+ 
+		int[] readArray(int n) {
+			int[] a = new int[n];
+			for (int i = 0; i < n; i++)
+				a[i] = nextInt();
+			return a;
+		}
+ 
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+	}
+class pair implements Comparable<pair>
+	    {
+	        int x;
+	        int y;
+ 
+	        pair(int x, int y) {
+	            this.x = x;
+	            this.y = y;
+	        }
+	        public int compareTo(pair o)
+	        {
+	        	return (int)(y-o.y);
+	        	
+	        }
+}",1
+0c173033,6b83b22e,"
+
+
+import java.io.*;
+import java.util.*;
+
+
+public class M {
+	static Scanner scanner=new Scanner(System.in);
+	public static void main(String[] args) {
+		int t=scanner.nextInt();
+		while(t-->0) {
+			int n=scanner.nextInt();
+			int a[]=new int [n];
+			int b[]=new int [n];
+			for(int i=0;i<n;i++)a[i]=scanner.nextInt();
+			for(int i=0;i+1<n;i+=2) {
+				b[i]=-a[i+1];
+				b[i+1]=a[i];
+			}
+			if(n%2==1) {
+				int x=a[n-1],y=a[n-2],z=a[n-3];
+				if(x+y!=0) {
+					b[n-3]=x+y;
+					b[n-2]=-z;
+					b[n-1]=-z;
+				}else if(y+z!=0) {
+					b[n-1]=y+z;
+					b[n-2]=-x;
+					b[n-3]=-x;
+				}else {
+					b[n-2]=x+z;
+					b[n-1]=-y;
+					b[n-3]=-y;
+				}
+			}
+			StringBuilder sb=new StringBuilder();
+			for(int i=0;i<n;i++)sb.append(b[i]+"" "");
+			System.out.println(sb);
+		}
+	}
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+","import java.util.Scanner;
+
+public class Subsequence {
+	private static Scanner sc = new Scanner(System.in);
+	
+	public static void main(String args[]) {
+		int t = sc.nextInt();
+		
+		while(t-->0) {
+			int n = sc.nextInt();
+			
+			int a[] = new int[n];
+			int b[] =  new int[n];
+			
+			for(int i=0;i<n;i++) {
+				a[i]= sc.nextInt();
+				
+			}
+			
+			if(n%2==0) {
+				calculateB(a,b,n);
+			}
+			else {
+				calculateB(a,b,n-3);
+				if (a[n - 2] + a[n - 3] != 0) {
+					b[n - 3] = -a[n - 1];
+					b[n - 2] = -a[n - 1];
+					b[n - 1] = a[n - 2] + a[n - 3];
+				} else if (a[n - 2] + a[n - 1] != 0) {
+					b[n - 3] = a[n - 2] + a[n - 1];
+					b[n - 2] = -a[n - 3];
+					b[n - 1] = -a[n - 3];
+				} else {
+					b[n - 3] = -a[n - 2];
+					b[n - 2] = a[n - 3] + a[n - 1];
+					b[n - 1] = -a[n - 2];
+				}
+			}
+			
+			for(int i=0;i<n;i++) {
+				System.out.print(b[i] + "" "");
+			}
+			System.out.println();
+		}
+
+	}
+
+	private static void calculateB(int[] a, int[] b, int n) {
+		
+		for(int i=0;i<n-1;i=i+2) {
+			b[i] = -a[i+1];
+			b[i+1] = a[i];
+		}
+		
+	}
+}
+",1
+24044589,e435b1ac,"import java.util.*;
+import java.io.*;
+
+public class C_Phoenix_and_Towers{
+    public static void main(String[] args) {
+        FastScanner s= new FastScanner();
+        StringBuilder res = new StringBuilder();
+        int t=s.nextInt();
+        int p=0;
+        while(p<t){
+        int n=s.nextInt();
+        int m=s.nextInt();
+        int x=s.nextInt();
+        int array[]= new int[n];
+        HashMap<Integer,Queue<Integer>> indices = new HashMap<Integer,Queue<Integer>>();
+        for(int i=0;i<n;i++){
+            array[i]=s.nextInt();
+            if(indices.containsKey(array[i])){
+              indices.get(array[i]).add(i);
+            }
+            else{
+                Queue<Integer> obj = new LinkedList<Integer>();
+                obj.add(i);
+                indices.put(array[i],obj);
+            }
+        }
+        long tower[]= new long[m];
+        int ans[]= new int[n];
+        Arrays.sort(array);
+        int k=0;
+        for(int i=0;i<n;i++){
+            tower[k]+=array[i];
+            int a=indices.get(array[i]).poll();
+            ans[a]=k+1;
+            k++;
+            if(k==m){
+                k=0;
+            }
+
+        }
+        long max=Long.MIN_VALUE;
+        long min=Long.MAX_VALUE;
+        for(int i=0;i<m;i++){
+            min=Math.min(min,tower[i]);
+            max=Math.max(max,tower[i]);
+        }
+        if(max-min<=x){
+            res.append(""YES\n"");
+            for(int i=0;i<n;i++){
+                res.append(ans[i]+"" "");
+            }
+            res.append(""\n"");
+        }
+        else{
+            res.append(""NO\n"");
+        }
+        p++;
+    }
+    System.out.println(res);
+
+    }
+    static class FastScanner {
+		BufferedReader br;
+		StringTokenizer st;
+ 
+		public FastScanner(String s) {
+			try {
+				br = new BufferedReader(new FileReader(s));
+			} catch (FileNotFoundException e) {
+				// TODO Auto-generated catch block
+				e.printStackTrace();
+			}
+		}
+ 
+		public FastScanner() {
+			br = new BufferedReader(new InputStreamReader(System.in));
+		}
+ 
+		String nextToken() {
+			while (st == null || !st.hasMoreElements()) {
+				try {
+					st = new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					// TODO Auto-generated catch block
+					e.printStackTrace();
+				}
+			}
+			return st.nextToken();
+		}
+ 
+		int nextInt() {
+			return Integer.parseInt(nextToken());
+		}
+ 
+		long nextLong() {
+			return Long.parseLong(nextToken());
+		}
+ 
+		double nextDouble() {
+			return Double.parseDouble(nextToken());
+		}
+	}
+
+
+
+
+}","import java.util.*;
+import java.io.*;
+public class C {
+
+	public static void main(String[] args) {
+		FastScanner sc = new FastScanner();
+		int T = sc.nextInt();
+		StringBuilder sb = new StringBuilder();
+		while(T-->0) {
+			int n = sc.nextInt();
+			int m = sc.nextInt();
+			long x = sc.nextLong();
+			long[] arr = new long[n];
+			for(int i = 0; i < n; i++) {
+				arr[i] = sc.nextLong();
+			}
+			int[] res = new int[n];
+			PriorityQueue<Pair> q = new PriorityQueue<>();
+			for(int i = 0; i < m; i++) {
+				q.add(new Pair(i+1, 0));
+			}
+			for(int i = 0; i < n; i++) {
+				Pair p = q.poll();
+				res[i] = p.i;
+				q.add(new Pair(p.i, p.w + arr[i]));
+			}
+			sb.append(""YES\n"");
+			for(int i = 0; i < n; i++) {
+				sb.append(res[i]+"" "");
+			}
+			sb.replace(sb.length()-1, sb.length(), ""\n"");
+		}
+		PrintWriter pw = new PrintWriter(System.out);
+		pw.println(sb.toString().trim());
+		pw.flush();
+
+	}
+	static class Pair implements Comparable<Pair>{
+		int i; long w;
+		public Pair(int i, long w) {
+			this.i = i; this.w = w;
+		}
+		public String toString() {
+			return i+"" ""+w;
+		}
+		@Override
+		public int compareTo(Pair p) {
+			return Long.compare(w, p.w);
+		}
+	}
+	
+	static class FastScanner {
+		public BufferedReader reader;
+		public StringTokenizer tokenizer;
+		public FastScanner() {
+			reader = new BufferedReader(new InputStreamReader(System.in), 32768);
+			tokenizer = null;
+		}
+		public String next() {
+			while (tokenizer == null || !tokenizer.hasMoreTokens()) {
+				try {
+					tokenizer = new StringTokenizer(reader.readLine());
+				} catch (IOException e) {
+					throw new RuntimeException(e);
+				}
+			}
+			return tokenizer.nextToken();
+		}
+		public int nextInt() {
+			return Integer.parseInt(next());
+		}
+		public long nextLong() {
+			return Long.parseLong(next());
+		}
+		public double nextDouble() {
+			return Double.parseDouble(next());
+		}
+		public String nextLine() {
+			try {
+				return reader.readLine();
+			} catch(IOException e) {
+				throw new RuntimeException(e);
+			}
+		}
+	}
+
+}
+",0
+8535bdf7,e86eb5b0,"import java.util.*;
+import java.io.*;
+import java.lang.*;
+public class Problem {
+    public static void dfs(int u, int parent, ArrayList<ArrayList<Integer>> graph,long[][] dp,Pair[] arr)
+    {
+        ArrayList<Integer> adja=graph.get(u);
+        for(int i=0;i<adja.size();i++)
+        {
+            int adja_ele=adja.get(i);
+            if(adja_ele!=parent)
+            {
+                dfs(adja_ele, u,graph,dp,arr);
+                long res1=Math.max(Math.abs(arr[u].getL()-arr[adja_ele].getL())+dp[adja_ele][0],Math.abs(arr[u].getL()-arr[adja_ele].getR())+dp[adja_ele][1]);
+                long res2=Math.max(Math.abs(arr[u].getR()-arr[adja_ele].getL())+dp[adja_ele][0],Math.abs(arr[u].getR()-arr[adja_ele].getR())+dp[adja_ele][1]);
+                dp[u][0]+=res1;
+                dp[u][1]+=res2;
+//                System.out.println(u+"" ""+adja_ele+"" ""+res1+"" ""+res2);
+
+            }
+        }
+    }
+
+
+
+    public static void main(String[] args) throws IOException{
+        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+        int t =Integer.parseInt(br.readLine());
+        while(t-- >0)
+        {
+
+            int n =Integer.parseInt(br.readLine().trim());
+            Pair[] arr=new Pair[n+1];
+
+            for(int i=1;i<n+1;i++) {
+                String[] sa=br.readLine().trim().split("" "");
+                int l=Integer.parseInt(sa[0]);
+                int r=Integer.parseInt(sa[1]);
+                Pair p=new Pair(l,r);
+                arr[i]=p;
+            }
+            ArrayList<ArrayList<Integer>> graph=new ArrayList<ArrayList<Integer>>(n+1);
+            for(int i=0;i<n+1;i++)
+            {
+               graph.add(new ArrayList<Integer>());
+            }
+            for(int i=0;i<n-1;i++)
+            {
+                String[] sa=br.readLine().trim().split("" "");
+                int u=Integer.parseInt(sa[0]);
+                int v=Integer.parseInt(sa[1]);
+                graph.get(u).add(v);
+                graph.get(v).add(u);
+            }
+            long[][] dp=new long[n+1][2];
+            dfs(1,0,graph,dp,arr);
+//            for(int i=0;i<dp.length;i++)
+//            {
+//                System.out.println(dp[i][0]+"" ""+dp[i][1]);
+//            }
+            System.out.println(Math.max(dp[1][0],dp[1][1]));
+        }
+    }
+
+}
+class Pair
+{
+    private int l;
+    private int r;
+
+    public Pair(int l, int r) {
+        this.l = l;
+        this.r = r;
+    }
+
+    public int getL() {
+        return l;
+    }
+
+    public void setL(int l) {
+        this.l = l;
+    }
+
+    public int getR() {
+        return r;
+    }
+
+    public void setR(int r) {
+        this.r = r;
+    }
+}
+
+","import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+import java.util.List;
+
+
+public class Exam1 {
+    /*
+    1. Time complexity: O(t*n*logn).
+    2. Space complexity: O(n).
+    2. n*t < 10^8 , it should be finished in the time constraint.
+     */
+
+    static int[] l, r;
+    static List<Integer>[] adj;
+    static Long[][] a;
+    public static void main(String[] args) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        String s = br.readLine();
+        int t = Integer.parseInt(s);
+        while (t-- > 0) {
+            s = br.readLine();
+            int n = Integer.parseInt(s);
+            l = new int[n];
+            r = new int[n];
+            for (int i = 0; i < n; i++) {
+                s = br.readLine();
+                String[] num = s.split("" "");
+                l[i] = Integer.parseInt(num[0]);
+                r[i] = Integer.parseInt(num[1]);
+            }
+            adj = new ArrayList[n];
+            for (int i = 0; i < n; i++) adj[i] = new ArrayList<>();
+            for (int i = 1; i < n; i++) {
+                s = br.readLine();
+                String[] num = s.split("" "");
+                int u = Integer.parseInt(num[0]) - 1, v = Integer.parseInt(num[1]) - 1;
+                adj[u].add(v);
+                adj[v].add(u);
+            }
+            a = new Long[n][2];
+            dfs(0, 0);
+            System.out.println(Math.max(a[0][0], a[0][1]));
+        }
+    }
+    private static void dfs(int cur, int fa) {
+        a[cur][0] = a[cur][1] = 0L;
+        for (int i = 0; i < adj[cur].size(); i++) {
+            int p = adj[cur].get(i);
+            if (p == fa) continue;
+            dfs(p, cur);
+            a[cur][0] += Math.max(a[p][0] + Math.abs(l[cur] - l[p]), a[p][1] + Math.abs(l[cur] - r[p]));
+            a[cur][1] += Math.max(a[p][0] + Math.abs(r[cur] - l[p]), a[p][1] + Math.abs(r[cur] - r[p]));
+        }
+    }
+}
+   			 	     	  			 		 	 	 	 		",0
+83b44c9c,ed610dc9,"import java.util.Scanner;
+
+public class MinimumGridPath {
+    public static void main(String[] args) {
+        Scanner scanner = new Scanner(System.in);
+        int test = scanner.nextInt();
+
+        StringBuilder sb = new StringBuilder();
+        for (int t = 0; t < test; t++) {
+            int n = scanner.nextInt();
+            long[] arr = new long[n];
+            for (int i = 0; i < n; i++) {
+                arr[i] = scanner.nextLong();
+            }
+
+            long minx = arr[0];
+            long miny = arr[1];
+
+            long min = minx * n + miny * n;
+            long sumx = arr[0];
+            long sumy = arr[1];
+
+            for(int i=2; i<n; i++) {
+                int xc;
+                int yc;
+                if(i%2 == 0) {
+                    xc = i/2 + 1;
+                    yc = i/2;
+                    sumx += arr[i];
+                    minx = Math.min(minx, arr[i]);
+                } else {
+                    xc = i/2 + 1;
+                    yc = i/2 + 1;
+                    sumy += arr[i];
+                    miny = Math.min(miny, arr[i]);
+                }
+                min = Math.min(min, sumx + (n-xc) * minx + sumy + (n-yc) * miny);
+            }
+
+
+            sb.append(min).append(System.lineSeparator());
+        }
+        System.out.println(sb);
+
+    }
+}
+
+/*
+// yehara
+import java.io.PrintWriter;
+import java.util.*;
+
+public class C {
+
+    static Scanner sc;
+    static PrintWriter out;
+
+    public static void main(String[] args) throws Exception {
+        sc = new Scanner(System.in);
+        out = new PrintWriter(System.out);
+        int t = sc.nextInt();
+        for(int i=0; i<t; i++) {
+            solve();
+        }
+        out.flush();
+    }
+
+    static void solve() {
+        int n = sc.nextInt();
+        int[] c = new int[n];
+        for(int i=0; i<n; i++) {
+            c[i] = Integer.parseInt(sc.next());
+        }
+        long minx = c[0];
+        long miny = c[1];
+
+        long min = minx * n + miny * n;
+        long sumx = c[0];
+        long sumy = c[1];
+
+        for(int i=2; i<n; i++) {
+            int xc;
+            int yc;
+            if(i%2 == 0) {
+                xc = i/2 + 1;
+                yc = i/2;
+                sumx += c[i];
+                minx = Math.min(minx, c[i]);
+            } else {
+                xc = i/2 + 1;
+                yc = i/2 + 1;
+                sumy += c[i];
+                miny = Math.min(miny, c[i]);
+            }
+            min = Math.min(min, sumx + (n-xc) * minx + sumy + (n-yc) * miny);
+        }
+
+        out.println(min);
+
+    }
+
+}
+
+ */
+","/*
+ * akshaygupta26
+ */
+import java.io.BufferedReader; 
+import java.io.IOException; 
+import java.io.InputStreamReader; 
+import java.util.Scanner; 
+import java.util.Random;
+import java.util.Arrays;
+import java.util.StringTokenizer; 
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Collections;
+import java.util.*;
+public class C 
+{ 
+    public static void main(String[] args) 
+	{ 
+		FastReader sc=new FastReader(); 
+		StringBuffer ans=new StringBuffer();
+		int test=sc.nextInt();
+		while(test-->0)
+		{
+			int n=sc.nextInt();
+			long arr[]=new long[n];
+			for(int i=0;i<n;i++) {
+				arr[i]=sc.nextLong();
+			}
+			long nn=n;
+			long ep=1;
+			long op=1;
+			
+			long se=arr[0];
+			long so=arr[1];
+			
+			long sume=se;long sumo=so;
+			long minm = (se*nn) +(so*nn);
+			
+			for(int i=2;i<n;i++) {
+				if(i%2 == 0) {
+					++ep;
+					sume+=arr[i];
+					se=Math.min(se, arr[i]);
+				}
+				else {
+					++op;
+					sumo+=arr[i];
+					so=Math.min(so, arr[i]);
+				}
+				
+				long cost = (sume)+(se*(nn-ep));
+				cost+=((sumo)+(so*(nn-op)));
+				minm=Math.min(cost, minm);
+			}
+			ans.append(minm+""\n"");
+		
+		}
+		
+	    System.out.print(ans);
+	} 
+        
+    static final Random random=new Random();
+    
+	static void ruffleSort(int[] a) {
+		int n=a.length;//shuffle, then sort 
+		for (int i=0; i<n; i++) {
+			int oi=random.nextInt(n), temp=a[oi];
+			a[oi]=a[i]; a[i]=temp;
+		}
+		Arrays.sort(a);
+	}
+	
+	static void ruffleSort(long[] a) {
+		int n=a.length;//shuffle, then sort 
+		for (int i=0; i<n; i++) {
+			int oi=random.nextInt(n);
+			long temp=a[oi];
+			a[oi]=a[i]; a[i]=temp;
+		}
+		Arrays.sort(a);
+	}
+	
+	static class FastReader 
+	{ 
+		BufferedReader br; 
+		StringTokenizer st; 
+
+		public FastReader() 
+		{ 
+			br = new BufferedReader(new
+					InputStreamReader(System.in)); 
+		} 
+
+		String next() 
+		{ 
+			while (st == null || !st.hasMoreElements()) 
+			{ 
+				try
+				{ 
+					st = new StringTokenizer(br.readLine()); 
+				} 
+				catch (IOException e) 
+				{ 
+					e.printStackTrace(); 
+				} 
+			} 
+			return st.nextToken(); 
+		} 
+
+		int nextInt() 
+		{ 
+			return Integer.parseInt(next()); 
+		} 
+
+		long nextLong() 
+		{ 
+			return Long.parseLong(next()); 
+		} 
+
+		double nextDouble() 
+		{ 
+			return Double.parseDouble(next()); 
+		} 
+
+		String nextLine() 
+		{ 
+			String str = """"; 
+			try
+			{ 
+				str = br.readLine(); 
+			} 
+			catch (IOException e) 
+			{ 
+				e.printStackTrace(); 
+			} 
+			return str; 
+		} 
+	} 
+
+
+} 
+",0
+2c7a0000,4201fdf7,"import java.io.*;
+import java.util.*;
+ 
+public class Codeforces {
+	public static void main(String[] args) throws IOException {
+		
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		//int cases = Integer.parseInt(br.readLine());
+		//while(cases-- > 0) {
+			int n = Integer.parseInt(br.readLine());
+			String[] str = br.readLine().split("" "");
+			int[] a = new int[n];
+			int k = 0;
+			ArrayList<Integer> pos = new ArrayList<>();
+			for(int i=0; i<n; i++) {
+				a[i] = Integer.parseInt(str[i]);
+				if(a[i] == 1) {
+					k++;
+					pos.add(i);
+				}
+			}
+			int[][] dp = new int[n+1][k+1];
+			for(int i=0; i<=n; i++) {
+				Arrays.fill(dp[i], Integer.MAX_VALUE);
+			}
+			dp[0][0] = 0;
+			for(int i=0; i<n; i++) {
+				for(int j=0; j<=k; j++) {
+					if(dp[i][j] == Integer.MAX_VALUE) {
+						continue;
+					}
+					dp[i+1][j] = Math.min(dp[i+1][j], dp[i][j]);
+					if(j < k && a[i] == 0) {
+						dp[i+1][j+1] = Math.min(dp[i+1][j+1], dp[i][j]+Math.abs(pos.get(j)-i));
+					}
+				}
+			}
+			System.out.println(dp[n][k]);
+		//}
+	}
+}
+","//https://codeforces.com/contest/1525/problem/D
+//D. Armchairs
+import java.util.*;
+import java.io.*;
+public class CF_1525_D{
+	public static void main(String[] args) throws Exception{
+		
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		PrintWriter pw = new PrintWriter(new OutputStreamWriter(System.out));
+		StringBuilder sb = new StringBuilder();
+		StringTokenizer st;
+
+		int n = Integer.parseInt(br.readLine());
+		int a[] = new int[n];
+		ArrayList<Integer> pos = new ArrayList<Integer>();
+
+		st = new StringTokenizer(br.readLine());
+		for(int i=0;i<n;i++){
+			a[i] = Integer.parseInt(st.nextToken());
+			if(a[i]==1)
+				pos.add(i);
+		}
+
+		int z = pos.size();
+		int dp[][] = new int[n+1][z+1];
+		for(int i=0;i<=n;i++)
+			Arrays.fill(dp[i], Integer.MAX_VALUE);
+
+		dp[0][0] = 0;
+		for(int i=0;i<n;i++){
+			for(int j=0;j<=z;j++){
+				if(dp[i][j] == Integer.MAX_VALUE)
+					continue;
+				dp[i+1][j] = Math.min(dp[i+1][j], dp[i][j]);
+
+				if(j<z && a[i]==0)
+					dp[i+1][j+1] = Math.min(dp[i+1][j+1], dp[i][j]+Math.abs(pos.get(j)-i));
+			}
+		}
+
+
+		pw.print(dp[n][z]);
+		pw.flush();
+		pw.close();
+	}
+}",1
+24b20554,43b10dec,"import java.util.*;
+import java.lang.*;
+public class Codeforces {
+    static Scanner sr=new Scanner(System.in);
+    public static void main(String[] args) throws java.lang.Exception {
+        StringBuilder ans = new StringBuilder("""");
+        int T = sr.nextInt();
+        while (T-- > 0) {
+            int n=sr.nextInt();
+            int m=sr.nextInt();
+            int x=sr.nextInt();
+            TreeMap<Integer,ArrayList<Integer>>h=new TreeMap<>();
+            for(int i=0;i<n;i++)
+            {
+                int a=sr.nextInt();
+                if(!h.containsKey(a))
+                    h.put(a,new ArrayList<>());
+                h.get(a).add(i);
+            }
+            ans.append(""YES"");
+            ans.append('\n');
+            int an[]=new int[n];
+            int q=0;
+            for(int z:h.keySet())
+            {
+                for(int i=0;i<h.get(z).size();i++)
+                {
+                    an[h.get(z).get(i)]=(q++)%m+1;
+                }
+            }
+            for(int i=0;i<n;i++)
+                ans.append(an[i]+"" "");
+            ans.append('\n');
+        }
+        System.out.println(ans);
+    }
+}
+","// package eround101;
+
+import java.util.*;
+import java.io.*;
+import java.lang.*;
+import java.util.StringTokenizer;
+import java.util.concurrent.TimeUnit;
+
+public class C101 {
+
+    static HritikScanner sc = new HritikScanner();
+    static PrintWriter pw = new PrintWriter(System.out, true);
+    final static int MOD = (int) 1e9 + 7;
+    static StringBuilder sb = new StringBuilder();
+
+    public static void main(String[] args) {
+
+        int t = ni();
+        while (t-- > 0) {
+            solve();
+        }
+    }
+
+     static void solve() {
+         int n = ni();
+         int m = ni(), x = ni();
+         Map<Integer, ArrayList<Integer>> map = new TreeMap<>();
+         pl(""YES"");
+         for(int i = 0; i < n; i++)
+         {
+             int num = ni();
+             if(!map.containsKey(num))
+             {
+                 map.put(num, new ArrayList<Integer>());
+             }
+             map.get(num).add(i);
+         }
+         int[] ans = new int[n];
+         int q = 0;
+         for(int block : map.keySet())
+         {
+             for(int i = 0; i < map.get(block).size(); i++)
+             {
+                 ans[map.get(block).get(i)] = (q++)%m+1;
+             }
+         }
+         for(int ele : ans)
+         {
+             p(ele + "" "");
+         }
+         pl();
+     }
+    
+    
+    /////////////////////////////////////////////////////////////////////////////////
+    static int[] nextIntArray(int n) {
+        int[] arr = new int[n];
+        int i = 0;
+        while (i < n) {
+            arr[i++] = ni();
+        }
+        return arr;
+    }
+
+    static long[] nextLongArray(int n) {
+        long[] arr = new long[n];
+        int i = 0;
+        while (i < n) {
+            arr[i++] = nl();
+        }
+        return arr;
+    }
+
+    static int[] nextIntArray1(int n) {
+        int[] arr = new int[n + 1];
+        int i = 1;
+        while (i <= n) {
+            arr[i++] = ni();
+        }
+        return arr;
+    }
+
+    /////////////////////////////////////////////////////////////////////////////////
+    static int ni() {
+        return sc.nextInt();
+    }
+
+    static long nl() {
+        return sc.nextLong();
+    }
+
+    static double nd() {
+        return sc.nextDouble();
+    }
+
+    /////////////////////////////////////////////////////////////////////////////////
+    static void pl() {
+        pw.println();
+    }
+
+    static void p(Object o) {
+        pw.print(o);
+    }
+
+    static void pl(Object o) {
+        pw.println(o);
+    }
+
+    static void psb(StringBuilder sb) {
+        pw.print(sb);
+    }
+
+    static void pa(Object arr[]) {
+        for (Object o : arr) {
+            p(o);
+        }
+        pl();
+    }
+
+    static void pa(int arr[]) {
+        for (int o : arr) {
+            p(o);
+        }
+        pl();
+    }
+
+    static void pa(long arr[]) {
+        for (long o : arr) {
+            p(o);
+        }
+        pl();
+    }
+
+    static void pa(double arr[]) {
+        for (double o : arr) {
+            p(o);
+        }
+        pl();
+    }
+
+    static void pa(char arr[]) {
+        for (char o : arr) {
+            p(o);
+        }
+        pl();
+    }
+
+    static void pa(List list) {
+        for (Object o : list) {
+            p(o);
+        }
+        pl();
+    }
+
+    static void pa(Object[][] arr) {
+
+        for (int i = 0; i < arr.length; ++i) {
+            for (Object o : arr[i]) {
+                p(o);
+            }
+            pl();
+        }
+    }
+
+    static void pa(int[][] arr) {
+        for (int i = 0; i < arr.length; ++i) {
+            for (int o : arr[i]) {
+                p(o);
+            }
+            pl();
+        }
+    }
+
+    static void pa(long[][] arr) {
+        for (int i = 0; i < arr.length; ++i) {
+            for (long o : arr[i]) {
+                p(o);
+            }
+            pl();
+        }
+    }
+
+    static void pa(char[][] arr) {
+        for (int i = 0; i < arr.length; ++i) {
+            for (char o : arr[i]) {
+                p(o);
+            }
+            pl();
+        }
+    }
+
+    static void pa(double[][] arr) {
+        for (int i = 0; i < arr.length; ++i) {
+            for (double o : arr[i]) {
+                p(o);
+            }
+            pl();
+        }
+    }
+
+/////////////////////////////////////////////////////////////////////////////////
+    static void print(Object s) {
+        System.out.println(s);
+    }
+
+    /////////////////////////////////////////////////////////////////////////////////
+    //-----------HritikScanner class for faster input----------//
+    static class HritikScanner {
+
+        BufferedReader br;
+        StringTokenizer st;
+
+        public HritikScanner() {
+            br = new BufferedReader(new InputStreamReader(System.in));
+        }
+
+        String next() {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+
+        String nextLine() {
+            String str = """";
+            try {
+                str = br.readLine();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+        }
+    }
+
+    //////////////////////////////////////////////////////////////////
+    public static class Pair implements Comparable<Pair> {
+
+        int num, row,col;
+
+        Pair(int num, int row, int col) {
+            this.num = num;
+            this.row = row;
+            this.col = col;
+        }
+
+        public int get1() {
+            return num;
+        }
+
+        public int get2() {
+            return row;
+        }
+
+        public int compareTo(Pair A) {
+            return this.num - A.num;
+        }
+        
+        public String toString()
+        {
+            return num +"" ""+ row+"" ""+col;
+        }
+    }
+
+    //////////////////////////////////////////////////////////////////
+    // Function to return gcd of a and b time complexity O(log(a+b))
+    static long gcd(long a, long b) {
+        if (a == 0) {
+            return b;
+        }
+        return gcd(b % a, a);
+    }
+
+    // method to return LCM of two numbers 
+    static long lcm(int a, int b) {
+        return (a / gcd(a, b)) * b;
+    }
+
+    //////////////////////////////////////////////////////////////////
+    static boolean isPrime(long n) {
+        // Corner cases 
+        if (n <= 1) {
+            return false;
+        }
+        if (n <= 3) {
+            return true;
+        }
+
+        // This is checked so that we can skip  
+        // middle five numbers in below loop 
+        if (n % 2 == 0 || n % 3 == 0) {
+            return false;
+        }
+
+        for (long i = 5; i * i <= n; i = i + 6) {
+            if (n % i == 0 || n % (i + 2) == 0) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+    //////////////////////////////////////////////////////////////////
+
+    static boolean isPowerOfTwo(long n) {
+        if (n == 0) {
+            return false;
+        }
+
+        return (long) (Math.ceil((Math.log(n) / Math.log(2))))
+                == (long) (Math.floor(((Math.log(n) / Math.log(2)))));
+    }
+
+    public static long getFact(int n) {
+        long ans = 1;
+        while (n > 0) {
+            ans *= n;
+            ans %= MOD;
+            n--;
+        }
+        return ans;
+    }
+
+    public static long pow(long n, int pow) {
+        if (pow == 0) {
+            return 1;
+        }
+        long temp = pow(n, pow / 2) % MOD;
+        temp *= temp;
+        temp %= MOD;
+        if (pow % 2 == 1) {
+            temp *= n;
+        }
+        temp %= MOD;
+        return temp;
+
+    }
+
+    public static long nCr(int n, int r) {
+        long ans = 1;
+        int temp = n - r;
+        while (n > temp) {
+            ans *= n;
+            ans %= MOD;
+            n--;
+        }
+        ans *= pow(getFact(r) % MOD, MOD - 2) % MOD;
+        ans %= MOD;
+        return ans;
+    }
+
+    //////////////////////////////////////////////////////////////////
+    // method returns Nth power of A 
+    static double nthRoot(int A, int N) {
+
+        // intially guessing a random number between 
+        // 0 and 9 
+        double xPre = Math.random() % 10;
+
+        // smaller eps, denotes more accuracy 
+        double eps = 0.001;
+
+        // initializing difference between two 
+        // roots by INT_MAX 
+        double delX = 2147483647;
+
+        // xK denotes current value of x 
+        double xK = 0.0;
+
+        // loop untill we reach desired accuracy 
+        while (delX > eps) {
+            // calculating current value from previous 
+            // value by newton's method 
+            xK = ((N - 1.0) * xPre
+                    + (double) A / Math.pow(xPre, N - 1)) / (double) N;
+            delX = Math.abs(xK - xPre);
+            xPre = xK;
+        }
+
+        return xK;
+    }
+
+}
+",1
+175201f9,40cc90ae,"import java.util.*;
+import java.io.*;
+public class Sol{
+ 
+/*   
+->check n=1, int overflow , array bounds , all possibilites(dont stuck on 1 approach)
+->Problem = Observation(constraints(m<=n/3 or k<=min(100,n)) 
+           + Thinking + Technique (seg_tree,binary lift,rmq,bipart,dp,connected comp etc)
+->solve or leave it (- tutorial improves you in minimal way -)
+*/
+ 
+public static void main (String []args) {
+//precomp();
+ 
+int times=ni();while(times-->0){solve();}out.close();}
+
+static void solve(){
+ int n=ni();
+ int sum[]=new int[5]; 
+ PriorityQueue<Integer> p[]=new PriorityQueue[5];for(int i=0;i<5;i++)p[i]=new PriorityQueue<Integer>();
+ for(int i=0;i<n;i++){
+   char c[]=ns().toCharArray();
+   int len=c.length;
+   int csum[]=new int[5];
+   for(int j=0;j<len;j++){csum[c[j]-'a']++;}
+   for(int j=0;j<5;j++){csum[j]=2*csum[j]-len;p[j].offer(csum[j]);sum[j]+=csum[j];}
+ }
+ int max=0;
+ for(int i=0;i<5;i++){
+   int cmax=n;
+   while(p[i].size()>0 && sum[i]<=0){cmax--;sum[i]-=p[i].poll();}
+   max=Math.max(max,cmax);
+ }
+ out.println(max);
+ return;
+
+}
+
+//-----------------Utility--------------------------------------------
+
+static long gcd(long a,long b){if(b==0)return a; return gcd(b,a%b);}
+ 
+static int Max=Integer.MAX_VALUE; static long mod=1000000007;
+ 
+//static int v(char c){return (int)(c-'a');}
+ 
+public static long power(long x, long y )
+    {
+        //0^0 = 1
+        long res = 1L;
+        x = x%mod;
+        while(y > 0)
+        {
+            if((y&1)==1)
+                res = (res*x)%mod;
+            y >>= 1;
+            x = (x*x)%mod;
+        }
+        return res;
+    }
+ 
+static class Pair implements Comparable<Pair>{
+        int id;int value;Pair next;
+        public Pair(int id,int value) {
+         
+          this.id=id;this.value=value;next=null;
+        }
+        @Override
+        public int compareTo(Pair p){return Long.compare(value,p.value);}
+    }
+
+ 
+//----------------------I/O---------------------------------------------
+ 
+static InputStream inputStream = System.in;
+static OutputStream outputStream = System.out;
+static FastReader in=new FastReader(inputStream);
+static PrintWriter out=new PrintWriter(outputStream);
+ 
+static class FastReader 
+{ 
+  BufferedReader br; 
+  StringTokenizer st; 
+ 
+        FastReader(InputStream is) {
+            br = new BufferedReader(new InputStreamReader(is));
+        }
+ 
+  public String next() 
+  { 
+      while (st == null || !st.hasMoreElements()) 
+      { 
+          try
+          { 
+              st = new StringTokenizer(br.readLine()); 
+          } 
+          catch (IOException  e) 
+          { 
+              e.printStackTrace(); 
+          } 
+      } 
+      return st.nextToken(); 
+  } 
+ 
+  public int nextInt() 
+  { 
+      return Integer.parseInt(next()); 
+  } 
+ 
+  public long nextLong() 
+  { 
+      return Long.parseLong(next()); 
+  } 
+ 
+ public  double nextDouble() 
+  { 
+      return Double.parseDouble(next()); 
+  } 
+ 
+ 
+  String nextLine() 
+  { 
+      String str = """"; 
+      try
+      { 
+          str = br.readLine(); 
+      } 
+      catch (IOException e) 
+      { 
+          e.printStackTrace(); 
+      } 
+      return str; 
+  } 
+}
+/*static int ni() {
+        try {
+            boolean in = false;
+            int res = 0;
+            for (;;) {
+                int b = System.in.read() - '0';
+                if (b >= 0) {
+                    in = true;
+                    res = 10 * res + b;
+                }
+                else if (in)
+                    return res;
+            }
+        } catch (IOException e) {
+            throw new Error(e);
+        }
+    }*/
+static int ni(){return in.nextInt();}
+static long nl(){return in.nextLong();}
+static double nd(){return in.nextDouble();}
+static String ns(){return in.nextLine();}
+}","import javax.swing.text.html.parser.Entity;
+import java.io.*;
+import java.util.*;
+import java.math.BigInteger;
+
+
+public class Main{
+    public static void main(String[] args) {
+        InputStream inputStream = System.in;
+        OutputStream outputStream = System.out;
+        InputReader in = new InputReader(inputStream);
+        PrintWriter out = new PrintWriter(outputStream);
+        Task solver = new Task();
+        solver.solve(in, out);
+        out.close();
+    }
+    // main solver
+    static class Task{
+
+        double eps= 0.00000001;
+        static final int MAXN = 1010;
+        static final int MOD= 1000000007;
+
+        // stores smallest prime factor for every number
+        static int spf[] = new int[MAXN];
+
+        static boolean[] prime;
+
+        // Calculating SPF (Smallest Prime Factor) for every
+        // number till MAXN.
+        // Time Complexity : O(nloglogn)
+        public void sieve()
+        {
+            spf[1] = 1;
+            for (int i=2; i<MAXN; i++)
+
+                // marking smallest prime factor for every
+                // number to be itself.
+                spf[i] = i;
+
+            // separately marking spf for every even
+            // number as 2
+            for (int i=4; i<MAXN; i+=2)
+                spf[i] = 2;
+
+            for (int i=3; i*i<MAXN; i++)
+            {
+                // checking if i is prime
+                if (spf[i] == i)
+                {
+                    // marking SPF for all numbers divisible by i
+                    for (int j=i*i; j<MAXN; j+=i)
+
+                        // marking spf[j] if it is not
+                        // previously marked
+                        if (spf[j]==j)
+                            spf[j] = i;
+                }
+            }
+        }
+
+        void sieveOfEratosthenes(int n)
+        {
+            // Create a boolean array
+            // ""prime[0..n]"" and
+            // initialize all entries
+            // it as true. A value in
+            // prime[i] will finally be
+            // false if i is Not a
+            // prime, else true.
+            prime= new boolean[n + 1];
+            for (int i = 0; i <= n; i++)
+                prime[i] = true;
+
+            for (int p = 2; p * p <= n; p++)
+            {
+                // If prime[p] is not changed, then it is a
+                // prime
+                if (prime[p] == true)
+                {
+                    // Update all multiples of p
+                    for (int i = p * p; i <= n; i += p)
+                        prime[i] = false;
+                }
+            }
+        }
+
+        // function to find first index >= x
+        public int lowerIndex(List<Integer> arr, int n, int x)
+        {
+            int l = 0, h = n - 1;
+            while (l <= h)
+            {
+                int mid = (l + h) / 2;
+                if (arr.get(mid) >= x)
+                    h = mid - 1;
+                else
+                    l = mid + 1;
+            }
+            return l;
+        }
+        public int lowerIndex(int[] arr, int n, int x)
+        {
+            int l = 0, h = n - 1;
+            while (l <= h)
+            {
+                int mid = (l + h) / 2;
+                if (arr[mid] >= x)
+                    h = mid - 1;
+                else
+                    l = mid + 1;
+            }
+            return l;
+        }
+
+        // function to find last index <= y
+        public int upperIndex(List<Integer> arr, int n, int y)
+        {
+            int l = 0, h = n - 1;
+            while (l <= h)
+            {
+                int mid = (l + h) / 2;
+                if (arr.get(mid) <= y)
+                    l = mid + 1;
+                else
+                    h = mid - 1;
+            }
+            return h;
+        }
+        public int upperIndex(int[] arr, int n, int y)
+        {
+            int l = 0, h = n - 1;
+            while (l <= h)
+            {
+                int mid = (l + h) / 2;
+                if (arr[mid] <= y)
+                    l = mid + 1;
+                else
+                    h = mid - 1;
+            }
+            return h;
+        }
+
+        // function to count elements within given range
+        public int countInRange(List<Integer> arr, int n, int x, int y)
+        {
+            // initialize result
+            int count = 0;
+            count = upperIndex(arr, n, y) -
+                    lowerIndex(arr, n, x) + 1;
+            return count;
+        }
+
+        public int _gcd(int a,  int  b)
+        {
+
+            if(b == 0) {
+                return a;
+            }
+            else {
+                return _gcd(b, a % b);
+            }
+        }
+
+        public int add(int a, int b){
+            a+=b;
+            if(a>=MOD) a-=MOD;
+            else if(a<0) a+=MOD;
+            return a;
+        }
+
+        public int mul(int a, int b){
+            long res= (long)a*(long)b;
+            return (int)(res%MOD);
+        }
+
+        public int power(int a, int b) {
+            int ans=1;
+            while(b>0){
+                if((b&1)!=0) ans= mul(ans,a);
+                b>>=1;
+                a= mul(a,a);
+            }
+            return ans;
+        }
+
+        int[] fact= new int[MAXN];
+        int[] inv= new int[MAXN];
+
+        public int Ckn(int n, int k){
+            if(k<0 || n<0) return 0;
+            return mul(mul(fact[n],inv[k]),inv[n-k]);
+        }
+
+        public int inverse(int a){
+            return power(a,MOD-2);
+        }
+
+        public void preprocess() {
+            fact[0]=1;
+            for(int i=1;i<MAXN;i++) fact[i]= mul(fact[i-1],i);
+            inv[MAXN-1]= inverse(fact[MAXN-1]);
+            for(int i=MAXN-2;i>=0;i--){
+                inv[i]= mul(inv[i+1],i+1);
+            }
+        }
+
+        /**
+         * return VALUE of lower bound for unsorted array
+         */
+        public int lowerBoundNormalArray(int[] arr, int x){
+            TreeSet<Integer> set= new TreeSet<>();
+            for(int num: arr) set.add(num);
+            return set.lower(x);
+        }
+        /**
+         * return VALUE of upper bound for unsorted array
+         */
+        public int upperBoundNormalArray(int[] arr, int x){
+            TreeSet<Integer> set= new TreeSet<>();
+            for(int num: arr) set.add(num);
+            return set.higher(x);
+        }
+
+        public void debugArr(int[] arr){
+            for(int i: arr) out.print(i+"" "");
+            out.println();
+        }
+
+        public int rand(){
+            int min=0, max= MAXN;
+            int random_int = (int)Math.floor(Math.random()*(max-min+1)+min);
+            return random_int;
+        }
+
+        InputReader in; PrintWriter out;
+        static int mod = 1000000007;
+        int ans = 0;
+        ArrayList<Integer>g[] = new ArrayList[101];
+        int cnt[][] = new int[101][101];
+        int dp[][] = new int[101][101];
+        int Add(int a, int b){
+            a+=b; while (a>=mod)a-=mod;
+            return a;
+        }
+        int Mul(int a, int b){
+            return (int)(((long)a * b) % mod);
+        }
+        void dfs(int node, int par, int root, int depth){
+            cnt[root][depth]++;
+            for (int v : g[node]){
+                if (v != par){
+                    dfs(v, node, root, depth+1);
+                }
+            }
+        }
+        public void solve(InputReader in, PrintWriter out) {
+           int t = in.nextInt();
+           while (t-- > 0){
+               int n = in.nextInt();
+               String[] str = new String[n];
+               ArrayList<Integer> diff[] = new ArrayList[5];
+               for (int i = 0; i < 5; i++) diff[i] = new ArrayList<>();
+               for (int i = 0; i < n; i++){
+                   str[i] = in.nextToken();
+                   int[] cnt = new int[5];
+                   for (int j = 0; j < str[i].length(); j++){
+                       cnt[str[i].charAt(j) - 'a']++;
+                   }
+                   for (int j = 0; j < 5; j++){
+                       diff[j].add(cnt[j] * 2 - str[i].length());
+                   }
+               }
+               int ans = 0;
+               for (int i = 0; i < 5; i++){
+                   Collections.sort(diff[i]);
+                   Collections.reverse(diff[i]);
+                   int cur = 0, x = 0;
+                   for (int j = 0; j < diff[i].size(); j++){
+                       cur+=diff[i].get(j);
+                       if (cur <= 0){
+                           break;
+                       }
+                       x++;
+                   }
+                   ans = Math.max(ans, x);
+               }
+               out.println(ans);
+           }
+        }
+
+        class SEG {
+            int n;
+            int[] segs;
+            public SEG (int[] a){
+                this.n= a.length;
+                segs= new int[4*this.n];
+                build(a,0,0,this.n-1);
+            }
+            public void build(int[] a, int root, int l, int r){
+                if(l==r){
+                    segs[root]=a[l];
+                    return;
+                }
+                int m= (l+r)/2;
+                build(a,2*root+1,l,m);
+                build(a,2*root+2,m+1,r);
+                segs[root]= _gcd(segs[2*root+1], segs[2*root+2]);
+            }
+            public int query(int root, int l, int r, int lq, int rq){
+                if(lq<=l && rq>=r) return segs[root];
+                if(lq>r || rq<l) return 0;
+                int m= (l+r)/2;
+                int left= query(2*root+1, l, m, lq, rq);
+                int right= query(2*root+2, m+1, r, lq, rq);
+                return _gcd(left,right);
+            }
+
+        }
+
+    }
+
+    static class Venice{
+        public Map<Long,Long> m= new HashMap<>();
+        public long base=0;
+        public long totalValue=0;
+        private int M= 1000000007;
+
+        private long addMod(long a, long b){
+            a+=b;
+            if(a>=M) a-=M;
+            return a;
+        }
+
+        public void reset(){
+            m= new HashMap<>();
+            base=0;
+            totalValue=0;
+        }
+        public void update(long add){
+            base= base+ add;
+        }
+        public void add(long key, long val){
+            long newKey= key-base;
+            m.put(newKey, addMod(m.getOrDefault(newKey,(long)0),val));
+        }
+    }
+
+
+
+    static class Tuple implements Comparable<Tuple>{
+        int x, y, z;
+        public Tuple(int x, int y, int z){
+            this.x= x;
+            this.y= y;
+            this.z=z;
+        }
+        @Override
+        public int compareTo(Tuple o){
+            return this.x-o.x;
+        }
+    }
+
+    static class Pair implements Comparable<Pair>{
+        public int x;
+        public int y;
+        public Pair(int x, int y){
+            this.x= x;
+            this.y= y;
+        }
+
+        @Override
+        public int compareTo(Pair o) {
+            return this.x-o.x;
+        }
+    }
+
+    // public static class compareL implements Comparator<Tuple>{
+    //     @Override
+    //     public int compare(Tuple t1, Tuple t2) {
+    //         return t2.l - t1.l;
+    //     }
+    // }
+
+    // fast input reader class;
+    static class InputReader {
+        BufferedReader br;
+        StringTokenizer st;
+
+        public InputReader(InputStream stream) {
+            br = new BufferedReader(new InputStreamReader(stream));
+        }
+
+        public String nextToken() {
+            while (st == null || !st.hasMoreTokens()) {
+                String line = null;
+                try {
+                    line = br.readLine();
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+                if (line == null) {
+                    return null;
+                }
+                st = new StringTokenizer(line);
+            }
+            return st.nextToken();
+        }
+
+        public int nextInt() {
+            return Integer.parseInt(nextToken());
+        }
+        public double nextDouble(){
+            return Double.parseDouble(nextToken());
+        }
+        public long nextLong(){
+            return Long.parseLong(nextToken());
+        }
+        public int[] nextIntArr(int n){
+            int[] arr= new int[n];
+            for(int i=0;i<n;i++) arr[i]= nextInt();
+            return arr;
+        }
+        public long[] nextLongArr(int n){
+            long[] arr= new long[n];
+            for(int i=0;i<n;i++) arr[i]= nextLong();
+            return arr;
+        }
+        public List<Integer> nextIntList(int n){
+            List<Integer> arr= new ArrayList<>();
+            for(int i=0;i<n;i++) arr.add(nextInt());
+            return arr;
+        }
+        public int[][] nextIntMatArr(int n, int m){
+            int[][] mat= new int[n][m];
+            for(int i=0;i<n;i++) for(int j=0;j<m;j++) mat[i][j]= nextInt();
+            return mat;
+        }
+        public List<List<Integer>> nextIntMatList(int n, int m){
+            List<List<Integer>> mat= new ArrayList<>();
+            for(int i=0;i<n;i++){
+                List<Integer> temp= new ArrayList<>();
+                for(int j=0;j<m;j++) temp.add(nextInt());
+                mat.add(temp);
+            }
+            return mat;
+        }
+        public char[] nextStringCharArr(){
+            return nextToken().toCharArray();
+        }
+    }
+}",0
+1469697d,69c86b61,"import java.util.*;
+import java.io.*;
+
+public class Test {
+    // global variables
+    static final long INF = 1000000000000000000L;
+
+    static class FastReader {
+        BufferedReader br;
+        StringTokenizer st;
+
+        public FastReader() throws FileNotFoundException {
+            br = new BufferedReader(
+                    new InputStreamReader(System.in));
+        }
+
+        String next() {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+
+        String nextLine() {
+            String str = """";
+            try {
+                str = br.readLine();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+        }
+    }
+
+    static FastReader s;
+
+    public static void main(String[] args)
+            throws IOException {
+        if (System.getProperty(""ONLINE_JUDGE"") == null) {
+
+            PrintStream ps = new PrintStream(new File(""output.txt""));
+            InputStream is = new FileInputStream(""input.txt"");
+            System.setIn(is);
+
+            System.setOut(ps);
+        }
+        long t = 1;
+        s = new FastReader();
+
+        t = s.nextLong();
+
+        for (int i = 1; i <= t; i++)
+            solve();
+
+    }
+
+    public static void solve() throws IOException {
+        long n = s.nextLong();
+        ArrayList<Long> k = new ArrayList<Long>((int)n + 1);
+        k.add(0L);
+        ArrayList<Long> h = new ArrayList<Long>((int) n + 1);
+        h.add(0L);
+        ArrayList<Long> dp = new ArrayList<Long>((int) n + 1);
+        dp.add(0L);
+        for (int i = 1; i <= n; i++) {
+            long k_ = s.nextLong();
+            k.add(k_);
+        }
+        for (int i = 1; i <= n; i++) {
+            long h_ = s.nextLong();
+            h.add(h_);
+            dp.add(0L);
+        }
+        for (int i = 1; i <= n; i++) {
+            long var = k.get(i) - h.get(i) + 1;
+            for (int j = i - 1; (j > 0 && k.get(j) >= var); j--) {
+                long var2 = k.get(j) - h.get(j) + 1;
+                if (var2 <= var) {
+                    var = var2;
+                }
+            }
+            int j = i - 1;
+            for (; j > 0; j--) {
+                if (k.get(j) < var) {
+                    break;
+                }
+            }
+            long var3 = k.get(i) - var + 1;
+            if (j != 0) {
+                dp.set(i, (dp.get(j) + (var3 * (var3 + 1)) / 2));
+            } else
+            {
+                dp.set(i, ((var3 * (var3 + 1)) / 2));
+            }
+
+        }
+        System.out.println(dp.get((int) n));
+    }
+}
+","import java.util.*;
+import java.io.*;
+
+public class Test {
+    // global variables
+    static final long INF = 1000000000000000000L;
+
+    static class FastReader {
+        BufferedReader br;
+        StringTokenizer st;
+
+        public FastReader() throws FileNotFoundException {
+            br = new BufferedReader(
+                    new InputStreamReader(System.in));
+        }
+
+        String next() {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+
+        String nextLine() {
+            String str = """";
+            try {
+                str = br.readLine();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+        }
+    }
+
+    static FastReader s;
+
+    public static void main(String[] args)
+            throws IOException {
+        if (System.getProperty(""ONLINE_JUDGE"") == null) {
+
+            PrintStream ps = new PrintStream(new File(""output.txt""));
+            InputStream is = new FileInputStream(""input.txt"");
+            System.setIn(is);
+
+            System.setOut(ps);
+        }
+        long t = 1;
+        s = new FastReader();
+
+        t = s.nextLong();
+
+        for (int i = 1; i <= t; i++)
+            solve();
+
+    }
+
+    public static void solve() throws IOException {
+        long n = s.nextLong();
+        ArrayList<Long> k = new ArrayList<Long>((int)n + 1);
+        k.add(0L);
+        ArrayList<Long> h = new ArrayList<Long>((int) n + 1);
+        h.add(0L);
+        ArrayList<Long> dp = new ArrayList<Long>((int) n + 1);
+        dp.add(0L);
+        for (int i = 1; i <= n; i++) {
+            long k_ = s.nextLong();
+            k.add(k_);
+        }
+        for (int i = 1; i <= n; i++) {
+            long h_ = s.nextLong();
+            h.add(h_);
+            dp.add(0L);
+        }
+        for (int i = 1; i <= n; i++) {
+            long var = k.get(i) - h.get(i) + 1;
+            for (int j = i - 1; (j > 0 && k.get(j) >= var); j--) {
+                long var2 = k.get(j) - h.get(j) + 1;
+                if (var2 <= var) {
+                    var = var2;
+                }
+            }
+            int j = i - 1;
+            for (; j > 0; j--) {
+                if (k.get(j) < var) {
+                    break;
+                }
+            }
+            long var3 = k.get(i) - var + 1;
+            if (j != 0) {
+                dp.set(i, (dp.get(j) + (var3 * (var3 + 1)) / 2));
+            } else
+            {
+                dp.set(i, ((var3 * (var3 + 1)) / 2));
+            }
+
+        }
+        System.out.println(dp.get((int) n));
+    }
+}
+",1
+2db37cb1,875ed4c8,"/*
+        ""Everything in the universe is balanced. Every disappointment
+                you face in life will be balanced by something good for you!
+                        Keep going, never give up.""
+
+                        Just have Patience + 1...
+
+*/
+
+
+
+import java.util.*;
+import java.lang.*;
+import java.io.*;
+
+public class Solution {
+
+    static int MAX = 100005;
+    static Map<Integer, List<int[]>> graph = new HashMap<>();
+    static int[] value = new int[MAX];
+
+    public static void main(String[] args) throws java.lang.Exception {
+        out = new PrintWriter(new BufferedOutputStream(System.out));
+        sc = new FastReader();
+
+        int test = sc.nextInt();
+        for (int t = 0; t < test; t++) {
+            solve();
+        }
+        out.close();
+    }
+
+    private static void solve() {
+        int n = sc.nextInt();
+        graph.clear();
+        for (int i = 1; i <= n; i++) {
+            graph.put(i, new ArrayList<>());
+        }
+        for (int i = 0; i < n - 1; i++) {
+            int u = sc.nextInt();
+            int v = sc.nextInt();
+            graph.get(u).add(new int[]{v, i});
+            graph.get(v).add(new int[]{u, i});
+        }
+
+        int node = 0;
+        for (int i = 1; i <= n; i++) {
+            int childrens = graph.get(i).size();
+            if (childrens > 2) {
+                out.println(-1);
+                return;
+            }
+            
+            if (childrens == 1) {
+                node = i;
+            }
+        }
+
+        dfs(node, 0, 2);
+
+        for (int i = 0; i < n - 1; i++) {
+            out.print(value[i] + "" "");
+        }
+        out.println();
+    }
+
+    private static void dfs(int currNode, int parent, int prime) {
+        int addPrime = prime == 2 ? 3 : 2;
+        for (int[] adjacentNode : graph.get(currNode)) {
+            if (adjacentNode[0] == parent) {
+                continue;
+            }
+            value[adjacentNode[1]] = prime;
+            dfs(adjacentNode[0], currNode, addPrime);
+        }
+    }
+
+
+    public static FastReader sc;
+    public static PrintWriter out;
+    static class FastReader
+    {
+        BufferedReader br;
+        StringTokenizer str;
+
+        public FastReader()
+        {
+            br = new BufferedReader(new
+                    InputStreamReader(System.in));
+        }
+
+        String next()
+        {
+            while (str == null || !str.hasMoreElements())
+            {
+                try
+                {
+                    str = new StringTokenizer(br.readLine());
+                }
+                catch (IOException  end)
+                {
+                    end.printStackTrace();
+                }
+            }
+            return str.nextToken();
+        }
+
+        int nextInt()
+        {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong()
+        {
+            return Long.parseLong(next());
+        }
+
+        double nextDouble()
+        {
+            return Double.parseDouble(next());
+        }
+
+        String nextLine()
+        {
+            String str = """";
+            try
+            {
+                str = br.readLine();
+            }
+            catch (IOException end)
+            {
+                end.printStackTrace();
+            }
+            return str;
+        }
+    }
+}
+","import java.util.*;
+import java.lang.*;
+import java.io.*;
+
+
+public class Main
+{
+    static PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
+	public static void main (String[] args) throws java.lang.Exception
+	{
+		FastReader sc = new FastReader();
+		
+		int t = sc.nextInt();
+		while(t-->0){
+		    
+		    solve(sc);
+
+		    
+		}
+		
+	}
+	
+	
+	public static void solve(FastReader sc){
+
+	    int n = sc.nextInt();
+	    
+	    ArrayList<ArrayList<Edge>> graph = new ArrayList<ArrayList<Edge>>();
+	    for(int i = 0;i<n;++i){
+	        graph.add(new ArrayList<>());
+	    }
+	    for(int i = 0;i<n-1;++i){
+	        int u = sc.nextInt();
+	        int v = sc.nextInt();
+	        
+	        u--;
+	        v--;
+	        
+	        graph.get(u).add(new Edge(v, i));
+	        graph.get(v).add(new Edge(u, i));
+	        
+	        
+	    }
+	    
+	    int start = 0;
+	    for(int i = 0;i<n;++i){
+	        if(graph.get(i).size()>2){
+	            out.println(-1);out.flush();return;
+	        }else if(graph.get(i).size()==1){
+	            start=i;
+	        }
+	    }
+	    
+	    int val=2;
+	    int [] wgt = new int[n-1];
+
+	    int curr = graph.get(start).get(0).node;
+	    
+	    wgt[graph.get(start).get(0).idx] = val;
+	    
+	    val=5;
+	    
+	    while(true){
+	        ArrayList<Edge> list = graph.get(curr);
+	        if(list.size()==1){
+	            break;
+	        }else{
+	            for(Edge el : list){
+	                if(wgt[el.idx]==0){
+	                    wgt[el.idx] = val;
+	                    val = 7-val;
+	                    curr = el.node;
+	                }
+	            }
+	            
+	        }
+	        
+	    }
+	    
+	    
+	    for(int el : wgt){
+	        out.print(el + "" "");
+	    }
+	    out.println();
+	    out.flush();
+	    
+	}
+	
+	
+	
+	
+	
+	
+	static class Edge {
+      int node;
+      int idx;
+
+      Edge(int src, int nbr) {
+         this.node = src;
+         this.idx = nbr;
+      }
+   }
+	/*
+	int [] arr = new int[n];
+	for(int i = 0;i<n;++i){
+	    arr[i] = sc.nextInt();
+	}
+	*/
+	static void mysort(int[] arr) {
+			for(int i=0;i<arr.length;i++) {
+	            int rand = (int) (Math.random() * arr.length);
+	            int loc = arr[rand];
+	            arr[rand] = arr[i];
+	            arr[i] = loc;
+	        }
+	        Arrays.sort(arr);
+	    }
+	
+	static class FastReader {
+			 BufferedReader br;
+			 StringTokenizer st;
+		 
+			 public FastReader()
+			 {
+				 br = new BufferedReader(new InputStreamReader(System.in));
+			 }
+		        
+			 String next()
+			 {
+				 while (st == null || !st.hasMoreElements()) {
+					 try {
+						 st = new StringTokenizer(br.readLine());
+					 }
+					 catch (IOException e) {
+						 e.printStackTrace();
+					 }
+				 }
+				 return st.nextToken();
+			 }
+		 
+			 int nextInt() { return Integer.parseInt(next()); }
+			 
+			 long nextLong() { return Long.parseLong(next()); }
+			 
+			 double nextDouble()
+			 {
+				 return Double.parseDouble(next());
+			 }	
+		 
+			 String nextLine()
+			 {
+				 String str = """";
+				 try {
+					 str = br.readLine();
+				 }
+				 catch (IOException e) {
+					 e.printStackTrace();
+				 }
+				 return str;
+			 }
+		 }	
+}",0
+9e7551da,f0e13442,"import java.io.*;
+import java.util.Arrays;
+import java.util.StringTokenizer;
+// نورت الكود يا كبير اتفضل
+
+// يا رب Accepted
+public class InterestingStory {
+    private static int[] freq;
+    private static String[] strs;
+
+    private static int[] countAlpha(char alpha) {
+
+        int[] count = new int[strs.length];
+
+        for (int i = 0; i < strs.length; i++)
+            for (char c : strs[i].toCharArray())
+                count[i] += c == alpha ? -1 : 1;
+
+        return count;
+    }
+
+    private static int solve(char alpha) {
+        int[] res = countAlpha(alpha);
+
+        Arrays.sort(res);
+
+        int freqSum = 0;
+        for (int j : freq) freqSum += j;
+
+        freqSum -= freq[alpha - 'a'];
+
+
+        int k = res.length - 1;
+
+        //System.out.println(freq[alpha - 'a'] + "" "" + freqSum);
+
+        while (k >= 0 && freq[alpha - 'a'] <= freqSum) {
+            //System.out.println(freq[alpha - 'a'] + "" "" + freqSum);
+            freqSum -= res[k--];
+        }
+        return k + 1;
+    }
+
+    public static void main(String[] args) {
+        FastReader in = new FastReader();
+        PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
+
+        int t = in.nextInt();
+        while (t-- > 0) {
+
+            int n = in.nextInt();
+            freq = new int[7];
+            strs = new String[n];
+
+            for (int i = 0; i < n; i++)
+                strs[i] = in.nextLine();
+
+            for (String str : strs)
+                for (char c : str.toCharArray())
+                    freq[c - 'a']++;
+
+            int max = 0;
+
+//            int x = solve('d');
+//            out.println(x);
+
+            for (char c = 'a'; c < 'f'; c++)
+                max = Math.max(max, solve(c));
+
+//            int[] arr = countAlpha('d');
+//            Arrays.sort(arr);
+//
+//            for (int i : arr)
+//                out.println(i);
+
+
+            out.println(max);
+
+        }
+
+        out.close();
+    }
+
+    private static class FastReader {
+        BufferedReader br;
+        StringTokenizer st;
+
+        FastReader() {
+            br = new BufferedReader(new
+                    InputStreamReader(System.in));
+        }
+
+        String next() {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        String nextLine() {
+            String str = """";
+            try {
+                str = br.readLine();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+        }
+    }
+}
+","import java.io.*;
+import java.util.Arrays;
+import java.util.StringTokenizer;
+// نورت الكود يا كبير اتفضل
+
+// يا رب Accepted
+public class InterestingStory {
+    private static int[] freq;
+    private static String[] strs;
+
+    private static int[] countAlpha(char alpha) {
+
+        int[] count = new int[strs.length];
+
+        for (int i = 0; i < strs.length; i++)
+            for (char c : strs[i].toCharArray())
+                count[i] += c == alpha ? -1 : 1;
+
+        return count;
+    }
+
+    private static int solve(char alpha) {
+        int[] res = countAlpha(alpha);
+
+        Arrays.sort(res);
+
+        int freqSum = 0;
+        for (int j : freq) freqSum += j;
+
+        freqSum -= freq[alpha - 'a'];
+
+
+        int k = res.length - 1;
+        
+
+        while (k >= 0 && freq[alpha - 'a'] <= freqSum)
+            freqSum -= res[k--];
+        
+        return k + 1;
+    }
+
+    public static void main(String[] args) {
+        FastReader in = new FastReader();
+        PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
+
+        int t = in.nextInt();
+        while (t-- > 0) {
+
+            int n = in.nextInt();
+            freq = new int[5];
+            strs = new String[n];
+
+            for (int i = 0; i < n; i++)
+                strs[i] = in.nextLine();
+
+            for (String str : strs)
+                for (char c : str.toCharArray())
+                    freq[c - 'a']++;
+
+            int max = 0;
+
+            for (char c = 'a'; c < 'f'; c++)
+                max = Math.max(max, solve(c));
+
+
+            out.println(max);
+
+        }
+
+        out.close();
+    }
+
+    private static class FastReader {
+        BufferedReader br;
+        StringTokenizer st;
+
+        FastReader() {
+            br = new BufferedReader(new
+                    InputStreamReader(System.in));
+        }
+
+        String next() {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        String nextLine() {
+            String str = """";
+            try {
+                str = br.readLine();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+        }
+    }
+}",1
+44428e63,c850e422,"import java.util.*;
+import java.io.*;
+
+public class C_Minimum_Grid_Path{
+    public static void main(String[] args) {
+        FastScanner s= new FastScanner();
+        StringBuilder res = new StringBuilder();
+        int t=s.nextInt();
+        int p=0;
+        while(p<t){
+       int n=s.nextInt();
+       int array[]= new int[n];
+       long sumodd[]= new long[n];
+       long sumeven []= new long[n];
+       long minodd[]= new long[n];
+       long mineven[]= new long[n];
+       long sume=0;
+       long sumo=0;
+       for(int i=0;i<n;i++){
+           array[i]=s.nextInt();
+           if(i%2==0){
+               sume+=array[i];
+               sumeven[i]=sume;
+               if(i==0){
+                   mineven[i]=array[i];
+               }
+               else{
+                   mineven[i]=Math.min(array[i],mineven[i-2]);
+               }
+           }
+           else{
+               sumo+=array[i];
+               sumodd[i]=sumo;
+               if(i==1){
+                minodd[i]=array[i];
+            }
+            else{
+                minodd[i]=Math.min(array[i],minodd[i-2]);
+            }
+           }
+       }
+       long ans=Long.MAX_VALUE;
+       for(int i=1;i<n;i++){
+           long temp=0;
+           if(i%2==0){
+               int num=i/2;
+              temp=(mineven[i]*(n-num))+(sumeven[i]-mineven[i])+(minodd[i-1]*(n-(num-1)))+(sumodd[i-1]-minodd[i-1]);
+              ans=Math.min(ans,temp);
+           }
+           else{
+               int num=i/2;
+               temp=(minodd[i]*(n-num))+(sumodd[i]-minodd[i])+(mineven[i-1]*(n-num))+(sumeven[i-1]-mineven[i-1]);
+               ans=Math.min(ans,temp);
+           }
+       }
+       res.append(ans+""\n"");
+       p++;
+    }
+    System.out.println(res);
+
+
+
+    }
+    static class FastScanner {
+		BufferedReader br;
+		StringTokenizer st;
+ 
+		public FastScanner(String s) {
+			try {
+				br = new BufferedReader(new FileReader(s));
+			} catch (FileNotFoundException e) {
+				// TODO Auto-generated catch block
+				e.printStackTrace();
+			}
+		}
+ 
+		public FastScanner() {
+			br = new BufferedReader(new InputStreamReader(System.in));
+		}
+ 
+		String nextToken() {
+			while (st == null || !st.hasMoreElements()) {
+				try {
+					st = new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					// TODO Auto-generated catch block
+					e.printStackTrace();
+				}
+			}
+			return st.nextToken();
+		}
+ 
+		int nextInt() {
+			return Integer.parseInt(nextToken());
+		}
+ 
+		long nextLong() {
+			return Long.parseLong(nextToken());
+		}
+ 
+		double nextDouble() {
+			return Double.parseDouble(nextToken());
+		}
+	}
+
+
+
+
+}","import java.io.*;
+import java.util.*;
+
+public class Code {
+
+  public static void main(String[] args) {
+    FastReader in = new FastReader();
+    PrintWriter out = new PrintWriter(System.out);
+
+    int t = in.nextInt();
+    while (t-- > 0) {
+      int n = in.nextInt();
+      long a[] = new long[n];
+      for (int i = 0; i < n; i++) {
+        a[i] = in.nextLong();
+      }
+      long result = Long.MAX_VALUE;
+      for (int i = 0; i < 2; i++) {
+        long x = 0;
+        long y = 0;
+        long minX = Long.MAX_VALUE;
+        long minY = Long.MAX_VALUE;
+        long prefix = 0;
+        for (int j = 0; j < n; j++) {
+          if (j % 2 == i) {
+            if (j > 0) {
+              result = Math.min(result, (n - x) * a[j] + (n - y) * minY + prefix);
+            }
+            ++x;
+            prefix += a[j];
+            minX = Math.min(minX, a[j]);
+          } else {
+            if (j > 0) {
+              result = Math.min(result, (n - y) * a[j] + (n - x) * minX + prefix);
+            }
+            ++y;
+            prefix += a[j];
+            minY = Math.min(minY, a[j]);
+          }
+        }
+      }
+      out.println(result);
+    }
+
+    out.close();
+  }
+
+  static void shuffle(int[] a) {
+    Random get = new Random();
+    for (int i = 0; i < a.length; i++) {
+      int r = get.nextInt(a.length);
+      int temp = a[i];
+      a[i] = a[r];
+      a[r] = temp;
+    }
+  }
+
+  static void shuffle(long[] a) {
+    Random get = new Random();
+    for (int i = 0; i < a.length; i++) {
+      int r = get.nextInt(a.length);
+      long temp = a[i];
+      a[i] = a[r];
+      a[r] = temp;
+    }
+  }
+
+  static class FastReader {
+    BufferedReader br;
+    StringTokenizer st;
+
+    public FastReader() {
+      br = new BufferedReader(new InputStreamReader(System.in));
+    }
+
+    public FastReader(String s) throws FileNotFoundException {
+      br = new BufferedReader(new FileReader(new File(s)));
+    }
+
+    String next() {
+      while (st == null || !st.hasMoreElements()) {
+        try {
+          st = new StringTokenizer(br.readLine());
+        } catch (IOException e) {
+          e.printStackTrace();
+        }
+      }
+      return st.nextToken();
+    }
+
+    int nextInt() {
+      return Integer.parseInt(next());
+    }
+
+    long nextLong() {
+      return Long.parseLong(next());
+    }
+
+    double nextDouble() {
+      return Double.parseDouble(next());
+    }
+
+    String nextLine() {
+      String str = """";
+      try {
+        str = br.readLine();
+      } catch (IOException e) {
+        e.printStackTrace();
+      }
+      return str;
+    }
+  }
+
+  static class Tuple implements Comparable<Tuple> {
+    int a;
+    int b;
+    int c;
+    public Tuple(int a, int b) {
+      this.a = a;
+      this.b = b;
+      this.c = 0;
+    }
+    public Tuple(int a, int b, int c) {
+      this.a = a;
+      this.b = b;
+      this.c = c;
+    }
+    public int getA() { return a; }
+    public int getB() { return b; }
+    public int getC() { return c; }
+    public int compareTo(Tuple other) {
+      if (this.a == other.a) {
+        if (this.b == other.b) return Long.compare(this.c, other.c);
+        return Long.compare(this.b, other.b);
+      }
+      return Long.compare(this.a, other.a);
+    }
+    @Override
+    public int hashCode() { return Arrays.deepHashCode(new Integer[] {a, b, c}); }
+    @Override
+    public boolean equals(Object o) {
+      if (!(o instanceof Tuple)) return false;
+      Tuple pairo = (Tuple) o;
+      return (this.a == pairo.a && this.b == pairo.b && this.c == pairo.c);
+    }
+    @Override
+    public String toString() { return String.format(""(%d %d %d)  "", this.a, this.b, this.c); }
+  }
+}
+",0
+4dc0247e,875ed4c8,"import java.io.*;
+import java.util.*;
+
+
+public class ComdeFormces {
+	public static void main(String[] args) throws Exception{
+		// TODO Auto-generated method stub
+		FastReader sc=new FastReader();
+		BufferedWriter log = new BufferedWriter(new OutputStreamWriter(System.out));
+		int t=sc.nextInt();
+		while(t--!=0) {
+			int n=sc.nextInt();
+//			int m=sc.nextInt();
+		    ArrayList<ArrayList<pair>> ar=new ArrayList<>();
+		    ArrayList<pair> arr=new ArrayList<>();
+		    int c[]=new int[n];
+		    for(int i=0;i<=n;i++) {
+		    	ar.add(new ArrayList<>());
+		    }
+		    for(int i=0;i<n-1;i++) {
+		    	int a=sc.nextInt();
+		    	int b=sc.nextInt();
+		    	ar.get(a).add(new pair(b,i));
+		    	ar.get(b).add(new pair(a,i));
+		    	
+		    }
+		    boolean ans=true;
+		    for(int i=0;i<=n;i++) {
+		     if(ar.get(i).size()>2) {
+		    	 ans=false;
+		    	 break;
+		     }  	
+		    }
+		    if(ans) {
+		    
+		       for(int i=1;i<=n;i++) {
+		    	   if(ar.get(i).size()==1) {
+		    		   boolean vis[]=new boolean[n+1];
+		    		   dfs(ar,2,i,vis,c);
+		    		   break;
+		    	   }
+		       }
+		       for(int i=0;i<n;i++) {
+		    	   if(c[i]!=0)log.write(c[i]+"" "");
+		       }
+		    }
+		    else log.write(""-1"");
+		    
+		     log.write(""\n"");
+		     log.flush();
+			}
+		}
+	
+		
+static void dfs(ArrayList<ArrayList<pair>>ar ,int val,int src,boolean vis[],int c[]) {
+	if(vis[src])return;
+	vis[src]=true;
+	for(int i=0;i<ar.get(src).size();i++) {
+		if(!vis[ar.get(src).get(i).a]) {
+			c[ar.get(src).get(i).b]=val;
+			if(val==2) {
+				dfs(ar,3,ar.get(src).get(i).a,vis,c);
+			}
+			else {
+				dfs(ar,2,ar.get(src).get(i).a,vis,c);
+			}
+		}
+	}
+}	
+	
+	
+	
+		
+
+		
+		
+static ArrayList<Integer> divisors(int n){
+	
+	ArrayList<Integer> ar=new ArrayList<>();
+     for (int i=2; i<=Math.sqrt(n); i++){
+	        if (n%i == 0){
+	            if (n/i == i) {
+	            	ar.add(i);
+	            }
+	            else {
+	               ar.add(i);
+	               ar.add(n/i);
+	            }
+	         }
+       }
+	return ar;
+}
+static int primeDivisor(int n){
+	ArrayList<Integer> ar=new ArrayList<>();
+	int cnt=0;
+	boolean pr=false;
+	while(n%2==0) {
+		pr=true;
+		n/=2;
+		
+	}
+	if(pr)ar.add(2);
+	for(int i=3;i*i<=n;i+=2) {
+		pr=false;
+		while(n%i==0) {
+			n/=i;
+			pr=true;
+		}
+		if(pr)ar.add(i);
+	}
+	if(n>2) ar.add(n);
+	return ar.size();
+	
+}
+static int mdlg(int num, int base) {
+	
+	int val=((int)(Math.ceil(Math.log(num)/Math.log(base))));
+	int val2=(int)Math.pow(base,val);
+//	System.out.println(num+"" ""+Math.pow(base,val));
+   if(num/val2==0)return val;
+    return val+1;
+//	return val;
+}	
+static String rev(String s) {
+	char temp[]=s.toCharArray();
+	for(int i=0;i<temp.length/2;i++) {
+		char tp=temp[i];
+		temp[i]=temp[temp.length-1-i];
+		temp[temp.length-1-i]=tp;
+		
+	}
+	return String.valueOf(temp);
+}	
+static long bsv(long a[],long min,long max) {
+	long ans=-1;
+	while(min<=max) {
+		long mid=min+(max-min)/2;
+		long an=solvess(a,mid);
+//	    System.out.println(""an=""+an+""mid=""+mid);
+		if(an==mid) {
+			ans=Math.max(ans,an);
+			min=mid+1;
+		}
+		else if(an>mid)min=mid+1;
+		else if(an<mid)max=mid-1;
+		
+	}
+	return ans;
+}		
+static long solvess(long aa[],long el) {
+	long a[]=new long[aa.length];
+	long min=Long.MAX_VALUE;
+	for(int i=0;i<a.length;i++ ) {
+		a[i]=aa[i];
+		min=Math.min(min, aa[i]);
+	}
+	boolean ans=true;
+	long val[]=new long[a.length];
+	for(int i=a.length-1;i>=2;i--) {
+		if(a[i]+val[i]>el) {
+			if(val[i]>=el) {
+			long df=a[i];
+			a[i]-=df;
+			val[i-1]+=(df/3);
+			val[i-2]+=2*(df/3);
+			a[i]+=df%3;
+			}
+			else {
+			 	long df=a[i]+val[i]-el;
+			 	val[i-1]+=(df/3);
+				val[i-2]+=2*(df/3);
+				a[i]-=df;
+				a[i]+=df%3;
+			}
+		}
+		
+	}
+	for(int i=0;i<a.length;i++) {
+		a[i]+=val[i];
+	}
+	
+	long min2=Long.MAX_VALUE;
+	for(int i=0;i<a.length;i++) {
+		min2=Math.min(min2, a[i]);
+	}
+	return min2;
+	
+
+	
+}	
+static int bsd(ArrayList<LinkedList<Integer>> arr, int val,int el) {
+	
+		int s=0;
+	    int e=arr.size()-1;
+	    int ptr=0;
+	    if(val==1)ptr=1;
+	    while(s<=e) {
+	    	int m=s+(e-s)/2;
+	    	if(arr.get(m).get(ptr)==el)return m;
+	    	else if(arr.get(m).get(ptr)<el)s=m+1;
+	    	else e=m-1;
+	    }
+	    return -1;
+	
+	
+}
+static int bs(ArrayList<pair> arr,int el) {
+	int start=0;
+	int end=arr.size()-1;
+	while(start<=end) {
+		int mid=start+(end-start)/2;
+		if(arr.get(mid).a==el)return mid;
+		else if(arr.get(mid).a<el)start=mid+1;
+		else end=mid-1;
+	}
+   if(start>arr.size()-1)return -2;
+   return -1;
+}	
+static String eval(String s, long bs, long be,long k) {
+	String ans="""";
+	for(int i=s.length()-1;i>=0;i--) {
+		if(s.charAt(i)=='a') {
+			ans=""a""+ans;
+		}
+		else if(be>0){
+			
+			if(be>k) {
+				for(int j=0;j<k;j++)ans=""b""+ans;
+				be-=k;
+			}
+			else {
+				for(int j=0;j<be;j++)ans=""b""+ans;
+				be=0;
+			} 
+			
+		}
+	}
+	for(int i=0;i<bs;i++)ans=""b""+ans;
+	return ans;
+	
+}	
+static int[][] slv() {
+	int r=200001;
+	int bits=(int)(Math.log(r)/Math.log(2))+1;
+	int cnt[][]=new int[r+1][bits];
+	for(int i=1;i<=r;i++) {
+		int temp=i;
+		int j=0;
+		int min=Integer.MAX_VALUE;
+		while(j<bits) {
+			int tval=1&temp;
+			temp>>=1;
+	        if(tval==0)cnt[i][j]=cnt[i-1][j]+1;
+	        else {
+	        	 cnt[i][j]=cnt[i-1][j];
+	        }
+	        j++;
+		}
+	}
+	return cnt;
+	
+}	
+static long find(int s,long a[]) {
+	if(s>=a.length)return -1;
+	long num=a[s];
+	for(int i=s;i<a.length;i+=2) {
+		num=gcd(num,a[i]);
+		if(num==1 || num==0)return -1;
+	}
+	return  num;
+}	
+static long gcd(long a,long b) {
+	if(b==0)return a;
+	else return gcd(b,a%b);
+}	
+static long factmod(long n,long mod,long img) {
+	if(n==0)return 1;
+	long ans=1;
+	long temp=1;
+	while(n--!=0) {
+		if(temp!=img) {
+		ans=((ans%mod)*((temp)%mod))%mod;
+		}
+		temp++;
+	}
+	return ans%mod;
+}	
+static long eval(ArrayList<Integer> a, int k) {
+	if(a.size()<1 )return 0;
+	int i=a.size()-1;
+	long ans=0;
+	while(i>=0) {
+		int temp=k;
+		int prev=0;
+		while(temp--!=0 && i>=0) {
+			ans+=Math.abs(a.get(i)-prev);
+			if(temp==0 || i==0)ans+=a.get(i);
+			prev=a.get(i);
+			i--;
+		}
+	}
+	return ans;
+}	
+static int bs(long a[] ,long num) {
+	int start=0;
+	int end=a.length-1;
+    while(start<=end) {
+    	int mid=start+(end-start)/2;
+    	if(a[mid]==num) {
+    		return mid;
+    	}
+    	else if(a[mid]<num)start=mid+1;
+    	else end=mid-1;
+    
+    }
+    return start;
+}	
+	
+	
+//utils
+static int ncr(int n, int r){
+    if(r>n-r)r=n-r;
+    int ans=1;
+    for(int i=0;i<r;i++){
+          ans*=(n-i);
+          ans/=(i+1);
+    }
+    return ans;
+} 
+ 
+public static class trip{
+	int a,b,c;
+	public trip(int a,int b,int c) {
+		this.a=a;
+		this.b=b;
+		this.c=c;
+	}
+	public int compareTo(trip q) {
+		return this.c-q.c;
+	}
+}	
+	static int mergesort(int[] a,int start,int end) {
+		if(start>=end)return a[end];
+		int mid=start+(end-start)/2;
+		int min1=mergesort(a,start,mid);
+		int min2=mergesort(a,mid+1,end);
+		merge(a,start,mid,end);
+		return Math.min(min1, min2);
+	}
+	static void merge(int []a, int start,int mid,int end) {
+		int ptr1=start;
+		int ptr2=mid+1;
+		int b[]=new int[end-start+1];
+		int i=0;
+		while(ptr1<=mid && ptr2<=end) {
+			if(a[ptr1]<=a[ptr2]) {
+				b[i]=a[ptr1];
+				ptr1++;
+				i++;
+			}
+			else {
+				b[i]=a[ptr2];
+				ptr2++;
+				i++;
+			}
+		}
+		while(ptr1<=mid) {
+			b[i]=a[ptr1];
+			ptr1++;
+			i++;
+		}
+		while(ptr2<=end) {
+			b[i]=a[ptr2];
+			ptr2++;
+			i++;
+		}
+		for(int j=start;j<=end;j++) {
+			a[j]=b[j-start];
+		}
+	}
+	public static class FastReader {
+
+		BufferedReader b;
+		StringTokenizer s;
+		public FastReader() {
+			b=new BufferedReader(new InputStreamReader(System.in));
+		}
+		String next() {
+			while(s==null ||!s.hasMoreElements()) {
+				try {
+					s=new StringTokenizer(b.readLine());
+				}
+				catch(IOException e) {
+					e.printStackTrace();
+				}
+			}
+			return s.nextToken();
+		}
+		public int nextInt() {
+			return Integer.parseInt(next());
+		}
+		public long nextLong() {
+			return Long.parseLong(next());
+		}
+		public double nextDouble() {
+			return Double.parseDouble(next());
+		}
+		String nextLine() {
+			String str="""";
+			try {
+				str=b.readLine();
+			}
+			catch(IOException e) {
+				e.printStackTrace();
+			}
+			return str;
+		}
+		boolean hasNext() {
+		    if (s != null && s.hasMoreTokens()) {
+		        return true;
+		    }
+		    String tmp;
+		    try {
+		        b.mark(1000);
+		        tmp = b.readLine();
+		        if (tmp == null) {
+		            return false;
+		        }
+		        b.reset();
+		    } catch (IOException e) {
+		        return false;
+		    }
+		    return true;
+		}
+}
+public static class pair{
+	int a;
+	int b;
+	public pair(int a,int b) {
+		this.a=a;
+		this.b=b;
+	}
+	public int compareTo(pair b) {
+		return b.b-this.b;
+	}
+	public int compareToo(pair b) {
+		if(this.a!=b.a)return this.a-b.a;
+		else {
+			return b.b-this.b;
+		}
+	}
+}	
+static long pow(long a, long pw) {
+	long temp;
+	if(pw==0)return 1;
+	temp=pow(a,pw/2);
+	if(pw%2==0)return temp*temp;
+	return a*temp*temp;
+	
+}
+static int pow(int a, int pw) {
+	int temp;
+	if(pw==0)return 1;
+	temp=pow(a,pw/2);
+	if(pw%2==0)return temp*temp;
+	return a*temp*temp;
+	
+}
+}
+","import java.util.*;
+import java.lang.*;
+import java.io.*;
+
+
+public class Main
+{
+    static PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
+	public static void main (String[] args) throws java.lang.Exception
+	{
+		FastReader sc = new FastReader();
+		
+		int t = sc.nextInt();
+		while(t-->0){
+		    
+		    solve(sc);
+
+		    
+		}
+		
+	}
+	
+	
+	public static void solve(FastReader sc){
+
+	    int n = sc.nextInt();
+	    
+	    ArrayList<ArrayList<Edge>> graph = new ArrayList<ArrayList<Edge>>();
+	    for(int i = 0;i<n;++i){
+	        graph.add(new ArrayList<>());
+	    }
+	    for(int i = 0;i<n-1;++i){
+	        int u = sc.nextInt();
+	        int v = sc.nextInt();
+	        
+	        u--;
+	        v--;
+	        
+	        graph.get(u).add(new Edge(v, i));
+	        graph.get(v).add(new Edge(u, i));
+	        
+	        
+	    }
+	    
+	    int start = 0;
+	    for(int i = 0;i<n;++i){
+	        if(graph.get(i).size()>2){
+	            out.println(-1);out.flush();return;
+	        }else if(graph.get(i).size()==1){
+	            start=i;
+	        }
+	    }
+	    
+	    int val=2;
+	    int [] wgt = new int[n-1];
+
+	    int curr = graph.get(start).get(0).node;
+	    
+	    wgt[graph.get(start).get(0).idx] = val;
+	    
+	    val=5;
+	    
+	    while(true){
+	        ArrayList<Edge> list = graph.get(curr);
+	        if(list.size()==1){
+	            break;
+	        }else{
+	            for(Edge el : list){
+	                if(wgt[el.idx]==0){
+	                    wgt[el.idx] = val;
+	                    val = 7-val;
+	                    curr = el.node;
+	                }
+	            }
+	            
+	        }
+	        
+	    }
+	    
+	    
+	    for(int el : wgt){
+	        out.print(el + "" "");
+	    }
+	    out.println();
+	    out.flush();
+	    
+	}
+	
+	
+	
+	
+	
+	
+	static class Edge {
+      int node;
+      int idx;
+
+      Edge(int src, int nbr) {
+         this.node = src;
+         this.idx = nbr;
+      }
+   }
+	/*
+	int [] arr = new int[n];
+	for(int i = 0;i<n;++i){
+	    arr[i] = sc.nextInt();
+	}
+	*/
+	static void mysort(int[] arr) {
+			for(int i=0;i<arr.length;i++) {
+	            int rand = (int) (Math.random() * arr.length);
+	            int loc = arr[rand];
+	            arr[rand] = arr[i];
+	            arr[i] = loc;
+	        }
+	        Arrays.sort(arr);
+	    }
+	
+	static class FastReader {
+			 BufferedReader br;
+			 StringTokenizer st;
+		 
+			 public FastReader()
+			 {
+				 br = new BufferedReader(new InputStreamReader(System.in));
+			 }
+		        
+			 String next()
+			 {
+				 while (st == null || !st.hasMoreElements()) {
+					 try {
+						 st = new StringTokenizer(br.readLine());
+					 }
+					 catch (IOException e) {
+						 e.printStackTrace();
+					 }
+				 }
+				 return st.nextToken();
+			 }
+		 
+			 int nextInt() { return Integer.parseInt(next()); }
+			 
+			 long nextLong() { return Long.parseLong(next()); }
+			 
+			 double nextDouble()
+			 {
+				 return Double.parseDouble(next());
+			 }	
+		 
+			 String nextLine()
+			 {
+				 String str = """";
+				 try {
+					 str = br.readLine();
+				 }
+				 catch (IOException e) {
+					 e.printStackTrace();
+				 }
+				 return str;
+			 }
+		 }	
+}",0
+bd65846f,d018b49f,"import java.lang.*;
+import java.util.*;
+import java.io.*;
+
+public class Main {    
+    static void deal(int[] arr,int n) {
+        int m1 = 0;
+        int m2 = 0;
+        for(int i=0;i<n;i++) {
+            if(arr[i]==1) {
+                m1 ++;
+            } else {
+                m2 ++;
+            }
+        }
+        if(m1 ==0) {
+            System.out.println(0);
+            return;
+        }
+        int[] arr1 = new int[m1];
+        int[] arr2 = new int[m2];
+        int index1 = 0;
+        int index2 = 0;
+        for(int i=0;i<n;i++) {
+            if(arr[i] == 1) {
+                arr1[index1] = i;
+                index1++;
+            } else {
+                arr2[index2] = i;
+                index2++;
+            }
+        }
+        int[][] dp = new int[m2][m1];
+        dp[0][0] = Math.abs(arr1[0]-arr2[0]);
+        for(int i=0;i<m1;i++) {
+            if(i>0) dp[i][i] = dp[i-1][i-1] + Math.abs(arr1[i]-arr2[i]);
+            for(int j=i+1;j<m2;j++) {
+                if(i>0) {
+                    dp[j][i] = Math.min(dp[j-1][i],dp[j-1][i-1]+Math.abs(arr2[j]-arr1[i]));
+                } else {
+                    dp[j][i] = Math.min(dp[j-1][i],Math.abs(arr2[j]-arr1[i]));
+                }
+            }
+        }
+        System.out.println(dp[m2-1][m1-1]);
+    }
+    
+	public static void main(String[] args) {
+      	MyScanner scanner = new MyScanner();
+        int n = scanner.nextInt();
+        int[] arr = new int[n];
+        for(int i=0;i<n;i++) {
+            arr[i] = scanner.nextInt();    
+        }
+        deal(arr,n);
+    }
+    public static class MyScanner {
+        BufferedReader br;
+        StringTokenizer st;
+        
+        public MyScanner() {
+                br = new BufferedReader(new InputStreamReader(System.in));
+        }
+        
+        String next() {
+                while (st == null || !st.hasMoreElements()) {
+                        try {
+                                st = new StringTokenizer(br.readLine());
+                        } catch (IOException e) {
+                                e.printStackTrace();
+                        }
+                }
+                return st.nextToken();
+        }
+        
+        int nextInt() {
+                return Integer.parseInt(next());
+        }
+        
+        long nextLong() {
+                return Long.parseLong(next());
+        }
+        
+        double nextDouble() {
+                return Double.parseDouble(next());
+        }
+        
+        String nextLine(){
+                String str = """";
+    try {
+            str = br.readLine();
+    } catch (IOException e) {
+            e.printStackTrace();
+    }
+    return str;
+        }
+        
+    }
+}","/* package codechef; // don't place package name! */
+
+import java.util.*;
+import java.lang.*;
+import java.io.*;
+
+/* Name of the class has to be ""Main"" only if the class is public. */
+public class Codechef {
+	static long dp[][];
+	public static void main(String[] args) throws java.lang.Exception {
+		FastReader in = new FastReader(System.in);
+		StringBuilder sb = new StringBuilder();
+		int t = 1;
+		//t = in.nextInt();
+		while (t > 0) {
+			--t;
+			int n = in.nextInt();
+			int arr[] = new int[n];
+			List<Integer> ones = new ArrayList<Integer>();
+			List<Integer> zero = new ArrayList<>();
+			for(int i = 0;i<n;i++)
+			{
+				int a = in.nextInt();
+				if(a == 1)
+					ones.add(i);
+				else 
+					zero.add(i);
+			}
+			if(ones.size() == 0) {
+				sb.append(0+""\n"");
+				continue;
+			}
+			dp = new long[ones.size()][zero.size()];
+			for(int i = 0;i<ones.size();i++)
+			    Arrays.fill(dp[i], -1);
+			sb.append(findans(ones, zero, ones.size()-1, zero.size()-1));
+           
+		}
+		System.out.print(sb);
+	}
+	
+	static long findans(List<Integer> ones,List<Integer> zero,int x,int y)
+	{
+		if(x < 0)
+			return 0;
+		if(y<0)
+			return Integer.MAX_VALUE;
+        if(dp[x][y]!=-1)
+        	return dp[x][y];
+		return  dp[x][y] = Math.min(findans(ones, zero, x, y-1),findans(ones, zero, x-1, y-1) + (long)Math.abs(ones.get(x)-zero.get(y)));
+	}
+
+	static long gcd(long a, long b) {
+		if (a == 0)
+			return b;
+		else
+			return gcd(b % a, a);
+	}
+
+	static long lcm(long a, long b) {
+		return (a / gcd(a, b)) * b;
+	}
+
+	static void sort(long[] a) {
+		ArrayList<Long> l = new ArrayList<>();
+		for (long i : a)
+			l.add(i);
+		Collections.sort(l);
+		for (int i = 0; i < a.length; i++)
+			a[i] = l.get(i);
+	}
+}
+
+class FastReader {
+
+	byte[] buf = new byte[2048];
+	int index, total;
+	InputStream in;
+
+	FastReader(InputStream is) {
+		in = is;
+	}
+
+	int scan() throws IOException {
+		if (index >= total) {
+			index = 0;
+			total = in.read(buf);
+			if (total <= 0) {
+				return -1;
+			}
+		}
+		return buf[index++];
+	}
+
+	String next() throws IOException {
+		int c;
+		for (c = scan(); c <= 32; c = scan())
+			;
+		StringBuilder sb = new StringBuilder();
+		for (; c > 32; c = scan()) {
+			sb.append((char) c);
+		}
+		return sb.toString();
+	}
+
+	String nextLine() throws IOException {
+		int c;
+		for (c = scan(); c <= 32; c = scan())
+			;
+		StringBuilder sb = new StringBuilder();
+		for (; c != 10 && c != 13; c = scan()) {
+			sb.append((char) c);
+		}
+		return sb.toString();
+	}
+
+	char nextChar() throws IOException {
+		int c;
+		for (c = scan(); c <= 32; c = scan())
+			;
+		return (char) c;
+	}
+
+	int nextInt() throws IOException {
+		int c, val = 0;
+		for (c = scan(); c <= 32; c = scan())
+			;
+		boolean neg = c == '-';
+		if (c == '-' || c == '+') {
+			c = scan();
+		}
+		for (; c >= '0' && c <= '9'; c = scan()) {
+			val = (val << 3) + (val << 1) + (c & 15);
+		}
+		return neg ? -val : val;
+	}
+
+	long nextLong() throws IOException {
+		int c;
+		long val = 0;
+		for (c = scan(); c <= 32; c = scan())
+			;
+		boolean neg = c == '-';
+		if (c == '-' || c == '+') {
+			c = scan();
+		}
+		for (; c >= '0' && c <= '9'; c = scan()) {
+			val = (val << 3) + (val << 1) + (c & 15);
+		}
+		return neg ? -val : val;
+	}
+}",0
+71e0f2e5,b226c49a,"import java.util.*;
+import java.lang.*;
+import java.io.*;
+
+
+
+public class Main {
+    
+   
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        int T = sc.nextInt();
+        for(int t=0;t<T;t++){
+            solve(sc);       
+        }      
+    }
+    
+    static class Edge{
+        public int node;
+        public int index;
+        Edge(int node, int index){
+            this.node = node;
+            this.index = index;
+        }
+    }
+    public static void solve(Scanner sc){
+        int V = sc.nextInt();
+        Boolean[] visited = new Boolean[V];
+        LinkedList<Edge>[] adj = new LinkedList[V];
+       
+        for(int v=0;v<V;v++){
+            visited[v] = false;
+        }
+        
+        
+        for(int v=0;v<V;v++){
+            adj[v] = new LinkedList();
+        }
+        
+        for(int i=0;i<V-1;i++){
+            int u = sc.nextInt()-1;
+            int v = sc.nextInt()-1;
+            adj[u].add(new Edge(v,i));
+             adj[v].add(new Edge(u,i));
+        }
+        
+       
+        //gotta go find the end or start
+        int start = -1;
+        for(int v=0;v<V;v++){
+            if(adj[v].size() == 1){
+                start = v;
+            }else if(adj[v].size() > 2){
+                System.out.println(""-1"");
+                return;
+            }
+        }
+        
+        int[] weight = new int[V-1];
+       
+        //
+        int curNode = start;
+        int prevNode = -1;
+        
+        
+        visited[start] = true; 
+        
+        for(int v=0;v<V;v++){
+            for(Edge e : adj[start]){
+                if(!visited[e.node]){
+                    if(v % 2 == 0){
+                       weight[e.index] = 2;
+                    }else{
+                       
+                        weight[e.index] = 5;
+                    }
+                    visited[e.node] = true;
+                    start = e.node;
+                }  
+            }
+            
+            
+        }
+        
+        for(int w : weight){
+            System.out.print(w + "" "");
+        }
+        System.out.println("""");
+        
+        
+        
+        
+    }
+}    
+","import java.util.*;
+import java.io.*;
+import java.math.*;
+
+public class A {
+
+	// -- static variables --- //
+	static FastReader		sc	= new FastReader();
+	static PrintWriter	out	= new PrintWriter(System.out);
+	static int					mod	= (int) 1000000007;
+
+	public static void main(String[] args) throws Exception {
+
+		int t = sc.nextInt();
+		while (t-- > 0)
+			A.go();
+		// out.println();
+		out.flush();
+	}
+
+	// >>>>>>>>>>>>>>>>>>> Code Starts <<<<<<<<<<<<<<<<<<<< //
+	static class pair {
+		int x, y;
+
+		pair(int x, int y) {
+			this.x = x;
+			this.y = y;
+		}
+
+		@Override
+		public int hashCode() {
+			final int prime = 31;
+			int result = 1;
+			result = prime * result + x;
+			result = prime * result + y;
+			return result;
+		}
+
+		@Override
+		public boolean equals(Object obj) {
+			if (this == obj)
+				return true;
+			if (obj == null)
+				return false;
+			if (getClass() != obj.getClass())
+				return false;
+			pair other = (pair) obj;
+			if (x != other.x)
+				return false;
+			if (y != other.y)
+				return false;
+			return true;
+		}
+	}
+	static void go() throws Exception {
+		int n=sc.nextInt();
+		ArrayList<ArrayList<Integer>> aa=new ArrayList<>();
+		for(int i=0;i<n;i++) {
+			aa.add(new ArrayList<>());
+		}
+		LinkedHashMap<pair,Integer> map=new LinkedHashMap<>();
+		for(int i=0;i<n-1;i++) {
+			int u=sc.nextInt()-1,v=sc.nextInt()-1;
+			aa.get(u).add(v);
+			aa.get(v).add(u);
+			if(u>v) {
+				int temp=v;
+				v=u;u=temp;
+			}
+			map.put(new pair(u,v),0);
+		}
+		
+		for(ArrayList<Integer> i : aa) {
+			if(i.size()>2) {
+				out.println(-1);
+				return;
+			}
+		}
+	
+
+		boolean vis[]=new boolean[n];
+		dfs(aa,0,vis,2,map);
+		for(pair i : map.keySet()) {
+			out.print(map.get(i)+"" "");
+		}
+		out.println();
+	}
+	static void dfs(ArrayList<ArrayList<Integer>> aa,int src,boolean vis[],int see,LinkedHashMap<pair,Integer> map) {
+		vis[src]=true;
+		for(int i: aa.get(src)) {
+			if(vis[i]==false) {
+					int x=src,y=i;
+					if(x>y) {
+						int temp=x;
+						x=y;
+						y=temp;
+					}
+					pair temp=new pair(x,y);
+					if(see==2) {
+							map.put(temp,5);
+							see=5;
+					}else {
+						map.put(temp,2);
+						see=2;
+					}
+					dfs(aa,i,vis,see,map);
+			}
+		}
+	}
+	static long lcm(long a, long b) {
+		return a * b / gcd(a, b);
+	}
+
+	// >>>>>>>>>>> Code Ends <<<<<<<<< //
+
+	// --For Rounding--//
+	static double round(double value, int places) {
+
+		if (places < 0)
+			throw new IllegalArgumentException();
+		BigDecimal bd = new BigDecimal(Double.toString(value));
+		bd = bd.setScale(places, RoundingMode.HALF_UP);
+		return bd.doubleValue();
+	}
+
+	// ----Greatest Common Divisor-----//
+	static long gcd(long a, long b) {
+		if (b == 0) {
+			return a;
+		}
+		return gcd(b, a % b);
+	}
+
+	// --- permutations and Combinations ---//
+	static long	fact[];
+	static long	invfact[];
+
+	static long ncr(int n, int k) {
+		if (k < 0 || k > n) {
+			return 0;
+		}
+		long x = fact[n];
+		long y = fact[k];
+		long yy = fact[n - k];
+		long ans = (x / y);
+		ans = (ans / yy);
+		return ans;
+	}
+
+	// ---sieve---//
+	static int prime[] = new int[1000006];
+
+	// static void sieve() {
+	//     Arrays.fill(prime, 1);
+	//     prime[0] = 0;
+	//     prime[1] = 0;
+	//     for (int i = 2; i * i <= 1000005; i++) {
+	//         if (prime[i] == 1)
+	//             for (int j = i * i; j <= 1000005; j +)= i) {
+	//                 prime[j] = 0;
+	//             }
+	//     }
+	// }
+
+	// ---- Manual sort ------//
+	static void sort(long[] a) {
+		ArrayList<Long> aa = new ArrayList<>();
+		for (long i : a) {
+			aa.add(i);
+		}
+		Collections.sort(aa);
+		for (int i = 0; i < a.length; i++)
+			a[i] = aa.get(i);
+	}
+
+	static void sort(int[] a) {
+		ArrayList<Integer> aa = new ArrayList<>();
+		for (int i : a) {
+			aa.add(i);
+		}
+		Collections.sort(aa);
+		for (int i = 0; i < a.length; i++)
+			a[i] = aa.get(i);
+	}
+
+	// --- Fast exponentiation ---//
+	static long pow(long x, long y) {
+		long res = 1l;
+		while (y != 0) {
+			if (y % 2 == 1) {
+				res = (x * res);
+			}
+			y /= 2;
+			x = (x * x);
+		}
+		return res;
+	}
+
+	// >>>>>>>>>>>>>>> Fast IO <<<<<<<<<<<<<< //
+	static class FastReader {
+		BufferedReader	br;
+		StringTokenizer	st;
+
+		public FastReader() {
+			br = new BufferedReader(new InputStreamReader(System.in));
+		}
+
+		String next() {
+			while (st == null || !st.hasMoreElements()) {
+				try {
+					st = new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			}
+			return st.nextToken();
+		}
+
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+
+		double nextDouble() {
+			return Double.parseDouble(next());
+		}
+
+		int[] intArray(int n) {
+			int a[] = new int[n];
+			for (int i = 0; i < n; i++)
+				a[i] = sc.nextInt();
+			return a;
+		}
+
+		long[] longArray(int n) {
+			long a[] = new long[n];
+			for (int i = 0; i < n; i++)
+				a[i] = sc.nextLong();
+			return a;
+		}
+
+		String nextLine() {
+			String str = """";
+			try {
+				str = br.readLine();
+			} catch (IOException e) {
+				e.printStackTrace();
+			}
+			return str;
+		}
+	}
+}",0
+7d7cf9a7,e45446bc,"import java.util.*;
+import java.io.*;
+import java.math.*;
+
+public class Coder {
+  static int n;
+  static long c[];
+  static StringBuilder str = new StringBuilder("""");
+  static void solve() {
+      long mne=c[0];
+      long mno=c[1];
+      long ans=(c[0]+c[1])*n;
+      long se=c[0];
+      long so=c[1];
+      long ecnt=1,ocnt=1;
+      for(int i=2;i<n;i++){
+          if(i%2==0){mne=Math.min(mne, c[i]);se+=c[i];ecnt++;}
+          else{mno=Math.min(mno, c[i]);so+=c[i];ocnt++;}
+          
+          ans=Math.min(ans, se+mne*(n-ecnt)+so+mno*(n-ocnt));
+      }
+      str.append(ans).append(""\n"");
+  }
+
+  public static void main(String[] args) throws java.lang.Exception {
+    BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
+    int q = Integer.parseInt(bf.readLine().trim());
+    while(q-->0) {
+        n=Integer.parseInt(bf.readLine().trim());
+        c=new long[n];
+        String s[]=bf.readLine().trim().split(""\\s+"");
+        for(int i=0;i<n;i++) c[i]=Long.parseLong(s[i]);
+      solve();
+    }
+    System.out.print(str);
+  }
+}","
+import java.util.*;
+import java.lang.*;
+import java.io.*;
+
+public class C {
+
+//	            ***                          ++                      
+//             +=-==+                      +++=-                     
+//            +-:---==+                   *+=----=                   
+//           +-:------==+               ++=------==                  
+//           =-----------=++=========================                
+//          +--:::::---:-----============-=======+++====             
+//          +---:..:----::-===============-======+++++++++           
+//          =---:...---:-===================---===++++++++++         
+//          +----:...:-=======================--==+++++++++++        
+//          +-:------====================++===---==++++===+++++      
+//         +=-----======================+++++==---==+==-::=++**+     
+//        +=-----================---=======++=========::.:-+*****    
+//       +==::-====================--:  --:-====++=+===:..-=+*****   
+//       +=---=====================-...  :=..:-=+++++++++===++*****  
+//       +=---=====+=++++++++++++++++=-:::::-====+++++++++++++*****+ 
+//      +=======++++++++++++=+++++++============++++++=======+****** 
+//      +=====+++++++++++++++++++++++++==++++==++++++=:...  . .+**** 
+//     ++====++++++++++++++++++++++++++++++++++++++++-.     ..-+**** 
+//     +======++++++++++++++++++++++++++++++++===+====:.    ..:=++++ 
+//     +===--=====+++++++++++++++++++++++++++=========-::....::-=++* 
+//     ====--==========+++++++==+++===++++===========--:::....:=++*  
+//     ====---===++++=====++++++==+++=======-::--===-:.  ....:-+++   
+//     ==--=--====++++++++==+++++++++++======--::::...::::::-=+++    
+//     ===----===++++++++++++++++++++============--=-==----==+++     
+//     =--------====++++++++++++++++=====================+++++++     
+//     =---------=======++++++++====+++=================++++++++     
+//     -----------========+++++++++++++++=================+++++++    
+//     =----------==========++++++++++=====================++++++++  
+//     =====------==============+++++++===================+++==+++++ 
+//     =======------==========================================++++++
+
+//	 created by : Nitesh Gupta
+
+	public static void main(String[] args) throws Exception {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		int t = Integer.parseInt(br.readLine());
+		StringBuilder sb = new StringBuilder();
+		while (t-- > 0) {
+			String[] scn = (br.readLine()).trim().split("" "");
+			int n = Integer.parseInt(scn[0]);
+			long[] arr = new long[n];
+			scn = (br.readLine()).trim().split("" "");
+			for (int i = 0; i < n; i++) {
+				arr[i] = Long.parseLong(scn[i]);
+			}
+			long min;
+			long hor = arr[0], ver = arr[1];
+			long min1 = 0, min2 = 0;
+			min = (hor + ver) * n;
+			long x = 0, y = 0;
+			for (int i = 2; i < n; i++) {
+				if (i % 2 == 0) {
+					x += 1;
+					if (arr[i] >= hor) {
+						min1 += arr[i];
+					} else {
+						min1 += hor;
+						hor = arr[i];
+					}
+					
+					
+				} else {
+					y += 1;
+					if (arr[i] >= ver) {
+						min2 += arr[i];
+					} else {
+						min2 += ver;
+						ver = arr[i];
+					}
+				}
+				long pro =  (n - x) * hor + (n - y) * ver;
+				min = Math.min(min, min1 + min2 +pro);
+			}
+			sb.append(min);
+			sb.append(""\n"");
+		}
+		System.out.println(sb);
+		return;
+
+	}
+
+	public static void sort(long[] arr) {
+		int n = arr.length;
+		for (int i = 0; i < n; i++) {
+			int idx = (int) Math.random() * n;
+			long temp = arr[i];
+			arr[i] = arr[idx];
+			arr[idx] = temp;
+		}
+		Arrays.sort(arr);
+	}
+
+	public static void print(long[] dp) {
+		for (long ele : dp) {
+			System.out.print(ele + "" "");
+		}
+		System.out.println();
+	}
+
+	public static void print(long[][] dp) {
+		for (long[] a : dp) {
+			for (long ele : a) {
+				System.out.print(ele + "" "");
+			}
+			System.out.println();
+		}
+	}
+
+}
+",0
+8d6f1bf5,dc281165,"//package Div2.C;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+
+public class Menorah {
+    public static void main(String[] args) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        int t = Integer.parseInt(br.readLine());
+        while (t > 0) {
+            int n = Integer.parseInt(br.readLine());
+            String source = br.readLine();
+            String destination = br.readLine();
+            int sameStatusOnes = 0;
+            int sameStatusZeros = 0;
+            int diffStatusOnes = 0;
+            int diffStatusZeros = 0;
+            for (int i = 0; i < n; i++) {
+                char c1 = source.charAt(i);
+                char c2 = destination.charAt(i);
+                if (c1 == c2) {
+                    if (c1 == '0') {
+                        sameStatusZeros += 1;
+                    } else {
+                        sameStatusOnes += 1;
+                    }
+                } else {
+                    if (c1 == '0') {
+                        diffStatusZeros += 1;
+                    } else {
+                        diffStatusOnes += 1;
+                    }
+                }
+            }
+            int sameStatus = sameStatusOnes + sameStatusZeros;
+            int diffStatus = diffStatusOnes + diffStatusZeros;
+            //first case
+            if (sameStatus == n) {
+                System.out.println(0);
+            } else if (diffStatus == n) {
+                //second case
+                if (diffStatus % 2 == 0 && diffStatusOnes == (n + 1) / 2)
+                    System.out.println(n);
+                else
+                    System.out.println(-1);
+            } else {
+                int op1 = -1;
+                int op2 = -1;
+                if (sameStatus % 2 != 0 && sameStatusOnes == (sameStatus + 1) / 2)
+                    op1 = sameStatus;
+                if (diffStatus % 2 == 0 && diffStatusOnes == (diffStatus + 1) / 2)
+                    op2 = diffStatus;
+
+                if (op1 != -1 && op2 != -1)
+                    System.out.println(Integer.min(op1, op2));
+                else if (op1 != -1)
+                    System.out.println(op1);
+                else if (op2 != -1)
+                    System.out.println(op2);
+                else
+                    System.out.println(-1);
+            }
+            t--;
+        }
+    }
+}
+","/**
+ * 12/24/21 morning
+ * https://codeforces.com/contest/1615/problem/C
+ */
+// package codeforce.global.r18;
+
+import java.util.*;
+import java.io.*;
+
+public class C {
+    static PrintWriter pw;
+
+    void solve(int n, char[] a, char[] b) {
+        int same = 0, diff = 0;
+        int[] sameCnt = {0, 0}, diffCnt = {0, 0};
+        for (int i = 0; i < n; i++) {
+            if (a[i] == b[i]) {
+                same++;
+                sameCnt[a[i] - '0']++;
+            } else {
+                diff++;
+                diffCnt[a[i] - '0']++;
+            }
+        }
+        // tr(same, sameCnt, diff, diffCnt);
+        int res = Integer.MAX_VALUE;
+        if (same % 2 != 0 && sameCnt[1] - sameCnt[0] == 1) res = Math.min(res, same);
+        if (diff % 2 == 0 && diffCnt[1] == diffCnt[0]) res = Math.min(res, diff);
+        pr(res == Integer.MAX_VALUE ? -1 : res);
+    }
+
+    private void run() {
+        // read_write_file(); // comment this before submission
+        FastScanner fs = new FastScanner();
+        int t = fs.nextInt();
+        while (t-- > 0) {
+            int n = fs.nextInt();
+            char[] a = fs.next().toCharArray(), b = fs.next().toCharArray();
+            solve(n, a, b);
+        }
+    }
+
+    private final String INPUT = ""input.txt"";
+    private final String OUTPUT = ""output.txt"";
+
+    void read_write_file() {
+        FileInputStream instream = null;
+        PrintStream outstream = null;
+        try {
+            instream = new FileInputStream(INPUT);
+            outstream = new PrintStream(new FileOutputStream(OUTPUT));
+            System.setIn(instream);
+            System.setOut(outstream);
+        } catch (Exception e) {
+        }
+    }
+
+    public static void main(String[] args) {
+        pw = new PrintWriter(System.out);
+        new C().run();
+        pw.close();
+    }
+
+    void pr(int num) {
+        pw.println(num);
+    }
+
+    void pr(long num) {
+        pw.println(num);
+    }
+
+    void pr(double num) {
+        pw.println(num);
+    }
+
+    void pr(String s) {
+        pw.println(s);
+    }
+
+    void pr(char c) {
+        pw.println(c);
+    }
+
+    class FastScanner {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st = new StringTokenizer("""");
+
+        String next() {
+            while (!st.hasMoreTokens())
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        int[] readArray(int n) {
+            int[] a = new int[n];
+            for (int i = 0; i < n; i++) a[i] = nextInt();
+            return a;
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+    }
+
+    void tr(Object... o) {
+        pw.println(Arrays.deepToString(o));
+    }
+}",0
+3666e0e8,ac7187d8,"
+import java.io.*;
+import java.lang.*;
+import java.util.*;
+
+public class C1499 {
+    public static void main(String[] args) throws IOException{
+        StringBuffer ans = new StringBuffer();
+        StringTokenizer st;
+        BufferedReader f = new BufferedReader(new InputStreamReader(System.in));
+        st = new StringTokenizer(f.readLine());
+        int t = Integer.parseInt(st.nextToken());
+        for(int i = 0; i < t; i++){
+            st = new StringTokenizer(f.readLine());
+            int n = Integer.parseInt(st.nextToken());
+            long op = Long.MAX_VALUE;
+            long[] arr = new long[n];
+            st = new StringTokenizer(f.readLine());
+            for(int x = 0; x < n; x++){
+                arr[x] = Integer.parseInt(st.nextToken());
+            }
+            long sum = arr[0];
+            long min = arr[0];
+            long min1 = arr[1];
+            long howMany = 1;
+            long howMany1 = 0;
+            long osum = sum;
+            for(int x = 1; x < n; x++){
+                osum+=arr[x];
+                if(x % 2 != 0){
+                    sum+= (n - howMany1) *arr[x];
+                    sum+=( min *(n-howMany));
+                    min1 = Math.min(arr[x], min1);
+                    howMany1++;
+                }else{
+                    sum+= (n - howMany) *arr[x];
+                    sum+=( min1 *(n-howMany1));
+                    min = Math.min(arr[x], min);
+                    howMany++;
+                }
+                //System.out.println(min1 + "" "" + min1);
+                //System.out.println(sum);
+                op = Math.min(op, sum);
+                sum = osum;
+            }
+
+            ans.append(op);
+            ans.append(""\n"");
+
+        }
+        f.close();
+
+
+
+        System.out.println(ans);
+    }
+    public static class point implements Comparable<point>{
+        int x;
+        int y;
+        public point(int x,int y){
+            this.x = x;
+            this.y = y;
+        }
+        public String toString(){
+            return(x + "" "" + y);
+        }
+        public boolean equals(Object x){
+            point y = ((point)(x));
+            if (this.x == y.x && this.y == y.y){
+                return true;
+            }
+            return false;
+        }
+        public int hashCode(){
+            return Objects.hash(x,y);
+        }
+        public int compareTo(point other){
+            if(this.x < other.x){
+                return -1;
+            }else if(this.x == other.x && this.y == other.y){
+                return 0;
+            }
+            return 1;
+        }
+    }
+}","import java.io.*;
+import java.util.*;
+public class C {
+    public static void main (String[] args) throws IOException {
+        BufferedReader f = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st = new StringTokenizer(f.readLine());
+        int t = Integer.parseInt(st.nextToken());
+        while (t-->0) {
+            st = new StringTokenizer(f.readLine());
+            int n = Integer.parseInt(st.nextToken());
+            st = new StringTokenizer(f.readLine());
+            long[] arr = new long[n];
+            for (int i = 0; i < n; i++) {
+                arr[i] = Long.parseLong(st.nextToken());
+            }
+            solve(n, arr);
+        }
+    }
+    static void solve(long n, long[] arr) {
+        long minEven = Integer.MAX_VALUE;
+        long minOdd = arr[0];
+        long evenSum = 0;
+        long oddSum = arr[0];
+        long finans = Long.MAX_VALUE;
+        long oddAns, evenAns;
+        long oddcount=1;
+        long evencount=0;
+        for (int k = 1; k < n; k++) {
+            if (k%2==1) {
+                evenSum+=arr[k];
+                evencount++;
+                minEven = Math.min(minEven, arr[k]);
+            } else {
+                oddSum+=arr[k];
+                oddcount++;
+                minOdd = Math.min(minOdd, arr[k]);
+            }
+            oddAns = oddSum+(n-oddcount)*minOdd;
+            evenAns = evenSum+(n-evencount)*minEven;
+            finans = Math.min(finans, oddAns+evenAns);
+        }
+        System.out.println(finans);
+    }
+}
+
+",0
+69b2fd22,9028caf7,"import java.io.*;
+import java.util.*;
+public class Main {
+    public static void main(String args[])
+    {
+        FastReader input=new FastReader();
+        PrintWriter out=new PrintWriter(System.out);
+        int T=1;
+        while(T-->0)
+        {
+            int n=input.nextInt();
+            int a[]=new int[n];
+            ArrayList<Integer> list=new ArrayList<>();
+            ArrayList<Integer> space=new ArrayList<>();
+            for(int i=0;i<n;i++)
+            {
+                a[i]=input.nextInt();
+                if(a[i]==1)
+                {
+                    list.add(i);
+                }
+                else
+                {
+                    space.add(i);
+                }
+            }
+            int pre[]=new int[space.size()];
+            for(int i=0;i<list.size();i++)
+            {
+                if(i==0)
+                {
+                    int min=Integer.MAX_VALUE;
+                    for(int j=0;j<space.size();j++)
+                    {
+                        pre[j]=Math.abs(list.get(i)-space.get(j));
+                        min=Math.min(min,pre[j]);
+                        pre[j]=min;
+                    }
+                }
+                else
+                {
+                    int arr[]=new int[space.size()];
+                    for(int j=0;j<i;j++)
+                    {
+                        arr[j]=Integer.MAX_VALUE;
+                    }
+
+                    int min=Integer.MAX_VALUE;
+                    for(int j=i;j<space.size();j++)
+                    {
+                        int v=Math.abs(list.get(i)-space.get(j));
+                        v+=pre[j-1];
+                        arr[j]=v;
+                        min=Math.min(min,v);
+                        arr[j]=min;
+                    }
+                    for(int j=0;j<space.size();j++)
+                    {
+                        pre[j]=arr[j];
+                    }
+                }
+            }
+            out.println(pre[space.size()-1]);
+        }
+        out.close();
+    }
+    static class FastReader
+    {
+        BufferedReader br;
+        StringTokenizer st;
+        public FastReader()
+        {
+            br = new BufferedReader(new InputStreamReader(System.in));
+        }
+        String next()
+        {
+            while (st == null || !st.hasMoreElements())
+            {
+                try
+                {
+                    st = new StringTokenizer(br.readLine());
+                }
+                catch (IOException e)
+                {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+        int nextInt()
+        {
+            return Integer.parseInt(next());
+        }
+        long nextLong()
+        {
+            return Long.parseLong(next());
+        }
+        double nextDouble()
+        {
+            return Double.parseDouble(next());
+        }
+        String nextLine()
+        {
+            String str="""";
+            try
+            {
+                str=br.readLine();
+            }
+            catch (IOException e)
+            {
+                e.printStackTrace();
+            }
+            return str;
+        }
+    }
+}","import java.io.*;
+import java.util.*;
+public class Main {
+    public static void main(String args[])
+    {
+        FastReader input=new FastReader();
+        PrintWriter out=new PrintWriter(System.out);
+        int T=1;
+        while(T-->0)
+        {
+            int n=input.nextInt();
+            int a[]=new int[n];
+            ArrayList<Integer> list=new ArrayList<>();
+            ArrayList<Integer> space=new ArrayList<>();
+            for(int i=0;i<n;i++)
+            {
+                a[i]=input.nextInt();
+                if(a[i]==1)
+                {
+                    list.add(i);
+                }
+                else
+                {
+                    space.add(i);
+                }
+            }
+            int pre[]=new int[space.size()];
+            for(int i=0;i<list.size();i++)
+            {
+                if(i==0)
+                {
+                    int min=Integer.MAX_VALUE;
+                    for(int j=0;j<space.size();j++)
+                    {
+                        pre[j]=Math.abs(list.get(i)-space.get(j));
+                        min=Math.min(min,pre[j]);
+                        pre[j]=min;
+                    }
+                }
+                else
+                {
+                    int arr[]=new int[space.size()];
+                    for(int j=0;j<i;j++)
+                    {
+                        arr[j]=Integer.MAX_VALUE;
+                    }
+
+                    int min=Integer.MAX_VALUE;
+                    for(int j=i;j<space.size();j++)
+                    {
+                        int v=Math.abs(list.get(i)-space.get(j));
+                        v+=pre[j-1];
+                        arr[j]=v;
+                        min=Math.min(min,v);
+                        arr[j]=min;
+                    }
+                    for(int j=0;j<space.size();j++)
+                    {
+                        pre[j]=arr[j];
+                    }
+                }
+            }
+            out.println(pre[space.size()-1]);
+        }
+        out.close();
+    }
+    static class FastReader
+    {
+        BufferedReader br;
+        StringTokenizer st;
+        public FastReader()
+        {
+            br = new BufferedReader(new InputStreamReader(System.in));
+        }
+        String next()
+        {
+            while (st == null || !st.hasMoreElements())
+            {
+                try
+                {
+                    st = new StringTokenizer(br.readLine());
+                }
+                catch (IOException e)
+                {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+        int nextInt()
+        {
+            return Integer.parseInt(next());
+        }
+        long nextLong()
+        {
+            return Long.parseLong(next());
+        }
+        double nextDouble()
+        {
+            return Double.parseDouble(next());
+        }
+        String nextLine()
+        {
+            String str="""";
+            try
+            {
+                str=br.readLine();
+            }
+            catch (IOException e)
+            {
+                e.printStackTrace();
+            }
+            return str;
+        }
+    }
+}",1
+3afcc566,d8a171a3,"//package codeforces.globalround18;
+
+import java.io.*;
+import java.util.*;
+
+import static java.lang.Math.*;
+
+//Think through the entire logic before jump into coding!
+//If you are out of ideas, take a guess! It is better than doing nothing!
+//Read both C and D, it is possible that D is easier than C for you!
+
+//Be aware of integer overflow!
+//If you find an answer and want to return immediately, don't forget to flush before return!
+
+public class C {
+    static InputReader in;
+    static PrintWriter out;
+
+    public static void main(String[] args) {
+        //initReaderPrinter(true);
+        initReaderPrinter(false);
+        solve(in.nextInt());
+        //solve(1);        
+    }
+
+    static void solve(int testCnt) {
+        for (int testNumber = 0; testNumber < testCnt; testNumber++) {
+            int n = in.nextInt();
+            char[] a = in.next().toCharArray(), b = in.next().toCharArray();
+            int match0 = 0, match1 = 0, mismatch10 = 0, mismatch01 = 0;
+            for(int i = 0; i < n; i++) {
+                if(a[i] == b[i]) {
+                    if(a[i] == '0') match0++;
+                    else match1++;
+                }
+                else {
+                    if(a[i] == '0') mismatch01++;
+                    else mismatch10++;
+                }
+            }
+            if(mismatch01 + mismatch10 == 0) out.println(0);
+            else {
+                if(match1 - match0 == 1 && mismatch01 == mismatch10) {
+                    out.println(min(match0 + match1, mismatch01 + mismatch10));
+                }
+                else if(match1 - match0 == 1) {
+                    out.println(match0 + match1);
+                }
+                else if(mismatch01 == mismatch10) {
+                    out.println(mismatch01 + mismatch10);
+                }
+                else out.println(-1);
+            }
+        }
+        out.close();
+    }
+
+    static void initReaderPrinter(boolean test) {
+        if (test) {
+            try {
+                in = new InputReader(new FileInputStream(""src/input.in""));
+                out = new PrintWriter(new FileOutputStream(""src/output.out""));
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+        } else {
+            in = new InputReader(System.in);
+            out = new PrintWriter(System.out);
+        }
+    }
+
+    static class InputReader {
+        BufferedReader br;
+        StringTokenizer st;
+
+        InputReader(InputStream stream) {
+            try {
+                br = new BufferedReader(new InputStreamReader(stream), 32768);
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }
+
+        String next() {
+            while (st == null || !st.hasMoreTokens()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+
+        String nextLine() {
+            String str = """";
+            try {
+                str = br.readLine();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+        }
+
+        Integer[] nextIntArray(int n) {
+            Integer[] a = new Integer[n];
+            for (int i = 0; i < n; i++) a[i] = nextInt();
+            return a;
+        }
+
+        int[] nextIntArrayPrimitive(int n) {
+            int[] a = new int[n];
+            for (int i = 0; i < n; i++) a[i] = nextInt();
+            return a;
+        }
+
+        int[] nextIntArrayPrimitiveOneIndexed(int n) {
+            int[] a = new int[n + 1];
+            for (int i = 1; i <= n; i++) a[i] = nextInt();
+            return a;
+        }
+
+        Long[] nextLongArray(int n) {
+            Long[] a = new Long[n];
+            for (int i = 0; i < n; i++) a[i] = nextLong();
+            return a;
+        }
+
+        long[] nextLongArrayPrimitive(int n) {
+            long[] a = new long[n];
+            for (int i = 0; i < n; i++) a[i] = nextLong();
+            return a;
+        }
+
+        long[] nextLongArrayPrimitiveOneIndexed(int n) {
+            long[] a = new long[n + 1];
+            for (int i = 1; i <= n; i++) a[i] = nextLong();
+            return a;
+        }
+
+        String[] nextStringArray(int n) {
+            String[] g = new String[n];
+            for (int i = 0; i < n; i++) g[i] = next();
+            return g;
+        }
+
+        List<Integer>[] readGraphOneIndexed(int n, int m) {
+            List<Integer>[] adj = new List[n + 1];
+            for (int i = 0; i <= n; i++) {
+                adj[i] = new ArrayList<>();
+            }
+            for (int i = 0; i < m; i++) {
+                int u = nextInt();
+                int v = nextInt();
+                adj[u].add(v);
+                adj[v].add(u);
+            }
+            return adj;
+        }
+
+        List<Integer>[] readGraphZeroIndexed(int n, int m) {
+            List<Integer>[] adj = new List[n];
+            for (int i = 0; i < n; i++) {
+                adj[i] = new ArrayList<>();
+            }
+            for (int i = 0; i < m; i++) {
+                int u = nextInt() - 1;
+                int v = nextInt() - 1;
+                adj[u].add(v);
+                adj[v].add(u);
+            }
+            return adj;
+        }
+
+        /*
+            A more efficient way of building a graph using int[] instead of ArrayList to store each node's neighboring nodes.
+            1-indexed.
+         */
+        int[][] buildGraph(int nodeCnt, int edgeCnt) {
+            int[] end1 = new int[edgeCnt], end2 = new int[edgeCnt];
+            int[] edgeCntForEachNode = new int[nodeCnt + 1], idxForEachNode = new int[nodeCnt + 1];
+            for (int i = 0; i < edgeCnt; i++) {
+                int u = in.nextInt(), v = in.nextInt();
+                edgeCntForEachNode[u]++;
+                edgeCntForEachNode[v]++;
+                end1[i] = u;
+                end2[i] = v;
+            }
+            int[][] adj = new int[nodeCnt + 1][];
+            for (int i = 1; i <= nodeCnt; i++) {
+                adj[i] = new int[edgeCntForEachNode[i]];
+            }
+            for (int i = 0; i < edgeCnt; i++) {
+                adj[end1[i]][idxForEachNode[end1[i]]] = end2[i];
+                idxForEachNode[end1[i]]++;
+                adj[end2[i]][idxForEachNode[end2[i]]] = end1[i];
+                idxForEachNode[end2[i]]++;
+            }
+            return adj;
+        }
+    }
+}","import java.io.*;
+import java.util.*;
+
+public class B {
+	
+	public static void main(String[] args)throws IOException {
+		
+		FastScanner scan = new FastScanner();
+		PrintWriter output = new PrintWriter(System.out);
+		int t = scan.nextInt();
+		for(int tt = 0;tt<t;tt++) {
+			int n = scan.nextInt();
+			char initial[] = scan.next().toCharArray();
+			char desired[] = scan.next().toCharArray();
+			int lit1 = 0, lit2 = 0;
+			int ans = Integer.MAX_VALUE;
+			for(int i = 0;i<n;i++) {
+				if(initial[i]=='1') lit1++;
+				if(desired[i]=='1') lit2++;
+			}
+			if(lit1==lit2) {
+				int count = 0;
+				for(int i = 0;i<n;i++) if(initial[i]!=desired[i]) count++;
+				ans = Math.min(ans, count);
+			}
+			if(lit2==(n-lit1+1)) {
+				int count = 0;
+				for(int i = 0;i<n;i++) if(initial[i]==desired[i]) count++;
+				ans = Math.min(ans, count);
+			}
+			if(ans == Integer.MAX_VALUE) ans = -1;
+			output.println(ans);	
+		}
+		output.flush();
+	}
+	
+	public static int[] sort(int arr[]) {
+		List<Integer> list = new ArrayList<>();
+		for(int i:arr) list.add(i);
+		Collections.sort(list);
+		for(int i = 0;i<list.size();i++) arr[i] = list.get(i);
+		return arr;
+	}
+	
+	public static int gcd(int a, int b) {
+		if(a == 0) return b;
+		return gcd(b%a, a);
+	}
+	
+	public static void printArray(int arr[]) {
+		for(int i:arr) System.out.print(i+"" "");
+		System.out.println();
+	}
+	
+	static class FastScanner {
+		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st=new StringTokenizer("""");
+		String next() {
+			while (!st.hasMoreTokens())
+				try {
+					st=new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			return st.nextToken();
+		}
+
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+		int[] readArray(int n) {
+			int[] a=new int[n];
+			for (int i=0; i<n; i++) a[i]=nextInt();
+			return a;
+		}
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+		
+		double nextDouble() {
+			return Double.parseDouble(next());
+		}
+	}
+
+}
+",0
+2120328e,52cd85f2,"/*****  --->         :)    Vijender  Srivastava      (:       <---       *****/
+import java.util.*;
+import java.lang.*;
+import java.io.*;
+public class Main  
+{
+    static FastReader sc =new FastReader();
+    static PrintWriter out=new PrintWriter(System.out);
+    static int mod=10000007;
+   static StringBuilder sb=new StringBuilder();
+    /* start */
+       public static void main(String [] args)
+    {
+            int t = i();
+            while(t-->0)
+            {
+                int n = i();
+                int a[] = input(n);
+                char c[] = inputC();
+                ArrayList<Integer> b = new ArrayList<>();
+                ArrayList<Integer> r = new ArrayList<>();
+                for(int i=0;i<n;i++)
+                {
+                    if(c[i]=='R')
+                    r.add(a[i]);
+                    else 
+                    b.add(a[i]);
+                }
+                Collections.sort(b);
+                Collections.sort(r,Collections.reverseOrder());
+                boolean is = true;
+                int cnt = 1;
+                for(int i=0;i<b.size();i++)
+                {
+                    if(b.get(i)<cnt)
+                    {
+                        is = false;
+                        break;
+                    }
+                    cnt++;
+                }
+                for(int i=0;i<r.size();i++)
+                {
+                    if(r.get(i)>n-i)
+                    {
+                        is = false;
+                        break;
+                    }
+                }
+
+                out.println(is==true?""YES"":""NO"");
+            }
+            out.close();
+    }
+
+    
+    /* end */
+    static class FastReader 
+    { 
+        BufferedReader br; 
+        StringTokenizer st; 
+
+        public FastReader() 
+        { 
+            br = new BufferedReader(new
+                     InputStreamReader(System.in)); 
+        } 
+
+        String next() 
+        { 
+            while (st == null || !st.hasMoreElements()) 
+            { 
+                try
+                { 
+                    st = new StringTokenizer(br.readLine()); 
+                } 
+                catch (IOException  e) 
+                { 
+                    e.printStackTrace(); 
+                } 
+            } 
+            return st.nextToken(); 
+        } 
+
+        int nextInt() 
+        { 
+            return Integer.parseInt(next()); 
+        } 
+
+        long nextLong() 
+        { 
+            return Long.parseLong(next()); 
+        } 
+
+        double nextDouble() 
+        { 
+            return Double.parseDouble(next()); 
+        } 
+
+        String nextLine() 
+        { 
+            String str = """"; 
+            try
+            { 
+                str = br.readLine(); 
+            } 
+            catch (IOException e) 
+            { 
+                e.printStackTrace(); 
+            } 
+            return str; 
+        } 
+    } 
+
+    
+    static int i() {
+        return sc.nextInt();
+    }
+
+    static String s() {
+        return sc.next();
+    }
+
+    static long l() {
+        return sc.nextLong();
+    }
+
+    static char[] inputC()
+    {
+        String s = sc.nextLine();
+        return s.toCharArray();
+    }
+
+    static int[] input(int n) {
+        int A[]=new int[n];
+           for(int i=0;i<n;i++) {
+               A[i]=sc.nextInt();
+           }
+        return A;
+    }
+
+    static long[] inputL(int n) {
+        long A[]=new long[n];
+           for(int i=0;i<n;i++) {
+               A[i]=sc.nextLong();
+           }
+           return A;
+    }
+
+    static long[] putL(long a[]) {
+        long A[]=new long[a.length];
+           for(int i=0;i<a.length;i++) {
+               A[i]=a[i];
+           }
+           return A;
+    }
+
+    static String[] inputS(int n) {
+        String A[]=new String[n];
+           for(int i=0;i<n;i++) {
+               A[i]=sc.next();
+           }
+           return A;
+    }
+      
+    static int gcd(int a, int b) 
+     { 
+         if (a == 0) 
+             return b; 
+         return gcd(b % a, a); 
+     } 
+
+     static long gcd(long a, long b) 
+     { 
+         if (a == 0) 
+             return b; 
+         return gcd(b % a, a); 
+     } 
+
+     
+    
+     static String reverse(String s) {
+        StringBuffer p=new StringBuffer(s);
+        p.reverse();
+        return p.toString();
+     }
+
+     static int min(int a,int b) {
+        return Math.min(a, b);
+    }
+    static int min(int a,int b,int c) {
+        return Math.min(a, Math.min(b, c));
+    }
+    static int min(int a,int b,int c,int d) {
+        return Math.min(a, Math.min(b, Math.min(c, d)));
+    }
+
+    static int max(int a,int b) {
+        return Math.max(a, b);
+    }
+    static int max(int a,int b,int c) {
+        return Math.max(a, Math.max(b, c));
+    }
+    static int max(int a,int b,int c,int d) {
+        return Math.max(a, Math.max(b, Math.max(c, d)));
+    }
+    static long min(long a,long b) {
+        return Math.min(a, b);
+    }
+    static long min(long a,long b,long c) {
+        return Math.min(a, Math.min(b, c));
+    }
+    static long min(long a,long b,long c,long d) {
+        return Math.min(a, Math.min(b, Math.min(c, d)));
+    }
+    static long max(long a,long b) {
+        return Math.max(a, b);
+    }
+    static long max(long a,long b,long c) {
+        return Math.max(a, Math.max(b, c));
+    }
+    static long max(long a,long b,long c,long d) {
+        return Math.max(a, Math.max(b, Math.max(c, d)));
+    }
+
+    static long sum(int A[]) {
+        long sum=0;
+        for(int i : A) {
+            sum+=i;
+        }
+        return sum;
+    }
+
+    static long sum(long A[]) {
+        long sum=0;
+        for(long i : A) {
+            sum+=i;
+        }
+        return sum;
+    }
+
+    static void print(int A[]) {
+        for(int i : A) {
+            System.out.print(i+"" "");
+        }
+        System.out.println();
+    }
+
+    static void print(long A[]) {
+        for(long i : A) {
+            System.out.print(i+"" "");
+        }
+        System.out.println();
+    }
+
+    static long mod(long x) {
+          return ((x%mod + mod)%mod);
+    }
+
+    static long power(long x, long y)
+    {
+
+	if(y==0)
+		return 1;
+	if(x==0)
+		return 0;
+    long res = 1;
+    while (y > 0) {
+
+        if (y % 2 == 1)
+            res = (res * x) ;
+
+        y = y >> 1; 
+        x = (x * x);
+    }
+
+    return res;
+    }
+
+    static boolean prime(int n) 
+	    { 
+	        if (n <= 1) 
+	            return false; 
+	        if (n <= 3) 
+	            return true; 
+	        if (n % 2 == 0 || n % 3 == 0) 
+	            return false; 
+	        double sq=Math.sqrt(n);
+	  
+	        for (int i = 5; i <= sq; i = i + 6) 
+	            if (n % i == 0 || n % (i + 2) == 0) 
+	                return false; 
+	        return true; 
+	    } 
+
+     static boolean prime(long n) 
+	    { 
+	        if (n <= 1) 
+	            return false; 
+	        if (n <= 3) 
+	            return true; 
+	        if (n % 2 == 0 || n % 3 == 0) 
+	            return false; 
+	        double sq=Math.sqrt(n);
+	  
+	        for (int i = 5; i <= sq; i = i + 6) 
+	            if (n % i == 0 || n % (i + 2) == 0) 
+	                return false; 
+	        return true; 
+	    } 
+        //pair class
+        private static class Pair implements Comparable<Pair> {
+            int first, second;
+            public Pair(int f, int s) {
+                first = f;
+                second = s;
+            }
+            @Override
+            public int compareTo(Pair p) {
+                if (first > p.first)
+                    return 1;
+                else if (first < p.first)
+                    return -1;
+                else {
+                    if (second > p.second)
+                        return 1;
+                    else if (second < p.second)
+                        return -1;
+                    else
+                        return 0;
+                }
+            }
+     
+        }
+}","import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.StringTokenizer;
+
+public class PC3C {
+	static PrintWriter out = new PrintWriter(System.out);
+	static MyFastReaderPC3C in = new MyFastReaderPC3C();
+	static long mod = (long) (1e9 + 7);
+
+	public static void main(String[] args) throws Exception {
+		
+		int test = i();
+		while (test-- > 0) {
+			 
+             int n=i();
+             int[] arr=arrI(n);
+             String s=string();
+             
+             ArrayList<Integer> lR=new ArrayList<>();
+
+             ArrayList<Integer> lB=new ArrayList<>();
+             for(int i=0;i<n;i++) {
+            	
+            	if(s.charAt(i)=='R') lR.add(arr[i]);
+            	else lB.add(arr[i]);
+            	 
+             }
+             
+             
+             Collections.sort(lB);
+             Collections.sort(lR,Collections.reverseOrder());
+             
+             
+             int k=1;
+             boolean st=true;
+             for(int i=0;i<lB.size();i++) {
+            	 
+            	 if(lB.get(i)>=k) {
+            		k+=1; 
+            	 }
+            	 else {
+            		st=false;
+            		break;
+            	 }
+            		 
+             }
+             boolean st2=true;
+               k=n;
+               for(int i=0;i<lR.size();i++) {
+            	 
+            	 if(lR.get(i)>k) {
+            	   st2=false;
+            	   break;
+            	 }
+            	 else {
+            		k-=1; 
+            	 }
+            		 
+             }
+               
+               if(st && st2) out.print(""YES"");
+               else out.print(""NO"");
+             
+             
+			out.print(""\n"");
+			out.flush();
+		}
+		out.close();
+	}
+
+	static class pair {
+		long x, y;
+
+		pair(long ar, long ar2) {
+			x = ar;
+			y = ar2;
+		}
+	}
+
+	static void sort(long[] a) // check for long
+	{
+		ArrayList<Long> l = new ArrayList<>();
+		for (long i : a)
+			l.add(i);
+		Collections.sort(l);
+		for (int i = 0; i < a.length; i++)
+			a[i] = l.get(i);
+	}
+
+	static void sort(int[] a) {
+		ArrayList<Integer> l = new ArrayList<>();
+		for (int i : a)
+			l.add(i);
+		Collections.sort(l);
+		for (int i = 0; i < a.length; i++)
+			a[i] = l.get(i);
+	}
+
+	public static int gcd(int a, int b) {
+		if (a == 0)
+			return b;
+		return gcd(b % a, a);
+	}
+
+	static class DescendingComparator implements Comparator<Integer> {
+		public int compare(Integer a, Integer b) {
+			return b - a;
+		}
+	}
+
+	static class AscendingComparator implements Comparator<Integer> {
+		public int compare(Integer a, Integer b) {
+			return a - b;
+		}
+	}
+
+	static boolean isPalindrome(char X[]) {
+		int l = 0, r = X.length - 1;
+		while (l <= r) {
+			if (X[l] != X[r])
+				return false;
+			l++;
+			r--;
+		}
+		return true;
+	}
+
+	static long fact(long N) {
+		long num = 1L;
+		while (N >= 1) {
+			num = ((num % mod) * (N % mod)) % mod;
+			N--;
+		}
+		return num;
+	}
+
+	static long pow(long a, long b) {
+		long mod = 1000000007;
+		long pow = 1;
+		long x = a;
+		while (b != 0) {
+			if ((b & 1) != 0)
+				pow = (pow * x) % mod;
+			x = (x * x) % mod;
+			b /= 2;
+		}
+		return pow;
+	}
+
+	static long toggleBits(long x)// one's complement || Toggle bits
+	{
+		int n = (int) (Math.floor(Math.log(x) / Math.log(2))) + 1;
+
+		return ((1 << n) - 1) ^ x;
+	}
+
+	static int countBits(long a) {
+		return (int) (Math.log(a) / Math.log(2) + 1);
+	}
+
+	static boolean isPrime(long N) {
+		if (N <= 1)
+			return false;
+		if (N <= 3)
+			return true;
+		if (N % 2 == 0 || N % 3 == 0)
+			return false;
+		for (int i = 5; i * i <= N; i = i + 6)
+			if (N % i == 0 || N % (i + 2) == 0)
+				return false;
+		return true;
+	}
+
+	static long GCD(long a, long b) {
+		if (b == 0) {
+			return a;
+		} else
+			return GCD(b, a % b);
+	}
+
+	// Debugging Functions Starts
+
+	static void print(char A[]) {
+		for (char c : A)
+			System.out.print(c + "" "");
+		System.out.println();
+	}
+
+	static void print(boolean A[]) {
+		for (boolean c : A)
+			System.out.print(c + "" "");
+		System.out.println();
+	}
+
+	static void print(int A[]) {
+		for (int a : A)
+			System.out.print(a + "" "");
+		System.out.println();
+	}
+
+	static void print(long A[]) {
+		for (long i : A)
+			System.out.print(i + "" "");
+		System.out.println();
+
+	}
+
+	static void print(ArrayList<Integer> A) {
+		for (int a : A)
+			System.out.print(a + "" "");
+		System.out.println();
+	}
+
+	// Debugging Functions END
+	// ----------------------
+	// IO FUNCTIONS STARTS
+	static HashMap<Integer, Integer> getHashMap(int A[]) {
+		HashMap<Integer, Integer> mp = new HashMap<>();
+		for (int a : A) {
+			int f = mp.getOrDefault(a, 0) + 1;
+			mp.put(a, f);
+		}
+		return mp;
+	}
+
+	public static Map<Character, Integer> mapSortByValue(Map<Character, Integer> hm) {
+		// Create a list from elements of HashMap
+		List<Map.Entry<Character, Integer>> list = new LinkedList<Map.Entry<Character, Integer>>(hm.entrySet());
+
+		// Sort the list
+		Collections.sort(list, new Comparator<Map.Entry<Character, Integer>>() {
+			public int compare(Map.Entry<Character, Integer> o1, Map.Entry<Character, Integer> o2) {
+				return o1.getValue() - o2.getValue();
+			}
+		});
+
+		// put data from sorted list to hashmap
+		Map<Character, Integer> temp = new LinkedHashMap<Character, Integer>();
+		for (Map.Entry<Character, Integer> aa : list) {
+			temp.put(aa.getKey(), aa.getValue());
+		}
+		return temp;
+	}
+	static String string() {
+		return in.nextLine();
+	}
+
+	static int i() {
+		return in.nextInt();
+	}
+
+	static long l() {
+		return in.nextLong();
+	}
+
+	static int[] arrI(int N) {
+		int A[] = new int[N];
+		for (int i = 0; i < N; i++) {
+			A[i] = in.nextInt();
+		}
+		return A;
+	}
+
+	static long[] arrL(int N) {
+		long A[] = new long[N];
+		for (int i = 0; i < A.length; i++)
+			A[i] = in.nextLong();
+		return A;
+	}
+
+}
+
+class MyFastReaderPC3C {
+	BufferedReader br;
+	StringTokenizer st;
+
+	public MyFastReaderPC3C() {
+		br = new BufferedReader(new InputStreamReader(System.in));
+	}
+
+	String next() {
+		while (st == null || !st.hasMoreElements()) {
+			try {
+				st = new StringTokenizer(br.readLine());
+			} catch (IOException e) {
+				e.printStackTrace();
+			}
+		}
+		return st.nextToken();
+	}
+
+	int nextInt() {
+		return Integer.parseInt(next());
+	}
+
+	long nextLong() {
+		return Long.parseLong(next());
+	}
+
+	double nextDouble() {
+		return Double.parseDouble(next());
+	}
+
+	String nextLine() {
+		String str = """";
+		try {
+			str = br.readLine();
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+		return str;
+	}
+}
+",0
+54eb12ca,949502c2,"import java.io.*;
+import java.util.*;
+public class huge implements Runnable 
+{
+	private boolean console=false;
+	
+	ArrayList<Integer> adj[]; int maxi,maxc; int dis[];
+	int vis[];
+	Queue<Integer> q;
+	public void solve() 
+	{
+		int i;
+		int n=in.ni(); maxi=0; maxc=0;
+		int a=in.ni()-1,b=in.ni()-1; 
+		int da=in.ni(); int db=in.ni();
+		adj=new ArrayList[n];
+		for(i=0;i<n;i++)
+			adj[i]=new ArrayList();
+		for(i=0;i<n-1;i++)
+		{
+			int u=in.ni()-1; int v=in.ni()-1;
+			adj[u].add(v); adj[v].add(u); 
+		}
+		maxc=maxi=0;
+		vis=new int[n]; int cur=-1; dfs(1,cur);
+		Arrays.fill(vis,0);
+		cur=-1; maxc=0; dfs(maxi,cur);
+		
+		int d=(maxc);
+		int ans=1;
+		if(db<=2*da||2*da>=d||da>=db)
+			ans=0;
+		q= new LinkedList();
+		vis=new int[n];
+		q.add(a);
+		dis=new int[n];
+		dis[a]=0; int cu=0;
+		while(!q.isEmpty()||vis[b]==0)
+		{
+			int v=q.poll();
+			vis[v]=1;
+			bfs(v);
+		}
+		if(dis[b]<=da)
+			ans=0;
+		if(ans==1)
+			out.println(""Bob"");
+		else
+			out.println(""Alice"");
+	}
+	public void bfs(int v)
+	{
+		for(int node:adj[v])
+		{
+			if(vis[node]==0)
+			{
+				q.add(node);
+				dis[node]=dis[v]+1;
+			}
+		}
+	}
+	public void dfs(int v,int cur)
+	{
+		cur++;
+		if(cur>maxc)
+		{
+			maxc=cur; maxi=v;
+		}
+		vis[v]=1;
+		for(int node:adj[v])
+		{
+			if(vis[node]==0)
+				dfs(node,cur);
+		}
+	}
+	@Override
+	public void run() {
+		try {  init();  } 
+		catch (FileNotFoundException e) {  e.printStackTrace();   }
+
+		int t= in.ni();
+
+		while (t-->0) {
+			solve();
+			out.flush(); }
+	}
+	private FastInput in;    private PrintWriter out;
+	public static void main(String[] args) throws Exception {	 new huge().run();	 }
+
+	private void init() throws FileNotFoundException {
+		InputStream inputStream = System.in; 	 OutputStream outputStream = System.out;
+		try {  if (!console && System.getProperty(""user.name"").equals(""sachan"")) {
+			outputStream = new FileOutputStream(""/home/sachan/Desktop/output.txt"");
+			inputStream = new FileInputStream(""/home/sachan/Desktop/input.txt"");   	}
+		}	catch (Exception ignored) {	}
+		out = new PrintWriter(outputStream); 	 in = new FastInput(inputStream);
+	}
+	static class FastInput { InputStream obj;
+	public FastInput(InputStream obj) {	this.obj = obj;	}
+	byte inbuffer[] = new byte[1024];  int lenbuffer = 0, ptrbuffer = 0;
+	int readByte() { if (lenbuffer == -1) throw new InputMismatchException();
+	if (ptrbuffer >= lenbuffer) { ptrbuffer = 0;
+	try { lenbuffer = obj.read(inbuffer);  }
+	catch (IOException e) { throw new InputMismatchException(); } }    
+	if (lenbuffer <= 0) return -1;return inbuffer[ptrbuffer++]; }
+
+	String ns() { int b = skip();StringBuilder sb = new StringBuilder();
+	while (!(isSpaceChar(b)))	  { sb.appendCodePoint(b);b = readByte(); }return sb.toString();}
+
+	int ni() { int num = 0, b;boolean minus = false;
+	while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-')) ;
+	if (b == '-') { minus = true;b = readByte(); }
+	while (true) { if (b >= '0' && b <= '9') { num = num * 10 + (b - '0'); } else {
+		return minus ? -num : num; }b = readByte(); }}
+
+	long nl() { long num = 0;int b;boolean minus = false;
+	while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-')) ;
+	if (b == '-') { minus = true;b = readByte(); }
+	while (true) { if (b >= '0' && b <= '9') { num = num * 10L + (b - '0'); } else {
+		return minus ? -num : num; }b = readByte(); } }
+
+	boolean isSpaceChar(int c) { return (!(c >= 33 && c <= 126)); }
+	int skip() { int b;while ((b = readByte()) != -1 && isSpaceChar(b)) ;return b; }
+	float nf() {return Float.parseFloat(ns());}
+	double nd() {return Double.parseDouble(ns());}
+	char nc() {return (char) skip();}
+	}
+}
+","import static java.lang.Math.max;
+import static java.lang.Math.min;
+import static java.lang.Math.abs;
+import static java.lang.System.out;
+import java.util.*;
+import java.io.*;
+import java.math.*;
+
+public class Template {
+
+	static int mod = 1000000007;
+
+	public static void main(String[] args) {
+		FastScanner sc = new FastScanner();
+		int yo = sc.nextInt();
+		while (yo-- > 0) {
+			int n = sc.nextInt();
+            int a = sc.nextInt()-1;
+            int b = sc.nextInt()-1;
+            int da = sc.nextInt();
+            int db = sc.nextInt();
+            
+            List<List<Integer>> list = new ArrayList<>();
+            for(int i = 0; i < n; i++) list.add(new ArrayList<>());
+            
+            for(int i = 0; i < n-1; i++){
+                int x = sc.nextInt()-1;
+                int y = sc.nextInt()-1;
+                list.get(x).add(y);
+                list.get(y).add(x);
+            }
+            
+            for(int i = 0; i <= n; i++) depth[i] = 0;
+            diam = 0;
+            dfs(a,-1,list);
+            
+            if(2 * da >= min(diam, db) || depth[b] <= da){
+                out.println(""Alice"");
+            }
+            else {
+                out.println(""Bob"");
+            }
+            
+		}
+	}
+    
+    static int[] depth = new int[200001];
+    static int diam = 0;
+    static int dfs(int x, int p, List<List<Integer>> list) {
+        int len = 0;
+        List<Integer> ne = list.get(x);
+        for(int y : ne) {
+            if(y != p) {
+                depth[y] = depth[x] + 1;
+                int cur = 1 + dfs(y, x,list);
+                diam = max(diam, cur + len);
+                len = max(len, cur);
+            }
+        }
+        return len;
+    }
+   
+
+	public static class Pair {
+		int x;
+		int y;
+
+		public Pair(int x, int y) {
+			this.x = x;
+			this.y = y;
+		}
+	}
+
+	public static void sort(int[] arr) {
+		ArrayList<Integer> ls = new ArrayList<Integer>();
+		for (int x : arr)
+			ls.add(x);
+		Collections.sort(ls);
+		for (int i = 0; i < arr.length; i++)
+			arr[i] = ls.get(i);
+	}
+
+	public static long gcd(long a, long b) {
+		if (b == 0)
+			return a;
+		return gcd(b, a % b);
+	}
+
+	static boolean[] sieve(int N) {
+		boolean[] sieve = new boolean[N + 1];
+		for (int i = 2; i <= N; i++)
+			sieve[i] = true;
+
+		for (int i = 2; i <= N; i++) {
+			if (sieve[i]) {
+				for (int j = 2 * i; j <= N; j += i) {
+					sieve[j] = false;
+				}
+			}
+		}
+		return sieve;
+	}
+
+	public static long power(long x, long y, long p) {
+		long res = 1L;
+		x = x % p;
+		while (y > 0) {
+			if ((y & 1) == 1)
+				res = (res * x) % p;
+			y >>= 1;
+			x = (x * x) % p;
+		}
+		return res;
+	}
+
+	public static void print(int[] arr) {
+		//for debugging only
+		for (int x : arr)
+			out.print(x + "" "");
+		out.println();
+	}
+
+	static class FastScanner {
+		private int BS = 1 << 16;
+		private char NC = (char) 0;
+		private byte[] buf = new byte[BS];
+		private int bId = 0, size = 0;
+		private char c = NC;
+		private double cnt = 1;
+		private BufferedInputStream in;
+
+		public FastScanner() {
+			in = new BufferedInputStream(System.in, BS);
+		}
+
+		public FastScanner(String s) {
+			try {
+				in = new BufferedInputStream(new FileInputStream(new File(s)), BS);
+			} catch (Exception e) {
+				in = new BufferedInputStream(System.in, BS);
+			}
+		}
+
+		private char getChar() {
+			while (bId == size) {
+				try {
+					size = in.read(buf);
+				} catch (Exception e) {
+					return NC;
+				}
+				if (size == -1)
+					return NC;
+				bId = 0;
+			}
+			return (char) buf[bId++];
+		}
+
+		public int nextInt() {
+			return (int) nextLong();
+		}
+
+		public int[] readInts(int N) {
+			int[] res = new int[N];
+			for (int i = 0; i < N; i++) {
+				res[i] = (int) nextLong();
+			}
+			return res;
+		}
+
+		public long[] readLongs(int N) {
+			long[] res = new long[N];
+			for (int i = 0; i < N; i++) {
+				res[i] = nextLong();
+			}
+			return res;
+		}
+
+		public long nextLong() {
+			cnt = 1;
+			boolean neg = false;
+			if (c == NC)
+				c = getChar();
+			for (; (c < '0' || c > '9'); c = getChar()) {
+				if (c == '-')
+					neg = true;
+			}
+			long res = 0;
+			for (; c >= '0' && c <= '9'; c = getChar()) {
+				res = (res << 3) + (res << 1) + c - '0';
+				cnt *= 10;
+			}
+			return neg ? -res : res;
+		}
+
+		public double nextDouble() {
+			double cur = nextLong();
+			return c != '.' ? cur : cur + nextLong() / cnt;
+		}
+
+		public double[] readDoubles(int N) {
+			double[] res = new double[N];
+			for (int i = 0; i < N; i++) {
+				res[i] = nextDouble();
+			}
+			return res;
+		}
+
+		public String next() {
+			StringBuilder res = new StringBuilder();
+			while (c <= 32)
+				c = getChar();
+			while (c > 32) {
+				res.append(c);
+				c = getChar();
+			}
+			return res.toString();
+		}
+
+		public String nextLine() {
+			StringBuilder res = new StringBuilder();
+			while (c <= 32)
+				c = getChar();
+			while (c != '\n') {
+				res.append(c);
+				c = getChar();
+			}
+			return res.toString();
+		}
+
+		public boolean hasNext() {
+			if (c > 32)
+				return true;
+			while (true) {
+				c = getChar();
+				if (c == NC)
+					return false;
+				else if (c > 32)
+					return true;
+			}
+		}
+	}
+
+	//	For Input.txt and Output.txt	
+	//	FileInputStream in = new FileInputStream(""input.txt"");
+	//	FileOutputStream out = new FileOutputStream(""output.txt"");
+	//	PrintWriter pw = new PrintWriter(out);
+	//	Scanner sc = new Scanner(in);
+}",0
+11c2ab99,e6a6e318,"import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.StringTokenizer;
+
+public class Main {
+
+	public static void main(String[] args) {
+		FastScanner fs=new FastScanner();
+		int T=fs.nextInt();
+		PrintWriter out=new PrintWriter(System.out);
+		for (int tt=0; tt<T; tt++) {
+			int n=fs.nextInt(), k=fs.nextInt();
+			int[] positions=fs.readArray(k), temps=fs.readArray(k);
+			int[] forced=new int[n];
+			Arrays.fill(forced, Integer.MAX_VALUE/2);
+			for (int i=0; i<k; i++) forced[positions[i]-1]=temps[i];
+			for (int i=1; i<n; i++)
+				forced[i]=Math.min(forced[i], forced[i-1]+1);
+			for (int i=n-2; i>=0; i--)
+				forced[i]=Math.min(forced[i], forced[i+1]+1);
+			for (int i=0; i<n; i++) out.print(forced[i]+"" "");
+			out.println();
+			
+		}
+		out.close();
+	}
+
+	static void sort(int[] a) {
+		ArrayList<Integer> l=new ArrayList<>();
+		for (int i:a) l.add(i);
+		Collections.sort(l);
+		for (int i=0; i<a.length; i++) a[i]=l.get(i);
+	}
+	
+	static class FastScanner {
+		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st=new StringTokenizer("""");
+		String next() {
+			while (!st.hasMoreTokens())
+				try {
+					st=new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			return st.nextToken();
+		}
+		
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+		int[] readArray(int n) {
+			int[] a=new int[n];
+			for (int i=0; i<n; i++) a[i]=nextInt();
+			return a;
+		}
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+	}
+
+	
+}
+
+","//package codeforces;
+import java.io.PrintWriter;
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.*;
+public class solution { 
+    public static void main(String args[]) throws java.lang.Exception{ 
+    	FastScanner s=new FastScanner();
+		PrintWriter out=new PrintWriter(System.out);
+		int t=s.nextInt();
+		for(int tt=0;tt<t;tt++) {
+			int n=s.nextInt(), k=s.nextInt();
+			int[] a=s.readArray(k), temp=s.readArray(k);
+			long[] ans=new long[n];
+			Arrays.fill(ans, Integer.MAX_VALUE);
+			for (int i=0; i<k; i++) {
+				ans[a[i]-1]=temp[i];
+			}
+			for (int i=1; i<n; i++) {
+				ans[i]=Math.min(ans[i],ans[i-1]+1);
+			}
+			for (int i=n-2; i>=0; i--) {
+				ans[i]=Math.min(ans[i],ans[i+1]+1);
+			}
+			for (int i=0; i<n; i++) {
+				out.print(ans[i]+"" "");
+			}
+			out.println();
+		}
+		out.close();
+    }
+    static void sort(long [] a) {
+		ArrayList<Long> l=new ArrayList<>();
+		for (long i:a) l.add(i);
+		Collections.sort(l);
+		for (int i=0; i<a.length; i++) a[i]=l.get(i);
+	}
+    static void sort(int [] a) {
+		ArrayList<Integer> l=new ArrayList<>();
+		for (int i:a) l.add(i);
+		Collections.sort(l);
+		for (int i=0; i<a.length; i++) a[i]=l.get(i);
+	}
+    static int gcd(int a, int b){
+      if (b == 0)
+        return a;
+      return gcd(b, a % b);
+    }
+    static void sortcol(int a[][],int c) {
+		Arrays.sort(a, (x, y) -> {
+			if(x[c]>y[c]) {
+				return 1;
+			}else {
+				return -1;
+			}
+		});
+	
+	}
+    public static void printb(boolean ans) {
+    	if(ans) {
+    		System.out.println(""Yes"");
+    	}else {
+    		System.out.println(""No"");
+    	}
+    }
+    static class FastScanner {
+		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st=new StringTokenizer("""");
+		String next() {
+			while (!st.hasMoreTokens())
+				try {
+					st=new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			return st.nextToken();
+		}
+		double nextDouble() {
+			return Double.parseDouble(next());
+		}
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+		int[] readArray(int n) {
+			int[] a=new int[n];
+			for (int i=0; i<n; i++) a[i]=nextInt();
+			return a;
+		}
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+	}
+    static class Pair implements Comparable<Pair>{
+    	int a , b; 
+    	Pair(int x , int y){
+    		a=x;
+    		b=y;
+    	}
+    	public int compareTo(Pair o) {
+    		return a != o.a ? a - o.a : b - o.b;
+    	}
+    }
+}
+",1
+35f0c004,efa38999,"import java.io.*;
+import java.util.*;
+public class Main {
+    public static void main(String args[])
+    {
+        FastReader input=new FastReader();
+        PrintWriter out=new PrintWriter(System.out);
+        int T=input.nextInt();
+        while(T-->0)
+        {
+            int n=input.nextInt();
+            String a=input.next();
+            String b=input.next();
+            int same1=0,same0=0,opp1=0,opp0=0;
+            for(int i=0;i<n;i++)
+            {
+                if(a.charAt(i)==b.charAt(i))
+                {
+                    if(a.charAt(i)=='1') same1++;
+                    else same0++;
+                }
+                else
+                {
+                    if(a.charAt(i)=='1') opp1++;
+                    else opp0++;
+                }
+            }
+            if(same0+same1==n)
+            {
+                out.println(0);
+            }
+            else
+            {
+                int x=same1+opp1;
+                int y=same1+opp0;
+                int z=same0+opp0;
+                if(x==y || (z+1)==y)
+                {
+                    int min=Integer.MAX_VALUE;
+                    if((same0+same1)%2!=0 && same0==(same0+same1)/2)
+                    {
+                        min=Math.min(min,same0+same1);
+                    }
+                    if((opp0+opp1)%2==0 && opp0==(opp0+opp1)/2)
+                    {
+                        min=Math.min(min,opp0+opp1);
+                    }
+                    out.println(min);
+                }
+                else
+                {
+                    out.println(-1);
+                }
+            }
+        }
+        out.close();
+    }
+    static class FastReader
+    {
+        BufferedReader br;
+        StringTokenizer st;
+        public FastReader()
+        {
+            br = new BufferedReader(new InputStreamReader(System.in));
+        }
+        String next()
+        {
+            while (st == null || !st.hasMoreElements())
+            {
+                try
+                {
+                    st = new StringTokenizer(br.readLine());
+                }
+                catch (IOException e)
+                {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+        int nextInt()
+        {
+            return Integer.parseInt(next());
+        }
+        long nextLong()
+        {
+            return Long.parseLong(next());
+        }
+        double nextDouble()
+        {
+            return Double.parseDouble(next());
+        }
+        String nextLine()
+        {
+            String str="""";
+            try
+            {
+                str=br.readLine();
+            }
+            catch (IOException e)
+            {
+                e.printStackTrace();
+            }
+            return str;
+        }
+    }
+}","import java.util.*;
+import java.io.*;
+
+public class Main {
+    // For fast input output
+    static class FastReader {
+        BufferedReader br;
+        StringTokenizer st;
+
+        public FastReader() {
+            try {
+                br = new BufferedReader(
+                        new FileReader(""input.txt""));
+                PrintStream out = new PrintStream(new FileOutputStream(""output.txt""));
+                System.setOut(out);
+            } catch (Exception e) {
+                br = new BufferedReader(new InputStreamReader(System.in));
+            }
+        }
+
+        String next() {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+
+        String nextLine() {
+            String str = """";
+            try {
+                str = br.readLine();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+        }
+    }
+
+    // end of fast i/o code
+    public static void main(String[] args) {
+        FastReader reader = new FastReader();
+        StringBuilder sb = new StringBuilder("""");
+
+        int t = reader.nextInt();
+        int ans = 0;
+        while (t-- > 0) {
+            int n = reader.nextInt();
+            String a = reader.nextLine();
+            String b = reader.nextLine();
+            ans  = -1;
+
+            int even_demand = 0;
+            int odd_demand = 0;
+            int same_ones = 0, same_zeros = 0;
+            int diff_ones = 0, diff_zeros = 0;
+            for(int i=0; i<n; i++){
+                if(a.charAt(i)==b.charAt(i)){
+                    even_demand++;
+                    if(a.charAt(i)=='1'){
+                        same_ones++;
+                    }else{
+                        same_zeros++;
+                    }
+                }else{
+                    odd_demand++;
+                    if(a.charAt(i)=='1'){
+                        diff_ones++;
+                    }else{
+                        diff_zeros++;
+                    }
+                }
+            }
+
+            // System.out.println(even_demand+"" ""+same_ones+"" ""+same_zeros+"" ""+odd_demand+"" ""+diff_ones+"" ""+diff_zeros);
+            if(even_demand%2==1 && same_ones==same_zeros+1){
+                ans = even_demand;
+            }
+            if(odd_demand%2==0 && diff_ones==diff_zeros){
+                if(ans==-1){
+                    ans = odd_demand;
+                }else{
+                    ans = Math.min(ans, odd_demand);
+                }
+            }
+            sb.append(ans + ""\n"");
+        }
+        System.out.println(sb);
+    }
+}",0
+42fe7dd0,9291ca83,"import java.util.*;
+ public class Solution {
+    static Scanner sc=new Scanner(System.in);
+    public static void main(String args[]) {
+      int t=sc.nextInt();
+      outer:while(t-->0){
+        int n=sc.nextInt();
+        int[][] ct=new int[n][5];
+        int[] len=new int[n];
+        for (int i=0;i<n;i++) {
+            String s=sc.next();
+            len[i]=s.length();
+            for(char c:s.toCharArray()){
+                ct[i][c-'a']++;
+            }
+        }
+        int mx=0;
+        for (int i=0;i<5;i++) {
+            int[] diff=new int[n];
+            for (int j=0;j<n;j++) {
+                diff[j]=ct[j][i]-(len[j]-ct[j][i]);
+            }
+            Arrays.sort(diff);
+            int sum=0,inc=0;
+            for(int j=n-1;j>=0;j--){
+                sum+=diff[j];
+                if (sum>0) {
+                    inc++;
+                }else {
+                    break;
+                }
+            }
+            mx=Math.max(mx,inc);
+        }
+        System.out.println(mx);
+        }
+        
+      }
+
+    }
+
+","import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.util.*;
+
+public class Practice {
+    static HashMap<String, Integer> map = new HashMap<>();
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        int t = sc.nextInt();
+        while (t-->0) {
+            int n = sc.nextInt();
+            int[][] occurances = new int[5][n];
+            for(int i=0;i<n;i++){
+                String s = sc.next();
+                int[] count = new int[5];
+                int len = s.length();
+                for(int j=0;j<s.length();j++){
+                    count[s.charAt(j)-'a']++;
+                }
+                for(int j=0;j<5;j++){
+                    occurances[j][i] = count[j] - (len-count[j]);
+                }
+            }
+            int ans = 0;
+            for(int i=0;i<5;i++){
+                Arrays.sort(occurances[i]);
+                int tmpAns = 0; int tmpSum=0;
+                for(int j=n-1;j>=0;j--){
+                    tmpSum+=occurances[i][j];
+                    if(tmpSum>0) tmpAns++;
+                    else break;
+                }
+                ans = Math.max(ans, tmpAns);
+            }
+            System.out.println(ans);
+        }
+    }
+}
+
+",1
+5a81e159,866a2d52,"
+
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.StringTokenizer;
+
+public class C_CF {
+
+    public static void main(String[] args) {
+        FastScanner57 fs = new FastScanner57();
+        PrintWriter pw = new PrintWriter(System.out);
+        int t = fs.ni();
+        //int t = 1;
+        for (int tc = 0; tc < t; tc++) {
+            int n = fs.ni();
+            long[][] lr = new long[n][2];
+            for (int i = 0; i < n; i++) {
+                lr[i][0] = fs.nl();
+                lr[i][1] = fs.nl();
+            }
+            List<List<Integer>> list = new ArrayList();
+            for (int i = 0; i < n;i ++) {
+                List<Integer> temp = new ArrayList();
+                list.add(temp);
+            }
+            for (int i = 0; i < n-1; i++) {
+                int a = fs.ni()-1, b = fs.ni()-1;
+                list.get(a).add(b);
+                list.get(b).add(a);
+            }
+            Long[][] dp = new Long[n][2];
+            pw.println(recur(0,0,-1,new long[] {0,0},dp,lr,list));
+        }
+        pw.close();
+
+    }
+    // 0 -> left was chosen
+    // 1 -> right was chosen
+    public static long recur(int ind, int p,int prev, long[] v, Long[][] dp, long[][] lr,List<List<Integer>> list) {
+
+        long last = v[0];
+        long ls = 0L;
+        long rs = 0L;
+        if (p==1) {
+            last = v[1];
+        }
+        if (ind!=0) ls += (long)Math.abs(last-lr[ind][0]);
+        if (ind!=0) rs += (long)Math.abs(last-lr[ind][1]);
+        if (dp[ind][p]!=null) return dp[ind][p];
+        long[] cur = lr[ind];
+        
+        List<Integer> temp = list.get(ind);
+        for (int val : temp) {
+            if (prev==val) continue;
+            ls += recur(val,0,ind,cur,dp,lr,list);
+            rs += recur(val,1,ind,cur,dp,lr,list);
+        }
+        return dp[ind][p] = Math.max(ls,rs);
+    }
+
+    public static void sort(long[] a) {
+        List<Long> list = new ArrayList();
+        for (int i = 0; i < a.length; i++) {
+            list.add(a[i]);
+        }
+        Collections.sort(list);
+        for (int i = 0; i < a.length; i++) {
+            a[i] = list.get(i);
+        }
+    }
+
+    public static long gcd(long n1, long n2) {
+        if (n2 == 0) {
+            return n1;
+        }
+        return gcd(n2, n1 % n2);
+    }
+
+}
+
+class UnionFind16 {
+
+    int[] id;
+
+    public UnionFind16(int size) {
+        id = new int[size];
+        for (int i = 0; i < size; i++) {
+            id[i] = i;
+        }
+    }
+
+    public int find(int p) {
+        int root = p;
+        while (root != id[root]) {
+            root = id[root];
+        }
+        while (p != root) {
+            int next = id[p];
+            id[p] = root;
+            p = next;
+        }
+        return root;
+    }
+
+    public void union(int p, int q) {
+        int a = find(p), b = find(q);
+        if (a == b) {
+            return;
+        }
+        id[b] = a;
+    }
+}
+
+class FastScanner57 {
+
+    BufferedReader br;
+    StringTokenizer st;
+
+    public FastScanner57() {
+        br = new BufferedReader(new InputStreamReader(System.in), 32768);
+        st = null;
+    }
+
+    String next() {
+        while (st == null || !st.hasMoreElements()) {
+            try {
+                st = new StringTokenizer(br.readLine());
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+        }
+        return st.nextToken();
+    }
+
+    int ni() {
+        return Integer.parseInt(next());
+    }
+
+    int[] intArray(int N) {
+        int[] ret = new int[N];
+        for (int i = 0; i < N; i++) {
+            ret[i] = ni();
+        }
+        return ret;
+    }
+
+    long nl() {
+        return Long.parseLong(next());
+    }
+
+    long[] longArray(int N) {
+        long[] ret = new long[N];
+        for (int i = 0; i < N; i++) {
+            ret[i] = nl();
+        }
+        return ret;
+    }
+
+    double nd() {
+        return Double.parseDouble(next());
+    }
+
+    String nextLine() {
+        String str = """";
+        try {
+            str = br.readLine();
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        return str;
+    }
+}
+","import java.io.*;
+import java.util.*;
+
+public class P1529C {
+  public static final int MAX = 100000;
+
+  private static final List<Integer>[] adjacency = new List[MAX];
+  private static final int[][] pair = new int[MAX][2];
+
+  public static void main(String[] args) {
+    SpeedScanner in = new SpeedScanner();
+
+    for(int i = 0; i < MAX; ++i)
+      adjacency[i] = new ArrayList<>();
+
+    int t = in.nextInt();
+    while(t-- != 0) {
+      int nv = in.nextInt();
+      for(int i = 0; i < nv; ++i) {
+        pair[i][0] = in.nextInt();
+        pair[i][1] = in.nextInt();
+      }
+      for(int i = 1; i < nv; ++i) {
+        int x = in.nextInt() - 1, y = in.nextInt() - 1;
+        adjacency[x].add(y);
+        adjacency[y].add(x);
+      }
+
+      long[] alts = dfsTraverse(0, -1);
+      System.out.println(alts[0] >= alts[1] ? alts[0] : alts[1]);
+
+      for(int i = 0; i < nv; ++i)
+        adjacency[i].clear();
+    }
+  }
+
+  private static long[] dfsTraverse(int vertex, int parent) {
+    long sumDiffL = 0, sumDiffR = 0;
+    for(int child: adjacency[vertex]) {
+      if(child == parent)
+        continue;
+      long[] temp = dfsTraverse(child, vertex);
+      sumDiffL += Math.max(Math.abs(pair[vertex][0] - pair[child][0]) + temp[0],
+          Math.abs(pair[vertex][0] - pair[child][1]) + temp[1]);
+      sumDiffR += Math.max(Math.abs(pair[vertex][1] - pair[child][0]) + temp[0],
+          Math.abs(pair[vertex][1] - pair[child][1]) + temp[1]);
+    }
+    return new long[]{sumDiffL, sumDiffR};
+  }
+}
+
+class SpeedScanner {
+  BufferedReader in;
+  StringTokenizer splitter;
+
+  public SpeedScanner() {
+    in = new BufferedReader(new InputStreamReader(System.in));
+  }
+
+  String next() {
+    while(splitter == null || !splitter.hasMoreElements())
+      try {
+        splitter = new StringTokenizer(in.readLine());
+      } catch (IOException e) {
+        e.printStackTrace();
+      }
+    return splitter.nextToken();
+  }
+
+  String nextLine() {
+    String s = """";
+    try {
+      s = in.readLine();
+    } catch (IOException e) {
+      e.printStackTrace();
+    }
+    return s;
+  }
+
+  int nextInt() {
+    return Integer.parseInt(next());
+  }
+
+  long nextLong() {
+    return Long.parseLong(next());
+  }
+
+  double nextDouble() {
+    return Double.parseDouble(next());
+  }
+}
+",0
+3d245498,7838095f,"import java.io.DataInputStream;
+import java.io.IOException;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+
+public class Main {
+
+    private static void run() throws IOException {
+        int n = in.nextInt();
+        int[] a = new int[n];
+
+        int[] ans = new int[n];
+
+        int sum = 0;
+        a[0] = in.nextInt();
+        for (int i = 1; i < n; i++) {
+            a[i] = in.nextInt();
+
+            if (a[i] * sum <= 0) {
+                ans[i] = 1;
+            } else {
+                ans[i] = -1;
+            }
+            sum += ans[i] * a[i];
+        }
+        if (sum == 0) {
+            sum -= ans[1] * a[1];
+            ans[1] = -ans[1];
+            sum += ans[1] * a[1];
+        }
+
+        int d = gcd(Math.abs(sum), Math.abs(a[0]));
+
+        if (a[0] * sum < 0) {
+            ans[0] = Math.abs(sum) / d;
+        } else {
+            ans[0] = -Math.abs(sum) / d;
+        }
+        for (int i = 1; i < n; i++) {
+            ans[i] *= Math.abs(a[0]) / d;
+        }
+
+        print_array(ans);
+    }
+
+    public static void main(String[] args) throws IOException {
+        in = new Reader();
+        out = new PrintWriter(new OutputStreamWriter(System.out));
+
+        int t = in.nextInt();
+        for (int i = 0; i < t; i++) {
+            run();
+        }
+
+        out.flush();
+        in.close();
+        out.close();
+    }
+
+    private static int gcd(int a, int b) {
+        if (a == 0 || b == 0)
+            return 0;
+        while (b != 0) {
+            int tmp;
+            tmp = a % b;
+            a = b;
+            b = tmp;
+        }
+        return a;
+    }
+
+    static final long mod = 1000000007;
+
+    static long pow_mod(long a, long b) {
+        long result = 1;
+        while (b != 0) {
+            if ((b & 1) != 0) result = (result * a) % mod;
+            a = (a * a) % mod;
+            b >>= 1;
+        }
+        return result;
+    }
+
+    private static long multiplied_mod(long... longs) {
+        long ans = 1;
+        for (long now : longs) {
+            ans = (ans * now) % mod;
+        }
+        return ans;
+    }
+
+    @SuppressWarnings(""FieldCanBeLocal"")
+    private static Reader in;
+    private static PrintWriter out;
+
+    private static int[] read_int_array(int len) throws IOException {
+        int[] a = new int[len];
+        for (int i = 0; i < len; i++) {
+            a[i] = in.nextInt();
+        }
+        return a;
+    }
+
+    private static long[] read_long_array(int len) throws IOException {
+        long[] a = new long[len];
+        for (int i = 0; i < len; i++) {
+            a[i] = in.nextLong();
+        }
+        return a;
+    }
+
+    private static void print_array(int[] array) {
+        for (int now : array) {
+            out.print(now);
+            out.print(' ');
+        }
+        out.println();
+    }
+
+    private static void print_array(long[] array) {
+        for (long now : array) {
+            out.print(now);
+            out.print(' ');
+        }
+        out.println();
+    }
+
+    static class Reader {
+        private static final int BUFFER_SIZE = 1 << 16;
+        private final DataInputStream din;
+        private final byte[] buffer;
+        private int bufferPointer, bytesRead;
+
+        Reader() {
+            din = new DataInputStream(System.in);
+            buffer = new byte[BUFFER_SIZE];
+            bufferPointer = bytesRead = 0;
+        }
+
+        public String readLine() throws IOException {
+            final byte[] buf = new byte[1024]; // line length
+            int cnt = 0, c;
+            while ((c = read()) != -1) {
+                if (c == '\n') {
+                    break;
+                }
+                buf[cnt++] = (byte) c;
+            }
+            return new String(buf, 0, cnt);
+        }
+
+        public int nextSign() throws IOException {
+            byte c = read();
+            while ('+' != c && '-' != c) {
+                c = read();
+            }
+            return '+' == c ? 0 : 1;
+        }
+
+        private static boolean isSpaceChar(int c) {
+            return !(c >= 33 && c <= 126);
+        }
+
+        public int skip() throws IOException {
+            int b;
+            // noinspection ALL
+            while ((b = read()) != -1 && isSpaceChar(b)) {
+                ;
+            }
+            return b;
+        }
+
+        public char nc() throws IOException {
+            return (char) skip();
+        }
+
+        public String next() throws IOException {
+            int b = skip();
+            final StringBuilder sb = new StringBuilder();
+            while (!isSpaceChar(b)) { // when nextLine, (isSpaceChar(b) && b != ' ')
+                sb.appendCodePoint(b);
+                b = read();
+            }
+            return sb.toString();
+        }
+
+        public int nextInt() throws IOException {
+            int ret = 0;
+            byte c = read();
+            while (c <= ' ') {
+                c = read();
+            }
+            final boolean neg = c == '-';
+            if (neg) {
+                c = read();
+            }
+            do {
+                ret = ret * 10 + c - '0';
+            } while ((c = read()) >= '0' && c <= '9');
+
+            if (neg) {
+                return -ret;
+            }
+            return ret;
+        }
+
+        public long nextLong() throws IOException {
+            long ret = 0;
+            byte c = read();
+            while (c <= ' ') {
+                c = read();
+            }
+            final boolean neg = c == '-';
+            if (neg) {
+                c = read();
+            }
+            do {
+                ret = ret * 10 + c - '0';
+            }
+            while ((c = read()) >= '0' && c <= '9');
+            if (neg) {
+                return -ret;
+            }
+            return ret;
+        }
+
+        public double nextDouble() throws IOException {
+            double ret = 0, div = 1;
+            byte c = read();
+            while (c <= ' ') {
+                c = read();
+            }
+            final boolean neg = c == '-';
+            if (neg) {
+                c = read();
+            }
+
+            do {
+                ret = ret * 10 + c - '0';
+            }
+            while ((c = read()) >= '0' && c <= '9');
+
+            if (c == '.') {
+                while ((c = read()) >= '0' && c <= '9') {
+                    ret += (c - '0') / (div *= 10);
+                }
+            }
+
+            if (neg) {
+                return -ret;
+            }
+            return ret;
+        }
+
+        private void fillBuffer() throws IOException {
+            bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
+            if (bytesRead == -1) {
+                buffer[0] = -1;
+            }
+        }
+
+        private byte read() throws IOException {
+            if (bufferPointer == bytesRead) {
+                fillBuffer();
+            }
+            return buffer[bufferPointer++];
+        }
+
+        public void close() throws IOException {
+            din.close();
+        }
+
+    }
+}","import java.io.DataInputStream;
+import java.io.IOException;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+
+public class Main {
+
+    private static void run() throws IOException {
+        int n = in.nextInt();
+        int[] a = new int[n];
+
+        int[] ans = new int[n];
+
+        int sum = 0;
+        a[0] = in.nextInt();
+        for (int i = 1; i < n; i++) {
+            a[i] = in.nextInt();
+
+            // checking is the multiply of the element at i index and sum is less then or equal 0
+            if (a[i] * sum <= 0) {
+                ans[i] = 1;
+            } else {
+                ans[i] = -1;
+            }
+            sum += ans[i] * a[i];
+        }
+        if (sum == 0) {
+            sum -= ans[1] * a[1];
+            ans[1] = -ans[1];
+            sum += ans[1] * a[1];
+        }
+
+        // storing the greatest available divisor
+
+        int d = gcd(Math.abs(sum), Math.abs(a[0]));
+
+        /**
+         * if the the value of a[0]  gets smaller then zero we will divide it with divisor and keep it  absolute positive
+         * else we make it negative and divide it with divisor
+         * then will store in index 0
+         */
+        if (a[0] * sum < 0) {
+            ans[0] = Math.abs(sum) / d;
+        } else {
+            ans[0] = -Math.abs(sum) / d;
+        }
+        /**
+         * then for each value of array we will divide the divisor with the absolute value of index 0
+         */
+        for (int i = 1; i < n; i++) {
+            ans[i] *= (double) Math.abs(a[0]) / d;
+        }
+
+        print_array(ans);
+    }
+
+    public static void main(String[] args) throws IOException {
+        in = new Reader();
+        out = new PrintWriter(new OutputStreamWriter(System.out));
+
+        int t = in.nextInt();
+        for (int i = 0; i < t; i++) {
+            run();
+        }
+
+        out.flush();
+        in.close();
+        out.close();
+    }
+
+    /**
+     * Here we are finding greatest common divisor of a[1], so that we divide the maximum value of sum as the sum might cross  20000 or more
+     * @param a
+     * @param b
+     * @return greatest common divisor
+     */
+    private static int gcd(int a, int b) {
+        if (a == 0 || b == 0)
+            return 0;
+        while (b != 0) {
+            int tmp;
+            tmp = a % b;
+            a = b;
+            b = tmp;
+        }
+        return a;
+    }
+
+
+    @SuppressWarnings(""FieldCanBeLocal"")
+    private static Reader in;
+    private static PrintWriter out;
+
+    private static void print_array(int[] array) {
+        for (int now : array) {
+            out.print(now);
+            out.print(' ');
+        }
+        out.println();
+    }
+
+
+    static class Reader {
+        private static final int BUFFER_SIZE = 1 << 16;
+        private final DataInputStream din;
+        private final byte[] buffer;
+        private int bufferPointer, bytesRead;
+
+        Reader() {
+            din = new DataInputStream(System.in);
+            buffer = new byte[BUFFER_SIZE];
+            bufferPointer = bytesRead = 0;
+        }
+
+        public int nextInt() throws IOException {
+            int ret = 0;
+            byte c = read();
+            while (c <= ' ') {
+                c = read();
+            }
+            final boolean neg = c == '-';
+            if (neg) {
+                c = read();
+            }
+            do {
+                ret = ret * 10 + c - '0';
+            } while ((c = read()) >= '0' && c <= '9');
+
+            if (neg) {
+                return -ret;
+            }
+            return ret;
+        }
+        private void fillBuffer() throws IOException {
+            bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
+            if (bytesRead == -1) {
+                buffer[0] = -1;
+            }
+        }
+
+        private byte read() throws IOException {
+            if (bufferPointer == bytesRead) {
+                fillBuffer();
+            }
+            return buffer[bufferPointer++];
+        }
+
+        public void close() throws IOException {
+            din.close();
+        }
+
+    }
+}
+
+	 	 		 	 		     		 		 	 		 	 	",1
+26e699de,fcc7e8fa,"//package Task1;
+
+import java.util.Scanner;
+
+public class Menorah {
+    static int MOD9= 1000000000;
+
+    public static void main(String[] args){
+
+        Scanner sc= new Scanner(System.in);
+        int numberTest=sc.nextInt();
+        while(numberTest-->0){
+            int n=sc.nextInt();
+            char[] s=new char[n+5];
+            char[] t=new char[n+5];
+            String ss=sc.next();
+            String tt=sc.next();
+            s=ss.toCharArray();
+            t=tt.toCharArray();
+            int cntax = 0, cntbx = 0, same = 0;
+            int ans=MOD9;
+            for(int i=0; i<n; i++){
+                if(s[i]=='1')cntax++;
+                if(t[i]=='1')cntbx++;
+                if(s[i]==t[i])same++;
+            }
+            if(same==n){
+                System.out.println(0);
+                continue;
+            }
+            else if (cntax==0){
+                System.out.println(-1);
+                continue;
+            }
+            if(cntax==cntbx){
+                ans=Math.min(ans,n-same);
+            }
+            if(n-cntax+1==cntbx)ans=Math.min(ans,same);
+            if(ans<MOD9) System.out.println(ans);
+            else System.out.println(-1);
+
+
+
+        }
+
+    }
+}
+","import java.io.OutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.PrintWriter;
+import java.util.*;
+import java.io.IOException;
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.io.InputStream;
+
+public class Main {
+
+    public static void main(String[] args) {
+        InputStream inputStream = System.in;
+        OutputStream outputStream = System.out;
+        InputReader in = new InputReader(inputStream);
+        PrintWriter out = new PrintWriter(outputStream);
+        TaskA solver = new TaskA();
+        int t;
+        t = in.nextInt();
+        //t = 1;
+        while (t > 0) {
+            solver.call(in,out);
+            t--;
+        }
+        out.close();
+    }
+
+    static class TaskA {
+        public void call(InputReader in, PrintWriter out) {
+            int n, _00 = 0, _01 = 0, _11 = 0, _10 = 0;
+            n = in.nextInt();
+            char[] s = in.next().toCharArray();
+            char[] s1 = in.next().toCharArray();
+
+            for (int i = 0; i < n; i++) {
+                if(s[i]==s1[i]){
+                    if(s[i]=='0'){
+                        _00++;
+                    }
+                    else{
+                        _11++;
+                    }
+                }
+                else{
+                    if(s[i]=='0'){
+                        _01++;
+                    }
+                    else{
+                        _10++;
+                    }
+                }
+            }
+            int ans = Integer.MAX_VALUE;
+
+            if(_10 ==_01){
+                ans = 2*_01;
+            }
+            if(_11 == _00 + 1){
+                ans = Math.min(ans, 2*_00 + 1);
+            }
+
+            if(ans == Integer.MAX_VALUE){
+                out.println(-1);
+            }
+            else{
+                out.println(ans);
+            }
+        }
+    }
+
+    static int gcd(int a, int b)
+    {
+        if (a == 0)
+            return b;
+        return gcd(b % a, a);
+    }
+
+    static int lcm(int a, int b)
+    {
+        return (a / gcd(a, b)) * b;
+    }
+
+    static class answer implements Comparable<answer>{
+        int a, b;
+
+        public answer(int a, int b) {
+            this.a = a;
+            this.b = b;
+        }
+
+        @Override
+        public int compareTo(answer o) {
+            return o.a - this.a;
+        }
+    }
+
+    static class arrayListClass {
+        ArrayList<Integer> arrayList2 ;
+
+        public arrayListClass(ArrayList<Integer> arrayList) {
+            this.arrayList2 = arrayList;
+        }
+    }
+
+    static long gcd(long a, long b)
+    {
+        if (b == 0)
+            return a;
+        return gcd(b, a % b);
+    }
+
+    static void sort(long[] a) {
+        ArrayList<Long> l=new ArrayList<>();
+        for (long i:a) l.add(i);
+        Collections.sort(l);
+        for (int i=0; i<a.length; i++) a[i]=l.get(i);
+    }
+
+    static final Random random=new Random();
+
+    static void shuffleSort(int[] a) {
+        int n = a.length;
+        for (int i=0; i<n; i++) {
+            int oi=random.nextInt(n), temp=a[oi];
+            a[oi]=a[i]; a[i]=temp;
+        }
+        Arrays.sort(a);
+    }
+
+    static class InputReader {
+        public BufferedReader reader;
+        public StringTokenizer tokenizer;
+
+        public InputReader(InputStream stream) {
+            reader = new BufferedReader(new InputStreamReader(stream), 32768);
+            tokenizer = null;
+        }
+
+        public String next() {
+            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
+                try {
+                    tokenizer = new StringTokenizer(reader.readLine());
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+            }
+            return tokenizer.nextToken();
+        }
+
+        public int nextInt() {
+            return Integer.parseInt(next());
+        }
+        public long nextLong(){
+            return Long.parseLong(next());
+        }
+        public double nextDouble() {
+            return Double.parseDouble(next());
+        }
+
+    }
+}",0
+9028caf7,e6b7a899,"import java.io.*;
+import java.util.*;
+public class Main {
+    public static void main(String args[])
+    {
+        FastReader input=new FastReader();
+        PrintWriter out=new PrintWriter(System.out);
+        int T=1;
+        while(T-->0)
+        {
+            int n=input.nextInt();
+            int a[]=new int[n];
+            ArrayList<Integer> list=new ArrayList<>();
+            ArrayList<Integer> space=new ArrayList<>();
+            for(int i=0;i<n;i++)
+            {
+                a[i]=input.nextInt();
+                if(a[i]==1)
+                {
+                    list.add(i);
+                }
+                else
+                {
+                    space.add(i);
+                }
+            }
+            int pre[]=new int[space.size()];
+            for(int i=0;i<list.size();i++)
+            {
+                if(i==0)
+                {
+                    int min=Integer.MAX_VALUE;
+                    for(int j=0;j<space.size();j++)
+                    {
+                        pre[j]=Math.abs(list.get(i)-space.get(j));
+                        min=Math.min(min,pre[j]);
+                        pre[j]=min;
+                    }
+                }
+                else
+                {
+                    int arr[]=new int[space.size()];
+                    for(int j=0;j<i;j++)
+                    {
+                        arr[j]=Integer.MAX_VALUE;
+                    }
+
+                    int min=Integer.MAX_VALUE;
+                    for(int j=i;j<space.size();j++)
+                    {
+                        int v=Math.abs(list.get(i)-space.get(j));
+                        v+=pre[j-1];
+                        arr[j]=v;
+                        min=Math.min(min,v);
+                        arr[j]=min;
+                    }
+                    for(int j=0;j<space.size();j++)
+                    {
+                        pre[j]=arr[j];
+                    }
+                }
+            }
+            out.println(pre[space.size()-1]);
+        }
+        out.close();
+    }
+    static class FastReader
+    {
+        BufferedReader br;
+        StringTokenizer st;
+        public FastReader()
+        {
+            br = new BufferedReader(new InputStreamReader(System.in));
+        }
+        String next()
+        {
+            while (st == null || !st.hasMoreElements())
+            {
+                try
+                {
+                    st = new StringTokenizer(br.readLine());
+                }
+                catch (IOException e)
+                {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+        int nextInt()
+        {
+            return Integer.parseInt(next());
+        }
+        long nextLong()
+        {
+            return Long.parseLong(next());
+        }
+        double nextDouble()
+        {
+            return Double.parseDouble(next());
+        }
+        String nextLine()
+        {
+            String str="""";
+            try
+            {
+                str=br.readLine();
+            }
+            catch (IOException e)
+            {
+                e.printStackTrace();
+            }
+            return str;
+        }
+    }
+}","import java.io.IOException;
+import java.io.InputStream;
+import java.io.PrintWriter;
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+import java.util.*;
+
+public class Main {
+	static final long MOD=1000000007;
+	static final long MOD1=998244353;
+	static long ans=0;
+	//static ArrayList<Integer> ans=new ArrayList<>();
+	public static void main(String[] args){
+		PrintWriter out = new PrintWriter(System.out);
+		InputReader sc=new InputReader(System.in);
+		int N = sc.nextInt();
+		int[] A = sc.nextIntArray(N);
+		ArrayList<Integer> a1 = new ArrayList<Integer>();
+		ArrayList<Integer> a2 = new ArrayList<Integer>();
+		for (int i = 0; i < A.length; i++) {
+			if (A[i]==0) {
+				a1.add(i);
+			}else {
+				a2.add(i);
+			}
+		}
+		int[][] dp = new int[a1.size()+1][a2.size()+1];
+		for (int i = 0; i < dp.length; i++) {
+			Arrays.fill(dp[i], Integer.MAX_VALUE/2);
+		}
+		dp[0][0] = 0;
+		for (int i = 1; i <= a1.size() ; i++) {
+			int pos1 = a1.get(i-1);
+			for (int j = 0; j <= a2.size(); j++) {
+				dp[i][j] = dp[i-1][j];
+				if (j-1>=0) {
+					int pos2 = a2.get(j-1);
+					dp[i][j] = Math.min(dp[i][j], dp[i-1][j-1] + Math.abs(pos1-pos2));
+				}
+			}
+		}
+		System.out.println(dp[a1.size()][a2.size()]);
+	}
+	static class InputReader { 
+		private InputStream in;
+		private byte[] buffer = new byte[1024];
+		private int curbuf;
+		private int lenbuf;
+		public InputReader(InputStream in) {
+			this.in = in;
+			this.curbuf = this.lenbuf = 0;
+		}
+		public boolean hasNextByte() {
+			if (curbuf >= lenbuf) {
+				curbuf = 0;
+				try {
+					lenbuf = in.read(buffer);
+				} catch (IOException e) {
+					throw new InputMismatchException();
+				}
+				if (lenbuf <= 0)
+					return false;
+			}
+			return true;
+		}
+ 
+		private int readByte() {
+			if (hasNextByte())
+				return buffer[curbuf++];
+			else
+				return -1;
+		}
+ 
+		private boolean isSpaceChar(int c) {
+			return !(c >= 33 && c <= 126);
+		}
+ 
+		private void skip() {
+			while (hasNextByte() && isSpaceChar(buffer[curbuf]))
+				curbuf++;
+		}
+ 
+		public boolean hasNext() {
+			skip();
+			return hasNextByte();
+		}
+ 
+		public String next() {
+			if (!hasNext())
+				throw new NoSuchElementException();
+			StringBuilder sb = new StringBuilder();
+			int b = readByte();
+			while (!isSpaceChar(b)) {
+				sb.appendCodePoint(b);
+				b = readByte();
+			}
+			return sb.toString();
+		}
+ 
+		public int nextInt() {
+			if (!hasNext())
+				throw new NoSuchElementException();
+			int c = readByte();
+			while (isSpaceChar(c))
+				c = readByte();
+			boolean minus = false;
+			if (c == '-') {
+				minus = true;
+				c = readByte();
+			}
+			int res = 0;
+			do {
+				if (c < '0' || c > '9')
+					throw new InputMismatchException();
+				res = res * 10 + c - '0';
+				c = readByte();
+			} while (!isSpaceChar(c));
+			return (minus) ? -res : res;
+		}
+ 
+		public long nextLong() {
+			if (!hasNext())
+				throw new NoSuchElementException();
+			int c = readByte();
+			while (isSpaceChar(c))
+				c = readByte();
+			boolean minus = false;
+			if (c == '-') {
+				minus = true;
+				c = readByte();
+			}
+			long res = 0;
+			do {
+				if (c < '0' || c > '9')
+					throw new InputMismatchException();
+				res = res * 10 + c - '0';
+				c = readByte();
+			} while (!isSpaceChar(c));
+			return (minus) ? -res : res;
+		}
+ 
+		public double nextDouble() {
+			return Double.parseDouble(next());
+		}
+ 
+		public int[] nextIntArray(int n) {
+			int[] a = new int[n];
+			for (int i = 0; i < n; i++)
+				a[i] = nextInt();
+			return a;
+		}
+		public double[] nextDoubleArray(int n) {
+			double[] a = new double[n];
+			for (int i = 0; i < n; i++)
+				a[i] = nextDouble();
+			return a;
+		}
+		public long[] nextLongArray(int n) {
+			long[] a = new long[n];
+			for (int i = 0; i < n; i++)
+				a[i] = nextLong();
+			return a;
+		}
+ 
+		public char[][] nextCharMap(int n, int m) {
+			char[][] map = new char[n][m];
+			for (int i = 0; i < n; i++)
+				map[i] = next().toCharArray();
+			return map;
+		}
+	}
+}
+",0
+b2590225,f7fc2e94,"//package com.company;
+
+import java.util.*;
+
+public class P3 {
+    public static class tower implements Comparable<tower>{
+        ArrayList<Integer> index;
+        int size;
+        tower(){
+            size = 0;
+            index = new ArrayList<>();
+        }
+        @Override
+        public int compareTo(tower a) {
+            if(this.size > a.size) {
+                return 1;
+            } else if (this.size < a.size) {
+                return -1;
+            } else {
+                return 0;
+            }
+        }
+    }
+
+    public static void main(String[] args) {
+        Scanner scan = new Scanner(System.in);
+        int t = scan.nextInt();
+        while(t>0){
+            t--;
+            int n = scan.nextInt();
+            int m = scan.nextInt();
+            int x = scan.nextInt();
+
+
+            ArrayList<Integer> arr = new ArrayList<>();
+            HashMap<Integer,Integer> map = new HashMap<>();
+            for(int i = 0;i<n;i++){
+                arr.add(scan.nextInt());
+                map.put(i, arr.get(i));
+            }
+
+            System.out.println(""YES"");
+            PriorityQueue<tower> towers  = new PriorityQueue<>();
+            for(int i = 0;i<m;i++){
+                tower curr = new tower();
+                towers.add(curr);
+            }
+            for(int i = 0;i<n;i++){
+                tower curr = towers.poll();
+                curr.size += arr.get(i);
+                curr.index.add(i);
+                towers.add(curr);
+            }
+
+            int[] ans = new int[n];
+            int count = 1;
+            while(towers.size() > 0){
+                tower curr = towers.poll();
+                for(Integer p : curr.index){
+                    ans[p] = count;
+                }
+                count++;
+            }
+            for(int i = 0;i<n;i++){
+                System.out.print(ans[i] +"" "");
+            }
+            System.out.println();
+
+        }
+    }
+}
+","//package Practice;
+import java.io.*;
+import java.util.*;
+public class codefor 
+{
+	static class height implements Comparable<height>
+	{
+		int h,index;
+		height(int hi,int i)
+		{
+			h=hi;
+			index=i;
+		}
+		public int compareTo(height a)
+		{
+			return this.h-a.h;
+		}
+		public String toString()
+		{
+			return ""(""+this.h+"",""+this.index+"") "";
+		}
+	}
+	static class FastReader 
+    { 
+        BufferedReader br; 
+        StringTokenizer st; 
+  
+        public FastReader() 
+        { 
+            br = new BufferedReader(new
+                     InputStreamReader(System.in)); 
+        }
+        String next() 
+        { 
+            while (st == null || !st.hasMoreElements()) 
+            { 
+                try
+                { 
+                    st = new StringTokenizer(br.readLine()); 
+                }
+                catch (IOException  e) 
+                { 
+                    e.printStackTrace(); 
+                } 
+            } 
+            return st.nextToken(); 
+        } 
+  
+        int nextInt() 
+        { 
+            return Integer.parseInt(next()); 
+        } 
+  
+        long nextLong() 
+        { 
+            return Long.parseLong(next()); 
+        } 
+  
+        double nextDouble() 
+        { 
+            return Double.parseDouble(next()); 
+        } 
+  
+        String nextLine() 
+        { 
+            String str = """"; 
+            try
+            { 
+                str = br.readLine(); 
+            } 
+            catch (IOException e) 
+            { 
+                e.printStackTrace(); 
+            } 
+            return str; 
+        } 
+    } 
+	public static void main(String[] args) 
+	{
+		FastReader sc=new FastReader();
+		int T=sc.nextInt();
+		while(T-->0)
+		{
+			int n=sc.nextInt(),m=sc.nextInt(),x=sc.nextInt(),i;
+			ArrayList<height> arr=new ArrayList<>();
+			int ans[]=new int[n];
+			PriorityQueue<height> tower=new PriorityQueue<height>();
+			for(i=0;i<n;i++)
+				arr.add(new height(sc.nextInt(),i));
+			if(n<m)
+				System.out.println(""NO"");
+			else
+			{
+				System.out.println(""YES"");
+			Collections.sort(arr,Collections.reverseOrder());
+			for(i=0;i<m;i++)
+				tower.add(new height(0,i+1));
+			for(i=0;i<n;i++)
+			{
+				//System.out.print(tower);
+				height t=tower.poll();
+				t.h=t.h+arr.get(i).h;
+				//System.out.println("" ""+t);
+				tower.add(t);
+				ans[arr.get(i).index]=t.index;
+			}
+			for(i=0;i<n;i++)
+				System.out.print(ans[i]+"" "");
+			System.out.println();
+			}
+		}
+	}
+}
+
+
+
+
+
+
+
+
+
+
+
+
+",0
+558df7d4,f0d91796,"import java.io.*;
+import java.util.*;
+public class Pupsen {
+	public static void main(String[] args) throws Exception {
+		FastIO in = new FastIO();
+		int t = in.nextInt();
+		for (int tc=0; tc<t; tc++) {
+			int n = in.nextInt();
+			int[] a = new int[n];
+			for (int i=0; i<n; i++) {
+				a[i] = in.nextInt();
+			}
+			int[] b = new int[n];
+			if (n%2==0) {
+				for (int i=0; i<n-1; i+=2) {
+					b[i] = -a[i+1];
+					b[i+1] = a[i];
+				}
+				for (int i=0; i<n; i++) System.out.print(b[i]+"" "");
+			}
+			else {
+				if (a[0]+a[1]!=0) {
+					b[0] = -a[2];
+					b[1] = -a[2];
+					b[2] = a[0]+a[1];
+				}
+				else if (a[0]+a[2]!=0) {
+					b[0] = -a[1];
+					b[2] = -a[1];
+					b[1] = a[0]+a[2];
+				}
+				else {
+					b[1] = -a[0];
+					b[2] = -a[0];
+					b[0] = a[1]+a[2];
+				}
+				for (int i=3; i<n-1; i+=2) {
+					b[i] = -a[i+1];
+					b[i+1] = a[i];
+				}
+				for (int i=0; i<n; i++) System.out.print(b[i]+"" "");
+			}
+			System.out.println();
+		}
+	}
+	static class FastIO {
+		BufferedReader br;
+	    StringTokenizer st;
+	    PrintWriter pr;
+	    public FastIO() throws IOException
+	    {
+	        br = new BufferedReader(new InputStreamReader(System.in));
+	    }
+	    
+
+	    public String next() throws IOException
+	    {
+	        while (st == null || !st.hasMoreElements()) {
+	           
+	            st = new StringTokenizer(br.readLine());
+	        }
+	        return st.nextToken();
+	    }
+
+	    public int nextInt() throws NumberFormatException, IOException { return Integer.parseInt(next()); }
+
+	    public long nextLong() throws NumberFormatException, IOException { return Long.parseLong(next()); }
+
+	    public double nextDouble() throws NumberFormatException, IOException
+	    {
+	        return Double.parseDouble(next());
+	    }
+
+	    public String nextLine() throws IOException
+	    {
+	        String str = br.readLine();
+	        return str;
+	    }
+	}
+}
+","import java.io.*;
+import java.util.*;
+ 
+public class cf {
+ 
+    public static void main(String[] args){
+ 
+        FastScanner sc = new FastScanner();
+        int t = sc.nextInt();
+        while(t-- > 0){
+ 			
+ 			int n=sc.nextInt();
+            int arr[]=new int[n];
+            for(int i=0;i<n;i++){
+                arr[i]=sc.nextInt();
+            }
+            int ans[]=new int[n];
+            if(n%2==0){
+                for(int i=0;i<n;i=i+2){
+                    ans[i]=-arr[i+1];
+                    ans[i+1]=arr[i];
+                }
+            }
+            else{
+                if(arr[0]+arr[1]!=0){
+                    ans[0]=-arr[2];
+                    ans[1]=-arr[2];
+                    ans[2]=arr[0]+arr[1];
+                }
+                else{
+                    if(arr[1]+arr[2]!=0){
+                        ans[1]=-arr[0];
+                        ans[2]=-arr[0];
+                        ans[0]=arr[1]+arr[2];
+                    }
+                    else{
+                        ans[0]=-arr[1];
+                        ans[2]=-arr[1];
+                        ans[1]=arr[0]+arr[2];
+                    }
+                }
+                for(int i=3;i<n;i=i+2){
+                    ans[i]=-arr[i+1];
+                    ans[i+1]=arr[i];
+                }
+            }
+            for(int j=0;j<n;j++){
+                System.out.print(ans[j]+"" "");
+            }
+            System.out.println();
+            
+
+            
+            
+
+            
+
+            
+           
+ 			
+
+        }	        	
+        	
+ 			
+    }
+ 
+    
+    
+    
+ 
+}
+
+//////////////////////////////////////////////////////////////
+// LCM AND GCD
+/*
+	public static int gcd(int a,int b){
+		if(b == 0){
+			return a;
+		}
+		return gcd(b,a%b);
+	}
+ 
+	public static int lcm(int a,int b){
+		 return (a / gcd(a, b)) * b;
+	}*/
+
+
+///////////////////////////////////////////////////////////////////////////////////
+
+//Iterator
+
+
+
+/*Iterator iterator = object.iterator();
+ 
+        while (iterator.hasNext()) {
+            System.out.print(iterator.next() + "" "");
+        }*/
+///////////////////////////////////////////////////////////////////////////////////
+
+
+class FastScanner
+{
+    //I don't understand how this works lmao
+    private int BS = 1 << 16;
+    private char NC = (char) 0;
+    private byte[] buf = new byte[BS];
+    private int bId = 0, size = 0;
+    private char c = NC;
+    private double cnt = 1;
+    private BufferedInputStream in;
+ 
+    public FastScanner() {
+        in = new BufferedInputStream(System.in, BS);
+    }
+ 
+    public FastScanner(String s) {
+        try {
+            in = new BufferedInputStream(new FileInputStream(new File(s)), BS);
+        } catch (Exception e) {
+            in = new BufferedInputStream(System.in, BS);
+        }
+    }
+ 
+    public char getChar() {
+        while (bId == size) {
+            try {
+                size = in.read(buf);
+            } catch (Exception e) {
+                return NC;
+            }
+            if (size == -1) return NC;
+            bId = 0;
+        }
+        return (char) buf[bId++];
+    }
+ 
+    public int nextInt() {
+        return (int) nextLong();
+    }
+ 
+    public int[] nextInts(int N) {
+        int[] res = new int[N];
+        for (int i = 0; i < N; i++) {
+            res[i] = (int) nextLong();
+        }
+        return res;
+    }
+ 
+    public long[] nextLongs(int N) {
+        long[] res = new long[N];
+        for (int i = 0; i < N; i++) {
+            res[i] = nextLong();
+        }
+        return res;
+    }
+ 
+    public long nextLong() {
+        cnt = 1;
+        boolean neg = false;
+        if (c == NC) c = getChar();
+        for (; (c < '0' || c > '9'); c = getChar()) {
+            if (c == '-') neg = true;
+        }
+        long res = 0;
+        for (; c >= '0' && c <= '9'; c = getChar()) {
+            res = (res << 3) + (res << 1) + c - '0';
+            cnt *= 10;
+        }
+        return neg ? -res : res;
+    }
+ 
+    public double nextDouble() {
+        double cur = nextLong();
+        return c != '.' ? cur : cur + nextLong() / cnt;
+    }
+ 
+    public double[] nextDoubles(int N) {
+        double[] res = new double[N];
+        for (int i = 0; i < N; i++) {
+            res[i] = nextDouble();
+        }
+        return res;
+    }
+ 
+    public String next() {
+        StringBuilder res = new StringBuilder();
+        while (c <= 32) c = getChar();
+        while (c > 32) {
+            res.append(c);
+            c = getChar();
+        }
+        return res.toString();
+    }
+ 
+    public String nextLine() {
+        StringBuilder res = new StringBuilder();
+        while (c <= 32) c = getChar();
+        while (c != '\n') {
+            res.append(c);
+            c = getChar();
+        }
+        return res.toString();
+    }
+ 
+    public boolean hasNext() {
+        if (c > 32) return true;
+        while (true) {
+            c = getChar();
+            if (c == NC) return false;
+            else if (c > 32) return true;
+        }
+    }
+}
+
+",1
+bf85ab7b,e48933fa,"
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Scanner;
+import java.io.DataInputStream;
+import java.io.FileInputStream;
+
+import java.io.IOException;
+
+public class ParsasHumongousTree {
+
+    public static void main(String args[]) throws IOException {
+        Reader scan = new Reader();
+        StringBuilder sb = new StringBuilder();
+
+        int t = scan.nextInt();
+        while (t-- > 0) {
+            int n = scan.nextInt();
+            int[] l = new int[n + 1];
+            int[] r = new int[n + 1];
+            for (int i = 1; i <= n; i++) {
+                l[i] = scan.nextInt();
+                r[i] = scan.nextInt();
+            }
+            Graph g = new Graph(n);
+            for (int i = 0; i < n - 1; i++) {
+                g.addEdge(scan.nextInt(), scan.nextInt());
+            }
+            sb.append(g.dfs(l, r) + ""\n"");
+        }
+        System.out.println(sb);
+    }
+}
+
+class Graph {
+
+    ArrayList<Integer>[] node;
+    int n;
+    int c = 0;
+    boolean[] vis;
+
+    Graph(int s) {
+        n = s + 1;
+        vis = new boolean[n + 1];
+        node = new ArrayList[n + 1];
+        for (int i = 0; i < n + 1; i++) {
+            node[i] = new ArrayList<>();
+        }
+    }
+
+    void addEdge(int u, int v) {
+
+        node[u].add(v);
+        node[v].add(u);
+        if (node[u].size() == 1) {
+            c = u;
+        }
+        if (node[v].size() == 1) {
+            c = v;
+        }
+    }
+
+    void cleanVisArray() {
+        for (int i = 0; i < n + 1; i++) {
+            vis[i] = false;
+        }
+    }
+
+    long dfs(int[] l, int[] r) {
+        cleanVisArray();
+
+        long[][] dp = new long[n][2];
+        dfsMain(1, dp, l, r);
+        return Math.max(dp[1][0], dp[1][1]);
+    }
+
+    void dfsMain(int v, long[][] dp, int[] l, int[] r) {
+        vis[v] = true;
+        for (int i : node[v]) {
+            if (!vis[i]) {
+                dfsMain(i, dp, l, r);
+                dp[v][0] += Math.max(Math.abs(l[v] - l[i]) + dp[i][0], Math.abs(l[v] - r[i]) + dp[i][1]);
+                dp[v][1] += Math.max(Math.abs(r[v] - l[i]) + dp[i][0], Math.abs(r[v] - r[i]) + dp[i][1]);
+            }
+        }
+    }
+
+}
+
+class Reader {
+
+    final private int BUFFER_SIZE = 1 << 16;
+    private DataInputStream din;
+    private byte[] buffer;
+    private int bufferPointer, bytesRead;
+
+    public Reader() {
+        din = new DataInputStream(System.in);
+        buffer = new byte[BUFFER_SIZE];
+        bufferPointer = bytesRead = 0;
+    }
+
+    public Reader(String file_name) throws IOException {
+        din = new DataInputStream(new FileInputStream(file_name));
+        buffer = new byte[BUFFER_SIZE];
+        bufferPointer = bytesRead = 0;
+    }
+
+    public String readLine() throws IOException {
+        byte[] buf = new byte[64]; // line length 
+        int cnt = 0, c;
+        while ((c = read()) != -1) {
+            if (c == '\n') {
+                break;
+            }
+            buf[cnt++] = (byte) c;
+        }
+        return new String(buf, 0, cnt);
+    }
+
+    public int nextInt() throws IOException {
+        int ret = 0;
+        byte c = read();
+        while (c <= ' ') {
+            c = read();
+        }
+        boolean neg = (c == '-');
+        if (neg) {
+            c = read();
+        }
+        do {
+            ret = ret * 10 + c - '0';
+        } while ((c = read()) >= '0' && c <= '9');
+
+        if (neg) {
+            return -ret;
+        }
+        return ret;
+    }
+
+    public long nextLong() throws IOException {
+        long ret = 0;
+        byte c = read();
+        while (c <= ' ') {
+            c = read();
+        }
+        boolean neg = (c == '-');
+        if (neg) {
+            c = read();
+        }
+        do {
+            ret = ret * 10 + c - '0';
+        } while ((c = read()) >= '0' && c <= '9');
+        if (neg) {
+            return -ret;
+        }
+        return ret;
+    }
+
+    public double nextDouble() throws IOException {
+        double ret = 0, div = 1;
+        byte c = read();
+        while (c <= ' ') {
+            c = read();
+        }
+        boolean neg = (c == '-');
+        if (neg) {
+            c = read();
+        }
+
+        do {
+            ret = ret * 10 + c - '0';
+        } while ((c = read()) >= '0' && c <= '9');
+
+        if (c == '.') {
+            while ((c = read()) >= '0' && c <= '9') {
+                ret += (c - '0') / (div *= 10);
+            }
+        }
+
+        if (neg) {
+            return -ret;
+        }
+        return ret;
+    }
+
+    private void fillBuffer() throws IOException {
+        bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
+        if (bytesRead == -1) {
+            buffer[0] = -1;
+        }
+    }
+
+    private byte read() throws IOException {
+        if (bufferPointer == bytesRead) {
+            fillBuffer();
+        }
+        return buffer[bufferPointer++];
+    }
+
+    public void close() throws IOException {
+        if (din == null) {
+            return;
+        }
+        din.close();
+    }
+}
+","import java.io.*;
+
+
+
+
+import java.util.*;
+/*
+ 
+
+
+ */
+
+
+
+
+
+ 
+ 
+ 
+ 
+ public class C {
+    static FastReader sc=null;
+   
+	public static void main(String[] args) {
+		sc=new FastReader();
+		int t=sc.nextInt();
+		while(t-->0) {
+			int n=sc.nextInt();
+			Node nodes[]=new Node[n];
+			for(int i=0;i<n;i++)nodes[i]=new Node(i,sc.nextInt(),sc.nextInt());
+			for(int i=0;i+1<n;i++) {
+				int v=sc.nextInt()-1,w=sc.nextInt()-1;
+				nodes[v].adj.add(nodes[w]);
+				nodes[w].adj.add(nodes[v]);
+			}
+			
+			dfs(nodes[0],null);
+			System.out.println(Math.max(nodes[0].right,nodes[0].left));
+		}
+		
+		
+		
+	}
+	static void dfs(Node v,Node par) {
+		for(Node nn:v.adj) {
+			if(nn!=par) {
+				dfs(nn,v);
+				v.right+=Math.max(nn.right+Math.abs(v.r-nn.r), 
+						nn.left+Math.abs(v.r-nn.l));
+				v.left+=Math.max(nn.right+Math.abs(v.l-nn.r), 
+						nn.left+Math.abs(v.l-nn.l));
+			}
+		}
+	}
+	static class Node{
+		int id;
+		long right=0,left=0;
+		int l,r;
+		ArrayList<Node> adj=new ArrayList<>();
+		
+		Node(int id,int l,int r){
+			this.id=id;
+			this.l=l;
+			this.r=r;
+		}
+	}
+	
+	
+	
+    static void ruffleSort(int a[]) {
+    	ArrayList<Integer> al=new ArrayList<>();
+    	for(int i:a)al.add(i);
+    	Collections.sort(al);
+    	for(int i=0;i<a.length;i++)a[i]=al.get(i);
+    }
+    
+    
+    static int[] reverseSort(int a[]) {
+        ArrayList<Integer> al=new ArrayList<>();
+        for(int i:a)al.add(i);
+        Collections.sort(al,Collections.reverseOrder());
+        for(int i=0;i<a.length;i++)a[i]=al.get(i);
+        return a;
+    }
+    
+    static void reverse(char a[]) {
+		int n=a.length;
+		char b[]=new char[n];
+		for(int i=0;i<n;i++)b[i]=a[n-1-i];
+		for(int i=0;i<n;i++)a[i]=b[i];
+	}
+   
+ 
+    static int gcd(int a,int b) {
+		if(b==0)return a;
+		else return gcd(b,a%b);
+	}  
+    static long gcd(long a,long b) {
+		if(b==0)return a;
+		else return gcd(b,a%b);
+	}  
+        
+ 
+    
+    
+    
+    static void print(long a[]) {
+        for(long e:a) {
+            System.out.print(e+"" "");
+        }
+        System.out.println();
+    }
+    static void print(char a[]) {
+        for(char e:a) {
+            System.out.print(e);
+        }
+        System.out.println();
+    }
+    
+    
+    static void print(int a[]) {
+        for(int e:a) {
+            System.out.print(e+"" "");
+        }
+        System.out.println();
+    }
+    
+    
+    static class FastReader 
+    { 
+        BufferedReader br; 
+        StringTokenizer st; 
+  
+        public FastReader() 
+        { 
+            br = new BufferedReader(new
+                     InputStreamReader(System.in)); 
+        } 
+  
+        String next() 
+        { 
+            while (st == null || !st.hasMoreElements()) 
+            { 
+                try
+                { 
+                    st = new StringTokenizer(br.readLine()); 
+                } 
+                catch (IOException  e) 
+                { 
+                    e.printStackTrace(); 
+                } 
+            } 
+            return st.nextToken(); 
+        } 
+  
+        int nextInt() 
+        { 
+            return Integer.parseInt(next()); 
+        } 
+  
+        long nextLong() 
+        { 
+            return Long.parseLong(next()); 
+        } 
+  
+        double nextDouble() 
+        { 
+            return Double.parseDouble(next()); 
+        } 
+  
+        String nextLine() 
+        { 
+            String str = """"; 
+            try
+            { 
+                str = br.readLine(); 
+            } 
+            catch (IOException e) 
+            { 
+                e.printStackTrace(); 
+            } 
+            return str; 
+        } 
+        int[] readArray(int n) {
+            int a[]=new int [n];
+            for(int i=0;i<n;i++) {
+                a[i]=sc.nextInt();
+            }
+            return a;
+        }
+        long[] readArrayL(int n) {
+            long a[]=new long [n];
+            for(int i=0;i<n;i++) {
+                a[i]=sc.nextLong();
+            }
+            return a;
+        }
+    } 
+}",0
+722e318f,ff1fc018,"import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.math.BigInteger;
+import java.text.DecimalFormat;
+import java.util.*;
+import java.util.concurrent.ThreadLocalRandom;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+import java.util.stream.LongStream;
+
+public class TaskB {
+
+    static long mod = 1000000007;
+    static FastScanner scanner;
+
+    static final StringBuilder result = new StringBuilder();
+
+    public static void main(String[] args) {
+        // 2 : 1000000000
+        scanner = new FastScanner();
+        int T = scanner.nextInt();
+        for (int t = 0; t < T; t++) {
+            solve(t + 1);
+            result.append(""\n"");
+        }
+        System.out.println(result);
+    }
+
+    static void solve(int t) {
+        int n = scanner.nextInt();
+        int[] a = scanner.nextIntArray(n);
+        String s = scanner.nextToken();
+
+        List<Integer> blue = new ArrayList<>();
+        List<Integer> red = new ArrayList<>();
+        for (int i = 0; i < n; i++) {
+            if (s.charAt(i) == 'B') {
+                blue.add(a[i]);
+            } else {
+                red.add(a[i]);
+            }
+        }
+        Collections.sort(blue);
+        Collections.sort(red);
+        for (int i = 0; i < blue.size(); i++) {
+            if (blue.get(i) < i + 1) {
+                result.append(""NO"");
+                return;
+            }
+        }
+        for (int i = 0; i < red.size(); i++) {
+            if (red.get(i) > i + 1 + blue.size()) {
+                result.append(""NO"");
+                return;
+            }
+        }
+        result.append(""YES"");
+    }
+
+    static class WithIdx implements Comparable<WithIdx> {
+        int val, idx;
+
+        public WithIdx(int val, int idx) {
+            this.val = val;
+            this.idx = idx;
+        }
+
+        @Override
+        public int compareTo(WithIdx o) {
+            if (val == o.val) {
+                return Integer.compare(idx, o.idx);
+            }
+            return Integer.compare(val, o.val);
+        }
+    }
+
+    public static class FastScanner {
+        BufferedReader br;
+        StringTokenizer st;
+
+        public FastScanner() {
+            br = new BufferedReader(new InputStreamReader(System.in));
+        }
+
+        String nextToken() {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    // TODO Auto-generated catch block
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        String nextLine() {
+            try {
+                return br.readLine();
+            } catch (Exception e) {
+                e.printStackTrace();
+                throw new RuntimeException();
+            }
+        }
+
+        int nextInt() {
+            return Integer.parseInt(nextToken());
+        }
+
+        long nextLong() {
+            return Long.parseLong(nextToken());
+        }
+
+        double nextDouble() {
+            return Double.parseDouble(nextToken());
+        }
+
+        int[] nextIntArray(int n) {
+            int[] res = new int[n];
+            for (int i = 0; i < n; i++) res[i] = nextInt();
+            return res;
+        }
+
+        long[] nextLongArray(int n) {
+            long[] res = new long[n];
+            for (int i = 0; i < n; i++) res[i] = nextLong();
+            return res;
+        }
+
+        String[] nextStringArray(int n) {
+            String[] res = new String[n];
+            for (int i = 0; i < n; i++) res[i] = nextToken();
+            return res;
+        }
+    }
+
+    static class PrefixSums {
+        long[] sums;
+
+        public PrefixSums(long[] sums) {
+            this.sums = sums;
+        }
+
+        public long sum(int fromInclusive, int toExclusive) {
+            if (fromInclusive > toExclusive) throw new IllegalArgumentException(""Wrong value"");
+            return sums[toExclusive] - sums[fromInclusive];
+        }
+
+        public static PrefixSums of(int[] ar) {
+            long[] sums = new long[ar.length + 1];
+            for (int i = 1; i <= ar.length; i++) {
+                sums[i] = sums[i - 1] + ar[i - 1];
+            }
+            return new PrefixSums(sums);
+        }
+
+        public static PrefixSums of(long[] ar) {
+            long[] sums = new long[ar.length + 1];
+            for (int i = 1; i <= ar.length; i++) {
+                sums[i] = sums[i - 1] + ar[i - 1];
+            }
+            return new PrefixSums(sums);
+        }
+    }
+
+    static class ADUtils {
+        static void sort(int[] ar) {
+            Random rnd = ThreadLocalRandom.current();
+            for (int i = ar.length - 1; i > 0; i--) {
+                int index = rnd.nextInt(i + 1);
+                // Simple swap
+                int a = ar[index];
+                ar[index] = ar[i];
+                ar[i] = a;
+            }
+            Arrays.sort(ar);
+        }
+
+        static void reverse(int[] arr) {
+            int last = arr.length / 2;
+            for (int i = 0; i < last; i++) {
+                int tmp = arr[i];
+                arr[i] = arr[arr.length - 1 - i];
+                arr[arr.length - 1 - i] = tmp;
+            }
+        }
+
+        static void sort(long[] ar) {
+            Random rnd = ThreadLocalRandom.current();
+            for (int i = ar.length - 1; i > 0; i--) {
+                int index = rnd.nextInt(i + 1);
+                // Simple swap
+                long a = ar[index];
+                ar[index] = ar[i];
+                ar[i] = a;
+            }
+            Arrays.sort(ar);
+        }
+    }
+
+    static class MathUtils {
+        static long[] FIRST_PRIMES = {
+                2, 3, 5, 7, 11, 13, 17, 19, 23, 29,
+                31, 37, 41, 43, 47, 53, 59, 61, 67, 71,
+                73, 79, 83, 89, 97, 101, 103, 107, 109, 113,
+                127, 131, 137, 139, 149, 151, 157, 163, 167, 173,
+                179, 181, 191, 193, 197, 199, 211, 223, 227, 229,
+                233, 239, 241, 251, 257, 263, 269, 271, 277, 281,
+                283, 293, 307, 311, 313, 317, 331, 337, 347, 349,
+                353, 359, 367, 373, 379, 383, 389, 397, 401, 409,
+                419, 421, 431, 433, 439, 443, 449, 457, 461, 463,
+                467, 479, 487, 491, 499, 503, 509, 521, 523, 541,
+                547, 557, 563, 569, 571, 577, 587, 593, 599, 601,
+                607, 613, 617, 619, 631, 641, 643, 647, 653, 659,
+                661, 673, 677, 683, 691, 701, 709, 719, 727, 733,
+                739, 743, 751, 757, 761, 769, 773, 787, 797, 809,
+                811, 821, 823, 827, 829, 839, 853, 857, 859, 863,
+                877, 881, 883, 887, 907, 911, 919, 929, 937, 941,
+                947, 953, 967, 971, 977, 983, 991, 997, 1009, 1013,
+                1019, 1021, 1031, 1033, 1039, 1049, 1051};
+
+        static long[] primes(int to) {
+            long[] all = new long[to + 1];
+            long[] primes = new long[to + 1];
+            all[1] = 1;
+            int primesLength = 0;
+            for (int i = 2; i <= to; i++) {
+                if (all[i] == 0) {
+                    primes[primesLength++] = i;
+                    all[i] = i;
+                }
+                for (int j = 0; j < primesLength && i * primes[j] <= to && all[i] >= primes[j];
+                        j++) {
+                    all[(int) (i * primes[j])] = primes[j];
+                }
+            }
+            return Arrays.copyOf(primes, primesLength);
+        }
+
+        static long modpow(long b, long e, long m) {
+            long result = 1;
+
+            while (e > 0) {
+                if ((e & 1) == 1) {
+                    /* multiply in this bit's contribution while using modulus to keep
+                     * result small */
+                    result = (result * b) % m;
+                }
+                b = (b * b) % m;
+                e >>= 1;
+            }
+
+            return result;
+        }
+
+        static long submod(long x, long y, long m) {
+            return (x - y + m) % m;
+        }
+
+        static long modInverse(long a, long m) {
+            long g = gcdF(a, m);
+            if (g != 1) {
+                throw new IllegalArgumentException(""Inverse doesn't exist"");
+            } else {
+                // If a and m are relatively prime, then modulo
+                // inverse is a^(m-2) mode m
+                return modpow(a, m - 2, m);
+            }
+        }
+
+        static public long gcdF(long a, long b) {
+            while (b != 0) {
+                long na = b;
+                long nb = a % b;
+                a = na;
+                b = nb;
+            }
+            return a;
+        }
+    }
+}
+
+/*
+5
+3 2 3 8 8
+2 8 5 10 1
+
+ */","import java.util.*;
+
+public class mentor1 {
+    public static boolean solve(int n, String color, int[] arr){
+        List<Integer> Barr = new ArrayList<Integer>();
+        List<Integer> Rarr = new ArrayList<Integer>();
+        for (int i = 0; i < n; i++) {
+            if(color.charAt(i) == 'B')Barr.add(arr[i]);
+            else Rarr.add(arr[i]);
+        }
+        Barr.sort(Comparator.naturalOrder());
+        Rarr.sort(Comparator.reverseOrder());
+        for (int i = 0; i < Barr.size(); i++) {
+            if(Barr.get(i)< i + 1)return false;
+        }
+        for (int i = 0; i < Rarr.size(); i++) {
+            int expect = n-i;
+            if(Rarr.get(i) > expect)return false;
+        }
+        return true;
+    }
+    public static void main(String[] args) {
+        Scanner input = new Scanner(System.in);
+        int n = input.nextInt();
+        for (int i = 0; i < n; i++) {
+            int m = input.nextInt();
+            int[] arr = new int[m];
+            for(int j = 0;j<m; j++)arr[j] = input.nextInt();
+            String color = input.next();
+            if(solve(m,color,arr)) System.out.println(""YES"");
+            else System.out.println(""NO"");
+        }
+    }
+}
+",0
+16857116,e185bce5,"import javax.swing.plaf.IconUIResource;
+import java.lang.reflect.Array;
+import java.text.CollationElementIterator;
+import java.util.*;
+import java.io.*;
+
+//Timus judge id- 323935JJ
+
+
+public class Main {
+
+
+
+
+    //----------------------------------------------------------------------------------------------
+    public static class Pair implements Comparable<Pair> {
+        int x=0,y=0;
+        int z=0;
+        public Pair(int a, int b) {
+            this.x=a;
+            this.y=b;
+
+        }
+
+        public int compareTo(Pair o) {
+            return this.x - o.x;
+        }
+    }
+
+
+    public static int mod = (int) (1e9 + 7);
+    static int ans = Integer.MAX_VALUE;
+
+    public static void main(String hi[]) throws Exception {
+        FastReader sc = new FastReader();
+        int t =sc.nextInt();
+        while(t-->0)
+        {
+            int n =sc.nextInt();
+            String a = sc.nextLine(),b=sc.nextLine();
+
+            int count1=0,count2=0,count3=0,count4=0;
+
+            for(int i=0;i<n;i++)
+            {
+                if(a.charAt(i)=='0'&&b.charAt(i)=='0')
+                    count1++;
+                else  if(a.charAt(i)=='1'&&b.charAt(i)=='1')
+                    count2++;
+                else  if(a.charAt(i)=='1'&&b.charAt(i)=='0')
+                    count3++;
+                else  if(a.charAt(i)=='0'&&b.charAt(i)=='1')
+                    count4++;
+            }
+            int ans=Integer.MAX_VALUE;
+
+            if(count3==count4)
+                ans=Math.min(count3*2,ans);
+
+            if(count2==count1+1)
+                ans=Math.min(ans,2*count1+1);
+
+            if(count2==1&&count1==0)
+                ans=1;
+            if(count3==0&&count4==0)
+                ans=0;
+            if(ans==Integer.MAX_VALUE)
+                System.out.println(-1);
+            else System.out.println(ans);
+
+        }
+
+    }
+
+    static int find(int[] a,int x)
+    {
+        if(a[x]==-1)
+            return x;
+        else return find(a,a[x]);
+    }
+
+
+
+
+
+    static int gcd(int a, int b)
+    {
+        if (a == 0)
+            return b;
+        return gcd(b % a, a);
+    }
+
+    // method to return LCM of two numbers
+    static int lcm(int a, int b)
+    {
+        return (a / gcd(a, b)) * b;
+    }
+
+
+    static long gcdl(long a, long b)
+    {
+        if (a == 0)
+            return b;
+        return gcdl(b % a, a);
+    }
+
+    // method to return LCM of two numbers
+    static long lcml(long a, long b)
+    {
+        return (a / gcdl(a, b)) * b;
+    }
+
+
+    static class FastReader {
+        BufferedReader br;
+        StringTokenizer st;
+
+        public FastReader() {
+            br = new BufferedReader(new
+                    InputStreamReader(System.in));
+        }
+
+        String next() {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+
+        String nextLine() {
+            String str = """";
+            try {
+                str = br.readLine();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+
+        }
+    }
+}
+
+","
+import java.util.*;
+
+import java.io.*;
+import java.math.BigInteger;
+import java.nio.charset.StandardCharsets;
+	
+public class Main {
+		private static FS sc = new FS();
+		
+		private static class FS {
+			BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+			StringTokenizer st = new StringTokenizer("""");
+			String next() {
+				while (!st.hasMoreTokens())
+					try {
+						st=new StringTokenizer(br.readLine());				               
+		            } catch (IOException e) {}
+				return st.nextToken();
+			}
+			
+			int nextInt() {
+				return Integer.parseInt(next());
+			}
+			long nextLong() {
+				return Long.parseLong(next());
+			}
+		}
+		
+		private static class extra {
+			
+			static int[] intArr(int size) {
+				int[] a = new int[size];
+				for(int i = 0; i < size; i++) a[i] = sc.nextInt();
+				return a;
+			}
+			
+			static long[] longArr(int size) {
+				Scanner scc = new Scanner(System.in);
+				long[] a = new long[size];
+				for(int i = 0; i < size; i++) a[i] = sc.nextLong();
+				return a;
+			}
+			
+			static long intSum(int[] a) {
+				long sum = 0; 
+				for(int i = 0; i < a.length; i++) {
+					sum += a[i];
+				}
+				return sum;
+			}
+			
+			static long longSum(long[] a) {
+				long sum = 0; 
+				for(int i = 0; i < a.length; i++) {
+					sum += a[i];
+				}
+				return sum;
+			}
+			
+			static LinkedList[] graphD(int vertices, int edges) {
+				LinkedList<Integer>[] temp = new LinkedList[vertices+1];
+				for(int i = 0; i <= vertices; i++) temp[i] = new LinkedList<>();
+				for(int i = 0; i < edges; i++) {
+					int x = sc.nextInt();
+					int y = sc.nextInt();
+					temp[x].add(y);
+				}
+				return temp;
+			}
+			
+			static LinkedList[] graphUD(int vertices, int edges) {
+				LinkedList<Integer>[] temp = new LinkedList[vertices+1];
+				for(int i = 0; i <= vertices; i++) temp[i] = new LinkedList<>();
+				for(int i = 0; i < edges; i++) {
+					int x = sc.nextInt();
+					int y = sc.nextInt();
+					temp[x].add(y);
+					temp[y].add(x);
+				}
+				return temp;
+			}
+			
+			static void printG(LinkedList[] temp) { for(LinkedList<Integer> aa:temp) System.out.println(aa); }
+			
+			static long cal(long val, long pow, long mod) {
+				if(pow == 0) return 1;
+				long res = cal(val, pow/2, mod);
+				
+				long ret = (res*res)%mod;
+				if(pow%2 == 0) return ret;
+				return (val*ret)%mod;
+			}
+			
+			static long gcd(long a, long b) { return b == 0 ? a:gcd(b, a%b); }
+			
+		}
+		
+		static int mod = (int) 1e9;
+		
+		static LinkedList<Integer>[] temp, idx;
+		static long inf = (long) Long.MAX_VALUE;
+//		static long inf = Long.MAX_VALUE;
+//		static int max;
+		
+		public static void main(String[] args) { 
+			int t = sc.nextInt();
+//			int t = 1;
+			StringBuilder ret = new StringBuilder();
+			while(t-- > 0) {
+				int n = sc.nextInt();
+				String a = sc.next(), b = sc.next();
+				int _00 = 0, _01 = 0, _10 = 0, _11 = 0;
+				for(int i = 0; i < n; i++) {
+					if(a.charAt(i) == '0' && b.charAt(i) == '0') _00++;
+					if(a.charAt(i) == '0' && b.charAt(i) == '1') _01++;
+					if(a.charAt(i) == '1' && b.charAt(i) == '0') _10++;
+					if(a.charAt(i) == '1' && b.charAt(i) == '1') _11++;
+				}
+				int ans = Integer.MAX_VALUE;
+				if(_10 == _01) ans = _01 + _10;
+				if(_10 > 0) {
+					int n00 = _10 - 1;
+		            int n01 = _11;
+		            int n10 = _00 + 1;
+		            int n11 = _01;
+		            if (n01 == n10) {
+		                ans = Math.min(ans, 1 + n01 + n10);
+		            }
+				}
+				if(_11 > 0) {
+					int n00 = _10;
+		            int n01 = _11 - 1;
+		            int n10 = _00;
+		            int n11 = _01 + 1;
+		            if (n01 == n10) {
+		                ans = Math.min(ans, 1 + n01 + n10);
+		            }
+				}
+				ret.append(ans == Integer.MAX_VALUE ? -1 : ans);
+				ret.append(""\n"");
+			}
+			System.out.println(ret);
+		}
+
+	}
+
+	
+	
+
+
+	
+	
+	
+",0
+1dab88fb,7b5f64b7,"import java.util.*;
+
+public class Main
+{
+    static class Edge{
+        public int node;
+        public int index;
+        public Edge(int n, int i){
+            node=n;
+            index=i;
+        }
+    }
+    static Scanner sc=new Scanner(System.in);
+	public static void main(String[] args) {
+	    
+	    int test=sc.nextInt();
+	    while(test-->0){
+	        
+	        solve();
+	    }
+	}
+	
+	static void solve(){
+	    int n=sc.nextInt();
+	        ArrayList<ArrayList<Edge>> graph= new ArrayList<ArrayList<Edge>>();
+	        for(int i=0;i<n;i++){
+	            graph.add(new ArrayList<>());
+	        }
+	        for (int i = 0; i < n - 1; i++) {
+	            int u = sc.nextInt();
+	            int v = sc.nextInt();
+	            u--; v--;
+	            
+	            graph.get(u).add(new Edge(v, i));
+	            graph.get(v).add(new Edge(u, i));
+            }
+            
+            int start = 0;
+            for (int i = 0; i < n; i++) {
+                if (graph.get(i).size() > 2) {
+                    System.out.println(""-1"");
+                    return;
+                } else if (graph.get(i).size() == 1) {
+                    start = i;
+                }
+            }
+            int[] weight = new int[n - 1];
+            
+            int prevNode = -1;
+            int curNode = start;
+            int curWeight = 2;
+            
+            while (true) {
+                ArrayList<Edge> edges = graph.get(curNode);
+                Edge next = edges.get(0);
+                
+                if (next.node == prevNode) {
+                    if (edges.size() == 1) {
+                        break;
+                    } else {
+                        next = edges.get(1);
+                    }
+                }
+                weight[next.index] = curWeight;
+                
+                prevNode = curNode;
+                curNode = next.node;
+                curWeight = 5 - curWeight;
+            }
+            for (int i = 0; i < n - 1; i++) {
+                System.out.print(weight[i]);
+                System.out.print("" "");
+            }
+            System.out.println();
+	}
+}
+","import java.util.*;
+import java.io.*;
+
+public class Main {
+	static class FastReader {
+		BufferedReader br;
+		StringTokenizer st;
+
+		public FastReader() {
+			br = new BufferedReader(new InputStreamReader(System.in));
+		}
+
+		String next() {
+			while (st == null || !st.hasMoreElements()) {
+				try {
+					st = new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			}
+			return st.nextToken();
+		}
+
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+
+		double nextDouble() {
+			return Double.parseDouble(next());
+		}
+
+		String nextLine() {
+			String str = """";
+			try {
+				str = br.readLine();
+			} catch (IOException e) {
+				e.printStackTrace();
+			}
+			return str;
+		}
+	}
+
+	public static FastReader obj = new FastReader();
+	public static PrintWriter out = new PrintWriter(System.out);
+
+	public static void sort(long[] a) {
+		ArrayList<Long> arr = new ArrayList<>();
+		for (int i = 0; i < a.length; i++)
+			arr.add(a[i]);
+		Collections.sort(arr);
+		for (int i = 0; i < arr.size(); i++)
+			a[i] = arr.get(i);
+	}
+
+	public static void revsort(long[] a) {
+		ArrayList<Long> arr = new ArrayList<>();
+		for (int i = 0; i < a.length; i++)
+			arr.add(a[i]);
+		Collections.sort(arr, Collections.reverseOrder());
+		for (int i = 0; i < arr.size(); i++)
+			a[i] = arr.get(i);
+	}
+
+	//Cover the small test cases like for n=1 .
+	public static class pair {
+		int a;
+		int b;
+
+		pair(int  x, int y) {
+			a = x;
+			b = y;
+		}
+	}
+
+	public static long l() {
+		return obj.nextLong();
+	}
+
+	public static int i() {
+		return obj.nextInt();
+	}
+
+	public static String s() {
+		return obj.next();
+	}
+
+	public static long[] l(int n) {
+		long[] arr = new long[n];
+		for (int i = 0; i < n; i++)
+			arr[i] = l();
+		return arr;
+	}
+
+	public static int[] i(int n) {
+		int[] arr = new int[n];
+		for (int i = 0; i < n; i++)
+			arr[i] = i();
+		return arr;
+	}
+
+	public static long ceil(long a, long b) {
+		return (a + b - 1) / b;
+	}
+
+	public static void p(long val) {
+		out.println(val);
+	}
+
+	public static void p(String s) {
+		out.println(s);
+	}
+
+	public static void pl(long[] arr) {
+		for (int i = 0; i < arr.length; i++) {
+			out.print(arr[i] + "" "");
+		}
+		out.println();
+	}
+
+	public static void p(int[] arr) {
+		for (int i = 0; i < arr.length; i++) {
+			out.print(arr[i] + "" "");
+		}
+		out.println();
+	}
+
+	public static void sortpair(ArrayList<pair> arr) {
+		//ascending just change return 1 to return -1 and vice versa to get descending.
+		//compare based on value of pair.a
+		arr.sort(new Comparator<pair>() {
+			public int compare(pair o1, pair o2) {
+				long val = o1.a - o2.a;
+				if (val == 0)
+					return 0;
+				else if (val > 0)
+					return 1;
+				else
+					return -1;
+			}
+		});
+	}
+
+	// Take of the small test cases such as when n=1,2 etc.
+	// remember in case of fenwick tree ft is 1 based but our array should be 0 based.
+	// in fenwick tree when we update some index it doesn't change the value to val but it
+	// adds the val value in it so remember to add val-a[i] instead of just adding val.
+	//in case of finding the inverse mod do it (biexpo(a,mod-2)%mod + mod )%mod
+    public static ArrayList<ArrayList<pair>> adj;
+    public static int[] ans;
+	public static void main(String[] args) {
+
+		int len = i();
+		while (len-- != 0) {
+			int n = i();
+			adj=new ArrayList<>(n+1);
+			ans=new int[n];
+			int ok=0;
+			for(int i=0;i<=n;i++)adj.add(new ArrayList<>());
+			for(int i=0;i<n-1;i++)
+			{
+				int a=obj.nextInt();
+				int b=obj.nextInt();
+				adj.get(a).add(new pair(b,i));
+				adj.get(b).add(new pair(a,i));
+				if(adj.get(a).size()>2)ok=1;
+				if(adj.get(b).size()>2)ok=1;
+			}
+			if(ok==1)out.println(-1);
+			else
+			{
+				int[] vis=new int[n+1];
+				if(adj.get(1).size()==2)
+				{
+					vis[adj.get(1).get(1).a]=1;
+					dfs(1,vis,11);
+					vis[adj.get(1).get(1).a]=0;
+					vis[1]=0;
+					dfs(1,vis,2);
+				}
+				else
+				{
+					dfs(1,vis,11);
+				}
+				for(int i=0;i<n-1;i++)out.print(ans[i]+"" "");
+				out.println();
+			}
+		}
+		out.flush();
+	}
+	public static void dfs(int cur,int[] vis,int c)
+	{
+		vis[cur]=1;
+		for(pair nd:adj.get(cur))
+		{
+			if(vis[nd.a]==1)continue;
+			if(c==2)ans[nd.b]=11;
+			else ans[nd.b]=2;
+			dfs(nd.a,vis,ans[nd.b]);
+		}
+	}
+}",0
+680ba922,ee4b9467,"import java.util.*;
+import java.io.*;
+
+public class Solution
+{
+    static class Reader {
+        final private int BUFFER_SIZE = 1 << 16;
+        private DataInputStream din;
+        private byte[] buffer;
+        private int bufferPointer, bytesRead;
+ 
+        public Reader()
+        {
+            din = new DataInputStream(System.in);
+            buffer = new byte[BUFFER_SIZE];
+            bufferPointer = bytesRead = 0;
+        }
+ 
+        public Reader(String file_name) throws IOException
+        {
+            din = new DataInputStream(
+                new FileInputStream(file_name));
+            buffer = new byte[BUFFER_SIZE];
+            bufferPointer = bytesRead = 0;
+        }
+ 
+        public String readLine() throws IOException
+        {
+            byte[] buf = new byte[64]; // line length
+            int cnt = 0, c;
+            while ((c = read()) != -1) {
+                if (c == '\n') {
+                    if (cnt != 0) {
+                        break;
+                    }
+                    else {
+                        continue;
+                    }
+                }
+                buf[cnt++] = (byte)c;
+            }
+            return new String(buf, 0, cnt);
+        }
+ 
+        public int nextInt() throws IOException
+        {
+            int ret = 0;
+            byte c = read();
+            while (c <= ' ') {
+                c = read();
+            }
+            boolean neg = (c == '-');
+            if (neg)
+                c = read();
+            do {
+                ret = ret * 10 + c - '0';
+            } while ((c = read()) >= '0' && c <= '9');
+ 
+            if (neg)
+                return -ret;
+            return ret;
+        }
+ 
+        public long nextLong() throws IOException
+        {
+            long ret = 0;
+            byte c = read();
+            while (c <= ' ')
+                c = read();
+            boolean neg = (c == '-');
+            if (neg)
+                c = read();
+            do {
+                ret = ret * 10 + c - '0';
+            } while ((c = read()) >= '0' && c <= '9');
+            if (neg)
+                return -ret;
+            return ret;
+        }
+ 
+        public double nextDouble() throws IOException
+        {
+            double ret = 0, div = 1;
+            byte c = read();
+            while (c <= ' ')
+                c = read();
+            boolean neg = (c == '-');
+            if (neg)
+                c = read();
+ 
+            do {
+                ret = ret * 10 + c - '0';
+            } while ((c = read()) >= '0' && c <= '9');
+ 
+            if (c == '.') {
+                while ((c = read()) >= '0' && c <= '9') {
+                    ret += (c - '0') / (div *= 10);
+                }
+            }
+ 
+            if (neg)
+                return -ret;
+            return ret;
+        }
+ 
+        private void fillBuffer() throws IOException
+        {
+            bytesRead = din.read(buffer, bufferPointer = 0,
+                                 BUFFER_SIZE);
+            if (bytesRead == -1)
+                buffer[0] = -1;
+        }
+ 
+        private byte read() throws IOException
+        {
+            if (bufferPointer == bytesRead)
+                fillBuffer();
+            return buffer[bufferPointer++];
+        }
+ 
+        public void close() throws IOException
+        {
+            if (din == null)
+                return;
+            din.close();
+        }
+    }
+    
+   
+  static int parent(int a , int p[])
+  {
+      if(a == p[a])
+      return a;
+      
+      return p[a] = parent(p[a],p);
+  }
+  
+  static void union(int a , int b , int p[] , int size[])
+  {
+      a = parent(a,p);
+      b = parent(b,p);
+      
+      if(a == b)
+      return;
+      
+      if(size[a] < size[b])
+      {
+          int temp = a;
+          a = b;
+          b = temp;
+      }
+      
+      p[b] = a;
+      size[a] += size[b];
+  }
+  
+  
+  
+  
+ static long getSum(int index , long BITree[])
+    {
+        long sum = 0; // Iniialize result
+      
+        // index in BITree[] is 1 more than
+        // the index in arr[]
+       // index = index + 1;
+      
+        // Traverse ancestors of BITree[index]
+        while(index>0)
+        {
+            // Add current element of BITree 
+            // to sum
+            sum += BITree[index];
+      
+            // Move index to parent node in 
+            // getSum View
+            index -= index & (-index);
+        }
+        return sum;
+    }
+  
+    // Updates a node in Binary Index Tree (BITree)
+    // at given index in BITree. The given value 
+    // 'val' is added to BITree[i] and all of 
+    // its ancestors in tree.
+    public static void updateBIT(int n, int index, 
+                                        long val , long BITree[])
+    {
+        // index in BITree[] is 1 more than 
+        // the index in arr[]
+      //  index = index + 1;
+      
+        // Traverse all ancestors and add 'val'
+        while(index <= n)
+        {
+        // Add 'val' to current node of BIT Tree
+        BITree[index] += val;
+      
+        // Update index to that of parent 
+        // in update View
+        index += index & (-index);
+        }
+    }
+    
+    
+   static int gcd(int a, int b)
+{
+    if (a == 0)
+        return b;
+    return gcd(b % a, a);
+}
+
+static int dp[][];
+
+
+static int f(int pos , int take , int arr[])
+{
+    if(pos == -1)
+    {
+        if(take == 0)
+    return 0;
+    
+    return -10000000;
+    
+    }
+    
+    
+    if(dp[pos][take] != -1)
+    return dp[pos][take];
+    
+    
+    if(pos+1-take == arr[pos])
+    dp[pos][take] = Math.max(dp[pos][take],1 + f(pos-1,take,arr));
+    
+    
+    dp[pos][take] = Math.max(dp[pos][take],f(pos-1,take,arr));
+    
+    
+    if(take > 0)
+    dp[pos][take] = Math.max(dp[pos][take],f(pos-1,take-1,arr));
+    
+    return dp[pos][take];
+}
+    public static void main(String []args) throws IOException
+    {
+        Scanner sc = new Scanner(System.in);
+        int t = sc.nextInt();
+        while(t-- > 0)
+        {
+            int n = sc.nextInt();
+            sc.nextLine();
+            String a = sc.nextLine();
+            String b = sc.nextLine();
+            int same = 0 , zo = 0 , oz = 0 , oo = 0 , zz = 0;
+            for(int i = 0 ; i < n ; i++)
+            {
+                if(a.charAt(i) == '0' && b.charAt(i) == '1')
+                oz++;
+                
+                else if(a.charAt(i) == '1' && b.charAt(i) == '0')
+                zo++;
+                
+                else if(a.charAt(i) == '1' && b.charAt(i) == '1')
+                oo++;
+                
+                else
+                zz++;
+            }
+            
+            if(oz == zo || (zz == oo-1))
+            {
+                int mx = Integer.MAX_VALUE;
+                if(oz == zo)
+                mx = Math.min(mx,2*oz);
+                
+                if(oo-1 == zz)
+                mx = Math.min(mx,zz+oo);
+                
+                System.out.println(mx);
+            }
+            
+            else
+            {
+                System.out.println(-1);
+            }
+        }
+    }
+}","import java.io.*;
+import java.util.*;
+ 
+public class _1615c {
+    FastScanner scn;
+    PrintWriter w;
+    PrintStream fs;
+
+    long MOD = 1000000007;
+    int MAX = 200005;
+    long mul(long x, long y) {long res = x * y; return (res >= MOD ? res % MOD : res);}
+    long power(long x, long y) {if (y < 0) return 1; long res = 1; x %= MOD; while (y!=0) {if ((y & 1)==1)res = mul(res, x); y >>= 1; x = mul(x, x);} return res;}
+    void ruffleSort(int[] a) {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);}
+    void reverseSort(int[] arr){List<Integer> list = new ArrayList<>();for (int i=0; i<arr.length; i++){list.add(arr[i]);}Collections.sort(list, Collections.reverseOrder());for (int i = 0; i < arr.length; i++){arr[i] = list.get(i);}}
+    boolean LOCAL;
+    void debug(Object... o){if(LOCAL)System.err.println(Arrays.deepToString(o));}
+    //SUFFICIENT DRY RUN????LOGIC VERIFIED FOR ALL TEST CASES???
+    
+    void solve(){
+        
+        int t=scn.nextInt();
+            while(t-->0)
+            {
+                int n=scn.nextInt();
+                String s1= scn.next();
+                String s2 = scn.next();
+
+                int op1=0,op0=0,one=0,zr=0;
+                for(int i=0;i<n;i++){
+                    char ch1 = s1.charAt(i);
+                    char ch2 = s2.charAt(i);
+                    
+                    if(ch1=='1'&&ch2=='0'){
+                        op1++;
+                    }else if(ch1=='0'&&ch2=='1'){
+                        op0++;
+                    }else if(ch1==ch2){
+                        if(ch1=='0'){
+                            zr++;
+                        }else{
+                            one++;
+                        }
+                    }
+                }
+                
+                if((one-zr)==1&&op1==op0){
+                    w.println(Math.min(2*op1,one+zr));
+                }else if((one-zr)==1){
+                    w.println(one+zr);
+                }else if(op1==op0){
+                    w.println(2*op1);
+                }else{
+                    w.println(-1);
+                }
+            
+            
+            }
+        
+    }
+ 
+    void run() {
+        try {
+            long ct = System.currentTimeMillis();
+            scn = new FastScanner(new File(""input.txt""));
+            w = new PrintWriter(new File(""output.txt""));
+            fs=new PrintStream(""error.txt"");
+            System.setErr(fs);
+            LOCAL=true;
+ 
+            solve();
+ 
+            w.close();
+            System.err.println(System.currentTimeMillis() - ct);
+        } catch (FileNotFoundException e) {
+            e.printStackTrace();
+        }
+    }
+ 
+    void runIO() {
+ 
+        scn = new FastScanner(System.in);
+        w = new PrintWriter(System.out);
+        LOCAL=false;
+ 
+        solve();
+ 
+        w.close();
+    }
+ 
+    class FastScanner {
+        BufferedReader br;
+        StringTokenizer st;
+ 
+        public FastScanner(File f) {
+            try {
+                br = new BufferedReader(new FileReader(f));
+            } catch (FileNotFoundException e) {
+                e.printStackTrace();
+            }
+        }
+ 
+        public FastScanner(InputStream f) {
+            br = new BufferedReader(new InputStreamReader(f));
+        }
+ 
+        String next() {
+            while (st == null || !st.hasMoreTokens()) {
+                String s = null;
+                try {
+                    s = br.readLine();
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+                if (s == null)
+                    return null;
+                st = new StringTokenizer(s);
+            }
+            return st.nextToken();
+        }
+ 
+        boolean hasMoreTokens() {
+            while (st == null || !st.hasMoreTokens()) {
+                String s = null;
+                try {
+                    s = br.readLine();
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+                if (s == null)
+                    return false;
+                st = new StringTokenizer(s);
+            }
+            return true;
+        }
+ 
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+        
+        int[] nextIntArray(int n) {
+            int a[] = new int[n];
+            for (int i = 0; i < n; i++) {
+                a[i] = nextInt();
+            }
+            return a;
+        }
+
+        long[] nextLongArray(int n) {
+            long a[] = new long[n];
+            for (int i = 0; i < n; i++) {
+                a[i] = nextLong();
+            }
+            return a;
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+ 
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+    }
+ 
+    int lowerBound(int[] arr, int x){int n = arr.length, si = 0, ei = n - 1;while(si <= ei){int mid = si + (ei - si)/2;if(arr[mid] == x){if(mid-1 >= 0 && arr[mid-1] == arr[mid]){ei = mid-1;}else{return mid;}}else if(arr[mid] > x){ei = mid - 1; }else{si = mid+1;}}return si; }
+    int upperBound(int[] arr, int x){int n = arr.length, si = 0, ei = n - 1;while(si <= ei){int mid = si + (ei - si)/2;if(arr[mid] == x){if(mid+1 < n && arr[mid+1] == arr[mid]){si = mid+1;}else{return mid + 1;}}else if(arr[mid] > x){ei = mid - 1; }else{si = mid+1;}}return si; }
+    int upperBound(ArrayList<Integer> list, int x){int n = list.size(), si = 0, ei = n - 1;while(si <= ei){int mid = si + (ei - si)/2;if(list.get(mid) == x){if(mid+1 < n && list.get(mid+1) == list.get(mid)){si = mid+1;}else{return mid + 1;}}else if(list.get(mid) > x){ei = mid - 1; }else{si = mid+1;}}return si; }
+    void swap(int[] arr, int i, int j){int temp = arr[i];arr[i] = arr[j];arr[j] = temp;}
+    long nextPowerOf2(long v){if (v == 0) return 1;v--;v |= v >> 1;v |= v >> 2;v |= v >> 4;v |= v >> 8;v |= v >> 16;v |= v >> 32;v++;return v;}
+    int gcd(int a, int b) {if(a == 0){return b;}return gcd(b%a, a);} // TC- O(logmax(a,b))
+    boolean nextPermutation(int[] arr) {if(arr == null || arr.length <= 1){return false;}int last = arr.length-2;while(last >= 0){if(arr[last] < arr[last+1]){break;}last--;}if (last < 0){return false;}if(last >= 0){int nextGreater = arr.length-1;for(int i=arr.length-1; i>last; i--){if(arr[i] > arr[last]){nextGreater = i;break;}}swap(arr, last, nextGreater);}int i = last + 1, j = arr.length - 1;while(i < j){swap(arr, i++, j--);}return true;}
+ 
+    public static void main(String[] args) {
+        new _1615c().runIO();
+    }
+}
+
+",0
+0c1143f7,960a4c0f,"import java.io.*;
+import java.util.*;
+
+public class E {
+
+	public static void main(String[] args) {
+		// TODO Auto-generated method stub
+			FastScanner sc = new FastScanner();
+			
+			int t = sc.nextInt();
+			
+			while(t-- > 0) {
+				
+				int n = sc.nextInt();
+				int[] a = new int[n];
+				
+				for(int i = 0 ; i< n ; i++) {
+					a[i] = sc.nextInt();
+				}
+				long oddMin = a[1];
+				long evenMin = a[0];
+				long res = (n * oddMin) + (n * evenMin);
+				long oddSum = a[1];
+				long evenSum = a[0];
+				
+				for(int i = 2 ;i < n ; i++) {
+					
+					if(i % 2 == 1) {
+						oddSum += a[i];
+						oddMin = Math.min(oddMin, a[i]);
+					}
+					else {
+						evenSum += a[i];
+						evenMin = Math.min(evenMin, a[i]);
+					}
+					
+					int odd = (i + 1) / 2;
+					int even = (i / 2) + 1;
+					
+					long minCostOdd = oddSum + oddMin*(n - odd);
+					long minCostEven = evenSum + evenMin*(n - even);
+					
+					res = Math.min(res, minCostOdd + minCostEven);
+				}
+				
+				System.out.println(res);
+			}
+			
+			
+			
+			
+
+	}
+	
+	static class FastScanner {
+		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st=new StringTokenizer("""");
+		String next() {
+			while (!st.hasMoreTokens())
+				try {
+					st=new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			return st.nextToken();
+		}
+		
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+		int[] readArray(int n) {
+			int[] a=new int[n];
+			for (int i=0; i<n; i++) a[i]=nextInt();
+			return a;
+		}
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+	}
+	
+	// Use this instead of Arrays.sort() on an array of ints. Arrays.sort() is n^2
+		// worst case since it uses a version of quicksort. Although this would never
+		// actually show up in the real world, in codeforces, people can hack, so
+		// this is needed.
+		static void ruffleSort(int[] a) {
+			//ruffle
+			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;
+			}
+			
+			//then sort
+			Arrays.sort(a);
+		}
+
+}
+","
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.Arrays;
+import java.util.Random;
+import java.util.StringTokenizer;
+
+public final class C {
+
+    public static void main(String[] args) {
+        final FastScanner fs = new FastScanner();
+        final int t = fs.nextInt();
+        for (int test = 0; test < t; test++) {
+            final int n = fs.nextInt();
+            final int[] arr = fs.nextIntArray(n);
+            long evenSum = arr[0];
+            long oddSum = arr[1];
+            int minEven = arr[0];
+            int minOdd = arr[1];
+            long res = (long) n * arr[0] + (long) n * arr[1];
+            for (int i = 2; i < n; i++) {
+                if (i % 2 == 0) {
+                    minEven = Math.min(minEven, arr[i]);
+                    evenSum += arr[i];
+                    final long eC = n - i / 2 - 1;
+                    final long oC = n - i / 2;
+                    final long curr = evenSum + eC * minEven + oddSum + oC * minOdd;
+                    res = Math.min(res, curr);
+
+                } else {
+                    minOdd = Math.min(minOdd, arr[i]);
+                    oddSum += arr[i];
+                    final long c = n - i / 2 - 1;
+                    final long curr = oddSum + c * minOdd + evenSum + c * minEven;
+                    res = Math.min(res, curr);
+                }
+            }
+            System.out.println(res);
+        }
+    }
+
+    static final class Utils {
+        private static class Shuffler {
+            private static void shuffle(int[] x) {
+                final Random r = new Random();
+
+                for (int i = 0; i <= x.length - 2; i++) {
+                    final int j = i + r.nextInt(x.length - i);
+                    swap(x, i, j);
+                }
+            }
+
+            private static void shuffle(long[] x) {
+                final Random r = new Random();
+
+                for (int i = 0; i <= x.length - 2; i++) {
+                    final int j = i + r.nextInt(x.length - i);
+                    swap(x, i, j);
+                }
+            }
+
+            private static void swap(int[] x, int i, int j) {
+                final int t = x[i];
+                x[i] = x[j];
+                x[j] = t;
+            }
+
+            private static void swap(long[] x, int i, int j) {
+                final long t = x[i];
+                x[i] = x[j];
+                x[j] = t;
+            }
+        }
+
+        public static void shuffleSort(int[] arr) {
+            Shuffler.shuffle(arr);
+            Arrays.sort(arr);
+        }
+
+        public static void shuffleSort(long[] arr) {
+            Shuffler.shuffle(arr);
+            Arrays.sort(arr);
+        }
+
+        private Utils() {}
+    }
+
+    static class FastScanner {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st = new StringTokenizer("""");
+
+        private String next() {
+            while (!st.hasMoreTokens()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    //noinspection CallToPrintStackTrace
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        int[] nextIntArray(int n) {
+            final int[] a = new int[n];
+            for (int i = 0; i < n; i++) { a[i] = nextInt(); }
+            return a;
+        }
+
+        long[] nextLongArray(int n) {
+            final long[] a = new long[n];
+            for (int i = 0; i < n; i++) { a[i] = nextLong(); }
+            return a;
+        }
+    }
+}
+",0
+3d88acb8,b6023b26,"import java.util.*;
+import java.io.*;
+public class D {
+
+	public static void main(String[] args) {
+		FastScanner sc = new FastScanner();
+		int T = sc.nextInt();
+		while(T-->0) {
+			int n = sc.nextInt();
+			int[] arr = new int[n];
+			for(int i = 0; i < n; i++) {
+				arr[i] = sc.nextInt();
+			}
+			if(check(arr)) System.out.println(""YES"");
+			else System.out.println(""NO"");
+		}
+
+	}
+	static boolean check(int[] arr) {
+		int n = arr.length;
+		TreeSet<Integer> set = new TreeSet<>();
+		set.add(arr[0]);
+		for(int i = 1; i < n; i++) {
+			set.add(arr[i]);
+			if(arr[i-1] == arr[i]) continue;
+			Integer x = set.lower(arr[i]);
+			if(x != null && x == arr[i-1]) continue;
+			x = set.higher(arr[i]);
+			if(x != null && x == arr[i-1]) continue;
+			return false;
+		}
+		return true;
+	}
+	
+	static class FastScanner {
+		public BufferedReader reader;
+		public StringTokenizer tokenizer;
+		public FastScanner() {
+			reader = new BufferedReader(new InputStreamReader(System.in), 32768);
+			tokenizer = null;
+		}
+		public String next() {
+			while (tokenizer == null || !tokenizer.hasMoreTokens()) {
+				try {
+					tokenizer = new StringTokenizer(reader.readLine());
+				} catch (IOException e) {
+					throw new RuntimeException(e);
+				}
+			}
+			return tokenizer.nextToken();
+		}
+		public int nextInt() {
+			return Integer.parseInt(next());
+		}
+		public long nextLong() {
+			return Long.parseLong(next());
+		}
+		public double nextDouble() {
+			return Double.parseDouble(next());
+		}
+		public String nextLine() {
+			try {
+				return reader.readLine();
+			} catch(IOException e) {
+				throw new RuntimeException(e);
+			}
+		}
+	}
+
+}
+","import java.io.*;
+import java.util.*;
+import java.math.*;
+import java.math.BigInteger; 
+//import javafx.util.*; 
+public final class B
+{    
+	static StringBuilder ans=new StringBuilder();
+	static FastReader in=new FastReader();
+	static ArrayList<ArrayList<Integer>> g;
+	static long mod=1000000007;
+	static int D1[],D[],par[];
+	static boolean set[];
+	static long INF=Long.MAX_VALUE;
+	public static void main(String args[])throws IOException
+	{  	
+
+		int T=i();
+		while(T-->0)
+		{
+			int N=i();
+			long A[]=inputLong(N);
+			boolean f=true;
+			TreeSet<Long> set=new TreeSet<>();
+			for(int i=0; i<N; i++)
+			{
+				if(i>=2)
+				{
+					if(A[i]<A[i-1])
+					{
+						if(set.ceiling(A[i]+1)!=A[i-1])f=false;
+					}
+					if(A[i]>A[i-1])
+					{
+						if(set.floor(A[i]-1)!=A[i-1])f=false;
+					}
+				}
+				set.add(A[i]);
+			}
+			if(f)System.out.println(""YES"");
+			else System.out.println(""NO"");
+		}
+	}
+
+	static int f2(int l,int r,int index)
+	{
+		while(r-l>1)
+		{
+			int m=(l+r)/2;
+			if(ask(index,m)==index)r=m;
+			else l=m;
+		}
+		return r;
+	}
+	static long fact(long N)
+	{
+		long num=1L;
+		while(N>=1)
+		{
+			num=((num%mod)*(N%mod))%mod;
+			N--;
+		}
+		return num;
+	}
+	static boolean reverse(long A[],int l,int r)
+	{
+		while(l<r)
+		{
+			long t=A[l];
+			A[l]=A[r];
+			A[r]=t;
+			l++;
+			r--;
+		}
+		if(isSorted(A))return true;
+		else return false;
+	}
+	static boolean isSorted(long A[])
+	{
+		for(int i=1; i<A.length; i++)if(A[i]<A[i-1])return false;
+		return true;
+	}
+	static boolean isPalindrome(char X[],int l,int r)
+	{
+		while(l<r)
+		{
+			if(X[l]!=X[r])return false;
+			l++; r--;
+		}
+		return true;
+	}
+
+	static long min(long a,long b,long c)
+	{
+		return Math.min(a, Math.min(c, b));
+	}
+
+	static void print(int a)
+	{
+		System.out.println(""! ""+a);
+	}
+	static int ask(int a,int b)
+	{
+		System.out.println(""? ""+a+"" ""+b);
+		return i();
+	}
+	static int find(int a)
+	{
+		if(par[a]<0)return a;
+		return par[a]=find(par[a]);
+	}
+	static void union(int a,int b)
+	{
+		a=find(a);
+		b=find(b);
+		if(a!=b)
+		{
+			par[a]+=par[b]; //transfers the size
+			par[b]=a;       //changes the parent
+		}
+	}
+	static void swap(char A[],int a,int b)
+	{
+		char ch=A[a];
+		A[a]=A[b];
+		A[b]=ch;
+	}
+
+	static void sort(long[] a) //check for long
+	{
+		ArrayList<Long> l=new ArrayList<>();
+		for (long i:a) l.add(i);
+		Collections.sort(l);
+		for (int i=0; i<a.length; i++) a[i]=l.get(i);
+	}
+	static void setGraph(int N)
+	{
+		D=new int[N+1];
+		set=new boolean[N+1];
+		g=new ArrayList<ArrayList<Integer>>();
+		for(int i=0; i<=N; i++)
+		{
+			D[i]=N+1;
+			g.add(new ArrayList<Integer>());
+		}
+	}
+
+	static  long pow(long a,long b)
+	{
+		long mod=1000000007;
+		long pow=1;
+		long x=a;
+		while(b!=0)
+		{
+			if((b&1)!=0)pow=(pow*x)%mod;
+			x=(x*x)%mod;
+			b/=2;
+		}
+		return pow;
+	}
+	static long toggleBits(long x)//one's complement || Toggle bits
+	{
+		int n=(int)(Math.floor(Math.log(x)/Math.log(2)))+1;
+
+		return ((1<<n)-1)^x;
+	}
+	static int countBits(long a)
+	{
+		return (int)(Math.log(a)/Math.log(2)+1);
+	}
+	static void sort(int[] a) {
+		ArrayList<Integer> l=new ArrayList<>();
+		for (int i:a) l.add(i);
+		Collections.sort(l);
+		for (int i=0; i<a.length; i++) a[i]=l.get(i);
+	}
+	static boolean isPrime(long N)
+	{
+		if (N<=1)  return false; 
+		if (N<=3)  return true; 
+		if (N%2 == 0 || N%3 == 0) return false; 
+		for (int i=5; i*i<=N; i=i+6) 
+			if (N%i == 0 || N%(i+2) == 0) 
+				return false; 
+		return true; 
+	}
+	static long GCD(long a,long b) 
+	{
+		if(b==0)
+		{
+			return a;
+		}
+		else return GCD(b,a%b );
+	}
+
+	//Debugging Functions Starts
+
+	static void print(char A[])
+	{
+		for(char c:A)System.out.print(c+"" "");
+		System.out.println();
+	}
+	static void print(boolean A[])
+	{
+		for(boolean c:A)System.out.print(c+"" "");
+		System.out.println();
+	}
+	static void print(int A[])
+	{
+		for(int a:A)System.out.print(a+"" "");
+		System.out.println();	
+	}
+	static void print(long A[])
+	{
+		for(long i:A)System.out.print(i+ "" "");
+		System.out.println();
+
+	}
+	static void print(ArrayList<Integer> A)
+	{
+		for(int a:A)System.out.print(a+"" "");
+		System.out.println();
+	}
+
+	//Debugging Functions END
+	//----------------------
+	//IO FUNCTIONS STARTS
+	static HashMap<Integer,Integer> Hash(int A[])
+	{
+		HashMap<Integer,Integer> mp=new HashMap<>();
+		for(int a:A)
+		{
+			int f=mp.getOrDefault(a,0)+1;
+			mp.put(a, f);
+		}
+		return mp;
+	}
+	static int i()
+	{
+		return in.nextInt();
+	}
+
+	static long l()
+	{
+		return in.nextLong();
+	}
+
+	static int[] input(int N){
+		int A[]=new int[N];
+		for(int i=0; i<N; i++)
+		{
+			A[i]=in.nextInt();
+		}
+		return A;
+	}
+
+	static long[] inputLong(int N)     {
+		long A[]=new long[N];
+		for(int i=0; i<A.length; i++)A[i]=in.nextLong();
+		return A;
+	}
+
+	//IO FUNCTIONS END
+
+}
+//class pair implements Comparable<pair>{
+//	int index; long a;
+//	pair(long a,int index)
+//	{
+//		this.a=a;
+//		this.index=index;
+//	}
+//	public int compareTo(pair X)
+//	{
+//		if(this.a>X.a)return 1;
+//		if(this.a==X.a)return this.index-X.index;
+//		return -1;
+//	}
+//}
+
+//Code For FastReader
+//Code For FastReader
+//Code For FastReader
+//Code For FastReader
+class FastReader
+{
+	BufferedReader br;
+	StringTokenizer st;
+	public FastReader()
+	{
+		br=new BufferedReader(new InputStreamReader(System.in));
+	}
+
+	String next()
+	{
+		while(st==null || !st.hasMoreElements())
+		{
+			try
+			{
+				st=new StringTokenizer(br.readLine());
+			}
+			catch(IOException e)
+			{
+				e.printStackTrace();
+			}
+		}
+		return st.nextToken();
+	}
+
+	int nextInt()
+	{
+		return Integer.parseInt(next());
+	}
+
+	long nextLong()
+	{
+		return Long.parseLong(next());
+	}
+	//gey
+	double nextDouble()
+	{
+		return Double.parseDouble(next());
+	}
+
+	String nextLine()
+	{
+		String str="""";
+		try
+		{
+			str=br.readLine();
+		}
+		catch (IOException e)
+		{
+			e.printStackTrace();
+		}
+		return str;
+	}
+
+}",0
+32ff22fe,f0d91796,"import java.io.*;
+import java.util.*;
+public class MyClass {
+    public static void pA(int[]a){
+        for(int i=0;i<a.length;i++){
+            System.out.print(a[i]+"" "");
+        }
+        System.out.println();
+    }
+    public static void main(String args[])throws IOException {
+        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+        int t=Integer.parseInt(br.readLine());
+        while(t-->0){
+            int n=Integer.parseInt(br.readLine());
+            String s[]=br.readLine().split("" "");
+            int arr[]=new int[n];
+            int a[]=new int[n];
+            for(int i=0;i<n;i++) arr[i]=Integer.parseInt(s[i]);
+            if(n%2==0){
+                for(int i=0;i<n-1;i+=2){
+                    a[i]=arr[i+1];
+                    a[i+1]=-1*arr[i];
+                }
+            }
+            else{
+                if(arr[1]+arr[2]!=0){
+                    a[0]=arr[1]+arr[2];
+                    a[1]=-1*arr[0];
+                    a[2]=-1*arr[0];
+                }
+                else if(arr[0]+arr[1]!=0){
+                    a[2]=arr[0]+arr[1];
+                    a[0]=-1*arr[2];
+                    a[1]=-1*arr[2];
+                }
+                else{
+                    a[1]=arr[0]+arr[2];
+                    a[0]=-1*arr[1];
+                    a[2]=-1*arr[1];
+                }
+                for(int i=3;i<n-1;i+=2){
+                    a[i]=arr[i+1];
+                    a[i+1]=-1*arr[i];
+                }
+            }
+            pA(a);
+        }
+    }
+}","import java.io.*;
+import java.util.*;
+ 
+public class cf {
+ 
+    public static void main(String[] args){
+ 
+        FastScanner sc = new FastScanner();
+        int t = sc.nextInt();
+        while(t-- > 0){
+ 			
+ 			int n=sc.nextInt();
+            int arr[]=new int[n];
+            for(int i=0;i<n;i++){
+                arr[i]=sc.nextInt();
+            }
+            int ans[]=new int[n];
+            if(n%2==0){
+                for(int i=0;i<n;i=i+2){
+                    ans[i]=-arr[i+1];
+                    ans[i+1]=arr[i];
+                }
+            }
+            else{
+                if(arr[0]+arr[1]!=0){
+                    ans[0]=-arr[2];
+                    ans[1]=-arr[2];
+                    ans[2]=arr[0]+arr[1];
+                }
+                else{
+                    if(arr[1]+arr[2]!=0){
+                        ans[1]=-arr[0];
+                        ans[2]=-arr[0];
+                        ans[0]=arr[1]+arr[2];
+                    }
+                    else{
+                        ans[0]=-arr[1];
+                        ans[2]=-arr[1];
+                        ans[1]=arr[0]+arr[2];
+                    }
+                }
+                for(int i=3;i<n;i=i+2){
+                    ans[i]=-arr[i+1];
+                    ans[i+1]=arr[i];
+                }
+            }
+            for(int j=0;j<n;j++){
+                System.out.print(ans[j]+"" "");
+            }
+            System.out.println();
+            
+
+            
+            
+
+            
+
+            
+           
+ 			
+
+        }	        	
+        	
+ 			
+    }
+ 
+    
+    
+    
+ 
+}
+
+//////////////////////////////////////////////////////////////
+// LCM AND GCD
+/*
+	public static int gcd(int a,int b){
+		if(b == 0){
+			return a;
+		}
+		return gcd(b,a%b);
+	}
+ 
+	public static int lcm(int a,int b){
+		 return (a / gcd(a, b)) * b;
+	}*/
+
+
+///////////////////////////////////////////////////////////////////////////////////
+
+//Iterator
+
+
+
+/*Iterator iterator = object.iterator();
+ 
+        while (iterator.hasNext()) {
+            System.out.print(iterator.next() + "" "");
+        }*/
+///////////////////////////////////////////////////////////////////////////////////
+
+
+class FastScanner
+{
+    //I don't understand how this works lmao
+    private int BS = 1 << 16;
+    private char NC = (char) 0;
+    private byte[] buf = new byte[BS];
+    private int bId = 0, size = 0;
+    private char c = NC;
+    private double cnt = 1;
+    private BufferedInputStream in;
+ 
+    public FastScanner() {
+        in = new BufferedInputStream(System.in, BS);
+    }
+ 
+    public FastScanner(String s) {
+        try {
+            in = new BufferedInputStream(new FileInputStream(new File(s)), BS);
+        } catch (Exception e) {
+            in = new BufferedInputStream(System.in, BS);
+        }
+    }
+ 
+    public char getChar() {
+        while (bId == size) {
+            try {
+                size = in.read(buf);
+            } catch (Exception e) {
+                return NC;
+            }
+            if (size == -1) return NC;
+            bId = 0;
+        }
+        return (char) buf[bId++];
+    }
+ 
+    public int nextInt() {
+        return (int) nextLong();
+    }
+ 
+    public int[] nextInts(int N) {
+        int[] res = new int[N];
+        for (int i = 0; i < N; i++) {
+            res[i] = (int) nextLong();
+        }
+        return res;
+    }
+ 
+    public long[] nextLongs(int N) {
+        long[] res = new long[N];
+        for (int i = 0; i < N; i++) {
+            res[i] = nextLong();
+        }
+        return res;
+    }
+ 
+    public long nextLong() {
+        cnt = 1;
+        boolean neg = false;
+        if (c == NC) c = getChar();
+        for (; (c < '0' || c > '9'); c = getChar()) {
+            if (c == '-') neg = true;
+        }
+        long res = 0;
+        for (; c >= '0' && c <= '9'; c = getChar()) {
+            res = (res << 3) + (res << 1) + c - '0';
+            cnt *= 10;
+        }
+        return neg ? -res : res;
+    }
+ 
+    public double nextDouble() {
+        double cur = nextLong();
+        return c != '.' ? cur : cur + nextLong() / cnt;
+    }
+ 
+    public double[] nextDoubles(int N) {
+        double[] res = new double[N];
+        for (int i = 0; i < N; i++) {
+            res[i] = nextDouble();
+        }
+        return res;
+    }
+ 
+    public String next() {
+        StringBuilder res = new StringBuilder();
+        while (c <= 32) c = getChar();
+        while (c > 32) {
+            res.append(c);
+            c = getChar();
+        }
+        return res.toString();
+    }
+ 
+    public String nextLine() {
+        StringBuilder res = new StringBuilder();
+        while (c <= 32) c = getChar();
+        while (c != '\n') {
+            res.append(c);
+            c = getChar();
+        }
+        return res.toString();
+    }
+ 
+    public boolean hasNext() {
+        if (c > 32) return true;
+        while (true) {
+            c = getChar();
+            if (c == NC) return false;
+            else if (c > 32) return true;
+        }
+    }
+}
+
+",0
+36f1b52a,558df7d4,"/*
+        ""Everything in the universe is balanced. Every disappointment
+                you face in life will be balanced by something good for you!
+                        Keep going, never give up.""
+
+*/
+
+
+import java.util.*;
+import java.lang.*;
+import java.io.*;
+
+public class Solution {
+    public static void main(String[] args) throws java.lang.Exception {
+        out = new PrintWriter(new BufferedOutputStream(System.out));
+        sc = new FastReader();
+
+        int test = sc.nextInt();
+        for (int t = 0; t < test; t++) {
+            solve();
+        }
+        out.close();
+    }
+
+    private static void solve() {
+        int n = sc.nextInt();
+        int[] arr = new int[n];
+        for (int i = 0; i < n; i++) {
+            arr[i] = sc.nextInt();
+        }
+
+        int[] res = new int[n];
+        if (n % 2 == 0) {
+            for (int i = 1; i < n; i += 2) {
+                res[i] = arr[i - 1];
+                res[i - 1] = -arr[i];
+            }
+        }else {
+            for (int i = 4; i < n; i += 2) {
+                res[i] = arr[i - 1];
+                res[i - 1] = -arr[i];
+            }
+
+            if (arr[0] + arr[1] != 0) {
+                res[0] = -arr[2];
+                res[1] = -arr[2];
+                res[2] = arr[0] + arr[1];
+            }else if (arr[0] + arr[2] != 0) {
+                res[0] = -arr[1];
+                res[2] = -arr[1];
+                res[1] = arr[0] + arr[2];
+            }else {
+                res[1] = -arr[0];
+                res[2] = -arr[0];
+                res[0] = arr[1] + arr[2];
+            }
+        }
+
+        for (int i = 0; i < n; i++) {
+            out.print(res[i] + "" "");
+        }
+        out.println();
+    }
+
+
+    public static FastReader sc;
+    public static PrintWriter out;
+    static class FastReader
+    {
+        BufferedReader br;
+        StringTokenizer str;
+
+        public FastReader()
+        {
+            br = new BufferedReader(new
+                    InputStreamReader(System.in));
+        }
+
+        String next()
+        {
+            while (str == null || !str.hasMoreElements())
+            {
+                try
+                {
+                    str = new StringTokenizer(br.readLine());
+                }
+                catch (IOException  end)
+                {
+                    end.printStackTrace();
+                }
+            }
+            return str.nextToken();
+        }
+
+        int nextInt()
+        {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong()
+        {
+            return Long.parseLong(next());
+        }
+
+        double nextDouble()
+        {
+            return Double.parseDouble(next());
+        }
+
+        String nextLine()
+        {
+            String str = """";
+            try
+            {
+                str = br.readLine();
+            }
+            catch (IOException end)
+            {
+                end.printStackTrace();
+            }
+            return str;
+        }
+    }
+}","import java.io.*;
+import java.util.*;
+public class Pupsen {
+	public static void main(String[] args) throws Exception {
+		FastIO in = new FastIO();
+		int t = in.nextInt();
+		for (int tc=0; tc<t; tc++) {
+			int n = in.nextInt();
+			int[] a = new int[n];
+			for (int i=0; i<n; i++) {
+				a[i] = in.nextInt();
+			}
+			int[] b = new int[n];
+			if (n%2==0) {
+				for (int i=0; i<n-1; i+=2) {
+					b[i] = -a[i+1];
+					b[i+1] = a[i];
+				}
+				for (int i=0; i<n; i++) System.out.print(b[i]+"" "");
+			}
+			else {
+				if (a[0]+a[1]!=0) {
+					b[0] = -a[2];
+					b[1] = -a[2];
+					b[2] = a[0]+a[1];
+				}
+				else if (a[0]+a[2]!=0) {
+					b[0] = -a[1];
+					b[2] = -a[1];
+					b[1] = a[0]+a[2];
+				}
+				else {
+					b[1] = -a[0];
+					b[2] = -a[0];
+					b[0] = a[1]+a[2];
+				}
+				for (int i=3; i<n-1; i+=2) {
+					b[i] = -a[i+1];
+					b[i+1] = a[i];
+				}
+				for (int i=0; i<n; i++) System.out.print(b[i]+"" "");
+			}
+			System.out.println();
+		}
+	}
+	static class FastIO {
+		BufferedReader br;
+	    StringTokenizer st;
+	    PrintWriter pr;
+	    public FastIO() throws IOException
+	    {
+	        br = new BufferedReader(new InputStreamReader(System.in));
+	    }
+	    
+
+	    public String next() throws IOException
+	    {
+	        while (st == null || !st.hasMoreElements()) {
+	           
+	            st = new StringTokenizer(br.readLine());
+	        }
+	        return st.nextToken();
+	    }
+
+	    public int nextInt() throws NumberFormatException, IOException { return Integer.parseInt(next()); }
+
+	    public long nextLong() throws NumberFormatException, IOException { return Long.parseLong(next()); }
+
+	    public double nextDouble() throws NumberFormatException, IOException
+	    {
+	        return Double.parseDouble(next());
+	    }
+
+	    public String nextLine() throws IOException
+	    {
+	        String str = br.readLine();
+	        return str;
+	    }
+	}
+}
+",1
+39098126,3bcd2014,"
+import static java.lang.Integer.MAX_VALUE;
+import static java.lang.Integer.parseInt;
+import static java.lang.Long.parseLong;
+import static java.lang.System.exit;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.StringTokenizer;
+
+public class B {
+
+    static void solve() throws Exception {
+        int t=scanInt();
+        while (t-->0){
+            int n=scanInt();
+            int []arr=new int[n];
+            int low=Integer.MAX_VALUE;
+            int high=0;
+            for (int i=0;i<n;i++){
+                arr[i]=scanInt();
+                low=Math.min(low,arr[i]);
+                high=Math.max(high,arr[i]);
+            }
+            int ans=low;
+            while (low<=high){
+                int mid=low+(high-low)/2;
+                boolean flag=true;
+                int []temp=new int[n];
+                for (int i=0;i<n;i++){
+                    temp[i]=arr[i];
+                }
+
+                for (int i=n-1;i>=2;i--){
+                    if(temp[i]<mid){
+                        flag=false;
+                        break;
+                    }
+
+                    int rem=Math.min(temp[i]-mid,arr[i]);
+                    int taken=rem/3;
+                    temp[i]-=3*taken;
+                    temp[i-1]+=taken;
+                    temp[i-2]+=2*taken;
+
+                }
+
+                if(temp[0]<mid || temp[1]<mid){
+                    flag=false;
+                }
+                if(flag){
+                    low=mid+1;
+                    ans=mid;
+                }else {
+                    high=mid-1;
+                }
+            }
+
+            System.out.println(ans);
+        }
+
+    }
+
+    static int scanInt() throws IOException {
+        return parseInt(scanString());
+    }
+
+    static long scanLong() throws IOException {
+        return parseLong(scanString());
+    }
+
+    static String scanString() throws IOException {
+        while (tok == null || !tok.hasMoreTokens()) {
+            tok = new StringTokenizer(in.readLine());
+        }
+        return tok.nextToken();
+    }
+
+    static BufferedReader in;
+    static PrintWriter out;
+    static StringTokenizer tok;
+
+    public static void main(String[] args) {
+        try {
+            in = new BufferedReader(new InputStreamReader(System.in));
+            out = new PrintWriter(System.out);
+            solve();
+            in.close();
+            out.close();
+        } catch (Throwable e) {
+            e.printStackTrace();
+            exit(1);
+        }
+    }
+}
+
+","import java.io.*;
+import java.util.*;
+
+import javax.sound.midi.MidiChannel;
+
+public class Main {
+    static PrintWriter out;
+    static Kioken sc;
+
+    public static void main(String[] args) throws FileNotFoundException {
+        boolean t = true;
+        boolean f = false;
+        if (f) {
+            out = new PrintWriter(""output.txt"");
+            sc = new Kioken(""input.txt"");
+        } else {
+            out = new PrintWriter((System.out));
+            sc = new Kioken();
+        }
+
+        int tt = 1;
+        tt = sc.nextInt();
+        while (tt-- > 0) {
+            solve();
+        }
+        out.flush();
+        out.close();
+    }
+
+    static boolean bs(int[] arr, int a){
+    
+      // out.println("" mid1 ""  + Arrays.toString(arr) + "" "" + a);
+
+      int[] curr = Arrays.copyOf(arr, arr.length);
+     for(int i = arr.length - 1; i >= 2; i--){
+       if(arr[i] < a){
+         return false;
+       }
+       int min = Math.min(arr[i] - a, curr[i]);
+       min = min/3;
+       arr[i] -= 3*min;
+       arr[i - 1] += min;
+       arr[i-2] += 2*min;
+     }
+
+      for(int i: arr){
+        if(i < a){
+          return false;
+        }
+      }
+      return true;
+    }
+    public static void solve() {
+       int n = sc.nextInt();
+       int[] arr = new int[n];
+       int max = Integer.MIN_VALUE;
+       for(int i = 0; i < n; i++){
+         arr[i] = sc.nextInt();
+         max = Math.max(max, arr[i]);
+       }
+
+       int l = 0, r = max, ans = 0;
+       while(l <= r){
+         int mid = (l+r)/2;
+        //  out.println("" l r "" + l + "" "" + r);
+         int[] aa = Arrays.copyOf(arr, arr.length);
+         if(bs(aa, mid)){
+          // out.println(Arrays.toString(arr) + "" "" + Arrays.toString(aa) + "" mid ""  + mid );
+            ans = mid;
+            l = mid+1;
+         }else{
+           r = mid-1;
+         }
+       }
+       out.println(ans);
+    }
+
+    public static long leftShift(long a) {
+        return (long) Math.pow(2, a);
+    }
+
+    public static void reverse(int[] arr) {
+        Arrays.sort(arr);
+        int n = arr.length;
+        for (int i = 0; i < arr.length; i++) {
+            int temp = arr[i];
+            arr[i] = arr[n - 1 - i];
+            arr[n - 1 - i] = temp;
+        }
+        return;
+    }
+
+    public static int lower_bound(ArrayList<Integer> ar, int k) {
+        int s = 0, e = ar.size();
+        while (s != e) {
+            int mid = s + e >> 1;
+            if (ar.get(mid) <= k) {
+                s = mid + 1;
+            } else {
+                e = mid;
+            }
+        }
+        return Math.abs(s) - 1;
+    }
+
+    public static int upper_bound(ArrayList<Integer> ar, int k) {
+        int s = 0;
+        int e = ar.size();
+        while (s != e) {
+            int mid = s + e >> 1;
+            if (ar.get(mid) < k) {
+                s = mid + 1;
+            } else {
+                e = mid;
+            }
+        }
+        if (s == ar.size()) {
+            return -1;
+        }
+        return s;
+    }
+
+    static class Kioken {
+        // FileInputStream br = new FileInputStream(""input.txt"");
+
+        BufferedReader br;
+        StringTokenizer st;
+
+        Kioken(String filename) {
+            try {
+                FileReader fr = new FileReader(filename);
+                br = new BufferedReader(fr);
+                st = new StringTokenizer("""");
+
+            } catch (Exception e) {
+                // TODO: handle exception
+                e.printStackTrace();
+            }
+        }
+
+        Kioken() {
+            try {
+                br = new BufferedReader(new InputStreamReader(System.in));
+                st = new StringTokenizer("""");
+
+            } catch (Exception e) {
+                // TODO: handle exception
+                e.printStackTrace();
+            }
+        }
+
+        public String next() {
+            while (!st.hasMoreTokens()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        public int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        public long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        public double nextDouble() {
+            return Double.parseDouble(next());
+        }
+
+        public String nextLine() {
+            try {
+                return br.readLine();
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+            return null;
+        }
+
+        public boolean hasNext() {
+            String next = null;
+            try {
+                next = br.readLine();
+            } catch (Exception e) {
+            }
+            if (next == null || next.length() == 0) {
+                return false;
+            }
+            st = new StringTokenizer(next);
+            return true;
+        }
+    }
+}",0
+0588b869,9028caf7,"import java.util.*;
+import java.io.*;
+public class Solution
+{
+    static class FastReader 
+    { 
+        BufferedReader br; 
+        StringTokenizer st; 
+  
+        public FastReader() 
+        { 
+            br = new BufferedReader(new
+                     InputStreamReader(System.in)); 
+        } 
+  
+        String next() 
+        { 
+            while (st == null || !st.hasMoreElements()) 
+            { 
+                try
+                { 
+                    st = new StringTokenizer(br.readLine()); 
+                } 
+                catch (IOException  e) 
+                { 
+                    e.printStackTrace(); 
+                } 
+            } 
+            return st.nextToken(); 
+        } 
+  
+        int nextInt() 
+        { 
+            return Integer.parseInt(next()); 
+        } 
+  
+        long nextLong() 
+        { 
+            return Long.parseLong(next()); 
+        } 
+  
+        double nextDouble() 
+        { 
+            return Double.parseDouble(next()); 
+        } 
+  
+        String nextLine() 
+        { 
+            String str = """"; 
+            try
+            { 
+                str = br.readLine(); 
+            } 
+            catch (IOException e) 
+            { 
+                e.printStackTrace(); 
+            } 
+            return str; 
+        } 
+    }
+    static final long mod=(long)1e9+7;
+    public static long pow(long a,int p)
+    {
+        long res=1;
+        while(p>0)
+        {
+            if(p%2==1)
+            {
+                p--;
+                res*=a;
+                res%=mod;
+            }
+            else
+            {
+                a*=a;
+                a%=mod;
+                p/=2;
+            }
+        }
+        return res;
+    }
+    static class Pair
+    {
+        int u,v,w;
+        Pair(int u,int v,int w)
+        {
+            this.u=u;
+            this.v=v;
+            this.w=w;
+        }
+    }
+    /*static class Pair implements Comparable<Pair>
+    {
+        int v,l;
+        Pair(int v,int l)
+        {
+            this.v=v;
+            this.l=l;
+        }
+        public int compareTo(Pair p)
+        {
+            return l-p.l; 
+        }
+    }*/
+    static int gcd(int a,int b)
+    {
+        if(b%a==0)
+        return a;
+        return gcd(b%a,a);
+    }
+    public static void dfs(int u,int dist[],int sub[],int mxv[],int par[],ArrayList<Integer> edge[])
+    {
+        sub[u]=1;
+        for(int v:edge[u])
+        {
+            if(dist[v]==-1)
+            {
+                par[v]=u;
+                dist[v]=dist[u]+1;
+                dfs(v,dist,sub,mxv,par,edge);
+                if(sub[v]+1>sub[u])
+                {
+                    sub[u]=sub[v]+1;
+                    mxv[u]=v;
+                }
+            }
+        }
+    }
+    public static void main(String args[])throws Exception
+    {
+        FastReader fs=new FastReader();
+        PrintWriter pw=new PrintWriter(System.out);
+        //int tc=fs.nextInt();
+        int n=fs.nextInt();
+        int a[]=new int[n];
+        for(int i=0;i<n;i++)
+        a[i]=fs.nextInt();
+        ArrayList<Integer> o=new ArrayList<>();
+        ArrayList<Integer> z=new ArrayList<>();
+        for(int i=0;i<n;i++)
+        {
+            if(a[i]==1)o.add(i);
+            else z.add(i);
+        }
+        int ans[][]=new int[o.size()+1][z.size()+1];
+        for(int i=1;i<=o.size();i++)
+        {
+            for(int j=i;j<=z.size();j++)
+            {
+                if(i==j)ans[i][j]=ans[i-1][j-1]+(int)Math.abs(o.get(i-1)-z.get(j-1));
+                else 
+                ans[i][j]=Math.min(ans[i][j-1],ans[i-1][j-1]+(int)Math.abs(o.get(i-1)-z.get(j-1)));
+            }
+        }
+        pw.println(ans[o.size()][z.size()]);
+        pw.flush();
+        pw.close();
+    }
+}","import java.io.*;
+import java.util.*;
+public class Main {
+    public static void main(String args[])
+    {
+        FastReader input=new FastReader();
+        PrintWriter out=new PrintWriter(System.out);
+        int T=1;
+        while(T-->0)
+        {
+            int n=input.nextInt();
+            int a[]=new int[n];
+            ArrayList<Integer> list=new ArrayList<>();
+            ArrayList<Integer> space=new ArrayList<>();
+            for(int i=0;i<n;i++)
+            {
+                a[i]=input.nextInt();
+                if(a[i]==1)
+                {
+                    list.add(i);
+                }
+                else
+                {
+                    space.add(i);
+                }
+            }
+            int pre[]=new int[space.size()];
+            for(int i=0;i<list.size();i++)
+            {
+                if(i==0)
+                {
+                    int min=Integer.MAX_VALUE;
+                    for(int j=0;j<space.size();j++)
+                    {
+                        pre[j]=Math.abs(list.get(i)-space.get(j));
+                        min=Math.min(min,pre[j]);
+                        pre[j]=min;
+                    }
+                }
+                else
+                {
+                    int arr[]=new int[space.size()];
+                    for(int j=0;j<i;j++)
+                    {
+                        arr[j]=Integer.MAX_VALUE;
+                    }
+
+                    int min=Integer.MAX_VALUE;
+                    for(int j=i;j<space.size();j++)
+                    {
+                        int v=Math.abs(list.get(i)-space.get(j));
+                        v+=pre[j-1];
+                        arr[j]=v;
+                        min=Math.min(min,v);
+                        arr[j]=min;
+                    }
+                    for(int j=0;j<space.size();j++)
+                    {
+                        pre[j]=arr[j];
+                    }
+                }
+            }
+            out.println(pre[space.size()-1]);
+        }
+        out.close();
+    }
+    static class FastReader
+    {
+        BufferedReader br;
+        StringTokenizer st;
+        public FastReader()
+        {
+            br = new BufferedReader(new InputStreamReader(System.in));
+        }
+        String next()
+        {
+            while (st == null || !st.hasMoreElements())
+            {
+                try
+                {
+                    st = new StringTokenizer(br.readLine());
+                }
+                catch (IOException e)
+                {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+        int nextInt()
+        {
+            return Integer.parseInt(next());
+        }
+        long nextLong()
+        {
+            return Long.parseLong(next());
+        }
+        double nextDouble()
+        {
+            return Double.parseDouble(next());
+        }
+        String nextLine()
+        {
+            String str="""";
+            try
+            {
+                str=br.readLine();
+            }
+            catch (IOException e)
+            {
+                e.printStackTrace();
+            }
+            return str;
+        }
+    }
+}",0
+22b41936,8f855b99,"
+
+
+import java.io.*;
+import java.util.*;
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.util.Collections;
+import java.io.InputStreamReader;
+import static java.lang.Math.*;
+import static java.lang.System.*;
+
+public class Main1 {
+
+     static ArrayList<Integer> list1 = new ArrayList<>() ;
+     static ArrayList<Integer> list2 = new ArrayList<>() ;
+     static int n , m ;
+     static long dp[][] ;
+
+     static long solver(int i , int j ){
+         // i = empty chairs
+
+         if (j == m)return 0 ;
+         int tt1 = n-i ;
+         int tt2 = m-j ;
+         if (n-i < m-j)return  Long.MAX_VALUE/2  ;
+         if ( dp[i][j] != -1 )return dp[i][j] ;
+
+        long a = solver(i+1 , j) ;
+        long b = abs( list1.get(i) - list2.get(j)) + solver(i+1 , j+1) ;
+
+        return dp[i][j] = min(a , b) ;
+
+     }
+
+
+
+    public static void main(String[] args) throws IOException {
+
+//        try {
+
+
+            FastScanner in = new FastScanner();
+            PrintWriter out = new PrintWriter(System.out);
+
+
+            int N = in.nextInt() ;
+            int a[] = in.readArray(N) ;
+        for (int i = 0; i <N ; i++) {
+            if (a[i] == 1)list2.add(i) ;
+            else list1.add(i) ;
+        }
+
+         n = list1.size() ;
+         m = list2.size() ;
+            dp = new long[n][m] ;
+
+
+            for(int i=0 ; i<n ; i++)
+                for(int j=0 ; j<m ; j++)
+                    dp[i][j] = -1 ;
+
+     
+        System.out.println(solver(0 , 0 ));
+
+
+
+
+
+
+
+
+            out.flush();
+            out.close();
+
+//        }
+//        catch (Exception e){
+//            return;
+//        }
+
+    }
+
+    static long gcd(long a, long b) {
+        return (b == 0) ? a : gcd(b, a % b);
+    }
+
+    static ArrayList<Integer> list = new ArrayList<>();
+    static boolean A[] = new boolean[2 * 90000001];
+
+
+    static void seive(int n) {
+        int maxn = n;
+        //int maxn = 1000000  ;
+        A[0] = A[1] = true;
+
+        for (int i = 2; i * i <= maxn; i++) {
+            if (!A[i]) {
+                for (int j = i * i; j <= maxn; j += i)
+                    A[j] = true;
+            }
+        }
+
+        for (int i = 2; i <= maxn; i++)
+            if (!A[i])
+                list.add(i);
+
+    }
+
+    static int findLCA(int a, int b, int par[][], int depth[]) {
+        if (depth[a] > depth[b]) {
+            a = a ^ b;
+            b = a ^ b;
+            a = a ^ b;
+        }
+        int diff = depth[b] - depth[a];
+        for (int i = 19; i >= 0; i--) {
+            if ((diff & (1 << i)) > 0) {
+                b = par[b][i];
+            }
+        }
+        if (a == b)
+            return a;
+        for (int i = 19; i >= 0; i--) {
+            if (par[b][i] != par[a][i]) {
+                b = par[b][i];
+                a = par[a][i];
+            }
+        }
+        return par[a][0];
+    }
+
+    static int gcd(int a, int b) {
+        return (b == 0) ? a : gcd(b, a % b);
+    }
+
+    static void formArrayForBinaryLifting(int n, int par[][]) {
+        for (int j = 1; j < 20; j++) {
+            for (int i = 0; i < n; i++) {
+                if (par[i][j - 1] == -1)
+                    continue;
+                par[i][j] = par[par[i][j - 1]][j - 1];
+            }
+        }
+    }
+
+
+    static void sort(int ar[]) {
+        int n = ar.length;
+        ArrayList<Integer> a = new ArrayList<>();
+        for (int i = 0; i < n; i++)
+            a.add(ar[i]);
+        Collections.sort(a);
+        for (int i = 0; i < n; i++)
+            ar[i] = a.get(i);
+    }
+
+    static void sort1(long ar[]) {
+        int n = ar.length;
+        ArrayList<Long> a = new ArrayList<>();
+        for (int i = 0; i < n; i++)
+            a.add(ar[i]);
+        Collections.sort(a);
+        for (int i = 0; i < n; i++)
+            ar[i] = a.get(i);
+    }
+
+    static long ncr(long n, long r, long mod) {
+        if (r == 0)
+            return 1;
+        long val = ncr(n - 1, r - 1, mod);
+        val = (n * val) % mod;
+        val = (val * modInverse(r, mod)) % mod;
+        return val;
+    }
+
+    static long fast_pow(long base, long n, long M) {
+        if (n == 0)
+            return 1;
+        if (n == 1)
+            return base % M;
+        long halfn = fast_pow(base, n / 2, M);
+        if (n % 2 == 0)
+            return (halfn * halfn) % M;
+        else
+            return (((halfn * halfn) % M) * base) % M;
+    }
+
+    static long modInverse(long n, long M) {
+        return fast_pow(n, M - 2, M);
+    }
+
+
+    private static int countDigits(long l) {
+        if (l >= 1000000000000000000L) return 19;
+        if (l >= 100000000000000000L) return 18;
+        if (l >= 10000000000000000L) return 17;
+        if (l >= 1000000000000000L) return 16;
+        if (l >= 100000000000000L) return 15;
+        if (l >= 10000000000000L) return 14;
+        if (l >= 1000000000000L) return 13;
+        if (l >= 100000000000L) return 12;
+        if (l >= 10000000000L) return 11;
+        if (l >= 1000000000L) return 10;
+        if (l >= 100000000L) return 9;
+        if (l >= 10000000L) return 8;
+        if (l >= 1000000L) return 7;
+        if (l >= 100000L) return 6;
+        if (l >= 10000L) return 5;
+        if (l >= 1000L) return 4;
+        if (l >= 100L) return 3;
+        if (l >= 10L) return 2;
+        return 1;
+    }
+
+
+    static class FastOutput implements AutoCloseable, Closeable, Appendable {
+        private static final int THRESHOLD = 32 << 10;
+        private final Writer os;
+        private StringBuilder cache = new StringBuilder(THRESHOLD * 2);
+
+        public FastOutput append(CharSequence csq) {
+            cache.append(csq);
+            return this;
+        }
+
+        public FastOutput append(CharSequence csq, int start, int end) {
+            cache.append(csq, start, end);
+            return this;
+        }
+
+        private void afterWrite() {
+            if (cache.length() < THRESHOLD) {
+                return;
+            }
+            flush();
+        }
+
+        public FastOutput(Writer os) {
+            this.os = os;
+        }
+
+        public FastOutput(OutputStream os) {
+            this(new OutputStreamWriter(os));
+        }
+
+        public FastOutput append(char c) {
+            cache.append(c);
+            afterWrite();
+            return this;
+        }
+
+        public FastOutput append(long c) {
+            cache.append(c);
+            afterWrite();
+            return this;
+        }
+
+        public FastOutput append(String c) {
+            cache.append(c);
+            afterWrite();
+            return this;
+        }
+
+        public FastOutput println() {
+            return append(System.lineSeparator());
+        }
+
+        public FastOutput flush() {
+            try {
+                //            boolean success = false;
+                //            if (stringBuilderValueField != null) {
+                //                try {
+                //                    char[] value = (char[]) stringBuilderValueField.get(cache);
+                //                    os.write(value, 0, cache.length());
+                //                    success = true;
+                //                } catch (Exception e) {
+                //                }
+                //            }
+                //            if (!success) {
+                os.append(cache);
+                //            }
+                os.flush();
+                cache.setLength(0);
+            } catch (IOException e) {
+                throw new UncheckedIOException(e);
+            }
+            return this;
+        }
+
+        public void close() {
+            flush();
+            try {
+                os.close();
+            } catch (IOException e) {
+                throw new UncheckedIOException(e);
+            }
+        }
+
+        public String toString() {
+            return cache.toString();
+        }
+
+    }
+
+
+    static class FastScanner {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st = new StringTokenizer("""");
+
+        String next() {
+            while (!st.hasMoreTokens())
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        int[] readArray(int n) {
+            int[] a = new int[n];
+            for (int i = 0; i < n; i++) a[i] = nextInt();
+            return a;
+        }
+
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+    }
+
+
+}
+
+
+
+
+
+
+
+","import javax.print.DocFlavor;
+import java.util.*;
+import java.lang.*;
+import java.io.*;
+
+public class Solution {
+    static int N = 5005;
+    static int[] arr = new int[N];
+    static long[][] memo = new long[N][N];
+    static List<Integer> occupiedSeats = new ArrayList<>();
+    static List<Integer> emptySeats = new ArrayList<>();
+    static int n, occSize, empSize;
+    public static void main(String[] args) throws java.lang.Exception {
+        out = new PrintWriter(new BufferedOutputStream(System.out));
+        sc = new FastReader();
+        int test = 1;
+        for (int t = 0; t < test; t++) {
+            solve();
+        }
+        out.close();
+    }
+
+    private static void solve() {
+        n = sc.nextInt();
+        for (int i = 1; i <= n; i++) {
+            arr[i] = sc.nextInt();
+            if (arr[i] == 1) {
+                occupiedSeats.add(i);
+            }else {
+                emptySeats.add(i);
+            }
+        }
+        occSize = occupiedSeats.size();
+        empSize = emptySeats.size();
+        for (long[] memset : memo) {
+            Arrays.fill(memset, -1);
+        }
+        out.println(minimumTime(0, 0));
+    }
+
+    private static long minimumTime(int occupied, int empty) {
+        if (occupied == occSize) {
+            return 0;
+        }
+        if (empty == empSize) {
+            return Integer.MAX_VALUE;
+        }
+        if (memo[occupied][empty] != -1) {
+            return memo[occupied][empty];
+        }
+        long curr = Math.abs(occupiedSeats.get(occupied) - emptySeats.get(empty)) + minimumTime(occupied + 1, empty + 1);
+        curr = Math.min(curr, minimumTime(occupied, empty + 1));
+        memo[occupied][empty] = curr;
+        return curr;
+    }
+
+    public static FastReader sc;
+    public static PrintWriter out;
+    static class FastReader
+    {
+        BufferedReader br;
+        StringTokenizer st;
+
+        public FastReader()
+        {
+            br = new BufferedReader(new
+                    InputStreamReader(System.in));
+        }
+
+        String next()
+        {
+            while (st == null || !st.hasMoreElements())
+            {
+                try
+                {
+                    st = new StringTokenizer(br.readLine());
+                }
+                catch (IOException  e)
+                {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt()
+        {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong()
+        {
+            return Long.parseLong(next());
+        }
+
+        double nextDouble()
+        {
+            return Double.parseDouble(next());
+        }
+
+        String nextLine()
+        {
+            String str = """";
+            try
+            {
+                str = br.readLine();
+            }
+            catch (IOException e)
+            {
+                e.printStackTrace();
+            }
+            return str;
+        }
+    }
+}",0
+584b0e9e,722e318f,"
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.math.BigInteger;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.BitSet;
+import java.util.Calendar;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.PriorityQueue;
+import java.util.SortedSet;
+import java.util.Stack;
+import java.util.StringTokenizer;
+import java.util.TreeMap;
+import java.util.TreeSet;
+
+public class D_Round_753_Div3 {
+    public static int MOD = 1000000007;
+
+    static int[][] dp;
+
+
+    public static void main(String[] args) throws FileNotFoundException {
+        // PrintWriter out = new PrintWriter(new FileOutputStream(new File(
+        // ""output.txt"")));
+        PrintWriter out = new PrintWriter(System.out);
+        Scanner in = new Scanner();
+        int T = in.nextInt();
+        for (int z = 0; z < T; z++) {
+            int n = in.nextInt();
+            int[] data = new int[n];
+            for (int i = 0; i < n; i++) {
+                data[i] = in.nextInt();
+            }
+            String line = in.next();
+            ArrayList<Integer> blue = new ArrayList<>();
+            ArrayList<Integer> red = new ArrayList<>();
+            for (int i = 0; i < n; i++) {
+                if (line.charAt(i) == 'B') {
+                    blue.add(data[i]);
+                } else {
+                    red.add(data[i]);
+                }
+            }
+            Collections.sort(blue);
+            Collections.sort(red);
+            int st = 1;
+            boolean ok = true;
+            for (int i : blue) {
+                if (i < st) {
+                    ok = false;
+                    break;
+                }
+                st++;
+            }
+            if (ok) {
+                for (int i : red) {
+                    if (i > st) {
+                        ok = false;
+                        break;
+                    }
+                    st++;
+                }
+            }
+            out.println(ok ? ""Yes"" : ""No"");
+        }
+        out.close();
+    }
+
+    static int find(int v, int[] u) {
+        if (v == u[v]) {
+            return v;
+        }
+        return u[v] = find(u[v], u);
+    }
+
+
+    static int abs(int a) {
+        return a < 0 ? -a : a;
+    }
+
+
+    public static int[] KMP(String val) {
+        int i = 0;
+        int j = -1;
+        int[] result = new int[val.length() + 1];
+        result[0] = -1;
+        while (i < val.length()) {
+            while (j >= 0 && val.charAt(j) != val.charAt(i)) {
+                j = result[j];
+            }
+            j++;
+            i++;
+            result[i] = j;
+        }
+        return result;
+
+    }
+
+    public static boolean nextPer(int[] data) {
+        int i = data.length - 1;
+        while (i > 0 && data[i] < data[i - 1]) {
+            i--;
+        }
+        if (i == 0) {
+            return false;
+        }
+        int j = data.length - 1;
+        while (data[j] < data[i - 1]) {
+            j--;
+        }
+        int temp = data[i - 1];
+        data[i - 1] = data[j];
+        data[j] = temp;
+        Arrays.sort(data, i, data.length);
+        return true;
+    }
+
+    public static int digit(long n) {
+        int result = 0;
+        while (n > 0) {
+            n /= 10;
+            result++;
+        }
+        return result;
+    }
+
+    public static double dist(long a, long b, long x, long y) {
+        double val = (b - a) * (b - a) + (x - y) * (x - y);
+        val = Math.sqrt(val);
+        double other = x * x + a * a;
+        other = Math.sqrt(other);
+        return val + other;
+
+    }
+
+    public static class Point {
+
+        int x;
+        int y;
+
+        public Point(int start, int end) {
+            this.x = start;
+            this.y = end;
+        }
+
+        public String toString() {
+            return x + "" "" + y;
+        }
+
+    }
+
+    public static class FT {
+
+        long[] data;
+
+        FT(int n) {
+            data = new long[n];
+        }
+
+        public void update(int index, long value) {
+            while (index < data.length) {
+                data[index] += value;
+                data[index] %= MOD;
+                index += (index & (-index));
+            }
+        }
+
+        public long get(int index) {
+
+            long result = 0;
+            while (index > 0) {
+                result += data[index];
+                result %= MOD;
+                index -= (index & (-index));
+            }
+            return result;
+
+        }
+    }
+
+    public static long gcd(long a, long b) {
+        if (b == 0) {
+            return a;
+        }
+        return gcd(b, a % b);
+    }
+
+    public static long pow(long a, int b) {
+        if (b == 0) {
+            return 1;
+        }
+        if (b == 1) {
+            return a;
+        }
+
+        long val = pow(a, b / 2);
+        if (b % 2 == 0) {
+            return (val * val);
+        } else {
+            return (val * ((val * a)));
+
+        }
+    }
+
+    static class Scanner {
+
+        BufferedReader br;
+        StringTokenizer st;
+
+        public Scanner() throws FileNotFoundException {
+            // System.setOut(new PrintStream(new BufferedOutputStream(System.out), true));
+            br = new BufferedReader(new InputStreamReader(System.in));
+            //br = new BufferedReader(new InputStreamReader(new FileInputStream(new File(""input.txt""))));
+        }
+
+        public String next() {
+
+            while (st == null || !st.hasMoreTokens()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (Exception e) {
+                    throw new RuntimeException();
+                }
+            }
+            return st.nextToken();
+        }
+
+        public long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        public int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        public double nextDouble() {
+            return Double.parseDouble(next());
+        }
+
+        public String nextLine() {
+            st = null;
+            try {
+                return br.readLine();
+            } catch (Exception e) {
+                throw new RuntimeException();
+            }
+        }
+
+        public boolean endLine() {
+            try {
+                String next = br.readLine();
+                while (next != null && next.trim().isEmpty()) {
+                    next = br.readLine();
+                }
+                if (next == null) {
+                    return true;
+                }
+                st = new StringTokenizer(next);
+                return st.hasMoreTokens();
+            } catch (Exception e) {
+                throw new RuntimeException();
+            }
+        }
+    }
+}","import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.math.BigInteger;
+import java.text.DecimalFormat;
+import java.util.*;
+import java.util.concurrent.ThreadLocalRandom;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+import java.util.stream.LongStream;
+
+public class TaskB {
+
+    static long mod = 1000000007;
+    static FastScanner scanner;
+
+    static final StringBuilder result = new StringBuilder();
+
+    public static void main(String[] args) {
+        // 2 : 1000000000
+        scanner = new FastScanner();
+        int T = scanner.nextInt();
+        for (int t = 0; t < T; t++) {
+            solve(t + 1);
+            result.append(""\n"");
+        }
+        System.out.println(result);
+    }
+
+    static void solve(int t) {
+        int n = scanner.nextInt();
+        int[] a = scanner.nextIntArray(n);
+        String s = scanner.nextToken();
+
+        List<Integer> blue = new ArrayList<>();
+        List<Integer> red = new ArrayList<>();
+        for (int i = 0; i < n; i++) {
+            if (s.charAt(i) == 'B') {
+                blue.add(a[i]);
+            } else {
+                red.add(a[i]);
+            }
+        }
+        Collections.sort(blue);
+        Collections.sort(red);
+        for (int i = 0; i < blue.size(); i++) {
+            if (blue.get(i) < i + 1) {
+                result.append(""NO"");
+                return;
+            }
+        }
+        for (int i = 0; i < red.size(); i++) {
+            if (red.get(i) > i + 1 + blue.size()) {
+                result.append(""NO"");
+                return;
+            }
+        }
+        result.append(""YES"");
+    }
+
+    static class WithIdx implements Comparable<WithIdx> {
+        int val, idx;
+
+        public WithIdx(int val, int idx) {
+            this.val = val;
+            this.idx = idx;
+        }
+
+        @Override
+        public int compareTo(WithIdx o) {
+            if (val == o.val) {
+                return Integer.compare(idx, o.idx);
+            }
+            return Integer.compare(val, o.val);
+        }
+    }
+
+    public static class FastScanner {
+        BufferedReader br;
+        StringTokenizer st;
+
+        public FastScanner() {
+            br = new BufferedReader(new InputStreamReader(System.in));
+        }
+
+        String nextToken() {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    // TODO Auto-generated catch block
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        String nextLine() {
+            try {
+                return br.readLine();
+            } catch (Exception e) {
+                e.printStackTrace();
+                throw new RuntimeException();
+            }
+        }
+
+        int nextInt() {
+            return Integer.parseInt(nextToken());
+        }
+
+        long nextLong() {
+            return Long.parseLong(nextToken());
+        }
+
+        double nextDouble() {
+            return Double.parseDouble(nextToken());
+        }
+
+        int[] nextIntArray(int n) {
+            int[] res = new int[n];
+            for (int i = 0; i < n; i++) res[i] = nextInt();
+            return res;
+        }
+
+        long[] nextLongArray(int n) {
+            long[] res = new long[n];
+            for (int i = 0; i < n; i++) res[i] = nextLong();
+            return res;
+        }
+
+        String[] nextStringArray(int n) {
+            String[] res = new String[n];
+            for (int i = 0; i < n; i++) res[i] = nextToken();
+            return res;
+        }
+    }
+
+    static class PrefixSums {
+        long[] sums;
+
+        public PrefixSums(long[] sums) {
+            this.sums = sums;
+        }
+
+        public long sum(int fromInclusive, int toExclusive) {
+            if (fromInclusive > toExclusive) throw new IllegalArgumentException(""Wrong value"");
+            return sums[toExclusive] - sums[fromInclusive];
+        }
+
+        public static PrefixSums of(int[] ar) {
+            long[] sums = new long[ar.length + 1];
+            for (int i = 1; i <= ar.length; i++) {
+                sums[i] = sums[i - 1] + ar[i - 1];
+            }
+            return new PrefixSums(sums);
+        }
+
+        public static PrefixSums of(long[] ar) {
+            long[] sums = new long[ar.length + 1];
+            for (int i = 1; i <= ar.length; i++) {
+                sums[i] = sums[i - 1] + ar[i - 1];
+            }
+            return new PrefixSums(sums);
+        }
+    }
+
+    static class ADUtils {
+        static void sort(int[] ar) {
+            Random rnd = ThreadLocalRandom.current();
+            for (int i = ar.length - 1; i > 0; i--) {
+                int index = rnd.nextInt(i + 1);
+                // Simple swap
+                int a = ar[index];
+                ar[index] = ar[i];
+                ar[i] = a;
+            }
+            Arrays.sort(ar);
+        }
+
+        static void reverse(int[] arr) {
+            int last = arr.length / 2;
+            for (int i = 0; i < last; i++) {
+                int tmp = arr[i];
+                arr[i] = arr[arr.length - 1 - i];
+                arr[arr.length - 1 - i] = tmp;
+            }
+        }
+
+        static void sort(long[] ar) {
+            Random rnd = ThreadLocalRandom.current();
+            for (int i = ar.length - 1; i > 0; i--) {
+                int index = rnd.nextInt(i + 1);
+                // Simple swap
+                long a = ar[index];
+                ar[index] = ar[i];
+                ar[i] = a;
+            }
+            Arrays.sort(ar);
+        }
+    }
+
+    static class MathUtils {
+        static long[] FIRST_PRIMES = {
+                2, 3, 5, 7, 11, 13, 17, 19, 23, 29,
+                31, 37, 41, 43, 47, 53, 59, 61, 67, 71,
+                73, 79, 83, 89, 97, 101, 103, 107, 109, 113,
+                127, 131, 137, 139, 149, 151, 157, 163, 167, 173,
+                179, 181, 191, 193, 197, 199, 211, 223, 227, 229,
+                233, 239, 241, 251, 257, 263, 269, 271, 277, 281,
+                283, 293, 307, 311, 313, 317, 331, 337, 347, 349,
+                353, 359, 367, 373, 379, 383, 389, 397, 401, 409,
+                419, 421, 431, 433, 439, 443, 449, 457, 461, 463,
+                467, 479, 487, 491, 499, 503, 509, 521, 523, 541,
+                547, 557, 563, 569, 571, 577, 587, 593, 599, 601,
+                607, 613, 617, 619, 631, 641, 643, 647, 653, 659,
+                661, 673, 677, 683, 691, 701, 709, 719, 727, 733,
+                739, 743, 751, 757, 761, 769, 773, 787, 797, 809,
+                811, 821, 823, 827, 829, 839, 853, 857, 859, 863,
+                877, 881, 883, 887, 907, 911, 919, 929, 937, 941,
+                947, 953, 967, 971, 977, 983, 991, 997, 1009, 1013,
+                1019, 1021, 1031, 1033, 1039, 1049, 1051};
+
+        static long[] primes(int to) {
+            long[] all = new long[to + 1];
+            long[] primes = new long[to + 1];
+            all[1] = 1;
+            int primesLength = 0;
+            for (int i = 2; i <= to; i++) {
+                if (all[i] == 0) {
+                    primes[primesLength++] = i;
+                    all[i] = i;
+                }
+                for (int j = 0; j < primesLength && i * primes[j] <= to && all[i] >= primes[j];
+                        j++) {
+                    all[(int) (i * primes[j])] = primes[j];
+                }
+            }
+            return Arrays.copyOf(primes, primesLength);
+        }
+
+        static long modpow(long b, long e, long m) {
+            long result = 1;
+
+            while (e > 0) {
+                if ((e & 1) == 1) {
+                    /* multiply in this bit's contribution while using modulus to keep
+                     * result small */
+                    result = (result * b) % m;
+                }
+                b = (b * b) % m;
+                e >>= 1;
+            }
+
+            return result;
+        }
+
+        static long submod(long x, long y, long m) {
+            return (x - y + m) % m;
+        }
+
+        static long modInverse(long a, long m) {
+            long g = gcdF(a, m);
+            if (g != 1) {
+                throw new IllegalArgumentException(""Inverse doesn't exist"");
+            } else {
+                // If a and m are relatively prime, then modulo
+                // inverse is a^(m-2) mode m
+                return modpow(a, m - 2, m);
+            }
+        }
+
+        static public long gcdF(long a, long b) {
+            while (b != 0) {
+                long na = b;
+                long nb = a % b;
+                a = na;
+                b = nb;
+            }
+            return a;
+        }
+    }
+}
+
+/*
+5
+3 2 3 8 8
+2 8 5 10 1
+
+ */",0
+99bc7da3,ced4639e,"import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.util.*;
+ 
+ 
+public class Codeforces {
+	
+	static int mod =1000000007; 
+	static Set<Integer> set;
+	public static void main(String[] args) throws Exception {
+		PrintWriter out=new PrintWriter(System.out);
+	    FastScanner fs=new FastScanner();
+	    int t=fs.nextInt();
+	    while(t-->0) {
+	    	int n=fs.nextInt();
+	    	int arr[]=new int[n];
+//	    	set=new HashSet<>();
+	    	for(int i=0;i<n;i++) {
+	    		arr[i]=Math.abs(fs.nextInt());
+//	    		set.add(arr[i]);
+	    	}
+//	    	sort(arr);
+//	    	for(int i=0;i<n;i++) System.out.print(arr[i]+"" "");
+//	    	System.out.println();
+//	    	if(set.size()<n||set.contains(0)) {
+//	    		System.out.println(""YES"");
+//	    		continue;
+//	    	}
+	    	boolean f=false;
+	    	for(int i=0;i<n;i++) {
+	    		boolean cur=recur(0,i,arr,0);
+	    		if(cur) {
+	    			f=true;
+	    			break;
+	    		}
+	    	}
+	    	if(f) System.out.println(""YES"");
+	    	else System.out.println(""NO"");
+	    }
+	    out.close();
+	}
+	static boolean recur(int pos,int ind,int arr[],int sum) {
+		if(pos==ind) return recur(pos+1,ind,arr,sum);
+		if(sum==arr[ind]) return true;
+		if(pos==arr.length) {
+			return false;
+		}
+		
+		if(recur(pos+1,ind,arr,sum+arr[pos])) return true;
+		if(recur(pos+1,ind,arr,sum)) return true;
+		if(recur(pos+1,ind,arr,sum-arr[pos])) return true;
+		return false;
+	}
+	static long gcd(long  a,long  b) {
+		if(b==0) return a;
+		return gcd(b,a%b);
+	}
+	static long nck(int n,int k) {
+		if(k>n) return 0;
+		long res=1;
+		res*=fact(n);
+		res%=mod;
+		res*=modInv(fact(k));
+		res%=mod;
+		res*=modInv(fact(n-k)); 
+		res%=mod;
+		return res;
+	}
+	static long fact(long n) {
+		long res=1;
+		for(int i=2;i<=n;i++) {
+			res*=i;
+			res%=mod;
+		}
+		return res;
+	}
+	static long pow(long a,long b) {
+		long res=1;
+		while(b!=0) {
+			if((b&1)!=0) {
+				res*=a;
+				res%=mod;
+			}
+			a*=a;
+			a%=mod;
+			b=b>>1;
+		}
+		return res;
+	}
+	static long modInv(long n) {
+		return pow(n,mod-2);
+	}
+	
+	static void sort(int[] a) {
+		//suffle
+		int n=a.length;
+		Random r=new Random();
+		for (int i=0; i<a.length; i++) {
+			int oi=r.nextInt(n);
+			int temp=a[i];
+			a[i]=a[oi];
+			a[oi]=temp;
+		}
+		
+		//then sort
+		Arrays.sort(a);
+	}
+	
+	// Use this to input code since it is faster than a Scanner
+	static class FastScanner {
+		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st=new StringTokenizer("""");
+		String next() {
+			while (!st.hasMoreTokens())
+				try {
+					st=new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			return st.nextToken();
+		}
+		
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+		int[] readArray(int n) {
+			int[] a=new int[n];
+			for (int i=0; i<n; i++) a[i]=nextInt();
+			return a;
+		}
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+	}
+ 
+}","import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+
+public class Main {
+    public static boolean find(int[] a) {
+        int n = a.length;
+        for (int i = 1; i < Math.pow(3, n); i++) {
+            int sum = 0;
+            int x = i;
+            for (int j = 0; j < n; j++) {
+                int r = x % 3;
+                if (r == 1) sum += a[j];
+                else if (r ==2) sum -= a[j];
+                x /= 3;
+            }
+            if (sum == 0) return true;
+        }
+        return false;
+    }
+
+    public static void main(String[] args) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        PrintWriter pw = new PrintWriter(System.out);
+        int t = Integer.parseInt(br.readLine());
+        for (int i = 0; i < t; i++) {
+            int n = Integer.parseInt(br.readLine());
+            int[] a = new int[n];
+            String[] s = br.readLine().trim().split(""\\s+"");
+            for (int j = 0; j < n; j++) {
+                a[j] = Integer.parseInt(s[j]);
+            }
+            boolean res = find(a);
+            if (res) pw.println(""YES"");
+            else pw.println(""NO"");
+        }
+        pw.flush();
+    }
+}",0
+403e3270,58d18fca,"import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.text.DecimalFormat;
+import java.util.*;
+
+//import sun.nio.fs.RegistryFileTypeDetector;
+
+
+ 
+public class Codeforces {
+	static int mod= 998244353;
+	
+	public static void main(String[] args) throws Exception {
+		PrintWriter out=new PrintWriter(System.out);
+		FastScanner fs=new FastScanner();
+		int t=fs.nextInt();
+		
+		outer:while(t-->0) {
+			int n=fs.nextInt();
+			int arr[]=fs.readArray(n);
+			int l=0, r=1000000000;
+			while(l<r) {
+				int mid=(l+r+1)/2;
+				if(check(arr,mid)) {
+					l=mid;
+				}
+				else r=mid-1;
+			}
+			out.println(l);
+			
+//			System.out.println(check(arr,13));
+			
+		}
+		
+		out.close();
+		
+	}
+	static boolean check(int arr[],int min) {
+		int n=arr.length;
+		int brr[]=new int[n];
+		for(int i=n-1;i>1;i--) {
+			if(brr[i]+arr[i]<min) return false;
+			int cur= Math.min(arr[i], arr[i]+brr[i]-min);
+//			System.out.println(cur+"" "");
+			int d=cur/3;
+//			System.out.println(d);
+			brr[i-1]+=d;
+			brr[i-2]+=2*d;
+		}
+		
+		return (arr[0]+brr[0]>=min)&&(arr[1]+brr[1]>=min);
+	}
+	static long pow(long a,long b) {
+		if(b<0) return 1;
+		long res=1;
+		while(b!=0) {
+			if((b&1)!=0) {
+				res*=a;
+				res%=mod;
+			}
+			a*=a;
+			a%=mod;
+			b=b>>1;
+		}
+		return res;
+	}
+	static int gcd(int  a,int  b) {
+		if(b==0) return a;
+		return gcd(b,a%b);
+	}
+	static long nck(int n,int k) {
+		if(k>n) return 0;
+		long res=1;
+		res*=fact(n);
+		res%=mod;
+		res*=modInv(fact(k));
+		res%=mod;
+		res*=modInv(fact(n-k)); 
+		res%=mod;
+		return res;
+	}
+	static long fact(long n) {
+//		return fact[(int)n];
+		long res=1;
+		for(int i=2;i<=n;i++) {
+			res*=i;
+			res%=mod;
+		}
+		return res;
+	}
+	
+	static long modInv(long n) {
+		return pow(n,mod-2);
+	}
+	
+	static void sort(int[] a) {
+		//suffle
+		int n=a.length;
+		Random r=new Random();
+		for (int i=0; i<a.length; i++) {
+			int oi=r.nextInt(n);
+			int temp=a[i];
+			a[i]=a[oi];
+			a[oi]=temp;
+		}
+		
+		//then sort
+		Arrays.sort(a);
+	}
+	
+	// Use this to input code since it is faster than a Scanner
+	static class FastScanner {
+		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st=new StringTokenizer("""");
+		String next() {
+			while (!st.hasMoreTokens())
+				try {
+					st=new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			return st.nextToken();
+		}
+		
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+		long[] lreadArray(int n) {
+			long a[]=new long[n];
+			for(int i=0;i<n;i++) a[i]=nextLong();
+			return a;
+		}
+		int[] readArray(int n) {
+			int[] a=new int[n];
+			for (int i=0; i<n; i++) a[i]=nextInt();
+			return a;
+		}
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+	}
+ 
+}","import java.io.*;
+import java.util.*;
+
+public class Main {
+
+	public static void main(String[] args) {
+		FastScanner fs=new FastScanner();
+		PrintWriter out = new PrintWriter(System.out);
+
+		/******  CODE STARTS HERE  *****/
+		//--------------------------------------------------------------------------------------------------------
+		int t = fs.nextInt();
+		while(t-->0) {
+			int n = fs.nextInt();
+			int[] h = fs.readArray(n);
+			int l=1, r=(int)1e9;
+			int ans = -1;
+			while(l<=r) {
+				int mid = (l+r)/2;
+				if(isPossible(mid, h, n)) {
+					ans = mid;
+					l = mid+1;
+				}else {
+					r= mid-1;
+				}
+			}
+			out.println(ans);
+		}
+		out.close();
+	}
+	
+	static boolean isPossible(int min, int[] h, int n) {
+		int[] c = new int[n];
+		for(int i=n-1; i>=2; i--) {
+			
+			if(h[i]+c[i]-min<0)return false;
+			
+			int x  = Math.min(h[i], h[i]+c[i]-min) / 3;
+			c[i-1] += x;
+			c[i-2] += 2*x;
+		}
+		
+		return (h[0]+c[0]>=min&&h[1]+c[1]>=min);
+	}
+    
+	//******  CODE ENDS HERE  *****
+	//----------------------------------------------------------------------------------------------------------------
+	
+	static void sort(int[] a) {
+		ArrayList<Integer> l=new ArrayList<>();
+		for (int i:a) l.add(i);
+		Collections.sort(l);
+		for (int i=0; i<a.length; i++) a[i]=l.get(i);
+	}
+	
+	
+	//----------- FastScanner class for faster input---------------------------
+	static class FastScanner {
+		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st=new StringTokenizer("""");
+		String next() {
+			while (!st.hasMoreTokens())
+				try {
+					st=new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			return st.nextToken();
+		}
+		
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+		int[] readArray(int n) {
+			int[] a=new int[n];
+			for (int i=0; i<n; i++) a[i]=nextInt();
+			return a;
+		}
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+	}
+}",1
+80881cae,a7e7f371,"//package Codeforces;
+import java.io.*;
+import java.util.*;
+
+
+public class CP
+{
+	static Scanner sc=new Scanner(System.in);
+	public static void main(String[] args) throws IOException, CloneNotSupportedException
+	{
+		int t=sc.nextInt();
+		while(t-->0)
+		{
+			int n=sc.nextInt();
+			int k[]=new int[n];
+			int h[]=new int[n];
+			for(int i=0;i<n;i++)
+				k[i]=sc.nextInt();
+			for(int i=0;i<n;i++)
+				h[i]=sc.nextInt();
+			ArrayList<Pair> interval=new ArrayList<Pair>();
+			ArrayList<Pair> act=new ArrayList<Pair>();
+			for(int i=0;i<n;i++)
+				interval.add(new Pair(k[i]-h[i]+1,k[i]));
+			Collections.sort(interval);
+//			out.println(interval);
+			act.add(interval.get(0).clone());
+			for(int i=1;i<n;i++)
+			{
+				Pair p=act.get(act.size()-1);
+				if(p.y<interval.get(i).x)
+					act.add(interval.get(i).clone());
+				else
+					p.y=Math.max(p.y, interval.get(i).y);
+			}
+//			out.println(act);
+			long mana=0;
+			for(Pair p: act)
+			{
+				long x=p.y-p.x+1;
+				mana+=(x*(x+1))/2;
+			}
+			System.out.println(mana);		
+ 		}
+	}
+	static class Pair implements Cloneable, Comparable<Pair>
+	{
+		int x,y;
+		Pair(int a,int b)
+		{
+			this.x=a;
+			this.y=b;
+		}
+//		@Override
+//		public boolean equals(Object obj) 
+//		{
+//			if(obj instanceof  Pair)
+//			{
+//				Pair p=(Pair)obj;
+//				return p.x==this.x && p.y==this.y;
+//			}
+//			return false;
+//		}
+//		@Override
+//		public int hashCode() 
+//		{
+//			return Math.abs(x)+500*Math.abs(y);
+//		}
+//		@Override
+//		public String toString() 
+//		{
+//			return ""(""+x+"" ""+y+"")"";
+//		}
+		@Override
+		protected Pair clone() throws CloneNotSupportedException {
+			return new Pair(this.x,this.y);
+		}
+		@Override
+		public int compareTo(Pair a) 
+		{
+			long t=(this.x-a.x);
+			if(t!=0)
+				return t>0?1:-1;
+			else
+				return (int)(this.y-a.y);
+		}
+//		public void swap()
+//		{
+//			this.y=this.y+this.x;
+//			this.x=this.y-this.x;
+//			this.y=this.y-this.x;			
+//		}
+	}
+}","
+import java.io.*;
+import java.util.*;
+
+
+public class cp {
+	static int mod=(int)1e9+7;
+	
+//	static  Reader sc=new Reader();
+	static FastReader sc=new FastReader(System.in);
+	static int[] sp;
+	static int size=(int)1e6;
+	static int[] arInt;
+	static long[] arLong;
+	public static void main(String[] args) throws IOException { 
+		long tc=sc.nextLong();
+//		Scanner sc=new Scanner(System.in);
+//			int tc=1;
+			
+//			primeSet=new HashSet<>();
+//			sieveOfEratosthenes((int)1e6+5);
+			while(tc-->0)
+			{
+				int n=sc.nextInt();
+				int k[]=new int[n];
+				int h[]=new int[n];
+				for(int i=0;i<n;i++)
+					k[i]=sc.nextInt();
+				for(int i=0;i<n;i++)
+					h[i]=sc.nextInt();
+				ArrayList<Pair> interval=new ArrayList<Pair>();
+				ArrayList<Pair> act=new ArrayList<Pair>();
+				for(int i=0;i<n;i++)
+					interval.add(new Pair(k[i]-h[i]+1,k[i]));
+				Collections.sort(interval);
+				// out.println(interval);
+				act.add(interval.get(0));
+				for(int i=1;i<n;i++)
+				{
+					Pair p=act.get(act.size()-1);
+					if(p.y<interval.get(i).x)
+						act.add(interval.get(i));
+					else
+						p.y=Math.max(p.y, interval.get(i).y);
+				}
+				// out.println(act);
+				long mana=0;
+				for(Pair p: act)
+				{
+					long x=p.y-p.x+1;
+					mana+=(x*(x+1))/2;
+				}
+				out.println(mana);
+				
+				
+				
+				
+				
+				
+				
+				
+				
+//				int n=sc.nextInt();
+//				long days[]=new long[n];
+//				long power[]=new long[n];
+//				for (int i = 0; i < power.length; i++) {
+//					days[i]=sc.nextLong();
+//				}
+//				for (int i = 0; i < power.length; i++) {
+//					power[i]=sc.nextLong();
+//					
+//				}
+//				
+//				long ans=0;
+//				for(int i=0;i<n;i++)
+//				{
+//					if(i==0)
+//					{
+//						ans+=power[i]*(power[i]+1L)/2L;
+//						continue;
+//					}
+//					
+//					long temp=power[i]*(power[i]+1)/2L;
+//					long temp2=(power[i-1]+days[i]-days[i-1])*(power[i-1]+days[i]-days[i-1]+1L)/2L;
+//					temp2-=power[i-1]*(power[i-1]+1L)/2L;
+//					ans+=Math.min(temp, temp2);
+////					if(days[i]-days[i-1]<=power[i])
+////					{
+////						ans+=power[i]*(power[i]+1)/2;
+////					}
+////					else {
+////						ans+=power[i]*(power[i]+1)/2;
+////						ans-=power[i-1]*(power[i-1]+1)/2;
+////					}
+//						
+//					
+//				}
+//				
+//				out.println(ans);
+			}
+			
+				
+			
+			
+			out.flush();
+			out.close();
+			System.gc();
+	
+	}
+	
+	
+	
+
+
+	/*
+	   ...SOLUTION ENDS HERE...........SOLUTION ENDS HERE...
+ */
+	
+	
+	static int util(char a,char b)
+	{
+		int A=a-'0';
+		int B=b-'0';
+		return A+B;
+	}
+	static boolean check(int x,int[] rich,int[] poor)
+	{
+		int cnt=0;
+		for(int i=0;i<rich.length;i++)
+		{
+			if(x-1-rich[i]<=cnt && cnt<=poor[i])
+				cnt++;
+		}
+		
+		return cnt>=x;
+	}
+	
+	static void arrInt(int n) throws IOException
+	{
+		arInt=new int[n];
+		for (int i = 0; i < arInt.length; i++) {
+			arInt[i]=sc.nextInt();
+		}
+	}
+	
+	static void arrLong(int n) throws IOException
+	{
+		arLong=new long[n];
+		for (int i = 0; i < arLong.length; i++) {
+			arLong[i]=sc.nextLong();
+		}
+	}
+	
+	
+	
+	static ArrayList<Integer> add(int id,int c)
+	{
+		ArrayList<Integer> newArr=new ArrayList<>();
+		for(int i=0;i<id;i++)
+			newArr.add(arInt[i]);
+		newArr.add(c);
+		for(int i=id;i<arInt.length;i++)
+		{
+			newArr.add(arInt[i]);
+		}
+		
+		
+		return newArr;
+	}
+
+	    // function to find last index <= y
+    static int upper(ArrayList<Integer> arr, int n, int y)
+    {
+        int l = 0, h = n - 1;
+        while (l <= h)
+        {
+            int mid = (l + h) / 2;
+            if (arr.get(mid) <= y)
+                l = mid + 1;
+            else
+                h = mid - 1;
+        }
+        return h;
+    }
+     
+	
+	
+	static int lower(ArrayList<Integer> arr, int n, int x)
+    {
+        int l = 0, h = n - 1;
+        while (l <= h)
+        {
+            int mid = (l + h) / 2;
+            if (arr.get(mid) >= x)
+                h = mid - 1;
+            else
+                l = mid + 1;
+        }
+        return l;
+    }
+          
+	
+	
+	
+	
+	static int N = 501; 
+	 
+	// Array to store inverse of 1 to N
+	static long[] factorialNumInverse = new long[N + 1];
+	 
+	// Array to precompute inverse of 1! to N!
+	static long[] naturalNumInverse = new long[N + 1];
+	 
+	// Array to store factorial of first N numbers
+	static long[] fact = new long[N + 1];
+	 
+	// Function to precompute inverse of numbers
+	public static void InverseofNumber(int p)
+	{
+	    naturalNumInverse[0] = naturalNumInverse[1] = 1;
+	     
+	    for(int i = 2; i <= N; i++)
+	        naturalNumInverse[i] = naturalNumInverse[p % i] *
+	                                 (long)(p - p / i) % p;
+	}
+	 
+	// Function to precompute inverse of factorials
+	public static void InverseofFactorial(int p)
+	{
+	    factorialNumInverse[0] = factorialNumInverse[1] = 1;
+	 
+	    // Precompute inverse of natural numbers
+	    for(int i = 2; i <= N; i++)
+	        factorialNumInverse[i] = (naturalNumInverse[i] *
+	                           factorialNumInverse[i - 1]) % p;
+	}
+	 
+	// Function to calculate factorial of 1 to N
+	public static void factorial(int p)
+	{
+	    fact[0] = 1;
+	 
+	    // Precompute factorials
+	    for(int i = 1; i <= N; i++)
+	    {
+	        fact[i] = (fact[i - 1] * (long)i) % p;
+	    }
+	}
+	 
+	// Function to return nCr % p in O(1) time
+	public static long Binomial(int N, int R, int p)
+	{
+	     
+	    // n C r = n!*inverse(r!)*inverse((n-r)!)
+	    long ans = ((fact[N] * factorialNumInverse[R]) %
+	                       p * factorialNumInverse[N - R]) % p;
+	     
+	    return ans;
+	}
+	
+	
+	static String tr(String s)
+	{
+		int now = 0;
+		while (now + 1 < s.length() && s.charAt(now)== '0')
+			++now;
+		return s.substring(now);
+	}
+	
+	 static ArrayList<Integer> ans;
+	static void dfs(int node,Graph gg,int cnt,int k,ArrayList<Integer> temp)
+	{
+		if(cnt==k)
+			return;
+		
+		for(Integer each:gg.list[node])
+		{
+			if(each==0)
+			{
+				temp.add(each);
+				ans=new ArrayList<>(temp);
+				temp.remove(temp.size()-1);
+				continue;
+			}
+			temp.add(each);
+			dfs(each,gg,cnt+1,k,temp);
+			temp.remove(temp.size()-1);
+			
+		}
+		
+		return;
+	}
+	
+	
+	static boolean isPrime(long n)
+    {
+        // Corner cases
+        if (n <= 1)
+            return false;
+        if (n <= 3)
+            return true;
+  
+        // This is checked so that we can skip
+        // middle five numbers in below loop
+        if (n % 2 == 0 || n % 3 == 0)
+            return false;
+  
+        for (int i = 5; i * i <= n; i = i + 6)
+            if (n % i == 0 || n % (i + 2) == 0)
+                return false;
+  
+        return true;
+    }
+	
+	
+	static ArrayList<Integer> commDiv(int a, int b)
+    {
+        // find gcd of a, b
+        int n = gcd(a, b);
+ 
+        // Count divisors of n.
+        ArrayList<Integer> Div=new ArrayList<>();
+        for (int i = 1; i <= Math.sqrt(n); i++) {
+            // if 'i' is factor of n
+            if (n % i == 0) {
+                // check if divisors are equal
+                if (n / i == i)
+                    Div.add(i);
+                else
+                {
+                	Div.add(i);
+                	Div.add(n/i);
+                }
+            }
+        }
+        return Div;
+    }
+	
+	static HashSet<Integer> factors(int x)
+	{
+		HashSet<Integer> a=new HashSet<Integer>();
+		for(int i=2;i*i<=x;i++)
+		{
+			if(x%i==0)
+			{
+				a.add(i);
+				a.add(x/i);
+			}
+		}
+		return a;
+	}
+		
+	
+static class Node
+{
+	int vertex;
+	HashSet<Node> adj;
+	boolean rem;
+	Node(int ver)
+	{
+		vertex=ver;
+		rem=false;
+		adj=new HashSet<Node>();
+	}
+	@Override
+	public String toString()
+	{
+		return vertex+"" "";
+	}
+}
+
+	static class Tuple{
+		int a;
+		int b;
+		int c;
+		public Tuple(int a,int b,int c) {
+			this.a=a;
+			this.b=b;
+			this.c=c;
+		}
+		
+	}
+
+	//function to find prime factors of n
+	static HashMap<Long,Long> findFactors(long n2)
+	{
+		HashMap<Long,Long> ans=new HashMap<>();
+		if(n2%2==0)
+		{
+			ans.put(2L, 0L);
+//			cnt++;
+			while((n2&1)==0)
+			{
+				n2=n2>>1;
+				ans.put(2L, ans.get(2L)+1);
+//				
+			}
+				
+		}
+		for(long i=3;i*i<=n2;i+=2)
+		{
+			if(n2%i==0)
+			{
+				ans.put((long)i, 0L);
+//				cnt++;
+				while(n2%i==0)
+				{
+					n2=n2/i;
+					ans.put((long)i, ans.get((long)i)+1);
+					
+				}
+			}
+		}
+		if(n2!=1)
+		{
+			ans.put(n2, ans.getOrDefault(n2, (long) 0)+1);
+			
+		}
+			
+		return ans;
+	}
+	
+
+	//fenwick tree implementaion
+	static class fwt
+	{
+		int n;
+		long BITree[];
+		fwt(int n)
+		{
+			this.n=n;
+			BITree=new long[n+1];
+		}
+		
+		fwt(int arr[], int n)
+		{
+			this.n=n;
+			BITree=new long[n+1];
+			for(int i = 0; i < n; i++)
+			updateBIT(n, i, arr[i]);
+		 }
+		
+		   long getSum(int index)
+		   {
+		       long sum = 0;
+		       index = index + 1;
+		       while(index>0)
+		       {
+		           sum += BITree[index];
+		           index -= index & (-index);
+		       }
+		       return sum;
+		   }
+		   void updateBIT(int n, int index,int val)
+		   {
+		       index = index + 1;
+		       while(index <= n)
+		       {
+		       BITree[index] += val;
+		       index += index & (-index);
+		       }
+		   }
+		   void print()
+		   {
+			    for(int i=0;i<n;i++)
+			    out.print(getSum(i)+"" "");
+			    out.println();
+		   }
+	}
+
+	
+	class sparseTable{
+	int n;
+	long[][]dp;
+	int log2[];
+	int P;
+	
+	void buildTable(long[] arr)
+	{
+		n=arr.length;
+		P=(int)Math.floor(Math.log(n)/Math.log(2));
+		
+		log2=new int[n+1];
+		log2[0]=log2[1]=0;
+		for(int i=2;i<=n;i++)
+		{
+			log2[i]=log2[i/2]+1;
+		}
+		dp=new long[P+1][n];
+		for(int i=0;i<n;i++)
+		{
+			dp[0][i]=arr[i];
+		}
+		
+		for(int p=1;p<=P;p++)
+		{
+			for(int i=0;i+(1<<p)<=n;i++)
+			{
+				long left=dp[p-1][i];
+				long right=dp[p-1][i+(1<<(p-1))];
+				dp[p][i]=Math.max(left, right);
+			}
+		}
+	}
+	
+	
+	long maxQuery(int l,int r)
+	{
+		int len=r-l+1;
+		int p=(int)Math.floor(log2[len]);
+		long left=dp[p][l];
+		long right=dp[p][r-(1<<p)+1];
+		return Math.max(left, right);
+	}
+}
+
+	
+	
+	
+	//Function to find number of set bits
+	static int setBitNumber(long n)
+    {
+        if (n == 0)
+            return 0;
+ 
+        int msb = 0;
+        n = n / 2;
+ 
+        while (n != 0) {
+            n = n / 2;
+            msb++;
+        }
+ 
+        return msb;
+    }
+ 
+	
+	
+	static int getFirstSetBitPos(long n)
+    {
+        return (int)((Math.log10(n & -n)) / Math.log10(2)) + 1;
+    }
+	
+	
+	static ArrayList<Integer> primes;
+	static HashSet<Integer> primeSet;
+	static boolean prime[];
+	static void sieveOfEratosthenes(int n)
+    {
+        // Create a boolean array
+        // ""prime[0..n]"" and
+        // initialize all entries
+        // it as true. A value in
+        // prime[i] will finally be
+        // false if i is Not a
+        // prime, else true.
+       prime= new boolean[n + 1];
+        for (int i = 2; i <= n; i++)
+            prime[i] = true;
+        
+        for (int p = 2; p * p <= n; p++)
+        {
+            // If prime[p] is not changed, then it is a
+            // prime
+            if (prime[p] == true)
+            {
+                // Update all multiples of p
+                for (int i = p * p; i <= n; i += p)
+                    prime[i] = false;
+            }
+        }
+ 
+        // Print all prime numbers
+        for (int i = 2; i <= n; i++)
+        {
+            if (prime[i] == true)
+               primeSet.add(i);
+        }
+    }
+	
+	
+	
+	static long mod(long a, long b) {
+		  long c = a % b;
+		  return (c < 0) ? c + b : c;
+		}
+	
+	static void swap(long arr[],int i,int j)
+	{
+		long temp=arr[i];
+		arr[i]=arr[j];
+		arr[j]=temp;
+	}
+
+	
+	
+	static boolean util(int a,int b,int c)
+	{
+		if(b>a)util(b, a, c);
+		
+		while(c>=a)
+		{
+			c-=a;
+			if(c%b==0)
+				return true;
+		}
+		
+		
+		return (c%b==0);
+	}
+	
+	
+	
+	static void flag(boolean flag)
+	   {
+	       out.println(flag ? ""YES"" : ""NO"");
+	       out.flush();
+	   }
+	  
+	
+	static void print(int a[])
+	  {
+	     int n=a.length;
+	     for(int i=0;i<n;i++)
+	       {
+	          out.print(a[i]+"" "");
+	       }
+	     out.println();
+	     out.flush();
+	  }
+	static void print(long a[])
+	  {
+	     int n=a.length;
+	     for(int i=0;i<n;i++)
+	       {
+	          out.print(a[i]+"" "");
+	       }
+	     out.println();
+	     out.flush();
+	  } 
+	static void print_int(ArrayList<Integer> al)
+	  {
+	     int si=al.size();
+	     for(int i=0;i<si;i++)
+	       {
+	          out.print(al.get(i)+"" "");
+	       }
+	     out.println();
+	     out.flush();
+	  }
+	static void print_long(ArrayList<Long> al)
+	  {
+	     int si=al.size();
+	     for(int i=0;i<si;i++)
+	       {
+	          out.print(al.get(i)+"" "");
+	       }
+	     out.println();
+	     out.flush();
+	  }
+	  
+	static void printYesNo(boolean condition)
+	{
+		if (condition) {
+			out.println(""YES"");
+		}
+		else {
+			out.println(""NO"");
+		}
+	}
+	
+	
+	static int LowerBound(int a[], int x) 
+	 { // x is the target value or key
+	  int l=-1,r=a.length;
+	  while(l+1<r) {
+	    int m=(l+r)>>>1;
+	    if(a[m]>=x) r=m;
+	    else l=m;
+	  }
+	  return r;
+	}
+	
+	
+	static int lowerIndex(int arr[], int n, int x)
+    {
+        int l = 0, h = n - 1;
+        while (l <= h)
+        {
+            int mid = (l + h) / 2;
+            if (arr[mid] >= x)
+                h = mid - 1;
+            else
+                l = mid + 1;
+        }
+        return l;
+    }
+	
+	
+	    // function to find last index <= y
+    static int upperIndex(int arr[], int n, int y)
+    {
+        int l = 0, h = n - 1;
+        while (l <= h)
+        {
+            int mid = (l + h) / 2;
+            if (arr[mid] <= y)
+                l = mid + 1;
+            else
+                h = mid - 1;
+        }
+        return h;
+    }
+    static int upperIndex(long arr[], int n, long y)
+    {
+    	int l = 0, h = n - 1;
+    	while (l <= h)
+    	{
+    		int mid = (l + h) / 2;
+    		if (arr[mid] <= y)
+    			l = mid + 1;
+    		else
+    			h = mid - 1;
+    	}
+    	return h;
+    }
+     
+	
+	 static int UpperBound(int a[], int x)
+	  {// x is the key or target value
+	    int l=-1,r=a.length;
+	    while(l+1<r) {
+	       int m=(l+r)>>>1;
+	       if(a[m]<=x) l=m;
+	       else r=m;
+	    }
+	    return l+1;
+	 }
+	 static int UpperBound(long a[], long x)
+	 {// x is the key or target value
+		 int l=-1,r=a.length;
+		 while(l+1<r) {
+			 int m=(l+r)>>>1;
+	       if(a[m]<=x) l=m;
+	       else r=m;
+		 }
+		 return l+1;
+	 }
+	
+	 
+	 static class DisjointUnionSets
+	 {
+	    int[] rank, parent;
+	    int n;
+	    // Constructor
+	    public DisjointUnionSets(int n)
+	    {
+	        rank = new int[n];
+	        parent = new int[n];
+	        this.n = n;
+	        makeSet();
+	    }
+	    // Creates n sets with single item in each
+	    void makeSet()
+	    {
+	        for (int i = 0; i < n; i++)
+	            parent[i] = i;
+	    }
+	    int find(int x)
+	    {
+	        if (parent[x] != x) {
+	            parent[x] = find(parent[x]);
+	        }
+	        return parent[x];
+	    }
+	    // Unites the set that includes x and the set
+	    // that includes x
+	    void union(int x, int y)
+	    {
+	        int xRoot = find(x), yRoot = find(y);
+	        if (xRoot == yRoot)
+	            return;
+	        if (rank[xRoot] < rank[yRoot])
+	            parent[xRoot] = yRoot;
+	        else if (rank[yRoot] < rank[xRoot])
+	         parent[yRoot] = xRoot;
+	        else // if ranks are the same
+	        {
+	         parent[yRoot] = xRoot;
+	            rank[xRoot] = rank[xRoot] + 1;
+	        }
+	        
+//	        if(xRoot!=yRoot)
+//	        	parent[y]=x;
+	    }
+	    
+	    int connectedComponents()
+	    {
+	    	int cnt=0;
+	    	for(int i=0;i<n;i++)
+	    	{
+	    		if(parent[i]==i)
+	    			cnt++;
+	    	}
+	    	return cnt;
+	    }
+	 }
+
+	 
+
+	 
+	 
+	static class Graph
+	  {
+	        int v;
+	        ArrayList<Integer> list[];
+	        Graph(int v)
+	        {
+	            this.v=v;
+	            list=new ArrayList[v+1];
+	            for(int i=1;i<=v;i++)
+	                list[i]=new ArrayList<Integer>();
+	        }
+	        void addEdge(int a, int b)
+	        {
+	            this.list[a].add(b);
+	        }
+	    }
+	
+	
+	
+//	static class GraphMap{
+//		Map<String,ArrayList<String>> graph;
+//		GraphMap() {
+//			// TODO Auto-generated constructor stub
+//			graph=new HashMap<String,ArrayList<String>>();
+//			
+//		}
+//		void addEdge(String a,String b)
+//		{
+//			if(graph.containsKey(a))
+//			this.graph.get(a).add(b);
+//			else {
+//				this.graph.put(a, new ArrayList<>());
+//				this.graph.get(a).add(b);
+//			}
+//		}
+//	}
+//	static void dfsMap(GraphMap g,HashSet<String> vis,String src,int ok)
+//	{
+//		vis.add(src);
+//		
+//		if(g.graph.get(src)!=null)
+//		{
+//			for(String each:g.graph.get(src))
+//			{
+//				if(!vis.contains(each))
+//				{
+//					dfsMap(g, vis, each, ok+1);
+//				}
+//			}
+//		}
+//		
+//		cnt=Math.max(cnt, ok);
+//	}
+	static double sum[];
+	static long cnt;
+//	static void DFS(Graph g, boolean[] visited, int u)
+//		{
+//	        visited[u]=true;
+//	        
+//	        for(int i=0;i<g.list[u].size();i++)
+//	        {
+//	            int v=g.list[u].get(i);
+//	            
+//	            if(!visited[v])
+//	            {
+//	            	cnt1=cnt1*2;
+//	            	DFS(g, visited, v);
+//	            
+//	            }
+//	            
+//	        }
+//	       
+//
+//	  } 
+	
+	
+	  
+	 static class Pair implements Comparable<Pair>
+	    {
+	       int x;
+	       int y;
+	       Pair(int x,int y)
+	        {
+	           this.x=x;
+	           this.y=y;
+	          
+	        }
+		@Override
+		public int compareTo(Pair o) {
+			// TODO Auto-generated method stub
+			return this.x-o.x;
+		}
+	       
+	       
+	       
+	    }
+	   
+	static long sum_array(int a[])
+	 {
+	    int n=a.length;
+	    long sum=0;
+	    for(int i=0;i<n;i++)
+	     sum+=a[i];
+	    return sum;
+	 }
+	static long sum_array(long a[])
+	 {
+	    int n=a.length;
+	    long sum=0;
+	    for(int i=0;i<n;i++)
+	     sum+=a[i];
+	    return sum;
+	 }
+
+	 static void sort(int[] a) 
+	   {
+			ArrayList<Integer> l=new ArrayList<>();
+			for (int i:a) l.add(i);
+			Collections.sort(l);
+			for (int i=0; i<a.length; i++) a[i]=l.get(i);
+		}
+	static void sort(long[] a) 
+	   {
+			ArrayList<Long> l=new ArrayList<>();
+			for (long i:a) l.add(i);
+			Collections.sort(l);
+			for (int i=0; i<a.length; i++) a[i]=l.get(i);
+		}
+
+	static void reverse_array(int a[])
+	 {
+	    int n=a.length;
+	    int i,t; 
+	    for (i = 0; i < n / 2; i++) { 
+	            t = a[i]; 
+	            a[i] = a[n - i - 1]; 
+	            a[n - i - 1] = t; 
+	        } 
+	 }
+	static void reverse_array(long a[])
+	 {
+	    int n=a.length;
+	    int i; long t; 
+	    for (i = 0; i < n / 2; i++) { 
+	            t = a[i]; 
+	            a[i] = a[n - i - 1]; 
+	            a[n - i - 1] = t; 
+	        } 
+	 }
+//	 static long modInverse(long a, long m)
+//		    {
+//		        long g = gcd(a, m);
+//		       
+//		          return   power(a, m - 2, m);
+//		        
+//		    }
+	static long power(long x, long y)
+	 {
+	   long res = 1;
+	   x = x % mod;
+	   if (x == 0)
+	     return 0;
+	   while (y > 0)
+	   {
+	    if ((y & 1) != 0)
+	    res = (res * x) % mod;
+	   
+	    y = y >> 1; // y = y/2
+	    x = (x * x) % mod;
+	   }
+	   return res;
+	 }
+	static int power(int x, int y)
+	{
+		int res = 1;
+		x = x % mod;
+		if (x == 0)
+			return 0;
+		while (y > 0)
+		{
+			if ((y & 1) != 0)
+				res = (res * x) % mod;
+			
+			y = y >> 1; // y = y/2
+	    x = (x * x) % mod;
+		}
+		return res;
+	}
+	static long gcd(long a, long b) 
+	    { 
+			
+	        if (a == 0) 
+	            return b; 
+	         //cnt+=a/b;
+	        return gcd(b%a,a); 
+	    } 
+	static int gcd(int a, int b) 
+	    { 
+	        if (a == 0) 
+	            return b; 
+	          
+	        return gcd(b%a, a); 
+	    } 
+
+	   static class FastReader{
+	 
+	        byte[] buf = new byte[2048];
+	        int index, total;
+	        InputStream in;
+	 
+	        FastReader(InputStream is) {
+	            in = is;
+	        }
+	 
+	        int scan() throws IOException {
+	            if (index >= total) {
+	                index = 0;
+	                total = in.read(buf);
+	                if (total <= 0) {
+	                    return -1;
+	                }
+	            }
+	            return buf[index++];
+	        }
+	 
+	        String next() throws IOException {
+	            int c;
+	            for (c = scan(); c <= 32; c = scan());
+	            StringBuilder sb = new StringBuilder();
+	            for (; c > 32; c = scan()) {
+	                sb.append((char) c);
+	            }
+	            return sb.toString();
+	        }
+	 
+	        int nextInt() throws IOException {
+	            int c, val = 0;
+	            for (c = scan(); c <= 32; c = scan());
+	            boolean neg = c == '-';
+	            if (c == '-' || c == '+') {
+	                c = scan();
+	            }
+	            for (; c >= '0' && c <= '9'; c = scan()) {
+	                val = (val << 3) + (val << 1) + (c & 15);
+	            }
+	            return neg ? -val : val;
+	        }
+	 
+	        long nextLong() throws IOException {
+	            int c;
+	            long val = 0;
+	            for (c = scan(); c <= 32; c = scan());
+	            boolean neg = c == '-';
+	            if (c == '-' || c == '+') {
+	                c = scan();
+	            }
+	            for (; c >= '0' && c <= '9'; c = scan()) {
+	                val = (val << 3) + (val << 1) + (c & 15);
+	            }
+	            return neg ? -val : val;
+	        }
+	    }
+	   
+	    static class Reader 
+	    { 
+	        final private int BUFFER_SIZE = 1 << 16; 
+	        private DataInputStream din; 
+	        private byte[] buffer; 
+	        private int bufferPointer, bytesRead; 
+	  
+	        public Reader() 
+	        { 
+	            din = new DataInputStream(System.in); 
+	            buffer = new byte[BUFFER_SIZE]; 
+	            bufferPointer = bytesRead = 0; 
+	        } 
+	  
+	        public Reader(String file_name) throws IOException 
+	        { 
+	            din = new DataInputStream(new FileInputStream(file_name)); 
+	            buffer = new byte[BUFFER_SIZE]; 
+	            bufferPointer = bytesRead = 0; 
+	        } 
+	  
+	        public String readLine() throws IOException 
+	        { 
+	            byte[] buf = new byte[64]; // line length 
+	            int cnt = 0, c; 
+	            while ((c = read()) != -1) 
+	            { 
+	                if (c == '\n') 
+	                    break; 
+	                buf[cnt++] = (byte) c; 
+	            } 
+	            return new String(buf, 0, cnt); 
+	        } 
+	  
+	        public int nextInt() throws IOException 
+	        { 
+	            int ret = 0; 
+	            byte c = read(); 
+	            while (c <= ' ') 
+	                c = read(); 
+	            boolean neg = (c == '-'); 
+	            if (neg) 
+	                c = read(); 
+	            do
+	            { 
+	                ret = ret * 10 + c - '0'; 
+	            }  while ((c = read()) >= '0' && c <= '9'); 
+	  
+	            if (neg) 
+	                return -ret; 
+	            return ret; 
+	        } 
+	  
+	        public long nextLong() throws IOException 
+	        { 
+	            long ret = 0; 
+	            byte c = read(); 
+	            while (c <= ' ') 
+	                c = read(); 
+	            boolean neg = (c == '-'); 
+	            if (neg) 
+	                c = read(); 
+	            do { 
+	                ret = ret * 10 + c - '0'; 
+	            } 
+	            while ((c = read()) >= '0' && c <= '9'); 
+	            if (neg) 
+	                return -ret; 
+	            return ret; 
+	        } 
+	  
+	        public double nextDouble() throws IOException 
+	        { 
+	            double ret = 0, div = 1; 
+	            byte c = read(); 
+	            while (c <= ' ') 
+	                c = read(); 
+	            boolean neg = (c == '-'); 
+	            if (neg) 
+	                c = read(); 
+	  
+	            do { 
+	                ret = ret * 10 + c - '0'; 
+	            } 
+	            while ((c = read()) >= '0' && c <= '9'); 
+	  
+	            if (c == '.') 
+	            { 
+	                while ((c = read()) >= '0' && c <= '9') 
+	                { 
+	                    ret += (c - '0') / (div *= 10); 
+	                } 
+	            } 
+	  
+	            if (neg) 
+	                return -ret; 
+	            return ret; 
+	        } 
+	  
+	        private void fillBuffer() throws IOException 
+	        { 
+	            bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE); 
+	            if (bytesRead == -1) 
+	                buffer[0] = -1; 
+	        } 
+	  
+	        private byte read() throws IOException 
+	        { 
+	            if (bufferPointer == bytesRead) 
+	                fillBuffer(); 
+	            return buffer[bufferPointer++]; 
+	        } 
+	  
+	        public void close() throws IOException 
+	        { 
+	            if (din == null) 
+	                return; 
+	            din.close(); 
+	        } 
+	    }
+	  static  PrintWriter out=new PrintWriter(System.out);
+	  static int int_max=Integer.MAX_VALUE;
+	  static int int_min=Integer.MIN_VALUE;
+	  static long long_max=Long.MAX_VALUE;
+	  static long long_min=Long.MIN_VALUE;
+
+}
+
+
+
+
+",1
+316c9955,e7370eec,"import java.io.DataInputStream;
+import java.io.IOException;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.util.LinkedList;
+
+public class C {
+
+    private static boolean[] visited;
+    private static Node[] nodes;
+
+    private static void run() throws IOException {
+        int n = in.nextInt();
+        nodes = new Node[n];
+        for (int i = 0; i < n; i++) {
+            nodes[i] = new Node();
+            nodes[i].index = i;
+            nodes[i].l = in.nextInt();
+            nodes[i].r = in.nextInt();
+        }
+        for (int i = 0; i < n - 1; i++) {
+            int x = in.nextInt() - 1;
+            int y = in.nextInt() - 1;
+            nodes[x].next.add(y);
+            nodes[y].next.add(x);
+        }
+
+        visited = new boolean[n];
+        dfs(0);
+        out.println(Math.max(nodes[0].ans_l, nodes[0].ans_r));
+    }
+
+    private static void dfs(int now) {
+        visited[now] = true;
+
+        for (int next : nodes[now].next) {
+            if (visited[next]) continue;
+
+            dfs(next);
+            nodes[now].ans_l += Math.max(nodes[next].ans_l + Math.abs(nodes[now].l - nodes[next].l), nodes[next].ans_r + Math.abs(nodes[now].l - nodes[next].r));
+            nodes[now].ans_r += Math.max(nodes[next].ans_l + Math.abs(nodes[now].r - nodes[next].l), nodes[next].ans_r + Math.abs(nodes[now].r - nodes[next].r));
+        }
+    }
+
+    static class Node {
+        int index;
+        long l, r;
+        long ans_l, ans_r;
+        LinkedList<Integer> next = new LinkedList<>();
+    }
+
+    public static void main(String[] args) throws IOException {
+        in = new Reader();
+        out = new PrintWriter(new OutputStreamWriter(System.out));
+
+        int t = in.nextInt();
+        for (int i = 0; i < t; i++) {
+            run();
+        }
+
+        out.flush();
+        in.close();
+        out.close();
+    }
+
+    private static int gcd(int a, int b) {
+        if (a == 0 || b == 0)
+            return 0;
+        while (b != 0) {
+            int tmp;
+            tmp = a % b;
+            a = b;
+            b = tmp;
+        }
+        return a;
+    }
+
+    static final long mod = 1000000007;
+
+    static long pow_mod(long a, long b) {
+        long result = 1;
+        while (b != 0) {
+            if ((b & 1) != 0) result = (result * a) % mod;
+            a = (a * a) % mod;
+            b >>= 1;
+        }
+        return result;
+    }
+
+    private static long multiplied_mod(long... longs) {
+        long ans = 1;
+        for (long now : longs) {
+            ans = (ans * now) % mod;
+        }
+        return ans;
+    }
+
+    @SuppressWarnings(""FieldCanBeLocal"")
+    private static Reader in;
+    private static PrintWriter out;
+
+    private static int[] read_int_array(int len) throws IOException {
+        int[] a = new int[len];
+        for (int i = 0; i < len; i++) {
+            a[i] = in.nextInt();
+        }
+        return a;
+    }
+
+    private static long[] read_long_array(int len) throws IOException {
+        long[] a = new long[len];
+        for (int i = 0; i < len; i++) {
+            a[i] = in.nextLong();
+        }
+        return a;
+    }
+
+    private static void print_array(int[] array) {
+        for (int now : array) {
+            out.print(now);
+            out.print(' ');
+        }
+        out.println();
+    }
+
+    private static void print_array(long[] array) {
+        for (long now : array) {
+            out.print(now);
+            out.print(' ');
+        }
+        out.println();
+    }
+
+    static class Reader {
+        private static final int BUFFER_SIZE = 1 << 16;
+        private final DataInputStream din;
+        private final byte[] buffer;
+        private int bufferPointer, bytesRead;
+
+        Reader() {
+            din = new DataInputStream(System.in);
+            buffer = new byte[BUFFER_SIZE];
+            bufferPointer = bytesRead = 0;
+        }
+
+        public String readLine() throws IOException {
+            final byte[] buf = new byte[1024]; // line length
+            int cnt = 0, c;
+            while ((c = read()) != -1) {
+                if (c == '\n') {
+                    break;
+                }
+                buf[cnt++] = (byte) c;
+            }
+            return new String(buf, 0, cnt);
+        }
+
+        public int nextSign() throws IOException {
+            byte c = read();
+            while ('+' != c && '-' != c) {
+                c = read();
+            }
+            return '+' == c ? 0 : 1;
+        }
+
+        private static boolean isSpaceChar(int c) {
+            return !(c >= 33 && c <= 126);
+        }
+
+        public int skip() throws IOException {
+            int b;
+            // noinspection ALL
+            while ((b = read()) != -1 && isSpaceChar(b)) {
+                ;
+            }
+            return b;
+        }
+
+        public char nc() throws IOException {
+            return (char) skip();
+        }
+
+        public String next() throws IOException {
+            int b = skip();
+            final StringBuilder sb = new StringBuilder();
+            while (!isSpaceChar(b)) { // when nextLine, (isSpaceChar(b) && b != ' ')
+                sb.appendCodePoint(b);
+                b = read();
+            }
+            return sb.toString();
+        }
+
+        public int nextInt() throws IOException {
+            int ret = 0;
+            byte c = read();
+            while (c <= ' ') {
+                c = read();
+            }
+            final boolean neg = c == '-';
+            if (neg) {
+                c = read();
+            }
+            do {
+                ret = ret * 10 + c - '0';
+            } while ((c = read()) >= '0' && c <= '9');
+
+            if (neg) {
+                return -ret;
+            }
+            return ret;
+        }
+
+        public long nextLong() throws IOException {
+            long ret = 0;
+            byte c = read();
+            while (c <= ' ') {
+                c = read();
+            }
+            final boolean neg = c == '-';
+            if (neg) {
+                c = read();
+            }
+            do {
+                ret = ret * 10 + c - '0';
+            }
+            while ((c = read()) >= '0' && c <= '9');
+            if (neg) {
+                return -ret;
+            }
+            return ret;
+        }
+
+        public double nextDouble() throws IOException {
+            double ret = 0, div = 1;
+            byte c = read();
+            while (c <= ' ') {
+                c = read();
+            }
+            final boolean neg = c == '-';
+            if (neg) {
+                c = read();
+            }
+
+            do {
+                ret = ret * 10 + c - '0';
+            }
+            while ((c = read()) >= '0' && c <= '9');
+
+            if (c == '.') {
+                while ((c = read()) >= '0' && c <= '9') {
+                    ret += (c - '0') / (div *= 10);
+                }
+            }
+
+            if (neg) {
+                return -ret;
+            }
+            return ret;
+        }
+
+        private void fillBuffer() throws IOException {
+            bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
+            if (bytesRead == -1) {
+                buffer[0] = -1;
+            }
+        }
+
+        private byte read() throws IOException {
+            if (bufferPointer == bytesRead) {
+                fillBuffer();
+            }
+            return buffer[bufferPointer++];
+        }
+
+        public void close() throws IOException {
+            din.close();
+        }
+
+    }
+}","//package codeforces.round722div2;
+
+import java.io.*;
+import java.util.*;
+
+public class C {
+    static InputReader in;
+    static PrintWriter out;
+
+    public static void main(String[] args) {
+        //initReaderPrinter(true);
+        initReaderPrinter(false);
+        solve(in.nextInt());
+        //solve(1);        
+    }
+    static int n;
+    static List<Integer>[] adj;
+    static long[] l, r;
+    static void solve(int testCnt) {
+        for (int testNumber = 0; testNumber < testCnt; testNumber++) {
+            n = in.nextInt();
+            adj = new List[n + 1];
+            for(int i = 0; i <= n; i++) {
+                adj[i] = new ArrayList<>();
+            }
+            l = new long[n + 1];
+            r = new long[n + 1];
+            for(int i = 1; i <= n; i++) {
+                l[i] = in.nextInt();
+                r[i] = in.nextInt();
+            }
+            for(int i = 0; i < n - 1; i++) {
+                int u = in.nextInt();
+                int v = in.nextInt();
+                adj[u].add(v);
+                adj[v].add(u);
+            }
+            long[] ans = dfs(1, 0);
+            out.println(Math.max(ans[0], ans[1]));
+        }
+        out.close();
+    }
+
+    static long[] dfs(int curr, int par) {
+        long[] ans = new long[2];
+        for(int next : adj[curr]) {
+            if(next == par) continue;
+            long[] nextAns = dfs(next, curr);
+            ans[0] += Math.max(nextAns[0] + Math.abs(l[curr] - l[next]), nextAns[1] + Math.abs(l[curr] - r[next]));
+            ans[1] += Math.max(nextAns[0] + Math.abs(r[curr] - l[next]), nextAns[1] + Math.abs(r[curr] - r[next]));
+        }
+        return ans;
+    }
+
+    static void initReaderPrinter(boolean test) {
+        if (test) {
+            try {
+                in = new InputReader(new FileInputStream(""src/input.in""));
+                out = new PrintWriter(new FileOutputStream(""src/output.out""));
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+        } else {
+            in = new InputReader(System.in);
+            out = new PrintWriter(System.out);
+        }
+    }
+
+    static class InputReader {
+        BufferedReader br;
+        StringTokenizer st;
+
+        InputReader(InputStream stream) {
+            try {
+                br = new BufferedReader(new InputStreamReader(stream), 32768);
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }
+
+        String next() {
+            while (st == null || !st.hasMoreTokens()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+
+        String nextLine() {
+            String str = """";
+            try {
+                str = br.readLine();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+        }
+
+        Integer[] nextIntArray(int n) {
+            Integer[] a = new Integer[n];
+            for (int i = 0; i < n; i++) a[i] = nextInt();
+            return a;
+        }
+
+        int[] nextIntArrayPrimitive(int n) {
+            int[] a = new int[n];
+            for (int i = 0; i < n; i++) a[i] = nextInt();
+            return a;
+        }
+
+        int[] nextIntArrayPrimitiveOneIndexed(int n) {
+            int[] a = new int[n + 1];
+            for (int i = 1; i <= n; i++) a[i] = nextInt();
+            return a;
+        }
+
+        Long[] nextLongArray(int n) {
+            Long[] a = new Long[n];
+            for (int i = 0; i < n; i++) a[i] = nextLong();
+            return a;
+        }
+
+        long[] nextLongArrayPrimitive(int n) {
+            long[] a = new long[n];
+            for (int i = 0; i < n; i++) a[i] = nextLong();
+            return a;
+        }
+
+        long[] nextLongArrayPrimitiveOneIndexed(int n) {
+            long[] a = new long[n + 1];
+            for (int i = 1; i <= n; i++) a[i] = nextLong();
+            return a;
+        }
+
+        String[] nextStringArray(int n) {
+            String[] g = new String[n];
+            for (int i = 0; i < n; i++) g[i] = next();
+            return g;
+        }
+    }
+}",0
+26e699de,e99c14b9,"//package Task1;
+
+import java.util.Scanner;
+
+public class Menorah {
+    static int MOD9= 1000000000;
+
+    public static void main(String[] args){
+
+        Scanner sc= new Scanner(System.in);
+        int numberTest=sc.nextInt();
+        while(numberTest-->0){
+            int n=sc.nextInt();
+            char[] s=new char[n+5];
+            char[] t=new char[n+5];
+            String ss=sc.next();
+            String tt=sc.next();
+            s=ss.toCharArray();
+            t=tt.toCharArray();
+            int cntax = 0, cntbx = 0, same = 0;
+            int ans=MOD9;
+            for(int i=0; i<n; i++){
+                if(s[i]=='1')cntax++;
+                if(t[i]=='1')cntbx++;
+                if(s[i]==t[i])same++;
+            }
+            if(same==n){
+                System.out.println(0);
+                continue;
+            }
+            else if (cntax==0){
+                System.out.println(-1);
+                continue;
+            }
+            if(cntax==cntbx){
+                ans=Math.min(ans,n-same);
+            }
+            if(n-cntax+1==cntbx)ans=Math.min(ans,same);
+            if(ans<MOD9) System.out.println(ans);
+            else System.out.println(-1);
+
+
+
+        }
+
+    }
+}
+","import java.io.*;
+
+import java.util.*;
+/*
+
+
+
+
+*/
+
+ 
+ public class A{
+	static FastReader sc=null;
+	
+	public static void main(String[] args) {
+		sc=new FastReader();
+		int t=sc.nextInt();
+		
+		for(int tt=0;tt<t;tt++) {
+			int n=sc.nextInt();
+			char a[]=sc.next().toCharArray(),b[]=sc.next().toCharArray();
+			
+			int fa=0,fb=0,da=0,db=0,sum=0;
+			boolean dif=false;
+			for(int i=0;i<n;i++) {
+				sum+=a[i]-'0';
+				if(a[i]!=b[i]) {
+					dif=true;
+					if(a[i]=='1')fa++;
+					else fb++;
+				}
+				else {
+					if(a[i]=='1')da++;
+					else db++;
+				}
+			}
+			
+			if(sum==0) {
+				System.out.println(dif?-1:0);
+				continue;
+			}
+			
+			int ans=n+1;
+			
+			if(fa==fb) ans=(fa+fb);
+			if(da==db+1) ans=Math.min(da+db, ans);
+			
+			System.out.println(ans==(n+1)?-1:ans);
+		}
+	}
+	
+	static int[] ruffleSort(int a[]) {
+		ArrayList<Integer> al=new ArrayList<>();
+		for(int i:a)al.add(i);
+		Collections.sort(al);
+		for(int i=0;i<a.length;i++)a[i]=al.get(i);
+		return a;
+	}
+	
+	static void print(int a[]) {
+		for(int e:a) {
+			System.out.print(e+"" "");
+		}
+		System.out.println();
+	}
+	
+	static class FastReader{
+		
+		StringTokenizer st=new StringTokenizer("""");
+		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+		
+		String next() {
+			while(!st.hasMoreTokens()) 
+				try {
+					st=new StringTokenizer(br.readLine());
+				}
+			   catch(IOException e){
+				   e.printStackTrace();
+			   }
+			return st.nextToken();
+		}
+		
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+		
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+		
+		int[] readArray(int n) {
+			int a[]=new int[n];
+			for(int i=0;i<n;i++)a[i]=sc.nextInt();
+			return a;
+		}
+	}
+	
+	
+}
+",0
+1162c08f,a4d6775d,"import java.util.*;
+
+public class CodeForces1525C{
+	public static void main(String[] args) {
+		Scanner sc=new Scanner(System.in);
+		ArrayList<Integer> o=new ArrayList<Integer>(), e=new ArrayList<Integer>();
+		int n = sc.nextInt(),dp[][]=new int[n+1][n+1];
+		for(int i=1;i<=n;i++){
+			int x=sc.nextInt();
+			if(x==1)o.add(i);
+			else e.add(i);
+		}
+		for(int i=1;i<=o.size();i++){
+			dp[i][i]=dp[i-1][i-1]+Math.abs(o.get(i-1)-e.get(i-1));
+			for(int j=i+1;j<=e.size();j++)
+				dp[i][j]=Math.min(dp[i][j-1],dp[i-1][j-1]+Math.abs(o.get(i-1)-e.get(j-1)));
+		}
+		System.out.println(dp[o.size()][e.size()]);
+	}
+}
+
+","import java.io.*;
+import java.util.*;
+ 
+public class ArmChairs {
+    
+ 
+    public static int solution(int n, int[] arr) {
+ 
+        ArrayList<Integer> one = new ArrayList<Integer>();
+        ArrayList<Integer> zero = new ArrayList<Integer>();
+ 
+        for (int i = 0; i < n; i++) {
+            if (arr[i] == 1) {
+                one.add(i);
+            } else {
+                zero.add(i);
+            }
+        }
+ 
+        int[][] dp = new int[one.size() + 1][zero.size() + 1];
+ 
+        for (int i = 1; i <= one.size(); i++) {
+            dp[i][i] = dp[i - 1][i - 1] + Math.abs(one.get(i - 1) - zero.get(i - 1));
+            for (int j = i + 1; j <= zero.size(); j++) {
+                dp[i][j] = Math.min(dp[i][j - 1], dp[i - 1][j - 1] + Math.abs(one.get(i - 1) - zero.get(j - 1)));
+            }
+        }
+ 
+        return dp[one.size()][zero.size()];
+    }
+ 
+ 
+    public static void main(String[] args) throws IOException{
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        BufferedWriter log = new BufferedWriter(new OutputStreamWriter(System.out));
+ 
+        int n = Integer.parseInt(br.readLine());
+ 
+        String[] s = br.readLine().split("" "");
+        int[] arr = new int[n];
+        for (int i = 0; i < n; i++) {
+            arr[i] = Integer.parseInt(s[i]);
+        } 
+ 
+        log.write(Integer.toString(solution(n, arr)) + ""\n"");
+        log.flush();
+        
+    }
+ 
+}",1
+2120328e,b790ef12,"/*****  --->         :)    Vijender  Srivastava      (:       <---       *****/
+import java.util.*;
+import java.lang.*;
+import java.io.*;
+public class Main  
+{
+    static FastReader sc =new FastReader();
+    static PrintWriter out=new PrintWriter(System.out);
+    static int mod=10000007;
+   static StringBuilder sb=new StringBuilder();
+    /* start */
+       public static void main(String [] args)
+    {
+            int t = i();
+            while(t-->0)
+            {
+                int n = i();
+                int a[] = input(n);
+                char c[] = inputC();
+                ArrayList<Integer> b = new ArrayList<>();
+                ArrayList<Integer> r = new ArrayList<>();
+                for(int i=0;i<n;i++)
+                {
+                    if(c[i]=='R')
+                    r.add(a[i]);
+                    else 
+                    b.add(a[i]);
+                }
+                Collections.sort(b);
+                Collections.sort(r,Collections.reverseOrder());
+                boolean is = true;
+                int cnt = 1;
+                for(int i=0;i<b.size();i++)
+                {
+                    if(b.get(i)<cnt)
+                    {
+                        is = false;
+                        break;
+                    }
+                    cnt++;
+                }
+                for(int i=0;i<r.size();i++)
+                {
+                    if(r.get(i)>n-i)
+                    {
+                        is = false;
+                        break;
+                    }
+                }
+
+                out.println(is==true?""YES"":""NO"");
+            }
+            out.close();
+    }
+
+    
+    /* end */
+    static class FastReader 
+    { 
+        BufferedReader br; 
+        StringTokenizer st; 
+
+        public FastReader() 
+        { 
+            br = new BufferedReader(new
+                     InputStreamReader(System.in)); 
+        } 
+
+        String next() 
+        { 
+            while (st == null || !st.hasMoreElements()) 
+            { 
+                try
+                { 
+                    st = new StringTokenizer(br.readLine()); 
+                } 
+                catch (IOException  e) 
+                { 
+                    e.printStackTrace(); 
+                } 
+            } 
+            return st.nextToken(); 
+        } 
+
+        int nextInt() 
+        { 
+            return Integer.parseInt(next()); 
+        } 
+
+        long nextLong() 
+        { 
+            return Long.parseLong(next()); 
+        } 
+
+        double nextDouble() 
+        { 
+            return Double.parseDouble(next()); 
+        } 
+
+        String nextLine() 
+        { 
+            String str = """"; 
+            try
+            { 
+                str = br.readLine(); 
+            } 
+            catch (IOException e) 
+            { 
+                e.printStackTrace(); 
+            } 
+            return str; 
+        } 
+    } 
+
+    
+    static int i() {
+        return sc.nextInt();
+    }
+
+    static String s() {
+        return sc.next();
+    }
+
+    static long l() {
+        return sc.nextLong();
+    }
+
+    static char[] inputC()
+    {
+        String s = sc.nextLine();
+        return s.toCharArray();
+    }
+
+    static int[] input(int n) {
+        int A[]=new int[n];
+           for(int i=0;i<n;i++) {
+               A[i]=sc.nextInt();
+           }
+        return A;
+    }
+
+    static long[] inputL(int n) {
+        long A[]=new long[n];
+           for(int i=0;i<n;i++) {
+               A[i]=sc.nextLong();
+           }
+           return A;
+    }
+
+    static long[] putL(long a[]) {
+        long A[]=new long[a.length];
+           for(int i=0;i<a.length;i++) {
+               A[i]=a[i];
+           }
+           return A;
+    }
+
+    static String[] inputS(int n) {
+        String A[]=new String[n];
+           for(int i=0;i<n;i++) {
+               A[i]=sc.next();
+           }
+           return A;
+    }
+      
+    static int gcd(int a, int b) 
+     { 
+         if (a == 0) 
+             return b; 
+         return gcd(b % a, a); 
+     } 
+
+     static long gcd(long a, long b) 
+     { 
+         if (a == 0) 
+             return b; 
+         return gcd(b % a, a); 
+     } 
+
+     
+    
+     static String reverse(String s) {
+        StringBuffer p=new StringBuffer(s);
+        p.reverse();
+        return p.toString();
+     }
+
+     static int min(int a,int b) {
+        return Math.min(a, b);
+    }
+    static int min(int a,int b,int c) {
+        return Math.min(a, Math.min(b, c));
+    }
+    static int min(int a,int b,int c,int d) {
+        return Math.min(a, Math.min(b, Math.min(c, d)));
+    }
+
+    static int max(int a,int b) {
+        return Math.max(a, b);
+    }
+    static int max(int a,int b,int c) {
+        return Math.max(a, Math.max(b, c));
+    }
+    static int max(int a,int b,int c,int d) {
+        return Math.max(a, Math.max(b, Math.max(c, d)));
+    }
+    static long min(long a,long b) {
+        return Math.min(a, b);
+    }
+    static long min(long a,long b,long c) {
+        return Math.min(a, Math.min(b, c));
+    }
+    static long min(long a,long b,long c,long d) {
+        return Math.min(a, Math.min(b, Math.min(c, d)));
+    }
+    static long max(long a,long b) {
+        return Math.max(a, b);
+    }
+    static long max(long a,long b,long c) {
+        return Math.max(a, Math.max(b, c));
+    }
+    static long max(long a,long b,long c,long d) {
+        return Math.max(a, Math.max(b, Math.max(c, d)));
+    }
+
+    static long sum(int A[]) {
+        long sum=0;
+        for(int i : A) {
+            sum+=i;
+        }
+        return sum;
+    }
+
+    static long sum(long A[]) {
+        long sum=0;
+        for(long i : A) {
+            sum+=i;
+        }
+        return sum;
+    }
+
+    static void print(int A[]) {
+        for(int i : A) {
+            System.out.print(i+"" "");
+        }
+        System.out.println();
+    }
+
+    static void print(long A[]) {
+        for(long i : A) {
+            System.out.print(i+"" "");
+        }
+        System.out.println();
+    }
+
+    static long mod(long x) {
+          return ((x%mod + mod)%mod);
+    }
+
+    static long power(long x, long y)
+    {
+
+	if(y==0)
+		return 1;
+	if(x==0)
+		return 0;
+    long res = 1;
+    while (y > 0) {
+
+        if (y % 2 == 1)
+            res = (res * x) ;
+
+        y = y >> 1; 
+        x = (x * x);
+    }
+
+    return res;
+    }
+
+    static boolean prime(int n) 
+	    { 
+	        if (n <= 1) 
+	            return false; 
+	        if (n <= 3) 
+	            return true; 
+	        if (n % 2 == 0 || n % 3 == 0) 
+	            return false; 
+	        double sq=Math.sqrt(n);
+	  
+	        for (int i = 5; i <= sq; i = i + 6) 
+	            if (n % i == 0 || n % (i + 2) == 0) 
+	                return false; 
+	        return true; 
+	    } 
+
+     static boolean prime(long n) 
+	    { 
+	        if (n <= 1) 
+	            return false; 
+	        if (n <= 3) 
+	            return true; 
+	        if (n % 2 == 0 || n % 3 == 0) 
+	            return false; 
+	        double sq=Math.sqrt(n);
+	  
+	        for (int i = 5; i <= sq; i = i + 6) 
+	            if (n % i == 0 || n % (i + 2) == 0) 
+	                return false; 
+	        return true; 
+	    } 
+        //pair class
+        private static class Pair implements Comparable<Pair> {
+            int first, second;
+            public Pair(int f, int s) {
+                first = f;
+                second = s;
+            }
+            @Override
+            public int compareTo(Pair p) {
+                if (first > p.first)
+                    return 1;
+                else if (first < p.first)
+                    return -1;
+                else {
+                    if (second > p.second)
+                        return 1;
+                    else if (second < p.second)
+                        return -1;
+                    else
+                        return 0;
+                }
+            }
+     
+        }
+}","import java.io.*;
+import java.util.*;
+public class Main {
+    static class FastReader {
+        BufferedReader br;
+        StringTokenizer st;
+
+        public FastReader() {
+            br = new BufferedReader(
+                    new InputStreamReader(System.in));
+        }
+
+        String next() {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+
+        String nextLine() {
+            String str = """";
+            try {
+                str = br.readLine();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+        }
+    }
+
+    public static void main(String[] args) {
+        FastReader obj = new FastReader();
+        PrintWriter out = new PrintWriter(System.out);
+        int l = obj.nextInt();
+        while (l-- != 0) {
+            int n = obj.nextInt();
+            int[] num = new int[n];
+            for (int i = 0; i < n; i++) num[i] = obj.nextInt();
+            Vector<Integer> red = new Vector<>();
+            Vector<Integer> blue = new Vector<>();
+            String s = obj.next();
+            for (int i = 0; i < s.length(); i++) {
+                if (s.charAt(i) == 'R') red.add(num[i]);
+                else blue.add(num[i]);
+            }
+            Collections.sort(blue);
+            Collections.sort(red);
+            int c = 1, f = 0;
+            for (int i = 0; i < blue.size(); i++) {
+                if (blue.get(i) < c) {
+                    f = 1;
+                    break;
+                }
+                c++;
+            }
+            for (int i = 0; i < red.size(); i++) {
+                if (red.get(i) > c) {
+                    f = 1;
+                    break;
+                }
+                c++;
+            }
+            if (f == 0) out.println(""YES"");
+            else out.println(""NO"");
+        }
+        out.flush();
+    }
+}
+",1
+6e207cbf,e19376ca,"import java.util.*;
+import java.lang.*;
+import java.io.*;
+
+public class Codechef
+{
+	public static void main (String[] args) throws java.lang.Exception
+	{
+        Scanner sc = new Scanner(System.in);
+        int t = sc.nextInt();
+        int sm, n;
+        while(t > 0) {
+            t--;
+            n = sc.nextInt();
+            String s1,s2;
+            s1 = sc.next();
+            s2 = sc.next();
+            int a[] = new int[4];
+            a[0] = 0; a[1] = 0; a[2] = 0; a[3] = 0;
+            for(int i = 0 ; i < n ; i++) {
+                if(s1.charAt(i) == '0'&& s2.charAt(i) == '1') a[0]++;
+                else if(s1.charAt(i) == '1'&& s2.charAt(i) == '0') a[1]++;
+                else if(s1.charAt(i) == '1'&& s2.charAt(i) == '1') a[2]++;
+                else a[3]++;
+            }
+            // System.out.println(a[0] + "" "" + a[1] + "" "" + a[2] + "" "" + a[3]);
+            int n1 = Integer.MAX_VALUE, n2 = Integer.MAX_VALUE, n3 = Integer.MAX_VALUE;
+            
+            if (a[0] == a[1]) {
+                n1 = 2*a[0];
+            }
+            if((a[2] - 1) == a[3]) {
+                // System.out.println(a[3] + 1);
+                n2 = 2*a[3] + 1;
+            } 
+            if((a[3] + 1) == a[2]) {
+                // System.out.println(a[2] + 1);
+                n3 = 2*a[2] + 1;
+            } 
+            int ans = Math.min(n1, Math.min(n2,n3));
+            if(ans == Integer.MAX_VALUE) {
+                System.out.println(""-1"");
+            } else {
+                System.out.println(ans);
+            }
+        }
+	}
+}
+","import java.io.*;
+import java.util.*;
+
+public class new1{
+
+    public static long gcd(long a, long b)
+    {
+        if (a == 0)
+            return b;
+          
+        return gcd(b%a, a);
+    }
+    public static int count(int[] arr, int[] dest) {
+    	int n = arr.length;
+    	int count = 0;
+    	for(int i = 0; i < n; i++) {
+    		if(arr[i] != dest[i]) count++;
+    	}
+    	return count;
+    }
+    
+    
+    
+
+	
+	public static void main(String[] args)  throws IOException{
+    	BufferedWriter output = new BufferedWriter(new OutputStreamWriter(System.out));
+		FastReader s = new FastReader();
+		int t = s.nextInt();
+		
+		
+    	for(int z = 0; z < t; z++) {
+    		int n = s.nextInt();
+    		String str1 = s.next();
+    		String str2 = s.next();
+    		int count1  = 0; int count2 = 0;
+    		for(int i = 0; i < n; i++) {
+    			if(str1.charAt(i) == '1') count1++;
+    			if(str2.charAt(i) == '1') count2++;
+    		}
+    		if(!(count1 == count2 || n - count1 + 1 == count2)) {
+    			System.out.println(-1);
+    			continue;
+    		}
+    		
+    		int[] arr = new int[n];
+    		int[] dest = new int[n];
+    		for(int i = 0; i < n; i++) {
+    			arr[i] = str1.charAt(i) - '0';
+    			dest[i] = str2.charAt(i) - '0';
+    		}
+    		int ans1 = count(arr, dest);
+    		int ans2 = Integer.MAX_VALUE;
+    		int flag = 0;
+    		for(int i = 0; i < n; i++) {
+    			if(flag == 0 && arr[i] == 1 && dest[i] == 1) {
+    				flag = 1;
+    			}
+    			else {
+    				arr[i] = 1 - arr[i];
+    			}
+    		}
+    		//System.out.println(ans1);
+    		if(flag == 1) {
+    			ans2 = Math.min(ans2, count(arr, dest) + 1);
+    		}
+    		else {
+    			for(int i = 0; i < n; i++) {
+    				if(str1.charAt(i) == '1' && flag == 0) {
+    					flag = 1; arr[i] = 1;
+    					break;	
+    				}
+    			}
+    			
+    		}
+    		if(flag == 1) ans2 = Math.min(ans2, count(arr, dest) + 1);
+    		int ans = Integer.MAX_VALUE;
+    		if(count1 == count2) ans = Math.min(ans, ans1);
+    		if(n - count1 + 1 == count2) ans = Math.min(ans, ans2);
+    		System.out.println(ans);
+    		
+    		
+    		
+    	}
+    	//output.flush();
+
+    }
+}
+
+
+class FastReader {
+    BufferedReader br;
+    StringTokenizer st;
+    public FastReader() {
+        br = new BufferedReader(new InputStreamReader(System.in));
+    }
+    String next() {
+        while (st == null || !st.hasMoreElements()) {
+            try {
+                st = new StringTokenizer(br.readLine());
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+        }
+        return st.nextToken();
+    }
+ 
+    public int nextInt() {
+        return Integer.parseInt(next());
+    }
+ 
+    long nextLong() {
+        return Long.parseLong(next());
+    }
+ 
+    double nextDouble() {
+        return Double.parseDouble(next());
+    }
+ 
+    String nextLine() {
+        String str = """";
+        try {
+            str = br.readLine();
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        return str;
+}}",0
+9028caf7,a4e39423,"import java.io.*;
+import java.util.*;
+public class Main {
+    public static void main(String args[])
+    {
+        FastReader input=new FastReader();
+        PrintWriter out=new PrintWriter(System.out);
+        int T=1;
+        while(T-->0)
+        {
+            int n=input.nextInt();
+            int a[]=new int[n];
+            ArrayList<Integer> list=new ArrayList<>();
+            ArrayList<Integer> space=new ArrayList<>();
+            for(int i=0;i<n;i++)
+            {
+                a[i]=input.nextInt();
+                if(a[i]==1)
+                {
+                    list.add(i);
+                }
+                else
+                {
+                    space.add(i);
+                }
+            }
+            int pre[]=new int[space.size()];
+            for(int i=0;i<list.size();i++)
+            {
+                if(i==0)
+                {
+                    int min=Integer.MAX_VALUE;
+                    for(int j=0;j<space.size();j++)
+                    {
+                        pre[j]=Math.abs(list.get(i)-space.get(j));
+                        min=Math.min(min,pre[j]);
+                        pre[j]=min;
+                    }
+                }
+                else
+                {
+                    int arr[]=new int[space.size()];
+                    for(int j=0;j<i;j++)
+                    {
+                        arr[j]=Integer.MAX_VALUE;
+                    }
+
+                    int min=Integer.MAX_VALUE;
+                    for(int j=i;j<space.size();j++)
+                    {
+                        int v=Math.abs(list.get(i)-space.get(j));
+                        v+=pre[j-1];
+                        arr[j]=v;
+                        min=Math.min(min,v);
+                        arr[j]=min;
+                    }
+                    for(int j=0;j<space.size();j++)
+                    {
+                        pre[j]=arr[j];
+                    }
+                }
+            }
+            out.println(pre[space.size()-1]);
+        }
+        out.close();
+    }
+    static class FastReader
+    {
+        BufferedReader br;
+        StringTokenizer st;
+        public FastReader()
+        {
+            br = new BufferedReader(new InputStreamReader(System.in));
+        }
+        String next()
+        {
+            while (st == null || !st.hasMoreElements())
+            {
+                try
+                {
+                    st = new StringTokenizer(br.readLine());
+                }
+                catch (IOException e)
+                {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+        int nextInt()
+        {
+            return Integer.parseInt(next());
+        }
+        long nextLong()
+        {
+            return Long.parseLong(next());
+        }
+        double nextDouble()
+        {
+            return Double.parseDouble(next());
+        }
+        String nextLine()
+        {
+            String str="""";
+            try
+            {
+                str=br.readLine();
+            }
+            catch (IOException e)
+            {
+                e.printStackTrace();
+            }
+            return str;
+        }
+    }
+}","import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+
+public class _109D {
+    static BufferedReader br;
+
+    public static void main(String[] args) throws IOException {
+        br = new BufferedReader(new InputStreamReader(System.in));
+        int n = readInt();
+        int arr[] = readIntarray();
+        ArrayList<Integer> a = new ArrayList<>();
+        ArrayList<Integer> b = new ArrayList<>();
+        for(int i = 0; i < n; i++){
+            if(arr[i] == 1){
+                a.add(i);
+            }else{
+                b.add(i);
+            }
+        }
+        if(a.size() == 0){
+            System.out.println(""0"");
+            return;
+        }
+        int [][] dp = new int[a.size()][b.size()];
+        for(int i = 0; i < a.size(); i++){
+            for(int j = i; j < b.size(); j++) {
+                if (j == 0) {
+                    dp[i][j] = Math.abs(a.get(i) - b.get(j));
+                } else if (i == 0) {
+                    dp[i][j] = Math.min(dp[i][j - 1], Math.abs(a.get(i) - b.get(j)));
+                } else if (i == j) {
+                    dp[i][j] = dp[i - 1][j - 1] + Math.abs(a.get(i) - b.get(j));
+                } else {
+                    dp[i][j] = Math.min(dp[i][j - 1], dp[i - 1][j - 1] + Math.abs(a.get(i) - b.get(j)));
+                }
+            }
+        }
+        System.out.println(dp[a.size() - 1][b.size() - 1]);
+    }
+
+
+    static int readInt() throws IOException {
+        return Integer.parseInt(br.readLine());
+    }
+
+    static long readLong() throws IOException {
+        return Long.parseLong(br.readLine());
+    }
+
+    static int[] readIntarray() throws IOException {
+        String[] _a = br.readLine().split("" "");
+        int[] _res = new int[_a.length];
+        for (int i = 0; i < _a.length; i++) {
+            _res[i] = Integer.parseInt(_a[i]);
+        }
+        return _res;
+    }
+
+    static long[] readLongarray() throws IOException {
+        String[] _a = br.readLine().split("" "");
+        long[] _res = new long[_a.length];
+        for (int i = 0; i < _a.length; i++) {
+            _res[i] = Long.parseLong(_a[i]);
+        }
+        return _res;
+    }
+}
+",0
+43855bfe,ddcadc64,"import java.io.DataInputStream;
+import java.io.FileInputStream;
+import java.io.IOException;
+
+public class O4 {
+    private static String solve(int n, int[] a) {
+
+        if (n == 2) {
+            return a[1] + "" "" + (-a[0]);
+        }
+        int res[] = new int[n];
+        if (n % 2 == 0) {
+            diagonalAlignment(a, res, n);
+        } else {
+
+            diagonalAlignment(a, res, n - 3);
+            if ( a[n - 3] + a[n - 2] != 0)
+            {
+                res[n - 1] = a[n - 3] + a[n - 2];
+                res[n - 2] = -a[n - 1];
+                res[n - 3] = -a[n - 1];
+            }
+
+            else if (a[n - 1] + a[n - 2] != 0){
+                res[n - 3] = a[n - 1] + a[n - 2];
+                res[n - 2] = -a[n - 3];
+                res[n - 1] = -a[n - 3];
+            }
+            else {
+                res[n - 2] = a[n - 1] + a[n - 3];
+                res[n - 1] = -a[n - 2];
+                res[n - 3] = -a[n - 2];
+
+            }
+        }
+
+
+        return formattedArray(res);
+
+    }
+
+    private static void diagonalAlignment(int[] a, int[] res, int n) {
+
+
+        for (int i = 0; i < n; i += 2) {
+            res[i + 1] = -a[i];
+            res[i] = a[i + 1];
+        }
+
+
+    }
+
+
+    public static void main(String[] args)
+            throws IOException {
+        Scanner s = new Scanner();
+        int t = 1;
+        t = s.nextInt();
+        StringBuilder ans = new StringBuilder();
+        int count = 0;
+        while (t-- > 0) {
+            int n = s.nextInt();
+
+            int a[] = new int[n];
+            getInputs(s, a, n);
+
+
+            ans.append(solve(n, a)).append(""\n"");
+        }
+        System.out.println(ans.toString());
+    }
+
+    static class Scanner {
+        final private int BUFFER_SIZE = 1 << 16;
+        private DataInputStream din;
+        private byte[] buffer;
+        private int bufferPointer, bytesRead;
+
+        public Scanner() {
+            din = new DataInputStream(System.in);
+            buffer = new byte[BUFFER_SIZE];
+            bufferPointer = bytesRead = 0;
+        }
+
+        public Scanner(String file_name) throws IOException {
+            din = new DataInputStream(
+                    new FileInputStream(file_name));
+            buffer = new byte[BUFFER_SIZE];
+            bufferPointer = bytesRead = 0;
+        }
+
+        public String readLine() throws IOException {
+            byte[] buf = new byte[64]; // line length
+            int cnt = 0, c;
+            while ((c = read()) != -1) {
+                if (c == '\n') {
+                    if (cnt != 0) {
+                        break;
+                    } else {
+                        continue;
+                    }
+                }
+                buf[cnt++] = (byte) c;
+            }
+            return new String(buf, 0, cnt);
+        }
+
+        public int nextInt() throws IOException {
+            int ret = 0;
+            byte c = read();
+            while (c <= ' ') {
+                c = read();
+            }
+            boolean neg = (c == '-');
+            if (neg)
+                c = read();
+            do {
+                ret = ret * 10 + c - '0';
+            } while ((c = read()) >= '0' && c <= '9');
+
+            if (neg)
+                return -ret;
+            return ret;
+        }
+
+        public long nextLong() throws IOException {
+            long ret = 0;
+            byte c = read();
+            while (c <= ' ')
+                c = read();
+            boolean neg = (c == '-');
+            if (neg)
+                c = read();
+            do {
+                ret = ret * 10 + c - '0';
+            } while ((c = read()) >= '0' && c <= '9');
+            if (neg)
+                return -ret;
+            return ret;
+        }
+
+        public double nextDouble() throws IOException {
+            double ret = 0, div = 1;
+            byte c = read();
+            while (c <= ' ')
+                c = read();
+            boolean neg = (c == '-');
+            if (neg)
+                c = read();
+
+            do {
+                ret = ret * 10 + c - '0';
+            } while ((c = read()) >= '0' && c <= '9');
+
+            if (c == '.') {
+                while ((c = read()) >= '0' && c <= '9') {
+                    ret += (c - '0') / (div *= 10);
+                }
+            }
+
+            if (neg)
+                return -ret;
+            return ret;
+        }
+
+        private void fillBuffer() throws IOException {
+            bytesRead = din.read(buffer, bufferPointer = 0,
+                    BUFFER_SIZE);
+            if (bytesRead == -1)
+                buffer[0] = -1;
+        }
+
+        private byte read() throws IOException {
+            if (bufferPointer == bytesRead)
+                fillBuffer();
+            return buffer[bufferPointer++];
+        }
+
+        public void close() throws IOException {
+            if (din == null)
+                return;
+            din.close();
+        }
+    }
+
+    public static long norm(long a, long MOD) {
+        return ((a % MOD) + MOD) % MOD;
+    }
+
+    public static long msub(long a, long b, long MOD) {
+        return norm(norm(a, MOD) - norm(b, MOD), MOD);
+
+    }
+
+    public static long madd(long a, long b, long MOD) {
+        return norm(norm(a, MOD) + norm(b, MOD), MOD);
+
+    }
+
+    public static long mMul(long a, long b, long MOD) {
+        return norm(norm(a, MOD) * norm(b, MOD), MOD);
+
+
+    }
+
+    public static long mDiv(long a, long b, long MOD) {
+        return norm(norm(a, MOD) / norm(b, MOD), MOD);
+    }
+
+    public static String formattedArray(int a[]) {
+        StringBuilder res = new StringBuilder("""");
+        for (int e : a)
+            res.append(e).append("" "");
+        return res.toString().trim();
+
+    }
+
+    private static void getInputs(Scanner s, int[] a, int n) throws IOException {
+        for (int i = 0; i < n; i++) {
+            a[i] = s.nextInt();
+        }
+    }
+}
+","import java.util.Scanner;
+
+public class D {
+    public static void main(String[] args) {
+        Scanner scn = new Scanner(System.in);
+        int t = scn.nextInt();
+        StringBuilder sb = new StringBuilder();
+        while (t-- > 0) {
+            int n = scn.nextInt();
+            int[] arr = new int[n];
+            int[] ans = new int[n];
+            for (int i = 0; i < n; i++) {
+                arr[i] = scn.nextInt();
+            }
+            if (n % 2 != 0) {
+                if (arr[n - 2] + arr[n - 3] == 0) {
+                    ans[n - 3] = -2 * arr[n - 1];
+                    ans[n - 2] = -arr[n - 1];
+                    ans[n - 1] = arr[n - 2] + arr[n - 3] * 2;
+                } else {
+                    ans[n - 3] = -arr[n - 1];
+                    ans[n - 2] = -arr[n - 1];
+                    ans[n - 1] = arr[n - 2] + arr[n - 3];
+                }
+                n -= 3;
+            }
+            for (int i = 0; i < n; i += 2) {
+                int div = 1;
+                if (arr[i] % 2 == 0 && arr[i + 1] % 2 == 0)
+                    div = 2;
+                ans[i] = arr[i + 1] / div;
+                ans[i + 1] = -arr[i] / div;
+            }
+            for (int v : ans) {
+                sb.append(v);
+                sb.append("" "");
+            }
+            sb.append(""\n"");
+        }
+        System.out.println(sb);
+    }
+}
+",0
+7279bcb3,cfba313d,"import java.util.*;
+
+public class main {
+    public static final Scanner sc = new Scanner(System.in);
+
+    public static int gcd(int a,int b) {
+        return b==0?a:gcd(b, a%b);
+    }
+    public static int max(int a,int b) {
+        if(a>b) return a;
+        else return b;
+    }
+
+
+    public static void solve(){
+        int n=sc.nextInt();
+        int[][] a=new int[5][n];
+        for(int i=0;i<n;i++){
+            String x=sc.next();
+            for(int j=0;j<x.length();j++){
+                if(x.charAt(j)=='a') a[0][i]++;
+                else a[0][i]--;
+                if(x.charAt(j)=='b') a[1][i]++;
+                else a[1][i]--;
+                if(x.charAt(j)=='c') a[2][i]++;
+                else a[2][i]--;
+                if(x.charAt(j)=='d') a[3][i]++;
+                else a[3][i]--;
+                if(x.charAt(j)=='e') a[4][i]++;
+                else a[4][i]--;
+            }
+        }
+        for(int j=0;j<5;j++) Arrays.sort(a[j]);
+        int ans=0;
+        for(int j=0;j<5;j++){
+            int tmp=0,cnt=0;
+            for(int i=n-1;i>=0;i--){
+                tmp+=a[j][i];
+                if(tmp<=0) break;
+                else cnt++;
+            }
+            ans=max(ans,cnt);
+        }
+        System.out.println(ans);
+    }
+    public static void main(String[] args) {
+        int T=1;
+        T=sc.nextInt();
+        while(--T>=0) solve();
+    }
+}
+","import java.io.*;
+import java.util.*;
+
+
+public class C {//Any Class Name
+	
+	static class Code {
+		
+		private void solve(InputReader in, OutputWriter out) throws IOException {
+			
+			ArrayOpn o= new ArrayOpn();
+			int t = in.readInt();
+			while(t -- > 0) {
+			
+				int n=in.readInt();
+				
+				
+				int[][] freq= new int[5][n];
+				
+				for(int i=0; i<n; i++) {
+					char s[]= in.readString().toCharArray();
+					
+					
+					for(char e: s) {
+						if(e=='a') {
+							freq[0][i]++;
+						}
+						else {
+							freq[0][i]--;
+						}
+						if(e=='b') {
+							freq[1][i]++;
+						}
+						else {
+							freq[1][i]--;
+						}
+						
+						if(e=='c') {
+							freq[2][i]++;
+						}
+						else {
+							freq[2][i]--;
+						}
+						if(e=='d') {
+							freq[3][i]++;
+						}
+						else {
+							freq[3][i]--;
+						}
+						if(e=='e') {
+							freq[4][i]++;
+						}
+						else {
+							freq[4][i]--;
+						}
+							
+					}
+				}
+				
+				
+				for(int i=0; i<5; i++) {
+					Arrays.sort(freq[i]);
+				}
+				
+				int ans=0;
+				for(int i=0; i<5; i++) {
+					int temp=0, count=0;
+					for(int j=n-1; j>=0; j--) {
+						temp+=freq[i][j];
+						if(temp<=0) {
+							break;
+						}
+						count++;
+					}
+					ans=Math.max(ans, count);
+				}
+				
+				out.printLine(ans);
+				
+			}
+			out.close();
+		}
+	}
+	
+	static class ArrayOpn{
+		private int[] aI(InputReader in, int n) {
+			int A[]= new int[n];
+			for(int i=0; i<n; i++) {
+				A[i]=in.readInt();
+			}
+			return A;
+		}
+		
+		static final Random random = new Random();
+		
+		private void sort(int A[]) {
+			int n = A.length;
+			for(int i=0; i<n; i++)
+			{
+				int j = random.nextInt(n),temp = A[j];
+				A[j] = A[i];
+				A[i] = temp;
+			}
+			Arrays.sort(A);
+//            return A;
+		}
+		
+		private int[][] mI(InputReader in, int n, int m){
+			int A[][]= new int[n][m];
+			for(int i=0; i<n; i++) {
+				for(int j=0; j<m; j++) {
+					A[i][j]=in.readInt();
+				}
+			}
+			return A;
+		}
+		
+		private int minEl(int A[]) {
+			int min=Integer.MAX_VALUE;
+			for(int e: A) {
+				min=Math.min(e, min);
+			}
+			return min;
+		}
+		private int maxEl(int A[]) {
+			int max=Integer.MIN_VALUE;
+			for(int e: A) {
+				max=Math.max(e, max);
+			}
+			return max;
+		}
+		
+		private int occurence(int A[], int e) {
+			int c=0;
+			for(int k: A) {
+				if(k==e) {
+					c++;
+				}
+			}
+			return c;
+		}
+		
+		public int linears(int A[], int e) {
+			
+			for(int i=0; i<A.length; i++) {
+				if(A[i]==e) {
+					return i;
+				}
+			}
+			return -1;
+		}
+		
+		public int binarys(int A[], int e) {
+			int low=0, high=A.length-1;
+			while(low<=high) {
+				int mid=(low+high)/2;
+				if(A[mid]==e) {
+					return mid;
+				}
+				else if(A[mid]<e) {
+					low=mid+1;
+				}
+				else {
+					high=mid-1;
+				}
+			}
+			return -1;
+		}
+		
+		public void printAr(OutputWriter out, int A[]) {
+			for(int e: A) {
+				out.print(e+"" "");
+			}
+		}
+	}
+	
+	static class Pair<F, S>{
+		private final F first; //first member of pair
+		private final S second; //second member of pair
+		
+		private Pair(F first, S second) {
+			this.first = first;
+			this.second = second;
+		}
+		
+		@Override
+		public boolean equals(Object o) {
+			if (this == o) {
+				return true;
+			}
+			
+			if (o == null || getClass() != o.getClass())
+				return false;
+			
+			Pair<? , ?> pair = (Pair<?, ?>) o;
+			if(!first.equals(pair.first))
+				return false;
+			return second.equals(pair.second);
+		}
+		
+		@Override
+		public int hashCode() {
+			return 31 * first.hashCode() + second.hashCode();
+		}
+		
+		@Override
+		public String toString() {
+			return ""("" + first +"", ""+ second +"")"";
+		}
+		
+		
+		public static <F,S> Pair<F,S> of(F a, S b) {
+			return new Pair<>(a,b);
+		}
+		public F getFirst() {
+			return first;
+		}
+		
+		public S getSecond() {
+			return second;
+		}
+	}
+	
+	// Comparator for using in Sorting On integers
+	static class PairCompare implements Comparator<Pair<Integer, Integer>> {
+		@Override
+		public int compare(Pair<Integer, Integer> p1, Pair<Integer, Integer> p2) {
+			int diff = Integer.compare(p1.first, p2.first);
+			if(diff == 0) {
+				return Integer.compare(p1.second, p2.second);
+			}
+			else return diff;
+		}
+	}
+	
+	
+	
+	public static void main(String[] args) throws IOException {
+		//initialize
+		InputStream inputStream = System.in;
+		OutputStream outputStream = System.out;
+		InputReader in = new InputReader(inputStream);
+		OutputWriter out = new OutputWriter(outputStream);
+		Code solver = new Code();
+		solver.solve(in, out);
+		out.flush();
+		out.close();
+	}
+	
+	
+	static class InputReader {
+		private InputStream stream;
+		private byte[] buf = new byte[1024];
+		private int curChar;
+		private int numChars;
+		private SpaceCharFilter filter;
+		
+		private InputReader(InputStream stream) {
+			this.stream = stream;
+		}
+		
+		private int read() {
+			if (numChars == -1)
+				throw new InputMismatchException();
+			if (curChar >= numChars) {
+				curChar = 0;
+				try {
+					numChars = stream.read(buf);
+				} catch (IOException e) {
+					throw new InputMismatchException();
+				}
+				if (numChars <= 0)
+					return -1;
+			}
+			return buf[curChar++];
+		}
+		
+		private String readString() {
+			int c = read();
+			while (isSpaceChar(c))
+				c = read();
+			StringBuilder res = new StringBuilder();
+			do {
+				if (Character.isValidCodePoint(c))
+					res.appendCodePoint(c);
+				c = read();
+			} while (!isSpaceChar(c));
+			return res.toString();
+		}
+		
+		private int readInt() {
+			int c = read();
+			while (isSpaceChar(c))
+				c = read();
+			int sgn = 1;
+			if (c == '-') {
+				sgn = -1;
+				c = read();
+			}
+			int res = 0;
+			do {
+				if (c < '0' || c > '9')
+					throw new InputMismatchException();
+				res *= 10;
+				res += c - '0';
+				c = read();
+			} while (!isSpaceChar(c));
+			return res * sgn;
+		}
+		
+		private long readLong() {
+			int c = read();
+			while (isSpaceChar(c)) {
+				c = read();
+			}
+			int sgn = 1;
+			if (c == '-') {
+				sgn = -1;
+				c = read();
+			}
+			long res = 0;
+			do {
+				if (c < '0' || c > '9') {
+					throw new InputMismatchException();
+				}
+				res *= 10;
+				res += c - '0';
+				c = read();
+			} while (!isSpaceChar(c));
+			return res * sgn;
+		}
+		
+		private double readDouble() {
+			int c = read();
+			while (isSpaceChar(c)) {
+				c = read();
+			}
+			int sgn = 1;
+			if (c == '-') {
+				sgn = -1;
+				c = read();
+			}
+			double res = 0;
+			while (!isSpaceChar(c) && c != '.') {
+				if (c == 'e' || c == 'E') {
+					return res * Math.pow(10, readInt());
+				}
+				if (c < '0' || c > '9') {
+					throw new InputMismatchException();
+				}
+				res *= 10;
+				res += c - '0';
+				c = read();
+			}
+			if (c == '.') {
+				c = read();
+				double m = 1;
+				while (!isSpaceChar(c)) {
+					if (c == 'e' || c == 'E') {
+						return res * Math.pow(10, readInt());
+					}
+					if (c < '0' || c > '9') {
+						throw new InputMismatchException();
+					}
+					m /= 10;
+					res += (c - '0') * m;
+					c = read();
+				}
+			}
+			return res * sgn;
+		}
+		
+		private boolean isSpaceChar(int c) {
+			if (filter != null)
+				return filter.isSpaceChar(c);
+			return isWhitespace(c);
+		}
+		
+		public String next() {
+			return readString();
+		}
+		
+		
+		private static boolean isWhitespace(int c) {
+			return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
+		}
+		
+		private char readCharacter() {
+			int c = read();
+			while (isSpaceChar(c))
+				c = read();
+			return (char) c;
+		}
+		
+		public interface SpaceCharFilter {
+			boolean isSpaceChar(int ch);
+		}
+	}
+	
+	static class OutputWriter {
+		private final PrintWriter writer;
+		
+		private OutputWriter(OutputStream outputStream) {
+			writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(
+					outputStream)));
+		}
+		
+		private OutputWriter(Writer writer) {
+			this.writer = new PrintWriter(writer);
+		}
+		
+		private void print(Object... objects) {
+			for (int i = 0; i < objects.length; i++) {
+				if (i != 0) {
+					writer.print(' ');
+				}
+				writer.print(objects[i]);
+			}
+			writer.flush();
+		}
+		
+		private void printLine(Object... objects) {
+			print(objects);
+			writer.println();
+			writer.flush();
+		}
+		
+		private void printLine(int i) {
+			writer.println(i);
+		}
+		
+		
+		private void close() {
+			writer.close();
+		}
+		
+		private void flush() {
+			writer.flush();
+		}
+		
+		
+	}
+	
+	static class IOUtils {
+		
+		private static int[] readIntArray(InputReader in, int size) {
+			int[] array = new int[size];
+			for (int i = 0; i < size; i++)
+				array[i] = in.readInt();
+			return array;
+		}
+		
+		private static long[] readLongArray(InputReader in, int size) {
+			long[] array = new long[size];
+			for (int i = 0; i < size; i++)
+				array[i] = in.readLong();
+			return array;
+		}
+		
+		private static char[] readCharArray(InputReader in, int size) {
+			char[] array = new char[size];
+			for (int i = 0; i < size; i++)
+				array[i] = in.readCharacter();
+			return array;
+		}
+		
+		private static char[][] readTable(InputReader in, int rowCount,
+				int columnCount) {
+			char[][] table = new char[rowCount][];
+			for (int i = 0; i < rowCount; i++)
+				table[i] = readCharArray(in, columnCount);
+			return table;
+		}
+		
+	}
+	
+	static class ArrayUtils {
+		
+		private static void fill(int[][] array, int value) {
+			for (int[] row : array)
+				Arrays.fill(row, value);
+		}
+		
+	}
+	
+	static class MiscUtils {
+		private static final int[] DX4 = {1, 0, -1, 0};
+		private static final int[] DY4 = {0, -1, 0, 1};
+		
+		private static boolean isValidCell(int row, int column, int rowCount,
+				int columnCount) {
+			return row >= 0 && row < rowCount && column >= 0
+					&& column < columnCount;
+		}
+		
+	}
+}",1
+a4e39423,ba8800f5,"import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+
+public class _109D {
+    static BufferedReader br;
+
+    public static void main(String[] args) throws IOException {
+        br = new BufferedReader(new InputStreamReader(System.in));
+        int n = readInt();
+        int arr[] = readIntarray();
+        ArrayList<Integer> a = new ArrayList<>();
+        ArrayList<Integer> b = new ArrayList<>();
+        for(int i = 0; i < n; i++){
+            if(arr[i] == 1){
+                a.add(i);
+            }else{
+                b.add(i);
+            }
+        }
+        if(a.size() == 0){
+            System.out.println(""0"");
+            return;
+        }
+        int [][] dp = new int[a.size()][b.size()];
+        for(int i = 0; i < a.size(); i++){
+            for(int j = i; j < b.size(); j++) {
+                if (j == 0) {
+                    dp[i][j] = Math.abs(a.get(i) - b.get(j));
+                } else if (i == 0) {
+                    dp[i][j] = Math.min(dp[i][j - 1], Math.abs(a.get(i) - b.get(j)));
+                } else if (i == j) {
+                    dp[i][j] = dp[i - 1][j - 1] + Math.abs(a.get(i) - b.get(j));
+                } else {
+                    dp[i][j] = Math.min(dp[i][j - 1], dp[i - 1][j - 1] + Math.abs(a.get(i) - b.get(j)));
+                }
+            }
+        }
+        System.out.println(dp[a.size() - 1][b.size() - 1]);
+    }
+
+
+    static int readInt() throws IOException {
+        return Integer.parseInt(br.readLine());
+    }
+
+    static long readLong() throws IOException {
+        return Long.parseLong(br.readLine());
+    }
+
+    static int[] readIntarray() throws IOException {
+        String[] _a = br.readLine().split("" "");
+        int[] _res = new int[_a.length];
+        for (int i = 0; i < _a.length; i++) {
+            _res[i] = Integer.parseInt(_a[i]);
+        }
+        return _res;
+    }
+
+    static long[] readLongarray() throws IOException {
+        String[] _a = br.readLine().split("" "");
+        long[] _res = new long[_a.length];
+        for (int i = 0; i < _a.length; i++) {
+            _res[i] = Long.parseLong(_a[i]);
+        }
+        return _res;
+    }
+}
+","import java.io.*;
+import java.util.*;
+import java.text.*;
+import java.math.*;
+
+public class Main {
+
+    public static void main(String[] args) throws IOException{
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        int n = Integer.parseInt(br.readLine());
+        StringTokenizer st = new StringTokenizer(br.readLine());
+        int ar[] = new int[n];
+        for(int i = 0; i < n; i++){
+            ar[i] = Integer.parseInt(st.nextToken());
+        }
+        ArrayList<Integer> ones = new ArrayList<Integer>();
+        ArrayList<Integer> zeroes = new ArrayList<Integer>();
+        for(int i = 0; i < n; i++){
+            if(ar[i] == 1)
+                ones.add(i);
+            else
+                zeroes.add(i);
+        }
+        int r = ones.size();
+        int c = zeroes.size();
+        int time[][] = new int[r][c];
+        System.out.println(calculateTime(time, r, c, 0, 0, ones, zeroes));
+    }
+    public static int calculateTime(int time[][], int r, int c, int currR, int currC, ArrayList<Integer> ones, ArrayList<Integer> zeroes){
+        // System.out.println(currR + "" "" + currC);
+        if(currR == r)
+            return 0;
+        if(currC == c)
+            return (int)1e9;
+        if(time[currR][currC] != 0)
+            return time[currR][currC];
+        return time[currR][currC] = Math.min((calculateTime(time, r, c, currR + 1, currC + 1, ones, zeroes) + Math.abs(ones.get(currR) - zeroes.get(currC))), calculateTime(time, r, c, currR, currC + 1, ones, zeroes));
+    }
+}",0
+af2b138c,e45446bc,"import java.util.*;
+import java.lang.*;
+import java.io.*;
+
+
+
+public class ecf106 {
+
+//HashMap<Integer,Integer> hm=new HashMap<>();
+//ArrayList<Integer> list=new ArrayList<>();
+//HashSet<Integer> hs=new HashSet<>();
+//Stack<Integer> st=new Stack<>();
+//Queue<Integer> q=new LinkedList<>();
+//PriorityQueue<Integer> pq=new PriorityQueue<>();
+// static ArrayList<ArrayList<Integer>> gp=new ArrayList<>();
+//int[] arr=new int[n];
+//System.out.println(""YES"");
+//1 hr- atleast 2 qs d-2
+//Mt_do 3 qs d-2  
+//Mt_do 4 qs d-3
+//StringBuilder sb=new StringBuilder();
+
+public static void main(String[] args) throws Exception{
+    InputStreamReader ip=new InputStreamReader(System.in);
+    BufferedReader br = new BufferedReader(ip);
+    int t= Integer.parseInt(br.readLine());
+    
+    while(t-->0){
+       int n=Integer.parseInt(br.readLine());//Integer.parseInt(strs[0]);
+        String[] strs=(br.readLine()).trim().split("" "");
+        // int n=Integer.parseInt(strs[0]),k=Integer.parseInt(strs[1]);//,k=Integer.parseInt(strs[2]);
+
+        // strs=(br.readLine()).trim().split("" "");
+         long[] arr=new long [n];
+
+        for(int i=0;i<n;i++){
+            arr[i]=Integer.parseInt(strs[i]);
+        }
+
+        long min1=0,min2=0;
+        long x=0,y=0;
+        long hor=arr[0],vert=arr[1];
+        long ans=(n*hor)+(n*vert);
+        
+        for(int i=2;i<n;i++){
+            if(i%2==0){
+                x++;
+                if(arr[i]>=hor){   //v.v.imp  donot update horizontal
+                    min1+=arr[i];  
+                }else{
+                    min1+=hor;  hor=arr[i];
+                }
+            }else{
+                y++;
+                if(arr[i]>=vert){   //v.v.imp  donot update vertical
+                    min2+=arr[i];    
+                }else{
+                    min2+=vert;  vert=arr[i];
+                }
+            }
+
+            long rem=(n-x)*hor+(n-y)*vert;
+
+            ans=Math.min(ans, min1+min2+rem);
+        }
+
+        System.out.println(ans);
+    }
+
+    }
+}
+
+
+
+
+
+
+
+
+
+
+// public static void main(String[] args) throws Exception{
+//     InputStreamReader ip=new InputStreamReader(System.in);
+//     BufferedReader br = new BufferedReader(ip);
+//     int t= Integer.parseInt(br.readLine());
+    
+//     while(t-->0){
+//     //    int n=Integer.parseInt(br.readLine());//Integer.parseInt(strs[0]);
+//         // String[] strs=(br.readLine()).trim().split("" "");
+//         // int n=Integer.parseInt(strs[0]),k=Integer.parseInt(strs[1]);//,k=Integer.parseInt(strs[2]);
+
+//         // strs=(br.readLine()).trim().split("" "");
+//         String str=(br.readLine()).trim();
+
+//         char[] arr=str.toCharArray();
+//             int  n=arr.length;
+//             int i=0, l=0, r=n;
+//             for (i=1; i<n; i++)
+//                 if (arr[i-1]==arr[i] && arr[i]=='0')
+//                     l=i;
+
+
+//             for (i=n-2; i>=0; i--)
+//                 if (arr[i]==arr[i+1] && arr[i]=='1')
+//                     r=i;
+//             if (l<=r)
+//                System.out.println(""YES"");
+//             else
+//             System.out.println(""NO"");
+
+//         // int cz=0,co=0;
+//         // int lz=0;
+//         // int n=str.length();
+
+//         // boolean fg1=true;
+//         // for(int i=0;i<n;i++){
+//         //     if(arr[i]=='1'){co++;}else{cz++;  lz=i;}
+//         //     if(i>0 && arr[i-1]>arr[i]){fg1=false; }
+//         // }
+
+//         // if(co==n || cz==n || fg1 || co==1 ||cz==1){
+//         //     System.out.println(""YES"");  continue;
+//         // }
+       
+//         // // String s1="""";
+//         // // String s2="""";
+//         // StringBuilder sb1=new StringBuilder();
+//         // StringBuilder sb2=new StringBuilder();
+//         // for(int i=0;i<n;i+=2){
+//         //     // s1+=arr[i];
+//         //     sb1.append(arr[i]);
+//         // }
+
+//         // for(int i=1;i<n;i+=2){
+//         //     // s2+=arr[i];
+//         //     sb2.append(arr[i]);
+//         // }
+
+//         // char[] arr1=(sb1.toString()).toCharArray();
+//         // char[] arr2=(sb2.toString()).toCharArray();
+//         // boolean fg2=true;
+//         // boolean fg3=true;
+//         // for(int i=0;i<arr1.length;i++){
+//         //     if(i>0 && arr1[i-1]>arr1[i]){fg2=false;  break;}
+//         // }
+
+        
+
+//         // for(int i=0;i<arr2.length;i++){
+//         //     if(i>0 && arr2[i-1]>arr2[i]){fg3=false;}
+//         // }
+
+//         // if(fg2 ||fg3){
+//         //     System.out.println(""YES"");
+//         // }else{
+//         //     System.out.println(""NO"");
+//         // }
+//     }
+
+// }
+// }
+
+
+
+
+
+
+
+        // int az=0,ao=0;
+        // ArrayList<Integer> list=new ArrayList<>();
+        // for(int i=0;i<n;i++){
+        //     if(arr[i]=='0'){az++; if(ao!=0){list.add(ao);}    ao=0;  }
+        //     else{ao++;   if(az!=0){list.add(az); }   az=0;  }
+        // }
+        // if(az!=0){list.add(az); }
+        // if(ao!=0){list.add(ao);}
+
+        // boolean fl=true;
+        // for(int i=1;i<list.size();i++){
+        //     int v1=list.get(i-1),v2=list.get(i);
+
+        //     if(v1>1 && v2>1){fl=false;  break;}
+        // }
+
+        // if(fl){System.out.println(""YES"");}
+        // else{System.out.println(""NO"");}
+//         }
+
+//     }
+// }
+        //c1    000001111
+
+
+        // boolean fg=true;
+        // int last=-2;
+        
+        // for(int i=0;i<=lz;i++){
+        //     if(arr[i]=='0'){ if((last+1)==i){fg=false;  break;}  last=i; }
+        // }
+
+
+
+        // if(fg){System.out.println(""YES"");  continue;}
+        // //c2 11111
+        // fg=true;
+        //  last=-2;
+        // for(int i=0;i<n;i++){
+        //     if(arr[i]=='0'){ if((last+1)==i){fg=false;  break;}  last=i; }
+        // }
+
+        // if(fg){System.out.println(""YES"");  continue;}
+        // //c3  0000
+        // fg=true;
+        //  last=-2;
+        // for(int i=0;i<n;i++){
+        //     if(arr[i]=='1'){ if((last+1)==i){fg=false;  break;}  last=i; }
+        // }
+
+        // if(fg){System.out.println(""YES"");}
+        // else{System.out.println(""NO"");}
+    // }
+
+    // }
+    // }
+
+
+
+// public static void main(String[] args) throws Exception{
+//     InputStreamReader ip=new InputStreamReader(System.in);
+//     BufferedReader br = new BufferedReader(ip);
+//     int t= Integer.parseInt(br.readLine());
+    
+//     while(t-->0){
+//     //    int n=Integer.parseInt(br.readLine());//Integer.parseInt(strs[0]);
+//         String[] strs=(br.readLine()).trim().split("" "");
+//         int n=Integer.parseInt(strs[0]),k1=Integer.parseInt(strs[1]),k2=Integer.parseInt(strs[2]);//,k=Integer.parseInt(strs[2]);
+
+//         strs=(br.readLine()).trim().split("" "");
+        
+//         int w=Integer.parseInt(strs[0]),b=Integer.parseInt(strs[1]);
+
+//         int tw=k1+k2;
+//         int tb=(2*n)-tw;
+
+//         if((tw/2)>=w && (tb/2)>=b){
+//             System.out.println(""YES"");
+//         }else{
+//             System.out.println(""NO"");
+//         }
+//     }
+
+//     }
+// }
+","
+import java.util.*;
+import java.lang.*;
+import java.io.*;
+
+public class C {
+
+//	            ***                          ++                      
+//             +=-==+                      +++=-                     
+//            +-:---==+                   *+=----=                   
+//           +-:------==+               ++=------==                  
+//           =-----------=++=========================                
+//          +--:::::---:-----============-=======+++====             
+//          +---:..:----::-===============-======+++++++++           
+//          =---:...---:-===================---===++++++++++         
+//          +----:...:-=======================--==+++++++++++        
+//          +-:------====================++===---==++++===+++++      
+//         +=-----======================+++++==---==+==-::=++**+     
+//        +=-----================---=======++=========::.:-+*****    
+//       +==::-====================--:  --:-====++=+===:..-=+*****   
+//       +=---=====================-...  :=..:-=+++++++++===++*****  
+//       +=---=====+=++++++++++++++++=-:::::-====+++++++++++++*****+ 
+//      +=======++++++++++++=+++++++============++++++=======+****** 
+//      +=====+++++++++++++++++++++++++==++++==++++++=:...  . .+**** 
+//     ++====++++++++++++++++++++++++++++++++++++++++-.     ..-+**** 
+//     +======++++++++++++++++++++++++++++++++===+====:.    ..:=++++ 
+//     +===--=====+++++++++++++++++++++++++++=========-::....::-=++* 
+//     ====--==========+++++++==+++===++++===========--:::....:=++*  
+//     ====---===++++=====++++++==+++=======-::--===-:.  ....:-+++   
+//     ==--=--====++++++++==+++++++++++======--::::...::::::-=+++    
+//     ===----===++++++++++++++++++++============--=-==----==+++     
+//     =--------====++++++++++++++++=====================+++++++     
+//     =---------=======++++++++====+++=================++++++++     
+//     -----------========+++++++++++++++=================+++++++    
+//     =----------==========++++++++++=====================++++++++  
+//     =====------==============+++++++===================+++==+++++ 
+//     =======------==========================================++++++
+
+//	 created by : Nitesh Gupta
+
+	public static void main(String[] args) throws Exception {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		int t = Integer.parseInt(br.readLine());
+		StringBuilder sb = new StringBuilder();
+		while (t-- > 0) {
+			String[] scn = (br.readLine()).trim().split("" "");
+			int n = Integer.parseInt(scn[0]);
+			long[] arr = new long[n];
+			scn = (br.readLine()).trim().split("" "");
+			for (int i = 0; i < n; i++) {
+				arr[i] = Long.parseLong(scn[i]);
+			}
+			long min;
+			long hor = arr[0], ver = arr[1];
+			long min1 = 0, min2 = 0;
+			min = (hor + ver) * n;
+			long x = 0, y = 0;
+			for (int i = 2; i < n; i++) {
+				if (i % 2 == 0) {
+					x += 1;
+					if (arr[i] >= hor) {
+						min1 += arr[i];
+					} else {
+						min1 += hor;
+						hor = arr[i];
+					}
+					
+					
+				} else {
+					y += 1;
+					if (arr[i] >= ver) {
+						min2 += arr[i];
+					} else {
+						min2 += ver;
+						ver = arr[i];
+					}
+				}
+				long pro =  (n - x) * hor + (n - y) * ver;
+				min = Math.min(min, min1 + min2 +pro);
+			}
+			sb.append(min);
+			sb.append(""\n"");
+		}
+		System.out.println(sb);
+		return;
+
+	}
+
+	public static void sort(long[] arr) {
+		int n = arr.length;
+		for (int i = 0; i < n; i++) {
+			int idx = (int) Math.random() * n;
+			long temp = arr[i];
+			arr[i] = arr[idx];
+			arr[idx] = temp;
+		}
+		Arrays.sort(arr);
+	}
+
+	public static void print(long[] dp) {
+		for (long ele : dp) {
+			System.out.print(ele + "" "");
+		}
+		System.out.println();
+	}
+
+	public static void print(long[][] dp) {
+		for (long[] a : dp) {
+			for (long ele : a) {
+				System.out.print(ele + "" "");
+			}
+			System.out.println();
+		}
+	}
+
+}
+",1
+10bbe9de,48993e07,"import java.io.*;
+import java.util.Arrays;
+import java.util.Scanner;
+import java.util.StringTokenizer;
+
+public class Main {
+    public static void main(String[] args) throws IOException {
+        SolveQue solveQue = new SolveQue();
+        solveQue.ques();
+    }
+}
+
+class SolveQue {
+    static class FastScanner {
+        BufferedReader br;
+        StringTokenizer st;
+
+        public FastScanner()
+        {
+            br = new BufferedReader(
+                    new InputStreamReader(System.in));
+        }
+
+        String next()
+        {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                }
+                catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt() { return Integer.parseInt(next()); }
+
+        long nextLong() { return Long.parseLong(next()); }
+
+        double nextDouble()
+        {
+            return Double.parseDouble(next());
+        }
+
+        String nextLine()
+        {
+            String str = """";
+            try {
+                str = br.readLine();
+            }
+            catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+        }
+    }
+    private static final FastScanner fs = new FastScanner();
+    private static final Scanner sc = new Scanner(System.in);
+    private static final BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+    private static final long MOD = (long) (1e9 + 7);
+    private static PrintWriter out = new PrintWriter(System.out);
+    private static BufferedWriter output = new BufferedWriter(new OutputStreamWriter(System.out));
+    private static final int iInf = Integer.MAX_VALUE - (int) (1e6);
+    private static final long lInf = (long)(1e17);
+    private static int[] phi;
+
+    /** Optimal(Maximum,Minimum) Answers
+     * 1. Binary search
+     * 2. Prefix Suffix
+     * 3. Greedy (sorting searching)
+     * 4. DP
+     **/
+    long[] getP(long[] arr,int n) {
+        long mn = lInf;
+        long[] P = new long[n];
+        Arrays.fill(P,lInf);
+        long cnt = 0;
+        for(int i = 0 ; i < n; i++){
+            long curr = arr[i];
+            if(mn + cnt < curr){
+                P[i] = mn + cnt;
+            } else {
+                mn = arr[i];
+                P[i] = arr[i];
+                cnt  = 0;
+            }
+            cnt++;
+        }
+        return  P;
+    }
+    long[] getS(long[] arr,int n) {
+        long mn = lInf;
+        long[] S = new long[n];
+        Arrays.fill(S,lInf);
+        long cnt = 0;
+        for(int i = n - 1; i >= 0; i--){
+            long curr = arr[i];
+            if(mn + cnt < curr){
+                S[i] = mn + cnt;
+            }else{
+                mn = arr[i];
+                S[i] = arr[i];
+                cnt  = 0;
+            }
+            cnt++;
+        }
+        return  S;
+    }
+    void solve(int T) throws IOException {
+        int n = fs.nextInt();
+        int k = fs.nextInt();
+        int[] a = new int[k];
+        long[] t = new long[k];
+        long[] arr = new long[n];
+        Arrays.fill(arr,lInf);
+        for (int i = 0; i < k; i++) {
+            a[i] = fs.nextInt();
+            a[i]--;
+        }
+        for (int i = 0; i < k; i++) {
+            t[i] = fs.nextLong();
+            arr[a[i]] = t[i];
+        }
+//        Arrays.fill(arr,lInf);
+        long[] P = getP(arr, n);
+//        Arrays.fill(arr,lInf);
+        long[] S = getS(arr, n);
+        for(int i = 0 ; i < n ; i++){
+            System.out.print(Math.min(P[i],S[i]) + "" "");
+        }
+        System.out.println();
+    }
+    void ques() throws IOException {
+        int t = 1;
+//        t = sc.nextInt();
+        t = fs.nextInt();
+//        t = Integer.parseInt(br.readLine());
+        int tt = 1;
+        while (t-- > 0) {
+            solve(tt);
+            tt++;
+        }
+        System.gc();
+    }
+}","import java.io.*;
+import java.util.*;
+
+public class Codeforce {
+
+    static class Reader {
+        final private int BUFFER_SIZE = 1 << 16;
+        private DataInputStream din;
+        private byte[] buffer;
+        private int bufferPointer, bytesRead;
+
+        public Reader() {
+            din = new DataInputStream(System.in);
+            buffer = new byte[BUFFER_SIZE];
+            bufferPointer = bytesRead = 0;
+        }
+
+        public Reader(String file_name) throws IOException {
+            din = new DataInputStream(
+                    new FileInputStream(file_name));
+            buffer = new byte[BUFFER_SIZE];
+            bufferPointer = bytesRead = 0;
+        }
+
+        public String readLine() throws IOException {
+            byte[] buf = new byte[64]; // line length
+            int cnt = 0, c;
+            while ((c = read()) != -1) {
+                if (c == '\n') {
+                    if (cnt != 0) {
+                        break;
+                    } else {
+                        continue;
+                    }
+                }
+                buf[cnt++] = (byte) c;
+            }
+            return new String(buf, 0, cnt);
+        }
+
+        public int nextInt() throws IOException {
+            int ret = 0;
+            byte c = read();
+            while (c <= ' ') {
+                c = read();
+            }
+            boolean neg = (c == '-');
+            if (neg)
+                c = read();
+            do {
+                ret = ret * 10 + c - '0';
+            } while ((c = read()) >= '0' && c <= '9');
+
+            if (neg)
+                return -ret;
+            return ret;
+        }
+
+        public long nextLong() throws IOException {
+            long ret = 0;
+            byte c = read();
+            while (c <= ' ')
+                c = read();
+            boolean neg = (c == '-');
+            if (neg)
+                c = read();
+            do {
+                ret = ret * 10 + c - '0';
+            } while ((c = read()) >= '0' && c <= '9');
+            if (neg)
+                return -ret;
+            return ret;
+        }
+
+        public double nextDouble() throws IOException {
+            double ret = 0, div = 1;
+            byte c = read();
+            while (c <= ' ')
+                c = read();
+            boolean neg = (c == '-');
+            if (neg)
+                c = read();
+
+            do {
+                ret = ret * 10 + c - '0';
+            } while ((c = read()) >= '0' && c <= '9');
+
+            if (c == '.') {
+                while ((c = read()) >= '0' && c <= '9') {
+                    ret += (c - '0') / (div *= 10);
+                }
+            }
+
+            if (neg)
+                return -ret;
+            return ret;
+        }
+
+        private void fillBuffer() throws IOException {
+            bytesRead = din.read(buffer, bufferPointer = 0,
+                    BUFFER_SIZE);
+            if (bytesRead == -1)
+                buffer[0] = -1;
+        }
+
+        private byte read() throws IOException {
+            if (bufferPointer == bytesRead)
+                fillBuffer();
+            return buffer[bufferPointer++];
+        }
+
+        public void close() throws IOException {
+            if (din == null)
+                return;
+            din.close();
+        }
+    }
+
+    static int mod = (int) (1e9 + 7);
+
+    public static class pair implements Comparator<pair> {
+        int x;
+        int y;
+
+        public pair() {
+
+        }
+
+        public pair(int x, int y) {
+            this.x = x;
+            this.y = y;
+
+        }
+
+        @Override
+        public int compare(pair o1, pair o2) {
+            return o1.y - o2.y;
+        }
+    }
+
+    public static long modularpow(long a, long b) {
+        long res = 1;
+        if (b == 0)
+            return res;
+        else {
+            while (b > 0) {
+                if (b % 2 == 1) {
+                    res *= a;
+                    res %= mod;
+
+                }
+                a = a * a;
+                a %= mod;
+                b /= 2;
+            }
+            return res % mod;
+        }
+    }
+
+    public static int gcd(int a, int b) {
+        if (b == 0)
+            return a;
+        else
+            return gcd(b, a % b);
+    }
+
+    public static String binary(int a) {
+        String s1 = """";
+        while (a > 0) {
+            s1 = a % 2 + s1;
+            a /= 2;
+        }
+        return s1;
+    }
+
+    public static int Lower_Bound(long a[], int l, int r, long k) {
+
+
+        while (r - l > 1) {
+            int mid = l + (r - l) / 2;
+            if (a[mid] <= k) l = mid;
+            else
+                r = mid;
+
+        }
+        return l;
+    }
+
+    public static int Upper_Bound(int a[], int l, int r, int k) {
+
+        while (r - l > 1) {
+            int mid = (l + r) / 2;
+            if (a[mid] <= k)
+                l = mid;
+            else
+                r = mid;
+        }
+        return l + 1;
+    }
+
+    public static void main(String arg[]) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        int t = Integer.parseInt(br.readLine());
+        StringBuilder sb = new StringBuilder();
+        while (t-- > 0) {
+                                br.readLine();
+                        String s[]=br.readLine().split("" "");
+                        int n=Integer.parseInt(s[0]);
+                        int k=Integer.parseInt(s[1]);
+                        long a[]=new long[n];
+                        long b[]=new long[n];
+                        long c[]=new long[n];
+                        Arrays.fill(c,Integer.MAX_VALUE);
+                        String s1[]=br.readLine().split("" "");
+                        s=br.readLine().split("" "");
+                        for(int i=0;i<k;i++)
+                            c[Integer.parseInt(s1[i])-1]=Integer.parseInt(s[i]);
+
+                        long p=Integer.MAX_VALUE;
+                        for(int i=0;i<n;i++)
+                        {
+                            p=Math.min(p+1,c[i]);
+                            a[i]=p;
+                        }
+                        p=Integer.MAX_VALUE;
+                        for(int i=n-1;i>=0;i--){
+                            p=Math.min(p+1,c[i]);
+                            b[i]=p;
+                        }
+                        for(int i=0;i<n;i++)
+                            sb.append((Math.min(a[i],b[i]))+"" "");
+                        sb.append(""\n"");
+
+                       }
+        System.out.println(sb);
+    }
+}",0
+927384f2,d4779c71,"import java.util.*;
+import java.io.*;
+
+public class Main{
+	static class Point{
+		int x,y,z;
+		Point(int nx, int ny){
+			x = nx; y = ny; 
+		}
+		@Override
+		public boolean equals(Object o) {
+			Point p = (Point)o;
+			return p.x == x && p.y == y;
+		}
+	}      
+	
+	public static void main(String[] args) throws IOException{
+		BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
+		int n = pint(in);
+		Stack<Integer> min = new Stack<Integer>();
+		Stack<Integer> max = new Stack<Integer>();
+		
+		int[] a = new int[n];
+		int[] dp = new int[n];
+		StringTokenizer st = new StringTokenizer(in.readLine());
+		a[0] = pint(st);
+		min.add(0);
+		max.add(0);
+		for(int i = 1; i < n; i++) {
+			a[i] = pint(st);
+			int h = dp[i - 1] + 1;
+			while(!max.isEmpty() && a[i] > a[max.peek()]) {
+				int k = a[max.peek()];
+				h = Math.min(h, dp[max.pop()] + 1);
+				while(!max.isEmpty() && a[max.peek()] == k) {max.pop();}
+			}
+			if(!max.isEmpty()) {
+				h = Math.min(h, dp[max.peek()] + 1);
+			}
+			while(!min.isEmpty() && a[i] < a[min.peek()]) {
+				int k = a[min.peek()];
+				h = Math.min(h, dp[min.pop()] + 1);
+				while(!min.isEmpty() && a[min.peek()] == k) {min.pop();}
+			}
+			if(!min.isEmpty()) {
+				h = Math.min(h, dp[min.peek()] + 1);
+			}
+			dp[i] = h;
+			min.add(i);
+			max.add(i);
+		}
+		System.out.println(dp[n - 1]);
+	}
+	static int[] resize(int[] a) {
+		int[] r = new int[a.length * 2];
+		for(int i = 0; i < a.length; i++) {
+			r[i] = a[i];
+		}
+		return r;
+	}
+    static int pint(BufferedReader in) throws IOException {return Integer.parseInt(in.readLine());}
+    static int pint(StringTokenizer st) {return Integer.parseInt(st.nextToken());}
+}","import java.util.ArrayList;
+import java.util.Scanner;
+import java.util.Stack;
+
+public class D {
+    static Scanner sc = new Scanner(System.in);
+    static int[] height;
+    static int[] dp;
+
+    public static void main(String[] args) {
+        int n = sc.nextInt();
+        height = new int[n];
+        dp = new int[n];
+        dp[0] = 0;
+        for (int i = 0; i < n; i++) {
+            height[i] = sc.nextInt();
+        }
+        Stack<Integer> rise = new Stack<Integer>();
+        Stack<Integer> fail = new Stack<Integer>();
+        rise.push(0);
+        fail.push(0);
+        for (int i = 1; i < n; i++) {
+            dp[i] = dp[i-1]+1;
+
+            if (rise.isEmpty()) {
+                rise.push(i);
+            } else if (height[rise.peek()] < height[i]) {
+                rise.push(i);
+            } else {
+                while (!rise.isEmpty() && height[rise.peek()] > height[i]) {
+                    rise.pop();
+                    if (!rise.isEmpty()) {
+                        dp[i] = Math.min(dp[i], dp[rise.peek()] + 1);
+                    }
+                }
+                while (!rise.isEmpty() && height[rise.peek()] == height[i]) {
+                    rise.pop();
+                }
+                rise.push(i);
+            }
+
+
+            if (fail.isEmpty()) {
+                fail.push(i);
+            } else if (height[fail.peek()] > height[i]) {
+                fail.push(i);
+            } else {
+                while (!fail.isEmpty() && height[fail.peek()] < height[i]) {
+                    fail.pop();
+                    if (!fail.isEmpty()){
+                        dp[i] = Math.min(dp[i], dp[fail.peek()] + 1);
+                    }
+                }
+                while (!fail.isEmpty() && height[fail.peek()] == height[i]) {
+                    fail.pop();
+                }
+                fail.push(i);
+            }
+        }
+
+        System.out.println(dp[n - 1]);
+
+    }
+}
+//   a[i]
+//
+//
+//         6 7 6 2
+
+//3 5 6 4 5 6 3",0
+aa8091b0,ac180326,"import java.util.*;
+ 
+import java.io.*;
+ 
+public class AiseHi {
+	static Scanner sc = new Scanner(System.in);
+	static int mod = (int)(1e9+7);
+	public static void main (String[] args) {
+		PrintWriter out = new PrintWriter(System.out);
+		int t = 1;
+    	t = sc.nextInt();
+    	z : while(t-->0) {
+    		int n = sc.nextInt();
+    		int m = sc.nextInt();
+    		int x = sc.nextInt();
+    		PriorityQueue<twoval> myQueue = new PriorityQueue<>();
+    		for(int i=1;i<=m;i++) {
+    			myQueue.add(new twoval(0,i));
+    		}
+    		List<twoval> arrayList = new ArrayList<>();
+    		int myArray[] = new int[n];
+    		for(int i=0;i<n;i++) {
+    			int aasjd = sc.nextInt();
+    			arrayList.add(new twoval(aasjd,i));
+    			myArray[i] = aasjd;
+    		}
+    		Collections.sort(arrayList);
+    		int ans[] = new int[n];
+    		for(int i=n-1;i>=0;i--) {
+    			twoval p = myQueue.poll();
+    			long aasjd = p.myArray;
+    			int idx = p.b;
+    			aasjd += arrayList.get(i).myArray;
+    			ans[arrayList.get(i).b] = idx;
+    			myQueue.add(new twoval(aasjd,idx));
+    		}
+    		long dasdaknw[] = new long[m];
+    		long min = Long.MAX_VALUE, max = Long.MIN_VALUE;
+    		for(int i=0;i<n;i++) {
+    			dasdaknw[ans[i]-1] += myArray[i];
+    		}
+    		for(int i=0;i<m;i++) {
+    			min = Math.min(min, dasdaknw[ans[i]-1]);
+    			max = Math.max(max, dasdaknw[ans[i]-1]);
+    		}
+    		if(max-min>x) {
+    			out.write(""NO\n"");
+    			continue;
+    		}
+    		out.write(""YES\n"");
+    		for(int aasjd : ans) out.write(aasjd+"" "");
+    		out.write(""\n"");
+    	}
+		out.close();
+	}
+	static int ceil(int myArray,int b) {
+		return myArray/b + (myArray%b==0?0:1);
+	}
+	static boolean prime[] = new boolean[2000009];
+	static int fac[] = new int[2000009];
+	
+	static void sieve() {
+		prime[0] = true;
+		prime[1] = true;
+		int max = 1000000;
+		for(int i=2;i*i<=max;i++) {
+			if(!prime[i]) {
+				for(int j=i*i;j<=max;j+=i) {
+					prime[j] = true;
+					fac[j] = i;
+				}
+			}
+		}
+	}
+	static int gcd(int myArray,int b) { if(b==0) return myArray; return gcd(b,myArray%b); }
+}
+ 
+class twoval implements Comparable<twoval>{
+	long myArray;
+	int b;
+	twoval(long aasjd,int r){
+		this.myArray = aasjd;
+		this.b = r;
+	}
+	public int compareTo(twoval o) {
+		return (int) (this.myArray - o.myArray);
+	}
+}
+","//This code is written by प्रविण शंखपाळ 
+
+//package wizard;
+
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.text.DecimalFormat;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.Arrays;
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.Stack;
+import java.util.Queue;
+import java.util.PriorityQueue;
+import java.util.List;
+import java.util.HashSet;
+import java.util.LinkedHashSet;
+import java.util.TreeSet;
+import java.util.Map;
+import java.util.HashMap;
+import java.util.Scanner;
+import java.util.Set;
+import java.util.StringTokenizer;
+import java.util.Vector;
+
+public class Dobby {
+
+	public static void main(String[] args) {
+
+		try {
+
+			FastReader fr = new FastReader();
+			PrintWriter pt = new PrintWriter(System.out);
+
+			int t = fr.nextInt();
+
+			while (t > 0) {
+
+				int n = fr.nextInt(), m = fr.nextInt(), x = fr.nextInt();
+
+				ArrayList<Pair> pp = new ArrayList<>();
+
+				int A[] = new int[n];
+
+				for (int i = 0; i < n; i++) {
+					A[i] = fr.nextInt();
+					Pair pr = new Pair(A[i], i);
+					pp.add(pr);
+				}
+
+				Collections.sort(pp);
+				Collections.reverse(pp);
+
+				int ps[] = new int[n];
+				int pk[] = new int[n];
+				Arrays.fill(ps, 0);
+				Arrays.fill(pk, 0);
+
+				int index = 0;
+
+				for (int i = 0; i < n; i++) {
+
+					if (pk[index] < x) {
+						pk[index] += pp.get(i).a;
+					}
+					ps[pp.get(i).b] = index + 1;
+					index++;
+
+					index = index == m ? 0 : index;
+
+				}
+
+				pt.println(""YES"");
+
+				for (int i = 0; i < n; i++) {
+					pt.print(ps[i] + "" "");
+				}
+				pt.println();
+
+				t--;
+			}
+
+			pt.close();
+
+		} catch (
+
+		Exception e) {
+			return;
+		}
+	}
+
+	static void merge(long arr[], int l, int m, int r) {
+
+		int n1 = m - l + 1;
+		int n2 = r - m;
+
+		long L[] = new long[n1];
+		long R[] = new long[n2];
+
+		for (int i = 0; i < n1; ++i)
+			L[i] = arr[l + i];
+		for (int j = 0; j < n2; ++j)
+			R[j] = arr[m + 1 + j];
+
+		int i = 0, j = 0;
+
+		int k = l;
+		while (i < n1 && j < n2) {
+			if (L[i] <= R[j]) {
+				arr[k] = L[i];
+				i++;
+			} else {
+				arr[k] = R[j];
+				j++;
+			}
+			k++;
+		}
+
+		while (i < n1) {
+			arr[k] = L[i];
+			i++;
+			k++;
+		}
+
+		while (j < n2) {
+			arr[k] = R[j];
+			j++;
+			k++;
+		}
+	}
+
+	static void sort(long arr[], int l, int r) {
+		if (l < r) {
+
+			int m = l + (r - l) / 2;
+
+			sort(arr, l, m);
+			sort(arr, m + 1, r);
+
+			merge(arr, l, m, r);
+		}
+	}
+
+	static class Pair implements Comparable<Pair> {
+		int a, b;
+
+		Pair(int a, int b) {
+			this.a = a;
+			this.b = b;
+		}
+
+		public int compareTo(Pair o) {
+			// TODO Auto-generated method stub
+			if (this.a != o.a)
+				return Integer.compare(this.a, o.a);
+			else
+				return Integer.compare(this.b, o.b);
+			// return 0;
+		}
+
+		public boolean equals(Object o) {
+			if (o instanceof Pair) {
+				Pair p = (Pair) o;
+				return p.a == a && p.b == b;
+			}
+			return false;
+		}
+
+	}
+
+	static int binarySearch(int arr[], int first, int last, int key) {
+		int mid = (first + last) / 2;
+		while (first <= last) {
+			if (arr[mid] < key) {
+				first = mid + 1;
+			} else if (arr[mid] == key) {
+				return mid;
+			} else {
+				last = mid - 1;
+			}
+			mid = (first + last) / 2;
+		}
+		return -1;
+	}
+
+	static class FastReader {
+		BufferedReader br;
+		StringTokenizer st;
+
+		public FastReader() {
+			br = new BufferedReader(new InputStreamReader(System.in));
+		}
+
+		String next() {
+			while (st == null || !st.hasMoreElements()) {
+				try {
+					st = new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			}
+			return st.nextToken();
+		}
+
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+
+		double nextDouble() {
+			return Double.parseDouble(next());
+		}
+
+		String nextLine() {
+			String str = """";
+			try {
+				str = br.readLine();
+			} catch (IOException e) {
+				e.printStackTrace();
+			}
+			return str;
+		}
+	}
+}
+",0
+692a4496,f7006f16,"import java.io.*;
+import java.util.*;
+
+public class c {
+	public static BufferedReader in;
+
+	public static void main(String[] args) throws Exception {
+		in = new BufferedReader(new InputStreamReader(System.in));
+		PrintWriter out = new PrintWriter(System.out);
+		int numcases = Integer.parseInt(in.readLine());
+		for (int casenum = 0; casenum < numcases; casenum++) {
+			int n = Integer.parseInt(in.readLine());
+			int[] p = new int[n];
+			Arrays.fill(p, -1);
+			for (int i = 0; i < n; i++) {
+				if (p[i] != -1)
+					continue;
+				ArrayList<Integer> cycle = new ArrayList<>();
+				cycle.add(query(i));
+				while (cycle.size() == 1 || !cycle.get(0).equals(cycle.get(cycle.size() - 1))) {
+					cycle.add(query(i));
+				}
+				cycle.remove(cycle.size() - 1);
+				for(int j = 0; j < cycle.size() - 1; j++){
+					p[cycle.get(j)] = cycle.get(j + 1);
+				}
+				p[cycle.get(cycle.size() - 1)] = cycle.get(0);
+				//System.out.println(Arrays.toString(p));
+			}
+			StringBuilder b = new StringBuilder();
+			b.append(""! "");
+			for (int i = 0; i < n; i++) {
+				b.append((p[i] + 1) + (i < n - 1 ? "" "" : ""\n""));
+			}
+			System.out.print(b);
+			System.out.flush();
+		}
+		in.close();
+		out.close();
+	}
+
+	public static int query(int i) throws Exception {
+		System.out.println(""? "" + (i + 1));
+		System.out.flush();
+		int k = Integer.parseInt(in.readLine());
+		return k - 1;
+	}
+}
+","import java.io.*;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.StringTokenizer;
+
+
+public class C {
+
+    private static StringTokenizer st;
+    private static BufferedReader br;
+    private static PrintWriter out;
+
+    static boolean[]used;
+    static int[]p;
+
+    public static void main(String[] args) throws IOException {
+        br = new BufferedReader(new InputStreamReader(System.in));
+        out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
+
+        int t = nextInt();
+        while (t --> 0) {
+            int n = nextInt();
+            used = new boolean[n+1];
+            p = new int[n+1];
+            for (int i = 1; i <= n; i++) {
+                if (!used[i]) {
+                    go(i);
+                }
+            }
+            System.out.print(""! "");
+            for (int i = 1; i <= n; i++) {
+                System.out.print(p[i]+"" "");
+            }
+            System.out.println();
+        }
+        out.close();
+    }
+
+    private static void go(int i) throws IOException {
+        List<Integer> inCycle = new ArrayList<>();
+        int first = -1;
+        while (true) {
+            System.out.println(""? "" + i);
+            int x = nextInt();
+            used[x] = true;
+            if (x == first) {
+                break;
+            }
+            if (first == -1) {
+                first = x;
+            }
+            inCycle.add(x);
+        }
+        List<Integer> numbers = new ArrayList<>();
+        for (int j = 0; j < inCycle.size(); j++) {
+            if (inCycle.get(j) == i) {
+                for (int k = j; k < inCycle.size(); k++) {
+                    numbers.add(inCycle.get(k));
+                }
+                for (int k = 0; k < j; k++) {
+                    numbers.add(inCycle.get(k));
+                }
+                break;
+            }
+        }
+        if (numbers.size() == 1) {
+            p[numbers.get(0)] = numbers.get(0);
+        } else {
+            for (int j = 0; j < numbers.size()-1; j++) {
+                p[numbers.get(j)] = numbers.get(j+1);
+            }
+            p[numbers.get(numbers.size()-1)] = numbers.get(0);
+        }
+    }
+
+    private static int nextInt() throws IOException {
+        return Integer.parseInt(next());
+    }
+
+    private static long nextLong() throws IOException {
+        return Long.parseLong(next());
+    }
+
+    private static double nextDouble() throws IOException {
+        return Double.parseDouble(next());
+    }
+
+    private static String next() throws IOException {
+        while (st==null || !st.hasMoreTokens())
+            st = new StringTokenizer(br.readLine());
+        return st.nextToken();
+    }
+
+}",0
+2ef4c176,fa1bf524,"import java.io.*;
+import java.util.*;
+
+public class Template {
+
+	static int mod = 1000000007;
+
+	public static void main(String[] args) {
+		FastScanner sc = new FastScanner();
+		PrintWriter out = new PrintWriter(System.out);
+		int yo = sc.nextInt();
+		while (yo-- > 0) {
+			int n = sc.nextInt();
+			
+			Map<Integer,Pair> map = new HashMap<>();
+			
+			for(int i = 0; i < n; i++) {
+				map.put(i, new Pair(sc.nextLong(),sc.nextLong()));
+			}
+			
+			List<List<Integer>> list = new ArrayList<>();
+			for(int i = 0; i < n; i++) {
+				list.add(new ArrayList<>());
+			}
+			for(int i = 0; i < n-1; i++) {
+				int x = sc.nextInt()-1;
+				int y = sc.nextInt()-1;
+				list.get(x).add(y);
+				list.get(y).add(x);
+			}
+			
+			// l -> 0, r -> 1
+			
+			for(int i = 0; i < 1e5+3; i++) {
+				for(int j = 0; j < 2; j++) {
+					dp[i][j] = -1;
+				}
+			}
+			long a1 = dfs(map,list,0,0,-1);
+			long a2 = dfs(map,list,1,0,-1);
+			long ans = Math.max(a1, a2);
+			out.println(ans);
+		}
+		out.close();
+	}
+
+//	static Map<String,Long> dp = new HashMap<>();
+	static long[][] dp = new long[(int)1e5+10][2];
+	private static long dfs(Map<Integer, Pair> map, List<List<Integer>> list, 
+							int x, int node, int parent) {
+		
+		
+		if(dp[node][x] != -1) {
+			return dp[node][x];
+		}
+
+		List<Integer> neighbours = list.get(node);
+		
+		long ans1 = 0;
+		if(x == 0) {
+			ans1 = map.get(node).x;
+		}
+		else {
+			ans1 = map.get(node).y;
+		}
+		
+		
+		long uAns = 0;
+		for(int e : neighbours) {
+			if(e == parent) continue;
+			long ua1 = dfs(map,list,0,e,node);
+			long ua2 = dfs(map,list,1,e,node);
+			// consider 0
+			long a1 = ua1 + Math.abs(map.get(e).x-ans1);
+			// consider 1
+			long a2 = ua2 + Math.abs(map.get(e).y-ans1);
+			uAns += Math.max(a1, a2);
+		}
+		
+		return dp[node][x] = uAns;
+	}
+
+	static class Pair {
+		long x;
+		long y;
+
+		public Pair(long x, long y) {
+			this.x = x;
+			this.y = y;
+		}
+	}
+
+	static void ruffleSort(int[] a) {
+		
+		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);
+	}
+
+	static long gcd(long a, long b) {
+		if (b == 0)
+			return a;
+		return gcd(b, a % b);
+	}
+
+	static boolean[] sieve(int N) {
+		boolean[] sieve = new boolean[N];
+		for (int i = 2; i < N; i++)
+			sieve[i] = true;
+
+		for (int i = 2; i < N; i++) {
+			if (sieve[i]) {
+				if (i * i < 0)
+					continue;
+				for (int j = i * i; j < N; j += i) {
+					sieve[j] = false;
+				}
+			}
+		}
+		return sieve;
+	}
+
+	static long pow(int a, long b) {
+		if (b == 0) {
+			return 1;
+		}
+		if (b == 1) {
+			return a;
+		}
+		if (b % 2 == 0) {
+			long ans = pow(a, b / 2);
+			return ans * ans;
+		} else {
+			long ans = pow(a, (b - 1) / 2);
+			return a * ans * ans;
+		}
+
+	}
+
+	static class FastScanner {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st = new StringTokenizer("""");
+
+		String next() {
+			while (!st.hasMoreTokens())
+				try {
+					st = new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			return st.nextToken();
+		}
+
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+
+		int[] readArray(int n) {
+			int[] a = new int[n];
+			for (int i = 0; i < n; i++)
+				a[i] = nextInt();
+			return a;
+		}
+
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+	}
+
+	//	For Input.txt and Output.txt	
+	//	FileInputStream in = new FileInputStream(""input.txt"");
+	//	FileOutputStream out = new FileOutputStream(""output.txt"");
+	//	PrintWriter pw = new PrintWriter(out);
+	//	Scanner sc = new Scanner(in);
+}
+","import java.util.*;
+import java.io.*;
+
+public class Solution {
+
+    static LinkedList<Integer> graph[];
+    static long key[][];
+    static long value[][];
+
+    public static void main(String[] args) throws IOException {
+
+        Scanner in = new Scanner(System.in);
+        StringBuffer out=new StringBuffer();
+        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+
+        int t=Integer.parseInt(br.readLine());
+        String input[];
+
+        OUTER:
+        while(t--!=0) {
+
+            int n=Integer.parseInt(br.readLine());
+
+            value=new long[n][2];
+            key=new long[n][2];
+
+            for(int i=0; i<n; i++) {
+                input= br.readLine().split(""\\s"");
+                for(int j=0; j<2; j++) {
+                    key[i][j] = Integer.parseInt(input[j]);
+                }
+            }
+
+            graph=new LinkedList[n];
+            for(int i=0; i<n; i++)
+                graph[i]=new LinkedList();
+
+            for(int i=1; i<n; i++) {
+                input= br.readLine().split(""\\s"");
+                int u=Integer.parseInt(input[0])-1, v=Integer.parseInt(input[1])-1;
+                graph[u].add(v);
+                graph[v].add(u);
+            }
+
+            int root=-1;
+            for(int i=0; i<n; i++)
+                if(graph[i].size()==1) {
+                    root=i;
+                    break;
+                }
+
+            solve(root, -1);
+
+            out.append(Math.max(value[root][0], value[root][1])+""\n"");
+        }
+
+        System.out.print(out);
+    }
+
+    private static void solve(int vertex, int parent) {
+
+        for(int child: graph[vertex]) {
+            if(child!=parent) {
+                solve(child, vertex);
+                for(int i=0; i<2; i++) {
+                    long max=Long.MIN_VALUE;
+                    for(int j=0; j<2; j++) {
+                        max=Math.max(max, Math.abs(key[vertex][i]-key[child][j])+value[child][j]);
+                    }
+                    value[vertex][i]+=max;
+                }
+            }
+        }
+
+//        System.out.println(vertex+"" ""+Arrays.toString(key[vertex])+"" ""+Arrays.toString(value[vertex]));
+    }
+}",0
+8703709f,f0801d53,"import java.io.*;
+import java.util.*;
+
+public class Main {
+
+//	static boolean[] prime = new boolean[10000000];
+	final static long mod = 1000000007;
+
+	public static void main(String[] args) {
+//		sieve();
+		InputReader in = new InputReader(System.in);
+		PrintWriter out = new PrintWriter(System.out);
+
+		int t = in.nextInt();
+		while (t-- > 0) {
+			int n = in.nextInt();
+
+			Integer[] k = intInput(n, in), h = intInput(n, in);
+			long ans = 0;
+			int a = k[n - 1];
+			int current = k[n - 1];
+			for (int i = n - 1; i >= 0; i--) {
+				if (current > k[i]) {
+					ans += sum(a - current + 1);
+					a = k[i];
+					current = k[i]-h[i]+1;
+				}else {
+					current = Math.min(current, k[i] - h[i]+1);
+				}
+			}
+			ans += sum(a - current + 1);
+			out.println(ans);
+		}
+
+		out.flush();
+	}
+
+	static long sum(long a) {
+		return a * (a + 1) / 2;
+	}
+
+	static boolean prime(long k) {
+		for (int i = 2; i * i <= k; i++) {
+			if (k % i == 0) {
+				return false;
+			}
+		}
+		return true;
+	}
+
+	static long gcd(long a, long b) {
+		if (a % b == 0) {
+			return b;
+		} else {
+			return gcd(b, a % b);
+		}
+	}
+
+	static void reverseArray(Integer[] a) {
+		for (int i = 0; i < (a.length >> 1); i++) {
+			Integer temp = a[i];
+			a[i] = a[a.length - 1 - i];
+			a[a.length - 1 - i] = temp;
+		}
+	}
+
+	static Integer[] intInput(int n, InputReader in) {
+		Integer[] a = new Integer[n];
+		for (int i = 0; i < a.length; i++)
+			a[i] = in.nextInt();
+		return a;
+	}
+
+	static Long[] longInput(int n, InputReader in) {
+		Long[] a = new Long[n];
+		for (int i = 0; i < a.length; i++)
+			a[i] = in.nextLong();
+		return a;
+	}
+
+	static String[] strInput(int n, InputReader in) {
+		String[] a = new String[n];
+		for (int i = 0; i < a.length; i++)
+			a[i] = in.next();
+		return a;
+	}
+
+//	static void sieve() {
+//		for (int i = 2; i * i < prime.length; i++) {
+//			if (prime[i])
+//				continue;	
+//			for (int j = i * i; j < prime.length; j += i) {
+//				prime[j] = true;
+//			}
+//		}
+//	}
+
+}
+
+class Data {
+	int val;
+	int ind;
+	boolean positive;
+
+	Data(int val, int ind) {
+		this.val = Math.abs(val);
+		this.ind = ind;
+		this.positive = val >= 0;
+	}
+}
+
+class compareVal implements Comparator<Data> {
+
+	@Override
+	public int compare(Data o1, Data o2) {
+//		return (o1.val - o2.val == 0 ? o1.ind - o2.ind : o1.val - o2.val);
+		return (o1.val - o2.val);
+	}
+
+}
+
+class compareInd implements Comparator<Data> {
+
+	@Override
+	public int compare(Data o1, Data o2) {
+		return o1.ind - o2.ind == 0 ? o1.val - o2.val : o1.ind - o2.ind;
+	}
+
+}
+
+class InputReader {
+	public BufferedReader reader;
+	public StringTokenizer tokenizer;
+
+	public InputReader(InputStream stream) {
+		reader = new BufferedReader(new InputStreamReader(stream), 32768);
+		tokenizer = null;
+	}
+
+	public String next() {
+		while (tokenizer == null || !tokenizer.hasMoreTokens()) {
+			try {
+				tokenizer = new StringTokenizer(reader.readLine());
+			} catch (IOException e) {
+				throw new RuntimeException(e);
+			}
+		}
+		return tokenizer.nextToken();
+	}
+
+	public int nextInt() {
+		return Integer.parseInt(next());
+	}
+
+	long nextLong() {
+		return Long.parseLong(next());
+	}
+
+	double nextDouble() {
+		return Double.parseDouble(next());
+	}
+
+	String nextLine() {
+		String str = """";
+		try {
+			str = reader.readLine();
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+		return str;
+	}
+
+}","import java.util.*;
+import java.io.*;
+
+public class hmm {
+
+	static Scanner sc = new Scanner(System.in);
+	static PrintWriter pw = new PrintWriter(System.out);
+
+
+	public static void main(String[] args) throws Exception {
+		int t =sc.nextInt();
+		while (t-- > 0) {
+             int n = sc.nextInt();
+             int []k = sc.nextIntArray(n);
+             int h[]=sc.nextIntArray(n);
+     
+             long mana = 0;
+             pair cur = new pair(k[n-1]-h[n-1]+1,k[n-1]);
+             for(int i=n-1;i>=0;i--) {
+            	 int s = k[i];
+            	 int start = s-h[i]+1;
+            	 if(s>=cur.x) {
+            		 cur.x = Math.min(start, cur.x);
+            	 }
+            	 else {
+            		 long x = cur.y - cur.x +1;
+            		 mana += x*(x+1)/2;
+            		 cur.x = start;
+            		 cur.y = s;
+            	 }
+             }
+       
+             long x = cur.y - cur.x +1;
+       
+    		 mana += x*(x+1)/2;
+    		 pw.println(mana);
+             
+           
+		}
+
+		pw.close();
+
+	}
+
+	// -------------- stuff ------------------------------
+	static class pair {
+		int x ;
+		int y;
+	
+		
+		public pair(int n,int c) {
+			x= n;
+			y = c;
+		
+			
+		}
+	
+	
+		
+	}
+
+	static class Scanner {
+		StringTokenizer st;
+		BufferedReader br;
+
+		public Scanner(InputStream s) {
+			br = new BufferedReader(new InputStreamReader(s));
+		}
+
+		public Scanner(FileReader r) {
+			br = new BufferedReader(r);
+		}
+
+		public String next() throws IOException {
+			while (st == null || !st.hasMoreTokens())
+				st = new StringTokenizer(br.readLine());
+			return st.nextToken();
+		}
+
+		public int nextInt() throws IOException {
+			return Integer.parseInt(next());
+		}
+
+		public long nextLong() throws IOException {
+			return Long.parseLong(next());
+		}
+
+		public String nextLine() throws IOException {
+			return br.readLine();
+		}
+
+		public int[] nextIntArray(int n) throws IOException {
+			int[] a = new int[n];
+			for (int i = 0; i < n; i++)
+				a[i] = nextInt();
+			return a;
+		}
+
+	}
+
+}",0
+0ea5a836,3c74c140,"import java.util.*;
+import java.io.*;
+public class Solution
+{
+    static class FastReader 
+    { 
+        BufferedReader br; 
+        StringTokenizer st; 
+  
+        public FastReader() 
+        { 
+            br = new BufferedReader(new
+                     InputStreamReader(System.in)); 
+        } 
+  
+        String next() 
+        { 
+            while (st == null || !st.hasMoreElements()) 
+            { 
+                try
+                { 
+                    st = new StringTokenizer(br.readLine()); 
+                } 
+                catch (IOException  e) 
+                { 
+                    e.printStackTrace(); 
+                } 
+            } 
+            return st.nextToken(); 
+        } 
+  
+        int nextInt() 
+        { 
+            return Integer.parseInt(next()); 
+        } 
+  
+        long nextLong() 
+        { 
+            return Long.parseLong(next()); 
+        } 
+  
+        double nextDouble() 
+        { 
+            return Double.parseDouble(next()); 
+        } 
+  
+        String nextLine() 
+        { 
+            String str = """"; 
+            try
+            { 
+                str = br.readLine(); 
+            } 
+            catch (IOException e) 
+            { 
+                e.printStackTrace(); 
+            } 
+            return str; 
+        } 
+    }
+    //static final long mod=(long)1e9+7;
+    static final long mod=998244353L;
+    public static long pow(long a,long p)
+    {
+        long res=1;
+        while(p>0)
+        {
+            if(p%2==1)
+            {
+                p--;
+                res*=a;
+                res%=mod;
+            }
+            else
+            {
+                a*=a;
+                a%=mod;
+                p/=2;
+            }
+        }
+        return res;
+    }
+    static class Pair
+    {
+        int u,v;
+        Pair(int u,int v)
+        {
+            this.u=u;
+            this.v=v;
+        }
+    }
+    /*static class Pair implements Comparable<Pair>
+    {
+        int v,l;
+        Pair(int v,int l)
+        {
+            this.v=v;
+            this.l=l;
+        }
+        public int compareTo(Pair p)
+        {
+            return l-p.l; 
+        }
+    }*/
+    static long gcd(long a,long b)
+    {
+        if(b%a==0)
+        return a;
+        return gcd(b%a,a);
+    }
+    public static class comp implements Comparator<Pair>
+    {
+        public int compare(Pair p1,Pair p2)
+        {
+            if(p1.v>p2.v)
+            return 1;
+            return -1;
+        }
+    }
+    public static void upd1(int a[],int i)
+    {
+        for(;i<a.length;i+=(i&(-i)))
+        a[i]+=1;
+    }
+    public static void upd2(long a[],int up)
+    {
+        for(int i=up;i<a.length;i+=(i&(-i)))
+        a[i]=a[i]+1L*up;
+    }
+    public static int q1(int a[],int i)
+    {
+        int s=0;
+        for(;i>0;i-=(i&(-i)))
+        s+=a[i];
+        return s;
+    }
+    public static long q2(long a[],int i)
+    {
+        long s=0;
+        for(;i>0;i-=(i&(-i)))
+        s+=a[i];
+        return s;
+    }
+    public static void main(String args[])throws Exception
+    {
+        FastReader fs=new FastReader();
+        PrintWriter pw=new PrintWriter(System.out);
+        int tc=fs.nextInt();
+        while(tc-->0)
+        {
+            int n=fs.nextInt();
+            char[][] c=new char[n][];
+            for(int i=0;i<n;i++)
+            c[i]=fs.nextLine().toCharArray();
+            ArrayList<Integer> list[]=new ArrayList[5];
+            for(int i=0;i<5;i++)
+            list[i]=new ArrayList<>();
+            for(int i=0;i<n;i++)
+            {
+                int cnt[]=new int[5];
+                for(int j=0;j<c[i].length;j++)
+                cnt[c[i][j]-'a']++;
+                for(int j=0;j<5;j++)
+                list[j].add(2*cnt[j]-c[i].length);
+            }
+            for(int i=0;i<5;i++)
+            Collections.sort(list[i]);
+            int ans=0;
+            for(int i=0;i<5;i++)
+            {
+                int s=0;
+                for(int j=n-1;j>=0;j--)
+                {
+                    ans=Math.max(ans,n-1-j);
+                    s+=list[i].get(j);
+                    if(s<=0)
+                    break;
+                }
+                if(s>0)
+                ans=n;
+            }
+            pw.println(ans);
+        }
+        pw.flush();
+        pw.close();
+    }
+}","
+//package com.company;
+
+
+
+import  java.math.*;
+import java.util.*;
+import java.lang.*;
+import java.io.*;
+
+
+
+public final class Main {
+
+    FastReader s;
+
+
+    public static void main (String[] args) throws java.lang.Exception
+    {
+
+        new Main().run();
+
+    }
+    void run()
+    {
+        s = new FastReader();
+        solve();
+    }
+   StringBuffer sb;
+   // int counter;
+    void solve()
+    {
+         sb = new StringBuffer();
+
+        for(int T = s.nextInt();T > 0;T--)
+        {
+
+
+            start();
+
+
+        }
+
+       // System.out.print(sb);
+
+    }
+
+
+    void start()
+    {
+
+        int n = s.nextInt();
+
+         int mat[][] = new int[n][5];
+        for(int i = 0; i<n; i++)
+        {
+            char [] x = s.nextLine().toCharArray();
+            for(char c : x)
+            {
+                mat[i][c-'a']++;
+            }
+            int p[] = new int[5];
+            int to = 0;
+            for(int j : mat[i])
+                to+=j;
+
+            for(int j = 0; j<5; j++)
+            {
+                mat[i][j]=2*mat[i][j]-to;
+            }
+        }
+
+        int ans  = 0;
+        for(int i = 0; i<5; i++)
+        {
+            int g = check(i,mat, n);
+            ans = Math.max(g,ans);
+        }
+        System.out.println(ans);
+
+
+
+    }
+
+    int check(int i, int mat[][], int n)
+    {
+        ArrayList<Integer> x = new ArrayList<>();
+        for(int j = 0; j<n; j++)
+        {
+            x.add(mat[j][i]);
+        }
+        Collections.sort(x);
+        int s = 0;
+        int cnt = 0;
+        int l = n-1;
+        while(l>=0)
+        {
+            int u = x.get(l);
+            if(s+u>0)
+            {
+                s+=u;
+                cnt++;
+            }
+            else
+                break;
+            l--;
+        }
+        return cnt;
+    }
+
+
+
+
+    long gcd(long a, long b)
+    {
+        if (b == 0)
+            return a;
+        return gcd(b, a % b);
+    }
+    long power(long x, long y, long p)
+    {
+        long res = 1; // Initialize result
+
+        // Update x if it is more
+        // than or equal to p
+        x = x % p;
+
+        while (y > 0)
+        {
+            // If y is odd, multiply
+            // x with the result
+            if ((y & 1) > 0)
+                res = (res * x) % p;
+
+            // y must be even now
+            y = y >> 1; // y = y/2
+            x = (x * x) % p;
+        }
+        return res;
+    }
+
+    int lower_bound(int [] arr , int key)
+    {
+
+        int i = 0;
+        int j = arr.length-1;
+          //if(arr[i] > key)return -1;
+         if(arr[j] < key)return -1;
+
+        while(i<j)
+        {
+            int mid = (i+j)/2;
+
+            if(arr[mid] == key)
+            {
+                j = mid;
+            }
+
+            else if(arr[mid] < key)
+            {
+                i = mid+1;
+            }
+            else
+                j = mid-1;
+      }
+
+        return i;
+    }
+
+    int upper_bound(int [] arr , int key)
+    {
+
+        int i = 0;
+        int j = arr.length-1;
+        if(arr[j] <= key)return j+1;
+
+        while(i<j)
+        {
+            int mid = (i+j)/2;
+
+
+
+             if(arr[mid] <= key)
+            {
+                i = mid+1;
+            }
+            else
+                j = mid;
+        }
+
+        return i;
+    }
+
+
+    static void sort(int[] A){
+        int n = A.length;
+        Random rnd = new Random();
+        for(int i=0; i<n; ++i){
+            int tmp = A[i];
+            int randomPos = i + rnd.nextInt(n-i);
+            A[i] = A[randomPos];
+            A[randomPos] = tmp;
+        }
+        Arrays.sort(A);
+    }
+    static void sort(long[] A){
+        int n = A.length;
+        Random rnd = new Random();
+        for(int i=0; i<n; ++i){
+            long tmp = A[i];
+            int randomPos = i + rnd.nextInt(n-i);
+            A[i] = A[randomPos];
+            A[randomPos] = tmp;
+        }
+        Arrays.sort(A);
+    }
+    static String sort(String s) {
+        Character ch[]=new Character[s.length()];
+        for(int i=0;i<s.length();i++) {
+            ch[i]=s.charAt(i);
+        }
+        Arrays.sort(ch);
+        StringBuffer st=new StringBuffer("""");
+        for(int i=0;i<s.length();i++) {
+            st.append(ch[i]);
+        }
+        return st.toString();
+    }
+
+    //long array input
+    public long [] longArr(int len)
+    {
+        // long arr input
+        long [] arr = new long[len];
+        String [] strs =  s.nextLine().trim().split(""\\s+"");
+        for(int i =0; i<len; i++)
+        {
+            arr[i] = Long.parseLong(strs[i]);
+
+        }
+        return arr;
+    }
+    // int arr input
+    public int [] intArr(int len)
+    {
+        // long arr input
+        int [] arr = new int[len];
+        String [] strs =  s.nextLine().trim().split(""\\s+"");
+        for(int i =0; i<len; i++)
+        {
+            arr[i] = Integer.parseInt(strs[i]);
+
+        }
+        return arr;
+    }
+
+    static class FastReader
+    {
+        BufferedReader br;
+        StringTokenizer st;
+
+        public FastReader()
+        {
+            br = new BufferedReader(new
+                    InputStreamReader(System.in));
+        }
+
+        String next()
+        {
+            while (st == null || !st.hasMoreElements())
+            {
+                try
+                {
+                    st = new StringTokenizer(br.readLine());
+                }
+                catch (IOException  e)
+                {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt()
+        {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong()
+        {
+            return Long.parseLong(next());
+        }
+
+        double nextDouble()
+        {
+            return Double.parseDouble(next());
+        }
+
+        String nextLine()
+        {
+            String str = """";
+            try
+            {
+                str = br.readLine();
+            }
+            catch (IOException e)
+            {
+                e.printStackTrace();
+            }
+            return str;
+        }
+    }
+
+
+
+}
+",0
+ca8f11a4,e19376ca,"
+import java.util.*;
+import java.util.stream.Collectors;
+import java.io.*;
+import java.math.*;
+
+public class GR18_C2 {
+	public static FastScanner sc;
+	public static StringBuilder sb ;public static int MOD= 1000000007;
+	public static class FastScanner {
+		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st=new StringTokenizer("""");
+		String next() {
+			while (!st.hasMoreTokens())
+				try { 
+					st=new StringTokenizer(br.readLine());				               
+	             } catch (IOException e) {}
+				return st.nextToken();
+			}
+		
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+		String nextLine() throws IOException {
+			return br.readLine();
+		}
+    }
+
+    public static void solve(int t) throws IOException {
+    	int n=sc.nextInt();
+    	String a=sc.next();
+    	String b=sc.next();
+    	
+    	int _00=0;
+    	int _01=0;
+    	int _10=0;
+    	int _11=0;
+    	
+    	for(int i=0;i<n;i++) {
+    		if(a.charAt(i)=='0' && b.charAt(i)=='0') _00++;
+    		if(a.charAt(i)=='0' && b.charAt(i)=='1') _01++;
+    		if(a.charAt(i)=='1' && b.charAt(i)=='0') _10++;
+    		if(a.charAt(i)=='1' && b.charAt(i)=='1') _11++;
+    	}
+    	
+    	int ans=Integer.MAX_VALUE;
+    	
+    	
+    	// All _01 and _10 can be converted to _11 and _00 by swapping and this requires to operations
+    	if(_01==_10) {
+    		ans=Math.min(ans, _10*2);
+    	}
+    	// By performing one operation, we get _01==_10 and then even operations can be done.
+    	// Possible when _11=_00 and one additional _11 for odd operation
+    	if(_00+1==_11) {
+    		ans=Math.min(ans, (_11-1)*2+1);
+    	}
+    	if(ans==Integer.MAX_VALUE) sb.append(-1).append('\n');
+    	else sb.append(ans).append('\n');
+    }
+    
+	public static void main(String[] args) throws IOException {
+		sb = new StringBuilder("""");
+		sc = new FastScanner();
+		int t=sc.nextInt();
+		for(int i=1;i<=t;i++){
+			solve(i);
+		}
+		System.out.println(sb);
+	}
+	
+	
+}
+","import java.io.*;
+import java.util.*;
+
+public class new1{
+
+    public static long gcd(long a, long b)
+    {
+        if (a == 0)
+            return b;
+          
+        return gcd(b%a, a);
+    }
+    public static int count(int[] arr, int[] dest) {
+    	int n = arr.length;
+    	int count = 0;
+    	for(int i = 0; i < n; i++) {
+    		if(arr[i] != dest[i]) count++;
+    	}
+    	return count;
+    }
+    
+    
+    
+
+	
+	public static void main(String[] args)  throws IOException{
+    	BufferedWriter output = new BufferedWriter(new OutputStreamWriter(System.out));
+		FastReader s = new FastReader();
+		int t = s.nextInt();
+		
+		
+    	for(int z = 0; z < t; z++) {
+    		int n = s.nextInt();
+    		String str1 = s.next();
+    		String str2 = s.next();
+    		int count1  = 0; int count2 = 0;
+    		for(int i = 0; i < n; i++) {
+    			if(str1.charAt(i) == '1') count1++;
+    			if(str2.charAt(i) == '1') count2++;
+    		}
+    		if(!(count1 == count2 || n - count1 + 1 == count2)) {
+    			System.out.println(-1);
+    			continue;
+    		}
+    		
+    		int[] arr = new int[n];
+    		int[] dest = new int[n];
+    		for(int i = 0; i < n; i++) {
+    			arr[i] = str1.charAt(i) - '0';
+    			dest[i] = str2.charAt(i) - '0';
+    		}
+    		int ans1 = count(arr, dest);
+    		int ans2 = Integer.MAX_VALUE;
+    		int flag = 0;
+    		for(int i = 0; i < n; i++) {
+    			if(flag == 0 && arr[i] == 1 && dest[i] == 1) {
+    				flag = 1;
+    			}
+    			else {
+    				arr[i] = 1 - arr[i];
+    			}
+    		}
+    		//System.out.println(ans1);
+    		if(flag == 1) {
+    			ans2 = Math.min(ans2, count(arr, dest) + 1);
+    		}
+    		else {
+    			for(int i = 0; i < n; i++) {
+    				if(str1.charAt(i) == '1' && flag == 0) {
+    					flag = 1; arr[i] = 1;
+    					break;	
+    				}
+    			}
+    			
+    		}
+    		if(flag == 1) ans2 = Math.min(ans2, count(arr, dest) + 1);
+    		int ans = Integer.MAX_VALUE;
+    		if(count1 == count2) ans = Math.min(ans, ans1);
+    		if(n - count1 + 1 == count2) ans = Math.min(ans, ans2);
+    		System.out.println(ans);
+    		
+    		
+    		
+    	}
+    	//output.flush();
+
+    }
+}
+
+
+class FastReader {
+    BufferedReader br;
+    StringTokenizer st;
+    public FastReader() {
+        br = new BufferedReader(new InputStreamReader(System.in));
+    }
+    String next() {
+        while (st == null || !st.hasMoreElements()) {
+            try {
+                st = new StringTokenizer(br.readLine());
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+        }
+        return st.nextToken();
+    }
+ 
+    public int nextInt() {
+        return Integer.parseInt(next());
+    }
+ 
+    long nextLong() {
+        return Long.parseLong(next());
+    }
+ 
+    double nextDouble() {
+        return Double.parseDouble(next());
+    }
+ 
+    String nextLine() {
+        String str = """";
+        try {
+            str = br.readLine();
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        return str;
+}}",0
+d2eb953e,dcf09f37,"import java.util.*;
+// import java.lang.*;
+import java.io.*;
+
+//           THIS TEMPLATE MADE BY AKSH BANSAL.
+
+public class Solution {
+    static class FastReader {
+        BufferedReader br;
+        StringTokenizer st;
+
+        public FastReader() {
+            br = new BufferedReader(new InputStreamReader(System.in));
+        }
+
+        String next() {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+
+        String nextLine() {
+            String str = """";
+            try {
+                str = br.readLine();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+        }
+    }
+    private static boolean[] isPrime;
+    private static void primes(){
+        int num = (int)1e6; // PRIMES FROM 1 TO NUM
+        isPrime = new boolean[num];
+     
+        for (int i = 2; i< isPrime.length; i++) {
+           isPrime[i] = true;
+        }
+        for (int i = 2; i< Math.sqrt(num); i++) {
+           if(isPrime[i] == true) {
+              for(int j = (i*i); j<num; j = j+i) {
+                 isPrime[j] = false;
+              }
+           }
+        }
+    }
+    private static long gcd(long a, long b){
+        if(b==0)return a;
+        return gcd(b,a%b);
+    }
+    private static long pow(long x,long y){
+        if(y==0)return 1;
+        long temp = pow(x, y/2);
+        if(y%2==1){
+            return x*temp*temp;
+        }
+        else{
+            return temp*temp;
+        }
+    }
+    static ArrayList<Integer>[] adj;
+    static void getAdj(int n,int q, FastReader sc){
+        adj = new ArrayList[n+1];
+        for(int i=1;i<=n;i++){
+            adj[i] = new ArrayList<>();
+        }
+        for(int i=0;i<q;i++){
+            int a = sc.nextInt();
+            int b = sc.nextInt();
+
+            adj[a].add(b);
+            adj[b].add(a);
+        }
+    }
+    static PrintWriter out;
+    public static void main(String[] args) throws IOException {
+        FastReader sc = new FastReader();
+        out = new PrintWriter(System.out);
+        // primes();
+        // ________________________________
+
+        int t = sc.nextInt();
+        StringBuilder output = new StringBuilder();
+
+        while (t-- > 0) {
+            int n = sc.nextInt();
+            pair = new int[n+1][2];
+            dp = new long[n+1][2];
+            for(int i=1;i<=n;i++){
+                pair[i][0]=sc.nextInt();
+                pair[i][1]=sc.nextInt();
+            }
+            getAdj(n, n-1, sc);
+            output.append(solver(n)).append(""\n"");
+        }
+
+        out.println(output);
+        // _______________________________
+
+        // int n = sc.nextInt();
+        // out.println(solver());
+        // ________________________________
+        out.flush();
+    }
+
+    static int[][] pair;
+    static long[][] dp;
+
+    public static long solver(int n) {
+        dfs(1,  0);
+        return Math.max(dp[1][0], dp[1][1]);
+    }
+
+    static void dfs(int node, int parent){
+        for(Integer child: adj[node]){
+            if(child!=parent){
+                dfs(child,  node);
+                long left1 = Math.abs(pair[node][0]-pair[child][0]) + dp[child][0];
+                long right1 = Math.abs(pair[node][0]-pair[child][1]) + dp[child][1];
+                long left2 = Math.abs(pair[node][1]-pair[child][0]) + dp[child][0];
+                long right2 = Math.abs(pair[node][1]-pair[child][1]) + dp[child][1];
+                dp[node][0] += Math.max(left1, right1);
+                dp[node][1] += Math.max(left2, right2);
+            }
+        }
+    }
+}","/*
+ * akshaygupta26
+ */
+import java.io.*;
+import java.util.*;
+
+public class E
+{ 
+	
+	static long dp[][];
+	static long val[][];
+	static ArrayList<Integer> arr[];
+    public static void main(String[] args) 
+	{ 
+		FastReader sc=new FastReader(); 
+		StringBuffer ans=new StringBuffer();
+		int test=sc.nextInt();
+		while(test-->0)
+		{
+			int n=sc.nextInt();
+			arr=new ArrayList[n+1];
+			val=new long[n+1][2];
+			dp=new long[n+1][2];
+			for(int i=0;i<=n;i++) Arrays.fill(dp[i], -1);
+			for(int i=1;i<=n;i++) {
+				val[i][0]=sc.nextLong();val[i][1]=sc.nextLong();
+			}
+			for(int i=0;i<=n;i++) arr[i]=new ArrayList<>();
+			for(int i=0;i<n-1;i++) {
+				int a=sc.nextInt(),b=sc.nextInt();
+				arr[a].add(b);arr[b].add(a);
+			}
+			long max1=0,max2=0;
+			
+			for(int ch:arr[1]) {
+				max1+=solve(ch,0,1);
+				max2+=solve(ch,1,1);
+			}
+			ans.append(Math.max(max1, max2)+""\n"");
+		}
+		
+	    System.out.print(ans);
+	} 
+    
+    static long solve(int nd,int prv,int par) {
+    	
+    	
+    	
+    	if(dp[nd][prv] != -1) return dp[nd][prv];
+    	
+    	long l=Math.abs(val[par][prv]-val[nd][0]);long r=Math.abs(val[par][prv]-val[nd][1]);
+    
+    		for(int ch:arr[nd]) {
+    			if(ch != par) {
+    				l+=solve(ch,0,nd);//Take left
+    				r+=solve(ch,1,nd);//Take right
+    			}
+    		}
+    
+    		return dp[nd][prv] =Math.max(l, r);
+    }
+ 
+    static long _gcd(long a,long b) {
+    	if(b == 0) return a;
+    	return _gcd(b,a%b);
+    }
+    
+    static final Random random=new Random();
+    
+	static void ruffleSort(int[] a) {
+		int n=a.length;//shuffle, then sort 
+		for (int i=0; i<n; i++) {
+			int oi=random.nextInt(n), temp=a[oi];
+			a[oi]=a[i]; a[i]=temp;
+		}
+		Arrays.sort(a);
+	}
+	
+	static void ruffleSort(long[] a) {
+		int n=a.length;//shuffle, then sort 
+		for (int i=0; i<n; i++) {
+			int oi=random.nextInt(n);
+			long temp=a[oi];
+			a[oi]=a[i]; a[i]=temp;
+		}
+		Arrays.sort(a);
+	}
+	
+	static class FastReader 
+	{ 
+		BufferedReader br; 
+		StringTokenizer st; 
+
+		public FastReader() 
+		{ 
+			br = new BufferedReader(new
+					InputStreamReader(System.in)); 
+		} 
+
+		String next() 
+		{ 
+			while (st == null || !st.hasMoreElements()) 
+			{ 
+				try
+				{ 
+					st = new StringTokenizer(br.readLine()); 
+				} 
+				catch (IOException e) 
+				{ 
+					e.printStackTrace(); 
+				} 
+			} 
+			return st.nextToken(); 
+		} 
+
+		int nextInt() 
+		{ 
+			return Integer.parseInt(next()); 
+		} 
+
+		long nextLong() 
+		{ 
+			return Long.parseLong(next()); 
+		} 
+
+		double nextDouble() 
+		{ 
+			return Double.parseDouble(next()); 
+		} 
+
+		String nextLine() 
+		{ 
+			String str = """"; 
+			try
+			{ 
+				str = br.readLine(); 
+			} 
+			catch (IOException e) 
+			{ 
+				e.printStackTrace(); 
+			} 
+			return str; 
+		} 
+	} 
+
+
+} 
+",0
+73f57af1,ac8ef97c,"/*input
+3
+2
+1 6
+3 8
+1 2
+3
+1 3
+4 6
+7 9
+1 2
+2 3
+6
+3 14
+12 20
+12 19
+2 12
+10 17
+3 17
+3 2
+6 5
+1 5
+2 6
+4 6
+
+
+*/
+import java.util.*;
+import java.lang.*;
+import java.io.*;
+
+public class Main
+{
+	static PrintWriter out;
+	static int MOD = 1000000007;
+	static FastReader scan;
+
+    /*-------- I/O usaing short named function ---------*/
+	public static String ns(){return scan.next();}
+	public static int ni(){return scan.nextInt();}
+	public static long nl(){return scan.nextLong();}
+	public static double nd(){return scan.nextDouble();}
+	public static String nln(){return scan.nextLine();}
+	public static void p(Object o){out.print(o);}
+	public static void ps(Object o){out.print(o + "" "");}
+	public static void pn(Object o){out.println(o);}
+    /*-------- for output of an array ---------------------*/
+     static void iPA(int arr []){
+     	 StringBuilder output = new StringBuilder();
+	     for(int i=0; i<arr.length; i++)output.append(arr[i] + "" "");out.println(output);
+	}
+	static void lPA(long arr []){
+	     StringBuilder output = new StringBuilder();
+	     for(int i=0; i<arr.length; i++)output.append(arr[i] + "" "");out.println(output);
+	}
+	static void sPA(String arr []){
+	     StringBuilder output = new StringBuilder();
+	     for(int i=0; i<arr.length; i++)output.append(arr[i] + "" "");out.println(output);
+	}
+	static void dPA(double arr []){
+	     StringBuilder output = new StringBuilder();
+	     for(int i=0; i<arr.length; i++)output.append(arr[i] + "" "");out.println(output);
+	}
+    /*-------------- for input in an array ---------------------*/
+	static void iIA(int arr[]){
+	     for(int i=0; i<arr.length; i++)arr[i] = ni();
+	}
+	static void lIA(long arr[]){
+	     for(int i=0; i<arr.length; i++)arr[i] = nl(); 
+	}
+	static void sIA(String arr[]){
+	     for(int i=0; i<arr.length; i++)arr[i] = ns(); 
+	}
+	static void dIA(double arr[]){
+	     for(int i=0; i<arr.length; i++)arr[i] = nd();
+	}
+	/*------------ for taking input faster ----------------*/
+     static class FastReader
+	{
+		BufferedReader br;
+		StringTokenizer st;
+
+		public FastReader()
+		{
+			br = new BufferedReader(new InputStreamReader(System.in));
+		}
+
+		String next()
+		{
+			while (st == null || !st.hasMoreElements())
+			{
+				try
+				{
+					st = new StringTokenizer(br.readLine());
+				}
+				catch (IOException e)
+				{
+					e.printStackTrace();
+				}
+			}
+			return st.nextToken();
+		}
+
+		int nextInt()
+		{
+			return Integer.parseInt(next());
+		}
+
+		long nextLong()
+		{
+			return Long.parseLong(next());
+		}
+
+		double nextDouble()
+		{
+			return Double.parseDouble(next());
+		}
+
+		String nextLine()
+		{
+			String str = """";
+			try
+			{
+				str = br.readLine();
+			}
+			catch (IOException e)
+			{
+				e.printStackTrace();
+			}
+			return str;
+		}
+	}
+
+	// Method to check if x is power of 2
+    static boolean isPowerOfTwo (int x) { return x!=0 && ((x&(x-1)) == 0);}
+    //Method to return lcm of two numbers
+    static int gcd(int a, int b){return a==0?b:gcd(b % a, a); }
+    //Method to count digit of a number
+    static int countDigit(long n){return (int)Math.floor(Math.log10(n) + 1);}
+
+    //Method for sorting
+	static void ruffle_sort(int[] a) {
+		//shandom_ruffle
+		Random r=new Random();
+		int n=a.length;
+		for (int i=0; i<n; i++) {
+			int oi=r.nextInt(n);
+			int temp=a[i];
+			a[i]=a[oi];
+			a[oi]=temp;
+		}
+		//sort
+		Arrays.sort(a);
+	}
+	//Method for checking if a number is prime or not
+	static boolean isPrime(int n) { 
+        if (n <= 1) return false; 
+        if (n <= 3) return true; 
+        if (n % 2 == 0 || n % 3 == 0) return false; 
+        for (int i = 5; i * i <= n; i = i + 6) 
+            if (n % i == 0 || n % (i + 2) == 0) 
+            return false; 
+        return true; 
+    } 
+
+    static long[] l, r;
+	public static void main (String[] args) throws java.lang.Exception
+	{
+		OutputStream outputStream =System.out;
+        out =new PrintWriter(outputStream);
+        scan =new FastReader();
+		//for fast output sometimes
+		StringBuilder sb = new StringBuilder();
+		int t = ni();
+		while(t-->0){
+			int n = ni();
+			l = new long[n];
+			r = new long[n];
+
+			for(int i=0; i<n; i++){
+				l[i] = nl();
+				r[i] = nl();
+			}
+
+			//lPA(l);
+			//lPA(r);
+
+			ArrayList<Integer> adj[] = new ArrayList[n];
+			for(int i=0; i<n; i++)
+				adj[i] = new ArrayList<Integer>();
+
+			for(int i=0; i<n-1; i++){
+				int u = ni()-1, v = ni()-1;
+				adj[u].add(v);
+				adj[v].add(u);
+			}
+
+			dp = new Long[n][2];
+			visited = new boolean[n];
+			long ans = Math.max(solve(adj, 0, 0, visited), solve(adj, 0, 1, visited));
+			pn(ans);
+        }
+        out.flush();
+		out.close();
+	}
+
+	static Long dp[][];
+	static boolean visited[];
+	static long solve(ArrayList<Integer> adj[], int vertex, int prev, boolean visited[]){
+
+		visited[vertex] = true;
+		if(dp[vertex][prev] != null)
+			return dp[vertex][prev];
+		long ans = 0;
+		for(int x : adj[vertex]){
+			if(!visited[x]){
+				if(prev == 0){
+					ans += Math.max(Math.abs(l[vertex] - l[x]) + solve(adj, x, 0, visited),
+						Math.abs(l[vertex] - r[x]) + solve(adj, x, 1, visited));
+					//pn(vertex + "" "" + x + "" "" + ans);
+				}else{
+					ans += Math.max(Math.abs(r[vertex] - l[x]) + solve(adj, x, 0, visited),
+						Math.abs(r[vertex] - r[x]) + solve(adj, x, 1, visited));
+					//pn(vertex + "" "" + x + "" "" + ans);
+				}
+			}
+		}
+		visited[vertex] = false;
+		//pn(ans);
+		return dp[vertex][prev] = ans;	
+	}
+	
+	
+}
+
+","import java.io.*;
+import java.util.*;
+
+public class Codeforces
+{
+    public static void main(String args[])throws Exception
+    {
+        BufferedReader bu=new BufferedReader(new InputStreamReader(System.in));
+        StringBuilder sb=new StringBuilder();
+        int t=Integer.parseInt(bu.readLine());
+        while(t-->0)
+        {
+            int n=Integer.parseInt(bu.readLine());
+            g=new ArrayList[n];
+            int i;
+            for(i=0;i<n;i++)
+            {
+                g[i]=new ArrayList<>();
+                String st[]=bu.readLine().split("" "");
+                a[i][0]=Integer.parseInt(st[0]); a[i][1]=Integer.parseInt(st[1]);
+                s[i][0]=s[i][1]=0;
+            }
+
+            for(i=0;i<n-1;i++)
+            {
+                String st[]=bu.readLine().split("" "");
+                int u=Integer.parseInt(st[0])-1,v=Integer.parseInt(st[1])-1;
+                g[u].add(v); g[v].add(u);
+            }
+
+            dfs(0,-1);
+            sb.append(Math.max(s[0][0],s[0][1])+""\n"");
+        }
+        System.out.print(sb);
+    }
+
+    static ArrayList<Integer> g[];
+    static int N=100000,a[][]=new int[N][2];
+    static long s[][]=new long[N][2];
+    static void dfs(int n,int p)
+    {
+        for(int x:g[n])
+        if(x!=p)
+        {
+            dfs(x,n);
+            s[n][0]+=Math.max(s[x][0]+Math.abs(a[x][0]-a[n][0]),s[x][1]+Math.abs(a[x][1]-a[n][0]));
+            s[n][1]+=Math.max(s[x][0]+Math.abs(a[x][0]-a[n][1]),s[x][1]+Math.abs(a[x][1]-a[n][1]));
+        }
+    }
+}
+",0
+0ee2f8f1,587307f2,"import java.util.*;
+public class Main{
+  public static void main(String args[]){
+    Scanner sc=new Scanner(System.in);
+    int T=sc.nextInt();
+    while(T-->0){
+     int n=sc.nextInt();
+     int arr[]=new int[n];
+     int min=Integer.MAX_VALUE;int max=Integer.MIN_VALUE;
+     for(int i=0;i<n;i++){
+      arr[i]=sc.nextInt();
+      min=Math.min(arr[i],min);
+      max=Math.max(arr[i],max);
+     }
+     while(min<=max){
+      int mid=min+(max-min)/2;
+      if(helper(arr,mid))
+       min=mid+1;
+       else max=mid-1;
+     }
+     System.out.println(min-1);
+    }
+  }
+  public static boolean helper(int arr[],int min){
+   int tmp[]=Arrays.copyOf(arr,arr.length);
+   for(int i=arr.length-1;i>=2;i--){
+    if(tmp[i]<min)
+     return false;
+    int d=(Math.min(arr[i],tmp[i]-min))/3;
+    tmp[i-1]+=d;
+    tmp[i-2]+=d*2;
+   }
+   return tmp[1]>=min && tmp[0]>=min;
+  }
+}","import java.util.*;
+public class Main{
+  public static void main(String args[]){
+    Scanner sc=new Scanner(System.in);
+    int T=sc.nextInt();
+    while(T-->0){
+     int n=sc.nextInt();
+     int arr[]=new int[n];
+     int min=Integer.MAX_VALUE;int max=Integer.MIN_VALUE;
+     for(int i=0;i<n;i++){
+      arr[i]=sc.nextInt();
+      min=Math.min(arr[i],min);
+      max=Math.max(arr[i],max);
+     }
+     while(min<=max){
+      int mid=min+(max-min)/2;
+      if(helper(arr,mid))
+       min=mid+1;
+       else max=mid-1;
+     }
+     System.out.println(min-1);
+    }
+  }
+  public static boolean helper(int arr[],int min){
+   int tmp[]=Arrays.copyOf(arr,arr.length);
+   for(int i=arr.length-1;i>=2;i--){
+    if(tmp[i]<min)
+     return false;
+    int d=(Math.min(arr[i],tmp[i]-min))/3;
+    tmp[i-1]+=d;
+    tmp[i-2]+=d*2;
+   }
+   return tmp[1]>=min && tmp[0]>=min;
+  }
+}",1
+5bf01190,79b9b897,"	// Main Code at the Bottom
+	import java.util.*;
+	import java.io.*; 
+	public class Main{
+		//Fast IO class
+	    static class FastReader {
+	        BufferedReader br; 
+	        StringTokenizer st; 
+	        public FastReader() {
+	        	boolean env=System.getProperty(""ONLINE_JUDGE"") != null;
+	        	//env=true;
+	        	if(!env) {
+	        		try {
+						br=new BufferedReader(new FileReader(""src\\input.txt""));
+					} catch (FileNotFoundException e) {
+						e.printStackTrace();
+					}
+	        	}
+	        	else br = new BufferedReader(new InputStreamReader(System.in)); 
+	        } 
+	        String next() {
+	            while (st == null || !st.hasMoreElements()) {
+	                try {
+	                    st = new StringTokenizer(br.readLine()); 
+	                } 
+	                catch (IOException  e) {
+	                    e.printStackTrace(); 
+	                } 
+	            } 
+	            return st.nextToken(); 
+	        } 
+	        int nextInt() {
+	            return Integer.parseInt(next()); 
+	        } 
+	        long nextLong() {
+	            return Long.parseLong(next()); 
+	        } 
+	        double nextDouble() {
+	            return Double.parseDouble(next()); 
+	        } 
+	        String nextLine() {
+	            String str = """"; 
+	            try {
+	                str = br.readLine(); 
+	            } 
+	            catch (IOException e) {
+	                e.printStackTrace(); 
+	            } 
+	            return str; 
+	        } 
+	    }     
+	    static long MOD=(long)1e9+7;
+	    //debug
+	    static void debug(Object... o) {
+	        System.out.println(Arrays.deepToString(o));
+	    }
+	    static FastReader sc=new FastReader();
+	    static PrintWriter out=new PrintWriter(System.out);  
+	    //Global variables and functions
+	    //Main function(The main code starts from here)
+	    public static void main (String[] args) throws java.lang.Exception {
+	    	int test=1;
+	    	test=sc.nextInt();
+	    	while(test-->0) {
+	    		int n=sc.nextInt();
+	    		long a[]=new long[n];
+	    		for(int i=0;i<n;i++) a[i]=sc.nextLong();
+	    		long x[]=new long[n],pre[]=new long[n];
+	    		pre[0]=a[0];
+	    		pre[1]=a[1];
+	    		for(int i=2;i<n;i++) pre[i]=a[i]+pre[i-2];
+	    		x[0]=n*a[0];
+	    		x[1]=n*a[1];
+	    		long m[]= {a[0],a[1]};
+	    		for(int i=2;i<n;i++) {
+	    			m[i%2]=Math.min(m[i%2],a[i]);
+
+	    			x[i]=(n-(i+2)/2)*m[i%2]+pre[i];
+	    			
+	    		}
+	    		long ans=Long.MAX_VALUE/10;
+	    		for(int i=1;i<n;i++) ans=Math.min(ans, x[i]+x[i-1]);
+	    		out.println(ans);
+	    				
+	    	}
+	        out.flush();
+	        out.close();
+	    }
+	}","import java.io.*;
+import java.lang.*;
+import java.util.*;
+import java.io.*;
+import java.util.*;
+public class Main{
+	static Scanner scanner=new Scanner(System.in);
+	public static void main(String[] args) {
+		int q=scanner.nextInt();
+		while(q-->0) {
+			int n=scanner.nextInt();
+			long a[]=new long [n];
+			for(int i=0;i<n;i++)a[i]=scanner.nextLong();
+			long minr=Integer.MAX_VALUE;
+			long mind=Integer.MAX_VALUE;
+			long x=a[0],s=a[0]*n;
+			long y=a[1],ss=a[1]*n;
+			long ans=s+ss;
+			for(int i=2;i<n;i++) {
+				if(i%2==0) {
+					if(x<=a[i]) {
+						s+=(a[i]-x);
+					}else {
+						s-=(x-a[i])*(n-(i)/2);
+						x=a[i];
+						//System.out.println(""oooo"");
+					}
+				}else {
+					if(y<=a[i]) {
+						ss+=(a[i]-y);
+					}else {
+						//System.out.println(""ppp"");
+						ss-=(y-a[i])*(n-(i)/2);
+						y=a[i];
+					}
+				}
+				ans=Math.min(ans, s+ss);
+			}
+			System.out.println(ans);
+		}
+	}
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+",0
+5b9a0551,9debf95c,"import java.io.*;
+import java.lang.reflect.Array;
+import java.util.*;
+public class Main {
+
+    public static void main(String[] args) {
+        FastScanner in=new FastScanner();
+        PrintWriter out=new PrintWriter(System.out);
+        int t=in.nextInt();
+        while(t-->0)
+        solve(in,out);
+        out.close();
+    }
+    static void solve(FastScanner in,PrintWriter out){
+        int n=in.nextInt();
+        long a[]=new long[n];
+        for (int i = 0; i < n; i++) {
+            a[i]=in.nextLong();
+        }
+        long odd=Integer.MAX_VALUE,even=Integer.MAX_VALUE;
+        even=a[0];
+        long sum=a[0];
+        long ans=Long.MAX_VALUE;
+        for (int i = 1; i < n; i++) {
+            if(i%2==0) {
+                ans=Math.min(ans,(n-i/2)*a[i] + odd*(n-i/2) +sum);
+                even=Math.min(even,a[i]);
+            } else {
+                ans=Math.min(ans,(n-i/2)*a[i] + even*(n-i/2-1) +sum);
+                odd=Math.min(odd,a[i]);
+            }
+            sum+=a[i];
+        }
+        out.println(ans);
+    }
+
+    static class pair<U extends Comparable<U>, V extends Comparable<V>> implements Comparable<pair<U, V>> {
+        public U x;
+        public V y;
+
+        public pair(U x, V y) {
+            this.x = x;
+            this.y = y;
+        }
+
+        public int compareTo(pair<U, V> other) {
+            int i = x.compareTo(other.x);
+            if (i != 0) return i;
+            return y.compareTo(other.y);
+        }
+
+        public String toString() {
+            return x.toString() + "" "" + y.toString();
+        }
+
+        public boolean equals(Object obj) {
+            if (this.getClass() != obj.getClass()) return false;
+            pair<U, V> other = (pair<U, V>) obj;
+            return x.equals(other.x) && y.equals(other.y);
+        }
+
+        public int hashCode() {
+            return 31 * x.hashCode() + y.hashCode();
+        }
+
+    }
+
+    static void sort(int[] a) {
+        ArrayList<Integer> l=new ArrayList<>();
+        for (int i:a) l.add(i);
+        Collections.sort(l);
+        for (int i=0; i<a.length; i++) a[i]=l.get(i);
+    }
+
+    static class FastScanner {
+        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st=new StringTokenizer("""");
+        String next() {
+            while (!st.hasMoreTokens())
+                try {
+                    st=new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+        int[] readArray(int n) {
+            int[] a=new int[n];
+            for (int i=0; i<n; i++) a[i]=nextInt();
+            return a;
+        }
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+    }
+}
+","//    A Computer is Like a mischievous genie.
+//    It will give you exactly what you ask for,
+//    but not always what you want
+//    A code by Rahul Verma
+
+
+import java.io.BufferedOutputStream;
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.PriorityQueue;
+import java.util.Queue;
+import java.util.Stack;
+import java.util.StringTokenizer;
+import java.util.TreeMap;
+
+
+public class Main {
+
+
+    static class Clock {
+
+        protected long start, stop;
+
+        public void start() {
+            start = System.currentTimeMillis();
+        }
+
+        public void stop() {
+            stop = System.currentTimeMillis();
+        }
+
+        public String getTime() {
+            return ((stop - start) + "" ms"");
+        }
+    }
+
+
+    public static PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
+
+    static class FastReader {
+
+        BufferedReader br;
+        StringTokenizer st;
+
+        public FastReader() {
+            br = new BufferedReader(new
+                InputStreamReader(System.in));
+        }
+
+        String next() {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+
+        String[] nextSArray() {
+            String sr[] = null;
+            try {
+                sr = br.readLine().trim().split("" "");
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            return sr;
+        }
+
+        String nextLine() {
+            String str = """";
+            try {
+                str = br.readLine();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+
+            return str;
+        }
+    }
+
+
+    static long powmodulo(long a, long p) {
+        if (p == 0) {
+            return 1 % mod;
+        }
+        if (p == 1) {
+            return a % mod;
+        }
+        long ans = 1;
+        while (p > 0) {
+            if ((p & 1) > 0) {
+                ans = (ans * a) % mod;
+            }
+            a = (a * a) % mod;
+            p = p >> 1;
+        }
+        return ans % mod;
+    }
+
+
+    static long mod = 1000000007;
+
+    static long gcd(long a, long b) {
+        if (a == 0) {
+            return b;
+        }
+        return gcd(b % a, a);
+    }
+
+    static long fast_powerNumbers(long a, long n) {
+        if (n == 1) {
+            return a;
+        }
+        long ans = fast_powerNumbers(a, n / 2);
+        if (n % 2 == 0) {
+            return (ans * ans);
+        } else {
+            return ((ans * ans) * (a));
+        }
+    }
+
+
+    static void dfs_helper(int[][] arr, int i, int j, int team, int n, int m) {
+        arr[i][j] = team;
+        if (i - 1 >= 0 && arr[i - 1][j] == 1) {
+            dfs(arr, i - 1, j, team, n, m);
+        }
+        if (j - 1 >= 0 && arr[i][j - 1] == 1) {
+            dfs(arr, i, j - 1, team, n, m);
+        }
+        if (i + 1 < n && arr[i + 1][j] == 1) {
+            dfs(arr, i + 1, j, team, n, m);
+        }
+        if (j + 1 < m && arr[i][j + 1] == 1) {
+            dfs(arr, i, j + 1, team, n, m);
+        }
+
+    }
+
+    static void dfs(int[][] arr, int i, int j, int team, int n, int m) {
+        dfs_helper(arr, i, j, team, n, m);
+
+    }
+
+    static int parent[];
+    static int rank[];
+
+    static int find(int i) {
+        if (parent[i] == -1) {
+            parent[i] = i;
+            return i;
+        }
+
+        if (parent[i] == i) {
+            return i;
+        } else {
+            parent[i] = find(parent[i]);
+        }
+        return parent[i];
+
+    }
+
+    static void unite(int s1, int s2) {
+
+        if (rank[s1] > rank[s2]) {
+            parent[s2] = s1;
+            rank[s1] += rank[s2];
+        } else {
+            parent[s1] = s2;
+            rank[s2] += rank[s1];
+        }
+    }
+
+
+    public static long arr[];
+    public static int arr1[];
+
+//    static void seive(int n) {
+//        arr = new int[n + 1];
+//        arr[0] = arr[1] = 1;
+//        for (int i = 4; i <= n; i = i + 2) {
+//            arr[i] = 1;
+//        }
+//        for (int i = 3; i * i <= n; i = i + 2) {
+//            if (arr[i] == 0) {
+//                for (int j = i * i; j <= n; j = j + i) {
+//                    arr[j] = 1;
+//                }
+//
+//            }
+//        }
+//    }
+
+    static  void seive(int n)
+    {
+        arr1=new int[n+1];
+        arr1[0]=arr1[1]=1;
+        for (int i = 4; i <=n ; i+=2) {
+            arr1[i]=1;
+        }
+        for (int i = 3; i*i <=n ; i+=2) {
+            if (arr1[i] == 0)
+            {
+                for (int j = i*i; j <=n ; j+=i) {
+                    arr1[j]=1;
+                }
+            }
+        }
+
+    }
+
+    public static boolean ccw(Point a,Point b,Point c)
+    {
+        long s1=(c.x-b.x)*(b.y-a.y) ;
+        long s2 = (c.y-b.y)*(b.x-a.x);
+        if(s1<s2)
+            return true;
+        else
+            return false;
+
+    }
+    public static boolean col(Point a,Point b,Point c)
+    {
+        long s1=(c.x-b.x)*(b.y-a.y) ;
+        long s2 = (c.y-b.y)*(b.x-a.x);
+        if(s1==s2)
+            return true;
+        else
+            return false;
+    }
+    static class Point
+    {
+        long x,y;
+        Point(long x,long y)
+        {
+            this.x=x;
+            this.y=y;
+        }
+    }
+
+    public static void main(String[] args) throws Exception {
+        FastReader sc = new FastReader();
+
+        Clock clock = new Clock();
+        clock.start();
+       int t1=sc.nextInt();
+        for (int t = 0; t <t1 ; t++) {
+          int n=sc.nextInt();
+          long arr[]=new long[n];
+            for (int i = 0; i < n; i++) {
+                arr[i]=sc.nextLong();
+            }
+          long sum1=0;
+          long sum2=0;
+          long min1 =Long.MAX_VALUE;
+          long min2 =Long.MAX_VALUE;
+          long brr[]=new long[n];
+            for (int i = 0; i <n ; i+=2) {
+
+                int nn =i/2;
+                min1=Math.min(arr[i],min1);
+                sum1+=arr[i];
+                long x =(sum1-min1) + min1*(n-nn);
+               // System.out.println(x);
+               brr[i]=x;
+
+            }
+            for (int i = 1; i <n ; i+=2) {
+                int nn =i/2;
+
+                //System.out.println(x);
+                min2=Math.min(arr[i],min2);
+                sum2+=arr[i];
+                long x =(sum2-min2) + min2*(n-nn);
+                brr[i]=x;
+            }
+            long min=Long.MAX_VALUE;
+            for (int i = 1; i < n; i++) {
+                min=Math.min(brr[i]+brr[i-1],min);
+            }
+            out.println(min);
+            //out.println(Arrays.toString(brr));
+
+           // System.out.println(min1+"" ""+min2);
+
+        }
+        out.close();
+
+
+    }
+
+
+}
+
+class Trio{
+    int a,i1,i2;
+    Trio(int a,int i1,int i2)
+    {
+        this.a=a;
+        this.i1=i1;
+        this.i2=i2;
+    }
+}
+
+class Pair{
+
+    int a,b;
+    Pair(int a,int b)
+    {
+        this.a=a;
+        this.b=b;
+    }
+}
+class DSU
+{
+    int parent[];
+    int rank[];
+    long arr[] = Main.arr;
+    long sum[] ;
+    DSU(int n)
+    {
+        this.parent=new int[n];
+        this.rank=new int[n];
+        sum=new long[n];
+        Arrays.fill(parent,-1);
+        Arrays.fill(rank,1);
+        for (int i = 0; i <n ; i++) {
+            sum[i]=arr[i];
+        }
+    }
+
+    int find(int s1)
+    {
+        if(parent[s1]==-1)
+            return s1;
+        return parent[s1]=find(parent[s1]);
+    }
+
+    void unite(int s1,int s2)
+    {
+        int p1=this.find(s1);
+        int p2=this.find(s2);
+        if(p1==p2)
+            return;
+        if(rank[p1]>rank[p2])
+        {
+            parent[p2]=p1;
+            rank[p1]+=rank[p2];
+            // System.out.println(arr[p2]);
+
+            sum[p1]+=sum[p2];
+            //sum[p2]+=sum[p1];
+
+        }
+        else
+        {
+            parent[p1]=p2;
+            rank[p2]+=rank[p1];
+            //System.out.println(arr[p1]);
+            sum[p2]+=sum[p1];
+            //sum[p1]+=sum[p2];
+        }
+    }
+
+
+}
+
+class Gaph {
+
+    HashMap<Integer, ArrayList<Integer>> hm;
+
+    Gaph() {
+        hm = new HashMap<>();
+    }
+
+    Gaph(int n) {
+
+        hm = new HashMap<>();
+        for (int i = 0; i < n; i++) {
+            hm.put(i, new ArrayList<Integer>());
+        }
+    }
+
+    // function for adding an edge.................................................
+    public void addEdge(int a, int b, boolean isDir) {
+        if (isDir) {
+            if (hm.containsKey(a)) {
+                hm.get(a).add(b);
+            } else {
+                hm.put(a, new ArrayList<>(Arrays.asList(b)));
+            }
+        } else {
+            if (hm.containsKey(a)) {
+                hm.get(a).add(b);
+            } else if (!hm.containsKey(a)) {
+                hm.put(a, new ArrayList<>(Arrays.asList(b)));
+            }
+
+            if (hm.containsKey(b)) {
+                hm.get(b).add(a);
+            } else if (!hm.containsKey(b)) {
+                hm.put(b, new ArrayList<>(Arrays.asList(a)));
+            }
+        }
+    }
+
+
+}
+
+// out.println(al.toString().replaceAll(""[\\[|\\]|,]"",""""));
+
+
+",0
+476e94d3,9310ad0c,"import java.util.*;
+import java.io.*;
+import java.math.BigInteger;
+ 
+public class code2{
+ 
+    public static int GCD(int a, int b)
+    {
+      if (b == 0)
+        return a;
+      return GCD(b, a % b);
+    }
+    
+    
+    //@SuppressWarnings(""unchecked"")
+    public static void main(String[] arg) throws IOException{
+        //Reader in=new Reader();
+        
+        PrintWriter out = new PrintWriter(System.out);
+        Scanner in = new Scanner(System.in);
+        
+        int t=in.nextInt();
+        
+        while(t-- > 0){
+           int n=in.nextInt();
+           long[] k=new long[n];
+           long[] h=new long[n];
+
+           for(int i=0;i<n;i++) k[i]=in.nextLong();
+           for(int i=0;i<n;i++) h[i]=in.nextLong();
+
+           long[] res=new long[n];
+           long[] power=new long[n];
+           long l=k[n-1]+1,r=-1;
+
+           for(int i=0;i<n;i++){
+             long lc=k[i]-h[i]+1;
+             //out.println(""lc:""+lc);
+             long m=h[i];
+             if(lc<=l){
+               res[i]=(m*(m+1))/2;
+               power[i]=h[i];
+             }
+             else if(lc>r){
+               //out.println(m);
+               res[i]=res[i-1]+(m*(m+1))/2;
+               power[i]=h[i];
+             }
+             else{
+               res[i]=Long.MAX_VALUE;
+               
+               for(int j=i-1;j>=0;j--){
+                 
+                if(power[j]+k[i]-k[j] >= h[i]){
+					
+                   long x=power[j]+k[i]-k[j];
+				   
+                   if(x>=h[i]){
+					  if(k[i]-h[i]+1>k[j]){
+						power[i]=h[i];
+						res[i]=res[j]+(m*(m+1))/2;
+					  } 
+					  else{
+						power[i]=x;
+						long c=(x*(x+1))/2;
+						long d=(power[j]*(power[j]+1))/2;
+						res[i]=res[j]+c-d;
+					  }
+					  break;
+				   }
+
+                 }
+
+               }
+             }
+             l=Math.min(l,lc);
+             r=k[i];
+             
+           }
+
+           out.println(res[n-1]);
+        }
+ 
+        out.flush();
+    }
+ 
+}
+
+","import java.io.*;
+import java.util.*;
+
+public class Main{
+
+    static class FastReader {
+        BufferedReader br;
+        StringTokenizer st;
+ 
+        public FastReader()
+        {
+            br = new BufferedReader(
+                new InputStreamReader(System.in));
+        }
+ 
+        String next()
+        {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                }
+                catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+ 
+        int nextInt() { return Integer.parseInt(next()); }
+ 
+        long nextLong() { return Long.parseLong(next()); }
+ 
+        double nextDouble()
+        {
+            return Double.parseDouble(next());
+        }
+ 
+        String nextLine()
+        {
+            String str = """";
+            try {
+                str = br.readLine();
+            }
+            catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+        }
+    }
+    
+    
+
+
+    
+
+    
+
+public static void main(String[] args) throws Exception {
+
+
+    FastReader sc = new FastReader();
+    
+   int t=sc.nextInt();
+
+   
+  while(t-->0)
+  {
+      int n=sc.nextInt();
+
+      long k[]=new long[n];
+      for(int i=0;i<n;i++)
+      {
+          k[i]=sc.nextLong();
+      }
+
+      long h[]=new long[n];
+      for(int i=0;i<n;i++)
+      {
+          h[i]=sc.nextLong();
+      }
+      ArrayList<Long> al=new ArrayList<>();
+      long csp=h[n-1],idx=k[n-1]-h[n-1];
+      for(int i=n-2;i>=0;i--)
+      {
+          if(idx<k[i])
+          {
+              if(k[i]-idx<h[i])
+              {
+                  long diff=h[i]-(k[i]-idx);
+                  csp+=diff;
+                  idx-=diff;
+              }
+          }
+          else
+          {
+              al.add(csp);
+              csp=h[i];
+              idx=k[i]-csp;
+          }
+         
+
+      }
+
+      long sum=0;
+      al.add(csp);
+      for(long i:al)
+      {
+         sum=sum+((i*(i+1))/2);
+      }
+
+      System.out.println(sum);
+     
+  }
+}
+}
+
+
+
+
+",0
+2b2d3b84,9fd33d5a,"
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Scanner;
+import java.util.StringTokenizer;
+public class Main
+{
+static class FastReader
+{
+BufferedReader br;
+StringTokenizer st;
+public FastReader()
+{
+br = new BufferedReader(new
+InputStreamReader(System.in));
+}
+String next()
+{
+while (st == null || !st.hasMoreElements())
+{
+try
+{
+st = new StringTokenizer(br.readLine());
+}
+catch (IOException e)
+{
+e.printStackTrace();
+}
+}
+return st.nextToken();
+}
+int nextInt()
+{
+return Integer.parseInt(next());
+}
+long nextLong()
+{
+return Long.parseLong(next());
+}
+double nextDouble()
+{
+return Double.parseDouble(next());
+}
+String nextLine()
+{
+String str = """";
+try
+{
+str = br.readLine();
+}
+catch (IOException e)
+{
+e.printStackTrace();
+}
+return str;
+}
+}
+
+
+public static void main(String[] args)
+{
+   FastReader in = new FastReader();
+   int t=in.nextInt();
+   while(t-->0)
+   {
+       int n=in.nextInt();
+       int k=in.nextInt();
+       
+       int a[]=new int[k];
+       int ans[]=new int[n];
+       int tem[]=new int[k];
+       
+       for(int i=0;i<k;i++)
+           a[i]=in.nextInt();
+       for(int  i=0;i<k;i++)
+           tem[i]=in.nextInt();
+       
+      long c[]=new long[n];
+      long l[]=new long[n];
+      long r[]=new long[n];
+      Arrays.fill(c,Integer.MAX_VALUE);
+      Arrays.fill(l, Integer.MAX_VALUE);
+      Arrays.fill(r,Integer.MAX_VALUE);
+      
+      long p=Integer.MAX_VALUE;
+      for(int i=0;i<k;i++)
+          c[a[i]-1]=tem[i];
+      
+      for(int i=0;i<n;i++)
+      {
+         p=Math.min(p+1,c[i]);
+         l[i]=p;
+      }
+      p=Integer.MAX_VALUE;
+      for(int i=n-1;i>=0;i--)
+      {
+         p=Math.min(p+1,c[i]);
+         r[i]=p;
+      }
+    
+       
+      for(int i=0;i<n;i++)
+          System.out.print(Math.min(l[i],r[i])+"" "");
+      System.out.println();
+   }
+}
+}
+","import java.util.*;
+import java.io.*;
+
+public class Solution {
+
+    private static ArrayList<Integer> prime = new ArrayList<>();
+
+    public static void main(String[] args) throws IOException {
+
+        Scanner in=new Scanner(System.in);
+        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+        StringBuffer out = new StringBuffer();
+
+        int T = in.nextInt();
+
+        OUTER:
+        while(T-->0) {
+
+            int n=in.nextInt(), k=in.nextInt();
+
+            int a[]=new int[k];
+            for(int i=0; i<k; i++) {
+                a[i]=in.nextInt()-1;
+            }
+
+            int t[]=new int[k];
+            long ans[]=new long[n];
+            for(int i=0; i<k; i++) {
+                t[i]=in.nextInt();
+                ans[a[i]]=t[i];
+            }
+
+            long temp=Integer.MAX_VALUE;
+
+            long left[]=new long[n];
+            for(int i=0; i<n; i++) {
+                if(ans[i]!=0) {
+                    temp=Math.min(temp, ans[i]);
+                }
+                left[i]=temp;
+                temp+=1;
+            }
+
+            temp=Integer.MAX_VALUE;
+
+            long right[]=new long[n];
+            for(int i=n-1; i>=0; i--) {
+                if(ans[i]!=0) {
+                    temp=Math.min(temp, ans[i]);
+                }
+                right[i]=temp;
+                temp+=1;
+            }
+
+            for(int i=0; i<n; i++) {
+                ans[i]=Math.min(left[i], right[i]);
+                out.append(ans[i]+"" "");
+            }
+            out.append(""\n"");
+        }
+
+        System.out.print(out);
+    }
+
+    private static long lcm(long a, long b) {
+        return (a*b)/gcd(a, b);
+    }
+
+    private static long gcd(long a, long b) {
+        if (a==0)
+            return b;
+        return gcd(b%a, a);
+    }
+
+    private static int toInt(String s) {
+        return Integer.parseInt(s);
+    }
+
+    private static long toLong(String s) {
+        return Long.parseLong(s);
+    }
+}",0
+0ecf356d,71a4f6d2,"import java.io.*;
+import java.util.*;
+
+public class Main {
+
+    public static void main(String[] args) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        int n = Integer.parseInt(br.readLine());
+        StringTokenizer st = new StringTokenizer(br.readLine());
+        int[] h = new int[n];
+        int[] dp = new int[n];
+        for(int i = 0; i<n; i++){
+            h[i] = Integer.parseInt(st.nextToken());
+        }
+        Stack<Integer> hi = new Stack<>();
+        Stack<Integer> lo = new Stack<>();
+        hi.push(0);
+        lo.push(0);
+        for(int i = 1; i<n; i++){
+            dp[i] = dp[i-1]+1;
+            while(!hi.isEmpty() && h[hi.peek()]<h[i]){
+                dp[i] = Math.min(dp[i], dp[hi.peek()]+1);
+                hi.pop();
+            }
+            if(!hi.isEmpty()){
+                dp[i] = Math.min(dp[i], dp[hi.peek()]+1);
+                if(h[i] == h[hi.peek()]) hi.pop();
+            }
+            while(!lo.isEmpty() && h[lo.peek()]>h[i]){
+                dp[i] = Math.min(dp[i], dp[lo.peek()]+1);
+                lo.pop();
+            }
+            if(!lo.isEmpty()){
+                dp[i] = Math.min(dp[i], dp[lo.peek()]+1);
+                if(h[i] == h[lo.peek()]) lo.pop();
+            }
+            hi.push(i);
+            lo.push(i);
+        }
+        System.out.println(dp[n-1]);
+    }
+}
+","import java.io.OutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.PrintWriter;
+import java.util.Vector;
+import java.util.InputMismatchException;
+import java.io.IOException;
+import java.util.Stack;
+import java.io.InputStream;
+
+public class Main {
+    public static void main(String[] args) {
+        InputStream inputStream = System.in;
+        OutputStream outputStream = System.out;
+        InputReader in = new InputReader(inputStream);
+        PrintWriter out = new PrintWriter(outputStream);
+        DDiscreteCentrifugalJumps solver = new DDiscreteCentrifugalJumps();
+        solver.solve(1, in, out);
+        out.close();
+    }
+
+    static class DDiscreteCentrifugalJumps {
+        public void solve(int testNumber, InputReader s, PrintWriter w) {
+            int n = s.nextInt();
+            int[] a = new int[n];
+            for (int i = 0; i < n; i++)
+                a[i] = s.nextInt();
+            int[] dp = new int[n];
+            for (int i = 0; i < n; i++)
+                dp[i] = i;
+            Stack<Integer> dec = new Stack<>();
+            dec.push(0);
+            Stack<Integer> inc = new Stack<>();
+            inc.push(0);
+            for (int i = 1; i < n; i++) {
+                while (!dec.isEmpty() && a[dec.peek()] < a[i]) {
+                    dp[i] = Math.min(dp[i], dp[dec.peek()] + 1);
+                    dec.pop();
+                }
+                if (!dec.isEmpty()) {
+                    dp[i] = Math.min(dp[i], dp[dec.peek()] + 1);
+                    if (a[dec.peek()] == a[i])
+                        dec.pop();
+                }
+                dec.push(i);
+                while (!inc.isEmpty() && a[inc.peek()] > a[i]) {
+                    dp[i] = Math.min(dp[i], dp[inc.peek()] + 1);
+                    inc.pop();
+                }
+                if (!inc.isEmpty()) {
+                    dp[i] = Math.min(dp[i], dp[inc.peek()] + 1);
+                    if (a[inc.peek()] == a[i])
+                        inc.pop();
+                }
+                inc.push(i);
+            }
+            w.println(dp[n - 1]);
+        }
+
+    }
+
+    static class InputReader {
+        private InputStream stream;
+        private byte[] buf = new byte[1024];
+        private int curChar;
+        private int numChars;
+        private InputReader.SpaceCharFilter filter;
+
+        public InputReader(InputStream stream) {
+            this.stream = stream;
+        }
+
+        public int read() {
+            if (numChars == -1) {
+                throw new InputMismatchException();
+            }
+            if (curChar >= numChars) {
+                curChar = 0;
+                try {
+                    numChars = stream.read(buf);
+                } catch (IOException e) {
+                    throw new InputMismatchException();
+                }
+                if (numChars <= 0) {
+                    return -1;
+                }
+            }
+            return buf[curChar++];
+        }
+
+        public int nextInt() {
+            int c = read();
+            while (isSpaceChar(c)) {
+                c = read();
+            }
+            int sgn = 1;
+            if (c == '-') {
+                sgn = -1;
+                c = read();
+            }
+            int res = 0;
+            do {
+                if (c < '0' || c > '9') {
+                    throw new InputMismatchException();
+                }
+                res *= 10;
+                res += c - '0';
+                c = read();
+            } while (!isSpaceChar(c));
+            return res * sgn;
+        }
+
+        public boolean isSpaceChar(int c) {
+            if (filter != null) {
+                return filter.isSpaceChar(c);
+            }
+            return isWhitespace(c);
+        }
+
+        public static boolean isWhitespace(int c) {
+            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
+        }
+
+        public interface SpaceCharFilter {
+            public boolean isSpaceChar(int ch);
+
+        }
+
+    }
+}
+
+",1
+1162c08f,6653a758,"import java.util.*;
+
+public class CodeForces1525C{
+	public static void main(String[] args) {
+		Scanner sc=new Scanner(System.in);
+		ArrayList<Integer> o=new ArrayList<Integer>(), e=new ArrayList<Integer>();
+		int n = sc.nextInt(),dp[][]=new int[n+1][n+1];
+		for(int i=1;i<=n;i++){
+			int x=sc.nextInt();
+			if(x==1)o.add(i);
+			else e.add(i);
+		}
+		for(int i=1;i<=o.size();i++){
+			dp[i][i]=dp[i-1][i-1]+Math.abs(o.get(i-1)-e.get(i-1));
+			for(int j=i+1;j<=e.size();j++)
+				dp[i][j]=Math.min(dp[i][j-1],dp[i-1][j-1]+Math.abs(o.get(i-1)-e.get(j-1)));
+		}
+		System.out.println(dp[o.size()][e.size()]);
+	}
+}
+
+","import java.util.*;
+public class D {
+	public static void main(String[] args) {
+		Scanner sc=new Scanner(System.in);
+		ArrayList<Integer> o=new ArrayList<Integer>(), e=new ArrayList<Integer>();
+		int n = sc.nextInt(),dp[][]=new int[n+1][n+1];
+		for(int i=1;i<=n;i++){
+			int x=sc.nextInt();
+			if(x==1)o.add(i);
+			else e.add(i);
+		}
+		for(int i=1;i<=o.size();i++){
+			dp[i][i]=dp[i-1][i-1]+Math.abs(o.get(i-1)-e.get(i-1));
+			for(int j=i+1;j<=e.size();j++)
+				dp[i][j]=Math.min(dp[i][j-1],dp[i-1][j-1]+Math.abs(o.get(i-1)-e.get(j-1)));
+		}
+		System.out.println(dp[o.size()][e.size()]);
+	}
+}",1
+1410e423,e90a198b,"import java.io.*;
+import java.util.*;
+
+public class C {
+
+	public static void main(String[] args) throws IOException {
+
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		PrintWriter pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
+		
+		int t = Integer.parseInt(br.readLine());
+		
+		while(t --> 0) {
+			
+			int n = Integer.parseInt(br.readLine());
+			
+			char[] lineA = br.readLine().toCharArray();
+			char[] lineB = br.readLine().toCharArray();
+			
+			boolean[] a = new boolean[n];
+			boolean[] b = new boolean[n];
+			
+			int ac = 0;
+			int aic = 0;
+			int bc = 0;
+			int stay = 0;
+			int flip = 0;
+			
+			for(int i = 0; i < n; i++) {
+				
+				if(lineA[i] == '1') {
+					
+					ac++;
+					a[i] = true;
+					
+				}else
+					aic++;
+				
+				if(lineB[i] == '1') {
+					
+					bc++;
+					b[i] = true;
+					
+				}
+				
+				if(a[i] == b[i])
+					stay++;
+				else
+					flip++;
+				
+			}
+			
+			if(ac != bc && aic + 1 != bc) {
+				
+				pw.println(-1);
+				
+			}else {
+				
+				if(ac == aic+1)
+					pw.println(Math.min(stay, flip));
+				else if(ac == bc)
+					pw.println(flip);
+				else
+					pw.println(stay);
+				
+			}
+			
+		}
+		
+		pw.close();
+
+	}
+
+}
+","import static java.lang.Math.max;
+import static java.lang.Math.min;
+import static java.lang.Math.abs;
+import static java.lang.System.out;
+import java.util.*;
+import java.io.*;
+import java.math.*;
+
+public class Template {
+    
+	static int mod = 1000000007;
+
+	public static void main(String[] args){
+        FastScanner sc = new FastScanner();
+        PrintWriter out = new PrintWriter(System.out);
+        int yo = sc.nextInt();
+        while (yo-- > 0) {
+            int n = sc.nextInt();
+            String s = sc.next();
+            String t = sc.next();
+            int op1 = cal(s,t,n);
+            int op2 = helper(s,t,n,'0');
+            int op3 = helper(s,t,n,'1');
+            int ans = min(min(op1,op2),op3);
+            if(ans == Integer.MAX_VALUE){
+                out.println(""-1"");
+            }
+            else {
+                out.println(ans);
+            }
+        }
+        out.close();
+	}
+    
+    static int helper(String str1, String str2, int n, int ch){
+        char[] s = str1.toCharArray();
+        char[] t = str2.toCharArray();
+        int idx = -1;
+        for(int i = 0; i < n; i++){
+            if(s[i] == '1' && t[i] == ch){
+                idx = i;
+                break;
+            }
+        }
+        if(idx == -1){
+            return Integer.MAX_VALUE;
+        }
+        for(int i = 0; i < n; i++){
+            if(i == idx) continue;
+            if(s[i] == '1') s[i] = '0';
+            else s[i] = '1';
+        }
+        int ans = cal(String.valueOf(s),String.valueOf(t),n);
+        if(ans == Integer.MAX_VALUE) return ans;
+        return 1 + ans;
+    }
+    static int cal(String s, String t, int n){
+        int op01 = 0;
+        int op10 = 0;
+        for(int i = 0; i < n; i++){
+            if(s.charAt(i) != t.charAt(i)){
+                if(s.charAt(i) == '1') op10++;
+                else op01++;
+            }
+        }
+        if(op10 != op01){
+            return Integer.MAX_VALUE;
+        }
+        return op01 + op10;
+    }
+    
+    /*
+    Source: hu_tao
+         Random stuff to try when stuck:
+            - use bruteforcer
+            - check for n = 1, n = 2, so on
+            -if it's 2C then it's dp
+            -for combo/probability problems, expand the given form we're interested in
+            -make everything the same then build an answer (constructive, make everything 0 then do something)
+            -something appears in parts of 2 --> model as graph
+            -assume a greedy then try to show why it works
+            -find way to simplify into one variable if multiple exist
+            -treat it like fmc (note any passing thoughts/algo that could be used so you can revisit them)
+            -find lower and upper bounds on answer
+            -figure out what ur trying to find and isolate it
+            -see what observations you have and come up with more continuations
+            -work backwards (in constructive, go from the goal to the start)
+            -turn into prefix/suffix sum argument (often works if problem revolves around adjacent array elements)
+            -instead of solving for answer, try solving for complement (ex, find n-(min) instead of max)
+            -draw something
+            -simulate a process
+            -dont implement something unless if ur fairly confident its correct
+            -after 3 bad submissions move on to next problem if applicable
+            -do something instead of nothing and stay organized
+            -write stuff down
+         Random stuff to check when wa:
+            -if code is way too long/cancer then reassess
+            -switched N/M
+            -int overflow
+            -switched variables
+            -wrong MOD
+            -hardcoded edge case incorrectly
+         Random stuff to check when tle:
+            -continue instead of break
+            -condition in for/while loop bad
+         Random stuff to check when rte:
+            -switched N/M
+            -long to int/int overflow
+            -division by 0
+            -edge case for empty list/data structure/N=1
+            
+      */
+
+	public static class Pair {
+		int x;
+		int y;
+
+		public Pair(int x, int y) {
+			this.x = x;
+			this.y = y;
+		}
+	}
+
+	public static void sort(int[] arr) {
+		ArrayList<Integer> ls = new ArrayList<Integer>();
+		for (int x : arr)
+			ls.add(x);
+		Collections.sort(ls);
+		for (int i = 0; i < arr.length; i++)
+			arr[i] = ls.get(i);
+	}
+
+	public static long gcd(long a, long b) {
+		if (b == 0)
+			return a;
+		return gcd(b, a % b);
+	}
+
+	static boolean[] sieve(int N) {
+		boolean[] sieve = new boolean[N + 1];
+		for (int i = 2; i <= N; i++)
+			sieve[i] = true;
+
+		for (int i = 2; i <= N; i++) {
+			if (sieve[i]) {
+				for (int j = 2 * i; j <= N; j += i) {
+					sieve[j] = false;
+				}
+			}
+		}
+		return sieve;
+	}
+
+	public static long power(long x, long y, long p) {
+		long res = 1L;
+		x = x % p;
+		while (y > 0) {
+			if ((y & 1) == 1)
+				res = (res * x) % p;
+			y >>= 1;
+			x = (x * x) % p;
+		}
+		return res;
+	}
+
+	public static void print(int[] arr, PrintWriter out) {
+		//for debugging only
+		for (int x : arr)
+			out.print(x + "" "");
+		out.println();
+	}
+    
+    public static int log2(int a){
+        return (int)(Math.log(a)/Math.log(2));
+    }
+    
+    public static long ceil(long x, long y){
+        return (x + 0l + y - 1) / y;
+    }
+
+	static class FastScanner {
+		private int BS = 1 << 16;
+		private char NC = (char) 0;
+		private byte[] buf = new byte[BS];
+		private int bId = 0, size = 0;
+		private char c = NC;
+		private double cnt = 1;
+		private BufferedInputStream in;
+
+		public FastScanner() {
+			in = new BufferedInputStream(System.in, BS);
+		}
+
+		public FastScanner(String s) {
+			try {
+				in = new BufferedInputStream(new FileInputStream(new File(s)), BS);
+			} catch (Exception e) {
+				in = new BufferedInputStream(System.in, BS);
+			}
+		}
+
+		private char getChar() {
+			while (bId == size) {
+				try {
+					size = in.read(buf);
+				} catch (Exception e) {
+					return NC;
+				}
+				if (size == -1)
+					return NC;
+				bId = 0;
+			}
+			return (char) buf[bId++];
+		}
+
+		public int nextInt() {
+			return (int) nextLong();
+		}
+
+		public int[] readInts(int N) {
+			int[] res = new int[N];
+			for (int i = 0; i < N; i++) {
+				res[i] = (int) nextLong();
+			}
+			return res;
+		}
+
+		public long[] readLongs(int N) {
+			long[] res = new long[N];
+			for (int i = 0; i < N; i++) {
+				res[i] = nextLong();
+			}
+			return res;
+		}
+
+		public long nextLong() {
+			cnt = 1;
+			boolean neg = false;
+			if (c == NC)
+				c = getChar();
+			for (; (c < '0' || c > '9'); c = getChar()) {
+				if (c == '-')
+					neg = true;
+			}
+			long res = 0;
+			for (; c >= '0' && c <= '9'; c = getChar()) {
+				res = (res << 3) + (res << 1) + c - '0';
+				cnt *= 10;
+			}
+			return neg ? -res : res;
+		}
+
+		public double nextDouble() {
+			double cur = nextLong();
+			return c != '.' ? cur : cur + nextLong() / cnt;
+		}
+
+		public double[] readDoubles(int N) {
+			double[] res = new double[N];
+			for (int i = 0; i < N; i++) {
+				res[i] = nextDouble();
+			}
+			return res;
+		}
+
+		public String next() {
+			StringBuilder res = new StringBuilder();
+			while (c <= 32)
+				c = getChar();
+			while (c > 32) {
+				res.append(c);
+				c = getChar();
+			}
+			return res.toString();
+		}
+
+		public String nextLine() {
+			StringBuilder res = new StringBuilder();
+			while (c <= 32)
+				c = getChar();
+			while (c != '\n') {
+				res.append(c);
+				c = getChar();
+			}
+			return res.toString();
+		}
+
+		public boolean hasNext() {
+			if (c > 32)
+				return true;
+			while (true) {
+				c = getChar();
+				if (c == NC)
+					return false;
+				else if (c > 32)
+					return true;
+			}
+		}
+	}
+
+	//	For Input.txt and Output.txt	
+	//	FileInputStream in = new FileInputStream(""input.txt"");
+	//	FileOutputStream out = new FileOutputStream(""output.txt"");
+	//	PrintWriter pw = new PrintWriter(out);
+	//	Scanner sc = new Scanner(in);
+}",0
+f229aa7f,fcc7e8fa,"import java.util.*;
+import java.io.*;
+import java.math.*;
+
+public class cf {
+	static PrintWriter pw = new PrintWriter(System.out);
+
+	public static void main(String[] args) throws IOException, InterruptedException {
+		Scanner sc = new Scanner(System.in);
+		int t = sc.nextInt();
+		while (t-- > 0) {
+			int n = sc.nextInt();
+			char[] a = sc.next().toCharArray();
+			char[] b = sc.next().toCharArray();
+			int x = 0, y = 0, lit = 0,lit2 = 0;
+			for (int i = 0; i < n; i++) {
+				if (a[i] == '1')
+					lit++;
+				if (b[i] == '1')
+					lit2++;
+				if (a[i] == b[i])
+					x++;
+				else
+					y++;
+			}
+			if(lit == lit2 || n - lit + 1 == lit2) {
+				if (lit == lit2 && n - lit + 1 == lit2) {
+					pw.println(Math.min(x,y));
+				}else if(lit == lit2) {
+					pw.println(y);
+				}else {
+					pw.println(x);
+				}
+			}else {
+				pw.println(-1);
+			}
+		}
+		pw.close();
+	}
+
+	public static class tuble implements Comparable<tuble> {
+		int x;
+		int y;
+		int z;
+
+		public tuble(int x, int y, int z) {
+			this.x = x;
+			this.y = y;
+			this.z = z;
+		}
+
+		public String toString() {
+			return x + "" "" + y + "" "" + z;
+		}
+
+		public int compareTo(tuble other) {
+			if (this.x == other.x) {
+				if (this.y == other.y)
+					return this.z - other.z;
+				return this.y - other.y;
+			} else {
+				return this.x - other.x;
+			}
+		}
+	}
+
+	public static class pair implements Comparable<pair> {
+		int x;
+		int y;
+
+		public pair(int x, int y) {
+			this.x = x;
+			this.y = y;
+		}
+
+		public String toString() {
+			return x + "" "" + y;
+		}
+
+		public boolean equals(Object o) {
+			if (o instanceof pair) {
+				pair p = (pair) o;
+				return p.x == x && p.y == y;
+			}
+			return false;
+		}
+
+		public int hashCode() {
+			return new Integer(x).hashCode() * 31 + new Integer(y).hashCode();
+		}
+
+		public int compareTo(pair other) {
+			if (this.x == other.x) {
+				return Long.compare(this.y, other.y);
+			}
+			return Long.compare(this.x, other.x);
+		}
+	}
+
+	static class Scanner {
+		StringTokenizer st;
+		BufferedReader br;
+
+		public Scanner(InputStream s) {
+			br = new BufferedReader(new InputStreamReader(s));
+		}
+
+		public Scanner(FileReader r) {
+			br = new BufferedReader(r);
+		}
+
+		public String next() throws IOException {
+			while (st == null || !st.hasMoreTokens())
+				st = new StringTokenizer(br.readLine());
+			return st.nextToken();
+		}
+
+		public int nextInt() throws IOException {
+			return Integer.parseInt(next());
+		}
+
+		public long nextLong() throws IOException {
+			return Long.parseLong(next());
+		}
+
+		public String nextLine() throws IOException {
+			return br.readLine();
+		}
+
+		public double nextDouble() throws IOException {
+			return Double.parseDouble(next());
+		}
+
+		public boolean ready() throws IOException {
+			return br.ready();
+		}
+
+	}
+
+}","import java.io.OutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.PrintWriter;
+import java.util.*;
+import java.io.IOException;
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.io.InputStream;
+
+public class Main {
+
+    public static void main(String[] args) {
+        InputStream inputStream = System.in;
+        OutputStream outputStream = System.out;
+        InputReader in = new InputReader(inputStream);
+        PrintWriter out = new PrintWriter(outputStream);
+        TaskA solver = new TaskA();
+        int t;
+        t = in.nextInt();
+        //t = 1;
+        while (t > 0) {
+            solver.call(in,out);
+            t--;
+        }
+        out.close();
+    }
+
+    static class TaskA {
+        public void call(InputReader in, PrintWriter out) {
+            int n, _00 = 0, _01 = 0, _11 = 0, _10 = 0;
+            n = in.nextInt();
+            char[] s = in.next().toCharArray();
+            char[] s1 = in.next().toCharArray();
+
+            for (int i = 0; i < n; i++) {
+                if(s[i]==s1[i]){
+                    if(s[i]=='0'){
+                        _00++;
+                    }
+                    else{
+                        _11++;
+                    }
+                }
+                else{
+                    if(s[i]=='0'){
+                        _01++;
+                    }
+                    else{
+                        _10++;
+                    }
+                }
+            }
+            int ans = Integer.MAX_VALUE;
+
+            if(_10 ==_01){
+                ans = 2*_01;
+            }
+            if(_11 == _00 + 1){
+                ans = Math.min(ans, 2*_00 + 1);
+            }
+
+            if(ans == Integer.MAX_VALUE){
+                out.println(-1);
+            }
+            else{
+                out.println(ans);
+            }
+        }
+    }
+
+    static int gcd(int a, int b)
+    {
+        if (a == 0)
+            return b;
+        return gcd(b % a, a);
+    }
+
+    static int lcm(int a, int b)
+    {
+        return (a / gcd(a, b)) * b;
+    }
+
+    static class answer implements Comparable<answer>{
+        int a, b;
+
+        public answer(int a, int b) {
+            this.a = a;
+            this.b = b;
+        }
+
+        @Override
+        public int compareTo(answer o) {
+            return o.a - this.a;
+        }
+    }
+
+    static class arrayListClass {
+        ArrayList<Integer> arrayList2 ;
+
+        public arrayListClass(ArrayList<Integer> arrayList) {
+            this.arrayList2 = arrayList;
+        }
+    }
+
+    static long gcd(long a, long b)
+    {
+        if (b == 0)
+            return a;
+        return gcd(b, a % b);
+    }
+
+    static void sort(long[] a) {
+        ArrayList<Long> l=new ArrayList<>();
+        for (long i:a) l.add(i);
+        Collections.sort(l);
+        for (int i=0; i<a.length; i++) a[i]=l.get(i);
+    }
+
+    static final Random random=new Random();
+
+    static void shuffleSort(int[] a) {
+        int n = a.length;
+        for (int i=0; i<n; i++) {
+            int oi=random.nextInt(n), temp=a[oi];
+            a[oi]=a[i]; a[i]=temp;
+        }
+        Arrays.sort(a);
+    }
+
+    static class InputReader {
+        public BufferedReader reader;
+        public StringTokenizer tokenizer;
+
+        public InputReader(InputStream stream) {
+            reader = new BufferedReader(new InputStreamReader(stream), 32768);
+            tokenizer = null;
+        }
+
+        public String next() {
+            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
+                try {
+                    tokenizer = new StringTokenizer(reader.readLine());
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+            }
+            return tokenizer.nextToken();
+        }
+
+        public int nextInt() {
+            return Integer.parseInt(next());
+        }
+        public long nextLong(){
+            return Long.parseLong(next());
+        }
+        public double nextDouble() {
+            return Double.parseDouble(next());
+        }
+
+    }
+}",0
+127af3a7,99ccaa44,"import java.util.ArrayList;
+import java.util.List;
+import java.util.Scanner;
+
+public class Main {
+
+    public static void main(String[] args) {
+        Scanner scanner = new Scanner(System.in);
+        int t = scanner.nextInt();
+        for (int i = 0; i < t; i++) {
+            notSitting(scanner);
+        }
+    }
+
+    private static void notSitting(Scanner scanner) {
+        int n = scanner.nextInt();
+        int[] num = new int[n - 1];
+        int[] ct = new int[n];
+        boolean[] visited = new boolean[n];
+        List<int[]>[] edges = new List[n];
+        for (int i = 0; i < n; i++) {
+            edges[i] = new ArrayList<>();
+        }
+        for (int i = 0; i < n - 1; i++) {
+            int u = scanner.nextInt() - 1;
+            int v = scanner.nextInt() - 1;
+            edges[u].add(new int[]{v, i});
+            edges[v].add(new int[]{u, i});
+            ct[u]++;
+            ct[v]++;
+        }
+        int start = -1;
+        for (int i = 0; i < n; i++) {
+            if (ct[i] >= 3) {
+                System.out.println(-1);
+                return;
+            } else if (ct[i] == 1) {
+                start = i;
+            }
+        }
+        visited[start] = true;
+        boolean odd = false;
+        for (int i = 0; i < n - 1; i++) {
+            for (int[] e : edges[start]) {
+                if (!visited[e[0]]) {
+                    visited[e[0]] = true;
+                    num[e[1]] = odd ? 3 : 2;
+                    odd = !odd;
+                    start = e[0];
+                    break;
+                }
+            }
+        }
+        for (int i = 0; i < n - 1; i++) {
+            System.out.print(num[i]);
+            System.out.print("" "");
+        }
+        System.out.println();
+    }
+}
+","import java.util.*;
+ 
+public class Main
+{
+	public static void main(String[] args) {
+	    Scanner sc = new Scanner(System.in); 
+		int tc = sc.nextInt();
+		while(tc>0)
+		{
+		    tc--;
+		    int ans = 0;
+		    int n = sc.nextInt();
+		    int in[] = new int[n];
+		    int wx[] = new int[n-1];
+		    int wy[] = new int[n-1];
+		    ArrayList<ArrayList<Integer>> arr = new ArrayList<ArrayList<Integer>>();
+		    HashMap<String,Integer> h = new HashMap<String,Integer>();
+		    HashSet<Integer> h2 = new HashSet<Integer>();
+		    for(int i=0;i<n;i++)
+		    {
+		        arr.add(new ArrayList<Integer>());
+		    }
+		    for(int i=0;i<n-1;i++)
+		    {
+		        int x = sc.nextInt();
+		        int y = sc.nextInt();
+		        x--;
+		        y--;
+		        in[x]++;
+		        in[y]++;
+		        if(in[x]>2 || in[y]>2)
+		        {
+		            ans = -1;
+		        }
+		        else if(ans!=-1)
+		        {
+		            arr.get(x).add(y);
+		            arr.get(y).add(x);
+		            wx[i] = x;
+		            wy[i] = y;
+		        }
+		        
+		    }
+		    if(ans == -1)
+		    {
+		        System.out.println(""-1"");
+		    }
+		    else
+		    {
+		        int vis[] = new int[n];
+		        ArrayDeque<Integer> q = new ArrayDeque<Integer>();
+		        q.add(0);
+		        vis[0] = 1;
+		        while(q.size()>0)
+		        {
+		            int x = q.removeFirst();
+		            for(int i=0;i<arr.get(x).size();i++)
+		            {
+		                int y = arr.get(x).get(i);
+		                String temp  =String.valueOf(x);
+		                if(vis[y] == 0)
+		                {
+		                    vis[y] = 1;
+		                    if(h2.contains(y) || h2.contains(x))
+		                    {
+		                        String s1 = temp+""_""+String.valueOf(y);
+		                        String s2 = String.valueOf(y)+""_""+temp;
+		                        h.put(s1,11);
+		                        h.put(s2,11);
+		                        
+		                    }
+		                    else
+		                    {
+		                        String s1 = temp+""_""+String.valueOf(y);
+		                        String s2 = String.valueOf(y)+""_""+temp;
+		                        h.put(s1,2);
+		                        h.put(s2,2);
+		                        h2.add(x);
+		                        h2.add(y);
+		                    }
+		                    q.add(y);
+		                }
+		            }
+		        }
+		        for(int i=0;i<wx.length;i++)
+		        {
+		            String s1 = String.valueOf(wx[i])+""_""+String.valueOf(wy[i]);
+		            System.out.print(h.get(s1)+"" "");
+		        }
+		        System.out.println();
+		    }
+		}
+	}
+}",0
+268eb6c6,3cf63146,"import java.util.*;
+import java.io.*;
+
+public class Test {
+  // Fast IO class
+  static class FastReader {
+    BufferedReader br;
+    StringTokenizer st;
+
+    public FastReader() {
+      boolean env = System.getProperty(""ONLINE_JUDGE"") != null;
+      // env=true;
+      if (!env) {
+        try {
+          br = new BufferedReader(new FileReader(""src/input.txt""));
+        } catch (FileNotFoundException e) {
+          e.printStackTrace();
+        }
+      } else br = new BufferedReader(new InputStreamReader(System.in));
+    }
+
+    String next() {
+      while (st == null || !st.hasMoreElements()) {
+        try {
+          st = new StringTokenizer(br.readLine());
+        } catch (IOException e) {
+          e.printStackTrace();
+        }
+      }
+      return st.nextToken();
+    }
+
+    int nextInt() {
+      return Integer.parseInt(next());
+    }
+
+    long nextLong() {
+      return Long.parseLong(next());
+    }
+
+    double nextDouble() {
+      return Double.parseDouble(next());
+    }
+
+    String nextLine() {
+      String str = """";
+      try {
+        str = br.readLine();
+      } catch (IOException e) {
+        e.printStackTrace();
+      }
+      return str;
+    }
+  }
+
+  static FastReader sc = new FastReader();
+  static PrintWriter out = new PrintWriter(System.out);
+
+  public static void main(String[] args) {
+    int t = sc.nextInt();
+    while (t-- > 0) {
+      int n = sc.nextInt();
+      int k = sc.nextInt();
+      int[] a = new int[k];
+      int[] temp = new int[n];
+      for (int i = 0; i < k; i++) a[i] = sc.nextInt();
+      for (int i = 0; i < k; i++) temp[a[i] - 1] = sc.nextInt();
+      int[] left = new int[n];
+      int[] right = new int[n];
+      Arrays.fill(left, Integer.MAX_VALUE - 1);
+      Arrays.fill(right, Integer.MAX_VALUE - 1);
+      if (temp[0] > 0) left[0] = temp[0];
+      for (int i = 1; i < n; i++) {
+        left[i] = Math.min(left[i - 1] + 1, left[i]);
+        if (temp[i] > 0) left[i] = Math.min(left[i], temp[i]);
+      }
+      if (temp[n - 1] > 0) right[n - 1] = temp[n - 1];
+      for (int i = n - 2; i >= 0; i--) {
+        right[i] = Math.min(right[i + 1] + 1, right[i]);
+        if (temp[i] > 0) right[i] = Math.min(right[i], temp[i]);
+      }
+      for (int i = 0; i < n; i++) out.print(Math.min(left[i], right[i]) + "" "");
+      out.println();
+    }
+    out.flush();
+    out.close();
+  }
+}
+","import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.time.LocalDateTime;
+import java.util.*;
+
+public class B {
+	static int tree[];
+	static int up[];
+	static int n;
+	static int mod =1000000007; 
+	public static void main(String[] args) throws Exception {
+		PrintWriter out=new PrintWriter(System.out);
+	    FastScanner fs=new FastScanner();
+	    int t=fs.nextInt();
+	   outer: while(t-->0) {
+		    n=fs.nextInt();
+		    int k=fs.nextInt();
+		   int ac[]=fs.readArray(k);
+		   int temp[]=fs.readArray(k);
+		   int arr[]=new int[n];
+		   Arrays.fill(arr, Integer.MAX_VALUE/2);
+		   for(int i=0;i<k;i++) {
+			   int ind = ac[i]-1;
+			   arr[ind]=temp[i];
+		   }
+		   int ans[]=new int[n];
+		   int left[]=new int[n];
+		   Arrays.fill(left, Integer.MAX_VALUE/2);
+//		   int right[]=new int[n];
+		   left[0]=arr[0];
+//		   Arrays.fill(right, Integer.MAX_VALUE/2);
+		   
+//		   right[n-1]=arr[n-1];
+		   for(int i=1;i<n;i++) {
+			   left[i]=Math.min(arr[i], left[i-1]+1);
+		   }
+		   ans[n-1]=Math.min(left[n-1],arr[n-1]);
+		   for(int i=n-2;i>=0;i--) {
+			   ans[i]=Math.min(Math.min(arr[i],left[i]),ans[i+1]+1);
+		   }
+//		   for(int i=0;i<n;i++) ans[i]=Math.min(left[i], right[i]);
+		   for(int i=0;i<n;i++) out.print(ans[i]+"" "");
+		   out.println();
+	   }
+	    out.close();
+	}
+	
+	static long gcd(long  a,long  b) {
+		if(b==0) return a;
+		return gcd(b,a%b);
+	}
+	static long nck(int n,int k) {
+		if(k>n) return 0;
+		long res=1;
+		res*=fact(n);
+		res%=mod;
+		res*=modInv(fact(k));
+		res%=mod;
+		res*=modInv(fact(n-k)); 
+		res%=mod;
+		return res;
+	}
+	static long fact(long n) {
+		long res=1;
+		for(int i=2;i<=n;i++) {
+			res*=i;
+			res%=mod;
+		}
+		return res;
+	}
+	static long pow(long a,long b) {
+		long res=1;
+		while(b!=0) {
+			if((b&1)!=0) {
+				res*=a;
+				res%=mod;
+			}
+			a*=a;
+			a%=mod;
+			b=b>>1;
+		}
+		return res;
+	}
+	static long modInv(long n) {
+		return pow(n,mod-2);
+	}
+	
+	static void sort(int[] a) {
+		//suffle
+		int n=a.length;
+		Random r=new Random();
+		for (int i=0; i<a.length; i++) {
+			int oi=r.nextInt(n);
+			int temp=a[i];
+			a[i]=a[oi];
+			a[oi]=temp;
+		}
+		
+		//then sort
+		Arrays.sort(a);
+	}
+	
+	// Use this to input code since it is faster than a Scanner
+	static class FastScanner {
+		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st=new StringTokenizer("""");
+		String next() {
+			while (!st.hasMoreTokens())
+				try {
+					st=new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			return st.nextToken();
+		}
+		
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+		int[] readArray(int n) {
+			int[] a=new int[n];
+			for (int i=0; i<n; i++) a[i]=nextInt();
+			return a;
+		}
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+	}
+ 
+}",0
+3c74c140,732c98a0,"
+//package com.company;
+
+
+
+import  java.math.*;
+import java.util.*;
+import java.lang.*;
+import java.io.*;
+
+
+
+public final class Main {
+
+    FastReader s;
+
+
+    public static void main (String[] args) throws java.lang.Exception
+    {
+
+        new Main().run();
+
+    }
+    void run()
+    {
+        s = new FastReader();
+        solve();
+    }
+   StringBuffer sb;
+   // int counter;
+    void solve()
+    {
+         sb = new StringBuffer();
+
+        for(int T = s.nextInt();T > 0;T--)
+        {
+
+
+            start();
+
+
+        }
+
+       // System.out.print(sb);
+
+    }
+
+
+    void start()
+    {
+
+        int n = s.nextInt();
+
+         int mat[][] = new int[n][5];
+        for(int i = 0; i<n; i++)
+        {
+            char [] x = s.nextLine().toCharArray();
+            for(char c : x)
+            {
+                mat[i][c-'a']++;
+            }
+            int p[] = new int[5];
+            int to = 0;
+            for(int j : mat[i])
+                to+=j;
+
+            for(int j = 0; j<5; j++)
+            {
+                mat[i][j]=2*mat[i][j]-to;
+            }
+        }
+
+        int ans  = 0;
+        for(int i = 0; i<5; i++)
+        {
+            int g = check(i,mat, n);
+            ans = Math.max(g,ans);
+        }
+        System.out.println(ans);
+
+
+
+    }
+
+    int check(int i, int mat[][], int n)
+    {
+        ArrayList<Integer> x = new ArrayList<>();
+        for(int j = 0; j<n; j++)
+        {
+            x.add(mat[j][i]);
+        }
+        Collections.sort(x);
+        int s = 0;
+        int cnt = 0;
+        int l = n-1;
+        while(l>=0)
+        {
+            int u = x.get(l);
+            if(s+u>0)
+            {
+                s+=u;
+                cnt++;
+            }
+            else
+                break;
+            l--;
+        }
+        return cnt;
+    }
+
+
+
+
+    long gcd(long a, long b)
+    {
+        if (b == 0)
+            return a;
+        return gcd(b, a % b);
+    }
+    long power(long x, long y, long p)
+    {
+        long res = 1; // Initialize result
+
+        // Update x if it is more
+        // than or equal to p
+        x = x % p;
+
+        while (y > 0)
+        {
+            // If y is odd, multiply
+            // x with the result
+            if ((y & 1) > 0)
+                res = (res * x) % p;
+
+            // y must be even now
+            y = y >> 1; // y = y/2
+            x = (x * x) % p;
+        }
+        return res;
+    }
+
+    int lower_bound(int [] arr , int key)
+    {
+
+        int i = 0;
+        int j = arr.length-1;
+          //if(arr[i] > key)return -1;
+         if(arr[j] < key)return -1;
+
+        while(i<j)
+        {
+            int mid = (i+j)/2;
+
+            if(arr[mid] == key)
+            {
+                j = mid;
+            }
+
+            else if(arr[mid] < key)
+            {
+                i = mid+1;
+            }
+            else
+                j = mid-1;
+      }
+
+        return i;
+    }
+
+    int upper_bound(int [] arr , int key)
+    {
+
+        int i = 0;
+        int j = arr.length-1;
+        if(arr[j] <= key)return j+1;
+
+        while(i<j)
+        {
+            int mid = (i+j)/2;
+
+
+
+             if(arr[mid] <= key)
+            {
+                i = mid+1;
+            }
+            else
+                j = mid;
+        }
+
+        return i;
+    }
+
+
+    static void sort(int[] A){
+        int n = A.length;
+        Random rnd = new Random();
+        for(int i=0; i<n; ++i){
+            int tmp = A[i];
+            int randomPos = i + rnd.nextInt(n-i);
+            A[i] = A[randomPos];
+            A[randomPos] = tmp;
+        }
+        Arrays.sort(A);
+    }
+    static void sort(long[] A){
+        int n = A.length;
+        Random rnd = new Random();
+        for(int i=0; i<n; ++i){
+            long tmp = A[i];
+            int randomPos = i + rnd.nextInt(n-i);
+            A[i] = A[randomPos];
+            A[randomPos] = tmp;
+        }
+        Arrays.sort(A);
+    }
+    static String sort(String s) {
+        Character ch[]=new Character[s.length()];
+        for(int i=0;i<s.length();i++) {
+            ch[i]=s.charAt(i);
+        }
+        Arrays.sort(ch);
+        StringBuffer st=new StringBuffer("""");
+        for(int i=0;i<s.length();i++) {
+            st.append(ch[i]);
+        }
+        return st.toString();
+    }
+
+    //long array input
+    public long [] longArr(int len)
+    {
+        // long arr input
+        long [] arr = new long[len];
+        String [] strs =  s.nextLine().trim().split(""\\s+"");
+        for(int i =0; i<len; i++)
+        {
+            arr[i] = Long.parseLong(strs[i]);
+
+        }
+        return arr;
+    }
+    // int arr input
+    public int [] intArr(int len)
+    {
+        // long arr input
+        int [] arr = new int[len];
+        String [] strs =  s.nextLine().trim().split(""\\s+"");
+        for(int i =0; i<len; i++)
+        {
+            arr[i] = Integer.parseInt(strs[i]);
+
+        }
+        return arr;
+    }
+
+    static class FastReader
+    {
+        BufferedReader br;
+        StringTokenizer st;
+
+        public FastReader()
+        {
+            br = new BufferedReader(new
+                    InputStreamReader(System.in));
+        }
+
+        String next()
+        {
+            while (st == null || !st.hasMoreElements())
+            {
+                try
+                {
+                    st = new StringTokenizer(br.readLine());
+                }
+                catch (IOException  e)
+                {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt()
+        {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong()
+        {
+            return Long.parseLong(next());
+        }
+
+        double nextDouble()
+        {
+            return Double.parseDouble(next());
+        }
+
+        String nextLine()
+        {
+            String str = """";
+            try
+            {
+                str = br.readLine();
+            }
+            catch (IOException e)
+            {
+                e.printStackTrace();
+            }
+            return str;
+        }
+    }
+
+
+
+}
+","import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.util.*;
+
+import static java.lang.Math.*;
+import static java.lang.System.out;
+import static java.lang.Long.MAX_VALUE;
+
+public final class Main {
+
+    FastReader in;
+    StringBuffer sb;
+    public static void main(String[] args) {
+        new Main().run();
+    }
+
+    void run(){
+        in= new FastReader();
+        start();
+    }
+
+    void start(){
+        sb= new StringBuffer();
+        for(int t=in.nextInt();t>0;t--)
+            solve();
+        out.print(sb);
+    }
+
+    void solve(){
+        int n = in.nextInt();
+        int[][] mat = new int[n][5];
+        for(int i = 0; i<n; i++) {
+            char[] pp =in.nextLine().toCharArray();
+            for(char c : pp) {
+                mat[i][c-'a']++;
+            }
+            int[] p = new int[5];
+            int tt = 0;
+            for(int j : mat[i])
+                tt +=j;
+            for(int j = 0; j<5; j++) {
+                mat[i][j]=2*mat[i][j]-tt;
+            }
+        }
+        int ans  = 0;
+        for(int i = 0; i<5; i++) {
+            int g = check(i,mat, n);
+            ans = Math.max(g,ans);
+        }
+        sb.append(ans).append(""\n"");
+    }
+
+    int check(int i, int[][] mat, int n) {
+        ArrayList<Integer> x = new ArrayList<>();
+        for(int j = 0; j<n; j++) {
+            x.add(mat[j][i]);
+        }
+        Collections.sort(x);
+        int s = 0;
+        int cnt = 0;
+        int l = n-1;
+        while(l>=0) {
+            int u = x.get(l);
+            if(s+u>0) {
+                s+=u;
+                cnt++;
+            }
+            else
+                break;
+            l--;
+        }
+        return cnt;
+    }
+
+    long power(long x, long y, long p) {
+        long res = 1;
+        x = x % p;
+        while (y > 0) {
+            if (y % 2 == 1)
+                res = (res * x) % p;
+
+            y = y >> 1;
+            x = (x * x) % p;
+        }
+        return res;
+    }
+
+    int upper_bound(long[] arr, int key) {
+        int i=0, j=arr.length-1;
+        if (arr[j]<=key) return j+1;
+        if(arr[i]>key) return i;
+        while (i<j){
+            int mid= (i+j)/2;
+            if(arr[mid]<=key){
+                i= mid+1;
+            }else{
+                j=mid;
+            }
+        }
+        return i;
+    }
+
+    void sort(long[] A){
+        int n = A.length;
+        Random rnd = new Random();
+        for(int i=0; i<n; ++i){
+            long tmp = A[i];
+            int randomPos = i + rnd.nextInt(n-i);
+            A[i] = A[randomPos];
+            A[randomPos] = tmp;
+        }
+        Arrays.sort(A);
+    }
+
+    long[] longArr(int n){
+        long[] res= new long[n];
+        for(int i=0;i<n;i++){
+            res[i]= in.nextLong();
+        }
+        return res;
+    }
+
+    // sieve of eratosthenes code for precomputing whether numbers are prime or not up to MAX_VALUE
+    long MAX= MAX_VALUE;
+    int[] precomp= new int[(int) (MAX+1)];
+    void sieve(){
+        long n= MAX;
+        boolean[] prime = new boolean[(int) (n+1)];
+        for(int i=0;i<=n;i++)
+            prime[i] = true;
+
+        for(long p = 2; p*p <=n; p++)
+        {
+            // If prime[p] is not changed, then it is a prime
+            if(prime[(int) p])
+            {
+                // Update all multiples of p
+                for(long i = p*p; i <= n; i += p)
+                    prime[(int) i] = false;
+            }
+        }
+
+        // Print all prime numbers
+        for(long i = 2; i <= n; i++)
+        {
+            if(prime[(int) i])
+                precomp[(int) i]= 1;
+        }
+    }
+
+    boolean isDigitSumPalindrome(long N) {
+        // code here
+        long sum= sumOfDigits(String.valueOf(N));
+        long rev=0;
+        long org= sum;
+        while (sum!=0){
+            long d= sum%10;
+            rev = rev*10 +d;
+            sum /= 10;
+        }
+        return org == rev;
+    }
+
+    long sumOfDigits(String n){
+        long sum= 0;
+        for (char c: n.toCharArray()){
+            sum += Integer.parseInt(String.valueOf(c));
+        }
+        return sum;
+    }
+
+    long[] revArray(long[] arr) {
+        int n= arr.length;
+        int i=0, j=n-1;
+        while (i<j){
+            long temp= arr[i];
+            arr[i]= arr[j];
+            arr[j]= temp;
+            i++;
+            j--;
+        }
+        return arr;
+    }
+
+    long gcd(long a, long b){
+        if (b==0)
+            return a;
+        return gcd(b, a%b);
+    }
+    long lcm(long a,long b){
+        return (a*b)/gcd(a,b);
+    }
+
+    static class Pair{
+        long first;
+        long second;
+        Pair(long x,long y){
+            this.first=x;
+            this.second=y;
+        }
+    }
+
+    static class Compare {
+        static void compare(ArrayList<Pair> arr, long n) {
+            arr.sort(new Comparator<Pair>() {
+                @Override
+                public int compare(Pair p1, Pair p2) {
+                    return (int) (p2.first - p1.first);
+                }
+            });
+        }
+    }
+
+    public static class FastReader{
+        BufferedReader br;
+        StringTokenizer st;
+        public FastReader(){
+            br=new BufferedReader(new InputStreamReader(System.in));
+        }
+        String next(){
+            while (st==null || !st.hasMoreElements()){
+                try{
+                    st=new StringTokenizer(br.readLine());
+                }catch (Exception e){
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+        int nextInt(){
+            return Integer.parseInt(next());
+        }
+        long nextLong(){
+            return Long.parseLong(next());
+        }
+        double nextDouble(){
+            return Double.parseDouble(next());
+        }
+        float nextFloat(){
+            return Float.parseFloat(next());
+        }
+        String nextLine(){
+            String str="""";
+            try{
+                str=br.readLine();
+            }catch (Exception e){
+                e.printStackTrace();
+            }
+            return str;
+        }
+    }
+}",1
+522458fc,702694f5,"import java.io.*;
+import java.util.*;
+
+/*
+polyakoff
+*/
+
+public class Main {
+
+    static FastReader in;
+    static PrintWriter out;
+    static Random rand = new Random();
+    static final int oo = (int) 2e9 + 10;
+    static final long OO = (long) 2e18 + 10;
+    static final int MOD = 998244353;
+
+    static int ask(int i) {
+        out.println(""? "" + (i + 1));
+        out.flush();
+        return in.nextInt() - 1;
+    }
+
+    static void solve() {
+        int n = in.nextInt();
+
+        int[] p = new int[n];
+        Arrays.fill(p, -1);
+        for (int i = 0; i < n; i++) {
+            if (p[i] == -1) {
+                int first = ask(i);
+                ArrayList<Integer> cycle = new ArrayList<>();
+                while (true) {
+                    int x = ask(i);
+                    cycle.add(x);
+                    if (x == first)
+                        break;
+                }
+                int sz = cycle.size();
+                int from = -1;
+                for (int j = 0; j < sz; j++) {
+                    if (cycle.get(j) == i) {
+                        from = j;
+                        break;
+                    }
+                }
+                p[i] = cycle.get((from + 1) % sz);
+                for (int j = (from + 1) % sz; j != from; j = (j + 1) % sz) {
+                    p[cycle.get(j)] = cycle.get((j + 1) % sz);
+                }
+            }
+        }
+
+        out.print(""!"");
+        for (int i = 0; i < n; i++) {
+            out.print("" "" + (p[i] + 1));
+        }
+        out.println();
+        out.flush();
+
+    }
+
+    public static void main(String[] args) {
+        in = new FastReader();
+        out = new PrintWriter(System.out);
+
+        int t = 1;
+        t = in.nextInt();
+        while (t-- > 0) {
+            solve();
+        }
+
+        out.flush();
+        out.close();
+    }
+
+    static class FastReader {
+        BufferedReader br;
+        StringTokenizer st;
+
+        FastReader() {
+            this(System.in);
+        }
+        FastReader(String file) throws FileNotFoundException {
+            this(new FileInputStream(file));
+        }
+        FastReader(InputStream is) {
+            br = new BufferedReader(new InputStreamReader(is));
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+        String next() {
+            while (st == null || !st.hasMoreTokens()) {
+                st = new StringTokenizer(nextLine());
+            }
+            return st.nextToken();
+        }
+        String nextLine() {
+            String line;
+            try {
+                line = br.readLine();
+            } catch (IOException e) {
+                throw new RuntimeException(e);
+            }
+            return line;
+        }
+    }
+}
+","import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+//import java.text.DecimalFormat;
+import java.util.*;
+
+//import B.Node;
+ 
+public class Codeforces {
+	static int mod= 998244353;
+	static char arr[];
+	static class Node{
+		int l,r,c,ind;
+		Node(){
+			
+		}
+		Node(int l,int r,int c){
+			this.l=l;
+			this.r=r;
+			this.c=c;
+		}
+		Node(int l,int r,int c,int d){
+			this.l=l;
+			ind=d;
+			this.r=r;
+			this.c=c;
+		}
+	}
+	public static void main(String[] args) throws Exception {
+		PrintWriter out=new PrintWriter(System.out);
+		FastScanner fs=new FastScanner();
+//		int t=fs.nextInt();
+		int t=fs.nextInt();
+		outer:while(t-->0) {
+			int n=fs.nextInt();
+			int p[]=new int[n];
+			Arrays.fill(p, -1);
+			for(int i=0;i<n;i++) {
+				if(p[i]==-1) {
+					List<Integer> list=new ArrayList<>();
+					Set<Integer> set=new HashSet<>();
+					while(true) {
+						System.out.println(""? ""+(i+1));
+						int cur=fs.nextInt();
+						list.add(cur);
+						if(set.contains(cur)) break;
+						set.add(cur);
+						
+					}
+					for(int j=0;j<list.size()-1;j++) {
+						int cur=list.get(j), next=list.get(j+1);
+						p[cur-1]=next;
+					}
+				}
+			}
+			StringBuilder ans=new StringBuilder(""! "");
+			for(int ele:p) {
+				ans.append(ele+ "" "");
+			}
+			System.out.println(ans);
+		}
+		
+		
+		out.close();
+		
+	}
+	static void query(int p[],int i,FastScanner fs) {
+		System.out.println(""? ""+i);
+		System.out.flush();
+		int last=fs.nextInt();
+		while(true) {
+			System.out.println(""? ""+i);
+			System.out.flush();
+			int cur=fs.nextInt();
+			p[last-1]=cur;
+			if(cur==1) return ;
+			last=cur;
+		}
+		
+	}
+	static long pow(long a,long b) {
+		if(b<0) return 1;
+		long res=1;
+		while(b!=0) {
+			if((b&1)!=0) {
+				res*=a;
+				res%=mod;
+			}
+			a*=a;
+			a%=mod;
+			b=b>>1;
+		}
+		return res;
+	}
+	static int gcd(int  a,int  b) {
+		if(b==0) return a;
+		return gcd(b,a%b);
+	}
+	static long nck(int n,int k) {
+		if(k>n) return 0;
+		long res=1;
+		res*=fact(n);
+		res%=mod;
+		res*=modInv(fact(k));
+		res%=mod;
+		res*=modInv(fact(n-k)); 
+		res%=mod;
+		return res;
+	}
+	static long fact(long n) {
+//		return fact[(int)n];
+		long res=1;
+		for(int i=2;i<=n;i++) {
+			res*=i;
+			res%=mod;
+		}
+		return res;
+	}
+	
+	static long modInv(long n) {
+		return pow(n,mod-2);
+	}
+	
+	static void sort(int[] a) {
+		//suffle
+		int n=a.length;
+		Random r=new Random();
+		for (int i=0; i<a.length; i++) {
+			int oi=r.nextInt(n);
+			int temp=a[i];
+			a[i]=a[oi];
+			a[oi]=temp;
+		}
+		
+		//then sort
+		Arrays.sort(a);
+	}
+	
+	// Use this to input code since it is faster than a Scanner
+	static class FastScanner {
+		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st=new StringTokenizer("""");
+		String next() {
+			while (!st.hasMoreTokens())
+				try {
+					st=new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			return st.nextToken();
+		}
+		
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+		long[] lreadArray(int n) {
+			long a[]=new long[n];
+			for(int i=0;i<n;i++) a[i]=nextLong();
+			return a;
+		}
+		int[] readArray(int n) {
+			int[] a=new int[n];
+			for (int i=0; i<n; i++) a[i]=nextInt();
+			return a;
+		}
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+	}
+ 
+}",0
+ca8f11a4,e185bce5,"
+import java.util.*;
+import java.util.stream.Collectors;
+import java.io.*;
+import java.math.*;
+
+public class GR18_C2 {
+	public static FastScanner sc;
+	public static StringBuilder sb ;public static int MOD= 1000000007;
+	public static class FastScanner {
+		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st=new StringTokenizer("""");
+		String next() {
+			while (!st.hasMoreTokens())
+				try { 
+					st=new StringTokenizer(br.readLine());				               
+	             } catch (IOException e) {}
+				return st.nextToken();
+			}
+		
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+		String nextLine() throws IOException {
+			return br.readLine();
+		}
+    }
+
+    public static void solve(int t) throws IOException {
+    	int n=sc.nextInt();
+    	String a=sc.next();
+    	String b=sc.next();
+    	
+    	int _00=0;
+    	int _01=0;
+    	int _10=0;
+    	int _11=0;
+    	
+    	for(int i=0;i<n;i++) {
+    		if(a.charAt(i)=='0' && b.charAt(i)=='0') _00++;
+    		if(a.charAt(i)=='0' && b.charAt(i)=='1') _01++;
+    		if(a.charAt(i)=='1' && b.charAt(i)=='0') _10++;
+    		if(a.charAt(i)=='1' && b.charAt(i)=='1') _11++;
+    	}
+    	
+    	int ans=Integer.MAX_VALUE;
+    	
+    	
+    	// All _01 and _10 can be converted to _11 and _00 by swapping and this requires to operations
+    	if(_01==_10) {
+    		ans=Math.min(ans, _10*2);
+    	}
+    	// By performing one operation, we get _01==_10 and then even operations can be done.
+    	// Possible when _11=_00 and one additional _11 for odd operation
+    	if(_00+1==_11) {
+    		ans=Math.min(ans, (_11-1)*2+1);
+    	}
+    	if(ans==Integer.MAX_VALUE) sb.append(-1).append('\n');
+    	else sb.append(ans).append('\n');
+    }
+    
+	public static void main(String[] args) throws IOException {
+		sb = new StringBuilder("""");
+		sc = new FastScanner();
+		int t=sc.nextInt();
+		for(int i=1;i<=t;i++){
+			solve(i);
+		}
+		System.out.println(sb);
+	}
+	
+	
+}
+","
+import java.util.*;
+
+import java.io.*;
+import java.math.BigInteger;
+import java.nio.charset.StandardCharsets;
+	
+public class Main {
+		private static FS sc = new FS();
+		
+		private static class FS {
+			BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+			StringTokenizer st = new StringTokenizer("""");
+			String next() {
+				while (!st.hasMoreTokens())
+					try {
+						st=new StringTokenizer(br.readLine());				               
+		            } catch (IOException e) {}
+				return st.nextToken();
+			}
+			
+			int nextInt() {
+				return Integer.parseInt(next());
+			}
+			long nextLong() {
+				return Long.parseLong(next());
+			}
+		}
+		
+		private static class extra {
+			
+			static int[] intArr(int size) {
+				int[] a = new int[size];
+				for(int i = 0; i < size; i++) a[i] = sc.nextInt();
+				return a;
+			}
+			
+			static long[] longArr(int size) {
+				Scanner scc = new Scanner(System.in);
+				long[] a = new long[size];
+				for(int i = 0; i < size; i++) a[i] = sc.nextLong();
+				return a;
+			}
+			
+			static long intSum(int[] a) {
+				long sum = 0; 
+				for(int i = 0; i < a.length; i++) {
+					sum += a[i];
+				}
+				return sum;
+			}
+			
+			static long longSum(long[] a) {
+				long sum = 0; 
+				for(int i = 0; i < a.length; i++) {
+					sum += a[i];
+				}
+				return sum;
+			}
+			
+			static LinkedList[] graphD(int vertices, int edges) {
+				LinkedList<Integer>[] temp = new LinkedList[vertices+1];
+				for(int i = 0; i <= vertices; i++) temp[i] = new LinkedList<>();
+				for(int i = 0; i < edges; i++) {
+					int x = sc.nextInt();
+					int y = sc.nextInt();
+					temp[x].add(y);
+				}
+				return temp;
+			}
+			
+			static LinkedList[] graphUD(int vertices, int edges) {
+				LinkedList<Integer>[] temp = new LinkedList[vertices+1];
+				for(int i = 0; i <= vertices; i++) temp[i] = new LinkedList<>();
+				for(int i = 0; i < edges; i++) {
+					int x = sc.nextInt();
+					int y = sc.nextInt();
+					temp[x].add(y);
+					temp[y].add(x);
+				}
+				return temp;
+			}
+			
+			static void printG(LinkedList[] temp) { for(LinkedList<Integer> aa:temp) System.out.println(aa); }
+			
+			static long cal(long val, long pow, long mod) {
+				if(pow == 0) return 1;
+				long res = cal(val, pow/2, mod);
+				
+				long ret = (res*res)%mod;
+				if(pow%2 == 0) return ret;
+				return (val*ret)%mod;
+			}
+			
+			static long gcd(long a, long b) { return b == 0 ? a:gcd(b, a%b); }
+			
+		}
+		
+		static int mod = (int) 1e9;
+		
+		static LinkedList<Integer>[] temp, idx;
+		static long inf = (long) Long.MAX_VALUE;
+//		static long inf = Long.MAX_VALUE;
+//		static int max;
+		
+		public static void main(String[] args) { 
+			int t = sc.nextInt();
+//			int t = 1;
+			StringBuilder ret = new StringBuilder();
+			while(t-- > 0) {
+				int n = sc.nextInt();
+				String a = sc.next(), b = sc.next();
+				int _00 = 0, _01 = 0, _10 = 0, _11 = 0;
+				for(int i = 0; i < n; i++) {
+					if(a.charAt(i) == '0' && b.charAt(i) == '0') _00++;
+					if(a.charAt(i) == '0' && b.charAt(i) == '1') _01++;
+					if(a.charAt(i) == '1' && b.charAt(i) == '0') _10++;
+					if(a.charAt(i) == '1' && b.charAt(i) == '1') _11++;
+				}
+				int ans = Integer.MAX_VALUE;
+				if(_10 == _01) ans = _01 + _10;
+				if(_10 > 0) {
+					int n00 = _10 - 1;
+		            int n01 = _11;
+		            int n10 = _00 + 1;
+		            int n11 = _01;
+		            if (n01 == n10) {
+		                ans = Math.min(ans, 1 + n01 + n10);
+		            }
+				}
+				if(_11 > 0) {
+					int n00 = _10;
+		            int n01 = _11 - 1;
+		            int n10 = _00;
+		            int n11 = _01 + 1;
+		            if (n01 == n10) {
+		                ans = Math.min(ans, 1 + n01 + n10);
+		            }
+				}
+				ret.append(ans == Integer.MAX_VALUE ? -1 : ans);
+				ret.append(""\n"");
+			}
+			System.out.println(ret);
+		}
+
+	}
+
+	
+	
+
+
+	
+	
+	
+",0
+0922b7e7,d1cd194e,"import java.io.*;
+import java.util.*;
+
+public class PhoenixAndTowers {
+	public static void main(String[] args) throws IOException {
+		// BufferedReader in = new BufferedReader(new FileReader(""PhoenixAndTowers.in""));
+		// PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter(""PhoenixAndTowers.out"")));
+		BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
+		PrintWriter out = new PrintWriter(System.out);
+
+		int T = Integer.parseInt(in.readLine());
+		for (int i = 0; i < T; i++) {
+			StringTokenizer st = new StringTokenizer(in.readLine());
+			int N = Integer.parseInt(st.nextToken());
+			int M = Integer.parseInt(st.nextToken());
+			int X = Integer.parseInt(st.nextToken());
+			PriorityQueue<Tower> towers = new PriorityQueue<Tower>();
+			for (int j = 1; j <= M; j++) towers.add(new Tower(j, 0));
+			out.println(""YES"");
+			st = new StringTokenizer(in.readLine());
+			for (int j = 0; j < N; j++) {
+				Tower t = towers.remove();
+				t.size += Integer.parseInt(st.nextToken());
+				towers.add(t);
+				out.print(t.idx + "" "");
+			}
+			out.println();
+		}
+
+		out.close();
+		in.close();
+	}
+	
+	public static class Tower implements Comparable<Tower> {
+		int idx, size;
+		public Tower(int idx, int size) {
+			this.idx = idx;
+			this.size = size;
+		}
+		@Override
+		public int compareTo(Tower o) {
+			return size - o.size;
+		}
+	}
+}","import java.util.*;
+
+import java.lang.*;
+import java.io.*;
+
+public class Template {
+	
+	static class FastReader {
+  BufferedReader br;
+  StringTokenizer st;
+
+  public FastReader()
+  {
+      br = new BufferedReader(
+          new InputStreamReader(System.in));
+  }
+
+  String next()
+  {
+      while (st == null ||!st.hasMoreElements()) {
+          try {
+              st = new StringTokenizer(br.readLine());
+          }
+          catch (IOException e) {
+              e.printStackTrace();
+          }
+      }
+      return st.nextToken();
+  }
+
+  int nextInt() { return Integer.parseInt(next()); }
+
+  long nextLong() { return Long.parseLong(next()); }
+
+  double nextDouble()
+  {
+      return Double.parseDouble(next());
+  }
+
+  String nextLine()
+  {
+      String str = """";
+      try {
+          str = br.readLine();
+      }
+      catch (IOException e) {
+          e.printStackTrace();
+      }
+      return str;
+  }
+  
+}
+	
+//	static void solve(String s) 
+//	{
+////		Scanner sc = new Scanner(System.in);
+////		String s = sc.next();
+//		
+//		int x[] = new int[2];
+//		x[0] = x[1] = -1;
+//		
+//		int ans = 0;
+//		int n = s.length();
+//		for(int i=0;i<n;i++)
+//		{
+//			int c = s.charAt(i) - '0';
+//			if(c == 1 || c == 0)
+//			{
+//				x[(i%2) ^ c] = i;
+//			}
+//			int min = Math.min(x[0], x[1]);
+//			ans += i - min;
+//			//System.out.println(ans);
+//		}
+//		System.out.println(ans);
+//	}
+//	
+
+//	    public static void main(String args[])
+//	    {
+//	    	FastReader sc = new FastReader();
+//	    	//solve();
+//	    	//Scanner sc = new Scanner(System.in)
+//	       int testcases = sc.nextInt();  // nTest is the number of treasure hunts.
+//	      
+////	    	int testcases = 3;
+//	        while(testcases-- > 0)
+//	        {
+//	        	String s = sc.next();
+//	        	solve(s);
+//	        	
+//	        }
+//	    
+//	    }
+	
+	static class Pair implements Comparable<Pair>
+	{
+		int h;
+		int ind;
+		
+		Pair(int h, int ind)
+		{
+			this.h = h;
+			this.ind = ind;
+		}
+		@Override
+		public int compareTo(Pair o) {
+			
+			return this.h - o.h;
+		}
+		
+		
+	}
+	public static void main(String[] args) {
+
+		FastReader fs=new FastReader();
+
+		int T=fs.nextInt();
+
+		for (int tt=0; tt<T; tt++) {
+		int n = fs.nextInt();
+		int m = fs.nextInt();
+		int x = fs.nextInt();
+		
+		if(n < m)
+		{
+			System.out.println(""NO"");
+			continue;
+		}
+		Pair a[] = new Pair[n];
+		PriorityQueue<Pair> heap = new PriorityQueue<>();
+		for(int i=0;i<n;i++)
+		{
+			a[i] = new Pair(fs.nextInt(), i);
+			
+		}
+		
+		Arrays.sort(a);
+		for(int i=1;i<=m;i++)
+		{
+			heap.add(new Pair(0, i));
+		}
+		int max = Integer.MIN_VALUE;
+		int min = Integer.MAX_VALUE;
+		int ans[] = new int[n];
+		int idx = 0;
+		while(!heap.isEmpty() && idx < n)
+		{
+			Pair curr = heap.poll();
+			curr.h += a[idx].h;
+			ans[a[idx].ind] = curr.ind;
+			heap.add(new Pair(curr.h,  curr.ind));
+			idx++;
+		}
+			
+		
+		
+//		int towers[] = new int[m+1];
+//		int tower = 1;
+//		boolean flag = false;
+//		boolean inc = true;
+//		for(int i=0;i<n;i++)
+//		{
+//			if(tower == m+1)
+//			{
+//				tower = m;
+//				inc = false;
+//			}
+//			if(tower == 0)
+//			{
+//				tower = 1;
+//				inc = true;
+//			}
+//			towers[tower] += a[i].h;
+//			System.out.println(a[i].h +"" THis"" + tower);
+////			min = Math.min(min, towers[tower]);
+////			max = Math.max(max, towers[tower]);
+//			ans[a[i].ind] = tower;
+////			if(Math.abs(max - min) > x)
+////			{
+////				System.out.println(""NO"" + a[i].ind+"" ""+a[i].h +"" ""+min +"" ""+max);
+////				flag = true;
+////				break;
+////			}
+//			if(inc)
+//				tower++;
+//			else
+//				tower--;
+//		}
+//		for(int i=1;i<=m;i++)
+//		{
+//			min = Math.min(min, towers[i]);
+//			max = Math.max(max, towers[i]);
+//		}
+//		if(Math.abs(max - min) > x)
+//			{
+//				System.out.println(""NO"" + max+"" ""+min);// + a[i].ind+"" ""+a[i].h +"" ""+min +"" ""+max);
+//				//flag = true;
+//				continue;
+//			}
+//		if(flag)
+//			continue;
+		System.out.println(""YES"");
+		for(int i:ans)
+			System.out.print(i+"" "");
+		
+		System.out.println();
+
+		}
+	
+}
+}
+",0
+929b98f0,bf85ab7b,"
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.PrintStream;
+import java.util.*;
+
+public class Main {
+
+    public static long[] ans(List<List<Integer>> edges, long[][] range, int root, boolean[] visited, PrintStream out) {
+        if (visited[root]) {
+            return new long[2];
+        }
+        visited[root] = true;
+        long[] ans = new long[2];
+        for (int x : edges.get(root)) {
+            if (!visited[x]) {
+                long[] temp = ans(edges, range, x, visited, out);
+                ans[0] += Math.max(Math.abs(range[root][0] - range[x][0]) + temp[0], Math.abs(range[root][0] - range[x][1]) + temp[1]);
+                ans[1] += Math.max(Math.abs(range[root][1] - range[x][0]) + temp[0], Math.abs(range[root][1] - range[x][1]) + temp[1]);
+            }
+        }
+        return ans;
+    }
+
+    public static void main(String[] args) throws IOException {
+        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
+        PrintStream out = new PrintStream(System.out);
+        int t = Integer.parseInt(reader.readLine());
+        while (t-->0) {
+            int n = Integer.parseInt(reader.readLine());
+            long[][] range = new long[n][2];
+            for (int i = 0; i < n; i++) {
+                String[] input = reader.readLine().split("" "");
+                range[i][0] = Integer.parseInt(input[0]);
+                range[i][1] = Integer.parseInt(input[1]);
+            }
+            List<List<Integer>> edges = new ArrayList<>();
+            for (int i = 0; i < n; i++) {
+                edges.add(new ArrayList<>());
+            }
+            for (int i = 0; i < n - 1; i++) {
+                String[] input = reader.readLine().split("" "");
+                int u = Integer.parseInt(input[0]) - 1, v = Integer.parseInt(input[1]) - 1;
+                edges.get(u).add(v);
+                edges.get(v).add(u);
+            }
+            int root = 0;
+            for (int i = 0; i < n; i++) {
+                if (edges.get(i).size() > 1) {
+                    root = i;
+                    break;
+                }
+                if (edges.get(i).size() == 1) {
+                    root = i;
+                }
+            }
+            long[] ans = ans(edges, range, root, new boolean[n], out);
+            out.println(Math.max(ans[0], ans[1]));
+        }
+        out.close();
+    }
+}
+","
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Scanner;
+import java.io.DataInputStream;
+import java.io.FileInputStream;
+
+import java.io.IOException;
+
+public class ParsasHumongousTree {
+
+    public static void main(String args[]) throws IOException {
+        Reader scan = new Reader();
+        StringBuilder sb = new StringBuilder();
+
+        int t = scan.nextInt();
+        while (t-- > 0) {
+            int n = scan.nextInt();
+            int[] l = new int[n + 1];
+            int[] r = new int[n + 1];
+            for (int i = 1; i <= n; i++) {
+                l[i] = scan.nextInt();
+                r[i] = scan.nextInt();
+            }
+            Graph g = new Graph(n);
+            for (int i = 0; i < n - 1; i++) {
+                g.addEdge(scan.nextInt(), scan.nextInt());
+            }
+            sb.append(g.dfs(l, r) + ""\n"");
+        }
+        System.out.println(sb);
+    }
+}
+
+class Graph {
+
+    ArrayList<Integer>[] node;
+    int n;
+    int c = 0;
+    boolean[] vis;
+
+    Graph(int s) {
+        n = s + 1;
+        vis = new boolean[n + 1];
+        node = new ArrayList[n + 1];
+        for (int i = 0; i < n + 1; i++) {
+            node[i] = new ArrayList<>();
+        }
+    }
+
+    void addEdge(int u, int v) {
+
+        node[u].add(v);
+        node[v].add(u);
+        if (node[u].size() == 1) {
+            c = u;
+        }
+        if (node[v].size() == 1) {
+            c = v;
+        }
+    }
+
+    void cleanVisArray() {
+        for (int i = 0; i < n + 1; i++) {
+            vis[i] = false;
+        }
+    }
+
+    long dfs(int[] l, int[] r) {
+        cleanVisArray();
+
+        long[][] dp = new long[n][2];
+        dfsMain(1, dp, l, r);
+        return Math.max(dp[1][0], dp[1][1]);
+    }
+
+    void dfsMain(int v, long[][] dp, int[] l, int[] r) {
+        vis[v] = true;
+        for (int i : node[v]) {
+            if (!vis[i]) {
+                dfsMain(i, dp, l, r);
+                dp[v][0] += Math.max(Math.abs(l[v] - l[i]) + dp[i][0], Math.abs(l[v] - r[i]) + dp[i][1]);
+                dp[v][1] += Math.max(Math.abs(r[v] - l[i]) + dp[i][0], Math.abs(r[v] - r[i]) + dp[i][1]);
+            }
+        }
+    }
+
+}
+
+class Reader {
+
+    final private int BUFFER_SIZE = 1 << 16;
+    private DataInputStream din;
+    private byte[] buffer;
+    private int bufferPointer, bytesRead;
+
+    public Reader() {
+        din = new DataInputStream(System.in);
+        buffer = new byte[BUFFER_SIZE];
+        bufferPointer = bytesRead = 0;
+    }
+
+    public Reader(String file_name) throws IOException {
+        din = new DataInputStream(new FileInputStream(file_name));
+        buffer = new byte[BUFFER_SIZE];
+        bufferPointer = bytesRead = 0;
+    }
+
+    public String readLine() throws IOException {
+        byte[] buf = new byte[64]; // line length 
+        int cnt = 0, c;
+        while ((c = read()) != -1) {
+            if (c == '\n') {
+                break;
+            }
+            buf[cnt++] = (byte) c;
+        }
+        return new String(buf, 0, cnt);
+    }
+
+    public int nextInt() throws IOException {
+        int ret = 0;
+        byte c = read();
+        while (c <= ' ') {
+            c = read();
+        }
+        boolean neg = (c == '-');
+        if (neg) {
+            c = read();
+        }
+        do {
+            ret = ret * 10 + c - '0';
+        } while ((c = read()) >= '0' && c <= '9');
+
+        if (neg) {
+            return -ret;
+        }
+        return ret;
+    }
+
+    public long nextLong() throws IOException {
+        long ret = 0;
+        byte c = read();
+        while (c <= ' ') {
+            c = read();
+        }
+        boolean neg = (c == '-');
+        if (neg) {
+            c = read();
+        }
+        do {
+            ret = ret * 10 + c - '0';
+        } while ((c = read()) >= '0' && c <= '9');
+        if (neg) {
+            return -ret;
+        }
+        return ret;
+    }
+
+    public double nextDouble() throws IOException {
+        double ret = 0, div = 1;
+        byte c = read();
+        while (c <= ' ') {
+            c = read();
+        }
+        boolean neg = (c == '-');
+        if (neg) {
+            c = read();
+        }
+
+        do {
+            ret = ret * 10 + c - '0';
+        } while ((c = read()) >= '0' && c <= '9');
+
+        if (c == '.') {
+            while ((c = read()) >= '0' && c <= '9') {
+                ret += (c - '0') / (div *= 10);
+            }
+        }
+
+        if (neg) {
+            return -ret;
+        }
+        return ret;
+    }
+
+    private void fillBuffer() throws IOException {
+        bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
+        if (bytesRead == -1) {
+            buffer[0] = -1;
+        }
+    }
+
+    private byte read() throws IOException {
+        if (bufferPointer == bytesRead) {
+            fillBuffer();
+        }
+        return buffer[bufferPointer++];
+    }
+
+    public void close() throws IOException {
+        if (din == null) {
+            return;
+        }
+        din.close();
+    }
+}
+",0
+856a8eda,c354b74f,"/*input
+2
+5 2 3
+1 2 3 1 2
+4 3 3
+1 1 2 3
+*/
+import java.io.*;
+import java.util.*;
+
+public class three{
+	public static class Pair implements Comparable<Pair>{
+		int min;
+		int idx;
+		@Override
+    public int compareTo(Pair o) {
+        return min - o.min;
+    }
+	}
+
+public static void main(String[] args) throws Exception {
+        MyScanner scn = new MyScanner();
+        out = new PrintWriter(new BufferedOutputStream(System.out));
+         /*
+      int n      = sc.nextInt();        // read input as integer
+      long k     = sc.nextLong();       // read input as long
+      double d   = sc.nextDouble();     // read input as double
+      String str = sc.next();           // read input as String
+      String s   = sc.nextLine();       // read whole line as String
+ 
+      int result = 3*n;
+      out.println(result);                    // print via PrintWriter
+      */
+
+      //The Code Starts here
+      int t = scn.nextInt();
+      while(t-- > 0){
+      	int n = scn.nextInt();
+      	int m = scn.nextInt();
+
+      	int x = scn.nextInt();
+      	int arr[] = scn.nextIntArray(n);
+      	PriorityQueue<Pair> pq = new PriorityQueue<>();
+      	      	System.out.println(""YES"");
+
+      	for(int i=0;i<m;i++){
+      		Pair p = new Pair();
+      		p.min = arr[i];
+      		p.idx = i+1;
+      		pq.add(p);
+      		System.out.print(p.idx + "" "");
+      	}
+
+      	for(int i=m;i<n;i++){
+      		Pair p = pq.peek();
+      		int mini = p.min;
+      		int index = p.idx;
+      		System.out.print(index + "" "");
+      		pq.remove();
+      		Pair np = new Pair();
+      		np.min = arr[i] + mini;
+      		np.idx = index;
+      		pq.add(np);
+      	}
+      	System.out.println();
+
+
+
+
+      	
+      }
+
+
+
+
+
+      //The Code Ends here
+        out.close();
+
+    
+
+    
+ }
+
+
+
+
+
+   //-----------PrintWriter for faster output---------------------------------
+    public static PrintWriter out;
+ 
+    //-----------MyScanner class for faster input----------
+    public static class MyScanner {
+        BufferedReader br;
+        StringTokenizer st;
+ 
+        public MyScanner() {
+            br = new BufferedReader(new InputStreamReader(System.in));
+        }
+ 
+        String next() {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+ 
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+ 
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+ 
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+ 
+        String nextLine() {
+            String str = """";
+            try {
+                str = br.readLine();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+        }
+ 
+        public int[] nextIntArray(int n) {
+            int[] arr = new int[n];
+            for (int i = 0; i < n; i++) {
+                arr[i] = nextInt();
+            }
+            return arr;
+        }
+ 
+        public long[] nextLongArray(int n) {
+            long[] arr = new long[n];
+            for (int i = 0; i < n; i++) {
+                arr[i] = nextLong();
+            }
+            return arr;
+        }
+ 
+        public int[][] nextInt2DArray(int m, int n) {
+            int[][] arr = new int[m][n];
+            for (int i = 0; i < m; i++) {
+                for (int j = 0; j < n; j++)
+                    arr[i][j] = nextInt();
+            }
+            return arr;
+        }
+ 
+        private boolean isSpaceChar(int c) {
+            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
+        }
+ 
+        private boolean isEndOfLine(int c) {
+            return c == '\n' || c == '\r' || c == -1;
+        }
+ 
+    }
+ 
+    public static void debug(Object... o) {
+        System.out.println(Arrays.deepToString(o));
+    }
+ 
+    // public static class Pair implements Comparable<Pair> {
+    //     long u;
+    //     long v;
+ 
+    //     public Pair(long u, long v) {
+    //         this.u = u;
+    //         this.v = v;
+    //     }
+ 
+ 
+    //     public int hashCode() {
+    //         int hu = (int) (u ^ (u >>> 32));
+    //         int hv = (int) (v ^ (v >>> 32));
+    //         return 31 * hu + hv;
+    //     }
+ 
+    //     public boolean equals(Object o) {
+    //         Pair other = (Pair) o;
+    //         return u == other.u && v == other.v;
+    //     }
+ 
+    //     public int compareTo(Pair other) {
+    //         return Long.compare(u, other.u) != 0 ? Long.compare(u, other.u) : Long.compare(v, other.v);
+    //     }
+ 
+    //     public String toString() {
+    //         return ""[u="" + u + "", v="" + v + ""]"";
+    //     }
+    // }
+    //--------------------------------------------------------
+}
+
+
+
+
+	
+
+
+
+	
+","//Some of the methods are copied from GeeksforGeeks Website  
+import java.util.*;
+import java.lang.*;
+import java.io.*;
+public class Main
+{ 
+  static  Reader sc=new Reader();
+  // static FastReader sc=new FastReader(System.in);
+  static class PairComparator implements Comparator<Pair>{
+              
+            // Overriding compare()method of Comparator 
+                        // for descending order of cgpa
+            public int compare(Pair s1, Pair s2) {
+                if (s1.x < s2.x)
+                    return -1;
+                else if (s1.x > s2.x)
+                    return 1;
+                                return 0;
+                }
+        }
+ public static void main (String[] args) throws java.lang.Exception
+   {
+//	try{
+	    /*
+	        int n=sc.nextInt();
+	        ArrayList<Integer> al=new ArrayList<>();
+	        ArrayList<Long> al=new ArrayList<>();
+	        Set<Integer> set=new HashSet<>();
+	        Collections.sort(al,Collections.reverseOrder());
+	     
+	        long n=sc.nextLong();
+	        for(int i=0;i<n;i++) 
+	        String s=sc.next();
+	        StringBuilder sb=new StringBuilder();
+	     */
+		  int t = sc.nextInt();
+		  while(t-->0)
+		    { 
+		       int n=sc.nextInt();
+		       int m=sc.nextInt();
+		       int x=sc.nextInt();
+		       PriorityQueue<Pair> pq=new PriorityQueue<>(m, new PairComparator());
+		       for(int i=1;i<=m;i++)
+		         {
+		          Pair p=new Pair(0,i);
+		          pq.add(p);
+		         }
+		       out.println(""YES"");
+		       int a[]=new int[n];
+		       for(int i=0;i<n;i++)
+		         {
+		           a[i]=sc.nextInt();
+		           Pair shortest=pq.poll();
+		           out.print(shortest.y+"" "");
+		           Pair update=new Pair(shortest.x+a[i],shortest.y);
+		           pq.add(update);
+		         }
+		      
+		      out.println( );
+		    }
+	     out.flush();
+	     out.close();
+// 	   }     
+// 	catch(Exception e)
+// 		 {}
+	}
+ 
+ /*
+   ...SOLUTION ENDS HERE...........SOLUTION ENDS HERE...
+ */
+ 
+static void flag(boolean flag)
+   {
+       out.println(flag ? ""YES"" : ""NO"");
+       out.flush();
+   }
+   
+ /*                     
+    Map<Long,Long> map=new HashMap<>();
+             for(int i=0;i<n;i++)
+               {
+                  if(!map.containsKey(a[i]))
+                   map.put(a[i],1);
+                 else
+                   map.replace(a[i],map.get(a[i])+1);
+               }
+     
+    Set<Map.Entry<Long,Long>> hmap=map.entrySet();
+             for(Map.Entry<Long,Long> data : hmap)
+               {
+          
+               }
+       
+   Iterator<Integer> it = set.iterator();
+          while(it.hasNext()) 
+           { 
+            int x=it.next();
+           }
+   */
+
+static void print(int a[])
+  {
+     int n=a.length;
+     for(int i=0;i<n;i++)
+       {
+          out.print(a[i]+"" "");
+       }
+     out.println();
+     out.flush();
+  }
+static void print(long a[])
+  {
+     int n=a.length;
+     for(int i=0;i<n;i++)
+       {
+          out.print(a[i]+"" "");
+       }
+     out.println();
+     out.flush();
+  } 
+static void print_int(ArrayList<Integer> al)
+  {
+     int si=al.size();
+     for(int i=0;i<si;i++)
+       {
+          out.print(al.get(i)+"" "");
+       }
+     out.println();
+     out.flush();
+  }
+static void print_long(ArrayList<Long> al)
+  {
+     int si=al.size();
+     for(int i=0;i<si;i++)
+       {
+          out.print(al.get(i)+"" "");
+       }
+     out.println();
+     out.flush();
+  }
+  
+static int LowerBound(int a[], int x) 
+ { // x is the target value or key
+  int l=-1,r=a.length;
+  while(l+1<r) {
+    int m=(l+r)>>>1;
+    if(a[m]>=x) r=m;
+    else l=m;
+  }
+  return r;
+}
+
+ static int UpperBound(int a[], int x)
+  {// x is the key or target value
+    int l=-1,r=a.length;
+    while(l+1<r) {
+       int m=(l+r)>>>1;
+       if(a[m]<=x) l=m;
+       else r=m;
+    }
+    return l+1;
+ }
+static class Graph
+  {
+        int v;
+        ArrayList<Integer> list[];
+        Graph(int v)
+        {
+            this.v=v;
+            list=new ArrayList[v+1];
+            for(int i=1;i<=v;i++)
+                list[i]=new ArrayList<Integer>();
+        }
+        void addEdge(int a, int b)
+        {
+            this.list[a].add(b);
+        }
+    }
+static void DFS(Graph g, boolean[] visited, int u)
+	{
+        visited[u]=true;
+        int v=0;
+        for(int i=0;i<g.list[u].size();i++)
+        {
+            v=g.list[u].get(i);
+            if(!visited[v])
+               DFS(g,visited,v);
+        }
+  } 
+  
+static class Pair
+   {
+      int x,y;
+      Pair(int x,int y)
+       {
+          this.x=x;
+          this.y=y;
+       }
+   }
+   
+static long sum_array(int a[])
+ {
+    int n=a.length;
+    long sum=0;
+    for(int i=0;i<n;i++)
+     sum+=a[i];
+    return sum;
+ }
+static long sum_array(long a[])
+ {
+    int n=a.length;
+    long sum=0;
+    for(int i=0;i<n;i++)
+     sum+=a[i];
+    return sum;
+ }
+
+ static void sort(int[] a) 
+   {
+		ArrayList<Integer> l=new ArrayList<>();
+		for (int i:a) l.add(i);
+		Collections.sort(l);
+		for (int i=0; i<a.length; i++) a[i]=l.get(i);
+	}
+static void sort(long[] a) 
+   {
+		ArrayList<Long> l=new ArrayList<>();
+		for (long i:a) l.add(i);
+		Collections.sort(l);
+		for (int i=0; i<a.length; i++) a[i]=l.get(i);
+	}
+
+static void reverse_array(int a[])
+ {
+    int n=a.length;
+    int i,t; 
+    for (i = 0; i < n / 2; i++) { 
+            t = a[i]; 
+            a[i] = a[n - i - 1]; 
+            a[n - i - 1] = t; 
+        } 
+ }
+static void reverse_array(long a[])
+ {
+    int n=a.length;
+    int i; long t; 
+    for (i = 0; i < n / 2; i++) { 
+            t = a[i]; 
+            a[i] = a[n - i - 1]; 
+            a[n - i - 1] = t; 
+        } 
+ }
+ 
+static long gcd(long a, long b) 
+    { 
+        if (a == 0) 
+            return b; 
+          
+        return gcd(b%a, a); 
+    } 
+static int gcd(int a, int b) 
+    { 
+        if (a == 0) 
+            return b; 
+          
+        return gcd(b%a, a); 
+    } 
+
+   static class FastReader{
+ 
+        byte[] buf = new byte[2048];
+        int index, total;
+        InputStream in;
+ 
+        FastReader(InputStream is) {
+            in = is;
+        }
+ 
+        int scan() throws IOException {
+            if (index >= total) {
+                index = 0;
+                total = in.read(buf);
+                if (total <= 0) {
+                    return -1;
+                }
+            }
+            return buf[index++];
+        }
+ 
+        String next() throws IOException {
+            int c;
+            for (c = scan(); c <= 32; c = scan());
+            StringBuilder sb = new StringBuilder();
+            for (; c > 32; c = scan()) {
+                sb.append((char) c);
+            }
+            return sb.toString();
+        }
+ 
+        int nextInt() throws IOException {
+            int c, val = 0;
+            for (c = scan(); c <= 32; c = scan());
+            boolean neg = c == '-';
+            if (c == '-' || c == '+') {
+                c = scan();
+            }
+            for (; c >= '0' && c <= '9'; c = scan()) {
+                val = (val << 3) + (val << 1) + (c & 15);
+            }
+            return neg ? -val : val;
+        }
+ 
+        long nextLong() throws IOException {
+            int c;
+            long val = 0;
+            for (c = scan(); c <= 32; c = scan());
+            boolean neg = c == '-';
+            if (c == '-' || c == '+') {
+                c = scan();
+            }
+            for (; c >= '0' && c <= '9'; c = scan()) {
+                val = (val << 3) + (val << 1) + (c & 15);
+            }
+            return neg ? -val : val;
+        }
+    }
+   
+    static class Reader 
+    { 
+        final private int BUFFER_SIZE = 1 << 16; 
+        private DataInputStream din; 
+        private byte[] buffer; 
+        private int bufferPointer, bytesRead; 
+  
+        public Reader() 
+        { 
+            din = new DataInputStream(System.in); 
+            buffer = new byte[BUFFER_SIZE]; 
+            bufferPointer = bytesRead = 0; 
+        } 
+  
+        public Reader(String file_name) throws IOException 
+        { 
+            din = new DataInputStream(new FileInputStream(file_name)); 
+            buffer = new byte[BUFFER_SIZE]; 
+            bufferPointer = bytesRead = 0; 
+        } 
+  
+        public String readLine() throws IOException 
+        { 
+            byte[] buf = new byte[64]; // line length 
+            int cnt = 0, c; 
+            while ((c = read()) != -1) 
+            { 
+                if (c == '\n') 
+                    break; 
+                buf[cnt++] = (byte) c; 
+            } 
+            return new String(buf, 0, cnt); 
+        } 
+  
+        public int nextInt() throws IOException 
+        { 
+            int ret = 0; 
+            byte c = read(); 
+            while (c <= ' ') 
+                c = read(); 
+            boolean neg = (c == '-'); 
+            if (neg) 
+                c = read(); 
+            do
+            { 
+                ret = ret * 10 + c - '0'; 
+            }  while ((c = read()) >= '0' && c <= '9'); 
+  
+            if (neg) 
+                return -ret; 
+            return ret; 
+        } 
+  
+        public long nextLong() throws IOException 
+        { 
+            long ret = 0; 
+            byte c = read(); 
+            while (c <= ' ') 
+                c = read(); 
+            boolean neg = (c == '-'); 
+            if (neg) 
+                c = read(); 
+            do { 
+                ret = ret * 10 + c - '0'; 
+            } 
+            while ((c = read()) >= '0' && c <= '9'); 
+            if (neg) 
+                return -ret; 
+            return ret; 
+        } 
+  
+        public double nextDouble() throws IOException 
+        { 
+            double ret = 0, div = 1; 
+            byte c = read(); 
+            while (c <= ' ') 
+                c = read(); 
+            boolean neg = (c == '-'); 
+            if (neg) 
+                c = read(); 
+  
+            do { 
+                ret = ret * 10 + c - '0'; 
+            } 
+            while ((c = read()) >= '0' && c <= '9'); 
+  
+            if (c == '.') 
+            { 
+                while ((c = read()) >= '0' && c <= '9') 
+                { 
+                    ret += (c - '0') / (div *= 10); 
+                } 
+            } 
+  
+            if (neg) 
+                return -ret; 
+            return ret; 
+        } 
+  
+        private void fillBuffer() throws IOException 
+        { 
+            bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE); 
+            if (bytesRead == -1) 
+                buffer[0] = -1; 
+        } 
+  
+        private byte read() throws IOException 
+        { 
+            if (bufferPointer == bytesRead) 
+                fillBuffer(); 
+            return buffer[bufferPointer++]; 
+        } 
+  
+        public void close() throws IOException 
+        { 
+            if (din == null) 
+                return; 
+            din.close(); 
+        } 
+    }
+  static  PrintWriter out=new PrintWriter(System.out);
+  static int int_max=Integer.MAX_VALUE;
+  static int int_min=Integer.MIN_VALUE;
+  static long long_max=Long.MAX_VALUE;
+  static long long_min=Long.MIN_VALUE;
+}
+// Thank You !",0
+55ab9b5d,c6113c06,"import java.io.*;
+import java.util.*;
+
+public class Main {
+
+    static int solve(char ch, char[][] str, int N) {
+        int[] a = new int[N];
+        for (int i = 0; i < N; i++) {
+            int c1 = 0, c2 = 0;
+            for (char x : str[i]) {
+                if (x == ch) c1++;
+                else c2++;
+            }
+            a[i] = c1 - c2;
+        }
+
+        int sum = 0, count = N;
+        for (int x : a) sum += x;
+
+        Arrays.sort(a);
+        for (int i = 0; i < N; i++) {
+            if (sum > 0) break;
+            count--;
+            sum -= a[i];
+        }
+        return count;
+    }
+
+    public static void main(String[] args) throws IOException {
+        // System.out.println(""===== input ====="");
+        // BufferedReader br = new BufferedReader(new FileReader(""input/input1.txt""));
+        // BufferedReader br2 = new BufferedReader(new FileReader(""input/input1.txt""));
+        // String s;
+        // while ((s = br2.readLine()) != null) {
+        //     System.out.println(s);
+        // }
+        // System.out.println(""===== output ====="");
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st = new StringTokenizer(br.readLine());
+        StringBuilder out = new StringBuilder();
+        int T = Integer.parseInt(st.nextToken());
+        while (T-- > 0) {
+            int n = Integer.parseInt(br.readLine().trim());
+            char[][] str = new char[n][];
+            for (int i = 0; i < n; i++) {
+                str[i] = br.readLine().trim().toCharArray();
+            }
+
+            int ans = 0;
+            for (char ch = 'a'; ch <= 'e'; ch++) {
+                ans = Math.max(ans, solve(ch, str, n));
+            }
+            out.append(ans).append(""\n"");
+        }
+        System.out.println(out);
+    }
+}
+","//created by Whiplash99
+import java.io.*;
+import java.util.*;
+public class D
+{
+    private static int solve(char ch, char[][] str, int N)
+    {
+        int[] a=new int[N];
+        for(int i=0;i<N;i++)
+        {
+            int c1=0, c2=0;
+            for(char x:str[i])
+            {
+                if(x==ch) c1++;
+                else c2++;
+            }
+            a[i]=c1-c2;
+        }
+
+        int sum=0, count=N;
+        for(int x:a) sum+=x;
+
+        Arrays.sort(a);
+        for(int i=0;i<N;i++)
+        {
+            if(sum>0) break;
+            count--; sum-=a[i];
+        }
+
+        return count;
+    }
+    public static void main(String[] args) throws Exception
+    {
+        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+
+        int i,N;
+
+        int T=Integer.parseInt(br.readLine().trim());
+        StringBuilder sb=new StringBuilder();
+
+        while (T-->0)
+        {
+            N=Integer.parseInt(br.readLine().trim());
+            char[][] str=new char[N][];
+
+            for(i=0;i<N;i++) str[i]=br.readLine().trim().toCharArray();
+
+            int ans=0;
+            for(char ch='a';ch<='e';ch++)
+            {
+                int tmp=solve(ch,str,N);
+                ans=Math.max(ans,tmp);
+            }
+            sb.append(ans).append(""\n"");
+        }
+        System.out.println(sb);
+    }
+}
+",1
+2c7a0000,bd50e3fe,"import java.io.*;
+import java.util.*;
+ 
+public class Codeforces {
+	public static void main(String[] args) throws IOException {
+		
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		//int cases = Integer.parseInt(br.readLine());
+		//while(cases-- > 0) {
+			int n = Integer.parseInt(br.readLine());
+			String[] str = br.readLine().split("" "");
+			int[] a = new int[n];
+			int k = 0;
+			ArrayList<Integer> pos = new ArrayList<>();
+			for(int i=0; i<n; i++) {
+				a[i] = Integer.parseInt(str[i]);
+				if(a[i] == 1) {
+					k++;
+					pos.add(i);
+				}
+			}
+			int[][] dp = new int[n+1][k+1];
+			for(int i=0; i<=n; i++) {
+				Arrays.fill(dp[i], Integer.MAX_VALUE);
+			}
+			dp[0][0] = 0;
+			for(int i=0; i<n; i++) {
+				for(int j=0; j<=k; j++) {
+					if(dp[i][j] == Integer.MAX_VALUE) {
+						continue;
+					}
+					dp[i+1][j] = Math.min(dp[i+1][j], dp[i][j]);
+					if(j < k && a[i] == 0) {
+						dp[i+1][j+1] = Math.min(dp[i+1][j+1], dp[i][j]+Math.abs(pos.get(j)-i));
+					}
+				}
+			}
+			System.out.println(dp[n][k]);
+		//}
+	}
+}
+","import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Scanner;
+
+public class Main
+{
+	public static void main(String[] args)
+	{
+		Scanner sc=new Scanner(System.in);
+		int n=sc.nextInt();
+		int[] a=new int[n];
+		for(int i=0;i<n;i++)
+			a[i]=sc.nextInt();
+		ArrayList<Integer> pos=new ArrayList<>(n);
+		for(int i=0;i<n;i++)
+			if(a[i]==1)
+				pos.add(i);
+		int k=pos.size();
+		int[][] dp=new int[n+1][k+1];
+		for(int i=0;i<n+1;i++)
+			Arrays.fill(dp[i], Integer.MAX_VALUE);
+		dp[0][0]=0;
+		for(int i=0;i<n;i++)
+			for(int j=0;j<=k;j++)
+			{
+				if(dp[i][j]==Integer.MAX_VALUE)
+					continue;
+				dp[i+1][j]=Math.min(dp[i+1][j], dp[i][j]);
+				if(j<k && a[i]==0)
+					dp[i+1][j+1]=Math.min(dp[i+1][j+1], dp[i][j]+Math.abs(pos.get(j)-i));
+			}
+		System.out.println(dp[n][k]);
+    }
+}",1
+ac2dfc53,c4187a0e,"import java.io.*;
+
+import java.util.*;
+/*
+
+
+
+
+*/
+
+ 
+ public class C{
+	static FastReader fs=null;
+	static Scanner sc=null;
+	
+	public static void main(String[] args) {
+		sc=new Scanner(System.in);
+		int t=sc.nextInt();
+		
+		for(int tt=0;tt<t;tt++) {
+			int n=sc.nextInt();
+			
+			boolean visited[]=new boolean[n+1];
+			int p[]=new int[n+1];
+			for(int i=1;i<=n;i++) {
+				if(visited[i])continue;
+				
+				while(true) {
+					int val=Query(i);
+					if(val==i)break;
+				}
+				
+				int cur=i;
+				while(!visited[cur]) {
+					int val=Query(i);
+					visited[cur]=true;
+					p[cur]=val;
+					cur=val;
+				}
+			}
+			
+			System.out.print(""! "");
+			for(int i=1;i<=n;i++)System.out.print(p[i]+"" "");
+			System.out.println();
+		}
+	}
+	static int Query(int id) {
+		System.out.println(""? ""+id);
+		int val=sc.nextInt();
+		return val;
+	}
+	
+	static int[] ruffleSort(int a[]) {
+		ArrayList<Integer> al=new ArrayList<>();
+		for(int i:a)al.add(i);
+		Collections.sort(al);
+		for(int i=0;i<a.length;i++)a[i]=al.get(i);
+		return a;
+	}
+	
+	static void print(int a[]) {
+		for(int e:a) {
+			System.out.print(e+"" "");
+		}
+		System.out.println();
+	}
+	
+	static class FastReader{
+		
+		StringTokenizer st=new StringTokenizer("""");
+		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+		
+		String next() {
+			while(!st.hasMoreTokens()) 
+				try {
+					st=new StringTokenizer(br.readLine());
+				}
+			   catch(IOException e){
+				   e.printStackTrace();
+			   }
+			return st.nextToken();
+		}
+		
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+		
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+		
+		int[] readArray(int n) {
+			int a[]=new int[n];
+			for(int i=0;i<n;i++)a[i]=sc.nextInt();
+			return a;
+		}
+	}
+	
+	
+}
+","import java.io.OutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.PrintWriter;
+import java.io.PrintStream;
+import java.io.BufferedWriter;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+import java.util.StringTokenizer;
+import java.io.Writer;
+import java.io.OutputStreamWriter;
+import java.io.BufferedReader;
+import java.io.InputStream;
+
+/**
+ * Built using CHelper plug-in
+ * Actual solution is at the top
+ */
+public class Main {
+    public static void main(String[] args) {
+        InputStream inputStream = System.in;
+        OutputStream outputStream = System.out;
+        InputReader in = new InputReader(inputStream);
+        OutputWriter out = new OutputWriter(outputStream);
+        CHiddenPermutations solver = new CHiddenPermutations();
+        int testCount = Integer.parseInt(in.next());
+        for (int i = 1; i <= testCount; i++)
+            solver.solve(i, in, out);
+        out.close();
+    }
+
+    static class CHiddenPermutations {
+        public void solve(int testNumber, InputReader in, OutputWriter out) {
+            int n = in.nextInt();
+            int[] arr = new int[n];
+            boolean[] vis = new boolean[n];
+            for (int i = 0; i < n; i++) {
+                if (vis[i]) continue;
+                ArrayList<Integer> cycle = new ArrayList<>();
+                int ans = query(i, in);
+                int now = query(i, in);
+                cycle.add(now);
+                while (now != ans) {
+                    now = query(i, in);
+                    cycle.add(now);
+                }
+                for (int j = 0; j < cycle.size(); j++) {
+                    arr[cycle.get(j)] = cycle.get((j + 1) % cycle.size()) + 1;
+                    vis[cycle.get(j)] = true;
+                }
+            }
+            out.print(""! "");
+            out.println(arr);
+            out.flush();
+        }
+
+        int query(int ind, InputReader in) {
+            System.out.println(""? "" + (ind + 1));
+            return in.nextInt() - 1;
+        }
+
+    }
+
+    static class InputReader {
+        BufferedReader reader;
+        StringTokenizer tokenizer;
+
+        public InputReader(InputStream stream) {
+            reader = new BufferedReader(new InputStreamReader(stream), 32768);
+            tokenizer = null;
+        }
+
+        public String next() {
+            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
+                try {
+                    tokenizer = new StringTokenizer(reader.readLine());
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+            }
+            return tokenizer.nextToken();
+        }
+
+        public int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+    }
+
+    static class OutputWriter {
+        private final PrintWriter writer;
+
+        public OutputWriter(OutputStream outputStream) {
+            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
+        }
+
+        public OutputWriter(Writer writer) {
+            this.writer = new PrintWriter(writer);
+        }
+
+        public void print(Object... objects) {
+            for (int i = 0; i < objects.length; i++) {
+                if (i != 0) {
+                    writer.print(' ');
+                }
+                writer.print(objects[i]);
+            }
+        }
+
+        public void print(int[] array) {
+            for (int i = 0; i < array.length; i++) {
+                if (i != 0) {
+                    writer.print(' ');
+                }
+                writer.print(array[i]);
+            }
+        }
+
+        public void println(int[] array) {
+            print(array);
+            writer.println();
+        }
+
+        public void close() {
+            writer.close();
+        }
+
+        public void flush() {
+            writer.flush();
+        }
+
+    }
+}
+
+",0
+25597bcb,86232d21,"import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.StringTokenizer;
+import java.util.TreeSet;
+
+public class PhoenixAndTowers { // Template for CF
+    public static class ListComparator implements Comparator<List<Integer>> {
+
+        @Override
+        public int compare(List<Integer> l1, List<Integer> l2) {
+            for (int i = 0; i < l1.size(); ++i) {
+                if (l1.get(i).compareTo(l2.get(i)) != 0) {
+                    return l1.get(i).compareTo(l2.get(i));
+                }
+            }
+            return 0;
+        }
+    }
+
+    public static class Pair {
+        int first;
+        int second;
+
+        public Pair(int first, int second) {
+            this.first = first;
+            this.second = second;
+        }
+
+        public int getFirst() {
+            return first;
+        }
+
+        public int getSecond() {
+            return second;
+        }
+
+        public void setFirst(int a) {
+            first = a;
+        }
+
+        @Override
+        public String toString() {
+            return first + "" "" + second;
+        }
+    }
+
+    public static void main(String[] args) throws IOException {
+        // Check for int overflow!!!!
+        // Should you use a long to store the sum or smthn?
+        BufferedReader f = new BufferedReader(new InputStreamReader(System.in));
+        PrintWriter out = new PrintWriter(System.out);
+
+        int T = Integer.parseInt(f.readLine());
+        for (int i = 0; i < T; i++) {
+            StringTokenizer st = new StringTokenizer(f.readLine());
+            int n = Integer.parseInt(st.nextToken());
+            int m = Integer.parseInt(st.nextToken());
+            int x = Integer.parseInt(st.nextToken());
+            st = new StringTokenizer(f.readLine());
+            List<Integer> list = new ArrayList<>();
+            for (int j = 0; j < n; j++) {
+                int a = Integer.parseInt(st.nextToken());
+                list.add(a);
+            }
+            ArrayList<Integer> copy = new ArrayList<>(list);
+            Collections.sort(list);
+            TreeSet<List<Integer>> set = new TreeSet<>(new ListComparator());
+            for (int j = 1; j <= m; j++) {
+                List<Integer> temp = new ArrayList<>();
+                temp.add(0);
+                temp.add(j);
+
+                set.add(temp);
+                // System.out.println(temp);
+            }
+            // System.out.println(set);
+            Map<Integer, LinkedList<Integer>> map = new HashMap<>();
+            for (int j = n - 1; j >= 0; j--) {
+                if (map.containsKey(list.get(j))) {
+                    map.get(list.get(j)).addLast(set.first().get(1));
+                } else {
+                    map.put(list.get(j), new LinkedList<>());
+                    map.get(list.get(j)).addLast(set.first().get(1));
+                }
+                List<Integer> temp = new ArrayList<>();
+                temp.add(set.first().get(0) + list.get(j));
+                temp.add(set.pollFirst().get(1));
+                set.add(temp);
+            }
+            // System.out.println(set);
+
+            if (set.last().get(0) - set.first().get(0) > x) {
+                out.println(""NO"");
+            } else {
+                out.println(""YES"");
+                for (int j = 0; j < n; j++) {
+                    out.print(map.get(copy.get(j)).pollFirst() + "" "");
+                }
+                out.println();
+            }
+        }
+        out.close();
+    }
+
+}","import static java.lang.Integer.parseInt;
+import static java.lang.Long.parseLong;
+import static java.lang.System.exit;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.util.PriorityQueue;
+import java.util.StringTokenizer;
+
+public class C {
+
+	static class Token implements Comparable<Token> {
+		final int i, h;
+
+		Token(int i, int h) {
+			this.i = i;
+			this.h = h;
+		}
+
+		public int compareTo(Token o) {
+			return h - o.h;
+		}
+	}
+
+	static void solve() throws Exception {
+		int tests = scanInt();
+		for (int test = 0; test < tests; test++) {
+			int n = scanInt(), m = scanInt();
+			scanInt();
+			PriorityQueue<Token> pq = new PriorityQueue<>();
+			int h[] = new int[m];
+			int ans[] = new int[n];
+			for (int i = 0; i < m; i++) {
+				pq.add(new Token(i, 0));
+			}
+			for (int i = 0; i < n; i++) {
+				Token cur = pq.remove();
+				pq.add(new Token(cur.i, h[cur.i] += scanInt()));
+				ans[i] = cur.i;
+			}
+			out.println(""YES"");
+			for (int i = 0; i < n; i++) {
+				out.print((ans[i] + 1) + "" "");
+			}
+			out.println();
+		}
+	}
+
+	static int scanInt() throws IOException {
+		return parseInt(scanString());
+	}
+
+	static long scanLong() throws IOException {
+		return parseLong(scanString());
+	}
+
+	static String scanString() throws IOException {
+		while (tok == null || !tok.hasMoreTokens()) {
+			tok = new StringTokenizer(in.readLine());
+		}
+		return tok.nextToken();
+	}
+
+	static BufferedReader in;
+	static PrintWriter out;
+	static StringTokenizer tok;
+
+	public static void main(String[] args) {
+		try {
+			in = new BufferedReader(new InputStreamReader(System.in));
+			out = new PrintWriter(System.out);
+			solve();
+			in.close();
+			out.close();
+		} catch (Throwable e) {
+			e.printStackTrace();
+			exit(1);
+		}
+	}
+}",0
+086f0f90,4a570de6,"import java.io.*;
+import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
+
+public class Main {
+    public static void main(String[] args) {
+        FastScanner sc = new FastScanner();
+        int t=sc.nextInt();
+        while (t-->=1) {
+            int n = sc.nextInt(),m=sc.nextInt(), x = sc.nextInt();
+            int a[] = sc.readArray(n);
+            PriorityQueue<Pair> pq=new PriorityQueue<>();
+            for (int i=0;i<m;i++){
+                pq.add(new Pair(0,i+1));
+            }
+            int ans[]= new int[n];
+
+            System.out.println(""YES"");
+            for (int i=0;i<n;i++){
+                Pair e=pq.peek();
+                pq.remove(e);
+                e.a+=a[i];
+                pq.add(e);
+                ans[i]=e.b;
+//                System.out.print((e.b)%m+1+"" "");
+            }
+            printArray(ans);
+            System.out.println();
+
+
+        }
+    }
+
+
+
+//        out.flush();
+
+
+
+    //------------------------------------if-------------------------------------------------------------------------------------------------------------------------------------------------
+    //sieve
+    static void primeSieve(int a[]){
+        //mark all odd number as prime
+        for (int i=3;i<a.length;i+=2){
+            a[i]=1;
+        }
+        for (long i=3;i<a.length;i+=2){
+            //if the number is marked then it is prime
+            if (a[(int) i]==1){
+                //mark all muliple of the number as not prime
+                for (long j=i*i;j<a.length;j+=i){
+                    a[(int)j]=0;
+                }
+            }
+        }
+        a[2]=1;
+        a[1]=a[0]=0;
+    }
+    static void sort(int[] a) {
+        ArrayList<Integer> l = new ArrayList<>();
+        for (int i : a) l.add(i);
+        Collections.sort(l);
+        for (int i = 0; i < a.length; i++) a[i] = l.get(i);
+    }
+    static String sortString(String s) {
+        char temp[] = s.toCharArray();
+        Arrays.sort(temp);
+        return new String(temp);
+    }
+    static class Pair implements Comparable<Pair> {
+        int a;
+        int b;
+
+        public Pair(int a, int b) {
+            this.a = a;
+            this.b = b;
+        }
+        //        to sort first part
+//        public int compareTo(Pair other) {
+//            if (this.a == other.a) return other.b > this.b ? -1 : 1;
+//            else if (this.a > other.a) return 1;
+//            else return -1;
+//        }
+//        public int compareTo(Pair other) {
+//            if (this.b == other.b) return 0;
+//            if (this.b < other.b) return 1;
+//            else return -1;
+//        }
+        //sort on the basis of first part only
+        public int compareTo(Pair other) {
+            if (this.a == other.a) return 0;
+            else if (this.a > other.a) return 1;
+            else return -1;
+        }
+
+    }
+    static int[] frequency(String s){
+        int fre[]= new int[26];
+        for (int i=0;i<s.length();i++){
+            fre[s.charAt(i)-'a']++;
+        }
+        return fre;
+    }
+    static long LOWERBOUND(long a[],long k){
+        int s=0,e=a.length-1;
+        long ans=-1;
+        while (s<=e){
+            int mid=(s+e)/2;
+            if (a[mid]<=k){
+                ans=mid;
+                s=mid+1;
+            }
+            else {
+                e=mid-1;
+            }
+        }
+        return ans;
+    }
+    static int mod =(int)(1e9+7);
+    static long mod(long x) {
+        return ((x % mod + mod) % mod);
+    }
+    static long add(long x, long y) {
+        return mod(mod(x) + mod(y));
+    }
+    static long mul(long x, long y) {
+        return mod(mod(x) * mod(y));
+    }
+    //Fast Power(logN)
+    static int fastPower(long a,long n){
+        int ans=1;
+        while (n>0){
+            long lastBit=n&1;
+            if (lastBit==1){
+                ans=(int)mul(ans,a);
+            }
+
+            a=(int)mul(a,a);
+            n>>=1;
+        }
+        return ans;
+    }
+    static int[] find(int n, int start, int diff) {
+        int a[] = new int[n];
+        a[0] = start;
+        for (int i = 1; i < n; i++) a[i] = a[i - 1] + diff;
+        return a;
+    }
+    static void swap(int a, int b) {
+        int c = a;
+        a = b;
+        b = c;
+    }
+    static void printArray(int a[]) {
+        for (int i = 0; i < a.length; i++) {
+            System.out.print(a[i] + "" "");
+        }
+    }
+    static boolean sorted(int a[]) {
+        int n = a.length;
+        boolean flag = true;
+        for (int i = 0; i < n - 1; i++) {
+            if (a[i] > a[i + 1]) flag = false;
+        }
+        if (flag) return true;
+        else return false;
+    }
+    public static int findlog(long n) {
+        if (n == 0)
+            return 0;
+
+        if (n == 1)
+            return 0;
+        if (n == 2)
+            return 1;
+        double num = Math.log(n);
+        double den = Math.log(2);
+        if (den == 0)
+            return 0;
+        return (int) (num / den);
+    }
+    public static long gcd(long a, long b) {
+        if (b % a == 0)
+            return a;
+        return gcd(b % a, a);
+    }
+    public static int gcdInt(int a, int b) {
+
+        if (b % a == 0)
+            return a;
+
+        return gcdInt(b % a, a);
+
+    }
+    static void sortReverse(int[] a) {
+        ArrayList<Integer> l = new ArrayList<>();
+        for (int i : a) l.add(i);
+        //        Collections.sort.(l);
+        Collections.sort(l, Collections.reverseOrder());
+        for (int i = 0; i < a.length; i++) a[i] = l.get(i);
+    }
+    static class FastScanner {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st = new StringTokenizer("""");
+
+        String next() {
+            while (!st.hasMoreTokens())
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        int[] readArray(int n) {
+            int[] a = new int[n];
+            for (int i = 0; i < n; i++) a[i] = nextInt();
+            return a;
+        }
+
+        long[] readArrayLong(long n) {
+            long[] a = new long[(int) n];
+            for (int i = 0; i < n; i++) a[i] = nextLong();
+            return a;
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+    }
+}","import java.io.*;
+import java.lang.*;
+import java.util.*;
+public class c
+{
+static class FastScanner {
+InputStreamReader is;
+BufferedReader br;
+StringTokenizer st;
+public FastScanner() {
+is = new InputStreamReader(System.in);
+br = new BufferedReader(is);
+}
+String next() throws Exception {
+while (st == null || !st.hasMoreElements())
+st = new StringTokenizer(br.readLine());
+return st.nextToken();
+}
+int ni() throws Exception {
+return Integer.parseInt(next());
+}
+long nextLong() throws Exception {
+return Long.parseLong(next());
+}
+int[] readArray(int num) throws Exception {
+int arr[]=new int[num];
+for(int i=0;i<num;i++)
+arr[i]=ni();
+return arr;
+}
+String nextLine() throws Exception {
+return br.readLine();
+}
+}
+ public static boolean power_of_two(int a)
+{
+  if((a&(a-1))==0)
+{
+ return true;
+}
+return false;
+}
+static boolean PS(double x)
+{
+if (x >= 0) {
+double i= Math.sqrt(x);
+if(i%1!=0)
+{
+return false;
+}
+return ((i * i) == x);
+}
+return false;
+}
+public static int[] ia(int n)
+{
+    int ar[]=new int[n];
+    return ar;
+}
+public static long[] la(int n)
+{
+    long ar[]=new long[n];
+    return ar;
+}
+
+static class pair implements Comparable<pair>{
+    int ht;
+    int id;
+    pair(int ht, int id)
+{
+    this.ht=ht;
+    this.id=id;
+}
+public int compareTo(pair p)
+{
+    return this.ht-p.ht;
+}
+}
+public static void main(String args[]) throws java.lang.Exception
+{
+FastScanner sc=new FastScanner();
+ int t=sc.ni();
+while(t-->0)
+{
+    int n=sc.ni();
+    int m=sc.ni();
+    int x=sc.ni();
+    int ar[]=ia(n);
+for(int i=0;i<n;i++)
+{
+ar[i]=sc.ni();
+}
+System.out.println(""YES"");
+PriorityQueue<pair> pq=new PriorityQueue<>();
+ for(int i=0;i<m;i++)
+ {
+pq.add(new pair(0,i+1));
+ }                     
+ int i=0;
+ while(i<n)
+ {
+     pair pp=pq.remove();
+pp.ht+=ar[i];
+System.out.print(pp.id+"" "");
+pq.add(pp);
+i++;
+ }   
+System.out.println();
+}
+}
+}",0
+1162c08f,eea69e7f,"import java.util.*;
+
+public class CodeForces1525C{
+	public static void main(String[] args) {
+		Scanner sc=new Scanner(System.in);
+		ArrayList<Integer> o=new ArrayList<Integer>(), e=new ArrayList<Integer>();
+		int n = sc.nextInt(),dp[][]=new int[n+1][n+1];
+		for(int i=1;i<=n;i++){
+			int x=sc.nextInt();
+			if(x==1)o.add(i);
+			else e.add(i);
+		}
+		for(int i=1;i<=o.size();i++){
+			dp[i][i]=dp[i-1][i-1]+Math.abs(o.get(i-1)-e.get(i-1));
+			for(int j=i+1;j<=e.size();j++)
+				dp[i][j]=Math.min(dp[i][j-1],dp[i-1][j-1]+Math.abs(o.get(i-1)-e.get(j-1)));
+		}
+		System.out.println(dp[o.size()][e.size()]);
+	}
+}
+
+","import java.util.*;
+
+public class Solution {
+	
+	public static int minMoves(int[] input) {
+		List<Integer> people = new ArrayList<Integer>();
+		List<Integer> chairs = new ArrayList<Integer>();
+		
+		for (int i = 0; i < input.length; i++) {
+			if (input[i] == 1) {
+				people.add(i);
+			} else {
+				chairs.add(i);
+			}
+		}
+		
+		int[] memo = new int[chairs.size() + 1];
+		
+
+		for (int p = 1; ((!people.isEmpty()) && (p <= people.size())); p++) {
+			int prev = memo[p];
+			memo[p] = memo[p - 1] + Math.abs(people.get(p - 1) - chairs.get(p - 1));
+			for (int c = p + 1; c <= chairs.size(); c++) {
+				int tmp = memo[c];
+				memo[c] = Math.min(memo[c - 1], prev + Math.abs(people.get(p - 1) - chairs.get(c - 1)));
+				prev = tmp;
+			}
+		}
+		return memo[memo.length - 1];
+	}
+	
+	
+	public static void main(String[] args) {
+		Scanner sc = new Scanner(System.in);
+		int n = sc.nextInt();
+		int[] input = new int[n];
+		for (int i = 0; i < n; i++) {
+			input[i] = sc.nextInt();
+		}
+		
+		System.out.println(Solution.minMoves(input));
+		
+	}
+}",0
+55ab9b5d,ae4d5b49,"import java.io.*;
+import java.util.*;
+
+public class Main {
+
+    static int solve(char ch, char[][] str, int N) {
+        int[] a = new int[N];
+        for (int i = 0; i < N; i++) {
+            int c1 = 0, c2 = 0;
+            for (char x : str[i]) {
+                if (x == ch) c1++;
+                else c2++;
+            }
+            a[i] = c1 - c2;
+        }
+
+        int sum = 0, count = N;
+        for (int x : a) sum += x;
+
+        Arrays.sort(a);
+        for (int i = 0; i < N; i++) {
+            if (sum > 0) break;
+            count--;
+            sum -= a[i];
+        }
+        return count;
+    }
+
+    public static void main(String[] args) throws IOException {
+        // System.out.println(""===== input ====="");
+        // BufferedReader br = new BufferedReader(new FileReader(""input/input1.txt""));
+        // BufferedReader br2 = new BufferedReader(new FileReader(""input/input1.txt""));
+        // String s;
+        // while ((s = br2.readLine()) != null) {
+        //     System.out.println(s);
+        // }
+        // System.out.println(""===== output ====="");
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st = new StringTokenizer(br.readLine());
+        StringBuilder out = new StringBuilder();
+        int T = Integer.parseInt(st.nextToken());
+        while (T-- > 0) {
+            int n = Integer.parseInt(br.readLine().trim());
+            char[][] str = new char[n][];
+            for (int i = 0; i < n; i++) {
+                str[i] = br.readLine().trim().toCharArray();
+            }
+
+            int ans = 0;
+            for (char ch = 'a'; ch <= 'e'; ch++) {
+                ans = Math.max(ans, solve(ch, str, n));
+            }
+            out.append(ans).append(""\n"");
+        }
+        System.out.println(out);
+    }
+}
+","import java.io.*;
+import java.util.*;
+
+public class Main {
+    public static void main(String[] args) throws IOException{
+        //BufferedReader f = new BufferedReader(new FileReader(""uva.in""));
+        BufferedReader f = new BufferedReader(new InputStreamReader(System.in));
+        PrintWriter out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
+        int t = Integer.parseInt(f.readLine());
+        while(t-- > 0) {
+            int n = Integer.parseInt(f.readLine());
+            int[][] occ = new int[n][6];
+            for(int i = 0; i < n; i++) {
+                char[] temp = f.readLine().toCharArray();
+                for(char j: temp) {
+                    occ[i][j-'a']++;
+                }
+                occ[i][5] = occ[i][0]+occ[i][1]+occ[i][2]+occ[i][3]+occ[i][4];
+            }
+            int max = 0;
+            for(int i = 0; i < 5; i++) {
+                int[] temp = new int[n];
+                for(int j = 0; j < n; j++) {
+                    temp[j] = occ[j][i]-(occ[j][5]-occ[j][i]);
+                }
+                Arrays.sort(temp);
+                int j;
+                int cur = 0;
+                for(j = n-1; j >= 0; j--) {
+                    if(cur+temp[j] <= 0) {
+                        break;
+                    }
+                    cur += temp[j];
+                }
+                max = Math.max(max, n-j-1);
+            }
+            out.println(max);
+        }
+        f.close();
+        out.close();
+    }
+}",0
+3e1442a3,d0e27497,"import java.util.*;
+public class Main {
+	public static void main(String[] args){
+		Scanner sc = new Scanner(System.in);
+
+		// long mod = 1_000_000_007L;
+		// long mod = 998_244_353L;
+
+		int t = sc.nextInt();
+
+		for ( int zzz=0; zzz<t; zzz++ ) {
+
+			int n = sc.nextInt();
+
+			HashMap<Integer, HashSet<Integer>> adj = new HashMap<>();
+			HashMap<HashSet<Integer>, Integer> inv = new HashMap<>();
+			boolean f = false;
+			for ( int i=0; i<n-1; i++ ) {
+				int u = sc.nextInt();
+				int v = sc.nextInt();
+				if ( adj.containsKey(u) ) {
+					HashSet<Integer> s = adj.get(u);
+					if ( s.size()>1 ) f = true;
+					s.add(v);
+					adj.put(u, s);
+				} else {
+					HashSet<Integer> s = new HashSet<>();
+					s.add(v);
+					adj.put(u, s);
+				}
+				if ( adj.containsKey(v) ) {
+					HashSet<Integer> s = adj.get(v);
+					if ( s.size()>1 ) f = true;
+					s.add(u);
+					adj.put(v, s);
+				} else {
+					HashSet<Integer> s = new HashSet<>();
+					s.add(u);
+					adj.put(v, s);
+				}
+
+				HashSet<Integer> si = new HashSet<>();
+				si.add(u);
+				si.add(v);
+				inv.put(si, i);
+			}
+
+			if ( f ) {
+				System.out.println(-1);
+				continue;
+			}
+
+			String[] ans = new String[n-1];
+			boolean g = false;
+			ArrayDeque<Integer> q = new ArrayDeque<>();
+			q.addLast(1);
+			boolean[] seen = new boolean[n+1];
+			while ( q.size()>0 ) {
+				int v = q.removeLast();
+				seen[v] = true;
+
+				HashSet<Integer> s = adj.get(v);
+				for ( int e : s ) {
+					if ( seen[e] ) continue;
+
+					HashSet<Integer> st = new HashSet<>();
+					st.add(v);
+					st.add(e);
+					int pos = inv.get(st);
+					if ( g ) {
+						ans[pos] = ""3"";
+					} else {
+						ans[pos] = ""2"";
+					}
+					g = !g;
+					q.addLast(e);
+					break;
+				}
+			}
+
+			g = true;
+			q.addLast(1);
+			while ( q.size()>0 ) {
+				int v = q.removeLast();
+				seen[v] = true;
+
+				HashSet<Integer> s = adj.get(v);
+				for ( int e : s ) {
+					if ( seen[e] ) continue;
+
+					HashSet<Integer> st = new HashSet<>();
+					st.add(v);
+					st.add(e);
+					int pos = inv.get(st);
+					if ( g ) {
+						ans[pos] = ""3"";
+					} else {
+						ans[pos] = ""2"";
+					}
+					g = !g;
+					q.addLast(e);
+					break;
+				}
+			}
+
+			System.out.println(String.join("" "", ans));
+		}
+	}
+}
+","import java.util.*;
+import java.io.*;
+
+public class Main {
+    static FastScanner sc = new FastScanner(System.in);
+    static PrintWriter pw = new PrintWriter(System.out);
+    static StringBuilder sb = new StringBuilder();
+    static long mod = (long) 1e9 + 7;
+
+    public static void main(String[] args) throws Exception {
+        int t = sc.nextInt();
+        for(int i = 0; i < t; i++) solve();
+        pw.flush();
+    }
+    
+    static ArrayList<ArrayList<int[]>> map;
+    static int[] ans;
+    public static void solve() {
+        sb.setLength(0);
+        int n = sc.nextInt();
+        ans = new int[n-1];
+        map = new ArrayList<>();
+        for(int i = 0; i < n; i++){
+            map.add(new ArrayList<>());
+        }
+        int[] cnt = new int[n];
+        for(int i = 0; i < n-1; i++){
+            int[] e = sc.nextIntArray(2);
+            e[0]--;
+            e[1]--;
+            cnt[e[0]]++;
+            cnt[e[1]]++;
+            //edge.add(e);
+            map.get(e[0]).add(new int[]{e[1],i});
+            map.get(e[1]).add(new int[]{e[0],i});
+        }
+        for(int i = 0; i < n; i++){
+            if(cnt[i] > 2){
+                pw.println(-1);
+                return;
+            }
+        }
+        
+        for(int i = 0; i < n; i++){
+            if(cnt[i] == 1){
+                ArrayDeque<int[]> dq = new ArrayDeque<>();
+                boolean[] used = new boolean[n];
+                used[i] = true;
+                dq.add(new int[]{i,0});
+                while(dq.size() > 0){
+                    int[] now = dq.poll();
+                    int u = now[0];
+                    int c = now[1];
+                    //System.err.println(u + "" "" + c + "" ""+ map.get(u).size());
+                    for(int[] next : map.get(u)){
+                        int v = next[0];
+                        int ei = next[1];
+                        //System.err.println(u + "" "" + v + "" "" + c + "" "" + ei);
+                        if(!used[v]){
+                            used[v] = true;
+                            //System.err.println(u + "" "" + v + "" "" + c);
+                            ans[ei] = c % 2 == 0 ? 3 : 2;
+                            dq.add(new int[]{v,c+1});
+                        }
+                    }
+                }
+                for(int v : ans){
+                    if(v == 0){
+                        pw.println(-1);
+                        return;
+                    }
+                    sb.append(v).append("" "");
+                }
+                pw.println(sb.toString().trim());
+                return;
+            }
+        }
+        pw.println(-1);
+    }
+
+    static class GeekInteger {
+        public static void save_sort(int[] array) {
+            shuffle(array);
+            Arrays.sort(array);
+        }
+
+        public static int[] shuffle(int[] array) {
+            int n = array.length;
+            Random random = new Random();
+            for (int i = 0, j; i < n; i++) {
+                j = i + random.nextInt(n - i);
+                int randomElement = array[j];
+                array[j] = array[i];
+                array[i] = randomElement;
+            }
+            return array;
+        }
+
+        public static void save_sort(long[] array) {
+            shuffle(array);
+            Arrays.sort(array);
+        }
+
+        public static long[] shuffle(long[] array) {
+            int n = array.length;
+            Random random = new Random();
+            for (int i = 0, j; i < n; i++) {
+                j = i + random.nextInt(n - i);
+                long randomElement = array[j];
+                array[j] = array[i];
+                array[i] = randomElement;
+            }
+            return array;
+        }
+
+    }
+}
+
+class FastScanner {
+    private BufferedReader reader = null;
+    private StringTokenizer tokenizer = null;
+
+    public FastScanner(InputStream in) {
+        reader = new BufferedReader(new InputStreamReader(in));
+        tokenizer = null;
+    }
+
+    public FastScanner(FileReader in) {
+        reader = new BufferedReader(in);
+        tokenizer = null;
+    }
+
+    public String next() {
+        if (tokenizer == null || !tokenizer.hasMoreTokens()) {
+            try {
+                tokenizer = new StringTokenizer(reader.readLine());
+            } catch (IOException e) {
+                throw new RuntimeException(e);
+            }
+        }
+        return tokenizer.nextToken();
+    }
+
+    public String nextLine() {
+        if (tokenizer == null || !tokenizer.hasMoreTokens()) {
+            try {
+                return reader.readLine();
+            } catch (IOException e) {
+                throw new RuntimeException(e);
+            }
+        }
+        return tokenizer.nextToken(""\n"");
+    }
+
+    public long nextLong() {
+        return Long.parseLong(next());
+    }
+
+    public int nextInt() {
+        return Integer.parseInt(next());
+    }
+
+    public double nextDouble() {
+        return Double.parseDouble(next());
+    }
+
+    public String[] nextArray(int n) {
+        String[] a = new String[n];
+        for (int i = 0; i < n; i++)
+            a[i] = next();
+        return a;
+    }
+
+    public int[] nextIntArray(int n) {
+        int[] a = new int[n];
+        for (int i = 0; i < n; i++)
+            a[i] = nextInt();
+        return a;
+    }
+
+    public long[] nextLongArray(int n) {
+        long[] a = new long[n];
+        for (int i = 0; i < n; i++)
+            a[i] = nextLong();
+        return a;
+    }
+}
+",0
+83b44c9c,e431de28,"import java.util.Scanner;
+
+public class MinimumGridPath {
+    public static void main(String[] args) {
+        Scanner scanner = new Scanner(System.in);
+        int test = scanner.nextInt();
+
+        StringBuilder sb = new StringBuilder();
+        for (int t = 0; t < test; t++) {
+            int n = scanner.nextInt();
+            long[] arr = new long[n];
+            for (int i = 0; i < n; i++) {
+                arr[i] = scanner.nextLong();
+            }
+
+            long minx = arr[0];
+            long miny = arr[1];
+
+            long min = minx * n + miny * n;
+            long sumx = arr[0];
+            long sumy = arr[1];
+
+            for(int i=2; i<n; i++) {
+                int xc;
+                int yc;
+                if(i%2 == 0) {
+                    xc = i/2 + 1;
+                    yc = i/2;
+                    sumx += arr[i];
+                    minx = Math.min(minx, arr[i]);
+                } else {
+                    xc = i/2 + 1;
+                    yc = i/2 + 1;
+                    sumy += arr[i];
+                    miny = Math.min(miny, arr[i]);
+                }
+                min = Math.min(min, sumx + (n-xc) * minx + sumy + (n-yc) * miny);
+            }
+
+
+            sb.append(min).append(System.lineSeparator());
+        }
+        System.out.println(sb);
+
+    }
+}
+
+/*
+// yehara
+import java.io.PrintWriter;
+import java.util.*;
+
+public class C {
+
+    static Scanner sc;
+    static PrintWriter out;
+
+    public static void main(String[] args) throws Exception {
+        sc = new Scanner(System.in);
+        out = new PrintWriter(System.out);
+        int t = sc.nextInt();
+        for(int i=0; i<t; i++) {
+            solve();
+        }
+        out.flush();
+    }
+
+    static void solve() {
+        int n = sc.nextInt();
+        int[] c = new int[n];
+        for(int i=0; i<n; i++) {
+            c[i] = Integer.parseInt(sc.next());
+        }
+        long minx = c[0];
+        long miny = c[1];
+
+        long min = minx * n + miny * n;
+        long sumx = c[0];
+        long sumy = c[1];
+
+        for(int i=2; i<n; i++) {
+            int xc;
+            int yc;
+            if(i%2 == 0) {
+                xc = i/2 + 1;
+                yc = i/2;
+                sumx += c[i];
+                minx = Math.min(minx, c[i]);
+            } else {
+                xc = i/2 + 1;
+                yc = i/2 + 1;
+                sumy += c[i];
+                miny = Math.min(miny, c[i]);
+            }
+            min = Math.min(min, sumx + (n-xc) * minx + sumy + (n-yc) * miny);
+        }
+
+        out.println(min);
+
+    }
+
+}
+
+ */
+","import java.io.*;
+import java.lang.*;
+import java.util.*;
+public class MinGridPath {
+
+	public static void main(String[] args) {
+		// TODO Auto-generated method stub
+		Scanner s=new Scanner(System.in);
+		int t=s.nextInt();
+		while(t-->0){
+			
+			int n = s.nextInt();
+			long[] aa =new long[n];
+			for(int i=0;i<n;i++)
+				aa[i]=s.nextLong();
+ 
+			long minEven = aa[0];
+			long minOdd = aa[1];
+			long sum = aa[0]+aa[1];
+			long best = n*minEven + n*minOdd;
+			int numOdd = 1;
+			int numEven = 1;
+			for(int i=2; i<n; ++i) {
+				if(i%2 == 0) {
+					minEven = Math.min(aa[i], minEven);
+					numEven++;
+				}else {
+					minOdd = Math.min(aa[i], minOdd);
+					numOdd++;
+				}
+				sum += aa[i];
+				long score = sum;
+				score += minEven*(n-numEven);
+				score += minOdd*(n-numOdd);				
+				best = Math.min(best, score);
+			}
+			System.out.println(best);
+			
+		}
+	}
+
+}
+",0
+3d06b643,cb87df79,"import java.io.*;
+import java.util.*;
+
+public class ArmChairs {
+    
+
+    public static int solution(int n, int[] arr) {
+
+        ArrayList<Integer> one = new ArrayList<Integer>();
+        ArrayList<Integer> zero = new ArrayList<Integer>();
+
+        for (int i = 0; i < n; i++) {
+            if (arr[i] == 1) {
+                one.add(i);
+            } else {
+                zero.add(i);
+            }
+        }
+
+        int[][] dp = new int[one.size() + 1][zero.size() + 1];
+
+        for (int i = 1; i <= one.size(); i++) {
+            dp[i][i] = dp[i - 1][i - 1] + Math.abs(one.get(i - 1) - zero.get(i - 1));
+            for (int j = i + 1; j <= zero.size(); j++) {
+                dp[i][j] = Math.min(dp[i][j - 1], dp[i - 1][j - 1] + Math.abs(one.get(i - 1) - zero.get(j - 1)));
+            }
+        }
+
+        return dp[one.size()][zero.size()];
+    }
+
+
+    public static void main(String[] args) throws IOException{
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        BufferedWriter log = new BufferedWriter(new OutputStreamWriter(System.out));
+
+        int n = Integer.parseInt(br.readLine());
+
+        String[] s = br.readLine().split("" "");
+        int[] arr = new int[n];
+        for (int i = 0; i < n; i++) {
+            arr[i] = Integer.parseInt(s[i]);
+        } 
+
+        log.write(Integer.toString(solution(n, arr)) + ""\n"");
+        log.flush();
+        
+    }
+
+}
+","import java.util.*;
+
+public class Longjumps {
+	 public static void main(String[] args){
+		 Scanner sc=new Scanner(System.in);
+			ArrayList<Integer> o=new ArrayList<Integer>(), e=new ArrayList<Integer>();
+			int n = sc.nextInt();
+			for(int i=1;i<=n;i++){
+				int x=sc.nextInt();
+				if(x==1)o.add(i);
+				else e.add(i);
+			}
+			int dp[][]=new int[o.size()+1][e.size()+1];
+			for(int i=1;i<=o.size();i++){
+				dp[i][i]=dp[i-1][i-1]+Math.abs(o.get(i-1)-e.get(i-1));
+				for(int j=i+1;j<=e.size();j++)
+					dp[i][j]=Math.min(dp[i][j-1],dp[i-1][j-1]+Math.abs(o.get(i-1)-e.get(j-1)));
+			}
+			System.out.println(dp[o.size()][e.size()]);
+	 }
+}",1
+034030f3,9e4ddc38,"import java.util.*;
+import java.io.*;
+
+public class D_1525 {
+	
+	static int INF = (int)1e9;
+	static int n, m;
+	static int[] full, free;
+	static int[][] memo;
+	
+	public static int dp(int i, int j) {
+		if(i == n)
+			return 0;
+		if(j == m)
+			return INF;
+		
+		if(memo[i][j] != -1)
+			return memo[i][j];
+		
+		return memo[i][j] = Math.min(dp(i, j + 1), Math.abs(free[j] - full[i]) + dp(i + 1, j + 1));
+	}
+	
+	public static void main(String[] args) throws Exception {
+		Scanner sc = new Scanner(System.in);
+		PrintWriter pw = new PrintWriter(System.out);
+		
+		int l = sc.nextInt();
+		int[] array = sc.nextIntArray(l);
+		
+		n = 0;
+		for(int i = 0; i < l; i++)
+			if(array[i] == 1)
+				n++;
+		m = l - n;
+		
+		full = new int[n];
+		free = new int[m];
+		int ind1 = 0, ind2 = 0;
+		for(int i = 0; i < l; i++)
+			if(array[i] == 0)
+				free[ind2++] = i;
+			else
+				full[ind1++] = i;
+		
+		memo = new int[n][m];
+		for(int[] i : memo)
+			Arrays.fill(i, -1);
+		
+		pw.println(dp(0, 0));
+		pw.flush();
+	}
+
+	public static class Scanner {
+		StringTokenizer st;
+		BufferedReader br;
+
+		public Scanner(InputStream system) {
+			br = new BufferedReader(new InputStreamReader(system));
+		}
+
+		public Scanner(String file) throws Exception {
+			br = new BufferedReader(new FileReader(file));
+		}
+
+		public String next() throws IOException {
+			while (st == null || !st.hasMoreTokens())
+				st = new StringTokenizer(br.readLine());
+			return st.nextToken();
+		}
+
+		public String nextLine() throws IOException {
+			return br.readLine();
+		}
+
+		public int nextInt() throws IOException {
+			return Integer.parseInt(next());
+		}
+
+		public double nextDouble() throws IOException {
+			return Double.parseDouble(next());
+		}
+
+		public char nextChar() throws IOException {
+			return next().charAt(0);
+		}
+
+		public long nextLong() throws IOException {
+			return Long.parseLong(next());
+		}
+
+		public int[] nextIntArray(int n) throws IOException {
+			int[] array = new int[n];
+			for (int i = 0; i < n; i++)
+				array[i] = nextInt();
+			return array;
+		}
+
+		public Integer[] nextIntegerArray(int n) throws IOException {
+			Integer[] array = new Integer[n];
+			for (int i = 0; i < n; i++)
+				array[i] = new Integer(nextInt());
+			return array;
+		}
+
+		public long[] nextLongArray(int n) throws IOException {
+			long[] array = new long[n];
+			for (int i = 0; i < n; i++)
+				array[i] = nextLong();
+			return array;
+		}
+
+		public double[] nextDoubleArray(int n) throws IOException {
+			double[] array = new double[n];
+			for (int i = 0; i < n; i++)
+				array[i] = nextDouble();
+			return array;
+		}
+
+		public static int[] shuffle(int[] a) {
+			int n = a.length;
+			Random rand = new Random();
+			for (int i = 0; i < n; i++) {
+				int tmpIdx = rand.nextInt(n);
+				int tmp = a[i];
+				a[i] = a[tmpIdx];
+				a[tmpIdx] = tmp;
+			}
+			return a;
+		}
+
+		public boolean ready() throws IOException {
+			return br.ready();
+		}
+
+		public void waitForInput() throws InterruptedException {
+			Thread.sleep(3000);
+		}
+	}
+}
+","import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.*;
+
+public class Try2{
+	public static void main(String[] args) throws IOException {
+		FastScanner fs = new FastScanner();
+//		int t =fs.nextInt();
+		int t=1;
+		
+		while (t-- > 0) {
+		
+			int n = fs.nextInt();
+			
+			
+			int a[] = new int[n];
+			
+			int countOne = 0;
+			
+			
+			ArrayList<Integer> aa = new ArrayList<Integer>();
+			
+			for(int i =0;i<n;i++) {
+					a[i] =fs.nextInt();
+					if(a[i]==1) {
+						countOne++;
+						aa.add(i);
+					}
+			}
+			
+			int dp[][] = new int[n+1][countOne+1];
+			
+			for(int i =0 ;i<=n;i++) {
+				for(int j =0 ;j<=countOne;j++) {
+					dp[i][j] = Integer.MAX_VALUE;
+				}
+			}
+			
+			
+			
+			dp[0][0] =0;
+			for(int i =0 ;i<n;i++) {
+				for(int j =0 ;j<countOne+1;j++) {
+					
+					if(dp[i][j]==Integer.MAX_VALUE) continue;
+					
+					dp[i+1][j] = Math.min(dp[i][j], dp[i+1][j]);
+					
+					if(j<countOne && a[i]==0) {
+						dp[i+1][j+1]=Math.min(dp[i][j]+Math.abs(aa.get(j)-i),dp[i+1][j+1]);
+					}
+					
+					
+					
+				}
+			}
+			
+			System.out.println(dp[n][countOne]);
+			
+			
+		
+		}
+		
+	}
+	
+	
+	
+	
+	static final Random random = new Random();
+
+	static void ruffleSort(int[] a) {
+		int n = a.length;// shuffle, then sort
+		for (int i = 0; i < n; i++) {
+			int oi = random.nextInt(n), temp = a[oi];
+			a[oi] = a[i];
+			a[i] = temp;
+		}
+		Arrays.sort(a);
+	}
+
+	static class FastScanner {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st = new StringTokenizer("""");
+
+		String next() {
+			while (!st.hasMoreTokens())
+				try {
+					st = new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			return st.nextToken();
+		}
+
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+
+		int[] readArray(int n) {
+			int[] a = new int[n];
+			for (int i = 0; i < n; i++)
+				a[i] = nextInt();
+			return a;
+		}
+
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+	}
+
+}
+",0
+9291ca83,b185d034,"import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.util.*;
+
+public class Practice {
+    static HashMap<String, Integer> map = new HashMap<>();
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        int t = sc.nextInt();
+        while (t-->0) {
+            int n = sc.nextInt();
+            int[][] occurances = new int[5][n];
+            for(int i=0;i<n;i++){
+                String s = sc.next();
+                int[] count = new int[5];
+                int len = s.length();
+                for(int j=0;j<s.length();j++){
+                    count[s.charAt(j)-'a']++;
+                }
+                for(int j=0;j<5;j++){
+                    occurances[j][i] = count[j] - (len-count[j]);
+                }
+            }
+            int ans = 0;
+            for(int i=0;i<5;i++){
+                Arrays.sort(occurances[i]);
+                int tmpAns = 0; int tmpSum=0;
+                for(int j=n-1;j>=0;j--){
+                    tmpSum+=occurances[i][j];
+                    if(tmpSum>0) tmpAns++;
+                    else break;
+                }
+                ans = Math.max(ans, tmpAns);
+            }
+            System.out.println(ans);
+        }
+    }
+}
+
+","import java.io.*;
+import java.util.*;
+public class A734C {
+    public static void main(String[] args) {
+        JS scan = new JS();
+        int t = scan.nextInt();
+        loop:while(t-->0){
+            int n = scan.nextInt();
+            String[] arr= new String[n];
+            Integer[][] counts = new Integer[5][n];
+            for(int i = 0;i<5;i++){
+                for(int j = 0;j<n;j++){
+                    counts[i][j] = 0;
+                }
+            }
+            for(int i =0;i<n;i++){
+                arr[i] = scan.next();
+                int[] freq =new int[5];
+                for(int j = 0;j<arr[i].length();j++){
+                    freq[arr[i].charAt(j)-'a']++;
+                }
+                for(int j = 0;j<5;j++){
+                    counts[j][i] = freq[j]-(arr[i].length()-freq[j]);
+                }
+            }
+            int best = 0;
+            for(int i = 0;i<5;i++){
+                Arrays.sort(counts[i]);
+                int curr = 0;
+                int extra = 0;
+                for(int j = n-1;j>=0;j--){
+                    extra+=counts[i][j];
+                    if(extra>0)curr++;
+                }
+                best = Math.max(best,curr);
+            }
+            System.out.println(best);
+
+        }
+    }
+    static class JS {
+        public int BS = 1 << 16;
+        public char NC = (char) 0;
+        byte[] buf = new byte[BS];
+        int bId = 0, size = 0;
+        char c = NC;
+        double num = 1;
+        BufferedInputStream in;
+
+        public JS() {
+            in = new BufferedInputStream(System.in, BS);
+        }
+
+        public JS(String s) throws FileNotFoundException {
+            in = new BufferedInputStream(new FileInputStream(new File(s)), BS);
+        }
+
+        public char nextChar() {
+            while (bId == size) {
+                try {
+                    size = in.read(buf);
+                } catch (Exception e) {
+                    return NC;
+                }
+                if (size == -1) return NC;
+                bId = 0;
+            }
+            return (char) buf[bId++];
+        }
+
+        public int nextInt() {
+            return (int) nextLong();
+        }
+
+        public long nextLong() {
+            num = 1;
+            boolean neg = false;
+            if (c == NC) c = nextChar();
+            for (; (c < '0' || c > '9'); c = nextChar()) {
+                if (c == '-') neg = true;
+            }
+            long res = 0;
+            for (; c >= '0' && c <= '9'; c = nextChar()) {
+                res = (res << 3) + (res << 1) + c - '0';
+                num *= 10;
+            }
+            return neg ? -res : res;
+        }
+
+        public double nextDouble() {
+            double cur = nextLong();
+            return c != '.' ? cur : cur + nextLong() / num;
+        }
+
+        public String next() {
+            StringBuilder res = new StringBuilder();
+            while (c <= 32) c = nextChar();
+            while (c > 32) {
+                res.append(c);
+                c = nextChar();
+            }
+            return res.toString();
+        }
+
+        public String nextLine() {
+            StringBuilder res = new StringBuilder();
+            while (c <= 32) c = nextChar();
+            while (c != '\n') {
+                res.append(c);
+                c = nextChar();
+            }
+            return res.toString();
+        }
+
+        public boolean hasNext() {
+            if (c > 32) return true;
+            while (true) {
+                c = nextChar();
+                if (c == NC) return false;
+                else if (c > 32) return true;
+            }
+        }
+    }
+}
+",1
+80e6c4db,f22a4243,"import java.util.*;
+import java.io.*;
+
+////***************************************************************************
+ /* public class E_Gardener_and_Tree implements Runnable{
+
+       public static void main(String[] args) throws Exception {
+        new Thread(null, new E_Gardener_and_Tree(), ""E_Gardener_and_Tree"", 1<<28).start();
+       }
+    public void run(){
+         WRITE YOUR CODE HERE!!!!
+         JUST WRITE EVERYTHING HERE WHICH YOU WRITE IN MAIN!!!
+       }
+
+  }
+*/
+/////**************************************************************************
+
+
+public class C_Set_or_Decrease{
+    public static void main(String[] args) {
+        FastScanner s= new FastScanner();
+        //PrintWriter out=new PrintWriter(System.out);
+        //end of program
+        //out.println(answer);
+        //out.close();
+        StringBuilder res = new StringBuilder();
+        int t=s.nextInt();
+        int p=0;
+        while(p<t){
+        int n=s.nextInt();
+        long k=s.nextLong();
+        ArrayList<Long> list = new  ArrayList<Long>();
+        long sum=0;
+        for(int i=0;i<n;i++){
+            long a=s.nextLong();
+            list.add(a);
+            sum+=a;
+        }
+        if(sum<=k){
+            res.append(""0 \n"");
+        }
+        else{
+            Collections.sort(list);
+            long well[]= new long[n-1];
+            long ss=0;
+            for(int i=1;i<n;i++){
+                long a=list.get(i);
+                ss+=a;
+                well[i-1]=ss;
+              //  System.out.print(well[i-1]+"" "");
+            }
+            System.out.println();
+            long yo=k/n;
+            long first=list.get(0);
+            long yo1=Math.min(yo,first);
+            long ans=Long.MAX_VALUE;
+           // System.out.println(""yo1 ""+yo1);
+            for(long i=yo1;i>(yo1-n-5);i--){
+              //  System.out.println(""i ""+i);
+                long num=first-i;
+                long start=-1;
+                long end=n-1;
+                long mid=0;
+                while(start<end){
+                    mid=(start+end)/2;
+                    if(start+1==end){
+                        break;
+                    }
+                    long hh=well[(int)mid];
+                    long a1=(n-mid-1);
+                    long a2=(a1*i);
+                    hh+=a2;
+                    if(hh<=k){
+                        start=mid;
+                    }
+                    else{
+                        end=mid;
+                    }
+                }
+                long jj=n-start-2;
+                long kk=jj+num;
+                ans=Math.min(ans,kk);
+
+
+
+            }
+            res.append(ans+"" \n"");
+        }
+        p++;
+    }
+    System.out.println(res);
+
+    }
+    static class FastScanner {
+		BufferedReader br;
+		StringTokenizer st;
+ 
+		public FastScanner(String s) {
+			try {
+				br = new BufferedReader(new FileReader(s));
+			} catch (FileNotFoundException e) {
+				// TODO Auto-generated catch block
+				e.printStackTrace();
+			}
+		}
+ 
+		public FastScanner() {
+			br = new BufferedReader(new InputStreamReader(System.in));
+		}
+ 
+		String nextToken() {
+			while (st == null || !st.hasMoreElements()) {
+				try {
+					st = new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					// TODO Auto-generated catch block
+					e.printStackTrace();
+				}
+			}
+			return st.nextToken();
+		}
+ 
+		int nextInt() {
+			return Integer.parseInt(nextToken());
+		}
+ 
+		long nextLong() {
+			return Long.parseLong(nextToken());
+		}
+ 
+		double nextDouble() {
+			return Double.parseDouble(nextToken());
+		}
+	}
+
+
+    static long modpower(long x, long y, long p)
+     {
+      long res = 1; // Initialize result
+   
+      x = x % p; // Update x if it is more than or
+      // equal to p
+   
+      if (x == 0)
+        return 0; // In case x is divisible by p;
+   
+      while (y > 0)
+      {
+   
+        // If y is odd, multiply x with result
+        if ((y & 1) != 0)
+          res = (res * x) % p;
+   
+        // y must be even now
+        y = y >> 1; // y = y/2
+        x = (x * x) % p;
+      }
+      return res;
+    }
+
+  
+   // SIMPLE POWER FUNCTION=>
+
+
+      static long power(long x, long y)
+        {
+            long res = 1;     // Initialize result
+        
+            while (y > 0)
+            {
+            
+                // If y is odd, multiply x with result
+                if ((y & 1) != 0)
+                    res = res * x;
+        
+                // y must be even now
+                y = y >> 1; // y = y/2
+                x = x * x;  // Change x to x^2
+            }
+            return res;
+        }
+
+
+
+
+
+}","
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.*;
+ 
+public class C {
+ 
+	public static void main(String[] args) {
+		FastScanner fs=new FastScanner();
+		int t=fs.nextInt();
+		while(t-->0) 
+		{
+			int n;
+			long k,sum=0L,temp=0L,min=Integer.MAX_VALUE;
+			n=fs.nextInt();
+			k=fs.nextLong();
+			int[] arr=fs.readArray(n);
+		    for(int i=0;i<n;i++)
+		        sum+=arr[i];
+		    sort(arr);
+		    Stack<Integer> s=new Stack<>();
+		    for(int i=1;i<n;i++){
+		        s.push(arr[i]-arr[0]);
+		    }
+		    while(!s.empty() && sum>k){
+		        min=Math.min(min,temp+(sum-k+temp)/(temp+1));
+		        sum-=s.peek();
+		        s.pop();
+		        temp++;
+		    }
+		    if(sum>k){
+		    	temp+=(sum-k+temp)/(temp+1);
+		    }
+		    System.out.println(Math.min(min, temp));
+		}
+	}
+	public static void kThLexString(String st,int k, int n)
+	{
+	// Set to store the unique substring
+	Set<String> z = new HashSet<String>();
+	
+	for(int i = 0; i < n; i++)
+	{
+	// String to create each substring
+	String pp = """";
+	
+	for(int j = i; j < i + k; j++)
+	{
+	if (j >= n)
+	break;
+	pp += st.charAt(j);
+	
+	// Adding to set
+	z.add(pp);
+	}
+	}
+	
+	// Converting set into a list
+	Vector<String> fin = new Vector<String>();
+	fin.addAll(z);
+	
+	// Sorting the strings int the list
+	// into lexicographical order
+	Collections.sort(fin);
+	
+	// Printing kth substring
+	System.out.print(fin.get(k - 1));
+	}
+	static long gcd(long a, long b)
+    {
+      if (b == 0)
+        return a;
+      return gcd(b, a % b);
+    }
+ 
+	static void sort(int[] a) {
+		ArrayList<Integer> l=new ArrayList<>();
+		for (int i:a) l.add(i);
+		Collections.sort(l);
+		for (int i=0; i<a.length; i++) a[i]=l.get(i);
+	}
+	void shuffleArray(long[] arr){
+        int n = arr.length;
+        Random rnd = new Random();
+        for(int i=0; i<n; ++i){
+            long tmp = arr[i];
+            int randomPos = i + rnd.nextInt(n-i);
+            arr[i] = arr[randomPos];
+            arr[randomPos] = tmp;
+        }   
+}
+	
+	static class FastScanner {
+		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st=new StringTokenizer("""");
+		String next() {
+			while (!st.hasMoreTokens())
+				try {
+					st=new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			return st.nextToken();
+		}
+		
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+		int[] readArray(int n) {
+			int[] a=new int[n];
+			for (int i=0; i<n; i++) a[i]=nextInt();
+			return a;
+		}
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+	}
+ 
+	
+}",0
+1c90c367,f0801d53,"
+/*
+
+    /$$$$$  /$$$$$$  /$$    /$$  /$$$$$$                                                                  
+   |__  $$ /$$__  $$ |$$    |$$ /$$__  $$                                                                 
+          | $$| $$  \ $$|    $$|$$| $$  \ $$                                                                 
+          | $$| $$$$$$$$|  $$ / $$/| $$$$$$$$                                                                 
+/ $$  | $$| $$__  $$ \  $$ $$/ | $$__  $$                                                                 
+| $$  | $$| $$  | $$  \  $$$/  | $$  | $$                                                                 
+|  $$$$$$/| $$  | $$   \  $/   | $$  | $$                                                                 
+ \______/ |__/  |__/    \_/    |__/  |__/                                                                 
+/$$$$$$$  /$$$$$$$   /$$$$$$   /$$$$$$  /$$$$$$$   /$$$$$$  /$$      /$$ /$$      /$$ /$$$$$$$$ /$$$$$$$ 
+| $$__  $$| $$__  $$ /$$__  $$ /$$__  $$| $$__  $$ /$$__  $$| $$$    /$$$| $$$    /$$$| $$_____/| $$__  $$
+| $$  \ $$| $$  \ $$| $$  \ $$| $$  \__/| $$  \ $$| $$  \ $$| $$$$  /$$$$| $$$$  /$$$$| $$      | $$  \ $$
+| $$$$$$$/| $$$$$$$/| $$  | $$| $$ /$$$$| $$$$$$$/| $$$$$$$$| $$ $$/$$ $$| $$ $$/$$ $$| $$$$$   | $$$$$$$/
+| $$____/ | $$__  $$| $$  | $$| $$|_  $$| $$__  $$| $$__  $$| $$  $$$| $$| $$  $$$| $$| $$__/   | $$__  $$
+| $$      | $$  \ $$| $$  | $$| $$  \ $$| $$  \ $$| $$  | $$| $$\  $ | $$| $$\  $ | $$| $$      | $$  \ $$
+| $$      | $$  | $$|  $$$$$$/|  $$$$$$/| $$  | $$| $$  | $$| $$ \/  | $$| $$ \/  | $$| $$$$$$$$| $$  | $$
+|__/      |__/  |__/ \______/  \______/ |__/  |__/|__/  |__/|__/     |__/|__/     |__/|________/|__/  |__/
+																																																				
+																																																				
+
+*/
+
+import java.io.BufferedReader;
+import java.text.DecimalFormat;
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.math.BigInteger;
+import java.util.*;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import java.io.*;
+
+public class abc {
+	static PrintWriter pw;
+
+	static long x = 1, y = 1;
+
+	/*
+	 * static long inv[]=new long[1000001]; static long dp[]=new long[1000001];
+	 */
+	/// MAIN FUNCTION///
+	public static void main(String[] args) throws Exception {
+
+		FastReader sc = new FastReader();
+		pw = new PrintWriter(System.out);
+		// use arraylist as it uses the concept of dynamic table(amortized analysis)
+		// Arrays.stream(array).forEach(a -> Arrays.fill(a, 0));
+		/* List<Integer> l1 = new ArrayList<Integer>(); */
+		// Random rand = new Random();
+		int tst = sc.nextInt();
+		while(tst-->0) {
+			int n=sc.nextInt();
+			int app[]=new int[n];
+			int h[]=new int[n];
+			for(int i=0;i<n;i++)
+			{
+				app[i]=sc.nextInt();
+			}
+			for(int i=0;i<n;i++)
+			{
+				h[i]=sc.nextInt();
+			}
+			long man = 0;
+			long last = app[n - 1] - h[n - 1] + 1;
+			int end = n-1;
+			for (int i = n-2; i >=0; i--) {
+				if(app[i]>=last) {
+					last = Math.min(last,app[i] - h[i] + 1);
+				}
+				else {
+					long s = app[end]-last+1;
+					man += (s*(s+1))/2;
+					end = i;
+					last = app[i] - h[i] + 1;;
+				}
+			}
+			long s = app[end]-last+1;
+			man += (s*(s+1))/2;
+			pw.println(man);
+		}
+		pw.flush();
+	}
+
+	public static long eculidean_gcd(long a, long b) {
+		if (a == 0) {
+			x = 0;
+			y = 1;
+			return b;
+		}
+		long ans = eculidean_gcd(b % a, a);
+		long x1 = x;
+		x = y - (b / a) * x;
+		y = x1;
+		return ans;
+	}
+
+	public static int sum(int n) {
+		int sum = 1;
+		if (n == 0)
+			return 0;
+		while (n != 0) {
+			sum = sum * n;
+			n = n - 1;
+		}
+		return sum;
+	}
+
+	public static boolean isLsbOne(int n) {
+		if ((n & 1) != 0)
+			return true;
+		return false;
+	}
+
+	public static pair helper(int arr[], int start, int end, int k, pair dp[][]) {
+		if (start >= end) {
+			if (start == end)
+				return (new pair(arr[start], 0));
+			else
+				return (new pair(0, 0));
+		}
+		if (dp[start][end].x != -1 && dp[start][end].y != -1) {
+			return dp[start][end];
+		}
+		pair ans = new pair(0, Integer.MAX_VALUE);
+		for (int i = start; i < end; i++) {
+			pair x1 = helper(arr, start, i, k, dp);
+			pair x2 = helper(arr, i + 1, end, k, dp);
+			long tip = k * (x1.x + x2.x) + x1.y + x2.y;
+			if (tip < ans.y)
+				ans = new pair(x1.x + x2.x, tip);
+		}
+		return dp[start][end] = ans;
+	}
+
+	public static void debugger() {
+		Random rand = new Random();
+		int tst = (int) (Math.abs(rand.nextInt()) % 2 + 1);
+		pw.println(tst);
+		while (tst-- > 0) {
+			int n = (int) (Math.abs(rand.nextInt()) % 5 + 1);
+			pw.println(n);
+			for (int i = 0; i < n; i++) {
+				pw.print((int) (Math.abs(rand.nextInt()) % 6 + 1) + "" "");
+			}
+			pw.println();
+		}
+	}
+
+	static int UpperBound(long a[], long x) {// x is the key or target value
+		int l = -1, r = a.length;
+		while (l + 1 < r) {
+			int m = (l + r) >>> 1;
+			if (a[m] <= x)
+				l = m;
+			else
+				r = m;
+		}
+		return l + 1;
+	}
+
+	static int LowerBound(long a[], long x) { // x is the target value or key
+		int l = -1, r = a.length;
+		while (l + 1 < r) {
+			int m = (l + r) >>> 1;
+			if (a[m] >= x)
+				r = m;
+			else
+				l = m;
+		}
+		return r;
+	}
+
+	static void recursion(int n) {
+		if (n == 1) {
+			pw.print(n + "" "");
+			return;
+		}
+		// pw.print(n+"" ""); gives us n to 1
+		recursion(n - 1);
+		// pw.print(n+"" ""); gives us 1 to n
+	}
+
+	// ch.charAt(i)+"""" converts into a char sequence
+	static class FastReader {
+		BufferedReader br;
+		StringTokenizer st;
+
+		public FastReader() {
+			br = new BufferedReader(new InputStreamReader(System.in));
+		}
+
+		String next() {
+			while (st == null || !st.hasMoreElements()) {
+				try {
+					st = new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			}
+			return st.nextToken();
+		}
+
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+
+		double nextDouble() {
+			return Double.parseDouble(next());
+		}
+
+		String nextLine() {
+			String str = """";
+			try {
+				str = br.readLine();
+			} catch (IOException e) {
+				e.printStackTrace();
+			}
+			return str;
+		}
+
+		/* CREATED BY ME */
+		int[] readArray(int n) {
+			int[] a = new int[n];
+			for (int i = 0; i < n; i++)
+				a[i] = nextInt();
+			return a;
+		}
+
+		long[] readLongArray(int n) {
+			long[] a = new long[n];
+			for (int i = 0; i < n; i++)
+				a[i] = nextLong();
+			return a;
+		}
+	}
+
+	public static long gcd(long a, long b) {
+		return b == 0 ? a : gcd(b, a % b);
+	}
+
+	public static boolean isPrime(long n) {
+		if (n == 2)
+			return true;
+		long i = 2;
+		while (i * i <= n) {
+			if (n % i == 0)
+				return false;
+			i++;
+		}
+		return true;
+	}
+
+	static int ceil(int x, int y) {
+		return (x % y == 0 ? x / y : (x / y + 1));
+	}
+
+	static long ceil(long x, long y) {
+		return (x % y == 0 ? x / y : (x / y + 1));
+	}
+
+	static double max(double x, double y) {
+		return Math.max(x, y);
+	}
+
+	static int min(int x, int y) {
+		return Math.min(x, y);
+	}
+
+	static int abs(int x) {
+		return Math.abs(x);
+	}
+
+	static long abs(long x) {
+		return Math.abs(x);
+	}
+
+	static int log2(int N) {
+		int result = (int) (Math.log(N) / Math.log(2));
+		return result;
+	}
+
+	static long max(long x, long y) {
+		return Math.max(x, y);
+	}
+
+	static long min(long x, long y) {
+		return Math.min(x, y);
+	}
+
+	public static class pair {
+		long x;
+		long y;
+
+		public pair(long a, long b) {
+			x = a;
+			y = b;
+		}
+	}
+
+	public static class Comp implements Comparator<pair> {
+		public int compare(pair a, pair b) {
+			long ans = a.x - b.x;
+			if (ans > 0)
+				return 1;
+			if (ans < 0)
+				return -1;
+			return 0;
+		}
+	}
+
+	// modular exponentiation
+	public static long fastExpo(long a, int n, int mod) {
+		if (n == 0)
+			return 1;
+		else {
+			if ((n & 1) == 1) {
+				long x = fastExpo(a, n / 2, mod);
+				return (((a * x) % mod) * x) % mod;
+			} else {
+				long x = fastExpo(a, n / 2, mod);
+				return (((x % mod) * (x % mod)) % mod) % mod;
+			}
+		}
+	}
+
+	public static long modInverse(long n, int p) {
+		return fastExpo(n, p - 2, p);
+	}
+
+	/*
+	 * public static void extract(ArrayList<Integer> ar, int k, int d) { int c = 0;
+	 * for (int i = 1; i < k; i++) { int x = 0; boolean dm = false; while (x > 0) {
+	 * long dig = x % 10; x = x / 10; if (dig == d) { dm = true; break; } } if (dm)
+	 * ar.add(i); } }
+	 */
+
+	public static int[] prefixfuntion(String s) {
+		int n = s.length();
+		int z[] = new int[n];
+		for (int i = 1; i < n; i++) {
+			int j = z[i - 1];
+			while (j > 0 && s.charAt(i) != s.charAt(j))
+				j = z[j - 1];
+			if (s.charAt(i) == s.charAt(j))
+				j++;
+			z[i] = j;
+		}
+		return z;
+	}
+
+// counts the set(1) bit of a number
+	public static long countSetBitsUtil(long x) {
+		if (x <= 0)
+			return 0;
+		return (x % 2 == 0 ? 0 : 1) + countSetBitsUtil(x / 2);
+	}
+
+//tells whether a particular index has which bit of a number	
+	public static int getIthBitsUtil(int x, int y) {
+		return (x & (1 << y)) != 0 ? 1 : 0;
+	}
+
+	public static void swaper(long x, long y) {
+		x = x ^ y;
+		y = y ^ x;
+		x = x ^ y;
+	}
+
+	public static double decimalPlaces(double sum) {
+		DecimalFormat df = new DecimalFormat(""#.00"");
+		String angleFormated = df.format(sum);
+		double fin = Double.parseDouble(angleFormated);
+		return fin;
+	}
+
+//use collections.swap for swapping 
+	static boolean isSubSequence(String str1, String str2, int m, int n) {
+		int j = 0;
+
+		for (int i = 0; i < n && j < m; i++)
+			if (str1.charAt(j) == str2.charAt(i))
+				j++;
+
+		return (j == m);
+	}
+
+	static long sum(long n) {
+		long s2 = 0, max = -1, min = 10;
+		while (n > 0) {
+			s2 = (n % 10);
+			min = min(s2, min);
+			max = max(s2, max);
+			n = n / 10;
+		}
+		return max * min;
+	}
+
+	static long pow(long base, long power) {
+		if (power == 0) {
+			return 1;
+		}
+		long result = pow(base, power / 2);
+		if (power % 2 == 1) {
+			return result * result * base;
+		}
+		return result * result;
+	}
+
+	// return the hash value of a string
+	static long compute_hash(String s) {
+		long val = 0;
+		long p = 31;
+		long mod = (long) (1000000007);
+		long pow = 1;
+		for (int i = 0; i < s.length(); i++) {
+			char ch = s.charAt(i);
+			val = (val + (int) (ch - 'a' + 1) * pow) % mod;
+			pow = (pow * p) % mod;
+		}
+		return val;
+	}
+
+}
+","import java.util.*;
+import java.io.*;
+
+public class hmm {
+
+	static Scanner sc = new Scanner(System.in);
+	static PrintWriter pw = new PrintWriter(System.out);
+
+
+	public static void main(String[] args) throws Exception {
+		int t =sc.nextInt();
+		while (t-- > 0) {
+             int n = sc.nextInt();
+             int []k = sc.nextIntArray(n);
+             int h[]=sc.nextIntArray(n);
+     
+             long mana = 0;
+             pair cur = new pair(k[n-1]-h[n-1]+1,k[n-1]);
+             for(int i=n-1;i>=0;i--) {
+            	 int s = k[i];
+            	 int start = s-h[i]+1;
+            	 if(s>=cur.x) {
+            		 cur.x = Math.min(start, cur.x);
+            	 }
+            	 else {
+            		 long x = cur.y - cur.x +1;
+            		 mana += x*(x+1)/2;
+            		 cur.x = start;
+            		 cur.y = s;
+            	 }
+             }
+       
+             long x = cur.y - cur.x +1;
+       
+    		 mana += x*(x+1)/2;
+    		 pw.println(mana);
+             
+           
+		}
+
+		pw.close();
+
+	}
+
+	// -------------- stuff ------------------------------
+	static class pair {
+		int x ;
+		int y;
+	
+		
+		public pair(int n,int c) {
+			x= n;
+			y = c;
+		
+			
+		}
+	
+	
+		
+	}
+
+	static class Scanner {
+		StringTokenizer st;
+		BufferedReader br;
+
+		public Scanner(InputStream s) {
+			br = new BufferedReader(new InputStreamReader(s));
+		}
+
+		public Scanner(FileReader r) {
+			br = new BufferedReader(r);
+		}
+
+		public String next() throws IOException {
+			while (st == null || !st.hasMoreTokens())
+				st = new StringTokenizer(br.readLine());
+			return st.nextToken();
+		}
+
+		public int nextInt() throws IOException {
+			return Integer.parseInt(next());
+		}
+
+		public long nextLong() throws IOException {
+			return Long.parseLong(next());
+		}
+
+		public String nextLine() throws IOException {
+			return br.readLine();
+		}
+
+		public int[] nextIntArray(int n) throws IOException {
+			int[] a = new int[n];
+			for (int i = 0; i < n; i++)
+				a[i] = nextInt();
+			return a;
+		}
+
+	}
+
+}",1
+018c15bd,378bb1ca,"import java.util.*;
+import java.util.Map.Entry;
+
+
+import java.io.*;
+import java.math.*;
+import static java.util.stream.Collectors.*;
+import static java.util.Map.Entry.*;
+
+/* Name of the class has to be ""Main"" only if the class is public. */
+public class Hey
+{
+	public static void main (String[] args) throws IOException
+	{
+		final long mod=(long) (1e9+7);  
+		
+		Reader s=new Reader();
+		  PrintWriter pt=new PrintWriter(System.out);
+//		  BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+		  int T=s.nextInt();
+//		  int T=Integer.parseInt(br.readLine());
+//		  int T=1;
+		  while(T-->0)
+		  {
+			  int n=s.nextInt();
+			  int c[]=new int[n];
+			  for(int i=0;i<n;i++) {
+				  c[i]=s.nextInt();
+			  }
+			  long mo[]=new long[n];
+			  long me[]=new long[n];
+			  mo[0]=-1;
+			  me[0]=-1;
+			  mo[1]=c[0];
+			  me[1]=c[1];
+			  long so[]=new long[n];
+			  long se[]=new long[n];
+			  so[1]=c[0];
+			  se[1]=c[1];
+			  for(int i=2;i<n;i++) {
+				  if(i%2==0) {
+					  mo[i]=Math.min(c[i], mo[i-1]);
+					  me[i]=me[i-1];
+					  so[i]=so[i-1]+c[i];
+					  se[i]=se[i-1];
+				  }
+				  else {
+					  mo[i]=mo[i-1];
+					  me[i]=Math.min(c[i], me[i-1]);
+					  so[i]=so[i-1];
+					  se[i]=se[i-1]+c[i];
+				  }
+			  }
+			  
+//			  pa(mo);
+//			  pa(me);
+//			  pa(so);
+//			  pa(se);
+			  long min=Long.MAX_VALUE;
+			  for(int i=1;i<n;i++) {
+				  long k1=0, k2=0;
+				  if(i%2==1) {
+					  k1=i/2+1;
+					  k2=i/2+1;
+				  }
+				  else {
+					  k2=i/2;
+					  k1=k2+1;
+				  }
+				  min=Math.min((n-k1)*mo[i]+so[i]+(n-k2)*me[i]+se[i], min);
+			  }
+			  pt.println(min);
+		  }
+		  pt.close();
+	}
+	
+	static boolean isSorted(int arr[], int n) {
+		for(int i=1;i<n;i++) {
+			if(arr[i]>=arr[i-1]==false) {
+				return false;
+			}
+		}
+		return true;
+	}
+	
+	static int setBit(int S, int j) { return S | 1 << j; }
+
+	static int clearBit(int S, int j) { return S & ~(1 << j); }
+
+	static int toggleBit(int S, int j) { return S ^ 1 << j; }
+
+	static boolean isOn(int S, int j) { return (S & 1 << j) != 0; }
+
+	static int turnOnLastZero(int S) { return S | S + 1; }
+	
+	static int turnOnLastConsecutiveZeroes(int S) { return S | S - 1; }
+	
+	static int turnOffLastBit(int S) { return S & S - 1; }
+	
+	static int turnOffLastConsecutiveBits(int S) { return S & S + 1; }
+
+	static int lowBit(int S) { return S & -S; }
+
+	static int setAll(int N) { return (1 << N) - 1; }
+
+	static int modulo(int S, int N) { return (S & N - 1); }		 //S%N, N is a power of 2
+
+	static boolean isPowerOfTwo(int S) { return (S & S - 1) == 0; }
+	
+	static boolean isWithin(long x, long y, long d, long k) {
+		return x*k*x*k + y*k*y*k <= d*d;
+	}
+	
+	static long modFact(long n, 
+            long p) 
+	{ 
+		if (n >= p) 
+		 return 0; 
+		
+		long result = 1; 
+		for (int i = 1; i <= n; i++) 
+		 result = (result * i) % p; 
+		
+		return result; 
+	} 
+	static int sum(int[] arr, int n)
+	{
+	    int inc[]=new int[n+1];
+	    int dec[]=new int[n+1];
+	    inc[0] = arr[0];
+	    dec[0] = arr[0];
+
+	    for (int i = 1; i < n; i++) {
+	        for (int j = 0; j < i; j++) {
+	            if (arr[j] > arr[i]) {
+	                dec[i] = max(dec[i], inc[j] + arr[i]);
+	            }
+	            else if (arr[i] > arr[j]) {
+	                inc[i] = max(inc[i], dec[j] + arr[i]);
+	            }
+	        }
+	    }
+	    return max(inc[n - 1], dec[n - 1]);
+	}
+	static long nc2(long a) {
+		return a*(a-1)/2;
+	}
+	public static int numberOfprimeFactors(int n) 
+    { 
+        // Print the number of 2s that divide n 
+		HashSet<Integer> hs = new HashSet<Integer>();
+        while (n%2==0) 
+        { 
+            hs.add(2);
+            n /= 2; 
+        } 
+  
+        // n must be odd at this point.  So we can 
+        // skip one element (Note i = i +2) 
+        for (int i = 3; i <= Math.sqrt(n); i+= 2) 
+        { 
+            // While i divides n, print i and divide n 
+            while (n%i == 0) 
+            { 
+                hs.add(i);
+                n /= i; 
+            } 
+        } 
+  
+        // This condition is to handle the case whien 
+        // n is a prime number greater than 2 
+        if (n > 2) 
+            hs.add(n);
+        return hs.size();
+    } 
+	static int gcd(int a, int b) 
+    { 
+      if (b == 0) 
+        return a; 
+      return gcd(b, a % b);  
+    } 
+
+
+
+
+	
+
+	static void reverse(int arr[],int start, int end) 
+	{ 
+		int temp; 
+		   
+		while (start < end) 
+		{ 
+		    temp = arr[start];  
+		    arr[start] = arr[end]; 
+		    arr[end] = temp; 
+		    start++; 
+		    end--; 
+		}  
+	}  
+	static void reverse(long arr[],int start, int end) 
+	{ 
+		long temp; 
+		   
+		while (start < end) 
+		{ 
+		    temp = arr[start];  
+		    arr[start] = arr[end]; 
+		    arr[end] = temp; 
+		    start++; 
+		    end--; 
+		}  
+	}  
+	static boolean isPrime(long n) 
+    { 
+        // Corner cases 
+        if (n <= 1) return false; 
+        if (n <= 3) return true; 
+      
+        // This is checked so that we can skip  
+        // middle five numbers in below loop 
+        if (n % 2 == 0 || n % 3 == 0) return false; 
+      
+        for (int i = 5; i * i <= n; i = i + 6) 
+            if (n % i == 0 || n % (i + 2) == 0) 
+            return false; 
+      
+        return true; 
+    } 
+	static int p2(int n) {
+		int k=0;
+		while(n>1) {
+			if(n%2!=0)
+				return k;
+			n/=2;
+			k++;
+		}
+		return k;
+	}
+	static boolean isp2(int n) {
+		while(n>1) {
+			if(n%2==1)
+				return false;
+			n/=2;
+		}
+		return true;
+	}
+	static int binarySearch(int arr[], int first, int last, int key){  
+		   int mid = (first + last)/2;  
+		   while( first <= last ){  
+		      if ( arr[mid] < key ){  
+		        first = mid + 1;     
+		      }else if ( arr[mid] == key ){  
+		        return mid;  
+		      }else{  
+		         last = mid - 1;  
+		      }  
+		      mid = (first + last)/2;  
+		   }  
+		   return -1;
+		 }  
+
+	static void print(int a[][]) {
+		for(int i=0;i<a.length;i++)
+		{
+			for(int j=0;j<a[0].length;j++)
+				System.out.print(a[i][j]+"" "");
+			System.out.println();
+		}
+	}
+	static int max (int x, int y) {
+		return (x > y)? x : y;
+	} 
+	static int search(Pair[] p, Pair pair) {
+		int l=0, r=p.length;
+		while (l <= r) { 
+	        int m = l + (r - l) / 2;
+	        if (p[m].compareTo(pair)==0) 
+	            return m; 
+	        if (p[m].compareTo(pair)<0) 
+	            l = m + 1; 
+	        else
+	            r = m - 1;
+	    }
+	    return -1;
+	}
+	static void pa(int a[])
+	{
+		for(int i=0;i<a.length;i++)
+			System.out.print(a[i]+"" "");
+		System.out.println();
+		
+	}
+	static void pa(long a[])
+	{
+		for(int i=0;i<a.length;i++)
+			System.out.print(a[i]+"" "");
+		System.out.println();
+		
+	}
+	static void reverseArray(int arr[], 
+            int start, int end) 
+	{ 
+		int temp; 
+		   
+		while (start < end) 
+		{ 
+		    temp = arr[start];  
+		    arr[start] = arr[end]; 
+		    arr[end] = temp; 
+		    start++; 
+		    end--; 
+		}  
+	}     
+	static boolean isPalindrome(String s) {
+		int l=s.length();
+		for(int i=0;i<l/2;i++)
+		{
+			if(s.charAt(i)!=s.charAt(l-i-1))
+				return false;
+		}
+		return true;
+	}
+	static long nc2(long n, long m) {
+		return (n*(n-1)/2)%m;
+	}
+	static long c(long a) {
+		return a*(a+1)/2;
+	}
+	static int next(int[] arr, int target)  
+    {  
+        int start = 0, end = arr.length - 1;  
+    
+        int ans = -1;  
+        while (start <= end) {  
+            int mid = (start + end) / 2;  
+    
+            // Move to right side if target is  
+            // greater.  
+            if (arr[mid] < target) {  
+                start = mid + 1;  
+            }  
+    
+            // Move left side.  
+            else {  
+                ans = mid;  
+                end = mid - 1;  
+            }  
+        }  
+        return ans;  
+    }  
+
+	static long power(long x, long y, long p) 
+    { 
+        long res = 1; 
+        x = x % p; 
+                      
+        while (y > 0) 
+        { 
+            if (y % 2 == 1) 
+                res = (res * x) % p; 
+            y = y >> 1;
+            x = (x * x) % p; 
+        } 
+        return  res; 
+    } 
+    static long modInverse(long n, long p) 
+    { 
+        return power(n, p-2, p); 
+    } 
+    static long nCrModP(long n, long r, 
+                                    long p) 
+    { 
+        if(r>n)
+        	return 0;
+    	if (r == 0) 
+            return 1; 
+        long[] fac = new long[(int) (n+1)]; 
+        fac[0] = 1; 
+        for (int i = 1 ;i <= n; i++) 
+            fac[i] = fac[i-1] * i % p; 
+        return (fac[(int) n]* modInverse(fac[(int) r], p) 
+                % p * modInverse(fac[(int) (n-r)], p) 
+                                    % p) % p; 
+    } 
+	static String reverse(String str)
+	{
+		return new StringBuffer(str).reverse().toString();
+	}
+
+
+
+	static long fastpow(long x, long y, long m)  
+    { 
+        if (y == 0) 
+            return 1; 
+          
+        long p = fastpow(x, y / 2, m) % m; 
+        p = (p * p) % m; 
+      
+        if (y % 2 == 0) 
+            return p; 
+        else
+            return (x * p) % m; 
+    } 
+	
+	static boolean isPerfectSquare(long l)
+	{
+		return Math.pow((long)Math.sqrt(l),2)==l;
+	}
+	
+	
+	static void merge(long[] arr, int l, int m, int r) 
+    { 
+        // Find sizes of two subarrays to be merged 
+        int n1 = m - l + 1; 
+        int n2 = r - m; 
+  
+        /* Create temp arrays */
+        long L[] = new long [n1]; 
+        long R[] = new long [n2]; 
+  
+        /*Copy data to temp arrays*/
+        for (int i=0; i<n1; ++i) 
+            L[i] = arr[l + i]; 
+        for (int j=0; j<n2; ++j) 
+            R[j] = arr[m + 1+ j]; 
+  
+  
+        /* Merge the temp arrays */
+  
+        // Initial indexes of first and second subarrays 
+        int i = 0, j = 0; 
+  
+        // Initial index of merged subarry array 
+        int k = l; 
+        while (i < n1 && j < n2) 
+        { 
+            if (L[i] <= R[j]) 
+            { 
+                arr[k] = L[i]; 
+                i++; 
+            } 
+            else
+            { 
+                arr[k] = R[j]; 
+                j++; 
+            } 
+            k++; 
+        } 
+  
+        /* Copy remaining elements of L[] if any */
+        while (i < n1) 
+        { 
+            arr[k] = L[i]; 
+            i++; 
+            k++; 
+        } 
+  
+        /* Copy remaining elements of R[] if any */
+        while (j < n2) 
+        { 
+            arr[k] = R[j]; 
+            j++; 
+            k++; 
+        } 
+    } 
+  
+    // Main function that sorts arr[l..r] using 
+    // merge() 
+    static void sort(int arr[], int l, int r) 
+    { 
+        if (l < r) 
+        { 
+            // Find the middle point 
+            int m = (l+r)/2; 
+  
+            // Sort first and second halves 
+            sort(arr, l, m); 
+            sort(arr , m+1, r); 
+  
+            // Merge the sorted halves 
+            merge(arr, l, m, r); 
+        } 
+    } 
+	static void merge(int arr[], int l, int m, int r) 
+    { 
+        // Find sizes of two subarrays to be merged 
+        int n1 = m - l + 1; 
+        int n2 = r - m; 
+  
+        /* Create temp arrays */
+        int L[] = new int [n1]; 
+        int R[] = new int [n2]; 
+  
+        /*Copy data to temp arrays*/
+        for (int i=0; i<n1; ++i) 
+            L[i] = arr[l + i]; 
+        for (int j=0; j<n2; ++j) 
+            R[j] = arr[m + 1+ j]; 
+  
+  
+        /* Merge the temp arrays */
+  
+        // Initial indexes of first and second subarrays 
+        int i = 0, j = 0; 
+  
+        // Initial index of merged subarry array 
+        int k = l; 
+        while (i < n1 && j < n2) 
+        { 
+            if (L[i] <= R[j]) 
+            { 
+                arr[k] = L[i]; 
+                i++; 
+            } 
+            else
+            { 
+                arr[k] = R[j]; 
+                j++; 
+            } 
+            k++; 
+        } 
+  
+        /* Copy remaining elements of L[] if any */
+        while (i < n1) 
+        { 
+            arr[k] = L[i]; 
+            i++; 
+            k++; 
+        } 
+  
+        /* Copy remaining elements of R[] if any */
+        while (j < n2) 
+        { 
+            arr[k] = R[j]; 
+            j++; 
+            k++; 
+        } 
+    } 
+  
+    // Main function that sorts arr[l..r] using 
+    // merge() 
+    static void sort(long arr[], int l, int r) 
+    { 
+        if (l < r) 
+        { 
+            // Find the middle point 
+            int m = (l+r)/2; 
+  
+            // Sort first and second halves 
+            sort(arr, l, m); 
+            sort(arr , m+1, r); 
+  
+            // Merge the sorted halves 
+            merge(arr, l, m, r); 
+        } 
+    } 
+    static class Pair implements Comparable<Pair>{
+        int a;
+        int b;
+        Pair(int a,int b){
+            this.a=a;
+ 
+            this.b=b;
+        }   
+        public int compareTo(Pair p){
+            if(a>p.a)
+                return 1;
+            if(a==p.a)
+                return (b-p.b);
+            return -1;
+        }
+    }
+	static class Reader 
+    { 
+        final private int BUFFER_SIZE = 1 << 16; 
+        private DataInputStream din; 
+        private byte[] buffer; 
+        private int bufferPointer, bytesRead; 
+  
+        public Reader() 
+        { 
+            din = new DataInputStream(System.in); 
+            buffer = new byte[BUFFER_SIZE]; 
+            bufferPointer = bytesRead = 0; 
+        } 
+  
+        public Reader(String file_name) throws IOException 
+        { 
+            din = new DataInputStream(new FileInputStream(file_name)); 
+            buffer = new byte[BUFFER_SIZE]; 
+            bufferPointer = bytesRead = 0; 
+        } 
+  
+        public String readLine() throws IOException 
+        { 
+            byte[] buf = new byte[128]; // line length 
+            int cnt = 0, c; 
+            while ((c = read()) != -1) 
+            { 
+                if (c == '\n') 
+                    break; 
+                buf[cnt++] = (byte) c; 
+            } 
+            return new String(buf, 0, cnt); 
+        } 
+  
+        public int nextInt() throws IOException 
+        { 
+            int ret = 0; 
+            byte c = read(); 
+            while (c <= ' ') 
+                c = read(); 
+            boolean neg = (c == '-'); 
+            if (neg) 
+                c = read(); 
+            do
+            { 
+                ret = ret * 10 + c - '0'; 
+            }  while ((c = read()) >= '0' && c <= '9'); 
+  
+            if (neg) 
+                return -ret; 
+            return ret; 
+        } 
+  
+        public long nextLong() throws IOException 
+        { 
+            long ret = 0; 
+            byte c = read(); 
+            while (c <= ' ') 
+                c = read(); 
+            boolean neg = (c == '-'); 
+            if (neg) 
+                c = read(); 
+            do { 
+                ret = ret * 10 + c - '0'; 
+            } 
+            while ((c = read()) >= '0' && c <= '9'); 
+            if (neg) 
+                return -ret; 
+            return ret; 
+        } 
+  
+        public double nextDouble() throws IOException 
+        { 
+            double ret = 0, div = 1; 
+            byte c = read(); 
+            while (c <= ' ') 
+                c = read(); 
+            boolean neg = (c == '-'); 
+            if (neg) 
+                c = read(); 
+  
+            do { 
+                ret = ret * 10 + c - '0'; 
+            } 
+            while ((c = read()) >= '0' && c <= '9'); 
+  
+            if (c == '.') 
+            { 
+                while ((c = read()) >= '0' && c <= '9') 
+                { 
+                    ret += (c - '0') / (div *= 10); 
+                } 
+            } 
+  
+            if (neg) 
+                return -ret; 
+            return ret; 
+        } 
+  
+        private void fillBuffer() throws IOException 
+        { 
+            bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE); 
+            if (bytesRead == -1) 
+                buffer[0] = -1; 
+        } 
+  
+        private byte read() throws IOException 
+        { 
+            if (bufferPointer == bytesRead) 
+                fillBuffer(); 
+            return buffer[bufferPointer++]; 
+        } 
+  
+        public void close() throws IOException 
+        { 
+            if (din == null) 
+                return; 
+            din.close(); 
+        } 
+    } 
+}","//package Current;
+
+import java.util.*;
+
+public class test {
+    static final long mod = (long) 1e9 + 7;
+
+    static class pair {
+        int x, y;
+
+        public pair(int x, int y) {
+            this.x = x;
+            this.y = y;
+        }
+    }
+
+    public static void main(String args[]) {
+
+        Scanner sc = new Scanner(System.in);
+        int t = 1;
+        t = sc.nextInt();
+        while (t-- > 0) {
+            // Start code
+            int n = sc.nextInt();
+            long[] cost = new long[n];
+            long[] a = new long[n];
+            for (int i = 0; i < n; i++) {
+                cost[i] = sc.nextLong();
+                a[i] = cost[i];
+                if (i > 1)
+                    a[i] = Math.min(a[i], a[i - 2]);
+            }
+            long sum = cost[0];
+            long res = Long.MAX_VALUE;
+
+            for (int i = 1; i < n; i++) {
+                sum += cost[i];
+                long cur = sum - a[i] - a[i - 1];
+                int p = (i + 1) / 2;
+                int q = (i + 1) - p;
+                int x = n - p + 1;
+                int y = n - q + 1;
+                cur += (a[i - 1] * x + a[i] * y);
+                res = Math.min(res, cur);
+            }
+            println(res);
+        }
+        sc.close();
+    }
+
+    static void print(Object o) {
+        System.out.print(o + "" "");
+    }
+
+    static void println(Object o) {
+        System.out.println(o);
+    }
+
+    static void swap(int arr[], int i, int j) {
+        int temp = arr[i];
+        arr[i] = arr[j];
+        arr[j] = temp;
+    }
+
+    static ArrayList<Long> factorial(int num) {
+        ArrayList<Long> fac = new ArrayList<>();
+        fac.add((long) 0);
+        fac.add((long) 1);
+
+        for (int i = 2; i < num; i++) {
+            fac.add((fac.get(i - 1) * i) % mod);
+        }
+
+        return fac;
+    }
+
+    static long ncr(long x, long y, ArrayList<Long> fac) {
+        if (y >= x)
+            return (long) 1;
+
+        long res = fac.get((int) x);
+        long z = (fac.get((int) y) * fac.get((int) (x - y))) % mod;
+        z = modInv(z);
+        res = (res * z) % mod;
+        return res;
+    }
+
+    static long modInv(long x) {
+        return modExpo(x, mod - 2);
+    }
+
+    static long modExpo(long x, long y) {
+        long res = 1;
+        x = x % mod;
+        while (y > 0) {
+            if (y % 2 == 1)
+                res = (res * x) % mod;
+            y = y / 2;
+            x = (x * x) % mod;
+        }
+        return res;
+    }
+
+    static int lowerBound(int n, long[] arr, long value) {
+        int res = (int) 1e7;
+        int l = 0, r = n - 1;
+        while (l <= r) {
+            int mid = l + (r - l) / 2;
+            if (arr[mid] >= value) {
+                res = mid;
+                r = mid - 1;
+            } else
+                l = mid + 1;
+        }
+        return res;
+    }
+}
+",0
+0951d079,71a4f6d2,"import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.Stack;
+import java.util.StringTokenizer;
+
+public class D {
+
+	public static void main(String[] args) throws NumberFormatException, IOException {
+		BufferedReader file = new BufferedReader(new InputStreamReader(System.in));
+		int n = Integer.parseInt(file.readLine());
+		int[] heights = new int[n];
+		StringTokenizer st = new StringTokenizer(file.readLine());
+		for(int i = 0; i < n; i++) {
+			heights[i] = Integer.parseInt(st.nextToken());
+		}
+		int[] dp = new int[n];
+		dp[0] = 0;
+		Stack<Integer> high = new Stack<>();
+		Stack<Integer> low = new Stack<>();
+		high.push(0);
+		low.push(0);
+		for(int i = 1; i < n; i++) {
+			dp[i] = dp[i-1]+1;
+			while(!high.isEmpty() && heights[high.peek()] < heights[i]) {
+				dp[i] = Math.min(dp[i], dp[high.peek()]+1);
+				high.pop();
+			}
+			if(!high.isEmpty()) {
+				dp[i] = Math.min(dp[i], dp[high.peek()]+1);
+				if(heights[high.peek()] == heights[i])
+					high.pop();
+			}
+			while(!low.isEmpty() && heights[low.peek()] > heights[i]) {
+				dp[i] = Math.min(dp[i], dp[low.peek()]+1);
+				low.pop();
+			}
+			if(!low.isEmpty()) {
+				dp[i] = Math.min(dp[i], dp[low.peek()]+1);
+				if(heights[low.peek()] == heights[i])
+					low.pop();
+			}
+			high.push(i);
+			low.push(i);
+		}
+		System.out.println(dp[n-1]);
+	}
+
+}
+","import java.io.OutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.PrintWriter;
+import java.util.Vector;
+import java.util.InputMismatchException;
+import java.io.IOException;
+import java.util.Stack;
+import java.io.InputStream;
+
+public class Main {
+    public static void main(String[] args) {
+        InputStream inputStream = System.in;
+        OutputStream outputStream = System.out;
+        InputReader in = new InputReader(inputStream);
+        PrintWriter out = new PrintWriter(outputStream);
+        DDiscreteCentrifugalJumps solver = new DDiscreteCentrifugalJumps();
+        solver.solve(1, in, out);
+        out.close();
+    }
+
+    static class DDiscreteCentrifugalJumps {
+        public void solve(int testNumber, InputReader s, PrintWriter w) {
+            int n = s.nextInt();
+            int[] a = new int[n];
+            for (int i = 0; i < n; i++)
+                a[i] = s.nextInt();
+            int[] dp = new int[n];
+            for (int i = 0; i < n; i++)
+                dp[i] = i;
+            Stack<Integer> dec = new Stack<>();
+            dec.push(0);
+            Stack<Integer> inc = new Stack<>();
+            inc.push(0);
+            for (int i = 1; i < n; i++) {
+                while (!dec.isEmpty() && a[dec.peek()] < a[i]) {
+                    dp[i] = Math.min(dp[i], dp[dec.peek()] + 1);
+                    dec.pop();
+                }
+                if (!dec.isEmpty()) {
+                    dp[i] = Math.min(dp[i], dp[dec.peek()] + 1);
+                    if (a[dec.peek()] == a[i])
+                        dec.pop();
+                }
+                dec.push(i);
+                while (!inc.isEmpty() && a[inc.peek()] > a[i]) {
+                    dp[i] = Math.min(dp[i], dp[inc.peek()] + 1);
+                    inc.pop();
+                }
+                if (!inc.isEmpty()) {
+                    dp[i] = Math.min(dp[i], dp[inc.peek()] + 1);
+                    if (a[inc.peek()] == a[i])
+                        inc.pop();
+                }
+                inc.push(i);
+            }
+            w.println(dp[n - 1]);
+        }
+
+    }
+
+    static class InputReader {
+        private InputStream stream;
+        private byte[] buf = new byte[1024];
+        private int curChar;
+        private int numChars;
+        private InputReader.SpaceCharFilter filter;
+
+        public InputReader(InputStream stream) {
+            this.stream = stream;
+        }
+
+        public int read() {
+            if (numChars == -1) {
+                throw new InputMismatchException();
+            }
+            if (curChar >= numChars) {
+                curChar = 0;
+                try {
+                    numChars = stream.read(buf);
+                } catch (IOException e) {
+                    throw new InputMismatchException();
+                }
+                if (numChars <= 0) {
+                    return -1;
+                }
+            }
+            return buf[curChar++];
+        }
+
+        public int nextInt() {
+            int c = read();
+            while (isSpaceChar(c)) {
+                c = read();
+            }
+            int sgn = 1;
+            if (c == '-') {
+                sgn = -1;
+                c = read();
+            }
+            int res = 0;
+            do {
+                if (c < '0' || c > '9') {
+                    throw new InputMismatchException();
+                }
+                res *= 10;
+                res += c - '0';
+                c = read();
+            } while (!isSpaceChar(c));
+            return res * sgn;
+        }
+
+        public boolean isSpaceChar(int c) {
+            if (filter != null) {
+                return filter.isSpaceChar(c);
+            }
+            return isWhitespace(c);
+        }
+
+        public static boolean isWhitespace(int c) {
+            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
+        }
+
+        public interface SpaceCharFilter {
+            public boolean isSpaceChar(int ch);
+
+        }
+
+    }
+}
+
+",1
+1480a727,a7d1ce58,"/*
+ * Everything is Hard 
+ * Before Easy 
+ * Jai Mata Dii 
+ */ 
+ 
+import java.util.*;
+import java.io.*; 
+  
+public class Main {
+	static class FastReader{ BufferedReader br;StringTokenizer st;public FastReader(){br = new BufferedReader(new InputStreamReader(System.in));}String next(){while (st == null || !st.hasMoreElements()){try{st = new StringTokenizer(br.readLine());}catch (IOException  e){e.printStackTrace();}}return st.nextToken();}int nextInt(){ return Integer.parseInt(next());}long nextLong(){return Long.parseLong(next());}double nextDouble(){return Double.parseDouble(next());}String nextLine(){String str = """"; try{str = br.readLine(); } catch (IOException e) {e.printStackTrace();} return str; }} 
+	static long mod = (long)(1e9+7); 
+//	 static long mod = 998244353; 
+//	 static Scanner sc = new Scanner(System.in); 
+	static FastReader sc = new FastReader(); 
+	static PrintWriter out = new PrintWriter(System.out);
+	public static void main (String[] args) {
+		int ttt = 1;
+		ttt = sc.nextInt();
+		z :for(int tc=1;tc<=ttt;tc++){
+			int n = sc.nextInt();
+			long d[] = new long[n];
+			for(int i=0;i<n;i++) {
+				d[i] = sc.nextLong();
+			}
+			long h[] = new long[n];
+			for(int i=0;i<n;i++) {
+				h[i] = sc.nextLong();
+			}
+			
+			long req[] = new long[n];
+			
+			for(int i=n-1;i>0;i--) {
+				long dif = d[i] - d[i-1];
+				long nxt = 0;
+				if(i+1<n) nxt = req[i+1];
+				long cur = Math.max(nxt, h[i]);
+				if(dif >= cur) {
+					req[i] = 0;
+				}
+				else {
+					req[i] = cur-dif;
+				}
+//				System.out.println(i+"" ""+req[i]);
+			}
+			
+			long ans = 0, prev = 0;
+			
+			for(int i=0;i<n;i++) {
+				if(i == 0) {
+					ans = ans + sumFrom(0, h[i]);
+					prev = h[i];
+				}
+				else {
+					if(req[i] == 0) {
+						ans = ans + sumFrom(0, h[i]);
+						prev = h[i];
+					}
+					else {
+						if(req[i]>prev) {
+							ans = ans + sumFrom(prev, req[i]);
+							ans = ans + sumFrom(req[i], req[i] + (d[i]-d[i-1]));
+							prev = req[i] + d[i] - d[i-1];
+						}
+						else {
+							ans = ans + sumFrom(prev, prev + (d[i]-d[i-1]));
+							prev = prev + d[i] - d[i-1];
+						}
+					}
+				}
+			}
+			
+			out.write(ans+""\n"");
+		}
+		out.close();
+	}
+	private static long sumFrom(long l, long cur) {
+		long is1 = (cur*(cur+1))/2;
+		long is2 = (l*(l+1))/2;
+		
+		return is1 - is2;
+	}
+	static long pow(long a, long b){long ret = 1;while(b>0){if(b%2 == 0){a = (a*a)%mod;b /= 2;}else{ret = (ret*a)%mod;b--;}}return ret%mod;}
+	static long gcd(long a,long b){if(b==0) return  a; return gcd(b,a%b); } 
+	private static void sort(int[] a) {List<Integer> k = new ArrayList<>();for(int val : a) k.add(val);Collections.sort(k);for(int i=0;i<a.length;i++) a[i] = k.get(i);} 
+	private static void ini(List<Integer>[] tre2){for(int i=0;i<tre2.length;i++){tre2[i] = new ArrayList<>();}} 
+	private static void init(List<int[]>[] tre2){for(int i=0;i<tre2.length;i++){tre2[i] = new ArrayList<>();}} 
+	private static void sort(long[] a) {List<Long> k = new ArrayList<>();for(long val : a) k.add(val);Collections.sort(k);for(int i=0;i<a.length;i++) a[i] = k.get(i);} 
+}","import java.util.*;
+import java.io.*;
+ 
+public class AiseHi {
+	static Scanner sc = new Scanner(System.in);
+	static int mod = (int)(1e9+7);
+	static int l;
+	static long dp[][];
+	public static void main (String[] args) {
+		Scanner sc = new Scanner(System.in);
+		int t = sc.nextInt();
+		z : while(t-->0) {
+			int n = sc.nextInt();
+			long dsasds[] = new long[n];
+			for(int i=0;i<n;i++) {
+				dsasds[i] = sc.nextLong();
+			}
+			long dsasdsuyuiyu[] = new long[n];
+			for(int i=0;i<n;i++) {
+				dsasdsuyuiyu[i] = sc.nextLong();
+			}
+			
+			long dsasdsuyuiyubtrtr[] = new long[n];
+			
+			for(int i=n-1;i>0;i--) {
+				long dif = dsasds[i] - dsasds[i-1];
+				long nxt = 0;
+				if(i+1<n) nxt = dsasdsuyuiyubtrtr[i+1];
+				long cur = Math.max(nxt, dsasdsuyuiyu[i]);
+				if(dif >= cur) {
+					dsasdsuyuiyubtrtr[i] = 0;
+				}
+				else {
+					dsasdsuyuiyubtrtr[i] = cur-dif;
+				}
+//				System.out.println(i+"" ""+dsasdsuyuiyubtrtr[i]);
+			}
+			
+			long dsasdscsacsauyuiyubtrtr = 0, kokopmom = 0;
+			
+			for(int i=0;i<n;i++) {
+				if(i == 0) {
+					dsasdscsacsauyuiyubtrtr = dsasdscsacsauyuiyubtrtr + sumFrom(0, dsasdsuyuiyu[i]);
+					kokopmom = dsasdsuyuiyu[i];
+				}
+				else {
+					if(dsasdsuyuiyubtrtr[i] == 0) {
+						dsasdscsacsauyuiyubtrtr = dsasdscsacsauyuiyubtrtr + sumFrom(0, dsasdsuyuiyu[i]);
+						kokopmom = dsasdsuyuiyu[i];
+					}
+					else {
+						if(dsasdsuyuiyubtrtr[i]>kokopmom) {
+							dsasdscsacsauyuiyubtrtr = dsasdscsacsauyuiyubtrtr + sumFrom(kokopmom, dsasdsuyuiyubtrtr[i]);
+							dsasdscsacsauyuiyubtrtr = dsasdscsacsauyuiyubtrtr + sumFrom(dsasdsuyuiyubtrtr[i], dsasdsuyuiyubtrtr[i] + (dsasds[i]-dsasds[i-1]));
+							kokopmom = dsasdsuyuiyubtrtr[i] + dsasds[i] - dsasds[i-1];
+						}
+						else {
+							dsasdscsacsauyuiyubtrtr = dsasdscsacsauyuiyubtrtr + sumFrom(kokopmom, kokopmom + (dsasds[i]-dsasds[i-1]));
+							kokopmom = kokopmom + dsasds[i] - dsasds[i-1];
+						}
+					}
+				}
+			}
+			
+			System.out.println(dsasdscsacsauyuiyubtrtr);
+		}
+	}
+
+	private static long sumFrom(long l, long cur) {
+		long is1 = (cur*(cur+1))/2;
+		long is2 = (l*(l+1))/2;
+		
+		return is1 - is2;
+	}
+
+	private static long solve(int i, int k, int pre, int a[], int dsasds[]) {
+		if(i == a.length) {
+			int dsasdsuyuiyubtrtr = pre*(l-dsasds[i-1]);
+			return dsasdsuyuiyubtrtr;
+		}
+		
+		if(dp[i][k]!=-1) return dp[i][k];
+		long cans = Integer.MAX_VALUE;
+		
+		if(k>0) {
+			cans = 1L*pre*(dsasds[i]-dsasds[i-1]) + solve(i+1, k-1, pre, a, dsasds);
+		}
+		cans = Math.min(cans, 1L*pre*(dsasds[i]-dsasds[i-1]) + solve(i+1, k, a[i], a, dsasds));
+		
+		return dp[i][k] = cans;
+	}
+	private static boolean same(char[] a, char[] b) {
+		for(int i=0;i<a.length;i++) {
+			if(a[i]!=b[i]) return false;
+		}
+		return true;
+	}
+	private static boolean isPos(List<long[]> val, long mid) {
+		for(int i=0;i<val.size();i++) {
+			for(int j=0;j<val.get(i).length-1;j++) {
+				if(val.get(i)[j]>=mid) return false;
+				mid = mid + 1;
+			}
+		}
+		return true;
+	}
+	static long fac[] = new long[100006];
+	
+	static void precompute() {
+		int n = 100005;
+		fac[0] = 1;
+		for(int i=1;i<=n;i++)
+			fac[i] = (i * fac[i-1])%mod;
+	}
+	
+	static long power(long base, long p, long mod2) {
+		
+		long dsasdscsacsauyuiyubtrtr = 1;
+		while(p!=0) {
+			if(p%2==0) {
+				base = (base*base)%mod2;
+				p/=2;
+			}
+			else {
+				dsasdscsacsauyuiyubtrtr = (dsasdscsacsauyuiyubtrtr*base)%mod2;
+				p-=1;
+			}
+		}
+		return (int) (dsasdscsacsauyuiyubtrtr%mod2);
+	}
+	private static boolean checkl(char[] s, char t[]) {
+		int i=0, j =0;
+		while(i<s.length && j<t.length) {
+			if(s[i] == t[j]) {
+				j++;
+			}
+			i++;
+		}
+		return j==t.length;
+	}
+	static int gcd(long a,long b) { if(b==0) return (int) a; return gcd(b,a%b); } 
+	private static int findn(int[] a, int l, int dsasdsuyuiyu, long m) {
+		int ret = -1;
+		while(l<=dsasdsuyuiyu) {
+			int mid = (l+dsasdsuyuiyu)/2;
+			if(a[mid]>m) {
+				dsasdsuyuiyu = mid-1;
+			}
+			else {
+				ret = mid;
+				l = mid+1;
+			}
+		}
+		return ret;
+	}
+	private static int find(int[] a, int l, int dsasdsuyuiyu, long m) {
+		int ret = -1;
+		while(l<=dsasdsuyuiyu) {
+			int mid = (l+dsasdsuyuiyu)/2;
+			if(a[mid]>=m) {
+				ret = mid;
+				dsasdsuyuiyu = mid-1;
+			}
+			else l = mid+1;
+		}
+		return ret;
+	}
+	private static boolean find(String ini, String a) {
+		return !KMPSearch(ini,a);
+	}
+	static boolean KMPSearch(String pat, String txt)
+    {
+        int M = pat.length();
+        int N = txt.length();
+ 
+        int lps[] = new int[M];
+        int j = 0; 
+        
+        computeLPSArray(pat, M, lps);
+  
+        int i = 0; 
+        while (i < N) {
+            if (pat.charAt(j) == txt.charAt(i)) {
+                j++;
+                i++;
+            }
+            if (j == M) {
+                j = lps[j - 1];
+                return true;
+            }
+            else if (i < N && pat.charAt(j) != txt.charAt(i)) {
+                if (j != 0)
+                    j = lps[j - 1];
+                else
+                    i = i + 1;
+            }
+        }
+        return false;
+    }
+  
+    static void computeLPSArray(String pat, int M, int lps[])
+    {
+        int len = 0;
+        int i = 1;
+        lps[0] = 0; // lps[0] is always 0
+  
+        // the loop calculates lps[i] for i = 1 to M-1
+        while (i < M) {
+            if (pat.charAt(i) == pat.charAt(len)) {
+                len++;
+                lps[i] = len;
+                i++;
+            }
+            else // (pat[i] != pat[len])
+            {
+                // This is tricky. Consider the example.
+                // AAACAAAA and i = 7. The idea is similar
+                // to search step.
+                if (len != 0) {
+                    len = lps[len - 1];
+  
+                    // Also, note that we do not increment
+                    // i here
+                }
+                else // if (len == 0)
+                {
+                    lps[i] = len;
+                    i++;
+                }
+            }
+        }
+    }
+//	private static boolean check(long n,long val) {
+//		if(n == 0) return true;
+//		
+//		while(val<=n) {
+////			if(check(n-val,))
+//		}
+//	}
+	private static int find(int[] a, TreeMap<Integer, Integer> ts, int lp) {
+		int ret = 1;
+		int idx = -1;
+		for(int i=a.length-1;i>=0;i--) {
+			if(a[i] == lp) {
+				idx = i;
+				break;
+			}
+		}
+		idx--;
+		int kokopmom = lp;
+		while(idx>=0) {
+			if((kokopmom - a[idx]) >= lp) {
+				ret++;
+				kokopmom = a[idx];
+			}
+			idx--;
+		}
+		return ret;
+	}
+	private static void reverse(char[] s) {
+		char a[] = new char[s.length];
+		for(int i=0;i<s.length;i++) a[i] = s[i];
+		for(int i=0;i<s.length;i++)
+			s[i] = a[a.length-1-i];
+	}
+	private static boolean isPalindrome(char[] s) {
+		int n = s.length;
+		for(int i=0;i<n/2;i++)
+			if(s[i]!=s[n-1-i]) return false;
+		return true;
+	}
+	private static boolean is(char[] s) {
+		for(char c : s) if(c == '0') return false;
+		return true;
+	}
+//	static int ceil(int a,int b) {
+//		return a/b + (a%b==0?0:1);
+//	}
+	static boolean prime[] = new boolean[2000009];
+//	static int fac[] = new int[2000009];
+	
+	static void sieve() {
+		prime[0] = true;
+		prime[1] = true;
+		int max = 1000000;
+		for(int i=2;i*i<=max;i++) {
+			if(!prime[i]) {
+				for(int j=i*i;j<=max;j+=i) {
+					prime[j] = true;
+//					fac[j] = i;
+				}
+			}
+		}
+	}
+//	static long gcd(long a,long b) { if(b==0) return a; return gcd(b,a%b); }
+}
+ 
+class DSU {
+	int par[];
+	int size[];
+	DSU(int n) {
+		par = new int[n];
+		size = new int[n];
+		Arrays.fill(size, 1);
+		for(int i=0;i<n;i++) par[i] = i;
+	}
+	int findPar(int x) {
+		if(x == par[x]) return x;
+		
+		return par[x] = findPar(par[x]);
+	}
+	boolean join(int u,int v) {
+		int fu = findPar(u);
+		int fv = findPar(v);
+		if(fu!=fv) {
+			if(size[fu]>size[fv]) {
+				par[fv] = fu;
+				size[fu] += size[fv];
+			}
+			else {
+				par[fu] = fv;
+				size[fv] += size[fu];
+			}
+			return true;
+		}
+		else return false;
+	}
+}
+
+class pair{
+	long val;
+	char c;
+	pair(long val, char c){
+		this.val = val;
+		this.c = c;
+	}
+}",1
+3bd7275e,8635bc10,"// ＼(≧▽≦)／
+// Terminus
+// TODO : get good
+
+import java.io.*;
+import java.util.*;
+
+public class tank {
+
+    static final FastScanner fs = new FastScanner();
+
+    static PrintWriter out = new PrintWriter(System.out);
+
+    public static void main(String[] args) {
+        int t = fs.nextInt();
+        while(t-- > 0) run_case();
+
+        out.close();
+    }
+
+    static void run_case() {
+        int n = fs.nextInt();
+        long k = fs.nextLong();
+        int[] a = fs.readArray(n);
+
+        ruffleSort(a);
+
+        long sum = 0;
+
+        for(int i: a) sum += i;
+
+        if(sum <= k) {
+            out.println(0);
+            return;
+        }
+
+        long ans = sum - k, dif;
+
+        for (int i = 1; i < n; i++) {
+            sum -= a[n - i];
+            sum += a[0];
+            //out.println(sum);
+            if(sum <= k) {
+                ans = Math.min(ans, i);
+                continue;
+            }
+            dif = sum - k;
+            if(dif % (i + 1) == 0) {
+                ans = Math.min(ans, dif / (i + 1) + i);
+            } else {
+                ans = Math.min(ans, dif / (i + 1) + 1 + i);
+            }
+        }
+
+        out.println(ans);
+    }
+
+    static void ruffleSort(int[] a) {
+        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);
+    }
+
+    static class FastScanner {
+        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st=new StringTokenizer("""");
+        String next() {
+            while (!st.hasMoreTokens())
+                try {
+                    st=new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            return st.nextToken();
+        }
+
+        String nextLine(){
+            try {
+                return br.readLine();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+
+            return """";
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        int[] readArray(int n) {
+            int[] a=new int[n];
+            for (int i=0; i<n; i++) a[i]=nextInt();
+            return a;
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+    }
+}","import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.Arrays;
+import java.util.StringTokenizer;
+
+
+public class C{
+
+//    static int N = 200010;
+    static int n;
+    static long k;
+    static long[] a;
+    static long[] s;
+
+    public static void main(String[] args){
+
+//        Scanner sc = new Scanner(System.in);
+        FastScanner sc = new FastScanner();
+        int T = sc.nextInt();
+        while(T-- > 0){
+            n = sc.nextInt();
+            k = sc.nextLong();
+//            a = sc.readArray(n);
+            a = new long[n + 1];
+            for(int i = 1; i <= n; i++) a[i] = sc.nextInt();
+            System.out.println(slover());
+        }
+    }
+
+    static long slover(){
+
+        Arrays.sort(a);
+        // for(int i = 1; i <= n; i++) System.out.print(a[i] + "" "");
+        // System.out.println();
+        s = new long[n + 1];
+        for(int i = 1; i <= n; i++) s[i] = s[i - 1] + a[i];
+        // System.out.println(s[n]);
+        long res = (long)1e10;
+        // 能枚举进行赋值操作的元素个数
+        for(int i = 1; i <= n; i++){
+//            long selected = (n - i) * a[1]; // 最小的替换(n - i)
+            long t;
+            if(s[i] + (n-i)*a[1] - k <= 0) t = 0;
+            else t = (long) Math.ceil((s[i] + (n-i) * a[1] - k) * 1.0 / (n-i+1));
+//            if(selected + s[i] <= k){
+//                t = 0;
+//            }else{
+//                // System.out.println(""get in"");
+//                t = (long)Math.ceil((s[i] + selected - k) * 1.0 / (1 + n - i));
+//            }
+
+            res = Math.min(res, n - i + t);
+            // System.out.println((n - i) + "" -> "" + (s[i] + selected - k) + "" "" + (1 + n - i) + "" ->"" + res);
+        }
+        return res;
+    }
+
+    static class FastScanner {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st = new StringTokenizer("""");
+        String next(){
+            while(!st.hasMoreTokens()){
+                try{
+                    st = new StringTokenizer(br.readLine());
+                }catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+        int nextInt(){
+            return Integer.parseInt(next());
+        }
+
+        int[] readArray(int n){
+            int[] a = new int[n];
+            for(int i = 0; i < n; i++) a[i] = nextInt();
+            return a;
+        }
+
+        long nextLong(){
+            return Long.parseLong(next());
+        }
+    }
+
+}",0
+3088ca9c,f6ed6826,"import java.util.*;
+import java.io.*;
+
+
+public class MyClass {
+    public static void main(String args[]) {
+     Scanner sc = new Scanner(System.in);
+     int t = sc.nextInt();
+     while(t>0)
+     {
+         int n = sc.nextInt();
+         sc.nextLine();
+         String [] str = new String[n];
+         int res = 0;
+         for(int i=0;i<n;i++)
+         {
+             str[i]=sc.nextLine();
+         }
+         int [][] freq = new int [n][5];
+         for(int i=0;i<n;i++)
+         {
+             for(int j=0;j<str[i].length();j++)
+             {
+                 int k = str[i].charAt(j)-'a';
+                 freq[i][k]++;
+             }
+         }
+         for(int i=0;i<5;i++)
+         {
+             int [] arr = new int[n];
+             for(int j=0;j<n;j++)
+             {
+                 int pos = freq[j][i];
+                 int sum=0;
+                 for(int k = 0;k<5;k++)
+                 {
+                     sum+=freq[j][k];
+                 }
+                 sum-=pos;
+                 arr[j]=(pos-sum);
+             }
+             Arrays.sort(arr);
+            //  int p = n-1;
+             int count=0;
+             int sum=0;
+             for(int p=n-1;p>=0;p--)
+             {
+                 sum+=arr[p];
+                 if(sum>0)
+                 {
+                     count++;
+                 }
+                 else
+                 {
+                     break;
+                 }
+             }
+             res=Math.max(count , res);
+         }
+         
+         System.out.println(res);
+         t--;
+         
+     }
+    }
+}","
+import java.util.*;
+
+
+import java.io.*;
+ public class Solution {
+		static FastScanner scr=new FastScanner();
+//		static Scanner scr=new Scanner(System.in);
+		static PrintStream out=new PrintStream(System.out);
+		static StringBuilder sb=new StringBuilder();
+		
+		
+		
+		
+		static class pair{
+			int x;int y;
+			pair(int x,int y){ 
+				this.x=x;this.y=y;
+				
+			}
+		}
+		static class triplet{
+			int x;
+			long y;
+			int z;
+			triplet(int x,long y,int z){
+				this.x=x;
+				this.y=y;
+				this.z=z;
+			}
+		}
+		static class FastScanner {
+			 BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+			StringTokenizer st=new StringTokenizer("""");
+		 	String next() {
+		 		while (!st.hasMoreTokens())
+		 			try {
+		 				st=new StringTokenizer(br.readLine());
+		 			} catch (IOException e) {
+		 				e.printStackTrace();
+		 			}
+		 			return st.nextToken();
+			} long gcd(long a,long b){
+				if(b==0) {
+					return a;
+				}
+					
+				return gcd(b,a%b);
+			}
+		 	int[]  sort(int a[]) {
+				 
+		        int multiplier = 1, len = a.length, max = Integer.MIN_VALUE;
+		        int b[] = new int[len];
+		        int bucket[];
+		        for (int i = 0; i < len; i++) if (max < a[i]) max = a[i];
+		        while (max / multiplier > 0) {
+		            bucket = new int[10];
+		            for (int i = 0; i < len; i++) bucket[(a[i] / multiplier) % 10]++;
+		            for (int i = 1; i < 10; i++) bucket[i] += (bucket[i - 1]);
+		            for (int i = len - 1; i >= 0; i--) b[--bucket[(a[i] / multiplier) % 10]] = a[i];
+		            for (int i = 0; i < len; i++) a[i] = b[i];
+		            multiplier *= 10;
+		        }
+		        return a;
+		    }
+		 	 long modPow(long base,long exp) {
+				if(exp==0) {
+					return 1;
+				}
+				if(exp%2==0) {
+					long res=(modPow(base,exp/2));
+					return (res*res);
+				}
+				return (base*modPow(base,exp-1));
+			}
+			int []reverse(int a[]){
+				int b[]=new int[a.length];
+				int index=0;
+				for(int i=a.length-1;i>=0;i--) {
+					b[index]=a[i];
+				}
+				return b;
+			}
+			int nextInt() {
+				return Integer.parseInt(next());
+			}
+			int[] readArray(int n) {
+				int[] a=new int[n];
+				for (int i=0; i<n; i++) a[i]=nextInt();
+				return a;
+			}
+			long[] readLongArray(int n) {
+				long  [] a=new long  [n];
+				for (int i=0; i<n; i++) a[i]=nextLong();
+				return a;
+			}
+			long nextLong() {
+				return Long.parseLong(next());
+			}
+		}
+		
+		static HashMap<Character,ArrayList<Integer>>hm=new HashMap<>();
+		static void solve() {
+			int n=scr.nextInt();
+			
+			int count[]=new int[5];
+			int store[][]=new int[n][5];
+			int max=MIN;
+			int length[]=new int[n];
+			for(int i=0;i<n;i++) {
+				String s=scr.next();
+				length[i]=s.length();
+				for(int j=0;j<s.length();j++) {
+					store[i][s.charAt(j)-'a']++;
+					count[s.charAt(j)-'a']++;
+				}
+			}
+			
+			for(int j=0;j<5;j++) {
+				
+				ArrayList<Integer>a=new ArrayList<>();
+				for(int i=0;i<n;i++) {
+					a.add((store[i][j]*2)-length[i]);
+				}
+				
+				Collections.sort(a,Collections.reverseOrder());
+				
+				long sum=0;
+				int ans=0;
+				for(int i=0;i<a.size();i++) {
+					sum+=a.get(i);
+					if(sum>0) {
+						ans++;
+					}else {
+						break;
+					}
+				}
+				max=Math.max(max, ans);
+			}
+			out.println(max);
+			
+		}
+		static int  MAX = Integer.MAX_VALUE;
+		static int  MIN = Integer.MIN_VALUE;
+		public static void main(String []args) {
+			int t=scr.nextInt();
+			while(t-->0) {
+				solve();
+			}
+//			solve();
+//			out.println(sb);
+		}
+	}
+ 	",0
+4d279121,a3e272af,"import java.util.*;
+import java.io.*;
+        
+@SuppressWarnings(""unchecked"")
+public class Main {
+    public static void main(String args[]) {    
+        FastReader input = new FastReader();
+        PrintWriter out = new PrintWriter(System.out);
+        int t = input.nextInt();
+        while(t-- > 0) {
+        int n = input.nextInt();
+        int m = input.nextInt();
+        int x = input.nextInt();
+        int arr[] = new int[n];
+        for(int i = 0; i < n; i++) arr[i] = input.nextInt(); 
+        PriorityQueue<Pair> queue = new PriorityQueue();
+        out.println(""YES"");
+        int res[] = new int[n];
+        for(int i = 1; i <= m; i++) {
+            queue.add(new Pair(0, i));
+        }
+        for(int i = 0; i < n; i++) {
+            Pair p = queue.remove();
+            out.print(p.second()+"" "");
+            queue.add(new Pair(p.first()+arr[i], p.second()));    
+        }
+        out.println();
+        out.flush();
+        }
+    }   
+}
+ 
+class Pair implements Comparable<Pair> {    
+    public int x;
+    public int y;
+ 
+    public Pair(int x, int y) {
+        this.x = x;
+        this.y = y;
+    }
+ 
+    public int first() {
+        return x;
+    }
+    public int second() {
+        return y;
+    }
+ 
+    public int compareTo(Pair p) {
+        if(this.first() == p.first()) {
+            return 0;
+        }else if(this.first() > p.first()) {
+            return 1;
+        }else {
+            return -1;
+        }
+    } 
+}
+ 
+class FastReader {
+    BufferedReader br;
+    StringTokenizer st;
+    
+    public FastReader() {
+        br = new BufferedReader(new InputStreamReader(System.in));
+    }
+    public String next() {
+        while(st == null || !st.hasMoreElements()) {
+            try {
+                st = new StringTokenizer(br.readLine());
+            }catch(Exception e) {
+                System.out.println(e);
+            }
+        }     
+        return st.nextToken();
+    }
+    public int nextInt() {
+        return Integer.parseInt(next());
+    }
+ 
+    public long nextLong() {
+        return Long.parseLong(next());
+    }
+ 
+    public String getString() {
+        return next();
+    }
+}","
+import java.io.*;
+import java.util.*;
+
+public class Asd {
+
+    static PrintWriter w = new PrintWriter(System.out);
+    static FastScanner s = new FastScanner();
+    static boolean sd = false;
+  
+    public static void main(String[] args) {
+
+       int t = s.nextInt();
+        //int t=1;
+        while (t-- > 0) {
+            solve();
+        }
+        w.close();
+
+    }
+  public static class Student {
+    public int i1;
+    public int value;
+          
+    // A parameterized student constructor
+    public Student(int i1,int i2) {
+      
+        this.i1 = i1;
+        this.value=i2;
+    }
+      
+    public int getkey() {
+        return i1;
+    } 
+    public int getValue() {
+        return value;
+    } 
+}
+   static class StudentComparator implements Comparator<Student>{
+              
+            // Overriding compare()method of Comparator 
+                        // for descending order of cgpa
+        @Override   
+        public int compare(Student s1, Student s2) {
+                if (s1.i1 < s2.i1)
+                    return -1;
+                else if (s1.i1 >s2.i1)
+                    return 1;
+                                return 0;
+                }
+        }
+    
+    /* Function to print all the permutations of the string
+     static String swap(String str, int i, int j)
+     {
+     char ch;
+     char[] array = str.toCharArray();
+     ch = array[i];
+     array[i] = array[j];
+     array[j] = ch;
+     return String.valueOf(array);
+     }
+    
+     static void permute(String str,int low,int high)
+     {
+     if(low == high)
+     list.add(Long.parseLong(str));
+ 
+     int i;
+     for(i = low; i<=high; i++){
+     str = swap(str,low,i);
+     permute(str, low+1,high);
+     str = swap(str,low,i);
+     }
+     }
+     use  permute(str2,0,str2.length()-1); to perform combinations
+     */
+
+    public static void solve() {
+        int n=s.nextInt();
+        int m=s.nextInt();
+        int x=s.nextInt();
+        int arr[]=new int[n];int res[]=new int[n];
+        for(int i=0;i<n;i++)
+            arr[i]=s.nextInt();
+        
+        PriorityQueue<Student> pq=new PriorityQueue<Student>(new StudentComparator());
+        for(int i=0;i<m;i++){
+            pq.add(new Student(arr[i],i));res[i]=i;}
+        for(int i=m;i<n;i++)
+        {
+            Student s1=pq.poll();
+            int k2=s1.getkey()+arr[i];
+            int v2=s1.getValue();res[i]=v2;
+            pq.add(new Student(k2,v2));
+        }
+        w.println(""YES"");
+        for(int i=0;i<n;i++)
+            w.print(res[i]+1+"" "");
+        w.println();
+       
+    }
+
+    static void call(ArrayList<Integer> t, ArrayList<Integer> m) {
+        if (t.size() == 0 && m.size() == 0) {
+            sd = true;
+            return;
+        }
+        t.remove(0);
+        t.remove(t.size() - 1);
+        call(t, new ArrayList<Integer>(m.subList(0, m.size() - 1)));
+        call(t, new ArrayList<Integer>(m.subList(1, m.size())));
+    }
+
+    static long gcd(long a, long b) {
+        if (b == 0) {
+            return a;
+        }
+        return gcd(b, a % b);
+    }
+
+    static int noofdivisors(int n) {
+            //it counts no of divisors of every number upto number n
+
+        int arr[] = new int[n + 1];
+        for (int i = 1; i <= (n); i++) {
+            for (int j = i; j <= (n); j = j + i) {
+                arr[j]++;
+            }
+        }
+        return arr[0];
+    }
+
+    static char[] reverse(char arr[]) {
+        char[] b = new char[arr.length];
+        int j = arr.length;
+        for (int i = 0; i < arr.length; i++) {
+            b[j - 1] = arr[i];
+            j = j - 1;
+        }
+        return b;
+    }
+
+    static long factorial(int n) {
+        long su = 1;
+        for (int i = 1; i <= n; i++) {
+            su *= (long) i;
+        }
+        return su;
+    }
+
+    static class FastScanner {
+
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st = new StringTokenizer("""");
+
+        public String next() {
+            while (!st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        long[] readArray(int n) {
+            long[] a = new long[n];
+            for (int i = 0; i < n; i++) {
+                a[i] = nextLong();
+            }
+            return a;
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+    }
+
+}
+",0
+9debf95c,ac596a43,"//    A Computer is Like a mischievous genie.
+//    It will give you exactly what you ask for,
+//    but not always what you want
+//    A code by Rahul Verma
+
+
+import java.io.BufferedOutputStream;
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.PriorityQueue;
+import java.util.Queue;
+import java.util.Stack;
+import java.util.StringTokenizer;
+import java.util.TreeMap;
+
+
+public class Main {
+
+
+    static class Clock {
+
+        protected long start, stop;
+
+        public void start() {
+            start = System.currentTimeMillis();
+        }
+
+        public void stop() {
+            stop = System.currentTimeMillis();
+        }
+
+        public String getTime() {
+            return ((stop - start) + "" ms"");
+        }
+    }
+
+
+    public static PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
+
+    static class FastReader {
+
+        BufferedReader br;
+        StringTokenizer st;
+
+        public FastReader() {
+            br = new BufferedReader(new
+                InputStreamReader(System.in));
+        }
+
+        String next() {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+
+        String[] nextSArray() {
+            String sr[] = null;
+            try {
+                sr = br.readLine().trim().split("" "");
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            return sr;
+        }
+
+        String nextLine() {
+            String str = """";
+            try {
+                str = br.readLine();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+
+            return str;
+        }
+    }
+
+
+    static long powmodulo(long a, long p) {
+        if (p == 0) {
+            return 1 % mod;
+        }
+        if (p == 1) {
+            return a % mod;
+        }
+        long ans = 1;
+        while (p > 0) {
+            if ((p & 1) > 0) {
+                ans = (ans * a) % mod;
+            }
+            a = (a * a) % mod;
+            p = p >> 1;
+        }
+        return ans % mod;
+    }
+
+
+    static long mod = 1000000007;
+
+    static long gcd(long a, long b) {
+        if (a == 0) {
+            return b;
+        }
+        return gcd(b % a, a);
+    }
+
+    static long fast_powerNumbers(long a, long n) {
+        if (n == 1) {
+            return a;
+        }
+        long ans = fast_powerNumbers(a, n / 2);
+        if (n % 2 == 0) {
+            return (ans * ans);
+        } else {
+            return ((ans * ans) * (a));
+        }
+    }
+
+
+    static void dfs_helper(int[][] arr, int i, int j, int team, int n, int m) {
+        arr[i][j] = team;
+        if (i - 1 >= 0 && arr[i - 1][j] == 1) {
+            dfs(arr, i - 1, j, team, n, m);
+        }
+        if (j - 1 >= 0 && arr[i][j - 1] == 1) {
+            dfs(arr, i, j - 1, team, n, m);
+        }
+        if (i + 1 < n && arr[i + 1][j] == 1) {
+            dfs(arr, i + 1, j, team, n, m);
+        }
+        if (j + 1 < m && arr[i][j + 1] == 1) {
+            dfs(arr, i, j + 1, team, n, m);
+        }
+
+    }
+
+    static void dfs(int[][] arr, int i, int j, int team, int n, int m) {
+        dfs_helper(arr, i, j, team, n, m);
+
+    }
+
+    static int parent[];
+    static int rank[];
+
+    static int find(int i) {
+        if (parent[i] == -1) {
+            parent[i] = i;
+            return i;
+        }
+
+        if (parent[i] == i) {
+            return i;
+        } else {
+            parent[i] = find(parent[i]);
+        }
+        return parent[i];
+
+    }
+
+    static void unite(int s1, int s2) {
+
+        if (rank[s1] > rank[s2]) {
+            parent[s2] = s1;
+            rank[s1] += rank[s2];
+        } else {
+            parent[s1] = s2;
+            rank[s2] += rank[s1];
+        }
+    }
+
+
+    public static long arr[];
+    public static int arr1[];
+
+//    static void seive(int n) {
+//        arr = new int[n + 1];
+//        arr[0] = arr[1] = 1;
+//        for (int i = 4; i <= n; i = i + 2) {
+//            arr[i] = 1;
+//        }
+//        for (int i = 3; i * i <= n; i = i + 2) {
+//            if (arr[i] == 0) {
+//                for (int j = i * i; j <= n; j = j + i) {
+//                    arr[j] = 1;
+//                }
+//
+//            }
+//        }
+//    }
+
+    static  void seive(int n)
+    {
+        arr1=new int[n+1];
+        arr1[0]=arr1[1]=1;
+        for (int i = 4; i <=n ; i+=2) {
+            arr1[i]=1;
+        }
+        for (int i = 3; i*i <=n ; i+=2) {
+            if (arr1[i] == 0)
+            {
+                for (int j = i*i; j <=n ; j+=i) {
+                    arr1[j]=1;
+                }
+            }
+        }
+
+    }
+
+    public static boolean ccw(Point a,Point b,Point c)
+    {
+        long s1=(c.x-b.x)*(b.y-a.y) ;
+        long s2 = (c.y-b.y)*(b.x-a.x);
+        if(s1<s2)
+            return true;
+        else
+            return false;
+
+    }
+    public static boolean col(Point a,Point b,Point c)
+    {
+        long s1=(c.x-b.x)*(b.y-a.y) ;
+        long s2 = (c.y-b.y)*(b.x-a.x);
+        if(s1==s2)
+            return true;
+        else
+            return false;
+    }
+    static class Point
+    {
+        long x,y;
+        Point(long x,long y)
+        {
+            this.x=x;
+            this.y=y;
+        }
+    }
+
+    public static void main(String[] args) throws Exception {
+        FastReader sc = new FastReader();
+
+        Clock clock = new Clock();
+        clock.start();
+       int t1=sc.nextInt();
+        for (int t = 0; t <t1 ; t++) {
+          int n=sc.nextInt();
+          long arr[]=new long[n];
+            for (int i = 0; i < n; i++) {
+                arr[i]=sc.nextLong();
+            }
+          long sum1=0;
+          long sum2=0;
+          long min1 =Long.MAX_VALUE;
+          long min2 =Long.MAX_VALUE;
+          long brr[]=new long[n];
+            for (int i = 0; i <n ; i+=2) {
+
+                int nn =i/2;
+                min1=Math.min(arr[i],min1);
+                sum1+=arr[i];
+                long x =(sum1-min1) + min1*(n-nn);
+               // System.out.println(x);
+               brr[i]=x;
+
+            }
+            for (int i = 1; i <n ; i+=2) {
+                int nn =i/2;
+
+                //System.out.println(x);
+                min2=Math.min(arr[i],min2);
+                sum2+=arr[i];
+                long x =(sum2-min2) + min2*(n-nn);
+                brr[i]=x;
+            }
+            long min=Long.MAX_VALUE;
+            for (int i = 1; i < n; i++) {
+                min=Math.min(brr[i]+brr[i-1],min);
+            }
+            out.println(min);
+            //out.println(Arrays.toString(brr));
+
+           // System.out.println(min1+"" ""+min2);
+
+        }
+        out.close();
+
+
+    }
+
+
+}
+
+class Trio{
+    int a,i1,i2;
+    Trio(int a,int i1,int i2)
+    {
+        this.a=a;
+        this.i1=i1;
+        this.i2=i2;
+    }
+}
+
+class Pair{
+
+    int a,b;
+    Pair(int a,int b)
+    {
+        this.a=a;
+        this.b=b;
+    }
+}
+class DSU
+{
+    int parent[];
+    int rank[];
+    long arr[] = Main.arr;
+    long sum[] ;
+    DSU(int n)
+    {
+        this.parent=new int[n];
+        this.rank=new int[n];
+        sum=new long[n];
+        Arrays.fill(parent,-1);
+        Arrays.fill(rank,1);
+        for (int i = 0; i <n ; i++) {
+            sum[i]=arr[i];
+        }
+    }
+
+    int find(int s1)
+    {
+        if(parent[s1]==-1)
+            return s1;
+        return parent[s1]=find(parent[s1]);
+    }
+
+    void unite(int s1,int s2)
+    {
+        int p1=this.find(s1);
+        int p2=this.find(s2);
+        if(p1==p2)
+            return;
+        if(rank[p1]>rank[p2])
+        {
+            parent[p2]=p1;
+            rank[p1]+=rank[p2];
+            // System.out.println(arr[p2]);
+
+            sum[p1]+=sum[p2];
+            //sum[p2]+=sum[p1];
+
+        }
+        else
+        {
+            parent[p1]=p2;
+            rank[p2]+=rank[p1];
+            //System.out.println(arr[p1]);
+            sum[p2]+=sum[p1];
+            //sum[p1]+=sum[p2];
+        }
+    }
+
+
+}
+
+class Gaph {
+
+    HashMap<Integer, ArrayList<Integer>> hm;
+
+    Gaph() {
+        hm = new HashMap<>();
+    }
+
+    Gaph(int n) {
+
+        hm = new HashMap<>();
+        for (int i = 0; i < n; i++) {
+            hm.put(i, new ArrayList<Integer>());
+        }
+    }
+
+    // function for adding an edge.................................................
+    public void addEdge(int a, int b, boolean isDir) {
+        if (isDir) {
+            if (hm.containsKey(a)) {
+                hm.get(a).add(b);
+            } else {
+                hm.put(a, new ArrayList<>(Arrays.asList(b)));
+            }
+        } else {
+            if (hm.containsKey(a)) {
+                hm.get(a).add(b);
+            } else if (!hm.containsKey(a)) {
+                hm.put(a, new ArrayList<>(Arrays.asList(b)));
+            }
+
+            if (hm.containsKey(b)) {
+                hm.get(b).add(a);
+            } else if (!hm.containsKey(b)) {
+                hm.put(b, new ArrayList<>(Arrays.asList(a)));
+            }
+        }
+    }
+
+
+}
+
+// out.println(al.toString().replaceAll(""[\\[|\\]|,]"",""""));
+
+
+","//    A Computer is Like a mischievous genie.
+//    It will give you exactly what you ask for,
+//    but not always what you want
+//    A code by Rahul Verma
+
+
+import java.io.BufferedOutputStream;
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.PriorityQueue;
+import java.util.Queue;
+import java.util.Stack;
+import java.util.StringTokenizer;
+import java.util.TreeMap;
+
+
+public class Main {
+
+
+    static class Clock {
+
+        protected long start, stop;
+
+        public void start() {
+            start = System.currentTimeMillis();
+        }
+
+        public void stop() {
+            stop = System.currentTimeMillis();
+        }
+
+        public String getTime() {
+            return ((stop - start) + "" ms"");
+        }
+    }
+
+
+    public static PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
+
+    static class FastReader {
+
+        BufferedReader br;
+        StringTokenizer st;
+
+        public FastReader() {
+            br = new BufferedReader(new
+                InputStreamReader(System.in));
+        }
+
+        String next() {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+
+        String[] nextSArray() {
+            String sr[] = null;
+            try {
+                sr = br.readLine().trim().split("" "");
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            return sr;
+        }
+
+        String nextLine() {
+            String str = """";
+            try {
+                str = br.readLine();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+
+            return str;
+        }
+    }
+
+
+    static long powmodulo(long a, long p) {
+        if (p == 0) {
+            return 1 % mod;
+        }
+        if (p == 1) {
+            return a % mod;
+        }
+        long ans = 1;
+        while (p > 0) {
+            if ((p & 1) > 0) {
+                ans = (ans * a) % mod;
+            }
+            a = (a * a) % mod;
+            p = p >> 1;
+        }
+        return ans % mod;
+    }
+
+
+    static long mod = 1000000007;
+
+    static long gcd(long a, long b) {
+        if (a == 0) {
+            return b;
+        }
+        return gcd(b % a, a);
+    }
+
+    static long fast_powerNumbers(long a, long n) {
+        if (n == 1) {
+            return a;
+        }
+        long ans = fast_powerNumbers(a, n / 2);
+        if (n % 2 == 0) {
+            return (ans * ans);
+        } else {
+            return ((ans * ans) * (a));
+        }
+    }
+
+
+    static void dfs_helper(int[][] arr, int i, int j, int team, int n, int m) {
+        arr[i][j] = team;
+        if (i - 1 >= 0 && arr[i - 1][j] == 1) {
+            dfs(arr, i - 1, j, team, n, m);
+        }
+        if (j - 1 >= 0 && arr[i][j - 1] == 1) {
+            dfs(arr, i, j - 1, team, n, m);
+        }
+        if (i + 1 < n && arr[i + 1][j] == 1) {
+            dfs(arr, i + 1, j, team, n, m);
+        }
+        if (j + 1 < m && arr[i][j + 1] == 1) {
+            dfs(arr, i, j + 1, team, n, m);
+        }
+
+    }
+
+    static void dfs(int[][] arr, int i, int j, int team, int n, int m) {
+        dfs_helper(arr, i, j, team, n, m);
+
+    }
+
+    static int parent[];
+    static int rank[];
+
+    static int find(int i) {
+        if (parent[i] == -1) {
+            parent[i] = i;
+            return i;
+        }
+
+        if (parent[i] == i) {
+            return i;
+        } else {
+            parent[i] = find(parent[i]);
+        }
+        return parent[i];
+
+    }
+
+    static void unite(int s1, int s2) {
+
+        if (rank[s1] > rank[s2]) {
+            parent[s2] = s1;
+            rank[s1] += rank[s2];
+        } else {
+            parent[s1] = s2;
+            rank[s2] += rank[s1];
+        }
+    }
+
+
+    public static long arr[];
+    public static int arr1[];
+
+//    static void seive(int n) {
+//        arr = new int[n + 1];
+//        arr[0] = arr[1] = 1;
+//        for (int i = 4; i <= n; i = i + 2) {
+//            arr[i] = 1;
+//        }
+//        for (int i = 3; i * i <= n; i = i + 2) {
+//            if (arr[i] == 0) {
+//                for (int j = i * i; j <= n; j = j + i) {
+//                    arr[j] = 1;
+//                }
+//
+//            }
+//        }
+//    }
+
+    static  void seive(int n)
+    {
+        arr1=new int[n+1];
+        arr1[0]=arr1[1]=1;
+        for (int i = 4; i <=n ; i+=2) {
+            arr1[i]=1;
+        }
+        for (int i = 3; i*i <=n ; i+=2) {
+            if (arr1[i] == 0)
+            {
+                for (int j = i*i; j <=n ; j+=i) {
+                    arr1[j]=1;
+                }
+            }
+        }
+
+    }
+
+    public static boolean ccw(Point a,Point b,Point c)
+    {
+        long s1=(c.x-b.x)*(b.y-a.y) ;
+        long s2 = (c.y-b.y)*(b.x-a.x);
+        if(s1<s2)
+            return true;
+        else
+            return false;
+
+    }
+    public static boolean col(Point a,Point b,Point c)
+    {
+        long s1=(c.x-b.x)*(b.y-a.y) ;
+        long s2 = (c.y-b.y)*(b.x-a.x);
+        if(s1==s2)
+            return true;
+        else
+            return false;
+    }
+    static class Point
+    {
+        long x,y;
+        Point(long x,long y)
+        {
+            this.x=x;
+            this.y=y;
+        }
+    }
+
+    public static void main(String[] args) throws Exception {
+        FastReader sc = new FastReader();
+
+        Clock clock = new Clock();
+        clock.start();
+       int t1=sc.nextInt();
+        for (int t = 0; t <t1 ; t++) {
+          int n=sc.nextInt();
+          long arr[]=new long[n];
+            for (int i = 0; i < n; i++) {
+                arr[i]=sc.nextLong();
+            }
+          long sum1=0;
+          long sum2=0;
+          long min1 =Long.MAX_VALUE;
+          long min2 =Long.MAX_VALUE;
+          long brr[]=new long[n];
+            for (int i = 0; i <n ; i+=2) {
+
+                int nn =i/2;
+                min1=Math.min(arr[i],min1);
+                sum1+=arr[i];
+                long x =(sum1-min1) + min1*(n-nn);
+               // System.out.println(x);
+               brr[i]=x;
+
+            }
+            for (int i = 1; i <n ; i+=2) {
+                int nn =i/2;
+
+                //System.out.println(x);
+                min2=Math.min(arr[i],min2);
+                sum2+=arr[i];
+                long x =(sum2-min2) + min2*(n-nn);
+                brr[i]=x;
+            }
+            long min=Long.MAX_VALUE;
+            for (int i = 1; i < n; i++) {
+                min=Math.min(brr[i]+brr[i-1],min);
+            }
+            out.println(min);
+            //out.println(Arrays.toString(brr));
+
+           // System.out.println(min1+"" ""+min2);
+
+        }
+        out.close();
+
+
+    }
+
+
+}
+
+class Trio{
+    int a,i1,i2;
+    Trio(int a,int i1,int i2)
+    {
+        this.a=a;
+        this.i1=i1;
+        this.i2=i2;
+    }
+}
+
+class Pair{
+
+    int a,b;
+    Pair(int a,int b)
+    {
+        this.a=a;
+        this.b=b;
+    }
+}
+class DSU
+{
+    int parent[];
+    int rank[];
+    long arr[] = Main.arr;
+    long sum[] ;
+    DSU(int n)
+    {
+        this.parent=new int[n];
+        this.rank=new int[n];
+        sum=new long[n];
+        Arrays.fill(parent,-1);
+        Arrays.fill(rank,1);
+        for (int i = 0; i <n ; i++) {
+            sum[i]=arr[i];
+        }
+    }
+
+    int find(int s1)
+    {
+        if(parent[s1]==-1)
+            return s1;
+        return parent[s1]=find(parent[s1]);
+    }
+
+    void unite(int s1,int s2)
+    {
+        int p1=this.find(s1);
+        int p2=this.find(s2);
+        if(p1==p2)
+            return;
+        if(rank[p1]>rank[p2])
+        {
+            parent[p2]=p1;
+            rank[p1]+=rank[p2];
+            // System.out.println(arr[p2]);
+
+            sum[p1]+=sum[p2];
+            //sum[p2]+=sum[p1];
+
+        }
+        else
+        {
+            parent[p1]=p2;
+            rank[p2]+=rank[p1];
+            //System.out.println(arr[p1]);
+            sum[p2]+=sum[p1];
+            //sum[p1]+=sum[p2];
+        }
+    }
+
+
+}
+
+class Gaph {
+
+    HashMap<Integer, ArrayList<Integer>> hm;
+
+    Gaph() {
+        hm = new HashMap<>();
+    }
+
+    Gaph(int n) {
+
+        hm = new HashMap<>();
+        for (int i = 0; i < n; i++) {
+            hm.put(i, new ArrayList<Integer>());
+        }
+    }
+
+    // function for adding an edge.................................................
+    public void addEdge(int a, int b, boolean isDir) {
+        if (isDir) {
+            if (hm.containsKey(a)) {
+                hm.get(a).add(b);
+            } else {
+                hm.put(a, new ArrayList<>(Arrays.asList(b)));
+            }
+        } else {
+            if (hm.containsKey(a)) {
+                hm.get(a).add(b);
+            } else if (!hm.containsKey(a)) {
+                hm.put(a, new ArrayList<>(Arrays.asList(b)));
+            }
+
+            if (hm.containsKey(b)) {
+                hm.get(b).add(a);
+            } else if (!hm.containsKey(b)) {
+                hm.put(b, new ArrayList<>(Arrays.asList(a)));
+            }
+        }
+    }
+
+
+}
+
+// out.println(al.toString().replaceAll(""[\\[|\\]|,]"",""""));
+",1
+bdfe8110,c57a973e,"import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.StringTokenizer;
+
+public class E {
+
+	public static void main(String[] args) {
+		FastScanner fs=new FastScanner();
+		int T=fs.nextInt();
+		PrintWriter out=new PrintWriter(System.out);
+		for (int tt=0; tt<T; tt++) {
+			int n=fs.nextInt(), k=fs.nextInt();
+			int[] positions=fs.readArray(k), temps=fs.readArray(k);
+			int[] forced=new int[n];
+			Arrays.fill(forced, Integer.MAX_VALUE/2);
+			for (int i=0; i<k; i++) forced[positions[i]-1]=temps[i];
+			for (int i=1; i<n; i++)
+				forced[i]=Math.min(forced[i], forced[i-1]+1);
+			for (int i=n-2; i>=0; i--)
+				forced[i]=Math.min(forced[i], forced[i+1]+1);
+			for (int i=0; i<n; i++) out.print(forced[i]+"" "");
+			out.println();
+			
+		}
+		out.close();
+	}
+
+	static void sort(int[] a) {
+		ArrayList<Integer> l=new ArrayList<>();
+		for (int i:a) l.add(i);
+		Collections.sort(l);
+		for (int i=0; i<a.length; i++) a[i]=l.get(i);
+	}
+	
+	static class FastScanner {
+		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st=new StringTokenizer("""");
+		String next() {
+			while (!st.hasMoreTokens())
+				try {
+					st=new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			return st.nextToken();
+		}
+		
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+		int[] readArray(int n) {
+			int[] a=new int[n];
+			for (int i=0; i<n; i++) a[i]=nextInt();
+			return a;
+		}
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+	}
+
+	
+}
+
+","import java.io.BufferedReader;
+import java.io.FileNotFoundException;
+import java.io.FileReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.Arrays;
+import java.util.StringTokenizer;
+
+
+public class Air {
+
+    public static void main(String[] args) {
+        FastScanner sc = new FastScanner();
+        int T = sc.nextInt();
+        for(int tt=0; tt<T;tt++){
+        	int n = sc.nextInt(), k=sc.nextInt();
+        	int [] positions=new int[k], temp=new int[k];
+        	for (int i=0;i<k;i++) positions[i]=sc.nextInt();
+        	for (int i=0;i<k;i++) temp[i]=sc.nextInt();
+        	int[] forced=new int[n];
+        	Arrays.fill(forced, Integer.MAX_VALUE/2);
+        	for (int i=0;i<k;i++) forced[positions[i]-1]=temp[i];
+        	for (int i=1;i<n;i++) forced[i]=Math.min(forced[i], forced[i-1]+1);
+        	for (int i=n-2;i>=0;i--) forced[i]=Math.min(forced[i], forced[i+1]+1);
+        	for (int i=0;i<n;i++) System.out.print(forced[i]+"" "");
+			System.out.println();
+		}
+
+    }
+
+    public static class FastScanner {
+        BufferedReader br;
+        StringTokenizer st;
+
+        public FastScanner(String s) {
+            try {
+                br = new BufferedReader(new FileReader(s));
+            } catch (FileNotFoundException e) {
+                // TODO Auto-generated catch block
+                e.printStackTrace();
+            }
+        }
+
+        public FastScanner() {
+            br = new BufferedReader(new InputStreamReader(System.in));
+        }
+
+        String nextToken() {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    // TODO Auto-generated catch block
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(nextToken());
+        }
+
+        long nextLong() {
+            return Long.parseLong(nextToken());
+        }
+
+        double nextDouble() {
+            return Double.parseDouble(nextToken());
+        }
+    }
+}
+",1
+45f5632f,5dc1f7b3,"import java.io.*;
+import java.util.*;
+
+ 
+public class A{
+    public static void main(String[] args) {
+        InputStream inputStream = System.in;
+        OutputStream outputStream = System.out;
+        InputReader in = new InputReader(inputStream);
+        PrintWriter out = new PrintWriter(outputStream);
+        Task solver = new Task();
+        solver.solve(in, out);
+        out.close();
+    }
+    // main solver
+    static class Task{
+
+        double eps= 0.00000001;
+        static final int MAXN = 10000001; 
+       
+        // stores smallest prime factor for every number 
+        static int spf[] = new int[MAXN]; 
+
+        Map<Integer,Set<Integer>> dp= new HashMap<>();
+        
+        // Calculating SPF (Smallest Prime Factor) for every 
+        // number till MAXN. 
+        // Time Complexity : O(nloglogn) 
+        public void sieve() 
+        { 
+            spf[1] = 1; 
+            for (int i=2; i<MAXN; i++) 
+        
+                // marking smallest prime factor for every 
+                // number to be itself. 
+                spf[i] = i; 
+        
+            // separately marking spf for every even 
+            // number as 2 
+            for (int i=4; i<MAXN; i+=2) 
+                spf[i] = 2; 
+        
+            for (int i=3; i*i<MAXN; i++) 
+            { 
+                // checking if i is prime 
+                if (spf[i] == i) 
+                { 
+                    // marking SPF for all numbers divisible by i 
+                    for (int j=i*i; j<MAXN; j+=i) 
+        
+                        // marking spf[j] if it is not  
+                        // previously marked 
+                        if (spf[j]==j) 
+                            spf[j] = i; 
+                } 
+            } 
+        } 
+        
+        // A O(log n) function returning primefactorization 
+        // by dividing by smallest prime factor at every step 
+        public Set<Integer> getFactorization(int x) 
+        { 
+            if(dp.containsKey(x)) return dp.get(x);
+            Set<Integer> ret = new HashSet<>(); 
+            while (x != 1) 
+            { 
+                if(spf[x]!=2) ret.add(spf[x]); 
+                x = x / spf[x]; 
+            } 
+            dp.put(x,ret);
+            return ret; 
+        } 
+        // function to find first index >= x 
+        public int lowerIndex(List<Integer> arr, int n, int x) 
+        { 
+            int l = 0, h = n - 1; 
+            while (l <= h)  
+            { 
+                int mid = (l + h) / 2; 
+                if (arr.get(mid) >= x) 
+                    h = mid - 1; 
+                else
+                    l = mid + 1; 
+            } 
+            return l; 
+        } 
+        
+        // function to find last index <= y 
+        public int upperIndex(List<Integer> arr, int n, int y) 
+        { 
+            int l = 0, h = n - 1; 
+            while (l <= h)  
+            { 
+                int mid = (l + h) / 2; 
+                if (arr.get(mid) <= y) 
+                    l = mid + 1; 
+                else
+                    h = mid - 1; 
+            } 
+            return h; 
+        } 
+        
+        // function to count elements within given range 
+        public int countInRange(List<Integer> arr, int n, int x, int y) 
+        { 
+            // initialize result 
+            int count = 0; 
+            count = upperIndex(arr, n, y) -  
+                    lowerIndex(arr, n, x) + 1; 
+            return count; 
+        }
+        ArrayList<Integer>A = new ArrayList<>();
+        ArrayList<Integer>B = new ArrayList<>();
+        ArrayList<List<Integer>> L = new ArrayList<List<Integer>>();
+        public void solve(InputReader in, PrintWriter out) {           
+            int n= in.nextInt();
+            int[] A= new int[n];
+            final int INF= 1000000000;
+            List<Integer> pos= new ArrayList<>();
+            for (int i = 0; i < n; i++){
+                A[i]= in.nextInt();
+                if (A[i] == 1) pos.add(i);
+            }
+            int cnt = pos.size();
+            int[][] dp= new int[cnt][n+1];
+            for(int[] temp: dp) Arrays.fill(temp,INF);
+            if (cnt == 0){
+                out.println(0);
+                return;
+            }
+            for (int i = n - 1; i >= 0; i--){
+                dp[cnt - 1][i] = dp[cnt - 1][i + 1];
+                if (A[i] != 1){
+                    dp[cnt - 1][i] = Math.min(dp[cnt - 1][i], Math.abs(i - pos.get(pos.size()-1)));
+                }
+            }
+            for (int i = cnt - 2; i >= 0; i--){
+                for (int j = n - 1; j >= 0; j--){
+                    dp[i][j] = dp[i][j + 1];
+                    if (A[j] != 1){
+                        dp[i][j] = Math.min(dp[i][j], Math.abs(j - pos.get(i)) + dp[i + 1][j + 1]);
+                    }
+                }
+            }
+            out.println(dp[0][0]);
+        }
+        void backtrack(PrintWriter out, int i, List<Integer> considered, int used, int sum, int cur, int g){
+            if (used == considered.size()){
+                int percentage = (cur * 100) / sum;
+                if (percentage >= g){
+                    considered.add(percentage);
+                    L.add(considered);
+                }
+                return;
+            }
+            if (i == B.size()){
+                return;
+            }
+            for (int j = i; j < B.size(); j++){
+                List<Integer> au = new ArrayList<>(considered);
+                au.add(j + 1);
+                backtrack(out, j + 1, au, used, sum, cur + B.get(j), g);
+            }
+        }
+        public int _gcd(int a,  int  b)
+        {
+        
+            if(b == 0) {
+                    return a;
+            }
+            else {
+                return _gcd(b, a % b);
+            }
+        }
+
+    }
+
+    static class Tuple implements Comparable<Tuple>{
+        int x, y, z;
+        public Tuple(int x, int y, int z){
+            this.x= x;
+            this.y= y;
+            this.z=z;
+        }
+        @Override
+        public int compareTo(Tuple o){
+            return this.x-o.x;
+        }
+    }
+
+    static class Pair implements Comparable<Pair>{
+        public int x;
+        public int y;
+        public Pair(int x, int y){
+            this.x= x;
+            this.y= y;
+        }
+ 
+        @Override
+        public int compareTo(Pair o) {
+            return this.x-o.x;
+        }
+    }
+    // fast input reader class;
+    static class InputReader {
+        BufferedReader br;
+        StringTokenizer st;
+ 
+        public InputReader(InputStream stream) {
+            br = new BufferedReader(new InputStreamReader(stream));
+        }
+ 
+        public String nextToken() {
+            while (st == null || !st.hasMoreTokens()) {
+                String line = null;
+                try {
+                    line = br.readLine();
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+                if (line == null) {
+                    return null;
+                }
+                st = new StringTokenizer(line);
+            }
+            return st.nextToken();
+        }
+ 
+        public int nextInt() {
+            return Integer.parseInt(nextToken());
+        }
+        public double nextDouble(){
+            return Double.parseDouble(nextToken());
+        }
+        public long nextLong(){
+            return Long.parseLong(nextToken());
+        }
+    }
+}
+ ","import java.io.*;
+import java.util.*;
+
+public class D {
+
+	public static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+	public static PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
+
+	public static void main(String[] args) throws IOException {
+		readInput();
+		out.close();
+	}
+	
+	static List<Integer> o1, o0;
+	static int[][] dp;
+	
+	static int solve(int i, int j) {
+		if (i >= dp.length) return 0;
+		if (j >= dp[0].length) return Integer.MAX_VALUE/10;
+		
+		if (dp[i][j] == -1) {
+			dp[i][j] = Integer.min(solve(i,j+1), solve(i+1,j+1) + Math.abs(o1.get(i)-o0.get(j)));
+		}
+		return dp[i][j];
+	}
+	
+	public static void readInput() throws IOException {
+		// br = new BufferedReader(new FileReader("".in""));
+		// out = new PrintWriter(new FileWriter("".out""));
+		int n;
+		n = Integer.parseInt(br.readLine());
+		int[] a=  new int[n];
+		StringTokenizer st = new StringTokenizer(br.readLine());
+		o1 = new ArrayList<Integer>();
+		o0 = new ArrayList<Integer>();
+		for (int i = 0; i < n; i++) {
+			a[i] = Integer.parseInt(st.nextToken());
+			if (a[i] == 1) o1.add(i);
+			else o0.add(i);
+		}
+		if (o1.size() == 0) {
+			out.println(0);
+			return;
+		}
+		dp = new int[o1.size()][o0.size()];
+		for (int[] x: dp) Arrays.fill(x, -1);
+		out.println(solve(0,0));
+		
+	}
+}
+",0
+3b5cec19,8f31b279,"import java.util.*;
+import java.io.*;
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.Scanner;
+import java.util.StringTokenizer;
+
+
+
+public class Test{
+
+    static class Pair implements Comparable<Pair>{
+    int wt;
+    int idx;
+    Pair(int x,int y){
+        this.wt=x;
+        this.idx=y;
+    }
+    @Override
+    public int compareTo(Pair x){
+        return this.wt-x.wt;
+    }
+
+    public String toString(){
+        return ""(""+wt+"" ""+idx+"")"";
+    }
+}   
+
+
+
+    public static void main (String[] args) throws java.lang.Exception{
+        FastReader scan=new FastReader();
+        int t=scan.nextInt();
+        while(t-->0){
+            int n=scan.nextInt();
+            int m=scan.nextInt();
+            int x=scan.nextInt();
+            int[]arr=new int[n];
+            for(int i=0;i<n;i++){
+                arr[i]=scan.nextInt();
+            }
+            Queue<Pair>q=new PriorityQueue<>();
+            for(int i=1;i<=m;i++){
+                q.add(new Pair(0,i));
+            }
+            System.out.println(""YES"");
+            for(int i=0;i<n;i++){
+                Pair temp=q.poll();
+                int wt=temp.wt;
+                int idx=temp.idx;
+                System.out.print(idx+"" "");
+                //System.out.println(temp);
+                q.add(new Pair(wt+arr[i],idx));
+            }
+            System.out.println();
+
+
+        }
+    }
+
+        static class FastReader {
+        BufferedReader br;
+        StringTokenizer st;
+ 
+        public FastReader()
+        {
+            br = new BufferedReader(
+                new InputStreamReader(System.in));
+        }
+ 
+        String next()
+        {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                }
+                catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+ 
+        int nextInt() { return Integer.parseInt(next()); }
+ 
+        long nextLong() { return Long.parseLong(next()); }
+ 
+        double nextDouble() { return Double.parseDouble(next()); }
+ 
+        String nextLine()
+        {
+            String str = """";
+            try {
+                str = br.readLine();
+            }
+            catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+            }
+        }
+}
+
+","import java.util.*;
+import java.io.*;
+public class JavaTract
+{
+	static class Pair implements Comparable<Pair>{
+    	int first;
+    	int second;
+    	Pair(int x,int y){
+        	this.first=x;
+        	this.second=y;
+    	}
+    	@Override
+    	public int compareTo(Pair x){
+        	return this.first-x.first;
+   		}
+   	}	
+    public static void main (String[] args) 
+    {
+        Scanner scan=new Scanner(System.in);
+        int t=scan.nextInt();
+        while(t-->0){
+            int n=scan.nextInt();
+            int m=scan.nextInt();
+            int x=scan.nextInt();
+            int[]arr=new int[n];
+            for(int i=0;i<n;i++){
+                arr[i]=scan.nextInt();
+            }
+            // TreeSet<Pair> set = new TreeSet<>(); 
+            Queue<Pair> set = new PriorityQueue<>();
+            for(int i=1;i<=m;i++){
+               
+               set.add(new Pair(0,i));
+            }
+            
+            System.out.println(""YES"");
+            for(int i=0;i<n;i++){
+                Pair temp=set.poll();
+                
+                int first = temp.first;
+                int second = temp.second;
+
+                System.out.print(second+"" "");
+                
+                set.add(new Pair(first+arr[i],second));
+                
+            }
+            System.out.println();
+
+
+        }
+    }
+
+       
+}
+	
+",1
+3380fa52,48993e07,"import java.util.*;
+import java.io.*;
+import java.math.*;
+
+/* Name of the class has to be ""Main"" only if the class is public. */
+public class Coder {
+  static int n, k;
+  static long a[];
+  static int pos[];
+  static int temp[];
+  static StringBuilder str = new StringBuilder("""");
+  static int cnt[][] = new int[(int)1e5+5][2];
+  static void solve() {
+    long []l = new long[n];
+    long []r = new long[n];
+    long p = Integer.MAX_VALUE;
+    for(int i=0;i<n;i++){
+        p = Math.min(p+1, a[i]);
+        l[i] = p;
+    }
+    p=Integer.MAX_VALUE;
+    for(int i=n-1;i>=0;i--){
+     p = Math.min(p+1, a[i]);
+     r[i] = p;
+    }
+    for(int i=0;i<n;i++){
+        str.append(Math.min(l[i],r[i])).append("" "");
+    }
+    str.append(""\n"");
+  }
+
+  public static void main(String[] args) throws java.lang.Exception {
+    BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
+    int t = Integer.parseInt(bf.readLine().trim());
+    while (t-- > 0) {
+      bf.readLine();
+      String s[] = bf.readLine().trim().split(""\\s+"");
+      n = Integer.parseInt(s[0]);
+      k = Integer.parseInt(s[1]);
+      s = bf.readLine().trim().split(""\\s+"");
+      pos = new int[k];
+      temp = new int[k];
+      a = new long[n];
+      for(int i=0;i<k;i++) pos[i]=Integer.parseInt(s[i]);
+      s = bf.readLine().trim().split(""\\s+"");
+      for(int i=0;i<k;i++) temp[i]=Integer.parseInt(s[i]);
+      Arrays.fill(a, Integer.MAX_VALUE);
+      for(int i=0;i<k;i++) a[pos[i]-1] = temp[i]; 
+      solve();
+    }
+    System.out.print(str);
+  }
+}","import java.io.*;
+import java.util.*;
+
+public class Codeforce {
+
+    static class Reader {
+        final private int BUFFER_SIZE = 1 << 16;
+        private DataInputStream din;
+        private byte[] buffer;
+        private int bufferPointer, bytesRead;
+
+        public Reader() {
+            din = new DataInputStream(System.in);
+            buffer = new byte[BUFFER_SIZE];
+            bufferPointer = bytesRead = 0;
+        }
+
+        public Reader(String file_name) throws IOException {
+            din = new DataInputStream(
+                    new FileInputStream(file_name));
+            buffer = new byte[BUFFER_SIZE];
+            bufferPointer = bytesRead = 0;
+        }
+
+        public String readLine() throws IOException {
+            byte[] buf = new byte[64]; // line length
+            int cnt = 0, c;
+            while ((c = read()) != -1) {
+                if (c == '\n') {
+                    if (cnt != 0) {
+                        break;
+                    } else {
+                        continue;
+                    }
+                }
+                buf[cnt++] = (byte) c;
+            }
+            return new String(buf, 0, cnt);
+        }
+
+        public int nextInt() throws IOException {
+            int ret = 0;
+            byte c = read();
+            while (c <= ' ') {
+                c = read();
+            }
+            boolean neg = (c == '-');
+            if (neg)
+                c = read();
+            do {
+                ret = ret * 10 + c - '0';
+            } while ((c = read()) >= '0' && c <= '9');
+
+            if (neg)
+                return -ret;
+            return ret;
+        }
+
+        public long nextLong() throws IOException {
+            long ret = 0;
+            byte c = read();
+            while (c <= ' ')
+                c = read();
+            boolean neg = (c == '-');
+            if (neg)
+                c = read();
+            do {
+                ret = ret * 10 + c - '0';
+            } while ((c = read()) >= '0' && c <= '9');
+            if (neg)
+                return -ret;
+            return ret;
+        }
+
+        public double nextDouble() throws IOException {
+            double ret = 0, div = 1;
+            byte c = read();
+            while (c <= ' ')
+                c = read();
+            boolean neg = (c == '-');
+            if (neg)
+                c = read();
+
+            do {
+                ret = ret * 10 + c - '0';
+            } while ((c = read()) >= '0' && c <= '9');
+
+            if (c == '.') {
+                while ((c = read()) >= '0' && c <= '9') {
+                    ret += (c - '0') / (div *= 10);
+                }
+            }
+
+            if (neg)
+                return -ret;
+            return ret;
+        }
+
+        private void fillBuffer() throws IOException {
+            bytesRead = din.read(buffer, bufferPointer = 0,
+                    BUFFER_SIZE);
+            if (bytesRead == -1)
+                buffer[0] = -1;
+        }
+
+        private byte read() throws IOException {
+            if (bufferPointer == bytesRead)
+                fillBuffer();
+            return buffer[bufferPointer++];
+        }
+
+        public void close() throws IOException {
+            if (din == null)
+                return;
+            din.close();
+        }
+    }
+
+    static int mod = (int) (1e9 + 7);
+
+    public static class pair implements Comparator<pair> {
+        int x;
+        int y;
+
+        public pair() {
+
+        }
+
+        public pair(int x, int y) {
+            this.x = x;
+            this.y = y;
+
+        }
+
+        @Override
+        public int compare(pair o1, pair o2) {
+            return o1.y - o2.y;
+        }
+    }
+
+    public static long modularpow(long a, long b) {
+        long res = 1;
+        if (b == 0)
+            return res;
+        else {
+            while (b > 0) {
+                if (b % 2 == 1) {
+                    res *= a;
+                    res %= mod;
+
+                }
+                a = a * a;
+                a %= mod;
+                b /= 2;
+            }
+            return res % mod;
+        }
+    }
+
+    public static int gcd(int a, int b) {
+        if (b == 0)
+            return a;
+        else
+            return gcd(b, a % b);
+    }
+
+    public static String binary(int a) {
+        String s1 = """";
+        while (a > 0) {
+            s1 = a % 2 + s1;
+            a /= 2;
+        }
+        return s1;
+    }
+
+    public static int Lower_Bound(long a[], int l, int r, long k) {
+
+
+        while (r - l > 1) {
+            int mid = l + (r - l) / 2;
+            if (a[mid] <= k) l = mid;
+            else
+                r = mid;
+
+        }
+        return l;
+    }
+
+    public static int Upper_Bound(int a[], int l, int r, int k) {
+
+        while (r - l > 1) {
+            int mid = (l + r) / 2;
+            if (a[mid] <= k)
+                l = mid;
+            else
+                r = mid;
+        }
+        return l + 1;
+    }
+
+    public static void main(String arg[]) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        int t = Integer.parseInt(br.readLine());
+        StringBuilder sb = new StringBuilder();
+        while (t-- > 0) {
+                                br.readLine();
+                        String s[]=br.readLine().split("" "");
+                        int n=Integer.parseInt(s[0]);
+                        int k=Integer.parseInt(s[1]);
+                        long a[]=new long[n];
+                        long b[]=new long[n];
+                        long c[]=new long[n];
+                        Arrays.fill(c,Integer.MAX_VALUE);
+                        String s1[]=br.readLine().split("" "");
+                        s=br.readLine().split("" "");
+                        for(int i=0;i<k;i++)
+                            c[Integer.parseInt(s1[i])-1]=Integer.parseInt(s[i]);
+
+                        long p=Integer.MAX_VALUE;
+                        for(int i=0;i<n;i++)
+                        {
+                            p=Math.min(p+1,c[i]);
+                            a[i]=p;
+                        }
+                        p=Integer.MAX_VALUE;
+                        for(int i=n-1;i>=0;i--){
+                            p=Math.min(p+1,c[i]);
+                            b[i]=p;
+                        }
+                        for(int i=0;i<n;i++)
+                            sb.append((Math.min(a[i],b[i]))+"" "");
+                        sb.append(""\n"");
+
+                       }
+        System.out.println(sb);
+    }
+}",1
+22b41936,45f5632f,"
+
+
+import java.io.*;
+import java.util.*;
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.util.Collections;
+import java.io.InputStreamReader;
+import static java.lang.Math.*;
+import static java.lang.System.*;
+
+public class Main1 {
+
+     static ArrayList<Integer> list1 = new ArrayList<>() ;
+     static ArrayList<Integer> list2 = new ArrayList<>() ;
+     static int n , m ;
+     static long dp[][] ;
+
+     static long solver(int i , int j ){
+         // i = empty chairs
+
+         if (j == m)return 0 ;
+         int tt1 = n-i ;
+         int tt2 = m-j ;
+         if (n-i < m-j)return  Long.MAX_VALUE/2  ;
+         if ( dp[i][j] != -1 )return dp[i][j] ;
+
+        long a = solver(i+1 , j) ;
+        long b = abs( list1.get(i) - list2.get(j)) + solver(i+1 , j+1) ;
+
+        return dp[i][j] = min(a , b) ;
+
+     }
+
+
+
+    public static void main(String[] args) throws IOException {
+
+//        try {
+
+
+            FastScanner in = new FastScanner();
+            PrintWriter out = new PrintWriter(System.out);
+
+
+            int N = in.nextInt() ;
+            int a[] = in.readArray(N) ;
+        for (int i = 0; i <N ; i++) {
+            if (a[i] == 1)list2.add(i) ;
+            else list1.add(i) ;
+        }
+
+         n = list1.size() ;
+         m = list2.size() ;
+            dp = new long[n][m] ;
+
+
+            for(int i=0 ; i<n ; i++)
+                for(int j=0 ; j<m ; j++)
+                    dp[i][j] = -1 ;
+
+     
+        System.out.println(solver(0 , 0 ));
+
+
+
+
+
+
+
+
+            out.flush();
+            out.close();
+
+//        }
+//        catch (Exception e){
+//            return;
+//        }
+
+    }
+
+    static long gcd(long a, long b) {
+        return (b == 0) ? a : gcd(b, a % b);
+    }
+
+    static ArrayList<Integer> list = new ArrayList<>();
+    static boolean A[] = new boolean[2 * 90000001];
+
+
+    static void seive(int n) {
+        int maxn = n;
+        //int maxn = 1000000  ;
+        A[0] = A[1] = true;
+
+        for (int i = 2; i * i <= maxn; i++) {
+            if (!A[i]) {
+                for (int j = i * i; j <= maxn; j += i)
+                    A[j] = true;
+            }
+        }
+
+        for (int i = 2; i <= maxn; i++)
+            if (!A[i])
+                list.add(i);
+
+    }
+
+    static int findLCA(int a, int b, int par[][], int depth[]) {
+        if (depth[a] > depth[b]) {
+            a = a ^ b;
+            b = a ^ b;
+            a = a ^ b;
+        }
+        int diff = depth[b] - depth[a];
+        for (int i = 19; i >= 0; i--) {
+            if ((diff & (1 << i)) > 0) {
+                b = par[b][i];
+            }
+        }
+        if (a == b)
+            return a;
+        for (int i = 19; i >= 0; i--) {
+            if (par[b][i] != par[a][i]) {
+                b = par[b][i];
+                a = par[a][i];
+            }
+        }
+        return par[a][0];
+    }
+
+    static int gcd(int a, int b) {
+        return (b == 0) ? a : gcd(b, a % b);
+    }
+
+    static void formArrayForBinaryLifting(int n, int par[][]) {
+        for (int j = 1; j < 20; j++) {
+            for (int i = 0; i < n; i++) {
+                if (par[i][j - 1] == -1)
+                    continue;
+                par[i][j] = par[par[i][j - 1]][j - 1];
+            }
+        }
+    }
+
+
+    static void sort(int ar[]) {
+        int n = ar.length;
+        ArrayList<Integer> a = new ArrayList<>();
+        for (int i = 0; i < n; i++)
+            a.add(ar[i]);
+        Collections.sort(a);
+        for (int i = 0; i < n; i++)
+            ar[i] = a.get(i);
+    }
+
+    static void sort1(long ar[]) {
+        int n = ar.length;
+        ArrayList<Long> a = new ArrayList<>();
+        for (int i = 0; i < n; i++)
+            a.add(ar[i]);
+        Collections.sort(a);
+        for (int i = 0; i < n; i++)
+            ar[i] = a.get(i);
+    }
+
+    static long ncr(long n, long r, long mod) {
+        if (r == 0)
+            return 1;
+        long val = ncr(n - 1, r - 1, mod);
+        val = (n * val) % mod;
+        val = (val * modInverse(r, mod)) % mod;
+        return val;
+    }
+
+    static long fast_pow(long base, long n, long M) {
+        if (n == 0)
+            return 1;
+        if (n == 1)
+            return base % M;
+        long halfn = fast_pow(base, n / 2, M);
+        if (n % 2 == 0)
+            return (halfn * halfn) % M;
+        else
+            return (((halfn * halfn) % M) * base) % M;
+    }
+
+    static long modInverse(long n, long M) {
+        return fast_pow(n, M - 2, M);
+    }
+
+
+    private static int countDigits(long l) {
+        if (l >= 1000000000000000000L) return 19;
+        if (l >= 100000000000000000L) return 18;
+        if (l >= 10000000000000000L) return 17;
+        if (l >= 1000000000000000L) return 16;
+        if (l >= 100000000000000L) return 15;
+        if (l >= 10000000000000L) return 14;
+        if (l >= 1000000000000L) return 13;
+        if (l >= 100000000000L) return 12;
+        if (l >= 10000000000L) return 11;
+        if (l >= 1000000000L) return 10;
+        if (l >= 100000000L) return 9;
+        if (l >= 10000000L) return 8;
+        if (l >= 1000000L) return 7;
+        if (l >= 100000L) return 6;
+        if (l >= 10000L) return 5;
+        if (l >= 1000L) return 4;
+        if (l >= 100L) return 3;
+        if (l >= 10L) return 2;
+        return 1;
+    }
+
+
+    static class FastOutput implements AutoCloseable, Closeable, Appendable {
+        private static final int THRESHOLD = 32 << 10;
+        private final Writer os;
+        private StringBuilder cache = new StringBuilder(THRESHOLD * 2);
+
+        public FastOutput append(CharSequence csq) {
+            cache.append(csq);
+            return this;
+        }
+
+        public FastOutput append(CharSequence csq, int start, int end) {
+            cache.append(csq, start, end);
+            return this;
+        }
+
+        private void afterWrite() {
+            if (cache.length() < THRESHOLD) {
+                return;
+            }
+            flush();
+        }
+
+        public FastOutput(Writer os) {
+            this.os = os;
+        }
+
+        public FastOutput(OutputStream os) {
+            this(new OutputStreamWriter(os));
+        }
+
+        public FastOutput append(char c) {
+            cache.append(c);
+            afterWrite();
+            return this;
+        }
+
+        public FastOutput append(long c) {
+            cache.append(c);
+            afterWrite();
+            return this;
+        }
+
+        public FastOutput append(String c) {
+            cache.append(c);
+            afterWrite();
+            return this;
+        }
+
+        public FastOutput println() {
+            return append(System.lineSeparator());
+        }
+
+        public FastOutput flush() {
+            try {
+                //            boolean success = false;
+                //            if (stringBuilderValueField != null) {
+                //                try {
+                //                    char[] value = (char[]) stringBuilderValueField.get(cache);
+                //                    os.write(value, 0, cache.length());
+                //                    success = true;
+                //                } catch (Exception e) {
+                //                }
+                //            }
+                //            if (!success) {
+                os.append(cache);
+                //            }
+                os.flush();
+                cache.setLength(0);
+            } catch (IOException e) {
+                throw new UncheckedIOException(e);
+            }
+            return this;
+        }
+
+        public void close() {
+            flush();
+            try {
+                os.close();
+            } catch (IOException e) {
+                throw new UncheckedIOException(e);
+            }
+        }
+
+        public String toString() {
+            return cache.toString();
+        }
+
+    }
+
+
+    static class FastScanner {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st = new StringTokenizer("""");
+
+        String next() {
+            while (!st.hasMoreTokens())
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        int[] readArray(int n) {
+            int[] a = new int[n];
+            for (int i = 0; i < n; i++) a[i] = nextInt();
+            return a;
+        }
+
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+    }
+
+
+}
+
+
+
+
+
+
+
+","import java.io.*;
+import java.util.*;
+ 
+public class A{
+    public static void main(String[] args) {
+        InputStream inputStream = System.in;
+        OutputStream outputStream = System.out;
+        InputReader in = new InputReader(inputStream);
+        PrintWriter out = new PrintWriter(outputStream);
+        Task solver = new Task();
+        solver.solve(in, out);
+        out.close();
+    }
+    // main solver
+    static class Task{
+
+        double eps= 0.00000001;
+        static final int MAXN = 10000001; 
+       
+        // stores smallest prime factor for every number 
+        static int spf[] = new int[MAXN]; 
+
+        Map<Integer,Set<Integer>> dp= new HashMap<>();
+        
+        // Calculating SPF (Smallest Prime Factor) for every 
+        // number till MAXN. 
+        // Time Complexity : O(nloglogn) 
+        public void sieve() 
+        { 
+            spf[1] = 1; 
+            for (int i=2; i<MAXN; i++) 
+        
+                // marking smallest prime factor for every 
+                // number to be itself. 
+                spf[i] = i; 
+        
+            // separately marking spf for every even 
+            // number as 2 
+            for (int i=4; i<MAXN; i+=2) 
+                spf[i] = 2; 
+        
+            for (int i=3; i*i<MAXN; i++) 
+            { 
+                // checking if i is prime 
+                if (spf[i] == i) 
+                { 
+                    // marking SPF for all numbers divisible by i 
+                    for (int j=i*i; j<MAXN; j+=i) 
+        
+                        // marking spf[j] if it is not  
+                        // previously marked 
+                        if (spf[j]==j) 
+                            spf[j] = i; 
+                } 
+            } 
+        } 
+        
+        // A O(log n) function returning primefactorization 
+        // by dividing by smallest prime factor at every step 
+        public Set<Integer> getFactorization(int x) 
+        { 
+            if(dp.containsKey(x)) return dp.get(x);
+            Set<Integer> ret = new HashSet<>(); 
+            while (x != 1) 
+            { 
+                if(spf[x]!=2) ret.add(spf[x]); 
+                x = x / spf[x]; 
+            } 
+            dp.put(x,ret);
+            return ret; 
+        } 
+        // function to find first index >= x 
+        public int lowerIndex(List<Integer> arr, int n, int x) 
+        { 
+            int l = 0, h = n - 1; 
+            while (l <= h)  
+            { 
+                int mid = (l + h) / 2; 
+                if (arr.get(mid) >= x) 
+                    h = mid - 1; 
+                else
+                    l = mid + 1; 
+            } 
+            return l; 
+        } 
+        
+        // function to find last index <= y 
+        public int upperIndex(List<Integer> arr, int n, int y) 
+        { 
+            int l = 0, h = n - 1; 
+            while (l <= h)  
+            { 
+                int mid = (l + h) / 2; 
+                if (arr.get(mid) <= y) 
+                    l = mid + 1; 
+                else
+                    h = mid - 1; 
+            } 
+            return h; 
+        } 
+        
+        // function to count elements within given range 
+        public int countInRange(List<Integer> arr, int n, int x, int y) 
+        { 
+            // initialize result 
+            int count = 0; 
+            count = upperIndex(arr, n, y) -  
+                    lowerIndex(arr, n, x) + 1; 
+            return count; 
+        }
+        ArrayList<Integer>A = new ArrayList<>();
+        ArrayList<Integer>B = new ArrayList<>();
+        ArrayList<List<Integer>> L = new ArrayList<List<Integer>>();
+        public void solve(InputReader in, PrintWriter out) {           
+            int n= in.nextInt();
+            int[] A= new int[n];
+            final int INF= 1000000000;
+            List<Integer> pos= new ArrayList<>();
+            for (int i = 0; i < n; i++){
+                A[i]= in.nextInt();
+                if (A[i] == 1) pos.add(i);
+            }
+            int cnt = pos.size();
+            int[][] dp= new int[cnt][n+1];
+            for(int[] temp: dp) Arrays.fill(temp,INF);
+            if (cnt == 0){
+                out.println(0);
+                return;
+            }
+            for (int i = n - 1; i >= 0; i--){
+                dp[cnt - 1][i] = dp[cnt - 1][i + 1];
+                if (A[i] != 1){
+                    dp[cnt - 1][i] = Math.min(dp[cnt - 1][i], Math.abs(i - pos.get(pos.size()-1)));
+                }
+            }
+            for (int i = cnt - 2; i >= 0; i--){
+                for (int j = n - 1; j >= 0; j--){
+                    dp[i][j] = dp[i][j + 1];
+                    if (A[j] != 1){
+                        dp[i][j] = Math.min(dp[i][j], Math.abs(j - pos.get(i)) + dp[i + 1][j + 1]);
+                    }
+                }
+            }
+            out.println(dp[0][0]);
+        }
+        void backtrack(PrintWriter out, int i, List<Integer> considered, int used, int sum, int cur, int g){
+            if (used == considered.size()){
+                int percentage = (cur * 100) / sum;
+                if (percentage >= g){
+                    considered.add(percentage);
+                    L.add(considered);
+                }
+                return;
+            }
+            if (i == B.size()){
+                return;
+            }
+            for (int j = i; j < B.size(); j++){
+                List<Integer> au = new ArrayList<>(considered);
+                au.add(j + 1);
+                backtrack(out, j + 1, au, used, sum, cur + B.get(j), g);
+            }
+        }
+        public int _gcd(int a,  int  b)
+        {
+        
+            if(b == 0) {
+                    return a;
+            }
+            else {
+                return _gcd(b, a % b);
+            }
+        }
+
+    }
+
+    static class Tuple implements Comparable<Tuple>{
+        int x, y, z;
+        public Tuple(int x, int y, int z){
+            this.x= x;
+            this.y= y;
+            this.z=z;
+        }
+        @Override
+        public int compareTo(Tuple o){
+            return this.x-o.x;
+        }
+    }
+
+    static class Pair implements Comparable<Pair>{
+        public int x;
+        public int y;
+        public Pair(int x, int y){
+            this.x= x;
+            this.y= y;
+        }
+ 
+        @Override
+        public int compareTo(Pair o) {
+            return this.x-o.x;
+        }
+    }
+    // fast input reader class;
+    static class InputReader {
+        BufferedReader br;
+        StringTokenizer st;
+ 
+        public InputReader(InputStream stream) {
+            br = new BufferedReader(new InputStreamReader(stream));
+        }
+ 
+        public String nextToken() {
+            while (st == null || !st.hasMoreTokens()) {
+                String line = null;
+                try {
+                    line = br.readLine();
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+                if (line == null) {
+                    return null;
+                }
+                st = new StringTokenizer(line);
+            }
+            return st.nextToken();
+        }
+ 
+        public int nextInt() {
+            return Integer.parseInt(nextToken());
+        }
+        public double nextDouble(){
+            return Double.parseDouble(nextToken());
+        }
+        public long nextLong(){
+            return Long.parseLong(nextToken());
+        }
+    }
+}
+ ",0
+6b97058e,921b6e4a,"import java.io.*;
+import java.util.*;
+
+public class D_Java {
+	public static final int MOD = 998244353;
+	
+	public static int mul(int a, int b) {
+		return (int)((long)a * (long)b % MOD);
+	}
+	
+	int[] f;
+	int[] rf;
+	
+	public int C(int n, int k) {
+		return (k < 0 || k > n) ? 0 : mul(f[n], mul(rf[n-k], rf[k]));
+	}
+	
+	public static int pow(int a, int n) {
+		int res = 1;
+		while (n != 0) {
+			if ((n & 1) == 1) {
+				res = mul(res, a);
+			}
+			a = mul(a, a);
+			n >>= 1;
+		}
+		return res;
+	}
+	
+	static void shuffleArray(int[] a) {
+		Random rnd = new Random();
+		for (int i = a.length-1; i > 0; i--) {
+			int index = rnd.nextInt(i + 1);
+			int tmp = a[index];
+			a[index] = a[i];
+			a[i] = tmp;
+		}
+	}
+	
+	public static int inv(int a) {
+		return pow(a, MOD-2);
+	}
+	
+	public void doIt() throws IOException {
+		BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
+		
+		StringTokenizer tok = new StringTokenizer(in.readLine());
+		int n = Integer.parseInt(tok.nextToken());
+		int k = Integer.parseInt(tok.nextToken());
+		
+		f = new int[n+42];
+		rf = new int[n+42];
+		f[0] = rf[0] = 1;
+		for (int i = 1; i < f.length; ++i) {
+			f[i] = mul(f[i-1], i);
+			rf[i] = mul(rf[i-1], inv(i));
+		}
+		
+		int[] events = new int[2*n];
+		for (int i = 0; i < n; ++i) {
+			tok = new StringTokenizer(in.readLine());
+			int le = Integer.parseInt(tok.nextToken());
+			int ri = Integer.parseInt(tok.nextToken());
+			events[i] = le*2;
+			events[i + n] = ri*2 + 1;
+		}
+		shuffleArray(events);
+		Arrays.sort(events);
+		
+		int ans = 0;
+		int balance = 0;
+		for (int r = 0; r < 2*n;) {
+			int l = r;
+			while (r < 2*n && events[l] == events[r]) {
+				++r;
+			}
+			int added = r - l;
+			if (events[l] % 2 == 0) {
+				// Open event
+				ans += C(balance + added, k);
+				if (ans >= MOD) ans -= MOD;
+				ans += MOD - C(balance, k);
+				if (ans >= MOD) ans -= MOD;
+				balance += added;
+			} else {
+				// Close event
+				balance -= added;
+			}
+		}
+		
+		in.close();
+		System.out.println(ans);
+	}
+	
+	public static void main(String[] args) throws IOException {
+		(new D_Java()).doIt();
+	}
+}
+","import java.io.*;
+import java.util.*;
+
+public class D_Java {
+	public static final int MOD = 998244353;
+	
+	public static int mul(int a, int b) {
+		return (int)((long)a * (long)b % MOD);
+	}
+	
+	int[] f;
+	int[] rf;
+	
+	public int C(int n, int k) {
+		return (k < 0 || k > n) ? 0 : mul(f[n], mul(rf[n-k], rf[k]));
+	}
+	
+	public static int pow(int a, int n) {
+		int res = 1;
+		while (n != 0) {
+			if ((n & 1) == 1) {
+				res = mul(res, a);
+			}
+			a = mul(a, a);
+			n >>= 1;
+		}
+		return res;
+	}
+	
+	static void shuffleArray(int[] a) {
+		Random rnd = new Random();
+		for (int i = a.length-1; i > 0; i--) {
+			int index = rnd.nextInt(i + 1);
+			int tmp = a[index];
+			a[index] = a[i];
+			a[i] = tmp;
+		}
+	}
+	
+	public static int inv(int a) {
+		return pow(a, MOD-2);
+	}
+	
+	public void doIt() throws IOException {
+		BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
+		
+		StringTokenizer tok = new StringTokenizer(in.readLine());
+		int n = Integer.parseInt(tok.nextToken());
+		int k = Integer.parseInt(tok.nextToken());
+		
+		f = new int[n+42];
+		rf = new int[n+42];
+		f[0] = rf[0] = 1;
+		for (int i = 1; i < f.length; ++i) {
+			f[i] = mul(f[i-1], i);
+			rf[i] = mul(rf[i-1], inv(i));
+		}
+		
+		int[] events = new int[2*n];
+		for (int i = 0; i < n; ++i) {
+			tok = new StringTokenizer(in.readLine());
+			int le = Integer.parseInt(tok.nextToken());
+			int ri = Integer.parseInt(tok.nextToken());
+			events[i] = le*2;
+			events[i + n] = ri*2 + 1;
+		}
+		shuffleArray(events);
+		Arrays.sort(events);
+		
+		int ans = 0;
+		int balance = 0;
+		for (int r = 0; r < 2*n;) {
+			int l = r;
+			while (r < 2*n && events[l] == events[r]) {
+				++r;
+			}
+			int added = r - l;
+			if (events[l] % 2 == 0) {
+				// Open event
+				ans += C(balance + added, k);
+				if (ans >= MOD) ans -= MOD;
+				ans += MOD - C(balance, k);
+				if (ans >= MOD) ans -= MOD;
+				balance += added;
+			} else {
+				// Close event
+				balance -= added;
+			}
+		}
+		
+		in.close();
+		System.out.println(ans);
+	}
+	
+	public static void main(String[] args) throws IOException {
+		(new D_Java()).doIt();
+	}
+}",1
+4be01508,b7de5c19,"import java.util.*;
+import java.io.*;
+
+public class q3{
+    static FastScanner fs = new FastScanner();
+    static PrintWriter pw = new PrintWriter(System.out);
+    static List<List<Edge>> list;
+    public static void main(String[] args){
+        int tt = fs.nextInt();
+        for (int t=0;t<tt;t++){
+            solve();
+        }
+        pw.close();
+    }
+
+    static void solve(){
+        int n = fs.nextInt();
+        list = new ArrayList<>();
+        for (int i=0;i<n;i++) list.add(new ArrayList<>());
+        
+        for (int i=0;i<n-1;i++){
+            int from = fs.nextInt()-1, to = fs.nextInt()-1;
+            list.get(from).add(new Edge(to, i));
+            list.get(to).add(new Edge(from, i));
+        }
+
+        int start = -1;
+        for (int i=0;i<n;i++){
+            if (list.get(i).size() > 2){
+                pw.println(-1);
+                return;
+            }
+            else if (list.get(i).size() == 1){
+                start = i;
+            }
+        }   
+
+        int[] ans = new int[n-1];
+        int prev = -1;
+        int cur = start;
+        int curWeight = 2;
+        while (true){
+            Edge now = list.get(cur).get(0);
+            if (now.node == prev){
+                if (list.get(cur).size() == 1){
+                    break;
+                }
+                now = list.get(cur).get(1);
+            }
+
+            ans[now.index] = 5 - curWeight;
+            curWeight = ans[now.index];
+            prev = cur;
+            cur = now.node;
+        }
+
+        for (int i : ans){
+            pw.printf(""%d "", i);
+        }
+        pw.println();
+    }
+
+    static class Edge {
+        int node;
+        int index;
+
+        public Edge(int node, int index){
+            this.node = node;
+            this.index = index;
+        }
+    }
+
+//    ----------input function----------
+
+    static void sort(int[] a){
+        ArrayList<Integer> L = new ArrayList<>();
+        for (int i : a) L.add(i);
+        Collections.sort(L);
+        for (int i = 0; i < a.length; i++) a[i] = L.get(i);
+    }
+
+    static class FastScanner{
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st = new StringTokenizer("""");
+        String next(){
+            while (!st.hasMoreTokens()){
+                try{
+                    st = new StringTokenizer(br.readLine());
+                }catch (IOException e){
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt(){
+            return Integer.parseInt(next());
+        }
+
+        int[] readArray(int n){
+            int[] a = new int[n];
+            for (int i = 0; i < n; i++) a[i] = nextInt();
+            return a;
+        }
+
+        long nextLong(){
+            return Long.parseLong(next());
+        }
+    }
+}
+","import java.util.*;
+
+public class Main {
+    public static void main(String[] args) {
+        Scanner scan = new Scanner(System.in);
+        int t = scan.nextInt();
+        for (int i = 0; i < t; i++) {
+            int n = scan.nextInt();
+            ArrayList<ArrayList<Pair>> graph = new ArrayList<>();
+            for (int j = 0; j < n; j++) {
+                graph.add(new ArrayList<>());
+            }
+            for (int j = 0; j < n - 1; j++) {
+                int u;
+                int v;
+                u = scan.nextInt();
+                v = scan.nextInt();
+                u--;
+                v--;
+                graph.get(u).add(new Pair(v, j));
+                graph.get(v).add(new Pair(u, j));
+            }
+            boolean soluble = true;
+            int curV = 0;
+            int prevV = -1;
+            int[] ans = new int[n];
+            int prime = 2;
+            for (int j = 0; j < n; j++) {
+                ArrayList<Pair> list = graph.get(j);
+                if (list.size() > 2) {
+                    soluble = false;
+                } else if (list.size() == 1) {
+                    curV = j;
+                }
+            }
+            if (soluble) {
+                for (int j = 0; j < n - 1; j++) {
+                    ArrayList<Pair> list = graph.get(curV);
+                    for (int z = 0; z < list.size(); z++) {
+                        if (list.get(z).vertex != prevV) {
+                            ans[list.get(z).numberOfEdge] = prime;
+                            prime = changePrime(prime);
+                            prevV = curV;
+                            curV = list.get(z).vertex;
+                            break;
+                        }
+                    }
+                }
+
+                for (int j = 0; j < n - 1; j++) {
+                    System.out.print(ans[j] + "" "");
+                }
+                System.out.println();
+            } else {
+                System.out.println(-1);
+            }
+        }
+    }
+    public static int changePrime(int prime) {
+        if (prime == 2) {
+            prime = 3;
+        } else {
+            prime = 2;
+        }
+        return prime;
+    }
+}
+
+class Pair {
+    int vertex;
+    int numberOfEdge;
+
+    public Pair(int vertex, int numberOfEdge) {
+        this.vertex = vertex;
+        this.numberOfEdge = numberOfEdge;
+    }
+}
+",0
+3dd65549,c1638a45,"import java.util.*;
+import java.io.*;
+
+public class codeforces {
+	public static void main(String[] args) throws Exception {
+		int t=sc.nextInt();
+		while(t-->0) {
+			int n=sc.nextInt();
+			char[] a=sc.next().toCharArray();
+			char[] b=sc.next().toCharArray();
+			int e0=0;
+			int e1=0;
+			int o0=0;
+			int o1=0;
+			for(int i=0;i<n;i++) {
+				if(a[i]!=b[i]) {
+					if(a[i]=='1') {
+						e1++;
+					}else {
+						e0++;
+					}
+				}else {
+					if(a[i]=='1') {
+						o1++;
+					}else {
+						o0++;
+					}
+				}
+			}
+			int ans=Integer.MAX_VALUE;
+			
+			if(e1==e0) {
+				ans=Math.min(ans, e1+e0);
+			}
+			if(o1==o0+1) {
+				ans=Math.min(ans, o1+o0);
+			}
+//			pw.println(e0+"" ""+e1+"" ""+o0+"" ""+o1);
+			pw.println(ans==Integer.MAX_VALUE?-1:ans);
+		}
+		pw.close();
+	}
+
+	static class Scanner {
+		StringTokenizer st;
+		BufferedReader br;
+
+		public Scanner(InputStream s) {
+			br = new BufferedReader(new InputStreamReader(s));
+		}
+
+		public Scanner(FileReader r) {
+			br = new BufferedReader(r);
+		}
+
+		public String next() throws IOException {
+			while (st == null || !st.hasMoreTokens())
+				st = new StringTokenizer(br.readLine());
+			return st.nextToken();
+		}
+
+		public int nextInt() throws IOException {
+			return Integer.parseInt(next());
+		}
+
+		public long nextLong() throws IOException {
+			return Long.parseLong(next());
+		}
+
+		public String nextLine() throws IOException {
+			return br.readLine();
+		}
+
+		public double nextDouble() throws IOException {
+			String x = next();
+			StringBuilder sb = new StringBuilder(""0"");
+			double res = 0, f = 1;
+			boolean dec = false, neg = false;
+			int start = 0;
+			if (x.charAt(0) == '-') {
+				neg = true;
+				start++;
+			}
+			for (int i = start; i < x.length(); i++)
+				if (x.charAt(i) == '.') {
+					res = Long.parseLong(sb.toString());
+					sb = new StringBuilder(""0"");
+					dec = true;
+				} else {
+					sb.append(x.charAt(i));
+					if (dec)
+						f *= 10;
+				}
+			res += Long.parseLong(sb.toString()) / f;
+			return res * (neg ? -1 : 1);
+		}
+
+		public long[] nextlongArray(int n) throws IOException {
+			long[] a = new long[n];
+			for (int i = 0; i < n; i++)
+				a[i] = nextLong();
+			return a;
+		}
+
+		public Long[] nextLongArray(int n) throws IOException {
+			Long[] a = new Long[n];
+			for (int i = 0; i < n; i++)
+				a[i] = nextLong();
+			return a;
+		}
+
+		public int[] nextIntArray(int n) throws IOException {
+			int[] a = new int[n];
+			for (int i = 0; i < n; i++)
+				a[i] = nextInt();
+			return a;
+		}
+
+		public Integer[] nextIntegerArray(int n) throws IOException {
+			Integer[] a = new Integer[n];
+			for (int i = 0; i < n; i++)
+				a[i] = nextInt();
+			return a;
+		}
+
+		public boolean ready() throws IOException {
+			return br.ready();
+		}
+
+	}
+
+	static class pair implements Comparable<pair> {
+		long x;
+		long y;
+
+		public pair(long x, long y) {
+			this.x = x;
+			this.y = y;
+		}
+
+		public String toString() {
+			return x + "" "" + y;
+		}
+
+		public boolean equals(Object o) {
+			if (o instanceof pair) {
+				pair p = (pair) o;
+				return p.x == x && p.y == y;
+			}
+			return false;
+		}
+
+		public int hashCode() {
+			return new Long(x).hashCode() * 31 + new Long(y).hashCode();
+		}
+
+		public int compareTo(pair other) {
+			if (this.x == other.x) {
+				return Long.compare(this.y, other.y);
+			}
+			return Long.compare(this.x, other.x);
+		}
+	}
+
+	static class tuble implements Comparable<tuble> {
+		int x;
+		int y;
+		int z;
+
+		public tuble(int x, int y, int z) {
+			this.x = x;
+			this.y = y;
+			this.z = z;
+		}
+
+		public String toString() {
+			return x + "" "" + y + "" "" + z;
+		}
+
+		public int compareTo(tuble other) {
+			if (this.x == other.x) {
+				if (this.y == other.y) {
+					return this.z - other.z;
+				}
+				return this.y - other.y;
+			} else {
+				return this.x - other.x;
+			}
+		}
+	}
+
+	static long mod = 1000000007;
+	static Random rn = new Random();
+	static Scanner sc = new Scanner(System.in);
+	static PrintWriter pw = new PrintWriter(System.out);
+}","import java.io.*;
+import java.util.*;
+public class qC {
+
+	public static void main(String[] args)throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		int T = Integer.parseInt(br.readLine());
+		while(T-- > 0) {
+			int N = Integer.parseInt(br.readLine());
+			char[] curr = br.readLine().toCharArray();
+			char[] sol = br.readLine().toCharArray();
+//			int oddP = 0;
+//			int evenP = 0;
+//			int even1 = 0;
+//			int odd1 = 0;
+//			int even0 = 0;
+//			int odd0 = 0;
+//			boolean alreadySolved = true;
+//			for(int i = 0;i < N;i++) {
+//				if(curr[i] == sol[i]) {
+//					evenP++;
+//					if(curr[i] == '1') even1++;
+//					else even0++;
+//				}
+//				else {
+//					oddP++;
+//					if(curr[i] == '1') odd1++;
+//					else odd0++;
+//					alreadySolved = false;
+//				}
+//			}
+//			
+//			if(alreadySolved) {
+//				System.out.println(0);
+//				continue;
+//			}
+//			int minSwaps = Integer.MAX_VALUE;
+//			if(N % 2 == 1) {
+//				if(evenP % 2 == 1 && Math.abs(odd1 - odd0) <= 1 && odd1 > 0 && odd0 > 0) {
+//					minSwaps = Math.min(minSwaps, oddP);
+//				}
+//				if(oddP % 2 == 0 && Math.abs(even1 - even0) <= 1 && even1 > 0 && even1 > 0) {
+//					minSwaps = Math.min(minSwaps, evenP);
+//				}
+//			}
+//			else {
+//				if(evenP % 2 == 0 && Math.abs(odd1 - odd0) <= 1 && odd1 > 0 && odd0 > 0) {
+//					minSwaps = Math.min(minSwaps, oddP);
+//				}
+//				if(oddP % 2 == 1 && Math.abs(even1 - even0) <= 1 && even1 > 0 && even1 > 0) {
+//					minSwaps = Math.min(minSwaps, evenP);
+//				}
+//			}
+//			System.out.println((minSwaps == Integer.MAX_VALUE) ? -1: minSwaps);
+			
+			int curr1 = 0;
+			int sol1 = 0;
+			int mismatch = 0;
+			for(int i = 0;i < N;i++) {
+				if(curr[i] == '1') curr1++;
+				if(sol[i] == '1') sol1++;
+				if(curr[i] != sol[i]) mismatch++;
+			}
+			
+			int minAns = Integer.MAX_VALUE;
+			//even operations
+			if(curr1 == sol1 && mismatch % 2 == 0) {
+				minAns = Math.min(mismatch, minAns);
+			}
+			//odd operations
+			for(int i = 0;i < N;i++) {
+				if(curr[i] == '1') {
+					int tempcurr1 = N - curr1 + 1;
+					int tempmismatch;
+					if(sol[i] == '0') {
+						tempmismatch = N - mismatch;
+					}
+					else {
+						tempmismatch = N - mismatch - 1;
+					}
+					if(tempcurr1 == sol1 && tempmismatch % 2 == 0) {
+						minAns = Math.min(minAns, tempmismatch + 1);
+					}
+				}
+			}
+			
+			System.out.println((minAns == Integer.MAX_VALUE) ? -1 : minAns);
+		}
+
+	}
+
+}
+",0
+6e207cbf,76ad805a,"import java.util.*;
+import java.lang.*;
+import java.io.*;
+
+public class Codechef
+{
+	public static void main (String[] args) throws java.lang.Exception
+	{
+        Scanner sc = new Scanner(System.in);
+        int t = sc.nextInt();
+        int sm, n;
+        while(t > 0) {
+            t--;
+            n = sc.nextInt();
+            String s1,s2;
+            s1 = sc.next();
+            s2 = sc.next();
+            int a[] = new int[4];
+            a[0] = 0; a[1] = 0; a[2] = 0; a[3] = 0;
+            for(int i = 0 ; i < n ; i++) {
+                if(s1.charAt(i) == '0'&& s2.charAt(i) == '1') a[0]++;
+                else if(s1.charAt(i) == '1'&& s2.charAt(i) == '0') a[1]++;
+                else if(s1.charAt(i) == '1'&& s2.charAt(i) == '1') a[2]++;
+                else a[3]++;
+            }
+            // System.out.println(a[0] + "" "" + a[1] + "" "" + a[2] + "" "" + a[3]);
+            int n1 = Integer.MAX_VALUE, n2 = Integer.MAX_VALUE, n3 = Integer.MAX_VALUE;
+            
+            if (a[0] == a[1]) {
+                n1 = 2*a[0];
+            }
+            if((a[2] - 1) == a[3]) {
+                // System.out.println(a[3] + 1);
+                n2 = 2*a[3] + 1;
+            } 
+            if((a[3] + 1) == a[2]) {
+                // System.out.println(a[2] + 1);
+                n3 = 2*a[2] + 1;
+            } 
+            int ans = Math.min(n1, Math.min(n2,n3));
+            if(ans == Integer.MAX_VALUE) {
+                System.out.println(""-1"");
+            } else {
+                System.out.println(ans);
+            }
+        }
+	}
+}
+","import java.util.Arrays;
+import java.util.Scanner;
+
+public class First {
+    static Scanner sc = new Scanner(System.in);
+    public static void main(String[] args) {
+        int t = sc.nextInt();
+        while (t-- > 0) {
+            int n = sc.nextInt();
+            String a = sc.next();
+            String b = sc.next();
+            char ch1[] = a.toCharArray();
+            char ch2[] = b.toCharArray();
+            int zz = 0;
+            int oz = 0;
+            int zo = 0;
+            int oo = 0;
+            for (int i = 0; i < n; i++) {
+                if (ch1[i] == '0') {
+                    if (ch2[i] == '0') {
+                        zz += 1;
+                    } else {
+                        oz += 1;
+                    }
+                } else {
+                    if (ch2[i] == '0') {
+                        zo += 1;
+                    } else {
+                        oo += 1;
+                    }
+                }
+            }
+            int ans = -1;
+            if ((oo - zz) == 1 || zo == oz) {
+                int s1 = (int) 1e7;
+                int s2 = (int) 1e7;
+                if ((oo - zz) == 1) {
+                    s1 = oo + zz;
+                }
+                if (zo == oz)
+                    s2 = zo + oz;
+                ans = Math.min(s1, s2);
+            }
+            System.out.println(ans);
+        }
+    }
+}
+
+//9
+//001011011
+//011010101    3 2 2 2
+//9
+//100010111
+//101101100    2 1 3 3",0
+3368f340,d8a171a3,"//package Codeforces;
+
+import java.io.*;
+import java.util.*;
+
+public class Menorah {
+    public static void main(String[] args) throws IOException {
+        Scanner sc = new Scanner(System.in);
+
+        int t = sc.nextInt();
+        StringBuilder sb = new StringBuilder();
+        while (t-->0){
+            int n = sc.nextInt();
+            char[] a = sc.next().toCharArray();
+            char[] b = sc.next().toCharArray();
+
+            int a1=0, b1=0;
+            for(int i=0;i<n;i++){
+                if(a[i]=='1')
+                    a1++;
+                if(b[i]=='1')
+                    b1++;
+            }
+
+            int min = 100000000;
+
+            if(a1==b1){
+                int c = 0;
+                for(int i=0;i<n;i++){
+                    if(a[i]!=b[i])
+                        c++;
+                }
+
+                min = Math.min(min, c);
+            }
+
+            if(b1==(n-a1+1)){
+                int ind = -1;
+                for(int i=0;i<n;i++){
+                    if(a[i]==b[i] && a[i]=='1'){
+                        ind = i;
+                        break;
+                    }
+                }
+
+                int c = 0;
+                for(int i=0;i<n;i++){
+                    if(i==ind)
+                        continue;
+
+                    if(a[i]==b[i])
+                        c++;
+                }
+
+                min = Math.min(min, c + 1);
+            }
+
+            if(min == 100000000)
+                sb.append(""-1\n"");
+            else sb.append(min).append(""\n"");
+        }
+
+        System.out.println(sb);
+
+        sc.close();
+    }
+}
+","import java.io.*;
+import java.util.*;
+
+public class B {
+	
+	public static void main(String[] args)throws IOException {
+		
+		FastScanner scan = new FastScanner();
+		PrintWriter output = new PrintWriter(System.out);
+		int t = scan.nextInt();
+		for(int tt = 0;tt<t;tt++) {
+			int n = scan.nextInt();
+			char initial[] = scan.next().toCharArray();
+			char desired[] = scan.next().toCharArray();
+			int lit1 = 0, lit2 = 0;
+			int ans = Integer.MAX_VALUE;
+			for(int i = 0;i<n;i++) {
+				if(initial[i]=='1') lit1++;
+				if(desired[i]=='1') lit2++;
+			}
+			if(lit1==lit2) {
+				int count = 0;
+				for(int i = 0;i<n;i++) if(initial[i]!=desired[i]) count++;
+				ans = Math.min(ans, count);
+			}
+			if(lit2==(n-lit1+1)) {
+				int count = 0;
+				for(int i = 0;i<n;i++) if(initial[i]==desired[i]) count++;
+				ans = Math.min(ans, count);
+			}
+			if(ans == Integer.MAX_VALUE) ans = -1;
+			output.println(ans);	
+		}
+		output.flush();
+	}
+	
+	public static int[] sort(int arr[]) {
+		List<Integer> list = new ArrayList<>();
+		for(int i:arr) list.add(i);
+		Collections.sort(list);
+		for(int i = 0;i<list.size();i++) arr[i] = list.get(i);
+		return arr;
+	}
+	
+	public static int gcd(int a, int b) {
+		if(a == 0) return b;
+		return gcd(b%a, a);
+	}
+	
+	public static void printArray(int arr[]) {
+		for(int i:arr) System.out.print(i+"" "");
+		System.out.println();
+	}
+	
+	static class FastScanner {
+		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st=new StringTokenizer("""");
+		String next() {
+			while (!st.hasMoreTokens())
+				try {
+					st=new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			return st.nextToken();
+		}
+
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+		int[] readArray(int n) {
+			int[] a=new int[n];
+			for (int i=0; i<n; i++) a[i]=nextInt();
+			return a;
+		}
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+		
+		double nextDouble() {
+			return Double.parseDouble(next());
+		}
+	}
+
+}
+",0
+464a03b8,c9159d9c,"import java.util.*;
+
+public class Soltion{
+ 
+     public static void main(String []args){
+        Scanner sc = new Scanner(System.in);
+        int t = sc.nextInt();
+        
+        while(t-->0){
+            int n = sc.nextInt();
+            Integer[] arr = new Integer[n];
+            for(int i=0;i<n;i++){
+                arr[i] = sc.nextInt();
+            }
+            String s = sc.next();
+            
+            List<Integer> blue = new ArrayList<>();
+            List<Integer> red = new ArrayList<>();
+            
+            for(int i=0;i<s.length();i++){
+                if(s.charAt(i)=='B'){
+                    blue.add(arr[i]);
+                }
+                else{
+                    red.add(arr[i]);
+                }
+            }
+            
+            Collections.sort(blue);
+            Collections.sort(red);
+            int p=1,q=n;
+            
+            boolean flag = true;
+            for(int i=red.size()-1;i>=0;i--){
+                if(red.get(i)>q){
+                    flag = false;
+                    break;
+                }
+                q--;
+            }
+            
+            for(int i=0;i<blue.size();i++){
+                if(blue.get(i)<p){
+                    flag = false;
+                    break;
+                }
+                p++;
+            }
+            
+            System.out.println(flag? ""Yes"" : ""No"");
+        }
+     }
+}
+","import java.util.*;
+
+public class SolutionB {
+
+    public static long gcd(long a, long b){
+        if(b==0){
+            return a;
+        }
+        return gcd(b, a%b);
+    }
+
+    public static long gcdSum(long b){
+        long a = 0;
+
+        long temp = b;
+        while(temp!=0){
+            a = a + temp%10;
+            temp = temp/10;
+        }
+        return gcd(a,b);
+
+    }
+
+    public static class Pair{
+        Long a;
+        Long b;
+
+        public Pair(Long a, Long b) {
+            this.a = a;
+            this.b = b;
+        }
+    }
+
+    public static long factorial (long n){
+        if(n==0)
+            return 1;
+        else if(n==1)
+            return n;
+
+        return n * factorial(n-1);
+    }
+
+    public static long lcm (long n){
+        if(n<3)
+            return n;
+        return lcmForBig(n,n-1);
+    }
+
+    private static long lcmForBig(long n, long l) {
+        if(l==1)
+            return n;
+        n = (n * l) / gcd(n, l);
+        return lcmForBig(n, l-1);
+
+    }
+
+
+    public static void main(String[] args){
+        Scanner s = new Scanner(System.in);
+        
+        int t = s.nextInt();
+
+        for(int i =0;i<t;i++) {
+            int n = s.nextInt();
+            int arr [] = new int[n];
+            ArrayList<Integer> blue = new ArrayList<>();
+            ArrayList<Integer> red = new ArrayList<>();
+
+            for(int j=0;j<n;j++){
+                int num = s.nextInt();
+                arr[j]=num;
+            }
+            String color = s.next();
+
+            for(int j=0;j<n;j++){
+                if(color.charAt(j)=='B'){
+                    blue.add(arr[j]);
+                }
+                else{
+                    red.add(arr[j]);
+                }
+            }
+            Collections.sort(blue);
+            String ans = ""YES"";
+            int counter = 0;
+
+            for(int j=0;j<blue.size();j++){
+                int current = blue.get(j);
+                if (current<1){
+                    ans=""NO"";
+                    break;
+                }
+                if(current>counter){
+                    counter++;
+                }
+                else{
+                    ans=""NO"";
+                    break;
+                }
+
+            }
+
+            if(ans==""NO""){
+                System.out.println(ans);
+            }
+            else{
+                int tempCounter = n+1;
+                Collections.sort(red);
+                for(int j=red.size()-1;j>=0;j--){
+                    int  current  = red.get(j);
+                    if(current>=tempCounter){
+                        ans=""NO"";
+                        break;
+                    }
+                    else{
+                        tempCounter--;
+                    }
+                }
+                if(tempCounter-counter!=1)
+                    System.out.println(""NO"");
+                else
+                    System.out.println(ans);
+            }
+
+        }
+
+        return;
+    }
+}
+",0
+a8f7c8b7,c1638a45,"
+import java.util.Scanner;
+
+public class Menorah {
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        int t = sc.nextInt();
+        while (t-- > 0) {
+            int n = sc.nextInt();
+            char initial[] = sc.next().toCharArray();
+            char desired[] = sc.next().toCharArray();
+            int lit1 = 0, lit2 = 0;
+            int ans = Integer.MAX_VALUE;
+            for (int i = 0; i < n; i++) {
+                if (initial[i] == '1') {
+                    ++lit1;
+                }
+                if (desired[i] == '1') {
+                    ++lit2;
+                }
+            }
+            if (lit1 == lit2) {
+                int count = 0;
+                for (int i = 0; i < n; i++) {
+                    if (initial[i] != desired[i]) {
+                        ++count;
+                    }
+                }
+                ans = Math.min(count, ans);
+            }
+            if (lit2 == (n - lit1 + 1)) {
+                int count = 0;
+                for (int i = 0; i < n; i++) {
+                    if (initial[i] == desired[i]) {
+                        ++count;
+                    }
+                }
+                ans = Math.min(ans, count);
+            }
+            if (ans == Integer.MAX_VALUE) {
+                System.out.println(-1);
+            } else {
+                System.out.println(ans);
+            }
+        }
+    }
+}","import java.io.*;
+import java.util.*;
+public class qC {
+
+	public static void main(String[] args)throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		int T = Integer.parseInt(br.readLine());
+		while(T-- > 0) {
+			int N = Integer.parseInt(br.readLine());
+			char[] curr = br.readLine().toCharArray();
+			char[] sol = br.readLine().toCharArray();
+//			int oddP = 0;
+//			int evenP = 0;
+//			int even1 = 0;
+//			int odd1 = 0;
+//			int even0 = 0;
+//			int odd0 = 0;
+//			boolean alreadySolved = true;
+//			for(int i = 0;i < N;i++) {
+//				if(curr[i] == sol[i]) {
+//					evenP++;
+//					if(curr[i] == '1') even1++;
+//					else even0++;
+//				}
+//				else {
+//					oddP++;
+//					if(curr[i] == '1') odd1++;
+//					else odd0++;
+//					alreadySolved = false;
+//				}
+//			}
+//			
+//			if(alreadySolved) {
+//				System.out.println(0);
+//				continue;
+//			}
+//			int minSwaps = Integer.MAX_VALUE;
+//			if(N % 2 == 1) {
+//				if(evenP % 2 == 1 && Math.abs(odd1 - odd0) <= 1 && odd1 > 0 && odd0 > 0) {
+//					minSwaps = Math.min(minSwaps, oddP);
+//				}
+//				if(oddP % 2 == 0 && Math.abs(even1 - even0) <= 1 && even1 > 0 && even1 > 0) {
+//					minSwaps = Math.min(minSwaps, evenP);
+//				}
+//			}
+//			else {
+//				if(evenP % 2 == 0 && Math.abs(odd1 - odd0) <= 1 && odd1 > 0 && odd0 > 0) {
+//					minSwaps = Math.min(minSwaps, oddP);
+//				}
+//				if(oddP % 2 == 1 && Math.abs(even1 - even0) <= 1 && even1 > 0 && even1 > 0) {
+//					minSwaps = Math.min(minSwaps, evenP);
+//				}
+//			}
+//			System.out.println((minSwaps == Integer.MAX_VALUE) ? -1: minSwaps);
+			
+			int curr1 = 0;
+			int sol1 = 0;
+			int mismatch = 0;
+			for(int i = 0;i < N;i++) {
+				if(curr[i] == '1') curr1++;
+				if(sol[i] == '1') sol1++;
+				if(curr[i] != sol[i]) mismatch++;
+			}
+			
+			int minAns = Integer.MAX_VALUE;
+			//even operations
+			if(curr1 == sol1 && mismatch % 2 == 0) {
+				minAns = Math.min(mismatch, minAns);
+			}
+			//odd operations
+			for(int i = 0;i < N;i++) {
+				if(curr[i] == '1') {
+					int tempcurr1 = N - curr1 + 1;
+					int tempmismatch;
+					if(sol[i] == '0') {
+						tempmismatch = N - mismatch;
+					}
+					else {
+						tempmismatch = N - mismatch - 1;
+					}
+					if(tempcurr1 == sol1 && tempmismatch % 2 == 0) {
+						minAns = Math.min(minAns, tempmismatch + 1);
+					}
+				}
+			}
+			
+			System.out.println((minAns == Integer.MAX_VALUE) ? -1 : minAns);
+		}
+
+	}
+
+}
+",0
+018c9543,d1dbc56a,"import java.io.*;
+import java.util.*;
+
+public class Main {
+    public static int n;
+    public static int a[] = new int[12];
+    public static int b[] = new int[12];
+
+    public static boolean f(int p) {
+        if (p > n) return false;
+
+        for (int i = 0; i < p; i++) {
+            b[p] = a[p] + b[i];
+            for (int j = 0; j < p; j++) {
+                if (b[j] == b[p])
+                    return true;
+            }
+            if (f(p + 1)) {
+                return true;
+            }
+
+
+//            b[p] = b[i] - a[p];
+//            for (int j = 0; j < p; j++) {
+//                if (b[j] == b[p])
+//                    return true;
+//            }
+//            if (f(p + 1)) {
+//                return true;
+//            }
+        }
+        return false;
+    }
+
+    public static void main(String[] args) throws Exception {
+        int T = r.readInt();
+        for (int t = 0; t < T; t++) {
+            n = r.readInt();
+            for (int i = 1; i <= n; i++) {
+                a[i] = r.readInt();
+            }
+
+            boolean ans = false;
+            if (n == 1) {
+                ans = a[1] == 0;
+            } else {
+                b[0] = 1;
+                ans = f(1);
+            }
+
+            if (ans) {
+                System.out.println(""YES"");
+            } else {
+                System.out.println(""NO"");
+            }
+        }
+    }
+
+    static public InputReader r = new InputReader(System.in);
+    static public OutputWriter w = new OutputWriter(System.out);
+
+    static public class InputReader {
+        private InputStream stream;
+        private byte[] buf = new byte[1024];
+        private int curChar;
+        private int numChars;
+        private InputReader.SpaceCharFilter filter;
+
+        public InputReader(InputStream stream) {
+            this.stream = stream;
+        }
+
+        public int read() {
+            if (numChars == -1)
+                throw new InputMismatchException();
+            if (curChar >= numChars) {
+                curChar = 0;
+                try {
+                    numChars = stream.read(buf);
+                } catch (IOException e) {
+                    throw new InputMismatchException();
+                }
+                if (numChars <= 0)
+                    return -1;
+            }
+            return buf[curChar++];
+        }
+
+        public int readInt() {
+            int c = read();
+            while (isSpaceChar(c))
+                c = read();
+            int sgn = 1;
+            if (c == '-') {
+                sgn = -1;
+                c = read();
+            }
+            int res = 0;
+            do {
+                if (c < '0' || c > '9')
+                    throw new InputMismatchException();
+                res *= 10;
+                res += c - '0';
+                c = read();
+            } while (!isSpaceChar(c));
+            return res * sgn;
+        }
+
+        public int[] readIntArray(int n) {
+            int[] array = new int[n];
+            for (int i = 0; i < n; i++) {
+                array[i] = this.readInt();
+            }
+            return array;
+        }
+
+        public long[] readLongArray(int n) {
+            long[] array = new long[n];
+            for (int i = 0; i < n; i++) {
+                array[i] = this.readLong();
+            }
+            return array;
+        }
+
+        public long readLong() {
+            int c = read();
+            while (isSpaceChar(c))
+                c = read();
+            int sgn = 1;
+            if (c == '-') {
+                sgn = -1;
+                c = read();
+            }
+            long res = 0;
+            do {
+                if (c < '0' || c > '9')
+                    throw new InputMismatchException();
+                res *= 10;
+                res += c - '0';
+                c = read();
+            } while (!isSpaceChar(c));
+            return res * sgn;
+        }
+
+        public String readString() {
+            int c = read();
+            while (isSpaceChar(c))
+                c = read();
+            StringBuilder res = new StringBuilder();
+            do {
+                res.appendCodePoint(c);
+                c = read();
+            } while (!isSpaceChar(c));
+            return res.toString();
+        }
+
+        public boolean isSpaceChar(int c) {
+            if (filter != null)
+                return filter.isSpaceChar(c);
+            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
+        }
+
+        public String next() {
+            return readString();
+        }
+
+        public interface SpaceCharFilter {
+            public boolean isSpaceChar(int ch);
+        }
+    }
+
+    static public class OutputWriter {
+        private final PrintWriter writer;
+
+        public OutputWriter(OutputStream outputStream) {
+            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
+        }
+
+        public OutputWriter(Writer writer) {
+            this.writer = new PrintWriter(writer);
+        }
+
+        public void print(Object... objects) {
+            for (int i = 0; i < objects.length; i++) {
+                if (i != 0)
+                    writer.print(' ');
+                writer.print(objects[i]);
+            }
+        }
+
+        public void printLine(Object... objects) {
+            print(objects);
+            writer.println();
+        }
+
+        public void close() {
+            writer.close();
+        }
+    }
+}
+
+//            1
+//            10
+//            1 2 4 8 16 32 64 128 256 512","import java.util.*;
+import java.io.*;
+public class D {
+	static ArrayList<Integer> set = new ArrayList<Integer>();
+	static int[] a;
+	static int test;
+	public static void main(String[] args) throws IOException{
+		Scanner in = new Scanner(System.in);
+		int t = in.nextInt();
+		for(int q=0;q<t;q++) {
+			int n = in.nextInt();
+			a = new int[n];
+			for(int i=0;i<n;i++) {
+				a[i] = Math.abs(in.nextInt());
+			}
+			boolean yes = false;
+			for(int i=0;i<n;i++) {
+				if(a[i]==0) yes = true;
+				int[] b = new int[n-1];
+				int index=0;
+				for(int j=0;j<n;j++) {
+					if(j!=i) {
+						b[index] = a[j];
+						index++;
+					}
+				}
+				test = a[i];
+				set = new ArrayList<Integer>();
+				if(b.length!=0) {
+					if(subset(b,0)) yes = true;					
+				}
+			}
+			if(yes) {
+				System.out.println(""YES"");
+			}else {
+				System.out.println(""NO"");
+			}
+		}
+	}
+	
+	static boolean subset(int[] a,int i) {
+//		System.out.println(set);
+		if(i>=a.length) {
+			if(binary(new int[set.size()],0)) return true;
+			return false;
+		}
+		set.add(a[i]);
+		if(subset(a,i+1))return true;
+		set.remove(set.size()-1);
+		if(subset(a,i+1))return true;
+		return false;
+	}
+	
+	static boolean binary(int[] b,int i) {
+		if(i==b.length) {
+			int sum=0;
+			for(int j=0;j<b.length;j++) {
+				if(b[j]==0) {
+					sum+= set.get(j);
+				}else {
+					sum-= set.get(j);
+				}
+			}
+//			System.out.println(sum+"" ""+test);
+			if(sum==test) {
+				return true;
+			}else {
+				return false;
+			}
+		}
+		b[i] = 0;
+		if(binary(b,i+1))return true;
+		b[i] = 1;
+		if(binary(b,i+1))return true;
+		return false;
+	}
+	
+}
+
+//Is only possible if you can use at least 1 number in b for at least 2 numbers in a
+
+",0
+1be078c4,f339ef6f,"import java.util.*;
+import java.io.*;
+
+public class E_1547 {
+	public static void main(String[] args) throws Exception {
+		Scanner sc = new Scanner(System.in);
+		PrintWriter pw = new PrintWriter(System.out);
+		
+		int T = sc.nextInt();
+		while(T-->0) {
+			int n = sc.nextInt(), k = sc.nextInt();
+			int[] a = sc.nextIntArray(k);
+			int[] t = sc.nextIntArray(k);
+			
+			int[] array = new int[n];
+			Arrays.fill(array, Integer.MAX_VALUE);
+			for(int i = 0; i < k; i++)
+				array[a[i] - 1] = t[i];
+			
+			int[] pre = new int[n];
+			int[] post = new int[n];
+			
+			int prev = (int)2e9;
+			for(int i = 0; i < n; i++)
+				prev = pre[i] = Math.min(prev + 1, array[i]);
+			
+			prev = (int)2e9;
+			for(int i = n - 1; i >= 0; i--)
+				prev = post[i] = Math.min(prev + 1, array[i]);
+			
+			for(int i = 0; i < n; i++)
+				array[i] = Math.min(pre[i], post[i]);
+			
+			for(int i = 0; i < n; i++)
+				pw.print(array[i] + (i == n - 1 ? ""\n"" : "" ""));
+		}
+		
+		pw.flush();
+	}
+
+	public static class Scanner {
+		StringTokenizer st;
+		BufferedReader br;
+
+		public Scanner(InputStream system) {
+			br = new BufferedReader(new InputStreamReader(system));
+		}
+
+		public Scanner(String file) throws Exception {
+			br = new BufferedReader(new FileReader(file));
+		}
+
+		public String next() throws IOException {
+			while (st == null || !st.hasMoreTokens())
+				st = new StringTokenizer(br.readLine());
+			return st.nextToken();
+		}
+
+		public String nextLine() throws IOException {
+			return br.readLine();
+		}
+
+		public int nextInt() throws IOException {
+			return Integer.parseInt(next());
+		}
+
+		public double nextDouble() throws IOException {
+			return Double.parseDouble(next());
+		}
+
+		public char nextChar() throws IOException {
+			return next().charAt(0);
+		}
+
+		public long nextLong() throws IOException {
+			return Long.parseLong(next());
+		}
+
+		public int[] nextIntArray(int n) throws IOException {
+			int[] array = new int[n];
+			for (int i = 0; i < n; i++)
+				array[i] = nextInt();
+			return array;
+		}
+
+		public Integer[] nextIntegerArray(int n) throws IOException {
+			Integer[] array = new Integer[n];
+			for (int i = 0; i < n; i++)
+				array[i] = new Integer(nextInt());
+			return array;
+		}
+
+		public long[] nextLongArray(int n) throws IOException {
+			long[] array = new long[n];
+			for (int i = 0; i < n; i++)
+				array[i] = nextLong();
+			return array;
+		}
+
+		public double[] nextDoubleArray(int n) throws IOException {
+			double[] array = new double[n];
+			for (int i = 0; i < n; i++)
+				array[i] = nextDouble();
+			return array;
+		}
+
+		public static int[] shuffle(int[] a) {
+			int n = a.length;
+			Random rand = new Random();
+			for (int i = 0; i < n; i++) {
+				int tmpIdx = rand.nextInt(n);
+				int tmp = a[i];
+				a[i] = a[tmpIdx];
+				a[tmpIdx] = tmp;
+			}
+			return a;
+		}
+
+		public boolean ready() throws IOException {
+			return br.ready();
+		}
+
+		public void waitForInput() throws InterruptedException {
+			Thread.sleep(3000);
+		}
+	}
+}
+","import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.List;
+import java.util.StringTokenizer;
+ 
+public class Main {
+	static FastReader fr;
+	static int arrForIndexSort[];
+	static class FastReader {
+        BufferedReader br;
+        StringTokenizer st;
+ 
+        public FastReader()
+        {
+            br = new BufferedReader(
+                new InputStreamReader(System.in));
+        }
+ 
+        String next()
+        {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                }
+                catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+ 
+        int nextInt() { return Integer.parseInt(next()); }
+ 
+        long nextLong() { return Long.parseLong(next()); }
+ 
+        double nextDouble()
+        {
+            return Double.parseDouble(next());
+        }
+ 
+        String nextLine()
+        {
+            String str = """";
+            try {
+                str = br.readLine();
+            }
+            catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+        }
+    }
+	static class Pair{
+		int first;
+		int second;
+		Pair(int first, int second){
+			this.first = first;
+			this.second = second;
+		}
+		@Override
+		public boolean equals(Object b) {
+			Pair a = (Pair)b;
+			if(this.first == a.first && this.second==a.second) {
+				return true;
+			}
+			return false;
+		}
+	}
+	class PairSorter implements Comparator<Main.Pair>{
+		public int compare(Pair a, Pair b) {
+			if(a.first!=b.first) {
+				return a.first-b.first;
+			}
+			return a.second-b.second; 
+		}
+	}
+	class IndexSorter implements Comparator<Integer>{
+		public int compare(Integer a, Integer b) {
+			//desc
+			if(arrForIndexSort[b]==arrForIndexSort[a]) {
+				return b-a;
+			}
+			return arrForIndexSort[b]-arrForIndexSort[a];
+		}
+	}
+	class ListSorter implements Comparator<List>{
+		public int compare(List a, List b) {
+			return b.size()-a.size(); 
+		}
+	}
+	static class DisjointSet{
+		int[] dsu;
+		public DisjointSet(int n) {
+			makeSet(n);
+		}
+		public void makeSet(int n) {
+			dsu = new int[n+1];
+			//*** 1 Based indexing ***
+			for(int i=1;i<=n;i++) {
+				dsu[i] = -1;
+			}
+		}
+		public int find(int i) {
+			while(dsu[i] > 0) {
+				i = dsu[i];
+			}
+			return i;
+		}
+		public void union(int i, int j) {
+			int iRep = find(i);
+			int jRep = find(j);
+			if(iRep == jRep) {
+				return;
+			}
+			if(dsu[iRep]>dsu[jRep]) {
+				dsu[jRep] += dsu[iRep];
+				dsu[iRep] = jRep;
+			}
+			else {
+				dsu[iRep] += dsu[jRep];
+				dsu[jRep] = iRep;
+			}
+		}
+	}
+	public static void main(String[] args) {
+		fr = new FastReader();
+		int T = 1;
+		T = fr.nextInt();
+		int t1 = T;
+		while (T-- > 0) {
+			solve();
+		}
+	}
+	public static void solve() {
+		int n=fr.nextInt();
+		int k=fr.nextInt();
+		int[] a = new int[k];
+		int[] map = new int[n];
+		int[] temp = new int[n];
+		Arrays.fill(temp, Integer.MAX_VALUE);
+		Arrays.fill(map, Integer.MAX_VALUE);
+		int min = Integer.MAX_VALUE;
+		int max = Integer.MIN_VALUE;
+		for(int i=0;i<k;i++) {
+			a[i] = fr.nextInt()-1;
+			min = Math.min(a[i], min);
+			max = Math.max(a[i], max);
+		}
+		for(int i=0;i<k;i++) {
+			map[a[i]] = fr.nextInt();
+		}
+		int diff = 0;
+		int curr = map[min];
+		for(int i=min;i<n;i++) {
+			int airConditioner = map[i];
+			if(airConditioner<curr+diff) {
+				temp[i] = airConditioner;
+				diff = 1;
+				curr = airConditioner;
+			}
+			else {
+				temp[i] = curr+diff;
+				diff++;
+			}
+			
+		}
+		diff = 0;
+		curr = map[max];
+		for(int i=max;i>=0;i--) {
+			int airConditioner = map[i];
+			if(airConditioner<curr+diff) {
+				temp[i] = Math.min(temp[i], airConditioner);
+				diff = 1;
+				curr = airConditioner;
+			}
+			else {
+				temp[i] =  Math.min(temp[i], curr+diff);
+				diff++;
+			}
+			
+		}
+		System.out.println(Arrays.toString(temp).replaceAll("",|\\[|\\]"",""""));
+		
+	}
+
+}",0
+120878da,ac180326,"import java.util.*;
+import java.lang.*;
+import java.io.*;
+
+public class codeforces
+{
+    public static class FastReader {  
+        BufferedReader br;
+        StringTokenizer st;
+ 
+        public FastReader()
+        {
+            br = new BufferedReader(
+                new InputStreamReader(System.in));
+        }
+ 
+        String next()
+        {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                }
+                catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+ 
+        int nextInt() { return Integer.parseInt(next()); }
+ 
+        long nextLong() { return Long.parseLong(next()); }
+ 
+        double nextDouble()
+        {
+            return Double.parseDouble(next());
+        }
+ 
+        String nextLine()
+        {
+            String str = """";
+            try {
+                str = br.readLine();
+            }
+            catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+        }
+    }
+	public static void main (String[] args) throws java.lang.Exception
+	{
+		// your code goes here
+		FastReader sc=new FastReader();
+		int t=sc.nextInt();
+		while(t-->0)
+		{
+		    int n=sc.nextInt();
+		    int m=sc.nextInt();
+		    int x=sc.nextInt();
+		    PriorityQueue<pair> pq=new PriorityQueue<>(new myComp());
+		    myarr a[]=new myarr[n];
+		    int b[]=new int[n];
+		  //  int c[]=new int[m];
+		    for(int i=0;i<n;i++)
+		    {
+		        a[i]=new myarr(sc.nextInt(),i);
+		    }
+		    Arrays.sort(a,new mycom());
+		    for(int i=0;i<m;i++)
+		    {
+		        pq.add(new pair(a[i].val,i+1));
+		      //  c[i]=a[i].val;
+		        b[a[i].ii]=i+1;
+		    }
+    		StringBuffer sb=new StringBuffer();
+		    boolean flag=false;
+		    if(m!=1)
+		    {
+    		    for(int i=m;i<n;i++)
+    		    {
+    		        pair p=pq.poll();
+    		        int g=p.b;
+    		        int h=pq.peek().b;
+    		        if(Math.abs((g+a[i].val)-h)<=x)
+    		        {
+    		            b[a[i].ii]=p.t;
+    		            pq.add(new pair(g+a[i].val,p.t));
+    		        }
+    		        else
+    		        {
+    		            flag=true;
+    		            break;
+    		        }
+    		    }
+    		    if(flag)
+    		    System.out.println(""NO"");
+    		    else
+    		    {
+    		        System.out.println(""YES"");
+    		        for(int i=0;i<n;i++)
+    		        {
+    		            sb.append(b[i]+"" "");
+    		        }
+    		        System.out.println(sb.toString());
+    		    }
+		    }
+		    else
+		    {
+    		    System.out.println(""YES"");
+    		    for(int i=0;i<n;i++)
+    		    {
+    		        sb.append(""1 "");
+    		    }
+    		    System.out.println(sb.toString());
+		    }
+		}
+	}
+	static class pair
+	{
+	    int b;
+	    int t;
+	    pair(int b,int t)
+	    {
+	        this.b=b;
+	        this.t=t;
+	    }
+	}
+	static class myComp implements Comparator<pair>
+	{
+	    public int compare(pair p1,pair p2)
+	    {
+	        if(p1.b==p2.b)
+	        return 0;
+	        else if(p1.b<p2.b)
+	        return -1;
+	        else
+	        return 1;
+	    }
+	}
+	static class myarr
+	{
+	    int val,ii;
+	    myarr(int val,int ii)
+	    {
+	        this.val=val;
+	        this.ii=ii;
+	    }
+	}
+	static class mycom implements Comparator<myarr>
+	{
+	    public int compare(myarr a,myarr b)
+	    {
+	        if(a.val==b.val)
+	        return 0;
+	        else if(a.val<b.val)
+	        return -1;
+	        else
+	        return 1;
+	    }
+	}
+}
+
+
+
+
+
+
+","//This code is written by प्रविण शंखपाळ 
+
+//package wizard;
+
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.text.DecimalFormat;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.Arrays;
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.Stack;
+import java.util.Queue;
+import java.util.PriorityQueue;
+import java.util.List;
+import java.util.HashSet;
+import java.util.LinkedHashSet;
+import java.util.TreeSet;
+import java.util.Map;
+import java.util.HashMap;
+import java.util.Scanner;
+import java.util.Set;
+import java.util.StringTokenizer;
+import java.util.Vector;
+
+public class Dobby {
+
+	public static void main(String[] args) {
+
+		try {
+
+			FastReader fr = new FastReader();
+			PrintWriter pt = new PrintWriter(System.out);
+
+			int t = fr.nextInt();
+
+			while (t > 0) {
+
+				int n = fr.nextInt(), m = fr.nextInt(), x = fr.nextInt();
+
+				ArrayList<Pair> pp = new ArrayList<>();
+
+				int A[] = new int[n];
+
+				for (int i = 0; i < n; i++) {
+					A[i] = fr.nextInt();
+					Pair pr = new Pair(A[i], i);
+					pp.add(pr);
+				}
+
+				Collections.sort(pp);
+				Collections.reverse(pp);
+
+				int ps[] = new int[n];
+				int pk[] = new int[n];
+				Arrays.fill(ps, 0);
+				Arrays.fill(pk, 0);
+
+				int index = 0;
+
+				for (int i = 0; i < n; i++) {
+
+					if (pk[index] < x) {
+						pk[index] += pp.get(i).a;
+					}
+					ps[pp.get(i).b] = index + 1;
+					index++;
+
+					index = index == m ? 0 : index;
+
+				}
+
+				pt.println(""YES"");
+
+				for (int i = 0; i < n; i++) {
+					pt.print(ps[i] + "" "");
+				}
+				pt.println();
+
+				t--;
+			}
+
+			pt.close();
+
+		} catch (
+
+		Exception e) {
+			return;
+		}
+	}
+
+	static void merge(long arr[], int l, int m, int r) {
+
+		int n1 = m - l + 1;
+		int n2 = r - m;
+
+		long L[] = new long[n1];
+		long R[] = new long[n2];
+
+		for (int i = 0; i < n1; ++i)
+			L[i] = arr[l + i];
+		for (int j = 0; j < n2; ++j)
+			R[j] = arr[m + 1 + j];
+
+		int i = 0, j = 0;
+
+		int k = l;
+		while (i < n1 && j < n2) {
+			if (L[i] <= R[j]) {
+				arr[k] = L[i];
+				i++;
+			} else {
+				arr[k] = R[j];
+				j++;
+			}
+			k++;
+		}
+
+		while (i < n1) {
+			arr[k] = L[i];
+			i++;
+			k++;
+		}
+
+		while (j < n2) {
+			arr[k] = R[j];
+			j++;
+			k++;
+		}
+	}
+
+	static void sort(long arr[], int l, int r) {
+		if (l < r) {
+
+			int m = l + (r - l) / 2;
+
+			sort(arr, l, m);
+			sort(arr, m + 1, r);
+
+			merge(arr, l, m, r);
+		}
+	}
+
+	static class Pair implements Comparable<Pair> {
+		int a, b;
+
+		Pair(int a, int b) {
+			this.a = a;
+			this.b = b;
+		}
+
+		public int compareTo(Pair o) {
+			// TODO Auto-generated method stub
+			if (this.a != o.a)
+				return Integer.compare(this.a, o.a);
+			else
+				return Integer.compare(this.b, o.b);
+			// return 0;
+		}
+
+		public boolean equals(Object o) {
+			if (o instanceof Pair) {
+				Pair p = (Pair) o;
+				return p.a == a && p.b == b;
+			}
+			return false;
+		}
+
+	}
+
+	static int binarySearch(int arr[], int first, int last, int key) {
+		int mid = (first + last) / 2;
+		while (first <= last) {
+			if (arr[mid] < key) {
+				first = mid + 1;
+			} else if (arr[mid] == key) {
+				return mid;
+			} else {
+				last = mid - 1;
+			}
+			mid = (first + last) / 2;
+		}
+		return -1;
+	}
+
+	static class FastReader {
+		BufferedReader br;
+		StringTokenizer st;
+
+		public FastReader() {
+			br = new BufferedReader(new InputStreamReader(System.in));
+		}
+
+		String next() {
+			while (st == null || !st.hasMoreElements()) {
+				try {
+					st = new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			}
+			return st.nextToken();
+		}
+
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+
+		double nextDouble() {
+			return Double.parseDouble(next());
+		}
+
+		String nextLine() {
+			String str = """";
+			try {
+				str = br.readLine();
+			} catch (IOException e) {
+				e.printStackTrace();
+			}
+			return str;
+		}
+	}
+}
+",0
+3f939694,54488276,"import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.util.StringTokenizer;
+import java.util.*;
+import java.io.*;
+public class Main {
+    public static void main(String args[])throws Exception{
+        Input sc=new Input();
+        StringBuilder sb=new StringBuilder();
+        int t=sc.readInt();
+        for(int f=0;f<t;f++){
+            int n=sc.readInt();
+            String str[]=new String[n];
+            for(int i=0;i<n;i++){
+                str[i]=sc.readString();
+            }
+            char ch[]={'a','b','c','d','e'};
+            int ans=0;
+            for(int i=0;i<5;i++){
+                char c=ch[i];
+                ArrayList<pair> lst=new ArrayList<>();
+                int a[]=new int[n];
+                for(int j=0;j<n;j++)
+                {
+                    int count=0;
+                    for(int k=0;k<str[j].length();k++){
+                        if(str[j].charAt(k)==c)
+                            count++;
+                    }
+                    lst.add(new pair(count,(str[j].length()-count)));
+                }
+                Collections.sort(lst);
+                int s1=0;int s2=0;
+//                for(int j=0;j<lst.size();j++){
+//                    System.out.println(lst.get(j).a+"" ""+lst.get(j).b);
+//                }
+//                System.out.println(""--------"");
+                int co=0;
+                for(int j=0;j<lst.size();j++){
+                    int v1=lst.get(j).a;
+                    int v2=lst.get(j).b;
+                    if((s1+v1)>(s2+v2)){
+                        s1+=v1;
+                        s2+=v2;
+                        co++;
+                    }
+                    //System.out.println(lst.get(j).a+"" ""+lst.get(j).b);
+                }
+                ans=Math.max(co,ans);
+
+            }
+            // count all 'a' in each string
+            sb.append(ans+""\n"");
+        }
+        System.out.print(sb);
+    }
+}
+class pair implements Comparable<pair>{
+    int a;
+    int b;
+    pair(int a,int b){
+        this.a=a;
+        this.b=b;
+    }
+
+    @Override
+    public int compareTo(pair o) {
+//        if(this.a!=o.a){
+//            return o.a-this.a;
+//        }else
+//            return this.b-o.b;
+        return -(this.a-this.b)+(o.a-o.b);
+    }
+}
+class Input{
+    BufferedReader br;
+    StringTokenizer st;
+    Input(){
+        br=new BufferedReader(new InputStreamReader(System.in));
+        st=new StringTokenizer("""");
+    }
+    public int[] readArray() throws Exception{
+        st=new StringTokenizer(br.readLine());
+        int a[]=new int[st.countTokens()];
+        for(int i=0;i<a.length;i++){
+            a[i]=Integer.parseInt(st.nextToken());
+        }
+        return a;
+    }
+    public long[] readArrayLong() throws Exception{
+        st=new StringTokenizer(br.readLine());
+        long a[]=new long[st.countTokens()];
+        for(int i=0;i<a.length;i++){
+            a[i]=Long.parseLong(st.nextToken());
+        }
+        return a;
+    }
+    public int readInt() throws Exception{
+        st=new StringTokenizer(br.readLine());
+        return Integer.parseInt(st.nextToken());
+    }
+    public long readLong() throws Exception{
+        st=new StringTokenizer(br.readLine());
+        return Long.parseLong(st.nextToken());
+    }
+    public String readString() throws Exception{
+        return br.readLine();
+    }
+    public int[][] read2dArray(int n,int m)throws Exception{
+        int a[][]=new int[n][m];
+        for(int i=0;i<n;i++){
+            st=new StringTokenizer(br.readLine());
+            for(int j=0;j<m;j++){
+                a[i][j]=Integer.parseInt(st.nextToken());
+            }
+        }
+        return a;
+    }
+}
+
+
+","import java.io.*;
+import java.util.*;
+
+public class C {
+	static int n;
+	public static void main (String[] args) throws IOException {
+		Kattio io = new Kattio();
+		int t = io.nextInt();
+		for (int ii=0; ii<t; ii++) {
+			n = io.nextInt();
+
+			String[] arr = new String[n];
+
+			for (int i=0; i<n; i++) {
+				String str = io.next();
+				arr[i] = str;
+			}
+
+			char[] chars = new char[]{'a','b','c','d','e'};
+
+			int ans = -1;
+
+			for (int i=0; i<5; i++) {
+				ans = Math.max(ans, solve(arr, chars[i]));
+			}
+			System.out.println(ans);
+		}
+	}
+
+	static int solve(String[] arr, char c) {
+		//System.out.println(""Comparing based on "" + c);
+		Arrays.sort(arr, new Comp(c));
+
+		int good = 0;
+		int total = 0;
+		int ret = 0;
+
+		for (int i=0; i<n; i++) {
+			//System.out.println(good + "" "" + total);
+			for (int j=0; j<arr[i].length(); j++) {
+				if (arr[i].charAt(j) == c) good++;
+			}
+			total += arr[i].length();
+			if (2 * good > total) {
+				ret++;
+			} else {
+				return ret;
+			}
+		}
+
+		return ret;
+	}
+
+	static class Comp implements Comparator<String> {
+		char c;
+
+		public Comp (char c) {
+			this.c = c;
+		}
+
+		public int compare(String a, String b) {
+			double cnt1 = 0;
+			double cnt2 = 0;
+			for (int i=0; i<a.length(); i++) {
+				if (a.charAt(i) == c) {
+					cnt1++;
+				}
+			}
+			for (int i=0; i<b.length(); i++) {
+				if (b.charAt(i) == c) {
+					cnt2++;
+				}
+			}
+			//higher ratio is better
+
+			return -Double.compare(cnt1 - (a.length() - cnt1), cnt2 - (b.length() - cnt2));
+		}
+	}
+
+	static class Kattio extends PrintWriter {
+		private BufferedReader r;
+		private StringTokenizer st;
+
+		// standard input
+		public Kattio() { this(System.in, System.out); }
+		public Kattio(InputStream i, OutputStream o) {
+			super(o);
+			r = new BufferedReader(new InputStreamReader(i));
+		}
+		// USACO-style file input
+		public Kattio(String problemName) throws IOException {
+			super(new FileWriter(problemName + "".out""));
+			r = new BufferedReader(new FileReader(problemName + "".in""));
+		}
+
+		// returns null if no more input
+		public String next() {
+			try {
+				while (st == null || !st.hasMoreTokens())
+					st = new StringTokenizer(r.readLine());
+				return st.nextToken();
+			} catch (Exception e) { }
+			return null;
+		}
+
+		public int nextInt() { return Integer.parseInt(next()); }
+		public double nextDouble() { return Double.parseDouble(next()); }
+		public long nextLong() { return Long.parseLong(next()); }
+	}
+}",0
+49e94e7e,d7a8434f,"import java.io.BufferedReader;
+import java.io.IOException;
+import java.lang.*;
+import java.io.InputStreamReader;
+import static java.lang.Math.*;
+import static java.lang.System.out;
+import java.util.*;
+import java.io.File;
+import java.io.PrintStream;
+import java.io.PrintWriter;
+import java.math.BigInteger;
+public class Main {
+ 
+	
+	/* 10^(7) = 1s.
+	 * ceilVal = (a+b-1) / b */
+	
+	static final int mod = 1000000007;
+	static final long temp = 998244353;
+	static final long MOD = 1000000007;
+	static final long M = (long)1e9+7;
+ 
+	
+	static class Pair implements Comparable<Pair> 
+	{
+		int first, second;
+		
+		public Pair(int first, int second) 
+		{
+			this.first = first;
+			this.second = second;
+		}
+		
+		public int compareTo(Pair ob) 
+		{
+			return (int)(first - ob.first);
+		}
+	}
+	
+	
+	static class Tuple implements Comparable<Tuple>
+	{
+		int first, second,third;
+		public Tuple(int first, int second, int third)
+		{
+			this.first = first;
+			this.second = second;
+			this.third = third;
+		}
+		public int compareTo(Tuple o)
+		{
+			return (int)(o.third - this.third);
+		}
+	}
+	
+	public static class DSU
+	{
+		int[] parent;
+		int[] rank; //Size of the trees is used as the rank
+		public DSU(int n)
+		{
+			parent = new int[n];
+			rank = new int[n];
+			Arrays.fill(parent, -1);
+			Arrays.fill(rank, 1);
+		}
+		
+		public int find(int i) //finding through path compression
+		{
+			return parent[i] < 0 ? i : (parent[i] = find(parent[i]));
+		}
+		
+		public boolean union(int a, int b) //Union Find by Rank 
+		{
+			a = find(a);
+			b = find(b);
+			
+			if(a == b) return false; //if they are already connected we exit by returning false.
+			
+			// if a's parent is less than b's parent
+			if(rank[a] < rank[b])
+			{
+				//then move a under b
+				parent[a] = b;
+			}
+			//else if rank of j's parent is less than i's parent
+			else if(rank[a] > rank[b])
+			{
+				//then move b under a
+				parent[b] = a;
+			}
+			//if both have the same rank.
+			else
+			{
+				//move a under b (it doesnt matter if its the other way around.
+				parent[b] = a;
+				rank[a] = 1 + rank[a];
+			}
+			return true;
+		}	
+	}
+
+	static class Reader 
+	{
+		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st=new StringTokenizer("""");
+		String next() {
+			while (!st.hasMoreTokens())
+				try {
+					st=new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			return st.nextToken();
+		}
+		
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+		
+		int[] readArray(int n) throws IOException {
+			int[] a=new int[n];
+			for (int i=0; i<n; i++) a[i]=nextInt();
+			return a;
+		}
+		
+		long[] longReadArray(int n) throws IOException {
+			long[] a=new long[n];
+			for (int i=0; i<n; i++) a[i]=nextLong();
+			return a;
+		}
+		
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+		double nextDouble() {
+			return Double.parseDouble(next());
+		}
+	}
+	
+	public static int gcd(int a, int b)
+	{
+		if(b == 0)
+		 return a;
+		
+		else
+		return gcd(b,a%b);
+	} 
+ 
+		public static long lcm(long a, long b)
+	    {
+	        return (a / LongGCD(a, b)) * b;
+	    }
+	
+	public static long LongGCD(long a, long b)
+	{
+		if(b == 0)
+			 return a;
+			
+			else
+			return LongGCD(b,a%b);
+	}
+	
+		public static long LongLCM(long a, long b)
+	    {
+	        return (a / LongGCD(a, b)) * b;
+	    }
+	
+		//Count the number of coprime's upto N
+		public static long phi(long n)  //euler totient/phi function
+	    { 
+	       long ans = n;
+//	       for(long i = 2;i*i<=n;i++)
+//	       {
+//	    	   if(n%i == 0)
+//	    	   {
+//	    		   while(n%i == 0) n/=i;
+//	    		   ans -= (ans/i);
+//	    	   }
+//	       }
+//	       
+//	       if(n > 1)
+//	       {
+//	    	   ans -= (ans/n);
+//	       }
+	       
+	       for(long i = 2;i<=n;i++)
+	       {
+	    	   if(isPrime(i))
+	    	   {
+	    		   ans -= (ans/i);
+	    	   }
+	       }
+	       
+	       return ans;
+	       
+	    }	
+	
+	public static long fastPow(long x, long n) 
+	{
+		if(n == 0)
+			return 1;
+		else if(n%2 == 0)
+			return fastPow(x*x,n/2);
+		else
+			return x*fastPow(x*x,(n-1)/2);
+	}
+	
+	   public static long modPow(long x, long y, long p)
+	    {
+	        long res = 1;
+	        x = x % p;
+	 
+	        while (y > 0) {
+	            if (y % 2 == 1)
+	                res = (res * x) % p;
+	 
+	            y = y >> 1; 
+	            x = (x * x) % p;
+	        }
+	        return res;
+	    }
+	   
+	   static long modInverse(long n, long p)
+	    {
+	        return modPow(n, p - 2, p);
+	    }
+	 
+	    // Returns nCr % p using Fermat's little theorem.
+	    
+	    public static long nCrModP(long n, long r,long p)
+	    {
+	    	if (n<r) 
+	              return 0;
+	          
+	        if (r == 0)
+	            return 1;
+	 
+	        long[] fac = new long[(int)(n) + 1];
+	        fac[0] = 1;
+	 
+	        for (int i = 1; i <= n; i++)
+	            fac[i] = fac[i - 1] * i % p;
+	 
+	        return (fac[(int)(n)] * modInverse(fac[(int)(r)], p)
+	                % p * modInverse(fac[(int)(n - r)], p)
+	                % p)
+	            % p;
+	    }
+	    
+	    public static long fact(long n) 
+	    {
+	    	  long[] fac = new long[(int)(n) + 1];
+		        fac[0] = 1;
+		 
+		        for (long i = 1; i <= n; i++)
+		            fac[(int)(i)] = fac[(int)(i - 1)] * i;
+		        
+		        return fac[(int)(n)];
+		}
+	    
+	    public static long nCr(long n, long k) 
+	    {
+			long ans = 1;
+			for(long i = 0;i<k;i++)
+			{
+				ans *= (n-i);
+				ans /= (i+1);
+			}
+			return ans;
+		}
+ 
+		//Modular Operations for Addition and Multiplication. 
+		   public static long perfomMod(long x)
+		   {
+		        return ((x%M + M)%M);
+		    }
+		   public static long addMod(long a, long b)
+		   {
+		        return perfomMod(perfomMod(a)+perfomMod(b));
+		    }
+		  
+		   public static long subMod(long a, long b)
+		   {
+		        return perfomMod(perfomMod(a)-perfomMod(b));
+		   }
+		   
+		   public static long mulMod(long  a, long b)
+		   {
+		        return perfomMod(perfomMod(a)*perfomMod(b));
+		   }
+		   
+		   public static boolean isPrime(long n) 
+			{
+				if(n == 1)
+				{
+					return false;
+				}
+				
+				//check only for sqrt of the number as the divisors 
+				//keep repeating so only half of them are required. So,sqrt.
+				for(int i = 2;i*i<=n;i++)
+				{
+					if(n%i == 0)
+					{
+						return false;
+					}
+				}
+				return true;
+			}
+			
+			public static List<Integer> SieveList(int n)
+			{
+				boolean prime[] = new boolean[(int)(n+1)];
+				Arrays.fill(prime, true);
+				
+				List<Integer> l = new ArrayList<>();
+				for (int p = 2; p*p<=n; p++) 
+				{ 
+					if (prime[p] == true) 
+					{ 	
+					    for(int i = p*p; i<=n; i += p) 
+						{
+						    prime[i] = false; 
+						}	
+					} 
+				} 
+		 
+				for (int p = 2; p<=n; p++) 
+				{
+				    if (prime[p] == true)
+				    {
+				       l.add(p); 
+				    }
+				}
+				
+				return l;
+			}
+			
+			public static int countDivisors(int x)
+			{
+				int c = 0;
+				for(int i = 1;i*i<=x;i++)
+				{
+					if(x%i == 0)
+					{
+						if(x/i != i)
+						{
+							c+=2;
+						}
+						else 
+						{
+							c++;
+						}
+					}
+				}
+				return c;
+			}
+			
+			public static long log2(long n)
+		    {
+				 long ans = (long)(log(n)/log(2));
+				 return ans;
+			}
+			   
+			public static boolean isPow2(long n)
+			{
+				 return (n  != 0 && ((n & (n-1))) == 0);
+			}	
+		   
+		   public static boolean isSq(int x)  
+		   {
+			    long s = (long)Math.round(Math.sqrt(x));
+			    return s*s==x;
+		   }
+		
+			   /*
+			    * 
+			    * >=         <=
+			   0 1 2 3 4 5 6 7  
+			   5 5 5 6 6 6 7 7
+			   lower_bound for 6 at index 3 (>=)
+			   upper_bound for 6 at index 6(To get six reduce by one) (<=)
+			   */
+
+		   public static int LowerBound(int a[], int x) 
+		   {
+			      int l=-1,r=a.length;
+				  while(l+1<r) 
+				  {
+				    int m=(l+r)>>>1;
+				    if(a[m]>=x) r=m;
+				    else l=m;
+				  }
+				  return r;
+			}
+		   
+			public static int UpperBound(long a[], long x) 
+			{
+				int l=-1, r=a.length;
+			    while(l+1<r) 
+			    {
+			       int m=(l+r)>>>1;
+			       if(a[m]<=x) l=m;
+			       else r=m;
+			    }
+			    return l+1;
+			}
+			
+			public static void Sort(long[] a) 
+			{
+				List<Long> l = new ArrayList<>();
+				for (long i : a) l.add(i);
+				Collections.sort(l);
+//				Collections.reverse(l);  //Use to Sort decreasingly 
+				for (int i=0; i<a.length; i++) a[i]=l.get(i);
+			}
+			
+			public static void ssort(char[] a)
+			{
+				List<Character> l = new ArrayList<>();
+				for (char i : a) l.add(i);
+				Collections.sort(l);
+				for (int i=0; i<a.length; i++) a[i]=l.get(i);
+			}
+	
+	
+	public static void main(String[] args) throws Exception 
+	{
+		Reader sc = new Reader();
+		PrintWriter fout = new PrintWriter(System.out); 
+		
+		int tt = sc.nextInt();
+		while(tt-- > 0)
+		{
+	       int n = sc.nextInt();
+	       char[] a = sc.next().toCharArray(), b = sc.next().toCharArray();
+	       
+	       int c00 = 0, c01 = 0, c10 = 0, c11 = 0;
+	       for(int i = 0;i<n;i++)
+	       {
+	    	   if(a[i] == '0' && b[i] == '0')
+	    	   {
+	    		   c00++;
+	    	   }
+	    	   else if(a[i] == '0' && b[i] == '1')
+	    	   {
+	    		   c01++;
+	    	   }
+	    	   else if(a[i] == '1' && b[i] == '0')
+	    	   {
+	    		   c10++;
+	    	   }
+	    	   else if(a[i] == '1' && b[i] == '1')
+	    	   {
+	    		   c11++;
+	    	   }
+	       }
+	       
+	       int ans = mod;
+	       if(c01 == c10) ans = min(ans, c01 + c10);
+	       if(c11 == c00 + 1) ans = min(ans, c11 + c00);
+	       
+	       fout.println((ans == mod) ? -1 : ans);
+		}
+		
+		fout.close();
+	}
+}","import java.util.*;
+import java.io.*;
+public class C {
+
+	public static void main(String[] args) {
+		FastScanner sc = new FastScanner();
+		int T = sc.nextInt();
+		while(T-->0) {
+			int n = sc.nextInt();
+			char[] s = new char[n];
+			char[] t = new char[n];
+			s = sc.next().toCharArray();
+			t = sc.next().toCharArray();
+			int a = 0, b = 0, c = 0, d = 0;
+			for(int i = 0; i < n; i++) {
+				if(s[i] == '0' && t[i] == '0') a++;
+				if(s[i] == '1' && t[i] == '0') b++;
+				if(s[i] == '0' && t[i] == '1') c++;
+				if(s[i] == '1' && t[i] == '1') d++;
+			}
+			int res = Integer.MAX_VALUE;
+			if(b == c || b+1 == c) {
+				if((b + c) % 2 == 0) {
+					res = Math.min(res, b + c);
+				}
+			}
+			if(a == d || a+1 == d) {
+				if((a + d) % 2 == 1) {
+					res = Math.min(res, a + d);
+				}
+			}
+			if(res == Integer.MAX_VALUE) System.out.println(-1);
+			else System.out.println(res);
+		}
+	}
+	
+	static class FastScanner {
+		public BufferedReader reader;
+		public StringTokenizer tokenizer;
+		public FastScanner() {
+			reader = new BufferedReader(new InputStreamReader(System.in), 32768);
+			tokenizer = null;
+		}
+		public String next() {
+			while (tokenizer == null || !tokenizer.hasMoreTokens()) {
+				try {
+					tokenizer = new StringTokenizer(reader.readLine());
+				} catch (IOException e) {
+					throw new RuntimeException(e);
+				}
+			}
+			return tokenizer.nextToken();
+		}
+		public int nextInt() {
+			return Integer.parseInt(next());
+		}
+		public long nextLong() {
+			return Long.parseLong(next());
+		}
+		public double nextDouble() {
+			return Double.parseDouble(next());
+		}
+		public String nextLine() {
+			try {
+				return reader.readLine();
+			} catch(IOException e) {
+				throw new RuntimeException(e);
+			}
+		}
+	}
+
+}
+",0
+ba468e1f,fb312dc6,"import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.*;
+
+public class Codeforces {
+    public static void main(String[] args) {
+        FastReader fastReader = new FastReader();
+        int t = fastReader.nextInt();
+        while (t-- > 0) {
+            int n = fastReader.nextInt();
+
+            int a[] = new int[n];
+            for (int i = 0; i < n; i++) {
+                a[i] = fastReader.nextInt();
+            }
+            ArrayList<Integer> b = new ArrayList<>();
+            ArrayList<Integer> r = new ArrayList<>();
+            char c[] = fastReader.next().toCharArray();
+            for (int i = 0; i < n; i++) {
+                if (c[i] == 'B') {
+                    b.add(a[i]);
+                } else {
+                    r.add(a[i]);
+                }
+            }
+
+            Collections.sort(b);
+            Collections.sort(r);
+            int sizeb = b.size();
+
+            boolean isValid = true;
+            for (int i = 1 , j = 0; i <=sizeb; i++ , j++){
+                if (b.get(j) <  i){
+                    isValid =false;
+                }
+            }
+
+            for (int i = sizeb+1 , j = 0; i <=n && j < r.size(); i++ , j++){
+                if (r.get(j) >  i){
+                    isValid =false;
+                }
+            }
+
+            if (isValid){
+                System.out.println(""YES"");
+            }else{
+                System.out.println(""NO"");
+            }
+        }
+
+
+    }
+
+    static class FastReader {
+
+
+        BufferedReader br;
+        StringTokenizer st;
+
+        public FastReader() {
+            br = new BufferedReader(
+                    new InputStreamReader(System.in));
+        }
+
+        String next() {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+
+        String nextLine() {
+            String str = """";
+            try {
+                str = br.readLine();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+        }
+    }
+}
+","import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.StringTokenizer;
+
+public class D {
+    static class Pair{
+        int val;
+        char c;
+        Pair(int a,char b){
+            this.val=a;
+            this.c=b;
+        }
+    }
+    public static void main(String[] args)
+    {
+        FastScanner sc=new FastScanner();
+        int t=sc.nextInt();
+        PrintWriter pw=new PrintWriter(System.out);
+        while(t-->0) {
+            int n=sc.nextInt();
+            int[] a=sc.readArray(n);
+            char[] s=sc.next().toCharArray();
+            boolean ok=true;
+            ArrayList<Integer> blues=new ArrayList<>();
+            ArrayList<Integer> reds=new ArrayList<>();
+            for(int i=0;i<n;i++){
+                if(s[i]=='B'){
+                    blues.add(a[i]);
+                } else {
+                    reds.add(a[i]);
+                }
+            }
+            Collections.sort(blues);
+            Collections.sort(reds);
+            for(int i=0;i<blues.size();i++){
+                if(blues.get(i)<(i+1)){
+                    ok=false;
+                    break;
+                }
+            }
+            int start=blues.size()+1;
+            for(int i=0;i<reds.size();i++){
+                if(reds.get(i)>(start++)){
+                    ok=false;
+                    break;
+                }
+            }
+            if(ok){
+               pw.println(""YES"");
+            } else {
+                pw.println(""NO"");
+            }
+        }
+        pw.flush();
+    }
+
+    static class FastScanner {
+        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st=new StringTokenizer("""");
+        String next() {
+            while (!st.hasMoreTokens())
+                try {
+                    st=new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+        int[] readArray(int n) {
+            int[] a=new int[n];
+            for (int i=0; i<n; i++) a[i]=nextInt();
+            return a;
+        }
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+    }
+}
+",0
+953ac418,ba9b94f7,"
+import java.io.*;
+import java.lang.*;
+import java.util.*;
+
+public class E1578 {
+    public static void main(String[] args) throws IOException{
+        StringBuffer ans = new StringBuffer();
+        StringTokenizer st;
+        BufferedReader f = new BufferedReader(new InputStreamReader(System.in));
+        st = new StringTokenizer(f.readLine());
+        int q = Integer.parseInt(st.nextToken());
+        for(; q > 0; q--){
+            st = new StringTokenizer(f.readLine());
+            st = new StringTokenizer(f.readLine());
+            int n = Integer.parseInt(st.nextToken());
+            int k = Integer.parseInt(st.nextToken());
+            int[] a = new int[k];
+            st = new StringTokenizer(f.readLine());
+            for(int i = 0; i < k; i++){
+                a[i] = Integer.parseInt(st.nextToken()) - 1;
+            }
+            int[] arr = new int[n];
+            int[] b = new int[k];
+            st = new StringTokenizer(f.readLine());
+            Arrays.fill(arr, Integer.MAX_VALUE-1);
+            for(int i = 0; i < k; i++){
+                b[i] = Integer.parseInt(st.nextToken());
+                arr[a[i]] = b[i];
+            }
+            int[] l = new int[n];
+            int[] r = new int[n];
+            for(int i = 0; i < n; i++){
+                if(i == 0)
+                    l[i] = arr[i];
+                else
+                    l[i] = Math.min(l[i-1]+1, arr[i]);
+            }
+            for(int i = n-1; i > -1; i--){
+                if(i == n-1)
+                    r[i] = arr[i];
+                else
+                    r[i] = Math.min(r[i+1]+1, arr[i]);
+            }
+            for(int i = 0; i  < n; i++)
+                ans.append(Math.min(l[i], r[i])).append("" "");
+            ans.append(""\n"");
+        }
+
+        f.close();
+
+
+
+        System.out.println(ans);
+    }
+    public static class point implements Comparable<point>{
+        int x;
+        int y;
+        public point(int x,int y){
+            this.x = x;
+            this.y = y;
+        }
+        public String toString(){
+            return(x + "" "" + y);
+        }
+        public boolean equals(Object x){
+            point y = ((point)(x));
+            if (this.x == y.x && this.y == y.y){
+                return true;
+            }
+            return false;
+        }
+        public int hashCode(){
+            return Objects.hash(x,y);
+        }
+        public int compareTo(point other){
+            if(this.x > other.x || (this.x == other.x && this.y > other.y)){
+                return 1;
+            }else if(this.x == other.x && other.y == this.y){
+                return 0;
+            }
+            return -1;
+        }
+    }
+
+}","import java.util.*;
+import java.io.*;
+
+public class _1547_E {
+    public static void main(String[] args) throws IOException {
+        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
+        PrintWriter out = new PrintWriter(System.out);
+        int t = Integer.parseInt(in.readLine());
+        while(t-- > 0) {
+            in.readLine();
+            StringTokenizer line1 = new StringTokenizer(in.readLine());
+            int n = Integer.parseInt(line1.nextToken());
+            int k = Integer.parseInt(line1.nextToken());
+            int[] x = new int[n];
+            line1 = new StringTokenizer(in.readLine());
+            StringTokenizer line2 = new StringTokenizer(in.readLine());
+            TreeSet<AC> after = new TreeSet<AC>();
+            for(int i = 0; i < k; i++) {
+                int ai = Integer.parseInt(line1.nextToken()) - 1;
+                int ti = Integer.parseInt(line2.nextToken());
+                x[ai] = ti;
+                after.add(new AC(ti, ai));
+            }
+            TreeSet<AC> before = new TreeSet<AC>();
+            int[] res = new int[n];
+            for(int i = 0; i < n; i++) {
+                if(x[i] > 0) {
+                    after.remove(new AC(x[i], i));
+                    before.add(new AC(x[i], n - i));
+                }
+                AC be = before.size() == 0 ? null : before.first();
+                AC af = after.size() == 0 ? null : after.first();
+                if(be == null) {
+                    res[i] = af.d + af.t - i;
+                }else if(af == null) {
+                    res[i] = be.d + be.t - (n - i);
+                }else {
+                    res[i] = Math.min(af.d + af.t - i, be.d + be.t - (n - i));
+                }
+            }
+            StringBuilder sb = new StringBuilder();
+            for(int i = 0; i < n; i++) {
+                sb.append(res[i]);
+                sb.append(' ');
+            }
+            out.println(sb.toString());
+        }
+        in.close();
+        out.close();
+    }
+    static class AC implements Comparable<AC> {
+        int t, d;
+        AC(int tt, int dd) {
+            t = tt;
+            d = dd;
+        }
+        @Override
+        public int compareTo(AC o) {
+            if(t + d == o.t + o.d) {
+                return d - o.d;
+            }
+            return t + d - (o.t + o.d);
+        }
+    }
+}
+",0
+07038b12,a18cb2c1,"//Siddhartha Bose
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStream;
+import java.io.PrintWriter;
+import java.math.BigInteger;
+import java.time.LocalDate;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.PriorityQueue;
+import java.util.Queue;
+import java.util.Stack;
+import java.util.StringTokenizer;
+import java.util.TreeMap;
+import java.util.TreeSet;
+
+public class h {
+
+	public static int r1=0;
+	static class FastReader 
+    { 
+        BufferedReader br; 
+        StringTokenizer st; 
+  
+        public FastReader() 
+        { 
+            br = new BufferedReader(new
+                     InputStreamReader(System.in)); 
+        } 
+  
+        String next() 
+        { 
+            while (st == null || !st.hasMoreElements()) 
+            { 
+                try
+                { 
+                    st = new StringTokenizer(br.readLine()); 
+                } 
+                catch (IOException  e) 
+                { 
+                    e.printStackTrace(); 
+                } 
+            } 
+            return st.nextToken(); 
+        } 
+  
+        int nextInt() 
+        { 
+            return Integer.parseInt(next()); 
+        } 
+  
+        long nextLong() 
+        { 
+            return Long.parseLong(next()); 
+        } 
+  
+        double nextDouble() 
+        { 
+            return Double.parseDouble(next()); 
+        } 
+  
+        String nextLine() 
+        { 
+            String str = """"; 
+            try
+            { 
+                str = br.readLine(); 
+            } 
+            catch (IOException e) 
+            { 
+                e.printStackTrace(); 
+            } 
+            return str; 
+        } 
+    } 
+	static long[][] f=new long[501][501];
+	public static void main(String[] args)  {
+		OutputStream outputStream =System.out;
+	    PrintWriter out =new PrintWriter(outputStream);
+		FastReader s=new FastReader();
+			
+		   int t=s.nextInt();
+		 while(t>0) {
+				int n=s.nextInt();
+				for(int i=1;i<=n;i++) {
+					vis[i]=0;
+					deg[i]=0;
+					ans[i]=0;
+					f1[i]=new ArrayList<>();
+				}
+				for(int i=1;i<=n-1;i++) {
+					int x=s.nextInt();
+					int y=s.nextInt();
+					f1[x].add(new pair1(y,i));
+					f1[y].add(new pair1(x,i));
+					deg[x]++;
+					deg[y]++;
+				}
+//				dfs(1);
+				int node=-1;
+				boolean p=false;
+				for(int i=1;i<=n;i++) {
+					if(deg[i]>2) {
+						p=true;
+					}
+					if(deg[i]==1) {
+						node=i;
+					}
+				}
+				if(p) {
+					out.println(-1);
+				}else {
+					dfs(node,2);
+//					System.out.println();
+				for(int i=1;i<=n-1;i++) {
+					out.print(ans[i]+"" "");
+				}
+				out.println();
+				}
+			 t--;
+			   }
+			
+		
+		
+	out.close();
+	}
+	static int[] ans=new int[100001];
+	static int[] deg=new int[100001];
+	static void dfs(int node,int v) {
+		vis[node]=1;
+//		deg[node]++;
+
+		for(int i=0;i<f1[node].size();i++) {
+			if(vis[f1[node].get(i).a]==0) {
+			int g=2;
+			if(v==2) {
+				g=5;
+			}
+			ans[f1[node].get(i).b]=v;
+				dfs(f1[node].get(i).a,g);
+//				deg[node]++;
+				
+			}
+			
+		}
+	}
+//	static long ans(int[] a,int[] b,long till,long[] post,int n,int k,int i) {
+//		if(k==0 || i==n) {
+//			return till+post[i];
+//		}
+//		if(f[i][k]!=-1) {
+//			return f[i][k];
+//		}
+//		
+//	}
+//	static class pair
+	static int[] vis=new int[100001];
+	static class pair1 {
+		private int a;
+		private int b;
+		pair1(int a,int b){
+			this.a=a;
+			this.b=b;
+		}
+		
+		
+		
+	}
+	static class pair3 implements Comparable<pair3>{
+		private int a;
+		private int b;
+		private int d;
+		private int c;
+		pair3(int a,int b,int c,int d){
+			this.a=a;
+			this.d=d;
+			this.b=b;
+			this.c=c;
+		}
+		@Override
+		public int compareTo(pair3 c) {
+			if(c.b-c.a!=this.b-this.a) {
+				return Integer.compare(c.b-c.a, this.b-this.a);
+			}else {
+				return Integer.compare(this.c, c.c);
+			}
+			 
+		}
+	}
+	static class pair2 implements Comparable<pair2>{
+		private int a;
+		private int b;
+		private int d;
+		private int c;
+		pair2(int a,int b,int c,int d){
+			this.a=a;
+			this.d=d;
+			this.b=b;
+			this.c=c;
+		}
+		public int compareTo(pair2 c) {
+			if(c.b!=this.b) {
+				return Integer.compare(c.b, this.b);
+			}else {
+				if(c.c!=this.c) {
+				return Integer.compare(this.c, c.c);
+			}else {
+				return Integer.compare(this.a, c.a);
+			}
+				
+			}
+			 
+		}
+	}
+	static boolean r(int k) {
+		for(int i=2;i<=k/2;i++) {
+			if(k%i==0) {
+				return false;
+			}
+		}
+		return true;
+	}
+	public static int[] is_prime=new int[100001];
+	public static ArrayList<Long> primes=new ArrayList<>();
+	public static void sieve() {
+		long maxN=100;
+		for(long i=1;i<=maxN;i++) {
+			is_prime[(int) i]=1;
+		}
+		is_prime[0]=0;
+		is_prime[1]=0;
+		for(long i=2;i*i<=maxN;i++) {
+			if(is_prime[(int) i]!=0) {
+				primes.add( i);
+				long c=1;
+				for(long j=i*i;j<=maxN;j+=i) {
+					is_prime[(int) j]++;
+				}
+			}
+		}
+		
+		for(long i=2;i<=maxN;i++) {
+			is_prime[(int) i]=is_prime[(int) (i-1)]+is_prime[(int) i];
+		}
+//		int count=0;
+//		for(long i=1;i<=maxN;i++) {
+//			if(is_prime[(int) i]==1) {
+//				count++;
+//			}
+//			if(is_prime[count]==1) {
+//				arr[(int) i]=1;
+//			}else {
+//				arr[(int)i]=0;
+//			}
+//		}
+	}
+	public static long[] merge_sort(long[] A, int start, int end) {
+		if (end > start) {
+			int mid = (end + start) / 2;
+			long[] v = merge_sort(A, start, mid);
+			long[] o = merge_sort(A, mid + 1, end);
+			return (merge(v, o));
+		} else {
+			long[] y = new long[1];
+			y[0] = A[start];
+			return y;
+		}
+	}
+	static ArrayList<pair1>[] f1=new ArrayList[100001];
+	
+	public static long[] merge(long a[], long b[]) {
+//		int count=0;
+		long[] temp = new long[a.length + b.length];
+		int m = a.length;
+		int n = b.length;
+		int i = 0;
+		int j = 0;
+		int c = 0;
+		while (i < m && j < n) {
+			if (a[i] < b[j]) {
+				temp[c++] = a[i++];
+			
+			} else {
+				temp[c++] = b[j++];
+			}
+		}
+		while (i < m) {
+			temp[c++] = a[i++];
+		}
+		while (j < n) {
+			temp[c++] = b[j++];
+		}
+		return temp;
+	}
+	
+	
+	
+}","import java.util.*;
+import java.io.*;
+
+public class C1627 {
+    public static void main(String[] args) throws IOException {
+        Scanner sc = new Scanner(System.in);
+        PrintWriter pw = new PrintWriter(System.out);
+        int t = sc.nextInt();
+        while (t-- > 0) {
+            int n = sc.nextInt();
+            int[][] edges = new int[n - 1][2];
+            int[] deg = new int[n];
+            boolean valid = true;
+            ArrayList<Integer>[] adjList = new ArrayList[n];
+            for (int i = 0; i < n; i++) {
+                adjList[i] = new ArrayList<>();
+            }
+            for (int i = 0; i < n - 1; i++) {
+                int u = sc.nextInt() - 1;
+                int v = sc.nextInt() - 1;
+                edges[i] = new int[]{u, v};
+                deg[u]++;
+                deg[v]++;
+                valid &= deg[u] <= 2 && deg[v] <= 2;
+                adjList[u].add(i);
+                adjList[v].add(i);
+            }
+            if (!valid) {
+                pw.println(-1);
+                continue;
+            }
+            int root = -1;
+            for (int i = 0; i < n; i++) {
+                if (adjList[i].size() == 1)
+                    root = i;
+            }
+            int[] ans = new int[n - 1];
+            int curColor = 2;
+            int par = -1;
+            while (true) {
+                int nxt = -1;
+                for (int e : adjList[root]) {
+                    int other = edges[e][0] ^ edges[e][1] ^ root;
+                    if (other != par) {
+                        ans[e] = curColor;
+                        curColor = 5 - curColor;
+                        nxt = other;
+                        break;
+                    }
+                }
+                if (nxt == -1)
+                    break;
+                par = root;
+                root = nxt;
+            }
+            for (int x : ans) {
+                pw.print(x + "" "");
+            }
+            pw.println();
+        }
+        pw.close();
+    }
+
+    static class Scanner {
+        BufferedReader br;
+        StringTokenizer st;
+
+        public Scanner(InputStream s) {
+            br = new BufferedReader(new InputStreamReader(s));
+        }
+
+        public Scanner(FileReader f) {
+            br = new BufferedReader(f);
+        }
+
+        public String next() throws IOException {
+            while (st == null || !st.hasMoreTokens())
+                st = new StringTokenizer(br.readLine());
+            return st.nextToken();
+        }
+
+        public int nextInt() throws IOException {
+            return Integer.parseInt(next());
+        }
+
+        public long nextLong() throws IOException {
+            return Long.parseLong(next());
+        }
+
+        public double nextDouble() throws IOException {
+            return Double.parseDouble(next());
+        }
+
+        public int[] nextIntArr(int n) throws IOException {
+            int[] arr = new int[n];
+            for (int i = 0; i < n; i++) {
+                arr[i] = Integer.parseInt(next());
+            }
+            return arr;
+        }
+
+    }
+}
+    ",0
+69c97258,db01da00,"import java.util.Scanner;
+import java.util.ArrayList;
+import java.lang.Math;
+
+public class fell {
+	private static final Scanner cin = new Scanner(System.in);
+	private static final int maxVal = 1000000000;
+
+	public static void main(String[] args) {
+		int n = cin.nextInt();
+		ArrayList<Integer> a = new ArrayList<>();
+		ArrayList<Integer> b = new ArrayList<>();
+
+		for (int i = 0; i < n; i++) {
+			int t = cin.nextInt();
+			if (t == 0)
+				a.add(i);
+			else
+				b.add(i);
+		}
+
+		if (a.size() == n) {
+			System.out.println(0);
+			return;
+		}
+
+		int[][] dp = new int[n][n];
+
+		for (int i = 0; i < n; i++)
+			for (int j = 0; j < n; j++) {
+				if (i == 0)
+					dp[i][j] = 0;
+				else
+					dp[i][j] = maxVal;
+			}
+		
+		for (int i = 0; i < a.size(); i++) {
+			for (int j = 0; j < Math.min(i + 1, b.size() + 1); j++) {
+				dp[i + 1][j] = Math.min(dp[i + 1][j], dp[i][j]);
+				if (j == b.size())
+					continue;
+				dp[i + 1][j + 1] = Math.min(dp[i + 1][j + 1], dp[i][j] + Math.abs(a.get(i) - b.get(j)));
+			}
+		}
+
+		System.out.println(dp[a.size()][b.size()]);
+	}
+}","import java.util.*;
+import java.lang.*;
+import java.io.*;
+
+public class Main {
+    static int func(List<Integer> ones, List<Integer> zeroes, int idO, int idZ, int o, int z, Integer[][] memo) {
+        if(idZ == zeroes.size() || idO == ones.size()) {
+            return 0;
+        }
+        
+        if(memo[idO][idZ] != null) {
+            return memo[idO][idZ];
+        }
+        
+        if(o == z) {
+            return memo[idO][idZ] = Math.abs(ones.get(idO) - zeroes.get(idZ))
+                + func(ones, zeroes, idO + 1, idZ + 1, o - 1, z - 1, memo);
+        } else {
+            return memo[idO][idZ] = Math.min(
+                Math.abs(ones.get(idO) - zeroes.get(idZ))
+                + func(ones, zeroes, idO + 1, idZ + 1, o - 1, z - 1, memo),
+                func(ones, zeroes, idO, idZ + 1, o, z - 1, memo)
+            );
+        }
+    }
+    
+	public static void main (String[] args) {
+	   // Scanner scan = new Scanner(System.in);
+    	FastScanner scan = new FastScanner();
+        int n =  scan.nextInt();
+        int[] arr = scan.readArray(n);
+        
+        List<Integer> ones = new ArrayList<>();
+        List<Integer> zeroes = new ArrayList<>();
+        
+        for(int i = 0; i < n; i++) {
+            if(arr[i] == 0) {
+                zeroes.add(i);
+            } else {
+                ones.add(i);
+            }
+        }
+        
+        int o = ones.size();
+        int z = zeroes.size();
+        
+        Integer[][] memo = new Integer[o + 1][z + 1];
+        
+        int ans = func(ones, zeroes, 0, 0, o, z, memo);
+        
+        System.out.println(ans);
+    }
+/*
+    int n = scan.nextInt();
+            int[] arr = scan.readArray(n);
+    
+    int n = scan.nextInt();
+            int m = scan.nextInt();
+            int[][] arr = new int[n][m];
+            for(int i = 0; i < n; i++) {
+                for(int j = 0; j < m; j++) {
+                    arr[i][j] = scan.nextInt();
+                }
+            }
+    
+*/
+    
+    
+    static class FastScanner {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st = new StringTokenizer("""");
+		String next() {
+			while (!st.hasMoreTokens())
+				try {
+					st = new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			return st.nextToken();
+		}
+		
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+		int[] readArray(int n) {
+			int[] a = new int[n];
+			for (int i = 0; i < n; i++) a[i] = nextInt();
+			return a;
+		}
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+	}
+    
+}",0
+ac121776,eb6cfca7,"import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.*;
+
+
+public class Solution {
+    static class MyScanner {
+        BufferedReader br;
+        StringTokenizer st;
+
+        public MyScanner() {
+            br = new BufferedReader(new InputStreamReader(System.in));
+        }
+
+        String next() {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+
+        String nextLine(){
+            String str = """";
+            try {
+                str = br.readLine();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+        }
+
+    }
+    static class HashMultiSet<T> implements Iterable<T>
+    { private final HashMap<T,Integer> map;
+        private int size;
+        public HashMultiSet(){map=new HashMap<>(); size=0;}
+        public void clear(){map.clear(); size=0;}
+        public int size(){return size;}
+        public int setSize(){return map.size();}
+        public boolean contains(T a){return map.containsKey(a);}
+        public boolean isEmpty(){return size==0;}
+        public Integer get(T a){return map.getOrDefault(a,0);}
+        public void add(T a, int count)
+        {
+            int cur=get(a);map.put(a,cur+count); size+=count;
+            if(cur+count==0) map.remove(a);
+        }
+        public void addOne(T a){add(a,1);}
+        public void remove(T a, int count){add(a,Math.max(-get(a),-count));}
+        public void removeOne(T a){remove(a,1);}
+        public void removeAll(T a){remove(a,Integer.MAX_VALUE-10);}
+
+        public Iterator<T> iterator()
+        {
+            return new Iterator<>()
+            {
+                private final Iterator<T> iter = map.keySet().iterator();
+                private int count = 0; private T curElement;
+
+                public boolean hasNext(){return iter.hasNext()||count>0;}
+                public T next()
+                {
+                    if(count==0)
+                    {
+                        curElement=iter.next();
+                        count=get(curElement);
+                    }
+                    count--; return curElement;
+                }
+            };
+        }
+    }
+    static class DisjointUnionSets {
+        int[] rank, parent;
+        int n;
+
+        // Constructor
+        public DisjointUnionSets(int n)
+        {
+            rank = new int[n];
+            parent = new int[n];
+            this.n = n;
+            makeSet();
+        }
+
+        // Creates n sets with single item in each
+        void makeSet()
+        {
+            for (int i = 0; i < n; i++) {
+                // Initially, all elements are in
+                // their own set.
+                parent[i] = i;
+            }
+        }
+
+        // Returns representative of x's set
+        int find(int x)
+        {
+            // Finds the representative of the set
+            // that x is an element of
+            if (parent[x] != x) {
+                // if x is not the parent of itself
+                // Then x is not the representative of
+                // his set,
+                parent[x] = find(parent[x]);
+
+                // so we recursively call Find on its parent
+                // and move i's node directly under the
+                // representative of this set
+            }
+
+            return parent[x];
+        }
+
+        // Unites the set that includes x and the set
+        // that includes x
+        void union(int x, int y)
+        {
+            // Find representatives of two sets
+            int xRoot = find(x), yRoot = find(y);
+
+            // Elements are in the same set, no need
+            // to unite anything.
+            if (xRoot == yRoot)
+                return;
+
+            // If x's rank is less than y's rank
+            if (rank[xRoot] < rank[yRoot])
+
+                // Then move x under y  so that depth
+                // of tree remains less
+                parent[xRoot] = yRoot;
+
+                // Else if y's rank is less than x's rank
+            else if (rank[yRoot] < rank[xRoot])
+
+                // Then move y under x so that depth of
+                // tree remains less
+                parent[yRoot] = xRoot;
+
+            else // if ranks are the same
+            {
+                // Then move y under x (doesn't matter
+                // which one goes where)
+                parent[yRoot] = xRoot;
+
+                // And increment the result tree's
+                // rank by 1
+                rank[xRoot] = rank[xRoot] + 1;
+            }
+        }
+    }
+    private  static  boolean try1(String s, int index,int prev){
+        int n = s.length();
+        for(int i = index;i<n;i++){
+            if(s.charAt(i) == '0' && prev == i-1){
+                return false;
+            }else if(s.charAt(i) == '0'){
+                prev = i;
+            }
+        }
+        return true;
+    }
+    public static void main(String[] args) {
+        MyScanner sc = new MyScanner();
+        int t = sc.nextInt();
+        while (t-- != 0) {
+            int n = sc.nextInt();
+            long a[] = new long[n];
+            for(int i=0;i<n;i++){
+                a[i] = sc.nextLong();
+            }
+            long mineA = a[0];
+            long mineB = a[1];
+            long accA =0 ;
+            long accB = 0;
+            long remA = n;
+            long remB = n;
+            long ans = (mineA * n) + (mineB *n);
+            boolean check = true;
+            for(int i =2;i<n;i++){
+                if(check){
+                    check = false;
+                    long x = Math.min(a[i],mineA);
+                    long y = Math.max(a[i],mineA);
+                    mineA = x;
+                    accA += y;
+                    remA --;
+                    long sug = (accA +  remA * mineA) + (accB + remB * mineB);
+                    ans = Math.min(sug , ans);
+                }else{
+                    check = true;
+                    long x = Math.min(a[i],mineB);
+                    long y = Math.max(a[i],mineB);
+                    mineB = x;
+                    accB += y;
+                    remB --;
+                    long sug = (accA +  remA * mineA) + (accB + remB * mineB);
+                    ans = Math.min(sug,ans);
+                }
+            }
+            System.out.println(ans);
+        }
+    }
+}
+","
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.InputMismatchException;
+import java.util.List;
+import java.util.Map.Entry;
+import java.util.TreeMap;
+
+public class Main {
+
+	public Main() throws FileNotFoundException {
+
+//		File file = Paths.get(""input.txt"").toFile();
+//		if (file.exists()) {
+//			System.setIn(new FileInputStream(file));
+//		}
+		long t = System.currentTimeMillis();
+
+		InputReader reader = new InputReader();
+
+		int ttt = reader.nextInt();
+
+		for (int tt = 0; tt < ttt; tt++) {
+			int n=reader.nextInt();
+			
+			long[] s=new long[n];
+			for(int i=0;i<n;i++) {
+				s[i]=reader.nextLong();
+			}
+			
+			long smallest1=s[0];
+			long smallest2=s[1];
+			long val=n*s[0]+n*s[1];
+			
+			int left1=n-1;
+			int left2=n-1;
+			long base=s[0]+s[1];
+			for(int i=2;i<n;i++) {
+				if(i%2==0) {
+					//left1
+					val=Math.min(val, base+left2*smallest2+left1*s[i]);
+					base+=s[i];
+					smallest1=Math.min(smallest1, s[i]);
+					left1--;
+				}else {
+					val=Math.min(val, base+left1*smallest1+left2*s[i]);
+					base+=s[i];
+					smallest2=Math.min(smallest2, s[i]);
+					left2--;
+					//left2
+				}
+			}
+			
+
+			System.out.println(val);
+		}
+
+	}
+
+	static class InputReader {
+		private byte[] buf = new byte[16384];
+		private int curChar;
+		private int numChars;
+
+		public int read() {
+			if (numChars == -1)
+				throw new InputMismatchException();
+			if (curChar >= numChars) {
+				curChar = 0;
+				try {
+					numChars = System.in.read(buf);
+				} catch (IOException e) {
+					throw new InputMismatchException();
+				}
+				if (numChars <= 0)
+					return -1;
+			}
+			return buf[curChar++];
+		}
+
+		public String nextLine() {
+			int c = read();
+			while (isSpaceChar(c))
+				c = read();
+			StringBuilder res = new StringBuilder();
+			do {
+				res.appendCodePoint(c);
+				c = read();
+			} while (!isEndOfLine(c));
+			return res.toString();
+		}
+
+		public String nextString() {
+			int c = read();
+			while (isSpaceChar(c))
+				c = read();
+			StringBuilder res = new StringBuilder();
+			do {
+				res.appendCodePoint(c);
+				c = read();
+			} while (!isSpaceChar(c));
+			return res.toString();
+		}
+
+		public long nextLong() {
+			int c = read();
+			while (isSpaceChar(c))
+				c = read();
+			int sgn = 1;
+			if (c == '-') {
+				sgn = -1;
+				c = read();
+			}
+			long res = 0;
+			do {
+				if (c < '0' || c > '9')
+					throw new InputMismatchException();
+				res *= 10;
+				res += c - '0';
+				c = read();
+			} while (!isSpaceChar(c));
+			return res * sgn;
+		}
+
+		public int nextInt() {
+			int c = read();
+			while (isSpaceChar(c))
+				c = read();
+			int sgn = 1;
+			if (c == '-') {
+				sgn = -1;
+				c = read();
+			}
+			int res = 0;
+			do {
+				if (c < '0' || c > '9')
+					throw new InputMismatchException();
+				res *= 10;
+				res += c - '0';
+				c = read();
+			} while (!isSpaceChar(c));
+			return res * sgn;
+		}
+
+		public int[] nextIntArray(int n) {
+			int[] arr = new int[n];
+			for (int i = 0; i < n; i++) {
+				arr[i] = nextInt();
+			}
+			return arr;
+		}
+
+		public long[] nextLongArray(int n) {
+			long[] arr = new long[n];
+			for (int i = 0; i < n; i++) {
+				arr[i] = nextLong();
+			}
+			return arr;
+		}
+
+		private boolean isSpaceChar(int c) {
+			return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
+		}
+
+		private boolean isEndOfLine(int c) {
+			return c == '\n' || c == '\r' || c == -1;
+		}
+
+	}
+
+	public static void main(String[] args) throws FileNotFoundException {
+		new Main();
+	}
+
+}
+",0
+9756f13a,ea899386,"import java.util.*;
+import java.io.*;
+
+public class PhoenixAndTowers {
+    public static void main(String [] args) throws IOException{
+
+        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
+        BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));
+
+        int t = Integer.parseInt(in.readLine());
+        for (int test = 0; test < t; test++){
+            String [] data = in.readLine().split("" "");
+            int n = Integer.parseInt(data[0]);
+            int m = Integer.parseInt(data[1]);
+            int x = Integer.parseInt(data[2]);
+
+            data = in.readLine().split("" "");
+            intPair [] blocks = new intPair[n];
+            for (int i = 0; i < n; i++){
+                blocks[i] = new intPair(i, Integer.parseInt(data[i]));
+            }
+            Arrays.sort(blocks);
+            TreeSet<intPair> towers = new TreeSet<>();
+            // intPair [] towers = new intPair[m];
+            for (int i = 0; i < m; i++){
+                // towers[i] = new intPair(i+1, 0);
+                towers.add(new intPair(i+1, 0));
+            }
+            int [] newIdx = new int[n];
+
+            for (int i = n - 1; i >= 0; i--){
+                //Arrays.sort(towers);
+                intPair low = towers.pollFirst();
+                //towers[0].value += blocks[i].value;
+                low.value += blocks[i].value;
+                newIdx[blocks[i].idx] = low.idx;
+                towers.add(low);
+            }
+
+            int min = n*x;
+            int max = 0;
+            for (intPair tower : towers){
+                if (tower.value < min){
+                    min = tower.value;
+                }
+                if (tower.value > max){
+                    max = tower.value;
+                }
+            }
+            if (max - min <= x){
+                out.write(""YES\n"");
+                for (int i = 0; i < n; i++){
+                    if (i != 0){
+                        out.write("" "" + newIdx[i]);
+                    }else {
+                        out.write("""" + newIdx[i]);
+                    }
+                }
+                out.write(""\n"");
+            } else {
+                out.write(""NO\n"");
+            }
+        }
+        out.close();
+    } 
+
+    static class intPair implements Comparable<intPair>{
+        int idx;
+        int value;
+        intPair(int idx, int value){
+            this.idx = idx;
+            this.value = value;
+        }
+        @Override
+        public int compareTo(PhoenixAndTowers.intPair o) {
+            return this.value != o.value? this.value - o.value: this.idx - o.idx;
+        }
+    }
+}
+","import java.io.*;
+import java.util.*;
+ 
+public class Codeforces {
+	public static class Tower implements Comparable<Tower>{
+		int val;
+		int index;
+		public Tower(int ind, int v) {
+			val = v;
+			index = ind;
+		}
+		@Override
+		public int compareTo(Tower o) {
+			return Integer.compare(val, o.val);
+		}
+	}
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		int cases = Integer.parseInt(br.readLine());
+		while(cases-- > 0) {
+			String[] str = br.readLine().split("" "");
+			int n = Integer.parseInt(str[0]);
+			int m = Integer.parseInt(str[1]);
+			int x = Integer.parseInt(str[2]);
+			int[] h = new int[n];
+			str = br.readLine().split("" "");
+			for(int i=0; i<n; i++) {
+				h[i] = Integer.parseInt(str[i]);
+			}
+			PriorityQueue<Tower> q = new PriorityQueue<>(m);
+			int[] ans = new int[n];
+			for(int i=0; i<m; i++) {
+				q.add(new Tower(i, h[i]));
+				ans[i] = i;
+			}
+			for(int i=m; i<n; i++) {
+				Tower lowest = q.poll();
+				lowest.val += h[i];
+				ans[i] = lowest.index;
+				q.add(lowest);
+			}
+			System.out.println(""YES"");
+			for(int i=0; i<n; i++) {
+				System.out.print((ans[i]+1) + "" "");
+			}
+			System.out.println();
+		}
+	}
+}
+",0
+d8a171a3,f229aa7f,"import java.io.*;
+import java.util.*;
+
+public class B {
+	
+	public static void main(String[] args)throws IOException {
+		
+		FastScanner scan = new FastScanner();
+		PrintWriter output = new PrintWriter(System.out);
+		int t = scan.nextInt();
+		for(int tt = 0;tt<t;tt++) {
+			int n = scan.nextInt();
+			char initial[] = scan.next().toCharArray();
+			char desired[] = scan.next().toCharArray();
+			int lit1 = 0, lit2 = 0;
+			int ans = Integer.MAX_VALUE;
+			for(int i = 0;i<n;i++) {
+				if(initial[i]=='1') lit1++;
+				if(desired[i]=='1') lit2++;
+			}
+			if(lit1==lit2) {
+				int count = 0;
+				for(int i = 0;i<n;i++) if(initial[i]!=desired[i]) count++;
+				ans = Math.min(ans, count);
+			}
+			if(lit2==(n-lit1+1)) {
+				int count = 0;
+				for(int i = 0;i<n;i++) if(initial[i]==desired[i]) count++;
+				ans = Math.min(ans, count);
+			}
+			if(ans == Integer.MAX_VALUE) ans = -1;
+			output.println(ans);	
+		}
+		output.flush();
+	}
+	
+	public static int[] sort(int arr[]) {
+		List<Integer> list = new ArrayList<>();
+		for(int i:arr) list.add(i);
+		Collections.sort(list);
+		for(int i = 0;i<list.size();i++) arr[i] = list.get(i);
+		return arr;
+	}
+	
+	public static int gcd(int a, int b) {
+		if(a == 0) return b;
+		return gcd(b%a, a);
+	}
+	
+	public static void printArray(int arr[]) {
+		for(int i:arr) System.out.print(i+"" "");
+		System.out.println();
+	}
+	
+	static class FastScanner {
+		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st=new StringTokenizer("""");
+		String next() {
+			while (!st.hasMoreTokens())
+				try {
+					st=new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			return st.nextToken();
+		}
+
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+		int[] readArray(int n) {
+			int[] a=new int[n];
+			for (int i=0; i<n; i++) a[i]=nextInt();
+			return a;
+		}
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+		
+		double nextDouble() {
+			return Double.parseDouble(next());
+		}
+	}
+
+}
+","import java.util.*;
+import java.io.*;
+import java.math.*;
+
+public class cf {
+	static PrintWriter pw = new PrintWriter(System.out);
+
+	public static void main(String[] args) throws IOException, InterruptedException {
+		Scanner sc = new Scanner(System.in);
+		int t = sc.nextInt();
+		while (t-- > 0) {
+			int n = sc.nextInt();
+			char[] a = sc.next().toCharArray();
+			char[] b = sc.next().toCharArray();
+			int x = 0, y = 0, lit = 0,lit2 = 0;
+			for (int i = 0; i < n; i++) {
+				if (a[i] == '1')
+					lit++;
+				if (b[i] == '1')
+					lit2++;
+				if (a[i] == b[i])
+					x++;
+				else
+					y++;
+			}
+			if(lit == lit2 || n - lit + 1 == lit2) {
+				if (lit == lit2 && n - lit + 1 == lit2) {
+					pw.println(Math.min(x,y));
+				}else if(lit == lit2) {
+					pw.println(y);
+				}else {
+					pw.println(x);
+				}
+			}else {
+				pw.println(-1);
+			}
+		}
+		pw.close();
+	}
+
+	public static class tuble implements Comparable<tuble> {
+		int x;
+		int y;
+		int z;
+
+		public tuble(int x, int y, int z) {
+			this.x = x;
+			this.y = y;
+			this.z = z;
+		}
+
+		public String toString() {
+			return x + "" "" + y + "" "" + z;
+		}
+
+		public int compareTo(tuble other) {
+			if (this.x == other.x) {
+				if (this.y == other.y)
+					return this.z - other.z;
+				return this.y - other.y;
+			} else {
+				return this.x - other.x;
+			}
+		}
+	}
+
+	public static class pair implements Comparable<pair> {
+		int x;
+		int y;
+
+		public pair(int x, int y) {
+			this.x = x;
+			this.y = y;
+		}
+
+		public String toString() {
+			return x + "" "" + y;
+		}
+
+		public boolean equals(Object o) {
+			if (o instanceof pair) {
+				pair p = (pair) o;
+				return p.x == x && p.y == y;
+			}
+			return false;
+		}
+
+		public int hashCode() {
+			return new Integer(x).hashCode() * 31 + new Integer(y).hashCode();
+		}
+
+		public int compareTo(pair other) {
+			if (this.x == other.x) {
+				return Long.compare(this.y, other.y);
+			}
+			return Long.compare(this.x, other.x);
+		}
+	}
+
+	static class Scanner {
+		StringTokenizer st;
+		BufferedReader br;
+
+		public Scanner(InputStream s) {
+			br = new BufferedReader(new InputStreamReader(s));
+		}
+
+		public Scanner(FileReader r) {
+			br = new BufferedReader(r);
+		}
+
+		public String next() throws IOException {
+			while (st == null || !st.hasMoreTokens())
+				st = new StringTokenizer(br.readLine());
+			return st.nextToken();
+		}
+
+		public int nextInt() throws IOException {
+			return Integer.parseInt(next());
+		}
+
+		public long nextLong() throws IOException {
+			return Long.parseLong(next());
+		}
+
+		public String nextLine() throws IOException {
+			return br.readLine();
+		}
+
+		public double nextDouble() throws IOException {
+			return Double.parseDouble(next());
+		}
+
+		public boolean ready() throws IOException {
+			return br.ready();
+		}
+
+	}
+
+}",0
+03b3c5af,d74028ea,"import java.io.OutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.PrintWriter;
+import java.util.*;
+import java.io.IOException;
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.io.InputStream;
+
+public class TaskA {
+    public static void main(String[] args) {
+        InputStream inputStream = System.in;
+        OutputStream outputStream = System.out;
+        FastReader in = new FastReader(inputStream);
+        PrintWriter out = new PrintWriter(outputStream);
+        Solver solver = new Solver();
+        int testCount = 1;
+        testCount = Integer.parseInt(in.next());
+        for (int i = 1; i <= testCount; i++)
+            solver.solve(i, in, out);
+        out.close();
+    }
+
+    static class Solver {
+        public void fastSort(int[] a){
+            Random random = new Random();
+            for(int i=0;i<a.length;i++){
+                int nextInd = random.nextInt(a.length);
+                int temp = a[nextInd];
+                a[nextInd] = a[i];
+                a[i] = temp;
+            }
+            Arrays.sort(a);
+            return;
+        }
+        public Pair[] pairs;
+        ArrayList<ArrayList<Integer>> adj;
+        long[][] dp;
+        public void dfs(int vertex,int parent){
+//            dp[0][vertex] = dp[1][vertex] = 0;
+            for(int i=0;i<adj.get(vertex).size();i++){
+                if((int)adj.get(vertex).get(i)!=parent){
+                    int curVer = adj.get(vertex).get(i);
+                    dfs(curVer,vertex);
+                    dp[0][vertex] += Math.max( (dp[0][curVer] + Math.abs(pairs[curVer].f - pairs[vertex].f) )
+                            , (dp[1][curVer] + Math.abs(pairs[curVer].s - pairs[vertex].f)) );
+                    dp[1][vertex] += Math.max( (dp[0][curVer] + Math.abs(pairs[curVer].f - pairs[vertex].s) )
+                            , (dp[1][curVer] + Math.abs(pairs[curVer].s - pairs[vertex].s)) );
+                }
+            }
+        }
+        public void solve(int testNumber, FastReader in, PrintWriter out) {
+            int n = in.nextInt();
+            pairs = new Pair[n];
+            adj = new ArrayList<>();
+            for(int i=0;i<n;i++){
+                pairs[i] = new Pair(in.nextInt(),in.nextInt());
+                adj.add(new ArrayList<>());
+            }
+            for(int i=0;i<n-1;i++){
+                int u = in.nextInt(),v = in.nextInt();
+                adj.get(u-1).add(v-1);
+                adj.get(v-1).add(u-1);
+            }
+            dp = new long[2][n];
+            dfs(0,-1);
+//            out.println(Arrays.toString(dp[0]));
+//            out.println(Arrays.toString(dp[1]));
+            out.println(Math.max(dp[0][0],dp[1][0]));
+        }
+    }
+    static class Pair implements Comparable<Pair>{
+        int f;
+        int s;
+        public Pair(int a,int b){
+            this.f = a;
+            this.s = b;
+        }
+        public  int compareTo(Pair other){
+            if(other.f==this.f){
+                return (int)(this.s-other.s);
+            }
+            else return this.f-other.f;
+        }
+    }
+    static class FastReader {
+        BufferedReader br;
+        StringTokenizer st;
+
+        public FastReader(InputStream stream){
+            br = new BufferedReader(new
+                InputStreamReader(stream));
+        }
+
+        public String next(){
+            while (st == null || !st.hasMoreElements()){
+                try{
+                    st = new StringTokenizer(br.readLine());
+                }
+                catch (IOException e){
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        public int nextInt(){
+            return Integer.parseInt(next());
+        }
+
+        public long nextLong(){
+            return Long.parseLong(next());
+        }
+
+        public double nextDouble(){
+            return Double.parseDouble(next());
+        }
+
+        public String nextLine(){
+            String str = """";
+            try{
+                str = br.readLine();
+            }
+            catch (IOException e){
+                e.printStackTrace();
+            }
+            return str;
+        }
+
+        public int[] nextArray(int n) {
+            int[] a=new int[n];
+            for (int i=0; i<n; i++) a[i]=nextInt();
+                return a;
+        }
+    }
+}
+
+","import java.io.*;
+import java.util.*;
+ 
+public class Main {
+ 
+  static class Task {
+ 
+    int NN = 200005;
+    int MOD = 1000000007;
+    int INF = 2000000000;
+    long INFINITY = 2000000000000000000L;
+
+	int [] a;
+	int [] b;
+	List<Integer> [] g;
+	long [][] dp;
+
+	long rec(int node, int prev, int index) {
+		if(dp[node][index] != -1){
+			return dp[node][index];
+		}
+		long ret = 0;
+		int val = index==0?a[node]:b[node];
+		for(int adj: g[node]) {
+			if(adj == prev) {
+				continue;
+			}
+			ret += Math.max((long)(rec(adj, node, 0) + (long)(Math.abs(val - a[adj]))), (long)(rec(adj, node, 1) + (long)(Math.abs(val - b[adj]))));
+		}
+		return dp[node][index] = ret;
+	}
+    
+    public void solve(InputReader in, PrintWriter out) {
+		int t = in.nextInt();
+		while(t-->0) {
+			int n = in.nextInt();
+			a = new int[n + 1];
+			b = new int[n + 1];
+			g = new ArrayList[n + 1];
+			dp = new long[n + 1][2];
+			for(int i=1;i<=n;++i) {
+				a[i] = in.nextInt();
+				b[i] = in.nextInt();
+				g[i] = new ArrayList<>();
+				dp[i][0] = dp[i][1] = -1;
+			}
+			for(int i=1;i<n;++i) {
+				int u = in.nextInt();
+				int v = in.nextInt();
+				g[u].add(v);
+				g[v].add(u);
+			}
+			long ans = Math.max(rec(1, -1, 0), rec(1, -1, 1));
+			out.println(ans);
+		}
+    }
+  }
+ 
+  static void prepareIO(boolean isFileIO) {
+    // long t1 = System.currentTimeMillis();
+    Task solver = new Task();
+    // Standard IO
+    if (!isFileIO) {
+      InputStream inputStream = System.in;
+      OutputStream outputStream = System.out;
+      InputReader in = new InputReader(inputStream);
+      PrintWriter out = new PrintWriter(outputStream);
+      solver.solve(in, out);
+      // out.println(""time(s): "" + (1.0*(System.currentTimeMillis()-t1))/1000.0);
+      out.close();
+    }
+    // File IO
+    else {
+      String IPfilePath = System.getProperty(""user.home"") + ""/Downloads/ip.in"";
+      String OPfilePath = System.getProperty(""user.home"") + ""/Downloads/op.out"";
+      InputReader fin = new InputReader(IPfilePath);
+      PrintWriter fout = null;
+      try {
+        fout = new PrintWriter(new File(OPfilePath));
+      } catch (FileNotFoundException e) {
+        e.printStackTrace();
+      }
+      solver.solve(fin, fout);
+      // fout.println(""time(s): "" + (1.0*(System.currentTimeMillis()-t1))/1000.0);
+      fout.close();
+    }
+  }
+ 
+  public static void main(String[] args) {
+    prepareIO(false);
+  }
+ 
+  static class InputReader {
+    public BufferedReader reader;
+    public StringTokenizer tokenizer;
+ 
+    public InputReader(InputStream stream) {
+      reader = new BufferedReader(new InputStreamReader(stream), 32768);
+      tokenizer = null;
+    }
+ 
+    public InputReader(String filePath) {
+      File file = new File(filePath);
+      try {
+        reader = new BufferedReader(new FileReader(file));
+      } catch (FileNotFoundException e) {
+        // TODO Auto-generated catch block
+        e.printStackTrace();
+      }
+      tokenizer = null;
+    }
+ 
+    public String nextLine() {
+      String str = """";
+      try {
+        str = reader.readLine();
+      } catch (IOException e) {
+        // TODO Auto-generated catch block
+        e.printStackTrace();
+      }
+      return str;
+    }
+ 
+    public String next() {
+      while (tokenizer == null || !tokenizer.hasMoreTokens()) {
+        try {
+          tokenizer = new StringTokenizer(reader.readLine());
+        } catch (IOException e) {
+          throw new RuntimeException(e);
+        }
+      }
+      return tokenizer.nextToken();
+    }
+ 
+    public int nextInt() {
+      return Integer.parseInt(next());
+    }
+ 
+    public long nextLong() {
+      return Long.parseLong(next());
+    }
+ 
+    public double nextDouble() {
+      return Double.parseDouble(next());
+    }
+  }
+}",0
+9069684f,fffc11ee,"import java.io.*;
+import java.util.*;
+
+public class Test {
+    static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+    static StringTokenizer st;
+
+    static boolean[] vis;
+    static ArrayList<Integer>[] adj;
+    static int[] l, r;
+    static long[][] dp;
+
+    @SuppressWarnings(""unchecked"")
+    public static void main(String[] args) throws IOException {
+        int T = readInt();
+        for (int t = 0; t < T; t++) {
+            int n = readInt();
+            l = new int[n + 1];
+            r = new int[n + 1];
+            for (int i = 1; i <= n; i++) {
+                l[i] = readInt();
+                r[i] = readInt();
+            }
+
+            adj = new ArrayList[n + 1];
+            for (int i = 1; i <= n; i++) adj[i] = new ArrayList<>();
+            for (int i = 0; i < n - 1; i++) {
+                int u = readInt(), v = readInt();
+                adj[u].add(v);
+                adj[v].add(u);
+            }
+
+            dp = new long[n + 1][2];
+            vis = new boolean[n + 1];
+            vis[1] = true;
+            dfs(1);
+            System.out.println(Math.max(dp[1][0], dp[1][1]));
+        }
+    }
+
+    static void dfs(int u) {
+        for (int x : adj[u]) {
+            if (!vis[x]) {
+                vis[x] = true;
+                dfs(x);
+                dp[u][0] += Math.max(dp[x][0] + Math.abs(l[u] - l[x]), dp[x][1] + Math.abs(l[u] - r[x]));
+                dp[u][1] += Math.max(dp[x][0] + Math.abs(r[u] - l[x]), dp[x][1] + Math.abs(r[u] - r[x]));
+            }
+        }
+    }
+
+    static String next() throws IOException {
+        while (st == null || !st.hasMoreTokens())
+            st = new StringTokenizer(br.readLine().trim());
+        return st.nextToken();
+    }
+
+    static int readInt() throws IOException {
+        return Integer.parseInt(next());
+    }
+}
+","import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.util.*;
+
+public class C {
+
+    private static final boolean TEST_MODE = true;
+    private static Node[] tree;
+    private static long[] lWt, rWt;
+
+    public static void main(String[] args) throws Exception {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        int T = getInt(br);
+        for (int t=0; t<T; t++) {
+            int N = getInt(br);
+
+            tree = new Node[N+1];
+            for (int v = 1; v <= N; v++) {
+                String s = br.readLine();
+                tree[v] = new Node(s);
+            }
+
+            for (int e=1; e<=N-1; e++) {
+                int[] arr = getIntArray(2, br);
+                int u = arr[0];
+                int v = arr[1];
+                tree[u].addNbr(v);
+                tree[v].addNbr(u);
+            }
+            rootTheTree();
+
+            lWt = new long[N + 1];
+            rWt = new long[N + 1];
+            Arrays.fill(lWt, -1);
+            Arrays.fill(rWt, -1);
+            getMaxBeauty();
+        }
+    }
+
+    private static void rootTheTree() {
+       // Arbitrarily pick the root as #1.
+        Node root = tree[1];
+        root.parent = 0;
+        Queue<Integer> q = new LinkedList<>();
+        q.add(1);
+
+        // Constraint: Every node that is in the queue has parent already assigned.
+        while (!q.isEmpty()) {
+            int currId = q.poll();
+            Node currNode = tree[currId];
+            // Add all neighbours as children.
+            for (int nbrId : currNode.nbrs) {
+                if (nbrId == currNode.parent) {
+                    continue;
+                }
+                tree[nbrId].parent = currId;
+                currNode.addChild(nbrId);
+                q.add(nbrId);
+            }
+//            currNode.nbrs.clear();
+        }
+    }
+
+    private static void getMaxBeauty() throws Exception {
+        Stack<Integer> stack = new Stack<>();
+        stack.add(1);
+
+        while (!stack.isEmpty()) {
+            int currId = stack.pop();
+            Node curr = tree[currId];
+
+            // Is leaf ?
+            if (curr.children.size() == 0) {
+                lWt[currId] = 0;
+                rWt[currId] = 0;
+                continue;
+            }
+            // Are all children processed ?
+            boolean allChildrenProcessed = (lWt[curr.children.get(0)] >= 0);
+            if (allChildrenProcessed) {
+                lWt[currId] = 0;
+                rWt[currId] = 0;
+                // Compute lwt and rwt maximized against each child.
+                for (int childId : curr.children) {
+                    Node childNode = tree[childId];
+                    long ll = Math.abs(curr.left - childNode.left) + lWt[childId];
+                    long lr = Math.abs(curr.left - childNode.right) + rWt[childId];
+                    lWt[currId] += Math.max(ll, lr);
+
+                    long rl = Math.abs(curr.right - childNode.left) + lWt[childId];
+                    long rr = Math.abs(curr.right - childNode.right) + rWt[childId];
+                    rWt[currId] += Math.max(rl, rr);
+                }
+            } else { // Add all unvisited children.
+                stack.add(currId);
+                stack.addAll(curr.children);
+            }
+        }
+        long res = Math.max(lWt[1], rWt[1]);
+        System.out.println(res);
+    }
+
+    private static int getLeftId(int nodeId) {
+        return tree[nodeId].left;
+    }
+
+    private static int getRightId(int nodeId) {
+        return tree[nodeId].right;
+    }
+
+    private static Integer getInt(BufferedReader br) throws Exception {
+        return Integer.parseInt(br.readLine());
+    }
+
+    private static Long getLong(BufferedReader br) throws Exception {
+        return Long.parseLong(br.readLine());
+    }
+
+    private static int[] getIntArray(int N, BufferedReader br) throws Exception {
+        String s = br.readLine();
+        String[] tokens = s.split("" "");
+        int[] result = new int[N];
+
+        for (int i=0; i<N; i++) {
+            result[i] = Integer.parseInt(tokens[i]);
+        }
+        return result;
+    }
+
+    private static long[] getLongArray(int N, BufferedReader br) throws Exception {
+        String s = br.readLine();
+        String[] tokens = s.split("" "");
+        long[] result = new long[N+1];
+
+        for (int i=0; i<N; i++) {
+            result[i+1] = Long.parseLong(tokens[i]);
+        }
+        return result;
+    }
+
+    private static void printArray(String message, Object[] arr) {
+        if (!TEST_MODE) {
+            return;
+        }
+        System.out.print(message + "" : "");
+        for (int i=0; i<arr.length; i++) {
+            System.out.print(arr[i] + "" "");
+        }
+        System.out.println();
+    }
+}
+
+class Node {
+    int parent = -1;
+    List<Integer> nbrs = new ArrayList<>();
+    List<Integer> children = new ArrayList<>();
+    int left, right;
+
+    public Node(int l, int r) {
+        this.left = l;
+        this.right = r;
+    }
+
+    public Node(String s) {
+        String[] tokens = s.split("" "");
+        this.left = Integer.parseInt(tokens[0]);
+        this.right = Integer.parseInt(tokens[1]);
+    }
+
+    public void addNbr(int nbr) {
+        nbrs.add(nbr);
+    }
+
+    public void addChild(int child) {
+        children.add(child);
+    }
+}",0
+2120328e,6de04ee2,"/*****  --->         :)    Vijender  Srivastava      (:       <---       *****/
+import java.util.*;
+import java.lang.*;
+import java.io.*;
+public class Main  
+{
+    static FastReader sc =new FastReader();
+    static PrintWriter out=new PrintWriter(System.out);
+    static int mod=10000007;
+   static StringBuilder sb=new StringBuilder();
+    /* start */
+       public static void main(String [] args)
+    {
+            int t = i();
+            while(t-->0)
+            {
+                int n = i();
+                int a[] = input(n);
+                char c[] = inputC();
+                ArrayList<Integer> b = new ArrayList<>();
+                ArrayList<Integer> r = new ArrayList<>();
+                for(int i=0;i<n;i++)
+                {
+                    if(c[i]=='R')
+                    r.add(a[i]);
+                    else 
+                    b.add(a[i]);
+                }
+                Collections.sort(b);
+                Collections.sort(r,Collections.reverseOrder());
+                boolean is = true;
+                int cnt = 1;
+                for(int i=0;i<b.size();i++)
+                {
+                    if(b.get(i)<cnt)
+                    {
+                        is = false;
+                        break;
+                    }
+                    cnt++;
+                }
+                for(int i=0;i<r.size();i++)
+                {
+                    if(r.get(i)>n-i)
+                    {
+                        is = false;
+                        break;
+                    }
+                }
+
+                out.println(is==true?""YES"":""NO"");
+            }
+            out.close();
+    }
+
+    
+    /* end */
+    static class FastReader 
+    { 
+        BufferedReader br; 
+        StringTokenizer st; 
+
+        public FastReader() 
+        { 
+            br = new BufferedReader(new
+                     InputStreamReader(System.in)); 
+        } 
+
+        String next() 
+        { 
+            while (st == null || !st.hasMoreElements()) 
+            { 
+                try
+                { 
+                    st = new StringTokenizer(br.readLine()); 
+                } 
+                catch (IOException  e) 
+                { 
+                    e.printStackTrace(); 
+                } 
+            } 
+            return st.nextToken(); 
+        } 
+
+        int nextInt() 
+        { 
+            return Integer.parseInt(next()); 
+        } 
+
+        long nextLong() 
+        { 
+            return Long.parseLong(next()); 
+        } 
+
+        double nextDouble() 
+        { 
+            return Double.parseDouble(next()); 
+        } 
+
+        String nextLine() 
+        { 
+            String str = """"; 
+            try
+            { 
+                str = br.readLine(); 
+            } 
+            catch (IOException e) 
+            { 
+                e.printStackTrace(); 
+            } 
+            return str; 
+        } 
+    } 
+
+    
+    static int i() {
+        return sc.nextInt();
+    }
+
+    static String s() {
+        return sc.next();
+    }
+
+    static long l() {
+        return sc.nextLong();
+    }
+
+    static char[] inputC()
+    {
+        String s = sc.nextLine();
+        return s.toCharArray();
+    }
+
+    static int[] input(int n) {
+        int A[]=new int[n];
+           for(int i=0;i<n;i++) {
+               A[i]=sc.nextInt();
+           }
+        return A;
+    }
+
+    static long[] inputL(int n) {
+        long A[]=new long[n];
+           for(int i=0;i<n;i++) {
+               A[i]=sc.nextLong();
+           }
+           return A;
+    }
+
+    static long[] putL(long a[]) {
+        long A[]=new long[a.length];
+           for(int i=0;i<a.length;i++) {
+               A[i]=a[i];
+           }
+           return A;
+    }
+
+    static String[] inputS(int n) {
+        String A[]=new String[n];
+           for(int i=0;i<n;i++) {
+               A[i]=sc.next();
+           }
+           return A;
+    }
+      
+    static int gcd(int a, int b) 
+     { 
+         if (a == 0) 
+             return b; 
+         return gcd(b % a, a); 
+     } 
+
+     static long gcd(long a, long b) 
+     { 
+         if (a == 0) 
+             return b; 
+         return gcd(b % a, a); 
+     } 
+
+     
+    
+     static String reverse(String s) {
+        StringBuffer p=new StringBuffer(s);
+        p.reverse();
+        return p.toString();
+     }
+
+     static int min(int a,int b) {
+        return Math.min(a, b);
+    }
+    static int min(int a,int b,int c) {
+        return Math.min(a, Math.min(b, c));
+    }
+    static int min(int a,int b,int c,int d) {
+        return Math.min(a, Math.min(b, Math.min(c, d)));
+    }
+
+    static int max(int a,int b) {
+        return Math.max(a, b);
+    }
+    static int max(int a,int b,int c) {
+        return Math.max(a, Math.max(b, c));
+    }
+    static int max(int a,int b,int c,int d) {
+        return Math.max(a, Math.max(b, Math.max(c, d)));
+    }
+    static long min(long a,long b) {
+        return Math.min(a, b);
+    }
+    static long min(long a,long b,long c) {
+        return Math.min(a, Math.min(b, c));
+    }
+    static long min(long a,long b,long c,long d) {
+        return Math.min(a, Math.min(b, Math.min(c, d)));
+    }
+    static long max(long a,long b) {
+        return Math.max(a, b);
+    }
+    static long max(long a,long b,long c) {
+        return Math.max(a, Math.max(b, c));
+    }
+    static long max(long a,long b,long c,long d) {
+        return Math.max(a, Math.max(b, Math.max(c, d)));
+    }
+
+    static long sum(int A[]) {
+        long sum=0;
+        for(int i : A) {
+            sum+=i;
+        }
+        return sum;
+    }
+
+    static long sum(long A[]) {
+        long sum=0;
+        for(long i : A) {
+            sum+=i;
+        }
+        return sum;
+    }
+
+    static void print(int A[]) {
+        for(int i : A) {
+            System.out.print(i+"" "");
+        }
+        System.out.println();
+    }
+
+    static void print(long A[]) {
+        for(long i : A) {
+            System.out.print(i+"" "");
+        }
+        System.out.println();
+    }
+
+    static long mod(long x) {
+          return ((x%mod + mod)%mod);
+    }
+
+    static long power(long x, long y)
+    {
+
+	if(y==0)
+		return 1;
+	if(x==0)
+		return 0;
+    long res = 1;
+    while (y > 0) {
+
+        if (y % 2 == 1)
+            res = (res * x) ;
+
+        y = y >> 1; 
+        x = (x * x);
+    }
+
+    return res;
+    }
+
+    static boolean prime(int n) 
+	    { 
+	        if (n <= 1) 
+	            return false; 
+	        if (n <= 3) 
+	            return true; 
+	        if (n % 2 == 0 || n % 3 == 0) 
+	            return false; 
+	        double sq=Math.sqrt(n);
+	  
+	        for (int i = 5; i <= sq; i = i + 6) 
+	            if (n % i == 0 || n % (i + 2) == 0) 
+	                return false; 
+	        return true; 
+	    } 
+
+     static boolean prime(long n) 
+	    { 
+	        if (n <= 1) 
+	            return false; 
+	        if (n <= 3) 
+	            return true; 
+	        if (n % 2 == 0 || n % 3 == 0) 
+	            return false; 
+	        double sq=Math.sqrt(n);
+	  
+	        for (int i = 5; i <= sq; i = i + 6) 
+	            if (n % i == 0 || n % (i + 2) == 0) 
+	                return false; 
+	        return true; 
+	    } 
+        //pair class
+        private static class Pair implements Comparable<Pair> {
+            int first, second;
+            public Pair(int f, int s) {
+                first = f;
+                second = s;
+            }
+            @Override
+            public int compareTo(Pair p) {
+                if (first > p.first)
+                    return 1;
+                else if (first < p.first)
+                    return -1;
+                else {
+                    if (second > p.second)
+                        return 1;
+                    else if (second < p.second)
+                        return -1;
+                    else
+                        return 0;
+                }
+            }
+     
+        }
+}","import java.util.*;
+public class Solution{
+    public static void main(String[] args){
+    Scanner sc=new Scanner(System.in);
+    int t=sc.nextInt();
+
+    while(t-->0) {
+        int n=sc.nextInt();
+        int[] a=new int[n];
+        for(int i=0;i<n;i++)
+             a[i]=sc.nextInt();
+
+     char[] c=sc.next().toCharArray();
+
+        Vector<Integer> l=new Vector<>(), r=new Vector<>();
+        for(int i=0;i<n;i++)
+            (c[i] == 'B' ? l : r).add(a[i]);
+        Collections.sort(l);
+        Collections.sort(r,Collections.reverseOrder());
+
+        boolean ok = true;
+        for(int i=0;i<l.size();i++)
+            if (l.get(i) < i + 1)
+                ok = false;
+        for(int i=0;i<r.size();i++)
+            if (r.get(i) > n - i)
+                ok = false;
+
+         System.out.print((ok ? ""YES"" : ""NO"")+'\n');
+    }
+    }
+}",1
+529d9642,8ad1ad84,"import java.util.*;
+import java.io.*;
+import java.math.*;
+
+/**
+ *
+ * @Har_Har_Mahadev
+ */
+
+/**
+ * Main , Solution , Remove Public
+ */
+public class C {
+
+	private static ArrayList<Integer>[] adj;
+	private static ArrayList<Pair> lis;
+	private static Pair[] arr;
+	
+
+	public static void process() throws IOException {
+
+		int n = sc.nextInt();
+		lis = new ArrayList<C.Pair>();
+		for(int i = 0; i<n; i++)lis.add(new Pair(sc.nextInt(), sc.nextInt()));
+		adj = new ArrayList[n+1];
+		for(int i = 0; i<=n; i++)adj[i] = new ArrayList<Integer>();
+		for(int i = 1; i<n; i++) {
+			int u = sc.nextInt(),v = sc.nextInt();
+			adj[u].add(v);
+			adj[v].add(u);
+		}
+		arr = new Pair[n+1];
+		for(int i = 1; i<=n; i++)arr[i] = new Pair(0, 0);
+		dfs(1,-1);
+		println(max(arr[1].x,arr[1].y));
+	}
+
+	
+
+	private static void dfs(int node, int par) {
+		for(int child : adj[node]) {
+			if(child == par)continue;
+			dfs(child, node);
+			long ff = lis.get(node-1).x;
+			long ss = lis.get(node-1).y;
+			long cff = lis.get(child-1).x;
+			long css = lis.get(child-1).y;
+			
+			
+			// first 
+			long val1 = abs(ff-cff) + arr[child].x;
+			long val2 = abs(ff-css) + arr[child].y;
+			if(val1 > val2) {
+				arr[node].x+=val1;
+			}
+			else {
+				arr[node].x+=val2;
+			}
+			// second 
+			val1 = abs(ss-cff) + arr[child].x;
+			val2 = abs(ss-css) + arr[child].y;
+			if(val1 > val2) {
+				arr[node].y+=val1;
+			}
+			else {
+				arr[node].y+=val2;
+			}
+		}
+		
+		
+	}
+
+
+
+	
+
+
+
+	//=============================================================================
+	//--------------------------The End---------------------------------
+	//=============================================================================
+	private static long INF = 2000000000000000000L, M = 1000000007, MM = 998244353;
+	private static int N = 0;
+
+	private static void google(int tt) {
+		System.out.print(""Case #"" + (tt) + "": "");
+	}
+
+	static FastScanner sc;
+	static PrintWriter out;
+
+	public static void main(String[] args) throws IOException {
+		boolean oj = true;
+		if (oj) {
+			sc = new FastScanner();
+			out = new PrintWriter(System.out);
+		} else {
+			sc = new FastScanner(100);
+			out = new PrintWriter(""output.txt"");
+		}
+		int t = 1;
+		t = sc.nextInt();
+		int TTT = 1;
+		while (t-- > 0) {
+			//			google(TTT++);
+			process();
+		}
+		out.flush();
+		out.close();
+	}
+
+	static class Pair implements Comparable<Pair> {
+		long x, y;
+
+		Pair(long x, long y) {
+			this.x = x;
+			this.y = y;
+		}
+
+		@Override
+		public int compareTo(Pair o) {
+			return Long.compare(this.x, o.x);
+		}
+
+		//		 @Override
+		//		    public boolean equals(Object o) {
+		//		        if (this == o) return true;
+		//		        if (!(o instanceof Pair)) return false;
+		//		        Pair key = (Pair) o;
+		//		        return x == key.x && y == key.y;
+		//		    }
+		//		 
+		//		    @Override
+		//		    public int hashCode() {
+		//		        int result = x;
+		//		        result = 31 * result + y;
+		//		        return result;
+		//		    }
+	}
+
+	/////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+	static void println(Object o) {
+		out.println(o);
+	}
+
+	static void println() {
+		out.println();
+	}
+
+	static void print(Object o) {
+		out.print(o);
+	}
+
+	static void pflush(Object o) {
+		out.println(o);
+		out.flush();
+	}
+
+	static int ceil(int x, int y) {
+		return (x % y == 0 ? x / y : (x / y + 1));
+	}
+
+	static long ceil(long x, long y) {
+		return (x % y == 0 ? x / y : (x / y + 1));
+	}
+
+	static int max(int x, int y) {
+		return Math.max(x, y);
+	}
+
+	static int min(int x, int y) {
+		return Math.min(x, y);
+	}
+
+	static int abs(int x) {
+		return Math.abs(x);
+	}
+
+	static long abs(long x) {
+		return Math.abs(x);
+	}
+
+	static long sqrt(long z) {
+		long sqz = (long) Math.sqrt(z);
+		while (sqz * 1L * sqz < z) {
+			sqz++;
+		}
+		while (sqz * 1L * sqz > z) {
+			sqz--;
+		}
+		return sqz;
+	}
+
+	static int log2(int N) {
+		int result = (int) (Math.log(N) / Math.log(2));
+		return result;
+	}
+
+	static long max(long x, long y) {
+		return Math.max(x, y);
+	}
+
+	static long min(long x, long y) {
+		return Math.min(x, y);
+	}
+
+	public static int gcd(int a, int b) {
+		BigInteger b1 = BigInteger.valueOf(a);
+		BigInteger b2 = BigInteger.valueOf(b);
+		BigInteger gcd = b1.gcd(b2);
+		return gcd.intValue();
+	}
+
+	public static long gcd(long a, long b) {
+		BigInteger b1 = BigInteger.valueOf(a);
+		BigInteger b2 = BigInteger.valueOf(b);
+		BigInteger gcd = b1.gcd(b2);
+		return gcd.longValue();
+	}
+
+	public static long lcm(long a, long b) {
+		return (a * b) / gcd(a, b);
+	}
+
+	public static int lcm(int a, int b) {
+		return (a * b) / gcd(a, b);
+	}
+
+	public static int lower_bound(int[] arr, int x) {
+		int low = 0, high = arr.length, mid = -1;
+
+		while (low < high) {
+			mid = (low + high) / 2;
+
+			if (arr[mid] >= x)
+				high = mid;
+			else
+				low = mid + 1;
+		}
+
+		return low;
+	}
+
+	public static int upper_bound(int[] arr, int x) {
+		int low = 0, high = arr.length, mid = -1;
+
+		while (low < high) {
+			mid = (low + high) / 2;
+
+			if (arr[mid] > x)
+				high = mid;
+			else
+				low = mid + 1;
+		}
+
+		return low;
+	}
+
+	/////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+	static class FastScanner {
+		BufferedReader br;
+		StringTokenizer st;
+
+		FastScanner() throws FileNotFoundException {
+			br = new BufferedReader(new InputStreamReader(System.in));
+		}
+
+		FastScanner(int a) throws FileNotFoundException {
+			br = new BufferedReader(new FileReader(""input.txt""));
+		}
+
+		String next() throws IOException {
+			while (st == null || !st.hasMoreElements()) {
+				try {
+					st = new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			}
+			return st.nextToken();
+		}
+
+		int nextInt() throws IOException {
+			return Integer.parseInt(next());
+		}
+
+		long nextLong() throws IOException {
+			return Long.parseLong(next());
+		}
+
+		double nextDouble() throws IOException {
+			return Double.parseDouble(next());
+		}
+
+		String nextLine() throws IOException {
+			String str = """";
+			try {
+				str = br.readLine();
+			} catch (IOException e) {
+				e.printStackTrace();
+			}
+			return str;
+		}
+
+		int[] readArray(int n) throws IOException {
+			int[] A = new int[n];
+			for (int i = 0; i != n; i++) {
+				A[i] = sc.nextInt();
+			}
+			return A;
+		}
+
+		long[] readArrayLong(int n) throws IOException {
+			long[] A = new long[n];
+			for (int i = 0; i != n; i++) {
+				A[i] = sc.nextLong();
+			}
+			return A;
+		}
+	}
+
+	static void ruffleSort(int[] a) {
+		Random get = new Random();
+		for (int i = 0; i < a.length; i++) {
+			int r = get.nextInt(a.length);
+			int temp = a[i];
+			a[i] = a[r];
+			a[r] = temp;
+		}
+		Arrays.sort(a);
+	}
+
+	static void ruffleSort(long[] a) {
+		Random get = new Random();
+		for (int i = 0; i < a.length; i++) {
+			int r = get.nextInt(a.length);
+			long temp = a[i];
+			a[i] = a[r];
+			a[r] = temp;
+		}
+		Arrays.sort(a);
+	}
+}
+","import java.io.*;
+import java.util.*;
+import java.math.*;
+import java.math.BigInteger; 
+//import javafx.util.*; 
+public final class B
+{    
+	 static PrintWriter out = new PrintWriter(System.out); 
+	static StringBuilder ans=new StringBuilder();
+	static FastReader in=new FastReader();
+	static ArrayList<Integer> g[];
+	static long mod=(long)(1e9+7);
+	static int D1[],D2[],par[];
+	static boolean set[];
+	static int value[];
+	static long INF=Long.MAX_VALUE;
+	static int N,M;
+	static long L[],R[],dp[][];
+	static int s=1;
+	public static void main(String args[])throws IOException
+	{  					
+		int T=i();
+		outer:while(T-->0)
+		{
+			int N=i();
+			setGraph(N);
+			for(int i=1; i<=N; i++)
+			{
+				L[i]=l();
+				R[i]=l();
+			}
+			for(int i=1; i<N; i++)
+			{
+				int a=i(),b=i();
+				g[a].add(b);
+				g[b].add(a);
+			}
+			f(1,-1);
+			out.println(Math.max(dp[0][1], dp[1][1]));
+		}
+		out.close();
+		//print(L);
+		//print(R);
+		
+		//print(dp[0]);
+		//print(dp[1]);
+		
+
+	}	
+	static void f(int n,int p)
+	{
+		for(int c:g[n])
+		{
+			if(c!=p)
+			{
+			f(c,n);
+			long a=dp[0][c]+Math.abs(L[c]-L[n]);
+			long b=dp[1][c]+Math.abs(R[c]-L[n]);
+			dp[0][n]+=Math.max(a, b);
+			a=dp[0][c]+Math.abs(L[c]-R[n]);
+			b=dp[1][c]+Math.abs(R[c]-R[n]);
+			dp[1][n]+=Math.max(a, b);
+			}
+		}
+	}
+	static boolean isPalin(char X[])
+	{
+		int l=0,r=X.length-1;
+		while(l<=r)
+		{
+			if(X[l]!=X[r])return false;
+			l++;
+			r--;
+		}
+		return true;
+	}
+
+	static boolean isSorted(int A[])
+	{
+		int N=A.length;
+		for(int i=0; i<N-1; i++)
+		{
+			if(A[i]>A[i+1])return false;
+		}
+
+		return true;		
+	}
+	static int f1(int x,ArrayList<Integer> A)
+	{
+		int l=-1,r=A.size();
+		while(r-l>1)
+		{
+			int m=(l+r)/2;
+			int a=A.get(m);
+			if(a<x)l=m;
+			else r=m;
+		}		
+		return l;
+	}
+
+
+	static int ask(int t,int i,int j,int x)
+	{
+		System.out.println(""? ""+t+"" ""+i+"" ""+j+"" ""+x);
+		return i();
+	}
+
+	static int ask(int a)
+	{
+		System.out.println(""? 1 ""+a);
+		return i();
+	}
+	static int f(int st,int end,int d)
+	{
+		if(st>end)return 0;
+		int a=0,b=0,c=0;
+		if(d>1)a=f(st+d-1,end,d-1);
+		b=f(st+d,end,d);
+		c=f(st+d+1,end,d+1);
+		return value[st]+max(a,b,c);
+	}
+	static int max(int a,int b,int c)
+	{
+		return Math.max(a, Math.max(c, b));
+	}
+	static int value(char X[],char Y[])
+	{
+		int c=0;
+		for(int i=0; i<7; i++)
+		{
+			if(Y[i]=='1' && X[i]=='0')return -1;
+			if(X[i]=='1' && Y[i]=='0')c++;
+		}
+		return c;
+	}
+	static boolean isValid(int i,int j)
+	{
+		if(i<0 || i>=N)return false;
+		if(j<0 || j>=M)return false;
+		return true;
+	}
+
+	static long fact(long N)
+	{
+		long num=1L;
+		while(N>=1)
+		{
+			num=((num%mod)*(N%mod))%mod;
+			N--;
+		}
+		return num;
+	}
+	static boolean reverse(long A[],int l,int r)
+	{
+		while(l<r)
+		{
+			long t=A[l];
+			A[l]=A[r];
+			A[r]=t;
+			l++;
+			r--;
+		}
+		if(isSorted(A))return true;
+		else return false;
+	}
+	static boolean isSorted(long A[])
+	{
+		for(int i=1; i<A.length; i++)if(A[i]<A[i-1])return false;
+		return true;
+	}
+	static boolean isPalindrome(char X[],int l,int r)
+	{
+		while(l<r)
+		{
+			if(X[l]!=X[r])return false;
+			l++; r--;
+		}
+		return true;
+	}
+
+	static long min(long a,long b,long c)
+	{
+		return Math.min(a, Math.min(c, b));
+	}
+
+	static void print(int a)
+	{
+		System.out.println(""! ""+a);
+	}
+	static int ask(int a,int b)
+	{
+		System.out.println(""? ""+a+"" ""+b);
+		return i();
+	}
+	static int find(int a)
+	{
+		if(par[a]<0)return a;
+		return par[a]=find(par[a]);
+	}
+	static void union(int a,int b)
+	{
+		a=find(a);
+		b=find(b);
+		if(a!=b)
+		{
+			par[a]+=par[b]; //transfers the size
+			par[b]=a;       //changes the parent
+		}
+	}
+	static void swap(char A[],int a,int b)
+	{
+		char ch=A[a];
+		A[a]=A[b];
+		A[b]=ch;
+	}
+
+	static void sort(long[] a) //check for long
+	{
+		ArrayList<Long> l=new ArrayList<>();
+		for (long i:a) l.add(i);
+		Collections.sort(l);
+		for (int i=0; i<a.length; i++) a[i]=l.get(i);
+	}
+	static void setGraph(int N)
+	{
+		g=new ArrayList[N+1];
+		dp=new long[2][N+1];
+		L=new long[N+1];
+		R=new long[N+1];
+		for(int i=0; i<=N; i++)
+		{
+
+			g[i]=new ArrayList<Integer>();
+		}
+	}
+
+	static  long pow(long a,long b)
+	{
+		long mod=1000000007;
+		long pow=1;
+		long x=a;
+		while(b!=0)
+		{
+			if((b&1)!=0)pow=(pow*x)%mod;
+			x=(x*x)%mod;
+			b/=2;
+		}
+		return pow;
+	}
+	static long toggleBits(long x)//one's complement || Toggle bits
+	{
+		int n=(int)(Math.floor(Math.log(x)/Math.log(2)))+1;
+
+		return ((1<<n)-1)^x;
+	}
+	static int countBits(long a)
+	{
+		return (int)(Math.log(a)/Math.log(2)+1);
+	}
+	static void sort(int[] a) {
+		ArrayList<Integer> l=new ArrayList<>();
+		for (int i:a) l.add(i);
+		Collections.sort(l);
+		for (int i=0; i<a.length; i++) a[i]=l.get(i);
+	}
+	static boolean isPrime(long N)
+	{
+		if (N<=1)  return false; 
+		if (N<=3)  return true; 
+		if (N%2 == 0 || N%3 == 0) return false; 
+		for (int i=5; i*i<=N; i=i+6) 
+			if (N%i == 0 || N%(i+2) == 0) 
+				return false; 
+		return true; 
+	}
+	static long GCD(long a,long b) 
+	{
+		if(b==0)
+		{
+			return a;
+		}
+		else return GCD(b,a%b );
+	}
+
+	//Debugging Functions Starts
+
+	static void print(char A[])
+	{
+		for(char c:A)System.out.print(c+"" "");
+		System.out.println();
+	}
+	static void print(boolean A[])
+	{
+		for(boolean c:A)System.out.print(c+"" "");
+		System.out.println();
+	}
+	static void print(int A[])
+	{
+		for(int a:A)System.out.print(a+"" "");
+		System.out.println();	
+	}
+	static void print(long A[])
+	{
+		for(long i:A)System.out.print(i+ "" "");
+		System.out.println();
+
+	}
+	static void print(ArrayList<Integer> A)
+	{
+		for(int a:A)System.out.print(a+"" "");
+		System.out.println();
+	}
+
+	//Debugging Functions END
+	//----------------------
+	//IO FUNCTIONS STARTS
+	static HashMap<Integer,Integer> Hash(int A[])
+	{
+		HashMap<Integer,Integer> mp=new HashMap<>();
+		for(int a:A)
+		{
+			int f=mp.getOrDefault(a,0)+1;
+			mp.put(a, f);
+		}
+		return mp;
+	}
+	static int i()
+	{
+		return in.nextInt();
+	}
+
+	static long l()
+	{
+		return in.nextLong();
+	}
+
+	static int[] input(int N){
+		int A[]=new int[N];
+		for(int i=0; i<N; i++)
+		{
+			A[i]=in.nextInt();
+		}
+		return A;
+	}
+
+	static long[] inputLong(int N)     {
+		long A[]=new long[N];
+		for(int i=0; i<A.length; i++)A[i]=in.nextLong();
+		return A;
+	}
+
+	//IO FUNCTIONS END
+
+}
+
+class node implements Comparable<node>
+{
+	int x,index; boolean right;
+	node(int x,boolean right,int index)
+	{
+		this.x=x;
+		this.right=right;
+		this.index=index;
+	}
+	public int compareTo(node X)
+	{
+		return this.x-X.x;
+	}
+}
+
+//Code For FastReader
+//Code For FastReader
+//Code For FastReader
+//Code For FastReader
+class FastReader
+{
+	BufferedReader br;
+	StringTokenizer st;
+	public FastReader()
+	{
+		br=new BufferedReader(new InputStreamReader(System.in));
+	}
+
+	String next()
+	{
+		while(st==null || !st.hasMoreElements())
+		{
+			try
+			{
+				st=new StringTokenizer(br.readLine());
+			}
+			catch(IOException e)
+			{
+				e.printStackTrace();
+			}
+		}
+		return st.nextToken();
+	}
+
+	int nextInt()
+	{
+		return Integer.parseInt(next());
+	}
+
+	long nextLong()
+	{
+		return Long.parseLong(next());
+	}
+	//gey
+	double nextDouble()
+	{
+		return Double.parseDouble(next());
+	}
+
+	String nextLine()
+	{
+		String str="""";
+		try
+		{
+			str=br.readLine();
+		}
+		catch (IOException e)
+		{
+			e.printStackTrace();
+		}
+		return str;
+	}
+
+}",0
+3d06b643,930dd1f1,"import java.io.*;
+import java.util.*;
+
+public class ArmChairs {
+    
+
+    public static int solution(int n, int[] arr) {
+
+        ArrayList<Integer> one = new ArrayList<Integer>();
+        ArrayList<Integer> zero = new ArrayList<Integer>();
+
+        for (int i = 0; i < n; i++) {
+            if (arr[i] == 1) {
+                one.add(i);
+            } else {
+                zero.add(i);
+            }
+        }
+
+        int[][] dp = new int[one.size() + 1][zero.size() + 1];
+
+        for (int i = 1; i <= one.size(); i++) {
+            dp[i][i] = dp[i - 1][i - 1] + Math.abs(one.get(i - 1) - zero.get(i - 1));
+            for (int j = i + 1; j <= zero.size(); j++) {
+                dp[i][j] = Math.min(dp[i][j - 1], dp[i - 1][j - 1] + Math.abs(one.get(i - 1) - zero.get(j - 1)));
+            }
+        }
+
+        return dp[one.size()][zero.size()];
+    }
+
+
+    public static void main(String[] args) throws IOException{
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        BufferedWriter log = new BufferedWriter(new OutputStreamWriter(System.out));
+
+        int n = Integer.parseInt(br.readLine());
+
+        String[] s = br.readLine().split("" "");
+        int[] arr = new int[n];
+        for (int i = 0; i < n; i++) {
+            arr[i] = Integer.parseInt(s[i]);
+        } 
+
+        log.write(Integer.toString(solution(n, arr)) + ""\n"");
+        log.flush();
+        
+    }
+
+}
+","import java.util.*;
+import java.io.*;
+public class Armchairs 
+{
+	public static int val(int b[],int m,int c[],int n,int dp[][])
+	{
+		if(dp[m][n]>-1)
+		{
+			return dp[m][n];
+		}
+		else
+		if(m==0)
+		{
+			return 0;
+		}
+		else
+		if(n==0)
+		{
+							return 2099999999;
+		}
+		else
+		{
+		
+			return dp[m][n]=Math.min(val(b,m-1,c,n-1,dp)+Math.abs(b[m-1]-c[n-1]),val(b,m,c,n-1,dp));
+		}
+	}
+	public static void process()throws IOException
+	{
+		int n=I();
+		int a[]=Ai(n);
+		ArrayList<Integer> arr=new ArrayList<Integer>();
+		ArrayList<Integer> arr1=new ArrayList<Integer>();
+		for(int i=0;i<n;i++)
+		{
+			if(a[i]==0)
+			{
+				arr1.add(i);
+			}
+			else
+			{
+				arr.add(i);
+			}
+		}
+		int b[]=new int[arr.size()];
+		int c[]=new int[arr1.size()];
+		int m=arr.size();int n1=arr1.size();
+		int dp[][]=new int[m+1][n1+1];
+
+		dyn(dp,m+1,n1+1,-1);
+		
+		for(int i=0;i<arr.size();i++)
+		{
+			b[i]=arr.get(i);
+		}
+		for(int i=0;i<arr1.size();i++)
+		{
+			c[i]=arr1.get(i);
+		}
+
+		arr.clear();
+	    arr1.clear();
+	   pn(val(b,m,c,n1,dp));
+	}
+	static Scanner sc = new Scanner(System.in);
+	static PrintWriter out = new PrintWriter(System.out);
+	static void pn(Object o){out.println(o);out.flush();}
+	static void p(Object o){out.print(o);out.flush();}
+	static void pni(Object o){out.println(o);System.out.flush();}
+	static int I() throws IOException{return sc.nextInt();}
+	static long L() throws IOException{return sc.nextLong();}
+	static double D() throws IOException{return sc.nextDouble();}
+	static String S() throws IOException{return sc.next();}
+	static char C() throws IOException{return sc.next().charAt(0);}
+	static int[] Ai(int n) throws IOException{int[] arr = new int[n];for (int i = 0; i < n; i++)arr[i] = I();return arr;}
+	static String[] As(int n) throws IOException{String s[] = new String[n];for (int i = 0; i < n; i++)s[i] = S();return s;}
+	static long[] Al(int n) throws IOException {long[] arr = new long[n];for (int i = 0; i < n; i++)arr[i] = L();return arr;}
+	static void dyn(int dp[][],int n,int m,int z)throws IOException {for(int i=0;i<n;i++){ for(int j=0;j<m;j++){ dp[i][j]=z;}} }
+	
+//	*--------------------------------------------------------------------------------------------------------------------------------*//
+	static class AnotherReader {BufferedReader br;StringTokenizer st;AnotherReader() throws FileNotFoundException {br = new BufferedReader(new InputStreamReader(System.in));}
+	AnotherReader(int a) throws FileNotFoundException {br = new BufferedReader(new FileReader(""input.txt""));}
+	String next() throws IOException{while (st == null || !st.hasMoreElements()) {try {st = new StringTokenizer(br.readLine());} catch (IOException e) {e.printStackTrace();}}return st.nextToken();}
+	int nextInt() throws IOException {return Integer.parseInt(next());}
+	long nextLong() throws IOException {return Long.parseLong(next());}
+	double nextDouble() throws IOException {return Double.parseDouble(next());}
+	String nextLine() throws IOException {String str = """";try {str = br.readLine();} catch (IOException e) {e.printStackTrace();}return str;}}
+	public static void main(String[] args)throws IOException{try{boolean oj=true;if(oj==true)
+	{AnotherReader sk=new AnotherReader();PrintWriter out=new PrintWriter(System.out);}
+	else
+	{AnotherReader sk=new AnotherReader(100);out=new PrintWriter(""output.txt"");}
+	//long T=L();while(T-->0)
+	{process();}out.flush();out.close();}catch(Exception e){return;}}}
+//*-----------------------------------------------------------------------------------------------------------------------------------*//
+	
+",0
+4138b081,f729338f,"import java.io.*;
+import java.util.*;
+ 
+public class Contest1627C
+{
+    static class InputReader {
+        BufferedReader reader;
+        StringTokenizer tokenizer;
+        public InputReader(InputStream stream) {
+            reader = new BufferedReader(new InputStreamReader(stream), 32768);
+            tokenizer = null;
+        }
+        String next() { // reads in the next string
+            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
+                try {
+                    tokenizer = new StringTokenizer(reader.readLine());
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+            }
+            return tokenizer.nextToken();
+        }
+        public int nextInt() { // reads in the next int
+            return Integer.parseInt(next());
+        }
+        public long nextLong() { // reads in the next long
+            return Long.parseLong(next());
+        }
+        public double nextDouble() { // reads in the next double
+            return Double.parseDouble(next());
+            }
+        }
+    static InputReader r = new InputReader(System.in);
+    static PrintWriter pw = new PrintWriter(System.out);
+    static long mod = 1000000007; static ArrayList<Integer>[] adj; static ArrayList<Integer>[] num; static int[] ans;
+    public static void main(String[] args)
+    {
+    	int t = r.nextInt();
+    	while (t > 0)
+    	{
+    		t--;
+    		int n = r.nextInt();
+    		adj = new ArrayList[n];
+    		num = new ArrayList[n];
+    		for (int i = 0; i < n; i ++)
+    		{
+    			adj[i] = new ArrayList<Integer>();
+    			num[i] = new ArrayList<Integer>();
+    		}
+    		int[] deg = new int[n];
+    		boolean flag = false;
+    		for (int i = 0; i < n - 1; i ++)
+    		{
+    			int a = r.nextInt()-1;
+    			int b = r.nextInt()-1;
+    			adj[a].add(b);
+    			adj[b].add(a);
+    			num[a].add(i);
+    			num[b].add(i);
+    			deg[a] ++;
+    			deg[b] ++;
+    			if (deg[a] > 2 || deg[b] > 2)
+    			{
+    				flag = true;
+    			}
+    		}
+    		if (flag)
+    		{
+    			pw.println(-1);
+    			continue;
+    		}
+    		ans = new int[n];
+    		for (int i = 0; i < n; i ++)
+    		{
+    			if (deg[i] == 1)
+    			{
+    				dfs(i,3,-1);
+    			}
+    		}
+    		for (int i = 0; i < n - 1; i ++)
+    		{
+    			pw.println(ans[i]);
+    		}
+    	}
+        pw.close();
+    }
+    static void dfs(int node, int x, int p)
+    {
+    	for (int j = 0; j < adj[node].size(); j ++)
+    	{
+    		int i = adj[node].get(j);
+    		if (i == p)
+    		{
+    			continue;
+    		}
+    		ans[num[node].get(j)] = x;
+    		dfs(i,5-x,node);
+    	}
+    }
+}","import java.io.*;
+import java.util.*;
+
+public class Solution{
+    
+    public static class Edge
+    {
+        int index; int u, v;
+        Edge(int u, int v, int index)
+        {
+            this.index=index;
+            this.u = u;
+            this.v = v;
+        }
+        
+    }
+	public static void main (String[] args) throws Exception 
+	{
+		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+		StringBuilder sb=new StringBuilder();
+		int t=Integer.parseInt(br.readLine());
+		
+		while(t-->0)
+		{
+		    int n=Integer.parseInt(br.readLine());
+		    ArrayList<Edge> graph[] = new ArrayList[n];
+		    for(int i=0; i<n; i++) graph[i] = new ArrayList<>();
+		    
+		    for(int i=0; i<n-1; i++)
+		    {
+		        StringTokenizer st=new StringTokenizer(br.readLine());
+		        int u = Integer.parseInt(st.nextToken());
+		        int v = Integer.parseInt(st.nextToken());
+		        
+		        u--; v--;
+		        graph[u].add(new Edge(u,v,i));
+		        graph[v].add(new Edge(v,u,i));
+		    }
+		    
+		    int start_i = 0;
+		    boolean poss = true;
+		    for(int i =0; i<n; i++)
+		    {
+		        if(graph[i].size()>2) 
+		        {
+		            poss = false;
+		        }
+		        else if(graph[i].size() == 1) start_i = i;
+		    }
+		    
+		    if(!poss) 
+		    {
+		        sb.append(""-1\n"");
+		        continue;
+		    }
+		    
+		    int wts[] = new int[n-1];
+		    
+		    ArrayList<Edge> edges = new ArrayList<>();
+		    
+		    Edge first = graph[start_i].get(0);
+		    wts[first.index] = 2;
+		    
+		    edges = graph[first.v];
+		    
+		    while(edges.size()>1)
+		    {
+		        
+		        Edge firste = edges.get(0);
+		        Edge sece = edges.get(1);
+		        if(wts[firste.index] != 0 ) //second not visited
+		        {
+		            wts[sece.index] = 5 - wts[firste.index];
+		            edges = graph[sece.v];
+		        }
+		        else //first not visited
+		        {
+		            wts[firste.index] = 5 - wts[sece.index];
+		            edges = graph[firste.v];
+		        }
+		    }
+		    
+		    for(int i=0; i<n-1; i++)
+		        sb.append(wts[i]+"" "");
+	        sb.append(""\n"");
+		    
+		    
+		}
+		System.out.println(sb);
+	}
+}",0
+00f79486,fb312dc6,"/*                       In_The_Name_Of_Allah_The_Merciful                        */
+import java.util.*;
+
+import java.io.*;  
+public class Main
+{
+	class Pair implements Comparable<Pair>{
+		int f,s;
+		Pair(int x,int y){
+			f=x;
+			s=y;
+		}
+		@Override
+		public int compareTo(Pair a) {
+			if(a.f!=this.f)return Integer.compare(f,a.f);
+			else return Integer.compare(s,a.s);
+		}
+	}
+    PrintWriter out;
+    FastReader sc;
+    long[] m1= {(long)(1e9+7),998244353};
+    long mod=m1[1];
+    long maxlong=Long.MAX_VALUE;
+    long minlong=Long.MIN_VALUE;
+    StringBuilder sb;
+   
+    /******************************************************************************************
+     *****************************************************************************************/
+    
+	public void sol() {
+		int n=ni();
+		int[] ar=new int[n];
+		for(int i=0;i<n;i++)ar[i]=ni();
+		char[] s=rl();
+		PriorityQueue<Integer> red=new PriorityQueue<>(Collections.reverseOrder()),blue=new PriorityQueue<>();
+		for(int i=0;i<n;i++) {
+			if(s[i]=='R')red.add(ar[i]);
+			else blue.add(ar[i]);
+		}
+		int a=n;
+		while(red.size()>0) {
+			if(red.poll()>a) {
+				no();return;
+			}a--;
+		}a=1;
+		while(blue.size()>0) {
+			if(blue.poll()<a) {
+				no();return;
+			}a++;
+		}yes();
+	}
+    public static void main(String[] args) 
+	{ 
+	    Main g=new Main();
+		g.out=new PrintWriter(System.out);
+		g.sc=new FastReader();
+		int t=1;
+ 		t=g.ni();
+		while(t-->0)
+		g.sol();
+		g.out.flush();
+	}
+	
+	/****************************************************************************************
+     *****************************************************************************************/
+	static class FastReader 
+	{ 
+		BufferedReader br; 
+		StringTokenizer st; 
+ 
+		public FastReader() 
+		{ 
+			br = new BufferedReader(new
+					InputStreamReader(System.in)); 
+		} 
+ 
+		String next() 
+		{ 
+			while (st == null || !st.hasMoreElements()) 
+			{ 
+				try
+				{ 
+					st = new StringTokenizer(br.readLine()); 
+				} 
+				catch (IOException e) 
+				{ 
+					e.printStackTrace(); 
+				} 
+			} 
+			return st.nextToken(); 
+		} 
+ 
+		int nextInt() 
+		{ 
+			return Integer.parseInt(next()); 
+		} 
+ 
+		long nextLong() 
+		{ 
+			return Long.parseLong(next()); 
+		} 
+ 
+		double nextDouble() 
+		{ 
+			return Double.parseDouble(next()); 
+		} 
+ 
+		String nextLine() 
+		{ 
+			String str = """"; 
+			try
+			{ 
+				str = br.readLine(); 
+			} 
+			catch (IOException e) 
+			{ 
+				e.printStackTrace(); 
+			} 
+			return str; 
+		} 
+	} public int ni(){
+	      return sc.nextInt();
+	}public long nl(){
+	      return sc.nextLong();
+	}public double nd(){
+	      return sc.nextDouble();
+	}public char[] rl(){
+	      return sc.nextLine().toCharArray();
+	}public String rl1(){
+	      return sc.nextLine();
+	}
+	public void pl(Object s){
+	      out.println(s);
+	}
+	public void pr(Object s){
+	      out.print(s);
+	}public String next(){
+	      return sc.next();
+	}public long abs(long x){
+	      return Math.abs(x);
+	}
+	public int abs(int x){
+	      return Math.abs(x);
+	}
+	public double abs(double x){
+	      return Math.abs(x);
+	}public long min(long x,long y){
+            return (long)Math.min(x,y);
+      }
+      public int min(int x,int y){
+            return (int)Math.min(x,y);
+      }
+      public double min(double x,double y){
+            return Math.min(x,y);
+      }public long gcd(long a, long b) {
+		if (a == 0)
+			return b;
+		return gcd(b % a, a);
+	}public long lcm(long a, long b) {
+            return (a / gcd(a, b)) * b;
+      }
+       void sort1(int[] a) {
+		ArrayList<Integer> l = new ArrayList<>();
+		for (int i : a) {
+			l.add(i);
+		}
+		Collections.sort(l,Collections.reverseOrder());
+		for (int i = 0; i < a.length; i++) {
+			a[i] = l.get(i);
+		}
+	}
+	 void sort(int[] a) {
+		ArrayList<Integer> l = new ArrayList<>();
+		for (int i : a) {
+			l.add(i);
+		}
+		Collections.sort(l);
+		for (int i = 0; i < a.length; i++) {
+			a[i] = l.get(i);
+		}
+	}void sort(char[] a) {
+		ArrayList<Character> l = new ArrayList<>();
+		for (char i : a) {
+			l.add(i);
+		}
+		Collections.sort(l);
+		for (int i = 0; i < a.length; i++) {
+			a[i] = l.get(i);
+		}
+	}void sort1(char[] a) {
+		ArrayList<Character> l = new ArrayList<>();
+		for (char i : a) {
+			l.add(i);
+		}
+		Collections.sort(l,Collections.reverseOrder());
+		for (int i = 0; i < a.length; i++) {
+			a[i] = l.get(i);
+		}
+	}
+	 void sort(long[] a) {
+		ArrayList<Long> l = new ArrayList<>();
+		for (long i : a) {
+			l.add(i);
+		}
+		Collections.sort(l);
+		for (int i = 0; i < a.length; i++) {
+			a[i] = l.get(i);
+		}
+	}void sort1(long[] a) {
+		ArrayList<Long> l = new ArrayList<>();
+		for (long i : a) {
+			l.add(i);
+		}
+		Collections.sort(l,Collections.reverseOrder());
+		for (int i = 0; i < a.length; i++) {
+			a[i] = l.get(i);
+		}
+	}
+	void sort(double[] a) {
+		ArrayList<Double> l = new ArrayList<>();
+		for (double i : a) {
+			l.add(i);
+		}
+		Collections.sort(l);
+		for (int i = 0; i < a.length; i++) {
+			a[i] = l.get(i);
+		}
+	}long pow(long a,long b){
+          if(b==0){
+                return 1;
+          }long p=pow(a,b/2);
+          if(b%2==0) return mMultiplication(p,p)%mod;
+          else return (mMultiplication(mMultiplication(p,p),a))%mod;
+    }
+	
+	int  swap(int a,int b){
+	      return a;
+	}long  swap(long a,long b){
+	      return a;
+	}double  swap(double a,double b){
+	      return a;
+	}
+	boolean isPowerOfTwo (int x) 
+      { 
+            return x!=0 && ((x&(x-1)) == 0);     
+      }boolean isPowerOfTwo (long x) 
+      { 
+            return x!=0 && ((x&(x-1)) == 0);     
+      }public long max(long x,long y){
+            return (long)Math.max(x,y);
+      }
+      public int max(int x,int y){
+            return (int)Math.max(x,y);
+      }
+      public double max(double x,double y){
+            return Math.max(x,y);
+      }long sqrt(long x){
+            return (long)Math.sqrt(x);
+      }int sqrt(int x){
+            return (int)Math.sqrt(x);
+      }void input(int[] ar,int n){
+            for(int i=0;i<n;i++)ar[i]=ni();
+      }void input(long[] ar,int n){
+            for(int i=0;i<n;i++)ar[i]=nl();
+      }void fill(int[] ar,int k){
+            Arrays.fill(ar,k);
+      }void yes(){
+            pl(""YES"");
+      }void no(){
+            pl(""NO"");
+      }
+      long c2(long n) {
+    	  return (n*(n-1))/2;
+      }
+    long[] sieve(int n) 
+    {
+          long[] k=new long[n+1];
+          boolean[] pr=new boolean[n+1];
+          for(int i=1;i<=n;i++){
+                k[i]=i;
+                pr[i]=true;
+          }for(int i=2;i<=n;i++){
+                if(pr[i]){
+                      for(int j=i+i;j<=n;j+=i){
+                            pr[j]=false;
+                            if(k[j]==j){
+                                  k[j]=i;
+                            }
+                      }
+                }
+          }return k;
+    }
+    int strSmall(int[] arr, int target)  
+    {  
+        int start = 0, end = arr.length-1;  
+        int ans = -1;  
+        while (start <= end) {  
+            int mid = (start + end) / 2;   
+            if (arr[mid] >= target) {  
+                end = mid - 1;  
+            }   
+            else {  
+                ans = mid;  
+                start = mid + 1;  
+            }  
+        }  
+        return ans;  
+    } int strSmall(ArrayList<Integer> arr, int target)  
+    {  
+        int start = 0, end = arr.size()-1;  
+        int ans = -1;  
+        while (start <= end) {  
+            int mid = (start + end) / 2;   
+            if (arr.get(mid) > target) {  
+                start = mid + 1; 
+                ans=start;
+            }   
+            else {
+                end = mid - 1;  
+            }  
+        }  
+        return ans;  
+    }long mMultiplication(long a,long b) 
+    { 
+        long res = 0;    
+        a %= mod; 
+  
+        while (b > 0)  
+        {  
+            if ((b & 1) > 0)  
+            { 
+                res = (res + a) % mod; 
+            }  
+            a = (2 * a) % mod; 
+  
+            b >>= 1;  
+        } 
+        return res; 
+    }long nCr(int n, int r ,long p)
+    {
+ 
+          if (n<r) 
+              return 0;
+        if (r == 0)
+            return 1;
+            long[] fac = new long[n + 1];
+        fac[0] = 1;
+ 
+        for (int i = 1; i <= n; i++)
+            fac[i] = fac[i - 1] * i %p;
+        return (fac[n] * modInverse(fac[r], p)
+                % p * modInverse(fac[n - r], p)
+                % p)
+            % p;
+    }long power(long x, long y, long p)
+    {
+        long res = 1;
+        x = x % p;
+ 
+        while (y > 0) {
+            if (y % 2 == 1)
+                res = (res * x) % p;
+            y = y >> 1; 
+            x = (x * x) % p;
+        }
+ 
+        return res;
+    }long modInverse(long n, long p)
+    {
+        return power(n, p - 2, p);
+    }
+    
+    int[][] floydWarshall(int graph[][],int INF,int V)
+    {
+        int dist[][] = new int[V][V];
+        int i, j, k;
+        for (i = 0; i < V; i++)
+            for (j = 0; j < V; j++)
+                dist[i][j] = graph[i][j];
+        for (k = 0; k < V; k++)
+        {
+            for (i = 0; i < V; i++)
+            {
+                for (j = 0; j < V; j++)
+                {
+                    if (dist[i][k] + dist[k][j] < dist[i][j])
+                        dist[i][j] = dist[i][k] + dist[k][j];
+                }
+            }
+        }return dist;
+    }
+    class minque {
+		Deque<Long> q;
+		minque(){
+			q=new ArrayDeque<Long>();
+		}public void add(long p){
+			while(!q.isEmpty()&&q.peekLast()>p)q.pollLast();
+			q.addLast(p);
+		}public void remove(long p) {
+			if(!q.isEmpty()&&q.getFirst()==p)q.removeFirst();
+		}public long min() {
+			return q.getFirst();
+		}
+	}
+      int find(subset[] subsets, int i)
+      {
+          if (subsets[i].parent != i)
+              subsets[i].parent
+                  = find(subsets, subsets[i].parent);
+          return subsets[i].parent;
+      }void Union(subset[] subsets, int x, int y)
+      {
+          int xroot = find(subsets, x);
+          int yroot = find(subsets, y);
+   
+          if (subsets[xroot].rank < subsets[yroot].rank) {
+          	subsets[xroot].parent = yroot;
+          }
+          else if (subsets[yroot].rank < subsets[xroot].rank) {
+          	subsets[yroot].parent = xroot;
+          }
+          else {
+              subsets[xroot].parent = yroot;
+              subsets[yroot].rank++;
+          }
+      }class subset
+      {
+          int parent;
+          int rank;
+      }
+	 
+}","import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.StringTokenizer;
+
+public class D {
+    static class Pair{
+        int val;
+        char c;
+        Pair(int a,char b){
+            this.val=a;
+            this.c=b;
+        }
+    }
+    public static void main(String[] args)
+    {
+        FastScanner sc=new FastScanner();
+        int t=sc.nextInt();
+        PrintWriter pw=new PrintWriter(System.out);
+        while(t-->0) {
+            int n=sc.nextInt();
+            int[] a=sc.readArray(n);
+            char[] s=sc.next().toCharArray();
+            boolean ok=true;
+            ArrayList<Integer> blues=new ArrayList<>();
+            ArrayList<Integer> reds=new ArrayList<>();
+            for(int i=0;i<n;i++){
+                if(s[i]=='B'){
+                    blues.add(a[i]);
+                } else {
+                    reds.add(a[i]);
+                }
+            }
+            Collections.sort(blues);
+            Collections.sort(reds);
+            for(int i=0;i<blues.size();i++){
+                if(blues.get(i)<(i+1)){
+                    ok=false;
+                    break;
+                }
+            }
+            int start=blues.size()+1;
+            for(int i=0;i<reds.size();i++){
+                if(reds.get(i)>(start++)){
+                    ok=false;
+                    break;
+                }
+            }
+            if(ok){
+               pw.println(""YES"");
+            } else {
+                pw.println(""NO"");
+            }
+        }
+        pw.flush();
+    }
+
+    static class FastScanner {
+        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st=new StringTokenizer("""");
+        String next() {
+            while (!st.hasMoreTokens())
+                try {
+                    st=new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+        int[] readArray(int n) {
+            int[] a=new int[n];
+            for (int i=0; i<n; i++) a[i]=nextInt();
+            return a;
+        }
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+    }
+}
+",0
+1dab88fb,f59d9b6e,"import java.util.*;
+
+public class Main
+{
+    static class Edge{
+        public int node;
+        public int index;
+        public Edge(int n, int i){
+            node=n;
+            index=i;
+        }
+    }
+    static Scanner sc=new Scanner(System.in);
+	public static void main(String[] args) {
+	    
+	    int test=sc.nextInt();
+	    while(test-->0){
+	        
+	        solve();
+	    }
+	}
+	
+	static void solve(){
+	    int n=sc.nextInt();
+	        ArrayList<ArrayList<Edge>> graph= new ArrayList<ArrayList<Edge>>();
+	        for(int i=0;i<n;i++){
+	            graph.add(new ArrayList<>());
+	        }
+	        for (int i = 0; i < n - 1; i++) {
+	            int u = sc.nextInt();
+	            int v = sc.nextInt();
+	            u--; v--;
+	            
+	            graph.get(u).add(new Edge(v, i));
+	            graph.get(v).add(new Edge(u, i));
+            }
+            
+            int start = 0;
+            for (int i = 0; i < n; i++) {
+                if (graph.get(i).size() > 2) {
+                    System.out.println(""-1"");
+                    return;
+                } else if (graph.get(i).size() == 1) {
+                    start = i;
+                }
+            }
+            int[] weight = new int[n - 1];
+            
+            int prevNode = -1;
+            int curNode = start;
+            int curWeight = 2;
+            
+            while (true) {
+                ArrayList<Edge> edges = graph.get(curNode);
+                Edge next = edges.get(0);
+                
+                if (next.node == prevNode) {
+                    if (edges.size() == 1) {
+                        break;
+                    } else {
+                        next = edges.get(1);
+                    }
+                }
+                weight[next.index] = curWeight;
+                
+                prevNode = curNode;
+                curNode = next.node;
+                curWeight = 5 - curWeight;
+            }
+            for (int i = 0; i < n - 1; i++) {
+                System.out.print(weight[i]);
+                System.out.print("" "");
+            }
+            System.out.println();
+	}
+}
+","/* package codechef; // don't place package name! */
+
+import java.util.*;
+import java.lang.*;
+import java.io.*;
+
+/* Name of the class has to be ""Main"" only if the class is public. */
+public class Codechef{
+    public static class Edge{
+        int node;
+        int index;
+        Edge(int node, int index){
+            this.node = node;
+            this.index = index;
+        }
+    }
+    static Scanner scn = new Scanner(System.in);
+	public static void main (String[] args) throws java.lang.Exception{
+		int t = scn.nextInt();
+		while(t-->0){
+		    solve();
+		}
+	}
+	public static void solve(){
+	    int n = scn.nextInt();
+	    ArrayList<Edge>[]graph = new ArrayList[n];
+	    for(int i = 0; i < n; i++){
+	        graph[i] = new ArrayList<>();
+	    }
+	    for(int i = 0; i < n - 1; i++){
+	        int u = scn.nextInt() - 1;
+	        int v = scn.nextInt() - 1;
+	        graph[u].add(new Edge(v, i));
+	        graph[v].add(new Edge(u, i));
+	    }
+	    int start = 0;
+	    for(int i = 0; i < n; i++){
+	        if(graph[i].size() > 2){
+	            System.out.println(""-1"");
+	            return;
+	        }else if(graph[i].size() == 1){
+	            start = i;
+	        }
+	    }
+	    int[]weight = new int[n - 1];
+	    int prevNode = -1, curNode = start, curWeight = 2;
+	    while(true){
+	        ArrayList<Edge>edges = graph[curNode];
+	        Edge next = edges.get(0);
+	        if(next.node == prevNode){
+	            if(edges.size() == 1){
+	                break;
+	            }else{
+	                next = edges.get(1);
+	            }
+	        }
+	        weight[next.index] = curWeight;
+	        prevNode = curNode;
+	        curNode = next.node;
+	        curWeight = 5 - curWeight;
+	    }
+	    for(int i = 0; i < n - 1; i++){
+	        System.out.print(weight[i]);
+	        System.out.print("" "");
+	    }
+	    System.out.println();
+	}
+}
+",1
+83b44c9c,8d9871a9,"import java.util.Scanner;
+
+public class MinimumGridPath {
+    public static void main(String[] args) {
+        Scanner scanner = new Scanner(System.in);
+        int test = scanner.nextInt();
+
+        StringBuilder sb = new StringBuilder();
+        for (int t = 0; t < test; t++) {
+            int n = scanner.nextInt();
+            long[] arr = new long[n];
+            for (int i = 0; i < n; i++) {
+                arr[i] = scanner.nextLong();
+            }
+
+            long minx = arr[0];
+            long miny = arr[1];
+
+            long min = minx * n + miny * n;
+            long sumx = arr[0];
+            long sumy = arr[1];
+
+            for(int i=2; i<n; i++) {
+                int xc;
+                int yc;
+                if(i%2 == 0) {
+                    xc = i/2 + 1;
+                    yc = i/2;
+                    sumx += arr[i];
+                    minx = Math.min(minx, arr[i]);
+                } else {
+                    xc = i/2 + 1;
+                    yc = i/2 + 1;
+                    sumy += arr[i];
+                    miny = Math.min(miny, arr[i]);
+                }
+                min = Math.min(min, sumx + (n-xc) * minx + sumy + (n-yc) * miny);
+            }
+
+
+            sb.append(min).append(System.lineSeparator());
+        }
+        System.out.println(sb);
+
+    }
+}
+
+/*
+// yehara
+import java.io.PrintWriter;
+import java.util.*;
+
+public class C {
+
+    static Scanner sc;
+    static PrintWriter out;
+
+    public static void main(String[] args) throws Exception {
+        sc = new Scanner(System.in);
+        out = new PrintWriter(System.out);
+        int t = sc.nextInt();
+        for(int i=0; i<t; i++) {
+            solve();
+        }
+        out.flush();
+    }
+
+    static void solve() {
+        int n = sc.nextInt();
+        int[] c = new int[n];
+        for(int i=0; i<n; i++) {
+            c[i] = Integer.parseInt(sc.next());
+        }
+        long minx = c[0];
+        long miny = c[1];
+
+        long min = minx * n + miny * n;
+        long sumx = c[0];
+        long sumy = c[1];
+
+        for(int i=2; i<n; i++) {
+            int xc;
+            int yc;
+            if(i%2 == 0) {
+                xc = i/2 + 1;
+                yc = i/2;
+                sumx += c[i];
+                minx = Math.min(minx, c[i]);
+            } else {
+                xc = i/2 + 1;
+                yc = i/2 + 1;
+                sumy += c[i];
+                miny = Math.min(miny, c[i]);
+            }
+            min = Math.min(min, sumx + (n-xc) * minx + sumy + (n-yc) * miny);
+        }
+
+        out.println(min);
+
+    }
+
+}
+
+ */
+","import java.util.*;
+
+public class Main {
+	static Scanner scan = new Scanner(System.in);
+
+	static int[] readArray(int[] x) {
+		for(int i=0; i<x.length; ++i) x[i] = scan.nextInt();
+		return x;
+	}
+
+	static long[] readArray(long[] x) {
+		for(int i=0; i<x.length; ++i) x[i] = scan.nextLong();
+		return x;
+	}
+
+
+	public static void go() {
+	}
+
+	public static void main(String[] args) {
+		int t = scan.nextInt();
+		for(int it=0; it<t; ++it) {
+			int n = scan.nextInt();
+			long[] aa = readArray(new long[n]);
+
+			long minEven = aa[0];
+			long minOdd = aa[1];
+			long sum = aa[0]+aa[1];
+			long best = n*minEven + n*minOdd;
+			int numOdd = 1;
+			int numEven = 1;
+			for(int i=2; i<n; ++i) {
+				if(i%2 == 0) {
+					minEven = Math.min(aa[i], minEven);
+					numEven++;
+				}else {
+					minOdd = Math.min(aa[i], minOdd);
+					numOdd++;
+				}
+				sum += aa[i];
+				long score = sum;
+				score += minEven*(n-numEven);
+				score += minOdd*(n-numOdd);				
+				best = Math.min(best, score);
+			}
+			System.out.println(best);
+		}
+	}
+}
+",0
+14b0fb8e,6490bbe8,"import java.io.*;
+
+import java.util.*;
+ public class Solution {
+	 
+	static long res;
+	public static void main(String[] args) throws Exception
+    {
+		FastReader fr=new FastReader();
+        int n=fr.nextInt();
+        ArrayList<Integer> oc=new ArrayList<>();
+        ArrayList<Integer> em=new ArrayList<>();
+        res=Long.MAX_VALUE;
+        for(int i=0;i<n;i++) {
+        	int v=fr.nextInt();
+        	if(v==1)
+        		oc.add(i);
+        	else
+        		em.add(i);
+        }
+        Collections.sort(oc);
+        Collections.sort(em);
+        long dp[][]=new long[5001][5001];
+        for(int i=0;i<dp.length;i++) {
+        	for(int j=0;j<dp[i].length;j++) {
+        		dp[i][j]=-1;
+        	}
+        }
+        System.out.println(getMin(oc,em,0,0,dp));
+        
+        
+		
+    }
+	public static long getMin(ArrayList<Integer> oc,ArrayList<Integer> em,int idx,int j,long dp[][]) {
+	   if(idx==oc.size())
+		   return 0;
+		long available=em.size()-j;
+		long req=oc.size()-idx;
+		if(available<req)
+			return Integer.MAX_VALUE;
+		if(dp[idx][j]!=-1)
+			return dp[idx][j];
+		
+		long ch1=getMin(oc,em,idx,j+1,dp);
+		long ch2=getMin(oc,em,idx+1,j+1,dp)+Math.abs(em.get(j)-oc.get(idx));
+		
+		return dp[idx][j]=Math.min(ch1,ch2);
+		
+	}
+	
+		
+	
+	 
+public static String lcs(String a,String b) {
+		int dp[][]=new int[a.length()+1][b.length()+1];
+		for(int i=0;i<=a.length();i++)
+		{
+			for(int j=0;j<=b.length();j++)
+			{
+				if(i==0||j==0)
+					dp[i][j]=0;
+			}
+		}
+		
+		for(int i=1;i<=a.length();i++)
+		{
+			for(int j=1;j<=b.length();j++)
+			{
+				if(a.charAt(i-1)==b.charAt(j-1))
+					dp[i][j]=1+dp[i-1][j-1];
+				else
+					dp[i][j]=Math.max(dp[i-1][j],dp[i][j-1]);
+			}
+		}
+		
+		int i=a.length();
+		int j=b.length();
+		String lcs="""";
+		while(i>0&&j>0)
+		{
+			if(a.charAt(i-1)==b.charAt(j-1)) {
+				lcs=a.charAt(i-1)+lcs;
+				i--;
+				j--;
+			}
+			else 
+			{
+				if(dp[i-1][j]>dp[i][j-1])
+					i--;
+				else
+					j--;
+			}
+		}
+		
+		return lcs;
+            
+	}
+	
+	 
+	 
+	 
+	 public static long facto(long n) {
+		 if(n==1||n==0)
+			 return 1;
+		 return n*facto(n-1);
+	 }
+	 public static long gcd(long n1,long n2) {
+		 if (n2 == 0) {
+		        return n1;
+		    }
+		    return gcd(n2, n1 % n2);
+	}
+	 public static boolean isPali(String s) {
+		 int i=0;
+		 int j=s.length()-1;
+		 while(i<=j) {
+			 if(s.charAt(i)!=s.charAt(j))
+				 return false;
+			 i++;
+			 j--;
+		 }
+		 return true;
+	 }
+	 public static String reverse(String s) {
+		 String res="""";
+		 for(int i=0;i<s.length();i++) {
+			 res+=s.charAt(i);
+		 }
+		 return res;
+	 }
+	
+		
+	 
+	 public static int bsearch(long suf[],long val) {
+		 int i=0;
+		 int j=suf.length-1;
+		 while(i<=j) {
+			 int mid=(i+j)/2;
+			 if(suf[mid]==val)
+				 return mid;
+			 else if(suf[mid]<val)
+				 j=mid-1;
+			 else
+				 i=mid+1;
+		 }
+		 return -1;
+	 }
+	 
+	 
+	 
+	
+	 
+	 
+	public static int[] getFreq(String s) {
+		int a[]=new int[26];
+		for(int i=0;i<s.length();i++) {
+			a[s.charAt(i)-'a']++;
+		}
+		return a;
+		
+	}
+	 
+	 public static boolean isPrime(int n) {
+		 
+		 for(int i=2;(i*i)<=n;i++) {
+			 if(n%i==0)
+				 return false;
+		 }
+		 return true;
+	 }
+            	  
+             
+             
+    }
+class Pair{
+	long i;
+	long j;
+	
+	Pair(long num,long freq){
+		this.i=num;
+		
+		this.j=freq;
+	}
+	
+}
+
+	
+	 
+	
+	
+
+	 
+ 
+  
+
+class FastReader
+{
+    BufferedReader br;
+    StringTokenizer st;
+ 
+    public FastReader()
+    {
+        br = new BufferedReader(new
+                InputStreamReader(System.in));
+    }
+ 
+    String next()
+    {
+        while (st == null || !st.hasMoreElements())
+        {
+            try
+            {
+                st = new StringTokenizer(br.readLine());
+            }
+            catch (IOException e)
+            {
+                e.printStackTrace();
+            }
+        }
+        return st.nextToken();
+    }
+ 
+    int nextInt()
+    {
+        return Integer.parseInt(next());
+    }
+ 
+    long nextLong()
+    {
+        return Long.parseLong(next());
+    }
+ 
+    double nextDouble()
+    {
+        return Double.parseDouble(next());
+    }
+ 
+    String nextLine()
+    {
+        String str = """";
+        try
+        {
+            str = br.readLine();
+        }
+        catch (IOException e)
+        {
+            e.printStackTrace();
+        }
+        return str;
+    }
+}
+
+","import java.util.*;
+// import java.lang.*;
+import java.io.*;
+
+//           THIS TEMPLATE MADE BY AKSH BANSAL.
+
+public class Solution {
+    static class FastReader {
+        BufferedReader br;
+        StringTokenizer st;
+
+        public FastReader() {
+            br = new BufferedReader(new InputStreamReader(System.in));
+        }
+
+        String next() {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+
+        String nextLine() {
+            String str = """";
+            try {
+                str = br.readLine();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+        }
+    }
+    private static boolean[] isPrime;
+    private static void primes(){
+        int num = (int)1e6; // PRIMES FROM 1 TO NUM
+        isPrime = new boolean[num];
+     
+        for (int i = 2; i< isPrime.length; i++) {
+           isPrime[i] = true;
+        }
+        for (int i = 2; i< Math.sqrt(num); i++) {
+           if(isPrime[i] == true) {
+              for(int j = (i*i); j<num; j = j+i) {
+                 isPrime[j] = false;
+              }
+           }
+        }
+    }
+    private static long gcd(long a, long b){
+        if(b==0)return a;
+        return gcd(b,a%b);
+    }
+    private static long pow(long x,long y){
+        if(y==0)return 1;
+        long temp = pow(x, y/2);
+        if(y%2==1){
+            return x*temp*temp;
+        }
+        else{
+            return temp*temp;
+        }
+    }
+    // static ArrayList<Integer>[] adj;
+    // static void getAdj(int n,int q, FastReader sc){
+    //     adj = new ArrayList[n+1];
+    //     for(int i=1;i<=n;i++){
+    //         adj[i] = new ArrayList<>();
+    //     }
+    //     for(int i=0;i<q;i++){
+    //         int a = sc.nextInt();
+    //         int b = sc.nextInt();
+
+    //         adj[a].add(b);
+    //         adj[b].add(a);
+    //     }
+    // }
+    public static void main(String[] args) throws IOException {
+        FastReader sc = new FastReader();
+        PrintWriter out = new PrintWriter(System.out);
+        // primes();
+        // ________________________________
+
+        // int t = sc.nextInt();
+        // StringBuilder output = new StringBuilder();
+
+        // while (t-- > 0) {
+
+        //     output.append(solver()).append(""\n"");
+        // }
+
+        // out.println(output);
+        // _______________________________
+
+        int n = sc.nextInt();
+        int arr[] = new int[n];
+        for(int i=0;i<n;i++){
+            arr[i] = sc.nextInt();
+        }
+        out.println(solver(n, arr));
+        // ________________________________
+        out.flush();
+    }
+
+    public static long solver(int n, int[] arr) {
+        ArrayList<Integer> a = new ArrayList<>();
+        ArrayList<Integer> b = new ArrayList<>();
+        for(int i=0;i<n;i++){
+            if(arr[i] ==1){
+                a.add(i);
+            }
+            else{
+                b.add(i);
+            }
+        }
+        // System.out.println(""__""+ a);
+        // System.out.println(""__""+ b);
+        long inf = (long)1e10;
+        int aLen = a.size(), bLen = b.size();
+        long[][] dp = new long[bLen+1][aLen+1];
+        for(int i=0;i<bLen+1;i++)Arrays.fill(dp[i],inf);
+        // dp[0][0] = 0;
+        for(int i=0;i<=bLen;i++){
+            dp[i][0] = 0;
+        }
+        for(int i=1;i<=bLen;i++){
+            for(int j=1;j<=i && j<=aLen;j++){
+                int aa = a.get(j-1);
+                int bb = b.get(i-1);
+                // System.out.println((i-1)+"" ""+(j-1)+""__""+ aa+"" ""+bb);
+                dp[i][j] = Math.min(
+                    Math.abs(aa-bb)+dp[i-1][j-1],
+                    dp[i-1][j]
+                );
+                // System.out.println((i-1)+"" ""+(j-1)+""__""+ dp[i][j]);
+            }
+        }
+        // for(int i=0;i<=bLen;i++){
+        //     for(int j=0;j<=aLen;j++){
+        //         System.out.print(dp[i][j]+"" "");
+        //     }
+        //     System.out.println(""__"" );
+        // }
+        return dp[bLen][aLen]==inf?0:dp[bLen][aLen];
+    }
+}",0
+a368f345,e5d02e93,"import java.util.*;
+import java.io.*;
+
+public class codeforces {
+    static class Pair {
+        char type;
+        int L;
+        int R;
+
+        Pair(char type, int L, int R) {
+            this.type = type;
+            this.L = L;
+            this.R = R;
+        }
+    }
+
+    static FastReader fr;
+    static StringBuilder res;
+
+    static class FastReader {
+
+        BufferedReader br;
+        StringTokenizer st;
+        BufferedWriter bw;
+
+        public FastReader() {
+            br = new BufferedReader(new InputStreamReader(System.in));
+            bw = new BufferedWriter(new OutputStreamWriter(System.out));
+        }
+
+        String next() {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        char nextChar() {
+            return next().charAt(0);
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+
+        void write(String str) {
+
+            try {
+                bw.write(str);
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+        }
+
+        void close() {
+            try {
+                bw.close();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+        }
+
+        String nextLine() {
+            String str = """";
+            try {
+                str = br.readLine();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+        }
+    }
+
+    public static void main(String[] args) throws java.lang.Exception {
+        fr = new FastReader();
+        boolean fixed = false;
+        int t = !fixed ? fr.nextInt() : 1;
+        res = new StringBuilder();
+        while (t-- > 0) {
+            solve();
+        }
+        fr.write(res.toString());
+        fr.close();
+    }
+
+    static int M = 1000008;
+    static boolean[] primes = new boolean[M];
+    static int[] dp = new int[M];
+
+    public static void sieve() {
+        for (int i = 2; i * i <= M; i++) {
+            if (!primes[i]) {
+                for (int j = i * i; j < M; j += i) {
+                    primes[j] = true;
+                }
+            }
+        }
+
+        for (int i = 5; i < 1000001; i++) {
+            if (!primes[i] && !primes[i - 2])
+                dp[i] = dp[i - 1] + 1;
+            else
+                dp[i] = dp[i - 1];
+        }
+    }
+
+    public static void solve() {
+        int n = fr.nextInt();
+        String[] arr = new String[n];
+        for (int i = 0; i < n; i++) {
+            arr[i] = fr.nextLine();
+        }
+        char[] chars = { 'a', 'b', 'c', 'd', 'e' };
+        int ans = 0;
+        for (int i = 0; i < 5; i++) {
+            char ch = chars[i];
+            List<Integer> a = new ArrayList<>();
+            for (int j = 0; j < n; j++) {
+                String s = arr[j];
+                int c = 0;
+                for (int k = 0; k < s.length(); k++) {
+                    if (s.charAt(k) == ch)
+                        c++;
+                }
+                a.add(2 * c - s.length());
+            }
+            // System.out.println(a);
+            Collections.sort(a, Collections.reverseOrder());
+            int sum = 0, len = 0;
+            for (int k = 0; k < a.size(); k++) {
+                if (sum + a.get(k) <= 0) {
+                    break;
+                } else {
+                    len++;
+                    sum += a.get(k);
+                }
+            }
+            ans = Math.max(ans, len);
+        }
+        res.append(ans + ""\n"");
+    }
+
+    public static int[] readArray(int n) {
+        int[] arr = new int[n];
+        for (int i = 0; i < n; i++) {
+            arr[i] = fr.nextInt();
+        }
+        return arr;
+    }
+
+    public static long gcd(long a, long b) {
+        if (a == 0)
+            return b;
+        return gcd(b % a, a);
+    }
+
+    public static List<Integer> readArrayList(int n) {
+        List<Integer> arr = new ArrayList<>();
+        for (int i = 0; i < n; i++) {
+            arr.add(fr.nextInt());
+        }
+        return arr;
+    }
+}
+","import java.util.*;
+import java.io.*;
+
+public class C_1551 {
+	public static void main(String[] args) throws Exception {
+		Scanner sc = new Scanner(System.in);
+		PrintWriter pw = new PrintWriter(System.out);
+		
+		int t = sc.nextInt();
+		while(t-->0) {
+			int n = sc.nextInt();
+			int[] a = new int[n];
+			int[] b = new int[n];
+			int[] c = new int[n];
+			int[] d = new int[n];
+			int[] e = new int[n];
+			for(int i = 0; i < n; i++) {
+				String s = sc.next();
+				int[] cnt = new int[5];
+				for(int j = 0; j < s.length(); j++)
+					cnt[s.charAt(j) - 'a']++;
+				a[i] = 2 * cnt[0] - s.length();
+				b[i] = 2 * cnt[1] - s.length();
+				c[i] = 2 * cnt[2] - s.length();
+				d[i] = 2 * cnt[3] - s.length();
+				e[i] = 2 * cnt[4] - s.length();
+			}
+			
+			Arrays.sort(a);
+			Arrays.sort(b);
+			Arrays.sort(c);
+			Arrays.sort(d);
+			Arrays.sort(e);
+			
+			int max = 0;
+			int sum = 0;
+			for(int i = n - 1; i >= 0; i--) {
+				sum += a[i];
+				if(sum <= 0)
+					break;
+				max = n - i;
+			}
+			
+			sum = 0;
+			for(int i = n - 1; i >= 0; i--) {
+				sum += b[i];
+				if(sum <= 0)
+					break;
+				max = Math.max(max, n - i);	
+			}
+			
+			sum = 0;
+			for(int i = n - 1; i >= 0; i--) {
+				sum += c[i];
+				if(sum <= 0)
+					break;
+				max = Math.max(max, n - i);	
+			}
+			
+			sum = 0;
+			for(int i = n - 1; i >= 0; i--) {
+				sum += d[i];
+				if(sum <= 0)
+					break;
+				max = Math.max(max, n - i);	
+			}
+			
+			sum = 0;
+			for(int i = n - 1; i >= 0; i--) {
+				sum += e[i];
+				if(sum <= 0)
+					break;
+				max = Math.max(max, n - i);	
+			}
+			
+			pw.println(max);
+			
+		}
+		
+		pw.flush();
+	}
+
+	public static class Scanner {
+		StringTokenizer st;
+		BufferedReader br;
+
+		public Scanner(InputStream system) {
+			br = new BufferedReader(new InputStreamReader(system));
+		}
+
+		public Scanner(String file) throws Exception {
+			br = new BufferedReader(new FileReader(file));
+		}
+
+		public String next() throws IOException {
+			while (st == null || !st.hasMoreTokens())
+				st = new StringTokenizer(br.readLine());
+			return st.nextToken();
+		}
+
+		public String nextLine() throws IOException {
+			return br.readLine();
+		}
+
+		public int nextInt() throws IOException {
+			return Integer.parseInt(next());
+		}
+
+		public double nextDouble() throws IOException {
+			return Double.parseDouble(next());
+		}
+
+		public char nextChar() throws IOException {
+			return next().charAt(0);
+		}
+
+		public long nextLong() throws IOException {
+			return Long.parseLong(next());
+		}
+
+		public int[] nextIntArray(int n) throws IOException {
+			int[] array = new int[n];
+			for (int i = 0; i < n; i++)
+				array[i] = nextInt();
+			return array;
+		}
+
+		public Integer[] nextIntegerArray(int n) throws IOException {
+			Integer[] array = new Integer[n];
+			for (int i = 0; i < n; i++)
+				array[i] = new Integer(nextInt());
+			return array;
+		}
+
+		public long[] nextLongArray(int n) throws IOException {
+			long[] array = new long[n];
+			for (int i = 0; i < n; i++)
+				array[i] = nextLong();
+			return array;
+		}
+
+		public double[] nextDoubleArray(int n) throws IOException {
+			double[] array = new double[n];
+			for (int i = 0; i < n; i++)
+				array[i] = nextDouble();
+			return array;
+		}
+
+		public static int[] shuffle(int[] a) {
+			int n = a.length;
+			Random rand = new Random();
+			for (int i = 0; i < n; i++) {
+				int tmpIdx = rand.nextInt(n);
+				int tmp = a[i];
+				a[i] = a[tmpIdx];
+				a[tmpIdx] = tmp;
+			}
+			return a;
+		}
+
+		public boolean ready() throws IOException {
+			return br.ready();
+		}
+
+		public void waitForInput() throws InterruptedException {
+			Thread.sleep(3000);
+		}
+	}
+}
+",0
+d2a4c1fb,dcdaf666,"import java.util.*;
+
+public class CodeForcesRound {
+
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        int t = sc.nextInt();
+        for (int i = 0; i<t; i++)
+            System.out.println(solve(sc));
+        sc.close();
+    }
+
+    public static long solve(Scanner sc) {
+        int n = sc.nextInt();
+        long[] c = new long[n];
+        long[] ps = new long[n];
+
+        c[0] = sc.nextLong();
+        c[1] = sc.nextLong();
+        ps[0] = c[0];
+        ps[1] = c[1];
+
+        for (int i = 2; i<n; i++) {
+            c[i] = sc.nextLong();
+            ps[i] = ps[i-2] + c[i];
+        }
+
+        long res = Long.MAX_VALUE;
+        long[] mins = new long[n];
+        mins[0] = n*c[0];
+        mins[1] = n*c[1];
+        int minEven = 0;
+        int minOdd = 1;
+
+        for (int i = 2; i<n; i++) {
+            if (i%2==0) {
+                if (c[i]<c[minEven])
+                    minEven = i;
+
+                mins[i] = ps[minEven]-c[minEven] + ps[i]-ps[minEven] + c[minEven]*(n-i/2);
+            } else {
+                if (c[i]<c[minOdd])
+                    minOdd = i;
+
+                mins[i] = ps[minOdd]-c[minOdd] + ps[i]-ps[minOdd] + c[minOdd]*(n-i/2);
+            }
+        }
+
+        for (int i = 1; i<n; i++) {
+            res = Math.min(res, mins[i]+mins[i-1]);
+        }
+
+        return res;
+    }
+
+    public static long min(long a, long b, long c) {
+        long t = Math.min(a, b);
+        return Math.min(t, c);
+    }
+}
+","import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.PrintStream;
+import java.util.StringTokenizer;
+
+public class Solution {
+
+    //
+
+    public static void main(String[] args) {
+        PrintStream out = System.out;
+        FastScanner fs = new FastScanner();
+
+        int T = fs.nextInt();
+
+
+        while (T-- > 0) {
+
+            int n = fs.nextInt();
+            long[] arr = new long[n];
+
+            for (int i = 0; i < n; i++) {
+                arr[i] = fs.nextLong();
+            }
+            long[] ps = new long[n];
+            ps[0] = arr[0];
+            for (int i = 1; i < n; i++) {
+                ps[i] = ps[i - 1] + arr[i];
+            }
+
+            long min = arr[0] * n + arr[1] * n;
+
+            int even = 0;
+            int odd = 1;
+
+            for (int i = 2; i < n; i++) {
+
+                if (i % 2 == 0) {
+                    if (arr[i] < arr[even]) {
+                        even = i;
+                    }
+                } else {
+                    if (arr[i] < arr[odd]) {
+                        odd = i;
+                    }
+                }
+
+                int tmp = i + 1;
+                int oddCount = tmp / 2;
+                int evenCount = (tmp + 1) / 2;
+
+
+                long local = ps[i];
+                local += (n - oddCount) * arr[odd];
+                local += (n - evenCount) * arr[even];
+
+                min = Math.min(min, local);
+            }
+            out.println(min);
+        }
+    }
+
+    // if these strings are both balanced then as one or zero goes out of the window one or zero must come in
+    //
+
+    static class FastScanner {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st = new StringTokenizer("""");
+
+        public String next() {
+            while (!st.hasMoreElements())
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            return st.nextToken();
+        }
+
+        int[] readArray(int n) {
+            int[] a = new int[n];
+            for (int i = 0; i < n; i++) a[i] = nextInt();
+            return a;
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+    }
+
+
+}
+",0
+25597bcb,5fcbdd19,"import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.StringTokenizer;
+import java.util.TreeSet;
+
+public class PhoenixAndTowers { // Template for CF
+    public static class ListComparator implements Comparator<List<Integer>> {
+
+        @Override
+        public int compare(List<Integer> l1, List<Integer> l2) {
+            for (int i = 0; i < l1.size(); ++i) {
+                if (l1.get(i).compareTo(l2.get(i)) != 0) {
+                    return l1.get(i).compareTo(l2.get(i));
+                }
+            }
+            return 0;
+        }
+    }
+
+    public static class Pair {
+        int first;
+        int second;
+
+        public Pair(int first, int second) {
+            this.first = first;
+            this.second = second;
+        }
+
+        public int getFirst() {
+            return first;
+        }
+
+        public int getSecond() {
+            return second;
+        }
+
+        public void setFirst(int a) {
+            first = a;
+        }
+
+        @Override
+        public String toString() {
+            return first + "" "" + second;
+        }
+    }
+
+    public static void main(String[] args) throws IOException {
+        // Check for int overflow!!!!
+        // Should you use a long to store the sum or smthn?
+        BufferedReader f = new BufferedReader(new InputStreamReader(System.in));
+        PrintWriter out = new PrintWriter(System.out);
+
+        int T = Integer.parseInt(f.readLine());
+        for (int i = 0; i < T; i++) {
+            StringTokenizer st = new StringTokenizer(f.readLine());
+            int n = Integer.parseInt(st.nextToken());
+            int m = Integer.parseInt(st.nextToken());
+            int x = Integer.parseInt(st.nextToken());
+            st = new StringTokenizer(f.readLine());
+            List<Integer> list = new ArrayList<>();
+            for (int j = 0; j < n; j++) {
+                int a = Integer.parseInt(st.nextToken());
+                list.add(a);
+            }
+            ArrayList<Integer> copy = new ArrayList<>(list);
+            Collections.sort(list);
+            TreeSet<List<Integer>> set = new TreeSet<>(new ListComparator());
+            for (int j = 1; j <= m; j++) {
+                List<Integer> temp = new ArrayList<>();
+                temp.add(0);
+                temp.add(j);
+
+                set.add(temp);
+                // System.out.println(temp);
+            }
+            // System.out.println(set);
+            Map<Integer, LinkedList<Integer>> map = new HashMap<>();
+            for (int j = n - 1; j >= 0; j--) {
+                if (map.containsKey(list.get(j))) {
+                    map.get(list.get(j)).addLast(set.first().get(1));
+                } else {
+                    map.put(list.get(j), new LinkedList<>());
+                    map.get(list.get(j)).addLast(set.first().get(1));
+                }
+                List<Integer> temp = new ArrayList<>();
+                temp.add(set.first().get(0) + list.get(j));
+                temp.add(set.pollFirst().get(1));
+                set.add(temp);
+            }
+            // System.out.println(set);
+
+            if (set.last().get(0) - set.first().get(0) > x) {
+                out.println(""NO"");
+            } else {
+                out.println(""YES"");
+                for (int j = 0; j < n; j++) {
+                    out.print(map.get(copy.get(j)).pollFirst() + "" "");
+                }
+                out.println();
+            }
+        }
+        out.close();
+    }
+
+}","import java.io.*;
+import java.util.*;
+
+public class C {
+    public static void main(String[] args) {
+        Scanner in = new Scanner(System.in);
+        PrintWriter pw = new PrintWriter(System.out);
+        int t = in.nextInt();
+        for (int t1 = 0; t1 < t; t1++) {
+            int n = in.nextInt(), m = in.nextInt(), x = in.nextInt();
+            ArrayList<Pair> list = new ArrayList<>();
+            for (int i = 1; i <= n; i++) list.add(new Pair(in.nextInt(), i));
+            pw.println(solve(list, n, m, x));
+        }
+
+        pw.close();
+    }
+
+    static StringBuilder solve(ArrayList<Pair> arr, int n, int m, int x) {
+        Stack<Pair> stack = new Stack<>();
+        HashMap<Integer, Integer> map = new HashMap<>();
+        PriorityQueue<Pair> pq = new PriorityQueue<>();
+        Collections.sort(arr);
+        for (int i = m; i < n; i++) stack.push(arr.get(i));
+        for (int i = 0, j = 1; i < m; i++, j++) {
+            Pair p = arr.get(i);
+            pq.add(new Pair(p.f, j));
+            map.put(p.s, j);
+        }
+        while (!stack.isEmpty()) {
+            Pair val = stack.pop();
+            Pair p = pq.remove();
+            map.put(val.s, p.s);
+            pq.add(new Pair(p.f + val.f, p.s));
+        }
+      //  debug(pq);
+        int min = pq.remove().f;
+        while (!pq.isEmpty()) {
+            int val = pq.remove().f;
+            if ((val - min) > x) return new StringBuilder().append(""NO"");
+        }
+        StringBuilder sb = new StringBuilder();
+        sb.append(""YES\n"");
+        for (int i = 1; i <= n; i++) {
+            sb.append(map.get(i) + "" "");
+        }
+        return sb;
+    }
+
+    static class Pair implements Comparable<Pair> {
+        int f, s;
+
+        Pair(int f, int s) {
+            this.f = f;
+            this.s = s;
+        }
+
+        @Override
+        public int compareTo(Pair p) {
+            return Integer.compare(this.f, p.f);
+        }
+
+        @Override
+        public String toString() {
+            return f + "" "" + s;
+        }
+    }
+
+    static void debug(Object... obj) {
+        System.err.println(Arrays.deepToString(obj));
+    }
+}",0
+643e22cc,bd7281dc,"import java.io.*;
+import java.util.*;
+
+public class C {
+
+	public static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+	public static PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
+
+	public static void main(String[] args) throws IOException {
+		readInput();
+		out.close();
+	}
+	
+	static class Tower implements Comparable<Tower>{
+		int i, w;
+		public Tower(int a, int b) {
+			i=a;
+			w=b;
+		}
+		public int compareTo(Tower o) {return w - o.w;}
+	}
+	
+	static class Block implements Comparable<Block>{
+		int i, w;
+		public Block(int a, int b) {
+			i=a;
+			w=b;
+		}
+		public int compareTo(Block o) {return o.w-w;}
+	}
+
+	static PriorityQueue<Tower> towers;
+	static PriorityQueue<Block> blocks;
+	static int[] par;
+	
+	static void solve() {
+		while (!blocks.isEmpty()) {
+			Block h = blocks.poll();
+			Tower t = towers.poll();
+			par[h.i] = t.i;
+			t.w += h.w;
+			towers.add(t);
+		}
+		List<Tower> res = new ArrayList<Tower>(towers);
+		Collections.sort(res);
+		boolean works = true;
+		for (int i =1 ; i < m; i++) {
+			if (Math.abs(res.get(i-1).w - res.get(i).w) > x) works = false;
+		}
+		if (works) {
+			out.println(""YES"");
+			for (int i = 0; i < n; i++) out.print(par[i] + 1 + "" "");
+			out.println();
+		}
+		else out.println(""NO"");
+	}
+	static int n,m,x;
+	public static void readInput() throws IOException {
+		// br = new BufferedReader(new FileReader("".in""));
+		// out = new PrintWriter(new FileWriter("".out""));
+		int t = Integer.parseInt(br.readLine());
+		while (t-->0) {
+			StringTokenizer st=  new StringTokenizer(br.readLine());
+			n = Integer.parseInt(st.nextToken());
+			m = Integer.parseInt(st.nextToken());
+			x = Integer.parseInt(st.nextToken());
+			towers = new PriorityQueue<Tower>();
+			blocks = new PriorityQueue<Block>();
+			par = new int[n];
+			st = new StringTokenizer(br.readLine());
+			for (int i= 0 ; i < n; i++) {
+				blocks.add(new Block(i,Integer.parseInt(st.nextToken())));
+			}
+			for (int i =0 ; i < m; i++) {
+				towers.add(new Tower(i, 0));
+			}
+			solve();
+		}
+	}
+}
+","/*
+bts songs to dance to:
+I need U
+Run
+ON
+Filter
+I'm fine
+ */
+import static java.lang.Math.max;
+import static java.lang.Math.min;
+import static java.lang.Math.abs;
+import static java.lang.System.out;
+import java.util.*;
+import java.io.*;
+import java.math.*;
+
+public class x1515C
+{
+    public static void main(String hi[]) throws Exception
+    {
+        BufferedReader infile = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st = new StringTokenizer(infile.readLine());
+        int T = Integer.parseInt(st.nextToken());
+        StringBuilder sb = new StringBuilder();
+        while(T-->0)
+        {
+            st = new StringTokenizer(infile.readLine());
+            int N = Integer.parseInt(st.nextToken());
+            int M = Integer.parseInt(st.nextToken());
+            int X = Integer.parseInt(st.nextToken());
+            int[] arr = readArr(N, infile, st);
+            ArrayList<Unit> ls = new ArrayList<Unit>();
+            for(int i=0; i < N; i++)
+                ls.add(new Unit(arr[i], i));
+            Collections.sort(ls);
+            int[] res = new int[N];
+            PriorityQueue<Unit> pq = new PriorityQueue<Unit>(Comparator.reverseOrder());
+            for(int i=1; i <= M; i++)
+                pq.add(new Unit(0, i));
+            for(Unit add: ls)
+            {
+                Unit tower = pq.poll();
+                tower.height += add.height;
+                res[add.id] = tower.id;
+                pq.add(tower);
+            }
+            int min = pq.poll().height;
+            int max = min;
+            while(pq.size() > 0)
+                max = max(max, pq.poll().height);
+            if(max-min > X)
+                sb.append(""NO\n"");
+            else
+            {
+                sb.append(""YES\n"");
+                for(int x: res)
+                    sb.append(x+"" "");
+                sb.append(""\n"");
+            }
+        }
+        System.out.print(sb);
+    }
+    public static int[] readArr(int N, BufferedReader infile, StringTokenizer st) throws Exception
+    {
+        int[] arr = new int[N];
+        st = new StringTokenizer(infile.readLine());
+        for(int i=0; i < N; i++)
+            arr[i] = Integer.parseInt(st.nextToken());
+        return arr;
+    }
+}
+class Unit implements Comparable<Unit>
+{
+    public int id;
+    public int height;
+
+    public Unit(int h, int i)
+    {
+        height = h;
+        id = i;
+    }
+    public int compareTo(Unit oth)
+    {
+        return oth.height-height;
+    }
+}",0
+63bfa731,7974ffba,"
+import java.util.*;
+import java.io.*;
+
+public class D {
+    static ArrayList<Integer> adj[] = new ArrayList[(int)1e5+7];
+    static int diameter = 0;
+    static int[] depth = new int[(int)1e5 + 7];
+    public static void main(String[] args) {
+        FastReader in = new FastReader();
+        int t = in.nextInt();
+        while(t-- > 0){
+            int n = in.nextInt();
+            int a = in.nextInt(), b = in.nextInt(), da = in.nextInt(), db = in.nextInt();
+            for(int i = 1; i <= n; i++){
+                adj[i] = new ArrayList<>();
+            }
+            for(int i = 1; i <=n; i++){
+                adj[i].clear();
+            }
+            for(int i = 0; i < n- 1; i++){
+                int u = in.nextInt();
+                int v = in.nextInt();
+                adj[u].add(v);
+                adj[v].add(u);
+            }
+            diameter = 0;
+            depth[a] = 0;
+            dfs(a, -1);
+            System.out.println(2 * da >= Math.min(diameter, db) || depth[b] <= da ? ""Alice"" : ""Bob"");
+        }
+    }
+    static int dfs(int node, int parent){
+        int len = 0;
+        for(int x : adj[node]){
+            if(x != parent){
+                depth[x] = depth[node] + 1;
+                int cur = 1 + dfs(x, node);
+                diameter = Math.max(diameter, cur + len);
+                len = Math.max(len, cur);
+//                System.out.print(""x "" + x + "" node "" + node + "" par "" + parent);
+//                System.out.println("" cur "" + cur + "" len "" + len + "" diam "" + diameter);
+            }
+        }
+        return len;
+    }
+    static long getDigitSum(long n)
+    {
+        long sum = 0;
+
+        while (n > 0)
+        {
+            sum = sum + n % 10;
+            n = n/10;
+        }
+
+        return sum;
+    }
+
+    static class FastReader
+    {
+        BufferedReader br;
+        StringTokenizer st;
+
+        public FastReader()
+        {
+            br = new BufferedReader(new
+                    InputStreamReader(System.in));
+        }
+
+        String next()
+        {
+            while (st == null || !st.hasMoreElements())
+            {
+                try
+                {
+                    st = new StringTokenizer(br.readLine());
+                }
+                catch (IOException e)
+                {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt()
+        {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong()
+        {
+            return Long.parseLong(next());
+        }
+
+        double nextDouble()
+        {
+            return Double.parseDouble(next());
+        }
+
+        String nextLine()
+        {
+            String str = """";
+            try
+            {
+                str = br.readLine();
+            }
+            catch (IOException e)
+            {
+                e.printStackTrace();
+            }
+            return str;
+        }
+        int[] readArray(int n){
+            int[] a = new int[n];
+            for(int i = 0; i < n; i++){
+                a[i] = nextInt();
+            }
+            return a;
+        }
+    }
+}
+","import java.util.*;
+import java.io.*;
+import java.math.*;
+public class Euler {
+	
+	static int N = (int)1e5 + 5;
+	static int n, a, b, da, db;
+	static int[] depth = new int[N];
+	static ArrayList<Integer>[] adj = new ArrayList[N];
+	static int diam;
+	
+	public static int dfs(int x, int p) {
+		
+		int len = 0;
+		for (int y : adj[x]) {
+			if (y != p) {
+				depth[y] = depth[x] + 1;
+				int cur = 1 + dfs(y, x);
+				diam = Math.max(diam, cur + len);
+				len = Math.max(len, cur);
+			}
+		}
+		return len;
+		
+	}
+	
+    public static void main(String[] args){
+
+        FastReader in = new FastReader();
+        PrintWriter o = new PrintWriter(System.out);
+        
+        int t = in.nextInt();
+        
+        while(t-- > 0) {
+			n = in.nextInt();
+			a = in.nextInt();
+			b = in.nextInt();
+			da = in.nextInt();
+			db = in.nextInt();
+			for (int i = 1; i <= n; i++) {
+				adj[i] = new ArrayList<>();
+			}
+			for (int i = 0; i < n - 1; i++) {
+				int u = in.nextInt();
+				int v = in.nextInt();
+				adj[u].add(v);
+				adj[v].add(u);
+			}
+			diam = 0;
+			depth[a] = 0;
+			dfs(a, -1);
+			
+			boolean works = true;
+			
+			if (depth[b] <= da) {
+				o.println(""Alice"");
+				continue;
+			}
+			
+			if (2 * da >= diam) {
+				o.println(""Alice"");
+				continue;
+			}
+			
+			if (db > 2 * da) {
+				o.println(""Bob"");
+				continue;
+			}
+			
+			if (db <= 2 * da) {
+				o.println(""Alice"");
+			}
+			
+			
+		}
+        
+        
+        o.close();
+        o.flush();
+        return;
+
+
+    }
+    
+    
+    static class FastReader {
+        BufferedReader br;
+        StringTokenizer st;
+
+        public FastReader() {
+            br = new BufferedReader(new InputStreamReader(System.in));
+        }
+
+        String next() {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+
+        String nextLine() {
+            String str = """";
+            try {
+                str = br.readLine();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+        }
+    }
+
+
+}
+",1
+04df7bb8,85125ecb,"										import java.math.BigInteger;
+										import java.sql.Array;
+									    import java.util.ArrayList;
+										import java.util.Arrays;
+										import java.util.Collection;
+										import java.util.Collections;
+										import java.util.Comparator;
+										import java.util.Deque;
+										import java.util.HashMap;
+										import java.util.HashSet;
+										import java.util.InputMismatchException;
+										import java.util.LinkedList;
+										import java.util.PriorityQueue;
+										import java.util.Queue;
+										import java.util.Scanner;
+										import java.util.Set;
+										import java.util.Stack;
+										import java.io.BufferedReader;
+										import java.io.IOException;
+										import java.io.InputStream;
+										import java.io.InputStreamReader;
+										import java.util.Scanner;
+										import java.util.StringTokenizer;
+										import java.util.TreeMap;
+										import java.util.TreeSet;
+										
+											
+											
+											
+											
+											
+											public class Main {
+							
+												
+												static HashMap<Integer,Boolean>map;
+												
+											static long dp[][];
+											static 	boolean flag;
+										static	HashSet<Long>hs;
+											static long mod=(long)(1e9+7);
+												public static void main(String[] args) {
+												StringBuilder ans=new StringBuilder();
+												FastReader sc=new FastReader();
+													
+												
+												int t=sc.nextInt();
+												
+												
+												while(t-->0) {
+													
+													int n=sc.nextInt();
+													
+													
+													//int n=sb.length();
+													
+													
+													
+													int k=sc.nextInt();
+													
+													
+													long L[]=new long[n];
+													long R[]=new long[n];
+													int a[]=new int[k];
+													int temp[]=new int[k];
+													
+													for(int i=0;i<k;i++)
+														a[i]=sc.nextInt();
+													
+													for(int i=0;i<k;i++)
+														temp[i]=sc.nextInt();
+													
+													int c[]=new int [n];
+													Arrays.fill(c, Integer.MAX_VALUE);
+													for(int i=0;i<k;i++)
+														c[a[i]-1]=temp[i];
+												
+													long p=Integer.MAX_VALUE;
+													
+													for(int i=0;i<n;i++)
+													{
+														p=Math.min(p+1, c[i]);
+														
+														L[i]=p;
+														
+														
+													}
+													p=Integer.MAX_VALUE;
+													for(int i=n-1;i>=0;i--)
+													{
+														p=Math.min(p+1, c[i]);
+														
+														R[i]=p;
+														
+														
+													}
+													
+													for(int i=0;i<n;i++)
+													{
+														ans.append(Math.min(L[i], R[i])+"" "");
+													}
+											ans.append(""\n"");
+													
+												}
+												System.out.println(ans);
+												
+												}
+													
+											static class Sparse{
+												int log[];
+												long sparse[][];
+												Sparse(int n){
+													
+												log=new int [n+1];
+												
+												
+												for(int i=1;i<n+1;i++)
+													
+												{
+													log[i]=log[i/2]+1;
+												}
+												sparse=new long[n][18];
+												
+												
+												
+												}
+												
+												
+			
+												
+												
+												
+												
+											}
+													
+
+
+												
+												
+							
+												
+												
+												
+												
+												
+												
+												
+												
+											static	long solve(String X,String Y,int n,int m,int M){
+												    
+													if(m==0&&n==0)return 0;
+													
+													//	if(m==1&&X.charAt(n-1)!='u')return Integer.MIN_VALUE;
+													if(n==0||m==0)return Integer.MIN_VALUE;
+											        
+											        if(dp[n][m]!=-1)return dp[n][m]; 
+												    
+												    
+												    
+												    if(Y.charAt(m-1)==X.charAt(n-1))
+												    {
+												 //   else if(n==1)return Integer.MAX_VALUE;
+												    	return dp[n][m]=1+ Math.max(solve (X,Y,n-1,m,M),solve (X,Y,n-1,m-1,M));
+												    }
+												    else{
+												        
+												        return dp[n][m]= solve(X,Y,n-1,m,M);
+												        
+												    }
+												}
+												
+												static long solve(long [][]g,int n,int m,boolean visited [][]) {
+													
+													if(n==0||m==0)return 0;
+													
+													visited[n][m]=true;
+													long ans=g[n-1][m-1]+Math.max(solve(g, n, m-1, visited),solve(g, n-1, m, visited));
+													
+													
+													visited[n][m]=false;
+													
+													return ans;
+													
+													
+													
+												}
+												
+												
+												
+												
+												static boolean isP(long x,long n,long m) {
+													
+													return (x^n)<=m;
+													
+												}
+												
+												
+												
+												
+												
+												static class pair{
+													int n;int i;
+													
+													pair(int n,int i){
+														this.n=n;
+														this.i=i;
+													}
+												}
+													
+													
+												
+												
+												
+												
+												
+												static long	 solve(char g[][],int n,int m) {
+													if(n==0||m==0)return 0;
+													if(n==1&&m==1)return 1;
+													if(g[n-1][m-1]=='#')return 0;
+													
+													if(dp[n][m]!=-1)return dp[n][m];
+													
+													return dp[n][m]= (solve(g, n-1, m)%mod+solve(g, n, m-1)%mod)%mod;
+														
+													
+												}
+												
+												
+												
+												
+												
+												
+												
+												
+												
+									static	int  solve	(int v,ArrayList<ArrayList<Integer>>adj,int d[],boolean visited[]) {
+											
+											
+											visited[v]=true;
+											for(int u:adj.get(v)) {
+												
+												if(!visited[u])
+												{
+												solve(u, adj, d, visited);
+												
+												}
+												d[v]=Math.max(1+d[u], d[v]);
+											}
+											
+											
+											return d[v];
+											
+											
+										}
+												
+												
+											
+												
+										static class colors{
+											
+											int c;int n;
+											public colors(int c,int n) {
+												// TODO Auto-generated constructor stub
+												this.c=c;
+												this.n=n;
+											}
+											
+										}
+												
+												
+												
+												
+												static int CeilIndex(long A[], int l, int r, long key)
+											    {
+											        while (r - l > 1) {
+											            int m = l + (r - l) / 2;
+											            if (A[m] >= key)
+											                r = m;
+											            else
+											                l = m;
+											        }
+											 
+											        return r;
+											    }
+											 
+												static int CeilIndexd(long A[], int l, int r, long key)
+											    {
+											        while (r - l > 1) {
+											            int m = l + (r - l) / 2;
+											            if (-1*A[m] >= key)
+											                r = m;
+											            else
+											                l = m;
+											        }
+											 
+											        return r;
+											    }
+											 
+												
+												
+												
+											
+												
+											static void solve(ArrayList<Long>A,long bd) {
+											
+												if(bd>(long)1e9)return;
+											//	if(hs.contains(bd))return;
+												//A.add(bd);
+												hs.add(bd);
+												A.add(bd*10);
+												A.add(bd*10+1);
+											//	hs.add(bd*10);
+												//hs.add(bd*10+1);
+											
+												solve(A,bd*10);
+												solve(A,bd*10+1);
+												
+												
+											}
+												
+												
+												
+												
+												
+												 static boolean isPrime(int n)
+												    {
+												        // Corner cases
+												        if (n <= 1)
+												            return false;
+												        if (n <= 3)
+												            return true;
+												  
+												        // This is checked so that we can skip
+												        // middle five numbers in below loop
+												        if (n % 2 == 0 || n % 3 == 0)
+												            return false;
+												  
+												        for (int i = 5; i * i <= n; i = i + 6)
+												            if (n % i == 0 || n % (i + 2) == 0)
+												                return false;
+												  
+												        return true;
+												    }
+												  
+												static long lcm(long a, long b)
+											    {
+											        return ((a / gcd(a, b))%mod * b%mod)%mod;
+											    }
+												   static long gcd(long a,long b)
+												    {
+												        if (a == 0)
+												            return b%mod; 
+												        return (gcd(b % a, a))%mod; 
+												    }
+												
+									
+												//System.out.println(count);
+												
+											
+												
+												
+												static void dfs(int v,boolean visited[],ArrayList<ArrayList<Integer>>adj,int div[],int t)
+												{
+													visited[v]=true;
+													
+													div[v]=t+1;
+													for(int u:adj.get(v)) {
+														
+														
+														
+														if(!visited[u]) {
+															dfs(u,visited,adj,div,(t+1)%2);
+														}
+														
+													}
+													
+													
+												}
+												
+												
+												static class Helper{
+													
+													int a;int b;int t;
+													public Helper(int a,int b) {
+														// TODO Auto-generated constructor stub
+														
+														this.a=a;
+														this.b=b;
+											
+														
+													
+													}
+													
+													
+												}
+										
+										
+												
+										
+												
+												
+												
+												
+												//	System.out.println(max);
+										
+												
+											
+												
+											
+									
+				//System.out.println(ans.toString());
+				//main(						
+											
+							
+					
+				static void solvedfs(ArrayList<ArrayList<Integer>>adj,int n,int v,int subt[],int subtAns[],boolean []visited) {
+							
+							
+							int count=1;
+							int ans=0;
+							visited[v]=true;
+							for(int u:adj.get(v)) {
+								
+								
+								if(!visited[u])
+								{
+									//System.out.println(v+"" ""+subt[v]+"" ""+n);
+									subtAns[u]=Math.max(subtAns[u], subt[v]-subtAns[u]);
+									
+								solvedfs(adj, n, u, subt, subtAns, visited);			
+								
+								}
+							}
+							
+						
+							
+							
+							
+							
+							
+						}
+						
+												
+												
+												
+								static int dfs(ArrayList<ArrayList<Integer>>adj,int v,int subt[],int subtAns[],boolean []visited) {
+								
+									
+									int count=0;
+									int ans=0;
+									visited[v]=true;
+									for(int u:adj.get(v)) {
+										
+										
+										if(!visited[u])
+										{
+											count+=ans;
+											ans=Math.max(dfs(adj,u,subt,subtAns,visited),ans);
+										}
+									}
+										subt[v]=count;
+										subtAns[v]=ans;
+										return ans+1;
+										
+									
+									
+									
+									
+									
+								}
+												
+								
+												
+												
+								static	int solve(ArrayList<ArrayList<Integer>>adj,int node,ArrayList<Integer>A)			
+									{
+										if(adj.get(node).size()==0)return 1;
+										
+										int count=0;
+										for(int v:adj.get(node)) {
+											
+											count+=solve(adj,v,A);
+											
+										}
+										
+										A.set(node,count);
+										return count+1;
+										
+										
+										
+									}
+												
+												
+												
+												
+												
+												
+												
+									static void dfs(String[]building,int i,int j,int n,int m, boolean visited[][]) {
+										
+										
+										visited[i][j]=true;
+										
+										if(isValid(building,i+1,j,n,m,visited))
+										{	visited[i+1][j]=true;
+											dfs(building,i+1,j,n,m,visited);
+										
+										}
+											if(isValid(building,i-1,j,n,m,visited))
+										{
+											visited[i-1][j]=true;
+											dfs(building,i-1,j,n,m,visited);
+										}
+										 if(isValid(building,i,j+1,n,m,visited))
+										{visited[i][j+1]=true;
+											dfs(building,i,j+1,n,m,visited);
+										}
+												if(isValid(building,i,j-1,n,m,visited))
+										{visited[i][j-1]=true;
+											dfs(building,i,j-1,n,m,visited);
+										}
+										
+										
+										
+										
+									}
+									static boolean isValid(String[]building,int i,int j,int n,int m, boolean visited[][])		
+									{
+										if(i==-1||j==-1||i==n||j==m||visited[i][j]||building[i].charAt(j)=='#')
+											return false;
+									return true;
+									}
+												
+												
+												
+												
+								static	void compute(boolean sieve[],int n) {
+										
+										for(int i=2;i<=n;i++) {
+											if(sieve[i])continue;
+											
+											for(int j=2*i;j<n;j+=i)
+											{
+												sieve[j]=true;
+											}
+											
+										}
+											
+										
+										
+									}
+								
+								static	void computeHs(boolean sieve[]) {
+									int n=(int)(1e9-1e7+1);
+									for(int i=1;i<n;i++) {
+										if(sieve[i])continue;
+										
+										for(int j=2*i;j<n;j+=i)
+										{
+											sieve[j]=true;
+										}
+										
+									}
+									
+								}
+							
+								
+									
+												
+												
+												static boolean isValid(StringBuilder s,int w) {
+													if(w>s.length())return false;
+													HashSet<Character>hs=new HashSet<Character>();
+													int a[]=new int[3];
+													
+													for(int i=0;i<w;i++) {
+													
+														++a[s.charAt(i)-49];
+														
+													}
+													
+													if(a[0]>0&&a[1]>0&&a[2]>0)return true;
+												
+													int start=0;
+													int end=w;
+													
+													while(end!=s.length()) {
+														--a[s.charAt(start)-49];
+														
+															++a[s.charAt(end)-49];
+														
+																	start++;
+																		end++;
+																		if(a[0]>0&&a[1]>0&&a[2]>0)return true;
+																				
+													}
+													return false;
+													
+													
+													
+												}
+								
+												
+												
+												
+									
+							
+												
+									static int find(int parent[],int i) {
+										
+										if(parent[i]==-1)return i;
+										
+										return parent[i]=find(parent,parent[i]);
+										
+									}
+									static void union(int parent[],int rank[],int s1,int s2) {
+										
+										if(rank[s1]>=rank[s2]) {
+											
+											parent[s2]=s1;
+											rank[s1]+=rank[s2];
+										}
+										
+										else {
+											
+											parent[s1]=s2;
+											rank[s2]+=rank[s1];
+										}
+										
+										
+									}
+												
+												
+												
+												
+												
+												
+												
+												
+												
+												
+												
+									static	int solve(String S,int K) {
+											
+											if(K<=0)return 0;
+											if(S.charAt(K-1)!=S.charAt(K))
+											return 1+solve(S,K-1);
+											else return solve(S,K-1);
+										}
+										
+										
+										
+										
+				
+				
+					
+				static	boolean isValid(int g[][],int r,int c,int n,int m,boolean visited[][],int s) {
+						if(r==-1||r==n||c==-1||c==m||visited[r][c]||g[r][c]!=s)return false;
+						return true;
+					}
+				
+										
+											
+																					
+											
+									    static class FastReader {
+									        BufferedReader br;
+									        StringTokenizer st;
+									 
+									        public FastReader()
+									        {
+									            br = new BufferedReader(
+									                new InputStreamReader(System.in));
+									        }
+									 
+									        String next()
+									        {
+									            while (st == null || !st.hasMoreElements()) {
+									                try {
+									                    st = new StringTokenizer(br.readLine());
+									                }
+									                catch (IOException e) {
+									                    e.printStackTrace();
+									                }
+									            }
+									            return st.nextToken();
+									        }
+									 
+									        int nextInt() { return Integer.parseInt(next()); }
+									 
+									        long nextLong() { return Long.parseLong(next()); }
+									 
+									        double nextDouble()
+									        {
+									            return Double.parseDouble(next());
+									        }
+									 
+									        String nextLine()
+									        {
+									            String str = """";
+									            try {
+									                str = br.readLine();
+									            }
+									            catch (IOException e) {
+									                e.printStackTrace();
+									            }
+									            return str;
+									        }
+									    }
+									 
+										
+											}
+											
+											
+											
+											
+											    ","import java.io.*;
+import java.util.Arrays;
+import java.util.Hashtable;
+
+public class AirConditionersUpsolve{
+    static class InputReader {
+        private static final int DEFAULT_BUFFER_SIZE = 1 << 16; // Change this to increase your input size //
+        private static final InputStream DEFAULT_STREAM = System.in;private static final int MAX_DECIMAL_PRECISION = 21;private int c;private byte[] buf;private int bufferSize, bufIndex, numBytesRead;private InputStream stream;private static final byte EOF = -1;private static final byte NEW_LINE = 10;private static final byte CARRIAGE_RETURN = 13;private static final byte SPACE = 32;private static final byte DASH = 45;private static final byte DOT = 46;private char[] charBuffer;private static byte[] bytes = new byte[58];private static int[] ints = new int[58];private static char[] chars = new char[128];static { char ch = ' ';int value = 0;byte _byte = 0;for (int i = 48; i < 58; i++) bytes[i] = _byte++;for (int i = 48; i < 58; i++) ints[i] = value++;for (int i = 32; i < 128; i++) chars[i] = ch++; }private static final double[][] doubles = {{0.0d, 0.00d, 0.000d, 0.0000d, 0.00000d, 0.000000d, 0.0000000d, 0.00000000d, 0.000000000d, 0.0000000000d, 0.00000000000d, 0.000000000000d, 0.0000000000000d, 0.00000000000000d, 0.000000000000000d, 0.0000000000000000d, 0.00000000000000000d, 0.000000000000000000d, 0.0000000000000000000d, 0.00000000000000000000d, 0.000000000000000000000d}, {0.1d, 0.01d, 0.001d, 0.0001d, 0.00001d, 0.000001d, 0.0000001d, 0.00000001d, 0.000000001d, 0.0000000001d, 0.00000000001d, 0.000000000001d, 0.0000000000001d, 0.00000000000001d, 0.000000000000001d, 0.0000000000000001d, 0.00000000000000001d, 0.000000000000000001d, 0.0000000000000000001d, 0.00000000000000000001d, 0.000000000000000000001d}, {0.2d, 0.02d, 0.002d, 0.0002d, 0.00002d, 0.000002d, 0.0000002d, 0.00000002d, 0.000000002d, 0.0000000002d, 0.00000000002d, 0.000000000002d, 0.0000000000002d, 0.00000000000002d, 0.000000000000002d, 0.0000000000000002d, 0.00000000000000002d, 0.000000000000000002d, 0.0000000000000000002d, 0.00000000000000000002d, 0.000000000000000000002d}, {0.3d, 0.03d, 0.003d, 0.0003d, 0.00003d, 0.000003d, 0.0000003d, 0.00000003d, 0.000000003d, 0.0000000003d, 0.00000000003d, 0.000000000003d, 0.0000000000003d, 0.00000000000003d, 0.000000000000003d, 0.0000000000000003d, 0.00000000000000003d, 0.000000000000000003d, 0.0000000000000000003d, 0.00000000000000000003d, 0.000000000000000000003d}, {0.4d, 0.04d, 0.004d, 0.0004d, 0.00004d, 0.000004d, 0.0000004d, 0.00000004d, 0.000000004d, 0.0000000004d, 0.00000000004d, 0.000000000004d, 0.0000000000004d, 0.00000000000004d, 0.000000000000004d, 0.0000000000000004d, 0.00000000000000004d, 0.000000000000000004d, 0.0000000000000000004d, 0.00000000000000000004d, 0.000000000000000000004d}, {0.5d, 0.05d, 0.005d, 0.0005d, 0.00005d, 0.000005d, 0.0000005d, 0.00000005d, 0.000000005d, 0.0000000005d, 0.00000000005d, 0.000000000005d, 0.0000000000005d, 0.00000000000005d, 0.000000000000005d, 0.0000000000000005d, 0.00000000000000005d, 0.000000000000000005d, 0.0000000000000000005d, 0.00000000000000000005d, 0.000000000000000000005d}, {0.6d, 0.06d, 0.006d, 0.0006d, 0.00006d, 0.000006d, 0.0000006d, 0.00000006d, 0.000000006d, 0.0000000006d, 0.00000000006d, 0.000000000006d, 0.0000000000006d, 0.00000000000006d, 0.000000000000006d, 0.0000000000000006d, 0.00000000000000006d, 0.000000000000000006d, 0.0000000000000000006d, 0.00000000000000000006d, 0.000000000000000000006d}, {0.7d, 0.07d, 0.007d, 0.0007d, 0.00007d, 0.000007d, 0.0000007d, 0.00000007d, 0.000000007d, 0.0000000007d, 0.00000000007d, 0.000000000007d, 0.0000000000007d, 0.00000000000007d, 0.000000000000007d, 0.0000000000000007d, 0.00000000000000007d, 0.000000000000000007d, 0.0000000000000000007d, 0.00000000000000000007d, 0.000000000000000000007d}, {0.8d, 0.08d, 0.008d, 0.0008d, 0.00008d, 0.000008d, 0.0000008d, 0.00000008d, 0.000000008d, 0.0000000008d, 0.00000000008d, 0.000000000008d, 0.0000000000008d, 0.00000000000008d, 0.000000000000008d, 0.0000000000000008d, 0.00000000000000008d, 0.000000000000000008d, 0.0000000000000000008d, 0.00000000000000000008d, 0.000000000000000000008d}, {0.9d, 0.09d, 0.009d, 0.0009d, 0.00009d, 0.000009d, 0.0000009d, 0.00000009d, 0.000000009d, 0.0000000009d, 0.00000000009d, 0.000000000009d, 0.0000000000009d, 0.00000000000009d, 0.000000000000009d, 0.0000000000000009d, 0.00000000000000009d, 0.000000000000000009d, 0.0000000000000000009d, 0.00000000000000000009d, 0.000000000000000000009d}};
+        public InputReader() { this(DEFAULT_STREAM, DEFAULT_BUFFER_SIZE); }
+        public InputReader(int bufferSize) { this(DEFAULT_STREAM, bufferSize); }
+        public InputReader(InputStream stream) { this(stream, DEFAULT_BUFFER_SIZE); }
+        public InputReader(InputStream stream, int bufferSize) { if (stream == null || bufferSize <= 0) throw new IllegalArgumentException();buf = new byte[bufferSize];charBuffer = new char[128];this.bufferSize = bufferSize;this.stream = stream; }
+        private byte read() throws IOException { if (numBytesRead == EOF) throw new IOException();if (bufIndex >= numBytesRead) { bufIndex = 0;numBytesRead = stream.read(buf);if (numBytesRead == EOF) return EOF; }return buf[bufIndex++]; }
+        private int readJunk(int token) throws IOException { if (numBytesRead == EOF) return EOF;
+            do { while (bufIndex < numBytesRead) { if (buf[bufIndex] > token) return 0;bufIndex++; }
+                numBytesRead = stream.read(buf);if (numBytesRead == EOF) return EOF;bufIndex = 0; } while (true); }
+        public byte nextByte() throws IOException {return (byte) nextInt(); }
+        public int nextInt() throws IOException { if (readJunk(DASH - 1) == EOF) throw new IOException();int sgn = 1, res = 0;c = buf[bufIndex];if (c == DASH) { sgn = -1;bufIndex++; } do { while (bufIndex < numBytesRead) { if (buf[bufIndex] > SPACE) { res = (res << 3) + (res << 1);res += ints[buf[bufIndex++]]; } else { bufIndex++;return res * sgn; } }numBytesRead = stream.read(buf);if (numBytesRead == EOF) return res * sgn;bufIndex = 0; } while (true); }
+        public long nextLong() throws IOException { if (readJunk(DASH - 1) == EOF) throw new IOException();int sgn = 1;long res = 0L;c = buf[bufIndex];if (c == DASH) { sgn = -1;bufIndex++; } do { while (bufIndex < numBytesRead) { if (buf[bufIndex] > SPACE) { res = (res << 3) + (res << 1);res += ints[buf[bufIndex++]]; } else { bufIndex++;return res * sgn; } }numBytesRead = stream.read(buf);if (numBytesRead == EOF) return res * sgn;bufIndex = 0; } while (true); }
+        private void doubleCharBufferSize() { char[] newBuffer = new char[charBuffer.length << 1];for (int i = 0; i < charBuffer.length; i++) newBuffer[i] = charBuffer[i];charBuffer = newBuffer; }
+        public String nextLine() throws IOException { try { c = read(); } catch (IOException e) { return null; }if (c == NEW_LINE) return """";if (c == EOF) return null;int i = 0;charBuffer[i++] = (char) c;do { while (bufIndex < numBytesRead) { if (buf[bufIndex] != NEW_LINE && buf[bufIndex] != CARRIAGE_RETURN) { if (i == charBuffer.length) doubleCharBufferSize();charBuffer[i++] = (char) buf[bufIndex++]; } else { if(buf[bufIndex] == CARRIAGE_RETURN) bufIndex++;bufIndex++;return new String(charBuffer, 0, i); } }numBytesRead = stream.read(buf);if (numBytesRead == EOF) return new String(charBuffer, 0, i);bufIndex = 0; } while (true); }
+        public String nextString() throws IOException { if (numBytesRead == EOF) return null;if (readJunk(SPACE) == EOF) return null;for (int i = 0; ; ) { while (bufIndex < numBytesRead) { if (buf[bufIndex] > SPACE) { if (i == charBuffer.length) doubleCharBufferSize();charBuffer[i++] = (char) buf[bufIndex++]; } else {bufIndex++;return new String(charBuffer, 0, i); } }numBytesRead = stream.read(buf);if (numBytesRead == EOF) return new String(charBuffer, 0, i);bufIndex = 0; } }
+        public double nextDoubleFast() throws IOException {c = read();int sgn = 1;while (c <= SPACE) c = read();if (c == DASH) { sgn = -1;c = read(); }double res = 0.0;while (c > DOT) { res *= 10.0;res += ints[c];c = read(); }if (c == DOT) { int i = 0;c = read();while (c > SPACE && i < MAX_DECIMAL_PRECISION) { res += doubles[ints[c]][i++];c = read(); } }return res * sgn; }
+        public void close() throws IOException {stream.close(); }
+    }
+
+    // region variables
+    static InputReader sc = new InputReader();
+    static OutputStream outputStream = System.out;
+    static PrintWriter w = new PrintWriter(outputStream);
+    // endregion
+
+    private static void initiateIO()
+            throws IOException {if (System.getProperty(""ONLINE_JUDGE"") == null) { try { w = new PrintWriter(""output.txt"");sc = new InputReader(new FileInputStream(""input.txt"")); } catch (Exception e) { throw new IOException(); }} }
+
+    public static void main(String[] args)
+            throws IOException {
+
+        initiateIO();
+
+        int t = sc.nextInt();
+        while(t-- > 0) {
+            solve();
+        }
+
+        w.close();
+
+    }
+
+    static void solve() throws IOException {
+        int n = sc.nextInt();
+        int k = sc.nextInt();
+        int[] ac = new int[n+1];
+        Arrays.fill(ac, Integer.MAX_VALUE);
+        int[] pos = new int[k+1];
+        for(int i = 1; i <= k; i++) {
+            pos[i] = sc.nextInt();
+        }
+        for(int i = 1; i <= k; i++) {
+            int posi = pos[i];
+            int temp = sc.nextInt();
+            ac[posi] = temp;
+        }
+
+        long[] prev = new long[n+1];
+
+        long temp = Integer.MAX_VALUE;
+        for(int i = 1; i <= n; i++) {
+            temp = Math.min(temp+1, ac[i]);
+            prev[i] = temp;
+        }
+
+        long[] next = new long[n+1];
+
+        temp = Integer.MAX_VALUE;
+        for(int i = n; i > 0; i--) {
+            temp = Math.min(temp+1, ac[i]);
+            next[i] = temp;
+        }
+
+        for(int i = 1; i <= n; i++) {
+            w.print(Math.min(prev[i], next[i])+"" "");
+        }
+        w.println();
+    }
+}",1
+646b3abc,8261bd1c,"import java.util.*;
+import java.io.*;
+
+public class Main {
+    static FastScanner sc = new FastScanner(System.in);
+    static PrintWriter pw = new PrintWriter(System.out);
+    static StringBuilder sb = new StringBuilder();
+    static long mod = (long) 1e9 + 7;
+
+    public static void main(String[] args) throws Exception {
+        int n = sc.nextInt();
+        for(int i = 0; i < n; i++) solve();
+        pw.flush();
+    }
+
+    public static void solve() {
+        int n = sc.nextInt();
+        char[] a = sc.next().toCharArray();
+        char[] b = sc.next().toCharArray();
+        boolean isFirst = false;
+        boolean allOk = true;
+        int a1 = 0;
+        int a0 = 0;
+        int b1 = 0;
+        int b0 = 0;
+        int[][] cnt1 = new int[2][2];
+        for(int i = 0; i < n; i++){
+            if(a[i] != b[i]){
+                allOk = false;
+            }
+            if(a[i] == '1'){
+                a1++;
+                isFirst = true;
+            }else{
+                a0++;
+            }
+            if(b[i] == '1'){
+                b1++;
+            }else{
+                b0++;
+            }
+            cnt1[a[i]-'0'][b[i]-'0']++;
+        }
+        if(allOk){
+            pw.println(0);
+            return;
+        }else if(!isFirst){
+            pw.println(-1);
+            return;
+        }else if(a1 != b1 && (a0+1) != b1){
+            pw.println(-1);
+            return;
+        }else{
+            int same = cnt1[1][1] - cnt1[0][0] == 1 ? cnt1[1][1] + cnt1[0][0] : Integer.MAX_VALUE;
+            int odd = cnt1[1][0] - cnt1[0][1] == 0 ? cnt1[1][0] + cnt1[0][1] : Integer.MAX_VALUE;
+            int min = Math.min(same,odd);
+            pw.println(min == Integer.MAX_VALUE ? -1 : min);
+        }
+    }
+    
+
+    static class GeekInteger {
+        public static void save_sort(int[] array) {
+            shuffle(array);
+            Arrays.sort(array);
+        }
+
+        public static int[] shuffle(int[] array) {
+            int n = array.length;
+            Random random = new Random();
+            for (int i = 0, j; i < n; i++) {
+                j = i + random.nextInt(n - i);
+                int randomElement = array[j];
+                array[j] = array[i];
+                array[i] = randomElement;
+            }
+            return array;
+        }
+
+        public static void save_sort(long[] array) {
+            shuffle(array);
+            Arrays.sort(array);
+        }
+
+        public static long[] shuffle(long[] array) {
+            int n = array.length;
+            Random random = new Random();
+            for (int i = 0, j; i < n; i++) {
+                j = i + random.nextInt(n - i);
+                long randomElement = array[j];
+                array[j] = array[i];
+                array[i] = randomElement;
+            }
+            return array;
+        }
+
+    }
+}
+
+class FastScanner {
+    private BufferedReader reader = null;
+    private StringTokenizer tokenizer = null;
+
+    public FastScanner(InputStream in) {
+        reader = new BufferedReader(new InputStreamReader(in));
+        tokenizer = null;
+    }
+
+    public FastScanner(FileReader in) {
+        reader = new BufferedReader(in);
+        tokenizer = null;
+    }
+
+    public String next() {
+        if (tokenizer == null || !tokenizer.hasMoreTokens()) {
+            try {
+                tokenizer = new StringTokenizer(reader.readLine());
+            } catch (IOException e) {
+                throw new RuntimeException(e);
+            }
+        }
+        return tokenizer.nextToken();
+    }
+
+    public String nextLine() {
+        if (tokenizer == null || !tokenizer.hasMoreTokens()) {
+            try {
+                return reader.readLine();
+            } catch (IOException e) {
+                throw new RuntimeException(e);
+            }
+        }
+        return tokenizer.nextToken(""\n"");
+    }
+
+    public long nextLong() {
+        return Long.parseLong(next());
+    }
+
+    public int nextInt() {
+        return Integer.parseInt(next());
+    }
+
+    public double nextDouble() {
+        return Double.parseDouble(next());
+    }
+
+    public String[] nextArray(int n) {
+        String[] a = new String[n];
+        for (int i = 0; i < n; i++)
+            a[i] = next();
+        return a;
+    }
+
+    public int[] nextIntArray(int n) {
+        int[] a = new int[n];
+        for (int i = 0; i < n; i++)
+            a[i] = nextInt();
+        return a;
+    }
+
+    public long[] nextLongArray(int n) {
+        long[] a = new long[n];
+        for (int i = 0; i < n; i++)
+            a[i] = nextLong();
+        return a;
+    }
+}
+","import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.PrintWriter;
+import java.math.BigInteger;
+import java.util.*;
+
+
+public class Cgr18A {
+
+
+    public static void main(String[] args) {
+
+        InputStream inputStream = System.in;
+        OutputStream outputStream = System.out;
+        InputReader sc = new InputReader(inputStream);
+        PrintWriter out = new PrintWriter(outputStream);
+        Solver solver = new Solver();
+        int t = sc.nextInt();
+//        int t = 1;
+        while (t-- != 0) {
+            solver.solve(sc, out);
+        }
+        out.close();
+
+    }
+
+    static class Solver {
+        final int INF = (int) 1e9;
+        public void solve(InputReader sc, PrintWriter out) {
+            int n = sc.nextInt();
+            char[] a = sc.next().toCharArray();
+            char[] b = sc.next().toCharArray();
+            boolean isAllZeroA = isAllZero(a);
+            boolean isAllZeroB = isAllZero(b);
+            if(isAllZeroA && isAllZeroB) {
+                out.println(0);
+                return;
+            }
+            if(isAllZeroA || isAllZeroB) {
+                out.println(-1);
+                return;
+            }
+            int eq = 0;
+            for(int i = 0; i< n;i++) if(a[i]==b[i]) eq++;
+            int eqHasOne = 0;
+            int notEqHasOne = 0;
+            int noteq = n-eq;
+            for (int i = 0; i < n; i++) {
+                if(a[i]==b[i] && a[i]=='1') eqHasOne++;
+                if(a[i]!=b[i] && a[i]=='1') notEqHasOne++;
+            }
+            int l = solveIt(new int[] {eq,noteq},new int[] {eqHasOne,notEqHasOne},0);
+            int r = solveIt(new int[] {eq,noteq},new int[] {eqHasOne,notEqHasOne},1);
+            if(l==INF && r==INF) {
+                out.println(-1);
+            } else {
+                out.println(Math.min(l,r));
+            }
+        }
+
+        private boolean isAllZero(char[] a) {
+            for(char c : a) if(c=='1') return false;
+            return true;
+        }
+
+        private int solveIt(int[] arr,int[] hasOne, int minusPointer) {
+            if(arr[0]==0 && arr[1]==0) throw new RuntimeException();
+            int cnt = 0;
+            int max = arr[0] + arr[1];
+            while(arr[1]!=0) {
+                int minus = minusPointer;
+                int plus = 1-minus;
+                if(hasOne[minusPointer]<1) return INF;
+                int eqHasOne = hasOne[0];
+                int notEqHasOne = hasOne[1];
+                int eqHasZero = arr[0] - eqHasOne;
+                int notEqHasZero = arr[1] - notEqHasOne;
+                if(minusPointer==0) {
+                    int newNotEqHasOne = eqHasZero;
+                    int newEqHasOne = notEqHasZero + 1;
+                    hasOne[0] = newEqHasOne;
+                    hasOne[1] = newNotEqHasOne;
+                } else {
+                    int newEqHasOne = notEqHasZero;
+                    int newNotEqHasOne = eqHasZero + 1;
+                    hasOne[0] = newEqHasOne;
+                    hasOne[1] = newNotEqHasOne;
+                }
+                int minusValue = arr[minus]-1;
+                int plusValue = arr[plus]+1;
+                arr[minus] = plusValue;
+                arr[plus] = minusValue;
+                minusPointer = 1-minusPointer;
+                cnt++;
+                if(cnt>max+10) break;
+            }
+            if(arr[1]!=0) return INF;
+            return cnt;
+        }
+    }
+
+    static void sort(int[] arr) {
+        ArrayList<Integer> al = new ArrayList();
+        for (int i : arr) al.add(i);
+        Collections.sort(al);
+        int idx = 0;
+        for (int i : al) arr[idx++] = i;
+    }
+
+    static void sort(long[] arr) {
+        ArrayList<Long> al = new ArrayList();
+        for (long i : arr) al.add(i);
+        Collections.sort(al);
+        int idx = 0;
+        for (long i : al) arr[idx++] = i;
+    }
+
+    static void sortDec(int[] arr) {
+        ArrayList<Integer> al = new ArrayList();
+        for (int i : arr) al.add(i);
+        Collections.sort(al, Collections.reverseOrder());
+        int idx = 0;
+        for (int i : al) arr[idx++] = i;
+    }
+
+    static void sortDec(long[] arr) {
+        ArrayList<Long> al = new ArrayList();
+        for (long i : arr) al.add(i);
+        Collections.sort(al, Collections.reverseOrder());
+        int idx = 0;
+        for (long i : al) arr[idx++] = i;
+    }
+
+    static class InputReader {
+        private boolean finished = false;
+
+        private InputStream stream;
+        private byte[] buf = new byte[1024];
+        private int curChar;
+        private int numChars;
+        private SpaceCharFilter filter;
+
+        public InputReader(InputStream stream) {
+            this.stream = stream;
+        }
+
+        public int read() {
+            if (numChars == -1) {
+                throw new InputMismatchException();
+            }
+            if (curChar >= numChars) {
+                curChar = 0;
+                try {
+                    numChars = stream.read(buf);
+                } catch (IOException e) {
+                    throw new InputMismatchException();
+                }
+                if (numChars <= 0) {
+                    return -1;
+                }
+            }
+            return buf[curChar++];
+        }
+
+        public int peek() {
+            if (numChars == -1) {
+                return -1;
+            }
+            if (curChar >= numChars) {
+                curChar = 0;
+                try {
+                    numChars = stream.read(buf);
+                } catch (IOException e) {
+                    return -1;
+                }
+                if (numChars <= 0) {
+                    return -1;
+                }
+            }
+            return buf[curChar];
+        }
+
+        public int nextInt() {
+            int c = read();
+            while (isSpaceChar(c)) {
+                c = read();
+            }
+            int sgn = 1;
+            if (c == '-') {
+                sgn = -1;
+                c = read();
+            }
+            int res = 0;
+            do {
+                if (c < '0' || c > '9') {
+                    throw new InputMismatchException();
+                }
+                res *= 10;
+                res += c - '0';
+                c = read();
+            } while (!isSpaceChar(c));
+            return res * sgn;
+        }
+
+        public long nextLong() {
+            int c = read();
+            while (isSpaceChar(c)) {
+                c = read();
+            }
+            int sgn = 1;
+            if (c == '-') {
+                sgn = -1;
+                c = read();
+            }
+            long res = 0;
+            do {
+                if (c < '0' || c > '9') {
+                    throw new InputMismatchException();
+                }
+                res *= 10;
+                res += c - '0';
+                c = read();
+            } while (!isSpaceChar(c));
+            return res * sgn;
+        }
+
+        public String nextString() {
+            int c = read();
+            while (isSpaceChar(c)) {
+                c = read();
+            }
+            StringBuilder res = new StringBuilder();
+            do {
+                if (Character.isValidCodePoint(c)) {
+                    res.appendCodePoint(c);
+                }
+                c = read();
+            } while (!isSpaceChar(c));
+            return res.toString();
+        }
+
+        public boolean isSpaceChar(int c) {
+            if (filter != null) {
+                return filter.isSpaceChar(c);
+            }
+            return isWhitespace(c);
+        }
+
+        public static boolean isWhitespace(int c) {
+            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
+        }
+
+        private String readLine0() {
+            StringBuilder buf = new StringBuilder();
+            int c = read();
+            while (c != '\n' && c != -1) {
+                if (c != '\r') {
+                    buf.appendCodePoint(c);
+                }
+                c = read();
+            }
+            return buf.toString();
+        }
+
+        public String readLine() {
+            String s = readLine0();
+            while (s.trim().length() == 0) {
+                s = readLine0();
+            }
+            return s;
+        }
+
+        public String readLine(boolean ignoreEmptyLines) {
+            if (ignoreEmptyLines) {
+                return readLine();
+            } else {
+                return readLine0();
+            }
+        }
+
+        public BigInteger readBigInteger() {
+            try {
+                return new BigInteger(nextString());
+            } catch (NumberFormatException e) {
+                throw new InputMismatchException();
+            }
+        }
+
+        public char nextCharacter() {
+            int c = read();
+            while (isSpaceChar(c)) {
+                c = read();
+            }
+            return (char) c;
+        }
+
+        public double nextDouble() {
+            int c = read();
+            while (isSpaceChar(c)) {
+                c = read();
+            }
+            int sgn = 1;
+            if (c == '-') {
+                sgn = -1;
+                c = read();
+            }
+            double res = 0;
+            while (!isSpaceChar(c) && c != '.') {
+                if (c == 'e' || c == 'E') {
+                    return res * Math.pow(10, nextInt());
+                }
+                if (c < '0' || c > '9') {
+                    throw new InputMismatchException();
+                }
+                res *= 10;
+                res += c - '0';
+                c = read();
+            }
+            if (c == '.') {
+                c = read();
+                double m = 1;
+                while (!isSpaceChar(c)) {
+                    if (c == 'e' || c == 'E') {
+                        return res * Math.pow(10, nextInt());
+                    }
+                    if (c < '0' || c > '9') {
+                        throw new InputMismatchException();
+                    }
+                    m /= 10;
+                    res += (c - '0') * m;
+                    c = read();
+                }
+            }
+            return res * sgn;
+        }
+
+        public boolean isExhausted() {
+            int value;
+            while (isSpaceChar(value = peek()) && value != -1) {
+                read();
+            }
+            return value == -1;
+        }
+
+        public String next() {
+            return nextString();
+        }
+
+        public SpaceCharFilter getFilter() {
+            return filter;
+        }
+
+        public void setFilter(SpaceCharFilter filter) {
+            this.filter = filter;
+        }
+
+        public interface SpaceCharFilter {
+            public boolean isSpaceChar(int ch);
+        }
+
+        public int[] nextIntArray(int n) {
+            int[] array = new int[n];
+            for (int i = 0; i < n; ++i) array[i] = nextInt();
+            return array;
+        }
+
+        public int[] nextSortedIntArray(int n) {
+            int array[] = nextIntArray(n);
+            Arrays.sort(array);
+            return array;
+        }
+
+        public int[] nextSumIntArray(int n) {
+            int[] array = new int[n];
+            array[0] = nextInt();
+            for (int i = 1; i < n; ++i) array[i] = array[i - 1] + nextInt();
+            return array;
+        }
+
+        public long[] nextLongArray(int n) {
+            long[] array = new long[n];
+            for (int i = 0; i < n; ++i) array[i] = nextLong();
+            return array;
+        }
+
+        public long[] nextSumLongArray(int n) {
+            long[] array = new long[n];
+            array[0] = nextInt();
+            for (int i = 1; i < n; ++i) array[i] = array[i - 1] + nextInt();
+            return array;
+        }
+
+        public long[] nextSortedLongArray(int n) {
+            long array[] = nextLongArray(n);
+            Arrays.sort(array);
+            return array;
+        }
+    }
+
+
+}
+",0
+01b911ac,a195911e,"import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.StringTokenizer;
+import java.util.Arrays;
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.TreeSet;
+import java.util.TreeMap;
+import java.util.PriorityQueue;
+import java.util.Collections;
+import java.util.Stack;
+
+import java.math.BigInteger;
+import java.util.LinkedList;
+import java.util.Iterator;
+
+public class First {
+
+    public static void main(String[] args) {
+        FastScanner fs = new FastScanner();
+        int T = fs.nextInt();
+        for (int tt = 0; tt < T; tt++) {
+
+            solve(fs);
+        }
+        
+    }
+    static void solve(FastScanner fs)
+    {
+        int n=fs.nextInt();
+        long[] times=takeLong(n, fs);
+        long[] damage=takeLong(n, fs);
+        long reqTime=times[n-1]-damage[n-1]+1;
+        long ans=0;
+        for(int i=n-1;i>=0;)
+        {
+            reqTime=times[i]-damage[i]+1;
+            long time=times[i];
+            i--;    
+            while(i>=0 && times[i]>=reqTime)
+            {
+                long thisReqTime=times[i]-damage[i]+1;
+                reqTime=Math.min(reqTime, thisReqTime);
+                i--;
+            }
+            long x=time-reqTime+1;
+            // pn(x);
+            ans+=(x*(x+1)/2);
+
+
+
+        }
+        pn(ans);
+    }
+    static long MOD=(long)(1e9+7);
+    static boolean check(String x, String ans)
+    {
+        if(x.length()!=ans.length()) return x.length()>ans.length();
+        if(x.compareTo(ans) <= -1) return false;
+        else return true;
+    }
+    static long gcd(long a, long b) 
+    {
+        if (a == 0)
+            return b;    
+        return gcd(b%a, a);
+    }
+    static void pn(Object o) { System.out.println(o); } 
+    static void p(Object o) { System.out.print(o); }
+    static void flush() { System.out.flush(); }
+
+    static void debugInt(int[] arr)
+    {
+        for(int i=0;i<arr.length;++i)
+            System.out.print(arr[i]+"" "");
+        System.out.println();
+    }
+    static void debugIntInt(int[][] arr)
+    {
+        for(int i=0;i<arr.length;++i)
+        {
+            for(int j=0;j<arr[0].length;++j)
+                System.out.print(arr[i][j]+"" "");
+            System.out.println();
+        }
+        System.out.println();
+    }
+    static void debugLong(long[] arr)
+    {
+        for(int i=0;i<arr.length;++i)
+            System.out.print(arr[i]+"" "");
+        System.out.println();
+    }
+    static void debugLongLong(long[][] arr)
+    {
+        for(int i=0;i<arr.length;++i)
+        {
+            for(int j=0;j<arr[0].length;++j)
+                System.out.print(arr[i][j]+"" "");
+            System.out.println();
+        }
+        System.out.println();
+    }
+    static long[] takeLong(int n, FastScanner fs)
+    {
+        long[] arr=new long[n];
+        for(int i=0;i<n;++i)
+            arr[i]=fs.nextLong();
+        return arr;
+    } 
+    static long[][] takeLongLong(int m, int n, FastScanner fs)
+    {
+        long[][] arr=new long[m][n];
+        for(int i=0;i<m;++i)
+            for(int j=0;j<n;++j)
+                arr[i][j]=fs.nextLong();
+        return arr;
+    } 
+    static int[] takeInt(int n, FastScanner fs)
+    {
+        int[] arr=new int[n];
+        for(int i=0;i<n;++i)
+            arr[i]=fs.nextInt();
+        return arr;
+    } 
+    static int[][] takeIntInt(int m, int n, FastScanner fs)
+    {
+        int[][] arr=new int[m][n];
+        for(int i=0;i<m;++i)
+            for(int j=0;j<n;++j)
+                arr[i][j]=fs.nextInt();
+        return arr;
+    } 
+    static void sort(int[] a) {
+        ArrayList<Integer> l=new ArrayList<>();
+        for (int i:a) l.add(i);
+        Collections.sort(l);
+        for (int i=0; i<a.length; i++) a[i]=l.get(i);
+    }
+    static int getDecimalFromBinary(String s)
+    {
+        long no=0;
+        for(int i=0;i<s.length();i++)
+        {
+            if(s.charAt(i)=='1')
+                no++;
+            no=no<<1;
+        }
+        return (int)(no>>1);
+    }
+    static String getBinaryFromDecimal(int x)
+    {
+        StringBuilder sb=new StringBuilder();
+        for(int i=0;i<31;++i)
+        {
+            if((x&1)==0)
+                sb.append('0');
+            else
+                sb.append('1');
+            x=x>>1;
+        }
+        return sb.reverse().toString();
+    }
+    static boolean[] sieve()
+    {
+        int size=(int)(1e5+5);
+        boolean[] isPrime=new boolean[size];
+        Arrays.fill(isPrime, true);
+        for(int i=2;i<size;++i)
+            for(int j=2*i;isPrime[i]==true && j<size;j+=i)
+                isPrime[j]=false;
+
+        return isPrime;
+    }
+    static class FastScanner {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st = new StringTokenizer("""");
+        String next() {
+            while (!st.hasMoreTokens())
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+    }
+
+
+}
+class SortComp implements Comparator<String>
+{
+    public int compare(String s1, String s2)
+    {
+        if(s1.length()!=s2.length()) return s2.length()-s1.length();
+        if(s1.compareTo(s2) <= -1) return 1;
+        else return -1;
+    }
+}","import java.util.*;
+
+import java.io.*;
+import java.math.*;
+
+
+public class Main
+
+{ 
+	 static FastReader sc=new FastReader(); 
+	 static int dp[];
+	 static boolean v[];
+//	 static int mod=998244353;;
+	 static int mod=1000000007;
+	 static int max;
+	 static int bit[];
+	 //static long fact[];
+//	 static long A[];
+	 static HashMap<Integer,Integer> map;
+	 //static StringBuffer sb=new StringBuffer("""");
+	 //static HashMap<Integer,Integer> map;
+	   static PrintWriter out=new PrintWriter(System.out);
+	  public static void main(String[] args)
+	  {
+		 //  StringBuffer sb=new StringBuffer("""");
+		  int ttt=1;
+		       ttt =i();		       
+	        outer :while (ttt-- > 0) 
+	        {
+	        	int n=i();
+	        	long A[]=inputL(n);
+	        	long B[]=inputL(n);
+	        	long C[]=new long[n];
+	        	for(int i=0;i<n;i++) {
+	        		C[i]=A[i]-B[i]+1;
+	        	}
+	        	long min=C[n-1];
+	        	long ans=0;
+	        	long last=A[n-1];
+	        	for(int i=n-1;i>=0;i--) {
+	        		if(C[i]>min) {
+	        			continue;
+	        		}
+	        		if(A[i]<min) {
+	        			long y=last-min+1;
+	        			ans+=y*(y+1)/2;
+	        			last=A[i];
+	        			min=C[i];
+	        			continue;
+	        		}
+	        		
+	        		min=C[i];
+	        		
+	        	}
+	        	long y=last-min+1;
+    			ans+=y*(y+1)/2;
+	        	System.out.println(ans);
+	        }
+	        //System.out.println(sb.toString());
+		     out.close();
+	     
+	     
+	    //CHECK FOR N=1                    //CHECK FOR M=0
+        //CHECK FOR N=1                    //CHECK FOR M=0
+       	//CHECK FOR N=1
+       	
+		        
+		     
+    }
+	 
+	 
+	 
+	
+	
+	  
+	 
+	 
+static class Pair implements Comparable<Pair>
+     {
+    	 int x;
+    	 int y;
+    	 int z;
+    	 Pair(int x,int y){
+    		 this.x=x;
+    		 this.y=y;
+//    		 this.z=z;
+    		 
+    	 }
+		@Override
+		public int compareTo(Pair o) {
+			if(this.x>o.x)
+				return 1;
+			else if(this.x<o.x)
+				return -1;
+			else {
+				if(this.y>o.y)
+					return 1;
+				else if(this.y<o.y)
+					return -1;
+				else
+					return 0;
+			}
+		}
+		public int hashCode() 
+		{ 
+			final int temp = 14; 
+			int ans = 1; 
+			ans =x*31+y*13; 
+			return ans; 
+		} 
+		@Override
+		public boolean equals(Object o) 
+		{ 
+			if (this == o) { 
+				return true; 
+			} 
+			if (o == null) { 
+				return false; 
+			} 
+			if (this.getClass() != o.getClass()) { 
+				return false; 
+			} 
+			Pair other = (Pair)o; 
+			if (this.x != other.x || this.y!=other.y) { 
+				return false; 
+			} 
+			return true; 
+		} 	
+//		
+		/* FOR TREE MAP PAIR USE */
+		
+//		public int compareTo(Pair o) {
+// 			if (x > o.x) {
+// 				return 1;
+// 			}
+// 			if (x < o.x) {
+// 				return -1;
+// 			}
+// 			if (y > o.y) {
+// 				return 1;
+// 			}
+// 			if (y < o.y) {
+// 				return -1;
+// 			}
+// 			return 0;
+// 		}
+		
+     }
+
+static int find(int A[],int a) {
+	  if(A[a]==a)
+		  return a;
+	  return A[a]=find(A, A[a]);
+}
+//static int find(int A[],int a) {
+//	  if(A[a]==a)
+//		  return a;
+//	  return find(A, A[a]);
+//}
+//FENWICK TREE
+static void update(int i, int x){
+	for(; i < bit.length; i += (i&-i))
+		bit[i] += x;
+}
+
+static int sum(int i){
+	int ans = 0;
+	for(; i > 0; i -= (i&-i))
+		ans += bit[i];
+	return ans;
+}
+//END
+static void add(int v) {
+	if(!map.containsKey(v)) {
+		map.put(v, 1);
+	}
+	else {
+		map.put(v, map.get(v)+1);
+	}
+}
+static void remove(int v) {
+	if(map.containsKey(v)) {
+		map.put(v, map.get(v)-1);
+		if(map.get(v)==0)
+			map.remove(v);
+	}
+}
+public static int upper(int A[],int k,int si,int ei)
+{
+	int l=si;
+	int u=ei;
+	int ans=-1;
+	while(l<=u) {
+		int mid=(l+u)/2;
+		if(A[mid]<=k) {
+			ans=mid;
+			l=mid+1;
+		}
+		else {
+			u=mid-1;
+		}
+	}
+	return ans;
+}
+public static int lower(int A[],int k,int si,int ei)
+{
+	int l=si;
+	int u=ei;
+	int ans=-1;
+	while(l<=u) {
+		int mid=(l+u)/2;
+		if(A[mid]<=k) {
+			l=mid+1;
+		}
+		else {
+			ans=mid;
+			u=mid-1;
+		}
+	}
+	return ans;
+	
+    
+}
+static int[] copy(int A[]) {
+	int B[]=new int[A.length];
+	for(int i=0;i<A.length;i++) {
+		B[i]=A[i];
+	}
+	return B;
+}
+static long[] copy(long A[]) {
+	long B[]=new long[A.length];
+	for(int i=0;i<A.length;i++) {
+		B[i]=A[i];
+	}
+	return B;
+}
+static int[] input(int n) {
+	int A[]=new int[n];
+	   for(int i=0;i<n;i++) {
+		   A[i]=sc.nextInt();
+	   }
+	   return A;
+   }
+static long[] inputL(int n) {
+	long A[]=new long[n];
+	   for(int i=0;i<n;i++) {
+		   A[i]=sc.nextLong();
+	   }
+	   return A;
+   }
+static String[] inputS(int n) {
+	String A[]=new String[n];
+	   for(int i=0;i<n;i++) {
+		   A[i]=sc.next();
+	   }
+	   return A;
+   }
+static long sum(int A[]) {
+	long sum=0;
+	for(int i : A) {
+		sum+=i;
+	}
+	return sum;
+}
+static long sum(long A[]) {
+	long sum=0;
+	for(long i : A) {
+		sum+=i;
+	}
+	return sum;
+}
+static void reverse(long A[]) {
+	int n=A.length;
+	long B[]=new long[n];
+	for(int i=0;i<n;i++) {
+		B[i]=A[n-i-1];
+	}
+	for(int i=0;i<n;i++)
+		A[i]=B[i];
+	
+}
+static void reverse(int A[]) {
+	int n=A.length;
+	int B[]=new int[n];
+	for(int i=0;i<n;i++) {
+		B[i]=A[n-i-1];
+	}
+	for(int i=0;i<n;i++)
+		A[i]=B[i];
+	
+}
+static void input(int A[],int B[]) {
+	   for(int i=0;i<A.length;i++) {
+		   A[i]=sc.nextInt();
+		   B[i]=sc.nextInt();
+	   }
+}
+static int[][] input(int n,int m){
+	int A[][]=new int[n][m];
+	for(int i=0;i<n;i++) {
+		for(int j=0;j<m;j++) {
+			A[i][j]=i();
+		}
+	}
+	return A;
+}
+static char[][] charinput(int n,int m){
+	char A[][]=new char[n][m];
+	for(int i=0;i<n;i++) {
+		String s=s();
+		for(int j=0;j<m;j++) {
+			A[i][j]=s.charAt(j);
+		}
+	}
+	return A;
+}
+static int nextPowerOf2(int n)
+{
+    n--;
+    n |= n >> 1;
+    n |= n >> 2;
+    n |= n >> 4;
+    n |= n >> 8;
+    n |= n >> 16;
+    n++;
+     
+    return n;
+}
+static int highestPowerof2(int x)
+{
+   
+    x |= x >> 1;
+    x |= x >> 2;
+    x |= x >> 4;
+    x |= x >> 8;
+    x |= x >> 16;
+     
+    return x ^ (x >> 1); 
+ 
+}
+static long highestPowerof2(long x)
+{
+   
+    x |= x >> 1;
+    x |= x >> 2;
+    x |= x >> 4;
+    x |= x >> 8;
+    x |= x >> 16;
+    return x ^ (x >> 1); 
+ 
+}
+
+static int max(int A[]) {
+	int max=Integer.MIN_VALUE;
+	for(int i=0;i<A.length;i++) {
+		max=Math.max(max, A[i]);
+	}
+	return max;
+}
+static int min(int A[]) {
+	int min=Integer.MAX_VALUE;
+	for(int i=0;i<A.length;i++) {
+		min=Math.min(min, A[i]);
+	}
+	return min;
+}
+static long max(long A[]) {
+	long max=Long.MIN_VALUE;
+	for(int i=0;i<A.length;i++) {
+		max=Math.max(max, A[i]);
+	}
+	return max;
+}
+static long min(long A[]) {
+	long min=Long.MAX_VALUE;
+	for(int i=0;i<A.length;i++) {
+		min=Math.min(min, A[i]);
+	}
+	return min;
+}
+static long [] prefix(long A[]) {
+	long p[]=new long[A.length];
+	p[0]=A[0];
+	for(int i=1;i<A.length;i++)
+		p[i]=p[i-1]+A[i];
+	return p;
+}
+static long [] prefix(int A[]) {
+	long p[]=new long[A.length];
+	p[0]=A[0];
+	for(int i=1;i<A.length;i++)
+		p[i]=p[i-1]+A[i];
+	return p;
+}
+static long [] suffix(long A[]) {
+	long p[]=new long[A.length];
+	p[A.length-1]=A[A.length-1];
+	for(int i=A.length-2;i>=0;i--)
+		p[i]=p[i+1]+A[i];
+	return p;
+}
+static long [] suffix(int A[]) {
+	long p[]=new long[A.length];
+	p[A.length-1]=A[A.length-1];
+	for(int i=A.length-2;i>=0;i--)
+		p[i]=p[i+1]+A[i];
+	return p;
+}
+static void fill(int dp[]) {
+	Arrays.fill(dp, -1);
+}
+static void fill(int dp[][]) {
+	for(int i=0;i<dp.length;i++)
+	Arrays.fill(dp[i], -1);
+}
+static void fill(int dp[][][]) {
+	for(int i=0;i<dp.length;i++) {
+		for(int j=0;j<dp[0].length;j++) {
+			Arrays.fill(dp[i][j],-1);
+		}
+	}
+}
+static void fill(int dp[][][][]) {
+	for(int i=0;i<dp.length;i++) {
+		for(int j=0;j<dp[0].length;j++) {
+			for(int k=0;k<dp[0][0].length;k++) {
+			Arrays.fill(dp[i][j][k],-1);
+			}
+		}
+	}
+}
+static void fill(long dp[]) {
+	Arrays.fill(dp, -1);
+}
+static void fill(long dp[][]) {
+	for(int i=0;i<dp.length;i++)
+	Arrays.fill(dp[i], -1);
+}
+static void fill(long dp[][][]) {
+	for(int i=0;i<dp.length;i++) {
+		for(int j=0;j<dp[0].length;j++) {
+			Arrays.fill(dp[i][j],-1);
+		}
+	}
+}
+static void fill(long dp[][][][]) {
+	for(int i=0;i<dp.length;i++) {
+		for(int j=0;j<dp[0].length;j++) {
+			for(int k=0;k<dp[0][0].length;k++) {
+			Arrays.fill(dp[i][j][k],-1);
+			}
+		}
+	}
+}
+static int min(int a,int b) {
+	return Math.min(a, b);
+}
+static int min(int a,int b,int c) {
+	return Math.min(a, Math.min(b, c));
+}
+static int min(int a,int b,int c,int d) {
+	return Math.min(a, Math.min(b, Math.min(c, d)));
+}
+static int max(int a,int b) {
+	return Math.max(a, b);
+}
+static int max(int a,int b,int c) {
+	return Math.max(a, Math.max(b, c));
+}
+static int max(int a,int b,int c,int d) {
+	return Math.max(a, Math.max(b, Math.max(c, d)));
+}
+static long min(long a,long b) {
+	return Math.min(a, b);
+}
+static long min(long a,long b,long c) {
+	return Math.min(a, Math.min(b, c));
+}
+static long min(long a,long b,long c,long d) {
+	return Math.min(a, Math.min(b, Math.min(c, d)));
+}
+static long max(long a,long b) {
+	return Math.max(a, b);
+}
+static long max(long a,long b,long c) {
+	return Math.max(a, Math.max(b, c));
+}
+static long max(long a,long b,long c,long d) {
+	return Math.max(a, Math.max(b, Math.max(c, d)));
+}
+
+static long power(long x, long y, long p)
+{
+
+	if(y==0)
+		return 1;
+	if(x==0)
+		return 0;
+    long res = 1;
+    x = x % p;
+
+    while (y > 0) {
+
+        if (y % 2 == 1)
+            res = (res * x) % p;
+
+        y = y >> 1; 
+        x = (x * x) % p;
+    }
+
+    return res;
+}
+static long power(long x, long y)
+{
+
+	if(y==0)
+		return 1;
+	if(x==0)
+		return 0;
+    long res = 1;
+
+    while (y > 0) {
+
+        if (y % 2 == 1)
+            res = (res * x);
+
+        y = y >> 1; 
+        x = (x * x);
+    }
+
+    return res;
+}
+static void print(int A[]) {
+	for(int i : A) {
+		out.print(i+"" "");
+	}
+	out.println();
+}
+static void print(long A[]) {
+	for(long i : A) {
+		System.out.print(i+"" "");
+	}
+	System.out.println();
+}
+static long mod(long x) {
+	  return ((x%mod + mod)%mod);
+}
+static String reverse(String s) {
+	StringBuffer p=new StringBuffer(s);
+	p.reverse();
+	return p.toString();
+}
+
+     static int i() {
+    	 return sc.nextInt();
+     }
+     static String s() {
+    	 return sc.next();
+     }
+     static long l() {
+    	 return sc.nextLong();
+     }  
+     static void sort(int[] A){
+        int n = A.length;
+        Random rnd = new Random();
+        for(int i=0; i<n; ++i){
+            int tmp = A[i];
+            int randomPos = i + rnd.nextInt(n-i);
+            A[i] = A[randomPos];
+            A[randomPos] = tmp;
+        }
+        Arrays.sort(A);
+     }
+     static void sort(long[] A){
+	        int n = A.length;
+	        Random rnd = new Random();
+	        for(int i=0; i<n; ++i){
+	            long tmp = A[i];
+	            int randomPos = i + rnd.nextInt(n-i);
+	            A[i] = A[randomPos];
+	            A[randomPos] = tmp;
+	        }
+	        Arrays.sort(A);
+	     }
+  static String sort(String s) {
+ 	 Character ch[]=new Character[s.length()];
+ 	 for(int i=0;i<s.length();i++) {
+ 		 ch[i]=s.charAt(i);
+ 	 }
+ 	 Arrays.sort(ch);
+ 	 StringBuffer st=new StringBuffer("""");
+ 	 for(int i=0;i<s.length();i++) {
+ 		 st.append(ch[i]);
+ 	 }
+ 	 return st.toString();
+  }
+  static HashMap<Integer,Integer> hash(int A[]){
+	  HashMap<Integer,Integer> map=new HashMap<Integer, Integer>();
+	  for(int i : A) {
+		  if(map.containsKey(i)) {
+			  map.put(i, map.get(i)+1);
+		  }
+		  else {
+			  map.put(i, 1);
+		  }
+	  }
+	  return map;
+  }
+  static HashMap<Long,Integer> hash(long A[]){
+	  HashMap<Long,Integer> map=new HashMap<Long, Integer>();
+	  for(long i : A) {
+		  if(map.containsKey(i)) {
+			  map.put(i, map.get(i)+1);
+		  }
+		  else {
+			  map.put(i, 1);
+		  }
+	  }
+	  return map;
+  }
+  static TreeMap<Integer,Integer> tree(int A[]){
+	  TreeMap<Integer,Integer> map=new TreeMap<Integer, Integer>();
+	  for(int i : A) {
+		  if(map.containsKey(i)) {
+			  map.put(i, map.get(i)+1);
+		  }
+		  else {
+			  map.put(i, 1);
+		  }
+	  }
+	  return map;
+  }
+  static TreeMap<Long,Integer> tree(long A[]){
+	  TreeMap<Long,Integer> map=new TreeMap<Long, Integer>();
+	  for(long i : A) {
+		  if(map.containsKey(i)) {
+			  map.put(i, map.get(i)+1);
+		  }
+		  else {
+			  map.put(i, 1);
+		  }
+	  }
+	  return map;
+  }
+     static boolean prime(int n) 
+	    { 
+	        if (n <= 1) 
+	            return false; 
+	        if (n <= 3) 
+	            return true; 
+	        if (n % 2 == 0 || n % 3 == 0) 
+	            return false; 
+	        double sq=Math.sqrt(n);
+	  
+	        for (int i = 5; i <= sq; i = i + 6) 
+	            if (n % i == 0 || n % (i + 2) == 0) 
+	                return false; 
+	        return true; 
+	    } 
+     static boolean prime(long n) 
+	    { 
+	        if (n <= 1) 
+	            return false; 
+	        if (n <= 3) 
+	            return true; 
+	        if (n % 2 == 0 || n % 3 == 0) 
+	            return false; 
+	        double sq=Math.sqrt(n);
+	  
+	        for (int i = 5; i <= sq; i = i + 6) 
+	            if (n % i == 0 || n % (i + 2) == 0) 
+	                return false; 
+	        return true; 
+	    } 
+     static int gcd(int a, int b) 
+     { 
+         if (a == 0) 
+             return b; 
+         return gcd(b % a, a); 
+     } 
+     static long gcd(long a, long b) 
+     { 
+         if (a == 0) 
+             return b; 
+         return gcd(b % a, a); 
+     } 
+     
+        
+    static class FastReader 
+    { 
+        BufferedReader br; 
+        StringTokenizer st; 
+  
+        public FastReader() 
+        { 
+            br = new BufferedReader(new
+                     InputStreamReader(System.in)); 
+        } 
+  
+        String next() 
+        { 
+            while (st == null || !st.hasMoreElements()) 
+            { 
+                try
+                { 
+                    st = new StringTokenizer(br.readLine()); 
+                } 
+                catch (IOException  e) 
+                { 
+                    e.printStackTrace(); 
+                } 
+            } 
+            return st.nextToken(); 
+        } 
+  
+        int nextInt() 
+        { 
+            return Integer.parseInt(next()); 
+        } 
+  
+        long nextLong() 
+        { 
+            return Long.parseLong(next()); 
+        } 
+  
+        double nextDouble() 
+        { 
+            return Double.parseDouble(next()); 
+        } 
+  
+        String nextLine() 
+        { 
+            String str = """"; 
+            try
+            { 
+                str = br.readLine(); 
+            } 
+            catch (IOException e) 
+            { 
+                e.printStackTrace(); 
+            } 
+            return str; 
+        } 
+    } 
+} 
+
+
+
+",0
+079ad09e,20012377,"import java.io.OutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.PrintWriter;
+import java.util.Arrays;
+import java.util.InputMismatchException;
+import java.io.IOException;
+import java.io.InputStream;
+ 
+public class Main {
+    public static void main(String[] args) {
+        InputStream inputStream = System.in;
+        OutputStream outputStream = System.out;
+        FastReader in = new FastReader(inputStream);
+        PrintWriter out = new PrintWriter(outputStream);
+        EAirConditioners solver = new EAirConditioners();
+        int testCount = Integer.parseInt(in.next());
+        for (int i = 1; i <= testCount; i++)
+            solver.solve(i, in, out);
+        out.close();
+    }
+ 
+    static class EAirConditioners {
+        public void solve(int testNumber, FastReader in, PrintWriter out) {
+            int n = in.nextInt(), q = in.nextInt();
+            int[] a = in.readArray(q);
+            long[] t = in.readLongArray(q);
+            long[] pref = new long[n + 2];
+            long[] suff = new long[n + 2];
+ 
+            Arrays.fill(pref, (long) 1e14);
+            Arrays.fill(suff, (long) 1e14);
+ 
+            for (int i = 0; i < q; ++i) {
+                pref[a[i]] = t[i] - a[i];
+                suff[a[i]] = t[i] + a[i];
+            }
+ 
+            for (int i = 1; i <= n; ++i) {
+                pref[i] = Math.min(pref[i], pref[i - 1]);
+            }
+ 
+            for (int i = n; i >= 1; --i) {
+                suff[i] = Math.min(suff[i], suff[i + 1]);
+            }
+ 
+            for (int i = 1; i <= n; ++i) {
+                out.print(Math.min(pref[i] + i, suff[i] - i) + "" "");
+            }
+            out.println();
+        }
+ 
+    }
+ 
+    static class FastReader {
+        private InputStream stream;
+        private byte[] buf = new byte[1024];
+        private int curChar;
+        private int numChars;
+        private FastReader.SpaceCharFilter filter;
+ 
+        public FastReader(InputStream stream) {
+            this.stream = stream;
+        }
+ 
+        public int read() {
+            if (numChars == -1) throw new InputMismatchException();
+            if (curChar >= numChars) {
+                curChar = 0;
+                try {
+                    numChars = stream.read(buf);
+                } catch (IOException e) {
+                    throw new InputMismatchException();
+                }
+                if (numChars <= 0) return -1;
+            }
+            return buf[curChar++];
+        }
+ 
+        public int nextInt() {
+            int c = read();
+            while (isSpaceChar(c)) c = read();
+            int sgn = 1;
+            if (c == '-') {
+                sgn = -1;
+                c = read();
+            }
+            int res = 0;
+            do {
+                if (c < '0' || c > '9') throw new InputMismatchException();
+                res *= 10;
+                res += c - '0';
+                c = read();
+            }
+            while (!isSpaceChar(c));
+            return res * sgn;
+        }
+ 
+        public long nextLong() {
+            int c = read();
+            while (isSpaceChar(c)) c = read();
+            int sgn = 1;
+            if (c == '-') {
+                sgn = -1;
+                c = read();
+            }
+            long res = 0;
+            do {
+                if (c < '0' || c > '9') throw new InputMismatchException();
+                res *= 10;
+                res += c - '0';
+                c = read();
+            } while (!isSpaceChar(c));
+            return res * sgn;
+        }
+ 
+        public String next() {
+            int c = read();
+            while (isSpaceChar(c)) c = read();
+            StringBuilder res = new StringBuilder();
+            do {
+                res.appendCodePoint(c);
+                c = read();
+            } while (!isSpaceChar(c));
+            return res.toString();
+        }
+ 
+        public boolean isSpaceChar(int c) {
+            if (filter != null) return filter.isSpaceChar(c);
+            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
+        }
+ 
+        public int[] readArray(int size) {
+            int[] array = new int[size];
+            for (int i = 0; i < size; i++) array[i] = nextInt();
+            return array;
+        }
+ 
+        public long[] readLongArray(int size) {
+            long[] array = new long[size];
+            for (int i = 0; i < size; i++) array[i] = nextLong();
+            return array;
+        }
+ 
+        public interface SpaceCharFilter {
+            public boolean isSpaceChar(int ch);
+ 
+        }
+ 
+    }
+}","import java.io.OutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.PrintWriter;
+import java.util.Arrays;
+import java.util.InputMismatchException;
+import java.io.IOException;
+import java.io.InputStream;
+
+public class Main {
+    public static void main(String[] args) {
+        InputStream inputStream = System.in;
+        OutputStream outputStream = System.out;
+        FastReader in = new FastReader(inputStream);
+        PrintWriter out = new PrintWriter(outputStream);
+        EAirConditioners solver = new EAirConditioners();
+        int testCount = Integer.parseInt(in.next());
+        for (int i = 1; i <= testCount; i++)
+            solver.solve(i, in, out);
+        out.close();
+    }
+
+    static class EAirConditioners {
+        public void solve(int testNumber, FastReader in, PrintWriter out) {
+            int n = in.nextInt(), q = in.nextInt();
+            int[] a = in.readArray(q);
+            long[] t = in.readLongArray(q);
+            long[] pref = new long[n + 2];
+            long[] suff = new long[n + 2];
+
+            Arrays.fill(pref, (long) 1e14);
+            Arrays.fill(suff, (long) 1e14);
+
+            for (int i = 0; i < q; ++i) {
+                pref[a[i]] = t[i] - a[i];
+                suff[a[i]] = t[i] + a[i];
+            }
+
+            for (int i = 1; i <= n; ++i) {
+                pref[i] = Math.min(pref[i], pref[i - 1]);
+            }
+
+            for (int i = n; i >= 1; --i) {
+                suff[i] = Math.min(suff[i], suff[i + 1]);
+            }
+
+            for (int i = 1; i <= n; ++i) {
+                out.print(Math.min(pref[i] + i, suff[i] - i) + "" "");
+            }
+            out.println();
+        }
+
+    }
+
+    static class FastReader {
+        private InputStream stream;
+        private byte[] buf = new byte[1024];
+        private int curChar;
+        private int numChars;
+        private FastReader.SpaceCharFilter filter;
+
+        public FastReader(InputStream stream) {
+            this.stream = stream;
+        }
+
+        public int read() {
+            if (numChars == -1) throw new InputMismatchException();
+            if (curChar >= numChars) {
+                curChar = 0;
+                try {
+                    numChars = stream.read(buf);
+                } catch (IOException e) {
+                    throw new InputMismatchException();
+                }
+                if (numChars <= 0) return -1;
+            }
+            return buf[curChar++];
+        }
+
+        public int nextInt() {
+            int c = read();
+            while (isSpaceChar(c)) c = read();
+            int sgn = 1;
+            if (c == '-') {
+                sgn = -1;
+                c = read();
+            }
+            int res = 0;
+            do {
+                if (c < '0' || c > '9') throw new InputMismatchException();
+                res *= 10;
+                res += c - '0';
+                c = read();
+            }
+            while (!isSpaceChar(c));
+            return res * sgn;
+        }
+
+        public long nextLong() {
+            int c = read();
+            while (isSpaceChar(c)) c = read();
+            int sgn = 1;
+            if (c == '-') {
+                sgn = -1;
+                c = read();
+            }
+            long res = 0;
+            do {
+                if (c < '0' || c > '9') throw new InputMismatchException();
+                res *= 10;
+                res += c - '0';
+                c = read();
+            } while (!isSpaceChar(c));
+            return res * sgn;
+        }
+
+        public String next() {
+            int c = read();
+            while (isSpaceChar(c)) c = read();
+            StringBuilder res = new StringBuilder();
+            do {
+                res.appendCodePoint(c);
+                c = read();
+            } while (!isSpaceChar(c));
+            return res.toString();
+        }
+
+        public boolean isSpaceChar(int c) {
+            if (filter != null) return filter.isSpaceChar(c);
+            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
+        }
+
+        public int[] readArray(int size) {
+            int[] array = new int[size];
+            for (int i = 0; i < size; i++) array[i] = nextInt();
+            return array;
+        }
+
+        public long[] readLongArray(int size) {
+            long[] array = new long[size];
+            for (int i = 0; i < size; i++) array[i] = nextLong();
+            return array;
+        }
+
+        public interface SpaceCharFilter {
+            public boolean isSpaceChar(int ch);
+
+        }
+
+    }
+}
+
+
+",1
+6653a758,6bcc5afd,"import java.util.*;
+public class D {
+	public static void main(String[] args) {
+		Scanner sc=new Scanner(System.in);
+		ArrayList<Integer> o=new ArrayList<Integer>(), e=new ArrayList<Integer>();
+		int n = sc.nextInt(),dp[][]=new int[n+1][n+1];
+		for(int i=1;i<=n;i++){
+			int x=sc.nextInt();
+			if(x==1)o.add(i);
+			else e.add(i);
+		}
+		for(int i=1;i<=o.size();i++){
+			dp[i][i]=dp[i-1][i-1]+Math.abs(o.get(i-1)-e.get(i-1));
+			for(int j=i+1;j<=e.size();j++)
+				dp[i][j]=Math.min(dp[i][j-1],dp[i-1][j-1]+Math.abs(o.get(i-1)-e.get(j-1)));
+		}
+		System.out.println(dp[o.size()][e.size()]);
+	}
+}","import java.util.*;
+public class MyClass {
+    public static void main(String args[]) {
+     Scanner s=new Scanner(System.in);
+     int n=s.nextInt();
+     int a[]=new int[n];
+     ArrayList<Integer> lt1=new ArrayList<>();
+     ArrayList<Integer> lt0=new ArrayList<>();
+     for(int i=0;i<n;i++)
+     {
+         int l=s.nextInt();
+         if(l==0)
+         lt0.add(i+1);
+         else
+         lt1.add(i+1);
+     }
+     int dp[][]=new int[lt1.size()+1][lt0.size()+1];
+     for(int i=1;i<=lt1.size();i++)
+     {
+         dp[i][i]=dp[i-1][i-1]+Math.abs(lt0.get(i-1)-lt1.get(i-1));
+         for(int j=i+1;j<=lt0.size();j++)
+         {
+             dp[i][j]=Math.min(dp[i][j-1],dp[i-1][j-1]+Math.abs(lt1.get(i-1)-lt0.get(j-1)));
+         }
+     }
+     System.out.println(dp[lt1.size()][lt0.size()]);
+     
+    }
+}",1
+11c2ab99,259c1ea4,"import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.StringTokenizer;
+
+public class Main {
+
+	public static void main(String[] args) {
+		FastScanner fs=new FastScanner();
+		int T=fs.nextInt();
+		PrintWriter out=new PrintWriter(System.out);
+		for (int tt=0; tt<T; tt++) {
+			int n=fs.nextInt(), k=fs.nextInt();
+			int[] positions=fs.readArray(k), temps=fs.readArray(k);
+			int[] forced=new int[n];
+			Arrays.fill(forced, Integer.MAX_VALUE/2);
+			for (int i=0; i<k; i++) forced[positions[i]-1]=temps[i];
+			for (int i=1; i<n; i++)
+				forced[i]=Math.min(forced[i], forced[i-1]+1);
+			for (int i=n-2; i>=0; i--)
+				forced[i]=Math.min(forced[i], forced[i+1]+1);
+			for (int i=0; i<n; i++) out.print(forced[i]+"" "");
+			out.println();
+			
+		}
+		out.close();
+	}
+
+	static void sort(int[] a) {
+		ArrayList<Integer> l=new ArrayList<>();
+		for (int i:a) l.add(i);
+		Collections.sort(l);
+		for (int i=0; i<a.length; i++) a[i]=l.get(i);
+	}
+	
+	static class FastScanner {
+		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st=new StringTokenizer("""");
+		String next() {
+			while (!st.hasMoreTokens())
+				try {
+					st=new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			return st.nextToken();
+		}
+		
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+		int[] readArray(int n) {
+			int[] a=new int[n];
+			for (int i=0; i<n; i++) a[i]=nextInt();
+			return a;
+		}
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+	}
+
+	
+}
+
+","import java.util.Arrays;
+import java.util.Scanner;
+
+public class E {
+    public static void main(String[] args) {
+        Scanner scn = new Scanner(System.in);
+        int test = scn.nextInt();
+        while (test-- > 0) {
+            int nrLands = scn.nextInt();
+            int[] toRightLands = new int[nrLands];
+            Arrays.fill(toRightLands, (int) (1e9 + 1e8));
+            int[] toLeftLands = new int[nrLands];
+            Arrays.fill(toLeftLands, (int) (1e9 + 1e8));
+            int nrAcs = scn.nextInt();
+
+            AC[] acs = new AC[nrAcs];
+            for (int i = 0; i < nrAcs; i++) {
+                acs[i] = new AC();
+                acs[i].myPos = scn.nextInt() - 1;
+            }
+            for (int i = 0; i < nrAcs; i++) {
+                acs[i].myTemp = scn.nextInt();
+            }
+            Arrays.sort(acs);
+            int nextAc = 1;
+            AC lastChosen = acs[0];
+
+            for (int i = lastChosen.myPos; i < nrLands; i++) {
+
+                if (nextAc < acs.length && i == acs[nextAc].myPos) {
+                    if (acs[nextAc].myTemp < lastChosen.myTemp + i - lastChosen.myPos) {
+                        lastChosen = acs[nextAc];
+                    }
+                    nextAc++;
+                }
+
+                toRightLands[i] = lastChosen.myTemp + i - lastChosen.myPos;
+
+            }
+
+
+            int nextAc1 = acs.length - 2;
+            AC lastChosen1 = acs[acs.length - 1];
+
+            for (int i = lastChosen1.myPos; i >= 0; i--) {
+                if (nextAc1 >= 0 && i == acs[nextAc1].myPos) {
+                    if (acs[nextAc1].myTemp < lastChosen1.myTemp - i + lastChosen1.myPos) {
+                        lastChosen1 = acs[nextAc1];
+                    }
+                    nextAc1--;
+                }
+
+                toLeftLands[i] = lastChosen1.myTemp - i + lastChosen1.myPos;
+            }
+            for (int i = 0; i < nrLands; i++) {
+                System.out.print(Integer.min(toLeftLands[i], toRightLands[i]) + "" "");
+            }
+            System.out.println();
+
+
+        }
+
+
+    }
+
+
+    static class AC implements Comparable<AC> {
+        int myPos, myTemp;
+
+
+        @Override
+        public int compareTo(AC o) {
+            return Integer.compare(myPos, o.myPos);
+        }
+    }
+}
+",0
+0df4050e,6f02c6d9,"import java.io.*;
+import java.util.*;
+
+public class MainClass {
+    public static void main(String[] args) {
+        Reader in = new Reader(System.in);
+        int t = in.nextInt();
+        StringBuilder stringBuilder = new StringBuilder();
+        while (t-- > 0) {
+            ArrayList<Integer> reds = new ArrayList<>();
+            ArrayList<Integer> blue = new ArrayList<>();
+            int n = in.nextInt();
+            int[] a = new int[n];
+            for (int i = 0; i < n; i++) {
+                a[i] = in.nextInt() - 1;
+            }
+            char[] s = in.next().toCharArray();
+            for (int i = 0; i < n; i++) {
+                if (s[i] == 'R') {
+                    reds.add(a[i]);
+                } else {
+                    blue.add(a[i]);
+                }
+            }
+            Collections.sort(reds, Collections.reverseOrder());
+            Collections.sort(blue);
+            boolean ff = true;
+            int start = 0;
+            for (int i = 0; i < blue.size(); i++) {
+                if (blue.get(i) < start) {
+                    ff = false;
+                    break;
+                }
+                start++;
+            }
+            start = n - 1;
+            for (int i = 0; i < reds.size(); i++) {
+                if (reds.get(i) > start) {
+                    ff = false;
+                    break;
+                }
+                start--;
+            }
+            stringBuilder.append(ff?""YES"":""NO"").append(""\n"");
+        }
+        System.out.println(stringBuilder);
+    }
+}
+class Reader {
+    public BufferedReader reader;
+    public StringTokenizer tokenizer;
+
+    public Reader(InputStream stream) {
+        reader = new BufferedReader(new InputStreamReader(stream), 32768);
+        tokenizer = null;
+    }
+
+    public String next() {
+        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
+            try {
+                tokenizer = new StringTokenizer(reader.readLine());
+            } catch (IOException e) {
+                throw new RuntimeException(e);
+            }
+        }
+        return tokenizer.nextToken();
+    }
+
+    public int nextInt() {
+        return Integer.parseInt(next());
+    }
+
+    public long nextLong() {
+        return Long.parseLong(next());
+    }
+
+}","
+import java.io.*;
+import java.util.*;
+
+public class Main {
+
+
+    static long mod = 1000000007;
+
+    static long inv(long a, long b) {
+        return 1 < a ? b - inv(b % a, a) * b / a : 1;
+    }
+
+    static long mi(long a) {
+        return inv(a, mod);
+    }
+
+    static InputReader sc = new InputReader(System.in);
+    static PrintWriter out = new PrintWriter(System.out);
+
+    public static void main(String[] args) throws IOException {
+
+        int t = sc.nextInt();
+        while (t-- > 0) {
+
+            int n = sc.nextInt();
+            int[] A = new int[n];
+
+            for (int i = 0; i < A.length; i++) {
+                A[i] = sc.nextInt();
+            }
+            String word = sc.next();
+            ArrayList<Integer> blue = new ArrayList<>();
+            ArrayList<Integer> red = new ArrayList<>();
+
+            for (int i = 0; i < word.length(); i++) {
+                if (word.charAt(i) == 'R') {
+                    red.add(A[i]);
+                } else {
+                    blue.add(A[i]);
+                }
+            }
+            Collections.sort(blue);
+            Collections.sort(red);
+
+            boolean possible = true;
+
+            int a = 1;
+            for (int i = 0; i < blue.size(); i++, a++) {
+                if (blue.get(i) < a) {
+                    possible = false;
+                    break;
+                }
+            }
+
+            for (int i = 0; i < red.size(); i++, a++) {
+                if (red.get(i) > a) {
+                    possible = false;
+                    break;
+                }
+            }
+
+            if (possible) out.println(""YES"");
+            else out.println(""NO"");
+
+
+        }
+        out.flush();
+        out.close();
+    }
+
+    static class InputReader {
+        BufferedReader reader;
+        StringTokenizer tokenizer;
+
+        public InputReader(InputStream stream) {
+            reader = new BufferedReader(new InputStreamReader(stream), 32768);
+            tokenizer = null;
+        }
+
+
+        String next() {
+            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
+                try {
+                    tokenizer = new StringTokenizer(reader.readLine());
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+            }
+            return tokenizer.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+
+        String nextLine() {
+            String str = """";
+            try {
+                str = reader.readLine();
+            } catch (IOException e) {
+                throw new RuntimeException(e);
+            }
+            return str;
+        }
+    }
+
+    public static void shuffle(int[] a) {
+        Random get = new Random();
+        for (int i = 0; i < a.length; i++) {
+            int r = get.nextInt(a.length);
+            int temp = a[i];
+            a[i] = a[r];
+            a[r] = temp;
+        }
+    }
+
+    public static void shuffle(long[] a) {
+        Random get = new Random();
+        for (int i = 0; i < a.length; i++) {
+            int r = get.nextInt(a.length);
+            long temp = a[i];
+            a[i] = a[r];
+            a[r] = temp;
+        }
+    }
+
+}
+",1
+d1cd194e,dbffab11,"import java.util.*;
+
+import java.lang.*;
+import java.io.*;
+
+public class Template {
+	
+	static class FastReader {
+  BufferedReader br;
+  StringTokenizer st;
+
+  public FastReader()
+  {
+      br = new BufferedReader(
+          new InputStreamReader(System.in));
+  }
+
+  String next()
+  {
+      while (st == null ||!st.hasMoreElements()) {
+          try {
+              st = new StringTokenizer(br.readLine());
+          }
+          catch (IOException e) {
+              e.printStackTrace();
+          }
+      }
+      return st.nextToken();
+  }
+
+  int nextInt() { return Integer.parseInt(next()); }
+
+  long nextLong() { return Long.parseLong(next()); }
+
+  double nextDouble()
+  {
+      return Double.parseDouble(next());
+  }
+
+  String nextLine()
+  {
+      String str = """";
+      try {
+          str = br.readLine();
+      }
+      catch (IOException e) {
+          e.printStackTrace();
+      }
+      return str;
+  }
+  
+}
+	
+//	static void solve(String s) 
+//	{
+////		Scanner sc = new Scanner(System.in);
+////		String s = sc.next();
+//		
+//		int x[] = new int[2];
+//		x[0] = x[1] = -1;
+//		
+//		int ans = 0;
+//		int n = s.length();
+//		for(int i=0;i<n;i++)
+//		{
+//			int c = s.charAt(i) - '0';
+//			if(c == 1 || c == 0)
+//			{
+//				x[(i%2) ^ c] = i;
+//			}
+//			int min = Math.min(x[0], x[1]);
+//			ans += i - min;
+//			//System.out.println(ans);
+//		}
+//		System.out.println(ans);
+//	}
+//	
+
+//	    public static void main(String args[])
+//	    {
+//	    	FastReader sc = new FastReader();
+//	    	//solve();
+//	    	//Scanner sc = new Scanner(System.in)
+//	       int testcases = sc.nextInt();  // nTest is the number of treasure hunts.
+//	      
+////	    	int testcases = 3;
+//	        while(testcases-- > 0)
+//	        {
+//	        	String s = sc.next();
+//	        	solve(s);
+//	        	
+//	        }
+//	    
+//	    }
+	
+	static class Pair implements Comparable<Pair>
+	{
+		int h;
+		int ind;
+		
+		Pair(int h, int ind)
+		{
+			this.h = h;
+			this.ind = ind;
+		}
+		@Override
+		public int compareTo(Pair o) {
+			
+			return this.h - o.h;
+		}
+		
+		
+	}
+	public static void main(String[] args) {
+
+		FastReader fs=new FastReader();
+
+		int T=fs.nextInt();
+
+		for (int tt=0; tt<T; tt++) {
+		int n = fs.nextInt();
+		int m = fs.nextInt();
+		int x = fs.nextInt();
+		
+		if(n < m)
+		{
+			System.out.println(""NO"");
+			continue;
+		}
+		Pair a[] = new Pair[n];
+		PriorityQueue<Pair> heap = new PriorityQueue<>();
+		for(int i=0;i<n;i++)
+		{
+			a[i] = new Pair(fs.nextInt(), i);
+			
+		}
+		
+		Arrays.sort(a);
+		for(int i=1;i<=m;i++)
+		{
+			heap.add(new Pair(0, i));
+		}
+		int max = Integer.MIN_VALUE;
+		int min = Integer.MAX_VALUE;
+		int ans[] = new int[n];
+		int idx = 0;
+		while(!heap.isEmpty() && idx < n)
+		{
+			Pair curr = heap.poll();
+			curr.h += a[idx].h;
+			ans[a[idx].ind] = curr.ind;
+			heap.add(new Pair(curr.h,  curr.ind));
+			idx++;
+		}
+			
+		
+		
+//		int towers[] = new int[m+1];
+//		int tower = 1;
+//		boolean flag = false;
+//		boolean inc = true;
+//		for(int i=0;i<n;i++)
+//		{
+//			if(tower == m+1)
+//			{
+//				tower = m;
+//				inc = false;
+//			}
+//			if(tower == 0)
+//			{
+//				tower = 1;
+//				inc = true;
+//			}
+//			towers[tower] += a[i].h;
+//			System.out.println(a[i].h +"" THis"" + tower);
+////			min = Math.min(min, towers[tower]);
+////			max = Math.max(max, towers[tower]);
+//			ans[a[i].ind] = tower;
+////			if(Math.abs(max - min) > x)
+////			{
+////				System.out.println(""NO"" + a[i].ind+"" ""+a[i].h +"" ""+min +"" ""+max);
+////				flag = true;
+////				break;
+////			}
+//			if(inc)
+//				tower++;
+//			else
+//				tower--;
+//		}
+//		for(int i=1;i<=m;i++)
+//		{
+//			min = Math.min(min, towers[i]);
+//			max = Math.max(max, towers[i]);
+//		}
+//		if(Math.abs(max - min) > x)
+//			{
+//				System.out.println(""NO"" + max+"" ""+min);// + a[i].ind+"" ""+a[i].h +"" ""+min +"" ""+max);
+//				//flag = true;
+//				continue;
+//			}
+//		if(flag)
+//			continue;
+		System.out.println(""YES"");
+		for(int i:ans)
+			System.out.print(i+"" "");
+		
+		System.out.println();
+
+		}
+	
+}
+}
+","/* package codechef; // don't place package name! */
+
+import java.util.*;
+import java.lang.*;
+import java.io.*;
+
+/* Name of the class has to be ""Main"" only if the class is public. */
+public  class cses
+{   
+    static int mod=1000000007;
+    static FastReader sc=new FastReader();
+    public static void main (String[] args) throws java.lang.Exception
+    {
+        long startTime=System.currentTimeMillis();
+        int t=sc.nextInt();
+        for(int y=0;y<t;++y)
+        {
+           int n=sc.nextInt();
+           int m=sc.nextInt();
+           int x=sc.nextInt();
+           int arr[]=arrayintinput(n);
+           //PriorityQueue<Node> pq=new PriorityQueue<>();
+           int index[]=new int[n];
+           
+           
+           PriorityQueue<Node> pq =new PriorityQueue<Node>(new comp());           
+           for(int i=0;i<m;++i)
+           {
+               pq.add(new Node(0,i+1));
+           }
+           for(int i=0;i<n;++i)
+           {
+            Node temp=pq.remove();
+            temp.sum+=arr[i];
+            index[i]=temp.build;
+            pq.add(new Node(temp.sum,temp.build));
+           }
+           System.out.println(""YES"");
+            for(int i=0;i<n;++i)
+            {
+                System.out.print(index[i]+"" "");    
+            }  
+            System.out.println();
+        }
+    //  getExecutionTime(startTime);
+    }
+    
+
+    static int[] arrayintinput(int n)
+    {
+        int arr[]=new int[n];
+        for(int i=0;i<n;++i)
+        {
+            arr[i]=sc.nextInt();
+        }
+        return arr;
+    }
+    static class comp implements Comparator<Node>{ 
+        public int compare(Node a,Node b)
+        {
+            return a.sum-b.sum;
+        }
+    }
+   static class Node{
+    int sum;
+    int build;
+    Node(int sum ,int build)
+    {
+    this.sum=sum;
+    this.build=build;
+    }
+    }
+
+    static class FastReader {
+        BufferedReader br;
+        StringTokenizer st;
+ 
+        public FastReader()
+        {
+            br = new BufferedReader(
+                new InputStreamReader(System.in));
+        }
+ 
+        String next()
+        {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                }
+                catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+ 
+        int nextInt() { return Integer.parseInt(next()); }
+ 
+        long nextLong() { return Long.parseLong(next()); }
+ 
+        double nextDouble()
+        {
+            return Double.parseDouble(next());
+        }
+ 
+        String nextLine()
+        {
+            String str = """";
+            try {
+                str = br.readLine();
+            }
+            catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+        }
+    }
+      
+    
+   static void getExecutionTime(long startTime)
+   {
+        final long endTime = System.currentTimeMillis();
+        System.out.println();
+        System.out.println(""Time take is ""+(endTime-startTime)+"" ms"");
+   }
+  
+
+}
+//  System.out.println(""Case #""+(y+1)+"": ""+ans);
+
+",0
+2b9dfed3,351c9206,"import static java.lang.Math.max;
+import static java.lang.Math.min;
+import static java.lang.Math.abs;
+import java.util.*;
+import java.io.*;
+import java.math.*;
+
+/**
+ *
+ * @Har_Har_Mahadev
+ */
+
+/**
+ * Main , Solution , Remove Public
+ */
+public class E {
+
+	public static void process() throws IOException {
+
+		int n = sc.nextInt(),k = sc.nextInt();
+		int index[] = sc.readArray(k);
+		long t[] = sc.readArrayLong(k);
+		PriorityQueue<Pair> q = new PriorityQueue<Pair>();
+		for(int i = 0; i<k; i++)q.add(new Pair(t[i]+index[i], index[i]));
+		long ans[] = new long[n+1];
+		Arrays.fill(ans, INF);
+		int i = 1;
+		while(!q.isEmpty() && i<=n) {
+			while(!q.isEmpty() && q.peek().y < i) {
+				q.poll();
+			}
+			if(q.isEmpty())break;
+			Pair e = q.peek();
+			ans[i]=min(ans[i],e.x-i);
+			i++;
+		}
+//		System.out.println(Arrays.toString(ans));
+		q.clear();
+		for(i = 0; i<k; i++) {
+			q.add(new Pair(t[i]+n-index[i], index[i]));
+		}
+		i = n;
+		while(!q.isEmpty() && i>=1) {
+			while(!q.isEmpty() && q.peek().y > i) {
+				q.poll();
+			}
+			if(q.isEmpty())break;
+			Pair e = q.peek();
+			ans[i]=min(ans[i],e.x-(n-i));
+			i--;
+		}
+		for( i = 1; i<=n; i++)out.print(ans[i]+"" "");
+		out.println();
+
+	}
+
+	//=============================================================================
+	//--------------------------The End---------------------------------
+	//=============================================================================
+	private static long INF = 2000000000000000000L, M = 1000000007, MM = 998244353;
+	private static int N = 0;
+
+	private static void google(int tt) {
+		System.out.print(""Case #"" + (tt) + "": "");
+	}
+
+	static FastScanner sc;
+	static FastWriter out;
+
+	public static void main(String[] args) throws IOException {
+		boolean oj = true;
+		if (oj) {
+			sc = new FastScanner();
+			out = new FastWriter(System.out);
+		} else {
+			sc = new FastScanner(""input.txt"");
+			out = new FastWriter(""output.txt"");
+		}
+		long s = System.currentTimeMillis();
+		int t = 1;
+		t = sc.nextInt();
+		int TTT = 1;
+		while (t-- > 0) {
+			//			google(TTT++);
+			process();
+		}
+		out.flush();
+		//		tr(System.currentTimeMillis()-s+""ms"");
+	}
+
+	private static boolean oj = System.getProperty(""ONLINE_JUDGE"") != null;
+
+	private static void tr(Object... o) {
+		if (!oj)
+			System.err.println(Arrays.deepToString(o));
+	}
+
+	static class Pair implements Comparable<Pair> {
+		long x;
+		int y;
+
+		Pair(long x, int y) {
+			this.x = x;
+			this.y = y;
+		}
+
+		@Override
+		public int compareTo(Pair o) {
+			return Long.compare(this.x, o.x);
+		}
+
+		/*
+		 	@Override
+		    public boolean equals(Object o) {
+		        if (this == o) return true;
+		        if (!(o instanceof Pair)) return false;
+		        Pair key = (Pair) o;
+		        return x == key.x && y == key.y;
+		    }
+		 
+		    @Override
+		    public int hashCode() {
+		        int result = x;
+		        result = 31 * result + y;
+		        return result;
+		    }
+		*/
+	}
+
+	/////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+	static int ceil(int x, int y) {
+		return (x % y == 0 ? x / y : (x / y + 1));
+	}
+
+	static long ceil(long x, long y) {
+		return (x % y == 0 ? x / y : (x / y + 1));
+	}
+
+	static long sqrt(long z) {
+		long sqz = (long) Math.sqrt(z);
+		while (sqz * 1L * sqz < z) {
+			sqz++;
+		}
+		while (sqz * 1L * sqz > z) {
+			sqz--;
+		}
+		return sqz;
+	}
+
+	static int log2(int N) {
+		int result = (int) (Math.log(N) / Math.log(2));
+		return result;
+	}
+
+	public static long gcd(long a, long b) {
+		if (a > b)
+			a = (a + b) - (b = a);
+		if (a == 0L)
+			return b;
+		return gcd(b % a, a);
+	}
+
+	public static long lcm(long a, long b) {
+		return (a * b) / gcd(a, b);
+	}
+
+	public static int lower_bound(int[] arr, int x) {
+		int low = 0, high = arr.length - 1, mid = -1;
+		int ans = -1;
+		while (low <= high) {
+			mid = (low + high) / 2;
+
+			if (arr[mid] > x) {
+				high = mid - 1;
+			} else {
+				ans = mid;
+				low = mid + 1;
+			}
+		}
+
+		return ans;
+	}
+
+	public static int upper_bound(int[] arr, int x) {
+		int low = 0, high = arr.length - 1, mid = -1;
+		int ans = arr.length;
+		while (low < high) {
+			mid = (low + high) / 2;
+
+			if (arr[mid] >= x) {
+				ans = mid;
+				high = mid - 1;
+			} else {
+				low = mid + 1;
+			}
+		}
+
+		return ans;
+	}
+
+	static void ruffleSort(int[] a) {
+		Random get = new Random();
+		for (int i = 0; i < a.length; i++) {
+			int r = get.nextInt(a.length);
+			int temp = a[i];
+			a[i] = a[r];
+			a[r] = temp;
+		}
+		Arrays.sort(a);
+	}
+
+	static void ruffleSort(long[] a) {
+		Random get = new Random();
+		for (int i = 0; i < a.length; i++) {
+			int r = get.nextInt(a.length);
+			long temp = a[i];
+			a[i] = a[r];
+			a[r] = temp;
+		}
+		Arrays.sort(a);
+	}
+
+	static void reverseArray(int[] a) {
+		int n = a.length;
+		int arr[] = new int[n];
+		for (int i = 0; i < n; i++)
+			arr[i] = a[n - i - 1];
+		for (int i = 0; i < n; i++)
+			a[i] = arr[i];
+	}
+
+	static void reverseArray(long[] a) {
+		int n = a.length;
+		long arr[] = new long[n];
+		for (int i = 0; i < n; i++)
+			arr[i] = a[n - i - 1];
+		for (int i = 0; i < n; i++)
+			a[i] = arr[i];
+	}
+
+	//custom multiset (replace with HashMap if needed)
+	public static void push(TreeMap<Integer, Integer> map, int k, int v) {
+		//map[k] += v;
+		if (!map.containsKey(k))
+			map.put(k, v);
+		else
+			map.put(k, map.get(k) + v);
+	}
+
+	public static void pull(TreeMap<Integer, Integer> map, int k, int v) {
+		//assumes map[k] >= v
+		//map[k] -= v
+		int lol = map.get(k);
+		if (lol == v)
+			map.remove(k);
+		else
+			map.put(k, lol - v);
+	}
+
+	// compress Big value to Time Limit
+	public static int[] compress(int[] arr) {
+		ArrayList<Integer> ls = new ArrayList<Integer>();
+		for (int x : arr)
+			ls.add(x);
+		Collections.sort(ls);
+		HashMap<Integer, Integer> map = new HashMap<Integer, Integer>();
+		int boof = 1; //min value
+		for (int x : ls)
+			if (!map.containsKey(x))
+				map.put(x, boof++);
+		int[] brr = new int[arr.length];
+		for (int i = 0; i < arr.length; i++)
+			brr[i] = map.get(arr[i]);
+		return brr;
+	}
+
+	// Fast Writer 
+
+	public static class FastWriter {
+		private static final int BUF_SIZE = 1 << 13;
+		private final byte[] buf = new byte[BUF_SIZE];
+		private final OutputStream out;
+		private int ptr = 0;
+
+		private FastWriter() {
+			out = null;
+		}
+
+		public FastWriter(OutputStream os) {
+			this.out = os;
+		}
+
+		public FastWriter(String path) {
+			try {
+				this.out = new FileOutputStream(path);
+			} catch (FileNotFoundException e) {
+				throw new RuntimeException(""FastWriter"");
+			}
+		}
+
+		public FastWriter write(byte b) {
+			buf[ptr++] = b;
+			if (ptr == BUF_SIZE)
+				innerflush();
+			return this;
+		}
+
+		public FastWriter write(char c) {
+			return write((byte) c);
+		}
+
+		public FastWriter write(char[] s) {
+			for (char c : s) {
+				buf[ptr++] = (byte) c;
+				if (ptr == BUF_SIZE)
+					innerflush();
+			}
+			return this;
+		}
+
+		public FastWriter write(String s) {
+			s.chars().forEach(c -> {
+				buf[ptr++] = (byte) c;
+				if (ptr == BUF_SIZE)
+					innerflush();
+			});
+			return this;
+		}
+
+		private static int countDigits(int l) {
+			if (l >= 1000000000)
+				return 10;
+			if (l >= 100000000)
+				return 9;
+			if (l >= 10000000)
+				return 8;
+			if (l >= 1000000)
+				return 7;
+			if (l >= 100000)
+				return 6;
+			if (l >= 10000)
+				return 5;
+			if (l >= 1000)
+				return 4;
+			if (l >= 100)
+				return 3;
+			if (l >= 10)
+				return 2;
+			return 1;
+		}
+
+		public FastWriter write(int x) {
+			if (x == Integer.MIN_VALUE) {
+				return write((long) x);
+			}
+			if (ptr + 12 >= BUF_SIZE)
+				innerflush();
+			if (x < 0) {
+				write((byte) '-');
+				x = -x;
+			}
+			int d = countDigits(x);
+			for (int i = ptr + d - 1; i >= ptr; i--) {
+				buf[i] = (byte) ('0' + x % 10);
+				x /= 10;
+			}
+			ptr += d;
+			return this;
+		}
+
+		private static int countDigits(long l) {
+			if (l >= 1000000000000000000L)
+				return 19;
+			if (l >= 100000000000000000L)
+				return 18;
+			if (l >= 10000000000000000L)
+				return 17;
+			if (l >= 1000000000000000L)
+				return 16;
+			if (l >= 100000000000000L)
+				return 15;
+			if (l >= 10000000000000L)
+				return 14;
+			if (l >= 1000000000000L)
+				return 13;
+			if (l >= 100000000000L)
+				return 12;
+			if (l >= 10000000000L)
+				return 11;
+			if (l >= 1000000000L)
+				return 10;
+			if (l >= 100000000L)
+				return 9;
+			if (l >= 10000000L)
+				return 8;
+			if (l >= 1000000L)
+				return 7;
+			if (l >= 100000L)
+				return 6;
+			if (l >= 10000L)
+				return 5;
+			if (l >= 1000L)
+				return 4;
+			if (l >= 100L)
+				return 3;
+			if (l >= 10L)
+				return 2;
+			return 1;
+		}
+
+		public FastWriter write(long x) {
+			if (x == Long.MIN_VALUE) {
+				return write("""" + x);
+			}
+			if (ptr + 21 >= BUF_SIZE)
+				innerflush();
+			if (x < 0) {
+				write((byte) '-');
+				x = -x;
+			}
+			int d = countDigits(x);
+			for (int i = ptr + d - 1; i >= ptr; i--) {
+				buf[i] = (byte) ('0' + x % 10);
+				x /= 10;
+			}
+			ptr += d;
+			return this;
+		}
+
+		public FastWriter write(double x, int precision) {
+			if (x < 0) {
+				write('-');
+				x = -x;
+			}
+			x += Math.pow(10, -precision) / 2;
+			//		if(x < 0){ x = 0; }
+			write((long) x).write(""."");
+			x -= (long) x;
+			for (int i = 0; i < precision; i++) {
+				x *= 10;
+				write((char) ('0' + (int) x));
+				x -= (int) x;
+			}
+			return this;
+		}
+
+		public FastWriter writeln(char c) {
+			return write(c).writeln();
+		}
+
+		public FastWriter writeln(int x) {
+			return write(x).writeln();
+		}
+
+		public FastWriter writeln(long x) {
+			return write(x).writeln();
+		}
+
+		public FastWriter writeln(double x, int precision) {
+			return write(x, precision).writeln();
+		}
+
+		public FastWriter write(int... xs) {
+			boolean first = true;
+			for (int x : xs) {
+				if (!first)
+					write(' ');
+				first = false;
+				write(x);
+			}
+			return this;
+		}
+
+		public FastWriter write(long... xs) {
+			boolean first = true;
+			for (long x : xs) {
+				if (!first)
+					write(' ');
+				first = false;
+				write(x);
+			}
+			return this;
+		}
+
+		public FastWriter writeln() {
+			return write((byte) '\n');
+		}
+
+		public FastWriter writeln(int... xs) {
+			return write(xs).writeln();
+		}
+
+		public FastWriter writeln(long... xs) {
+			return write(xs).writeln();
+		}
+
+		public FastWriter writeln(char[] line) {
+			return write(line).writeln();
+		}
+
+		public FastWriter writeln(char[]... map) {
+			for (char[] line : map)
+				write(line).writeln();
+			return this;
+		}
+
+		public FastWriter writeln(String s) {
+			return write(s).writeln();
+		}
+
+		private void innerflush() {
+			try {
+				out.write(buf, 0, ptr);
+				ptr = 0;
+			} catch (IOException e) {
+				throw new RuntimeException(""innerflush"");
+			}
+		}
+
+		public void flush() {
+			innerflush();
+			try {
+				out.flush();
+			} catch (IOException e) {
+				throw new RuntimeException(""flush"");
+			}
+		}
+
+		public FastWriter print(byte b) {
+			return write(b);
+		}
+
+		public FastWriter print(char c) {
+			return write(c);
+		}
+
+		public FastWriter print(char[] s) {
+			return write(s);
+		}
+
+		public FastWriter print(String s) {
+			return write(s);
+		}
+
+		public FastWriter print(int x) {
+			return write(x);
+		}
+
+		public FastWriter print(long x) {
+			return write(x);
+		}
+
+		public FastWriter print(double x, int precision) {
+			return write(x, precision);
+		}
+
+		public FastWriter println(char c) {
+			return writeln(c);
+		}
+
+		public FastWriter println(int x) {
+			return writeln(x);
+		}
+
+		public FastWriter println(long x) {
+			return writeln(x);
+		}
+
+		public FastWriter println(double x, int precision) {
+			return writeln(x, precision);
+		}
+
+		public FastWriter print(int... xs) {
+			return write(xs);
+		}
+
+		public FastWriter print(long... xs) {
+			return write(xs);
+		}
+
+		public FastWriter println(int... xs) {
+			return writeln(xs);
+		}
+
+		public FastWriter println(long... xs) {
+			return writeln(xs);
+		}
+
+		public FastWriter println(char[] line) {
+			return writeln(line);
+		}
+
+		public FastWriter println(char[]... map) {
+			return writeln(map);
+		}
+
+		public FastWriter println(String s) {
+			return writeln(s);
+		}
+
+		public FastWriter println() {
+			return writeln();
+		}
+	}
+
+	// Fast Inputs
+	static class FastScanner {
+		//I don't understand how this works lmao
+		private int BS = 1 << 16;
+		private char NC = (char) 0;
+		private byte[] buf = new byte[BS];
+		private int bId = 0, size = 0;
+		private char c = NC;
+		private double cnt = 1;
+		private BufferedInputStream in;
+
+		public FastScanner() {
+			in = new BufferedInputStream(System.in, BS);
+		}
+
+		public FastScanner(String s) {
+			try {
+				in = new BufferedInputStream(new FileInputStream(new File(s)), BS);
+			} catch (Exception e) {
+				in = new BufferedInputStream(System.in, BS);
+			}
+		}
+
+		private char getChar() {
+			while (bId == size) {
+				try {
+					size = in.read(buf);
+				} catch (Exception e) {
+					return NC;
+				}
+				if (size == -1)
+					return NC;
+				bId = 0;
+			}
+			return (char) buf[bId++];
+		}
+
+		public int nextInt() {
+			return (int) nextLong();
+		}
+
+		public int[] readArray(int N) {
+			int[] res = new int[N];
+			for (int i = 0; i < N; i++) {
+				res[i] = (int) nextLong();
+			}
+			return res;
+		}
+
+		public long[] readArrayLong(int N) {
+			long[] res = new long[N];
+			for (int i = 0; i < N; i++) {
+				res[i] = nextLong();
+			}
+			return res;
+		}
+
+		public int[][] readArrayMatrix(int N, int M, int Index) {
+			if (Index == 0) {
+				int[][] res = new int[N][M];
+				for (int i = 0; i < N; i++) {
+					for (int j = 0; j < M; j++)
+						res[i][j] = (int) nextLong();
+				}
+				return res;
+			}
+			int[][] res = new int[N][M];
+			for (int i = 1; i <= N; i++) {
+				for (int j = 1; j <= M; j++)
+					res[i][j] = (int) nextLong();
+			}
+			return res;
+
+		}
+
+		public long[][] readArrayMatrixLong(int N, int M, int Index) {
+			if (Index == 0) {
+				long[][] res = new long[N][M];
+				for (int i = 0; i < N; i++) {
+					for (int j = 0; j < M; j++)
+						res[i][j] = nextLong();
+				}
+				return res;
+			}
+			long[][] res = new long[N][M];
+			for (int i = 1; i <= N; i++) {
+				for (int j = 1; j <= M; j++)
+					res[i][j] = nextLong();
+			}
+			return res;
+
+		}
+
+		public long nextLong() {
+			cnt = 1;
+			boolean neg = false;
+			if (c == NC)
+				c = getChar();
+			for (; (c < '0' || c > '9'); c = getChar()) {
+				if (c == '-')
+					neg = true;
+			}
+			long res = 0;
+			for (; c >= '0' && c <= '9'; c = getChar()) {
+				res = (res << 3) + (res << 1) + c - '0';
+				cnt *= 10;
+			}
+			return neg ? -res : res;
+		}
+
+		public double nextDouble() {
+			double cur = nextLong();
+			return c != '.' ? cur : cur + nextLong() / cnt;
+		}
+
+		public double[] readArrayDouble(int N) {
+			double[] res = new double[N];
+			for (int i = 0; i < N; i++) {
+				res[i] = nextDouble();
+			}
+			return res;
+		}
+
+		public String next() {
+			StringBuilder res = new StringBuilder();
+			while (c <= 32)
+				c = getChar();
+			while (c > 32) {
+				res.append(c);
+				c = getChar();
+			}
+			return res.toString();
+		}
+
+		public String nextLine() {
+			StringBuilder res = new StringBuilder();
+			while (c <= 32)
+				c = getChar();
+			while (c != '\n') {
+				res.append(c);
+				c = getChar();
+			}
+			return res.toString();
+		}
+
+		public boolean hasNext() {
+			if (c > 32)
+				return true;
+			while (true) {
+				c = getChar();
+				if (c == NC)
+					return false;
+				else if (c > 32)
+					return true;
+			}
+		}
+	}
+
+}
+","import static java.lang.Math.max;
+import static java.lang.Math.min;
+import static java.lang.Math.abs;
+import java.util.*;
+import java.io.*;
+import java.math.*;
+
+/**
+ *
+ * @Har_Har_Mahadev
+ */
+
+/**
+ * Main , Solution , Remove Public
+ */
+public class E {
+
+	public static void process() throws IOException {
+
+		int n = sc.nextInt(),k = sc.nextInt();
+		int index[] = sc.readArray(k);
+		long t[] = sc.readArrayLong(k);
+		PriorityQueue<Pair> q = new PriorityQueue<Pair>();
+		for(int i = 0; i<k; i++)q.add(new Pair(t[i]+index[i], index[i]));
+		long ans[] = new long[n+1];
+		Arrays.fill(ans, INF);
+		int i = 1;
+		while(!q.isEmpty() && i<=n) {
+			while(!q.isEmpty() && q.peek().y < i) {
+				q.poll();
+			}
+			if(q.isEmpty())break;
+			Pair e = q.peek();
+			ans[i]=min(ans[i],e.x-i);
+			i++;
+		}
+//		System.out.println(Arrays.toString(ans));
+		q.clear();
+		for(i = 0; i<k; i++) {
+			q.add(new Pair(t[i]+n-index[i], index[i]));
+		}
+		i = n;
+		while(!q.isEmpty() && i>=1) {
+			while(!q.isEmpty() && q.peek().y > i) {
+				q.poll();
+			}
+			if(q.isEmpty())break;
+			Pair e = q.peek();
+			ans[i]=min(ans[i],e.x-(n-i));
+			i--;
+		}
+		for( i = 1; i<=n; i++)out.print(ans[i]+"" "");
+		out.println();
+
+	}
+
+	//=============================================================================
+	//--------------------------The End---------------------------------
+	//=============================================================================
+	private static long INF = 2000000000000000000L, M = 1000000007, MM = 998244353;
+	private static int N = 0;
+
+	private static void google(int tt) {
+		System.out.print(""Case #"" + (tt) + "": "");
+	}
+
+	static FastScanner sc;
+	static FastWriter out;
+
+	public static void main(String[] args) throws IOException {
+		boolean oj = true;
+		if (oj) {
+			sc = new FastScanner();
+			out = new FastWriter(System.out);
+		} else {
+			sc = new FastScanner(""input.txt"");
+			out = new FastWriter(""output.txt"");
+		}
+		long s = System.currentTimeMillis();
+		int t = 1;
+		t = sc.nextInt();
+		int TTT = 1;
+		while (t-- > 0) {
+			//			google(TTT++);
+			process();
+		}
+		out.flush();
+		//		tr(System.currentTimeMillis()-s+""ms"");
+	}
+
+	private static boolean oj = System.getProperty(""ONLINE_JUDGE"") != null;
+
+	private static void tr(Object... o) {
+		if (!oj)
+			System.err.println(Arrays.deepToString(o));
+	}
+
+	static class Pair implements Comparable<Pair> {
+		long x;
+		int y;
+
+		Pair(long x, int y) {
+			this.x = x;
+			this.y = y;
+		}
+
+		@Override
+		public int compareTo(Pair o) {
+			return Long.compare(this.x, o.x);
+		}
+
+		/*
+		 	@Override
+		    public boolean equals(Object o) {
+		        if (this == o) return true;
+		        if (!(o instanceof Pair)) return false;
+		        Pair key = (Pair) o;
+		        return x == key.x && y == key.y;
+		    }
+		 
+		    @Override
+		    public int hashCode() {
+		        int result = x;
+		        result = 31 * result + y;
+		        return result;
+		    }
+		*/
+	}
+
+	/////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+	static int ceil(int x, int y) {
+		return (x % y == 0 ? x / y : (x / y + 1));
+	}
+
+	static long ceil(long x, long y) {
+		return (x % y == 0 ? x / y : (x / y + 1));
+	}
+
+	static long sqrt(long z) {
+		long sqz = (long) Math.sqrt(z);
+		while (sqz * 1L * sqz < z) {
+			sqz++;
+		}
+		while (sqz * 1L * sqz > z) {
+			sqz--;
+		}
+		return sqz;
+	}
+
+	static int log2(int N) {
+		int result = (int) (Math.log(N) / Math.log(2));
+		return result;
+	}
+
+	public static long gcd(long a, long b) {
+		if (a > b)
+			a = (a + b) - (b = a);
+		if (a == 0L)
+			return b;
+		return gcd(b % a, a);
+	}
+
+	public static long lcm(long a, long b) {
+		return (a * b) / gcd(a, b);
+	}
+
+	public static int lower_bound(int[] arr, int x) {
+		int low = 0, high = arr.length - 1, mid = -1;
+		int ans = -1;
+		while (low <= high) {
+			mid = (low + high) / 2;
+
+			if (arr[mid] > x) {
+				high = mid - 1;
+			} else {
+				ans = mid;
+				low = mid + 1;
+			}
+		}
+
+		return ans;
+	}
+
+	public static int upper_bound(int[] arr, int x) {
+		int low = 0, high = arr.length - 1, mid = -1;
+		int ans = arr.length;
+		while (low < high) {
+			mid = (low + high) / 2;
+
+			if (arr[mid] >= x) {
+				ans = mid;
+				high = mid - 1;
+			} else {
+				low = mid + 1;
+			}
+		}
+
+		return ans;
+	}
+
+	static void ruffleSort(int[] a) {
+		Random get = new Random();
+		for (int i = 0; i < a.length; i++) {
+			int r = get.nextInt(a.length);
+			int temp = a[i];
+			a[i] = a[r];
+			a[r] = temp;
+		}
+		Arrays.sort(a);
+	}
+
+	static void ruffleSort(long[] a) {
+		Random get = new Random();
+		for (int i = 0; i < a.length; i++) {
+			int r = get.nextInt(a.length);
+			long temp = a[i];
+			a[i] = a[r];
+			a[r] = temp;
+		}
+		Arrays.sort(a);
+	}
+
+	static void reverseArray(int[] a) {
+		int n = a.length;
+		int arr[] = new int[n];
+		for (int i = 0; i < n; i++)
+			arr[i] = a[n - i - 1];
+		for (int i = 0; i < n; i++)
+			a[i] = arr[i];
+	}
+
+	static void reverseArray(long[] a) {
+		int n = a.length;
+		long arr[] = new long[n];
+		for (int i = 0; i < n; i++)
+			arr[i] = a[n - i - 1];
+		for (int i = 0; i < n; i++)
+			a[i] = arr[i];
+	}
+
+	//custom multiset (replace with HashMap if needed)
+	public static void push(TreeMap<Integer, Integer> map, int k, int v) {
+		//map[k] += v;
+		if (!map.containsKey(k))
+			map.put(k, v);
+		else
+			map.put(k, map.get(k) + v);
+	}
+
+	public static void pull(TreeMap<Integer, Integer> map, int k, int v) {
+		//assumes map[k] >= v
+		//map[k] -= v
+		int lol = map.get(k);
+		if (lol == v)
+			map.remove(k);
+		else
+			map.put(k, lol - v);
+	}
+
+	// compress Big value to Time Limit
+	public static int[] compress(int[] arr) {
+		ArrayList<Integer> ls = new ArrayList<Integer>();
+		for (int x : arr)
+			ls.add(x);
+		Collections.sort(ls);
+		HashMap<Integer, Integer> map = new HashMap<Integer, Integer>();
+		int boof = 1; //min value
+		for (int x : ls)
+			if (!map.containsKey(x))
+				map.put(x, boof++);
+		int[] brr = new int[arr.length];
+		for (int i = 0; i < arr.length; i++)
+			brr[i] = map.get(arr[i]);
+		return brr;
+	}
+
+	// Fast Writer 
+
+	public static class FastWriter {
+		private static final int BUF_SIZE = 1 << 13;
+		private final byte[] buf = new byte[BUF_SIZE];
+		private final OutputStream out;
+		private int ptr = 0;
+
+		private FastWriter() {
+			out = null;
+		}
+
+		public FastWriter(OutputStream os) {
+			this.out = os;
+		}
+
+		public FastWriter(String path) {
+			try {
+				this.out = new FileOutputStream(path);
+			} catch (FileNotFoundException e) {
+				throw new RuntimeException(""FastWriter"");
+			}
+		}
+
+		public FastWriter write(byte b) {
+			buf[ptr++] = b;
+			if (ptr == BUF_SIZE)
+				innerflush();
+			return this;
+		}
+
+		public FastWriter write(char c) {
+			return write((byte) c);
+		}
+
+		public FastWriter write(char[] s) {
+			for (char c : s) {
+				buf[ptr++] = (byte) c;
+				if (ptr == BUF_SIZE)
+					innerflush();
+			}
+			return this;
+		}
+
+		public FastWriter write(String s) {
+			s.chars().forEach(c -> {
+				buf[ptr++] = (byte) c;
+				if (ptr == BUF_SIZE)
+					innerflush();
+			});
+			return this;
+		}
+
+		private static int countDigits(int l) {
+			if (l >= 1000000000)
+				return 10;
+			if (l >= 100000000)
+				return 9;
+			if (l >= 10000000)
+				return 8;
+			if (l >= 1000000)
+				return 7;
+			if (l >= 100000)
+				return 6;
+			if (l >= 10000)
+				return 5;
+			if (l >= 1000)
+				return 4;
+			if (l >= 100)
+				return 3;
+			if (l >= 10)
+				return 2;
+			return 1;
+		}
+
+		public FastWriter write(int x) {
+			if (x == Integer.MIN_VALUE) {
+				return write((long) x);
+			}
+			if (ptr + 12 >= BUF_SIZE)
+				innerflush();
+			if (x < 0) {
+				write((byte) '-');
+				x = -x;
+			}
+			int d = countDigits(x);
+			for (int i = ptr + d - 1; i >= ptr; i--) {
+				buf[i] = (byte) ('0' + x % 10);
+				x /= 10;
+			}
+			ptr += d;
+			return this;
+		}
+
+		private static int countDigits(long l) {
+			if (l >= 1000000000000000000L)
+				return 19;
+			if (l >= 100000000000000000L)
+				return 18;
+			if (l >= 10000000000000000L)
+				return 17;
+			if (l >= 1000000000000000L)
+				return 16;
+			if (l >= 100000000000000L)
+				return 15;
+			if (l >= 10000000000000L)
+				return 14;
+			if (l >= 1000000000000L)
+				return 13;
+			if (l >= 100000000000L)
+				return 12;
+			if (l >= 10000000000L)
+				return 11;
+			if (l >= 1000000000L)
+				return 10;
+			if (l >= 100000000L)
+				return 9;
+			if (l >= 10000000L)
+				return 8;
+			if (l >= 1000000L)
+				return 7;
+			if (l >= 100000L)
+				return 6;
+			if (l >= 10000L)
+				return 5;
+			if (l >= 1000L)
+				return 4;
+			if (l >= 100L)
+				return 3;
+			if (l >= 10L)
+				return 2;
+			return 1;
+		}
+
+		public FastWriter write(long x) {
+			if (x == Long.MIN_VALUE) {
+				return write("""" + x);
+			}
+			if (ptr + 21 >= BUF_SIZE)
+				innerflush();
+			if (x < 0) {
+				write((byte) '-');
+				x = -x;
+			}
+			int d = countDigits(x);
+			for (int i = ptr + d - 1; i >= ptr; i--) {
+				buf[i] = (byte) ('0' + x % 10);
+				x /= 10;
+			}
+			ptr += d;
+			return this;
+		}
+
+		public FastWriter write(double x, int precision) {
+			if (x < 0) {
+				write('-');
+				x = -x;
+			}
+			x += Math.pow(10, -precision) / 2;
+			//		if(x < 0){ x = 0; }
+			write((long) x).write(""."");
+			x -= (long) x;
+			for (int i = 0; i < precision; i++) {
+				x *= 10;
+				write((char) ('0' + (int) x));
+				x -= (int) x;
+			}
+			return this;
+		}
+
+		public FastWriter writeln(char c) {
+			return write(c).writeln();
+		}
+
+		public FastWriter writeln(int x) {
+			return write(x).writeln();
+		}
+
+		public FastWriter writeln(long x) {
+			return write(x).writeln();
+		}
+
+		public FastWriter writeln(double x, int precision) {
+			return write(x, precision).writeln();
+		}
+
+		public FastWriter write(int... xs) {
+			boolean first = true;
+			for (int x : xs) {
+				if (!first)
+					write(' ');
+				first = false;
+				write(x);
+			}
+			return this;
+		}
+
+		public FastWriter write(long... xs) {
+			boolean first = true;
+			for (long x : xs) {
+				if (!first)
+					write(' ');
+				first = false;
+				write(x);
+			}
+			return this;
+		}
+
+		public FastWriter writeln() {
+			return write((byte) '\n');
+		}
+
+		public FastWriter writeln(int... xs) {
+			return write(xs).writeln();
+		}
+
+		public FastWriter writeln(long... xs) {
+			return write(xs).writeln();
+		}
+
+		public FastWriter writeln(char[] line) {
+			return write(line).writeln();
+		}
+
+		public FastWriter writeln(char[]... map) {
+			for (char[] line : map)
+				write(line).writeln();
+			return this;
+		}
+
+		public FastWriter writeln(String s) {
+			return write(s).writeln();
+		}
+
+		private void innerflush() {
+			try {
+				out.write(buf, 0, ptr);
+				ptr = 0;
+			} catch (IOException e) {
+				throw new RuntimeException(""innerflush"");
+			}
+		}
+
+		public void flush() {
+			innerflush();
+			try {
+				out.flush();
+			} catch (IOException e) {
+				throw new RuntimeException(""flush"");
+			}
+		}
+
+		public FastWriter print(byte b) {
+			return write(b);
+		}
+
+		public FastWriter print(char c) {
+			return write(c);
+		}
+
+		public FastWriter print(char[] s) {
+			return write(s);
+		}
+
+		public FastWriter print(String s) {
+			return write(s);
+		}
+
+		public FastWriter print(int x) {
+			return write(x);
+		}
+
+		public FastWriter print(long x) {
+			return write(x);
+		}
+
+		public FastWriter print(double x, int precision) {
+			return write(x, precision);
+		}
+
+		public FastWriter println(char c) {
+			return writeln(c);
+		}
+
+		public FastWriter println(int x) {
+			return writeln(x);
+		}
+
+		public FastWriter println(long x) {
+			return writeln(x);
+		}
+
+		public FastWriter println(double x, int precision) {
+			return writeln(x, precision);
+		}
+
+		public FastWriter print(int... xs) {
+			return write(xs);
+		}
+
+		public FastWriter print(long... xs) {
+			return write(xs);
+		}
+
+		public FastWriter println(int... xs) {
+			return writeln(xs);
+		}
+
+		public FastWriter println(long... xs) {
+			return writeln(xs);
+		}
+
+		public FastWriter println(char[] line) {
+			return writeln(line);
+		}
+
+		public FastWriter println(char[]... map) {
+			return writeln(map);
+		}
+
+		public FastWriter println(String s) {
+			return writeln(s);
+		}
+
+		public FastWriter println() {
+			return writeln();
+		}
+	}
+
+	// Fast Inputs
+	static class FastScanner {
+		//I don't understand how this works lmao
+		private int BS = 1 << 16;
+		private char NC = (char) 0;
+		private byte[] buf = new byte[BS];
+		private int bId = 0, size = 0;
+		private char c = NC;
+		private double cnt = 1;
+		private BufferedInputStream in;
+
+		public FastScanner() {
+			in = new BufferedInputStream(System.in, BS);
+		}
+
+		public FastScanner(String s) {
+			try {
+				in = new BufferedInputStream(new FileInputStream(new File(s)), BS);
+			} catch (Exception e) {
+				in = new BufferedInputStream(System.in, BS);
+			}
+		}
+
+		private char getChar() {
+			while (bId == size) {
+				try {
+					size = in.read(buf);
+				} catch (Exception e) {
+					return NC;
+				}
+				if (size == -1)
+					return NC;
+				bId = 0;
+			}
+			return (char) buf[bId++];
+		}
+
+		public int nextInt() {
+			return (int) nextLong();
+		}
+
+		public int[] readArray(int N) {
+			int[] res = new int[N];
+			for (int i = 0; i < N; i++) {
+				res[i] = (int) nextLong();
+			}
+			return res;
+		}
+
+		public long[] readArrayLong(int N) {
+			long[] res = new long[N];
+			for (int i = 0; i < N; i++) {
+				res[i] = nextLong();
+			}
+			return res;
+		}
+
+		public int[][] readArrayMatrix(int N, int M, int Index) {
+			if (Index == 0) {
+				int[][] res = new int[N][M];
+				for (int i = 0; i < N; i++) {
+					for (int j = 0; j < M; j++)
+						res[i][j] = (int) nextLong();
+				}
+				return res;
+			}
+			int[][] res = new int[N][M];
+			for (int i = 1; i <= N; i++) {
+				for (int j = 1; j <= M; j++)
+					res[i][j] = (int) nextLong();
+			}
+			return res;
+
+		}
+
+		public long[][] readArrayMatrixLong(int N, int M, int Index) {
+			if (Index == 0) {
+				long[][] res = new long[N][M];
+				for (int i = 0; i < N; i++) {
+					for (int j = 0; j < M; j++)
+						res[i][j] = nextLong();
+				}
+				return res;
+			}
+			long[][] res = new long[N][M];
+			for (int i = 1; i <= N; i++) {
+				for (int j = 1; j <= M; j++)
+					res[i][j] = nextLong();
+			}
+			return res;
+
+		}
+
+		public long nextLong() {
+			cnt = 1;
+			boolean neg = false;
+			if (c == NC)
+				c = getChar();
+			for (; (c < '0' || c > '9'); c = getChar()) {
+				if (c == '-')
+					neg = true;
+			}
+			long res = 0;
+			for (; c >= '0' && c <= '9'; c = getChar()) {
+				res = (res << 3) + (res << 1) + c - '0';
+				cnt *= 10;
+			}
+			return neg ? -res : res;
+		}
+
+		public double nextDouble() {
+			double cur = nextLong();
+			return c != '.' ? cur : cur + nextLong() / cnt;
+		}
+
+		public double[] readArrayDouble(int N) {
+			double[] res = new double[N];
+			for (int i = 0; i < N; i++) {
+				res[i] = nextDouble();
+			}
+			return res;
+		}
+
+		public String next() {
+			StringBuilder res = new StringBuilder();
+			while (c <= 32)
+				c = getChar();
+			while (c > 32) {
+				res.append(c);
+				c = getChar();
+			}
+			return res.toString();
+		}
+
+		public String nextLine() {
+			StringBuilder res = new StringBuilder();
+			while (c <= 32)
+				c = getChar();
+			while (c != '\n') {
+				res.append(c);
+				c = getChar();
+			}
+			return res.toString();
+		}
+
+		public boolean hasNext() {
+			if (c > 32)
+				return true;
+			while (true) {
+				c = getChar();
+				if (c == NC)
+					return false;
+				else if (c > 32)
+					return true;
+			}
+		}
+	}
+
+}
+",1
+0922b7e7,c34bb733,"import java.io.*;
+import java.util.*;
+
+public class PhoenixAndTowers {
+	public static void main(String[] args) throws IOException {
+		// BufferedReader in = new BufferedReader(new FileReader(""PhoenixAndTowers.in""));
+		// PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter(""PhoenixAndTowers.out"")));
+		BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
+		PrintWriter out = new PrintWriter(System.out);
+
+		int T = Integer.parseInt(in.readLine());
+		for (int i = 0; i < T; i++) {
+			StringTokenizer st = new StringTokenizer(in.readLine());
+			int N = Integer.parseInt(st.nextToken());
+			int M = Integer.parseInt(st.nextToken());
+			int X = Integer.parseInt(st.nextToken());
+			PriorityQueue<Tower> towers = new PriorityQueue<Tower>();
+			for (int j = 1; j <= M; j++) towers.add(new Tower(j, 0));
+			out.println(""YES"");
+			st = new StringTokenizer(in.readLine());
+			for (int j = 0; j < N; j++) {
+				Tower t = towers.remove();
+				t.size += Integer.parseInt(st.nextToken());
+				towers.add(t);
+				out.print(t.idx + "" "");
+			}
+			out.println();
+		}
+
+		out.close();
+		in.close();
+	}
+	
+	public static class Tower implements Comparable<Tower> {
+		int idx, size;
+		public Tower(int idx, int size) {
+			this.idx = idx;
+			this.size = size;
+		}
+		@Override
+		public int compareTo(Tower o) {
+			return size - o.size;
+		}
+	}
+}","//package pack;
+import java.io.*;
+
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.*;
+import java.io.*;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.*;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.*;
+import java.math.*;
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.StringTokenizer;
+import java.util.Vector;
+import static java.lang.Math.sqrt;
+import static java.lang.Math.floor;
+
+
+
+
+
+
+public class topcoder {
+   
+	static class pair{
+		 
+		 int first;
+		 int second;
+		  public pair(int first, int second) {
+			  this.first = first;
+			  this.second = second;
+		  }
+	}
+
+
+	static class Compare{
+		
+		 static void compare(ArrayList<pair>arr, int n) {
+			 
+			 Collections.sort(arr,new Comparator<pair>() {
+				 public int compare(pair p1, pair p2) {
+					 return p1.first-p2.first;
+				 }
+			 });
+		
+	}
+	}
+	
+	
+static class pairr implements  Comparable<pairr>{
+	Integer value;
+	Integer index;
+	
+	   public pairr(Integer value, Integer index) {
+		    this.value = value;
+		    this.index = index;
+	   }
+	   @Override
+	   
+	   public int compareTo(pairr o) {
+		   return value-o.value;
+	   }
+}
+
+
+
+	 static class Key<K1, K2>
+	{
+	    public K1 key1;
+	    public K2 key2;
+	 
+	    public Key(K1 key1, K2 key2)
+	    {
+	        this.key1 = key1;
+	        this.key2 = key2;
+	    }
+	 
+	    @Override
+	    public boolean equals(Object o)
+	    {
+	        if (this == o) {
+	            return true;
+	        }
+	 
+	        if (o == null || getClass() != o.getClass()) {
+	            return false;
+	        }
+	 
+	        Key key = (Key) o;
+	        if (key1 != null ? !key1.equals(key.key1) : key.key1 != null) {
+	            return false;
+	        }
+	 
+	        if (key2 != null ? !key2.equals(key.key2) : key.key2 != null) {
+	            return false;
+	        }
+	 
+	        return true;
+	    }
+	 
+	    @Override
+	    public int hashCode()
+	    {
+	        int result = key1 != null ? key1.hashCode() : 0;
+	        result = 31 * result + (key2 != null ? key2.hashCode() : 0);
+	        return result;
+	    }
+	 
+	    @Override
+	    public String toString() {
+	        return ""["" + key1 + "", "" + key2 + ""]"";
+	    }
+	}
+	
+	
+	 public static int sumOfDigits (long n) {
+		 
+		 int sum = 0;
+		 
+		 while(n > 0) {
+			 sum += n%10;
+			 n /= 10;
+		 }
+		 
+		 return sum;
+	 
+	 }
+	 
+	 
+	 public static long binary_search(int s, int e, long num, long []ar) {
+		 
+		 if(s > e) {
+			 return -1;
+		 }	 
+			 
+		 
+		     int mid = (s+e)/2;
+		     
+		      if(s == e && ar[s] >= num) {
+		    	  return ar[s];
+		      }else if(s == e && ar[s] < num) {
+		    	  return -1;
+		      }else if(ar[mid] < num) {
+		    	  return binary_search(mid+1,e,num,ar);
+		      }else if(ar[mid] >= num) {
+		    	    return binary_search(s,mid,num,ar);
+		      }
+		      
+		      return -1;
+		 
+	 }
+	 
+	 
+	 public static int index_search(int s, int e, long num, long []ar) {
+		 
+		 if(s > e) {
+			 return -1;
+		 }	 
+			 
+		 
+		     int mid = (s+e)/2;
+		     
+		      if(s == e && ar[s] >= num) {
+		    	  return s;
+		      }else if(s == e && ar[s] < num) {
+		    	  return -1;
+		      }else if(ar[mid] < num) {
+		    	  return index_search(mid+1,e,num,ar);
+		      }else if(ar[mid] >= num) {
+		    	    return index_search(s,mid,num,ar);
+		      }
+		      
+		      return -1;
+		 
+	 }
+		     public static void swap(int []ar, int i, int j) {
+		    	 
+		    	 
+		    	 for(int k= j; k >= i; k--) {
+		    		 int temp = ar[k];
+		    		 ar[k] = ar[k+1];
+		    		 ar[k+1] = temp;
+		    	 }
+		     }
+		     
+		     public static boolean digit_exists(long n) {
+		    	 
+		    	 while(n > 0) {
+		    		 if(n%10 == 9)
+		    			 return true;
+		    		 n = n/10;
+		    	 }
+		    	 
+		    	 return false;
+		     }
+		     public static int log(int n) {
+		    	 
+		    	 int c = 0;
+		    	 while(n > 0) {
+		    		 c++;
+		    		 n /=2;
+		    	 }
+		    	 
+		    	 return c;
+		     }
+			  public static int findOr(int[]bits){
+	    	        int or=0;
+	    	            for(int i=0;i<32;i++){
+	    	                or=or<<1;
+	    	                if(bits[i]>0)
+	    	                    or=or+1;
+	    	            }
+	    	        return or;
+	    	    }
+			  
+			  static void simpleSieve(int limit, Vector<Integer> prime)
+			    {
+			        // Create a boolean array ""mark[0..n-1]"" and initialize
+			        // all entries of it as true. A value in mark[p] will
+			        // finally be false if 'p' is Not a prime, else true.
+			        boolean mark[] = new boolean[limit+1];
+			         
+			        for (int i = 0; i < mark.length; i++)
+			            mark[i] = true;
+			      
+			        for (int p=2; p*p<limit; p++)
+			        {
+			            // If p is not changed, then it is a prime
+			            if (mark[p] == true)
+			            {
+			                // Update all multiples of p
+			                for (int i=p*p; i<limit; i+=p)
+			                    mark[i] = false;
+			            }
+			        }
+			      
+			        // Print all prime numbers and store them in prime
+			        for (int p=2; p<limit; p++)
+			        {
+			            if (mark[p] == true)
+			            {
+			                prime.add(p);
+			             
+			            }
+			        }
+			    }
+			      
+			    // Prints all prime numbers smaller than 'n'
+			public    static void segmentedSieve(int n, ArrayList<Integer>l)
+			    {
+			        // Compute all primes smaller than or equal
+			        // to square root of n using simple sieve
+			        int limit = (int) (floor(sqrt(n))+1);
+			        Vector<Integer> prime = new Vector<>(); 
+			  
+			        simpleSieve(limit, prime);
+			      
+			        // Divide the range [0..n-1] in different segments
+			        // We have chosen segment size as sqrt(n).
+			        int low  = limit;
+			        int high = 2*limit;
+			      
+			        // While all segments of range [0..n-1] are not processed,
+			        // process one segment at a time
+			        while (low < n)
+			        {
+			            if (high >= n)
+			                high = n;
+			 
+			            // To mark primes in current range. A value in mark[i]
+			            // will finally be false if 'i-low' is Not a prime,
+			            // else true.
+			            boolean mark[] = new boolean[limit+1];
+			             
+			            for (int i = 0; i < mark.length; i++)
+			                mark[i] = true;
+			      
+			            // Use the found primes by simpleSieve() to find
+			            // primes in current range
+			            for (int i = 0; i < prime.size(); i++)
+			            {
+			                // Find the minimum number in [low..high] that is
+			                // a multiple of prime.get(i) (divisible by prime.get(i))
+			                // For example, if low is 31 and prime.get(i) is 3,
+			                // we start with 33.
+			                int loLim = (int) (floor(low/prime.get(i)) * prime.get(i));
+			                if (loLim < low)
+			                    loLim += prime.get(i);
+			      
+			                /*  Mark multiples of prime.get(i) in [low..high]:
+			                    We are marking j - low for j, i.e. each number
+			                    in range [low, high] is mapped to [0, high-low]
+			                    so if range is [50, 100]  marking 50 corresponds
+			                    to marking 0, marking 51 corresponds to 1 and
+			                    so on. In this way we need to allocate space only
+			                    for range  */
+			                for (int j=loLim; j<high; j+=prime.get(i))
+			                    mark[j-low] = false;
+			            }
+			      
+			            // Numbers which are not marked as false are prime
+			            for (int i = low; i<high; i++)
+			                if (mark[i - low] == true)
+			                   l.add(i);
+			      
+			            // Update low and high for next segment
+			            low  = low + limit;
+			            high = high + limit;
+			        }
+			    }
+			    
+			    public static int find_indexNum(long k) {
+			    	
+			    	long k1 = k;
+			    	int power = 0;
+			    	
+			    	while(k > 0) {
+			    		power++;
+			    		k /=2 ;
+			    	}
+			    	
+			    	long check = (long)Math.pow(2, power-1);
+			    	if(k1 == check) {
+			    		return power;
+			    	}
+			//   System.out.println(power);
+			    	long f = (long)Math.pow(2, power-1);
+			    	long rem = k1-f;
+			    	return find_indexNum(rem);
+			    }
+			    
+			 public static void sortPair(ArrayList<pair>l, int n) {
+				  n = l.size();
+				  
+				  Compare obj = new Compare();
+				  obj.compare(l, n);
+			 }
+               
+            
+			  public static int add(long n, long num, long a, int i) {
+				//System.out.println(num);
+				  if(num > n)return -1;
+				
+				  if(num == n) {
+					  
+					  return i;
+				  }
+				  
+				if(a < 2050)return -1;
+				  
+				
+				 
+				  long temp = num+a;
+				  
+				  if(temp <= n) {
+				return	  add(n,temp,a,i+1);
+				  }else if(temp > n){
+					  a /= 10;
+					  return add(n,num,a,i);
+				  }
+				  
+			      return -1;
+				  }
+			
+				   
+		public static void shuffle(int []array, int num,int t_index,  boolean []vis, int m ) {	  
+			 
+		
+		for(int i = 0; i < m; i++) {
+			if(vis[i] == false) {
+				
+				
+				int temp = array[i];
+		          if(i < t_index) {
+		        	  vis[i] = true;
+		          }
+				array[i] = num;
+				array[t_index] = temp;
+			//	System.out.println(array[t_index]+"" ""+array[i]);
+				break;
+			}
+		}
+		}
+		
+		public static void rotate(int []arr,int j, int times, int m) {
+			
+		
+			
+			 if(j == 0) {
+				 int temp1 = arr[0];
+				 arr[0] = arr[times];
+				 arr[times] = temp1;
+				 
+			 }else {
+			 int temp = arr[j];
+			 int z = arr[0];
+				
+			 arr[0] = arr[times];
+			
+			 arr[j] = z;
+			 arr[times] =  temp;
+			    
+			
+			
+		}
+
+		}
+		
+		public static void recur(int i,int A, int B,int []dp,int []metal, int n, boolean took,int ind) {
+			
+		  if(i-A <= 0 && i-B <= 0)return;
+		    int count = 0;
+		    
+		    for(int j = 1; j <= n; j++) {
+		    	if(dp[j] >= metal[j]) {
+		    		count++;
+		    	}
+		    }
+		    
+		    if(count == n)return;
+			if(i-A >= 0 && i-B >= 0 && dp[i] > 0 && dp[i] > metal[i]) {
+			dp[i]--;
+		
+			dp[i-A]++;
+		
+			dp[i-B]++;
+			}
+			
+			
+			if(ind == 6) {
+		//	System.out.println(Arrays.toString(dp));
+			}
+			recur(i-A,A,B,dp,metal,n,took,ind);
+			recur(i-B,A,B,dp,metal,n,took,ind);
+		}
+		
+		
+		public static boolean isPrime(int n) { 
+	        if (n <= 1) return false; 
+	        if (n <= 3) return true; 
+	        if (n % 2 == 0 || n % 3 == 0) return false; 
+	        for (int i = 5; i * i <= n; i = i + 6) 
+	            if (n % i == 0 || n % (i + 2) == 0) 
+	            return false; 
+	        return true; 
+	    }
+		
+		  public static boolean[] getSieve(int n) {
+		        boolean[] isPrime = new boolean[n+1];
+		        for (int i = 2; i <= n; i++) isPrime[i] = true;
+		        for (int i = 2; i*i <= n; i++) if (isPrime[i]) 
+		                for (int j = i; i*j <= n; j++) isPrime[i*j] = false;
+		        return isPrime;
+		    }
+		  
+
+		    public static int gcd(int a, int b) { 
+		    	int tmp = 0;
+		    	while(b != 0) {
+		    		tmp = b;
+		    		b = a%b;
+		    		a = tmp;
+		    	}
+		    	return a;
+		    }
+		    
+		    
+		    public static long gcd(long a, long b) { 
+		    	long tmp = 0;
+		    	while(b != 0) {
+		    		tmp = b;
+		    		b = a%b;
+		    		a = tmp;
+		    	}
+		    	return a;
+		    }
+		    
+		
+		public static boolean poss( int r, int c, int k, int n, int m,boolean [][]vis) {
+			
+			if(k < 0)return false;
+			if(r > n || c > m || r < 1 || c < 1)return false;
+			
+			if(r == n &&  c == m &&  k == 0) {
+			//	System.out.println(k);
+				return true;
+			}
+              if(vis[r][c] == true) {
+            	  return false;
+              }
+              vis[r][c] = true;
+			
+			
+		return	poss(r+1,c,k-c,n,m,vis) || poss(r,c+1,k-r,n,m,vis);
+			
+			
+		}
+			
+	    public static void dfs(LinkedList<Integer>[]list, HashMap<Integer,Integer>map, int parent, int n) {
+	    	
+	    	Stack<Integer>st = new Stack<>();
+	   
+	    	
+	    }
+	   public static boolean pos(int n) {
+		
+		   
+		   int i = 1;
+		   boolean pos = false;
+		   
+		   while(i*i <= n) {
+			   if(i*i*2 == n || i*i*4 == n) {
+				   pos = true;
+				   break;
+			   }
+			   i++;
+		   }
+		   if(pos)return true;
+		    return false;
+		   
+	   }
+	  
+			
+	    public static void main(String args[])throws IOException{
+			 
+	    	//	 System.setIn(new FileInputStream(""Case.txt""));
+	    		 BufferedReader ob = new BufferedReader(new InputStreamReader(System.in));
+	    	    
+	    		 
+	    		 int t = Integer.parseInt(ob.readLine());
+	    		 
+	    		 
+	    		 while( t--> 0) {
+	    		
+	    		StringTokenizer	 st = new StringTokenizer(ob.readLine());
+	    			 int n = Integer.parseInt(st.nextToken());
+	    			 int m = Integer.parseInt(st.nextToken());
+	    			 int x = Integer.parseInt(st.nextToken());
+	    			 
+	    			 int []ar = new int[n];
+	    			 st = new StringTokenizer(ob.readLine());
+	    			 PriorityQueue<Integer>pq = new PriorityQueue<>();
+	    			 
+	    			 for(int i = 0; i < n; i++) {
+	    				 ar[i] = Integer.parseInt(st.nextToken());
+	    				 pq.add(ar[i]);
+	    			 }
+	    			 
+	    			 
+	    	PriorityQueue<pairr>p = new PriorityQueue<>();
+	    	for(int i =0; i < n; i++) {
+	    		p.add(new pairr(ar[i],i));
+	    	}
+	    	int []ans = new int[n];
+	    	
+	    	
+	    	for(int i = 0; i < n; i++) {
+	    	pairr a = p.poll();
+	    	ans[a.index] = (i%m)+1;
+	    	}
+	    	
+	    	System.out.println(""YES"");
+	    	for(int i = 0; i < n; i++ ) {
+	    		System.out.print(ans[i]+"" "");
+	    	}
+	    	System.out.println();
+	    		 }
+	    }
+}
+	    	
+	    	
+	    	
+	    				 ",0
+3a12e509,47310b0e,"import java.io.*;
+import java.util.*;
+
+
+public class Practice
+{
+//	static final long mod=7420738134811L;
+	static int mod=1000000007;
+	static final int size=501;
+	static FastReader sc=new FastReader(System.in);
+//	static Reader sc=new Reader();
+	static  PrintWriter out=new PrintWriter(System.out);
+	static long[] factorialNumInverse;
+	static long[] naturalNumInverse;	
+	static int[] sp;
+	static long[] fact;
+	static ArrayList<Integer> pr;
+	public static void main(String[] args) throws IOException
+	{
+//		System.setIn(new FileInputStream(""input.txt""));
+//		System.setOut(new PrintStream(""output.txt""));
+//		factorial(mod);
+//		InverseofNumber(mod);
+//		InverseofFactorial(mod);
+//		make_seive();
+		int t=1;
+		t=sc.nextInt();
+		while(t-->0)
+			solve();
+		out.close();
+		out.flush();
+	}
+	static void solve() throws IOException
+	{
+		int n=sc.nextInt();
+		int arr[]=new int[n];
+		for(int i=0;i<n;i++)
+			arr[i]=sc.nextInt();
+		String s=sc.next();
+		ArrayList<Integer> blue=new ArrayList<Integer>();
+		ArrayList<Integer> red=new ArrayList<Integer>();
+		for(int i=0;i<n;i++)
+		{
+			if(s.charAt(i)=='B')
+				blue.add(arr[i]);
+			else
+				red.add(arr[i]);
+		}
+		Collections.sort(blue);
+		Collections.sort(red);
+		for(int i=0;i<blue.size();i++)
+		{
+			if(blue.get(i)<i+1)
+			{
+				out.println(""NO"");
+				return;
+			}
+		}
+		for(int i=0;i<red.size();i++)
+		{
+			if(red.get(i)>i+1+blue.size())
+			{
+				out.println(""NO"");
+				return;
+			}
+		}
+		out.println(""YES"");
+	}
+	static class Pair implements Cloneable, Comparable<Pair>
+	{
+		int x,y;
+		Pair(int a,int b)
+		{
+			this.x=a;
+			this.y=b;
+		}
+		@Override
+		public boolean equals(Object obj) 
+		{
+			if(obj instanceof  Pair)
+			{
+				Pair p=(Pair)obj;
+				return p.x==this.x && p.y==this.y;
+			}
+			return false;
+		}
+		@Override
+		public int hashCode() 
+		{
+			return Math.abs(x)+500*Math.abs(y);
+		}
+		@Override
+		public String toString() 
+		{
+			return ""(""+x+"" ""+y+"")"";
+		}
+		@Override
+		protected Pair clone() throws CloneNotSupportedException {
+			return new Pair(this.x,this.y);
+		}
+		@Override
+		public int compareTo(Pair a) 
+		{
+			int t= this.x-a.x;
+			if(t!=0)
+				return t;
+			else
+				return this.y-a.y;
+		}
+		public void swap()
+		{
+			this.y=this.y+this.x;
+			this.x=this.y-this.x;
+			this.y=this.y-this.x;			
+		}
+	}
+	static class Tuple implements Cloneable, Comparable<Tuple>
+	{
+		int x,y,z;
+		Tuple(int a,int b,int c)
+		{
+			this.x=a;
+			this.y=b;
+			this.z=c;
+		}
+		public boolean equals(Object obj) 
+		{
+			if(obj instanceof  Tuple)
+			{
+				Tuple p=(Tuple)obj;
+				return p.x==this.x && p.y==this.y && p.z==this.z;
+			}
+			return false;
+		}
+		@Override
+		public int hashCode() 
+		{
+			return (this.x+501*this.y);
+		}
+		@Override
+		public String toString() 
+		{
+			return ""(""+x+"",""+y+"",""+z+"")"";
+		}
+		@Override
+		protected Tuple clone() throws CloneNotSupportedException {
+			return new Tuple(this.x,this.y,this.z);
+		}
+		@Override
+		public int compareTo(Tuple a) 
+		{
+			int x=this.z-a.z;
+			if(x!=0)
+				return x;
+			int X= this.x-a.x;
+			if(X!=0)
+				return X;
+			return a.y-this.y;
+		}
+	}
+	static void arraySort(int arr[])
+	{
+		ArrayList<Integer> a=new ArrayList<Integer>();
+		for (int i = 0; i < arr.length; i++) {
+			a.add(arr[i]);
+		}
+		Collections.sort(a);
+		for (int i = 0; i < arr.length; i++) {
+			arr[i]=a.get(i);
+		}
+	}
+	static void arraySort(long arr[])
+	{
+		ArrayList<Long> a=new ArrayList<Long>();
+		for (int i = 0; i < arr.length; i++) {
+			a.add(arr[i]);
+		}
+		Collections.sort(a);
+		for (int i = 0; i < arr.length; i++) {
+			arr[i]=a.get(i);
+		}
+	}
+	static HashSet<Integer> primeFactors(int n)
+	{
+		HashSet<Integer> ans=new HashSet<Integer>();
+		if(n%2==0)
+		{
+			ans.add(2);
+			while((n&1)==0)
+				n=n>>1;
+		}
+		for(int i=3;i*i<=n;i+=2)
+		{
+			if(n%i==0)
+			{
+				ans.add(i);
+				while(n%i==0)
+					n=n/i;
+			}
+		}
+		if(n!=1)
+			ans.add(n);
+		return ans;
+	}
+	static void make_seive()
+	{
+		sp=new int[size];
+		pr=new ArrayList<Integer>();
+		for (int i=2; i<size; ++i) {
+		    if (sp[i] == 0) {
+		        sp[i] = i;
+		        pr.add(i);
+		    }
+		    for (int j=0; j<(int)pr.size() && pr.get(j)<=sp[i] && i*pr.get(j)<size; ++j)
+		        sp[i * pr.get(j)] = pr.get(j);
+		}
+	}
+	public static void InverseofNumber(int p)
+	{
+		naturalNumInverse=new long[size];
+	    naturalNumInverse[0] = naturalNumInverse[1] = 1;
+	    for(int i = 2; i < size; i++)
+	        naturalNumInverse[i] = naturalNumInverse[p % i] * (long)(p - p / i) % p;
+	}
+	// Function to precompute inverse of factorials
+	public static void InverseofFactorial(int p)
+	{
+		factorialNumInverse=new long[size];
+	    factorialNumInverse[0] = factorialNumInverse[1] = 1;
+	    // pre-compute inverse of natural numbers
+	    for(int i = 2; i < size; i++)
+	        factorialNumInverse[i] = (naturalNumInverse[i] * factorialNumInverse[i - 1]) % p;
+	}
+	// Function to calculate factorial of 1 to 200001
+	public static void factorial(int p)
+	{
+		fact=new long[size];
+	    fact[0] = 1;
+	    for(int i = 1; i < size; i++)
+	        fact[i] = (fact[i - 1] * (long)i) % p;
+	}
+	 
+	// Function to return nCr % p in O(1) time
+	public static long Binomial(int N, int R)
+	{
+		if(R<0)
+			return 1;
+	    // n C r = n!*inverse(r!)*inverse((n-r)!)
+	    long ans = ((fact[N] * factorialNumInverse[R]) % mod * factorialNumInverse[N - R]) % mod;
+	    return ans;
+	}
+	static int findXOR(int x)	//from 0 to x
+	{
+		if(x<0)
+			return 0;
+		if(x%4==0)
+			return x;
+		if(x%4==1)
+			return 1;
+		if(x%4==2)
+			return x+1;
+		return 0;
+	}
+	static boolean isPrime(long x)
+	{
+		if(x==1)
+			return false;
+		if(x<=3)
+			return true;
+		if(x%2==0 || x%3==0)
+			return false;
+		for(int i=5;i<=Math.sqrt(x);i+=2)
+			if(x%i==0)
+				return false;
+		return true;
+	}
+	static long gcd(long a,long b)
+	{
+		return (b==0)?a:gcd(b,a%b);
+	}
+	static int gcd(int a,int b)
+	{
+		return (b==0)?a:gcd(b,a%b);
+	}
+	static class Node
+	{
+		int vertex;
+		HashSet<Edge> adj;
+		int taxC,taxD;
+		Node(int ver)
+		{
+			vertex=ver;
+			taxD=0;
+			taxC=0;
+			adj=new HashSet<Edge>();
+		}
+		@Override
+		public String toString() 
+		{
+			return vertex+"" "";
+		}
+	}
+	static class Edge
+	{
+		Node to;
+		int cost;
+		Edge(Node t,int c)
+		{
+			this.to=t;
+			this.cost=c;
+		}
+		@Override
+		public String toString() {
+			return ""(""+to.vertex+"",""+cost+"") "";
+		}
+	}
+	static long power(long x, long y)
+	  {
+		if(x<=0)
+			return 1;
+	    long res = 1; 
+	    x = x % mod; 
+	    if (x == 0)
+	      return 0; 
+	    while (y > 0)
+	    {
+	    	if ((y & 1) != 0)
+	    		res = (res * x) % mod;
+	    	
+	    	y = y >> 1; // y = y/2
+	    	x = (x * x) % mod;
+	    }
+	    return res;
+	  }
+	static long binomialCoeff(long n, long k)
+    {
+		if(n<k)
+			return 0;
+        long res = 1;
+//        if(k>n)
+//        	return 0;
+        // Since C(n, k) = C(n, n-k)
+        if (k > n - k)
+            k = n - k;
+ 
+        // Calculate value of
+        // [n * (n-1) *---* (n-k+1)] / [k * (k-1) *----* 1]
+        for (long i = 0; i < k; ++i) {
+            res *= (n - i);
+            res /= (i + 1);
+        }
+ 
+        return res;
+    }
+	static class FastReader
+	{
+        byte[] buf = new byte[2048];
+        int index, total;
+        InputStream in;
+ 
+        FastReader(InputStream is) 
+        {
+            in = is;
+        }
+ 
+        int scan() throws IOException 
+        {
+            if (index >= total) {
+                index = 0;
+                total = in.read(buf);
+                if (total <= 0) {
+                    return -1;
+                }
+            }
+            return buf[index++];
+        }
+ 
+        String next() throws IOException 
+        {
+            int c;
+            for (c = scan(); c <= 32; c = scan());
+            StringBuilder sb = new StringBuilder();
+            for (; c > 32; c = scan()) {
+                sb.append((char) c);
+            }
+            return sb.toString();
+        }
+ 
+        int nextInt() throws IOException 
+        {
+            int c, val = 0;
+            for (c = scan(); c <= 32; c = scan());
+            boolean neg = c == '-';
+            if (c == '-' || c == '+') {
+                c = scan();
+            }
+            for (; c >= '0' && c <= '9'; c = scan()) {
+                val = (val << 3) + (val << 1) + (c & 15);
+            }
+            return neg ? -val : val;
+        }
+ 
+        long nextLong() throws IOException 
+        {
+            int c;
+            long val = 0;
+            for (c = scan(); c <= 32; c = scan());
+            boolean neg = c == '-';
+            if (c == '-' || c == '+') {
+                c = scan();
+            }
+            for (; c >= '0' && c <= '9'; c = scan()) {
+                val = (val << 3) + (val << 1) + (c & 15);
+            }
+            return neg ? -val : val;
+        }
+    }
+	static class Reader 
+	{
+        final private int BUFFER_SIZE = 1 << 16;
+        private DataInputStream din;
+        private byte[] buffer;
+        private int bufferPointer, bytesRead;
+ 
+        public Reader()
+        {
+            din = new DataInputStream(System.in);
+            buffer = new byte[BUFFER_SIZE];
+            bufferPointer = bytesRead = 0;
+        }
+ 
+        public Reader(String file_name) throws IOException
+        {
+            din = new DataInputStream(
+                new FileInputStream(file_name));
+            buffer = new byte[BUFFER_SIZE];
+            bufferPointer = bytesRead = 0;
+        }
+ 
+        public String readLine() throws IOException
+        {
+            byte[] buf = new byte[64]; // line length
+            int cnt = 0, c;
+            while ((c = read()) != -1) {
+                if (c == '\n') {
+                    if (cnt != 0) {
+                        break;
+                    }
+                    else {
+                        continue;
+                    }
+                }
+                buf[cnt++] = (byte)c;
+            }
+            return new String(buf, 0, cnt);
+        }
+ 
+        public int nextInt() throws IOException
+        {
+            int ret = 0;
+            byte c = read();
+            while (c <= ' ') {
+                c = read();
+            }
+            boolean neg = (c == '-');
+            if (neg)
+                c = read();
+            do {
+                ret = ret * 10 + c - '0';
+            } while ((c = read()) >= '0' && c <= '9');
+ 
+            if (neg)
+                return -ret;
+            return ret;
+        }
+ 
+        public long nextLong() throws IOException
+        {
+            long ret = 0;
+            byte c = read();
+            while (c <= ' ')
+                c = read();
+            boolean neg = (c == '-');
+            if (neg)
+                c = read();
+            do {
+                ret = ret * 10 + c - '0';
+            } while ((c = read()) >= '0' && c <= '9');
+            if (neg)
+                return -ret;
+            return ret;
+        }
+ 
+        public double nextDouble() throws IOException
+        {
+            double ret = 0, div = 1;
+            byte c = read();
+            while (c <= ' ')
+                c = read();
+            boolean neg = (c == '-');
+            if (neg)
+                c = read();
+ 
+            do {
+                ret = ret * 10 + c - '0';
+            } while ((c = read()) >= '0' && c <= '9');
+ 
+            if (c == '.') {
+                while ((c = read()) >= '0' && c <= '9') {
+                    ret += (c - '0') / (div *= 10);
+                }
+            }
+ 
+            if (neg)
+                return -ret;
+            return ret;
+        }
+ 
+        private void fillBuffer() throws IOException
+        {
+            bytesRead = din.read(buffer, bufferPointer = 0,
+                                 BUFFER_SIZE);
+            if (bytesRead == -1)
+                buffer[0] = -1;
+        }
+ 
+        private byte read() throws IOException
+        {
+            if (bufferPointer == bytesRead)
+                fillBuffer();
+            return buffer[bufferPointer++];
+        }
+ 
+        public void close() throws IOException
+        {
+            if (din == null)
+                return;
+            din.close();
+        }
+        public void printarray(int arr[])
+        {
+        	for (int i = 0; i < arr.length; i++)
+				System.out.print(arr[i]+"" "");
+        	System.out.println();
+        }
+    }
+}
+
+
+
+
+
+
+
+","import java.io.*;
+import java.util.*;
+
+public class Codeforces {
+    public static void main(String[] args) throws IOException{
+        try (BufferedReader br = new BufferedReader(new InputStreamReader(System.in))) {
+            int t = Integer.parseInt(br.readLine());
+            while (t-- > 0) {
+                int n = Integer.parseInt(br.readLine());
+                String[] s = br.readLine().split("" "");
+                String c = br.readLine();
+
+                ArrayList<Integer> blue = new ArrayList<>();
+                ArrayList<Integer> red = new ArrayList<>();
+                
+                for (int i = 0; i < n; i++) {
+                    if (c.charAt(i) == 'B') blue.add(Integer.parseInt(s[i]));
+                    else
+                        red.add(Integer.parseInt(s[i]));
+                }
+
+                Collections.sort(blue);
+                Collections.sort(red);
+                int p1 = 0, p2 = 0, num = 1, flag = 1;
+                while (num <= n) {
+                    if (p1 < blue.size()) {
+                        if (blue.get(p1) < num) {
+                            flag = 0;
+                            break;
+                        }
+                        p1++;
+                    }
+                    else if (p2 < red.size()) {
+                        if (red.get(p2) > num) {
+                            flag = 0;
+                            break;
+                        }
+                        p2++;
+                    }
+                    num++;
+                }
+                if (flag == 1)  System.out.println(""YES"");
+                else
+                    System.out.println(""NO"");
+            }
+        }
+    }
+}",0
+51cc7026,51d88c51,"
+import java.util.*;
+import java.math.*;
+import java.io.*;
+import java.lang.*;
+public class C_Balanced_Stone_Heaps {
+	static class FastReader {
+		BufferedReader br;
+		StringTokenizer st;
+ 
+		public FastReader() {
+			br = new BufferedReader(new InputStreamReader(System.in));
+		}
+ 
+		String next() {
+			while (st == null || !st.hasMoreElements()) {
+				try {
+					st = new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			}
+			return st.nextToken();
+		}
+ 
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+ 
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+ 
+		double nextDouble() {
+			return Double.parseDouble(next());
+		}
+ 
+		String nextLine() {
+			String str = """";
+			try {
+				str = br.readLine();
+			} catch (IOException e) {
+				e.printStackTrace();
+			}
+			return str;
+		}
+ 
+		int[] nextIntArray(int n) {
+			int a[] = new int[n];
+			for (int i = 0; i < n; i++) {
+				a[i] = Integer.parseInt(next());
+			}
+			return a;
+		}
+ 
+	}
+	
+    public static int t, n;
+    public static int H[];
+	private static long startTime = System.currentTimeMillis();
+	public static void main(String[] args) {
+		FastReader sc =new FastReader();
+		t = sc.nextInt();
+        while (t-->0) {
+            n = sc.nextInt();
+            H = new int[n];
+            int max = Integer.MIN_VALUE, min = Integer.MAX_VALUE;
+			for (int i = 0; i < n; i++) {
+                H[i] = sc.nextInt();
+                max = Math.max(H[i], max);
+                min = Math.min(H[i], min);
+            }
+            int mid = 0;
+            while (min < max) {
+                mid = min + (max-min+1)/2;
+                if(check(mid)) {
+                    min = mid;
+                }
+                else max = mid-1;
+            }			
+
+            System.out.println(min);
+        }
+
+	}
+
+    public static boolean check(int x){
+        int S[] = Arrays.copyOf(H, H.length);
+        for (int i = n-1; i >= 2; i--) {
+            if(S[i]<x) return false;
+
+            int move = Math.min(S[i]-x, H[i])/3;
+            if(i>=2){
+                // S[i]-=move*3;
+                S[i-1]+=(move);
+                S[i-2]+=2*(move);
+            }
+        }
+        return S[0]>= x && S[1] >= x;
+    }
+
+}
+","
+import java.awt.Container;
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.math.BigInteger;
+
+import java.util.*;
+
+public class Main
+{
+   
+    public static boolean check(int a[],int value)
+    {
+           int b[]= new int[a.length];
+           for (int i = a.length-1; i >=2; i--) {
+            if(a[i]+b[i]<value)
+            {
+                return false;
+            }
+            int d = Math.min(a[i], (a[i]+b[i]-value));
+            b[i-1]+=d/3;
+            b[i-2]+=(2*(d/3));
+            
+        }
+        
+        
+        
+        if(a[0]+b[0]<value||a[1]+b[1]<value)
+        {
+            return false;
+        }
+        return true;
+        
+    }
+   
+    public static void main(String[] args)
+    {
+        FastScanner input = new FastScanner();
+        StringBuilder result = new StringBuilder();
+        int tc = input.nextInt();
+        work:
+        while (tc-- > 0) {
+          int n = input.nextInt();
+        int a[]= new int[n];
+     
+        int min = Integer.MAX_VALUE;
+        int max = Integer.MIN_VALUE;
+        for (int i = 0; i < n; i++) {
+            a[i] = input.nextInt();
+            min = Math.min(min, a[i]);
+            max = Math.max(max, a[i]);
+            
+        }
+        int low = min;
+        int high  = max;
+        int ans = 0;
+        while(low<=high)
+        {
+            int mid = low+(high-low)/2;
+            if(check(a, mid))
+            {
+                ans = mid;
+                low = mid+1;
+            }
+            else
+            {
+                high = mid-1;
+            }
+            
+            
+        }
+        result.append(ans+""\n"");
+           
+        }
+        System.out.println(result);
+        
+       
+    }
+
+    static class FastScanner
+    {
+
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st = new StringTokenizer("""");
+
+        String next()
+        {
+            while (!st.hasMoreTokens()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt()
+        {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong()
+        {
+
+            return Long.parseLong(next());
+        }
+
+        double nextDouble()
+        {
+            return Double.parseDouble(next());
+        }
+
+        String nextLine() throws IOException
+        {
+            return br.readLine();
+        }
+    }
+
+}
+",0
+0f14b12d,7d12d33c,"//import jdk.nashorn.internal.parser.Scanner;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.*;
+import java.util.*;
+
+import javax.management.Query;
+public class Test{
+    public static void main(String[] args) throws IOException, InterruptedException{
+      Scanner sc = new Scanner(System.in);
+     int t = sc.nextInt();
+    
+     while(t-->0){
+      int n = sc.nextInt();
+      String [] words = new String[n];
+      int [] occ = new int[5];
+      int [] occWord = new int [5];
+      boolean []  found ;
+      for(int i =0;i<n;i++){
+        words[i] = sc.nextLine();
+        found = new boolean[5];
+        for(int j=0 ; j<words[i].length();j++){
+          occ[words[i].charAt(j)-'a']++;
+          if(!found[words[i].charAt(j)-'a']){
+            found[words[i].charAt(j)-'a']=true;
+            occWord[words[i].charAt(j)-'a'] ++;
+          }
+        }
+      }
+      int maxRes =0;
+      for(int i =0;i<5;i++){
+      int maxChar = 'a' +i;
+      
+      PriorityQueue<Pair> pq = new PriorityQueue<>();
+      for (String word : words){
+          pq.add(new Pair(word,occOfMaxChar(word, maxChar)-occOfOtherChar(word, maxChar)));
+      }
+      int res = 0;
+      int curr = 0;
+      int maxCharCount = 0;
+      int otherCharCount =0;
+      while(!pq.isEmpty()){
+        String word = pq.poll().x;
+        maxCharCount +=occOfMaxChar(word, maxChar);
+         otherCharCount += occOfOtherChar(word, maxChar);
+         curr ++;
+         if(maxCharCount >otherCharCount){
+           res = curr;
+         }
+          
+      }
+      maxRes = Math.max(maxRes, res);
+    }
+    System.out.println(maxRes);}
+   
+  }
+  public static int occOfMaxChar (String s, int maxChar){
+     int occ = 0;
+     for(int i =0 ;i<s.length();i++){
+       if(s.charAt(i)==maxChar){
+         occ++;
+       }
+      }
+      return occ;
+  }
+  public static int occOfOtherChar (String s, int maxChar){
+    int occ = 0;
+    for(int i =0 ;i<s.length();i++){
+      if(s.charAt(i)!=maxChar){
+        occ++;
+      }
+     }
+     return occ;
+ }
+
+    static int w;
+    static int n;
+    static long [][] memo;
+    static int [] depth ;
+    static long[] values;
+    static ArrayList<Pair> gold ;
+    public static long dp (int idx,int time){
+      if ( idx == n){
+       return 0;
+      }
+      if (memo[idx][time] != -1){
+        return  memo[idx][time];
+      }
+      long take = 0;
+      if (3 * w*depth[idx] <= time){
+        take = values[idx]+ dp(idx+1, time-3*w*depth[idx]);
+      }
+      long leave = dp(idx+1, time);
+      return memo[idx][time]=Math.max(take, leave);
+    }
+
+
+    static class Pair implements Comparable {
+      String x;
+      int y;
+      public Pair (String x, int y) {
+        this.x = x;
+        this.y = y;
+      }
+      @Override
+      public int compareTo(Object o){
+        Pair p = (Pair) o;
+        return p.y -y;
+      }
+    }
+    static class Scanner {
+      StringTokenizer st;
+      BufferedReader br;
+   
+      public Scanner(InputStream s) {
+        br = new BufferedReader(new InputStreamReader(s));
+      }
+   
+      public boolean hasNext() {
+        // TODO Auto-generated method stub
+        return false;
+      }
+   
+      public String next() throws IOException {
+        while (st == null || !st.hasMoreTokens())
+          st = new StringTokenizer(br.readLine());
+        return st.nextToken();
+      }
+   
+      public int nextInt() throws IOException {
+        return Integer.parseInt(next());
+      }
+   
+      public long nextLong() throws IOException {
+        return Long.parseLong(next());
+      }
+   
+      public String nextLine() throws IOException {
+        return br.readLine();
+      }
+   
+      public double nextDouble() throws IOException {
+        String x = next();
+        StringBuilder sb = new StringBuilder(""0"");
+        double res = 0, f = 1;
+        boolean dec = false, neg = false;
+        int start = 0;
+        if (x.charAt(0) == '-') {
+          neg = true;
+          start++;
+        }
+        for (int i = start; i < x.length(); i++)
+          if (x.charAt(i) == '.') {
+            res = Long.parseLong(sb.toString());
+            sb = new StringBuilder(""0"");
+            dec = true;
+          } else {
+            sb.append(x.charAt(i));
+            if (dec)
+              f *= 10;
+          }
+        res += Long.parseLong(sb.toString()) / f;
+        return res * (neg ? -1 : 1);
+      }
+   
+      public boolean ready() throws IOException {
+        return br.ready();
+      }
+   
+    }
+     }
+
+","//import jdk.nashorn.internal.parser.Scanner;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.*;
+import java.util.*;
+
+import javax.management.Query;
+public class Test{
+    public static void main(String[] args) throws IOException, InterruptedException{
+      Scanner sc = new Scanner(System.in);
+     int t = sc.nextInt();
+    
+     while(t-->0){
+      int n = sc.nextInt();
+      String [] words = new String[n];
+     
+      for(int i =0;i<n;i++){
+        words[i] = sc.nextLine();
+       
+      }
+      int maxRes =0;
+      for(int i =0;i<5;i++){
+      int maxChar = 'a' +i;
+      
+      PriorityQueue<Pair> pq = new PriorityQueue<>();
+      for (String word : words){
+          pq.add(new Pair(word,occOfMaxChar(word, maxChar)-occOfOtherChar(word, maxChar)));
+      }
+      int res = 0;
+      int curr = 0;
+      int maxCharCount = 0;
+      int otherCharCount =0;
+      while(!pq.isEmpty()){
+        String word = pq.poll().x;
+        maxCharCount +=occOfMaxChar(word, maxChar);
+         otherCharCount += occOfOtherChar(word, maxChar);
+         curr ++;
+         if(maxCharCount >otherCharCount){
+           res = curr;
+         }
+          
+      }
+      maxRes = Math.max(maxRes, res);
+    }
+    System.out.println(maxRes);}
+   
+  }
+  public static int occOfMaxChar (String s, int maxChar){
+     int occ = 0;
+     for(int i =0 ;i<s.length();i++){
+       if(s.charAt(i)==maxChar){
+         occ++;
+       }
+      }
+      return occ;
+  }
+  public static int occOfOtherChar (String s, int maxChar){
+    int occ = 0;
+    for(int i =0 ;i<s.length();i++){
+      if(s.charAt(i)!=maxChar){
+        occ++;
+      }
+     }
+     return occ;
+ }
+
+    static int w;
+    static int n;
+    static long [][] memo;
+    static int [] depth ;
+    static long[] values;
+    static ArrayList<Pair> gold ;
+    public static long dp (int idx,int time){
+      if ( idx == n){
+       return 0;
+      }
+      if (memo[idx][time] != -1){
+        return  memo[idx][time];
+      }
+      long take = 0;
+      if (3 * w*depth[idx] <= time){
+        take = values[idx]+ dp(idx+1, time-3*w*depth[idx]);
+      }
+      long leave = dp(idx+1, time);
+      return memo[idx][time]=Math.max(take, leave);
+    }
+
+
+    static class Pair implements Comparable {
+      String x;
+      int y;
+      public Pair (String x, int y) {
+        this.x = x;
+        this.y = y;
+      }
+      @Override
+      public int compareTo(Object o){
+        Pair p = (Pair) o;
+        return p.y -y;
+      }
+    }
+    static class Scanner {
+      StringTokenizer st;
+      BufferedReader br;
+   
+      public Scanner(InputStream s) {
+        br = new BufferedReader(new InputStreamReader(s));
+      }
+   
+      public boolean hasNext() {
+        // TODO Auto-generated method stub
+        return false;
+      }
+   
+      public String next() throws IOException {
+        while (st == null || !st.hasMoreTokens())
+          st = new StringTokenizer(br.readLine());
+        return st.nextToken();
+      }
+   
+      public int nextInt() throws IOException {
+        return Integer.parseInt(next());
+      }
+   
+      public long nextLong() throws IOException {
+        return Long.parseLong(next());
+      }
+   
+      public String nextLine() throws IOException {
+        return br.readLine();
+      }
+   
+      public double nextDouble() throws IOException {
+        String x = next();
+        StringBuilder sb = new StringBuilder(""0"");
+        double res = 0, f = 1;
+        boolean dec = false, neg = false;
+        int start = 0;
+        if (x.charAt(0) == '-') {
+          neg = true;
+          start++;
+        }
+        for (int i = start; i < x.length(); i++)
+          if (x.charAt(i) == '.') {
+            res = Long.parseLong(sb.toString());
+            sb = new StringBuilder(""0"");
+            dec = true;
+          } else {
+            sb.append(x.charAt(i));
+            if (dec)
+              f *= 10;
+          }
+        res += Long.parseLong(sb.toString()) / f;
+        return res * (neg ? -1 : 1);
+      }
+   
+      public boolean ready() throws IOException {
+        return br.ready();
+      }
+   
+    }
+     }
+",1
+80881cae,ad4c7a20,"//package Codeforces;
+import java.io.*;
+import java.util.*;
+
+
+public class CP
+{
+	static Scanner sc=new Scanner(System.in);
+	public static void main(String[] args) throws IOException, CloneNotSupportedException
+	{
+		int t=sc.nextInt();
+		while(t-->0)
+		{
+			int n=sc.nextInt();
+			int k[]=new int[n];
+			int h[]=new int[n];
+			for(int i=0;i<n;i++)
+				k[i]=sc.nextInt();
+			for(int i=0;i<n;i++)
+				h[i]=sc.nextInt();
+			ArrayList<Pair> interval=new ArrayList<Pair>();
+			ArrayList<Pair> act=new ArrayList<Pair>();
+			for(int i=0;i<n;i++)
+				interval.add(new Pair(k[i]-h[i]+1,k[i]));
+			Collections.sort(interval);
+//			out.println(interval);
+			act.add(interval.get(0).clone());
+			for(int i=1;i<n;i++)
+			{
+				Pair p=act.get(act.size()-1);
+				if(p.y<interval.get(i).x)
+					act.add(interval.get(i).clone());
+				else
+					p.y=Math.max(p.y, interval.get(i).y);
+			}
+//			out.println(act);
+			long mana=0;
+			for(Pair p: act)
+			{
+				long x=p.y-p.x+1;
+				mana+=(x*(x+1))/2;
+			}
+			System.out.println(mana);		
+ 		}
+	}
+	static class Pair implements Cloneable, Comparable<Pair>
+	{
+		int x,y;
+		Pair(int a,int b)
+		{
+			this.x=a;
+			this.y=b;
+		}
+//		@Override
+//		public boolean equals(Object obj) 
+//		{
+//			if(obj instanceof  Pair)
+//			{
+//				Pair p=(Pair)obj;
+//				return p.x==this.x && p.y==this.y;
+//			}
+//			return false;
+//		}
+//		@Override
+//		public int hashCode() 
+//		{
+//			return Math.abs(x)+500*Math.abs(y);
+//		}
+//		@Override
+//		public String toString() 
+//		{
+//			return ""(""+x+"" ""+y+"")"";
+//		}
+		@Override
+		protected Pair clone() throws CloneNotSupportedException {
+			return new Pair(this.x,this.y);
+		}
+		@Override
+		public int compareTo(Pair a) 
+		{
+			long t=(this.x-a.x);
+			if(t!=0)
+				return t>0?1:-1;
+			else
+				return (int)(this.y-a.y);
+		}
+//		public void swap()
+//		{
+//			this.y=this.y+this.x;
+//			this.x=this.y-this.x;
+//			this.y=this.y-this.x;			
+//		}
+	}
+}","import java.io.*;
+import java.util.*;
+
+
+public class Practice
+{
+//	static final long mod=7420738134811L;
+	static int mod=1000000007;
+	static final int size=501;
+	static FastReader sc=new FastReader(System.in);
+//	static Reader sc=new Reader();
+//	static Scanner sc=new Scanner(System.in);
+	static  PrintWriter out=new PrintWriter(System.out);
+	static long[] factorialNumInverse;
+	static long[] naturalNumInverse;	
+	static int[] sp;
+	static long[] fact;
+	static ArrayList<Integer> pr;
+	public static void main(String[] args) throws IOException, CloneNotSupportedException
+	{
+//		System.setIn(new FileInputStream(""input.txt""));
+//		System.setOut(new PrintStream(""output.txt""));
+//		factorial(mod);
+//		InverseofNumber(mod);
+//		InverseofFactorial(mod);
+//		make_seive();
+		int t=1;
+		t=sc.nextInt();
+		for(int i=1;i<=t;i++)
+			solve(i);
+		out.close();
+		out.flush();
+//		System.out.flush();
+//		System.exit(0);
+	}
+	
+	static void solve(int CASENO) throws IOException, CloneNotSupportedException
+	{
+		int n=sc.nextInt();
+		int k[]=new int[n];
+		int h[]=new int[n];
+		for(int i=0;i<n;i++)
+			k[i]=sc.nextInt();
+		for(int i=0;i<n;i++)
+			h[i]=sc.nextInt();
+		ArrayList<Pair> interval=new ArrayList<Pair>();
+		ArrayList<Pair> act=new ArrayList<Pair>();
+		for(int i=0;i<n;i++)
+			interval.add(new Pair(k[i]-h[i]+1,k[i]));
+		Collections.sort(interval);
+//		out.println(interval);
+		act.add(interval.get(0).clone());
+		for(int i=1;i<n;i++)
+		{
+			Pair p=act.get(act.size()-1);
+			if(p.y<interval.get(i).x)
+				act.add(interval.get(i).clone());
+			else
+				p.y=Math.max(p.y, interval.get(i).y);
+		}
+//		out.println(act);
+		long mana=0;
+		for(Pair p: act)
+		{
+			long x=p.y-p.x+1;
+			mana+=(x*(x+1))/2;
+		}
+		out.println(mana);
+	}
+	static class Pair implements Cloneable, Comparable<Pair>
+	{
+		int x,y;
+		Pair(int a,int b)
+		{
+			this.x=a;
+			this.y=b;
+		}
+		@Override
+		public boolean equals(Object obj) 
+		{
+			if(obj instanceof  Pair)
+			{
+				Pair p=(Pair)obj;
+				return p.x==this.x && p.y==this.y;
+			}
+			return false;
+		}
+		@Override
+		public int hashCode() 
+		{
+			return Math.abs(x)+500*Math.abs(y);
+		}
+		@Override
+		public String toString() 
+		{
+			return ""(""+x+"" ""+y+"")"";
+		}
+		@Override
+		protected Pair clone() throws CloneNotSupportedException {
+			return new Pair(this.x,this.y);
+		}
+		@Override
+		public int compareTo(Pair a) 
+		{
+			long t=(this.x-a.x);
+			if(t!=0)
+				return t>0?1:-1;
+			else
+				return (int)(this.y-a.y);
+		}
+		public void swap()
+		{
+			this.y=this.y+this.x;
+			this.x=this.y-this.x;
+			this.y=this.y-this.x;			
+		}
+	}
+	static class Tuple implements Cloneable, Comparable<Tuple>
+	{
+		int x,y,z;
+		Tuple(int a,int b,int c)
+		{
+			this.x=a;
+			this.y=b;
+			this.z=c;
+		}
+		public boolean equals(Object obj) 
+		{
+			if(obj instanceof  Tuple)
+			{
+				Tuple p=(Tuple)obj;
+				return p.x==this.x && p.y==this.y && p.z==this.z;
+			}
+			return false;
+		}
+		@Override
+		public int hashCode() 
+		{
+			return (this.x+501*this.y);
+		}
+		@Override
+		public String toString() 
+		{
+			return ""(""+x+"",""+y+"",""+z+"")"";
+		}
+		@Override
+		protected Tuple clone() throws CloneNotSupportedException {
+			return new Tuple(this.x,this.y,this.z);
+		}
+		@Override
+		public int compareTo(Tuple a) 
+		{
+			int x=this.z-a.z;
+			if(x!=0)
+				return x;
+			int X= this.x-a.x;
+			if(X!=0)
+				return X;
+			return a.y-this.y;
+		}
+	}
+	static void arraySort(int arr[])
+	{
+		ArrayList<Integer> a=new ArrayList<Integer>();
+		for (int i = 0; i < arr.length; i++) {
+			a.add(arr[i]);
+		}
+		Collections.sort(a,Comparator.reverseOrder());
+		for (int i = 0; i < arr.length; i++) {
+			arr[i]=a.get(i);
+		}
+	}
+	static void arraySort(long arr[])
+	{
+		ArrayList<Long> a=new ArrayList<Long>();
+		for (int i = 0; i < arr.length; i++) {
+			a.add(arr[i]);
+		}
+		Collections.sort(a);
+		for (int i = 0; i < arr.length; i++) {
+			arr[i]=a.get(i);
+		}
+	}
+	static HashSet<Integer> primeFactors(int n)
+	{
+		HashSet<Integer> ans=new HashSet<Integer>();
+		if(n%2==0)
+		{
+			ans.add(2);
+			while((n&1)==0)
+				n=n>>1;
+		}
+		for(int i=3;i*i<=n;i+=2)
+		{
+			if(n%i==0)
+			{
+				ans.add(i);
+				while(n%i==0)
+					n=n/i;
+			}
+		}
+		if(n!=1)
+			ans.add(n);
+		return ans;
+	}
+	static void make_seive()
+	{
+		sp=new int[size];
+		pr=new ArrayList<Integer>();
+		for (int i=2; i<size; ++i) {
+		    if (sp[i] == 0) {
+		        sp[i] = i;
+		        pr.add(i);
+		    }
+		    for (int j=0; j<(int)pr.size() && pr.get(j)<=sp[i] && i*pr.get(j)<size; ++j)
+		        sp[i * pr.get(j)] = pr.get(j);
+		}
+	}
+	public static void InverseofNumber(int p)
+	{
+		naturalNumInverse=new long[size];
+	    naturalNumInverse[0] = naturalNumInverse[1] = 1;
+	    for(int i = 2; i < size; i++)
+	        naturalNumInverse[i] = naturalNumInverse[p % i] * (long)(p - p / i) % p;
+	}
+	// Function to precompute inverse of factorials
+	public static void InverseofFactorial(int p)
+	{
+		factorialNumInverse=new long[size];
+	    factorialNumInverse[0] = factorialNumInverse[1] = 1;
+	    // pre-compute inverse of natural numbers
+	    for(int i = 2; i < size; i++)
+	        factorialNumInverse[i] = (naturalNumInverse[i] * factorialNumInverse[i - 1]) % p;
+	}
+	// Function to calculate factorial of 1 to 200001
+	public static void factorial(int p)
+	{
+		fact=new long[size];
+	    fact[0] = 1;
+	    for(int i = 1; i < size; i++)
+	        fact[i] = (fact[i - 1] * (long)i) % p;
+	}
+	 
+	// Function to return nCr % p in O(1) time
+	public static long Binomial(int N, int R)
+	{
+		if(R<0)
+			return 1;
+	    // n C r = n!*inverse(r!)*inverse((n-r)!)
+	    long ans = ((fact[N] * factorialNumInverse[R]) % mod * factorialNumInverse[N - R]) % mod;
+	    return ans;
+	}
+	static int findXOR(int x)	//from 0 to x
+	{
+		if(x<0)
+			return 0;
+		if(x%4==0)
+			return x;
+		if(x%4==1)
+			return 1;
+		if(x%4==2)
+			return x+1;
+		return 0;
+	}
+	static boolean isPrime(long x)
+	{
+		if(x==1)
+			return false;
+		if(x<=3)
+			return true;
+		if(x%2==0 || x%3==0)
+			return false;
+		for(int i=5;i<=Math.sqrt(x);i+=2)
+			if(x%i==0)
+				return false;
+		return true;
+	}
+	static long gcd(long a,long b)
+	{
+		return (b==0)?a:gcd(b,a%b);
+	}
+	static int gcd(int a,int b)
+	{
+		return (b==0)?a:gcd(b,a%b);
+	}
+	static class Node
+	{
+		int vertex,dis;
+		HashSet<Node> adj;
+		Node(int ver)
+		{
+			vertex=ver;
+			dis=-1;
+			adj=new HashSet<Node>();
+		}
+		@Override
+		public String toString() 
+		{
+			return vertex+"" "";
+		}
+	}
+	static class Edge
+	{
+		Node to;
+		int cost;
+		Edge(Node t,int c)
+		{
+			this.to=t;
+			this.cost=c;
+		}
+		@Override
+		public String toString() {
+			return ""(""+to.vertex+"",""+cost+"") "";
+		}
+	}
+	static long power(long x, long y)
+	  {
+		if(x<=0)
+			return 1;
+	    long res = 1; 
+	    x = x % mod; 
+	    if (x == 0)
+	      return 0; 
+	    while (y > 0)
+	    {
+	    	if ((y & 1) != 0)
+	    		res = (res * x) % mod;
+	    	
+	    	y = y >> 1; // y = y/2
+	    	x = (x * x) % mod;
+	    }
+	    return res%mod;
+	  }
+	static long binomialCoeff(long n, long k)
+    {
+		if(n<k)
+			return 0;
+        long res = 1;
+        // Since C(n, k) = C(n, n-k)
+        if (k > n - k)
+            k = n - k;
+ 
+        // Calculate value of
+        // [n * (n-1) *---* (n-k+1)] / [k * (k-1) *----* 1]
+        for (long i = 0; i < k; ++i) {
+            res *= (n - i);
+            res /= (i + 1);
+        }
+ 
+        return res;
+    }
+	static class FastReader
+	{
+        byte[] buf = new byte[2048];
+        int index, total;
+        InputStream in;
+ 
+        FastReader(InputStream is) 
+        {
+            in = is;
+        }
+ 
+        int scan() throws IOException 
+        {
+            if (index >= total) {
+                index = 0;
+                total = in.read(buf);
+                if (total <= 0) {
+                    return -1;
+                }
+            }
+            return buf[index++];
+        }
+ 
+        String next() throws IOException 
+        {
+            int c;
+            for (c = scan(); c <= 32; c = scan());
+            StringBuilder sb = new StringBuilder();
+            for (; c > 32; c = scan()) {
+                sb.append((char) c);
+            }
+            return sb.toString();
+        }
+ 
+        int nextInt() throws IOException 
+        {
+            int c, val = 0;
+            for (c = scan(); c <= 32; c = scan());
+            boolean neg = c == '-';
+            if (c == '-' || c == '+') {
+                c = scan();
+            }
+            for (; c >= '0' && c <= '9'; c = scan()) {
+                val = (val << 3) + (val << 1) + (c & 15);
+            }
+            return neg ? -val : val;
+        }
+ 
+        long nextLong() throws IOException 
+        {
+            int c;
+            long val = 0;
+            for (c = scan(); c <= 32; c = scan());
+            boolean neg = c == '-';
+            if (c == '-' || c == '+') {
+                c = scan();
+            }
+            for (; c >= '0' && c <= '9'; c = scan()) {
+                val = (val << 3) + (val << 1) + (c & 15);
+            }
+            return neg ? -val : val;
+        }
+    }
+	static class Reader 
+	{
+        final private int BUFFER_SIZE = 1 << 16;
+        private DataInputStream din;
+        private byte[] buffer;
+        private int bufferPointer, bytesRead;
+ 
+        public Reader()
+        {
+            din = new DataInputStream(System.in);
+            buffer = new byte[BUFFER_SIZE];
+            bufferPointer = bytesRead = 0;
+        }
+ 
+        public Reader(String file_name) throws IOException
+        {
+            din = new DataInputStream(
+                new FileInputStream(file_name));
+            buffer = new byte[BUFFER_SIZE];
+            bufferPointer = bytesRead = 0;
+        }
+ 
+        public String readLine() throws IOException
+        {
+            byte[] buf = new byte[64]; // line length
+            int cnt = 0, c;
+            while ((c = read()) != -1) {
+                if (c == '\n') {
+                    if (cnt != 0) {
+                        break;
+                    }
+                    else {
+                        continue;
+                    }
+                }
+                buf[cnt++] = (byte)c;
+            }
+            return new String(buf, 0, cnt);
+        }
+ 
+        public int nextInt() throws IOException
+        {
+            int ret = 0;
+            byte c = read();
+            while (c <= ' ') {
+                c = read();
+            }
+            boolean neg = (c == '-');
+            if (neg)
+                c = read();
+            do {
+                ret = ret * 10 + c - '0';
+            } while ((c = read()) >= '0' && c <= '9');
+ 
+            if (neg)
+                return -ret;
+            return ret;
+        }
+ 
+        public long nextLong() throws IOException
+        {
+            long ret = 0;
+            byte c = read();
+            while (c <= ' ')
+                c = read();
+            boolean neg = (c == '-');
+            if (neg)
+                c = read();
+            do {
+                ret = ret * 10 + c - '0';
+            } while ((c = read()) >= '0' && c <= '9');
+            if (neg)
+                return -ret;
+            return ret;
+        }
+ 
+        public double nextDouble() throws IOException
+        {
+            double ret = 0, div = 1;
+            byte c = read();
+            while (c <= ' ')
+                c = read();
+            boolean neg = (c == '-');
+            if (neg)
+                c = read();
+ 
+            do {
+                ret = ret * 10 + c - '0';
+            } while ((c = read()) >= '0' && c <= '9');
+ 
+            if (c == '.') {
+                while ((c = read()) >= '0' && c <= '9') {
+                    ret += (c - '0') / (div *= 10);
+                }
+            }
+ 
+            if (neg)
+                return -ret;
+            return ret;
+        }
+ 
+        private void fillBuffer() throws IOException
+        {
+            bytesRead = din.read(buffer, bufferPointer = 0,
+                                 BUFFER_SIZE);
+            if (bytesRead == -1)
+                buffer[0] = -1;
+        }
+ 
+        private byte read() throws IOException
+        {
+            if (bufferPointer == bytesRead)
+                fillBuffer();
+            return buffer[bufferPointer++];
+        }
+ 
+        public void close() throws IOException
+        {
+            if (din == null)
+                return;
+            din.close();
+        }
+        public void printarray(int arr[])
+        {
+        	for (int i = 0; i < arr.length; i++)
+				System.out.print(arr[i]+"" "");
+        	System.out.println();
+        }
+    }
+}
+
+
+
+
+
+
+
+",1
+1ea771ea,ee270b2a,"
+import java.io.*;
+import java.util.*;
+
+
+public class CODECHEF {
+    static class FastReader {
+        byte[] buf = new byte[2048];
+        int index, total;
+        InputStream in;
+
+        FastReader(InputStream is) {
+            in = is;
+        }
+
+        int scan() throws IOException {
+            if (index >= total) {
+                index = 0;
+                total = in.read(buf);
+                if (total <= 0) {
+                    return -1;
+                }
+            }
+            return buf[index++];
+        }
+
+        String next() throws IOException {
+            int c;
+            for (c = scan(); c <= 32; c = scan())
+                ;
+            StringBuilder sb = new StringBuilder();
+            for (; c > 32; c = scan()) {
+                sb.append((char) c);
+            }
+            return sb.toString();
+        }
+
+        String nextLine() throws IOException {
+            int c;
+            for (c = scan(); c <= 32; c = scan())
+                ;
+            StringBuilder sb = new StringBuilder();
+            for (; c != 10 && c != 13; c = scan()) {
+                sb.append((char) c);
+            }
+            return sb.toString();
+        }
+
+        char nextChar() throws IOException {
+            int c;
+            for (c = scan(); c <= 32; c = scan())
+                ;
+            return (char) c;
+        }
+
+        int nextInt() throws IOException {
+            int c, val = 0;
+            for (c = scan(); c <= 32; c = scan())
+                ;
+            boolean neg = c == '-';
+            if (c == '-' || c == '+') {
+                c = scan();
+            }
+            for (; c >= '0' && c <= '9'; c = scan()) {
+                val = (val << 3) + (val << 1) + (c & 15);
+            }
+            return neg ? -val : val;
+        }
+
+        long nextLong() throws IOException {
+            int c;
+            long val = 0;
+            for (c = scan(); c <= 32; c = scan())
+                ;
+            boolean neg = c == '-';
+            if (c == '-' || c == '+') {
+                c = scan();
+            }
+            for (; c >= '0' && c <= '9'; c = scan()) {
+                val = (val << 3) + (val << 1) + (c & 15);
+            }
+            return neg ? -val : val;
+        }
+
+    }
+    static long MOD=1000000000;
+    static class Pair{
+        long a;
+        int b;
+        Pair(long i,int j){
+            a=i;
+            b=j;
+        }
+    }
+    static long[] solve(int[] pos,long[] arr,int n,int k){
+        long[] ans=new long[n];
+        long[] left=new long[n];
+        long[] right=new long[n];
+        long min=Integer.MAX_VALUE;
+        for(int i=0;i<n;i++){
+            min=Math.min(min+1,arr[i]);
+            left[i]=min;
+        }
+        min=Integer.MAX_VALUE;
+        for(int i=n-1;i>=0;i--){
+            min=Math.min(min+1,arr[i]);
+            right[i]=min;
+        }
+        for(int i=0;i<n;i++){
+            ans[i]=Math.min(left[i],right[i]);
+        }
+        return ans;
+
+
+    }
+
+
+    public static void main(String[] args) throws java.lang.Exception {
+         FastReader fs=new FastReader(System.in);
+//       StringBuilder sb=new StringBuilder();
+//       PrintWriter out=new PrintWriter(System.out);
+         int t=fs.nextInt();
+         while (t-->0){
+            int n=fs.nextInt();
+            int k=fs.nextInt();
+            int[] pos=new int[k];
+            for(int i=0;i<k;i++)
+                pos[i]=fs.nextInt()-1;
+            long[] temp=new long[n];
+            int ptr=0;
+            Arrays.fill(temp,Integer.MAX_VALUE);
+             for(int i=0;i<k;i++)
+                 temp[pos[ptr++]]=fs.nextLong();
+             long[] ans=solve(pos,temp,n,k);
+             for(int i=0;i<n;i++)
+                 System.out.print(ans[i]+"" "");
+             System.out.println();
+
+         }
+        //out.close;
+    }
+}
+","import java.util.*;
+
+public class D{
+    private static Scanner scanner = new Scanner(System.in);
+    public static void main(String[] args){
+        int q = scanner.nextInt();
+        while(q-- > 0){
+            int n = scanner.nextInt(),
+            k = scanner.nextInt();
+            int[] a = new int[k];
+            for(int i=0;i<k;i++){
+                a[i] = scanner.nextInt();
+            }
+            int[] t = new int[k];
+            for(int j=0;j<k;j++){
+                t[j] = scanner.nextInt();
+            }
+            long[] L = new long[n];
+            long[] R = new long[n];
+            for(int i=0;i<n;i++){
+                L[i] = Integer.MAX_VALUE;
+                R[i] = Integer.MAX_VALUE;
+            }
+            for(int i=0;i<k;i++){
+                L[a[i]-1] = t[i];
+                R[a[i]-1] = t[i];
+            }
+            
+            long min = Integer.MAX_VALUE;
+            for(int i=0;i<n;i++){
+                L[i] = Math.min(min+1,L[i]);
+                min = L[i];
+            }
+            min = Integer.MAX_VALUE;
+            for(int i=n-1;i>=0;i--){
+                R[i] = Math.min(min+1,R[i]);
+                min = R[i];
+            }
+            for(int i=0;i<n;i++){
+                System.out.print(Math.min(L[i],R[i]) + "" "");
+            }
+            System.out.println();
+        }
+    }
+}
+",1
+42fe7dd0,c4ca2ff3,"import java.util.*;
+ public class Solution {
+    static Scanner sc=new Scanner(System.in);
+    public static void main(String args[]) {
+      int t=sc.nextInt();
+      outer:while(t-->0){
+        int n=sc.nextInt();
+        int[][] ct=new int[n][5];
+        int[] len=new int[n];
+        for (int i=0;i<n;i++) {
+            String s=sc.next();
+            len[i]=s.length();
+            for(char c:s.toCharArray()){
+                ct[i][c-'a']++;
+            }
+        }
+        int mx=0;
+        for (int i=0;i<5;i++) {
+            int[] diff=new int[n];
+            for (int j=0;j<n;j++) {
+                diff[j]=ct[j][i]-(len[j]-ct[j][i]);
+            }
+            Arrays.sort(diff);
+            int sum=0,inc=0;
+            for(int j=n-1;j>=0;j--){
+                sum+=diff[j];
+                if (sum>0) {
+                    inc++;
+                }else {
+                    break;
+                }
+            }
+            mx=Math.max(mx,inc);
+        }
+        System.out.println(mx);
+        }
+        
+      }
+
+    }
+
+","/* package codechef; // don't place package name! */
+
+import java.util.*;
+import java.lang.*;
+import java.io.*;
+
+/* Name of the class has to be ""Main"" only if the class is public. */
+public class Main
+{
+	public static void main (String[] args) throws java.lang.Exception
+	{
+		// your code goes here
+		Scanner sc=new Scanner(System.in);
+		int t=sc.nextInt();
+		PrintWriter out=new PrintWriter(System.out);
+		while(t-->0) {
+		    int n=sc.nextInt();
+		    int freq[][]=new int[n][5];
+		    int rem[][]=new int[n][5];
+		    for(int i=0;i<n;i++) {
+		        String str=sc.next();
+		        
+		        for(int j=0;j<str.length();j++) {
+		            freq[i][str.charAt(j)-'a']++;
+		        }
+		        for(int k=0;k<5;k++) {
+		            rem[i][k]=str.length()-freq[i][k];
+		        }
+		    }
+		    
+		    int ans=0;
+		    for(int i=0;i<5;i++) {
+		        int arr[]=new int[n];
+		        for(int j=0;j<n;j++)
+		        arr[j]=freq[j][i]-rem[j][i];
+		        
+		        Arrays.sort(arr);
+		        int total=0;
+		        int sum=0;
+		        for(int k=n-1;k>=0;k--) {
+		            if(sum+arr[k]>0) {
+		                sum=sum+arr[k];
+		                total++;
+		            }
+		            else {
+		                break;
+		            }
+		        }
+		        ans=Math.max(ans,total);
+		    }
+		    out.println(ans);
+		    
+		}
+		out.flush();
+		out.close();
+	}
+}
+
+",1
+46e9aed4,ee4f7b06,"
+import java.util.*;
+
+import java.lang.*;
+import java.io.*;
+
+/* Name of the class has to be ""Main"" only if the class is public. */
+public final class Solution {
+    
+
+    public static void main(String[] args) throws Exception {
+        
+        Reader sc = new Reader();
+        BufferedWriter op = new BufferedWriter(new OutputStreamWriter(System.out));
+         
+         int n=sc.nextInt();
+          ArrayList<Integer> fill= new ArrayList<Integer>();
+          ArrayList<Integer> unfilled= new ArrayList<>();
+          for(int i=0;i<n;i++){
+              int x =sc.nextInt();
+              if(x==1){
+                  fill.add(i);
+              }else{
+                  unfilled.add(i);
+              }
+          }
+          Collections.sort(fill);
+          Collections.sort(unfilled);
+          
+          
+          long[][] dp =new long[fill.size()+1][unfilled.size()+1];
+           for(int i=0;i<fill.size()+1;i++){
+              for(int j=0;j<unfilled.size()+1;j++){
+                  dp[i][j]=Integer.MAX_VALUE;
+              }
+          }
+          for(int i=0;i<unfilled.size()+1;i++){
+              dp[0][i]=0;
+          }
+        //   for(int j=0;j<fill.size()+1;j++){
+        //       dp[j][0]=0;
+        //   }
+         
+
+          for(int i=1;i<fill.size()+1;i++){
+              for(int j=1;j<unfilled.size()+1;j++){
+                  dp[i][j]=Math.min(dp[i][j-1],dp[i-1][j-1]+Math.abs(fill.get(i-1)-unfilled.get(j-1)));
+              }
+          }
+          System.out.println(dp[fill.size()][unfilled.size()]);
+        //   for(int i=0;i<fill.size()+1;i++){
+        //       for(int j=0;j<unfilled.size()+1;j++)
+        //       {
+        //           System.out.print(dp[i][j]+"" "");
+        //       }
+        //       System.out.println();
+        //   }
+         
+    }
+
+
+
+
+   
+    }
+
+class Reader {
+    final private int BUFFER_SIZE = 1 << 16;
+    private DataInputStream din;
+    private byte[] buffer;
+    private int bufferPointer, bytesRead;
+
+    public Reader() {
+        din = new DataInputStream(System.in);
+        buffer = new byte[BUFFER_SIZE];
+        bufferPointer = bytesRead = 0;
+    }
+
+    public Reader(String file_name) throws IOException {
+        din = new DataInputStream(new FileInputStream(file_name));
+        buffer = new byte[BUFFER_SIZE];
+        bufferPointer = bytesRead = 0;
+    }
+
+    public String readLine() throws IOException {
+        byte[] buf = new byte[64]; // line length
+        int cnt = 0, c;
+        while ((c = read()) != -1) {
+            if (c == '\n') {
+                if (cnt != 0) {
+                    break;
+                } else {
+                    continue;
+                }
+            }
+            buf[cnt++] = (byte) c;
+        }
+        return new String(buf, 0, cnt);
+    }
+
+    public int nextInt() throws IOException {
+        int ret = 0;
+        byte c = read();
+        while (c <= ' ') {
+            c = read();
+        }
+        boolean neg = (c == '-');
+        if (neg)
+            c = read();
+        do {
+            ret = ret * 10 + c - '0';
+        } while ((c = read()) >= '0' && c <= '9');
+
+        if (neg)
+            return -ret;
+        return ret;
+    }
+
+    public long nextLong() throws IOException {
+        long ret = 0;
+        byte c = read();
+        while (c <= ' ')
+            c = read();
+        boolean neg = (c == '-');
+        if (neg)
+            c = read();
+        do {
+            ret = ret * 10 + c - '0';
+        } while ((c = read()) >= '0' && c <= '9');
+        if (neg)
+            return -ret;
+        return ret;
+    }
+
+    public double nextDouble() throws IOException {
+        double ret = 0, div = 1;
+        byte c = read();
+        while (c <= ' ')
+            c = read();
+        boolean neg = (c == '-');
+        if (neg)
+            c = read();
+
+        do {
+            ret = ret * 10 + c - '0';
+        } while ((c = read()) >= '0' && c <= '9');
+
+        if (c == '.') {
+            while ((c = read()) >= '0' && c <= '9') {
+                ret += (c - '0') / (div *= 10);
+            }
+        }
+
+        if (neg)
+            return -ret;
+        return ret;
+    }
+
+    private void fillBuffer() throws IOException {
+        bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
+        if (bytesRead == -1)
+            buffer[0] = -1;
+    }
+
+    private byte read() throws IOException {
+        if (bufferPointer == bytesRead)
+            fillBuffer();
+        return buffer[bufferPointer++];
+    }
+
+    public void close() throws IOException {
+        if (din == null)
+            return;
+        din.close();
+    }
+}
+
+","    import java.io.*;
+    import java.util.*;
+    import java.lang.Math;
+
+
+    public class Main {
+
+          static PrintWriter pw;
+          static Scanner sc;
+          static StringBuilder ans;
+          static long mod = 1000000000+7;
+
+          static void pn(final Object arg) {
+               pw.print(arg);          
+               pw.flush();      
+          }     
+
+          /*-------------- for input in an value ---------------------*/
+          static int ni()     { return sc.nextInt();       }
+          static long nl()    { return sc.nextLong();      }
+          static double nd()  { return sc.nextDouble();    }
+          static String ns()  { return sc.next();          }
+
+
+          static void ap(int arg)           { ans.append(arg); }
+          static void ap(long arg)          { ans.append(arg); }
+          static void ap(String arg)        { ans.append(arg); }
+          static void ap(StringBuilder arg) { ans.append(arg); }        
+
+
+          /*-------------- for input in an array ---------------------*/
+          static void inputIntegerArray(int arr[]){
+               for(int i=0; i<arr.length; i++)arr[i] = ni();
+          }
+          static void inputLongArray(long arr[]){
+               for(int i=0; i<arr.length; i++)arr[i] = nl(); 
+          }
+          static void inputStringArray(String arr[]){
+               for(int i=0; i<arr.length; i++)arr[i] = ns(); 
+          }    
+          static void inputDoubleArray(double arr[]){
+               for(int i=0; i<arr.length; i++)arr[i] = nd();
+          }
+
+
+          /*-------------- File vs Input ---------------------*/
+          static void runFile() throws Exception {
+               sc = new Scanner(new FileReader(""input.txt""));
+               pw = new PrintWriter(new BufferedWriter(new FileWriter(""output.txt"")));
+          }
+          static void runIo() throws Exception  {
+               pw =new PrintWriter(System.out);
+               sc = new Scanner(System.in);
+          }    
+
+          static void swap(int a, int b) {
+               int  t = a;
+               a = b;
+               b = t;
+          }
+
+          static boolean isPowerOfTwo (long x) { return x!=0 && ((x&(x-1)) == 0);}
+
+          static int gcd(int a, int b) { if (b == 0) return a;     return gcd(b, a % b); }
+          
+          static int countDigit(long n){return (int)Math.floor(Math.log10(n) + 1);} 
+          
+          static boolean isPrime(int n) { 
+               if (n <= 1) return false; 
+               if (n <= 3) return true; 
+               if (n % 2 == 0 || n % 3 == 0) return false; 
+
+               for (int i = 5; i * i <= n; i = i + 6) 
+               if (n % i == 0 || n % (i + 2) == 0) 
+                    return false; 
+
+               return true; 
+          }         
+
+          static boolean sv[] = new boolean[1000002];
+          static void seive() {
+                 //true -> not prime
+               // false->prime
+
+               sv[0] = sv[1] = true; 
+               sv[2] = false;
+               for(int i = 0; i< sv.length; i++) {
+                    if( !sv[i] && (long)i*(long)i < sv.length ) {
+                         for ( int j = i*i; j<sv.length ; j += i ) {                
+                          sv[j] = true;
+                         }
+                    }
+               }
+
+          }
+
+          static long  binpow(  long a,   long b) {
+               long res = 1;
+               while (b > 0) {
+                    if ( (b & 1) > 0){
+                    res = (res * a)%mod;
+               }
+               a = (a * a)%mod;
+               b >>= 1;
+               }
+
+               return res;
+          }
+
+          static long factorial(long n)  {
+               long res = 1, i;
+               for (i = 2; i <= n; i++){
+                    res  =  ((res%mod) * (i%mod))%mod;
+               }          
+               return res;
+          }
+  
+
+          static class Pair {
+               int idx;
+               int v;
+               Pair(int idx, int v){
+                    this.idx = idx;
+                    this.v = v;
+               }
+          }
+     
+          public static void main(String[] args)  throws Exception {
+
+               // runFile();
+
+               runIo();              
+
+               int t;
+               t = 1;     
+            
+               // t =  sc.nextInt();
+          
+               ans = new StringBuilder();
+          
+               while( t-- > 0 ) {   
+                    solve();
+               }                
+          
+               pn(ans+""""); 
+ 
+          }
+    
+          static int N ; 
+          static int M ; 
+          static ArrayList<Integer> f;
+          static ArrayList<Integer> e;
+          static long dp[][];
+
+          static long find(int i, int j ) {
+               
+               if( i == N )   return 0;
+               if( j == M )   return Integer.MAX_VALUE;
+
+
+               if (dp[i][j] != -1 )
+                    return dp[i][j];
+
+               return dp[i][j] = Math.min( find(i, j+1), Math.abs(f.get(i)-e.get(j)) +  find(i+1, j+1) );
+          }       
+
+
+          public static void solve() {          
+          
+               int n = ni();
+               f = new ArrayList();
+               e = new ArrayList();               
+
+               for(int i = 0; i<n; i++) {
+                    int v = ni();
+                    if( v == 0 ) {
+                         e.add(i);
+                    }
+                    else
+                         f.add(i);
+               }
+
+               N = f.size();
+               M = e.size();               
+
+               dp = new long[N][M];
+
+               for(int i = 0; i<N; i++)
+                    Arrays.fill(dp[i], -1);
+
+               ap(find(0, 0)+""\n"");
+          }
+ 
+     }
+  
+
+   // 0 1 2 3 4 5 6 7
+   // 1 1 0 0 0 1 0 0
+
+   // 1s -> { 0, 1, 5 }
+   // 0s -> { 2, 3, 6, 7 }
+
+
+",0
+3368f340,402aff07,"//package Codeforces;
+
+import java.io.*;
+import java.util.*;
+
+public class Menorah {
+    public static void main(String[] args) throws IOException {
+        Scanner sc = new Scanner(System.in);
+
+        int t = sc.nextInt();
+        StringBuilder sb = new StringBuilder();
+        while (t-->0){
+            int n = sc.nextInt();
+            char[] a = sc.next().toCharArray();
+            char[] b = sc.next().toCharArray();
+
+            int a1=0, b1=0;
+            for(int i=0;i<n;i++){
+                if(a[i]=='1')
+                    a1++;
+                if(b[i]=='1')
+                    b1++;
+            }
+
+            int min = 100000000;
+
+            if(a1==b1){
+                int c = 0;
+                for(int i=0;i<n;i++){
+                    if(a[i]!=b[i])
+                        c++;
+                }
+
+                min = Math.min(min, c);
+            }
+
+            if(b1==(n-a1+1)){
+                int ind = -1;
+                for(int i=0;i<n;i++){
+                    if(a[i]==b[i] && a[i]=='1'){
+                        ind = i;
+                        break;
+                    }
+                }
+
+                int c = 0;
+                for(int i=0;i<n;i++){
+                    if(i==ind)
+                        continue;
+
+                    if(a[i]==b[i])
+                        c++;
+                }
+
+                min = Math.min(min, c + 1);
+            }
+
+            if(min == 100000000)
+                sb.append(""-1\n"");
+            else sb.append(min).append(""\n"");
+        }
+
+        System.out.println(sb);
+
+        sc.close();
+    }
+}
+","import java.util.*;
+public class Main {
+    public static void main(String args[]) {
+        Scanner s = new Scanner(System.in);
+        int t = s.nextInt();
+        while (t-- > 0){
+            int n = s.nextInt();
+            String a = s.next();
+            String b = s.next();
+            int a1 = 0, b1 = 0;
+            for (char c: a.toCharArray()){
+                if (c == '1') a1++;
+            }
+            for (char c: b.toCharArray()){
+                if (c == '1') b1++;
+            }
+            int ans = Integer.MAX_VALUE;
+            int res = 0;
+            for (int i = 0; i < n; i++) {
+                if (a.charAt(i) != b.charAt(i)) res++;
+            }
+            if (a1 == b1) ans = Math.min(ans, res);
+            if (b1 == n-a1+1) ans = Math.min(ans, n-res);
+            if (ans == Integer.MAX_VALUE){
+                System.out.println(""-1"");
+            } else {
+                System.out.println(ans);
+            }
+        }
+    }
+}",0
+0889dcfb,22138fad,"import java.io.*;
+import java.util.*;
+import static java.lang.Math.*;
+
+public class C{
+	
+	static class Event implements Comparable<Event>{
+		long i;
+		int index;
+		boolean start; 
+		public Event(long a,int c, boolean b) {
+			i=a;
+			index = c;
+			start=b;
+		}
+		public int compareTo(Event o){
+			if (o.i != i) return (int)(i-o.i);
+			if (start == o.start) return 0;
+			return start ? -1:1;
+		}
+	}
+	
+	public static void main(String[] args) throws IOException{
+		// br = new BufferedReader(new FileReader("".in""));
+		// out = new PrintWriter(new FileWriter("".out""));
+		// new Thread(null, new (), ""fisa balls"", 1<<28).start();
+		
+		int t= readInt();
+		while(t-->0) {
+			int n =readInt();
+			long[] k = new long[n], h = new long[n];
+			for (int i = 0; i < n; i++) k[i]=readInt();
+			for (int i = 0; i < n; i++) h[i]=readInt();
+			List<Event> e = new ArrayList<Event>();
+			for (int i = 0 ; i <n; i++) {
+				Event e1 = new Event(k[i]-h[i]+1, i, true);
+				Event e2 = new Event(k[i], i, false);
+				e.add(e1);
+				e.add(e2);
+			}
+			Collections.sort(e);
+			long ans = 0;
+			long start = Long.MAX_VALUE;
+			long end = 0;
+			int stackSize = 0;
+			for (Event ev: e) {
+				if (ev.start) {
+					start = min(start, ev.i);
+					end = max(end, k[ev.index]);
+					stackSize++;
+				}
+				else {
+					end = max(end, ev.i);
+					stackSize--;
+					if (stackSize == 0) {
+						long diff = end-start+1;
+					//	System.out.println(""YOYO "" + diff);
+						ans += diff*(diff+1)/2;
+						
+						
+						start = Long.MAX_VALUE;
+						end = 0;
+					}
+				}
+			}
+			out.println(ans);
+		}
+		
+		out.close();
+	}
+	
+	static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+	static PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
+	static StringTokenizer st = new StringTokenizer("""");
+	static String read() throws IOException{
+		while (!st.hasMoreElements()) st = new StringTokenizer(br.readLine());
+		return st.nextToken();
+	}
+	public static int readInt() throws IOException{return Integer.parseInt(read());}
+	public static long readLong() throws IOException{return Long.parseLong(read());}
+}","import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.util.HashMap;
+import java.util.PriorityQueue;
+import java.util.StringTokenizer;
+
+public class MonstersAndSpells {
+	
+	static long rangeSum(long l, long r) {
+		return ((r*(r+1))/2) - ((l*(l-1))/2);
+	}
+	
+	static class Event implements Comparable<Event> {
+		
+		int time;
+		int monsterNum;
+		boolean isMonster;
+		
+		public Event(int time, int monsterNum, boolean isMonster) {
+			this.time = time; this.monsterNum = monsterNum; this.isMonster = isMonster;
+		}
+		
+		@Override
+		public int compareTo(Event o) {
+			if(time == o.time) {
+				if(!(isMonster ^ o.isMonster)) {
+					return monsterNum - o.monsterNum;
+				}
+				if(o.isMonster) {
+					return -1;
+				}
+				return 1;
+			}
+			return time - o.time;
+		}
+		
+	}
+	
+	public static void main(String[] args) throws IOException {
+		
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		PrintWriter pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
+		StringTokenizer st = new StringTokenizer(br.readLine());
+		
+		int t = Integer.parseInt(st.nextToken());
+		
+		for(int test = 0; test < t; test++) {
+			
+			st = new StringTokenizer(br.readLine());
+			
+			int n = Integer.parseInt(st.nextToken());
+			
+			int[] k = new int[n];
+			int[] h = new int[n];
+			
+			st = new StringTokenizer(br.readLine());
+			for(int i = 0; i < n; i++)
+				k[i] = Integer.parseInt(st.nextToken());
+			
+			st = new StringTokenizer(br.readLine());
+			for(int i = 0; i < n; i++)
+				h[i] = Integer.parseInt(st.nextToken());
+			
+			int[] latestStart = new int[n];
+			
+			for(int i = 0; i < n; i++) {
+				latestStart[i] = k[i] - h[i] + 1;
+			}
+			
+			
+			
+			PriorityQueue<Event> pq = new PriorityQueue<Event>();
+			for(int i = 0; i < n; i++) {
+				pq.add(new Event(k[i],i,true));
+				pq.add(new Event(latestStart[i],i,false));
+			}
+			
+			long manaUsed = 0;
+			int lastEvent = 0;
+			
+			HashMap<Integer, Event> waiting = new HashMap<Integer, Event>();
+			
+			long currentSpell = 1;
+			
+			//pw.println(""NEW GAME"");
+			
+			while(!pq.isEmpty()) {
+				
+				Event nextEvent = pq.poll();
+				
+				if(!waiting.isEmpty() && nextEvent.time > lastEvent) {
+					manaUsed += rangeSum(currentSpell+1, currentSpell + nextEvent.time - lastEvent);
+					currentSpell = currentSpell + nextEvent.time - lastEvent;
+				}
+				if(waiting.isEmpty()) {
+					currentSpell = 1;
+					manaUsed++;
+				}
+				
+				//pw.println(manaUsed + "" "" + currentSpell + "" "" + nextEvent.monsterNum + "" "" + nextEvent.isMonster);
+				
+				if(nextEvent.isMonster) {
+					waiting.remove(nextEvent.monsterNum);
+					
+				}
+				
+				if(!nextEvent.isMonster) {
+					waiting.put(nextEvent.monsterNum,nextEvent);
+				}
+				
+				lastEvent = nextEvent.time;
+					
+			}
+			
+			pw.println(manaUsed);
+			
+		}
+		
+		pw.close();
+		
+	}
+
+}
+",0
+35857a5a,ab7507bf,"import java.io.PrintWriter;
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.*;
+public class solution { 
+    public static void main(String args[]) throws java.lang.Exception{ 
+    	FastScanner s=new FastScanner();
+		PrintWriter out=new PrintWriter(System.out);
+		int t=s.nextInt();
+		for(int tt=0;tt<t;tt++) {
+			int n=s.nextInt();
+			int c[][]=new int[n][5];
+			int sum[]=new int[5];
+			for(int i=0;i<n;i++) {
+				String a=s.next();
+				for(int j=0;j<a.length();j++) {
+					c[i][a.charAt(j)-'a']++;
+				}
+				for(int j=0;j<5;j++) {
+					sum[j]+=c[i][j];
+				}
+			}
+			int sum1=0;
+			for(int i=0;i<5;i++) {
+				sum1+=sum[i];
+			}
+			int ans=0;
+			
+			for(int i=0;i<5;i++) {
+				int sum2=sum1-sum[i];
+				//out.println(sum2);
+				if(sum[i]>sum2) {
+					ans=n;
+					break;
+				}else {
+					
+					ArrayList<Integer> f=new ArrayList<>();
+					for(int j=0;j<n;j++) {
+						int sum3=0;
+						for(int k=0;k<5;k++) {
+							if(k!=i) {
+								sum3+=c[j][k];
+							}else {
+								sum3-=c[j][k];
+							}
+						}
+						f.add(sum3);
+					}
+					Collections.sort(f);
+					while(sum[i]<=sum2 && f.size()>0 && f.get(f.size()-1)>0) {
+						sum2-=f.get(f.size()-1);
+						f.remove(f.size()-1);
+						//out.println(sum2);
+					}
+					if(sum[i]>sum2) {
+						ans=Math.max(ans,f.size());
+					}
+					//out.println(ans+"" Ayush"");
+				}
+			}
+			out.println(ans);
+		}
+		out.close();
+    }
+    public static int modulus(int a,int b) {
+    	int ans=a%b;
+    	if(ans<0) {
+    		ans=b+ans;
+    	}
+    	return ans;
+    }
+    static void sort(long [] a) {
+		ArrayList<Long> l=new ArrayList<>();
+		for (long i:a) l.add(i);
+		Collections.sort(l);
+		for (int i=0; i<a.length; i++) a[i]=l.get(i);
+	}
+    static void sort(int [] a) {
+		ArrayList<Integer> l=new ArrayList<>();
+		for (int i:a) l.add(i);
+		Collections.sort(l);
+		for (int i=0; i<a.length; i++) a[i]=l.get(i);
+	}
+    static int gcd(int a, int b){
+      if (b == 0)
+        return a;
+      return gcd(b, a % b);
+    }
+    static void sortcol(int a[][],int c) {
+		Arrays.sort(a, (x, y) -> {
+			if(x[c]>y[c]) {
+				return 1;
+			}else {
+				return -1;
+			}
+		});
+	}
+    public static void printb(boolean ans) {
+    	if(ans) {
+    		System.out.println(""Yes"");
+    	}else {
+    		System.out.println(""No"");
+    	}
+    }
+    static class FastScanner {
+		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st=new StringTokenizer("""");
+		String next() {
+			while (!st.hasMoreTokens())
+				try {
+					st=new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			return st.nextToken();
+		}
+		double nextDouble() {
+			return Double.parseDouble(next());
+		}
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+		int[] readArray(int n) {
+			int[] a=new int[n];
+			for (int i=0; i<n; i++) a[i]=nextInt();
+			return a;
+		}
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+	}
+    static class Pair implements Comparable<Pair>{
+    	int a , b; 
+    	Pair(int x , int y){
+    		a=x;
+    		b=y;
+    	}
+    	public int compareTo(Pair o) {
+    		return a != o.a ? a - o.a : b - o.b;
+    	}
+    }
+}
+","import java.util.*;
+import java.io.*;
+
+public class C1551 {
+
+	public static void main(String[] args) throws IOException {
+		Scanner sc = new Scanner(System.in);
+		PrintWriter pw = new PrintWriter(System.out);
+		int t = sc.nextInt();
+		while (t-- > 0) {
+			int n = sc.nextInt();
+			char[][] arr = new char[n][];
+			for (int i = 0; i < arr.length; i++) {
+				arr[i] = sc.next().toCharArray();
+			}
+			int[][] cnt = new int[n][5];
+			for (int i = 0; i < cnt.length; i++) {
+				for (char c : arr[i]) {
+					cnt[i][c - 'a']++;
+				}
+			}
+			int fans = 0;
+			for (int letter = 0; letter < 5; letter++) {
+				ArrayList<Integer> al = new ArrayList<Integer>();
+				for (int i = 0; i < n; i++) {
+					al.add(2 * cnt[i][letter] - arr[i].length);
+				}
+				Collections.sort(al, Collections.reverseOrder());
+				int sum = 0;
+				int ans = 0;
+				for (int x : al) {
+					sum += x;
+					if (sum > 0) {
+						ans++;
+					} else {
+						break;
+					}
+				}
+				fans = Math.max(ans, fans);
+			}
+			pw.println(fans);
+		}
+		pw.close();
+	}
+
+	static class Scanner {
+		BufferedReader br;
+		StringTokenizer st;
+
+		public Scanner(InputStream s) {
+			br = new BufferedReader(new InputStreamReader(s));
+		}
+
+		public Scanner(FileReader f) {
+			br = new BufferedReader(f);
+		}
+
+		public String next() throws IOException {
+			while (st == null || !st.hasMoreTokens())
+				st = new StringTokenizer(br.readLine());
+			return st.nextToken();
+		}
+
+		public int nextInt() throws IOException {
+			return Integer.parseInt(next());
+		}
+
+		public long nextLong() throws IOException {
+			return Long.parseLong(next());
+		}
+
+		public double nextDouble() throws IOException {
+			return Double.parseDouble(next());
+		}
+
+		public int[] nextIntArr(int n) throws IOException {
+			int[] arr = new int[n];
+			for (int i = 0; i < n; i++) {
+				arr[i] = Integer.parseInt(next());
+			}
+			return arr;
+		}
+
+	}
+
+}
+",0
+bdfe8110,e6a6e318,"import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.StringTokenizer;
+
+public class E {
+
+	public static void main(String[] args) {
+		FastScanner fs=new FastScanner();
+		int T=fs.nextInt();
+		PrintWriter out=new PrintWriter(System.out);
+		for (int tt=0; tt<T; tt++) {
+			int n=fs.nextInt(), k=fs.nextInt();
+			int[] positions=fs.readArray(k), temps=fs.readArray(k);
+			int[] forced=new int[n];
+			Arrays.fill(forced, Integer.MAX_VALUE/2);
+			for (int i=0; i<k; i++) forced[positions[i]-1]=temps[i];
+			for (int i=1; i<n; i++)
+				forced[i]=Math.min(forced[i], forced[i-1]+1);
+			for (int i=n-2; i>=0; i--)
+				forced[i]=Math.min(forced[i], forced[i+1]+1);
+			for (int i=0; i<n; i++) out.print(forced[i]+"" "");
+			out.println();
+			
+		}
+		out.close();
+	}
+
+	static void sort(int[] a) {
+		ArrayList<Integer> l=new ArrayList<>();
+		for (int i:a) l.add(i);
+		Collections.sort(l);
+		for (int i=0; i<a.length; i++) a[i]=l.get(i);
+	}
+	
+	static class FastScanner {
+		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st=new StringTokenizer("""");
+		String next() {
+			while (!st.hasMoreTokens())
+				try {
+					st=new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			return st.nextToken();
+		}
+		
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+		int[] readArray(int n) {
+			int[] a=new int[n];
+			for (int i=0; i<n; i++) a[i]=nextInt();
+			return a;
+		}
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+	}
+
+	
+}
+
+","//package codeforces;
+import java.io.PrintWriter;
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.*;
+public class solution { 
+    public static void main(String args[]) throws java.lang.Exception{ 
+    	FastScanner s=new FastScanner();
+		PrintWriter out=new PrintWriter(System.out);
+		int t=s.nextInt();
+		for(int tt=0;tt<t;tt++) {
+			int n=s.nextInt(), k=s.nextInt();
+			int[] a=s.readArray(k), temp=s.readArray(k);
+			long[] ans=new long[n];
+			Arrays.fill(ans, Integer.MAX_VALUE);
+			for (int i=0; i<k; i++) {
+				ans[a[i]-1]=temp[i];
+			}
+			for (int i=1; i<n; i++) {
+				ans[i]=Math.min(ans[i],ans[i-1]+1);
+			}
+			for (int i=n-2; i>=0; i--) {
+				ans[i]=Math.min(ans[i],ans[i+1]+1);
+			}
+			for (int i=0; i<n; i++) {
+				out.print(ans[i]+"" "");
+			}
+			out.println();
+		}
+		out.close();
+    }
+    static void sort(long [] a) {
+		ArrayList<Long> l=new ArrayList<>();
+		for (long i:a) l.add(i);
+		Collections.sort(l);
+		for (int i=0; i<a.length; i++) a[i]=l.get(i);
+	}
+    static void sort(int [] a) {
+		ArrayList<Integer> l=new ArrayList<>();
+		for (int i:a) l.add(i);
+		Collections.sort(l);
+		for (int i=0; i<a.length; i++) a[i]=l.get(i);
+	}
+    static int gcd(int a, int b){
+      if (b == 0)
+        return a;
+      return gcd(b, a % b);
+    }
+    static void sortcol(int a[][],int c) {
+		Arrays.sort(a, (x, y) -> {
+			if(x[c]>y[c]) {
+				return 1;
+			}else {
+				return -1;
+			}
+		});
+	
+	}
+    public static void printb(boolean ans) {
+    	if(ans) {
+    		System.out.println(""Yes"");
+    	}else {
+    		System.out.println(""No"");
+    	}
+    }
+    static class FastScanner {
+		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st=new StringTokenizer("""");
+		String next() {
+			while (!st.hasMoreTokens())
+				try {
+					st=new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			return st.nextToken();
+		}
+		double nextDouble() {
+			return Double.parseDouble(next());
+		}
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+		int[] readArray(int n) {
+			int[] a=new int[n];
+			for (int i=0; i<n; i++) a[i]=nextInt();
+			return a;
+		}
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+	}
+    static class Pair implements Comparable<Pair>{
+    	int a , b; 
+    	Pair(int x , int y){
+    		a=x;
+    		b=y;
+    	}
+    	public int compareTo(Pair o) {
+    		return a != o.a ? a - o.a : b - o.b;
+    	}
+    }
+}
+",1
+016510dc,f1540246,"import java.io.OutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.PrintWriter;
+import java.util.ArrayList;
+import java.util.StringTokenizer;
+import java.io.IOException;
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.io.InputStream;
+
+public class TaskC {
+    public static void main(String[] args) {
+        InputStream inputStream = System.in;
+        OutputStream outputStream = System.out;
+        FastReader in = new FastReader(inputStream);
+        PrintWriter out = new PrintWriter(outputStream);
+        Solver solver = new Solver();
+        int testCount = Integer.parseInt(in.next());
+        for (int i = 1; i <= testCount; i++)
+            solver.solve(i, in, out);
+        out.close();
+    }
+
+    static class Solver {
+        public void solve(int testNumber, FastReader in, PrintWriter out) {
+            int n = in.nextInt(),m = in.nextInt();
+            int[][] a = new int[n][m];
+            for(int i=0;i<n;i++){
+                String s = in.next();
+                for(int j=0;j<m;j++){
+                    a[i][j] = (s.charAt(j)-'0');
+                }
+            }
+            ArrayList<Pair> ans = new ArrayList<>();
+            for(int i=0;i<=n-2;i++){
+                for(int j=0;j<=m-2;j++) {
+                    int cnt = 0;
+                    if (a[i][j] == 1) cnt++;
+                    if (a[i + 1][j] == 1) cnt++;
+                    if(a[i][j+1]==1) cnt++;
+                    if(a[i+1][j+1]==1) cnt++;
+                    if(cnt==4){
+                        a[i][j] = 0;
+                        a[i+1][j] = 0;
+                        a[i+1][j+1] = 0;
+                        ans.add(new Pair((i+1),(j+1)));
+                        ans.add(new Pair((i+2),(j+1)));
+                        ans.add(new Pair((i+2),(j+2)));
+//                        out.println();
+                        cnt = 1;
+                    }
+                    if(cnt==1){
+                        boolean flag = false;
+                        for(int x=0;x<2;x++){
+                            for(int y=0;y<2;y++){
+                                if(a[i+x][j+y]==1){
+//                                    out.print((i+1+x)+"" ""+(j+1+y)+"" "");
+                                    ans.add(new Pair((i+1+x),(j+1+y)));
+                                    int cnt2 = 1;
+                                    for(int sx=0;sx<2;sx++){
+                                        for(int sy=0;sy<2;sy++){
+                                            if(a[i+sx][j+sy]!=1){
+//                                                out.print((i+sx+1)+"" ""+(j+1+sy)+"" "");
+                                                a[i+sx][j+sy]=1;
+                                                ans.add(new Pair((i+sx+1),(j+sy+1)));
+                                                cnt2++;
+                                                if(cnt2==3){
+                                                    a[i+x][j+y]=0;
+                                                    flag = true;
+                                                    break;
+                                                }
+                                            }
+                                        }
+                                        if(flag) break;
+                                    }
+                                    if(flag) break;
+                                }
+                                if(flag) break;
+                            }
+                            if(flag) break;
+                        }
+//                        out.println();
+                        cnt = 2;
+                    }
+                    if(cnt==2){
+                        boolean flag = false;
+                        for(int x=0;x<2;x++){
+                            for(int y=0;y<2;y++){
+                                if(a[i+x][j+y]==1){
+//                                    out.print((i+1+x)+"" ""+(j+1+y)+"" "");
+                                    ans.add(new Pair((i+1+x),(j+1+y)));
+                                    int cnt2 = 1;
+                                    for(int sx=0;sx<2;sx++){
+                                        for(int sy=0;sy<2;sy++){
+                                            if(a[i+sx][j+sy]!=1){
+//                                                out.print((i+sx+1)+"" ""+(j+1+sy)+"" "");
+                                                cnt2++;
+                                                ans.add(new Pair((i+sx+1),(j+1+sy)));
+                                                a[i+sx][j+sy]=1;
+                                                if(cnt2==3){
+                                                    a[i+x][j+y]=0;
+                                                    flag = true;
+                                                    break;
+                                                }
+                                            }
+                                        }
+                                        if(flag) break;
+                                    }
+                                    if(flag) break;
+                                }
+                                if(flag) break;
+                            }
+                            if(flag) break;
+                        }
+//                        out.println();
+                        cnt = 3;
+                    }
+                    if(cnt==3){
+                        for(int x=0;x<2;x++){
+                            for(int y=0;y<2;y++){
+                                if(a[i+x][j+y]==1){
+                                    a[i+x][j+y]=0;
+                                    ans.add(new Pair((i+1+x),(j+1+y)));
+//                                    out.print((i+1+x)+"" ""+(j+1+y)+"" "");
+                                }
+                            }
+                        }
+//                            out.println();
+                    }
+                }
+            }
+            out.println((ans.size())/3);
+            for(int i=0;i<ans.size();i+=3){
+                for(int j=0;j<=2;j++){
+                    out.print(ans.get(i+j).a+"" ""+ans.get(i+j).b+ "" "");
+                }
+                out.println();
+            }
+        }
+    }
+    static class Pair{
+        int a,b;
+        public Pair(int a,int b){
+            this.a=a;
+            this.b=b;
+        }
+    }
+    static class FastReader {
+        BufferedReader br;
+        StringTokenizer st;
+
+        public FastReader(InputStream stream){
+            br = new BufferedReader(new
+                InputStreamReader(stream));
+        }
+
+        public String next(){
+            while (st == null || !st.hasMoreElements()){
+                try{
+                    st = new StringTokenizer(br.readLine());
+                }
+                catch (IOException e){
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        public int nextInt(){
+            return Integer.parseInt(next());
+        }
+
+        public long nextLong(){
+            return Long.parseLong(next());
+        }
+
+        public double nextDouble(){
+            return Double.parseDouble(next());
+        }
+
+        public String nextLine(){
+            String str = """";
+            try{
+                str = br.readLine();
+            }
+            catch (IOException e){
+                e.printStackTrace();
+            }
+            return str;
+        }
+
+        public int[] nextArray(int n) {
+            int[] a=new int[n];
+            for (int i=0; i<n; i++) a[i]=nextInt();
+                return a;
+        }
+    }
+}
+
+","//package codeforces.round684div2;
+
+import java.io.*;
+import java.util.*;
+
+public class C {
+    static InputReader in;
+    static PrintWriter out;
+
+    public static void main(String[] args) {
+        //initReaderPrinter(true);
+        initReaderPrinter(false);
+        solve(in.nextInt());
+        //solve(1);        
+    }
+
+    static void solve(int testCnt) {
+        for (int testNumber = 0; testNumber < testCnt; testNumber++) {
+            int n = in.nextInt(), m = in.nextInt();
+            char[][] g = new char[n][];
+            for(int i = 0; i < n; i++) {
+                g[i] = in.next().toCharArray();
+            }
+            List<List<Integer>> list = new ArrayList<>();
+            for(int i = 0; i < n - 1; i++) {
+                for(int j = 0; j < m - 1; j++) {
+                    list.addAll(change(g, i, j));
+                }
+            }
+            out.println(list.size());
+            for(int i = 0; i < list.size(); i++) {
+                for(int j = 0; j < 6; j++) {
+                    out.print(list.get(i).get(j) + "" "");
+                }
+                out.println();
+            }
+        }
+        out.close();
+    }
+
+    static List<List<Integer>> change(char[][] g, int i, int j) {
+        List<List<Integer>> list = new ArrayList<>();
+        int cnt = 0;
+        cnt += g[i][j] - '0';
+        cnt += g[i][j + 1] - '0';
+        cnt += g[i + 1][j] - '0';
+        cnt += g[i + 1][j + 1] - '0';
+        if(cnt != 0) {
+            if(cnt == 4) {
+                List<Integer> op = new ArrayList<>();
+                op.add(i + 1); op.add(j + 1 + 1); op.add(i + 1 + 1); op.add(j + 1); op.add(i + 1 + 1); op.add(j + 1 + 1);
+                list.add(op);
+                g[i][j + 1] = '0';
+                g[i + 1][j] = '0';
+                g[i + 1][j + 1] = '0';
+                cnt = 1;
+            }
+            if(cnt == 1) {
+                List<Integer> op = new ArrayList<>();
+                int zeroCnt = 0;
+                for(int k1 = 0; k1 < 2; k1++) {
+                    for(int k2 = 0; k2 < 2; k2++) {
+                        if(g[i + k1][j + k2] == '0' && zeroCnt < 2) {
+                            op.add(i + k1 + 1);
+                            op.add(j + k2 + 1);
+                            zeroCnt++;
+                        }
+                        else if(g[i + k1][j + k2] == '1'){
+                            op.add(i + k1 + 1);
+                            op.add(j + k2 + 1);
+                        }
+                    }
+                }
+                list.add(op);
+                zeroCnt = 0;
+                for(int k1 = 0; k1 < 2; k1++) {
+                    for(int k2 = 0; k2 < 2; k2++) {
+                        if(g[i + k1][j + k2] == '0' && zeroCnt < 2) {
+                            g[i + k1][j + k2] = '1';
+                            zeroCnt++;
+                        }
+                        else if(g[i + k1][j + k2] == '1'){
+                            g[i + k1][j + k2] = '0';
+                        }
+                    }
+                }
+                cnt = 2;
+            }
+            if(cnt == 2) {
+                List<Integer> op = new ArrayList<>();
+                int oneCnt = 0;
+                for(int k1 = 0; k1 < 2; k1++) {
+                    for(int k2 = 0; k2 < 2; k2++) {
+                        if(g[i + k1][j + k2] == '0') {
+                            op.add(i + k1 + 1);
+                            op.add(j + k2 + 1);
+                        }
+                        else if(oneCnt < 1){
+                            op.add(i + k1 + 1);
+                            op.add(j + k2 + 1);
+                            oneCnt++;
+                        }
+                    }
+                }
+                list.add(op);
+                oneCnt = 0;
+                for(int k1 = 0; k1 < 2; k1++) {
+                    for(int k2 = 0; k2 < 2; k2++) {
+                        if(g[i + k1][j + k2] == '0') {
+                            g[i + k1][j + k2] = '1';
+                        }
+                        else if(oneCnt < 1){
+                            g[i + k1][j + k2] = '0';
+                            oneCnt++;
+                        }
+                    }
+                }
+                cnt = 3;
+            }
+            if(cnt == 3) {
+                List<Integer> op = new ArrayList<>();
+                for(int k1 = 0; k1 < 2; k1++) {
+                    for(int k2 = 0; k2 < 2; k2++) {
+                        if(g[i + k1][j + k2] == '1') {
+                            op.add(i + k1 + 1);
+                            op.add(j + k2 + 1);
+                        }
+                    }
+                }
+                list.add(op);
+            }
+            for(int k1 = 0; k1 < 2; k1++) {
+                for(int k2 = 0; k2 < 2; k2++) {
+                    g[i + k1][j + k2] = '0';
+                }
+            }
+        }
+        return list;
+    }
+
+    static void initReaderPrinter(boolean test) {
+        if (test) {
+            try {
+                in = new InputReader(new FileInputStream(""src/input.in""));
+                out = new PrintWriter(new FileOutputStream(""src/output.out""));
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+        } else {
+            in = new InputReader(System.in);
+            out = new PrintWriter(System.out);
+        }
+    }
+
+    static class InputReader {
+        BufferedReader br;
+        StringTokenizer st;
+
+        InputReader(InputStream stream) {
+            try {
+                br = new BufferedReader(new InputStreamReader(stream), 32768);
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }
+
+        String next() {
+            while (st == null || !st.hasMoreTokens()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+
+        String nextLine() {
+            String str = """";
+            try {
+                str = br.readLine();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+        }
+
+        Integer[] nextIntArray(int n) {
+            Integer[] a = new Integer[n];
+            for (int i = 0; i < n; i++) {
+                a[i] = nextInt();
+            }
+            return a;
+        }
+
+        Long[] nextLongArray(int n) {
+            Long[] a = new Long[n];
+            for (int i = 0; i < n; i++) {
+                a[i] = nextLong();
+            }
+            return a;
+        }
+    }
+}
+
+
+",0
+317a209c,548ffb07,"import java.io.*;
+import java.util.*;
+
+public class D_Java {
+	public static final int MOD = 998244353;
+	
+	public static int mul(int a, int b) {
+		return (int)((long)a * (long)b % MOD);
+	}
+	
+	int[] f;
+	int[] rf;
+	
+	public int C(int n, int k) {
+		return (k < 0 || k > n) ? 0 : mul(f[n], mul(rf[n-k], rf[k]));
+	}
+	
+	public static int pow(int a, int n) {
+		int res = 1;
+		while (n != 0) {
+			if ((n & 1) == 1) {
+				res = mul(res, a);
+			}
+			a = mul(a, a);
+			n >>= 1;
+		}
+		return res;
+	}
+	
+	static void shuffleArray(int[] a) {
+		Random rnd = new Random();
+		for (int i = a.length-1; i > 0; i--) {
+			int index = rnd.nextInt(i + 1);
+			int tmp = a[index];
+			a[index] = a[i];
+			a[i] = tmp;
+		}
+	}
+	
+	public static int inv(int a) {
+		return pow(a, MOD-2);
+	}
+	
+	public void doIt() throws IOException {
+		BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
+		
+		StringTokenizer tok = new StringTokenizer(in.readLine());
+		int n = Integer.parseInt(tok.nextToken());
+		int k = Integer.parseInt(tok.nextToken());
+		
+		f = new int[n+42];
+		rf = new int[n+42];
+		f[0] = rf[0] = 1;
+		for (int i = 1; i < f.length; ++i) {
+			f[i] = mul(f[i-1], i);
+			rf[i] = mul(rf[i-1], inv(i));
+		}
+		
+		int[] events = new int[2*n];
+		for (int i = 0; i < n; ++i) {
+			tok = new StringTokenizer(in.readLine());
+			int le = Integer.parseInt(tok.nextToken());
+			int ri = Integer.parseInt(tok.nextToken());
+			events[i] = le*2;
+			events[i + n] = ri*2 + 1;
+		}
+		shuffleArray(events);
+		Arrays.sort(events);
+		
+		int ans = 0;
+		int balance = 0;
+		for (int r = 0; r < 2*n;) {
+			int l = r;
+			while (r < 2*n && events[l] == events[r]) {
+				++r;
+			}
+			int added = r - l;
+			if (events[l] % 2 == 0) {
+				// Open event
+				ans += C(balance + added, k);
+				if (ans >= MOD) ans -= MOD;
+				ans += MOD - C(balance, k);
+				if (ans >= MOD) ans -= MOD;
+				balance += added;
+			} else {
+				// Close event
+				balance -= added;
+			}
+		}
+		
+		in.close();
+		System.out.println(ans);
+	}
+	
+	public static void main(String[] args) throws IOException {
+		(new D_Java()).doIt();
+	}
+}","import java.io.*;
+import java.util.*;
+
+public class D_Java {
+	public static final int MOD = 998244353;
+	
+	public static int mul(int a, int b) {
+		return (int)((long)a * (long)b % MOD);
+	}
+	
+	int[] f;
+	int[] rf;
+	
+	public int C(int n, int k) {
+		return (k < 0 || k > n) ? 0 : mul(f[n], mul(rf[n-k], rf[k]));
+	}
+	
+	public static int pow(int a, int n) {
+		int res = 1;
+		while (n != 0) {
+			if ((n & 1) == 1) {
+				res = mul(res, a);
+			}
+			a = mul(a, a);
+			n >>= 1;
+		}
+		return res;
+	}
+	
+	static void shuffleArray(int[] a) {
+		Random rnd = new Random();
+		for (int i = a.length-1; i > 0; i--) {
+			int index = rnd.nextInt(i + 1);
+			int tmp = a[index];
+			a[index] = a[i];
+			a[i] = tmp;
+		}
+	}
+	
+	public static int inv(int a) {
+		return pow(a, MOD-2);
+	}
+	
+	public void doIt() throws IOException {
+		BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
+		
+		StringTokenizer tok = new StringTokenizer(in.readLine());
+		int n = Integer.parseInt(tok.nextToken());
+		int k = Integer.parseInt(tok.nextToken());
+		
+		f = new int[n+42];
+		rf = new int[n+42];
+		f[0] = rf[0] = 1;
+		for (int i = 1; i < f.length; ++i) {
+			f[i] = mul(f[i-1], i);
+			rf[i] = mul(rf[i-1], inv(i));
+		}
+		
+		int[] events = new int[2*n];
+		for (int i = 0; i < n; ++i) {
+			tok = new StringTokenizer(in.readLine());
+			int le = Integer.parseInt(tok.nextToken());
+			int ri = Integer.parseInt(tok.nextToken());
+			events[i] = le*2;
+			events[i + n] = ri*2 + 1;
+		}
+		shuffleArray(events);
+		Arrays.sort(events);
+		
+		int ans = 0;
+		int balance = 0;
+		for (int r = 0; r < 2*n;) {
+			int l = r;
+			while (r < 2*n && events[l] == events[r]) {
+				++r;
+			}
+			int added = r - l;
+			if (events[l] % 2 == 0) {
+				// Open event
+				ans += C(balance + added, k);
+				if (ans >= MOD) ans -= MOD;
+				ans += MOD - C(balance, k);
+				if (ans >= MOD) ans -= MOD;
+				balance += added;
+			} else {
+				// Close event
+				balance -= added;
+			}
+		}
+		
+		in.close();
+		System.out.println(ans);
+	}
+	
+	public static void main(String[] args) throws IOException {
+		(new D_Java()).doIt();
+	}
+}
+",1
+2eb89317,fcc7e8fa,"import java.util.*;
+import java.io.*;
+
+////***************************************************************************
+ /* public class E_Gardener_and_Tree implements Runnable{
+
+       public static void main(String[] args) throws Exception {
+        new Thread(null, new E_Gardener_and_Tree(), ""E_Gardener_and_Tree"", 1<<28).start();
+       }
+    public void run(){
+         WRITE YOUR CODE HERE!!!!
+         JUST WRITE EVERYTHING HERE WHICH YOU WRITE IN MAIN!!!
+       }
+
+  }
+*/
+/////**************************************************************************
+
+
+public class C_Menorah{
+    public static void main(String[] args) {
+        FastScanner s= new FastScanner();
+        //PrintWriter out=new PrintWriter(System.out);
+        //end of program
+        //out.println(answer);
+        //out.close();
+        StringBuilder res = new StringBuilder();
+        int t=s.nextInt();
+        int p=0;
+        
+        while(p<t){
+        int n=s.nextInt();
+        String str1=s.nextToken();
+        String str2=s.nextToken();
+       
+        if(str1.equals(str2)){
+            res.append(""0 \n"");
+        }
+      
+        else{
+            long count1=0;
+            long count0=0;
+            for(int i=0;i<n;i++){
+                char ch=str1.charAt(i);
+                if(ch=='1'){
+                    count1++;
+                }
+            }
+            count0=n-count1;
+            if(count1==0){
+                res.append(""-1 \n"");
+            }
+            else{
+                long nice1=0;
+                long nice0=0;
+                for(int i=0;i<n;i++){
+                    char ch=str2.charAt(i);
+                    if(ch=='1'){
+                        nice1++;
+                    }
+                }
+                nice0=(n-nice1);
+                int check1=0;
+                int check2=0;
+                if((count1==nice1)&&(count0==nice0)){
+                    check1=1;
+                }
+                long yo1=(1+count0);
+                long yo0=(count1-1);
+                if((yo1==nice1)&&(yo0==nice0)){
+                    check2=1;
+                }
+                if(check1==0 && check2==0){
+                    res.append(""-1 \n"");
+                }
+                else{
+                    //System.out.println(""here"");
+                    long correct=0;
+                    long wrong=0;
+                    long correct1=0;
+                    long correct0=0;
+                    long wrong1=0;
+                    long wrong0=0;
+                   
+                    for(int i=0;i<n;i++){
+                        char ch1=str1.charAt(i);
+                        char ch2=str2.charAt(i);
+                        if(ch1==ch2){
+                            correct++;
+                            if(ch1=='1'){
+                                correct1++;
+                            }
+                            else{
+                                correct0++;
+                            }
+                        }
+                        else{
+                            wrong++;
+                            if(ch1=='1'){
+                                wrong1++;
+                            }
+                            else{
+                                wrong0++;
+                            }
+                        }
+                    }
+              long ans1=      solve(correct1,correct0,wrong1,wrong0,1);
+              long ans2=      solve(correct1,correct0,wrong1,wrong0,0);
+              long ans=Math.min(ans1,ans2);
+              if(ans>=Integer.MAX_VALUE){
+                  ans=-1;
+              }
+              res.append(ans+"" \n"");
+                  
+                    
+                   
+                }
+
+
+
+            }
+
+        }
+        p++;
+    }
+    
+    System.out.println(res);
+    
+    }
+    private static long solve( long correct1, long correct0, long wrong1, long wrong0,long a) {
+               long op1=Integer.MAX_VALUE;
+               long op2=Integer.MAX_VALUE;
+               if(wrong1==0 && wrong0==0){
+                   return 0;
+               }
+               if(a==1){
+               {
+                   // using correct1
+                   if(correct1>0){
+                       long newcorrect1=1+wrong0;
+                       long newcorrect0=wrong1;
+                       long newwrong1=correct0;
+                       long newwrong0=correct1-1;
+                       op1=(1+solve(newcorrect1,newcorrect0,newwrong1,newwrong0,0));
+
+                   }
+               }
+            }
+            else{
+
+               {
+                   //using wrong1
+                   {
+                       if(wrong1>0){
+                        long newcorrect1=wrong0;
+                        long newcorrect0=wrong1-1;
+                        long newwrong1=1+correct0;
+                        long newwrong0=correct1;
+                        op2=(1+solve(newcorrect1,newcorrect0,newwrong1,newwrong0,1));
+                       }
+                   }
+               }
+            }  
+               long ans=Math.min(op1,op2);
+               return ans;
+    
+    }
+    static class FastScanner {
+		BufferedReader br;
+		StringTokenizer st;
+ 
+		public FastScanner(String s) {
+			try {
+				br = new BufferedReader(new FileReader(s));
+			} catch (FileNotFoundException e) {
+				// TODO Auto-generated catch block
+				e.printStackTrace();
+			}
+		}
+ 
+		public FastScanner() {
+			br = new BufferedReader(new InputStreamReader(System.in));
+		}
+ 
+		String nextToken() {
+			while (st == null || !st.hasMoreElements()) {
+				try {
+					st = new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					// TODO Auto-generated catch block
+					e.printStackTrace();
+				}
+			}
+			return st.nextToken();
+		}
+ 
+		int nextInt() {
+			return Integer.parseInt(nextToken());
+		}
+ 
+		long nextLong() {
+			return Long.parseLong(nextToken());
+		}
+ 
+		double nextDouble() {
+			return Double.parseDouble(nextToken());
+		}
+	}
+
+
+    static long modpower(long x, long y, long p)
+     {
+      long res = 1; // Initialize result
+   
+      x = x % p; // Update x if it is more than or
+      // equal to p
+   
+      if (x == 0)
+        return 0; // In case x is divisible by p;
+   
+      while (y > 0)
+      {
+   
+        // If y is odd, multiply x with result
+        if ((y & 1) != 0)
+          res = (res * x) % p;
+   
+        // y must be even now
+        y = y >> 1; // y = y/2
+        x = (x * x) % p;
+      }
+      return res;
+    }
+
+  
+   // SIMPLE POWER FUNCTION=>
+
+
+      static long power(long x, long y)
+        {
+            long res = 1;     // Initialize result
+        
+            while (y > 0)
+            {
+            
+                // If y is odd, multiply x with result
+                if ((y & 1) != 0)
+                    res = res * x;
+        
+                // y must be even now
+                y = y >> 1; // y = y/2
+                x = x * x;  // Change x to x^2
+            }
+            return res;
+        }
+
+
+
+
+
+}","import java.io.OutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.PrintWriter;
+import java.util.*;
+import java.io.IOException;
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.io.InputStream;
+
+public class Main {
+
+    public static void main(String[] args) {
+        InputStream inputStream = System.in;
+        OutputStream outputStream = System.out;
+        InputReader in = new InputReader(inputStream);
+        PrintWriter out = new PrintWriter(outputStream);
+        TaskA solver = new TaskA();
+        int t;
+        t = in.nextInt();
+        //t = 1;
+        while (t > 0) {
+            solver.call(in,out);
+            t--;
+        }
+        out.close();
+    }
+
+    static class TaskA {
+        public void call(InputReader in, PrintWriter out) {
+            int n, _00 = 0, _01 = 0, _11 = 0, _10 = 0;
+            n = in.nextInt();
+            char[] s = in.next().toCharArray();
+            char[] s1 = in.next().toCharArray();
+
+            for (int i = 0; i < n; i++) {
+                if(s[i]==s1[i]){
+                    if(s[i]=='0'){
+                        _00++;
+                    }
+                    else{
+                        _11++;
+                    }
+                }
+                else{
+                    if(s[i]=='0'){
+                        _01++;
+                    }
+                    else{
+                        _10++;
+                    }
+                }
+            }
+            int ans = Integer.MAX_VALUE;
+
+            if(_10 ==_01){
+                ans = 2*_01;
+            }
+            if(_11 == _00 + 1){
+                ans = Math.min(ans, 2*_00 + 1);
+            }
+
+            if(ans == Integer.MAX_VALUE){
+                out.println(-1);
+            }
+            else{
+                out.println(ans);
+            }
+        }
+    }
+
+    static int gcd(int a, int b)
+    {
+        if (a == 0)
+            return b;
+        return gcd(b % a, a);
+    }
+
+    static int lcm(int a, int b)
+    {
+        return (a / gcd(a, b)) * b;
+    }
+
+    static class answer implements Comparable<answer>{
+        int a, b;
+
+        public answer(int a, int b) {
+            this.a = a;
+            this.b = b;
+        }
+
+        @Override
+        public int compareTo(answer o) {
+            return o.a - this.a;
+        }
+    }
+
+    static class arrayListClass {
+        ArrayList<Integer> arrayList2 ;
+
+        public arrayListClass(ArrayList<Integer> arrayList) {
+            this.arrayList2 = arrayList;
+        }
+    }
+
+    static long gcd(long a, long b)
+    {
+        if (b == 0)
+            return a;
+        return gcd(b, a % b);
+    }
+
+    static void sort(long[] a) {
+        ArrayList<Long> l=new ArrayList<>();
+        for (long i:a) l.add(i);
+        Collections.sort(l);
+        for (int i=0; i<a.length; i++) a[i]=l.get(i);
+    }
+
+    static final Random random=new Random();
+
+    static void shuffleSort(int[] a) {
+        int n = a.length;
+        for (int i=0; i<n; i++) {
+            int oi=random.nextInt(n), temp=a[oi];
+            a[oi]=a[i]; a[i]=temp;
+        }
+        Arrays.sort(a);
+    }
+
+    static class InputReader {
+        public BufferedReader reader;
+        public StringTokenizer tokenizer;
+
+        public InputReader(InputStream stream) {
+            reader = new BufferedReader(new InputStreamReader(stream), 32768);
+            tokenizer = null;
+        }
+
+        public String next() {
+            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
+                try {
+                    tokenizer = new StringTokenizer(reader.readLine());
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+            }
+            return tokenizer.nextToken();
+        }
+
+        public int nextInt() {
+            return Integer.parseInt(next());
+        }
+        public long nextLong(){
+            return Long.parseLong(next());
+        }
+        public double nextDouble() {
+            return Double.parseDouble(next());
+        }
+
+    }
+}",0
+3cf63146,bdfe8110,"import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.time.LocalDateTime;
+import java.util.*;
+
+public class B {
+	static int tree[];
+	static int up[];
+	static int n;
+	static int mod =1000000007; 
+	public static void main(String[] args) throws Exception {
+		PrintWriter out=new PrintWriter(System.out);
+	    FastScanner fs=new FastScanner();
+	    int t=fs.nextInt();
+	   outer: while(t-->0) {
+		    n=fs.nextInt();
+		    int k=fs.nextInt();
+		   int ac[]=fs.readArray(k);
+		   int temp[]=fs.readArray(k);
+		   int arr[]=new int[n];
+		   Arrays.fill(arr, Integer.MAX_VALUE/2);
+		   for(int i=0;i<k;i++) {
+			   int ind = ac[i]-1;
+			   arr[ind]=temp[i];
+		   }
+		   int ans[]=new int[n];
+		   int left[]=new int[n];
+		   Arrays.fill(left, Integer.MAX_VALUE/2);
+//		   int right[]=new int[n];
+		   left[0]=arr[0];
+//		   Arrays.fill(right, Integer.MAX_VALUE/2);
+		   
+//		   right[n-1]=arr[n-1];
+		   for(int i=1;i<n;i++) {
+			   left[i]=Math.min(arr[i], left[i-1]+1);
+		   }
+		   ans[n-1]=Math.min(left[n-1],arr[n-1]);
+		   for(int i=n-2;i>=0;i--) {
+			   ans[i]=Math.min(Math.min(arr[i],left[i]),ans[i+1]+1);
+		   }
+//		   for(int i=0;i<n;i++) ans[i]=Math.min(left[i], right[i]);
+		   for(int i=0;i<n;i++) out.print(ans[i]+"" "");
+		   out.println();
+	   }
+	    out.close();
+	}
+	
+	static long gcd(long  a,long  b) {
+		if(b==0) return a;
+		return gcd(b,a%b);
+	}
+	static long nck(int n,int k) {
+		if(k>n) return 0;
+		long res=1;
+		res*=fact(n);
+		res%=mod;
+		res*=modInv(fact(k));
+		res%=mod;
+		res*=modInv(fact(n-k)); 
+		res%=mod;
+		return res;
+	}
+	static long fact(long n) {
+		long res=1;
+		for(int i=2;i<=n;i++) {
+			res*=i;
+			res%=mod;
+		}
+		return res;
+	}
+	static long pow(long a,long b) {
+		long res=1;
+		while(b!=0) {
+			if((b&1)!=0) {
+				res*=a;
+				res%=mod;
+			}
+			a*=a;
+			a%=mod;
+			b=b>>1;
+		}
+		return res;
+	}
+	static long modInv(long n) {
+		return pow(n,mod-2);
+	}
+	
+	static void sort(int[] a) {
+		//suffle
+		int n=a.length;
+		Random r=new Random();
+		for (int i=0; i<a.length; i++) {
+			int oi=r.nextInt(n);
+			int temp=a[i];
+			a[i]=a[oi];
+			a[oi]=temp;
+		}
+		
+		//then sort
+		Arrays.sort(a);
+	}
+	
+	// Use this to input code since it is faster than a Scanner
+	static class FastScanner {
+		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st=new StringTokenizer("""");
+		String next() {
+			while (!st.hasMoreTokens())
+				try {
+					st=new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			return st.nextToken();
+		}
+		
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+		int[] readArray(int n) {
+			int[] a=new int[n];
+			for (int i=0; i<n; i++) a[i]=nextInt();
+			return a;
+		}
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+	}
+ 
+}","import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.StringTokenizer;
+
+public class E {
+
+	public static void main(String[] args) {
+		FastScanner fs=new FastScanner();
+		int T=fs.nextInt();
+		PrintWriter out=new PrintWriter(System.out);
+		for (int tt=0; tt<T; tt++) {
+			int n=fs.nextInt(), k=fs.nextInt();
+			int[] positions=fs.readArray(k), temps=fs.readArray(k);
+			int[] forced=new int[n];
+			Arrays.fill(forced, Integer.MAX_VALUE/2);
+			for (int i=0; i<k; i++) forced[positions[i]-1]=temps[i];
+			for (int i=1; i<n; i++)
+				forced[i]=Math.min(forced[i], forced[i-1]+1);
+			for (int i=n-2; i>=0; i--)
+				forced[i]=Math.min(forced[i], forced[i+1]+1);
+			for (int i=0; i<n; i++) out.print(forced[i]+"" "");
+			out.println();
+			
+		}
+		out.close();
+	}
+
+	static void sort(int[] a) {
+		ArrayList<Integer> l=new ArrayList<>();
+		for (int i:a) l.add(i);
+		Collections.sort(l);
+		for (int i=0; i<a.length; i++) a[i]=l.get(i);
+	}
+	
+	static class FastScanner {
+		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st=new StringTokenizer("""");
+		String next() {
+			while (!st.hasMoreTokens())
+				try {
+					st=new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			return st.nextToken();
+		}
+		
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+		int[] readArray(int n) {
+			int[] a=new int[n];
+			for (int i=0; i<n; i++) a[i]=nextInt();
+			return a;
+		}
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+	}
+
+	
+}
+
+",0
+5647d16e,ea09d197,"import static java.lang.Math.max;
+import static java.lang.Math.min;
+import static java.lang.Math.abs;
+import static java.lang.System.out;
+import java.util.*;
+import java.io.*;
+import java.math.*;
+/*
+-> Give your 100%, that's it!
+-> Rules To Solve Any Problem:
+    1. Read the problem.
+    2. Think About It.
+    3. Solve it!
+*/
+
+public class Template {
+    
+	static int mod = 1000000007;
+
+	public static void main(String[] args){
+        FastScanner sc = new FastScanner();
+        PrintWriter out = new PrintWriter(System.out);
+        int N = 100001;
+        int yo = sc.nextInt();
+        while (yo-- > 0) {
+            List<List<Integer>> list = new ArrayList<>();
+            int n = sc.nextInt();
+            for(int i = 0; i < n; i++){
+                list.add(new ArrayList<>());
+            }
+            
+            List<Pair> res = new ArrayList<>();
+            for(int i = 0; i < n-1; i++){
+                int u = sc.nextInt()-1;
+                int v = sc.nextInt()-1;
+                res.add(new Pair(u+1,v+1));
+                list.get(v).add(u);
+                list.get(u).add(v);
+            }
+            
+            boolean ok = helper(0,list,n,-1);
+            if(ok){
+                out.println(-1);
+                continue;
+            }
+            map.clear();
+            dfs(0,list,n,-1,-1);
+            for(Pair p : res){
+                int x = p.x;
+                int y = p.y;
+                out.print(map.get(x + "" "" + y) + "" "" );
+            }
+            out.println();
+            
+        }
+        out.close();
+	}
+    
+    static Map<String,Integer> map = new HashMap<>();
+    static void dfs(int curr, List<List<Integer>> list, int n, int par, int what){
+        List<Integer> neighbours = list.get(curr);
+        if(what == -1){
+            boolean three = true;
+            for(int e : neighbours){
+                String str1 = (curr+1) + "" "" + (e+1);
+                String str2 = (e+1) + "" "" + (curr+1);
+                // out.println(str1);
+                if(three){
+                    map.put(str1,3); map.put(str2,3);
+                    three = false;
+                }
+                else {
+                    map.put(str1,2);map.put(str2,2);
+                }
+                dfs(e,list,n,curr,map.get(str1));
+            }
+        }
+        else {
+            for(int e : neighbours){
+                if(e == par) continue;
+                String str1 = (curr+1) + "" "" + (e+1);
+                String str2 = (e+1) + "" "" + (curr+1);
+                if(what == 2){
+                    map.put(str1,3);map.put(str2,3);
+                }
+                else {
+                    map.put(str1,2); map.put(str2,2);
+                }
+                dfs(e,list,n,curr,map.get(str1));
+            }    
+        }
+        
+    }
+    
+    static boolean helper(int curr, List<List<Integer>> list, int n, int par){
+        if(par != -1){
+            if(list.get(curr).size() >= 3){
+                return true;
+            }
+        }
+        else {
+            if(list.get(curr).size() > 2){
+                return true;
+            }
+        }
+        List<Integer> neighbours = list.get(curr);
+        for(int e : neighbours){
+            if(e == par) continue;
+            if(helper(e,list,n,curr)){
+                return true;
+            }
+        }
+        return false;
+    }
+   
+    
+    
+    /*
+    Source: hu_tao
+         Random stuff to try when stuck:
+            - use bruteforcer
+            - check for n = 1, n = 2, so on
+            -if it's 2C then it's dp
+            -for combo/probability problems, expand the given form we're interested in
+            -make everything the same then build an answer (constructive, make everything 0 then do something)
+            -something appears in parts of 2 --> model as graph
+            -assume a greedy then try to show why it works
+            -find way to simplify into one variable if multiple exist
+            -treat it like fmc (note any passing thoughts/algo that could be used so you can revisit them)
+            -find lower and upper bounds on answer
+            -figure out what ur trying to find and isolate it
+            -see what observations you have and come up with more continuations
+            -work backwards (in constructive, go from the goal to the start)
+            -turn into prefix/suffix sum argument (often works if problem revolves around adjacent array elements)
+            -instead of solving for answer, try solving for complement (ex, find n-(min) instead of max)
+            -draw something
+            -simulate a process
+            -dont implement something unless if ur fairly confident its correct
+            -after 3 bad submissions move on to next problem if applicable
+            -do something instead of nothing and stay organized
+            -write stuff down
+         Random stuff to check when wa:
+            -if code is way too long/cancer then reassess
+            -switched N/M
+            -int overflow
+            -switched variables
+            -wrong MOD
+            -hardcoded edge case incorrectly
+         Random stuff to check when tle:
+            -continue instead of break
+            -condition in for/while loop bad
+         Random stuff to check when rte:
+            -switched N/M
+            -long to int/int overflow
+            -division by 0
+            -edge case for empty list/data structure/N=1
+      */
+
+	public static class Pair {
+		int x;
+		int y;
+
+		public Pair(int x, int y) {
+			this.x = x;
+			this.y = y;
+		}
+	}
+
+	public static void sort(int[] arr) {
+		ArrayList<Integer> ls = new ArrayList<Integer>();
+		for (int x : arr)
+			ls.add(x);
+		Collections.sort(ls);
+		for (int i = 0; i < arr.length; i++)
+			arr[i] = ls.get(i);
+	}
+
+	public static long gcd(long a, long b) {
+		if (b == 0)
+			return a;
+		return gcd(b, a % b);
+	}
+
+	static boolean[] sieve(int N) {
+		boolean[] sieve = new boolean[N + 1];
+		for (int i = 2; i <= N; i++)
+			sieve[i] = true;
+
+		for (int i = 2; i <= N; i++) {
+			if (sieve[i]) {
+				for (int j = 2 * i; j <= N; j += i) {
+					sieve[j] = false;
+				}
+			}
+		}
+		return sieve;
+	}
+
+	public static long power(long x, long y, long p) {
+		long res = 1L;
+		x = x % p;
+		while (y > 0) {
+			if ((y & 1) == 1)
+				res = (res * x) % p;
+			y >>= 1;
+			x = (x * x) % p;
+		}
+		return res;
+	}
+
+	public static void print(int[] arr, PrintWriter out) {
+		//for debugging only
+		for (int x : arr)
+			out.print(x + "" "");
+		out.println();
+	}
+    
+    public static int log2(int a){
+        return (int)(Math.log(a)/Math.log(2));
+    }
+    
+    public static long ceil(long x, long y){
+        return (x + 0l + y - 1) / y;
+    }
+
+	static class FastScanner {
+		private int BS = 1 << 16;
+		private char NC = (char) 0;
+		private byte[] buf = new byte[BS];
+		private int bId = 0, size = 0;
+		private char c = NC;
+		private double cnt = 1;
+		private BufferedInputStream in;
+
+		public FastScanner() {
+			in = new BufferedInputStream(System.in, BS);
+		}
+
+		public FastScanner(String s) {
+			try {
+				in = new BufferedInputStream(new FileInputStream(new File(s)), BS);
+			} catch (Exception e) {
+				in = new BufferedInputStream(System.in, BS);
+			}
+		}
+
+		private char getChar() {
+			while (bId == size) {
+				try {
+					size = in.read(buf);
+				} catch (Exception e) {
+					return NC;
+				}
+				if (size == -1)
+					return NC;
+				bId = 0;
+			}
+			return (char) buf[bId++];
+		}
+
+		public int nextInt() {
+			return (int) nextLong();
+		}
+
+		public int[] readInts(int N) {
+			int[] res = new int[N];
+			for (int i = 0; i < N; i++) {
+				res[i] = (int) nextLong();
+			}
+			return res;
+		}
+
+		public long[] readLongs(int N) {
+			long[] res = new long[N];
+			for (int i = 0; i < N; i++) {
+				res[i] = nextLong();
+			}
+			return res;
+		}
+
+		public long nextLong() {
+			cnt = 1;
+			boolean neg = false;
+			if (c == NC)
+				c = getChar();
+			for (; (c < '0' || c > '9'); c = getChar()) {
+				if (c == '-')
+					neg = true;
+			}
+			long res = 0;
+			for (; c >= '0' && c <= '9'; c = getChar()) {
+				res = (res << 3) + (res << 1) + c - '0';
+				cnt *= 10;
+			}
+			return neg ? -res : res;
+		}
+
+		public double nextDouble() {
+			double cur = nextLong();
+			return c != '.' ? cur : cur + nextLong() / cnt;
+		}
+
+		public double[] readDoubles(int N) {
+			double[] res = new double[N];
+			for (int i = 0; i < N; i++) {
+				res[i] = nextDouble();
+			}
+			return res;
+		}
+
+		public String next() {
+			StringBuilder res = new StringBuilder();
+			while (c <= 32)
+				c = getChar();
+			while (c > 32) {
+				res.append(c);
+				c = getChar();
+			}
+			return res.toString();
+		}
+
+		public String nextLine() {
+			StringBuilder res = new StringBuilder();
+			while (c <= 32)
+				c = getChar();
+			while (c != '\n') {
+				res.append(c);
+				c = getChar();
+			}
+			return res.toString();
+		}
+
+		public boolean hasNext() {
+			if (c > 32)
+				return true;
+			while (true) {
+				c = getChar();
+				if (c == NC)
+					return false;
+				else if (c > 32)
+					return true;
+			}
+		}
+	}
+
+	//	For Input.txt and Output.txt	
+	//	FileInputStream in = new FileInputStream(""input.txt"");
+	//	FileOutputStream out = new FileOutputStream(""output.txt"");
+	//	PrintWriter pw = new PrintWriter(out);
+	//	Scanner sc = new Scanner(in);
+}","//some updates in import stuff
+import static java.lang.Math.max;
+import static java.lang.Math.min;
+import static java.lang.Math.abs;
+
+import java.util.*;
+import java.io.*;
+import java.math.*;
+
+
+public class C{
+
+    static int mod = (int) (Math.pow(10, 9)+7);
+	static final int dx[] = { -1, 0, 1, 0 }, dy[] = { 0, -1, 0, 1 };
+	static final int[] dx8 = { -1, -1, -1, 0, 0, 1, 1, 1 }, dy8 = { -1, 0, 1, -1, 1, -1, 0, 1 };
+	static final int[] dx9 = { -1, -1, -1, 0, 0, 0, 1, 1, 1 }, dy9 = { -1, 0, 1, -1, 0, 1, -1, 0, 1 };
+
+	static final double eps = 1e-10;
+	static List<Integer> primeNumbers = new ArrayList<>();
+    public static void main(String[] args) {
+        MyScanner sc = new MyScanner();
+        out = new PrintWriter(new BufferedOutputStream(System.out));
+
+        //code below
+        int test = sc.nextInt();
+        while(test --> 0){
+            int n = sc.nextInt();
+            int[][] data = new int[n-1][2];
+
+            Map<Integer, Integer> count = new HashMap<>();
+            Graph g = new Graph(n+1);
+
+            for(int i= 0; i < n-1; i++){
+                int x = sc.nextInt();
+                int y = sc.nextInt();
+
+                data[i][0] = x;
+                data[i][1] = y;
+
+                g.addEdge(x, y);
+            
+                count.putIfAbsent(x, 0);
+                count.put(x, count.get(x)+1);
+
+                count.putIfAbsent(y, 0);
+                count.put(y, count.get(y)+1);
+            }
+
+            //we will count 
+            int one = 0;
+            int two = 0;
+
+            boolean flag = true;
+            int start = 0;
+            for(int i : count.keySet()){
+                if(count.get(i) == 1){  
+                    start = i;
+                    one++;
+                }else if(count.get(i) == 2){
+                    two++;
+                }else{
+                    flag = false;
+                    break;
+                }
+            }
+
+            if(one != 2){
+                flag = false;
+            }
+
+            if(!flag){
+                out.println(-1);
+                continue;
+            }
+
+            //now we know this question is solvable for sure
+            //we do something really cool
+            Map<Integer, ArrayList<Pair>> fuck = new HashMap<>();
+            g.addData(start, fuck);
+            
+            for(int i = 0; i < n-1; i++){
+                int x = data[i][0];
+                int y = data[i][1];
+
+                //search for the answer 
+                ArrayList<Pair> temp = fuck.get(x);
+                for(Pair curr : temp){
+                    if(curr.a == y){
+                        out.print(curr.b + "" "");
+                        break;
+                    }
+                }
+            }
+            
+            out.println();
+        }
+
+
+        out.close();
+    }
+
+    //Updation Required
+    //Fenwick Tree (customisable)
+    //Segment Tree (customisable)
+
+    //-----CURRENTLY PRESENT-------//
+    //Graph
+    //DSU
+    //powerMODe
+    //power
+    //Segment Tree (work on this one) 
+    //Prime Sieve
+    //Count Divisors
+    //Next Permutation 
+    //Get NCR 
+    //isVowel
+    //Sort (int)
+    //Sort (long)
+    //Binomial Coefficient
+    //Pair
+    //Triplet
+    //lcm (int & long)
+    //gcd (int & long)
+    //gcd (for binomial coefficient)
+    //swap (int & char)
+    //reverse
+
+    //Fast input and output 
+
+    //-------------------------------------------------------------------
+    //-------------------------------------------------------------------
+    //-------------------------------------------------------------------
+    //-------------------------------------------------------------------
+    //-------------------------------------------------------------------
+
+    //GRAPH (basic structure)
+    public static class Graph{
+        public int V;
+        public ArrayList<ArrayList<Integer>> edges;
+
+        //2 -> [0,1,2] (current)
+        Graph(int V){
+            this.V  = V;
+            edges = new ArrayList<>(V+1);
+            for(int i= 0; i <= V; i++){
+                edges.add(new ArrayList<>());
+            }
+        }
+
+        public void addEdge(int from , int to){
+            edges.get(from).add(to);
+            edges.get(to).add(from);
+        }
+
+        public void addData(int start, Map<Integer, ArrayList<Pair>> fuck){
+            //we will add stuff here
+            int curr = start;
+            int[] visited = new int[V+1];
+            visited[curr] = 1;
+
+            int index = 0;
+            while(true){
+                int make = 0;
+                boolean last = true;
+                for(int edge : edges.get(curr)){
+                    if(visited[edge] == 1){
+                        continue;
+                    }else{
+                        make = edge; 
+                        last = false;
+                        break;
+                    }
+                }
+
+                if(last){
+                    break;
+                }
+
+                //now we have found make, we make and add it in map
+                fuck.putIfAbsent(curr, new ArrayList<>());
+                fuck.putIfAbsent(make, new ArrayList<>());
+
+                fuck.get(curr).add(new Pair(make, index %2 == 0 ? 2 : 3));
+                fuck.get(make).add(new Pair(curr, index %2 == 0 ? 2 : 3));
+
+                visited[make] = 1;
+                curr = make;
+                index++;
+            }
+        }
+    }
+
+    //DSU (path and rank optimised)
+    public static class DisjointUnionSets {
+        int[] rank, parent;
+        int n;
+      
+        public DisjointUnionSets(int n)
+        {
+            rank = new int[n];
+            parent = new int[n];
+            Arrays.fill(rank, 1);
+            Arrays.fill(parent,-1);
+            this.n = n;
+        }
+      
+        public int find(int curr){
+            if(parent[curr] == -1)
+                return curr;
+ 
+            //path compression optimisation
+            return parent[curr] = find(parent[curr]);
+        }
+ 
+        public void union(int a, int b){
+            int s1 = find(a);
+            int s2 = find(b);
+ 
+            if(s1 != s2){
+                if(rank[s1] < rank[s2]){
+                    parent[s1] = s2;
+                    rank[s2] += rank[s1];
+                }else{
+                    parent[s2] = s1;
+                    rank[s1] += rank[s2];
+                }
+            }
+        }
+    }
+
+    //with mod
+    public static long powerMOD(long x, long y)
+    {
+        long res = 1L;    
+        while (y > 0)
+        {
+            // If y is odd, multiply x with result
+            if ((y & 1) != 0){
+                x %= mod;
+                res %= mod;
+                res = (res * x)%mod;
+            }
+            // y must be even now
+            y = y >> 1; // y = y/2
+            x%= mod;
+            x = (x * x)%mod;  // Change x to x^2
+        }
+        return res%mod;
+    }
+
+    //without mod
+    public static long power(long x, long y)
+    {
+        long res = 1L;     
+        while (y > 0)
+        {
+            // If y is odd, multiply x with result
+            if ((y & 1) != 0){
+                res = (res * x);
+            }
+            // y must be even now
+            y = y >> 1; // y = y/
+            x = (x * x);
+        }
+        return res;
+    }
+
+    public static class segmentTree{
+
+        public long[] arr;
+        public long[] tree;
+        public long[] lazy;
+
+        segmentTree(long[] array){
+            int n = array.length;
+            arr = new long[n];
+            for(int i= 0; i < n; i++) arr[i] = array[i];
+            tree = new long[4*n + 1];
+            lazy = new long[4*n + 1];
+        }
+
+        public  void build(int[]arr, int s, int e, int[] tree, int index){
+
+            if(s == e){
+                tree[index] = arr[s];
+                return;
+            }
+    
+            //otherwise divide in two parts and fill both sides simply
+            int mid = (s+e)/2;
+            build(arr, s, mid, tree, 2*index);
+            build(arr, mid+1, e, tree, 2*index+1);
+    
+            //who will build the current position dude
+            tree[index] = Math.min(tree[2*index], tree[2*index+1]);
+        }
+    
+        public  int query(int sr, int er, int sc, int ec, int index, int[] tree){
+            
+            if(lazy[index] != 0){
+                tree[index] += lazy[index];
+    
+                if(sc != ec){
+                    lazy[2*index+1] += lazy[index];
+                    lazy[2*index] += lazy[index];
+                }
+    
+                lazy[index] = 0;
+            }
+            
+            //no overlap
+            if(sr > ec || sc > er) return Integer.MAX_VALUE;
+    
+            //found the index baby
+            if(sr <= sc && ec <= er) return tree[index];
+    
+            //finding the index on both sides hehehehhe
+            int mid = (sc + ec)/2;
+            int left = query(sr, er, sc, mid, 2*index, tree);
+            int right = query(sr, er, mid+1, ec, 2*index + 1, tree);
+    
+            return Integer.min(left, right);
+        }
+    
+        //now we will do point update implementation
+        //it should be simple then we expected for sure
+        public  void update(int index, int indexr, int increment, int[] tree, int s, int e){
+    
+            if(lazy[index] != 0){
+                tree[index] += lazy[index];
+    
+                if(s != e){
+                    lazy[2*index+1] = lazy[index];
+                    lazy[2*index] = lazy[index];
+                }
+                
+                lazy[index] = 0;
+            }
+    
+            //no overlap
+            if(indexr < s || indexr > e) return;
+    
+            //found the required index
+            if(s == e){
+                tree[index] += increment;
+                return;
+            } 
+    
+            //search for the index on both sides
+            int mid = (s+e)/2;
+            update(2*index, indexr, increment, tree, s, mid);
+            update(2*index+1, indexr, increment, tree, mid+1, e);
+    
+            //now update the current range simply
+            tree[index] = Math.min(tree[2*index+1], tree[2*index]);
+        }
+    
+        public  void rangeUpdate(int[] tree , int index, int s, int e, int sr, int er, int increment){
+    
+            //if not at all in the same range
+            if(e < sr || er < s) return;
+    
+            //complete then also move forward
+            if(s == e){
+                tree[index] += increment;
+                return;
+            }
+    
+            //otherwise move in both subparts
+            int mid = (s+e)/2;
+            rangeUpdate(tree, 2*index, s, mid, sr, er, increment);
+            rangeUpdate(tree, 2*index + 1, mid+1, e, sr, er, increment);
+    
+            //update current range too na
+            //i always forget this step for some reasons hehehe, idiot
+            tree[index] = Math.min(tree[2*index], tree[2*index + 1]);
+        }
+        
+        public  void rangeUpdateLazy(int[] tree, int index, int s, int e, int sr, int er, int increment){
+            
+            //update lazy values
+            //resolve lazy value before going down
+            if(lazy[index] != 0){
+                tree[index] += lazy[index];
+    
+                if(s != e){
+                    lazy[2*index+1] += lazy[index];
+                    lazy[2*index] += lazy[index];
+                }
+    
+                lazy[index] = 0;
+            }
+    
+            //no overlap case
+            if(sr > e || s > er) return;
+    
+            //complete overlap
+            if(sr <= s && er >= e){
+                tree[index] += increment;
+    
+                if(s != e){
+                    lazy[2*index+1] += increment;
+                    lazy[2*index] += increment;
+                }
+                return;
+            }
+    
+            //otherwise go on both left and right side and do your shit
+            int mid = (s + e)/2;
+            rangeUpdateLazy(tree, 2*index, s, mid, sr, er, increment);
+            rangeUpdateLazy(tree, 2*index + 1, mid+1, e, sr, er, increment);
+    
+            tree[index] = Math.min(tree[2*index+1], tree[2*index]);
+            return;
+    
+        }
+    
+    }
+
+    //prime sieve
+    public static void primeSieve(int n){
+        BitSet bitset = new BitSet(n+1);
+        for(long i = 0; i < n ; i++){
+            if (i == 0 || i == 1) {
+                bitset.set((int) i);
+                continue;
+            }
+            if(bitset.get((int) i)) continue;
+            primeNumbers.add((int)i);
+            for(long j = i; j <= n ; j+= i)
+                bitset.set((int)j);
+        }
+    }
+
+    //number of divisors
+    public static int countDivisors(long number){
+        if(number == 1) return 1;
+        List<Integer> primeFactors = new ArrayList<>();
+        int index = 0;
+        long curr = primeNumbers.get(index);
+        while(curr * curr <= number){
+            while(number % curr == 0){
+                number = number/curr;
+                primeFactors.add((int) curr);
+            }    
+            index++;
+            curr = primeNumbers.get(index);
+        }
+
+        if(number != 1) primeFactors.add((int) number);
+        int current = primeFactors.get(0);
+        int totalDivisors = 1;
+        int currentCount = 2;
+        for (int i = 1; i < primeFactors.size(); i++) {
+            if (primeFactors.get(i) == current) {
+                currentCount++;
+            } else {
+                totalDivisors *= currentCount;
+                currentCount = 2;
+                current = primeFactors.get(i);
+            }
+        }
+        totalDivisors *= currentCount;
+        return totalDivisors;
+    }
+
+    //now adding next permutation function to java hehe
+    public static boolean next_permutation(int[] p) {
+        for (int a = p.length - 2; a >= 0; --a)
+          if (p[a] < p[a + 1])
+            for (int b = p.length - 1;; --b)
+              if (p[b] > p[a]) {
+                int t = p[a];
+                p[a] = p[b];
+                p[b] = t;
+                for (++a, b = p.length - 1; a < b; ++a, --b) {
+                  t = p[a];
+                  p[a] = p[b];
+                  p[b] = t;
+                }
+                return true;
+              }
+        return false;
+    }
+
+    //finding the value of NCR in O(RlogN) time and O(1) space
+    public static long getNcR(int n, int r)
+    {
+        long p = 1, k = 1;
+        if (n - r < r) r = n - r;
+
+        if (r != 0) {
+            while (r > 0) {
+                p *= n;
+                k *= r;
+                long m = __gcd(p, k);
+                p /= m;
+                k /= m;
+                n--;
+                r--;
+            }
+        }
+        else {
+            p = 1;
+        }
+        return p;
+    }
+
+    //is vowel function 
+    public static boolean isVowel(char c)
+    {
+        return (c=='a' || c=='A' || c=='e' || c=='E' || c=='i' || c=='I' || c=='o' || c=='O' ||     c=='u' || c=='U');
+    }   
+
+    //to sort the array with better method
+	public static void sort(int[] a) {
+		ArrayList<Integer> l=new ArrayList<>();
+		for (int i:a) l.add(i);
+		Collections.sort(l);
+		for (int i=0; i<a.length; i++) a[i]=l.get(i);
+	}
+
+    //sort long
+    public static void sort(long[] a) {
+		ArrayList<Long> l=new ArrayList<>();
+		for (long i:a) l.add(i);
+		Collections.sort(l);
+		for (int i=0; i<a.length; i++) a[i]=l.get(i);
+	}
+	
+    //for calculating binomialCoeff
+    public static int binomialCoeff(int n, int k)
+    {
+        int C[] = new int[k + 1];
+        // nC0 is 1
+        C[0] = 1;
+        for (int i = 1; i <= n; i++) {
+            // Compute next row of pascal
+            // triangle using the previous row
+            for (int j = Math.min(i, k); j > 0; j--)
+                C[j] = C[j] + C[j - 1];
+        }
+        return C[k];
+    }
+
+    //Pair with int int 
+    public static class Pair{
+        public int a;
+        public int b;
+
+        Pair(int a , int b){
+            this.a = a;
+            this.b = b;
+        }
+
+        @Override
+        public String toString(){
+            return a + "" -> "" + b; 
+        }
+    }
+
+    //Triplet with int int int
+    public static class Triplet{
+
+        public int a;
+        public int b;
+        public int c;
+
+        Triplet(int a , int b, int c){
+            this.a = a;
+            this.b = b;
+            this.c = c;
+        }
+
+        @Override
+        public String toString(){
+            return a + "" -> "" + b; 
+        }
+    }
+
+    //Shortcut function
+    public static long lcm(long a , long b){
+        return a * (b/gcd(a,b));
+    }
+
+    //let's make one for calculating lcm basically
+    public static int lcm(int a , int b){
+        return (a * b)/gcd(a,b);
+    }
+
+    //int version for gcd
+    public static int gcd(int a, int b){
+        if(b == 0)
+            return a;
+            
+        return gcd(b , a%b);
+    }
+
+    //long version for gcd
+    public static long gcd(long a, long b){
+        if(b == 0)
+            return a;
+
+        return gcd(b , a%b);
+    }
+
+     //for ncr calculator(ignore this code)
+     public static long __gcd(long n1, long n2)
+     {
+         long gcd = 1;
+         for (int i = 1; i <= n1 && i <= n2; ++i) {
+             // Checks if i is factor of both integers
+             if (n1 % i == 0 && n2 % i == 0) {
+                 gcd = i;
+             }
+         }
+         return gcd;
+     }
+
+    //swapping two elements in an array
+    public static void swap(int[] arr, int left , int right){
+        int temp = arr[left];
+        arr[left] = arr[right];
+        arr[right] = temp;
+    }
+
+    //for char array
+    public static void swap(char[] arr, int left , int right){
+        char temp = arr[left];
+        arr[left] = arr[right];
+        arr[right] = temp;
+    }
+
+    //reversing an array
+    public static void reverse(int[] arr){
+        int left = 0;
+        int right = arr.length-1;
+
+        while(left <= right){
+            swap(arr, left,right);
+            left++;
+            right--;
+        }
+    }
+
+
+    public static long expo(long a, long b, long mod) {
+        long res = 1; 
+        while (b > 0) {
+            if ((b & 1) == 1L) res = (res * a) % mod;  //think about this one for a second
+            a = (a * a) % mod;
+            b = b >> 1;
+        } 
+        return res;
+    }
+
+    //SOME EXTRA DOPE FUNCTIONS 
+    public static long mminvprime(long a, long b) {
+        return expo(a, b - 2, b);
+    }
+
+    public static long mod_add(long a, long b, long m) {
+        a = a % m;
+        b = b % m;
+        return (((a + b) % m) + m) % m;
+    }
+
+    public static long mod_sub(long a, long b, long m) {
+        a = a % m; 
+        b = b % m; 
+        return (((a - b) % m) + m) % m;
+    }
+   
+    public static long mod_mul(long a, long b, long m) {
+        a = a % m;
+        b = b % m;
+        return (((a * b) % m) + m) % m;
+    }
+
+    public static long mod_div(long a, long b, long m) {
+        a = a % m;
+        b = b % m;
+        return (mod_mul(a, mminvprime(b, m), m) + m) % m;
+    }
+
+    //O(n) every single time remember that
+    public static long nCr(long N, long K , long mod){
+        long upper = 1L;
+        long lower = 1L;
+        long lowerr = 1L;
+
+        for(long i = 1; i <= N; i++){
+            upper = mod_mul(upper, i, mod);
+        }
+
+        for(long i = 1; i <= K; i++){
+            lower = mod_mul(lower, i, mod);
+        }
+
+        for(long i = 1; i <= (N - K); i++){
+            lowerr = mod_mul(lowerr, i, mod);
+        }
+
+        // out.println(upper + "" "" + lower + "" "" + lowerr);
+        long answer = mod_mul(lower, lowerr, mod);
+        answer = mod_div(upper, answer, mod);
+
+        return answer;
+    }
+
+    // ll *fact = new ll[2 * n + 1];
+	// ll *ifact = new ll[2 * n + 1];
+	// fact[0] = 1;
+	// ifact[0] = 1;
+	// for (ll i = 1; i <= 2 * n; i++)
+	// {
+	// 	fact[i] = mod_mul(fact[i - 1], i, MOD1);
+	// 	ifact[i] = mminvprime(fact[i], MOD1);
+	// }
+    //ifact is basically inverse factorial in here!!!!!(imp)
+    public static long combination(long n, long r, long m, long[] fact, long[] ifact) {
+        long val1 = fact[(int)n];
+        long val2 = ifact[(int)(n - r)];
+        long val3 = ifact[(int)r];
+        return (((val1 * val2) % m) * val3) % m;
+    }
+
+  
+
+     
+    //-----------PrintWriter for faster output---------------------------------
+    public static PrintWriter out;
+      
+    //-----------MyScanner class for faster input----------
+    public static class MyScanner {
+      BufferedReader br;
+      StringTokenizer st;
+ 
+        public MyScanner() {
+            br = new BufferedReader(new InputStreamReader(System.in));
+        }
+    
+        String next() {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+    
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+    
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+    
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+    
+        String nextLine(){
+            String str = """";
+            try {
+                str = br.readLine();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+        }
+
+    }
+   //--------------------------------------------------------
+}",0
+90dc2b20,d8a171a3,"import java.util.*;
+import java.io.*;
+public class C1615{
+	static FastScanner fs = null;
+	public static void main(String[] args) {
+		fs = new FastScanner();
+		PrintWriter out = new PrintWriter(System.out);
+		int t = fs.nextInt();
+		while (t-->0) {
+			int n = fs.nextInt();
+			String a = fs.next();
+			String b = fs.next();
+			char ch1[] = a.toCharArray();
+			char ch2[] = b.toCharArray();
+			int c00 = 0;
+			int c01 = 0;
+			int c10 = 0;
+			int c11 = 0;
+			for(int i=0;i<n;i++){
+				if(ch1[i]=='0'){
+					if(ch2[i]=='0'){
+						c00+=1;
+					}
+					else{
+						c01+=1;
+					}
+				}
+				else{
+					if(ch2[i]=='0'){
+						c10+=1;
+					}
+					else{
+						c11+=1;
+					}
+				}
+			}
+			int ans = -1;
+			if((c11-c00)==1 || c10==c01){
+				int s1 = (int)1e7; 
+				int s2 = (int)1e7;
+				if((c11-c00)==1){
+					s1 = c11+c00;
+				}
+				if(c10==c01)
+				s2 = c10+c01;
+				ans = Math.min(s1,s2); 
+			}
+			out.println(ans);
+		}
+		out.close();
+	}
+	static void sort(int[] a) {
+		ArrayList<Integer> l=new ArrayList<>();
+		for (int i:a) l.add(i);
+		Collections.sort(l);
+		for (int i=0; i<a.length; i++) a[i]=l.get(i);
+	}
+	static class FastScanner {
+		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st=new StringTokenizer("""");
+		String next() {
+			while (!st.hasMoreTokens())
+				try {
+					st=new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			return st.nextToken();
+		}
+		
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+		int[] readArray(int n) {
+			int[] a=new int[n];
+			for (int i=0; i<n; i++) a[i]=nextInt();
+			return a;
+		}
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+	}
+}","import java.io.*;
+import java.util.*;
+
+public class B {
+	
+	public static void main(String[] args)throws IOException {
+		
+		FastScanner scan = new FastScanner();
+		PrintWriter output = new PrintWriter(System.out);
+		int t = scan.nextInt();
+		for(int tt = 0;tt<t;tt++) {
+			int n = scan.nextInt();
+			char initial[] = scan.next().toCharArray();
+			char desired[] = scan.next().toCharArray();
+			int lit1 = 0, lit2 = 0;
+			int ans = Integer.MAX_VALUE;
+			for(int i = 0;i<n;i++) {
+				if(initial[i]=='1') lit1++;
+				if(desired[i]=='1') lit2++;
+			}
+			if(lit1==lit2) {
+				int count = 0;
+				for(int i = 0;i<n;i++) if(initial[i]!=desired[i]) count++;
+				ans = Math.min(ans, count);
+			}
+			if(lit2==(n-lit1+1)) {
+				int count = 0;
+				for(int i = 0;i<n;i++) if(initial[i]==desired[i]) count++;
+				ans = Math.min(ans, count);
+			}
+			if(ans == Integer.MAX_VALUE) ans = -1;
+			output.println(ans);	
+		}
+		output.flush();
+	}
+	
+	public static int[] sort(int arr[]) {
+		List<Integer> list = new ArrayList<>();
+		for(int i:arr) list.add(i);
+		Collections.sort(list);
+		for(int i = 0;i<list.size();i++) arr[i] = list.get(i);
+		return arr;
+	}
+	
+	public static int gcd(int a, int b) {
+		if(a == 0) return b;
+		return gcd(b%a, a);
+	}
+	
+	public static void printArray(int arr[]) {
+		for(int i:arr) System.out.print(i+"" "");
+		System.out.println();
+	}
+	
+	static class FastScanner {
+		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st=new StringTokenizer("""");
+		String next() {
+			while (!st.hasMoreTokens())
+				try {
+					st=new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			return st.nextToken();
+		}
+
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+		int[] readArray(int n) {
+			int[] a=new int[n];
+			for (int i=0; i<n; i++) a[i]=nextInt();
+			return a;
+		}
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+		
+		double nextDouble() {
+			return Double.parseDouble(next());
+		}
+	}
+
+}
+",0
+e2fe9d7d,ece1820d,"
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.math.BigInteger;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.BitSet;
+import java.util.Calendar;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.PriorityQueue;
+import java.util.SortedSet;
+import java.util.Stack;
+import java.util.StringTokenizer;
+import java.util.TreeMap;
+import java.util.TreeSet;
+
+public class C_Edu_Round_120 {
+    public static long MOD = 998244353;
+
+    static int[] dp;
+
+
+    public static void main(String[] args) throws FileNotFoundException {
+        // PrintWriter out = new PrintWriter(new FileOutputStream(new File(
+        // ""output.txt"")));
+        PrintWriter out = new PrintWriter(System.out);
+        Scanner in = new Scanner();
+        int T = in.nextInt();
+        //System.out.println(cal(1608737403, 1000000000) - 923456789987654321L);
+        for (int z = 0; z < T; z++) {
+            int n = in.nextInt();
+            long k = in.nextLong();
+            long[] data = new long[n];
+            long total = 0;
+            PriorityQueue<Integer> q = new PriorityQueue<>();
+            for (int i = 0; i < n; i++) {
+                q.add(in.nextInt());
+            }
+            for (int i = 0; i < n; i++) {
+                data[i] = q.poll();
+                total += data[i];
+            }
+            Arrays.sort(data);
+            long result = Long.max(0, total - k);
+            long cur = 0;
+            int num = 0;
+            for (int i = n - 1; i > 0 && total > k + cur; i--) {
+
+                num++;
+                cur += data[i] - data[0];
+                long left = Long.max(0, total - cur - k);
+                left /= (num + 1);
+                if (total - cur - (left * (num + 1)) > k) {
+                    left++;
+                }
+                //System.out.println(num + "" "" + left + "" "" + cur + "" "" + total);
+                result = Long.min(result, left + num);
+            }
+
+
+            out.println(result);
+
+        }
+
+        out.close();
+    }
+
+    static long cal(long msg, long k) {
+        if (msg <= k) {
+            return msg * (msg + 1L) / 2L;
+        }
+        long re = k * (k + 1L) / 2L;
+        long left = 2 * k - 1 - msg;
+        long other = (k - 1) * k / 2;
+        other -= left * (left + 1) / 2;
+        //System.out.println(other);
+        return re + other;
+    }
+
+    static long cal2(long msg, long k) {
+        if (msg <= k) {
+            return BigInteger.valueOf(msg).multiply(BigInteger.valueOf(msg + 1)).shiftRight(1).longValue();
+        }
+        BigInteger re = BigInteger.valueOf(k).multiply(BigInteger.valueOf(k + 1)).shiftRight(1);
+        long left = 2 * k - 1 - msg;
+        BigInteger other = BigInteger.valueOf(k).multiply(BigInteger.valueOf(k - 1)).shiftRight(1);
+        other = other.subtract(BigInteger.valueOf(left).multiply(BigInteger.valueOf(left + 1)).shiftRight(1));
+        return re.add(other).longValue();
+
+    }
+
+    static int find(int index, int[] u) {
+        if (u[index] != index) {
+            return u[index] = find(u[index], u);
+        }
+        return index;
+    }
+
+    static int abs(int a) {
+        return a < 0 ? -a : a;
+    }
+
+
+    public static int[] KMP(String val) {
+        int i = 0;
+        int j = -1;
+        int[] result = new int[val.length() + 1];
+        result[0] = -1;
+        while (i < val.length()) {
+            while (j >= 0 && val.charAt(j) != val.charAt(i)) {
+                j = result[j];
+            }
+            j++;
+            i++;
+            result[i] = j;
+        }
+        return result;
+
+    }
+
+    public static boolean nextPer(int[] data) {
+        int i = data.length - 1;
+        while (i > 0 && data[i] < data[i - 1]) {
+            i--;
+        }
+        if (i == 0) {
+            return false;
+        }
+        int j = data.length - 1;
+        while (data[j] < data[i - 1]) {
+            j--;
+        }
+        int temp = data[i - 1];
+        data[i - 1] = data[j];
+        data[j] = temp;
+        Arrays.sort(data, i, data.length);
+        return true;
+    }
+
+    public static int digit(long n) {
+        int result = 0;
+        while (n > 0) {
+            n /= 10;
+            result++;
+        }
+        return result;
+    }
+
+    public static double dist(long a, long b, long x, long y) {
+        double val = (b - a) * (b - a) + (x - y) * (x - y);
+        val = Math.sqrt(val);
+        double other = x * x + a * a;
+        other = Math.sqrt(other);
+        return val + other;
+
+    }
+
+    public static class Point {
+
+        int x;
+        int y;
+
+        public Point(int start, int end) {
+            this.x = start;
+            this.y = end;
+        }
+
+        public String toString() {
+            return x + "" "" + y;
+        }
+
+    }
+
+    public static class FT {
+
+        long[] data;
+
+        FT(int n) {
+            data = new long[n];
+        }
+
+        public void update(int index, long value) {
+            while (index < data.length) {
+                data[index] += value;
+                index += (index & (-index));
+            }
+        }
+
+        public long get(int index) {
+
+            long result = 0;
+            while (index > 0) {
+                result += data[index];
+                index -= (index & (-index));
+            }
+            return result;
+
+        }
+    }
+
+    public static long gcd(long a, long b) {
+        if (b == 0) {
+            return a;
+        }
+        return gcd(b, a % b);
+    }
+
+    public static long pow(long a, int b) {
+        if (b == 0) {
+            return 1;
+        }
+        if (b == 1) {
+            return a;
+        }
+
+        long val = pow(a, b / 2);
+        if (b % 2 == 0) {
+            return (val * val) % MOD;
+        } else {
+            return (val * ((val * a) % MOD)) % MOD;
+
+        }
+    }
+
+    static class Scanner {
+
+        BufferedReader br;
+        StringTokenizer st;
+
+        public Scanner() throws FileNotFoundException {
+            // System.setOut(new PrintStream(new BufferedOutputStream(System.out), true));
+            br = new BufferedReader(new InputStreamReader(System.in));
+            //br = new BufferedReader(new InputStreamReader(new FileInputStream(new File(""input.txt""))));
+        }
+
+        public String next() {
+
+            while (st == null || !st.hasMoreTokens()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (Exception e) {
+                    throw new RuntimeException();
+                }
+            }
+            return st.nextToken();
+        }
+
+        public long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        public int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        public double nextDouble() {
+            return Double.parseDouble(next());
+        }
+
+        public String nextLine() {
+            st = null;
+            try {
+                return br.readLine();
+            } catch (Exception e) {
+                throw new RuntimeException();
+            }
+        }
+
+        public boolean endLine() {
+            try {
+                String next = br.readLine();
+                while (next != null && next.trim().isEmpty()) {
+                    next = br.readLine();
+                }
+                if (next == null) {
+                    return true;
+                }
+                st = new StringTokenizer(next);
+                return st.hasMoreTokens();
+            } catch (Exception e) {
+                throw new RuntimeException();
+            }
+        }
+    }
+}","import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.util.*;
+import java.util.concurrent.ThreadLocalRandom;
+ 
+public class a729 {
+ 
+	public static void main(String[] args) throws IOException {
+   
+		
+//		try {
+			
+		BufferedWriter out = new BufferedWriter(
+	            new OutputStreamWriter(System.out));
+		BufferedReader br = new BufferedReader(
+		        new InputStreamReader(System.in));
+		PrintWriter pt = new PrintWriter(System.out);
+		FastReader sc = new FastReader();
+		int t = sc.nextInt();
+	
+for(int o = 0 ; o<t;o++){
+int n = sc.nextInt();
+long k = sc.nextLong();
+long[] arr = new long[n];
+for(int i = 0 ; i<n;i++) {
+	arr[i] = sc.nextLong();
+}
+shuffleArray(arr);
+Arrays.sort(arr);
+long[] psum = new long[n+1];
+for(int i = 1; i<=n;i++){
+	psum[i] = psum[i-1] + arr[i-1];
+}
+if(n==1) {
+	long val = arr[0]-k;
+	val = Math.max(0, val);
+	System.out.println(val);
+	continue;
+}
+if(k>=psum[n]) {
+	System.out.println(0);
+	continue;
+}
+long ans = Integer.MAX_VALUE;
+long x = 0;
+long a1 = arr[0];
+for(int y = 0 ; y<n;y++) {
+	long val = psum[n-y] + y*a1 - k;
+//	if(val<0) {
+//		continue;
+//	}
+	x = val/(y+1);
+	if(val%(y+1)!=0 && val>0) {
+		x++;
+	}
+//	if(x<0) {
+//		continue;
+//	}
+	ans = Math.min(ans, Math.max(x, 0) + y);
+	
+	
+}
+ans = Math.max(ans, 0);
+System.out.println(ans);
+}
+//     }catch(Exception e) {
+//    	 return;
+//     }
+     }
+     
+     
+//------------------------------------------------------------------------------------------------------------------------------------------------
+ 
+	
+	static int cntDivisors(int n)
+    {
+        int cnt = 0;
+		for (int i=1; i<=Math.sqrt(n); i++)
+        {
+            if (n%i==0)
+            {
+                if (n/i == i)
+                	cnt++;
+                	
+                else 
+                	cnt+=2;
+            }
+        }
+    
+    return cnt;
+    }
+	
+	
+	
+	public static long findgcd(long[] arr,int v) {
+		int n = arr.length;
+		long g = arr[v];
+		for(int i = v ; i<n;i+=2) {
+			g = gcd(g, arr[i]);
+		}
+		return g;
+	}
+	
+	public static int count(long x) {
+		int a = 0;
+		while(x>0) {
+			x/=2;
+			a++;
+		}
+		return a;
+		
+	}
+	
+ 
+	public static long ncr(long[] fac, int n , int r , long m) {
+		return fac[n]*(modInverse(fac[r], m))%m *(modInverse(fac[n-r], m))%m; 
+	}
+	
+	
+	public static void build(int [][] seg,char []arr,int idx, int lo , int hi) {
+	if(lo == hi) {
+//		seg[idx] = arr[lo];
+		seg[idx][(int)arr[lo]-'a'] = 1;
+		
+		return;
+	}
+	int mid = (lo + hi)/2;
+build(seg,arr,2*idx+1, lo, mid);
+build(seg,arr,idx*2+2, mid +1, hi);
+//seg[idx] = Math.min(seg[2*idx+1],seg[2*idx+2]);
+for(int i = 0 ; i<27;i++) {
+	seg[idx][i] = seg[2*idx+1][i] + seg[2*idx + 2][i];
+}
+	}
+//for f/inding minimum in range 
+public static void query(int[][]seg,int[]ans,int idx , int lo , int hi , int l , int r) {
+	if(lo>=l && hi<=r) {
+		for(int i = 0 ; i<27;i++) {
+			ans[i]+= seg[idx][i];
+		}
+		return ;
+	}
+if(hi<l || lo>r) {
+	return;
+}
+int mid = (lo + hi)/2;
+query(seg,ans,idx*2 +1, lo, mid, l, r);
+query(seg,ans,idx*2 + 2, mid + 1, hi, l, r);
+//return Math.min(left, right);
+}
+//// for sum
+//
+public static void update(int[][]seg,char[]arr,int idx, int lo , int hi , int node , char val) {
+if(lo == hi) {
+//	seg[idx] += val;
+seg[idx][val-'a']++;
+seg[idx][arr[node]-'a']--;
+ 
+}else {
+int mid = (lo + hi )/2;
+if(node<=mid && node>=lo) {
+update(seg,arr, idx * 2 +1, lo, mid, node, val);
+}else {
+update(seg,arr, idx*2 + 2, mid + 1, hi, node, val);
+}
+//seg[idx] = seg[idx*2 + 1] + seg[idx*2 + 2];
+for(int i = 0 ; i<27;i++) {
+	seg[idx][i] = seg[2*idx+1][i] + seg[2*idx + 2][i];
+}
+}
+ 
+}
+	
+	
+	
+	
+	
+	
+	public static int lower_bound(int array[], int low, int high, int key){
+	// Base Case
+	if (low > high) {
+	return low;
+	}
+ 
+	// Find the middle index
+	int mid = low + (high - low) / 2;
+ 
+	// If key is lesser than or equal to
+	// array[mid] , then search
+	// in left subarray
+	if (key <= array[mid]) {
+ 
+	return lower_bound(array, low,
+	            mid - 1, key);
+	}
+ 
+	// If key is greater than array[mid],
+	// then find in right subarray
+	return lower_bound(array, mid + 1, high,
+	        key);
+	}
+	
+	public static int upper_bound(int arr[], int low,
+            int high, int key){
+// Base Case
+if (low > high || low == arr.length)
+return low;
+ 
+// Find the value of middle index
+int mid = low + (high - low) / 2;
+ 
+// If key is greater than or equal
+// to array[mid], then find in
+// right subarray
+if (key >= arr[mid]) {
+return upper_bound(arr, mid + 1, high,
+                key);
+}
+ 
+// If key is less than array[mid],
+// then find in left subarray
+return upper_bound(arr, low, mid - 1,
+            key);
+}
+ 
+//	-----------------------------------------------------------------------------------------------------------------------------------------------
+	public static long gcd(long a, long b){
+        if (a == 0)
+            return b;
+        return gcd(b % a, a);
+    }
+//--------------------------------------------------------------------------------------------------------------------------------------------------------
+	public static long modInverse(long a, long m){
+        long m0 = m;
+        long y = 0, x = 1;
+ 
+        if (m == 1)
+            return 0;
+ 
+        while (a > 1) {
+            // q is quotient
+            long q = a / m;
+ 
+            long t = m;
+ 
+            // m is remainder now, process
+            // same as Euclid's algo
+            m = a % m;
+            a = t;
+            t = y;
+ 
+            // Update x and y
+            y = x - q * y;
+            x = t;
+        }
+ 
+        // Make x positive
+        if (x < 0)
+            x += m0;
+ 
+        return x;
+    }
+ 
+		
+ 
+//-----------------------------------------------------------------------------------------------------------------------------------
+ 
+	//segment tree
+	//for finding minimum in range 
+//	public static void build(int [] seg,int []arr,int idx, int lo , int hi) {
+//		if(lo == hi) {
+//			seg[idx] = arr[lo];
+//			return;
+//		}
+//		int mid = (lo + hi)/2;
+//	build(seg,arr,2*idx+1, lo, mid);
+//	build(seg,arr,idx*2+2, mid +1, hi);
+//	seg[idx] = Math.min(seg[2*idx+1],seg[2*idx+2]);
+//	}
+////for finding minimum in range 
+//public static int query(int[]seg,int idx , int lo , int hi , int l , int r) {
+//		if(lo>=l && hi<=r) {
+//			return seg[idx];
+//		}
+//	if(hi<l || lo>r) {
+//		return Integer.MAX_VALUE;
+//	}
+//	int mid = (lo + hi)/2;
+//	int left = query(seg,idx*2 +1, lo, mid, l, r);
+//	int right = query(seg,idx*2 + 2, mid + 1, hi, l, r);
+//	return Math.min(left, right);
+//}
+//	// for sum
+//
+//public static void update(int[]seg,int idx, int lo , int hi , int node , int val) {
+//	if(lo == hi) {
+//		seg[idx] += val;
+//	}else {
+//int mid = (lo + hi )/2;
+//if(node<=mid && node>=lo) {
+//	update(seg, idx * 2 +1, lo, mid, node, val);
+//}else {
+//	update(seg, idx*2 + 2, mid + 1, hi, node, val);
+//}
+//seg[idx] = seg[idx*2 + 1] + seg[idx*2 + 2];
+//
+//}
+ 
+//}
+//---------------------------------------------------------------------------------------------------------------------------------------
+ 
+ 
+	static void shuffleArray(long[] ar)
+	  {
+	    // If running on Java 6 or older, use `new Random()` on RHS here
+	    Random rnd = ThreadLocalRandom.current();
+	    for (int i = ar.length - 1; i > 0; i--)
+	    {
+	      int index = rnd.nextInt(i + 1);
+	      // Simple swap
+	      long a = ar[index];
+	      ar[index] = ar[i];
+	      ar[i] = a;
+	    }
+	  }
+//-----------------------------------------------------------------------------------------------------------------------------------------------------------
+ 
+}
+ 
+ 
+class FastReader {
+    BufferedReader br;
+    StringTokenizer st;
+ 
+    public FastReader()
+    {
+        br = new BufferedReader(
+            new InputStreamReader(System.in));
+    }
+ 
+    String next()
+    {
+        while (st == null || !st.hasMoreElements()) {
+            try {
+                st = new StringTokenizer(br.readLine());
+ 
+            
+            
+            
+            
+            }
+            catch (IOException e) {
+                e.printStackTrace();
+            }
+        }
+        return st.nextToken();
+    }
+ 
+    int nextInt() { return Integer.parseInt(next()); }
+ 
+    long nextLong() { return Long.parseLong(next()); }
+ 
+    double nextDouble()
+    {
+        return Double.parseDouble(next());
+    }
+ 
+    String nextLine()
+    {
+        String str = """";
+        try {
+            str = br.readLine();
+        }
+        catch (IOException e) {
+            e.printStackTrace();
+        }
+        return str;
+    }
+}
+//------------------------------------------------------------------------------------------------------------------------------------------------------------
+class SegmentTree{
+	
+int n;
+	public SegmentTree(int[] arr,int n) {
+		this.arr = arr;
+		this.n = n;
+	}
+	int[] arr = new int[n];
+//	int n = arr.length;
+	int[] seg = new int[4*n];
+	void build(int idx, int lo , int hi) {
+		if(lo == hi) {
+			seg[idx] = arr[lo];
+			return;
+		}
+		int mid = (lo + hi)/2;
+	build(2*idx+1, lo, mid);
+	build(idx*2+2, mid +1, hi);
+	seg[idx] = Math.min(seg[2*idx+1],seg[2*idx+2]);
+	}
+	int query(int idx , int lo , int hi , int l , int r) {
+		if(lo<=l && hi>=r) {
+			return seg[idx];
+		}
+	if(hi<l || lo>r) {
+		return Integer.MAX_VALUE;
+	}
+	int mid = (lo + hi)/2;
+	int left = query(idx*2 +1, lo, mid, l, r);
+	int right = query(idx*2 + 2, mid + 1, hi, l, r);
+	return Math.min(left, right);
+	}
+	
+	
+}
+//-----------------------------------------------------------------------------------------------------------------------------------------------------------
+class coup{
+	char a; 
+	int b;
+	public coup(char a , int b) {
+		this.a = a;
+		this.b = b;
+	}
+}
+ 
+class trip{
+	int a , b, c;
+	public trip(int a , int b, int c) {
+		this.a = a;
+		this.b = b;
+		this.c = c;
+	}
+}
+",0
+aa4b840f,e99c14b9,"import java.io.*;
+import java.util.*;
+ 
+public class Contest1615C
+{
+    static class InputReader {
+        BufferedReader reader;
+        StringTokenizer tokenizer;
+        public InputReader(InputStream stream) {
+            reader = new BufferedReader(new InputStreamReader(stream), 32768);
+            tokenizer = null;
+        }
+        String next() { // reads in the next string
+            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
+                try {
+                    tokenizer = new StringTokenizer(reader.readLine());
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+            }
+            return tokenizer.nextToken();
+        }
+        public int nextInt() { // reads in the next int
+            return Integer.parseInt(next());
+        }
+        public long nextLong() { // reads in the next long
+            return Long.parseLong(next());
+        }
+        public double nextDouble() { // reads in the next double
+            return Double.parseDouble(next());
+            }
+        }
+    static InputReader r = new InputReader(System.in);
+    static PrintWriter pw = new PrintWriter(System.out);
+    static long mod = 1000000007;
+    public static void main(String[] args)
+    {
+    	int t = r.nextInt();
+    	
+    	while (t > 0)
+    	{
+    		t--;
+    		int n = r.nextInt();
+    		String a = r.next();
+    		String b = r.next();
+    		int sum1 = 0; int sum2 = 0;
+    		for (int i = 0; i < n; i ++)
+    		{
+    			sum1 += (a.charAt(i) == '1'?1:0);
+    			sum2 += (b.charAt(i) == '1'?1:0);
+    		}
+    		if (sum1!=sum2 && sum1+sum2 != n+1)
+    		{
+    			pw.println(-1);
+    			continue;
+    		}
+    		int[][] count = new int[2][2];
+    		for (int i = 0; i < n; i ++)
+    		{
+    			count[(int)a.charAt(i)-(int)'0'][(int)b.charAt(i)-(int)'0']++;
+    		}
+    		int min = 10000000;
+    		if (count[0][1] == count[1][0])
+    		{
+    			min = Math.min(min, count[0][1]*2);
+    		}
+    		if (count[1][1] == count[0][0] + 1)
+    		{
+    			min = Math.min(min, count[1][1] + count[0][0]);
+    		}
+    		pw.println(min == 10000000 ? -1:min);
+    	}
+        pw.close();
+    }
+}","import java.io.*;
+
+import java.util.*;
+/*
+
+
+
+
+*/
+
+ 
+ public class A{
+	static FastReader sc=null;
+	
+	public static void main(String[] args) {
+		sc=new FastReader();
+		int t=sc.nextInt();
+		
+		for(int tt=0;tt<t;tt++) {
+			int n=sc.nextInt();
+			char a[]=sc.next().toCharArray(),b[]=sc.next().toCharArray();
+			
+			int fa=0,fb=0,da=0,db=0,sum=0;
+			boolean dif=false;
+			for(int i=0;i<n;i++) {
+				sum+=a[i]-'0';
+				if(a[i]!=b[i]) {
+					dif=true;
+					if(a[i]=='1')fa++;
+					else fb++;
+				}
+				else {
+					if(a[i]=='1')da++;
+					else db++;
+				}
+			}
+			
+			if(sum==0) {
+				System.out.println(dif?-1:0);
+				continue;
+			}
+			
+			int ans=n+1;
+			
+			if(fa==fb) ans=(fa+fb);
+			if(da==db+1) ans=Math.min(da+db, ans);
+			
+			System.out.println(ans==(n+1)?-1:ans);
+		}
+	}
+	
+	static int[] ruffleSort(int a[]) {
+		ArrayList<Integer> al=new ArrayList<>();
+		for(int i:a)al.add(i);
+		Collections.sort(al);
+		for(int i=0;i<a.length;i++)a[i]=al.get(i);
+		return a;
+	}
+	
+	static void print(int a[]) {
+		for(int e:a) {
+			System.out.print(e+"" "");
+		}
+		System.out.println();
+	}
+	
+	static class FastReader{
+		
+		StringTokenizer st=new StringTokenizer("""");
+		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+		
+		String next() {
+			while(!st.hasMoreTokens()) 
+				try {
+					st=new StringTokenizer(br.readLine());
+				}
+			   catch(IOException e){
+				   e.printStackTrace();
+			   }
+			return st.nextToken();
+		}
+		
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+		
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+		
+		int[] readArray(int n) {
+			int a[]=new int[n];
+			for(int i=0;i<n;i++)a[i]=sc.nextInt();
+			return a;
+		}
+	}
+	
+	
+}
+",0
+4548305b,be3b1289,"import java.util.function.Consumer;
+import java.util.*;
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.math.RoundingMode;
+import java.text.DecimalFormat;
+import java.io.*;
+import java.lang.Math.*;
+ public class KickStart2020{
+	static class FastReader {
+        BufferedReader br;
+        StringTokenizer st;
+        public FastReader(){br = new BufferedReader(
+           new InputStreamReader(System.in));}
+        String next(){
+            while (st == null || !st.hasMoreElements()) {
+                try { st = new StringTokenizer(br.readLine()); }
+                catch (IOException e) {e.printStackTrace();}}
+            return st.nextToken();}
+        int nextInt() { return Integer.parseInt(next()); }
+        long nextLong() { return Long.parseLong(next()); }
+        double nextDouble() { return Double.parseDouble(next());}
+        float nextFloat() {return Float.parseFloat(next());}
+        String nextLine() {
+            String str = """";
+            try {str = br.readLine();}
+            catch (IOException e) { e.printStackTrace();}
+            return str; }}
+	static boolean isBracketSequence(String s, int a, int b) {
+		Stack<Character> ss = new Stack<>();
+		boolean hachu = true;
+		for(int i = a; i <= b; i++) {
+			if(s.charAt(i) == ')' && ss.isEmpty()) {hachu = false; break;}
+			if(s.charAt(i) == '(') ss.add('(');
+			else ss.pop();
+		}
+		return ss.empty() && hachu;
+	}
+	static String reverseOfString(String a) {
+		StringBuilder ssd = new StringBuilder();
+		for(int i = a.length() - 1; i >= 0; i--) {
+			ssd.append(a.charAt(i));
+		}
+		return ssd.toString();
+	}
+	static char[] reverseOfChar(char a[]) {
+		char b[] = new char[a.length];
+		int j = 0;
+		for(int i = a.length - 1; i >= 0; i--) {
+			b[i] = a[j];
+			j++;
+		}
+		return b;
+	}
+	static boolean isPalindrome(char a[]) {
+		boolean hachu = true;
+		for(int i = 0; i <= a.length / 2; i++) {
+			if(a[i] != a[a.length - 1 - i]) {
+				hachu = false;
+				break;
+			}
+		}
+		return hachu;
+	} 
+	static long gcd(long a, long b)
+	{
+	    if (b == 0)
+	        return a;
+	    return gcd(b, a % b);
+	     
+	}
+	static long powermod(long x, long y, long mod){
+	    long ans = 1;
+	    x = x % mod; 
+	    if (x == 0)
+	      return 0; 
+	    int i = 1;
+	    while (y > 0){
+	      if ((y & 1) != 0)
+	        ans = (ans * x) % mod;
+	      y = y >> 1; 
+	      x = (x * x) % mod;
+	    }
+	    return ans;
+	  }
+	static long power(long x, long y){
+	    long ans = 1;
+	    if (x == 0)
+	      return 0; 
+	    int i = 1;
+	    while (y > 0){
+	      if ((y & 1) != 0)
+	        ans = (ans * x);
+	      y = y >> 1; 
+	      x = (x * x);
+	    }
+	    return ans;
+	  }
+	static boolean check(String a) {
+		boolean hachu = true;
+		for(int i = 0; i < a.length(); i++) {
+			if(a.charAt(0) != a.charAt(i)) {hachu = false; break;}
+		}
+		return hachu;
+	}
+	 public static class Pair implements Comparable<Pair> {
+	        public  int index;
+	        public  int value;
+	 
+	        public Pair(int index, int value) {
+	            this.index = index;
+	            this.value = value;
+	        }
+	        @Override
+	        public int compareTo(Pair other) {
+	            //multiplied to -1 as the author need descending sort order
+	            return   -1 * Integer.valueOf(this.value).compareTo(other.value);
+	        }
+	 }
+	 static boolean equalString(int i, int j, int arr[], String b) {
+		 int brr[] = new int[26];
+		 for(int k = i; k <= j; k++) brr[b.charAt(k) - 'a']++;
+		 for(int k = 0; k < 26; k++) {
+			 if(arr[k] != brr[k]) return false;
+		 }
+		 return true;
+	 }
+	 static boolean cequalArray(String a, String b) {
+		  int count[] = new int[26];
+		  int count1[] = new int[26];
+		  for(int i = 0; i < a.length(); i++) count[a.charAt(i) - 'a']++;
+		  for(int i = 0; i < a.length(); i++) count1[b.charAt(i) - 'a']++;
+		  for(int i = 0; i < 26; i++) if(count[i] != count1[i]) return false;
+		  return true;
+	 }
+	 static boolean isPrime(long d) {
+		 if(d == 1) return true;
+		 for(int i = 2; i <= (long)Math.sqrt(d); i++) {
+			 if(d % i == 0) return false;
+		 }
+		 return true;
+	 }
+		public static void main(String[] args) throws Exception{
+			FastReader sc = new FastReader();
+			PrintWriter out = new PrintWriter(System.out);
+          int t = sc.nextInt();
+          while(t-- > 0) {
+           int n = sc.nextInt();
+           int k = sc.nextInt();
+           int arr[] = new int[k];
+           int temp[] = new int[k];
+           for(int i = 0; i < k; i++) arr[i] = sc.nextInt();
+           for(int i = 0; i < k; i++) temp[i] = sc.nextInt();
+           long brr[] = new long[n];
+           Arrays.fill(brr, Integer.MAX_VALUE);
+           for(int i = 0; i < k; i++) brr[arr[i] - 1] = temp[i];
+           for(int i = 1; i < n; i++) {
+        	   brr[i] = Math.min(brr[i], brr[i - 1] + 1);
+           }
+           for(int i = n - 2; i >= 0; i--) {
+        	   brr[i] = Math.min(brr[i], brr[i + 1] + 1);
+           }
+           for(long e: brr) out.print(e + "" "");
+           out.println();
+             
+          }
+                 out.close();
+			}
+		}","import java.util.*;
+import java.lang.*;
+import java.io.*;
+
+
+public class cf {
+    static PrintWriter out;
+    static int MOD = 1000000007;
+    static FastReader scan;
+
+    /*-------- I/O using short named function ---------*/
+    public static String ns() {
+        return scan.next();
+    }
+
+    public static int ni() {
+        return scan.nextInt();
+    }
+
+    public static long nl() {
+        return scan.nextLong();
+    }
+
+    public static double nd() {
+        return scan.nextDouble();
+    }
+
+    public static String nln() {
+        return scan.nextLine();
+    }
+
+    public static void p(Object o) {
+        out.print(o);
+    }
+
+    public static void ps(Object o) {
+        out.print(o + "" "");
+    }
+
+    public static void pn(Object o) {
+        out.println(o);
+    }
+
+    /*-------- for output of an array ---------------------*/
+    static void iPA(int arr[]) {
+        StringBuilder output = new StringBuilder();
+        for (int i = 0; i < arr.length; i++) output.append(arr[i] + "" "");
+        out.println(output);
+    }
+
+    static void lPA(long arr[]) {
+        StringBuilder output = new StringBuilder();
+        for (int i = 0; i < arr.length; i++) output.append(arr[i] + "" "");
+        out.println(output);
+    }
+
+    static void sPA(String arr[]) {
+        StringBuilder output = new StringBuilder();
+        for (int i = 0; i < arr.length; i++) output.append(arr[i] + "" "");
+        out.println(output);
+    }
+
+    static void dPA(double arr[]) {
+        StringBuilder output = new StringBuilder();
+        for (int i = 0; i < arr.length; i++) output.append(arr[i] + "" "");
+        out.println(output);
+    }
+
+    /*-------------- for input in an array ---------------------*/
+    static void iIA(int arr[]) {
+        for (int i = 0; i < arr.length; i++) arr[i] = ni();
+    }
+
+    static void lIA(long arr[]) {
+        for (int i = 0; i < arr.length; i++) arr[i] = nl();
+    }
+
+    static void sIA(String arr[]) {
+        for (int i = 0; i < arr.length; i++) arr[i] = ns();
+    }
+
+    static void dIA(double arr[]) {
+        for (int i = 0; i < arr.length; i++) arr[i] = nd();
+    }
+
+    /*------------ for taking input faster ----------------*/
+    static class FastReader {
+        BufferedReader br;
+        StringTokenizer st;
+
+        public FastReader() {
+            br = new BufferedReader(new InputStreamReader(System.in));
+        }
+
+        String next() {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+
+        String nextLine() {
+            String str = """";
+            try {
+                str = br.readLine();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+        }
+    }
+
+    public static ArrayList<Integer> sieveOfEratosthenes(int n) {
+        // Create a boolean array
+        // ""prime[0..n]"" and
+        // initialize all entries
+        // it as true. A value in
+        // prime[i] will finally be
+        // false if i is Not a
+        // prime, else true.
+        boolean prime[] = new boolean[n + 1];
+        for (int i = 0; i <= n; i++)
+            prime[i] = true;
+
+        for (int p = 2; p * p <= n; p++) {
+            // If prime[p] is not changed, then it is a
+            // prime
+            if (prime[p] == true) {
+                // Update all multiples of p
+                for (int i = p * p; i <= n; i += p)
+                    prime[i] = false;
+            }
+        }
+        ArrayList<Integer> arr = new ArrayList<>();
+        // Print all prime numbers
+        for (int i = 2; i <= n; i++) {
+            if (prime[i] == true)
+                arr.add(i);
+        }
+        return arr;
+    }
+
+    // Method to check if x is power of 2
+    static boolean isPowerOfTwo(int x) {
+        return x != 0 && ((x & (x - 1)) == 0);
+    }
+
+    //Method to return lcm of two numbers
+    static int gcd(int a, int b) {
+        return a == 0 ? b : gcd(b % a, a);
+    }
+
+    //Method to count digit of a number
+    static int countDigit(long n) {
+        String sex = Long.toString(n);
+        return sex.length();
+    }
+
+    static void reverse(int a[]) {
+        int i, k, t;
+        int n = a.length;
+        for (i = 0; i < n / 2; i++) {
+            t = a[i];
+            a[i] = a[n - i - 1];
+            a[n - i - 1] = t;
+        }
+    }
+
+    static final Random random = new Random();
+
+    //Method for sorting
+    static void ruffleSort(int[] arr) {
+        int n = arr.length;
+        for (int i = 0; i < n; i++) {
+            int j = random.nextInt(n);
+            int temp = arr[j];
+            arr[j] = arr[i];
+            arr[i] = temp;
+        }
+        Arrays.sort(arr);
+    }
+
+    static void sortadv(long[] a) {
+        ArrayList<Long> l = new ArrayList<>();
+        for (long value : a) {
+            l.add(value);
+        }
+        Collections.sort(l);
+        for (int i = 0; i < l.size(); i++)
+            a[i] = l.get(i);
+    }
+
+    //Method for checking if a number is prime or not
+    static boolean isPrime(int n) {
+        if (n <= 1) return false;
+        if (n <= 3) return true;
+        if (n % 2 == 0 || n % 3 == 0) return false;
+        for (int i = 5; i * i <= n; i = i + 6)
+            if (n % i == 0 || n % (i + 2) == 0)
+                return false;
+        return true;
+    }
+
+    public static void main(String[] args) throws java.lang.Exception {
+        OutputStream outputStream = System.out;
+        out = new PrintWriter(outputStream);
+        scan = new FastReader();
+        //for fast output sometimes
+        StringBuilder sb = new StringBuilder();
+        int t = ni();
+        while (t-- != 0) {
+            int n=ni();
+            int k=ni();
+            int[] a=new int[k];
+            int[] temp=new int[k];
+            iIA(a);
+            iIA(temp);
+            long dp[]=new long[n];
+            Arrays.fill(dp,Integer.MAX_VALUE);
+            for(int i=0;i<k;i++){
+                dp[a[i]-1]=temp[i];
+            }
+            //iPA(dp);
+            for(int i=1;i<n;i++){
+                dp[i]=Math.min(dp[i-1]+1,dp[i]);
+            }
+            //iPA(dp);
+            for(int i=n-2;i>=0;i--){
+                dp[i]=Math.min(dp[i+1]+1,dp[i]);
+            }
+            lPA(dp);
+            //pn("""");
+        }
+
+        out.flush();
+        out.close();
+    }
+}
+
+",1
+98950986,b9595381,"import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.math.BigInteger;
+import java.util.*;
+
+public class ReverseString {
+
+
+
+
+    static class pair implements Comparable<pair>{
+
+        String s;
+        int contribution;
+        pair(String s , int contribution){
+            this.s = s;
+            this.contribution = contribution;
+        }
+
+
+
+        @Override
+        public int compareTo(pair pair) {
+            return this.contribution-pair.contribution;
+        }
+
+
+        public String toString(){
+            return s + "" "" + contribution;
+        }
+
+        public int getValue(){
+            return contribution;
+        }
+
+
+
+
+    }
+
+
+    static int factorOfLetter(String s , char c){
+
+        int sum = 0;
+        for (int i = 0; i < s.length(); i++) {
+            if(s.charAt(i)==c)sum++;
+        }
+        int rem = Math.abs(sum-s.length());
+
+        return sum-rem;
+    }
+
+
+
+    public static void main(String[] args)  throws IOException {
+
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        PrintWriter pw = new PrintWriter(System.out);
+
+        int t = Integer.parseInt(br.readLine());
+        while (t-->0){
+
+
+            int n = Integer.parseInt(br.readLine());
+
+            int max = Integer.MIN_VALUE;
+
+            String [] arr = new String[n];
+            for (int i = 0; i < n; i++) {
+                arr[i] = br.readLine();
+            }
+
+
+
+            for (int i = 0; i < 5; i++) {
+                int word = 0;
+                ArrayList<pair> tmp = new ArrayList<>();
+                for (int j = 0; j < arr.length; j++) {
+
+                    tmp.add(new pair(arr[j] , factorOfLetter(arr[j] , (char)(i+97))));
+
+                }
+
+                Collections.sort(tmp);
+                //System.out.println(tmp);
+                int acc = 0;
+                for (int j = tmp.size()-1; j >=0 ; j--) {
+
+                    acc += tmp.get(j).contribution;
+                    if (acc<=0)break;
+                    else word++;
+
+                }
+
+                max = Math.max(max , word);
+            }
+
+
+            System.out.println(max);
+
+
+
+
+
+
+
+
+
+        }
+
+
+    }
+
+
+
+}","import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.*;
+public class Main{
+    
+static int dest1;
+static int dest2;
+public static void main(String args[]){
+       	FastScanner in = new FastScanner();
+		int test=in.nextInt();
+                while(test-->0){
+                    int n=in.nextInt();
+                    int count[][]=new int[n][5];
+                    int total[]=new int[n];
+                    String words[]=new String[n];
+                    for(int i=0;i<n;i++){
+                        words[i]=in.next();
+                        for(int j=0;j<words[i].length();j++)
+                            count[i][words[i].charAt(j)-'a']++;
+                        
+                        total[i]=words[i].length();
+                    }
+                    int max=Integer.MIN_VALUE;
+                   for(int i=0;i<5;i++){
+                       
+                      Integer ans[]=new Integer[n];
+                      for(int j=0;j<n;j++){
+                          ans[j]=count[j][i]-(total[j]-count[j][i]);
+                      }
+                      Arrays.sort(ans,Collections.reverseOrder());
+                      int j=0;
+                      int r=0;
+                      while(j<n && r+ans[j]>0){
+                          r+=ans[j];
+                          j++;
+                      }
+                      max=Math.max(j,max);
+                      
+                   }
+                   System.out.println(max);
+                   
+                    
+                }
+}
+public static int solve(int start[], int end[], int n)
+    {
+        int distance[][]=new int[n][n];
+        int r=n;
+        int c=n;
+        boolean visited[][]=new boolean[n][n];
+        int startx=start[0];
+        int starty=start[1];
+        int endx=end[0];
+        int endy=end[1];
+        Pair tmp=new Pair(startx,starty);
+		Queue<Pair> q=new LinkedList<>();
+		q.add(tmp);
+		visited[startx][starty]=true;
+		distance[startx][starty]=0;
+		int dx[]={-2,-1,1,2,2,1,-1,-2};
+		int dy[]={1,2,2,1,-1,-2,-2,-1};
+		while(!q.isEmpty())
+		{
+			Pair cell=q.poll();
+			int x=cell.x;
+			int y=cell.y;
+			int d=distance[x][y];
+			for(int i=0;i<8;i++)
+			{
+				int childx=x+dx[i];
+				int childy=y+dy[i];
+				if(valid(childx,childy,r,c,visited))
+				{
+					visited[childx][childy]=true;
+					distance[childx][childy]=d+1;
+					q.add(new Pair(childx,childy));
+				}
+			}
+		}
+		return distance[endx][endy];
+    }
+       
+public static boolean valid(int x,int y,int r,int c,boolean visited[][])
+	{
+		if(x<0||y<0||x>=r||y>=c)
+			return false;
+		if(visited[x][y])
+			return false;
+		return true;
+	}
+public static int knight(int i,int j){
+    if(i==dest1 && j==dest2)
+        return 0;
+    
+    if(i<1 || j<1)
+        return 0;
+    if(i>8 || j>8)
+        return 0;
+    
+    if(i<1 || j>8)
+        return 0;
+    
+    if(i>8 || j<1)
+        return 0;
+    
+    int min=0;
+    if(i-1>=1 && j-2>=1)
+        min+=1+knight(i-1,j-2);
+    if(i-1>=1 && j+2<=8)
+        min+=1+knight(i-1,j+2);
+    if(i-2>=1 && j-1>=1)
+        min+=1+knight(i-2,j-1);
+    if(i-2>=1 && j+1<=8)
+        min+=1+knight(i-2,j+1);
+     if(i+1<=8 && j-2>=1)
+        min+=1+knight(i+1,j-2);
+    if(i+1<=8 && j+2<=8)
+        min+=1+knight(i+1,j+2);
+    if(i+2<=8 && j-1>=1)
+        min+=1+knight(i+2,j-1);
+    if(i+2<=8 && j+1<=8)
+        min+=1+knight(i+2,j+1);
+    
+    return min;
+}
+
+}
+class FastScanner {
+		java.io.BufferedReader br = new java.io.BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st = new StringTokenizer("""");
+ 
+		String next() {
+			while (!st.hasMoreTokens())
+				try {
+					st = new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			return st.nextToken();
+		}
+ 
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+ 
+		int[] readArray(int n) {
+			int[] a = new int[n];
+			for (int i = 0; i < n; i++)
+				a[i] = nextInt();
+			return a;
+		}
+ 
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+	}
+class Pair
+    {
+    	int x;
+    	int y;
+    	Pair(int i,int j)
+    	{
+    		x=i;
+    		y=j;
+    	}
+    }
+ 
+      
+
+
+
+",0
+0d4d22e0,d20e861b,"
+
+import java.util.*;
+public class CodeForces {
+	static ArrayList<String>res;
+	public static void main(String[] args) {
+		Scanner input = new Scanner(System.in);
+		int test = input.nextInt();
+		while(test-->0){
+			int n = input.nextInt();
+			int m = input.nextInt();
+			char arr[][] = new char[n][m];
+			res = new ArrayList<>();
+			for(int i =0;i<n;i++){
+				for(int j =0;j<1;j++){
+					arr[i] = input.next().toCharArray();
+				}
+			}
+			for(int i =0;i<n-1;i++){
+				for(int j =0;j<m-1;j++){
+					int count =0;
+					if(arr[i+1][j] == '1')count++;
+					if(arr[i][j+1] == '1')count++;
+					if(arr[i][j] == '1')count++;
+					if(arr[i+1][j+1] == '1')count++;
+					if(count == 0)continue;
+					if(count == 1)one(arr,i,j);
+					if(count == 2)two(arr,i,j);
+					if(count == 3)three(arr,i,j);
+					if(count == 4)four(arr,i,j);
+				}
+			}
+			System.out.println(res.size());
+			for(String it:res)System.out.println(it);
+		}	
+	}
+	public static void one(char arr[][],int i,int j){
+		int row = i+2;
+		int col = j+2;
+		int count =0;
+		StringBuilder sb = new StringBuilder();
+		for(int x=i;x<row;x++){
+			for(int y = j;y<col;y++){
+				if(arr[x][y] == '1' ){
+					sb.append(x+1);
+					sb.append("" "");
+					sb.append(y+1);
+					arr[x][y] = '0';
+					sb.append("" "");
+				}else if(arr[x][y] == '0' && count<2){
+					sb.append(x+1);
+					sb.append("" "");
+					sb.append(y+1);
+					arr[x][y] = '1';
+					sb.append("" "");
+					count++;
+				}
+			}
+		}
+		res.add(sb.toString());
+		two(arr,i,j);
+	}
+	public static void two(char arr[][],int i,int j){
+			int row = i+2;
+			int col = j+2;
+			boolean ok = true;
+			StringBuilder sb = new StringBuilder();
+			for(int x=i;x<row;x++){
+				for(int y = j;y<col;y++){
+					if(arr[x][y] == '1' && ok){
+						sb.append(x+1);
+						sb.append("" "");
+						sb.append(y+1);
+						arr[x][y] = '0';
+						sb.append("" "");
+						ok = false;
+					}else if(arr[x][y] == '0'){
+						sb.append(x+1);
+						sb.append("" "");
+						sb.append(y+1);
+						arr[x][y] = '1';
+						sb.append("" "");
+					}
+				}
+			}
+			res.add(sb.toString());
+			three(arr,i,j);
+		}
+	public static void three(char arr[][],int i,int j){
+		StringBuilder sb = new StringBuilder();
+		if(arr[i][j] == '1'){
+			sb.append(i+1);
+			sb.append("" "");
+			sb.append(j+1);
+			arr[i][j] = '0';
+			sb.append("" "");
+		}
+		if(arr[i+1][j] == '1'){
+			sb.append(i+2);
+			sb.append("" "");
+			sb.append(j+1);
+			arr[i+1][j] = '0';
+			sb.append("" "");
+		}
+		if(arr[i][j+1] == '1'){
+			arr[i][j+1] ='0';
+			sb.append(i+1);
+			sb.append("" "");
+			sb.append(j+2);
+			sb.append("" "");
+		}
+		if(arr[i+1][j+1] == '1'){
+			arr[i+1][j+1] = '0';
+			sb.append(i+2);
+			sb.append("" "");
+			sb.append(j+2);
+		}
+		res.add(sb.toString());
+	}
+	public static void four(char arr[][],int i,int j){
+		int row = i+2;
+		int col = j+2;
+		int count =0;
+		StringBuilder sb = new StringBuilder();
+		for(int x=i;x<row;x++){
+			for(int y = j;y<col;y++){
+				if(count<3){
+					sb.append(x+1);
+					sb.append("" "");
+					sb.append(y+1);
+					arr[x][y] = '0';
+					sb.append("" "");
+					count++;
+				}
+			}
+		}
+		res.add(sb.toString());
+		one(arr,i,j);
+	}
+}
+
+
+
+/*
+1.make sure to include continue or return if u are handling a specific case separately!!!!
+and check the constraints of every alphabet(missed to check for case 0)!!!!!!!!!
+
+2.when u have transitions between states and its not dp try dfs (also think of topo sort)
+ */
+","import java.util.*;
+
+public class CodeForces{
+// 4
+//   -3 -5 -2 1
+// k  2  4  0 3
+static ArrayList<int[]> ans = new ArrayList<>();
+    
+    public static void add(int a,int b,int c,int d,int e,int f){
+        int[] tem=new int[6];
+        tem[0]=a;tem[1]=b;tem[2]=c;tem[3]=d;tem[4]=e;tem[5]=f;
+        ans.add(tem);
+    }
+   public static void helper(int[][] arr,int r,int c){
+       for(int k=0;k<12;k++){
+           if(arr[r][c]==1){
+               add(r,c,r+1,c,r,c+1);
+               arr[r][c]=1-arr[r][c];
+               arr[r+1][c]=1-arr[r+1][c];
+               arr[r][c+1]=1-arr[r][c+1];
+           }
+           if(arr[r][c+1]==1){
+                add(r,c+1,r+1,c+1,r,c);
+               arr[r][c+1]=1-arr[r][c+1];
+               arr[r+1][c+1]=1-arr[r+1][c+1];
+               arr[r][c]=1-arr[r][c];
+           }
+           if(arr[r+1][c]==1){
+                add(r+1,c+1,r,c,r+1,c);
+               arr[r+1][c+1]=1-arr[r+1][c+1];
+               arr[r][c]=1-arr[r][c];
+               arr[r+1][c]=1-arr[r+1][c];
+           }
+           if(arr[r+1][c+1]==1){
+                add(r+1,c+1,r+1,c,r,c+1);
+               arr[r+1][c+1]=1-arr[r+1][c+1];
+               arr[r+1][c]=1-arr[r+1][c];
+               arr[r][c+1]=1-arr[r][c+1];
+           }
+           
+       }
+       
+   } 
+   public static void main(String[] args) {
+		Scanner sc = new Scanner(System.in);
+		int t=sc.nextInt();
+		while(t-->0){
+		    int n = sc.nextInt();
+		    int m = sc.nextInt();
+		    ans.clear();
+		    int[][] arr=new int[n][m];
+		    for(int i=0;i<n;i++){
+		        String str = sc.next();
+		        for(int j=0;j<m;j++){
+		            arr[i][j]=str.charAt(j)-'0';
+		        }
+		    }
+		    
+		    for(int i=0;i<n;i+=2){
+		        for(int j=0;j<m;j+=2){
+		            if(i==n-1&&j==m-1){
+		                helper(arr,i-1,j-1);
+		            }else if(i==n-1){
+		                helper(arr,i-1,j);
+		            }else if(j==m-1){
+		                helper(arr,i,j-1);
+		            }else{
+		                helper(arr,i,j);
+		            }
+		            
+		        }
+		    }
+		    System.out.println(ans.size());
+		    for(int[] move:ans){
+		        for(int i=0;i<6;i++){
+		            System.out.print(move[i]+1 +"" "");
+		        }
+		        System.out.println();
+		    }
+		  //  for(int i=0;i<n;i++){
+		        
+		  //      for(int j=0;j<m;j++){
+		  //          System.out.print(arr[i][j] +"" "");
+		  //      }
+		  //      System.out.println();
+		  //  }	
+		
+		    
+		}   
+		
+		
+        
+	}
+}",0
+a4d6775d,eea69e7f,"import java.io.*;
+import java.util.*;
+ 
+public class ArmChairs {
+    
+ 
+    public static int solution(int n, int[] arr) {
+ 
+        ArrayList<Integer> one = new ArrayList<Integer>();
+        ArrayList<Integer> zero = new ArrayList<Integer>();
+ 
+        for (int i = 0; i < n; i++) {
+            if (arr[i] == 1) {
+                one.add(i);
+            } else {
+                zero.add(i);
+            }
+        }
+ 
+        int[][] dp = new int[one.size() + 1][zero.size() + 1];
+ 
+        for (int i = 1; i <= one.size(); i++) {
+            dp[i][i] = dp[i - 1][i - 1] + Math.abs(one.get(i - 1) - zero.get(i - 1));
+            for (int j = i + 1; j <= zero.size(); j++) {
+                dp[i][j] = Math.min(dp[i][j - 1], dp[i - 1][j - 1] + Math.abs(one.get(i - 1) - zero.get(j - 1)));
+            }
+        }
+ 
+        return dp[one.size()][zero.size()];
+    }
+ 
+ 
+    public static void main(String[] args) throws IOException{
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        BufferedWriter log = new BufferedWriter(new OutputStreamWriter(System.out));
+ 
+        int n = Integer.parseInt(br.readLine());
+ 
+        String[] s = br.readLine().split("" "");
+        int[] arr = new int[n];
+        for (int i = 0; i < n; i++) {
+            arr[i] = Integer.parseInt(s[i]);
+        } 
+ 
+        log.write(Integer.toString(solution(n, arr)) + ""\n"");
+        log.flush();
+        
+    }
+ 
+}","import java.util.*;
+
+public class Solution {
+	
+	public static int minMoves(int[] input) {
+		List<Integer> people = new ArrayList<Integer>();
+		List<Integer> chairs = new ArrayList<Integer>();
+		
+		for (int i = 0; i < input.length; i++) {
+			if (input[i] == 1) {
+				people.add(i);
+			} else {
+				chairs.add(i);
+			}
+		}
+		
+		int[] memo = new int[chairs.size() + 1];
+		
+
+		for (int p = 1; ((!people.isEmpty()) && (p <= people.size())); p++) {
+			int prev = memo[p];
+			memo[p] = memo[p - 1] + Math.abs(people.get(p - 1) - chairs.get(p - 1));
+			for (int c = p + 1; c <= chairs.size(); c++) {
+				int tmp = memo[c];
+				memo[c] = Math.min(memo[c - 1], prev + Math.abs(people.get(p - 1) - chairs.get(c - 1)));
+				prev = tmp;
+			}
+		}
+		return memo[memo.length - 1];
+	}
+	
+	
+	public static void main(String[] args) {
+		Scanner sc = new Scanner(System.in);
+		int n = sc.nextInt();
+		int[] input = new int[n];
+		for (int i = 0; i < n; i++) {
+			input[i] = sc.nextInt();
+		}
+		
+		System.out.println(Solution.minMoves(input));
+		
+	}
+}",0
+26e699de,3dd65549,"//package Task1;
+
+import java.util.Scanner;
+
+public class Menorah {
+    static int MOD9= 1000000000;
+
+    public static void main(String[] args){
+
+        Scanner sc= new Scanner(System.in);
+        int numberTest=sc.nextInt();
+        while(numberTest-->0){
+            int n=sc.nextInt();
+            char[] s=new char[n+5];
+            char[] t=new char[n+5];
+            String ss=sc.next();
+            String tt=sc.next();
+            s=ss.toCharArray();
+            t=tt.toCharArray();
+            int cntax = 0, cntbx = 0, same = 0;
+            int ans=MOD9;
+            for(int i=0; i<n; i++){
+                if(s[i]=='1')cntax++;
+                if(t[i]=='1')cntbx++;
+                if(s[i]==t[i])same++;
+            }
+            if(same==n){
+                System.out.println(0);
+                continue;
+            }
+            else if (cntax==0){
+                System.out.println(-1);
+                continue;
+            }
+            if(cntax==cntbx){
+                ans=Math.min(ans,n-same);
+            }
+            if(n-cntax+1==cntbx)ans=Math.min(ans,same);
+            if(ans<MOD9) System.out.println(ans);
+            else System.out.println(-1);
+
+
+
+        }
+
+    }
+}
+","import java.util.*;
+import java.io.*;
+
+public class codeforces {
+	public static void main(String[] args) throws Exception {
+		int t=sc.nextInt();
+		while(t-->0) {
+			int n=sc.nextInt();
+			char[] a=sc.next().toCharArray();
+			char[] b=sc.next().toCharArray();
+			int e0=0;
+			int e1=0;
+			int o0=0;
+			int o1=0;
+			for(int i=0;i<n;i++) {
+				if(a[i]!=b[i]) {
+					if(a[i]=='1') {
+						e1++;
+					}else {
+						e0++;
+					}
+				}else {
+					if(a[i]=='1') {
+						o1++;
+					}else {
+						o0++;
+					}
+				}
+			}
+			int ans=Integer.MAX_VALUE;
+			
+			if(e1==e0) {
+				ans=Math.min(ans, e1+e0);
+			}
+			if(o1==o0+1) {
+				ans=Math.min(ans, o1+o0);
+			}
+//			pw.println(e0+"" ""+e1+"" ""+o0+"" ""+o1);
+			pw.println(ans==Integer.MAX_VALUE?-1:ans);
+		}
+		pw.close();
+	}
+
+	static class Scanner {
+		StringTokenizer st;
+		BufferedReader br;
+
+		public Scanner(InputStream s) {
+			br = new BufferedReader(new InputStreamReader(s));
+		}
+
+		public Scanner(FileReader r) {
+			br = new BufferedReader(r);
+		}
+
+		public String next() throws IOException {
+			while (st == null || !st.hasMoreTokens())
+				st = new StringTokenizer(br.readLine());
+			return st.nextToken();
+		}
+
+		public int nextInt() throws IOException {
+			return Integer.parseInt(next());
+		}
+
+		public long nextLong() throws IOException {
+			return Long.parseLong(next());
+		}
+
+		public String nextLine() throws IOException {
+			return br.readLine();
+		}
+
+		public double nextDouble() throws IOException {
+			String x = next();
+			StringBuilder sb = new StringBuilder(""0"");
+			double res = 0, f = 1;
+			boolean dec = false, neg = false;
+			int start = 0;
+			if (x.charAt(0) == '-') {
+				neg = true;
+				start++;
+			}
+			for (int i = start; i < x.length(); i++)
+				if (x.charAt(i) == '.') {
+					res = Long.parseLong(sb.toString());
+					sb = new StringBuilder(""0"");
+					dec = true;
+				} else {
+					sb.append(x.charAt(i));
+					if (dec)
+						f *= 10;
+				}
+			res += Long.parseLong(sb.toString()) / f;
+			return res * (neg ? -1 : 1);
+		}
+
+		public long[] nextlongArray(int n) throws IOException {
+			long[] a = new long[n];
+			for (int i = 0; i < n; i++)
+				a[i] = nextLong();
+			return a;
+		}
+
+		public Long[] nextLongArray(int n) throws IOException {
+			Long[] a = new Long[n];
+			for (int i = 0; i < n; i++)
+				a[i] = nextLong();
+			return a;
+		}
+
+		public int[] nextIntArray(int n) throws IOException {
+			int[] a = new int[n];
+			for (int i = 0; i < n; i++)
+				a[i] = nextInt();
+			return a;
+		}
+
+		public Integer[] nextIntegerArray(int n) throws IOException {
+			Integer[] a = new Integer[n];
+			for (int i = 0; i < n; i++)
+				a[i] = nextInt();
+			return a;
+		}
+
+		public boolean ready() throws IOException {
+			return br.ready();
+		}
+
+	}
+
+	static class pair implements Comparable<pair> {
+		long x;
+		long y;
+
+		public pair(long x, long y) {
+			this.x = x;
+			this.y = y;
+		}
+
+		public String toString() {
+			return x + "" "" + y;
+		}
+
+		public boolean equals(Object o) {
+			if (o instanceof pair) {
+				pair p = (pair) o;
+				return p.x == x && p.y == y;
+			}
+			return false;
+		}
+
+		public int hashCode() {
+			return new Long(x).hashCode() * 31 + new Long(y).hashCode();
+		}
+
+		public int compareTo(pair other) {
+			if (this.x == other.x) {
+				return Long.compare(this.y, other.y);
+			}
+			return Long.compare(this.x, other.x);
+		}
+	}
+
+	static class tuble implements Comparable<tuble> {
+		int x;
+		int y;
+		int z;
+
+		public tuble(int x, int y, int z) {
+			this.x = x;
+			this.y = y;
+			this.z = z;
+		}
+
+		public String toString() {
+			return x + "" "" + y + "" "" + z;
+		}
+
+		public int compareTo(tuble other) {
+			if (this.x == other.x) {
+				if (this.y == other.y) {
+					return this.z - other.z;
+				}
+				return this.y - other.y;
+			} else {
+				return this.x - other.x;
+			}
+		}
+	}
+
+	static long mod = 1000000007;
+	static Random rn = new Random();
+	static Scanner sc = new Scanner(System.in);
+	static PrintWriter pw = new PrintWriter(System.out);
+}",0
+307ef2cb,565f77b7,"import java.util.PriorityQueue;
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.StringTokenizer;
+import java.util.Arrays;
+import java.util.Random;
+import java.io.FileWriter;
+import java.io.PrintWriter;
+/*
+    Solution Created: 18:16:56 02/05/2021
+    Custom Competitive programming helper.
+*/
+
+public class Main {
+	public static void solve() {
+		int n = in.nextInt(), m = in.nextInt(), x = in.nextInt();
+		Pair[] a = new Pair[n];
+		for(int i = 0; i<n; i++) a[i] = new Pair(i, in.nextInt());
+		Util.sortArray(a);
+		Util.reverse(a);
+		PriorityQueue<Pair> heights = new PriorityQueue<>();
+		for(int i = 0; i<m; i++) heights.add(new Pair(i, 0));
+		int[] ans = new int[n];
+		for(int i = 0; i<n; i++) {
+			Pair p = heights.poll();
+			p.val += a[i].val;
+			ans[a[i].idx] = p.idx+1;
+			heights.add(p);
+		}
+		long mn = Long.MAX_VALUE, mx = Long.MIN_VALUE;
+		while(!heights.isEmpty()) {
+			Pair p = heights.poll();
+			mn = Math.min(mn, p.val);
+			mx = Math.max(mx, p.val);
+		}
+		if(mx-mn>x) {
+			out.println(""NO"");
+			return;
+		}
+		out.println(""YES"");
+		out.printlnArray(ans);
+	}
+	static class Pair implements Comparable<Pair>{
+		int idx;
+		long val;
+		public Pair(int idx, long val) {
+			this.idx = idx;
+			this.val = val;
+		}
+		public String toString() {
+			return this.idx+"" ""+this.val;
+		}
+		@Override
+		public int compareTo(Main.Pair o) {
+			return Long.compare(this.val, o.val);
+		}
+	}
+	public static void main(String[] args) {
+		in = new Reader();
+		out = new Writer();
+		int t = in.nextInt();
+		while(t-->0) solve();
+		out.exit();
+	}
+	static Reader in; static Writer out;
+
+static class Reader {
+	static BufferedReader br;
+	static StringTokenizer st;
+	
+	public Reader() {
+		this.br = new BufferedReader(new InputStreamReader(System.in));
+	}
+	
+	public Reader(String f){
+		try {
+			this.br = new BufferedReader(new FileReader(f));
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+	}
+	
+	public int[] na(int n) {
+		int[] a = new int[n];
+		for (int i = 0; i < n; i++) a[i] = nextInt();
+		return a;
+	}
+
+	public double[] nd(int n) {
+		double[] a = new double[n];
+		for (int i = 0; i < n; i++) a[i] = nextDouble();
+		return a;
+	}
+	
+	public long[] nl(int n) {
+		long[] a = new long[n];
+		for (int i = 0; i < n; i++) a[i] = nextLong();
+		return a;
+	}
+
+	public char[] nca() {
+		return next().toCharArray();
+	}
+
+	public String[] ns(int n) {
+		String[] a = new String[n];
+		for (int i = 0; i < n; i++) a[i] = next();
+		return a;
+	}
+
+	public int nextInt() {
+		ensureNext();
+		return Integer.parseInt(st.nextToken());
+	}
+
+	public double nextDouble() {
+		ensureNext();
+		return Double.parseDouble(st.nextToken());
+	}
+
+	public Long nextLong() {
+		ensureNext();
+		return Long.parseLong(st.nextToken());
+	}
+
+	public String next() {
+		ensureNext();
+		return st.nextToken();
+	}
+	
+	public String nextLine() {
+		try {
+			return br.readLine();
+		} catch (Exception e) {
+			e.printStackTrace();
+			return null;
+		}
+	}
+	
+	private void ensureNext() {
+		if (st == null || !st.hasMoreTokens()) {
+			try {
+				st = new StringTokenizer(br.readLine());
+			} catch (IOException e) {
+				e.printStackTrace();
+			}
+		}
+	}
+}
+
+static class Util{
+		private static Random random = new Random();
+		static long[] fact;
+		
+		public static void initFactorial(int n, long mod) {
+			fact = new long[n+1];
+			fact[0] = 1;
+			for (int i = 1; i < n+1; i++) fact[i] = (fact[i - 1] * i) % mod;
+		}
+		
+		public static long modInverse(long a, long MOD) {
+			long[] gcdE = gcdExtended(a, MOD);
+			if (gcdE[0] != 1) return -1; // Inverted doesn't exist
+			long x = gcdE[1];
+			return (x % MOD + MOD) % MOD;
+		}
+		
+		public static long[] gcdExtended(long p, long q) {
+			if (q == 0) return new long[] { p, 1, 0 };
+			long[] vals = gcdExtended(q, p % q);
+			long tmp = vals[2];
+			vals[2] = vals[1] - (p / q) * vals[2];
+			vals[1] = tmp;
+			return vals;
+		}
+		
+		public static long nCr(int n, int r, long MOD) {
+			if (r == 0) return 1;
+			return (fact[n] * modInverse(fact[r], MOD) % MOD * modInverse(fact[n - r], MOD) % MOD) % MOD;
+		}
+		
+		public static long nCr(int n, int r) {
+			return (fact[n]/fact[r])/fact[n-r];
+		}
+		
+		public static long nPr(int n, int r, long MOD) {
+			if (r == 0) return 1;
+			return (fact[n] * modInverse(fact[n - r], MOD) % MOD) % MOD;
+		}
+		public static long nPr(int n, int r) {
+			return fact[n]/fact[n-r];
+		}
+		
+		public static boolean isPrime(int n) { 
+	        if (n <= 1) return false; 
+	        if (n <= 3) return true; 
+	        if (n % 2 == 0 || n % 3 == 0) return false; 
+	        for (int i = 5; i * i <= n; i = i + 6) 
+	            if (n % i == 0 || n % (i + 2) == 0) 
+	            return false; 
+	        return true; 
+	    }
+		
+	    public static boolean[] getSieve(int n) {
+	        boolean[] isPrime = new boolean[n+1];
+	        for (int i = 2; i <= n; i++) isPrime[i] = true;
+	        for (int i = 2; i*i <= n; i++) if (isPrime[i]) 
+	                for (int j = i; i*j <= n; j++) isPrime[i*j] = false;
+	        return isPrime;
+	    }
+	    
+	    public static int gcd(int a, int b) { 
+	    	int tmp = 0;
+	    	while(b != 0) {
+	    		tmp = b;
+	    		b = a%b;
+	    		a = tmp;
+	    	}
+	    	return a;
+	    }
+	    
+	    public static long gcd(long a, long b) { 
+	    	long tmp = 0;
+	    	while(b != 0) {
+	    		tmp = b;
+	    		b = a%b;
+	    		a = tmp;
+	    	}
+	    	return a;
+	    }
+	    
+	    public static int random(int min, int max) {
+	    	return random.nextInt(max-min+1)+min;
+	    }
+	    
+		public static void dbg(Object... o) { 
+			System.out.println(Arrays.deepToString(o)); 
+		}
+		
+		public static void reverse(int[] s, int l , int r) {
+			for(int i = l; i<=(l+r)/2; i++) {
+				int tmp = s[i];
+				s[i] = s[r+l-i];
+				s[r+l-i] = tmp;
+			}
+	    }
+		
+		public static void reverse(int[] s) {
+			reverse(s, 0, s.length-1);
+	    }
+		
+		public static void reverse(long[] s, int l , int r) {
+			for(int i = l; i<=(l+r)/2; i++) {
+				long tmp = s[i];
+				s[i] = s[r+l-i];
+				s[r+l-i] = tmp;
+			}
+	    }
+		
+		public static void reverse(long[] s) {
+			reverse(s, 0, s.length-1);
+	    }
+		
+		public static void reverse(float[] s, int l , int r) {
+			for(int i = l; i<=(l+r)/2; i++) {
+				float tmp = s[i];
+				s[i] = s[r+l-i];
+				s[r+l-i] = tmp;
+			}
+	    }
+		
+		public static void reverse(float[] s) {
+			reverse(s, 0, s.length-1);
+	    }
+		
+		public static void reverse(double[] s, int l , int r) {
+			for(int i = l; i<=(l+r)/2; i++) {
+				double tmp = s[i];
+				s[i] = s[r+l-i];
+				s[r+l-i] = tmp;
+			}
+	    }
+		
+		public static void reverse(double[] s) {
+			reverse(s, 0, s.length-1);
+	    }
+		
+		public static void reverse(char[] s, int l , int r) {
+			for(int i = l; i<=(l+r)/2; i++) {
+				char tmp = s[i];
+				s[i] = s[r+l-i];
+				s[r+l-i] = tmp;
+			}
+	    }
+		
+		public static void reverse(char[] s) {
+			reverse(s, 0, s.length-1);
+	    }
+		
+		public static <T> void reverse(T[] s, int l , int r) {
+			for(int i = l; i<=(l+r)/2; i++) {
+				T tmp = s[i];
+				s[i] = s[r+l-i];
+				s[r+l-i] = tmp;
+			}
+	    }
+		
+		public static <T> void reverse(T[] s) {
+			reverse(s, 0, s.length-1);
+	    }
+		
+		public static void shuffle(int[] s) {
+	        for (int i = 0; i < s.length; ++i) {
+	            int j = random.nextInt(i + 1);
+	            int t = s[i];
+	            s[i] = s[j];
+	            s[j] = t;
+	        }
+	    }
+		
+	    public static void shuffle(long[] s) {
+	        for (int i = 0; i < s.length; ++i) {
+	            int j = random.nextInt(i + 1);
+	            long t = s[i];
+	            s[i] = s[j];
+	            s[j] = t;
+	        }
+	    }
+	    
+	    public static void shuffle(float[] s) {
+	        for (int i = 0; i < s.length; ++i) {
+	            int j = random.nextInt(i + 1);
+	            float t = s[i];
+	            s[i] = s[j];
+	            s[j] = t;
+	        }
+	    }
+	    
+	    public static void shuffle(double[] s) {
+	        for (int i = 0; i < s.length; ++i) {
+	            int j = random.nextInt(i + 1);
+	            double t = s[i];
+	            s[i] = s[j];
+	            s[j] = t;
+	        }
+	    }
+	    
+	    public static void shuffle(char[] s) {
+	        for (int i = 0; i < s.length; ++i) {
+	            int j = random.nextInt(i + 1);
+	            char t = s[i];
+	            s[i] = s[j];
+	            s[j] = t;
+	        }
+	    }
+	    
+	    public static <T> void shuffle(T[] s) {
+	        for (int i = 0; i < s.length; ++i) {
+	            int j = random.nextInt(i + 1);
+	            T t = s[i];
+	            s[i] = s[j];
+	            s[j] = t;
+	        }
+	    }
+	    
+		public static void sortArray(int[] a) {
+	        shuffle(a);
+	        Arrays.sort(a);
+	    }
+		
+		public static void sortArray(long[] a) {
+			shuffle(a);
+	        Arrays.sort(a);
+	    }
+		
+		public static void sortArray(float[] a) {
+			shuffle(a);
+	        Arrays.sort(a);
+	    }
+		
+		public static void sortArray(double[] a) {
+			shuffle(a);
+	        Arrays.sort(a);
+	    }
+		
+		public static void sortArray(char[] a) {
+			shuffle(a);
+	        Arrays.sort(a);
+	    }
+		
+		public static <T extends Comparable<T>> void sortArray(T[] a) {
+	        Arrays.sort(a);
+	    }
+	}
+
+static class Writer {
+	private PrintWriter pw;
+	public Writer(){
+		pw = new PrintWriter(System.out);
+	}
+	
+	public Writer(String f){
+		try {
+			pw = new PrintWriter(new FileWriter(f));
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+	}
+	
+	public void printArray(int[] a) {
+		for(int i = 0; i<a.length; i++) print(a[i]+"" "");
+	}
+	
+	public void printlnArray(int[] a) {
+		for(int i = 0; i<a.length; i++) print(a[i]+"" "");
+		pw.println();
+	}
+	
+	public void printArray(long[] a) {
+		for(int i = 0; i<a.length; i++) print(a[i]+"" "");
+	}
+	
+	public void printlnArray(long[] a) {
+		for(int i = 0; i<a.length; i++) print(a[i]+"" "");
+		pw.println();
+	}
+	
+	public void print(Object o) {
+		pw.print(o.toString());
+	}
+	
+	public void println(Object o) {
+		pw.println(o.toString());
+	}
+	
+	public void println() {
+		pw.println();
+	}
+	
+	public void flush() {
+		pw.flush();
+	}
+	public void exit() {
+		pw.close();
+	}
+}
+}
+","import java.util.*;
+import java.io.*;
+
+public class Solution {
+
+	static Scanner scn = new Scanner(System.in);
+	static PrintWriter out = new PrintWriter(System.out);
+	static StringBuilder sb = new StringBuilder();
+
+	public static void main(String[] HastaLaVistaLa) {
+		int t = scn.nextInt();
+		while(t-- > 0) solve();
+		out.println(sb);
+		out.close();
+	}
+
+	public static void solve() {
+		// Road To Specialist Day 3
+		int n = scn.nextInt(), m = scn.nextInt(), x = scn.nextInt();
+		int[] a = new int[n], ans = new int[n];
+		for(int i = 0; i < n; i++) a[i] = scn.nextInt();
+		PriorityQueue<Pair> pq = new PriorityQueue<>();
+		for(int i = 0; i < m; i++) pq.add(new Pair(0L, i));
+		for(int i = 0; i < n; i++) {
+			int e = a[i];
+			Pair p = pq.poll();
+			p.value += e;
+			pq.add(p);
+			ans[i] = p.id + 1;
+		}
+		boolean check = false;
+		long prev = pq.poll().value;
+		while(!pq.isEmpty()) {
+			long cur = pq.poll().value;
+			if(Math.abs(cur - prev) > x) check = true;
+			prev = cur;
+		}
+		if(check) sb.append(""NO"");
+		else {
+			sb.append(""YES\n"");
+			for(int i : ans) sb.append(i + "" "");
+		}
+		sb.append(""\n"");
+	}
+	static class Pair implements Comparable<Pair> {
+		int id;
+		long value;
+		public Pair(long value, int id) {
+			this.id = id;
+			this.value = value;
+		}
+		public int compareTo(Pair o) {
+			return Long.compare(value, o.value);
+		}
+	}
+}",0
+81a9086f,baebdc56,"
+import java.io.*;
+import java.util.*;
+ 
+public class D 
+{	
+	static long mod=998244353;
+	static long[] facts, factInvs;
+	
+	public static void main(String[] args)throws IOException 
+	{	
+		FastReader f=new FastReader();
+		StringBuffer sb = new StringBuffer();
+		
+		int n=f.nextInt();
+		int k=f.nextInt();
+		
+		Time time[]=new Time[n];
+		for(int i=0;i<n;i++)
+		{
+			int x=f.nextInt();
+			int y=f.nextInt();
+			
+			time[i]=new Time(x,y);
+		}
+		Arrays.sort(time);
+		precomp();
+//		for(Time t : time)
+//			System.out.println(t.x+"" ""+t.y);
+		
+		int curr=0;
+		long ans=0;
+		Queue<Integer> pq=new PriorityQueue<>();
+		for(int i=0;i<n;i++)
+		{	
+//			System.out.println(""time seg = ""+time[i].x+"" ""+time[i].y);
+			int x=time[i].x;
+			pq.add(time[i].y);
+			curr++;
+			while(!pq.isEmpty() && pq.peek()<x)
+			{	
+				pq.poll();
+				curr--;
+			}
+//			System.out.println(""curr = ""+curr);
+
+			if(curr<k)
+				continue;
+			else
+			{	
+				long add=getNcR(curr-1,k-1)%mod;
+				ans=(ans%mod + add)%mod;
+//				System.out.println(""add = ""+add);
+			}
+		}
+		System.out.println(ans);
+	}
+	
+	static void precomp() 
+	{
+		facts=new long[1000000];
+		factInvs=new long[1000000];
+		factInvs[0]=facts[0]=1;
+		
+		for (int i=1; i<facts.length; i++)
+			facts[i]=mul(facts[i-1], i);
+		
+		factInvs[facts.length-1]=modInv(facts[facts.length-1]);
+		
+		for (int i=facts.length-2; i>=0; i--)
+			factInvs[i]=mul(factInvs[i+1], i+1);
+	}
+	
+	static long getNcR(int n, int k) {
+		return mul(facts[n], mul(factInvs[k], factInvs[n-k]));
+	}
+	
+	static long mul(long a, long b) {
+		return a*b%mod;
+	}
+	
+	static long modInv(long x) {
+		return exp(x, mod-2);
+	}
+	
+	static long exp(long base, long e) 
+	{
+		if (e==0) 
+			return 1;
+		long half=exp(base, e/2);
+		if (e%2==0) 
+			return mul(half, half);
+		else
+			return mul(half, mul(half, base));
+	}
+	
+	static class Time implements Comparable<Time>
+	{
+		int x,y;
+		Time(int x,int y)
+		{
+			this.x=x;
+			this.y=y;
+		}
+		@Override
+		public int compareTo(Time o) 
+		{
+			return Integer.compare(x,o.x);
+		}
+	}
+	
+	static class FastReader 
+	{ 
+	    BufferedReader br; 
+	    StringTokenizer st; 
+
+	    public FastReader() {
+	    	br = new BufferedReader(new
+	                 InputStreamReader(System.in)); 
+	    }
+	    String next() { 
+	        while (st == null || !st.hasMoreElements()) { 
+	            try{ 
+	                st = new StringTokenizer(br.readLine()); 
+	            } 
+	            catch (IOException  e) { 
+	                e.printStackTrace(); 
+	            } 
+	        } 
+	        return st.nextToken(); 
+	    } 
+	    int nextInt() { 
+	        return Integer.parseInt(next()); 
+	    } 
+	    long nextLong() { 
+	        return Long.parseLong(next()); 
+	    } 
+	    double nextDouble() { 
+	        return Double.parseDouble(next()); 
+	    } 
+	    String nextLine() { 
+	        String str = """"; 
+	        try{ 
+	            str = br.readLine(); 
+	        } 
+	        catch (IOException e) { 
+	            e.printStackTrace(); 
+	        } 
+	        return str; 
+	    } 
+	} 
+}","import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.Arrays;
+import java.util.Random;
+import java.util.StringTokenizer;
+
+public class D {
+	
+	static final int mod=998244353;
+	
+	static long[] facts, factInvs;
+
+	public static void main(String[] args) {
+		precomp();
+		FastScanner fs=new FastScanner();
+		int n=fs.nextInt(), k=fs.nextInt();
+		Seg[] segs=new Seg[n];
+		for (int i=0; i<n; i++) segs[i]=new Seg(fs.nextInt(), fs.nextInt());
+		Event[] events=new Event[n*2];
+		for (int i=0; i<n; i++) {
+			events[2*i]=new Event(segs[i], true);
+			events[2*i+1]=new Event(segs[i], false);
+		}
+		long ans=0;
+
+		Arrays.sort(events);
+		int counter=0;
+		for (Event e:events) {
+			if (e.start) {
+				counter++;
+			}
+			else {
+				counter--;
+				if (counter+1<k)
+					continue;
+				else
+					ans=add(ans, nCk(counter, k-1));
+			}
+		}
+		System.out.println(ans);
+	}
+
+	static final Random random=new Random();
+	
+	static void ruffleSort(int[] a) {
+		int n=a.length;//shuffle, then sort 
+		for (int i=0; i<n; i++) {
+			int oi=random.nextInt(n), temp=a[oi];
+			a[oi]=a[i]; a[i]=temp;
+		}
+		Arrays.sort(a);
+	}
+	
+	static long add(long a, long b) {
+		return (a+b)%mod;
+	}
+	
+	static long mul(long a, long b) {
+		return a*b%mod;
+	}
+	
+	static long exp(long base, long e) {
+		if (e==0) return 1;
+		long half=exp(base, e/2);
+		if (e%2==0) return mul(half, half);
+		return mul(half, mul(half, base));
+	}
+	
+	static long modInv(long x) {
+		return exp(x, mod-2);
+	}
+	
+	static void precomp() {
+		facts=new long[1_000_000];
+		factInvs=new long[1_000_000];
+		factInvs[0]=facts[0]=1;
+		for (int i=1; i<facts.length; i++)
+			facts[i]=mul(facts[i-1], i);
+		factInvs[facts.length-1]=modInv(facts[facts.length-1]);
+		for (int i=facts.length-2; i>=0; i--)
+			factInvs[i]=mul(factInvs[i+1], i+1);
+	}
+	
+	static long nCk(int n, int k) {
+		return mul(facts[n], mul(factInvs[k], factInvs[n-k]));
+	}
+	
+	static class Seg {
+		int l, r;
+		public Seg(int l, int r) {
+			this.l=l;
+			this.r=r;
+		}
+	}
+	
+	static class Event implements Comparable<Event> {
+		boolean start;
+		Seg s;
+		public Event(Seg s, boolean start) {
+			this.s=s;
+			this.start=start;
+		}
+
+		int x() {
+			if (start) return s.l;
+			return s.r;
+		}
+		
+		public int compareTo(Event o) {
+			if (x()!=o.x()) return Integer.compare(x(), o.x());
+			if (start==o.start)return 0;
+			if (start) return -1;
+			return 1;
+		}
+	}
+	
+	static class FastScanner {
+		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st=new StringTokenizer("""");
+		String next() {
+			while (!st.hasMoreTokens())
+				try {
+					st=new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			return st.nextToken();
+		}
+		
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+		int[] readArray(int n) {
+			int[] a=new int[n];
+			for (int i=0; i<n; i++) a[i]=nextInt();
+			return a;
+		}
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+	}
+
+	
+}
+",0
+8703709f,d2901569,"import java.io.*;
+import java.util.*;
+
+public class Main {
+
+//	static boolean[] prime = new boolean[10000000];
+	final static long mod = 1000000007;
+
+	public static void main(String[] args) {
+//		sieve();
+		InputReader in = new InputReader(System.in);
+		PrintWriter out = new PrintWriter(System.out);
+
+		int t = in.nextInt();
+		while (t-- > 0) {
+			int n = in.nextInt();
+
+			Integer[] k = intInput(n, in), h = intInput(n, in);
+			long ans = 0;
+			int a = k[n - 1];
+			int current = k[n - 1];
+			for (int i = n - 1; i >= 0; i--) {
+				if (current > k[i]) {
+					ans += sum(a - current + 1);
+					a = k[i];
+					current = k[i]-h[i]+1;
+				}else {
+					current = Math.min(current, k[i] - h[i]+1);
+				}
+			}
+			ans += sum(a - current + 1);
+			out.println(ans);
+		}
+
+		out.flush();
+	}
+
+	static long sum(long a) {
+		return a * (a + 1) / 2;
+	}
+
+	static boolean prime(long k) {
+		for (int i = 2; i * i <= k; i++) {
+			if (k % i == 0) {
+				return false;
+			}
+		}
+		return true;
+	}
+
+	static long gcd(long a, long b) {
+		if (a % b == 0) {
+			return b;
+		} else {
+			return gcd(b, a % b);
+		}
+	}
+
+	static void reverseArray(Integer[] a) {
+		for (int i = 0; i < (a.length >> 1); i++) {
+			Integer temp = a[i];
+			a[i] = a[a.length - 1 - i];
+			a[a.length - 1 - i] = temp;
+		}
+	}
+
+	static Integer[] intInput(int n, InputReader in) {
+		Integer[] a = new Integer[n];
+		for (int i = 0; i < a.length; i++)
+			a[i] = in.nextInt();
+		return a;
+	}
+
+	static Long[] longInput(int n, InputReader in) {
+		Long[] a = new Long[n];
+		for (int i = 0; i < a.length; i++)
+			a[i] = in.nextLong();
+		return a;
+	}
+
+	static String[] strInput(int n, InputReader in) {
+		String[] a = new String[n];
+		for (int i = 0; i < a.length; i++)
+			a[i] = in.next();
+		return a;
+	}
+
+//	static void sieve() {
+//		for (int i = 2; i * i < prime.length; i++) {
+//			if (prime[i])
+//				continue;	
+//			for (int j = i * i; j < prime.length; j += i) {
+//				prime[j] = true;
+//			}
+//		}
+//	}
+
+}
+
+class Data {
+	int val;
+	int ind;
+	boolean positive;
+
+	Data(int val, int ind) {
+		this.val = Math.abs(val);
+		this.ind = ind;
+		this.positive = val >= 0;
+	}
+}
+
+class compareVal implements Comparator<Data> {
+
+	@Override
+	public int compare(Data o1, Data o2) {
+//		return (o1.val - o2.val == 0 ? o1.ind - o2.ind : o1.val - o2.val);
+		return (o1.val - o2.val);
+	}
+
+}
+
+class compareInd implements Comparator<Data> {
+
+	@Override
+	public int compare(Data o1, Data o2) {
+		return o1.ind - o2.ind == 0 ? o1.val - o2.val : o1.ind - o2.ind;
+	}
+
+}
+
+class InputReader {
+	public BufferedReader reader;
+	public StringTokenizer tokenizer;
+
+	public InputReader(InputStream stream) {
+		reader = new BufferedReader(new InputStreamReader(stream), 32768);
+		tokenizer = null;
+	}
+
+	public String next() {
+		while (tokenizer == null || !tokenizer.hasMoreTokens()) {
+			try {
+				tokenizer = new StringTokenizer(reader.readLine());
+			} catch (IOException e) {
+				throw new RuntimeException(e);
+			}
+		}
+		return tokenizer.nextToken();
+	}
+
+	public int nextInt() {
+		return Integer.parseInt(next());
+	}
+
+	long nextLong() {
+		return Long.parseLong(next());
+	}
+
+	double nextDouble() {
+		return Double.parseDouble(next());
+	}
+
+	String nextLine() {
+		String str = """";
+		try {
+			str = reader.readLine();
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+		return str;
+	}
+
+}","import java.util.*;
+import java.util.Scanner;
+
+
+public class Solution {
+	static int mod=1000000007;;
+	
+//	 
+	public static void main(String[] args) {
+		// TODO Auto-generated method stub
+//		System.out.println();
+
+		Scanner sc=new Scanner(System.in);
+		int tt=sc.nextInt();
+//		
+//		
+		while(tt-->0){
+				int n=sc.nextInt();
+			
+				int k[]=new int[n];
+				int h[]=new int[n];
+				
+				for(int i=0;i<n;i++) {
+					k[i]=sc.nextInt();
+				}
+				for(int i=0;i<n;i++) {
+					h[i]=sc.nextInt();
+				}
+				long ans=0;
+				int start=k[0]-h[0]-1;
+				int end=k[0];
+				int last=0;
+				for(int j=0;j<n;j++) {
+					 start=k[j]-h[j]+1;
+					 end=k[j];
+					 last=j;
+				for(int i=j+1;i<n;i++) {
+					int temp=k[i]-h[i]+1;
+					
+					if(temp<=end) {
+						start=Math.min(start, temp);
+						end=Math.max(end, k[i]);
+						last=i;
+					}
+					
+					
+					
+				}
+				j=last;
+				
+				long va=end-start+1;
+				
+				ans+=(va*(va+1))/2;
+				
+				}
+				System.out.println(ans);
+				
+			
+		}
+	}
+		
+		
+	
+		
+		
+	
+	
+	
+
+
+}
+",0
+5756162d,808f7516,"import java.io.*;
+import java.math.BigInteger;
+import java.util.*;
+
+public class Main {
+    static int MOD = 1000000007;
+
+    // After writing solution, quick scan for:
+    //   array out of bounds
+    //   special cases e.g. n=1?
+    //
+    // Big numbers arithmetic bugs:
+    //   int overflow
+    //   sorting, or taking max, after MOD
+    void solve() throws IOException {
+        int n = ri();
+        int[] h = ril(n);
+        
+        List<List<Integer>> adj = new ArrayList<>(n);
+        for (int i = 0; i < n; i++) adj.add(new ArrayList<>());
+        int[] nextGe = new int[n];
+        nextGe[n-1] = n;
+        for (int i = n-2; i >= 0; i--) {
+            int j = i+1;
+            while (j != n && h[j] < h[i]) j = nextGe[j];
+            nextGe[i] = j;
+        }
+        int[] nextLe = new int[n];
+        nextLe[n-1] = n;
+        for (int i = n-2; i >= 0; i--) {
+            int j = i+1;
+            while (j != n && h[j] > h[i]) j = nextLe[j];
+            nextLe[i] = j;
+        }
+        int[] prevGe = new int[n];
+        prevGe[0] = -1;
+        for (int i = 1; i < n; i++) {
+            int j = i-1;
+            while (j != -1 && h[j] < h[i]) j = prevGe[j];
+            prevGe[i] = j;
+        }
+        int[] prevLe = new int[n];
+        prevLe[0] = -1;
+        for (int i = 1; i < n; i++) {
+            int j = i-1;
+            while (j != -1 && h[j] > h[i]) j = prevLe[j];
+            prevLe[i] = j;
+        }
+        for (int i = 0; i < n; i++) {
+            if (prevLe[i] != -1) adj.get(prevLe[i]).add(i);
+            if (prevGe[i] != -1) adj.get(prevGe[i]).add(i);
+            if (nextLe[i] != n) adj.get(i).add(nextLe[i]);
+            if (nextGe[i] != n) adj.get(i).add(nextGe[i]);
+        }
+
+        int dist = 0;
+        Deque<Integer> q = new ArrayDeque<>();
+        boolean[] visited = new boolean[n];
+        q.addLast(0);
+        visited[0] = true;
+        while (!q.isEmpty()) {
+            int sz = q.size();
+            for (int i = 0; i < sz; i++) {
+                int u = q.removeFirst();
+                if (u == n-1) {
+                    q.clear();
+                    break;
+                }
+                for (int v : adj.get(u)) {
+                    if (!visited[v]) {
+                        visited[v] = true;
+                        q.addLast(v);
+                    }
+                }
+            }
+            dist++;
+        }
+        pw.println(dist-1);
+    }
+
+    // Template code below
+
+    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+    PrintWriter pw = new PrintWriter(System.out);
+
+    public static void main(String[] args) throws IOException {
+        Main m = new Main();
+        m.solve();
+        m.close();
+    }
+
+    void close() throws IOException {
+        pw.flush();
+        pw.close();
+        br.close();
+    }
+
+    int ri() throws IOException {
+        return Integer.parseInt(br.readLine());
+    }
+
+    long rl() throws IOException {
+        return Long.parseLong(br.readLine());
+    }
+
+    int[] ril(int n) throws IOException {
+        int[] nums = new int[n];
+        int c = 0;
+        for (int i = 0; i < n; i++) {
+            int sign = 1;
+            c = br.read();
+            int x = 0;
+            if (c == '-') {
+                sign = -1;
+                c = br.read();
+            }
+            while (c >= '0' && c <= '9') {
+                x = x * 10 + c - '0';
+                c = br.read();
+            }
+            nums[i] = x * sign;
+        }
+        while (c != '\n' && c != -1) c = br.read();
+        return nums;
+    }
+
+    long[] rll(int n) throws IOException {
+        long[] nums = new long[n];
+        int c = 0;
+        for (int i = 0; i < n; i++) {
+            int sign = 1;
+            c = br.read();
+            long x = 0;
+            if (c == '-') {
+                sign = -1;
+                c = br.read();
+            }
+            while (c >= '0' && c <= '9') {
+                x = x * 10 + c - '0';
+                c = br.read();
+            }
+            nums[i] = x * sign;
+        }
+        while (c != '\n' && c != -1) c = br.read();
+        return nums;
+    }
+
+    int[] rkil() throws IOException {
+        int sign = 1;
+        int c = br.read();
+        int x = 0;
+        if (c == '-') {
+            sign = -1;
+            c = br.read();
+        }
+        while (c >= '0' && c <= '9') {
+            x = x * 10 + c - '0';
+            c = br.read();
+        }
+        return ril(x);
+    }
+
+    long[] rkll() throws IOException {
+        int sign = 1;
+        int c = br.read();
+        int x = 0;
+        if (c == '-') {
+            sign = -1;
+            c = br.read();
+        }
+        while (c >= '0' && c <= '9') {
+            x = x * 10 + c - '0';
+            c = br.read();
+        }
+        return rll(x);
+    }
+
+    char[] rs() throws IOException {
+        return br.readLine().toCharArray();
+    }
+
+    void sort(int[] A) {
+        Random r = new Random();
+        for (int i = A.length-1; i > 0; i--) {
+            int j = r.nextInt(i+1);
+            int temp = A[i];
+            A[i] = A[j];
+            A[j] = temp;
+        }
+        Arrays.sort(A);
+    }
+}","import java.util.*;
+import java.io.*;
+public class EdD {
+	public static void main(String[] args) throws Exception{
+		int num = 998244353;
+
+		// TODO Auto-generated method stub
+ 		BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
+ 		PrintWriter out = new PrintWriter(System.out);
+//	 		String input1 = bf.readLine().trim();
+//	 		String input2 = bf.readLine().trim();
+ 		int n = Integer.parseInt(bf.readLine());
+ 		int[] array = new int[n];
+ 		StringTokenizer st = new StringTokenizer(bf.readLine());
+ 		for(int j = 0;j<n;j++){
+ 			array[j] = Integer.parseInt(st.nextToken());
+ 		}
+ 		Map<Integer, Set<Integer>> mp = new HashMap<Integer, Set<Integer>>();
+ 		for(int j =0;j<n;j++)
+ 			mp.put(j, new HashSet<Integer>());
+ 		int[] nextge = new int[n];
+ 		int[] nextle = new int[n];
+ 		int[] prevge = new int[n];
+ 		int[] prevle = new int[n];
+ 		nextge[n-1] = -1;
+ 		nextle[n-1] = -1;
+ 		prevge[0] = -1;
+ 		prevle[0] = -1;
+ 		for(int j = n-2;j>=0;j--){
+ 			if (array[j+1] < array[j]){
+ 				nextle[j] = j+1;
+ 				mp.get(j).add(j+1);
+ 				int temp = j+1;
+ 				while(temp!= -1 && array[temp] < array[j])
+ 					temp = nextge[temp];
+ 				nextge[j] = temp;
+ 				if (temp!= -1)
+ 					mp.get(j).add(temp);
+ 			}
+ 			else if (array[j+1] > array[j]){
+ 				nextge[j] = j+1;
+ 				mp.get(j).add(j+1);
+ 				int temp = j+1;
+ 				while(temp!= -1 && array[temp] > array[j])
+ 					temp = nextle[temp];
+ 				nextle[j] = temp;
+ 				if (temp!= -1)
+ 					mp.get(j).add(temp);
+ 			}
+ 			else{
+ 				nextge[j] = j+1;
+ 				mp.get(j).add(j+1);
+ 				nextle[j] = j+1;
+ 				mp.get(j).add(j+1);
+ 			}	
+ 		}
+ 		for(int j = 1;j<n;j++){
+ 			if (array[j] < array[j-1]){
+ 			
+ 				prevge[j] = j-1;
+ 				mp.get(j-1).add(j);
+ 				int temp = j-1;
+ 				while(temp!= -1 && array[temp] > array[j])
+ 					temp = prevle[temp];
+ 				prevle[j] = temp;
+ 				if (temp!= -1)
+ 					mp.get(temp).add(j);
+ 			}
+ 			else if (array[j] > array[j-1]){
+ 				prevle[j] = j-1;
+ 				mp.get(j-1).add(j);
+ 				int temp = j-1;
+ 				while(temp!= -1 && array[temp] < array[j])
+ 					temp = prevge[temp];
+ 				prevge[j] = temp;
+ 				if (temp!= -1)
+ 					mp.get(temp).add(j);
+ 			}
+ 			else{
+ 				prevge[j] = j-1;
+ 				prevle[j] = j-1;
+ 				mp.get(j-1).add(j);
+ 			}	
+ 		}
+	 	int[] depth = new int[n+1];
+ 		Set<Integer> seen = new HashSet<Integer>();
+ 		Queue<Integer> bfs = new LinkedList<Integer>();
+ 		bfs.add(0);
+ 		seen.add(0);
+ 		while(!bfs.isEmpty()){
+ 			int v = bfs.remove();
+ 			for(int child : mp.get(v)){
+ 				if (!seen.contains(child)){
+ 					bfs.add(child);
+ 					seen.add(child);
+ 					depth[child] = depth[v]+1;
+ 				}
+ 			}
+ 		}
+ 		
+ 		
+ 		out.println(depth[n-1]);
+	 		
+ 		out.close();
+ 		
+ 		
+ 		
+ 	}
+}
+ 	
+ 
+//StringJoiner sj = new StringJoiner("" ""); 
+//sj.add(strings)
+//sj.toString() gives string of those stuff w spaces or whatever that sequence is
+
+ 		
+ 		
+ 		
+ 		
+	
+
+
+",0
+6f037b1d,ef1117e3,"import java.util.*;
+
+
+import java.io.*;
+public class Test {
+    static class Scan
+    {
+        private byte[] buf=new byte[1024];
+        private int index;
+        private InputStream in;
+        private int total;
+        public Scan()
+        {
+            in=System.in;
+        }
+        public int scan()throws IOException
+        {
+            if(total<0)
+            throw new InputMismatchException();
+            if(index>=total)
+            {
+                index=0;
+                total=in.read(buf);
+                if(total<=0)
+                return -1;
+            }
+            return buf[index++];
+        }
+        public int scanInt()throws IOException
+        {
+            int integer=0;
+            int n=scan();
+            while(isWhiteSpace(n))
+            n=scan();
+            int neg=1;
+            if(n=='-')
+            {
+                neg=-1;
+                n=scan();
+            }
+            while(!isWhiteSpace(n))
+            {
+                if(n>='0'&&n<='9')
+                {
+                    integer*=10;
+                    integer+=n-'0';
+                    n=scan();
+                }
+                else throw new InputMismatchException();
+            }
+            return neg*integer;
+        }
+        public double scanDouble()throws IOException
+        {
+            double doub=0;
+            int n=scan();
+            while(isWhiteSpace(n))
+            n=scan();
+            int neg=1;
+            if(n=='-')
+            {
+                neg=-1;
+                n=scan();
+            }
+            while(!isWhiteSpace(n)&&n!='.')
+            {
+                if(n>='0'&&n<='9')
+                {
+                    doub*=10;
+                    doub+=n-'0';
+                    n=scan();
+                }
+                else throw new InputMismatchException();
+            }
+            if(n=='.')
+            {
+                n=scan();
+                double temp=1;
+                while(!isWhiteSpace(n))
+                {
+                    if(n>='0'&&n<='9')
+                    {
+                        temp/=10;
+                        doub+=(n-'0')*temp;
+                        n=scan();
+                    }
+                    else throw new InputMismatchException();
+                }
+            }
+            return doub*neg;
+        }
+        public String scanString()throws IOException
+        {
+            StringBuilder sb=new StringBuilder();
+            int n=scan();
+            while(isWhiteSpace(n))
+            n=scan();
+            while(!isWhiteSpace(n))
+            {
+                sb.append((char)n);
+                n=scan();
+            }
+            return sb.toString();
+        }
+        private boolean isWhiteSpace(int n)
+        {
+            if(n==' '||n=='\n'||n=='\r'||n=='\t'||n==-1)
+            return true;
+            return false;
+        }
+    }
+
+    static class Print
+    {
+        private final BufferedWriter bw;
+        public Print()
+        {
+            this.bw=new BufferedWriter(new OutputStreamWriter(System.out));
+        }
+        public void print(Object object)throws IOException
+        {
+            bw.append(""""+object);
+        }
+        public void println(Object object)throws IOException
+        {
+            print(object);
+            bw.append(""\n"");
+        }
+        public void close()throws IOException
+        {
+            bw.close();
+        }
+    }
+    public static void main(String[] args) throws IOException{
+        Scan scan = new Scan();
+        Print print = new Print();
+        int testcases = scan.scanInt();
+        while(testcases-->0){
+            int n = scan.scanInt();
+            ArrayList<ArrayList<Integer>> list = new ArrayList<ArrayList<Integer>>();
+            long range[][] = new long[n][2];
+            for(int i=0; i<n; i++){
+                
+                range[i][0] = scan.scanInt();
+                range[i][1] = scan.scanInt();
+                list.add(new ArrayList<Integer>());
+            }
+            for(int i=0; i<n-1; i++){
+                int a = scan.scanInt()-1;
+                int b = scan.scanInt()-1;
+                list.get(a).add(b);
+                list.get(b).add(a);
+            }
+            long dp[][] = new long[n][2];
+            // for(int i=0;i<n; i++){
+            //     Arrays.fill(dp[i], 0);
+            // }
+            boolean vis[] = new boolean[n];
+            dfs(list, vis, 0, dp, range);
+            print.println(Math.max(dp[0][0], dp[0][1]));
+            
+        }
+        print.close();
+    }
+
+    public static void dfs(ArrayList<ArrayList<Integer>> list, boolean[] vis, int parent, long dp[][] , long range[][]){
+        vis[parent] = true;
+        ArrayList<Integer> l = list.get(parent);
+
+        for(int i=0; i<l.size(); i++){
+            int next = l.get(i);
+            if(vis[next] == false){
+                dfs(list, vis, next, dp, range);
+                dp[parent][0] += Math.max(Math.abs(range[parent][0]-range[next][0])+dp[next][0], Math.abs(range[parent][0]-range[next][1])+dp[next][1]); 
+                dp[parent][1] += Math.max(Math.abs(range[parent][1]-range[next][0])+dp[next][0], Math.abs(range[parent][1]-range[next][1])+dp[next][1]); 
+            }
+
+        }
+    }
+
+    public static int gcd(int a, int b){
+        if(b == 0){
+            return a;
+        }
+        else{
+            return gcd(b, a%b);
+        }
+    }
+    
+    
+
+    
+    
+}
+","import java.util.*;
+import java.io.*;
+public class C {
+    static class Scan {
+        private byte[] buf=new byte[1024];
+        private int index;
+        private InputStream in;
+        private int total;
+        public Scan()
+        {
+            in=System.in;
+        }
+        public int scan()throws IOException
+        {
+            if(total<0)
+            throw new InputMismatchException();
+            if(index>=total)
+            {
+                index=0;
+                total=in.read(buf);
+                if(total<=0)
+                return -1;
+            }
+            return buf[index++];
+        }
+        public int scanInt()throws IOException
+        {
+            int integer=0;
+            int n=scan();
+            while(isWhiteSpace(n))
+            n=scan();
+            int neg=1;
+            if(n=='-')
+            {
+                neg=-1;
+                n=scan();
+            }
+            while(!isWhiteSpace(n))
+            {
+                if(n>='0'&&n<='9')
+                {
+                    integer*=10;
+                    integer+=n-'0';
+                    n=scan();
+                }
+                else throw new InputMismatchException();
+            }
+            return neg*integer;
+        }
+        public double scanDouble()throws IOException
+        {
+            double doub=0;
+            int n=scan();
+            while(isWhiteSpace(n))
+            n=scan();
+            int neg=1;
+            if(n=='-')
+            {
+                neg=-1;
+                n=scan();
+            }
+            while(!isWhiteSpace(n)&&n!='.')
+            {
+                if(n>='0'&&n<='9')
+                {
+                    doub*=10;
+                    doub+=n-'0';
+                    n=scan();
+                }
+                else throw new InputMismatchException();
+            }
+            if(n=='.')
+            {
+                n=scan();
+                double temp=1;
+                while(!isWhiteSpace(n))
+                {
+                    if(n>='0'&&n<='9')
+                    {
+                        temp/=10;
+                        doub+=(n-'0')*temp;
+                        n=scan();
+                    }
+                    else throw new InputMismatchException();
+                }
+            }
+            return doub*neg;
+        }
+        public String scanString()throws IOException
+        {
+            StringBuilder sb=new StringBuilder();
+            int n=scan();
+            while(isWhiteSpace(n))
+            n=scan();
+            while(!isWhiteSpace(n))
+            {
+                sb.append((char)n);
+                n=scan();
+            }
+            return sb.toString();
+        }
+        private boolean isWhiteSpace(int n)
+        {
+            if(n==' '||n=='\n'||n=='\r'||n=='\t'||n==-1)
+            return true;
+            return false;
+        }
+    }
+    
+    public static void sort(int arr[],int l,int r) {    //sort(arr,0,n-1);
+        if(l==r) {
+            return;
+        }
+        int mid=(l+r)/2;
+        sort(arr,l,mid);
+        sort(arr,mid+1,r);
+        merge(arr,l,mid,mid+1,r);
+    }
+    public static void merge(int arr[],int l1,int r1,int l2,int r2) {
+        int tmp[]=new int[r2-l1+1];
+        int indx1=l1,indx2=l2;
+        //sorting the two halves using a tmp array
+        for(int i=0;i<tmp.length;i++) {
+            if(indx1>r1) {
+                tmp[i]=arr[indx2];
+                indx2++;
+                continue;
+            }
+            if(indx2>r2) {
+                tmp[i]=arr[indx1];
+                indx1++;
+                continue;
+            }
+            if(arr[indx1]<arr[indx2]) {
+                tmp[i]=arr[indx1];
+                indx1++;
+                continue;
+            }
+            tmp[i]=arr[indx2];
+            indx2++;
+        }
+        //Copying the elements of tmp into the main array
+        for(int i=0,j=l1;i<tmp.length;i++,j++) {
+            arr[j]=tmp[i];
+        }
+    }
+    
+    public static void sort(long arr[],int l,int r) {    //sort(arr,0,n-1);
+        if(l==r) {
+            return;
+        }
+        int mid=(l+r)/2;
+        sort(arr,l,mid);
+        sort(arr,mid+1,r);
+        merge(arr,l,mid,mid+1,r);
+    }
+    public static void merge(long arr[],int l1,int r1,int l2,int r2) {
+        long tmp[]=new long[r2-l1+1];
+        int indx1=l1,indx2=l2;
+        //sorting the two halves using a tmp array
+        for(int i=0;i<tmp.length;i++) {
+            if(indx1>r1) {
+                tmp[i]=arr[indx2];
+                indx2++;
+                continue;
+            }
+            if(indx2>r2) {
+                tmp[i]=arr[indx1];
+                indx1++;
+                continue;
+            }
+            if(arr[indx1]<arr[indx2]) {
+                tmp[i]=arr[indx1];
+                indx1++;
+                continue;
+            }
+            tmp[i]=arr[indx2];
+            indx2++;
+        }
+        //Copying the elements of tmp into the main array
+        for(int i=0,j=l1;i<tmp.length;i++,j++) {
+            arr[j]=tmp[i];
+        }
+    }
+    
+    
+    static int n,l[],r[];
+    static ArrayList<Integer> adj_lst[];
+    static long dp[][];
+    
+    
+    public static void main(String args[]) throws IOException {
+        Scan input=new Scan();
+        StringBuilder ans=new StringBuilder("""");
+        int test=input.scanInt();
+        for(int tt=1;tt<=test;tt++) {
+            n=input.scanInt();
+            l=new int[n];
+            r=new int[n];
+            adj_lst=new ArrayList[n];
+            for(int i=0;i<n;i++) {
+                adj_lst[i]=new ArrayList<>();
+                l[i]=input.scanInt();
+                r[i]=input.scanInt();
+            }
+            for(int i=0;i<n-1;i++) {
+                int u=input.scanInt()-1;
+                int v=input.scanInt()-1;
+                adj_lst[u].add(v);
+                adj_lst[v].add(u);
+            }
+            
+            dp=new long[n+5][5];
+            
+            for(int i=0;i<dp.length;i++) {
+                for(int j=0;j<dp[0].length;j++) {
+                    dp[i][j]=-1;
+                }
+            }
+            
+            ans.append(solve(0,-1,0)+""\n"");
+            
+        }
+        System.out.println(ans);
+    }
+    public static long solve(int root,int par,int state) {
+        
+        if(dp[root+1][state]!=-1) {
+            return dp[root+1][state];
+        }
+        
+        long sum1=0,sum2=0;
+        
+        if(par!=-1 && state==0) {
+            sum1+=Math.abs(l[root]-l[par]);
+            sum2+=Math.abs(r[root]-l[par]);
+        }
+        else if(par!=-1) {
+            sum1+=Math.abs(l[root]-r[par]);
+            sum2+=Math.abs(r[root]-r[par]);
+        }
+        
+        for(int i=0;i<adj_lst[root].size();i++) {
+            if(adj_lst[root].get(i)==par) {
+                continue;
+            }
+            sum1+=solve(adj_lst[root].get(i),root,0);
+            sum2+=solve(adj_lst[root].get(i),root,1);
+        }
+        
+        long sum=Math.max(sum1,sum2);
+        
+        dp[root+1][state]=sum;
+        
+        return sum;
+        
+    }
+}
+",0
+93ee4612,da5cf40b,"import java.io.OutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.PrintWriter;
+import java.util.StringTokenizer;
+import java.io.IOException;
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.io.InputStream;
+
+/**
+ * Built using CHelper plug-in
+ * Actual solution is at the top
+ */
+public class Main {
+    public static void main(String[] args) {
+        InputStream inputStream = System.in;
+        OutputStream outputStream = System.out;
+        FastScanner in = new FastScanner(inputStream);
+        PrintWriter out = new PrintWriter(outputStream);
+        TaskC solver = new TaskC();
+        solver.solve(1, in, out);
+        out.close();
+    }
+
+    static class TaskC {
+        public void solve(int testNumber, FastScanner in, PrintWriter out) {
+            int numTests = in.nextInt();
+            for (int test = 0; test < numTests; test++) {
+                int n = in.nextInt();
+                char[] a = in.next().toCharArray();
+                char[] b = in.next().toCharArray();
+                int ka = 0;
+                int kb = 0;
+                int k11 = 0;
+                int k01 = 0;
+                for (int i = 0; i < n; i++) {
+                    if (a[i] == '1') {
+                        ++ka;
+                    }
+                    if (b[i] == '1') {
+                        ++kb;
+                    }
+                    if (a[i] == '1' && b[i] == '1') {
+                        ++k11;
+                    }
+                    if (a[i] == '0' && b[i] == '1') {
+                        ++k01;
+                    }
+                }
+                if (ka == 0) {
+                    out.println(kb == 0 ? 0 : -1);
+                    continue;
+                }
+                int ans = Integer.MAX_VALUE;
+                if (ka == kb) {
+                    ans = Math.min(ans, 2 * (ka - k11));
+                }
+                if (ka == n - kb + 1) {
+                    int cur = 0;
+                    if (k11 == 0) {
+                        cur = 1 + 2 * (kb - k01);
+                    } else {
+                        cur = 1 + 2 * (kb - k01 - 1);
+                    }
+                    ans = Math.min(ans, cur);
+                }
+
+                if (ans == Integer.MAX_VALUE) {
+                    ans = -1;
+                }
+                out.println(ans);
+            }
+        }
+
+    }
+
+    static class FastScanner {
+        private BufferedReader in;
+        private StringTokenizer st;
+
+        public FastScanner(InputStream stream) {
+            try {
+                in = new BufferedReader(new InputStreamReader(stream, ""UTF-8""));
+            } catch (Exception e) {
+                throw new AssertionError();
+            }
+        }
+
+        public String next() {
+            while (st == null || !st.hasMoreTokens()) {
+                try {
+                    String rl = in.readLine();
+                    if (rl == null) {
+                        return null;
+                    }
+                    st = new StringTokenizer(rl);
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+            }
+            return st.nextToken();
+        }
+
+        public int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+    }
+}
+
+","/*****  --->         :)    Vijender  Srivastava      (:       <---       *****/
+import java.util.*;
+import java.lang.*;
+import java.io.*;
+public class Main  
+{
+    static FastReader sc =new FastReader();
+    static PrintWriter out=new PrintWriter(System.out);
+    static long mod=(long)1e9+7;
+    /* start */
+   
+       public static void main(String [] args)
+    {
+        // int testcases = 1;
+        int testcases = i();
+        while(testcases-->0)
+        {
+            
+            solve();
+        }
+        out.flush();
+        out.close();
+    }
+    static void solve()
+    { 
+        int n = i();
+        char c[] = inputC();
+        char d[] = inputC();
+        int x01=0,x10=0,x00=0,x11=0;
+        for(int i=0;i<n;i++)
+        {
+            if(c[i]=='0'&&d[i]=='0')x00++;
+            if(c[i]=='0'&&d[i]=='1')x01++;
+            if(c[i]=='1'&&d[i]=='0')x10++;
+            if(c[i]=='1'&&d[i]=='1')x11++;
+        }
+
+        int ans = Integer.MAX_VALUE;
+        if(x01==0 && x10==0)
+        {
+            pl(0);
+            return ;
+        }
+        if(x11==x00+1)
+        {
+            ans = min(x11+x00,ans);
+        }
+      if(x01==x10)
+        {
+            ans = min(x01+x10,ans);
+        }
+        if(ans == Integer.MAX_VALUE){
+            ans = -1;
+        }
+        pl(ans);
+    }
+    
+    /* end */
+    static class FastReader 
+    { 
+        BufferedReader br; 
+        StringTokenizer st; 
+
+        public FastReader() 
+        { 
+            br = new BufferedReader(new
+                     InputStreamReader(System.in)); 
+        } 
+
+        String next() 
+        { 
+            while (st == null || !st.hasMoreElements()) 
+            { 
+                try
+                { 
+                    st = new StringTokenizer(br.readLine()); 
+                } 
+                catch (IOException  e) 
+                { 
+                    e.printStackTrace(); 
+                } 
+            } 
+            return st.nextToken(); 
+        } 
+
+        int nextInt() 
+        { 
+            return Integer.parseInt(next()); 
+        } 
+
+        long nextLong() 
+        { 
+            return Long.parseLong(next()); 
+        } 
+
+        double nextDouble() 
+        { 
+            return Double.parseDouble(next()); 
+        } 
+
+        String nextLine() 
+        { 
+            String str = """"; 
+            try
+            { 
+                str = br.readLine(); 
+            } 
+            catch (IOException e) 
+            { 
+                e.printStackTrace(); 
+            } 
+            return str; 
+        } 
+    } 
+
+    static void p(Object o)
+    {
+        out.print(o);
+    }
+    static void pl(Object o)
+    {
+        out.println(o);
+    }
+    static int i() {
+        return sc.nextInt();
+    }
+
+    static String s() {
+        return sc.next();
+    }
+
+    static long l() {
+        return sc.nextLong();
+    }
+
+    static char[] inputC()
+    {
+        String s = sc.nextLine();
+        return s.toCharArray();
+    }
+
+    static int[] input(int n) {
+        int A[]=new int[n];
+           for(int i=0;i<n;i++) {
+               A[i]=sc.nextInt();
+           }
+        return A;
+    }
+
+    static long[] inputL(int n) {
+        long A[]=new long[n];
+           for(int i=0;i<n;i++) {
+               A[i]=sc.nextLong();
+           }
+           return A;
+    }
+
+    static long[] putL(long a[]) {
+        long A[]=new long[a.length];
+           for(int i=0;i<a.length;i++) {
+               A[i]=a[i];
+           }
+           return A;
+    }
+
+    static String[] inputS(int n) {
+        String A[]=new String[n];
+           for(int i=0;i<n;i++) {
+               A[i]=sc.next();
+           }
+           return A;
+    }
+      
+    static int gcd(int a, int b) 
+     { 
+         if (a == 0) 
+             return b; 
+         return gcd(b % a, a); 
+     } 
+
+     static long gcd(long a, long b) 
+     { 
+         if (a == 0) 
+             return b; 
+         return gcd(b % a, a); 
+     } 
+
+     static int lcm(int a, int b)
+    {
+        return (a / gcd(a, b)) * b;
+    }
+    
+     static String reverse(String s) {
+        StringBuffer p=new StringBuffer(s);
+        p.reverse();
+        return p.toString();
+     }
+
+     static int min(int a,int b) {
+        return Math.min(a, b);
+    }
+    static int min(int a,int b,int c) {
+        return Math.min(a, Math.min(b, c));
+    }
+    static int min(int a,int b,int c,int d) {
+        return Math.min(a, Math.min(b, Math.min(c, d)));
+    }
+
+    static int max(int a,int b) {
+        return Math.max(a, b);
+    }
+    static int max(int a,int b,int c) {
+        return Math.max(a, Math.max(b, c));
+    }
+    static int max(int a,int b,int c,int d) {
+        return Math.max(a, Math.max(b, Math.max(c, d)));
+    }
+    static long min(long a,long b) {
+        return Math.min(a, b);
+    }
+    static long min(long a,long b,long c) {
+        return Math.min(a, Math.min(b, c));
+    }
+    static long min(long a,long b,long c,long d) {
+        return Math.min(a, Math.min(b, Math.min(c, d)));
+    }
+    static long max(long a,long b) {
+        return Math.max(a, b);
+    }
+    static long max(long a,long b,long c) {
+        return Math.max(a, Math.max(b, c));
+    }
+    static long max(long a,long b,long c,long d) {
+        return Math.max(a, Math.max(b, Math.max(c, d)));
+    }
+
+    static long sum(int A[]) {
+        long sum=0;
+        for(int i : A) {
+            sum+=i;
+        }
+        return sum;
+    }
+
+    static long sum(long A[]) {
+        long sum=0;
+        for(long i : A) {
+            sum+=i;
+        }
+        return sum;
+    }
+
+    static void print(int A[]) {
+        for(int i : A) {
+            System.out.print(i+"" "");
+        }
+        System.out.println();
+    }
+
+    static void print(long A[]) {
+        for(long i : A) {
+            System.out.print(i+"" "");
+        }
+        System.out.println();
+    }
+
+    static long mod(long x) {
+          return ((x%mod + mod)%mod);
+    }
+
+    static long power(long x, long y)
+    {
+
+	if(y==0)
+		return 1;
+	if(x==0)
+		return 0;
+    long res = 1;
+    while (y > 0) {
+
+        if (y % 2 == 1)
+            res = (res * x) ;
+
+        y = y >> 1; 
+        x = (x * x);
+    }
+
+    return res;
+    }
+
+    static boolean prime(int n) 
+	    { 
+	        if (n <= 1) 
+	            return false; 
+	        if (n <= 3) 
+	            return true; 
+	        if (n % 2 == 0 || n % 3 == 0) 
+	            return false; 
+	        double sq=Math.sqrt(n);
+	  
+	        for (int i = 5; i <= sq; i = i + 6) 
+	            if (n % i == 0 || n % (i + 2) == 0) 
+	                return false; 
+	        return true; 
+	    } 
+
+     static boolean prime(long n) 
+	    { 
+	        if (n <= 1) 
+	            return false; 
+	        if (n <= 3) 
+	            return true; 
+	        if (n % 2 == 0 || n % 3 == 0) 
+	            return false; 
+	        double sq=Math.sqrt(n);
+	  
+	        for (int i = 5; i <= sq; i = i + 6) 
+	            if (n % i == 0 || n % (i + 2) == 0) 
+	                return false; 
+	        return true; 
+	    } 
+
+        static long[] sort(long a[]) {
+            ArrayList<Long> arr = new ArrayList<>();
+            for(long i : a) {
+                arr.add(i);
+            }
+            Collections.sort(arr);
+            for(int i = 0; i < arr.size(); i++) {
+                a[i] = arr.get(i);
+            }
+            return a;
+        }
+    
+        static int[] sort(int a[])
+        {
+            ArrayList<Integer> arr = new ArrayList<>();
+            for(Integer i : a) {
+                arr.add(i);
+            }
+            Collections.sort(arr);
+            for(int i = 0; i < arr.size(); i++) {
+                a[i] = arr.get(i);
+            }
+            return a;
+        }
+        //pair class
+        private static class Pair implements Comparable<Pair> {
+            long first, second;
+            public Pair(long f, long s) {
+                first = f;
+                second = s;
+            }
+            @Override
+            public int compareTo(Pair p) {
+                if (first > p.first)
+                    return 1;
+                else if (first < p.first)
+                    return -1;
+                else {
+                    if (second > p.second)
+                        return 1;
+                    else if (second < p.second)
+                        return -1;
+                    else
+                        return 0;
+                }
+            }
+     
+        }
+}",0
+3a12e509,6de04ee2,"import java.io.*;
+import java.util.*;
+
+
+public class Practice
+{
+//	static final long mod=7420738134811L;
+	static int mod=1000000007;
+	static final int size=501;
+	static FastReader sc=new FastReader(System.in);
+//	static Reader sc=new Reader();
+	static  PrintWriter out=new PrintWriter(System.out);
+	static long[] factorialNumInverse;
+	static long[] naturalNumInverse;	
+	static int[] sp;
+	static long[] fact;
+	static ArrayList<Integer> pr;
+	public static void main(String[] args) throws IOException
+	{
+//		System.setIn(new FileInputStream(""input.txt""));
+//		System.setOut(new PrintStream(""output.txt""));
+//		factorial(mod);
+//		InverseofNumber(mod);
+//		InverseofFactorial(mod);
+//		make_seive();
+		int t=1;
+		t=sc.nextInt();
+		while(t-->0)
+			solve();
+		out.close();
+		out.flush();
+	}
+	static void solve() throws IOException
+	{
+		int n=sc.nextInt();
+		int arr[]=new int[n];
+		for(int i=0;i<n;i++)
+			arr[i]=sc.nextInt();
+		String s=sc.next();
+		ArrayList<Integer> blue=new ArrayList<Integer>();
+		ArrayList<Integer> red=new ArrayList<Integer>();
+		for(int i=0;i<n;i++)
+		{
+			if(s.charAt(i)=='B')
+				blue.add(arr[i]);
+			else
+				red.add(arr[i]);
+		}
+		Collections.sort(blue);
+		Collections.sort(red);
+		for(int i=0;i<blue.size();i++)
+		{
+			if(blue.get(i)<i+1)
+			{
+				out.println(""NO"");
+				return;
+			}
+		}
+		for(int i=0;i<red.size();i++)
+		{
+			if(red.get(i)>i+1+blue.size())
+			{
+				out.println(""NO"");
+				return;
+			}
+		}
+		out.println(""YES"");
+	}
+	static class Pair implements Cloneable, Comparable<Pair>
+	{
+		int x,y;
+		Pair(int a,int b)
+		{
+			this.x=a;
+			this.y=b;
+		}
+		@Override
+		public boolean equals(Object obj) 
+		{
+			if(obj instanceof  Pair)
+			{
+				Pair p=(Pair)obj;
+				return p.x==this.x && p.y==this.y;
+			}
+			return false;
+		}
+		@Override
+		public int hashCode() 
+		{
+			return Math.abs(x)+500*Math.abs(y);
+		}
+		@Override
+		public String toString() 
+		{
+			return ""(""+x+"" ""+y+"")"";
+		}
+		@Override
+		protected Pair clone() throws CloneNotSupportedException {
+			return new Pair(this.x,this.y);
+		}
+		@Override
+		public int compareTo(Pair a) 
+		{
+			int t= this.x-a.x;
+			if(t!=0)
+				return t;
+			else
+				return this.y-a.y;
+		}
+		public void swap()
+		{
+			this.y=this.y+this.x;
+			this.x=this.y-this.x;
+			this.y=this.y-this.x;			
+		}
+	}
+	static class Tuple implements Cloneable, Comparable<Tuple>
+	{
+		int x,y,z;
+		Tuple(int a,int b,int c)
+		{
+			this.x=a;
+			this.y=b;
+			this.z=c;
+		}
+		public boolean equals(Object obj) 
+		{
+			if(obj instanceof  Tuple)
+			{
+				Tuple p=(Tuple)obj;
+				return p.x==this.x && p.y==this.y && p.z==this.z;
+			}
+			return false;
+		}
+		@Override
+		public int hashCode() 
+		{
+			return (this.x+501*this.y);
+		}
+		@Override
+		public String toString() 
+		{
+			return ""(""+x+"",""+y+"",""+z+"")"";
+		}
+		@Override
+		protected Tuple clone() throws CloneNotSupportedException {
+			return new Tuple(this.x,this.y,this.z);
+		}
+		@Override
+		public int compareTo(Tuple a) 
+		{
+			int x=this.z-a.z;
+			if(x!=0)
+				return x;
+			int X= this.x-a.x;
+			if(X!=0)
+				return X;
+			return a.y-this.y;
+		}
+	}
+	static void arraySort(int arr[])
+	{
+		ArrayList<Integer> a=new ArrayList<Integer>();
+		for (int i = 0; i < arr.length; i++) {
+			a.add(arr[i]);
+		}
+		Collections.sort(a);
+		for (int i = 0; i < arr.length; i++) {
+			arr[i]=a.get(i);
+		}
+	}
+	static void arraySort(long arr[])
+	{
+		ArrayList<Long> a=new ArrayList<Long>();
+		for (int i = 0; i < arr.length; i++) {
+			a.add(arr[i]);
+		}
+		Collections.sort(a);
+		for (int i = 0; i < arr.length; i++) {
+			arr[i]=a.get(i);
+		}
+	}
+	static HashSet<Integer> primeFactors(int n)
+	{
+		HashSet<Integer> ans=new HashSet<Integer>();
+		if(n%2==0)
+		{
+			ans.add(2);
+			while((n&1)==0)
+				n=n>>1;
+		}
+		for(int i=3;i*i<=n;i+=2)
+		{
+			if(n%i==0)
+			{
+				ans.add(i);
+				while(n%i==0)
+					n=n/i;
+			}
+		}
+		if(n!=1)
+			ans.add(n);
+		return ans;
+	}
+	static void make_seive()
+	{
+		sp=new int[size];
+		pr=new ArrayList<Integer>();
+		for (int i=2; i<size; ++i) {
+		    if (sp[i] == 0) {
+		        sp[i] = i;
+		        pr.add(i);
+		    }
+		    for (int j=0; j<(int)pr.size() && pr.get(j)<=sp[i] && i*pr.get(j)<size; ++j)
+		        sp[i * pr.get(j)] = pr.get(j);
+		}
+	}
+	public static void InverseofNumber(int p)
+	{
+		naturalNumInverse=new long[size];
+	    naturalNumInverse[0] = naturalNumInverse[1] = 1;
+	    for(int i = 2; i < size; i++)
+	        naturalNumInverse[i] = naturalNumInverse[p % i] * (long)(p - p / i) % p;
+	}
+	// Function to precompute inverse of factorials
+	public static void InverseofFactorial(int p)
+	{
+		factorialNumInverse=new long[size];
+	    factorialNumInverse[0] = factorialNumInverse[1] = 1;
+	    // pre-compute inverse of natural numbers
+	    for(int i = 2; i < size; i++)
+	        factorialNumInverse[i] = (naturalNumInverse[i] * factorialNumInverse[i - 1]) % p;
+	}
+	// Function to calculate factorial of 1 to 200001
+	public static void factorial(int p)
+	{
+		fact=new long[size];
+	    fact[0] = 1;
+	    for(int i = 1; i < size; i++)
+	        fact[i] = (fact[i - 1] * (long)i) % p;
+	}
+	 
+	// Function to return nCr % p in O(1) time
+	public static long Binomial(int N, int R)
+	{
+		if(R<0)
+			return 1;
+	    // n C r = n!*inverse(r!)*inverse((n-r)!)
+	    long ans = ((fact[N] * factorialNumInverse[R]) % mod * factorialNumInverse[N - R]) % mod;
+	    return ans;
+	}
+	static int findXOR(int x)	//from 0 to x
+	{
+		if(x<0)
+			return 0;
+		if(x%4==0)
+			return x;
+		if(x%4==1)
+			return 1;
+		if(x%4==2)
+			return x+1;
+		return 0;
+	}
+	static boolean isPrime(long x)
+	{
+		if(x==1)
+			return false;
+		if(x<=3)
+			return true;
+		if(x%2==0 || x%3==0)
+			return false;
+		for(int i=5;i<=Math.sqrt(x);i+=2)
+			if(x%i==0)
+				return false;
+		return true;
+	}
+	static long gcd(long a,long b)
+	{
+		return (b==0)?a:gcd(b,a%b);
+	}
+	static int gcd(int a,int b)
+	{
+		return (b==0)?a:gcd(b,a%b);
+	}
+	static class Node
+	{
+		int vertex;
+		HashSet<Edge> adj;
+		int taxC,taxD;
+		Node(int ver)
+		{
+			vertex=ver;
+			taxD=0;
+			taxC=0;
+			adj=new HashSet<Edge>();
+		}
+		@Override
+		public String toString() 
+		{
+			return vertex+"" "";
+		}
+	}
+	static class Edge
+	{
+		Node to;
+		int cost;
+		Edge(Node t,int c)
+		{
+			this.to=t;
+			this.cost=c;
+		}
+		@Override
+		public String toString() {
+			return ""(""+to.vertex+"",""+cost+"") "";
+		}
+	}
+	static long power(long x, long y)
+	  {
+		if(x<=0)
+			return 1;
+	    long res = 1; 
+	    x = x % mod; 
+	    if (x == 0)
+	      return 0; 
+	    while (y > 0)
+	    {
+	    	if ((y & 1) != 0)
+	    		res = (res * x) % mod;
+	    	
+	    	y = y >> 1; // y = y/2
+	    	x = (x * x) % mod;
+	    }
+	    return res;
+	  }
+	static long binomialCoeff(long n, long k)
+    {
+		if(n<k)
+			return 0;
+        long res = 1;
+//        if(k>n)
+//        	return 0;
+        // Since C(n, k) = C(n, n-k)
+        if (k > n - k)
+            k = n - k;
+ 
+        // Calculate value of
+        // [n * (n-1) *---* (n-k+1)] / [k * (k-1) *----* 1]
+        for (long i = 0; i < k; ++i) {
+            res *= (n - i);
+            res /= (i + 1);
+        }
+ 
+        return res;
+    }
+	static class FastReader
+	{
+        byte[] buf = new byte[2048];
+        int index, total;
+        InputStream in;
+ 
+        FastReader(InputStream is) 
+        {
+            in = is;
+        }
+ 
+        int scan() throws IOException 
+        {
+            if (index >= total) {
+                index = 0;
+                total = in.read(buf);
+                if (total <= 0) {
+                    return -1;
+                }
+            }
+            return buf[index++];
+        }
+ 
+        String next() throws IOException 
+        {
+            int c;
+            for (c = scan(); c <= 32; c = scan());
+            StringBuilder sb = new StringBuilder();
+            for (; c > 32; c = scan()) {
+                sb.append((char) c);
+            }
+            return sb.toString();
+        }
+ 
+        int nextInt() throws IOException 
+        {
+            int c, val = 0;
+            for (c = scan(); c <= 32; c = scan());
+            boolean neg = c == '-';
+            if (c == '-' || c == '+') {
+                c = scan();
+            }
+            for (; c >= '0' && c <= '9'; c = scan()) {
+                val = (val << 3) + (val << 1) + (c & 15);
+            }
+            return neg ? -val : val;
+        }
+ 
+        long nextLong() throws IOException 
+        {
+            int c;
+            long val = 0;
+            for (c = scan(); c <= 32; c = scan());
+            boolean neg = c == '-';
+            if (c == '-' || c == '+') {
+                c = scan();
+            }
+            for (; c >= '0' && c <= '9'; c = scan()) {
+                val = (val << 3) + (val << 1) + (c & 15);
+            }
+            return neg ? -val : val;
+        }
+    }
+	static class Reader 
+	{
+        final private int BUFFER_SIZE = 1 << 16;
+        private DataInputStream din;
+        private byte[] buffer;
+        private int bufferPointer, bytesRead;
+ 
+        public Reader()
+        {
+            din = new DataInputStream(System.in);
+            buffer = new byte[BUFFER_SIZE];
+            bufferPointer = bytesRead = 0;
+        }
+ 
+        public Reader(String file_name) throws IOException
+        {
+            din = new DataInputStream(
+                new FileInputStream(file_name));
+            buffer = new byte[BUFFER_SIZE];
+            bufferPointer = bytesRead = 0;
+        }
+ 
+        public String readLine() throws IOException
+        {
+            byte[] buf = new byte[64]; // line length
+            int cnt = 0, c;
+            while ((c = read()) != -1) {
+                if (c == '\n') {
+                    if (cnt != 0) {
+                        break;
+                    }
+                    else {
+                        continue;
+                    }
+                }
+                buf[cnt++] = (byte)c;
+            }
+            return new String(buf, 0, cnt);
+        }
+ 
+        public int nextInt() throws IOException
+        {
+            int ret = 0;
+            byte c = read();
+            while (c <= ' ') {
+                c = read();
+            }
+            boolean neg = (c == '-');
+            if (neg)
+                c = read();
+            do {
+                ret = ret * 10 + c - '0';
+            } while ((c = read()) >= '0' && c <= '9');
+ 
+            if (neg)
+                return -ret;
+            return ret;
+        }
+ 
+        public long nextLong() throws IOException
+        {
+            long ret = 0;
+            byte c = read();
+            while (c <= ' ')
+                c = read();
+            boolean neg = (c == '-');
+            if (neg)
+                c = read();
+            do {
+                ret = ret * 10 + c - '0';
+            } while ((c = read()) >= '0' && c <= '9');
+            if (neg)
+                return -ret;
+            return ret;
+        }
+ 
+        public double nextDouble() throws IOException
+        {
+            double ret = 0, div = 1;
+            byte c = read();
+            while (c <= ' ')
+                c = read();
+            boolean neg = (c == '-');
+            if (neg)
+                c = read();
+ 
+            do {
+                ret = ret * 10 + c - '0';
+            } while ((c = read()) >= '0' && c <= '9');
+ 
+            if (c == '.') {
+                while ((c = read()) >= '0' && c <= '9') {
+                    ret += (c - '0') / (div *= 10);
+                }
+            }
+ 
+            if (neg)
+                return -ret;
+            return ret;
+        }
+ 
+        private void fillBuffer() throws IOException
+        {
+            bytesRead = din.read(buffer, bufferPointer = 0,
+                                 BUFFER_SIZE);
+            if (bytesRead == -1)
+                buffer[0] = -1;
+        }
+ 
+        private byte read() throws IOException
+        {
+            if (bufferPointer == bytesRead)
+                fillBuffer();
+            return buffer[bufferPointer++];
+        }
+ 
+        public void close() throws IOException
+        {
+            if (din == null)
+                return;
+            din.close();
+        }
+        public void printarray(int arr[])
+        {
+        	for (int i = 0; i < arr.length; i++)
+				System.out.print(arr[i]+"" "");
+        	System.out.println();
+        }
+    }
+}
+
+
+
+
+
+
+
+","import java.util.*;
+public class Solution{
+    public static void main(String[] args){
+    Scanner sc=new Scanner(System.in);
+    int t=sc.nextInt();
+
+    while(t-->0) {
+        int n=sc.nextInt();
+        int[] a=new int[n];
+        for(int i=0;i<n;i++)
+             a[i]=sc.nextInt();
+
+     char[] c=sc.next().toCharArray();
+
+        Vector<Integer> l=new Vector<>(), r=new Vector<>();
+        for(int i=0;i<n;i++)
+            (c[i] == 'B' ? l : r).add(a[i]);
+        Collections.sort(l);
+        Collections.sort(r,Collections.reverseOrder());
+
+        boolean ok = true;
+        for(int i=0;i<l.size();i++)
+            if (l.get(i) < i + 1)
+                ok = false;
+        for(int i=0;i<r.size();i++)
+            if (r.get(i) > n - i)
+                ok = false;
+
+         System.out.print((ok ? ""YES"" : ""NO"")+'\n');
+    }
+    }
+}",0
+0f3a2acf,dba80ad4,"import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.*;
+
+public class Practice {
+    static int[][] vals;
+    static ArrayList<ArrayList<Integer>> adjList;
+    static long[][] ans;
+    public static void main(String[] args) throws IOException {
+        BufferedReader bu=new BufferedReader(new InputStreamReader(System.in));
+        int t = Integer.parseInt(bu.readLine());
+        while (t-- > 0) {
+            Integer n = Integer.parseInt(bu.readLine());
+            vals = new int[2][n];
+            adjList = new ArrayList<>();
+            for(int i=0;i<n;i++){
+                String st[]=bu.readLine().split("" "");
+                vals[0][i] = Integer.parseInt(st[0]);
+                vals[1][i] = Integer.parseInt(st[1]);
+                adjList.add(new ArrayList<>());
+            }
+            for(int i=0;i<n-1;i++){
+                String st[]=bu.readLine().split("" "");
+                int source = Integer.parseInt(st[0]);; int dest = Integer.parseInt(st[1]);;
+                adjList.get(source-1).add(dest-1);
+                adjList.get(dest-1).add(source-1);
+            }
+            ans = new long[2][n];
+            DFS(0, adjList, -1, ans, vals);
+            System.out.println(Math.max(ans[0][0], ans[1][0]));
+        }
+    }
+
+    private static void DFS(Integer current, ArrayList<ArrayList<Integer>> adjList, Integer prev, long[][] ans, int[][] vals) {
+        ans[0][current] = 0L; ans[1][current] = 0L;
+        for(Integer node: adjList.get(current)){
+            if(node.equals(prev)) continue;
+            DFS(node, adjList, current, ans, vals);
+            ans[0][current] += Math.max(ans[0][node] + Math.abs(vals[0][current] - vals[0][node]), ans[1][node] + Math.abs(vals[0][current] - vals[1][node]));
+            ans[1][current] += Math.max(ans[0][node] + Math.abs(vals[1][current] - vals[0][node]) , ans[1][node] + Math.abs(vals[1][current] - vals[1][node]));
+        }
+    }
+}
+
+","import java.util.*;
+import static java.lang.Math.*;
+import java.io.*;
+public class S {
+       
+      public static void main(String args[])throws IOException{
+              BufferedReader br = new  BufferedReader(new InputStreamReader(System.in));
+              int test = Integer.parseInt(br.readLine());
+              while(test > 0){
+                    test--;
+                        int n = Integer.parseInt(br.readLine());
+                        int a[][] = new int[n][2];
+                        for(int i = 0; i < n; i++){
+                              StringTokenizer st = new StringTokenizer(br.readLine());
+                              a[i][0] = Integer.parseInt(st.nextToken());
+                              a[i][1] = Integer.parseInt(st.nextToken());
+                        }
+                        Map<Integer, List<Integer>> g = new HashMap<Integer, List<Integer>>();
+                        for(int i = 0; i < n-1; i++){
+                              StringTokenizer st = new StringTokenizer(br.readLine());
+                              int u = Integer.parseInt(st.nextToken());
+                              int v = Integer.parseInt(st.nextToken());
+                              u--;
+                              v--;
+                              if(!g.containsKey(u))g.put(u, new ArrayList<Integer>());
+                              g.get(u).add(v);
+                              if(!g.containsKey(v))g.put(v, new ArrayList<Integer>());
+                              g.get(v).add(u);
+                        }
+                        solve(n, a, g);
+                    //System.out.println(s + "" "" + tar);
+                    //StringTokenizer st = new StringTokenizer(br.readLine());
+                    //int n = Integer.parseInt(st.nextToken());
+                    //int l = Integer.parseInt(st.nextToken());
+                    //st = new StringTokenizer(br.readLine());
+                    //int a[] = new int[n];
+                    //for(int i = 0; i < n; i++){
+                  //      a[i] = Integer.parseInt(st.nextToken());
+                    //}
+             }
+      }
+      
+      public static void solve(int n, int a[][], Map<Integer, List<Integer>> g){
+            Map<Integer, long[]> dp = new HashMap<Integer, long[]>();
+            boolean visited[] =  new boolean[n];
+            long ans = 0;
+            visited[0] = true;
+            long part[] = dfs(a, g, 0, visited, dp);
+            ans = Math.max(part[0], part[1]);
+            System.out.println(ans);
+      }
+      
+      public static long[] dfs(int a[][], Map<Integer, List<Integer>> g, int node, boolean visited[], Map<Integer, long[]> dp){
+            if(dp.containsKey(node)){
+                  return dp.get(node);
+            }
+            List<Integer> children = g.get(node);
+            if(children == null)return new long[]{0, 0};
+            long ansL = 0;
+            long ansR = 0;
+            for(int child : children){
+                  if(!visited[child]){
+                        visited[child] = true;
+                        long sol[] = dfs(a, g, child, visited, dp);
+                        ansL += Math.max(sol[0] + Math.abs(a[node][0] - a[child][0]), sol[1] + Math.abs(a[node][0] - a[child][1]));
+                        ansR += Math.max(sol[0] + Math.abs(a[node][1] - a[child][0]), sol[1] + Math.abs(a[node][1] - a[child][1]));
+                  }
+            }
+            long ans[] = new long[]{ansL, ansR};
+            dp.put(node, ans);
+            return ans;
+            
+      }
+      
+      public static int gcd(int a, int b){
+            if(b == 0)return a;
+            return gcd(b, a%b);
+      }
+}",0
+24afd00e,424c930b,"/*
+    JAI MATA DI
+ */
+
+import java.util.*;
+import java.io.*;
+import java.math.BigInteger;
+import java.sql.Array;
+public class CP {
+	  static class FR{
+			BufferedReader br;
+			StringTokenizer st;
+			public FR() {
+				br = new BufferedReader(new InputStreamReader(System.in));
+			}
+			String next() 
+		    { 
+		        while (st == null || !st.hasMoreElements()) 
+		        { 
+		            try
+		            { 
+		                st = new StringTokenizer(br.readLine()); 
+		            } 
+		            catch (IOException  e) 
+		            { 
+		                e.printStackTrace(); 
+		            } 
+		        } 
+		        return st.nextToken(); 
+		    } 
+
+		    int nextInt() 
+		    { 
+		        return Integer.parseInt(next()); 
+		    } 
+
+		    long nextLong() 
+		    { 
+		        return Long.parseLong(next()); 
+		    } 
+
+		    double nextDouble() 
+		    { 
+		        return Double.parseDouble(next()); 
+		    } 
+
+		    String nextLine() 
+		    { 
+		        String str = """"; 
+		        try
+		        { 
+		            str = br.readLine(); 
+		        } 
+		        catch (IOException e) 
+		        { 
+		            e.printStackTrace(); 
+		        } 
+		        return str; 
+		    } 
+		}
+	 static int mod  = 1000000007;
+	 static int gcd(int a, int b)
+	  {      
+	     if (b == 0)
+	        return a;
+	     return gcd(b, a % b); 
+	  }
+	 static long gcd(long a, long b)
+	  {      
+	     if (b == 0)
+	        return a;
+	     return gcd(b, a % b); 
+	  }
+	 static boolean[] prime(int num) {
+			boolean[] bool = new boolean[num];
+		     
+		      for (int i = 0; i< bool.length; i++) {
+		         bool[i] = true;
+		      }
+		      for (int i = 2; i< Math.sqrt(num); i++) {
+		         if(bool[i] == true) {
+		            for(int j = (i*i); j<num; j = j+i) {
+		               bool[j] = false;
+		            }
+		         }
+		      }
+		      if(num >= 0) {
+		    	  bool[0] = false;
+		    	  bool[1] = false;
+		      }
+		      
+		      return bool;
+		}
+	
+	 
+
+/* ***************************************************************************************************************************************************/	 
+	 static FR sc = new FR();
+	 static StringBuilder sb = new StringBuilder();
+	 public static void main(String args[]) {
+		 int tc = sc.nextInt();
+	
+		 while(tc-- > 0) {
+			 TEST_CASE();
+		 }
+			System.out.println(sb);
+		 }		
+
+		static void TEST_CASE() {
+		int n = sc.nextInt();
+		 lr = new long[n][2];
+		for(int  i =0 ; i < n ; i ++) {
+			lr[i][0] = sc.nextLong();
+			lr[i][1] = sc.nextLong();
+		}
+		 adj = new ArrayList<ArrayList<Integer>>();
+		for(int i = 0 ; i <n ; i++) adj.add(new ArrayList<Integer>());
+		
+		for(int i = 0 ; i<n-1 ; i++) {
+			int u = sc.nextInt()-1 , v = sc.nextInt()-1;
+			adj.get(u).add(v);
+			adj.get(v).add(u);
+		}
+		min = new long[n];
+		max = new long[n];
+		dfs(0,-1);
+		sb.append(Math.max(min[0], max[0])).append(""\n"");
+		
+		}
+		static long[] min , max , lr[];
+		static ArrayList<ArrayList<Integer>> adj;
+		static void dfs(int u , int p  ) {
+			
+			for(int child:adj.get(u)) {
+				if(child == p) continue;
+				dfs(child , u);
+			}
+			long left = lr[u][0] , right = lr[u][1];
+			
+			long ansl = 0 , ansr = 0;
+			for(int child:adj.get(u)) {
+				if(child == p) continue;
+				long leftc = lr[child][0] , rightc = lr[child][1];
+				ansl += Math.max( min[child] + Math.abs(left - leftc)  ,
+						max[child] +Math.abs(left - rightc)      );
+			}
+			for(int child:adj.get(u)) {
+				if(child == p) continue;
+				long leftc = lr[child][0] , rightc = lr[child][1];
+				ansr += Math.max( min[child] + Math.abs(right - leftc)  ,
+						max[child] +Math.abs(right - rightc)      );
+			}
+			min[u] = ansl;
+			max[u] = ansr;
+			
+		}
+		
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+","import java.io.*;
+import java.util.*;
+
+
+public class Solution{
+    public static void main(String[] args) {
+        InputStream inputStream = System.in;
+        OutputStream outputStream = System.out;
+        InputReader in = new InputReader(inputStream);
+        PrintWriter out = new PrintWriter(outputStream);
+        Task solver = new Task();
+        solver.solve(in, out);
+        out.close();
+    }
+    // main solver
+    static class Task{
+
+        double eps= 0.00000001;
+        static final int MAXN = 10000001;
+
+        // stores smallest prime factor for every number
+        static int spf[] = new int[MAXN];
+
+        Map<Integer,Set<Integer>> dp= new HashMap<>();
+
+        // Calculating SPF (Smallest Prime Factor) for every
+        // number till MAXN.
+        // Time Complexity : O(nloglogn)
+        public void sieve()
+        {
+            spf[1] = 1;
+            for (int i=2; i<MAXN; i++)
+
+                // marking smallest prime factor for every
+                // number to be itself.
+                spf[i] = i;
+
+            // separately marking spf for every even
+            // number as 2
+            for (int i=4; i<MAXN; i+=2)
+                spf[i] = 2;
+
+            for (int i=3; i*i<MAXN; i++)
+            {
+                // checking if i is prime
+                if (spf[i] == i)
+                {
+                    // marking SPF for all numbers divisible by i
+                    for (int j=i*i; j<MAXN; j+=i)
+
+                        // marking spf[j] if it is not
+                        // previously marked
+                        if (spf[j]==j)
+                            spf[j] = i;
+                }
+            }
+        }
+
+        // A O(log n) function returning primefactorization
+        // by dividing by smallest prime factor at every step
+        public Set<Integer> getFactorization(int x)
+        {
+            if(dp.containsKey(x)) return dp.get(x);
+            Set<Integer> ret = new HashSet<>();
+            while (x != 1)
+            {
+                if(spf[x]!=2) ret.add(spf[x]);
+                x = x / spf[x];
+            }
+            dp.put(x,ret);
+            return ret;
+        }
+        // function to find first index >= x
+        public int lowerIndex(List<Integer> arr, int n, int x)
+        {
+            int l = 0, h = n - 1;
+            while (l <= h)
+            {
+                int mid = (l + h) / 2;
+                if (arr.get(mid) >= x)
+                    h = mid - 1;
+                else
+                    l = mid + 1;
+            }
+            return l;
+        }
+
+        // function to find last index <= y
+        public int upperIndex(List<Integer> arr, int n, int y)
+        {
+            int l = 0, h = n - 1;
+            while (l <= h)
+            {
+                int mid = (l + h) / 2;
+                if (arr.get(mid) <= y)
+                    l = mid + 1;
+                else
+                    h = mid - 1;
+            }
+            return h;
+        }
+
+        // function to count elements within given range
+        public int countInRange(List<Integer> arr, int n, int x, int y)
+        {
+            // initialize result
+            int count = 0;
+            count = upperIndex(arr, n, y) -
+                    lowerIndex(arr, n, x) + 1;
+            return count;
+        }
+        
+        long[] dpl, dpr;
+        List<Integer>[] adj;
+        int[] l,r;
+        public void solve(InputReader in, PrintWriter out) {
+            int t= in.nextInt();
+            while(t-->0){
+                int n= in.nextInt();
+                l= new int[n];
+                r= new int[n];
+                adj= new List[n];
+                for(int i=0;i<n;i++){
+                    l[i]= in.nextInt();
+                    r[i]= in.nextInt();
+                }
+                for(int i=0;i<n;i++) adj[i]= new ArrayList<>();
+                for(int i=0;i<n-1;i++){
+                    int u= in.nextInt()-1, v= in.nextInt()-1;
+                    adj[u].add(v); adj[v].add(u);
+                }
+                dpl= new long[n]; dpr= new long[n];
+                dfs(0,-1);
+
+                out.println(Math.max(dpl[0],dpr[0]));
+                
+            }
+        }
+
+        public void dfs(int u, int p){
+            long suml=0, sumr=0;
+            for(int v: adj[u] ){
+                if(v==p) continue;
+                dfs(v,u);
+                suml+= Math.max((long)Math.abs((long)l[u]-(long)l[v])+dpl[v], (long)Math.abs((long)l[u]-(long)r[v])+dpr[v]);
+                sumr+= Math.max((long)Math.abs((long)r[u]-(long)l[v])+dpl[v],(long) Math.abs((long)r[u]-(long)r[v])+dpr[v]);
+            }
+            dpl[u]= suml; dpr[u]= sumr;
+        }
+
+        // public static class compareL implements Comparator<Tuple>{
+        //     @Override
+        //     public int compare(Tuple t1, Tuple t2) {
+        //         return t2.l - t1.l;
+        //     }
+        // }
+        
+        public int _gcd(int a,  int  b)
+        {
+
+            if(b == 0) {
+                return a;
+            }
+            else {
+                return _gcd(b, a % b);
+            }
+        }
+
+    }
+
+    // static class Data{
+    //     List<Integer> arr;
+    //     BigInteger prod=new BigInteger(-1);
+    //     public Data(List<Integer> arr, BigInteger prod) {
+    //         this.arr= arr;
+    //         this.prod= prod;
+    //     }
+    // }
+
+    static class Tuple implements Comparable<Tuple>{
+        int x, y, z;
+        public Tuple(int x, int y, int z){
+            this.x= x;
+            this.y= y;
+            this.z=z;
+        }
+        @Override
+        public int compareTo(Tuple o){
+            return this.x-o.x;
+        }
+    }
+
+    static class Pair implements Comparable<Pair>{
+        public int x;
+        public int y;
+        public Pair(int x, int y){
+            this.x= x;
+            this.y= y;
+        }
+
+        @Override
+        public int compareTo(Pair o) {
+            return this.x-o.x;
+        }
+    }
+    // fast input reader class;
+    static class InputReader {
+        BufferedReader br;
+        StringTokenizer st;
+
+        public InputReader(InputStream stream) {
+            br = new BufferedReader(new InputStreamReader(stream));
+        }
+
+        public String nextToken() {
+            while (st == null || !st.hasMoreTokens()) {
+                String line = null;
+                try {
+                    line = br.readLine();
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+                if (line == null) {
+                    return null;
+                }
+                st = new StringTokenizer(line);
+            }
+            return st.nextToken();
+        }
+
+        public int nextInt() {
+            return Integer.parseInt(nextToken());
+        }
+        public double nextDouble(){
+            return Double.parseDouble(nextToken());
+        }
+        public long nextLong(){
+            return Long.parseLong(nextToken());
+        }
+    }
+}",0
+7011024d,e6b7a899,"import java.util.*;
+
+public class D {
+
+    public static void main(String[] args) {
+        Scanner scanner = new Scanner(System.in);
+        int n = scanner.nextInt();
+        ArrayList<Integer> occupied = new ArrayList<>();
+        ArrayList<Integer> vacant = new ArrayList<>();
+        for (int i = 0; i < n; i++) {
+            int x = scanner.nextInt();
+            if (x == 1)
+                occupied.add(i);
+            else
+                vacant.add(i);
+        }
+
+        Solution Solution = new Solution(occupied, vacant);
+
+//        System.out.println(Solution.tabulation());
+        System.out.println(Solution.memoization());
+    }
+}
+
+class Solution {
+
+    ArrayList<Integer> occupied, vacant;
+    int x, y;
+
+    public Solution(ArrayList<Integer> occupied, ArrayList<Integer> vacant) {
+        this.occupied = occupied;
+        this.vacant = vacant;
+        x = occupied.size(); y = vacant.size();
+    }
+
+    int tabulation() {
+        return tabulation(x, y);
+    }
+
+    int tabulation(int x, int y) {
+        int[][] dp = new int[x+1][y+1];
+        for (int i = 0; i <= x; i++) {
+            Arrays.fill(dp[i], Integer.MAX_VALUE/2);
+        }
+        for (int i = 0; i <= x; i++) {
+            dp[i][0] = 0;
+        }
+        for (int i = 0; i <= y; i++) {
+            dp[0][i] = 0;
+        }
+        
+        for (int i = 1; i <= x; i++) {
+            for (int j = 1; j <= y; j++) {
+                if(i == j) {
+                    dp[i][j] = dp[i-1][j-1] + Math.abs(occupied.get(i-1) - vacant.get(j-1));
+                }
+                else {
+                    dp[i][j] = Math.min(dp[i][j-1], dp[i-1][j-1] + Math.abs(occupied.get(i-1) - vacant.get(j-1)));
+                }
+            }
+        }
+        return dp[x][y];
+    }
+
+    int memoization() {
+        int[][] dp = new int[x][y];
+        for (int i = 0; i < x; i++) {
+            Arrays.fill(dp[i], -1);
+        }
+        return memoization(dp, x-1, y-1);
+    }
+
+    int memoization(int[][] dp, int n, int m) {
+        if(n < 0) {
+            return 0;
+        }
+        if(m < n) {
+            return Integer.MAX_VALUE;
+        }
+        if(dp[n][m] != -1) {
+            return dp[n][m];
+        }
+        int first = memoization(dp, n, m-1);
+        int second = memoization(dp, n-1, m-1) + Math.abs(occupied.get(n) - vacant.get(m));
+        dp[n][m] = Math.min(first, second);
+        return dp[n][m];
+    }
+}","import java.io.IOException;
+import java.io.InputStream;
+import java.io.PrintWriter;
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+import java.util.*;
+
+public class Main {
+	static final long MOD=1000000007;
+	static final long MOD1=998244353;
+	static long ans=0;
+	//static ArrayList<Integer> ans=new ArrayList<>();
+	public static void main(String[] args){
+		PrintWriter out = new PrintWriter(System.out);
+		InputReader sc=new InputReader(System.in);
+		int N = sc.nextInt();
+		int[] A = sc.nextIntArray(N);
+		ArrayList<Integer> a1 = new ArrayList<Integer>();
+		ArrayList<Integer> a2 = new ArrayList<Integer>();
+		for (int i = 0; i < A.length; i++) {
+			if (A[i]==0) {
+				a1.add(i);
+			}else {
+				a2.add(i);
+			}
+		}
+		int[][] dp = new int[a1.size()+1][a2.size()+1];
+		for (int i = 0; i < dp.length; i++) {
+			Arrays.fill(dp[i], Integer.MAX_VALUE/2);
+		}
+		dp[0][0] = 0;
+		for (int i = 1; i <= a1.size() ; i++) {
+			int pos1 = a1.get(i-1);
+			for (int j = 0; j <= a2.size(); j++) {
+				dp[i][j] = dp[i-1][j];
+				if (j-1>=0) {
+					int pos2 = a2.get(j-1);
+					dp[i][j] = Math.min(dp[i][j], dp[i-1][j-1] + Math.abs(pos1-pos2));
+				}
+			}
+		}
+		System.out.println(dp[a1.size()][a2.size()]);
+	}
+	static class InputReader { 
+		private InputStream in;
+		private byte[] buffer = new byte[1024];
+		private int curbuf;
+		private int lenbuf;
+		public InputReader(InputStream in) {
+			this.in = in;
+			this.curbuf = this.lenbuf = 0;
+		}
+		public boolean hasNextByte() {
+			if (curbuf >= lenbuf) {
+				curbuf = 0;
+				try {
+					lenbuf = in.read(buffer);
+				} catch (IOException e) {
+					throw new InputMismatchException();
+				}
+				if (lenbuf <= 0)
+					return false;
+			}
+			return true;
+		}
+ 
+		private int readByte() {
+			if (hasNextByte())
+				return buffer[curbuf++];
+			else
+				return -1;
+		}
+ 
+		private boolean isSpaceChar(int c) {
+			return !(c >= 33 && c <= 126);
+		}
+ 
+		private void skip() {
+			while (hasNextByte() && isSpaceChar(buffer[curbuf]))
+				curbuf++;
+		}
+ 
+		public boolean hasNext() {
+			skip();
+			return hasNextByte();
+		}
+ 
+		public String next() {
+			if (!hasNext())
+				throw new NoSuchElementException();
+			StringBuilder sb = new StringBuilder();
+			int b = readByte();
+			while (!isSpaceChar(b)) {
+				sb.appendCodePoint(b);
+				b = readByte();
+			}
+			return sb.toString();
+		}
+ 
+		public int nextInt() {
+			if (!hasNext())
+				throw new NoSuchElementException();
+			int c = readByte();
+			while (isSpaceChar(c))
+				c = readByte();
+			boolean minus = false;
+			if (c == '-') {
+				minus = true;
+				c = readByte();
+			}
+			int res = 0;
+			do {
+				if (c < '0' || c > '9')
+					throw new InputMismatchException();
+				res = res * 10 + c - '0';
+				c = readByte();
+			} while (!isSpaceChar(c));
+			return (minus) ? -res : res;
+		}
+ 
+		public long nextLong() {
+			if (!hasNext())
+				throw new NoSuchElementException();
+			int c = readByte();
+			while (isSpaceChar(c))
+				c = readByte();
+			boolean minus = false;
+			if (c == '-') {
+				minus = true;
+				c = readByte();
+			}
+			long res = 0;
+			do {
+				if (c < '0' || c > '9')
+					throw new InputMismatchException();
+				res = res * 10 + c - '0';
+				c = readByte();
+			} while (!isSpaceChar(c));
+			return (minus) ? -res : res;
+		}
+ 
+		public double nextDouble() {
+			return Double.parseDouble(next());
+		}
+ 
+		public int[] nextIntArray(int n) {
+			int[] a = new int[n];
+			for (int i = 0; i < n; i++)
+				a[i] = nextInt();
+			return a;
+		}
+		public double[] nextDoubleArray(int n) {
+			double[] a = new double[n];
+			for (int i = 0; i < n; i++)
+				a[i] = nextDouble();
+			return a;
+		}
+		public long[] nextLongArray(int n) {
+			long[] a = new long[n];
+			for (int i = 0; i < n; i++)
+				a[i] = nextLong();
+			return a;
+		}
+ 
+		public char[][] nextCharMap(int n, int m) {
+			char[][] map = new char[n][m];
+			for (int i = 0; i < n; i++)
+				map[i] = next().toCharArray();
+			return map;
+		}
+	}
+}
+",0
+d9199dfd,ff1fc018,"import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Scanner;
+
+public class Simple{  
+    public static void main(String args[]){  
+        //System.out.println(""Hello Java"");
+        Scanner s = new Scanner(System.in);
+        int t = s.nextInt();
+        while (t>0){
+            
+            int n = s.nextInt();
+            int arr[] = new int[n];
+
+            for(int i=0;i<n;i++){
+                arr[i] = s.nextInt();
+            }
+            String str = s.next();
+
+            //Arrays.sort(arr);
+            ArrayList<Integer> blue = new ArrayList<>();
+            ArrayList<Integer> red = new ArrayList<>();
+            for(int i=0;i<n;i++){
+                if(str.charAt(i)=='R'){
+                    red.add(arr[i]);
+                }
+                else{
+                    blue.add(arr[i]);
+                }
+            }
+            Collections.sort(red);
+            Collections.sort(blue);
+            
+            int start =1;
+
+            boolean bool =true;
+            for(int i=0;i<blue.size();i++){
+                if(blue.get(i)<start){
+                    bool = false;
+                    break;
+                }
+
+                start++;
+            }
+            if(!bool){
+                System.out.println(""NO"");
+            }
+            else{
+                for(int i=0;i<red.size();i++){
+                    if(red.get(i)>start){
+                        bool = false;
+                        break;
+                    }
+                    start++;
+                }
+                if(bool){
+                    System.out.println(""YES"");
+                }
+                else{
+                    System.out.println(""NO"");
+                }
+            }
+            
+            
+
+
+            t--;
+        }
+        s.close();  
+    }
+    
+}  
+","import java.util.*;
+
+public class mentor1 {
+    public static boolean solve(int n, String color, int[] arr){
+        List<Integer> Barr = new ArrayList<Integer>();
+        List<Integer> Rarr = new ArrayList<Integer>();
+        for (int i = 0; i < n; i++) {
+            if(color.charAt(i) == 'B')Barr.add(arr[i]);
+            else Rarr.add(arr[i]);
+        }
+        Barr.sort(Comparator.naturalOrder());
+        Rarr.sort(Comparator.reverseOrder());
+        for (int i = 0; i < Barr.size(); i++) {
+            if(Barr.get(i)< i + 1)return false;
+        }
+        for (int i = 0; i < Rarr.size(); i++) {
+            int expect = n-i;
+            if(Rarr.get(i) > expect)return false;
+        }
+        return true;
+    }
+    public static void main(String[] args) {
+        Scanner input = new Scanner(System.in);
+        int n = input.nextInt();
+        for (int i = 0; i < n; i++) {
+            int m = input.nextInt();
+            int[] arr = new int[m];
+            for(int j = 0;j<m; j++)arr[j] = input.nextInt();
+            String color = input.next();
+            if(solve(m,color,arr)) System.out.println(""YES"");
+            else System.out.println(""NO"");
+        }
+    }
+}
+",0
+3c667d4f,be3b1289,"import java.util.*;
+public class j
+{
+  public static void main(String args[])
+  {
+    Scanner in=new Scanner(System.in);
+    int n=in.nextInt();
+    while(n-->0)
+    {
+      int len=in.nextInt();
+      int t=in.nextInt();
+      int pos[]=new int[t];
+      int temp[]=new int[t];
+      for(int i=0;i<t;i++)
+      pos[i]=in.nextInt();
+      for(int i=0;i<t;i++)
+      temp[i]=in.nextInt();
+      long range[]=new long[len];
+      Arrays.fill(range,Long.MAX_VALUE-10000);
+      for(int i=0;i<t;i++)
+      range[pos[i]-1]=temp[i];
+      for(int i=1;i<len;i++)
+      {
+        range[i]=Math.min(range[i],1+range[i-1]);
+      }
+      for(int i=len-2;i>=0;i--)
+      {
+      range[i]=Math.min(range[i+1]+1,range[i]);
+      }
+      for(int i=0;i<len;i++)
+      {
+        System.out.print(range[i]+"" "");
+      }System.out.println();
+    }
+  }
+}
+","import java.util.*;
+import java.lang.*;
+import java.io.*;
+
+
+public class cf {
+    static PrintWriter out;
+    static int MOD = 1000000007;
+    static FastReader scan;
+
+    /*-------- I/O using short named function ---------*/
+    public static String ns() {
+        return scan.next();
+    }
+
+    public static int ni() {
+        return scan.nextInt();
+    }
+
+    public static long nl() {
+        return scan.nextLong();
+    }
+
+    public static double nd() {
+        return scan.nextDouble();
+    }
+
+    public static String nln() {
+        return scan.nextLine();
+    }
+
+    public static void p(Object o) {
+        out.print(o);
+    }
+
+    public static void ps(Object o) {
+        out.print(o + "" "");
+    }
+
+    public static void pn(Object o) {
+        out.println(o);
+    }
+
+    /*-------- for output of an array ---------------------*/
+    static void iPA(int arr[]) {
+        StringBuilder output = new StringBuilder();
+        for (int i = 0; i < arr.length; i++) output.append(arr[i] + "" "");
+        out.println(output);
+    }
+
+    static void lPA(long arr[]) {
+        StringBuilder output = new StringBuilder();
+        for (int i = 0; i < arr.length; i++) output.append(arr[i] + "" "");
+        out.println(output);
+    }
+
+    static void sPA(String arr[]) {
+        StringBuilder output = new StringBuilder();
+        for (int i = 0; i < arr.length; i++) output.append(arr[i] + "" "");
+        out.println(output);
+    }
+
+    static void dPA(double arr[]) {
+        StringBuilder output = new StringBuilder();
+        for (int i = 0; i < arr.length; i++) output.append(arr[i] + "" "");
+        out.println(output);
+    }
+
+    /*-------------- for input in an array ---------------------*/
+    static void iIA(int arr[]) {
+        for (int i = 0; i < arr.length; i++) arr[i] = ni();
+    }
+
+    static void lIA(long arr[]) {
+        for (int i = 0; i < arr.length; i++) arr[i] = nl();
+    }
+
+    static void sIA(String arr[]) {
+        for (int i = 0; i < arr.length; i++) arr[i] = ns();
+    }
+
+    static void dIA(double arr[]) {
+        for (int i = 0; i < arr.length; i++) arr[i] = nd();
+    }
+
+    /*------------ for taking input faster ----------------*/
+    static class FastReader {
+        BufferedReader br;
+        StringTokenizer st;
+
+        public FastReader() {
+            br = new BufferedReader(new InputStreamReader(System.in));
+        }
+
+        String next() {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+
+        String nextLine() {
+            String str = """";
+            try {
+                str = br.readLine();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+        }
+    }
+
+    public static ArrayList<Integer> sieveOfEratosthenes(int n) {
+        // Create a boolean array
+        // ""prime[0..n]"" and
+        // initialize all entries
+        // it as true. A value in
+        // prime[i] will finally be
+        // false if i is Not a
+        // prime, else true.
+        boolean prime[] = new boolean[n + 1];
+        for (int i = 0; i <= n; i++)
+            prime[i] = true;
+
+        for (int p = 2; p * p <= n; p++) {
+            // If prime[p] is not changed, then it is a
+            // prime
+            if (prime[p] == true) {
+                // Update all multiples of p
+                for (int i = p * p; i <= n; i += p)
+                    prime[i] = false;
+            }
+        }
+        ArrayList<Integer> arr = new ArrayList<>();
+        // Print all prime numbers
+        for (int i = 2; i <= n; i++) {
+            if (prime[i] == true)
+                arr.add(i);
+        }
+        return arr;
+    }
+
+    // Method to check if x is power of 2
+    static boolean isPowerOfTwo(int x) {
+        return x != 0 && ((x & (x - 1)) == 0);
+    }
+
+    //Method to return lcm of two numbers
+    static int gcd(int a, int b) {
+        return a == 0 ? b : gcd(b % a, a);
+    }
+
+    //Method to count digit of a number
+    static int countDigit(long n) {
+        String sex = Long.toString(n);
+        return sex.length();
+    }
+
+    static void reverse(int a[]) {
+        int i, k, t;
+        int n = a.length;
+        for (i = 0; i < n / 2; i++) {
+            t = a[i];
+            a[i] = a[n - i - 1];
+            a[n - i - 1] = t;
+        }
+    }
+
+    static final Random random = new Random();
+
+    //Method for sorting
+    static void ruffleSort(int[] arr) {
+        int n = arr.length;
+        for (int i = 0; i < n; i++) {
+            int j = random.nextInt(n);
+            int temp = arr[j];
+            arr[j] = arr[i];
+            arr[i] = temp;
+        }
+        Arrays.sort(arr);
+    }
+
+    static void sortadv(long[] a) {
+        ArrayList<Long> l = new ArrayList<>();
+        for (long value : a) {
+            l.add(value);
+        }
+        Collections.sort(l);
+        for (int i = 0; i < l.size(); i++)
+            a[i] = l.get(i);
+    }
+
+    //Method for checking if a number is prime or not
+    static boolean isPrime(int n) {
+        if (n <= 1) return false;
+        if (n <= 3) return true;
+        if (n % 2 == 0 || n % 3 == 0) return false;
+        for (int i = 5; i * i <= n; i = i + 6)
+            if (n % i == 0 || n % (i + 2) == 0)
+                return false;
+        return true;
+    }
+
+    public static void main(String[] args) throws java.lang.Exception {
+        OutputStream outputStream = System.out;
+        out = new PrintWriter(outputStream);
+        scan = new FastReader();
+        //for fast output sometimes
+        StringBuilder sb = new StringBuilder();
+        int t = ni();
+        while (t-- != 0) {
+            int n=ni();
+            int k=ni();
+            int[] a=new int[k];
+            int[] temp=new int[k];
+            iIA(a);
+            iIA(temp);
+            long dp[]=new long[n];
+            Arrays.fill(dp,Integer.MAX_VALUE);
+            for(int i=0;i<k;i++){
+                dp[a[i]-1]=temp[i];
+            }
+            //iPA(dp);
+            for(int i=1;i<n;i++){
+                dp[i]=Math.min(dp[i-1]+1,dp[i]);
+            }
+            //iPA(dp);
+            for(int i=n-2;i>=0;i--){
+                dp[i]=Math.min(dp[i+1]+1,dp[i]);
+            }
+            lPA(dp);
+            //pn("""");
+        }
+
+        out.flush();
+        out.close();
+    }
+}
+
+",1
+734a94be,cb87df79,"
+
+import java.io.*;
+import java.math.*;
+import java.util.*;
+
+
+public class test {
+	 
+	   static class Pair{ 
+		   long x;
+		   long y;
+		   
+		   Pair(long x,long y){ 
+			   this.x = x;
+			   this.y = y;
+			   
+		   }
+	   }
+	  
+	   static class Compare { 
+		   
+		     void compare(Pair arr[], int n) 
+		    { 
+		        // Comparator to sort the pair according to second element 
+		        Arrays.sort(arr, new Comparator<Pair>() { 
+		            @Override public int compare(Pair p1, Pair p2) 
+		            { 
+		            	if(p1.x!=p2.x) {
+		                return (int)(p1.x - p2.x); 
+		            	}
+		            	else { 
+		            		return (int)(p1.y - p2.y);
+		            	}
+		            } 
+		        }); 
+		  
+//		        for (int i = 0; i < n; i++) { 
+//		            System.out.print(arr[i].x + "" "" + arr[i].y + "" ""); 
+//		        } 
+//		        System.out.println(); 
+		    } 
+		} 
+	 
+	   static class Scanner {
+	        BufferedReader br;
+	        StringTokenizer st;
+	 
+	        public Scanner()
+	        {
+	            br = new BufferedReader(
+	                new InputStreamReader(System.in));
+	        }
+	 
+	        String next()
+	        {
+	            while (st == null || !st.hasMoreElements()) {
+	                try {
+	                    st = new StringTokenizer(br.readLine());
+	                }
+	                catch (IOException e) {
+	                    e.printStackTrace();
+	                }
+	            }
+	            return st.nextToken();
+	        }
+	 
+	        int nextInt() { return Integer.parseInt(next()); }
+	 
+	        long nextLong() { return Long.parseLong(next()); }
+	 
+	        double nextDouble()
+	        {
+	            return Double.parseDouble(next());
+	        }
+	 
+	        String nextLine()
+	        {
+	            String str = """";
+	            try {
+	                str = br.readLine();
+	            }
+	            catch (IOException e) {
+	                e.printStackTrace();
+	            }
+	            return str;
+	        }
+	    }
+	
+	   static int solve(int dp[][] , ArrayList<Integer> one , ArrayList<Integer> zero , int i,int j)
+	   {
+	       int n=one.size();
+	       int m=zero.size();
+	       
+	       if(i>=n)
+	           return 0;
+	       
+	       else if(j>=m)
+	           return Integer.MAX_VALUE;
+	       
+	       else if(dp[i][j]!=-1)
+	           return dp[i][j];
+	       
+	       int val1 = Math.abs(one.get(i)-zero.get(j))+solve(dp, one ,zero ,i+1,j+1);
+	       int val2 = solve(dp , one , zero , i,j+1);
+	       
+	        dp[i][j]= Math.min(val1,val2);
+	        
+	        return dp[i][j];
+	   }
+	     
+	   public static void main(String args[]) throws Exception { 
+		
+		   Scanner sc = new Scanner();
+		   StringBuffer res = new StringBuffer();
+		   
+		   int tc = 1;
+		   
+		   while(tc-->0) { 
+			
+			    int n = sc.nextInt();
+			    
+			    ArrayList<Integer> one = new ArrayList<>();
+			    ArrayList<Integer> zero = new ArrayList<>();
+			    
+			    for(int i=0;i<n;i++) { 
+			    	
+			    	int x = sc.nextInt();
+			    	
+			    	if(x==1) { 
+			    		one.add(i);
+			    	}
+			    	else { 
+			    		zero.add(i);
+			    	}
+			    }
+			    
+			    int dp[][] = new int[one.size()+1][zero.size()+1];
+			    
+			     for(int i=1;i<=one.size();i++)
+			     {
+			         dp[i][i]=dp[i-1][i-1]+Math.abs(zero.get(i-1)-one.get(i-1));
+			         for(int j=i+1;j<=zero.size();j++)
+			         {
+			             dp[i][j]=Math.min(dp[i][j-1],dp[i-1][j-1]+Math.abs(one.get(i-1)-zero.get(j-1)));
+			         }
+			     }
+			     System.out.println(dp[one.size()][zero.size()]);
+		   }
+			System.out.println(res);
+	   }
+}  
+
+
+
+
+","import java.util.*;
+
+public class Longjumps {
+	 public static void main(String[] args){
+		 Scanner sc=new Scanner(System.in);
+			ArrayList<Integer> o=new ArrayList<Integer>(), e=new ArrayList<Integer>();
+			int n = sc.nextInt();
+			for(int i=1;i<=n;i++){
+				int x=sc.nextInt();
+				if(x==1)o.add(i);
+				else e.add(i);
+			}
+			int dp[][]=new int[o.size()+1][e.size()+1];
+			for(int i=1;i<=o.size();i++){
+				dp[i][i]=dp[i-1][i-1]+Math.abs(o.get(i-1)-e.get(i-1));
+				for(int j=i+1;j<=e.size();j++)
+					dp[i][j]=Math.min(dp[i][j-1],dp[i-1][j-1]+Math.abs(o.get(i-1)-e.get(j-1)));
+			}
+			System.out.println(dp[o.size()][e.size()]);
+	 }
+}",1
+169e34bf,fae0662f,"import java.util.*;
+public class D{
+  static Scanner sc;
+  public static void solve(){
+    int n=sc.nextInt();
+    Integer a[]=new Integer[n];
+    int flag;
+    for(int i=0;i<n;i++) a[i]=sc.nextInt();
+    String s=sc.next();
+    ArrayList<Integer> x=new ArrayList<>();
+    ArrayList<Integer> y=new ArrayList<>();
+    for(int i=0;i<n;i++){
+      if(s.charAt(i)=='B') x.add(a[i]);
+      else y.add(a[i]);
+    }
+    Collections.sort(x);
+    Collections.sort(y);
+    int p=n;
+    int q=1;
+    for(int i=y.size()-1;i>=0;i--){
+      if(y.get(i)>p){System.out.println(""NO""); return;}
+      p-=1;
+    }
+    for(int i=0;i<x.size();i++){
+      if(x.get(i)<q){System.out.println(""NO""); return;}
+      q+=1;
+    }
+    System.out.println(""YES"");
+  }
+  public static void main(String args[]){
+      sc=new Scanner(System.in);
+      int t=sc.nextInt();
+      while(t-->0) solve();
+  }
+}
+","import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.StringTokenizer;
+
+public class D {
+	
+	public static void main(String[] args) throws IOException {
+		FastScanner fs = new FastScanner();
+		PrintWriter out = new PrintWriter(System.out);
+		
+		int t = fs.nextInt();
+		for (int tc = 0; tc < t; tc++) {
+			int n = fs.nextInt();
+			int[] a = fs.readArray(n);
+			String s = fs.nextLine();
+			
+			// let all blue to be 1 -> blueCount
+			ArrayList<Integer> blues = new ArrayList<Integer>();
+			ArrayList<Integer> reds = new ArrayList<Integer>();
+			
+			for (int i = 0; i < s.length(); i++) {
+				if (s.charAt(i) == 'B') {
+					blues.add(a[i]);
+				} else {
+					reds.add(a[i]);
+				}
+			}
+			
+			Collections.sort(blues);
+			Collections.sort(reds);
+			
+			boolean ok = true;
+			
+			for (int i = 1; i <= blues.size(); i++) {
+				if (blues.get(i - 1) < i) {
+					ok = false;
+					break;
+				}
+			}
+			
+			for (int i = blues.size() + 1; i <= n; i++) {
+				if (reds.get(i - blues.size() - 1) > i) {
+					ok = false;
+					break;
+				}
+			}
+			
+			if (ok) {
+				out.println(""YES"");
+			} else {
+				out.println(""NO"");
+			}
+		}
+		
+		out.close();
+	}
+	
+	static class FastScanner {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st = new StringTokenizer("""");
+        
+        String next() {
+            while (!st.hasMoreTokens())
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            return st.nextToken();
+        }
+        
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        int[] readArray(int n) {
+            int[] a = new int[n];
+            for (int i = 0; i < n; i++) a[i] = nextInt();
+            return a;
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+        
+        String nextLine() throws IOException {
+        	return br.readLine();
+        }
+    }
+}
+
+",1
+c73cd266,d2eb953e,"import java.io.*;
+import java.util.*;
+
+
+public class Agad {
+    public static void main(String[] args) throws IOException {
+        FastReader reader = new FastReader();
+        PrintWriter writer = new PrintWriter(System.out);
+
+        int t = reader.nextInt();
+        while(t-- > 0) {
+            n = reader.nextInt();
+            lr = new int[n][2];
+            for (int i = 0; i < n; i++) {
+                lr[i][0] = reader.nextInt(); lr[i][1] = reader.nextInt();
+            }
+            g = new ArrayList[n];
+            for (int i = 0; i < n; i++) g[i] = new ArrayList<>();
+            for (int i = 1; i < n; i++) {
+                int a = reader.nextInt() - 1, b = reader.nextInt() - 1;
+                g[a].add(b); g[b].add(a);
+            }
+            long[] dp = dfs(0, -1);
+            writer.write(Math.max(dp[0], dp[1]) + ""\n"");
+        }        
+
+        writer.flush();
+        writer.close();
+    }
+
+    static int n;
+    static int[][] lr;
+    static ArrayList<Integer>[] g;
+
+    static long[] dfs(int v, int p) {
+        long[] dp = new long[2];
+        for (int ch : g[v]) if (ch != p) {
+            long[] tmp = dfs(ch, v);
+            dp[0] += Math.max(tmp[0] + Math.abs(lr[v][0] - lr[ch][0]), tmp[1] + Math.abs(lr[v][0] - lr[ch][1]));
+            dp[1] += Math.max(tmp[0] + Math.abs(lr[v][1] - lr[ch][0]), tmp[1] + Math.abs(lr[v][1] - lr[ch][1]));
+        }
+        return dp;
+    }
+
+    static class FastReader
+    {
+        BufferedReader br;
+        StringTokenizer st;
+
+        public FastReader()
+        {
+            br = new BufferedReader(new
+                    InputStreamReader(System.in));
+        }
+
+        String next()
+        {
+            while (st == null || !st.hasMoreElements())
+            {
+                try
+                {
+                    st = new StringTokenizer(br.readLine());
+                }
+                catch (IOException  e)
+                {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt()
+        {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong()
+        {
+            return Long.parseLong(next());
+        }
+
+        double nextDouble()
+        {
+            return Double.parseDouble(next());
+        }
+
+        String nextLine()
+        {
+            String str = """";
+            try
+            {
+                str = br.readLine();
+            }
+            catch (IOException e)
+            {
+                e.printStackTrace();
+            }
+            return str;
+        }
+    }
+}
+
+","import java.util.*;
+// import java.lang.*;
+import java.io.*;
+
+//           THIS TEMPLATE MADE BY AKSH BANSAL.
+
+public class Solution {
+    static class FastReader {
+        BufferedReader br;
+        StringTokenizer st;
+
+        public FastReader() {
+            br = new BufferedReader(new InputStreamReader(System.in));
+        }
+
+        String next() {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+
+        String nextLine() {
+            String str = """";
+            try {
+                str = br.readLine();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+        }
+    }
+    private static boolean[] isPrime;
+    private static void primes(){
+        int num = (int)1e6; // PRIMES FROM 1 TO NUM
+        isPrime = new boolean[num];
+     
+        for (int i = 2; i< isPrime.length; i++) {
+           isPrime[i] = true;
+        }
+        for (int i = 2; i< Math.sqrt(num); i++) {
+           if(isPrime[i] == true) {
+              for(int j = (i*i); j<num; j = j+i) {
+                 isPrime[j] = false;
+              }
+           }
+        }
+    }
+    private static long gcd(long a, long b){
+        if(b==0)return a;
+        return gcd(b,a%b);
+    }
+    private static long pow(long x,long y){
+        if(y==0)return 1;
+        long temp = pow(x, y/2);
+        if(y%2==1){
+            return x*temp*temp;
+        }
+        else{
+            return temp*temp;
+        }
+    }
+    static ArrayList<Integer>[] adj;
+    static void getAdj(int n,int q, FastReader sc){
+        adj = new ArrayList[n+1];
+        for(int i=1;i<=n;i++){
+            adj[i] = new ArrayList<>();
+        }
+        for(int i=0;i<q;i++){
+            int a = sc.nextInt();
+            int b = sc.nextInt();
+
+            adj[a].add(b);
+            adj[b].add(a);
+        }
+    }
+    static PrintWriter out;
+    public static void main(String[] args) throws IOException {
+        FastReader sc = new FastReader();
+        out = new PrintWriter(System.out);
+        // primes();
+        // ________________________________
+
+        int t = sc.nextInt();
+        StringBuilder output = new StringBuilder();
+
+        while (t-- > 0) {
+            int n = sc.nextInt();
+            pair = new int[n+1][2];
+            dp = new long[n+1][2];
+            for(int i=1;i<=n;i++){
+                pair[i][0]=sc.nextInt();
+                pair[i][1]=sc.nextInt();
+            }
+            getAdj(n, n-1, sc);
+            output.append(solver(n)).append(""\n"");
+        }
+
+        out.println(output);
+        // _______________________________
+
+        // int n = sc.nextInt();
+        // out.println(solver());
+        // ________________________________
+        out.flush();
+    }
+
+    static int[][] pair;
+    static long[][] dp;
+
+    public static long solver(int n) {
+        dfs(1,  0);
+        return Math.max(dp[1][0], dp[1][1]);
+    }
+
+    static void dfs(int node, int parent){
+        for(Integer child: adj[node]){
+            if(child!=parent){
+                dfs(child,  node);
+                long left1 = Math.abs(pair[node][0]-pair[child][0]) + dp[child][0];
+                long right1 = Math.abs(pair[node][0]-pair[child][1]) + dp[child][1];
+                long left2 = Math.abs(pair[node][1]-pair[child][0]) + dp[child][0];
+                long right2 = Math.abs(pair[node][1]-pair[child][1]) + dp[child][1];
+                dp[node][0] += Math.max(left1, right1);
+                dp[node][1] += Math.max(left2, right2);
+            }
+        }
+    }
+}",0
+3a12e509,c9159d9c,"import java.io.*;
+import java.util.*;
+
+
+public class Practice
+{
+//	static final long mod=7420738134811L;
+	static int mod=1000000007;
+	static final int size=501;
+	static FastReader sc=new FastReader(System.in);
+//	static Reader sc=new Reader();
+	static  PrintWriter out=new PrintWriter(System.out);
+	static long[] factorialNumInverse;
+	static long[] naturalNumInverse;	
+	static int[] sp;
+	static long[] fact;
+	static ArrayList<Integer> pr;
+	public static void main(String[] args) throws IOException
+	{
+//		System.setIn(new FileInputStream(""input.txt""));
+//		System.setOut(new PrintStream(""output.txt""));
+//		factorial(mod);
+//		InverseofNumber(mod);
+//		InverseofFactorial(mod);
+//		make_seive();
+		int t=1;
+		t=sc.nextInt();
+		while(t-->0)
+			solve();
+		out.close();
+		out.flush();
+	}
+	static void solve() throws IOException
+	{
+		int n=sc.nextInt();
+		int arr[]=new int[n];
+		for(int i=0;i<n;i++)
+			arr[i]=sc.nextInt();
+		String s=sc.next();
+		ArrayList<Integer> blue=new ArrayList<Integer>();
+		ArrayList<Integer> red=new ArrayList<Integer>();
+		for(int i=0;i<n;i++)
+		{
+			if(s.charAt(i)=='B')
+				blue.add(arr[i]);
+			else
+				red.add(arr[i]);
+		}
+		Collections.sort(blue);
+		Collections.sort(red);
+		for(int i=0;i<blue.size();i++)
+		{
+			if(blue.get(i)<i+1)
+			{
+				out.println(""NO"");
+				return;
+			}
+		}
+		for(int i=0;i<red.size();i++)
+		{
+			if(red.get(i)>i+1+blue.size())
+			{
+				out.println(""NO"");
+				return;
+			}
+		}
+		out.println(""YES"");
+	}
+	static class Pair implements Cloneable, Comparable<Pair>
+	{
+		int x,y;
+		Pair(int a,int b)
+		{
+			this.x=a;
+			this.y=b;
+		}
+		@Override
+		public boolean equals(Object obj) 
+		{
+			if(obj instanceof  Pair)
+			{
+				Pair p=(Pair)obj;
+				return p.x==this.x && p.y==this.y;
+			}
+			return false;
+		}
+		@Override
+		public int hashCode() 
+		{
+			return Math.abs(x)+500*Math.abs(y);
+		}
+		@Override
+		public String toString() 
+		{
+			return ""(""+x+"" ""+y+"")"";
+		}
+		@Override
+		protected Pair clone() throws CloneNotSupportedException {
+			return new Pair(this.x,this.y);
+		}
+		@Override
+		public int compareTo(Pair a) 
+		{
+			int t= this.x-a.x;
+			if(t!=0)
+				return t;
+			else
+				return this.y-a.y;
+		}
+		public void swap()
+		{
+			this.y=this.y+this.x;
+			this.x=this.y-this.x;
+			this.y=this.y-this.x;			
+		}
+	}
+	static class Tuple implements Cloneable, Comparable<Tuple>
+	{
+		int x,y,z;
+		Tuple(int a,int b,int c)
+		{
+			this.x=a;
+			this.y=b;
+			this.z=c;
+		}
+		public boolean equals(Object obj) 
+		{
+			if(obj instanceof  Tuple)
+			{
+				Tuple p=(Tuple)obj;
+				return p.x==this.x && p.y==this.y && p.z==this.z;
+			}
+			return false;
+		}
+		@Override
+		public int hashCode() 
+		{
+			return (this.x+501*this.y);
+		}
+		@Override
+		public String toString() 
+		{
+			return ""(""+x+"",""+y+"",""+z+"")"";
+		}
+		@Override
+		protected Tuple clone() throws CloneNotSupportedException {
+			return new Tuple(this.x,this.y,this.z);
+		}
+		@Override
+		public int compareTo(Tuple a) 
+		{
+			int x=this.z-a.z;
+			if(x!=0)
+				return x;
+			int X= this.x-a.x;
+			if(X!=0)
+				return X;
+			return a.y-this.y;
+		}
+	}
+	static void arraySort(int arr[])
+	{
+		ArrayList<Integer> a=new ArrayList<Integer>();
+		for (int i = 0; i < arr.length; i++) {
+			a.add(arr[i]);
+		}
+		Collections.sort(a);
+		for (int i = 0; i < arr.length; i++) {
+			arr[i]=a.get(i);
+		}
+	}
+	static void arraySort(long arr[])
+	{
+		ArrayList<Long> a=new ArrayList<Long>();
+		for (int i = 0; i < arr.length; i++) {
+			a.add(arr[i]);
+		}
+		Collections.sort(a);
+		for (int i = 0; i < arr.length; i++) {
+			arr[i]=a.get(i);
+		}
+	}
+	static HashSet<Integer> primeFactors(int n)
+	{
+		HashSet<Integer> ans=new HashSet<Integer>();
+		if(n%2==0)
+		{
+			ans.add(2);
+			while((n&1)==0)
+				n=n>>1;
+		}
+		for(int i=3;i*i<=n;i+=2)
+		{
+			if(n%i==0)
+			{
+				ans.add(i);
+				while(n%i==0)
+					n=n/i;
+			}
+		}
+		if(n!=1)
+			ans.add(n);
+		return ans;
+	}
+	static void make_seive()
+	{
+		sp=new int[size];
+		pr=new ArrayList<Integer>();
+		for (int i=2; i<size; ++i) {
+		    if (sp[i] == 0) {
+		        sp[i] = i;
+		        pr.add(i);
+		    }
+		    for (int j=0; j<(int)pr.size() && pr.get(j)<=sp[i] && i*pr.get(j)<size; ++j)
+		        sp[i * pr.get(j)] = pr.get(j);
+		}
+	}
+	public static void InverseofNumber(int p)
+	{
+		naturalNumInverse=new long[size];
+	    naturalNumInverse[0] = naturalNumInverse[1] = 1;
+	    for(int i = 2; i < size; i++)
+	        naturalNumInverse[i] = naturalNumInverse[p % i] * (long)(p - p / i) % p;
+	}
+	// Function to precompute inverse of factorials
+	public static void InverseofFactorial(int p)
+	{
+		factorialNumInverse=new long[size];
+	    factorialNumInverse[0] = factorialNumInverse[1] = 1;
+	    // pre-compute inverse of natural numbers
+	    for(int i = 2; i < size; i++)
+	        factorialNumInverse[i] = (naturalNumInverse[i] * factorialNumInverse[i - 1]) % p;
+	}
+	// Function to calculate factorial of 1 to 200001
+	public static void factorial(int p)
+	{
+		fact=new long[size];
+	    fact[0] = 1;
+	    for(int i = 1; i < size; i++)
+	        fact[i] = (fact[i - 1] * (long)i) % p;
+	}
+	 
+	// Function to return nCr % p in O(1) time
+	public static long Binomial(int N, int R)
+	{
+		if(R<0)
+			return 1;
+	    // n C r = n!*inverse(r!)*inverse((n-r)!)
+	    long ans = ((fact[N] * factorialNumInverse[R]) % mod * factorialNumInverse[N - R]) % mod;
+	    return ans;
+	}
+	static int findXOR(int x)	//from 0 to x
+	{
+		if(x<0)
+			return 0;
+		if(x%4==0)
+			return x;
+		if(x%4==1)
+			return 1;
+		if(x%4==2)
+			return x+1;
+		return 0;
+	}
+	static boolean isPrime(long x)
+	{
+		if(x==1)
+			return false;
+		if(x<=3)
+			return true;
+		if(x%2==0 || x%3==0)
+			return false;
+		for(int i=5;i<=Math.sqrt(x);i+=2)
+			if(x%i==0)
+				return false;
+		return true;
+	}
+	static long gcd(long a,long b)
+	{
+		return (b==0)?a:gcd(b,a%b);
+	}
+	static int gcd(int a,int b)
+	{
+		return (b==0)?a:gcd(b,a%b);
+	}
+	static class Node
+	{
+		int vertex;
+		HashSet<Edge> adj;
+		int taxC,taxD;
+		Node(int ver)
+		{
+			vertex=ver;
+			taxD=0;
+			taxC=0;
+			adj=new HashSet<Edge>();
+		}
+		@Override
+		public String toString() 
+		{
+			return vertex+"" "";
+		}
+	}
+	static class Edge
+	{
+		Node to;
+		int cost;
+		Edge(Node t,int c)
+		{
+			this.to=t;
+			this.cost=c;
+		}
+		@Override
+		public String toString() {
+			return ""(""+to.vertex+"",""+cost+"") "";
+		}
+	}
+	static long power(long x, long y)
+	  {
+		if(x<=0)
+			return 1;
+	    long res = 1; 
+	    x = x % mod; 
+	    if (x == 0)
+	      return 0; 
+	    while (y > 0)
+	    {
+	    	if ((y & 1) != 0)
+	    		res = (res * x) % mod;
+	    	
+	    	y = y >> 1; // y = y/2
+	    	x = (x * x) % mod;
+	    }
+	    return res;
+	  }
+	static long binomialCoeff(long n, long k)
+    {
+		if(n<k)
+			return 0;
+        long res = 1;
+//        if(k>n)
+//        	return 0;
+        // Since C(n, k) = C(n, n-k)
+        if (k > n - k)
+            k = n - k;
+ 
+        // Calculate value of
+        // [n * (n-1) *---* (n-k+1)] / [k * (k-1) *----* 1]
+        for (long i = 0; i < k; ++i) {
+            res *= (n - i);
+            res /= (i + 1);
+        }
+ 
+        return res;
+    }
+	static class FastReader
+	{
+        byte[] buf = new byte[2048];
+        int index, total;
+        InputStream in;
+ 
+        FastReader(InputStream is) 
+        {
+            in = is;
+        }
+ 
+        int scan() throws IOException 
+        {
+            if (index >= total) {
+                index = 0;
+                total = in.read(buf);
+                if (total <= 0) {
+                    return -1;
+                }
+            }
+            return buf[index++];
+        }
+ 
+        String next() throws IOException 
+        {
+            int c;
+            for (c = scan(); c <= 32; c = scan());
+            StringBuilder sb = new StringBuilder();
+            for (; c > 32; c = scan()) {
+                sb.append((char) c);
+            }
+            return sb.toString();
+        }
+ 
+        int nextInt() throws IOException 
+        {
+            int c, val = 0;
+            for (c = scan(); c <= 32; c = scan());
+            boolean neg = c == '-';
+            if (c == '-' || c == '+') {
+                c = scan();
+            }
+            for (; c >= '0' && c <= '9'; c = scan()) {
+                val = (val << 3) + (val << 1) + (c & 15);
+            }
+            return neg ? -val : val;
+        }
+ 
+        long nextLong() throws IOException 
+        {
+            int c;
+            long val = 0;
+            for (c = scan(); c <= 32; c = scan());
+            boolean neg = c == '-';
+            if (c == '-' || c == '+') {
+                c = scan();
+            }
+            for (; c >= '0' && c <= '9'; c = scan()) {
+                val = (val << 3) + (val << 1) + (c & 15);
+            }
+            return neg ? -val : val;
+        }
+    }
+	static class Reader 
+	{
+        final private int BUFFER_SIZE = 1 << 16;
+        private DataInputStream din;
+        private byte[] buffer;
+        private int bufferPointer, bytesRead;
+ 
+        public Reader()
+        {
+            din = new DataInputStream(System.in);
+            buffer = new byte[BUFFER_SIZE];
+            bufferPointer = bytesRead = 0;
+        }
+ 
+        public Reader(String file_name) throws IOException
+        {
+            din = new DataInputStream(
+                new FileInputStream(file_name));
+            buffer = new byte[BUFFER_SIZE];
+            bufferPointer = bytesRead = 0;
+        }
+ 
+        public String readLine() throws IOException
+        {
+            byte[] buf = new byte[64]; // line length
+            int cnt = 0, c;
+            while ((c = read()) != -1) {
+                if (c == '\n') {
+                    if (cnt != 0) {
+                        break;
+                    }
+                    else {
+                        continue;
+                    }
+                }
+                buf[cnt++] = (byte)c;
+            }
+            return new String(buf, 0, cnt);
+        }
+ 
+        public int nextInt() throws IOException
+        {
+            int ret = 0;
+            byte c = read();
+            while (c <= ' ') {
+                c = read();
+            }
+            boolean neg = (c == '-');
+            if (neg)
+                c = read();
+            do {
+                ret = ret * 10 + c - '0';
+            } while ((c = read()) >= '0' && c <= '9');
+ 
+            if (neg)
+                return -ret;
+            return ret;
+        }
+ 
+        public long nextLong() throws IOException
+        {
+            long ret = 0;
+            byte c = read();
+            while (c <= ' ')
+                c = read();
+            boolean neg = (c == '-');
+            if (neg)
+                c = read();
+            do {
+                ret = ret * 10 + c - '0';
+            } while ((c = read()) >= '0' && c <= '9');
+            if (neg)
+                return -ret;
+            return ret;
+        }
+ 
+        public double nextDouble() throws IOException
+        {
+            double ret = 0, div = 1;
+            byte c = read();
+            while (c <= ' ')
+                c = read();
+            boolean neg = (c == '-');
+            if (neg)
+                c = read();
+ 
+            do {
+                ret = ret * 10 + c - '0';
+            } while ((c = read()) >= '0' && c <= '9');
+ 
+            if (c == '.') {
+                while ((c = read()) >= '0' && c <= '9') {
+                    ret += (c - '0') / (div *= 10);
+                }
+            }
+ 
+            if (neg)
+                return -ret;
+            return ret;
+        }
+ 
+        private void fillBuffer() throws IOException
+        {
+            bytesRead = din.read(buffer, bufferPointer = 0,
+                                 BUFFER_SIZE);
+            if (bytesRead == -1)
+                buffer[0] = -1;
+        }
+ 
+        private byte read() throws IOException
+        {
+            if (bufferPointer == bytesRead)
+                fillBuffer();
+            return buffer[bufferPointer++];
+        }
+ 
+        public void close() throws IOException
+        {
+            if (din == null)
+                return;
+            din.close();
+        }
+        public void printarray(int arr[])
+        {
+        	for (int i = 0; i < arr.length; i++)
+				System.out.print(arr[i]+"" "");
+        	System.out.println();
+        }
+    }
+}
+
+
+
+
+
+
+
+","import java.util.*;
+
+public class SolutionB {
+
+    public static long gcd(long a, long b){
+        if(b==0){
+            return a;
+        }
+        return gcd(b, a%b);
+    }
+
+    public static long gcdSum(long b){
+        long a = 0;
+
+        long temp = b;
+        while(temp!=0){
+            a = a + temp%10;
+            temp = temp/10;
+        }
+        return gcd(a,b);
+
+    }
+
+    public static class Pair{
+        Long a;
+        Long b;
+
+        public Pair(Long a, Long b) {
+            this.a = a;
+            this.b = b;
+        }
+    }
+
+    public static long factorial (long n){
+        if(n==0)
+            return 1;
+        else if(n==1)
+            return n;
+
+        return n * factorial(n-1);
+    }
+
+    public static long lcm (long n){
+        if(n<3)
+            return n;
+        return lcmForBig(n,n-1);
+    }
+
+    private static long lcmForBig(long n, long l) {
+        if(l==1)
+            return n;
+        n = (n * l) / gcd(n, l);
+        return lcmForBig(n, l-1);
+
+    }
+
+
+    public static void main(String[] args){
+        Scanner s = new Scanner(System.in);
+        
+        int t = s.nextInt();
+
+        for(int i =0;i<t;i++) {
+            int n = s.nextInt();
+            int arr [] = new int[n];
+            ArrayList<Integer> blue = new ArrayList<>();
+            ArrayList<Integer> red = new ArrayList<>();
+
+            for(int j=0;j<n;j++){
+                int num = s.nextInt();
+                arr[j]=num;
+            }
+            String color = s.next();
+
+            for(int j=0;j<n;j++){
+                if(color.charAt(j)=='B'){
+                    blue.add(arr[j]);
+                }
+                else{
+                    red.add(arr[j]);
+                }
+            }
+            Collections.sort(blue);
+            String ans = ""YES"";
+            int counter = 0;
+
+            for(int j=0;j<blue.size();j++){
+                int current = blue.get(j);
+                if (current<1){
+                    ans=""NO"";
+                    break;
+                }
+                if(current>counter){
+                    counter++;
+                }
+                else{
+                    ans=""NO"";
+                    break;
+                }
+
+            }
+
+            if(ans==""NO""){
+                System.out.println(ans);
+            }
+            else{
+                int tempCounter = n+1;
+                Collections.sort(red);
+                for(int j=red.size()-1;j>=0;j--){
+                    int  current  = red.get(j);
+                    if(current>=tempCounter){
+                        ans=""NO"";
+                        break;
+                    }
+                    else{
+                        tempCounter--;
+                    }
+                }
+                if(tempCounter-counter!=1)
+                    System.out.println(""NO"");
+                else
+                    System.out.println(ans);
+            }
+
+        }
+
+        return;
+    }
+}
+",0
+12c1cc56,7b71234c,"import java.io.*;
+import java.util.*;
+
+public class Codeforces
+{
+    public static void main(String args[])throws Exception
+    {
+        BufferedReader bu=new BufferedReader(new InputStreamReader(System.in));
+        StringBuilder sb=new StringBuilder();
+        int n=Integer.parseInt(bu.readLine());
+        String s[]=bu.readLine().split("" "");
+        ArrayList<Integer> z=new ArrayList<>(),o=new ArrayList<>();
+        long dp[][]=new long[n+1][n+1];
+        int i,j,a;
+        for(i=0;i<n;i++)
+        {
+            a=Integer.parseInt(s[i]);
+            if(a==0) z.add(i);
+            else o.add(i);
+        }
+
+        for(i=1;i<=o.size();i++)
+        {
+            long min=dp[i-1][i-1];
+            for(j=i;j<=z.size();j++)
+            {
+                dp[i][j]=min+Math.abs(z.get(j-1)-o.get(i-1));
+                min=Math.min(min,dp[i-1][j]);
+            }
+        }
+        long ans=Long.MAX_VALUE;
+        for(i=o.size();i<=z.size();i++)
+        ans=Math.min(ans,dp[o.size()][i]);
+        System.out.print(ans);
+    }
+}","import java.io.*;
+import java.util.*;
+
+public class Codeforces
+{
+    public static void main(String args[])throws Exception
+    {
+        BufferedReader bu=new BufferedReader(new InputStreamReader(System.in));
+        StringBuilder sb=new StringBuilder();
+        int n=Integer.parseInt(bu.readLine());
+        String s[]=bu.readLine().split("" "");
+        ArrayList<Integer> z=new ArrayList<>(),o=new ArrayList<>();
+        long dp[][]=new long[n+1][n+1];
+        int i,j,a;
+        for(i=0;i<n;i++)
+        {
+            a=Integer.parseInt(s[i]);
+            if(a==0) z.add(i);
+            else o.add(i);
+        }
+
+        for(i=1;i<=o.size();i++)
+        {
+            long min=dp[i-1][i-1];
+            for(j=i;j<=z.size();j++)
+            {
+                dp[i][j]=min+Math.abs(z.get(j-1)-o.get(i-1));
+                min=Math.min(min,dp[i-1][j]);
+            }
+        }
+        long ans=Long.MAX_VALUE;
+        for(i=o.size();i<=z.size();i++)
+        ans=Math.min(ans,dp[o.size()][i]);
+        System.out.print(ans);
+    }
+}",1
+169e34bf,69b8ffb2,"import java.util.*;
+public class D{
+  static Scanner sc;
+  public static void solve(){
+    int n=sc.nextInt();
+    Integer a[]=new Integer[n];
+    int flag;
+    for(int i=0;i<n;i++) a[i]=sc.nextInt();
+    String s=sc.next();
+    ArrayList<Integer> x=new ArrayList<>();
+    ArrayList<Integer> y=new ArrayList<>();
+    for(int i=0;i<n;i++){
+      if(s.charAt(i)=='B') x.add(a[i]);
+      else y.add(a[i]);
+    }
+    Collections.sort(x);
+    Collections.sort(y);
+    int p=n;
+    int q=1;
+    for(int i=y.size()-1;i>=0;i--){
+      if(y.get(i)>p){System.out.println(""NO""); return;}
+      p-=1;
+    }
+    for(int i=0;i<x.size();i++){
+      if(x.get(i)<q){System.out.println(""NO""); return;}
+      q+=1;
+    }
+    System.out.println(""YES"");
+  }
+  public static void main(String args[]){
+      sc=new Scanner(System.in);
+      int t=sc.nextInt();
+      while(t-->0) solve();
+  }
+}
+","import java.util.*;
+
+//CODE FORCES
+
+public class anshulvmc {
+
+    
+    public static void sort(int[] a) {
+		ArrayList<Integer> l=new ArrayList<>();
+		for (int i:a) l.add(i);
+		Collections.sort(l);
+		for (int i=0; i<a.length; i++) a[i]=l.get(i);
+	}
+    
+    
+    
+    
+    public static int gcd(int a, int b) {
+		if (b==0) return a;
+		return gcd(b, a%b);
+	}
+    
+    public static void google(int t) {
+    	System.out.println(""Case #""+t+"": "");
+    }
+    
+    
+//    public static void gt(int[][] arr,int k) {
+//    	int n = arr.length+1;
+//    	k = Math.min(k,n+1);
+//    	
+//    	Node[] nodes = new Node[n];
+//    	for(int i=0;i<n;i++) nodes[i] = new Node();
+//    	for(int i=0;i<n-1;i++) {
+//    		int a = arr[i][0];
+//    		int b = arr[i][1];
+//    		System.out.println(a+"" ""+b);
+//    		nodes[a].adj.add(nodes[b]);
+//    		nodes[b].adj.add(nodes[a]);
+//    	}
+//    	
+//    	ArrayDeque<Node> bfs = new ArrayDeque<>();
+//    	for(Node nn:nodes) {
+//    		if(nn.adj.size()<2) {
+//    			bfs.addLast(nn);
+//    			nn.dist=0;
+//    		}
+//    	}
+//    	
+//    	while(bfs.size()>0) {
+//    		Node nn = bfs.removeFirst();
+//    		for(Node a : nn.adj) {
+//    			if(a.dist!=-1) continue;
+//    			a.usedDegree++;
+//    			if(a.adj.size() - a.usedDegree <= 1) {
+//    				a.dist = nn.dist+1;
+//    				bfs.addLast(a);
+//    			}
+//    		}
+//    	}
+//    	
+//    	int[] cs = new int[n+1];
+//    	for(Node nn:nodes) {
+//    		cs[nn.dist]++;
+//    	}
+//    	for(int i=1;i<cs.length;i++) cs[i]+=cs[i-1];
+//    	System.out.println(n-cs[k-1]);
+//    }
+    
+    public static class Node{
+    	ArrayList<Node> adj = new ArrayList<>();
+    	int dist = -1;
+    	int usedDegree = 0;
+    }
+    
+    
+    public static void cat_mice(int dest,int[] arr) {
+    	sort(arr);
+    	int time = dest;
+		int timeleft = dest-1;
+		int counter=0;
+		for(int i=arr.length-1;i>=0;i--) {
+			int val = arr[i];
+			int takes = time - val;
+			if(takes <= timeleft) {
+				timeleft -= takes;
+				counter++;
+			}
+		}
+    	System.out.println(counter);
+    }
+    
+    
+    public static void minex(int n,int[] arr) {
+    	sort(arr);
+    	int ans=arr[0];
+    	for(int i=0;i<arr.length-1;i++) {
+    		ans = Math.max(ans,arr[i+1] - arr[i]);
+    	}
+    	System.out.println(ans);
+    }
+	
+    
+    public static void func(long start,long n) {
+    	long x = start;
+    	if(n==0){
+    	       System.out.println(x);
+    	       return;
+    	   }
+    	   long k=n-1;
+    	   long c=k/4;
+    	   long rem=k%4;
+    	   long ans=x;
+    	   if(x%2 == 0) {
+       		ans -= 1;
+       		ans -= (c * 4);
+       		if(rem == 1) {
+       			ans += n;
+       		}
+       		else if(rem == 2) {
+       			ans += n + n-1;
+       		}
+       		else if(rem == 3){
+       			ans += (n-2) + (n-1) - n;
+       		}
+       	}
+       	else {
+       		ans += 1;
+       		ans += (c * 4);
+       		if(rem == 1) {
+       			ans -= n;
+       		}
+       		else if(rem == 2) {
+       			ans -= n + n-1;
+       		}
+       		else if(rem == 3) {
+       			ans -= n-2 + n-1 - n;
+       		}
+       	}
+    	   System.out.println(ans);
+    	   
+    	
+    }
+    
+	public static boolean redblue(int[] num, String chnum) {
+    	ArrayList<Integer> blue = new ArrayList<>();
+    	ArrayList<Integer> red = new ArrayList<>();
+    	for(int i=0;i<chnum.length();i++) {
+    		char ch = chnum.charAt(i);
+    		if(ch == 'B') {
+    			blue.add(num[i]);
+    		}
+    		else {
+    			red.add(num[i]);
+    		}
+    	}
+    	Collections.sort(blue);
+    	Collections.sort(red);
+//    	System.out.println(blue);
+//    	System.out.println(red);
+    	for(int i=0;i<blue.size();i++) {
+    		if(blue.get(i) >= i+1) {
+    			
+    		}
+    		else {
+    			return false;
+    		}
+    	}
+    	for(int i=0;i<red.size();i++) {
+    		if(red.get(i) > i+1 + blue.size()) {
+//    			System.out.println(red.get(i)+"" ""+(i+1 + blue.size()));
+    			return false;
+    		}
+    	}
+    	return true;
+    }
+    
+    public static void main(String args[])
+    
+    
+    {	
+    	Scanner scn = new Scanner(System.in);
+    	int test = scn.nextInt();
+    	for(int i=0;i<test;i++) {
+    		int size = scn.nextInt();
+    		int[] arr = new int[size];
+    		for(int j=0;j<size;j++) {
+    			arr[j] = scn.nextInt();
+    		}
+    		String str = scn.next();
+    		boolean f = redblue(arr,str);
+    		if(f) {
+    			System.out.println(""YES"");
+    		}
+    		else {
+    			System.out.println(""NO"");
+    		}
+    	}
+//    	int n = 1;
+//    	int[] dp = new int[2];
+//    	System.out.println(fact(n,dp));
+    			
+    }
+
+}",0
+21123500,fbd26aa0,"import java.io.*;
+import java.util.*;
+
+public class Main {
+	static class Pair implements Comparable<Pair> {
+		int f, s;
+		Pair(int f, int s) {
+			this.f = f; this.s = s;
+		}
+		public int compareTo(Pair other) {
+			if (this.f != other.f) return this.f - other.f;
+			return this.s - other.s;
+		}
+	}
+	public static void main(String[] args) throws IOException {
+		PriorityQueue<Pair> pq = new PriorityQueue();
+		for (int t = readInt(); t > 0; --t) {
+			int n = readInt(), m = readInt(), x = readInt();
+			System.out.println(""YES"");
+			for (int i = 1; i <= m; ++i) {
+				pq.add(new Pair(readInt(), i));
+				System.out.print(i + "" "");
+			}
+			for (int i = m + 1; i <= n; ++i) {
+				Pair p = pq.poll();
+				p.f += readInt();
+				pq.add(p);
+				System.out.print(p.s + "" "");
+			}
+			System.out.println();
+			pq.clear();
+		}
+	}
+	static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+	static StringTokenizer st;
+	static String next() throws IOException {
+		while (st == null || !st.hasMoreTokens())
+			st = new StringTokenizer(br.readLine());
+		return st.nextToken();
+	}
+	static int readInt() throws IOException {
+		return Integer.parseInt(next());
+	}
+}
+","import java.io.*;
+import java.util.*;
+
+public class Main {
+	static class Pair implements Comparable<Pair> {
+		int f, s;
+		Pair(int f, int s) {
+			this.f = f; this.s = s;
+		}
+		public int compareTo(Pair other) {
+			if (this.f != other.f) return this.f - other.f;
+			return this.s - other.s;
+		}
+	}
+	public static void main(String[] args) throws IOException {
+		PriorityQueue<Pair> pq = new PriorityQueue();
+		for (int t = readInt(); t > 0; --t) {
+			int n = readInt(), m = readInt(), x = readInt();
+			System.out.println(""YES"");
+			for (int i = 1; i <= m; ++i) {
+				pq.add(new Pair(readInt(), i));
+				System.out.print(i + "" "");
+			}
+			for (int i = m + 1; i <= n; ++i) {
+				Pair p = pq.poll();
+				p.f += readInt();
+				pq.add(p);
+				System.out.print(p.s + "" "");
+			}
+			System.out.println();
+			pq.clear();
+		}
+	}
+	static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+	static StringTokenizer st;
+	static String next() throws IOException {
+		while (st == null || !st.hasMoreTokens())
+			st = new StringTokenizer(br.readLine());
+		return st.nextToken();
+	}
+	static int readInt() throws IOException {
+		return Integer.parseInt(next());
+	}
+}
+",1
+49e94e7e,da5cf40b,"import java.io.BufferedReader;
+import java.io.IOException;
+import java.lang.*;
+import java.io.InputStreamReader;
+import static java.lang.Math.*;
+import static java.lang.System.out;
+import java.util.*;
+import java.io.File;
+import java.io.PrintStream;
+import java.io.PrintWriter;
+import java.math.BigInteger;
+public class Main {
+ 
+	
+	/* 10^(7) = 1s.
+	 * ceilVal = (a+b-1) / b */
+	
+	static final int mod = 1000000007;
+	static final long temp = 998244353;
+	static final long MOD = 1000000007;
+	static final long M = (long)1e9+7;
+ 
+	
+	static class Pair implements Comparable<Pair> 
+	{
+		int first, second;
+		
+		public Pair(int first, int second) 
+		{
+			this.first = first;
+			this.second = second;
+		}
+		
+		public int compareTo(Pair ob) 
+		{
+			return (int)(first - ob.first);
+		}
+	}
+	
+	
+	static class Tuple implements Comparable<Tuple>
+	{
+		int first, second,third;
+		public Tuple(int first, int second, int third)
+		{
+			this.first = first;
+			this.second = second;
+			this.third = third;
+		}
+		public int compareTo(Tuple o)
+		{
+			return (int)(o.third - this.third);
+		}
+	}
+	
+	public static class DSU
+	{
+		int[] parent;
+		int[] rank; //Size of the trees is used as the rank
+		public DSU(int n)
+		{
+			parent = new int[n];
+			rank = new int[n];
+			Arrays.fill(parent, -1);
+			Arrays.fill(rank, 1);
+		}
+		
+		public int find(int i) //finding through path compression
+		{
+			return parent[i] < 0 ? i : (parent[i] = find(parent[i]));
+		}
+		
+		public boolean union(int a, int b) //Union Find by Rank 
+		{
+			a = find(a);
+			b = find(b);
+			
+			if(a == b) return false; //if they are already connected we exit by returning false.
+			
+			// if a's parent is less than b's parent
+			if(rank[a] < rank[b])
+			{
+				//then move a under b
+				parent[a] = b;
+			}
+			//else if rank of j's parent is less than i's parent
+			else if(rank[a] > rank[b])
+			{
+				//then move b under a
+				parent[b] = a;
+			}
+			//if both have the same rank.
+			else
+			{
+				//move a under b (it doesnt matter if its the other way around.
+				parent[b] = a;
+				rank[a] = 1 + rank[a];
+			}
+			return true;
+		}	
+	}
+
+	static class Reader 
+	{
+		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st=new StringTokenizer("""");
+		String next() {
+			while (!st.hasMoreTokens())
+				try {
+					st=new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			return st.nextToken();
+		}
+		
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+		
+		int[] readArray(int n) throws IOException {
+			int[] a=new int[n];
+			for (int i=0; i<n; i++) a[i]=nextInt();
+			return a;
+		}
+		
+		long[] longReadArray(int n) throws IOException {
+			long[] a=new long[n];
+			for (int i=0; i<n; i++) a[i]=nextLong();
+			return a;
+		}
+		
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+		double nextDouble() {
+			return Double.parseDouble(next());
+		}
+	}
+	
+	public static int gcd(int a, int b)
+	{
+		if(b == 0)
+		 return a;
+		
+		else
+		return gcd(b,a%b);
+	} 
+ 
+		public static long lcm(long a, long b)
+	    {
+	        return (a / LongGCD(a, b)) * b;
+	    }
+	
+	public static long LongGCD(long a, long b)
+	{
+		if(b == 0)
+			 return a;
+			
+			else
+			return LongGCD(b,a%b);
+	}
+	
+		public static long LongLCM(long a, long b)
+	    {
+	        return (a / LongGCD(a, b)) * b;
+	    }
+	
+		//Count the number of coprime's upto N
+		public static long phi(long n)  //euler totient/phi function
+	    { 
+	       long ans = n;
+//	       for(long i = 2;i*i<=n;i++)
+//	       {
+//	    	   if(n%i == 0)
+//	    	   {
+//	    		   while(n%i == 0) n/=i;
+//	    		   ans -= (ans/i);
+//	    	   }
+//	       }
+//	       
+//	       if(n > 1)
+//	       {
+//	    	   ans -= (ans/n);
+//	       }
+	       
+	       for(long i = 2;i<=n;i++)
+	       {
+	    	   if(isPrime(i))
+	    	   {
+	    		   ans -= (ans/i);
+	    	   }
+	       }
+	       
+	       return ans;
+	       
+	    }	
+	
+	public static long fastPow(long x, long n) 
+	{
+		if(n == 0)
+			return 1;
+		else if(n%2 == 0)
+			return fastPow(x*x,n/2);
+		else
+			return x*fastPow(x*x,(n-1)/2);
+	}
+	
+	   public static long modPow(long x, long y, long p)
+	    {
+	        long res = 1;
+	        x = x % p;
+	 
+	        while (y > 0) {
+	            if (y % 2 == 1)
+	                res = (res * x) % p;
+	 
+	            y = y >> 1; 
+	            x = (x * x) % p;
+	        }
+	        return res;
+	    }
+	   
+	   static long modInverse(long n, long p)
+	    {
+	        return modPow(n, p - 2, p);
+	    }
+	 
+	    // Returns nCr % p using Fermat's little theorem.
+	    
+	    public static long nCrModP(long n, long r,long p)
+	    {
+	    	if (n<r) 
+	              return 0;
+	          
+	        if (r == 0)
+	            return 1;
+	 
+	        long[] fac = new long[(int)(n) + 1];
+	        fac[0] = 1;
+	 
+	        for (int i = 1; i <= n; i++)
+	            fac[i] = fac[i - 1] * i % p;
+	 
+	        return (fac[(int)(n)] * modInverse(fac[(int)(r)], p)
+	                % p * modInverse(fac[(int)(n - r)], p)
+	                % p)
+	            % p;
+	    }
+	    
+	    public static long fact(long n) 
+	    {
+	    	  long[] fac = new long[(int)(n) + 1];
+		        fac[0] = 1;
+		 
+		        for (long i = 1; i <= n; i++)
+		            fac[(int)(i)] = fac[(int)(i - 1)] * i;
+		        
+		        return fac[(int)(n)];
+		}
+	    
+	    public static long nCr(long n, long k) 
+	    {
+			long ans = 1;
+			for(long i = 0;i<k;i++)
+			{
+				ans *= (n-i);
+				ans /= (i+1);
+			}
+			return ans;
+		}
+ 
+		//Modular Operations for Addition and Multiplication. 
+		   public static long perfomMod(long x)
+		   {
+		        return ((x%M + M)%M);
+		    }
+		   public static long addMod(long a, long b)
+		   {
+		        return perfomMod(perfomMod(a)+perfomMod(b));
+		    }
+		  
+		   public static long subMod(long a, long b)
+		   {
+		        return perfomMod(perfomMod(a)-perfomMod(b));
+		   }
+		   
+		   public static long mulMod(long  a, long b)
+		   {
+		        return perfomMod(perfomMod(a)*perfomMod(b));
+		   }
+		   
+		   public static boolean isPrime(long n) 
+			{
+				if(n == 1)
+				{
+					return false;
+				}
+				
+				//check only for sqrt of the number as the divisors 
+				//keep repeating so only half of them are required. So,sqrt.
+				for(int i = 2;i*i<=n;i++)
+				{
+					if(n%i == 0)
+					{
+						return false;
+					}
+				}
+				return true;
+			}
+			
+			public static List<Integer> SieveList(int n)
+			{
+				boolean prime[] = new boolean[(int)(n+1)];
+				Arrays.fill(prime, true);
+				
+				List<Integer> l = new ArrayList<>();
+				for (int p = 2; p*p<=n; p++) 
+				{ 
+					if (prime[p] == true) 
+					{ 	
+					    for(int i = p*p; i<=n; i += p) 
+						{
+						    prime[i] = false; 
+						}	
+					} 
+				} 
+		 
+				for (int p = 2; p<=n; p++) 
+				{
+				    if (prime[p] == true)
+				    {
+				       l.add(p); 
+				    }
+				}
+				
+				return l;
+			}
+			
+			public static int countDivisors(int x)
+			{
+				int c = 0;
+				for(int i = 1;i*i<=x;i++)
+				{
+					if(x%i == 0)
+					{
+						if(x/i != i)
+						{
+							c+=2;
+						}
+						else 
+						{
+							c++;
+						}
+					}
+				}
+				return c;
+			}
+			
+			public static long log2(long n)
+		    {
+				 long ans = (long)(log(n)/log(2));
+				 return ans;
+			}
+			   
+			public static boolean isPow2(long n)
+			{
+				 return (n  != 0 && ((n & (n-1))) == 0);
+			}	
+		   
+		   public static boolean isSq(int x)  
+		   {
+			    long s = (long)Math.round(Math.sqrt(x));
+			    return s*s==x;
+		   }
+		
+			   /*
+			    * 
+			    * >=         <=
+			   0 1 2 3 4 5 6 7  
+			   5 5 5 6 6 6 7 7
+			   lower_bound for 6 at index 3 (>=)
+			   upper_bound for 6 at index 6(To get six reduce by one) (<=)
+			   */
+
+		   public static int LowerBound(int a[], int x) 
+		   {
+			      int l=-1,r=a.length;
+				  while(l+1<r) 
+				  {
+				    int m=(l+r)>>>1;
+				    if(a[m]>=x) r=m;
+				    else l=m;
+				  }
+				  return r;
+			}
+		   
+			public static int UpperBound(long a[], long x) 
+			{
+				int l=-1, r=a.length;
+			    while(l+1<r) 
+			    {
+			       int m=(l+r)>>>1;
+			       if(a[m]<=x) l=m;
+			       else r=m;
+			    }
+			    return l+1;
+			}
+			
+			public static void Sort(long[] a) 
+			{
+				List<Long> l = new ArrayList<>();
+				for (long i : a) l.add(i);
+				Collections.sort(l);
+//				Collections.reverse(l);  //Use to Sort decreasingly 
+				for (int i=0; i<a.length; i++) a[i]=l.get(i);
+			}
+			
+			public static void ssort(char[] a)
+			{
+				List<Character> l = new ArrayList<>();
+				for (char i : a) l.add(i);
+				Collections.sort(l);
+				for (int i=0; i<a.length; i++) a[i]=l.get(i);
+			}
+	
+	
+	public static void main(String[] args) throws Exception 
+	{
+		Reader sc = new Reader();
+		PrintWriter fout = new PrintWriter(System.out); 
+		
+		int tt = sc.nextInt();
+		while(tt-- > 0)
+		{
+	       int n = sc.nextInt();
+	       char[] a = sc.next().toCharArray(), b = sc.next().toCharArray();
+	       
+	       int c00 = 0, c01 = 0, c10 = 0, c11 = 0;
+	       for(int i = 0;i<n;i++)
+	       {
+	    	   if(a[i] == '0' && b[i] == '0')
+	    	   {
+	    		   c00++;
+	    	   }
+	    	   else if(a[i] == '0' && b[i] == '1')
+	    	   {
+	    		   c01++;
+	    	   }
+	    	   else if(a[i] == '1' && b[i] == '0')
+	    	   {
+	    		   c10++;
+	    	   }
+	    	   else if(a[i] == '1' && b[i] == '1')
+	    	   {
+	    		   c11++;
+	    	   }
+	       }
+	       
+	       int ans = mod;
+	       if(c01 == c10) ans = min(ans, c01 + c10);
+	       if(c11 == c00 + 1) ans = min(ans, c11 + c00);
+	       
+	       fout.println((ans == mod) ? -1 : ans);
+		}
+		
+		fout.close();
+	}
+}","/*****  --->         :)    Vijender  Srivastava      (:       <---       *****/
+import java.util.*;
+import java.lang.*;
+import java.io.*;
+public class Main  
+{
+    static FastReader sc =new FastReader();
+    static PrintWriter out=new PrintWriter(System.out);
+    static long mod=(long)1e9+7;
+    /* start */
+   
+       public static void main(String [] args)
+    {
+        // int testcases = 1;
+        int testcases = i();
+        while(testcases-->0)
+        {
+            
+            solve();
+        }
+        out.flush();
+        out.close();
+    }
+    static void solve()
+    { 
+        int n = i();
+        char c[] = inputC();
+        char d[] = inputC();
+        int x01=0,x10=0,x00=0,x11=0;
+        for(int i=0;i<n;i++)
+        {
+            if(c[i]=='0'&&d[i]=='0')x00++;
+            if(c[i]=='0'&&d[i]=='1')x01++;
+            if(c[i]=='1'&&d[i]=='0')x10++;
+            if(c[i]=='1'&&d[i]=='1')x11++;
+        }
+
+        int ans = Integer.MAX_VALUE;
+        if(x01==0 && x10==0)
+        {
+            pl(0);
+            return ;
+        }
+        if(x11==x00+1)
+        {
+            ans = min(x11+x00,ans);
+        }
+      if(x01==x10)
+        {
+            ans = min(x01+x10,ans);
+        }
+        if(ans == Integer.MAX_VALUE){
+            ans = -1;
+        }
+        pl(ans);
+    }
+    
+    /* end */
+    static class FastReader 
+    { 
+        BufferedReader br; 
+        StringTokenizer st; 
+
+        public FastReader() 
+        { 
+            br = new BufferedReader(new
+                     InputStreamReader(System.in)); 
+        } 
+
+        String next() 
+        { 
+            while (st == null || !st.hasMoreElements()) 
+            { 
+                try
+                { 
+                    st = new StringTokenizer(br.readLine()); 
+                } 
+                catch (IOException  e) 
+                { 
+                    e.printStackTrace(); 
+                } 
+            } 
+            return st.nextToken(); 
+        } 
+
+        int nextInt() 
+        { 
+            return Integer.parseInt(next()); 
+        } 
+
+        long nextLong() 
+        { 
+            return Long.parseLong(next()); 
+        } 
+
+        double nextDouble() 
+        { 
+            return Double.parseDouble(next()); 
+        } 
+
+        String nextLine() 
+        { 
+            String str = """"; 
+            try
+            { 
+                str = br.readLine(); 
+            } 
+            catch (IOException e) 
+            { 
+                e.printStackTrace(); 
+            } 
+            return str; 
+        } 
+    } 
+
+    static void p(Object o)
+    {
+        out.print(o);
+    }
+    static void pl(Object o)
+    {
+        out.println(o);
+    }
+    static int i() {
+        return sc.nextInt();
+    }
+
+    static String s() {
+        return sc.next();
+    }
+
+    static long l() {
+        return sc.nextLong();
+    }
+
+    static char[] inputC()
+    {
+        String s = sc.nextLine();
+        return s.toCharArray();
+    }
+
+    static int[] input(int n) {
+        int A[]=new int[n];
+           for(int i=0;i<n;i++) {
+               A[i]=sc.nextInt();
+           }
+        return A;
+    }
+
+    static long[] inputL(int n) {
+        long A[]=new long[n];
+           for(int i=0;i<n;i++) {
+               A[i]=sc.nextLong();
+           }
+           return A;
+    }
+
+    static long[] putL(long a[]) {
+        long A[]=new long[a.length];
+           for(int i=0;i<a.length;i++) {
+               A[i]=a[i];
+           }
+           return A;
+    }
+
+    static String[] inputS(int n) {
+        String A[]=new String[n];
+           for(int i=0;i<n;i++) {
+               A[i]=sc.next();
+           }
+           return A;
+    }
+      
+    static int gcd(int a, int b) 
+     { 
+         if (a == 0) 
+             return b; 
+         return gcd(b % a, a); 
+     } 
+
+     static long gcd(long a, long b) 
+     { 
+         if (a == 0) 
+             return b; 
+         return gcd(b % a, a); 
+     } 
+
+     static int lcm(int a, int b)
+    {
+        return (a / gcd(a, b)) * b;
+    }
+    
+     static String reverse(String s) {
+        StringBuffer p=new StringBuffer(s);
+        p.reverse();
+        return p.toString();
+     }
+
+     static int min(int a,int b) {
+        return Math.min(a, b);
+    }
+    static int min(int a,int b,int c) {
+        return Math.min(a, Math.min(b, c));
+    }
+    static int min(int a,int b,int c,int d) {
+        return Math.min(a, Math.min(b, Math.min(c, d)));
+    }
+
+    static int max(int a,int b) {
+        return Math.max(a, b);
+    }
+    static int max(int a,int b,int c) {
+        return Math.max(a, Math.max(b, c));
+    }
+    static int max(int a,int b,int c,int d) {
+        return Math.max(a, Math.max(b, Math.max(c, d)));
+    }
+    static long min(long a,long b) {
+        return Math.min(a, b);
+    }
+    static long min(long a,long b,long c) {
+        return Math.min(a, Math.min(b, c));
+    }
+    static long min(long a,long b,long c,long d) {
+        return Math.min(a, Math.min(b, Math.min(c, d)));
+    }
+    static long max(long a,long b) {
+        return Math.max(a, b);
+    }
+    static long max(long a,long b,long c) {
+        return Math.max(a, Math.max(b, c));
+    }
+    static long max(long a,long b,long c,long d) {
+        return Math.max(a, Math.max(b, Math.max(c, d)));
+    }
+
+    static long sum(int A[]) {
+        long sum=0;
+        for(int i : A) {
+            sum+=i;
+        }
+        return sum;
+    }
+
+    static long sum(long A[]) {
+        long sum=0;
+        for(long i : A) {
+            sum+=i;
+        }
+        return sum;
+    }
+
+    static void print(int A[]) {
+        for(int i : A) {
+            System.out.print(i+"" "");
+        }
+        System.out.println();
+    }
+
+    static void print(long A[]) {
+        for(long i : A) {
+            System.out.print(i+"" "");
+        }
+        System.out.println();
+    }
+
+    static long mod(long x) {
+          return ((x%mod + mod)%mod);
+    }
+
+    static long power(long x, long y)
+    {
+
+	if(y==0)
+		return 1;
+	if(x==0)
+		return 0;
+    long res = 1;
+    while (y > 0) {
+
+        if (y % 2 == 1)
+            res = (res * x) ;
+
+        y = y >> 1; 
+        x = (x * x);
+    }
+
+    return res;
+    }
+
+    static boolean prime(int n) 
+	    { 
+	        if (n <= 1) 
+	            return false; 
+	        if (n <= 3) 
+	            return true; 
+	        if (n % 2 == 0 || n % 3 == 0) 
+	            return false; 
+	        double sq=Math.sqrt(n);
+	  
+	        for (int i = 5; i <= sq; i = i + 6) 
+	            if (n % i == 0 || n % (i + 2) == 0) 
+	                return false; 
+	        return true; 
+	    } 
+
+     static boolean prime(long n) 
+	    { 
+	        if (n <= 1) 
+	            return false; 
+	        if (n <= 3) 
+	            return true; 
+	        if (n % 2 == 0 || n % 3 == 0) 
+	            return false; 
+	        double sq=Math.sqrt(n);
+	  
+	        for (int i = 5; i <= sq; i = i + 6) 
+	            if (n % i == 0 || n % (i + 2) == 0) 
+	                return false; 
+	        return true; 
+	    } 
+
+        static long[] sort(long a[]) {
+            ArrayList<Long> arr = new ArrayList<>();
+            for(long i : a) {
+                arr.add(i);
+            }
+            Collections.sort(arr);
+            for(int i = 0; i < arr.size(); i++) {
+                a[i] = arr.get(i);
+            }
+            return a;
+        }
+    
+        static int[] sort(int a[])
+        {
+            ArrayList<Integer> arr = new ArrayList<>();
+            for(Integer i : a) {
+                arr.add(i);
+            }
+            Collections.sort(arr);
+            for(int i = 0; i < arr.size(); i++) {
+                a[i] = arr.get(i);
+            }
+            return a;
+        }
+        //pair class
+        private static class Pair implements Comparable<Pair> {
+            long first, second;
+            public Pair(long f, long s) {
+                first = f;
+                second = s;
+            }
+            @Override
+            public int compareTo(Pair p) {
+                if (first > p.first)
+                    return 1;
+                else if (first < p.first)
+                    return -1;
+                else {
+                    if (second > p.second)
+                        return 1;
+                    else if (second < p.second)
+                        return -1;
+                    else
+                        return 0;
+                }
+            }
+     
+        }
+}",0
+42c7b9df,adbb2f71,"import java.io.OutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.PrintWriter;
+import java.util.InputMismatchException;
+import java.io.IOException;
+import java.io.InputStream;
+
+/**
+ * Built using CHelper plug-in
+ * Actual solution is at the top
+ */
+public class Main {
+    public static void main(String[] args) {
+        InputStream inputStream = System.in;
+        OutputStream outputStream = System.out;
+        InputReader in = new InputReader(inputStream);
+        PrintWriter out = new PrintWriter(outputStream);
+        CSbalansirovannieKuchkiKamnei solver = new CSbalansirovannieKuchkiKamnei();
+        int testCount = Integer.parseInt(in.next());
+        for (int i = 1; i <= testCount; i++)
+            solver.solve(i, in, out);
+        out.close();
+    }
+
+    static class CSbalansirovannieKuchkiKamnei {
+        public void solve(int testNumber, InputReader in, PrintWriter out) {
+            int n = in.nextInt();
+            long[] a = new long[n];
+            for (int i = 0; i < n; i++) {
+                a[i] = in.nextInt();
+            }
+            long t1 = 0;
+            long t2 = (int) 1e9 + 10;
+            long[] b = new long[n];
+            while (t1 < t2) {
+                long mid = (t1 + t2 + 1) / 2;
+                System.arraycopy(a, 0, b, 0, n);
+                boolean fine = true;
+                for (int i = n - 1; i >= 0; i--) {
+                    if (b[i] < mid) {
+                        fine = false;
+                        break;
+                    }
+                    if (i >= 2) {
+                        long how = Math.min(a[i], (b[i] - mid)) / 3;
+                        b[i - 1] += how;
+                        b[i - 2] += how * 2;
+                    }
+                }
+                if (fine) {
+                    t1 = mid;
+                } else {
+                    t2 = mid - 1;
+                }
+            }
+            out.println(t1);
+        }
+
+    }
+
+    static class InputReader {
+        private static final int BUFFER_LENGTH = 1 << 10;
+        private InputStream stream;
+        private byte[] buf = new byte[BUFFER_LENGTH];
+        private int curChar;
+        private int numChars;
+
+        public InputReader(InputStream stream) {
+            this.stream = stream;
+        }
+
+        private int nextC() {
+            if (numChars == -1) {
+                throw new InputMismatchException();
+            }
+            if (curChar >= numChars) {
+                curChar = 0;
+                try {
+                    numChars = stream.read(buf);
+                } catch (IOException e) {
+                    throw new InputMismatchException();
+                }
+                if (numChars <= 0)
+                    return -1;
+            }
+            return buf[curChar++];
+        }
+
+        public String next() {
+            int c = nextC();
+            while (isSpaceChar(c)) {
+                c = nextC();
+            }
+            StringBuilder res = new StringBuilder();
+            do {
+                res.append((char) c);
+                c = nextC();
+            } while (!isSpaceChar(c));
+            return res.toString();
+        }
+
+        public int nextInt() {
+            int c = skipWhileSpace();
+            int sgn = 1;
+            if (c == '-') {
+                sgn = -1;
+                c = nextC();
+            }
+            int res = 0;
+            do {
+                if (c < '0' || c > '9') {
+                    throw new InputMismatchException();
+                }
+                res *= 10;
+                res += c - '0';
+                c = nextC();
+            } while (!isSpaceChar(c));
+            return res * sgn;
+        }
+
+        public int skipWhileSpace() {
+            int c = nextC();
+            while (isSpaceChar(c)) {
+                c = nextC();
+            }
+            return c;
+        }
+
+        public boolean isSpaceChar(int c) {
+            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
+        }
+
+    }
+}
+
+","import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.StringTokenizer;
+import java.util.*;
+
+public class cp {
+    public static void main(String args[]) throws Exception {
+        FastScanner sc = new FastScanner();
+        int T = 1;
+        T = sc.nextInt();
+        PrintWriter pw = new PrintWriter(System.out);
+        StringBuilder sb = new StringBuilder();
+        while (T-- > 0) {
+            solve(sc, pw, sb);
+        }
+        pw.print(sb);
+        pw.close();
+    }
+    public static void solve(FastScanner sc, PrintWriter pw, StringBuilder sb) throws Exception {
+       int n=sc.nextInt();
+       int[] h=new int[n];
+       for(int i=0;i<n;i++){
+            h[i]=sc.nextInt();
+       }
+       long low=0,high=(long)1e12,ans=low;
+       while(low<=high){
+            long mid=low+(high-low)/2L;
+            if(ok(mid,h)){
+                ans=mid;
+                low=mid+1;
+            }
+            else{
+                high=mid-1;
+            }
+       }
+       sb.append(ans+""\n"");
+    }
+
+    public static boolean ok(long value,int[] h){
+        int n=h.length;
+        int[] copy=new int[n];
+        for(int i=0;i<n;i++){
+            copy[i]=h[i];
+        }
+        for(int i=n-1;i-2>=0;i--){
+            if(copy[i]<value) return false;
+            // we take this condition as the max stones that we can move is the number present in the heap not the copy by the condition di<=hi/3
+            long toSub=Math.min(copy[i]-value,h[i])/3L;
+            // System.out.println(""i: ""+i+"" toSub:""+toSub);
+            copy[i-1]+=toSub;
+            copy[i-2]+=toSub*2L;
+        }
+        // System.out.println(Arrays.toString(copy));
+        if(copy[0]<value || copy[1]<value) return false;
+        // System.out.println(""YES"");
+        return true;
+    }
+
+    
+
+    public static long[]  sort(long[] arr){
+        ArrayList<Long> temp = new ArrayList<>();
+        for(long x:arr) temp.add(x);
+        Collections.sort(temp);
+        int i=0;
+        for(long x:temp){
+            arr[i++]=x;
+        }
+        return arr;
+    }
+    public static int gcd(int a,int b){
+        if(b==0) return a;
+        return gcd(b,a%b);
+    }
+    static class FastScanner {
+        public BufferedReader reader;
+        public StringTokenizer tokenizer;
+
+        public FastScanner() {
+            reader = new BufferedReader(new InputStreamReader(System.in), 32768);
+            tokenizer = null;
+        }
+
+        public String next() {
+            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
+                try {
+                    tokenizer = new StringTokenizer(reader.readLine());
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+            }
+            return tokenizer.nextToken();
+        }
+
+        public int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        public long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        public double nextDouble() {
+            return Double.parseDouble(next());
+        }
+
+        public String nextLine() {
+            try {
+                return reader.readLine();
+            } catch (IOException e) {
+                throw new RuntimeException(e);
+            }
+        }
+
+        public int[] readIntArray(int n){
+            int[] arr=new int[n];
+            for(int i=0;i<n;i++){
+                arr[i]=nextInt();
+            }
+            return arr;
+        }
+
+        public long[] readLongArray(int n){
+            long[] arr=new long[n];
+            for(int i=0;i<n;i++){
+                arr[i]=nextLong();
+            }
+            return arr;
+        }
+    }
+}
+",0
+47d54299,63bfa731,"// package com.company.Codechef;
+
+// import com.sun.security.jgss.GSSUtil;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.*;
+
+public class a {
+
+   static int depth[];
+   static ArrayList<Integer> tree[];
+   static int diameter=0;
+
+    public static void main(String[] args) {
+        FastReader input=new FastReader();
+        int t=input.nextInt();
+        while (t-->0){
+            diameter=0;
+            int n=input.nextInt();
+            int a=input.nextInt();
+            int b=input.nextInt();
+            int da=input.nextInt();
+            int db=input.nextInt();
+            depth=new int[n+1];
+            tree=new ArrayList[n+1];
+            for (int i = 0; i <=n ; i++) {
+                tree[i]=new ArrayList<>();
+            }
+            for (int i = 0; i <n-1 ; i++) {
+                int x=input.nextInt();
+                int y=input.nextInt();
+                tree[x].add(y);
+                tree[y].add(x);
+            }
+            dfs(a,0);
+//            System.out.println(depth[b]);
+            if (2 * da >= Math.min(diameter, db) ||depth[b]<=da){
+                System.out.println(""Alice"");
+            }else {
+                System.out.println(""Bob"");
+            }
+
+
+
+       }
+
+    }
+
+    private static int dfs(int root, int p) {
+        int len=0;
+
+        for(int child:tree[root]){
+            if (child!=p){
+                depth[child]=depth[root]+1;
+
+                int curr=1+dfs(child,root);
+                diameter=Math.max(diameter,curr+len);
+                len=Math.max(len,curr);
+
+            }
+        }
+        return len;
+
+    }
+    static class FastReader
+    {
+        BufferedReader br;
+        StringTokenizer st;
+
+        public FastReader()
+        {
+            br = new BufferedReader(new
+                    InputStreamReader(System.in));
+        }
+
+        String next()
+        {
+            while (st == null || !st.hasMoreElements())
+            {
+                try
+                {
+                    st = new StringTokenizer(br.readLine());
+                }
+                catch (IOException e)
+                {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt()
+        {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong()
+        {
+            return Long.parseLong(next());
+        }
+
+        double nextDouble()
+        {
+            return Double.parseDouble(next());
+        }
+
+        String nextLine()
+        {
+            String str = """";
+            try
+            {
+                str = br.readLine();
+            }
+            catch (IOException e)
+            {
+                e.printStackTrace();
+            }
+            return str;
+        }
+    }
+
+}","
+import java.util.*;
+import java.io.*;
+
+public class D {
+    static ArrayList<Integer> adj[] = new ArrayList[(int)1e5+7];
+    static int diameter = 0;
+    static int[] depth = new int[(int)1e5 + 7];
+    public static void main(String[] args) {
+        FastReader in = new FastReader();
+        int t = in.nextInt();
+        while(t-- > 0){
+            int n = in.nextInt();
+            int a = in.nextInt(), b = in.nextInt(), da = in.nextInt(), db = in.nextInt();
+            for(int i = 1; i <= n; i++){
+                adj[i] = new ArrayList<>();
+            }
+            for(int i = 1; i <=n; i++){
+                adj[i].clear();
+            }
+            for(int i = 0; i < n- 1; i++){
+                int u = in.nextInt();
+                int v = in.nextInt();
+                adj[u].add(v);
+                adj[v].add(u);
+            }
+            diameter = 0;
+            depth[a] = 0;
+            dfs(a, -1);
+            System.out.println(2 * da >= Math.min(diameter, db) || depth[b] <= da ? ""Alice"" : ""Bob"");
+        }
+    }
+    static int dfs(int node, int parent){
+        int len = 0;
+        for(int x : adj[node]){
+            if(x != parent){
+                depth[x] = depth[node] + 1;
+                int cur = 1 + dfs(x, node);
+                diameter = Math.max(diameter, cur + len);
+                len = Math.max(len, cur);
+//                System.out.print(""x "" + x + "" node "" + node + "" par "" + parent);
+//                System.out.println("" cur "" + cur + "" len "" + len + "" diam "" + diameter);
+            }
+        }
+        return len;
+    }
+    static long getDigitSum(long n)
+    {
+        long sum = 0;
+
+        while (n > 0)
+        {
+            sum = sum + n % 10;
+            n = n/10;
+        }
+
+        return sum;
+    }
+
+    static class FastReader
+    {
+        BufferedReader br;
+        StringTokenizer st;
+
+        public FastReader()
+        {
+            br = new BufferedReader(new
+                    InputStreamReader(System.in));
+        }
+
+        String next()
+        {
+            while (st == null || !st.hasMoreElements())
+            {
+                try
+                {
+                    st = new StringTokenizer(br.readLine());
+                }
+                catch (IOException e)
+                {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt()
+        {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong()
+        {
+            return Long.parseLong(next());
+        }
+
+        double nextDouble()
+        {
+            return Double.parseDouble(next());
+        }
+
+        String nextLine()
+        {
+            String str = """";
+            try
+            {
+                str = br.readLine();
+            }
+            catch (IOException e)
+            {
+                e.printStackTrace();
+            }
+            return str;
+        }
+        int[] readArray(int n){
+            int[] a = new int[n];
+            for(int i = 0; i < n; i++){
+                a[i] = nextInt();
+            }
+            return a;
+        }
+    }
+}
+",1
+4a5b029f,fb05904c,"/* package whatever; // don't place package name! */
+
+import java.util.*;
+import java.lang.*;
+import java.io.*;
+
+/* Name of the class has to be ""Main"" only if the class is public. */
+public class Ideone
+{
+	public static void main (String[] args) throws java.lang.Exception
+	{
+		Scanner scn = new Scanner(System.in);
+		int t = scn.nextInt();
+		while(t>0){
+			int n = scn.nextInt();
+			String a = scn.next();
+			String b = scn.next();
+		
+	//	System.out.println(a);
+			int ob=0,oa=0,za=0;
+			for(int i=0;i<a.length();i++){
+				if(a.charAt(i)=='1'){
+					
+					oa++;
+				}else{
+					za++;
+				}
+			}
+			for(int i=0;i<b.length();i++){
+				if(b.charAt(i)=='1'){
+					ob++;	
+				}
+			}
+		//	System.out.println(ob+"" ""+za);
+			int min = Integer.MAX_VALUE;
+			if(ob==oa){
+				int op=0;
+				for(int i=0;i<a.length();i++){
+					if(a.charAt(i)!=b.charAt(i)){
+						op++;
+					}
+				}
+			
+				min = Math.min(min,op);
+			}
+			if(ob==za+1){
+				int op=0;
+				for(int i=0;i<n;i++){
+					if(a.charAt(i)==b.charAt(i)){
+						op++;
+					}
+				}
+				min = Math.min(min,op);
+			}
+			
+			if(min!=Integer.MAX_VALUE){
+				System.out.println(min);
+				}else{
+				System.out.println(-1);
+			}
+			t--;
+		}
+	}
+}","/*
+  Challenge 1: Newbie to CM in 1year (Dec 2021 - Nov 2022)   🔥 5* Codechef
+  Challenge 2: CM to IM in 1 year (Dec 2022 - Nov 2023)    🔥🔥 6* Codechef
+  Challenge 3: IM to GM in 1 year (Dec 2023 - Nov 2024)  🔥🔥🔥 7* Codechef
+  Goal: Become better in CP!
+  Key: Consistency!
+*/
+
+import java.util.*;
+import java.io.*;
+import java.math.*;
+
+public class Coder {
+
+  static int n;
+  static char a[];
+  static char b[];
+  static StringBuffer str=new StringBuffer();
+
+  static void solve(){
+    boolean flag=true;
+    for(int i=0;i<n;i++) if(a[i]!=b[i]) flag=false;
+    if(flag){str.append(""0\n""); return;}
+    int tot=0;
+    int tot1=0;
+    for(int i=0;i<n;i++) if(a[i]=='1') tot++;
+    for(int i=0;i<n;i++) if(b[i]=='1') tot1++;
+    if(tot==0){
+      if(tot1!=0) str.append(""-1\n"");
+      else str.append(""0\n"");
+    }else{
+      int x=tot-1;
+      int ul=n-tot;
+      if(tot!=tot1 && (ul+1)!=tot1) str.append(""-1\n"");
+      else{
+        int same=0, nsame=0;
+        int zs, os;
+        int zd, od;
+        zs=os=zd=od=0;
+        for(int i=0;i<n;i++){
+          if(a[i]==b[i]){
+            same++;
+            if(a[i]=='0') zs++;
+            else os++;
+          }
+          else{
+            nsame++;
+            if(a[i]=='0') zd++;
+            else od++;
+          }
+        }
+        
+        // else if(zd>0 && od>0 && os>0 && zs>0) str.append(Math.min(nsame, same)).append(""\n"");
+        // else if(zd>0 && od>0) str.append(nsame).append(""\n"");
+        // else if(zs>0 && os>0) str.append(same).append(""\n"");
+        // else str.append(""-1\n"");
+        if(same==1 && nsame==n-1 && os==1) str.append(""1\n"");
+        else if(zd==od && od>0 && os>0 && os-zs==1) str.append(Math.min(nsame, same)).append(""\n"");
+        else if(zd==od && od>0) str.append(nsame).append(""\n"");
+        else if(os>0 && os-zs==1) str.append(same).append(""\n"");
+        else str.append(""-1\n"");
+      }
+    } 
+  }
+
+  public static void main(String[] args) throws java.lang.Exception {
+    BufferedReader bf;
+    PrintWriter pw;
+    boolean lenv=false;
+    if(lenv){
+      bf = new BufferedReader(
+                          new FileReader(""input.txt""));
+      pw=new PrintWriter(new
+            BufferedWriter(new FileWriter(""output.txt"")));
+    }else{
+      bf = new BufferedReader(new InputStreamReader(System.in));
+      pw = new PrintWriter(new OutputStreamWriter(System.out));
+    }
+    
+    int t = Integer.parseInt(bf.readLine().trim());
+    while (t-- > 0) {
+      String st[]=bf.readLine().trim().split(""\\s+"");
+      n=Integer.parseInt(st[0]);
+      a=bf.readLine().trim().toCharArray();
+      b=bf.readLine().trim().toCharArray();
+      solve();
+    }
+    pw.println(str);
+    pw.flush();
+    // System.outin.print(str);
+  }
+}",0
+4851a411,e201bc2e,"import java.util.ArrayList;
+import java.util.HashMap;
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.StringTokenizer;
+import java.util.Arrays;
+import java.util.Random;
+import java.io.FileWriter;
+import java.io.PrintWriter;
+/*
+    Solution Created: 17:15:47 15/01/2022
+    Custom Competitive programming helper.
+*/
+
+public class Main {
+	static ArrayList<Integer> adj[];
+	static HashMap<Integer, HashMap<Integer, Integer>> mp;
+	public static void insert(int i, int j, int v) {
+		int a = Math.min(i, j), b = Math.max(i, j);
+		if(!mp.containsKey(a)) mp.put(a, new HashMap<>());
+		mp.get(a).put(b, v);
+	}
+	public static int get(int i, int j) {
+		int a = Math.min(i, j), b = Math.max(i, j);
+		return mp.get(a).get(b);
+	}
+	public static void dfs(int i, int p, boolean two) {
+		
+		for(int to : adj[i]) {
+			if(to == p) continue;
+			insert(i, to, two?2:3);
+			dfs(to,i,!two);
+			two = !two;
+		}
+	}
+	public static void solve() {
+		mp = new HashMap<>();
+		int n = in.nextInt();
+		adj = new ArrayList[n];
+		for(int i = 0; i<n; i++) adj[i] = new ArrayList<>();
+		int[][] e = new int[n-1][2];
+		int[] deg = new int[n];
+		for(int i = 0; i<n-1; i++) {
+			e[i] = in.na(2);
+			deg[--e[i][0]]++;
+			deg[--e[i][1]]++;
+			adj[e[i][0]].add(e[i][1]);
+			adj[e[i][1]].add(e[i][0]);
+		}
+		for(int i = 0; i<n; i++) {
+			if(deg[i]>=3) {
+				out.println(-1);
+				return;
+			}
+		}
+		dfs(0,-1,true);
+		for(int i = 0; i<n-1; i++) {
+			out.print(get(e[i][0], e[i][1])+"" "");
+		}
+		out.println();
+	}
+	
+	public static void main(String[] args) {
+		in = new Reader();
+		out = new Writer();
+		int t = in.nextInt();
+		while(t-->0) solve();
+		out.exit();
+	}
+	static Reader in; static Writer out;
+
+static class Reader {
+	static BufferedReader br;
+	static StringTokenizer st;
+	
+	public Reader() {
+		this.br = new BufferedReader(new InputStreamReader(System.in));
+	}
+	
+	public Reader(String f){
+		try {
+			this.br = new BufferedReader(new FileReader(f));
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+	}
+	
+	public int[] na(int n) {
+		int[] a = new int[n];
+		for (int i = 0; i < n; i++) a[i] = nextInt();
+		return a;
+	}
+
+	public double[] nd(int n) {
+		double[] a = new double[n];
+		for (int i = 0; i < n; i++) a[i] = nextDouble();
+		return a;
+	}
+	
+	public long[] nl(int n) {
+		long[] a = new long[n];
+		for (int i = 0; i < n; i++) a[i] = nextLong();
+		return a;
+	}
+
+	public char[] nca() {
+		return next().toCharArray();
+	}
+
+	public String[] ns(int n) {
+		String[] a = new String[n];
+		for (int i = 0; i < n; i++) a[i] = next();
+		return a;
+	}
+
+	public int nextInt() {
+		ensureNext();
+		return Integer.parseInt(st.nextToken());
+	}
+
+	public double nextDouble() {
+		ensureNext();
+		return Double.parseDouble(st.nextToken());
+	}
+
+	public Long nextLong() {
+		ensureNext();
+		return Long.parseLong(st.nextToken());
+	}
+
+	public String next() {
+		ensureNext();
+		return st.nextToken();
+	}
+	
+	public String nextLine() {
+		try {
+			return br.readLine();
+		} catch (Exception e) {
+			e.printStackTrace();
+			return null;
+		}
+	}
+	
+	private void ensureNext() {
+		if (st == null || !st.hasMoreTokens()) {
+			try {
+				st = new StringTokenizer(br.readLine());
+			} catch (IOException e) {
+				e.printStackTrace();
+			}
+		}
+	}
+}
+
+static class Util{
+		private static Random random = new Random();
+		static long[] fact;
+		
+		public static void initFactorial(int n, long mod) {
+			fact = new long[n+1];
+			fact[0] = 1;
+			for (int i = 1; i < n+1; i++) fact[i] = (fact[i - 1] * i) % mod;
+		}
+		
+		public static long modInverse(long a, long MOD) {
+			long[] gcdE = gcdExtended(a, MOD);
+			if (gcdE[0] != 1) return -1; // Inverted doesn't exist
+			long x = gcdE[1];
+			return (x % MOD + MOD) % MOD;
+		}
+		
+		public static long[] gcdExtended(long p, long q) {
+			if (q == 0) return new long[] { p, 1, 0 };
+			long[] vals = gcdExtended(q, p % q);
+			long tmp = vals[2];
+			vals[2] = vals[1] - (p / q) * vals[2];
+			vals[1] = tmp;
+			return vals;
+		}
+		
+		public static long nCr(int n, int r, long MOD) {
+			if (r == 0) return 1;
+			return (fact[n] * modInverse(fact[r], MOD) % MOD * modInverse(fact[n - r], MOD) % MOD) % MOD;
+		}
+		
+		public static long nCr(int n, int r) {
+			return (fact[n]/fact[r])/fact[n-r];
+		}
+		
+		public static long nPr(int n, int r, long MOD) {
+			if (r == 0) return 1;
+			return (fact[n] * modInverse(fact[n - r], MOD) % MOD) % MOD;
+		}
+		public static long nPr(int n, int r) {
+			return fact[n]/fact[n-r];
+		}
+		
+		public static boolean isPrime(int n) { 
+	        if (n <= 1) return false; 
+	        if (n <= 3) return true; 
+	        if (n % 2 == 0 || n % 3 == 0) return false; 
+	        for (int i = 5; i * i <= n; i = i + 6) 
+	            if (n % i == 0 || n % (i + 2) == 0) 
+	            return false; 
+	        return true; 
+	    }
+		
+	    public static boolean[] getSieve(int n) {
+	        boolean[] isPrime = new boolean[n+1];
+	        for (int i = 2; i <= n; i++) isPrime[i] = true;
+	        for (int i = 2; i*i <= n; i++) if (isPrime[i]) 
+	                for (int j = i; i*j <= n; j++) isPrime[i*j] = false;
+	        return isPrime;
+	    }
+	    
+	    static long pow(long x, long pow, long mod){
+	    	long res = 1;
+	    	x = x % mod;
+	    	if (x == 0) return 0;
+	    	while (pow > 0){
+	    		if ((pow & 1) != 0) res = (res * x) % mod;
+	        	pow >>= 1;
+	        	x = (x * x) % mod;
+	    	}
+	    	return res;
+	    }
+	    
+	    public static int gcd(int a, int b) { 
+	    	int tmp = 0;
+	    	while(b != 0) {
+	    		tmp = b;
+	    		b = a%b;
+	    		a = tmp;
+	    	}
+	    	return a;
+	    }
+	    
+	    public static long gcd(long a, long b) { 
+	    	long tmp = 0;
+	    	while(b != 0) {
+	    		tmp = b;
+	    		b = a%b;
+	    		a = tmp;
+	    	}
+	    	return a;
+	    }
+	    
+	    public static int random(int min, int max) {
+	    	return random.nextInt(max-min+1)+min;
+	    }
+	    
+		public static void dbg(Object... o) { 
+			System.out.println(Arrays.deepToString(o)); 
+		}
+		
+		public static void reverse(int[] s, int l , int r) {
+			for(int i = l; i<=(l+r)/2; i++) {
+				int tmp = s[i];
+				s[i] = s[r+l-i];
+				s[r+l-i] = tmp;
+			}
+	    }
+		
+		public static void reverse(int[] s) {
+			reverse(s, 0, s.length-1);
+	    }
+		
+		public static void reverse(long[] s, int l , int r) {
+			for(int i = l; i<=(l+r)/2; i++) {
+				long tmp = s[i];
+				s[i] = s[r+l-i];
+				s[r+l-i] = tmp;
+			}
+	    }
+		
+		public static void reverse(long[] s) {
+			reverse(s, 0, s.length-1);
+	    }
+		
+		public static void reverse(float[] s, int l , int r) {
+			for(int i = l; i<=(l+r)/2; i++) {
+				float tmp = s[i];
+				s[i] = s[r+l-i];
+				s[r+l-i] = tmp;
+			}
+	    }
+		
+		public static void reverse(float[] s) {
+			reverse(s, 0, s.length-1);
+	    }
+		
+		public static void reverse(double[] s, int l , int r) {
+			for(int i = l; i<=(l+r)/2; i++) {
+				double tmp = s[i];
+				s[i] = s[r+l-i];
+				s[r+l-i] = tmp;
+			}
+	    }
+		
+		public static void reverse(double[] s) {
+			reverse(s, 0, s.length-1);
+	    }
+		
+		public static void reverse(char[] s, int l , int r) {
+			for(int i = l; i<=(l+r)/2; i++) {
+				char tmp = s[i];
+				s[i] = s[r+l-i];
+				s[r+l-i] = tmp;
+			}
+	    }
+		
+		public static void reverse(char[] s) {
+			reverse(s, 0, s.length-1);
+	    }
+		
+		public static <T> void reverse(T[] s, int l , int r) {
+			for(int i = l; i<=(l+r)/2; i++) {
+				T tmp = s[i];
+				s[i] = s[r+l-i];
+				s[r+l-i] = tmp;
+			}
+	    }
+		
+		public static <T> void reverse(T[] s) {
+			reverse(s, 0, s.length-1);
+	    }
+		
+		public static void shuffle(int[] s) {
+	        for (int i = 0; i < s.length; ++i) {
+	            int j = random.nextInt(i + 1);
+	            int t = s[i];
+	            s[i] = s[j];
+	            s[j] = t;
+	        }
+	    }
+		
+	    public static void shuffle(long[] s) {
+	        for (int i = 0; i < s.length; ++i) {
+	            int j = random.nextInt(i + 1);
+	            long t = s[i];
+	            s[i] = s[j];
+	            s[j] = t;
+	        }
+	    }
+	    
+	    public static void shuffle(float[] s) {
+	        for (int i = 0; i < s.length; ++i) {
+	            int j = random.nextInt(i + 1);
+	            float t = s[i];
+	            s[i] = s[j];
+	            s[j] = t;
+	        }
+	    }
+	    
+	    public static void shuffle(double[] s) {
+	        for (int i = 0; i < s.length; ++i) {
+	            int j = random.nextInt(i + 1);
+	            double t = s[i];
+	            s[i] = s[j];
+	            s[j] = t;
+	        }
+	    }
+	    
+	    public static void shuffle(char[] s) {
+	        for (int i = 0; i < s.length; ++i) {
+	            int j = random.nextInt(i + 1);
+	            char t = s[i];
+	            s[i] = s[j];
+	            s[j] = t;
+	        }
+	    }
+	    
+	    public static <T> void shuffle(T[] s) {
+	        for (int i = 0; i < s.length; ++i) {
+	            int j = random.nextInt(i + 1);
+	            T t = s[i];
+	            s[i] = s[j];
+	            s[j] = t;
+	        }
+	    }
+	    
+		public static void sortArray(int[] a) {
+	        shuffle(a);
+	        Arrays.sort(a);
+	    }
+		
+		public static void sortArray(long[] a) {
+			shuffle(a);
+	        Arrays.sort(a);
+	    }
+		
+		public static void sortArray(float[] a) {
+			shuffle(a);
+	        Arrays.sort(a);
+	    }
+		
+		public static void sortArray(double[] a) {
+			shuffle(a);
+	        Arrays.sort(a);
+	    }
+		
+		public static void sortArray(char[] a) {
+			shuffle(a);
+	        Arrays.sort(a);
+	    }
+		
+		public static <T extends Comparable<T>> void sortArray(T[] a) {
+	        Arrays.sort(a);
+	    }
+		
+		public static int[][] rotate90(int[][] a){
+			int n = a.length, m = a[0].length;
+			int[][] ans = new int[m][n];
+			for(int i = 0; i<n; i++) for(int j = 0; j<m; j++) ans[m-j-1][i] = a[i][j];
+			return ans;
+		}
+		
+		public static char[][] rotate90(char[][] a){
+			int n = a.length, m = a[0].length;
+			char[][] ans = new char[m][n];
+			for(int i = 0; i<n; i++) for(int j = 0; j<m; j++) ans[m-j-1][i] = a[i][j];
+			return ans;
+		}
+	}
+
+static class Writer {
+	private PrintWriter pw;
+	public Writer(){
+		pw = new PrintWriter(System.out);
+	}
+	
+	public Writer(String f){
+		try {
+			pw = new PrintWriter(new FileWriter(f));
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+	}
+	
+	public void yesNo(boolean condition) {
+		println(condition?""YES"":""NO"");
+	}
+	
+	public void printArray(int[] a) {
+		for(int i = 0; i<a.length; i++) print(a[i]+"" "");
+	}
+	
+	public void printlnArray(int[] a) {
+		for(int i = 0; i<a.length; i++) print(a[i]+"" "");
+		pw.println();
+	}
+	
+	public void printArray(long[] a) {
+		for(int i = 0; i<a.length; i++) print(a[i]+"" "");
+	}
+	
+	public void printlnArray(long[] a) {
+		for(int i = 0; i<a.length; i++) print(a[i]+"" "");
+		pw.println();
+	}
+	
+	public void print(Object o) {
+		pw.print(o.toString());
+	}
+	
+	public void println(Object o) {
+		pw.println(o.toString());
+	}
+	
+	public void println() {
+		pw.println();
+	}
+	
+	public void flush() {
+		pw.flush();
+	}
+	public void exit() {
+		pw.close();
+	}
+}
+}
+","import java.util.*;
+import java.util.Scanner;
+
+
+public class Solution {
+	static int mod=1000000007;;
+	
+//	 
+	public static void main(String[] args) {
+		// TODO Auto-generated method stub
+//		System.out.println();
+
+		Scanner sc=new Scanner(System.in);
+		int tt=sc.nextInt();
+//		
+//		
+		while(tt-->0){
+			int n=sc.nextInt();
+			
+			int degree[]=new int[n];
+			
+			Arrays.fill(degree, 0);
+			int u[]=new int[n-1];
+			int v[]=new int[n-1];
+			boolean brea=false;
+			HashMap<Integer,LinkedList<Integer>>graph=new HashMap<>();
+			for(int i=0;i<n-1;i++) {
+				u[i]=sc.nextInt();
+				v[i]=sc.nextInt();
+				u[i]--;
+				v[i]--;
+				
+				if(graph.containsKey(u[i])) {
+					LinkedList<Integer> ll=graph.get(u[i]);
+					ll.add(i);
+					graph.put(u[i],ll);
+				}
+				else {
+					LinkedList<Integer> ll=new LinkedList<>();
+					ll.add(i);
+					graph.put(u[i],ll);
+				}
+				if(graph.containsKey(v[i])) {
+					LinkedList<Integer> ll=graph.get(v[i]);
+					ll.add(i);
+					graph.put(v[i],ll);
+				}
+				else {
+					LinkedList<Integer> ll=new LinkedList<>();
+					ll.add(i);
+					graph.put(v[i],ll);
+				}
+				
+				
+				
+				degree[u[i]]++;
+				if(degree[u[i]]>2)brea=true;
+				degree[v[i]]++;
+				if(degree[v[i]]>2)brea=true;
+			}
+			
+			if(brea) {
+				System.out.println(-1);
+				continue;
+			}
+			
+			
+			
+			int i;
+			for( i=0;i<n;i++) {
+				
+				if(degree[i]==1)break;
+				
+			}
+//			System.out.println(graph+"" ""+i);
+			
+			int ans[]=new int[n-1];
+			int ind=graph.get(i).get(0);
+			ans[ind]=2;
+			
+			if(u[ind]==i)i=v[ind];
+			else i=u[ind];
+			
+			boolean flip=true;
+			
+			while(graph.get(i).size()>1) {
+				
+				if(graph.get(i).get(0)==ind) {
+					ind=graph.get(i).get(1);
+				}
+				else {
+					ind=graph.get(i).get(0);
+				}
+				
+				if(flip) {
+					ans[ind]=3;
+				}else ans[ind]=2;
+				
+				flip=!flip;
+				
+				
+				if(u[ind]==i)i=v[ind];
+				else i=u[ind];
+				
+			}
+			
+			
+			 
+			for(int j:ans)
+			 System.out.print(j+"" "");
+			 System.out.println();
+			
+		
+			
+		}
+	}
+		
+		
+	
+		
+		
+	
+	
+	
+
+
+}
+",0
+39073790,d735b078,"import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.PrintWriter;
+import java.math.BigInteger;
+import java.util.*;
+
+
+public class DisJump {
+
+    public static void main(String[] args) {
+
+        InputStream inputStream = System.in;
+        OutputStream outputStream = System.out;
+        InputReader sc = new InputReader(inputStream);
+        PrintWriter out = new PrintWriter(outputStream);
+        Solver solver = new Solver();
+//		int t = sc.nextInt();
+        int t = 1;
+        while (t-- != 0) {
+            solver.solve(sc, out);
+        }
+        out.close();
+
+    }
+
+    static class Node {
+        int v, dis;
+
+        public Node(int v, int dis) {
+            this.v = v;
+            this.dis = dis;
+        }
+    }
+
+    static class Solver {
+        public void solve(InputReader sc, PrintWriter out) {
+            int n = sc.nextInt();
+            int[] h = sc.nextIntArray(n);
+            ArrayList<Integer>[] g = new ArrayList[n];
+            for(int i = 0; i < n; i++) g[i] = new ArrayList<>();
+            for(int rot = 0; rot < 2; rot++) {
+                int[] stk = new int[n];
+                int at = -1;
+                for(int i = 0; i < n; i++) {
+                    while (at!=-1 && h[stk[at]]<h[i]) g[stk[at--]].add(i);
+                    if(at!=-1) {
+                        g[stk[at]].add(i);
+                        if(h[stk[at]]==h[i]) at--;
+                    }
+                    stk[++at] = i;
+                }
+                for(int i = 0; i < n; i++) h[i] = -h[i];
+            }
+            int[] qu = new int[n];
+            int[] dist = new int[n];
+            Arrays.fill(dist,-1);
+            int qTop = 0;
+            int qEnd = 1;
+            qu[0] = 0;
+            dist[0] = 0;
+            while (qTop<qEnd) {
+                int front = qu[qTop];
+                for(int v : g[front]) {
+                    if(dist[v]==-1) {
+                        qu[qEnd] = v;
+                        dist[v] = dist[front]+1;
+                        qEnd++;
+                    }
+                }
+                qTop++;
+            }
+            out.println(dist[n-1]);
+        }
+    }
+
+    static void sort(int[] arr) {
+        Random rand = new Random();
+        int n = arr.length;
+        for (int i = 0; i < n; i++) {
+            int idx = rand.nextInt(n);
+            if (idx == i) continue;
+            arr[i] ^= arr[idx];
+            arr[idx] ^= arr[i];
+            arr[i] ^= arr[idx];
+        }
+        Arrays.sort(arr);
+    }
+
+    static void sort(long[] arr) {
+        Random rand = new Random();
+        int n = arr.length;
+        for (int i = 0; i < n; i++) {
+            int idx = rand.nextInt(n);
+            if (idx == i) continue;
+            arr[i] ^= arr[idx];
+            arr[idx] ^= arr[i];
+            arr[i] ^= arr[idx];
+        }
+        Arrays.sort(arr);
+    }
+
+    static void sortDec(int[] arr) {
+        Random rand = new Random();
+        int n = arr.length;
+        for (int i = 0; i < n; i++) {
+            int idx = rand.nextInt(n);
+            if (idx == i) continue;
+            arr[i] ^= arr[idx];
+            arr[idx] ^= arr[i];
+            arr[i] ^= arr[idx];
+        }
+        Arrays.sort(arr);
+        int l = 0;
+        int r = n - 1;
+        while (l < r) {
+            int tmp = arr[l];
+            arr[l] = arr[r];
+            arr[r] = tmp;
+            l++;
+            r--;
+        }
+    }
+
+    static void sortDec(long[] arr) {
+        Random rand = new Random();
+        int n = arr.length;
+        for (int i = 0; i < n; i++) {
+            int idx = rand.nextInt(n);
+            if (idx == i) continue;
+            arr[i] ^= arr[idx];
+            arr[idx] ^= arr[i];
+            arr[i] ^= arr[idx];
+        }
+        Arrays.sort(arr);
+        int l = 0;
+        int r = n - 1;
+        while (l < r) {
+            long tmp = arr[l];
+            arr[l] = arr[r];
+            arr[r] = tmp;
+            l++;
+            r--;
+        }
+    }
+
+    static class InputReader {
+        private boolean finished = false;
+
+        private InputStream stream;
+        private byte[] buf = new byte[1024];
+        private int curChar;
+        private int numChars;
+        private SpaceCharFilter filter;
+
+        public InputReader(InputStream stream) {
+            this.stream = stream;
+        }
+
+        public int read() {
+            if (numChars == -1) {
+                throw new InputMismatchException();
+            }
+            if (curChar >= numChars) {
+                curChar = 0;
+                try {
+                    numChars = stream.read(buf);
+                } catch (IOException e) {
+                    throw new InputMismatchException();
+                }
+                if (numChars <= 0) {
+                    return -1;
+                }
+            }
+            return buf[curChar++];
+        }
+
+        public int peek() {
+            if (numChars == -1) {
+                return -1;
+            }
+            if (curChar >= numChars) {
+                curChar = 0;
+                try {
+                    numChars = stream.read(buf);
+                } catch (IOException e) {
+                    return -1;
+                }
+                if (numChars <= 0) {
+                    return -1;
+                }
+            }
+            return buf[curChar];
+        }
+
+        public int nextInt() {
+            int c = read();
+            while (isSpaceChar(c)) {
+                c = read();
+            }
+            int sgn = 1;
+            if (c == '-') {
+                sgn = -1;
+                c = read();
+            }
+            int res = 0;
+            do {
+                if (c < '0' || c > '9') {
+                    throw new InputMismatchException();
+                }
+                res *= 10;
+                res += c - '0';
+                c = read();
+            } while (!isSpaceChar(c));
+            return res * sgn;
+        }
+
+        public long nextLong() {
+            int c = read();
+            while (isSpaceChar(c)) {
+                c = read();
+            }
+            int sgn = 1;
+            if (c == '-') {
+                sgn = -1;
+                c = read();
+            }
+            long res = 0;
+            do {
+                if (c < '0' || c > '9') {
+                    throw new InputMismatchException();
+                }
+                res *= 10;
+                res += c - '0';
+                c = read();
+            } while (!isSpaceChar(c));
+            return res * sgn;
+        }
+
+        public String nextString() {
+            int c = read();
+            while (isSpaceChar(c)) {
+                c = read();
+            }
+            StringBuilder res = new StringBuilder();
+            do {
+                if (Character.isValidCodePoint(c)) {
+                    res.appendCodePoint(c);
+                }
+                c = read();
+            } while (!isSpaceChar(c));
+            return res.toString();
+        }
+
+        public boolean isSpaceChar(int c) {
+            if (filter != null) {
+                return filter.isSpaceChar(c);
+            }
+            return isWhitespace(c);
+        }
+
+        public static boolean isWhitespace(int c) {
+            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
+        }
+
+        private String readLine0() {
+            StringBuilder buf = new StringBuilder();
+            int c = read();
+            while (c != '\n' && c != -1) {
+                if (c != '\r') {
+                    buf.appendCodePoint(c);
+                }
+                c = read();
+            }
+            return buf.toString();
+        }
+
+        public String readLine() {
+            String s = readLine0();
+            while (s.trim().length() == 0) {
+                s = readLine0();
+            }
+            return s;
+        }
+
+        public String readLine(boolean ignoreEmptyLines) {
+            if (ignoreEmptyLines) {
+                return readLine();
+            } else {
+                return readLine0();
+            }
+        }
+
+        public BigInteger readBigInteger() {
+            try {
+                return new BigInteger(nextString());
+            } catch (NumberFormatException e) {
+                throw new InputMismatchException();
+            }
+        }
+
+        public char nextCharacter() {
+            int c = read();
+            while (isSpaceChar(c)) {
+                c = read();
+            }
+            return (char) c;
+        }
+
+        public double nextDouble() {
+            int c = read();
+            while (isSpaceChar(c)) {
+                c = read();
+            }
+            int sgn = 1;
+            if (c == '-') {
+                sgn = -1;
+                c = read();
+            }
+            double res = 0;
+            while (!isSpaceChar(c) && c != '.') {
+                if (c == 'e' || c == 'E') {
+                    return res * Math.pow(10, nextInt());
+                }
+                if (c < '0' || c > '9') {
+                    throw new InputMismatchException();
+                }
+                res *= 10;
+                res += c - '0';
+                c = read();
+            }
+            if (c == '.') {
+                c = read();
+                double m = 1;
+                while (!isSpaceChar(c)) {
+                    if (c == 'e' || c == 'E') {
+                        return res * Math.pow(10, nextInt());
+                    }
+                    if (c < '0' || c > '9') {
+                        throw new InputMismatchException();
+                    }
+                    m /= 10;
+                    res += (c - '0') * m;
+                    c = read();
+                }
+            }
+            return res * sgn;
+        }
+
+        public boolean isExhausted() {
+            int value;
+            while (isSpaceChar(value = peek()) && value != -1) {
+                read();
+            }
+            return value == -1;
+        }
+
+        public String next() {
+            return nextString();
+        }
+
+        public SpaceCharFilter getFilter() {
+            return filter;
+        }
+
+        public void setFilter(SpaceCharFilter filter) {
+            this.filter = filter;
+        }
+
+        public interface SpaceCharFilter {
+            public boolean isSpaceChar(int ch);
+        }
+
+        public int[] nextIntArray(int n) {
+            int[] array = new int[n];
+            for (int i = 0; i < n; ++i) array[i] = nextInt();
+            return array;
+        }
+
+        public int[] nextSortedIntArray(int n) {
+            int array[] = nextIntArray(n);
+            Arrays.sort(array);
+            return array;
+        }
+
+        public int[] nextSumIntArray(int n) {
+            int[] array = new int[n];
+            array[0] = nextInt();
+            for (int i = 1; i < n; ++i) array[i] = array[i - 1] + nextInt();
+            return array;
+        }
+
+        public long[] nextLongArray(int n) {
+            long[] array = new long[n];
+            for (int i = 0; i < n; ++i) array[i] = nextLong();
+            return array;
+        }
+
+        public long[] nextSumLongArray(int n) {
+            long[] array = new long[n];
+            array[0] = nextInt();
+            for (int i = 1; i < n; ++i) array[i] = array[i - 1] + nextInt();
+            return array;
+        }
+
+        public long[] nextSortedLongArray(int n) {
+            long array[] = nextLongArray(n);
+            Arrays.sort(array);
+            return array;
+        }
+    }
+
+
+}
+","import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.math.BigInteger;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Stack;
+import java.util.StringTokenizer;
+
+// 1 0 1 0 0
+public class D {
+
+	// Right side greater
+	public static int[] rightGreaterEle(long[] a) {
+		int n = a.length;
+		int ans[] = new int[n];
+		ans[n - 1] = -1;
+		Stack<Integer> st = new Stack<>();
+		st.add(n - 1);
+		for (int i = n - 2; i >= 0; i--) {
+			if (st.isEmpty() || a[st.peek()] >= a[i]) {
+				ans[i] = st.peek();
+				st.push(i);
+			} else {
+
+				while (!st.isEmpty() && a[st.peek()] < a[i]) {
+					st.pop();
+				}
+				if (st.isEmpty())
+					ans[i] = -1;
+				else
+					ans[i] = st.peek();
+				st.push(i);
+			}
+		}
+		return ans;
+
+	}
+
+	// Right side smaller
+	public static int[] rightSideSmaller(long[] a) {
+		int n = a.length;
+		int ans[] = new int[n];
+		ans[n - 1] = -1;
+		Stack<Integer> st = new Stack<>();
+		st.add(n - 1);
+		for (int i = n - 2; i >= 0; i--) {
+			if (st.isEmpty() || a[st.peek()] <= a[i]) {
+				ans[i] = st.peek();
+				st.push(i);
+			} else {
+
+				while (!st.isEmpty() && a[st.peek()] > a[i]) {
+					st.pop();
+				}
+				if (st.isEmpty())
+					ans[i] = -1;
+				else
+					ans[i] = st.peek();
+				st.push(i);
+			}
+		}
+		return ans;
+
+	}
+
+	// Left side greater
+	public static int[] leftSideGreater(long[] a) {
+		int n = a.length;
+		int ans[] = new int[n];
+		ans[0] = -1;
+		Stack<Integer> st = new Stack<>();
+		st.push(0);
+		for (int i = 1; i < n; i++) {
+			if (st.isEmpty() || a[st.peek()] >= a[i]) {
+				ans[i] = st.peek();
+				st.push(i);
+			} else {
+
+				while (!st.isEmpty() && a[st.peek()] < a[i]) {
+					st.pop();
+				}
+				if (st.isEmpty())
+					ans[i] = -1;
+				else
+					ans[i] = st.peek();
+				st.push(i);
+			}
+		}
+		return ans;
+
+	}
+
+	// Left side smaller
+	public static int[] leftSideSmaller(long[] a) {
+		int n = a.length;
+		int ans[] = new int[n];
+		ans[0] = -1;
+		Stack<Integer> st = new Stack<>();
+		st.push(0);
+		for (int i = 1; i < n; i++) {
+			if (st.isEmpty() || a[st.peek()] <= a[i]) {
+				ans[i] = st.peek();
+				st.push(i);
+			} else {
+
+				while (!st.isEmpty() && a[st.peek()] > a[i]) {
+					st.pop();
+				}
+				if (st.isEmpty())
+					ans[i] = -1;
+				else
+					ans[i] = st.peek();
+				st.push(i);
+			}
+		}
+		return ans;
+
+	}
+
+	public static void main(String[] args) {
+		FastScanner sc = new FastScanner();
+		int n = sc.nextInt();
+		long a[] = new long[n];
+		for (int i = 0; i < n; i++)
+			a[i] = sc.nextLong();
+
+		int rg[] = rightGreaterEle(a);
+		int rs[] = rightSideSmaller(a);
+
+		int lg[] = leftSideGreater(a);
+		int ls[] = leftSideSmaller(a);
+
+		int dp[] = new int[n];
+		Arrays.fill(dp, Integer.MAX_VALUE);
+
+		dp[0] = 0;
+		for(int i=1;i<n;i++) dp[i]=dp[i-1]+1;
+		
+		for (int i = 0; i < n; i++) {
+			
+		
+			// Where from we can reach at ith index
+			//System.out.println(l1+"" ""+l2+"" ""+r1+"" ""+r2);
+			int l1 = ls[i], l2 = lg[i];
+			if (l1 != -1)
+				dp[i] = Math.min(dp[i], dp[l1] + 1);
+			if (l2 != -1)
+				dp[i] = Math.min(dp[i], dp[l2] + 1);
+
+			//System.out.println(""from left ""+dp[i]);
+			int r1 = rs[i], r2 = rg[i];
+
+			if (r1 != -1)
+				dp[r1] = Math.min(dp[r1], dp[i] + 1);
+			if (r2 != -1)
+				dp[r2] = Math.min(dp[r2], dp[i] + 1);
+			
+//			if(i==4)
+//			System.out.println(dp[l1]+"" ""+dp[l2]+"" ""+dp[r1]+"" ""+dp[r2]);
+//			System.out.println((i+1)+"" ""+dp[i]);
+
+		}
+		System.out.println(dp[n-1]);
+
+	}
+
+	static class FastScanner {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st = new StringTokenizer("""");
+
+		String next() {
+			while (!st.hasMoreTokens())
+				try {
+					st = new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			return st.nextToken();
+		}
+
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+
+		int[] readArray(int n) {
+			int[] a = new int[n];
+			for (int i = 0; i < n; i++)
+				a[i] = nextInt();
+			return a;
+		}
+
+		long[] readLongArray(int n) {
+			long[] a = new long[n];
+			for (int i = 0; i < n; i++)
+				a[i] = nextLong();
+			return a;
+		}
+
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+	}
+
+}
+",0
+ca0c55ad,e14d1ba0,"import java.util.*;
+public class ss
+{
+    public static void main(String[]args)
+    {
+        Scanner in=new Scanner (System.in);
+        int t=in.nextInt();
+        for(int i1=0;i1<t;i1++)
+        {
+            int n=in.nextInt();
+	
+	long[] ar=new long[n];
+	
+	for(int i=0;i<n;i++)
+	{
+		ar[i]=in.nextLong();
+		
+	}
+	
+	long[] ans=new long[n];
+	ans[0]=ar[0]*n;
+	long m=ar[0];
+	long s1=ar[0];
+	for(int i=2;i<n;i+=2)
+	{
+		if(m>ar[i])
+		{
+			m=ar[i];
+		}
+		s1+=ar[i];
+		ans[i]=s1-m+m*(n-i/2);
+
+		
+
+
+	}
+	ans[1]=ar[1]*n;
+	 m=ar[1];
+	 s1=ar[1];
+	for(int i=3;i<n;i+=2)
+	{
+		if(m>ar[i])
+		{
+			m=ar[i];
+		}
+		s1+=ar[i];
+		ans[i]=s1-m+m*(n-i/2);
+	}
+	long mini=ans[0]+ans[1];
+	for(int i=1;i<n-1;i++)
+	{
+		mini=Math.min(ans[i]+ans[i+1],mini);
+	}
+	System.out.println(mini);
+}
+}
+}","import java.util.*;
+public class ss
+{
+    public static void main(String[]args)
+    {
+        Scanner in=new Scanner (System.in);
+        int t=in.nextInt();
+        for(int i1=0;i1<t;i1++)
+        {
+            int n=in.nextInt();
+	
+	long[] ar=new long[n];
+	
+	for(int i=0;i<n;i++)
+	{
+		ar[i]=in.nextLong();
+		
+	}
+	
+	long[] ans=new long[n];
+	ans[0]=ar[0]*n;
+	long m=ar[0];
+	long s1=ar[0];
+	for(int i=2;i<n;i+=2)
+	{
+		if(m>ar[i])
+		{
+			m=ar[i];
+		}
+		s1+=ar[i];
+		ans[i]=s1-m+m*(n-i/2);
+ 
+		
+ 
+ 
+	}
+	ans[1]=ar[1]*n;
+	 m=ar[1];
+	 s1=ar[1];
+	for(int i=3;i<n;i+=2)
+	{
+		if(m>ar[i])
+		{
+			m=ar[i];
+		}
+		s1+=ar[i];
+		ans[i]=s1-m+m*(n-i/2);
+	}
+	long mini=ans[0]+ans[1];
+	for(int i=1;i<n-1;i++)
+	{
+		mini=Math.min(ans[i]+ans[i+1],mini);
+	}
+	System.out.println(mini);
+}
+}
+}
+
+",1
+2bbf754b,69b8ffb2,"import java.util.*;
+
+/** 
+__                  __
+( _)                ( _)
+/ / \\              / /\_\_
+/ /   \\            / / | \ \
+/ /     \\          / /  |\ \ \
+/  /   ,  \ ,       / /   /|  \ \
+/  /    |\_ /|      / /   / \   \_\
+/  /  |\/ _ '_| \   / /   /   \    \\
+|  /   |/  0 \0\    / |    |    \    \\
+|    |\|      \_\_ /  /    |     \    \\
+|  | |/    \.\ o\o)  /      \     |    \\
+\    |     /\\`v-v  /        |    |     \\
+| \/    /_| \\_|  /         |    | \    \\
+| |    /__/_ `-` /   _____  |    |  \    \\
+\|    [__]  \_/  |_________  \   |   \    ()
+/    [___] (    \         \  |\ |   |   //
+|    [___]                  |\| \|   /  |/
+/|    [____]                  \  |/\ / / ||
+(  \   [____ /     ) _\      \  \    \| | ||
+\  \  [_____|    / /     __/    \   / / //
+|   \ [_____/   / /        \    |   \/ //
+|   /  '----|   /=\____   _/    |   / //
+__ /  /        |  /   ___/  _/\    \  | ||
+(/-(/-\)       /   \  (/\/\)/  |    /  | /
+(/\/\)           /   /   //
+_________/   /    /
+\____________/    (
+
+
+
+*/
+
+public class Main {
+	public static void main(String[] args) {
+		Scanner sc=new Scanner(System.in);
+		int  t=sc.nextInt();
+		while(t-- >0) {
+			int n=sc.nextInt();
+			int[] arr=new int[n];
+			for(int i=0;i<n;i++) {
+				arr[i]=sc.nextInt();
+			}
+			String str=sc.next();
+			
+			ArrayList<Pair> plist=new ArrayList<>();
+			for(int i=0;i<n;i++) {
+				char ch=str.charAt(i);
+				plist.add(new Pair(arr[i],ch));
+			}
+			
+			//B-reduce
+			//R-increse
+			Collections.sort(plist);
+			
+			int counter=1;
+			boolean flag=false;
+			for(int i=0;i<plist.size();i++) {
+				int val=plist.get(i).number;
+				int clr=plist.get(i).color;
+				
+				if(clr=='B') {
+					if(val<counter) {
+						flag=true;
+						break;
+					}
+				}
+				else {
+					if(val>counter) {
+						flag=true;
+						break;
+					}
+					
+				}
+				counter++;
+			}
+			System.out.println(flag?""NO"":""YES"");
+			
+			
+		}
+	}
+	public static class Pair implements Comparable<Pair>{
+		int number;
+		char color;
+		
+		Pair(int number,char color){
+			this.number=number;
+			this.color=color;
+		}
+		
+		@Override
+		public int compareTo(Pair o) {
+			if(o.color==this.color) {
+				return this.number-o.number;
+			}
+			else {
+				return this.color-o.color;
+			}
+		}
+		
+		public String toString() {
+			return number+""-""+color+""."";
+		}
+	}
+}
+","import java.util.*;
+
+//CODE FORCES
+
+public class anshulvmc {
+
+    
+    public static void sort(int[] a) {
+		ArrayList<Integer> l=new ArrayList<>();
+		for (int i:a) l.add(i);
+		Collections.sort(l);
+		for (int i=0; i<a.length; i++) a[i]=l.get(i);
+	}
+    
+    
+    
+    
+    public static int gcd(int a, int b) {
+		if (b==0) return a;
+		return gcd(b, a%b);
+	}
+    
+    public static void google(int t) {
+    	System.out.println(""Case #""+t+"": "");
+    }
+    
+    
+//    public static void gt(int[][] arr,int k) {
+//    	int n = arr.length+1;
+//    	k = Math.min(k,n+1);
+//    	
+//    	Node[] nodes = new Node[n];
+//    	for(int i=0;i<n;i++) nodes[i] = new Node();
+//    	for(int i=0;i<n-1;i++) {
+//    		int a = arr[i][0];
+//    		int b = arr[i][1];
+//    		System.out.println(a+"" ""+b);
+//    		nodes[a].adj.add(nodes[b]);
+//    		nodes[b].adj.add(nodes[a]);
+//    	}
+//    	
+//    	ArrayDeque<Node> bfs = new ArrayDeque<>();
+//    	for(Node nn:nodes) {
+//    		if(nn.adj.size()<2) {
+//    			bfs.addLast(nn);
+//    			nn.dist=0;
+//    		}
+//    	}
+//    	
+//    	while(bfs.size()>0) {
+//    		Node nn = bfs.removeFirst();
+//    		for(Node a : nn.adj) {
+//    			if(a.dist!=-1) continue;
+//    			a.usedDegree++;
+//    			if(a.adj.size() - a.usedDegree <= 1) {
+//    				a.dist = nn.dist+1;
+//    				bfs.addLast(a);
+//    			}
+//    		}
+//    	}
+//    	
+//    	int[] cs = new int[n+1];
+//    	for(Node nn:nodes) {
+//    		cs[nn.dist]++;
+//    	}
+//    	for(int i=1;i<cs.length;i++) cs[i]+=cs[i-1];
+//    	System.out.println(n-cs[k-1]);
+//    }
+    
+    public static class Node{
+    	ArrayList<Node> adj = new ArrayList<>();
+    	int dist = -1;
+    	int usedDegree = 0;
+    }
+    
+    
+    public static void cat_mice(int dest,int[] arr) {
+    	sort(arr);
+    	int time = dest;
+		int timeleft = dest-1;
+		int counter=0;
+		for(int i=arr.length-1;i>=0;i--) {
+			int val = arr[i];
+			int takes = time - val;
+			if(takes <= timeleft) {
+				timeleft -= takes;
+				counter++;
+			}
+		}
+    	System.out.println(counter);
+    }
+    
+    
+    public static void minex(int n,int[] arr) {
+    	sort(arr);
+    	int ans=arr[0];
+    	for(int i=0;i<arr.length-1;i++) {
+    		ans = Math.max(ans,arr[i+1] - arr[i]);
+    	}
+    	System.out.println(ans);
+    }
+	
+    
+    public static void func(long start,long n) {
+    	long x = start;
+    	if(n==0){
+    	       System.out.println(x);
+    	       return;
+    	   }
+    	   long k=n-1;
+    	   long c=k/4;
+    	   long rem=k%4;
+    	   long ans=x;
+    	   if(x%2 == 0) {
+       		ans -= 1;
+       		ans -= (c * 4);
+       		if(rem == 1) {
+       			ans += n;
+       		}
+       		else if(rem == 2) {
+       			ans += n + n-1;
+       		}
+       		else if(rem == 3){
+       			ans += (n-2) + (n-1) - n;
+       		}
+       	}
+       	else {
+       		ans += 1;
+       		ans += (c * 4);
+       		if(rem == 1) {
+       			ans -= n;
+       		}
+       		else if(rem == 2) {
+       			ans -= n + n-1;
+       		}
+       		else if(rem == 3) {
+       			ans -= n-2 + n-1 - n;
+       		}
+       	}
+    	   System.out.println(ans);
+    	   
+    	
+    }
+    
+	public static boolean redblue(int[] num, String chnum) {
+    	ArrayList<Integer> blue = new ArrayList<>();
+    	ArrayList<Integer> red = new ArrayList<>();
+    	for(int i=0;i<chnum.length();i++) {
+    		char ch = chnum.charAt(i);
+    		if(ch == 'B') {
+    			blue.add(num[i]);
+    		}
+    		else {
+    			red.add(num[i]);
+    		}
+    	}
+    	Collections.sort(blue);
+    	Collections.sort(red);
+//    	System.out.println(blue);
+//    	System.out.println(red);
+    	for(int i=0;i<blue.size();i++) {
+    		if(blue.get(i) >= i+1) {
+    			
+    		}
+    		else {
+    			return false;
+    		}
+    	}
+    	for(int i=0;i<red.size();i++) {
+    		if(red.get(i) > i+1 + blue.size()) {
+//    			System.out.println(red.get(i)+"" ""+(i+1 + blue.size()));
+    			return false;
+    		}
+    	}
+    	return true;
+    }
+    
+    public static void main(String args[])
+    
+    
+    {	
+    	Scanner scn = new Scanner(System.in);
+    	int test = scn.nextInt();
+    	for(int i=0;i<test;i++) {
+    		int size = scn.nextInt();
+    		int[] arr = new int[size];
+    		for(int j=0;j<size;j++) {
+    			arr[j] = scn.nextInt();
+    		}
+    		String str = scn.next();
+    		boolean f = redblue(arr,str);
+    		if(f) {
+    			System.out.println(""YES"");
+    		}
+    		else {
+    			System.out.println(""NO"");
+    		}
+    	}
+//    	int n = 1;
+//    	int[] dp = new int[2];
+//    	System.out.println(fact(n,dp));
+    			
+    }
+
+}",0
+7814575b,b55888de,"import java.io.*;
+import java.util.*;
+import static java.lang.Math.max;
+import static java.lang.Math.min;
+import static java.lang.Math.abs;
+
+public class C {
+
+    static int fval(String s, char x){
+        int fx = 0, oth = 0;
+        for(int i = 0; i<s.length(); i++){
+            if(x == s.charAt(i)) fx++;
+            else oth++;
+        }
+        return fx-oth;
+    }
+
+    public static void main(String[] args) throws Exception {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        StringBuilder sb = new StringBuilder();
+        //int tst = 1;
+        int tst = Integer.parseInt(br.readLine());
+        long mod = (long)1e9+7;
+        while(tst-->0){
+            int n = Integer.parseInt(br.readLine());
+            ArrayList<String> lst = new ArrayList<>();
+            for(int i = 0; i<n; i++){
+                lst.add(br.readLine());
+            }
+            int ans = 0;
+            for(int i = 0; i<5; i++){
+                char x = (char)(97+i);
+                ArrayList<Integer> vals = new ArrayList<>();
+                for(int j = 0; j<n; j++){
+                    vals.add(fval(lst.get(j), x));
+                }
+                Collections.sort(vals, Collections.reverseOrder());
+                int pt = -1, sum = 0;
+                while(pt+1<n && sum+vals.get(pt+1)>0){
+                    sum+=vals.get(++pt);
+                }
+                ans = max(ans, pt+1);
+            }
+            sb.append(ans).append('\n');
+        }
+        System.out.println(sb);
+    }
+}
+/**
+ * min deletions
+ * for each letter calc max len of words
+ * Its desirable to add someting that has more of x and less of other letters -> f(x, s)=>fx-sum(fz)
+ */
+","import java.lang.reflect.Array;
+import java.util.*;
+public class Rough {
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);   
+        int t = sc.nextInt();
+        while (t-->0) {
+            int n = sc.nextInt();
+            sc.nextLine();
+            String s[] = new String[n];
+            int f[][] = new int[n][5];
+            for (int i = 0; i < n; i++) {
+                s[i]  = sc.nextLine();
+
+                for (int j = 0; j < s[i].length(); j++) {
+                    f[i][s[i].charAt(j)-'a']++;
+                }
+            }
+
+            int ans = 0;
+            for ( int i = 0; i < 5; i++) {
+                ArrayList<Integer> al = new ArrayList<>();
+
+                for (int j = 0; j < n; j++) {
+                    int o = 0;
+                    for (int k = 0; k < 5; k++) {
+                        if(k != i)
+                            o+=f[j][k];
+                    }
+                    al.add(f[j][i]-o);
+                }
+
+                Collections.sort(al,Collections.reverseOrder());
+
+                int max = 0;
+                int x = 0;
+                for (int j = 0; j < n; j++) {
+                    x+=al.get(j);
+                    if(x<=0)break;
+                    max++;
+                }
+                ans = Math.max(max,ans);
+            }
+
+            System.out.println(ans);
+        }
+        sc.close();
+    }
+}",0
+40cc90ae,51151974,"import javax.swing.text.html.parser.Entity;
+import java.io.*;
+import java.util.*;
+import java.math.BigInteger;
+
+
+public class Main{
+    public static void main(String[] args) {
+        InputStream inputStream = System.in;
+        OutputStream outputStream = System.out;
+        InputReader in = new InputReader(inputStream);
+        PrintWriter out = new PrintWriter(outputStream);
+        Task solver = new Task();
+        solver.solve(in, out);
+        out.close();
+    }
+    // main solver
+    static class Task{
+
+        double eps= 0.00000001;
+        static final int MAXN = 1010;
+        static final int MOD= 1000000007;
+
+        // stores smallest prime factor for every number
+        static int spf[] = new int[MAXN];
+
+        static boolean[] prime;
+
+        // Calculating SPF (Smallest Prime Factor) for every
+        // number till MAXN.
+        // Time Complexity : O(nloglogn)
+        public void sieve()
+        {
+            spf[1] = 1;
+            for (int i=2; i<MAXN; i++)
+
+                // marking smallest prime factor for every
+                // number to be itself.
+                spf[i] = i;
+
+            // separately marking spf for every even
+            // number as 2
+            for (int i=4; i<MAXN; i+=2)
+                spf[i] = 2;
+
+            for (int i=3; i*i<MAXN; i++)
+            {
+                // checking if i is prime
+                if (spf[i] == i)
+                {
+                    // marking SPF for all numbers divisible by i
+                    for (int j=i*i; j<MAXN; j+=i)
+
+                        // marking spf[j] if it is not
+                        // previously marked
+                        if (spf[j]==j)
+                            spf[j] = i;
+                }
+            }
+        }
+
+        void sieveOfEratosthenes(int n)
+        {
+            // Create a boolean array
+            // ""prime[0..n]"" and
+            // initialize all entries
+            // it as true. A value in
+            // prime[i] will finally be
+            // false if i is Not a
+            // prime, else true.
+            prime= new boolean[n + 1];
+            for (int i = 0; i <= n; i++)
+                prime[i] = true;
+
+            for (int p = 2; p * p <= n; p++)
+            {
+                // If prime[p] is not changed, then it is a
+                // prime
+                if (prime[p] == true)
+                {
+                    // Update all multiples of p
+                    for (int i = p * p; i <= n; i += p)
+                        prime[i] = false;
+                }
+            }
+        }
+
+        // function to find first index >= x
+        public int lowerIndex(List<Integer> arr, int n, int x)
+        {
+            int l = 0, h = n - 1;
+            while (l <= h)
+            {
+                int mid = (l + h) / 2;
+                if (arr.get(mid) >= x)
+                    h = mid - 1;
+                else
+                    l = mid + 1;
+            }
+            return l;
+        }
+        public int lowerIndex(int[] arr, int n, int x)
+        {
+            int l = 0, h = n - 1;
+            while (l <= h)
+            {
+                int mid = (l + h) / 2;
+                if (arr[mid] >= x)
+                    h = mid - 1;
+                else
+                    l = mid + 1;
+            }
+            return l;
+        }
+
+        // function to find last index <= y
+        public int upperIndex(List<Integer> arr, int n, int y)
+        {
+            int l = 0, h = n - 1;
+            while (l <= h)
+            {
+                int mid = (l + h) / 2;
+                if (arr.get(mid) <= y)
+                    l = mid + 1;
+                else
+                    h = mid - 1;
+            }
+            return h;
+        }
+        public int upperIndex(int[] arr, int n, int y)
+        {
+            int l = 0, h = n - 1;
+            while (l <= h)
+            {
+                int mid = (l + h) / 2;
+                if (arr[mid] <= y)
+                    l = mid + 1;
+                else
+                    h = mid - 1;
+            }
+            return h;
+        }
+
+        // function to count elements within given range
+        public int countInRange(List<Integer> arr, int n, int x, int y)
+        {
+            // initialize result
+            int count = 0;
+            count = upperIndex(arr, n, y) -
+                    lowerIndex(arr, n, x) + 1;
+            return count;
+        }
+
+        public int _gcd(int a,  int  b)
+        {
+
+            if(b == 0) {
+                return a;
+            }
+            else {
+                return _gcd(b, a % b);
+            }
+        }
+
+        public int add(int a, int b){
+            a+=b;
+            if(a>=MOD) a-=MOD;
+            else if(a<0) a+=MOD;
+            return a;
+        }
+
+        public int mul(int a, int b){
+            long res= (long)a*(long)b;
+            return (int)(res%MOD);
+        }
+
+        public int power(int a, int b) {
+            int ans=1;
+            while(b>0){
+                if((b&1)!=0) ans= mul(ans,a);
+                b>>=1;
+                a= mul(a,a);
+            }
+            return ans;
+        }
+
+        int[] fact= new int[MAXN];
+        int[] inv= new int[MAXN];
+
+        public int Ckn(int n, int k){
+            if(k<0 || n<0) return 0;
+            return mul(mul(fact[n],inv[k]),inv[n-k]);
+        }
+
+        public int inverse(int a){
+            return power(a,MOD-2);
+        }
+
+        public void preprocess() {
+            fact[0]=1;
+            for(int i=1;i<MAXN;i++) fact[i]= mul(fact[i-1],i);
+            inv[MAXN-1]= inverse(fact[MAXN-1]);
+            for(int i=MAXN-2;i>=0;i--){
+                inv[i]= mul(inv[i+1],i+1);
+            }
+        }
+
+        /**
+         * return VALUE of lower bound for unsorted array
+         */
+        public int lowerBoundNormalArray(int[] arr, int x){
+            TreeSet<Integer> set= new TreeSet<>();
+            for(int num: arr) set.add(num);
+            return set.lower(x);
+        }
+        /**
+         * return VALUE of upper bound for unsorted array
+         */
+        public int upperBoundNormalArray(int[] arr, int x){
+            TreeSet<Integer> set= new TreeSet<>();
+            for(int num: arr) set.add(num);
+            return set.higher(x);
+        }
+
+        public void debugArr(int[] arr){
+            for(int i: arr) out.print(i+"" "");
+            out.println();
+        }
+
+        public int rand(){
+            int min=0, max= MAXN;
+            int random_int = (int)Math.floor(Math.random()*(max-min+1)+min);
+            return random_int;
+        }
+
+        InputReader in; PrintWriter out;
+        static int mod = 1000000007;
+        int ans = 0;
+        ArrayList<Integer>g[] = new ArrayList[101];
+        int cnt[][] = new int[101][101];
+        int dp[][] = new int[101][101];
+        int Add(int a, int b){
+            a+=b; while (a>=mod)a-=mod;
+            return a;
+        }
+        int Mul(int a, int b){
+            return (int)(((long)a * b) % mod);
+        }
+        void dfs(int node, int par, int root, int depth){
+            cnt[root][depth]++;
+            for (int v : g[node]){
+                if (v != par){
+                    dfs(v, node, root, depth+1);
+                }
+            }
+        }
+        public void solve(InputReader in, PrintWriter out) {
+           int t = in.nextInt();
+           while (t-- > 0){
+               int n = in.nextInt();
+               String[] str = new String[n];
+               ArrayList<Integer> diff[] = new ArrayList[5];
+               for (int i = 0; i < 5; i++) diff[i] = new ArrayList<>();
+               for (int i = 0; i < n; i++){
+                   str[i] = in.nextToken();
+                   int[] cnt = new int[5];
+                   for (int j = 0; j < str[i].length(); j++){
+                       cnt[str[i].charAt(j) - 'a']++;
+                   }
+                   for (int j = 0; j < 5; j++){
+                       diff[j].add(cnt[j] * 2 - str[i].length());
+                   }
+               }
+               int ans = 0;
+               for (int i = 0; i < 5; i++){
+                   Collections.sort(diff[i]);
+                   Collections.reverse(diff[i]);
+                   int cur = 0, x = 0;
+                   for (int j = 0; j < diff[i].size(); j++){
+                       cur+=diff[i].get(j);
+                       if (cur <= 0){
+                           break;
+                       }
+                       x++;
+                   }
+                   ans = Math.max(ans, x);
+               }
+               out.println(ans);
+           }
+        }
+
+        class SEG {
+            int n;
+            int[] segs;
+            public SEG (int[] a){
+                this.n= a.length;
+                segs= new int[4*this.n];
+                build(a,0,0,this.n-1);
+            }
+            public void build(int[] a, int root, int l, int r){
+                if(l==r){
+                    segs[root]=a[l];
+                    return;
+                }
+                int m= (l+r)/2;
+                build(a,2*root+1,l,m);
+                build(a,2*root+2,m+1,r);
+                segs[root]= _gcd(segs[2*root+1], segs[2*root+2]);
+            }
+            public int query(int root, int l, int r, int lq, int rq){
+                if(lq<=l && rq>=r) return segs[root];
+                if(lq>r || rq<l) return 0;
+                int m= (l+r)/2;
+                int left= query(2*root+1, l, m, lq, rq);
+                int right= query(2*root+2, m+1, r, lq, rq);
+                return _gcd(left,right);
+            }
+
+        }
+
+    }
+
+    static class Venice{
+        public Map<Long,Long> m= new HashMap<>();
+        public long base=0;
+        public long totalValue=0;
+        private int M= 1000000007;
+
+        private long addMod(long a, long b){
+            a+=b;
+            if(a>=M) a-=M;
+            return a;
+        }
+
+        public void reset(){
+            m= new HashMap<>();
+            base=0;
+            totalValue=0;
+        }
+        public void update(long add){
+            base= base+ add;
+        }
+        public void add(long key, long val){
+            long newKey= key-base;
+            m.put(newKey, addMod(m.getOrDefault(newKey,(long)0),val));
+        }
+    }
+
+
+
+    static class Tuple implements Comparable<Tuple>{
+        int x, y, z;
+        public Tuple(int x, int y, int z){
+            this.x= x;
+            this.y= y;
+            this.z=z;
+        }
+        @Override
+        public int compareTo(Tuple o){
+            return this.x-o.x;
+        }
+    }
+
+    static class Pair implements Comparable<Pair>{
+        public int x;
+        public int y;
+        public Pair(int x, int y){
+            this.x= x;
+            this.y= y;
+        }
+
+        @Override
+        public int compareTo(Pair o) {
+            return this.x-o.x;
+        }
+    }
+
+    // public static class compareL implements Comparator<Tuple>{
+    //     @Override
+    //     public int compare(Tuple t1, Tuple t2) {
+    //         return t2.l - t1.l;
+    //     }
+    // }
+
+    // fast input reader class;
+    static class InputReader {
+        BufferedReader br;
+        StringTokenizer st;
+
+        public InputReader(InputStream stream) {
+            br = new BufferedReader(new InputStreamReader(stream));
+        }
+
+        public String nextToken() {
+            while (st == null || !st.hasMoreTokens()) {
+                String line = null;
+                try {
+                    line = br.readLine();
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+                if (line == null) {
+                    return null;
+                }
+                st = new StringTokenizer(line);
+            }
+            return st.nextToken();
+        }
+
+        public int nextInt() {
+            return Integer.parseInt(nextToken());
+        }
+        public double nextDouble(){
+            return Double.parseDouble(nextToken());
+        }
+        public long nextLong(){
+            return Long.parseLong(nextToken());
+        }
+        public int[] nextIntArr(int n){
+            int[] arr= new int[n];
+            for(int i=0;i<n;i++) arr[i]= nextInt();
+            return arr;
+        }
+        public long[] nextLongArr(int n){
+            long[] arr= new long[n];
+            for(int i=0;i<n;i++) arr[i]= nextLong();
+            return arr;
+        }
+        public List<Integer> nextIntList(int n){
+            List<Integer> arr= new ArrayList<>();
+            for(int i=0;i<n;i++) arr.add(nextInt());
+            return arr;
+        }
+        public int[][] nextIntMatArr(int n, int m){
+            int[][] mat= new int[n][m];
+            for(int i=0;i<n;i++) for(int j=0;j<m;j++) mat[i][j]= nextInt();
+            return mat;
+        }
+        public List<List<Integer>> nextIntMatList(int n, int m){
+            List<List<Integer>> mat= new ArrayList<>();
+            for(int i=0;i<n;i++){
+                List<Integer> temp= new ArrayList<>();
+                for(int j=0;j<m;j++) temp.add(nextInt());
+                mat.add(temp);
+            }
+            return mat;
+        }
+        public char[] nextStringCharArr(){
+            return nextToken().toCharArray();
+        }
+    }
+}","import java.io.*;
+import java.util.*;
+ public class Solution{
+    public static void main (String[] args) throws java.lang.Exception {
+        FastReader sc = new FastReader();
+        BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));
+        int testCase = sc.nextInt();
+        while (testCase-->0){
+            int n = sc.nextInt();
+            String[] strArr = new String[n];
+            for(int i=0; i<n; i++) {
+                strArr[i]=sc.nextLine();
+            }
+            int[] total = new int[5];
+            ArrayList<int[]> al = new ArrayList<>();
+            for(int i=0; i<n; i++){
+                int[] arr= new int[5];
+                for(int j=0; j<strArr[i].length(); j++){
+                    arr[strArr[i].charAt(j)-'a']++;
+                }
+                for(int j=0; j<5; j++){
+                    total[j]+=arr[j];
+                }
+                al.add(arr);
+            }
+            int ans=0;
+            for(int i=0; i<5; i++){
+                ArrayList<Integer> all = new ArrayList<>();
+                for(int j=0; j<n; j++){
+                    all.add(strArr[j].length()-2*al.get(j)[i]);
+                }
+                java.util.Collections.sort(all);
+                int c=0, d=0;
+                for(int j=0; j<n; j++){
+                    c+=all.get(j);
+                    if(c<0) d=j+1;
+                }
+                ans = Math.max(ans,d);
+            }
+            System.out.println(ans);
+        }
+    }
+    // Fast Reader Class
+    static class FastReader {
+        BufferedReader br; StringTokenizer st;
+        public FastReader() { br = new BufferedReader(new InputStreamReader(System.in)); }
+        String next() { while (st == null || !st.hasMoreElements()) { try { st = new StringTokenizer(br.readLine()); } catch (IOException e) { e.printStackTrace(); } }return st.nextToken(); }
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+        String nextLine() { String str = """"; try { str = br.readLine(); }  catch (IOException e) { e.printStackTrace(); }return str; }
+    }
+}",0
+26ad111c,b0a01ee7,"import java.io.*;
+import java.util.*;
+
+public class C {
+	
+	public static void main(String[] args) {
+		
+		FastReader f = new FastReader();
+		StringBuffer sb=new StringBuffer();
+		
+		int test=f.nextInt();
+		while(test-->0)
+		{
+			int n=f.nextInt();
+			String str[]=new String[n];
+			for(int i=0;i<n;i++)
+				str[i]=f.next();
+			int max=0;
+			for(char ch='a';ch<='e';ch++)
+				max=Math.max(max,solve(str,ch));
+			sb.append(max+""\n"");
+		}
+		System.out.println(sb);
+	}
+	
+	static int solve(String str[],char ch)
+	{	
+		int count=0;
+		int adv=0,equal=0;
+		int totalAdv=0;
+		List<Integer> c=new ArrayList<>();
+		for(int i=0;i<str.length;i++)
+		{		
+			int countC=0;
+			int countTtl=0;
+			for(int j=0;j<str[i].length();j++)
+			{
+				if(str[i].charAt(j)==ch)
+					countC++;
+				else
+					countTtl++;
+			}
+			if(countC>countTtl)
+			{
+				adv++;
+				totalAdv+=(countC-countTtl);
+			}
+			else if(countC==countTtl)
+				equal++;
+			else
+				c.add(Math.abs(countTtl-countC));
+		}
+		if(adv>0)
+			count+=adv+equal;
+		
+		Collections.sort(c);
+		for(int i:c)
+		{
+			if(totalAdv>i)
+			{
+				totalAdv-=i;
+				count++;
+			}
+		}
+		return count;
+	}
+	
+	static class FastReader 
+	{ 
+	    BufferedReader br; 
+	    StringTokenizer st; 
+ 
+	    public FastReader() {
+	    	br = new BufferedReader(new
+	                 InputStreamReader(System.in)); 
+	    }
+	    String next() { 
+	        while (st == null || !st.hasMoreElements()) { 
+	            try{ 
+	                st = new StringTokenizer(br.readLine()); 
+	            } 
+	            catch (IOException  e) { 
+	                e.printStackTrace(); 
+	            } 
+	        } 
+	        return st.nextToken(); 
+	    } 
+	    int nextInt() { 
+	        return Integer.parseInt(next()); 
+	    } 
+	    long nextLong() { 
+	        return Long.parseLong(next()); 
+	    } 
+	    double nextDouble() { 
+	        return Double.parseDouble(next()); 
+	    } 
+	    String nextLine() { 
+	        String str = """"; 
+	        try{ 
+	            str = br.readLine(); 
+	        } 
+	        catch (IOException e) { 
+	            e.printStackTrace(); 
+	        } 
+	        return str; 
+	    } 
+	} 
+}","import java.util.*;
+
+public class interestingstory {
+    public static void main(String[] args) throws Exception {
+       		// your code goes here
+		try{    
+            Scanner sc =new Scanner(System.in);
+            int t=sc.nextInt();
+            while(t-->0)
+            {
+                int n = sc.nextInt();
+                int answer = 0;
+                String [] string_arr = new String[n];    
+                for (int i = 0; i< n; i++){
+                    string_arr[i] = sc.next();
+                }
+
+                for(char c = 'a'; c <= 'e'; c++){
+                    int [] diff = new int[n];
+
+                    for (int j = 0; j < string_arr.length; j++){
+                        for(int i = 0; i < string_arr[j].length(); i++){
+                            if(string_arr[j].charAt(i) == c){
+                                diff[j] += 1;
+                            } else {
+                                diff[j] += -1;
+                            }
+                        }
+                    }
+
+                    Arrays.sort(diff);
+                    int sum = 0;
+                    int ans = n;
+                    for(int p = n-1; p >= 0;p--){
+                        sum += diff[p];
+                        if (sum <= 0) {
+                            ans = n - p - 1;
+                            break;
+                        } 
+                    }
+                    answer = Math.max(answer, ans);
+                }
+
+                System.out.println(answer);
+            }
+         } catch(java.lang.Exception e){}
+    }
+}",0
+298ee961,392218ef,"import java.util.*;
+import java.io.*;
+
+public class Main {
+  static void print(String s) {
+    System.out.print(s);
+  }
+  static void printLine(String s) {
+    System.out.println(s);
+  }
+  static double parseDouble(String s) {
+    return Double.parseDouble(s.trim());
+  }
+  static int parseInt(String s) {
+    return Integer.parseInt(s.trim());
+  }
+  static String[] split(String s) {
+    return s.split(""\\s+"");
+  }
+  
+  public static void main(String[] args) throws Exception {
+    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+    String line;
+    StringTokenizer st;
+    int test = parseInt(br.readLine());
+    for (int t = 0; t < test; t++) {
+      int n = parseInt(br.readLine());
+      ArrayList<Integer> blue = new ArrayList<Integer>();
+      ArrayList<Integer> red = new ArrayList<Integer>();
+      String[] toks = split(br.readLine());
+      String color = br.readLine();
+      for (int i = 0; i < n; i++) {
+        if (color.charAt(i) == 'B') {
+          blue.add(parseInt(toks[i]));
+        } else {
+          red.add(parseInt(toks[i]));
+        }
+      }
+      int[] blueArr = new int[blue.size()];
+      int[] redArr = new int[red.size()];
+      for (int i = 0; i < blue.size(); i++) {
+        blueArr[i] = blue.get(i);
+      }
+      for (int i = 0; i < red.size(); i++) {
+        redArr[i] = red.get(i);
+      }
+      Arrays.sort(blueArr);
+      Arrays.sort(redArr);
+      int blueP = 0; // pointer
+      int redP = 0; // pointer
+      
+      // blue -> decrease, red -> increase
+      int start = 1;
+      boolean unable = false;
+      while (start <= n) {
+        if (blueP < blueArr.length) {
+          if (blueArr[blueP] < start) {
+            unable = true;
+            printLine(""NO"");
+            break;  
+          } else {
+            blueP++;
+            start++;
+          }
+        } else {
+          if (redArr[redP] > start) {
+            unable = true;
+            printLine(""NO"");
+            break;  
+          } else {
+            redP++;
+            start++;
+          }
+        }        
+      }
+      if (!unable) {
+        printLine(""YES"");
+      }      
+    }
+  }
+}
+","import java.util.*;
+import java.lang.*;
+import java.io.*;
+public class Main
+{
+    static void sort(int a[]){
+        ArrayList<Integer> arr=new ArrayList<>();
+        for(int i=0;i<a.length;i++)arr.add(a[i]);
+        Collections.sort(arr);
+        for(int i=0;i<a.length;i++)a[i]=arr.get(i);
+    }
+	public static void main (String[] args) throws java.lang.Exception
+	{
+	   // Scanner sc=new Scanner(System.in);
+	    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+	   // int t=1;
+	    //t=sc.nextInt();
+	    int t=Integer.parseInt(br.readLine());
+	    while(--t>=0){
+	        int n=Integer.parseInt(br.readLine());
+	         int a[]=new int[n];
+	         StringTokenizer st=new StringTokenizer(br.readLine());
+	        for(int i=0;i<n;i++)a[i]=Integer.parseInt(st.nextToken());
+	       String s=br.readLine();
+	        ArrayList<Integer> inc=new ArrayList<>();
+	        ArrayList<Integer> dec=new ArrayList<>();
+	        
+	        for(int i=0;i<n;i++){
+	            if(s.charAt(i)=='R')inc.add(a[i]);
+	            else dec.add(a[i]);
+	        }
+	        Collections.sort(dec);
+	        Collections.sort(inc,Collections.reverseOrder());
+	        int p=n;
+	        boolean flag=false;
+	        for(int i=0;i<inc.size();i++){
+	            if(inc.get(i)>p)flag=true;
+	            p--;
+	        }
+	        p=1;
+	        for(int i=0;i<dec.size();i++){
+	            if(dec.get(i)<p)flag=true;
+	            p++;
+	        }
+	        if(flag)System.out.println(""NO"");
+	        else System.out.println(""YES"");
+	    }
+	    
+	}
+}
+",0
+00af3420,86102d81,"import java.util.*;
+import java.io.*;
+
+public class Main {
+
+    public static void main(String[] args) throws IOException {
+        Scanner sc = new Scanner(System.in);
+        PrintWriter pw = new PrintWriter(System.out);
+        int t = sc.nextInt();
+        while(t-- > 0){
+            int n = sc.nextInt();
+            String[] s = new String[n];
+            for(int i=0; i<n; i++)
+                s[i] = sc.next();
+            int MAX = 0;
+            for(char c = 'a'; c <= 'e'; c++){
+                PriorityQueue<Integer> pq = new PriorityQueue<>(Collections.reverseOrder()); //Big comes in top;
+                for(int i=0; i<n; ++i) {
+                    int curChar = 0;
+                    int otherChar = 0;
+                    for(int j=0; j<s[i].length(); j++) {
+                        if(s[i].charAt(j) == c)
+                            curChar++;
+                        else
+                            otherChar++;
+                    }
+                    int diff = curChar - otherChar;
+                    pq.add(diff);
+                }
+                int cur = 0;
+                int numberOfWords = 0;
+                while(!pq.isEmpty()){
+                    if(cur + pq.peek() > 0){
+                        cur += pq.poll();
+                        numberOfWords++;
+                    }else{
+                        break;
+                    }
+                }
+                MAX = Math.max(MAX, numberOfWords);
+            }
+            pw.println(MAX);
+        }
+        pw.close();
+    }
+
+    static class Scanner {
+        BufferedReader br;
+        StringTokenizer st;
+
+        public Scanner(InputStream s) {
+            br = new BufferedReader(new InputStreamReader(s));
+        }
+
+        public Scanner(FileReader f) {
+            br = new BufferedReader(f);
+        }
+
+        public String next() throws IOException {
+            while (st == null || !st.hasMoreTokens())
+                st = new StringTokenizer(br.readLine());
+            return st.nextToken();
+        }
+
+        public int nextInt() throws IOException {
+            return Integer.parseInt(next());
+        }
+
+        public long nextLong() throws IOException {
+            return Long.parseLong(next());
+        }
+
+        public double nextDouble() throws IOException {
+            return Double.parseDouble(next());
+        }
+
+        public int[] nextIntArr(int n) throws IOException {
+            int[] arr = new int[n];
+            for (int i = 0; i < n; i++) {
+                arr[i] = Integer.parseInt(next());
+            }
+            return arr;
+        }
+
+    }
+}
+
+","
+	import java.io.*;
+import java.util.*;
+		
+	public class Aqueous {
+		
+		
+		static MyScanner sc = new MyScanner();
+			
+		public static void main(String[] args) {
+			
+			int t = sc.nextInt();
+			
+				while(t-->0) {
+					
+					int n = sc.nextInt();
+					
+						String s[] = new String[n];
+						
+							for(int i = 0; i<n; i++) {
+								s[i] = sc.next();
+							}
+							
+							int ans = Integer.MIN_VALUE;
+							
+							for(char c = 'a'; c<='e'; c++) {
+								
+								int ls[] = new int[n];
+								
+									for(int i = 0; i<n; i++) {
+										
+										String temp = s[i];
+										int delta = 0;
+										
+											for(int j = 0; j<temp.length(); j++) {
+												if(temp.charAt(j)==c) {
+													delta++;
+												}
+												else {
+													delta--;
+												}
+											}
+											
+											ls[i] = delta;
+									}
+									
+									Arrays.sort(ls);
+									
+									int cur = 0;
+									int score= 0;
+									
+									for(int k = n-1; k>=0; k--) {
+										if(cur+ls[k]>=1) {
+											cur+=ls[k];
+											score++;
+										}
+									}
+									
+									ans = Math.max(ans, score);
+							}
+							
+							System.out.println(ans);
+						
+				}
+		}
+		
+		static void ruffleSort(int a[]) {
+
+	          int n = a.length;
+
+	          Random r = new Random();
+
+	          for (int i = 0; i < n; i++) {
+
+	              int oi = r.nextInt(n);
+	              int temp = a[oi];
+	              a[oi] = a[i];
+	              a[i] = temp;
+	          }
+
+	          Arrays.sort(a);
+	      }
+		
+		
+		static void ruffleSort(long a[]) {
+
+	          int n = a.length;
+
+	          Random r = new Random();
+
+	          for (int i = 0; i < n; i++) {
+	              int oi = r.nextInt(n);
+
+	              long temp = a[oi];
+	              a[oi] = a[i];
+	              a[i] = temp;
+	          }
+
+	          Arrays.sort(a);
+	      }
+
+		
+		
+	    public static class MyScanner {
+	        BufferedReader br;
+	        StringTokenizer st;
+
+	        public MyScanner() {
+	            br = new BufferedReader(new InputStreamReader(System.in));
+	        }
+
+	        String next() {
+	            while (st == null || !st.hasMoreElements()) {
+	                try {
+	                    st = new StringTokenizer(br.readLine());
+	                } catch (IOException e) {
+	                    e.printStackTrace();
+	                }
+	            }
+	            return st.nextToken();
+	        }
+
+	        int nextInt() {
+	            return Integer.parseInt(next());
+	        }
+
+	        long nextLong() {
+	            return Long.parseLong(next());
+	        }
+
+	        double nextDouble() {
+	            return Double.parseDouble(next());
+	        }
+
+	        String nextLine() {
+	            String str = """";
+	            try {
+	                str = br.readLine();
+	            } catch (IOException e) {
+	                e.printStackTrace();
+	            }
+	            return str;
+	        }
+
+	    }
+	}
+",0
+00db6701,0c1143f7,"import java.util.*;
+import java.io.*;
+public class Main  {
+    public static void main(String args[]) {
+      FastScanner fs=new FastScanner();    
+      PrintWriter out=new PrintWriter(System.out);
+      
+      int t=fs.nextInt();
+      while(t-->0)
+      {
+          int n=fs.nextInt();
+          int c[]=fs.readArray(n);
+          int i;
+          
+          
+          long mn0=c[0];
+          long mn1=c[1];
+          long s0=c[0];
+          long s1=c[1];
+          
+          
+          long ans;
+          ans=(mn0+mn1)*n*1L;
+          
+          for(i=2;i<n;i++)
+          {
+              if(i%2==0)
+              {
+                  s0+=c[i];
+                  mn0=Math.min(mn0,c[i]);
+              }
+              else
+              {
+                  s1+=c[i];
+                  mn1=Math.min(mn1,c[i]);
+              }
+              ans=Math.min(ans,s0+mn0*(n-i/2-1)+s1+mn1*(n-(i+1)/2));
+          }
+          
+          out.println(ans);
+          
+          
+          
+          
+      }
+        
+        out.flush();
+        out.close();
+    }
+	static void sort(int a[]){
+	    ArrayList<Integer> al=new ArrayList<>();
+	    for(int x:a)al.add(x);
+	    Collections.sort(al);
+	    for(int i=0;i<a.length;i++) a[i]=al.get(i);
+	}
+}
+        class FastScanner {
+		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st=new StringTokenizer("""");
+		
+		String next() {
+			while (!st.hasMoreTokens())
+				try {
+				st=new StringTokenizer(br.readLine());
+				}
+				catch (IOException e) {
+					e.printStackTrace();
+				}
+			return st.nextToken();
+		}
+		String nextLine() {
+		    String str="""";
+		    try {
+		        str=br.readLine();
+		    }
+		    catch (IOException e) {
+		        e.printStackTrace(); 
+		    }
+		    return str;
+		}
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+		int[] readArray(int n) {
+			int[] a=new int[n];
+			for (int i=0; i<n; i++) a[i]=nextInt();
+			return a;
+		}
+	}","import java.io.*;
+import java.util.*;
+
+public class E {
+
+	public static void main(String[] args) {
+		// TODO Auto-generated method stub
+			FastScanner sc = new FastScanner();
+			
+			int t = sc.nextInt();
+			
+			while(t-- > 0) {
+				
+				int n = sc.nextInt();
+				int[] a = new int[n];
+				
+				for(int i = 0 ; i< n ; i++) {
+					a[i] = sc.nextInt();
+				}
+				long oddMin = a[1];
+				long evenMin = a[0];
+				long res = (n * oddMin) + (n * evenMin);
+				long oddSum = a[1];
+				long evenSum = a[0];
+				
+				for(int i = 2 ;i < n ; i++) {
+					
+					if(i % 2 == 1) {
+						oddSum += a[i];
+						oddMin = Math.min(oddMin, a[i]);
+					}
+					else {
+						evenSum += a[i];
+						evenMin = Math.min(evenMin, a[i]);
+					}
+					
+					int odd = (i + 1) / 2;
+					int even = (i / 2) + 1;
+					
+					long minCostOdd = oddSum + oddMin*(n - odd);
+					long minCostEven = evenSum + evenMin*(n - even);
+					
+					res = Math.min(res, minCostOdd + minCostEven);
+				}
+				
+				System.out.println(res);
+			}
+			
+			
+			
+			
+
+	}
+	
+	static class FastScanner {
+		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st=new StringTokenizer("""");
+		String next() {
+			while (!st.hasMoreTokens())
+				try {
+					st=new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			return st.nextToken();
+		}
+		
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+		int[] readArray(int n) {
+			int[] a=new int[n];
+			for (int i=0; i<n; i++) a[i]=nextInt();
+			return a;
+		}
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+	}
+	
+	// Use this instead of Arrays.sort() on an array of ints. Arrays.sort() is n^2
+		// worst case since it uses a version of quicksort. Although this would never
+		// actually show up in the real world, in codeforces, people can hack, so
+		// this is needed.
+		static void ruffleSort(int[] a) {
+			//ruffle
+			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;
+			}
+			
+			//then sort
+			Arrays.sort(a);
+		}
+
+}
+",0
+5289e80a,d82fa7e3,"import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.*;
+
+//6 4 1 1 4 1
+
+//-3 4 -2 0 -4 6 1
+// 4    6 1
+//-4 -3 -2 0 1 4 6
+public class C1 {
+    private static void solve(List<Integer>[] g, int[][] a) {
+        long[] dfs = dfs(g, a, 0, -1);
+        System.out.println(Math.max(dfs[0], dfs[1]));
+    }
+
+    private static long[] dfs(List<Integer>[] g, int[][] a, int v, int p) {
+        long lans = 0;
+        long rans = 0;
+        for (Integer i : g[v]) {
+            if (i != p) {
+                long[] dfs = dfs(g, a, i, v);
+                lans += Math.max(Math.abs(a[v][0] - a[i][1]) + dfs[1], Math.abs(a[v][0] - a[i][0]) + dfs[0]);
+                rans += Math.max(Math.abs(a[v][1] - a[i][1]) + dfs[1], Math.abs(a[v][1] - a[i][0]) + dfs[0]);
+
+            }
+        }
+        return new long[]{lans, rans};
+    }
+
+    public static void main(String[] args) {
+        FastScanner sc = new FastScanner();
+        int t = sc.nextInt();
+        for (int i = 0; i < t; i++) {
+            int n = sc.nextInt();
+            int[][] a = new int[n][2];
+            for (int j = 0; j < n; j++) {
+                a[j] = new int[]{sc.nextInt(), sc.nextInt()};
+            }
+            List<Integer>[] g = new ArrayList[n];
+            for (int j = 0; j < n; j++) {
+                g[j] = new ArrayList<>();
+            }
+            for (int j = 0; j < n - 1; j++) {
+                int u = sc.nextInt() - 1;
+                int v = sc.nextInt() - 1;
+                g[u].add(v);
+                g[v].add(u);
+            }
+            solve(g, a);
+        }
+    }
+
+
+    static class FastScanner {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st = new StringTokenizer("""");
+
+        String next() {
+            while (!st.hasMoreTokens())
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        long[] readArrayLong(int n) {
+            long[] a = new long[n];
+            for (int i = 0; i < n; i++)
+                a[i] = nextLong();
+            return a;
+        }
+
+        int[] readArrayInt(int n) {
+            int[] a = new int[n];
+            for (int i = 0; i < n; i++)
+                a[i] = nextInt();
+            return a;
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+    }
+}","import java.io.OutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.PrintWriter;
+import java.util.InputMismatchException;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.io.InputStream;
+
+public class Main {
+    public static void main(String[] args) {
+        InputStream inputStream = System.in;
+        OutputStream outputStream = System.out;
+        FastReader in = new FastReader(inputStream);
+        PrintWriter out = new PrintWriter(outputStream);
+        CParsasHumongousTree solver = new CParsasHumongousTree();
+        int testCount = Integer.parseInt(in.next());
+        for (int i = 1; i <= testCount; i++)
+            solver.solve(i, in, out);
+        out.close();
+    }
+
+    static class CParsasHumongousTree {
+        int n;
+        long[][] dp;
+        int[] l;
+        int[] r;
+        ArrayList<Integer>[] a;
+
+        public void solve(int testNumber, FastReader in, PrintWriter out) {
+            n = in.nextInt();
+            l = new int[n];
+            r = new int[n];
+            dp = new long[n][2];
+            a = new ArrayList[n];
+            for (int i = 0; i < n; ++i) {
+                a[i] = new ArrayList<>();
+            }
+
+            for (int i = 0; i < n; ++i) {
+                l[i] = in.nextInt();
+                r[i] = in.nextInt();
+            }
+
+            for (int i = 0; i < n - 1; ++i) {
+                int u = in.nextInt() - 1, v = in.nextInt() - 1;
+                a[u].add(v);
+                a[v].add(u);
+            }
+
+            dfs(0, -1);
+
+            out.println(Math.max(dp[0][0], dp[0][1]));
+        }
+
+        void dfs(int u, int p) {
+            dp[u][0] = dp[u][1] = 0;
+            for (int v : a[u]) {
+                if (v != p) {
+                    dfs(v, u);
+                    dp[u][0] += Math.max(dp[v][0] + Math.abs(l[u] - l[v]), dp[v][1] + Math.abs(l[u] - r[v]));
+                    dp[u][1] += Math.max(dp[v][0] + Math.abs(r[u] - l[v]), dp[v][1] + Math.abs(r[u] - r[v]));
+                }
+            }
+        }
+
+    }
+
+    static class FastReader {
+        private InputStream stream;
+        private byte[] buf = new byte[1024];
+        private int curChar;
+        private int numChars;
+        private FastReader.SpaceCharFilter filter;
+
+        public FastReader(InputStream stream) {
+            this.stream = stream;
+        }
+
+        public int read() {
+            if (numChars == -1) throw new InputMismatchException();
+            if (curChar >= numChars) {
+                curChar = 0;
+                try {
+                    numChars = stream.read(buf);
+                } catch (IOException e) {
+                    throw new InputMismatchException();
+                }
+                if (numChars <= 0) return -1;
+            }
+            return buf[curChar++];
+        }
+
+        public int nextInt() {
+            int c = read();
+            while (isSpaceChar(c)) c = read();
+            int sgn = 1;
+            if (c == '-') {
+                sgn = -1;
+                c = read();
+            }
+            int res = 0;
+            do {
+                if (c < '0' || c > '9') throw new InputMismatchException();
+                res *= 10;
+                res += c - '0';
+                c = read();
+            }
+            while (!isSpaceChar(c));
+            return res * sgn;
+        }
+
+        public String next() {
+            int c = read();
+            while (isSpaceChar(c)) c = read();
+            StringBuilder res = new StringBuilder();
+            do {
+                res.appendCodePoint(c);
+                c = read();
+            } while (!isSpaceChar(c));
+            return res.toString();
+        }
+
+        public boolean isSpaceChar(int c) {
+            if (filter != null) return filter.isSpaceChar(c);
+            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
+        }
+
+        public interface SpaceCharFilter {
+            public boolean isSpaceChar(int ch);
+
+        }
+
+    }
+}
+
+",0
+52cd85f2,ff34fab2,"import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.StringTokenizer;
+
+public class PC3C {
+	static PrintWriter out = new PrintWriter(System.out);
+	static MyFastReaderPC3C in = new MyFastReaderPC3C();
+	static long mod = (long) (1e9 + 7);
+
+	public static void main(String[] args) throws Exception {
+		
+		int test = i();
+		while (test-- > 0) {
+			 
+             int n=i();
+             int[] arr=arrI(n);
+             String s=string();
+             
+             ArrayList<Integer> lR=new ArrayList<>();
+
+             ArrayList<Integer> lB=new ArrayList<>();
+             for(int i=0;i<n;i++) {
+            	
+            	if(s.charAt(i)=='R') lR.add(arr[i]);
+            	else lB.add(arr[i]);
+            	 
+             }
+             
+             
+             Collections.sort(lB);
+             Collections.sort(lR,Collections.reverseOrder());
+             
+             
+             int k=1;
+             boolean st=true;
+             for(int i=0;i<lB.size();i++) {
+            	 
+            	 if(lB.get(i)>=k) {
+            		k+=1; 
+            	 }
+            	 else {
+            		st=false;
+            		break;
+            	 }
+            		 
+             }
+             boolean st2=true;
+               k=n;
+               for(int i=0;i<lR.size();i++) {
+            	 
+            	 if(lR.get(i)>k) {
+            	   st2=false;
+            	   break;
+            	 }
+            	 else {
+            		k-=1; 
+            	 }
+            		 
+             }
+               
+               if(st && st2) out.print(""YES"");
+               else out.print(""NO"");
+             
+             
+			out.print(""\n"");
+			out.flush();
+		}
+		out.close();
+	}
+
+	static class pair {
+		long x, y;
+
+		pair(long ar, long ar2) {
+			x = ar;
+			y = ar2;
+		}
+	}
+
+	static void sort(long[] a) // check for long
+	{
+		ArrayList<Long> l = new ArrayList<>();
+		for (long i : a)
+			l.add(i);
+		Collections.sort(l);
+		for (int i = 0; i < a.length; i++)
+			a[i] = l.get(i);
+	}
+
+	static void sort(int[] a) {
+		ArrayList<Integer> l = new ArrayList<>();
+		for (int i : a)
+			l.add(i);
+		Collections.sort(l);
+		for (int i = 0; i < a.length; i++)
+			a[i] = l.get(i);
+	}
+
+	public static int gcd(int a, int b) {
+		if (a == 0)
+			return b;
+		return gcd(b % a, a);
+	}
+
+	static class DescendingComparator implements Comparator<Integer> {
+		public int compare(Integer a, Integer b) {
+			return b - a;
+		}
+	}
+
+	static class AscendingComparator implements Comparator<Integer> {
+		public int compare(Integer a, Integer b) {
+			return a - b;
+		}
+	}
+
+	static boolean isPalindrome(char X[]) {
+		int l = 0, r = X.length - 1;
+		while (l <= r) {
+			if (X[l] != X[r])
+				return false;
+			l++;
+			r--;
+		}
+		return true;
+	}
+
+	static long fact(long N) {
+		long num = 1L;
+		while (N >= 1) {
+			num = ((num % mod) * (N % mod)) % mod;
+			N--;
+		}
+		return num;
+	}
+
+	static long pow(long a, long b) {
+		long mod = 1000000007;
+		long pow = 1;
+		long x = a;
+		while (b != 0) {
+			if ((b & 1) != 0)
+				pow = (pow * x) % mod;
+			x = (x * x) % mod;
+			b /= 2;
+		}
+		return pow;
+	}
+
+	static long toggleBits(long x)// one's complement || Toggle bits
+	{
+		int n = (int) (Math.floor(Math.log(x) / Math.log(2))) + 1;
+
+		return ((1 << n) - 1) ^ x;
+	}
+
+	static int countBits(long a) {
+		return (int) (Math.log(a) / Math.log(2) + 1);
+	}
+
+	static boolean isPrime(long N) {
+		if (N <= 1)
+			return false;
+		if (N <= 3)
+			return true;
+		if (N % 2 == 0 || N % 3 == 0)
+			return false;
+		for (int i = 5; i * i <= N; i = i + 6)
+			if (N % i == 0 || N % (i + 2) == 0)
+				return false;
+		return true;
+	}
+
+	static long GCD(long a, long b) {
+		if (b == 0) {
+			return a;
+		} else
+			return GCD(b, a % b);
+	}
+
+	// Debugging Functions Starts
+
+	static void print(char A[]) {
+		for (char c : A)
+			System.out.print(c + "" "");
+		System.out.println();
+	}
+
+	static void print(boolean A[]) {
+		for (boolean c : A)
+			System.out.print(c + "" "");
+		System.out.println();
+	}
+
+	static void print(int A[]) {
+		for (int a : A)
+			System.out.print(a + "" "");
+		System.out.println();
+	}
+
+	static void print(long A[]) {
+		for (long i : A)
+			System.out.print(i + "" "");
+		System.out.println();
+
+	}
+
+	static void print(ArrayList<Integer> A) {
+		for (int a : A)
+			System.out.print(a + "" "");
+		System.out.println();
+	}
+
+	// Debugging Functions END
+	// ----------------------
+	// IO FUNCTIONS STARTS
+	static HashMap<Integer, Integer> getHashMap(int A[]) {
+		HashMap<Integer, Integer> mp = new HashMap<>();
+		for (int a : A) {
+			int f = mp.getOrDefault(a, 0) + 1;
+			mp.put(a, f);
+		}
+		return mp;
+	}
+
+	public static Map<Character, Integer> mapSortByValue(Map<Character, Integer> hm) {
+		// Create a list from elements of HashMap
+		List<Map.Entry<Character, Integer>> list = new LinkedList<Map.Entry<Character, Integer>>(hm.entrySet());
+
+		// Sort the list
+		Collections.sort(list, new Comparator<Map.Entry<Character, Integer>>() {
+			public int compare(Map.Entry<Character, Integer> o1, Map.Entry<Character, Integer> o2) {
+				return o1.getValue() - o2.getValue();
+			}
+		});
+
+		// put data from sorted list to hashmap
+		Map<Character, Integer> temp = new LinkedHashMap<Character, Integer>();
+		for (Map.Entry<Character, Integer> aa : list) {
+			temp.put(aa.getKey(), aa.getValue());
+		}
+		return temp;
+	}
+	static String string() {
+		return in.nextLine();
+	}
+
+	static int i() {
+		return in.nextInt();
+	}
+
+	static long l() {
+		return in.nextLong();
+	}
+
+	static int[] arrI(int N) {
+		int A[] = new int[N];
+		for (int i = 0; i < N; i++) {
+			A[i] = in.nextInt();
+		}
+		return A;
+	}
+
+	static long[] arrL(int N) {
+		long A[] = new long[N];
+		for (int i = 0; i < A.length; i++)
+			A[i] = in.nextLong();
+		return A;
+	}
+
+}
+
+class MyFastReaderPC3C {
+	BufferedReader br;
+	StringTokenizer st;
+
+	public MyFastReaderPC3C() {
+		br = new BufferedReader(new InputStreamReader(System.in));
+	}
+
+	String next() {
+		while (st == null || !st.hasMoreElements()) {
+			try {
+				st = new StringTokenizer(br.readLine());
+			} catch (IOException e) {
+				e.printStackTrace();
+			}
+		}
+		return st.nextToken();
+	}
+
+	int nextInt() {
+		return Integer.parseInt(next());
+	}
+
+	long nextLong() {
+		return Long.parseLong(next());
+	}
+
+	double nextDouble() {
+		return Double.parseDouble(next());
+	}
+
+	String nextLine() {
+		String str = """";
+		try {
+			str = br.readLine();
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+		return str;
+	}
+}
+","import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.PriorityQueue;
+import java.util.Queue;
+import java.util.Stack;
+import java.util.StringTokenizer;
+import java.util.TreeMap;
+import java.util.TreeSet;
+
+import java.io.*;
+ 
+public class Div2 {
+	
+	private static class MyScanner {
+	    BufferedReader br;
+	    StringTokenizer st;
+
+	    public MyScanner() {
+	       br = new BufferedReader(new InputStreamReader(System.in));
+	    }
+
+	    String next() {
+	        while (st == null || !st.hasMoreElements()) {
+	            try {
+	                st = new StringTokenizer(br.readLine());
+	            } catch (IOException e) {
+	                e.printStackTrace();
+	            }
+	        }
+	        return st.nextToken();
+	    }
+
+	    int nextInt() {
+	        return Integer.parseInt(next());
+	    }
+
+	    long nextLong() {
+	        return Long.parseLong(next());
+	    }
+
+	    double nextDouble() {
+	        return Double.parseDouble(next());
+	    }
+
+	    String nextLine(){
+	        String str = """";
+		  try {
+		     str = br.readLine();
+		  } catch (IOException e) {
+		     e.printStackTrace();
+		  }
+		  return str;
+	    }
+
+	 }
+
+	 public static String solution(int [] arr, int n, String st) 
+	 {
+        ArrayList<Integer> red = new ArrayList<>();
+        ArrayList<Integer> blue = new ArrayList<>();
+        
+        for(int i = 0; i<n; i++)
+        {
+        	if(st.charAt(i)=='R')
+        		red.add(arr[i]);
+        	else
+        		blue.add(arr[i]);
+        }
+	    	
+        Collections.sort(red);
+        Collections.sort(blue);
+        int cb = 1;
+        
+        for(int j = 0; j<blue.size(); j++)
+        {
+            if(blue.get(j)<cb)
+            	return ""NO"";
+            cb++;
+        }
+        
+        int cr = n;
+        for(int j = red.size()-1; j>=0; j--)
+        {
+            if(red.get(j)>cr)
+            	return ""NO"";
+            cr--;
+        }
+        
+        return ""YES"";
+
+	 }
+        
+private static PrintWriter out = new PrintWriter(System.out);
+
+public static void main (String[] args)
+{
+	MyScanner s =  new MyScanner();
+	  
+    int t = s.nextInt();
+    
+    for(int j = 0; j<t ; j++)
+    {
+    	int n = s.nextInt();
+    	int[] arr = new int[n];
+    	for(int i =0; i<n; i++)
+    		arr[i] = s.nextInt();
+    	
+    	String st = s.next();
+   
+    	out.println(solution(arr,n, st));
+    }
+    
+		     
+    out.flush();
+    out.close();
+    
+}
+}
+
+",0
+cc9230d3,ec558d69,"import java.io.BufferedReader;
+import java.util.StringTokenizer;
+import java.io.InputStreamReader;
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.util.ArrayList;
+
+public class C {
+
+
+    static int[][] lr = new int[2][(int)2e5+10];
+    static long[][] dp = new long[2][(int)2e5+10];
+    static ArrayList<ArrayList<Integer>> g;
+    public static void main(String[] args) {
+        
+        FastReader fr = new FastReader();
+        PrintWriter out = new PrintWriter(System.out, true);
+        int cases = fr.nextInt();
+        for(int c = 0; c < cases; c++) {
+            int nodes = fr.nextInt();
+            g = new ArrayList<ArrayList<Integer>>();
+            
+            for(int i = 1; i <= nodes; i++) {
+                lr[0][i] = fr.nextInt();
+                lr[1][i] = fr.nextInt();
+            }
+            for(int i = 0; i <= nodes; i++) {
+                g.add(new ArrayList<Integer>());
+            }
+
+            for(int i = 0; i < nodes-1; i++) {
+                int f = fr.nextInt();
+                int t = fr.nextInt();
+                g.get(f).add(t);
+                g.get(t).add(f);
+            }
+            DFS(1, -1);
+            out.write(Math.max(dp[0][1], dp[1][1]) + ""\n"");
+
+        }
+        out.close();
+    }
+
+    static void DFS(int v, int p) {
+        dp[0][v] = dp[1][v] = 0;
+        for(Integer u : g.get(v)) {
+            if (u == p) continue;
+            DFS(u, v);
+            dp[0][v] += Math.max(Math.abs(lr[0][v] - lr[1][u]) + dp[1][u], dp[0][u] + Math.abs(lr[0][v] - lr[0][u]));
+            dp[1][v] += Math.max(Math.abs(lr[1][v] - lr[1][u]) + dp[1][u], dp[0][u] + Math.abs(lr[1][v] - lr[0][u]));
+        }
+    }
+
+    static class FastReader {
+
+        BufferedReader br;
+        StringTokenizer st;
+
+        public FastReader() {
+            this.br = new BufferedReader(new InputStreamReader(System.in));
+        }
+
+        String next() { 
+            while (st == null || !st.hasMoreElements()) {
+                try{
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt() { return Integer.parseInt(next()); }
+
+        long nextLong() { return Long.parseLong(next()); }
+
+        double nextDouble() { return Double.parseDouble(next()); }
+
+        String nextLine() {
+            String str = """";
+            try {
+                str = br.readLine();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+        }
+    }
+}
+","import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+public class Main 
+{
+    static int N=(int)2e5+10;
+    static int[][] A=new int[2][N];
+    static long[][] dp=new long[2][N];
+    static ArrayList<ArrayList<Integer>> links=new ArrayList<>(N);
+    static {
+        for (int i=0;i<N;i++)
+            links.add(new ArrayList<>());
+    }
+    static void dfs(int v,int p) 
+    {
+        dp[0][v]=dp[1][v]=0;
+        for (Integer link :links.get(v))
+        {
+            if (link==p) continue;
+            dfs(link,v);
+            dp[0][v]+=Math.max(Math.abs(A[0][v]-A[0][link])+dp[0][link],Math.abs(A[0][v]-A[1][link])+dp[1][link]);
+            dp[1][v]+=Math.max(Math.abs(A[1][v]-A[0][link])+dp[0][link],Math.abs(A[1][v]-A[1][link])+dp[1][link]);
+        }
+    }
+
+	public static void main (String[] args) throws Exception
+	{
+		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+		int t=Integer.parseInt(br.readLine()),n,i;
+		while (t-->0)
+		{
+		    n=Integer.parseInt(br.readLine());
+		    for (i=1;i<=n;i++)
+		    {
+		        String[] in=br.readLine().split("" "");
+		        A[0][i]=Integer.parseInt(in[0]);
+		        A[1][i]=Integer.parseInt(in[1]);
+		        links.set(i,new ArrayList<>());
+		    }
+		    for (i=1;i<n;i++)
+		    {
+		        String[] in=br.readLine().split("" "");
+		        int a=Integer.parseInt(in[0]);
+		        int b=Integer.parseInt(in[1]);
+		        links.get(a).add(b);
+		        links.get(b).add(a);
+		    }
+		    dfs(1,-1);
+		    System.out.println(Math.max(dp[0][1],dp[1][1]));
+		}
+	}
+}
+
+",1
+3850468c,403e3270,"
+import java.io.*;
+import java.util.*;
+public class solution {
+	static long cr[][]=new long[1001][1001];
+	//static double EPS = 1e-7;
+   static long mod=1000000007;
+   
+public static void main(String[] args)  {
+	FScanner sc = new FScanner();
+	//Arrays.fill(prime, true);
+	//sieve();
+	
+	//ncr();
+	int t=sc.nextInt();
+	StringBuilder sb = new StringBuilder();
+      while(t-->0) {	
+      int n=sc.nextInt();
+      long arr[]=new long[n];
+      long dp[]=new long[n];
+      long sum=0;
+      for(int i=0;i<n;i++)
+      {
+    	  arr[i]=sc.nextInt();
+    	  dp[i]=arr[i];
+      }
+        
+      long l=0;long r=1000000000;
+      long ans=0;
+      while(l<=r)
+      {
+    	  long mid=(l+r)/2;
+    	  dp=Arrays.copyOf(arr, n);
+    	  if(solve(arr,dp,mid,n) )
+    	  {
+    		  ans=mid;
+    		  l=mid+1;
+    	  }
+    	  else
+    		  r=mid-1;
+    	  
+      }
+      
+      sb.append(ans);
+        sb.append(""\n"");
+	}
+      System.out.println(sb.toString());
+}  
+ public static boolean solve(long arr[],long dp[],long sum,int n)
+ {  
+	  
+	 for(int i=n-1;i>1;i--)
+     {    if(dp[i]<=sum)
+   	      continue;
+   	  long val=Math.min(arr[i],dp[i]-sum)/3;
+   	  dp[i-1]+=val;
+   	  dp[i-2]+=2*val;
+     }
+     long min=Integer.MAX_VALUE;
+     for(int i=0;i<n;i++)
+     {
+   	  min=Math.min(min,dp[i]);
+     }
+     if(min>=sum)
+    	 return true;
+     else
+     return false;
+ }
+
+public static long gcd(long a,long b)
+{   
+	
+     return b==0 ? a:gcd(b,a%b);	
+	
+}
+     
+ /* public static void sieve()
+{   prime[0]=prime[1]=false;
+int n=1000000;
+	for(int p = 2; p*p <=n; p++)
+    {
+        if(prime[p] == true)
+        {
+          
+            for(int i = p*p; i <= n; i += p)
+                prime[i] = false;
+        }
+    }
+   */
+
+public static void ncr()
+{
+	cr[0][0]=1;
+	for(int i=1;i<=1000;i++)
+	{
+		cr[i][0]=1;
+		for(int j=1;j<i;j++)
+		{
+			cr[i][j]=(cr[i-1][j-1]+cr[i-1][j])%mod;
+		}
+		cr[i][i]=1;
+	}
+}
+
+}
+ 
+  class pair
+  //implements Comparable<pair> 
+  {
+	int a;int b;
+	 pair(int a,int b)
+	{   
+		this.b=b;
+		this.a=a;
+	}
+	
+}
+ 
+ class FScanner {
+	BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+	StringTokenizer sb = new StringTokenizer("""");
+ 
+	String next(){
+		while(!sb.hasMoreTokens()){
+			try{
+				sb = new StringTokenizer(br.readLine());
+			} catch(IOException e){ }
+		}
+		return sb.nextToken();
+	}
+	String nextLine(){
+		try{ return br.readLine(); } 
+		catch(IOException e) { } return """";
+	}
+ 
+	int nextInt(){
+		return Integer.parseInt(next());
+	}
+ 
+	long nextLong() {
+		return Long.parseLong(next());
+	}
+ 
+	int[] readArray(int n) {
+		int a[] = new int[n];
+		for(int i=0;i<n;i++) a[i] = nextInt();
+		return a;
+	}
+ 
+	float nextFloat(){
+	return Float.parseFloat(next());
+	}
+	
+	double nextDouble(){
+	return Double.parseDouble(next());
+	}
+}","import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.text.DecimalFormat;
+import java.util.*;
+
+//import sun.nio.fs.RegistryFileTypeDetector;
+
+
+ 
+public class Codeforces {
+	static int mod= 998244353;
+	
+	public static void main(String[] args) throws Exception {
+		PrintWriter out=new PrintWriter(System.out);
+		FastScanner fs=new FastScanner();
+		int t=fs.nextInt();
+		
+		outer:while(t-->0) {
+			int n=fs.nextInt();
+			int arr[]=fs.readArray(n);
+			int l=0, r=1000000000;
+			while(l<r) {
+				int mid=(l+r+1)/2;
+				if(check(arr,mid)) {
+					l=mid;
+				}
+				else r=mid-1;
+			}
+			out.println(l);
+			
+//			System.out.println(check(arr,13));
+			
+		}
+		
+		out.close();
+		
+	}
+	static boolean check(int arr[],int min) {
+		int n=arr.length;
+		int brr[]=new int[n];
+		for(int i=n-1;i>1;i--) {
+			if(brr[i]+arr[i]<min) return false;
+			int cur= Math.min(arr[i], arr[i]+brr[i]-min);
+//			System.out.println(cur+"" "");
+			int d=cur/3;
+//			System.out.println(d);
+			brr[i-1]+=d;
+			brr[i-2]+=2*d;
+		}
+		
+		return (arr[0]+brr[0]>=min)&&(arr[1]+brr[1]>=min);
+	}
+	static long pow(long a,long b) {
+		if(b<0) return 1;
+		long res=1;
+		while(b!=0) {
+			if((b&1)!=0) {
+				res*=a;
+				res%=mod;
+			}
+			a*=a;
+			a%=mod;
+			b=b>>1;
+		}
+		return res;
+	}
+	static int gcd(int  a,int  b) {
+		if(b==0) return a;
+		return gcd(b,a%b);
+	}
+	static long nck(int n,int k) {
+		if(k>n) return 0;
+		long res=1;
+		res*=fact(n);
+		res%=mod;
+		res*=modInv(fact(k));
+		res%=mod;
+		res*=modInv(fact(n-k)); 
+		res%=mod;
+		return res;
+	}
+	static long fact(long n) {
+//		return fact[(int)n];
+		long res=1;
+		for(int i=2;i<=n;i++) {
+			res*=i;
+			res%=mod;
+		}
+		return res;
+	}
+	
+	static long modInv(long n) {
+		return pow(n,mod-2);
+	}
+	
+	static void sort(int[] a) {
+		//suffle
+		int n=a.length;
+		Random r=new Random();
+		for (int i=0; i<a.length; i++) {
+			int oi=r.nextInt(n);
+			int temp=a[i];
+			a[i]=a[oi];
+			a[oi]=temp;
+		}
+		
+		//then sort
+		Arrays.sort(a);
+	}
+	
+	// Use this to input code since it is faster than a Scanner
+	static class FastScanner {
+		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st=new StringTokenizer("""");
+		String next() {
+			while (!st.hasMoreTokens())
+				try {
+					st=new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			return st.nextToken();
+		}
+		
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+		long[] lreadArray(int n) {
+			long a[]=new long[n];
+			for(int i=0;i<n;i++) a[i]=nextLong();
+			return a;
+		}
+		int[] readArray(int n) {
+			int[] a=new int[n];
+			for (int i=0; i<n; i++) a[i]=nextInt();
+			return a;
+		}
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+	}
+ 
+}",0
+fadc1365,fdd85afb,"import java.io.PrintWriter;
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.*;
+public class a{ 
+    public static void main(String args[]) throws java.lang.Exception{ 
+    	FastScanner s=new FastScanner();
+		PrintWriter out=new PrintWriter(System.out);
+		int t=s.nextInt();
+		for(int tt=0;tt<t;tt++) {
+			int n=s.nextInt(),k=s.nextInt();
+			int pos[]=s.readArray(k);
+			int temp[]=s.readArray(k);
+			long ans[]=new long[n];
+			Arrays.fill(ans,Integer.MAX_VALUE);
+			for(int i=0;i<k;i++){
+				ans[pos[i]-1]=temp[i];
+			}
+			for(int i=1;i<n;i++){
+				ans[i]=Math.min(ans[i-1]+1,ans[i]);
+			}
+			for(int i=n-2;i>=0;i--){
+				ans[i]=Math.min(ans[i],ans[i+1]+1);
+			}
+			for(int i=0;i<n;i++){
+				out.print(ans[i]+"" "");
+			}
+			out.println();
+		}
+		out.close();
+    }
+	static boolean isPrime(int n){
+        if (n <= 1)
+            return false;
+        else if (n == 2)
+            return true;
+        else if (n % 2 == 0)
+            return false;
+        for (int i = 3; i <= Math.sqrt(n); i += 2){
+            if (n % i == 0)
+                return false;
+        }
+        return true;
+    }
+    static void sort(long [] a) {
+		ArrayList<Long> l=new ArrayList<>();
+		for (long i:a) l.add(i);
+		Collections.sort(l);
+		for (int i=0; i<a.length; i++) a[i]=l.get(i);
+	}
+	static void sort(char [] a) {
+		ArrayList<Character> l=new ArrayList<>();
+		for (char i:a) l.add(i);
+		Collections.sort(l);
+		for (int i=0; i<a.length; i++) a[i]=l.get(i);
+	}
+    static void sort(int [] a) {
+		ArrayList<Integer> l=new ArrayList<>();
+		for (int i:a) l.add(i);
+		Collections.sort(l);
+		for (int i=0; i<a.length; i++) a[i]=l.get(i);
+	}
+    static int gcd(int a, int b){
+      if (b == 0)
+        return a;
+      return gcd(b, a % b);
+    }
+    static void sortcol(int a[][],int c) {
+		Arrays.sort(a, (x, y) -> {
+			if(x[c]>y[c]) {
+				return 1;
+			}else {
+				return -1;
+			}
+		});
+	}
+    public static void printb(boolean ans) {
+    	if(ans) {
+    		System.out.println(""Yes"");
+    	}else {
+    		System.out.println(""No"");
+    	}
+    }
+    static class FastScanner {
+		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st=new StringTokenizer("""");
+		String next() {
+			while (!st.hasMoreTokens())
+				try {
+					st=new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			return st.nextToken();
+		}
+		double nextDouble() {
+			return Double.parseDouble(next());
+		}
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+		int[] readArray(int n) {
+			int[] a=new int[n];
+			for (int i=0; i<n; i++) a[i]=nextInt();
+			return a;
+		}
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+	}
+    static class Pair implements Comparable<Pair>{
+    	int a , b; 
+    	Pair(int x , int y){
+    		a=x;
+    		b=y;
+    	}
+    	public int compareTo(Pair o) {
+    		return a != o.a ? a - o.a : b - o.b;
+    	}
+    }
+}
+","import java.util.*;
+
+public class Solution{
+    public static void main(String[] args){
+        Scanner sc=new Scanner(System.in);
+        int t=sc.nextInt();
+        long max=(long)1e18;
+        StringBuilder sb=new StringBuilder();
+        while(t-->0){
+            int n=sc.nextInt();
+            int k=sc.nextInt();
+            long[] ans=new long[n+1];
+            long[] tem=new long[n+1];
+            int[] item=new int[k];
+            
+            Arrays.fill(ans,max);
+            
+            for(int i=0;i<k;i++){
+                item[i]=sc.nextInt();
+               
+            }
+            for(int i=0;i<k;i++){
+                tem[item[i]]=sc.nextLong();
+            }
+            for(int i=n;i>=1;i--){
+                 if(tem[i]!=0){
+                     if(i==n)ans[i]=Math.min(ans[i],tem[i]);
+                     else{ ans[i]=Math.min(ans[i],ans[i+1]+1);
+                           ans[i]=Math.min(tem[i],ans[i]);
+                           
+                     }
+                 }
+                 else{
+                     if(i<n)ans[i]=Math.min(ans[i],ans[i+1]+1);
+                   
+                 }
+            }
+               for(int i=1;i<=n;i++){
+                 if(tem[i]!=0){
+                     if(i==1)ans[i]=Math.min(ans[i],tem[i]);
+                     else{ ans[i]=Math.min(ans[i],ans[i-1]+1);
+                     ans[i]=Math.min(tem[i],ans[i]);
+                     }
+                 }
+                 else{
+                     if(i>1)ans[i]=Math.min(ans[i],ans[i-1]+1);
+                   
+                 }
+            }
+            for(int i=1;i<=n;i++){
+              
+                sb.append(ans[i]+"" "");
+            }
+            sb.append(""\n"");
+        }
+        System.out.println(sb);
+    }
+}",0
+66565156,6f393cfe,"import java.io.*;
+import java.util.*;
+
+public class A1 {
+    static final Reader s = new Reader();
+    static final PrintWriter out = new PrintWriter(System.out);
+
+    public static void main(String[] args) throws IOException {
+        int t  = s.nextInt();
+//        int t=1;
+        for(int i=1; i<=t; ++i) {
+//            out.print(""Case #""+i+"": "");
+            new Solver();
+        }
+        out.close();
+    }
+    static class Solver {
+    	Solver() {
+    		int n = s.nextInt();
+    		String[] a = new String[n];
+    		int[][] cnt = new int[n][5];
+    		for(int i=0;i<n;i++) {
+    			char[] g = s.next().toCharArray();
+    			for(int j=0;j<g.length;j++) {
+    				cnt[i][g[j]-'a']++;
+    			}
+    		}
+    		int g=0;
+    		for(int i=0;i<5;i++) {
+    			List<Integer> l = new ArrayList<>();
+    			for(int j=0;j<n;j++) {
+    				int sum=0;
+    				for(int k=0;k<5;k++) {
+    					if(i==k)sum+=cnt[j][k];
+    					else sum-=cnt[j][k];
+    				}
+    				l.add(sum);
+    			}
+    			Collections.sort(l,Collections.reverseOrder());
+    			int f=0;
+    			int v=0;
+    			for(int h:l) {
+    				v += h;
+    				if(v > 0)f++;
+    				else break;
+    			}
+    			g = Math.max(g, f);
+    		}
+    		out.println(g);
+    	}
+    }
+    static class Reader {
+        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st;
+        String next() {
+            while(st==null||!st.hasMoreTokens()) {
+                try {
+                    st=new StringTokenizer(in.readLine());
+                } catch(Exception e) {}
+            }
+            return st.nextToken();
+        }
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+    }
+
+}
+","import java.io.*;
+import java.util.*;
+
+public class C {
+
+    public static void main(String[] args) throws Exception{
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
+        try{
+            int t = Integer.parseInt(br.readLine());
+            while(t-->0){
+                int n = Integer.parseInt(br.readLine());
+                int lst[][] = new int[n][5];
+                for(int i=0; i<n; i++){
+                    String s = br.readLine();
+                    for(int j=0; j<s.length(); j++){
+                        lst[i][s.charAt(j)-'a']++;
+                    }
+                }
+                int fans = Integer.MIN_VALUE;
+                for(int i=0; i<5; i++){
+                    int val[] = new int[n];
+                    for(int k=0; k<n; k++){
+                        int sum = 0;
+                        for(int j=0; j<5; j++){
+                            if(i==j){
+                                sum += lst[k][j];
+                            }else{
+                                sum -= lst[k][j];
+                            }
+                        }
+                        val[k] = sum;
+                    }
+                    Arrays.sort(val);
+                    int sum = 0;
+                    int ans = 0;
+                    for(int x = n-1; x>=0; x--){
+                        sum+=val[x];
+                        if(sum>0){
+                            ans++;
+                        }else{
+                            break;
+                        }
+                    }
+                    fans = Math.max(fans, ans);
+                }
+                bw.write(fans+""\n"");
+            }
+            bw.flush();
+        }catch(Exception e){
+            return;
+        }
+    }
+    
+}",1
+0b04b41e,fdd41565,"import java.io.BufferedReader;
+import java.io.*;
+import java.util.*;
+
+public class josph {
+
+static BufferedReader br;
+
+
+static long mod = 1000000000 + 7;
+static HashSet<Integer> p = new HashSet<>();
+static boolean debug =true;
+// Arrays.sort(time , (a1,a2) -> (a1[0]-a2[0])); 2d array sort lamda
+public static void main(String[] args) throws Exception {
+br = new BufferedReader(new InputStreamReader(System.in));
+PrintWriter pr = new PrintWriter(System.out);
+int tc = 1;
+tc= cinI();
+while(tc-->0){
+int n =cinI();
+String[] a= new String[n];
+
+int[][] f =new int[10][n];
+
+for(int i=0;i<n;i++){
+a[i]=cin();
+char[] x = a[i].toCharArray();
+
+for(char c:x){
+int index = c-'a';
+f[index][i]+=1;
+}
+for(int j=0;j<10;j++){
+int rem =x.length-f[j][i];
+f[j][i]-=rem;
+}
+}
+int max=0;
+for(int j=0;j<10;j++){
+Arrays.sort(f[j]);
+int cnt=0;
+int sum=0;
+for(int i=n-1;i>=0;i--){
+sum+=f[j][i];
+if(sum>0){
+cnt+=1;
+}
+else{
+break;
+}
+}
+max=max(max,cnt);
+}
+System.out.println(max);
+}
+
+}
+
+public static <E> void print(String var ,E e){
+if(debug==true){
+System.out.println(var +"" ""+e);
+}
+}
+private static long[] sort(long[] e){
+ArrayList<Long> x=new ArrayList<>();
+for(long c:e){
+x.add(c);
+}
+Collections.sort(x);
+long[] y = new long[e.length];
+for(int i=0;i<x.size();i++){
+y[i]=x.get(i);
+}
+return y;
+}
+public static void printDp(long[][] dp) {
+
+int n = dp.length;
+for (int i = 0; i < n; i++) {
+for (int j = 0; j < dp[0].length; j++) {
+System.out.print(dp[i][j] + "" "");
+}
+System.out.println();
+}
+}
+
+
+
+
+
+
+private static long gcd(long a, long b) {
+if (a == 0)
+return b;
+if (b == 0)
+return a;
+
+// base case
+if (a == b)
+return a;
+
+// a is greater
+if (a > b)
+return gcd(a % b, b);
+return gcd(a, b % a);
+}
+
+
+public static long min(long a, long b) {
+return Math.min(a, b);
+}
+
+public static int min(int a, int b) {
+return Math.min(a, b);
+}
+
+
+public static void sieve() {
+int[] pf = new int[100000000 + 1];
+//0 prime //1 not prime
+pf[0] = 1;
+pf[1] = 1;
+for (int j = 2; j <= 10000; j++) {
+
+if (pf[j] == 0) {
+p.add(j);
+for (int k = j * j; k < pf.length; k += j) {
+pf[k] = 1;
+}
+}
+}
+
+}
+
+
+public static int[] readArray(int n, int x, int z) throws Exception {
+int[] arr = new int[n];
+String[] ar = cinA();
+for (int i = x; i < n + x; i++) {
+arr[i] = getI(ar[i - x]);
+}
+return arr;
+}
+
+public static long[] readArray(int n, int x) throws Exception {
+long[] arr = new long[n];
+String[] ar = cinA();
+for (int i = x; i < n + x; i++) {
+arr[i] = getL(ar[i - x]);
+}
+return arr;
+}
+
+public static void arrinit(String[] a, long[] b) throws Exception {
+for (int i = 0; i < a.length; i++) {
+b[i] = Long.parseLong(a[i]);
+}
+}
+
+public static HashSet<Integer>[] Graph(int n, int edge, int directed) throws Exception {
+HashSet<Integer>[] tree = new HashSet[n];
+
+for (int j = 0; j < edge; j++) {
+
+String[] uv = cinA();
+int u = getI(uv[0]);
+int v = getI(uv[1]);
+if (directed == 0) {
+
+tree[v].add(u);
+}
+tree[u].add(v);
+}
+return tree;
+}
+
+public static void arrinit(String[] a, int[] b) throws Exception {
+for (int i = 0; i < a.length; i++) {
+b[i] = Integer.parseInt(a[i]);
+}
+}
+
+
+static double findRoots(int a, int b, int c) {
+// If a is 0, then equation is not
+//quadratic, but linear
+
+
+int d = b * b - 4 * a * c;
+double sqrt_val = Math.sqrt(Math.abs(d));
+
+
+// System.out.println(""Roots are real and different \n"");
+
+return Math.max((double) (-b + sqrt_val) / (2 * a),
+(double) (-b - sqrt_val) / (2 * a));
+
+
+}
+
+public static String cin() throws Exception {
+return br.readLine();
+}
+
+public static String[] cinA() throws Exception {
+return br.readLine().split("" "");
+}
+
+public static String[] cinA(int x) throws Exception {
+return br.readLine().split("""");
+}
+
+public static String ToString(Long x) {
+return Long.toBinaryString(x);
+}
+
+public static void cout(String s) {
+System.out.println(s);
+}
+
+public static Integer cinI() throws Exception {
+return Integer.parseInt(br.readLine());
+}
+
+public static int getI(String s) throws Exception {
+return Integer.parseInt(s);
+}
+
+public static long getL(String s) throws Exception {
+return Long.parseLong(s);
+}
+
+public static long max(long a, long b) {
+return Math.max(a, b);
+}
+
+public static int max(int a, int b) {
+return Math.max(a, b);
+}
+
+public static void coutI(int x) {
+System.out.println(String.valueOf(x));
+}
+
+public static void coutI(long x) {
+System.out.println(String.valueOf(x));
+}
+
+public static Long cinL() throws Exception {
+return Long.parseLong(br.readLine());
+}
+
+public static void arrInit(String[] arr, int[] arr1) throws Exception {
+for (int i = 0; i < arr.length; i++) {
+arr1[i] = getI(arr[i]);
+}
+
+}
+}","import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.*;
+public class Main
+{
+    public static void main(String args[])
+    {
+     FastReader s=new FastReader();
+     int t=s.nextInt();
+     while(t>0)
+     {
+      Solve solve=new Solve();
+      t--;
+      int n=s.nextInt();
+      String str[]=new String[n];
+      for(int i=0;i<n;i++)
+      str[i]=s.nextLine();
+      char array[]=new char[]{'a','b','c','d','e'};
+      int arr[]=new int[n];
+      int ans=0;
+      for(int i=0;i<5;i++)
+      {
+        Arrays.fill(arr,0);
+          for(int j=0;j<n;j++)
+          {
+                 for(int k=0;k<str[j].length();k++)
+                 {
+                     if(str[j].charAt(k)==array[i])
+                     arr[j]++;
+                     else
+                     arr[j]--;
+                 }
+          }
+          ans=(ans>solve.solve(arr,n))?ans:solve.solve(arr,n);
+      }
+      System.out.println(ans);
+     }
+    }
+}
+class Solve{
+    public int solve(int arr[],int n)
+    {
+        int ans=0;
+        int sum=0;
+        Arrays.sort(arr);
+        for(int i=n-1;i>=0;i--)
+        {
+            if(sum+arr[i]>0)
+            {
+                sum+=arr[i];
+                ans++;
+            }
+            else
+            break;
+        }
+        return ans;
+    }
+}
+class FastReader {
+    BufferedReader br;
+    StringTokenizer st;
+    public FastReader()
+    {
+        br = new BufferedReader(
+                new InputStreamReader(System.in));
+    }
+    String next()
+    {
+        while (st == null || !st.hasMoreElements()) {
+            try {
+                st = new StringTokenizer(br.readLine());
+            }
+            catch (IOException e) {
+                e.printStackTrace();
+            }
+        }
+        return st.nextToken();
+    }
+
+    int nextInt() { return Integer.parseInt(next()); }
+
+    long nextLong() { return Long.parseLong(next()); }
+
+    double nextDouble()
+    {
+        return Double.parseDouble(next());
+    }
+
+    String nextLine()
+    {
+        String str = """";
+        try {
+            str = br.readLine();
+        }
+        catch (IOException e) {
+            e.printStackTrace();
+        }
+        return str;
+    }
+}
+",0
+4a1573d6,db8d728d,"
+
+import java.util.*;
+import java.math.*;
+import java.io.*; 
+ public class A{
+
+static FastReader scan=new FastReader();
+ public static PrintWriter out = new PrintWriter (new BufferedOutputStream(System.out));
+  static LinkedList<Integer>edges[];
+  static boolean stdin = true;
+    static String filein = ""input"";
+    static String fileout = ""output"";
+static int dx[] = { -1, 0, 1, 0 };
+static int dy[] = { 0, 1, 0, -1 };
+int dx_8[]={1,1,1,0,0,-1,-1,-1};
+int dy_8[]={-1,0,1,-1,1,-1,0,1};
+static char sts[]={'U','R','D','L'};
+static boolean prime[];
+static long LCM(long a,long b){
+    return (Math.abs(a*b))/gcd(a,b);
+   }
+    public static int upperBound(long[] array, int length, long value) {
+        int low = 0;
+        int high = length;
+        while (low < high) {
+            final int mid = low+(high-low) / 2;
+            if ( array[mid]>value) {
+                high = mid ;
+            } else {
+                low = mid+1;
+            }
+        }
+        return low;
+    }
+   static long gcd(long a, long b) {
+    if(a!=0&&b!=0)
+        while((a%=b)!=0&&(b%=a)!=0);
+    return a^b;
+}
+static int countSetBits(int n) 
+    { 
+        int count = 0; 
+        while (n > 0) { 
+            if((n&1)!=1)
+                count++;
+            //count += n & 1; 
+            n >>= 1; 
+        } 
+        return count; 
+    } 
+ static void sieve(long n) 
+    { 
+        
+        prime = new boolean[(int)n+1]; 
+        for(int i=0;i<n;i++) 
+            prime[i] = true; 
+          
+        for(int p = 2; p*p <=n; p++) 
+        { 
+           
+            if(prime[p] == true) 
+            { 
+                
+                for(int i = p*p; i <= n; i += p) 
+                    prime[i] = false; 
+            } 
+        } 
+    }  
+  
+ 
+ 
+           static boolean isprime(long x)
+           {
+            for(long i=2;i*i<=x;i++)
+                if(x%i==0)
+                    return false;
+                return true;
+           }
+           static int perm=0,FOR=0;
+           
+     
+
+static boolean flag=false;
+static int len=100000000;
+
+static ArrayList<Pair>inters=new ArrayList<Pair>();
+
+
+
+
+
+static StringBuilder sb;
+static void swap(int i,int j,StringBuilder st)
+{
+    char tmp=st.charAt(i);
+    st.setCharAt(i,st.charAt(j));
+    st.setCharAt(j,tmp);
+}
+
+
+ private static int next(int[] arr, int target)  
+    {  
+        int start = 0, end = arr.length - 1;  
+    
+        int ans = -1;  
+        while (start <= end) {  
+            int mid = (start + end) / 2;  
+    
+            // Move to right side if target is  
+            // greater.  
+            if(arr[mid]==target)
+                return mid;
+            if (arr[mid] <target) {  
+                start = mid + 1;  
+            }  
+    
+            // Move left side.  
+            else {  
+                ans = mid;  
+                end = mid - 1;  
+            }  
+        }  
+        return ans;  
+    }  
+//static boolean vis[][];
+    static long solve(int h,long n,int cur)
+    {
+        if(h==0)
+            return 0;
+        long half=1L<<(h-1);
+        if(n<=half)
+        {
+            if((cur^1)==0)
+                return 1+solve(h-1,n,0);
+            else 
+                return 2*half+solve(h-1,n,0);
+        }
+        else 
+        {
+              if((cur^1)==0)
+             return 2*half+solve(h-1,n-half,1);
+            else 
+                return 1+solve(h-1,n-half,1);
+        }
+    }
+
+  
+public static class comp1 implements Comparator<String>{  
+public int compare(String o1,String o2){
+return o1.length()-o2.length(); 
+}
+  }
+  public static class comp2 implements Comparator<String>{  
+public int compare(String o1,String o2){
+return o1.compareTo(o2); 
+}
+  }
+  static StringBuilder a,b;
+
+    static boolean isPowerOfTwo(int n)
+{
+    if(n==0)
+    return false;
+ 
+return (int)(Math.ceil((Math.log(n) / Math.log(2)))) == 
+       (int)(Math.floor(((Math.log(n) / Math.log(2)))));
+}
+static ArrayList<Integer>v;
+static ArrayList<Integer>pows;
+static void block(long x) 
+{ 
+   v = new ArrayList<Integer>(); 
+      
+    pows=new ArrayList<Integer>();
+   
+    while (x > 0)  
+    { 
+        v.add((int)x % 3); 
+        x = x / 3; 
+    } 
+  
+    // Displaying the output when 
+    // the bit is '1' in binary 
+    // equivalent of number. 
+    for (int i = 0; i < v.size(); i++)  
+    { 
+        if (v.get(i)==1||v.get(i)==0)  
+        { 
+      pows.add(i); 
+
+        } 
+    } 
+
+} 
+
+
+   static long mod=(long)(1e9)+7;
+    static int countWaysUtil(int x, int n, int num) 
+    { 
+        // Base cases 
+        int val = (int) (x - Math.pow(num, n)); 
+        if (val == 0) 
+            return 1; 
+        if (val < 0) 
+            return 0; 
+       
+        // Consider two possibilities, num is 
+        // included and num is not included. 
+        return countWaysUtil(val, n, num + 1) + 
+               countWaysUtil(x, n, num + 1); 
+    }
+       static int countWays(int x, int n) 
+    { 
+        return countWaysUtil(x, n, 1); 
+    } 
+    static int dp[][];
+    static int n;
+    static int arr[];
+        static int rec(int i,int prev)
+        {
+            if(i==n)
+                return 0;
+            if(dp[i][prev]!=-1){
+                //out.println(""FUCK"");
+                return dp[i][prev];
+            }
+            if(i==0)
+                return dp[i][prev]=Math.max(rec(i+1,1),rec(i+1,0));
+            else 
+            return dp[i][prev]=Math.max(rec(i+1,0)+Math.abs(arr[i]-(prev==0?arr[i-1]:1)),rec(i+1,1)+Math.abs(1-(prev==0?arr[i-1]:1)));
+        }
+        static boolean can(int i,int j)
+        {
+            int x=i,y=j;
+            int x2=Math.abs(y-x),y2=y+x;
+            if(x>=x2&&y<=y2)
+                return true;
+            return false;
+        }
+public static void main(String[] args)  throws Exception 
+{
+//SUCK IT UP AND DO IT ALRIGHT
+//scan=new FastReader(""div7.in"");
+//out = new PrintWriter(""div7.out"");
+   //System.out.println(countSetBits(2015));
+    //int elem[]={1,2,3,4,5};
+//System.out.println(""avjsmlfpb"".compareTo(""avjsmbpfl""));
+int tt=1;
+
+/*for(int i=0;i<=100;i++)
+    if(prime[i])
+        arr.add(i);
+    System.out.println(arr.size());*/
+   // check(new StringBuilder(""05:11""));
+   // System.out.println(26010000000000L%150);
+   tt=scan.nextInt();
+
+outer:while(tt-->0)
+{
+ int n=scan.nextInt(),m=scan.nextInt();
+ char board[][]=new char[n][m];
+ for(int i=0;i<n;i++)
+    board[i]=scan.next().toCharArray();
+ArrayList<Pair>res[]=new ArrayList[3*n*m];
+for(int i=0;i<3*n*m;i++)
+res[i]=new ArrayList();
+int k=0;
+for(int i=0;i<n;i++)
+{
+    for(int j=0;j<m;j++)
+    {
+        ArrayList<Pair>arr=new ArrayList<Pair>();
+        ArrayList<Pair>arr2=new ArrayList<Pair>();
+        if(i+1<n&&j+1<m)
+        {
+            if(board[i][j]=='1')
+                arr.add(new Pair(i,j));
+            else arr2.add(new Pair(i,j));
+            if(board[i][j+1]=='1')
+                arr.add(new Pair(i,j+1));
+            else  arr2.add(new Pair(i,j+1));
+            
+            if(board[i+1][j]=='1')
+                arr.add(new Pair(i+1,j));
+            else arr2.add(new Pair(i+1,j));
+            if(board[i+1][j+1]=='1')
+                arr.add(new Pair(i+1,j+1));
+            else arr2.add(new Pair(i+1,j+1));
+            if(arr.size()==3)
+            {
+                for(Pair p:arr){
+                    board[p.x][p.y]='0';
+                    res[k].add(new Pair(p.x,p.y));
+                }
+                k++;
+            }
+            else if(arr.size()==2)
+            {
+                for(Pair p:arr2)
+                {
+                    board[p.x][p.y]='1';
+                     res[k].add(new Pair(p.x,p.y));
+                }
+                //k++;
+                Pair p=arr.get(0);
+                board[p.x][p.y]='0';
+                res[k].add(new Pair(p.x,p.y));
+                k++;
+                for(Pair pp:arr2)
+                {
+                    board[pp.x][pp.y]='0';
+                    res[k].add(new Pair(pp.x,pp.y));
+                }
+                p=arr.get(1);
+                board[p.x][p.y]='0';
+                res[k].add(new Pair(p.x,p.y));
+                k++;
+            }
+            else if(arr.size()==1)
+            {
+                Pair p=arr.get(0);
+                Pair tmp=new Pair(p.x,p.y);
+                board[p.x][p.y]='0';
+                res[k].add(new Pair(p.x,p.y));
+                p=arr2.get(1);
+                 board[p.x][p.y]='1';
+                res[k].add(new Pair(p.x,p.y));
+                  p=arr2.get(2);
+                 board[p.x][p.y]='1';
+                res[k].add(new Pair(p.x,p.y));
+                k++;
+                arr=new ArrayList();
+                arr.add(new Pair(arr2.get(1).x,arr2.get(1).y));
+                arr.add(new Pair(arr2.get(2).x,arr2.get(2).y));
+                arr2.remove(1);
+                arr2.remove(1);
+                arr2.add(new Pair(tmp.x,tmp.y));
+
+                for(Pair pp:arr2)
+                {
+                    board[pp.x][pp.y]='1';
+                     res[k].add(new Pair(pp.x,pp.y));
+                }
+                //k++;
+                 p=arr.get(0);
+                board[p.x][p.y]='0';
+                res[k].add(new Pair(p.x,p.y));
+                k++;
+                for(Pair pp:arr2)
+                {
+                    board[pp.x][pp.y]='0';
+                    res[k].add(new Pair(pp.x,pp.y));
+                }
+                p=arr.get(1);
+                board[p.x][p.y]='0';
+                res[k].add(new Pair(p.x,p.y));
+                k++;
+            }
+            else if(arr.size()==4)
+            {
+                Pair p=arr.get(0);
+                board[p.x][p.y]='0';
+                arr2.add(new Pair(p.x,p.y));
+                res[k].add(new Pair(p.x,p.y));
+                 p=arr.get(1);
+                board[p.x][p.y]='0';
+                arr2.add(new Pair(p.x,p.y));
+                  res[k].add(new Pair(p.x,p.y));
+
+                 p=arr.get(2);
+                board[p.x][p.y]='0';
+                arr2.add(new Pair(p.x,p.y));
+                  res[k].add(new Pair(p.x,p.y));
+                  k++;
+                arr.remove(0);
+                arr.remove(0);
+                arr.remove(0);
+                p=arr.get(0);
+
+                Pair tmp=new Pair(p.x,p.y);
+                board[p.x][p.y]='0';
+                res[k].add(new Pair(p.x,p.y));
+                p=arr2.get(1);
+                 board[p.x][p.y]='1';
+                res[k].add(new Pair(p.x,p.y));
+                  p=arr2.get(2);
+                 board[p.x][p.y]='1';
+                res[k].add(new Pair(p.x,p.y));
+                k++;
+                arr=new ArrayList();
+                arr.add(new Pair(arr2.get(1).x,arr2.get(1).y));
+                arr.add(new Pair(arr2.get(2).x,arr2.get(2).y));
+                arr2.remove(1);
+                arr2.remove(1);
+                arr2.add(new Pair(tmp.x,tmp.y));
+
+                for(Pair pp:arr2)
+                {
+                    board[pp.x][pp.y]='1';
+                     res[k].add(new Pair(pp.x,pp.y));
+                }
+                //k++;
+                 p=arr.get(0);
+                board[p.x][p.y]='0';
+                res[k].add(new Pair(p.x,p.y));
+                k++;
+                for(Pair pp:arr2)
+                {
+                    board[pp.x][pp.y]='0';
+                    res[k].add(new Pair(pp.x,pp.y));
+                }
+                p=arr.get(1);
+                board[p.x][p.y]='0';
+                res[k].add(new Pair(p.x,p.y));
+                k++;
+            }
+
+
+        }
+    }
+}
+/*for(int i=0;i<n;i++){
+for(int j=0;j<m;j++)
+{
+    out.print(board[i][j]+"" "");
+}
+out.println();
+}*/
+out.println(k);
+for(int i=0;i<k;i++)
+{
+    for(Pair p:res[i])
+        out.print((p.x+1)+"" ""+(p.y+1)+"" "");
+    out.println();
+}
+
+
+}
+
+
+
+
+ 
+out.close();
+
+//SEE UP 
+
+}
+static class special{
+    char c;
+    int idx;
+    special(char c,int idx)
+    {
+        this.c=c;
+        this.idx=idx;
+    }
+}
+static long binexp(long a,long n)
+{
+    if(n==0)
+        return 1;
+    long res=binexp(a,n/2);
+    if(n%2==1)
+        return res*res*a;
+    else 
+        return res*res;
+}
+static long fastPow(int base, int pow) {
+        if (pow==0)
+            return 1;
+        long half=fastPow(base, pow/2);
+        if (pow%2==0)
+            return half*half%mod;
+        return half*half%mod*base%mod;
+    }
+static long powMod(long base, long exp, long mod) {
+       if (base == 0 || base == 1) return base;
+       if (exp == 0) return 1;
+       if (exp == 1) return (base % mod+mod)%mod;
+       long R = (powMod(base, exp/2, mod) % mod+mod)%mod;
+       R *= R;
+       R %= mod;
+       if ((exp & 1) == 1) {
+           return (base * R % mod+mod)%mod;
+       }
+       else return (R %mod+mod)%mod;
+   }
+static double dis(double x1,double y1,double x2,double y2)
+{
+    return Math.sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2));
+}
+static long mod(long x,long y)
+    {
+        if(x<0)
+            x=x+(-x/y+1)*y;
+        return x%y;
+    }
+ public static  long pow(long b, long e) {
+            long r = 1;
+            while (e > 0) {
+                if (e % 2 == 1) r = r * b ;
+                b = b * b;
+                e >>= 1;
+            }
+            return r;
+        }
+private static void sort(long[] arr) {
+        List<Long> list = new ArrayList<>();
+        for (long object : arr) list.add(object);
+        Collections.sort(list);
+    //Collections.reverse(list);
+        for (int i = 0; i < list.size(); ++i) arr[i] = list.get(i);
+    }
+private static void sort2(long[] arr) {
+        List<Long> list = new ArrayList<>();
+        for (long object : arr) list.add(object);
+        Collections.sort(list);
+    Collections.reverse(list);
+        for (int i = 0; i < list.size(); ++i) arr[i] = list.get(i);
+    }
+ public static class FastReader {
+        BufferedReader br;
+        StringTokenizer root;
+        
+ 
+        public FastReader() {
+            br = new BufferedReader(new InputStreamReader(System.in));
+        }
+        FastReader(String filename)throws Exception
+        {
+
+            br=new BufferedReader(new FileReader(filename));
+        }
+
+        boolean hasNext(){
+            String line;
+            while(root.hasMoreTokens())
+                return true;
+            return false;
+        }
+ 
+        String next() {
+            while (root == null || !root.hasMoreTokens()) {
+                try {
+                    root = new StringTokenizer(br.readLine());
+                } catch (Exception addd) {
+                    addd.printStackTrace();
+                }
+            }
+            return root.nextToken();
+        }
+ 
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+ 
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+ 
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+ 
+        String nextLine() {
+            String str = """";
+            try {
+                str = br.readLine();
+            } catch (Exception addd) {
+                addd.printStackTrace();
+            }
+            return str;
+        }
+         public int[] nextIntArray(int arraySize) {
+            int array[] = new int[arraySize];
+ 
+            for (int i = 0; i < arraySize; i++) {
+                array[i] = nextInt();
+            }
+ 
+            return array;
+        }
+}
+ static class Pair implements Comparable<Pair>{
+        public int x, y;
+        public Pair(int x1, int y1) {
+            x=x1;
+            y=y1;
+        }
+        @Override
+        public int hashCode() {
+            return (int)(x + 31 * y);
+        }
+        public String toString() {
+            return x + "" "" + y;
+        }
+        @Override
+        public boolean equals(Object o){
+            if (o == this) return true;
+            if (o.getClass() != getClass()) return false;
+            Pair t = (Pair)o;
+            return t.x == x && t.y == y;
+        }
+public int compareTo(Pair o)
+{
+    return (o.y-y);
+
+    }
+
+static class pair{
+    int i;
+    int j;
+pair(int i,int j){
+    this.i=i;
+    this.j=j;
+}}}
+ static class tuple{
+        int x,y,z;
+        tuple(int a,int b,int c){
+            x=a;
+            y=b;
+            z=c;
+        }
+    }
+    static class Edge{
+        int d,w;
+        Edge(int d,int w)
+        {
+            this.d=d;
+            this.w=w;
+        }
+    }
+}
+
+
+
+
+
+
+
+
+
+","import java.util.*;
+import java.io.*;
+import java.math.*;
+import java.lang.*;
+
+public class BinaryTable {
+    
+    // static int mod = 998244353;
+    static int mod = 1000000007;
+
+    private static class FastReader {
+        BufferedReader br;
+        StringTokenizer st;
+ 
+        public FastReader() {
+            br = new BufferedReader(new
+            InputStreamReader(System.in));
+        }
+ 
+        String next() {
+            while (st == null || !st.hasMoreElements())
+            {
+                try
+                {
+                    st = new StringTokenizer(br.readLine());
+                }
+                catch (IOException  e)
+                {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+ 
+        int nextInt()
+        {
+            return Integer.parseInt(next());
+        }
+ 
+        long nextLong()
+        {
+            return Long.parseLong(next());
+        }
+ 
+        double nextDouble()
+        {
+            return Double.parseDouble(next());
+        }
+ 
+        String nextLine()
+        {
+            String str = """";
+            try
+            {
+                str = br.readLine();
+            }
+            catch (IOException e)
+            {
+                e.printStackTrace();
+            }
+            return str;
+        }
+    }
+
+    public static void main(String[] args) throws Exception {
+        FastReader scn = new FastReader();
+        PrintWriter pw = new PrintWriter(System.out);
+        int t = scn.nextInt();
+        outer : while(t-->0){
+            int n = scn.nextInt();
+            int m = scn.nextInt();
+            int[][] arr = new int[n][m];
+            for(int i=0; i<n; i++){
+            	String s = scn.nextLine();
+            	for(int j=0; j<m; j++){
+            		char ch = s.charAt(j);
+            		arr[i][j] = ch - '0';
+            	}
+            }
+            ArrayList<Pair> list = new ArrayList<>();
+            if(n % 2 == 0 && m % 2 == 0){
+            	for(int i=0; i<n; i+=2){
+            		for(int j=0; j<m; j+=2){
+            			if(arr[i][j] == 1 && arr[i][j+1] == 1 && arr[i+1][j] == 1 && arr[i+1][j+1] == 1){
+            				list.add(new Pair(i, j));
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i+1, j));
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i+1, j+1));
+            				list.add(new Pair(i+1, j));
+            				list.add(new Pair(i, j));
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i+1, j+1));
+            				list.add(new Pair(i, j));
+            				list.add(new Pair(i+1, j));
+            				list.add(new Pair(i+1, j+1));
+            			}else if(arr[i][j] == 1 && arr[i][j+1] == 1 && arr[i+1][j] == 1){
+            				list.add(new Pair(i, j));
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i+1, j));
+            			}else if(arr[i][j] == 1 && arr[i][j+1] == 1 && arr[i+1][j+1] == 1){
+            				list.add(new Pair(i, j));
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i+1, j+1));
+            			}else if(arr[i][j] == 1 && arr[i+1][j] == 1 && arr[i+1][j+1] == 1){
+            				list.add(new Pair(i, j));
+            				list.add(new Pair(i+1, j));
+            				list.add(new Pair(i+1, j+1));
+            			}else if(arr[i][j+1] == 1 && arr[i+1][j] == 1 && arr[i+1][j+1] == 1){
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i+1, j));
+            				list.add(new Pair(i+1, j+1));
+            			}else if(arr[i][j] == 1 && arr[i+1][j+1] == 1){
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i+1, j+1));
+            				list.add(new Pair(i+1, j));
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i+1, j));
+            				list.add(new Pair(i, j));
+            			}else if(arr[i][j+1] == 1 && arr[i+1][j] == 1){
+            				list.add(new Pair(i, j));
+            				list.add(new Pair(i+1, j+1));
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i+1, j+1));
+            				list.add(new Pair(i, j));
+            				list.add(new Pair(i+1, j));
+            			}else if(arr[i][j] == 1 && arr[i+1][j] == 1){
+            				list.add(new Pair(i, j));
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i+1, j+1));
+            				list.add(new Pair(i+1, j+1));
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i+1, j));
+            			}else if(arr[i][j] == 1 && arr[i][j+1] == 1){
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i+1, j+1));
+            				list.add(new Pair(i+1, j));
+            				list.add(new Pair(i+1, j));
+            				list.add(new Pair(i+1, j+1));
+            				list.add(new Pair(i, j));
+            			}else if(arr[i+1][j] == 1 && arr[i+1][j+1] == 1){
+            				list.add(new Pair(i, j));
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i+1, j+1));
+            				list.add(new Pair(i, j));
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i+1, j));
+            			}else if(arr[i][j+1] == 1 && arr[i+1][j+1] == 1){
+            				list.add(new Pair(i, j));
+            				list.add(new Pair(i+1, j));
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i, j));
+            				list.add(new Pair(i+1, j));
+            				list.add(new Pair(i+1, j+1));
+            			}else if(arr[i][j] == 1){
+            				list.add(new Pair(i, j));
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i+1, j));
+            				list.add(new Pair(i, j));
+            				list.add(new Pair(i+1, j+1));
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i+1, j+1));
+            				list.add(new Pair(i, j));
+            				list.add(new Pair(i+1, j));
+            			}else if(arr[i][j+1] == 1){
+            				list.add(new Pair(i, j));
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i+1, j+1));
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i+1, j+1));
+            				list.add(new Pair(i+1, j));
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i+1, j));
+            				list.add(new Pair(i, j));
+            			}else if(arr[i+1][j] == 1){
+            				list.add(new Pair(i, j));
+            				list.add(new Pair(i+1, j+1));
+            				list.add(new Pair(i+1, j));
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i+1, j+1));
+            				list.add(new Pair(i+1, j));
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i+1, j));
+            				list.add(new Pair(i, j));
+            			}else if(arr[i+1][j+1] == 1){
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i+1, j));
+            				list.add(new Pair(i+1, j+1));
+            				list.add(new Pair(i, j));
+            				list.add(new Pair(i+1, j+1));
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i+1, j+1));
+            				list.add(new Pair(i, j));
+            				list.add(new Pair(i+1, j));
+            			}
+            		}
+            	}
+            }else if(n % 2 == 0 && m % 2 == 1){
+            	int M = m-1;
+            	for(int i=0; i<n; i+=2){
+            		for(int j=0; j<M; j+=2){
+            			if(arr[i][j] == 1 && arr[i][j+1] == 1 && arr[i+1][j] == 1 && arr[i+1][j+1] == 1){
+            				list.add(new Pair(i, j));
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i+1, j));
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i+1, j+1));
+            				list.add(new Pair(i+1, j));
+            				list.add(new Pair(i, j));
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i+1, j+1));
+            				list.add(new Pair(i, j));
+            				list.add(new Pair(i+1, j));
+            				list.add(new Pair(i+1, j+1));
+            			}else if(arr[i][j] == 1 && arr[i][j+1] == 1 && arr[i+1][j] == 1){
+            				list.add(new Pair(i, j));
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i+1, j));
+            			}else if(arr[i][j] == 1 && arr[i][j+1] == 1 && arr[i+1][j+1] == 1){
+            				list.add(new Pair(i, j));
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i+1, j+1));
+            			}else if(arr[i][j] == 1 && arr[i+1][j] == 1 && arr[i+1][j+1] == 1){
+            				list.add(new Pair(i, j));
+            				list.add(new Pair(i+1, j));
+            				list.add(new Pair(i+1, j+1));
+            			}else if(arr[i][j+1] == 1 && arr[i+1][j] == 1 && arr[i+1][j+1] == 1){
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i+1, j));
+            				list.add(new Pair(i+1, j+1));
+            			}else if(arr[i][j] == 1 && arr[i+1][j+1] == 1){
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i+1, j+1));
+            				list.add(new Pair(i+1, j));
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i+1, j));
+            				list.add(new Pair(i, j));
+            			}else if(arr[i][j+1] == 1 && arr[i+1][j] == 1){
+            				list.add(new Pair(i, j));
+            				list.add(new Pair(i+1, j+1));
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i+1, j+1));
+            				list.add(new Pair(i, j));
+            				list.add(new Pair(i+1, j));
+            			}else if(arr[i][j] == 1 && arr[i+1][j] == 1){
+            				list.add(new Pair(i, j));
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i+1, j+1));
+            				list.add(new Pair(i+1, j+1));
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i+1, j));
+            			}else if(arr[i][j] == 1 && arr[i][j+1] == 1){
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i+1, j+1));
+            				list.add(new Pair(i+1, j));
+            				list.add(new Pair(i+1, j));
+            				list.add(new Pair(i+1, j+1));
+            				list.add(new Pair(i, j));
+            			}else if(arr[i+1][j] == 1 && arr[i+1][j+1] == 1){
+            				list.add(new Pair(i, j));
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i+1, j+1));
+            				list.add(new Pair(i, j));
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i+1, j));
+            			}else if(arr[i][j+1] == 1 && arr[i+1][j+1] == 1){
+            				list.add(new Pair(i, j));
+            				list.add(new Pair(i+1, j));
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i, j));
+            				list.add(new Pair(i+1, j));
+            				list.add(new Pair(i+1, j+1));
+            			}else if(arr[i][j] == 1){
+            				list.add(new Pair(i, j));
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i+1, j));
+            				list.add(new Pair(i, j));
+            				list.add(new Pair(i+1, j+1));
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i+1, j+1));
+            				list.add(new Pair(i, j));
+            				list.add(new Pair(i+1, j));
+            			}else if(arr[i][j+1] == 1){
+            				list.add(new Pair(i, j));
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i+1, j+1));
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i+1, j+1));
+            				list.add(new Pair(i+1, j));
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i+1, j));
+            				list.add(new Pair(i, j));
+            			}else if(arr[i+1][j] == 1){
+            				list.add(new Pair(i, j));
+            				list.add(new Pair(i+1, j+1));
+            				list.add(new Pair(i+1, j));
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i+1, j+1));
+            				list.add(new Pair(i+1, j));
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i+1, j));
+            				list.add(new Pair(i, j));
+            			}else if(arr[i+1][j+1] == 1){
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i+1, j));
+            				list.add(new Pair(i+1, j+1));
+            				list.add(new Pair(i, j));
+            				list.add(new Pair(i+1, j+1));
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i+1, j+1));
+            				list.add(new Pair(i, j));
+            				list.add(new Pair(i+1, j));
+            			}
+            		}
+            	}
+            	for(int i=0; i<n; i+=2){
+            		if(arr[i][m-1] == 1 && arr[i+1][m-1] == 1){
+            			list.add(new Pair(i, m-2));
+            			list.add(new Pair(i+1, m-2));
+            			list.add(new Pair(i+1, m-1));
+            			list.add(new Pair(i, m-2));
+            			list.add(new Pair(i+1, m-2));
+            			list.add(new Pair(i, m-1));
+            		}else if(arr[i][m-1] == 1){
+            			list.add(new Pair(i, m-2));
+            			list.add(new Pair(i, m-1));
+            			list.add(new Pair(i+1, m-1));
+            			list.add(new Pair(i, m-1));
+						list.add(new Pair(i+1, m-1));
+            			list.add(new Pair(i+1, m-2));
+            			list.add(new Pair(i, m-2));
+            			list.add(new Pair(i+1, m-2));
+            			list.add(new Pair(i, m-1));
+            		}else if(arr[i+1][m-1] == 1){
+            			list.add(new Pair(i, m-1));
+            			list.add(new Pair(i+1, m-2));
+            			list.add(new Pair(i+1, m-1));
+            			list.add(new Pair(i, m-2));
+            			list.add(new Pair(i+1, m-2));
+            			list.add(new Pair(i+1, m-1));
+            			list.add(new Pair(i+1, m-1));
+            			list.add(new Pair(i, m-1));
+           				list.add(new Pair(i, m-2));
+            		}
+            	}
+            }else if(n % 2 == 1 && m % 2 == 0){
+            	int N = n-1;
+            	for(int i=0; i<N; i+=2){
+            		for(int j=0; j<m; j+=2){
+            			if(arr[i][j] == 1 && arr[i][j+1] == 1 && arr[i+1][j] == 1 && arr[i+1][j+1] == 1){
+            				list.add(new Pair(i, j));
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i+1, j));
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i+1, j+1));
+            				list.add(new Pair(i+1, j));
+            				list.add(new Pair(i, j));
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i+1, j+1));
+            				list.add(new Pair(i, j));
+            				list.add(new Pair(i+1, j));
+            				list.add(new Pair(i+1, j+1));
+            			}else if(arr[i][j] == 1 && arr[i][j+1] == 1 && arr[i+1][j] == 1){
+            				list.add(new Pair(i, j));
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i+1, j));
+            			}else if(arr[i][j] == 1 && arr[i][j+1] == 1 && arr[i+1][j+1] == 1){
+            				list.add(new Pair(i, j));
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i+1, j+1));
+            			}else if(arr[i][j] == 1 && arr[i+1][j] == 1 && arr[i+1][j+1] == 1){
+            				list.add(new Pair(i, j));
+            				list.add(new Pair(i+1, j));
+            				list.add(new Pair(i+1, j+1));
+            			}else if(arr[i][j+1] == 1 && arr[i+1][j] == 1 && arr[i+1][j+1] == 1){
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i+1, j));
+            				list.add(new Pair(i+1, j+1));
+            			}else if(arr[i][j] == 1 && arr[i+1][j+1] == 1){
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i+1, j+1));
+            				list.add(new Pair(i+1, j));
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i+1, j));
+            				list.add(new Pair(i, j));
+            			}else if(arr[i][j+1] == 1 && arr[i+1][j] == 1){
+            				list.add(new Pair(i, j));
+            				list.add(new Pair(i+1, j+1));
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i+1, j+1));
+            				list.add(new Pair(i, j));
+            				list.add(new Pair(i+1, j));
+            			}else if(arr[i][j] == 1 && arr[i+1][j] == 1){
+            				list.add(new Pair(i, j));
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i+1, j+1));
+            				list.add(new Pair(i+1, j+1));
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i+1, j));
+            			}else if(arr[i][j] == 1 && arr[i][j+1] == 1){
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i+1, j+1));
+            				list.add(new Pair(i+1, j));
+            				list.add(new Pair(i+1, j));
+            				list.add(new Pair(i+1, j+1));
+            				list.add(new Pair(i, j));
+            			}else if(arr[i+1][j] == 1 && arr[i+1][j+1] == 1){
+            				list.add(new Pair(i, j));
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i+1, j+1));
+            				list.add(new Pair(i, j));
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i+1, j));
+            			}else if(arr[i][j+1] == 1 && arr[i+1][j+1] == 1){
+            				list.add(new Pair(i, j));
+            				list.add(new Pair(i+1, j));
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i, j));
+            				list.add(new Pair(i+1, j));
+            				list.add(new Pair(i+1, j+1));
+            			}else if(arr[i][j] == 1){
+            				list.add(new Pair(i, j));
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i+1, j));
+            				list.add(new Pair(i, j));
+            				list.add(new Pair(i+1, j+1));
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i+1, j+1));
+            				list.add(new Pair(i, j));
+            				list.add(new Pair(i+1, j));
+            			}else if(arr[i][j+1] == 1){
+            				list.add(new Pair(i, j));
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i+1, j+1));
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i+1, j+1));
+            				list.add(new Pair(i+1, j));
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i+1, j));
+            				list.add(new Pair(i, j));
+            			}else if(arr[i+1][j] == 1){
+            				list.add(new Pair(i, j));
+            				list.add(new Pair(i+1, j+1));
+            				list.add(new Pair(i+1, j));
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i+1, j+1));
+            				list.add(new Pair(i+1, j));
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i+1, j));
+            				list.add(new Pair(i, j));
+            			}else if(arr[i+1][j+1] == 1){
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i+1, j));
+            				list.add(new Pair(i+1, j+1));
+            				list.add(new Pair(i, j));
+            				list.add(new Pair(i+1, j+1));
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i+1, j+1));
+            				list.add(new Pair(i, j));
+            				list.add(new Pair(i+1, j));
+            			}
+            		}
+            	}
+            	for(int j=0; j<m; j+=2){
+            		if(arr[n-1][j] == 1 && arr[n-1][j+1] == 1){
+            			list.add(new Pair(n-2, j));
+            			list.add(new Pair(n-2, j+1));
+            			list.add(new Pair(n-1, j+1));
+            			list.add(new Pair(n-1, j));
+            			list.add(new Pair(n-2, j));
+            			list.add(new Pair(n-2, j+1));
+            		}else if(arr[n-1][j] == 1){
+            			list.add(new Pair(n-2, j));
+            			list.add(new Pair(n-1, j));
+            			list.add(new Pair(n-1, j+1));
+            			list.add(new Pair(n-1, j));
+						list.add(new Pair(n-1, j+1));
+            			list.add(new Pair(n-2, j+1));
+            			list.add(new Pair(n-2, j+1));
+            			list.add(new Pair(n-1, j));
+            			list.add(new Pair(n-2, j));
+            		}else if(arr[n-1][j+1] == 1){
+            			list.add(new Pair(n-1, j));
+            			list.add(new Pair(n-1, j+1));
+            			list.add(new Pair(n-2, j+1));
+            			list.add(new Pair(n-2, j));
+            			list.add(new Pair(n-1, j+1));
+            			list.add(new Pair(n-2, j+1));
+            			list.add(new Pair(n-2, j));
+            			list.add(new Pair(n-1, j));
+           				list.add(new Pair(n-1, j+1));
+            		}
+            	}
+            }else if(n % 2 == 1 && m % 2 == 1){
+            	int N = n-1;
+            	int M = m-1;
+            	for(int i=0; i<N; i+=2){
+            		for(int j=0; j<M; j+=2){
+            			if(arr[i][j] == 1 && arr[i][j+1] == 1 && arr[i+1][j] == 1 && arr[i+1][j+1] == 1){
+            				list.add(new Pair(i, j));
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i+1, j));
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i+1, j+1));
+            				list.add(new Pair(i+1, j));
+            				list.add(new Pair(i, j));
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i+1, j+1));
+            				list.add(new Pair(i, j));
+            				list.add(new Pair(i+1, j));
+            				list.add(new Pair(i+1, j+1));
+            			}else if(arr[i][j] == 1 && arr[i][j+1] == 1 && arr[i+1][j] == 1){
+            				list.add(new Pair(i, j));
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i+1, j));
+            			}else if(arr[i][j] == 1 && arr[i][j+1] == 1 && arr[i+1][j+1] == 1){
+            				list.add(new Pair(i, j));
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i+1, j+1));
+            			}else if(arr[i][j] == 1 && arr[i+1][j] == 1 && arr[i+1][j+1] == 1){
+            				list.add(new Pair(i, j));
+            				list.add(new Pair(i+1, j));
+            				list.add(new Pair(i+1, j+1));
+            			}else if(arr[i][j+1] == 1 && arr[i+1][j] == 1 && arr[i+1][j+1] == 1){
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i+1, j));
+            				list.add(new Pair(i+1, j+1));
+            			}else if(arr[i][j] == 1 && arr[i+1][j+1] == 1){
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i+1, j+1));
+            				list.add(new Pair(i+1, j));
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i+1, j));
+            				list.add(new Pair(i, j));
+            			}else if(arr[i][j+1] == 1 && arr[i+1][j] == 1){
+            				list.add(new Pair(i, j));
+            				list.add(new Pair(i+1, j+1));
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i+1, j+1));
+            				list.add(new Pair(i, j));
+            				list.add(new Pair(i+1, j));
+            			}else if(arr[i][j] == 1 && arr[i+1][j] == 1){
+            				list.add(new Pair(i, j));
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i+1, j+1));
+            				list.add(new Pair(i+1, j+1));
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i+1, j));
+            			}else if(arr[i][j] == 1 && arr[i][j+1] == 1){
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i+1, j+1));
+            				list.add(new Pair(i+1, j));
+            				list.add(new Pair(i+1, j));
+            				list.add(new Pair(i+1, j+1));
+            				list.add(new Pair(i, j));
+            			}else if(arr[i+1][j] == 1 && arr[i+1][j+1] == 1){
+            				list.add(new Pair(i, j));
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i+1, j+1));
+            				list.add(new Pair(i, j));
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i+1, j));
+            			}else if(arr[i][j+1] == 1 && arr[i+1][j+1] == 1){
+            				list.add(new Pair(i, j));
+            				list.add(new Pair(i+1, j));
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i, j));
+            				list.add(new Pair(i+1, j));
+            				list.add(new Pair(i+1, j+1));
+            			}else if(arr[i][j] == 1){
+            				list.add(new Pair(i, j));
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i+1, j));
+            				list.add(new Pair(i, j));
+            				list.add(new Pair(i+1, j+1));
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i+1, j+1));
+            				list.add(new Pair(i, j));
+            				list.add(new Pair(i+1, j));
+            			}else if(arr[i][j+1] == 1){
+            				list.add(new Pair(i, j));
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i+1, j+1));
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i+1, j+1));
+            				list.add(new Pair(i+1, j));
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i+1, j));
+            				list.add(new Pair(i, j));
+            			}else if(arr[i+1][j] == 1){
+            				list.add(new Pair(i, j));
+            				list.add(new Pair(i+1, j+1));
+            				list.add(new Pair(i+1, j));
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i+1, j+1));
+            				list.add(new Pair(i+1, j));
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i+1, j));
+            				list.add(new Pair(i, j));
+            			}else if(arr[i+1][j+1] == 1){
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i+1, j));
+            				list.add(new Pair(i+1, j+1));
+            				list.add(new Pair(i, j));
+            				list.add(new Pair(i+1, j+1));
+            				list.add(new Pair(i, j+1));
+            				list.add(new Pair(i+1, j+1));
+            				list.add(new Pair(i, j));
+            				list.add(new Pair(i+1, j));
+            			}
+            		}
+            	}
+            	for(int j=0; j<M; j+=2){
+            		if(arr[n-1][j] == 1 && arr[n-1][j+1] == 1){
+            			list.add(new Pair(n-2, j));
+            			list.add(new Pair(n-2, j+1));
+            			list.add(new Pair(n-1, j+1));
+            			list.add(new Pair(n-1, j));
+            			list.add(new Pair(n-2, j));
+            			list.add(new Pair(n-2, j+1));
+            		}else if(arr[n-1][j] == 1){
+            			list.add(new Pair(n-2, j));
+            			list.add(new Pair(n-1, j));
+            			list.add(new Pair(n-1, j+1));
+            			list.add(new Pair(n-1, j));
+						list.add(new Pair(n-1, j+1));
+            			list.add(new Pair(n-2, j+1));
+            			list.add(new Pair(n-2, j+1));
+            			list.add(new Pair(n-1, j));
+            			list.add(new Pair(n-2, j));
+            		}else if(arr[n-1][j+1] == 1){
+            			list.add(new Pair(n-1, j));
+            			list.add(new Pair(n-1, j+1));
+            			list.add(new Pair(n-2, j+1));
+            			list.add(new Pair(n-2, j));
+            			list.add(new Pair(n-1, j+1));
+            			list.add(new Pair(n-2, j+1));
+            			list.add(new Pair(n-2, j));
+            			list.add(new Pair(n-1, j));
+           				list.add(new Pair(n-1, j+1));
+            		}
+            	}
+            	for(int i=0; i<N; i+=2){
+            		if(arr[i][m-1] == 1 && arr[i+1][m-1] == 1){
+            			list.add(new Pair(i, m-2));
+            			list.add(new Pair(i+1, m-2));
+            			list.add(new Pair(i+1, m-1));
+            			list.add(new Pair(i, m-2));
+            			list.add(new Pair(i+1, m-2));
+            			list.add(new Pair(i, m-1));
+            		}else if(arr[i][m-1] == 1){
+            			list.add(new Pair(i, m-2));
+            			list.add(new Pair(i, m-1));
+            			list.add(new Pair(i+1, m-1));
+            			list.add(new Pair(i, m-1));
+						list.add(new Pair(i+1, m-1));
+            			list.add(new Pair(i+1, m-2));
+            			list.add(new Pair(i, m-2));
+            			list.add(new Pair(i+1, m-2));
+            			list.add(new Pair(i, m-1));
+            		}else if(arr[i+1][m-1] == 1){
+            			list.add(new Pair(i, m-1));
+            			list.add(new Pair(i+1, m-2));
+            			list.add(new Pair(i+1, m-1));
+            			list.add(new Pair(i, m-2));
+            			list.add(new Pair(i+1, m-2));
+            			list.add(new Pair(i+1, m-1));
+            			list.add(new Pair(i+1, m-1));
+            			list.add(new Pair(i, m-1));
+           				list.add(new Pair(i, m-2));
+            		}
+            	}
+            	if(arr[n-1][m-1] == 1){
+            		list.add(new Pair(n-1, m-1));
+            		list.add(new Pair(n-2, m-1));
+            		list.add(new Pair(n-1, m-2));
+            		list.add(new Pair(n-2, m-2));
+            		list.add(new Pair(n-1, m-2));
+            		list.add(new Pair(n-1, m-1));
+            		list.add(new Pair(n-1, m-1));
+            		list.add(new Pair(n-2, m-2));
+            		list.add(new Pair(n-2, m-1));
+            	}
+            }
+            int k = list.size()/3;
+            pw.println(k);
+            for(int i=0; i<k; i++){
+            	for(int j=0; j<3; j++){
+            		Pair p = list.get(i*3+j);
+            		pw.print((p.x+1) + "" "" + (p.y+1) + "" "");
+            	}
+            	pw.println();
+            }
+        }
+        pw.close();
+    }
+
+    public static class Pair{
+        int x;
+        int y;
+
+        Pair(int x, int y){
+            this.x = x;
+            this.y = y;
+        }
+    }
+
+    private static void sort(int[] arr) {
+        List<Integer> list = new ArrayList<>();
+        for (int i=0; i<arr.length; i++){
+            list.add(arr[i]);
+        }
+        Collections.sort(list); // collections.sort uses nlogn in backend
+        for (int i = 0; i < arr.length; i++){
+            arr[i] = list.get(i);
+        }
+    }
+
+    private static void sort(long[] arr) {
+        List<Long> list = new ArrayList<>();
+        for(int i=0; i<arr.length; i++){
+            list.add(arr[i]);
+        }
+        Collections.sort(list); // collections.sort uses nlogn in backend
+        for (int i = 0; i < arr.length; i++){
+            arr[i] = list.get(i);
+        }
+    }
+
+    // private static void sort(Pair[] arr) {
+    //     List<Pair> list = new ArrayList<>();
+    //     for(int i=0; i<arr.length; i++){
+    //         list.add(arr[i]);
+    //     }
+    //     Collections.sort(list); // collections.sort uses nlogn in backend
+    //     for (int i = 0; i < arr.length; i++){
+    //         arr[i] = list.get(i);
+    //     }
+    // }
+
+    private static void reverseSort(int[] arr){
+        List<Integer> list = new ArrayList<>();
+        for (int i=0; i<arr.length; i++){
+            list.add(arr[i]);
+        }
+        Collections.sort(list, Collections.reverseOrder()); // collections.sort uses nlogn in backend
+        for (int i = 0; i < arr.length; i++){
+            arr[i] = list.get(i);
+        }
+    }
+
+    private static void reverseSort(long[] arr){
+        List<Long> list = new ArrayList<>();
+        for (int i=0; i<arr.length; i++){
+            list.add(arr[i]);
+        }
+        Collections.sort(list, Collections.reverseOrder()); // collections.sort uses nlogn in backend
+        for (int i = 0; i < arr.length; i++){
+            arr[i] = list.get(i);
+        }
+    }
+
+    private static void reverseSort(ArrayList<Integer> list){
+        Collections.sort(list, Collections.reverseOrder());
+    }
+
+    private static int lowerBound(int[] arr, int x){
+        int n = arr.length, si = 0, ei = n - 1;
+        while(si <= ei){
+            int mid = si + (ei - si)/2;
+            if(arr[mid] == x){
+                if(mid-1 >= 0 && arr[mid-1] == arr[mid]){
+                    ei = mid-1;
+                }else{
+                    return mid;
+                }
+            }else if(arr[mid] > x){
+                ei = mid - 1; 
+            }else{
+                si = mid+1;
+            }
+        }
+        return si; 
+    }
+
+    private static int upperBound(int[] arr, int x){
+        int n = arr.length, si = 0, ei = n - 1;
+        while(si <= ei){
+            int mid = si + (ei - si)/2;
+            if(arr[mid] == x){
+                if(mid+1 < n && arr[mid+1] == arr[mid]){
+                    si = mid+1;
+                }else{
+                    return mid + 1;
+                }
+            }else if(arr[mid] > x){
+                ei = mid - 1; 
+            }else{
+                si = mid+1;
+            }
+        }
+        return si; 
+    }
+
+    private static int upperBound(ArrayList<Integer> list, int x){
+        int n = list.size(), si = 0, ei = n - 1;
+        while(si <= ei){
+            int mid = si + (ei - si)/2;
+            if(list.get(mid) == x){
+                if(mid+1 < n && list.get(mid+1) == list.get(mid)){
+                    si = mid+1;
+                }else{
+                    return mid + 1;
+                }
+            }else if(list.get(mid) > x){
+                ei = mid - 1; 
+            }else{
+                si = mid+1;
+            }
+        }
+        return si; 
+    }
+
+    // (x^y)%p in O(logy)
+    private static long power(long x, long y){
+        long res = 1; 
+        x = x % mod;
+        while(y > 0){
+            if ((y & 1) == 1){
+                res = (res * x) % mod;
+            }
+            y = y >> 1; 
+            x = (x * x) % mod;
+        }
+        return res;
+    }
+
+    public static boolean nextPermutation(int[] arr) {
+        if(arr == null || arr.length <= 1){
+            return false;
+        }
+        
+        int last = arr.length-2;
+        while(last >= 0){
+            if(arr[last] < arr[last+1]){
+                break;
+            }
+            last--;
+        }
+
+        if (last < 0){
+              return false;
+        }
+        
+        if(last >= 0){
+            int nextGreater = arr.length-1;
+            for(int i=arr.length-1; i>last; i--){
+                if(arr[i] > arr[last]){
+                    nextGreater = i;
+                    break;
+                }
+            }
+            swap(arr, last, nextGreater);
+        }
+        
+        reverse(arr, last+1, arr.length-1);
+        return true;
+    }
+    
+    private static void swap(int[] arr, int i, int j){
+        int temp = arr[i];
+        arr[i] = arr[j];
+        arr[j] = temp;
+    }
+    
+    private static void reverse(int[] arr, int i, int j){
+        while(i < j){
+            swap(arr, i++, j--);
+        }
+    }
+
+    private static String reverseStr(String s){
+        StringBuilder sb = new StringBuilder(s);
+        return sb.reverse().toString();
+    }
+
+    // TC- O(logmax(a,b))
+    private static int gcd(int a, int b) {
+        if(a == 0){
+            return b;
+        }
+        return gcd(b%a, a);
+    }
+
+    private static long gcd(long a, long b) {
+        if(a == 0L){
+            return b;
+        }
+        return gcd(b%a, a);
+    }
+
+    private static long lcm(long a, long b) {
+        return a / gcd(a, b) * b;
+    }
+
+    // TC- O(logmax(a,b))
+    private static int lcm(int a, int b) {
+        return a / gcd(a, b) * b;
+    }
+
+    private static long inv(long x){
+        return power(x, mod - 2);
+    }
+
+    private static long summation(long n){
+        return (n * (n + 1L)) >> 1;
+    } 
+}",0
+3088ca9c,a2cf5634,"import java.util.*;
+import java.io.*;
+
+
+public class MyClass {
+    public static void main(String args[]) {
+     Scanner sc = new Scanner(System.in);
+     int t = sc.nextInt();
+     while(t>0)
+     {
+         int n = sc.nextInt();
+         sc.nextLine();
+         String [] str = new String[n];
+         int res = 0;
+         for(int i=0;i<n;i++)
+         {
+             str[i]=sc.nextLine();
+         }
+         int [][] freq = new int [n][5];
+         for(int i=0;i<n;i++)
+         {
+             for(int j=0;j<str[i].length();j++)
+             {
+                 int k = str[i].charAt(j)-'a';
+                 freq[i][k]++;
+             }
+         }
+         for(int i=0;i<5;i++)
+         {
+             int [] arr = new int[n];
+             for(int j=0;j<n;j++)
+             {
+                 int pos = freq[j][i];
+                 int sum=0;
+                 for(int k = 0;k<5;k++)
+                 {
+                     sum+=freq[j][k];
+                 }
+                 sum-=pos;
+                 arr[j]=(pos-sum);
+             }
+             Arrays.sort(arr);
+            //  int p = n-1;
+             int count=0;
+             int sum=0;
+             for(int p=n-1;p>=0;p--)
+             {
+                 sum+=arr[p];
+                 if(sum>0)
+                 {
+                     count++;
+                 }
+                 else
+                 {
+                     break;
+                 }
+             }
+             res=Math.max(count , res);
+         }
+         
+         System.out.println(res);
+         t--;
+         
+     }
+    }
+}","
+/*
+    Author : Kartikey Rana
+    from MSIT New Delhi
+ */
+import java.util.*;
+
+import javax.sql.rowset.serial.SerialArray;
+import javax.swing.text.html.HTMLDocument.HTMLReader.PreAction;
+import java.io.*;
+import java.math.*;
+import java.sql.Array;;
+
+public class Main {
+	static class FR {
+
+		BufferedReader br;
+		StringTokenizer st;
+
+		public FR() {
+			br = new BufferedReader(new InputStreamReader(System.in));
+		}
+
+		String next() {
+			while (st == null || !st.hasMoreElements()) {
+				try {
+					st = new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			}
+			return st.nextToken();
+		}
+
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+
+		double nextDouble() {
+			return Double.parseDouble(next());
+		}
+
+		String nextLine() {
+			String str = """";
+			try {
+				str = br.readLine();
+			} catch (IOException e) {
+				e.printStackTrace();
+			}
+			return str;
+		}
+
+		// NEXT INT ARRAY
+
+		int[] NIA(int n) {
+			int arr[] = new int[n];
+			for (int i = 0; i < n; i++)
+				arr[i] = nextInt();
+			return arr;
+		}
+
+		// NEXT DOUBLE ARRAY
+
+		double[] NDA(int n) {
+			double arr[] = new double[n];
+			for (int i = 0; i < n; i++)
+				arr[i] = nextDouble();
+			return arr;
+		}
+
+		// NEXT LONG ARRAY
+
+		long[] NLA(int n) {
+			long[] arr = new long[n];
+			for (int i = 0; i < n; i++)
+				arr[i] = nextLong();
+			return arr;
+		}
+
+		// NEXT STRING ARRAY
+
+		String[] NSA(int n) {
+			String[] arr = new String[n];
+			for (int i = 0; i < n; i++)
+				arr[i] = next();
+			return arr;
+		}
+
+		// NEXT CHARACTER ARRAY
+
+		char[] NCA(int n) {
+			char[] arr = new char[n];
+			String s = sc.nextLine();
+
+			for (int i = 0; i < n; i++)
+				arr[i] = s.charAt(i);
+			return arr;
+		}
+
+	}
+
+//*************************  FR CLASS ENDS **********************************
+
+	static long mod = (long) (1e9 + 7);
+
+	public static int[] sieve(int n) {
+
+		int[] primes = new int[n + 1];
+		for (int i = 0; i <= n; i++) {
+			primes[i] = i;
+		}
+
+		for (int i = 2; i < n; i++) {
+			if (primes[i] < 0)
+				continue;
+			if ((long) i * (long) i > n)
+				break;
+			for (int j = i * i; j < n; j++) {
+				if (primes[j] > 0 && primes[j] % primes[i] == 0)
+					primes[j] = -primes[j];
+			}
+		}
+		return primes;
+	}
+
+	static int lcm(int a, int b) {
+		return (int) ((a / gcd(a, b)) * b);
+	}
+
+	static long gcd(long a, long b) {
+		if (b == 0)
+			return a;
+
+		return gcd(b, a % b);
+	}
+
+	static long[][] ncr(int n, int k) {
+		long C[][] = new long[n + 1][k + 1];
+		int i, j;
+
+		// Calculate value of Binomial
+		// Coefficient in bottom up manner
+		for (i = 0; i <= n; i++) {
+			for (j = 0; j <= Math.min(i, k); j++) {
+				// Base Cases
+				if (j == 0 || j == i)
+					C[i][j] = 1;
+
+				// Calculate value using
+				// previously stored values
+				else
+					C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % mod;
+			}
+		}
+
+		return C;
+	}
+
+	static long modInverse(long a, long m) {
+		long g = gcd(a, m);
+
+		return power(a, m - 2, m);
+
+	}
+
+	static long power(long x, long y, long m) {
+		if (y == 0)
+			return 1;
+		long p = power(x, y / 2, m) % m;
+		p = (int) ((p * (long) p) % m);
+		if (y % 2 == 0)
+			return p;
+		else
+			return (int) ((x * (long) p) % m);
+	}
+
+	static int XOR(int n) {
+		if (n % 4 == 0)
+			return n;
+
+		if (n % 4 == 1)
+			return 1;
+
+		if (n % 4 == 2)
+			return n + 1;
+
+		return 0;
+	}
+
+//	----------------------------------DSU--------------------------------
+
+	
+	static int parent[];
+	static int rank[];
+	
+	public static int find(int x) {
+		
+		if(x == parent[x]) {
+			return x;
+		}
+		int temp = find(parent[x]);
+		parent[x] = temp;
+		return temp;
+		
+	}
+	
+	public static void union(int x, int y) {
+		
+		int lx = find(x);
+		int ly = find(y);
+		if(parent[x] == parent[y])
+			return;
+		if(rank[lx] < rank[ly]) {
+			parent[lx] = ly;
+		} else if(rank[lx] >rank[ly]) {
+			parent[ly] = lx;
+		} else {
+			parent[lx] = ly;
+			rank[ly]++;
+		}
+		find(x);
+		find(y);
+	}
+
+	/* ***************************************************************************************************************************************************/
+
+
+	static class Pair implements Comparable<Pair> {
+
+		int x;
+		int y;
+
+		public Pair(int x, int y) {
+			super();
+			this.x = x;
+			this.y = y;
+		}
+
+		@Override
+		public int compareTo(Pair o) {
+			return this.x - o.x;
+		}
+
+	}
+	
+	
+	static FR sc = new FR();
+	static StringBuilder sb = new StringBuilder();
+	
+	
+	public static void main(String args[]) throws IOException {
+		
+		int tc = sc.nextInt();
+//		int tc = 1;
+		while (tc-- > 0) {
+			TEST_CASE();
+		}
+		sb.setLength(sb.length() - 1);
+		System.out.println(sb);
+	}
+
+	static void TEST_CASE() throws IOException {
+		// BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		
+		int n = sc.nextInt();
+		String[] strs = new String[n];
+		
+		for(int i = 0; i < n; i++) {
+			strs[i] = sc.next();
+		}
+		
+		int max = -1;
+		
+		for(int i = 0; i < 5; i++) {
+			ArrayList<Integer> arr = new ArrayList<>();
+			for(int j = 0; j < n; j++) {
+				String s = strs[j];
+				char letter = (char)(97+i);
+				int val = 0;
+				for(int k = 0; k < s.length(); k++) {
+					if(s.charAt(k) == letter)
+						val++;
+					else
+						val--;
+				}
+				arr.add(val);
+			}
+			Collections.sort(arr, Collections.reverseOrder());
+			int val = 0;
+			int ans = 0;
+			for(int x : arr) {
+				val += x;
+				if(val <= 0)
+					break;
+				else
+					ans++;
+			}
+			max = Math.max(ans, max);
+		}
+		sb.append(max + ""\n"");
+	}
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+",0
+51cc7026,e81b2d16,"
+import java.util.*;
+import java.math.*;
+import java.io.*;
+import java.lang.*;
+public class C_Balanced_Stone_Heaps {
+	static class FastReader {
+		BufferedReader br;
+		StringTokenizer st;
+ 
+		public FastReader() {
+			br = new BufferedReader(new InputStreamReader(System.in));
+		}
+ 
+		String next() {
+			while (st == null || !st.hasMoreElements()) {
+				try {
+					st = new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			}
+			return st.nextToken();
+		}
+ 
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+ 
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+ 
+		double nextDouble() {
+			return Double.parseDouble(next());
+		}
+ 
+		String nextLine() {
+			String str = """";
+			try {
+				str = br.readLine();
+			} catch (IOException e) {
+				e.printStackTrace();
+			}
+			return str;
+		}
+ 
+		int[] nextIntArray(int n) {
+			int a[] = new int[n];
+			for (int i = 0; i < n; i++) {
+				a[i] = Integer.parseInt(next());
+			}
+			return a;
+		}
+ 
+	}
+	
+    public static int t, n;
+    public static int H[];
+	private static long startTime = System.currentTimeMillis();
+	public static void main(String[] args) {
+		FastReader sc =new FastReader();
+		t = sc.nextInt();
+        while (t-->0) {
+            n = sc.nextInt();
+            H = new int[n];
+            int max = Integer.MIN_VALUE, min = Integer.MAX_VALUE;
+			for (int i = 0; i < n; i++) {
+                H[i] = sc.nextInt();
+                max = Math.max(H[i], max);
+                min = Math.min(H[i], min);
+            }
+            int mid = 0;
+            while (min < max) {
+                mid = min + (max-min+1)/2;
+                if(check(mid)) {
+                    min = mid;
+                }
+                else max = mid-1;
+            }			
+
+            System.out.println(min);
+        }
+
+	}
+
+    public static boolean check(int x){
+        int S[] = Arrays.copyOf(H, H.length);
+        for (int i = n-1; i >= 2; i--) {
+            if(S[i]<x) return false;
+
+            int move = Math.min(S[i]-x, H[i])/3;
+            if(i>=2){
+                // S[i]-=move*3;
+                S[i-1]+=(move);
+                S[i-2]+=2*(move);
+            }
+        }
+        return S[0]>= x && S[1] >= x;
+    }
+
+}
+","import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.*;
+
+public class fastTemp {
+    static class FastReader {
+        BufferedReader br;
+        StringTokenizer st;
+
+        public FastReader()
+        {
+            br = new BufferedReader(
+                    new InputStreamReader(System.in));
+        }
+
+        String next()
+        {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                }
+                catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt() { return Integer.parseInt(next()); }
+
+        long nextLong() { return Long.parseLong(next()); }
+
+        double nextDouble()
+        {
+            return Double.parseDouble(next());
+        }
+
+        String nextLine()
+        {
+            String str = """";
+            try {
+                str = br.readLine();
+            }
+            catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+        }
+    }
+
+    static int n;
+    static int arr[];
+    public static void main(String[] args)
+    {
+        FastReader fs = new FastReader();
+        int t = fs.nextInt();
+        while(t-- >0){
+               n = fs.nextInt();
+               arr = new int[n];
+              int max = Integer.MIN_VALUE;
+              for(int i=0;i<n;i++){
+                arr[i] = fs.nextInt();
+                  if(max<arr[i]){
+                      max =arr[i];
+                  }
+              }
+              int l=1;
+              int r = max;
+              int ans = 0;
+              while(l<r){
+                  int mid = l + (r-l+1)/2;
+                  if(check(mid)){
+                  l = mid;
+                  }else{
+                      r = mid-1;
+                  }
+              }
+            System.out.println(l);
+        }
+
+    }
+static int min = Integer.MAX_VALUE;
+    public static boolean check(int x){
+
+        int ar[] = new int[n];
+        for(int i=0;i<n;i++){
+            ar[i] = arr[i];
+        }
+
+       // Collections.copy(curr,arr);
+
+        for(int i=n-1;i>=2;i--){
+           if(ar[i]<x){
+               return false;
+           }
+           int d = (Math.min(arr[i],ar[i]-x))/3;
+          ar[i-1] += d;
+          ar[i-2] += 2*d;
+        }
+
+        return ar[0]>=x && ar[1]>=x;
+    }
+
+
+}",1
+35f0c004,8d6f1bf5,"import java.io.*;
+import java.util.*;
+public class Main {
+    public static void main(String args[])
+    {
+        FastReader input=new FastReader();
+        PrintWriter out=new PrintWriter(System.out);
+        int T=input.nextInt();
+        while(T-->0)
+        {
+            int n=input.nextInt();
+            String a=input.next();
+            String b=input.next();
+            int same1=0,same0=0,opp1=0,opp0=0;
+            for(int i=0;i<n;i++)
+            {
+                if(a.charAt(i)==b.charAt(i))
+                {
+                    if(a.charAt(i)=='1') same1++;
+                    else same0++;
+                }
+                else
+                {
+                    if(a.charAt(i)=='1') opp1++;
+                    else opp0++;
+                }
+            }
+            if(same0+same1==n)
+            {
+                out.println(0);
+            }
+            else
+            {
+                int x=same1+opp1;
+                int y=same1+opp0;
+                int z=same0+opp0;
+                if(x==y || (z+1)==y)
+                {
+                    int min=Integer.MAX_VALUE;
+                    if((same0+same1)%2!=0 && same0==(same0+same1)/2)
+                    {
+                        min=Math.min(min,same0+same1);
+                    }
+                    if((opp0+opp1)%2==0 && opp0==(opp0+opp1)/2)
+                    {
+                        min=Math.min(min,opp0+opp1);
+                    }
+                    out.println(min);
+                }
+                else
+                {
+                    out.println(-1);
+                }
+            }
+        }
+        out.close();
+    }
+    static class FastReader
+    {
+        BufferedReader br;
+        StringTokenizer st;
+        public FastReader()
+        {
+            br = new BufferedReader(new InputStreamReader(System.in));
+        }
+        String next()
+        {
+            while (st == null || !st.hasMoreElements())
+            {
+                try
+                {
+                    st = new StringTokenizer(br.readLine());
+                }
+                catch (IOException e)
+                {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+        int nextInt()
+        {
+            return Integer.parseInt(next());
+        }
+        long nextLong()
+        {
+            return Long.parseLong(next());
+        }
+        double nextDouble()
+        {
+            return Double.parseDouble(next());
+        }
+        String nextLine()
+        {
+            String str="""";
+            try
+            {
+                str=br.readLine();
+            }
+            catch (IOException e)
+            {
+                e.printStackTrace();
+            }
+            return str;
+        }
+    }
+}","//package Div2.C;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+
+public class Menorah {
+    public static void main(String[] args) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        int t = Integer.parseInt(br.readLine());
+        while (t > 0) {
+            int n = Integer.parseInt(br.readLine());
+            String source = br.readLine();
+            String destination = br.readLine();
+            int sameStatusOnes = 0;
+            int sameStatusZeros = 0;
+            int diffStatusOnes = 0;
+            int diffStatusZeros = 0;
+            for (int i = 0; i < n; i++) {
+                char c1 = source.charAt(i);
+                char c2 = destination.charAt(i);
+                if (c1 == c2) {
+                    if (c1 == '0') {
+                        sameStatusZeros += 1;
+                    } else {
+                        sameStatusOnes += 1;
+                    }
+                } else {
+                    if (c1 == '0') {
+                        diffStatusZeros += 1;
+                    } else {
+                        diffStatusOnes += 1;
+                    }
+                }
+            }
+            int sameStatus = sameStatusOnes + sameStatusZeros;
+            int diffStatus = diffStatusOnes + diffStatusZeros;
+            //first case
+            if (sameStatus == n) {
+                System.out.println(0);
+            } else if (diffStatus == n) {
+                //second case
+                if (diffStatus % 2 == 0 && diffStatusOnes == (n + 1) / 2)
+                    System.out.println(n);
+                else
+                    System.out.println(-1);
+            } else {
+                int op1 = -1;
+                int op2 = -1;
+                if (sameStatus % 2 != 0 && sameStatusOnes == (sameStatus + 1) / 2)
+                    op1 = sameStatus;
+                if (diffStatus % 2 == 0 && diffStatusOnes == (diffStatus + 1) / 2)
+                    op2 = diffStatus;
+
+                if (op1 != -1 && op2 != -1)
+                    System.out.println(Integer.min(op1, op2));
+                else if (op1 != -1)
+                    System.out.println(op1);
+                else if (op2 != -1)
+                    System.out.println(op2);
+                else
+                    System.out.println(-1);
+            }
+            t--;
+        }
+    }
+}
+",0
+ba468e1f,ff34fab2,"import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.*;
+
+public class Codeforces {
+    public static void main(String[] args) {
+        FastReader fastReader = new FastReader();
+        int t = fastReader.nextInt();
+        while (t-- > 0) {
+            int n = fastReader.nextInt();
+
+            int a[] = new int[n];
+            for (int i = 0; i < n; i++) {
+                a[i] = fastReader.nextInt();
+            }
+            ArrayList<Integer> b = new ArrayList<>();
+            ArrayList<Integer> r = new ArrayList<>();
+            char c[] = fastReader.next().toCharArray();
+            for (int i = 0; i < n; i++) {
+                if (c[i] == 'B') {
+                    b.add(a[i]);
+                } else {
+                    r.add(a[i]);
+                }
+            }
+
+            Collections.sort(b);
+            Collections.sort(r);
+            int sizeb = b.size();
+
+            boolean isValid = true;
+            for (int i = 1 , j = 0; i <=sizeb; i++ , j++){
+                if (b.get(j) <  i){
+                    isValid =false;
+                }
+            }
+
+            for (int i = sizeb+1 , j = 0; i <=n && j < r.size(); i++ , j++){
+                if (r.get(j) >  i){
+                    isValid =false;
+                }
+            }
+
+            if (isValid){
+                System.out.println(""YES"");
+            }else{
+                System.out.println(""NO"");
+            }
+        }
+
+
+    }
+
+    static class FastReader {
+
+
+        BufferedReader br;
+        StringTokenizer st;
+
+        public FastReader() {
+            br = new BufferedReader(
+                    new InputStreamReader(System.in));
+        }
+
+        String next() {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+
+        String nextLine() {
+            String str = """";
+            try {
+                str = br.readLine();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+        }
+    }
+}
+","import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.PriorityQueue;
+import java.util.Queue;
+import java.util.Stack;
+import java.util.StringTokenizer;
+import java.util.TreeMap;
+import java.util.TreeSet;
+
+import java.io.*;
+ 
+public class Div2 {
+	
+	private static class MyScanner {
+	    BufferedReader br;
+	    StringTokenizer st;
+
+	    public MyScanner() {
+	       br = new BufferedReader(new InputStreamReader(System.in));
+	    }
+
+	    String next() {
+	        while (st == null || !st.hasMoreElements()) {
+	            try {
+	                st = new StringTokenizer(br.readLine());
+	            } catch (IOException e) {
+	                e.printStackTrace();
+	            }
+	        }
+	        return st.nextToken();
+	    }
+
+	    int nextInt() {
+	        return Integer.parseInt(next());
+	    }
+
+	    long nextLong() {
+	        return Long.parseLong(next());
+	    }
+
+	    double nextDouble() {
+	        return Double.parseDouble(next());
+	    }
+
+	    String nextLine(){
+	        String str = """";
+		  try {
+		     str = br.readLine();
+		  } catch (IOException e) {
+		     e.printStackTrace();
+		  }
+		  return str;
+	    }
+
+	 }
+
+	 public static String solution(int [] arr, int n, String st) 
+	 {
+        ArrayList<Integer> red = new ArrayList<>();
+        ArrayList<Integer> blue = new ArrayList<>();
+        
+        for(int i = 0; i<n; i++)
+        {
+        	if(st.charAt(i)=='R')
+        		red.add(arr[i]);
+        	else
+        		blue.add(arr[i]);
+        }
+	    	
+        Collections.sort(red);
+        Collections.sort(blue);
+        int cb = 1;
+        
+        for(int j = 0; j<blue.size(); j++)
+        {
+            if(blue.get(j)<cb)
+            	return ""NO"";
+            cb++;
+        }
+        
+        int cr = n;
+        for(int j = red.size()-1; j>=0; j--)
+        {
+            if(red.get(j)>cr)
+            	return ""NO"";
+            cr--;
+        }
+        
+        return ""YES"";
+
+	 }
+        
+private static PrintWriter out = new PrintWriter(System.out);
+
+public static void main (String[] args)
+{
+	MyScanner s =  new MyScanner();
+	  
+    int t = s.nextInt();
+    
+    for(int j = 0; j<t ; j++)
+    {
+    	int n = s.nextInt();
+    	int[] arr = new int[n];
+    	for(int i =0; i<n; i++)
+    		arr[i] = s.nextInt();
+    	
+    	String st = s.next();
+   
+    	out.println(solution(arr,n, st));
+    }
+    
+		     
+    out.flush();
+    out.close();
+    
+}
+}
+
+",0
+8aadde13,fb20d298,"import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.util.Scanner;
+import java.util.StringTokenizer;
+import java.util.TreeSet;
+
+public class A {
+    public static void main(String args[]) throws Exception {
+        FastScanner sc = new FastScanner();
+        int T = 1;
+        T = sc.nextInt();
+        PrintWriter pw = new PrintWriter(System.out);
+        while (T-- > 0) {
+            solve(sc, pw);
+        }
+        pw.close();
+    }
+
+    public static void solve(FastScanner sc, PrintWriter pw) throws Exception {
+        int n = sc.nextInt();
+        int[] arr = new int[n];
+        for(int i=0;i<n;i++){
+            arr[i]=sc.nextInt();
+        }
+        if(check(arr)) pw.println(""YES"");
+        else pw.println(""NO"");
+    }
+
+    public static boolean check(int[] arr){
+        int n=arr.length;
+        TreeSet<Integer> S = new TreeSet<>();
+        S.add(arr[0]);
+        for(int i=1;i<n;i++) {
+            S.add(arr[i]);
+            if (arr[i] == arr[i - 1]) continue;
+            Integer lb = S.lower(arr[i]);
+            if (lb != null && lb == arr[i - 1]) continue;
+            Integer ub = S.higher(arr[i]);
+            if (ub != null && ub == arr[i - 1]) continue;
+            return false;
+        }
+        return true;
+    }
+
+    static class FastScanner {
+        public BufferedReader reader;
+        public StringTokenizer tokenizer;
+
+        public FastScanner() {
+            reader = new BufferedReader(new InputStreamReader(System.in), 32768);
+            tokenizer = null;
+        }
+
+        public String next() {
+            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
+                try {
+                    tokenizer = new StringTokenizer(reader.readLine());
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+            }
+            return tokenizer.nextToken();
+        }
+
+        public int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        public long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        public double nextDouble() {
+            return Double.parseDouble(next());
+        }
+
+        public String nextLine() {
+            try {
+                return reader.readLine();
+            } catch (IOException e) {
+                throw new RuntimeException(e);
+            }
+        }
+    }
+}","/*
+ * Author:- Tanmay
+ */
+import java.io.*;
+import java.util.*;
+public class Main {
+	public static void main(String[] args) {
+		FastScanner sc = new FastScanner();
+		PrintWriter out = new PrintWriter(System.out);
+//		int t=1;	
+		int t=sc.nextInt();
+//		outer:	
+		while(t-- >0) {
+			int n = sc.nextInt();
+			int b[] = sc.readArray(n);
+			TreeSet<Integer> set = new TreeSet<>();
+			boolean f = true;
+			set.add(b[0]);
+			for(int i=1 ; i<n ; i++) {
+				set.add(b[i]);
+				if(b[i-1]==b[i]) {
+					continue;
+				}
+				Integer find = set.lower(b[i]);
+				if(find!=null && find==b[i-1]) {
+					continue;
+				}
+				find = set.higher(b[i]);
+				if(find!=null && find==b[i-1]) {
+					continue;
+				}
+				f = false;
+				break;
+			}
+			if(f == false) {
+				out.println(""NO"");
+			}
+			else out.println(""YES"");
+		}
+		out.flush();
+		out.close();
+	}
+	static class FastScanner {
+		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st=new StringTokenizer("""");
+		String next() {
+			while (!st.hasMoreTokens())
+				try {
+					st=new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			return st.nextToken();
+		}
+		
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+		int [] readArray(int n) {
+			int[] a=new int[n];
+			for (int i=0; i<n; i++) a[i]=nextInt();
+			return a;
+		}
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+		long [] longArray(int n) {
+			long[] a=new long[n];
+			for(int i=0 ; i<n ; i++) a[i]=nextLong();
+			return a;
+		}
+		double nextDouble() {
+			return Double.parseDouble(next());
+		}
+	}
+} ",1
+54129ce9,607d5541,"import java.io.*;
+import java.util.*;
+
+public class Program{
+    static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+    static PrintWriter pw = new PrintWriter(System.out);
+    static StringTokenizer st = new StringTokenizer("""");
+    static int T, N, a[];
+    static boolean ok;
+    static void dfs(int i, int sum){
+        if(sum == a[N-1]){
+            ok = true;
+            return;
+        }
+        if(ok || i == N-1) return;
+        dfs(i+1, sum);
+        if(ok) return;
+        dfs(i+1, sum + a[i]);
+        if(ok) return;
+        dfs(i+1, sum - a[i]);
+    }
+    public static void main(String args[]) throws IOException{
+        T = nexti();
+        while(T-- > 0){
+            N = nexti();
+            a = new int[N];
+            for(int i = 0; i < N; i++) a[i] = nexti();
+            ok = false;
+            for(int i = 0; i < N; i++){
+                dfs(0, 0);
+                int tmp = a[i];
+                a[i] = a[N-1];
+                a[N-1] = tmp;
+            }
+            pw.println((ok ? ""YES"" : ""NO""));
+        }
+        br.close(); pw.close();
+    }
+    static String next() throws IOException{
+        while(!st.hasMoreTokens()) st = new StringTokenizer(br.readLine());
+        return st.nextToken();
+    }
+    static int nexti() throws IOException{
+        return Integer.parseInt(next());
+    }
+}
+","import java.io.*;
+import java.util.*;
+
+public class Program{
+    static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+    static PrintWriter pw = new PrintWriter(System.out);
+    static StringTokenizer st = new StringTokenizer("""");
+    static int T, N, a[];
+    static boolean ok;
+    static void dfs(int i, int sum){
+        if(sum == a[N-1]){
+            ok = true;
+            return;
+        }
+        if(ok || i == N-1) return;
+        dfs(i+1, sum);
+        if(ok) return;
+        dfs(i+1, sum + a[i]);
+        if(ok) return;
+        dfs(i+1, sum - a[i]);
+    }
+    public static void main(String args[]) throws IOException{
+        T = nexti();
+        while(T-- > 0){
+            N = nexti();
+            a = new int[N];
+            for(int i = 0; i < N; i++) a[i] = nexti();
+            ok = false;
+            for(int i = 0; i < N; i++){
+                dfs(0, 0);
+                int tmp = a[i];
+                a[i] = a[N-1];
+                a[N-1] = tmp;
+            }
+            pw.println((ok ? ""YES"" : ""NO""));
+        }
+        br.close(); pw.close();
+    }
+    static String next() throws IOException{
+        while(!st.hasMoreTokens()) st = new StringTokenizer(br.readLine());
+        return st.nextToken();
+    }
+    static int nexti() throws IOException{
+        return Integer.parseInt(next());
+    }
+}",1
+ba468e1f,d9199dfd,"import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.*;
+
+public class Codeforces {
+    public static void main(String[] args) {
+        FastReader fastReader = new FastReader();
+        int t = fastReader.nextInt();
+        while (t-- > 0) {
+            int n = fastReader.nextInt();
+
+            int a[] = new int[n];
+            for (int i = 0; i < n; i++) {
+                a[i] = fastReader.nextInt();
+            }
+            ArrayList<Integer> b = new ArrayList<>();
+            ArrayList<Integer> r = new ArrayList<>();
+            char c[] = fastReader.next().toCharArray();
+            for (int i = 0; i < n; i++) {
+                if (c[i] == 'B') {
+                    b.add(a[i]);
+                } else {
+                    r.add(a[i]);
+                }
+            }
+
+            Collections.sort(b);
+            Collections.sort(r);
+            int sizeb = b.size();
+
+            boolean isValid = true;
+            for (int i = 1 , j = 0; i <=sizeb; i++ , j++){
+                if (b.get(j) <  i){
+                    isValid =false;
+                }
+            }
+
+            for (int i = sizeb+1 , j = 0; i <=n && j < r.size(); i++ , j++){
+                if (r.get(j) >  i){
+                    isValid =false;
+                }
+            }
+
+            if (isValid){
+                System.out.println(""YES"");
+            }else{
+                System.out.println(""NO"");
+            }
+        }
+
+
+    }
+
+    static class FastReader {
+
+
+        BufferedReader br;
+        StringTokenizer st;
+
+        public FastReader() {
+            br = new BufferedReader(
+                    new InputStreamReader(System.in));
+        }
+
+        String next() {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+
+        String nextLine() {
+            String str = """";
+            try {
+                str = br.readLine();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+        }
+    }
+}
+","import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Scanner;
+
+public class Simple{  
+    public static void main(String args[]){  
+        //System.out.println(""Hello Java"");
+        Scanner s = new Scanner(System.in);
+        int t = s.nextInt();
+        while (t>0){
+            
+            int n = s.nextInt();
+            int arr[] = new int[n];
+
+            for(int i=0;i<n;i++){
+                arr[i] = s.nextInt();
+            }
+            String str = s.next();
+
+            //Arrays.sort(arr);
+            ArrayList<Integer> blue = new ArrayList<>();
+            ArrayList<Integer> red = new ArrayList<>();
+            for(int i=0;i<n;i++){
+                if(str.charAt(i)=='R'){
+                    red.add(arr[i]);
+                }
+                else{
+                    blue.add(arr[i]);
+                }
+            }
+            Collections.sort(red);
+            Collections.sort(blue);
+            
+            int start =1;
+
+            boolean bool =true;
+            for(int i=0;i<blue.size();i++){
+                if(blue.get(i)<start){
+                    bool = false;
+                    break;
+                }
+
+                start++;
+            }
+            if(!bool){
+                System.out.println(""NO"");
+            }
+            else{
+                for(int i=0;i<red.size();i++){
+                    if(red.get(i)>start){
+                        bool = false;
+                        break;
+                    }
+                    start++;
+                }
+                if(bool){
+                    System.out.println(""YES"");
+                }
+                else{
+                    System.out.println(""NO"");
+                }
+            }
+            
+            
+
+
+            t--;
+        }
+        s.close();  
+    }
+    
+}  
+",0
+67241a76,8a39dbf5,"import java.util.*;
+import java.io.*;
+
+public class CodeForces {
+
+    public void run() {
+        try {
+            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+            int q = Integer.parseInt(br.readLine());
+            while (q-- > 0){
+                br.readLine();
+                StringTokenizer st = new StringTokenizer(br.readLine());
+                int n = Integer.parseInt(st.nextToken());
+                int k = Integer.parseInt(st.nextToken());
+                int[] a = new int[k];
+                int[] t = new int[k];
+                long[] L = new long[n];
+                long[] R = new long[n];
+                for (int i = 0; i < n; i++) {
+                    L[i] = Integer.MAX_VALUE;
+                    R[i] = Integer.MAX_VALUE;
+                }
+                st = new StringTokenizer(br.readLine());
+                StringTokenizer st1 = new StringTokenizer(br.readLine());
+                for (int i = 0; i < k; i++) {
+                    a[i] = Integer.parseInt(st.nextToken());
+                    t[i] = Integer.parseInt(st1.nextToken());
+                    L[a[i] - 1] = t[i];
+                    R[a[i] - 1] = t[i];
+                }
+                for (int i = 1; i < n; i++) {
+                    L[i] = Math.min(L[i-1] + 1, L[i]);
+                }
+                for (int i = n - 2; i >= 0; i--) {
+                    R[i] = Math.min(R[i], R[i + 1] + 1);
+                }
+                StringBuilder sb = new StringBuilder();
+                for (int i = 0; i < n; i++) {
+                    long tmp = Math.min(L[i], R[i]);
+                    sb.append(tmp);
+                    sb.append("" "");
+                }
+                System.out.println(sb.toString().trim());
+
+            }
+
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    public static void main(String[] args) {
+        new CodeForces().run();
+    }
+}
+
+
+","import java.util.*;
+import java.lang.*;
+import java.io.*;
+ 
+/* Name of the class has to be ""Main"" only if the class is public. */
+public class Codeforces {
+    public static void main(String[] args) throws java.lang.Exception {
+        /* your code goes here */
+        BufferedReader buf = new BufferedReader(new InputStreamReader(System.in));
+       int t = Integer.parseInt(buf.readLine());
+        StringBuilder sb = new StringBuilder();
+       for (int i = 0; i < t; i++) {
+           String st=buf.readLine();
+          String st1[]=(buf.readLine()).split("" "");
+          int n=Integer.parseInt(st1[0]);
+          int k=Integer.parseInt(st1[1]);
+          int a[]=new int[k];
+          int temp[]=new int[k];
+          long arr[]=new long[n];
+          String st2[]=(buf.readLine()).split("" "");
+           String st3[]=(buf.readLine()).split("" "");
+           for(int j=0;j<k;j++)
+           {
+               a[j]=Integer.parseInt(st2[j]);
+               temp[j]=Integer.parseInt(st3[j]);
+           }
+          for(int j=0;j<k;j++)
+          {
+              arr[a[j]-1]=temp[j];
+          }
+          long min=Integer.MAX_VALUE;
+          long left[]=new long[n];
+          long right[]=new long[n];
+          if(arr[0]==0)
+              left[0]=min;
+          else
+              left[0]=arr[0];
+          for(int j=1;j<n;j++)
+          {
+              if(arr[j]==0)
+              {
+                  left[j]=left[j-1]+1;
+              }
+              else
+              {
+                  left[j]=Math.min(left[j-1]+1,arr[j]);
+              }
+          }
+          if(arr[n-1]==0)
+              right[n-1]=min;
+          else
+              right[n-1]=arr[n-1];
+          for(int j=n-2;j>=0;j--)
+          {
+              if(arr[j]==0)
+              {
+                  right[j]=right[j+1]+1;
+              }
+              else
+              {
+                  right[j]=Math.min(right[j+1]+1,arr[j]);
+              }
+          }
+          for(int j=0;j<n;j++)
+          {
+              arr[j]=Math.min(left[j],right[j]);
+              sb.append(arr[j]+"" "");
+          }
+          sb.append(""\n"");
+        }
+        System.out.println(sb);
+    }
+}",0
+23cb8587,a5f41b95,"import java.io.*;
+import java.util.*;
+
+public class C {
+
+	static long mod = (long) (1e9 + 7);
+
+	public static void main(String[] args) throws IOException {
+		Scanner scn = new Scanner(System.in);
+		PrintWriter out = new PrintWriter(System.out);
+		StringBuilder sb = new StringBuilder();
+		int T = scn.ni(), tcs = 0;
+		C: while (tcs++ < T) {
+			int n = scn.ni();
+			tree = new ArrayList[n + 1];
+			range = new long[n + 1][2];
+			for (int i = 0; i <= n; i++)
+				tree[i] = new ArrayList<>();
+			for (int i = 1; i <= n; i++) {
+				range[i][0] = scn.nl();
+				range[i][1] = scn.nl();
+			}
+			for (int i = 0; i < n - 1; i++) {
+				int x = scn.ni();
+				int y = scn.ni();
+				tree[x].add(y);
+				tree[y].add(x);
+			}
+			strg = new long[n + 1][2];
+			for (long a1[] : strg)
+				Arrays.fill(a1, -1L);
+			sb.append(Math.max(DFS(1, -1, 0), DFS(1, -1, 1)));
+			sb.append(""\n"");
+		}
+		out.print(sb);
+		out.close();
+	}
+
+	static ArrayList<Integer> tree[];
+	static long range[][], strg[][];
+
+	static long DFS(int u, int pa, int ok) {
+		if (strg[u][ok] != -1)
+			return strg[u][ok];
+		long tg = 0;
+		for (int ch : tree[u]) {
+			if (ch == pa)
+				continue;
+			long sg = 0;
+			if (ok == 0) {
+				sg = Math.max(DFS(ch, u, 0) + Math.abs(range[u][0] - range[ch][0]),
+						DFS(ch, u, 1) + Math.abs(range[u][0] - range[ch][1]));
+			} else {
+				sg = Math.max(DFS(ch, u, 0) + Math.abs(range[u][1] - range[ch][0]),
+						DFS(ch, u, 1) + Math.abs(range[u][1] - range[ch][1]));
+			}
+			tg += sg;
+		}
+		return strg[u][ok] = tg;
+	}
+
+	static class Scanner {
+
+		StringTokenizer st;
+		BufferedReader br;
+
+		public Scanner(InputStream s) {
+			br = new BufferedReader(new InputStreamReader(s));
+		}
+
+		public String next() throws IOException {
+			while (st == null || !st.hasMoreTokens())
+				st = new StringTokenizer(br.readLine());
+			return st.nextToken();
+		}
+
+		public int ni() throws IOException {
+			return Integer.parseInt(next());
+		}
+
+		public long nl() throws IOException {
+			return Long.parseLong(next());
+		}
+
+		public int[] nia(int n) throws IOException {
+			int a[] = new int[n];
+			String sa[] = br.readLine().split("" "");
+			for (int i = 0; i < n; i++)
+				a[i] = Integer.parseInt(sa[i]);
+			return a;
+		}
+
+		public long[] nla(int n) throws IOException {
+			long a[] = new long[n];
+			String sa[] = br.readLine().split("" "");
+			for (int i = 0; i < n; i++)
+				a[i] = Long.parseLong(sa[i]);
+			return a;
+		}
+
+		public void sort(int[] a) {
+			ArrayList<Integer> l = new ArrayList<>();
+			for (int v : a)
+				l.add(v);
+			Collections.sort(l);
+			for (int i = 0; i < a.length; i++)
+				a[i] = l.get(i);
+		}
+
+		public void sort(long[] a) {
+			ArrayList<Long> l = new ArrayList<>();
+			for (long v : a)
+				l.add(v);
+			Collections.sort(l);
+			for (int i = 0; i < a.length; i++)
+				a[i] = l.get(i);
+		}
+	}
+}","import java.io.OutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.PrintWriter;
+import java.util.*;
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+
+public class First {
+
+    public static void main(String[] args) {
+        InputStream inputStream = System.in;
+        OutputStream outputStream = System.out;
+        InputReader in = new InputReader(inputStream);
+        PrintWriter out = new PrintWriter(outputStream);
+        TaskA solver = new TaskA();
+        int t;
+        t = in.nextInt();
+        //t = 1;
+        while (t > 0) {
+            solver.call(in,out);
+            t--;
+        }
+        out.close();
+    }
+
+    static class TaskA {
+        Map<Integer, ArrayList<Integer>> map;
+        long[][] arr;
+        long[][] dp = new long[2][100005];
+        public void call(InputReader in, PrintWriter out) {
+            int n;
+            n = in.nextInt();
+
+            map = new HashMap<>();
+            arr = new long[n][2];
+
+            for (int i = 0; i < n; i++) {
+                arr[i][0] = in.nextLong();
+                arr[i][1] = in.nextLong();
+            }
+
+            int u, v;
+
+            for (int i = 0; i < 2; i++) {
+                for (int j = 0; j <= n; j++) {
+                    dp[i][j] = -1;
+                }
+            }
+
+            for (int i = 0; i < n-1; i++) {
+                u = in.nextInt()-1;
+                v = in.nextInt()-1;
+
+                if(map.getOrDefault(u,null)==null){
+                    map.put(u, new ArrayList<>());
+                }
+                map.get(u).add(v);
+
+                if(map.getOrDefault(v,null)==null){
+                    map.put(v, new ArrayList<>());
+                }
+                map.get(v).add(u);
+            }
+
+            out.println(Math.max(ans(0, -1,0), ans(0,-1,1)));
+
+        }
+        public long ans (int child, int par, int choice){
+            if(dp[choice][child]!=-1){
+                return dp[choice][child];
+            }
+            long opt = 0;
+            
+            for (Integer i : map.get(child)) {
+                if(i!=par) {
+                    opt += Math.max(Math.abs(arr[i][0] - arr[child][choice]) + ans(i, child, 0), Math.abs(arr[child][choice] - arr[i][1]) + ans(i, child, 1));
+                }
+            }
+            
+            return dp[choice][child] = opt;
+        }
+    }
+
+    static int gcd(int a, int b)
+    {
+        if (a == 0)
+            return b;
+        return gcd(b % a, a);
+    }
+
+    static int lcm(int a, int b)
+    {
+        return (a / gcd(a, b)) * b;
+    }
+
+    static class answer implements Comparable<answer>{
+        long a;
+        long b;
+
+        public answer(long a, long b) {
+            this.a = a;
+            this.b = b;
+        }
+
+        @Override
+        public int compareTo(answer o) {
+            return 0;
+        }
+    }
+
+    static class answer1 implements Comparable<answer1>{
+        int a, b, c;
+
+        public answer1(int a, int b, int c) {
+            this.a = a;
+            this.b = b;
+            this.c = c;
+
+        }
+
+        @Override
+        public int compareTo(answer1 o) {
+            if(o.c==this.c){
+                return this.a - o.a;
+            }
+            return o.c - this.c;
+        }
+    }
+
+    static long gcd(long a, long b)
+    {
+        if (b == 0)
+            return a;
+        return gcd(b, a % b);
+    }
+
+    static void sort(long[] a) {
+        ArrayList<Long> l=new ArrayList<>();
+        for (Long i:a) l.add(i);
+        Collections.sort(l);
+        for (int i=0; i<a.length; i++) a[i]=l.get(i);
+    }
+
+    static final Random random=new Random();
+
+    static void shuffleSort(int[] a) {
+        int n=a.length;
+        for (int i=0; i<n; i++) {
+            int oi=random.nextInt(n), temp=a[oi];
+            a[oi]=a[i]; a[i]=temp;
+        }
+        Arrays.sort(a);
+    }
+
+    static class InputReader {
+        public BufferedReader reader;
+        public StringTokenizer tokenizer;
+
+        public InputReader(InputStream stream) {
+            reader = new BufferedReader(new InputStreamReader(stream), 32768);
+            tokenizer = null;
+        }
+
+        public String next() {
+            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
+                try {
+                    tokenizer = new StringTokenizer(reader.readLine());
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+            }
+            return tokenizer.nextToken();
+        }
+
+        public int nextInt() {
+            return Integer.parseInt(next());
+        }
+        public long nextLong(){
+            return Long.parseLong(next());
+        }
+        public double nextDouble() {
+            return Double.parseDouble(next());
+        }
+
+    }
+}",0
+07043d35,97a7fab5,"// Piyush Nagpal
+import java.util.*;
+import java.io.*;
+ public class C{
+     
+    static int MOD=1000000007;
+    static PrintWriter pw;
+    static FastReader sc;
+    
+    static class FastReader {
+        BufferedReader br;
+        StringTokenizer st;
+ 
+        public FastReader()
+        {
+            br = new BufferedReader(
+                new InputStreamReader(System.in));
+        }
+ 
+        String next()
+        {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                }
+                catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+ 
+        int nextInt() { return Integer.parseInt(next()); }
+ 
+        long nextLong() { return Long.parseLong(next()); }
+ 
+        double nextDouble(){return Double.parseDouble(next());}
+        
+        public char nextChar() throws IOException {return next().charAt(0);}
+ 
+        String nextLine(){
+            String str = """";
+            try {
+                str = br.readLine();
+            }
+            catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+        }
+        public int[] intArr(int n) throws IOException {int[]in=new int[n];for(int i=0;i<n;i++)in[i]=nextInt();return in;}
+        public long[] longArr(int n) throws IOException {long[]in=new long[n];for(int i=0;i<n;i++)in[i]=nextLong();return in;}
+        
+    }   
+
+
+     public static long gcd(long a,long b){if( b>a ){return gcd(b,a);}if( b==0 ){return a;} return gcd(b,a%b);}
+     public static long expo( long a,long b,long M ){long result=1;while(b>0){if( b%2==1 ){result=(result*a)%M;}a=(a*a)%M;b=b/2;}return result%M;}
+    public static ArrayList<Long> Sieve(int n){boolean [] arr= new boolean[n+1];Arrays.fill(arr, true);ArrayList<Long> list= new ArrayList<>();for(int i=2;i<=n;i++){if( arr[i]==true ){list.add((long)i);}for(int j=2*i;j<=n;j+=i){arr[j]=false;}}return list;}
+
+    public static void printarr(int [] arr){for(int i=0;i<arr.length;i++){pw.print(arr[i]+"" "");}}
+    public static void printarr(long [] arr){for(int i=0;i<arr.length;i++){pw.print(arr[i]+"" "");}}
+    
+    // int [] arr=sc.intArr(n);
+    static int Max=2*100005;
+
+    // static int [][] arr= new int [Max][5];
+    // static int [] tot= new int [Max];
+    static ArrayList<ArrayList<Integer>> arr= new ArrayList<>();
+    static ArrayList<Integer> tot= new ArrayList<>();
+    static int fun(int ch , int n){
+    	ArrayList<Integer> list= new ArrayList<>();
+    	for(int i=0;i<n;i++){
+    		list.add( (arr.get(i).get(ch))-(tot.get(i)-(arr.get(i).get(ch))) );
+    	}
+    	Collections.sort(list,Collections.reverseOrder());
+    	int count=0,sum=0;
+    	for(Integer x: list){
+    		sum+=x;
+    		if(sum>0){
+    			count++;
+    		}
+    	}
+    	return count;
+    }
+
+    static void solve() throws Exception{
+    	int n=sc.nextInt();
+    	arr= new ArrayList<>();
+    	tot= new ArrayList<>();
+    	for(int i=0;i<n;i++){
+            arr.add( new ArrayList<>());
+    		tot.add(0);
+    		for(int j=0;j<5;j++){
+    			ArrayList<Integer> list=arr.get(i);
+    			list.add(0);
+    		}
+    	}
+    	// pw.println(tot);
+    	// pw.println(arr);
+    	// return;
+    	for(int i=0;i<n;i++){
+    		String s=sc.next();
+    		tot.set(i,s.length());
+    		for(int j=0;j<s.length();j++){
+    			ArrayList<Integer> list=arr.get(i);
+    			list.set((s.charAt(j)-'a'),list.get((s.charAt(j)-'a'))+1);
+    			// list.set((s.charAt(j)-'a'),1);
+    		}
+    	}
+    	int ans =0;
+    	for(int i=0;i<5;i++){
+    		ans = Math.max(ans,fun(i,n));
+    	}
+    	pw.println(ans);
+ }
+    
+   public static void main(String[] args) throws Exception{
+        try {
+            System.setIn(new FileInputStream(""input.txt""));
+            System.setOut(new PrintStream(new FileOutputStream(""output.txt"")));
+        } catch (Exception e) {
+            System.err.println(""Error"");
+        }
+        sc= new FastReader();
+        pw = new PrintWriter(System.out);
+
+   
+        int tc=1;
+        tc=sc.nextInt();
+        for(int i=1;i<=tc;i++) {
+//            pw.printf(""Case #%d: ""b, i);
+            solve();
+        }
+       
+        pw.flush();
+
+    
+
+    }
+
+}","import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.OutputStream;
+import java.io.PrintWriter;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Stack;
+import java.util.StringTokenizer;
+import java.util.Vector;
+
+
+public class Main{
+
+	static InputStream inputStream = System.in;
+	static OutputStream outputStream = System.out;
+	static InputReader in = new InputReader(inputStream);
+	static PrintWriter out = new PrintWriter(outputStream);
+
+	public static void main(String[] args) {
+
+		int t = in.nextInt();
+
+		while (t-- > 0) {
+			int n = in.nextInt();
+			String[] v = new String[n];
+
+			for (int i = 0; i < n; i++) {
+				v[i] = in.next();
+			}
+
+			ArrayList<ArrayList<Integer>> v1 = new ArrayList<>();
+
+			for (int i = 0; i < n; i++) {
+				ArrayList<Integer> list = new ArrayList<>();
+
+				for (int j = 0; j < 5; j++) {
+
+					list.add(0);
+				}
+				v1.add(list);
+			}
+
+			for (int i = 0; i < n; i++) {
+				String s = v[i];
+				for (int j = 0; j < s.length(); j++) {
+					int val = v1.get(i).get(s.charAt(j) - 'a');
+					val++;
+					v1.get(i).set(s.charAt(j) - 'a', val);
+
+				}
+
+			}
+			int ret = 0;
+			for (int i = 0; i < 5; i++) {
+				ArrayList<Integer> v3 = new ArrayList<>();
+
+				for (int j = 0; j < n; j++) {
+					String s1 = v[j];
+					int n2 = s1.length();
+					int cnt = v1.get(j).get(i);
+					int diff = cnt - (n2 - cnt);
+					v3.add(diff);
+				}
+				Collections.sort(v3);
+				Collections.reverse(v3);
+
+				int till = 0;
+				for (int k = 0; k < n; k++) {
+					till += v3.get(k);
+					if (till > 0) {
+						ret = Math.max(ret, k + 1);
+					}
+				}
+
+			}
+			out.println(ret);
+
+		}
+
+		out.close();
+	}
+
+	static class InputReader {
+		public BufferedReader reader;
+		public StringTokenizer tokenizer;
+
+		public InputReader(InputStream stream) {
+			reader = new BufferedReader(new InputStreamReader(stream), 32768);
+			tokenizer = null;
+		}
+
+		public String next() {
+			while (tokenizer == null || !tokenizer.hasMoreTokens()) {
+				try {
+					tokenizer = new StringTokenizer(reader.readLine());
+				} catch (IOException e) {
+					throw new RuntimeException(e);
+				}
+			}
+			return tokenizer.nextToken();
+		}
+
+		public long nextLong() {
+			return Long.parseLong(next());
+		}
+
+		public int nextInt() {
+			return Integer.parseInt(next());
+		}
+
+		public String nextLine() throws IOException {
+			return reader.readLine().trim();
+		}
+	}
+
+}
+",0
+778c91af,9399204d,"import java.io.*;
+import java.util.*;
+import java.text.DecimalFormat;
+
+public class C {
+    static long mod=(long)1e9+7;
+    static long mod1=998244353;
+    static InputStream inputStream = System.in;
+    static OutputStream outputStream = System.out;
+    static InputReader in = new InputReader(inputStream);
+    static PrintWriter out = new PrintWriter(outputStream);
+
+    public static void main(String[] args) throws IOException {
+
+        int t= in.nextInt();
+        while(t-->0) {
+
+            int n = in.nextInt();
+            ArrayList<Pair>[] adj = new ArrayList[5];
+            for(int i = 0;i<5;i++) adj[i] = new ArrayList<>();
+            for(int i = 0;i<n;i++){
+                char[] arr = in.next().toCharArray();
+                int[] count = new int[5];
+                for(char c:arr)
+                    count[c-'a']++;
+                for(int j = 0;j<5;j++){
+                    adj[j].add(new Pair(count[j],arr.length-count[j]));
+                }
+            }
+            int max = 0;
+            for(int i = 0;i<5;i++){
+                Collections.sort(adj[i]);
+                int count = 0;
+                int sum1 = 0;
+                int sum2 = 0;
+                for(Pair p:adj[i]){
+                    if(sum1+p.a>sum2+p.b){
+                        count++;
+                        sum1+=p.a;
+                        sum2+=p.b;
+                    }
+                }
+                max = Math.max(max,count);
+            }
+
+            out.println(max);
+
+        }
+        out.close();
+    }
+
+    static class Pair implements Comparable<Pair>{
+        int a,b;
+        Pair(int a, int b){
+            this.a = a;
+            this.b = b;
+        }
+
+        public int compareTo(Pair x){
+            return Integer.compare(x.a-x.b,this.a-this.b);
+        }
+    }
+
+
+    static final Random random=new Random();
+
+    static void ruffleSort(char[] a) {
+        int n=a.length;//shuffle, then sort
+        for (int i=0; i<n; i++) {
+            int oi=random.nextInt(n); char temp=a[oi];
+            a[oi]=a[i]; a[i]=temp;
+        }
+        Arrays.sort(a);
+    }
+    static long gcd(long x, long y){
+        if(x==0)
+            return y;
+        if(y==0)
+            return x;
+        long r=0, a, b;
+        a = Math.max(x, y);
+        b = Math.min(x, y);
+        r = b;
+        while(a % b != 0){
+            r = a % b;
+            a = b;
+            b = r;
+        }
+        return r;
+    }
+    static long modulo(long a,long b,long c){
+        long x=1,y=a%c;
+        while(b > 0){
+            if(b%2 == 1)
+                x=(x*y)%c;
+            y = (y*y)%c;
+            b = b>>1;
+        }
+        return  x%c;
+    }
+    public static void debug(Object... o){
+        System.err.println(Arrays.deepToString(o));
+    }
+
+    static int upper_bound(int[] arr,int n,int x){
+        int mid;
+        int low=0;
+        int high=n;
+        while(low<high){
+            mid=low+(high-low)/2;
+            if(x>=arr[mid])
+                low=mid+1;
+            else
+                high=mid;
+        }
+        return low;
+    }
+
+    static int lower_bound(int[] arr,int n,int x){
+        int mid;
+        int low=0;
+        int high=n;
+        while(low<high){
+            mid=low+(high-low)/2;
+            if(x<=arr[mid])
+                high=mid;
+            else
+                low=mid+1;
+        }
+        return low;
+    }
+    static String printPrecision(double d){
+        DecimalFormat ft = new DecimalFormat(""0.00000000000"");
+        return String.valueOf(ft.format(d));
+    }
+    static int countBit(long mask){
+        int ans=0;
+        while(mask!=0){
+            mask&=(mask-1);
+            ans++;
+        }
+        return ans;
+    }
+
+    static class InputReader {
+        public BufferedReader reader;
+        public StringTokenizer tokenizer;
+
+        public InputReader(InputStream stream) {
+            reader = new BufferedReader(new InputStreamReader(stream), 32768);
+            tokenizer = null;
+        }
+
+        public String next() {
+            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
+                try {
+                    tokenizer = new StringTokenizer(reader.readLine());
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+            }
+            return tokenizer.nextToken();
+        }
+
+        public int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        public long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        public double nextDouble() {
+            return Double.parseDouble(next());
+        }
+
+        public int[] readArray(int n) {
+            int[] arr = new int[n];
+            for (int i = 0; i < n; i++) arr[i] = nextInt();
+            return arr;
+        }
+    }
+}","import java.io.*;
+import java.util.*;
+
+
+
+import java.math.*;
+import java.math.BigInteger;
+
+
+public final class A
+{    
+	static PrintWriter out = new PrintWriter(System.out); 
+	static StringBuilder ans=new StringBuilder();
+	static FastReader in=new FastReader();
+	static ArrayList<Integer> g[];
+	static long mod=(long)1e9+7,INF=Long.MAX_VALUE;
+	static boolean set[],col[]; 
+	static int par[],tot[],partial[];
+	static int D[],P[][];
+	static long dp[][],sum=0,max=0,size[];
+	//	static node1 seg[];
+	//static pair moves[]= {new pair(-1,0),new pair(1,0), new pair(0,-1), new pair(0,1)};
+	public static void main(String args[])throws IOException
+	{				
+
+
+	
+		int T=i();
+		outer:while(T-->0)
+		{
+			int N=i();
+			int size[]=new int[N];
+			PriorityQueue<node1> q[]=new PriorityQueue[6];
+			for(int i=0; i<5; i++)q[i]=new PriorityQueue<node1>();
+			for(int i=0; i<N; i++)
+			{
+				char X[]=in.next().toCharArray();
+				int s=X.length;
+				size[i]=s;
+				int f[]=new int[5];
+				for(char x:X)f[x-'a']++;
+				for(int j=0; j<5; j++)q[j].add(new node1(f[j],i,s));
+			}
+			
+			int max=0;
+			for(int i=0; i<5; i++)
+			{
+				PriorityQueue<node1> q_new=new PriorityQueue<>();
+				q_new=q[i];
+				int c=0;
+				long f=0;
+				while(q_new.size()>0)
+				{
+					node1 x=q_new.remove();
+//					System.out.println(x.f+"" ""+x.size+"" ""+x.a);
+					f+=x.a;
+					if(f>0)
+					{
+						c++;
+						max=Math.max(max, c);
+					}
+					else break;
+				}
+			}
+			out.println(max);
+		}
+		out.close();
+
+	}
+	static int OR(int i,int j)
+	{
+		if(i>j)
+		{
+			int t=i;
+			i=j;
+			j=t;
+		}
+		System.out.println(""OR ""+i+"" ""+j);
+		return i();
+	}
+	static int AND(int i,int j)
+	{
+		if(i>j)
+		{
+			int t=i;
+			i=j;
+			j=t;
+		}
+		System.out.println(""AND ""+i+"" ""+j);
+		return i();
+	}
+	static int XOR(int i,int j)
+	{
+		if(i>j)
+		{
+			int t=i;
+			i=j;
+			j=t;
+		}
+		System.out.println(""XOR ""+i+"" ""+j);
+		return i();
+	}
+
+	static boolean f1(int l,char X[])
+	{
+		int i=0;
+		for(; l<X.length; l++)
+		{
+			if(X[i]!=X[l])return false;
+			i++;
+		}
+		return true;
+	}
+	static int f(int a)
+	{
+		for(int i=a+1; a>0; a++)
+		{
+			if(GCD(i,a)==1)return i;
+		}
+		return 0;
+	}
+	static int min(char X[],char str[],int N)
+	{
+		int s=0;
+		for(int i=0; i<N; i++)
+		{
+			int it=i%3;
+			if(X[i]!=str[it])s++;
+			//             ans.append(str[it]);
+		}
+		return s;
+	}
+	static char f(int i,char X[])
+	{
+		int a=0,b=0,c=0;
+		for(; i<X.length; i+=3)
+		{
+			if(X[i]=='R')a++;
+			if(X[i]=='B')b++;
+			if(X[i]=='G')c++;
+		}
+		if(a>=b && a>=c)return 'R';
+		if(b>=a && b>=c)return 'B';
+		return 'G';
+	}
+
+
+	static void f1(int n,int p,long sum,int N)
+	{
+		for(int c:g[n])
+		{
+			if(c==p)continue;
+
+			long s=sum+N-2*size[c];
+			f1(c,n,s,N);
+			max=Math.max(max, s);
+		}
+	}
+	static long f(int i,int j,ArrayList<Integer> A)
+	{
+
+		if(i+1==A.size())
+		{
+			return j;
+		}		
+		int moves=1+A.get(i);
+		if(j==1)return 1+f(i+1,moves,A);
+		if(j>0 && dp[i][j-1]==0)f(i,j-1,A);
+		return dp[i][j]=dp[i][j-1]+f(i+1,j+moves,A);
+	}
+	//	static void build(int v,int tl,int tr,long A[])
+	//	{
+	//		if(tl==tr)
+	//		{
+	//			seg[v]=new node1(A[tl],A[tr],1,true);
+	//			return ;
+	//		}
+	//		int tm=(tl+tr)/2;
+	//		build(2*v,tl,tm,A);
+	//		build(2*v+1,tm+1,tr,A);
+	//		seg[v]=merge(seg[2*v],seg[2*v+1]);
+	//	}
+	//	static node1 ask(int v,int tl,int tr,int l,int r)
+	//	{
+	//		if(l>r)return new node1(0,0,0,false);//verify true or false
+	//		if(tl==l && tr==r)return seg[v];
+	//		int tm=(tl+tr)/2;
+	//		node1 a=ask(v*2,tl,tm,l,Math.min(tm, r));
+	//		node1 b=ask(v*2+1,tm+1,tr,Math.max(tm+1, l),r);
+	//		return merge(a,b);
+	//	}
+	//	static node1 merge(node1 a,node1 b)
+	//	{
+	//		long s=0;
+	//		long l1=a.L,r1=a.R,c1=a.cnt;
+	//		long l2=b.L,r2=b.R,c2=b.cnt;
+	//		long g=GCD(l2,r1); s=c1+c2;
+	//		if(g==1)
+	//		{
+	//			s--;
+	//			g=(l2*r1)/g;
+	//			if(c1==1)
+	//			{
+	//				l1=g;
+	//			}
+	//			if(c2==1)r2=g;
+	//			return new node1(l1,r2,s,true);
+	//		}
+	//		return new node1(l1,r2,s,a.leaf^b.leaf);
+	//	}
+	static long f(long l,long r,long a,long b,long N)
+	{
+		while(r-l>1)
+		{
+			long m=(l+r)/2;
+			long x=m*b;
+			if(N<x)
+			{
+				r=m;
+				continue;
+			}
+			if((N-x)%a==0)r=m;
+			else l=m;
+
+		}
+		return r;
+	}
+	static long f1(long a,long A[],long bits[],long sum)
+	{
+		long s=A.length;
+		s=mul(s,a);
+		s=(s+(sum%mod))%mod;
+		long p=1L;
+		for(long x:bits)
+		{
+			if((a&p)!=0)s=((s-mul(x,p))+mod)%mod;
+			p<<=1;
+		}
+		return s;
+	}
+	static long f2(long a,long A[],long bits[])
+	{
+		long s=0;
+		long p=1L;
+		for(long x:bits)
+		{
+			if((a&p)!=0)
+			{
+				s=(s+mul(p,x))%mod;
+			}
+			p<<=1;
+		}
+		return s;
+	}
+	static long f(long x1,long y1,long x2,long y2)
+	{
+		return Math.abs(x1-x2)+Math.abs(y1-y2);
+	}
+	static long f(long x,long max,long s)
+	{
+		long l=-1,r=(x/s)+1;
+		while(r-l>1)
+		{
+			long m=(l+r)/2;
+			if(x-m*s>max)l=m;
+			else r=m;
+		}
+		return l+1;
+	}
+	static int f(long A[],long x)
+	{
+		int l=-1,r=A.length;
+		while(r-l>1)
+		{
+			int m=(l+r)/2;
+			if(A[m]>=x)r=m;
+			else l=m;			
+		}
+		return r;
+	}
+
+
+
+	static int bin(int x,ArrayList<Integer> A)
+	{
+		int l=0,r=A.size()-1;
+		while(l<=r)
+		{
+			int m=(l+r)/2;
+			int a=A.get(m);
+			if(a==x)return m;
+			if(a<x)l=m+1;
+			else r=m-1;
+		}
+		return 0;
+	}
+	static int left(int x,ArrayList<Integer> A)
+	{
+		int l=-1,r=A.size();
+		while(r-l>1)
+		{
+			int m=(l+r)/2;
+			int a=A.get(m);
+			if(a<=x)l=m;
+			else r=m;
+		}
+		return l;
+	}
+	static int right(int x,ArrayList<Integer> A)
+	{
+		int l=-1,r=A.size();
+		while(r-l>1)
+		{
+			int m=(l+r)/2;
+			int a=A.get(m);
+			if(a<x)l=m;
+			else r=m;
+		}
+		return r;
+	}
+
+
+
+	static boolean equal(long A[],long B[])
+	{
+		for(int i=0; i<A.length; i++)if(A[i]!=B[i])return false;
+		return true;	
+	}
+
+
+	static int max(int a ,int b,int c,int d)
+	{
+		a=Math.max(a, b);
+		c=Math.max(c,d);
+		return Math.max(a, c);
+	}
+	static int min(int a ,int b,int c,int d)
+	{
+		a=Math.min(a, b);
+		c=Math.min(c,d);
+		return Math.min(a, c);
+	}
+
+
+
+	static HashMap<Integer,Integer> Hash(int A[])
+	{
+		HashMap<Integer,Integer> mp=new HashMap<>();
+		for(int a:A)
+		{
+			int f=mp.getOrDefault(a,0)+1;
+			mp.put(a, f);
+		}
+		return mp;
+	}
+	static long mul(long a, long b)
+	{
+		return ( a %mod * 1L * b%mod )%mod;
+	}
+	static void swap(int A[],int a,int b)
+	{
+		int t=A[a];
+		A[a]=A[b];
+		A[b]=t;
+	}
+
+
+	static int find(int a)
+	{
+		if(par[a]<0)return a;
+		return par[a]=find(par[a]);
+	}
+	static void union(int a,int b)
+	{
+		a=find(a);
+		b=find(b);
+		if(a!=b)
+		{
+			par[a]+=par[b];
+			par[b]=a;
+		}
+	}
+	static boolean isSorted(int A[])
+	{
+		for(int i=1; i<A.length; i++)
+		{
+			if(A[i]<A[i-1])return false;
+		}
+		return true;
+	}
+
+	static boolean isDivisible(StringBuilder X,int i,long num)
+	{
+		long r=0;
+		for(; i<X.length(); i++)
+		{
+			r=r*10+(X.charAt(i)-'0');
+			r=r%num;
+		}
+		return r==0;
+	}    
+
+
+
+	static int lower_Bound(int A[],int low,int high, int x) 
+	{ 
+		if (low > high) 
+			if (x >= A[high]) 
+				return A[high]; 
+
+		int mid = (low + high) / 2; 
+
+		if (A[mid] == x) 
+			return A[mid]; 
+
+		if (mid > 0 && A[mid - 1] <= x && x < A[mid]) 
+			return A[mid - 1]; 
+
+		if (x < A[mid]) 
+			return lower_Bound( A, low, mid - 1, x); 
+
+		return lower_Bound(A, mid + 1, high, x); 
+	} 
+
+	static String f(String A)
+	{
+		String X="""";
+		for(int i=A.length()-1; i>=0; i--)
+		{
+			int c=A.charAt(i)-'0';
+			X+=(c+1)%2;
+		}
+		return X;
+	}
+
+	static void sort(long[] a) //check for long
+	{
+		ArrayList<Long> l=new ArrayList<>();
+		for (long i:a) l.add(i);
+		Collections.sort(l);
+		for (int i=0; i<a.length; i++) a[i]=l.get(i);
+	}
+
+	static String swap(String X,int i,int j)
+	{
+		char ch[]=X.toCharArray();
+		char a=ch[i];
+		ch[i]=ch[j];
+		ch[j]=a;
+		return new String(ch);
+	}
+
+	static int sD(long n)  
+	{  
+
+		if (n % 2 == 0 )  
+			return 2;  
+
+		for (int i = 3; i * i <= n; i += 2) {  
+			if (n % i == 0 )  
+				return i;  
+		}  
+
+		return (int)n;  
+	}  
+
+	static void setGraph(int N)
+	{
+		tot=new int[N+1];
+		partial=new int[N+1];
+		D=new int[N+1];
+		P=new int[N+1][(int)(Math.log(N)+10)];
+		set=new boolean[N+1];
+		g=new ArrayList[N+1];
+		for(int i=0; i<=N; i++)
+		{
+
+			g[i]=new ArrayList<>();		
+			D[i]=Integer.MAX_VALUE;
+			//D2[i]=INF;
+		}
+	}
+
+
+
+	static  long pow(long a,long b)
+	{
+		//long mod=1000000007;
+		long pow=1;
+		long x=a;
+		while(b!=0)
+		{
+			if((b&1)!=0)pow=(pow*x)%mod;
+			x=(x*x)%mod;
+			b/=2;
+		}
+		return pow;
+	}
+
+	static long toggleBits(long x)//one's complement || Toggle bits
+	{
+		int n=(int)(Math.floor(Math.log(x)/Math.log(2)))+1;
+
+		return ((1<<n)-1)^x;
+	}
+
+	static int countBits(long a)
+	{
+		return (int)(Math.log(a)/Math.log(2)+1);
+	}
+
+	static long fact(long N)
+	{ 
+		long n=2; 
+		if(N<=1)return 1;
+		else
+		{
+			for(int i=3; i<=N; i++)n=(n*i)%mod;
+		}
+		return n;
+	}
+
+	static int kadane(int A[])
+	{
+		int lsum=A[0],gsum=A[0];
+		for(int i=1; i<A.length; i++)
+		{
+			lsum=Math.max(lsum+A[i],A[i]);
+			gsum=Math.max(gsum,lsum);
+		}
+		return gsum;
+	}
+
+	static void sort(int[] a) {
+		ArrayList<Integer> l=new ArrayList<>();
+		for (int i:a) l.add(i);
+		Collections.sort(l);
+		for (int i=0; i<a.length; i++) a[i]=l.get(i);
+	}
+
+	static boolean isPrime(long N)
+	{
+		if (N<=1)  return false; 
+		if (N<=3)  return true; 
+		if (N%2 == 0 || N%3 == 0) return false; 
+		for (int i=5; i*i<=N; i=i+6) 
+			if (N%i == 0 || N%(i+2) == 0) 
+				return false; 
+		return true; 
+	}
+	static void print(char A[])
+	{
+		for(char c:A)System.out.print(c+"" "");
+		System.out.println();
+	}
+	static void print(boolean A[])
+	{
+		for(boolean c:A)System.out.print(c+"" "");
+		System.out.println();
+	}
+	static void print(int A[])
+	{
+		for(int a:A)System.out.print(a+"" "");
+		System.out.println();	
+	}
+	static void print(long A[])
+	{
+		for(long i:A)System.out.print(i+ "" "");
+		System.out.println();
+
+	}
+	static void print(ArrayList<Integer> A)
+	{
+		for(int a:A)System.out.print(a+"" "");
+		System.out.println();
+	}
+
+	static int i()
+	{
+		return in.nextInt();
+	}
+
+	static long l()
+	{
+		return in.nextLong();
+	}
+
+	static int[] input(int N){
+		int A[]=new int[N];
+		for(int i=0; i<N; i++)
+		{
+			A[i]=in.nextInt();
+		}
+		return A;
+	}
+
+	static long[] inputLong(int N)     {
+		long A[]=new long[N];
+		for(int i=0; i<A.length; i++)A[i]=in.nextLong();
+		return A;
+	}
+
+	static long GCD(long a,long b) 
+	{
+		if(b==0)
+		{
+			return a;
+		}
+		else return GCD(b,a%b );
+	}
+
+}
+class node1 implements Comparable<node1>
+{
+	int index,f,size;
+	long a;
+	node1(int f,int i,int size)
+	{
+		this.f=f;
+		this.index=i;
+		this.size=size;
+		a=2*f-size;
+	}
+	public int compareTo(node1 x)
+	{
+		if(this.a==x.a)return 0;
+		else if(this.a<x.a)return 1;
+		else return -1;
+	}
+}
+
+
+//Code For FastReader
+//Code For FastReader
+//Code For FastReader
+//Code For FastReader
+class FastReader
+{
+	BufferedReader br;
+	StringTokenizer st;
+	public FastReader()
+	{
+		br=new BufferedReader(new InputStreamReader(System.in));
+	}
+
+	String next()
+	{
+		while(st==null || !st.hasMoreElements())
+		{
+			try
+			{
+				st=new StringTokenizer(br.readLine());
+			}
+			catch(IOException e)
+			{
+				e.printStackTrace();
+			}
+		}
+		return st.nextToken();
+	}
+
+	int nextInt()
+	{
+		return Integer.parseInt(next());
+	}
+
+	long nextLong()
+	{
+		return Long.parseLong(next());
+	}
+
+	double nextDouble()
+	{
+		return Double.parseDouble(next());
+	}
+
+	String nextLine()
+	{
+		String str="""";
+		try
+		{
+			str=br.readLine();
+		}
+		catch (IOException e)
+		{
+			e.printStackTrace();
+		}
+		return str;
+	}
+
+}
+",0
+29210e56,4323e2bd,"import java.util.*;
+import java.io.*;
+import java.math.*;
+
+/**
+ *
+ * @Har_Har_Mahadev
+ */
+
+/**
+ * Main , Solution , Remove Public
+ */
+public class A {
+
+	private static long[][] dp;
+	private static ArrayList<Integer> lis1,lis0;
+
+	public static void process() throws IOException {
+
+		int n = sc.nextInt();
+		int arr[] = sc.readArray(n);
+		lis1 = new ArrayList<Integer>();
+		lis0 = new ArrayList<Integer>();
+		for(int i = 0; i<n; i++) {
+			if(arr[i] == 1)lis1.add(i+1);
+			else lis0.add(i+1);
+		}
+		Collections.sort(lis0);
+		Collections.sort(lis1);
+		int n0 = lis0.size();
+		int n1 = lis1.size();
+		dp = new long[n0+1][n1+1];
+		for(int i = 0; i<=n0; i++) {
+			Arrays.fill(dp[i], -1);
+		}
+		long ans = solve(0,0,n0,n1);
+		println(ans);
+		
+
+	}
+
+	private static long solve(int i, int j, int n0, int n1) {
+		if(j == n1)return 0;
+		if(i == n0)return INF;
+		if(dp[i][j] != -1)return dp[i][j];
+		long ans = solve(i+1, j, n0, n1);
+		ans = min(ans,abs(lis0.get(i) - lis1.get(j)) + solve(i+1, j+1, n0, n1));
+		return dp[i][j] = ans;
+	}
+
+	//=============================================================================
+	//--------------------------The End---------------------------------
+	//=============================================================================
+	private static long INF = 2000000000000000000L, M = 1000000007, MM = 998244353;
+	private static int N = 0;
+
+	private static void google(int tt) {
+		System.out.print(""Case #"" + (tt) + "": "");
+	}
+
+	static FastScanner sc;
+	static PrintWriter out;
+
+	public static void main(String[] args) throws IOException {
+		boolean oj = true;
+		if (oj) {
+			sc = new FastScanner();
+			out = new PrintWriter(System.out);
+		} else {
+			sc = new FastScanner(100);
+			out = new PrintWriter(""output.txt"");
+		}
+		int t = 1;
+//		t = sc.nextInt();
+		int TTT = 1;
+		while (t-- > 0) {
+			//			google(TTT++);
+			process();
+		}
+		out.flush();
+		out.close();
+	}
+
+	static class Pair implements Comparable<Pair> {
+		int x, y;
+
+		Pair(int x, int y) {
+			this.x = x;
+			this.y = y;
+		}
+
+		@Override
+		public int compareTo(Pair o) {
+			return Integer.compare(this.x, o.x);
+		}
+
+		//		 @Override
+		//		    public boolean equals(Object o) {
+		//		        if (this == o) return true;
+		//		        if (!(o instanceof Pair)) return false;
+		//		        Pair key = (Pair) o;
+		//		        return x == key.x && y == key.y;
+		//		    }
+		//		 
+		//		    @Override
+		//		    public int hashCode() {
+		//		        int result = x;
+		//		        result = 31 * result + y;
+		//		        return result;
+		//		    }
+	}
+
+	/////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+	static void println(Object o) {
+		out.println(o);
+	}
+
+	static void println() {
+		out.println();
+	}
+
+	static void print(Object o) {
+		out.print(o);
+	}
+
+	static void pflush(Object o) {
+		out.println(o);
+		out.flush();
+	}
+
+	static int ceil(int x, int y) {
+		return (x % y == 0 ? x / y : (x / y + 1));
+	}
+
+	static long ceil(long x, long y) {
+		return (x % y == 0 ? x / y : (x / y + 1));
+	}
+
+	static int max(int x, int y) {
+		return Math.max(x, y);
+	}
+
+	static int min(int x, int y) {
+		return Math.min(x, y);
+	}
+
+	static int abs(int x) {
+		return Math.abs(x);
+	}
+
+	static long abs(long x) {
+		return Math.abs(x);
+	}
+
+	static long sqrt(long z) {
+		long sqz = (long) Math.sqrt(z);
+		while (sqz * 1L * sqz < z) {
+			sqz++;
+		}
+		while (sqz * 1L * sqz > z) {
+			sqz--;
+		}
+		return sqz;
+	}
+
+	static int log2(int N) {
+		int result = (int) (Math.log(N) / Math.log(2));
+		return result;
+	}
+
+	static long max(long x, long y) {
+		return Math.max(x, y);
+	}
+
+	static long min(long x, long y) {
+		return Math.min(x, y);
+	}
+
+	public static int gcd(int a, int b) {
+		BigInteger b1 = BigInteger.valueOf(a);
+		BigInteger b2 = BigInteger.valueOf(b);
+		BigInteger gcd = b1.gcd(b2);
+		return gcd.intValue();
+	}
+
+	public static long gcd(long a, long b) {
+		BigInteger b1 = BigInteger.valueOf(a);
+		BigInteger b2 = BigInteger.valueOf(b);
+		BigInteger gcd = b1.gcd(b2);
+		return gcd.longValue();
+	}
+
+	public static long lcm(long a, long b) {
+		return (a * b) / gcd(a, b);
+	}
+
+	public static int lcm(int a, int b) {
+		return (a * b) / gcd(a, b);
+	}
+
+	public static int lower_bound(int[] arr, int x) {
+		int low = 0, high = arr.length, mid = -1;
+
+		while (low < high) {
+			mid = (low + high) / 2;
+
+			if (arr[mid] >= x)
+				high = mid;
+			else
+				low = mid + 1;
+		}
+
+		return low;
+	}
+
+	public static int upper_bound(int[] arr, int x) {
+		int low = 0, high = arr.length, mid = -1;
+
+		while (low < high) {
+			mid = (low + high) / 2;
+
+			if (arr[mid] > x)
+				high = mid;
+			else
+				low = mid + 1;
+		}
+
+		return low;
+	}
+
+	/////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+	static class FastScanner {
+		BufferedReader br;
+		StringTokenizer st;
+
+		FastScanner() throws FileNotFoundException {
+			br = new BufferedReader(new InputStreamReader(System.in));
+		}
+
+		FastScanner(int a) throws FileNotFoundException {
+			br = new BufferedReader(new FileReader(""input.txt""));
+		}
+
+		String next() throws IOException {
+			while (st == null || !st.hasMoreElements()) {
+				try {
+					st = new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			}
+			return st.nextToken();
+		}
+
+		int nextInt() throws IOException {
+			return Integer.parseInt(next());
+		}
+
+		long nextLong() throws IOException {
+			return Long.parseLong(next());
+		}
+
+		double nextDouble() throws IOException {
+			return Double.parseDouble(next());
+		}
+
+		String nextLine() throws IOException {
+			String str = """";
+			try {
+				str = br.readLine();
+			} catch (IOException e) {
+				e.printStackTrace();
+			}
+			return str;
+		}
+
+		int[] readArray(int n) throws IOException {
+			int[] A = new int[n];
+			for (int i = 0; i != n; i++) {
+				A[i] = sc.nextInt();
+			}
+			return A;
+		}
+
+		long[] readArrayLong(int n) throws IOException {
+			long[] A = new long[n];
+			for (int i = 0; i != n; i++) {
+				A[i] = sc.nextLong();
+			}
+			return A;
+		}
+	}
+
+	static void ruffleSort(int[] a) {
+		Random get = new Random();
+		for (int i = 0; i < a.length; i++) {
+			int r = get.nextInt(a.length);
+			int temp = a[i];
+			a[i] = a[r];
+			a[r] = temp;
+		}
+		Arrays.sort(a);
+	}
+
+	static void ruffleSort(long[] a) {
+		Random get = new Random();
+		for (int i = 0; i < a.length; i++) {
+			int r = get.nextInt(a.length);
+			long temp = a[i];
+			a[i] = a[r];
+			a[r] = temp;
+		}
+		Arrays.sort(a);
+	}
+}
+","import java.io.*;
+import java.util.*;
+import java.math.*;
+import java.math.BigInteger; 
+//import javafx.util.*; 
+public final class B
+{    
+	static StringBuilder ans=new StringBuilder();
+	static FastReader in=new FastReader();
+	static ArrayList<ArrayList<Integer>> g;
+	static long mod=(long)(1e9+7);
+	static int D1[],D2[],par[];
+	static boolean set[];
+	static int value[];
+	static long INF=Long.MAX_VALUE;
+	static int dp[][];
+	static int N,M;
+	static int A[][],B[][];
+	static int s=1;
+	public static void main(String args[])throws IOException
+	{  					
+		int N=i();
+		int A[]=input(N);
+		ArrayList<Integer> one=new ArrayList<Integer>();
+		ArrayList<Integer> zero=new ArrayList<Integer>();
+		for(int i=1; i<=N; i++)
+		{
+			if(A[i-1]==1)one.add(i);
+			else zero.add(i);
+		}
+		int sum[][]=new int[N+5][N+5];
+		for(int i=1; i<=one.size(); i++)
+		{
+			for(int j=1; j<=zero.size(); j++)
+			{
+				sum[i][j]=Math.abs(one.get(i-1)-zero.get(j-1));
+			}
+			//print(sum[i]);
+		}
+		dp=new int[N+5][N+5];
+		//for(int d[]:dp)Arrays.fill(d, Integer.MAX_VALUE);
+		Arrays.fill(dp[0], 0);
+		for(int i=1; i<=one.size(); i++)
+		{
+			for(int j=i; j<=zero.size(); j++)
+			{
+				if(i==j)
+				{
+					dp[i][j]=dp[i-1][j-1]+sum[i][j];
+				}
+				else
+				{
+					dp[i][j]=Math.min(dp[i][j-1], dp[i-1][j-1]+sum[i][j]);
+				}
+			}
+		}
+		System.out.println(dp[one.size()][zero.size()]);
+//		f(0,0,one,zero,0);
+		//for(int d[]:dp)print(d);
+		
+	}	
+	static int f(int i,int j,ArrayList<Integer> one,ArrayList<Integer> zero, int s)
+	{
+		if(i==one.size())return s;
+		if(j==zero.size())return Integer.MAX_VALUE;
+		int a=one.get(i),b=zero.get(j);
+        if(dp[a][b]==-1)
+        {
+        	int min=Integer.MAX_VALUE;
+        	for(int t=j; t<zero.size(); t++)
+    		{
+                 min=Math.min(min, f(i+1,t+1,one,zero,s+Math.abs(b-a))); 
+    		}  
+        	dp[a][b]=min;
+        }	
+        a=one.get(i);b=zero.get(j);
+		return dp[a][b];
+	}
+	static boolean isSorted(int A[])
+	{
+		int N=A.length;
+		for(int i=0; i<N-1; i++)
+		{
+			if(A[i]>A[i+1])return false;
+		}
+
+		return true;		
+	}
+	static int f1(int x,ArrayList<Integer> A)
+	{
+		int l=-1,r=A.size();
+		while(r-l>1)
+		{
+			int m=(l+r)/2;
+			int a=A.get(m);
+			if(a<x)l=m;
+			else r=m;
+		}		
+		return l;
+	}
+
+
+	static int ask(int t,int i,int j,int x)
+	{
+		System.out.println(""? ""+t+"" ""+i+"" ""+j+"" ""+x);
+		return i();
+	}
+
+	static int ask(int a)
+	{
+		System.out.println(""? 1 ""+a);
+		return i();
+	}
+	static int f(int st,int end,int d)
+	{
+		if(st>end)return 0;
+		int a=0,b=0,c=0;
+		if(d>1)a=f(st+d-1,end,d-1);
+		b=f(st+d,end,d);
+		c=f(st+d+1,end,d+1);
+		return value[st]+max(a,b,c);
+	}
+	static int max(int a,int b,int c)
+	{
+		return Math.max(a, Math.max(c, b));
+	}
+	static int value(char X[],char Y[])
+	{
+		int c=0;
+		for(int i=0; i<7; i++)
+		{
+			if(Y[i]=='1' && X[i]=='0')return -1;
+			if(X[i]=='1' && Y[i]=='0')c++;
+		}
+		return c;
+	}
+	static boolean isValid(int i,int j)
+	{
+		if(i<0 || i>=N)return false;
+		if(j<0 || j>=M)return false;
+		return true;
+	}
+
+	static long fact(long N)
+	{
+		long num=1L;
+		while(N>=1)
+		{
+			num=((num%mod)*(N%mod))%mod;
+			N--;
+		}
+		return num;
+	}
+	static boolean reverse(long A[],int l,int r)
+	{
+		while(l<r)
+		{
+			long t=A[l];
+			A[l]=A[r];
+			A[r]=t;
+			l++;
+			r--;
+		}
+		if(isSorted(A))return true;
+		else return false;
+	}
+	static boolean isSorted(long A[])
+	{
+		for(int i=1; i<A.length; i++)if(A[i]<A[i-1])return false;
+		return true;
+	}
+	static boolean isPalindrome(char X[],int l,int r)
+	{
+		while(l<r)
+		{
+			if(X[l]!=X[r])return false;
+			l++; r--;
+		}
+		return true;
+	}
+
+	static long min(long a,long b,long c)
+	{
+		return Math.min(a, Math.min(c, b));
+	}
+
+	static void print(int a)
+	{
+		System.out.println(""! ""+a);
+	}
+	static int ask(int a,int b)
+	{
+		System.out.println(""? ""+a+"" ""+b);
+		return i();
+	}
+	static int find(int a)
+	{
+		if(par[a]<0)return a;
+		return par[a]=find(par[a]);
+	}
+	static void union(int a,int b)
+	{
+		a=find(a);
+		b=find(b);
+		if(a!=b)
+		{
+			par[a]+=par[b]; //transfers the size
+			par[b]=a;       //changes the parent
+		}
+	}
+	static void swap(char A[],int a,int b)
+	{
+		char ch=A[a];
+		A[a]=A[b];
+		A[b]=ch;
+	}
+
+	static void sort(long[] a) //check for long
+	{
+		ArrayList<Long> l=new ArrayList<>();
+		for (long i:a) l.add(i);
+		Collections.sort(l);
+		for (int i=0; i<a.length; i++) a[i]=l.get(i);
+	}
+	static void setGraph(int N)
+	{
+		g=new ArrayList<ArrayList<Integer>>();
+		for(int i=0; i<=N; i++)
+		{
+			g.add(new ArrayList<Integer>());
+		}
+	}
+
+	static  long pow(long a,long b)
+	{
+		long mod=1000000007;
+		long pow=1;
+		long x=a;
+		while(b!=0)
+		{
+			if((b&1)!=0)pow=(pow*x)%mod;
+			x=(x*x)%mod;
+			b/=2;
+		}
+		return pow;
+	}
+	static long toggleBits(long x)//one's complement || Toggle bits
+	{
+		int n=(int)(Math.floor(Math.log(x)/Math.log(2)))+1;
+
+		return ((1<<n)-1)^x;
+	}
+	static int countBits(long a)
+	{
+		return (int)(Math.log(a)/Math.log(2)+1);
+	}
+	static void sort(int[] a) {
+		ArrayList<Integer> l=new ArrayList<>();
+		for (int i:a) l.add(i);
+		Collections.sort(l);
+		for (int i=0; i<a.length; i++) a[i]=l.get(i);
+	}
+	static boolean isPrime(long N)
+	{
+		if (N<=1)  return false; 
+		if (N<=3)  return true; 
+		if (N%2 == 0 || N%3 == 0) return false; 
+		for (int i=5; i*i<=N; i=i+6) 
+			if (N%i == 0 || N%(i+2) == 0) 
+				return false; 
+		return true; 
+	}
+	static long GCD(long a,long b) 
+	{
+		if(b==0)
+		{
+			return a;
+		}
+		else return GCD(b,a%b );
+	}
+
+	//Debugging Functions Starts
+
+	static void print(char A[])
+	{
+		for(char c:A)System.out.print(c+"" "");
+		System.out.println();
+	}
+	static void print(boolean A[])
+	{
+		for(boolean c:A)System.out.print(c+"" "");
+		System.out.println();
+	}
+	static void print(int A[])
+	{
+		for(int a:A)System.out.print(a+"" "");
+		System.out.println();	
+	}
+	static void print(long A[])
+	{
+		for(long i:A)System.out.print(i+ "" "");
+		System.out.println();
+
+	}
+	static void print(ArrayList<Integer> A)
+	{
+		for(int a:A)System.out.print(a+"" "");
+		System.out.println();
+	}
+
+	//Debugging Functions END
+	//----------------------
+	//IO FUNCTIONS STARTS
+	static HashMap<Integer,Integer> Hash(int A[])
+	{
+		HashMap<Integer,Integer> mp=new HashMap<>();
+		for(int a:A)
+		{
+			int f=mp.getOrDefault(a,0)+1;
+			mp.put(a, f);
+		}
+		return mp;
+	}
+	static int i()
+	{
+		return in.nextInt();
+	}
+
+	static long l()
+	{
+		return in.nextLong();
+	}
+
+	static int[] input(int N){
+		int A[]=new int[N];
+		for(int i=0; i<N; i++)
+		{
+			A[i]=in.nextInt();
+		}
+		return A;
+	}
+
+	static long[] inputLong(int N)     {
+		long A[]=new long[N];
+		for(int i=0; i<A.length; i++)A[i]=in.nextLong();
+		return A;
+	}
+
+	//IO FUNCTIONS END
+
+}
+
+class node implements Comparable<node>
+{
+	int l,r,index;
+	node(int l,int r,int index)
+	{
+		this.l=l;
+		this.r=r;
+		this.index=index;
+	}
+	public int compareTo(node X)
+	{
+		return X.r-this.r;
+	}
+}
+class node1 implements Comparable<node1>
+{
+	int l,r,index;
+	node1(int l,int r,int index)
+	{
+		this.l=l;
+		this.r=r;
+		this.index=index;
+	}
+	public int compareTo(node1 X)
+	{
+		if(this.l==X.l)
+			return X.r-this.r;
+		return this.l-X.l;
+	}
+}
+//Code For FastReader
+//Code For FastReader
+//Code For FastReader
+//Code For FastReader
+class FastReader
+{
+	BufferedReader br;
+	StringTokenizer st;
+	public FastReader()
+	{
+		br=new BufferedReader(new InputStreamReader(System.in));
+	}
+
+	String next()
+	{
+		while(st==null || !st.hasMoreElements())
+		{
+			try
+			{
+				st=new StringTokenizer(br.readLine());
+			}
+			catch(IOException e)
+			{
+				e.printStackTrace();
+			}
+		}
+		return st.nextToken();
+	}
+
+	int nextInt()
+	{
+		return Integer.parseInt(next());
+	}
+
+	long nextLong()
+	{
+		return Long.parseLong(next());
+	}
+	//gey
+	double nextDouble()
+	{
+		return Double.parseDouble(next());
+	}
+
+	String nextLine()
+	{
+		String str="""";
+		try
+		{
+			str=br.readLine();
+		}
+		catch (IOException e)
+		{
+			e.printStackTrace();
+		}
+		return str;
+	}
+
+}",0
+0ecf356d,b2bae06a,"import java.io.*;
+import java.util.*;
+
+public class Main {
+
+    public static void main(String[] args) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        int n = Integer.parseInt(br.readLine());
+        StringTokenizer st = new StringTokenizer(br.readLine());
+        int[] h = new int[n];
+        int[] dp = new int[n];
+        for(int i = 0; i<n; i++){
+            h[i] = Integer.parseInt(st.nextToken());
+        }
+        Stack<Integer> hi = new Stack<>();
+        Stack<Integer> lo = new Stack<>();
+        hi.push(0);
+        lo.push(0);
+        for(int i = 1; i<n; i++){
+            dp[i] = dp[i-1]+1;
+            while(!hi.isEmpty() && h[hi.peek()]<h[i]){
+                dp[i] = Math.min(dp[i], dp[hi.peek()]+1);
+                hi.pop();
+            }
+            if(!hi.isEmpty()){
+                dp[i] = Math.min(dp[i], dp[hi.peek()]+1);
+                if(h[i] == h[hi.peek()]) hi.pop();
+            }
+            while(!lo.isEmpty() && h[lo.peek()]>h[i]){
+                dp[i] = Math.min(dp[i], dp[lo.peek()]+1);
+                lo.pop();
+            }
+            if(!lo.isEmpty()){
+                dp[i] = Math.min(dp[i], dp[lo.peek()]+1);
+                if(h[i] == h[lo.peek()]) lo.pop();
+            }
+            hi.push(i);
+            lo.push(i);
+        }
+        System.out.println(dp[n-1]);
+    }
+}
+","    import java.util.*;
+    import java.io.*;
+    public class D{
+        static class InputReader {
+
+            private final InputStream stream;
+            private final byte[] buf = new byte[8192];
+            private int curChar, snumChars;
+            private SpaceCharFilter filter;
+
+            public InputReader(InputStream stream) {
+                this.stream = stream;
+            }
+
+            public int snext() {
+                if (snumChars == -1)
+                    throw new InputMismatchException();
+                if (curChar >= snumChars) {
+                    curChar = 0;
+                    try {
+                        snumChars = stream.read(buf);
+                    } catch (IOException e) {
+                        throw new InputMismatchException();
+                    }
+                    if (snumChars <= 0)
+                        return -1;
+                }
+                return buf[curChar++];
+            }
+
+            public int nextInt() {
+                int c = snext();
+                while (isSpaceChar(c)) {
+                    c = snext();
+                }
+                int sgn = 1;
+                if (c == '-') {
+                    sgn = -1;
+                    c = snext();
+                }
+                int res = 0;
+                do {
+                    if (c < '0' || c > '9')
+                        throw new InputMismatchException();
+                    res *= 10;
+                    res += c - '0';
+                    c = snext();
+                } while (!isSpaceChar(c));
+                return res * sgn;
+            }
+
+            public long nextLong() {
+                int c = snext();
+                while (isSpaceChar(c)) {
+                    c = snext();
+                }
+                int sgn = 1;
+                if (c == '-') {
+                    sgn = -1;
+                    c = snext();
+                }
+                long res = 0;
+                do {
+                    if (c < '0' || c > '9')
+                        throw new InputMismatchException();
+                    res *= 10;
+                    res += c - '0';
+                    c = snext();
+                } while (!isSpaceChar(c));
+                return res * sgn;
+            }
+
+            public int[] nextIntArray(int n) {
+                int a[] = new int[n];
+                for (int i = 0; i < n; i++) {
+                    a[i] = nextInt();
+                }
+                return a;
+            }
+
+            public String readString() {
+                int c = snext();
+                while (isSpaceChar(c)) {
+                    c = snext();
+                }
+                StringBuilder res = new StringBuilder();
+                do {
+                    res.appendCodePoint(c);
+                    c = snext();
+                } while (!isSpaceChar(c));
+                return res.toString();
+            }
+
+            public String nextLine() {
+                int c = snext();
+                while (isSpaceChar(c))
+                    c = snext();
+                StringBuilder res = new StringBuilder();
+                do {
+                    res.appendCodePoint(c);
+                    c = snext();
+                } while (!isEndOfLine(c));
+                return res.toString();
+            }
+
+            public boolean isSpaceChar(int c) {
+                if (filter != null)
+                    return filter.isSpaceChar(c);
+                return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
+            }
+
+            private boolean isEndOfLine(int c) {
+                return c == '\n' || c == '\r' || c == -1;
+            }
+
+            public interface SpaceCharFilter {
+                public boolean isSpaceChar(int ch);
+            }
+
+        }
+        static class OutputWriter {
+            private final PrintWriter writer;
+    
+            public OutputWriter(OutputStream outputStream) {
+                writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
+            }
+    
+            public OutputWriter(Writer writer) {
+                this.writer = new PrintWriter(writer);
+            }
+    
+            public void print(Object...objects) {
+                for (int i = 0; i < objects.length; i++) {
+                    if (i != 0)
+                        writer.print(' ');
+                    writer.print(objects[i]);
+                }
+            }
+    
+            public void printLine(Object...objects) {
+                print(objects);
+                writer.println();
+            }
+    
+            public void close() {
+                writer.close();
+            }
+    
+            public void flush() {
+                writer.flush();
+            }
+    
+            }
+        static int gcd(int a, int b) 
+        { 
+            if (a == 0) 
+                return b; 
+            return gcd(b % a, a); 
+        } 
+        static int mod = (int)(1e9+7);
+        public static long pow(long a,long b)
+        {
+            long ans = 1;
+            while(b> 0)
+            {
+                if((b & 1)==1){
+                    ans = (ans*a) % mod; 
+                }
+                a = (a*a) % mod;
+                b = b>>1;
+            }
+            return ans;
+        }
+
+        public static void main(String[] args) {
+            InputReader in = new InputReader(System.in);
+            OutputWriter out = new OutputWriter(System.out);
+            int n = in.nextInt();
+            int[] arr = in.nextIntArray(n);
+            Stack<Integer> min = new Stack<>();
+            Stack<Integer> max = new Stack<>();
+            int[] dp = new int[n];
+            // Arrays.fill(dp,(int)1e9);
+            dp[0] = 0;
+            min.push(0);
+            max.push(0);
+            for(int i=1;i<n;i++)
+            {
+                int h=dp[i-1]+1;
+                while(!max.isEmpty() && arr[i]>arr[max.peek()])
+                {
+                    int x = arr[max.peek()];
+                    h = Math.min(h,1+dp[max.pop()]);
+                    while(!max.isEmpty() && arr[max.peek()]==x)
+                    {
+                        max.pop();
+                    }
+                }
+                if(!max.isEmpty())
+                {
+                    h = Math.min(h,1+dp[max.peek()]);
+                }
+                while(!min.isEmpty() && arr[i]<arr[min.peek()])
+                {
+                    int x = arr[min.peek()];
+                    h = Math.min(h,1+dp[min.pop()]);
+                    while(!min.isEmpty() && arr[min.peek()]==x)
+                    {
+                        min.pop();
+                    }
+                }
+                if(!min.isEmpty())
+                {
+                    h = Math.min(h,1+dp[min.peek()]);
+                }
+                dp[i] = h;
+                min.push(i);
+                max.push(i);
+            }
+            out.printLine(dp[n-1]);
+            out.flush();
+            out.close();
+        }
+    }",0
+81fb6415,b3d4c5ca,"import java.math.BigInteger;
+import java.util.*;
+import java.io.*;
+import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
+
+public class CodeForces {
+
+
+    public void run() throws Exception {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        int t = Integer.parseInt(br.readLine());
+        next : while (t-- > 0) {
+            StringTokenizer st = new StringTokenizer(br.readLine());
+            int n = Integer.parseInt(st.nextToken());
+            long k = Long.parseLong(st.nextToken());
+            Long[] a = new Long[n];
+            st = new StringTokenizer(br.readLine());
+            for (int i = 0; i < n; i++) {
+                a[i] = Long.parseLong(st.nextToken());
+            }
+            Arrays.sort(a);
+            long ans = Long.MAX_VALUE;
+            long[] lsum = new long[n + 1];
+            for (int i = 0; i < n; i++) {
+                lsum[i + 1] = lsum[i] + a[i];
+            }
+            for (long y = 0; y < n; y++) {
+                long x = 0;
+                if ((k - lsum[n - (int)y] + a[0]) >= 0) {
+                    x = (k - lsum[n - (int)y] + a[0]) / (y + 1);
+                } else {
+                    if ((k - lsum[n - (int)y] + a[0]) % (y + 1) == 0) {
+                        x = (k - lsum[n - (int)y] + a[0]) / (y + 1);
+                    } else {
+                        x = (k - lsum[n - (int)y] + a[0]) / (y + 1) - 1;
+                    }
+                }
+                x = a[0] - x;
+                ans = Math.min(ans, Math.max(0, x) + y);
+            }
+            System.out.println(ans);
+        }
+
+    }
+
+    public static void main(String[] args) throws Exception {
+        new CodeForces().run();
+    }
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+","import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.*;
+
+public class Main {
+    public static long floor(long a, long b) {
+        long res = a / b;
+        while(res * b > a) res--;
+        return res;
+    }
+    public static void main(String[] args) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        int t = Integer.parseInt(br.readLine());
+        while (t-- > 0) {
+            StringTokenizer st = new StringTokenizer(br.readLine());
+            int n = Integer.parseInt(st.nextToken());
+            long k = Long.parseLong(st.nextToken());
+            st = new StringTokenizer(br.readLine());
+            Long[] p = new Long[n];
+            for(int i = 0 ;i<n;i++) {
+                p[i] = Long.parseLong(st.nextToken());
+            }
+            Arrays.sort(p);
+            long[] sums = new long[n+1];
+            for(int i=0;i<n;i++) sums[i+1] = sums[i] + p[i];
+            long ans = Long.MAX_VALUE;
+            for(int y=0;y<n;y++) {
+                long x = p[0] - floor(k - sums[n-y] + p[0], y+1);
+                ans = Math.min(Math.max(x, 0) + y, ans);
+            }
+            System.out.println(ans);
+        }
+    }
+}",0
+2e404969,bc46480a,"import java.util.*;
+import java.lang.*;
+import java.io.*;
+
+public class Codechef {
+	static long fans[] = new long[200001];
+	static long inv[] = new long[200001];
+	static long mod = 1000000007;
+
+	static void init() {
+		fans[0] = 1;
+		inv[0] = 1;
+		fans[1] = 1;
+		inv[1] = 1;
+		for (int i = 2; i < 200001; i++) {
+			fans[i] = ((long) i * fans[i - 1]) % mod;
+			inv[i] = power(fans[i], mod - 2);
+		}
+	}
+
+	static long ncr(int n, int r) {
+		return (((fans[n] * inv[n - r]) % mod) * (inv[r])) % mod;
+	}
+
+	public static void main(String[] args) throws java.lang.Exception {
+		FastReader in = new FastReader(System.in);
+		StringBuilder sb = new StringBuilder();
+		int t = 1;
+		t = in.nextInt();
+		while (t > 0) {
+			--t;
+			int n = in.nextInt();
+			long time[] = generateArray(in, n);
+			long hp[] = generateArray(in, n);
+			int s = 0;
+			long ans = 0;
+			while(s<time.length)
+			{
+				long l = time[s] - hp[s];
+				long r = time[s];
+				for(int i = s+1;i<n;i++)
+				{
+					if(time[i]-hp[i]<=l)
+					{
+						l = time[i]-hp[i];
+						r = time[i];
+					}
+					else if(time[i]-hp[i]<r)
+					{
+						r = time[i];
+					}
+				}
+					
+					while(s<n && time[s]>=l && time[s]<=r)
+					{
+						++s;
+					}
+					long temp = r - l;
+					ans += (temp*(temp+1))/2;
+			}
+			sb.append(ans+""\n"");
+
+		}
+		System.out.print(sb);
+	}
+
+	static long power(long x, long y) {
+		long res = 1; // Initialize result
+
+		while (y > 0) {
+
+			// If y is odd, multiply x with result
+			if ((y & 1) != 0)
+				res = ((res % mod) * (x % mod)) % mod;
+
+			// y must be even now
+			y = y >> 1; // y = y/2
+			x = ((x % mod) * (x % mod)) % mod; // Change x to x^2
+		}
+		return res;
+	}
+
+	static long[] generateArray(FastReader in, int n) throws IOException {
+		long arr[] = new long[n];
+		for (int i = 0; i < n; i++)
+			arr[i] = in.nextLong();
+		return arr;
+	}
+
+	static long[][] generatematrix(FastReader in, int n, int m) throws IOException {
+		long arr[][] = new long[n][m];
+		for (int i = 0; i < n; i++) {
+			for (int j = 0; j < m; j++) {
+				arr[i][j] = in.nextLong();
+			}
+		}
+		return arr;
+	}
+
+	static long gcd(long a, long b) {
+		if (a == 0)
+			return b;
+		else
+			return gcd(b % a, a);
+	}
+
+	static long lcm(long a, long b) {
+		return (a / gcd(a, b)) * b;
+	}
+
+	static void sort(long[] a) {
+		ArrayList<Long> l = new ArrayList<>();
+		for (long i : a)
+			l.add(i);
+		Collections.sort(l);
+		for (int i = 0; i < a.length; i++)
+			a[i] = l.get(i);
+	}
+}
+
+class FastReader {
+
+	byte[] buf = new byte[2048];
+	int index, total;
+	InputStream in;
+
+	FastReader(InputStream is) {
+		in = is;
+	}
+
+	int scan() throws IOException {
+		if (index >= total) {
+			index = 0;
+			total = in.read(buf);
+			if (total <= 0) {
+				return -1;
+			}
+		}
+		return buf[index++];
+	}
+
+	String next() throws IOException {
+		int c;
+		for (c = scan(); c <= 32; c = scan())
+			;
+		StringBuilder sb = new StringBuilder();
+		for (; c > 32; c = scan()) {
+			sb.append((char) c);
+		}
+		return sb.toString();
+	}
+
+	String nextLine() throws IOException {
+		int c;
+		for (c = scan(); c <= 32; c = scan())
+			;
+		StringBuilder sb = new StringBuilder();
+		for (; c != 10 && c != 13; c = scan()) {
+			sb.append((char) c);
+		}
+		return sb.toString();
+	}
+
+	char nextChar() throws IOException {
+		int c;
+		for (c = scan(); c <= 32; c = scan())
+			;
+		return (char) c;
+	}
+
+	int nextInt() throws IOException {
+		int c, val = 0;
+		for (c = scan(); c <= 32; c = scan())
+			;
+		boolean neg = c == '-';
+		if (c == '-' || c == '+') {
+			c = scan();
+		}
+		for (; c >= '0' && c <= '9'; c = scan()) {
+			val = (val << 3) + (val << 1) + (c & 15);
+		}
+		return neg ? -val : val;
+	}
+
+	long nextLong() throws IOException {
+		int c;
+		long val = 0;
+		for (c = scan(); c <= 32; c = scan())
+			;
+		boolean neg = c == '-';
+		if (c == '-' || c == '+') {
+			c = scan();
+		}
+		for (; c >= '0' && c <= '9'; c = scan()) {
+			val = (val << 3) + (val << 1) + (c & 15);
+		}
+		return neg ? -val : val;
+	}
+}","import java.io.IOException;
+import java.io.InputStream;
+import java.util.Arrays;
+import java.util.InputMismatchException;
+
+/**
+ * Accomplished using the EduTools plugin by JetBrains https://plugins.jetbrains.com/plugin/10081-edutools
+ */
+
+public class Main {
+   static InputReader sc=new InputReader(System.in);
+   public static void main(String[] args) {
+      // Write your solution here
+      int t=sc.nextInt();
+      while(t-->0){
+         solve();
+      }
+   }
+
+   private static void solve() {
+      int n=sc.nextInt();
+      Node left[]=new Node[n];
+      int index=0;
+      Node ini[]=new Node[n];
+      int tmp[]=new int[n];
+      for(int i=0;i<n;i++){
+         tmp[i]=sc.nextInt();
+      }
+      for(int i=0;i<n;i++){
+         ini[i]=new Node(tmp[i],tmp[i]-sc.nextInt()+1);
+      }
+      Arrays.sort(ini);
+      left[0]=ini[0];
+      for(int i=1;i<n;i++){
+         //System.out.println(ini[i].k+"" ""+ini[i].s);
+         if(ini[i].s<=left[index].k&&ini[i].k>left[index].k){
+            left[index].k=ini[i].k;
+         }else if(ini[i].s>left[index].k){
+            index++;
+            left[index]=ini[i];
+         }
+      }
+      long ans=0;
+      for(int i=0;i<=index;i++){
+         //System.out.println(left[i].k+"" ""+left[i].s);
+         ans+=(long)(left[i].k-left[i].s+2)*(left[i].k-left[i].s+1)/2;
+      }
+      System.out.println(ans);
+
+
+   }
+}
+class Node implements Comparable<Node>{
+   int k,s;
+   Node(int k,int s){
+      this.s=s;
+      this.k=k;
+   }
+   @Override
+   public int compareTo(Node node) {
+      return this.s-node.s;
+   }
+}
+class InputReader {
+
+   private final InputStream stream;
+   private final byte[] buf = new byte[8192];
+   private int curChar, snumChars;
+
+   public InputReader(InputStream st) {
+      this.stream = st;
+   }
+
+   public int read() {
+      if (snumChars == -1)
+         throw new InputMismatchException();
+      if (curChar >= snumChars) {
+         curChar = 0;
+         try {
+            snumChars = stream.read(buf);
+         } catch (IOException e) {
+            throw new InputMismatchException();
+         }
+         if (snumChars <= 0)
+            return -1;
+      }
+      return buf[curChar++];
+   }
+
+   public int nextInt() {
+      int c = read();
+      while (isSpaceChar(c)) {
+         c = read();
+      }
+      int sgn = 1;
+      if (c == '-') {
+         sgn = -1;
+         c = read();
+      }
+      int res = 0;
+      do {
+         res *= 10;
+         res += c - '0';
+         c = read();
+      } while (!isSpaceChar(c));
+      return res * sgn;
+   }
+
+   public long nextLong() {
+      int c = read();
+      while (isSpaceChar(c)) {
+         c = read();
+      }
+      int sgn = 1;
+      if (c == '-') {
+         sgn = -1;
+         c = read();
+      }
+      long res = 0;
+      do {
+         res *= 10;
+         res += c - '0';
+         c = read();
+      } while (!isSpaceChar(c));
+      return res * sgn;
+   }
+
+   public int[] nextIntArray(int n) {
+      int a[] = new int[n];
+      for (int i = 0; i < n; i++) {
+         a[i] = nextInt();
+      }
+      return a;
+   }
+
+   public String readString() {
+      int c = read();
+      while (isSpaceChar(c)) {
+         c = read();
+      }
+      StringBuilder res = new StringBuilder();
+      do {
+         res.appendCodePoint(c);
+         c = read();
+      } while (!isSpaceChar(c));
+      return res.toString();
+   }
+
+   public String nextLine() {
+      int c = read();
+      while (isSpaceChar(c))
+         c = read();
+      StringBuilder res = new StringBuilder();
+      do {
+         res.appendCodePoint(c);
+         c = read();
+      } while (!isEndOfLine(c));
+      return res.toString();
+   }
+
+   public boolean isSpaceChar(int c) {
+      return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
+   }
+
+   private boolean isEndOfLine(int c) {
+      return c == '\n' || c == '\r' || c == -1;
+   }
+
+}
+",0
+4f7af821,f870e76b,"import java.util.*;
+
+public class contestA {
+    public static void main(String[] args) {
+        Scanner scanner = new Scanner(System.in);
+        int t = scanner.nextInt();
+        int inf = 1000300300;
+        while (t-->0){
+            int n = scanner.nextInt();
+            int k = scanner.nextInt();
+            int[] c = new int[n];
+            Arrays.fill(c,inf);
+            int[] a = new int[k];
+            int[] b = new int[k];
+            for(int i=0;i<k;++i) a[i] = scanner.nextInt() - 1;
+            for(int i=0;i<k;++i) b[i] = scanner.nextInt();
+            for(int i=0;i<k;++i) c[a[i]] = b[i];
+            for(int i=1;i<n;++i){
+                c[i] = Math.min(c[i],c[i-1]+1);
+            }
+            for(int i=n-2;i>=0;--i){
+                c[i] = Math.min(c[i],c[i+1]+1);
+            }
+            for(int i=0;i<n;++i) System.out.print(c[i]+"" "");
+            System.out.println();
+        }
+    }
+}
+
+","
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.OutputStream;
+import java.io.PrintWriter;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Stack;
+import java.util.StringTokenizer;
+import java.util.Vector;
+
+public class Main {
+
+	static InputStream inputStream = System.in;
+	static OutputStream outputStream = System.out;
+	static InputReader in = new InputReader(inputStream);
+	static PrintWriter out = new PrintWriter(outputStream);
+
+	public static void main(String[] args) {
+
+		int t = in.nextInt();
+
+		while (t-- > 0) {
+
+			int n = in.nextInt();
+
+			int k = in.nextInt();
+
+			int[] v1 = new int[k];
+			int[] v2 = new int[k];
+
+			for (int i = 0; i < k; i++) {
+				v1[i] = in.nextInt();
+			}
+
+			for (int i = 0; i < k; i++) {
+				v2[i] = in.nextInt();
+			}
+			
+			
+			
+			//wejhfduiwehiofhw
+
+			int[] res = new int[n + 2];
+
+			Arrays.fill(res, 2000000000);
+
+			for (int i = 0; i < k; i++) {
+				res[v1[i]] = v2[i];
+
+			}
+
+			for (int i = 1; i <= n; i++) {
+
+				int val = Math.min(res[i], res[i - 1] + 1);
+
+				res[i] = val;
+
+			}
+			
+			//ewhfowiejp
+			
+			
+			
+			
+			
+			
+			
+			
+			
+			//wedhciuwahidochqowi
+			
+			
+			
+			
+			
+			
+			
+			
+			//wjdhoiqwnlidhqw
+			for (int i = n; i >= 1; i--) {
+				int val1 = Math.min(res[i], res[i + 1] + 1);
+				res[i] = val1;
+				// out.println(res[i]);
+			}
+
+			for (int i = 1; i <= n; i++) {
+				int r = res[i];
+				out.print(r + "" "");
+
+			}
+
+			out.println();
+
+		}
+
+		out.close();
+	}
+
+	private static void takeinput(int[] arr, int k) {
+		for (int i = 0; i < k; i++) {
+			arr[i] = in.nextInt();
+		}
+
+	}
+
+	static class InputReader {
+		public BufferedReader reader;
+		public StringTokenizer tokenizer;
+
+		public InputReader(InputStream stream) {
+			reader = new BufferedReader(new InputStreamReader(stream), 32768);
+			tokenizer = null;
+		}
+
+		public String next() {
+			while (tokenizer == null || !tokenizer.hasMoreTokens()) {
+				try {
+					tokenizer = new StringTokenizer(reader.readLine());
+				} catch (IOException e) {
+					throw new RuntimeException(e);
+				}
+			}
+			return tokenizer.nextToken();
+		}
+
+		public long nextLong() {
+			return Long.parseLong(next());
+		}
+
+		public int nextInt() {
+			return Integer.parseInt(next());
+		}
+
+		public String nextLine() throws IOException {
+			return reader.readLine().trim();
+		}
+	}
+
+}
+",0
+b55888de,d3a0b8d2,"import java.lang.reflect.Array;
+import java.util.*;
+public class Rough {
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);   
+        int t = sc.nextInt();
+        while (t-->0) {
+            int n = sc.nextInt();
+            sc.nextLine();
+            String s[] = new String[n];
+            int f[][] = new int[n][5];
+            for (int i = 0; i < n; i++) {
+                s[i]  = sc.nextLine();
+
+                for (int j = 0; j < s[i].length(); j++) {
+                    f[i][s[i].charAt(j)-'a']++;
+                }
+            }
+
+            int ans = 0;
+            for ( int i = 0; i < 5; i++) {
+                ArrayList<Integer> al = new ArrayList<>();
+
+                for (int j = 0; j < n; j++) {
+                    int o = 0;
+                    for (int k = 0; k < 5; k++) {
+                        if(k != i)
+                            o+=f[j][k];
+                    }
+                    al.add(f[j][i]-o);
+                }
+
+                Collections.sort(al,Collections.reverseOrder());
+
+                int max = 0;
+                int x = 0;
+                for (int j = 0; j < n; j++) {
+                    x+=al.get(j);
+                    if(x<=0)break;
+                    max++;
+                }
+                ans = Math.max(max,ans);
+            }
+
+            System.out.println(ans);
+        }
+        sc.close();
+    }
+}","import java.io.File;
+import java.io.IOException;
+import java.util.*;
+
+public class C {
+    public static void main(String[] args){
+        Scanner in = new Scanner(System.in);
+        int t = in.nextInt();
+        while (t-- > 0){
+            int n = in.nextInt();
+            int[][] cnt = new int[n][5];
+            int[] len = new int[n];
+            for (int i = 0; i < n; i++){
+                String s = in.next();
+                len[i] = s.length();
+                for (char c : s.toCharArray()) cnt[i][c-'a']++;
+            }
+            int max = 0;
+            for (int i = 0; i < 5; i++){
+                int[] diff = new int[n];
+                for (int j = 0; j < n; j++) diff[j] = cnt[j][i] - (len[j] - cnt[j][i]);
+                Arrays.sort(diff);
+                int j = n-2, sum = diff[n-1];
+                while (j>=0 && sum > 0){
+                    max = Math.max(max, n - 1 - j);
+                    sum += diff[j]; j--;
+                }
+                if (sum > 0) max = Math.max(max, n);
+            }
+            System.out.println(max);
+        }
+    }
+}
+",0
+4201fdf7,93322168,"//https://codeforces.com/contest/1525/problem/D
+//D. Armchairs
+import java.util.*;
+import java.io.*;
+public class CF_1525_D{
+	public static void main(String[] args) throws Exception{
+		
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		PrintWriter pw = new PrintWriter(new OutputStreamWriter(System.out));
+		StringBuilder sb = new StringBuilder();
+		StringTokenizer st;
+
+		int n = Integer.parseInt(br.readLine());
+		int a[] = new int[n];
+		ArrayList<Integer> pos = new ArrayList<Integer>();
+
+		st = new StringTokenizer(br.readLine());
+		for(int i=0;i<n;i++){
+			a[i] = Integer.parseInt(st.nextToken());
+			if(a[i]==1)
+				pos.add(i);
+		}
+
+		int z = pos.size();
+		int dp[][] = new int[n+1][z+1];
+		for(int i=0;i<=n;i++)
+			Arrays.fill(dp[i], Integer.MAX_VALUE);
+
+		dp[0][0] = 0;
+		for(int i=0;i<n;i++){
+			for(int j=0;j<=z;j++){
+				if(dp[i][j] == Integer.MAX_VALUE)
+					continue;
+				dp[i+1][j] = Math.min(dp[i+1][j], dp[i][j]);
+
+				if(j<z && a[i]==0)
+					dp[i+1][j+1] = Math.min(dp[i+1][j+1], dp[i][j]+Math.abs(pos.get(j)-i));
+			}
+		}
+
+
+		pw.print(dp[n][z]);
+		pw.flush();
+		pw.close();
+	}
+}","//Some of the methods are copied from GeeksforGeeks Website  
+import java.util.*;
+import java.lang.*;
+import java.io.*;
+public class Main
+{ 
+  static  Reader sc=new Reader();
+  // static FastReader sc=new FastReader(System.in);
+  static ArrayList<Integer> one;
+  static ArrayList<Integer> zero;
+  static long dp[][];
+  static void ini()
+   {
+      for(long a[] : dp)
+        Arrays.fill(a,-1);
+   }
+static long solve(int i,int j)
+ {
+    if(i==one.size()) return 0;
+    if(j==zero.size()) return int_max;
+    
+    if(dp[i][j]!=-1) return dp[i][j];
+    
+     long ans1=Math.abs(one.get(i)-zero.get(j))+solve(i+1,j+1);
+     long ans2=solve(i,j+1);
+     return dp[i][j]=Math.min(ans1,ans2);
+ }
+   // static int ceilSearch(ArrayList<Integer> arr, int low, int high, int x)
+   //  {
+   //    int mid;   
+       
+   //    /* If x is smaller than or equal to the
+   //       first element, then return the first element */
+   //    if(x <= arr.get(low))
+   //     return low;
+      
+   //    /* If x is greater than the last
+   //       element, then return -1 */
+   //    if(x > arr.get(high))
+   //     return -1; 
+      
+   //    /* get the index of middle element
+   //       of arr[low..high]*/
+   //    mid = (low + high)/2;  /* low + (high - low)/2 */
+      
+   //    /* If x is same as middle element,
+   //       then return mid */
+   //    if(arr.get(mid) == x)
+   //     return mid;
+          
+   //    /* If x is greater than arr[mid], then
+   //       either arr[mid + 1] is ceiling of x or
+   //       ceiling lies in arr[mid+1...high] */
+   //    else if(arr.get(mid) < x)
+   //    {
+   //     if(mid + 1 <= high && x <= arr.get(mid+1))
+   //        return mid + 1;
+   //     else
+   //        return ceilSearch(arr, mid+1, high, x);
+   //    }
+      
+   //    /* If x is smaller than arr[mid],
+   //       then either arr[mid] is ceiling of x
+   //       or ceiling lies in arr[low...mid-1] */  
+   //    else
+   //    {
+   //     if(mid - 1 >= low && x > arr.get(mid-1))
+   //        return mid;
+   //     else   
+   //        return ceilSearch(arr, low, mid - 1, x);
+   //    }
+   //  }
+    
+   //  static int floorSearch(
+   //     ArrayList<Integer> arr, int low,
+   //     int high, int x)
+   //  {
+   //     // If low and high cross each other
+   //     if (low > high)
+   //          return -1;
+ 
+   //     // If last element is smaller than x
+   //     if (x >= arr.get(high))
+   //          return high;
+ 
+   //     // Find the middle point
+   //     int mid = (low + high) / 2;
+ 
+   //     // If middle point is floor.
+   //     if (arr.get(mid) == x)
+   //          return mid;
+ 
+   //     // If x lies between mid-1 and mid
+   //     if (
+   //          mid > 0 && arr.get(mid - 1) <= x && x < arr.get(mid))
+   //          return mid - 1;
+ 
+   //     // If x is smaller than mid, floor
+   //     // must be in left half.
+   //     if (x < arr.get(mid))
+   //          return floorSearch(
+   //              arr, low,
+   //              mid - 1, x);
+ 
+   //     // If mid-1 is not floor and x is
+   //     // greater than arr[mid],
+   //     return floorSearch(
+   //          arr, mid + 1, high,
+   //          x);
+   //  }
+ 
+ 
+ public static void main (String[] args) throws java.lang.Exception
+   {
+	try{
+	  
+		  int t = 1;// sc.nextInt();
+		  int max=5001;
+		  dp=new long[max][max];
+		  ini();
+		  one=new ArrayList<>();
+		  zero=new ArrayList<>();
+		  while(t-->0)
+		    { 
+		       int n=sc.nextInt();
+		       long ans=0;
+		       int a[]=new int[n];
+		       for(int i=0;i<n;i++)
+		         {
+		           a[i]=sc.nextInt();
+		           if(a[i]==1)
+		            one.add(i);
+		           else
+		            zero.add(i);
+		         }
+		    //  print_int(one);
+		    //  print_int(zero);
+		      
+		    //  for(int i=0;i<one.size();i++)
+		    //    {
+		    //       int ele=one.get(i);
+		    //       int floor=floorSearch(zero,0,zero.size()-1,ele);
+		    //       int ceil=ceilSearch(zero,0,zero.size()-1,ele);
+		           
+		    //       int left=int_max;
+		    //       if(floor!=-1)
+		    //        left=zero.get(floor);
+		           
+		    //       int right=int_max;
+		    //       if(ceil!=-1)
+		    //        right=zero.get(ceil);
+		          
+		    //      int left_val=Math.abs(ele-left);
+		    //      int right_val=Math.abs(ele-right);
+		          
+		    //      if(left_val<=right_val)
+		    //        {
+		    //           ans+=left_val;
+		    //           zero.remove(floor);
+		    //        }
+		    //      else
+		    //        {
+		    //           ans+=right_val;
+		    //           zero.remove(ceil);
+		    //        }
+		    //    }
+		    //   out.println(ans);
+		    
+		    ans=solve(0,0);
+		    out.println(ans);
+		    }
+	     out.flush();
+	     out.close();
+	   }     
+	catch(Exception e)
+		 {}
+	}
+ 
+ /*
+   ...SOLUTION ENDS HERE...........SOLUTION ENDS HERE...
+ */
+ 
+static void flag(boolean flag)
+   {
+       out.println(flag ? ""YES"" : ""NO"");
+       out.flush();
+   }
+   
+ /*                     
+    Map<Long,Long> map=new HashMap<>();
+             for(int i=0;i<n;i++)
+               {
+                  if(!map.containsKey(a[i]))
+                   map.put(a[i],1);
+                 else
+                   map.replace(a[i],map.get(a[i])+1);
+               }
+     
+    Set<Map.Entry<Long,Long>> hmap=map.entrySet();
+             for(Map.Entry<Long,Long> data : hmap)
+               {
+          
+               }
+       
+   Iterator<Integer> it = set.iterator();
+          while(it.hasNext()) 
+           { 
+            int x=it.next();
+           }
+   */
+
+static void print(int a[])
+  {
+     int n=a.length;
+     for(int i=0;i<n;i++)
+       {
+          out.print(a[i]+"" "");
+       }
+     out.println();
+     out.flush();
+  }
+static void print(long a[])
+  {
+     int n=a.length;
+     for(int i=0;i<n;i++)
+       {
+          out.print(a[i]+"" "");
+       }
+     out.println();
+     out.flush();
+  } 
+static void print_int(ArrayList<Integer> al)
+  {
+     int si=al.size();
+     for(int i=0;i<si;i++)
+       {
+          out.print(al.get(i)+"" "");
+       }
+     out.println();
+     out.flush();
+  }
+static void print_long(ArrayList<Long> al)
+  {
+     int si=al.size();
+     for(int i=0;i<si;i++)
+       {
+          out.print(al.get(i)+"" "");
+       }
+     out.println();
+     out.flush();
+  }
+
+static class Graph
+  {
+        int v;
+        ArrayList<Integer> list[];
+        Graph(int v)
+        {
+            this.v=v;
+            list=new ArrayList[v+1];
+            for(int i=1;i<=v;i++)
+                list[i]=new ArrayList<Integer>();
+        }
+        void addEdge(int a, int b)
+        {
+            this.list[a].add(b);
+        }
+    }
+static void DFS(Graph g, boolean[] visited, int u)
+	{
+        visited[u]=true;
+        int v=0;
+        for(int i=0;i<g.list[u].size();i++)
+        {
+            v=g.list[u].get(i);
+            if(!visited[v])
+               DFS(g,visited,v);
+        }
+  } 
+  
+// static class Pair
+//    {
+//       int x,y;
+//       Pair(int x,int y)
+//        {
+//           this.x=x;
+//           this.y=y;
+//        }
+//    }
+   
+static long sum_array(int a[])
+ {
+    int n=a.length;
+    long sum=0;
+    for(int i=0;i<n;i++)
+     sum+=a[i];
+    return sum;
+ }
+static long sum_array(long a[])
+ {
+    int n=a.length;
+    long sum=0;
+    for(int i=0;i<n;i++)
+     sum+=a[i];
+    return sum;
+ }
+
+ static void sort(int[] a) 
+   {
+		ArrayList<Integer> l=new ArrayList<>();
+		for (int i:a) l.add(i);
+		Collections.sort(l);
+		for (int i=0; i<a.length; i++) a[i]=l.get(i);
+	}
+static void sort(long[] a) 
+   {
+		ArrayList<Long> l=new ArrayList<>();
+		for (long i:a) l.add(i);
+		Collections.sort(l);
+		for (int i=0; i<a.length; i++) a[i]=l.get(i);
+	}
+
+static void reverse_array(int a[])
+ {
+    int n=a.length;
+    int i,t; 
+    for (i = 0; i < n / 2; i++) { 
+            t = a[i]; 
+            a[i] = a[n - i - 1]; 
+            a[n - i - 1] = t; 
+        } 
+ }
+static void reverse_array(long a[])
+ {
+    int n=a.length;
+    int i; long t; 
+    for (i = 0; i < n / 2; i++) { 
+            t = a[i]; 
+            a[i] = a[n - i - 1]; 
+            a[n - i - 1] = t; 
+        } 
+ }
+ 
+static long gcd(long a, long b) 
+    { 
+        if (a == 0) 
+            return b; 
+          
+        return gcd(b%a, a); 
+    } 
+static int gcd(int a, int b) 
+    { 
+        if (a == 0) 
+            return b; 
+          
+        return gcd(b%a, a); 
+    } 
+
+   static class FastReader{
+ 
+        byte[] buf = new byte[2048];
+        int index, total;
+        InputStream in;
+ 
+        FastReader(InputStream is) {
+            in = is;
+        }
+ 
+        int scan() throws IOException {
+            if (index >= total) {
+                index = 0;
+                total = in.read(buf);
+                if (total <= 0) {
+                    return -1;
+                }
+            }
+            return buf[index++];
+        }
+ 
+        String next() throws IOException {
+            int c;
+            for (c = scan(); c <= 32; c = scan());
+            StringBuilder sb = new StringBuilder();
+            for (; c > 32; c = scan()) {
+                sb.append((char) c);
+            }
+            return sb.toString();
+        }
+ 
+        int nextInt() throws IOException {
+            int c, val = 0;
+            for (c = scan(); c <= 32; c = scan());
+            boolean neg = c == '-';
+            if (c == '-' || c == '+') {
+                c = scan();
+            }
+            for (; c >= '0' && c <= '9'; c = scan()) {
+                val = (val << 3) + (val << 1) + (c & 15);
+            }
+            return neg ? -val : val;
+        }
+ 
+        long nextLong() throws IOException {
+            int c;
+            long val = 0;
+            for (c = scan(); c <= 32; c = scan());
+            boolean neg = c == '-';
+            if (c == '-' || c == '+') {
+                c = scan();
+            }
+            for (; c >= '0' && c <= '9'; c = scan()) {
+                val = (val << 3) + (val << 1) + (c & 15);
+            }
+            return neg ? -val : val;
+        }
+    }
+   
+    static class Reader 
+    { 
+        final private int BUFFER_SIZE = 1 << 16; 
+        private DataInputStream din; 
+        private byte[] buffer; 
+        private int bufferPointer, bytesRead; 
+  
+        public Reader() 
+        { 
+            din = new DataInputStream(System.in); 
+            buffer = new byte[BUFFER_SIZE]; 
+            bufferPointer = bytesRead = 0; 
+        } 
+  
+        public Reader(String file_name) throws IOException 
+        { 
+            din = new DataInputStream(new FileInputStream(file_name)); 
+            buffer = new byte[BUFFER_SIZE]; 
+            bufferPointer = bytesRead = 0; 
+        } 
+  
+        public String readLine() throws IOException 
+        { 
+            byte[] buf = new byte[64]; // line length 
+            int cnt = 0, c; 
+            while ((c = read()) != -1) 
+            { 
+                if (c == '\n') 
+                    break; 
+                buf[cnt++] = (byte) c; 
+            } 
+            return new String(buf, 0, cnt); 
+        } 
+  
+        public int nextInt() throws IOException 
+        { 
+            int ret = 0; 
+            byte c = read(); 
+            while (c <= ' ') 
+                c = read(); 
+            boolean neg = (c == '-'); 
+            if (neg) 
+                c = read(); 
+            do
+            { 
+                ret = ret * 10 + c - '0'; 
+            }  while ((c = read()) >= '0' && c <= '9'); 
+  
+            if (neg) 
+                return -ret; 
+            return ret; 
+        } 
+  
+        public long nextLong() throws IOException 
+        { 
+            long ret = 0; 
+            byte c = read(); 
+            while (c <= ' ') 
+                c = read(); 
+            boolean neg = (c == '-'); 
+            if (neg) 
+                c = read(); 
+            do { 
+                ret = ret * 10 + c - '0'; 
+            } 
+            while ((c = read()) >= '0' && c <= '9'); 
+            if (neg) 
+                return -ret; 
+            return ret; 
+        } 
+  
+        public double nextDouble() throws IOException 
+        { 
+            double ret = 0, div = 1; 
+            byte c = read(); 
+            while (c <= ' ') 
+                c = read(); 
+            boolean neg = (c == '-'); 
+            if (neg) 
+                c = read(); 
+  
+            do { 
+                ret = ret * 10 + c - '0'; 
+            } 
+            while ((c = read()) >= '0' && c <= '9'); 
+  
+            if (c == '.') 
+            { 
+                while ((c = read()) >= '0' && c <= '9') 
+                { 
+                    ret += (c - '0') / (div *= 10); 
+                } 
+            } 
+  
+            if (neg) 
+                return -ret; 
+            return ret; 
+        } 
+  
+        private void fillBuffer() throws IOException 
+        { 
+            bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE); 
+            if (bytesRead == -1) 
+                buffer[0] = -1; 
+        } 
+  
+        private byte read() throws IOException 
+        { 
+            if (bufferPointer == bytesRead) 
+                fillBuffer(); 
+            return buffer[bufferPointer++]; 
+        } 
+  
+        public void close() throws IOException 
+        { 
+            if (din == null) 
+                return; 
+            din.close(); 
+        } 
+    }
+  static  PrintWriter out=new PrintWriter(System.out);
+  static int int_max=Integer.MAX_VALUE;
+  static int int_min=Integer.MIN_VALUE;
+  static long long_max=Long.MAX_VALUE;
+  static long long_min=Long.MIN_VALUE;
+}
+// Thank You !",0
+1dab88fb,9c55bc1b,"import java.util.*;
+
+public class Main
+{
+    static class Edge{
+        public int node;
+        public int index;
+        public Edge(int n, int i){
+            node=n;
+            index=i;
+        }
+    }
+    static Scanner sc=new Scanner(System.in);
+	public static void main(String[] args) {
+	    
+	    int test=sc.nextInt();
+	    while(test-->0){
+	        
+	        solve();
+	    }
+	}
+	
+	static void solve(){
+	    int n=sc.nextInt();
+	        ArrayList<ArrayList<Edge>> graph= new ArrayList<ArrayList<Edge>>();
+	        for(int i=0;i<n;i++){
+	            graph.add(new ArrayList<>());
+	        }
+	        for (int i = 0; i < n - 1; i++) {
+	            int u = sc.nextInt();
+	            int v = sc.nextInt();
+	            u--; v--;
+	            
+	            graph.get(u).add(new Edge(v, i));
+	            graph.get(v).add(new Edge(u, i));
+            }
+            
+            int start = 0;
+            for (int i = 0; i < n; i++) {
+                if (graph.get(i).size() > 2) {
+                    System.out.println(""-1"");
+                    return;
+                } else if (graph.get(i).size() == 1) {
+                    start = i;
+                }
+            }
+            int[] weight = new int[n - 1];
+            
+            int prevNode = -1;
+            int curNode = start;
+            int curWeight = 2;
+            
+            while (true) {
+                ArrayList<Edge> edges = graph.get(curNode);
+                Edge next = edges.get(0);
+                
+                if (next.node == prevNode) {
+                    if (edges.size() == 1) {
+                        break;
+                    } else {
+                        next = edges.get(1);
+                    }
+                }
+                weight[next.index] = curWeight;
+                
+                prevNode = curNode;
+                curNode = next.node;
+                curWeight = 5 - curWeight;
+            }
+            for (int i = 0; i < n - 1; i++) {
+                System.out.print(weight[i]);
+                System.out.print("" "");
+            }
+            System.out.println();
+	}
+}
+","import java.util.*;
+import java.io.*;
+
+public class Main {
+    static MyScanner sc;
+    static PrintWriter out;
+    static {
+        sc = new MyScanner();
+        out = new PrintWriter(System.out);
+    }
+    public static void bfs(Node[] g, int[] ans) {
+        Arrays.fill(ans, -1);
+        boolean[] visited = new boolean[g.length];
+        Queue<Integer> q = new LinkedList<>();
+        int s = 0;
+        for(int i = 0; i < g.length; i++) {
+            if(g[i].l.size() == 1) {
+                s = i;
+                break;
+            }
+        }
+        q.add(s);
+        int curr = 2;
+        while(!q.isEmpty()) {
+            int u = q.poll();
+            if(visited[u])
+                continue;
+            visited[u] = true;
+            for(Edge edge : g[u].l) {
+                if(!visited[edge.v]) {
+                    ans[edge.id] = curr;
+                    q.add(edge.v);
+                    if(curr == 2) curr = 3;
+                    else curr = 2;
+                }
+            }
+        }
+    }
+    public static void solve() {
+        int n = sc.nextInt();
+        Node[] a = new Node[n];
+        for(int i = 0; i < n; i++)
+            a[i] = new Node();
+        for(int i = 0; i < n - 1; i++) {
+            int u = sc.nextInt() - 1;
+            int v = sc.nextInt() - 1;
+            a[u].l.add(new Edge(v, i));
+            a[v].l.add(new Edge(u, i));
+        }
+        for(Node node : a) {
+            if(node.l.size() > 2) {
+                out.println(-1);
+                return;
+            }
+        }
+        int[] ans = new int[n - 1];
+        bfs(a, ans);
+        for(int i = 0; i < n - 1; i++)
+            out.print(ans[i] + "" "");
+        out.println();
+    }
+    public static void main(String[] args) {
+        int t = sc.nextInt();
+        while(t-- > 0)
+            solve();
+        out.flush();
+    }
+}
+
+class Edge {
+    int v, id;
+    Edge(int a, int b) {
+        v = a;
+        id = b;
+    }
+}
+
+class Node {
+    ArrayList<Edge> l;
+    Node() {
+        l = new ArrayList<>();
+    }
+}
+
+class MyScanner {
+    BufferedReader br;
+    StringTokenizer tok;
+    MyScanner() {
+        try { br = new BufferedReader(new InputStreamReader(System.in)); }
+        catch(Exception e) { System.out.println(e); }
+        tok = new StringTokenizer("""");
+    }
+    public String next() {
+        try {
+            while(!tok.hasMoreTokens()) tok = new StringTokenizer(br.readLine());
+        }
+        catch(Exception e) { System.out.println(e); }
+        return tok.nextToken();
+    }
+    public int nextInt() {
+        return Integer.parseInt(next());
+    }
+    public long nextLong() {
+        return Long.parseLong(next());
+    }
+    public double nextDouble() {
+        return Double.parseDouble(next());
+    }
+}
+",0
+6f393cfe,d3a0b8d2,"import java.io.*;
+import java.util.*;
+
+public class C {
+
+    public static void main(String[] args) throws Exception{
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
+        try{
+            int t = Integer.parseInt(br.readLine());
+            while(t-->0){
+                int n = Integer.parseInt(br.readLine());
+                int lst[][] = new int[n][5];
+                for(int i=0; i<n; i++){
+                    String s = br.readLine();
+                    for(int j=0; j<s.length(); j++){
+                        lst[i][s.charAt(j)-'a']++;
+                    }
+                }
+                int fans = Integer.MIN_VALUE;
+                for(int i=0; i<5; i++){
+                    int val[] = new int[n];
+                    for(int k=0; k<n; k++){
+                        int sum = 0;
+                        for(int j=0; j<5; j++){
+                            if(i==j){
+                                sum += lst[k][j];
+                            }else{
+                                sum -= lst[k][j];
+                            }
+                        }
+                        val[k] = sum;
+                    }
+                    Arrays.sort(val);
+                    int sum = 0;
+                    int ans = 0;
+                    for(int x = n-1; x>=0; x--){
+                        sum+=val[x];
+                        if(sum>0){
+                            ans++;
+                        }else{
+                            break;
+                        }
+                    }
+                    fans = Math.max(fans, ans);
+                }
+                bw.write(fans+""\n"");
+            }
+            bw.flush();
+        }catch(Exception e){
+            return;
+        }
+    }
+    
+}","import java.io.File;
+import java.io.IOException;
+import java.util.*;
+
+public class C {
+    public static void main(String[] args){
+        Scanner in = new Scanner(System.in);
+        int t = in.nextInt();
+        while (t-- > 0){
+            int n = in.nextInt();
+            int[][] cnt = new int[n][5];
+            int[] len = new int[n];
+            for (int i = 0; i < n; i++){
+                String s = in.next();
+                len[i] = s.length();
+                for (char c : s.toCharArray()) cnt[i][c-'a']++;
+            }
+            int max = 0;
+            for (int i = 0; i < 5; i++){
+                int[] diff = new int[n];
+                for (int j = 0; j < n; j++) diff[j] = cnt[j][i] - (len[j] - cnt[j][i]);
+                Arrays.sort(diff);
+                int j = n-2, sum = diff[n-1];
+                while (j>=0 && sum > 0){
+                    max = Math.max(max, n - 1 - j);
+                    sum += diff[j]; j--;
+                }
+                if (sum > 0) max = Math.max(max, n);
+            }
+            System.out.println(max);
+        }
+    }
+}
+",0
+49b94994,f0d91796,"import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.util.StringTokenizer;
+
+public class Main1582D {
+    public static void main(String[] args) {
+        final FastScanner in = new FastScanner(System.in);
+        final PrintWriter out = new PrintWriter(System.out);
+        int t = in.nextInt();
+        for (int i = 0; i < t; i++) {
+            int n = in.nextInt();
+            int[] a = new int[n];
+            for (int j = 0; j < n; j++) {
+                a[j] = in.nextInt();
+            }
+            int[] b = solution(a, n);
+            for (int j = 0; j < n; j++) {
+                out.print(b[j]);
+                out.print("" "");
+            }
+            out.println();
+        }
+
+        out.flush();
+        out.close();
+        in.close();
+    }
+
+    private static int[] solution(int[] a, int n) {
+        int[] b = new int[n];
+        int start = 0;
+
+        if (n % 2 == 1) {
+            if (a[0] + a[1] != 0) {
+                b[0] = -a[2];
+                b[1] = -a[2];
+                b[2] = a[0] + a[1];
+            } else if (a[0] + a[2] != 0) {
+                b[0] = -a[1];
+                b[1] = a[0] + a[2];
+                b[2] = -a[1];
+            } else {
+                b[0] = a[1] + a[2];
+                b[1] = -a[0];
+                b[2] = -a[0];
+            }
+            start = 3;
+        } else {
+            b[0] = -a[1];
+            b[1] = a[0];
+            int gcd = gcd(b[0], b[1]);
+            b[0] /= gcd;
+            b[1] /= gcd;
+            start = 2;
+        }
+        for (int i = start; i < n; i += 2) {
+            b[i] = -a[i + 1];
+            b[i + 1] = a[i];
+        }
+        return b;
+    }
+
+    private static int gcd(int a, int b) {
+        if (b == 0) return a;
+        return gcd(b, a % b);
+    }
+
+    private static class FastScanner {
+        BufferedReader br;
+        StringTokenizer st;
+
+        FastScanner(InputStream stream) {
+            try {
+                br = new BufferedReader(new InputStreamReader(stream));
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }
+
+        String next() {
+            while (st == null || !st.hasMoreTokens()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+
+        int[] readIntArr(int n) {
+            int[] result = new int[n];
+            for (int i = 0; i < n; i++) {
+                result[i] = Integer.parseInt(next());
+            }
+            return result;
+        }
+
+        long[] readLongArr(int n) {
+            long[] result = new long[n];
+            for (int i = 0; i < n; i++) {
+                result[i] = Long.parseLong(next());
+            }
+            return result;
+        }
+
+
+        void close() {
+            try {
+                br.close();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+
+    }
+}
+","import java.io.*;
+import java.util.*;
+ 
+public class cf {
+ 
+    public static void main(String[] args){
+ 
+        FastScanner sc = new FastScanner();
+        int t = sc.nextInt();
+        while(t-- > 0){
+ 			
+ 			int n=sc.nextInt();
+            int arr[]=new int[n];
+            for(int i=0;i<n;i++){
+                arr[i]=sc.nextInt();
+            }
+            int ans[]=new int[n];
+            if(n%2==0){
+                for(int i=0;i<n;i=i+2){
+                    ans[i]=-arr[i+1];
+                    ans[i+1]=arr[i];
+                }
+            }
+            else{
+                if(arr[0]+arr[1]!=0){
+                    ans[0]=-arr[2];
+                    ans[1]=-arr[2];
+                    ans[2]=arr[0]+arr[1];
+                }
+                else{
+                    if(arr[1]+arr[2]!=0){
+                        ans[1]=-arr[0];
+                        ans[2]=-arr[0];
+                        ans[0]=arr[1]+arr[2];
+                    }
+                    else{
+                        ans[0]=-arr[1];
+                        ans[2]=-arr[1];
+                        ans[1]=arr[0]+arr[2];
+                    }
+                }
+                for(int i=3;i<n;i=i+2){
+                    ans[i]=-arr[i+1];
+                    ans[i+1]=arr[i];
+                }
+            }
+            for(int j=0;j<n;j++){
+                System.out.print(ans[j]+"" "");
+            }
+            System.out.println();
+            
+
+            
+            
+
+            
+
+            
+           
+ 			
+
+        }	        	
+        	
+ 			
+    }
+ 
+    
+    
+    
+ 
+}
+
+//////////////////////////////////////////////////////////////
+// LCM AND GCD
+/*
+	public static int gcd(int a,int b){
+		if(b == 0){
+			return a;
+		}
+		return gcd(b,a%b);
+	}
+ 
+	public static int lcm(int a,int b){
+		 return (a / gcd(a, b)) * b;
+	}*/
+
+
+///////////////////////////////////////////////////////////////////////////////////
+
+//Iterator
+
+
+
+/*Iterator iterator = object.iterator();
+ 
+        while (iterator.hasNext()) {
+            System.out.print(iterator.next() + "" "");
+        }*/
+///////////////////////////////////////////////////////////////////////////////////
+
+
+class FastScanner
+{
+    //I don't understand how this works lmao
+    private int BS = 1 << 16;
+    private char NC = (char) 0;
+    private byte[] buf = new byte[BS];
+    private int bId = 0, size = 0;
+    private char c = NC;
+    private double cnt = 1;
+    private BufferedInputStream in;
+ 
+    public FastScanner() {
+        in = new BufferedInputStream(System.in, BS);
+    }
+ 
+    public FastScanner(String s) {
+        try {
+            in = new BufferedInputStream(new FileInputStream(new File(s)), BS);
+        } catch (Exception e) {
+            in = new BufferedInputStream(System.in, BS);
+        }
+    }
+ 
+    public char getChar() {
+        while (bId == size) {
+            try {
+                size = in.read(buf);
+            } catch (Exception e) {
+                return NC;
+            }
+            if (size == -1) return NC;
+            bId = 0;
+        }
+        return (char) buf[bId++];
+    }
+ 
+    public int nextInt() {
+        return (int) nextLong();
+    }
+ 
+    public int[] nextInts(int N) {
+        int[] res = new int[N];
+        for (int i = 0; i < N; i++) {
+            res[i] = (int) nextLong();
+        }
+        return res;
+    }
+ 
+    public long[] nextLongs(int N) {
+        long[] res = new long[N];
+        for (int i = 0; i < N; i++) {
+            res[i] = nextLong();
+        }
+        return res;
+    }
+ 
+    public long nextLong() {
+        cnt = 1;
+        boolean neg = false;
+        if (c == NC) c = getChar();
+        for (; (c < '0' || c > '9'); c = getChar()) {
+            if (c == '-') neg = true;
+        }
+        long res = 0;
+        for (; c >= '0' && c <= '9'; c = getChar()) {
+            res = (res << 3) + (res << 1) + c - '0';
+            cnt *= 10;
+        }
+        return neg ? -res : res;
+    }
+ 
+    public double nextDouble() {
+        double cur = nextLong();
+        return c != '.' ? cur : cur + nextLong() / cnt;
+    }
+ 
+    public double[] nextDoubles(int N) {
+        double[] res = new double[N];
+        for (int i = 0; i < N; i++) {
+            res[i] = nextDouble();
+        }
+        return res;
+    }
+ 
+    public String next() {
+        StringBuilder res = new StringBuilder();
+        while (c <= 32) c = getChar();
+        while (c > 32) {
+            res.append(c);
+            c = getChar();
+        }
+        return res.toString();
+    }
+ 
+    public String nextLine() {
+        StringBuilder res = new StringBuilder();
+        while (c <= 32) c = getChar();
+        while (c != '\n') {
+            res.append(c);
+            c = getChar();
+        }
+        return res.toString();
+    }
+ 
+    public boolean hasNext() {
+        if (c > 32) return true;
+        while (true) {
+            c = getChar();
+            if (c == NC) return false;
+            else if (c > 32) return true;
+        }
+    }
+}
+
+",0
+3afcc566,fcc7e8fa,"//package codeforces.globalround18;
+
+import java.io.*;
+import java.util.*;
+
+import static java.lang.Math.*;
+
+//Think through the entire logic before jump into coding!
+//If you are out of ideas, take a guess! It is better than doing nothing!
+//Read both C and D, it is possible that D is easier than C for you!
+
+//Be aware of integer overflow!
+//If you find an answer and want to return immediately, don't forget to flush before return!
+
+public class C {
+    static InputReader in;
+    static PrintWriter out;
+
+    public static void main(String[] args) {
+        //initReaderPrinter(true);
+        initReaderPrinter(false);
+        solve(in.nextInt());
+        //solve(1);        
+    }
+
+    static void solve(int testCnt) {
+        for (int testNumber = 0; testNumber < testCnt; testNumber++) {
+            int n = in.nextInt();
+            char[] a = in.next().toCharArray(), b = in.next().toCharArray();
+            int match0 = 0, match1 = 0, mismatch10 = 0, mismatch01 = 0;
+            for(int i = 0; i < n; i++) {
+                if(a[i] == b[i]) {
+                    if(a[i] == '0') match0++;
+                    else match1++;
+                }
+                else {
+                    if(a[i] == '0') mismatch01++;
+                    else mismatch10++;
+                }
+            }
+            if(mismatch01 + mismatch10 == 0) out.println(0);
+            else {
+                if(match1 - match0 == 1 && mismatch01 == mismatch10) {
+                    out.println(min(match0 + match1, mismatch01 + mismatch10));
+                }
+                else if(match1 - match0 == 1) {
+                    out.println(match0 + match1);
+                }
+                else if(mismatch01 == mismatch10) {
+                    out.println(mismatch01 + mismatch10);
+                }
+                else out.println(-1);
+            }
+        }
+        out.close();
+    }
+
+    static void initReaderPrinter(boolean test) {
+        if (test) {
+            try {
+                in = new InputReader(new FileInputStream(""src/input.in""));
+                out = new PrintWriter(new FileOutputStream(""src/output.out""));
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+        } else {
+            in = new InputReader(System.in);
+            out = new PrintWriter(System.out);
+        }
+    }
+
+    static class InputReader {
+        BufferedReader br;
+        StringTokenizer st;
+
+        InputReader(InputStream stream) {
+            try {
+                br = new BufferedReader(new InputStreamReader(stream), 32768);
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }
+
+        String next() {
+            while (st == null || !st.hasMoreTokens()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+
+        String nextLine() {
+            String str = """";
+            try {
+                str = br.readLine();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+        }
+
+        Integer[] nextIntArray(int n) {
+            Integer[] a = new Integer[n];
+            for (int i = 0; i < n; i++) a[i] = nextInt();
+            return a;
+        }
+
+        int[] nextIntArrayPrimitive(int n) {
+            int[] a = new int[n];
+            for (int i = 0; i < n; i++) a[i] = nextInt();
+            return a;
+        }
+
+        int[] nextIntArrayPrimitiveOneIndexed(int n) {
+            int[] a = new int[n + 1];
+            for (int i = 1; i <= n; i++) a[i] = nextInt();
+            return a;
+        }
+
+        Long[] nextLongArray(int n) {
+            Long[] a = new Long[n];
+            for (int i = 0; i < n; i++) a[i] = nextLong();
+            return a;
+        }
+
+        long[] nextLongArrayPrimitive(int n) {
+            long[] a = new long[n];
+            for (int i = 0; i < n; i++) a[i] = nextLong();
+            return a;
+        }
+
+        long[] nextLongArrayPrimitiveOneIndexed(int n) {
+            long[] a = new long[n + 1];
+            for (int i = 1; i <= n; i++) a[i] = nextLong();
+            return a;
+        }
+
+        String[] nextStringArray(int n) {
+            String[] g = new String[n];
+            for (int i = 0; i < n; i++) g[i] = next();
+            return g;
+        }
+
+        List<Integer>[] readGraphOneIndexed(int n, int m) {
+            List<Integer>[] adj = new List[n + 1];
+            for (int i = 0; i <= n; i++) {
+                adj[i] = new ArrayList<>();
+            }
+            for (int i = 0; i < m; i++) {
+                int u = nextInt();
+                int v = nextInt();
+                adj[u].add(v);
+                adj[v].add(u);
+            }
+            return adj;
+        }
+
+        List<Integer>[] readGraphZeroIndexed(int n, int m) {
+            List<Integer>[] adj = new List[n];
+            for (int i = 0; i < n; i++) {
+                adj[i] = new ArrayList<>();
+            }
+            for (int i = 0; i < m; i++) {
+                int u = nextInt() - 1;
+                int v = nextInt() - 1;
+                adj[u].add(v);
+                adj[v].add(u);
+            }
+            return adj;
+        }
+
+        /*
+            A more efficient way of building a graph using int[] instead of ArrayList to store each node's neighboring nodes.
+            1-indexed.
+         */
+        int[][] buildGraph(int nodeCnt, int edgeCnt) {
+            int[] end1 = new int[edgeCnt], end2 = new int[edgeCnt];
+            int[] edgeCntForEachNode = new int[nodeCnt + 1], idxForEachNode = new int[nodeCnt + 1];
+            for (int i = 0; i < edgeCnt; i++) {
+                int u = in.nextInt(), v = in.nextInt();
+                edgeCntForEachNode[u]++;
+                edgeCntForEachNode[v]++;
+                end1[i] = u;
+                end2[i] = v;
+            }
+            int[][] adj = new int[nodeCnt + 1][];
+            for (int i = 1; i <= nodeCnt; i++) {
+                adj[i] = new int[edgeCntForEachNode[i]];
+            }
+            for (int i = 0; i < edgeCnt; i++) {
+                adj[end1[i]][idxForEachNode[end1[i]]] = end2[i];
+                idxForEachNode[end1[i]]++;
+                adj[end2[i]][idxForEachNode[end2[i]]] = end1[i];
+                idxForEachNode[end2[i]]++;
+            }
+            return adj;
+        }
+    }
+}","import java.io.OutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.PrintWriter;
+import java.util.*;
+import java.io.IOException;
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.io.InputStream;
+
+public class Main {
+
+    public static void main(String[] args) {
+        InputStream inputStream = System.in;
+        OutputStream outputStream = System.out;
+        InputReader in = new InputReader(inputStream);
+        PrintWriter out = new PrintWriter(outputStream);
+        TaskA solver = new TaskA();
+        int t;
+        t = in.nextInt();
+        //t = 1;
+        while (t > 0) {
+            solver.call(in,out);
+            t--;
+        }
+        out.close();
+    }
+
+    static class TaskA {
+        public void call(InputReader in, PrintWriter out) {
+            int n, _00 = 0, _01 = 0, _11 = 0, _10 = 0;
+            n = in.nextInt();
+            char[] s = in.next().toCharArray();
+            char[] s1 = in.next().toCharArray();
+
+            for (int i = 0; i < n; i++) {
+                if(s[i]==s1[i]){
+                    if(s[i]=='0'){
+                        _00++;
+                    }
+                    else{
+                        _11++;
+                    }
+                }
+                else{
+                    if(s[i]=='0'){
+                        _01++;
+                    }
+                    else{
+                        _10++;
+                    }
+                }
+            }
+            int ans = Integer.MAX_VALUE;
+
+            if(_10 ==_01){
+                ans = 2*_01;
+            }
+            if(_11 == _00 + 1){
+                ans = Math.min(ans, 2*_00 + 1);
+            }
+
+            if(ans == Integer.MAX_VALUE){
+                out.println(-1);
+            }
+            else{
+                out.println(ans);
+            }
+        }
+    }
+
+    static int gcd(int a, int b)
+    {
+        if (a == 0)
+            return b;
+        return gcd(b % a, a);
+    }
+
+    static int lcm(int a, int b)
+    {
+        return (a / gcd(a, b)) * b;
+    }
+
+    static class answer implements Comparable<answer>{
+        int a, b;
+
+        public answer(int a, int b) {
+            this.a = a;
+            this.b = b;
+        }
+
+        @Override
+        public int compareTo(answer o) {
+            return o.a - this.a;
+        }
+    }
+
+    static class arrayListClass {
+        ArrayList<Integer> arrayList2 ;
+
+        public arrayListClass(ArrayList<Integer> arrayList) {
+            this.arrayList2 = arrayList;
+        }
+    }
+
+    static long gcd(long a, long b)
+    {
+        if (b == 0)
+            return a;
+        return gcd(b, a % b);
+    }
+
+    static void sort(long[] a) {
+        ArrayList<Long> l=new ArrayList<>();
+        for (long i:a) l.add(i);
+        Collections.sort(l);
+        for (int i=0; i<a.length; i++) a[i]=l.get(i);
+    }
+
+    static final Random random=new Random();
+
+    static void shuffleSort(int[] a) {
+        int n = a.length;
+        for (int i=0; i<n; i++) {
+            int oi=random.nextInt(n), temp=a[oi];
+            a[oi]=a[i]; a[i]=temp;
+        }
+        Arrays.sort(a);
+    }
+
+    static class InputReader {
+        public BufferedReader reader;
+        public StringTokenizer tokenizer;
+
+        public InputReader(InputStream stream) {
+            reader = new BufferedReader(new InputStreamReader(stream), 32768);
+            tokenizer = null;
+        }
+
+        public String next() {
+            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
+                try {
+                    tokenizer = new StringTokenizer(reader.readLine());
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+            }
+            return tokenizer.nextToken();
+        }
+
+        public int nextInt() {
+            return Integer.parseInt(next());
+        }
+        public long nextLong(){
+            return Long.parseLong(next());
+        }
+        public double nextDouble() {
+            return Double.parseDouble(next());
+        }
+
+    }
+}",0
+b56ebada,b95a75a7,"import java.io.OutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.PrintWriter;
+import java.util.*;
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+
+public class First {
+
+    public static void main(String[] args) {
+        InputStream inputStream = System.in;
+        OutputStream outputStream = System.out;
+        InputReader in = new InputReader(inputStream);
+        PrintWriter out = new PrintWriter(outputStream);
+        TaskA solver = new TaskA();
+        //int a = 1;
+        int t;
+        t = in.nextInt();
+        //t = 1;
+        while (t > 0) {
+            //out.print(""Case #""+(a++)+"": "");
+            solver.call(in, out);
+            t--;
+        }
+        out.close();
+
+    }
+
+    static class TaskA {
+        public void call(InputReader in, PrintWriter out) {
+            int n;
+            n = in.nextInt();
+
+            int[] arr = new int[n];
+            Integer[] lower = new Integer[n];
+            Integer[] higher = new Integer[n];
+
+            for (int i = 0; i < n; i++) {
+                arr[i] = in.nextInt();
+            }
+
+            TreeSet<Integer> set = new TreeSet<>();
+            for (int i = 0; i < n; i++) {
+                set.add(arr[i]);
+                lower[i] = set.lower(arr[i]);
+                higher[i] = set.higher(arr[i]);
+            }
+
+            for (int i = 1; i < n; i++) {
+                if(arr[i]>arr[i-1]){
+                    if(higher[i-1] != null && higher[i-1]<arr[i]){
+                        out.println(""NO"");
+                        return;
+                    }
+                }
+                else{
+                    if(lower[i-1] != null && lower[i-1]>arr[i]){
+                        out.println(""NO"");
+                        return;
+                    }
+                }
+            }
+            out.println(""YES"");
+
+
+        }
+    }
+
+    static int gcd(int a, int b)
+    {
+        if (a == 0)
+            return b;
+        return gcd(b % a, a);
+    }
+
+    static int lcm(int a, int b)
+    {
+        return (a / gcd(a, b)) * b;
+    }
+
+    static class answer implements Comparable<answer>{
+        int a;
+        int b;
+
+        public answer(int a, int b) {
+            this.a = a;
+            this.b = b;
+        }
+
+        @Override
+        public int compareTo(answer o) {
+            return o.a - this.a;
+        }
+    }
+
+    static class answer1 implements Comparable<answer1>{
+        int a, b, c;
+
+        public answer1(int a, int b, int c) {
+            this.a = a;
+            this.b = b;
+            this.c = c;
+
+        }
+
+        @Override
+        public int compareTo(answer1 o) {
+            return this.a - o.a;
+        }
+    }
+
+    static long gcd(long a, long b)
+    {
+        if (b == 0)
+            return a;
+        return gcd(b, a % b);
+    }
+
+    static void sort(long[] a) {
+        ArrayList<Long> l=new ArrayList<>();
+        for (long i:a) l.add(i);
+        Collections.sort(l);
+        for (int i=0; i<a.length; i++) a[i]=l.get(i);
+    }
+
+    static final Random random=new Random();
+
+    static void shuffleSort(int[] a) {
+        int n=a.length;
+        for (int i=0; i<n; i++) {
+            int oi=random.nextInt(n), temp=a[oi];
+            a[oi]=a[i]; a[i]=temp;
+        }
+        Arrays.sort(a);
+    }
+
+    static class InputReader {
+        public BufferedReader reader;
+        public StringTokenizer tokenizer;
+
+        public InputReader(InputStream stream) {
+            reader = new BufferedReader(new InputStreamReader(stream), 32768);
+            tokenizer = null;
+        }
+
+        public String next() {
+            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
+                try {
+                    tokenizer = new StringTokenizer(reader.readLine());
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+            }
+            return tokenizer.nextToken();
+        }
+
+        public int nextInt() {
+            return Integer.parseInt(next());
+        }
+        public long nextLong(){
+            return Long.parseLong(next());
+        }
+        public double nextDouble() {
+            return Double.parseDouble(next());
+        }
+
+    }
+}","import java.util.*;
+import java.io.*;
+
+
+public class Main{
+    public static class Node {
+        int val;
+        Node left;
+        Node right;
+        Node(int val)
+        {
+            this.val=val;
+        }
+    }
+    public static void main(String[] args) throws java.io.IOException {
+        Scanner sc=new Scanner(System.in);
+        int t=sc.nextInt();
+        while(t-->0)
+        {
+            int n=sc.nextInt();
+            int[] arr=new int[n];
+            for(int i=0;i<n;++i)
+            {
+                arr[i]=sc.nextInt();
+            }
+            Node head=new Node(arr[0]);
+            boolean cond=false;
+            for(int i=1;i<n;i++)
+            {
+                int cur=head.val;
+                //System.out.println(cur);
+                if(arr[i]>cur)
+                {
+                    if(head.right==null)
+                    {
+                        Node next=new Node(arr[i]);
+                        head.right=next;
+                        next.left=head;
+                        head=head.right;
+                    }
+                    else if(head.right.val<arr[i])
+                    {
+                        cond=true;
+                        break;
+                    }
+                    else if(head.right.val==arr[i])
+                    {
+                        head=head.right;
+                    }
+                    else
+                    {
+                        Node next=new Node(arr[i]);
+                        next.right=head.right;
+                        head.right.left=next;
+                        head.right=next;
+                        next.left=head;
+                        head=next;
+                    }
+                }
+                else if(arr[i]<cur)
+                {
+                    if(head.left==null)
+                    {
+                        Node next=new Node(arr[i]);
+                        head.left=next;
+                        next.right=head;
+                        head=head.left;
+                    }
+                    else if(head.left.val>arr[i])
+                    {
+                        cond=true;
+                        break;
+                    }
+                    else if(head.left.val==arr[i])
+                    {
+                        head=head.left;
+                    }
+                    else
+                    {
+                        Node next=new Node(arr[i]);
+                        next.left=head.left;
+                        head.left.right=next;
+                        head.left=next;
+                        next.right=head;
+                        head=next;
+                    }
+                }
+            }
+            if(cond)
+                System.out.println(""NO"");
+            else
+                System.out.println(""YES"");
+        }
+    }
+}
+// 1 0 1 1 0 0 1",0
+8782922d,f5f97f19,"
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.StringTokenizer;
+
+public class Interesting_Story {
+    static class RealScanner {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st = new StringTokenizer("""");
+
+        String next() {
+            while (!st.hasMoreTokens())
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        int[] readArray(int n) {
+            int[] a = new int[n];
+            for (int i = 0; i < n; i++) a[i] = nextInt();
+            return a;
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+    }
+
+    public static void main(String[] args) {
+        RealScanner sc = new RealScanner();
+        int t = sc.nextInt();
+        while (t-- > 0) {
+            int n = sc.nextInt();
+            List<String> l = new ArrayList<>();
+            for (int i = 0; i < n; i++) {
+                l.add(sc.next());
+            }
+            int res = 0;
+            for (int i = 0; i <= 5; i++) {
+                List<Integer> myL = new ArrayList<>();
+                for (String s : l) {
+                    int count1 = 0, count2 = 0;
+                    for (char ch : s.toCharArray()) {
+                        if (ch == (char) (i + 97)) {
+                            count1++;
+                        } else {
+                            count2++;
+                        }
+                    }
+                    myL.add(count2 - count1);
+                }
+                //System.out.println(myL);
+                Collections.sort(myL);
+                int sum = 0;
+                for (int m = 0; m < myL.size(); m++) {
+                    sum += myL.get(m);
+                    if (sum < 0) {
+                        res = Math.max(res, m + 1);
+                    }
+                }
+            }
+            System.out.println(res);
+        }
+    }
+}
+","import java.util.Arrays;
+import java.util.Comparator;
+import java.util.Scanner;
+
+public class One {
+    static class Word {
+        int a = 0;
+        int b = 0;
+        int c = 0;
+        int d = 0;
+        int e = 0;
+        int total = 0;
+        String s = """";
+
+        @Override
+        public String toString() {
+            return s;
+        }
+    }
+
+    static class CompA implements Comparator<Word> {
+        public int compare(Word a, Word b) {
+            return (2 * b.a - b.total) - (2 * a.a - a.total);
+        }
+    }
+
+    static class CompB implements Comparator<Word> {
+        public int compare(Word a, Word b) {
+            return (2 * b.b - b.total) - (2 * a.b - a.total);
+        }
+    }
+
+    static class CompC implements Comparator<Word> {
+        public int compare(Word a, Word b) {
+            return (2 * b.c - b.total) - (2 * a.c - a.total);
+        }
+    }
+
+    static class CompD implements Comparator<Word> {
+        public int compare(Word a, Word b) {
+            return (2 * b.d - b.total) - (2 * a.d - a.total);
+        }
+    }
+
+    static class CompE implements Comparator<Word> {
+        public int compare(Word a, Word b) {
+            return (2 * b.e - b.total) - (2 * a.e - a.total);
+        }
+    }
+
+    public static void main(String[] args) {
+        Scanner scan = new Scanner(System.in);
+        int t = scan.nextInt();
+
+        while (t != 0) {
+            t--;
+            int n = scan.nextInt();
+            Word[] words = new Word[n];
+
+            for (int i = 0 ; i < n ; i++) {
+                String s = scan.next();
+                Word word = new Word();
+                word.s = s;
+
+                for (int j = 0 ; j < s.length() ; j++) {
+                    if (s.charAt(j) == 'a') {
+                        word.a++;
+                    } else if (s.charAt(j) == 'b') {
+                        word.b++;
+                    } else if (s.charAt(j) == 'c') {
+                        word.c++;
+                    } else if (s.charAt(j) == 'd') {
+                        word.d++;
+                    } else if (s.charAt(j) == 'e') {
+                        word.e++;
+                    }
+
+                    word.total++;
+                }
+
+                words[i] = word;
+            }
+
+            int answer = 0;
+            int main = 0;
+            int other = 0;
+            int count = 0;
+            Arrays.sort(words, new CompA());
+
+            for (int i = 0 ; i < n ; i++) {
+                main += words[i].a;
+                other += words[i].total - words[i].a;
+
+                if (main > other) {
+                    count++;
+                } else {
+                    break;
+                }
+            }
+
+            answer = Math.max(answer, count);
+            main = 0;
+            other = 0;
+            count = 0;
+            Arrays.sort(words, new CompB());
+
+            for (int i = 0 ; i < n ; i++) {
+                main += words[i].b;
+                other += words[i].total - words[i].b;
+
+                if (main > other) {
+                    count++;
+                } else {
+                    break;
+                }
+            }
+
+            answer = Math.max(answer, count);
+            main = 0;
+            other = 0;
+            count = 0;
+            Arrays.sort(words, new CompC());
+
+            for (int i = 0 ; i < n ; i++) {
+                main += words[i].c;
+                other += words[i].total - words[i].c;
+
+                if (main > other) {
+                    count++;
+                } else {
+                    break;
+                }
+            }
+
+            answer = Math.max(answer, count);
+            main = 0;
+            other = 0;
+            count = 0;
+            Arrays.sort(words, new CompD());
+
+            for (int i = 0 ; i < n ; i++) {
+                main += words[i].d;
+                other += words[i].total - words[i].d;
+
+                if (main > other) {
+                    count++;
+                } else {
+                    break;
+                }
+            }
+
+            answer = Math.max(answer, count);
+            main = 0;
+            other = 0;
+            count = 0;
+            Arrays.sort(words, new CompE());
+
+            for (int i = 0 ; i < n ; i++) {
+                main += words[i].e;
+                other += words[i].total - words[i].e;
+
+                if (main > other) {
+                    count++;
+                } else {
+                    break;
+                }
+            }
+
+            answer = Math.max(answer, count);
+            System.out.println(answer);
+        }
+
+        scan.close();
+    }
+}
+",0
+20166f71,a98d56f9,"import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.PrintStream;
+import java.io.PrintWriter;
+import java.io.File;
+import java.io.FileInputStream;
+import java.util.*;
+
+public class Main {
+
+    // static final File ip = new File(""input.txt"");
+    // static final File op = new File(""output.txt"");
+    // static {
+    // try {
+    // System.setOut(new PrintStream(op));
+    // System.setIn(new FileInputStream(ip));
+    // } catch (Exception e) {
+    // }
+    // }
+    private static final PrintWriter out = new PrintWriter(System.out);
+
+    public static void main(String[] args) {
+        FastReader sc = new FastReader();
+        int test = 1;
+        test = sc.nextInt();
+        while (test-- > 0) {
+            int n = sc.nextInt();
+            long k = sc.nextLong();
+            long[] a = new long[n];
+            for (int i = 0; i < n; i++) {
+                a[i] = sc.nextLong();
+            }
+            sortL(a);
+            long[] pref = new long[n + 1];
+            for (int i = 0; i < n; i++) {
+                pref[i + 1] = pref[i] + a[i];
+            }
+            long ans = (long) 9e18;
+            for (int t = 0; t <= n - 1; t++) {
+                long sum = pref[n - t] + a[0] * t;
+                long cur = t;
+                if (sum > k) {
+                    long diff = sum - k;
+                    cur += (diff + t) / (t + 1);
+                }
+                ans = Math.min(ans, cur);
+            }
+            out.println(ans);
+        }
+        out.close();
+    }
+
+    static long power(long x, long y, long p) {
+        long res = 1;
+        x = x % p;
+        if (x == 0)
+            return 0;
+        while (y > 0) {
+            if ((y & 1) != 0)
+                res = (res * x) % p;
+            y = y >> 1;
+            x = (x * x) % p;
+        }
+        return res;
+    }
+
+    public static int countSetBits(long number) {
+        int count = 0;
+        while (number > 0) {
+            ++count;
+            number &= number - 1;
+        }
+        return count;
+    }
+
+    static int lower_bound(long target, long[] a, int pos) {
+        if (pos >= a.length)
+            return -1;
+        int low = pos, high = a.length - 1;
+        while (low < high) {
+            int mid = low + (high - low) / 2;
+            if (a[mid] < target)
+                low = mid + 1;
+            else
+                high = mid;
+        }
+        return a[low] >= target ? low : -1;
+    }
+
+    private static <T> void swap(long[] a, int i, int j) {
+        long tmp = a[i];
+        a[i] = a[j];
+        a[j] = tmp;
+    }
+
+    static class pair {
+        long a;
+        int b;
+
+        pair(long x, int y) {
+            this.a = x;
+            this.b = y;
+        }
+    }
+
+    static class first implements Comparator<pair> {
+
+        public int compare(pair p1, pair p2) {
+            if (p1.a > p2.a)
+                return 1;
+            else if (p1.a < p2.a)
+                return -1;
+            return 0;
+        }
+    }
+
+    static class second implements Comparator<pair> {
+
+        public int compare(pair p1, pair p2) {
+            if (p1.b > p2.b)
+                return 1;
+            else if (p1.b < p2.b)
+                return -1;
+            return 0;
+        }
+    }
+
+    private static long getSum(int[] array) {
+        long sum = 0;
+        for (int value : array) {
+            sum += value;
+        }
+        return sum;
+    }
+
+    private static boolean isPrime(Long x) {
+        if (x < 2)
+            return false;
+        for (long d = 2; d * d <= x; ++d) {
+            if (x % d == 0)
+                return false;
+        }
+        return true;
+    }
+
+    static long[] reverse(long a[]) {
+        int n = a.length;
+        int i;
+        long t;
+        for (i = 0; i < n / 2; i++) {
+            t = a[i];
+            a[i] = a[n - i - 1];
+            a[n - i - 1] = t;
+        }
+        return a;
+    }
+
+    private static boolean isPrimeInt(int x) {
+        if (x < 2)
+            return false;
+        for (int d = 2; d * d <= x; ++d) {
+            if (x % d == 0)
+                return false;
+        }
+        return true;
+    }
+
+    public static String reverse(String input) {
+        StringBuilder str = new StringBuilder("""");
+
+        for (int i = input.length() - 1; i >= 0; i--) {
+            str.append(input.charAt(i));
+        }
+
+        return str.toString();
+    }
+
+    private static int[] getPrimes(int n) {
+        boolean[] used = new boolean[n + 1];
+        used[0] = used[1] = true;
+        // int size = 0;
+        for (int i = 2; i <= n; ++i) {
+            if (!used[i]) {
+                // ++size;
+                for (int j = 2 * i; j <= n; j += i) {
+                    used[j] = true;
+                }
+            }
+        }
+        int[] primes = new int[n + 1];
+        for (int i = 0; i <= n; ++i) {
+            if (!used[i]) {
+                primes[i] = 1;
+            }
+        }
+        return primes;
+    }
+
+    private static long lcm(long a, long b) {
+        return a / gcd(a, b) * b;
+    }
+
+    private static long gcd(long a, long b) {
+        return (a == 0 ? b : gcd(b % a, a));
+    }
+
+    static void sortI(int[] arr) {
+        int n = arr.length;
+        Random rnd = new Random();
+        for (int i = 0; i < n; ++i) {
+            int tmp = arr[i];
+            int randomPos = i + rnd.nextInt(n - i);
+            arr[i] = arr[randomPos];
+            arr[randomPos] = tmp;
+        }
+        Arrays.sort(arr);
+    }
+
+    static void shuffleList(ArrayList<Long> arr) {
+        int n = arr.size();
+        Random rnd = new Random();
+        for (int i = 0; i < n; ++i) {
+            long tmp = arr.get(i);
+            int randomPos = i + rnd.nextInt(n - i);
+            arr.set(i, arr.get(randomPos));
+            arr.set(randomPos, tmp);
+        }
+    }
+
+    static void factorize(long n) {
+        int count = 0;
+        while (!(n % 2 > 0)) {
+            n >>= 1;
+
+            count++;
+        }
+        if (count > 0) {
+            // System.out.println(""2"" + "" "" + count);
+        }
+        long i = 0;
+        for (i = 3; i <= (long) Math.sqrt(n); i += 2) {
+            count = 0;
+            while (n % i == 0) {
+                count++;
+                n = n / i;
+            }
+            if (count > 0) {
+                // System.out.println(i + "" "" + count);
+            }
+        }
+
+        if (n > 2) {
+            // System.out.println(i + "" "" + count);
+        }
+    }
+
+    static void sortL(long[] arr) {
+        int n = arr.length;
+        Random rnd = new Random();
+        for (int i = 0; i < n; ++i) {
+            long tmp = arr[i];
+            int randomPos = i + rnd.nextInt(n - i);
+            arr[i] = arr[randomPos];
+            arr[randomPos] = tmp;
+        }
+        Arrays.sort(arr);
+    }
+
+    ////////////////////////////////// DSU START ///////////////////////////
+
+    static class DSU {
+        int[] parent, rank, total_Elements;
+
+        DSU(int n) {
+            parent = new int[n + 1];
+            rank = new int[n + 1];
+            total_Elements = new int[n + 1];
+            for (int i = 0; i <= n; i++) {
+                parent[i] = i;
+                rank[i] = 1;
+                total_Elements[i] = 1;
+            }
+        }
+
+        int find(int u) {
+            if (parent[u] == u)
+                return u;
+            return parent[u] = find(parent[u]);
+        }
+
+        void unionByRank(int u, int v) {
+            int pu = find(u);
+            int pv = find(v);
+
+            if (pu != pv) {
+                if (rank[pu] > rank[pv]) {
+                    parent[pv] = pu;
+                    total_Elements[pu] += total_Elements[pv];
+                } else if (rank[pu] < rank[pv]) {
+                    parent[pu] = pv;
+                    total_Elements[pv] += total_Elements[pu];
+                } else {
+                    parent[pu] = pv;
+                    total_Elements[pv] += total_Elements[pu];
+                    rank[pv]++;
+                }
+            }
+        }
+
+        boolean unionBySize(int u, int v) {
+            u = find(u);
+            v = find(v);
+            if (u != v) {
+                parent[u] = v;
+                total_Elements[v] += total_Elements[u];
+                total_Elements[u] = 0;
+                return true;
+            }
+            return false;
+        }
+    }
+
+    ////////////////////////////////// DSU END /////////////////////////////
+
+    static class FastReader {
+        BufferedReader br;
+        StringTokenizer st;
+
+        public FastReader() {
+            br = new BufferedReader(new InputStreamReader(System.in));
+        }
+
+        public boolean hasNext() {
+            return false;
+        }
+
+        String next() {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+
+        String nextLine() {
+            String str = """";
+            try {
+                str = br.readLine();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+        }
+    }
+}","import java.util.*;
+import java.io.*;
+import java.math.*;
+ 
+public class Test{
+ 
+ //Global declarations
+ final static Random random = new Random();
+ final static FastReader in = new FastReader();
+ final static PrintWriter out = new PrintWriter(System.out);
+  
+  
+  
+ public static long helperFunction(long x, long y) {
+	  //Long range is -10^18 to 10^18 and is 64 bit (8 bytes)
+	  //Integer range is ~~ -2 * 10^9(-2^31) to 2 * 10^9(2^31 - 1) and is 32 bit (4 bytes)  
+	
+	  if(x>=0)
+	  return x/y;
+	  
+
+	  //for ceiling negative numbers (integers)
+	  return (x-y+1)/y;	
+ }
+	  	
+ public static void ruffleLong(long a[]) {
+	  
+		//shuffle, then sort
+		
+		int i,j,n=a.length;
+		long temp; 
+		
+		for (i=0; i<n; i++) {
+			j = random.nextInt(n);
+			
+			temp = a[i];
+			
+			a[i] = a[j]; 
+			
+			a[j] = temp;
+		}
+		
+		Arrays.sort(a);	
+ }
+ 
+ 
+ public static void ruffleInt(int a[]) {
+	  
+		//shuffle, then sort
+		
+		int i,j,n=a.length,temp; 
+		
+		for (i=0; i<n; i++) {
+			j = random.nextInt(n);
+			
+			temp = a[i];
+			
+			a[i] = a[j]; 
+			
+			a[j] = temp;
+		}
+		
+		Arrays.sort(a);	
+ }
+ 
+  
+ public static void main(String ... args) throws IOException {
+	// << --> multiply
+	// >> --> divide
+	
+	//variable_name <<= 1 --> (variable)multiply by 2
+	//variable_name >>= 1 --> (variable)divide by 2
+	
+	//2<<3 --> (multiply)2 * 2^3 --> 16;
+	//6>>1 --> (divide)6 / 2^1 --> 3;
+  
+	/**
+	  
+	int n = in.nextInt(),a,b;
+	in.nextLine();
+	while(n-->0){
+	 a = in.nextInt();
+	 b = in.nextInt();
+	 out.println(a+b);
+	 if(n>0)
+	 in.nextLine();
+	}	
+	out.close();
+	
+	
+	int tt = in.nextInt();
+	while(tt-->0){
+		out.println(helperFunction());
+	}
+	
+	//out.println(helperFunction());
+	
+	**/
+	
+	
+	//it returns the remaining length (+ve) so bigger so swap
+	//System.out.println(""h"".compareTo(""ha""));
+	
+	/*
+	Problem 13 - Large sum
+	  
+	String s = ""37107287533902102798797998220837590246510135740250463769376774900097126481248969700780504170182605387432498619952474105947423330951305812372661730962991942213363574161572522430563301811072406154908250230675882075393461711719803104210475137780632466768926167069662363382013637841838368417873436172675728112879812849979408065481931592621691275889832738442742289174325203219235894228767964876702721893184745144573600130643909116721685684458871160315327670386486105843025439939619828917593665686757934951621764571418565606295021572231965867550793241933316490635246274190492910143244581382266334794475817892575867718337217661963751590579239728245598838407582035653253593990084026335689488301894586282278288018119938482628201427819413994056758715117009439035398664372827112653829987240784473053190104293586865155060062958648615320752733719591914205172558297169388870771546649911559348760353292171497005693854370070576826684624621495650076471787294438377604532826541087568284431911906346940378552177792951453612327252500029607107508256381565671088525835072145876576172410976447339110607218265236877223636045174237069058518606604482076212098132878607339694128114266041808683061932846081119106155694051268969251934325451728388641918047049293215058642563049483624672216484350762017279180399446930047329563406911573244438690812579451408905770622942919710792820955037687525678773091862540744969844508330393682126183363848253301546861961243487676812975343759465158038628759287849020152168555482871720121925776695478182833757993103614740356856449095527097864797581167263201004368978425535399209318374414978068609844840309812907779179908821879532736447567559084803087086987551392711854517078544161852424320693150332599594068957565367821070749269665376763262354472106979395067965269474259770973916669376304263398708541052684708299085211399427365734116182760315001271653786073615010808570091499395125570281987460043753582903531743471732693212357815498262974255273730794953759765105305946966067683156574377167401875275889028025717332296191766687138199318110487701902712526768027607800301367868099252546340106163286652636270218540497705585629946580636237993140746255962240744869082311749777923654662572469233228109171419143028819710328859780666976089293863828502533340334413065578016127815921815005561868836468420090470230530811728164304876237919698424872550366387845831148769693215490281042402013833512446218144177347063783299490636259666498587618221225225512486764533677201869716985443124195724099139590089523100588229554825530026352078153229679624948164195386821877476085327132285723110424803456124867697064507995236377742425354112916842768655389262050249103265729672370191327572567528565324825826546309220705859652229798860272258331913126375147341994889534765745501184957014548792889848568277260777137214037988797153829820378303147352772158034814451349137322665138134829543829199918180278916522431027392251122869539409579530664052326325380441000596549391598795936352974615218550237130764225512118369380358038858490341698116222072977186158236678424689157993532961922624679571944012690438771072750481023908955235974572318970677254791506150550495392297953090112996751986188088225875314529584099251203829009407770775672113067397083047244838165338735023408456470580773088295917476714036319800818712901187549131054712658197623331044818386269515456334926366572897563400500428462801835170705278318394258821455212272512503275512160354698120058176216521282765275169129689778932238195734329339946437501907836945765883352399886755061649651847751807381688378610915273579297013376217784275219262340194239963916804498399317331273132924185707147349566916674687634660915035914677504995186714302352196288948901024233251169136196266227326746080059154747183079839286853520694694454072476841822524674417161514036427982273348055556214818971426179103425986472045168939894221798260880768528778364618279934631376775430780936333301898264209010848802521674670883215120185883543223812876952786713296124747824645386369930090493103636197638780396218407357239979422340623539380833965132740801111666627891981488087797941876876144230030984490851411606618262936828367647447792391803351109890697907148578694408955299065364044742557608365997664579509666024396409905389607120198219976047599490197230297649139826800329731560371200413779037855660850892521673093931987275027546890690370753941304265231501194809377245048795150954100921645863754710598436791786391670211874924319957006419179697775990283006991536871371193661495281130587638027841075444973307840789923115535562561142322423255033685442488917353448899115014406480203690680639606723221932041495354150312888033953605329934036800697771065056663195481234880673210146739058568557934581403627822703280826165707739483275922328459417065250945123252306082291880205877731971983945018088807242966198081119777158542502016545090413245809786882778948721859617721078384350691861554356628840622574736922845095162084960398013400172393067166682355524525280460972253503534226472524250874054075591789781264330331690"";
+	StringBuilder st = new StringBuilder("""");
+	int i,ct=0,p=0;
+	BigInteger res = BigInteger.valueOf(0);
+	String a[] = new String[100];
+	for(i=0;i<5000;++i){
+		
+		st.append(s.charAt(i));
+		++ct;
+		
+		if(ct == 50){
+			a[p] = st.toString();
+			ct=0;
+			++p;
+			st.setLength(0);
+		}
+		
+	}
+	//out.println(Arrays.toString(a));
+	
+	for(String val: a){
+		res = res.add(new BigInteger(val));
+	}
+	
+	out.println(res.toString());*/
+	
+	//out.println(helperFunction());
+	
+	
+	//String airports[] = {""AAA"", ""AAAA""};
+	
+	//int i,n=airports.length;
+	
+	
+	
+	
+	/*
+	Maximum number of unique values in the array after performing given operations
+ 
+	int a[] = {1,2,4,4};
+	int i,n = a.length,res=0;
+	
+	int mp[] = new int[n+2];
+	
+	Arrays.sort(a);
+	
+	for(i=0;i<n;++i){
+		
+		if(mp[a[i]] == 0)
+		++mp[a[i]];
+		
+		else if(mp[a[i]+1] == 0)
+			++mp[a[i]+1];
+			
+		else if(mp[a[i]-1] == 0)
+			++mp[a[i]-1];
+	}
+	
+	for(int val: mp){
+		if(val > 0)
+			++res;
+	}
+	
+	out.println(res);*/
+	
+	
+	int tt = in.nextInt();
+	
+	while(tt-->0){
+		
+		int n = in.nextInt();
+		long k = in.nextLong();
+		
+		
+		int i,y;
+		long a[] = new long[n];
+		long pref[] = new long[n];
+		
+		long x,res=Long.MAX_VALUE;
+		
+		for(i=0;i<n;++i)
+			a[i] = in.nextLong();
+			
+		
+		ruffleLong(a);
+		
+		pref[0] = a[0];
+			
+		for(i=1;i<n;++i)
+		pref[i] = pref[i-1]+a[i];
+			
+		//out.println(Arrays.toString(pref));
+		
+		//we have to minimize (x+y)
+		//x --> decrease/minimize the smallest value (a[0]) by x
+		//y --> no.of times settting largest values to the smallest value in (descending order)
+		
+		for(y=0;y<n;++y){
+			
+			// x cannot be negative
+			x = Math.max(0,a[0] - (helperFunction((k-pref[n-1-y]+pref[0]),y+1)));
+			
+			res = Math.min(res,y+x);
+			
+			//out.println(y+"" ""+x);
+				
+		}
+		
+		out.println(res);
+	}
+		
+	
+	out.close();
+}
+ 
+ static class FastReader {
+		BufferedReader br;
+		StringTokenizer st;
+ 
+		public FastReader()
+		{
+			br = new BufferedReader(
+				new InputStreamReader(System.in));
+		}
+ 
+		String next()
+		{
+			while (st == null || !st.hasMoreElements()) {
+				try {
+					st = new StringTokenizer(br.readLine());
+				}
+				catch (IOException e) {
+					e.printStackTrace();
+				}
+			}
+			return st.nextToken();
+		}
+ 
+		int nextInt() { return Integer.parseInt(next()); }
+ 
+		long nextLong() { return Long.parseLong(next()); }
+ 
+		double nextDouble()
+		{
+			return Double.parseDouble(next());
+		}
+ 
+		String nextLine()
+		{
+			String str = """";
+   
+			try {
+				str = br.readLine();
+			}
+			catch (IOException e) {
+				e.printStackTrace();
+			}
+			return str;
+		}
+   }
+ }
+ 
+ 
+",0
+7bcacc97,e431de28,"/* package codechef; // don't place package name! */
+
+import java.util.*;
+import java.lang.*;
+import java.io.*;
+
+/* Name of the class has to be ""Main"" only if the class is public. */
+public class Main
+{
+	public static void main (String[] args) throws java.lang.Exception
+	{
+	//  StringBuilder sb=new StringBuilder();
+	
+//	BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
+	Scanner sc=new Scanner(System.in);
+//	int t=Integer.parseInt(bf.readLine());
+    int t=sc.nextInt();
+	while(t-->0)
+	{
+	 //  ArrayList<Integer> abcd=new ArrayList<>();
+	 //  HashMap<Integer,Integer> amd=new HashMap<>();
+	 
+	 
+	 
+	   //   int n=Integer.parseInt(bf.readLine());
+	   //   int a[]=new int[n];
+	   //   String s[]=bf.readLine().split("" "");
+	   //   for(int i=0;i<n;i++)
+	   //   {
+	   //       a[i]=Integer.parseInt(s[i]);
+	   //   }
+	   
+	      int n=sc.nextInt();
+	      long a[]=new long[n];
+	      for(int i=0;i<n;i++)
+	      {
+	          a[i]=sc.nextLong();
+	      }
+	      
+	      long ans=Long.MAX_VALUE;
+	      int count1=1;
+	      int count2=1;
+	      boolean san=true;
+	      long sum1=a[0];
+	      long sum2=a[1];
+	      long min1=a[0];
+	      long min2=a[1];
+	      ans=((n*1L*sum1)+(n*1L*sum2));
+	     // System.out.println(""san ""+ans);
+	      for(int i=2;i<n;i++)
+	      {
+	          if(san)
+	          {
+	              count1++;
+	              san=false;
+	              sum1+=a[i];
+	              min1=Math.min(min1,a[i]);
+	              long z1=sum1+(n-count1)*min1;
+	              long z2= sum2+(n-count2)*min2;
+	              ans=Math.min(ans,z1+z2);
+	              
+	          }
+	          else
+	          {
+	              count2++;
+	              san=true;
+	              sum2+=a[i];
+	              min2=Math.min(min2,a[i]);
+	              long z1=sum1+(n-count1)*min1;
+	              long z2= sum2+(n-count2)*min2;
+	              ans=Math.min(ans,z1+z2);
+	              
+	              
+	          }
+	       //   System.out.println(i+"" ""+ans);
+	      }
+	      System.out.println(ans);
+	      
+	      
+	      
+	      
+	    
+	}
+	
+	}
+	
+	static class Data
+	{
+	    int first;
+	    int sec;
+	    Data(int z1,int z2)
+	    {
+	        first=z1;
+	        sec=z2;
+	    }
+	}
+	static class MINasc implements Comparator<Data>
+	{
+	    public int compare (Data z1,Data z2)
+	    {
+	        if(z1.first>z2.first)
+	        return 1;
+	        else if(z1.first<z2.first)
+	        return -1;
+	        else 
+	        return 0;
+	    }
+	}
+	static class MINdsc implements Comparator<Data>
+	{
+	    public int compare (Data z1,Data z2)
+	    {
+	        if(z1.first>z2.first)
+	        return -1;
+	        else if(z1.first<z2.first)
+	        return 1;
+	        else 
+	        return 0;
+	    }
+	}
+	
+	
+}","import java.io.*;
+import java.lang.*;
+import java.util.*;
+public class MinGridPath {
+
+	public static void main(String[] args) {
+		// TODO Auto-generated method stub
+		Scanner s=new Scanner(System.in);
+		int t=s.nextInt();
+		while(t-->0){
+			
+			int n = s.nextInt();
+			long[] aa =new long[n];
+			for(int i=0;i<n;i++)
+				aa[i]=s.nextLong();
+ 
+			long minEven = aa[0];
+			long minOdd = aa[1];
+			long sum = aa[0]+aa[1];
+			long best = n*minEven + n*minOdd;
+			int numOdd = 1;
+			int numEven = 1;
+			for(int i=2; i<n; ++i) {
+				if(i%2 == 0) {
+					minEven = Math.min(aa[i], minEven);
+					numEven++;
+				}else {
+					minOdd = Math.min(aa[i], minOdd);
+					numOdd++;
+				}
+				sum += aa[i];
+				long score = sum;
+				score += minEven*(n-numEven);
+				score += minOdd*(n-numOdd);				
+				best = Math.min(best, score);
+			}
+			System.out.println(best);
+			
+		}
+	}
+
+}
+",0
+161b4a40,49e94e7e,"import java.util.*;
+import java.io.*;
+
+public class Main{
+    static final Random random=new Random();
+    static long mod=1000000007L;
+    static HashMap<String,Integer>map=new HashMap<>();
+
+    static class FastReader{
+        BufferedReader br;
+        StringTokenizer st;
+        public FastReader(){
+            br=new BufferedReader(new InputStreamReader(System.in));
+        }
+        String next(){
+            while(st==null || !st.hasMoreTokens()){
+                try {
+                    st=new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+        int nextInt(){
+            return Integer.parseInt(next());
+        }
+        long nextLong(){
+            return Long.parseLong(next());
+        }
+        double nextDouble(){
+            return Double.parseDouble(next());
+        }
+        String nextLine(){
+            String str="""";
+            try {
+                str=br.readLine().trim();
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+            return str;
+        }
+        int[] readIntArray(int n){
+            int[] res=new int[n];
+            for(int i=0;i<n;i++)res[i]=nextInt();
+            return res;
+        }
+    }
+    static class FastWriter {
+		private final BufferedWriter bw;
+
+		public FastWriter() {
+			this.bw = new BufferedWriter(new OutputStreamWriter(System.out));
+		}
+
+		public void print(Object object) throws IOException {
+			bw.append("""" + object);
+		}
+
+		public void println(Object object) throws IOException {
+			print(object);
+			bw.append(""\n"");
+		}
+
+		public void close() throws IOException {
+			bw.close();
+		}
+	}
+    public static void main(String[] args) {
+        try {
+            FastReader in=new FastReader();
+            FastWriter out = new FastWriter();
+            int testCases=in.nextInt();
+            //int testCases=1;
+            while(testCases-- > 0){
+                solve(in);
+            }
+            out.close();
+        } catch (Exception e) {
+            return;
+        }
+    }
+    public static void solve( FastReader in){
+        int n=in.nextInt();
+        String s=in.next();
+        String t=in.next();
+        //int k=in.nextInt();
+        //long y=in.nextInt();
+        //long n=in.nextLong();
+        //int k=in.nextInt();
+        //long k=in.nextLong();
+        StringBuilder res=new StringBuilder();
+        char[] s1=s.toCharArray();
+        char[] t1=t.toCharArray();
+        int ans=n+2;
+        int[] cnt={0,0};
+        for(int i=0;i<n;i++){
+            if(s1[i]=='0' && t1[i]=='1'){
+                cnt[0]++;
+            }
+            if(s1[i]=='1' && t1[i]=='0'){
+                cnt[1]++;
+            }
+        }
+        if(cnt[0]==cnt[1])ans=Math.min(ans,cnt[0]+cnt[1]);
+        cnt[0]=cnt[1]=0;
+        for(int i=0;i<n;i++){
+            if(s1[i]=='0' && t1[i]=='0'){
+                cnt[0]++;
+            }
+            if(s1[i]=='1' && t1[i]=='1'){
+                cnt[1]++;
+            }
+        }
+        if(cnt[1]==cnt[0]+1){
+            ans=Math.min(ans,cnt[0]+cnt[1]);
+        }
+        if(ans>n){
+            res.append(""-1"");
+        }
+        else{
+            res.append(""""+ans);
+        }
+        //int ans=x.size()+y.size();
+        //res.append(""""+""Yes"");
+        //res.append(""""+"""");
+        System.out.println(res.toString());
+    }
+    
+    static int gcd(int a,int b){
+        if(b==0){
+            return a;
+        }
+        return gcd(b,a%b);
+    }
+
+    static void sort(int[] arr)
+    {
+        
+        ArrayList<Integer> ls = new ArrayList<Integer>();
+        for(int x: arr)
+            ls.add(x);
+        Collections.sort(ls);
+        for(int i=0; i < arr.length; i++)
+            arr[i] = ls.get(i);
+    }
+    static void reversesort(int[] arr)
+    {
+        
+        ArrayList<Integer> ls = new ArrayList<Integer>();
+        for(int x: arr)
+            ls.add(x);
+        Collections.sort(ls);
+        Collections.reverse(ls);
+        for(int i=0; i < arr.length; i++)
+            arr[i] = ls.get(i);
+    }
+
+    static int lcm(int a, int b)
+    {
+        return (a / gcd(a, b)) * b;
+    }
+
+    static void debug(String x){
+        System.out.println(x);
+    }
+    static < E > void print(E res)
+    {
+        System.out.println(res);
+    }
+    static String rString(String s){
+        StringBuilder sb=new StringBuilder();
+        sb.append(s);
+        return sb.reverse().toString();
+    }
+}","import java.io.BufferedReader;
+import java.io.IOException;
+import java.lang.*;
+import java.io.InputStreamReader;
+import static java.lang.Math.*;
+import static java.lang.System.out;
+import java.util.*;
+import java.io.File;
+import java.io.PrintStream;
+import java.io.PrintWriter;
+import java.math.BigInteger;
+public class Main {
+ 
+	
+	/* 10^(7) = 1s.
+	 * ceilVal = (a+b-1) / b */
+	
+	static final int mod = 1000000007;
+	static final long temp = 998244353;
+	static final long MOD = 1000000007;
+	static final long M = (long)1e9+7;
+ 
+	
+	static class Pair implements Comparable<Pair> 
+	{
+		int first, second;
+		
+		public Pair(int first, int second) 
+		{
+			this.first = first;
+			this.second = second;
+		}
+		
+		public int compareTo(Pair ob) 
+		{
+			return (int)(first - ob.first);
+		}
+	}
+	
+	
+	static class Tuple implements Comparable<Tuple>
+	{
+		int first, second,third;
+		public Tuple(int first, int second, int third)
+		{
+			this.first = first;
+			this.second = second;
+			this.third = third;
+		}
+		public int compareTo(Tuple o)
+		{
+			return (int)(o.third - this.third);
+		}
+	}
+	
+	public static class DSU
+	{
+		int[] parent;
+		int[] rank; //Size of the trees is used as the rank
+		public DSU(int n)
+		{
+			parent = new int[n];
+			rank = new int[n];
+			Arrays.fill(parent, -1);
+			Arrays.fill(rank, 1);
+		}
+		
+		public int find(int i) //finding through path compression
+		{
+			return parent[i] < 0 ? i : (parent[i] = find(parent[i]));
+		}
+		
+		public boolean union(int a, int b) //Union Find by Rank 
+		{
+			a = find(a);
+			b = find(b);
+			
+			if(a == b) return false; //if they are already connected we exit by returning false.
+			
+			// if a's parent is less than b's parent
+			if(rank[a] < rank[b])
+			{
+				//then move a under b
+				parent[a] = b;
+			}
+			//else if rank of j's parent is less than i's parent
+			else if(rank[a] > rank[b])
+			{
+				//then move b under a
+				parent[b] = a;
+			}
+			//if both have the same rank.
+			else
+			{
+				//move a under b (it doesnt matter if its the other way around.
+				parent[b] = a;
+				rank[a] = 1 + rank[a];
+			}
+			return true;
+		}	
+	}
+
+	static class Reader 
+	{
+		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st=new StringTokenizer("""");
+		String next() {
+			while (!st.hasMoreTokens())
+				try {
+					st=new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			return st.nextToken();
+		}
+		
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+		
+		int[] readArray(int n) throws IOException {
+			int[] a=new int[n];
+			for (int i=0; i<n; i++) a[i]=nextInt();
+			return a;
+		}
+		
+		long[] longReadArray(int n) throws IOException {
+			long[] a=new long[n];
+			for (int i=0; i<n; i++) a[i]=nextLong();
+			return a;
+		}
+		
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+		double nextDouble() {
+			return Double.parseDouble(next());
+		}
+	}
+	
+	public static int gcd(int a, int b)
+	{
+		if(b == 0)
+		 return a;
+		
+		else
+		return gcd(b,a%b);
+	} 
+ 
+		public static long lcm(long a, long b)
+	    {
+	        return (a / LongGCD(a, b)) * b;
+	    }
+	
+	public static long LongGCD(long a, long b)
+	{
+		if(b == 0)
+			 return a;
+			
+			else
+			return LongGCD(b,a%b);
+	}
+	
+		public static long LongLCM(long a, long b)
+	    {
+	        return (a / LongGCD(a, b)) * b;
+	    }
+	
+		//Count the number of coprime's upto N
+		public static long phi(long n)  //euler totient/phi function
+	    { 
+	       long ans = n;
+//	       for(long i = 2;i*i<=n;i++)
+//	       {
+//	    	   if(n%i == 0)
+//	    	   {
+//	    		   while(n%i == 0) n/=i;
+//	    		   ans -= (ans/i);
+//	    	   }
+//	       }
+//	       
+//	       if(n > 1)
+//	       {
+//	    	   ans -= (ans/n);
+//	       }
+	       
+	       for(long i = 2;i<=n;i++)
+	       {
+	    	   if(isPrime(i))
+	    	   {
+	    		   ans -= (ans/i);
+	    	   }
+	       }
+	       
+	       return ans;
+	       
+	    }	
+	
+	public static long fastPow(long x, long n) 
+	{
+		if(n == 0)
+			return 1;
+		else if(n%2 == 0)
+			return fastPow(x*x,n/2);
+		else
+			return x*fastPow(x*x,(n-1)/2);
+	}
+	
+	   public static long modPow(long x, long y, long p)
+	    {
+	        long res = 1;
+	        x = x % p;
+	 
+	        while (y > 0) {
+	            if (y % 2 == 1)
+	                res = (res * x) % p;
+	 
+	            y = y >> 1; 
+	            x = (x * x) % p;
+	        }
+	        return res;
+	    }
+	   
+	   static long modInverse(long n, long p)
+	    {
+	        return modPow(n, p - 2, p);
+	    }
+	 
+	    // Returns nCr % p using Fermat's little theorem.
+	    
+	    public static long nCrModP(long n, long r,long p)
+	    {
+	    	if (n<r) 
+	              return 0;
+	          
+	        if (r == 0)
+	            return 1;
+	 
+	        long[] fac = new long[(int)(n) + 1];
+	        fac[0] = 1;
+	 
+	        for (int i = 1; i <= n; i++)
+	            fac[i] = fac[i - 1] * i % p;
+	 
+	        return (fac[(int)(n)] * modInverse(fac[(int)(r)], p)
+	                % p * modInverse(fac[(int)(n - r)], p)
+	                % p)
+	            % p;
+	    }
+	    
+	    public static long fact(long n) 
+	    {
+	    	  long[] fac = new long[(int)(n) + 1];
+		        fac[0] = 1;
+		 
+		        for (long i = 1; i <= n; i++)
+		            fac[(int)(i)] = fac[(int)(i - 1)] * i;
+		        
+		        return fac[(int)(n)];
+		}
+	    
+	    public static long nCr(long n, long k) 
+	    {
+			long ans = 1;
+			for(long i = 0;i<k;i++)
+			{
+				ans *= (n-i);
+				ans /= (i+1);
+			}
+			return ans;
+		}
+ 
+		//Modular Operations for Addition and Multiplication. 
+		   public static long perfomMod(long x)
+		   {
+		        return ((x%M + M)%M);
+		    }
+		   public static long addMod(long a, long b)
+		   {
+		        return perfomMod(perfomMod(a)+perfomMod(b));
+		    }
+		  
+		   public static long subMod(long a, long b)
+		   {
+		        return perfomMod(perfomMod(a)-perfomMod(b));
+		   }
+		   
+		   public static long mulMod(long  a, long b)
+		   {
+		        return perfomMod(perfomMod(a)*perfomMod(b));
+		   }
+		   
+		   public static boolean isPrime(long n) 
+			{
+				if(n == 1)
+				{
+					return false;
+				}
+				
+				//check only for sqrt of the number as the divisors 
+				//keep repeating so only half of them are required. So,sqrt.
+				for(int i = 2;i*i<=n;i++)
+				{
+					if(n%i == 0)
+					{
+						return false;
+					}
+				}
+				return true;
+			}
+			
+			public static List<Integer> SieveList(int n)
+			{
+				boolean prime[] = new boolean[(int)(n+1)];
+				Arrays.fill(prime, true);
+				
+				List<Integer> l = new ArrayList<>();
+				for (int p = 2; p*p<=n; p++) 
+				{ 
+					if (prime[p] == true) 
+					{ 	
+					    for(int i = p*p; i<=n; i += p) 
+						{
+						    prime[i] = false; 
+						}	
+					} 
+				} 
+		 
+				for (int p = 2; p<=n; p++) 
+				{
+				    if (prime[p] == true)
+				    {
+				       l.add(p); 
+				    }
+				}
+				
+				return l;
+			}
+			
+			public static int countDivisors(int x)
+			{
+				int c = 0;
+				for(int i = 1;i*i<=x;i++)
+				{
+					if(x%i == 0)
+					{
+						if(x/i != i)
+						{
+							c+=2;
+						}
+						else 
+						{
+							c++;
+						}
+					}
+				}
+				return c;
+			}
+			
+			public static long log2(long n)
+		    {
+				 long ans = (long)(log(n)/log(2));
+				 return ans;
+			}
+			   
+			public static boolean isPow2(long n)
+			{
+				 return (n  != 0 && ((n & (n-1))) == 0);
+			}	
+		   
+		   public static boolean isSq(int x)  
+		   {
+			    long s = (long)Math.round(Math.sqrt(x));
+			    return s*s==x;
+		   }
+		
+			   /*
+			    * 
+			    * >=         <=
+			   0 1 2 3 4 5 6 7  
+			   5 5 5 6 6 6 7 7
+			   lower_bound for 6 at index 3 (>=)
+			   upper_bound for 6 at index 6(To get six reduce by one) (<=)
+			   */
+
+		   public static int LowerBound(int a[], int x) 
+		   {
+			      int l=-1,r=a.length;
+				  while(l+1<r) 
+				  {
+				    int m=(l+r)>>>1;
+				    if(a[m]>=x) r=m;
+				    else l=m;
+				  }
+				  return r;
+			}
+		   
+			public static int UpperBound(long a[], long x) 
+			{
+				int l=-1, r=a.length;
+			    while(l+1<r) 
+			    {
+			       int m=(l+r)>>>1;
+			       if(a[m]<=x) l=m;
+			       else r=m;
+			    }
+			    return l+1;
+			}
+			
+			public static void Sort(long[] a) 
+			{
+				List<Long> l = new ArrayList<>();
+				for (long i : a) l.add(i);
+				Collections.sort(l);
+//				Collections.reverse(l);  //Use to Sort decreasingly 
+				for (int i=0; i<a.length; i++) a[i]=l.get(i);
+			}
+			
+			public static void ssort(char[] a)
+			{
+				List<Character> l = new ArrayList<>();
+				for (char i : a) l.add(i);
+				Collections.sort(l);
+				for (int i=0; i<a.length; i++) a[i]=l.get(i);
+			}
+	
+	
+	public static void main(String[] args) throws Exception 
+	{
+		Reader sc = new Reader();
+		PrintWriter fout = new PrintWriter(System.out); 
+		
+		int tt = sc.nextInt();
+		while(tt-- > 0)
+		{
+	       int n = sc.nextInt();
+	       char[] a = sc.next().toCharArray(), b = sc.next().toCharArray();
+	       
+	       int c00 = 0, c01 = 0, c10 = 0, c11 = 0;
+	       for(int i = 0;i<n;i++)
+	       {
+	    	   if(a[i] == '0' && b[i] == '0')
+	    	   {
+	    		   c00++;
+	    	   }
+	    	   else if(a[i] == '0' && b[i] == '1')
+	    	   {
+	    		   c01++;
+	    	   }
+	    	   else if(a[i] == '1' && b[i] == '0')
+	    	   {
+	    		   c10++;
+	    	   }
+	    	   else if(a[i] == '1' && b[i] == '1')
+	    	   {
+	    		   c11++;
+	    	   }
+	       }
+	       
+	       int ans = mod;
+	       if(c01 == c10) ans = min(ans, c01 + c10);
+	       if(c11 == c00 + 1) ans = min(ans, c11 + c00);
+	       
+	       fout.println((ans == mod) ? -1 : ans);
+		}
+		
+		fout.close();
+	}
+}",0
+2bbf754b,d9199dfd,"import java.util.*;
+
+/** 
+__                  __
+( _)                ( _)
+/ / \\              / /\_\_
+/ /   \\            / / | \ \
+/ /     \\          / /  |\ \ \
+/  /   ,  \ ,       / /   /|  \ \
+/  /    |\_ /|      / /   / \   \_\
+/  /  |\/ _ '_| \   / /   /   \    \\
+|  /   |/  0 \0\    / |    |    \    \\
+|    |\|      \_\_ /  /    |     \    \\
+|  | |/    \.\ o\o)  /      \     |    \\
+\    |     /\\`v-v  /        |    |     \\
+| \/    /_| \\_|  /         |    | \    \\
+| |    /__/_ `-` /   _____  |    |  \    \\
+\|    [__]  \_/  |_________  \   |   \    ()
+/    [___] (    \         \  |\ |   |   //
+|    [___]                  |\| \|   /  |/
+/|    [____]                  \  |/\ / / ||
+(  \   [____ /     ) _\      \  \    \| | ||
+\  \  [_____|    / /     __/    \   / / //
+|   \ [_____/   / /        \    |   \/ //
+|   /  '----|   /=\____   _/    |   / //
+__ /  /        |  /   ___/  _/\    \  | ||
+(/-(/-\)       /   \  (/\/\)/  |    /  | /
+(/\/\)           /   /   //
+_________/   /    /
+\____________/    (
+
+
+
+*/
+
+public class Main {
+	public static void main(String[] args) {
+		Scanner sc=new Scanner(System.in);
+		int  t=sc.nextInt();
+		while(t-- >0) {
+			int n=sc.nextInt();
+			int[] arr=new int[n];
+			for(int i=0;i<n;i++) {
+				arr[i]=sc.nextInt();
+			}
+			String str=sc.next();
+			
+			ArrayList<Pair> plist=new ArrayList<>();
+			for(int i=0;i<n;i++) {
+				char ch=str.charAt(i);
+				plist.add(new Pair(arr[i],ch));
+			}
+			
+			//B-reduce
+			//R-increse
+			Collections.sort(plist);
+			
+			int counter=1;
+			boolean flag=false;
+			for(int i=0;i<plist.size();i++) {
+				int val=plist.get(i).number;
+				int clr=plist.get(i).color;
+				
+				if(clr=='B') {
+					if(val<counter) {
+						flag=true;
+						break;
+					}
+				}
+				else {
+					if(val>counter) {
+						flag=true;
+						break;
+					}
+					
+				}
+				counter++;
+			}
+			System.out.println(flag?""NO"":""YES"");
+			
+			
+		}
+	}
+	public static class Pair implements Comparable<Pair>{
+		int number;
+		char color;
+		
+		Pair(int number,char color){
+			this.number=number;
+			this.color=color;
+		}
+		
+		@Override
+		public int compareTo(Pair o) {
+			if(o.color==this.color) {
+				return this.number-o.number;
+			}
+			else {
+				return this.color-o.color;
+			}
+		}
+		
+		public String toString() {
+			return number+""-""+color+""."";
+		}
+	}
+}
+","import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Scanner;
+
+public class Simple{  
+    public static void main(String args[]){  
+        //System.out.println(""Hello Java"");
+        Scanner s = new Scanner(System.in);
+        int t = s.nextInt();
+        while (t>0){
+            
+            int n = s.nextInt();
+            int arr[] = new int[n];
+
+            for(int i=0;i<n;i++){
+                arr[i] = s.nextInt();
+            }
+            String str = s.next();
+
+            //Arrays.sort(arr);
+            ArrayList<Integer> blue = new ArrayList<>();
+            ArrayList<Integer> red = new ArrayList<>();
+            for(int i=0;i<n;i++){
+                if(str.charAt(i)=='R'){
+                    red.add(arr[i]);
+                }
+                else{
+                    blue.add(arr[i]);
+                }
+            }
+            Collections.sort(red);
+            Collections.sort(blue);
+            
+            int start =1;
+
+            boolean bool =true;
+            for(int i=0;i<blue.size();i++){
+                if(blue.get(i)<start){
+                    bool = false;
+                    break;
+                }
+
+                start++;
+            }
+            if(!bool){
+                System.out.println(""NO"");
+            }
+            else{
+                for(int i=0;i<red.size();i++){
+                    if(red.get(i)>start){
+                        bool = false;
+                        break;
+                    }
+                    start++;
+                }
+                if(bool){
+                    System.out.println(""YES"");
+                }
+                else{
+                    System.out.println(""NO"");
+                }
+            }
+            
+            
+
+
+            t--;
+        }
+        s.close();  
+    }
+    
+}  
+",0
+4eac0eea,f4d6d28d,"import java.util.*;
+import java.io.*;
+import java.lang.*;
+import static java.lang.Math.*;
+// import java.math.*;
+
+public class cp{
+    static BufferedReader br;
+    static StringTokenizer st;
+
+    public static void main(String[] args)throws IOException{
+
+        br = new BufferedReader(new InputStreamReader(System.in));
+        List<Integer> answer = new ArrayList<Integer>();
+
+        for(int t=Integer.parseInt(br.readLine()); t>0; t--){
+            st = readLine();
+            int n = tokenInt();
+
+            String[] words = new String[n];
+            int i=0;
+            while(n-- >0){
+                words[i] = br.readLine();
+                i++;
+            }
+
+            answer.add(new Solver().solve(words));
+        }
+
+        for (int ans : answer ) System.out.println(ans);
+
+    }
+
+    static StringTokenizer readLine() throws IOException { return new StringTokenizer(br.readLine()); }
+    static int tokenInt() { return Integer.parseInt(st.nextToken()); }
+    static long tokenLong(){ return Long.parseLong(st.nextToken()); }
+    static double tokenDouble(){ return Double.parseDouble(st.nextToken()); }
+    static char[] tokenChar(){ return st.nextToken().toCharArray(); }
+    static int[] readIntArray(int n) {
+        int[] a=new int[n];
+        for (int i=0; i<n; i++) a[i]=tokenInt();
+        return a;
+    }
+
+    static int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b);}
+    static int lcm(int a, int b) { return (a * b) / gcd(a,b);}
+
+    static void printArr(int[] arr){
+        for (int i=0; i<arr.length; i++) System.out.print(arr[i] + "" "");
+        System.out.println();
+        return;
+    }
+    static void printArr(char[] arr){
+        for (int i=0; i<arr.length; i++) System.out.print(arr[i] + "" "");
+        System.out.println();
+        return;
+    }
+
+}
+
+
+class Solver{
+    public int solve(String[] words) throws IOException{
+
+        char[] alphabets = {'a', 'b', 'c', 'd', 'e'};
+        // char[] alphabets = {'a'};
+
+        int[][] arr = new int[5][words.length];
+
+        int i=0;
+        for(String s : words) {
+            char[] wordArr = s.toCharArray();
+            int j=0;
+            for (char alpha : alphabets) {
+
+                int counter = 0;
+                for(char letter : wordArr){
+                    if(alpha == letter){
+                        counter++;
+                    }
+                }
+                arr[j][i] = 2*counter - s.length();
+                // System.out.println( alpha + ""  "" + (2*counter - s.length()));
+                j++;
+            }
+            // System.out.println(""********"");
+
+            i++;
+
+        }
+
+        int[] ans = new int[5];
+
+        int m=0;
+        for (int[] ar : arr) {
+            // Arrays.sort(ar, Collections.reverseOrder());
+            Arrays.sort(ar);
+            int val=0;
+            int counter = 0;
+            for(i=ar.length-1; i>=0; i--){
+                val += ar[i];
+                if(val>0){
+                    counter++;
+                } else break;
+            }
+            ans[m] = counter;
+            m++;
+            // cp.printArr(ar);
+        }
+
+        // cp.printArr(ans);
+
+        return Arrays.stream(ans).max().getAsInt();
+    }
+}
+
+/*
+bac
+aaada
+e
+*/
+
+","import java.util.*;
+import java.io.*;
+import java.lang.*;
+import static java.lang.Math.*;
+
+public class cp{
+    static BufferedReader br;
+    static StringTokenizer st;
+
+    public static void main(String[] args)throws IOException{
+
+        br = new BufferedReader(new InputStreamReader(System.in));
+        List<Integer> answer = new ArrayList<Integer>();
+
+        for(int t=Integer.parseInt(br.readLine()); t>0; t--){
+            st = readLine();
+            int n = tokenInt();
+
+            String[] words = new String[n];
+            int i=0;
+            while(n-- >0){
+                words[i] = br.readLine();
+                i++;
+            }
+
+            answer.add(new Solver().solve(words));
+        }
+
+        for (int ans : answer ) System.out.println(ans);
+
+    }
+
+    static StringTokenizer readLine() throws IOException { return new StringTokenizer(br.readLine()); }
+    static int tokenInt() { return Integer.parseInt(st.nextToken()); }
+    static long tokenLong(){ return Long.parseLong(st.nextToken()); }
+    static double tokenDouble(){ return Double.parseDouble(st.nextToken()); }
+    static char[] tokenChar(){ return st.nextToken().toCharArray(); }
+    static int[] readIntArray(int n) {
+        int[] a=new int[n];
+        for (int i=0; i<n; i++) a[i]=tokenInt();
+        return a;
+    }
+
+    static int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b);}
+    static int lcm(int a, int b) { return (a * b) / gcd(a,b);}
+
+    static void printArr(int[] arr){
+        for (int i=0; i<arr.length; i++) System.out.print(arr[i] + "" "");
+        System.out.println();
+        return;
+    }
+    static void printArr(char[] arr){
+        for (int i=0; i<arr.length; i++) System.out.print(arr[i] + "" "");
+        System.out.println();
+        return;
+    }
+
+}
+
+
+class Solver{
+    public int solve(String[] words) throws IOException{
+
+        char[] alphabets = {'a', 'b', 'c', 'd', 'e'};
+
+        int[][] arr = new int[5][words.length];
+
+        int i=0;
+        for(String s : words) {
+            char[] wordArr = s.toCharArray();
+            int j=0;
+            for (char alpha : alphabets) {
+                int counter = 0;
+                for(char letter : wordArr){
+                    if(alpha == letter)
+                        counter++;
+                }
+                arr[j][i] = 2*counter - s.length();
+                j++;
+            }
+            i++;
+        }
+
+        int[] ans = new int[5];
+
+        int m=0;
+        for (int[] ar : arr) {
+            Arrays.sort(ar);
+            int val=0;
+            int counter=0;
+            for(i=ar.length-1; i>=0; i--){
+                val += ar[i];
+                if(val>0) counter++;
+                else break;
+            }
+            ans[m] = counter;
+            m++;
+        }
+
+        return Arrays.stream(ans).max().getAsInt();
+    }
+}
+
+/*
+bac
+aaada
+e
+*/
+",1
+680ba922,90dc2b20,"import java.util.*;
+import java.io.*;
+
+public class Solution
+{
+    static class Reader {
+        final private int BUFFER_SIZE = 1 << 16;
+        private DataInputStream din;
+        private byte[] buffer;
+        private int bufferPointer, bytesRead;
+ 
+        public Reader()
+        {
+            din = new DataInputStream(System.in);
+            buffer = new byte[BUFFER_SIZE];
+            bufferPointer = bytesRead = 0;
+        }
+ 
+        public Reader(String file_name) throws IOException
+        {
+            din = new DataInputStream(
+                new FileInputStream(file_name));
+            buffer = new byte[BUFFER_SIZE];
+            bufferPointer = bytesRead = 0;
+        }
+ 
+        public String readLine() throws IOException
+        {
+            byte[] buf = new byte[64]; // line length
+            int cnt = 0, c;
+            while ((c = read()) != -1) {
+                if (c == '\n') {
+                    if (cnt != 0) {
+                        break;
+                    }
+                    else {
+                        continue;
+                    }
+                }
+                buf[cnt++] = (byte)c;
+            }
+            return new String(buf, 0, cnt);
+        }
+ 
+        public int nextInt() throws IOException
+        {
+            int ret = 0;
+            byte c = read();
+            while (c <= ' ') {
+                c = read();
+            }
+            boolean neg = (c == '-');
+            if (neg)
+                c = read();
+            do {
+                ret = ret * 10 + c - '0';
+            } while ((c = read()) >= '0' && c <= '9');
+ 
+            if (neg)
+                return -ret;
+            return ret;
+        }
+ 
+        public long nextLong() throws IOException
+        {
+            long ret = 0;
+            byte c = read();
+            while (c <= ' ')
+                c = read();
+            boolean neg = (c == '-');
+            if (neg)
+                c = read();
+            do {
+                ret = ret * 10 + c - '0';
+            } while ((c = read()) >= '0' && c <= '9');
+            if (neg)
+                return -ret;
+            return ret;
+        }
+ 
+        public double nextDouble() throws IOException
+        {
+            double ret = 0, div = 1;
+            byte c = read();
+            while (c <= ' ')
+                c = read();
+            boolean neg = (c == '-');
+            if (neg)
+                c = read();
+ 
+            do {
+                ret = ret * 10 + c - '0';
+            } while ((c = read()) >= '0' && c <= '9');
+ 
+            if (c == '.') {
+                while ((c = read()) >= '0' && c <= '9') {
+                    ret += (c - '0') / (div *= 10);
+                }
+            }
+ 
+            if (neg)
+                return -ret;
+            return ret;
+        }
+ 
+        private void fillBuffer() throws IOException
+        {
+            bytesRead = din.read(buffer, bufferPointer = 0,
+                                 BUFFER_SIZE);
+            if (bytesRead == -1)
+                buffer[0] = -1;
+        }
+ 
+        private byte read() throws IOException
+        {
+            if (bufferPointer == bytesRead)
+                fillBuffer();
+            return buffer[bufferPointer++];
+        }
+ 
+        public void close() throws IOException
+        {
+            if (din == null)
+                return;
+            din.close();
+        }
+    }
+    
+   
+  static int parent(int a , int p[])
+  {
+      if(a == p[a])
+      return a;
+      
+      return p[a] = parent(p[a],p);
+  }
+  
+  static void union(int a , int b , int p[] , int size[])
+  {
+      a = parent(a,p);
+      b = parent(b,p);
+      
+      if(a == b)
+      return;
+      
+      if(size[a] < size[b])
+      {
+          int temp = a;
+          a = b;
+          b = temp;
+      }
+      
+      p[b] = a;
+      size[a] += size[b];
+  }
+  
+  
+  
+  
+ static long getSum(int index , long BITree[])
+    {
+        long sum = 0; // Iniialize result
+      
+        // index in BITree[] is 1 more than
+        // the index in arr[]
+       // index = index + 1;
+      
+        // Traverse ancestors of BITree[index]
+        while(index>0)
+        {
+            // Add current element of BITree 
+            // to sum
+            sum += BITree[index];
+      
+            // Move index to parent node in 
+            // getSum View
+            index -= index & (-index);
+        }
+        return sum;
+    }
+  
+    // Updates a node in Binary Index Tree (BITree)
+    // at given index in BITree. The given value 
+    // 'val' is added to BITree[i] and all of 
+    // its ancestors in tree.
+    public static void updateBIT(int n, int index, 
+                                        long val , long BITree[])
+    {
+        // index in BITree[] is 1 more than 
+        // the index in arr[]
+      //  index = index + 1;
+      
+        // Traverse all ancestors and add 'val'
+        while(index <= n)
+        {
+        // Add 'val' to current node of BIT Tree
+        BITree[index] += val;
+      
+        // Update index to that of parent 
+        // in update View
+        index += index & (-index);
+        }
+    }
+    
+    
+   static int gcd(int a, int b)
+{
+    if (a == 0)
+        return b;
+    return gcd(b % a, a);
+}
+
+static int dp[][];
+
+
+static int f(int pos , int take , int arr[])
+{
+    if(pos == -1)
+    {
+        if(take == 0)
+    return 0;
+    
+    return -10000000;
+    
+    }
+    
+    
+    if(dp[pos][take] != -1)
+    return dp[pos][take];
+    
+    
+    if(pos+1-take == arr[pos])
+    dp[pos][take] = Math.max(dp[pos][take],1 + f(pos-1,take,arr));
+    
+    
+    dp[pos][take] = Math.max(dp[pos][take],f(pos-1,take,arr));
+    
+    
+    if(take > 0)
+    dp[pos][take] = Math.max(dp[pos][take],f(pos-1,take-1,arr));
+    
+    return dp[pos][take];
+}
+    public static void main(String []args) throws IOException
+    {
+        Scanner sc = new Scanner(System.in);
+        int t = sc.nextInt();
+        while(t-- > 0)
+        {
+            int n = sc.nextInt();
+            sc.nextLine();
+            String a = sc.nextLine();
+            String b = sc.nextLine();
+            int same = 0 , zo = 0 , oz = 0 , oo = 0 , zz = 0;
+            for(int i = 0 ; i < n ; i++)
+            {
+                if(a.charAt(i) == '0' && b.charAt(i) == '1')
+                oz++;
+                
+                else if(a.charAt(i) == '1' && b.charAt(i) == '0')
+                zo++;
+                
+                else if(a.charAt(i) == '1' && b.charAt(i) == '1')
+                oo++;
+                
+                else
+                zz++;
+            }
+            
+            if(oz == zo || (zz == oo-1))
+            {
+                int mx = Integer.MAX_VALUE;
+                if(oz == zo)
+                mx = Math.min(mx,2*oz);
+                
+                if(oo-1 == zz)
+                mx = Math.min(mx,zz+oo);
+                
+                System.out.println(mx);
+            }
+            
+            else
+            {
+                System.out.println(-1);
+            }
+        }
+    }
+}","import java.util.*;
+import java.io.*;
+public class C1615{
+	static FastScanner fs = null;
+	public static void main(String[] args) {
+		fs = new FastScanner();
+		PrintWriter out = new PrintWriter(System.out);
+		int t = fs.nextInt();
+		while (t-->0) {
+			int n = fs.nextInt();
+			String a = fs.next();
+			String b = fs.next();
+			char ch1[] = a.toCharArray();
+			char ch2[] = b.toCharArray();
+			int c00 = 0;
+			int c01 = 0;
+			int c10 = 0;
+			int c11 = 0;
+			for(int i=0;i<n;i++){
+				if(ch1[i]=='0'){
+					if(ch2[i]=='0'){
+						c00+=1;
+					}
+					else{
+						c01+=1;
+					}
+				}
+				else{
+					if(ch2[i]=='0'){
+						c10+=1;
+					}
+					else{
+						c11+=1;
+					}
+				}
+			}
+			int ans = -1;
+			if((c11-c00)==1 || c10==c01){
+				int s1 = (int)1e7; 
+				int s2 = (int)1e7;
+				if((c11-c00)==1){
+					s1 = c11+c00;
+				}
+				if(c10==c01)
+				s2 = c10+c01;
+				ans = Math.min(s1,s2); 
+			}
+			out.println(ans);
+		}
+		out.close();
+	}
+	static void sort(int[] a) {
+		ArrayList<Integer> l=new ArrayList<>();
+		for (int i:a) l.add(i);
+		Collections.sort(l);
+		for (int i=0; i<a.length; i++) a[i]=l.get(i);
+	}
+	static class FastScanner {
+		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st=new StringTokenizer("""");
+		String next() {
+			while (!st.hasMoreTokens())
+				try {
+					st=new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			return st.nextToken();
+		}
+		
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+		int[] readArray(int n) {
+			int[] a=new int[n];
+			for (int i=0; i<n; i++) a[i]=nextInt();
+			return a;
+		}
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+	}
+}",0
+1eda0725,80881cae,"import java.io.*;
+import java.util.*;
+public class Main {
+    public static void main(String args[])
+    {
+        FastReader input=new FastReader();
+        PrintWriter out=new PrintWriter(System.out);
+        int T=input.nextInt();
+        while(T-->0)
+        {
+            int n=input.nextInt();
+            int k[]=new int[n];
+            int h[]=new int[n];
+            for(int i=0;i<n;i++)
+            {
+                k[i]=input.nextInt();
+            }
+            for(int i=0;i<n;i++)
+            {
+                h[i]=input.nextInt();
+            }
+            ArrayList<int []> list=new ArrayList<>();
+            for(int i=0;i<n;i++)
+            {
+                int p=k[i]-h[i]+1;
+                if(list.size()==0) list.add(new int[]{p,k[i]});
+                else
+                {
+                    while(list.size()>0)
+                    {
+                        int j=list.size()-1;
+                        int a[]=list.get(j);
+                        int l=a[0],r=a[1];
+                        int l1=p,r1=k[i];
+                        if(l1>r)
+                        {
+                            list.add(new int[]{l1,r1});
+                            break;
+                        }
+                        else if(l1>=l && l1<=r)
+                        {
+                            list.remove(j);
+                            list.add(new int[]{l,r1});
+                            break;
+                        }
+                        else
+                        {
+                            list.remove(j);
+                        }
+                    }
+                    if(list.size()==0) list.add(new int[]{p,k[i]});
+                }
+            }
+            long sum=0;
+            for(int i=0;i<list.size();i++)
+            {
+                long d=list.get(i)[1]-list.get(i)[0]+1;
+                long val=d*(d+1)/2;
+                sum+=val;
+            }
+            out.println(sum);
+        }
+        out.close();
+    }
+    static class FastReader
+    {
+        BufferedReader br;
+        StringTokenizer st;
+        public FastReader()
+        {
+            br = new BufferedReader(new InputStreamReader(System.in));
+        }
+        String next()
+        {
+            while (st == null || !st.hasMoreElements())
+            {
+                try
+                {
+                    st = new StringTokenizer(br.readLine());
+                }
+                catch (IOException e)
+                {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+        int nextInt()
+        {
+            return Integer.parseInt(next());
+        }
+        long nextLong()
+        {
+            return Long.parseLong(next());
+        }
+        double nextDouble()
+        {
+            return Double.parseDouble(next());
+        }
+        String nextLine()
+        {
+            String str="""";
+            try
+            {
+                str=br.readLine();
+            }
+            catch (IOException e)
+            {
+                e.printStackTrace();
+            }
+            return str;
+        }
+    }
+}","//package Codeforces;
+import java.io.*;
+import java.util.*;
+
+
+public class CP
+{
+	static Scanner sc=new Scanner(System.in);
+	public static void main(String[] args) throws IOException, CloneNotSupportedException
+	{
+		int t=sc.nextInt();
+		while(t-->0)
+		{
+			int n=sc.nextInt();
+			int k[]=new int[n];
+			int h[]=new int[n];
+			for(int i=0;i<n;i++)
+				k[i]=sc.nextInt();
+			for(int i=0;i<n;i++)
+				h[i]=sc.nextInt();
+			ArrayList<Pair> interval=new ArrayList<Pair>();
+			ArrayList<Pair> act=new ArrayList<Pair>();
+			for(int i=0;i<n;i++)
+				interval.add(new Pair(k[i]-h[i]+1,k[i]));
+			Collections.sort(interval);
+//			out.println(interval);
+			act.add(interval.get(0).clone());
+			for(int i=1;i<n;i++)
+			{
+				Pair p=act.get(act.size()-1);
+				if(p.y<interval.get(i).x)
+					act.add(interval.get(i).clone());
+				else
+					p.y=Math.max(p.y, interval.get(i).y);
+			}
+//			out.println(act);
+			long mana=0;
+			for(Pair p: act)
+			{
+				long x=p.y-p.x+1;
+				mana+=(x*(x+1))/2;
+			}
+			System.out.println(mana);		
+ 		}
+	}
+	static class Pair implements Cloneable, Comparable<Pair>
+	{
+		int x,y;
+		Pair(int a,int b)
+		{
+			this.x=a;
+			this.y=b;
+		}
+//		@Override
+//		public boolean equals(Object obj) 
+//		{
+//			if(obj instanceof  Pair)
+//			{
+//				Pair p=(Pair)obj;
+//				return p.x==this.x && p.y==this.y;
+//			}
+//			return false;
+//		}
+//		@Override
+//		public int hashCode() 
+//		{
+//			return Math.abs(x)+500*Math.abs(y);
+//		}
+//		@Override
+//		public String toString() 
+//		{
+//			return ""(""+x+"" ""+y+"")"";
+//		}
+		@Override
+		protected Pair clone() throws CloneNotSupportedException {
+			return new Pair(this.x,this.y);
+		}
+		@Override
+		public int compareTo(Pair a) 
+		{
+			long t=(this.x-a.x);
+			if(t!=0)
+				return t>0?1:-1;
+			else
+				return (int)(this.y-a.y);
+		}
+//		public void swap()
+//		{
+//			this.y=this.y+this.x;
+//			this.x=this.y-this.x;
+//			this.y=this.y-this.x;			
+//		}
+	}
+}",0
+46bde295,8a858867,"
+
+import java.io.*;
+import java.util.Arrays;
+
+public class C {
+    static StreamTokenizer in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
+    static PrintWriter out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
+    private static int nextInt() {
+        try {
+            in.nextToken();
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        return (int) in.nval;
+    }
+    private static long nextLong() {
+        try {
+            in.nextToken();
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        return (long) in.nval;
+    }
+    private static String next(){
+        try {
+            in.nextToken();
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        return in.sval;
+    }
+
+    public static void main(String[] args) {
+        int t = nextInt();
+        for (int c = 0; c < t; c++) {
+            int n = nextInt();
+            String[] info = new String[n];
+            for (int i = 0; i < n; i++) {
+                info[i] = next();
+            }
+            int ans = 0;
+            for (int i = 0; i < 5; i++) {
+                char cur = (char) (i+'a');
+                int[] map = new int[n];
+                for (int j = 0; j < n; j++) {
+                    for (int k = 0; k < info[j].length(); k++) {
+                        if(info[j].charAt(k)==cur)map[j]++;
+                        else map[j]--;
+                    }
+                }
+                Arrays.sort(map);
+                int sum = 0;
+                for(int j = n-1; j >= 0; j--) {
+                    sum += map[j];
+                    if(sum<=0){
+                        break;
+                    }
+                    ans = Math.max(ans,n-j);
+                }
+            }
+            System.out.println(ans);
+        }
+    }
+}
+","import java.io.*;
+import java.util.*;
+ 
+ 
+public class Mainnn{
+    // static final File ip = new File(""input.txt"");
+    // static final File op = new File(""output.txt"");
+    // static {
+    //     try {
+    //         System.setOut(new PrintStream(op));
+    //         System.setIn(new FileInputStream(ip));
+    //     } catch (Exception e) {
+    //     }
+
+    //     // in = new InputReader(System.in);
+    // }
+
+
+
+   public static void main(String[] args) {
+      MyScanner sc = new MyScanner();
+      out = new PrintWriter(new BufferedOutputStream(System.out));
+      
+      //out.println(result);                    // print via PrintWriter
+      /////////////////////////////////////////////
+
+        int test = sc.nextInt();
+        while(test-- != 0)
+        {
+            int n = sc.nextInt();
+            String[] info = new String[n];
+            for (int i = 0; i < n; i++) {
+                info[i] = sc.next();
+            }
+            int ans = 0;
+            for (int i = 0; i < 5; i++) {
+                char cur = (char) (i+'a');
+                int[] map = new int[n];
+                for (int j = 0; j < n; j++) {
+                    for (int k = 0; k < info[j].length(); k++) {
+                        if(info[j].charAt(k)==cur)map[j]++;
+                        else map[j]--;
+                    }
+                }
+                Arrays.sort(map);
+                int sum = 0;
+                for(int j = n-1; j >= 0; j--) {
+                    sum += map[j];
+                    if(sum<=0){
+                        break;
+                    }
+                    ans = Math.max(ans,n-j);
+                }
+            }
+            System.out.println(ans);
+        }
+
+
+
+
+
+      /////////////////////////////////////////////
+      // Stop writing your solution here. -------------------------------------
+      out.close();
+   }
+   
+   static void shuffleArrayL(long[] arr) {
+    int n = arr.length;
+    Random rnd = new Random();
+    for (int i = 0; i < n; ++i) {
+        long tmp = arr[i];
+        int randomPos = i + rnd.nextInt(n - i);
+        arr[i] = arr[randomPos];
+        arr[randomPos] = tmp;
+    }
+}
+
+   //-----------PrintWriter for faster output---------------------------------
+   public static PrintWriter out;
+      
+   //-----------MyScanner class for faster input----------
+   public static class MyScanner {
+      BufferedReader br;
+      StringTokenizer st;
+ 
+      public MyScanner() {
+         br = new BufferedReader(new InputStreamReader(System.in));
+      }
+ 
+      String next() {
+          while (st == null || !st.hasMoreElements()) {
+              try {
+                  st = new StringTokenizer(br.readLine());
+              } catch (IOException e) {
+                  e.printStackTrace();
+              }
+          }
+          return st.nextToken();
+      }
+ 
+      int nextInt() {
+          return Integer.parseInt(next());
+      }
+ 
+      long nextLong() {
+          return Long.parseLong(next());
+      }
+ 
+      double nextDouble() {
+          return Double.parseDouble(next());
+      }
+ 
+      String nextLine(){
+          String str = """";
+	  try {
+	     str = br.readLine();
+	  } catch (IOException e) {
+	     e.printStackTrace();
+	  }
+	  return str;
+      }
+
+   }
+   //--------------------------------------------------------
+}",1
+3380fa52,8a39dbf5,"import java.util.*;
+import java.io.*;
+import java.math.*;
+
+/* Name of the class has to be ""Main"" only if the class is public. */
+public class Coder {
+  static int n, k;
+  static long a[];
+  static int pos[];
+  static int temp[];
+  static StringBuilder str = new StringBuilder("""");
+  static int cnt[][] = new int[(int)1e5+5][2];
+  static void solve() {
+    long []l = new long[n];
+    long []r = new long[n];
+    long p = Integer.MAX_VALUE;
+    for(int i=0;i<n;i++){
+        p = Math.min(p+1, a[i]);
+        l[i] = p;
+    }
+    p=Integer.MAX_VALUE;
+    for(int i=n-1;i>=0;i--){
+     p = Math.min(p+1, a[i]);
+     r[i] = p;
+    }
+    for(int i=0;i<n;i++){
+        str.append(Math.min(l[i],r[i])).append("" "");
+    }
+    str.append(""\n"");
+  }
+
+  public static void main(String[] args) throws java.lang.Exception {
+    BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
+    int t = Integer.parseInt(bf.readLine().trim());
+    while (t-- > 0) {
+      bf.readLine();
+      String s[] = bf.readLine().trim().split(""\\s+"");
+      n = Integer.parseInt(s[0]);
+      k = Integer.parseInt(s[1]);
+      s = bf.readLine().trim().split(""\\s+"");
+      pos = new int[k];
+      temp = new int[k];
+      a = new long[n];
+      for(int i=0;i<k;i++) pos[i]=Integer.parseInt(s[i]);
+      s = bf.readLine().trim().split(""\\s+"");
+      for(int i=0;i<k;i++) temp[i]=Integer.parseInt(s[i]);
+      Arrays.fill(a, Integer.MAX_VALUE);
+      for(int i=0;i<k;i++) a[pos[i]-1] = temp[i]; 
+      solve();
+    }
+    System.out.print(str);
+  }
+}","import java.util.*;
+import java.lang.*;
+import java.io.*;
+ 
+/* Name of the class has to be ""Main"" only if the class is public. */
+public class Codeforces {
+    public static void main(String[] args) throws java.lang.Exception {
+        /* your code goes here */
+        BufferedReader buf = new BufferedReader(new InputStreamReader(System.in));
+       int t = Integer.parseInt(buf.readLine());
+        StringBuilder sb = new StringBuilder();
+       for (int i = 0; i < t; i++) {
+           String st=buf.readLine();
+          String st1[]=(buf.readLine()).split("" "");
+          int n=Integer.parseInt(st1[0]);
+          int k=Integer.parseInt(st1[1]);
+          int a[]=new int[k];
+          int temp[]=new int[k];
+          long arr[]=new long[n];
+          String st2[]=(buf.readLine()).split("" "");
+           String st3[]=(buf.readLine()).split("" "");
+           for(int j=0;j<k;j++)
+           {
+               a[j]=Integer.parseInt(st2[j]);
+               temp[j]=Integer.parseInt(st3[j]);
+           }
+          for(int j=0;j<k;j++)
+          {
+              arr[a[j]-1]=temp[j];
+          }
+          long min=Integer.MAX_VALUE;
+          long left[]=new long[n];
+          long right[]=new long[n];
+          if(arr[0]==0)
+              left[0]=min;
+          else
+              left[0]=arr[0];
+          for(int j=1;j<n;j++)
+          {
+              if(arr[j]==0)
+              {
+                  left[j]=left[j-1]+1;
+              }
+              else
+              {
+                  left[j]=Math.min(left[j-1]+1,arr[j]);
+              }
+          }
+          if(arr[n-1]==0)
+              right[n-1]=min;
+          else
+              right[n-1]=arr[n-1];
+          for(int j=n-2;j>=0;j--)
+          {
+              if(arr[j]==0)
+              {
+                  right[j]=right[j+1]+1;
+              }
+              else
+              {
+                  right[j]=Math.min(right[j+1]+1,arr[j]);
+              }
+          }
+          for(int j=0;j<n;j++)
+          {
+              arr[j]=Math.min(left[j],right[j]);
+              sb.append(arr[j]+"" "");
+          }
+          sb.append(""\n"");
+        }
+        System.out.println(sb);
+    }
+}",0
+2c865582,2ef4c176,"import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.*;
+import java.util.StringTokenizer;
+
+public class Main {
+    static class FastReader {
+        BufferedReader br;
+        StringTokenizer st;
+
+        public FastReader()
+        {
+            br = new BufferedReader(
+                    new InputStreamReader(System.in));
+        }
+
+        String next()
+        {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                }
+                catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt() { return Integer.parseInt(next()); }
+
+        long nextLong() { return Long.parseLong(next()); }
+
+        double nextDouble()
+        {
+            return Double.parseDouble(next());
+        }
+
+        String nextLine()
+        {
+            String str = """";
+            try {
+                str = br.readLine();
+            }
+            catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+        }
+    }
+
+
+    static long dfs(int cur,int parent,int taken,HashMap<Integer,ArrayList<node>> hm,ArrayList<node> al,long[][] dp){
+        long ans=0;
+        if(dp[cur-1][taken]!=-1) return dp[cur-1][taken];
+        int v=taken==0?al.get(cur-1).l:al.get(cur-1).r;
+        for(node x:hm.get(cur)){
+            int xl=x.l,xr=x.r,idx=x.idx;
+            if(idx!=parent){
+                ans+=Math.max(Math.abs(v-xl)+dfs(idx,cur,0,hm,al,dp),Math.abs(v-xr)+dfs(idx,cur,1,hm,al,dp));
+            }
+        }
+        return dp[cur-1][taken]=ans;
+    }
+    public static void main(String[] args) {
+        FastReader obj = new FastReader();
+        int t = obj.nextInt();
+        while(t-->0) {
+            int n = obj.nextInt(),a,b;
+            ArrayList<node> al=new ArrayList<>();
+            for(int i=0;i<n;i++){
+                a = obj.nextInt();
+                b = obj.nextInt();
+                al.add(new node(a,b,i+1));
+            }
+            HashMap<Integer,ArrayList<node>> hm=new HashMap<>();
+            for(int i=0;i<n-1;i++){
+                a = obj.nextInt();
+                b = obj.nextInt();
+                if(!hm.containsKey(a)){
+                    hm.put(a,new ArrayList<node>());
+                }
+                if(!hm.containsKey(b)){
+                    hm.put(b,new ArrayList<node>());
+                }
+                hm.get(a).add(al.get(b-1));
+                hm.get(b).add(al.get(a-1));
+            }
+            long[][] dp=new long[n+2][2];
+            for(long[] x:dp) Arrays.fill(x,-1);
+            long ans1,ans2;
+            ans1=dfs(1,0,0,hm,al,dp);
+            ans2=dfs(1,0,1,hm,al,dp);
+            System.out.println(Math.max(ans1,ans2));
+        }
+    }
+}
+
+class node{
+    int l,r,idx;
+    node(int l1,int r1,int i){
+        l=l1;
+        r=r1;
+        idx=i;
+    }
+}","import java.io.*;
+import java.util.*;
+
+public class Template {
+
+	static int mod = 1000000007;
+
+	public static void main(String[] args) {
+		FastScanner sc = new FastScanner();
+		PrintWriter out = new PrintWriter(System.out);
+		int yo = sc.nextInt();
+		while (yo-- > 0) {
+			int n = sc.nextInt();
+			
+			Map<Integer,Pair> map = new HashMap<>();
+			
+			for(int i = 0; i < n; i++) {
+				map.put(i, new Pair(sc.nextLong(),sc.nextLong()));
+			}
+			
+			List<List<Integer>> list = new ArrayList<>();
+			for(int i = 0; i < n; i++) {
+				list.add(new ArrayList<>());
+			}
+			for(int i = 0; i < n-1; i++) {
+				int x = sc.nextInt()-1;
+				int y = sc.nextInt()-1;
+				list.get(x).add(y);
+				list.get(y).add(x);
+			}
+			
+			// l -> 0, r -> 1
+			
+			for(int i = 0; i < 1e5+3; i++) {
+				for(int j = 0; j < 2; j++) {
+					dp[i][j] = -1;
+				}
+			}
+			long a1 = dfs(map,list,0,0,-1);
+			long a2 = dfs(map,list,1,0,-1);
+			long ans = Math.max(a1, a2);
+			out.println(ans);
+		}
+		out.close();
+	}
+
+//	static Map<String,Long> dp = new HashMap<>();
+	static long[][] dp = new long[(int)1e5+10][2];
+	private static long dfs(Map<Integer, Pair> map, List<List<Integer>> list, 
+							int x, int node, int parent) {
+		
+		
+		if(dp[node][x] != -1) {
+			return dp[node][x];
+		}
+
+		List<Integer> neighbours = list.get(node);
+		
+		long ans1 = 0;
+		if(x == 0) {
+			ans1 = map.get(node).x;
+		}
+		else {
+			ans1 = map.get(node).y;
+		}
+		
+		
+		long uAns = 0;
+		for(int e : neighbours) {
+			if(e == parent) continue;
+			long ua1 = dfs(map,list,0,e,node);
+			long ua2 = dfs(map,list,1,e,node);
+			// consider 0
+			long a1 = ua1 + Math.abs(map.get(e).x-ans1);
+			// consider 1
+			long a2 = ua2 + Math.abs(map.get(e).y-ans1);
+			uAns += Math.max(a1, a2);
+		}
+		
+		return dp[node][x] = uAns;
+	}
+
+	static class Pair {
+		long x;
+		long y;
+
+		public Pair(long x, long y) {
+			this.x = x;
+			this.y = y;
+		}
+	}
+
+	static void ruffleSort(int[] a) {
+		
+		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);
+	}
+
+	static long gcd(long a, long b) {
+		if (b == 0)
+			return a;
+		return gcd(b, a % b);
+	}
+
+	static boolean[] sieve(int N) {
+		boolean[] sieve = new boolean[N];
+		for (int i = 2; i < N; i++)
+			sieve[i] = true;
+
+		for (int i = 2; i < N; i++) {
+			if (sieve[i]) {
+				if (i * i < 0)
+					continue;
+				for (int j = i * i; j < N; j += i) {
+					sieve[j] = false;
+				}
+			}
+		}
+		return sieve;
+	}
+
+	static long pow(int a, long b) {
+		if (b == 0) {
+			return 1;
+		}
+		if (b == 1) {
+			return a;
+		}
+		if (b % 2 == 0) {
+			long ans = pow(a, b / 2);
+			return ans * ans;
+		} else {
+			long ans = pow(a, (b - 1) / 2);
+			return a * ans * ans;
+		}
+
+	}
+
+	static class FastScanner {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st = new StringTokenizer("""");
+
+		String next() {
+			while (!st.hasMoreTokens())
+				try {
+					st = new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			return st.nextToken();
+		}
+
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+
+		int[] readArray(int n) {
+			int[] a = new int[n];
+			for (int i = 0; i < n; i++)
+				a[i] = nextInt();
+			return a;
+		}
+
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+	}
+
+	//	For Input.txt and Output.txt	
+	//	FileInputStream in = new FileInputStream(""input.txt"");
+	//	FileOutputStream out = new FileOutputStream(""output.txt"");
+	//	PrintWriter pw = new PrintWriter(out);
+	//	Scanner sc = new Scanner(in);
+}
+",0
+7c11511f,f3d7ce08,"import java.io.*;
+import java.util.*;
+
+public class Solution {
+
+    public static void main(String[] args) throws Exception {
+        int tc = io.nextInt();
+        for (int i = 0; i < tc; i++) {
+            solve();
+        }
+        io.close();
+    }
+
+    private static void solve() throws Exception {
+        int n = io.nextInt();
+        String a = io.next();
+        String b = io.next();
+        int zz = 0;
+        int zo = 0;
+        int oo = 0;
+        int oz = 0;
+        for (int i = 0; i < a.length(); i++) {
+            if (a.charAt(i) == '1' && b.charAt(i) == '0') {
+                oz++;
+            }
+            if (a.charAt(i) == '0' && b.charAt(i) == '0') {
+                zz++;
+            }
+            if (a.charAt(i) == '1' && b.charAt(i) == '1') {
+                oo++;
+            }
+            if (a.charAt(i) == '0' && b.charAt(i) == '1') {
+                zo++;
+            }
+        }
+        int ans = Integer.MAX_VALUE;
+        if (oz == zo) {
+            ans = Math.min(ans, oz + zo);
+        }
+        if (oo - 1 == zz) {
+            ans = Math.min(ans, oo + zz);
+        }
+        if (ans == Integer.MAX_VALUE) {
+            ans = -1;
+        }
+        io.println(ans);
+    }
+
+    static void sort(int[] a) {
+        ArrayList<Integer> l = new ArrayList<>(a.length);
+        for (int i : a) l.add(i);
+        Collections.sort(l);
+        for (int i = 0; i < a.length; i++) a[i] = l.get(i);
+    }
+
+    //-----------PrintWriter for faster output---------------------------------
+    public static FastIO io = new FastIO();
+
+    //-----------MyScanner class for faster input----------
+    static class FastIO extends PrintWriter {
+        private InputStream stream;
+        private byte[] buf = new byte[1 << 16];
+        private int curChar, numChars;
+
+        // standard input
+        public FastIO() {
+            this(System.in, System.out);
+        }
+
+        public FastIO(InputStream i, OutputStream o) {
+            super(o);
+            stream = i;
+        }
+
+        // file input
+        public FastIO(String i, String o) throws IOException {
+            super(new FileWriter(o));
+            stream = new FileInputStream(i);
+        }
+
+        // throws InputMismatchException() if previously detected end of file
+        private int nextByte() {
+            if (numChars == -1) throw new InputMismatchException();
+            if (curChar >= numChars) {
+                curChar = 0;
+                try {
+                    numChars = stream.read(buf);
+                } catch (IOException e) {
+                    throw new InputMismatchException();
+                }
+                if (numChars == -1) return -1; // end of file
+            }
+            return buf[curChar++];
+        }
+
+        // to read in entire lines, replace c <= ' '
+        // with a function that checks whether c is a line break
+        public String next() {
+            int c;
+            do {
+                c = nextByte();
+            } while (c <= ' ');
+            StringBuilder res = new StringBuilder();
+            do {
+                res.appendCodePoint(c);
+                c = nextByte();
+            } while (c > ' ');
+            return res.toString();
+        }
+
+        public String nextLine() {
+            int c;
+            do {
+                c = nextByte();
+            } while (c < '\n');
+            StringBuilder res = new StringBuilder();
+            do {
+                res.appendCodePoint(c);
+                c = nextByte();
+            } while (c > '\n');
+            return res.toString();
+        }
+
+        public int nextInt() {
+            int c;
+            do {
+                c = nextByte();
+            } while (c <= ' ');
+            int sgn = 1;
+            if (c == '-') {
+                sgn = -1;
+                c = nextByte();
+            }
+            int res = 0;
+            do {
+                if (c < '0' || c > '9')
+                    throw new InputMismatchException();
+                res = 10 * res + c - '0';
+                c = nextByte();
+            } while (c > ' ');
+            return res * sgn;
+        }
+
+        public long nextLong() {
+            int c;
+            do {
+                c = nextByte();
+            } while (c <= ' ');
+            int sgn = 1;
+            if (c == '-') {
+                sgn = -1;
+                c = nextByte();
+            }
+            long res = 0;
+            do {
+                if (c < '0' || c > '9')
+                    throw new InputMismatchException();
+                res = 10 * res + c - '0';
+                c = nextByte();
+            } while (c > ' ');
+            return res * sgn;
+        }
+
+
+        public double nextDouble() {
+            return Double.parseDouble(next());
+        }
+    }
+    //--------------------------------------------------------
+}","import javax.swing.plaf.IconUIResource;
+import java.lang.reflect.Array;
+import java.text.CollationElementIterator;
+import java.util.*;
+import java.io.*;
+ 
+//Timus judge id- 323935JJ
+ 
+ 
+public class Main {
+ 
+ 
+ 
+ 
+    //----------------------------------------------------------------------------------------------
+    public static class Pair implements Comparable<Pair> {
+        int x=0,y=0;
+        int z=0;
+        public Pair(int a, int b) {
+            this.x=a;
+            this.y=b;
+ 
+        }
+ 
+        public int compareTo(Pair o) {
+            return this.x - o.x;
+        }
+    }
+ 
+ 
+    public static int mod = (int) (1e9 + 7);
+    static int ans = Integer.MAX_VALUE;
+ 
+    public static void main(String hi[]) throws Exception {
+        FastReader sc = new FastReader();
+        int t =sc.nextInt();
+        while(t-->0)
+        {
+            int n =sc.nextInt();
+            String a = sc.nextLine(),b=sc.nextLine();
+ 
+            int count1=0,count2=0,count3=0,count4=0;
+ 
+            for(int i=0;i<n;i++)
+            {
+                if(a.charAt(i)=='0'&&b.charAt(i)=='0')
+                    count1++;
+                else  if(a.charAt(i)=='1'&&b.charAt(i)=='1')
+                    count2++;
+                else  if(a.charAt(i)=='1'&&b.charAt(i)=='0')
+                    count3++;
+                else  if(a.charAt(i)=='0'&&b.charAt(i)=='1')
+                    count4++;
+            }
+            int ans=Integer.MAX_VALUE;
+ 
+            if(count3==count4)
+                ans=Math.min(count3*2,ans);
+ 
+            if(count2==count1+1)
+                ans=Math.min(ans,2*count1+1);
+ 
+           
+            if(ans==Integer.MAX_VALUE)
+                System.out.println(-1);
+            else System.out.println(ans);
+ 
+        }
+ 
+    }
+ 
+    static int find(int[] a,int x)
+    {
+        if(a[x]==-1)
+            return x;
+        else return find(a,a[x]);
+    }
+ 
+ 
+ 
+ 
+ 
+    static int gcd(int a, int b)
+    {
+        if (a == 0)
+            return b;
+        return gcd(b % a, a);
+    }
+ 
+    // method to return LCM of two numbers
+    static int lcm(int a, int b)
+    {
+        return (a / gcd(a, b)) * b;
+    }
+ 
+ 
+    static long gcdl(long a, long b)
+    {
+        if (a == 0)
+            return b;
+        return gcdl(b % a, a);
+    }
+ 
+    // method to return LCM of two numbers
+    static long lcml(long a, long b)
+    {
+        return (a / gcdl(a, b)) * b;
+    }
+ 
+ 
+    static class FastReader {
+        BufferedReader br;
+        StringTokenizer st;
+ 
+        public FastReader() {
+            br = new BufferedReader(new
+                    InputStreamReader(System.in));
+        }
+ 
+        String next() {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+ 
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+ 
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+ 
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+ 
+        String nextLine() {
+            String str = """";
+            try {
+                str = br.readLine();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+ 
+        }
+    }
+}
+ ",0
+d221162a,ee4f7b06,"import java.util.*;
+import java.io.*;
+
+public class Main2 {
+	static class FastReader{ 
+        BufferedReader br; 
+        StringTokenizer st; 
+        public FastReader(){br = new BufferedReader(new InputStreamReader(System.in));}
+        String next(){while (st == null || !st.hasMoreElements()){try{st = new StringTokenizer(br.readLine());} 
+        catch (IOException  e){e.printStackTrace();}}return st.nextToken();}
+        int nextInt(){ return Integer.parseInt(next());}long nextLong(){return Long.parseLong(next());}double nextDouble(){return Double.parseDouble(next());}
+        String nextLine(){String str = """"; try{str = br.readLine(); } catch (IOException e) {e.printStackTrace();} return str; } 
+    }
+	static long mod = 998244353;
+//	static Scanner sc = new Scanner(System.in);
+	static FastReader sc = new FastReader();
+	static PrintWriter out = new PrintWriter(System.out);
+	public static void main (String[] args) {
+		int t = 1;
+//    	t = sc.nextInt();
+	    z : while(t-->0) {
+	    	int n = sc.nextInt();
+	    	int a[] = new int[n];
+	    	for(int i=0;i<n;i++) a[i] = sc.nextInt();
+	    	List<Integer> a1 = new ArrayList<>();
+	    	ArrayList<Integer> a2 = new ArrayList<>();
+	    	for (int i = 0; i < n; i++) {
+	    		if(a[i] == 0) a1.add(i);
+	    		else a2.add(i);
+			}
+	    	long dp[][] = new long[n+1][n+1];
+	    	for (int i = 0; i <= n; i++) {
+	    		Arrays.fill(dp[i],-1);
+			}
+	    	out.write(find(0,0,a1,a2,dp)+""\n"");
+	    }
+		out.close();
+	}
+	private static long find(int i, int j, List<Integer> a1, ArrayList<Integer> a2, long[][] dp) {
+		if(j == a2.size()) return 0;
+		
+		int req = a2.size()-j;
+		int ava = a1.size()-i;
+		
+		if(ava<req) return Integer.MAX_VALUE/2;
+		
+		if(dp[i][j] != -1) return dp[i][j];
+		
+		long ans1 = find(i+1,j,a1,a2,dp);
+		long ans2 = Math.abs(a1.get(i)-a2.get(j)) + find(i+1,j+1,a1,a2,dp);
+		
+		return dp[i][j] = Math.min(ans1, ans2);
+	}
+}
+","    import java.io.*;
+    import java.util.*;
+    import java.lang.Math;
+
+
+    public class Main {
+
+          static PrintWriter pw;
+          static Scanner sc;
+          static StringBuilder ans;
+          static long mod = 1000000000+7;
+
+          static void pn(final Object arg) {
+               pw.print(arg);          
+               pw.flush();      
+          }     
+
+          /*-------------- for input in an value ---------------------*/
+          static int ni()     { return sc.nextInt();       }
+          static long nl()    { return sc.nextLong();      }
+          static double nd()  { return sc.nextDouble();    }
+          static String ns()  { return sc.next();          }
+
+
+          static void ap(int arg)           { ans.append(arg); }
+          static void ap(long arg)          { ans.append(arg); }
+          static void ap(String arg)        { ans.append(arg); }
+          static void ap(StringBuilder arg) { ans.append(arg); }        
+
+
+          /*-------------- for input in an array ---------------------*/
+          static void inputIntegerArray(int arr[]){
+               for(int i=0; i<arr.length; i++)arr[i] = ni();
+          }
+          static void inputLongArray(long arr[]){
+               for(int i=0; i<arr.length; i++)arr[i] = nl(); 
+          }
+          static void inputStringArray(String arr[]){
+               for(int i=0; i<arr.length; i++)arr[i] = ns(); 
+          }    
+          static void inputDoubleArray(double arr[]){
+               for(int i=0; i<arr.length; i++)arr[i] = nd();
+          }
+
+
+          /*-------------- File vs Input ---------------------*/
+          static void runFile() throws Exception {
+               sc = new Scanner(new FileReader(""input.txt""));
+               pw = new PrintWriter(new BufferedWriter(new FileWriter(""output.txt"")));
+          }
+          static void runIo() throws Exception  {
+               pw =new PrintWriter(System.out);
+               sc = new Scanner(System.in);
+          }    
+
+          static void swap(int a, int b) {
+               int  t = a;
+               a = b;
+               b = t;
+          }
+
+          static boolean isPowerOfTwo (long x) { return x!=0 && ((x&(x-1)) == 0);}
+
+          static int gcd(int a, int b) { if (b == 0) return a;     return gcd(b, a % b); }
+          
+          static int countDigit(long n){return (int)Math.floor(Math.log10(n) + 1);} 
+          
+          static boolean isPrime(int n) { 
+               if (n <= 1) return false; 
+               if (n <= 3) return true; 
+               if (n % 2 == 0 || n % 3 == 0) return false; 
+
+               for (int i = 5; i * i <= n; i = i + 6) 
+               if (n % i == 0 || n % (i + 2) == 0) 
+                    return false; 
+
+               return true; 
+          }         
+
+          static boolean sv[] = new boolean[1000002];
+          static void seive() {
+                 //true -> not prime
+               // false->prime
+
+               sv[0] = sv[1] = true; 
+               sv[2] = false;
+               for(int i = 0; i< sv.length; i++) {
+                    if( !sv[i] && (long)i*(long)i < sv.length ) {
+                         for ( int j = i*i; j<sv.length ; j += i ) {                
+                          sv[j] = true;
+                         }
+                    }
+               }
+
+          }
+
+          static long  binpow(  long a,   long b) {
+               long res = 1;
+               while (b > 0) {
+                    if ( (b & 1) > 0){
+                    res = (res * a)%mod;
+               }
+               a = (a * a)%mod;
+               b >>= 1;
+               }
+
+               return res;
+          }
+
+          static long factorial(long n)  {
+               long res = 1, i;
+               for (i = 2; i <= n; i++){
+                    res  =  ((res%mod) * (i%mod))%mod;
+               }          
+               return res;
+          }
+  
+
+          static class Pair {
+               int idx;
+               int v;
+               Pair(int idx, int v){
+                    this.idx = idx;
+                    this.v = v;
+               }
+          }
+     
+          public static void main(String[] args)  throws Exception {
+
+               // runFile();
+
+               runIo();              
+
+               int t;
+               t = 1;     
+            
+               // t =  sc.nextInt();
+          
+               ans = new StringBuilder();
+          
+               while( t-- > 0 ) {   
+                    solve();
+               }                
+          
+               pn(ans+""""); 
+ 
+          }
+    
+          static int N ; 
+          static int M ; 
+          static ArrayList<Integer> f;
+          static ArrayList<Integer> e;
+          static long dp[][];
+
+          static long find(int i, int j ) {
+               
+               if( i == N )   return 0;
+               if( j == M )   return Integer.MAX_VALUE;
+
+
+               if (dp[i][j] != -1 )
+                    return dp[i][j];
+
+               return dp[i][j] = Math.min( find(i, j+1), Math.abs(f.get(i)-e.get(j)) +  find(i+1, j+1) );
+          }       
+
+
+          public static void solve() {          
+          
+               int n = ni();
+               f = new ArrayList();
+               e = new ArrayList();               
+
+               for(int i = 0; i<n; i++) {
+                    int v = ni();
+                    if( v == 0 ) {
+                         e.add(i);
+                    }
+                    else
+                         f.add(i);
+               }
+
+               N = f.size();
+               M = e.size();               
+
+               dp = new long[N][M];
+
+               for(int i = 0; i<N; i++)
+                    Arrays.fill(dp[i], -1);
+
+               ap(find(0, 0)+""\n"");
+          }
+ 
+     }
+  
+
+   // 0 1 2 3 4 5 6 7
+   // 1 1 0 0 0 1 0 0
+
+   // 1s -> { 0, 1, 5 }
+   // 0s -> { 2, 3, 6, 7 }
+
+
+",0
+0951d079,b2bae06a,"import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.Stack;
+import java.util.StringTokenizer;
+
+public class D {
+
+	public static void main(String[] args) throws NumberFormatException, IOException {
+		BufferedReader file = new BufferedReader(new InputStreamReader(System.in));
+		int n = Integer.parseInt(file.readLine());
+		int[] heights = new int[n];
+		StringTokenizer st = new StringTokenizer(file.readLine());
+		for(int i = 0; i < n; i++) {
+			heights[i] = Integer.parseInt(st.nextToken());
+		}
+		int[] dp = new int[n];
+		dp[0] = 0;
+		Stack<Integer> high = new Stack<>();
+		Stack<Integer> low = new Stack<>();
+		high.push(0);
+		low.push(0);
+		for(int i = 1; i < n; i++) {
+			dp[i] = dp[i-1]+1;
+			while(!high.isEmpty() && heights[high.peek()] < heights[i]) {
+				dp[i] = Math.min(dp[i], dp[high.peek()]+1);
+				high.pop();
+			}
+			if(!high.isEmpty()) {
+				dp[i] = Math.min(dp[i], dp[high.peek()]+1);
+				if(heights[high.peek()] == heights[i])
+					high.pop();
+			}
+			while(!low.isEmpty() && heights[low.peek()] > heights[i]) {
+				dp[i] = Math.min(dp[i], dp[low.peek()]+1);
+				low.pop();
+			}
+			if(!low.isEmpty()) {
+				dp[i] = Math.min(dp[i], dp[low.peek()]+1);
+				if(heights[low.peek()] == heights[i])
+					low.pop();
+			}
+			high.push(i);
+			low.push(i);
+		}
+		System.out.println(dp[n-1]);
+	}
+
+}
+","    import java.util.*;
+    import java.io.*;
+    public class D{
+        static class InputReader {
+
+            private final InputStream stream;
+            private final byte[] buf = new byte[8192];
+            private int curChar, snumChars;
+            private SpaceCharFilter filter;
+
+            public InputReader(InputStream stream) {
+                this.stream = stream;
+            }
+
+            public int snext() {
+                if (snumChars == -1)
+                    throw new InputMismatchException();
+                if (curChar >= snumChars) {
+                    curChar = 0;
+                    try {
+                        snumChars = stream.read(buf);
+                    } catch (IOException e) {
+                        throw new InputMismatchException();
+                    }
+                    if (snumChars <= 0)
+                        return -1;
+                }
+                return buf[curChar++];
+            }
+
+            public int nextInt() {
+                int c = snext();
+                while (isSpaceChar(c)) {
+                    c = snext();
+                }
+                int sgn = 1;
+                if (c == '-') {
+                    sgn = -1;
+                    c = snext();
+                }
+                int res = 0;
+                do {
+                    if (c < '0' || c > '9')
+                        throw new InputMismatchException();
+                    res *= 10;
+                    res += c - '0';
+                    c = snext();
+                } while (!isSpaceChar(c));
+                return res * sgn;
+            }
+
+            public long nextLong() {
+                int c = snext();
+                while (isSpaceChar(c)) {
+                    c = snext();
+                }
+                int sgn = 1;
+                if (c == '-') {
+                    sgn = -1;
+                    c = snext();
+                }
+                long res = 0;
+                do {
+                    if (c < '0' || c > '9')
+                        throw new InputMismatchException();
+                    res *= 10;
+                    res += c - '0';
+                    c = snext();
+                } while (!isSpaceChar(c));
+                return res * sgn;
+            }
+
+            public int[] nextIntArray(int n) {
+                int a[] = new int[n];
+                for (int i = 0; i < n; i++) {
+                    a[i] = nextInt();
+                }
+                return a;
+            }
+
+            public String readString() {
+                int c = snext();
+                while (isSpaceChar(c)) {
+                    c = snext();
+                }
+                StringBuilder res = new StringBuilder();
+                do {
+                    res.appendCodePoint(c);
+                    c = snext();
+                } while (!isSpaceChar(c));
+                return res.toString();
+            }
+
+            public String nextLine() {
+                int c = snext();
+                while (isSpaceChar(c))
+                    c = snext();
+                StringBuilder res = new StringBuilder();
+                do {
+                    res.appendCodePoint(c);
+                    c = snext();
+                } while (!isEndOfLine(c));
+                return res.toString();
+            }
+
+            public boolean isSpaceChar(int c) {
+                if (filter != null)
+                    return filter.isSpaceChar(c);
+                return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
+            }
+
+            private boolean isEndOfLine(int c) {
+                return c == '\n' || c == '\r' || c == -1;
+            }
+
+            public interface SpaceCharFilter {
+                public boolean isSpaceChar(int ch);
+            }
+
+        }
+        static class OutputWriter {
+            private final PrintWriter writer;
+    
+            public OutputWriter(OutputStream outputStream) {
+                writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
+            }
+    
+            public OutputWriter(Writer writer) {
+                this.writer = new PrintWriter(writer);
+            }
+    
+            public void print(Object...objects) {
+                for (int i = 0; i < objects.length; i++) {
+                    if (i != 0)
+                        writer.print(' ');
+                    writer.print(objects[i]);
+                }
+            }
+    
+            public void printLine(Object...objects) {
+                print(objects);
+                writer.println();
+            }
+    
+            public void close() {
+                writer.close();
+            }
+    
+            public void flush() {
+                writer.flush();
+            }
+    
+            }
+        static int gcd(int a, int b) 
+        { 
+            if (a == 0) 
+                return b; 
+            return gcd(b % a, a); 
+        } 
+        static int mod = (int)(1e9+7);
+        public static long pow(long a,long b)
+        {
+            long ans = 1;
+            while(b> 0)
+            {
+                if((b & 1)==1){
+                    ans = (ans*a) % mod; 
+                }
+                a = (a*a) % mod;
+                b = b>>1;
+            }
+            return ans;
+        }
+
+        public static void main(String[] args) {
+            InputReader in = new InputReader(System.in);
+            OutputWriter out = new OutputWriter(System.out);
+            int n = in.nextInt();
+            int[] arr = in.nextIntArray(n);
+            Stack<Integer> min = new Stack<>();
+            Stack<Integer> max = new Stack<>();
+            int[] dp = new int[n];
+            // Arrays.fill(dp,(int)1e9);
+            dp[0] = 0;
+            min.push(0);
+            max.push(0);
+            for(int i=1;i<n;i++)
+            {
+                int h=dp[i-1]+1;
+                while(!max.isEmpty() && arr[i]>arr[max.peek()])
+                {
+                    int x = arr[max.peek()];
+                    h = Math.min(h,1+dp[max.pop()]);
+                    while(!max.isEmpty() && arr[max.peek()]==x)
+                    {
+                        max.pop();
+                    }
+                }
+                if(!max.isEmpty())
+                {
+                    h = Math.min(h,1+dp[max.peek()]);
+                }
+                while(!min.isEmpty() && arr[i]<arr[min.peek()])
+                {
+                    int x = arr[min.peek()];
+                    h = Math.min(h,1+dp[min.pop()]);
+                    while(!min.isEmpty() && arr[min.peek()]==x)
+                    {
+                        min.pop();
+                    }
+                }
+                if(!min.isEmpty())
+                {
+                    h = Math.min(h,1+dp[min.peek()]);
+                }
+                dp[i] = h;
+                min.push(i);
+                max.push(i);
+            }
+            out.printLine(dp[n-1]);
+            out.flush();
+            out.close();
+        }
+    }",0
+08cf0478,9291ca83,"import java.util.*;
+import java.io.*;
+
+public class Main {
+
+  static class Pair {
+	  int fi;
+	  int se;
+	  
+	  public Pair(int fi, int se) {
+		  this.fi = fi;
+		  this.se = se;
+	  }
+  }
+
+  public static void main(final String[] args) {
+    FastScanner sc = new FastScanner();
+
+	int t = sc.nextInt();
+	while(t-- > 0) {
+		int n = sc.nextInt();
+		int[][] arr = new int[5][n];
+		
+		for(int i = 0; i < n; i++) {
+			char[] s = sc.next().toCharArray();
+			int[] cnt = new int[5];
+			for(int j = 0; j < s.length; j++) {
+				cnt[s[j]-'a']++;
+			}
+			for(int j = 0; j < 5; j++)
+				arr[j][i] = cnt[j]-(s.length-cnt[j]);
+		}
+		
+		int ans = 0;
+		for(int i = 0; i < 5; i++) {
+			Arrays.sort(arr[i]);
+			int maxSum = 0;
+			int words = 0;
+			for(int j = arr[i].length-1; j >=0; j--) {
+				maxSum += arr[i][j];
+				if(maxSum > 0) words++;
+			}
+			
+			ans = Math.max(ans, words);
+		}
+		
+		System.out.println(ans);
+	}
+
+  } 
+
+  static class FastScanner {
+		BufferedReader br;
+		StringTokenizer st;
+		public FastScanner() {
+			br = new BufferedReader(new InputStreamReader(System.in));
+		}
+		String next() {while (st == null || !st.hasMoreElements()) {
+			try {st = new StringTokenizer(br.readLine());}
+			catch (IOException e) {e.printStackTrace();}}
+		return st.nextToken();}
+		int nextInt() {return Integer.parseInt(next());}
+		long nextLong() {return Long.parseLong(next());}
+		double nextDouble() {return Double.parseDouble(next());}
+		String nextLine(){String str = """";
+		try {str = br.readLine();}
+		catch (IOException e) {e.printStackTrace();}
+		return str;}
+	}
+}
+","import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.util.*;
+
+public class Practice {
+    static HashMap<String, Integer> map = new HashMap<>();
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        int t = sc.nextInt();
+        while (t-->0) {
+            int n = sc.nextInt();
+            int[][] occurances = new int[5][n];
+            for(int i=0;i<n;i++){
+                String s = sc.next();
+                int[] count = new int[5];
+                int len = s.length();
+                for(int j=0;j<s.length();j++){
+                    count[s.charAt(j)-'a']++;
+                }
+                for(int j=0;j<5;j++){
+                    occurances[j][i] = count[j] - (len-count[j]);
+                }
+            }
+            int ans = 0;
+            for(int i=0;i<5;i++){
+                Arrays.sort(occurances[i]);
+                int tmpAns = 0; int tmpSum=0;
+                for(int j=n-1;j>=0;j--){
+                    tmpSum+=occurances[i][j];
+                    if(tmpSum>0) tmpAns++;
+                    else break;
+                }
+                ans = Math.max(ans, tmpAns);
+            }
+            System.out.println(ans);
+        }
+    }
+}
+
+",1
+9f354c5c,a6532df9,"
+import java.util.*;
+
+import java.io.*;
+import java.math.*;
+import java.sql.Array;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+
+
+
+public class Solution {
+	 private static class MyScanner {
+	        private static final int BUF_SIZE = 2048;
+	        BufferedReader br;
+	 
+	        private MyScanner() {
+	            br = new BufferedReader(new InputStreamReader(System.in));
+	        }
+	 
+	        private boolean isSpace(char c) {
+	            return c == '\n' || c == '\r' || c == ' ';
+	        }
+	 
+	        String next() {
+	            try {
+	                StringBuilder sb = new StringBuilder();
+	                int r;
+	                while ((r = br.read()) != -1 && isSpace((char)r));
+	                if (r == -1) {
+	                    return null;
+	                }
+	 
+	                sb.append((char) r);
+	                while ((r = br.read()) != -1 && !isSpace((char)r)) {
+	                    sb.append((char)r);
+	                }
+	                return sb.toString();
+	            } catch (IOException e) {
+	                e.printStackTrace();
+	            }
+	            return null;
+	        }
+	 
+	        int nextInt() {
+	            return Integer.parseInt(next());
+	        }
+	 
+	        long nextLong() {
+	            return Long.parseLong(next());
+	        }
+	 
+	        double nextDouble() {
+	            return Double.parseDouble(next());
+	        }
+	    }
+	  static class Reader{
+		  
+			BufferedReader br;
+			StringTokenizer st;
+			public Reader() {
+				br = new BufferedReader(new InputStreamReader(System.in));
+			}
+			String next() 
+		    { 
+		        while (st == null || !st.hasMoreElements()) 
+		        { 
+		            try
+		            { 
+		                st = new StringTokenizer(br.readLine()); 
+		            } 
+		            catch (IOException  e) 
+		            { 
+		                e.printStackTrace(); 
+		            } 
+		        } 
+		        return st.nextToken(); 
+		    } 
+
+		    int nextInt() 
+		    { 
+		        return Integer.parseInt(next()); 
+		    } 
+
+		    long nextLong() 
+		    { 
+		        return Long.parseLong(next()); 
+		    } 
+
+		    double nextDouble() 
+		    { 
+		        return Double.parseDouble(next()); 
+		    } 
+
+		    String nextLine() 
+		    { 
+		        String str = """"; 
+		        try
+		        { 
+		            str = br.readLine(); 
+		        } 
+		        catch (IOException e) 
+		        { 
+		            e.printStackTrace(); 
+		        } 
+		        return str; 
+		    } 
+		}
+	 
+	  static long mod = (long)(1e9 + 7);
+	 
+	static void sort(long[] arr ) {
+		 ArrayList<Long> al = new ArrayList<>();
+		 for(long e:arr) al.add(e);
+		 Collections.sort(al);
+		 for(int i = 0 ; i<al.size(); i++) arr[i] = al.get(i);
+	 }
+	static void sort(int[] arr ) {
+		 ArrayList<Integer> al = new ArrayList<>();
+		 for(int e:arr) al.add(e);
+		 Collections.sort(al);
+		 for(int i = 0 ; i<al.size(); i++) arr[i] = al.get(i);
+	 }
+	
+	static void sort(char[] arr) {
+		ArrayList<Character> al = new ArrayList<Character>();
+		for(char cc:arr) al.add(cc);
+		Collections.sort(al);
+		for(int i = 0 ;i<arr.length ;i++) arr[i] = al.get(i);
+	}
+
+	static long mod_mul(  long... a) {
+		long ans = a[0]%mod;
+		for(int i = 1 ; i<a.length ; i++) {
+			ans = (ans * (a[i]%mod))%mod;
+		}
+		
+		return ans;
+	}
+	static long mod_sum( long... a) {
+		long ans = 0;
+		for(long e:a) {
+			ans = (ans + e)%mod;
+		}
+		return ans;
+	}
+	 static long gcd(long a, long b)
+	  {      
+	     if (b == 0)
+	        return a;
+	     return gcd(b, a % b); 
+	  }
+	 static boolean[] prime(int num) {
+			boolean[] bool = new boolean[num];
+		     
+		      for (int i = 0; i< bool.length; i++) {
+		         bool[i] = true;
+		      }
+		      for (int i = 2; i< Math.sqrt(num); i++) {
+		         if(bool[i] == true) {
+		            for(int j = (i*i); j<num; j = j+i) {
+		               bool[j] = false;
+		            }
+		         }
+		      }
+		      if(num >= 0) {
+		    	  bool[0] = false;
+		    	  bool[1] = false;
+		      }
+		      
+		      return bool;
+		}
+
+	 static long modInverse(long a, long m)
+	    {
+	        long g = gcd(a, m);
+	       
+	          return   power(a, m - 2, m);
+	        
+	    }
+	   static long lcm(long a , long b) {
+		   return (a*b)/gcd(a, b);
+	   }
+	   static int lcm(int a , int b) {
+		   return (int)((a*b)/gcd(a, b));
+	   }
+	 static long power(long x, long y, long m){
+	        if (y == 0) return 1; long p = power(x, y / 2, m) % m; p = (int)((p * (long)p) % m);
+	        if (y % 2 == 0) return p; else return (int)((x * (long)p) % m); }
+	   
+     static class Combinations{
+	    	 private long[] z;
+	    	 private long[] z1;
+	    	 private long[] z2;
+	    	 private long mod;
+	    	  public Combinations(long N , long mod) {
+	    		  this.mod = mod;
+				z = new long[(int)N+1];
+				z1 = new long[(int)N+1];
+				z[0] = 1;
+				for(int i =1 ; i<=N ; i++) z[i] = (z[i-1]*i)%mod;
+			     z2 = new long[(int)N+1];
+				z2[0] = z2[1] = 1;
+			    for (int i = 2; i <= N; i++)
+			        z2[i] = z2[(int)(mod % i)] * (mod - mod / i) % mod;
+			    
+			    
+			    z1[0] = z1[1] = 1;
+			    
+			    for (int i = 2; i <= N; i++)
+			        z1[i] = (z2[i] * z1[i - 1]) % mod;
+			}
+	    	  long fac(long n) {
+	    		  return z[(int)n];
+	    	  }
+	    	  long invrsNum(long n) {
+	    		  return z2[(int)n];
+	    	  }
+	    	  long invrsFac(long n) {
+	    		  return invrsFac((int)n);
+	    	  }
+	    	  long ncr(long N, long R)
+	    	  {		if(R<0 || R>N ) return 0;
+	    		    long ans = ((z[(int)N] * z1[(int)R])
+	    		              % mod * z1[(int)(N - R)])
+	    		             % mod;
+	    		    return ans;
+	    		}
+	      }
+	      static class DisjointUnionSets {
+			    int[] rank, parent;
+			    int n;
+			  
+			    public DisjointUnionSets(int n)
+			    {
+			        rank = new int[n];
+			        parent = new int[n];
+			        this.n = n;
+			        makeSet();
+			    }
+			  
+			    void makeSet()
+			    {
+			        for (int i = 0; i < n; i++) {
+			          
+			            parent[i] = i;
+			        }
+			    }
+			  
+			    int find(int x)
+			    {
+			        if (parent[x] != x) {
+			        
+			            parent[x] = find(parent[x]);
+			  
+			        }
+			  
+			        return parent[x];
+			    }
+			  
+			    void union(int x, int y)
+			    {
+			        int xRoot = find(x), yRoot = find(y);
+			  
+			        if (xRoot == yRoot)
+			            return;
+			  
+			        if (rank[xRoot] < rank[yRoot])
+			  
+			            parent[xRoot] = yRoot;
+			  
+			        else if (rank[yRoot] < rank[xRoot])
+			  
+			            parent[yRoot] = xRoot;
+			  
+			        else
+			        {
+			            parent[yRoot] = xRoot;
+			  
+			            rank[xRoot] = rank[xRoot] + 1;
+			        }
+			    }
+			}
+	      static int max(int... a ) {
+	    	  int max = a[0];
+	    	  for(int e:a) max = Math.max(max, e);
+	    	  return max;
+	      }
+	      static long max(long... a ) {
+	    	  long max = a[0];
+	    	  for(long e:a) max = Math.max(max, e);
+	    	  return max;
+	      }
+	      static int min(int... a ) {
+	    	  int min = a[0];
+	    	  for(int e:a) min = Math.min(e, min);
+	    	  return min;
+	      }
+	      static long min(long... a ) {
+	    	  long min = a[0];
+	    	  for(long e:a) min = Math.min(e, min);
+	    	  return min;
+	      }
+	      static int[] KMP(String str) {
+	    	  int n = str.length();
+	    	  int[] kmp = new int[n];
+	    	  for(int i = 1 ; i<n ; i++) {
+	    		  int j = kmp[i-1];
+	    		  while(j>0 && str.charAt(i) != str.charAt(j)) {
+	    			  j = kmp[j-1];
+	    		  }
+	    		  if(str.charAt(i) == str.charAt(j)) j++;
+	    		  kmp[i] = j;
+	    	  }
+	    	  
+	    	  return kmp;
+	      }
+	      
+	      
+/************************************************ Query **************************************************************************************/	  
+	 
+/***************************************** 		Sparse Table	********************************************************/
+	      static class SparseTable{
+	    		
+	    		private long[][] st;
+	    		
+	    		SparseTable(long[] arr){
+	    			int n = arr.length;
+	    			st = new long[n][25];
+	    			log = new int[n+2];
+	    			build_log(n+1);
+	    			build(arr);
+	    		}
+	    		
+	    		private void build(long[] arr) {
+	    			int n = arr.length;
+	    			
+	    			for(int i = n-1 ; i>=0 ; i--) {
+	    				for(int j = 0 ; j<25 ; j++) {
+	    					int r = i + (1<<j)-1;
+	    					if(r>=n) break;
+	    					if(j == 0 ) st[i][j] = arr[i];
+	    					else st[i][j] = Math.min(st[i][j-1] , st[ i + ( 1 << (j-1) ) ][ j-1 ] );
+	    				}
+	    			}
+	    		}
+	    		public long gcd(long a  ,long b) {
+	    			if(a == 0) return b;
+	    			return gcd(b%a , a);
+	    		}
+	    		public long query(int l ,int r) {
+	    			int w = r-l+1;
+	    			int power = log[w];
+	    			return Math.min(st[l][power],st[r - (1<<power) + 1][power]);
+	    		}
+	    		private int[] log;
+	    		void build_log(int n) {
+	    			log[1] = 0;
+	    			for(int i = 2 ; i<=n ; i++) {
+	    				log[i] = 1 + log[i/2];
+	    			}
+	    		}
+	    	}
+	      
+	      
+/********************************************************	Segement Tree	*****************************************************/
+/**
+	 	 static class SegmentTree{
+			 long[] tree;
+			 long[] arr;
+			 int n;
+			 SegmentTree(long[] arr){
+				 this.n = arr.length;
+				 tree = new long[4*n+1];
+				 this.arr = arr;
+				 buildTree(0, n-1, 1);
+			 }
+			 
+			 
+			  void buildTree(int s ,int e  ,int index ) {
+					if(s == e) {
+						tree[index] = arr[s];
+						return;
+					}
+				
+					int mid = (s+e)/2;
+					
+					buildTree( s,  mid, 2*index);
+					buildTree( mid+1, e, 2*index+1);
+					
+					tree[index] = Math.min(tree[2*index] , tree[2*index+1]);
+				}
+			  
+			 long query(int si ,int ei) {
+				 return query(0 ,n-1 , si ,ei , 1   );
+			 }
+			 private long query( int ss ,int se ,int qs , int qe,int index) {
+					
+					if(ss>=qs && se<=qe) return tree[index];
+					
+					if(qe<ss || se<qs) return (long)(1e17);
+					
+					int mid = (ss + se)/2;
+					long left = query( ss , mid , qs ,qe , 2*index);
+					long right= query(mid + 1 , se , qs ,qe , 2*index+1);
+					return Math.min(left, right);
+				}
+			 public void update(int index , int val) {
+				 arr[index] = val;
+				 for(long e:arr) System.out.print(e+"" "");
+				 update(index , 0 , n-1 , 1);
+			 }
+			 private void update(int id ,int si , int ei , int index) {
+				 if(id < si || id>ei) return;
+				 if(si == ei ) { 
+					 tree[index] = arr[id];
+					 return;
+				 }
+				 if(si > ei) return;
+				 int mid = (ei + si)/2;
+					
+					update( id,  si, mid , 2*index);
+					update( id , mid+1, ei , 2*index+1);
+					
+					tree[index] = Math.min(tree[2*index] ,tree[2*index+1]);
+			 }
+			  
+		 }
+		 */
+
+/* ***************************************************************************************************************************************************/	 
+	 
+//	      static MyScanner sc = new MyScanner(); // only in case of less memory
+	      static Reader sc = new Reader();
+	 static StringBuilder sb = new StringBuilder();
+	 public static void main(String args[]) throws IOException {
+
+		 int tc = 1;
+		  tc = sc.nextInt();
+
+		 for(int i = 1 ; i<=tc ; i++) {
+
+//			 sb.append(""Case #"" + i + "": ""  );	// During KickStart && HackerCup
+			 TEST_CASE();
+			  
+		 }
+		 System.out.println(sb);
+	 }
+
+	 static void TEST_CASE() {
+		int n = sc.nextInt();
+		ArrayList<ArrayList<Integer>> adj = new ArrayList<>();
+		for(int i =0 ; i<n ; i++) adj.add(new ArrayList<>());
+		int[] U = new int[n-1] , V = new int[n-1];
+		for(int i = 0 ; i<n-1 ; i++) {
+			int u = sc.nextInt()-1 , v = sc.nextInt()-1;
+			U[i] = u; V[i] = v;
+			adj.get(u).add(v);
+			adj.get(v).add(u);
+		}
+		int ind = -1;
+		for(int i =0 ; i<n ; i++) {
+			if(adj.get(i).size()>2) {
+				sb.append(""-1\n"");
+				return;
+			}
+			if(adj.get(i).size() == 1) {
+				ind = i;
+			}
+		}
+		Map<String , Integer> map = new HashMap<>();
+		dfs(adj, ind, -1, true, map);
+		for(int i =0 ; i<n-1 ; i++) {
+		 int u = U[i];
+		 int v = V[i];
+		 if(map.containsKey(u+"" ""+v)) sb.append(map.get(u+"" ""+v)+"" "");
+		 else sb.append(map.get(v+"" ""+u)+"" "");
+		}
+		sb.append(""\n"");
+		
+	 }
+	 static void dfs(ArrayList<ArrayList<Integer>> adj ,int u , int p ,boolean eve ,Map<String , Integer> map ) {
+		 if(eve) {
+			 map.put(u+"" ""+p, 2);
+		 }else {
+			 map.put(u+"" ""+p, 3);
+		 }
+		 for(int v:adj.get(u)) {
+			 if(v == p) continue;
+			 eve = !eve;
+			 dfs(adj, v, u, eve, map);
+		 }
+	 }
+	}
+/*******************************************************************************************************************************************************/
+
+/**
+1
+		
+ */
+
+ 
+
+","import java.io.*;
+import java.util.*;
+public class new1{
+	
+	
+	public static void dfs(ArrayList<ArrayList<int[]> > aList1, int p, int u, int[] ans, int v) {
+		int[] aa = aList1.get(u).get(0);
+		if(aa[0] != p) {
+			ans[aa[1]] = v;
+			if(v == 2) dfs(aList1, u, aa[0], ans, 3);
+			else dfs(aList1, u, aa[0], ans, 2);
+		}
+		else if(aList1.get(u).size() > 1){
+			aa = aList1.get(u).get(1);
+			ans[aa[1]] = v;
+			if(v == 2) dfs(aList1, u, aa[0], ans, 3);
+			else dfs(aList1, u, aa[0], ans, 2);
+		}
+		
+		
+	}
+	
+	public static void main(String[] args)  throws IOException{
+
+		
+		BufferedWriter output = new BufferedWriter(new OutputStreamWriter(System.out));
+		FastReader s = new FastReader();
+		int t = s.nextInt();
+		for(int z = 0; z < t; z++) {
+			int n = s.nextInt();
+			ArrayList<ArrayList<int[]> > aList1 =  new ArrayList<ArrayList<int[]> >(n + 1);
+			
+	        for (int j = 1; j <= n + 1; j++) { 
+	            ArrayList<int[]> list = new ArrayList<>();
+	            aList1.add(list);
+	        }
+		
+			for(int j = 0; j < n - 1; j ++) {
+				int u = s.nextInt();
+				int v = s.nextInt();
+				int[] aa = {v, j};
+				int[] bb = {u, j};
+				aList1.get(u).add(aa);
+				aList1.get(v).add(bb);
+			}
+			int pos = 1; int ind = -1;
+			for(int i = 1; i <= n; i++) {
+				if(aList1.get(i).size() > 2) {
+					pos = 0;
+					break;
+				}
+				if(aList1.get(i).size() == 1) {
+					ind = i;
+				}
+			}
+			if(pos == 0) {
+				output.write(-1 + ""\n"");
+			}
+			else {
+				int[] ans = new int[n - 1];
+				dfs(aList1, -1, ind, ans, 2);
+				for(int i = 0; i < n - 1; i++) {
+					output.write(ans[i] + "" "");
+				}
+				output.write(""\n"");
+			}
+			
+			
+			
+		}
+	   output.flush();
+	  }
+}
+
+
+ 
+	class FastReader {
+	    BufferedReader br;
+	    StringTokenizer st;
+	    public FastReader() {
+	        br = new BufferedReader(new InputStreamReader(System.in));
+	    }
+	    String next() {
+	        while (st == null || !st.hasMoreElements()) {
+	            try {
+	                st = new StringTokenizer(br.readLine());
+	            } catch (IOException e) {
+	                e.printStackTrace();
+	            }
+	        }
+	        return st.nextToken();
+	    }
+	 
+	    public int nextInt() {
+	        return Integer.parseInt(next());
+	    }
+	 
+	    long nextLong() {
+	        return Long.parseLong(next());
+	    }
+	 
+	    double nextDouble() {
+	        return Double.parseDouble(next());
+	    }
+	 
+	    String nextLine() {
+	        String str = """";
+	        try {
+	            str = br.readLine();
+	        } catch (IOException e) {
+	            e.printStackTrace();
+	        }
+	        return str;
+	}}",0
+a3e272af,d1cd194e,"
+import java.io.*;
+import java.util.*;
+
+public class Asd {
+
+    static PrintWriter w = new PrintWriter(System.out);
+    static FastScanner s = new FastScanner();
+    static boolean sd = false;
+  
+    public static void main(String[] args) {
+
+       int t = s.nextInt();
+        //int t=1;
+        while (t-- > 0) {
+            solve();
+        }
+        w.close();
+
+    }
+  public static class Student {
+    public int i1;
+    public int value;
+          
+    // A parameterized student constructor
+    public Student(int i1,int i2) {
+      
+        this.i1 = i1;
+        this.value=i2;
+    }
+      
+    public int getkey() {
+        return i1;
+    } 
+    public int getValue() {
+        return value;
+    } 
+}
+   static class StudentComparator implements Comparator<Student>{
+              
+            // Overriding compare()method of Comparator 
+                        // for descending order of cgpa
+        @Override   
+        public int compare(Student s1, Student s2) {
+                if (s1.i1 < s2.i1)
+                    return -1;
+                else if (s1.i1 >s2.i1)
+                    return 1;
+                                return 0;
+                }
+        }
+    
+    /* Function to print all the permutations of the string
+     static String swap(String str, int i, int j)
+     {
+     char ch;
+     char[] array = str.toCharArray();
+     ch = array[i];
+     array[i] = array[j];
+     array[j] = ch;
+     return String.valueOf(array);
+     }
+    
+     static void permute(String str,int low,int high)
+     {
+     if(low == high)
+     list.add(Long.parseLong(str));
+ 
+     int i;
+     for(i = low; i<=high; i++){
+     str = swap(str,low,i);
+     permute(str, low+1,high);
+     str = swap(str,low,i);
+     }
+     }
+     use  permute(str2,0,str2.length()-1); to perform combinations
+     */
+
+    public static void solve() {
+        int n=s.nextInt();
+        int m=s.nextInt();
+        int x=s.nextInt();
+        int arr[]=new int[n];int res[]=new int[n];
+        for(int i=0;i<n;i++)
+            arr[i]=s.nextInt();
+        
+        PriorityQueue<Student> pq=new PriorityQueue<Student>(new StudentComparator());
+        for(int i=0;i<m;i++){
+            pq.add(new Student(arr[i],i));res[i]=i;}
+        for(int i=m;i<n;i++)
+        {
+            Student s1=pq.poll();
+            int k2=s1.getkey()+arr[i];
+            int v2=s1.getValue();res[i]=v2;
+            pq.add(new Student(k2,v2));
+        }
+        w.println(""YES"");
+        for(int i=0;i<n;i++)
+            w.print(res[i]+1+"" "");
+        w.println();
+       
+    }
+
+    static void call(ArrayList<Integer> t, ArrayList<Integer> m) {
+        if (t.size() == 0 && m.size() == 0) {
+            sd = true;
+            return;
+        }
+        t.remove(0);
+        t.remove(t.size() - 1);
+        call(t, new ArrayList<Integer>(m.subList(0, m.size() - 1)));
+        call(t, new ArrayList<Integer>(m.subList(1, m.size())));
+    }
+
+    static long gcd(long a, long b) {
+        if (b == 0) {
+            return a;
+        }
+        return gcd(b, a % b);
+    }
+
+    static int noofdivisors(int n) {
+            //it counts no of divisors of every number upto number n
+
+        int arr[] = new int[n + 1];
+        for (int i = 1; i <= (n); i++) {
+            for (int j = i; j <= (n); j = j + i) {
+                arr[j]++;
+            }
+        }
+        return arr[0];
+    }
+
+    static char[] reverse(char arr[]) {
+        char[] b = new char[arr.length];
+        int j = arr.length;
+        for (int i = 0; i < arr.length; i++) {
+            b[j - 1] = arr[i];
+            j = j - 1;
+        }
+        return b;
+    }
+
+    static long factorial(int n) {
+        long su = 1;
+        for (int i = 1; i <= n; i++) {
+            su *= (long) i;
+        }
+        return su;
+    }
+
+    static class FastScanner {
+
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st = new StringTokenizer("""");
+
+        public String next() {
+            while (!st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        long[] readArray(int n) {
+            long[] a = new long[n];
+            for (int i = 0; i < n; i++) {
+                a[i] = nextLong();
+            }
+            return a;
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+    }
+
+}
+","import java.util.*;
+
+import java.lang.*;
+import java.io.*;
+
+public class Template {
+	
+	static class FastReader {
+  BufferedReader br;
+  StringTokenizer st;
+
+  public FastReader()
+  {
+      br = new BufferedReader(
+          new InputStreamReader(System.in));
+  }
+
+  String next()
+  {
+      while (st == null ||!st.hasMoreElements()) {
+          try {
+              st = new StringTokenizer(br.readLine());
+          }
+          catch (IOException e) {
+              e.printStackTrace();
+          }
+      }
+      return st.nextToken();
+  }
+
+  int nextInt() { return Integer.parseInt(next()); }
+
+  long nextLong() { return Long.parseLong(next()); }
+
+  double nextDouble()
+  {
+      return Double.parseDouble(next());
+  }
+
+  String nextLine()
+  {
+      String str = """";
+      try {
+          str = br.readLine();
+      }
+      catch (IOException e) {
+          e.printStackTrace();
+      }
+      return str;
+  }
+  
+}
+	
+//	static void solve(String s) 
+//	{
+////		Scanner sc = new Scanner(System.in);
+////		String s = sc.next();
+//		
+//		int x[] = new int[2];
+//		x[0] = x[1] = -1;
+//		
+//		int ans = 0;
+//		int n = s.length();
+//		for(int i=0;i<n;i++)
+//		{
+//			int c = s.charAt(i) - '0';
+//			if(c == 1 || c == 0)
+//			{
+//				x[(i%2) ^ c] = i;
+//			}
+//			int min = Math.min(x[0], x[1]);
+//			ans += i - min;
+//			//System.out.println(ans);
+//		}
+//		System.out.println(ans);
+//	}
+//	
+
+//	    public static void main(String args[])
+//	    {
+//	    	FastReader sc = new FastReader();
+//	    	//solve();
+//	    	//Scanner sc = new Scanner(System.in)
+//	       int testcases = sc.nextInt();  // nTest is the number of treasure hunts.
+//	      
+////	    	int testcases = 3;
+//	        while(testcases-- > 0)
+//	        {
+//	        	String s = sc.next();
+//	        	solve(s);
+//	        	
+//	        }
+//	    
+//	    }
+	
+	static class Pair implements Comparable<Pair>
+	{
+		int h;
+		int ind;
+		
+		Pair(int h, int ind)
+		{
+			this.h = h;
+			this.ind = ind;
+		}
+		@Override
+		public int compareTo(Pair o) {
+			
+			return this.h - o.h;
+		}
+		
+		
+	}
+	public static void main(String[] args) {
+
+		FastReader fs=new FastReader();
+
+		int T=fs.nextInt();
+
+		for (int tt=0; tt<T; tt++) {
+		int n = fs.nextInt();
+		int m = fs.nextInt();
+		int x = fs.nextInt();
+		
+		if(n < m)
+		{
+			System.out.println(""NO"");
+			continue;
+		}
+		Pair a[] = new Pair[n];
+		PriorityQueue<Pair> heap = new PriorityQueue<>();
+		for(int i=0;i<n;i++)
+		{
+			a[i] = new Pair(fs.nextInt(), i);
+			
+		}
+		
+		Arrays.sort(a);
+		for(int i=1;i<=m;i++)
+		{
+			heap.add(new Pair(0, i));
+		}
+		int max = Integer.MIN_VALUE;
+		int min = Integer.MAX_VALUE;
+		int ans[] = new int[n];
+		int idx = 0;
+		while(!heap.isEmpty() && idx < n)
+		{
+			Pair curr = heap.poll();
+			curr.h += a[idx].h;
+			ans[a[idx].ind] = curr.ind;
+			heap.add(new Pair(curr.h,  curr.ind));
+			idx++;
+		}
+			
+		
+		
+//		int towers[] = new int[m+1];
+//		int tower = 1;
+//		boolean flag = false;
+//		boolean inc = true;
+//		for(int i=0;i<n;i++)
+//		{
+//			if(tower == m+1)
+//			{
+//				tower = m;
+//				inc = false;
+//			}
+//			if(tower == 0)
+//			{
+//				tower = 1;
+//				inc = true;
+//			}
+//			towers[tower] += a[i].h;
+//			System.out.println(a[i].h +"" THis"" + tower);
+////			min = Math.min(min, towers[tower]);
+////			max = Math.max(max, towers[tower]);
+//			ans[a[i].ind] = tower;
+////			if(Math.abs(max - min) > x)
+////			{
+////				System.out.println(""NO"" + a[i].ind+"" ""+a[i].h +"" ""+min +"" ""+max);
+////				flag = true;
+////				break;
+////			}
+//			if(inc)
+//				tower++;
+//			else
+//				tower--;
+//		}
+//		for(int i=1;i<=m;i++)
+//		{
+//			min = Math.min(min, towers[i]);
+//			max = Math.max(max, towers[i]);
+//		}
+//		if(Math.abs(max - min) > x)
+//			{
+//				System.out.println(""NO"" + max+"" ""+min);// + a[i].ind+"" ""+a[i].h +"" ""+min +"" ""+max);
+//				//flag = true;
+//				continue;
+//			}
+//		if(flag)
+//			continue;
+		System.out.println(""YES"");
+		for(int i:ans)
+			System.out.print(i+"" "");
+		
+		System.out.println();
+
+		}
+	
+}
+}
+",0
+6255ee79,ac8ef97c,"
+import java.io.*;
+import java.util.*;
+
+
+
+public class Test2  {
+	static class node{
+		int l,r;
+		ArrayList<Integer> child;
+		node(int l,int r){
+			child = new  ArrayList<Integer>();
+			this.l = l;
+			this.r = r;
+		}
+	}
+	  static FastReader f = new FastReader();
+	public static void main(String[] args) throws IOException {	
+		int t =f.nextInt();
+		while(t-->0) {
+			int n = f.nextInt();
+			ArrayList<node> arr = new  ArrayList<node>();
+			for(int i = 0;i<n;i++) {
+				int l = f.nextInt(),r = f.nextInt();
+				arr.add(new node(l,r));
+			}
+			for(int i = 0;i<n-1;i++) {
+				int u = f.nextInt()-1,v = f.nextInt()-1;
+				arr.get(u).child.add(v);
+				arr.get(v).child.add(u);
+			}
+			long dp[][] = new long[n][2];
+			for(int i = 0;i<n;i++)Arrays.fill(dp[i],-1);
+			long min = 0;
+			long max = 0;
+			for(int e:arr.get(0).child) {
+				 min+=fun(arr, e, 0, arr.get(0).l,dp);
+			}
+			for(int e:arr.get(0).child) {
+				 max+=fun(arr, e, 0, arr.get(0).r,dp);
+			}
+			System.out.println(Math.max(min, max));
+	     }
+     }
+   static long fun(ArrayList<node> arr,int i,int p,int pre,long dp[][]) {
+	   long min = 0,max = 0;
+	   if(dp[i][0]!=-1) {
+		   min = dp[i][0];
+	   }else {
+	   for(int e:arr.get(i).child) {
+		   if(e!=p) {
+			   min+=fun(arr, e, i, arr.get(i).l,dp);
+		   }
+	   }
+	   dp[i][0] =min;
+	   }
+	   if(dp[i][1]!=-1) {
+		   max = dp[i][1];
+	   }else {
+	   for(int e:arr.get(i).child) {
+		   if(e!=p) {
+			   max+=fun(arr, e, i, arr.get(i).r,dp);
+		   }
+	   }dp[i][1] = max;
+	   }
+	   min+=(Math.abs(arr.get(i).l-pre));
+	   max +=Math.abs(arr.get(i).r-pre);
+	   //System.out.println(min+"" max = ""+max+"" i = ""+i+"" per =""+p+"" pre = ""+pre);
+	   return Math.max(min, max);
+   }
+	static ArrayList<Integer> primeFectors(int n){
+		ArrayList<Integer> ret = new ArrayList<Integer>();
+		while (n%2==0)
+        {
+           ret.add(2);
+            n /= 2;
+        }
+		for (int i = 3; i <= Math.ceil(Math.sqrt(n)); i+= 2)
+        {
+			
+            // While i divides n, print i and divide n
+            while (n%i==0)
+            {
+                ret.add(i);
+                n /= i;
+            }
+        }
+		 if (n > 2)
+	            ret.add(n);
+		return ret;
+	}
+	static class FastReader 
+    { 
+         BufferedReader br; 
+        StringTokenizer st; 
+        public FastReader() 
+        { 
+            br = new BufferedReader(new
+                     InputStreamReader(System.in)); 
+        } 
+        String next() 
+        { 
+            while (st == null || !st.hasMoreElements()) 
+            { 
+                try
+                { 
+                    st = new StringTokenizer(br.readLine()); 
+                } 
+                catch (IOException  e) 
+                { 
+                    e.printStackTrace(); 
+                } 
+            } 
+            return st.nextToken(); 
+        } 
+        int nextInt() 
+        { 
+            return Integer.parseInt(next()); 
+        } 	  
+        long nextLong() 
+        { 
+            return Long.parseLong(next()); 
+        } 
+        double nextDouble() 
+        { 
+            return Double.parseDouble(next()); 
+        } 
+        String nextLine() 
+        { 
+            String str = """"; 
+            try
+            { 
+                str = br.readLine(); 
+            } 
+            catch (IOException e) 
+            { 
+                e.printStackTrace(); 
+            } 
+            return str; 
+        } 
+    }
+}
+
+
+
+","import java.io.*;
+import java.util.*;
+
+public class Codeforces
+{
+    public static void main(String args[])throws Exception
+    {
+        BufferedReader bu=new BufferedReader(new InputStreamReader(System.in));
+        StringBuilder sb=new StringBuilder();
+        int t=Integer.parseInt(bu.readLine());
+        while(t-->0)
+        {
+            int n=Integer.parseInt(bu.readLine());
+            g=new ArrayList[n];
+            int i;
+            for(i=0;i<n;i++)
+            {
+                g[i]=new ArrayList<>();
+                String st[]=bu.readLine().split("" "");
+                a[i][0]=Integer.parseInt(st[0]); a[i][1]=Integer.parseInt(st[1]);
+                s[i][0]=s[i][1]=0;
+            }
+
+            for(i=0;i<n-1;i++)
+            {
+                String st[]=bu.readLine().split("" "");
+                int u=Integer.parseInt(st[0])-1,v=Integer.parseInt(st[1])-1;
+                g[u].add(v); g[v].add(u);
+            }
+
+            dfs(0,-1);
+            sb.append(Math.max(s[0][0],s[0][1])+""\n"");
+        }
+        System.out.print(sb);
+    }
+
+    static ArrayList<Integer> g[];
+    static int N=100000,a[][]=new int[N][2];
+    static long s[][]=new long[N][2];
+    static void dfs(int n,int p)
+    {
+        for(int x:g[n])
+        if(x!=p)
+        {
+            dfs(x,n);
+            s[n][0]+=Math.max(s[x][0]+Math.abs(a[x][0]-a[n][0]),s[x][1]+Math.abs(a[x][1]-a[n][0]));
+            s[n][1]+=Math.max(s[x][0]+Math.abs(a[x][0]-a[n][1]),s[x][1]+Math.abs(a[x][1]-a[n][1]));
+        }
+    }
+}
+",0
+b434c275,f8c99dd0,"import java.io.*;
+import java.util.*;
+
+
+
+import java.math.*;
+import java.math.BigInteger;
+
+
+public final class A
+{    
+	static PrintWriter out = new PrintWriter(System.out); 
+	static StringBuilder ans=new StringBuilder();
+	static FastReader in=new FastReader();
+	static ArrayList<Integer> g[];
+	static long mod=(long)1e9+7,INF=Long.MAX_VALUE;
+	static boolean set[],col[]; 
+	static int par[],tot[],partial[];
+	static int D[],P[][];
+	static long dp[][],sum=0,max=0,size[];
+	//	static node1 seg[];
+	//static pair moves[]= {new pair(-1,0),new pair(1,0), new pair(0,-1), new pair(0,1)};
+	public static void main(String args[])throws IOException
+	{				
+
+
+	
+		int T=i();
+		outer:while(T-->0)
+		{
+			int N=i();
+			int size[]=new int[N];
+			PriorityQueue<node1> q[]=new PriorityQueue[26];
+			for(int i=0; i<26; i++)q[i]=new PriorityQueue<node1>();
+			for(int i=0; i<N; i++)
+			{
+				char X[]=in.next().toCharArray();
+				int s=X.length;
+				size[i]=s;
+				int f[]=new int[26];
+				for(char x:X)f[x-'a']++;
+				for(int j=0; j<26; j++)q[j].add(new node1(f[j],i,s));
+			}
+			
+			int max=0;
+			for(int i=0; i<26; i++)
+			{
+				PriorityQueue<node1> q_new=new PriorityQueue<>();
+				q_new=q[i];
+				int c=0;
+				long f=0;
+				while(q_new.size()>0)
+				{
+					node1 x=q_new.remove();
+//					System.out.println(x.f+"" ""+x.size+"" ""+x.a);
+					f+=x.a;
+					if(f>0)
+					{
+						c++;
+						max=Math.max(max, c);
+					}
+					else break;
+				}
+			}
+			out.println(max);
+		}
+		out.close();
+
+	}
+	static int OR(int i,int j)
+	{
+		if(i>j)
+		{
+			int t=i;
+			i=j;
+			j=t;
+		}
+		System.out.println(""OR ""+i+"" ""+j);
+		return i();
+	}
+	static int AND(int i,int j)
+	{
+		if(i>j)
+		{
+			int t=i;
+			i=j;
+			j=t;
+		}
+		System.out.println(""AND ""+i+"" ""+j);
+		return i();
+	}
+	static int XOR(int i,int j)
+	{
+		if(i>j)
+		{
+			int t=i;
+			i=j;
+			j=t;
+		}
+		System.out.println(""XOR ""+i+"" ""+j);
+		return i();
+	}
+
+	static boolean f1(int l,char X[])
+	{
+		int i=0;
+		for(; l<X.length; l++)
+		{
+			if(X[i]!=X[l])return false;
+			i++;
+		}
+		return true;
+	}
+	static int f(int a)
+	{
+		for(int i=a+1; a>0; a++)
+		{
+			if(GCD(i,a)==1)return i;
+		}
+		return 0;
+	}
+	static int min(char X[],char str[],int N)
+	{
+		int s=0;
+		for(int i=0; i<N; i++)
+		{
+			int it=i%3;
+			if(X[i]!=str[it])s++;
+			//             ans.append(str[it]);
+		}
+		return s;
+	}
+	static char f(int i,char X[])
+	{
+		int a=0,b=0,c=0;
+		for(; i<X.length; i+=3)
+		{
+			if(X[i]=='R')a++;
+			if(X[i]=='B')b++;
+			if(X[i]=='G')c++;
+		}
+		if(a>=b && a>=c)return 'R';
+		if(b>=a && b>=c)return 'B';
+		return 'G';
+	}
+
+
+	static void f1(int n,int p,long sum,int N)
+	{
+		for(int c:g[n])
+		{
+			if(c==p)continue;
+
+			long s=sum+N-2*size[c];
+			f1(c,n,s,N);
+			max=Math.max(max, s);
+		}
+	}
+	static long f(int i,int j,ArrayList<Integer> A)
+	{
+
+		if(i+1==A.size())
+		{
+			return j;
+		}		
+		int moves=1+A.get(i);
+		if(j==1)return 1+f(i+1,moves,A);
+		if(j>0 && dp[i][j-1]==0)f(i,j-1,A);
+		return dp[i][j]=dp[i][j-1]+f(i+1,j+moves,A);
+	}
+	//	static void build(int v,int tl,int tr,long A[])
+	//	{
+	//		if(tl==tr)
+	//		{
+	//			seg[v]=new node1(A[tl],A[tr],1,true);
+	//			return ;
+	//		}
+	//		int tm=(tl+tr)/2;
+	//		build(2*v,tl,tm,A);
+	//		build(2*v+1,tm+1,tr,A);
+	//		seg[v]=merge(seg[2*v],seg[2*v+1]);
+	//	}
+	//	static node1 ask(int v,int tl,int tr,int l,int r)
+	//	{
+	//		if(l>r)return new node1(0,0,0,false);//verify true or false
+	//		if(tl==l && tr==r)return seg[v];
+	//		int tm=(tl+tr)/2;
+	//		node1 a=ask(v*2,tl,tm,l,Math.min(tm, r));
+	//		node1 b=ask(v*2+1,tm+1,tr,Math.max(tm+1, l),r);
+	//		return merge(a,b);
+	//	}
+	//	static node1 merge(node1 a,node1 b)
+	//	{
+	//		long s=0;
+	//		long l1=a.L,r1=a.R,c1=a.cnt;
+	//		long l2=b.L,r2=b.R,c2=b.cnt;
+	//		long g=GCD(l2,r1); s=c1+c2;
+	//		if(g==1)
+	//		{
+	//			s--;
+	//			g=(l2*r1)/g;
+	//			if(c1==1)
+	//			{
+	//				l1=g;
+	//			}
+	//			if(c2==1)r2=g;
+	//			return new node1(l1,r2,s,true);
+	//		}
+	//		return new node1(l1,r2,s,a.leaf^b.leaf);
+	//	}
+	static long f(long l,long r,long a,long b,long N)
+	{
+		while(r-l>1)
+		{
+			long m=(l+r)/2;
+			long x=m*b;
+			if(N<x)
+			{
+				r=m;
+				continue;
+			}
+			if((N-x)%a==0)r=m;
+			else l=m;
+
+		}
+		return r;
+	}
+	static long f1(long a,long A[],long bits[],long sum)
+	{
+		long s=A.length;
+		s=mul(s,a);
+		s=(s+(sum%mod))%mod;
+		long p=1L;
+		for(long x:bits)
+		{
+			if((a&p)!=0)s=((s-mul(x,p))+mod)%mod;
+			p<<=1;
+		}
+		return s;
+	}
+	static long f2(long a,long A[],long bits[])
+	{
+		long s=0;
+		long p=1L;
+		for(long x:bits)
+		{
+			if((a&p)!=0)
+			{
+				s=(s+mul(p,x))%mod;
+			}
+			p<<=1;
+		}
+		return s;
+	}
+	static long f(long x1,long y1,long x2,long y2)
+	{
+		return Math.abs(x1-x2)+Math.abs(y1-y2);
+	}
+	static long f(long x,long max,long s)
+	{
+		long l=-1,r=(x/s)+1;
+		while(r-l>1)
+		{
+			long m=(l+r)/2;
+			if(x-m*s>max)l=m;
+			else r=m;
+		}
+		return l+1;
+	}
+	static int f(long A[],long x)
+	{
+		int l=-1,r=A.length;
+		while(r-l>1)
+		{
+			int m=(l+r)/2;
+			if(A[m]>=x)r=m;
+			else l=m;			
+		}
+		return r;
+	}
+
+
+
+	static int bin(int x,ArrayList<Integer> A)
+	{
+		int l=0,r=A.size()-1;
+		while(l<=r)
+		{
+			int m=(l+r)/2;
+			int a=A.get(m);
+			if(a==x)return m;
+			if(a<x)l=m+1;
+			else r=m-1;
+		}
+		return 0;
+	}
+	static int left(int x,ArrayList<Integer> A)
+	{
+		int l=-1,r=A.size();
+		while(r-l>1)
+		{
+			int m=(l+r)/2;
+			int a=A.get(m);
+			if(a<=x)l=m;
+			else r=m;
+		}
+		return l;
+	}
+	static int right(int x,ArrayList<Integer> A)
+	{
+		int l=-1,r=A.size();
+		while(r-l>1)
+		{
+			int m=(l+r)/2;
+			int a=A.get(m);
+			if(a<x)l=m;
+			else r=m;
+		}
+		return r;
+	}
+
+
+
+	static boolean equal(long A[],long B[])
+	{
+		for(int i=0; i<A.length; i++)if(A[i]!=B[i])return false;
+		return true;	
+	}
+
+
+	static int max(int a ,int b,int c,int d)
+	{
+		a=Math.max(a, b);
+		c=Math.max(c,d);
+		return Math.max(a, c);
+	}
+	static int min(int a ,int b,int c,int d)
+	{
+		a=Math.min(a, b);
+		c=Math.min(c,d);
+		return Math.min(a, c);
+	}
+
+
+
+	static HashMap<Integer,Integer> Hash(int A[])
+	{
+		HashMap<Integer,Integer> mp=new HashMap<>();
+		for(int a:A)
+		{
+			int f=mp.getOrDefault(a,0)+1;
+			mp.put(a, f);
+		}
+		return mp;
+	}
+	static long mul(long a, long b)
+	{
+		return ( a %mod * 1L * b%mod )%mod;
+	}
+	static void swap(int A[],int a,int b)
+	{
+		int t=A[a];
+		A[a]=A[b];
+		A[b]=t;
+	}
+
+
+	static int find(int a)
+	{
+		if(par[a]<0)return a;
+		return par[a]=find(par[a]);
+	}
+	static void union(int a,int b)
+	{
+		a=find(a);
+		b=find(b);
+		if(a!=b)
+		{
+			par[a]+=par[b];
+			par[b]=a;
+		}
+	}
+	static boolean isSorted(int A[])
+	{
+		for(int i=1; i<A.length; i++)
+		{
+			if(A[i]<A[i-1])return false;
+		}
+		return true;
+	}
+
+	static boolean isDivisible(StringBuilder X,int i,long num)
+	{
+		long r=0;
+		for(; i<X.length(); i++)
+		{
+			r=r*10+(X.charAt(i)-'0');
+			r=r%num;
+		}
+		return r==0;
+	}    
+
+
+
+	static int lower_Bound(int A[],int low,int high, int x) 
+	{ 
+		if (low > high) 
+			if (x >= A[high]) 
+				return A[high]; 
+
+		int mid = (low + high) / 2; 
+
+		if (A[mid] == x) 
+			return A[mid]; 
+
+		if (mid > 0 && A[mid - 1] <= x && x < A[mid]) 
+			return A[mid - 1]; 
+
+		if (x < A[mid]) 
+			return lower_Bound( A, low, mid - 1, x); 
+
+		return lower_Bound(A, mid + 1, high, x); 
+	} 
+
+	static String f(String A)
+	{
+		String X="""";
+		for(int i=A.length()-1; i>=0; i--)
+		{
+			int c=A.charAt(i)-'0';
+			X+=(c+1)%2;
+		}
+		return X;
+	}
+
+	static void sort(long[] a) //check for long
+	{
+		ArrayList<Long> l=new ArrayList<>();
+		for (long i:a) l.add(i);
+		Collections.sort(l);
+		for (int i=0; i<a.length; i++) a[i]=l.get(i);
+	}
+
+	static String swap(String X,int i,int j)
+	{
+		char ch[]=X.toCharArray();
+		char a=ch[i];
+		ch[i]=ch[j];
+		ch[j]=a;
+		return new String(ch);
+	}
+
+	static int sD(long n)  
+	{  
+
+		if (n % 2 == 0 )  
+			return 2;  
+
+		for (int i = 3; i * i <= n; i += 2) {  
+			if (n % i == 0 )  
+				return i;  
+		}  
+
+		return (int)n;  
+	}  
+
+	static void setGraph(int N)
+	{
+		tot=new int[N+1];
+		partial=new int[N+1];
+		D=new int[N+1];
+		P=new int[N+1][(int)(Math.log(N)+10)];
+		set=new boolean[N+1];
+		g=new ArrayList[N+1];
+		for(int i=0; i<=N; i++)
+		{
+
+			g[i]=new ArrayList<>();		
+			D[i]=Integer.MAX_VALUE;
+			//D2[i]=INF;
+		}
+	}
+
+
+
+	static  long pow(long a,long b)
+	{
+		//long mod=1000000007;
+		long pow=1;
+		long x=a;
+		while(b!=0)
+		{
+			if((b&1)!=0)pow=(pow*x)%mod;
+			x=(x*x)%mod;
+			b/=2;
+		}
+		return pow;
+	}
+
+	static long toggleBits(long x)//one's complement || Toggle bits
+	{
+		int n=(int)(Math.floor(Math.log(x)/Math.log(2)))+1;
+
+		return ((1<<n)-1)^x;
+	}
+
+	static int countBits(long a)
+	{
+		return (int)(Math.log(a)/Math.log(2)+1);
+	}
+
+	static long fact(long N)
+	{ 
+		long n=2; 
+		if(N<=1)return 1;
+		else
+		{
+			for(int i=3; i<=N; i++)n=(n*i)%mod;
+		}
+		return n;
+	}
+
+	static int kadane(int A[])
+	{
+		int lsum=A[0],gsum=A[0];
+		for(int i=1; i<A.length; i++)
+		{
+			lsum=Math.max(lsum+A[i],A[i]);
+			gsum=Math.max(gsum,lsum);
+		}
+		return gsum;
+	}
+
+	static void sort(int[] a) {
+		ArrayList<Integer> l=new ArrayList<>();
+		for (int i:a) l.add(i);
+		Collections.sort(l);
+		for (int i=0; i<a.length; i++) a[i]=l.get(i);
+	}
+
+	static boolean isPrime(long N)
+	{
+		if (N<=1)  return false; 
+		if (N<=3)  return true; 
+		if (N%2 == 0 || N%3 == 0) return false; 
+		for (int i=5; i*i<=N; i=i+6) 
+			if (N%i == 0 || N%(i+2) == 0) 
+				return false; 
+		return true; 
+	}
+	static void print(char A[])
+	{
+		for(char c:A)System.out.print(c+"" "");
+		System.out.println();
+	}
+	static void print(boolean A[])
+	{
+		for(boolean c:A)System.out.print(c+"" "");
+		System.out.println();
+	}
+	static void print(int A[])
+	{
+		for(int a:A)System.out.print(a+"" "");
+		System.out.println();	
+	}
+	static void print(long A[])
+	{
+		for(long i:A)System.out.print(i+ "" "");
+		System.out.println();
+
+	}
+	static void print(ArrayList<Integer> A)
+	{
+		for(int a:A)System.out.print(a+"" "");
+		System.out.println();
+	}
+
+	static int i()
+	{
+		return in.nextInt();
+	}
+
+	static long l()
+	{
+		return in.nextLong();
+	}
+
+	static int[] input(int N){
+		int A[]=new int[N];
+		for(int i=0; i<N; i++)
+		{
+			A[i]=in.nextInt();
+		}
+		return A;
+	}
+
+	static long[] inputLong(int N)     {
+		long A[]=new long[N];
+		for(int i=0; i<A.length; i++)A[i]=in.nextLong();
+		return A;
+	}
+
+	static long GCD(long a,long b) 
+	{
+		if(b==0)
+		{
+			return a;
+		}
+		else return GCD(b,a%b );
+	}
+
+}
+class node1 implements Comparable<node1>
+{
+	int index,f,size;
+	long a;
+	node1(int f,int i,int size)
+	{
+		this.f=f;
+		this.index=i;
+		this.size=size;
+		a=2*f-size;
+	}
+	public int compareTo(node1 x)
+	{
+		if(this.a==x.a)return 0;
+		else if(this.a<x.a)return 1;
+		else return -1;
+	}
+}
+
+
+//Code For FastReader
+//Code For FastReader
+//Code For FastReader
+//Code For FastReader
+class FastReader
+{
+	BufferedReader br;
+	StringTokenizer st;
+	public FastReader()
+	{
+		br=new BufferedReader(new InputStreamReader(System.in));
+	}
+
+	String next()
+	{
+		while(st==null || !st.hasMoreElements())
+		{
+			try
+			{
+				st=new StringTokenizer(br.readLine());
+			}
+			catch(IOException e)
+			{
+				e.printStackTrace();
+			}
+		}
+		return st.nextToken();
+	}
+
+	int nextInt()
+	{
+		return Integer.parseInt(next());
+	}
+
+	long nextLong()
+	{
+		return Long.parseLong(next());
+	}
+
+	double nextDouble()
+	{
+		return Double.parseDouble(next());
+	}
+
+	String nextLine()
+	{
+		String str="""";
+		try
+		{
+			str=br.readLine();
+		}
+		catch (IOException e)
+		{
+			e.printStackTrace();
+		}
+		return str;
+	}
+
+}
+","import java.util.*;
+import java.io.*;
+
+public class Solution {
+  static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+  public static void solve() throws IOException {
+    int n = Integer.parseInt(br.readLine());
+    ArrayList<int[]> words = new ArrayList<>();
+    ArrayList<Integer> lens = new ArrayList<>();
+    //count [a,b,c,d,e]
+    for (int i = 0; i < n; i++) {
+      String temp = br.readLine();
+      int[] word = new int[5];
+      for (int j = 0; j < temp.length(); j++) {
+        word[(int)(temp.charAt(j)) - 97]++;
+      }
+      words.add(word);
+      lens.add(temp.length());
+    }
+    int ans = 0;
+    for (int i = 0; i < 5; i++) {
+      ArrayList<Integer> sums = new ArrayList<>();
+      //target occ - other occ
+      for (int j = 0; j < words.size(); j++) {
+        sums.add(words.get(j)[i] - (lens.get(j) - words.get(j)[i]));
+      }
+      Collections.sort(sums);
+      int loc = 0;
+      int run = 0;
+      for (int j = sums.size() - 1; j >= 0; j--) {
+        if(run + sums.get(j) > 0) {
+          loc++;
+          run += sums.get(j);
+        }
+        else break;
+      }
+      ans = Math.max(ans, loc);
+    }
+    System.out.println(ans);
+  }
+  public static void main(String[] args) throws IOException {
+    int t = Integer.parseInt(br.readLine());
+    for (int i = 0; i < t; i++) {
+      solve();
+    }
+  }
+}
+",0
+b728ba1d,d04e5afb,"import java.io.OutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.PrintWriter;
+import java.util.InputMismatchException;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Objects;
+import java.util.Collections;
+import java.io.InputStream;
+
+public class Main {
+    public static void main(String[] args) {
+        InputStream inputStream = System.in;
+        OutputStream outputStream = System.out;
+        FastReader in = new FastReader(inputStream);
+        PrintWriter out = new PrintWriter(outputStream);
+        CPhoenixAndTowers solver = new CPhoenixAndTowers();
+        int testCount = Integer.parseInt(in.next());
+        for (int i = 1; i <= testCount; i++)
+            solver.solve(i, in, out);
+        out.close();
+    }
+
+    static class CPhoenixAndTowers {
+        public void solve(int testNumber, FastReader in, PrintWriter out) {
+            int n = in.nextInt(), m = in.nextInt(), k = in.nextInt();
+            ArrayList<Pair<Integer, Integer>> a = new ArrayList<>();
+            for (int i = 0; i < n; ++i) {
+                a.add(new Pair<>(in.nextInt(), i));
+            }
+            Collections.sort(a);
+
+            int[] ans = new int[n];
+            int[] sum = new int[m];
+            int j = 1;
+
+            for (int i = 0; i < n; ++i) {
+                ans[a.get(i).y] = j;
+                sum[j - 1] += a.get(i).x;
+                j++;
+                if (j == m + 1) j = 1;
+            }
+
+            for (int i = 1; i < m; ++i) {
+                if (Math.abs(sum[i - 1] - sum[i]) > k) {
+                    out.println(""NO"");
+                }
+            }
+
+            out.println(""YES"");
+            for (int e : ans) {
+                out.print(e + "" "");
+            }
+            out.println();
+
+        }
+
+    }
+
+    static class Pair<U, V> implements Comparable<Pair<U, V>> {
+        public U x;
+        public V y;
+
+        public Pair(U x, V y) {
+            this.x = x;
+            this.y = y;
+        }
+
+        public int compareTo(Pair<U, V> o) {
+            int value = ((Comparable<U>) x).compareTo(o.x);
+            if (value != 0) return value;
+            return ((Comparable<V>) y).compareTo(o.y);
+        }
+
+        public boolean equals(Object o) {
+            if (this == o) return true;
+            if (o == null || getClass() != o.getClass()) return false;
+            Pair<?, ?> pair = (Pair<?, ?>) o;
+            return x.equals(pair.x) && y.equals(pair.y);
+        }
+
+        public int hashCode() {
+            return Objects.hash(x, y);
+        }
+
+    }
+
+    static class FastReader {
+        private InputStream stream;
+        private byte[] buf = new byte[1024];
+        private int curChar;
+        private int numChars;
+        private FastReader.SpaceCharFilter filter;
+
+        public FastReader(InputStream stream) {
+            this.stream = stream;
+        }
+
+        public int read() {
+            if (numChars == -1) throw new InputMismatchException();
+            if (curChar >= numChars) {
+                curChar = 0;
+                try {
+                    numChars = stream.read(buf);
+                } catch (IOException e) {
+                    throw new InputMismatchException();
+                }
+                if (numChars <= 0) return -1;
+            }
+            return buf[curChar++];
+        }
+
+        public int nextInt() {
+            int c = read();
+            while (isSpaceChar(c)) c = read();
+            int sgn = 1;
+            if (c == '-') {
+                sgn = -1;
+                c = read();
+            }
+            int res = 0;
+            do {
+                if (c < '0' || c > '9') throw new InputMismatchException();
+                res *= 10;
+                res += c - '0';
+                c = read();
+            }
+            while (!isSpaceChar(c));
+            return res * sgn;
+        }
+
+        public String next() {
+            int c = read();
+            while (isSpaceChar(c)) c = read();
+            StringBuilder res = new StringBuilder();
+            do {
+                res.appendCodePoint(c);
+                c = read();
+            } while (!isSpaceChar(c));
+            return res.toString();
+        }
+
+        public boolean isSpaceChar(int c) {
+            if (filter != null) return filter.isSpaceChar(c);
+            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
+        }
+
+        public interface SpaceCharFilter {
+            public boolean isSpaceChar(int ch);
+
+        }
+
+    }
+}
+
+
+","import java.io.OutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.PrintWriter;
+import java.util.InputMismatchException;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Objects;
+import java.util.Collections;
+import java.io.InputStream;
+
+public class Main {
+    public static void main(String[] args) {
+        InputStream inputStream = System.in;
+        OutputStream outputStream = System.out;
+        FastReader in = new FastReader(inputStream);
+        PrintWriter out = new PrintWriter(outputStream);
+        CPhoenixAndTowers solver = new CPhoenixAndTowers();
+        int testCount = Integer.parseInt(in.next());
+        for (int i = 1; i <= testCount; i++)
+            solver.solve(i, in, out);
+        out.close();
+    }
+
+    static class CPhoenixAndTowers {
+        public void solve(int testNumber, FastReader in, PrintWriter out) {
+            int n = in.nextInt(), m = in.nextInt(), k = in.nextInt();
+            ArrayList<Pair<Integer, Integer>> a = new ArrayList<>();
+            for (int i = 0; i < n; ++i) {
+                a.add(new Pair<>(in.nextInt(), i));
+            }
+            Collections.sort(a);
+
+            int[] ans = new int[n];
+            int[] sum = new int[m];
+            int j = 1;
+
+            for (int i = 0; i < n; ++i) {
+                ans[a.get(i).y] = j;
+                sum[j - 1] += a.get(i).x;
+                j++;
+                if (j == m + 1) j = 1;
+            }
+
+            for (int i = 1; i < m; ++i) {
+                if (Math.abs(sum[i - 1] - sum[i]) > k) {
+                    out.println(""NO"");
+                }
+            }
+
+            out.println(""YES"");
+            for (int e : ans) {
+                out.print(e + "" "");
+            }
+            out.println();
+
+        }
+
+    }
+
+    static class FastReader {
+        private InputStream stream;
+        private byte[] buf = new byte[1024];
+        private int curChar;
+        private int numChars;
+        private FastReader.SpaceCharFilter filter;
+
+        public FastReader(InputStream stream) {
+            this.stream = stream;
+        }
+
+        public int read() {
+            if (numChars == -1) throw new InputMismatchException();
+            if (curChar >= numChars) {
+                curChar = 0;
+                try {
+                    numChars = stream.read(buf);
+                } catch (IOException e) {
+                    throw new InputMismatchException();
+                }
+                if (numChars <= 0) return -1;
+            }
+            return buf[curChar++];
+        }
+
+        public int nextInt() {
+            int c = read();
+            while (isSpaceChar(c)) c = read();
+            int sgn = 1;
+            if (c == '-') {
+                sgn = -1;
+                c = read();
+            }
+            int res = 0;
+            do {
+                if (c < '0' || c > '9') throw new InputMismatchException();
+                res *= 10;
+                res += c - '0';
+                c = read();
+            }
+            while (!isSpaceChar(c));
+            return res * sgn;
+        }
+
+        public String next() {
+            int c = read();
+            while (isSpaceChar(c)) c = read();
+            StringBuilder res = new StringBuilder();
+            do {
+                res.appendCodePoint(c);
+                c = read();
+            } while (!isSpaceChar(c));
+            return res.toString();
+        }
+
+        public boolean isSpaceChar(int c) {
+            if (filter != null) return filter.isSpaceChar(c);
+            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
+        }
+
+        public interface SpaceCharFilter {
+            public boolean isSpaceChar(int ch);
+
+        }
+
+    }
+
+    static class Pair<U, V> implements Comparable<Pair<U, V>> {
+        public U x;
+        public V y;
+
+        public Pair(U x, V y) {
+            this.x = x;
+            this.y = y;
+        }
+
+        public int compareTo(Pair<U, V> o) {
+            int value = ((Comparable<U>) x).compareTo(o.x);
+            if (value != 0) return value;
+            return ((Comparable<V>) y).compareTo(o.y);
+        }
+
+        public boolean equals(Object o) {
+            if (this == o) return true;
+            if (o == null || getClass() != o.getClass()) return false;
+            Pair<?, ?> pair = (Pair<?, ?>) o;
+            return x.equals(pair.x) && y.equals(pair.y);
+        }
+
+        public int hashCode() {
+            return Objects.hash(x, y);
+        }
+
+    }
+}
+
+
+",1
+4ea10951,7c11511f,"import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.*;
+
+public class Main {
+    static String f1(String s, int index) {
+        StringBuffer sb = new StringBuffer();
+        for(int i =0;i<s.length();i++){
+            if( i == index) sb.append(s.charAt(i));
+            else if (s.charAt(i) == '0') sb.append('1');
+            else sb.append('0');
+        }
+        return sb.toString();
+    }
+    static long solve(String s1, String s2) {
+        if(s1.equals(s2)) return 0;
+        int o1 = 0, o2 = 0, diff = 0;
+        for (int i = 0; i < s1.length(); i++) {
+            if (s1.charAt(i) == '1') o1++;
+            if (s2.charAt(i) == '1') o2++;
+            if (s1.charAt(i) != s2.charAt(i)) diff++;
+        }
+        return o1 == o2? diff : Integer.MAX_VALUE;
+    }
+    public static void main(String[] args) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        int t = Integer.parseInt(br.readLine());
+        while (t-- > 0) {
+            int n = Integer.parseInt(br.readLine());
+            String s1 = br.readLine();
+            String s2 = br.readLine();
+            long res = solve(s1, s2);
+            for(int i=0;i<s1.length();i++) {
+                if(s1.charAt(i) == '1' && s2.charAt(i) == '1') {
+                    res = Math.min(res, 1 + solve(f1(s1, i), s2));
+                    break;
+                }
+            }
+            for(int i=0;i<s1.length();i++) {
+                if(s1.charAt(i) == '1' && s2.charAt(i) == '0') {
+                    res = Math.min(res,1 + solve(f1(s1, i), s2));
+                    break;
+                }
+            }
+            if(res == Integer.MAX_VALUE) System.out.println(""-1"");
+            else System.out.println(res);
+        }
+    }
+}","import java.io.*;
+import java.util.*;
+
+public class Solution {
+
+    public static void main(String[] args) throws Exception {
+        int tc = io.nextInt();
+        for (int i = 0; i < tc; i++) {
+            solve();
+        }
+        io.close();
+    }
+
+    private static void solve() throws Exception {
+        int n = io.nextInt();
+        String a = io.next();
+        String b = io.next();
+        int zz = 0;
+        int zo = 0;
+        int oo = 0;
+        int oz = 0;
+        for (int i = 0; i < a.length(); i++) {
+            if (a.charAt(i) == '1' && b.charAt(i) == '0') {
+                oz++;
+            }
+            if (a.charAt(i) == '0' && b.charAt(i) == '0') {
+                zz++;
+            }
+            if (a.charAt(i) == '1' && b.charAt(i) == '1') {
+                oo++;
+            }
+            if (a.charAt(i) == '0' && b.charAt(i) == '1') {
+                zo++;
+            }
+        }
+        int ans = Integer.MAX_VALUE;
+        if (oz == zo) {
+            ans = Math.min(ans, oz + zo);
+        }
+        if (oo - 1 == zz) {
+            ans = Math.min(ans, oo + zz);
+        }
+        if (ans == Integer.MAX_VALUE) {
+            ans = -1;
+        }
+        io.println(ans);
+    }
+
+    static void sort(int[] a) {
+        ArrayList<Integer> l = new ArrayList<>(a.length);
+        for (int i : a) l.add(i);
+        Collections.sort(l);
+        for (int i = 0; i < a.length; i++) a[i] = l.get(i);
+    }
+
+    //-----------PrintWriter for faster output---------------------------------
+    public static FastIO io = new FastIO();
+
+    //-----------MyScanner class for faster input----------
+    static class FastIO extends PrintWriter {
+        private InputStream stream;
+        private byte[] buf = new byte[1 << 16];
+        private int curChar, numChars;
+
+        // standard input
+        public FastIO() {
+            this(System.in, System.out);
+        }
+
+        public FastIO(InputStream i, OutputStream o) {
+            super(o);
+            stream = i;
+        }
+
+        // file input
+        public FastIO(String i, String o) throws IOException {
+            super(new FileWriter(o));
+            stream = new FileInputStream(i);
+        }
+
+        // throws InputMismatchException() if previously detected end of file
+        private int nextByte() {
+            if (numChars == -1) throw new InputMismatchException();
+            if (curChar >= numChars) {
+                curChar = 0;
+                try {
+                    numChars = stream.read(buf);
+                } catch (IOException e) {
+                    throw new InputMismatchException();
+                }
+                if (numChars == -1) return -1; // end of file
+            }
+            return buf[curChar++];
+        }
+
+        // to read in entire lines, replace c <= ' '
+        // with a function that checks whether c is a line break
+        public String next() {
+            int c;
+            do {
+                c = nextByte();
+            } while (c <= ' ');
+            StringBuilder res = new StringBuilder();
+            do {
+                res.appendCodePoint(c);
+                c = nextByte();
+            } while (c > ' ');
+            return res.toString();
+        }
+
+        public String nextLine() {
+            int c;
+            do {
+                c = nextByte();
+            } while (c < '\n');
+            StringBuilder res = new StringBuilder();
+            do {
+                res.appendCodePoint(c);
+                c = nextByte();
+            } while (c > '\n');
+            return res.toString();
+        }
+
+        public int nextInt() {
+            int c;
+            do {
+                c = nextByte();
+            } while (c <= ' ');
+            int sgn = 1;
+            if (c == '-') {
+                sgn = -1;
+                c = nextByte();
+            }
+            int res = 0;
+            do {
+                if (c < '0' || c > '9')
+                    throw new InputMismatchException();
+                res = 10 * res + c - '0';
+                c = nextByte();
+            } while (c > ' ');
+            return res * sgn;
+        }
+
+        public long nextLong() {
+            int c;
+            do {
+                c = nextByte();
+            } while (c <= ' ');
+            int sgn = 1;
+            if (c == '-') {
+                sgn = -1;
+                c = nextByte();
+            }
+            long res = 0;
+            do {
+                if (c < '0' || c > '9')
+                    throw new InputMismatchException();
+                res = 10 * res + c - '0';
+                c = nextByte();
+            } while (c > ' ');
+            return res * sgn;
+        }
+
+
+        public double nextDouble() {
+            return Double.parseDouble(next());
+        }
+    }
+    //--------------------------------------------------------
+}",0
+43b85d63,a37923d1,"import java.io.BufferedWriter;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.PriorityQueue;
+import java.util.Map.Entry;
+
+import java.util.Random;
+import java.util.TreeSet;
+
+public final class CF_724_D2_D2
+{
+
+
+	static boolean verb=true;
+	static void log(Object X){if (verb) System.err.println(X);}
+	static void log(Object[] X){if (verb) {for (Object U:X) System.err.print(U+"" "");System.err.println("""");}}
+	static void log(int[] X){if (verb) {for (int U:X) System.err.print(U+"" "");System.err.println("""");}}
+	static void logWln(int[] X){if (verb) {for (int U:X) System.err.print(U+"" "");}}
+	static void log(int[] X,int L){if (verb) {for (int i=0;i<L;i++) System.err.print(X[i]+"" "");System.err.println("""");}}
+	static void log(long[] X){if (verb) {for (long U:X) System.err.print(U+"" "");System.err.println("""");}}
+
+	static void logWln(Object X){if (verb) System.err.print(X);}
+	static void info(Object o){	System.out.println(o);}
+	static void output(Object o){outputWln(""""+o+""\n"");	}
+	static void outputFlush(Object o){try {out.write(""""+ o+""\n"");out.flush();} catch (Exception e) {}}
+	static void outputWln(Object o){try {out.write(""""+ o);} catch (Exception e) {}}
+
+
+	static void logBin(int[] tm) {for (int x:tm) logWln(bin(8,x)+"" "");log("""");}
+
+	static String bin(int L,int x) {
+		String s=Integer.toBinaryString(x);
+		while (s.length()<L) s=""0""+s;
+		return s;
+	}
+
+	static long powerMod(long b,long e,long m){
+		long x=1;
+		while (e>0) {
+			if (e%2==1)			
+				x=(b*x)%m;
+			b=(b*b)%m;
+			e=e/2;
+		}
+		return x; 
+	}
+
+
+
+	static long mod=1000000007;
+
+
+
+	// Global vars
+	static BufferedWriter out;
+	static InputReader reader;
+
+	static int pgcd(int a,int b){
+		if (a<b)
+			return pgcd(b,a);
+		while (b!=0){
+			int c=b;
+			b=a%b;
+			a=c;
+		}
+		return a;
+	}
+	
+	static class Node {
+		
+		Node left;
+		Node right;
+		int nl;
+		int nr;
+		int v;
+		
+		public Node(Node left, Node right, int v) {
+			this.left = left;
+			this.right = right;
+			this.v = v;
+			nl=0;
+			nr=0;
+		}
+	
+		public String toString() {
+			return """"+v;
+		}
+		
+	}
+
+	
+	static int PX=Integer.MAX_VALUE;
+	static int NX=Integer.MIN_VALUE;
+
+	static void process() throws Exception {
+
+
+		out = new BufferedWriter(new OutputStreamWriter(System.out));
+		reader = new InputReader(System.in);
+
+		int T=reader.readInt();
+		int CX=26;
+		for (int t=0;t<T;t++) {
+		
+		
+			int n=reader.readInt();
+		
+			int[] b=new int[n];
+			for (int i=0;i<n;i++) {
+				b[i]=reader.readInt();
+			}
+			TreeSet<Integer> ts=new TreeSet<Integer>();
+			ts.add(b[0]);
+			ts.add(NX);
+			ts.add(PX);
+			int core=b[0];
+			boolean ok=true;
+			for (int i=1;i<n;i++) {
+				int x=b[i];
+				if (x==core) {
+					//ok
+				} else if (x<core) {
+					int y=ts.lower(core);
+					if (y>x) {
+						ok=false;
+						//log(""fail 1"");
+
+						break;
+					}
+					//log(""core:""+core+"" x:""+x+"" y:""+y);
+					core=x;
+					ts.add(x);
+						
+					
+				} else {
+					int y=ts.higher(core);
+					if (y<x) {
+						ok=false;
+						//log(""fail 2"");
+						break;
+						
+					}
+					//log(""core:""+core+"" x:""+x+"" y:""+y);
+					core=x;
+					ts.add(x);
+					
+				}
+			}
+			
+			
+			if (ok)
+				output(""YES"");
+			else
+				output(""NO"");
+			
+			
+		
+		}
+
+
+		try {
+			out.close();
+		} catch (Exception Ex) {
+		}
+
+	}
+
+
+	public static void main(String[] args) throws Exception {
+		process();
+
+	}
+
+	static final class InputReader {
+		private final InputStream stream;
+		private final byte[] buf = new byte[1024];
+		private int curChar;
+		private int numChars;
+
+		public InputReader(InputStream stream) {
+			this.stream = stream;
+		}
+
+		private int read() throws IOException {
+			if (curChar >= numChars) {
+				curChar = 0;
+				numChars = stream.read(buf);
+				if (numChars <= 0) {
+					return -1;
+				}
+			}
+			return buf[curChar++];
+		}
+
+		public final String readString() throws IOException {
+			int c = read();
+			while (isSpaceChar(c)) {
+				c = read();
+			}
+			StringBuilder res = new StringBuilder();
+			do {
+				res.append((char) c);
+				c = read();
+			} while (!isSpaceChar(c));
+			return res.toString();
+		}
+
+		public final String readString(int L) throws IOException {
+			int c = read();
+			while (isSpaceChar(c)) {
+				c = read();
+			}
+			StringBuilder res = new StringBuilder(L);
+			do {
+				res.append((char) c);
+				c = read();
+			} while (!isSpaceChar(c));
+			return res.toString();
+		}
+
+		public final int readInt() throws IOException {
+			int c = read();
+			boolean neg = false;
+			while (isSpaceChar(c)) {
+				c = read();
+			}
+			char d = (char) c;
+			// log(""d:""+d);
+			if (d == '-') {
+				neg = true;
+				c = read();
+			}
+			int res = 0;
+			do {
+				res *= 10;
+				res += c - '0';
+				c = read();
+			} while (!isSpaceChar(c));
+			// log(""res:""+res);
+			if (neg)
+				return -res;
+			return res;
+
+		}
+
+		public final long readLong() throws IOException {
+			int c = read();
+			boolean neg = false;
+			while (isSpaceChar(c)) {
+				c = read();
+			}
+			char d = (char) c;
+			// log(""d:""+d);
+			if (d == '-') {
+				neg = true;
+				c = read();
+			}
+			long res = 0;
+			do {
+				res *= 10;
+				res += c - '0';
+				c = read();
+			} while (!isSpaceChar(c));
+			// log(""res:""+res);
+			if (neg)
+				return -res;
+			return res;
+
+		}
+
+		private boolean isSpaceChar(int c) {
+			return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
+		}
+	}
+
+}","import java.util.Scanner;
+import java.util.TreeSet;
+
+public class D {
+    public static void main(String[] args) {
+        Scanner scn = new Scanner(System.in);
+        int test = scn.nextInt();
+        for (int t = 0; t < test; t++) {
+            int n = scn.nextInt();
+            int[] b = new int[n];
+            TreeSet<Integer> ts = new TreeSet<>();
+            int lastAdded = -1;
+            boolean ans = true;
+            for (int i = 0; i < n; i++) {
+                b[i] = scn.nextInt();
+            }
+            for (int val : b) {
+                if (t == 4) {
+                    int x = 2;
+                }
+                if (val > lastAdded) {
+                    Integer between = ts.higher(lastAdded);
+                    if (between != null && between < val) {
+                        ans = false;
+                        break;
+
+                    }
+
+                }
+                if (val < lastAdded) {
+                    Integer between = ts.lower(lastAdded);
+                    if (between != null && between > val) {
+                        ans = false;
+                        break;
+                    }
+                }
+                ts.add(val);
+                lastAdded = val;
+            }
+            if (ans) System.out.println(""YES"");
+            else System.out.println(""NO"");
+        }
+
+    }
+
+    boolean between(int mid, int a, int b) {
+        return a >= mid && mid >= b || a <= mid && mid <= b;
+    }
+
+
+}
+",0
+0c00d532,521c5645,"import java.io.OutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.PrintWriter;
+import java.util.*;
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+
+public class First {
+
+    public static void main(String[] args) {
+        InputStream inputStream = System.in;
+        OutputStream outputStream = System.out;
+        InputReader in = new InputReader(inputStream);
+        PrintWriter out = new PrintWriter(outputStream);
+        TaskA solver = new TaskA();
+        //int a = 1;
+        int t;
+        t = in.nextInt();
+        //t = 1;
+        while (t > 0) {
+            //out.print(""Case #""+(a++)+"": "");
+            solver.call(in,out);
+            t--;
+        }
+        out.close();
+
+    }
+
+    static class TaskA {
+        public void call(InputReader in, PrintWriter out) {
+            int n;
+            n = in.nextInt();
+            int[] arr = new int[n];
+            long[] array = new long[n];
+
+            for (int i = 0; i < n; i++) {
+                arr[i] = in.nextInt();
+                if(i==0){
+                    array[i] = arr[i];
+                }
+                else
+                    array[i] = (long)arr[i] + array[i-1];
+            }
+
+            int evenMin = arr[0], oddMin = arr[1];
+
+            long ans = ((long) n * (long)arr[0]) + ((long) n * (long)arr[1]);
+
+            for (int i = 2; i < n; i++) {
+                if(i%2==0){
+                    if(evenMin>arr[i]) {
+                        evenMin = arr[i];
+                    }
+                }
+                else{
+                    if(oddMin>arr[i]) {
+                        oddMin = arr[i];
+                    }
+                }
+                if(i%2==0){
+                    ans = Math.min(ans, array[i] + (long) ((n - (i / 2)) - 1) * (long)evenMin + (long) ((n - ((i-1) / 2)) - 1) * (long)oddMin );
+                }
+                else{
+                    ans = Math.min(ans, array[i] + (long) ((n - (i / 2)) - 1) * (long)oddMin + (long) ((n - ((i-1) / 2)) - 1) * (long)evenMin);
+                }
+
+            }
+            out.println(ans);
+
+
+
+
+
+        }
+    }
+
+    static int gcd(int a, int b)
+    {
+        if (a == 0)
+            return b;
+        return gcd(b % a, a);
+    }
+
+    static int lcm(int a, int b)
+    {
+        return (a / gcd(a, b)) * b;
+    }
+
+    static class answer implements Comparable<answer>{
+        int a;
+        int b;
+
+        public answer(int a, int b) {
+            this.a = a;
+            this.b = b;
+        }
+
+        @Override
+        public int compareTo(answer o) {
+            return this.a - o.a;
+        }
+    }
+
+    static class answer1 implements Comparable<answer1>{
+        int a, b, c;
+
+        public answer1(int a, int b, int c) {
+            this.a = a;
+            this.b = b;
+            this.c = c;
+
+        }
+
+        @Override
+        public int compareTo(answer1 o) {
+            return this.a - o.a;
+        }
+    }
+
+    static long gcd(long a, long b)
+    {
+        if (b == 0)
+            return a;
+        return gcd(b, a % b);
+    }
+
+    static void sort(long[] a) {
+        ArrayList<Long> l=new ArrayList<>();
+        for (long i:a) l.add(i);
+        Collections.sort(l);
+        for (int i=0; i<a.length; i++) a[i]=l.get(i);
+    }
+
+    static final Random random=new Random();
+
+    static void shuffleSort(int[] a) {
+        int n=a.length;
+        for (int i=0; i<n; i++) {
+            int oi=random.nextInt(n), temp=a[oi];
+            a[oi]=a[i]; a[i]=temp;
+        }
+        Arrays.sort(a);
+    }
+
+    static class InputReader {
+        public BufferedReader reader;
+        public StringTokenizer tokenizer;
+
+        public InputReader(InputStream stream) {
+            reader = new BufferedReader(new InputStreamReader(stream), 32768);
+            tokenizer = null;
+        }
+
+        public String next() {
+            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
+                try {
+                    tokenizer = new StringTokenizer(reader.readLine());
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+            }
+            return tokenizer.nextToken();
+        }
+
+        public int nextInt() {
+            return Integer.parseInt(next());
+        }
+        public long nextLong(){
+            return Long.parseLong(next());
+        }
+        public double nextDouble() {
+            return Double.parseDouble(next());
+        }
+
+    }
+}
+","import java.io.*;
+
+import java.util.*;
+/*
+
+
+ */
+
+
+
+public class C {
+    static FastReader sc=null;
+ 
+    
+    public static void main(String[] args) {
+    	sc=new FastReader();
+    	int t=sc.nextInt();
+    	while(t-->0) {
+    		int n=sc.nextInt();
+    		int c[]=sc.readArray(n);
+    		long dp[]=new long[n];
+    		dp[0]=Long.MAX_VALUE;
+    		dp[1]=(long)n*c[1]+ (long)n*c[0];
+    		long preMin[]=new long[n],pre[]=new long[n];
+    		preMin[0]=pre[0]=c[0];
+    		preMin[1]=pre[1]=c[1];
+    		for(int i=2;i<n;i++) {
+    			preMin[i]=Math.min(preMin[i-2],c[i]);
+    			pre[i]=pre[i-2]+c[i];
+    		}
+    		for(int i=2;i<n;i++) {
+    			dp[i]=preMin[i]*(n-i/2)+pre[i]-preMin[i]+preMin[i-1]*(n-(i-1)/2)+pre[i-1]-preMin[i-1];
+    		}
+    		long ans=Long.MAX_VALUE;
+    		//print(dp);
+    		for(long e:dp)ans=Math.min(ans, e);
+    		System.out.println(ans);
+    	}
+    	
+    	
+    }
+  
+  
+   
+    
+    
+   
+ 
+   
+    
+    static void ruffleSort(int a[]) {
+        ArrayList<Integer> al=new ArrayList<>();
+        for(int i:a)al.add(i);
+        Collections.sort(al);
+        for(int i=0;i<a.length;i++)a[i]=al.get(i);
+    }
+    static void ruffleSort(long a[]) {
+        ArrayList<Long> al=new ArrayList<>();
+        for(long i:a)al.add(i);
+        Collections.sort(al);
+        for(int i=0;i<a.length;i++)a[i]=al.get(i);
+    }
+    
+    static int[] reverse(int a[]) {
+        ArrayList<Integer> al=new ArrayList<>();
+        for(int i:a)al.add(i);
+        Collections.sort(al,Collections.reverseOrder());
+        for(int i=0;i<a.length;i++)a[i]=al.get(i);
+        return a;
+    }
+ 
+    static int gcd(int a,int b) {
+		if(b==0)return a;
+		else return gcd(b,a%b);
+	}   
+        
+ 
+    
+    
+    
+    static void print(long a[]) {
+        for(long e:a) {
+            System.out.print(e+"" "");
+        }
+        System.out.println();
+    }
+    static void print(char a[]) {
+        for(char e:a) {
+            System.out.print(e);
+        }
+        System.out.println();
+    }
+    
+    
+    static void print(int a[]) {
+        for(int e:a) {
+            System.out.print(e+"" "");
+        }
+        System.out.println();
+    }
+    
+    
+    static class FastReader 
+    { 
+        BufferedReader br; 
+        StringTokenizer st; 
+  
+        public FastReader() 
+        { 
+            br = new BufferedReader(new
+                     InputStreamReader(System.in)); 
+        } 
+  
+        String next() 
+        { 
+            while (st == null || !st.hasMoreElements()) 
+            { 
+                try
+                { 
+                    st = new StringTokenizer(br.readLine()); 
+                } 
+                catch (IOException  e) 
+                { 
+                    e.printStackTrace(); 
+                } 
+            } 
+            return st.nextToken(); 
+        } 
+  
+        int nextInt() 
+        { 
+            return Integer.parseInt(next()); 
+        } 
+  
+        long nextLong() 
+        { 
+            return Long.parseLong(next()); 
+        } 
+  
+        double nextDouble() 
+        { 
+            return Double.parseDouble(next()); 
+        } 
+  
+        String nextLine() 
+        { 
+            String str = """"; 
+            try
+            { 
+                str = br.readLine(); 
+            } 
+            catch (IOException e) 
+            { 
+                e.printStackTrace(); 
+            } 
+            return str; 
+        } 
+        int[] readArray(int n) {
+            int a[]=new int [n];
+            for(int i=0;i<n;i++) {
+                a[i]=sc.nextInt();
+            }
+            return a;
+        }
+    } 
+}
+",0
+597195ee,5f3a196a,"import java.io.*;
+import java.util.Arrays;
+import java.util.StringTokenizer;
+
+public class C_MonstersAndSpells_1700 {
+    public static void main(String[] args) {
+        MyScanner sc = new MyScanner();
+        out = new PrintWriter(new BufferedOutputStream(System.out));
+        int t = sc.nextInt();
+        while(t-->0) {
+            int n = sc.nextInt();
+            int[] times = new int[n];
+            int[] health = new int[n];
+            for(int i = 0; i < n; i++) {
+                times[i] = sc.nextInt();
+            }
+            for(int i = 0; i < n; i++) {
+                health[i] = sc.nextInt();
+            }
+            Point[] points = new Point[n];
+            for(int i = 0; i < n; i++) {
+                points[i] = new Point(times[i]-health[i], times[i]);
+            }
+            Arrays.sort(points);
+            long ans = 0;
+            for(int i = 0; i < n; i++) {
+                int j = i+1;
+                int latestTime = points[i].time;
+                while(j < n && points[j].startBy < latestTime) {
+                    latestTime = Math.max(latestTime, times[j]);
+                    j++;
+                }
+                long length = latestTime-points[i].startBy;
+                ans += (length*(length + 1))/2;
+                i = j - 1;
+            }
+            System.out.println(ans);
+        }
+
+        out.close();
+    }
+
+    static class Point implements Comparable<Point> {
+        Integer startBy;
+        Integer time;
+
+        Point(int startBy, int time) {
+            this.startBy = startBy;
+            this.time = time;
+        }
+
+        @Override
+        public int compareTo(Point o) {
+            return this.startBy.compareTo(o.startBy);
+        }
+    }
+
+    public static PrintWriter out;
+
+    public static class MyScanner {
+        BufferedReader br;
+        StringTokenizer st;
+
+        public MyScanner() {
+            br = new BufferedReader(new InputStreamReader(System.in));
+        }
+
+        String next() {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+
+        String nextLine(){
+            String str = """";
+            try {
+                str = br.readLine();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+        }
+
+    }
+    static class Pair {
+        public int x,y;
+        public Pair(int x, int y) {
+            this.x = x;
+            this.y = y;
+        }
+    }
+}
+","import java.io.*;
+import java.util.*;
+public class MonstersAndSpells {
+	public static PrintWriter out;
+	public static void main(String[] args)throws IOException {
+        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st=new StringTokenizer(br.readLine());
+        out=new PrintWriter(System.out);
+        int t=Integer.parseInt(st.nextToken());
+        while(t-->0) {
+        	st=new StringTokenizer(br.readLine());
+        	int n=Integer.parseInt(st.nextToken());//monsters
+        	int time[]=new int[n];//time
+        	int health[]=new int[n];//health
+        	st=new StringTokenizer(br.readLine());
+        	for(int i=0;i<n;i++) {
+        		time[i]=Integer.parseInt(st.nextToken());
+        	}
+        	st=new StringTokenizer(br.readLine());
+        	for(int i=0;i<n;i++) {
+        		health[i]=Integer.parseInt(st.nextToken());
+        	}
+        	State a[]=new State[n];
+        	for(int i=0;i<n;i++) {
+        		a[i]=new State(time[i]-health[i], time[i]);
+        	}
+        	Arrays.sort(a);
+        	long ans=0;
+        	for(int i=0;i<n;i++) {
+        		int j=i+1;
+        		int max=a[i].time;
+        		while(j<n&&a[j].x<max) {
+        			max=Math.max(max, time[j]);
+        			j++;
+        		}
+        		ans+=((long)(max-a[i].x)*(long)(max-a[i].x+1))/2;
+        		i=j-1;
+        	}
+        	out.println(ans);
+        }
+        out.close();
+	}
+	static class State implements Comparable<State>{
+		int x, time;
+		public State(int x, int time) {
+			this.x=x;this.time=time;
+		}
+		public int compareTo(State o) {
+			return x-o.x;
+		}
+	}
+}
+",1
+c34bb733,ea899386,"//package pack;
+import java.io.*;
+
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.*;
+import java.io.*;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.*;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.*;
+import java.math.*;
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.StringTokenizer;
+import java.util.Vector;
+import static java.lang.Math.sqrt;
+import static java.lang.Math.floor;
+
+
+
+
+
+
+public class topcoder {
+   
+	static class pair{
+		 
+		 int first;
+		 int second;
+		  public pair(int first, int second) {
+			  this.first = first;
+			  this.second = second;
+		  }
+	}
+
+
+	static class Compare{
+		
+		 static void compare(ArrayList<pair>arr, int n) {
+			 
+			 Collections.sort(arr,new Comparator<pair>() {
+				 public int compare(pair p1, pair p2) {
+					 return p1.first-p2.first;
+				 }
+			 });
+		
+	}
+	}
+	
+	
+static class pairr implements  Comparable<pairr>{
+	Integer value;
+	Integer index;
+	
+	   public pairr(Integer value, Integer index) {
+		    this.value = value;
+		    this.index = index;
+	   }
+	   @Override
+	   
+	   public int compareTo(pairr o) {
+		   return value-o.value;
+	   }
+}
+
+
+
+	 static class Key<K1, K2>
+	{
+	    public K1 key1;
+	    public K2 key2;
+	 
+	    public Key(K1 key1, K2 key2)
+	    {
+	        this.key1 = key1;
+	        this.key2 = key2;
+	    }
+	 
+	    @Override
+	    public boolean equals(Object o)
+	    {
+	        if (this == o) {
+	            return true;
+	        }
+	 
+	        if (o == null || getClass() != o.getClass()) {
+	            return false;
+	        }
+	 
+	        Key key = (Key) o;
+	        if (key1 != null ? !key1.equals(key.key1) : key.key1 != null) {
+	            return false;
+	        }
+	 
+	        if (key2 != null ? !key2.equals(key.key2) : key.key2 != null) {
+	            return false;
+	        }
+	 
+	        return true;
+	    }
+	 
+	    @Override
+	    public int hashCode()
+	    {
+	        int result = key1 != null ? key1.hashCode() : 0;
+	        result = 31 * result + (key2 != null ? key2.hashCode() : 0);
+	        return result;
+	    }
+	 
+	    @Override
+	    public String toString() {
+	        return ""["" + key1 + "", "" + key2 + ""]"";
+	    }
+	}
+	
+	
+	 public static int sumOfDigits (long n) {
+		 
+		 int sum = 0;
+		 
+		 while(n > 0) {
+			 sum += n%10;
+			 n /= 10;
+		 }
+		 
+		 return sum;
+	 
+	 }
+	 
+	 
+	 public static long binary_search(int s, int e, long num, long []ar) {
+		 
+		 if(s > e) {
+			 return -1;
+		 }	 
+			 
+		 
+		     int mid = (s+e)/2;
+		     
+		      if(s == e && ar[s] >= num) {
+		    	  return ar[s];
+		      }else if(s == e && ar[s] < num) {
+		    	  return -1;
+		      }else if(ar[mid] < num) {
+		    	  return binary_search(mid+1,e,num,ar);
+		      }else if(ar[mid] >= num) {
+		    	    return binary_search(s,mid,num,ar);
+		      }
+		      
+		      return -1;
+		 
+	 }
+	 
+	 
+	 public static int index_search(int s, int e, long num, long []ar) {
+		 
+		 if(s > e) {
+			 return -1;
+		 }	 
+			 
+		 
+		     int mid = (s+e)/2;
+		     
+		      if(s == e && ar[s] >= num) {
+		    	  return s;
+		      }else if(s == e && ar[s] < num) {
+		    	  return -1;
+		      }else if(ar[mid] < num) {
+		    	  return index_search(mid+1,e,num,ar);
+		      }else if(ar[mid] >= num) {
+		    	    return index_search(s,mid,num,ar);
+		      }
+		      
+		      return -1;
+		 
+	 }
+		     public static void swap(int []ar, int i, int j) {
+		    	 
+		    	 
+		    	 for(int k= j; k >= i; k--) {
+		    		 int temp = ar[k];
+		    		 ar[k] = ar[k+1];
+		    		 ar[k+1] = temp;
+		    	 }
+		     }
+		     
+		     public static boolean digit_exists(long n) {
+		    	 
+		    	 while(n > 0) {
+		    		 if(n%10 == 9)
+		    			 return true;
+		    		 n = n/10;
+		    	 }
+		    	 
+		    	 return false;
+		     }
+		     public static int log(int n) {
+		    	 
+		    	 int c = 0;
+		    	 while(n > 0) {
+		    		 c++;
+		    		 n /=2;
+		    	 }
+		    	 
+		    	 return c;
+		     }
+			  public static int findOr(int[]bits){
+	    	        int or=0;
+	    	            for(int i=0;i<32;i++){
+	    	                or=or<<1;
+	    	                if(bits[i]>0)
+	    	                    or=or+1;
+	    	            }
+	    	        return or;
+	    	    }
+			  
+			  static void simpleSieve(int limit, Vector<Integer> prime)
+			    {
+			        // Create a boolean array ""mark[0..n-1]"" and initialize
+			        // all entries of it as true. A value in mark[p] will
+			        // finally be false if 'p' is Not a prime, else true.
+			        boolean mark[] = new boolean[limit+1];
+			         
+			        for (int i = 0; i < mark.length; i++)
+			            mark[i] = true;
+			      
+			        for (int p=2; p*p<limit; p++)
+			        {
+			            // If p is not changed, then it is a prime
+			            if (mark[p] == true)
+			            {
+			                // Update all multiples of p
+			                for (int i=p*p; i<limit; i+=p)
+			                    mark[i] = false;
+			            }
+			        }
+			      
+			        // Print all prime numbers and store them in prime
+			        for (int p=2; p<limit; p++)
+			        {
+			            if (mark[p] == true)
+			            {
+			                prime.add(p);
+			             
+			            }
+			        }
+			    }
+			      
+			    // Prints all prime numbers smaller than 'n'
+			public    static void segmentedSieve(int n, ArrayList<Integer>l)
+			    {
+			        // Compute all primes smaller than or equal
+			        // to square root of n using simple sieve
+			        int limit = (int) (floor(sqrt(n))+1);
+			        Vector<Integer> prime = new Vector<>(); 
+			  
+			        simpleSieve(limit, prime);
+			      
+			        // Divide the range [0..n-1] in different segments
+			        // We have chosen segment size as sqrt(n).
+			        int low  = limit;
+			        int high = 2*limit;
+			      
+			        // While all segments of range [0..n-1] are not processed,
+			        // process one segment at a time
+			        while (low < n)
+			        {
+			            if (high >= n)
+			                high = n;
+			 
+			            // To mark primes in current range. A value in mark[i]
+			            // will finally be false if 'i-low' is Not a prime,
+			            // else true.
+			            boolean mark[] = new boolean[limit+1];
+			             
+			            for (int i = 0; i < mark.length; i++)
+			                mark[i] = true;
+			      
+			            // Use the found primes by simpleSieve() to find
+			            // primes in current range
+			            for (int i = 0; i < prime.size(); i++)
+			            {
+			                // Find the minimum number in [low..high] that is
+			                // a multiple of prime.get(i) (divisible by prime.get(i))
+			                // For example, if low is 31 and prime.get(i) is 3,
+			                // we start with 33.
+			                int loLim = (int) (floor(low/prime.get(i)) * prime.get(i));
+			                if (loLim < low)
+			                    loLim += prime.get(i);
+			      
+			                /*  Mark multiples of prime.get(i) in [low..high]:
+			                    We are marking j - low for j, i.e. each number
+			                    in range [low, high] is mapped to [0, high-low]
+			                    so if range is [50, 100]  marking 50 corresponds
+			                    to marking 0, marking 51 corresponds to 1 and
+			                    so on. In this way we need to allocate space only
+			                    for range  */
+			                for (int j=loLim; j<high; j+=prime.get(i))
+			                    mark[j-low] = false;
+			            }
+			      
+			            // Numbers which are not marked as false are prime
+			            for (int i = low; i<high; i++)
+			                if (mark[i - low] == true)
+			                   l.add(i);
+			      
+			            // Update low and high for next segment
+			            low  = low + limit;
+			            high = high + limit;
+			        }
+			    }
+			    
+			    public static int find_indexNum(long k) {
+			    	
+			    	long k1 = k;
+			    	int power = 0;
+			    	
+			    	while(k > 0) {
+			    		power++;
+			    		k /=2 ;
+			    	}
+			    	
+			    	long check = (long)Math.pow(2, power-1);
+			    	if(k1 == check) {
+			    		return power;
+			    	}
+			//   System.out.println(power);
+			    	long f = (long)Math.pow(2, power-1);
+			    	long rem = k1-f;
+			    	return find_indexNum(rem);
+			    }
+			    
+			 public static void sortPair(ArrayList<pair>l, int n) {
+				  n = l.size();
+				  
+				  Compare obj = new Compare();
+				  obj.compare(l, n);
+			 }
+               
+            
+			  public static int add(long n, long num, long a, int i) {
+				//System.out.println(num);
+				  if(num > n)return -1;
+				
+				  if(num == n) {
+					  
+					  return i;
+				  }
+				  
+				if(a < 2050)return -1;
+				  
+				
+				 
+				  long temp = num+a;
+				  
+				  if(temp <= n) {
+				return	  add(n,temp,a,i+1);
+				  }else if(temp > n){
+					  a /= 10;
+					  return add(n,num,a,i);
+				  }
+				  
+			      return -1;
+				  }
+			
+				   
+		public static void shuffle(int []array, int num,int t_index,  boolean []vis, int m ) {	  
+			 
+		
+		for(int i = 0; i < m; i++) {
+			if(vis[i] == false) {
+				
+				
+				int temp = array[i];
+		          if(i < t_index) {
+		        	  vis[i] = true;
+		          }
+				array[i] = num;
+				array[t_index] = temp;
+			//	System.out.println(array[t_index]+"" ""+array[i]);
+				break;
+			}
+		}
+		}
+		
+		public static void rotate(int []arr,int j, int times, int m) {
+			
+		
+			
+			 if(j == 0) {
+				 int temp1 = arr[0];
+				 arr[0] = arr[times];
+				 arr[times] = temp1;
+				 
+			 }else {
+			 int temp = arr[j];
+			 int z = arr[0];
+				
+			 arr[0] = arr[times];
+			
+			 arr[j] = z;
+			 arr[times] =  temp;
+			    
+			
+			
+		}
+
+		}
+		
+		public static void recur(int i,int A, int B,int []dp,int []metal, int n, boolean took,int ind) {
+			
+		  if(i-A <= 0 && i-B <= 0)return;
+		    int count = 0;
+		    
+		    for(int j = 1; j <= n; j++) {
+		    	if(dp[j] >= metal[j]) {
+		    		count++;
+		    	}
+		    }
+		    
+		    if(count == n)return;
+			if(i-A >= 0 && i-B >= 0 && dp[i] > 0 && dp[i] > metal[i]) {
+			dp[i]--;
+		
+			dp[i-A]++;
+		
+			dp[i-B]++;
+			}
+			
+			
+			if(ind == 6) {
+		//	System.out.println(Arrays.toString(dp));
+			}
+			recur(i-A,A,B,dp,metal,n,took,ind);
+			recur(i-B,A,B,dp,metal,n,took,ind);
+		}
+		
+		
+		public static boolean isPrime(int n) { 
+	        if (n <= 1) return false; 
+	        if (n <= 3) return true; 
+	        if (n % 2 == 0 || n % 3 == 0) return false; 
+	        for (int i = 5; i * i <= n; i = i + 6) 
+	            if (n % i == 0 || n % (i + 2) == 0) 
+	            return false; 
+	        return true; 
+	    }
+		
+		  public static boolean[] getSieve(int n) {
+		        boolean[] isPrime = new boolean[n+1];
+		        for (int i = 2; i <= n; i++) isPrime[i] = true;
+		        for (int i = 2; i*i <= n; i++) if (isPrime[i]) 
+		                for (int j = i; i*j <= n; j++) isPrime[i*j] = false;
+		        return isPrime;
+		    }
+		  
+
+		    public static int gcd(int a, int b) { 
+		    	int tmp = 0;
+		    	while(b != 0) {
+		    		tmp = b;
+		    		b = a%b;
+		    		a = tmp;
+		    	}
+		    	return a;
+		    }
+		    
+		    
+		    public static long gcd(long a, long b) { 
+		    	long tmp = 0;
+		    	while(b != 0) {
+		    		tmp = b;
+		    		b = a%b;
+		    		a = tmp;
+		    	}
+		    	return a;
+		    }
+		    
+		
+		public static boolean poss( int r, int c, int k, int n, int m,boolean [][]vis) {
+			
+			if(k < 0)return false;
+			if(r > n || c > m || r < 1 || c < 1)return false;
+			
+			if(r == n &&  c == m &&  k == 0) {
+			//	System.out.println(k);
+				return true;
+			}
+              if(vis[r][c] == true) {
+            	  return false;
+              }
+              vis[r][c] = true;
+			
+			
+		return	poss(r+1,c,k-c,n,m,vis) || poss(r,c+1,k-r,n,m,vis);
+			
+			
+		}
+			
+	    public static void dfs(LinkedList<Integer>[]list, HashMap<Integer,Integer>map, int parent, int n) {
+	    	
+	    	Stack<Integer>st = new Stack<>();
+	   
+	    	
+	    }
+	   public static boolean pos(int n) {
+		
+		   
+		   int i = 1;
+		   boolean pos = false;
+		   
+		   while(i*i <= n) {
+			   if(i*i*2 == n || i*i*4 == n) {
+				   pos = true;
+				   break;
+			   }
+			   i++;
+		   }
+		   if(pos)return true;
+		    return false;
+		   
+	   }
+	  
+			
+	    public static void main(String args[])throws IOException{
+			 
+	    	//	 System.setIn(new FileInputStream(""Case.txt""));
+	    		 BufferedReader ob = new BufferedReader(new InputStreamReader(System.in));
+	    	    
+	    		 
+	    		 int t = Integer.parseInt(ob.readLine());
+	    		 
+	    		 
+	    		 while( t--> 0) {
+	    		
+	    		StringTokenizer	 st = new StringTokenizer(ob.readLine());
+	    			 int n = Integer.parseInt(st.nextToken());
+	    			 int m = Integer.parseInt(st.nextToken());
+	    			 int x = Integer.parseInt(st.nextToken());
+	    			 
+	    			 int []ar = new int[n];
+	    			 st = new StringTokenizer(ob.readLine());
+	    			 PriorityQueue<Integer>pq = new PriorityQueue<>();
+	    			 
+	    			 for(int i = 0; i < n; i++) {
+	    				 ar[i] = Integer.parseInt(st.nextToken());
+	    				 pq.add(ar[i]);
+	    			 }
+	    			 
+	    			 
+	    	PriorityQueue<pairr>p = new PriorityQueue<>();
+	    	for(int i =0; i < n; i++) {
+	    		p.add(new pairr(ar[i],i));
+	    	}
+	    	int []ans = new int[n];
+	    	
+	    	
+	    	for(int i = 0; i < n; i++) {
+	    	pairr a = p.poll();
+	    	ans[a.index] = (i%m)+1;
+	    	}
+	    	
+	    	System.out.println(""YES"");
+	    	for(int i = 0; i < n; i++ ) {
+	    		System.out.print(ans[i]+"" "");
+	    	}
+	    	System.out.println();
+	    		 }
+	    }
+}
+	    	
+	    	
+	    	
+	    				 ","import java.io.*;
+import java.util.*;
+ 
+public class Codeforces {
+	public static class Tower implements Comparable<Tower>{
+		int val;
+		int index;
+		public Tower(int ind, int v) {
+			val = v;
+			index = ind;
+		}
+		@Override
+		public int compareTo(Tower o) {
+			return Integer.compare(val, o.val);
+		}
+	}
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		int cases = Integer.parseInt(br.readLine());
+		while(cases-- > 0) {
+			String[] str = br.readLine().split("" "");
+			int n = Integer.parseInt(str[0]);
+			int m = Integer.parseInt(str[1]);
+			int x = Integer.parseInt(str[2]);
+			int[] h = new int[n];
+			str = br.readLine().split("" "");
+			for(int i=0; i<n; i++) {
+				h[i] = Integer.parseInt(str[i]);
+			}
+			PriorityQueue<Tower> q = new PriorityQueue<>(m);
+			int[] ans = new int[n];
+			for(int i=0; i<m; i++) {
+				q.add(new Tower(i, h[i]));
+				ans[i] = i;
+			}
+			for(int i=m; i<n; i++) {
+				Tower lowest = q.poll();
+				lowest.val += h[i];
+				ans[i] = lowest.index;
+				q.add(lowest);
+			}
+			System.out.println(""YES"");
+			for(int i=0; i<n; i++) {
+				System.out.print((ans[i]+1) + "" "");
+			}
+			System.out.println();
+		}
+	}
+}
+",0
+3ff25f43,a195911e,"import java.io.BufferedInputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+
+public class EDU121C {
+    public static void main(String[] args) {
+        JS scan = new JS();
+        int t = scan.nextInt();
+        while(t-->0){
+            int n = scan.nextInt();
+            long[] k = new long[n];
+            long[] h = new long[n];
+            for(int i =0;i<n;i++){
+                k[i] = scan.nextInt();
+            }
+            for(int i = 0;i<n;i++){
+                h[i] = scan.nextInt();
+            }
+            long ans = 0;
+            long lastD = 0;
+            long lastHP = 0;
+            for(int i = 0;i<n;i++){
+                long dist = k[i]-lastD;
+                long lo = h[i];
+                long hi = lastHP+dist;
+                long hpComingOut = 0;
+                while(lo<=hi){
+                    long mid = (lo+hi)/2;
+                    boolean check = false;
+                    for(int j = i+1;j<n;j++){
+                        if(k[j]-k[i]<h[j]-mid){
+                            check = true;
+                            break;
+                        }
+                    }
+                    if(check){
+                        //we're in trouble
+                        lo = mid+1;
+                    }else{
+                        hi = mid-1;
+                        hpComingOut = mid;
+                    }
+                }
+                if(hpComingOut>dist){
+                    ans+=summ(dist+lastHP)-summ(lastHP);
+                    lastHP+=dist;
+                }else{
+                    long diff = dist-hpComingOut;
+                    ans+=summ(hpComingOut);
+                    lastHP = hpComingOut;
+                }
+                lastD = k[i];
+            }
+            System.out.println(ans);
+        }
+    }
+    static long summ(long a){
+        return (a*(a+1))/2;
+    }
+    static class JS {
+        public int BS = 1 << 16;
+        public char NC = (char) 0;
+        byte[] buf = new byte[BS];
+        int bId = 0, size = 0;
+        char c = NC;
+        double num = 1;
+        BufferedInputStream in;
+
+        public JS() {
+            in = new BufferedInputStream(System.in, BS);
+        }
+
+        public JS(String s) throws FileNotFoundException {
+            in = new BufferedInputStream(new FileInputStream(new File(s)), BS);
+        }
+
+        public char nextChar() {
+            while (bId == size) {
+                try {
+                    size = in.read(buf);
+                } catch (Exception e) {
+                    return NC;
+                }
+                if (size == -1) return NC;
+                bId = 0;
+            }
+            return (char) buf[bId++];
+        }
+
+        public int nextInt() {
+            return (int) nextLong();
+        }
+
+        public long nextLong() {
+            num = 1;
+            boolean neg = false;
+            if (c == NC) c = nextChar();
+            for (; (c < '0' || c > '9'); c = nextChar()) {
+                if (c == '-') neg = true;
+            }
+            long res = 0;
+            for (; c >= '0' && c <= '9'; c = nextChar()) {
+                res = (res << 3) + (res << 1) + c - '0';
+                num *= 10;
+            }
+            return neg ? -res : res;
+        }
+
+        public double nextDouble() {
+            double cur = nextLong();
+            return c != '.' ? cur : cur + nextLong() / num;
+        }
+
+        public String next() {
+            StringBuilder res = new StringBuilder();
+            while (c <= 32) c = nextChar();
+            while (c > 32) {
+                res.append(c);
+                c = nextChar();
+            }
+            return res.toString();
+        }
+
+        public String nextLine() {
+            StringBuilder res = new StringBuilder();
+            while (c <= 32) c = nextChar();
+            while (c != '\n') {
+                res.append(c);
+                c = nextChar();
+            }
+            return res.toString();
+        }
+
+        public boolean hasNext() {
+            if (c > 32) return true;
+            while (true) {
+                c = nextChar();
+                if (c == NC) return false;
+                else if (c > 32) return true;
+            }
+        }
+    }
+}
+","import java.util.*;
+
+import java.io.*;
+import java.math.*;
+
+
+public class Main
+
+{ 
+	 static FastReader sc=new FastReader(); 
+	 static int dp[];
+	 static boolean v[];
+//	 static int mod=998244353;;
+	 static int mod=1000000007;
+	 static int max;
+	 static int bit[];
+	 //static long fact[];
+//	 static long A[];
+	 static HashMap<Integer,Integer> map;
+	 //static StringBuffer sb=new StringBuffer("""");
+	 //static HashMap<Integer,Integer> map;
+	   static PrintWriter out=new PrintWriter(System.out);
+	  public static void main(String[] args)
+	  {
+		 //  StringBuffer sb=new StringBuffer("""");
+		  int ttt=1;
+		       ttt =i();		       
+	        outer :while (ttt-- > 0) 
+	        {
+	        	int n=i();
+	        	long A[]=inputL(n);
+	        	long B[]=inputL(n);
+	        	long C[]=new long[n];
+	        	for(int i=0;i<n;i++) {
+	        		C[i]=A[i]-B[i]+1;
+	        	}
+	        	long min=C[n-1];
+	        	long ans=0;
+	        	long last=A[n-1];
+	        	for(int i=n-1;i>=0;i--) {
+	        		if(C[i]>min) {
+	        			continue;
+	        		}
+	        		if(A[i]<min) {
+	        			long y=last-min+1;
+	        			ans+=y*(y+1)/2;
+	        			last=A[i];
+	        			min=C[i];
+	        			continue;
+	        		}
+	        		
+	        		min=C[i];
+	        		
+	        	}
+	        	long y=last-min+1;
+    			ans+=y*(y+1)/2;
+	        	System.out.println(ans);
+	        }
+	        //System.out.println(sb.toString());
+		     out.close();
+	     
+	     
+	    //CHECK FOR N=1                    //CHECK FOR M=0
+        //CHECK FOR N=1                    //CHECK FOR M=0
+       	//CHECK FOR N=1
+       	
+		        
+		     
+    }
+	 
+	 
+	 
+	
+	
+	  
+	 
+	 
+static class Pair implements Comparable<Pair>
+     {
+    	 int x;
+    	 int y;
+    	 int z;
+    	 Pair(int x,int y){
+    		 this.x=x;
+    		 this.y=y;
+//    		 this.z=z;
+    		 
+    	 }
+		@Override
+		public int compareTo(Pair o) {
+			if(this.x>o.x)
+				return 1;
+			else if(this.x<o.x)
+				return -1;
+			else {
+				if(this.y>o.y)
+					return 1;
+				else if(this.y<o.y)
+					return -1;
+				else
+					return 0;
+			}
+		}
+		public int hashCode() 
+		{ 
+			final int temp = 14; 
+			int ans = 1; 
+			ans =x*31+y*13; 
+			return ans; 
+		} 
+		@Override
+		public boolean equals(Object o) 
+		{ 
+			if (this == o) { 
+				return true; 
+			} 
+			if (o == null) { 
+				return false; 
+			} 
+			if (this.getClass() != o.getClass()) { 
+				return false; 
+			} 
+			Pair other = (Pair)o; 
+			if (this.x != other.x || this.y!=other.y) { 
+				return false; 
+			} 
+			return true; 
+		} 	
+//		
+		/* FOR TREE MAP PAIR USE */
+		
+//		public int compareTo(Pair o) {
+// 			if (x > o.x) {
+// 				return 1;
+// 			}
+// 			if (x < o.x) {
+// 				return -1;
+// 			}
+// 			if (y > o.y) {
+// 				return 1;
+// 			}
+// 			if (y < o.y) {
+// 				return -1;
+// 			}
+// 			return 0;
+// 		}
+		
+     }
+
+static int find(int A[],int a) {
+	  if(A[a]==a)
+		  return a;
+	  return A[a]=find(A, A[a]);
+}
+//static int find(int A[],int a) {
+//	  if(A[a]==a)
+//		  return a;
+//	  return find(A, A[a]);
+//}
+//FENWICK TREE
+static void update(int i, int x){
+	for(; i < bit.length; i += (i&-i))
+		bit[i] += x;
+}
+
+static int sum(int i){
+	int ans = 0;
+	for(; i > 0; i -= (i&-i))
+		ans += bit[i];
+	return ans;
+}
+//END
+static void add(int v) {
+	if(!map.containsKey(v)) {
+		map.put(v, 1);
+	}
+	else {
+		map.put(v, map.get(v)+1);
+	}
+}
+static void remove(int v) {
+	if(map.containsKey(v)) {
+		map.put(v, map.get(v)-1);
+		if(map.get(v)==0)
+			map.remove(v);
+	}
+}
+public static int upper(int A[],int k,int si,int ei)
+{
+	int l=si;
+	int u=ei;
+	int ans=-1;
+	while(l<=u) {
+		int mid=(l+u)/2;
+		if(A[mid]<=k) {
+			ans=mid;
+			l=mid+1;
+		}
+		else {
+			u=mid-1;
+		}
+	}
+	return ans;
+}
+public static int lower(int A[],int k,int si,int ei)
+{
+	int l=si;
+	int u=ei;
+	int ans=-1;
+	while(l<=u) {
+		int mid=(l+u)/2;
+		if(A[mid]<=k) {
+			l=mid+1;
+		}
+		else {
+			ans=mid;
+			u=mid-1;
+		}
+	}
+	return ans;
+	
+    
+}
+static int[] copy(int A[]) {
+	int B[]=new int[A.length];
+	for(int i=0;i<A.length;i++) {
+		B[i]=A[i];
+	}
+	return B;
+}
+static long[] copy(long A[]) {
+	long B[]=new long[A.length];
+	for(int i=0;i<A.length;i++) {
+		B[i]=A[i];
+	}
+	return B;
+}
+static int[] input(int n) {
+	int A[]=new int[n];
+	   for(int i=0;i<n;i++) {
+		   A[i]=sc.nextInt();
+	   }
+	   return A;
+   }
+static long[] inputL(int n) {
+	long A[]=new long[n];
+	   for(int i=0;i<n;i++) {
+		   A[i]=sc.nextLong();
+	   }
+	   return A;
+   }
+static String[] inputS(int n) {
+	String A[]=new String[n];
+	   for(int i=0;i<n;i++) {
+		   A[i]=sc.next();
+	   }
+	   return A;
+   }
+static long sum(int A[]) {
+	long sum=0;
+	for(int i : A) {
+		sum+=i;
+	}
+	return sum;
+}
+static long sum(long A[]) {
+	long sum=0;
+	for(long i : A) {
+		sum+=i;
+	}
+	return sum;
+}
+static void reverse(long A[]) {
+	int n=A.length;
+	long B[]=new long[n];
+	for(int i=0;i<n;i++) {
+		B[i]=A[n-i-1];
+	}
+	for(int i=0;i<n;i++)
+		A[i]=B[i];
+	
+}
+static void reverse(int A[]) {
+	int n=A.length;
+	int B[]=new int[n];
+	for(int i=0;i<n;i++) {
+		B[i]=A[n-i-1];
+	}
+	for(int i=0;i<n;i++)
+		A[i]=B[i];
+	
+}
+static void input(int A[],int B[]) {
+	   for(int i=0;i<A.length;i++) {
+		   A[i]=sc.nextInt();
+		   B[i]=sc.nextInt();
+	   }
+}
+static int[][] input(int n,int m){
+	int A[][]=new int[n][m];
+	for(int i=0;i<n;i++) {
+		for(int j=0;j<m;j++) {
+			A[i][j]=i();
+		}
+	}
+	return A;
+}
+static char[][] charinput(int n,int m){
+	char A[][]=new char[n][m];
+	for(int i=0;i<n;i++) {
+		String s=s();
+		for(int j=0;j<m;j++) {
+			A[i][j]=s.charAt(j);
+		}
+	}
+	return A;
+}
+static int nextPowerOf2(int n)
+{
+    n--;
+    n |= n >> 1;
+    n |= n >> 2;
+    n |= n >> 4;
+    n |= n >> 8;
+    n |= n >> 16;
+    n++;
+     
+    return n;
+}
+static int highestPowerof2(int x)
+{
+   
+    x |= x >> 1;
+    x |= x >> 2;
+    x |= x >> 4;
+    x |= x >> 8;
+    x |= x >> 16;
+     
+    return x ^ (x >> 1); 
+ 
+}
+static long highestPowerof2(long x)
+{
+   
+    x |= x >> 1;
+    x |= x >> 2;
+    x |= x >> 4;
+    x |= x >> 8;
+    x |= x >> 16;
+    return x ^ (x >> 1); 
+ 
+}
+
+static int max(int A[]) {
+	int max=Integer.MIN_VALUE;
+	for(int i=0;i<A.length;i++) {
+		max=Math.max(max, A[i]);
+	}
+	return max;
+}
+static int min(int A[]) {
+	int min=Integer.MAX_VALUE;
+	for(int i=0;i<A.length;i++) {
+		min=Math.min(min, A[i]);
+	}
+	return min;
+}
+static long max(long A[]) {
+	long max=Long.MIN_VALUE;
+	for(int i=0;i<A.length;i++) {
+		max=Math.max(max, A[i]);
+	}
+	return max;
+}
+static long min(long A[]) {
+	long min=Long.MAX_VALUE;
+	for(int i=0;i<A.length;i++) {
+		min=Math.min(min, A[i]);
+	}
+	return min;
+}
+static long [] prefix(long A[]) {
+	long p[]=new long[A.length];
+	p[0]=A[0];
+	for(int i=1;i<A.length;i++)
+		p[i]=p[i-1]+A[i];
+	return p;
+}
+static long [] prefix(int A[]) {
+	long p[]=new long[A.length];
+	p[0]=A[0];
+	for(int i=1;i<A.length;i++)
+		p[i]=p[i-1]+A[i];
+	return p;
+}
+static long [] suffix(long A[]) {
+	long p[]=new long[A.length];
+	p[A.length-1]=A[A.length-1];
+	for(int i=A.length-2;i>=0;i--)
+		p[i]=p[i+1]+A[i];
+	return p;
+}
+static long [] suffix(int A[]) {
+	long p[]=new long[A.length];
+	p[A.length-1]=A[A.length-1];
+	for(int i=A.length-2;i>=0;i--)
+		p[i]=p[i+1]+A[i];
+	return p;
+}
+static void fill(int dp[]) {
+	Arrays.fill(dp, -1);
+}
+static void fill(int dp[][]) {
+	for(int i=0;i<dp.length;i++)
+	Arrays.fill(dp[i], -1);
+}
+static void fill(int dp[][][]) {
+	for(int i=0;i<dp.length;i++) {
+		for(int j=0;j<dp[0].length;j++) {
+			Arrays.fill(dp[i][j],-1);
+		}
+	}
+}
+static void fill(int dp[][][][]) {
+	for(int i=0;i<dp.length;i++) {
+		for(int j=0;j<dp[0].length;j++) {
+			for(int k=0;k<dp[0][0].length;k++) {
+			Arrays.fill(dp[i][j][k],-1);
+			}
+		}
+	}
+}
+static void fill(long dp[]) {
+	Arrays.fill(dp, -1);
+}
+static void fill(long dp[][]) {
+	for(int i=0;i<dp.length;i++)
+	Arrays.fill(dp[i], -1);
+}
+static void fill(long dp[][][]) {
+	for(int i=0;i<dp.length;i++) {
+		for(int j=0;j<dp[0].length;j++) {
+			Arrays.fill(dp[i][j],-1);
+		}
+	}
+}
+static void fill(long dp[][][][]) {
+	for(int i=0;i<dp.length;i++) {
+		for(int j=0;j<dp[0].length;j++) {
+			for(int k=0;k<dp[0][0].length;k++) {
+			Arrays.fill(dp[i][j][k],-1);
+			}
+		}
+	}
+}
+static int min(int a,int b) {
+	return Math.min(a, b);
+}
+static int min(int a,int b,int c) {
+	return Math.min(a, Math.min(b, c));
+}
+static int min(int a,int b,int c,int d) {
+	return Math.min(a, Math.min(b, Math.min(c, d)));
+}
+static int max(int a,int b) {
+	return Math.max(a, b);
+}
+static int max(int a,int b,int c) {
+	return Math.max(a, Math.max(b, c));
+}
+static int max(int a,int b,int c,int d) {
+	return Math.max(a, Math.max(b, Math.max(c, d)));
+}
+static long min(long a,long b) {
+	return Math.min(a, b);
+}
+static long min(long a,long b,long c) {
+	return Math.min(a, Math.min(b, c));
+}
+static long min(long a,long b,long c,long d) {
+	return Math.min(a, Math.min(b, Math.min(c, d)));
+}
+static long max(long a,long b) {
+	return Math.max(a, b);
+}
+static long max(long a,long b,long c) {
+	return Math.max(a, Math.max(b, c));
+}
+static long max(long a,long b,long c,long d) {
+	return Math.max(a, Math.max(b, Math.max(c, d)));
+}
+
+static long power(long x, long y, long p)
+{
+
+	if(y==0)
+		return 1;
+	if(x==0)
+		return 0;
+    long res = 1;
+    x = x % p;
+
+    while (y > 0) {
+
+        if (y % 2 == 1)
+            res = (res * x) % p;
+
+        y = y >> 1; 
+        x = (x * x) % p;
+    }
+
+    return res;
+}
+static long power(long x, long y)
+{
+
+	if(y==0)
+		return 1;
+	if(x==0)
+		return 0;
+    long res = 1;
+
+    while (y > 0) {
+
+        if (y % 2 == 1)
+            res = (res * x);
+
+        y = y >> 1; 
+        x = (x * x);
+    }
+
+    return res;
+}
+static void print(int A[]) {
+	for(int i : A) {
+		out.print(i+"" "");
+	}
+	out.println();
+}
+static void print(long A[]) {
+	for(long i : A) {
+		System.out.print(i+"" "");
+	}
+	System.out.println();
+}
+static long mod(long x) {
+	  return ((x%mod + mod)%mod);
+}
+static String reverse(String s) {
+	StringBuffer p=new StringBuffer(s);
+	p.reverse();
+	return p.toString();
+}
+
+     static int i() {
+    	 return sc.nextInt();
+     }
+     static String s() {
+    	 return sc.next();
+     }
+     static long l() {
+    	 return sc.nextLong();
+     }  
+     static void sort(int[] A){
+        int n = A.length;
+        Random rnd = new Random();
+        for(int i=0; i<n; ++i){
+            int tmp = A[i];
+            int randomPos = i + rnd.nextInt(n-i);
+            A[i] = A[randomPos];
+            A[randomPos] = tmp;
+        }
+        Arrays.sort(A);
+     }
+     static void sort(long[] A){
+	        int n = A.length;
+	        Random rnd = new Random();
+	        for(int i=0; i<n; ++i){
+	            long tmp = A[i];
+	            int randomPos = i + rnd.nextInt(n-i);
+	            A[i] = A[randomPos];
+	            A[randomPos] = tmp;
+	        }
+	        Arrays.sort(A);
+	     }
+  static String sort(String s) {
+ 	 Character ch[]=new Character[s.length()];
+ 	 for(int i=0;i<s.length();i++) {
+ 		 ch[i]=s.charAt(i);
+ 	 }
+ 	 Arrays.sort(ch);
+ 	 StringBuffer st=new StringBuffer("""");
+ 	 for(int i=0;i<s.length();i++) {
+ 		 st.append(ch[i]);
+ 	 }
+ 	 return st.toString();
+  }
+  static HashMap<Integer,Integer> hash(int A[]){
+	  HashMap<Integer,Integer> map=new HashMap<Integer, Integer>();
+	  for(int i : A) {
+		  if(map.containsKey(i)) {
+			  map.put(i, map.get(i)+1);
+		  }
+		  else {
+			  map.put(i, 1);
+		  }
+	  }
+	  return map;
+  }
+  static HashMap<Long,Integer> hash(long A[]){
+	  HashMap<Long,Integer> map=new HashMap<Long, Integer>();
+	  for(long i : A) {
+		  if(map.containsKey(i)) {
+			  map.put(i, map.get(i)+1);
+		  }
+		  else {
+			  map.put(i, 1);
+		  }
+	  }
+	  return map;
+  }
+  static TreeMap<Integer,Integer> tree(int A[]){
+	  TreeMap<Integer,Integer> map=new TreeMap<Integer, Integer>();
+	  for(int i : A) {
+		  if(map.containsKey(i)) {
+			  map.put(i, map.get(i)+1);
+		  }
+		  else {
+			  map.put(i, 1);
+		  }
+	  }
+	  return map;
+  }
+  static TreeMap<Long,Integer> tree(long A[]){
+	  TreeMap<Long,Integer> map=new TreeMap<Long, Integer>();
+	  for(long i : A) {
+		  if(map.containsKey(i)) {
+			  map.put(i, map.get(i)+1);
+		  }
+		  else {
+			  map.put(i, 1);
+		  }
+	  }
+	  return map;
+  }
+     static boolean prime(int n) 
+	    { 
+	        if (n <= 1) 
+	            return false; 
+	        if (n <= 3) 
+	            return true; 
+	        if (n % 2 == 0 || n % 3 == 0) 
+	            return false; 
+	        double sq=Math.sqrt(n);
+	  
+	        for (int i = 5; i <= sq; i = i + 6) 
+	            if (n % i == 0 || n % (i + 2) == 0) 
+	                return false; 
+	        return true; 
+	    } 
+     static boolean prime(long n) 
+	    { 
+	        if (n <= 1) 
+	            return false; 
+	        if (n <= 3) 
+	            return true; 
+	        if (n % 2 == 0 || n % 3 == 0) 
+	            return false; 
+	        double sq=Math.sqrt(n);
+	  
+	        for (int i = 5; i <= sq; i = i + 6) 
+	            if (n % i == 0 || n % (i + 2) == 0) 
+	                return false; 
+	        return true; 
+	    } 
+     static int gcd(int a, int b) 
+     { 
+         if (a == 0) 
+             return b; 
+         return gcd(b % a, a); 
+     } 
+     static long gcd(long a, long b) 
+     { 
+         if (a == 0) 
+             return b; 
+         return gcd(b % a, a); 
+     } 
+     
+        
+    static class FastReader 
+    { 
+        BufferedReader br; 
+        StringTokenizer st; 
+  
+        public FastReader() 
+        { 
+            br = new BufferedReader(new
+                     InputStreamReader(System.in)); 
+        } 
+  
+        String next() 
+        { 
+            while (st == null || !st.hasMoreElements()) 
+            { 
+                try
+                { 
+                    st = new StringTokenizer(br.readLine()); 
+                } 
+                catch (IOException  e) 
+                { 
+                    e.printStackTrace(); 
+                } 
+            } 
+            return st.nextToken(); 
+        } 
+  
+        int nextInt() 
+        { 
+            return Integer.parseInt(next()); 
+        } 
+  
+        long nextLong() 
+        { 
+            return Long.parseLong(next()); 
+        } 
+  
+        double nextDouble() 
+        { 
+            return Double.parseDouble(next()); 
+        } 
+  
+        String nextLine() 
+        { 
+            String str = """"; 
+            try
+            { 
+                str = br.readLine(); 
+            } 
+            catch (IOException e) 
+            { 
+                e.printStackTrace(); 
+            } 
+            return str; 
+        } 
+    } 
+} 
+
+
+
+",0
+8be61667,ca3128ab,"import java.io.*;
+import java.util.*;
+public class Main {
+    public static void main(String args[])
+    {
+        FastReader input=new FastReader();
+        PrintWriter out=new PrintWriter(System.out);
+        int T=input.nextInt();
+        while(T-->0)
+        {
+            int n=input.nextInt();
+            int c[]=new int[n];
+            for(int i=0;i<n;i++)
+            {
+                c[i]=input.nextInt();
+            }
+            long me=Integer.MAX_VALUE;
+            long mo=Integer.MAX_VALUE;
+            long se=0,so=0;
+            long min=Long.MAX_VALUE;
+            for(int i=1;i<=n;i++)
+            {
+                if(i%2==0)
+                {
+                    me=Math.min(me,c[i-1]);
+                    se+=c[i-1];
+                }
+                else
+                {
+                    mo=Math.min(mo,c[i-1]);
+                    so+=c[i-1];
+                }
+                if(i>=2)
+                {
+                    long sum=0;
+                    long c1=i/2+i%2;
+                    long c2=(i-1)/2+(i-1)%2;
+                    if(i%2==0)
+                    {
+                        sum+=se;
+                        sum+=(me)*(n-c1);
+                        sum+=so;
+                        sum+=mo*(n-c2);
+                    }
+                    else
+                    {
+                        sum+=so;
+                        sum+=(mo)*(n-c1);
+                        sum+=se;
+                        sum+=me*(n-c2);
+                    }
+                    min=Math.min(min,sum);
+                }
+            }
+            out.println(min);
+        }
+        out.close();
+    }
+    static class FastReader
+    {
+        BufferedReader br;
+        StringTokenizer st;
+        public FastReader()
+        {
+            br = new BufferedReader(new InputStreamReader(System.in));
+        }
+        String next()
+        {
+            while (st == null || !st.hasMoreElements())
+            {
+                try
+                {
+                    st = new StringTokenizer(br.readLine());
+                }
+                catch (IOException e)
+                {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+        int nextInt()
+        {
+            return Integer.parseInt(next());
+        }
+        long nextLong()
+        {
+            return Long.parseLong(next());
+        }
+        double nextDouble()
+        {
+            return Double.parseDouble(next());
+        }
+        String nextLine()
+        {
+            String str="""";
+            try
+            {
+                str=br.readLine();
+            }
+            catch (IOException e)
+            {
+                e.printStackTrace();
+            }
+            return str;
+        }
+    }
+}","
+import java.io.*;
+import java.math.*;
+import java.util.*;
+
+
+public class test {
+	 
+	   static class Pair{ 
+		   long x;
+		   long y;
+		   
+		   Pair(long x,long y){ 
+			   this.x = x;
+			   this.y = y;
+			   
+		   }
+	   }
+	  
+	   static class Compare { 
+		   
+		     void compare(Pair arr[], int n) 
+		    { 
+		        // Comparator to sort the pair according to second element 
+		        Arrays.sort(arr, new Comparator<Pair>() { 
+		            @Override public int compare(Pair p1, Pair p2) 
+		            { 
+		            	if(p1.x!=p2.x) {
+		                return (int)(p1.x - p2.x); 
+		            	}
+		            	else { 
+		            		return (int)(p1.y - p2.y);
+		            	}
+		            } 
+		        }); 
+		  
+//		        for (int i = 0; i < n; i++) { 
+//		            System.out.print(arr[i].x + "" "" + arr[i].y + "" ""); 
+//		        } 
+//		        System.out.println(); 
+		    } 
+		} 
+	 
+	   static class Scanner {
+	        BufferedReader br;
+	        StringTokenizer st;
+	 
+	        public Scanner()
+	        {
+	            br = new BufferedReader(
+	                new InputStreamReader(System.in));
+	        }
+	 
+	        String next()
+	        {
+	            while (st == null || !st.hasMoreElements()) {
+	                try {
+	                    st = new StringTokenizer(br.readLine());
+	                }
+	                catch (IOException e) {
+	                    e.printStackTrace();
+	                }
+	            }
+	            return st.nextToken();
+	        }
+	 
+	        int nextInt() { return Integer.parseInt(next()); }
+	 
+	        long nextLong() { return Long.parseLong(next()); }
+	 
+	        double nextDouble()
+	        {
+	            return Double.parseDouble(next());
+	        }
+	 
+	        String nextLine()
+	        {
+	            String str = """";
+	            try {
+	                str = br.readLine();
+	            }
+	            catch (IOException e) {
+	                e.printStackTrace();
+	            }
+	            return str;
+	        }
+	    }
+	
+	
+	   public static void main(String args[]) throws Exception { 
+		
+		   
+		   Scanner sc = new Scanner();
+		   StringBuilder res = new StringBuilder();
+		   
+		   int tc = sc.nextInt();
+		   
+		   while(tc-->0) { 
+			
+			int n = sc.nextInt();
+			
+			long c[] = new long[n];
+			
+			for(int i=0;i<n;i++) { 
+				c[i] = sc.nextLong();
+			}
+			
+			
+			long min_odd = Integer.MAX_VALUE;
+			long min_even = Integer.MAX_VALUE;
+		    long ans = Long.MAX_VALUE;
+		    long sum = 0;
+		    
+			int cnt1 = n;
+			
+			int cnt2 = n;
+			
+			
+		    for(int i = 0; i < n; i++){
+		        sum += c[i];
+		        if(i % 2 == 0){
+		            cnt1--;
+		            min_odd = Math.min(min_odd, c[i]);
+		        }
+		        else{
+		            cnt2--;
+		            min_even = Math.min(min_even, c[i]);
+		        }
+		        if(i > 0){
+		            long temp = sum + (min_odd * cnt1) + (min_even * cnt2);
+		            ans = Math.min(ans, temp);
+		        }
+		 
+		    }
+		    
+		    System.out.println(ans);
+		   }
+		   
+		   System.out.println(res);
+	   }
+}  
+
+
+
+
+",0
+680ba922,6d7d5dd7,"import java.util.*;
+import java.io.*;
+
+public class Solution
+{
+    static class Reader {
+        final private int BUFFER_SIZE = 1 << 16;
+        private DataInputStream din;
+        private byte[] buffer;
+        private int bufferPointer, bytesRead;
+ 
+        public Reader()
+        {
+            din = new DataInputStream(System.in);
+            buffer = new byte[BUFFER_SIZE];
+            bufferPointer = bytesRead = 0;
+        }
+ 
+        public Reader(String file_name) throws IOException
+        {
+            din = new DataInputStream(
+                new FileInputStream(file_name));
+            buffer = new byte[BUFFER_SIZE];
+            bufferPointer = bytesRead = 0;
+        }
+ 
+        public String readLine() throws IOException
+        {
+            byte[] buf = new byte[64]; // line length
+            int cnt = 0, c;
+            while ((c = read()) != -1) {
+                if (c == '\n') {
+                    if (cnt != 0) {
+                        break;
+                    }
+                    else {
+                        continue;
+                    }
+                }
+                buf[cnt++] = (byte)c;
+            }
+            return new String(buf, 0, cnt);
+        }
+ 
+        public int nextInt() throws IOException
+        {
+            int ret = 0;
+            byte c = read();
+            while (c <= ' ') {
+                c = read();
+            }
+            boolean neg = (c == '-');
+            if (neg)
+                c = read();
+            do {
+                ret = ret * 10 + c - '0';
+            } while ((c = read()) >= '0' && c <= '9');
+ 
+            if (neg)
+                return -ret;
+            return ret;
+        }
+ 
+        public long nextLong() throws IOException
+        {
+            long ret = 0;
+            byte c = read();
+            while (c <= ' ')
+                c = read();
+            boolean neg = (c == '-');
+            if (neg)
+                c = read();
+            do {
+                ret = ret * 10 + c - '0';
+            } while ((c = read()) >= '0' && c <= '9');
+            if (neg)
+                return -ret;
+            return ret;
+        }
+ 
+        public double nextDouble() throws IOException
+        {
+            double ret = 0, div = 1;
+            byte c = read();
+            while (c <= ' ')
+                c = read();
+            boolean neg = (c == '-');
+            if (neg)
+                c = read();
+ 
+            do {
+                ret = ret * 10 + c - '0';
+            } while ((c = read()) >= '0' && c <= '9');
+ 
+            if (c == '.') {
+                while ((c = read()) >= '0' && c <= '9') {
+                    ret += (c - '0') / (div *= 10);
+                }
+            }
+ 
+            if (neg)
+                return -ret;
+            return ret;
+        }
+ 
+        private void fillBuffer() throws IOException
+        {
+            bytesRead = din.read(buffer, bufferPointer = 0,
+                                 BUFFER_SIZE);
+            if (bytesRead == -1)
+                buffer[0] = -1;
+        }
+ 
+        private byte read() throws IOException
+        {
+            if (bufferPointer == bytesRead)
+                fillBuffer();
+            return buffer[bufferPointer++];
+        }
+ 
+        public void close() throws IOException
+        {
+            if (din == null)
+                return;
+            din.close();
+        }
+    }
+    
+   
+  static int parent(int a , int p[])
+  {
+      if(a == p[a])
+      return a;
+      
+      return p[a] = parent(p[a],p);
+  }
+  
+  static void union(int a , int b , int p[] , int size[])
+  {
+      a = parent(a,p);
+      b = parent(b,p);
+      
+      if(a == b)
+      return;
+      
+      if(size[a] < size[b])
+      {
+          int temp = a;
+          a = b;
+          b = temp;
+      }
+      
+      p[b] = a;
+      size[a] += size[b];
+  }
+  
+  
+  
+  
+ static long getSum(int index , long BITree[])
+    {
+        long sum = 0; // Iniialize result
+      
+        // index in BITree[] is 1 more than
+        // the index in arr[]
+       // index = index + 1;
+      
+        // Traverse ancestors of BITree[index]
+        while(index>0)
+        {
+            // Add current element of BITree 
+            // to sum
+            sum += BITree[index];
+      
+            // Move index to parent node in 
+            // getSum View
+            index -= index & (-index);
+        }
+        return sum;
+    }
+  
+    // Updates a node in Binary Index Tree (BITree)
+    // at given index in BITree. The given value 
+    // 'val' is added to BITree[i] and all of 
+    // its ancestors in tree.
+    public static void updateBIT(int n, int index, 
+                                        long val , long BITree[])
+    {
+        // index in BITree[] is 1 more than 
+        // the index in arr[]
+      //  index = index + 1;
+      
+        // Traverse all ancestors and add 'val'
+        while(index <= n)
+        {
+        // Add 'val' to current node of BIT Tree
+        BITree[index] += val;
+      
+        // Update index to that of parent 
+        // in update View
+        index += index & (-index);
+        }
+    }
+    
+    
+   static int gcd(int a, int b)
+{
+    if (a == 0)
+        return b;
+    return gcd(b % a, a);
+}
+
+static int dp[][];
+
+
+static int f(int pos , int take , int arr[])
+{
+    if(pos == -1)
+    {
+        if(take == 0)
+    return 0;
+    
+    return -10000000;
+    
+    }
+    
+    
+    if(dp[pos][take] != -1)
+    return dp[pos][take];
+    
+    
+    if(pos+1-take == arr[pos])
+    dp[pos][take] = Math.max(dp[pos][take],1 + f(pos-1,take,arr));
+    
+    
+    dp[pos][take] = Math.max(dp[pos][take],f(pos-1,take,arr));
+    
+    
+    if(take > 0)
+    dp[pos][take] = Math.max(dp[pos][take],f(pos-1,take-1,arr));
+    
+    return dp[pos][take];
+}
+    public static void main(String []args) throws IOException
+    {
+        Scanner sc = new Scanner(System.in);
+        int t = sc.nextInt();
+        while(t-- > 0)
+        {
+            int n = sc.nextInt();
+            sc.nextLine();
+            String a = sc.nextLine();
+            String b = sc.nextLine();
+            int same = 0 , zo = 0 , oz = 0 , oo = 0 , zz = 0;
+            for(int i = 0 ; i < n ; i++)
+            {
+                if(a.charAt(i) == '0' && b.charAt(i) == '1')
+                oz++;
+                
+                else if(a.charAt(i) == '1' && b.charAt(i) == '0')
+                zo++;
+                
+                else if(a.charAt(i) == '1' && b.charAt(i) == '1')
+                oo++;
+                
+                else
+                zz++;
+            }
+            
+            if(oz == zo || (zz == oo-1))
+            {
+                int mx = Integer.MAX_VALUE;
+                if(oz == zo)
+                mx = Math.min(mx,2*oz);
+                
+                if(oo-1 == zz)
+                mx = Math.min(mx,zz+oo);
+                
+                System.out.println(mx);
+            }
+            
+            else
+            {
+                System.out.println(-1);
+            }
+        }
+    }
+}","
+import java.util.Scanner;
+
+public class Menorah {
+
+    public static void main(String[] args) {
+        Scanner scan = new Scanner(System.in);
+        int t = scan.nextInt();
+        k:
+        while (t-- > 0) {
+            int n = scan.nextInt();
+            String a = scan.next();
+            String b = scan.next();
+            int zo = 0;
+            int oz = 0;
+            int ind = -1;
+            for (int i = 0; i < n; i++) {
+                if (a.charAt(i) == '0' && b.charAt(i) == '1') {
+                    ++zo;
+                } else if (a.charAt(i) == '1' && b.charAt(i) == '0') {
+                    ++oz;
+                } else if (a.charAt(i) == '1' && b.charAt(i) == '1') {
+                    ind = i;
+                }
+            }
+            int res = 1000000000;
+            int res2 = 1000000000;
+            if (zo == oz) {
+                res = zo + oz;
+            }
+            if (ind != -1) {
+                char[] s = a.toCharArray();
+                for (int i = 0; i < n; i++) {
+                    if (i == ind) {
+                        continue;
+                    }
+                    if (s[i] == '0') {
+                        s[i] = '1';
+                    } else {
+                        s[i] = '0';
+                    }
+                }
+
+                zo = 0;
+                oz = 0;
+
+                for (int i = 0; i < n; i++) {
+
+                    if (s[i] == '0' && b.charAt(i) == '1') {
+                        ++zo;
+                    } else if (s[i] == '1' && b.charAt(i) == '0') {
+                        ++oz;
+                    }
+                }
+
+                if (zo == oz) {
+                    res2 = zo + oz + 1;
+                }
+
+            }
+            if (res == 1000000000 && res2 == 1000000000) {
+                System.out.println(""-1"");
+            } else {
+                System.out.println(Math.min(res, res2));
+            }
+
+        }
+    }
+}
+",0
+884f5678,9862c742,"import java.io.*;
+import java.util.*;
+import java.text.*;
+import java.math.*;
+import java.util.regex.*;
+
+public class JaiShreeRam{
+	static Scanner in=new Scanner();
+	static long mod = 1000000007;
+	static ArrayList<ArrayList<Integer>> adj;
+	public static void main(String[] args) throws Exception{
+		class Element{
+			int x;
+			char c;
+			public Element(int y,char k) {
+				x=y;
+				c=k;
+			}
+		}
+		int z=in.readInt();
+		while(z-->0) {
+			int n=in.readInt();
+			int a[]=nia(n);
+			char c[]=in.readString().toCharArray();
+			ArrayList<Integer> d=new ArrayList<>();
+			ArrayList<Integer> in=new ArrayList<>();
+			for(int i=0;i<n;i++) {
+				if(c[i]=='R') {
+					in.add(a[i]);
+				}
+				else {
+					d.add(a[i]);
+				}
+			}
+			String ans=""YES"";
+			Collections.sort(d);
+			int k=1;
+			for(int i:d) {
+				if(i<k) {
+					ans=""NO"";
+				}
+				k++;
+			}
+			Collections.sort(in);
+			for(int i=in.size()-1;i>=0;i--) {
+				if(in.get(i)>n) {
+					ans=""NO"";
+					break;
+				}
+				n--;
+			}
+			System.out.println(ans);
+		}
+	}
+	static long ans(long l,long r,long x,long y) {
+		long mid=(r-l)/2+l;
+		long a=mid%x;
+		long b=y%mid;
+		long c=0;
+		if(l>r) {
+			return 0;
+		}
+		if(a==b) {
+			return mid;
+		}
+		else if(a<b) {
+			c=ans(l,mid-1,x,y);
+			if(c==0) {
+				c=ans(mid+1,r,x,y);
+			}
+		}
+		else{
+			c=ans(l,mid-1,x,y);
+			if(c==0) {
+				c=ans(mid+1,r,x,y);
+			}
+		}
+		return c;
+	}
+	static int[] nia(int n){
+		int[] arr= new int[n];
+		int i=0;
+		while(i<n){
+			arr[i++]=in.readInt();
+		}
+		return arr;
+	}
+	static long[] nla(int n){
+		long[] arr= new long[n];
+		int i=0;
+		while(i<n){
+			arr[i++]=in.readLong();
+		}
+		return arr;
+	}
+	static int[] nia1(int n){
+		int[] arr= new int[n+1];
+		int i=1;
+		while(i<=n){
+			arr[i++]=in.readInt();
+		}
+		return arr;
+	}
+	static long gcd(long a, long b) {
+		if (b==0) return a;
+		return gcd(b, a%b);
+	}
+	static class Scanner{
+		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st=new StringTokenizer("""");
+		String readString() {
+			while (!st.hasMoreTokens())
+				try {
+					st=new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			return st.nextToken();
+		}
+		double readDouble() {
+			return Double.parseDouble(readString());
+		}
+		int readInt() {
+			return Integer.parseInt(readString());
+		}
+		long readLong() {
+			return Long.parseLong(readString());
+		}
+	}	
+}","/******************************************************************************
+
+Welcome to GDB Online.
+GDB online is an online compiler and debugger tool for C, C++, Python, Java, PHP, Ruby, Perl,
+C#, VB, Swift, Pascal, Fortran, Haskell, Objective-C, Assembly, HTML, CSS, JS, SQLite, Prolog.
+Code, Compile, Run and Debug online from anywhere in world.
+
+*******************************************************************************/
+import java.util.*;
+public class Main
+{
+	public static void main(String[] args) {
+		Scanner s  = new Scanner(System.in);
+		int t = s.nextInt();
+		while(t-- > 0){
+		    int n = s.nextInt();
+		    int[] arr = new int[n];
+		    for(int i=0;i<n;i++)
+		        arr[i] = s.nextInt();
+		    String str = s.next();
+		    List<Integer> left = new ArrayList<>();
+		    List<Integer> right = new ArrayList<>();
+		    for(int i=0;i<arr.length;i++){
+		        if(str.charAt(i) == 'B')
+		            left.add(arr[i]);
+		        else right.add(arr[i]);
+		    }
+		    Collections.sort(left);
+		    Collections.sort(right);
+		    boolean flag = false;
+		    for(int i=0;i<left.size();i++)
+		        if(left.get(i) < i+1){
+		            flag = true;
+		            break;
+		        }
+		    if(!flag){
+		        for(int i=0;i<right.size();i++)
+    		        if(right.get(i) > left.size()+i+1){
+    		            flag = true;
+    		            break;
+    		        }
+		    }
+		    if(flag)
+		        System.out.println(""NO"");
+		    else System.out.println(""YES"");
+		}
+	}
+}
+
+",0
+4f7af821,8f6421f3,"import java.util.*;
+
+public class contestA {
+    public static void main(String[] args) {
+        Scanner scanner = new Scanner(System.in);
+        int t = scanner.nextInt();
+        int inf = 1000300300;
+        while (t-->0){
+            int n = scanner.nextInt();
+            int k = scanner.nextInt();
+            int[] c = new int[n];
+            Arrays.fill(c,inf);
+            int[] a = new int[k];
+            int[] b = new int[k];
+            for(int i=0;i<k;++i) a[i] = scanner.nextInt() - 1;
+            for(int i=0;i<k;++i) b[i] = scanner.nextInt();
+            for(int i=0;i<k;++i) c[a[i]] = b[i];
+            for(int i=1;i<n;++i){
+                c[i] = Math.min(c[i],c[i-1]+1);
+            }
+            for(int i=n-2;i>=0;--i){
+                c[i] = Math.min(c[i],c[i+1]+1);
+            }
+            for(int i=0;i<n;++i) System.out.print(c[i]+"" "");
+            System.out.println();
+        }
+    }
+}
+
+","import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.StringTokenizer;
+import java.util.Arrays;
+public class Main{  
+    public static void main (String[] args){
+        FastReader s = new FastReader();
+        int t=1;t=s.ni();
+        for(int test=1;test<=t;test++){
+        int n=s.ni(),k=s.ni();
+        int position[]=s.readArray(k),temp[]=s.readArray(k);
+        int ans[]=new int[n];
+        Arrays.fill(ans,Integer.MAX_VALUE/2);
+        for(int i=0;i<k;i++){
+            ans[position[i]-1]=temp[i];
+        }
+        for(int i=1;i<n;i++){
+            ans[i]=Math.min(ans[i-1]+1,ans[i]);
+        }
+        for(int i=n-2;i>=0;i--){
+            ans[i]=Math.min(ans[i],ans[i+1]+1);
+        }
+        for(int i=0;i<n;i++)
+        System.out.print(ans[i]+"" "");
+        System.out.println();
+        }
+    }
+    
+    
+    static class FastReader {
+        BufferedReader br;
+        StringTokenizer st;
+        public FastReader(){
+        br = new BufferedReader(new InputStreamReader(System.in));}
+        int ni() { return Integer.parseInt(next()); }
+        long nl() { return Long.parseLong(next()); }
+        double nd() { return Double.parseDouble(next()); }
+        int[] readArray(int n){
+		int[] a = new int[n];
+		for (int i = 0; i < n; i++)
+			a[i] =Integer.parseInt(next());
+		return a;
+	    }
+        String next(){
+            while (st == null || !st.hasMoreElements()) {try {st = new StringTokenizer(br.readLine());}
+            catch (IOException e){e.printStackTrace();}}return st.nextToken();}
+            String nextLine(){String str = """";try {str = br.readLine();}catch (IOException e) 
+            {e.printStackTrace();}return str;}
+    }
+}
+
+
+  
+",1
+22dff786,624529e3,"import java.util.*;
+
+public class Solution {
+
+    public static void main(String args[])
+
+    {   Scanner s = new Scanner(System.in);
+
+        int t = s.nextInt();
+
+        while(t-- > 0){
+        	
+        	int n= s.nextInt();
+        	
+        	long [] time= new long [n];
+        	
+        	long [] health= new long [n];
+        	
+        	for(int i=0; i<n; i++)
+        		
+        		time[i]= s.nextLong();
+        	
+        	for(int i=0; i<n; i++)
+        		
+        		health[i]= s.nextLong();
+        	
+        	long currhealth= health[n-1];
+        	
+        	long currtime= time[n-1];
+        	
+        	long ans=0;
+        	
+        	for(int i= n-2; i>=0; i--)
+        	
+        	{   if(currtime-time[i]>= currhealth)
+        		
+        	    {  ans+= (currhealth*(currhealth+1))/2;
+        	    
+        	       currhealth= health[i];
+        	       
+        	       currtime= time[i];
+        		
+        	    }
+        	
+        	    else if(currtime-time[i]>currhealth-health[i])
+        	    	
+        	    	currhealth+= (currtime-time[i]-currhealth+health[i]);
+        		
+        	}
+        	
+        	ans+= (currhealth*(currhealth+1))/2;
+        	
+        	System.out.println(ans);
+
+        }
+        
+        s.close();
+
+    }
+    
+}","import java.util.*;
+import java.io.*;
+import java.lang.*;
+public class Main
+{
+	public static void main(String[] args) {
+	Scanner sc=new Scanner(System.in);
+	int t=sc.nextInt();
+	while(t-->0){
+	    int n=sc.nextInt();
+	    long k[]=new long[n];
+	    long h[]=new long[n];
+	    for(int i=0;i<n;i++){
+	        k[i]=sc.nextInt();
+	    }
+	    for(int i=0;i<n;i++){
+	        h[i]=sc.nextInt();
+	    }
+	    long length=h[n-1];
+	    long curr=0;
+	    long ans=0;
+	    for(int i=n-1;i>=1;i--){
+	        if(k[i]-k[i-1]>=length){
+	            curr=curr+length;
+	            ans=ans+(curr*(curr+1))/2;
+	            length=h[i-1];
+	            curr=0;
+	        }
+	        else{
+	            length=Math.max(length-(k[i]-k[i-1]),h[i-1]);
+	            curr=curr+k[i]-k[i-1];
+	        }
+	    }
+	    curr=curr+length;
+	    ans=ans+(curr*(curr+1))/2;
+	    System.out.println(ans);
+	 }
+	}
+}
+
+",0
+2722ef48,e9144440,"import java.io.OutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.PrintWriter;
+import java.util.Arrays;
+import java.io.BufferedWriter;
+import java.io.Writer;
+import java.io.OutputStreamWriter;
+import java.util.InputMismatchException;
+import java.io.IOException;
+import java.io.InputStream;
+
+/**
+ * Built using CHelper plug-in
+ * Actual solution is at the top
+ */
+public class Main {
+    public static void main(String[] args) {
+        InputStream inputStream = System.in;
+        OutputStream outputStream = System.out;
+        InputReader in = new InputReader(inputStream);
+        OutputWriter out = new OutputWriter(outputStream);
+        CNotAssigning solver = new CNotAssigning();
+        int testCount = Integer.parseInt(in.next());
+        for (int i = 1; i <= testCount; i++)
+            solver.solve(i, in, out);
+        out.close();
+    }
+
+    static class CNotAssigning {
+        int N = 100010;
+        int M = N * 2;
+        int[] h;
+        int[] e = new int[M];
+        int[] ne = new int[M];
+        int idx;
+        int n;
+        int[] dep;
+        int[] res;
+
+        public void solve(int testNumber, InputReader in, OutputWriter out) {
+            n = in.nextInt();
+            h = new int[n + 1];
+            dep = new int[n + 1];
+            res = new int[n - 1];
+            Arrays.fill(h, -1);
+            idx = 0;
+            for (int i = 0; i < n - 1; i++) {
+                int a = in.nextInt();
+                int b = in.nextInt();
+                add(a, b);
+                add(b, a);
+                dep[a]++;
+                dep[b]++;
+            }
+            int start = 0;
+            for (int i = 1; i <= n; i++) {
+                if (dep[i] > 2) {
+                    out.println(-1);
+                    return;
+                }
+                if (dep[i] == 1) {
+                    start = i;
+                }
+            }
+            dfs(start, start, 2);
+            out.println(res);
+        }
+
+        private void dfs(int u, int p, int num) {
+            for (int i = h[u]; i != -1; i = ne[i]) {
+                int j = e[i];
+                if (j == p) {
+                    continue;
+                }
+                res[i / 2] = num;
+                dfs(j, u, 7 - num);
+            }
+        }
+
+        void add(int a, int b) {
+            e[idx] = b;
+            ne[idx] = h[a];
+            h[a] = idx++;
+        }
+
+    }
+
+    static class OutputWriter {
+        private final PrintWriter writer;
+
+        public OutputWriter(OutputStream outputStream) {
+            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
+        }
+
+        public OutputWriter(Writer writer) {
+            this.writer = new PrintWriter(writer);
+        }
+
+        public void print(int[] array) {
+            for (int i = 0; i < array.length; i++) {
+                if (i != 0) {
+                    writer.print(' ');
+                }
+                writer.print(array[i]);
+            }
+        }
+
+        public void println(int[] array) {
+            print(array);
+            writer.println();
+        }
+
+        public void close() {
+            writer.close();
+        }
+
+        public void println(int i) {
+            writer.println(i);
+        }
+
+    }
+
+    static class InputReader {
+        private InputStream stream;
+        private byte[] buf = new byte[1024];
+        private int curChar;
+        private int numChars;
+        private InputReader.SpaceCharFilter filter;
+
+        public InputReader(InputStream stream) {
+            this.stream = stream;
+        }
+
+        public int read() {
+            if (numChars == -1) {
+                throw new InputMismatchException();
+            }
+            if (curChar >= numChars) {
+                curChar = 0;
+                try {
+                    numChars = stream.read(buf);
+                } catch (IOException e) {
+                    throw new InputMismatchException();
+                }
+                if (numChars <= 0) {
+                    return -1;
+                }
+            }
+            return buf[curChar++];
+        }
+
+        public int nextInt() {
+            int c = read();
+            while (isSpaceChar(c)) {
+                c = read();
+            }
+            int sgn = 1;
+            if (c == '-') {
+                sgn = -1;
+                c = read();
+            }
+            int res = 0;
+            do {
+                if (c < '0' || c > '9') {
+                    throw new InputMismatchException();
+                }
+                res *= 10;
+                res += c - '0';
+                c = read();
+            } while (!isSpaceChar(c));
+            return res * sgn;
+        }
+
+        public String nextString() {
+            int c = read();
+            while (isSpaceChar(c)) {
+                c = read();
+            }
+            StringBuilder res = new StringBuilder();
+            do {
+                if (Character.isValidCodePoint(c)) {
+                    res.appendCodePoint(c);
+                }
+                c = read();
+            } while (!isSpaceChar(c));
+            return res.toString();
+        }
+
+        public boolean isSpaceChar(int c) {
+            if (filter != null) {
+                return filter.isSpaceChar(c);
+            }
+            return isWhitespace(c);
+        }
+
+        public static boolean isWhitespace(int c) {
+            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
+        }
+
+        public String next() {
+            return nextString();
+        }
+
+        public interface SpaceCharFilter {
+            public boolean isSpaceChar(int ch);
+
+        }
+
+    }
+}
+
+","import java.util.Scanner;
+
+public class C
+{
+	static int N = 100010;
+	static int[] cot = new int[N];
+	static boolean[] vis = new boolean[N];
+
+	static int[] h = new int[N];
+	static int[] des = new int[2 * N], next = new int[2 * N];
+	static int idx = 0;
+
+	static int[] ans = new int[N];
+
+	public static void main(String[] args)
+	{
+		Scanner in = new Scanner(System.in);
+		int round = in.nextInt();
+		for (int z = 0; z < round; z++)
+		{
+			int n = in.nextInt();
+			for (int i = 1; i <= n; i++)
+			{
+				h[i] = -1;
+				vis[i] = false;
+				cot[i] = 0;
+			}
+			idx = 0;
+
+			boolean flag = true;
+			for (int i = 1; i < n; i++)
+			{
+				int a = in.nextInt();
+				int b = in.nextInt();
+
+				des[idx] = b;
+				next[idx] = h[a];
+				h[a] = idx++;
+
+				des[idx] = a;
+				next[idx] = h[b];
+				h[b] = idx++;
+
+				if (++cot[a] >= 3 | ++cot[b] >= 3)
+					flag = false;
+			}
+
+			if (!flag)
+				System.out.println(-1);
+			else
+			{
+				int startPoint = -1;
+				for (int i = 1; i <= n; i++)
+					if (cot[i] == 1)
+					{
+						startPoint = i;
+						break;
+					}
+				dfs(startPoint, 3);
+				for (int i = 1; i < n; i++)
+					System.out.print(ans[i] + "" "");
+				System.out.println();
+			}
+		}
+	}
+
+	private static void dfs(int point, int preLen)
+	{
+		vis[point] = true;
+		for (int i = h[point]; i != -1; i = next[i])
+			if (!vis[des[i]])
+			{
+				ans[i / 2 + 1] = 5 - preLen;
+				// System.out.println(point + "">"" + des[i] + "" "" + ans[i / 2 + 1] + "" "" + (i / 2
+				// + 1));
+				dfs(des[i], ans[i / 2 + 1]);
+			}
+	}
+}",0
+3b498a39,e6b7a899,"/*
+ *     HI THERE! (: 
+ * 
+ * CREATED BY : NAITIK V
+ * 
+ *     JAI HIND
+ * 
+ */
+
+import java.util.*;
+
+
+import java.io.*;
+import java.math.*;
+
+public class Main
+
+{ 
+	 static FastReader sc=new FastReader(); 
+	 static long dp[][];
+	 static int mod=1000000007;
+	 static int max;
+	  public static void main(String[] args)
+{
+		   PrintWriter out=new PrintWriter(System.out);
+		   //StringBuffer sb=new StringBuffer("""");
+		  int ttt=1;
+		   //ttt =i();
+		 
+	        outer :while (ttt-- > 0) 
+			{
+	        	int n=i();
+	        	int A[]=input(n);
+	        	dp=new long[n+1][n+1];
+	        	for(int i=0;i<=n;i++) {
+	        		Arrays.fill(dp[i],-1);
+	        	}
+		        	
+	        	
+	        	ArrayList<Integer> l=new ArrayList<Integer>();
+	        	ArrayList<Integer> m=new ArrayList<Integer>();
+	        	for(int i=0;i<n;i++) {
+	        		if(A[i]==0) {
+	        			l.add(i+1);
+	        		}
+	        		else {
+	        			m.add(i+1);
+	        		}
+	        	}
+	        	A=new int[m.size()];
+	        	int B[]=new int[l.size()];
+	        	for(int i=0;i<l.size();i++) {
+	        		B[i]=l.get(i);
+	        	}
+	        	for(int i=0;i<m.size();i++) {
+	        		A[i]=m.get(i);
+	        	}
+	        	n=m.size();
+	        	int o=l.size();
+		        	System.out.println(go(A,B,0,0,n,o));
+	        	
+			}
+
+	     //System.out.println(sb.toString());
+		     out.close();
+	     
+	     
+	    //CHECK FOR N=1                    //CHECK FOR M=0
+        //CHECK FOR N=1                    //CHECK FOR M=0
+       	//CHECK FOR N=1
+       	//CHECK FOR N=1
+       	//CHECK FOR N=1
+		        
+		     
+    }
+	  
+	 
+	  
+	  
+	
+	 
+	private static long go(int[] A, int[] B, int i, int j, int n, int m) {
+		if(i==n)
+			return 0;
+		if(j==m)
+			return Integer.MAX_VALUE;
+		if(dp[i][j]!=-1)
+			return dp[i][j];
+		long op1=go(A, B, i+1, j+1, n, m)+Math.abs(A[i]-B[j]);
+		long op2=go(A, B, i, j+1, n, m);
+		return dp[i][j]=Math.min(op1, op2);
+	
+		
+		
+		
+		
+		}
+
+
+
+
+
+
+static class Pair implements Comparable<Pair>
+     {
+    	 int x;
+    	 int y;
+    	 Pair(int x,int y){
+    		 this.x=x;
+    		 this.y=y;
+    	 }
+		@Override
+		public int compareTo(Pair o) {
+			if(this.x>o.x)
+				return 1;
+			else if(this.x<o.x)
+				return -1;
+			else {
+				if(this.y>o.y)
+					return 1;
+				else if(this.y<o.y)
+					return -1;
+				else
+					return 0;
+			}
+		}
+		
+		/* FOR TREE MAP PAIR USE */
+		
+//		public int compareTo(Pair o) {
+// 			if (x > o.x) {
+// 				return 1;
+// 			}
+// 			if (x < o.x) {
+// 				return -1;
+// 			}
+// 			if (y > o.y) {
+// 				return 1;
+// 			}
+// 			if (y < o.y) {
+// 				return -1;
+// 			}
+// 			return 0;
+// 		}
+	
+		
+     }
+
+static int[] input(int n) {
+	int A[]=new int[n];
+	   for(int i=0;i<n;i++) {
+		   A[i]=sc.nextInt();
+	   }
+	   return A;
+   }
+static long[] inputL(int n) {
+	long A[]=new long[n];
+	   for(int i=0;i<n;i++) {
+		   A[i]=sc.nextLong();
+	   }
+	   return A;
+   }
+static String[] inputS(int n) {
+	String A[]=new String[n];
+	   for(int i=0;i<n;i++) {
+		   A[i]=sc.next();
+	   }
+	   return A;
+   }
+static long sum(int A[]) {
+	long sum=0;
+	for(int i : A) {
+		sum+=i;
+	}
+	return sum;
+}
+static long sum(long A[]) {
+	long sum=0;
+	for(long i : A) {
+		sum+=i;
+	}
+	return sum;
+}
+static void reverse(long A[]) {
+	int n=A.length;
+	long B[]=new long[n];
+	for(int i=0;i<n;i++) {
+		B[i]=A[n-i-1];
+	}
+	for(int i=0;i<n;i++)
+		A[i]=B[i];
+	
+}
+static void reverse(int A[]) {
+	int n=A.length;
+	int B[]=new int[n];
+	for(int i=0;i<n;i++) {
+		B[i]=A[n-i-1];
+	}
+	for(int i=0;i<n;i++)
+		A[i]=B[i];
+	
+}
+static void input(int A[],int B[]) {
+	   for(int i=0;i<A.length;i++) {
+		   A[i]=sc.nextInt();
+		   B[i]=sc.nextInt();
+	   }
+}
+static int[][] input(int n,int m){
+	int A[][]=new int[n][m];
+	for(int i=0;i<n;i++) {
+		for(int j=0;j<m;j++) {
+			A[i][j]=i();
+		}
+	}
+	return A;
+}
+static char[][] charinput(int n,int m){
+	char A[][]=new char[n][m];
+	for(int i=0;i<n;i++) {
+		String s=s();
+		for(int j=0;j<m;j++) {
+			A[i][j]=s.charAt(j);
+		}
+	}
+	return A;
+}
+static int max(int A[]) {
+	int max=Integer.MIN_VALUE;
+	for(int i=0;i<A.length;i++) {
+		max=Math.max(max, A[i]);
+	}
+	return max;
+}
+static int min(int A[]) {
+	int min=Integer.MAX_VALUE;
+	for(int i=0;i<A.length;i++) {
+		min=Math.min(min, A[i]);
+	}
+	return min;
+}
+static long max(long A[]) {
+	long max=Long.MIN_VALUE;
+	for(int i=0;i<A.length;i++) {
+		max=Math.max(max, A[i]);
+	}
+	return max;
+}
+static long min(long A[]) {
+	long min=Long.MAX_VALUE;
+	for(int i=0;i<A.length;i++) {
+		min=Math.min(min, A[i]);
+	}
+	return min;
+}
+static long [] prefix(long A[]) {
+	long p[]=new long[A.length];
+	p[0]=A[0];
+	for(int i=1;i<A.length;i++)
+		p[i]=p[i-1]+A[i];
+	return p;
+}
+static long [] prefix(int A[]) {
+	long p[]=new long[A.length];
+	p[0]=A[0];
+	for(int i=1;i<A.length;i++)
+		p[i]=p[i-1]+A[i];
+	return p;
+}
+static long [] suffix(long A[]) {
+	long p[]=new long[A.length];
+	p[A.length-1]=A[A.length-1];
+	for(int i=A.length-2;i>=0;i--)
+		p[i]=p[i+1]+A[i];
+	return p;
+}
+static long [] suffix(int A[]) {
+	long p[]=new long[A.length];
+	p[A.length-1]=A[A.length-1];
+	for(int i=A.length-2;i>=0;i--)
+		p[i]=p[i+1]+A[i];
+	return p;
+}
+static long power(long x, long y, long p)
+{
+
+	if(y==0)
+		return 1;
+	if(x==0)
+		return 0;
+    long res = 1;
+    x = x % p;
+
+    while (y > 0) {
+
+        if (y % 2 == 1)
+            res = (res * x) % p;
+
+        y = y >> 1; 
+        x = (x * x) % p;
+    }
+
+    return res;
+}
+static void print(int A[]) {
+	for(int i : A) {
+		System.out.print(i+"" "");
+	}
+	System.out.println();
+}
+static void print(long A[]) {
+	for(long i : A) {
+		System.out.print(i+"" "");
+	}
+	System.out.println();
+}
+static long mod(long x) {
+	  return ((x%mod + mod)%mod);
+}
+static String reverse(String s) {
+	StringBuffer p=new StringBuffer(s);
+	p.reverse();
+	return p.toString();
+}
+
+     static int i() {
+    	 return sc.nextInt();
+     }
+     static String s() {
+    	 return sc.next();
+     }
+     static long l() {
+    	 return sc.nextLong();
+     }  
+     static void sort(int[] A){
+        int n = A.length;
+        Random rnd = new Random();
+        for(int i=0; i<n; ++i){
+            int tmp = A[i];
+            int randomPos = i + rnd.nextInt(n-i);
+            A[i] = A[randomPos];
+            A[randomPos] = tmp;
+        }
+        Arrays.sort(A);
+     }
+     static void sort(long[] A){
+	        int n = A.length;
+	        Random rnd = new Random();
+	        for(int i=0; i<n; ++i){
+	            long tmp = A[i];
+	            int randomPos = i + rnd.nextInt(n-i);
+	            A[i] = A[randomPos];
+	            A[randomPos] = tmp;
+	        }
+	        Arrays.sort(A);
+	     }
+  static String sort(String s) {
+ 	 Character ch[]=new Character[s.length()];
+ 	 for(int i=0;i<s.length();i++) {
+ 		 ch[i]=s.charAt(i);
+ 	 }
+ 	 Arrays.sort(ch);
+ 	 StringBuffer st=new StringBuffer("""");
+ 	 for(int i=0;i<s.length();i++) {
+ 		 st.append(ch[i]);
+ 	 }
+ 	 return st.toString();
+  }
+  static HashMap<Integer,Integer> hash(int A[]){
+	  HashMap<Integer,Integer> map=new HashMap<Integer, Integer>();
+	  for(int i : A) {
+		  if(map.containsKey(i)) {
+			  map.put(i, map.get(i)+1);
+		  }
+		  else {
+			  map.put(i, 1);
+		  }
+	  }
+	  return map;
+  }
+  static TreeMap<Integer,Integer> tree(int A[]){
+	  TreeMap<Integer,Integer> map=new TreeMap<Integer, Integer>();
+	  for(int i : A) {
+		  if(map.containsKey(i)) {
+			  map.put(i, map.get(i)+1);
+		  }
+		  else {
+			  map.put(i, 1);
+		  }
+	  }
+	  return map;
+  }
+     static boolean prime(int n) 
+	    { 
+	        if (n <= 1) 
+	            return false; 
+	        if (n <= 3) 
+	            return true; 
+	        if (n % 2 == 0 || n % 3 == 0) 
+	            return false; 
+	        double sq=Math.sqrt(n);
+	  
+	        for (int i = 5; i <= sq; i = i + 6) 
+	            if (n % i == 0 || n % (i + 2) == 0) 
+	                return false; 
+	        return true; 
+	    } 
+     static boolean prime(long n) 
+	    { 
+	        if (n <= 1) 
+	            return false; 
+	        if (n <= 3) 
+	            return true; 
+	        if (n % 2 == 0 || n % 3 == 0) 
+	            return false; 
+	        double sq=Math.sqrt(n);
+	  
+	        for (int i = 5; i <= sq; i = i + 6) 
+	            if (n % i == 0 || n % (i + 2) == 0) 
+	                return false; 
+	        return true; 
+	    } 
+     static int gcd(int a, int b) 
+     { 
+         if (a == 0) 
+             return b; 
+         return gcd(b % a, a); 
+     } 
+     static long gcd(long a, long b) 
+     { 
+         if (a == 0) 
+             return b; 
+         return gcd(b % a, a); 
+     } 
+     
+        
+    static class FastReader 
+    { 
+        BufferedReader br; 
+        StringTokenizer st; 
+  
+        public FastReader() 
+        { 
+            br = new BufferedReader(new
+                     InputStreamReader(System.in)); 
+        } 
+  
+        String next() 
+        { 
+            while (st == null || !st.hasMoreElements()) 
+            { 
+                try
+                { 
+                    st = new StringTokenizer(br.readLine()); 
+                } 
+                catch (IOException  e) 
+                { 
+                    e.printStackTrace(); 
+                } 
+            } 
+            return st.nextToken(); 
+        } 
+  
+        int nextInt() 
+        { 
+            return Integer.parseInt(next()); 
+        } 
+  
+        long nextLong() 
+        { 
+            return Long.parseLong(next()); 
+        } 
+  
+        double nextDouble() 
+        { 
+            return Double.parseDouble(next()); 
+        } 
+  
+        String nextLine() 
+        { 
+            String str = """"; 
+            try
+            { 
+                str = br.readLine(); 
+            } 
+            catch (IOException e) 
+            { 
+                e.printStackTrace(); 
+            } 
+            return str; 
+        } 
+    } 
+} 
+
+
+
+","import java.io.IOException;
+import java.io.InputStream;
+import java.io.PrintWriter;
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+import java.util.*;
+
+public class Main {
+	static final long MOD=1000000007;
+	static final long MOD1=998244353;
+	static long ans=0;
+	//static ArrayList<Integer> ans=new ArrayList<>();
+	public static void main(String[] args){
+		PrintWriter out = new PrintWriter(System.out);
+		InputReader sc=new InputReader(System.in);
+		int N = sc.nextInt();
+		int[] A = sc.nextIntArray(N);
+		ArrayList<Integer> a1 = new ArrayList<Integer>();
+		ArrayList<Integer> a2 = new ArrayList<Integer>();
+		for (int i = 0; i < A.length; i++) {
+			if (A[i]==0) {
+				a1.add(i);
+			}else {
+				a2.add(i);
+			}
+		}
+		int[][] dp = new int[a1.size()+1][a2.size()+1];
+		for (int i = 0; i < dp.length; i++) {
+			Arrays.fill(dp[i], Integer.MAX_VALUE/2);
+		}
+		dp[0][0] = 0;
+		for (int i = 1; i <= a1.size() ; i++) {
+			int pos1 = a1.get(i-1);
+			for (int j = 0; j <= a2.size(); j++) {
+				dp[i][j] = dp[i-1][j];
+				if (j-1>=0) {
+					int pos2 = a2.get(j-1);
+					dp[i][j] = Math.min(dp[i][j], dp[i-1][j-1] + Math.abs(pos1-pos2));
+				}
+			}
+		}
+		System.out.println(dp[a1.size()][a2.size()]);
+	}
+	static class InputReader { 
+		private InputStream in;
+		private byte[] buffer = new byte[1024];
+		private int curbuf;
+		private int lenbuf;
+		public InputReader(InputStream in) {
+			this.in = in;
+			this.curbuf = this.lenbuf = 0;
+		}
+		public boolean hasNextByte() {
+			if (curbuf >= lenbuf) {
+				curbuf = 0;
+				try {
+					lenbuf = in.read(buffer);
+				} catch (IOException e) {
+					throw new InputMismatchException();
+				}
+				if (lenbuf <= 0)
+					return false;
+			}
+			return true;
+		}
+ 
+		private int readByte() {
+			if (hasNextByte())
+				return buffer[curbuf++];
+			else
+				return -1;
+		}
+ 
+		private boolean isSpaceChar(int c) {
+			return !(c >= 33 && c <= 126);
+		}
+ 
+		private void skip() {
+			while (hasNextByte() && isSpaceChar(buffer[curbuf]))
+				curbuf++;
+		}
+ 
+		public boolean hasNext() {
+			skip();
+			return hasNextByte();
+		}
+ 
+		public String next() {
+			if (!hasNext())
+				throw new NoSuchElementException();
+			StringBuilder sb = new StringBuilder();
+			int b = readByte();
+			while (!isSpaceChar(b)) {
+				sb.appendCodePoint(b);
+				b = readByte();
+			}
+			return sb.toString();
+		}
+ 
+		public int nextInt() {
+			if (!hasNext())
+				throw new NoSuchElementException();
+			int c = readByte();
+			while (isSpaceChar(c))
+				c = readByte();
+			boolean minus = false;
+			if (c == '-') {
+				minus = true;
+				c = readByte();
+			}
+			int res = 0;
+			do {
+				if (c < '0' || c > '9')
+					throw new InputMismatchException();
+				res = res * 10 + c - '0';
+				c = readByte();
+			} while (!isSpaceChar(c));
+			return (minus) ? -res : res;
+		}
+ 
+		public long nextLong() {
+			if (!hasNext())
+				throw new NoSuchElementException();
+			int c = readByte();
+			while (isSpaceChar(c))
+				c = readByte();
+			boolean minus = false;
+			if (c == '-') {
+				minus = true;
+				c = readByte();
+			}
+			long res = 0;
+			do {
+				if (c < '0' || c > '9')
+					throw new InputMismatchException();
+				res = res * 10 + c - '0';
+				c = readByte();
+			} while (!isSpaceChar(c));
+			return (minus) ? -res : res;
+		}
+ 
+		public double nextDouble() {
+			return Double.parseDouble(next());
+		}
+ 
+		public int[] nextIntArray(int n) {
+			int[] a = new int[n];
+			for (int i = 0; i < n; i++)
+				a[i] = nextInt();
+			return a;
+		}
+		public double[] nextDoubleArray(int n) {
+			double[] a = new double[n];
+			for (int i = 0; i < n; i++)
+				a[i] = nextDouble();
+			return a;
+		}
+		public long[] nextLongArray(int n) {
+			long[] a = new long[n];
+			for (int i = 0; i < n; i++)
+				a[i] = nextLong();
+			return a;
+		}
+ 
+		public char[][] nextCharMap(int n, int m) {
+			char[][] map = new char[n][m];
+			for (int i = 0; i < n; i++)
+				map[i] = next().toCharArray();
+			return map;
+		}
+	}
+}
+",0
+4548305b,c0aa6246,"import java.util.function.Consumer;
+import java.util.*;
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.math.RoundingMode;
+import java.text.DecimalFormat;
+import java.io.*;
+import java.lang.Math.*;
+ public class KickStart2020{
+	static class FastReader {
+        BufferedReader br;
+        StringTokenizer st;
+        public FastReader(){br = new BufferedReader(
+           new InputStreamReader(System.in));}
+        String next(){
+            while (st == null || !st.hasMoreElements()) {
+                try { st = new StringTokenizer(br.readLine()); }
+                catch (IOException e) {e.printStackTrace();}}
+            return st.nextToken();}
+        int nextInt() { return Integer.parseInt(next()); }
+        long nextLong() { return Long.parseLong(next()); }
+        double nextDouble() { return Double.parseDouble(next());}
+        float nextFloat() {return Float.parseFloat(next());}
+        String nextLine() {
+            String str = """";
+            try {str = br.readLine();}
+            catch (IOException e) { e.printStackTrace();}
+            return str; }}
+	static boolean isBracketSequence(String s, int a, int b) {
+		Stack<Character> ss = new Stack<>();
+		boolean hachu = true;
+		for(int i = a; i <= b; i++) {
+			if(s.charAt(i) == ')' && ss.isEmpty()) {hachu = false; break;}
+			if(s.charAt(i) == '(') ss.add('(');
+			else ss.pop();
+		}
+		return ss.empty() && hachu;
+	}
+	static String reverseOfString(String a) {
+		StringBuilder ssd = new StringBuilder();
+		for(int i = a.length() - 1; i >= 0; i--) {
+			ssd.append(a.charAt(i));
+		}
+		return ssd.toString();
+	}
+	static char[] reverseOfChar(char a[]) {
+		char b[] = new char[a.length];
+		int j = 0;
+		for(int i = a.length - 1; i >= 0; i--) {
+			b[i] = a[j];
+			j++;
+		}
+		return b;
+	}
+	static boolean isPalindrome(char a[]) {
+		boolean hachu = true;
+		for(int i = 0; i <= a.length / 2; i++) {
+			if(a[i] != a[a.length - 1 - i]) {
+				hachu = false;
+				break;
+			}
+		}
+		return hachu;
+	} 
+	static long gcd(long a, long b)
+	{
+	    if (b == 0)
+	        return a;
+	    return gcd(b, a % b);
+	     
+	}
+	static long powermod(long x, long y, long mod){
+	    long ans = 1;
+	    x = x % mod; 
+	    if (x == 0)
+	      return 0; 
+	    int i = 1;
+	    while (y > 0){
+	      if ((y & 1) != 0)
+	        ans = (ans * x) % mod;
+	      y = y >> 1; 
+	      x = (x * x) % mod;
+	    }
+	    return ans;
+	  }
+	static long power(long x, long y){
+	    long ans = 1;
+	    if (x == 0)
+	      return 0; 
+	    int i = 1;
+	    while (y > 0){
+	      if ((y & 1) != 0)
+	        ans = (ans * x);
+	      y = y >> 1; 
+	      x = (x * x);
+	    }
+	    return ans;
+	  }
+	static boolean check(String a) {
+		boolean hachu = true;
+		for(int i = 0; i < a.length(); i++) {
+			if(a.charAt(0) != a.charAt(i)) {hachu = false; break;}
+		}
+		return hachu;
+	}
+	 public static class Pair implements Comparable<Pair> {
+	        public  int index;
+	        public  int value;
+	 
+	        public Pair(int index, int value) {
+	            this.index = index;
+	            this.value = value;
+	        }
+	        @Override
+	        public int compareTo(Pair other) {
+	            return   -1 * Integer.valueOf(this.value).compareTo(other.value);
+	        }
+	 }
+	 static boolean equalString(int i, int j, int arr[], String b) {
+		 int brr[] = new int[26];
+		 for(int k = i; k <= j; k++) brr[b.charAt(k) - 'a']++;
+		 for(int k = 0; k < 26; k++) {
+			 if(arr[k] != brr[k]) return false;
+		 }
+		 return true;
+	 }
+	 static boolean cequalArray(String a, String b) {
+		  int count[] = new int[26];
+		  int count1[] = new int[26];
+		  for(int i = 0; i < a.length(); i++) count[a.charAt(i) - 'a']++;
+		  for(int i = 0; i < a.length(); i++) count1[b.charAt(i) - 'a']++;
+		  for(int i = 0; i < 26; i++) if(count[i] != count1[i]) return false;
+		  return true;
+	 }
+	 static boolean isPrime(long d) {
+		 if(d == 1) return true;
+		 for(int i = 2; i <= (long)Math.sqrt(d); i++) {
+			 if(d % i == 0) return false;
+		 }
+		 return true;
+	 }
+		public static void main(String[] args) throws Exception{
+			FastReader sc = new FastReader();
+			PrintWriter out = new PrintWriter(System.out);
+          int t = sc.nextInt();
+          while(t-- > 0) {
+           int n = sc.nextInt();
+           int k = sc.nextInt();
+           int arr[] = new int[k];
+           int temp[] = new int[k];
+           for(int i = 0; i < k; i++) arr[i] = sc.nextInt();
+           for(int i = 0; i < k; i++) temp[i] = sc.nextInt();
+           long brr[] = new long[n];
+           Arrays.fill(brr, Integer.MAX_VALUE);
+           for(int i = 0; i < k; i++) brr[arr[i] - 1] = temp[i];
+           for(int i = 1; i < n; i++) {
+        	   brr[i] = Math.min(brr[i], brr[i - 1] + 1);
+           }
+           for(int i = n - 2; i >= 0; i--) {
+        	   brr[i] = Math.min(brr[i], brr[i + 1] + 1);
+           }
+           for(long e: brr) out.print(e + "" "");
+           out.println();
+             
+          }
+                 out.close();
+			}
+		}","
+import java.util.*;
+import java.util.Map.Entry;
+import java.lang.*;
+import java.io.*;
+import java.math.BigInteger;
+
+
+public class CF {
+	private static FS sc = new FS();
+	
+	private static class FS {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st = new StringTokenizer("""");
+		String next() {
+			while (!st.hasMoreTokens())
+				try {
+					st=new StringTokenizer(br.readLine());				               
+	            } catch (IOException e) {}
+			return st.nextToken();
+		}
+		
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+	}
+	
+	private static class extra {
+		
+		static int[] intArr(int size) {
+			int[] a = new int[size];
+			for(int i = 0; i < size; i++) a[i] = sc.nextInt();
+			return a;
+		}
+		
+		static long[] longArr(int size) {
+			long[] a = new long[size];
+			for(int i = 0; i < size; i++) a[i] = sc.nextLong();
+			return a;
+		}
+		
+		static long intSum(int[] a) {
+			long sum = 0; 
+			for(int i = 0; i < a.length; i++) {
+				sum += a[i];
+			}
+			return sum;
+		}
+		
+		static long longSum(long[] a) {
+			long sum = 0; 
+			for(int i = 0; i < a.length; i++) {
+				sum += a[i];
+			}
+			return sum;
+		}
+		
+		static LinkedList[] graphD(int vertices, int edges) {
+			LinkedList<Integer>[] temp = new LinkedList[vertices+1];
+			for(int i = 0; i <= vertices; i++) temp[i] = new LinkedList<>();
+			for(int i = 0; i < edges; i++) {
+				int x = sc.nextInt();
+				int y = sc.nextInt();
+				temp[x].add(y);
+			}
+			return temp;
+		}
+		
+		static LinkedList[] graphUD(int vertices, int edges) {
+			LinkedList<Integer>[] temp = new LinkedList[vertices+1];
+			for(int i = 0; i <= vertices; i++) temp[i] = new LinkedList<>();
+			for(int i = 0; i < edges; i++) {
+				int x = sc.nextInt();
+				int y = sc.nextInt();
+				temp[x].add(y);
+				temp[y].add(x);
+			}
+			return temp;
+		}
+		
+		static void printG(LinkedList[] temp) {
+			for(LinkedList<Integer> aa:temp) System.out.println(aa);
+		}
+		
+		static long cal(long val, long pow) {
+			if(pow == 0) return 1;
+			long res = cal(val, pow/2);
+			
+//			long ret = (res*res)%mod;
+//			if(pow%2 == 0) return ret;
+//			return (val*ret)%mod;
+			long ret = res*res;
+			if(pow%2 == 0) return ret;
+			return val*ret;
+		}
+		
+		static long gcd(long a, long b) { return b == 0 ? a:gcd(b, a%b); }
+		
+	}
+	
+	static int mod = (int) 1e9 + 9;
+//	static int mod = (int) 998244353;
+	static int max = (int) 1e6, sq = 316;
+	static LinkedList<Integer>[] temp;
+//	static int[] par, rank;
+	
+	public static void main(String[] args) {	
+		int t = sc.nextInt();
+//		int t = 1;
+		StringBuilder ret = new StringBuilder();
+		while(t-- > 0) {
+			int n = sc.nextInt(); int m = sc.nextInt();
+			int[] a = extra.intArr(m);
+			int[] b = extra.intArr(m);
+			long[] c = new long[n];
+			Arrays.fill(c, (int)1e18);
+			for(int i = 0; i < m; i++) c[a[i]-1] = b[i];
+			long[] l = new long[n];
+			long[] r = new long[n];
+			Arrays.fill(l, (int)1e18);
+			Arrays.fill(r, (int)1e18);
+			long min = (long)1e18;
+			for(int i = 0; i < n; i++) {
+				min = Math.min(min+1, c[i]);
+				l[i] = min;
+			}
+			min = (int)1e18;
+			for(int i = n-1; i >= 0; i--) {
+				min = Math.min(min+1, c[i]);
+				r[i] = min;
+			}
+			for(int i = 0; i < n; i++) {
+				ret.append(Math.min(l[i], r[i]) + "" "");
+			}
+			ret.append(""\n"");
+ 		}
+		System.out.println(ret);
+	}
+	
+}",0
+4e28b45e,fc1771af,"import java.util.*;
+import java.io.*;
+public class C {
+
+	public static void main(String[] args) {
+		FastScanner sc = new FastScanner();
+		int T = sc.nextInt();
+		while(T-->0) {
+			int n = sc.nextInt();
+			char[] s = new char[n];
+			char[] t = new char[n];
+			s = sc.next().toCharArray();
+			t = sc.next().toCharArray();
+			int a = 0, b = 0, c = 0, d = 0;
+			for(int i = 0; i < n; i++) {
+				if(s[i] == '0' && t[i] == '0') a++;
+				if(s[i] == '1' && t[i] == '0') b++;
+				if(s[i] == '0' && t[i] == '1') c++;
+				if(s[i] == '1' && t[i] == '1') d++;
+			}
+			int res = Integer.MAX_VALUE;
+			if(b == c || b+1 == c) {
+				if((b + c) % 2 == 0) {
+					res = Math.min(res, b + c);
+				}
+			}
+			if(a == d || a+1 == d) {
+				if((a + d) % 2 == 1) {
+					res = Math.min(res, a + d);
+				}
+			}
+			if(res == Integer.MAX_VALUE) System.out.println(-1);
+			else System.out.println(res);
+		}
+	}
+	
+	static class FastScanner {
+		public BufferedReader reader;
+		public StringTokenizer tokenizer;
+		public FastScanner() {
+			reader = new BufferedReader(new InputStreamReader(System.in), 32768);
+			tokenizer = null;
+		}
+		public String next() {
+			while (tokenizer == null || !tokenizer.hasMoreTokens()) {
+				try {
+					tokenizer = new StringTokenizer(reader.readLine());
+				} catch (IOException e) {
+					throw new RuntimeException(e);
+				}
+			}
+			return tokenizer.nextToken();
+		}
+		public int nextInt() {
+			return Integer.parseInt(next());
+		}
+		public long nextLong() {
+			return Long.parseLong(next());
+		}
+		public double nextDouble() {
+			return Double.parseDouble(next());
+		}
+		public String nextLine() {
+			try {
+				return reader.readLine();
+			} catch(IOException e) {
+				throw new RuntimeException(e);
+			}
+		}
+	}
+
+}
+","// हर हर महादेव
+import java.util.*;
+import java.lang.*;
+import java.io.*;
+import java.math.BigInteger;
+import java.text.DecimalFormat;
+
+public final class Solution {
+
+    static int inf = Integer.MAX_VALUE;
+    static long mod = 1000000000 + 7;
+    
+ static void ne(Scanner sc, BufferedWriter op) throws Exception {
+            int n=sc.nextInt();
+     String one=sc.next();
+     String two=sc.next();
+     int _10=0;
+     int _00=0;
+     int _11=0;
+     int _01=0;
+   for(int i=0;i<n;i++){
+       int c1=one.charAt(i)-'0';
+       int c2=two.charAt(i)-'0';
+       if(c1==0 && c2==0){
+           _00++;
+       }
+       if(c1==1 && c2==0){
+           _10++;
+       }
+       if(c1==1 && c2==1){
+           _11++;
+       }
+       if(c1==0 && c2==1){
+           _01++;
+       }
+   }
+   int same=_00+_11;
+   int diff=_01+_10;
+   if(same==n){
+      op.write(""0\n"");
+      return;
+   }
+   if(same==1 && _11==1){
+       op.write(""1\n"");
+       return;
+   }
+//    if(diff==n){
+//        if(diff%2==0){
+//            op.write(n+""\n"");
+ 
+//        }else{
+//            op.write(""-1\n"");
+//        }
+//        return;
+//    }
+   int ans=inf;
+    
+    if(_11-_00==1 && _00!=0 && _11!=0){
+        // print(""here"");
+        ans=Math.min(ans,same);
+     }
+     if(_10 ==_01 && _10!=0 && _01!=0){
+        ans=Math.min(ans,diff);
+     }
+    
+    if(ans==inf){
+        op.write(""-1\n"");
+    }else{
+        op.write(ans+""\n"");
+    }
+
+ }
+ public static boolean ok(int n, int k)
+    {
+        if ((n & (1 << (k - 1))) > 0)
+           return true;
+        else
+            return false;
+    }
+  
+  static int gcd(int a, int b)
+    {
+        if (a == 0)
+            return b; 
+        return gcd(b % a, a); 
+    }
+  
+
+    public static void main(String[] args) throws Exception {
+        BufferedWriter op = new BufferedWriter(new OutputStreamWriter(System.out));
+        // Reader sc = new Reader();
+        Scanner sc= new Scanner(System.in);
+        int t = sc.nextInt();
+        while (t-->0){ ne(sc, op); }
+        
+        // ne(sc,op);
+           
+                   
+        op.flush();
+    }
+
+    static void print(Object o) {
+        System.out.println(String.valueOf(o));
+    }
+    static int[] toIntArr(String s){
+        int[] val= new int[s.length()];
+        for(int i=0;i<s.length();i++){
+            val[i]=s.charAt(i)-'a';
+        }
+        return val;
+    }
+
+    static void  sort(int[] arr){
+        ArrayList<Integer> list= new ArrayList<>();
+        for(int i=0;i<arr.length;i++){
+            list.add(arr[i]);
+
+        }
+        Collections.sort(list);
+        for(int i=0;i<arr.length;i++){
+            arr[i]=list.get(i);
+        }
+    }
+       static void  sort(long[] arr){
+        ArrayList<Long> list= new ArrayList<>();
+        for(int i=0;i<arr.length;i++){
+            list.add(arr[i]);
+
+        }
+        Collections.sort(list);
+        for(int i=0;i<arr.length;i++){
+            arr[i]=list.get(i);
+        }
+    }
+
+}
+
+
+
+// return -1 to put no ahed in array
+class pair {
+    int  xx;
+    int yy;
+    pair(int xx, int yy ) {
+        this.xx = xx;
+        this.yy = yy;
+    }
+}
+
+
+class sortY implements Comparator<pair> {
+    public int compare(pair p1, pair p2) {
+        if (p1.yy > p2.yy) {
+            return 1;
+        } else if (p1.yy == p2.yy) {
+            if (p1.xx > p2.xx) {
+                return 1;
+            } else if (p1.xx < p2.xx) {
+                return -1;
+            }
+            return 0;
+
+        }
+        return -1;
+    }
+}
+
+class sortX implements Comparator<pair> {
+    public int compare(pair p1, pair p2) {
+        if (p1.xx > p2.xx) {
+            return 1;
+        } else if (p1.xx == p2.xx) {
+            if (p1.yy > p2.yy) {
+                return 1;
+            } else if (p1.yy < p2.yy) {
+                return -1;
+            }
+            return 0;
+
+        }
+        return -1;
+    }
+}
+
+class debug {
+
+    static void print1d(long[] arr) {
+        System.out.println();
+        for (int i = 0; i < arr.length; i++) {
+            System.out.print(arr[i] + "" "");
+        }
+
+    }
+
+    static void print1d(int[] arr) {
+        System.out.println();
+        for (int i = 0; i < arr.length; i++) {
+            System.out.println(i+"" = ""+arr[i]);
+        }
+
+    }
+
+    static void print1d(boolean[] arr) {
+        System.out.println();
+        for (int i = 0; i < arr.length; i++) {
+            System.out.println(i + ""= "" + arr[i]);
+        }
+
+    }
+
+    static void print2d(int[][] arr) {
+        System.out.println();
+        int n = arr.length;
+        int n2 = arr[0].length;
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < n2; j++) {
+                System.out.print(arr[i][j] + "" "");
+            }
+            System.out.println();
+        }
+
+    }
+       static void print2d(boolean[][] arr) {
+        System.out.println();
+        int n = arr.length;
+        int n2 = arr[0].length;
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < n2; j++) {
+                System.out.print(arr[i][j] + "" "");
+            }
+            System.out.println();
+        }
+
+    }
+
+    static void print2d(long[][] arr) {
+        System.out.println();
+        int n = arr.length;
+        int n2 = arr[0].length;
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < n2; j++) {
+                System.out.print(arr[i][j] + "" "");
+            }
+            System.out.println();
+        }
+
+    }
+     static void printPair(ArrayList<pair> list) {
+        if(list.size()==0){
+            System.out.println(""empty list"");
+            return;
+        }
+       System.out.println();
+       for(int i=0;i<list.size();i++){
+          System.out.println(list.get(i).xx+""-""+list.get(i).yy);
+       }
+    }
+
+}
+
+class Reader {
+    final private int BUFFER_SIZE = 1 << 16;
+    private DataInputStream din;
+    private byte[] buffer;
+    private int bufferPointer, bytesRead;
+
+    public Reader() {
+        din = new DataInputStream(System.in);
+        buffer = new byte[BUFFER_SIZE];
+        bufferPointer = bytesRead = 0;
+    }
+
+    public Reader(String file_name) throws IOException {
+        din = new DataInputStream(new FileInputStream(file_name));
+        buffer = new byte[BUFFER_SIZE];
+        bufferPointer = bytesRead = 0;
+    }
+
+    public String readLine() throws IOException {
+        byte[] buf = new byte[64]; // line length
+        int cnt = 0, c;
+        while ((c = read()) != -1) {
+            if (c == '\n') {
+                if (cnt != 0) {
+                    break;
+                } else {
+                    continue;
+                }
+            }
+            buf[cnt++] = (byte) c;
+        }
+        return new String(buf, 0, cnt);
+    }
+
+    public int nextInt() throws IOException {
+        int ret = 0;
+        byte c = read();
+        while (c <= ' ') {
+            c = read();
+        }
+        boolean neg = (c == '-');
+        if (neg)
+            c = read();
+        do {
+            ret = ret * 10 + c - '0';
+        } while ((c = read()) >= '0' && c <= '9');
+
+        if (neg)
+            return -ret;
+        return ret;
+    }
+
+    public long nextLong() throws IOException {
+        long ret = 0;
+        byte c = read();
+        while (c <= ' ')
+            c = read();
+        boolean neg = (c == '-');
+        if (neg)
+            c = read();
+        do {
+            ret = ret * 10 + c - '0';
+        } while ((c = read()) >= '0' && c <= '9');
+        if (neg)
+            return -ret;
+        return ret;
+    }
+
+    public double nextDouble() throws IOException {
+        double ret = 0, div = 1;
+        byte c = read();
+        while (c <= ' ')
+            c = read();
+        boolean neg = (c == '-');
+        if (neg)
+            c = read();
+
+        do {
+            ret = ret * 10 + c - '0';
+        } while ((c = read()) >= '0' && c <= '9');
+
+        if (c == '.') {
+            while ((c = read()) >= '0' && c <= '9') {
+                ret += (c - '0') / (div *= 10);
+            }
+        }
+
+        if (neg)
+            return -ret;
+        return ret;
+    }
+
+    private void fillBuffer() throws IOException {
+        bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
+        if (bytesRead == -1)
+            buffer[0] = -1;
+    }
+
+    private byte read() throws IOException {
+        if (bufferPointer == bytesRead)
+            fillBuffer();
+        return buffer[bufferPointer++];
+    }
+
+    public void close() throws IOException {
+        if (din == null)
+            return;
+        din.close();
+    }
+}
+ class MultiTreeSet<E> {
+	TreeMap<E, Integer> freqTreeMap = new TreeMap<E, Integer>();
+	int size;
+ 
+	public MultiTreeSet() {}
+ 
+	public MultiTreeSet(Collection<? extends E> c) {
+		for(E element : c)
+			add(element);
+	}
+ 
+	public int size() {
+		return size;
+	}
+ 
+	public void add(E element) {
+		Integer freq = freqTreeMap.get(element);
+		if(freq==null)
+			freqTreeMap.put(element, 1);
+		else
+			freqTreeMap.put(element,freq+1);
+		++size;
+	}
+ 
+	public void remove(E element) {
+		Integer freq = freqTreeMap.get(element);
+		if(freq!=null) {
+			if(freq==1)
+				freqTreeMap.remove(element);
+			else
+				freqTreeMap.put(element, freq-1);
+			--size;
+		}
+	}
+ 
+	public int get(E element) {
+		Integer freq = freqTreeMap.get(element);
+		if(freq==null)
+			return 0;
+		return freq;
+	}
+ 
+	public boolean contains(E element) {
+		return get(element)>0;
+	}
+ 
+	public boolean isEmpty() {
+		return size==0;
+	}
+ 
+	public E first() {
+		return freqTreeMap.firstKey();
+	}
+ 
+	public E last() {
+		return freqTreeMap.lastKey();
+	}
+ 
+	public E ceiling(E element) {
+		return freqTreeMap.ceilingKey(element);
+	}
+ 
+	public E floor(E element) {
+		return freqTreeMap.floorKey(element);
+	}
+ 
+	public E higher(E element) {
+		return freqTreeMap.higherKey(element);
+	}
+ 
+	public E lower(E element) {
+		return freqTreeMap.lowerKey(element);
+	}
+}
+ ",0
+a101df86,dffa45ac,"import java.util.*;
+public class Main {
+	public static void main(String[] args){
+		Scanner sc = new Scanner(System.in);
+
+		// long mod = 1_000_000_007L;
+		// long mod = 998_244_353L;
+
+		int t = sc.nextInt();
+
+		for ( int zzz=0; zzz<t; zzz++ ) {
+
+			int n = sc.nextInt();
+
+			int[] a = new int[n];
+			String[] b = new String[n];
+			for ( int i=0; i<n; i++ ) {
+				a[i] = sc.nextInt();
+			}
+
+			int pos = 0;
+			if ( n%2==1 ) {
+				int a01 = a[0]+a[1];
+				if ( a01==0 ) {
+					a01 = a[0]-a[1];
+					b[0] = String.valueOf(a[2]);
+					b[1] = String.valueOf(0-a[2]);
+					b[2] = String.valueOf(0-a01);
+				} else {
+					b[0] = String.valueOf(a[2]);
+					b[1] = String.valueOf(a[2]);
+					b[2] = String.valueOf(0-a01);
+				}
+
+				pos = 3;
+			}
+
+			for ( int i=pos; i<n; i=i+2 ) {
+				b[i] = String.valueOf(a[i+1]);
+				b[i+1] = String.valueOf(0-a[i]);
+			}
+
+			System.out.println(String.join("" "", b));
+		}
+	}
+}
+","import java.util.*;
+public class Main {
+	public static void main(String[] args){
+		Scanner sc = new Scanner(System.in);
+
+		// long mod = 1_000_000_007L;
+		// long mod = 998_244_353L;
+
+		int t = sc.nextInt();
+
+		for ( int zzz=0; zzz<t; zzz++ ) {
+
+			int n = sc.nextInt();
+
+			int[] a = new int[n];
+			String[] b = new String[n];
+			for ( int i=0; i<n; i++ ) {
+				a[i] = sc.nextInt();
+			}
+
+			int pos = 0;
+			if ( n%2==1 ) {
+				int a01 = a[0]+a[1];
+				if ( a01==0 ) {
+					a01 = a[0]-a[1];
+					b[0] = String.valueOf(a[2]);
+					b[1] = String.valueOf(0-a[2]);
+					b[2] = String.valueOf(0-a01);
+				} else {
+					b[0] = String.valueOf(a[2]);
+					b[1] = String.valueOf(a[2]);
+					b[2] = String.valueOf(0-a01);
+				}
+
+				pos = 3;
+			}
+
+			for ( int i=pos; i<n; i=i+2 ) {
+				b[i] = String.valueOf(a[i+1]);
+				b[i+1] = String.valueOf(0-a[i]);
+			}
+
+			System.out.println(String.join("" "", b));
+		}
+	}
+}
+",1
+04df7bb8,aaccc000,"										import java.math.BigInteger;
+										import java.sql.Array;
+									    import java.util.ArrayList;
+										import java.util.Arrays;
+										import java.util.Collection;
+										import java.util.Collections;
+										import java.util.Comparator;
+										import java.util.Deque;
+										import java.util.HashMap;
+										import java.util.HashSet;
+										import java.util.InputMismatchException;
+										import java.util.LinkedList;
+										import java.util.PriorityQueue;
+										import java.util.Queue;
+										import java.util.Scanner;
+										import java.util.Set;
+										import java.util.Stack;
+										import java.io.BufferedReader;
+										import java.io.IOException;
+										import java.io.InputStream;
+										import java.io.InputStreamReader;
+										import java.util.Scanner;
+										import java.util.StringTokenizer;
+										import java.util.TreeMap;
+										import java.util.TreeSet;
+										
+											
+											
+											
+											
+											
+											public class Main {
+							
+												
+												static HashMap<Integer,Boolean>map;
+												
+											static long dp[][];
+											static 	boolean flag;
+										static	HashSet<Long>hs;
+											static long mod=(long)(1e9+7);
+												public static void main(String[] args) {
+												StringBuilder ans=new StringBuilder();
+												FastReader sc=new FastReader();
+													
+												
+												int t=sc.nextInt();
+												
+												
+												while(t-->0) {
+													
+													int n=sc.nextInt();
+													
+													
+													//int n=sb.length();
+													
+													
+													
+													int k=sc.nextInt();
+													
+													
+													long L[]=new long[n];
+													long R[]=new long[n];
+													int a[]=new int[k];
+													int temp[]=new int[k];
+													
+													for(int i=0;i<k;i++)
+														a[i]=sc.nextInt();
+													
+													for(int i=0;i<k;i++)
+														temp[i]=sc.nextInt();
+													
+													int c[]=new int [n];
+													Arrays.fill(c, Integer.MAX_VALUE);
+													for(int i=0;i<k;i++)
+														c[a[i]-1]=temp[i];
+												
+													long p=Integer.MAX_VALUE;
+													
+													for(int i=0;i<n;i++)
+													{
+														p=Math.min(p+1, c[i]);
+														
+														L[i]=p;
+														
+														
+													}
+													p=Integer.MAX_VALUE;
+													for(int i=n-1;i>=0;i--)
+													{
+														p=Math.min(p+1, c[i]);
+														
+														R[i]=p;
+														
+														
+													}
+													
+													for(int i=0;i<n;i++)
+													{
+														ans.append(Math.min(L[i], R[i])+"" "");
+													}
+											ans.append(""\n"");
+													
+												}
+												System.out.println(ans);
+												
+												}
+													
+											static class Sparse{
+												int log[];
+												long sparse[][];
+												Sparse(int n){
+													
+												log=new int [n+1];
+												
+												
+												for(int i=1;i<n+1;i++)
+													
+												{
+													log[i]=log[i/2]+1;
+												}
+												sparse=new long[n][18];
+												
+												
+												
+												}
+												
+												
+			
+												
+												
+												
+												
+											}
+													
+
+
+												
+												
+							
+												
+												
+												
+												
+												
+												
+												
+												
+											static	long solve(String X,String Y,int n,int m,int M){
+												    
+													if(m==0&&n==0)return 0;
+													
+													//	if(m==1&&X.charAt(n-1)!='u')return Integer.MIN_VALUE;
+													if(n==0||m==0)return Integer.MIN_VALUE;
+											        
+											        if(dp[n][m]!=-1)return dp[n][m]; 
+												    
+												    
+												    
+												    if(Y.charAt(m-1)==X.charAt(n-1))
+												    {
+												 //   else if(n==1)return Integer.MAX_VALUE;
+												    	return dp[n][m]=1+ Math.max(solve (X,Y,n-1,m,M),solve (X,Y,n-1,m-1,M));
+												    }
+												    else{
+												        
+												        return dp[n][m]= solve(X,Y,n-1,m,M);
+												        
+												    }
+												}
+												
+												static long solve(long [][]g,int n,int m,boolean visited [][]) {
+													
+													if(n==0||m==0)return 0;
+													
+													visited[n][m]=true;
+													long ans=g[n-1][m-1]+Math.max(solve(g, n, m-1, visited),solve(g, n-1, m, visited));
+													
+													
+													visited[n][m]=false;
+													
+													return ans;
+													
+													
+													
+												}
+												
+												
+												
+												
+												static boolean isP(long x,long n,long m) {
+													
+													return (x^n)<=m;
+													
+												}
+												
+												
+												
+												
+												
+												static class pair{
+													int n;int i;
+													
+													pair(int n,int i){
+														this.n=n;
+														this.i=i;
+													}
+												}
+													
+													
+												
+												
+												
+												
+												
+												static long	 solve(char g[][],int n,int m) {
+													if(n==0||m==0)return 0;
+													if(n==1&&m==1)return 1;
+													if(g[n-1][m-1]=='#')return 0;
+													
+													if(dp[n][m]!=-1)return dp[n][m];
+													
+													return dp[n][m]= (solve(g, n-1, m)%mod+solve(g, n, m-1)%mod)%mod;
+														
+													
+												}
+												
+												
+												
+												
+												
+												
+												
+												
+												
+									static	int  solve	(int v,ArrayList<ArrayList<Integer>>adj,int d[],boolean visited[]) {
+											
+											
+											visited[v]=true;
+											for(int u:adj.get(v)) {
+												
+												if(!visited[u])
+												{
+												solve(u, adj, d, visited);
+												
+												}
+												d[v]=Math.max(1+d[u], d[v]);
+											}
+											
+											
+											return d[v];
+											
+											
+										}
+												
+												
+											
+												
+										static class colors{
+											
+											int c;int n;
+											public colors(int c,int n) {
+												// TODO Auto-generated constructor stub
+												this.c=c;
+												this.n=n;
+											}
+											
+										}
+												
+												
+												
+												
+												static int CeilIndex(long A[], int l, int r, long key)
+											    {
+											        while (r - l > 1) {
+											            int m = l + (r - l) / 2;
+											            if (A[m] >= key)
+											                r = m;
+											            else
+											                l = m;
+											        }
+											 
+											        return r;
+											    }
+											 
+												static int CeilIndexd(long A[], int l, int r, long key)
+											    {
+											        while (r - l > 1) {
+											            int m = l + (r - l) / 2;
+											            if (-1*A[m] >= key)
+											                r = m;
+											            else
+											                l = m;
+											        }
+											 
+											        return r;
+											    }
+											 
+												
+												
+												
+											
+												
+											static void solve(ArrayList<Long>A,long bd) {
+											
+												if(bd>(long)1e9)return;
+											//	if(hs.contains(bd))return;
+												//A.add(bd);
+												hs.add(bd);
+												A.add(bd*10);
+												A.add(bd*10+1);
+											//	hs.add(bd*10);
+												//hs.add(bd*10+1);
+											
+												solve(A,bd*10);
+												solve(A,bd*10+1);
+												
+												
+											}
+												
+												
+												
+												
+												
+												 static boolean isPrime(int n)
+												    {
+												        // Corner cases
+												        if (n <= 1)
+												            return false;
+												        if (n <= 3)
+												            return true;
+												  
+												        // This is checked so that we can skip
+												        // middle five numbers in below loop
+												        if (n % 2 == 0 || n % 3 == 0)
+												            return false;
+												  
+												        for (int i = 5; i * i <= n; i = i + 6)
+												            if (n % i == 0 || n % (i + 2) == 0)
+												                return false;
+												  
+												        return true;
+												    }
+												  
+												static long lcm(long a, long b)
+											    {
+											        return ((a / gcd(a, b))%mod * b%mod)%mod;
+											    }
+												   static long gcd(long a,long b)
+												    {
+												        if (a == 0)
+												            return b%mod; 
+												        return (gcd(b % a, a))%mod; 
+												    }
+												
+									
+												//System.out.println(count);
+												
+											
+												
+												
+												static void dfs(int v,boolean visited[],ArrayList<ArrayList<Integer>>adj,int div[],int t)
+												{
+													visited[v]=true;
+													
+													div[v]=t+1;
+													for(int u:adj.get(v)) {
+														
+														
+														
+														if(!visited[u]) {
+															dfs(u,visited,adj,div,(t+1)%2);
+														}
+														
+													}
+													
+													
+												}
+												
+												
+												static class Helper{
+													
+													int a;int b;int t;
+													public Helper(int a,int b) {
+														// TODO Auto-generated constructor stub
+														
+														this.a=a;
+														this.b=b;
+											
+														
+													
+													}
+													
+													
+												}
+										
+										
+												
+										
+												
+												
+												
+												
+												//	System.out.println(max);
+										
+												
+											
+												
+											
+									
+				//System.out.println(ans.toString());
+				//main(						
+											
+							
+					
+				static void solvedfs(ArrayList<ArrayList<Integer>>adj,int n,int v,int subt[],int subtAns[],boolean []visited) {
+							
+							
+							int count=1;
+							int ans=0;
+							visited[v]=true;
+							for(int u:adj.get(v)) {
+								
+								
+								if(!visited[u])
+								{
+									//System.out.println(v+"" ""+subt[v]+"" ""+n);
+									subtAns[u]=Math.max(subtAns[u], subt[v]-subtAns[u]);
+									
+								solvedfs(adj, n, u, subt, subtAns, visited);			
+								
+								}
+							}
+							
+						
+							
+							
+							
+							
+							
+						}
+						
+												
+												
+												
+								static int dfs(ArrayList<ArrayList<Integer>>adj,int v,int subt[],int subtAns[],boolean []visited) {
+								
+									
+									int count=0;
+									int ans=0;
+									visited[v]=true;
+									for(int u:adj.get(v)) {
+										
+										
+										if(!visited[u])
+										{
+											count+=ans;
+											ans=Math.max(dfs(adj,u,subt,subtAns,visited),ans);
+										}
+									}
+										subt[v]=count;
+										subtAns[v]=ans;
+										return ans+1;
+										
+									
+									
+									
+									
+									
+								}
+												
+								
+												
+												
+								static	int solve(ArrayList<ArrayList<Integer>>adj,int node,ArrayList<Integer>A)			
+									{
+										if(adj.get(node).size()==0)return 1;
+										
+										int count=0;
+										for(int v:adj.get(node)) {
+											
+											count+=solve(adj,v,A);
+											
+										}
+										
+										A.set(node,count);
+										return count+1;
+										
+										
+										
+									}
+												
+												
+												
+												
+												
+												
+												
+									static void dfs(String[]building,int i,int j,int n,int m, boolean visited[][]) {
+										
+										
+										visited[i][j]=true;
+										
+										if(isValid(building,i+1,j,n,m,visited))
+										{	visited[i+1][j]=true;
+											dfs(building,i+1,j,n,m,visited);
+										
+										}
+											if(isValid(building,i-1,j,n,m,visited))
+										{
+											visited[i-1][j]=true;
+											dfs(building,i-1,j,n,m,visited);
+										}
+										 if(isValid(building,i,j+1,n,m,visited))
+										{visited[i][j+1]=true;
+											dfs(building,i,j+1,n,m,visited);
+										}
+												if(isValid(building,i,j-1,n,m,visited))
+										{visited[i][j-1]=true;
+											dfs(building,i,j-1,n,m,visited);
+										}
+										
+										
+										
+										
+									}
+									static boolean isValid(String[]building,int i,int j,int n,int m, boolean visited[][])		
+									{
+										if(i==-1||j==-1||i==n||j==m||visited[i][j]||building[i].charAt(j)=='#')
+											return false;
+									return true;
+									}
+												
+												
+												
+												
+								static	void compute(boolean sieve[],int n) {
+										
+										for(int i=2;i<=n;i++) {
+											if(sieve[i])continue;
+											
+											for(int j=2*i;j<n;j+=i)
+											{
+												sieve[j]=true;
+											}
+											
+										}
+											
+										
+										
+									}
+								
+								static	void computeHs(boolean sieve[]) {
+									int n=(int)(1e9-1e7+1);
+									for(int i=1;i<n;i++) {
+										if(sieve[i])continue;
+										
+										for(int j=2*i;j<n;j+=i)
+										{
+											sieve[j]=true;
+										}
+										
+									}
+									
+								}
+							
+								
+									
+												
+												
+												static boolean isValid(StringBuilder s,int w) {
+													if(w>s.length())return false;
+													HashSet<Character>hs=new HashSet<Character>();
+													int a[]=new int[3];
+													
+													for(int i=0;i<w;i++) {
+													
+														++a[s.charAt(i)-49];
+														
+													}
+													
+													if(a[0]>0&&a[1]>0&&a[2]>0)return true;
+												
+													int start=0;
+													int end=w;
+													
+													while(end!=s.length()) {
+														--a[s.charAt(start)-49];
+														
+															++a[s.charAt(end)-49];
+														
+																	start++;
+																		end++;
+																		if(a[0]>0&&a[1]>0&&a[2]>0)return true;
+																				
+													}
+													return false;
+													
+													
+													
+												}
+								
+												
+												
+												
+									
+							
+												
+									static int find(int parent[],int i) {
+										
+										if(parent[i]==-1)return i;
+										
+										return parent[i]=find(parent,parent[i]);
+										
+									}
+									static void union(int parent[],int rank[],int s1,int s2) {
+										
+										if(rank[s1]>=rank[s2]) {
+											
+											parent[s2]=s1;
+											rank[s1]+=rank[s2];
+										}
+										
+										else {
+											
+											parent[s1]=s2;
+											rank[s2]+=rank[s1];
+										}
+										
+										
+									}
+												
+												
+												
+												
+												
+												
+												
+												
+												
+												
+												
+									static	int solve(String S,int K) {
+											
+											if(K<=0)return 0;
+											if(S.charAt(K-1)!=S.charAt(K))
+											return 1+solve(S,K-1);
+											else return solve(S,K-1);
+										}
+										
+										
+										
+										
+				
+				
+					
+				static	boolean isValid(int g[][],int r,int c,int n,int m,boolean visited[][],int s) {
+						if(r==-1||r==n||c==-1||c==m||visited[r][c]||g[r][c]!=s)return false;
+						return true;
+					}
+				
+										
+											
+																					
+											
+									    static class FastReader {
+									        BufferedReader br;
+									        StringTokenizer st;
+									 
+									        public FastReader()
+									        {
+									            br = new BufferedReader(
+									                new InputStreamReader(System.in));
+									        }
+									 
+									        String next()
+									        {
+									            while (st == null || !st.hasMoreElements()) {
+									                try {
+									                    st = new StringTokenizer(br.readLine());
+									                }
+									                catch (IOException e) {
+									                    e.printStackTrace();
+									                }
+									            }
+									            return st.nextToken();
+									        }
+									 
+									        int nextInt() { return Integer.parseInt(next()); }
+									 
+									        long nextLong() { return Long.parseLong(next()); }
+									 
+									        double nextDouble()
+									        {
+									            return Double.parseDouble(next());
+									        }
+									 
+									        String nextLine()
+									        {
+									            String str = """";
+									            try {
+									                str = br.readLine();
+									            }
+									            catch (IOException e) {
+									                e.printStackTrace();
+									            }
+									            return str;
+									        }
+									    }
+									 
+										
+											}
+											
+											
+											
+											
+											    ","import java.io.*;
+import java.util.*;
+
+public class GFG {
+	public static void main (String[] args) {
+	    Scanner sc = new Scanner(System.in);
+	    int t = sc.nextInt();
+	    while(t-- > 0){
+	        int n = sc.nextInt();
+	        int k = sc.nextInt();
+	        int[] a = new int[k];
+	        int[] temp = new int[k];
+	        for(int i=0;i<k;i++){
+	            a[i] = sc.nextInt();
+	        }
+	        for(int i=0;i<k;i++){
+	            temp[i] = sc.nextInt();
+	        }
+	        long[] c = new long[n];
+	        Arrays.fill(c,Integer.MAX_VALUE);
+	        for(int i=0;i<k;i++){
+	            c[a[i]-1] = temp[i];
+	        }
+	        long p = Integer.MAX_VALUE;
+	        long[] left = new long[n];
+	        for(int i=0;i<n;i++){
+	            p = (p+1<c[i])?p+1:c[i];
+	            left[i] = p;
+	        }
+	        p = Integer.MAX_VALUE;
+	        long[] right = new long[n];
+	        for(int i=n-1;i>=0;i--){
+	            p = (p+1<c[i])?p+1:c[i];
+	            right[i] = p;
+	        }
+	        for(int i=0;i<n;i++){
+	            long kl = (left[i]>right[i])?right[i]:left[i];
+	            System.out.print(kl+"" "");
+	        }
+	        System.out.println();
+	    }
+	}
+}
+",1
+141effef,9cea10af,"// package codeforces;
+
+import java.util.*;
+
+public class ArmChairs {
+	static int[]arr;
+	static ArrayList<Integer>a;
+	static ArrayList<Integer>b;
+	static int dp[][];
+	public static void main(String[] args) {
+		Scanner scn = new Scanner(System.in);
+		int n = scn.nextInt();
+		arr=new int[n];
+		for(int i=0;i<n;i++) {
+			arr[i]=scn.nextInt();
+		}
+		dp=new int[n+1][n+1];
+		a =new ArrayList<>();
+		b =new ArrayList<>();
+		for(int i=0;i<n;i++) {
+			if(arr[i]==0) {
+				a.add(i);
+			}else{
+				b.add(i);
+			}
+		}
+		System.out.println(solve(0,0));	
+	}
+	
+	public static int solve(int i,int j) {
+		if(i==b.size()) {
+			return 0;
+		}
+		if(j==a.size()) {
+			return 100000000;
+		}
+
+		if(dp[i][j]!=0) {
+			return dp[i][j];
+		}
+		int x=Math.abs(a.get(j)-b.get(i))+solve(i+1,j+1);
+		int y=solve(i,j+1);
+		return dp[i][j]=Math.min(x, y);
+	}
+	
+
+}
+","//package currentContest;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.StringTokenizer;
+public class P4 {
+	static int dp[][]=new int[5000+1][5000+1];
+	public static void main(String[] args) {
+		// TODO Auto-generated method stub
+		FastReader sc=new FastReader();
+		int t=1;
+		//t=sc.nextInt();
+		StringBuilder s=new StringBuilder();
+		while(t--!=0) {
+			int n=sc.nextInt();
+			int a[]=new int[n];
+			
+			for(int i=0;i<=n;i++) {
+				for(int j=0;j<=n;j++) {
+					P4.dp[i][j]=-1;
+				}
+			}
+			ArrayList<Integer> one=new ArrayList<>();
+			ArrayList<Integer> zero=new ArrayList<>();
+			for(int i=0;i<n;i++) {
+				a[i]=sc.nextInt();
+				if(a[i]==0) {
+					zero.add(i);
+				}else {
+					one.add(i);
+				}
+			}
+			Collections.sort(zero);
+			Collections.sort(one);
+			long ans=sol(0,0,zero.size(),one.size(),a,zero,one);
+			System.out.println(ans);
+		}
+		//System.out.println(s);
+	}
+	private static long sol(int i, int j, int n, int m,int a[], ArrayList<Integer> zero, ArrayList<Integer> one) {
+		//System.out.println(i+"" ""+j);
+		// TODO Auto-generated method stub
+		if(j==m) {
+			return 0;
+		}
+		int av=n-i;
+		int rem=m-j;
+		if(av<rem) {
+			return Integer.MAX_VALUE-1;
+		}
+		if(dp[i][j]!=-1) {
+			return dp[i][j];
+		}
+		long ans1=sol(i+1,j,n,m,a, zero, one);
+		long ans2=Math.abs(zero.get(i)-one.get(j))+sol(i+1,j+1,n,m,a, zero, one);
+		dp[i][j]=(int) Math.min(ans1, ans2);
+		return dp[i][j];
+	}
+	static class FastReader 
+    { 
+        BufferedReader br; 
+        StringTokenizer st; 
+  
+        public FastReader() 
+        { 
+            br = new BufferedReader(new
+                     InputStreamReader(System.in)); 
+        } 
+  
+        String next() 
+        { 
+            while (st == null || !st.hasMoreElements()) 
+            { 
+                try
+                { 
+                    st = new StringTokenizer(br.readLine()); 
+                } 
+                catch (IOException  e) 
+                { 
+                    e.printStackTrace(); 
+                } 
+            } 
+            return st.nextToken(); 
+        } 
+  
+        int nextInt() 
+        { 
+            return Integer.parseInt(next()); 
+        } 
+  
+        long nextLong() 
+        { 
+            return Long.parseLong(next()); 
+        } 
+  
+        double nextDouble() 
+        { 
+            return Double.parseDouble(next()); 
+        } 
+  
+        String nextLine() 
+        { 
+            String str = """"; 
+            try
+            { 
+                str = br.readLine(); 
+            } 
+            catch (IOException e) 
+            { 
+                e.printStackTrace(); 
+            } 
+            return str; 
+        } 
+    } 
+}
+",0
+74f4382e,bd584714,"
+import java.io.*;
+import java.util.*;
+
+public class Solution {
+
+	static long modInverse(long a, long m) {
+		long m0 = m;
+		long y = 0, x = 1;
+
+		if (m == 1)
+			return 0;
+
+		while (a > 1) {
+
+			long q = a / m;
+
+			long t = m;
+
+			m = a % m;
+			a = t;
+			t = y;
+
+			y = x - q * y;
+			x = t;
+		}
+
+		if (x < 0)
+			x += m0;
+
+		return x;
+	}
+
+	static void pla() {
+
+		int a = 0;
+		int b = 2;
+		int c = 0;
+		int d = 0;
+
+		a = (int) Math.pow(2, 32);
+
+		c = a + b;
+		b = c / a;
+		d = a + b + c;
+
+	}
+
+	static int mod = (int) 1e9 + 7;
+
+	//static Scanner sc = new Scanner(System.in);
+	static StringBuilder out = new StringBuilder();
+
+	
+	static int pri[] = new int[(int) 1e5 + 5];
+	static void sieve() {
+		pri[1] = pri[0] = 1;
+		for (int i = 2; i < pri.length; i++) {
+			pri[i] = i;
+		}
+		for (int i = 2; i < Math.sqrt(pri.length); i++) {
+			if (pri[i] != i)
+				continue;
+
+			for (int j = i * i; j < pri.length; j += i) {
+				if (pri[j] == j)
+					pri[j] = i;
+			}
+
+		}
+	}
+	
+	public static void main(String[] args) throws IOException {
+
+		int t = sc.nextInt();
+
+		//sieve();
+		int tc = 1;
+		while (tc <= t) {
+
+			// out.append(""Case #"" + tc + "": "");
+			Solution run = new Solution();
+
+			run.run();
+
+			tc++;
+		}
+
+		System.out.println(out);
+
+	}
+
+	
+	ArrayList<Integer> gr[];
+	long a[][];
+	public static int gcd(int a, int b) {
+		return (b == 0) ? a : gcd(b, a % b);
+	}
+
+	public void run() throws IOException {
+
+		int n = sc.nextInt();
+		
+		gr=new ArrayList[n+1];
+		a=new long[n+1][2];
+		for(int i=0;i<=n;i++)gr[i]=new ArrayList<>();
+		
+	
+		for(int i=1;i<=n;i++) {
+			
+			a[i][0]=sc.nextInt();
+			a[i][1]=sc.nextInt();
+		}
+		
+		for(int i=0;i<n-1;i++) {
+			
+			int u=sc.nextInt();
+			int v=sc.nextInt();
+			
+			gr[u].add(v);
+			gr[v].add(u);
+		}
+		
+		dp=new long[n+1][2];
+		
+		for(long a1[]:dp)Arrays.fill(a1, -1L);
+		
+		//dfs(1,-1);
+		
+		long res=Math.max(dfs(1,-1,0), dfs(1,-1,1));
+		
+		out.append(res+""\n"");
+		
+		
+	}
+	
+	long dp[][];
+	
+	
+	long dfs(int u, int pa,int ok) {
+		
+		
+		
+			
+			if(dp[u][ok]!=-1)return dp[u][ok];
+			
+			
+		
+		
+		
+		long ans=0;
+		for(int ch: gr[u]) {
+			
+			
+			if(ch==pa)continue;
+			long res=0;
+			
+			
+				
+				if(ok==0) {
+					
+					res=Math.max(dfs(ch,u,0)+Math.abs(a[u][0]-a[ch][0]), dfs(ch,u,1)+Math.abs(a[u][0]-a[ch][1]));
+					
+				}
+				else {
+					
+					res=Math.max(dfs(ch,u,0)+Math.abs(a[u][1]-a[ch][0]), dfs(ch,u,1)+Math.abs(a[u][1]-a[ch][1]));
+					
+					
+				}
+			
+			
+			
+			ans+=res;
+			
+			
+			
+			
+		}
+		
+		return dp[u][ok]=ans;
+	}
+	
+	
+	void dfs(int u, int pa) {
+		
+		if(gr[u].size()==1) {
+			dp[u][0]=dp[u][1]=0L;
+		}
+		
+		
+		for(int ch:gr[u]) {
+			
+			
+			if(ch==pa)continue;
+			
+			
+			dfs(ch,u);
+		}
+		
+		
+		
+		for(int ch: gr[u]) {
+			
+			if(ch==pa)continue;
+			
+			long ans1=0;
+			long ans2=0;
+			
+			
+			ans1=Math.max(dp[ch][0]+Math.abs(a[u][0]-a[ch][0]), dp[ch][1]+Math.abs(a[u][0]-a[u][1]));
+			
+			dp[u][0]+=ans1;
+			
+			ans1=Math.max(dp[ch][0]+Math.abs(a[u][1]-a[ch][0]), dp[ch][1]+Math.abs(a[u][1]-a[u][1]));
+			
+			dp[u][1]+=ans2;
+			
+			
+			
+		}
+		
+		
+	}
+
+	static void sort(int a[], int n) {
+
+		ArrayList<Integer> al = new ArrayList<>();
+
+		for (int i = 0; i < n; i++) {
+
+			al.add(a[i]);
+		}
+
+		Collections.sort(al);
+
+		for (int i = 0; i < n; i++) {
+
+			a[i] = al.get(i);
+		}
+	}
+
+	static void sort(long a[], int n) {
+
+		ArrayList<Long> al = new ArrayList<>();
+
+		for (int i = 0; i < n; i++) {
+
+			al.add(a[i]);
+		}
+
+		Collections.sort(al);
+
+		for (int i = 0; i < n; i++) {
+
+			a[i] = al.get(i);
+		}
+	}
+
+	static Reader sc = new Reader();
+
+	static class Reader {
+		final private int BUFFER_SIZE = 1 << 16;
+		private DataInputStream din;
+		private byte[] buffer;
+		private int bufferPointer, bytesRead;
+
+		public Reader() {
+			din = new DataInputStream(System.in);
+			buffer = new byte[BUFFER_SIZE];
+			bufferPointer = bytesRead = 0;
+		}
+
+		public Reader(String file_name) throws IOException {
+			din = new DataInputStream(new FileInputStream(file_name));
+			buffer = new byte[BUFFER_SIZE];
+			bufferPointer = bytesRead = 0;
+		}
+
+		public String readLine() throws IOException {
+			byte[] buf = new byte[64]; // line length
+			int cnt = 0, c;
+			while ((c = read()) != -1) {
+				if (c == '\n')
+					break;
+				buf[cnt++] = (byte) c;
+			}
+			return new String(buf, 0, cnt);
+		}
+
+		public int nextInt() throws IOException {
+			int ret = 0;
+			byte c = read();
+			while (c <= ' ')
+				c = read();
+			boolean neg = (c == '-');
+			if (neg)
+				c = read();
+			do {
+				ret = ret * 10 + c - '0';
+			} while ((c = read()) >= '0' && c <= '9');
+
+			if (neg)
+				return -ret;
+			return ret;
+		}
+
+		public long nextLong() throws IOException {
+			long ret = 0;
+			byte c = read();
+			while (c <= ' ')
+				c = read();
+			boolean neg = (c == '-');
+			if (neg)
+				c = read();
+			do {
+				ret = ret * 10 + c - '0';
+			} while ((c = read()) >= '0' && c <= '9');
+			if (neg)
+				return -ret;
+			return ret;
+		}
+
+		public double nextDouble() throws IOException {
+			double ret = 0, div = 1;
+			byte c = read();
+			while (c <= ' ')
+				c = read();
+			boolean neg = (c == '-');
+			if (neg)
+				c = read();
+
+			do {
+				ret = ret * 10 + c - '0';
+			} while ((c = read()) >= '0' && c <= '9');
+
+			if (c == '.') {
+				while ((c = read()) >= '0' && c <= '9') {
+					ret += (c - '0') / (div *= 10);
+				}
+			}
+
+			if (neg)
+				return -ret;
+			return ret;
+		}
+
+		private void fillBuffer() throws IOException {
+			bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
+			if (bytesRead == -1)
+				buffer[0] = -1;
+		}
+
+		private byte read() throws IOException {
+			if (bufferPointer == bytesRead)
+				fillBuffer();
+			return buffer[bufferPointer++];
+		}
+
+		public void close() throws IOException {
+			if (din == null)
+				return;
+			din.close();
+		}
+	}
+
+}","import java.io.OutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.PrintWriter;
+import java.util.Arrays;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+import java.util.StringTokenizer;
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.InputStream;
+
+public class Main {
+    public static void main(String[] args) {
+        InputStream inputStream = System.in;
+        OutputStream outputStream = System.out;
+        Scanner in = new Scanner(inputStream);
+        PrintWriter out = new PrintWriter(outputStream);
+        CParsasHumongousTree solver = new CParsasHumongousTree();
+        solver.solve(1, in, out);
+        out.close();
+    }
+
+    static class CParsasHumongousTree {
+        int n;
+        long[] l;
+        long[] r;
+        ArrayList<Integer>[] adj;
+        long[][] dp;
+
+        public void solve(int testNumber, Scanner sc, PrintWriter pw) {
+            int t = 1;
+            t = sc.nextInt();
+            while (t-- > 0) {
+                n = sc.nextInt();
+                l = new long[n];
+                r = new long[n];
+                for (int i = 0; i < n; i++) {
+                    l[i] = sc.nextInt();
+                    r[i] = sc.nextInt();
+                }
+                adj = new ArrayList[n];
+                for (int i = 0; i < n; i++) adj[i] = new ArrayList<>();
+                for (int i = 0; i < n - 1; i++) {
+                    int x = sc.nextInt() - 1;
+                    int y = sc.nextInt() - 1;
+                    adj[x].add(y);
+                    adj[y].add(x);
+                }
+                dp = new long[n + 1][2];
+                for (long[] x : dp) Arrays.fill(x, -1);
+                long ans = solve(-1, 0, 0);
+                for (long[] x : dp) Arrays.fill(x, -1);
+                ans = Math.max(ans, solve(-1, 0, 1));
+                pw.println(ans);
+            }
+
+        }
+
+        long solve(int from, int i, int f) {
+            if (dp[i][f] != -1) return dp[i][f];
+            long ans = 0;
+            long a = f == 0 ? l[i] : r[i];
+            for (int x : adj[i]) {
+                if (x != from)
+                    ans += Math.max((Math.abs(l[x] - a) + solve(i, x, 0)), (Math.abs(r[x] - a) + solve(i, x, 1)));
+            }
+            return dp[i][f] = ans;
+        }
+
+    }
+
+    static class Scanner {
+        StringTokenizer st;
+        BufferedReader br;
+
+        public Scanner(FileReader r) {
+            br = new BufferedReader(r);
+        }
+
+        public Scanner(InputStream s) {
+            br = new BufferedReader(new InputStreamReader(s));
+        }
+
+        public String next() {
+            while (st == null || !st.hasMoreTokens()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+            }
+            return st.nextToken();
+        }
+
+        public int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+    }
+}
+
+",0
+0e87b87f,6369a7a2,"import java.io.*;
+import java.util.*;
+public class table {
+    static class FastReader {
+        BufferedReader br;
+        StringTokenizer st;
+
+        public FastReader() {
+            br = new BufferedReader(new
+                    InputStreamReader(System.in));
+        }
+
+        public FastReader(File file) throws java.io.IOException {
+            br = new BufferedReader(new InputStreamReader(new FileInputStream(file)));
+        }
+
+        String next() {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+
+        String nextLine() {
+            String str = """";
+            try {
+                str = br.readLine();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+        }
+    }
+    public static void main(String[] args) throws java.io.IOException {
+        File file = new File(""hoofball.in""); // change this
+        FastReader input = new FastReader(); // change this
+        PrintWriter output = new PrintWriter(""hoofball.out""); // change this or ph
+
+        int testcases = input.nextInt();
+        for (int t = 0; t < testcases; t++) {
+            int rows = input.nextInt();
+            int columns = input.nextInt();
+            char[][] matrix = new char[rows][columns];
+            for (int i = 0; i < rows; i++) {
+                matrix[i] = input.next().toCharArray();
+            }
+            int counter = 0;
+            ArrayList<String> list = new ArrayList<String>();
+            for (int r = 0; r < rows - 1; r++) {
+                for (int c = 0; c < columns - 1; c++) {
+                    int r1 = r + 1;
+                    int c1 = c + 1;
+                    int r2 = r + 2;
+                    int c2 = c + 2;
+                    while (matrix[r][c] == '1' || matrix[r+1][c] == '1' || matrix[r][c+1] == '1' || matrix[r+1][c+1] == '1') {
+                        if (matrix[r][c] == '0' && matrix[r+1][c] == '1' && matrix[r][c+1] == '1' && matrix[r+1][c+1] == '1') { // 0 1 1 1
+                            list.add(r2 +"" ""+ c1 +"" ""+ r1 +"" ""+ c2 +"" ""+ r2 +"" ""+ c2);
+                            matrix[r+1][c] = '0';
+                            matrix[r][c+1] = '0';
+                            matrix[r+1][c+1] = '0';
+                        } else if (matrix[r][c] == '1' && matrix[r+1][c] == '0' && matrix[r][c+1] == '1' && matrix[r+1][c+1] == '1') { // 1 0 1 1
+                            list.add(r1 +"" ""+ c1 +"" ""+ r1 +"" ""+ c2 +"" ""+ r2 +"" ""+ c2);
+                            matrix[r][c] = '0';
+                            matrix[r][c+1] = '0';
+                            matrix[r+1][c+1] = '0';
+                        } else if (matrix[r][c] == '1' && matrix[r+1][c] == '1' && matrix[r][c+1] == '0' && matrix[r+1][c+1] == '1') { // 1 1 0 1
+                            list.add(r1 +"" ""+ c1 +"" ""+ r2 +"" ""+ c1 +"" ""+ r2 +"" ""+ c2);
+                            matrix[r][c] = '0';
+                            matrix[r+1][c] = '0';
+                            matrix[r+1][c+1] = '0';
+                        } else if (matrix[r][c] == '1' && matrix[r+1][c] == '1' && matrix[r][c+1] == '1' && matrix[r+1][c+1] == '0') { // 1 1 1 0
+                            list.add(r1 +"" ""+ c1 +"" ""+ r2 +"" ""+ c1 +"" ""+ r1 +"" ""+ c2);
+                            matrix[r][c] = '0';
+                            matrix[r+1][c] = '0';
+                            matrix[r][c+1] = '0';
+                        } else if (matrix[r][c] == '1' && matrix[r+1][c] == '1' && matrix[r][c+1] == '0' && matrix[r+1][c+1] == '0') { // 1 1 0 0
+                            list.add(r1 +"" ""+ c1 +"" ""+ r1 +"" ""+ c2 +"" ""+ r2 +"" ""+ c2);
+                            matrix[r][c] = '0';
+                            matrix[r][c+1] = '1';
+                            matrix[r+1][c+1] = '1';
+                        } else if (matrix[r][c] == '0' && matrix[r+1][c] == '0' && matrix[r][c+1] == '1' && matrix[r+1][c+1] == '1') { // 0 0 1 1
+                            list.add(r1 +"" ""+ c1 +"" ""+ r2 +"" ""+ c1 +"" ""+ r2 +"" ""+ c2);
+                            matrix[r][c] = '1';
+                            matrix[r+1][c] = '1';
+                            matrix[r+1][c+1] = '0';
+                        } else if (matrix[r][c] == '1' && matrix[r+1][c] == '0' && matrix[r][c+1] == '1' && matrix[r+1][c+1] == '0') { // 1 0 1 0
+                            list.add(r1 +"" ""+ c1 +"" ""+ r2 +"" ""+ c1 +"" ""+ r1 +"" ""+ c2);
+                            matrix[r][c] = '0';
+                            matrix[r+1][c] = '1';
+                            matrix[r][c+1] = '0';
+                        } else if (matrix[r][c] == '0' && matrix[r+1][c] == '1' && matrix[r][c+1] == '0' && matrix[r+1][c+1] == '1') { // 0 1 0 1
+                            list.add(r1 +"" ""+ c1 +"" ""+ r1 +"" ""+ c2 +"" ""+ r2 +"" ""+ c2);
+                            matrix[r][c] = '1';
+                            matrix[r][c+1] = '1';
+                            matrix[r+1][c+1] = '0';
+                        } else if (matrix[r][c] == '1' && matrix[r+1][c] == '0' && matrix[r][c+1] == '0' && matrix[r+1][c+1] == '0') { // 1 0 0 0
+                            list.add(r1 +"" ""+ c1 +"" ""+ r1 +"" ""+ c2 +"" ""+ r2 +"" ""+ c2);
+                            matrix[r][c] = '0';
+                            matrix[r][c+1] = '1';
+                            matrix[r+1][c+1] = '1';
+                        } else if (matrix[r][c] == '0' && matrix[r+1][c] == '1' && matrix[r][c+1] == '0' && matrix[r+1][c+1] == '0') { // 0 1 0 0
+                            list.add(r2 +"" ""+ c1 +"" ""+ r1 +"" ""+ c2 +"" ""+ r2 +"" ""+ c2);
+                            matrix[r+1][c] = '0';
+                            matrix[r][c+1] = '1';
+                            matrix[r+1][c+1] = '1';
+                        } else if (matrix[r][c] == '0' && matrix[r+1][c] == '0' && matrix[r][c+1] == '1' && matrix[r+1][c+1] == '0') { // 0 0 1 0
+                            list.add(r2 +"" ""+ c1 +"" ""+ r1 +"" ""+ c2 +"" ""+ r2 +"" ""+ c2);
+                            matrix[r+1][c] = '1';
+                            matrix[r][c+1] = '0';
+                            matrix[r+1][c+1] = '1';
+                        } else if (matrix[r][c] == '0' && matrix[r+1][c] == '0' && matrix[r][c+1] == '0' && matrix[r+1][c+1] == '1') { // 0 0 0 1
+                            list.add(r1 +"" ""+ c1 +"" ""+ r1 +"" ""+ c2 +"" ""+ r2 +"" ""+ c2);
+                            matrix[r][c] = '1';
+                            matrix[r][c+1] = '1';
+                            matrix[r+1][c+1] = '0';
+                        } else if (matrix[r][c] == '1' && matrix[r+1][c] == '1' && matrix[r][c+1] == '1' && matrix[r+1][c+1] == '1') { // 1 1 1 1
+                            list.add(r2 +"" ""+ c1 +"" ""+ r1 +"" ""+ c2 +"" ""+ r2 +"" ""+ c2);
+                            matrix[r+1][c] = '0';
+                            matrix[r][c+1] = '0';
+                            matrix[r+1][c+1] = '0';
+                        } else if (matrix[r][c] == '1' && matrix[r+1][c] == '0' && matrix[r][c+1] == '0' && matrix[r+1][c+1] == '1') { // 1 0 0 1
+                            list.add(r1 +"" ""+ c1 +"" ""+ r1 +"" ""+ c2 +"" ""+ r2 +"" ""+ c1);
+                            matrix[r][c] = '0';
+                            matrix[r][c+1] = '1';
+                            matrix[r+1][c] = '1';
+                        } else if (matrix[r][c] == '0' && matrix[r+1][c] == '1' && matrix[r][c+1] == '1' && matrix[r+1][c+1] == '0') { // 0 1 1 0
+                            list.add(r1 +"" ""+ c1 +"" ""+ r2 +"" ""+ c1 +"" ""+ r2 +"" ""+ c2);
+                            matrix[r][c] = '1';
+                            matrix[r+1][c] = '0';
+                            matrix[r+1][c+1] = '1';
+                        } else {
+                            System.out.println(""error"");
+                        }
+                        counter++;
+                    }
+                }
+            }
+            System.out.println(counter);
+            for (int i = 0; i < list.size(); i++) {
+                System.out.println(list.get(i));
+            }
+        }
+
+        output.close();
+    }
+}
+","import java.io.*;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.StringTokenizer;
+
+public class C2 {
+    static ArrayList<Integer[]> list;
+
+    public static void main(String[] args) {
+        InputStream inputStream = System.in;
+        OutputStream outputStream = System.out;
+        InputReader in = new InputReader(inputStream);
+        PrintWriter out = new PrintWriter(outputStream);
+        int t = in.nextInt();
+        for (int i = 0; i < t; i++) {
+            list = new ArrayList<>();
+            int n = in.nextInt();
+            int m = in.nextInt();
+            char[][] arr = new char[n][m];
+            for (int j = 0; j < n; j++) {
+                arr[j] = in.next().toCharArray();
+            }
+            for (int j = 0; j < n; j += 2) {
+                for (int k = 0; k < m; k += 2) {
+                    if (j == n - 1) j = n - 2;
+                    if (k == m - 1) k = m - 2;
+                    int cnt = 0;
+                    while (arr[j][k] == '1' || arr[j + 1][k] == '1' || arr[j][k + 1] == '1' || arr[j + 1][k + 1] == '1') {
+//                        System.out.println(arr[j][k] + "" "" + arr[j][k + 1] + ""\n"" + arr[j + 1][k] + "" "" + arr[j + 1][k + 1]);
+
+                        if (checkThree(arr, j, k)) {
+//                            System.out.println(""3:"");
+//                            System.out.println(arr[j][k] + "" "" + arr[j][k + 1] + ""\n"" + arr[j + 1][k] + "" "" + arr[j + 1][k + 1]);
+                            continue;
+                        } else if (checkTwo(arr, j, k)) {
+//                            System.out.println(""2:"");
+//                            System.out.println(arr[j][k] + "" "" + arr[j][k + 1] + ""\n"" + arr[j + 1][k] + "" "" + arr[j + 1][k + 1]);
+                            checkThree(arr, j, k);
+//                            System.out.println(""3:"");
+//                            System.out.println(arr[j][k] + "" "" + arr[j][k + 1] + ""\n"" + arr[j + 1][k] + "" "" + arr[j + 1][k + 1]);
+                            continue;
+                        } else if (checkDiagonal(arr, j, k)) {
+//                            System.out.println(""/2:"");
+//                            System.out.println(arr[j][k] + "" "" + arr[j][k + 1] + ""\n"" + arr[j + 1][k] + "" "" + arr[j + 1][k + 1]);
+                        } else if (checkOne(arr, j, k)) {
+//                            System.out.println(""1:"");
+//                            System.out.println(arr[j][k] + "" "" + arr[j][k + 1] + ""\n"" + arr[j + 1][k] + "" "" + arr[j + 1][k + 1]);
+                        }
+//                        cnt++;
+//                        if (cnt == 10) return;
+//                        System.out.println();
+                    }
+//                    System.out.println(""qwe"");
+//                    System.out.println(""qwe"");
+                }
+            }
+            out.println(list.size());
+            for (Integer[] integers : list) {
+                for (int j = 0; j < integers.length; j++) {
+                    out.print((integers[j] + 1) + "" "");
+                }
+                out.println();
+            }
+        }
+        out.close();
+    }
+
+    public static boolean checkThree(char[][] arr, int i, int j) {
+        if (arr[i][j] == '1' && arr[i][j + 1] == '1' && arr[i + 1][j] == '1') {
+            arr[i][j] = '0';
+            arr[i][j + 1] = '0';
+            arr[i + 1][j] = '0';
+            list.add(new Integer[]{i, j, i, (j + 1), (i + 1), j});
+            return true;
+        } else if (arr[i][j] == '1' && arr[i][j + 1] == '1' && arr[i + 1][j + 1] == '1') {
+            arr[i][j] = '0';
+            arr[i][j + 1] = '0';
+            arr[i + 1][j + 1] = '0';
+            list.add(new Integer[]{i, j, i, (j + 1), (i + 1), j + 1});
+            return true;
+        } else if (arr[i + 1][j] == '1' && arr[i + 1][j + 1] == '1' && arr[i][j] == '1') {
+            arr[i + 1][j] = '0';
+            arr[i + 1][j + 1] = '0';
+            arr[i][j] = '0';
+            list.add(new Integer[]{i + 1, j, i + 1, j + 1, (i), j});
+            return true;
+        } else if (arr[i + 1][j] == '1' && arr[i + 1][j + 1] == '1' && arr[i][j + 1] == '1') {
+            arr[i + 1][j] = '0';
+            arr[i + 1][j + 1] = '0';
+            arr[i][j + 1] = '0';
+            list.add(new Integer[]{i + 1, j, i + 1, j + 1, (i), j + 1});
+            return true;
+        }
+        return false;
+    }
+
+    public static boolean checkDiagonal(char[][] arr, int i, int j) {
+        if (arr[i][j] == '1' && arr[i + 1][j + 1] == '1') {
+            arr[i][j] = '0';
+            arr[i][j + 1] = '1';
+            arr[i + 1][j] = '1';
+            list.add(new Integer[]{i, j, i, j + 1, (i + 1), j});
+            return true;
+        } else if (arr[i + 1][j] == '1' && arr[i][j + 1] == '1') {
+            arr[i + 1][j] = '0';
+            arr[i][j] = '1';
+            arr[i + 1][j + 1] = '1';
+            list.add(new Integer[]{i + 1, j, i, j, (i + 1), j + 1});
+            return true;
+        }
+        return false;
+    }
+
+    public static boolean checkOne(char[][] arr, int i, int j) {
+        if (arr[i][j] == '1') {
+            arr[i][j] = '0';
+            arr[i + 1][j] = '1';
+            arr[i][j + 1] = '1';
+            list.add(new Integer[]{i, j, i + 1, j, (i), j + 1});
+            return true;
+        } else if (arr[i + 1][j] == '1') {
+            arr[i + 1][j] = '0';
+            arr[i][j] = '1';
+            arr[i + 1][j + 1] = '1';
+            list.add(new Integer[]{i + 1, j, i, j, (i + 1), j + 1});
+            return true;
+        } else if (arr[i][j + 1] == '1') {
+            arr[i][j + 1] = '0';
+            arr[i][j] = '1';
+            arr[i + 1][j + 1] = '1';
+            list.add(new Integer[]{i, j + 1, i, j, (i + 1), j + 1});
+            return true;
+        } else if (arr[i + 1][j + 1] == '1') {
+            arr[i + 1][j + 1] = '0';
+            arr[i + 1][j] = '1';
+            arr[i][j + 1] = '1';
+            list.add(new Integer[]{i + 1, j + 1, i + 1, j, (i), j + 1});
+            return true;
+        }
+        return false;
+    }
+
+    public static char changeValue(char c) {
+        return c == '1' ? '0' : '1';
+    }
+
+    public static boolean checkTwo(char[][] arr, int i, int j) {
+        if (arr[i][j] == '1' && arr[i][j + 1] == '1') {
+            arr[i][j] = '0';
+            arr[i + 1][j + 1] = changeValue(arr[i + 1][j + 1]);
+            arr[i + 1][j] = changeValue(arr[i + 1][j]);
+            list.add(new Integer[]{i, j, i + 1, j + 1, (i + 1), j});
+            return true;
+        } else if (arr[i][j] == '1' && arr[i + 1][j] == '1') {
+            arr[i][j] = '0';
+            arr[i + 1][j + 1] = changeValue(arr[i + 1][j + 1]);
+            arr[i][j + 1] = changeValue(arr[i][j + 1]);
+            list.add(new Integer[]{i, j, i + 1, j + 1, (i), j + 1});
+            return true;
+        } else if (arr[i + 1][j] == '1' && arr[i + 1][j + 1] == '1') {
+            arr[i + 1][j] = '0';
+            arr[i][j + 1] = changeValue(arr[i][j + 1]);
+            arr[i][j] = changeValue(arr[i][j]);
+            list.add(new Integer[]{i + 1, j, i, j + 1, (i), j});
+            return true;
+        } else if (arr[i][j + 1] == '1' && arr[i + 1][j + 1] == '1') {
+            arr[i][j + 1] = '0';
+            arr[i][j] = changeValue(arr[i][j]);
+            arr[i + 1][j] = changeValue(arr[i + 1][j]);
+            list.add(new Integer[]{i, j + 1, i, j, (i + 1), j});
+            return true;
+        }
+        return false;
+    }
+
+    static class InputReader {
+        public BufferedReader reader;
+        public StringTokenizer tokenizer;
+
+        public InputReader(InputStream stream) {
+            reader = new BufferedReader(new InputStreamReader(stream), 32768);
+            tokenizer = null;
+        }
+
+        public String next() {
+            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
+                try {
+                    tokenizer = new StringTokenizer(reader.readLine());
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+            }
+            return tokenizer.nextToken();
+        }
+
+        public int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        public long nextLong() {
+            return Long.parseLong(next());
+        }
+    }
+}
+",0
+04a706b1,5b7127bf,"import java.io.*;
+import java.util.*;
+import static java.util.Collections.*;
+import static java.lang.Math.*;
+import java.util.stream.*;
+
+import javax.sound.sampled.Mixer;
+
+import static java.util.Arrays.*;
+
+@SuppressWarnings(""unchecked"")
+public class D_Tree_Tag {
+    public static PrintWriter out;
+    public static InputReader in;
+    public static long MOD = (long)1e9+7;
+    public static int n,a,b,da,db;
+    public static Graph g;
+    public static int dab;
+    public static int mxdist;
+    static class Graph
+    {
+        public int n;
+        public ArrayList adjacency[];
+        public Graph(int nodes)
+        {
+            n = nodes;
+            adjacency = new ArrayList[nodes];
+            for(int i=0;i<nodes;i++)
+            {
+                adjacency[i] = new ArrayList<Integer>();
+            }
+        }
+        @Override
+        public String toString()
+        {
+            String ret = """";
+            for (ArrayList temp : adjacency) {
+                ret+=(temp.toString()+""\n"");
+            }
+            return ret;
+        }
+        public void addEdge(int from, int to)
+        {
+            adjacency[from].add(to);
+            adjacency[to].add(from);
+        }
+    }
+    static class Pair{
+        public int a,b;
+        public Pair(int a, int b){
+            this.a=a; this.b=b;
+        }
+    }
+    public static void dist(){
+        int[] vis = new int[n]; fill(vis,0);
+        LinkedList<Pair> l = new LinkedList<Pair>();
+        l.add(new Pair(a,0));
+        while(!l.isEmpty()){
+            Pair cur = l.pollFirst();
+            int v = cur.a, ct = cur.b;
+            vis[v] = 1;
+            if(v==b) {dab = ct; return;}
+            for(int neigh : (ArrayList<Integer>)g.adjacency[v]){
+                if(vis[neigh]==0) l.add(new Pair(neigh,ct+1));
+            }
+        }
+    }
+    // https://www.geeksforgeeks.org/diameter-tree-using-dfs/#:~:text=We%20start%20DFS%20from%20a,the%20diameter%20of%20the%20tree.
+    // Used to track farthest node. 
+    static int x; 
+    static int maxCount; 
+    static List<Integer> adj[]; 
+      
+    // Sets maxCount as maximum distance  
+    // from node 
+    static void dfsUtil(int node, int count,  
+                         boolean visited[], 
+                       List<Integer> adj[]) 
+    { 
+        visited[node] = true; 
+        count++; 
+          
+        List<Integer> l = adj[node]; 
+        for(Integer i: l) 
+        { 
+            if(!visited[i]){ 
+                if (count >= maxCount) { 
+                    maxCount = count; 
+                    x = i; 
+                } 
+                dfsUtil(i, count, visited, adj); 
+            } 
+        } 
+    } 
+       
+    // The function to do DFS traversal. It uses  
+    // recursive dfsUtil() 
+    static void dfs(int node, int n, List<Integer> 
+                                       adj[]) 
+    { 
+        boolean[] visited = new boolean[n + 1]; 
+        int count = 0; 
+       
+        // Mark all the vertices as not visited 
+        Arrays.fill(visited, false); 
+       
+        // Increment count by 1 for visited node 
+        dfsUtil(node, count + 1, visited, adj); 
+          
+    } 
+       
+    // Returns diameter of binary tree represented 
+    // as adjacency list. 
+    static int diameter(List<Integer> adj[], int n) 
+    { 
+        maxCount = Integer.MIN_VALUE; 
+       
+        /* DFS from a random node and then see 
+        farthest node X from it*/
+        dfs(1, n, adj); 
+       
+        /* DFS from X and check the farthest node 
+        from it */
+        dfs(x, n, adj); 
+       
+        return maxCount; 
+    } 
+    public static int dfs2(int v, int[] vis){
+        ArrayList<Integer> l = new ArrayList<Integer>();
+        vis[v] = 1;
+        int count = 0;
+        for(int neigh : (ArrayList<Integer>)g.adjacency[v]){
+            if(vis[neigh]==0) {count++; l.add(dfs2(neigh,vis));}
+        }
+        if(count==0) return 0;
+        if(count==1) {
+            // out.println(""from i=""+v+"",mxdist=""+l.get(0));
+            mxdist = max(mxdist, 1+l.get(0)); return (1+l.get(0));}
+        sort(l);
+        // out.println(""l=""+l);
+        mxdist = max(mxdist,2+l.get(l.size()-1) + l.get(l.size()-2));
+        
+        return 1+l.get(l.size()-1);
+    }
+    public static void main(String[] args)throws IOException {
+        in = new InputReader(System.in);
+        out = new PrintWriter(System.out);
+        
+        int cases = in.nextInt();
+        
+        for(int t = 0; t < cases; t++){
+            n = in.nextInt();
+            a = in.nextInt()-1;
+            b = in.nextInt()-1;
+            da = in.nextInt();
+            db = in.nextInt();
+            g = new Graph(n);
+            for(int i=0;i<n-1;i++){
+                int u = in.nextInt()-1;
+                int v=  in.nextInt()-1;
+                g.addEdge(u, v);
+            }
+            // dab=-1;
+            dist();
+            mxdist = diameter(g.adjacency, n);
+            mxdist--;
+            if(dab==-1){
+                out.println(""FUCK"");
+            }
+            // mxdist = -1;
+            // int[] vis = new int[n]; fill(vis,0);
+            // mxdist = max(mxdist,dfs2(a,vis));
+            // out.println(""mxdist=""+mxdist);
+            if(dab<=da){
+                out.println(""Alice"");
+            }
+            else{
+                if(da>=db) out.println(""Alice"");
+                else{
+                    if(db>(2*da) && mxdist>(2*da)){
+                        out.println(""Bob"");
+                    }
+                    else out.println(""Alice"");
+                }
+            }
+            // out.println(""dab:""+dab);
+            // out.println(""dist:""+mxdist);
+        }
+
+        out.close();
+    }
+    static class InputReader {
+        public BufferedReader reader;
+        public StringTokenizer tokenizer;
+
+        public InputReader(InputStream stream) {
+            reader = new BufferedReader(new InputStreamReader(stream), 32768);
+            tokenizer = null;
+        }
+
+        public String next() {
+            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
+                try {
+                    tokenizer = new StringTokenizer(reader.readLine());
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+            }
+            return tokenizer.nextToken();
+        }
+
+        public int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        public long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        public int[] nextArrI(int n) {
+            int[] a=new int[n];
+            for(int i=0; i<n; i++) a[i]=nextInt();
+            return a;
+        }
+        
+        public long[] nextArrL(int n) {
+            long[] a=new long[n];
+            for (int i=0; i<n; i++) a[i]=nextLong();
+            return a;
+        }
+    }
+
+}","import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.PrintWriter;
+import java.math.BigInteger;
+import java.util.*;
+
+
+public class Main {
+
+    public static void main(String[] args) {
+
+        InputStream inputStream = System.in;
+        OutputStream outputStream = System.out;
+        InputReader sc = new InputReader(inputStream);
+        PrintWriter out = new PrintWriter(outputStream);
+        Solver solver = new Solver();
+		int t = sc.nextInt();
+//        int t = 1;
+        while (t-- != 0) {
+            solver.solve(sc, out);
+        }
+        out.close();
+
+    }
+
+    static class Solver {
+        ArrayList<Integer>[] gp;
+        int theirdist = 0;
+        int dist = 0;
+        boolean[] vis;
+        int first;
+        int sec;
+        public void solve(InputReader sc, PrintWriter out) {
+            int n = sc.nextInt();
+            int a = sc.nextInt()-1;
+            int b = sc.nextInt()-1;
+            int da = sc.nextInt();
+            int db = sc.nextInt();dist=0;first=0;sec=0;
+            vis = new boolean[n];
+            theirdist = 0;
+            gp = new ArrayList[n];
+            for(int i = 0; i < n; i++) {
+                gp[i] = new ArrayList<>();
+            }
+            for(int i = 0; i < n-1; i++) {
+                int s = sc.nextInt()-1;
+                int d = sc.nextInt()-1;
+                gp[s].add(d);
+                gp[d].add(s);
+            }
+            dfsfirst(0,0);
+            Arrays.fill(vis,false);
+            dist = 0;
+            dfssec(first,0);
+            int dia = dist;
+            Arrays.fill(vis,false);
+            dfstheir(a,b,0);
+            if(theirdist<=da) {
+                out.println(""Alice"");
+                return;
+            }
+            if(da>=(dia+1)/2) {
+                out.println(""Alice"");
+                return;
+            }
+            if(db<(da*2)+1) {
+                out.println(""Alice"");
+                return;
+            }
+            out.println(""Bob"");
+        }
+
+        private void dfstheir(int a, int b, int i) {
+            vis[a] = true;
+            if(a==b) {
+                theirdist = i;
+                //return;
+            }
+            for(int v : gp[a]) {
+                if(!vis[v]) {
+                    dfstheir(v,b,i+1);
+                }
+            }
+        }
+
+        private void dfssec(int first, int i1) {
+            vis[first] = true;
+            for(int v : gp[first]) {
+                if(!vis[v]) {
+                    dfssec(v,i1+1);
+                }
+            }
+            if(i1>=dist) {
+                dist = i1;
+                sec = first;
+            }
+        }
+
+        private void dfsfirst(int i, int i1) {
+            vis[i] = true;
+            for(int v : gp[i]) {
+                if(!vis[v]) {
+                    dfsfirst(v,i1+1);
+                }
+            }
+            if(i1>=dist) {
+                dist = i1;
+                first = i;
+            }
+        }
+    }
+
+    static void sort(int[] arr) {
+        Random rand = new Random();
+        int n = arr.length;
+        for (int i = 0; i < n; i++) {
+            int idx = rand.nextInt(n);
+            if (idx == i) continue;
+            arr[i] ^= arr[idx];
+            arr[idx] ^= arr[i];
+            arr[i] ^= arr[idx];
+        }
+        Arrays.sort(arr);
+    }
+
+    static void sort(long[] arr) {
+        Random rand = new Random();
+        int n = arr.length;
+        for (int i = 0; i < n; i++) {
+            int idx = rand.nextInt(n);
+            if (idx == i) continue;
+            arr[i] ^= arr[idx];
+            arr[idx] ^= arr[i];
+            arr[i] ^= arr[idx];
+        }
+        Arrays.sort(arr);
+    }
+
+    static void sortDec(int[] arr) {
+        Random rand = new Random();
+        int n = arr.length;
+        for (int i = 0; i < n; i++) {
+            int idx = rand.nextInt(n);
+            if (idx == i) continue;
+            arr[i] ^= arr[idx];
+            arr[idx] ^= arr[i];
+            arr[i] ^= arr[idx];
+        }
+        Arrays.sort(arr);
+        int l = 0;
+        int r = n - 1;
+        while (l < r) {
+            int tmp = arr[l];
+            arr[l] = arr[r];
+            arr[r] = tmp;
+            l++;
+            r--;
+        }
+    }
+
+    static void sortDec(long[] arr) {
+        Random rand = new Random();
+        int n = arr.length;
+        for (int i = 0; i < n; i++) {
+            int idx = rand.nextInt(n);
+            if (idx == i) continue;
+            arr[i] ^= arr[idx];
+            arr[idx] ^= arr[i];
+            arr[i] ^= arr[idx];
+        }
+        Arrays.sort(arr);
+        int l = 0;
+        int r = n - 1;
+        while (l < r) {
+            long tmp = arr[l];
+            arr[l] = arr[r];
+            arr[r] = tmp;
+            l++;
+            r--;
+        }
+    }
+
+    static class InputReader {
+        private boolean finished = false;
+
+        private InputStream stream;
+        private byte[] buf = new byte[1024];
+        private int curChar;
+        private int numChars;
+        private SpaceCharFilter filter;
+
+        public InputReader(InputStream stream) {
+            this.stream = stream;
+        }
+
+        public int read() {
+            if (numChars == -1) {
+                throw new InputMismatchException();
+            }
+            if (curChar >= numChars) {
+                curChar = 0;
+                try {
+                    numChars = stream.read(buf);
+                } catch (IOException e) {
+                    throw new InputMismatchException();
+                }
+                if (numChars <= 0) {
+                    return -1;
+                }
+            }
+            return buf[curChar++];
+        }
+
+        public int peek() {
+            if (numChars == -1) {
+                return -1;
+            }
+            if (curChar >= numChars) {
+                curChar = 0;
+                try {
+                    numChars = stream.read(buf);
+                } catch (IOException e) {
+                    return -1;
+                }
+                if (numChars <= 0) {
+                    return -1;
+                }
+            }
+            return buf[curChar];
+        }
+
+        public int nextInt() {
+            int c = read();
+            while (isSpaceChar(c)) {
+                c = read();
+            }
+            int sgn = 1;
+            if (c == '-') {
+                sgn = -1;
+                c = read();
+            }
+            int res = 0;
+            do {
+                if (c < '0' || c > '9') {
+                    throw new InputMismatchException();
+                }
+                res *= 10;
+                res += c - '0';
+                c = read();
+            } while (!isSpaceChar(c));
+            return res * sgn;
+        }
+
+        public long nextLong() {
+            int c = read();
+            while (isSpaceChar(c)) {
+                c = read();
+            }
+            int sgn = 1;
+            if (c == '-') {
+                sgn = -1;
+                c = read();
+            }
+            long res = 0;
+            do {
+                if (c < '0' || c > '9') {
+                    throw new InputMismatchException();
+                }
+                res *= 10;
+                res += c - '0';
+                c = read();
+            } while (!isSpaceChar(c));
+            return res * sgn;
+        }
+
+        public String nextString() {
+            int c = read();
+            while (isSpaceChar(c)) {
+                c = read();
+            }
+            StringBuilder res = new StringBuilder();
+            do {
+                if (Character.isValidCodePoint(c)) {
+                    res.appendCodePoint(c);
+                }
+                c = read();
+            } while (!isSpaceChar(c));
+            return res.toString();
+        }
+
+        public boolean isSpaceChar(int c) {
+            if (filter != null) {
+                return filter.isSpaceChar(c);
+            }
+            return isWhitespace(c);
+        }
+
+        public static boolean isWhitespace(int c) {
+            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
+        }
+
+        private String readLine0() {
+            StringBuilder buf = new StringBuilder();
+            int c = read();
+            while (c != '\n' && c != -1) {
+                if (c != '\r') {
+                    buf.appendCodePoint(c);
+                }
+                c = read();
+            }
+            return buf.toString();
+        }
+
+        public String readLine() {
+            String s = readLine0();
+            while (s.trim().length() == 0) {
+                s = readLine0();
+            }
+            return s;
+        }
+
+        public String readLine(boolean ignoreEmptyLines) {
+            if (ignoreEmptyLines) {
+                return readLine();
+            } else {
+                return readLine0();
+            }
+        }
+
+        public BigInteger readBigInteger() {
+            try {
+                return new BigInteger(nextString());
+            } catch (NumberFormatException e) {
+                throw new InputMismatchException();
+            }
+        }
+
+        public char nextCharacter() {
+            int c = read();
+            while (isSpaceChar(c)) {
+                c = read();
+            }
+            return (char) c;
+        }
+
+        public double nextDouble() {
+            int c = read();
+            while (isSpaceChar(c)) {
+                c = read();
+            }
+            int sgn = 1;
+            if (c == '-') {
+                sgn = -1;
+                c = read();
+            }
+            double res = 0;
+            while (!isSpaceChar(c) && c != '.') {
+                if (c == 'e' || c == 'E') {
+                    return res * Math.pow(10, nextInt());
+                }
+                if (c < '0' || c > '9') {
+                    throw new InputMismatchException();
+                }
+                res *= 10;
+                res += c - '0';
+                c = read();
+            }
+            if (c == '.') {
+                c = read();
+                double m = 1;
+                while (!isSpaceChar(c)) {
+                    if (c == 'e' || c == 'E') {
+                        return res * Math.pow(10, nextInt());
+                    }
+                    if (c < '0' || c > '9') {
+                        throw new InputMismatchException();
+                    }
+                    m /= 10;
+                    res += (c - '0') * m;
+                    c = read();
+                }
+            }
+            return res * sgn;
+        }
+
+        public boolean isExhausted() {
+            int value;
+            while (isSpaceChar(value = peek()) && value != -1) {
+                read();
+            }
+            return value == -1;
+        }
+
+        public String next() {
+            return nextString();
+        }
+
+        public SpaceCharFilter getFilter() {
+            return filter;
+        }
+
+        public void setFilter(SpaceCharFilter filter) {
+            this.filter = filter;
+        }
+
+        public interface SpaceCharFilter {
+            public boolean isSpaceChar(int ch);
+        }
+
+        public int[] nextIntArray(int n) {
+            int[] array = new int[n];
+            for (int i = 0; i < n; ++i) array[i] = nextInt();
+            return array;
+        }
+
+        public int[] nextSortedIntArray(int n) {
+            int array[] = nextIntArray(n);
+            Arrays.sort(array);
+            return array;
+        }
+
+        public int[] nextSumIntArray(int n) {
+            int[] array = new int[n];
+            array[0] = nextInt();
+            for (int i = 1; i < n; ++i) array[i] = array[i - 1] + nextInt();
+            return array;
+        }
+
+        public long[] nextLongArray(int n) {
+            long[] array = new long[n];
+            for (int i = 0; i < n; ++i) array[i] = nextLong();
+            return array;
+        }
+
+        public long[] nextSumLongArray(int n) {
+            long[] array = new long[n];
+            array[0] = nextInt();
+            for (int i = 1; i < n; ++i) array[i] = array[i - 1] + nextInt();
+            return array;
+        }
+
+        public long[] nextSortedLongArray(int n) {
+            long array[] = nextLongArray(n);
+            Arrays.sort(array);
+            return array;
+        }
+    }
+
+
+}
+",0
+141effef,6653a758,"// package codeforces;
+
+import java.util.*;
+
+public class ArmChairs {
+	static int[]arr;
+	static ArrayList<Integer>a;
+	static ArrayList<Integer>b;
+	static int dp[][];
+	public static void main(String[] args) {
+		Scanner scn = new Scanner(System.in);
+		int n = scn.nextInt();
+		arr=new int[n];
+		for(int i=0;i<n;i++) {
+			arr[i]=scn.nextInt();
+		}
+		dp=new int[n+1][n+1];
+		a =new ArrayList<>();
+		b =new ArrayList<>();
+		for(int i=0;i<n;i++) {
+			if(arr[i]==0) {
+				a.add(i);
+			}else{
+				b.add(i);
+			}
+		}
+		System.out.println(solve(0,0));	
+	}
+	
+	public static int solve(int i,int j) {
+		if(i==b.size()) {
+			return 0;
+		}
+		if(j==a.size()) {
+			return 100000000;
+		}
+
+		if(dp[i][j]!=0) {
+			return dp[i][j];
+		}
+		int x=Math.abs(a.get(j)-b.get(i))+solve(i+1,j+1);
+		int y=solve(i,j+1);
+		return dp[i][j]=Math.min(x, y);
+	}
+	
+
+}
+","import java.util.*;
+public class D {
+	public static void main(String[] args) {
+		Scanner sc=new Scanner(System.in);
+		ArrayList<Integer> o=new ArrayList<Integer>(), e=new ArrayList<Integer>();
+		int n = sc.nextInt(),dp[][]=new int[n+1][n+1];
+		for(int i=1;i<=n;i++){
+			int x=sc.nextInt();
+			if(x==1)o.add(i);
+			else e.add(i);
+		}
+		for(int i=1;i<=o.size();i++){
+			dp[i][i]=dp[i-1][i-1]+Math.abs(o.get(i-1)-e.get(i-1));
+			for(int j=i+1;j<=e.size();j++)
+				dp[i][j]=Math.min(dp[i][j-1],dp[i-1][j-1]+Math.abs(o.get(i-1)-e.get(j-1)));
+		}
+		System.out.println(dp[o.size()][e.size()]);
+	}
+}",0
+2a35cd81,464ad4dd,"import java.util.*;
+import java.io.*;
+public class Transform_the_experssion  {
+	static Scanner sc=new Scanner(System.in);
+	static PrintWriter pw=new PrintWriter(System.out);
+	static ArrayList<Integer> []arr;
+	
+	public static void main(String[] args) throws IOException, InterruptedException {
+       int t=sc.nextInt();
+       while(t-->0) {
+           int n=sc.nextInt();
+           String [] strings=new String [n];
+           int [][]arr=new int [5][n];
+           int [] total=new int [5];
+           for(int i=0;i<n;i++)
+        	   strings[i]=sc.next();
+           for(int i=0;i<5;i++) {
+        	   char x=(char)('a'+i);
+        	   for(int j=0;j<n;j++) {
+        		   int sum=0;
+        		   int end=strings[j].length();
+        		   for(int k=0;k<end;k++) {
+        			   if(strings[j].charAt(k)==x) {
+        				   sum++;
+        			   }
+        		   }
+        		   arr[i][j]=sum-(end-sum);
+        		   total[i]+=sum-(end-sum);
+        	   }
+           }
+           boolean f=false;
+           for(int i=0;i<5 && !f;i++) {
+        	   if(total[i]>0) {
+        		   pw.println(n);
+        		   f=true;
+        	   }
+           }
+           //pw.println(Arrays.toString(total));
+           if(!f) {
+        	   int [] MaxS=new int [5];
+        	   for(int i=0;i<5;i++) {
+        			Arrays.sort(arr[i]);
+        			if(arr[i][n-1]<=0)   {
+        				 MaxS[i]=0; 
+        			}
+        			else {
+						int sum=arr[i][n-1],countWords=1;
+						for(int j=n-2;j>-1 && sum+arr[i][j]>0;j--) {
+							sum+=arr[i][j];
+							countWords++;
+						}
+						 MaxS[i]=countWords;
+					}
+        	   }
+        	   int ans=0;
+        	   //pw.println(Arrays.toString(MaxS));
+               for(int i=0;i<5;i++)
+            	   ans=Math.max(ans, MaxS[i]);
+               pw.println(ans);
+           }
+           
+    }
+    
+    
+    pw.flush();
+	}
+	/*public class UnionFind {                                              
+		int[] p, rank, setSize;
+		int numSets;
+
+		public UnionFind(int N) 
+		{
+			p = new int[numSets = N];
+			rank = new int[N];
+			setSize = new int[N];
+			for (int i = 0; i < N; i++) {  p[i] = i; setSize[i] = 1; }
+		}
+
+		public int findSet(int i) { return p[i] == i ? i : (p[i] = findSet(p[i])); }
+
+		public boolean isSameSet(int i, int j) { return findSet(i) == findSet(j); }
+
+		public void unionSet(int i, int j) 
+		{ 
+			if (isSameSet(i, j)) 
+				return;
+			numSets--; 
+			int x = findSet(i), y = findSet(j);
+			if(rank[x] > rank[y]) { p[y] = x; setSize[x] += setSize[y]; }
+			else
+			{	p[x] = y; setSize[y] += setSize[x];
+				if(rank[x] == rank[y]) rank[y]++; 
+			} 
+		}
+
+		public int numDisjointSets() { return numSets; }
+
+		public int sizeOfSet(int i) { return setSize[findSet(i)]; }
+	}
+	static class pair implements Comparai)ble<pair> {
+		long x;
+		long y;
+ 
+		public pair(long x, long y) {
+			this.x = x;
+			this.y = y;
+		}
+ 
+		public String toString() {
+			return x + "" "" + y;
+		}
+ 
+		public boolean equals(Object o) {
+			if (o instanceof pair) {
+				pair p = (pair) o;
+				return p.x == x && p.y == y;
+			}
+			return false;
+		}
+ 
+		public int hashCode() {
+			return new Double(x).hashCode() * 31 + new Double(y).hashCode();
+		}
+ 
+		public int compareTo(pair other) {
+			if (this.x == other.x) {
+				return Long.compare(this.y, other.y);
+			}
+			return Long.compare(this.x, other.x);
+		}
+	}*/
+	static class Scanner {
+		StringTokenizer st;
+		BufferedReader br;
+ 
+		public Scanner(InputStream s) {
+			br = new BufferedReader(new InputStreamReader(s));
+		}
+ 
+		public Scanner(FileReader r) {
+			br = new BufferedReader(r);
+		}
+		public String readAllLines(BufferedReader reader) throws IOException {
+		    StringBuilder content = new StringBuilder();
+		    String line;
+		    
+		    while ((line = reader.readLine()) != null) {
+		        content.append(line);
+		        content.append(System.lineSeparator());
+		    }
+
+		    return content.toString();
+		}
+		public String next() throws IOException {
+			while (st == null || !st.hasMoreTokens())
+				st = new StringTokenizer(br.readLine());
+			return st.nextToken();
+		}
+ 
+		public int nextInt() throws IOException {
+			return Integer.parseInt(next());
+		}
+ 
+		public long nextLong() throws IOException {
+			return Long.parseLong(next());
+		}
+ 
+		public String nextLine() throws IOException {
+			return br.readLine();
+		}
+ 
+		public double nextDouble() throws IOException {
+			String x = next();
+			StringBuilder sb = new StringBuilder(""0"");
+			double res = 0, f = 1;
+			boolean dec = false, neg = false;
+			int start = 0;
+			if (x.charAt(0) == '-') {
+				neg = true;
+				start++;
+			}
+			for (int i = start; i < x.length(); i++)
+				if (x.charAt(i) == '.') {
+					res = Long.parseLong(sb.toString());
+					sb = new StringBuilder(""0"");
+					dec = true;
+				} else {
+					sb.append(x.charAt(i));
+					if (dec)
+						f *= 10;
+				}
+			res += Long.parseLong(sb.toString()) / f;
+			return res * (neg ? -1 : 1);
+		}
+ 
+		public long[] nextlongArray(int n) throws IOException {
+			long[] a = new long[n];
+			for (int i = 0; i < n; i++)
+				a[i] = nextLong();
+			return a;
+		}
+ 
+		public Long[] nextLongArray(int n) throws IOException {
+			Long[] a = new Long[n];
+			for (int i = 0; i < n; i++)
+				a[i] = nextLong();
+			return a;
+		}
+ 
+		public int[] nextIntArray(int n) throws IOException {
+			int[] a = new int[n];
+			for (int i = 0; i < n; i++)
+				a[i] = nextInt();
+			return a;
+		}
+ 
+		public Integer[] nextIntegerArray(int n) throws IOException {
+			Integer[] a = new Integer[n];
+			for (int i = 0; i < n; i++)
+				a[i] = nextInt();
+			return a;
+		}
+ 
+		public boolean ready() throws IOException {
+			return br.ready();
+		}
+ 
+	}
+ 
+}","import java.io.*;
+import java.util.*;
+public class Solution{
+    public static int in = 0, count=0;
+    static class comparator implements Comparator<int[]>{
+        public int compare(int[] arr1 ,int[] arr2){
+            int gain1 =0, gain2=0;
+            for(int i:arr1) gain1+=i;
+            for(int i:arr2) gain2+=i;
+            if((gain1-2*arr1[in])>(gain2-2*arr2[in]))
+                return 1;
+            else if((gain1-2*arr1[in])==(gain2-2*arr2[in])) {
+                count++;
+                return 0;
+            }
+            return -1;
+        }
+    }
+    public static int solve(ArrayList<int[]> al, int[] total){
+        ArrayList<int[]> c = (ArrayList<int[]>) al.clone();
+        java.util.Collections.sort(c, new comparator());
+
+        int i= al.size()-1;
+        int sum=0; for(int ii:total) sum+=ii;
+        int check = total[in];
+        sum-=check;
+        for(; i>=0; i--){
+            if(check>sum) return i+1;
+            else{
+                int newSum=0; for(int ii:c.get(i)) newSum+=ii;
+                newSum-=c.get(i)[in];
+                sum-=newSum;
+                check-=c.get(i)[in];
+            }
+        }
+        return 0;
+    }
+    public static void main (String[] args) throws java.lang.Exception {
+        FastReader sc = new FastReader();
+        BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));
+        int testCase = sc.nextInt();
+        while (testCase-->0){
+            int n = sc.nextInt();
+            String[] strArr = new String[n];
+            for(int i=0; i<n; i++) {
+                strArr[i]=sc.nextLine();
+            }
+            int[] total = new int[5];
+            ArrayList<int[]> al = new ArrayList<>();
+            for(int i=0; i<n; i++){
+                int[] arr= new int[5];
+                for(int j=0; j<strArr[i].length(); j++){
+                    arr[strArr[i].charAt(j)-'a']++;
+                }
+                for(int j=0; j<5; j++){
+                    total[j]+=arr[j];
+                }
+                al.add(arr);
+            }
+            int ans = Integer.MIN_VALUE;
+            for(int i=0; i<5; i++) {
+                in = i;
+                ans = Math.max(solve(al, total), ans);
+                count=0;
+            }
+            System.out.println(ans);
+        }
+    }
+    // Fast Reader Class
+    static class FastReader {
+        BufferedReader br; StringTokenizer st;
+        public FastReader() { br = new BufferedReader(new InputStreamReader(System.in)); }
+        String next() { while (st == null || !st.hasMoreElements()) { try { st = new StringTokenizer(br.readLine()); } catch (IOException e) { e.printStackTrace(); } }return st.nextToken(); }
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+        String nextLine() { String str = """"; try { str = br.readLine(); }  catch (IOException e) { e.printStackTrace(); }return str; }
+    }
+}",0
+0b04b41e,9291ca83,"import java.io.BufferedReader;
+import java.io.*;
+import java.util.*;
+
+public class josph {
+
+static BufferedReader br;
+
+
+static long mod = 1000000000 + 7;
+static HashSet<Integer> p = new HashSet<>();
+static boolean debug =true;
+// Arrays.sort(time , (a1,a2) -> (a1[0]-a2[0])); 2d array sort lamda
+public static void main(String[] args) throws Exception {
+br = new BufferedReader(new InputStreamReader(System.in));
+PrintWriter pr = new PrintWriter(System.out);
+int tc = 1;
+tc= cinI();
+while(tc-->0){
+int n =cinI();
+String[] a= new String[n];
+
+int[][] f =new int[10][n];
+
+for(int i=0;i<n;i++){
+a[i]=cin();
+char[] x = a[i].toCharArray();
+
+for(char c:x){
+int index = c-'a';
+f[index][i]+=1;
+}
+for(int j=0;j<10;j++){
+int rem =x.length-f[j][i];
+f[j][i]-=rem;
+}
+}
+int max=0;
+for(int j=0;j<10;j++){
+Arrays.sort(f[j]);
+int cnt=0;
+int sum=0;
+for(int i=n-1;i>=0;i--){
+sum+=f[j][i];
+if(sum>0){
+cnt+=1;
+}
+else{
+break;
+}
+}
+max=max(max,cnt);
+}
+System.out.println(max);
+}
+
+}
+
+public static <E> void print(String var ,E e){
+if(debug==true){
+System.out.println(var +"" ""+e);
+}
+}
+private static long[] sort(long[] e){
+ArrayList<Long> x=new ArrayList<>();
+for(long c:e){
+x.add(c);
+}
+Collections.sort(x);
+long[] y = new long[e.length];
+for(int i=0;i<x.size();i++){
+y[i]=x.get(i);
+}
+return y;
+}
+public static void printDp(long[][] dp) {
+
+int n = dp.length;
+for (int i = 0; i < n; i++) {
+for (int j = 0; j < dp[0].length; j++) {
+System.out.print(dp[i][j] + "" "");
+}
+System.out.println();
+}
+}
+
+
+
+
+
+
+private static long gcd(long a, long b) {
+if (a == 0)
+return b;
+if (b == 0)
+return a;
+
+// base case
+if (a == b)
+return a;
+
+// a is greater
+if (a > b)
+return gcd(a % b, b);
+return gcd(a, b % a);
+}
+
+
+public static long min(long a, long b) {
+return Math.min(a, b);
+}
+
+public static int min(int a, int b) {
+return Math.min(a, b);
+}
+
+
+public static void sieve() {
+int[] pf = new int[100000000 + 1];
+//0 prime //1 not prime
+pf[0] = 1;
+pf[1] = 1;
+for (int j = 2; j <= 10000; j++) {
+
+if (pf[j] == 0) {
+p.add(j);
+for (int k = j * j; k < pf.length; k += j) {
+pf[k] = 1;
+}
+}
+}
+
+}
+
+
+public static int[] readArray(int n, int x, int z) throws Exception {
+int[] arr = new int[n];
+String[] ar = cinA();
+for (int i = x; i < n + x; i++) {
+arr[i] = getI(ar[i - x]);
+}
+return arr;
+}
+
+public static long[] readArray(int n, int x) throws Exception {
+long[] arr = new long[n];
+String[] ar = cinA();
+for (int i = x; i < n + x; i++) {
+arr[i] = getL(ar[i - x]);
+}
+return arr;
+}
+
+public static void arrinit(String[] a, long[] b) throws Exception {
+for (int i = 0; i < a.length; i++) {
+b[i] = Long.parseLong(a[i]);
+}
+}
+
+public static HashSet<Integer>[] Graph(int n, int edge, int directed) throws Exception {
+HashSet<Integer>[] tree = new HashSet[n];
+
+for (int j = 0; j < edge; j++) {
+
+String[] uv = cinA();
+int u = getI(uv[0]);
+int v = getI(uv[1]);
+if (directed == 0) {
+
+tree[v].add(u);
+}
+tree[u].add(v);
+}
+return tree;
+}
+
+public static void arrinit(String[] a, int[] b) throws Exception {
+for (int i = 0; i < a.length; i++) {
+b[i] = Integer.parseInt(a[i]);
+}
+}
+
+
+static double findRoots(int a, int b, int c) {
+// If a is 0, then equation is not
+//quadratic, but linear
+
+
+int d = b * b - 4 * a * c;
+double sqrt_val = Math.sqrt(Math.abs(d));
+
+
+// System.out.println(""Roots are real and different \n"");
+
+return Math.max((double) (-b + sqrt_val) / (2 * a),
+(double) (-b - sqrt_val) / (2 * a));
+
+
+}
+
+public static String cin() throws Exception {
+return br.readLine();
+}
+
+public static String[] cinA() throws Exception {
+return br.readLine().split("" "");
+}
+
+public static String[] cinA(int x) throws Exception {
+return br.readLine().split("""");
+}
+
+public static String ToString(Long x) {
+return Long.toBinaryString(x);
+}
+
+public static void cout(String s) {
+System.out.println(s);
+}
+
+public static Integer cinI() throws Exception {
+return Integer.parseInt(br.readLine());
+}
+
+public static int getI(String s) throws Exception {
+return Integer.parseInt(s);
+}
+
+public static long getL(String s) throws Exception {
+return Long.parseLong(s);
+}
+
+public static long max(long a, long b) {
+return Math.max(a, b);
+}
+
+public static int max(int a, int b) {
+return Math.max(a, b);
+}
+
+public static void coutI(int x) {
+System.out.println(String.valueOf(x));
+}
+
+public static void coutI(long x) {
+System.out.println(String.valueOf(x));
+}
+
+public static Long cinL() throws Exception {
+return Long.parseLong(br.readLine());
+}
+
+public static void arrInit(String[] arr, int[] arr1) throws Exception {
+for (int i = 0; i < arr.length; i++) {
+arr1[i] = getI(arr[i]);
+}
+
+}
+}","import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.util.*;
+
+public class Practice {
+    static HashMap<String, Integer> map = new HashMap<>();
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        int t = sc.nextInt();
+        while (t-->0) {
+            int n = sc.nextInt();
+            int[][] occurances = new int[5][n];
+            for(int i=0;i<n;i++){
+                String s = sc.next();
+                int[] count = new int[5];
+                int len = s.length();
+                for(int j=0;j<s.length();j++){
+                    count[s.charAt(j)-'a']++;
+                }
+                for(int j=0;j<5;j++){
+                    occurances[j][i] = count[j] - (len-count[j]);
+                }
+            }
+            int ans = 0;
+            for(int i=0;i<5;i++){
+                Arrays.sort(occurances[i]);
+                int tmpAns = 0; int tmpSum=0;
+                for(int j=n-1;j>=0;j--){
+                    tmpSum+=occurances[i][j];
+                    if(tmpSum>0) tmpAns++;
+                    else break;
+                }
+                ans = Math.max(ans, tmpAns);
+            }
+            System.out.println(ans);
+        }
+    }
+}
+
+",1
+9261620f,f0881ab5,"import java.util.*;
+public class Main {
+    public static void main(String args[]) {
+        Scanner sc = new Scanner(System.in);
+        int t = sc.nextInt();
+        while(t-->0){
+            int n  =sc.nextInt();
+            long[] arr = new long[n];
+            for(int i=0;i<n;i++){
+                arr[i] =sc.nextLong();
+            }
+            Map<Long, Long> map = new HashMap<>();
+            List<Long> list = new ArrayList<>();
+            list.add((long)0);
+            for(int i=0;i<n;i++){
+                int s = list.size();
+                for(int j=0;j<s;j++){
+                    list.add(list.get(j)+arr[i]);
+                }
+            }
+            int flag = 0;
+            for(int i=0;i<list.size();i++){
+                map.put(list.get(i), map.getOrDefault(list.get(i), (long)0)+1);
+                if(map.get(list.get(i))>1){
+                    flag = 1;
+                    break;
+                }
+            }
+            if(flag>0)
+                System.out.println(""YES"");
+            else
+                System.out.println(""NO"");
+        }
+    }
+}","    import java.util.*;
+    public class Main {
+        public static void main(String args[]) {
+            Scanner sc = new Scanner(System.in);
+            int t = sc.nextInt();
+            while(t-->0){
+                int n  =sc.nextInt();
+                long[] arr = new long[n];
+                for(int i=0;i<n;i++){
+                    arr[i] =sc.nextLong();
+                }
+                Map<Long, Long> map = new HashMap<>();
+                List<Long> list = new ArrayList<>();
+                list.add((long)0);
+                for(int i=0;i<n;i++){
+                    int s = list.size();
+                    for(int j=0;j<s;j++){
+                        list.add(list.get(j)+arr[i]);
+                    }
+                }
+                int flag = 0;
+                for(int i=0;i<list.size();i++){
+                    map.put(list.get(i), map.getOrDefault(list.get(i), (long)0)+1);
+                    if(map.get(list.get(i))>1){
+                        flag = 1;
+                        break;
+                    }
+                }
+                if(flag>0)
+                    System.out.println(""YES"");
+                else
+                    System.out.println(""NO"");
+            }
+        }
+    }",1
+c4ca2ff3,d83f74f7,"/* package codechef; // don't place package name! */
+
+import java.util.*;
+import java.lang.*;
+import java.io.*;
+
+/* Name of the class has to be ""Main"" only if the class is public. */
+public class Main
+{
+	public static void main (String[] args) throws java.lang.Exception
+	{
+		// your code goes here
+		Scanner sc=new Scanner(System.in);
+		int t=sc.nextInt();
+		PrintWriter out=new PrintWriter(System.out);
+		while(t-->0) {
+		    int n=sc.nextInt();
+		    int freq[][]=new int[n][5];
+		    int rem[][]=new int[n][5];
+		    for(int i=0;i<n;i++) {
+		        String str=sc.next();
+		        
+		        for(int j=0;j<str.length();j++) {
+		            freq[i][str.charAt(j)-'a']++;
+		        }
+		        for(int k=0;k<5;k++) {
+		            rem[i][k]=str.length()-freq[i][k];
+		        }
+		    }
+		    
+		    int ans=0;
+		    for(int i=0;i<5;i++) {
+		        int arr[]=new int[n];
+		        for(int j=0;j<n;j++)
+		        arr[j]=freq[j][i]-rem[j][i];
+		        
+		        Arrays.sort(arr);
+		        int total=0;
+		        int sum=0;
+		        for(int k=n-1;k>=0;k--) {
+		            if(sum+arr[k]>0) {
+		                sum=sum+arr[k];
+		                total++;
+		            }
+		            else {
+		                break;
+		            }
+		        }
+		        ans=Math.max(ans,total);
+		    }
+		    out.println(ans);
+		    
+		}
+		out.flush();
+		out.close();
+	}
+}
+
+","import java.util.*;
+
+import java.io.*;
+import java.math.*;
+
+
+public class A		
+{ 
+			 static FastReader sc=new FastReader(); 
+			 static long dp[][];
+			 static int mod=1000000007;
+			 static int max;
+			 static int bit[];
+			 static long ans;
+			 static HashMap<Integer,Integer> map;
+			
+				
+		     public static void main(String[] args)
+		    {
+		    	//CHECK FOR N=1
+		        	//CHECK FOR N=1
+			  PrintWriter out=new PrintWriter(System.out);
+			  StringBuffer sb=new StringBuffer("""");
+			 
+		  int ttt=1;
+		     ttt =i();
+		   
+		    outer :while (ttt-- > 0) 
+			{	
+		    	int n=i();
+		    	String A[]=inputS(n);
+		    	Pair P[]=new Pair[n];
+		    	int B[][]=new int[n][5];
+		    	for(int i=0;i<n;i++) {
+		    		for(int j=0;j<A[i].length();j++) {
+		    			B[i][A[i].charAt(j)-'a']++;
+		    		}
+		    	}
+		    	int ans=Integer.MAX_VALUE;
+		    	for(int k=0;k<5;k++) {
+		    		int s1=0;
+		    		int s2=0;
+		    	for(int i=0;i<n;i++) {
+		    		int a=B[i][k];
+		    		int b=A[i].length()-a;
+		    		s1+=a;
+		    		s2+=b;
+		    		P[i]=new Pair(a, b);
+		    	}
+		    	Arrays.sort(P);
+		    	int res=go(P,s1,s2);
+		    	ans=min(ans,res);
+		    	
+		    	}
+		    	System.out.println(n-ans);
+		    	
+		    			
+		    	
+		    	
+			}
+		   out.close();
+		  // System.out.println(sb.toString());
+		   
+		   
+		   //CHECK FOR N=1                    //CHECK FOR M=0
+		    //CHECK FOR N=1                    //CHECK FOR M=0
+		   
+    }
+		 static int go(Pair P[],int a,int b) {
+			 int i=0;
+			 int ans=0;
+			 while(a<=b&& i<P.length) {
+				 a-=P[i].x;
+				 b-=P[i].y;
+				 ans++;
+				 i++;
+			 }
+			 return ans;
+		 }
+
+
+static class Pair implements Comparable<Pair>
+     {
+    	 int x;
+    	 int y;
+    	 Pair(int x,int y){
+    		 this.x=x;
+    		 this.y=y;
+    		 
+    	 }
+		@Override
+		public int compareTo(Pair o) {
+			int a=o.y-o.x;
+			int b=this.y-this.x;
+			if(a>b)
+				return 1;
+			else if(a<b)
+				return -1;
+			else {
+				
+					return 0;
+			}
+		}
+		
+		/* FOR TREE MAP PAIR USE */
+		
+//		public int compareTo(Pair o) {
+// 			if (x > o.x) {
+// 				return 1;
+// 			}
+// 			if (x < o.x) {
+// 				return -1;
+// 			}
+// 			if (y > o.y) {
+// 				return 1;
+// 			}
+// 			if (y < o.y) {
+// 				return -1;
+// 			}
+// 			return 0;
+// 		}
+//		public int hashCode() 
+//		{ 
+//			final int temp = 14; 
+//			int ans = 1; 
+//			ans =x*31+y*13; 
+//			return ans; 
+//		} 
+//  
+//		// Equal objects must produce the same 
+//		// hash code as long as they are equal 
+//		@Override
+//		public boolean equals(Object o) 
+//		{ 
+//			if (this == o) { 
+//				return true; 
+//			} 
+//			if (o == null) { 
+//				return false; 
+//			} 
+//			if (this.getClass() != o.getClass()) { 
+//				return false; 
+//			} 
+//			Pair other = (Pair)o; 
+//			if (this.x != other.x || this.y!=other.y) { 
+//				return false; 
+//			} 
+//			return true; 
+//		} 	
+		
+     }
+//FRENWICK TREE
+static void update(int i, int x){
+	for(; i < bit.length; i += (i&-i))
+		bit[i] += x;
+}
+
+static int sum(int i){
+	int ans = 0;
+	for(; i > 0; i -= (i&-i))
+		ans += bit[i];
+	return ans;
+}
+//END
+static void add(int v) {
+	if(!map.containsKey(v)) {
+		map.put(v, 1);
+	}
+	else {
+		map.put(v, map.get(v)+1);
+	}
+}
+static void remove(int v) {
+	if(map.containsKey(v)) {
+		map.put(v, map.get(v)-1);
+		if(map.get(v)==0)
+			map.remove(v);
+	}
+}
+static int[] copy(int A[]) {
+	int B[]=new int[A.length];
+	for(int i=0;i<A.length;i++) {
+		B[i]=A[i];
+	}
+	return B;
+}
+static long[] copy(long A[]) {
+	long B[]=new long[A.length];
+	for(int i=0;i<A.length;i++) {
+		B[i]=A[i];
+	}
+	return B;
+}
+static int[] input(int n) {
+	int A[]=new int[n];
+	   for(int i=0;i<n;i++) {
+		   A[i]=sc.nextInt();
+	   }
+	   return A;
+   }
+static long[] inputL(int n) {
+	long A[]=new long[n];
+	   for(int i=0;i<n;i++) {
+		   A[i]=sc.nextLong();
+	   }
+	   return A;
+   }
+static String[] inputS(int n) {
+	String A[]=new String[n];
+	   for(int i=0;i<n;i++) {
+		   A[i]=sc.next();
+	   }
+	   return A;
+   }
+static long sum(int A[]) {
+	long sum=0;
+	for(int i : A) {
+		sum+=i;
+	}
+	return sum;
+}
+static long sum(long A[]) {
+	long sum=0;
+	for(long i : A) {
+		sum+=i;
+	}
+	return sum;
+}
+static void reverse(long A[]) {
+	int n=A.length;
+	long B[]=new long[n];
+	for(int i=0;i<n;i++) {
+		B[i]=A[n-i-1];
+	}
+	for(int i=0;i<n;i++)
+		A[i]=B[i];
+	
+}
+static void reverse(int A[]) {
+	int n=A.length;
+	int B[]=new int[n];
+	for(int i=0;i<n;i++) {
+		B[i]=A[n-i-1];
+	}
+	for(int i=0;i<n;i++)
+		A[i]=B[i];
+	
+}
+static void input(int A[],int B[]) {
+	   for(int i=0;i<A.length;i++) {
+		   A[i]=sc.nextInt();
+		   B[i]=sc.nextInt();
+	   }
+}
+static int[][] input(int n,int m){
+	int A[][]=new int[n][m];
+	for(int i=0;i<n;i++) {
+		for(int j=0;j<m;j++) {
+			A[i][j]=i();
+		}
+	}
+	return A;
+}
+static char[][] charinput(int n,int m){
+	char A[][]=new char[n][m];
+	for(int i=0;i<n;i++) {
+		String s=s();
+		for(int j=0;j<m;j++) {
+			A[i][j]=s.charAt(j);
+		}
+	}
+	return A;
+}
+static int find(int A[],int a) {
+	  if(A[a]==a)
+		  return a;
+	  return A[a]=find(A, A[a]);
+}
+static int max(int A[]) {
+	int max=Integer.MIN_VALUE;
+	for(int i=0;i<A.length;i++) {
+		max=Math.max(max, A[i]);
+	}
+	return max;
+}
+static int min(int A[]) {
+	int min=Integer.MAX_VALUE;
+	for(int i=0;i<A.length;i++) {
+		min=Math.min(min, A[i]);
+	}
+	return min;
+}
+static long max(long A[]) {
+	long max=Long.MIN_VALUE;
+	for(int i=0;i<A.length;i++) {
+		max=Math.max(max, A[i]);
+	}
+	return max;
+}
+static long min(long A[]) {
+	long min=Long.MAX_VALUE;
+	for(int i=0;i<A.length;i++) {
+		min=Math.min(min, A[i]);
+	}
+	return min;
+}
+static long [] prefix(long A[]) {
+	long p[]=new long[A.length];
+	p[0]=A[0];
+	for(int i=1;i<A.length;i++)
+		p[i]=p[i-1]+A[i];
+	return p;
+}
+static long [] prefix(int A[]) {
+	long p[]=new long[A.length];
+	p[0]=A[0];
+	for(int i=1;i<A.length;i++)
+		p[i]=p[i-1]+A[i];
+	return p;
+}
+static long [] suffix(long A[]) {
+	long p[]=new long[A.length];
+	p[A.length-1]=A[A.length-1];
+	for(int i=A.length-2;i>=0;i--)
+		p[i]=p[i+1]+A[i];
+	return p;
+}
+static long [] suffix(int A[]) {
+	long p[]=new long[A.length];
+	p[A.length-1]=A[A.length-1];
+	for(int i=A.length-2;i>=0;i--)
+		p[i]=p[i+1]+A[i];
+	return p;
+}
+static void fill(int dp[]) {
+	Arrays.fill(dp, -1);
+}
+static void fill(int dp[][]) {
+	for(int i=0;i<dp.length;i++)
+	Arrays.fill(dp[i], -1);
+}
+static void fill(int dp[][][]) {
+	for(int i=0;i<dp.length;i++) {
+		for(int j=0;j<dp[0].length;j++) {
+			Arrays.fill(dp[i][j],-1);
+		}
+	}
+}
+static void fill(int dp[][][][]) {
+	for(int i=0;i<dp.length;i++) {
+		for(int j=0;j<dp[0].length;j++) {
+			for(int k=0;k<dp[0][0].length;k++) {
+			Arrays.fill(dp[i][j][k],-1);
+			}
+		}
+	}
+}
+static void fill(long dp[]) {
+	Arrays.fill(dp, -1);
+}
+static void fill(long dp[][]) {
+	for(int i=0;i<dp.length;i++)
+	Arrays.fill(dp[i], -1);
+}
+static void fill(long dp[][][]) {
+	for(int i=0;i<dp.length;i++) {
+		for(int j=0;j<dp[0].length;j++) {
+			Arrays.fill(dp[i][j],-1);
+		}
+	}
+}
+static void fill(long dp[][][][]) {
+	for(int i=0;i<dp.length;i++) {
+		for(int j=0;j<dp[0].length;j++) {
+			for(int k=0;k<dp[0][0].length;k++) {
+			Arrays.fill(dp[i][j][k],-1);
+			}
+		}
+	}
+}
+static int min(int a,int b) {
+	return Math.min(a, b);
+}
+static int min(int a,int b,int c) {
+	return Math.min(a, Math.min(b, c));
+}
+static int min(int a,int b,int c,int d) {
+	return Math.min(a, Math.min(b, Math.min(c, d)));
+}
+static int max(int a,int b) {
+	return Math.max(a, b);
+}
+static int max(int a,int b,int c) {
+	return Math.max(a, Math.max(b, c));
+}
+static int max(int a,int b,int c,int d) {
+	return Math.max(a, Math.max(b, Math.max(c, d)));
+}
+static long min(long a,long b) {
+	return Math.min(a, b);
+}
+static long min(long a,long b,long c) {
+	return Math.min(a, Math.min(b, c));
+}
+static long min(long a,long b,long c,long d) {
+	return Math.min(a, Math.min(b, Math.min(c, d)));
+}
+static long max(long a,long b) {
+	return Math.max(a, b);
+}
+static long max(long a,long b,long c) {
+	return Math.max(a, Math.max(b, c));
+}
+static long max(long a,long b,long c,long d) {
+	return Math.max(a, Math.max(b, Math.max(c, d)));
+}
+
+static long power(long x, long y, long p)
+{
+
+	if(y==0)
+		return 1;
+	if(x==0)
+		return 0;
+    long res = 1;
+    x = x % p;
+
+    while (y > 0) {
+
+        if (y % 2 == 1)
+            res = (res * x) % p;
+
+        y = y >> 1; 
+        x = (x * x) % p;
+    }
+
+    return res;
+}
+static void print(int A[]) {
+	for(int i : A) {
+		System.out.print(i+"" "");
+	}
+	System.out.println();
+}
+static void print(long A[]) {
+	for(long i : A) {
+		System.out.print(i+"" "");
+	}
+	System.out.println();
+}
+static long mod(long x) {
+	  return ((x%mod + mod)%mod);
+}
+static String reverse(String s) {
+	StringBuffer p=new StringBuffer(s);
+	p.reverse();
+	return p.toString();
+}
+
+     static int i() {
+    	 return sc.nextInt();
+     }
+     static String s() {
+    	 return sc.next();
+     }
+     static long l() {
+    	 return sc.nextLong();
+     }  
+     static void sort(int[] A){
+        int n = A.length;
+        Random rnd = new Random();
+        for(int i=0; i<n; ++i){
+            int tmp = A[i];
+            int randomPos = i + rnd.nextInt(n-i);
+            A[i] = A[randomPos];
+            A[randomPos] = tmp;
+        }
+        Arrays.sort(A);
+     }
+     static void sort(long[] A){
+	        int n = A.length;
+	        Random rnd = new Random();
+	        for(int i=0; i<n; ++i){
+	            long tmp = A[i];
+	            int randomPos = i + rnd.nextInt(n-i);
+	            A[i] = A[randomPos];
+	            A[randomPos] = tmp;
+	        }
+	        Arrays.sort(A);
+	     }
+  static String sort(String s) {
+ 	 Character ch[]=new Character[s.length()];
+ 	 for(int i=0;i<s.length();i++) {
+ 		 ch[i]=s.charAt(i);
+ 	 }
+ 	 Arrays.sort(ch);
+ 	 StringBuffer st=new StringBuffer("""");
+ 	 for(int i=0;i<s.length();i++) {
+ 		 st.append(ch[i]);
+ 	 }
+ 	 return st.toString();
+  }
+  static HashMap<Integer,Integer> hash(int A[]){
+	  HashMap<Integer,Integer> map=new HashMap<Integer, Integer>();
+	  for(int i : A) {
+		  if(map.containsKey(i)) {
+			  map.put(i, map.get(i)+1);
+		  }
+		  else {
+			  map.put(i, 1);
+		  }
+	  }
+	  return map;
+  }
+  static TreeMap<Integer,Integer> tree(int A[]){
+	  TreeMap<Integer,Integer> map=new TreeMap<Integer, Integer>();
+	  for(int i : A) {
+		  if(map.containsKey(i)) {
+			  map.put(i, map.get(i)+1);
+		  }
+		  else {
+			  map.put(i, 1);
+		  }
+	  }
+	  return map;
+  }
+     static boolean prime(int n) 
+	    { 
+	        if (n <= 1) 
+	            return false; 
+	        if (n <= 3) 
+	            return true; 
+	        if (n % 2 == 0 || n % 3 == 0) 
+	            return false; 
+	        double sq=Math.sqrt(n);
+	  
+	        for (int i = 5; i <= sq; i = i + 6) 
+	            if (n % i == 0 || n % (i + 2) == 0) 
+	                return false; 
+	        return true; 
+	    } 
+     static boolean prime(long n) 
+	    { 
+	        if (n <= 1) 
+	            return false; 
+	        if (n <= 3) 
+	            return true; 
+	        if (n % 2 == 0 || n % 3 == 0) 
+	            return false; 
+	        double sq=Math.sqrt(n);
+	  
+	        for (int i = 5; i <= sq; i = i + 6) 
+	            if (n % i == 0 || n % (i + 2) == 0) 
+	                return false; 
+	        return true; 
+	    } 
+     static int gcd(int a, int b) 
+     { 
+         if (a == 0) 
+             return b; 
+         return gcd(b % a, a); 
+     } 
+     static long gcd(long a, long b) 
+     { 
+         if (a == 0) 
+             return b; 
+         return gcd(b % a, a); 
+     } 
+     
+        
+    static class FastReader 
+    { 
+        BufferedReader br; 
+        StringTokenizer st; 
+  
+        public FastReader() 
+        { 
+            br = new BufferedReader(new
+                     InputStreamReader(System.in)); 
+        } 
+  
+        String next() 
+        { 
+            while (st == null || !st.hasMoreElements()) 
+            { 
+                try
+                { 
+                    st = new StringTokenizer(br.readLine()); 
+                } 
+                catch (IOException  e) 
+                { 
+                    e.printStackTrace(); 
+                } 
+            } 
+            return st.nextToken(); 
+        } 
+  
+        int nextInt() 
+        { 
+            return Integer.parseInt(next()); 
+        } 
+  
+        long nextLong() 
+        { 
+            return Long.parseLong(next()); 
+        } 
+  
+        double nextDouble() 
+        { 
+            return Double.parseDouble(next()); 
+        } 
+  
+        String nextLine() 
+        { 
+            String str = """"; 
+            try
+            { 
+                str = br.readLine(); 
+            } 
+            catch (IOException e) 
+            { 
+                e.printStackTrace(); 
+            } 
+            return str; 
+        } 
+    } 
+} 
+",0
+29cf2e70,72d9eb5b,"import java.util.*;
+import java.io.*;
+ 
+public class D {
+    public static void main(String[] args) {
+        Scanner in = new Scanner(System.in);
+        
+        int T = in.nextInt();
+        while(T-- > 0) {
+            int n = in.nextInt();
+            int[] a = new int[n];
+            for(int j=0;j<n;j++) a[j] = in.nextInt();
+            char[] s = in.next().toCharArray();
+ 
+            List<Integer> blue = new ArrayList<>();
+            List<Integer> red = new ArrayList<>();
+            for(int j=0;j<n;j++) {
+                if(s[j] == 'B') blue.add(a[j]);
+                else red.add(a[j]);
+            }
+ 
+            Collections.sort(blue);
+            Collections.sort(red);
+ 
+            boolean p = true;
+            int cur = 1;
+            for(int val : blue) {
+                if(val<cur) {
+                    p = false;
+                    break;
+                }
+                else cur++;
+            }
+            for(int val : red) {
+                if(val>cur) {
+                    p = false;
+                    break;
+                }
+                else cur++;
+            }
+            
+            if(p) System.out.println(""yes"");
+            else System.out.println(""no"");
+        }
+    }
+}
+","import java.util.*;
+import java.io.*;
+
+public class D {
+    public static void main(String[] args) {
+        Scanner in = new Scanner(System.in);
+        
+        int T = in.nextInt();
+        while(T-- > 0) {
+            int n = in.nextInt();
+            int[] a = new int[n];
+            for(int j=0;j<n;j++) a[j] = in.nextInt();
+            char[] s = in.next().toCharArray();
+
+            List<Integer> blue = new ArrayList<>();
+            List<Integer> red = new ArrayList<>();
+            for(int j=0;j<n;j++) {
+                if(s[j] == 'B') blue.add(a[j]);
+                else red.add(a[j]);
+            }
+
+            Collections.sort(blue);
+            Collections.sort(red);
+
+            boolean p = true;
+            int cur = 1;
+            for(int val : blue) {
+                if(val<cur) {
+                    p = false;
+                    break;
+                }
+                else cur++;
+            }
+            for(int val : red) {
+                if(val>cur) {
+                    p = false;
+                    break;
+                }
+                else cur++;
+            }
+            
+            if(p) System.out.println(""yes"");
+            else System.out.println(""no"");
+        }
+    }
+}
+",1
+12c1cc56,c06c758d,"import java.io.*;
+import java.util.*;
+
+public class Codeforces
+{
+    public static void main(String args[])throws Exception
+    {
+        BufferedReader bu=new BufferedReader(new InputStreamReader(System.in));
+        StringBuilder sb=new StringBuilder();
+        int n=Integer.parseInt(bu.readLine());
+        String s[]=bu.readLine().split("" "");
+        ArrayList<Integer> z=new ArrayList<>(),o=new ArrayList<>();
+        long dp[][]=new long[n+1][n+1];
+        int i,j,a;
+        for(i=0;i<n;i++)
+        {
+            a=Integer.parseInt(s[i]);
+            if(a==0) z.add(i);
+            else o.add(i);
+        }
+
+        for(i=1;i<=o.size();i++)
+        {
+            long min=dp[i-1][i-1];
+            for(j=i;j<=z.size();j++)
+            {
+                dp[i][j]=min+Math.abs(z.get(j-1)-o.get(i-1));
+                min=Math.min(min,dp[i-1][j]);
+            }
+        }
+        long ans=Long.MAX_VALUE;
+        for(i=o.size();i<=z.size();i++)
+        ans=Math.min(ans,dp[o.size()][i]);
+        System.out.print(ans);
+    }
+}","import java.io.*;
+import java.util.*;
+
+public class Codeforces
+{
+    public static void main(String args[])throws Exception
+    {
+        BufferedReader bu=new BufferedReader(new InputStreamReader(System.in));
+        StringBuilder sb=new StringBuilder();
+        int n=Integer.parseInt(bu.readLine());
+        String s[]=bu.readLine().split("" "");
+        ArrayList<Integer> z=new ArrayList<>(),o=new ArrayList<>();
+        long dp[][]=new long[n+1][n+1];
+        int i,j,a;
+        for(i=0;i<n;i++)
+        {
+            a=Integer.parseInt(s[i]);
+            if(a==0) z.add(i);
+            else o.add(i);
+        }
+
+        for(i=1;i<=o.size();i++)
+        {
+            long min=dp[i-1][i-1];
+            for(j=i;j<=z.size();j++)
+            {
+                dp[i][j]=min+Math.abs(z.get(j-1)-o.get(i-1));
+                min=Math.min(min,dp[i-1][j]);
+            }
+        }
+        long ans=Long.MAX_VALUE;
+        for(i=o.size();i<=z.size();i++)
+        ans=Math.min(ans,dp[o.size()][i]);
+        System.out.print(ans);
+    }
+}",1
+d9199dfd,fb312dc6,"import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Scanner;
+
+public class Simple{  
+    public static void main(String args[]){  
+        //System.out.println(""Hello Java"");
+        Scanner s = new Scanner(System.in);
+        int t = s.nextInt();
+        while (t>0){
+            
+            int n = s.nextInt();
+            int arr[] = new int[n];
+
+            for(int i=0;i<n;i++){
+                arr[i] = s.nextInt();
+            }
+            String str = s.next();
+
+            //Arrays.sort(arr);
+            ArrayList<Integer> blue = new ArrayList<>();
+            ArrayList<Integer> red = new ArrayList<>();
+            for(int i=0;i<n;i++){
+                if(str.charAt(i)=='R'){
+                    red.add(arr[i]);
+                }
+                else{
+                    blue.add(arr[i]);
+                }
+            }
+            Collections.sort(red);
+            Collections.sort(blue);
+            
+            int start =1;
+
+            boolean bool =true;
+            for(int i=0;i<blue.size();i++){
+                if(blue.get(i)<start){
+                    bool = false;
+                    break;
+                }
+
+                start++;
+            }
+            if(!bool){
+                System.out.println(""NO"");
+            }
+            else{
+                for(int i=0;i<red.size();i++){
+                    if(red.get(i)>start){
+                        bool = false;
+                        break;
+                    }
+                    start++;
+                }
+                if(bool){
+                    System.out.println(""YES"");
+                }
+                else{
+                    System.out.println(""NO"");
+                }
+            }
+            
+            
+
+
+            t--;
+        }
+        s.close();  
+    }
+    
+}  
+","import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.StringTokenizer;
+
+public class D {
+    static class Pair{
+        int val;
+        char c;
+        Pair(int a,char b){
+            this.val=a;
+            this.c=b;
+        }
+    }
+    public static void main(String[] args)
+    {
+        FastScanner sc=new FastScanner();
+        int t=sc.nextInt();
+        PrintWriter pw=new PrintWriter(System.out);
+        while(t-->0) {
+            int n=sc.nextInt();
+            int[] a=sc.readArray(n);
+            char[] s=sc.next().toCharArray();
+            boolean ok=true;
+            ArrayList<Integer> blues=new ArrayList<>();
+            ArrayList<Integer> reds=new ArrayList<>();
+            for(int i=0;i<n;i++){
+                if(s[i]=='B'){
+                    blues.add(a[i]);
+                } else {
+                    reds.add(a[i]);
+                }
+            }
+            Collections.sort(blues);
+            Collections.sort(reds);
+            for(int i=0;i<blues.size();i++){
+                if(blues.get(i)<(i+1)){
+                    ok=false;
+                    break;
+                }
+            }
+            int start=blues.size()+1;
+            for(int i=0;i<reds.size();i++){
+                if(reds.get(i)>(start++)){
+                    ok=false;
+                    break;
+                }
+            }
+            if(ok){
+               pw.println(""YES"");
+            } else {
+                pw.println(""NO"");
+            }
+        }
+        pw.flush();
+    }
+
+    static class FastScanner {
+        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st=new StringTokenizer("""");
+        String next() {
+            while (!st.hasMoreTokens())
+                try {
+                    st=new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+        int[] readArray(int n) {
+            int[] a=new int[n];
+            for (int i=0; i<n; i++) a[i]=nextInt();
+            return a;
+        }
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+    }
+}
+",1
+584b0e9e,c9159d9c,"
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.math.BigInteger;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.BitSet;
+import java.util.Calendar;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.PriorityQueue;
+import java.util.SortedSet;
+import java.util.Stack;
+import java.util.StringTokenizer;
+import java.util.TreeMap;
+import java.util.TreeSet;
+
+public class D_Round_753_Div3 {
+    public static int MOD = 1000000007;
+
+    static int[][] dp;
+
+
+    public static void main(String[] args) throws FileNotFoundException {
+        // PrintWriter out = new PrintWriter(new FileOutputStream(new File(
+        // ""output.txt"")));
+        PrintWriter out = new PrintWriter(System.out);
+        Scanner in = new Scanner();
+        int T = in.nextInt();
+        for (int z = 0; z < T; z++) {
+            int n = in.nextInt();
+            int[] data = new int[n];
+            for (int i = 0; i < n; i++) {
+                data[i] = in.nextInt();
+            }
+            String line = in.next();
+            ArrayList<Integer> blue = new ArrayList<>();
+            ArrayList<Integer> red = new ArrayList<>();
+            for (int i = 0; i < n; i++) {
+                if (line.charAt(i) == 'B') {
+                    blue.add(data[i]);
+                } else {
+                    red.add(data[i]);
+                }
+            }
+            Collections.sort(blue);
+            Collections.sort(red);
+            int st = 1;
+            boolean ok = true;
+            for (int i : blue) {
+                if (i < st) {
+                    ok = false;
+                    break;
+                }
+                st++;
+            }
+            if (ok) {
+                for (int i : red) {
+                    if (i > st) {
+                        ok = false;
+                        break;
+                    }
+                    st++;
+                }
+            }
+            out.println(ok ? ""Yes"" : ""No"");
+        }
+        out.close();
+    }
+
+    static int find(int v, int[] u) {
+        if (v == u[v]) {
+            return v;
+        }
+        return u[v] = find(u[v], u);
+    }
+
+
+    static int abs(int a) {
+        return a < 0 ? -a : a;
+    }
+
+
+    public static int[] KMP(String val) {
+        int i = 0;
+        int j = -1;
+        int[] result = new int[val.length() + 1];
+        result[0] = -1;
+        while (i < val.length()) {
+            while (j >= 0 && val.charAt(j) != val.charAt(i)) {
+                j = result[j];
+            }
+            j++;
+            i++;
+            result[i] = j;
+        }
+        return result;
+
+    }
+
+    public static boolean nextPer(int[] data) {
+        int i = data.length - 1;
+        while (i > 0 && data[i] < data[i - 1]) {
+            i--;
+        }
+        if (i == 0) {
+            return false;
+        }
+        int j = data.length - 1;
+        while (data[j] < data[i - 1]) {
+            j--;
+        }
+        int temp = data[i - 1];
+        data[i - 1] = data[j];
+        data[j] = temp;
+        Arrays.sort(data, i, data.length);
+        return true;
+    }
+
+    public static int digit(long n) {
+        int result = 0;
+        while (n > 0) {
+            n /= 10;
+            result++;
+        }
+        return result;
+    }
+
+    public static double dist(long a, long b, long x, long y) {
+        double val = (b - a) * (b - a) + (x - y) * (x - y);
+        val = Math.sqrt(val);
+        double other = x * x + a * a;
+        other = Math.sqrt(other);
+        return val + other;
+
+    }
+
+    public static class Point {
+
+        int x;
+        int y;
+
+        public Point(int start, int end) {
+            this.x = start;
+            this.y = end;
+        }
+
+        public String toString() {
+            return x + "" "" + y;
+        }
+
+    }
+
+    public static class FT {
+
+        long[] data;
+
+        FT(int n) {
+            data = new long[n];
+        }
+
+        public void update(int index, long value) {
+            while (index < data.length) {
+                data[index] += value;
+                data[index] %= MOD;
+                index += (index & (-index));
+            }
+        }
+
+        public long get(int index) {
+
+            long result = 0;
+            while (index > 0) {
+                result += data[index];
+                result %= MOD;
+                index -= (index & (-index));
+            }
+            return result;
+
+        }
+    }
+
+    public static long gcd(long a, long b) {
+        if (b == 0) {
+            return a;
+        }
+        return gcd(b, a % b);
+    }
+
+    public static long pow(long a, int b) {
+        if (b == 0) {
+            return 1;
+        }
+        if (b == 1) {
+            return a;
+        }
+
+        long val = pow(a, b / 2);
+        if (b % 2 == 0) {
+            return (val * val);
+        } else {
+            return (val * ((val * a)));
+
+        }
+    }
+
+    static class Scanner {
+
+        BufferedReader br;
+        StringTokenizer st;
+
+        public Scanner() throws FileNotFoundException {
+            // System.setOut(new PrintStream(new BufferedOutputStream(System.out), true));
+            br = new BufferedReader(new InputStreamReader(System.in));
+            //br = new BufferedReader(new InputStreamReader(new FileInputStream(new File(""input.txt""))));
+        }
+
+        public String next() {
+
+            while (st == null || !st.hasMoreTokens()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (Exception e) {
+                    throw new RuntimeException();
+                }
+            }
+            return st.nextToken();
+        }
+
+        public long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        public int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        public double nextDouble() {
+            return Double.parseDouble(next());
+        }
+
+        public String nextLine() {
+            st = null;
+            try {
+                return br.readLine();
+            } catch (Exception e) {
+                throw new RuntimeException();
+            }
+        }
+
+        public boolean endLine() {
+            try {
+                String next = br.readLine();
+                while (next != null && next.trim().isEmpty()) {
+                    next = br.readLine();
+                }
+                if (next == null) {
+                    return true;
+                }
+                st = new StringTokenizer(next);
+                return st.hasMoreTokens();
+            } catch (Exception e) {
+                throw new RuntimeException();
+            }
+        }
+    }
+}","import java.util.*;
+
+public class SolutionB {
+
+    public static long gcd(long a, long b){
+        if(b==0){
+            return a;
+        }
+        return gcd(b, a%b);
+    }
+
+    public static long gcdSum(long b){
+        long a = 0;
+
+        long temp = b;
+        while(temp!=0){
+            a = a + temp%10;
+            temp = temp/10;
+        }
+        return gcd(a,b);
+
+    }
+
+    public static class Pair{
+        Long a;
+        Long b;
+
+        public Pair(Long a, Long b) {
+            this.a = a;
+            this.b = b;
+        }
+    }
+
+    public static long factorial (long n){
+        if(n==0)
+            return 1;
+        else if(n==1)
+            return n;
+
+        return n * factorial(n-1);
+    }
+
+    public static long lcm (long n){
+        if(n<3)
+            return n;
+        return lcmForBig(n,n-1);
+    }
+
+    private static long lcmForBig(long n, long l) {
+        if(l==1)
+            return n;
+        n = (n * l) / gcd(n, l);
+        return lcmForBig(n, l-1);
+
+    }
+
+
+    public static void main(String[] args){
+        Scanner s = new Scanner(System.in);
+        
+        int t = s.nextInt();
+
+        for(int i =0;i<t;i++) {
+            int n = s.nextInt();
+            int arr [] = new int[n];
+            ArrayList<Integer> blue = new ArrayList<>();
+            ArrayList<Integer> red = new ArrayList<>();
+
+            for(int j=0;j<n;j++){
+                int num = s.nextInt();
+                arr[j]=num;
+            }
+            String color = s.next();
+
+            for(int j=0;j<n;j++){
+                if(color.charAt(j)=='B'){
+                    blue.add(arr[j]);
+                }
+                else{
+                    red.add(arr[j]);
+                }
+            }
+            Collections.sort(blue);
+            String ans = ""YES"";
+            int counter = 0;
+
+            for(int j=0;j<blue.size();j++){
+                int current = blue.get(j);
+                if (current<1){
+                    ans=""NO"";
+                    break;
+                }
+                if(current>counter){
+                    counter++;
+                }
+                else{
+                    ans=""NO"";
+                    break;
+                }
+
+            }
+
+            if(ans==""NO""){
+                System.out.println(ans);
+            }
+            else{
+                int tempCounter = n+1;
+                Collections.sort(red);
+                for(int j=red.size()-1;j>=0;j--){
+                    int  current  = red.get(j);
+                    if(current>=tempCounter){
+                        ans=""NO"";
+                        break;
+                    }
+                    else{
+                        tempCounter--;
+                    }
+                }
+                if(tempCounter-counter!=1)
+                    System.out.println(""NO"");
+                else
+                    System.out.println(ans);
+            }
+
+        }
+
+        return;
+    }
+}
+",0
+2bda1866,e4ab72e5,"import java.io.*;
+import java.util.*;
+
+public class Main {
+	static class Scanner {
+		Scanner(InputStream in) { this.in = in; } InputStream in;
+		byte[] bb = new byte[1 << 15]; int i, n;
+		byte getc() {
+			if (i == n) {
+				i = n = 0;
+				try { n = in.read(bb); } catch (IOException e) {}
+			}
+			return i < n ? bb[i++] : 0;
+		}
+		int nextInt() {
+			byte c = 0; while (c <= ' ') c = getc();
+			int a = 0; while (c > ' ') { a = a * 10 + c - '0'; c = getc(); }
+			return a;
+		}
+	}
+	
+	public static void main(String[] args) throws Exception {
+		BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
+		BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));		
+		
+		int T = Integer.parseInt(in.readLine());
+		
+		for (int ts=1; ts<=T; ts++) {
+			int N = Integer.parseInt(in.readLine());
+			String A = in.readLine();
+			String B = in.readLine();
+			
+			int ans = -1;
+			
+			//even number of ops
+			int fromZero = 0;
+			int fromOne = 0;
+			for (int i=0; i<N; i++) {
+				if (A.charAt(i) != B.charAt(i)) {
+					if (A.charAt(i) == '0') {
+						fromZero++;
+					} else {
+						fromOne++;
+					}
+				}
+			}
+			if (fromZero == fromOne) {
+				ans = fromZero + fromOne;
+			}
+			
+			
+			//odd number of ops
+			int zero = 0;
+			int one = 0;
+			for (int i=0; i<N; i++) {
+				if (A.charAt(i) == B.charAt(i)) {
+					if (A.charAt(i) == '0') {
+						zero++;
+					} else {
+						one++;
+					}
+				}
+			}
+			
+			if (one == zero + 1) {
+				int current = one + zero;
+				if (ans == -1)
+					ans = current;
+				else
+					ans = Math.min(ans, current);
+			}
+			
+			out.write(ans + ""\n"");
+		}
+		
+		in.close();
+		out.close();
+	}
+
+}
+","import java.io.*;
+import java.util.*;
+
+public class q3 {
+    public static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+//    public static long mod = 1000000007;
+
+
+    public static void solve() throws Exception {
+        String[] parts = br.readLine().split("" "");
+        int n = Integer.parseInt(parts[0]);
+
+        StringBuilder a = new StringBuilder(br.readLine());
+        StringBuilder b = new StringBuilder(br.readLine());
+
+        boolean flag = true;
+        for(int i = 0;i < n;i++) if(a.charAt(i) != b.charAt(i)) flag = false;
+        if(flag){
+            System.out.println(0);
+            return;
+        }
+
+        if(n == 1){
+            System.out.println(-1);
+            return;
+        }
+
+        int aco = 0,bco = 0;
+        for(int i = 0;i < a.length();i++) {
+            if(a.charAt(i) == '1') aco++;
+            if(b.charAt(i) == '1') bco++;
+        }
+
+        if(aco == 0 || bco == 0){
+            System.out.println(-1);
+            return;
+        }
+
+        if(aco == bco || n - aco + 1 == bco){
+
+        }else{
+            System.out.println(-1);
+            return;
+        }
+
+        int ez = 0,eo = 0,nez = 0,neo = 0;
+        for(int i = 0;i < n;i++){
+            if(a.charAt(i) == b.charAt(i)){
+                if(a.charAt(i) == '1') eo++;
+                else ez++;
+            }else{
+                if(a.charAt(i) == '1') neo++;
+                else nez++;
+            }
+        }
+
+        HashSet<String> vis = new HashSet<>();
+        Queue<String> que = new LinkedList<>();
+
+        vis.add(ez + "" "" + eo + "" "" + nez + "" "" + neo);
+        que.add(ez + "" "" + eo + "" "" + nez + "" "" + neo);
+
+        int level = 0;
+        while(que.size() > 0){
+            for(int s = que.size() - 1;s >= 0;s--) {
+                String[] rem = que.remove().split("" "");
+                int v1 = Integer.parseInt(rem[0]);
+                int v2 = Integer.parseInt(rem[1]);
+                int v3 = Integer.parseInt(rem[2]);
+                int v4 = Integer.parseInt(rem[3]);
+
+                if (v3 == 0 && v4 == 0) {
+                    System.out.println(level);
+                    return;
+                }
+
+                String first = (v4) + "" "" + (v3 + 1) + "" "" + (v2 - 1) + "" "" + (v1);
+                if (vis.add(first)) que.add(first);
+
+                String second = (v4 - 1) + "" "" + (v3) + "" "" + (v2) + "" "" + (v1 + 1);
+                if (vis.add(second)) que.add(second);
+            }
+            level++;
+        }
+
+        System.out.println(-1);
+    }
+
+    public static void main(String[] args) throws Exception {
+        int tests = Integer.parseInt(br.readLine());
+        for (int test = 1; test <= tests; test++) {
+            solve();
+        }
+    }
+
+//    public static ArrayList<Integer> primes;
+//    public static void seive(int n){
+//        primes = new ArrayList<>();
+//        boolean[] arr = new boolean[n + 1];
+//        Arrays.fill(arr,true);
+//
+//        for(int i = 2;i * i <= n;i++){
+//            if(arr[i]) {
+//                for (int j = i * i; j <= n; j += i) {
+//                    arr[j] = false;
+//                }
+//            }
+//        }
+//        for(int i = 2;i <= n;i++) if(arr[i]) primes.add(i);
+//    }
+
+
+//    public static void sort(int[] arr){
+//        ArrayList<Integer> temp = new ArrayList<>();
+//        for(int val : arr) temp.add(val);
+//
+//        Collections.sort(temp);
+//
+//        for(int i = 0;i < arr.length;i++) arr[i] = temp.get(i);
+//    }
+
+//    public static void sort(long[] arr){
+//        ArrayList<Long> temp = new ArrayList<>();
+//        for(long val : arr) temp.add(val);
+//
+//        Collections.sort(temp);
+//
+//        for(int i = 0;i < arr.length;i++) arr[i] = temp.get(i);
+//    }
+//
+//    public static long power(long a,long b,long mod){
+//        if(b == 0) return 1;
+//
+//        long p = power(a,b / 2,mod);
+//        p = (p * p) % mod;
+//
+//        if(b % 2 == 1) return (p * a) % mod;
+//        return p;
+//    }
+//    public static long modDivide(long a,long b,long mod){
+//        return ((a % mod) * (power(b,mod - 2,mod) % mod)) % mod;
+//    }
+//
+//    public static int GCD(int a,int b){
+//        return b == 0 ? a : GCD(b,a % b);
+//    }
+//    public static long GCD(long a,long b){
+//        return b == 0 ? a : GCD(b,a % b);
+//    }
+//
+//    public static int LCM(int a,int b){
+//        return a * b / GCD(a,b);
+//    }
+//    public static long LCM(long a,long b){
+//        return a * b / GCD(a,b);
+//    }
+}
+",0
+585af783,f7a0ea6d,"import java.util.*;
+import java.io.*;
+public class codeforces {
+
+    public static void main(String []args){
+        FastScanner sc = new FastScanner();
+        int t = sc.nextInt();
+        while(t-->0)   {
+            int n = sc.nextInt();
+            String s[] = new String[n];
+            for(int i=0;i<n;i++)
+                s[i] = sc.next();
+            int a[][] = new int[n][6];
+            for(int i=0;i<n;i++)
+                for(int j=0;j<s[i].length();j++){
+                    a[i][s[i].charAt(j)-'a']++;
+                }
+            for(int i=0;i<n;i++)
+                a[i][5] = s[i].length();
+            int ans=0;
+           for(int i=0;i<5;i++)
+           {
+             ans = Math.max(ans,help(a,i,n));
+           }
+           System.out.println(ans);
+        }
+    }
+    public static int help(int a[][],int i,int n){
+        int total=0,count=0,count1=0;
+        PriorityQueue<Integer> pq = new PriorityQueue<>();
+
+        for(int j=0;j<n;j++)
+        {
+            if(2*a[j][i]-a[j][5]>0)
+            {
+                total+=(2*a[j][i]-a[j][5]);
+                count++;
+            }
+            else if(2*a[j][i]-a[j][5]==0)
+                count1++;
+            else
+                pq.add(a[j][5]-2*a[j][i]);
+        }
+        if(count>0)
+        {
+            count+=count1;
+            int value=0;
+            while(!pq.isEmpty()&&value<total){
+                value+=pq.peek();
+                pq.remove();
+                count++;
+            }
+            if(value>=total)
+                count--;
+        }
+        return count;
+    }
+    public static class Pair{
+        public  int x;
+        public  int y;
+        public Pair(int x,int y){
+            this.x=x;
+            this.y=y;
+        }
+    }
+    public static class FastScanner {
+        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st=new StringTokenizer("""");
+        String next() {
+            while (!st.hasMoreTokens())
+                try {
+                    st=new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+        int[] readArray(int n) {
+            int[] a=new int[n];
+            for (int i=0; i<n; i++) a[i]=nextInt();
+            return a;
+        }
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+    }
+}
+","import java.util.*;
+
+public class Solution {
+	
+	private static Scanner in = new Scanner(System.in);
+	
+	public static void main(String args[]) {
+		
+		int t = in.nextInt();
+		
+		while(t-->0) {
+			solution();
+		}
+	}
+	
+	private static void solution() {
+		
+		int ans=0;
+		int n = in.nextInt();
+		String s[] = new String[n];
+		int occurance[][] = new int[n][5];
+		for(int i=0;i<n;i++) {
+			s[i] = in.next();
+			for(int j=0;j<s[i].length();j++) {
+				occurance[i][s[i].charAt(j)-'a']++;
+			}
+		}
+		
+//		for(int i=0;i<n;i++)
+//		{
+//			for(int j=0;j<5;j++)
+//				System.out.println(occurance[i][j]);
+//			System.out.println();
+//		}
+		
+		for(int i=0;i<5;i++) {
+			int arr[] = new int[n];
+			for(int j=0;j<n;j++) {
+				arr[j] = s[j].length() - (2 * occurance[j][i]);
+			}
+			Arrays.sort(arr);
+			
+//			for(int j=0;j<n;j++)
+//				System.out.println(arr[j]);
+			
+			int temp=0;
+			int count=0;
+			for(int j=0;j<n;j++) {
+				if(temp+arr[j] < 0)
+				{
+					count++;
+					temp += arr[j];
+				}
+				else 
+					break;
+			}
+			ans = Math.max(ans, count);
+		}
+		System.out.println(ans);
+	}
+}",0
+b8b08542,d783d815,"import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.util.Collections;
+import java.util.PriorityQueue;
+import java.util.Scanner;
+import java.util.StringJoiner;
+import java.util.StringTokenizer;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.HashSet;
+
+import static java.lang.System.out;
+import static java.util.stream.Collectors.joining;
+
+public class C {
+  static FastScanner sc = new FastScanner(System.in);
+
+  public static void main(String[] args) {
+    try (PrintWriter out = new PrintWriter(System.out)) {
+      int T = sc.nextInt();
+      for (int tt = 1; tt <= T; tt++) {
+        int n = sc.nextInt();
+        String[] strings = new String[n];
+        PriorityQueue<Pair>[] frequencies = new PriorityQueue[5];
+        for (int i = 0; i < 5; i++)
+          frequencies[i] = new PriorityQueue<>();
+        for (int i = 0; i < n; i++) {
+          strings[i] = sc.next();
+          int[] freq = new int[5];
+          for (char c : strings[i].toCharArray())
+            freq[c - 'a']++;
+          for (int j = 0; j < 5; j++) {
+            frequencies[j].add(new Pair(freq[j], strings[i].length()));
+          }
+        }
+        int ans = 0;
+        for (PriorityQueue<Pair> pq : frequencies) {
+          long curlen = 0;
+          long curfreq = 0;
+          int cnt = 0;
+          while (!pq.isEmpty()) {
+            Pair pair = pq.remove();
+            curfreq += pair.freq;
+            curlen += pair.len;
+            if (curfreq >= curlen / 2 + 1) {
+              cnt++;
+            } else {
+              break;
+            }
+          }
+          ans = Math.max(ans, cnt);
+        }
+        System.out.println(ans);
+      }
+    }
+
+  }
+
+  static class Pair implements Comparable<Pair> {
+    int freq, len;
+
+    public Pair(int freq, int len) {
+      this.freq = freq;
+      this.len = len;
+    }
+
+    @Override
+    public int compareTo(Pair o) {
+      return -(o.len - 2 * o.freq - len + 2 * freq);
+    }
+
+    @Override
+    public String toString() {
+      return freq + "" "" + len;
+    }
+  }
+  /*
+1  
+5
+cbdca
+d
+a
+d
+eb
+   */
+
+  static class FastScanner {
+    BufferedReader br;
+    StringTokenizer st;
+
+    public FastScanner(File f) {
+      try {
+        br = new BufferedReader(new FileReader(f));
+      } catch (FileNotFoundException e) {
+        e.printStackTrace();
+      }
+    }
+
+    public FastScanner(InputStream f) {
+      br = new BufferedReader(new InputStreamReader(f), 32768);
+    }
+
+    String next() {
+      while (st == null || !st.hasMoreTokens()) {
+        String s = null;
+        try {
+          s = br.readLine();
+        } catch (IOException e) {
+          e.printStackTrace();
+        }
+        if (s == null)
+          return null;
+        st = new StringTokenizer(s);
+      }
+      return st.nextToken();
+    }
+
+    boolean hasMoreTokens() {
+      while (st == null || !st.hasMoreTokens()) {
+        String s = null;
+        try {
+          s = br.readLine();
+        } catch (IOException e) {
+          e.printStackTrace();
+        }
+        if (s == null)
+          return false;
+        st = new StringTokenizer(s);
+      }
+      return true;
+    }
+
+    int nextInt() {
+      return Integer.parseInt(next());
+    }
+
+    long nextLong() {
+      return Long.parseLong(next());
+    }
+
+    double nextDouble() {
+      return Double.parseDouble(next());
+    }
+  }
+}
+","//package codeforce.div3.r734;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.util.Collections;
+import java.util.PriorityQueue;
+import java.util.Scanner;
+import java.util.StringJoiner;
+import java.util.StringTokenizer;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.HashSet;
+
+import static java.lang.System.out;
+import static java.util.stream.Collectors.joining;
+
+
+public class C {
+  static FastScanner sc = new FastScanner(System.in);
+
+  public static void main(String[] args) {
+    try (PrintWriter out = new PrintWriter(System.out)) {
+      int T = sc.nextInt();
+      for (int tt = 1; tt <= T; tt++) {
+        int n = sc.nextInt();
+        String[] strings = new String[n];
+        PriorityQueue<Pair>[] frequencies = new PriorityQueue[5];
+        for (int i = 0; i < 5; i++)
+          frequencies[i] = new PriorityQueue<>();
+        for (int i = 0; i < n; i++) {
+          strings[i] = sc.next();
+          int[] freq = new int[5];
+          for (char c : strings[i].toCharArray())
+            freq[c - 'a']++;
+          for (int j = 0; j < 5; j++) {
+            //if (freq[j] > 0)
+            frequencies[j].add(new Pair(freq[j], strings[i].length()));
+          }
+        }
+      /*  for (int i = 0; i < 5; i++) {
+          while (!frequencies[i].isEmpty())
+            System.out.print(frequencies[i].remove() + "", "");
+          System.out.println();
+        }*/
+
+        int ans = 0;
+        for (PriorityQueue<Pair> pq : frequencies) {
+          long curlen = 0;
+          long curfreq = 0;
+          int cnt = 0;
+          while (!pq.isEmpty()) {
+            Pair pair = pq.remove();
+            curfreq += pair.freq;
+            curlen += pair.len;
+            if (curfreq >= curlen / 2 + 1) {
+              cnt++;
+            } else {
+              break;
+            }
+          }
+          ans = Math.max(ans, cnt);
+        }
+        System.out.println(ans);
+      }
+    }
+
+  }
+
+  static class Pair implements Comparable<Pair> {
+    int freq, len;
+
+    public Pair(int freq, int len) {
+      this.freq = freq;
+      this.len = len;
+    }
+
+    @Override
+    public int compareTo(Pair o) {
+      /*if(freq == 0 && o.freq == 0)
+        return len - o.len;
+      if(freq == 0) 
+        return len - (o.len - o.freq);
+      if(o.freq == 0)
+        return o.len - (len - freq);
+      int diff1 = freq * o.len;
+      int diff2 = o.freq * len;
+      return diff2 - diff1;*/
+      return -(o.len - 2*o.freq  - len + 2*freq);
+    }
+
+    @Override
+    public String toString() {
+      return freq + "" "" + len;
+    }
+  }
+  /*
+1  
+5
+cbdca
+d
+a
+d
+eb
+   */
+
+  static class FastScanner {
+    BufferedReader br;
+    StringTokenizer st;
+
+    public FastScanner(File f) {
+      try {
+        br = new BufferedReader(new FileReader(f));
+      } catch (FileNotFoundException e) {
+        e.printStackTrace();
+      }
+    }
+
+    public FastScanner(InputStream f) {
+      br = new BufferedReader(new InputStreamReader(f), 32768);
+    }
+
+    String next() {
+      while (st == null || !st.hasMoreTokens()) {
+        String s = null;
+        try {
+          s = br.readLine();
+        } catch (IOException e) {
+          e.printStackTrace();
+        }
+        if (s == null)
+          return null;
+        st = new StringTokenizer(s);
+      }
+      return st.nextToken();
+    }
+
+    boolean hasMoreTokens() {
+      while (st == null || !st.hasMoreTokens()) {
+        String s = null;
+        try {
+          s = br.readLine();
+        } catch (IOException e) {
+          e.printStackTrace();
+        }
+        if (s == null)
+          return false;
+        st = new StringTokenizer(s);
+      }
+      return true;
+    }
+
+    int nextInt() {
+      return Integer.parseInt(next());
+    }
+
+    long nextLong() {
+      return Long.parseLong(next());
+    }
+
+    double nextDouble() {
+      return Double.parseDouble(next());
+    }
+  }
+}
+",1
+e1c4f3db,e81b2d16,"import java.util.*;
+
+public class BalancedStoneHeaps {
+
+    public static boolean check(int n, int x, int[] h) {
+        int[] c_h = new int[n];
+        for (int i = 0; i < n; i++)
+            c_h[i] = h[i];
+        for (int i = n - 1; i >= 2; i--) {
+            if (c_h[i] < x)
+                return false;
+            int d = Math.min(h[i], c_h[i] - x) / 3;
+            c_h[i - 1] += d;
+            c_h[i - 2] += 2 * d;
+        }
+        return c_h[0] >= x && c_h[1] >= x;
+    }
+
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        int t = sc.nextInt();
+        while (t-- > 0) {
+            int n = sc.nextInt();
+            int[] h = new int[n];
+            int max = Integer.MIN_VALUE;
+            for (int i = 0; i < n; i++) {
+                h[i] = sc.nextInt();
+                if (h[i] > max) {
+                    max = h[i];
+                }
+            }
+            int l = 0;
+            int r = max;
+            while (l < r) {
+                int mid = l + (r - l + 1) / 2;
+                if (check(n, mid, h)) {
+                    l = mid;
+                } else {
+                    r = mid - 1;
+                }
+            }
+            System.out.println(l);
+        }
+    }
+}","import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.*;
+
+public class fastTemp {
+    static class FastReader {
+        BufferedReader br;
+        StringTokenizer st;
+
+        public FastReader()
+        {
+            br = new BufferedReader(
+                    new InputStreamReader(System.in));
+        }
+
+        String next()
+        {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                }
+                catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt() { return Integer.parseInt(next()); }
+
+        long nextLong() { return Long.parseLong(next()); }
+
+        double nextDouble()
+        {
+            return Double.parseDouble(next());
+        }
+
+        String nextLine()
+        {
+            String str = """";
+            try {
+                str = br.readLine();
+            }
+            catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+        }
+    }
+
+    static int n;
+    static int arr[];
+    public static void main(String[] args)
+    {
+        FastReader fs = new FastReader();
+        int t = fs.nextInt();
+        while(t-- >0){
+               n = fs.nextInt();
+               arr = new int[n];
+              int max = Integer.MIN_VALUE;
+              for(int i=0;i<n;i++){
+                arr[i] = fs.nextInt();
+                  if(max<arr[i]){
+                      max =arr[i];
+                  }
+              }
+              int l=1;
+              int r = max;
+              int ans = 0;
+              while(l<r){
+                  int mid = l + (r-l+1)/2;
+                  if(check(mid)){
+                  l = mid;
+                  }else{
+                      r = mid-1;
+                  }
+              }
+            System.out.println(l);
+        }
+
+    }
+static int min = Integer.MAX_VALUE;
+    public static boolean check(int x){
+
+        int ar[] = new int[n];
+        for(int i=0;i<n;i++){
+            ar[i] = arr[i];
+        }
+
+       // Collections.copy(curr,arr);
+
+        for(int i=n-1;i>=2;i--){
+           if(ar[i]<x){
+               return false;
+           }
+           int d = (Math.min(arr[i],ar[i]-x))/3;
+          ar[i-1] += d;
+          ar[i-2] += 2*d;
+        }
+
+        return ar[0]>=x && ar[1]>=x;
+    }
+
+
+}",1
+11c2ab99,fadc1365,"import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.StringTokenizer;
+
+public class Main {
+
+	public static void main(String[] args) {
+		FastScanner fs=new FastScanner();
+		int T=fs.nextInt();
+		PrintWriter out=new PrintWriter(System.out);
+		for (int tt=0; tt<T; tt++) {
+			int n=fs.nextInt(), k=fs.nextInt();
+			int[] positions=fs.readArray(k), temps=fs.readArray(k);
+			int[] forced=new int[n];
+			Arrays.fill(forced, Integer.MAX_VALUE/2);
+			for (int i=0; i<k; i++) forced[positions[i]-1]=temps[i];
+			for (int i=1; i<n; i++)
+				forced[i]=Math.min(forced[i], forced[i-1]+1);
+			for (int i=n-2; i>=0; i--)
+				forced[i]=Math.min(forced[i], forced[i+1]+1);
+			for (int i=0; i<n; i++) out.print(forced[i]+"" "");
+			out.println();
+			
+		}
+		out.close();
+	}
+
+	static void sort(int[] a) {
+		ArrayList<Integer> l=new ArrayList<>();
+		for (int i:a) l.add(i);
+		Collections.sort(l);
+		for (int i=0; i<a.length; i++) a[i]=l.get(i);
+	}
+	
+	static class FastScanner {
+		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st=new StringTokenizer("""");
+		String next() {
+			while (!st.hasMoreTokens())
+				try {
+					st=new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			return st.nextToken();
+		}
+		
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+		int[] readArray(int n) {
+			int[] a=new int[n];
+			for (int i=0; i<n; i++) a[i]=nextInt();
+			return a;
+		}
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+	}
+
+	
+}
+
+","import java.io.PrintWriter;
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.*;
+public class a{ 
+    public static void main(String args[]) throws java.lang.Exception{ 
+    	FastScanner s=new FastScanner();
+		PrintWriter out=new PrintWriter(System.out);
+		int t=s.nextInt();
+		for(int tt=0;tt<t;tt++) {
+			int n=s.nextInt(),k=s.nextInt();
+			int pos[]=s.readArray(k);
+			int temp[]=s.readArray(k);
+			long ans[]=new long[n];
+			Arrays.fill(ans,Integer.MAX_VALUE);
+			for(int i=0;i<k;i++){
+				ans[pos[i]-1]=temp[i];
+			}
+			for(int i=1;i<n;i++){
+				ans[i]=Math.min(ans[i-1]+1,ans[i]);
+			}
+			for(int i=n-2;i>=0;i--){
+				ans[i]=Math.min(ans[i],ans[i+1]+1);
+			}
+			for(int i=0;i<n;i++){
+				out.print(ans[i]+"" "");
+			}
+			out.println();
+		}
+		out.close();
+    }
+	static boolean isPrime(int n){
+        if (n <= 1)
+            return false;
+        else if (n == 2)
+            return true;
+        else if (n % 2 == 0)
+            return false;
+        for (int i = 3; i <= Math.sqrt(n); i += 2){
+            if (n % i == 0)
+                return false;
+        }
+        return true;
+    }
+    static void sort(long [] a) {
+		ArrayList<Long> l=new ArrayList<>();
+		for (long i:a) l.add(i);
+		Collections.sort(l);
+		for (int i=0; i<a.length; i++) a[i]=l.get(i);
+	}
+	static void sort(char [] a) {
+		ArrayList<Character> l=new ArrayList<>();
+		for (char i:a) l.add(i);
+		Collections.sort(l);
+		for (int i=0; i<a.length; i++) a[i]=l.get(i);
+	}
+    static void sort(int [] a) {
+		ArrayList<Integer> l=new ArrayList<>();
+		for (int i:a) l.add(i);
+		Collections.sort(l);
+		for (int i=0; i<a.length; i++) a[i]=l.get(i);
+	}
+    static int gcd(int a, int b){
+      if (b == 0)
+        return a;
+      return gcd(b, a % b);
+    }
+    static void sortcol(int a[][],int c) {
+		Arrays.sort(a, (x, y) -> {
+			if(x[c]>y[c]) {
+				return 1;
+			}else {
+				return -1;
+			}
+		});
+	}
+    public static void printb(boolean ans) {
+    	if(ans) {
+    		System.out.println(""Yes"");
+    	}else {
+    		System.out.println(""No"");
+    	}
+    }
+    static class FastScanner {
+		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st=new StringTokenizer("""");
+		String next() {
+			while (!st.hasMoreTokens())
+				try {
+					st=new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			return st.nextToken();
+		}
+		double nextDouble() {
+			return Double.parseDouble(next());
+		}
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+		int[] readArray(int n) {
+			int[] a=new int[n];
+			for (int i=0; i<n; i++) a[i]=nextInt();
+			return a;
+		}
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+	}
+    static class Pair implements Comparable<Pair>{
+    	int a , b; 
+    	Pair(int x , int y){
+    		a=x;
+    		b=y;
+    	}
+    	public int compareTo(Pair o) {
+    		return a != o.a ? a - o.a : b - o.b;
+    	}
+    }
+}
+",1
+5af25bd7,fa1bf524,"import java.io.*;
+import java.util.*;
+ 
+public class MySolution {
+    public static void main(String[] args) throws Exception {
+        BufferedReader bu = new BufferedReader(new InputStreamReader(System.in));
+        StringBuilder out = new StringBuilder();
+        int numOfTestCases = Integer.parseInt(bu.readLine());
+        for (int tc = 1; tc <= numOfTestCases; tc++) {
+            int vertices = Integer.parseInt(bu.readLine());
+            connections = new ArrayList[vertices];
+            for (int i = 0; i < vertices; i++) {
+                connections[i] = new ArrayList<Integer>();
+                String st[] = bu.readLine().split("" "");
+                a[i][0] = Integer.parseInt(st[0]);
+                a[i][1] = Integer.parseInt(st[1]);
+                s[i][0] = s[i][1] = 0;
+            }
+            for (int j = 0; j < vertices-1; j++) {
+                String st[] = bu.readLine().split("" "");
+                int u = Integer.parseInt(st[0]) - 1, v = Integer.parseInt(st[1]) - 1;
+                connections[u].add(v);
+                connections[v].add(u);
+            }
+            dfs(0, -1);
+            out.append(Math.max(s[0][0], s[0][1]) + ""\n"");
+        }
+        System.out.print(out);
+    }
+ 
+    static int N = 100000;
+    static int[][] a = new int[N][2];
+    static long[][] s = new long[N][2];
+    static ArrayList<Integer>[] connections;
+ 
+    public static void dfs(int n, int parent) {
+        for (int child : connections[n]) {
+            if (child != parent) {
+                dfs(child, n);
+                s[n][0] += Math.max(s[child][0] + Math.abs(a[n][0] - a[child][0]), s[child][1] + Math.abs(a[n][0] - a[child][1]));
+                s[n][1] += Math.max(s[child][0] + Math.abs(a[n][1] - a[child][0]), s[child][1] + Math.abs(a[n][1] - a[child][1]));
+            }
+        }
+    }
+}
+","import java.util.*;
+import java.io.*;
+
+public class Solution {
+
+    static LinkedList<Integer> graph[];
+    static long key[][];
+    static long value[][];
+
+    public static void main(String[] args) throws IOException {
+
+        Scanner in = new Scanner(System.in);
+        StringBuffer out=new StringBuffer();
+        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+
+        int t=Integer.parseInt(br.readLine());
+        String input[];
+
+        OUTER:
+        while(t--!=0) {
+
+            int n=Integer.parseInt(br.readLine());
+
+            value=new long[n][2];
+            key=new long[n][2];
+
+            for(int i=0; i<n; i++) {
+                input= br.readLine().split(""\\s"");
+                for(int j=0; j<2; j++) {
+                    key[i][j] = Integer.parseInt(input[j]);
+                }
+            }
+
+            graph=new LinkedList[n];
+            for(int i=0; i<n; i++)
+                graph[i]=new LinkedList();
+
+            for(int i=1; i<n; i++) {
+                input= br.readLine().split(""\\s"");
+                int u=Integer.parseInt(input[0])-1, v=Integer.parseInt(input[1])-1;
+                graph[u].add(v);
+                graph[v].add(u);
+            }
+
+            int root=-1;
+            for(int i=0; i<n; i++)
+                if(graph[i].size()==1) {
+                    root=i;
+                    break;
+                }
+
+            solve(root, -1);
+
+            out.append(Math.max(value[root][0], value[root][1])+""\n"");
+        }
+
+        System.out.print(out);
+    }
+
+    private static void solve(int vertex, int parent) {
+
+        for(int child: graph[vertex]) {
+            if(child!=parent) {
+                solve(child, vertex);
+                for(int i=0; i<2; i++) {
+                    long max=Long.MIN_VALUE;
+                    for(int j=0; j<2; j++) {
+                        max=Math.max(max, Math.abs(key[vertex][i]-key[child][j])+value[child][j]);
+                    }
+                    value[vertex][i]+=max;
+                }
+            }
+        }
+
+//        System.out.println(vertex+"" ""+Arrays.toString(key[vertex])+"" ""+Arrays.toString(value[vertex]));
+    }
+}",0
+cdb801a1,dcdaf666,"//package codeforces;	
+import java.io.*;
+import java.util.*;
+public class Solution {
+	static class FastReader {
+		BufferedReader br;
+		StringTokenizer st;
+
+		public FastReader() {
+			br = new BufferedReader(new InputStreamReader(System.in));
+		}
+
+		String next() {
+			while (st == null || !st.hasMoreElements()) {
+				try {
+					st = new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			}
+			return st.nextToken();
+		}
+
+		int ni() {
+			return Integer.parseInt(next());
+		}
+
+		long nl() {
+			return Long.parseLong(next());
+		}
+
+		double nd() {
+			return Double.parseDouble(next());
+		}
+
+		String nextLine() {
+			String str = """";
+			try {
+				str = br.readLine();
+			} catch (IOException e) {
+				e.printStackTrace();
+			}
+			return str;
+		}
+	}
+
+	
+	public static void main(String[] args) throws java.lang.Exception {
+		FastReader fr = new FastReader();
+		PrintWriter out = new PrintWriter(System.out);
+		int t = fr.ni();
+		while(t-->0) {
+			
+			int n = fr.ni();
+			long arr [] = new long[n];
+			for(int i = 0 ; i < n ; i++) arr[i]= fr.nl();
+			long even = arr[0];
+			long odd = arr[1];
+			long minEven = arr[0];
+			long minOdd = arr[1];
+			long ans = (minEven*n) + (minOdd*n);
+			for(int i = 2 ; i < n ; i++) {
+				if((i&1) == 0) {
+					even += arr[i];
+					minEven = Math.min(minEven, arr[i]);
+					long a = (i+2)/2;
+					long b = (i+1)-a;
+					long temp = (even + (minEven*(n - a)));
+					temp += (odd + (minOdd*(n - b)));
+					ans = Math.min(ans, temp);
+				}else {
+					odd += arr[i];
+					minOdd = Math.min(minOdd, arr[i]);
+					long a = (i+2)/2;
+					long b = (i+1)-a;
+					long temp = (even + (minEven*(n - a)));
+					temp += (odd + (minOdd*(n - b)));
+					ans = Math.min(ans, temp);
+					
+				}
+			}
+			out.println(ans);
+		}
+		out.close();
+	}
+}","import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.PrintStream;
+import java.util.StringTokenizer;
+
+public class Solution {
+
+    //
+
+    public static void main(String[] args) {
+        PrintStream out = System.out;
+        FastScanner fs = new FastScanner();
+
+        int T = fs.nextInt();
+
+
+        while (T-- > 0) {
+
+            int n = fs.nextInt();
+            long[] arr = new long[n];
+
+            for (int i = 0; i < n; i++) {
+                arr[i] = fs.nextLong();
+            }
+            long[] ps = new long[n];
+            ps[0] = arr[0];
+            for (int i = 1; i < n; i++) {
+                ps[i] = ps[i - 1] + arr[i];
+            }
+
+            long min = arr[0] * n + arr[1] * n;
+
+            int even = 0;
+            int odd = 1;
+
+            for (int i = 2; i < n; i++) {
+
+                if (i % 2 == 0) {
+                    if (arr[i] < arr[even]) {
+                        even = i;
+                    }
+                } else {
+                    if (arr[i] < arr[odd]) {
+                        odd = i;
+                    }
+                }
+
+                int tmp = i + 1;
+                int oddCount = tmp / 2;
+                int evenCount = (tmp + 1) / 2;
+
+
+                long local = ps[i];
+                local += (n - oddCount) * arr[odd];
+                local += (n - evenCount) * arr[even];
+
+                min = Math.min(min, local);
+            }
+            out.println(min);
+        }
+    }
+
+    // if these strings are both balanced then as one or zero goes out of the window one or zero must come in
+    //
+
+    static class FastScanner {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st = new StringTokenizer("""");
+
+        public String next() {
+            while (!st.hasMoreElements())
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            return st.nextToken();
+        }
+
+        int[] readArray(int n) {
+            int[] a = new int[n];
+            for (int i = 0; i < n; i++) a[i] = nextInt();
+            return a;
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+    }
+
+
+}
+",0
+4303de0d,c9a316ca,"import java.io.*;
+import java.util.*;
+public class ParsasHumongousTree
+{
+    static class FastReader 
+{ 
+    BufferedReader br; 
+    StringTokenizer st; 
+  
+    public FastReader() 
+    { 
+        br = new BufferedReader(new InputStreamReader(System.in)); 
+    } 
+  
+    String next() 
+    { 
+        while (st == null || !st.hasMoreElements()) 
+        { 
+            try
+            { 
+                st = new StringTokenizer(br.readLine()); 
+            } 
+            catch (IOException  e) 
+            { 
+                e.printStackTrace(); 
+            } 
+        } 
+        return st.nextToken(); 
+    } 
+  
+    int nextInt() 
+    { 
+        return Integer.parseInt(next()); 
+    } 
+  
+    long nextLong() 
+    { 
+        return Long.parseLong(next()); 
+    } 
+  
+    double nextDouble() 
+    { 
+        return Double.parseDouble(next()); 
+    } 
+  
+    String nextLine() 
+    { 
+        String str = """"; 
+        try
+        { 
+            str = br.readLine(); 
+        } 
+        catch (IOException e) 
+        { 
+            e.printStackTrace(); 
+        } 
+        return str; 
+    } 
+}
+    static class Output 
+    {
+        private final PrintWriter writer;
+        
+        public Output(OutputStream outputStream) 
+        {
+            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
+        }
+        
+        public Output(Writer writer) 
+        {
+            this.writer = new PrintWriter(writer);
+        }
+        
+        public void print(Object...objects) 
+        {
+            for (int i = 0; i < objects.length; i++) 
+            {
+                if (i != 0)
+                    writer.print(' ');
+                writer.print(objects[i]);
+            }
+        }
+        
+        public void printLine(Object...objects) 
+        {
+            print(objects);
+            writer.println();
+        }
+        
+        public void close() 
+        {
+            writer.close();
+        }
+        
+        public void flush() {
+            writer.flush();
+        }
+    }
+    static class Pair
+    {
+    	int a;
+    	int b;
+    	public Pair(int a, int b)
+    	{
+    		this.a=a;
+    		this.b=b;
+    	}
+    }
+    static HashMap<Integer,List<Integer>> edge=new HashMap();
+    static Pair a[];
+    static long dp[][];
+    static void dfs(int node, int parent)
+    {
+        for(int i:edge.get(node))
+        {
+            if(i!=parent)
+            {
+                dfs(i,node);
+                dp[node][0]+=Math.max(Math.abs(a[node].a-a[i].a)+dp[i][0],Math.abs(a[node].a-a[i].b)+dp[i][1]);
+                dp[node][1]+=Math.max(Math.abs(a[node].b-a[i].a)+dp[i][0],Math.abs(a[node].b-a[i].b)+dp[i][1]);
+            }
+        }
+    }
+    public static void main(String args[])
+    {
+        FastReader sc=new FastReader();
+        Output out=new Output(System.out);
+        int t=sc.nextInt();
+        while(t-->0)
+        {
+            int n=sc.nextInt();
+            a=new Pair[n+1];
+            edge.clear();
+            for(int i=1;i<n+1;i++)
+            {
+                int l=sc.nextInt();
+                int r=sc.nextInt();
+                Pair p=new Pair(l,r);
+                a[i]=p;
+            }
+            for(int i=0;i<n-1;i++)
+            {
+                int u=sc.nextInt();
+                int v=sc.nextInt();
+                if(edge.containsKey(u))
+                {
+                    List<Integer> list=edge.get(u);
+                    list.add(v);
+                    edge.put(u,list);
+                }
+                else
+                {
+                    List<Integer> list=new ArrayList();
+                    list.add(v);
+                    edge.put(u,list);
+                }
+                if(edge.containsKey(v))
+                {
+                    List<Integer> list=edge.get(v);
+                    list.add(u);
+                    edge.put(v,list);
+                }
+                else
+                {
+                    List<Integer> list=new ArrayList();
+                    list.add(u);
+                    edge.put(v,list);
+                }
+            }
+            dp=new long[n+1][2];
+            dfs(1,0);
+            out.printLine(((long)Math.max(dp[1][0],dp[1][1])));
+            out.flush();
+        }
+    }
+}","
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.*;
+
+
+
+import static javax.swing.UIManager.get;
+import static javax.swing.UIManager.getString;
+
+
+public class Main {
+
+
+    static class Pair implements Comparable<Pair> {
+        int x = 0;
+        int y = 0;
+
+        public Pair(int x1, int y1) {
+            x = x1;
+            y = y1;
+        }
+
+
+        @Override
+        public int compareTo(Pair o) {
+            return this.x - o.x;
+        }
+    }
+
+    static boolean checkPallindrome(int n) {
+        ArrayList<Integer> list = new ArrayList<>();
+        while (n > 0) {
+            list.add(n % 10);
+            n /= 10;
+        }
+        int low = 0, high = list.size() - 1;
+        while (low <= high) {
+            if (list.get(low) != list.get(high))
+                return false;
+            low++;
+            high--;
+        }
+        return true;
+    }
+
+
+    static boolean check(String s) {
+
+        int low = 0, high = s.length() - 1;
+        while (low <= high) {
+            if (s.charAt(low) != s.charAt(high))
+                return false;
+            low++;
+            high--;
+        }
+        return true;
+    }
+
+    class Node implements Comparable<Node> {
+        int x = 0, y = 0, z = 0;
+
+        @Override
+        public int compareTo(Node o) {
+            return this.y - o.y;
+        }
+    }
+
+    static int min = Integer.MAX_VALUE;
+
+    public static void main(String[] args) throws IOException {
+        FastReader sc = new FastReader();
+//(1)very very important**(never take the first problem for granted, always check the test cases) take 5 minutes more and check the edge cases
+        // 5 minutes will not decreases rating as much as a wrong submission does it is easy u just think with an open mind and u will surely get the answer
+        //(2)let ur brain consume the problem don't just jump to the solution. after reading the problem take a pause 1 minute
+        //(3)go through the example test cases and also at least two of ur own test cases.Think of testcases which are difficult(edge cases).dry run ur concept
+ //(4) sometimes if else condition is not required but due to if else you miss some points and get wrong answer
+
+
+        int t = sc.nextInt();
+        while (t-- > 0) {
+
+            int n =sc.nextInt();
+            ArrayList<ArrayList<Integer>> list = new ArrayList<>();
+            for(int i=0;i<n;i++)
+                list.add(new ArrayList<Integer>());
+
+            ArrayList<Pair> list1 = new ArrayList<>();
+
+            for(int i=0;i<n;i++)
+            list1.add(new Pair(sc.nextInt(),sc.nextInt()));
+
+            for(int i=0;i<n-1;i++)
+            {
+                int a =sc.nextInt()-1,b=sc.nextInt()-1;
+                list.get(a).add(b);
+                list.get(b).add(a);
+            }
+
+            long[][] dp = new long[2][n];
+
+            dfs(0,-1,dp,list,list1);
+
+
+System.out.println(Math.max(dp[0][0],dp[1][0]));
+        }
+
+
+
+}
+
+static void dfs(int u,int p,long[][] dp,ArrayList<ArrayList<Integer>> list,ArrayList<Pair> list1)
+{
+    for(int v:list.get(u))
+    {  if(v==p)
+        continue;
+        dfs(v,u,dp,list,list1);
+        dp[1][u]+= Math.max(Math.abs(list1.get(u).y-list1.get(v).x)+dp[0][v],Math.abs(list1.get(u).y-list1.get(v).y)+dp[1][v]);
+        dp[0][u]+=Math.max(Math.abs(list1.get(u).x-list1.get(v).x)+dp[0][v],Math.abs(list1.get(u).x-list1.get(v).y)+dp[1][v]);
+
+    }
+
+}
+
+
+//static int lcs( int[] X, int[] Y, int m, int n )
+//{
+//    int L[][] = new int[m+1][n+1];
+//
+//    /* Following steps build L[m+1][n+1] in bottom up fashion. Note
+//        that L[i][j] contains length of LCS of X[0..i-1] and Y[0..j-1] */
+//    for (int i=0; i<=m; i++)
+//    {
+//        for (int j=0; j<=n; j++)
+//        {
+//            if (i == 0 || j == 0)
+//                L[i][j] = 0;
+//            else if (X[i-1] == Y[j-1])
+//                L[i][j] = L[i-1][j-1] + 1;
+//            else
+//                L[i][j] = Math.max(L[i-1][j], L[i][j-1]);
+//        }
+//    }
+//    return L[m][n];
+//}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+// syntax of conditional operator y=(x==1)?1:0;
+//Things to check when u r getting wrong answer
+// 1-  check the flow of the code
+//2- If ur stuck read the problem once again
+//3- before submitting always check the output format of ur code
+//4- don't check standings until problem B is done
+//5- if u r thinking ur concept is correct but still u r getting wrong answer try to implement it in another way
+//6- By default, java interpret all numeral literals as 32-bit integer values.
+// If you want to explicitely specify that this is something bigger then 32-bit integer you should use suffix L for long values.    example   long a = 600851475143L
+
+//All the functions
+
+
+
+
+    long pow(long a,long b,long m)
+    {
+        a%=m;
+        long res=1L;
+        while(b>0)
+        {
+            long temp=b&1;
+            if(temp==1)
+                res=(res*a)%m;
+            a=(a*a)%m;
+            b>>=1;
+        }
+        return res;
+    }
+
+    static class DisjointUnionSets {
+        int[] rank, parent;
+        int n;
+
+        // Constructor
+        public DisjointUnionSets(int n)
+        {
+            rank = new int[n];
+            parent = new int[n];
+            this.n = n;
+            makeSet();
+        }
+
+        // Creates n sets with single item in each
+        void makeSet()
+        {
+            for (int i = 0; i < n; i++) {
+                // Initially, all elements are in
+                // their own set.
+                parent[i] = i;
+            }
+        }
+
+        // Returns representative of x's set
+        int find(int x)
+        {
+            // Finds the representative of the set
+            // that x is an element of
+            if (parent[x] != x) {
+                // if x is not the parent of itself
+                // Then x is not the representative of
+                // his set,
+                parent[x] = find(parent[x]);
+
+                // so we recursively call Find on its parent
+                // and move i's node directly under the
+                // representative of this set
+            }
+
+            return parent[x];
+        }
+
+        // Unites the set that includes x and the set
+        // that includes x
+        void union(int x, int y)
+        {
+            // Find representatives of two sets
+            int xRoot = find(x), yRoot = find(y);
+
+            // Elements are in the same set, no need
+            // to unite anything.
+            if (xRoot == yRoot)
+                return;
+
+            // If x's rank is less than y's rank
+            if (rank[xRoot] < rank[yRoot])
+
+                // Then move x under y  so that depth
+                // of tree remains less
+                parent[xRoot] = yRoot;
+
+                // Else if y's rank is less than x's rank
+            else if (rank[yRoot] < rank[xRoot])
+
+                // Then move y under x so that depth of
+                // tree remains less
+                parent[yRoot] = xRoot;
+
+            else // if ranks are the same
+            {
+                // Then move y under x (doesn't matter
+                // which one goes where)
+                parent[yRoot] = xRoot;
+
+                // And increment the result tree's
+                // rank by 1
+                rank[xRoot] = rank[xRoot] + 1;
+            }
+        }
+    }
+
+
+
+
+
+
+
+
+
+
+    static void debug(String s)
+    { System.out.println(s);
+
+    }
+
+    //collections.sort use merge sort instead of quick sort but arrays.sort use quicksort whose worst time complexity is O(n^2)
+    static int[] sort(int[] a)
+    {         ArrayList<Integer> list = new ArrayList<>();
+        for(int i=0;i<a.length;i++)
+            list.add(a[i]);
+
+        Collections.sort(list);
+        int ind=0;
+        for(int x:list)
+            a[ind++]=x;
+        return a;
+
+    }
+
+    //function to print an array for debugging
+    static void print(int[] a) {
+        for (int i = 0; i < a.length; i++)
+            System.out.print(a[i] + "" "");
+        System.out.println();
+    }
+
+    static void printc(char[] a) {
+        for (int i = 0; i < a.length; i++)
+            System.out.print(a[i] + "" "");
+        System.out.println();
+    }
+
+
+    //normal gcd function, always put the greater number as a and the smaller number as b
+    static int gcd(int a, int b) {
+        if (b == 0)
+            return a;
+        return gcd(b, a % b);
+
+    }
+
+    static int lcm(int a,int b)
+    {
+        return (a*b)/gcd(a,b);
+    }
+
+
+    //to find gcd and lcm for numbers of long data type
+    static long gcdl(long a, long b) {
+        if (b == 0)
+            return a;
+        return gcdl(b, a % b);
+
+    }
+
+    static long lcml(long a,long b)
+    {
+        return (a*b)/gcdl(a,b);
+    }
+
+
+    //Input Reader to read faster input
+    static class FastReader {
+        BufferedReader br;
+        StringTokenizer st;
+
+        public FastReader() {
+            br = new BufferedReader(new
+                    InputStreamReader(System.in));
+        }
+
+        String next() {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+
+        String nextLine() {
+            String str = """";
+            try {
+                str = br.readLine();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+        }
+
+
+        int[] readArray(int n)
+        {  int[] a = new int[n];
+            for(int i=0;i<n;i++)
+                a[i]=nextInt();
+
+            return a;
+        }
+    }
+
+
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+",0
+5449d33c,dff5ff0a,"import java.io.*;
+import java.util.*;
+import java.lang.*;
+
+public class C {
+  public static void main(String[] args) {
+    InputStream inputStream = System.in;
+    OutputStream outputStream = System.out;
+    InputReader in = new InputReader(inputStream);
+    PrintWriter out = new PrintWriter(outputStream);
+    Solver solver = new Solver();
+    solver.Main(in, out);
+    out.close();
+  }
+
+  static class Solver {
+    public void Main(InputReader in, PrintWriter out) {
+      int T = in.nextInt();
+      for (int t = 0; t < T; t++) {
+        int n = in.nextInt();
+        String[] A = new String[n];
+        for (int i = 0; i < n; i++) {
+          A[i] = in.next();
+        }
+        int ans = 0;
+        for (char c = 'a'; c <= 'e'; c++) {
+          int[] ls = new int[n];
+          for (int i = 0; i < n; i++) {
+            int delta = 0;
+            for (int j = 0; j < A[i].length(); j++) {
+              if (A[i].charAt(j) == c) {
+                delta += 1;
+              } else {
+                delta -= 1;
+              }
+            }
+            ls[i] = delta;
+          }
+          Arrays.sort(ls, 0, n);
+          int cur = 0;
+          int score = 0;
+          for (int i = n - 1; i >= 0; i--) {
+            if (cur + ls[i] >= 1) {
+              cur += ls[i];
+              score += 1;
+            }
+          }
+          ans = Math.max(ans, score);
+        }
+        out.println(ans);
+      }
+    }
+  }
+
+  static class InputReader {
+    public BufferedReader reader;
+    public StringTokenizer tokenizer;
+
+    public InputReader(InputStream stream) {
+      reader = new BufferedReader(new InputStreamReader(stream), 32768);
+      tokenizer = null;
+    }
+
+    public String next() {
+      while (tokenizer == null || !tokenizer.hasMoreTokens()) {
+        try {
+          tokenizer = new StringTokenizer(reader.readLine());
+        } catch (IOException e) {
+          throw new RuntimeException(e);
+        }
+      }
+      return tokenizer.nextToken();
+    }
+
+    public int nextInt() {
+      return Integer.parseInt(next());
+    }
+  }
+}
+","import java.io.DataInputStream;
+import java.io.IOException;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.util.Arrays;
+
+public class Main {
+
+    private static void run() throws IOException {
+        int n = in.nextInt();
+        char[][] a = new char[n][];
+        for (int i = 0; i < n; i++) {
+            a[i] = in.next().toCharArray();
+        }
+        int ans = Integer.MIN_VALUE;
+        for (char now = 'a'; now <= 'e'; now++) {
+            ans = Math.max(ans, check(a, now));
+        }
+        out.println(ans);
+    }
+
+    private static int check(char[][] a, char target) {
+        int[] count = new int[a.length];
+        for (int i = 0; i < a.length; i++) {
+            for (char c : a[i]) {
+                if (c == target) {
+                    count[i]++;
+                } else {
+                    count[i]--;
+                }
+            }
+        }
+        Arrays.sort(count);
+        int ans = 0;
+        int sum = 0;
+        for (int i = a.length - 1; i >= 0; i--) {
+            if (count[i] <= 0) break;
+
+            ans++;
+            sum += count[i];
+        }
+
+        if (ans == 0) return 0;
+
+        for (int i = a.length - 1; i >= 0; i--) {
+            if (count[i] > 0) continue;
+
+            if (sum > -count[i]) {
+                sum += count[i];
+                ans++;
+            }
+        }
+        return ans;
+    }
+
+    public static void main(String[] args) throws IOException {
+        in = new Reader();
+        out = new PrintWriter(new OutputStreamWriter(System.out));
+
+        int t = in.nextInt();
+        for (int i = 0; i < t; i++) {
+            run();
+        }
+
+        out.flush();
+        in.close();
+        out.close();
+    }
+
+    private static int gcd(int a, int b) {
+        if (a == 0 || b == 0)
+            return 0;
+        while (b != 0) {
+            int tmp;
+            tmp = a % b;
+            a = b;
+            b = tmp;
+        }
+        return a;
+    }
+
+    static final long mod = 1000000007;
+
+    static long pow_mod(long a, long b) {
+        long result = 1;
+        while (b != 0) {
+            if ((b & 1) != 0) result = (result * a) % mod;
+            a = (a * a) % mod;
+            b >>= 1;
+        }
+        return result;
+    }
+
+    private static long multiplied_mod(long... longs) {
+        long ans = 1;
+        for (long now : longs) {
+            ans = (ans * now) % mod;
+        }
+        return ans;
+    }
+
+    @SuppressWarnings(""FieldCanBeLocal"")
+    private static Reader in;
+    private static PrintWriter out;
+
+    private static int[] read_int_array(int len) throws IOException {
+        int[] a = new int[len];
+        for (int i = 0; i < len; i++) {
+            a[i] = in.nextInt();
+        }
+        return a;
+    }
+
+    private static long[] read_long_array(int len) throws IOException {
+        long[] a = new long[len];
+        for (int i = 0; i < len; i++) {
+            a[i] = in.nextLong();
+        }
+        return a;
+    }
+
+    private static void print_array(int[] array) {
+        for (int now : array) {
+            out.print(now);
+            out.print(' ');
+        }
+        out.println();
+    }
+
+    private static void print_array(long[] array) {
+        for (long now : array) {
+            out.print(now);
+            out.print(' ');
+        }
+        out.println();
+    }
+
+    static class Reader {
+        private static final int BUFFER_SIZE = 1 << 16;
+        private final DataInputStream din;
+        private final byte[] buffer;
+        private int bufferPointer, bytesRead;
+
+        Reader() {
+            din = new DataInputStream(System.in);
+            buffer = new byte[BUFFER_SIZE];
+            bufferPointer = bytesRead = 0;
+        }
+
+        public String readLine() throws IOException {
+            final byte[] buf = new byte[1024]; // line length
+            int cnt = 0, c;
+            while ((c = read()) != -1) {
+                if (c == '\n') {
+                    break;
+                }
+                buf[cnt++] = (byte) c;
+            }
+            return new String(buf, 0, cnt);
+        }
+
+        public int nextSign() throws IOException {
+            byte c = read();
+            while ('+' != c && '-' != c) {
+                c = read();
+            }
+            return '+' == c ? 0 : 1;
+        }
+
+        private static boolean isSpaceChar(int c) {
+            return !(c >= 33 && c <= 126);
+        }
+
+        public int skip() throws IOException {
+            int b;
+            // noinspection ALL
+            while ((b = read()) != -1 && isSpaceChar(b)) {
+                ;
+            }
+            return b;
+        }
+
+        public char nc() throws IOException {
+            return (char) skip();
+        }
+
+        public String next() throws IOException {
+            int b = skip();
+            final StringBuilder sb = new StringBuilder();
+            while (!isSpaceChar(b)) { // when nextLine, (isSpaceChar(b) && b != ' ')
+                sb.appendCodePoint(b);
+                b = read();
+            }
+            return sb.toString();
+        }
+
+        public int nextInt() throws IOException {
+            int ret = 0;
+            byte c = read();
+            while (c <= ' ') {
+                c = read();
+            }
+            final boolean neg = c == '-';
+            if (neg) {
+                c = read();
+            }
+            do {
+                ret = ret * 10 + c - '0';
+            } while ((c = read()) >= '0' && c <= '9');
+
+            if (neg) {
+                return -ret;
+            }
+            return ret;
+        }
+
+        public long nextLong() throws IOException {
+            long ret = 0;
+            byte c = read();
+            while (c <= ' ') {
+                c = read();
+            }
+            final boolean neg = c == '-';
+            if (neg) {
+                c = read();
+            }
+            do {
+                ret = ret * 10 + c - '0';
+            }
+            while ((c = read()) >= '0' && c <= '9');
+            if (neg) {
+                return -ret;
+            }
+            return ret;
+        }
+
+        public double nextDouble() throws IOException {
+            double ret = 0, div = 1;
+            byte c = read();
+            while (c <= ' ') {
+                c = read();
+            }
+            final boolean neg = c == '-';
+            if (neg) {
+                c = read();
+            }
+
+            do {
+                ret = ret * 10 + c - '0';
+            }
+            while ((c = read()) >= '0' && c <= '9');
+
+            if (c == '.') {
+                while ((c = read()) >= '0' && c <= '9') {
+                    ret += (c - '0') / (div *= 10);
+                }
+            }
+
+            if (neg) {
+                return -ret;
+            }
+            return ret;
+        }
+
+        private void fillBuffer() throws IOException {
+            bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
+            if (bytesRead == -1) {
+                buffer[0] = -1;
+            }
+        }
+
+        private byte read() throws IOException {
+            if (bufferPointer == bytesRead) {
+                fillBuffer();
+            }
+            return buffer[bufferPointer++];
+        }
+
+        public void close() throws IOException {
+            din.close();
+        }
+
+    }
+}",0
+abd16ff0,db1ef8b3,"import java.util.*;
+
+public class Solve{
+
+    public static void main(String[] args){
+        Scanner sc=new Scanner(System.in);
+        int t=sc.nextInt();
+       
+       
+        while(t-->0){
+            int n=sc.nextInt();
+           long ans=Long.MAX_VALUE;
+           long pre=0;
+           PriorityQueue<Long> epq=new PriorityQueue<>();
+           PriorityQueue<Long> opq=new PriorityQueue<>();
+           for(int i=0;i<n;i++){
+               long a=sc.nextInt();
+               if(i%2==0)opq.add(a);
+               else epq.add(a);
+               pre+=a;
+              if(i>0) ans=Math.min(ans,pre+opq.peek()*(n-opq.size())+epq.peek()*(n-epq.size()));
+               
+           }
+          System.out.println(ans);
+        }
+    }
+}","import java.util.*;
+import java.io.*;
+import java.math.*;
+
+/**
+ *
+ * @Har_Har_Mahadev
+ */
+
+public class C {
+
+	private static long INF = 2000000000000000000L, M = 1000000007, MM = 998244353;
+	private static int N = 0;
+
+	public static void process() throws IOException {
+
+		int n = sc.nextInt();
+		PriorityQueue<Integer> odd = new PriorityQueue<Integer>();
+		PriorityQueue<Integer> even = new PriorityQueue<Integer>();
+		int arr[] = sc.readArray(n);
+		long min = INF;
+		long sumOdd = 0;
+		long sumEven = 0;
+		for (int i = 0; i < n; i++) {
+			int x = arr[i];
+			if (i % 2 == 0) {
+				even.add(x);
+				sumEven += x;
+			} else {
+				odd.add(x);
+				sumOdd += x;
+			}
+			if (i > 0) {
+				long ans = 0;
+				ans += 1l * even.peek() * (n - (even.size()));
+				ans += 1l * odd.peek() * (n - (odd.size()));
+				ans += sumOdd + sumEven;
+				min = Math.min(ans, min);
+			}
+		}
+		System.out.println(min);
+	}
+
+	//=============================================================================
+	//--------------------------The End---------------------------------
+	//=============================================================================
+
+	static FastScanner sc;
+	static PrintWriter out;
+
+	public static void main(String[] args) throws IOException {
+		boolean oj = true;
+		if (oj) {
+			sc = new FastScanner();
+			out = new PrintWriter(System.out);
+		} else {
+			sc = new FastScanner(100);
+			out = new PrintWriter(""output.txt"");
+		}
+		int t = 1;
+		t = sc.nextInt();
+		while (t-- > 0) {
+			process();
+		}
+		out.flush();
+		out.close();
+	}
+
+	static class Pair implements Comparable<Pair> {
+		int x, y;
+
+		Pair(int x, int y) {
+			this.x = x;
+			this.y = y;
+		}
+
+		@Override
+		public int compareTo(Pair o) {
+			return Integer.compare(this.x, o.x);
+		}
+
+		//		 @Override
+		//		    public boolean equals(Object o) {
+		//		        if (this == o) return true;
+		//		        if (!(o instanceof Pair)) return false;
+		//		        Pair key = (Pair) o;
+		//		        return x == key.x && y == key.y;
+		//		    }
+		//		 
+		//		    @Override
+		//		    public int hashCode() {
+		//		        int result = x;
+		//		        result = 31 * result + y;
+		//		        return result;
+		//		    }
+	}
+
+	/////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+	static void println(Object o) {
+		out.println(o);
+	}
+
+	static void println() {
+		out.println();
+	}
+
+	static void print(Object o) {
+		out.print(o);
+	}
+
+	static void pflush(Object o) {
+		out.println(o);
+		out.flush();
+	}
+
+	static int ceil(int x, int y) {
+		return (x % y == 0 ? x / y : (x / y + 1));
+	}
+
+	static long ceil(long x, long y) {
+		return (x % y == 0 ? x / y : (x / y + 1));
+	}
+
+	static int max(int x, int y) {
+		return Math.max(x, y);
+	}
+
+	static int min(int x, int y) {
+		return Math.min(x, y);
+	}
+
+	static int abs(int x) {
+		return Math.abs(x);
+	}
+
+	static long abs(long x) {
+		return Math.abs(x);
+	}
+
+	static int log2(int N) {
+		int result = (int) (Math.log(N) / Math.log(2));
+		return result;
+	}
+
+	static long max(long x, long y) {
+		return Math.max(x, y);
+	}
+
+	static long min(long x, long y) {
+		return Math.min(x, y);
+	}
+
+	public static int gcd(int a, int b) {
+		BigInteger b1 = BigInteger.valueOf(a);
+		BigInteger b2 = BigInteger.valueOf(b);
+		BigInteger gcd = b1.gcd(b2);
+		return gcd.intValue();
+	}
+
+	public static long gcd(long a, long b) {
+		BigInteger b1 = BigInteger.valueOf(a);
+		BigInteger b2 = BigInteger.valueOf(b);
+		BigInteger gcd = b1.gcd(b2);
+		return gcd.longValue();
+	}
+
+	public static long lcm(long a, long b) {
+		return (a * b) / gcd(a, b);
+	}
+
+	public static int lcm(int a, int b) {
+		return (a * b) / gcd(a, b);
+	}
+
+	public static int lower_bound(int[] arr, int x) {
+		int low = 0, high = arr.length, mid = -1;
+
+		while (low < high) {
+			mid = (low + high) / 2;
+
+			if (arr[mid] >= x)
+				high = mid;
+			else
+				low = mid + 1;
+		}
+
+		return low;
+	}
+
+	public static int upper_bound(int[] arr, int x) {
+		int low = 0, high = arr.length, mid = -1;
+
+		while (low < high) {
+			mid = (low + high) / 2;
+
+			if (arr[mid] > x)
+				high = mid;
+			else
+				low = mid + 1;
+		}
+
+		return low;
+	}
+
+	/////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+	static class FastScanner {
+		BufferedReader br;
+		StringTokenizer st;
+
+		FastScanner() throws FileNotFoundException {
+			br = new BufferedReader(new InputStreamReader(System.in));
+		}
+
+		FastScanner(int a) throws FileNotFoundException {
+			br = new BufferedReader(new FileReader(""input.txt""));
+		}
+
+		String next() throws IOException {
+			while (st == null || !st.hasMoreElements()) {
+				try {
+					st = new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			}
+			return st.nextToken();
+		}
+
+		int nextInt() throws IOException {
+			return Integer.parseInt(next());
+		}
+
+		long nextLong() throws IOException {
+			return Long.parseLong(next());
+		}
+
+		double nextDouble() throws IOException {
+			return Double.parseDouble(next());
+		}
+
+		String nextLine() throws IOException {
+			String str = """";
+			try {
+				str = br.readLine();
+			} catch (IOException e) {
+				e.printStackTrace();
+			}
+			return str;
+		}
+
+		int[] readArray(int n) throws IOException {
+			int[] A = new int[n];
+			for (int i = 0; i != n; i++) {
+				A[i] = sc.nextInt();
+			}
+			return A;
+		}
+
+		long[] readArrayLong(int n) throws IOException {
+			long[] A = new long[n];
+			for (int i = 0; i != n; i++) {
+				A[i] = sc.nextLong();
+			}
+			return A;
+		}
+	}
+
+	static void ruffleSort(int[] a) {
+		Random get = new Random();
+		for (int i = 0; i < a.length; i++) {
+			int r = get.nextInt(a.length);
+			int temp = a[i];
+			a[i] = a[r];
+			a[r] = temp;
+		}
+		Arrays.sort(a);
+	}
+
+	static void ruffleSort(long[] a) {
+		Random get = new Random();
+		for (int i = 0; i < a.length; i++) {
+			int r = get.nextInt(a.length);
+			long temp = a[i];
+			a[i] = a[r];
+			a[r] = temp;
+		}
+		Arrays.sort(a);
+	}
+}
+",0
+4da08761,a5d5a95f,"import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.PrintWriter;
+import java.util.ArrayList;
+import java.util.Arrays;
+
+/**
+ * Built using CHelper plug-in
+ * Actual solution is at the top
+ */
+public class Solution {
+    public static void main(String[] args) {
+        InputStream inputStream = System.in;
+        OutputStream outputStream = System.out;
+        InputReader in = new InputReader(inputStream);
+        PrintWriter out = new PrintWriter(outputStream);
+        Main solver = new Main();
+        boolean multipleTC = true;
+        int testCount = multipleTC ? Integer.parseInt(in.next()) : 1;
+        for (int i = 1; i <= testCount; i++)
+            solver.solve(in, out, i);
+        out.close();
+    }
+    static class Main {
+        PrintWriter out;
+        InputReader in;
+
+        public void solve(InputReader in, PrintWriter out, int test) {
+            this.out = out;
+            this.in = in;
+            int n = ni();
+            String[] arr = new String[n];
+            int[][] freq = new int[n][5];
+            int[][] rem = new int[n][5];
+            for(int i = 0; i < n; i++){
+                arr[i] = n();
+                for(int j = 0; j < arr[i].length(); j++)
+                    freq[i][arr[i].charAt(j) - 'a']++;
+                for(int j = 0; j < 5; j++)
+                    rem[i][j] = arr[i].length() - freq[i][j];
+            }
+            int ans = 0;
+            for(int i = 0; i < 5; i++){
+                int[] vals = new int[n];
+                for(int j = 0; j < n; j++)
+                    vals[j] = freq[j][i] - rem[j][i];
+                Arrays.sort(vals);
+                int sum = 0, x = 0;
+                for(int j = n - 1; j >= 0; j--){
+                    if(sum + vals[j] > 0){
+                        x++;
+                        sum += vals[j];
+                    } else {
+                        break;
+                    }
+                }
+                if(x > ans) {
+                    ans = x;
+                }
+            }
+            pn(ans);
+        }
+
+        int gcd(int a, int b)
+        {
+            if (a == 0)
+                return b;
+
+            return gcd(b%a, a);
+        }
+
+
+        String n(){
+            return in.next();
+        }
+
+        int ni() {
+            return in.nextInt();
+        }
+
+        long nl() {
+            return in.nextLong();
+        }
+
+        void pn(long zx) {
+            out.println(zx);
+        }
+
+        void pn(String sz) {
+            out.println(sz);
+        }
+
+        void pn(double dx){
+            out.println(dx);
+        }
+
+        class Tuple {
+            long x;
+            long y;
+
+            Tuple(long a, long b) {
+                x = a;
+                y = b;
+            }
+        }
+
+    }
+
+    static class InputReader {
+        private InputStream stream;
+        private byte[] buf = new byte[1024];
+        private int curChar;
+        private int numChars;
+
+        public InputReader(InputStream stream) {
+            this.stream = stream;
+        }
+
+        public int read() {
+            if (numChars == -1) {
+                throw new UnknownError();
+            }
+            if (curChar >= numChars) {
+                curChar = 0;
+                try {
+                    numChars = stream.read(buf);
+                } catch (IOException e) {
+                    throw new UnknownError();
+                }
+                if (numChars <= 0) {
+                    return -1;
+                }
+            }
+            return buf[curChar++];
+        }
+
+        public int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        public long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        public String next() {
+            int c = read();
+            while (isSpaceChar(c)) {
+                c = read();
+            }
+            StringBuffer res = new StringBuffer();
+            do {
+                res.appendCodePoint(c);
+                c = read();
+            } while (!isSpaceChar(c));
+
+            return res.toString();
+        }
+
+        private boolean isSpaceChar(int c) {
+            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
+        }
+
+    }
+}","import java.util.*;
+import java.io.*;
+public class Main {
+// For fast input output
+static class FastReader {
+BufferedReader br;
+StringTokenizer st;
+public FastReader()
+{ try {br = new BufferedReader(
+new FileReader(""input.txt""));
+PrintStream out = new PrintStream(new FileOutputStream(""output.txt""));
+System.setOut(out);}
+catch(Exception e) { br = new BufferedReader(new InputStreamReader(System.in));}
+}
+String next()
+{
+while (st == null || !st.hasMoreElements()) {
+try {st = new StringTokenizer(br.readLine());}
+catch (IOException e) {
+e.printStackTrace();}
+}
+return st.nextToken();
+}
+int nextInt() { return Integer.parseInt(next()); }
+long nextLong() { return Long.parseLong(next()); }
+double nextDouble() {return Double.parseDouble(next()); }
+String nextLine()
+{
+String str = """";
+try {
+str = br.readLine();
+}
+catch (IOException e) {
+e.printStackTrace();
+}
+return str;
+}
+}
+// end of fast i/o code
+public static void main(String[] args) {
+  FastReader reader = new FastReader();
+  int Q = reader.nextInt();
+  outer: for (int q = 0; q < Q; q++) {
+    int N = reader.nextInt();
+    int[][] scores = new int[5][N];
+    for (int i = 0; i < N; i++) {
+      int[] occurs = new int[5];
+      String word = reader.next();
+      for (int j = 0; j < word.length(); j++) {
+        occurs[word.charAt(j) - 'a']++;
+      }
+      for (int j = 0; j < 5; j++) {
+        scores[j][i] = occurs[j] - (word.length() - occurs[j]) ;
+      }
+    }
+    int bestCount = 0;
+    for (int i = 0; i < 5; i++) {
+      int[] curr = scores[i];
+      Arrays.sort(curr);
+      int currentCount = 1;
+      int currentScore = curr[curr.length - 1];
+      for (int j = curr.length - 2; j >= 0 && currentScore > 0; j--) {
+        currentScore += curr[j];
+        currentCount++;
+      }
+      if (currentScore <= 0) currentCount--;
+      bestCount = Math.max(currentCount, bestCount);
+    }
+    System.out.println(bestCount);
+  }
+}
+
+}
+",0
+18d20d2e,d8a171a3,"import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.math.BigInteger;
+import java.util.*;
+
+public class C {
+    public static void main(String[] args) {
+        FastScanner scanner = new FastScanner();
+        int t = scanner.nextInt();
+        for (int i=0; i < t;i++) {
+            int n = scanner.nextInt();
+            String start = scanner.nextLine().trim();
+            String finish = scanner.nextLine().trim();
+            int ans = solve(start, finish, n);
+            System.out.println(ans);
+        }
+    }
+
+    public static int solve(String start, String finish, int n) {
+        int nOnesInA = 0;
+        for (char c : start.toCharArray()) {
+            if (c == '1') {
+                nOnesInA++;
+            }
+        }
+        int nOnesInB = 0;
+        for (char c : finish.toCharArray()) {
+            if (c == '1') {
+                nOnesInB++;
+            }
+        }
+        int ans = Integer.MAX_VALUE;
+        if (nOnesInA == nOnesInB) {
+            ans = simpleSolve(start, finish, n);
+        }
+        if ((n - nOnesInA) + 1 == nOnesInB) {
+            int newAns = simpleSolve(flip(start, n), finish, n) + 1;
+            if (newAns < ans) {
+                ans = newAns;
+            }
+        }
+        if (ans == Integer.MAX_VALUE) {
+            return -1;
+        }
+        return ans;
+    }
+
+    public static int simpleSolve(String start, String finish, int n) {
+        int ans = 0;
+        for (int i=0; i < n; i++) {
+            if ((start.charAt(i) == '1') && (finish.charAt(i) == '0')) {
+                ans+=2;
+            }
+        }
+        return ans;
+    }
+
+    public static String flip(String start, int n) {
+        char[] flipped = new char[n];
+        for(int i=0; i<n; i++) {
+            if (start.charAt(i) == '1') {
+                flipped[i] = '0';
+            } else {
+                flipped[i] = '1';
+            }
+        }
+        return String.valueOf(flipped);
+    }
+
+    public static class FastScanner {
+        BufferedReader br;
+        StringTokenizer st;
+
+        public FastScanner() {
+            br = new BufferedReader(new InputStreamReader(System.in));
+        }
+
+        String next() {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+
+        String nextLine() {
+            String str = """";
+            try {
+                str = br.readLine();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+        }
+    }
+}","import java.io.*;
+import java.util.*;
+
+public class B {
+	
+	public static void main(String[] args)throws IOException {
+		
+		FastScanner scan = new FastScanner();
+		PrintWriter output = new PrintWriter(System.out);
+		int t = scan.nextInt();
+		for(int tt = 0;tt<t;tt++) {
+			int n = scan.nextInt();
+			char initial[] = scan.next().toCharArray();
+			char desired[] = scan.next().toCharArray();
+			int lit1 = 0, lit2 = 0;
+			int ans = Integer.MAX_VALUE;
+			for(int i = 0;i<n;i++) {
+				if(initial[i]=='1') lit1++;
+				if(desired[i]=='1') lit2++;
+			}
+			if(lit1==lit2) {
+				int count = 0;
+				for(int i = 0;i<n;i++) if(initial[i]!=desired[i]) count++;
+				ans = Math.min(ans, count);
+			}
+			if(lit2==(n-lit1+1)) {
+				int count = 0;
+				for(int i = 0;i<n;i++) if(initial[i]==desired[i]) count++;
+				ans = Math.min(ans, count);
+			}
+			if(ans == Integer.MAX_VALUE) ans = -1;
+			output.println(ans);	
+		}
+		output.flush();
+	}
+	
+	public static int[] sort(int arr[]) {
+		List<Integer> list = new ArrayList<>();
+		for(int i:arr) list.add(i);
+		Collections.sort(list);
+		for(int i = 0;i<list.size();i++) arr[i] = list.get(i);
+		return arr;
+	}
+	
+	public static int gcd(int a, int b) {
+		if(a == 0) return b;
+		return gcd(b%a, a);
+	}
+	
+	public static void printArray(int arr[]) {
+		for(int i:arr) System.out.print(i+"" "");
+		System.out.println();
+	}
+	
+	static class FastScanner {
+		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st=new StringTokenizer("""");
+		String next() {
+			while (!st.hasMoreTokens())
+				try {
+					st=new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			return st.nextToken();
+		}
+
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+		int[] readArray(int n) {
+			int[] a=new int[n];
+			for (int i=0; i<n; i++) a[i]=nextInt();
+			return a;
+		}
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+		
+		double nextDouble() {
+			return Double.parseDouble(next());
+		}
+	}
+
+}
+",0
+5dbd0a07,bdc08e6f,"
+import java.io.*;
+import java.util.*;
+
+import static java.lang.Double.parseDouble;
+import static java.lang.Integer.compare;
+import static java.lang.Integer.parseInt;
+import static java.lang.Long.parseLong;
+import static java.lang.System.in;
+import static java.lang.System.out;
+import static java.util.Arrays.asList;
+import static java.util.Collections.max;
+import static java.util.Collections.min;
+
+public class Main {
+    private static final int MOD = (int) (1E9 + 7);
+    private static final int INF = (int) (1E9);
+    static FastScanner scanner = new FastScanner(in);
+
+    public static void main(String[] args) throws IOException {
+        // Write your solution here
+        StringBuilder answer = new StringBuilder();
+        int t = 1;
+        t = parseInt(scanner.nextLine());
+        while (t-- > 0) {
+            answer.append(solve()).append(""\n"");
+        }
+//        out.println(answer);
+    }
+
+    private static Object solve() throws IOException {
+       int n = scanner.nextInt();
+       int m = scanner.nextInt();
+       int x = scanner.nextInt();
+       Integer[] h = new Integer[n];
+       for (int i = 0; i < n; i++) {
+          h[i] = scanner.nextInt();
+       }
+       TreeSet<Pair> q = new TreeSet<>();
+       PriorityQueue<Pair> height = new PriorityQueue<>();
+       for (int i = 0; i < m; i++) {
+          q.add(new Pair(i + 1,0));
+       }
+       for (int i = 0; i < n; i++) {
+          height.add(new Pair(i,h[i]));
+       }
+       boolean shift = false;
+       int size = 0;
+       while(!height.isEmpty()){
+          Pair p = height.poll();
+          Pair building  = (shift) ? q.pollLast() : q.pollFirst();
+          h[p.index] = building.index;
+          q.add(new Pair(building.index,building.value + p.value));
+           //out.println(""q = "" + q);
+          if(++size == n){
+              size = 0;
+              shift = !shift;
+          }
+       }
+       if(safe(q,x)){
+          out.println(""YES"");
+          StringBuilder stringBuilder = new StringBuilder();
+          for (Object o : h)
+             stringBuilder.append(o).append("" "");
+          out.println(stringBuilder);
+       }
+       else {
+           out.println(""NO"");
+       }
+        return """";
+    }
+
+   private static boolean safe(TreeSet<Pair> q, int x) {
+       int last = q.pollFirst().value;
+       while (!q.isEmpty()){
+          Pair p = q.pollFirst();
+          if(p.value - last > x) return false;
+          last = p.value;
+       }
+       return true;
+   }
+
+   private static class Pair implements Comparable<Pair> {
+        int index, value;
+
+        public Pair(int index, int value) {
+            this.index = index;
+            this.value = value;
+        }
+
+        public int compareTo(Pair o) {
+            if (value != o.value) return compare(value, o.value);
+            return compare(index, o.index);
+        }
+
+       @Override
+       public String toString() {
+           return ""Pair{"" +
+                   ""index="" + index +
+                   "", value="" + value +
+                   '}';
+       }
+   }
+
+    private static int maxx(Integer... a) {
+        return max(asList(a));
+    }
+
+    private static int minn(Integer... a) {
+        return min(asList(a));
+    }
+
+    private static long maxx(Long... a) {
+        return max(asList(a));
+    }
+
+    private static long minn(Long... a) {
+        return min(asList(a));
+    }
+
+    private static int add(int a, int b) {
+        long res = ((long) (a + MOD) % MOD + (b + MOD) % MOD) % MOD;
+        return (int) res;
+    }
+
+    private static int mul(int a, int b) {
+        long res = ((long) a % MOD * b % MOD) % MOD;
+        return (int) res;
+    }
+
+
+    private static int gcd(int a, int b) {
+        if (b == 0)
+            return a;
+        return gcd(b, a % b);
+    }
+
+    private static int lcm(int a, int b) {
+        return (a / gcd(a, b)) * b;
+    }
+
+    static class FastScanner {
+        BufferedReader br;
+        StringTokenizer st;
+
+        FastScanner(File f) {
+            try {
+                br = new BufferedReader(new FileReader(f));
+            } catch (FileNotFoundException e) {
+                e.printStackTrace();
+            }
+        }
+
+        FastScanner(InputStream f) {
+            br = new BufferedReader(new InputStreamReader(f));
+        }
+
+        String nextLine() {
+            try {
+                return br.readLine();
+            } catch (IOException e) {
+                return null;
+            }
+        }
+
+        String next() {
+            while (st == null || !st.hasMoreTokens()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return parseInt(next());
+        }
+
+        long nextLong() {
+            return parseLong(next());
+        }
+
+        double nextDouble() {
+            return parseDouble(next());
+        }
+
+    }
+}
+","
+import java.io.*;
+import java.util.*;
+
+import static java.lang.Double.parseDouble;
+import static java.lang.Integer.compare;
+import static java.lang.Integer.parseInt;
+import static java.lang.Long.parseLong;
+import static java.lang.System.in;
+import static java.lang.System.out;
+import static java.util.Arrays.asList;
+import static java.util.Collections.max;
+import static java.util.Collections.min;
+
+public class Main {
+    private static final int MOD = (int) (1E9 + 7);
+    private static final int INF = (int) (1E9);
+    static FastScanner scanner = new FastScanner(in);
+
+    public static void main(String[] args) throws IOException {
+        // Write your solution here
+        StringBuilder answer = new StringBuilder();
+        int t = 1;
+        t = parseInt(scanner.nextLine());
+        while (t-- > 0) {
+            answer.append(solve()).append(""\n"");
+        }
+//        out.println(answer);
+    }
+
+    private static Object solve() throws IOException {
+       int n = scanner.nextInt();
+       int m = scanner.nextInt();
+       int x = scanner.nextInt();
+       Integer[] h = new Integer[n];
+       for (int i = 0; i < n; i++) {
+          h[i] = scanner.nextInt();
+       }
+       TreeSet<Pair> q = new TreeSet<>();
+       PriorityQueue<Pair> height = new PriorityQueue<>();
+       for (int i = 0; i < m; i++) {
+          q.add(new Pair(i + 1,0));
+       }
+       for (int i = 0; i < n; i++) {
+          height.add(new Pair(i,h[i]));
+       }
+       boolean shift = false;
+       int size = 0;
+       while(!height.isEmpty()){
+          Pair p = height.poll();
+          Pair building  = (shift) ? q.pollLast() : q.pollFirst();
+          h[p.index] = building.index;
+          q.add(new Pair(building.index,building.value + p.value));
+           //out.println(""q = "" + q);
+          if(++size == n){
+              size = 0;
+              shift = !shift;
+          }
+       }
+       if(safe(q,x)){
+          out.println(""YES"");
+          StringBuilder stringBuilder = new StringBuilder();
+          for (Object o : h)
+             stringBuilder.append(o).append("" "");
+          out.println(stringBuilder);
+       }
+       else {
+           out.println(""NO"");
+       }
+        return """";
+    }
+
+   private static boolean safe(TreeSet<Pair> q, int x) {
+       int last = q.pollFirst().value;
+       while (!q.isEmpty()){
+          Pair p = q.pollFirst();
+          if(p.value - last > x) return false;
+          last = p.value;
+       }
+       return true;
+   }
+
+   private static class Pair implements Comparable<Pair> {
+        int index, value;
+
+        public Pair(int index, int value) {
+            this.index = index;
+            this.value = value;
+        }
+
+        public int compareTo(Pair o) {
+            if (value != o.value) return compare(value, o.value);
+            return compare(index, o.index);
+        }
+
+       @Override
+       public String toString() {
+           return ""Pair{"" +
+                   ""index="" + index +
+                   "", value="" + value +
+                   '}';
+       }
+   }
+
+    private static int maxx(Integer... a) {
+        return max(asList(a));
+    }
+
+    private static int minn(Integer... a) {
+        return min(asList(a));
+    }
+
+    private static long maxx(Long... a) {
+        return max(asList(a));
+    }
+
+    private static long minn(Long... a) {
+        return min(asList(a));
+    }
+
+    private static int add(int a, int b) {
+        long res = ((long) (a + MOD) % MOD + (b + MOD) % MOD) % MOD;
+        return (int) res;
+    }
+
+    private static int mul(int a, int b) {
+        long res = ((long) a % MOD * b % MOD) % MOD;
+        return (int) res;
+    }
+
+    private static int pow(int a, int b) {
+        a %= MOD;
+        int res = 1;
+        while (b > 0) {
+            if ((b & 1) != 0)
+                res = mul(res, a);
+            a = mul(a, a);
+            b >>= 1;
+        }
+        return res;
+    }
+
+    private static int gcd(int a, int b) {
+        if (b == 0)
+            return a;
+        return gcd(b, a % b);
+    }
+
+    private static int lcm(int a, int b) {
+        return (a / gcd(a, b)) * b;
+    }
+
+    static class FastScanner {
+        BufferedReader br;
+        StringTokenizer st;
+
+        FastScanner(File f) {
+            try {
+                br = new BufferedReader(new FileReader(f));
+            } catch (FileNotFoundException e) {
+                e.printStackTrace();
+            }
+        }
+
+        FastScanner(InputStream f) {
+            br = new BufferedReader(new InputStreamReader(f));
+        }
+
+        String nextLine() {
+            try {
+                return br.readLine();
+            } catch (IOException e) {
+                return null;
+            }
+        }
+
+        String next() {
+            while (st == null || !st.hasMoreTokens()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return parseInt(next());
+        }
+
+        long nextLong() {
+            return parseLong(next());
+        }
+
+        double nextDouble() {
+            return parseDouble(next());
+        }
+
+    }
+}",1
+67996c4c,9028caf7,"import java.util.*;
+import java.io.*;
+
+public class code{
+
+	static class Reader
+    {
+        final private int BUFFER_SIZE = 1 << 16;
+        private DataInputStream din;
+        private byte[] buffer;
+        private int bufferPointer, bytesRead;
+
+        public Reader()
+        {
+            din = new DataInputStream(System.in);
+            buffer = new byte[BUFFER_SIZE];
+            bufferPointer = bytesRead = 0;
+        }
+
+        public Reader(String file_name) throws IOException
+        {
+            din = new DataInputStream(new FileInputStream(file_name));
+            buffer = new byte[BUFFER_SIZE];
+            bufferPointer = bytesRead = 0;
+        }
+
+        public String readLine() throws IOException
+        {
+            byte[] buf = new byte[64]; // line length
+            int cnt = 0, c;
+            while ((c = read()) != -1)
+            {
+                if (c == '\n')
+                    break;
+                buf[cnt++] = (byte) c;
+            }
+            return new String(buf, 0, cnt);
+        }
+
+        public int nextInt() throws IOException
+        {
+            int ret = 0;
+            byte c = read();
+            while (c <= ' ')
+                c = read();
+            boolean neg = (c == '-');
+            if (neg)
+                c = read();
+            do
+            {
+                ret = ret * 10 + c - '0';
+            }  while ((c = read()) >= '0' && c <= '9');
+
+            if (neg)
+                return -ret;
+            return ret;
+        }
+
+        public long nextLong() throws IOException
+        {
+            long ret = 0;
+            byte c = read();
+            while (c <= ' ')
+                c = read();
+            boolean neg = (c == '-');
+            if (neg)
+                c = read();
+            do {
+                ret = ret * 10 + c - '0';
+            }
+            while ((c = read()) >= '0' && c <= '9');
+            if (neg)
+                return -ret;
+            return ret;
+        }
+
+        public double nextDouble() throws IOException
+        {
+            double ret = 0, div = 1;
+            byte c = read();
+            while (c <= ' ')
+                c = read();
+            boolean neg = (c == '-');
+            if (neg)
+                c = read();
+
+            do {
+                ret = ret * 10 + c - '0';
+            }
+            while ((c = read()) >= '0' && c <= '9');
+
+            if (c == '.')
+            {
+                while ((c = read()) >= '0' && c <= '9')
+                {
+                    ret += (c - '0') / (div *= 10);
+                }
+            }
+
+            if (neg)
+                return -ret;
+            return ret;
+        }
+
+        private void fillBuffer() throws IOException
+        {
+            bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
+            if (bytesRead == -1)
+                buffer[0] = -1;
+        }
+
+        private byte read() throws IOException
+        {
+            if (bufferPointer == bytesRead)
+                fillBuffer();
+            return buffer[bufferPointer++];
+        }
+
+        public void close() throws IOException
+        {
+            if (din == null)
+                return;
+            din.close();
+        }
+    }
+
+	public static int GCD(int a, int b)
+    {
+      if (b == 0)
+        return a;
+      return GCD(b, a % b);
+    }
+
+	public static void main(String[] arg) throws IOException{
+		//Reader in=new Reader();
+		Scanner in=new Scanner(System.in);
+
+   int n=in.nextInt();
+	 int[] arr=new int[n];
+	 ArrayList<Integer> zero=new ArrayList<Integer>();
+	 ArrayList<Integer> one=new ArrayList<Integer>();
+
+	 for(int i=0;i<n;i++){
+		 arr[i]=in.nextInt();
+		 if(arr[i]==0) zero.add(i);
+		 else one.add(i);
+	 }
+   if(one.size()==0) {
+		 System.out.println(0);
+	 }
+	 else{
+			 int[][] dp=new int[one.size()][zero.size()];
+
+		   for(int i=0;i<one.size();i++){
+				 for(int j=0;j<zero.size();j++){
+					 if(i==0 && j==0) dp[i][j]=Math.abs(one.get(i)-zero.get(j));
+					 else if(j==0) dp[i][j]=Integer.MAX_VALUE/2;
+					 else if(i==0) dp[i][j]=Math.min(dp[i][j-1],Math.abs(one.get(i)-zero.get(j)));
+					 else{
+						 dp[i][j]=Math.min(dp[i][j-1],dp[i-1][j-1]+Math.abs(one.get(i)-zero.get(j)));
+					 }
+				 }
+			 }
+
+		  System.out.println(dp[one.size()-1][zero.size()-1]);
+		}
+	}
+}
+","import java.io.*;
+import java.util.*;
+public class Main {
+    public static void main(String args[])
+    {
+        FastReader input=new FastReader();
+        PrintWriter out=new PrintWriter(System.out);
+        int T=1;
+        while(T-->0)
+        {
+            int n=input.nextInt();
+            int a[]=new int[n];
+            ArrayList<Integer> list=new ArrayList<>();
+            ArrayList<Integer> space=new ArrayList<>();
+            for(int i=0;i<n;i++)
+            {
+                a[i]=input.nextInt();
+                if(a[i]==1)
+                {
+                    list.add(i);
+                }
+                else
+                {
+                    space.add(i);
+                }
+            }
+            int pre[]=new int[space.size()];
+            for(int i=0;i<list.size();i++)
+            {
+                if(i==0)
+                {
+                    int min=Integer.MAX_VALUE;
+                    for(int j=0;j<space.size();j++)
+                    {
+                        pre[j]=Math.abs(list.get(i)-space.get(j));
+                        min=Math.min(min,pre[j]);
+                        pre[j]=min;
+                    }
+                }
+                else
+                {
+                    int arr[]=new int[space.size()];
+                    for(int j=0;j<i;j++)
+                    {
+                        arr[j]=Integer.MAX_VALUE;
+                    }
+
+                    int min=Integer.MAX_VALUE;
+                    for(int j=i;j<space.size();j++)
+                    {
+                        int v=Math.abs(list.get(i)-space.get(j));
+                        v+=pre[j-1];
+                        arr[j]=v;
+                        min=Math.min(min,v);
+                        arr[j]=min;
+                    }
+                    for(int j=0;j<space.size();j++)
+                    {
+                        pre[j]=arr[j];
+                    }
+                }
+            }
+            out.println(pre[space.size()-1]);
+        }
+        out.close();
+    }
+    static class FastReader
+    {
+        BufferedReader br;
+        StringTokenizer st;
+        public FastReader()
+        {
+            br = new BufferedReader(new InputStreamReader(System.in));
+        }
+        String next()
+        {
+            while (st == null || !st.hasMoreElements())
+            {
+                try
+                {
+                    st = new StringTokenizer(br.readLine());
+                }
+                catch (IOException e)
+                {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+        int nextInt()
+        {
+            return Integer.parseInt(next());
+        }
+        long nextLong()
+        {
+            return Long.parseLong(next());
+        }
+        double nextDouble()
+        {
+            return Double.parseDouble(next());
+        }
+        String nextLine()
+        {
+            String str="""";
+            try
+            {
+                str=br.readLine();
+            }
+            catch (IOException e)
+            {
+                e.printStackTrace();
+            }
+            return str;
+        }
+    }
+}",0
+7011024d,eea69e7f,"import java.util.*;
+
+public class D {
+
+    public static void main(String[] args) {
+        Scanner scanner = new Scanner(System.in);
+        int n = scanner.nextInt();
+        ArrayList<Integer> occupied = new ArrayList<>();
+        ArrayList<Integer> vacant = new ArrayList<>();
+        for (int i = 0; i < n; i++) {
+            int x = scanner.nextInt();
+            if (x == 1)
+                occupied.add(i);
+            else
+                vacant.add(i);
+        }
+
+        Solution Solution = new Solution(occupied, vacant);
+
+//        System.out.println(Solution.tabulation());
+        System.out.println(Solution.memoization());
+    }
+}
+
+class Solution {
+
+    ArrayList<Integer> occupied, vacant;
+    int x, y;
+
+    public Solution(ArrayList<Integer> occupied, ArrayList<Integer> vacant) {
+        this.occupied = occupied;
+        this.vacant = vacant;
+        x = occupied.size(); y = vacant.size();
+    }
+
+    int tabulation() {
+        return tabulation(x, y);
+    }
+
+    int tabulation(int x, int y) {
+        int[][] dp = new int[x+1][y+1];
+        for (int i = 0; i <= x; i++) {
+            Arrays.fill(dp[i], Integer.MAX_VALUE/2);
+        }
+        for (int i = 0; i <= x; i++) {
+            dp[i][0] = 0;
+        }
+        for (int i = 0; i <= y; i++) {
+            dp[0][i] = 0;
+        }
+        
+        for (int i = 1; i <= x; i++) {
+            for (int j = 1; j <= y; j++) {
+                if(i == j) {
+                    dp[i][j] = dp[i-1][j-1] + Math.abs(occupied.get(i-1) - vacant.get(j-1));
+                }
+                else {
+                    dp[i][j] = Math.min(dp[i][j-1], dp[i-1][j-1] + Math.abs(occupied.get(i-1) - vacant.get(j-1)));
+                }
+            }
+        }
+        return dp[x][y];
+    }
+
+    int memoization() {
+        int[][] dp = new int[x][y];
+        for (int i = 0; i < x; i++) {
+            Arrays.fill(dp[i], -1);
+        }
+        return memoization(dp, x-1, y-1);
+    }
+
+    int memoization(int[][] dp, int n, int m) {
+        if(n < 0) {
+            return 0;
+        }
+        if(m < n) {
+            return Integer.MAX_VALUE;
+        }
+        if(dp[n][m] != -1) {
+            return dp[n][m];
+        }
+        int first = memoization(dp, n, m-1);
+        int second = memoization(dp, n-1, m-1) + Math.abs(occupied.get(n) - vacant.get(m));
+        dp[n][m] = Math.min(first, second);
+        return dp[n][m];
+    }
+}","import java.util.*;
+
+public class Solution {
+	
+	public static int minMoves(int[] input) {
+		List<Integer> people = new ArrayList<Integer>();
+		List<Integer> chairs = new ArrayList<Integer>();
+		
+		for (int i = 0; i < input.length; i++) {
+			if (input[i] == 1) {
+				people.add(i);
+			} else {
+				chairs.add(i);
+			}
+		}
+		
+		int[] memo = new int[chairs.size() + 1];
+		
+
+		for (int p = 1; ((!people.isEmpty()) && (p <= people.size())); p++) {
+			int prev = memo[p];
+			memo[p] = memo[p - 1] + Math.abs(people.get(p - 1) - chairs.get(p - 1));
+			for (int c = p + 1; c <= chairs.size(); c++) {
+				int tmp = memo[c];
+				memo[c] = Math.min(memo[c - 1], prev + Math.abs(people.get(p - 1) - chairs.get(c - 1)));
+				prev = tmp;
+			}
+		}
+		return memo[memo.length - 1];
+	}
+	
+	
+	public static void main(String[] args) {
+		Scanner sc = new Scanner(System.in);
+		int n = sc.nextInt();
+		int[] input = new int[n];
+		for (int i = 0; i < n; i++) {
+			input[i] = sc.nextInt();
+		}
+		
+		System.out.println(Solution.minMoves(input));
+		
+	}
+}",0
+169e34bf,ba468e1f,"import java.util.*;
+public class D{
+  static Scanner sc;
+  public static void solve(){
+    int n=sc.nextInt();
+    Integer a[]=new Integer[n];
+    int flag;
+    for(int i=0;i<n;i++) a[i]=sc.nextInt();
+    String s=sc.next();
+    ArrayList<Integer> x=new ArrayList<>();
+    ArrayList<Integer> y=new ArrayList<>();
+    for(int i=0;i<n;i++){
+      if(s.charAt(i)=='B') x.add(a[i]);
+      else y.add(a[i]);
+    }
+    Collections.sort(x);
+    Collections.sort(y);
+    int p=n;
+    int q=1;
+    for(int i=y.size()-1;i>=0;i--){
+      if(y.get(i)>p){System.out.println(""NO""); return;}
+      p-=1;
+    }
+    for(int i=0;i<x.size();i++){
+      if(x.get(i)<q){System.out.println(""NO""); return;}
+      q+=1;
+    }
+    System.out.println(""YES"");
+  }
+  public static void main(String args[]){
+      sc=new Scanner(System.in);
+      int t=sc.nextInt();
+      while(t-->0) solve();
+  }
+}
+","import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.*;
+
+public class Codeforces {
+    public static void main(String[] args) {
+        FastReader fastReader = new FastReader();
+        int t = fastReader.nextInt();
+        while (t-- > 0) {
+            int n = fastReader.nextInt();
+
+            int a[] = new int[n];
+            for (int i = 0; i < n; i++) {
+                a[i] = fastReader.nextInt();
+            }
+            ArrayList<Integer> b = new ArrayList<>();
+            ArrayList<Integer> r = new ArrayList<>();
+            char c[] = fastReader.next().toCharArray();
+            for (int i = 0; i < n; i++) {
+                if (c[i] == 'B') {
+                    b.add(a[i]);
+                } else {
+                    r.add(a[i]);
+                }
+            }
+
+            Collections.sort(b);
+            Collections.sort(r);
+            int sizeb = b.size();
+
+            boolean isValid = true;
+            for (int i = 1 , j = 0; i <=sizeb; i++ , j++){
+                if (b.get(j) <  i){
+                    isValid =false;
+                }
+            }
+
+            for (int i = sizeb+1 , j = 0; i <=n && j < r.size(); i++ , j++){
+                if (r.get(j) >  i){
+                    isValid =false;
+                }
+            }
+
+            if (isValid){
+                System.out.println(""YES"");
+            }else{
+                System.out.println(""NO"");
+            }
+        }
+
+
+    }
+
+    static class FastReader {
+
+
+        BufferedReader br;
+        StringTokenizer st;
+
+        public FastReader() {
+            br = new BufferedReader(
+                    new InputStreamReader(System.in));
+        }
+
+        String next() {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+
+        String nextLine() {
+            String str = """";
+            try {
+                str = br.readLine();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+        }
+    }
+}
+",0
+0048a372,0adb1ee5,"import java.io.*;
+import java.util.*;
+
+public class AirConditioners {
+    public static long[] solve(int n, int k, HashMap<Integer, Integer> store) {
+        long[] result = new long[n];
+        Arrays.fill(result, Integer.MAX_VALUE);
+        long current = Integer.MAX_VALUE;
+        for (int i = 0; i < n; i++) {
+            current++;
+            if (store.containsKey(i)) {
+                current = Math.min(current, store.get(i));
+            }
+
+            result[i] = Math.min(result[i], current);
+        }
+        current = Integer.MAX_VALUE;
+        for (int i = n - 1; i >= 0; i--) {
+            current++;
+            if (store.containsKey(i)) {
+                current = Math.min(current, store.get(i));
+            }
+            result[i] = Math.min(result[i], current);
+        }
+        return result;
+    }
+
+    public static void main(String[] args) {
+        FastScanner fs = new FastScanner();
+        PrintWriter out = new PrintWriter(System.out);
+        int test = fs.nextInt();
+        for (int t = 0; t < test; t++) {
+            int n = fs.nextInt();
+            int k = fs.nextInt();
+            int[] array = fs.readArray(k);
+            int[] temperature = fs.readArray(k);
+            HashMap<Integer, Integer> store = new HashMap<>();
+            for (int i = 0; i < k; i++) {
+                store.put(array[i] - 1, temperature[i]);
+            }
+            long[] ans = solve(n, k, store);
+            for (int i = 0; i < n; i++) {
+                out.print(ans[i] + "" "");
+            }
+            out.println();
+        }
+        out.println();
+        out.close();
+    }
+
+    static void sort(int[] a) {
+        ArrayList<Integer> l = new ArrayList<>();
+        for (int i : a)
+            l.add(i);
+        Collections.sort(l);
+        for (int i = 0; i < a.length; i++)
+            a[i] = l.get(i);
+    }
+
+    static class FastScanner {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st = new StringTokenizer("""");
+
+        String next() {
+            while (!st.hasMoreTokens())
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        int[] readArray(int n) {
+            int[] a = new int[n];
+            for (int i = 0; i < n; i++)
+                a[i] = nextInt();
+            return a;
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+    }
+
+}","// D
+import java.util.*;
+// import java.lang.*;
+import java.io.*;
+
+//           THIS TEMPLATE MADE BY AKSH BANSAL.
+
+public class Solution {
+    static class FastReader {
+        BufferedReader br;
+        StringTokenizer st;
+
+        public FastReader() {
+            br = new BufferedReader(new InputStreamReader(System.in));
+        }
+
+        String next() {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+
+        String nextLine() {
+            String str = """";
+            try {
+                str = br.readLine();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+        }
+    }
+    private static boolean[] isPrime;
+    private static void primes(){
+        int num = (int)1e6; // PRIMES FROM 1 TO NUM
+        isPrime = new boolean[num];
+     
+        for (int i = 2; i< isPrime.length; i++) {
+           isPrime[i] = true;
+        }
+        for (int i = 2; i< Math.sqrt(num); i++) {
+           if(isPrime[i] == true) {
+              for(int j = (i*i); j<num; j = j+i) {
+                 isPrime[j] = false;
+              }
+           }
+        }
+    }
+    static void sort(int a[]){
+        ArrayList<Integer> arr=new ArrayList<>();
+        for(int i=0;i<a.length;i++)
+        arr.add(a[i]);
+        Collections.sort(arr);
+        for(int i=0;i<a.length;i++)
+        a[i]=arr.get(i);
+        
+    }
+    static void sort(long a[]){
+        ArrayList<Long> arr=new ArrayList<>();
+        for(int i=0;i<a.length;i++)
+        arr.add(a[i]);
+        Collections.sort(arr);
+        for(int i=0;i<a.length;i++)
+        a[i]=arr.get(i);
+        
+    }
+    private static long gcd(long a, long b){
+        if(b==0)return a;
+        return gcd(b,a%b);
+    }
+    private static long pow(long x,long y){
+        if(y==0)return 1;
+        long temp = pow(x, y/2);
+        if(y%2==1){
+            return x*temp*temp;
+        }
+        else{
+            return temp*temp;
+        }
+    }
+    // static ArrayList<Integer>[] adj;
+    // static void getAdj(int n,int q, FastReader sc){
+    //     adj = new ArrayList[n+1];
+    //     for(int i=1;i<=n;i++){
+    //         adj[i] = new ArrayList<>();
+    //     }
+    //     for(int i=0;i<q;i++){
+    //         int a = sc.nextInt();
+    //         int b = sc.nextInt();
+
+    //         adj[a].add(b);
+    //         adj[b].add(a);
+    //     }
+    // }
+    static PrintWriter out;
+    static FastReader sc ;
+    public static void main(String[] args) throws IOException {
+        sc = new FastReader();
+        out = new PrintWriter(System.out);
+        // primes();
+        // ________________________________
+
+        int t = sc.nextInt();
+        StringBuilder output = new StringBuilder();
+
+        while (t-- > 0) {
+            int n= sc.nextInt();
+            int k= sc.nextInt();
+            long[][] arr = new long[k][2];
+            for(int i=0;i<k;i++){
+                arr[i][0] = sc.nextLong();
+            }
+            for(int i=0;i<k;i++){
+                arr[i][1] = sc.nextLong();
+            }
+            // output.append(solver()).append(""\n"");
+            solver(arr, k, n);
+        }
+
+        out.println(output);
+        // _______________________________
+
+        // int n = sc.nextInt();
+        // out.println(solver());
+        // ________________________________
+        out.flush();
+    }
+
+    public static void solver(long[][] arr, int k, int n) {
+        HashMap<Long, Long> map = new HashMap<>();
+        for(int i=0;i<k;i++){
+            map.put(arr[i][0]-1, arr[i][1]);
+        }
+
+        long cur = Integer.MAX_VALUE;
+        long[] left = new long[n];
+        long[] right = new long[n];
+
+        for(int i=0;i<n;i++){
+            long temp = Integer.MAX_VALUE;
+            if(map.containsKey((long)i)){
+                temp = map.get((long)i);
+            }
+            cur = Math.min(cur+1, temp);
+            left[i] = cur;
+            // System.out.println(""__""+ temp);
+        }
+
+        cur = Integer.MAX_VALUE;
+
+        for(int i=n-1;i>=0;i--){
+            long temp = Integer.MAX_VALUE;
+            if(map.containsKey((long)i)){
+                temp = map.get((long)i);
+            }
+            cur = Math.min(cur+1, temp);
+            right[i] = cur;
+        }
+        for(int i=0;i<n;i++){
+            out.print(Math.min(left[i], right[i])+"" "");
+        }
+        out.println();
+    }
+}",0
+3e93b259,e431de28,"import java.util.*;
+import java.io.*;
+public class Main
+{
+    static class FastReader 
+    { 
+        BufferedReader br; 
+        StringTokenizer st; 
+  
+        public FastReader() 
+        { 
+            br = new BufferedReader(new
+                     InputStreamReader(System.in)); 
+        } 
+  
+        String next() 
+        { 
+            while (st == null || !st.hasMoreElements()) 
+            { 
+                try
+                { 
+                    st = new StringTokenizer(br.readLine()); 
+                } 
+                catch (IOException  e) 
+                { 
+                    e.printStackTrace(); 
+                } 
+            } 
+            return st.nextToken(); 
+        } 
+  
+        int nextInt() 
+        { 
+            return Integer.parseInt(next()); 
+        } 
+  
+        long nextLong() 
+        { 
+            return Long.parseLong(next()); 
+        } 
+  
+        double nextDouble() 
+        { 
+            return Double.parseDouble(next()); 
+        } 
+  
+        String nextLine() 
+        { 
+            String str = """"; 
+            try
+            { 
+                str = br.readLine(); 
+            } 
+            catch (IOException e) 
+            { 
+                e.printStackTrace(); 
+            } 
+            return str; 
+        } 
+    }
+    static class Pair implements Comparable<Pair>
+    {
+        int f,s;
+        Pair(int f,int s)
+        {
+            this.f=f;
+            this.s=s;
+        }
+        public int compareTo(Pair p)
+        {
+            return this.f-p.f;
+        }
+    }
+    public static void main(String args[])
+    {
+        FastReader fs=new FastReader();
+        PrintWriter pw=new PrintWriter(System.out);
+        int tc=fs.nextInt();
+        while(tc-->0)
+        {
+            int n=fs.nextInt();
+            long a[]=new long[n];
+            for(int i=0;i<n;i++)
+            a[i]=fs.nextLong();
+            long minans=a[0]*n+a[1]*n;
+            long sum=a[0]+a[1];
+            long min1=a[0],min2=a[1];
+            for(int i=2;i<n;i++)
+            {
+                sum+=a[i];
+                if(i%2==0)
+                min1=Math.min(min1,a[i]);
+                else
+                min2=Math.min(min2,a[i]);
+                long tsum=sum-min1-min2;
+                if(i%2==0)
+                tsum=tsum+(n-i/2+1)*min2+(n-i/2)*min1;
+                else
+                tsum=tsum+(min1+min2)*(n-((i+1)/2)+1);
+                
+                minans=Math.min(minans,tsum);
+                //minans=Math.min(minans,(n-cnt1)*a[i]+(n-cnt2)*a[i-1]+sum);
+            }
+            pw.println(minans);
+        }
+        pw.flush();
+        pw.close();
+    }
+}","import java.io.*;
+import java.lang.*;
+import java.util.*;
+public class MinGridPath {
+
+	public static void main(String[] args) {
+		// TODO Auto-generated method stub
+		Scanner s=new Scanner(System.in);
+		int t=s.nextInt();
+		while(t-->0){
+			
+			int n = s.nextInt();
+			long[] aa =new long[n];
+			for(int i=0;i<n;i++)
+				aa[i]=s.nextLong();
+ 
+			long minEven = aa[0];
+			long minOdd = aa[1];
+			long sum = aa[0]+aa[1];
+			long best = n*minEven + n*minOdd;
+			int numOdd = 1;
+			int numEven = 1;
+			for(int i=2; i<n; ++i) {
+				if(i%2 == 0) {
+					minEven = Math.min(aa[i], minEven);
+					numEven++;
+				}else {
+					minOdd = Math.min(aa[i], minOdd);
+					numOdd++;
+				}
+				sum += aa[i];
+				long score = sum;
+				score += minEven*(n-numEven);
+				score += minOdd*(n-numOdd);				
+				best = Math.min(best, score);
+			}
+			System.out.println(best);
+			
+		}
+	}
+
+}
+",0
+8639f6c6,e18ae6a1,"import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.StringTokenizer;
+
+/**
+ * Created by dhruvthakker on 01/10/21 at 9:42 am
+ */
+public class Season2 {
+    static InputReader in = new InputReader();
+    static PrintWriter out = new PrintWriter(System.out);
+
+    public static void main(String args[]) {
+        int t = in.nextInt();
+        while (t-- > 0) {
+            int n = in.nextInt();
+            int air = in.nextInt();
+            Map<Integer, Integer> tempByIndex = new HashMap<>();
+            int inx[] = new int[air];
+            for (int i = 0; i < air; i++) {
+                int x = in.nextInt() - 1;
+                tempByIndex.put(x, 0);
+                inx[i] = x;
+            }
+            for (int i = 0; i < air; i++) {
+                tempByIndex.put(inx[i], in.nextInt());
+            }
+
+            long leftMax[] = new long[n];
+            long rightMax[] = new long[n];
+
+            leftMax[0] = tempByIndex.getOrDefault(0, Integer.MAX_VALUE);
+            rightMax[n - 1] = tempByIndex.getOrDefault(n - 1, Integer.MAX_VALUE);
+            for (int i = 1; i < n; i++) {
+                leftMax[i] = Math.min(leftMax[i - 1] + 1, tempByIndex.getOrDefault(i, Integer.MAX_VALUE));
+                rightMax[n - 1 - i] = Math.min(rightMax[n - i] + 1, tempByIndex.getOrDefault(n - 1 - i, Integer.MAX_VALUE));
+            }
+            for (int i = 0; i < n; i++) {
+                long ans = Math.min(leftMax[i], rightMax[i]);
+                out.print(ans + "" "");
+            }
+            out.println();
+        }
+        out.flush();
+    }
+
+    static void debug(Object... o) {
+        System.out.println(Arrays.deepToString(o));
+    }
+
+    static class InputReader {
+        BufferedReader br;
+        StringTokenizer st;
+
+        public InputReader() {
+            br = new BufferedReader(new
+                    InputStreamReader(System.in));
+        }
+
+        String next() {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+
+        String nextLine() {
+            String str = """";
+            try {
+                str = br.readLine();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+        }
+    }
+}
+","
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.*;
+
+public class Main
+{
+ 
+    public static void main(String[] args)
+    {
+      FastScanner input = new FastScanner();
+        int tc = input.nextInt();
+        while (tc-- > 0) {
+         int n = input.nextInt();
+      int k = input.nextInt();
+      int a[] = new int[n+1];
+      int b[] = new int[k+1];
+        for (int i = 1; i <=k; i++) {
+            b[i] = input.nextInt();
+            
+        }
+        Arrays.fill(a, Integer.MAX_VALUE);
+        for (int i = 1; i <=k; i++) {
+           int value = input.nextInt();
+           a[b[i]] = value;
+            
+        }
+//        System.out.println(Arrays.toString(a));
+        long L[] = new long[n+1];
+        long R[] = new long[n+1];
+        Arrays.fill(L, Integer.MAX_VALUE);
+        Arrays.fill(R, Integer.MAX_VALUE);
+        long p = Integer.MAX_VALUE;
+        for (int i = 1; i <=n; i++) {
+             p = Math.min(p+1, a[i]);
+             L[i] = p;
+        }
+        p = Integer.MAX_VALUE;
+        for (int i = n; i >=1; i--) {
+            p = Math.min(p+1,a[i] );
+            R[i] = p;
+        }
+//        System.out.println(Arrays.toString(L));
+//        System.out.println(Arrays.toString(R));
+        long ans[] = new long[n+1];
+        for (int i = 1; i <=n; i++) {
+            ans[i] = Math.min(L[i], R[i]);
+        }
+        StringBuilder result = new StringBuilder();
+        for (int i = 1; i <=n; i++) {
+         result.append(ans[i]+"" "");
+        }
+        System.out.println(result);   
+        }
+      
+    }
+
+    
+
+    static class FastScanner
+    {
+
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st = new StringTokenizer("""");
+
+        String next()
+        {
+            while (!st.hasMoreTokens()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt()
+        {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong()
+        {
+
+            return Long.parseLong(next());
+        }
+
+        double nextDouble()
+        {
+            return Double.parseDouble(next());
+        }
+
+        String nextLine() throws IOException
+        {
+            return br.readLine();
+        }
+    }
+
+}
+",0
+ccc8ef27,f7a0ea6d,"import java.util.*;
+public class Sol
+{
+    public static void main(String[] args)
+    {
+        Scanner sc = new Scanner(System.in);
+        int t = sc.nextInt();
+        while(t-->0)
+        {
+			int n = sc.nextInt();
+			int a[][]=new int[n][5];
+			int tot[]=new int[n];
+			for(int i=0;i<n;i++)
+			{
+				String x = sc.next();
+				for(int j=0;j<x.length();j++)
+					a[i][x.charAt(j)-'a'] += 1;
+				tot[i]=x.length();
+			}
+			
+			int max=Integer.MIN_VALUE;
+			for(int i=0;i<5;i++)
+				max=Math.max(max,function(a,n,i,tot));
+			System.out.println(max);
+			
+		}	
+    }
+	static int function(int a[][],int n,int i,int tot[])
+	{
+		Integer ans[] = new Integer[n];
+		for(int j=0;j<n;j++)
+			ans[j]=a[j][i]-(tot[j]-a[j][i]);
+		int res=0,j=0;
+		Arrays.sort(ans,Collections.reverseOrder());
+		while(j<n&&res+ans[j]>0)
+			res+=ans[j++];
+		return j;
+	}
+}","import java.util.*;
+
+public class Solution {
+	
+	private static Scanner in = new Scanner(System.in);
+	
+	public static void main(String args[]) {
+		
+		int t = in.nextInt();
+		
+		while(t-->0) {
+			solution();
+		}
+	}
+	
+	private static void solution() {
+		
+		int ans=0;
+		int n = in.nextInt();
+		String s[] = new String[n];
+		int occurance[][] = new int[n][5];
+		for(int i=0;i<n;i++) {
+			s[i] = in.next();
+			for(int j=0;j<s[i].length();j++) {
+				occurance[i][s[i].charAt(j)-'a']++;
+			}
+		}
+		
+//		for(int i=0;i<n;i++)
+//		{
+//			for(int j=0;j<5;j++)
+//				System.out.println(occurance[i][j]);
+//			System.out.println();
+//		}
+		
+		for(int i=0;i<5;i++) {
+			int arr[] = new int[n];
+			for(int j=0;j<n;j++) {
+				arr[j] = s[j].length() - (2 * occurance[j][i]);
+			}
+			Arrays.sort(arr);
+			
+//			for(int j=0;j<n;j++)
+//				System.out.println(arr[j]);
+			
+			int temp=0;
+			int count=0;
+			for(int j=0;j<n;j++) {
+				if(temp+arr[j] < 0)
+				{
+					count++;
+					temp += arr[j];
+				}
+				else 
+					break;
+			}
+			ans = Math.max(ans, count);
+		}
+		System.out.println(ans);
+	}
+}",0
+3ef54b1a,bac616ee,"import java.io.*;
+import java.util.*;
+
+public class Main {
+    public static void main(String[] args) {
+        FastIO fio = new FastIO();
+
+        int t = fio.nextInt();
+
+        for (int i = 0; i < t; i++) {
+            int n = fio.nextInt();
+            ArrayList<ArrayList<Tuple>> adjList = new ArrayList<>();
+
+            for (int j = 0; j < n; j++) {
+                adjList.add(new ArrayList<>());
+            }
+
+            for (int j = 0; j < n - 1; j++) {
+                int u = fio.nextInt() - 1;
+                int v = fio.nextInt() - 1;
+                adjList.get(u).add(new Tuple(v, j));
+                adjList.get(v).add(new Tuple(u, j));
+            }
+
+            boolean possible = true;
+
+            for (ArrayList<Tuple> neighbours : adjList) {
+                if (neighbours.size() > 2) {
+                    possible = false;
+                    break;
+                }
+            }
+
+            if (!possible) {
+                fio.println(-1);
+                continue;
+            }
+
+            int[] assignments = new int[n - 1];
+            boolean[] visited = new boolean[n];
+            visited[0] = true;
+            Queue<Integer> queue = new LinkedList<>();
+            queue.offer(0);
+
+            while (!queue.isEmpty()) {
+                int u = queue.poll();
+                List<Tuple> neighbors = adjList.get(u);
+
+                for (int j = 0; j < neighbors.size(); j++) {
+                    Tuple tt = neighbors.get(j);
+                    int pi = j;
+
+                    if (neighbors.size() == 2 && visited[neighbors.get(1 - j).v]) {
+                        pi = 1 - assignments[neighbors.get(1 - j).num];
+                    }
+
+                    if (!visited[tt.v]) {
+                        assignments[tt.num] = pi;
+                        visited[tt.v] = true;
+                        queue.offer(tt.v);
+                    }
+                }
+            }
+
+            for (int j = 0; j < n - 1; j++) {
+                if (j > 0) {
+                    fio.print("" "");
+                }
+
+                fio.print(assignments[j] == 0 ? 2 : 3);
+            }
+
+            fio.println();
+        }
+
+        fio.close();
+    }
+}
+
+class Tuple {
+    int v, num;
+
+    Tuple(int v, int num) {
+        this.v = v;
+        this.num = num;
+    }
+}
+
+class State {
+    int u;
+    int i;
+
+    State(int u, int i) {
+        this.u = u;
+        this.i = i;
+    }
+}
+
+/**
+ * Fast I/O
+ * @source https://www.geeksforgeeks.org/fast-io-in-java-in-competitive-programming/
+ */
+class FastIO extends PrintWriter 
+{ 
+    BufferedReader br; 
+    StringTokenizer st;
+
+    public FastIO() 
+    { 
+        super(new BufferedOutputStream(System.out)); 
+        br = new BufferedReader(new
+                InputStreamReader(System.in));
+    } 
+
+    String next() 
+    { 
+        while (st == null || !st.hasMoreElements()) 
+        { 
+            try
+            { 
+                st = new StringTokenizer(br.readLine()); 
+            } 
+            catch (IOException  e) 
+            { 
+                e.printStackTrace(); 
+            } 
+        } 
+        return st.nextToken(); 
+    } 
+
+    int nextInt() 
+    { 
+        return Integer.parseInt(next()); 
+    } 
+
+    long nextLong() 
+    { 
+        return Long.parseLong(next()); 
+    } 
+
+    double nextDouble() 
+    { 
+        return Double.parseDouble(next()); 
+    } 
+
+    String nextLine() 
+    { 
+        String str = """"; 
+        try
+        { 
+            str = br.readLine(); 
+        } 
+        catch (IOException e) 
+        { 
+            e.printStackTrace(); 
+        } 
+        return str; 
+    } 
+}
+
+","import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+import java.util.StringTokenizer;
+
+public class NotAssigning {
+	
+	static class FastReader {
+		
+        BufferedReader br;
+        StringTokenizer st;
+ 
+        public FastReader() {
+        	
+            br = new BufferedReader(new InputStreamReader(System.in));
+            
+        }
+ 
+        String next() {
+        	
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                }
+                catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+            
+        }
+ 
+        int nextInt() {
+        	
+        	return Integer.parseInt(next());
+        	
+        }
+ 
+        long nextLong() {
+        	
+        	return Long.parseLong(next());
+        	
+        }
+        
+        double nextFloat() {
+        	
+        	return Float.parseFloat(next());
+        
+        }
+ 
+        double nextDouble() {
+        	
+        	return Double.parseDouble(next());
+        	
+        }
+ 
+        String nextLine() {
+        	
+            String str = """";
+            try {
+                str = br.readLine();
+            }
+            catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+            
+        }
+        
+        int[] nextArray(int n) {
+        	
+        	int[] a = new int[n];
+        	for (int i=0; i<n; i++) {
+        		a[i] = this.nextInt();
+        	}
+        	return a;
+        	
+        }
+        
+        long[] nextArrayLong(int n) {
+        	
+        	long[] a = new long[n];
+        	for (int i=0; i<n; i++) {
+        		a[i] = this.nextLong();
+        	}
+        	return a;
+        	
+        }
+        
+    }
+	
+	static class Pair {
+		
+		int a, b;
+
+		public Pair(int a, int b) {
+			
+			this.a = a;
+			this.b = b;
+			
+		}
+
+	}
+	
+	static boolean vis[];
+	public static void dfs(ArrayList<ArrayList<Pair>> t, int cur, boolean mode, int[] w) {
+		vis[cur] = true;
+		for (Pair p : t.get(cur)) {
+			if (!vis[p.a]) {
+				if (mode) {
+					w[p.b] = 3;
+				}
+				else {
+					w[p.b] = 2;
+				}
+				dfs(t, p.a, !mode, w);
+			}
+		}
+	}
+	
+	public static void solve(int n, int[] u, int[] v) {
+		
+		ArrayList<ArrayList<Pair>> t = new ArrayList<ArrayList<Pair>>(n);
+		for (int i=0; i<n; i++) {
+			t.add(new ArrayList<Pair>());
+		}
+		for (int i=0; i<n-1; i++) {
+			t.get(u[i]).add(new Pair(v[i], i));
+			t.get(v[i]).add(new Pair(u[i], i));
+		}
+		int start = 0;
+		for (int i=0; i<n; i++) {
+			if (t.get(i).size() > 2) {
+				System.out.println(""-1"");
+				return;
+			}
+			if (t.get(i).size() == 1) {
+				start = i;
+			}
+		}
+		vis = new boolean[n];
+		int[] w = new int[n-1];
+		dfs(t, start, false, w);
+		StringBuilder ans = new StringBuilder();
+		for (int i=0; i<n-1; i++) {
+			ans.append(w[i]).append("" "");
+		}
+		System.out.println(ans);
+		
+	}
+
+	public static void main(String[] args) {
+		
+		FastReader in = new FastReader();
+		int t = in.nextInt();
+		while (t-- > 0) {
+			int n = in.nextInt();
+			int[] u = new int[n-1];
+			int[] v = new int[n-1];
+			for (int i=0; i<n-1; i++) {
+				u[i] = in.nextInt()-1;
+				v[i] = in.nextInt()-1;
+			}
+			solve(n, u, v);
+		}
+
+	}
+
+}
+",0
+1f257299,76b978c2,"import java.lang.reflect.Array;
+import java.util.*;
+import java.io.*;
+
+//import static com.sun.tools.javac.jvm.ByteCodes.swap;
+
+
+
+
+public class fastTemp {
+
+
+    static FastScanner fs = null;
+
+    static int bit[][];
+    static int c1;
+    static int c2;
+    public static void main(String[] args) {
+        fs = new FastScanner();
+        PrintWriter out = new PrintWriter(System.out);
+
+        int t = fs.nextInt();
+        while (t-- > 0) {
+            int n = fs.nextInt();
+           int p[] = new int[n];
+           Arrays.fill(p,-1);
+           for(int i=0;i<n;i++){
+               if(p[i]!=-1){
+                   continue;
+               }
+               System.out.println(""? ""+(i+1));
+               int ans = (i+1);
+               int x = fs.nextInt();
+               while(p[x-1]==-1){
+                   System.out.println(""? ""+(i+1));
+                   int last = fs.nextInt();
+                   p[x-1] = last;
+                   x = last;
+               }
+
+           }
+            System.out.print(""! "");
+           for(int i=0;i<n;i++){
+               System.out.print(p[i]+"" "");
+           }
+
+            System.out.flush();
+
+        }
+    }
+
+    public static boolean binary (int l,int h,long k ){
+
+        while(l<=h){
+            int m = (l+h)/2;
+            if(m*m==k){
+                return true;
+            }else if(m*m<k){
+                l = m+1;
+            }else{
+                h = m-1;
+            }
+
+        }
+        return false;
+    }
+    public static void solve1(int i,int c1){
+        for(int j=0;j < bit.length;j++){
+            if(j==c1){
+                bit[j][i] = 1;
+            }else{
+                bit[j][i] = 0;
+            }
+        }
+
+    }
+
+    public static void solve30(int i,int c2){
+        for(int j=0;j< bit.length;j++){
+//            if(j>=c2 || j>=bit.length-2){
+//                bit[j][i] = 1;
+//            }else{
+            bit[j][i] = 1;
+
+            // }
+
+        }}
+
+    public static void solve0(int i,int c2){
+        int val = bit.length/18;
+
+        for(int j=0;j< bit.length;j++){
+             if(j==c2 && j<bit.length-1){
+                 bit[j][i] = 1;
+                 bit[j+1][i] = 1;
+                 j += 1;
+             }else{
+                 bit[j][i] = 0;
+             }
+
+        }}
+
+    public static void union(int a,int b,int rank[],int [] p){
+        int x = get(a,rank,p);
+        int y = get(b,rank,p);
+
+        if(rank[x]==rank[y]){
+            rank[x]++;
+        }
+
+        if(rank[x]>rank[y]){
+            p[y] = x;
+        }else{
+            p[x] = y;
+        }
+    }
+
+    public static int get(int a,int [] rank,int []p){
+        return p[a] = (p[a]==a)? a : get(p[a],rank,p);
+    }
+
+    public static long[] sort(long arr[]) {
+        List<Long> list = new ArrayList<>();
+        for(long i:arr)
+            list.add(i);
+        Collections.sort(list);
+        for(int i = 0;i<list.size();i++) {
+            arr[i] = list.get(i);
+        }
+        return arr;
+    }
+
+    static class p {
+        int id;
+        int id1;
+        p(int id,int id1){
+            this.id=id;
+            this.id1=id1;
+        }
+
+
+
+    }
+
+    static long power(long x, long y, long p)
+    {
+
+        // Initialize result
+        long res = 1;
+
+        // Update x if it is more than or
+        // equal to p
+        x = x % p;
+
+        while (y > 0) {
+
+            // If y is odd, multiply x
+            // with result
+            if (y % 2 == 1)
+                res = (res * x) % p;
+
+            // y must be even now
+            y = y >> 1; // y = y/2
+            x = (x * x) % p;
+        }
+
+        return res;
+    }
+
+    // Returns n^(-1) mod p
+    static long modInverse(long n, long p)
+    {
+        return power(n, p - 2, p);
+    }
+
+    // Returns nCr % p using Fermat's
+    // little theorem.
+
+    static long nCrModPFermat(long n, long r, long p)
+    {
+
+        if (n<r)
+            return 0;
+        // Base case
+        if (r == 0)
+            return 1;
+
+        // Fill factorial array so that we
+        // can find all factorial of r, n
+        // and n-r
+        long[] fac = new long[(int)n + 1];
+        fac[0] = 1;
+
+        for (int i = 1; i <= n; i++)
+            fac[i] = fac[i - 1] * i % p;
+
+        return (fac[(int)n] * modInverse(fac[(int)r], p) % p * modInverse(fac[(int)n - (int)r], p) % p) % p;
+    }
+
+
+//public static int dijkstra(int src , int dist[] ){
+//
+//PriorityQueue<Pair> q = new PriorityQueue<>();
+//q.add(new Pair(1,0));
+//
+//while(q.size()>0){
+//
+//    Pair rem = q.remove();
+//    for(Pair x:graph[rem.y]){
+//        if(dist[x.y]>dist[rem.y]+x.wt){
+//            dist[x.y] = dist[rem.y] + x.wt;
+//            q.add(new Pair(x.y,dist[x.y]));
+//        }
+//    }
+//
+//}
+//
+//return dist[dist.length-1];
+//
+//}
+    // T --> O(n) && S--> O(d)
+
+
+
+
+    public static int lower(long arr[], long key) {
+        int l = 0, r = arr.length-1;
+        long ans = -1;
+        while(l<=r) {
+            int mid = l +(r-l)/2;
+            if(arr[mid]<=key) {
+                ans = arr[mid];
+                l = mid+1;
+            }
+            else {
+                r = mid-1;
+            }
+        }
+        return l;
+    }
+
+    public static long upper(long arr[], long key) {
+        int l = 0, r = arr.length-1;
+        long ans = -1;
+        while(l<=r) {
+            int mid = l +(r-l)/2;
+            if(arr[mid] >= key) {
+                ans = arr[mid];
+                r = mid-1;
+            }
+            else {
+                l = mid+1;
+            }
+        }
+        return ans;
+    }
+
+
+
+    public static class String1 implements Comparable<String1>{
+        String str;
+        int id;
+        String1(String str , int id){
+            this.str = str;
+            this.id = id;
+        }
+        public  int compareTo(String1 o){
+            int i=0;
+            while(i<str.length() && str.charAt(i)==o.str.charAt(i)){
+                i++;
+            }
+            if(i<str.length()){
+                if(i%2==1){
+                    return o.str.compareTo(str);   // descending order
+                }else{
+                    return str.compareTo(o.str);  // ascending order
+                }
+            }
+            return str.compareTo(o.str);
+        }
+    }
+
+
+    static void sort(int[] a) {
+        ArrayList<Integer> l=new ArrayList<>();
+        for (int i:a) l.add(i);
+        Collections.sort(l);
+        for (int i=0; i<a.length; i++) a[i]=l.get(i);
+    }
+    static class FastScanner {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st = new StringTokenizer("""");
+
+        String next() {
+            while (!st.hasMoreTokens())
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        int[] readArray(int n) {
+            int[] a = new int[n];
+            for (int i = 0; i < n; i++) a[i] = nextInt();
+            return a;
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+    }
+    // ------------------------------------------swap----------------------------------------------------------------------
+
+    static void swap(int arr[],int i,int j)
+    {
+        int temp=arr[i];
+        arr[i]=arr[j];
+        arr[j]=temp;
+    }
+
+
+    //-------------------------------------------seiveOfEratosthenes----------------------------------------------------
+
+
+    static boolean prime[];
+    static void sieveOfEratosthenes(int n)
+    {
+        // Create a boolean array
+        // ""prime[0..n]"" and
+        // initialize all entries
+        // it as true. A value in
+        // prime[i] will finally be
+        // false if i is Not a
+        // prime, else true.
+        prime= new boolean[n + 1];
+        for (int i = 0; i <= n; i++)
+            prime[i] = true;
+
+        for (int p = 2; p * p <= n; p++)
+        {
+            // If prime[p] is not changed, then it is a
+            // prime
+            if (prime[p] == true)
+            {
+                // Update all multiples of p
+                for (int i = p * p; i <= n; i += p)
+                    prime[i] = false;
+            }
+        }
+
+        // Print all prime numbers
+//        for (int i = 2; i <= n; i++)
+//        {
+//            if (prime[i] == true)
+//                System.out.print(i + "" "");
+//        }
+    }
+
+
+
+    //------------------------------------------- power------------------------------------------------------------------
+
+
+
+    public static long power(int a , int b) {
+        if (b == 0) {
+            return 1;
+        } else if (b == 1) {
+            return a;
+
+        } else {
+
+            long R = power(a, b / 2);
+            if (b % 2 != 0) {
+
+
+                return (((power(a, b / 2))) * a * ((power(a, b / 2))));
+            } else {
+                return ((power(a, b / 2))) * ((power(a, b / 2)));
+            }
+        }
+
+    }
+    public static int log2(int x) {
+        return (int) (Math.log(x) / Math.log(2));
+    }
+
+    //---------------------------------------EXTENDED EUCLID ALGO--------------------------------------------------------
+//    public static class Pair{
+//        int x;
+//        int y;
+//        public Pair(int x,int y){
+//            this.x = x;
+//            this.y = y ;
+//        }
+//    }
+
+//    public static Pair Euclid(int a,int b){
+//
+//        if(b==0){
+//            return new Pair(1,0);  // answer of x and y
+//        }
+//
+//        Pair dash = Euclid(b,a%b);
+//
+//        return new Pair(dash.y , dash.x - (a/b)*dash.y);
+//
+//
+//    }
+//--------------------------------GCD------------------GCD-----------GCD--------------------------------------------
+
+    public static int gcd(int a,int b){
+        if(b==0){
+            return a;
+        }
+
+        return gcd(b,a%b);
+    }
+    public static void BFS(ArrayList<Integer>[] graph) {
+
+
+    }
+
+// This is an extension of method 2. Instead of moving one by one, divide the array in different sets
+//where number of sets is equal to GCD of n and d and move the elements within sets.
+//If GCD is 1 as is for the above example array (n = 7 and d =2), then elements will be moved within one set only, we just start with temp = arr[0] and keep moving arr[I+d] to arr[I] and finally store temp at the right place.
+//Here is an example for n =12 and d = 3. GCD is 3 and
+
+
+//     void leftRotate(int arr[], int d, int n)
+//     {
+//         /* To handle if d >= n */
+//         d = d % n;
+//         int i, j, k, temp;
+//         int g_c_d = gcd(d, n);
+//         for (i = 0; i < g_c_d; i++) {
+//             /* move i-th values of blocks */
+//             temp = arr[i];
+//             j = i;
+//             while (true) {
+//                 k = j + d;
+//                 if (k >= n)
+//                     k = k - n;
+//                 if (k == i)
+//                     break;
+//                 arr[j] = arr[k];
+//                 j = k;
+//             }
+//             arr[j] = temp;
+//         }
+//     }
+
+
+}
+// Fenwick / BinaryIndexed  Tree  USE IT - FenwickTree ft1=new FenwickTree(n);
+","import java.io.*;
+import java.util.*;
+public class check1  {
+
+//    public static void find(int n,int arr[])
+//    {
+//
+//    }
+//    2,1,3,4
+    public static void main(String[] args) throws IOException{
+
+        Reader sc=new Reader();
+//        PrintWriter out = new PrintWriter(System.out);
+
+        int t=sc.nextInt();
+        while(t-->0)
+        {
+            int n = sc.nextInt();
+            int p[]=new int[n];
+            System.out.println(""? 1"");
+            System.out.flush();
+            int t1 = sc.nextInt();
+
+            Set<Integer> hs = new HashSet<>();
+            int i=1;
+            int prev=1;
+            int cnt=1;
+            while(i<n && cnt<2*n)
+            { 
+                if(p[prev-1]!=0)
+                {
+                    i++;
+                    if(i>=n || cnt>=2*n) break;
+                    System.out.println(""? ""+i);
+                    System.out.flush();
+                    cnt++;
+
+                    int t2 = sc.nextInt();
+                    prev=t2;
+                    continue;
+                }
+                String s1 = ""? ""+i;
+                System.out.println(s1);
+                System.out.flush();
+                int tt = sc.nextInt();
+                
+                cnt++;                
+                p[prev-1]=tt;
+                prev=tt;
+            }
+            long sum=0;
+            int ind=-1;
+            for(i=0;i<n;i++)
+            {
+                sum+=p[i];
+                if(p[i]==0) ind=i;
+            }
+            long diff = n*(n+1)-sum*2;
+            if(diff>0)
+            {
+                p[ind]=(int)(diff/2);
+            }
+            System.out.print(""!"");
+            for(i=0;i<n;i++)
+            {
+                System.out.print("" ""+p[i]);
+            }
+
+//            out.println(Arrays.toString(p));
+            System.out.println();
+            System.out.flush();
+        }
+        System.out.flush();
+    }
+
+    public static long power(long x,long power)
+    {
+        if(power==0) return 1;
+
+        long ans1 = power(x,power/2);
+        ans1=ans1*ans1;
+
+        if(power%2==0) return ans1;
+        return x*ans1;
+    }
+
+    //    (a*a_inverse) = 1(mod m)
+//    finding a_inverse
+    public static long modInverse(long a,long m)
+    {
+//        works only when m is prime
+        long g=gcd(a,m);
+        if(g==1) return power(a,m-2,m);
+        else return -1;
+    }
+
+    //    (x^power)mod(m)
+    public static long power(long x,long power,long m)
+    {
+        if(power==0) return 1;
+
+        long p = power(x,power/2,m)%m;
+        p = (p*p)%m;
+
+        if(power%2==0) return p;
+        return (x*p)%m;
+    }
+    public static long gcd(long small,long large)
+    {
+        if(small==0) return large;
+        return gcd(large % small,small);
+    }
+
+    public static boolean isprime(long no)
+    {
+        if(no<=1) return false;
+        if(no<=3) return true;
+        if(no%2==0 || no%3==0) return false;
+        // 6k+1 6k+5 can be prime
+        for(long i=5;i*i<=no;i+=6)
+        {
+            if(no%(i)==0 || no%(i+2)==0)
+                return false;
+        }
+        return true;
+    }
+
+    //    prime no smaller than or equal to n
+    public static boolean[] prime_nos_till_no(int no)
+    {
+        boolean prime[]=new boolean[no+1];
+//        prime[i]== true means prime
+//        prime[i]== false means not a prime
+//        initialize prime array as true
+
+        Arrays.fill(prime,true);
+        prime[0]=false;
+        for(int i=2;i*i<=no;i++)
+        {
+            if(prime[i]==true)
+            {
+                for(int j=i*i;j<=no;j+=i)
+                {
+                    prime[j]=false;
+                }
+            }
+        }
+        return prime;
+
+    }
+    public static void shufflearray(long arr[])
+    {
+
+
+        int n=arr.length;
+        Random rand=new Random();
+        for(int i=0;i<n;i++)
+        {
+            long temp=arr[i];
+            int randomPos=i+rand.nextInt(n-i);
+            arr[i]=arr[randomPos];
+            arr[randomPos]=temp;
+        }
+    }
+    //       Arrays.sort(arr, new Comparator<pair>() {
+//        //@Override
+//        public int compare(pair o1, pair o2) {
+//            long l1=o1.a-o2.a;
+//            if(l1<0L) return -1;
+//            if(l1==0) return 0;
+//            return 1;
+//        }
+//    });
+    static class Reader {
+        final private int BUFFER_SIZE = 1 << 16;
+        private DataInputStream din;
+        private byte[] buffer;
+        private int bufferPointer, bytesRead;
+
+        public Reader() {
+            din = new DataInputStream(System.in);
+            buffer = new byte[BUFFER_SIZE];
+            bufferPointer = bytesRead = 0;
+        }
+
+        public Reader(String file_name) throws IOException {
+            din = new DataInputStream(new FileInputStream(file_name));
+            buffer = new byte[BUFFER_SIZE];
+            bufferPointer = bytesRead = 0;
+        }
+
+        public String nextLine() throws IOException {
+            byte[] buf = new byte[64]; // line length
+            int cnt = 0, c;
+            while ((c = read()) != -1) {
+                if (c == '\n')
+                    break;
+                buf[cnt++] = (byte) c;
+            }
+            return new String(buf, 0, cnt);
+        }
+        public boolean isSpaceChar(int c) {
+            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
+        }
+
+        public String next() throws IOException{
+            int c = read();
+            while (isSpaceChar(c)) c = read();
+            StringBuilder res = new StringBuilder();
+            do {
+                res.appendCodePoint(c);
+                c = read();
+            } while (!isSpaceChar(c));
+            return res.toString();
+        }
+
+
+        public int nextInt() throws IOException {
+            int ret = 0;
+            byte c = read();
+            while (c <= ' ')
+                c = read();
+            boolean neg = (c == '-');
+            if (neg)
+                c = read();
+            do {
+                ret = ret * 10 + c - '0';
+            } while ((c = read()) >= '0' && c <= '9');
+
+            if (neg)
+                return -ret;
+            return ret;
+        }
+
+        public long nextLong() throws IOException {
+            long ret = 0;
+            byte c = read();
+            while (c <= ' ')
+                c = read();
+            boolean neg = (c == '-');
+            if (neg)
+                c = read();
+            do {
+                ret = ret * 10 + c - '0';
+            }
+            while ((c = read()) >= '0' && c <= '9');
+            if (neg)
+                return -ret;
+            return ret;
+        }
+
+        public double nextDouble() throws IOException {
+            double ret = 0, div = 1;
+            byte c = read();
+            while (c <= ' ')
+                c = read();
+            boolean neg = (c == '-');
+            if (neg)
+                c = read();
+
+            do {
+                ret = ret * 10 + c - '0';
+            }
+            while ((c = read()) >= '0' && c <= '9');
+
+            if (c == '.') {
+                while ((c = read()) >= '0' && c <= '9') {
+                    ret += (c - '0') / (div *= 10);
+                }
+            }
+
+            if (neg)
+                return -ret;
+            return ret;
+        }
+
+        private void fillBuffer() throws IOException {
+            bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
+            if (bytesRead == -1)
+                buffer[0] = -1;
+        }
+
+        private byte read() throws IOException {
+            if (bufferPointer == bytesRead)
+                fillBuffer();
+            return buffer[bufferPointer++];
+        }
+
+        public void close() throws IOException {
+            if (din == null)
+                return;
+            din.close();
+        }
+
+    }
+
+}",0
+ad2a1ae2,bc46480a,"
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.*;
+import java.util.StringTokenizer;
+ 
+public class Solution {
+	 static class FastReader {
+	        BufferedReader br;
+	        StringTokenizer st;
+	 
+	        public FastReader()
+	        {
+	            br = new BufferedReader(
+	                new InputStreamReader(System.in));
+	        }
+	 
+	        String next()
+	        {
+	            while (st == null || !st.hasMoreElements()) {
+	                try {
+	                    st = new StringTokenizer(br.readLine());
+	                }
+	                catch (IOException e) {
+	                    e.printStackTrace();
+	                }
+	            }
+	            return st.nextToken();
+	        }
+	 
+	        int nextInt() { return Integer.parseInt(next()); }
+	 
+	        long nextLong() { return Long.parseLong(next()); }
+	 
+	        double nextDouble()
+	        {
+	            return Double.parseDouble(next());
+	        }
+	 
+	        String nextLine()
+	        {
+	            String str = """";
+	            try {
+	                str = br.readLine();
+	            }
+	            catch (IOException e) {
+	                e.printStackTrace();
+	            }
+	            return str;
+	        }}
+	 
+	public static void main(String[] args) {
+		FastReader sc = new FastReader();
+       
+        int t=sc.nextInt();
+       while(t-->0) {
+    	   int n=sc.nextInt();
+    	   int r[]=new int[n];
+    	   int l[]=new int[n];
+    	   for(int i=0;i<n;i++) {
+    		   r[i]=sc.nextInt();
+    	   }
+    	   for(int i=0;i<n;i++) l[i]=r[i]-sc.nextInt()+1;
+    	   long ans=0,min=l[n-1],max=r[n-1];
+    	   
+    	   for(int i=n-2;i>=0;i--) {
+    		   if(r[i]>=min) min=Math.min(min,l[i]);
+    		   else {
+    			   ans+=(max-min+1)*(max-min+2)/2;
+    			   max=r[i];
+    			   min=l[i];
+    		   }
+    		   
+    	   }
+    	   ans+=(max-min+1)*(max-min+2)/2;
+    	   System.out.println(ans);
+    	   
+    	   
+       }
+}	
+}
+","import java.io.IOException;
+import java.io.InputStream;
+import java.util.Arrays;
+import java.util.InputMismatchException;
+
+/**
+ * Accomplished using the EduTools plugin by JetBrains https://plugins.jetbrains.com/plugin/10081-edutools
+ */
+
+public class Main {
+   static InputReader sc=new InputReader(System.in);
+   public static void main(String[] args) {
+      // Write your solution here
+      int t=sc.nextInt();
+      while(t-->0){
+         solve();
+      }
+   }
+
+   private static void solve() {
+      int n=sc.nextInt();
+      Node left[]=new Node[n];
+      int index=0;
+      Node ini[]=new Node[n];
+      int tmp[]=new int[n];
+      for(int i=0;i<n;i++){
+         tmp[i]=sc.nextInt();
+      }
+      for(int i=0;i<n;i++){
+         ini[i]=new Node(tmp[i],tmp[i]-sc.nextInt()+1);
+      }
+      Arrays.sort(ini);
+      left[0]=ini[0];
+      for(int i=1;i<n;i++){
+         //System.out.println(ini[i].k+"" ""+ini[i].s);
+         if(ini[i].s<=left[index].k&&ini[i].k>left[index].k){
+            left[index].k=ini[i].k;
+         }else if(ini[i].s>left[index].k){
+            index++;
+            left[index]=ini[i];
+         }
+      }
+      long ans=0;
+      for(int i=0;i<=index;i++){
+         //System.out.println(left[i].k+"" ""+left[i].s);
+         ans+=(long)(left[i].k-left[i].s+2)*(left[i].k-left[i].s+1)/2;
+      }
+      System.out.println(ans);
+
+
+   }
+}
+class Node implements Comparable<Node>{
+   int k,s;
+   Node(int k,int s){
+      this.s=s;
+      this.k=k;
+   }
+   @Override
+   public int compareTo(Node node) {
+      return this.s-node.s;
+   }
+}
+class InputReader {
+
+   private final InputStream stream;
+   private final byte[] buf = new byte[8192];
+   private int curChar, snumChars;
+
+   public InputReader(InputStream st) {
+      this.stream = st;
+   }
+
+   public int read() {
+      if (snumChars == -1)
+         throw new InputMismatchException();
+      if (curChar >= snumChars) {
+         curChar = 0;
+         try {
+            snumChars = stream.read(buf);
+         } catch (IOException e) {
+            throw new InputMismatchException();
+         }
+         if (snumChars <= 0)
+            return -1;
+      }
+      return buf[curChar++];
+   }
+
+   public int nextInt() {
+      int c = read();
+      while (isSpaceChar(c)) {
+         c = read();
+      }
+      int sgn = 1;
+      if (c == '-') {
+         sgn = -1;
+         c = read();
+      }
+      int res = 0;
+      do {
+         res *= 10;
+         res += c - '0';
+         c = read();
+      } while (!isSpaceChar(c));
+      return res * sgn;
+   }
+
+   public long nextLong() {
+      int c = read();
+      while (isSpaceChar(c)) {
+         c = read();
+      }
+      int sgn = 1;
+      if (c == '-') {
+         sgn = -1;
+         c = read();
+      }
+      long res = 0;
+      do {
+         res *= 10;
+         res += c - '0';
+         c = read();
+      } while (!isSpaceChar(c));
+      return res * sgn;
+   }
+
+   public int[] nextIntArray(int n) {
+      int a[] = new int[n];
+      for (int i = 0; i < n; i++) {
+         a[i] = nextInt();
+      }
+      return a;
+   }
+
+   public String readString() {
+      int c = read();
+      while (isSpaceChar(c)) {
+         c = read();
+      }
+      StringBuilder res = new StringBuilder();
+      do {
+         res.appendCodePoint(c);
+         c = read();
+      } while (!isSpaceChar(c));
+      return res.toString();
+   }
+
+   public String nextLine() {
+      int c = read();
+      while (isSpaceChar(c))
+         c = read();
+      StringBuilder res = new StringBuilder();
+      do {
+         res.appendCodePoint(c);
+         c = read();
+      } while (!isEndOfLine(c));
+      return res.toString();
+   }
+
+   public boolean isSpaceChar(int c) {
+      return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
+   }
+
+   private boolean isEndOfLine(int c) {
+      return c == '\n' || c == '\r' || c == -1;
+   }
+
+}
+",0
+bdfe8110,fadc1365,"import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.StringTokenizer;
+
+public class E {
+
+	public static void main(String[] args) {
+		FastScanner fs=new FastScanner();
+		int T=fs.nextInt();
+		PrintWriter out=new PrintWriter(System.out);
+		for (int tt=0; tt<T; tt++) {
+			int n=fs.nextInt(), k=fs.nextInt();
+			int[] positions=fs.readArray(k), temps=fs.readArray(k);
+			int[] forced=new int[n];
+			Arrays.fill(forced, Integer.MAX_VALUE/2);
+			for (int i=0; i<k; i++) forced[positions[i]-1]=temps[i];
+			for (int i=1; i<n; i++)
+				forced[i]=Math.min(forced[i], forced[i-1]+1);
+			for (int i=n-2; i>=0; i--)
+				forced[i]=Math.min(forced[i], forced[i+1]+1);
+			for (int i=0; i<n; i++) out.print(forced[i]+"" "");
+			out.println();
+			
+		}
+		out.close();
+	}
+
+	static void sort(int[] a) {
+		ArrayList<Integer> l=new ArrayList<>();
+		for (int i:a) l.add(i);
+		Collections.sort(l);
+		for (int i=0; i<a.length; i++) a[i]=l.get(i);
+	}
+	
+	static class FastScanner {
+		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st=new StringTokenizer("""");
+		String next() {
+			while (!st.hasMoreTokens())
+				try {
+					st=new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			return st.nextToken();
+		}
+		
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+		int[] readArray(int n) {
+			int[] a=new int[n];
+			for (int i=0; i<n; i++) a[i]=nextInt();
+			return a;
+		}
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+	}
+
+	
+}
+
+","import java.io.PrintWriter;
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.*;
+public class a{ 
+    public static void main(String args[]) throws java.lang.Exception{ 
+    	FastScanner s=new FastScanner();
+		PrintWriter out=new PrintWriter(System.out);
+		int t=s.nextInt();
+		for(int tt=0;tt<t;tt++) {
+			int n=s.nextInt(),k=s.nextInt();
+			int pos[]=s.readArray(k);
+			int temp[]=s.readArray(k);
+			long ans[]=new long[n];
+			Arrays.fill(ans,Integer.MAX_VALUE);
+			for(int i=0;i<k;i++){
+				ans[pos[i]-1]=temp[i];
+			}
+			for(int i=1;i<n;i++){
+				ans[i]=Math.min(ans[i-1]+1,ans[i]);
+			}
+			for(int i=n-2;i>=0;i--){
+				ans[i]=Math.min(ans[i],ans[i+1]+1);
+			}
+			for(int i=0;i<n;i++){
+				out.print(ans[i]+"" "");
+			}
+			out.println();
+		}
+		out.close();
+    }
+	static boolean isPrime(int n){
+        if (n <= 1)
+            return false;
+        else if (n == 2)
+            return true;
+        else if (n % 2 == 0)
+            return false;
+        for (int i = 3; i <= Math.sqrt(n); i += 2){
+            if (n % i == 0)
+                return false;
+        }
+        return true;
+    }
+    static void sort(long [] a) {
+		ArrayList<Long> l=new ArrayList<>();
+		for (long i:a) l.add(i);
+		Collections.sort(l);
+		for (int i=0; i<a.length; i++) a[i]=l.get(i);
+	}
+	static void sort(char [] a) {
+		ArrayList<Character> l=new ArrayList<>();
+		for (char i:a) l.add(i);
+		Collections.sort(l);
+		for (int i=0; i<a.length; i++) a[i]=l.get(i);
+	}
+    static void sort(int [] a) {
+		ArrayList<Integer> l=new ArrayList<>();
+		for (int i:a) l.add(i);
+		Collections.sort(l);
+		for (int i=0; i<a.length; i++) a[i]=l.get(i);
+	}
+    static int gcd(int a, int b){
+      if (b == 0)
+        return a;
+      return gcd(b, a % b);
+    }
+    static void sortcol(int a[][],int c) {
+		Arrays.sort(a, (x, y) -> {
+			if(x[c]>y[c]) {
+				return 1;
+			}else {
+				return -1;
+			}
+		});
+	}
+    public static void printb(boolean ans) {
+    	if(ans) {
+    		System.out.println(""Yes"");
+    	}else {
+    		System.out.println(""No"");
+    	}
+    }
+    static class FastScanner {
+		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st=new StringTokenizer("""");
+		String next() {
+			while (!st.hasMoreTokens())
+				try {
+					st=new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			return st.nextToken();
+		}
+		double nextDouble() {
+			return Double.parseDouble(next());
+		}
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+		int[] readArray(int n) {
+			int[] a=new int[n];
+			for (int i=0; i<n; i++) a[i]=nextInt();
+			return a;
+		}
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+	}
+    static class Pair implements Comparable<Pair>{
+    	int a , b; 
+    	Pair(int x , int y){
+    		a=x;
+    		b=y;
+    	}
+    	public int compareTo(Pair o) {
+    		return a != o.a ? a - o.a : b - o.b;
+    	}
+    }
+}
+",1
+8a39dbf5,ff3283cf,"import java.util.*;
+import java.lang.*;
+import java.io.*;
+ 
+/* Name of the class has to be ""Main"" only if the class is public. */
+public class Codeforces {
+    public static void main(String[] args) throws java.lang.Exception {
+        /* your code goes here */
+        BufferedReader buf = new BufferedReader(new InputStreamReader(System.in));
+       int t = Integer.parseInt(buf.readLine());
+        StringBuilder sb = new StringBuilder();
+       for (int i = 0; i < t; i++) {
+           String st=buf.readLine();
+          String st1[]=(buf.readLine()).split("" "");
+          int n=Integer.parseInt(st1[0]);
+          int k=Integer.parseInt(st1[1]);
+          int a[]=new int[k];
+          int temp[]=new int[k];
+          long arr[]=new long[n];
+          String st2[]=(buf.readLine()).split("" "");
+           String st3[]=(buf.readLine()).split("" "");
+           for(int j=0;j<k;j++)
+           {
+               a[j]=Integer.parseInt(st2[j]);
+               temp[j]=Integer.parseInt(st3[j]);
+           }
+          for(int j=0;j<k;j++)
+          {
+              arr[a[j]-1]=temp[j];
+          }
+          long min=Integer.MAX_VALUE;
+          long left[]=new long[n];
+          long right[]=new long[n];
+          if(arr[0]==0)
+              left[0]=min;
+          else
+              left[0]=arr[0];
+          for(int j=1;j<n;j++)
+          {
+              if(arr[j]==0)
+              {
+                  left[j]=left[j-1]+1;
+              }
+              else
+              {
+                  left[j]=Math.min(left[j-1]+1,arr[j]);
+              }
+          }
+          if(arr[n-1]==0)
+              right[n-1]=min;
+          else
+              right[n-1]=arr[n-1];
+          for(int j=n-2;j>=0;j--)
+          {
+              if(arr[j]==0)
+              {
+                  right[j]=right[j+1]+1;
+              }
+              else
+              {
+                  right[j]=Math.min(right[j+1]+1,arr[j]);
+              }
+          }
+          for(int j=0;j<n;j++)
+          {
+              arr[j]=Math.min(left[j],right[j]);
+              sb.append(arr[j]+"" "");
+          }
+          sb.append(""\n"");
+        }
+        System.out.println(sb);
+    }
+}","import java.util.*;
+import java.lang.*;
+import java.io.*;
+
+/* Name of the class has to be ""Main"" only if the class is public. */
+public class Codeforces {
+    public static void main(String[] args) throws java.lang.Exception {
+        /* your code goes here */
+        BufferedReader buf = new BufferedReader(new InputStreamReader(System.in));
+       int t = Integer.parseInt(buf.readLine());
+        StringBuilder sb = new StringBuilder();
+       for (int i = 0; i < t; i++) {
+           String st=buf.readLine();
+          String st1[]=(buf.readLine()).split("" "");
+          int n=Integer.parseInt(st1[0]);
+          int k=Integer.parseInt(st1[1]);
+          int a[]=new int[k];
+          int temp[]=new int[k];
+          long arr[]=new long[n];
+          String st2[]=(buf.readLine()).split("" "");
+           String st3[]=(buf.readLine()).split("" "");
+           for(int j=0;j<k;j++)
+           {
+               a[j]=Integer.parseInt(st2[j]);
+               temp[j]=Integer.parseInt(st3[j]);
+           }
+          for(int j=0;j<k;j++)
+          {
+              arr[a[j]-1]=temp[j];
+          }
+          long min=Integer.MAX_VALUE;
+          long left[]=new long[n];
+          long right[]=new long[n];
+          if(arr[0]==0)
+              left[0]=min;
+          else
+              left[0]=arr[0];
+          for(int j=1;j<n;j++)
+          {
+              if(arr[j]==0)
+              {
+                  left[j]=left[j-1]+1;
+              }
+              else
+              {
+                  left[j]=Math.min(left[j-1]+1,arr[j]);
+              }
+          }
+          if(arr[n-1]==0)
+              right[n-1]=min;
+          else
+              right[n-1]=arr[n-1];
+          for(int j=n-2;j>=0;j--)
+          {
+              if(arr[j]==0)
+              {
+                  right[j]=right[j+1]+1;
+              }
+              else
+              {
+                  right[j]=Math.min(right[j+1]+1,arr[j]);
+              }
+          }
+          for(int j=0;j<n;j++)
+          {
+              arr[j]=Math.min(left[j],right[j]);
+              sb.append(arr[j]+"" "");
+          }
+          sb.append(""\n"");
+        }
+        System.out.println(sb);
+    }
+}",1
+10584086,f229aa7f,"import java.util.*;
+import java.io.*;
+
+public class _1615_C {
+    public static void main(String[] args) throws IOException {
+        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
+        PrintWriter out = new PrintWriter(System.out);
+        int t = Integer.parseInt(in.readLine());
+        while(t-- > 0) {
+            int n = Integer.parseInt(in.readLine());
+            String a = in.readLine();
+            String b = in.readLine();
+            int x = 0;
+            int y = 0;
+            int match = 0;
+            for(int i = 0; i < n; i++) {
+                if(a.charAt(i) == '1') {
+                    x++;
+                }
+                if(b.charAt(i) == '1') {
+                    y++;
+                }
+                if(a.charAt(i) == b.charAt(i)) {
+                    match++;
+                }
+            }
+            if(x != y && n - x + 1 != y) {
+                out.println(-1);
+            }else {
+                int moves = Integer.MAX_VALUE;
+                if(x == y) {
+                    int mismatch = n - match;
+                    moves = Math.min(moves, mismatch);
+                }
+                if(n - x + 1 == y) {
+                    moves = Math.min(moves, match);
+                }
+                out.println(moves);
+            }
+        }
+        in.close();
+        out.close();
+    }
+}
+","import java.util.*;
+import java.io.*;
+import java.math.*;
+
+public class cf {
+	static PrintWriter pw = new PrintWriter(System.out);
+
+	public static void main(String[] args) throws IOException, InterruptedException {
+		Scanner sc = new Scanner(System.in);
+		int t = sc.nextInt();
+		while (t-- > 0) {
+			int n = sc.nextInt();
+			char[] a = sc.next().toCharArray();
+			char[] b = sc.next().toCharArray();
+			int x = 0, y = 0, lit = 0,lit2 = 0;
+			for (int i = 0; i < n; i++) {
+				if (a[i] == '1')
+					lit++;
+				if (b[i] == '1')
+					lit2++;
+				if (a[i] == b[i])
+					x++;
+				else
+					y++;
+			}
+			if(lit == lit2 || n - lit + 1 == lit2) {
+				if (lit == lit2 && n - lit + 1 == lit2) {
+					pw.println(Math.min(x,y));
+				}else if(lit == lit2) {
+					pw.println(y);
+				}else {
+					pw.println(x);
+				}
+			}else {
+				pw.println(-1);
+			}
+		}
+		pw.close();
+	}
+
+	public static class tuble implements Comparable<tuble> {
+		int x;
+		int y;
+		int z;
+
+		public tuble(int x, int y, int z) {
+			this.x = x;
+			this.y = y;
+			this.z = z;
+		}
+
+		public String toString() {
+			return x + "" "" + y + "" "" + z;
+		}
+
+		public int compareTo(tuble other) {
+			if (this.x == other.x) {
+				if (this.y == other.y)
+					return this.z - other.z;
+				return this.y - other.y;
+			} else {
+				return this.x - other.x;
+			}
+		}
+	}
+
+	public static class pair implements Comparable<pair> {
+		int x;
+		int y;
+
+		public pair(int x, int y) {
+			this.x = x;
+			this.y = y;
+		}
+
+		public String toString() {
+			return x + "" "" + y;
+		}
+
+		public boolean equals(Object o) {
+			if (o instanceof pair) {
+				pair p = (pair) o;
+				return p.x == x && p.y == y;
+			}
+			return false;
+		}
+
+		public int hashCode() {
+			return new Integer(x).hashCode() * 31 + new Integer(y).hashCode();
+		}
+
+		public int compareTo(pair other) {
+			if (this.x == other.x) {
+				return Long.compare(this.y, other.y);
+			}
+			return Long.compare(this.x, other.x);
+		}
+	}
+
+	static class Scanner {
+		StringTokenizer st;
+		BufferedReader br;
+
+		public Scanner(InputStream s) {
+			br = new BufferedReader(new InputStreamReader(s));
+		}
+
+		public Scanner(FileReader r) {
+			br = new BufferedReader(r);
+		}
+
+		public String next() throws IOException {
+			while (st == null || !st.hasMoreTokens())
+				st = new StringTokenizer(br.readLine());
+			return st.nextToken();
+		}
+
+		public int nextInt() throws IOException {
+			return Integer.parseInt(next());
+		}
+
+		public long nextLong() throws IOException {
+			return Long.parseLong(next());
+		}
+
+		public String nextLine() throws IOException {
+			return br.readLine();
+		}
+
+		public double nextDouble() throws IOException {
+			return Double.parseDouble(next());
+		}
+
+		public boolean ready() throws IOException {
+			return br.ready();
+		}
+
+	}
+
+}",0
+1a400c1b,b505f95e,"import java.util.*;
+import java.io.*;
+import java.lang.*;
+import static java.lang.Math.*;
+
+public class cp{
+    static BufferedReader br;
+    static StringTokenizer st;
+
+    public static void main(String[] args)throws IOException{
+
+        br = new BufferedReader(new InputStreamReader(System.in));
+        List<int[]> answer = new ArrayList<int[]>();
+
+        for(int t=Integer.parseInt(br.readLine()); t>0; t--){
+
+            st = readLine();
+            st = readLine();
+            int n = tokenInt();
+            int k = tokenInt();
+
+            st = readLine();
+            int[] posArr = readIntArray(k);
+            st = readLine();
+            int[] tempArr = readIntArray(k);
+
+            answer.add(new Solver().solve(n, k, posArr, tempArr));
+
+        }
+
+        ListIterator<int[]> it = answer.listIterator();
+        while (it.hasNext())
+            printArr(it.next());
+
+    }
+
+    static StringTokenizer readLine() throws IOException { return new StringTokenizer(br.readLine()); }
+    static int tokenInt() { return Integer.parseInt(st.nextToken()); }
+    static long tokenLong(){ return Long.parseLong(st.nextToken()); }
+    static double tokenDouble(){ return Double.parseDouble(st.nextToken()); }
+    static char[] tokenChar(){ return st.nextToken().toCharArray(); }
+    static int[] readIntArray(int n) {
+        int[] a=new int[n];
+        for (int i=0; i<n; i++) a[i]=tokenInt();
+        return a;
+    }
+
+    static int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b);}
+    static int lcm(int a, int b) { return (a * b) / gcd(a,b);}
+
+    static void printArr(int[] arr){
+        for (int i=0; i<arr.length; i++) System.out.print(arr[i] + "" "");
+        System.out.println();
+        return;
+    }
+
+}
+
+
+class Solver{
+    public int[] solve(int n, int k, int[] posArr, int[] tempArr) throws IOException{
+
+        // System.out.println(n);
+        // System.out.println(k);
+        int[] answer = new int[n];
+        for(int i=0; i<n; i++)
+            answer[i] = Integer.MAX_VALUE / 2;
+        for(int i=0; i<k; i++)
+            answer[posArr[i]-1] = tempArr[i];
+
+        for (int i=1; i<n; i++)
+            answer[i] = min(answer[i-1]+1, answer[i]);
+
+        for (int j=n-2; j>=0; j--)
+            answer[j] = min(answer[j+1]+1, answer[j]);
+
+        return answer;
+    }
+}
+
+
+/*
+
+
+
+*/
+","import java.util.*;
+import java.io.*;
+
+public class E {
+    public static void main(String[] args) throws IOException {
+        setIO();
+
+        int INF = 2000000000;
+
+        int Q = ni();
+        while (Q-- > 0) {
+        	rl();
+        	st = nl();
+        	int N = ni(st), K = ni(st);
+        	int[] P = nia(K);
+        	int[] T = nia(K);
+        	int[] A = new int[N];
+        	Arrays.fill(A, INF);
+        	for (int i = 0; i < K; i++) {
+        		A[P[i]-1] = T[i];
+			}
+
+        	int[] R = new int[N];
+        	R[N-1] = A[N-1];
+        	for (int i = N-2; i >= 0; i--) {
+				R[i] = Math.min(R[i+1] + 1, A[i]);
+			}
+
+        	int[] L = new int[N];
+        	L[0] = A[0];
+        	for (int i = 1; i < N; i++) {
+        		L[i] = Math.min(L[i-1] + 1, A[i]);
+			}
+
+        	for (int i = 0; i < N; i++) {
+        		out.print(Math.min(L[i], R[i]) + "" "");
+			}
+        	out.println();
+		}
+
+        f.close();
+        out.close();
+    }
+
+    static BufferedReader f;
+    static PrintWriter out;
+    static StringTokenizer st;
+
+    static String rl() throws IOException {
+        return f.readLine();
+    }
+
+    static int ni(StringTokenizer st) {
+        return Integer.parseInt(st.nextToken());
+    }
+
+    static long nlg(StringTokenizer st) {
+        return Long.parseLong(st.nextToken());
+    }
+
+    static int ni() throws IOException {
+        return Integer.parseInt(rl());
+    }
+
+    static long nlg() throws IOException {
+        return Long.parseLong(rl());
+    }
+
+    static StringTokenizer nl() throws IOException {
+        return new StringTokenizer(rl());
+    }
+
+    static int[] nia(int N) throws IOException {
+        StringTokenizer st = nl();
+        int[] A = new int[N];
+        for (int i = 0; i < N; i++)
+            A[i] = ni(st);
+        return A;
+    }
+
+    static void setIn(String s) throws IOException {
+        f = new BufferedReader(new FileReader(s));
+    }
+
+    static void setOut(String s) throws IOException {
+        out = new PrintWriter(new FileWriter(s));
+    }
+
+    static void setIn() {
+        f = new BufferedReader(new InputStreamReader(System.in));
+    }
+
+    static void setOut() {
+        out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
+    }
+
+    static void setIO(String s) throws IOException {
+        setIn(s + "".in"");
+        setOut(s + "".out"");
+    }
+
+    static void setTextIO(String s) throws IOException {
+        setIn(s + "".txt"");
+        setOut(s + ""_out.txt"");
+    }
+
+    static void setIO() {
+        setIn();
+        setOut();
+    }
+}",0
+464ad4dd,9291ca83,"import java.io.*;
+import java.util.*;
+public class Solution{
+    public static int in = 0, count=0;
+    static class comparator implements Comparator<int[]>{
+        public int compare(int[] arr1 ,int[] arr2){
+            int gain1 =0, gain2=0;
+            for(int i:arr1) gain1+=i;
+            for(int i:arr2) gain2+=i;
+            if((gain1-2*arr1[in])>(gain2-2*arr2[in]))
+                return 1;
+            else if((gain1-2*arr1[in])==(gain2-2*arr2[in])) {
+                count++;
+                return 0;
+            }
+            return -1;
+        }
+    }
+    public static int solve(ArrayList<int[]> al, int[] total){
+        ArrayList<int[]> c = (ArrayList<int[]>) al.clone();
+        java.util.Collections.sort(c, new comparator());
+
+        int i= al.size()-1;
+        int sum=0; for(int ii:total) sum+=ii;
+        int check = total[in];
+        sum-=check;
+        for(; i>=0; i--){
+            if(check>sum) return i+1;
+            else{
+                int newSum=0; for(int ii:c.get(i)) newSum+=ii;
+                newSum-=c.get(i)[in];
+                sum-=newSum;
+                check-=c.get(i)[in];
+            }
+        }
+        return 0;
+    }
+    public static void main (String[] args) throws java.lang.Exception {
+        FastReader sc = new FastReader();
+        BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));
+        int testCase = sc.nextInt();
+        while (testCase-->0){
+            int n = sc.nextInt();
+            String[] strArr = new String[n];
+            for(int i=0; i<n; i++) {
+                strArr[i]=sc.nextLine();
+            }
+            int[] total = new int[5];
+            ArrayList<int[]> al = new ArrayList<>();
+            for(int i=0; i<n; i++){
+                int[] arr= new int[5];
+                for(int j=0; j<strArr[i].length(); j++){
+                    arr[strArr[i].charAt(j)-'a']++;
+                }
+                for(int j=0; j<5; j++){
+                    total[j]+=arr[j];
+                }
+                al.add(arr);
+            }
+            int ans = Integer.MIN_VALUE;
+            for(int i=0; i<5; i++) {
+                in = i;
+                ans = Math.max(solve(al, total), ans);
+                count=0;
+            }
+            System.out.println(ans);
+        }
+    }
+    // Fast Reader Class
+    static class FastReader {
+        BufferedReader br; StringTokenizer st;
+        public FastReader() { br = new BufferedReader(new InputStreamReader(System.in)); }
+        String next() { while (st == null || !st.hasMoreElements()) { try { st = new StringTokenizer(br.readLine()); } catch (IOException e) { e.printStackTrace(); } }return st.nextToken(); }
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+        String nextLine() { String str = """"; try { str = br.readLine(); }  catch (IOException e) { e.printStackTrace(); }return str; }
+    }
+}","import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.util.*;
+
+public class Practice {
+    static HashMap<String, Integer> map = new HashMap<>();
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        int t = sc.nextInt();
+        while (t-->0) {
+            int n = sc.nextInt();
+            int[][] occurances = new int[5][n];
+            for(int i=0;i<n;i++){
+                String s = sc.next();
+                int[] count = new int[5];
+                int len = s.length();
+                for(int j=0;j<s.length();j++){
+                    count[s.charAt(j)-'a']++;
+                }
+                for(int j=0;j<5;j++){
+                    occurances[j][i] = count[j] - (len-count[j]);
+                }
+            }
+            int ans = 0;
+            for(int i=0;i<5;i++){
+                Arrays.sort(occurances[i]);
+                int tmpAns = 0; int tmpSum=0;
+                for(int j=n-1;j>=0;j--){
+                    tmpSum+=occurances[i][j];
+                    if(tmpSum>0) tmpAns++;
+                    else break;
+                }
+                ans = Math.max(ans, tmpAns);
+            }
+            System.out.println(ans);
+        }
+    }
+}
+
+",0
+402aff07,f229aa7f,"import java.util.*;
+public class Main {
+    public static void main(String args[]) {
+        Scanner s = new Scanner(System.in);
+        int t = s.nextInt();
+        while (t-- > 0){
+            int n = s.nextInt();
+            String a = s.next();
+            String b = s.next();
+            int a1 = 0, b1 = 0;
+            for (char c: a.toCharArray()){
+                if (c == '1') a1++;
+            }
+            for (char c: b.toCharArray()){
+                if (c == '1') b1++;
+            }
+            int ans = Integer.MAX_VALUE;
+            int res = 0;
+            for (int i = 0; i < n; i++) {
+                if (a.charAt(i) != b.charAt(i)) res++;
+            }
+            if (a1 == b1) ans = Math.min(ans, res);
+            if (b1 == n-a1+1) ans = Math.min(ans, n-res);
+            if (ans == Integer.MAX_VALUE){
+                System.out.println(""-1"");
+            } else {
+                System.out.println(ans);
+            }
+        }
+    }
+}","import java.util.*;
+import java.io.*;
+import java.math.*;
+
+public class cf {
+	static PrintWriter pw = new PrintWriter(System.out);
+
+	public static void main(String[] args) throws IOException, InterruptedException {
+		Scanner sc = new Scanner(System.in);
+		int t = sc.nextInt();
+		while (t-- > 0) {
+			int n = sc.nextInt();
+			char[] a = sc.next().toCharArray();
+			char[] b = sc.next().toCharArray();
+			int x = 0, y = 0, lit = 0,lit2 = 0;
+			for (int i = 0; i < n; i++) {
+				if (a[i] == '1')
+					lit++;
+				if (b[i] == '1')
+					lit2++;
+				if (a[i] == b[i])
+					x++;
+				else
+					y++;
+			}
+			if(lit == lit2 || n - lit + 1 == lit2) {
+				if (lit == lit2 && n - lit + 1 == lit2) {
+					pw.println(Math.min(x,y));
+				}else if(lit == lit2) {
+					pw.println(y);
+				}else {
+					pw.println(x);
+				}
+			}else {
+				pw.println(-1);
+			}
+		}
+		pw.close();
+	}
+
+	public static class tuble implements Comparable<tuble> {
+		int x;
+		int y;
+		int z;
+
+		public tuble(int x, int y, int z) {
+			this.x = x;
+			this.y = y;
+			this.z = z;
+		}
+
+		public String toString() {
+			return x + "" "" + y + "" "" + z;
+		}
+
+		public int compareTo(tuble other) {
+			if (this.x == other.x) {
+				if (this.y == other.y)
+					return this.z - other.z;
+				return this.y - other.y;
+			} else {
+				return this.x - other.x;
+			}
+		}
+	}
+
+	public static class pair implements Comparable<pair> {
+		int x;
+		int y;
+
+		public pair(int x, int y) {
+			this.x = x;
+			this.y = y;
+		}
+
+		public String toString() {
+			return x + "" "" + y;
+		}
+
+		public boolean equals(Object o) {
+			if (o instanceof pair) {
+				pair p = (pair) o;
+				return p.x == x && p.y == y;
+			}
+			return false;
+		}
+
+		public int hashCode() {
+			return new Integer(x).hashCode() * 31 + new Integer(y).hashCode();
+		}
+
+		public int compareTo(pair other) {
+			if (this.x == other.x) {
+				return Long.compare(this.y, other.y);
+			}
+			return Long.compare(this.x, other.x);
+		}
+	}
+
+	static class Scanner {
+		StringTokenizer st;
+		BufferedReader br;
+
+		public Scanner(InputStream s) {
+			br = new BufferedReader(new InputStreamReader(s));
+		}
+
+		public Scanner(FileReader r) {
+			br = new BufferedReader(r);
+		}
+
+		public String next() throws IOException {
+			while (st == null || !st.hasMoreTokens())
+				st = new StringTokenizer(br.readLine());
+			return st.nextToken();
+		}
+
+		public int nextInt() throws IOException {
+			return Integer.parseInt(next());
+		}
+
+		public long nextLong() throws IOException {
+			return Long.parseLong(next());
+		}
+
+		public String nextLine() throws IOException {
+			return br.readLine();
+		}
+
+		public double nextDouble() throws IOException {
+			return Double.parseDouble(next());
+		}
+
+		public boolean ready() throws IOException {
+			return br.ready();
+		}
+
+	}
+
+}",0
+4e28b45e,d7a8434f,"import java.util.*;
+import java.io.*;
+public class C {
+
+	public static void main(String[] args) {
+		FastScanner sc = new FastScanner();
+		int T = sc.nextInt();
+		while(T-->0) {
+			int n = sc.nextInt();
+			char[] s = new char[n];
+			char[] t = new char[n];
+			s = sc.next().toCharArray();
+			t = sc.next().toCharArray();
+			int a = 0, b = 0, c = 0, d = 0;
+			for(int i = 0; i < n; i++) {
+				if(s[i] == '0' && t[i] == '0') a++;
+				if(s[i] == '1' && t[i] == '0') b++;
+				if(s[i] == '0' && t[i] == '1') c++;
+				if(s[i] == '1' && t[i] == '1') d++;
+			}
+			int res = Integer.MAX_VALUE;
+			if(b == c || b+1 == c) {
+				if((b + c) % 2 == 0) {
+					res = Math.min(res, b + c);
+				}
+			}
+			if(a == d || a+1 == d) {
+				if((a + d) % 2 == 1) {
+					res = Math.min(res, a + d);
+				}
+			}
+			if(res == Integer.MAX_VALUE) System.out.println(-1);
+			else System.out.println(res);
+		}
+	}
+	
+	static class FastScanner {
+		public BufferedReader reader;
+		public StringTokenizer tokenizer;
+		public FastScanner() {
+			reader = new BufferedReader(new InputStreamReader(System.in), 32768);
+			tokenizer = null;
+		}
+		public String next() {
+			while (tokenizer == null || !tokenizer.hasMoreTokens()) {
+				try {
+					tokenizer = new StringTokenizer(reader.readLine());
+				} catch (IOException e) {
+					throw new RuntimeException(e);
+				}
+			}
+			return tokenizer.nextToken();
+		}
+		public int nextInt() {
+			return Integer.parseInt(next());
+		}
+		public long nextLong() {
+			return Long.parseLong(next());
+		}
+		public double nextDouble() {
+			return Double.parseDouble(next());
+		}
+		public String nextLine() {
+			try {
+				return reader.readLine();
+			} catch(IOException e) {
+				throw new RuntimeException(e);
+			}
+		}
+	}
+
+}
+","import java.util.*;
+import java.io.*;
+public class C {
+
+	public static void main(String[] args) {
+		FastScanner sc = new FastScanner();
+		int T = sc.nextInt();
+		while(T-->0) {
+			int n = sc.nextInt();
+			char[] s = new char[n];
+			char[] t = new char[n];
+			s = sc.next().toCharArray();
+			t = sc.next().toCharArray();
+			int a = 0, b = 0, c = 0, d = 0;
+			for(int i = 0; i < n; i++) {
+				if(s[i] == '0' && t[i] == '0') a++;
+				if(s[i] == '1' && t[i] == '0') b++;
+				if(s[i] == '0' && t[i] == '1') c++;
+				if(s[i] == '1' && t[i] == '1') d++;
+			}
+			int res = Integer.MAX_VALUE;
+			if(b == c || b+1 == c) {
+				if((b + c) % 2 == 0) {
+					res = Math.min(res, b + c);
+				}
+			}
+			if(a == d || a+1 == d) {
+				if((a + d) % 2 == 1) {
+					res = Math.min(res, a + d);
+				}
+			}
+			if(res == Integer.MAX_VALUE) System.out.println(-1);
+			else System.out.println(res);
+		}
+	}
+	
+	static class FastScanner {
+		public BufferedReader reader;
+		public StringTokenizer tokenizer;
+		public FastScanner() {
+			reader = new BufferedReader(new InputStreamReader(System.in), 32768);
+			tokenizer = null;
+		}
+		public String next() {
+			while (tokenizer == null || !tokenizer.hasMoreTokens()) {
+				try {
+					tokenizer = new StringTokenizer(reader.readLine());
+				} catch (IOException e) {
+					throw new RuntimeException(e);
+				}
+			}
+			return tokenizer.nextToken();
+		}
+		public int nextInt() {
+			return Integer.parseInt(next());
+		}
+		public long nextLong() {
+			return Long.parseLong(next());
+		}
+		public double nextDouble() {
+			return Double.parseDouble(next());
+		}
+		public String nextLine() {
+			try {
+				return reader.readLine();
+			} catch(IOException e) {
+				throw new RuntimeException(e);
+			}
+		}
+	}
+
+}
+",1
+34b9ed7f,8311f375,"import java.io.*;
+import java.util.*;
+
+public class q3 {
+    public static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+//    public static long mod = 1000000007;
+
+    public static void solve() throws Exception {
+        String[] parts = br.readLine().split("" "");
+        int n = Integer.parseInt(parts[0]);
+
+
+        int[] arr = new int[n + 1];
+        boolean[] vis = new boolean[n + 1];
+
+        for(int i = 1;i <= n;i++){
+            if(vis[i]) continue;
+
+            ArrayList<Integer> list = new ArrayList<>();
+            while(true){
+                System.out.println(""? "" + i);
+                int val = Integer.parseInt(br.readLine());
+                vis[val] = true;
+                list.add(val);
+
+                if(list.size() > 1 && val == list.get(0)) break;
+            }
+
+            for(int j = 0;j < list.size() - 1;j++) arr[list.get(j)] = list.get(j + 1);
+//            arr[list.get(list.size() - 1)] = list.get(0);
+        }
+
+        System.out.print(""! "");
+        StringBuilder ans = new StringBuilder();
+        for(int i = 1;i <= n;i++) ans.append(arr[i]).append("" "");
+        System.out.println(ans);
+
+
+    }
+
+    public static void main(String[] args) throws Exception {
+        int tests = Integer.parseInt(br.readLine());
+        for (int test = 1; test <= tests; test++) {
+            solve();
+        }
+    }
+
+//    public static ArrayList<Integer> primes;
+//    public static void seive(int n){
+//        primes = new ArrayList<>();
+//        boolean[] arr = new boolean[n + 1];
+//        Arrays.fill(arr,true);
+//
+//        for(int i = 2;i * i <= n;i++){
+//            if(arr[i]) {
+//                for (int j = i * i; j <= n; j += i) {
+//                    arr[j] = false;
+//                }
+//            }
+//        }
+//        for(int i = 2;i <= n;i++) if(arr[i]) primes.add(i);
+//    }
+
+
+//    public static void sort(int[] arr){
+//        ArrayList<Integer> temp = new ArrayList<>();
+//        for(int val : arr) temp.add(val);
+//
+//        Collections.sort(temp);
+//
+//        for(int i = 0;i < arr.length;i++) arr[i] = temp.get(i);
+//    }
+
+//    public static void sort(long[] arr){
+//        ArrayList<Long> temp = new ArrayList<>();
+//        for(long val : arr) temp.add(val);
+//
+//        Collections.sort(temp);
+//
+//        for(int i = 0;i < arr.length;i++) arr[i] = temp.get(i);
+//    }
+//
+//    public static long power(long a,long b,long mod){
+//        if(b == 0) return 1;
+//
+//        long p = power(a,b / 2,mod);
+//        p = (p * p) % mod;
+//
+//        if(b % 2 == 1) return (p * a) % mod;
+//        return p;
+//    }
+//    public static long modDivide(long a,long b,long mod){
+//        return ((a % mod) * (power(b,mod - 2,mod) % mod)) % mod;
+//    }
+//
+//    public static int GCD(int a,int b){
+//        return b == 0 ? a : GCD(b,a % b);
+//    }
+//    public static long GCD(long a,long b){
+//        return b == 0 ? a : GCD(b,a % b);
+//    }
+//
+//    public static int LCM(int a,int b){
+//        return a * b / GCD(a,b);
+//    }
+//    public static long LCM(long a,long b){
+//        return a * b / GCD(a,b);
+//    }
+}
+","import java.io.*;
+import java.util.*;
+
+public class q3 {
+    public static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+//    public static long mod = 1000000007;
+
+    public static void solve() throws Exception {
+        String[] parts = br.readLine().split("" "");
+        int n = Integer.parseInt(parts[0]);
+
+
+        int[] arr = new int[n + 1];
+        boolean[] vis = new boolean[n + 1];
+
+        for(int i = 1;i <= n;i++){
+            if(vis[i]) continue;
+
+            ArrayList<Integer> list = new ArrayList<>();
+            while(true){
+                System.out.println(""? "" + i);
+                int val = Integer.parseInt(br.readLine());
+                vis[val] = true;
+                list.add(val);
+
+                if(list.size() > 1 && val == list.get(0)) break;
+            }
+
+            for(int j = 0;j < list.size() - 1;j++) arr[list.get(j)] = list.get(j + 1);
+        }
+
+        System.out.print(""! "");
+        StringBuilder ans = new StringBuilder();
+        for(int i = 1;i <= n;i++) ans.append(arr[i]).append("" "");
+        System.out.println(ans);
+
+
+    }
+
+    public static void main(String[] args) throws Exception {
+        int tests = Integer.parseInt(br.readLine());
+        for (int test = 1; test <= tests; test++) {
+            solve();
+        }
+    }
+
+}
+",1
+d6bbd286,fabb36ff,"import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+import java.util.StringTokenizer;
+
+public class C {
+
+	@SuppressWarnings(""unchecked"")
+	public static void main(String[] args) throws NumberFormatException, IOException {
+		BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
+		int inputs = Integer.parseInt(in.readLine());
+		StringBuilder ans = new StringBuilder();
+		while(inputs-->0) {
+			int n = Integer.parseInt(in.readLine());
+			int[] degree = new int[n];
+			boolean bad = false;
+			ArrayList<int[]>[] con = new ArrayList[n];
+			for(int i = 0; i < n; i++) {
+				con[i] = new ArrayList<>();
+			}
+			for(int i = 0; i < n-1; i++) {
+				StringTokenizer st = new StringTokenizer(in.readLine());
+				int a = Integer.parseInt(st.nextToken())-1;
+				int b = Integer.parseInt(st.nextToken())-1;
+				degree[a]++;
+				degree[b]++;
+				if(degree[a] > 2 || degree[b] > 2)
+					 bad = true;
+				con[a].add(new int[] {b, i});
+				con[b].add(new int[] {a, i});
+			}
+			if(bad)
+				ans.append(""-1\n"");
+			else {
+				int[] assign = new int[n-1];
+				for(int i = 0; i < degree.length; i++) {
+					if(degree[i] == 1) {
+						dfs(i, -1, 11, con, assign);
+						break;
+					}
+				}
+				for(int i = 0; i < n-2; i++)
+					ans.append(assign[i] + "" "");
+				ans.append(assign[n-2] + ""\n"");
+			}
+		}
+		System.out.print(ans);
+
+	}
+	
+	public static void dfs(int curr, int prev, int num, ArrayList<int[]>[] con, int[] a) {
+		for(int[] next : con[curr]) {
+			if(next[0] != prev) {
+				a[next[1]] = 13-num;
+				dfs(next[0], curr, 13-num, con, a);
+			}
+		}
+	}
+
+}
+","import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.PrintWriter;
+import java.math.BigInteger;
+import java.util.*;
+
+public class Cr766A {
+
+    public static void main(String[] args) {
+
+        InputStream inputStream = System.in;
+        OutputStream outputStream = System.out;
+        InputReader sc = new InputReader(inputStream);
+        PrintWriter out = new PrintWriter(outputStream);
+        Solver solver = new Solver();
+        int t = sc.nextInt();
+//        int t = 1;
+        while (t-- != 0) {
+            solver.solve(sc, out);
+        }
+        out.close();
+
+    }
+
+    static class Solver {
+        ArrayList<int[]>[] gp;
+        int[] ans;
+        public void solve(InputReader sc, PrintWriter out) {
+            int n = sc.nextInt();
+            gp = new ArrayList[n];
+            ans = new int[n-1];
+            for (int i = 0; i < n; i++) {
+                gp[i] = new ArrayList<>();
+            }
+            for (int i = 0; i < n - 1; i++) {
+                int u = sc.nextInt()-1;
+                int v = sc.nextInt()-1;
+                gp[u].add(new int[] {v,i});
+                gp[v].add(new int[] {u,i});
+            }
+            for(int i = 0; i < n; i++) {
+                if(gp[i].size()>2) {
+                    out.println(-1);
+                    return;
+                }
+            }
+            int oneDegree = -1;
+            for(int i = 0; i < n; i++) {
+                if(gp[i].size()==1) {
+                    oneDegree = i;
+                }
+            }
+            if(oneDegree==-1) {
+                throw new RuntimeException();
+            }
+            dfs(oneDegree,-1,3);
+            for(int i = 0; i < n-1; i++) {
+                if(i>0) out.print("" "");
+                out.print(ans[i]);
+            }
+            out.println();
+        }
+
+        private void dfs(int src, int p, int prevPrime) {
+            int ocr = 0;
+            for(int[] vs : gp[src]) {
+                int v = vs[0];
+                int idx = vs[1];
+                if(v==p) continue;
+                ocr++;
+                ans[idx] = 5-prevPrime;
+                dfs(v,src,ans[idx]);
+            }
+            if(ocr>1) {
+                throw new RuntimeException();
+            }
+        }
+
+        private int getDist(int i, int j, int r, int c) {
+            return Math.abs(i-r) + Math.abs(j-c);
+        }
+
+    }
+
+    static void sort(int[] arr) {
+        ArrayList<Integer> al = new ArrayList();
+        for (int i : arr) al.add(i);
+        Collections.sort(al);
+        int idx = 0;
+        for (int i : al) arr[idx++] = i;
+    }
+
+    static void sort(long[] arr) {
+        ArrayList<Long> al = new ArrayList();
+        for (long i : arr) al.add(i);
+        Collections.sort(al);
+        int idx = 0;
+        for (long i : al) arr[idx++] = i;
+    }
+
+    static void sortDec(int[] arr) {
+        ArrayList<Integer> al = new ArrayList();
+        for (int i : arr) al.add(i);
+        Collections.sort(al, Collections.reverseOrder());
+        int idx = 0;
+        for (int i : al) arr[idx++] = i;
+    }
+
+    static void sortDec(long[] arr) {
+        ArrayList<Long> al = new ArrayList();
+        for (long i : arr) al.add(i);
+        Collections.sort(al, Collections.reverseOrder());
+        int idx = 0;
+        for (long i : al) arr[idx++] = i;
+    }
+
+    static class InputReader {
+        private boolean finished = false;
+
+        private InputStream stream;
+        private byte[] buf = new byte[1024];
+        private int curChar;
+        private int numChars;
+        private SpaceCharFilter filter;
+
+        public InputReader(InputStream stream) {
+            this.stream = stream;
+        }
+
+        public int read() {
+            if (numChars == -1) {
+                throw new InputMismatchException();
+            }
+            if (curChar >= numChars) {
+                curChar = 0;
+                try {
+                    numChars = stream.read(buf);
+                } catch (IOException e) {
+                    throw new InputMismatchException();
+                }
+                if (numChars <= 0) {
+                    return -1;
+                }
+            }
+            return buf[curChar++];
+        }
+
+        public int peek() {
+            if (numChars == -1) {
+                return -1;
+            }
+            if (curChar >= numChars) {
+                curChar = 0;
+                try {
+                    numChars = stream.read(buf);
+                } catch (IOException e) {
+                    return -1;
+                }
+                if (numChars <= 0) {
+                    return -1;
+                }
+            }
+            return buf[curChar];
+        }
+
+        public int nextInt() {
+            int c = read();
+            while (isSpaceChar(c)) {
+                c = read();
+            }
+            int sgn = 1;
+            if (c == '-') {
+                sgn = -1;
+                c = read();
+            }
+            int res = 0;
+            do {
+                if (c < '0' || c > '9') {
+                    throw new InputMismatchException();
+                }
+                res *= 10;
+                res += c - '0';
+                c = read();
+            } while (!isSpaceChar(c));
+            return res * sgn;
+        }
+
+        public long nextLong() {
+            int c = read();
+            while (isSpaceChar(c)) {
+                c = read();
+            }
+            int sgn = 1;
+            if (c == '-') {
+                sgn = -1;
+                c = read();
+            }
+            long res = 0;
+            do {
+                if (c < '0' || c > '9') {
+                    throw new InputMismatchException();
+                }
+                res *= 10;
+                res += c - '0';
+                c = read();
+            } while (!isSpaceChar(c));
+            return res * sgn;
+        }
+
+        public String nextString() {
+            int c = read();
+            while (isSpaceChar(c)) {
+                c = read();
+            }
+            StringBuilder res = new StringBuilder();
+            do {
+                if (Character.isValidCodePoint(c)) {
+                    res.appendCodePoint(c);
+                }
+                c = read();
+            } while (!isSpaceChar(c));
+            return res.toString();
+        }
+
+        public boolean isSpaceChar(int c) {
+            if (filter != null) {
+                return filter.isSpaceChar(c);
+            }
+            return isWhitespace(c);
+        }
+
+        public static boolean isWhitespace(int c) {
+            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
+        }
+
+        private String readLine0() {
+            StringBuilder buf = new StringBuilder();
+            int c = read();
+            while (c != '\n' && c != -1) {
+                if (c != '\r') {
+                    buf.appendCodePoint(c);
+                }
+                c = read();
+            }
+            return buf.toString();
+        }
+
+        public String readLine() {
+            String s = readLine0();
+            while (s.trim().length() == 0) {
+                s = readLine0();
+            }
+            return s;
+        }
+
+        public String readLine(boolean ignoreEmptyLines) {
+            if (ignoreEmptyLines) {
+                return readLine();
+            } else {
+                return readLine0();
+            }
+        }
+
+        public BigInteger readBigInteger() {
+            try {
+                return new BigInteger(nextString());
+            } catch (NumberFormatException e) {
+                throw new InputMismatchException();
+            }
+        }
+
+        public char nextCharacter() {
+            int c = read();
+            while (isSpaceChar(c)) {
+                c = read();
+            }
+            return (char) c;
+        }
+
+        public double nextDouble() {
+            int c = read();
+            while (isSpaceChar(c)) {
+                c = read();
+            }
+            int sgn = 1;
+            if (c == '-') {
+                sgn = -1;
+                c = read();
+            }
+            double res = 0;
+            while (!isSpaceChar(c) && c != '.') {
+                if (c == 'e' || c == 'E') {
+                    return res * Math.pow(10, nextInt());
+                }
+                if (c < '0' || c > '9') {
+                    throw new InputMismatchException();
+                }
+                res *= 10;
+                res += c - '0';
+                c = read();
+            }
+            if (c == '.') {
+                c = read();
+                double m = 1;
+                while (!isSpaceChar(c)) {
+                    if (c == 'e' || c == 'E') {
+                        return res * Math.pow(10, nextInt());
+                    }
+                    if (c < '0' || c > '9') {
+                        throw new InputMismatchException();
+                    }
+                    m /= 10;
+                    res += (c - '0') * m;
+                    c = read();
+                }
+            }
+            return res * sgn;
+        }
+
+        public boolean isExhausted() {
+            int value;
+            while (isSpaceChar(value = peek()) && value != -1) {
+                read();
+            }
+            return value == -1;
+        }
+
+        public String next() {
+            return nextString();
+        }
+
+        public SpaceCharFilter getFilter() {
+            return filter;
+        }
+
+        public void setFilter(SpaceCharFilter filter) {
+            this.filter = filter;
+        }
+
+        public interface SpaceCharFilter {
+            public boolean isSpaceChar(int ch);
+        }
+
+        public int[] nextIntArray(int n) {
+            int[] array = new int[n];
+            for (int i = 0; i < n; ++i) array[i] = nextInt();
+            return array;
+        }
+
+        public int[] nextSortedIntArray(int n) {
+            int array[] = nextIntArray(n);
+            Arrays.sort(array);
+            return array;
+        }
+
+        public int[] nextSumIntArray(int n) {
+            int[] array = new int[n];
+            array[0] = nextInt();
+            for (int i = 1; i < n; ++i) array[i] = array[i - 1] + nextInt();
+            return array;
+        }
+
+        public long[] nextLongArray(int n) {
+            long[] array = new long[n];
+            for (int i = 0; i < n; ++i) array[i] = nextLong();
+            return array;
+        }
+
+        public long[] nextSumLongArray(int n) {
+            long[] array = new long[n];
+            array[0] = nextInt();
+            for (int i = 1; i < n; ++i) array[i] = array[i - 1] + nextInt();
+            return array;
+        }
+
+        public long[] nextSortedLongArray(int n) {
+            long array[] = nextLongArray(n);
+            Arrays.sort(array);
+            return array;
+        }
+    }
+
+
+}
+",0
+5a74241a,6490bbe8,"import java.util.*;
+import java.io.*;
+
+public class _109 {
+    public static void main(String[] args) {
+        MyScanner sc = new MyScanner();
+        PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
+        int t = 1;
+        while (t-- > 0) {
+            int n = sc.nextInt();
+            int [] a = new int[n];
+            ArrayList<Integer> one = new ArrayList<>();
+            ArrayList<Integer> zero = new ArrayList<>();
+            for (int i = 0; i < n; i++) {
+                a[i] = sc.nextInt();
+                if (a[i] == 0) zero.add(i);
+                else one.add(i);
+            }
+            if (one.size() == 0) {
+                out.println(0);
+                continue;
+            }
+            int zeros = zero.size();
+            int ones = one.size();
+            long [][] dp = new long[zeros + 1][ones + 1];
+            for (long [] arr: dp) Arrays.fill(arr, Integer.MAX_VALUE);
+            for (int i = 0; i <= zeros; i++) dp[i][0] = 0;
+            long res = Long.MAX_VALUE;
+            for (int i = 1; i <= zeros; i++) {
+                for (int j = 1; j <= ones; j++) {
+                    int zeroIndex = zero.get(i - 1);
+                    int oneIndex = one.get(j - 1);
+                    dp[i][j] = Math.min(dp[i][j], dp[i - 1][j]);
+                    dp[i][j] = Math.min(dp[i][j], dp[i - 1][j - 1] + Math.abs(zeroIndex - oneIndex));
+                    if (j == ones) res = Math.min(res, dp[i][j]);
+                }
+            }
+            out.println(res);
+        }
+        out.close();
+    }
+
+
+
+    static void sort(int[] a) {
+        ArrayList<Integer> q = new ArrayList<>();
+        for (int i : a) q.add(i);
+        Collections.sort(q);
+        for (int i = 0; i < a.length; i++) a[i] = q.get(i);
+    }
+
+    static void sort(long[] a) {
+        ArrayList<Long> q = new ArrayList<>();
+        for (long i : a) q.add(i);
+        Collections.sort(q);
+        for (int i = 0; i < a.length; i++) a[i] = q.get(i);
+    }
+
+
+    //-----------MyScanner class for faster input----------
+    public static class MyScanner {
+        BufferedReader br;
+        StringTokenizer st;
+
+        public MyScanner() {
+            br = new BufferedReader(new InputStreamReader(System.in));
+        }
+
+        String next() {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+
+        String nextLine() {
+            String str = """";
+            try {
+                str = br.readLine();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+        }
+
+
+    }
+
+}","import java.util.*;
+// import java.lang.*;
+import java.io.*;
+
+//           THIS TEMPLATE MADE BY AKSH BANSAL.
+
+public class Solution {
+    static class FastReader {
+        BufferedReader br;
+        StringTokenizer st;
+
+        public FastReader() {
+            br = new BufferedReader(new InputStreamReader(System.in));
+        }
+
+        String next() {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+
+        String nextLine() {
+            String str = """";
+            try {
+                str = br.readLine();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+        }
+    }
+    private static boolean[] isPrime;
+    private static void primes(){
+        int num = (int)1e6; // PRIMES FROM 1 TO NUM
+        isPrime = new boolean[num];
+     
+        for (int i = 2; i< isPrime.length; i++) {
+           isPrime[i] = true;
+        }
+        for (int i = 2; i< Math.sqrt(num); i++) {
+           if(isPrime[i] == true) {
+              for(int j = (i*i); j<num; j = j+i) {
+                 isPrime[j] = false;
+              }
+           }
+        }
+    }
+    private static long gcd(long a, long b){
+        if(b==0)return a;
+        return gcd(b,a%b);
+    }
+    private static long pow(long x,long y){
+        if(y==0)return 1;
+        long temp = pow(x, y/2);
+        if(y%2==1){
+            return x*temp*temp;
+        }
+        else{
+            return temp*temp;
+        }
+    }
+    // static ArrayList<Integer>[] adj;
+    // static void getAdj(int n,int q, FastReader sc){
+    //     adj = new ArrayList[n+1];
+    //     for(int i=1;i<=n;i++){
+    //         adj[i] = new ArrayList<>();
+    //     }
+    //     for(int i=0;i<q;i++){
+    //         int a = sc.nextInt();
+    //         int b = sc.nextInt();
+
+    //         adj[a].add(b);
+    //         adj[b].add(a);
+    //     }
+    // }
+    public static void main(String[] args) throws IOException {
+        FastReader sc = new FastReader();
+        PrintWriter out = new PrintWriter(System.out);
+        // primes();
+        // ________________________________
+
+        // int t = sc.nextInt();
+        // StringBuilder output = new StringBuilder();
+
+        // while (t-- > 0) {
+
+        //     output.append(solver()).append(""\n"");
+        // }
+
+        // out.println(output);
+        // _______________________________
+
+        int n = sc.nextInt();
+        int arr[] = new int[n];
+        for(int i=0;i<n;i++){
+            arr[i] = sc.nextInt();
+        }
+        out.println(solver(n, arr));
+        // ________________________________
+        out.flush();
+    }
+
+    public static long solver(int n, int[] arr) {
+        ArrayList<Integer> a = new ArrayList<>();
+        ArrayList<Integer> b = new ArrayList<>();
+        for(int i=0;i<n;i++){
+            if(arr[i] ==1){
+                a.add(i);
+            }
+            else{
+                b.add(i);
+            }
+        }
+        // System.out.println(""__""+ a);
+        // System.out.println(""__""+ b);
+        long inf = (long)1e10;
+        int aLen = a.size(), bLen = b.size();
+        long[][] dp = new long[bLen+1][aLen+1];
+        for(int i=0;i<bLen+1;i++)Arrays.fill(dp[i],inf);
+        // dp[0][0] = 0;
+        for(int i=0;i<=bLen;i++){
+            dp[i][0] = 0;
+        }
+        for(int i=1;i<=bLen;i++){
+            for(int j=1;j<=i && j<=aLen;j++){
+                int aa = a.get(j-1);
+                int bb = b.get(i-1);
+                // System.out.println((i-1)+"" ""+(j-1)+""__""+ aa+"" ""+bb);
+                dp[i][j] = Math.min(
+                    Math.abs(aa-bb)+dp[i-1][j-1],
+                    dp[i-1][j]
+                );
+                // System.out.println((i-1)+"" ""+(j-1)+""__""+ dp[i][j]);
+            }
+        }
+        // for(int i=0;i<=bLen;i++){
+        //     for(int j=0;j<=aLen;j++){
+        //         System.out.print(dp[i][j]+"" "");
+        //     }
+        //     System.out.println(""__"" );
+        // }
+        return dp[bLen][aLen]==inf?0:dp[bLen][aLen];
+    }
+}",0
+6de04ee2,d9199dfd,"import java.util.*;
+public class Solution{
+    public static void main(String[] args){
+    Scanner sc=new Scanner(System.in);
+    int t=sc.nextInt();
+
+    while(t-->0) {
+        int n=sc.nextInt();
+        int[] a=new int[n];
+        for(int i=0;i<n;i++)
+             a[i]=sc.nextInt();
+
+     char[] c=sc.next().toCharArray();
+
+        Vector<Integer> l=new Vector<>(), r=new Vector<>();
+        for(int i=0;i<n;i++)
+            (c[i] == 'B' ? l : r).add(a[i]);
+        Collections.sort(l);
+        Collections.sort(r,Collections.reverseOrder());
+
+        boolean ok = true;
+        for(int i=0;i<l.size();i++)
+            if (l.get(i) < i + 1)
+                ok = false;
+        for(int i=0;i<r.size();i++)
+            if (r.get(i) > n - i)
+                ok = false;
+
+         System.out.print((ok ? ""YES"" : ""NO"")+'\n');
+    }
+    }
+}","import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Scanner;
+
+public class Simple{  
+    public static void main(String args[]){  
+        //System.out.println(""Hello Java"");
+        Scanner s = new Scanner(System.in);
+        int t = s.nextInt();
+        while (t>0){
+            
+            int n = s.nextInt();
+            int arr[] = new int[n];
+
+            for(int i=0;i<n;i++){
+                arr[i] = s.nextInt();
+            }
+            String str = s.next();
+
+            //Arrays.sort(arr);
+            ArrayList<Integer> blue = new ArrayList<>();
+            ArrayList<Integer> red = new ArrayList<>();
+            for(int i=0;i<n;i++){
+                if(str.charAt(i)=='R'){
+                    red.add(arr[i]);
+                }
+                else{
+                    blue.add(arr[i]);
+                }
+            }
+            Collections.sort(red);
+            Collections.sort(blue);
+            
+            int start =1;
+
+            boolean bool =true;
+            for(int i=0;i<blue.size();i++){
+                if(blue.get(i)<start){
+                    bool = false;
+                    break;
+                }
+
+                start++;
+            }
+            if(!bool){
+                System.out.println(""NO"");
+            }
+            else{
+                for(int i=0;i<red.size();i++){
+                    if(red.get(i)>start){
+                        bool = false;
+                        break;
+                    }
+                    start++;
+                }
+                if(bool){
+                    System.out.println(""YES"");
+                }
+                else{
+                    System.out.println(""NO"");
+                }
+            }
+            
+            
+
+
+            t--;
+        }
+        s.close();  
+    }
+    
+}  
+",0
+90d0ffd0,b21c7532,"import java.io.*;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Random;
+import java.util.StringTokenizer;
+
+public class C {
+
+    public static void main(String[] args) {
+        FastReader scan = new FastReader();
+        PrintWriter out = new PrintWriter(System.out);
+        Task solver = new Task();
+        int t = scan.nextInt();
+        for(int tt = 1; tt <= t; tt++) solver.solve(tt, scan, out);
+        out.close();
+    }
+
+    static class Task {
+        int n, m;
+        char[][] a;
+        ArrayList<int[]> moves;
+
+        public void solve(int testNumber, FastReader scan, PrintWriter out) {
+            n = scan.nextInt();
+            m = scan.nextInt();
+            a = new char[n][m];
+            moves = new ArrayList<>();
+            for(int i = 0; i < n; i++) a[i] = scan.next().toCharArray();
+            if(n % 2 == 0) {
+                for (int i = 0; i < n; i += 2) {
+                    if (m % 2 == 0) {
+                        for (int j = 0; j < m; j += 2) move(i, j);
+                    } else {
+                        for (int j = 0; j < m - 3; j += 2) move(i, j);
+                        if (one(i, m - 2).size() == 4) {
+                            move(i, m - 3);
+                            move(i, m - 2);
+                        } else {
+                            move(i, m - 3);
+                            move(i, m - 2);
+                        }
+                    }
+                }
+            }
+            else {
+                for (int i = 0; i < n - 1; i += 2) {
+                    if (m % 2 == 0) {
+                        for (int j = 0; j < m; j += 2) move(i, j);
+                    } else {
+                        for (int j = 0; j < m - 3; j += 2) move(i, j);
+                        if (one(i, m - 2).size() == 4) {
+                            move(i, m - 3);
+                            move(i, m - 2);
+                        } else {
+                            move(i, m - 3);
+                            move(i, m - 2);
+                        }
+                    }
+                }
+                if (m % 2 == 0) {
+                    for (int j = 0; j < m; j += 2) move(n - 2, j);
+                } else {
+                    for (int j = 0; j < m - 3; j += 2) move(n - 2, j);
+                    if (one(n - 2, m - 2).size() == 4) {
+                        move(n - 2, m - 3);
+                        move(n - 2, m - 2);
+                    } else {
+                        move(n - 2, m - 3);
+                        move(n - 2, m - 2);
+                    }
+                }
+            }
+            out.println(moves.size() / 3);
+            for(int i = 0; i < moves.size(); i += 3) {
+                for(int j = 0; j < 3; j++) out.printf(""%d %d "", moves.get(i + j)[0], moves.get(i + j)[1]);
+                out.println();
+            }
+        }
+
+        void move(int y, int x) {
+            ArrayList<int[]> o = one(y, x), z = zero(y, x);
+            while(!o.isEmpty()) {
+                int first = -1, second = -1;
+                if(o.size() <= 2) {
+                    first = 1;
+                    second = 2;
+                }
+                else {
+                    first = 3;
+                    second = 0;
+                }
+                for(int i = 0; i < first; i++) {
+                    int[] t = o.get(i);
+                    a[t[0] - 1][t[1] - 1] = '0';
+                    moves.add(t);
+                }
+                for(int i = 0; i < second; i++) {
+                    int[] t = z.get(i);
+                    a[t[0] - 1][t[1] - 1] = '1';
+                    moves.add(t);
+                }
+                o = one(y, x);
+                z = zero(y, x);
+            }
+        }
+
+        ArrayList<int[]> one(int y, int x) {
+            ArrayList<int[]> res = new ArrayList<>();
+            for(int i = y + 1; i >= y; i--) {
+                for(int j = x + 1; j >= x; j--) {
+                    if(a[i][j] == '1') res.add(new int[] {i + 1, j + 1});
+                }
+            }
+            return res;
+        }
+        ArrayList<int[]> zero(int y, int x) {
+            ArrayList<int[]> res = new ArrayList<>();
+            for(int i = y; i <= y + 1; i++) {
+                for(int j = x; j <= x + 1; j++) {
+                    if(a[i][j] == '0') res.add(new int[] {i + 1, j + 1});
+                }
+            }
+            return res;
+        }
+    }
+
+    static void ruffleSort(int[] a) {
+        Random get = new Random();
+        for (int i = 0; i < a.length; i++) {
+            int r = get.nextInt(a.length);
+            int temp = a[i];
+            a[i] = a[r];
+            a[r] = temp;
+        }
+        Arrays.sort(a);
+    }
+
+    static void ruffleSort(long[] a) {
+        Random get = new Random();
+        for (int i = 0; i < a.length; i++) {
+            int r = get.nextInt(a.length);
+            long temp = a[i];
+            a[i] = a[r];
+            a[r] = temp;
+        }
+        Arrays.sort(a);
+    }
+
+    static class FastReader {
+        BufferedReader br;
+        StringTokenizer st;
+
+        public FastReader() {
+            br = new BufferedReader(new InputStreamReader(System.in));
+        }
+
+        public FastReader(String s) throws FileNotFoundException {
+            br = new BufferedReader(new FileReader(new File(s)));
+        }
+
+        String next() {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+
+        String nextLine() {
+            String str = """";
+            try {
+                str = br.readLine();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+        }
+    }
+
+}","import java.util.*;
+import java.math.*;
+import java.io.*;
+
+public class B{
+	public static void main(String[] args){
+		FastReader in = new FastReader(); 
+		int t = in.nextInt();
+		// int t = 1;
+		while(t-- != 0){
+			int n = in.nextInt(), m = in.nextInt();
+		 	
+		 	int[][] arr = new int[n][m];
+		 	
+		 	for(int i = 0; i < n; i++){
+		 		String s = in.next();
+		 		for(int j = 0; j < m; j++){
+		 			arr[i][j] = s.charAt(j)-'0';
+		 		}
+		 	}
+
+		 	// for(int i = 0; i < n; i++){
+		 	// 	System.out.println(Arrays.toString(arr[i]));
+		 	// }
+		 	int res = 0;
+		 	for(int i = 0; i < n-1; i += 2){
+		 		for(int j = 0; j < m-1; j += 2){
+		 			int r = arr[i][j] + arr[i][j+1] + arr[i+1][j] + arr[i+1][j+1];
+		 			if(r == 1) res += 3;
+		 			else if(r == 2) res += 2;
+		 			else if(r == 3) res += 1;
+		 			else if(r == 4) res += 4;
+		 		}
+		 	}
+		 	
+		 	if(n % 2 == 1){
+		 		for(int j = 0; j < m-1; j += 2){
+		 			int r = arr[n-1][j] + arr[n-1][j+1];
+		 			if(r == 1) res += 3;
+		 			else if(r == 2) res += 2;
+		 		}
+		 	}
+		 	if(m % 2 == 1){
+		 		for(int i = 0; i < n-1; i += 2){
+		 			int r = arr[i][m-1] + arr[i+1][m-1];
+		 			if(r == 1) res += 3;
+		 			else if(r == 2) res += 2;
+		 		}	
+		 	}
+
+		 	if(n % 2 == 1 && m % 2 == 1){
+		 		if(arr[n-1][m-1] == 1) res+= 3;
+		 	}
+
+		 	System.out.println(res);
+
+		 	for(int i = 0; i < n-1; i += 2){
+		 		for(int j = 0; j < m-1; j += 2){
+		 			int a = arr[i][j], b = arr[i][j+1], c = arr[i+1][j], d = arr[i+1][j+1];
+		 			int r = a+b+c+d;
+		 			if(r == 1){
+		 				print1(i+1, j+1, a,b,c,d);
+		 			}
+		 			else if(r == 2){
+		 				print2(i+1, j+1, a,b,c,d);
+		 			}
+		 			else if(r == 3){
+		 				print3(i+1, j+1, a,b,c,d);
+		 			}	
+		 			else if(r == 4){
+		 				print4(i+1, j+1, a,b,c,d);
+		 			}
+		 		}
+		 	}
+
+		 	// System.out.println(""AFTER"");
+		 	if(n % 2 == 1){
+		 		for(int j = 0; j < m-1; j += 2){
+		 			int r = arr[n-1][j] + arr[n-1][j+1];
+		 			int a = 0, b = 0, c = arr[n-1][j], d=arr[n-1][j+1];
+		 			if(r == 1) print1(n-1,j+1, a,b,c,d);
+		 			else if(r==2)print2(n-1,j+1, a,b,c,d);
+		 			// System.out.println(""n is od + "" + j);
+		 			// System.out.printf(""%d %d %d %d\nABCD\n"", a,b,c,d);
+		 		}
+		 	}
+		 	if(m % 2 == 1){
+		 		for(int i = 0; i < n-1; i += 2){
+		 			int r = arr[i][m-1] + arr[i+1][m-1];
+		 			int a = 0, b = arr[i][m-1], c = 0, d=arr[i+1][m-1];
+		 			if(r == 1) print1(i+1,m-1, a,b,c,d);
+		 			else if(r==2) print2(i+1,m-1, a,b,c,d);
+		 			// System.out.println(""m is odd + "" + i);
+		 		}	
+		 	}
+
+		 	if(n % 2 == 1 && m % 2 == 1){
+		 		if(arr[n-1][m-1] == 1){
+		 			print1(n-1, m-1,0,0,0,1);
+		 			// System.out.println(""ekeui de "");
+		 		}
+		 	}
+
+		}
+		
+		
+	}
+
+	public static void print3(int i, int j, int a, int b, int c, int d){
+		if(a == 0){
+			System.out.printf(""%d %d %d %d %d %d\n"", i, j+1, i+1,j, i+1, j+1);//b c d
+		}else if(b == 0){
+			System.out.printf(""%d %d %d %d %d %d\n"", i,j,i+1,j,i+1,j+1); // a c d
+		}else if(c == 0){
+			System.out.printf(""%d %d %d %d %d %d\n"", i,j,i,j+1,i+1,j+1); //a b d
+		}else{
+			System.out.printf(""%d %d %d %d %d %d\n"", i,j,i+1,j,i,j+1); //a c b
+		}
+	}
+
+	public static void print2(int i, int j, int a, int b, int c, int d){
+		if(a == 0 && b==0){
+			System.out.printf(""%d %d %d %d %d %d\n"", i,j, i+1,j, i,j+1); //a c b
+			a = 1;
+			b = 1;
+			c = 0;
+			print3(i, j, a, b, c, d);
+		}else if(a == 0 && c == 0){
+			System.out.printf(""%d %d %d %d %d %d\n"", i,j, i+1,j, i,j+1); //a c b
+			a = 1;
+			c = 1;
+			b = 0;
+			print3(i, j, a, b, c, d);
+		}else if(a == 0 && d == 0){
+			System.out.printf(""%d %d %d %d %d %d\n"", i,j, i+1,j+1, i,j+1); //a d b
+			a = 1;
+			d = 1;
+			b = 0;
+			print3(i, j, a, b, c, d);
+		}else if(b == 0 && d == 0){
+			System.out.printf(""%d %d %d %d %d %d\n"", i,j,i+1,j+1,i,j+1); //a d b
+			a = 0;
+			d = 1;
+			b = 1;
+			print3(i, j, a, b, c, d);
+		}else if(c == 0 && d == 0){
+			System.out.printf(""%d %d %d %d %d %d\n"", i+1,j,i+1,j+1,i,j+1); //c d b
+			c = 1;
+			d = 1;
+			b = 0;
+			print3(i, j, a, b, c, d);
+		}else if(c == 0 && b == 0){
+			System.out.printf(""%d %d %d %d %d %d\n"", i+1,j, i+1,j+1, i,j+1); //c d b
+			c = 1;
+			d = 0;
+			b = 1;
+			print3(i, j, a, b, c, d);
+		}
+	}
+
+	public static void print1(int i, int j, int a, int b, int c, int d){
+		if(a == 1){
+			System.out.printf(""%d %d %d %d %d %d\n"", i, j, i+1,j, i+1, j+1);//a c d
+			a = 0;
+			c=1;
+			d=1;
+			print2(i, j,a,b,c,d);
+		}else if(b == 1){
+			System.out.printf(""%d %d %d %d %d %d\n"", i,j+1,i+1,j,i+1,j+1); //b c d
+			b=0;
+			c=1;
+			d=1;
+			print2(i, j,a,b,c,d);
+		}else if(c == 1){
+			System.out.printf(""%d %d %d %d %d %d\n"", i,j, i+1,j, i+1,j+1); // a c d
+			c=0;
+			a=1;
+			d=1;
+			print2(i, j,a,b,c,d);
+		}else{
+			System.out.printf(""%d %d %d %d %d %d\n"", i,j,i+1,j,i+1,j+1); // a c d
+			d=0;
+			a=1;
+			c=1;
+			print2(i, j,a,b,c,d);
+		}
+	}
+
+	public static void print4(int i, int j, int a, int b, int c, int d){
+		System.out.printf(""%d %d %d %d %d %d\n"", i,j,i+1,j,i+1,j+1); // a c d
+		a=0;
+		d=0;
+		c=0;
+		print1(i,j,a,b,c,d);
+	}
+
+
+	static class FastReader { 
+	    BufferedReader br; 
+	    StringTokenizer st; 
+
+	    public FastReader(){ 
+	        br = new BufferedReader(new
+	                 InputStreamReader(System.in)); 
+	    } 
+
+	    String next(){ 
+	        while (st == null || !st.hasMoreElements()){ 
+	            try{ 
+	                st = new StringTokenizer(br.readLine()); 
+	            }catch (IOException  e){ 
+	                e.printStackTrace(); 
+	            } 
+	        } 
+	        return st.nextToken(); 
+	    } 
+
+	    int nextInt(){ 
+	        return Integer.parseInt(next()); 
+	    } 
+
+	    long nextLong(){ 
+	        return Long.parseLong(next()); 
+	    } 
+
+	    double nextDouble(){ 
+	        return Double.parseDouble(next()); 
+	    } 
+
+	    String nextLine(){ 
+	        String str = """"; 
+	        try{ 
+	            str = br.readLine(); 
+	        }catch (IOException e){ 
+	            e.printStackTrace(); 
+	        } 
+	        return str; 
+	    } 
+	}
+}
+
+
+",0
+ca3128ab,e270e909,"
+import java.io.*;
+import java.math.*;
+import java.util.*;
+
+
+public class test {
+	 
+	   static class Pair{ 
+		   long x;
+		   long y;
+		   
+		   Pair(long x,long y){ 
+			   this.x = x;
+			   this.y = y;
+			   
+		   }
+	   }
+	  
+	   static class Compare { 
+		   
+		     void compare(Pair arr[], int n) 
+		    { 
+		        // Comparator to sort the pair according to second element 
+		        Arrays.sort(arr, new Comparator<Pair>() { 
+		            @Override public int compare(Pair p1, Pair p2) 
+		            { 
+		            	if(p1.x!=p2.x) {
+		                return (int)(p1.x - p2.x); 
+		            	}
+		            	else { 
+		            		return (int)(p1.y - p2.y);
+		            	}
+		            } 
+		        }); 
+		  
+//		        for (int i = 0; i < n; i++) { 
+//		            System.out.print(arr[i].x + "" "" + arr[i].y + "" ""); 
+//		        } 
+//		        System.out.println(); 
+		    } 
+		} 
+	 
+	   static class Scanner {
+	        BufferedReader br;
+	        StringTokenizer st;
+	 
+	        public Scanner()
+	        {
+	            br = new BufferedReader(
+	                new InputStreamReader(System.in));
+	        }
+	 
+	        String next()
+	        {
+	            while (st == null || !st.hasMoreElements()) {
+	                try {
+	                    st = new StringTokenizer(br.readLine());
+	                }
+	                catch (IOException e) {
+	                    e.printStackTrace();
+	                }
+	            }
+	            return st.nextToken();
+	        }
+	 
+	        int nextInt() { return Integer.parseInt(next()); }
+	 
+	        long nextLong() { return Long.parseLong(next()); }
+	 
+	        double nextDouble()
+	        {
+	            return Double.parseDouble(next());
+	        }
+	 
+	        String nextLine()
+	        {
+	            String str = """";
+	            try {
+	                str = br.readLine();
+	            }
+	            catch (IOException e) {
+	                e.printStackTrace();
+	            }
+	            return str;
+	        }
+	    }
+	
+	
+	   public static void main(String args[]) throws Exception { 
+		
+		   
+		   Scanner sc = new Scanner();
+		   StringBuilder res = new StringBuilder();
+		   
+		   int tc = sc.nextInt();
+		   
+		   while(tc-->0) { 
+			
+			int n = sc.nextInt();
+			
+			long c[] = new long[n];
+			
+			for(int i=0;i<n;i++) { 
+				c[i] = sc.nextLong();
+			}
+			
+			
+			long min_odd = Integer.MAX_VALUE;
+			long min_even = Integer.MAX_VALUE;
+		    long ans = Long.MAX_VALUE;
+		    long sum = 0;
+		    
+			int cnt1 = n;
+			
+			int cnt2 = n;
+			
+			
+		    for(int i = 0; i < n; i++){
+		        sum += c[i];
+		        if(i % 2 == 0){
+		            cnt1--;
+		            min_odd = Math.min(min_odd, c[i]);
+		        }
+		        else{
+		            cnt2--;
+		            min_even = Math.min(min_even, c[i]);
+		        }
+		        if(i > 0){
+		            long temp = sum + (min_odd * cnt1) + (min_even * cnt2);
+		            ans = Math.min(ans, temp);
+		        }
+		 
+		    }
+		    
+		    System.out.println(ans);
+		   }
+		   
+		   System.out.println(res);
+	   }
+}  
+
+
+
+
+","import java.io.*;
+import java.util.*;
+
+public class GFG {
+    
+    public static class Pair{
+        long first;
+        long second;
+        Pair(long first,long second){
+            this.first = first;
+            this.second = second;
+        }
+    }
+    public static int gcd(int a, int b)
+    {
+        // if b=0, a is the GCD
+        if (b == 0)
+            return a;
+ 
+        // call the gcd() method recursively by
+        // replacing a with b and b with
+        // modulus(a,b) as long as b != 0
+        else
+            return gcd(b, a % b);
+    }
+	public static void main (String[] args) {
+	    Scanner sc = new Scanner(System.in);
+	    int t = sc.nextInt();
+	     while(t-- > 0){
+	         int n = sc.nextInt();
+	         long pre = 0,ans = Long.MAX_VALUE;
+	         long[] arr = new long[n];
+	         PriorityQueue<Long> epq = new PriorityQueue<>();
+	         PriorityQueue<Long> opq = new PriorityQueue<>();
+	         for(int i=0;i<n;i++)
+	         {
+	             arr[i] = sc.nextLong();
+	             if(i%2==0)
+	             epq.add(arr[i]);
+	             else
+	             opq.add(arr[i]);
+	             pre+=arr[i];
+	             if(i>0)
+	             ans = Math.min(ans,pre+(n-epq.size())*epq.peek()+(n-opq.size())*opq.peek());
+	         }
+	         System.out.println(ans);
+	     }    
+	}
+}
+",0
+1013b392,5a340556,"import java.io.*;
+import java.util.*;
+
+public class ddd {
+    //----------------------------START--------------------------------------//
+    public static void main(String[] args)
+            throws IOException {
+
+        ADMIN_MODE();
+
+        int t = sc.ni();while(t-->0)
+            solve();
+
+
+        w.close();
+    }
+
+    static boolean[] neg;
+
+    static void solve() throws IOException {
+        int n = sc.ni();
+        neg = new boolean[n];
+        pr[] arr = new pr[n];
+        for(int i = 0; i < n; i++) {
+            long curr = sc.nl();
+            if(curr < 0) neg[i] = true;
+            arr[i] = new pr(Math.abs(curr), i);
+        }
+        Arrays.sort(arr);
+        long[] res = new long[n];
+        for(int i = 0; i < n-1; i+=2) {
+            long lcm = lcm(arr[i].val, arr[i+1].val);
+            res[arr[i].idx] = lcm/arr[i].val * (neg[arr[i].idx] ? -1 :1) * -1;
+            res[arr[i+1].idx] = lcm/arr[i+1].val * (neg[arr[i+1].idx] ? -1 :1);
+        }
+
+        if(n%2==1) {
+            long aa = arr[n-3].val * (neg[arr[n-3].idx] ? -1 : 1);
+            long bb = arr[n-2].val * (neg[arr[n-2].idx] ? -1 : 1);
+            long cc = arr[n-1].val * (neg[arr[n-1].idx] ? -1 : 1);
+
+            if (aa == -1*bb) {
+                if(aa == cc) {
+                    pr temp = arr[n-1];
+                    arr[n-1] = arr[n-2];
+                    arr[n-2] = temp;
+                } else {
+                    pr temp = arr[n-3];
+                    arr[n-3] = arr[n-1];
+                    arr[n-1] = temp;
+                }
+            }
+        }
+
+        if(n%2==1) {
+            long a = arr[n-2].val * (neg[arr[n-2].idx] ? -1 :1) +
+                    arr[n-3].val * (neg[arr[n-3].idx] ? -1 :1);
+            boolean f = (a < 0);
+            a = Math.abs(a);
+            long b = arr[n-1].val;
+            long lcm = lcm(a, b);
+            if(f) {
+                res[arr[n-2].idx] = lcm/a * -1;
+                res[arr[n-3].idx] = lcm/a * -1;
+            } else {
+                res[arr[n - 2].idx] = lcm / a;
+                res[arr[n - 3].idx] = lcm / a;
+            }
+            res[arr[n-1].idx] = lcm/b * (neg[arr[n-1].idx] ? -1 :1) * - 1;
+        }
+
+        for(int i = 0; i < n; i++) {
+            w.pr(res[i]+"" "");
+        }
+        w.pl();
+    }
+
+    static class pr implements Comparable<pr>{
+        long val;int idx;
+
+        public pr(long val, int idx) {
+            this.val = val;
+            this.idx = idx;
+        }
+
+        @Override
+        public int compareTo(pr o) {
+            return Long.compare(val, o.val);
+        }
+    }
+
+    //--------------------------INPUT READER--------------------------------//
+    static class fs {
+        public BufferedReader br;
+        StringTokenizer st = new StringTokenizer("""");
+
+        public fs() { this(System.in); }
+        public fs(InputStream is) {
+            br = new BufferedReader(new InputStreamReader(is));
+        }
+        String next() {
+            while (!st.hasMoreTokens()) {
+                try { st = new StringTokenizer(br.readLine()); }
+                catch (IOException e) { e.printStackTrace(); }
+            }
+            return st.nextToken();
+        }
+
+        int ni() { return Integer.parseInt(next()); }
+        long nl() { return Long.parseLong(next()); }
+        double nd() { return Double.parseDouble(next()); }
+        String ns() { return next(); }
+
+        int[] na(long nn) {
+            int n = (int) nn;
+            int[] a = new int[n];
+            for (int i = 0; i < n; i++) a[i] = ni();
+            return a;
+        }
+
+        long[] nal(long nn) {
+            int n = (int) nn;
+            long[] l = new long[n];
+            for(int i = 0; i < n; i++) l[i] = nl();
+            return l;
+        }
+    }
+    //-----------------------------------------------------------------------//
+
+    //---------------------------PRINTER-------------------------------------//
+    static class Printer {
+        static PrintWriter w;
+        public Printer() {this(System.out);}
+        public Printer(OutputStream os) {
+            w = new PrintWriter(os);
+        }
+        public void p(int i) {w.println(i);};
+        public void p(long l) {w.println(l);};
+        public void p(double d) {w.println(d);};
+        public void p(String s) { w.println(s);};
+        public void pr(int i) {w.print(i);};
+        public void pr(long l) {w.print(l);};
+        public void pr(double d) {w.print(d);};
+        public void pr(String s) { w.print(s);};
+        public void pl() {w.println();};
+        public void close() {w.close();};
+    }
+    //------------------------------------------------------------------------//
+
+    //--------------------------VARIABLES------------------------------------//
+    static fs sc = new fs();
+    static OutputStream outputStream = System.out;
+    static Printer w = new Printer(outputStream);
+    //-----------------------------------------------------------------------//
+
+    //--------------------------ADMIN_MODE-----------------------------------//
+    private static void ADMIN_MODE() throws IOException {
+        if (System.getProperty(""ONLINE_JUDGE"") == null) {
+            w = new Printer(new FileOutputStream(""output.txt""));
+            sc = new fs(new FileInputStream(""input.txt""));
+        }
+    }
+    //-------------------------------UTILS------------------------------------//
+    static long gcd(long a, long b) {
+        return b == 0 ? (a < 0L ? -a: a) : gcd(b, a%b);
+    }
+
+    static long lcm(long a, long b) {
+        return a/gcd(a, b)*b;
+    }
+
+    // region pow(a, b, mod) -> a^b
+    static long mp (long b , long x, long mod) {
+        if (x == 0) return 1;
+        if (x == 1) return b;
+        if (x % 2 == 0) return mp (b * b % mod, x / 2, mod) % mod;
+
+        return b * mp (b * b % mod, x / 2, mod) % mod;
+    }
+    // endregion
+}","import java.io.*;
+import java.util.*;
+
+public class ddd {
+    //----------------------------START--------------------------------------//
+    public static void main(String[] args)
+            throws IOException {
+
+        ADMIN_MODE();
+
+        int t = sc.ni();while(t-->0)
+            solve();
+
+
+        w.close();
+    }
+
+    static boolean[] neg;
+
+    static void solve() throws IOException {
+        int n = sc.ni();
+        neg = new boolean[n];
+        pr[] arr = new pr[n];
+        for(int i = 0; i < n; i++) {
+            long curr = sc.nl();
+            if(curr < 0) neg[i] = true;
+            arr[i] = new pr(Math.abs(curr), i);
+        }
+        Arrays.sort(arr);
+        long[] res = new long[n];
+        for(int i = 0; i < n-1; i+=2) {
+            long lcm = lcm(arr[i].val, arr[i+1].val);
+            res[arr[i].idx] = lcm/arr[i].val * (neg[arr[i].idx] ? -1 :1) * -1;
+            res[arr[i+1].idx] = lcm/arr[i+1].val * (neg[arr[i+1].idx] ? -1 :1);
+        }
+
+        if(n%2==1) {
+            long aa = arr[n-3].val * (neg[arr[n-3].idx] ? -1 : 1);
+            long bb = arr[n-2].val * (neg[arr[n-2].idx] ? -1 : 1);
+            long cc = arr[n-1].val * (neg[arr[n-1].idx] ? -1 : 1);
+
+            if (aa == -1*bb) {
+                if(aa == cc) {
+                    pr temp = arr[n-1];
+                    arr[n-1] = arr[n-2];
+                    arr[n-2] = temp;
+                } else {
+                    pr temp = arr[n-3];
+                    arr[n-3] = arr[n-1];
+                    arr[n-1] = temp;
+                }
+            }
+        }
+
+        if(n%2==1) {
+            long a = arr[n-2].val * (neg[arr[n-2].idx] ? -1 :1) +
+                    arr[n-3].val * (neg[arr[n-3].idx] ? -1 :1);
+            boolean f = (a < 0);
+            a = Math.abs(a);
+            long b = arr[n-1].val;
+            long lcm = lcm(a, b);
+            if(f) {
+                res[arr[n-2].idx] = lcm/a * -1;
+                res[arr[n-3].idx] = lcm/a * -1;
+            } else {
+                res[arr[n - 2].idx] = lcm / a;
+                res[arr[n - 3].idx] = lcm / a;
+            }
+            res[arr[n-1].idx] = lcm/b * (neg[arr[n-1].idx] ? -1 :1) * - 1;
+        }
+
+        for(int i = 0; i < n; i++) {
+            w.pr(res[i]+"" "");
+        }
+        w.pl();
+    }
+
+    static class pr implements Comparable<pr>{
+        long val;int idx;
+
+        public pr(long val, int idx) {
+            this.val = val;
+            this.idx = idx;
+        }
+
+        @Override
+        public int compareTo(pr o) {
+            return Long.compare(val, o.val);
+        }
+    }
+
+    //--------------------------INPUT READER--------------------------------//
+    static class fs {
+        public BufferedReader br;
+        StringTokenizer st = new StringTokenizer("""");
+
+        public fs() { this(System.in); }
+        public fs(InputStream is) {
+            br = new BufferedReader(new InputStreamReader(is));
+        }
+        String next() {
+            while (!st.hasMoreTokens()) {
+                try { st = new StringTokenizer(br.readLine()); }
+                catch (IOException e) { e.printStackTrace(); }
+            }
+            return st.nextToken();
+        }
+
+        int ni() { return Integer.parseInt(next()); }
+        long nl() { return Long.parseLong(next()); }
+        double nd() { return Double.parseDouble(next()); }
+        String ns() { return next(); }
+
+        int[] na(long nn) {
+            int n = (int) nn;
+            int[] a = new int[n];
+            for (int i = 0; i < n; i++) a[i] = ni();
+            return a;
+        }
+
+        long[] nal(long nn) {
+            int n = (int) nn;
+            long[] l = new long[n];
+            for(int i = 0; i < n; i++) l[i] = nl();
+            return l;
+        }
+    }
+    //-----------------------------------------------------------------------//
+
+    //---------------------------PRINTER-------------------------------------//
+    static class Printer {
+        static PrintWriter w;
+        public Printer() {this(System.out);}
+        public Printer(OutputStream os) {
+            w = new PrintWriter(os);
+        }
+        public void p(int i) {w.println(i);};
+        public void p(long l) {w.println(l);};
+        public void p(double d) {w.println(d);};
+        public void p(String s) { w.println(s);};
+        public void pr(int i) {w.print(i);};
+        public void pr(long l) {w.print(l);};
+        public void pr(double d) {w.print(d);};
+        public void pr(String s) { w.print(s);};
+        public void pl() {w.println();};
+        public void close() {w.close();};
+    }
+    //------------------------------------------------------------------------//
+
+    //--------------------------VARIABLES------------------------------------//
+    static fs sc = new fs();
+    static OutputStream outputStream = System.out;
+    static Printer w = new Printer(outputStream);
+    //-----------------------------------------------------------------------//
+
+    //--------------------------ADMIN_MODE-----------------------------------//
+    private static void ADMIN_MODE() throws IOException {
+        if (System.getProperty(""ONLINE_JUDGE"") == null) {
+            w = new Printer(new FileOutputStream(""output.txt""));
+            sc = new fs(new FileInputStream(""input.txt""));
+        }
+    }
+    //-------------------------------UTILS------------------------------------//
+    static long gcd(long a, long b) {
+        return b == 0 ? (a < 0L ? -a: a) : gcd(b, a%b);
+    }
+
+    static long lcm(long a, long b) {
+        return a/gcd(a, b)*b;
+    }
+
+    // region pow(a, b, mod) -> a^b
+    static long mp (long b , long x, long mod) {
+        if (x == 0) return 1;
+        if (x == 1) return b;
+        if (x % 2 == 0) return mp (b * b % mod, x / 2, mod) % mod;
+
+        return b * mp (b * b % mod, x / 2, mod) % mod;
+    }
+    // endregion
+}",1
+ae716b8f,f1a42a42,"
+//package training2200;
+
+import java.io.*;
+import java.util.*;
+
+public class DisCenJump {
+
+	public static void main(String[] args) throws IOException {
+
+		DisCenJump obj = new DisCenJump();
+
+		obj.doStuff();
+
+	}
+
+	int bslo(int v) {
+		int l = 0, r = lo.size()-1;
+		while (l < r) {
+			int m = (l+r)/2;
+			if (v <= lo.get(m)[0]) {
+				if (v > lo.get(m+1)[0]) return m;
+				l = m+1;
+			} else r = m;
+		}
+		return l;
+	}
+	int bshi(int v) {
+		int l = 0, r = hi.size()-1;
+		while (l < r) {
+			int m = (l+r)/2;
+			if (v >= hi.get(m)[0]) {
+				if (v < hi.get(m+1)[0]) return m;
+				l = m+1;
+			} else r = m;
+		}
+		return l;
+	}
+	
+	int[] nums;
+	int[] dp;
+	ArrayList<int[]> lo, hi;
+	private void doStuff() throws IOException {
+
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		nums = new int[Integer.parseInt(br.readLine())];
+		StringTokenizer st = new StringTokenizer(br.readLine());
+		for (int i = 0; i < nums.length; i++) {
+			nums[i] = Integer.parseInt(st.nextToken());
+		}
+		br.close();
+		
+		dp = new int[nums.length];
+		lo = new ArrayList<>();
+		hi = new ArrayList<>();
+		lo.add(new int[] {nums[nums.length-1], nums.length-1});
+		hi.add(new int[] {nums[nums.length-1], nums.length-1});
+		for (int i = dp.length-2; i >= 0; i--) {
+			dp[i] = dp[i+1]+1;
+			int pos = bslo(nums[i]);
+			for (int j = pos; j < lo.size(); j++) {
+				dp[i] = Math.min(dp[i], dp[lo.get(j)[1]]+1);
+			}
+			pos = bshi(nums[i]);
+			for (int j = pos; j < hi.size(); j++) {
+				dp[i] = Math.min(dp[i], dp[hi.get(j)[1]]+1);
+			}
+			
+			while (lo.size() > 0 && lo.get(lo.size()-1)[0] <= nums[i]) {
+				lo.remove(lo.size()-1);
+			}
+			lo.add(new int[] {nums[i], i});
+			
+			while (hi.size() > 0 && hi.get(hi.size()-1)[0] >= nums[i]) {
+				hi.remove(hi.size()-1);
+			}
+			hi.add(new int[] {nums[i], i});
+		}
+		
+		System.out.println(dp[0]);
+
+	}
+
+}","import java.io.*;
+import java.util.*;
+import java.util.stream.Collectors;
+
+public class Jumps {
+
+    public static void main(String[] args) {
+
+        FastScanner sc = new FastScanner();
+        int n = sc.nextInt();
+        int ar[] = sc.nextIntArray(n);
+        // 1 4 6 9 3 2
+        int dp[] = new int[n];
+        int nextLower[] = new int[n];
+        int nextHigher[] = new int[n];
+        int nextLowerE[] = new int[n];
+        int nextHigherE[] = new int[n];
+        Arrays.fill(nextHigher, n);
+        Arrays.fill(nextLower, n);
+        Arrays.fill(nextHigherE, n);
+        Arrays.fill(nextLowerE, n);
+        dp[n-1] = 0;
+        Stack<Integer> stack = new Stack<>();
+
+        for(int i = n-1; i >= 0; i--) {
+
+            while(stack.size() > 0 && ar[stack.peek()] < ar[i])
+                stack.pop();
+            if(stack.size() > 0)
+                nextHigherE[i] = stack.peek();
+            stack.push(i);
+        }
+        stack.clear();
+
+        for(int i = n-1; i >= 0; i--) {
+
+            while(stack.size() > 0 && ar[stack.peek()] <= ar[i])
+                stack.pop();
+            if(stack.size() > 0)
+                nextHigher[i] = stack.peek();
+            stack.push(i);
+        }
+        stack.clear();
+
+        for(int i = n-1; i >= 0; i--) {
+
+            while(stack.size() > 0 && ar[stack.peek()] > ar[i])
+                stack.pop();
+            if(stack.size() > 0)
+                nextLowerE[i] = stack.peek();
+            stack.push(i);
+        }
+        stack.clear();
+
+        for(int i = n-1; i >= 0; i--) {
+
+            while(stack.size() > 0 && ar[stack.peek()] >= ar[i])
+                stack.pop();
+            if(stack.size() > 0)
+                nextLower[i] = stack.peek();
+            stack.push(i);
+        }
+
+        for(int i = n-2; i >= 0; i--) {
+
+            int maxIndex = max(nextHigherE[i], nextLowerE[i]);
+            int ans = dp[i+1];
+            if(maxIndex < n) {
+                ans = min(ans, dp[maxIndex]);
+            }
+
+            if(nextHigherE[i] < nextLowerE[i]) {
+                int cur = nextHigherE[i];
+                while(cur < maxIndex) {
+                    ans = min(ans, dp[cur]);
+                    cur = nextLower[cur];
+                }
+            } else {
+                int cur = nextLowerE[i];
+                while(cur < maxIndex) {
+                    ans = min(ans, dp[cur]);
+                    cur = nextHigher[cur];
+                }
+            }
+            dp[i] = ans + 1;
+        }
+        System.out.println(dp[0]);
+    }
+
+    static final Random random = new Random();
+
+    static class FastScanner {
+        private InputStream sin = System.in;
+        private final byte[] buffer = new byte[1024];
+        private int ptr = 0;
+        private int buflen = 0;
+        public FastScanner(){}
+        public FastScanner(String filename) throws FileNotFoundException {
+            File file = new File(filename);
+            sin = new FileInputStream(file);
+        }
+        private boolean hasNextByte() {
+            if (ptr < buflen) {
+                return true;
+            }else{
+                ptr = 0;
+                try {
+                    buflen = sin.read(buffer);
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+                if (buflen <= 0) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        private int readByte() { if (hasNextByte()) return buffer[ptr++]; else return -1;}
+        private static boolean isPrintableChar(int c) { return 33 <= c && c <= 126;}
+        public boolean hasNext() { while(hasNextByte() && !isPrintableChar(buffer[ptr])) ptr++; return hasNextByte();}
+        public String next() {
+            if (!hasNext()) throw new NoSuchElementException();
+            StringBuilder sb = new StringBuilder();
+            int b = readByte();
+            while(isPrintableChar(b)) {
+                sb.appendCodePoint(b);
+                b = readByte();
+            }
+            return sb.toString();
+        }
+        public long nextLong() {
+            if (!hasNext()) throw new NoSuchElementException();
+            long n = 0;
+            boolean minus = false;
+            int b = readByte();
+            if (b == '-') {
+                minus = true;
+                b = readByte();
+            }
+            if (b < '0' || '9' < b) {
+                throw new NumberFormatException();
+            }
+            while(true){
+                if ('0' <= b && b <= '9') {
+                    n *= 10;
+                    n += b - '0';
+                }else if(b == -1 || !isPrintableChar(b) || b == ':'){
+                    return minus ? -n : n;
+                }else{
+                    throw new NumberFormatException();
+                }
+                b = readByte();
+            }
+        }
+        public int nextInt() {
+            long nl = nextLong();
+            if (nl < Integer.MIN_VALUE || nl > Integer.MAX_VALUE) throw new NumberFormatException();
+            return (int) nl;
+        }
+        public double nextDouble() { return Double.parseDouble(next());}
+        public long[] nextLongArray(final int n){
+            final long[] a = new long[n];
+            for (int i = 0; i < n; i++)
+                a[i] = nextLong();
+            return a;
+        }
+        public int[] nextIntArray(final int n){
+            final int[] a = new int[n];
+            for (int i = 0; i < n; i++)
+                a[i] = nextInt();
+            return a;
+        }
+        public double[] nextDoubleArray(final int n){
+            final double[] a = new double[n];
+            for (int i = 0; i < n; i++)
+                a[i] = nextDouble();
+            return a;
+        }
+
+        public List<Integer>[] adjacencyList(int nodes, int edges) {
+            return adjacencyList(nodes, edges, false);
+        }
+        public List<Integer>[] adjacencyList(int nodes, int edges, boolean isDirected) {
+
+            List<Integer>[] adj = new ArrayList[nodes + 1];
+            Arrays.setAll(adj, (i) -> new ArrayList<>());
+            for (int i = 0; i < edges; i++) {
+                int a = nextInt(), b = nextInt();
+                adj[a].add(b);
+                if (!isDirected) adj[b].add(a);
+            }
+            return adj;
+        }
+    }
+
+    static int findDistance(List<Integer> G[], int nodes, int src, int dst) {
+
+        LinkedList<Integer> queue = new LinkedList<>();
+        int dist[] = new int[nodes + 1];
+        int ans = -1;
+        dist[src] = 0;
+        queue.add(src);
+        while(queue.size() > 0) {
+            int u = queue.poll();
+            if(u == dst) {
+                ans = dist[u];
+            }
+            for(int v : G[u]) {
+                if(dist[v] >= 0)
+                    continue;
+                queue.add(v);
+                dist[v] = dist[u] + 1;
+            }
+        }
+        return ans;
+    }
+
+    static void sort(int A[]) {
+        shuffleArray(A);
+        Arrays.sort(A);
+    }
+    static void sort(long A[]) {
+        shuffleArray(A);
+        Arrays.sort(A);
+    }
+    static void sort(double A[]) {
+        shuffleArray(A);
+        Arrays.sort(A);
+    }
+    static void shuffleArray(int[] A) {
+        int n = A.length;
+        for(int i = 0; i < n; i++) {
+            int tmp = A[i];
+            int randomPos = i + random.nextInt(n-i);
+            A[i] = A[randomPos];
+            A[randomPos] = tmp;
+        }
+    }
+    static void shuffleArray(long[] A) {
+        int n = A.length;
+        for(int i = 0; i < n; i++) {
+            long tmp = A[i];
+            int randomPos = i + random.nextInt(n-i);
+            A[i] = A[randomPos];
+            A[randomPos] = tmp;
+        }
+    }
+    static void shuffleArray(double[] A) {
+        int n = A.length;
+        for(int i = 0; i < n; i++) {
+            double tmp = A[i];
+            int randomPos = i + random.nextInt(n-i);
+            A[i] = A[randomPos];
+            A[randomPos] = tmp;
+        }
+    }
+
+    static int[] subArray(int A[], int x, int y) {
+        int B[] = new int[y - x + 1];
+        for(int i = x; i <= y; i++)
+            B[i-x] = A[i];
+        return B;
+    }
+
+    static int[] toArray(List<Integer> L) {
+        return L.stream().mapToInt(x -> x).toArray();
+    }
+
+    static void println(int[] A) {
+        for(int e: A) System.out.print(e + "" "");
+        System.out.println();
+    }
+
+    static void println(long[] A) {
+        for(long e: A) System.out.print(e + "" "");
+        System.out.println();
+    }
+
+    static void println(List arr) {
+        for(Object e: arr) System.out.print(e + "" "");
+        System.out.println();
+    }
+
+    static void print(String s) {
+        System.out.print(s);
+    }
+
+    static void println(String s) {
+        System.out.println(s);
+    }
+
+    static List<Integer> toList(int ar[]) {
+        return Arrays.stream(ar).boxed().collect(Collectors.toList());
+    }
+
+    static List<Long> toList(long ar[]) {
+        return Arrays.stream(ar).boxed().collect(Collectors.toList());
+    }
+
+    static List<Double> toList(double ar[]) {
+        return Arrays.stream(ar).boxed().collect(Collectors.toList());
+    }
+
+    static long gcd(long a, long b) {
+        if(b == 0)
+            return a;
+        return gcd(b, a % b);
+    }
+
+    private static int abs(int a){  return (a>=0) ? a: -a;  }
+    private static int min(int... ins){ return Arrays.stream(ins).min().getAsInt(); }
+    private static int max(int... ins){ return Arrays.stream(ins).max().getAsInt(); }
+    private static int sum(int... ins){ return Arrays.stream(ins).sum(); }
+    private static long abs(long a){ return (a>=0) ? a: -a; }
+    private static long min(long... ins){ return Arrays.stream(ins).min().getAsLong(); }
+    private static long max(long... ins){ return Arrays.stream(ins).max().getAsLong(); }
+    private static long sum(long... ins){ return Arrays.stream(ins).sum(); }
+    private static double abs(double a){ return (a>=0) ? a: -a; }
+    private static double min(double... ins){ return Arrays.stream(ins).min().getAsDouble(); }
+    private static double max(double... ins){ return Arrays.stream(ins).max().getAsDouble(); }
+    private static double sum(double... ins){ return Arrays.stream(ins).sum(); }
+
+    private static class Pair implements Comparable<Pair> {
+        int x, y;
+        Pair(int x, int y) { this.x = x; this.y = y; }
+        Pair() {}
+
+        @Override
+        public int compareTo(Pair other) {
+            return x == other.x ? y - other.y : x - other.x;
+        }
+
+        @Override
+        public boolean equals(Object o) {
+            if (this == o) return true;
+            if (o == null || getClass() != o.getClass()) return false;
+            Pair pair = (Pair) o;
+            return x == pair.x &&
+                    y == pair.y;
+        }
+
+        @Override
+        public int hashCode() {
+            return Objects.hash(x, y);
+        }
+    }
+}",0
+808f7516,9ebe348d,"import java.util.*;
+import java.io.*;
+public class EdD {
+	public static void main(String[] args) throws Exception{
+		int num = 998244353;
+
+		// TODO Auto-generated method stub
+ 		BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
+ 		PrintWriter out = new PrintWriter(System.out);
+//	 		String input1 = bf.readLine().trim();
+//	 		String input2 = bf.readLine().trim();
+ 		int n = Integer.parseInt(bf.readLine());
+ 		int[] array = new int[n];
+ 		StringTokenizer st = new StringTokenizer(bf.readLine());
+ 		for(int j = 0;j<n;j++){
+ 			array[j] = Integer.parseInt(st.nextToken());
+ 		}
+ 		Map<Integer, Set<Integer>> mp = new HashMap<Integer, Set<Integer>>();
+ 		for(int j =0;j<n;j++)
+ 			mp.put(j, new HashSet<Integer>());
+ 		int[] nextge = new int[n];
+ 		int[] nextle = new int[n];
+ 		int[] prevge = new int[n];
+ 		int[] prevle = new int[n];
+ 		nextge[n-1] = -1;
+ 		nextle[n-1] = -1;
+ 		prevge[0] = -1;
+ 		prevle[0] = -1;
+ 		for(int j = n-2;j>=0;j--){
+ 			if (array[j+1] < array[j]){
+ 				nextle[j] = j+1;
+ 				mp.get(j).add(j+1);
+ 				int temp = j+1;
+ 				while(temp!= -1 && array[temp] < array[j])
+ 					temp = nextge[temp];
+ 				nextge[j] = temp;
+ 				if (temp!= -1)
+ 					mp.get(j).add(temp);
+ 			}
+ 			else if (array[j+1] > array[j]){
+ 				nextge[j] = j+1;
+ 				mp.get(j).add(j+1);
+ 				int temp = j+1;
+ 				while(temp!= -1 && array[temp] > array[j])
+ 					temp = nextle[temp];
+ 				nextle[j] = temp;
+ 				if (temp!= -1)
+ 					mp.get(j).add(temp);
+ 			}
+ 			else{
+ 				nextge[j] = j+1;
+ 				mp.get(j).add(j+1);
+ 				nextle[j] = j+1;
+ 				mp.get(j).add(j+1);
+ 			}	
+ 		}
+ 		for(int j = 1;j<n;j++){
+ 			if (array[j] < array[j-1]){
+ 			
+ 				prevge[j] = j-1;
+ 				mp.get(j-1).add(j);
+ 				int temp = j-1;
+ 				while(temp!= -1 && array[temp] > array[j])
+ 					temp = prevle[temp];
+ 				prevle[j] = temp;
+ 				if (temp!= -1)
+ 					mp.get(temp).add(j);
+ 			}
+ 			else if (array[j] > array[j-1]){
+ 				prevle[j] = j-1;
+ 				mp.get(j-1).add(j);
+ 				int temp = j-1;
+ 				while(temp!= -1 && array[temp] < array[j])
+ 					temp = prevge[temp];
+ 				prevge[j] = temp;
+ 				if (temp!= -1)
+ 					mp.get(temp).add(j);
+ 			}
+ 			else{
+ 				prevge[j] = j-1;
+ 				prevle[j] = j-1;
+ 				mp.get(j-1).add(j);
+ 			}	
+ 		}
+	 	int[] depth = new int[n+1];
+ 		Set<Integer> seen = new HashSet<Integer>();
+ 		Queue<Integer> bfs = new LinkedList<Integer>();
+ 		bfs.add(0);
+ 		seen.add(0);
+ 		while(!bfs.isEmpty()){
+ 			int v = bfs.remove();
+ 			for(int child : mp.get(v)){
+ 				if (!seen.contains(child)){
+ 					bfs.add(child);
+ 					seen.add(child);
+ 					depth[child] = depth[v]+1;
+ 				}
+ 			}
+ 		}
+ 		
+ 		
+ 		out.println(depth[n-1]);
+	 		
+ 		out.close();
+ 		
+ 		
+ 		
+ 	}
+}
+ 	
+ 
+//StringJoiner sj = new StringJoiner("" ""); 
+//sj.add(strings)
+//sj.toString() gives string of those stuff w spaces or whatever that sequence is
+
+ 		
+ 		
+ 		
+ 		
+	
+
+
+","import java.io.OutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.PrintWriter;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.TreeSet;
+import java.util.ArrayList;
+import java.util.StringTokenizer;
+import java.io.BufferedReader;
+import java.io.InputStream;
+
+/**
+ * Built using CHelper plug-in
+ * Actual solution is at the top
+ */
+public class Main {
+    public static void main(String[] args) {
+        InputStream inputStream = System.in;
+        OutputStream outputStream = System.out;
+        InputReader in = new InputReader(inputStream);
+        PrintWriter out = new PrintWriter(outputStream);
+        TaskD solver = new TaskD();
+        solver.solve(1, in, out);
+        out.close();
+    }
+
+    static class TaskD {
+        public void solve(int testNumber, InputReader in, PrintWriter out) {
+            int N = in.nextInt();
+            int[] h = new int[N];
+            int[] hsort = new int[N];
+            HashMap<Integer, Integer> condense = new HashMap<>();
+            for (int i = 0; i < N; i++) {
+                h[i] = in.nextInt();
+                hsort[i] = h[i];
+            }
+            ArrayUtils.sort(hsort);
+            int timer = 0;
+            int[] t = new int[N];
+            for (int i = 0; i < N; i++) {
+                if (!condense.containsKey(hsort[i])) {
+                    condense.put(hsort[i], timer++);
+                    t[timer - 1]++;
+                } else {
+                    t[condense.get(hsort[i])]++;
+                }
+            }
+            int[][] heights = new int[timer][];
+            for (int i = 0; i < timer; i++) {
+                heights[i] = new int[t[i]];
+                t[i] = 0;
+            }
+            for (int i = 0; i < N; i++) {
+                h[i] = condense.get(h[i]);
+                heights[h[i]][t[h[i]]++] = i;
+            }
+            TreeSet<Integer> cur = new TreeSet<>();
+            ArrayList<Integer>[] to = new ArrayList[N];
+            for (int i = 0; i < N; i++) {
+                to[i] = new ArrayList<>();
+                if (i != N - 1) {
+                    to[i].add(i + 1);
+                }
+            }
+            int low = N + 1;
+            int high = -1;
+            for (int i = 0; i < timer; i++) {
+                for (int e : heights[i]) {
+                    cur.add(e);
+                    low = Math.min(low, e);
+                    high = Math.max(high, e);
+                }
+                for (int e : heights[i]) {
+                    if (low < e) {
+                        to[cur.lower(e)].add(e);
+                    }
+                    if (high > e) {
+                        to[e].add(cur.higher(e));
+                    }
+                }
+            }
+            cur.clear();
+            low = N + 1;
+            high = -1;
+            for (int i = timer - 1; i >= 0; i--) {
+                for (int e : heights[i]) {
+                    cur.add(e);
+                    low = Math.min(low, e);
+                    high = Math.max(high, e);
+                }
+                for (int e : heights[i]) {
+                    if (low < e) {
+                        to[cur.lower(e)].add(e);
+                    }
+                    if (high > e) {
+                        to[e].add(cur.higher(e));
+                    }
+                }
+            }
+            long[] dp = new long[N];
+            Arrays.fill(dp, (int) (1e8));
+            dp[0] = 0;
+            for (int i = 0; i < N; i++) {
+                for (int toa : to[i]) {
+                    dp[toa] = Math.min(dp[toa], dp[i] + 1);
+                }
+            }
+            out.println(dp[N - 1]);
+        }
+
+    }
+
+    static class InputReader {
+        public BufferedReader reader;
+        public StringTokenizer tokenizer;
+
+        public InputReader(InputStream stream) {
+            reader = new BufferedReader(new InputStreamReader(stream), 32768);
+            tokenizer = null;
+        }
+
+        public String next() {
+            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
+                try {
+                    tokenizer = new StringTokenizer(reader.readLine());
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+            }
+            return tokenizer.nextToken();
+        }
+
+        public int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+    }
+
+    static class ArrayUtils {
+        public static void shuffle(int[] arr) {
+            for (int i = 0; i < arr.length; i++) {
+                int rand = (int) (Math.random() * (i + 1));
+                swap(arr, i, rand);
+            }
+        }
+
+        public static void swap(int[] arr, int i, int j) {
+            int temp = arr[i];
+            arr[i] = arr[j];
+            arr[j] = temp;
+        }
+
+        public static void sort(int[] arr) {
+            shuffle(arr);
+            Arrays.sort(arr);
+            //get rid of quicksort cases
+        }
+
+    }
+}
+
+",0
+28c2d81a,48c5f745,"
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.*;
+
+public class D {
+    public static void main(String[] args) {
+        FastScanner fs = new FastScanner();
+        int cases = fs.nextInt();
+        while(cases-->0){
+            int n = fs.nextInt(), k = fs.nextInt();
+            int[] positions = fs.readArray(k), temps = fs.readArray(k);
+            int[] forced = new int[n];
+            Arrays.fill(forced, Integer.MAX_VALUE/2);
+            for(int i=0; i<k; i++)
+                forced[positions[i]-1] = temps[i];
+            for(int i=1; i<n; i++)
+                forced[i] = Math.min(forced[i],forced[i-1]+1);
+            for(int i=n-2; i>=0; i--)
+                forced[i] = Math.min(forced[i], forced[i+1]+1);
+            for(int i=0; i<n; i++)
+                System.out.print(forced[i] + "" "");
+            System.out.println();
+
+        }
+    }
+
+
+
+
+
+    //----------------------------------------------------------------------------------//
+    static class FastScanner {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st = new StringTokenizer("""");
+        String next() {
+            while (!st.hasMoreTokens())
+                try {
+                    st=new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+        char nextChar(){
+            return next().charAt(0);
+        }
+        int[] readArray(int n) {
+            int[] a=new int[n];
+            for (int i=0; i<n; i++) a[i]=nextInt();
+            return a;
+        }
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+    }
+    static class Debug{
+        public static void debug(long a){
+            System.out.println(""--> ""+a);
+        }
+        public static void debug(long a, long b){
+            System.out.println(""--> ""+ a +"" + "" + b);
+        }
+        public static void debug(char a, char b){ System.out.println(""--> ""+ a +"" + "" + b); }
+        public static void debug(int[] array){
+            System.out.print(""Array--> "");
+            System.out.println(Arrays.toString(array));
+        }
+        public static void debug(char[] array){
+            System.out.print(""Array--> "");
+            System.out.println(Arrays.toString(array));
+        }
+        public static void debug(HashMap<Integer,Integer> map){
+            System.out.print(""Map--> ""+map.toString());
+        }
+    }
+}
+","
+import java.io.*;
+import java.util.*;
+public class E {
+
+
+	public static void main(String[] args) throws Exception {
+		// TODO Auto-generated method stub
+		Reader sc=new Reader();
+		PrintWriter pw=new PrintWriter(System.out);
+		int t=sc.nextInt();
+		while(t-->0) {
+			int n=sc.nextInt();
+			int k=sc.nextInt();
+			int[] idxes=new int[k];
+			int[] temps=new int[k];
+			for(int i=0;i<k;i++) {
+				idxes[i]=sc.nextInt()-1;
+			}
+			for(int i=0;i<k;i++) {
+				temps[i]=sc.nextInt();
+			}
+			int[] ans=new int[n];
+			Arrays.fill(ans, Integer.MAX_VALUE/2);
+			for(int i=0;i<k;i++) {
+				ans[idxes[i]]=temps[i];
+			}
+			for(int i=1;i<n;i++) {
+				ans[i]=Math.min(ans[i], ans[i-1]+1);
+			}
+			for(int i=n-2;i>=0;i--) {
+				ans[i]=Math.min(ans[i], ans[i+1]+1);
+			}
+			for(int i=0;i<n;i++) {
+				pw.print(ans[i]+"" "");
+			}
+			pw.println();
+			
+		}
+		pw.flush();
+		sc.close();
+	}
+	
+	static class Reader {
+        final private int BUFFER_SIZE = 1 << 16;
+        private DataInputStream din;
+        private byte[] buffer;
+        private int bufferPointer, bytesRead;
+ 
+        public Reader()
+        {
+            din = new DataInputStream(System.in);
+            buffer = new byte[BUFFER_SIZE];
+            bufferPointer = bytesRead = 0;
+        }
+ 
+        public Reader(String file_name) throws IOException
+        {
+            din = new DataInputStream(
+                new FileInputStream(file_name));
+            buffer = new byte[BUFFER_SIZE];
+            bufferPointer = bytesRead = 0;
+        }
+ 
+        public String readLine() throws IOException
+        {
+            byte[] buf = new byte[64]; // line length
+            int cnt = 0, c;
+            while ((c = read()) != -1) {
+                if (c == '\n') {
+                    if (cnt != 0) {
+                        break;
+                    }
+                    else {
+                        continue;
+                    }
+                }
+                buf[cnt++] = (byte)c;
+            }
+            return new String(buf, 0, cnt);
+        }
+ 
+        public int nextInt() throws IOException
+        {
+            int ret = 0;
+            byte c = read();
+            while (c <= ' ') {
+                c = read();
+            }
+            boolean neg = (c == '-');
+            if (neg)
+                c = read();
+            do {
+                ret = ret * 10 + c - '0';
+            } while ((c = read()) >= '0' && c <= '9');
+ 
+            if (neg)
+                return -ret;
+            return ret;
+        }
+ 
+        public long nextLong() throws IOException
+        {
+            long ret = 0;
+            byte c = read();
+            while (c <= ' ')
+                c = read();
+            boolean neg = (c == '-');
+            if (neg)
+                c = read();
+            do {
+                ret = ret * 10 + c - '0';
+            } while ((c = read()) >= '0' && c <= '9');
+            if (neg)
+                return -ret;
+            return ret;
+        }
+ 
+        public double nextDouble() throws IOException
+        {
+            double ret = 0, div = 1;
+            byte c = read();
+            while (c <= ' ')
+                c = read();
+            boolean neg = (c == '-');
+            if (neg)
+                c = read();
+ 
+            do {
+                ret = ret * 10 + c - '0';
+            } while ((c = read()) >= '0' && c <= '9');
+ 
+            if (c == '.') {
+                while ((c = read()) >= '0' && c <= '9') {
+                    ret += (c - '0') / (div *= 10);
+                }
+            }
+ 
+            if (neg)
+                return -ret;
+            return ret;
+        }
+ 
+        private void fillBuffer() throws IOException
+        {
+            bytesRead = din.read(buffer, bufferPointer = 0,
+                                 BUFFER_SIZE);
+            if (bytesRead == -1)
+                buffer[0] = -1;
+        }
+ 
+        private byte read() throws IOException
+        {
+            if (bufferPointer == bytesRead)
+                fillBuffer();
+            return buffer[bufferPointer++];
+        }
+ 
+        public void close() throws IOException
+        {
+            if (din == null)
+                return;
+            din.close();
+        }
+    }
+
+}
+
+",1
+3b498a39,ae775964,"/*
+ *     HI THERE! (: 
+ * 
+ * CREATED BY : NAITIK V
+ * 
+ *     JAI HIND
+ * 
+ */
+
+import java.util.*;
+
+
+import java.io.*;
+import java.math.*;
+
+public class Main
+
+{ 
+	 static FastReader sc=new FastReader(); 
+	 static long dp[][];
+	 static int mod=1000000007;
+	 static int max;
+	  public static void main(String[] args)
+{
+		   PrintWriter out=new PrintWriter(System.out);
+		   //StringBuffer sb=new StringBuffer("""");
+		  int ttt=1;
+		   //ttt =i();
+		 
+	        outer :while (ttt-- > 0) 
+			{
+	        	int n=i();
+	        	int A[]=input(n);
+	        	dp=new long[n+1][n+1];
+	        	for(int i=0;i<=n;i++) {
+	        		Arrays.fill(dp[i],-1);
+	        	}
+		        	
+	        	
+	        	ArrayList<Integer> l=new ArrayList<Integer>();
+	        	ArrayList<Integer> m=new ArrayList<Integer>();
+	        	for(int i=0;i<n;i++) {
+	        		if(A[i]==0) {
+	        			l.add(i+1);
+	        		}
+	        		else {
+	        			m.add(i+1);
+	        		}
+	        	}
+	        	A=new int[m.size()];
+	        	int B[]=new int[l.size()];
+	        	for(int i=0;i<l.size();i++) {
+	        		B[i]=l.get(i);
+	        	}
+	        	for(int i=0;i<m.size();i++) {
+	        		A[i]=m.get(i);
+	        	}
+	        	n=m.size();
+	        	int o=l.size();
+		        	System.out.println(go(A,B,0,0,n,o));
+	        	
+			}
+
+	     //System.out.println(sb.toString());
+		     out.close();
+	     
+	     
+	    //CHECK FOR N=1                    //CHECK FOR M=0
+        //CHECK FOR N=1                    //CHECK FOR M=0
+       	//CHECK FOR N=1
+       	//CHECK FOR N=1
+       	//CHECK FOR N=1
+		        
+		     
+    }
+	  
+	 
+	  
+	  
+	
+	 
+	private static long go(int[] A, int[] B, int i, int j, int n, int m) {
+		if(i==n)
+			return 0;
+		if(j==m)
+			return Integer.MAX_VALUE;
+		if(dp[i][j]!=-1)
+			return dp[i][j];
+		long op1=go(A, B, i+1, j+1, n, m)+Math.abs(A[i]-B[j]);
+		long op2=go(A, B, i, j+1, n, m);
+		return dp[i][j]=Math.min(op1, op2);
+	
+		
+		
+		
+		
+		}
+
+
+
+
+
+
+static class Pair implements Comparable<Pair>
+     {
+    	 int x;
+    	 int y;
+    	 Pair(int x,int y){
+    		 this.x=x;
+    		 this.y=y;
+    	 }
+		@Override
+		public int compareTo(Pair o) {
+			if(this.x>o.x)
+				return 1;
+			else if(this.x<o.x)
+				return -1;
+			else {
+				if(this.y>o.y)
+					return 1;
+				else if(this.y<o.y)
+					return -1;
+				else
+					return 0;
+			}
+		}
+		
+		/* FOR TREE MAP PAIR USE */
+		
+//		public int compareTo(Pair o) {
+// 			if (x > o.x) {
+// 				return 1;
+// 			}
+// 			if (x < o.x) {
+// 				return -1;
+// 			}
+// 			if (y > o.y) {
+// 				return 1;
+// 			}
+// 			if (y < o.y) {
+// 				return -1;
+// 			}
+// 			return 0;
+// 		}
+	
+		
+     }
+
+static int[] input(int n) {
+	int A[]=new int[n];
+	   for(int i=0;i<n;i++) {
+		   A[i]=sc.nextInt();
+	   }
+	   return A;
+   }
+static long[] inputL(int n) {
+	long A[]=new long[n];
+	   for(int i=0;i<n;i++) {
+		   A[i]=sc.nextLong();
+	   }
+	   return A;
+   }
+static String[] inputS(int n) {
+	String A[]=new String[n];
+	   for(int i=0;i<n;i++) {
+		   A[i]=sc.next();
+	   }
+	   return A;
+   }
+static long sum(int A[]) {
+	long sum=0;
+	for(int i : A) {
+		sum+=i;
+	}
+	return sum;
+}
+static long sum(long A[]) {
+	long sum=0;
+	for(long i : A) {
+		sum+=i;
+	}
+	return sum;
+}
+static void reverse(long A[]) {
+	int n=A.length;
+	long B[]=new long[n];
+	for(int i=0;i<n;i++) {
+		B[i]=A[n-i-1];
+	}
+	for(int i=0;i<n;i++)
+		A[i]=B[i];
+	
+}
+static void reverse(int A[]) {
+	int n=A.length;
+	int B[]=new int[n];
+	for(int i=0;i<n;i++) {
+		B[i]=A[n-i-1];
+	}
+	for(int i=0;i<n;i++)
+		A[i]=B[i];
+	
+}
+static void input(int A[],int B[]) {
+	   for(int i=0;i<A.length;i++) {
+		   A[i]=sc.nextInt();
+		   B[i]=sc.nextInt();
+	   }
+}
+static int[][] input(int n,int m){
+	int A[][]=new int[n][m];
+	for(int i=0;i<n;i++) {
+		for(int j=0;j<m;j++) {
+			A[i][j]=i();
+		}
+	}
+	return A;
+}
+static char[][] charinput(int n,int m){
+	char A[][]=new char[n][m];
+	for(int i=0;i<n;i++) {
+		String s=s();
+		for(int j=0;j<m;j++) {
+			A[i][j]=s.charAt(j);
+		}
+	}
+	return A;
+}
+static int max(int A[]) {
+	int max=Integer.MIN_VALUE;
+	for(int i=0;i<A.length;i++) {
+		max=Math.max(max, A[i]);
+	}
+	return max;
+}
+static int min(int A[]) {
+	int min=Integer.MAX_VALUE;
+	for(int i=0;i<A.length;i++) {
+		min=Math.min(min, A[i]);
+	}
+	return min;
+}
+static long max(long A[]) {
+	long max=Long.MIN_VALUE;
+	for(int i=0;i<A.length;i++) {
+		max=Math.max(max, A[i]);
+	}
+	return max;
+}
+static long min(long A[]) {
+	long min=Long.MAX_VALUE;
+	for(int i=0;i<A.length;i++) {
+		min=Math.min(min, A[i]);
+	}
+	return min;
+}
+static long [] prefix(long A[]) {
+	long p[]=new long[A.length];
+	p[0]=A[0];
+	for(int i=1;i<A.length;i++)
+		p[i]=p[i-1]+A[i];
+	return p;
+}
+static long [] prefix(int A[]) {
+	long p[]=new long[A.length];
+	p[0]=A[0];
+	for(int i=1;i<A.length;i++)
+		p[i]=p[i-1]+A[i];
+	return p;
+}
+static long [] suffix(long A[]) {
+	long p[]=new long[A.length];
+	p[A.length-1]=A[A.length-1];
+	for(int i=A.length-2;i>=0;i--)
+		p[i]=p[i+1]+A[i];
+	return p;
+}
+static long [] suffix(int A[]) {
+	long p[]=new long[A.length];
+	p[A.length-1]=A[A.length-1];
+	for(int i=A.length-2;i>=0;i--)
+		p[i]=p[i+1]+A[i];
+	return p;
+}
+static long power(long x, long y, long p)
+{
+
+	if(y==0)
+		return 1;
+	if(x==0)
+		return 0;
+    long res = 1;
+    x = x % p;
+
+    while (y > 0) {
+
+        if (y % 2 == 1)
+            res = (res * x) % p;
+
+        y = y >> 1; 
+        x = (x * x) % p;
+    }
+
+    return res;
+}
+static void print(int A[]) {
+	for(int i : A) {
+		System.out.print(i+"" "");
+	}
+	System.out.println();
+}
+static void print(long A[]) {
+	for(long i : A) {
+		System.out.print(i+"" "");
+	}
+	System.out.println();
+}
+static long mod(long x) {
+	  return ((x%mod + mod)%mod);
+}
+static String reverse(String s) {
+	StringBuffer p=new StringBuffer(s);
+	p.reverse();
+	return p.toString();
+}
+
+     static int i() {
+    	 return sc.nextInt();
+     }
+     static String s() {
+    	 return sc.next();
+     }
+     static long l() {
+    	 return sc.nextLong();
+     }  
+     static void sort(int[] A){
+        int n = A.length;
+        Random rnd = new Random();
+        for(int i=0; i<n; ++i){
+            int tmp = A[i];
+            int randomPos = i + rnd.nextInt(n-i);
+            A[i] = A[randomPos];
+            A[randomPos] = tmp;
+        }
+        Arrays.sort(A);
+     }
+     static void sort(long[] A){
+	        int n = A.length;
+	        Random rnd = new Random();
+	        for(int i=0; i<n; ++i){
+	            long tmp = A[i];
+	            int randomPos = i + rnd.nextInt(n-i);
+	            A[i] = A[randomPos];
+	            A[randomPos] = tmp;
+	        }
+	        Arrays.sort(A);
+	     }
+  static String sort(String s) {
+ 	 Character ch[]=new Character[s.length()];
+ 	 for(int i=0;i<s.length();i++) {
+ 		 ch[i]=s.charAt(i);
+ 	 }
+ 	 Arrays.sort(ch);
+ 	 StringBuffer st=new StringBuffer("""");
+ 	 for(int i=0;i<s.length();i++) {
+ 		 st.append(ch[i]);
+ 	 }
+ 	 return st.toString();
+  }
+  static HashMap<Integer,Integer> hash(int A[]){
+	  HashMap<Integer,Integer> map=new HashMap<Integer, Integer>();
+	  for(int i : A) {
+		  if(map.containsKey(i)) {
+			  map.put(i, map.get(i)+1);
+		  }
+		  else {
+			  map.put(i, 1);
+		  }
+	  }
+	  return map;
+  }
+  static TreeMap<Integer,Integer> tree(int A[]){
+	  TreeMap<Integer,Integer> map=new TreeMap<Integer, Integer>();
+	  for(int i : A) {
+		  if(map.containsKey(i)) {
+			  map.put(i, map.get(i)+1);
+		  }
+		  else {
+			  map.put(i, 1);
+		  }
+	  }
+	  return map;
+  }
+     static boolean prime(int n) 
+	    { 
+	        if (n <= 1) 
+	            return false; 
+	        if (n <= 3) 
+	            return true; 
+	        if (n % 2 == 0 || n % 3 == 0) 
+	            return false; 
+	        double sq=Math.sqrt(n);
+	  
+	        for (int i = 5; i <= sq; i = i + 6) 
+	            if (n % i == 0 || n % (i + 2) == 0) 
+	                return false; 
+	        return true; 
+	    } 
+     static boolean prime(long n) 
+	    { 
+	        if (n <= 1) 
+	            return false; 
+	        if (n <= 3) 
+	            return true; 
+	        if (n % 2 == 0 || n % 3 == 0) 
+	            return false; 
+	        double sq=Math.sqrt(n);
+	  
+	        for (int i = 5; i <= sq; i = i + 6) 
+	            if (n % i == 0 || n % (i + 2) == 0) 
+	                return false; 
+	        return true; 
+	    } 
+     static int gcd(int a, int b) 
+     { 
+         if (a == 0) 
+             return b; 
+         return gcd(b % a, a); 
+     } 
+     static long gcd(long a, long b) 
+     { 
+         if (a == 0) 
+             return b; 
+         return gcd(b % a, a); 
+     } 
+     
+        
+    static class FastReader 
+    { 
+        BufferedReader br; 
+        StringTokenizer st; 
+  
+        public FastReader() 
+        { 
+            br = new BufferedReader(new
+                     InputStreamReader(System.in)); 
+        } 
+  
+        String next() 
+        { 
+            while (st == null || !st.hasMoreElements()) 
+            { 
+                try
+                { 
+                    st = new StringTokenizer(br.readLine()); 
+                } 
+                catch (IOException  e) 
+                { 
+                    e.printStackTrace(); 
+                } 
+            } 
+            return st.nextToken(); 
+        } 
+  
+        int nextInt() 
+        { 
+            return Integer.parseInt(next()); 
+        } 
+  
+        long nextLong() 
+        { 
+            return Long.parseLong(next()); 
+        } 
+  
+        double nextDouble() 
+        { 
+            return Double.parseDouble(next()); 
+        } 
+  
+        String nextLine() 
+        { 
+            String str = """"; 
+            try
+            { 
+                str = br.readLine(); 
+            } 
+            catch (IOException e) 
+            { 
+                e.printStackTrace(); 
+            } 
+            return str; 
+        } 
+    } 
+} 
+
+
+
+","
+import java.awt.Point;
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.io.ObjectInputStream.GetField;
+import java.lang.reflect.Array;
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Hashtable;
+import java.util.LinkedList;
+import java.util.PriorityQueue;
+import java.util.Queue;
+import java.util.Set;
+import java.util.Stack;
+import java.util.StringTokenizer;
+import java.util.TreeMap;
+import java.util.TreeSet;
+
+import javax.sound.sampled.ReverbType;
+
+
+public class Edu109 {
+	static PrintWriter out;
+	static Scanner sc;
+	static ArrayList<int[]>q,w,x;
+	static ArrayList<Integer>adj[];
+	static HashSet<Integer>primesH;
+	static boolean prime[];
+	//static ArrayList<Integer>a;
+	static HashSet<Long>tmp;
+	static int[][][]dist;
+	static boolean[]v;
+	static int[]a,b,c,d;
+	static Boolean[][]dp;
+	static char[][]mp;
+	static int A,B,n,m,h,ans,sum;
+	//static String a,b;
+	static long oo=(long)1e9+7;
+	public static void main(String[]args) throws IOException {
+		sc=new Scanner(System.in);
+		out=new PrintWriter(System.out);
+		//A();
+		//B();
+		//C();
+		D();
+		//E();
+		//F();
+		//G();
+		out.close();
+	}
+	  private static void A() throws IOException {
+		  int t=ni();
+		  while(t-->0) {
+				int k=ni();
+				int ans=0;
+				for(int i=1;i<=100;i++) {
+					if((i*100)%k==0) {
+						ans=i*100/k;break;
+					}
+				}
+				ol(ans);
+		  }
+		
+	   }
+		static void B() throws IOException {
+			int t=ni();
+			while(t-->0) {
+				int n=ni();
+				a=nai(n);
+				boolean isSorted=true,one=a[0]==1;
+				int pos=0;
+				for(int i=1;i<n;i++) {
+					if(a[i]<a[i-1])isSorted=false;
+					if(a[i]==1)pos=i;
+				}
+				boolean ok=true;
+				for(int i=pos+1;i<n;i++) {
+					if(a[i]<a[i-1])ok=false;
+				}
+				boolean lst=a[0]==n;
+				boolean fir=a[n-1]==1;
+				if(isSorted)ol(0);
+				else if(lst&&fir)ol(3);
+				else if(lst||fir)ol(2);
+				else if(a[0]==1||a[n-1]==n)ol(1);
+				else ol(2);
+//				if(isSorted)ol(0);
+//				else out.println(fl&&lst?3:((one?1:2)-(ok?1:0)+(lst?1:0)));
+			}
+		}
+		
+		static void C() throws IOException{
+			 int t=ni();
+			 while(t-->0) {
+				int n=ni();
+				int m=ni();
+				a=nai(n);
+				TreeMap<Integer, Integer>tr=new TreeMap<Integer, Integer>();
+				for(int i=0;i<n;i++)tr.put(a[i], i);
+				char[]mv=new char[n];
+				for(int i=0;i<n;i++) {
+					String s=ns();
+					mv[i]=s.charAt(0);
+				}
+				long[]ans=new long[n];
+				Arrays.fill(ans, -1);
+				PriorityQueue<Integer>lodd=new PriorityQueue<Integer>();
+				PriorityQueue<Integer>lev=new PriorityQueue<Integer>();
+				PriorityQueue<Integer>rodd=new PriorityQueue<Integer>();
+				PriorityQueue<Integer>rev=new PriorityQueue<Integer>();
+				for(int i=0;i<n;i++) {
+					if(a[i]%2==0) {
+						if(mv[i]=='L')lev.add(a[i]);
+						else rev.add(a[i]);
+					}else {
+						if(mv[i]=='L')lodd.add(a[i]);
+						else rodd.add(a[i]);
+					}
+				}
+				PriorityQueue<Integer>par[]=new PriorityQueue[4];
+				par[0]=rev;par[1]=rodd;par[2]=lev;par[3]=lodd;
+				for(int i=0;i<2;i++){
+					while(par[i].size()>=1&&par[i+2].size()>=1) {
+						int r=par[i].poll(),l=par[i+2].poll();
+						int d1=(l-r)/2;
+						if(l<r) {
+							d1=clc(l,r,m);
+						}
+						int dr=Integer.MAX_VALUE,dl=Integer.MAX_VALUE;
+						if(par[i].size()==1) {
+							dr=m-par[i].peek()+(par[i].peek()-r)/2;
+						}
+						if(!par[i+2].isEmpty()) {
+							dl=(par[i+2].peek()+l)/2;
+						}
+						int cur=Math.min(d1, Math.min(dl, dr));
+						if(cur==d1) {
+							ans[tr.get(r)]=ans[tr.get(l)]=cur;
+						}
+						else if(cur==dr) {
+							ans[tr.get(r)]=ans[tr.get(par[i].poll())]=cur;
+							par[i+2].add(l);
+						}else {
+							ans[tr.get(l)]=ans[tr.get(par[i+2].poll())]=cur;
+							par[i].add(r);
+						}
+						
+					}
+				}
+				for(int i=0;i<4;i++) {
+					if(i<2&&par[i].size()%2==1)par[i].poll();
+					while(par[i].size()>1) {
+						int x=par[i].poll(),y=par[i].poll();
+						int val=0;
+						if(i<2) {
+							val=m-y+(y-x)/2;
+						}else {
+							val=(x+y)/2;
+						}
+						ans[tr.get(x)]=ans[tr.get(y)]=val;
+					}
+				}
+				for(int i=0;i<n;i++) {
+					out.print(ans[i]+"" "");
+				}ol("""");
+			 }
+		}
+		private static int clc(int l, int r, int m) {
+			int b1=0,b2=m;
+			int ans=0;
+			if(l>m-r) {
+				ans+=l;
+				b2=2*m - l -r;// m-(l-m+r) -> m-l+m-r
+			}else {
+				ans+=m-r;
+				b1=m-r-l;
+			}
+			return ans+(b2-b1)/2;
+		}
+		private static Boolean dp(int i, int j) {
+			if(j>sum/2)return false;
+			if(i==x.size()) {
+				return sum/2==j;
+			}
+			if(dp[i][j]!=null)return dp[i][j];
+			
+			return dp[i][j]=dp(i+1,j+x.get(i)[0])||dp(i+1,j);
+		}
+		static boolean isPrime(long n) {
+			if(n==2)return true;
+			if(n<2||n%2==0)return false;
+			
+			for(long i=3L;i*i<n;i+=2l) {
+				long rem=(n%i);
+				if(rem==0)return false;
+			}
+			return true;
+		}
+		static long[][]mem;
+		static int ones;
+		static ArrayList<Integer>pos;
+		static void D() throws IOException {
+			int t=1;
+			while(t-->0) {
+				n=ni();
+				a=nai(n);
+				mem=new long[n][n];
+				ones=0;
+				pos=new ArrayList<Integer>();
+				for(int i=0;i<n;i++) {
+					Arrays.fill(mem[i], -1);
+					if(a[i]==1)pos.add(i);
+				}
+				ones=pos.size();
+				long ans=solve(0,0);
+				out.println(ans);
+			}
+		}
+		private static long solve(int i, int j) {
+			if(i==n||j>=ones)return j==ones?0:(long)1e14;
+			if(mem[i][j]!=-1)return mem[i][j];
+			long lv=solve(i+1,j);
+			if(a[i]==0) {
+				int pr=Math.abs(i-pos.get(j));
+				lv=Math.min(lv, pr+solve(i+1,j+1));
+			}
+			return mem[i][j]=lv;
+		}
+		private static int bfs(int i, int j,int k) {
+			boolean [][]vis=new boolean[dist.length][dist[0].length];
+			Queue<int[]>q=new LinkedList<int[]>();
+			int mn=Integer.MAX_VALUE;
+			q.add(new int[] {i,j,0,0});
+			int[]dx=new int[] {-1,1,0,0};
+			int[]dy=new int[] {0,0,1,-1};
+			while(!q.isEmpty()) {
+				int []x=q.poll();
+				vis[x[0]][x[1]]=true;
+				int c=x[2];
+				if(c>k/2)continue;
+				if(c>0&&k%c==0&&(k/c)%2==0) {
+					mn=Math.min(mn,x[3]*k/c );
+				}
+				for(int a=0;a<4;a++) {
+					int nx=x[0]+dx[a];
+					int ny=x[1]+dy[a];
+					if(valid(nx,ny)&&!vis[nx][ny]) {
+						q.add(new int[] {nx,ny,c+1,x[3]+dist[x[0]][x[1]][a]});
+					}
+				}
+				
+			}
+			return mn;
+		}
+		private static boolean valid(int nx, int ny) {
+			return nx>=0&&nx<dist.length&&ny>=0&&ny<dist[0].length;
+		}
+		static int gcd (int a, int b) {
+		    return b==0?a:gcd (b, a % b);
+		}
+		
+	static void E() throws IOException {
+		int t=ni();
+		while(t-->0) {
+			
+			
+		}
+		
+	}
+
+	static void F() throws IOException {
+		int t=ni();
+		while(t-->0) {
+			
+		}
+	}
+	static void CC() throws IOException {
+		for(int kk=2;kk<21;kk++) {
+			ol(kk+""   -------"");
+		int n=kk;
+		int k=n-2;
+		int msk=1<<k;
+		int[]a=new int[k];
+		for(int i=0;i<a.length;i++)a[i]=i+2;
+		int mx=1;
+		int ms=0;
+		for(int i=1;i<msk;i++) {
+			long prod=1;
+			int cnt=0;
+			for(int j=0;j<a.length;j++) {
+				if(((i>>j)&1)!=0) {
+					prod*=a[j];
+					cnt++;
+				}
+			}
+			if(cnt>=mx&&prod%n==1) {
+				mx=cnt;
+				ms=i;
+			}
+			
+		}
+		ol(mx==1?mx:mx+1);
+		out.print(1+"" "");
+		long pr=1;
+		for(int j=0;j<a.length;j++) {
+			if(((ms>>j)&1)!=0) {
+				out.print(a[j]+"" "");
+				pr*=a[j];
+			}
+		}
+		ol("""");
+		ol(""Prod: ""+pr);
+		ol(n+""*""+((pr-1)/n)+"" + ""+1);
+		}
+	}
+	static int ni() throws IOException {
+		return sc.nextInt();
+	}
+	static double nd() throws IOException {
+		return sc.nextDouble();
+	}
+	static long nl() throws IOException {
+		return  sc.nextLong();
+	}
+	static String ns() throws IOException {
+		return sc.next();
+	}
+	static int[] nai(int n) throws IOException {
+		int[] a = new int[n];
+		for (int i = 0; i < n; i++)
+			a[i] = sc.nextInt();
+		return a;
+	}
+	static long[] nal(int n) throws IOException {
+		long[] a = new long[n];
+		for (int i = 0; i < n; i++)
+			a[i] = sc.nextLong();
+		return a;
+	}
+	static int[][] nmi(int n,int m) throws IOException{
+		int[][]a=new int[n][m];
+		for(int i=0;i<n;i++) {
+			for(int j=0;j<m;j++) {
+				a[i][j]=sc.nextInt();
+			}
+		}
+		return a;
+	}
+
+	static long[][] nml(int n,int m) throws IOException{
+		long[][]a=new long[n][m];
+		for(int i=0;i<n;i++) {
+			for(int j=0;j<m;j++) {
+				a[i][j]=sc.nextLong();
+			}
+		}
+		return a;
+	}
+	static void o(String x) {
+		out.print(x);
+	}
+	static void ol(String x) {
+		out.println(x);
+	}
+	static void ol(int x) {
+		out.println(x);
+	}
+	static void disp1(int []a) {
+		for(int i=0;i<a.length;i++) {
+			out.print(a[i]+"" "");
+		}
+		out.println();
+	}
+
+	static class Scanner 
+	{
+		StringTokenizer st;
+		BufferedReader br;
+
+		public Scanner(InputStream s){	br = new BufferedReader(new InputStreamReader(s));}
+
+		public String next() throws IOException 
+		{
+			while (st == null || !st.hasMoreTokens()) 
+				st = new StringTokenizer(br.readLine());
+			return st.nextToken();
+		}
+		public boolean hasNext() {return st.hasMoreTokens();}
+		public int nextInt() throws IOException {return Integer.parseInt(next());}
+		
+		public double nextDouble() throws IOException {return Double.parseDouble(next());}
+		
+		public long nextLong() throws IOException {return Long.parseLong(next());}
+
+		public String nextLine() throws IOException {return br.readLine();}
+			
+		public boolean ready() throws IOException {return br.ready(); }
+		
+
+	}
+}
+",0
+8e990c75,96b3758b,"import java.util.Scanner;
+
+public class Armchairs {
+    public static void main(String[] args) {
+        Scanner scanner = new Scanner(System.in);
+        int num = scanner.nextInt();
+        int[] chairs = new int[num];
+        int numOne = 0;
+        for (int i = 0; i < num; i++) {
+            chairs[i] = scanner.nextInt();
+            if (chairs[i] == 1) numOne++;
+        }
+        if (numOne == 0) {
+            System.out.println(0);
+            return;
+        }
+        int one = 0;
+        int zero = 0;
+
+        int[] ones = new int[numOne];
+        int[] zeros = new int[num - numOne];
+
+        for (int i = 0; i < num; i++) {
+            if (chairs[i] == 0) zeros[zero++] = i;
+            else ones[one++] = i;
+        }
+
+        long[][] nums = new long[numOne][num - numOne];
+        for (int c = 0; c < num - numOne; c++)
+            nums[0][c] = Math.abs(ones[0] - zeros[c]);
+
+        for (int r = 1; r < numOne; r++) {
+            long min = nums[r - 1][r - 1];
+            for (int c = r; c < num - numOne; c++) {
+                min = Math.min(nums[r - 1][c - 1], min);
+                nums[r][c] = min + Math.abs(ones[r] - zeros[c]);
+            }
+        }
+
+        Long result = Long.MAX_VALUE;
+        for (long min: nums[numOne - 1]) {
+            if (min > 0) result = Math.min(result, min);
+        }
+        System.out.println(result);
+    }
+}
+","
+import java.io.*;
+import java.util.*;
+
+public class D {
+	
+	static int[][] dp;
+	
+	static int solve(int i,int j,ArrayList<Integer> A,ArrayList<Integer> B) {
+		if(i==A.size()) {
+			return 0;
+		}
+		if(j==B.size()) {
+			return 1000000009;
+		}
+		if(dp[i][j]!=-1) {
+			return dp[i][j];
+		}
+		int ans=1000000009;
+		int a=A.get(i);
+		int b=B.get(j);
+		ans=Math.min(ans, Math.abs(a-b)+solve(i+1,j+1,A,B));
+		ans=Math.min(ans, solve(i,j+1,A,B));
+		return dp[i][j]=ans;
+	}
+
+	public static void main(String[] args){
+		FastReader sc=new FastReader();
+		int t=1;
+		while(t-->0) {
+			int n=sc.nextInt();
+			int[] a=new int[n];
+			ArrayList<Integer> A=new ArrayList<>();
+			ArrayList<Integer> B=new ArrayList<>();
+			for(int i=0;i<n;i++) {
+				a[i]=sc.nextInt();
+				if(a[i]==1) {
+					A.add(i);
+				} else {
+					B.add(i);
+				}
+			}
+			dp=new int[5010][5010];
+			for(int i=0;i<5010;i++) {
+				Arrays.fill(dp[i], -1);
+			}
+			System.out.println(solve(0,0,A,B));
+			
+		}
+	}
+	static class FastReader {
+		BufferedReader br;
+		StringTokenizer st;
+
+		public FastReader()
+		{
+			br = new BufferedReader(
+				new InputStreamReader(System.in));
+		}
+
+		String next()
+		{
+			while (st == null || !st.hasMoreElements()) {
+				try {
+					st = new StringTokenizer(br.readLine());
+				}
+				catch (IOException e) {
+					e.printStackTrace();
+				}
+			}
+			return st.nextToken();
+		}
+
+		int nextInt() { return Integer.parseInt(next()); }
+
+		long nextLong() { return Long.parseLong(next()); }
+
+		double nextDouble()
+		{
+			return Double.parseDouble(next());
+		}
+
+		String nextLine()
+		{
+			String str = """";
+			try {
+				str = br.readLine();
+			}
+			catch (IOException e) {
+				e.printStackTrace();
+			}
+			return str;
+		}
+	}
+
+}
+",0
+8c011cb9,e0f6aad6,"import java.io.*;
+import java.util.*;
+
+/*
+polyakoff
+*/
+
+public class Main {
+
+    static FastReader in;
+    static PrintWriter out;
+    static Random rand = new Random();
+    static final int oo = (int) 2e9 + 10;
+    static final long OO = (long) 2e18 + 10;
+    static final int MOD = 998244353;
+
+
+    static void solve() {
+        int n = in.nextInt();
+        String[] s = new String[n];
+        for (int i = 0; i < n; i++) {
+            s[i] = in.next();
+        }
+
+        HashSet<String> set = new HashSet<>();
+        for (int i = 0; i < n; i++) {
+            if (s[i].charAt(0) == s[i].charAt(s[i].length() - 1)) {
+                out.println(""YES"");
+                return;
+            }
+            if (s[i].length() == 2) {
+                String t = new StringBuilder(s[i]).reverse().toString();
+                if (set.contains(t)) {
+                    out.println(""YES"");
+                    return;
+                }
+                for (char c = 'a'; c <= 'z'; c++) {
+                    if (set.contains(t + c)) {
+                        out.println(""YES"");
+                        return;
+                    }
+                }
+                set.add(s[i]);
+            } else {
+                String t = new StringBuilder(s[i]).reverse().toString();
+                if (set.contains(t) || set.contains(t.substring(0, 2))) {
+                    out.println(""YES"");
+                    return;
+                }
+                set.add(s[i]);
+            }
+        }
+
+        out.println(""NO"");
+
+
+    }
+
+    public static void main(String[] args) {
+        in = new FastReader();
+        out = new PrintWriter(System.out);
+
+        int t = 1;
+        t = in.nextInt();
+        while (t-- > 0) {
+            solve();
+        }
+
+        out.flush();
+        out.close();
+    }
+
+    static class FastReader {
+        BufferedReader br;
+        StringTokenizer st;
+
+        FastReader() {
+            this(System.in);
+        }
+        FastReader(String file) throws FileNotFoundException {
+            this(new FileInputStream(file));
+        }
+        FastReader(InputStream is) {
+            br = new BufferedReader(new InputStreamReader(is));
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+        String next() {
+            while (st == null || !st.hasMoreTokens()) {
+                st = new StringTokenizer(nextLine());
+            }
+            return st.nextToken();
+        }
+        String nextLine() {
+            String line;
+            try {
+                line = br.readLine();
+            } catch (IOException e) {
+                throw new RuntimeException(e);
+            }
+            return line;
+        }
+    }
+}
+","
+import java.util.*;
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.StringTokenizer;
+
+public class Main {
+    public static  ArrayList<Integer> primeupton(int n)
+    {
+        ArrayList<Integer> ans= new ArrayList<>();
+        boolean prime[] = new boolean[n + 1];
+        for (int i = 0; i <= n; i++)
+            prime[i] = true;
+
+        for (int p = 2; p * p <= n; p++)
+        {
+
+            if (prime[p] == true)
+            {
+
+                for (int i = p * p; i <= n; i += p)
+                    prime[i] = false;
+            }
+        }
+
+        // Print all prime numbers
+        for (int i = 2; i <= n; i++)
+        {
+            if (prime[i] == true)
+                ans.add(i);
+        }
+
+        return ans;
+    }
+
+    public static Map<Integer,Integer> primeFactors(int n)
+    {
+        HashMap<Integer,Integer> map= new HashMap<>();
+        int count=0;
+        while (n%2==0)
+        {
+            count++;
+            n /= 2;
+        }
+        map.put(2,count);
+        for (int i = 3; i <= Math.sqrt(n); i+= 2)
+        {
+            count=0;
+            while (n%i == 0)
+            {
+                count++;
+                n /= i;
+            }
+            map.put(i,count);
+        }
+        if (n > 2)
+            map.put(n,1);
+
+        return map;
+    }
+    public static String toBinary(int decimal){
+        StringBuilder ans= new StringBuilder();
+
+        while(decimal > 0){
+            ans.append(decimal%2) ;
+            decimal = decimal/2;
+        }
+
+        return ans.reverse().toString();
+    }
+    private static LinkedList[] adj;
+    static class Sortbyroll implements Comparator<Pair> {
+        @Override
+        public int compare(Pair o1, Pair o2) {
+            return o1.b-o2.b;
+        }
+
+        // Method
+        // Sorting in ascending order of roll number
+
+
+
+
+    }
+    static class Pair {
+        int a;
+        int b;
+
+
+        Pair(int a, int b) {
+            this.a = a;
+            this.b = b;
+
+        }
+        public int getB(){
+            return b;
+        }
+    }
+    static int gcd(int a, int b)
+    {
+        if (b == 0)
+            return a;
+        return gcd(b, a % b);
+    }
+
+    public static class FastReader {
+        BufferedReader br;
+        StringTokenizer st;
+
+        public FastReader() {
+            br = new BufferedReader(
+                    new InputStreamReader(System.in));
+        }
+
+        String next() {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+
+        String nextLine() {
+            String str = """";
+            try {
+                str = br.readLine();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+        }
+    }
+    static int sum (int n){
+        return n*(n+1)/2;
+    }
+    public static void main(String[] args) throws Exception {
+        // your code goes here
+        FastReader sc = new FastReader();
+        int t = sc.nextInt();
+        while (t-- > 0) {
+            int n = sc.nextInt();
+            Set<String> list1= new HashSet<>();
+            Set<String> list2= new HashSet<>();
+            Set<String> list3= new HashSet<>();
+            int flag=0;
+            for(int i=0;i<n;i++) {
+                String s = sc.next();
+                if (flag == 1) {
+                   list1.add(s);
+                }
+                else
+                {
+                    if (s.length() == 1) {
+                        flag = 1;
+                    } else if (s.length() == 2) {
+                        list2.add(s);
+                        StringBuilder x = new StringBuilder();
+                        x.append(s.charAt(1));
+                        x.append(s.charAt(0));
+                        if (list3.contains(x.toString()) || list2.contains(x.toString())) {
+                            flag = 1;
+                        }
+                    } else {
+                        list1.add(s);
+                        list3.add(s.substring(0, 2));
+                        StringBuilder x = new StringBuilder();
+                        x.append(s.charAt(2));
+                        x.append(s.charAt(1));
+                        x.append(s.charAt(0));
+
+                        if (list1.contains(x.toString())) flag = 1;
+                        StringBuilder y = new StringBuilder();
+                        y.append(s.charAt(2));
+                        y.append(s.charAt(1));
+                        if (list2.contains(y.toString())) flag = 1;
+
+                    }
+
+
+                }
+            }
+
+            if(flag!=1){
+                System.out.println(""NO"");
+            } else
+                System.out.println(""YES"");
+        }
+    }
+
+}",0
+1ea771ea,b9219544,"
+import java.io.*;
+import java.util.*;
+
+
+public class CODECHEF {
+    static class FastReader {
+        byte[] buf = new byte[2048];
+        int index, total;
+        InputStream in;
+
+        FastReader(InputStream is) {
+            in = is;
+        }
+
+        int scan() throws IOException {
+            if (index >= total) {
+                index = 0;
+                total = in.read(buf);
+                if (total <= 0) {
+                    return -1;
+                }
+            }
+            return buf[index++];
+        }
+
+        String next() throws IOException {
+            int c;
+            for (c = scan(); c <= 32; c = scan())
+                ;
+            StringBuilder sb = new StringBuilder();
+            for (; c > 32; c = scan()) {
+                sb.append((char) c);
+            }
+            return sb.toString();
+        }
+
+        String nextLine() throws IOException {
+            int c;
+            for (c = scan(); c <= 32; c = scan())
+                ;
+            StringBuilder sb = new StringBuilder();
+            for (; c != 10 && c != 13; c = scan()) {
+                sb.append((char) c);
+            }
+            return sb.toString();
+        }
+
+        char nextChar() throws IOException {
+            int c;
+            for (c = scan(); c <= 32; c = scan())
+                ;
+            return (char) c;
+        }
+
+        int nextInt() throws IOException {
+            int c, val = 0;
+            for (c = scan(); c <= 32; c = scan())
+                ;
+            boolean neg = c == '-';
+            if (c == '-' || c == '+') {
+                c = scan();
+            }
+            for (; c >= '0' && c <= '9'; c = scan()) {
+                val = (val << 3) + (val << 1) + (c & 15);
+            }
+            return neg ? -val : val;
+        }
+
+        long nextLong() throws IOException {
+            int c;
+            long val = 0;
+            for (c = scan(); c <= 32; c = scan())
+                ;
+            boolean neg = c == '-';
+            if (c == '-' || c == '+') {
+                c = scan();
+            }
+            for (; c >= '0' && c <= '9'; c = scan()) {
+                val = (val << 3) + (val << 1) + (c & 15);
+            }
+            return neg ? -val : val;
+        }
+
+    }
+    static long MOD=1000000000;
+    static class Pair{
+        long a;
+        int b;
+        Pair(long i,int j){
+            a=i;
+            b=j;
+        }
+    }
+    static long[] solve(int[] pos,long[] arr,int n,int k){
+        long[] ans=new long[n];
+        long[] left=new long[n];
+        long[] right=new long[n];
+        long min=Integer.MAX_VALUE;
+        for(int i=0;i<n;i++){
+            min=Math.min(min+1,arr[i]);
+            left[i]=min;
+        }
+        min=Integer.MAX_VALUE;
+        for(int i=n-1;i>=0;i--){
+            min=Math.min(min+1,arr[i]);
+            right[i]=min;
+        }
+        for(int i=0;i<n;i++){
+            ans[i]=Math.min(left[i],right[i]);
+        }
+        return ans;
+
+
+    }
+
+
+    public static void main(String[] args) throws java.lang.Exception {
+         FastReader fs=new FastReader(System.in);
+//       StringBuilder sb=new StringBuilder();
+//       PrintWriter out=new PrintWriter(System.out);
+         int t=fs.nextInt();
+         while (t-->0){
+            int n=fs.nextInt();
+            int k=fs.nextInt();
+            int[] pos=new int[k];
+            for(int i=0;i<k;i++)
+                pos[i]=fs.nextInt()-1;
+            long[] temp=new long[n];
+            int ptr=0;
+            Arrays.fill(temp,Integer.MAX_VALUE);
+             for(int i=0;i<k;i++)
+                 temp[pos[ptr++]]=fs.nextLong();
+             long[] ans=solve(pos,temp,n,k);
+             for(int i=0;i<n;i++)
+                 System.out.print(ans[i]+"" "");
+             System.out.println();
+
+         }
+        //out.close;
+    }
+}
+","/*
+stream Butter!
+eggyHide eggyVengeance
+I need U
+xiao rerun when
+ */
+import static java.lang.Math.*;
+import static java.lang.System.out;
+import java.util.*;
+import java.io.*;
+import java.math.*;
+
+public class x1547E
+{
+    public static void main(String hi[]) throws Exception
+    {
+        FastScanner infile = new FastScanner();
+        StringBuilder sb = new StringBuilder();
+        int T = infile.nextInt();
+        while(T-->0)
+        {
+            int N = infile.nextInt();
+            int K = infile.nextInt();
+            int[] locs = infile.nextInts(K);
+            int[] temps = infile.nextInts(K);
+            long[] arr = new long[N];
+            Arrays.fill(arr, Long.MAX_VALUE/2);
+            for(int i=0; i < K; i++)
+                arr[locs[i]-1] = temps[i];
+            long[] suffix = new long[N];
+            suffix[N-1] = arr[N-1];
+            for(int i=N-2; i >= 0; i--)
+                suffix[i] = min(arr[i], suffix[i+1]+1);
+            long[] prefix = new long[N];
+            prefix[0] = arr[0];
+            for(int i=1; i < N; i++)
+                prefix[i] = min(arr[i], prefix[i-1]+1);
+            for(int i=0; i < N; i++)
+            {
+                long res = min(prefix[i], suffix[i]);
+                sb.append(res+"" "");
+            }
+            sb.append(""\n"");
+        }
+        System.out.print(sb);
+    }
+}
+class FastScanner
+{
+    //I don't understand how this works lmao
+    private int BS = 1 << 16;
+    private char NC = (char) 0;
+    private byte[] buf = new byte[BS];
+    private int bId = 0, size = 0;
+    private char c = NC;
+    private double cnt = 1;
+    private BufferedInputStream in;
+
+    public FastScanner() {
+        in = new BufferedInputStream(System.in, BS);
+    }
+
+    public FastScanner(String s) {
+        try {
+            in = new BufferedInputStream(new FileInputStream(new File(s)), BS);
+        } catch (Exception e) {
+            in = new BufferedInputStream(System.in, BS);
+        }
+    }
+
+    private char getChar() {
+        while (bId == size) {
+            try {
+                size = in.read(buf);
+            } catch (Exception e) {
+                return NC;
+            }
+            if (size == -1) return NC;
+            bId = 0;
+        }
+        return (char) buf[bId++];
+    }
+
+    public int nextInt() {
+        return (int) nextLong();
+    }
+
+    public int[] nextInts(int N) {
+        int[] res = new int[N];
+        for (int i = 0; i < N; i++) {
+            res[i] = (int) nextLong();
+        }
+        return res;
+    }
+
+    public long[] nextLongs(int N) {
+        long[] res = new long[N];
+        for (int i = 0; i < N; i++) {
+            res[i] = nextLong();
+        }
+        return res;
+    }
+
+    public long nextLong() {
+        cnt = 1;
+        boolean neg = false;
+        if (c == NC) c = getChar();
+        for (; (c < '0' || c > '9'); c = getChar()) {
+            if (c == '-') neg = true;
+        }
+        long res = 0;
+        for (; c >= '0' && c <= '9'; c = getChar()) {
+            res = (res << 3) + (res << 1) + c - '0';
+            cnt *= 10;
+        }
+        return neg ? -res : res;
+    }
+
+    public double nextDouble() {
+        double cur = nextLong();
+        return c != '.' ? cur : cur + nextLong() / cnt;
+    }
+
+    public double[] nextDoubles(int N) {
+        double[] res = new double[N];
+        for (int i = 0; i < N; i++) {
+            res[i] = nextDouble();
+        }
+        return res;
+    }
+
+    public String next() {
+        StringBuilder res = new StringBuilder();
+        while (c <= 32) c = getChar();
+        while (c > 32) {
+            res.append(c);
+            c = getChar();
+        }
+        return res.toString();
+    }
+
+    public String nextLine() {
+        StringBuilder res = new StringBuilder();
+        while (c <= 32) c = getChar();
+        while (c != '\n') {
+            res.append(c);
+            c = getChar();
+        }
+        return res.toString();
+    }
+
+    public boolean hasNext() {
+        if (c > 32) return true;
+        while (true) {
+            c = getChar();
+            if (c == NC) return false;
+            else if (c > 32) return true;
+        }
+    }
+}
+",0
+2470b521,2da4b3fe,"// package com.company;
+
+
+import com.sun.security.jgss.GSSUtil;
+
+import javax.swing.*;
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.util.*;
+
+//ankit singh
+
+public class Main {
+
+   static int inf=Integer.MAX_VALUE/2;
+    public static void main(String[] args) {
+       Scanner input=new Scanner(System.in);
+       int nn=input.nextInt();
+        int a[]=new int[nn];
+        ArrayList<Integer> one=new ArrayList<>();
+        ArrayList<Integer> zero=new ArrayList<>();
+        for (int i = 0; i <nn ; i++) {
+            a[i]=input.nextInt();
+            if(a[i]==1){
+                one.add(i);
+            }else zero.add(i);
+        }
+        if (one.size()==0) {
+            System.out.println(0);
+            return;
+        }
+        int n=one.size();
+        int m=zero.size();
+        int dp[][]=new int[n+1][m+1];
+        int ans=0;
+        for (int i = 1; i <=n ; i++) {
+             dp[i][0]=inf;
+            for (int j = 1; j <=m ; j++) {
+                dp[i][j]=inf;
+
+                //take the current
+                dp[i][j]=Math.min(dp[i][j],dp[i-1][j-1]+Math.abs(one.get(i-1)-zero.get(j-1)));
+
+                //take previos
+                dp[i][j]=Math.min(dp[i][j],dp[i][j-1]);
+
+
+            }
+        }
+        ans=inf;
+        for (int i = 1; i <=m ; i++) {
+            ans=Math.min(ans,dp[n][i]);
+        }
+        System.out.println(ans);
+
+
+
+    }
+
+}","
+import java.util.*;
+import java.lang.*;
+import java.io.*;
+
+public class Codeforces {
+	public static class FastReader {  
+        BufferedReader br;
+        StringTokenizer st;
+ 
+        public FastReader()
+        {
+            br = new BufferedReader(
+                new InputStreamReader(System.in));
+        }
+ 
+        String next()
+        {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                }
+                catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+ 
+        int nextInt() { return Integer.parseInt(next()); }
+ 
+        long nextLong() { return Long.parseLong(next()); }
+ 
+        double nextDouble()
+        {
+            return Double.parseDouble(next());
+        }
+ 
+        String nextLine()
+        {
+            String str = """";
+            try {
+                str = br.readLine();
+            }
+            catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+        }
+    }
+	public static void main (String[] args) throws java.lang.Exception
+	{
+		// your code goes here
+		FastReader sc=new FastReader();
+		int n=sc.nextInt();
+		int a[]=new int[n];
+		ArrayList<Integer> arr0=new ArrayList<>();
+		ArrayList<Integer> arr1=new ArrayList<>();
+		for(int i=0;i<n;i++)
+		{
+		    a[i]=sc.nextInt();
+		    if(a[i]==0)
+		    arr0.add(i);
+		    else
+		    arr1.add(i);
+		}
+		n=arr0.size();
+		int m=arr1.size();
+		int dp[][]=new int[m+1][n+1];
+		for(int i=0;i<=n;i++)
+		{
+		    dp[0][i]=0;
+		}
+		for(int i=1;i<=m;i++)
+		{
+		    dp[i][i]=dp[i-1][i-1]+Math.abs(arr0.get(i-1)-arr1.get(i-1));
+		    for(int j=i+1;j<=n;j++)
+		    {
+		        dp[i][j]=Math.min(dp[i-1][j-1]+Math.abs(arr0.get(j-1)-arr1.get(i-1)),dp[i][j-1]);
+		    }
+		}
+		System.out.println(dp[m][n]);
+	}
+}
+
+
+
+
+
+
+
+
+
+
+
+",0
+a101df86,f0d91796,"import java.util.*;
+public class Main {
+	public static void main(String[] args){
+		Scanner sc = new Scanner(System.in);
+
+		// long mod = 1_000_000_007L;
+		// long mod = 998_244_353L;
+
+		int t = sc.nextInt();
+
+		for ( int zzz=0; zzz<t; zzz++ ) {
+
+			int n = sc.nextInt();
+
+			int[] a = new int[n];
+			String[] b = new String[n];
+			for ( int i=0; i<n; i++ ) {
+				a[i] = sc.nextInt();
+			}
+
+			int pos = 0;
+			if ( n%2==1 ) {
+				int a01 = a[0]+a[1];
+				if ( a01==0 ) {
+					a01 = a[0]-a[1];
+					b[0] = String.valueOf(a[2]);
+					b[1] = String.valueOf(0-a[2]);
+					b[2] = String.valueOf(0-a01);
+				} else {
+					b[0] = String.valueOf(a[2]);
+					b[1] = String.valueOf(a[2]);
+					b[2] = String.valueOf(0-a01);
+				}
+
+				pos = 3;
+			}
+
+			for ( int i=pos; i<n; i=i+2 ) {
+				b[i] = String.valueOf(a[i+1]);
+				b[i+1] = String.valueOf(0-a[i]);
+			}
+
+			System.out.println(String.join("" "", b));
+		}
+	}
+}
+","import java.io.*;
+import java.util.*;
+ 
+public class cf {
+ 
+    public static void main(String[] args){
+ 
+        FastScanner sc = new FastScanner();
+        int t = sc.nextInt();
+        while(t-- > 0){
+ 			
+ 			int n=sc.nextInt();
+            int arr[]=new int[n];
+            for(int i=0;i<n;i++){
+                arr[i]=sc.nextInt();
+            }
+            int ans[]=new int[n];
+            if(n%2==0){
+                for(int i=0;i<n;i=i+2){
+                    ans[i]=-arr[i+1];
+                    ans[i+1]=arr[i];
+                }
+            }
+            else{
+                if(arr[0]+arr[1]!=0){
+                    ans[0]=-arr[2];
+                    ans[1]=-arr[2];
+                    ans[2]=arr[0]+arr[1];
+                }
+                else{
+                    if(arr[1]+arr[2]!=0){
+                        ans[1]=-arr[0];
+                        ans[2]=-arr[0];
+                        ans[0]=arr[1]+arr[2];
+                    }
+                    else{
+                        ans[0]=-arr[1];
+                        ans[2]=-arr[1];
+                        ans[1]=arr[0]+arr[2];
+                    }
+                }
+                for(int i=3;i<n;i=i+2){
+                    ans[i]=-arr[i+1];
+                    ans[i+1]=arr[i];
+                }
+            }
+            for(int j=0;j<n;j++){
+                System.out.print(ans[j]+"" "");
+            }
+            System.out.println();
+            
+
+            
+            
+
+            
+
+            
+           
+ 			
+
+        }	        	
+        	
+ 			
+    }
+ 
+    
+    
+    
+ 
+}
+
+//////////////////////////////////////////////////////////////
+// LCM AND GCD
+/*
+	public static int gcd(int a,int b){
+		if(b == 0){
+			return a;
+		}
+		return gcd(b,a%b);
+	}
+ 
+	public static int lcm(int a,int b){
+		 return (a / gcd(a, b)) * b;
+	}*/
+
+
+///////////////////////////////////////////////////////////////////////////////////
+
+//Iterator
+
+
+
+/*Iterator iterator = object.iterator();
+ 
+        while (iterator.hasNext()) {
+            System.out.print(iterator.next() + "" "");
+        }*/
+///////////////////////////////////////////////////////////////////////////////////
+
+
+class FastScanner
+{
+    //I don't understand how this works lmao
+    private int BS = 1 << 16;
+    private char NC = (char) 0;
+    private byte[] buf = new byte[BS];
+    private int bId = 0, size = 0;
+    private char c = NC;
+    private double cnt = 1;
+    private BufferedInputStream in;
+ 
+    public FastScanner() {
+        in = new BufferedInputStream(System.in, BS);
+    }
+ 
+    public FastScanner(String s) {
+        try {
+            in = new BufferedInputStream(new FileInputStream(new File(s)), BS);
+        } catch (Exception e) {
+            in = new BufferedInputStream(System.in, BS);
+        }
+    }
+ 
+    public char getChar() {
+        while (bId == size) {
+            try {
+                size = in.read(buf);
+            } catch (Exception e) {
+                return NC;
+            }
+            if (size == -1) return NC;
+            bId = 0;
+        }
+        return (char) buf[bId++];
+    }
+ 
+    public int nextInt() {
+        return (int) nextLong();
+    }
+ 
+    public int[] nextInts(int N) {
+        int[] res = new int[N];
+        for (int i = 0; i < N; i++) {
+            res[i] = (int) nextLong();
+        }
+        return res;
+    }
+ 
+    public long[] nextLongs(int N) {
+        long[] res = new long[N];
+        for (int i = 0; i < N; i++) {
+            res[i] = nextLong();
+        }
+        return res;
+    }
+ 
+    public long nextLong() {
+        cnt = 1;
+        boolean neg = false;
+        if (c == NC) c = getChar();
+        for (; (c < '0' || c > '9'); c = getChar()) {
+            if (c == '-') neg = true;
+        }
+        long res = 0;
+        for (; c >= '0' && c <= '9'; c = getChar()) {
+            res = (res << 3) + (res << 1) + c - '0';
+            cnt *= 10;
+        }
+        return neg ? -res : res;
+    }
+ 
+    public double nextDouble() {
+        double cur = nextLong();
+        return c != '.' ? cur : cur + nextLong() / cnt;
+    }
+ 
+    public double[] nextDoubles(int N) {
+        double[] res = new double[N];
+        for (int i = 0; i < N; i++) {
+            res[i] = nextDouble();
+        }
+        return res;
+    }
+ 
+    public String next() {
+        StringBuilder res = new StringBuilder();
+        while (c <= 32) c = getChar();
+        while (c > 32) {
+            res.append(c);
+            c = getChar();
+        }
+        return res.toString();
+    }
+ 
+    public String nextLine() {
+        StringBuilder res = new StringBuilder();
+        while (c <= 32) c = getChar();
+        while (c != '\n') {
+            res.append(c);
+            c = getChar();
+        }
+        return res.toString();
+    }
+ 
+    public boolean hasNext() {
+        if (c > 32) return true;
+        while (true) {
+            c = getChar();
+            if (c == NC) return false;
+            else if (c > 32) return true;
+        }
+    }
+}
+
+",0
+48993e07,96cd6ee9,"import java.io.*;
+import java.util.*;
+
+public class Codeforce {
+
+    static class Reader {
+        final private int BUFFER_SIZE = 1 << 16;
+        private DataInputStream din;
+        private byte[] buffer;
+        private int bufferPointer, bytesRead;
+
+        public Reader() {
+            din = new DataInputStream(System.in);
+            buffer = new byte[BUFFER_SIZE];
+            bufferPointer = bytesRead = 0;
+        }
+
+        public Reader(String file_name) throws IOException {
+            din = new DataInputStream(
+                    new FileInputStream(file_name));
+            buffer = new byte[BUFFER_SIZE];
+            bufferPointer = bytesRead = 0;
+        }
+
+        public String readLine() throws IOException {
+            byte[] buf = new byte[64]; // line length
+            int cnt = 0, c;
+            while ((c = read()) != -1) {
+                if (c == '\n') {
+                    if (cnt != 0) {
+                        break;
+                    } else {
+                        continue;
+                    }
+                }
+                buf[cnt++] = (byte) c;
+            }
+            return new String(buf, 0, cnt);
+        }
+
+        public int nextInt() throws IOException {
+            int ret = 0;
+            byte c = read();
+            while (c <= ' ') {
+                c = read();
+            }
+            boolean neg = (c == '-');
+            if (neg)
+                c = read();
+            do {
+                ret = ret * 10 + c - '0';
+            } while ((c = read()) >= '0' && c <= '9');
+
+            if (neg)
+                return -ret;
+            return ret;
+        }
+
+        public long nextLong() throws IOException {
+            long ret = 0;
+            byte c = read();
+            while (c <= ' ')
+                c = read();
+            boolean neg = (c == '-');
+            if (neg)
+                c = read();
+            do {
+                ret = ret * 10 + c - '0';
+            } while ((c = read()) >= '0' && c <= '9');
+            if (neg)
+                return -ret;
+            return ret;
+        }
+
+        public double nextDouble() throws IOException {
+            double ret = 0, div = 1;
+            byte c = read();
+            while (c <= ' ')
+                c = read();
+            boolean neg = (c == '-');
+            if (neg)
+                c = read();
+
+            do {
+                ret = ret * 10 + c - '0';
+            } while ((c = read()) >= '0' && c <= '9');
+
+            if (c == '.') {
+                while ((c = read()) >= '0' && c <= '9') {
+                    ret += (c - '0') / (div *= 10);
+                }
+            }
+
+            if (neg)
+                return -ret;
+            return ret;
+        }
+
+        private void fillBuffer() throws IOException {
+            bytesRead = din.read(buffer, bufferPointer = 0,
+                    BUFFER_SIZE);
+            if (bytesRead == -1)
+                buffer[0] = -1;
+        }
+
+        private byte read() throws IOException {
+            if (bufferPointer == bytesRead)
+                fillBuffer();
+            return buffer[bufferPointer++];
+        }
+
+        public void close() throws IOException {
+            if (din == null)
+                return;
+            din.close();
+        }
+    }
+
+    static int mod = (int) (1e9 + 7);
+
+    public static class pair implements Comparator<pair> {
+        int x;
+        int y;
+
+        public pair() {
+
+        }
+
+        public pair(int x, int y) {
+            this.x = x;
+            this.y = y;
+
+        }
+
+        @Override
+        public int compare(pair o1, pair o2) {
+            return o1.y - o2.y;
+        }
+    }
+
+    public static long modularpow(long a, long b) {
+        long res = 1;
+        if (b == 0)
+            return res;
+        else {
+            while (b > 0) {
+                if (b % 2 == 1) {
+                    res *= a;
+                    res %= mod;
+
+                }
+                a = a * a;
+                a %= mod;
+                b /= 2;
+            }
+            return res % mod;
+        }
+    }
+
+    public static int gcd(int a, int b) {
+        if (b == 0)
+            return a;
+        else
+            return gcd(b, a % b);
+    }
+
+    public static String binary(int a) {
+        String s1 = """";
+        while (a > 0) {
+            s1 = a % 2 + s1;
+            a /= 2;
+        }
+        return s1;
+    }
+
+    public static int Lower_Bound(long a[], int l, int r, long k) {
+
+
+        while (r - l > 1) {
+            int mid = l + (r - l) / 2;
+            if (a[mid] <= k) l = mid;
+            else
+                r = mid;
+
+        }
+        return l;
+    }
+
+    public static int Upper_Bound(int a[], int l, int r, int k) {
+
+        while (r - l > 1) {
+            int mid = (l + r) / 2;
+            if (a[mid] <= k)
+                l = mid;
+            else
+                r = mid;
+        }
+        return l + 1;
+    }
+
+    public static void main(String arg[]) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        int t = Integer.parseInt(br.readLine());
+        StringBuilder sb = new StringBuilder();
+        while (t-- > 0) {
+                                br.readLine();
+                        String s[]=br.readLine().split("" "");
+                        int n=Integer.parseInt(s[0]);
+                        int k=Integer.parseInt(s[1]);
+                        long a[]=new long[n];
+                        long b[]=new long[n];
+                        long c[]=new long[n];
+                        Arrays.fill(c,Integer.MAX_VALUE);
+                        String s1[]=br.readLine().split("" "");
+                        s=br.readLine().split("" "");
+                        for(int i=0;i<k;i++)
+                            c[Integer.parseInt(s1[i])-1]=Integer.parseInt(s[i]);
+
+                        long p=Integer.MAX_VALUE;
+                        for(int i=0;i<n;i++)
+                        {
+                            p=Math.min(p+1,c[i]);
+                            a[i]=p;
+                        }
+                        p=Integer.MAX_VALUE;
+                        for(int i=n-1;i>=0;i--){
+                            p=Math.min(p+1,c[i]);
+                            b[i]=p;
+                        }
+                        for(int i=0;i<n;i++)
+                            sb.append((Math.min(a[i],b[i]))+"" "");
+                        sb.append(""\n"");
+
+                       }
+        System.out.println(sb);
+    }
+}","import java.io.*;
+import java.util.*;
+import java.math.BigInteger;
+
+
+public class C{
+    public static void main(String[] args) {
+        InputStream inputStream = System.in;
+        OutputStream outputStream = System.out;
+        InputReader in = new InputReader(inputStream);
+        PrintWriter out = new PrintWriter(outputStream);
+        Task solver = new Task();
+        solver.solve(in, out);
+        out.close();
+    }
+    // main solver
+    static class Task{
+
+        double eps= 0.00000001;
+        static final int MAXN = 100005;
+        static final int MOD= 998244353;
+
+        // stores smallest prime factor for every number
+        static int spf[] = new int[MAXN];
+
+        Map<Integer,Set<Integer>> dp= new HashMap<>();
+
+        // Calculating SPF (Smallest Prime Factor) for every
+        // number till MAXN.
+        // Time Complexity : O(nloglogn)
+        public void sieve()
+        {
+            spf[1] = 1;
+            for (int i=2; i<MAXN; i++)
+
+                // marking smallest prime factor for every
+                // number to be itself.
+                spf[i] = i;
+
+            // separately marking spf for every even
+            // number as 2
+            for (int i=4; i<MAXN; i+=2)
+                spf[i] = 2;
+
+            for (int i=3; i*i<MAXN; i++)
+            {
+                // checking if i is prime
+                if (spf[i] == i)
+                {
+                    // marking SPF for all numbers divisible by i
+                    for (int j=i*i; j<MAXN; j+=i)
+
+                        // marking spf[j] if it is not
+                        // previously marked
+                        if (spf[j]==j)
+                            spf[j] = i;
+                }
+            }
+        }
+
+        // A O(log n) function returning primefactorization
+        // by dividing by smallest prime factor at every step
+        public Set<Integer> getFactorization(int x)
+        {
+            if(dp.containsKey(x)) return dp.get(x);
+            Set<Integer> ret = new HashSet<>();
+            while (x != 1)
+            {
+                if(spf[x]!=2) ret.add(spf[x]);
+                x = x / spf[x];
+            }
+            dp.put(x,ret);
+            return ret;
+        }
+        // function to find first index >= x
+        public int lowerIndex(List<Integer> arr, int n, int x)
+        {
+            int l = 0, h = n - 1;
+            while (l <= h)
+            {
+                int mid = (l + h) / 2;
+                if (arr.get(mid) >= x)
+                    h = mid - 1;
+                else
+                    l = mid + 1;
+            }
+            return l;
+        }
+
+        // function to find last index <= y
+        public int upperIndex(List<Integer> arr, int n, int y)
+        {
+            int l = 0, h = n - 1;
+            while (l <= h)
+            {
+                int mid = (l + h) / 2;
+                if (arr.get(mid) <= y)
+                    l = mid + 1;
+                else
+                    h = mid - 1;
+            }
+            return h;
+        }
+
+        // function to count elements within given range
+        public int countInRange(List<Integer> arr, int n, int x, int y)
+        {
+            // initialize result
+            int count = 0;
+            count = upperIndex(arr, n, y) -
+                    lowerIndex(arr, n, x) + 1;
+            return count;
+        }
+
+        public int add(int a, int b){
+            a+=b;
+            if(a>=MOD) a-=MOD;
+            else if(a<0) a+=MOD;
+            return a;
+        }
+
+        public int mul(int a, int b){
+            long res= (long)a*(long)b;
+            return (int)(res%MOD);
+        }
+
+        public int power(int a, int b) {
+            int ans=1;
+            while(b>0){
+                if((b&1)!=0) ans= mul(ans,a);
+                b>>=1;
+                a= mul(a,a);
+            }
+            return ans;
+        }
+
+        int[] fact= new int[MAXN];
+        int[] inv= new int[MAXN];
+
+        public int Ckn(int n, int k){
+            if(k<0 || n<0) return 0;
+            return mul(mul(fact[n],inv[k]),inv[n-k]);
+        }
+
+        public int inverse(int a){
+            return power(a,MOD-2);
+        }
+
+        public void preprocess() {
+            fact[0]=1;
+            for(int i=1;i<MAXN;i++) fact[i]= mul(fact[i-1],i);
+            inv[MAXN-1]= inverse(fact[MAXN-1]);
+            for(int i=MAXN-2;i>=0;i--){
+                inv[i]= mul(inv[i+1],i+1);
+            }
+        }
+        
+        
+        public void solve(InputReader in, PrintWriter out) {
+            int test= in.nextInt();
+            while(test-->0){
+                int n= in.nextInt(), k= in.nextInt();
+                int[] a= new int[k];
+                int[] t= new int[k];
+                for(int i=0;i<k;i++) a[i]= in.nextInt();
+                for(int i=0;i<k;i++) t[i]= in.nextInt();
+                int[] c= new int[n];
+                Arrays.fill(c, Integer.MAX_VALUE);
+                for(int i=0;i<k;i++){
+                    c[a[i]-1]=t[i];
+                }
+                int[] L= new int[n];
+                int[] R= new int[n];
+                Arrays.fill(L, Integer.MAX_VALUE);
+                Arrays.fill(R, Integer.MAX_VALUE);
+
+                long p= Integer.MAX_VALUE;
+                for(int i=0;i<n;i++){
+                    p=Math.min(p+1,c[i]);
+                    L[i]=(int)p;
+                }
+                p= Integer.MAX_VALUE;
+                for(int i=n-1;i>=0;i--){
+                    p= Math.min(p+1,c[i]);
+                    R[i]=(int)p;
+                }
+                for(int i=0;i<n;i++){
+                    out.print(Math.min(L[i],R[i])+"" "");
+                }
+                out.println();
+            }
+            
+        }
+    
+
+        // public static class compareL implements Comparator<Tuple>{
+        //     @Override
+        //     public int compare(Tuple t1, Tuple t2) {
+        //         return t2.l - t1.l;
+        //     }
+        // }
+        
+        public int _gcd(int a,  int  b)
+        {
+
+            if(b == 0) {
+                return a;
+            }
+            else {
+                return _gcd(b, a % b);
+            }
+        }
+
+    }
+
+    static class Venice{
+        public Map<Long,Long> m= new HashMap<>();
+        public long base=0;
+        public long totalValue=0;
+        private int M= 1000000007;
+
+        private long addMod(long a, long b){
+            a+=b;
+            if(a>=M) a-=M;
+            return a;
+        }
+
+        public void reset(){
+            m= new HashMap<>();
+            base=0;
+            totalValue=0;
+        }
+        public void update(long add){
+            base= base+ add;
+        }
+        public void add(long key, long val){
+            long newKey= key-base;
+            m.put(newKey, addMod(m.getOrDefault(newKey,(long)0),val));
+        }
+    }
+
+
+    static class Tuple implements Comparable<Tuple>{
+        int x, y, z;
+        public Tuple(int x, int y, int z){
+            this.x= x;
+            this.y= y;
+            this.z=z;
+        }
+        @Override
+        public int compareTo(Tuple o){
+            return this.x-o.x;
+        }
+    }
+
+    static class Pair implements Comparable<Pair>{
+        public int x;
+        public int y;
+        public Pair(int x, int y){
+            this.x= x;
+            this.y= y;
+        }
+
+        @Override
+        public int compareTo(Pair o) {
+            return this.x-o.x;
+        }
+    }
+    // fast input reader class;
+    static class InputReader {
+        BufferedReader br;
+        StringTokenizer st;
+
+        public InputReader(InputStream stream) {
+            br = new BufferedReader(new InputStreamReader(stream));
+        }
+
+        public String nextToken() {
+            while (st == null || !st.hasMoreTokens()) {
+                String line = null;
+                try {
+                    line = br.readLine();
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+                if (line == null) {
+                    return null;
+                }
+                st = new StringTokenizer(line);
+            }
+            return st.nextToken();
+        }
+
+        public int nextInt() {
+            return Integer.parseInt(nextToken());
+        }
+        public double nextDouble(){
+            return Double.parseDouble(nextToken());
+        }
+        public long nextLong(){
+            return Long.parseLong(nextToken());
+        }
+    }
+}",1
+69b2fd22,d221162a,"import java.io.*;
+import java.util.*;
+public class Main {
+    public static void main(String args[])
+    {
+        FastReader input=new FastReader();
+        PrintWriter out=new PrintWriter(System.out);
+        int T=1;
+        while(T-->0)
+        {
+            int n=input.nextInt();
+            int a[]=new int[n];
+            ArrayList<Integer> list=new ArrayList<>();
+            ArrayList<Integer> space=new ArrayList<>();
+            for(int i=0;i<n;i++)
+            {
+                a[i]=input.nextInt();
+                if(a[i]==1)
+                {
+                    list.add(i);
+                }
+                else
+                {
+                    space.add(i);
+                }
+            }
+            int pre[]=new int[space.size()];
+            for(int i=0;i<list.size();i++)
+            {
+                if(i==0)
+                {
+                    int min=Integer.MAX_VALUE;
+                    for(int j=0;j<space.size();j++)
+                    {
+                        pre[j]=Math.abs(list.get(i)-space.get(j));
+                        min=Math.min(min,pre[j]);
+                        pre[j]=min;
+                    }
+                }
+                else
+                {
+                    int arr[]=new int[space.size()];
+                    for(int j=0;j<i;j++)
+                    {
+                        arr[j]=Integer.MAX_VALUE;
+                    }
+
+                    int min=Integer.MAX_VALUE;
+                    for(int j=i;j<space.size();j++)
+                    {
+                        int v=Math.abs(list.get(i)-space.get(j));
+                        v+=pre[j-1];
+                        arr[j]=v;
+                        min=Math.min(min,v);
+                        arr[j]=min;
+                    }
+                    for(int j=0;j<space.size();j++)
+                    {
+                        pre[j]=arr[j];
+                    }
+                }
+            }
+            out.println(pre[space.size()-1]);
+        }
+        out.close();
+    }
+    static class FastReader
+    {
+        BufferedReader br;
+        StringTokenizer st;
+        public FastReader()
+        {
+            br = new BufferedReader(new InputStreamReader(System.in));
+        }
+        String next()
+        {
+            while (st == null || !st.hasMoreElements())
+            {
+                try
+                {
+                    st = new StringTokenizer(br.readLine());
+                }
+                catch (IOException e)
+                {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+        int nextInt()
+        {
+            return Integer.parseInt(next());
+        }
+        long nextLong()
+        {
+            return Long.parseLong(next());
+        }
+        double nextDouble()
+        {
+            return Double.parseDouble(next());
+        }
+        String nextLine()
+        {
+            String str="""";
+            try
+            {
+                str=br.readLine();
+            }
+            catch (IOException e)
+            {
+                e.printStackTrace();
+            }
+            return str;
+        }
+    }
+}","import java.util.*;
+import java.io.*;
+
+public class Main2 {
+	static class FastReader{ 
+        BufferedReader br; 
+        StringTokenizer st; 
+        public FastReader(){br = new BufferedReader(new InputStreamReader(System.in));}
+        String next(){while (st == null || !st.hasMoreElements()){try{st = new StringTokenizer(br.readLine());} 
+        catch (IOException  e){e.printStackTrace();}}return st.nextToken();}
+        int nextInt(){ return Integer.parseInt(next());}long nextLong(){return Long.parseLong(next());}double nextDouble(){return Double.parseDouble(next());}
+        String nextLine(){String str = """"; try{str = br.readLine(); } catch (IOException e) {e.printStackTrace();} return str; } 
+    }
+	static long mod = 998244353;
+//	static Scanner sc = new Scanner(System.in);
+	static FastReader sc = new FastReader();
+	static PrintWriter out = new PrintWriter(System.out);
+	public static void main (String[] args) {
+		int t = 1;
+//    	t = sc.nextInt();
+	    z : while(t-->0) {
+	    	int n = sc.nextInt();
+	    	int a[] = new int[n];
+	    	for(int i=0;i<n;i++) a[i] = sc.nextInt();
+	    	List<Integer> a1 = new ArrayList<>();
+	    	ArrayList<Integer> a2 = new ArrayList<>();
+	    	for (int i = 0; i < n; i++) {
+	    		if(a[i] == 0) a1.add(i);
+	    		else a2.add(i);
+			}
+	    	long dp[][] = new long[n+1][n+1];
+	    	for (int i = 0; i <= n; i++) {
+	    		Arrays.fill(dp[i],-1);
+			}
+	    	out.write(find(0,0,a1,a2,dp)+""\n"");
+	    }
+		out.close();
+	}
+	private static long find(int i, int j, List<Integer> a1, ArrayList<Integer> a2, long[][] dp) {
+		if(j == a2.size()) return 0;
+		
+		int req = a2.size()-j;
+		int ava = a1.size()-i;
+		
+		if(ava<req) return Integer.MAX_VALUE/2;
+		
+		if(dp[i][j] != -1) return dp[i][j];
+		
+		long ans1 = find(i+1,j,a1,a2,dp);
+		long ans2 = Math.abs(a1.get(i)-a2.get(j)) + find(i+1,j+1,a1,a2,dp);
+		
+		return dp[i][j] = Math.min(ans1, ans2);
+	}
+}
+",0
+317a209c,3e6def38,"import java.io.*;
+import java.util.*;
+
+public class D_Java {
+	public static final int MOD = 998244353;
+	
+	public static int mul(int a, int b) {
+		return (int)((long)a * (long)b % MOD);
+	}
+	
+	int[] f;
+	int[] rf;
+	
+	public int C(int n, int k) {
+		return (k < 0 || k > n) ? 0 : mul(f[n], mul(rf[n-k], rf[k]));
+	}
+	
+	public static int pow(int a, int n) {
+		int res = 1;
+		while (n != 0) {
+			if ((n & 1) == 1) {
+				res = mul(res, a);
+			}
+			a = mul(a, a);
+			n >>= 1;
+		}
+		return res;
+	}
+	
+	static void shuffleArray(int[] a) {
+		Random rnd = new Random();
+		for (int i = a.length-1; i > 0; i--) {
+			int index = rnd.nextInt(i + 1);
+			int tmp = a[index];
+			a[index] = a[i];
+			a[i] = tmp;
+		}
+	}
+	
+	public static int inv(int a) {
+		return pow(a, MOD-2);
+	}
+	
+	public void doIt() throws IOException {
+		BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
+		
+		StringTokenizer tok = new StringTokenizer(in.readLine());
+		int n = Integer.parseInt(tok.nextToken());
+		int k = Integer.parseInt(tok.nextToken());
+		
+		f = new int[n+42];
+		rf = new int[n+42];
+		f[0] = rf[0] = 1;
+		for (int i = 1; i < f.length; ++i) {
+			f[i] = mul(f[i-1], i);
+			rf[i] = mul(rf[i-1], inv(i));
+		}
+		
+		int[] events = new int[2*n];
+		for (int i = 0; i < n; ++i) {
+			tok = new StringTokenizer(in.readLine());
+			int le = Integer.parseInt(tok.nextToken());
+			int ri = Integer.parseInt(tok.nextToken());
+			events[i] = le*2;
+			events[i + n] = ri*2 + 1;
+		}
+		shuffleArray(events);
+		Arrays.sort(events);
+		
+		int ans = 0;
+		int balance = 0;
+		for (int r = 0; r < 2*n;) {
+			int l = r;
+			while (r < 2*n && events[l] == events[r]) {
+				++r;
+			}
+			int added = r - l;
+			if (events[l] % 2 == 0) {
+				// Open event
+				ans += C(balance + added, k);
+				if (ans >= MOD) ans -= MOD;
+				ans += MOD - C(balance, k);
+				if (ans >= MOD) ans -= MOD;
+				balance += added;
+			} else {
+				// Close event
+				balance -= added;
+			}
+		}
+		
+		in.close();
+		System.out.println(ans);
+	}
+	
+	public static void main(String[] args) throws IOException {
+		(new D_Java()).doIt();
+	}
+}","import java.io.*;
+import java.util.*;
+
+public class D_Java {
+	public static final int MOD = 998244353;
+	
+	public static int mul(int a, int b) {
+		return (int)((long)a * (long)b % MOD);
+	}
+	
+	int[] f;
+	int[] rf;
+	
+	public int C(int n, int k) {
+		return (k < 0 || k > n) ? 0 : mul(f[n], mul(rf[n-k], rf[k]));
+	}
+	
+	public static int pow(int a, int n) {
+		int res = 1;
+		while (n != 0) {
+			if ((n & 1) == 1) {
+				res = mul(res, a);
+			}
+			a = mul(a, a);
+			n >>= 1;
+		}
+		return res;
+	}
+	
+	static void shuffleArray(int[] a) {
+		Random rnd = new Random();
+		for (int i = a.length-1; i > 0; i--) {
+			int index = rnd.nextInt(i + 1);
+			int tmp = a[index];
+			a[index] = a[i];
+			a[i] = tmp;
+		}
+	}
+	
+	public static int inv(int a) {
+		return pow(a, MOD-2);
+	}
+	
+	public void doIt() throws IOException {
+		BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
+		
+		StringTokenizer tok = new StringTokenizer(in.readLine());
+		int n = Integer.parseInt(tok.nextToken());
+		int k = Integer.parseInt(tok.nextToken());
+		
+		f = new int[n+42];
+		rf = new int[n+42];
+		f[0] = rf[0] = 1;
+		for (int i = 1; i < f.length; ++i) {
+			f[i] = mul(f[i-1], i);
+			rf[i] = mul(rf[i-1], inv(i));
+		}
+		
+		int[] events = new int[2*n];
+		for (int i = 0; i < n; ++i) {
+			tok = new StringTokenizer(in.readLine());
+			int le = Integer.parseInt(tok.nextToken());
+			int ri = Integer.parseInt(tok.nextToken());
+			events[i] = le*2;
+			events[i + n] = ri*2 + 1;
+		}
+		shuffleArray(events);
+		Arrays.sort(events);
+		
+		int ans = 0;
+		int balance = 0;
+		for (int r = 0; r < 2*n;) {
+			int l = r;
+			while (r < 2*n && events[l] == events[r]) {
+				++r;
+			}
+			int added = r - l;
+			if (events[l] % 2 == 0) {
+				// Open event
+				ans += C(balance + added, k);
+				if (ans >= MOD) ans -= MOD;
+				ans += MOD - C(balance, k);
+				if (ans >= MOD) ans -= MOD;
+				balance += added;
+			} else {
+				// Close event
+				balance -= added;
+			}
+		}
+		
+		in.close();
+		System.out.println(ans);
+	}
+	
+	public static void main(String[] args) throws IOException {
+		(new D_Java()).doIt();
+	}
+}",1
+1be078c4,7ae0cb0d,"import java.util.*;
+import java.io.*;
+
+public class E_1547 {
+	public static void main(String[] args) throws Exception {
+		Scanner sc = new Scanner(System.in);
+		PrintWriter pw = new PrintWriter(System.out);
+		
+		int T = sc.nextInt();
+		while(T-->0) {
+			int n = sc.nextInt(), k = sc.nextInt();
+			int[] a = sc.nextIntArray(k);
+			int[] t = sc.nextIntArray(k);
+			
+			int[] array = new int[n];
+			Arrays.fill(array, Integer.MAX_VALUE);
+			for(int i = 0; i < k; i++)
+				array[a[i] - 1] = t[i];
+			
+			int[] pre = new int[n];
+			int[] post = new int[n];
+			
+			int prev = (int)2e9;
+			for(int i = 0; i < n; i++)
+				prev = pre[i] = Math.min(prev + 1, array[i]);
+			
+			prev = (int)2e9;
+			for(int i = n - 1; i >= 0; i--)
+				prev = post[i] = Math.min(prev + 1, array[i]);
+			
+			for(int i = 0; i < n; i++)
+				array[i] = Math.min(pre[i], post[i]);
+			
+			for(int i = 0; i < n; i++)
+				pw.print(array[i] + (i == n - 1 ? ""\n"" : "" ""));
+		}
+		
+		pw.flush();
+	}
+
+	public static class Scanner {
+		StringTokenizer st;
+		BufferedReader br;
+
+		public Scanner(InputStream system) {
+			br = new BufferedReader(new InputStreamReader(system));
+		}
+
+		public Scanner(String file) throws Exception {
+			br = new BufferedReader(new FileReader(file));
+		}
+
+		public String next() throws IOException {
+			while (st == null || !st.hasMoreTokens())
+				st = new StringTokenizer(br.readLine());
+			return st.nextToken();
+		}
+
+		public String nextLine() throws IOException {
+			return br.readLine();
+		}
+
+		public int nextInt() throws IOException {
+			return Integer.parseInt(next());
+		}
+
+		public double nextDouble() throws IOException {
+			return Double.parseDouble(next());
+		}
+
+		public char nextChar() throws IOException {
+			return next().charAt(0);
+		}
+
+		public long nextLong() throws IOException {
+			return Long.parseLong(next());
+		}
+
+		public int[] nextIntArray(int n) throws IOException {
+			int[] array = new int[n];
+			for (int i = 0; i < n; i++)
+				array[i] = nextInt();
+			return array;
+		}
+
+		public Integer[] nextIntegerArray(int n) throws IOException {
+			Integer[] array = new Integer[n];
+			for (int i = 0; i < n; i++)
+				array[i] = new Integer(nextInt());
+			return array;
+		}
+
+		public long[] nextLongArray(int n) throws IOException {
+			long[] array = new long[n];
+			for (int i = 0; i < n; i++)
+				array[i] = nextLong();
+			return array;
+		}
+
+		public double[] nextDoubleArray(int n) throws IOException {
+			double[] array = new double[n];
+			for (int i = 0; i < n; i++)
+				array[i] = nextDouble();
+			return array;
+		}
+
+		public static int[] shuffle(int[] a) {
+			int n = a.length;
+			Random rand = new Random();
+			for (int i = 0; i < n; i++) {
+				int tmpIdx = rand.nextInt(n);
+				int tmp = a[i];
+				a[i] = a[tmpIdx];
+				a[tmpIdx] = tmp;
+			}
+			return a;
+		}
+
+		public boolean ready() throws IOException {
+			return br.ready();
+		}
+
+		public void waitForInput() throws InterruptedException {
+			Thread.sleep(3000);
+		}
+	}
+}
+","import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.Arrays;
+import java.util.StringTokenizer;
+
+public class AirConditioners {
+
+    static FastReader read  =new FastReader();
+    static int INF = (int)(2e9);
+    static int mxn = (int)(3e5 + 10);
+    public static void main(String[] args) {
+
+        int t = read.nextInt();
+        while (t-- > 0)
+            solve();
+    }
+
+    private static void solve() {
+
+        int n = read.nextInt(), k = read.nextInt();
+
+        int[] a = new int[n];
+        int[] t = new int[n];
+
+        Arrays.fill(t, Integer.MAX_VALUE);
+
+        for (int i=0;i<k;++i){
+            a[i] = read.nextInt();
+        }
+
+        for (int i=0;i<k;++i){
+            t[--a[i]] = read.nextInt();
+        }
+
+        int[] L = new int[n];
+        int[] R = new int[n];
+
+        int tmp = INF;
+        for (int i=0;i<n;++i){
+            tmp = Math.min(tmp+1, t[i]);
+            L[i] = tmp;
+        }
+
+        tmp = INF;
+
+        for (int i=n-1;i>=0;--i){
+            tmp = Math.min(tmp+1, t[i]);
+            R[i] = tmp;
+        }
+
+
+        for (int i=0;i<n;++i){
+            int ans = Math.min(L[i], R[i]);
+            System.out.print(ans + "" "");
+        }
+
+        System.out.println();
+
+    }
+
+    static class FastReader {
+        BufferedReader br;
+        StringTokenizer st;
+
+        public FastReader() {
+            br = new BufferedReader(new
+                    InputStreamReader(System.in));
+        }
+
+        public String next() {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        public int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        public long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        public double nextDouble() {
+            return Double.parseDouble(next());
+        }
+
+        String nextLine() {
+            String str = """";
+            try {
+                str = br.readLine();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+        }
+
+        String[] strArray() {
+            String[] str = nextLine().split("" "");
+            return str;
+        }
+
+        int[] intArray(int n) {
+            String[] str = strArray();
+            int[] arr = new int[n];
+            for (int i = 0; i < n; i++) {
+                arr[i] = Integer.parseInt(str[i]);
+            }
+            return arr;
+        }
+    }
+
+}
+",0
+26e699de,76ad805a,"//package Task1;
+
+import java.util.Scanner;
+
+public class Menorah {
+    static int MOD9= 1000000000;
+
+    public static void main(String[] args){
+
+        Scanner sc= new Scanner(System.in);
+        int numberTest=sc.nextInt();
+        while(numberTest-->0){
+            int n=sc.nextInt();
+            char[] s=new char[n+5];
+            char[] t=new char[n+5];
+            String ss=sc.next();
+            String tt=sc.next();
+            s=ss.toCharArray();
+            t=tt.toCharArray();
+            int cntax = 0, cntbx = 0, same = 0;
+            int ans=MOD9;
+            for(int i=0; i<n; i++){
+                if(s[i]=='1')cntax++;
+                if(t[i]=='1')cntbx++;
+                if(s[i]==t[i])same++;
+            }
+            if(same==n){
+                System.out.println(0);
+                continue;
+            }
+            else if (cntax==0){
+                System.out.println(-1);
+                continue;
+            }
+            if(cntax==cntbx){
+                ans=Math.min(ans,n-same);
+            }
+            if(n-cntax+1==cntbx)ans=Math.min(ans,same);
+            if(ans<MOD9) System.out.println(ans);
+            else System.out.println(-1);
+
+
+
+        }
+
+    }
+}
+","import java.util.Arrays;
+import java.util.Scanner;
+
+public class First {
+    static Scanner sc = new Scanner(System.in);
+    public static void main(String[] args) {
+        int t = sc.nextInt();
+        while (t-- > 0) {
+            int n = sc.nextInt();
+            String a = sc.next();
+            String b = sc.next();
+            char ch1[] = a.toCharArray();
+            char ch2[] = b.toCharArray();
+            int zz = 0;
+            int oz = 0;
+            int zo = 0;
+            int oo = 0;
+            for (int i = 0; i < n; i++) {
+                if (ch1[i] == '0') {
+                    if (ch2[i] == '0') {
+                        zz += 1;
+                    } else {
+                        oz += 1;
+                    }
+                } else {
+                    if (ch2[i] == '0') {
+                        zo += 1;
+                    } else {
+                        oo += 1;
+                    }
+                }
+            }
+            int ans = -1;
+            if ((oo - zz) == 1 || zo == oz) {
+                int s1 = (int) 1e7;
+                int s2 = (int) 1e7;
+                if ((oo - zz) == 1) {
+                    s1 = oo + zz;
+                }
+                if (zo == oz)
+                    s2 = zo + oz;
+                ans = Math.min(s1, s2);
+            }
+            System.out.println(ans);
+        }
+    }
+}
+
+//9
+//001011011
+//011010101    3 2 2 2
+//9
+//100010111
+//101101100    2 1 3 3",0
+51e5a1a5,960a4c0f,"import java.io.*;
+import java.util.*;
+public class A {
+    static FastScanner fs;
+    public static void main(String[] args) {
+        fs=new FastScanner();
+        int t = fs.nextInt();
+        while (t-->0)
+            solve();
+    }
+    public static void solve() {
+        int n = fs.nextInt();
+        int[] c = fs.readArray(n);
+        long sumEven = c[0];
+        long minEven = c[0];
+        long sumOdd = c[1];
+        long minOdd = c[1];
+        long ans = n*minOdd+n*minEven;
+        for (int i=2; i<n; i++) {
+            if (i%2==0) {
+                sumEven+=c[i];
+                minEven = Math.min(minEven, c[i]);
+            }
+            else {
+                sumOdd+=c[i];
+                minOdd = Math.min(minOdd, c[i]);
+            }
+            ans = Math.min(ans, sumEven+(n-i/2-1)*minEven+sumOdd+(n-(i+1)/2)*minOdd);
+        }
+        System.out.println(ans);
+    }
+    static void ruffleSort(int[] a) {
+        int n=a.length;//shuffle, then sort
+        for (int i=0; i<n; i++) {
+            int oi=random.nextInt(n), temp=a[oi];
+            a[oi]=a[i]; a[i]=temp;
+        }
+        Arrays.sort(a);
+    }
+    static final Random random =new Random();
+    static class FastScanner {
+        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st=new StringTokenizer("""");
+        String next() {
+            while (!st.hasMoreTokens())
+                try {
+                    st=new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+        int[] readArray(int n) {
+            int[] a=new int[n];
+            for (int i=0; i<n; i++) a[i]=nextInt();
+            return a;
+        }
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+    }
+
+    static int[] reverse(int[] a) {
+        int n=a.length;
+        int[] res=new int[n];
+        for (int i=0; i<n; i++) res[i]=a[n-1-i];
+        return res;
+    }
+}","
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.Arrays;
+import java.util.Random;
+import java.util.StringTokenizer;
+
+public final class C {
+
+    public static void main(String[] args) {
+        final FastScanner fs = new FastScanner();
+        final int t = fs.nextInt();
+        for (int test = 0; test < t; test++) {
+            final int n = fs.nextInt();
+            final int[] arr = fs.nextIntArray(n);
+            long evenSum = arr[0];
+            long oddSum = arr[1];
+            int minEven = arr[0];
+            int minOdd = arr[1];
+            long res = (long) n * arr[0] + (long) n * arr[1];
+            for (int i = 2; i < n; i++) {
+                if (i % 2 == 0) {
+                    minEven = Math.min(minEven, arr[i]);
+                    evenSum += arr[i];
+                    final long eC = n - i / 2 - 1;
+                    final long oC = n - i / 2;
+                    final long curr = evenSum + eC * minEven + oddSum + oC * minOdd;
+                    res = Math.min(res, curr);
+
+                } else {
+                    minOdd = Math.min(minOdd, arr[i]);
+                    oddSum += arr[i];
+                    final long c = n - i / 2 - 1;
+                    final long curr = oddSum + c * minOdd + evenSum + c * minEven;
+                    res = Math.min(res, curr);
+                }
+            }
+            System.out.println(res);
+        }
+    }
+
+    static final class Utils {
+        private static class Shuffler {
+            private static void shuffle(int[] x) {
+                final Random r = new Random();
+
+                for (int i = 0; i <= x.length - 2; i++) {
+                    final int j = i + r.nextInt(x.length - i);
+                    swap(x, i, j);
+                }
+            }
+
+            private static void shuffle(long[] x) {
+                final Random r = new Random();
+
+                for (int i = 0; i <= x.length - 2; i++) {
+                    final int j = i + r.nextInt(x.length - i);
+                    swap(x, i, j);
+                }
+            }
+
+            private static void swap(int[] x, int i, int j) {
+                final int t = x[i];
+                x[i] = x[j];
+                x[j] = t;
+            }
+
+            private static void swap(long[] x, int i, int j) {
+                final long t = x[i];
+                x[i] = x[j];
+                x[j] = t;
+            }
+        }
+
+        public static void shuffleSort(int[] arr) {
+            Shuffler.shuffle(arr);
+            Arrays.sort(arr);
+        }
+
+        public static void shuffleSort(long[] arr) {
+            Shuffler.shuffle(arr);
+            Arrays.sort(arr);
+        }
+
+        private Utils() {}
+    }
+
+    static class FastScanner {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st = new StringTokenizer("""");
+
+        private String next() {
+            while (!st.hasMoreTokens()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    //noinspection CallToPrintStackTrace
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        int[] nextIntArray(int n) {
+            final int[] a = new int[n];
+            for (int i = 0; i < n; i++) { a[i] = nextInt(); }
+            return a;
+        }
+
+        long[] nextLongArray(int n) {
+            final long[] a = new long[n];
+            for (int i = 0; i < n; i++) { a[i] = nextLong(); }
+            return a;
+        }
+    }
+}
+",0
+5af25bd7,cbbbed5f,"import java.io.*;
+import java.util.*;
+ 
+public class MySolution {
+    public static void main(String[] args) throws Exception {
+        BufferedReader bu = new BufferedReader(new InputStreamReader(System.in));
+        StringBuilder out = new StringBuilder();
+        int numOfTestCases = Integer.parseInt(bu.readLine());
+        for (int tc = 1; tc <= numOfTestCases; tc++) {
+            int vertices = Integer.parseInt(bu.readLine());
+            connections = new ArrayList[vertices];
+            for (int i = 0; i < vertices; i++) {
+                connections[i] = new ArrayList<Integer>();
+                String st[] = bu.readLine().split("" "");
+                a[i][0] = Integer.parseInt(st[0]);
+                a[i][1] = Integer.parseInt(st[1]);
+                s[i][0] = s[i][1] = 0;
+            }
+            for (int j = 0; j < vertices-1; j++) {
+                String st[] = bu.readLine().split("" "");
+                int u = Integer.parseInt(st[0]) - 1, v = Integer.parseInt(st[1]) - 1;
+                connections[u].add(v);
+                connections[v].add(u);
+            }
+            dfs(0, -1);
+            out.append(Math.max(s[0][0], s[0][1]) + ""\n"");
+        }
+        System.out.print(out);
+    }
+ 
+    static int N = 100000;
+    static int[][] a = new int[N][2];
+    static long[][] s = new long[N][2];
+    static ArrayList<Integer>[] connections;
+ 
+    public static void dfs(int n, int parent) {
+        for (int child : connections[n]) {
+            if (child != parent) {
+                dfs(child, n);
+                s[n][0] += Math.max(s[child][0] + Math.abs(a[n][0] - a[child][0]), s[child][1] + Math.abs(a[n][0] - a[child][1]));
+                s[n][1] += Math.max(s[child][0] + Math.abs(a[n][1] - a[child][0]), s[child][1] + Math.abs(a[n][1] - a[child][1]));
+            }
+        }
+    }
+}
+","import java.util.*;
+import java.io.*;
+
+public class C{
+
+	private static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+    private static BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
+    private static int vertices;
+    private static LinkedList<Integer> adj[];
+    private static long dp[][];
+    private static int l[];
+    private static int r[];
+    private static boolean vis[];
+
+    public static void dfs(int v) {
+        if(vis[v])
+            return;
+        vis[v] = true;
+        Iterator<Integer> iterator = adj[v].listIterator();
+        while(iterator.hasNext()) {
+            int child = iterator.next();
+            if(!vis[child]) {
+                dfs(child);
+                long left = dp[child][0] + Math.abs(l[v] - l[child]);
+                dp[v][0] += Math.max(left, dp[child][1] + Math.abs(l[v] - r[child]));
+                long right = dp[child][0] + Math.abs(r[v] - l[child]);
+                dp[v][1] += Math.max(right, dp[child][1] + Math.abs(r[v] - r[child]));
+            }
+        }
+    }
+
+	public static void main (String[] args) throws IOException {
+        int t = Integer.parseInt(br.readLine());
+        while(t-- > 0) {
+            int n = Integer.parseInt(br.readLine());
+            vertices = n;
+            dp = new long[n+1][2];
+            adj = new LinkedList[n+1];
+            vis = new boolean[n+1];
+            l = new int[n+1];
+            r = new int[n+1];
+            for(int i=1;i<=n;i++) {
+                adj[i] = new LinkedList<>();
+            }
+            for(int i=1;i<=n;i++) {
+                String lr[] = br.readLine().split("" "");
+                l[i] = Integer.parseInt(lr[0]);
+                r[i] = Integer.parseInt(lr[1]);
+            }
+            for(int i=0;i<n-1;i++) {
+                String uv[] = br.readLine().split("" "");
+                int u = Integer.parseInt(uv[0]);
+                int v = Integer.parseInt(uv[1]);
+                adj[u].add(v);
+                adj[v].add(u);
+            }
+            dfs(1);
+            long ans = Math.max(dp[1][0], dp[1][1]);
+            bw.write(ans + ""\n"");
+        }
+        bw.flush();
+    }
+}",0
+72d9eb5b,884f5678,"import java.util.*;
+import java.io.*;
+
+public class D {
+    public static void main(String[] args) {
+        Scanner in = new Scanner(System.in);
+        
+        int T = in.nextInt();
+        while(T-- > 0) {
+            int n = in.nextInt();
+            int[] a = new int[n];
+            for(int j=0;j<n;j++) a[j] = in.nextInt();
+            char[] s = in.next().toCharArray();
+
+            List<Integer> blue = new ArrayList<>();
+            List<Integer> red = new ArrayList<>();
+            for(int j=0;j<n;j++) {
+                if(s[j] == 'B') blue.add(a[j]);
+                else red.add(a[j]);
+            }
+
+            Collections.sort(blue);
+            Collections.sort(red);
+
+            boolean p = true;
+            int cur = 1;
+            for(int val : blue) {
+                if(val<cur) {
+                    p = false;
+                    break;
+                }
+                else cur++;
+            }
+            for(int val : red) {
+                if(val>cur) {
+                    p = false;
+                    break;
+                }
+                else cur++;
+            }
+            
+            if(p) System.out.println(""yes"");
+            else System.out.println(""no"");
+        }
+    }
+}
+","import java.io.*;
+import java.util.*;
+import java.text.*;
+import java.math.*;
+import java.util.regex.*;
+
+public class JaiShreeRam{
+	static Scanner in=new Scanner();
+	static long mod = 1000000007;
+	static ArrayList<ArrayList<Integer>> adj;
+	public static void main(String[] args) throws Exception{
+		class Element{
+			int x;
+			char c;
+			public Element(int y,char k) {
+				x=y;
+				c=k;
+			}
+		}
+		int z=in.readInt();
+		while(z-->0) {
+			int n=in.readInt();
+			int a[]=nia(n);
+			char c[]=in.readString().toCharArray();
+			ArrayList<Integer> d=new ArrayList<>();
+			ArrayList<Integer> in=new ArrayList<>();
+			for(int i=0;i<n;i++) {
+				if(c[i]=='R') {
+					in.add(a[i]);
+				}
+				else {
+					d.add(a[i]);
+				}
+			}
+			String ans=""YES"";
+			Collections.sort(d);
+			int k=1;
+			for(int i:d) {
+				if(i<k) {
+					ans=""NO"";
+				}
+				k++;
+			}
+			Collections.sort(in);
+			for(int i=in.size()-1;i>=0;i--) {
+				if(in.get(i)>n) {
+					ans=""NO"";
+					break;
+				}
+				n--;
+			}
+			System.out.println(ans);
+		}
+	}
+	static long ans(long l,long r,long x,long y) {
+		long mid=(r-l)/2+l;
+		long a=mid%x;
+		long b=y%mid;
+		long c=0;
+		if(l>r) {
+			return 0;
+		}
+		if(a==b) {
+			return mid;
+		}
+		else if(a<b) {
+			c=ans(l,mid-1,x,y);
+			if(c==0) {
+				c=ans(mid+1,r,x,y);
+			}
+		}
+		else{
+			c=ans(l,mid-1,x,y);
+			if(c==0) {
+				c=ans(mid+1,r,x,y);
+			}
+		}
+		return c;
+	}
+	static int[] nia(int n){
+		int[] arr= new int[n];
+		int i=0;
+		while(i<n){
+			arr[i++]=in.readInt();
+		}
+		return arr;
+	}
+	static long[] nla(int n){
+		long[] arr= new long[n];
+		int i=0;
+		while(i<n){
+			arr[i++]=in.readLong();
+		}
+		return arr;
+	}
+	static int[] nia1(int n){
+		int[] arr= new int[n+1];
+		int i=1;
+		while(i<=n){
+			arr[i++]=in.readInt();
+		}
+		return arr;
+	}
+	static long gcd(long a, long b) {
+		if (b==0) return a;
+		return gcd(b, a%b);
+	}
+	static class Scanner{
+		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st=new StringTokenizer("""");
+		String readString() {
+			while (!st.hasMoreTokens())
+				try {
+					st=new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			return st.nextToken();
+		}
+		double readDouble() {
+			return Double.parseDouble(readString());
+		}
+		int readInt() {
+			return Integer.parseInt(readString());
+		}
+		long readLong() {
+			return Long.parseLong(readString());
+		}
+	}	
+}",0
+a8f7c8b7,f229aa7f,"
+import java.util.Scanner;
+
+public class Menorah {
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        int t = sc.nextInt();
+        while (t-- > 0) {
+            int n = sc.nextInt();
+            char initial[] = sc.next().toCharArray();
+            char desired[] = sc.next().toCharArray();
+            int lit1 = 0, lit2 = 0;
+            int ans = Integer.MAX_VALUE;
+            for (int i = 0; i < n; i++) {
+                if (initial[i] == '1') {
+                    ++lit1;
+                }
+                if (desired[i] == '1') {
+                    ++lit2;
+                }
+            }
+            if (lit1 == lit2) {
+                int count = 0;
+                for (int i = 0; i < n; i++) {
+                    if (initial[i] != desired[i]) {
+                        ++count;
+                    }
+                }
+                ans = Math.min(count, ans);
+            }
+            if (lit2 == (n - lit1 + 1)) {
+                int count = 0;
+                for (int i = 0; i < n; i++) {
+                    if (initial[i] == desired[i]) {
+                        ++count;
+                    }
+                }
+                ans = Math.min(ans, count);
+            }
+            if (ans == Integer.MAX_VALUE) {
+                System.out.println(-1);
+            } else {
+                System.out.println(ans);
+            }
+        }
+    }
+}","import java.util.*;
+import java.io.*;
+import java.math.*;
+
+public class cf {
+	static PrintWriter pw = new PrintWriter(System.out);
+
+	public static void main(String[] args) throws IOException, InterruptedException {
+		Scanner sc = new Scanner(System.in);
+		int t = sc.nextInt();
+		while (t-- > 0) {
+			int n = sc.nextInt();
+			char[] a = sc.next().toCharArray();
+			char[] b = sc.next().toCharArray();
+			int x = 0, y = 0, lit = 0,lit2 = 0;
+			for (int i = 0; i < n; i++) {
+				if (a[i] == '1')
+					lit++;
+				if (b[i] == '1')
+					lit2++;
+				if (a[i] == b[i])
+					x++;
+				else
+					y++;
+			}
+			if(lit == lit2 || n - lit + 1 == lit2) {
+				if (lit == lit2 && n - lit + 1 == lit2) {
+					pw.println(Math.min(x,y));
+				}else if(lit == lit2) {
+					pw.println(y);
+				}else {
+					pw.println(x);
+				}
+			}else {
+				pw.println(-1);
+			}
+		}
+		pw.close();
+	}
+
+	public static class tuble implements Comparable<tuble> {
+		int x;
+		int y;
+		int z;
+
+		public tuble(int x, int y, int z) {
+			this.x = x;
+			this.y = y;
+			this.z = z;
+		}
+
+		public String toString() {
+			return x + "" "" + y + "" "" + z;
+		}
+
+		public int compareTo(tuble other) {
+			if (this.x == other.x) {
+				if (this.y == other.y)
+					return this.z - other.z;
+				return this.y - other.y;
+			} else {
+				return this.x - other.x;
+			}
+		}
+	}
+
+	public static class pair implements Comparable<pair> {
+		int x;
+		int y;
+
+		public pair(int x, int y) {
+			this.x = x;
+			this.y = y;
+		}
+
+		public String toString() {
+			return x + "" "" + y;
+		}
+
+		public boolean equals(Object o) {
+			if (o instanceof pair) {
+				pair p = (pair) o;
+				return p.x == x && p.y == y;
+			}
+			return false;
+		}
+
+		public int hashCode() {
+			return new Integer(x).hashCode() * 31 + new Integer(y).hashCode();
+		}
+
+		public int compareTo(pair other) {
+			if (this.x == other.x) {
+				return Long.compare(this.y, other.y);
+			}
+			return Long.compare(this.x, other.x);
+		}
+	}
+
+	static class Scanner {
+		StringTokenizer st;
+		BufferedReader br;
+
+		public Scanner(InputStream s) {
+			br = new BufferedReader(new InputStreamReader(s));
+		}
+
+		public Scanner(FileReader r) {
+			br = new BufferedReader(r);
+		}
+
+		public String next() throws IOException {
+			while (st == null || !st.hasMoreTokens())
+				st = new StringTokenizer(br.readLine());
+			return st.nextToken();
+		}
+
+		public int nextInt() throws IOException {
+			return Integer.parseInt(next());
+		}
+
+		public long nextLong() throws IOException {
+			return Long.parseLong(next());
+		}
+
+		public String nextLine() throws IOException {
+			return br.readLine();
+		}
+
+		public double nextDouble() throws IOException {
+			return Double.parseDouble(next());
+		}
+
+		public boolean ready() throws IOException {
+			return br.ready();
+		}
+
+	}
+
+}",0
+09586ae3,88c90c09,"import java.io.*;
+import java.util.*;
+public class Main {
+    public static void main(String args[])
+    {
+        FastReader input=new FastReader();
+        PrintWriter out=new PrintWriter(System.out);
+        int T=input.nextInt();
+        while(T-->0)
+        {
+            int n=input.nextInt();
+            int a[]=new int[n];
+            for(int i=0;i<n;i++) a[i]=input.nextInt();
+            long i=1,j=(long)1e15;
+            while(i<j)
+            {
+                long mid=(i+j)/2;
+                if(fun(a,mid,n))
+                {
+                    i=mid+1;
+                }
+                else
+                {
+                    j=mid;
+                }
+            }
+            out.println(i-1);
+        }
+        out.close();
+    }
+    public static boolean fun(int a[],long x,int n)
+    {
+        long arr[]=new long[n];
+        for(int i=0;i<n;i++) arr[i]=a[i];
+        long b[]=new long[n];
+        for(int i=n-1;i>=2;i--)
+        {
+            if(b[i]+arr[i]<x) return false;
+            long z=Math.max(0,x-b[i]);
+            long u=arr[i]-z;
+            long y=u/3;
+            b[i-1]+=y;
+            b[i-2]+=2*y;
+        }
+        if(arr[0]+b[0]<x || arr[1]+b[1]<x) return false;
+        return true;
+    }
+    static class FastReader
+    {
+        BufferedReader br;
+        StringTokenizer st;
+        public FastReader()
+        {
+            br = new BufferedReader(new InputStreamReader(System.in));
+        }
+        String next()
+        {
+            while (st == null || !st.hasMoreElements())
+            {
+                try
+                {
+                    st = new StringTokenizer(br.readLine());
+                }
+                catch (IOException e)
+                {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+        int nextInt()
+        {
+            return Integer.parseInt(next());
+        }
+        long nextLong()
+        {
+            return Long.parseLong(next());
+        }
+        double nextDouble()
+        {
+            return Double.parseDouble(next());
+        }
+        String nextLine()
+        {
+            String str="""";
+            try
+            {
+                str=br.readLine();
+            }
+            catch (IOException e)
+            {
+                e.printStackTrace();
+            }
+            return str;
+        }
+    }
+}","import java.io.OutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.PrintWriter;
+import java.sql.SQLOutput;
+import java.util.*;
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+
+public class Main {
+    public static void main(String[] args) {
+        InputStream inputStream = System.in;
+        OutputStream outputStream = System.out;
+        InputReader in = new InputReader(inputStream);
+        PrintWriter out = new PrintWriter(outputStream);
+        TaskA solver = new TaskA();
+        //int a = 1;
+        int t;
+        t = in.nextInt();
+        //t = 1;
+        while (t > 0) {
+            //out.print(""Case #""+(a++)+"": "");
+            solver.call(in,out);
+            t--;
+        }
+        out.close();
+
+    }
+
+    static class TaskA {
+        int n;
+        long[] arr;
+        public void call(InputReader in, PrintWriter out) {
+            n = in.nextInt();
+            arr = new long[n];
+
+            for (int i = 0; i < n; i++) {
+                arr[i] = in.nextLong();
+            }
+            long l, r, mid;
+            l = 0;
+            r = (long)1e10;
+            while (l  + 1 < r){
+                mid = ( l + r)/2;
+                if(ans(mid)){
+                    l = mid;
+                }
+                else{
+                    r = mid;
+                }
+            }
+
+            out.println(l);
+        }
+
+        public boolean ans(long mid) {
+            long[] array = new long[n];
+            long a, b;
+            for (int i = n - 1; i >= 2; i--) {
+                a = mid - array[i];
+                if(a > 0){
+                    b = arr[i] - a;
+                    if(b >= 0){
+                        b/=3;
+                        array[i - 1] += b;
+                        array[i - 2] += 2*b;
+                    }
+                    else{
+                        return false;
+                    }
+                }
+                else{
+                    b = arr[i];
+                    b/=3;
+                    array[i - 1] += b;
+                    array[i - 2] += 2*b;
+                }
+            }
+            for (int i = 0; i < 2; i++) {
+                if(arr[i] + array[i] < mid){
+                    return false;
+                }
+            }
+            return true;
+        }
+    }
+
+    static int gcd(int a, int b)
+    {
+        if (a == 0)
+            return b;
+        return gcd(b % a, a);
+    }
+
+    static int lcm(int a, int b)
+    {
+        return (a / gcd(a, b)) * b;
+    }
+
+
+    static class answer implements Comparable<answer>{
+        int a, b;
+
+        public answer(int a, int b) {
+            this.a = a;
+            this.b = b;
+        }
+        @Override
+        public int compareTo(answer o) {
+            return Integer.compare(this.a, o.a);
+        }
+
+    }
+
+    static class answer1 implements Comparable<answer1>{
+        int a, b, c;
+
+        public answer1(int a, int b, int c) {
+            this.a = a;
+            this.b = b;
+            this.c = c;
+
+        }
+
+        @Override
+        public int compareTo(answer1 o) {
+            return (o.a - this.a);
+        }
+    }
+
+    static long gcd(long a, long b)
+    {
+        if (b == 0)
+            return a;
+        return gcd(b, a % b);
+    }
+
+    static void sort(long[] a) {
+        ArrayList<Long> l = new ArrayList<>();
+        for (Long i:a) l.add(i);
+        l.sort(Collections.reverseOrder());
+        for (int i=0; i<a.length; i++) a[i]=l.get(i);
+    }
+
+    static final Random random=new Random();
+
+    static void shuffleSort(int[] a) {
+        int n = a.length;
+        for (int i=0; i<n; i++) {
+            int oi= random.nextInt(n), temp=a[oi];
+            a[oi]=a[i]; a[i]=temp;
+        }
+        Arrays.sort(a);
+    }
+
+    static class InputReader {
+        public BufferedReader reader;
+        public StringTokenizer tokenizer;
+
+        public InputReader(InputStream stream) {
+            reader = new BufferedReader(new InputStreamReader(stream), 32768);
+            tokenizer = null;
+        }
+
+        public String next() {
+            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
+                try {
+                    tokenizer = new StringTokenizer(reader.readLine());
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+            }
+            return tokenizer.nextToken();
+        }
+
+        public int nextInt() {
+            return Integer.parseInt(next());
+        }
+        public long nextLong(){
+            return Long.parseLong(next());
+        }
+        public double nextDouble() {
+            return Double.parseDouble(next());
+        }
+
+    }
+}",0
+a4ec80a0,d314aa92,"import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.PriorityQueue;
+import java.util.Scanner;
+
+public class Armchairs {
+
+	static List<Integer> zpos ;
+	static List<Integer> opos ;
+	static long[][] dp ;
+	
+	public static void main(String[] args) {
+		// TODO Auto-generated method stub
+		Scanner sc = new Scanner(System.in);
+		int n = sc.nextInt();
+		zpos = new ArrayList<Integer>();
+		opos = new ArrayList<Integer>();
+		for (int i = 0; i < n; i++) {
+			int x = sc.nextInt();
+			if (x == 1) opos.add(i);
+			else zpos.add(i);
+		}
+		dp = new long[5001][5001];
+		for (int i = 0; i < 5001; i++) Arrays.fill(dp[i], -1);
+		System.out.println(dp(0, 0, opos.size(), zpos.size(), opos.size()));
+	}
+
+	private static long dp(int i, int j, int m, int n, int cnt) {
+		// TODO Auto-generated method stub
+		if (cnt == 0) return 0;
+		if (i >= m || j >= n) return Integer.MAX_VALUE;
+		if (dp[i][j] != -1) return dp[i][j];
+		long dns = dp(i, j + 1, m, n, cnt);
+		long s = Math.abs(zpos.get(j) - opos.get(i)) + dp(i + 1, j + 1, m, n, cnt - 1);
+		return dp[i][j] = Math.min(dns, s);
+	}
+
+}
+","import java.io.*;
+import java.util.*;
+
+public class Codeforces {
+
+    public static class FastReader {
+        BufferedReader br;
+        StringTokenizer st;
+
+        public FastReader(String s) {
+            try {
+                br = new BufferedReader(new FileReader(s));
+            } catch (FileNotFoundException e) {
+                // TODO Auto-generated catch block
+                e.printStackTrace();
+            }
+        }
+
+        public FastReader() {
+            br = new BufferedReader(new InputStreamReader(System.in));
+        }
+
+        String nextToken() {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    // TODO Auto-generated catch block
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(nextToken());
+        }
+
+        long nextLong() {
+            return Long.parseLong(nextToken());
+        }
+
+        double nextDouble() {
+            return Double.parseDouble(nextToken());
+        }
+    }
+
+
+    static FastReader f = new FastReader();
+    static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+    static StringTokenizer st;
+    static StringBuilder sb = new StringBuilder("""");
+    private static int m = (int) 1e9 + 7;
+    static int MAX = 500005;
+    static long[] fact;
+
+    static int[] inputArray(int n) throws IOException {
+        int[] a = new int[n];
+        for (int i = 0; i < n; i++) {
+            a[i] = f.nextInt();
+        }
+        return a;
+    }
+
+    private static class SegmentTree {
+        int[] array;
+        int[] tree;
+        int n;
+        int max;
+
+        SegmentTree(int a[], int n) {
+            this.tree = new int[4 * n + 1];
+            this.array = a;
+            this.n = n;
+            buildTree();
+        }
+
+        void buildTree() {
+            buildTreeHelper(0, 0, n - 1);
+        }
+
+        void buildTreeHelper(int i, int start, int end) {
+            if (start > end) {
+                return;
+            }
+            if (start == end) {
+                tree[i] = array[start];
+                return;
+            }
+            int mid = (start + end) / 2;
+            buildTreeHelper(2 * i + 1, start, mid);
+            buildTreeHelper(2 * i + 2, mid + 1, end);
+            tree[i] = Math.max(tree[2 * i + 1], tree[2 * i + 2]);
+        }
+
+        char overlap(int start, int end, int qs, int qe) {
+            if (qe < start || qs > end || start > end) {
+                return 0;
+            }
+            if (qs <= start && qe >= end) {
+                return 2;
+            }
+            return 1;
+        }
+
+        int query(int start, int end) {
+            return andQueryHelper(0, 0, n - 1, start, end);
+        }
+
+        int andQueryHelper(int i, int start, int end, int qs, int qe) {
+            if (overlap(start, end, qs, qe) == 0) {
+                return 0;
+            }
+            if (overlap(start, end, qs, qe) == 1) {
+                int mid = (start + end) / 2;
+                return Math.max(andQueryHelper(2 * i + 1, start, mid, qs, qe),
+                        andQueryHelper(2 * i + 2, mid + 1, end, qs, qe));
+            } else {
+                return tree[i];
+            }
+        }
+    }
+
+    static int query(int l, int r) {
+        System.out.println(""? "" + l + "" "" + r);
+        System.out.flush();
+        int res = f.nextInt();
+        System.out.flush();
+        return res;
+    }
+
+    static long gcd(long a , long b) {
+        if(a == 0 || b == 0) {
+            return Math.max(a , b);
+        }
+        //System.out.println(""a - "" + a + "" b - "" + b);
+        if(a % b == 0) {
+            return b;
+        }
+        return gcd(b , a % b);
+    }
+
+    public static void main(String[] args) throws IOException {
+
+//        System.out.println(gcd(11, 3));
+
+        int t = 1;
+        while(t-- != 0) {
+            int N = f.nextInt();
+            int a[] = inputArray(N);
+            ArrayList<Integer> space = new ArrayList<>();
+            ArrayList<Integer> fill = new ArrayList<>();
+            for(int i = 0 ; i < N;  i++) {
+                if(a[i] == 0) {
+                    space.add(i);
+                }
+                else {
+                    fill.add(i);
+                }
+            }
+            int n = fill.size(), m = space.size();
+            int[][] dp = new int[n+1][m+1];
+            // i - no of filled
+            // j is no of space
+            Arrays.fill(dp[0], 0);
+            for(int i = 1 ; i <= n ; i++) {
+                dp[i][0] = -1;
+            }
+            for(int i = 1 ; i <= n ; i++) {
+                for(int j = 1 ; j <= m ; j++) {
+                    if(i > j) {
+                        dp[i][j] = -1;
+                        continue;
+                    }
+                    dp[i][j] = Integer.MAX_VALUE;
+                    if(dp[i-1][j-1] != -1) {
+                        dp[i][j] = Math.min(dp[i][j], dp[i-1][j-1]) + Math.abs(fill.get(i-1) - space.get(j-1));
+                    }
+                    if(dp[i][j-1] != -1) {
+                        dp[i][j] = Math.min(dp[i][j], dp[i][j-1]);
+                    }
+                }
+            }
+
+            System.out.println(dp[n][m]);
+
+        }
+
+        System.out.println(sb);
+
+    }
+
+}
+
+/*
+5
+2 1
+1 1
+500 4
+217871987498122 10
+100000000000000001 1
+ */
+
+
+",0
+54d7c21e,80881cae,"
+import java.io.*;
+import java.util.*;
+
+
+public class cp {
+	static int mod=(int)1e9+7;
+	
+//	static  Reader sc=new Reader();
+	static FastReader sc=new FastReader(System.in);
+	static int[] sp;
+	static int size=(int)1e6;
+	static int[] arInt;
+	static long[] arLong;
+	public static void main(String[] args) throws IOException { 
+		long tc=sc.nextLong();
+//		Scanner sc=new Scanner(System.in);
+//			int tc=1;
+			
+//			primeSet=new HashSet<>();
+//			sieveOfEratosthenes((int)1e6+5);
+			while(tc-->0)
+			{
+				int n=sc.nextInt();
+				int k[]=new int[n];
+				int h[]=new int[n];
+				for(int i=0;i<n;i++)
+					k[i]=sc.nextInt();
+				for(int i=0;i<n;i++)
+					h[i]=sc.nextInt();
+				ArrayList<Pair> interval=new ArrayList<Pair>();
+				ArrayList<Pair> act=new ArrayList<Pair>();
+				for(int i=0;i<n;i++)
+					interval.add(new Pair(k[i]-h[i]+1,k[i]));
+				Collections.sort(interval);
+				// out.println(interval);
+				act.add(interval.get(0));
+				for(int i=1;i<n;i++)
+				{
+					Pair p=act.get(act.size()-1);
+					if(p.y<interval.get(i).x)
+						act.add(interval.get(i));
+					else
+						p.y=Math.max(p.y, interval.get(i).y);
+				}
+				// out.println(act);
+				long mana=0;
+				for(Pair p: act)
+				{
+					long x=p.y-p.x+1;
+					mana+=(x*(x+1))/2;
+				}
+				out.println(mana);
+				
+				
+				
+				
+				
+				
+				
+				
+				
+//				int n=sc.nextInt();
+//				long days[]=new long[n];
+//				long power[]=new long[n];
+//				for (int i = 0; i < power.length; i++) {
+//					days[i]=sc.nextLong();
+//				}
+//				for (int i = 0; i < power.length; i++) {
+//					power[i]=sc.nextLong();
+//					
+//				}
+//				
+//				long ans=0;
+//				for(int i=0;i<n;i++)
+//				{
+//					if(i==0)
+//					{
+//						ans+=power[i]*(power[i]+1L)/2L;
+//						continue;
+//					}
+//					
+//					long temp=power[i]*(power[i]+1)/2L;
+//					long temp2=(power[i-1]+days[i]-days[i-1])*(power[i-1]+days[i]-days[i-1]+1L)/2L;
+//					temp2-=power[i-1]*(power[i-1]+1L)/2L;
+//					ans+=Math.min(temp, temp2);
+////					if(days[i]-days[i-1]<=power[i])
+////					{
+////						ans+=power[i]*(power[i]+1)/2;
+////					}
+////					else {
+////						ans+=power[i]*(power[i]+1)/2;
+////						ans-=power[i-1]*(power[i-1]+1)/2;
+////					}
+//						
+//					
+//				}
+//				
+//				out.println(ans);
+			}
+			
+				
+			
+			
+			out.flush();
+			out.close();
+			System.gc();
+	
+	}
+	
+	
+	
+
+
+	/*
+	   ...SOLUTION ENDS HERE...........SOLUTION ENDS HERE...
+ */
+	
+	
+	static int util(char a,char b)
+	{
+		int A=a-'0';
+		int B=b-'0';
+		return A+B;
+	}
+	static boolean check(int x,int[] rich,int[] poor)
+	{
+		int cnt=0;
+		for(int i=0;i<rich.length;i++)
+		{
+			if(x-1-rich[i]<=cnt && cnt<=poor[i])
+				cnt++;
+		}
+		
+		return cnt>=x;
+	}
+	
+	static void arrInt(int n) throws IOException
+	{
+		arInt=new int[n];
+		for (int i = 0; i < arInt.length; i++) {
+			arInt[i]=sc.nextInt();
+		}
+	}
+	
+	static void arrLong(int n) throws IOException
+	{
+		arLong=new long[n];
+		for (int i = 0; i < arLong.length; i++) {
+			arLong[i]=sc.nextLong();
+		}
+	}
+	
+	
+	
+	static ArrayList<Integer> add(int id,int c)
+	{
+		ArrayList<Integer> newArr=new ArrayList<>();
+		for(int i=0;i<id;i++)
+			newArr.add(arInt[i]);
+		newArr.add(c);
+		for(int i=id;i<arInt.length;i++)
+		{
+			newArr.add(arInt[i]);
+		}
+		
+		
+		return newArr;
+	}
+
+	    // function to find last index <= y
+    static int upper(ArrayList<Integer> arr, int n, int y)
+    {
+        int l = 0, h = n - 1;
+        while (l <= h)
+        {
+            int mid = (l + h) / 2;
+            if (arr.get(mid) <= y)
+                l = mid + 1;
+            else
+                h = mid - 1;
+        }
+        return h;
+    }
+     
+	
+	
+	static int lower(ArrayList<Integer> arr, int n, int x)
+    {
+        int l = 0, h = n - 1;
+        while (l <= h)
+        {
+            int mid = (l + h) / 2;
+            if (arr.get(mid) >= x)
+                h = mid - 1;
+            else
+                l = mid + 1;
+        }
+        return l;
+    }
+          
+	
+	
+	
+	
+	static int N = 501; 
+	 
+	// Array to store inverse of 1 to N
+	static long[] factorialNumInverse = new long[N + 1];
+	 
+	// Array to precompute inverse of 1! to N!
+	static long[] naturalNumInverse = new long[N + 1];
+	 
+	// Array to store factorial of first N numbers
+	static long[] fact = new long[N + 1];
+	 
+	// Function to precompute inverse of numbers
+	public static void InverseofNumber(int p)
+	{
+	    naturalNumInverse[0] = naturalNumInverse[1] = 1;
+	     
+	    for(int i = 2; i <= N; i++)
+	        naturalNumInverse[i] = naturalNumInverse[p % i] *
+	                                 (long)(p - p / i) % p;
+	}
+	 
+	// Function to precompute inverse of factorials
+	public static void InverseofFactorial(int p)
+	{
+	    factorialNumInverse[0] = factorialNumInverse[1] = 1;
+	 
+	    // Precompute inverse of natural numbers
+	    for(int i = 2; i <= N; i++)
+	        factorialNumInverse[i] = (naturalNumInverse[i] *
+	                           factorialNumInverse[i - 1]) % p;
+	}
+	 
+	// Function to calculate factorial of 1 to N
+	public static void factorial(int p)
+	{
+	    fact[0] = 1;
+	 
+	    // Precompute factorials
+	    for(int i = 1; i <= N; i++)
+	    {
+	        fact[i] = (fact[i - 1] * (long)i) % p;
+	    }
+	}
+	 
+	// Function to return nCr % p in O(1) time
+	public static long Binomial(int N, int R, int p)
+	{
+	     
+	    // n C r = n!*inverse(r!)*inverse((n-r)!)
+	    long ans = ((fact[N] * factorialNumInverse[R]) %
+	                       p * factorialNumInverse[N - R]) % p;
+	     
+	    return ans;
+	}
+	
+	
+	static String tr(String s)
+	{
+		int now = 0;
+		while (now + 1 < s.length() && s.charAt(now)== '0')
+			++now;
+		return s.substring(now);
+	}
+	
+	 static ArrayList<Integer> ans;
+	static void dfs(int node,Graph gg,int cnt,int k,ArrayList<Integer> temp)
+	{
+		if(cnt==k)
+			return;
+		
+		for(Integer each:gg.list[node])
+		{
+			if(each==0)
+			{
+				temp.add(each);
+				ans=new ArrayList<>(temp);
+				temp.remove(temp.size()-1);
+				continue;
+			}
+			temp.add(each);
+			dfs(each,gg,cnt+1,k,temp);
+			temp.remove(temp.size()-1);
+			
+		}
+		
+		return;
+	}
+	
+	
+	static boolean isPrime(long n)
+    {
+        // Corner cases
+        if (n <= 1)
+            return false;
+        if (n <= 3)
+            return true;
+  
+        // This is checked so that we can skip
+        // middle five numbers in below loop
+        if (n % 2 == 0 || n % 3 == 0)
+            return false;
+  
+        for (int i = 5; i * i <= n; i = i + 6)
+            if (n % i == 0 || n % (i + 2) == 0)
+                return false;
+  
+        return true;
+    }
+	
+	
+	static ArrayList<Integer> commDiv(int a, int b)
+    {
+        // find gcd of a, b
+        int n = gcd(a, b);
+ 
+        // Count divisors of n.
+        ArrayList<Integer> Div=new ArrayList<>();
+        for (int i = 1; i <= Math.sqrt(n); i++) {
+            // if 'i' is factor of n
+            if (n % i == 0) {
+                // check if divisors are equal
+                if (n / i == i)
+                    Div.add(i);
+                else
+                {
+                	Div.add(i);
+                	Div.add(n/i);
+                }
+            }
+        }
+        return Div;
+    }
+	
+	static HashSet<Integer> factors(int x)
+	{
+		HashSet<Integer> a=new HashSet<Integer>();
+		for(int i=2;i*i<=x;i++)
+		{
+			if(x%i==0)
+			{
+				a.add(i);
+				a.add(x/i);
+			}
+		}
+		return a;
+	}
+		
+	
+static class Node
+{
+	int vertex;
+	HashSet<Node> adj;
+	boolean rem;
+	Node(int ver)
+	{
+		vertex=ver;
+		rem=false;
+		adj=new HashSet<Node>();
+	}
+	@Override
+	public String toString()
+	{
+		return vertex+"" "";
+	}
+}
+
+	static class Tuple{
+		int a;
+		int b;
+		int c;
+		public Tuple(int a,int b,int c) {
+			this.a=a;
+			this.b=b;
+			this.c=c;
+		}
+		
+	}
+
+	//function to find prime factors of n
+	static HashMap<Long,Long> findFactors(long n2)
+	{
+		HashMap<Long,Long> ans=new HashMap<>();
+		if(n2%2==0)
+		{
+			ans.put(2L, 0L);
+//			cnt++;
+			while((n2&1)==0)
+			{
+				n2=n2>>1;
+				ans.put(2L, ans.get(2L)+1);
+//				
+			}
+				
+		}
+		for(long i=3;i*i<=n2;i+=2)
+		{
+			if(n2%i==0)
+			{
+				ans.put((long)i, 0L);
+//				cnt++;
+				while(n2%i==0)
+				{
+					n2=n2/i;
+					ans.put((long)i, ans.get((long)i)+1);
+					
+				}
+			}
+		}
+		if(n2!=1)
+		{
+			ans.put(n2, ans.getOrDefault(n2, (long) 0)+1);
+			
+		}
+			
+		return ans;
+	}
+	
+
+	//fenwick tree implementaion
+	static class fwt
+	{
+		int n;
+		long BITree[];
+		fwt(int n)
+		{
+			this.n=n;
+			BITree=new long[n+1];
+		}
+		
+		fwt(int arr[], int n)
+		{
+			this.n=n;
+			BITree=new long[n+1];
+			for(int i = 0; i < n; i++)
+			updateBIT(n, i, arr[i]);
+		 }
+		
+		   long getSum(int index)
+		   {
+		       long sum = 0;
+		       index = index + 1;
+		       while(index>0)
+		       {
+		           sum += BITree[index];
+		           index -= index & (-index);
+		       }
+		       return sum;
+		   }
+		   void updateBIT(int n, int index,int val)
+		   {
+		       index = index + 1;
+		       while(index <= n)
+		       {
+		       BITree[index] += val;
+		       index += index & (-index);
+		       }
+		   }
+		   void print()
+		   {
+			    for(int i=0;i<n;i++)
+			    out.print(getSum(i)+"" "");
+			    out.println();
+		   }
+	}
+
+	
+	class sparseTable{
+	int n;
+	long[][]dp;
+	int log2[];
+	int P;
+	
+	void buildTable(long[] arr)
+	{
+		n=arr.length;
+		P=(int)Math.floor(Math.log(n)/Math.log(2));
+		
+		log2=new int[n+1];
+		log2[0]=log2[1]=0;
+		for(int i=2;i<=n;i++)
+		{
+			log2[i]=log2[i/2]+1;
+		}
+		dp=new long[P+1][n];
+		for(int i=0;i<n;i++)
+		{
+			dp[0][i]=arr[i];
+		}
+		
+		for(int p=1;p<=P;p++)
+		{
+			for(int i=0;i+(1<<p)<=n;i++)
+			{
+				long left=dp[p-1][i];
+				long right=dp[p-1][i+(1<<(p-1))];
+				dp[p][i]=Math.max(left, right);
+			}
+		}
+	}
+	
+	
+	long maxQuery(int l,int r)
+	{
+		int len=r-l+1;
+		int p=(int)Math.floor(log2[len]);
+		long left=dp[p][l];
+		long right=dp[p][r-(1<<p)+1];
+		return Math.max(left, right);
+	}
+}
+
+	
+	
+	
+	//Function to find number of set bits
+	static int setBitNumber(long n)
+    {
+        if (n == 0)
+            return 0;
+ 
+        int msb = 0;
+        n = n / 2;
+ 
+        while (n != 0) {
+            n = n / 2;
+            msb++;
+        }
+ 
+        return msb;
+    }
+ 
+	
+	
+	static int getFirstSetBitPos(long n)
+    {
+        return (int)((Math.log10(n & -n)) / Math.log10(2)) + 1;
+    }
+	
+	
+	static ArrayList<Integer> primes;
+	static HashSet<Integer> primeSet;
+	static boolean prime[];
+	static void sieveOfEratosthenes(int n)
+    {
+        // Create a boolean array
+        // ""prime[0..n]"" and
+        // initialize all entries
+        // it as true. A value in
+        // prime[i] will finally be
+        // false if i is Not a
+        // prime, else true.
+       prime= new boolean[n + 1];
+        for (int i = 2; i <= n; i++)
+            prime[i] = true;
+        
+        for (int p = 2; p * p <= n; p++)
+        {
+            // If prime[p] is not changed, then it is a
+            // prime
+            if (prime[p] == true)
+            {
+                // Update all multiples of p
+                for (int i = p * p; i <= n; i += p)
+                    prime[i] = false;
+            }
+        }
+ 
+        // Print all prime numbers
+        for (int i = 2; i <= n; i++)
+        {
+            if (prime[i] == true)
+               primeSet.add(i);
+        }
+    }
+	
+	
+	
+	static long mod(long a, long b) {
+		  long c = a % b;
+		  return (c < 0) ? c + b : c;
+		}
+	
+	static void swap(long arr[],int i,int j)
+	{
+		long temp=arr[i];
+		arr[i]=arr[j];
+		arr[j]=temp;
+	}
+
+	
+	
+	static boolean util(int a,int b,int c)
+	{
+		if(b>a)util(b, a, c);
+		
+		while(c>=a)
+		{
+			c-=a;
+			if(c%b==0)
+				return true;
+		}
+		
+		
+		return (c%b==0);
+	}
+	
+	
+	
+	static void flag(boolean flag)
+	   {
+	       out.println(flag ? ""YES"" : ""NO"");
+	       out.flush();
+	   }
+	  
+	
+	static void print(int a[])
+	  {
+	     int n=a.length;
+	     for(int i=0;i<n;i++)
+	       {
+	          out.print(a[i]+"" "");
+	       }
+	     out.println();
+	     out.flush();
+	  }
+	static void print(long a[])
+	  {
+	     int n=a.length;
+	     for(int i=0;i<n;i++)
+	       {
+	          out.print(a[i]+"" "");
+	       }
+	     out.println();
+	     out.flush();
+	  } 
+	static void print_int(ArrayList<Integer> al)
+	  {
+	     int si=al.size();
+	     for(int i=0;i<si;i++)
+	       {
+	          out.print(al.get(i)+"" "");
+	       }
+	     out.println();
+	     out.flush();
+	  }
+	static void print_long(ArrayList<Long> al)
+	  {
+	     int si=al.size();
+	     for(int i=0;i<si;i++)
+	       {
+	          out.print(al.get(i)+"" "");
+	       }
+	     out.println();
+	     out.flush();
+	  }
+	  
+	static void printYesNo(boolean condition)
+	{
+		if (condition) {
+			out.println(""YES"");
+		}
+		else {
+			out.println(""NO"");
+		}
+	}
+	
+	
+	static int LowerBound(int a[], int x) 
+	 { // x is the target value or key
+	  int l=-1,r=a.length;
+	  while(l+1<r) {
+	    int m=(l+r)>>>1;
+	    if(a[m]>=x) r=m;
+	    else l=m;
+	  }
+	  return r;
+	}
+	
+	
+	static int lowerIndex(int arr[], int n, int x)
+    {
+        int l = 0, h = n - 1;
+        while (l <= h)
+        {
+            int mid = (l + h) / 2;
+            if (arr[mid] >= x)
+                h = mid - 1;
+            else
+                l = mid + 1;
+        }
+        return l;
+    }
+	
+	
+	    // function to find last index <= y
+    static int upperIndex(int arr[], int n, int y)
+    {
+        int l = 0, h = n - 1;
+        while (l <= h)
+        {
+            int mid = (l + h) / 2;
+            if (arr[mid] <= y)
+                l = mid + 1;
+            else
+                h = mid - 1;
+        }
+        return h;
+    }
+    static int upperIndex(long arr[], int n, long y)
+    {
+    	int l = 0, h = n - 1;
+    	while (l <= h)
+    	{
+    		int mid = (l + h) / 2;
+    		if (arr[mid] <= y)
+    			l = mid + 1;
+    		else
+    			h = mid - 1;
+    	}
+    	return h;
+    }
+     
+	
+	 static int UpperBound(int a[], int x)
+	  {// x is the key or target value
+	    int l=-1,r=a.length;
+	    while(l+1<r) {
+	       int m=(l+r)>>>1;
+	       if(a[m]<=x) l=m;
+	       else r=m;
+	    }
+	    return l+1;
+	 }
+	 static int UpperBound(long a[], long x)
+	 {// x is the key or target value
+		 int l=-1,r=a.length;
+		 while(l+1<r) {
+			 int m=(l+r)>>>1;
+	       if(a[m]<=x) l=m;
+	       else r=m;
+		 }
+		 return l+1;
+	 }
+	
+	 
+	 static class DisjointUnionSets
+	 {
+	    int[] rank, parent;
+	    int n;
+	    // Constructor
+	    public DisjointUnionSets(int n)
+	    {
+	        rank = new int[n];
+	        parent = new int[n];
+	        this.n = n;
+	        makeSet();
+	    }
+	    // Creates n sets with single item in each
+	    void makeSet()
+	    {
+	        for (int i = 0; i < n; i++)
+	            parent[i] = i;
+	    }
+	    int find(int x)
+	    {
+	        if (parent[x] != x) {
+	            parent[x] = find(parent[x]);
+	        }
+	        return parent[x];
+	    }
+	    // Unites the set that includes x and the set
+	    // that includes x
+	    void union(int x, int y)
+	    {
+	        int xRoot = find(x), yRoot = find(y);
+	        if (xRoot == yRoot)
+	            return;
+	        if (rank[xRoot] < rank[yRoot])
+	            parent[xRoot] = yRoot;
+	        else if (rank[yRoot] < rank[xRoot])
+	         parent[yRoot] = xRoot;
+	        else // if ranks are the same
+	        {
+	         parent[yRoot] = xRoot;
+	            rank[xRoot] = rank[xRoot] + 1;
+	        }
+	        
+//	        if(xRoot!=yRoot)
+//	        	parent[y]=x;
+	    }
+	    
+	    int connectedComponents()
+	    {
+	    	int cnt=0;
+	    	for(int i=0;i<n;i++)
+	    	{
+	    		if(parent[i]==i)
+	    			cnt++;
+	    	}
+	    	return cnt;
+	    }
+	 }
+
+	 
+
+	 
+	 
+	static class Graph
+	  {
+	        int v;
+	        ArrayList<Integer> list[];
+	        Graph(int v)
+	        {
+	            this.v=v;
+	            list=new ArrayList[v+1];
+	            for(int i=1;i<=v;i++)
+	                list[i]=new ArrayList<Integer>();
+	        }
+	        void addEdge(int a, int b)
+	        {
+	            this.list[a].add(b);
+	        }
+	    }
+	
+	
+	
+//	static class GraphMap{
+//		Map<String,ArrayList<String>> graph;
+//		GraphMap() {
+//			// TODO Auto-generated constructor stub
+//			graph=new HashMap<String,ArrayList<String>>();
+//			
+//		}
+//		void addEdge(String a,String b)
+//		{
+//			if(graph.containsKey(a))
+//			this.graph.get(a).add(b);
+//			else {
+//				this.graph.put(a, new ArrayList<>());
+//				this.graph.get(a).add(b);
+//			}
+//		}
+//	}
+//	static void dfsMap(GraphMap g,HashSet<String> vis,String src,int ok)
+//	{
+//		vis.add(src);
+//		
+//		if(g.graph.get(src)!=null)
+//		{
+//			for(String each:g.graph.get(src))
+//			{
+//				if(!vis.contains(each))
+//				{
+//					dfsMap(g, vis, each, ok+1);
+//				}
+//			}
+//		}
+//		
+//		cnt=Math.max(cnt, ok);
+//	}
+	static double sum[];
+	static long cnt;
+//	static void DFS(Graph g, boolean[] visited, int u)
+//		{
+//	        visited[u]=true;
+//	        
+//	        for(int i=0;i<g.list[u].size();i++)
+//	        {
+//	            int v=g.list[u].get(i);
+//	            
+//	            if(!visited[v])
+//	            {
+//	            	cnt1=cnt1*2;
+//	            	DFS(g, visited, v);
+//	            
+//	            }
+//	            
+//	        }
+//	       
+//
+//	  } 
+	
+	
+	  
+	 static class Pair implements Comparable<Pair>
+	    {
+	       int x;
+	       int y;
+	       Pair(int x,int y)
+	        {
+	           this.x=x;
+	           this.y=y;
+	          
+	        }
+		@Override
+		public int compareTo(Pair o) {
+			// TODO Auto-generated method stub
+			return this.x-o.x;
+		}
+	       
+	       
+	       
+	    }
+	   
+	static long sum_array(int a[])
+	 {
+	    int n=a.length;
+	    long sum=0;
+	    for(int i=0;i<n;i++)
+	     sum+=a[i];
+	    return sum;
+	 }
+	static long sum_array(long a[])
+	 {
+	    int n=a.length;
+	    long sum=0;
+	    for(int i=0;i<n;i++)
+	     sum+=a[i];
+	    return sum;
+	 }
+
+	 static void sort(int[] a) 
+	   {
+			ArrayList<Integer> l=new ArrayList<>();
+			for (int i:a) l.add(i);
+			Collections.sort(l);
+			for (int i=0; i<a.length; i++) a[i]=l.get(i);
+		}
+	static void sort(long[] a) 
+	   {
+			ArrayList<Long> l=new ArrayList<>();
+			for (long i:a) l.add(i);
+			Collections.sort(l);
+			for (int i=0; i<a.length; i++) a[i]=l.get(i);
+		}
+
+	static void reverse_array(int a[])
+	 {
+	    int n=a.length;
+	    int i,t; 
+	    for (i = 0; i < n / 2; i++) { 
+	            t = a[i]; 
+	            a[i] = a[n - i - 1]; 
+	            a[n - i - 1] = t; 
+	        } 
+	 }
+	static void reverse_array(long a[])
+	 {
+	    int n=a.length;
+	    int i; long t; 
+	    for (i = 0; i < n / 2; i++) { 
+	            t = a[i]; 
+	            a[i] = a[n - i - 1]; 
+	            a[n - i - 1] = t; 
+	        } 
+	 }
+//	 static long modInverse(long a, long m)
+//		    {
+//		        long g = gcd(a, m);
+//		       
+//		          return   power(a, m - 2, m);
+//		        
+//		    }
+	static long power(long x, long y)
+	 {
+	   long res = 1;
+	   x = x % mod;
+	   if (x == 0)
+	     return 0;
+	   while (y > 0)
+	   {
+	    if ((y & 1) != 0)
+	    res = (res * x) % mod;
+	   
+	    y = y >> 1; // y = y/2
+	    x = (x * x) % mod;
+	   }
+	   return res;
+	 }
+	static int power(int x, int y)
+	{
+		int res = 1;
+		x = x % mod;
+		if (x == 0)
+			return 0;
+		while (y > 0)
+		{
+			if ((y & 1) != 0)
+				res = (res * x) % mod;
+			
+			y = y >> 1; // y = y/2
+	    x = (x * x) % mod;
+		}
+		return res;
+	}
+	static long gcd(long a, long b) 
+	    { 
+			
+	        if (a == 0) 
+	            return b; 
+	         //cnt+=a/b;
+	        return gcd(b%a,a); 
+	    } 
+	static int gcd(int a, int b) 
+	    { 
+	        if (a == 0) 
+	            return b; 
+	          
+	        return gcd(b%a, a); 
+	    } 
+
+	   static class FastReader{
+	 
+	        byte[] buf = new byte[2048];
+	        int index, total;
+	        InputStream in;
+	 
+	        FastReader(InputStream is) {
+	            in = is;
+	        }
+	 
+	        int scan() throws IOException {
+	            if (index >= total) {
+	                index = 0;
+	                total = in.read(buf);
+	                if (total <= 0) {
+	                    return -1;
+	                }
+	            }
+	            return buf[index++];
+	        }
+	 
+	        String next() throws IOException {
+	            int c;
+	            for (c = scan(); c <= 32; c = scan());
+	            StringBuilder sb = new StringBuilder();
+	            for (; c > 32; c = scan()) {
+	                sb.append((char) c);
+	            }
+	            return sb.toString();
+	        }
+	 
+	        int nextInt() throws IOException {
+	            int c, val = 0;
+	            for (c = scan(); c <= 32; c = scan());
+	            boolean neg = c == '-';
+	            if (c == '-' || c == '+') {
+	                c = scan();
+	            }
+	            for (; c >= '0' && c <= '9'; c = scan()) {
+	                val = (val << 3) + (val << 1) + (c & 15);
+	            }
+	            return neg ? -val : val;
+	        }
+	 
+	        long nextLong() throws IOException {
+	            int c;
+	            long val = 0;
+	            for (c = scan(); c <= 32; c = scan());
+	            boolean neg = c == '-';
+	            if (c == '-' || c == '+') {
+	                c = scan();
+	            }
+	            for (; c >= '0' && c <= '9'; c = scan()) {
+	                val = (val << 3) + (val << 1) + (c & 15);
+	            }
+	            return neg ? -val : val;
+	        }
+	    }
+	   
+	    static class Reader 
+	    { 
+	        final private int BUFFER_SIZE = 1 << 16; 
+	        private DataInputStream din; 
+	        private byte[] buffer; 
+	        private int bufferPointer, bytesRead; 
+	  
+	        public Reader() 
+	        { 
+	            din = new DataInputStream(System.in); 
+	            buffer = new byte[BUFFER_SIZE]; 
+	            bufferPointer = bytesRead = 0; 
+	        } 
+	  
+	        public Reader(String file_name) throws IOException 
+	        { 
+	            din = new DataInputStream(new FileInputStream(file_name)); 
+	            buffer = new byte[BUFFER_SIZE]; 
+	            bufferPointer = bytesRead = 0; 
+	        } 
+	  
+	        public String readLine() throws IOException 
+	        { 
+	            byte[] buf = new byte[64]; // line length 
+	            int cnt = 0, c; 
+	            while ((c = read()) != -1) 
+	            { 
+	                if (c == '\n') 
+	                    break; 
+	                buf[cnt++] = (byte) c; 
+	            } 
+	            return new String(buf, 0, cnt); 
+	        } 
+	  
+	        public int nextInt() throws IOException 
+	        { 
+	            int ret = 0; 
+	            byte c = read(); 
+	            while (c <= ' ') 
+	                c = read(); 
+	            boolean neg = (c == '-'); 
+	            if (neg) 
+	                c = read(); 
+	            do
+	            { 
+	                ret = ret * 10 + c - '0'; 
+	            }  while ((c = read()) >= '0' && c <= '9'); 
+	  
+	            if (neg) 
+	                return -ret; 
+	            return ret; 
+	        } 
+	  
+	        public long nextLong() throws IOException 
+	        { 
+	            long ret = 0; 
+	            byte c = read(); 
+	            while (c <= ' ') 
+	                c = read(); 
+	            boolean neg = (c == '-'); 
+	            if (neg) 
+	                c = read(); 
+	            do { 
+	                ret = ret * 10 + c - '0'; 
+	            } 
+	            while ((c = read()) >= '0' && c <= '9'); 
+	            if (neg) 
+	                return -ret; 
+	            return ret; 
+	        } 
+	  
+	        public double nextDouble() throws IOException 
+	        { 
+	            double ret = 0, div = 1; 
+	            byte c = read(); 
+	            while (c <= ' ') 
+	                c = read(); 
+	            boolean neg = (c == '-'); 
+	            if (neg) 
+	                c = read(); 
+	  
+	            do { 
+	                ret = ret * 10 + c - '0'; 
+	            } 
+	            while ((c = read()) >= '0' && c <= '9'); 
+	  
+	            if (c == '.') 
+	            { 
+	                while ((c = read()) >= '0' && c <= '9') 
+	                { 
+	                    ret += (c - '0') / (div *= 10); 
+	                } 
+	            } 
+	  
+	            if (neg) 
+	                return -ret; 
+	            return ret; 
+	        } 
+	  
+	        private void fillBuffer() throws IOException 
+	        { 
+	            bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE); 
+	            if (bytesRead == -1) 
+	                buffer[0] = -1; 
+	        } 
+	  
+	        private byte read() throws IOException 
+	        { 
+	            if (bufferPointer == bytesRead) 
+	                fillBuffer(); 
+	            return buffer[bufferPointer++]; 
+	        } 
+	  
+	        public void close() throws IOException 
+	        { 
+	            if (din == null) 
+	                return; 
+	            din.close(); 
+	        } 
+	    }
+	  static  PrintWriter out=new PrintWriter(System.out);
+	  static int int_max=Integer.MAX_VALUE;
+	  static int int_min=Integer.MIN_VALUE;
+	  static long long_max=Long.MAX_VALUE;
+	  static long long_min=Long.MIN_VALUE;
+
+}
+
+
+
+
+","//package Codeforces;
+import java.io.*;
+import java.util.*;
+
+
+public class CP
+{
+	static Scanner sc=new Scanner(System.in);
+	public static void main(String[] args) throws IOException, CloneNotSupportedException
+	{
+		int t=sc.nextInt();
+		while(t-->0)
+		{
+			int n=sc.nextInt();
+			int k[]=new int[n];
+			int h[]=new int[n];
+			for(int i=0;i<n;i++)
+				k[i]=sc.nextInt();
+			for(int i=0;i<n;i++)
+				h[i]=sc.nextInt();
+			ArrayList<Pair> interval=new ArrayList<Pair>();
+			ArrayList<Pair> act=new ArrayList<Pair>();
+			for(int i=0;i<n;i++)
+				interval.add(new Pair(k[i]-h[i]+1,k[i]));
+			Collections.sort(interval);
+//			out.println(interval);
+			act.add(interval.get(0).clone());
+			for(int i=1;i<n;i++)
+			{
+				Pair p=act.get(act.size()-1);
+				if(p.y<interval.get(i).x)
+					act.add(interval.get(i).clone());
+				else
+					p.y=Math.max(p.y, interval.get(i).y);
+			}
+//			out.println(act);
+			long mana=0;
+			for(Pair p: act)
+			{
+				long x=p.y-p.x+1;
+				mana+=(x*(x+1))/2;
+			}
+			System.out.println(mana);		
+ 		}
+	}
+	static class Pair implements Cloneable, Comparable<Pair>
+	{
+		int x,y;
+		Pair(int a,int b)
+		{
+			this.x=a;
+			this.y=b;
+		}
+//		@Override
+//		public boolean equals(Object obj) 
+//		{
+//			if(obj instanceof  Pair)
+//			{
+//				Pair p=(Pair)obj;
+//				return p.x==this.x && p.y==this.y;
+//			}
+//			return false;
+//		}
+//		@Override
+//		public int hashCode() 
+//		{
+//			return Math.abs(x)+500*Math.abs(y);
+//		}
+//		@Override
+//		public String toString() 
+//		{
+//			return ""(""+x+"" ""+y+"")"";
+//		}
+		@Override
+		protected Pair clone() throws CloneNotSupportedException {
+			return new Pair(this.x,this.y);
+		}
+		@Override
+		public int compareTo(Pair a) 
+		{
+			long t=(this.x-a.x);
+			if(t!=0)
+				return t>0?1:-1;
+			else
+				return (int)(this.y-a.y);
+		}
+//		public void swap()
+//		{
+//			this.y=this.y+this.x;
+//			this.x=this.y-this.x;
+//			this.y=this.y-this.x;			
+//		}
+	}
+}",1
+2a35cd81,97a7fab5,"import java.util.*;
+import java.io.*;
+public class Transform_the_experssion  {
+	static Scanner sc=new Scanner(System.in);
+	static PrintWriter pw=new PrintWriter(System.out);
+	static ArrayList<Integer> []arr;
+	
+	public static void main(String[] args) throws IOException, InterruptedException {
+       int t=sc.nextInt();
+       while(t-->0) {
+           int n=sc.nextInt();
+           String [] strings=new String [n];
+           int [][]arr=new int [5][n];
+           int [] total=new int [5];
+           for(int i=0;i<n;i++)
+        	   strings[i]=sc.next();
+           for(int i=0;i<5;i++) {
+        	   char x=(char)('a'+i);
+        	   for(int j=0;j<n;j++) {
+        		   int sum=0;
+        		   int end=strings[j].length();
+        		   for(int k=0;k<end;k++) {
+        			   if(strings[j].charAt(k)==x) {
+        				   sum++;
+        			   }
+        		   }
+        		   arr[i][j]=sum-(end-sum);
+        		   total[i]+=sum-(end-sum);
+        	   }
+           }
+           boolean f=false;
+           for(int i=0;i<5 && !f;i++) {
+        	   if(total[i]>0) {
+        		   pw.println(n);
+        		   f=true;
+        	   }
+           }
+           //pw.println(Arrays.toString(total));
+           if(!f) {
+        	   int [] MaxS=new int [5];
+        	   for(int i=0;i<5;i++) {
+        			Arrays.sort(arr[i]);
+        			if(arr[i][n-1]<=0)   {
+        				 MaxS[i]=0; 
+        			}
+        			else {
+						int sum=arr[i][n-1],countWords=1;
+						for(int j=n-2;j>-1 && sum+arr[i][j]>0;j--) {
+							sum+=arr[i][j];
+							countWords++;
+						}
+						 MaxS[i]=countWords;
+					}
+        	   }
+        	   int ans=0;
+        	   //pw.println(Arrays.toString(MaxS));
+               for(int i=0;i<5;i++)
+            	   ans=Math.max(ans, MaxS[i]);
+               pw.println(ans);
+           }
+           
+    }
+    
+    
+    pw.flush();
+	}
+	/*public class UnionFind {                                              
+		int[] p, rank, setSize;
+		int numSets;
+
+		public UnionFind(int N) 
+		{
+			p = new int[numSets = N];
+			rank = new int[N];
+			setSize = new int[N];
+			for (int i = 0; i < N; i++) {  p[i] = i; setSize[i] = 1; }
+		}
+
+		public int findSet(int i) { return p[i] == i ? i : (p[i] = findSet(p[i])); }
+
+		public boolean isSameSet(int i, int j) { return findSet(i) == findSet(j); }
+
+		public void unionSet(int i, int j) 
+		{ 
+			if (isSameSet(i, j)) 
+				return;
+			numSets--; 
+			int x = findSet(i), y = findSet(j);
+			if(rank[x] > rank[y]) { p[y] = x; setSize[x] += setSize[y]; }
+			else
+			{	p[x] = y; setSize[y] += setSize[x];
+				if(rank[x] == rank[y]) rank[y]++; 
+			} 
+		}
+
+		public int numDisjointSets() { return numSets; }
+
+		public int sizeOfSet(int i) { return setSize[findSet(i)]; }
+	}
+	static class pair implements Comparai)ble<pair> {
+		long x;
+		long y;
+ 
+		public pair(long x, long y) {
+			this.x = x;
+			this.y = y;
+		}
+ 
+		public String toString() {
+			return x + "" "" + y;
+		}
+ 
+		public boolean equals(Object o) {
+			if (o instanceof pair) {
+				pair p = (pair) o;
+				return p.x == x && p.y == y;
+			}
+			return false;
+		}
+ 
+		public int hashCode() {
+			return new Double(x).hashCode() * 31 + new Double(y).hashCode();
+		}
+ 
+		public int compareTo(pair other) {
+			if (this.x == other.x) {
+				return Long.compare(this.y, other.y);
+			}
+			return Long.compare(this.x, other.x);
+		}
+	}*/
+	static class Scanner {
+		StringTokenizer st;
+		BufferedReader br;
+ 
+		public Scanner(InputStream s) {
+			br = new BufferedReader(new InputStreamReader(s));
+		}
+ 
+		public Scanner(FileReader r) {
+			br = new BufferedReader(r);
+		}
+		public String readAllLines(BufferedReader reader) throws IOException {
+		    StringBuilder content = new StringBuilder();
+		    String line;
+		    
+		    while ((line = reader.readLine()) != null) {
+		        content.append(line);
+		        content.append(System.lineSeparator());
+		    }
+
+		    return content.toString();
+		}
+		public String next() throws IOException {
+			while (st == null || !st.hasMoreTokens())
+				st = new StringTokenizer(br.readLine());
+			return st.nextToken();
+		}
+ 
+		public int nextInt() throws IOException {
+			return Integer.parseInt(next());
+		}
+ 
+		public long nextLong() throws IOException {
+			return Long.parseLong(next());
+		}
+ 
+		public String nextLine() throws IOException {
+			return br.readLine();
+		}
+ 
+		public double nextDouble() throws IOException {
+			String x = next();
+			StringBuilder sb = new StringBuilder(""0"");
+			double res = 0, f = 1;
+			boolean dec = false, neg = false;
+			int start = 0;
+			if (x.charAt(0) == '-') {
+				neg = true;
+				start++;
+			}
+			for (int i = start; i < x.length(); i++)
+				if (x.charAt(i) == '.') {
+					res = Long.parseLong(sb.toString());
+					sb = new StringBuilder(""0"");
+					dec = true;
+				} else {
+					sb.append(x.charAt(i));
+					if (dec)
+						f *= 10;
+				}
+			res += Long.parseLong(sb.toString()) / f;
+			return res * (neg ? -1 : 1);
+		}
+ 
+		public long[] nextlongArray(int n) throws IOException {
+			long[] a = new long[n];
+			for (int i = 0; i < n; i++)
+				a[i] = nextLong();
+			return a;
+		}
+ 
+		public Long[] nextLongArray(int n) throws IOException {
+			Long[] a = new Long[n];
+			for (int i = 0; i < n; i++)
+				a[i] = nextLong();
+			return a;
+		}
+ 
+		public int[] nextIntArray(int n) throws IOException {
+			int[] a = new int[n];
+			for (int i = 0; i < n; i++)
+				a[i] = nextInt();
+			return a;
+		}
+ 
+		public Integer[] nextIntegerArray(int n) throws IOException {
+			Integer[] a = new Integer[n];
+			for (int i = 0; i < n; i++)
+				a[i] = nextInt();
+			return a;
+		}
+ 
+		public boolean ready() throws IOException {
+			return br.ready();
+		}
+ 
+	}
+ 
+}","import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.OutputStream;
+import java.io.PrintWriter;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Stack;
+import java.util.StringTokenizer;
+import java.util.Vector;
+
+
+public class Main{
+
+	static InputStream inputStream = System.in;
+	static OutputStream outputStream = System.out;
+	static InputReader in = new InputReader(inputStream);
+	static PrintWriter out = new PrintWriter(outputStream);
+
+	public static void main(String[] args) {
+
+		int t = in.nextInt();
+
+		while (t-- > 0) {
+			int n = in.nextInt();
+			String[] v = new String[n];
+
+			for (int i = 0; i < n; i++) {
+				v[i] = in.next();
+			}
+
+			ArrayList<ArrayList<Integer>> v1 = new ArrayList<>();
+
+			for (int i = 0; i < n; i++) {
+				ArrayList<Integer> list = new ArrayList<>();
+
+				for (int j = 0; j < 5; j++) {
+
+					list.add(0);
+				}
+				v1.add(list);
+			}
+
+			for (int i = 0; i < n; i++) {
+				String s = v[i];
+				for (int j = 0; j < s.length(); j++) {
+					int val = v1.get(i).get(s.charAt(j) - 'a');
+					val++;
+					v1.get(i).set(s.charAt(j) - 'a', val);
+
+				}
+
+			}
+			int ret = 0;
+			for (int i = 0; i < 5; i++) {
+				ArrayList<Integer> v3 = new ArrayList<>();
+
+				for (int j = 0; j < n; j++) {
+					String s1 = v[j];
+					int n2 = s1.length();
+					int cnt = v1.get(j).get(i);
+					int diff = cnt - (n2 - cnt);
+					v3.add(diff);
+				}
+				Collections.sort(v3);
+				Collections.reverse(v3);
+
+				int till = 0;
+				for (int k = 0; k < n; k++) {
+					till += v3.get(k);
+					if (till > 0) {
+						ret = Math.max(ret, k + 1);
+					}
+				}
+
+			}
+			out.println(ret);
+
+		}
+
+		out.close();
+	}
+
+	static class InputReader {
+		public BufferedReader reader;
+		public StringTokenizer tokenizer;
+
+		public InputReader(InputStream stream) {
+			reader = new BufferedReader(new InputStreamReader(stream), 32768);
+			tokenizer = null;
+		}
+
+		public String next() {
+			while (tokenizer == null || !tokenizer.hasMoreTokens()) {
+				try {
+					tokenizer = new StringTokenizer(reader.readLine());
+				} catch (IOException e) {
+					throw new RuntimeException(e);
+				}
+			}
+			return tokenizer.nextToken();
+		}
+
+		public long nextLong() {
+			return Long.parseLong(next());
+		}
+
+		public int nextInt() {
+			return Integer.parseInt(next());
+		}
+
+		public String nextLine() throws IOException {
+			return reader.readLine().trim();
+		}
+	}
+
+}
+",0
+11d91f31,4323e2bd,"import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.StringTokenizer;
+import java.util.*;
+
+public class ArmChairs {
+    static final Random random = new Random();
+
+    static class FastReader {
+        BufferedReader br;
+        StringTokenizer st;
+
+        public FastReader() {
+            br = new BufferedReader(new
+                    InputStreamReader(System.in));
+        }
+
+        String next() {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+
+        String nextLine() {
+            String str = """";
+            try {
+                str = br.readLine();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+        }
+
+        int[] readArray(int n, int size) {
+            int[] a = new int[size];
+            for (int i = 0; i < n; i++) {
+                a[i] = this.nextInt();
+            }
+
+            return a;
+        }
+
+        long[] readLongArray(int n, int size) {
+            long[] a = new long[size];
+            for (int i = 0; i < n; i++) {
+                a[i] = this.nextLong();
+            }
+            return a;
+        }
+    }
+
+    static void ruffleSort(long[] a) {
+        int n = a.length;//shuffle, then sort
+        for (int i = 0; i < n; i++) {
+            int oi = random.nextInt(n);
+            long temp = a[oi];
+            a[oi] = a[i];
+            a[i] = temp;
+        }
+        Arrays.sort(a);
+    }
+
+    static void ruffleSort(int[] a) {
+        int n = a.length;//shuffle, then sort
+        for (int i = 0; i < n; i++) {
+            int oi = random.nextInt(n), temp = a[oi];
+            a[oi] = a[i];
+            a[i] = temp;
+        }
+        Arrays.sort(a);
+    }
+
+    public static void main(String[] args) {
+        FastReader fs = new FastReader();
+        int t = 1;
+
+        for (int z = 0; z < t; z++) {
+            int n = fs.nextInt();
+            List<Integer> empty = new ArrayList<>();
+            List<Integer> chairs = new ArrayList<>();
+            for(int i = 0; i < n; i++) {
+                int status = fs.nextInt();
+                if(status == 1) chairs.add(i+1);
+                else empty.add(i+1);
+            }
+            int[][] dp = new int[empty.size() + 1][chairs.size() + 1];
+            dp[0][0] = 0;
+            for(int i = 1; i <= chairs.size(); i++) dp[0][i] = (int)3e+8;
+            for(int i = 1; i <= empty.size(); i++) {
+                for(int j = 1; j <= chairs.size(); j++) {
+                    // Shift jth person to ith chair
+                    dp[i][j] = dp[i-1][j-1] + Math.abs(empty.get(i-1) - chairs.get(j-1));
+                    dp[i][j] = Math.min(dp[i][j], dp[i-1][j]);
+                }
+                //System.out.println(i + "" "" + Arrays.toString(dp[i]));
+            }
+            //System.out.println(empty.size() + "" "" + chairs.size());
+            System.out.println(dp[empty.size()][chairs.size()]);
+        }
+    }
+}","import java.io.*;
+import java.util.*;
+import java.math.*;
+import java.math.BigInteger; 
+//import javafx.util.*; 
+public final class B
+{    
+	static StringBuilder ans=new StringBuilder();
+	static FastReader in=new FastReader();
+	static ArrayList<ArrayList<Integer>> g;
+	static long mod=(long)(1e9+7);
+	static int D1[],D2[],par[];
+	static boolean set[];
+	static int value[];
+	static long INF=Long.MAX_VALUE;
+	static int dp[][];
+	static int N,M;
+	static int A[][],B[][];
+	static int s=1;
+	public static void main(String args[])throws IOException
+	{  					
+		int N=i();
+		int A[]=input(N);
+		ArrayList<Integer> one=new ArrayList<Integer>();
+		ArrayList<Integer> zero=new ArrayList<Integer>();
+		for(int i=1; i<=N; i++)
+		{
+			if(A[i-1]==1)one.add(i);
+			else zero.add(i);
+		}
+		int sum[][]=new int[N+5][N+5];
+		for(int i=1; i<=one.size(); i++)
+		{
+			for(int j=1; j<=zero.size(); j++)
+			{
+				sum[i][j]=Math.abs(one.get(i-1)-zero.get(j-1));
+			}
+			//print(sum[i]);
+		}
+		dp=new int[N+5][N+5];
+		//for(int d[]:dp)Arrays.fill(d, Integer.MAX_VALUE);
+		Arrays.fill(dp[0], 0);
+		for(int i=1; i<=one.size(); i++)
+		{
+			for(int j=i; j<=zero.size(); j++)
+			{
+				if(i==j)
+				{
+					dp[i][j]=dp[i-1][j-1]+sum[i][j];
+				}
+				else
+				{
+					dp[i][j]=Math.min(dp[i][j-1], dp[i-1][j-1]+sum[i][j]);
+				}
+			}
+		}
+		System.out.println(dp[one.size()][zero.size()]);
+//		f(0,0,one,zero,0);
+		//for(int d[]:dp)print(d);
+		
+	}	
+	static int f(int i,int j,ArrayList<Integer> one,ArrayList<Integer> zero, int s)
+	{
+		if(i==one.size())return s;
+		if(j==zero.size())return Integer.MAX_VALUE;
+		int a=one.get(i),b=zero.get(j);
+        if(dp[a][b]==-1)
+        {
+        	int min=Integer.MAX_VALUE;
+        	for(int t=j; t<zero.size(); t++)
+    		{
+                 min=Math.min(min, f(i+1,t+1,one,zero,s+Math.abs(b-a))); 
+    		}  
+        	dp[a][b]=min;
+        }	
+        a=one.get(i);b=zero.get(j);
+		return dp[a][b];
+	}
+	static boolean isSorted(int A[])
+	{
+		int N=A.length;
+		for(int i=0; i<N-1; i++)
+		{
+			if(A[i]>A[i+1])return false;
+		}
+
+		return true;		
+	}
+	static int f1(int x,ArrayList<Integer> A)
+	{
+		int l=-1,r=A.size();
+		while(r-l>1)
+		{
+			int m=(l+r)/2;
+			int a=A.get(m);
+			if(a<x)l=m;
+			else r=m;
+		}		
+		return l;
+	}
+
+
+	static int ask(int t,int i,int j,int x)
+	{
+		System.out.println(""? ""+t+"" ""+i+"" ""+j+"" ""+x);
+		return i();
+	}
+
+	static int ask(int a)
+	{
+		System.out.println(""? 1 ""+a);
+		return i();
+	}
+	static int f(int st,int end,int d)
+	{
+		if(st>end)return 0;
+		int a=0,b=0,c=0;
+		if(d>1)a=f(st+d-1,end,d-1);
+		b=f(st+d,end,d);
+		c=f(st+d+1,end,d+1);
+		return value[st]+max(a,b,c);
+	}
+	static int max(int a,int b,int c)
+	{
+		return Math.max(a, Math.max(c, b));
+	}
+	static int value(char X[],char Y[])
+	{
+		int c=0;
+		for(int i=0; i<7; i++)
+		{
+			if(Y[i]=='1' && X[i]=='0')return -1;
+			if(X[i]=='1' && Y[i]=='0')c++;
+		}
+		return c;
+	}
+	static boolean isValid(int i,int j)
+	{
+		if(i<0 || i>=N)return false;
+		if(j<0 || j>=M)return false;
+		return true;
+	}
+
+	static long fact(long N)
+	{
+		long num=1L;
+		while(N>=1)
+		{
+			num=((num%mod)*(N%mod))%mod;
+			N--;
+		}
+		return num;
+	}
+	static boolean reverse(long A[],int l,int r)
+	{
+		while(l<r)
+		{
+			long t=A[l];
+			A[l]=A[r];
+			A[r]=t;
+			l++;
+			r--;
+		}
+		if(isSorted(A))return true;
+		else return false;
+	}
+	static boolean isSorted(long A[])
+	{
+		for(int i=1; i<A.length; i++)if(A[i]<A[i-1])return false;
+		return true;
+	}
+	static boolean isPalindrome(char X[],int l,int r)
+	{
+		while(l<r)
+		{
+			if(X[l]!=X[r])return false;
+			l++; r--;
+		}
+		return true;
+	}
+
+	static long min(long a,long b,long c)
+	{
+		return Math.min(a, Math.min(c, b));
+	}
+
+	static void print(int a)
+	{
+		System.out.println(""! ""+a);
+	}
+	static int ask(int a,int b)
+	{
+		System.out.println(""? ""+a+"" ""+b);
+		return i();
+	}
+	static int find(int a)
+	{
+		if(par[a]<0)return a;
+		return par[a]=find(par[a]);
+	}
+	static void union(int a,int b)
+	{
+		a=find(a);
+		b=find(b);
+		if(a!=b)
+		{
+			par[a]+=par[b]; //transfers the size
+			par[b]=a;       //changes the parent
+		}
+	}
+	static void swap(char A[],int a,int b)
+	{
+		char ch=A[a];
+		A[a]=A[b];
+		A[b]=ch;
+	}
+
+	static void sort(long[] a) //check for long
+	{
+		ArrayList<Long> l=new ArrayList<>();
+		for (long i:a) l.add(i);
+		Collections.sort(l);
+		for (int i=0; i<a.length; i++) a[i]=l.get(i);
+	}
+	static void setGraph(int N)
+	{
+		g=new ArrayList<ArrayList<Integer>>();
+		for(int i=0; i<=N; i++)
+		{
+			g.add(new ArrayList<Integer>());
+		}
+	}
+
+	static  long pow(long a,long b)
+	{
+		long mod=1000000007;
+		long pow=1;
+		long x=a;
+		while(b!=0)
+		{
+			if((b&1)!=0)pow=(pow*x)%mod;
+			x=(x*x)%mod;
+			b/=2;
+		}
+		return pow;
+	}
+	static long toggleBits(long x)//one's complement || Toggle bits
+	{
+		int n=(int)(Math.floor(Math.log(x)/Math.log(2)))+1;
+
+		return ((1<<n)-1)^x;
+	}
+	static int countBits(long a)
+	{
+		return (int)(Math.log(a)/Math.log(2)+1);
+	}
+	static void sort(int[] a) {
+		ArrayList<Integer> l=new ArrayList<>();
+		for (int i:a) l.add(i);
+		Collections.sort(l);
+		for (int i=0; i<a.length; i++) a[i]=l.get(i);
+	}
+	static boolean isPrime(long N)
+	{
+		if (N<=1)  return false; 
+		if (N<=3)  return true; 
+		if (N%2 == 0 || N%3 == 0) return false; 
+		for (int i=5; i*i<=N; i=i+6) 
+			if (N%i == 0 || N%(i+2) == 0) 
+				return false; 
+		return true; 
+	}
+	static long GCD(long a,long b) 
+	{
+		if(b==0)
+		{
+			return a;
+		}
+		else return GCD(b,a%b );
+	}
+
+	//Debugging Functions Starts
+
+	static void print(char A[])
+	{
+		for(char c:A)System.out.print(c+"" "");
+		System.out.println();
+	}
+	static void print(boolean A[])
+	{
+		for(boolean c:A)System.out.print(c+"" "");
+		System.out.println();
+	}
+	static void print(int A[])
+	{
+		for(int a:A)System.out.print(a+"" "");
+		System.out.println();	
+	}
+	static void print(long A[])
+	{
+		for(long i:A)System.out.print(i+ "" "");
+		System.out.println();
+
+	}
+	static void print(ArrayList<Integer> A)
+	{
+		for(int a:A)System.out.print(a+"" "");
+		System.out.println();
+	}
+
+	//Debugging Functions END
+	//----------------------
+	//IO FUNCTIONS STARTS
+	static HashMap<Integer,Integer> Hash(int A[])
+	{
+		HashMap<Integer,Integer> mp=new HashMap<>();
+		for(int a:A)
+		{
+			int f=mp.getOrDefault(a,0)+1;
+			mp.put(a, f);
+		}
+		return mp;
+	}
+	static int i()
+	{
+		return in.nextInt();
+	}
+
+	static long l()
+	{
+		return in.nextLong();
+	}
+
+	static int[] input(int N){
+		int A[]=new int[N];
+		for(int i=0; i<N; i++)
+		{
+			A[i]=in.nextInt();
+		}
+		return A;
+	}
+
+	static long[] inputLong(int N)     {
+		long A[]=new long[N];
+		for(int i=0; i<A.length; i++)A[i]=in.nextLong();
+		return A;
+	}
+
+	//IO FUNCTIONS END
+
+}
+
+class node implements Comparable<node>
+{
+	int l,r,index;
+	node(int l,int r,int index)
+	{
+		this.l=l;
+		this.r=r;
+		this.index=index;
+	}
+	public int compareTo(node X)
+	{
+		return X.r-this.r;
+	}
+}
+class node1 implements Comparable<node1>
+{
+	int l,r,index;
+	node1(int l,int r,int index)
+	{
+		this.l=l;
+		this.r=r;
+		this.index=index;
+	}
+	public int compareTo(node1 X)
+	{
+		if(this.l==X.l)
+			return X.r-this.r;
+		return this.l-X.l;
+	}
+}
+//Code For FastReader
+//Code For FastReader
+//Code For FastReader
+//Code For FastReader
+class FastReader
+{
+	BufferedReader br;
+	StringTokenizer st;
+	public FastReader()
+	{
+		br=new BufferedReader(new InputStreamReader(System.in));
+	}
+
+	String next()
+	{
+		while(st==null || !st.hasMoreElements())
+		{
+			try
+			{
+				st=new StringTokenizer(br.readLine());
+			}
+			catch(IOException e)
+			{
+				e.printStackTrace();
+			}
+		}
+		return st.nextToken();
+	}
+
+	int nextInt()
+	{
+		return Integer.parseInt(next());
+	}
+
+	long nextLong()
+	{
+		return Long.parseLong(next());
+	}
+	//gey
+	double nextDouble()
+	{
+		return Double.parseDouble(next());
+	}
+
+	String nextLine()
+	{
+		String str="""";
+		try
+		{
+			str=br.readLine();
+		}
+		catch (IOException e)
+		{
+			e.printStackTrace();
+		}
+		return str;
+	}
+
+}",0
+7c220622,a06631ff,"import java.io.*;
+import java.util.*;
+
+public class D {
+    public static void main(String[] args) throws IOException {
+        in.init();
+        int n = in.readInt();
+        for (int i = 0; i < n; i++) {
+            sol();
+        }
+        in.dinit();
+    }
+
+    private static void sol() throws IOException {
+        // ArrayList<Integer> arr = new ArrayList<>();
+        int n = in.readInt();
+
+        int arr[] = in.arr(n);
+        int three2n = 1;
+        for (int i = 0; i < arr.length; i++) {
+            three2n *= 3;
+        }
+        for (int i = 1; i < three2n; i++) {
+            int sum = i;
+            int actualsum = 0;
+            for (int j = 0; j < arr.length; j++) {
+                int change = sum % 3;
+                change = (change == 2) ? -1 : change;
+                actualsum += change * arr[j];
+                sum = sum / 3;
+            }
+            if (actualsum == 0) {
+                System.out.println(""YES"");
+                return;
+            }
+
+        }
+        System.out.println(""NO"");
+
+    }
+
+}
+
+
+class in {
+
+    static BufferedReader br;
+    static PrintWriter out;
+    static StringTokenizer st;
+
+    public static void init() throws IOException {
+         br = new BufferedReader(new InputStreamReader(System.in));
+         out = new PrintWriter(new OutputStreamWriter(System.out));
+       // br = new BufferedReader(new FileReader(""in.txt""));
+        //out = new PrintWriter(new FileWriter(""out.txt""));
+
+        // out.close();
+    }
+
+    static int[] arr(int n) throws IOException {
+        int arr[] = new int[n];
+        for (int i = 0; i < n; i++) {
+            arr[i] = in.readInt();
+
+        }
+        return arr;
+
+    }
+
+    public static void dinit() throws IOException {
+        br.close();
+
+        out.close();
+    }
+
+    static String next() throws IOException {
+        while (st == null || !st.hasMoreTokens())
+            st = new StringTokenizer(br.readLine().trim());
+        return st.nextToken();
+    }
+
+    static long readLong() throws IOException {
+        return Long.parseLong(next());
+    }
+
+    static int readInt() throws IOException {
+        return Integer.parseInt(next());
+    }
+
+    static double readDouble() throws IOException {
+        return Double.parseDouble(next());
+    }
+
+    static char readCharacter() throws IOException {
+        return next().charAt(0);
+    }
+
+    static String readLine() throws IOException {
+        return br.readLine().trim();
+    }
+}
+","import java.io.*;
+import java.util.*;
+
+public class Main {
+	static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+	static StringTokenizer st;
+	static PrintWriter pr = new PrintWriter(new OutputStreamWriter(System.out));
+	static String readLine() throws IOException {
+		return br.readLine();
+	}
+	static String next() throws IOException {
+		while (st == null || !st.hasMoreTokens())
+			st = new StringTokenizer(readLine());
+		return st.nextToken();
+	}
+	static int readInt() throws IOException {
+		return Integer.parseInt(next());
+	}
+	static long readLong() throws IOException {
+		return Long.parseLong(next());
+	}
+	static double readDouble() throws IOException {
+		return Double.parseDouble(next());
+	}
+	static char readChar() throws IOException {
+		return next().charAt(0);
+	}
+	static class Pair implements Comparable<Pair> {
+		int f, s;
+		Pair(int f, int s) {
+			this.f = f; this.s = s;
+		}
+		public int compareTo(Pair other) {
+			if (this.f != other.f) return this.f - other.f;
+			return this.s - other.s;
+		}
+	}
+	static void solve() throws IOException {
+		int n = readInt(), a[] = new int[n];
+		for (int i = 0; i < n; ++i) a[i] = readInt();
+		for (int i = 0; i < n; ++i) {
+			List<Integer> b = new ArrayList();
+			for (int j = 0; j < n; ++j)
+				if (j != i) b.add(a[j]);
+			int s = (int)Math.pow(3, n - 1);
+			for (int mm = 0; mm < s; ++mm) {
+				int sum = 0;
+				for (int m = mm, j = 0; m > 0; m /= 3, ++j) {
+					if (m%3 == 1) sum += b.get(j);
+					else if (m%3 == 2) sum -= b.get(j);
+				}
+				if (sum == a[i]) {
+					pr.println(""YES"");
+					return;
+				}
+			}
+		}
+		pr.println(""NO"");
+	}
+	public static void main(String[] args) throws IOException {
+		//solve();
+		for (int t = readInt(); t > 0; --t) solve();
+		pr.close();
+	}
+}
+",0
+cc669e02,d88fa51c,"
+
+
+import java.util.*;
+public class Codeforces {
+
+
+	// CHECK CONSTRAINTS ALWAYS EDGE CASE MISSED 
+	
+static int mod = 1000000007;	
+
+
+
+
+public static void main(String[] args) {
+     Scanner sc = new Scanner(System.in);
+        while(sc.hasNext()) {
+   int t   =  sc.nextInt();
+   while(t-->0) {
+	  	 
+	int n =  sc.nextInt();
+	long k = sc.nextLong();
+	long a[] = new long[n+1];
+	for(int i = 1 ; i<=n;i++) {
+		a[i] = sc.nextLong();
+	}
+	a[0] = -1;
+	Arrays.sort(a);
+	
+	long sum = 0;
+	for(int i = 1 ; i<=n;i++) {
+		sum+=a[i];
+	}
+	
+	if(sum<=k) {
+		System.out.println(0);
+	}
+	else if(sum == k+1) {
+		System.out.println(1);
+	}
+	else {
+		long ans = sum-k;
+		
+		long diff = sum - k;
+	         sum = 0;
+	  for(int i = n ; i>1 ; i--) {
+		long x = 0;
+		  sum+=a[i];
+		  if(sum - (n-i+1)*a[1] >= diff) {
+			  x = 0;
+		  }
+		  else {
+			  x = (long) Math.max(Math.ceil((double)(diff - sum + ((n-i+1)*a[1]))/(n-i+2)) , 0);
+	      
+		  }
+		
+		  ans = Math.min(ans, x +n-i+1);
+		  
+	  }
+	  System.out.println(ans);
+	         
+	         
+	}
+	
+	
+	
+	
+
+		
+	 
+	   
+	   
+	   
+	   
+	   
+	   
+	   
+   }
+     }
+    }
+    }
+
+        
+
+
+
+
+		
+
+
+        
+
+
+
+
+		","import java.util.*;
+import java.io.*;
+import java.math.BigInteger;
+ 
+public class code{
+ 
+    public static int GCD(int a, int b)
+    {
+      if (b == 0)
+        return a;
+      return GCD(b, a % b);
+    }
+    
+    
+    //@SuppressWarnings(""unchecked"")
+    public static void main(String[] arg) throws IOException{
+        //Reader in=new Reader();
+        
+        PrintWriter out = new PrintWriter(System.out);
+        Scanner in = new Scanner(System.in);
+        
+        int t=in.nextInt();
+        
+        while(t-- > 0){
+          int n=in.nextInt();
+          long k=in.nextLong();
+
+          PriorityQueue<Long> pq=new PriorityQueue<Long>();
+          long[] sum=new long[n+1];
+
+          for(int i=0;i<n;i++){
+            long a=in.nextLong();
+            pq.offer(a);
+            //sum[i+1]=arr[i]+sum[i];
+          }
+
+          
+          for(int i=1;i<=n;i++){
+            sum[i]=pq.poll()+sum[i-1];
+          }
+
+          long min=(long)1e18;
+          for(int i=0;i<n;i++){
+            long x=sum[1]-floor(k-sum[n-i]+sum[1],(long)i+1);
+            min=Math.min(min,(long)i+Math.max(0L,x));
+          }
+
+          out.println(min);
+        }
+ 
+        out.flush();
+    }
+
+    public static long floor(long a,long b){
+      long z=a/b;
+      if(b*z>a) z--;
+      return z;
+    }
+ 
+}
+
+",0
+c9159d9c,d3a96420,"import java.util.*;
+
+public class SolutionB {
+
+    public static long gcd(long a, long b){
+        if(b==0){
+            return a;
+        }
+        return gcd(b, a%b);
+    }
+
+    public static long gcdSum(long b){
+        long a = 0;
+
+        long temp = b;
+        while(temp!=0){
+            a = a + temp%10;
+            temp = temp/10;
+        }
+        return gcd(a,b);
+
+    }
+
+    public static class Pair{
+        Long a;
+        Long b;
+
+        public Pair(Long a, Long b) {
+            this.a = a;
+            this.b = b;
+        }
+    }
+
+    public static long factorial (long n){
+        if(n==0)
+            return 1;
+        else if(n==1)
+            return n;
+
+        return n * factorial(n-1);
+    }
+
+    public static long lcm (long n){
+        if(n<3)
+            return n;
+        return lcmForBig(n,n-1);
+    }
+
+    private static long lcmForBig(long n, long l) {
+        if(l==1)
+            return n;
+        n = (n * l) / gcd(n, l);
+        return lcmForBig(n, l-1);
+
+    }
+
+
+    public static void main(String[] args){
+        Scanner s = new Scanner(System.in);
+        
+        int t = s.nextInt();
+
+        for(int i =0;i<t;i++) {
+            int n = s.nextInt();
+            int arr [] = new int[n];
+            ArrayList<Integer> blue = new ArrayList<>();
+            ArrayList<Integer> red = new ArrayList<>();
+
+            for(int j=0;j<n;j++){
+                int num = s.nextInt();
+                arr[j]=num;
+            }
+            String color = s.next();
+
+            for(int j=0;j<n;j++){
+                if(color.charAt(j)=='B'){
+                    blue.add(arr[j]);
+                }
+                else{
+                    red.add(arr[j]);
+                }
+            }
+            Collections.sort(blue);
+            String ans = ""YES"";
+            int counter = 0;
+
+            for(int j=0;j<blue.size();j++){
+                int current = blue.get(j);
+                if (current<1){
+                    ans=""NO"";
+                    break;
+                }
+                if(current>counter){
+                    counter++;
+                }
+                else{
+                    ans=""NO"";
+                    break;
+                }
+
+            }
+
+            if(ans==""NO""){
+                System.out.println(ans);
+            }
+            else{
+                int tempCounter = n+1;
+                Collections.sort(red);
+                for(int j=red.size()-1;j>=0;j--){
+                    int  current  = red.get(j);
+                    if(current>=tempCounter){
+                        ans=""NO"";
+                        break;
+                    }
+                    else{
+                        tempCounter--;
+                    }
+                }
+                if(tempCounter-counter!=1)
+                    System.out.println(""NO"");
+                else
+                    System.out.println(ans);
+            }
+
+        }
+
+        return;
+    }
+}
+","import java.util.*;
+
+public class Main {
+  public static void main(String[] args) {
+    Scanner sc= new Scanner(System.in);
+    int t=sc.nextInt();
+    while(t-->0){
+      int n=sc.nextInt();
+      int[] a=new int[n];
+      for(int i=0;i<n;i++)a[i]=sc.nextInt();
+      String x=sc.next();
+      Vector<Integer> R=new Vector<>();
+      Vector<Integer> B=new Vector<>();
+      for(int i=0;i<n;i++){
+        if(x.charAt(i)=='B') R.add(a[i]);
+        else B.add(a[i]);
+      }
+      Collections.sort(R);
+      Collections.sort(B);
+      boolean yes=true;
+      for(int i=0;i<R.size();i++){
+        if(R.get(i)-i<1){System.out.println(""NO"");yes=false;break;}
+      }
+      if(yes)
+        {
+          int s=B.size();
+          for(int j=0;j<s;j++){
+            if(B.get(j)+s-j>n+1){System.out.println(""NO"");yes=false;break;}
+          }
+        }
+        if(yes)System.out.println(""YES"");
+    }
+    sc.close();
+  }
+}
+",0
+2f8c3bf3,3c667d4f,"import java.util.*;
+public class Main
+{
+	public static void main(String[] args) {
+		Scanner sc=new Scanner(System.in);
+		int t=sc.nextInt();
+		while(t-->0){
+		    int n=sc.nextInt();
+		    int k=sc.nextInt();
+		    
+		    int idx[]=new int[k];
+		    
+		    for(int i=0;i<k;i++){
+		        idx[i]=sc.nextInt();
+		    }
+		    
+		    long arr[]=new long[n];
+		    Arrays.fill(arr,Integer.MAX_VALUE);
+		    for(int i=0;i<k;i++){
+		        long temp=sc.nextLong();
+		        arr[idx[i]-1]=temp;
+		    }
+		    
+		    long left[]=new long[n];
+		    long right[]=new long[n];
+		    
+		    Arrays.fill(left,Integer.MAX_VALUE);
+		    Arrays.fill(right,Integer.MAX_VALUE);
+		    
+		    
+		    left[0]=arr[0];
+		    
+		    for(int i=1;i<n;i++){
+		       left[i]=Math.min(left[i-1]+1,arr[i]);
+		    }
+		    
+		    right[arr.length-1]=arr[arr.length-1];
+		    
+		    for(int i=n-2;i>=0;i--){
+		        right[i]=Math.min(right[i+1]+1,arr[i]);
+		    }
+		    
+		    for(int i=0;i<n;i++){
+		      //  System.out.print(left[i]+""--""+right[i]+""\\"");
+		       
+		       
+		       System.out.print(Math.min(left[i],right[i])+"" "");
+		    }
+		    System.out.println();
+		  
+		}
+	}
+}
+","import java.util.*;
+public class j
+{
+  public static void main(String args[])
+  {
+    Scanner in=new Scanner(System.in);
+    int n=in.nextInt();
+    while(n-->0)
+    {
+      int len=in.nextInt();
+      int t=in.nextInt();
+      int pos[]=new int[t];
+      int temp[]=new int[t];
+      for(int i=0;i<t;i++)
+      pos[i]=in.nextInt();
+      for(int i=0;i<t;i++)
+      temp[i]=in.nextInt();
+      long range[]=new long[len];
+      Arrays.fill(range,Long.MAX_VALUE-10000);
+      for(int i=0;i<t;i++)
+      range[pos[i]-1]=temp[i];
+      for(int i=1;i<len;i++)
+      {
+        range[i]=Math.min(range[i],1+range[i-1]);
+      }
+      for(int i=len-2;i>=0;i--)
+      {
+      range[i]=Math.min(range[i+1]+1,range[i]);
+      }
+      for(int i=0;i<len;i++)
+      {
+        System.out.print(range[i]+"" "");
+      }System.out.println();
+    }
+  }
+}
+",0
+69b2fd22,764484c3,"import java.io.*;
+import java.util.*;
+public class Main {
+    public static void main(String args[])
+    {
+        FastReader input=new FastReader();
+        PrintWriter out=new PrintWriter(System.out);
+        int T=1;
+        while(T-->0)
+        {
+            int n=input.nextInt();
+            int a[]=new int[n];
+            ArrayList<Integer> list=new ArrayList<>();
+            ArrayList<Integer> space=new ArrayList<>();
+            for(int i=0;i<n;i++)
+            {
+                a[i]=input.nextInt();
+                if(a[i]==1)
+                {
+                    list.add(i);
+                }
+                else
+                {
+                    space.add(i);
+                }
+            }
+            int pre[]=new int[space.size()];
+            for(int i=0;i<list.size();i++)
+            {
+                if(i==0)
+                {
+                    int min=Integer.MAX_VALUE;
+                    for(int j=0;j<space.size();j++)
+                    {
+                        pre[j]=Math.abs(list.get(i)-space.get(j));
+                        min=Math.min(min,pre[j]);
+                        pre[j]=min;
+                    }
+                }
+                else
+                {
+                    int arr[]=new int[space.size()];
+                    for(int j=0;j<i;j++)
+                    {
+                        arr[j]=Integer.MAX_VALUE;
+                    }
+
+                    int min=Integer.MAX_VALUE;
+                    for(int j=i;j<space.size();j++)
+                    {
+                        int v=Math.abs(list.get(i)-space.get(j));
+                        v+=pre[j-1];
+                        arr[j]=v;
+                        min=Math.min(min,v);
+                        arr[j]=min;
+                    }
+                    for(int j=0;j<space.size();j++)
+                    {
+                        pre[j]=arr[j];
+                    }
+                }
+            }
+            out.println(pre[space.size()-1]);
+        }
+        out.close();
+    }
+    static class FastReader
+    {
+        BufferedReader br;
+        StringTokenizer st;
+        public FastReader()
+        {
+            br = new BufferedReader(new InputStreamReader(System.in));
+        }
+        String next()
+        {
+            while (st == null || !st.hasMoreElements())
+            {
+                try
+                {
+                    st = new StringTokenizer(br.readLine());
+                }
+                catch (IOException e)
+                {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+        int nextInt()
+        {
+            return Integer.parseInt(next());
+        }
+        long nextLong()
+        {
+            return Long.parseLong(next());
+        }
+        double nextDouble()
+        {
+            return Double.parseDouble(next());
+        }
+        String nextLine()
+        {
+            String str="""";
+            try
+            {
+                str=br.readLine();
+            }
+            catch (IOException e)
+            {
+                e.printStackTrace();
+            }
+            return str;
+        }
+    }
+}","import java.util.*;
+import java.lang.*;
+import java.io.*;
+
+/* Name of the class has to be ""Main"" only if the class is public. */
+public class Armchairs
+{
+	public static void main (String[] args) throws java.lang.Exception
+	{
+		Scanner sc = new Scanner(System.in);
+		PrintWriter out = new PrintWriter(System.out);
+		
+		int n = sc.nextInt();
+		Vector<Integer> a = new Vector();
+		Vector<Integer> b = new Vector();
+		    
+		for (int i=0; i<n; ++i){
+		    int input = sc.nextInt();
+		    if(input==1) a.add(i);
+		    else b.add(i);
+		}
+		
+		n = a.size();
+		int m = b.size();
+		
+		if(n==0) out.print(0);
+		else{
+		    int [][]dp = new int [n][m];
+    		for (int i=0; i<n; ++i) for (int j=0; j<m; ++j) dp[i][j] = 25000000;
+    		dp[0][0] = Math.abs(a.get(0) - b.get(0));
+    		for (int i=0; i<n; ++i) for (int j=1; j<m; ++j){
+    		    if(i==0) dp[i][j] = Math.min(Math.abs(a.get(i) - b.get(j)),dp[i][j-1]);
+    		    else dp[i][j] = Math.min(Math.abs(a.get(i) - b.get(j)) + dp[i-1][j-1],dp[i][j-1]);
+    		}
+    		out.print(dp[n-1][m-1]);
+		}
+		
+		out.close();
+	}
+	
+	/*Methods*/
+	static int min(int... ar){int min=Integer.MAX_VALUE;for(int i:ar)min=Math.min(min, i);return min;}
+    static long min(long... ar){long min=Long.MAX_VALUE;for(long i:ar)min=Math.min(min, i);return min;}
+    static int max(int... ar) {int max=Integer.MIN_VALUE;for(int i:ar)max=Math.max(max, i);return max;}
+    static long max(long... ar) {long max=Long.MIN_VALUE;for(long i:ar)max=Math.max(max, i);return max;}
+    static void reverse(int a[]){for(int i=0;i<a.length>>1;i++){int tem=a[i];a[i]=a[a.length-1-i];a[a.length-1-i]=tem;}}
+    static void reverse(long a[]){for(int i=0;i<a.length>>1;i++){long tem=a[i];a[i]=a[a.length-1-i];a[a.length-1-i]=tem;}}
+    static String reverse(String s){StringBuilder sb=new StringBuilder(s);sb.reverse();return sb.toString();}
+}
+",0
+69b2fd22,7bc92b7f,"import java.io.*;
+import java.util.*;
+public class Main {
+    public static void main(String args[])
+    {
+        FastReader input=new FastReader();
+        PrintWriter out=new PrintWriter(System.out);
+        int T=1;
+        while(T-->0)
+        {
+            int n=input.nextInt();
+            int a[]=new int[n];
+            ArrayList<Integer> list=new ArrayList<>();
+            ArrayList<Integer> space=new ArrayList<>();
+            for(int i=0;i<n;i++)
+            {
+                a[i]=input.nextInt();
+                if(a[i]==1)
+                {
+                    list.add(i);
+                }
+                else
+                {
+                    space.add(i);
+                }
+            }
+            int pre[]=new int[space.size()];
+            for(int i=0;i<list.size();i++)
+            {
+                if(i==0)
+                {
+                    int min=Integer.MAX_VALUE;
+                    for(int j=0;j<space.size();j++)
+                    {
+                        pre[j]=Math.abs(list.get(i)-space.get(j));
+                        min=Math.min(min,pre[j]);
+                        pre[j]=min;
+                    }
+                }
+                else
+                {
+                    int arr[]=new int[space.size()];
+                    for(int j=0;j<i;j++)
+                    {
+                        arr[j]=Integer.MAX_VALUE;
+                    }
+
+                    int min=Integer.MAX_VALUE;
+                    for(int j=i;j<space.size();j++)
+                    {
+                        int v=Math.abs(list.get(i)-space.get(j));
+                        v+=pre[j-1];
+                        arr[j]=v;
+                        min=Math.min(min,v);
+                        arr[j]=min;
+                    }
+                    for(int j=0;j<space.size();j++)
+                    {
+                        pre[j]=arr[j];
+                    }
+                }
+            }
+            out.println(pre[space.size()-1]);
+        }
+        out.close();
+    }
+    static class FastReader
+    {
+        BufferedReader br;
+        StringTokenizer st;
+        public FastReader()
+        {
+            br = new BufferedReader(new InputStreamReader(System.in));
+        }
+        String next()
+        {
+            while (st == null || !st.hasMoreElements())
+            {
+                try
+                {
+                    st = new StringTokenizer(br.readLine());
+                }
+                catch (IOException e)
+                {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+        int nextInt()
+        {
+            return Integer.parseInt(next());
+        }
+        long nextLong()
+        {
+            return Long.parseLong(next());
+        }
+        double nextDouble()
+        {
+            return Double.parseDouble(next());
+        }
+        String nextLine()
+        {
+            String str="""";
+            try
+            {
+                str=br.readLine();
+            }
+            catch (IOException e)
+            {
+                e.printStackTrace();
+            }
+            return str;
+        }
+    }
+}","import java.util.*;
+import java.io.*;
+
+
+public class Main{
+
+    public static void main(String[] args) throws java.io.IOException {
+        Scanner sc = new Scanner(System.in);
+        int n=sc.nextInt();
+        int[] arr=new int[n];
+        int[][] dp=new int[n][n];
+        int[][] min=new int[n][n];
+        ArrayList<Integer> ones=new ArrayList<>();
+        ArrayList<Integer> zero=new ArrayList<>();
+        for(int i=0;i<n;++i) {
+            arr[i] = sc.nextInt();
+            if(arr[i]==1)
+                ones.add(i);
+            else
+                zero.add(i);
+        }
+        for(int i=0;i<n;++i)
+            for(int j=0;j<n;++j) {
+                min[i][j] = Integer.MAX_VALUE;
+                dp[i][j] = Integer.MAX_VALUE;
+            }
+        int len=ones.size();
+        int zlen=zero.size();
+        int minn=0;
+        for(int i=0;i<len;++i)
+        {
+            int cur = ones.get(i);
+            for(int j=i;j<zlen;j++)
+            {
+                int curz = zero.get(j);
+                int cost = Math.abs(cur-curz);
+                if(i!=0 && curz-1>=0)
+                {
+                    cost+=min[i-1][curz-1];
+                }
+                dp[i][curz]=cost;
+            }
+            minn=Integer.MAX_VALUE;
+            for(int j=0;j<n;++j)
+            {
+                if(dp[i][j]<minn)
+                    minn=dp[i][j];
+                min[i][j]=minn;
+            }
+        }
+        System.out.println(minn);
+    }
+}
+// 1 0 1 1 0 0 1",0
+3b498a39,69b2fd22,"/*
+ *     HI THERE! (: 
+ * 
+ * CREATED BY : NAITIK V
+ * 
+ *     JAI HIND
+ * 
+ */
+
+import java.util.*;
+
+
+import java.io.*;
+import java.math.*;
+
+public class Main
+
+{ 
+	 static FastReader sc=new FastReader(); 
+	 static long dp[][];
+	 static int mod=1000000007;
+	 static int max;
+	  public static void main(String[] args)
+{
+		   PrintWriter out=new PrintWriter(System.out);
+		   //StringBuffer sb=new StringBuffer("""");
+		  int ttt=1;
+		   //ttt =i();
+		 
+	        outer :while (ttt-- > 0) 
+			{
+	        	int n=i();
+	        	int A[]=input(n);
+	        	dp=new long[n+1][n+1];
+	        	for(int i=0;i<=n;i++) {
+	        		Arrays.fill(dp[i],-1);
+	        	}
+		        	
+	        	
+	        	ArrayList<Integer> l=new ArrayList<Integer>();
+	        	ArrayList<Integer> m=new ArrayList<Integer>();
+	        	for(int i=0;i<n;i++) {
+	        		if(A[i]==0) {
+	        			l.add(i+1);
+	        		}
+	        		else {
+	        			m.add(i+1);
+	        		}
+	        	}
+	        	A=new int[m.size()];
+	        	int B[]=new int[l.size()];
+	        	for(int i=0;i<l.size();i++) {
+	        		B[i]=l.get(i);
+	        	}
+	        	for(int i=0;i<m.size();i++) {
+	        		A[i]=m.get(i);
+	        	}
+	        	n=m.size();
+	        	int o=l.size();
+		        	System.out.println(go(A,B,0,0,n,o));
+	        	
+			}
+
+	     //System.out.println(sb.toString());
+		     out.close();
+	     
+	     
+	    //CHECK FOR N=1                    //CHECK FOR M=0
+        //CHECK FOR N=1                    //CHECK FOR M=0
+       	//CHECK FOR N=1
+       	//CHECK FOR N=1
+       	//CHECK FOR N=1
+		        
+		     
+    }
+	  
+	 
+	  
+	  
+	
+	 
+	private static long go(int[] A, int[] B, int i, int j, int n, int m) {
+		if(i==n)
+			return 0;
+		if(j==m)
+			return Integer.MAX_VALUE;
+		if(dp[i][j]!=-1)
+			return dp[i][j];
+		long op1=go(A, B, i+1, j+1, n, m)+Math.abs(A[i]-B[j]);
+		long op2=go(A, B, i, j+1, n, m);
+		return dp[i][j]=Math.min(op1, op2);
+	
+		
+		
+		
+		
+		}
+
+
+
+
+
+
+static class Pair implements Comparable<Pair>
+     {
+    	 int x;
+    	 int y;
+    	 Pair(int x,int y){
+    		 this.x=x;
+    		 this.y=y;
+    	 }
+		@Override
+		public int compareTo(Pair o) {
+			if(this.x>o.x)
+				return 1;
+			else if(this.x<o.x)
+				return -1;
+			else {
+				if(this.y>o.y)
+					return 1;
+				else if(this.y<o.y)
+					return -1;
+				else
+					return 0;
+			}
+		}
+		
+		/* FOR TREE MAP PAIR USE */
+		
+//		public int compareTo(Pair o) {
+// 			if (x > o.x) {
+// 				return 1;
+// 			}
+// 			if (x < o.x) {
+// 				return -1;
+// 			}
+// 			if (y > o.y) {
+// 				return 1;
+// 			}
+// 			if (y < o.y) {
+// 				return -1;
+// 			}
+// 			return 0;
+// 		}
+	
+		
+     }
+
+static int[] input(int n) {
+	int A[]=new int[n];
+	   for(int i=0;i<n;i++) {
+		   A[i]=sc.nextInt();
+	   }
+	   return A;
+   }
+static long[] inputL(int n) {
+	long A[]=new long[n];
+	   for(int i=0;i<n;i++) {
+		   A[i]=sc.nextLong();
+	   }
+	   return A;
+   }
+static String[] inputS(int n) {
+	String A[]=new String[n];
+	   for(int i=0;i<n;i++) {
+		   A[i]=sc.next();
+	   }
+	   return A;
+   }
+static long sum(int A[]) {
+	long sum=0;
+	for(int i : A) {
+		sum+=i;
+	}
+	return sum;
+}
+static long sum(long A[]) {
+	long sum=0;
+	for(long i : A) {
+		sum+=i;
+	}
+	return sum;
+}
+static void reverse(long A[]) {
+	int n=A.length;
+	long B[]=new long[n];
+	for(int i=0;i<n;i++) {
+		B[i]=A[n-i-1];
+	}
+	for(int i=0;i<n;i++)
+		A[i]=B[i];
+	
+}
+static void reverse(int A[]) {
+	int n=A.length;
+	int B[]=new int[n];
+	for(int i=0;i<n;i++) {
+		B[i]=A[n-i-1];
+	}
+	for(int i=0;i<n;i++)
+		A[i]=B[i];
+	
+}
+static void input(int A[],int B[]) {
+	   for(int i=0;i<A.length;i++) {
+		   A[i]=sc.nextInt();
+		   B[i]=sc.nextInt();
+	   }
+}
+static int[][] input(int n,int m){
+	int A[][]=new int[n][m];
+	for(int i=0;i<n;i++) {
+		for(int j=0;j<m;j++) {
+			A[i][j]=i();
+		}
+	}
+	return A;
+}
+static char[][] charinput(int n,int m){
+	char A[][]=new char[n][m];
+	for(int i=0;i<n;i++) {
+		String s=s();
+		for(int j=0;j<m;j++) {
+			A[i][j]=s.charAt(j);
+		}
+	}
+	return A;
+}
+static int max(int A[]) {
+	int max=Integer.MIN_VALUE;
+	for(int i=0;i<A.length;i++) {
+		max=Math.max(max, A[i]);
+	}
+	return max;
+}
+static int min(int A[]) {
+	int min=Integer.MAX_VALUE;
+	for(int i=0;i<A.length;i++) {
+		min=Math.min(min, A[i]);
+	}
+	return min;
+}
+static long max(long A[]) {
+	long max=Long.MIN_VALUE;
+	for(int i=0;i<A.length;i++) {
+		max=Math.max(max, A[i]);
+	}
+	return max;
+}
+static long min(long A[]) {
+	long min=Long.MAX_VALUE;
+	for(int i=0;i<A.length;i++) {
+		min=Math.min(min, A[i]);
+	}
+	return min;
+}
+static long [] prefix(long A[]) {
+	long p[]=new long[A.length];
+	p[0]=A[0];
+	for(int i=1;i<A.length;i++)
+		p[i]=p[i-1]+A[i];
+	return p;
+}
+static long [] prefix(int A[]) {
+	long p[]=new long[A.length];
+	p[0]=A[0];
+	for(int i=1;i<A.length;i++)
+		p[i]=p[i-1]+A[i];
+	return p;
+}
+static long [] suffix(long A[]) {
+	long p[]=new long[A.length];
+	p[A.length-1]=A[A.length-1];
+	for(int i=A.length-2;i>=0;i--)
+		p[i]=p[i+1]+A[i];
+	return p;
+}
+static long [] suffix(int A[]) {
+	long p[]=new long[A.length];
+	p[A.length-1]=A[A.length-1];
+	for(int i=A.length-2;i>=0;i--)
+		p[i]=p[i+1]+A[i];
+	return p;
+}
+static long power(long x, long y, long p)
+{
+
+	if(y==0)
+		return 1;
+	if(x==0)
+		return 0;
+    long res = 1;
+    x = x % p;
+
+    while (y > 0) {
+
+        if (y % 2 == 1)
+            res = (res * x) % p;
+
+        y = y >> 1; 
+        x = (x * x) % p;
+    }
+
+    return res;
+}
+static void print(int A[]) {
+	for(int i : A) {
+		System.out.print(i+"" "");
+	}
+	System.out.println();
+}
+static void print(long A[]) {
+	for(long i : A) {
+		System.out.print(i+"" "");
+	}
+	System.out.println();
+}
+static long mod(long x) {
+	  return ((x%mod + mod)%mod);
+}
+static String reverse(String s) {
+	StringBuffer p=new StringBuffer(s);
+	p.reverse();
+	return p.toString();
+}
+
+     static int i() {
+    	 return sc.nextInt();
+     }
+     static String s() {
+    	 return sc.next();
+     }
+     static long l() {
+    	 return sc.nextLong();
+     }  
+     static void sort(int[] A){
+        int n = A.length;
+        Random rnd = new Random();
+        for(int i=0; i<n; ++i){
+            int tmp = A[i];
+            int randomPos = i + rnd.nextInt(n-i);
+            A[i] = A[randomPos];
+            A[randomPos] = tmp;
+        }
+        Arrays.sort(A);
+     }
+     static void sort(long[] A){
+	        int n = A.length;
+	        Random rnd = new Random();
+	        for(int i=0; i<n; ++i){
+	            long tmp = A[i];
+	            int randomPos = i + rnd.nextInt(n-i);
+	            A[i] = A[randomPos];
+	            A[randomPos] = tmp;
+	        }
+	        Arrays.sort(A);
+	     }
+  static String sort(String s) {
+ 	 Character ch[]=new Character[s.length()];
+ 	 for(int i=0;i<s.length();i++) {
+ 		 ch[i]=s.charAt(i);
+ 	 }
+ 	 Arrays.sort(ch);
+ 	 StringBuffer st=new StringBuffer("""");
+ 	 for(int i=0;i<s.length();i++) {
+ 		 st.append(ch[i]);
+ 	 }
+ 	 return st.toString();
+  }
+  static HashMap<Integer,Integer> hash(int A[]){
+	  HashMap<Integer,Integer> map=new HashMap<Integer, Integer>();
+	  for(int i : A) {
+		  if(map.containsKey(i)) {
+			  map.put(i, map.get(i)+1);
+		  }
+		  else {
+			  map.put(i, 1);
+		  }
+	  }
+	  return map;
+  }
+  static TreeMap<Integer,Integer> tree(int A[]){
+	  TreeMap<Integer,Integer> map=new TreeMap<Integer, Integer>();
+	  for(int i : A) {
+		  if(map.containsKey(i)) {
+			  map.put(i, map.get(i)+1);
+		  }
+		  else {
+			  map.put(i, 1);
+		  }
+	  }
+	  return map;
+  }
+     static boolean prime(int n) 
+	    { 
+	        if (n <= 1) 
+	            return false; 
+	        if (n <= 3) 
+	            return true; 
+	        if (n % 2 == 0 || n % 3 == 0) 
+	            return false; 
+	        double sq=Math.sqrt(n);
+	  
+	        for (int i = 5; i <= sq; i = i + 6) 
+	            if (n % i == 0 || n % (i + 2) == 0) 
+	                return false; 
+	        return true; 
+	    } 
+     static boolean prime(long n) 
+	    { 
+	        if (n <= 1) 
+	            return false; 
+	        if (n <= 3) 
+	            return true; 
+	        if (n % 2 == 0 || n % 3 == 0) 
+	            return false; 
+	        double sq=Math.sqrt(n);
+	  
+	        for (int i = 5; i <= sq; i = i + 6) 
+	            if (n % i == 0 || n % (i + 2) == 0) 
+	                return false; 
+	        return true; 
+	    } 
+     static int gcd(int a, int b) 
+     { 
+         if (a == 0) 
+             return b; 
+         return gcd(b % a, a); 
+     } 
+     static long gcd(long a, long b) 
+     { 
+         if (a == 0) 
+             return b; 
+         return gcd(b % a, a); 
+     } 
+     
+        
+    static class FastReader 
+    { 
+        BufferedReader br; 
+        StringTokenizer st; 
+  
+        public FastReader() 
+        { 
+            br = new BufferedReader(new
+                     InputStreamReader(System.in)); 
+        } 
+  
+        String next() 
+        { 
+            while (st == null || !st.hasMoreElements()) 
+            { 
+                try
+                { 
+                    st = new StringTokenizer(br.readLine()); 
+                } 
+                catch (IOException  e) 
+                { 
+                    e.printStackTrace(); 
+                } 
+            } 
+            return st.nextToken(); 
+        } 
+  
+        int nextInt() 
+        { 
+            return Integer.parseInt(next()); 
+        } 
+  
+        long nextLong() 
+        { 
+            return Long.parseLong(next()); 
+        } 
+  
+        double nextDouble() 
+        { 
+            return Double.parseDouble(next()); 
+        } 
+  
+        String nextLine() 
+        { 
+            String str = """"; 
+            try
+            { 
+                str = br.readLine(); 
+            } 
+            catch (IOException e) 
+            { 
+                e.printStackTrace(); 
+            } 
+            return str; 
+        } 
+    } 
+} 
+
+
+
+","import java.io.*;
+import java.util.*;
+public class Main {
+    public static void main(String args[])
+    {
+        FastReader input=new FastReader();
+        PrintWriter out=new PrintWriter(System.out);
+        int T=1;
+        while(T-->0)
+        {
+            int n=input.nextInt();
+            int a[]=new int[n];
+            ArrayList<Integer> list=new ArrayList<>();
+            ArrayList<Integer> space=new ArrayList<>();
+            for(int i=0;i<n;i++)
+            {
+                a[i]=input.nextInt();
+                if(a[i]==1)
+                {
+                    list.add(i);
+                }
+                else
+                {
+                    space.add(i);
+                }
+            }
+            int pre[]=new int[space.size()];
+            for(int i=0;i<list.size();i++)
+            {
+                if(i==0)
+                {
+                    int min=Integer.MAX_VALUE;
+                    for(int j=0;j<space.size();j++)
+                    {
+                        pre[j]=Math.abs(list.get(i)-space.get(j));
+                        min=Math.min(min,pre[j]);
+                        pre[j]=min;
+                    }
+                }
+                else
+                {
+                    int arr[]=new int[space.size()];
+                    for(int j=0;j<i;j++)
+                    {
+                        arr[j]=Integer.MAX_VALUE;
+                    }
+
+                    int min=Integer.MAX_VALUE;
+                    for(int j=i;j<space.size();j++)
+                    {
+                        int v=Math.abs(list.get(i)-space.get(j));
+                        v+=pre[j-1];
+                        arr[j]=v;
+                        min=Math.min(min,v);
+                        arr[j]=min;
+                    }
+                    for(int j=0;j<space.size();j++)
+                    {
+                        pre[j]=arr[j];
+                    }
+                }
+            }
+            out.println(pre[space.size()-1]);
+        }
+        out.close();
+    }
+    static class FastReader
+    {
+        BufferedReader br;
+        StringTokenizer st;
+        public FastReader()
+        {
+            br = new BufferedReader(new InputStreamReader(System.in));
+        }
+        String next()
+        {
+            while (st == null || !st.hasMoreElements())
+            {
+                try
+                {
+                    st = new StringTokenizer(br.readLine());
+                }
+                catch (IOException e)
+                {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+        int nextInt()
+        {
+            return Integer.parseInt(next());
+        }
+        long nextLong()
+        {
+            return Long.parseLong(next());
+        }
+        double nextDouble()
+        {
+            return Double.parseDouble(next());
+        }
+        String nextLine()
+        {
+            String str="""";
+            try
+            {
+                str=br.readLine();
+            }
+            catch (IOException e)
+            {
+                e.printStackTrace();
+            }
+            return str;
+        }
+    }
+}",0
+38b356b7,c77654b8,"import java.awt.*;
+import java.io.*;
+import java.util.*;
+
+public class Main {
+	static BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
+	static StringBuilder str = new StringBuilder();
+	
+	public static void main(String[] args) throws NumberFormatException, IOException {
+		int t = Integer.parseInt(reader.readLine());
+		while (t-- > 0) {
+			solve();
+		}
+		printRes();
+	}
+	
+	public static void printRes() {
+		
+		System.out.println(str);
+	}
+
+	public static void solve() throws IOException {
+		int n = Integer.parseInt(reader.readLine());
+		String[] s = reader.readLine().split("" "");
+		int[] nums = new int[n];
+		
+		for (int i = 0; i < n; i++) {
+			nums[i] = Integer.parseInt(s[i]);
+		}
+		
+		int i = 0;
+		
+		if (n % 2 == 1) {
+			if (nums[1] + nums[2] != 0) {
+				str.append(-(nums[1] + nums[2]) + "" "" + nums[0] + "" "" + nums[0] + "" "");
+			} else if (nums[0] + nums[2] != 0) {
+				str.append(nums[1] + "" "" + -(nums[0] + nums[2]) + "" "" + nums[1] + "" "");
+			} else {
+				str.append(nums[2] + "" "" + nums[2] + "" "" + -(nums[0] + nums[1]) + "" "");
+			}
+			i = 3;
+		}
+		for (; i < n; i+=2) {
+			if (nums[i] > 0 && nums[i+1] > 0) {
+				str.append(nums[i+1] + "" "" + (-nums[i]) + "" "");
+			} else if (nums[i] < 0 && nums[i+1] < 0) {
+				str.append(nums[i+1] + "" "" + Math.abs(nums[i]) + "" "");
+			} else {
+				str.append(Math.abs(nums[i+1]) + "" "" + Math.abs(nums[i]) + "" "");
+			}
+		}
+		str.append(""\n"");
+	}
+}
+","import java.io.PrintWriter;
+import java.util.*;
+public class Main {
+
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        PrintWriter pw = new PrintWriter(System.out);
+        int tc = sc.nextInt();
+        while(tc-->0){
+            int n = sc.nextInt();
+            int[] arr = new int[n]; for(int i = 0; i<n; i++)arr[i] = sc.nextInt();
+            if(n % 2 == 0){
+                for(int i = 0; i<n; i+=2){
+                    pw.print((-arr[i + 1]) + "" "" + arr[i] + "" "");
+                }
+                pw.println();
+            }else{
+                if(arr[0] + arr[1] != 0) pw.print(arr[2] + "" "" + arr[2] + "" "" + (-(arr[0] + arr[1])) + "" "");
+                else if(arr[0] + arr[2] != 0)pw.println(arr[1] + "" "" + (-(arr[0] + arr[2]))+"" "" + arr[1]);
+                else pw.println(-(arr[1] + arr[2]) + "" "" + arr[0]+"" "" + arr[0]);
+                for(int i = 3; i<n; i+=2){
+                    pw.print((-arr[i + 1]) + "" "" + arr[i] + "" "");
+                }
+                pw.println();
+            }
+        }
+        pw.flush();
+    }
+}
+",0
+8f31b279,a3e272af,"import java.util.*;
+import java.io.*;
+public class JavaTract
+{
+	static class Pair implements Comparable<Pair>{
+    	int first;
+    	int second;
+    	Pair(int x,int y){
+        	this.first=x;
+        	this.second=y;
+    	}
+    	@Override
+    	public int compareTo(Pair x){
+        	return this.first-x.first;
+   		}
+   	}	
+    public static void main (String[] args) 
+    {
+        Scanner scan=new Scanner(System.in);
+        int t=scan.nextInt();
+        while(t-->0){
+            int n=scan.nextInt();
+            int m=scan.nextInt();
+            int x=scan.nextInt();
+            int[]arr=new int[n];
+            for(int i=0;i<n;i++){
+                arr[i]=scan.nextInt();
+            }
+            // TreeSet<Pair> set = new TreeSet<>(); 
+            Queue<Pair> set = new PriorityQueue<>();
+            for(int i=1;i<=m;i++){
+               
+               set.add(new Pair(0,i));
+            }
+            
+            System.out.println(""YES"");
+            for(int i=0;i<n;i++){
+                Pair temp=set.poll();
+                
+                int first = temp.first;
+                int second = temp.second;
+
+                System.out.print(second+"" "");
+                
+                set.add(new Pair(first+arr[i],second));
+                
+            }
+            System.out.println();
+
+
+        }
+    }
+
+       
+}
+	
+","
+import java.io.*;
+import java.util.*;
+
+public class Asd {
+
+    static PrintWriter w = new PrintWriter(System.out);
+    static FastScanner s = new FastScanner();
+    static boolean sd = false;
+  
+    public static void main(String[] args) {
+
+       int t = s.nextInt();
+        //int t=1;
+        while (t-- > 0) {
+            solve();
+        }
+        w.close();
+
+    }
+  public static class Student {
+    public int i1;
+    public int value;
+          
+    // A parameterized student constructor
+    public Student(int i1,int i2) {
+      
+        this.i1 = i1;
+        this.value=i2;
+    }
+      
+    public int getkey() {
+        return i1;
+    } 
+    public int getValue() {
+        return value;
+    } 
+}
+   static class StudentComparator implements Comparator<Student>{
+              
+            // Overriding compare()method of Comparator 
+                        // for descending order of cgpa
+        @Override   
+        public int compare(Student s1, Student s2) {
+                if (s1.i1 < s2.i1)
+                    return -1;
+                else if (s1.i1 >s2.i1)
+                    return 1;
+                                return 0;
+                }
+        }
+    
+    /* Function to print all the permutations of the string
+     static String swap(String str, int i, int j)
+     {
+     char ch;
+     char[] array = str.toCharArray();
+     ch = array[i];
+     array[i] = array[j];
+     array[j] = ch;
+     return String.valueOf(array);
+     }
+    
+     static void permute(String str,int low,int high)
+     {
+     if(low == high)
+     list.add(Long.parseLong(str));
+ 
+     int i;
+     for(i = low; i<=high; i++){
+     str = swap(str,low,i);
+     permute(str, low+1,high);
+     str = swap(str,low,i);
+     }
+     }
+     use  permute(str2,0,str2.length()-1); to perform combinations
+     */
+
+    public static void solve() {
+        int n=s.nextInt();
+        int m=s.nextInt();
+        int x=s.nextInt();
+        int arr[]=new int[n];int res[]=new int[n];
+        for(int i=0;i<n;i++)
+            arr[i]=s.nextInt();
+        
+        PriorityQueue<Student> pq=new PriorityQueue<Student>(new StudentComparator());
+        for(int i=0;i<m;i++){
+            pq.add(new Student(arr[i],i));res[i]=i;}
+        for(int i=m;i<n;i++)
+        {
+            Student s1=pq.poll();
+            int k2=s1.getkey()+arr[i];
+            int v2=s1.getValue();res[i]=v2;
+            pq.add(new Student(k2,v2));
+        }
+        w.println(""YES"");
+        for(int i=0;i<n;i++)
+            w.print(res[i]+1+"" "");
+        w.println();
+       
+    }
+
+    static void call(ArrayList<Integer> t, ArrayList<Integer> m) {
+        if (t.size() == 0 && m.size() == 0) {
+            sd = true;
+            return;
+        }
+        t.remove(0);
+        t.remove(t.size() - 1);
+        call(t, new ArrayList<Integer>(m.subList(0, m.size() - 1)));
+        call(t, new ArrayList<Integer>(m.subList(1, m.size())));
+    }
+
+    static long gcd(long a, long b) {
+        if (b == 0) {
+            return a;
+        }
+        return gcd(b, a % b);
+    }
+
+    static int noofdivisors(int n) {
+            //it counts no of divisors of every number upto number n
+
+        int arr[] = new int[n + 1];
+        for (int i = 1; i <= (n); i++) {
+            for (int j = i; j <= (n); j = j + i) {
+                arr[j]++;
+            }
+        }
+        return arr[0];
+    }
+
+    static char[] reverse(char arr[]) {
+        char[] b = new char[arr.length];
+        int j = arr.length;
+        for (int i = 0; i < arr.length; i++) {
+            b[j - 1] = arr[i];
+            j = j - 1;
+        }
+        return b;
+    }
+
+    static long factorial(int n) {
+        long su = 1;
+        for (int i = 1; i <= n; i++) {
+            su *= (long) i;
+        }
+        return su;
+    }
+
+    static class FastScanner {
+
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st = new StringTokenizer("""");
+
+        public String next() {
+            while (!st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        long[] readArray(int n) {
+            long[] a = new long[n];
+            for (int i = 0; i < n; i++) {
+                a[i] = nextLong();
+            }
+            return a;
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+    }
+
+}
+",0
+829d2024,8a20e743,"import java.util.*;
+import java.io.*;
+
+
+public class Main{
+    public static class Element implements Comparable<Element>{
+        public int key;
+        public int value;
+        Element(int k, int v)
+        {
+            key=k;
+            value=v;
+        }
+
+        @Override
+        public int compareTo(Element o) {
+            if(this.value<o.value)
+                return -1;
+            if(this.value>o.value)
+                return 1;
+            return 0;
+        }
+    }
+    public static void main(String[] args) {
+        Scanner sc=new Scanner(System.in);
+        int t=sc.nextInt();
+        while(t-->0)
+        {
+            int n=sc.nextInt();
+            int m=sc.nextInt();
+            int x=sc.nextInt();
+            int[] arr=new int[n];
+            for(int i=0;i<n;++i)
+                arr[i]=sc.nextInt();
+            PriorityQueue<Element> pq=new PriorityQueue<>();
+            for(int i=1;i<=m;++i)
+            {
+                pq.add(new Element(i,0));
+            }
+            System.out.println(""YES"");
+            for(int j=0;j<n;j++)
+            {
+                Element cur = pq.poll();
+                System.out.print(cur.key+"" "");
+                cur.value+= arr[j];
+                pq.add(cur);
+            }
+            System.out.println();
+        }
+    }
+}
+","/*
+ * akshaygupta26
+ */
+import java.io.*;
+import java.util.*;
+public class C
+{ 
+	static class Pair{
+		int h,in;
+		Pair(){}
+		Pair(int in,int h){
+			this.in=in;
+			this.h=h;
+		}
+	}
+	static class customSort implements Comparator<Pair>{
+		public int compare(Pair a,Pair b) {
+			return a.h-b.h;
+		}
+	}
+    public static void main(String[] args) 
+	{ 
+		FastReader sc=new FastReader(); 
+		StringBuffer ans=new StringBuffer();
+		int test=sc.nextInt();
+		while(test-->0)
+		{
+			
+			int n=sc.nextInt(),m=sc.nextInt(),x=sc.nextInt();
+			
+			int arr[]=new int[n];
+			int res[]=new int[n];
+			
+			int sum =0;
+			for(int i=0;i<n;i++) {
+				arr[i]=sc.nextInt();sum+=arr[i];
+			}
+			
+			PriorityQueue<Pair> pq=new PriorityQueue<>(new customSort());
+			
+			for(int i=1;i<=m;i++) {
+				pq.add(new Pair(i,0));
+			}
+			
+			ans.append(""YES\n"");
+			for(int a:arr) {
+				Pair xx=pq.poll();
+				ans.append(xx.in+"" "");
+				xx.h+=a;
+				pq.add(xx);
+			}
+			ans.append(""\n"");
+			
+			
+		}
+	    System.out.print(ans);
+	} 
+    
+ 
+    static long _gcd(long a,long b) {
+    	if(b == 0) return a;
+    	return _gcd(b,a%b);
+    }
+    
+    static final Random random=new Random();
+    
+	static void ruffleSort(int[] a) {
+		int n=a.length;//shuffle, then sort 
+		for (int i=0; i<n; i++) {
+			int oi=random.nextInt(n), temp=a[oi];
+			a[oi]=a[i]; a[i]=temp;
+		}
+		Arrays.sort(a);
+	}
+	
+	static void ruffleSort(long[] a) {
+		int n=a.length;//shuffle, then sort 
+		for (int i=0; i<n; i++) {
+			int oi=random.nextInt(n);
+			long temp=a[oi];
+			a[oi]=a[i]; a[i]=temp;
+		}
+		Arrays.sort(a);
+	}
+	
+	static class FastReader 
+	{ 
+		BufferedReader br; 
+		StringTokenizer st; 
+
+		public FastReader() 
+		{ 
+			br = new BufferedReader(new
+					InputStreamReader(System.in)); 
+		} 
+
+		String next() 
+		{ 
+			while (st == null || !st.hasMoreElements()) 
+			{ 
+				try
+				{ 
+					st = new StringTokenizer(br.readLine()); 
+				} 
+				catch (IOException e) 
+				{ 
+					e.printStackTrace(); 
+				} 
+			} 
+			return st.nextToken(); 
+		} 
+
+		int nextInt() 
+		{ 
+			return Integer.parseInt(next()); 
+		} 
+
+		long nextLong() 
+		{ 
+			return Long.parseLong(next()); 
+		} 
+
+		double nextDouble() 
+		{ 
+			return Double.parseDouble(next()); 
+		} 
+
+		String nextLine() 
+		{ 
+			String str = """"; 
+			try
+			{ 
+				str = br.readLine(); 
+			} 
+			catch (IOException e) 
+			{ 
+				e.printStackTrace(); 
+			} 
+			return str; 
+		} 
+	} 
+
+
+} 
+",1
+3cb8c2b7,ec8566b8,"
+import java.util.*;
+
+public class CvsMe {
+    private static class pair {
+        int low, high;
+
+        pair(int low, int high) {
+            this.low = low;
+            this.high = high;
+        }
+        @Override
+        public int hashCode()
+        {
+
+            // uses roll no to verify the uniqueness
+            // of the object of Student class
+
+            final int temp = 14;
+            int ans = 1;
+            ans = (temp *  ans) + low +high;
+            return ans;
+        }
+
+        // Equal objects must produce the same
+        // hash code as long as they are equal
+        @Override
+        public boolean equals(Object o)
+        {
+            if (this == o) {
+                return true;
+            }
+            if (o == null) {
+                return false;
+            }
+            if (this.getClass() != o.getClass()) {
+                return false;
+            }
+            pair other = (pair)o;
+            if (this.low != other.low && this.high !=other.high) {
+                return false;
+            }
+            return true;
+        }
+    }
+
+
+
+    static int val[];
+    static HashMap<pair, Integer> mp;
+    static int ans[];
+
+    public static void main(String[] args) {
+        Scanner in = new Scanner(System.in);
+        int t = in.nextInt();
+        while (t-- != 0) {
+            int n = in.nextInt();
+            ArrayList<ArrayList<Integer>> edge = new ArrayList<>();
+            boolean flag = false;
+            int deg[] = new int[n + 1];
+            val = new int[n + 1];
+            ans = new int[n + 1];
+            mp = new HashMap<>();
+            for (int i = 0; i <= n; i++) {
+                edge.add(new ArrayList<Integer>());
+            }
+            int start = -1;
+            int end = -1;
+            for (int i = 1; i < n; i++) {
+                int u = in.nextInt();
+                int v = in.nextInt();
+                pair p = new pair(u, v);
+                mp.put(p, i);
+                edge.get(u).add(v);
+                edge.get(v).add(u);
+                deg[u]++;
+                deg[v]++;
+                if (deg[u] > 2 || deg[v] > 2) {
+                    flag = true;
+                }
+
+            }
+            boolean vis[] = new boolean[n + 1];
+            if (flag) {
+                System.out.println(-1);
+                continue;
+            } else {
+                for (int i = 1; i <= n; i++) {
+                    if (deg[i] == 1 ) {
+                        start = i;break;
+                    }
+                }
+
+                dfs(vis, edge, 5, start);
+                for (int i = 1; i < n; i++) {
+                    System.out.print(ans[i] + "" "");
+                }
+
+                System.out.println();
+            }
+
+        }
+    }
+
+    private static void dfs(boolean vis[], ArrayList<ArrayList<Integer>> edge, int k, int i) {
+        vis[i] = true;
+
+
+        for (int j : edge.get(i)) {
+            if (!vis[j]) {
+                int w = 2;
+                if (val[i] == 2 || val[j] == 2){ w = 5;}
+                int id = 0;
+                pair p = new pair(i, j);
+
+                if (mp.containsKey(p)) {
+                    id = mp.get(p);
+                    
+                } else {
+                    p = new pair(j, i);
+                    if (mp.containsKey(p)) {id = mp.get(p);
+
+                }}
+                ans[id] = w;
+
+                val[i] = w;
+                val[j] = w;
+                dfs(vis, edge, k, j);
+            }
+        }
+
+    }
+
+}","import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.*;
+import java.util.concurrent.ThreadLocalRandom;
+
+public class A {
+    private static void sport(List<Integer>[] g, Map<W, Integer> map) {
+        int n = g.length;
+        for (int i = 0; i < n; i++) {
+            if (g[i].size() > 2) {
+                System.out.println(-1);
+                return;
+            }
+        }
+        int[] ans = new int[n - 1];
+        //dfs(new C(-1, 0), g, ans, 3, new HashSet<>());
+        Queue<int[]> queue = new LinkedList<>();
+        Set<Integer> seen = new HashSet<>();
+        int val = 3;
+        for (Integer integer : g[0]) {
+            Integer idx = map.get(new W(0, integer));
+            ans[idx] = val;
+            queue.add(new int[]{val, integer});
+            seen.add(integer);
+            val = val == 2 ? 3 : 2;
+        }
+        seen.add(0);
+        while (!queue.isEmpty()) {
+            int[] poll = queue.poll();
+            for (Integer u : g[poll[1]]) {
+                if (!seen.contains(u)) {
+                    seen.add(u);
+                    int curr = poll[0] == 2 ? 3 : 2;
+                    Integer integer = map.get(new W(poll[1], u));
+                    ans[integer] = curr;
+                    queue.add(new int[]{curr, u});
+                }
+            }
+        }
+        for (int an : ans) {
+            System.out.print(an + "" "");
+        }
+        System.out.println();
+    }
+
+    static class W {
+        int u;
+        int v;
+
+        public W(int u, int v) {
+            this.u = u;
+            this.v = v;
+        }
+
+        @Override
+        public boolean equals(Object o) {
+            if (this == o) return true;
+            if (o == null || getClass() != o.getClass()) return false;
+            W w = (W) o;
+            return u == w.u && v == w.v;
+        }
+
+        @Override
+        public int hashCode() {
+            return Objects.hash(u, v);
+        }
+    }
+
+    static void dfs(C v, List<C>[] g, int[] ans, int prev, Set<Integer> seen) {
+        if (v.i != -1) {
+            ans[v.i] = prev == 2 ? 3 : 2;
+        }
+        seen.add(v.v);
+        int next = prev == 2 ? 3 : 2;
+        for (C c : g[v.v]) {
+            if (!seen.contains(c.v)) {
+                dfs(c, g, ans, next, seen);
+            }
+            next = next == 2 ? 3 : 2;
+
+        }
+    }
+
+    static class C {
+        int i;
+        int v;
+
+        public C(int i, int v) {
+            this.i = i;
+            this.v = v;
+        }
+    }
+
+    public static void main(String[] args) throws IOException {
+        FastScanner sc = new FastScanner();
+        int t = sc.nextInt();
+        for (int i = 0; i < t; i++) {
+            int n = sc.nextInt();
+            List<Integer>[] g = new ArrayList[n];
+            for (int j = 0; j < n; j++) {
+                g[j] = new ArrayList<>();
+            }
+            Map<W, Integer> map = new HashMap<>();
+            for (int j = 0; j < n - 1; j++) {
+                int u = sc.nextInt() - 1;
+                int v = sc.nextInt() - 1;
+                g[u].add(v);
+                g[v].add(u);
+                map.put(new W(u, v), j);
+                map.put(new W(v, u), j);
+            }
+            sport(g, map);
+        }
+    }
+
+    static void shuffleArray(int[] ar) {
+        // If running on Java 6 or older, use `new Random()` on RHS here
+        Random rnd = ThreadLocalRandom.current();
+        for (int i = ar.length - 1; i > 0; i--) {
+            int index = rnd.nextInt(i + 1);
+            // Simple swap
+            int a = ar[index];
+            ar[index] = ar[i];
+            ar[i] = a;
+        }
+    }
+
+    static class FastScanner {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st = new StringTokenizer("""");
+
+        String next() {
+            while (!st.hasMoreTokens()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        void nextLine() throws IOException {
+            br.readLine();
+        }
+
+        long[] readArrayLong(int n) {
+            long[] a = new long[n];
+            for (int i = 0; i < n; i++) {
+                a[i] = nextLong();
+            }
+            return a;
+        }
+
+        int[] readArrayInt(int n) {
+            int[] a = new int[n];
+            for (int i = 0; i < n; i++) {
+                a[i] = nextInt();
+            }
+            return a;
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+    }
+}",0
+1b372750,fdd41565,"import java.io.*;
+import java.util.*;
+import java.math.BigInteger;
+import java.util.InputMismatchException;
+
+public class Main {
+	static PrintWriter out;
+	static Reader in;
+	public static void main(String[] args) throws IOException {
+		input_output();
+		Main solver = new Main();
+		solver.solve();
+		out.close();
+
+		out.flush();
+	} 
+
+	static long INF = (long)1e18;
+	static int MAXN = (int)1e5 + 5;
+	static int MOD = (int)1e9 + 7;
+	static int q, t, n, m, k;
+	static double pi = Math.PI;
+
+	void solve() throws IOException {
+		t = in.nextInt();
+		
+
+		while (t --> 0) {
+			n = in.nextInt();
+
+			String[] arr = new String[n];
+			for (int i = 0; i < n; i++) {
+				arr[i] = in.next();
+			}
+
+			int ans = 0;
+			for (int i = 0; i < 26; i++) {
+				List<Integer> list = new ArrayList<>();
+				for (int j = 0; j < n; j++) {
+					int tmp = 0;
+					for (int x = 0; x < arr[j].length(); x++) {
+						if (arr[j].charAt(x)-'a' == i) tmp++;
+						else tmp--;
+					}
+
+					list.add(tmp);
+				}
+
+				Collections.sort(list);
+				int sum = 0, tmpAns = 0;
+				for (int j = n-1; j >= 0; j--) {
+					if (sum + list.get(j) > 0) {
+						tmpAns++;
+						sum += list.get(j);
+					} else break;
+				}
+				ans = Math.max(ans, tmpAns);
+			}
+
+			out.println(ans);
+		}	
+	}
+
+
+	static class Reader {
+		private InputStream mIs;
+		private byte[] buf = new byte[1024];
+		private int curChar;
+		private int numChars;
+
+		public Reader() {
+			this(System.in);
+		}
+
+		public Reader(InputStream is) {
+			mIs = is;
+		}
+
+		public int read() {
+			if (numChars == -1) {
+				throw new InputMismatchException();
+
+			}
+			if (curChar >= numChars) {
+				curChar = 0;
+				try {
+					numChars = mIs.read(buf);
+				} catch (IOException e) {
+					throw new InputMismatchException();
+				}
+				if (numChars <= 0) {
+					return -1;
+				}
+			}
+			return buf[curChar++];
+		}
+
+		public String nextLine() {
+			int c = read();
+			while (isSpaceChar(c)) {
+				c = read();
+			}
+			StringBuilder res = new StringBuilder();
+			do {
+				res.appendCodePoint(c);
+				c = read();
+			} while (!isEndOfLine(c));
+			return res.toString();
+		}
+
+		public String next() {
+			int c = read();
+			while (isSpaceChar(c)) {
+				c = read();
+			}
+			StringBuilder res = new StringBuilder();
+			do {
+				res.appendCodePoint(c);
+				c = read();
+			} while (!isSpaceChar(c));
+			return res.toString();
+		}
+
+		double nextDouble() {
+			return Double.parseDouble(next());
+		}
+
+		public long nextLong() {
+			int c = read();
+			while (isSpaceChar(c)) {
+				c = read();
+			}
+			int sgn = 1;
+			if (c == '-') {
+				sgn = -1;
+				c = read();
+			}
+			long res = 0;
+			do {
+				if (c < '0' || c > '9') {
+					throw new InputMismatchException();
+				}
+				res *= 10;
+				res += c - '0';
+				c = read();
+			} while (!isSpaceChar(c));
+			return res * sgn;
+		}
+
+		public int nextInt() {
+			int c = read();
+			while (isSpaceChar(c)) {
+				c = read();
+			}
+			int sgn = 1;
+			if (c == '-') {
+				sgn = -1;
+				c = read();
+			}
+			int res = 0;
+			do {
+				if (c < '0' || c > '9') {
+					throw new InputMismatchException();
+				}
+				res *= 10;
+				res += c - '0';
+				c = read();
+			} while (!isSpaceChar(c));
+			return res * sgn;
+		}
+
+		public boolean isSpaceChar(int c) {
+			return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
+		}
+
+		public boolean isEndOfLine(int c) {
+			return c == '\n' || c == '\r' || c == -1;
+		}
+
+	}
+	static void input_output() throws IOException {
+		File f = new File(""in.txt"");
+		if (f.exists() && !f.isDirectory()) {
+			in = new Reader(new FileInputStream(""in.txt""));
+		} else in = new Reader();
+		f = new File(""out.txt"");
+		if (f.exists() && !f.isDirectory()) {
+			out = new PrintWriter(new File(""out.txt""));
+		} else out = new PrintWriter(System.out);
+	}
+}","import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.*;
+public class Main
+{
+    public static void main(String args[])
+    {
+     FastReader s=new FastReader();
+     int t=s.nextInt();
+     while(t>0)
+     {
+      Solve solve=new Solve();
+      t--;
+      int n=s.nextInt();
+      String str[]=new String[n];
+      for(int i=0;i<n;i++)
+      str[i]=s.nextLine();
+      char array[]=new char[]{'a','b','c','d','e'};
+      int arr[]=new int[n];
+      int ans=0;
+      for(int i=0;i<5;i++)
+      {
+        Arrays.fill(arr,0);
+          for(int j=0;j<n;j++)
+          {
+                 for(int k=0;k<str[j].length();k++)
+                 {
+                     if(str[j].charAt(k)==array[i])
+                     arr[j]++;
+                     else
+                     arr[j]--;
+                 }
+          }
+          ans=(ans>solve.solve(arr,n))?ans:solve.solve(arr,n);
+      }
+      System.out.println(ans);
+     }
+    }
+}
+class Solve{
+    public int solve(int arr[],int n)
+    {
+        int ans=0;
+        int sum=0;
+        Arrays.sort(arr);
+        for(int i=n-1;i>=0;i--)
+        {
+            if(sum+arr[i]>0)
+            {
+                sum+=arr[i];
+                ans++;
+            }
+            else
+            break;
+        }
+        return ans;
+    }
+}
+class FastReader {
+    BufferedReader br;
+    StringTokenizer st;
+    public FastReader()
+    {
+        br = new BufferedReader(
+                new InputStreamReader(System.in));
+    }
+    String next()
+    {
+        while (st == null || !st.hasMoreElements()) {
+            try {
+                st = new StringTokenizer(br.readLine());
+            }
+            catch (IOException e) {
+                e.printStackTrace();
+            }
+        }
+        return st.nextToken();
+    }
+
+    int nextInt() { return Integer.parseInt(next()); }
+
+    long nextLong() { return Long.parseLong(next()); }
+
+    double nextDouble()
+    {
+        return Double.parseDouble(next());
+    }
+
+    String nextLine()
+    {
+        String str = """";
+        try {
+            str = br.readLine();
+        }
+        catch (IOException e) {
+            e.printStackTrace();
+        }
+        return str;
+    }
+}
+",1
+45e38fad,5be7547e,"import java.util.*;
+import java.io.*;
+
+
+
+public class C_Not_Assigning {
+    // For fast input output
+    static class FastReader {
+        BufferedReader br;
+        StringTokenizer st;
+
+        public FastReader() {
+            try {
+                br = new BufferedReader(
+                        new FileReader(""input.txt""));
+                PrintStream out = new PrintStream(new FileOutputStream(""output.txt""));
+                System.setOut(out);
+            } catch (Exception e) {
+                br = new BufferedReader(new InputStreamReader(System.in));
+            }
+        }
+
+        String next() {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+
+        String nextLine() {
+            String str = """";
+            try {
+                str = br.readLine();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+        }
+    }
+
+    static class Edge{
+        public int node;
+        public int next;
+        Edge(int node, int next){
+            this.node = node;
+            this.next = next;
+        }    
+    }
+    public static void dfs(int u, ArrayList<ArrayList<Edge>> g,int[] vis, int flag, int[] weight){
+        vis[u] = 1;
+        for(Edge e : g.get(u)){
+            if(vis[e.node] == 0){
+                if(flag == 0)
+                {
+                    weight[e.next] = 2;
+                    dfs(e.node, g, vis, 1, weight);
+                }
+                else
+                {
+                    weight[e.next] = 5;
+                    dfs(e.node, g, vis, 0, weight);
+                }
+            }
+        }
+    }
+    // end of fast i/o code
+    public static void main(String[] args) {
+        FastReader reader = new FastReader();
+        int t = reader.nextInt();
+        while(t-->0){
+            int n = reader.nextInt();
+            int[] order = new int[n+1];
+            int flag = 0; 
+            //ArrayList<ArrayList<Integer>> adj = new ArrayList<>(n+1);
+            //Map<Integer, List<Integer>> adj = new HashMap<>();
+            ArrayList<ArrayList<Edge>> graph= new ArrayList<>();
+            for(int i=0;i<n+1;i++){
+                graph.add(new ArrayList<>());
+            }
+            for(int i=0;i<n-1;i++){
+                int u = reader.nextInt();
+                int v = reader.nextInt();
+                order[u]++;
+                order[v]++;
+                graph.get(u).add(new Edge(v, i));
+                graph.get(v).add(new Edge(u, i));
+
+                if(order[u]==3 || order[v]==3){
+                    flag = 1;
+                }
+            }
+            if(flag == 1)
+                System.out.println(-1);
+            else{
+                for(int i=1;i<=n;i++){
+                    if(order[i] == 1){
+                        int[] vis = new int[n+1];
+                        int[] weight = new int[n];
+                        dfs(i, graph, vis, 0, weight);
+                        for(int j =0;j<n-1;j++){
+                            System.out.print(weight[j] + "" "");
+                        }
+                        break;
+                    }
+                }
+                System.out.println();
+            }
+        }
+    }
+}","// package codeforces;
+import java.io.*;
+import java.util.*;
+		
+public class practice {
+	
+	static FastScanner fs = new FastScanner();
+
+	public static void main(String[] args) {
+		int t = 1;
+		t = fs.nextInt();   
+		for(int i=1;i<=t;i++) {
+			solve(t);
+		}
+	}
+	
+	public static void dfs(int u, boolean visited[], ArrayList<ArrayList<Integer>> g[], int ans[], int x) {
+		visited[u] = true;
+		for(ArrayList<Integer> v:g[u]) {
+			if(!visited[v.get(0)]) {
+				ans[v.get(1)]=x;
+				dfs(v.get(0),visited,g,ans,x^1);
+			}
+		}
+		return;
+	}
+	
+	@SuppressWarnings(""unused"")
+	public static void solve(int tt) {
+		int n = fs.nextInt();
+		@SuppressWarnings(""unchecked"")
+		ArrayList<ArrayList<Integer>> g[] = new ArrayList[n];
+		for(int i=0;i<n;i++)g[i]=new ArrayList<ArrayList<Integer>>();
+		int ans[] = new int[n];
+		boolean visited[] = new boolean[n];
+		int deg[] = new int[n];
+		for(int i=0;i<n;i++)deg[i]=0;
+		for(int i=0;i<n-1;i++) {
+			int u = fs.nextInt() - 1;int v = fs.nextInt() - 1;
+			ArrayList<Integer> L1=new ArrayList<Integer>();
+			L1.add(v);L1.add(i);
+			g[u].add(L1);
+			ArrayList<Integer> L2=new ArrayList<Integer>();
+			L2.add(u);L2.add(i);
+			g[v].add(L2);
+			deg[u]++;
+			deg[v]++;
+		}
+		// degree must be <=2 cause if greater than that then sum will be always non prime
+		// there will be exactly 2 leafs, we start dfs from one of them
+		int leaf=-1;
+		boolean notcool=false;
+		for(int i=0;i<n;i++) {
+			if(deg[i]>2) {
+				System.out.println(-1);
+				return;
+			}
+		}
+		for(int i=0;i<n;i++) {
+			if(deg[i]==1) {
+				leaf=i;
+				break;
+			}
+		}
+		dfs(leaf,visited,g,ans,2);
+		for(int i=0;i<n-1;i++)System.out.print(ans[i]+"" "");
+		System.out.println();
+		return;
+	}
+	
+	public static int [] sortarray(int a[]) {
+		ArrayList<Integer> L = new ArrayList<Integer>();
+		for(int i:a) {
+			L.add(i);
+		}
+		Collections.sort(L);
+		for(int i=0;i<L.size();i++)a[i]=L.get(i);
+		return a;
+	}
+	
+	static class FastScanner {
+		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st=new StringTokenizer("""");
+		String next() {
+			while (!st.hasMoreTokens())
+				try {
+					st=new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			return st.nextToken();
+		}
+			
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+		int[] readArray(int n) {
+			int[] a=new int[n];
+			for (int i=0; i<n; i++) a[i]=nextInt();
+			return a;
+		}
+		ArrayList<Integer> readList(int n) {
+			ArrayList<Integer> a = new ArrayList<Integer>();
+			int x;
+			for(int i=0;i<n;i++) {
+				x=fs.nextInt();
+				a.add(x);
+			}
+			return a;
+		}
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+	}
+}
+",0
+4212c4b9,829d2024,"import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.PriorityQueue;
+import java.util.StringTokenizer;
+
+public class Solve {
+
+	static int mod = 1000000000 + 7;
+	static long fact[] = new long[2 * 100000 + 3];
+
+	public static void main(String[] args) throws Exception {
+		Scanner sc = new Scanner();
+		PrintWriter pw = new PrintWriter(System.out);
+		int t = sc.nextInt();
+		while (t-- > 0) {
+			int n = sc.nextInt(); // blocks
+			int m = sc.nextInt(); // towers to build
+			int x = sc.nextInt(); // maximum diff
+			int heights[] = new int[n];
+			int sum = 0;
+			PriorityQueue<Pair> pq = new PriorityQueue<Pair>();
+			for (int i = 0; i < n; i++) {
+				heights[i] = sc.nextInt();
+			}
+			for (int i = 0; i < m; i++) {
+				pq.add(new Pair(i + 1, 0));
+			}
+			pw.println(""YES"");
+
+			for (int i = 0; i < n; i++) {
+				Pair p = pq.poll();
+				p.value += heights[i];
+				pq.add(p);
+				pw.print(p.tower + "" "");
+			}
+
+			pw.println();
+		}
+		pw.flush();
+	}
+
+	static long gcd(long a, long b) {
+		if (a == 0)
+			return b;
+		if (b == 0)
+			return a;
+
+		return gcd(b, a % b);
+
+	}
+
+	static long nC2(long n) {
+		return n * (n - 1) / 2;
+	}
+
+	static long nCrModp(int n, int r, int p) {
+		if (r > n - r)
+			r = n - r;
+
+		// The array C is going to store last
+		// row of pascal triangle at the end.
+		// And last entry of last row is nCr
+		int C[] = new int[r + 1];
+
+		C[0] = 1; // Top row of Pascal Triangle
+
+		// One by constructs remaining rows of Pascal
+		// Triangle from top to bottom
+		for (int i = 1; i <= n; i++) {
+
+			// Fill entries of current row using previous
+			// row values
+			for (int j = Math.min(i, r); j > 0; j--)
+
+				// nCj = (n-1)Cj + (n-1)C(j-1);
+				C[j] = (C[j] + C[j - 1]) % p;
+		}
+		return C[r];
+	}
+
+	static void sort(int[] a) {
+		ArrayList<Integer> l = new ArrayList<>();
+		for (int i : a)
+			l.add(i);
+		Collections.sort(l);
+		for (int i = 0; i < a.length; i++)
+			a[i] = l.get(i);
+	}
+
+}
+
+class Pair implements Comparable<Pair> {
+	int tower;
+	int value = 0;
+
+	Pair(int x, int y) {
+		tower = x;
+		value = y;
+	}
+
+	public int compareTo(Pair o) {
+		return this.value - o.value;
+	}
+
+}
+
+class Scanner {
+	BufferedReader br;
+	StringTokenizer st;
+
+	Scanner() {
+		br = new BufferedReader(new InputStreamReader(System.in));
+	}
+
+	String next() throws IOException {
+		while (st == null || !st.hasMoreElements())
+			st = new StringTokenizer(br.readLine());
+		return st.nextToken();
+	}
+
+	int nextInt() throws NumberFormatException, IOException {
+		return Integer.parseInt(next());
+	}
+
+	long nextLong() throws NumberFormatException, IOException {
+		return Long.parseLong(next());
+	}
+
+	double nextDouble() throws NumberFormatException, IOException {
+		return Double.parseDouble(next());
+	}
+}
+
+//creating a hash table
+//Hashtable<Integer, String> h = new Hashtable<Integer, String>();
+//
+//Hashtable<Integer, String> h1 = new Hashtable<Integer, String>();
+//
+//h.put(3, ""Geeks"");
+//h.put(2, ""forGeeks"");
+//h.put(1, ""isBest"");
+//System.out.println(h.get(1));
+//if (h.containsKey(1)) {
+//	System.out.println(1111111);
+//}
+//if (h.containsValue(""isBest"")) {
+//	System.out.println(1111111);
+//}
+//
+//// create a clone or shallow copy of hash table h
+//h1 = (Hashtable<Integer, String>) h.clone();
+//
+//// checking clone h1
+////System.out.println(""values in clone: "" + h1);
+//
+//// clear hash table h
+//h.clear();
+
+//Creating object of the 
+// class linked list 
+//LinkedList<String> ll 
+//    = new LinkedList<String>(); 
+//
+//// Adding elements to the linked list 
+//ll.add(""A""); 
+//ll.add(""B""); 
+//ll.addLast(""C""); 
+//ll.addFirst(""D""); 
+//ll.add(2, ""E""); 
+//
+//System.out.println(ll); 
+//
+//ll.remove(""B""); 
+//ll.remove(3); 
+//ll.removeFirst(); 
+//ll.removeLast(); 
+//
+//System.out.println(ll); 
+
+//Set<Integer> set = new HashSet<Integer>();
+//try {
+//   for(int i = 0; i < 5; i++) {
+//      set.add(count[i]);
+//   }
+//   System.out.println(set);
+//
+//   TreeSet sortedSet = new TreeSet<Integer>(set);
+//   System.out.println(""The sorted list is:"");
+//   System.out.println(sortedSet);
+//
+//   System.out.println(""The First element of the set is: ""+ (Integer)sortedSet.first());
+//   System.out.println(""The last element of the set is: ""+ (Integer)sortedSet.last());
+//}
+//catch(Exception e) {}","import java.util.*;
+import java.io.*;
+
+
+public class Main{
+    public static class Element implements Comparable<Element>{
+        public int key;
+        public int value;
+        Element(int k, int v)
+        {
+            key=k;
+            value=v;
+        }
+
+        @Override
+        public int compareTo(Element o) {
+            if(this.value<o.value)
+                return -1;
+            if(this.value>o.value)
+                return 1;
+            return 0;
+        }
+    }
+    public static void main(String[] args) {
+        Scanner sc=new Scanner(System.in);
+        int t=sc.nextInt();
+        while(t-->0)
+        {
+            int n=sc.nextInt();
+            int m=sc.nextInt();
+            int x=sc.nextInt();
+            int[] arr=new int[n];
+            for(int i=0;i<n;++i)
+                arr[i]=sc.nextInt();
+            PriorityQueue<Element> pq=new PriorityQueue<>();
+            for(int i=1;i<=m;++i)
+            {
+                pq.add(new Element(i,0));
+            }
+            System.out.println(""YES"");
+            for(int j=0;j<n;j++)
+            {
+                Element cur = pq.poll();
+                System.out.print(cur.key+"" "");
+                cur.value+= arr[j];
+                pq.add(cur);
+            }
+            System.out.println();
+        }
+    }
+}
+",1
+169e34bf,2bbf754b,"import java.util.*;
+public class D{
+  static Scanner sc;
+  public static void solve(){
+    int n=sc.nextInt();
+    Integer a[]=new Integer[n];
+    int flag;
+    for(int i=0;i<n;i++) a[i]=sc.nextInt();
+    String s=sc.next();
+    ArrayList<Integer> x=new ArrayList<>();
+    ArrayList<Integer> y=new ArrayList<>();
+    for(int i=0;i<n;i++){
+      if(s.charAt(i)=='B') x.add(a[i]);
+      else y.add(a[i]);
+    }
+    Collections.sort(x);
+    Collections.sort(y);
+    int p=n;
+    int q=1;
+    for(int i=y.size()-1;i>=0;i--){
+      if(y.get(i)>p){System.out.println(""NO""); return;}
+      p-=1;
+    }
+    for(int i=0;i<x.size();i++){
+      if(x.get(i)<q){System.out.println(""NO""); return;}
+      q+=1;
+    }
+    System.out.println(""YES"");
+  }
+  public static void main(String args[]){
+      sc=new Scanner(System.in);
+      int t=sc.nextInt();
+      while(t-->0) solve();
+  }
+}
+","import java.util.*;
+
+/** 
+__                  __
+( _)                ( _)
+/ / \\              / /\_\_
+/ /   \\            / / | \ \
+/ /     \\          / /  |\ \ \
+/  /   ,  \ ,       / /   /|  \ \
+/  /    |\_ /|      / /   / \   \_\
+/  /  |\/ _ '_| \   / /   /   \    \\
+|  /   |/  0 \0\    / |    |    \    \\
+|    |\|      \_\_ /  /    |     \    \\
+|  | |/    \.\ o\o)  /      \     |    \\
+\    |     /\\`v-v  /        |    |     \\
+| \/    /_| \\_|  /         |    | \    \\
+| |    /__/_ `-` /   _____  |    |  \    \\
+\|    [__]  \_/  |_________  \   |   \    ()
+/    [___] (    \         \  |\ |   |   //
+|    [___]                  |\| \|   /  |/
+/|    [____]                  \  |/\ / / ||
+(  \   [____ /     ) _\      \  \    \| | ||
+\  \  [_____|    / /     __/    \   / / //
+|   \ [_____/   / /        \    |   \/ //
+|   /  '----|   /=\____   _/    |   / //
+__ /  /        |  /   ___/  _/\    \  | ||
+(/-(/-\)       /   \  (/\/\)/  |    /  | /
+(/\/\)           /   /   //
+_________/   /    /
+\____________/    (
+
+
+
+*/
+
+public class Main {
+	public static void main(String[] args) {
+		Scanner sc=new Scanner(System.in);
+		int  t=sc.nextInt();
+		while(t-- >0) {
+			int n=sc.nextInt();
+			int[] arr=new int[n];
+			for(int i=0;i<n;i++) {
+				arr[i]=sc.nextInt();
+			}
+			String str=sc.next();
+			
+			ArrayList<Pair> plist=new ArrayList<>();
+			for(int i=0;i<n;i++) {
+				char ch=str.charAt(i);
+				plist.add(new Pair(arr[i],ch));
+			}
+			
+			//B-reduce
+			//R-increse
+			Collections.sort(plist);
+			
+			int counter=1;
+			boolean flag=false;
+			for(int i=0;i<plist.size();i++) {
+				int val=plist.get(i).number;
+				int clr=plist.get(i).color;
+				
+				if(clr=='B') {
+					if(val<counter) {
+						flag=true;
+						break;
+					}
+				}
+				else {
+					if(val>counter) {
+						flag=true;
+						break;
+					}
+					
+				}
+				counter++;
+			}
+			System.out.println(flag?""NO"":""YES"");
+			
+			
+		}
+	}
+	public static class Pair implements Comparable<Pair>{
+		int number;
+		char color;
+		
+		Pair(int number,char color){
+			this.number=number;
+			this.color=color;
+		}
+		
+		@Override
+		public int compareTo(Pair o) {
+			if(o.color==this.color) {
+				return this.number-o.number;
+			}
+			else {
+				return this.color-o.color;
+			}
+		}
+		
+		public String toString() {
+			return number+""-""+color+""."";
+		}
+	}
+}
+",0
+4da08761,d6fb3b9e,"import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.PrintWriter;
+import java.util.ArrayList;
+import java.util.Arrays;
+
+/**
+ * Built using CHelper plug-in
+ * Actual solution is at the top
+ */
+public class Solution {
+    public static void main(String[] args) {
+        InputStream inputStream = System.in;
+        OutputStream outputStream = System.out;
+        InputReader in = new InputReader(inputStream);
+        PrintWriter out = new PrintWriter(outputStream);
+        Main solver = new Main();
+        boolean multipleTC = true;
+        int testCount = multipleTC ? Integer.parseInt(in.next()) : 1;
+        for (int i = 1; i <= testCount; i++)
+            solver.solve(in, out, i);
+        out.close();
+    }
+    static class Main {
+        PrintWriter out;
+        InputReader in;
+
+        public void solve(InputReader in, PrintWriter out, int test) {
+            this.out = out;
+            this.in = in;
+            int n = ni();
+            String[] arr = new String[n];
+            int[][] freq = new int[n][5];
+            int[][] rem = new int[n][5];
+            for(int i = 0; i < n; i++){
+                arr[i] = n();
+                for(int j = 0; j < arr[i].length(); j++)
+                    freq[i][arr[i].charAt(j) - 'a']++;
+                for(int j = 0; j < 5; j++)
+                    rem[i][j] = arr[i].length() - freq[i][j];
+            }
+            int ans = 0;
+            for(int i = 0; i < 5; i++){
+                int[] vals = new int[n];
+                for(int j = 0; j < n; j++)
+                    vals[j] = freq[j][i] - rem[j][i];
+                Arrays.sort(vals);
+                int sum = 0, x = 0;
+                for(int j = n - 1; j >= 0; j--){
+                    if(sum + vals[j] > 0){
+                        x++;
+                        sum += vals[j];
+                    } else {
+                        break;
+                    }
+                }
+                if(x > ans) {
+                    ans = x;
+                }
+            }
+            pn(ans);
+        }
+
+        int gcd(int a, int b)
+        {
+            if (a == 0)
+                return b;
+
+            return gcd(b%a, a);
+        }
+
+
+        String n(){
+            return in.next();
+        }
+
+        int ni() {
+            return in.nextInt();
+        }
+
+        long nl() {
+            return in.nextLong();
+        }
+
+        void pn(long zx) {
+            out.println(zx);
+        }
+
+        void pn(String sz) {
+            out.println(sz);
+        }
+
+        void pn(double dx){
+            out.println(dx);
+        }
+
+        class Tuple {
+            long x;
+            long y;
+
+            Tuple(long a, long b) {
+                x = a;
+                y = b;
+            }
+        }
+
+    }
+
+    static class InputReader {
+        private InputStream stream;
+        private byte[] buf = new byte[1024];
+        private int curChar;
+        private int numChars;
+
+        public InputReader(InputStream stream) {
+            this.stream = stream;
+        }
+
+        public int read() {
+            if (numChars == -1) {
+                throw new UnknownError();
+            }
+            if (curChar >= numChars) {
+                curChar = 0;
+                try {
+                    numChars = stream.read(buf);
+                } catch (IOException e) {
+                    throw new UnknownError();
+                }
+                if (numChars <= 0) {
+                    return -1;
+                }
+            }
+            return buf[curChar++];
+        }
+
+        public int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        public long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        public String next() {
+            int c = read();
+            while (isSpaceChar(c)) {
+                c = read();
+            }
+            StringBuffer res = new StringBuffer();
+            do {
+                res.appendCodePoint(c);
+                c = read();
+            } while (!isSpaceChar(c));
+
+            return res.toString();
+        }
+
+        private boolean isSpaceChar(int c) {
+            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
+        }
+
+    }
+}","import java.util.*;
+public class Sol
+{
+    public static void main(String[] args)
+    {
+        Scanner sc = new Scanner(System.in);
+        int t = sc.nextInt();
+        while(t-->0)
+        {
+			int n = sc.nextInt();
+			int a[][]=new int[n][5];
+			int tot[]=new int[n];
+			for(int i=0;i<n;i++)
+			{
+				String x = sc.next();
+				for(int j=0;j<x.length();j++)
+					a[i][x.charAt(j)-'a'] += 1;
+				tot[i]=x.length();
+			}
+			
+			int max=Integer.MIN_VALUE;
+			for(int i=0;i<5;i++)
+				max=Math.max(max,function(a,n,i,tot));
+			System.out.println(max);
+			
+		}	
+    }
+	static int function(int a[][],int n,int i,int tot[])
+	{
+		Integer ans[] = new Integer[n];
+		for(int j=0;j<n;j++)
+			ans[j]=a[j][i]-(tot[j]-a[j][i]);
+		int res=0,j=0;
+		Arrays.sort(ans,Collections.reverseOrder());
+		while(j<n&&res+ans[j]>0)
+			res+=ans[j++];
+		return j;
+	}
+}
+",0
+04ed33a5,7ea34254,"import java.util.Scanner;
+
+public class Subsequence {
+	private static Scanner sc = new Scanner(System.in);
+	
+	public static void main(String args[]) {
+		int t = sc.nextInt();
+		
+		while(t-->0) {
+			int n = sc.nextInt();
+			
+			int a[] = new int[n];
+			int b[] =  new int[n];
+			
+			for(int i=0;i<n;i++) {
+				a[i]= sc.nextInt();
+				
+			}
+			
+			if(n%2==0) {
+				calculateB(a,b,n);
+			}
+			else {
+				calculateB(a,b,n-3);
+				if (a[n - 2] + a[n - 3] != 0) {
+					b[n - 3] = -a[n - 1];
+					b[n - 2] = -a[n - 1];
+					b[n - 1] = a[n - 2] + a[n - 3];
+				} else if (a[n - 2] + a[n - 1] != 0) {
+					b[n - 3] = a[n - 2] + a[n - 1];
+					b[n - 2] = -a[n - 3];
+					b[n - 1] = -a[n - 3];
+				} else {
+					b[n - 3] = -a[n - 2];
+					b[n - 2] = a[n - 3] + a[n - 1];
+					b[n - 1] = -a[n - 2];
+				}
+			}
+			
+			for(int i=0;i<n;i++) {
+				System.out.print(b[i] + "" "");
+			}
+			System.out.println();
+		}
+
+	}
+
+	private static void calculateB(int[] a, int[] b, int n) {
+		
+		for(int i=0;i<n-1;i=i+2) {
+			b[i] = -a[i+1];
+			b[i+1] = a[i];
+		}
+		
+	}
+}
+","/* package codechef; // don't place package name! */
+
+import java.util.*;
+import java.lang.*;
+import java.io.*;
+/* Name of the class has to be ""Main"" only if the class is public. */
+public class Codechef
+{static class FastReader 
+    { 
+        BufferedReader br; 
+        StringTokenizer st; 
+  
+        public FastReader() 
+        { 
+            br = new BufferedReader(new
+                     InputStreamReader(System.in)); 
+        } 
+  
+        String next() 
+        { 
+            while (st == null || !st.hasMoreElements()) 
+            { 
+                try
+                { 
+                    st = new StringTokenizer(br.readLine()); 
+                } 
+                catch (IOException  e) 
+                { 
+                    e.printStackTrace(); 
+                } 
+            } 
+            return st.nextToken(); 
+        } 
+  
+        int nextInt() 
+        { 
+            return Integer.parseInt(next()); 
+        } 
+  
+        long nextLong() 
+        { 
+            return Long.parseLong(next()); 
+        } 
+  
+        double nextDouble() 
+        { 
+            return Double.parseDouble(next()); 
+        } 
+  
+        String nextLine() 
+        { 
+            String str = """"; 
+            try
+            { 
+                str = br.readLine(); 
+            } 
+            catch (IOException e) 
+            { 
+                e.printStackTrace(); 
+            } 
+            return str; 
+        } 
+    } 
+//    static int mod = 998244353 ;
+//    static int N = 200005;
+//    static long factorial_num_inv[] = new long[N+1];
+//    static long natual_num_inv[] = new long[N+1];
+//    static long fact[] = new long[N+1];
+//    static void InverseofNumber() 
+//{ 
+//    natual_num_inv[0] = 1;
+//    natual_num_inv[1] = 1; 
+//    for (int i = 2; i <= N; i++) 
+//        natual_num_inv[i] = natual_num_inv[mod % i] * (mod - mod / i) % mod; 
+//} 
+//static void InverseofFactorial() 
+//{ 
+//    factorial_num_inv[0] = factorial_num_inv[1] = 1; 
+  
+//    for (int i = 2; i <= N; i++) 
+//        factorial_num_inv[i] = (natual_num_inv[i] * factorial_num_inv[i - 1]) % mod; 
+//} 
+//static long nCrModP(long N, long R) 
+//{ 
+//    long ans = ((fact[(int)N] * factorial_num_inv[(int)R]) % mod * factorial_num_inv[(int)(N - R)]) % mod; 
+//    return ans%mod; 
+//}
+    //static boolean prime[];
+    //static void sieveOfEratosthenes(int n)
+    //{
+    //    prime = new boolean[n+1];
+        
+    //    for (int i = 0; i <= n; i++)
+    //        prime[i] = true;
+ 
+    //    for (int p = 2; p * p <= n; p++)
+    //    {
+    //        // If prime[p] is not changed, then it is a
+    //        // prime
+    //        if (prime[p] == true)
+    //        {
+    //            // Update all multiples of p
+    //            for (int i = p * p; i <= n; i += p)
+    //                prime[i] = false;
+    //        }
+    //    }
+ 
+        
+    //}
+    
+	public static void main (String[] args) throws java.lang.Exception
+	{
+    //    InverseofNumber();
+    //    InverseofFactorial();
+    //   fact[0] = 1; 
+    //   for (long i = 1; i <= 2*100000; i++)
+    //   { 
+    //       fact[(int)i] = (fact[(int)i - 1] * i) % mod; 
+    //   }
+    
+		FastReader scan = new FastReader();
+		PrintWriter pw = new PrintWriter(System.out);
+        int t = scan.nextInt();
+        while(t-->0){
+         int n= scan.nextInt();
+         long a[] = new long[n];
+         for(int i=0;i<n;i++){
+             a[i] = scan.nextLong();
+         }
+         long b[] = new long[n];
+         int i=0;
+         if(n%2==1){
+           if(a[0]+a[1]!=0){
+           b[0] = -1*a[2];
+           b[1] = -1*a[2];
+           b[2] = a[0]+a[1];}
+           else if(a[0]+a[2]!=0){
+            b[0] = -1*a[1];
+            b[2] = -1*a[1];
+            b[1] = a[0]+a[2];
+           }
+           else{
+            b[2] = -1*a[0];
+            b[1] = -1*a[0];
+            b[0] = a[2]+a[1]; 
+           }
+           i = 3;
+         }
+         else{
+             b[0] = -a[1];
+             b[1] = a[0];
+             i=2;
+         }
+         while(i<n-1){
+             b[i] = -a[i+1];
+             b[i+1] = a[i];
+             i = i+2;
+         }
+         for(int j=0;j<n;j++){
+             pw.print(b[j]+"" "");
+         }
+         pw.println();
+         pw.flush();
+        }
+    
+    }
+    
+//   static long gcd(long a,long b){
+//       if(a==0)
+//       return b;
+//       return gcd(b%a,a);
+//   }
+//   static long lcm(long a,long b){
+//       return (a/gcd(a,b))*b;
+//   }
+}
+//class Pair{
+//    Integer x,y;
+//    Pair(int x,int y){
+//        this.x = x;
+//        this.y = y;
+//    }
+//    public boolean equals(Object obj) {
+//        // TODO Auto-generated method stub
+//        if(obj instanceof Pair)
+//        {
+//            Pair temp = (Pair) obj;
+//            if(this.x.equals(temp.x) && this.y.equals(temp.y))
+//                return true;
+//        }
+//        return false;
+//    }
+
+//    @Override
+//    public int hashCode() {
+//        // TODO Auto-generated method stub
+        
+//        return (this.x.hashCode() + this.y.hashCode());        
+//    }
+//}
+//class Compar implements Comparator<Pair>{
+//    public int compare(Pair p1,Pair p2){
+//        return p1.x-p2.x;
+//    }
+//}
+",0
+80c384e4,967b67b0,"import java.util.*;
+
+public class Solution {
+	
+	private static Scanner in = new Scanner(System.in);
+	
+	public static void main(String[] args) {
+		
+		int t = in.nextInt();
+		while(t-- > 0)
+			solve();
+    }
+	
+	private static void solve() {
+		int n = in.nextInt();
+		int k = in.nextInt();
+		int a[] = new int[k+1];
+		for(int i=1; i<=k; i++)
+			a[i] = in.nextInt();
+		long l[] = new long[n+1];
+		long r[] = new long[n+1];
+		for(int i=1; i<=n; i++) {
+			l[i] = Integer.MAX_VALUE;
+			r[i] = Integer.MAX_VALUE;
+		}
+		for(int i=1; i<=k; i++) {
+			l[a[i]] = in.nextInt();
+			r[a[i]] = l[a[i]];
+		}
+		for(int i=2;i<=n;i++) {
+			l[i] = Math.min(l[i-1]+1, l[i]);
+		}
+		for(int i=n-1;i>=0;i--) {
+			r[i] = Math.min(r[i+1]+1, r[i]);
+		}
+		
+		for(int i=1;i<=n;i++) {
+				System.out.print(Math.min(l[i], r[i])+"" "");
+		}
+		System.out.println();
+	}
+}
+","import java.util.*;
+
+public class Solution {
+	
+	private static Scanner in = new Scanner(System.in);
+	
+	public static void main(String[] args) {
+		
+		int t = in.nextInt();
+		while(t-- > 0)
+			solve();
+    }
+	
+	private static void solve() {
+		int n = in.nextInt();
+		int k = in.nextInt();
+		int a[] = new int[k+1];
+		for(int i=1; i<=k; i++)
+			a[i] = in.nextInt();
+		long l[] = new long[n+1];
+		long r[] = new long[n+1];
+		for(int i=1; i<=n; i++) {
+			l[i] = Integer.MAX_VALUE;
+			r[i] = Integer.MAX_VALUE;
+		}
+		for(int i=1; i<=k; i++) {
+			l[a[i]] = in.nextInt();
+			r[a[i]] = l[a[i]];
+		}
+		for(int i=2;i<=n;i++) {
+			l[i] = Math.min(l[i-1]+1, l[i]);
+		}
+		for(int i=n-1;i>=0;i--) {
+			r[i] = Math.min(r[i+1]+1, r[i]);
+		}
+		
+		for(int i=1;i<=n;i++) {
+				System.out.print(Math.min(l[i], r[i])+"" "");
+		}
+		System.out.println();
+	}
+}",1
+68d422ec,d77f722c,"import java.io.BufferedReader;
+import java.io.InputStreamReader;
+
+public class AirConditioners {
+	public static void main(String args[]) {
+		try {
+			BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+
+			int t = Integer.parseInt(br.readLine());
+
+			while (t-- > 0) {
+				br.readLine();
+				String[] str = br.readLine().split("" "");				
+				int n = Integer.parseInt(str[0]);
+				int k = Integer.parseInt(str[1]);
+				
+				String[] stra = br.readLine().split("" "");
+				String[] strk = br.readLine().split("" "");
+				
+				int[] arr = new int[n];
+				for (int i = 0; i < n; i++) {
+					arr[i] = Integer.MAX_VALUE;
+				}
+				
+				int[][] ac = new int[k][2];				
+				for (int i = 0; i < k; i++) {
+					ac[i][1] = Integer.parseInt(stra[i]) - 1;					
+					ac[i][0] = Integer.parseInt(strk[i]);	
+					arr[ac[i][1]] = ac[i][0];
+				}				
+				sort(ac, 0, k-1);
+				
+				for (int i = 0; i < k; i++) {
+					int j = ac[i][1]-1;
+					while (j >= 0 && ac[i][0] + Math.abs(ac[i][1] - j) < arr[j]) {
+						arr[j] = ac[i][0] + Math.abs(ac[i][1] - j);
+						j--;
+					}
+					j = ac[i][1]+1;
+					while (j < n && ac[i][0] + Math.abs(ac[i][1] - j) < arr[j]) {
+						arr[j] = ac[i][0] + Math.abs(ac[i][1] - j);
+						j++;
+					}
+				}
+				
+				
+//				for (int i = 0; i < k; i++) {
+//					for (int j = 0; j < n; j++) {
+//						arr[j] = Math.min(arr[j], ac[i][0] + Math.abs(ac[i][1] - j));
+//					}
+//				}
+				
+				for (int i = 0; i < n; i++) {
+					System.out.print(arr[i] + "" "");
+				}
+				System.out.println();
+
+			}
+
+		} catch (Exception e) {
+			return;
+		}
+	}
+	
+	// Merges two subarrays of arr[].
+	// First subarray is arr[l..m]
+	// Second subarray is arr[m+1..r]
+	static void merge(int arr[][], int l, int m, int r) {
+		// Find sizes of two subarrays to be merged
+		int n1 = m - l + 1;
+		int n2 = r - m;
+		
+		/* Create temp arrays */
+		int L[][] = new int[n1][2];
+		int R[][] = new int[n2][2];
+		
+		/*Copy data to temp arrays*/
+		for (int i = 0; i < n1; ++i) {
+			L[i][0] = arr[l + i][0];
+			L[i][1] = arr[l + i][1];
+		}
+		for (int j = 0; j < n2; ++j) {
+			R[j][0] = arr[m + 1 + j][0];
+			R[j][1] = arr[m + 1 + j][1];
+		}
+		
+		/* Merge the temp arrays */
+		
+		// Initial indexes of first and second subarrays
+		int i = 0, j = 0;
+		
+		// Initial index of merged subarry array
+		int k = l;
+		while (i < n1 && j < n2) {
+			if (L[i][0] <= R[j][0]) {
+				arr[k][0] = L[i][0];
+				arr[k][1] = L[i][1];
+				i++;
+			} else {
+				arr[k][0] = R[j][0];
+				arr[k][1] = R[j][1];
+				j++;
+			}
+			k++;
+		}
+		
+		/* Copy remaining elements of L[] if any */
+		while (i < n1) {
+			arr[k][0] = L[i][0];
+			arr[k][1] = L[i][1];
+			i++;
+			k++;
+		}
+		
+		/* Copy remaining elements of R[] if any */
+		while (j < n2) {
+			arr[k][0] = R[j][0];
+			arr[k][1] = R[j][1];
+			j++;
+			k++;
+		}
+	}
+	
+	// Main function that sorts arr[l..r] using
+	// merge()
+	// l = 0, r = n-1
+	static void sort(int arr[][], int l, int r) {
+		if (l < r) {
+			// Find the middle point
+			int m = l + (r - l) / 2;
+			
+			// Sort first and second halves
+			sort(arr, l, m);
+			sort(arr, m + 1, r);
+			
+			// Merge the sorted halves
+			merge(arr, l, m, r);
+		}
+	}
+}
+","import java.io.*;
+import java.util.*;
+
+public class E {
+  public static void main(String[] args) throws IOException {
+    FastReader fr = new FastReader();
+    PrintWriter pr = new PrintWriter(new OutputStreamWriter(System.out));
+    int t = fr.nextInt();
+
+    while (t-- > 0) {
+      int n = fr.nextInt(), k = fr.nextInt();
+      String[] arr = fr.nextLine().split("" "");
+      String[] temp = fr.nextLine().split("" "");
+
+      long[] L = new long[n];
+      long[] R = new long[n];
+
+      long[] c = new long[n];
+      Arrays.fill(c, Long.MAX_VALUE);
+
+      for (int i = 0; i < k; i++) {
+        c[toInt(arr[i]) - 1] = toInt(temp[i]);
+      }
+
+      long p = Integer.MAX_VALUE;
+
+      for (int i = 0; i < R.length; i++) {
+        p = Math.min(p + 1, c[i]);
+        L[i] = p;
+      }
+
+      p = Integer.MAX_VALUE;
+
+      for (int i = n - 1; i >= 0; i--) {
+        p = Math.min(p + 1, c[i]);
+        R[i] = p;
+      }
+
+      StringBuilder sb = new StringBuilder();
+
+      for (int i = 0; i < R.length; i++) {
+        sb.append(Math.min(R[i], L[i]) + "" "");
+      }
+
+      pr.println(sb.toString().trim());
+    }
+
+    pr.close();
+  }
+
+  static class Pair {
+    int x, y;
+
+    public Pair(int x, int y) {
+      this.x = x;
+      this.y = y;
+    }
+  }
+
+  static int toInt(String s) {
+    return Integer.parseInt(s);
+  }
+
+  static class FastReader {
+    BufferedReader br;
+    StringTokenizer st;
+
+    public FastReader() throws FileNotFoundException {
+      br = new BufferedReader(new InputStreamReader(System.in));
+    }
+
+    String next() {
+      while (st == null || !st.hasMoreElements()) {
+        try {
+          st = new StringTokenizer(br.readLine());
+        } catch (IOException e) {
+          e.printStackTrace();
+        }
+      }
+      return st.nextToken();
+    }
+
+    int nextInt() {
+      return Integer.parseInt(next());
+    }
+
+    long nextLong() {
+      return Long.parseLong(next());
+    }
+
+    double nextDouble() {
+      return Double.parseDouble(next());
+    }
+
+    String nextLine() {
+      String str = """";
+      try {
+        str = br.readLine();
+      } catch (IOException e) {
+        e.printStackTrace();
+      }
+      return str;
+    }
+  }
+}
+",0
+5ee4d2f9,b38468e8,"
+import java.util.*;
+/**
+ * Created by Brandon on 4/29/2021, 11:04 AM.
+ */
+public class Main {
+    static long mod = 998244353;
+
+    public static void solve() {
+        // string:
+        //char** vals = new char* [n];
+        //for (int i = 0; i < n; i++) {
+        //	string str = """";
+        //	cin >> str;
+        //	vals[i] = new char[n];
+        //	for (int j = 0; j < n; j++) {
+        //		vals[i][j] = str[j];
+        //	}
+        //}
+        int n;
+        Scanner sc = new Scanner(System.in);
+        n = Integer.parseInt(sc.next());
+	    int[] arr = new int[n];
+        ArrayList<Integer> ones = new ArrayList<>();
+        for (int i = 0; i < n; i++) {
+            arr[i] = Integer.parseInt(sc.next());
+            if (arr[i] == 1) {
+                ones.add(i);
+            }
+        }
+        if (ones.size() == 0) {
+            System.out.println(""0\n"");
+            return;
+        }
+
+	    int[] zeroes = new int[n - ones.size()];
+        int cur = 0;
+        for (int i = 0; i < n; i++) {
+            if (arr[i] == 0) {
+                zeroes[cur] = i;
+                cur++;
+            }
+        }
+	    int[][] dp = new int[ones.size()][n-ones.size()];
+        for (int i = 1; i < ones.size(); i++) {
+            dp[i][0] = 100000000;
+        }
+        dp[0][0] = Math.abs(ones.get(0) - zeroes[0]);
+        for (int i = 1; i < n - ones.size(); i++) {
+            dp[0][i] = Math.min(dp[0][i - 1], Math.abs(ones.get(0) - zeroes[i]));
+        }
+        // dp[i][j] is number where you only have to move first i but max position you can put is j
+        for (int i = 1; i < ones.size(); i++) {
+            for (int j = 1; j < n - ones.size(); j++) {
+                dp[i][j] = Math.min(dp[i][j - 1], dp[i-1][j-1] + Math.abs(zeroes[j] - ones.get(i)));
+            }
+        }
+        System.out.println(dp[ones.size()-1][n-ones.size()-1] + ""\n"");
+    }
+    public static void main(String[] args) {
+        solve();
+    }
+}
+","import java.io.OutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.PrintWriter;
+import java.util.Arrays;
+import java.io.BufferedWriter;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+import java.util.StringTokenizer;
+import java.io.Writer;
+import java.io.OutputStreamWriter;
+import java.io.BufferedReader;
+import java.io.InputStream;
+
+/**
+ * Built using CHelper plug-in
+ * Actual solution is at the top
+ */
+public class Main {
+    public static void main(String[] args) {
+        InputStream inputStream = System.in;
+        OutputStream outputStream = System.out;
+        InputReader in = new InputReader(inputStream);
+        OutputWriter out = new OutputWriter(outputStream);
+        DArmchairs solver = new DArmchairs();
+        solver.solve(1, in, out);
+        out.close();
+    }
+
+    static class DArmchairs {
+        static ArrayList<Integer> empty;
+        static ArrayList<Integer> chair;
+        static long[][] dp;
+
+        public void solve(int testNumber, InputReader in, OutputWriter out) {
+            int n = in.nextInt();
+            int[] arr = in.nextIntArray(n);
+            empty = new ArrayList<>();
+            chair = new ArrayList<>();
+            for (int i = 0; i < n; i++) {
+                int a = arr[i];
+                if (a == 1) chair.add(i);
+                else empty.add(i);
+            }
+            dp = new long[chair.size()][empty.size()];
+            for (long[] row : dp) Arrays.fill(row, -1);
+            long ans = rec(0, 0);
+            out.println(ans);
+        }
+
+        static long rec(int i, int j) {
+            if (i == chair.size()) return 0;
+            int req = chair.size() - i;
+            int have = empty.size() - j;
+            if (req > have) return Integer.MAX_VALUE;
+
+            if (dp[i][j] != -1) return dp[i][j];
+            long opt1 = Math.abs(chair.get(i) - empty.get(j)) + rec(i + 1, j + 1);
+            long opt2 = rec(i, j + 1);
+            dp[i][j] = Math.min(opt1, opt2);
+            return dp[i][j];
+        }
+
+    }
+
+    static class OutputWriter {
+        private final PrintWriter writer;
+
+        public OutputWriter(OutputStream outputStream) {
+            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
+        }
+
+        public OutputWriter(Writer writer) {
+            this.writer = new PrintWriter(writer);
+        }
+
+        public void close() {
+            writer.close();
+        }
+
+        public void println(long i) {
+            writer.println(i);
+        }
+
+    }
+
+    static class InputReader {
+        BufferedReader reader;
+        StringTokenizer tokenizer;
+
+        public InputReader(InputStream stream) {
+            reader = new BufferedReader(new InputStreamReader(stream), 32768);
+            tokenizer = null;
+        }
+
+        public String next() {
+            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
+                try {
+                    tokenizer = new StringTokenizer(reader.readLine());
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+            }
+            return tokenizer.nextToken();
+        }
+
+        public int[] nextIntArray(int n) {
+            int[] array = new int[n];
+            for (int i = 0; i < n; ++i) array[i] = nextInt();
+            return array;
+        }
+
+        public int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+    }
+}
+
+",0
+ac180326,b728ba1d,"//This code is written by प्रविण शंखपाळ 
+
+//package wizard;
+
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.text.DecimalFormat;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.Arrays;
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.Stack;
+import java.util.Queue;
+import java.util.PriorityQueue;
+import java.util.List;
+import java.util.HashSet;
+import java.util.LinkedHashSet;
+import java.util.TreeSet;
+import java.util.Map;
+import java.util.HashMap;
+import java.util.Scanner;
+import java.util.Set;
+import java.util.StringTokenizer;
+import java.util.Vector;
+
+public class Dobby {
+
+	public static void main(String[] args) {
+
+		try {
+
+			FastReader fr = new FastReader();
+			PrintWriter pt = new PrintWriter(System.out);
+
+			int t = fr.nextInt();
+
+			while (t > 0) {
+
+				int n = fr.nextInt(), m = fr.nextInt(), x = fr.nextInt();
+
+				ArrayList<Pair> pp = new ArrayList<>();
+
+				int A[] = new int[n];
+
+				for (int i = 0; i < n; i++) {
+					A[i] = fr.nextInt();
+					Pair pr = new Pair(A[i], i);
+					pp.add(pr);
+				}
+
+				Collections.sort(pp);
+				Collections.reverse(pp);
+
+				int ps[] = new int[n];
+				int pk[] = new int[n];
+				Arrays.fill(ps, 0);
+				Arrays.fill(pk, 0);
+
+				int index = 0;
+
+				for (int i = 0; i < n; i++) {
+
+					if (pk[index] < x) {
+						pk[index] += pp.get(i).a;
+					}
+					ps[pp.get(i).b] = index + 1;
+					index++;
+
+					index = index == m ? 0 : index;
+
+				}
+
+				pt.println(""YES"");
+
+				for (int i = 0; i < n; i++) {
+					pt.print(ps[i] + "" "");
+				}
+				pt.println();
+
+				t--;
+			}
+
+			pt.close();
+
+		} catch (
+
+		Exception e) {
+			return;
+		}
+	}
+
+	static void merge(long arr[], int l, int m, int r) {
+
+		int n1 = m - l + 1;
+		int n2 = r - m;
+
+		long L[] = new long[n1];
+		long R[] = new long[n2];
+
+		for (int i = 0; i < n1; ++i)
+			L[i] = arr[l + i];
+		for (int j = 0; j < n2; ++j)
+			R[j] = arr[m + 1 + j];
+
+		int i = 0, j = 0;
+
+		int k = l;
+		while (i < n1 && j < n2) {
+			if (L[i] <= R[j]) {
+				arr[k] = L[i];
+				i++;
+			} else {
+				arr[k] = R[j];
+				j++;
+			}
+			k++;
+		}
+
+		while (i < n1) {
+			arr[k] = L[i];
+			i++;
+			k++;
+		}
+
+		while (j < n2) {
+			arr[k] = R[j];
+			j++;
+			k++;
+		}
+	}
+
+	static void sort(long arr[], int l, int r) {
+		if (l < r) {
+
+			int m = l + (r - l) / 2;
+
+			sort(arr, l, m);
+			sort(arr, m + 1, r);
+
+			merge(arr, l, m, r);
+		}
+	}
+
+	static class Pair implements Comparable<Pair> {
+		int a, b;
+
+		Pair(int a, int b) {
+			this.a = a;
+			this.b = b;
+		}
+
+		public int compareTo(Pair o) {
+			// TODO Auto-generated method stub
+			if (this.a != o.a)
+				return Integer.compare(this.a, o.a);
+			else
+				return Integer.compare(this.b, o.b);
+			// return 0;
+		}
+
+		public boolean equals(Object o) {
+			if (o instanceof Pair) {
+				Pair p = (Pair) o;
+				return p.a == a && p.b == b;
+			}
+			return false;
+		}
+
+	}
+
+	static int binarySearch(int arr[], int first, int last, int key) {
+		int mid = (first + last) / 2;
+		while (first <= last) {
+			if (arr[mid] < key) {
+				first = mid + 1;
+			} else if (arr[mid] == key) {
+				return mid;
+			} else {
+				last = mid - 1;
+			}
+			mid = (first + last) / 2;
+		}
+		return -1;
+	}
+
+	static class FastReader {
+		BufferedReader br;
+		StringTokenizer st;
+
+		public FastReader() {
+			br = new BufferedReader(new InputStreamReader(System.in));
+		}
+
+		String next() {
+			while (st == null || !st.hasMoreElements()) {
+				try {
+					st = new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			}
+			return st.nextToken();
+		}
+
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+
+		double nextDouble() {
+			return Double.parseDouble(next());
+		}
+
+		String nextLine() {
+			String str = """";
+			try {
+				str = br.readLine();
+			} catch (IOException e) {
+				e.printStackTrace();
+			}
+			return str;
+		}
+	}
+}
+","import java.io.OutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.PrintWriter;
+import java.util.InputMismatchException;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Objects;
+import java.util.Collections;
+import java.io.InputStream;
+
+public class Main {
+    public static void main(String[] args) {
+        InputStream inputStream = System.in;
+        OutputStream outputStream = System.out;
+        FastReader in = new FastReader(inputStream);
+        PrintWriter out = new PrintWriter(outputStream);
+        CPhoenixAndTowers solver = new CPhoenixAndTowers();
+        int testCount = Integer.parseInt(in.next());
+        for (int i = 1; i <= testCount; i++)
+            solver.solve(i, in, out);
+        out.close();
+    }
+
+    static class CPhoenixAndTowers {
+        public void solve(int testNumber, FastReader in, PrintWriter out) {
+            int n = in.nextInt(), m = in.nextInt(), k = in.nextInt();
+            ArrayList<Pair<Integer, Integer>> a = new ArrayList<>();
+            for (int i = 0; i < n; ++i) {
+                a.add(new Pair<>(in.nextInt(), i));
+            }
+            Collections.sort(a);
+
+            int[] ans = new int[n];
+            int[] sum = new int[m];
+            int j = 1;
+
+            for (int i = 0; i < n; ++i) {
+                ans[a.get(i).y] = j;
+                sum[j - 1] += a.get(i).x;
+                j++;
+                if (j == m + 1) j = 1;
+            }
+
+            for (int i = 1; i < m; ++i) {
+                if (Math.abs(sum[i - 1] - sum[i]) > k) {
+                    out.println(""NO"");
+                }
+            }
+
+            out.println(""YES"");
+            for (int e : ans) {
+                out.print(e + "" "");
+            }
+            out.println();
+
+        }
+
+    }
+
+    static class Pair<U, V> implements Comparable<Pair<U, V>> {
+        public U x;
+        public V y;
+
+        public Pair(U x, V y) {
+            this.x = x;
+            this.y = y;
+        }
+
+        public int compareTo(Pair<U, V> o) {
+            int value = ((Comparable<U>) x).compareTo(o.x);
+            if (value != 0) return value;
+            return ((Comparable<V>) y).compareTo(o.y);
+        }
+
+        public boolean equals(Object o) {
+            if (this == o) return true;
+            if (o == null || getClass() != o.getClass()) return false;
+            Pair<?, ?> pair = (Pair<?, ?>) o;
+            return x.equals(pair.x) && y.equals(pair.y);
+        }
+
+        public int hashCode() {
+            return Objects.hash(x, y);
+        }
+
+    }
+
+    static class FastReader {
+        private InputStream stream;
+        private byte[] buf = new byte[1024];
+        private int curChar;
+        private int numChars;
+        private FastReader.SpaceCharFilter filter;
+
+        public FastReader(InputStream stream) {
+            this.stream = stream;
+        }
+
+        public int read() {
+            if (numChars == -1) throw new InputMismatchException();
+            if (curChar >= numChars) {
+                curChar = 0;
+                try {
+                    numChars = stream.read(buf);
+                } catch (IOException e) {
+                    throw new InputMismatchException();
+                }
+                if (numChars <= 0) return -1;
+            }
+            return buf[curChar++];
+        }
+
+        public int nextInt() {
+            int c = read();
+            while (isSpaceChar(c)) c = read();
+            int sgn = 1;
+            if (c == '-') {
+                sgn = -1;
+                c = read();
+            }
+            int res = 0;
+            do {
+                if (c < '0' || c > '9') throw new InputMismatchException();
+                res *= 10;
+                res += c - '0';
+                c = read();
+            }
+            while (!isSpaceChar(c));
+            return res * sgn;
+        }
+
+        public String next() {
+            int c = read();
+            while (isSpaceChar(c)) c = read();
+            StringBuilder res = new StringBuilder();
+            do {
+                res.appendCodePoint(c);
+                c = read();
+            } while (!isSpaceChar(c));
+            return res.toString();
+        }
+
+        public boolean isSpaceChar(int c) {
+            if (filter != null) return filter.isSpaceChar(c);
+            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
+        }
+
+        public interface SpaceCharFilter {
+            public boolean isSpaceChar(int ch);
+
+        }
+
+    }
+}
+
+
+",0
+7686c854,abd16ff0,"import java.util.*;
+import java.util.function.BiFunction;
+import java.util.function.Function;
+import java.util.function.IntToLongFunction;
+import java.lang.*;
+import java.io.*;
+import java.math.*;
+public final class CF
+{
+     public static void main(String[]args)throws IOException
+    {
+        FastReader ob=new FastReader();
+        int t=ob.nextInt();
+        StringBuffer sb=new StringBuffer();
+        while(t-->0)
+        {
+            int n=ob.nextInt();
+            PriorityQueue<Long> a=new PriorityQueue<>();
+            PriorityQueue<Long> b=new PriorityQueue<>();
+            long ans=Long.MAX_VALUE;
+            long sum=0;
+            for(int i=0;i<n;i++)
+            {
+               long x=ob.nextInt();
+               if(i%2==0)
+               a.add(x);
+               else
+               b.add(x);  
+               sum+=x;
+               if(i!=0)
+               ans=Math.min(ans,sum+(a.peek()*(n-a.size()))+(b.peek()*(n-b.size())));
+            }
+            
+            sb.append(ans+""\n"");
+        }
+        System.out.println(sb);
+    }
+}
+class Pair implements Comparable<Pair>
+{
+    int x,y;
+    Pair(int x,int y)
+    {
+        this.x=x;
+        this.y=y;
+    }
+    @Override
+    public int compareTo(Pair a) {
+        return a.y-y;
+    }
+}
+class FastReader {
+    BufferedReader br;
+    StringTokenizer st;
+    public FastReader() {
+        br = new BufferedReader(new InputStreamReader(System.in));
+    }
+
+    public String next() {
+        while (st == null || !st.hasMoreElements()) {
+            try {
+                st = new StringTokenizer(br.readLine());
+            } catch (IOException e)  {
+                e.printStackTrace();
+            }
+        }
+        return st.nextToken();
+    }
+    public String nextLine()
+    {
+        String s="""";
+        try {
+        s=br.readLine();
+        } catch (IOException e)  {
+                e.printStackTrace();
+            }
+        return s;
+    }
+    public int nextInt() {
+        return Integer.parseInt(next());
+    }
+    public long nextLong() {
+        return Long.parseLong(next());
+    }
+    public double nextDouble() {
+        return Double.parseDouble(next());
+    }
+}
+","import java.util.*;
+
+public class Solve{
+
+    public static void main(String[] args){
+        Scanner sc=new Scanner(System.in);
+        int t=sc.nextInt();
+       
+       
+        while(t-->0){
+            int n=sc.nextInt();
+           long ans=Long.MAX_VALUE;
+           long pre=0;
+           PriorityQueue<Long> epq=new PriorityQueue<>();
+           PriorityQueue<Long> opq=new PriorityQueue<>();
+           for(int i=0;i<n;i++){
+               long a=sc.nextInt();
+               if(i%2==0)opq.add(a);
+               else epq.add(a);
+               pre+=a;
+              if(i>0) ans=Math.min(ans,pre+opq.peek()*(n-opq.size())+epq.peek()*(n-epq.size()));
+               
+           }
+          System.out.println(ans);
+        }
+    }
+}",1
+29cb9b0e,d3da65ff,"import java.util.*;
+public class Main
+{
+  
+    public static void solve (int ar[],int n)
+    {
+       if(n%2==1)
+        {
+    
+           
+            int c=ar[2];
+            int b=ar[1];
+            int a=ar[0];
+            if(a+b!=0)
+            {
+               ar[2]=-(a+b);
+               ar[1]=c;
+               ar[0]=c;
+            }
+            else if(b+c!=0)
+            {
+                 ar[2]=a;
+               ar[1]=a;
+               ar[0]=-(b+c);
+            }
+            else
+            {
+                 ar[2]=b;
+               ar[1]=-(a+c);
+               ar[0]=b;
+            }
+            System.out.print(ar[0]+"" ""+ar[1]+"" ""+ar[2]+"" "");
+           for(int i=3;i<(n);i=i+2)
+           {
+               System.out.print((-ar[i+1])+"" ""+ar[i]+"" "");
+           } 
+            System.out.println();
+        }
+          //  System.out.println(ans[n-1]+ "" x""+ans[n-2]+"" x""+ans[n-3]);
+           
+          else
+          {
+              for(int i=0;i<(n);i=i+2)
+           {
+               System.out.print((-ar[i+1])+"" ""+ar[i]+"" "");
+           }  
+            System.out.println();
+          }
+          
+           
+        
+    }
+	public static void main(String[] args) {
+		Scanner sc=new Scanner(System.in);int t=sc.nextInt();
+		while(t-->0)
+		{
+		    int n=sc.nextInt();
+		   int ar[]=new int[n];
+		   for(int i=0;i<n;i++)
+		   ar[i]=sc.nextInt();
+		   solve(ar,n);
+		}
+	}
+}
+","import java.util.*;
+public class Main
+{
+  
+    public static void solve (int ar[],int n)
+    {
+       if(n%2==1)
+        {
+    
+           
+            int c=ar[2];
+            int b=ar[1];
+            int a=ar[0];
+            if(a+b!=0)
+            {
+               ar[2]=-(a+b);
+               ar[1]=c;
+               ar[0]=c;
+            }
+            else if(b+c!=0)
+            {
+                 ar[2]=a;
+               ar[1]=a;
+               ar[0]=-(b+c);
+            }
+            else
+            {
+                 ar[2]=b;
+               ar[1]=-(a+c);
+               ar[0]=b;
+            }
+            System.out.print(ar[0]+"" ""+ar[1]+"" ""+ar[2]+"" "");
+           for(int i=3;i<(n);i=i+2)
+           {
+               System.out.print((-ar[i+1])+"" ""+ar[i]+"" "");
+           } 
+            System.out.println();
+        }
+          //  System.out.println(ans[n-1]+ "" x""+ans[n-2]+"" x""+ans[n-3]);
+           
+          else
+          {
+              for(int i=0;i<(n);i=i+2)
+           {
+               System.out.print((-ar[i+1])+"" ""+ar[i]+"" "");
+           }  
+            System.out.println();
+          }
+          
+           
+        
+    }
+	public static void main(String[] args) {
+		Scanner sc=new Scanner(System.in);int t=sc.nextInt();
+		while(t-->0)
+		{
+		    int n=sc.nextInt();
+		   int ar[]=new int[n];
+		   for(int i=0;i<n;i++)
+		   ar[i]=sc.nextInt();
+		   solve(ar,n);
+		}
+	}
+}
+",1
+45b19e51,f9adc043,"import java.util.*;
+import java.io.*;
+
+public class Main {
+    static FastScanner sc = new FastScanner(System.in);
+    static PrintWriter pw = new PrintWriter(System.out);
+    static StringBuilder sb = new StringBuilder();
+    static long mod = (long) 1e9 + 7;
+
+    public static void main(String[] args) throws Exception {
+        int n = sc.nextInt();
+        for(int i = 0; i < n; i++) solve();
+        pw.flush();
+    }
+
+    public static void solve() {
+        int n = sc.nextInt();
+        long[] a = sc.nextLongArray(n);
+        long left = 1;
+        long right = (long)1e9;
+        long[] dec = new long[2];
+        while(right-left > 1){
+            long mid = (right+left)/2L;
+            dec[0] = dec[1] = 0;
+            boolean ok = true;
+            for(int i = n-1; i >= 2; i--){
+                long a1 = a[i] + dec[1];
+                if(a1 < mid){
+                    ok = false;
+                    break;
+                }
+                long d = (Math.min(a[i],a1-mid))/3L;
+                dec[1] = dec[0]+d;
+                dec[0] = d*2;
+                //pw.println(dec[0] + "" "" + dec[1] + "" "" + mid + "" "" + d);
+            }
+            if(ok && a[0]+dec[0] >= mid && a[1]+dec[1] >= mid){
+                left = mid;
+            }else{
+                right = mid;
+            }
+            /*
+            for(int i = 2; i < n; i++){
+                long a1 = a[i-2]-dec[0];
+                long a2 = a[i-1]-dec[1];
+                long d = Math.max(0,(mid-a1+1)/2L);
+                if(d*3 > a[i]){
+                    if(i != 0){
+                        a[i] = 
+                    }
+                    ok = false;
+                    break;
+                }else{
+                    dec[0] = dec[1] - d;
+                    dec[1] = d*3;
+                }
+                //pw.println(dec[0] + "" "" + dec[1] + "" "" + mid);
+            }
+            if(ok && a[n-1]-dec[1] >= mid){
+                left = mid;
+            }else{
+                right = mid;
+            }
+            */
+        }
+        pw.println(left);
+    }
+
+    static class GeekInteger {
+        public static void save_sort(int[] array) {
+            shuffle(array);
+            Arrays.sort(array);
+        }
+
+        public static int[] shuffle(int[] array) {
+            int n = array.length;
+            Random random = new Random();
+            for (int i = 0, j; i < n; i++) {
+                j = i + random.nextInt(n - i);
+                int randomElement = array[j];
+                array[j] = array[i];
+                array[i] = randomElement;
+            }
+            return array;
+        }
+
+        public static void save_sort(long[] array) {
+            shuffle(array);
+            Arrays.sort(array);
+        }
+
+        public static long[] shuffle(long[] array) {
+            int n = array.length;
+            Random random = new Random();
+            for (int i = 0, j; i < n; i++) {
+                j = i + random.nextInt(n - i);
+                long randomElement = array[j];
+                array[j] = array[i];
+                array[i] = randomElement;
+            }
+            return array;
+        }
+
+    }
+}
+
+class FastScanner {
+    private BufferedReader reader = null;
+    private StringTokenizer tokenizer = null;
+
+    public FastScanner(InputStream in) {
+        reader = new BufferedReader(new InputStreamReader(in));
+        tokenizer = null;
+    }
+
+    public FastScanner(FileReader in) {
+        reader = new BufferedReader(in);
+        tokenizer = null;
+    }
+
+    public String next() {
+        if (tokenizer == null || !tokenizer.hasMoreTokens()) {
+            try {
+                tokenizer = new StringTokenizer(reader.readLine());
+            } catch (IOException e) {
+                throw new RuntimeException(e);
+            }
+        }
+        return tokenizer.nextToken();
+    }
+
+    public String nextLine() {
+        if (tokenizer == null || !tokenizer.hasMoreTokens()) {
+            try {
+                return reader.readLine();
+            } catch (IOException e) {
+                throw new RuntimeException(e);
+            }
+        }
+        return tokenizer.nextToken(""\n"");
+    }
+
+    public long nextLong() {
+        return Long.parseLong(next());
+    }
+
+    public int nextInt() {
+        return Integer.parseInt(next());
+    }
+
+    public double nextDouble() {
+        return Double.parseDouble(next());
+    }
+
+    public String[] nextArray(int n) {
+        String[] a = new String[n];
+        for (int i = 0; i < n; i++)
+            a[i] = next();
+        return a;
+    }
+
+    public int[] nextIntArray(int n) {
+        int[] a = new int[n];
+        for (int i = 0; i < n; i++)
+            a[i] = nextInt();
+        return a;
+    }
+
+    public long[] nextLongArray(int n) {
+        long[] a = new long[n];
+        for (int i = 0; i < n; i++)
+            a[i] = nextLong();
+        return a;
+    }
+}
+","import java.util.*;
+import java.io.*;
+
+public class C {
+	public static void main(String[] args) throws IOException {
+		FastScanner in = new FastScanner(System.in);
+		PrintWriter out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
+		int bruh = in.nextInt();
+
+		for (int cases = 0; cases < bruh; cases++) {
+			int n = in.nextInt();
+			long lo = (int) 1e9, hi = 0;
+			long [] a = new long[n];
+			
+			for (int i = 0; i < n; i++) {
+				a[i] = in.nextInt();
+				lo = Math.min(lo, a[i]);
+				hi = Math.max(hi, a[i]);
+			}
+			
+			long m = 0;
+			//System.out.println(Arrays.toString(a));
+			
+			while (lo <= hi) {
+				m = (lo + hi) / 2;
+				if (works(a, m)) {
+					lo = m + 1;
+				}
+				else {
+					hi = m - 1;
+				}
+			}
+			
+			out.println(hi);
+		}
+
+		out.close();
+
+	}
+
+
+	static boolean works(long[] a, long m) {
+		long[] d = Arrays.copyOf(a, a.length);
+		
+		for (int i = a.length - 1; i > 1; i--) {
+			if (d[i] < m) {
+				//System.out.println(m + "":x"" + Arrays.toString(d));
+				return false;
+			}
+			long canGive = (d[i] - m) / 3 * 3;
+			canGive = Math.min(canGive, a[i]);
+			d[i - 1] += canGive / 3;
+			d[i - 2] += canGive / 3 * 2;
+			d[i] -= canGive;
+		}
+		
+		//System.out.println(m + "": "" + Arrays.toString(d));
+		
+		if (d[0] < m || d[1] < m) return false;
+		return true;
+	}
+	
+	static class FastScanner {
+		BufferedReader br;
+		StringTokenizer st;
+		public FastScanner(InputStream i) {
+			br = new BufferedReader(new InputStreamReader(i));
+			st = new StringTokenizer("""");
+		}
+		public String next() throws IOException {
+			if (st.hasMoreTokens()) {
+				return st.nextToken();
+			}
+			else
+				st = new StringTokenizer(br.readLine());
+			return next();
+		}
+		public int nextInt() throws IOException {
+			return Integer.parseInt(next());
+		}
+		public double nextDouble() throws IOException {
+			return Double.parseDouble(next());
+		}
+		public long nextLong() throws IOException {
+			return Long.parseLong(next());
+		}
+		public String nextLine() throws IOException {
+			if (!st.hasMoreTokens()) {
+				st = new StringTokenizer(br.readLine());
+				return nextLine();
+			}
+
+			String ret = """";
+			while (st.hasMoreTokens()) {
+				ret += "" "" + st.nextToken();
+			}
+			return ret.substring(1);
+		}
+		public int[] nextIntArr(int size) throws IOException {
+			int[] arr = new int[size];
+			for (int i = 0; i < arr.length; i++) {
+				arr[i] = nextInt();
+			}
+			return arr;
+		}
+		public long[] nextLongArr(int size) throws IOException {
+			long[] arr = new long[size];
+			for (int i = 0; i < arr.length; i++) {
+				arr[i] = nextLong();
+			}
+			return arr;
+		}
+		public double[] nextDoubleArr(int size) throws IOException {
+			double[] arr = new double[size];
+			for (int i = 0; i < arr.length; i++) {
+				arr[i] = nextDouble();
+			}
+			return arr;
+		}
+	}
+}",0
+3cbcb1cc,6045e5d1,"
+import java.util.*;
+import java.lang.*;
+import java.io.*;
+
+public class E {
+
+	public static void main(String[] args) throws Exception {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		int t = Integer.parseInt(br.readLine());
+		br.readLine();
+		StringBuilder sb = new StringBuilder();
+		while (t-- > 0) {
+			String[] scn = (br.readLine()).trim().split("" "");
+			int n = Integer.parseInt(scn[0]);
+			int m = Integer.parseInt(scn[1]);
+			long[] land = new long[n + 1];
+			scn = (br.readLine()).trim().split("" "");
+			String[] scn1 = (br.readLine()).trim().split("" "");
+			for (int i = 0; i < m; i++) {
+				int idx = (int) Long.parseLong(scn[i]);
+				long temp = Long.parseLong(scn1[i]);
+				land[idx] = temp;
+			}
+			long[] ans = new long[n + 1];
+			long min = (long) (1e15);
+			for (int i = 1; i <= n; i++) {
+				if (land[i] != 0) {
+					min = Math.min(min, land[i]);
+				}
+				ans[i] = min;
+				min += 1;
+			}
+			min = (long) (1e15);
+			for (int i = n; i >= 1; i--) {
+				if (land[i] != 0) {
+					min = Math.min(min, land[i]);
+				}
+				ans[i] = Math.min(min, ans[i]);
+				min += 1;
+			}
+			for (int i = 1; i <= n; i++) {
+				sb.append(ans[i] + "" "");
+			}
+			sb.append(""\n"");
+			if (t != 0) {
+				br.readLine();
+			}
+		}
+		System.out.println(sb);
+		return;
+
+	}
+
+	public static void sort(long[] arr) {
+		int n = arr.length;
+		for (int i = 0; i < n; i++) {
+			int idx = (int) (Math.random() * n);
+			long temp = arr[i];
+			arr[i] = arr[idx];
+			arr[idx] = temp;
+		}
+		Arrays.sort(arr);
+	}
+
+	public static void sort(int[] arr) {
+		int n = arr.length;
+		for (int i = 0; i < n; i++) {
+			int idx = (int) (Math.random() * n);
+			int temp = arr[i];
+			arr[i] = arr[idx];
+			arr[idx] = temp;
+		}
+		Arrays.sort(arr);
+	}
+
+	public static void print(long[][] dp) {
+		for (long[] a : dp) {
+			for (long ele : a) {
+				System.out.print(ele + "" "");
+			}
+			System.out.println();
+		}
+	}
+
+	public static void print(int[][] dp) {
+		for (int[] a : dp) {
+			for (int ele : a) {
+				System.out.print(ele + "" "");
+			}
+			System.out.println();
+		}
+	}
+
+	public static void print(int[] dp) {
+		for (int ele : dp) {
+			System.out.print(ele + "" "");
+		}
+		System.out.println();
+	}
+
+	public static void print(long[] dp) {
+		for (long ele : dp) {
+			System.out.print(ele + "" "");
+		}
+		System.out.println();
+	}
+
+}
+
+","
+import java.util.*;
+import java.lang.*;
+import java.io.*;
+
+public class E {
+
+	public static void main(String[] args) throws Exception {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		int t = Integer.parseInt(br.readLine());
+		br.readLine();
+		StringBuilder sb = new StringBuilder();
+		while (t-- > 0) {
+			String[] scn = (br.readLine()).trim().split("" "");
+			int n = Integer.parseInt(scn[0]);
+			int m = Integer.parseInt(scn[1]);
+			long[] land = new long[n + 1];
+			scn = (br.readLine()).trim().split("" "");
+			String[] scn1 = (br.readLine()).trim().split("" "");
+			for (int i = 0; i < m; i++) {
+				int idx = (int) Long.parseLong(scn[i]);
+				long temp = Long.parseLong(scn1[i]);
+				land[idx] = temp;
+			}
+			long[] ans = new long[n + 1];
+			long min = (long) (1e15);
+			for (int i = 1; i <= n; i++) {
+				if (land[i] != 0) {
+					min = Math.min(min, land[i]);
+				}
+				ans[i] = min;
+				min += 1;
+			}
+			min = (long) (1e15);
+			for (int i = n; i >= 1; i--) {
+				if (land[i] != 0) {
+					min = Math.min(min, land[i]);
+				}
+				ans[i] = Math.min(min, ans[i]);
+				min += 1;
+			}
+			for (int i = 1; i <= n; i++) {
+				sb.append(ans[i] + "" "");
+			}
+			sb.append(""\n"");
+			if (t != 0) {
+				br.readLine();
+			}
+		}
+		System.out.println(sb);
+		return;
+
+	}
+
+	public static void sort(long[] arr) {
+		int n = arr.length;
+		for (int i = 0; i < n; i++) {
+			int idx = (int) (Math.random() * n);
+			long temp = arr[i];
+			arr[i] = arr[idx];
+			arr[idx] = temp;
+		}
+		Arrays.sort(arr);
+	}
+
+	public static void sort(int[] arr) {
+		int n = arr.length;
+		for (int i = 0; i < n; i++) {
+			int idx = (int) (Math.random() * n);
+			int temp = arr[i];
+			arr[i] = arr[idx];
+			arr[idx] = temp;
+		}
+		Arrays.sort(arr);
+	}
+
+	public static void print(long[][] dp) {
+		for (long[] a : dp) {
+			for (long ele : a) {
+				System.out.print(ele + "" "");
+			}
+			System.out.println();
+		}
+	}
+
+	public static void print(int[][] dp) {
+		for (int[] a : dp) {
+			for (int ele : a) {
+				System.out.print(ele + "" "");
+			}
+			System.out.println();
+		}
+	}
+
+	public static void print(int[] dp) {
+		for (int ele : dp) {
+			System.out.print(ele + "" "");
+		}
+		System.out.println();
+	}
+
+	public static void print(long[] dp) {
+		for (long ele : dp) {
+			System.out.print(ele + "" "");
+		}
+		System.out.println();
+	}
+
+}
+",1
+46e9aed4,8ddb5587,"
+import java.util.*;
+
+import java.lang.*;
+import java.io.*;
+
+/* Name of the class has to be ""Main"" only if the class is public. */
+public final class Solution {
+    
+
+    public static void main(String[] args) throws Exception {
+        
+        Reader sc = new Reader();
+        BufferedWriter op = new BufferedWriter(new OutputStreamWriter(System.out));
+         
+         int n=sc.nextInt();
+          ArrayList<Integer> fill= new ArrayList<Integer>();
+          ArrayList<Integer> unfilled= new ArrayList<>();
+          for(int i=0;i<n;i++){
+              int x =sc.nextInt();
+              if(x==1){
+                  fill.add(i);
+              }else{
+                  unfilled.add(i);
+              }
+          }
+          Collections.sort(fill);
+          Collections.sort(unfilled);
+          
+          
+          long[][] dp =new long[fill.size()+1][unfilled.size()+1];
+           for(int i=0;i<fill.size()+1;i++){
+              for(int j=0;j<unfilled.size()+1;j++){
+                  dp[i][j]=Integer.MAX_VALUE;
+              }
+          }
+          for(int i=0;i<unfilled.size()+1;i++){
+              dp[0][i]=0;
+          }
+        //   for(int j=0;j<fill.size()+1;j++){
+        //       dp[j][0]=0;
+        //   }
+         
+
+          for(int i=1;i<fill.size()+1;i++){
+              for(int j=1;j<unfilled.size()+1;j++){
+                  dp[i][j]=Math.min(dp[i][j-1],dp[i-1][j-1]+Math.abs(fill.get(i-1)-unfilled.get(j-1)));
+              }
+          }
+          System.out.println(dp[fill.size()][unfilled.size()]);
+        //   for(int i=0;i<fill.size()+1;i++){
+        //       for(int j=0;j<unfilled.size()+1;j++)
+        //       {
+        //           System.out.print(dp[i][j]+"" "");
+        //       }
+        //       System.out.println();
+        //   }
+         
+    }
+
+
+
+
+   
+    }
+
+class Reader {
+    final private int BUFFER_SIZE = 1 << 16;
+    private DataInputStream din;
+    private byte[] buffer;
+    private int bufferPointer, bytesRead;
+
+    public Reader() {
+        din = new DataInputStream(System.in);
+        buffer = new byte[BUFFER_SIZE];
+        bufferPointer = bytesRead = 0;
+    }
+
+    public Reader(String file_name) throws IOException {
+        din = new DataInputStream(new FileInputStream(file_name));
+        buffer = new byte[BUFFER_SIZE];
+        bufferPointer = bytesRead = 0;
+    }
+
+    public String readLine() throws IOException {
+        byte[] buf = new byte[64]; // line length
+        int cnt = 0, c;
+        while ((c = read()) != -1) {
+            if (c == '\n') {
+                if (cnt != 0) {
+                    break;
+                } else {
+                    continue;
+                }
+            }
+            buf[cnt++] = (byte) c;
+        }
+        return new String(buf, 0, cnt);
+    }
+
+    public int nextInt() throws IOException {
+        int ret = 0;
+        byte c = read();
+        while (c <= ' ') {
+            c = read();
+        }
+        boolean neg = (c == '-');
+        if (neg)
+            c = read();
+        do {
+            ret = ret * 10 + c - '0';
+        } while ((c = read()) >= '0' && c <= '9');
+
+        if (neg)
+            return -ret;
+        return ret;
+    }
+
+    public long nextLong() throws IOException {
+        long ret = 0;
+        byte c = read();
+        while (c <= ' ')
+            c = read();
+        boolean neg = (c == '-');
+        if (neg)
+            c = read();
+        do {
+            ret = ret * 10 + c - '0';
+        } while ((c = read()) >= '0' && c <= '9');
+        if (neg)
+            return -ret;
+        return ret;
+    }
+
+    public double nextDouble() throws IOException {
+        double ret = 0, div = 1;
+        byte c = read();
+        while (c <= ' ')
+            c = read();
+        boolean neg = (c == '-');
+        if (neg)
+            c = read();
+
+        do {
+            ret = ret * 10 + c - '0';
+        } while ((c = read()) >= '0' && c <= '9');
+
+        if (c == '.') {
+            while ((c = read()) >= '0' && c <= '9') {
+                ret += (c - '0') / (div *= 10);
+            }
+        }
+
+        if (neg)
+            return -ret;
+        return ret;
+    }
+
+    private void fillBuffer() throws IOException {
+        bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
+        if (bytesRead == -1)
+            buffer[0] = -1;
+    }
+
+    private byte read() throws IOException {
+        if (bufferPointer == bytesRead)
+            fillBuffer();
+        return buffer[bufferPointer++];
+    }
+
+    public void close() throws IOException {
+        if (din == null)
+            return;
+        din.close();
+    }
+}
+
+","import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.StringTokenizer;
+ 
+public class taskd {
+    public static void main(String[] args) {
+        FastScanner in = new FastScanner();
+        PrintWriter out = new PrintWriter(System.out);
+        taskd sol = new taskd();
+        sol.solve(in, out);
+        out.flush();
+    }
+
+    void solve(FastScanner in, PrintWriter out) {
+        int n = in.nextInt();
+        ArrayList<Integer> a = new ArrayList<>();
+        ArrayList<Integer> b = new ArrayList<>();
+        for (int i = 0; i < n; i++) {
+            int x = in.nextInt();
+            if (x == 1) {
+                a.add(i);
+            } else {
+                b.add(i);
+            }
+        }
+
+        long dp[][] = new long[a.size() + 5][b.size() + 5];
+        for (int i = a.size()-1; i >= 0; i--) {
+            dp[i][b.size()] = Integer.MAX_VALUE;
+            for (int j = b.size()-1; j >= 0; j--) {
+                dp[i][j] = dp[i][j + 1];
+                dp[i][j] = Math.min(dp[i][j], Math.abs(a.get(i) - b.get(j)) + dp[i + 1][j + 1]);
+            }
+        }
+        out.println(dp[0][0]);
+    }
+
+    static class FastScanner {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st = new StringTokenizer("""");
+        String next() {
+            while (!st.hasMoreTokens()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+        int nextInt() { return Integer.parseInt(next()); }
+        long nextLong() { return Long.parseLong(next()); }
+        float nextFloat() { return Float.parseFloat(next()); }
+        double nextDouble() { return Double.parseDouble(next()); }
+    }
+}",0
+4da08761,c4ca2ff3,"import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.PrintWriter;
+import java.util.ArrayList;
+import java.util.Arrays;
+
+/**
+ * Built using CHelper plug-in
+ * Actual solution is at the top
+ */
+public class Solution {
+    public static void main(String[] args) {
+        InputStream inputStream = System.in;
+        OutputStream outputStream = System.out;
+        InputReader in = new InputReader(inputStream);
+        PrintWriter out = new PrintWriter(outputStream);
+        Main solver = new Main();
+        boolean multipleTC = true;
+        int testCount = multipleTC ? Integer.parseInt(in.next()) : 1;
+        for (int i = 1; i <= testCount; i++)
+            solver.solve(in, out, i);
+        out.close();
+    }
+    static class Main {
+        PrintWriter out;
+        InputReader in;
+
+        public void solve(InputReader in, PrintWriter out, int test) {
+            this.out = out;
+            this.in = in;
+            int n = ni();
+            String[] arr = new String[n];
+            int[][] freq = new int[n][5];
+            int[][] rem = new int[n][5];
+            for(int i = 0; i < n; i++){
+                arr[i] = n();
+                for(int j = 0; j < arr[i].length(); j++)
+                    freq[i][arr[i].charAt(j) - 'a']++;
+                for(int j = 0; j < 5; j++)
+                    rem[i][j] = arr[i].length() - freq[i][j];
+            }
+            int ans = 0;
+            for(int i = 0; i < 5; i++){
+                int[] vals = new int[n];
+                for(int j = 0; j < n; j++)
+                    vals[j] = freq[j][i] - rem[j][i];
+                Arrays.sort(vals);
+                int sum = 0, x = 0;
+                for(int j = n - 1; j >= 0; j--){
+                    if(sum + vals[j] > 0){
+                        x++;
+                        sum += vals[j];
+                    } else {
+                        break;
+                    }
+                }
+                if(x > ans) {
+                    ans = x;
+                }
+            }
+            pn(ans);
+        }
+
+        int gcd(int a, int b)
+        {
+            if (a == 0)
+                return b;
+
+            return gcd(b%a, a);
+        }
+
+
+        String n(){
+            return in.next();
+        }
+
+        int ni() {
+            return in.nextInt();
+        }
+
+        long nl() {
+            return in.nextLong();
+        }
+
+        void pn(long zx) {
+            out.println(zx);
+        }
+
+        void pn(String sz) {
+            out.println(sz);
+        }
+
+        void pn(double dx){
+            out.println(dx);
+        }
+
+        class Tuple {
+            long x;
+            long y;
+
+            Tuple(long a, long b) {
+                x = a;
+                y = b;
+            }
+        }
+
+    }
+
+    static class InputReader {
+        private InputStream stream;
+        private byte[] buf = new byte[1024];
+        private int curChar;
+        private int numChars;
+
+        public InputReader(InputStream stream) {
+            this.stream = stream;
+        }
+
+        public int read() {
+            if (numChars == -1) {
+                throw new UnknownError();
+            }
+            if (curChar >= numChars) {
+                curChar = 0;
+                try {
+                    numChars = stream.read(buf);
+                } catch (IOException e) {
+                    throw new UnknownError();
+                }
+                if (numChars <= 0) {
+                    return -1;
+                }
+            }
+            return buf[curChar++];
+        }
+
+        public int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        public long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        public String next() {
+            int c = read();
+            while (isSpaceChar(c)) {
+                c = read();
+            }
+            StringBuffer res = new StringBuffer();
+            do {
+                res.appendCodePoint(c);
+                c = read();
+            } while (!isSpaceChar(c));
+
+            return res.toString();
+        }
+
+        private boolean isSpaceChar(int c) {
+            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
+        }
+
+    }
+}","/* package codechef; // don't place package name! */
+
+import java.util.*;
+import java.lang.*;
+import java.io.*;
+
+/* Name of the class has to be ""Main"" only if the class is public. */
+public class Main
+{
+	public static void main (String[] args) throws java.lang.Exception
+	{
+		// your code goes here
+		Scanner sc=new Scanner(System.in);
+		int t=sc.nextInt();
+		PrintWriter out=new PrintWriter(System.out);
+		while(t-->0) {
+		    int n=sc.nextInt();
+		    int freq[][]=new int[n][5];
+		    int rem[][]=new int[n][5];
+		    for(int i=0;i<n;i++) {
+		        String str=sc.next();
+		        
+		        for(int j=0;j<str.length();j++) {
+		            freq[i][str.charAt(j)-'a']++;
+		        }
+		        for(int k=0;k<5;k++) {
+		            rem[i][k]=str.length()-freq[i][k];
+		        }
+		    }
+		    
+		    int ans=0;
+		    for(int i=0;i<5;i++) {
+		        int arr[]=new int[n];
+		        for(int j=0;j<n;j++)
+		        arr[j]=freq[j][i]-rem[j][i];
+		        
+		        Arrays.sort(arr);
+		        int total=0;
+		        int sum=0;
+		        for(int k=n-1;k>=0;k--) {
+		            if(sum+arr[k]>0) {
+		                sum=sum+arr[k];
+		                total++;
+		            }
+		            else {
+		                break;
+		            }
+		        }
+		        ans=Math.max(ans,total);
+		    }
+		    out.println(ans);
+		    
+		}
+		out.flush();
+		out.close();
+	}
+}
+
+",1
+530f01c2,f41057db,"/* package codechef; // don't place package name! */
+
+import java.util.*;
+import java.lang.*;
+import java.io.*;
+
+/* Name of the class has to be ""Main"" only if the class is public. */
+public class Codechef
+{
+	public static void main (String[] args) throws java.lang.Exception
+	{
+		Scanner sc = new Scanner(System.in);
+		PrintWriter out = new PrintWriter(System.out);
+		int T = sc.nextInt();
+		for(int t = 0; t<T; t++){
+		    int n = sc.nextInt(), aS = sc.nextInt() - 1, bS = sc.nextInt() - 1, aDis = sc.nextInt(), bDis = sc.nextInt();
+		    Node nodes[] = new Node[n];
+		    for(int i = 0; i<n; i++)nodes[i] = new Node();
+		    for(int i = 0; i<n - 1; i++){
+		        int g = sc.nextInt() - 1, h = sc.nextInt() - 1;
+		        nodes[g].adj.add(nodes[h]); nodes[h].adj.add(nodes[g]);
+		    }
+		    if(aDis * 2 >= bDis){
+		        out.println(""Alice""); continue;
+		    }
+		    BFS(nodes, nodes[bS]);
+		    if (nodes[aS].dis<=aDis) {
+				//alice wins in one move
+				out.println(""Alice"");
+				continue;
+			}
+			Node farthest=farthest(nodes);
+			BFS(nodes, farthest);
+			farthest=farthest(nodes);
+			int farDist = farthest.dis;
+		    if(farDist <= aDis * 2)out.println(""Alice"");
+		    else out.println(""Bob"");
+		}
+		out.flush();
+	}
+	static Node farthest(Node[] nodes){
+	    Node ans = nodes[0];
+	    for(Node nn: nodes){
+	        if(nn.dis > ans.dis)ans = nn;
+	    }
+	    return ans;
+	}
+	static void BFS(Node nodes[], Node prev){
+	    for (Node nn:nodes) nn.dis=-1;
+	    Queue<Node> queue = new LinkedList();
+	    queue.add(prev);
+	    prev.dis = 0;
+	    while(!queue.isEmpty()){
+	        Node par = queue.poll();
+	        for(Node c: par.adj){
+	            if(c.dis == -1){
+	                c.dis = par.dis + 1;
+	                queue.add(c);
+	            }
+	        }
+	    }
+	}
+	static class Node{
+	    List<Node> adj = new ArrayList();
+	    int dis = -1;
+	}
+}
+","import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.util.ArrayDeque;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.StringTokenizer;
+
+public class Solution{
+	
+
+	public static void main(String[] args) throws Exception{
+
+		FastScanner fs = new FastScanner();
+		PrintWriter out = new PrintWriter(System.out);
+		
+		int tt = fs.nextInt();
+		
+		while(tt-->0) {
+			
+			int n = fs.nextInt(), aStart = fs.nextInt()-1, bStart = fs.nextInt()-1, aMove = fs.nextInt(), bMove = fs.nextInt();
+			
+			Node[] nodes = new Node[n];
+			for(int i=0;i<n;i++) {
+				nodes[i] = new Node();
+			}
+			
+			for(int i=0;i<n-1;i++) {
+				int u = fs.nextInt()-1, v = fs.nextInt()-1;
+				nodes[u].adjList.add(nodes[v]);
+				nodes[v].adjList.add(nodes[u]);
+			}
+			
+			if(2*aMove>=bMove) {
+				out.println(""Alice"");
+				continue;
+			}
+			
+			bfs(nodes,nodes[aStart]);
+			
+			if(nodes[bStart].dis<=aMove) {
+				out.println(""Alice"");
+				continue;
+			}
+			
+			Node fNode = farthest(nodes);
+			bfs(nodes, fNode);
+			fNode = farthest(nodes);
+			
+			
+			if(fNode.dis>=2*aMove+1) {
+				out.println(""Bob"");
+			}
+			else {
+				out.println(""Alice"");
+			}
+			
+		}
+		
+
+		out.close();
+	}
+	
+	static Node farthest(Node[] nodes) {
+		Node fNode = nodes[0];
+		for(Node n: nodes) {
+			if(n.dis>fNode.dis) {
+				fNode = n;
+			}
+		}
+		return fNode;
+	}
+	
+	static void bfs(Node[] nodes, Node start) {
+		for(Node n: nodes) n.dis = -1;
+		start.dis = 0;
+		ArrayDeque<Node> queue = new ArrayDeque<Node>();
+		queue.add(start);
+		while(!queue.isEmpty()) {
+			Node n = queue.remove();
+			for(Node node: n.adjList) {
+				if(node.dis==-1) {
+					node.dis = n.dis + 1;
+					queue.add(node);
+				}
+			}
+		}
+	}
+	
+	static class Node{
+		LinkedList<Node> adjList = new LinkedList<Node>();
+		int dis = -1;
+	}
+	
+	
+	
+	
+	static class FastScanner{
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st = new StringTokenizer("""");
+
+		public String next(){
+			while(!st.hasMoreElements()){
+				try{
+					st = new StringTokenizer(br.readLine());
+				} catch(IOException e){
+					e.printStackTrace();
+				}
+			}
+			return st.nextToken();
+		}
+		
+		public String nextLine() throws IOException {
+			return br.readLine();
+		}
+		
+		public int nextInt(){
+			return Integer.parseInt(next());
+		}
+
+		public int[] readArray(int n){
+			int[] a = new int[n];
+			for(int i=0;i<n;i++)
+				a[i] = nextInt();
+			return a;
+		}
+		
+		public long nextLong() {
+			return Long.parseLong(next());
+		}
+	}
+	
+	
+	static int lowerBound(int[] arr, int l, int r, int k) {
+		while(r>l) {
+			int mid = (l+r)/2;
+			if(arr[mid]>=k) {
+				r = mid;
+			}
+			else {
+				l = mid+1;
+			}
+		}
+		if(arr[l]<k)
+			return -1;
+		return l;
+	}
+	
+	
+	
+	static int upperBound(int[] arr, int l, int r, int k) {
+		while(r>l) {
+			int mid = (l+r)/2;
+			if(arr[mid]>k) {
+				r = mid;
+			}
+			else {
+				l = mid+1;
+			}
+		}
+		if(arr[l]<=k)
+			return -1;
+		return l;
+	}
+	
+	static long gcd(long a,long b) {
+		return (b==0)?a:gcd(b,a%b);
+	}
+
+}",1
+ac180326,d1cd194e,"//This code is written by प्रविण शंखपाळ 
+
+//package wizard;
+
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.text.DecimalFormat;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.Arrays;
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.Stack;
+import java.util.Queue;
+import java.util.PriorityQueue;
+import java.util.List;
+import java.util.HashSet;
+import java.util.LinkedHashSet;
+import java.util.TreeSet;
+import java.util.Map;
+import java.util.HashMap;
+import java.util.Scanner;
+import java.util.Set;
+import java.util.StringTokenizer;
+import java.util.Vector;
+
+public class Dobby {
+
+	public static void main(String[] args) {
+
+		try {
+
+			FastReader fr = new FastReader();
+			PrintWriter pt = new PrintWriter(System.out);
+
+			int t = fr.nextInt();
+
+			while (t > 0) {
+
+				int n = fr.nextInt(), m = fr.nextInt(), x = fr.nextInt();
+
+				ArrayList<Pair> pp = new ArrayList<>();
+
+				int A[] = new int[n];
+
+				for (int i = 0; i < n; i++) {
+					A[i] = fr.nextInt();
+					Pair pr = new Pair(A[i], i);
+					pp.add(pr);
+				}
+
+				Collections.sort(pp);
+				Collections.reverse(pp);
+
+				int ps[] = new int[n];
+				int pk[] = new int[n];
+				Arrays.fill(ps, 0);
+				Arrays.fill(pk, 0);
+
+				int index = 0;
+
+				for (int i = 0; i < n; i++) {
+
+					if (pk[index] < x) {
+						pk[index] += pp.get(i).a;
+					}
+					ps[pp.get(i).b] = index + 1;
+					index++;
+
+					index = index == m ? 0 : index;
+
+				}
+
+				pt.println(""YES"");
+
+				for (int i = 0; i < n; i++) {
+					pt.print(ps[i] + "" "");
+				}
+				pt.println();
+
+				t--;
+			}
+
+			pt.close();
+
+		} catch (
+
+		Exception e) {
+			return;
+		}
+	}
+
+	static void merge(long arr[], int l, int m, int r) {
+
+		int n1 = m - l + 1;
+		int n2 = r - m;
+
+		long L[] = new long[n1];
+		long R[] = new long[n2];
+
+		for (int i = 0; i < n1; ++i)
+			L[i] = arr[l + i];
+		for (int j = 0; j < n2; ++j)
+			R[j] = arr[m + 1 + j];
+
+		int i = 0, j = 0;
+
+		int k = l;
+		while (i < n1 && j < n2) {
+			if (L[i] <= R[j]) {
+				arr[k] = L[i];
+				i++;
+			} else {
+				arr[k] = R[j];
+				j++;
+			}
+			k++;
+		}
+
+		while (i < n1) {
+			arr[k] = L[i];
+			i++;
+			k++;
+		}
+
+		while (j < n2) {
+			arr[k] = R[j];
+			j++;
+			k++;
+		}
+	}
+
+	static void sort(long arr[], int l, int r) {
+		if (l < r) {
+
+			int m = l + (r - l) / 2;
+
+			sort(arr, l, m);
+			sort(arr, m + 1, r);
+
+			merge(arr, l, m, r);
+		}
+	}
+
+	static class Pair implements Comparable<Pair> {
+		int a, b;
+
+		Pair(int a, int b) {
+			this.a = a;
+			this.b = b;
+		}
+
+		public int compareTo(Pair o) {
+			// TODO Auto-generated method stub
+			if (this.a != o.a)
+				return Integer.compare(this.a, o.a);
+			else
+				return Integer.compare(this.b, o.b);
+			// return 0;
+		}
+
+		public boolean equals(Object o) {
+			if (o instanceof Pair) {
+				Pair p = (Pair) o;
+				return p.a == a && p.b == b;
+			}
+			return false;
+		}
+
+	}
+
+	static int binarySearch(int arr[], int first, int last, int key) {
+		int mid = (first + last) / 2;
+		while (first <= last) {
+			if (arr[mid] < key) {
+				first = mid + 1;
+			} else if (arr[mid] == key) {
+				return mid;
+			} else {
+				last = mid - 1;
+			}
+			mid = (first + last) / 2;
+		}
+		return -1;
+	}
+
+	static class FastReader {
+		BufferedReader br;
+		StringTokenizer st;
+
+		public FastReader() {
+			br = new BufferedReader(new InputStreamReader(System.in));
+		}
+
+		String next() {
+			while (st == null || !st.hasMoreElements()) {
+				try {
+					st = new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			}
+			return st.nextToken();
+		}
+
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+
+		double nextDouble() {
+			return Double.parseDouble(next());
+		}
+
+		String nextLine() {
+			String str = """";
+			try {
+				str = br.readLine();
+			} catch (IOException e) {
+				e.printStackTrace();
+			}
+			return str;
+		}
+	}
+}
+","import java.util.*;
+
+import java.lang.*;
+import java.io.*;
+
+public class Template {
+	
+	static class FastReader {
+  BufferedReader br;
+  StringTokenizer st;
+
+  public FastReader()
+  {
+      br = new BufferedReader(
+          new InputStreamReader(System.in));
+  }
+
+  String next()
+  {
+      while (st == null ||!st.hasMoreElements()) {
+          try {
+              st = new StringTokenizer(br.readLine());
+          }
+          catch (IOException e) {
+              e.printStackTrace();
+          }
+      }
+      return st.nextToken();
+  }
+
+  int nextInt() { return Integer.parseInt(next()); }
+
+  long nextLong() { return Long.parseLong(next()); }
+
+  double nextDouble()
+  {
+      return Double.parseDouble(next());
+  }
+
+  String nextLine()
+  {
+      String str = """";
+      try {
+          str = br.readLine();
+      }
+      catch (IOException e) {
+          e.printStackTrace();
+      }
+      return str;
+  }
+  
+}
+	
+//	static void solve(String s) 
+//	{
+////		Scanner sc = new Scanner(System.in);
+////		String s = sc.next();
+//		
+//		int x[] = new int[2];
+//		x[0] = x[1] = -1;
+//		
+//		int ans = 0;
+//		int n = s.length();
+//		for(int i=0;i<n;i++)
+//		{
+//			int c = s.charAt(i) - '0';
+//			if(c == 1 || c == 0)
+//			{
+//				x[(i%2) ^ c] = i;
+//			}
+//			int min = Math.min(x[0], x[1]);
+//			ans += i - min;
+//			//System.out.println(ans);
+//		}
+//		System.out.println(ans);
+//	}
+//	
+
+//	    public static void main(String args[])
+//	    {
+//	    	FastReader sc = new FastReader();
+//	    	//solve();
+//	    	//Scanner sc = new Scanner(System.in)
+//	       int testcases = sc.nextInt();  // nTest is the number of treasure hunts.
+//	      
+////	    	int testcases = 3;
+//	        while(testcases-- > 0)
+//	        {
+//	        	String s = sc.next();
+//	        	solve(s);
+//	        	
+//	        }
+//	    
+//	    }
+	
+	static class Pair implements Comparable<Pair>
+	{
+		int h;
+		int ind;
+		
+		Pair(int h, int ind)
+		{
+			this.h = h;
+			this.ind = ind;
+		}
+		@Override
+		public int compareTo(Pair o) {
+			
+			return this.h - o.h;
+		}
+		
+		
+	}
+	public static void main(String[] args) {
+
+		FastReader fs=new FastReader();
+
+		int T=fs.nextInt();
+
+		for (int tt=0; tt<T; tt++) {
+		int n = fs.nextInt();
+		int m = fs.nextInt();
+		int x = fs.nextInt();
+		
+		if(n < m)
+		{
+			System.out.println(""NO"");
+			continue;
+		}
+		Pair a[] = new Pair[n];
+		PriorityQueue<Pair> heap = new PriorityQueue<>();
+		for(int i=0;i<n;i++)
+		{
+			a[i] = new Pair(fs.nextInt(), i);
+			
+		}
+		
+		Arrays.sort(a);
+		for(int i=1;i<=m;i++)
+		{
+			heap.add(new Pair(0, i));
+		}
+		int max = Integer.MIN_VALUE;
+		int min = Integer.MAX_VALUE;
+		int ans[] = new int[n];
+		int idx = 0;
+		while(!heap.isEmpty() && idx < n)
+		{
+			Pair curr = heap.poll();
+			curr.h += a[idx].h;
+			ans[a[idx].ind] = curr.ind;
+			heap.add(new Pair(curr.h,  curr.ind));
+			idx++;
+		}
+			
+		
+		
+//		int towers[] = new int[m+1];
+//		int tower = 1;
+//		boolean flag = false;
+//		boolean inc = true;
+//		for(int i=0;i<n;i++)
+//		{
+//			if(tower == m+1)
+//			{
+//				tower = m;
+//				inc = false;
+//			}
+//			if(tower == 0)
+//			{
+//				tower = 1;
+//				inc = true;
+//			}
+//			towers[tower] += a[i].h;
+//			System.out.println(a[i].h +"" THis"" + tower);
+////			min = Math.min(min, towers[tower]);
+////			max = Math.max(max, towers[tower]);
+//			ans[a[i].ind] = tower;
+////			if(Math.abs(max - min) > x)
+////			{
+////				System.out.println(""NO"" + a[i].ind+"" ""+a[i].h +"" ""+min +"" ""+max);
+////				flag = true;
+////				break;
+////			}
+//			if(inc)
+//				tower++;
+//			else
+//				tower--;
+//		}
+//		for(int i=1;i<=m;i++)
+//		{
+//			min = Math.min(min, towers[i]);
+//			max = Math.max(max, towers[i]);
+//		}
+//		if(Math.abs(max - min) > x)
+//			{
+//				System.out.println(""NO"" + max+"" ""+min);// + a[i].ind+"" ""+a[i].h +"" ""+min +"" ""+max);
+//				//flag = true;
+//				continue;
+//			}
+//		if(flag)
+//			continue;
+		System.out.println(""YES"");
+		for(int i:ans)
+			System.out.print(i+"" "");
+		
+		System.out.println();
+
+		}
+	
+}
+}
+",0
+8d9871a9,e431de28,"import java.util.*;
+
+public class Main {
+	static Scanner scan = new Scanner(System.in);
+
+	static int[] readArray(int[] x) {
+		for(int i=0; i<x.length; ++i) x[i] = scan.nextInt();
+		return x;
+	}
+
+	static long[] readArray(long[] x) {
+		for(int i=0; i<x.length; ++i) x[i] = scan.nextLong();
+		return x;
+	}
+
+
+	public static void go() {
+	}
+
+	public static void main(String[] args) {
+		int t = scan.nextInt();
+		for(int it=0; it<t; ++it) {
+			int n = scan.nextInt();
+			long[] aa = readArray(new long[n]);
+
+			long minEven = aa[0];
+			long minOdd = aa[1];
+			long sum = aa[0]+aa[1];
+			long best = n*minEven + n*minOdd;
+			int numOdd = 1;
+			int numEven = 1;
+			for(int i=2; i<n; ++i) {
+				if(i%2 == 0) {
+					minEven = Math.min(aa[i], minEven);
+					numEven++;
+				}else {
+					minOdd = Math.min(aa[i], minOdd);
+					numOdd++;
+				}
+				sum += aa[i];
+				long score = sum;
+				score += minEven*(n-numEven);
+				score += minOdd*(n-numOdd);				
+				best = Math.min(best, score);
+			}
+			System.out.println(best);
+		}
+	}
+}
+","import java.io.*;
+import java.lang.*;
+import java.util.*;
+public class MinGridPath {
+
+	public static void main(String[] args) {
+		// TODO Auto-generated method stub
+		Scanner s=new Scanner(System.in);
+		int t=s.nextInt();
+		while(t-->0){
+			
+			int n = s.nextInt();
+			long[] aa =new long[n];
+			for(int i=0;i<n;i++)
+				aa[i]=s.nextLong();
+ 
+			long minEven = aa[0];
+			long minOdd = aa[1];
+			long sum = aa[0]+aa[1];
+			long best = n*minEven + n*minOdd;
+			int numOdd = 1;
+			int numEven = 1;
+			for(int i=2; i<n; ++i) {
+				if(i%2 == 0) {
+					minEven = Math.min(aa[i], minEven);
+					numEven++;
+				}else {
+					minOdd = Math.min(aa[i], minOdd);
+					numOdd++;
+				}
+				sum += aa[i];
+				long score = sum;
+				score += minEven*(n-numEven);
+				score += minOdd*(n-numOdd);				
+				best = Math.min(best, score);
+			}
+			System.out.println(best);
+			
+		}
+	}
+
+}
+",1
+2c7a0000,69b2fd22,"import java.io.*;
+import java.util.*;
+ 
+public class Codeforces {
+	public static void main(String[] args) throws IOException {
+		
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		//int cases = Integer.parseInt(br.readLine());
+		//while(cases-- > 0) {
+			int n = Integer.parseInt(br.readLine());
+			String[] str = br.readLine().split("" "");
+			int[] a = new int[n];
+			int k = 0;
+			ArrayList<Integer> pos = new ArrayList<>();
+			for(int i=0; i<n; i++) {
+				a[i] = Integer.parseInt(str[i]);
+				if(a[i] == 1) {
+					k++;
+					pos.add(i);
+				}
+			}
+			int[][] dp = new int[n+1][k+1];
+			for(int i=0; i<=n; i++) {
+				Arrays.fill(dp[i], Integer.MAX_VALUE);
+			}
+			dp[0][0] = 0;
+			for(int i=0; i<n; i++) {
+				for(int j=0; j<=k; j++) {
+					if(dp[i][j] == Integer.MAX_VALUE) {
+						continue;
+					}
+					dp[i+1][j] = Math.min(dp[i+1][j], dp[i][j]);
+					if(j < k && a[i] == 0) {
+						dp[i+1][j+1] = Math.min(dp[i+1][j+1], dp[i][j]+Math.abs(pos.get(j)-i));
+					}
+				}
+			}
+			System.out.println(dp[n][k]);
+		//}
+	}
+}
+","import java.io.*;
+import java.util.*;
+public class Main {
+    public static void main(String args[])
+    {
+        FastReader input=new FastReader();
+        PrintWriter out=new PrintWriter(System.out);
+        int T=1;
+        while(T-->0)
+        {
+            int n=input.nextInt();
+            int a[]=new int[n];
+            ArrayList<Integer> list=new ArrayList<>();
+            ArrayList<Integer> space=new ArrayList<>();
+            for(int i=0;i<n;i++)
+            {
+                a[i]=input.nextInt();
+                if(a[i]==1)
+                {
+                    list.add(i);
+                }
+                else
+                {
+                    space.add(i);
+                }
+            }
+            int pre[]=new int[space.size()];
+            for(int i=0;i<list.size();i++)
+            {
+                if(i==0)
+                {
+                    int min=Integer.MAX_VALUE;
+                    for(int j=0;j<space.size();j++)
+                    {
+                        pre[j]=Math.abs(list.get(i)-space.get(j));
+                        min=Math.min(min,pre[j]);
+                        pre[j]=min;
+                    }
+                }
+                else
+                {
+                    int arr[]=new int[space.size()];
+                    for(int j=0;j<i;j++)
+                    {
+                        arr[j]=Integer.MAX_VALUE;
+                    }
+
+                    int min=Integer.MAX_VALUE;
+                    for(int j=i;j<space.size();j++)
+                    {
+                        int v=Math.abs(list.get(i)-space.get(j));
+                        v+=pre[j-1];
+                        arr[j]=v;
+                        min=Math.min(min,v);
+                        arr[j]=min;
+                    }
+                    for(int j=0;j<space.size();j++)
+                    {
+                        pre[j]=arr[j];
+                    }
+                }
+            }
+            out.println(pre[space.size()-1]);
+        }
+        out.close();
+    }
+    static class FastReader
+    {
+        BufferedReader br;
+        StringTokenizer st;
+        public FastReader()
+        {
+            br = new BufferedReader(new InputStreamReader(System.in));
+        }
+        String next()
+        {
+            while (st == null || !st.hasMoreElements())
+            {
+                try
+                {
+                    st = new StringTokenizer(br.readLine());
+                }
+                catch (IOException e)
+                {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+        int nextInt()
+        {
+            return Integer.parseInt(next());
+        }
+        long nextLong()
+        {
+            return Long.parseLong(next());
+        }
+        double nextDouble()
+        {
+            return Double.parseDouble(next());
+        }
+        String nextLine()
+        {
+            String str="""";
+            try
+            {
+                str=br.readLine();
+            }
+            catch (IOException e)
+            {
+                e.printStackTrace();
+            }
+            return str;
+        }
+    }
+}",0
+317a209c,9ab3c0e1,"import java.io.*;
+import java.util.*;
+
+public class D_Java {
+	public static final int MOD = 998244353;
+	
+	public static int mul(int a, int b) {
+		return (int)((long)a * (long)b % MOD);
+	}
+	
+	int[] f;
+	int[] rf;
+	
+	public int C(int n, int k) {
+		return (k < 0 || k > n) ? 0 : mul(f[n], mul(rf[n-k], rf[k]));
+	}
+	
+	public static int pow(int a, int n) {
+		int res = 1;
+		while (n != 0) {
+			if ((n & 1) == 1) {
+				res = mul(res, a);
+			}
+			a = mul(a, a);
+			n >>= 1;
+		}
+		return res;
+	}
+	
+	static void shuffleArray(int[] a) {
+		Random rnd = new Random();
+		for (int i = a.length-1; i > 0; i--) {
+			int index = rnd.nextInt(i + 1);
+			int tmp = a[index];
+			a[index] = a[i];
+			a[i] = tmp;
+		}
+	}
+	
+	public static int inv(int a) {
+		return pow(a, MOD-2);
+	}
+	
+	public void doIt() throws IOException {
+		BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
+		
+		StringTokenizer tok = new StringTokenizer(in.readLine());
+		int n = Integer.parseInt(tok.nextToken());
+		int k = Integer.parseInt(tok.nextToken());
+		
+		f = new int[n+42];
+		rf = new int[n+42];
+		f[0] = rf[0] = 1;
+		for (int i = 1; i < f.length; ++i) {
+			f[i] = mul(f[i-1], i);
+			rf[i] = mul(rf[i-1], inv(i));
+		}
+		
+		int[] events = new int[2*n];
+		for (int i = 0; i < n; ++i) {
+			tok = new StringTokenizer(in.readLine());
+			int le = Integer.parseInt(tok.nextToken());
+			int ri = Integer.parseInt(tok.nextToken());
+			events[i] = le*2;
+			events[i + n] = ri*2 + 1;
+		}
+		shuffleArray(events);
+		Arrays.sort(events);
+		
+		int ans = 0;
+		int balance = 0;
+		for (int r = 0; r < 2*n;) {
+			int l = r;
+			while (r < 2*n && events[l] == events[r]) {
+				++r;
+			}
+			int added = r - l;
+			if (events[l] % 2 == 0) {
+				// Open event
+				ans += C(balance + added, k);
+				if (ans >= MOD) ans -= MOD;
+				ans += MOD - C(balance, k);
+				if (ans >= MOD) ans -= MOD;
+				balance += added;
+			} else {
+				// Close event
+				balance -= added;
+			}
+		}
+		
+		in.close();
+		System.out.println(ans);
+	}
+	
+	public static void main(String[] args) throws IOException {
+		(new D_Java()).doIt();
+	}
+}","//package CF672;
+
+/**
+ * @version 1.0
+ * @Package_Name: CF672
+ * @Author: Redorain
+ * @Date: 2020/9/25 8:47
+ */
+
+import java.util.*;
+
+public class d {
+
+    public static Scanner sc = new Scanner(System.in);
+    public static final int MOD = 998244353;
+    int []f; int [] lf;
+
+    public static int mul(int a, int b) {
+        return (int)((long)a * (long)b % MOD);
+    }
+
+    public static int ksm(int a, int n) {
+        int ans = 1;
+        while(n > 0) {
+            if((n & 1) == 1)
+                ans = mul(a, ans);
+            a = mul(a, a);
+            n >>= 1;
+        }
+        return ans;
+    }
+
+    public int C(int n, int k) {
+        return (k < 0 || k > n) ? 0 : mul(f[n], mul(lf[n - k], lf[k]));
+    }
+
+    public static int inv(int a) {
+        return ksm(a, MOD - 2);
+    }
+
+    public void solve() {
+        int n = sc.nextInt();
+        int k = sc.nextInt();
+        f = new int[n + 42];
+        lf = new int[n + 42];
+        f[0] = lf[0] = 1;
+        for(int i = 1; i < f.length; i++) {
+            f[i] = mul(f[i  - 1], i);
+            lf[i] = mul(lf[i - 1], inv(i));
+        }
+
+        int[] events = new int[2 * n];
+        for(int i = 0; i < n; i++) {
+            int le = sc.nextInt();
+            int ri = sc.nextInt();
+            events[i] = le * 2;
+            events[i + n] = ri * 2 + 1;
+        }
+
+        Arrays.sort(events);
+        int ans = 0, balance = 0;
+        for(int r = 0; r < 2 * n;) {
+            int l = r;
+            while(r < 2 * n && events[l] == events[r]) ++r;
+            int added = r - l;
+            if(events[l] % 2 == 0) {
+                ans += C(balance + added, k);
+                if(ans >= MOD) ans -= MOD;
+                ans += MOD - C(balance, k);
+                if(ans >= MOD) ans -= MOD;
+                balance += added;
+            }
+            else balance -= added;
+        }
+        sc.close();
+        System.out.println(ans);
+    }
+
+    public static void main(String[] args) {
+        (new d()).solve();
+    }
+}",1
+810cf242,968c1e7e,"import java.util.*;
+import java.io.*;
+public class E1547{
+	static int inf = 2*(int)Math.pow(10,9);
+	static FastScanner fs = null;
+	public static void main(String[] args) {
+		fs = new FastScanner();
+		int t = fs.nextInt();
+		while(t-->0){
+			int n = fs.nextInt();
+			int k = fs.nextInt();
+			int pos[] = new int[k];
+			for(int i=0;i<k;i++){
+				pos[i] = fs.nextInt();
+			}	
+			int time[] = new int[n];
+			Arrays.fill(time,inf);
+			for(int i=0;i<k;i++){
+				time[pos[i]-1] = fs.nextInt();
+			}
+			for(int i=0;i<n;i++){
+				if(i==0){
+					continue;
+				}
+				else{
+					time[i] = Math.min(time[i],time[i-1]+1);
+				}
+			}
+			for(int i=n-2;i>=0;i--){
+				time[i] = Math.min(time[i],1+time[i+1]);
+			}
+			for(int i=0;i<n;i++){
+				System.out.print(time[i]+"" "");
+			}
+			System.out.println();			
+		}
+	}
+	static void sort(int[] a) {
+		ArrayList<Integer> l=new ArrayList<>();
+		for (int i:a) l.add(i);
+		Collections.sort(l);
+		for (int i=0; i<a.length; i++) a[i]=l.get(i);
+	}
+	static class FastScanner {
+		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st=new StringTokenizer("""");
+		String next() {
+			while (!st.hasMoreTokens())
+				try {
+					st=new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			return st.nextToken();
+		}
+		
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+		int[] readArray(int n) {
+			int[] a=new int[n];
+			for (int i=0; i<n; i++) a[i]=nextInt();
+			return a;
+		}
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+	}
+}
+","import java.util.*;
+import java.io.*;
+
+public class E_Air_Conditioners{
+    public static void main(String[] args) {
+        FastScanner s= new FastScanner();
+        StringBuilder res = new StringBuilder();
+        int t=s.nextInt();
+        int p=0;
+        while(p<t){
+        int n=s.nextInt();
+        int k=s.nextInt();
+        int pos[]= new int[k];
+        int temp[]= new int[k];
+        int min=Integer.MAX_VALUE;
+        int ans[]= new int[n];
+        HashMap<Integer,ArrayList<Integer>> map = new HashMap<Integer,ArrayList<Integer>>();
+            HashMap<Integer,Integer> count1 = new  HashMap<Integer,Integer> ();
+        for(int i=0;i<k;i++){
+            pos[i]=s.nextInt();
+        }
+        for(int i=0;i<k;i++){
+            temp[i]=s.nextInt();
+            ans[pos[i]-1]=temp[i];
+            min=Math.min(temp[i],min);
+            if(map.containsKey(temp[i])){
+                map.get(temp[i]).add(pos[i]-1);
+                int a=count1.get(temp[i]);
+                a++;
+                count1.remove(temp[i]);
+                count1.put(temp[i],a);
+            }
+            else{
+                ArrayList<Integer> obj = new ArrayList<Integer>();
+                obj.add(pos[i]-1);
+                map.put(temp[i],obj);
+                count1.put(temp[i],1);
+            }
+        }
+     
+        int num=min;
+       
+        while(true){
+           
+        
+           if(!map.containsKey(num)){
+               break;
+           }
+          ArrayList<Integer> obj2 = map.get(num);
+          
+          for(int i=0;i<obj2.size();i++){
+              int index=obj2.get(i);
+              if(ans[index]!=0){
+                  if(ans[index]<num){
+                     
+                    if(index+1<n && (ans[index+1]>(num+1)|| ans[index+1]==0)){
+                        ans[index+1]=num+1;
+                       
+                        if(map.containsKey(num+1)){
+                            map.get(num+1).add(index+1);
+                        }
+                        else{
+                            ArrayList<Integer> object = new  ArrayList<Integer>();
+                            object.add(index+1);
+                            map.put(num+1,object);
+                        }
+                    }
+
+                    if(index-1>=0 && (ans[index-1]>(num+1)|| ans[index-1]==0)){
+                        ans[index-1]=num+1;
+                     
+                        if(map.containsKey(num+1)){
+                            map.get(num+1).add(index-1);
+                        }
+                        else{
+                            ArrayList<Integer> object = new  ArrayList<Integer>();
+                            object.add(index-1);
+                            map.put(num+1,object);
+                        }
+                    }
+
+                  }
+                  else if(ans[index]==num){
+                   
+                      if(index+1<n && (ans[index+1]>(num+1)|| ans[index+1]==0)){
+                        ans[index+1]=num+1;
+                   
+                        if(map.containsKey(num+1)){
+                            map.get(num+1).add(index+1);
+                        }
+                        else{
+                            ArrayList<Integer> object = new  ArrayList<Integer>();
+                            object.add(index+1);
+                            map.put(num+1,object);
+                        }
+                    }
+
+                    if(index-1>=0 && (ans[index-1]>(num+1)|| ans[index-1]==0)){
+                        ans[index-1]=num+1;
+                    
+                        if(map.containsKey(num+1)){
+                            map.get(num+1).add(index-1);
+                        }
+                        else{
+                            ArrayList<Integer> object = new  ArrayList<Integer>();
+                            object.add(index-1);
+                            map.put(num+1,object);
+                        }
+                    }
+                  }
+
+              }
+            
+            }
+           num++;
+        }
+        for(int i=0;i<ans.length;i++){
+            res.append(ans[i]+"" "");
+        }
+        res.append(""\n"");
+        p++;
+    }
+    System.out.println(res);
+
+
+    }
+    static class FastScanner {
+		BufferedReader br;
+		StringTokenizer st;
+ 
+		public FastScanner(String s) {
+			try {
+				br = new BufferedReader(new FileReader(s));
+			} catch (FileNotFoundException e) {
+				// TODO Auto-generated catch block
+				e.printStackTrace();
+			}
+		}
+ 
+		public FastScanner() {
+			br = new BufferedReader(new InputStreamReader(System.in));
+		}
+ 
+		String nextToken() {
+			while (st == null || !st.hasMoreElements()) {
+				try {
+					st = new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					// TODO Auto-generated catch block
+					e.printStackTrace();
+				}
+			}
+			return st.nextToken();
+		}
+ 
+		int nextInt() {
+			return Integer.parseInt(nextToken());
+		}
+ 
+		long nextLong() {
+			return Long.parseLong(nextToken());
+		}
+ 
+		double nextDouble() {
+			return Double.parseDouble(nextToken());
+		}
+	}
+
+
+
+
+}",0
+9fc811f7,cff39394,"import java.io.OutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.PrintWriter;
+import java.util.StringTokenizer;
+import java.io.IOException;
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+import java.io.InputStream;
+
+public class Main {
+    public static void main(String[] args) {
+        InputStream inputStream = System.in;
+        OutputStream outputStream = System.out;
+        InputReader in = new InputReader(inputStream);
+        PrintWriter out = new PrintWriter(outputStream);
+        DTreeTag solver = new DTreeTag();
+        int testCount = Integer.parseInt(in.next());
+        for (int i = 1; i <= testCount; i++)
+            solver.solve(i, in, out);
+        out.close();
+    }
+
+    static class DTreeTag {
+        int diam = 0;
+
+        public int dfs(ArrayList<Integer> g[], int x, int depth[], int p) {
+            int len = 0;
+            for (int y : g[x]) {
+                if (y != p) {
+                    depth[y] = depth[x] + 1;
+                    int cur = 1 + dfs(g, y, depth, x);
+                    diam = Math.max(diam, cur + len);
+                    len = Math.max(len, cur);
+                }
+            }
+            return len;
+        }
+
+        public void solve(int testNumber, InputReader in, PrintWriter out) {
+            int n = in.nextInt();
+            int a = in.nextInt() - 1;
+            int b = in.nextInt() - 1;
+            int da = in.nextInt();
+            int db = in.nextInt();
+            int dis[] = new int[n];
+            ArrayList<Integer> g[] = new ArrayList[n];
+            for (int i = 0; i < n; i++) g[i] = new ArrayList<>();
+            for (int i = 0; i < n - 1; i++) {
+                int u = in.nextInt() - 1;
+                int v = in.nextInt() - 1;
+                g[u].add(v);
+                g[v].add(u);
+            }
+            diam = 0;
+            dfs(g, a, dis, -1);
+            int disb = dis[b];
+            if (2 * da >= Math.min(diam, db) || disb <= da) {
+                out.println(""Alice"");
+            } else {
+                out.println(""Bob"");
+            }
+
+        }
+
+    }
+
+    static class InputReader {
+        public BufferedReader reader;
+        public StringTokenizer tokenizer;
+
+        public InputReader(InputStream stream) {
+            reader = new BufferedReader(new InputStreamReader(stream), 32768);
+            tokenizer = null;
+        }
+
+        public String next() {
+            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
+                try {
+                    tokenizer = new StringTokenizer(reader.readLine());
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+            }
+            return tokenizer.nextToken();
+        }
+
+        public int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+    }
+}
+
+","
+import java.io.BufferedOutputStream;
+import java.io.BufferedReader;
+import java.io.FileNotFoundException;
+import java.io.FileReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.util.ArrayList;
+import java.util.StringTokenizer;
+
+public class D {
+	static int diam=0;
+	public static int dfs(int a, int p,int[] depth,ArrayList<Integer>[] list) {
+		int len=0;
+		for(int y:list[a]) {
+			if(y==p)
+				continue;
+			depth[y]=depth[a]+1;
+			int cur=1+dfs(y,a,depth,list);
+			diam=Math.max(cur+len,diam);
+			len=Math.max(cur, len);
+		}
+		return len;
+	}
+
+	public static void main(String[] args) {
+		MyScanner s = new MyScanner();
+		out = new PrintWriter(new BufferedOutputStream(System.out));
+		try {
+		int t=s.nextInt();
+		while(t-->0) {
+		int n=s.nextInt();
+		int a=s.nextInt();
+		int b=s.nextInt();
+		int da=s.nextInt();
+		int db=s.nextInt();
+		ArrayList<Integer>[] list=new ArrayList[n+1];
+		for(int i=0;i<=n;i++)
+			list[i]=new ArrayList<Integer>();
+		for(int i=0;i<n-1;i++) {
+			int u=s.nextInt();
+			int v=s.nextInt();
+			list[u].add(v);
+			list[v].add(u);
+		}
+		int[] depth=new int[n+1];
+		diam=0;
+		depth[a]=0;
+		int dia=dfs(a,0,depth,list);
+		if(2*da>=Math.min(diam, db) || depth[b]<=da) {
+			System.out.println(""Alice"");
+		}
+		else {
+			System.out.println(""Bob"");
+		}
+		}
+		out.close();
+		}catch(Exception e) {
+			System.out.println(e);
+			return;
+		}
+	}
+	
+	public static PrintWriter out;
+	
+	public static class MyScanner {
+		BufferedReader br;
+		StringTokenizer st;
+		
+		public MyScanner() {
+			br = new BufferedReader(new InputStreamReader(System.in));
+		}
+		
+		String next() {
+			while (st == null || !st.hasMoreElements()) {
+				try {
+					st = new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			}
+			return st.nextToken();
+		}
+		
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+		
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+		
+		double nextDouble() {
+			return Double.parseDouble(next());
+		}
+		
+		String nextLine() {
+			String str = """";
+			try {
+				str = br.readLine();
+			} catch (IOException e) {
+				e.printStackTrace();
+			}
+			return str;
+		}
+		
+	}
+	public static class FastScanner {
+		BufferedReader br;
+		StringTokenizer st;
+		
+		public FastScanner(String s) {
+			try {
+				br = new BufferedReader(new FileReader(s));
+			} catch (FileNotFoundException e) {
+				e.printStackTrace();
+			}
+		}
+		
+		public FastScanner() {
+			br = new BufferedReader(new InputStreamReader(System.in));
+		}
+		
+		String nextToken() {
+			while (st == null || !st.hasMoreElements()) {
+				try {
+					st = new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			}
+			return st.nextToken();
+		}
+		
+		int nextInt() {
+			return Integer.parseInt(nextToken());
+		}
+		
+		long nextLong() {
+			return Long.parseLong(nextToken());
+		}
+		
+		double nextDouble() {
+			return Double.parseDouble(nextToken());
+		}
+		
+
+	}
+
+}
+",1
+608ee4fb,be7b6026,"import java.util.*;
+import java.io.*;
+
+public class Solution {
+
+    static class Pair {
+        int x;
+        int y;
+        Pair(int x, int y) {
+            this.x = x;
+            this.y = y;
+        }
+
+        @Override
+        public int hashCode() {
+            return x * 13 + y;
+        }
+
+        @Override
+        public boolean equals(Object o) {
+            Pair x = (Pair) o;
+            return (x.x == this.x && x.y == this.y);
+        }
+    }
+
+    public static void main(String[] args) throws IOException {
+
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+
+        int t = Integer.parseInt(br.readLine());
+
+        BufferedWriter output = new BufferedWriter(new OutputStreamWriter(System.out));
+
+        StringTokenizer st;
+
+        while (t-- > 0) {
+
+            int n = Integer.parseInt(br.readLine());
+            ArrayList<ArrayList<Integer>> adj = new ArrayList<>();
+
+            for (int i = 0; i <= n; i++)
+                adj.add(new ArrayList<>());
+
+            ArrayList<Pair> list2 = new ArrayList<>();
+            HashMap<Pair, Integer> map = new HashMap<>();
+
+            for (int i = 0; i < n - 1; i++) {
+                st = new StringTokenizer(br.readLine());
+                int k1 = Integer.parseInt(st.nextToken());
+                int k2 = Integer.parseInt(st.nextToken());
+                if (k1 > k2) {
+                    int temp4 = k2;
+                    k2 = k1;
+                    k1 = temp4;
+                }
+                Pair temp = new Pair(k1, k2);
+                list2.add(temp);
+                adj.get(k1).add(k2);
+                adj.get(k2).add(k1);
+            }
+
+            int endp = -1;
+            for(int i = 1; i <=n; i++)
+            {
+                if(adj.get(i).size() == 1)
+                {
+                    endp = i;
+                    break;
+                }
+            }
+
+            int flag = 0;
+            if(endp == -1)
+                flag = 1;
+            Queue<Integer> q = new LinkedList<>();
+            q.add(endp);
+            int a = 2;
+            int vis[] = new int[n+1];
+            vis[endp] = 1;
+            while(!q.isEmpty())
+            {
+                int node = q.poll();
+                ArrayList<Integer> temp = adj.get(node);
+                if(temp.size() > 2)
+                {
+                    flag = 1;
+                    break;
+                }
+                for(int i = 0; i < temp.size(); i++)
+                {
+                    if(vis[temp.get(i)] == 0)
+                    {
+                        vis[temp.get(i)] = 1;
+                        q.add(temp.get(i));
+                        int res = 7 - a;
+                        a = res;
+                        Pair p = new Pair(Math.min(node, temp.get(i)), Math.max(temp.get(i), node));
+                        map.put(p, res);
+                    }
+                }
+            }
+
+            if(flag == 1)
+            {
+                output.write(""-1\n"");
+                continue;
+            }
+            for(Pair p : list2)
+                output.write(map.get(p) + "" "");
+
+            output.write(""\n"");
+        }
+
+        output.flush();
+
+    }
+
+}","import java.io.*;
+import java.util.*;
+
+public class C {
+    public static void main(String[] args) {
+        FastReader in = new FastReader();
+        PrintWriter out = new PrintWriter(System.out);
+
+        int T = in.nextInt();
+        for(int ttt = 1; ttt <= T; ttt++) {
+            int n = in.nextInt();
+            int[][] edges = new int[n-1][2];
+            Map<Integer, List<int[]>> map = new HashMap<>();
+            int max = 0;
+            for(int i = 0; i < n-1; i++) {
+                edges[i][0] = in.nextInt();
+                edges[i][1] = in.nextInt();
+
+                if(!map.containsKey(edges[i][0])) map.put(edges[i][0], new ArrayList<>());
+                if(!map.containsKey(edges[i][1])) map.put(edges[i][1], new ArrayList<>());
+                map.get(edges[i][0]).add(new int[]{edges[i][1], 0});
+                map.get(edges[i][1]).add(new int[]{edges[i][0], 0});
+
+                max = Math.max(max, Math.max(map.get(edges[i][0]).size(), map.get(edges[i][1]).size()));
+            }
+
+            if(max > 2) out.println(-1);
+            else {
+                int start = 1;
+                for(int key : map.keySet()) {
+                    if(map.get(key).size()==1) {
+                        start = key;
+                    }
+                }
+
+                dfs(start, 0, map, 2);
+
+                for(int[] e : edges) {
+                    for(int[] u : map.get(e[0])) {
+                        if(u[0]==e[1]) {
+                            out.print(u[1] + "" "");
+                        }
+                    }
+                }
+                out.println();
+            }
+        }
+
+        out.close();
+    }
+
+    static void dfs(int v, int p, Map<Integer, List<int[]>> map, int val) {
+        for(int[] u : map.get(v)) {
+            if(u[0]!=p) {
+                dfs(u[0], v, map, (val==2 ? 3: 2));
+            }
+        }
+        for(int[] e : map.get(v)) {
+            if(e[0]==p) {
+                e[1] = val;
+            }
+        }
+        if(map.containsKey(p)) {
+            for(int[] e : map.get(p)) {
+                if(e[0]==v) {
+                    e[1] = val;
+                }
+            }
+        }
+    }
+
+    static class FastReader {
+        BufferedReader br;
+        StringTokenizer st;
+        public FastReader() { br = new BufferedReader(new InputStreamReader(System.in)); }
+        String next() {
+            while (st == null || !st.hasMoreElements()) {
+                try { st = new StringTokenizer(br.readLine()); }
+                catch(IOException e) { e.printStackTrace(); }
+            }
+            return st.nextToken();
+        }
+        int nextInt() { return Integer.parseInt(next()); }
+        long nextLong() { return Long.parseLong(next()); }
+        double nextDouble() { return Double.parseDouble(next()); }
+        String nextLine() {
+            String str = """";
+            try { str = br.readLine(); }
+            catch(IOException e) { e.printStackTrace(); }
+            return str;
+        }
+        int[] readInt(int size) {
+            int[] arr = new int[size];
+            for(int i = 0; i < size; i++)
+                arr[i] = Integer.parseInt(next());
+            return arr;
+        }
+        long[] readLong(int size) {
+            long[] arr = new long[size];
+            for(int i = 0; i < size; i++)
+                arr[i] = Long.parseLong(next());
+            return arr;
+        }
+        int[][] read2dArray(int rows, int cols) {
+            int[][] arr = new int[rows][cols];
+            for(int i = 0; i < rows; i++) {
+                for(int j = 0; j < cols; j++)
+                    arr[i][j] = Integer.parseInt(next());
+            }
+            return arr;
+        }
+    }
+}",0
+810fd282,ec558d69,"import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+
+public class Main
+{
+	static int N=(int)2e5+10;
+	static long[][] dp=new long[2][N];
+	static int[][] A=new int[2][N];
+	static ArrayList<ArrayList<Integer>> adj=new ArrayList<>(N);
+	static
+	{
+		for(int i=0;i<N;i++)
+			adj.add(new ArrayList<>());
+	}
+	
+	public static void dfs(int v,int p)
+	{
+		dp[0][v]=dp[1][v]=0;
+		for(Integer u:adj.get(v))
+		{
+			if(u==p)
+				continue;
+			dfs(u, v);
+			dp[0][v]+=Math.max(Math.abs(A[0][v]-A[1][u])+dp[1][u], dp[0][u]+Math.abs(A[0][v]-A[0][u]));
+			dp[1][v]+=Math.max(Math.abs(A[1][v]-A[1][u])+dp[1][u], dp[0][u]+Math.abs(A[1][v]-A[0][u]));
+		}
+	}
+	
+	public static void main(String[] args) throws Exception
+	{
+		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+		int t=Integer.parseInt(br.readLine());
+		while(t-->0)
+		{
+			int n=Integer.parseInt(br.readLine());
+			for(int i=1;i<=n;i++)
+			{
+				String[] ss1=br.readLine().split("" "");
+				A[0][i]=Integer.parseInt(ss1[0]);
+				A[1][i]=Integer.parseInt(ss1[1]);
+				adj.set(i, new ArrayList<>());
+			}
+			for(int i=1;i<n;i++)
+			{
+				String[] ss2=br.readLine().split("" "");
+				int u=Integer.parseInt(ss2[0]);
+				int v=Integer.parseInt(ss2[1]);
+				adj.get(u).add(v);
+				adj.get(v).add(u);
+			}
+			dfs(1, -1);
+			System.out.println(Math.max(dp[0][1], dp[1][1]));
+		}
+    }
+}","import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+public class Main 
+{
+    static int N=(int)2e5+10;
+    static int[][] A=new int[2][N];
+    static long[][] dp=new long[2][N];
+    static ArrayList<ArrayList<Integer>> links=new ArrayList<>(N);
+    static {
+        for (int i=0;i<N;i++)
+            links.add(new ArrayList<>());
+    }
+    static void dfs(int v,int p) 
+    {
+        dp[0][v]=dp[1][v]=0;
+        for (Integer link :links.get(v))
+        {
+            if (link==p) continue;
+            dfs(link,v);
+            dp[0][v]+=Math.max(Math.abs(A[0][v]-A[0][link])+dp[0][link],Math.abs(A[0][v]-A[1][link])+dp[1][link]);
+            dp[1][v]+=Math.max(Math.abs(A[1][v]-A[0][link])+dp[0][link],Math.abs(A[1][v]-A[1][link])+dp[1][link]);
+        }
+    }
+
+	public static void main (String[] args) throws Exception
+	{
+		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+		int t=Integer.parseInt(br.readLine()),n,i;
+		while (t-->0)
+		{
+		    n=Integer.parseInt(br.readLine());
+		    for (i=1;i<=n;i++)
+		    {
+		        String[] in=br.readLine().split("" "");
+		        A[0][i]=Integer.parseInt(in[0]);
+		        A[1][i]=Integer.parseInt(in[1]);
+		        links.set(i,new ArrayList<>());
+		    }
+		    for (i=1;i<n;i++)
+		    {
+		        String[] in=br.readLine().split("" "");
+		        int a=Integer.parseInt(in[0]);
+		        int b=Integer.parseInt(in[1]);
+		        links.get(a).add(b);
+		        links.get(b).add(a);
+		    }
+		    dfs(1,-1);
+		    System.out.println(Math.max(dp[0][1],dp[1][1]));
+		}
+	}
+}
+
+",1
+41e69083,54eb1a6b,"import java.util.*;
+public class Solution {
+
+	public static void main(String[] args) {
+		// TODO Auto-generated method stub
+          Scanner io =new Scanner (System.in);
+          int t = io.nextInt();
+  		for (int iii=0; iii<t; iii++) {
+  			int n = io.nextInt();
+  			long k = io.nextLong();
+   
+  			Long[] arr = new Long[n];
+  			for (int i=0; i<n; i++) {
+  				arr[i] = io.nextLong();
+  			}
+   
+  			Arrays.sort(arr);
+  			long[] psum = new long[n];
+  			psum[0] = arr[0];
+  			for (int i=1; i<n; i++) {
+  				psum[i] = psum[i-1] + arr[i];
+  			}
+   
+  			if (psum[n-1] <= k) {
+  				System.out.println(0);
+  				continue;
+  			}
+  			//System.out.println(psum[n-1]);
+   
+  			long ans = Long.MAX_VALUE;
+  			
+  			for (int i=0; i<n; i++) {
+  				long sum = psum[i] + (n-i-1)*arr[0];
+  				if (sum <= k) {
+  					ans = Math.min(ans, n-1-i);
+  					continue;
+  				}
+  				long ops = (long) Math.ceil((double) (sum - k)/(double) (n-i));
+   
+  				ans = Math.min(ans, n-1-i + ops);
+  				//System.out.println(sum);
+  			}
+  			System.out.println(ans);
+  			
+  		}
+
+        	  }
+        	   
+	
+	
+
+
+}
+","import java.util.*;
+public class Solution {
+ 
+	public static void main(String[] args) {
+		// TODO Auto-generated method stub
+          Scanner io =new Scanner (System.in);
+          int t = io.nextInt();
+  		for (int iii=0; iii<t; iii++) {
+  			int n = io.nextInt();
+  			long k = io.nextLong();
+   
+  			Long[] arr = new Long[n];
+  			for (int i=0; i<n; i++) {
+  				arr[i] = io.nextLong();
+  			}
+   
+  			Arrays.sort(arr);
+  			long[] psum = new long[n];
+  			psum[0] = arr[0];
+  			for (int i=1; i<n; i++) {
+  				psum[i] = psum[i-1] + arr[i];
+  			}
+   
+  			if (psum[n-1] <= k) {
+  				System.out.println(0);
+  				continue;
+  			}
+  			//System.out.println(psum[n-1]);
+   
+  			long ans = Long.MAX_VALUE;
+  			
+  			for (int i=0; i<n; i++) {
+  				long sum = psum[i] + (n-i-1)*arr[0];
+  				if (sum <= k) {
+  					ans = Math.min(ans, n-1-i);
+  					continue;
+  				}
+  				long ops = (long) Math.ceil((double) (sum - k)/(double) (n-i));
+   
+  				ans = Math.min(ans, n-1-i + ops);
+  				//System.out.println(sum);
+  			}
+  			System.out.println(ans);
+  			
+  		}
+ 
+        	  }
+        	   
+	
+	
+ 
+ 
+}",1
+a3ebea91,f80f6d8d,"// There are 𝑛 beautiful skyscrapers in New York, the height of the 𝑖-th one
+// is ℎ𝑖. Today some villains have set on fire first 𝑛−1 of them, and now the
+// only safety building is 𝑛-th skyscraper.
+
+// Let's call a jump from 𝑖-th skyscraper to 𝑗-th (𝑖<𝑗) discrete, if all
+// skyscrapers between are strictly lower or higher than both of them. Formally,
+// jump is discrete, if 𝑖<𝑗 and one of the following conditions satisfied:
+
+// 𝑖+1=𝑗 max(ℎ𝑖+1,…,ℎ𝑗−1)<min(ℎ𝑖,ℎ𝑗) max(ℎ𝑖,ℎ𝑗)<min(ℎ𝑖+1,…,ℎ𝑗−1). At
+// the moment, Vasya is staying on the first skyscraper and wants to live a
+// little longer, so his goal is to reach 𝑛-th skyscraper with minimal count of
+// discrete jumps. Help him with calcualting this number.
+
+// Input The first line contains a single integer 𝑛 (2≤𝑛≤3⋅105) — total amount
+// of skyscrapers.
+
+// The second line contains 𝑛 integers ℎ1,ℎ2,…,ℎ𝑛 (1≤ℎ𝑖≤109) — heights of
+// skyscrapers.
+
+// Output Print single number 𝑘 — minimal amount of discrete jumps. We can show
+// that an answer always exists.
+
+import java.io.*;
+import java.util.*;
+
+public class DiscreteCentrifugalJumps {
+  public static void solve(int n, int[] arr) {
+    int[] dp = new int[n]; // dp array
+    for (int i=1; i<n; i++) dp[i] = Integer.MAX_VALUE;
+    int[] lg = new int[n]; // first greater element from the left
+    int[] ll = new int[n]; // first smaller element from the left
+    int[] rg = new int[n]; // first greater element from the right
+    int[] rl = new int[n]; // first smaller element from the right
+
+    List<List<Integer>> jumps = new ArrayList<>(); // for each index i, use a list to record which places it can jump to
+    for (int i=0; i<n; i++) {
+      jumps.add(new ArrayList<Integer>());
+    }
+    // preprocessing
+    Stack<Pair<Integer, Integer>> stack = new Stack<>(); // each pair, first is height of skycraper, second is index in original array
+
+    for (int i=0; i<n; i++) {
+      while (!stack.isEmpty() && stack.peek().first < arr[i]) {
+        stack.pop();
+      }
+      if (stack.isEmpty()) lg[i] = -1;
+      else lg[i] = stack.peek().second; // ith building is first that is greater than s[-1].second building
+      stack.add(new Pair<Integer, Integer>(arr[i], i));
+    }
+    stack.clear();
+
+    for (int i=0; i<n; i++) {
+      while (!stack.isEmpty() && stack.peek().first > arr[i]) {
+        stack.pop();
+      }
+      if (stack.isEmpty()) ll[i] = -1;
+      else ll[i] = stack.peek().second; 
+      stack.add(new Pair<Integer, Integer>(arr[i], i));
+    }
+    stack.clear();
+
+    for (int i=n-1; i>=0; i--) {
+      while (!stack.isEmpty() && stack.peek().first > arr[i]) {
+        stack.pop();
+      }
+      if (stack.isEmpty()) rg[i] = -1;
+      else rg[i] = stack.peek().second; 
+      stack.add(new Pair<Integer, Integer>(arr[i], i));
+    }
+    stack.clear();
+
+    for (int i=n-1; i>=0; i--) {
+      while (!stack.isEmpty() && stack.peek().first < arr[i]) {
+        stack.pop();
+      }
+      if (stack.isEmpty()) rl[i] = -1;
+      else rl[i] = stack.peek().second;
+      stack.add(new Pair<Integer, Integer>(arr[i], i));
+    }
+    stack.clear();
+    
+    // we construct the jumps list
+    for (int i = 0; i<n; i++) {
+      if (lg[i] != -1) jumps.get(lg[i]).add(i);
+      if (ll[i] != -1) jumps.get(ll[i]).add(i);
+      if (rg[i] != -1) jumps.get(i).add(rg[i]);
+      if (rl[i] != -1) jumps.get(i).add(rl[i]);
+    }
+
+    // dp
+    for (int i=0; i<n; i++) {
+      for (int j: jumps.get(i)) {
+        dp[j] = Math.min(dp[j], dp[i] + 1);
+      }
+    }
+    System.out.println(dp[n-1]);
+  }
+  public static void main(String[] args) throws IOException {
+    try (BufferedReader br = new BufferedReader(new InputStreamReader(System.in))){
+      int n = Integer.parseInt(br.readLine());
+      String[] s = br.readLine().split("" "");
+      int[] arr = new int[n];
+      for (int i=0; i<n; i++) {
+        arr[i] = Integer.parseInt(s[i]);
+      }
+      solve(n, arr);
+    }
+  }
+}
+
+class Pair<T1, T2> {
+  public T1 first;
+  public T2 second;
+  public Pair(T1 first, T2 second) {
+    this.first = first;
+    this.second = second;
+  }
+}","
+import static java.lang.Math.min;
+
+import java.io.ByteArrayInputStream;
+import java.io.File;
+import java.io.PrintWriter;
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Scanner;
+
+public class D_2 {
+	public static void main(String[] args) throws Exception {
+		new D_2().go();
+	}
+
+	int USE_FILE = 0;
+	String INPUT = ""5\r\n"" +
+			""1 3 1 4 5\r\n"" +
+			"""";
+
+	void solve(int caseNr) {
+		int n = in.nextInt();
+		int[] h = na(n);
+		int[] dp = new int[n];
+
+		for (int i = 0; i < n; i++) {
+			dp[i] = inf;
+		}
+		dp[0] = 0;
+
+
+		// vector<pair<int, int>> st;
+		LinkedList<int[]> st = new LinkedList<>();
+
+		// lge[maxn], lle[maxn], rge[maxn], rle[maxn];
+		int[] lge = new int[n];
+		int[] lle = new int[n];
+		int[] rge = new int[n];
+		int[] rle = new int[n];
+
+
+		for (int i = 0; i < n; i++) { // the nearest greater from the left
+			while (!st.isEmpty() && st.getLast()[0] < h[i]) {
+				st.removeLast();
+			}
+			if (st.isEmpty()) {
+				lge[i] = -1;
+			} else {
+				lge[i] = st.getLast()[1];
+			}
+			st.add(new int[]{h[i], i});
+		}
+
+		st.clear();
+		for (int i = 0; i < n; i++) { // the nearest less from the left
+			while (!st.isEmpty() && st.getLast()[0] > h[i]) {
+				st.removeLast();
+			}
+			if (st.isEmpty()) {
+				lle[i] = -1;
+			} else {
+				lle[i] = st.getLast()[1];
+			}
+			st.add(new int[]{h[i], i});
+		}
+
+		st.clear();
+		for (int i = n - 1; i >= 0; i--) { // the nearest greater from the right
+			while (!st.isEmpty() && st.getLast()[0] < h[i]) {
+				st.removeLast();
+			}
+			if (st.isEmpty()) {
+				rge[i] = -1;
+			} else {
+				rge[i] = st.getLast()[1];
+			}
+			st.add(new int[]{h[i], i});
+		}
+
+		st.clear();
+		for (int i = n - 1; i >= 0; i--) { // the nearest less from the right
+			while (!st.isEmpty() && st.getLast()[0] > h[i]) {
+				st.removeLast();
+			}
+			if (st.isEmpty()) {
+				rle[i] = -1;
+			} else {
+				rle[i] = st.getLast()[1];
+			}
+			st.add(new int[]{h[i], i});
+		}
+
+
+		List<List<Integer>> jumps = new ArrayList<>();
+		for (int i = 0; i < n; i++) {
+			jumps.add(new ArrayList<>());
+		}
+
+		for (int i = 0; i < n; i++) {
+			if (rle[i] != -1) jumps.get(i).add(rle[i]);
+			if (rge[i] != -1) jumps.get(i).add(rge[i]);
+			if (lle[i] != -1) jumps.get(lle[i]).add(i);
+			if (lge[i] != -1) jumps.get(lge[i]).add(i);
+		}
+		for (int i = 0; i < n; i++) {
+			for (int to : jumps.get(i)) {
+				dp[to] = min(dp[to], dp[i] + 1);
+			}
+		}
+
+
+		// System.out.println(jumps);
+
+
+		System.out.println(dp[n - 1]);
+
+
+		return;
+	} // end of solve2
+
+
+
+
+
+	// ---------------------------------------------------------------------------------------------- //
+
+	void testCases() {
+		int t = 1;
+		for (int i=1; i<=t; i++) {
+			solve(i);
+		}
+		output_writer.flush();
+	}
+
+
+
+
+	// ---------------------------------------------------------------------------------------------- //
+
+	private int[] na(int n) {
+		int[] a = new int[n];
+		for (int i=0; i<n; i++) {
+			a[i] = in.nextInt();
+		}
+		return a;
+	}
+
+	private int inf = Integer.MAX_VALUE;
+
+
+
+
+	// ---------------------------------------------------------------------------------------------- //
+	// ---------------------------------------------------------------------------------------------- //
+
+	static boolean LOCAL = java.lang.System.getProperty(""ONLINE_JUDGE"") == null;
+	Scanner in;
+	PrintWriter output_writer = new PrintWriter(java.lang.System.out);
+
+	// the output musn't flush automatic or we time out
+	static class System {
+		static PrintWriter out = null;
+	}
+
+	void go() throws Exception {
+		System.out = output_writer;
+
+		if (LOCAL && USE_FILE == 0) {
+			//  if not set expects input from terminal
+			java.lang.System.setIn(new ByteArrayInputStream(INPUT.getBytes()));
+			in = new Scanner(java.lang.System.in);
+		}
+		if (LOCAL && USE_FILE > 0) {
+			String filename = String.format(""in/cf%d.txt"", USE_FILE);
+			File inputFile = new File(filename);
+			in = new Scanner(inputFile);
+			output_writer.printf(""[%s]\n"", filename);
+			output_writer.flush();
+		}
+		if (!LOCAL) {
+			in = new Scanner(java.lang.System.in);
+		}
+
+
+		long startTime = java.lang.System.currentTimeMillis();
+		testCases();
+		if (LOCAL) {
+			java.lang.System.out.printf(""[%dms]\n"", java.lang.System.currentTimeMillis()-startTime);
+		}
+		in.close();
+	}
+}
+
+
+
+",1
+ac180326,b1e9f1f6,"//This code is written by प्रविण शंखपाळ 
+
+//package wizard;
+
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.text.DecimalFormat;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.Arrays;
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.Stack;
+import java.util.Queue;
+import java.util.PriorityQueue;
+import java.util.List;
+import java.util.HashSet;
+import java.util.LinkedHashSet;
+import java.util.TreeSet;
+import java.util.Map;
+import java.util.HashMap;
+import java.util.Scanner;
+import java.util.Set;
+import java.util.StringTokenizer;
+import java.util.Vector;
+
+public class Dobby {
+
+	public static void main(String[] args) {
+
+		try {
+
+			FastReader fr = new FastReader();
+			PrintWriter pt = new PrintWriter(System.out);
+
+			int t = fr.nextInt();
+
+			while (t > 0) {
+
+				int n = fr.nextInt(), m = fr.nextInt(), x = fr.nextInt();
+
+				ArrayList<Pair> pp = new ArrayList<>();
+
+				int A[] = new int[n];
+
+				for (int i = 0; i < n; i++) {
+					A[i] = fr.nextInt();
+					Pair pr = new Pair(A[i], i);
+					pp.add(pr);
+				}
+
+				Collections.sort(pp);
+				Collections.reverse(pp);
+
+				int ps[] = new int[n];
+				int pk[] = new int[n];
+				Arrays.fill(ps, 0);
+				Arrays.fill(pk, 0);
+
+				int index = 0;
+
+				for (int i = 0; i < n; i++) {
+
+					if (pk[index] < x) {
+						pk[index] += pp.get(i).a;
+					}
+					ps[pp.get(i).b] = index + 1;
+					index++;
+
+					index = index == m ? 0 : index;
+
+				}
+
+				pt.println(""YES"");
+
+				for (int i = 0; i < n; i++) {
+					pt.print(ps[i] + "" "");
+				}
+				pt.println();
+
+				t--;
+			}
+
+			pt.close();
+
+		} catch (
+
+		Exception e) {
+			return;
+		}
+	}
+
+	static void merge(long arr[], int l, int m, int r) {
+
+		int n1 = m - l + 1;
+		int n2 = r - m;
+
+		long L[] = new long[n1];
+		long R[] = new long[n2];
+
+		for (int i = 0; i < n1; ++i)
+			L[i] = arr[l + i];
+		for (int j = 0; j < n2; ++j)
+			R[j] = arr[m + 1 + j];
+
+		int i = 0, j = 0;
+
+		int k = l;
+		while (i < n1 && j < n2) {
+			if (L[i] <= R[j]) {
+				arr[k] = L[i];
+				i++;
+			} else {
+				arr[k] = R[j];
+				j++;
+			}
+			k++;
+		}
+
+		while (i < n1) {
+			arr[k] = L[i];
+			i++;
+			k++;
+		}
+
+		while (j < n2) {
+			arr[k] = R[j];
+			j++;
+			k++;
+		}
+	}
+
+	static void sort(long arr[], int l, int r) {
+		if (l < r) {
+
+			int m = l + (r - l) / 2;
+
+			sort(arr, l, m);
+			sort(arr, m + 1, r);
+
+			merge(arr, l, m, r);
+		}
+	}
+
+	static class Pair implements Comparable<Pair> {
+		int a, b;
+
+		Pair(int a, int b) {
+			this.a = a;
+			this.b = b;
+		}
+
+		public int compareTo(Pair o) {
+			// TODO Auto-generated method stub
+			if (this.a != o.a)
+				return Integer.compare(this.a, o.a);
+			else
+				return Integer.compare(this.b, o.b);
+			// return 0;
+		}
+
+		public boolean equals(Object o) {
+			if (o instanceof Pair) {
+				Pair p = (Pair) o;
+				return p.a == a && p.b == b;
+			}
+			return false;
+		}
+
+	}
+
+	static int binarySearch(int arr[], int first, int last, int key) {
+		int mid = (first + last) / 2;
+		while (first <= last) {
+			if (arr[mid] < key) {
+				first = mid + 1;
+			} else if (arr[mid] == key) {
+				return mid;
+			} else {
+				last = mid - 1;
+			}
+			mid = (first + last) / 2;
+		}
+		return -1;
+	}
+
+	static class FastReader {
+		BufferedReader br;
+		StringTokenizer st;
+
+		public FastReader() {
+			br = new BufferedReader(new InputStreamReader(System.in));
+		}
+
+		String next() {
+			while (st == null || !st.hasMoreElements()) {
+				try {
+					st = new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			}
+			return st.nextToken();
+		}
+
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+
+		double nextDouble() {
+			return Double.parseDouble(next());
+		}
+
+		String nextLine() {
+			String str = """";
+			try {
+				str = br.readLine();
+			} catch (IOException e) {
+				e.printStackTrace();
+			}
+			return str;
+		}
+	}
+}
+","
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+import java.util.Collections;
+
+public class test {
+
+	public static void main(String[] args) throws NumberFormatException, IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+
+		int t = Integer.parseInt(br.readLine());
+		StringBuilder sb = new StringBuilder();
+		while (t-- > 0) {
+			String[] st = br.readLine().split("" "");
+			int n = Integer.parseInt(st[0]);
+			int m = Integer.parseInt(st[1]);
+			int x = Integer.parseInt(st[2]);
+
+			int[] arr = new int[n];
+			st = br.readLine().split("" "");
+			Pair[] temp = new Pair[n];
+			for (int i = 0; i < n; i++) {
+				arr[i] = Integer.parseInt(st[i]);
+				temp[i] = new Pair(arr[i], i);
+			}
+
+			int bcount = n / m;
+			int extra = n % m;
+
+			int[] ans = new int[n];
+			sort(temp);
+			int id = 0;
+
+			int minmax = 0;
+			boolean flag = false;
+			for (int i = 0; i < bcount; i++) {
+
+				minmax -= temp[id].val;
+				for (int j = 0; j < m; j++) {
+					ans[temp[id].idx] = j + 1;
+
+					if (j == m) {
+						minmax += temp[id].val;
+					}
+					id++;
+				}
+
+				if (minmax > x) {
+					sb.append(""NO\n"");
+					flag = true;
+					break;
+				}
+
+			}
+
+			for (int i = 0; i < extra; i++) {
+				ans[temp[id].idx] = i + 1;
+				id++;
+			}
+
+			if (flag == false) {
+				sb.append(""YES\n"");
+				for (int i = 0; i < n; i++) {
+					sb.append(ans[i] + "" "");
+				}
+
+				sb.append(""\n"");
+			}
+
+		}
+
+		System.out.println(sb);
+	}
+
+	public static class Pair implements Comparable<Pair> {
+		int val;
+		int idx;
+
+		public Pair(int val, int idx) {
+			this.val = val;
+			this.idx = idx;
+		}
+
+		@Override
+		public int compareTo(Pair o) {
+			return this.val - o.val;
+		}
+	}
+
+	public static void sort(Pair[] arr) {
+		ArrayList<Pair> list = new ArrayList<>();
+		for (int i = 0; i < arr.length; i++) {
+			list.add(new Pair(arr[i].val, arr[i].idx));
+		}
+
+		Collections.sort(list);
+
+		for (int i = 0; i < arr.length; i++) {
+			arr[i] = list.get(i);
+		}
+
+	}
+}
+",0
+464a03b8,f0ede32a,"import java.util.*;
+
+public class Soltion{
+ 
+     public static void main(String []args){
+        Scanner sc = new Scanner(System.in);
+        int t = sc.nextInt();
+        
+        while(t-->0){
+            int n = sc.nextInt();
+            Integer[] arr = new Integer[n];
+            for(int i=0;i<n;i++){
+                arr[i] = sc.nextInt();
+            }
+            String s = sc.next();
+            
+            List<Integer> blue = new ArrayList<>();
+            List<Integer> red = new ArrayList<>();
+            
+            for(int i=0;i<s.length();i++){
+                if(s.charAt(i)=='B'){
+                    blue.add(arr[i]);
+                }
+                else{
+                    red.add(arr[i]);
+                }
+            }
+            
+            Collections.sort(blue);
+            Collections.sort(red);
+            int p=1,q=n;
+            
+            boolean flag = true;
+            for(int i=red.size()-1;i>=0;i--){
+                if(red.get(i)>q){
+                    flag = false;
+                    break;
+                }
+                q--;
+            }
+            
+            for(int i=0;i<blue.size();i++){
+                if(blue.get(i)<p){
+                    flag = false;
+                    break;
+                }
+                p++;
+            }
+            
+            System.out.println(flag? ""Yes"" : ""No"");
+        }
+     }
+}
+","import java.util.*;
+
+public class Soltion{
+ 
+     public static void main(String []args){
+        Scanner sc = new Scanner(System.in);
+        int t = sc.nextInt();
+        
+        while(t-->0){
+            int n = sc.nextInt();
+            Integer[] arr = new Integer[n];
+            for(int i=0;i<n;i++){
+                arr[i] = sc.nextInt();
+            }
+            String s = sc.next();
+            
+            List<Integer> blue = new ArrayList<>();
+            List<Integer> red = new ArrayList<>();
+            
+            for(int i=0;i<s.length();i++){
+                if(s.charAt(i)=='B'){
+                    blue.add(arr[i]);
+                }
+                else{
+                    red.add(arr[i]);
+                }
+            }
+            
+            Collections.sort(blue);
+            Collections.sort(red);
+            int p=1,q=n;
+            
+            boolean flag = true;
+            for(int i=red.size()-1;i>=0;i--){
+                if(red.get(i)>q){
+                    flag = false;
+                    break;
+                }
+                q--;
+            }
+            
+            for(int i=0;i<blue.size();i++){
+                if(blue.get(i)<p){
+                    flag = false;
+                    break;
+                }
+                p++;
+            }
+            
+            System.out.println(flag? ""Yes"" : ""No"");
+        }
+     }
+}
+",1
+3e8ff074,d9199dfd,"import java.io.*;
+import java.util.*;
+
+public class blue_red_permutation {
+    public static void main(String[] args) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        int T = Integer.parseInt(br.readLine());
+
+        while (T-- > 0) {
+            int N = Integer.parseInt(br.readLine());
+
+            String line1[] = br.readLine().split("" "");
+            char line2[] = br.readLine().toCharArray();
+
+            Range ranges[] = new Range[N];
+            for (int i = 0; i < N; i++) {
+                int cnt = Integer.parseInt(line1[i]);
+                int low = line2[i] == 'B' ? Math.min(1, cnt) : Math.max(1, cnt);
+                int high = line2[i] == 'R' ? Math.max(N, cnt) : Math.min(N, cnt);
+                ranges[i] = new Range(low, high);
+            }
+
+            Arrays.sort(ranges);
+
+            boolean doable = true;
+            for (int i = 0; i < N; i++) {
+                if (!ranges[i].contains(i + 1)) { doable = false; break; }
+            }
+
+            System.out.println(doable ? ""YES"" : ""NO"");
+        }
+    }
+
+    static class Range implements Comparable<Range> {
+        final int low, high;
+        
+        Range(int low,int high) {
+            this.low = low;
+            this.high = high;
+        }
+
+        public boolean contains(int val) {
+            return val >= this.low && val <= this.high;
+        }
+
+        @Override
+        public int compareTo(Range range) {
+            if (this.low < range.low) { return -1; }
+            else if (this.low == range.low) { return this.high - range.high; }
+            else { return +1; }
+        }
+    }
+}","import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Scanner;
+
+public class Simple{  
+    public static void main(String args[]){  
+        //System.out.println(""Hello Java"");
+        Scanner s = new Scanner(System.in);
+        int t = s.nextInt();
+        while (t>0){
+            
+            int n = s.nextInt();
+            int arr[] = new int[n];
+
+            for(int i=0;i<n;i++){
+                arr[i] = s.nextInt();
+            }
+            String str = s.next();
+
+            //Arrays.sort(arr);
+            ArrayList<Integer> blue = new ArrayList<>();
+            ArrayList<Integer> red = new ArrayList<>();
+            for(int i=0;i<n;i++){
+                if(str.charAt(i)=='R'){
+                    red.add(arr[i]);
+                }
+                else{
+                    blue.add(arr[i]);
+                }
+            }
+            Collections.sort(red);
+            Collections.sort(blue);
+            
+            int start =1;
+
+            boolean bool =true;
+            for(int i=0;i<blue.size();i++){
+                if(blue.get(i)<start){
+                    bool = false;
+                    break;
+                }
+
+                start++;
+            }
+            if(!bool){
+                System.out.println(""NO"");
+            }
+            else{
+                for(int i=0;i<red.size();i++){
+                    if(red.get(i)>start){
+                        bool = false;
+                        break;
+                    }
+                    start++;
+                }
+                if(bool){
+                    System.out.println(""YES"");
+                }
+                else{
+                    System.out.println(""NO"");
+                }
+            }
+            
+            
+
+
+            t--;
+        }
+        s.close();  
+    }
+    
+}  
+",0
+2a655afe,692a4496,"import java.io.*;
+import java.util.*;
+
+public class c {
+    public static BufferedReader in;
+
+    public static void main(String[] args) throws Exception {
+        in = new BufferedReader(new InputStreamReader(System.in));
+        PrintWriter out = new PrintWriter(System.out);
+        int numcases = Integer.parseInt(in.readLine());
+        for (int casenum = 0; casenum < numcases; casenum++) {
+            int n = Integer.parseInt(in.readLine());
+            int[] p = new int[n];
+            Arrays.fill(p, -1);
+            for (int i = 0; i < n; i++) {
+                if (p[i] != -1)
+                    continue;
+                ArrayList<Integer> cycle = new ArrayList<>();
+                cycle.add(query(i));
+                while (cycle.size() == 1 || !cycle.get(0).equals(cycle.get(cycle.size() - 1))) {
+                    cycle.add(query(i));
+                }
+                cycle.remove(cycle.size() - 1);
+                for (int j = 0; j < cycle.size() - 1; j++) {
+                    p[cycle.get(j)] = cycle.get(j + 1);
+                }
+                p[cycle.get(cycle.size() - 1)] = cycle.get(0);
+                // System.out.println(Arrays.toString(p));
+            }
+            StringBuilder b = new StringBuilder();
+            b.append(""! "");
+            for (int i = 0; i < n; i++) {
+                b.append((p[i] + 1) + (i < n - 1 ? "" "" : ""\n""));
+            }
+            System.out.print(b);
+            System.out.flush();
+        }
+        in.close();
+        out.close();
+    }
+
+    public static int query(int i) throws Exception {
+        System.out.println(""? "" + (i + 1));
+        System.out.flush();
+        int k = Integer.parseInt(in.readLine());
+        return k - 1;
+    }
+}","import java.io.*;
+import java.util.*;
+
+public class c {
+	public static BufferedReader in;
+
+	public static void main(String[] args) throws Exception {
+		in = new BufferedReader(new InputStreamReader(System.in));
+		PrintWriter out = new PrintWriter(System.out);
+		int numcases = Integer.parseInt(in.readLine());
+		for (int casenum = 0; casenum < numcases; casenum++) {
+			int n = Integer.parseInt(in.readLine());
+			int[] p = new int[n];
+			Arrays.fill(p, -1);
+			for (int i = 0; i < n; i++) {
+				if (p[i] != -1)
+					continue;
+				ArrayList<Integer> cycle = new ArrayList<>();
+				cycle.add(query(i));
+				while (cycle.size() == 1 || !cycle.get(0).equals(cycle.get(cycle.size() - 1))) {
+					cycle.add(query(i));
+				}
+				cycle.remove(cycle.size() - 1);
+				for(int j = 0; j < cycle.size() - 1; j++){
+					p[cycle.get(j)] = cycle.get(j + 1);
+				}
+				p[cycle.get(cycle.size() - 1)] = cycle.get(0);
+				//System.out.println(Arrays.toString(p));
+			}
+			StringBuilder b = new StringBuilder();
+			b.append(""! "");
+			for (int i = 0; i < n; i++) {
+				b.append((p[i] + 1) + (i < n - 1 ? "" "" : ""\n""));
+			}
+			System.out.print(b);
+			System.out.flush();
+		}
+		in.close();
+		out.close();
+	}
+
+	public static int query(int i) throws Exception {
+		System.out.println(""? "" + (i + 1));
+		System.out.flush();
+		int k = Integer.parseInt(in.readLine());
+		return k - 1;
+	}
+}
+",1
+1eda0725,d2901569,"import java.io.*;
+import java.util.*;
+public class Main {
+    public static void main(String args[])
+    {
+        FastReader input=new FastReader();
+        PrintWriter out=new PrintWriter(System.out);
+        int T=input.nextInt();
+        while(T-->0)
+        {
+            int n=input.nextInt();
+            int k[]=new int[n];
+            int h[]=new int[n];
+            for(int i=0;i<n;i++)
+            {
+                k[i]=input.nextInt();
+            }
+            for(int i=0;i<n;i++)
+            {
+                h[i]=input.nextInt();
+            }
+            ArrayList<int []> list=new ArrayList<>();
+            for(int i=0;i<n;i++)
+            {
+                int p=k[i]-h[i]+1;
+                if(list.size()==0) list.add(new int[]{p,k[i]});
+                else
+                {
+                    while(list.size()>0)
+                    {
+                        int j=list.size()-1;
+                        int a[]=list.get(j);
+                        int l=a[0],r=a[1];
+                        int l1=p,r1=k[i];
+                        if(l1>r)
+                        {
+                            list.add(new int[]{l1,r1});
+                            break;
+                        }
+                        else if(l1>=l && l1<=r)
+                        {
+                            list.remove(j);
+                            list.add(new int[]{l,r1});
+                            break;
+                        }
+                        else
+                        {
+                            list.remove(j);
+                        }
+                    }
+                    if(list.size()==0) list.add(new int[]{p,k[i]});
+                }
+            }
+            long sum=0;
+            for(int i=0;i<list.size();i++)
+            {
+                long d=list.get(i)[1]-list.get(i)[0]+1;
+                long val=d*(d+1)/2;
+                sum+=val;
+            }
+            out.println(sum);
+        }
+        out.close();
+    }
+    static class FastReader
+    {
+        BufferedReader br;
+        StringTokenizer st;
+        public FastReader()
+        {
+            br = new BufferedReader(new InputStreamReader(System.in));
+        }
+        String next()
+        {
+            while (st == null || !st.hasMoreElements())
+            {
+                try
+                {
+                    st = new StringTokenizer(br.readLine());
+                }
+                catch (IOException e)
+                {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+        int nextInt()
+        {
+            return Integer.parseInt(next());
+        }
+        long nextLong()
+        {
+            return Long.parseLong(next());
+        }
+        double nextDouble()
+        {
+            return Double.parseDouble(next());
+        }
+        String nextLine()
+        {
+            String str="""";
+            try
+            {
+                str=br.readLine();
+            }
+            catch (IOException e)
+            {
+                e.printStackTrace();
+            }
+            return str;
+        }
+    }
+}","import java.util.*;
+import java.util.Scanner;
+
+
+public class Solution {
+	static int mod=1000000007;;
+	
+//	 
+	public static void main(String[] args) {
+		// TODO Auto-generated method stub
+//		System.out.println();
+
+		Scanner sc=new Scanner(System.in);
+		int tt=sc.nextInt();
+//		
+//		
+		while(tt-->0){
+				int n=sc.nextInt();
+			
+				int k[]=new int[n];
+				int h[]=new int[n];
+				
+				for(int i=0;i<n;i++) {
+					k[i]=sc.nextInt();
+				}
+				for(int i=0;i<n;i++) {
+					h[i]=sc.nextInt();
+				}
+				long ans=0;
+				int start=k[0]-h[0]-1;
+				int end=k[0];
+				int last=0;
+				for(int j=0;j<n;j++) {
+					 start=k[j]-h[j]+1;
+					 end=k[j];
+					 last=j;
+				for(int i=j+1;i<n;i++) {
+					int temp=k[i]-h[i]+1;
+					
+					if(temp<=end) {
+						start=Math.min(start, temp);
+						end=Math.max(end, k[i]);
+						last=i;
+					}
+					
+					
+					
+				}
+				j=last;
+				
+				long va=end-start+1;
+				
+				ans+=(va*(va+1))/2;
+				
+				}
+				System.out.println(ans);
+				
+			
+		}
+	}
+		
+		
+	
+		
+		
+	
+	
+	
+
+
+}
+",0
+22b41936,29210e56,"
+
+
+import java.io.*;
+import java.util.*;
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.util.Collections;
+import java.io.InputStreamReader;
+import static java.lang.Math.*;
+import static java.lang.System.*;
+
+public class Main1 {
+
+     static ArrayList<Integer> list1 = new ArrayList<>() ;
+     static ArrayList<Integer> list2 = new ArrayList<>() ;
+     static int n , m ;
+     static long dp[][] ;
+
+     static long solver(int i , int j ){
+         // i = empty chairs
+
+         if (j == m)return 0 ;
+         int tt1 = n-i ;
+         int tt2 = m-j ;
+         if (n-i < m-j)return  Long.MAX_VALUE/2  ;
+         if ( dp[i][j] != -1 )return dp[i][j] ;
+
+        long a = solver(i+1 , j) ;
+        long b = abs( list1.get(i) - list2.get(j)) + solver(i+1 , j+1) ;
+
+        return dp[i][j] = min(a , b) ;
+
+     }
+
+
+
+    public static void main(String[] args) throws IOException {
+
+//        try {
+
+
+            FastScanner in = new FastScanner();
+            PrintWriter out = new PrintWriter(System.out);
+
+
+            int N = in.nextInt() ;
+            int a[] = in.readArray(N) ;
+        for (int i = 0; i <N ; i++) {
+            if (a[i] == 1)list2.add(i) ;
+            else list1.add(i) ;
+        }
+
+         n = list1.size() ;
+         m = list2.size() ;
+            dp = new long[n][m] ;
+
+
+            for(int i=0 ; i<n ; i++)
+                for(int j=0 ; j<m ; j++)
+                    dp[i][j] = -1 ;
+
+     
+        System.out.println(solver(0 , 0 ));
+
+
+
+
+
+
+
+
+            out.flush();
+            out.close();
+
+//        }
+//        catch (Exception e){
+//            return;
+//        }
+
+    }
+
+    static long gcd(long a, long b) {
+        return (b == 0) ? a : gcd(b, a % b);
+    }
+
+    static ArrayList<Integer> list = new ArrayList<>();
+    static boolean A[] = new boolean[2 * 90000001];
+
+
+    static void seive(int n) {
+        int maxn = n;
+        //int maxn = 1000000  ;
+        A[0] = A[1] = true;
+
+        for (int i = 2; i * i <= maxn; i++) {
+            if (!A[i]) {
+                for (int j = i * i; j <= maxn; j += i)
+                    A[j] = true;
+            }
+        }
+
+        for (int i = 2; i <= maxn; i++)
+            if (!A[i])
+                list.add(i);
+
+    }
+
+    static int findLCA(int a, int b, int par[][], int depth[]) {
+        if (depth[a] > depth[b]) {
+            a = a ^ b;
+            b = a ^ b;
+            a = a ^ b;
+        }
+        int diff = depth[b] - depth[a];
+        for (int i = 19; i >= 0; i--) {
+            if ((diff & (1 << i)) > 0) {
+                b = par[b][i];
+            }
+        }
+        if (a == b)
+            return a;
+        for (int i = 19; i >= 0; i--) {
+            if (par[b][i] != par[a][i]) {
+                b = par[b][i];
+                a = par[a][i];
+            }
+        }
+        return par[a][0];
+    }
+
+    static int gcd(int a, int b) {
+        return (b == 0) ? a : gcd(b, a % b);
+    }
+
+    static void formArrayForBinaryLifting(int n, int par[][]) {
+        for (int j = 1; j < 20; j++) {
+            for (int i = 0; i < n; i++) {
+                if (par[i][j - 1] == -1)
+                    continue;
+                par[i][j] = par[par[i][j - 1]][j - 1];
+            }
+        }
+    }
+
+
+    static void sort(int ar[]) {
+        int n = ar.length;
+        ArrayList<Integer> a = new ArrayList<>();
+        for (int i = 0; i < n; i++)
+            a.add(ar[i]);
+        Collections.sort(a);
+        for (int i = 0; i < n; i++)
+            ar[i] = a.get(i);
+    }
+
+    static void sort1(long ar[]) {
+        int n = ar.length;
+        ArrayList<Long> a = new ArrayList<>();
+        for (int i = 0; i < n; i++)
+            a.add(ar[i]);
+        Collections.sort(a);
+        for (int i = 0; i < n; i++)
+            ar[i] = a.get(i);
+    }
+
+    static long ncr(long n, long r, long mod) {
+        if (r == 0)
+            return 1;
+        long val = ncr(n - 1, r - 1, mod);
+        val = (n * val) % mod;
+        val = (val * modInverse(r, mod)) % mod;
+        return val;
+    }
+
+    static long fast_pow(long base, long n, long M) {
+        if (n == 0)
+            return 1;
+        if (n == 1)
+            return base % M;
+        long halfn = fast_pow(base, n / 2, M);
+        if (n % 2 == 0)
+            return (halfn * halfn) % M;
+        else
+            return (((halfn * halfn) % M) * base) % M;
+    }
+
+    static long modInverse(long n, long M) {
+        return fast_pow(n, M - 2, M);
+    }
+
+
+    private static int countDigits(long l) {
+        if (l >= 1000000000000000000L) return 19;
+        if (l >= 100000000000000000L) return 18;
+        if (l >= 10000000000000000L) return 17;
+        if (l >= 1000000000000000L) return 16;
+        if (l >= 100000000000000L) return 15;
+        if (l >= 10000000000000L) return 14;
+        if (l >= 1000000000000L) return 13;
+        if (l >= 100000000000L) return 12;
+        if (l >= 10000000000L) return 11;
+        if (l >= 1000000000L) return 10;
+        if (l >= 100000000L) return 9;
+        if (l >= 10000000L) return 8;
+        if (l >= 1000000L) return 7;
+        if (l >= 100000L) return 6;
+        if (l >= 10000L) return 5;
+        if (l >= 1000L) return 4;
+        if (l >= 100L) return 3;
+        if (l >= 10L) return 2;
+        return 1;
+    }
+
+
+    static class FastOutput implements AutoCloseable, Closeable, Appendable {
+        private static final int THRESHOLD = 32 << 10;
+        private final Writer os;
+        private StringBuilder cache = new StringBuilder(THRESHOLD * 2);
+
+        public FastOutput append(CharSequence csq) {
+            cache.append(csq);
+            return this;
+        }
+
+        public FastOutput append(CharSequence csq, int start, int end) {
+            cache.append(csq, start, end);
+            return this;
+        }
+
+        private void afterWrite() {
+            if (cache.length() < THRESHOLD) {
+                return;
+            }
+            flush();
+        }
+
+        public FastOutput(Writer os) {
+            this.os = os;
+        }
+
+        public FastOutput(OutputStream os) {
+            this(new OutputStreamWriter(os));
+        }
+
+        public FastOutput append(char c) {
+            cache.append(c);
+            afterWrite();
+            return this;
+        }
+
+        public FastOutput append(long c) {
+            cache.append(c);
+            afterWrite();
+            return this;
+        }
+
+        public FastOutput append(String c) {
+            cache.append(c);
+            afterWrite();
+            return this;
+        }
+
+        public FastOutput println() {
+            return append(System.lineSeparator());
+        }
+
+        public FastOutput flush() {
+            try {
+                //            boolean success = false;
+                //            if (stringBuilderValueField != null) {
+                //                try {
+                //                    char[] value = (char[]) stringBuilderValueField.get(cache);
+                //                    os.write(value, 0, cache.length());
+                //                    success = true;
+                //                } catch (Exception e) {
+                //                }
+                //            }
+                //            if (!success) {
+                os.append(cache);
+                //            }
+                os.flush();
+                cache.setLength(0);
+            } catch (IOException e) {
+                throw new UncheckedIOException(e);
+            }
+            return this;
+        }
+
+        public void close() {
+            flush();
+            try {
+                os.close();
+            } catch (IOException e) {
+                throw new UncheckedIOException(e);
+            }
+        }
+
+        public String toString() {
+            return cache.toString();
+        }
+
+    }
+
+
+    static class FastScanner {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st = new StringTokenizer("""");
+
+        String next() {
+            while (!st.hasMoreTokens())
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        int[] readArray(int n) {
+            int[] a = new int[n];
+            for (int i = 0; i < n; i++) a[i] = nextInt();
+            return a;
+        }
+
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+    }
+
+
+}
+
+
+
+
+
+
+
+","import java.util.*;
+import java.io.*;
+import java.math.*;
+
+/**
+ *
+ * @Har_Har_Mahadev
+ */
+
+/**
+ * Main , Solution , Remove Public
+ */
+public class A {
+
+	private static long[][] dp;
+	private static ArrayList<Integer> lis1,lis0;
+
+	public static void process() throws IOException {
+
+		int n = sc.nextInt();
+		int arr[] = sc.readArray(n);
+		lis1 = new ArrayList<Integer>();
+		lis0 = new ArrayList<Integer>();
+		for(int i = 0; i<n; i++) {
+			if(arr[i] == 1)lis1.add(i+1);
+			else lis0.add(i+1);
+		}
+		Collections.sort(lis0);
+		Collections.sort(lis1);
+		int n0 = lis0.size();
+		int n1 = lis1.size();
+		dp = new long[n0+1][n1+1];
+		for(int i = 0; i<=n0; i++) {
+			Arrays.fill(dp[i], -1);
+		}
+		long ans = solve(0,0,n0,n1);
+		println(ans);
+		
+
+	}
+
+	private static long solve(int i, int j, int n0, int n1) {
+		if(j == n1)return 0;
+		if(i == n0)return INF;
+		if(dp[i][j] != -1)return dp[i][j];
+		long ans = solve(i+1, j, n0, n1);
+		ans = min(ans,abs(lis0.get(i) - lis1.get(j)) + solve(i+1, j+1, n0, n1));
+		return dp[i][j] = ans;
+	}
+
+	//=============================================================================
+	//--------------------------The End---------------------------------
+	//=============================================================================
+	private static long INF = 2000000000000000000L, M = 1000000007, MM = 998244353;
+	private static int N = 0;
+
+	private static void google(int tt) {
+		System.out.print(""Case #"" + (tt) + "": "");
+	}
+
+	static FastScanner sc;
+	static PrintWriter out;
+
+	public static void main(String[] args) throws IOException {
+		boolean oj = true;
+		if (oj) {
+			sc = new FastScanner();
+			out = new PrintWriter(System.out);
+		} else {
+			sc = new FastScanner(100);
+			out = new PrintWriter(""output.txt"");
+		}
+		int t = 1;
+//		t = sc.nextInt();
+		int TTT = 1;
+		while (t-- > 0) {
+			//			google(TTT++);
+			process();
+		}
+		out.flush();
+		out.close();
+	}
+
+	static class Pair implements Comparable<Pair> {
+		int x, y;
+
+		Pair(int x, int y) {
+			this.x = x;
+			this.y = y;
+		}
+
+		@Override
+		public int compareTo(Pair o) {
+			return Integer.compare(this.x, o.x);
+		}
+
+		//		 @Override
+		//		    public boolean equals(Object o) {
+		//		        if (this == o) return true;
+		//		        if (!(o instanceof Pair)) return false;
+		//		        Pair key = (Pair) o;
+		//		        return x == key.x && y == key.y;
+		//		    }
+		//		 
+		//		    @Override
+		//		    public int hashCode() {
+		//		        int result = x;
+		//		        result = 31 * result + y;
+		//		        return result;
+		//		    }
+	}
+
+	/////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+	static void println(Object o) {
+		out.println(o);
+	}
+
+	static void println() {
+		out.println();
+	}
+
+	static void print(Object o) {
+		out.print(o);
+	}
+
+	static void pflush(Object o) {
+		out.println(o);
+		out.flush();
+	}
+
+	static int ceil(int x, int y) {
+		return (x % y == 0 ? x / y : (x / y + 1));
+	}
+
+	static long ceil(long x, long y) {
+		return (x % y == 0 ? x / y : (x / y + 1));
+	}
+
+	static int max(int x, int y) {
+		return Math.max(x, y);
+	}
+
+	static int min(int x, int y) {
+		return Math.min(x, y);
+	}
+
+	static int abs(int x) {
+		return Math.abs(x);
+	}
+
+	static long abs(long x) {
+		return Math.abs(x);
+	}
+
+	static long sqrt(long z) {
+		long sqz = (long) Math.sqrt(z);
+		while (sqz * 1L * sqz < z) {
+			sqz++;
+		}
+		while (sqz * 1L * sqz > z) {
+			sqz--;
+		}
+		return sqz;
+	}
+
+	static int log2(int N) {
+		int result = (int) (Math.log(N) / Math.log(2));
+		return result;
+	}
+
+	static long max(long x, long y) {
+		return Math.max(x, y);
+	}
+
+	static long min(long x, long y) {
+		return Math.min(x, y);
+	}
+
+	public static int gcd(int a, int b) {
+		BigInteger b1 = BigInteger.valueOf(a);
+		BigInteger b2 = BigInteger.valueOf(b);
+		BigInteger gcd = b1.gcd(b2);
+		return gcd.intValue();
+	}
+
+	public static long gcd(long a, long b) {
+		BigInteger b1 = BigInteger.valueOf(a);
+		BigInteger b2 = BigInteger.valueOf(b);
+		BigInteger gcd = b1.gcd(b2);
+		return gcd.longValue();
+	}
+
+	public static long lcm(long a, long b) {
+		return (a * b) / gcd(a, b);
+	}
+
+	public static int lcm(int a, int b) {
+		return (a * b) / gcd(a, b);
+	}
+
+	public static int lower_bound(int[] arr, int x) {
+		int low = 0, high = arr.length, mid = -1;
+
+		while (low < high) {
+			mid = (low + high) / 2;
+
+			if (arr[mid] >= x)
+				high = mid;
+			else
+				low = mid + 1;
+		}
+
+		return low;
+	}
+
+	public static int upper_bound(int[] arr, int x) {
+		int low = 0, high = arr.length, mid = -1;
+
+		while (low < high) {
+			mid = (low + high) / 2;
+
+			if (arr[mid] > x)
+				high = mid;
+			else
+				low = mid + 1;
+		}
+
+		return low;
+	}
+
+	/////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+	static class FastScanner {
+		BufferedReader br;
+		StringTokenizer st;
+
+		FastScanner() throws FileNotFoundException {
+			br = new BufferedReader(new InputStreamReader(System.in));
+		}
+
+		FastScanner(int a) throws FileNotFoundException {
+			br = new BufferedReader(new FileReader(""input.txt""));
+		}
+
+		String next() throws IOException {
+			while (st == null || !st.hasMoreElements()) {
+				try {
+					st = new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			}
+			return st.nextToken();
+		}
+
+		int nextInt() throws IOException {
+			return Integer.parseInt(next());
+		}
+
+		long nextLong() throws IOException {
+			return Long.parseLong(next());
+		}
+
+		double nextDouble() throws IOException {
+			return Double.parseDouble(next());
+		}
+
+		String nextLine() throws IOException {
+			String str = """";
+			try {
+				str = br.readLine();
+			} catch (IOException e) {
+				e.printStackTrace();
+			}
+			return str;
+		}
+
+		int[] readArray(int n) throws IOException {
+			int[] A = new int[n];
+			for (int i = 0; i != n; i++) {
+				A[i] = sc.nextInt();
+			}
+			return A;
+		}
+
+		long[] readArrayLong(int n) throws IOException {
+			long[] A = new long[n];
+			for (int i = 0; i != n; i++) {
+				A[i] = sc.nextLong();
+			}
+			return A;
+		}
+	}
+
+	static void ruffleSort(int[] a) {
+		Random get = new Random();
+		for (int i = 0; i < a.length; i++) {
+			int r = get.nextInt(a.length);
+			int temp = a[i];
+			a[i] = a[r];
+			a[r] = temp;
+		}
+		Arrays.sort(a);
+	}
+
+	static void ruffleSort(long[] a) {
+		Random get = new Random();
+		for (int i = 0; i < a.length; i++) {
+			int r = get.nextInt(a.length);
+			long temp = a[i];
+			a[i] = a[r];
+			a[r] = temp;
+		}
+		Arrays.sort(a);
+	}
+}
+",0
+ccc8ef27,d6fb3b9e,"import java.util.*;
+public class Sol
+{
+    public static void main(String[] args)
+    {
+        Scanner sc = new Scanner(System.in);
+        int t = sc.nextInt();
+        while(t-->0)
+        {
+			int n = sc.nextInt();
+			int a[][]=new int[n][5];
+			int tot[]=new int[n];
+			for(int i=0;i<n;i++)
+			{
+				String x = sc.next();
+				for(int j=0;j<x.length();j++)
+					a[i][x.charAt(j)-'a'] += 1;
+				tot[i]=x.length();
+			}
+			
+			int max=Integer.MIN_VALUE;
+			for(int i=0;i<5;i++)
+				max=Math.max(max,function(a,n,i,tot));
+			System.out.println(max);
+			
+		}	
+    }
+	static int function(int a[][],int n,int i,int tot[])
+	{
+		Integer ans[] = new Integer[n];
+		for(int j=0;j<n;j++)
+			ans[j]=a[j][i]-(tot[j]-a[j][i]);
+		int res=0,j=0;
+		Arrays.sort(ans,Collections.reverseOrder());
+		while(j<n&&res+ans[j]>0)
+			res+=ans[j++];
+		return j;
+	}
+}","import java.util.*;
+public class Sol
+{
+    public static void main(String[] args)
+    {
+        Scanner sc = new Scanner(System.in);
+        int t = sc.nextInt();
+        while(t-->0)
+        {
+			int n = sc.nextInt();
+			int a[][]=new int[n][5];
+			int tot[]=new int[n];
+			for(int i=0;i<n;i++)
+			{
+				String x = sc.next();
+				for(int j=0;j<x.length();j++)
+					a[i][x.charAt(j)-'a'] += 1;
+				tot[i]=x.length();
+			}
+			
+			int max=Integer.MIN_VALUE;
+			for(int i=0;i<5;i++)
+				max=Math.max(max,function(a,n,i,tot));
+			System.out.println(max);
+			
+		}	
+    }
+	static int function(int a[][],int n,int i,int tot[])
+	{
+		Integer ans[] = new Integer[n];
+		for(int j=0;j<n;j++)
+			ans[j]=a[j][i]-(tot[j]-a[j][i]);
+		int res=0,j=0;
+		Arrays.sort(ans,Collections.reverseOrder());
+		while(j<n&&res+ans[j]>0)
+			res+=ans[j++];
+		return j;
+	}
+}
+",1
+1230c43e,2bbf754b,"//package com.company;
+
+import java.io.*;
+import java.math.BigInteger;
+import java.util.*;
+
+public class Main {
+
+    static boolean[] primecheck = new boolean[1000002];
+
+    public static void main(String[] args) throws IOException {
+        OutputStream outputStream = System.out;
+        FastReader in = new FastReader();
+        PrintWriter out = new PrintWriter(outputStream);
+        PROBLEM solver = new PROBLEM();
+        int t = 1;
+        t = in.nextInt();
+        for (int i = 0; i < t; i++) {
+            solver.solve(in, out);
+        }
+        out.close();
+    }
+
+    static class PROBLEM {
+
+        public void solve(FastReader in, PrintWriter out) {
+
+            int n = in.nextInt();
+            int[] a = in.readArray(n);
+            char[] c = in.nextLine().toCharArray();
+            int cur = 1;
+
+            ArrayList<Pair> p = new ArrayList<>();
+            for (int i = 0; i < n; i++) {
+                p.add(new Pair(c[i], a[i]));
+            }
+
+            Collections.sort(p);
+//            for (int i = 0; i < n; i++) {
+//                out.println(p.get(i).x + "" "" + p.get(i).y);
+//            }
+
+            for (int i = 0; i < n; i++) {
+                if(p.get(i).x == 'B' && p.get(i).y < i+1){
+                    out.println(""NO"");
+                    return;
+                }
+                if(p.get(i).x == 'R' && p.get(i).y > i+1){
+                    out.println(""NO"");
+                    return;
+                }
+            }
+
+            out.println(""YES"");
+
+//            int n = in.nextInt(), m = in.nextInt();
+//            char[] s = in.nextLine().toCharArray();
+//
+//            int rl = 0, ud = 0, r = 0 , l = 0, rlf = 0, udf = 0;
+//            int lmax = 0, rmax = 0, umax = 0, dmax = 0;
+//
+//            for (int i = 0; i < s.length; i++) {
+//                if(s[i] == 'L'){
+//                    if(rlf == 0) rlf = -1;
+//                    rl--;
+//                    l--;
+//                    if(rl == 0) l = 0;
+//                    if(rl < 0 && lmax+rmax <= m) lmax = Math.max(Math.abs(l), lmax);
+//                }
+//                if(s[i] == 'R'){
+//                    if(rlf == 0) rlf = 1;
+//                    rl++;
+//                    r++;
+//
+//                    if(rl > 0 && lmax+rmax <= m) rmax = Math.max(r, rmax);
+//                }
+//                if(s[i] == 'U'){
+//                    if(udf == 0) udf = 1;
+//                    ud++;
+//                    r = Math.max(Math.abs(ud), r);
+//                    if(ud > 0 && umax+dmax <= n) umax = Math.max(Math.abs(ud), umax);
+//                }
+//                if(s[i] == 'D'){
+//                    if(udf == 0) udf = -1;
+//                    ud--;
+//                    r = Math.max(Math.abs(ud), r);
+//                    if(ud < 0 && umax+dmax <= n) dmax = Math.max(Math.abs(ud), dmax);
+//                }
+//            }
+//
+//            int ansc = 0, ansr = 0;
+//
+//            out.println(rlf + ""  lmx = "" + lmax + "" rmax"" + rmax);
+//
+//            if(rlf == 1) ansc = m-rmax;
+//            else if(rlf == -1) ansc = 1+lmax;
+//            else ansc = 1;
+//
+//            if(udf == 1) ansr = 1+umax;
+//            else if(udf == -1) ansr = m-dmax;
+//            else ansr = 1;
+//
+//            out.println(ansr + "" "" + ansc);
+
+        }
+    }
+
+    static HashMap<Integer, Integer> initializeMap(int n){
+        HashMap<Integer,Integer> hm = new HashMap<>();
+        for (int i = 0; i <= n; i++) {
+            hm.put(i, 0);
+        }
+        return hm;
+    }
+
+    static boolean isRegular(char[] c){
+
+        Stack<Character> s = new Stack<>();
+        for (char value : c) {
+            if (s.isEmpty() && value == ')') return false;
+
+            if (value == '(') s.push(value);
+            else s.pop();
+        }
+
+        return s.isEmpty();
+    }
+
+    static ArrayList<ArrayList<Integer>> createAdj(int n, int e){
+
+        FastReader in = new FastReader();
+        ArrayList<ArrayList<Integer>> adj = new ArrayList<>();
+
+        for (int i = 0; i < n + 1; i++) {
+            adj.add(new ArrayList<>());
+        }
+
+        for (int i = 0; i < e; i++) {
+
+            int a = in.nextInt(), b = in.nextInt();
+            System.out.println(a);
+
+            adj.get(a).add(b);
+            adj.get(b).add(a);
+        }
+
+
+        return adj;
+    }
+
+    static int binarySearch(int[] a, int l, int r, int x){
+        if(r>=l){
+            int mid = l + (r-l)/2;
+
+            if(a[mid] == x) return mid;
+
+            if(a[mid] > x) return binarySearch(a, l, mid-1, x);
+            else return binarySearch(a,mid+1, r, x);
+        }
+        return -1;
+    }
+
+    static boolean isPalindromeI(int n){
+
+        int d = 0;
+        int y = n;
+        while(y>0){
+            d++;
+            y/=10;
+        }
+
+        int[] a = new int[d];
+        for (int i = 0; i < d; i++) {
+            a[i] = n%10;
+            n/=10;
+        }
+
+        System.out.println(Arrays.toString(a));
+        for (int i = 0; i < d / 2; i++) {
+            if(a[i] != a[d-i-1]) return false;
+        }
+        return true;
+    }
+
+    static long gcd(long a, long b) {
+        if (b == 0) return a;
+        return gcd(b, a % b);
+    }
+
+    static long lcm(long a, long b)
+    {
+        return (a / gcd(a, b)) * b;
+    }
+
+    static boolean isSquare(double a) {
+        boolean isSq = false;
+        double b = Math.sqrt(a);
+        double c = Math.sqrt(a) - Math.floor(b);
+
+        if (c == 0) isSq = true;
+
+        return isSq;
+    }
+
+    static int exponentMod(int A, int B, int C) {
+
+        // Base cases
+        if (A == 0)
+            return 0;
+        if (B == 0)
+            return 1;
+
+        // If B is even
+        long y;
+        if (B % 2 == 0) {
+            y = exponentMod(A, B / 2, C);
+            y = (y * y) % C;
+        }
+
+        // If B is odd
+        else {
+            y = A % C;
+            y = (y * exponentMod(A, B - 1, C) % C) % C;
+        }
+
+        return (int) ((y + C) % C);
+    }
+
+
+    static class Pair implements Comparable<Pair>{
+
+        char x;
+        int y;
+
+        Pair(char x, int y){
+            this.x = x;
+            this.y = y;
+        }
+
+        public int compareTo(Pair o){
+            int ans = Integer.compare(x, o.x);
+            if(o.x == x) ans = Integer.compare(y, o.y);
+
+            return ans;
+        }
+    }
+
+    static class Tuple implements Comparable<Tuple>{
+
+        int x, y, id;
+
+        Tuple(int x, int y, int id){
+            this.x = x;
+            this.y = y;
+            this.id = id;
+        }
+
+        public int compareTo(Tuple o){
+            int ans = Integer.compare(x, o.x);
+            if(o.x == x) ans = Integer.compare(y, o.y);
+
+            return ans;
+        }
+    }
+
+//    public static class Pair<U extends Comparable<U>, V extends Comparable<V>> implements Comparable<Pair<U, V>> {
+//        public U x;
+//        public V y;
+//
+//        public Pair(U x, V y) {
+//            this.x = x;
+//            this.y = y;
+//        }
+//
+//        public int hashCode() {
+//            return (x == null ? 0 : x.hashCode() * 31) + (y == null ? 0 : y.hashCode());
+//        }
+//
+//        public boolean equals(Object o) {
+//            if (this == o)
+//                return true;
+//            if (o == null || getClass() != o.getClass())
+//                return false;
+//            Pair<U, V> p = (Pair<U, V>) o;
+//            return (x == null ? p.x == null : x.equals(p.x)) && (y == null ? p.y == null : y.equals(p.y));
+//        }
+//
+//        public int compareTo(Pair<U, V> b) {
+//            int cmpU = x.compareTo(b.x);
+//            return cmpU != 0 ? cmpU : y.compareTo(b.y);
+//        }
+//
+//        public int compareToY(Pair<U, V> b) {
+//            int cmpU = y.compareTo(b.y);
+//            return cmpU != 0 ? cmpU : x.compareTo(b.x);
+//        }
+//
+//        public String toString() {
+//            return String.format(""(%s, %s)"", x.toString(), y.toString());
+//        }
+//
+//    }
+
+    static class FastReader {
+        BufferedReader br;
+        StringTokenizer st;
+
+        public FastReader() {
+            br = new BufferedReader(new InputStreamReader(System.in));
+        }
+
+        String next() {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+
+        char nextChar() {
+            return next().charAt(0);
+        }
+
+        boolean nextBoolean() {
+            return !(nextInt() == 0);
+        }
+        // boolean nextBoolean(){return Boolean.parseBoolean(next());}
+
+        String nextLine() {
+            String str = """";
+            try {
+                str = br.readLine();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+        }
+
+        public int[] readArray(int size) {
+            int[] array = new int[size];
+            for (int i = 0; i < size; i++) array[i] = nextInt();
+            return array;
+        }
+
+    }
+
+    private static int[] mergeSort(int[] array) {
+
+        //array.length replaced with ctr
+        int ctr = array.length;
+        if (ctr <= 1) {
+            return array;
+        }
+
+        int midpoint = ctr / 2;
+
+        int[] left = new int[midpoint];
+        int[] right;
+
+        if (ctr % 2 == 0) {
+            right = new int[midpoint];
+        } else {
+            right = new int[midpoint + 1];
+        }
+
+        for (int i = 0; i < left.length; i++) {
+            left[i] = array[i];
+        }
+
+        for (int i = 0; i < right.length; i++) {
+            right[i] = array[i + midpoint];
+        }
+
+        int[] result = new int[array.length];
+
+        left = mergeSort(left);
+        right = mergeSort(right);
+
+        result = merge(left, right);
+
+        return result;
+    }
+
+    private static int[] merge(int[] left, int[] right) {
+
+        int[] result = new int[left.length + right.length];
+        int leftPointer = 0, rightPointer = 0, resultPointer = 0;
+
+        while (leftPointer < left.length || rightPointer < right.length) {
+
+            if (leftPointer < left.length && rightPointer < right.length) {
+
+                if (left[leftPointer] < right[rightPointer]) {
+                    result[resultPointer++] = left[leftPointer++];
+                } else {
+                    result[resultPointer++] = right[rightPointer++];
+                }
+            } else if (leftPointer < left.length) {
+                result[resultPointer++] = left[leftPointer++];
+            } else {
+                result[resultPointer++] = right[rightPointer++];
+            }
+        }
+        return result;
+    }
+
+    public static void Sieve(int n) {
+
+        Arrays.fill(primecheck, true);
+        primecheck[0] = false;
+        primecheck[1] = false;
+
+        for (int i = 2; i * i < n + 1; i++) {
+            if (primecheck[i]) {
+                for (int j = i * 2; j < n + 1; j += i) {
+                    primecheck[j] = false;
+                }
+            }
+        }
+    }
+}
+
+
+","import java.util.*;
+
+/** 
+__                  __
+( _)                ( _)
+/ / \\              / /\_\_
+/ /   \\            / / | \ \
+/ /     \\          / /  |\ \ \
+/  /   ,  \ ,       / /   /|  \ \
+/  /    |\_ /|      / /   / \   \_\
+/  /  |\/ _ '_| \   / /   /   \    \\
+|  /   |/  0 \0\    / |    |    \    \\
+|    |\|      \_\_ /  /    |     \    \\
+|  | |/    \.\ o\o)  /      \     |    \\
+\    |     /\\`v-v  /        |    |     \\
+| \/    /_| \\_|  /         |    | \    \\
+| |    /__/_ `-` /   _____  |    |  \    \\
+\|    [__]  \_/  |_________  \   |   \    ()
+/    [___] (    \         \  |\ |   |   //
+|    [___]                  |\| \|   /  |/
+/|    [____]                  \  |/\ / / ||
+(  \   [____ /     ) _\      \  \    \| | ||
+\  \  [_____|    / /     __/    \   / / //
+|   \ [_____/   / /        \    |   \/ //
+|   /  '----|   /=\____   _/    |   / //
+__ /  /        |  /   ___/  _/\    \  | ||
+(/-(/-\)       /   \  (/\/\)/  |    /  | /
+(/\/\)           /   /   //
+_________/   /    /
+\____________/    (
+
+
+
+*/
+
+public class Main {
+	public static void main(String[] args) {
+		Scanner sc=new Scanner(System.in);
+		int  t=sc.nextInt();
+		while(t-- >0) {
+			int n=sc.nextInt();
+			int[] arr=new int[n];
+			for(int i=0;i<n;i++) {
+				arr[i]=sc.nextInt();
+			}
+			String str=sc.next();
+			
+			ArrayList<Pair> plist=new ArrayList<>();
+			for(int i=0;i<n;i++) {
+				char ch=str.charAt(i);
+				plist.add(new Pair(arr[i],ch));
+			}
+			
+			//B-reduce
+			//R-increse
+			Collections.sort(plist);
+			
+			int counter=1;
+			boolean flag=false;
+			for(int i=0;i<plist.size();i++) {
+				int val=plist.get(i).number;
+				int clr=plist.get(i).color;
+				
+				if(clr=='B') {
+					if(val<counter) {
+						flag=true;
+						break;
+					}
+				}
+				else {
+					if(val>counter) {
+						flag=true;
+						break;
+					}
+					
+				}
+				counter++;
+			}
+			System.out.println(flag?""NO"":""YES"");
+			
+			
+		}
+	}
+	public static class Pair implements Comparable<Pair>{
+		int number;
+		char color;
+		
+		Pair(int number,char color){
+			this.number=number;
+			this.color=color;
+		}
+		
+		@Override
+		public int compareTo(Pair o) {
+			if(o.color==this.color) {
+				return this.number-o.number;
+			}
+			else {
+				return this.color-o.color;
+			}
+		}
+		
+		public String toString() {
+			return number+""-""+color+""."";
+		}
+	}
+}
+",0
+3380fa52,f28b8cb4,"import java.util.*;
+import java.io.*;
+import java.math.*;
+
+/* Name of the class has to be ""Main"" only if the class is public. */
+public class Coder {
+  static int n, k;
+  static long a[];
+  static int pos[];
+  static int temp[];
+  static StringBuilder str = new StringBuilder("""");
+  static int cnt[][] = new int[(int)1e5+5][2];
+  static void solve() {
+    long []l = new long[n];
+    long []r = new long[n];
+    long p = Integer.MAX_VALUE;
+    for(int i=0;i<n;i++){
+        p = Math.min(p+1, a[i]);
+        l[i] = p;
+    }
+    p=Integer.MAX_VALUE;
+    for(int i=n-1;i>=0;i--){
+     p = Math.min(p+1, a[i]);
+     r[i] = p;
+    }
+    for(int i=0;i<n;i++){
+        str.append(Math.min(l[i],r[i])).append("" "");
+    }
+    str.append(""\n"");
+  }
+
+  public static void main(String[] args) throws java.lang.Exception {
+    BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
+    int t = Integer.parseInt(bf.readLine().trim());
+    while (t-- > 0) {
+      bf.readLine();
+      String s[] = bf.readLine().trim().split(""\\s+"");
+      n = Integer.parseInt(s[0]);
+      k = Integer.parseInt(s[1]);
+      s = bf.readLine().trim().split(""\\s+"");
+      pos = new int[k];
+      temp = new int[k];
+      a = new long[n];
+      for(int i=0;i<k;i++) pos[i]=Integer.parseInt(s[i]);
+      s = bf.readLine().trim().split(""\\s+"");
+      for(int i=0;i<k;i++) temp[i]=Integer.parseInt(s[i]);
+      Arrays.fill(a, Integer.MAX_VALUE);
+      for(int i=0;i<k;i++) a[pos[i]-1] = temp[i]; 
+      solve();
+    }
+    System.out.print(str);
+  }
+}","import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.lang.reflect.Array;
+import java.util.Arrays;
+import java.util.StringTokenizer;
+
+public class Main {
+    private static int gcd(int a, int b) {
+        return b == 0 ? a : gcd(b, a % b);
+    }
+
+    public static void main(String[] args) throws IOException {
+        BufferedReader br = new BufferedReader(
+                new InputStreamReader(System.in));
+
+        int q = Integer.parseInt(br.readLine());
+
+        for (int i = 0; i < q; i++) {
+            br.readLine();
+
+            StringTokenizer st = new StringTokenizer(br.readLine());
+            int n = Integer.parseInt(st.nextToken());
+            int k = Integer.parseInt(st.nextToken());
+
+            // read input a
+            st = new StringTokenizer(br.readLine());
+            int[] a = new int[k];
+            for (int j = 0; j < k; j++) {
+                a[j] = Integer.parseInt(st.nextToken());
+            }
+
+            // read input t
+            st = new StringTokenizer(br.readLine());
+            int[] t = new int[k];
+            for (int j = 0; j < k; j++) {
+                t[j] = Integer.parseInt(st.nextToken());
+            }
+
+            // known temperatures
+            int[] c = new int[n];
+            Arrays.fill(c, Integer.MAX_VALUE);
+            for (int j = 0; j < k; j++) {
+                c[a[j] - 1] = t[j];
+            }
+
+            // temperature from left to right
+            long[] left = new long[n];
+            Arrays.fill(left, Integer.MAX_VALUE);
+            long p = Integer.MAX_VALUE;
+            for (int j = 0; j < n; j++) {
+                p = Math.min(p + 1, c[j]);
+                left[j] = p;
+            }
+
+            // temperature from right to left
+            long[] right = new long[n];
+            Arrays.fill(right, Integer.MAX_VALUE);
+            p = Integer.MAX_VALUE;
+            for (int j = n - 1; j >= 0; j--) {
+                p = Math.min(p + 1, c[j]);
+                right[j] = p;
+            }
+
+            for (int j = 0; j < n; j++) {
+                System.out.print(Math.min(left[j], right[j]) + "" "");
+            }
+            System.out.println();
+        }
+    }
+}
+",1
+2c7a0000,f4f1b18f,"import java.io.*;
+import java.util.*;
+ 
+public class Codeforces {
+	public static void main(String[] args) throws IOException {
+		
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		//int cases = Integer.parseInt(br.readLine());
+		//while(cases-- > 0) {
+			int n = Integer.parseInt(br.readLine());
+			String[] str = br.readLine().split("" "");
+			int[] a = new int[n];
+			int k = 0;
+			ArrayList<Integer> pos = new ArrayList<>();
+			for(int i=0; i<n; i++) {
+				a[i] = Integer.parseInt(str[i]);
+				if(a[i] == 1) {
+					k++;
+					pos.add(i);
+				}
+			}
+			int[][] dp = new int[n+1][k+1];
+			for(int i=0; i<=n; i++) {
+				Arrays.fill(dp[i], Integer.MAX_VALUE);
+			}
+			dp[0][0] = 0;
+			for(int i=0; i<n; i++) {
+				for(int j=0; j<=k; j++) {
+					if(dp[i][j] == Integer.MAX_VALUE) {
+						continue;
+					}
+					dp[i+1][j] = Math.min(dp[i+1][j], dp[i][j]);
+					if(j < k && a[i] == 0) {
+						dp[i+1][j+1] = Math.min(dp[i+1][j+1], dp[i][j]+Math.abs(pos.get(j)-i));
+					}
+				}
+			}
+			System.out.println(dp[n][k]);
+		//}
+	}
+}
+","import java.io.OutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.PrintWriter;
+import java.util.Arrays;
+import java.util.StringTokenizer;
+import java.io.IOException;
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.io.InputStream;
+
+public class Main {
+  public static void main(String[] args) {
+    InputStream inputStream = System.in;
+    OutputStream outputStream = System.out;
+    FastScanner in = new FastScanner(inputStream);
+    PrintWriter out = new PrintWriter(outputStream);
+    DArmchairs solver = new DArmchairs();
+    solver.solve(1, in, out);
+    out.close();
+  }
+
+  static class DArmchairs {
+    public void solve(int testNumber, FastScanner in, PrintWriter out) {
+      int n = in.nextInt();
+      int[] a = in.nextIntArray(n);
+
+      int[] pos = new int[n];
+      int ptr = 0;
+      for (int i = 0; i < n; ++i) {
+        if (a[i] == 1) {
+          pos[ptr++] = i;
+        }
+      }
+      pos = Arrays.copyOf(pos, ptr);
+
+      int[][] dp = new int[n + 1][ptr + 1];
+      ArrayUtils.fill(dp, Integer.MAX_VALUE);
+      dp[0][0] = 0;
+      for (int i = 0; i < n; ++i) {
+        for (int j = 0; j <= ptr; ++j) {
+          if (dp[i][j] == Integer.MAX_VALUE) continue;
+          dp[i + 1][j] = Math.min(dp[i + 1][j], dp[i][j]);
+          if (j < ptr && a[i] == 0) {
+            dp[i + 1][j + 1] = Math.min(dp[i + 1][j + 1], dp[i][j] + Math.abs(pos[j] - i));
+          }
+        }
+      }
+      out.println(dp[n][ptr]);
+    }
+  }
+
+  static class ArrayUtils {
+    public static void fill(int[][] array, int value) {
+      for (int[] row : array) {
+        Arrays.fill(row, value);
+      }
+    }
+  }
+
+  static class FastScanner {
+    BufferedReader reader;
+    StringTokenizer tokenizer;
+
+    public FastScanner(InputStream inputStream) {
+      reader = new BufferedReader(new InputStreamReader(inputStream), 32768);
+      tokenizer = null;
+    }
+
+    public String next() {
+      while (tokenizer == null || !tokenizer.hasMoreTokens()) {
+        try {
+          tokenizer = new StringTokenizer(reader.readLine());
+        } catch (IOException e) {
+          throw new RuntimeException(e);
+        }
+      }
+      return tokenizer.nextToken();
+    }
+
+    public int nextInt() {
+      return Integer.parseInt(next());
+    }
+
+    public int[] nextIntArray(int n) {
+      int[] arr = new int[n];
+      for (int i = 0; i < n; i++) {
+        arr[i] = nextInt();
+      }
+      return arr;
+    }
+  }
+}
+",1
+2d1553b5,656d0f78,"// Main Code at the Bottom
+import java.util.*;
+import java.io.*; 
+public class Interactive{     
+    static long MOD=(long)1e9+7;
+    //debug
+    static void debug(Object... o) {
+        System.out.println(Arrays.deepToString(o));
+    }
+    static Scanner sc = new Scanner(System.in);
+    //Global variables and functions
+    static long query(int l, int r) {
+    	System.out.println(""? "" + l + "" "" + r);
+    	return sc.nextLong();
+    }
+    static int query(int i) {
+    	System.out.println(""? "" + i);
+    	return sc.nextInt();
+    }
+    //Main function(The main code starts from here)
+    public static void main (String[] args) throws java.lang.Exception {
+    	int test=1;
+    	test=sc.nextInt();
+    	while(test-->0) {
+    		int n = sc.nextInt();
+    		int ans[] = new int[n];
+    		for(int i = 1; i <= n; i++) {
+    			if(ans[i - 1] != 0) continue;
+    			HashSet<Integer> set = new HashSet<>();
+    			ArrayList<Integer> arr = new ArrayList<>();
+    			while(true) {
+    				int x = query(i);
+    				if(set.contains(x)) break;
+    				set.add(x);
+    				arr.add(x - 1);
+    			}
+    			for(int j = 0; j < arr.size(); j++) {
+    				ans[arr.get(j)] = arr.get((j + 1) % arr.size()) + 1;
+    			}
+    		}
+    		System.out.print(""! "");
+    		for(int x: ans) System.out.print(x+"" "");
+    		System.out.println();
+    	}
+    }
+}","import java.awt.Container;
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.math.BigInteger;
+
+import java.util.*;
+
+public class Main
+{
+    
+   
+   
+    public static void main(String[] args)
+    {
+        FastScanner input = new FastScanner();
+        int tc = input.nextInt();
+        work:
+        while (tc-- > 0) {
+             int n = input.nextInt();
+       int ans[] = new int[n];
+        for (int i = 1; i <=n; i++) {
+            if(ans[i-1]!=0)
+            {
+//                System.out.println(""NO"");
+                continue ;
+            }
+            HashSet<Integer> set = new HashSet<>();
+            ArrayList<Integer> a = new ArrayList<>();
+            while(true)
+            {
+                System.out.println(""? ""+i);
+                int value = input.nextInt();
+                if(set.contains(value))
+                {
+                    break;
+                }
+                a.add(value-1);
+                set.add(value);
+                
+            }
+            for (int j = 0; j <a.size(); j++) {
+                ans[a.get(j)] = a.get((j+1)%a.size())+1;
+            }
+//            System.out.println(a);
+        }
+        System.out.print(""! "");
+        for (int an : ans) {
+            System.out.print(an+"" "");
+        }
+        System.out.println("""");   
+        }
+    }
+
+    static class FastScanner
+    {
+
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st = new StringTokenizer("""");
+
+        String next()
+        {
+            while (!st.hasMoreTokens()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt()
+        {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong()
+        {
+
+            return Long.parseLong(next());
+        }
+
+        double nextDouble()
+        {
+            return Double.parseDouble(next());
+        }
+
+        String nextLine() throws IOException
+        {
+            return br.readLine();
+        }
+    }
+
+}",1
+04df7bb8,ee270b2a,"										import java.math.BigInteger;
+										import java.sql.Array;
+									    import java.util.ArrayList;
+										import java.util.Arrays;
+										import java.util.Collection;
+										import java.util.Collections;
+										import java.util.Comparator;
+										import java.util.Deque;
+										import java.util.HashMap;
+										import java.util.HashSet;
+										import java.util.InputMismatchException;
+										import java.util.LinkedList;
+										import java.util.PriorityQueue;
+										import java.util.Queue;
+										import java.util.Scanner;
+										import java.util.Set;
+										import java.util.Stack;
+										import java.io.BufferedReader;
+										import java.io.IOException;
+										import java.io.InputStream;
+										import java.io.InputStreamReader;
+										import java.util.Scanner;
+										import java.util.StringTokenizer;
+										import java.util.TreeMap;
+										import java.util.TreeSet;
+										
+											
+											
+											
+											
+											
+											public class Main {
+							
+												
+												static HashMap<Integer,Boolean>map;
+												
+											static long dp[][];
+											static 	boolean flag;
+										static	HashSet<Long>hs;
+											static long mod=(long)(1e9+7);
+												public static void main(String[] args) {
+												StringBuilder ans=new StringBuilder();
+												FastReader sc=new FastReader();
+													
+												
+												int t=sc.nextInt();
+												
+												
+												while(t-->0) {
+													
+													int n=sc.nextInt();
+													
+													
+													//int n=sb.length();
+													
+													
+													
+													int k=sc.nextInt();
+													
+													
+													long L[]=new long[n];
+													long R[]=new long[n];
+													int a[]=new int[k];
+													int temp[]=new int[k];
+													
+													for(int i=0;i<k;i++)
+														a[i]=sc.nextInt();
+													
+													for(int i=0;i<k;i++)
+														temp[i]=sc.nextInt();
+													
+													int c[]=new int [n];
+													Arrays.fill(c, Integer.MAX_VALUE);
+													for(int i=0;i<k;i++)
+														c[a[i]-1]=temp[i];
+												
+													long p=Integer.MAX_VALUE;
+													
+													for(int i=0;i<n;i++)
+													{
+														p=Math.min(p+1, c[i]);
+														
+														L[i]=p;
+														
+														
+													}
+													p=Integer.MAX_VALUE;
+													for(int i=n-1;i>=0;i--)
+													{
+														p=Math.min(p+1, c[i]);
+														
+														R[i]=p;
+														
+														
+													}
+													
+													for(int i=0;i<n;i++)
+													{
+														ans.append(Math.min(L[i], R[i])+"" "");
+													}
+											ans.append(""\n"");
+													
+												}
+												System.out.println(ans);
+												
+												}
+													
+											static class Sparse{
+												int log[];
+												long sparse[][];
+												Sparse(int n){
+													
+												log=new int [n+1];
+												
+												
+												for(int i=1;i<n+1;i++)
+													
+												{
+													log[i]=log[i/2]+1;
+												}
+												sparse=new long[n][18];
+												
+												
+												
+												}
+												
+												
+			
+												
+												
+												
+												
+											}
+													
+
+
+												
+												
+							
+												
+												
+												
+												
+												
+												
+												
+												
+											static	long solve(String X,String Y,int n,int m,int M){
+												    
+													if(m==0&&n==0)return 0;
+													
+													//	if(m==1&&X.charAt(n-1)!='u')return Integer.MIN_VALUE;
+													if(n==0||m==0)return Integer.MIN_VALUE;
+											        
+											        if(dp[n][m]!=-1)return dp[n][m]; 
+												    
+												    
+												    
+												    if(Y.charAt(m-1)==X.charAt(n-1))
+												    {
+												 //   else if(n==1)return Integer.MAX_VALUE;
+												    	return dp[n][m]=1+ Math.max(solve (X,Y,n-1,m,M),solve (X,Y,n-1,m-1,M));
+												    }
+												    else{
+												        
+												        return dp[n][m]= solve(X,Y,n-1,m,M);
+												        
+												    }
+												}
+												
+												static long solve(long [][]g,int n,int m,boolean visited [][]) {
+													
+													if(n==0||m==0)return 0;
+													
+													visited[n][m]=true;
+													long ans=g[n-1][m-1]+Math.max(solve(g, n, m-1, visited),solve(g, n-1, m, visited));
+													
+													
+													visited[n][m]=false;
+													
+													return ans;
+													
+													
+													
+												}
+												
+												
+												
+												
+												static boolean isP(long x,long n,long m) {
+													
+													return (x^n)<=m;
+													
+												}
+												
+												
+												
+												
+												
+												static class pair{
+													int n;int i;
+													
+													pair(int n,int i){
+														this.n=n;
+														this.i=i;
+													}
+												}
+													
+													
+												
+												
+												
+												
+												
+												static long	 solve(char g[][],int n,int m) {
+													if(n==0||m==0)return 0;
+													if(n==1&&m==1)return 1;
+													if(g[n-1][m-1]=='#')return 0;
+													
+													if(dp[n][m]!=-1)return dp[n][m];
+													
+													return dp[n][m]= (solve(g, n-1, m)%mod+solve(g, n, m-1)%mod)%mod;
+														
+													
+												}
+												
+												
+												
+												
+												
+												
+												
+												
+												
+									static	int  solve	(int v,ArrayList<ArrayList<Integer>>adj,int d[],boolean visited[]) {
+											
+											
+											visited[v]=true;
+											for(int u:adj.get(v)) {
+												
+												if(!visited[u])
+												{
+												solve(u, adj, d, visited);
+												
+												}
+												d[v]=Math.max(1+d[u], d[v]);
+											}
+											
+											
+											return d[v];
+											
+											
+										}
+												
+												
+											
+												
+										static class colors{
+											
+											int c;int n;
+											public colors(int c,int n) {
+												// TODO Auto-generated constructor stub
+												this.c=c;
+												this.n=n;
+											}
+											
+										}
+												
+												
+												
+												
+												static int CeilIndex(long A[], int l, int r, long key)
+											    {
+											        while (r - l > 1) {
+											            int m = l + (r - l) / 2;
+											            if (A[m] >= key)
+											                r = m;
+											            else
+											                l = m;
+											        }
+											 
+											        return r;
+											    }
+											 
+												static int CeilIndexd(long A[], int l, int r, long key)
+											    {
+											        while (r - l > 1) {
+											            int m = l + (r - l) / 2;
+											            if (-1*A[m] >= key)
+											                r = m;
+											            else
+											                l = m;
+											        }
+											 
+											        return r;
+											    }
+											 
+												
+												
+												
+											
+												
+											static void solve(ArrayList<Long>A,long bd) {
+											
+												if(bd>(long)1e9)return;
+											//	if(hs.contains(bd))return;
+												//A.add(bd);
+												hs.add(bd);
+												A.add(bd*10);
+												A.add(bd*10+1);
+											//	hs.add(bd*10);
+												//hs.add(bd*10+1);
+											
+												solve(A,bd*10);
+												solve(A,bd*10+1);
+												
+												
+											}
+												
+												
+												
+												
+												
+												 static boolean isPrime(int n)
+												    {
+												        // Corner cases
+												        if (n <= 1)
+												            return false;
+												        if (n <= 3)
+												            return true;
+												  
+												        // This is checked so that we can skip
+												        // middle five numbers in below loop
+												        if (n % 2 == 0 || n % 3 == 0)
+												            return false;
+												  
+												        for (int i = 5; i * i <= n; i = i + 6)
+												            if (n % i == 0 || n % (i + 2) == 0)
+												                return false;
+												  
+												        return true;
+												    }
+												  
+												static long lcm(long a, long b)
+											    {
+											        return ((a / gcd(a, b))%mod * b%mod)%mod;
+											    }
+												   static long gcd(long a,long b)
+												    {
+												        if (a == 0)
+												            return b%mod; 
+												        return (gcd(b % a, a))%mod; 
+												    }
+												
+									
+												//System.out.println(count);
+												
+											
+												
+												
+												static void dfs(int v,boolean visited[],ArrayList<ArrayList<Integer>>adj,int div[],int t)
+												{
+													visited[v]=true;
+													
+													div[v]=t+1;
+													for(int u:adj.get(v)) {
+														
+														
+														
+														if(!visited[u]) {
+															dfs(u,visited,adj,div,(t+1)%2);
+														}
+														
+													}
+													
+													
+												}
+												
+												
+												static class Helper{
+													
+													int a;int b;int t;
+													public Helper(int a,int b) {
+														// TODO Auto-generated constructor stub
+														
+														this.a=a;
+														this.b=b;
+											
+														
+													
+													}
+													
+													
+												}
+										
+										
+												
+										
+												
+												
+												
+												
+												//	System.out.println(max);
+										
+												
+											
+												
+											
+									
+				//System.out.println(ans.toString());
+				//main(						
+											
+							
+					
+				static void solvedfs(ArrayList<ArrayList<Integer>>adj,int n,int v,int subt[],int subtAns[],boolean []visited) {
+							
+							
+							int count=1;
+							int ans=0;
+							visited[v]=true;
+							for(int u:adj.get(v)) {
+								
+								
+								if(!visited[u])
+								{
+									//System.out.println(v+"" ""+subt[v]+"" ""+n);
+									subtAns[u]=Math.max(subtAns[u], subt[v]-subtAns[u]);
+									
+								solvedfs(adj, n, u, subt, subtAns, visited);			
+								
+								}
+							}
+							
+						
+							
+							
+							
+							
+							
+						}
+						
+												
+												
+												
+								static int dfs(ArrayList<ArrayList<Integer>>adj,int v,int subt[],int subtAns[],boolean []visited) {
+								
+									
+									int count=0;
+									int ans=0;
+									visited[v]=true;
+									for(int u:adj.get(v)) {
+										
+										
+										if(!visited[u])
+										{
+											count+=ans;
+											ans=Math.max(dfs(adj,u,subt,subtAns,visited),ans);
+										}
+									}
+										subt[v]=count;
+										subtAns[v]=ans;
+										return ans+1;
+										
+									
+									
+									
+									
+									
+								}
+												
+								
+												
+												
+								static	int solve(ArrayList<ArrayList<Integer>>adj,int node,ArrayList<Integer>A)			
+									{
+										if(adj.get(node).size()==0)return 1;
+										
+										int count=0;
+										for(int v:adj.get(node)) {
+											
+											count+=solve(adj,v,A);
+											
+										}
+										
+										A.set(node,count);
+										return count+1;
+										
+										
+										
+									}
+												
+												
+												
+												
+												
+												
+												
+									static void dfs(String[]building,int i,int j,int n,int m, boolean visited[][]) {
+										
+										
+										visited[i][j]=true;
+										
+										if(isValid(building,i+1,j,n,m,visited))
+										{	visited[i+1][j]=true;
+											dfs(building,i+1,j,n,m,visited);
+										
+										}
+											if(isValid(building,i-1,j,n,m,visited))
+										{
+											visited[i-1][j]=true;
+											dfs(building,i-1,j,n,m,visited);
+										}
+										 if(isValid(building,i,j+1,n,m,visited))
+										{visited[i][j+1]=true;
+											dfs(building,i,j+1,n,m,visited);
+										}
+												if(isValid(building,i,j-1,n,m,visited))
+										{visited[i][j-1]=true;
+											dfs(building,i,j-1,n,m,visited);
+										}
+										
+										
+										
+										
+									}
+									static boolean isValid(String[]building,int i,int j,int n,int m, boolean visited[][])		
+									{
+										if(i==-1||j==-1||i==n||j==m||visited[i][j]||building[i].charAt(j)=='#')
+											return false;
+									return true;
+									}
+												
+												
+												
+												
+								static	void compute(boolean sieve[],int n) {
+										
+										for(int i=2;i<=n;i++) {
+											if(sieve[i])continue;
+											
+											for(int j=2*i;j<n;j+=i)
+											{
+												sieve[j]=true;
+											}
+											
+										}
+											
+										
+										
+									}
+								
+								static	void computeHs(boolean sieve[]) {
+									int n=(int)(1e9-1e7+1);
+									for(int i=1;i<n;i++) {
+										if(sieve[i])continue;
+										
+										for(int j=2*i;j<n;j+=i)
+										{
+											sieve[j]=true;
+										}
+										
+									}
+									
+								}
+							
+								
+									
+												
+												
+												static boolean isValid(StringBuilder s,int w) {
+													if(w>s.length())return false;
+													HashSet<Character>hs=new HashSet<Character>();
+													int a[]=new int[3];
+													
+													for(int i=0;i<w;i++) {
+													
+														++a[s.charAt(i)-49];
+														
+													}
+													
+													if(a[0]>0&&a[1]>0&&a[2]>0)return true;
+												
+													int start=0;
+													int end=w;
+													
+													while(end!=s.length()) {
+														--a[s.charAt(start)-49];
+														
+															++a[s.charAt(end)-49];
+														
+																	start++;
+																		end++;
+																		if(a[0]>0&&a[1]>0&&a[2]>0)return true;
+																				
+													}
+													return false;
+													
+													
+													
+												}
+								
+												
+												
+												
+									
+							
+												
+									static int find(int parent[],int i) {
+										
+										if(parent[i]==-1)return i;
+										
+										return parent[i]=find(parent,parent[i]);
+										
+									}
+									static void union(int parent[],int rank[],int s1,int s2) {
+										
+										if(rank[s1]>=rank[s2]) {
+											
+											parent[s2]=s1;
+											rank[s1]+=rank[s2];
+										}
+										
+										else {
+											
+											parent[s1]=s2;
+											rank[s2]+=rank[s1];
+										}
+										
+										
+									}
+												
+												
+												
+												
+												
+												
+												
+												
+												
+												
+												
+									static	int solve(String S,int K) {
+											
+											if(K<=0)return 0;
+											if(S.charAt(K-1)!=S.charAt(K))
+											return 1+solve(S,K-1);
+											else return solve(S,K-1);
+										}
+										
+										
+										
+										
+				
+				
+					
+				static	boolean isValid(int g[][],int r,int c,int n,int m,boolean visited[][],int s) {
+						if(r==-1||r==n||c==-1||c==m||visited[r][c]||g[r][c]!=s)return false;
+						return true;
+					}
+				
+										
+											
+																					
+											
+									    static class FastReader {
+									        BufferedReader br;
+									        StringTokenizer st;
+									 
+									        public FastReader()
+									        {
+									            br = new BufferedReader(
+									                new InputStreamReader(System.in));
+									        }
+									 
+									        String next()
+									        {
+									            while (st == null || !st.hasMoreElements()) {
+									                try {
+									                    st = new StringTokenizer(br.readLine());
+									                }
+									                catch (IOException e) {
+									                    e.printStackTrace();
+									                }
+									            }
+									            return st.nextToken();
+									        }
+									 
+									        int nextInt() { return Integer.parseInt(next()); }
+									 
+									        long nextLong() { return Long.parseLong(next()); }
+									 
+									        double nextDouble()
+									        {
+									            return Double.parseDouble(next());
+									        }
+									 
+									        String nextLine()
+									        {
+									            String str = """";
+									            try {
+									                str = br.readLine();
+									            }
+									            catch (IOException e) {
+									                e.printStackTrace();
+									            }
+									            return str;
+									        }
+									    }
+									 
+										
+											}
+											
+											
+											
+											
+											    ","import java.util.*;
+
+public class D{
+    private static Scanner scanner = new Scanner(System.in);
+    public static void main(String[] args){
+        int q = scanner.nextInt();
+        while(q-- > 0){
+            int n = scanner.nextInt(),
+            k = scanner.nextInt();
+            int[] a = new int[k];
+            for(int i=0;i<k;i++){
+                a[i] = scanner.nextInt();
+            }
+            int[] t = new int[k];
+            for(int j=0;j<k;j++){
+                t[j] = scanner.nextInt();
+            }
+            long[] L = new long[n];
+            long[] R = new long[n];
+            for(int i=0;i<n;i++){
+                L[i] = Integer.MAX_VALUE;
+                R[i] = Integer.MAX_VALUE;
+            }
+            for(int i=0;i<k;i++){
+                L[a[i]-1] = t[i];
+                R[a[i]-1] = t[i];
+            }
+            
+            long min = Integer.MAX_VALUE;
+            for(int i=0;i<n;i++){
+                L[i] = Math.min(min+1,L[i]);
+                min = L[i];
+            }
+            min = Integer.MAX_VALUE;
+            for(int i=n-1;i>=0;i--){
+                R[i] = Math.min(min+1,R[i]);
+                min = R[i];
+            }
+            for(int i=0;i<n;i++){
+                System.out.print(Math.min(L[i],R[i]) + "" "");
+            }
+            System.out.println();
+        }
+    }
+}
+",1
+0c9d4def,ef1d196b,"import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.StringTokenizer;
+
+public class C{
+    private static int maxWords = 0;
+    private static int[][] words;
+    private static int n;
+    private static int[] netwrtchar(int index){
+        ArrayList<Integer> list = new ArrayList<>();
+        for(int i=0; i<n; i++){
+            int sum = 0;
+            for(int j=0; j<words[i].length; j++){
+                if(j==index) continue;
+                sum += words[i][j];
+            }
+            list.add(words[i][index] - sum);
+            // f[i] = words[i][index] - sum;
+        }
+        Collections.sort(list, Collections.reverseOrder());
+        int[] f = new int[list.size()];
+        for(int i=0; i<list.size(); i++){
+            f[i] = list.get(i);
+        }
+        return f;
+    }
+    private static int maxWindow(int[] f){
+        int count = 0, sum = 0;
+        int index = 0;
+        while(index<f.length && sum+f[index]>0){
+            sum += f[index++];
+            count++;
+        }
+        return count;
+    }
+    public static void main(String[] args){
+        FS sc = new FS();
+        PrintWriter pw = new PrintWriter(System.out);
+        int t = sc.nextInt();
+        while(t-->0){
+            n = sc.nextInt();
+            words = new int[n][5];
+            maxWords = 0;
+            for(int i=0; i<n; i++){
+                String s = sc.next();
+                for(int j=0; j<s.length(); j++){
+                    words[i][s.charAt(j)-'a']++;
+                }
+            }
+            int maxWindow = 0;
+            for(int i=0; i<5; i++){
+                int[] f = netwrtchar(i);
+                int current = maxWindow(f);
+                maxWindow = Math.max(maxWindow, current);
+            }
+            System.out.println(maxWindow);
+        }
+        pw.flush();
+        pw.close();
+    }
+
+    static class FS{
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st = new StringTokenizer("""");
+    
+        String next(){
+            while(!st.hasMoreElements()){
+                try{
+                    st = new StringTokenizer(br.readLine());
+                } catch(Exception ignored){
+                }
+            }
+            return st.nextToken();
+        }
+        
+        int[] nextArray(int n){
+            int[] a = new int[n];
+            for(int i = 0; i < n; i++){
+                a[i] = nextInt();
+            }
+            return a;
+        }
+        
+        long[] nextLongArray(int n){
+            long[] a = new long[n];
+            for(int i = 0; i < n; i++){
+                a[i] = nextLong();
+            }
+            return a;
+        }
+        
+        int nextInt(){
+            return Integer.parseInt(next());
+        }
+        
+        long nextLong(){
+            return Long.parseLong(next());
+        }
+        
+        double nextDouble(){
+            return Double.parseDouble(next());
+        }
+    }
+}","import java.util.*;
+
+// import jdk.tools.jlink.internal.SymLinkResourcePoolEntry;
+
+// 
+// import jdk.tools.jlink.internal.SymLinkResourcePoolEntry;
+
+// import org.graalvm.compiler.asm.sparc.SPARCAssembler.Asi;
+
+import java.io.*;
+
+public class Main{
+
+    public static void main(String[] args) {
+        MyScanner sc = new MyScanner();
+        out = new PrintWriter(new BufferedOutputStream(System.out));
+        
+        // Start writing your solution here. -------------------------------------
+        /*
+        int n      = sc.nextInt();        // read input as integer
+        long k     = sc.nextLong();       // read input as long
+        double d   = sc.nextDouble();     // read input as double
+        char c = sc.next().charAt(0);     // read input as char
+        String str = sc.next();           // read input as String
+        String s   = sc.nextLine();       // read whole line as String
+        out.println(result);              // print via PrintWriter
+        */
+        //------------------------------------------------------------------
+
+        int test = sc.nextInt();
+        while(test -- > 0){
+
+            int n = sc.nextInt();
+            List<Integer> a = new ArrayList<>();
+            List<Integer> b = new ArrayList<>();
+            List<Integer> c = new ArrayList<>();
+            List<Integer> d = new ArrayList<>();
+            List<Integer> e = new ArrayList<>();
+
+            while(n-->0){
+                int[] arr = new int[5];
+                // System.out.println(Arrays.toString(arr));
+
+                char[] ch = sc.nextLine().toCharArray();
+                int len = ch.length;
+
+                for(char chhh : ch){
+                    arr[chhh-'a']++;
+                }
+
+                for(int i = 0 ; i < 5 ; i++){
+                    arr[i] = 2*arr[i] - len;
+                }
+
+                // System.out.println(Arrays.toString(arr));
+
+                a.add(arr[0]);
+                b.add(arr[1]);
+                c.add(arr[2]);
+                d.add(arr[3]);
+                e.add(arr[4]);  
+            }
+
+            
+            
+            Collections.sort(a);
+            Collections.sort(b);
+            Collections.sort(c);
+            Collections.sort(d);
+            Collections.sort(e);
+
+            // System.out.println(a);
+            // System.out.println(b);
+            // System.out.println(c);
+            // System.out.println(d);
+            // System.out.println(e);
+
+            int max = 0;
+            int currSum = 0;
+            int words = 0;
+
+            boolean flag = true;
+            for(int i = a.size()-1 ; i >= 0 ; i--){
+                if(currSum + a.get(i) <= 0){
+                    max = Math.max(max , words);
+                    flag = false;
+                    break;
+                }else{
+                    currSum += a.get(i);
+                }
+                words++;
+            }
+
+            if(flag)
+                max = Math.max(a.size(), max);
+
+
+            //end mein check haina???
+
+            // System.out.println(max);
+            
+
+            currSum = 0;
+            words = 0;
+            flag = true;
+            for(int i = b.size()-1 ; i >= 0 ; i--){
+                if(currSum + b.get(i) <= 0){
+                    max = Math.max(max , words);
+                    flag = false;
+                    break;
+                }else{
+                    currSum += b.get(i);
+                }
+                words++;
+            }
+
+            if(flag)
+                max = Math.max(a.size(), max);
+            
+            
+            currSum = 0;
+            words = 0;
+            flag = true;
+            for(int i = c.size()-1 ; i >= 0 ; i--){
+                if(currSum + c.get(i) <= 0){
+                    max = Math.max(max , words);
+                    flag = false;
+                    break;
+                }else{
+                    currSum += c.get(i);
+                }
+                words++;
+            }
+
+    
+            if(flag)
+                max = Math.max(a.size(), max);
+            
+            currSum = 0;
+            words = 0;
+            flag = true;
+            for(int i = d.size()-1 ; i >= 0 ; i--){
+                if(currSum + d.get(i) <= 0){
+                    max = Math.max(max , words);
+                    flag = false;
+                    break;
+                }else{
+                    currSum += d.get(i);
+                }
+                words++;
+            }
+
+            if(flag)
+                max = Math.max(a.size(), max);
+
+            
+            currSum = 0;
+            words = 0;
+            flag = true;
+            for(int i = e.size()-1 ; i >= 0 ; i--){
+                if(currSum + e.get(i) <= 0){
+                    max = Math.max(max , words);
+                    flag = false;
+                    break;
+                }else{
+                    currSum += e.get(i);
+                }
+                words++;
+            }
+            
+            if(flag)
+                max = Math.max(a.size(), max);
+
+            out.println(max);
+
+        }
+
+        //------------------------------------------------------------------
+        
+        // Stop writing your solution here. -------------------------------------
+        out.close();
+    }
+
+    //-------------------------------------------------------------------
+    //-------------------------------------------------------------------
+    //-------------------------------------------------------------------
+    //-------------------------------------------------------------------
+    //-------------------------------------------------------------------
+
+    //for calculating binomialCoeff
+    public static int binomialCoeff(int n, int k)
+    {
+        int C[] = new int[k + 1];
+        // nC0 is 1
+        C[0] = 1;
+        for (int i = 1; i <= n; i++) {
+            // Compute next row of pascal
+            // triangle using the previous row
+            for (int j = Math.min(i, k); j > 0; j--)
+                C[j] = C[j] + C[j - 1];
+        }
+        return C[k];
+    }
+
+    //Pair with int int 
+    public static class Pair{
+
+        public int a;
+        public int b;
+
+        Pair(int a , int b){
+            this.a = a;
+            this.b = b;
+        }
+    }
+
+    //Shortcut function
+    public static long lcm(long a , long b){
+        return a * (b/gcd(a,b));
+    }
+
+    //let's make one for calculating lcm basically
+    public static int lcm(int a , int b){
+        return (a * b)/gcd(a,b);
+    }
+
+    //int version for gcd
+    public static int gcd(int a, int b){
+        if(b == 0)
+            return a;
+            
+        return gcd(b , a%b);
+    }
+
+    //long version for gcd
+    public static long gcd(long a, long b){
+        if(b == 0)
+            return a;
+
+        return gcd(b , a%b);
+    }
+
+    //swapping two elements in an array
+    public static void swap(int[] arr, int left , int right){
+        int temp = arr[left];
+        arr[left] = arr[right];
+        arr[right] = temp;
+    }
+
+    //reversing an array
+    public static void reverse(int[] arr){
+        int left = 0;
+        int right = arr.length-1;
+
+        while(left <= right){
+            swap(arr, left,right);
+            left++;
+            right--;
+        }
+    }
+
+     
+    //-----------PrintWriter for faster output---------------------------------
+    public static PrintWriter out;
+      
+    //-----------MyScanner class for faster input----------
+    public static class MyScanner {
+      BufferedReader br;
+      StringTokenizer st;
+ 
+        public MyScanner() {
+            br = new BufferedReader(new InputStreamReader(System.in));
+        }
+    
+        String next() {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+    
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+    
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+    
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+    
+        String nextLine(){
+            String str = """";
+            try {
+                str = br.readLine();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+        }
+
+    }
+   //--------------------------------------------------------
+}",0
+6d55e68b,d8a171a3,"import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+
+public class _1615C16 {
+
+  public static void main(String[] args) throws IOException {
+    BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
+    int t = Integer.parseInt(in.readLine());
+    int n;
+    int s1, e1;
+    char[] start, end;
+    for (int s = 0; s < t; s++) {
+      n = Integer.parseInt(in.readLine());
+      start = in.readLine().toCharArray();
+      end = in.readLine().toCharArray();
+      s1 = 0;
+      e1 = 0;
+      for (int i = 0; i < n; i++) if (start[i] == '1') s1++;
+      for (int i = 0; i < n; i++) if (end[i] == '1') e1++;
+      if (e1 == n - s1 + 1) {
+        for (int i = 0; i < n; i++) {
+          if (start[i] == '1') start[i] = '0';
+          else start[i] = '1';
+        }
+        int ct = 0;
+        for (int i = 0; i < n; i++) if (start[i] != end[i]) ct++;
+        int ct2 = Integer.MAX_VALUE;
+        if (s1 == e1) {
+          for (int i = 0; i < n; i++) {
+            if (start[i] == '1') start[i] = '0';
+            else start[i] = '1';
+          }
+          ct2 = 0;
+          for (int i = 0; i < n; i++) if (start[i] != end[i]) ct2++;
+        }
+        System.out.println(Math.min(ct, ct2));
+      } else if (s1 == e1) {
+        int ct = 0;
+        for (int i = 0; i < n; i++) if (start[i] != end[i]) ct++;
+        int ct2 = Integer.MAX_VALUE;
+        if (e1 == n - s1 + 1) {
+          ct2 = 0;
+          for (int i = 0; i < n; i++) if (start[i] != end[i]) ct2++;
+        }
+        System.out.println(Math.min(ct, ct2));
+      } else {
+        System.out.println(-1);
+      }
+    }
+  }
+}
+","import java.io.*;
+import java.util.*;
+
+public class B {
+	
+	public static void main(String[] args)throws IOException {
+		
+		FastScanner scan = new FastScanner();
+		PrintWriter output = new PrintWriter(System.out);
+		int t = scan.nextInt();
+		for(int tt = 0;tt<t;tt++) {
+			int n = scan.nextInt();
+			char initial[] = scan.next().toCharArray();
+			char desired[] = scan.next().toCharArray();
+			int lit1 = 0, lit2 = 0;
+			int ans = Integer.MAX_VALUE;
+			for(int i = 0;i<n;i++) {
+				if(initial[i]=='1') lit1++;
+				if(desired[i]=='1') lit2++;
+			}
+			if(lit1==lit2) {
+				int count = 0;
+				for(int i = 0;i<n;i++) if(initial[i]!=desired[i]) count++;
+				ans = Math.min(ans, count);
+			}
+			if(lit2==(n-lit1+1)) {
+				int count = 0;
+				for(int i = 0;i<n;i++) if(initial[i]==desired[i]) count++;
+				ans = Math.min(ans, count);
+			}
+			if(ans == Integer.MAX_VALUE) ans = -1;
+			output.println(ans);	
+		}
+		output.flush();
+	}
+	
+	public static int[] sort(int arr[]) {
+		List<Integer> list = new ArrayList<>();
+		for(int i:arr) list.add(i);
+		Collections.sort(list);
+		for(int i = 0;i<list.size();i++) arr[i] = list.get(i);
+		return arr;
+	}
+	
+	public static int gcd(int a, int b) {
+		if(a == 0) return b;
+		return gcd(b%a, a);
+	}
+	
+	public static void printArray(int arr[]) {
+		for(int i:arr) System.out.print(i+"" "");
+		System.out.println();
+	}
+	
+	static class FastScanner {
+		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st=new StringTokenizer("""");
+		String next() {
+			while (!st.hasMoreTokens())
+				try {
+					st=new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			return st.nextToken();
+		}
+
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+		int[] readArray(int n) {
+			int[] a=new int[n];
+			for (int i=0; i<n; i++) a[i]=nextInt();
+			return a;
+		}
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+		
+		double nextDouble() {
+			return Double.parseDouble(next());
+		}
+	}
+
+}
+",0
+4a570de6,4d279121,"import java.io.*;
+import java.lang.*;
+import java.util.*;
+public class c
+{
+static class FastScanner {
+InputStreamReader is;
+BufferedReader br;
+StringTokenizer st;
+public FastScanner() {
+is = new InputStreamReader(System.in);
+br = new BufferedReader(is);
+}
+String next() throws Exception {
+while (st == null || !st.hasMoreElements())
+st = new StringTokenizer(br.readLine());
+return st.nextToken();
+}
+int ni() throws Exception {
+return Integer.parseInt(next());
+}
+long nextLong() throws Exception {
+return Long.parseLong(next());
+}
+int[] readArray(int num) throws Exception {
+int arr[]=new int[num];
+for(int i=0;i<num;i++)
+arr[i]=ni();
+return arr;
+}
+String nextLine() throws Exception {
+return br.readLine();
+}
+}
+ public static boolean power_of_two(int a)
+{
+  if((a&(a-1))==0)
+{
+ return true;
+}
+return false;
+}
+static boolean PS(double x)
+{
+if (x >= 0) {
+double i= Math.sqrt(x);
+if(i%1!=0)
+{
+return false;
+}
+return ((i * i) == x);
+}
+return false;
+}
+public static int[] ia(int n)
+{
+    int ar[]=new int[n];
+    return ar;
+}
+public static long[] la(int n)
+{
+    long ar[]=new long[n];
+    return ar;
+}
+
+static class pair implements Comparable<pair>{
+    int ht;
+    int id;
+    pair(int ht, int id)
+{
+    this.ht=ht;
+    this.id=id;
+}
+public int compareTo(pair p)
+{
+    return this.ht-p.ht;
+}
+}
+public static void main(String args[]) throws java.lang.Exception
+{
+FastScanner sc=new FastScanner();
+ int t=sc.ni();
+while(t-->0)
+{
+    int n=sc.ni();
+    int m=sc.ni();
+    int x=sc.ni();
+    int ar[]=ia(n);
+for(int i=0;i<n;i++)
+{
+ar[i]=sc.ni();
+}
+System.out.println(""YES"");
+PriorityQueue<pair> pq=new PriorityQueue<>();
+ for(int i=0;i<m;i++)
+ {
+pq.add(new pair(0,i+1));
+ }                     
+ int i=0;
+ while(i<n)
+ {
+     pair pp=pq.remove();
+pp.ht+=ar[i];
+System.out.print(pp.id+"" "");
+pq.add(pp);
+i++;
+ }   
+System.out.println();
+}
+}
+}","import java.util.*;
+import java.io.*;
+        
+@SuppressWarnings(""unchecked"")
+public class Main {
+    public static void main(String args[]) {    
+        FastReader input = new FastReader();
+        PrintWriter out = new PrintWriter(System.out);
+        int t = input.nextInt();
+        while(t-- > 0) {
+        int n = input.nextInt();
+        int m = input.nextInt();
+        int x = input.nextInt();
+        int arr[] = new int[n];
+        for(int i = 0; i < n; i++) arr[i] = input.nextInt(); 
+        PriorityQueue<Pair> queue = new PriorityQueue();
+        out.println(""YES"");
+        int res[] = new int[n];
+        for(int i = 1; i <= m; i++) {
+            queue.add(new Pair(0, i));
+        }
+        for(int i = 0; i < n; i++) {
+            Pair p = queue.remove();
+            out.print(p.second()+"" "");
+            queue.add(new Pair(p.first()+arr[i], p.second()));    
+        }
+        out.println();
+        out.flush();
+        }
+    }   
+}
+ 
+class Pair implements Comparable<Pair> {    
+    public int x;
+    public int y;
+ 
+    public Pair(int x, int y) {
+        this.x = x;
+        this.y = y;
+    }
+ 
+    public int first() {
+        return x;
+    }
+    public int second() {
+        return y;
+    }
+ 
+    public int compareTo(Pair p) {
+        if(this.first() == p.first()) {
+            return 0;
+        }else if(this.first() > p.first()) {
+            return 1;
+        }else {
+            return -1;
+        }
+    } 
+}
+ 
+class FastReader {
+    BufferedReader br;
+    StringTokenizer st;
+    
+    public FastReader() {
+        br = new BufferedReader(new InputStreamReader(System.in));
+    }
+    public String next() {
+        while(st == null || !st.hasMoreElements()) {
+            try {
+                st = new StringTokenizer(br.readLine());
+            }catch(Exception e) {
+                System.out.println(e);
+            }
+        }     
+        return st.nextToken();
+    }
+    public int nextInt() {
+        return Integer.parseInt(next());
+    }
+ 
+    public long nextLong() {
+        return Long.parseLong(next());
+    }
+ 
+    public String getString() {
+        return next();
+    }
+}",0
+31cdf5fe,80cc284c,"import java.util.Scanner;
+
+public class Main {
+
+    public static void main(String[] args)
+    {
+        Scanner scanner = new Scanner(System.in);
+        int t = scanner.nextInt();
+        while(t-- > 0)
+        {
+            int n = scanner.nextInt();
+            int[] time = new int[n];
+            int[] h = new int[n];
+            for(int i  = 0; i < n; i++)
+            {
+                time[i] = scanner.nextInt();
+            }
+            for(int j = 0; j < n; j++)
+            {
+                h[j] = scanner.nextInt();
+            }
+            long prevMTime = time[n-1];
+            long prevMHealth = h[n-1];
+            long manaRequired = 0;
+            long currMTime = time[n-1];
+            long currMHealth = h[n-1];
+            long spellCastingTime = prevMTime - prevMHealth + 1;
+
+            for(int i = n-2; i >= 0; i--)
+            {
+                currMHealth = h[i];
+                currMTime = time[i];
+                //spellCastingTime = prevMTime - prevMHealth + 1;
+                if(spellCastingTime <= currMTime && currMTime - spellCastingTime + 1 < currMHealth)
+                {
+                    spellCastingTime = currMTime - currMHealth + 1;
+                }
+                else if(spellCastingTime > currMTime)
+                {
+                    long hm = (prevMTime - spellCastingTime) + 1;
+                    manaRequired += (hm * (hm+1)) / 2;
+                    prevMTime =currMTime;
+                    prevMHealth = currMHealth;
+                    spellCastingTime = prevMTime - prevMHealth + 1;
+                }
+            }
+            long hm = (prevMTime - spellCastingTime) + 1;
+            manaRequired += (hm * (hm+1)) / 2;
+            System.out.println(manaRequired);
+
+        }
+    }
+
+}
+","import java.util.*;
+public class solution{
+	
+
+	public static void main(String[] args) {
+		Scanner sc = new Scanner(System.in);
+		int t = sc.nextInt();
+		while(t-- > 0){
+			int n = sc.nextInt();
+			long[] k = new long[n];
+			long[] h = new long[n];
+			for(int i = 0;i < n;i++){
+				k[i] = sc.nextLong();
+			}
+			for(int i = 0;i < n;i++){
+				h[i] = sc.nextLong(); 
+			}
+			long length = h[n-1];
+			long curr = 0;
+			long ans = 0;
+			for(int i = n-1;i >= 1;i--){
+				if(k[i] - k[i-1] >= length){
+					curr += length;
+					ans = ans += (curr * (curr + 1))/2;
+					length = h[i-1];
+					curr = 0;
+				}else{
+					length = Math.max(length - (k[i] - k[i-1]), h[i-1]);
+					curr += k[i] - k[i-1];
+				}
+			}
+			curr += length;
+			ans += (curr * (curr + 1))/2;
+			System.out.println(ans);
+		}
+	}
+}",0
+548ffb07,e7dce35b,"import java.io.*;
+import java.util.*;
+
+public class D_Java {
+	public static final int MOD = 998244353;
+	
+	public static int mul(int a, int b) {
+		return (int)((long)a * (long)b % MOD);
+	}
+	
+	int[] f;
+	int[] rf;
+	
+	public int C(int n, int k) {
+		return (k < 0 || k > n) ? 0 : mul(f[n], mul(rf[n-k], rf[k]));
+	}
+	
+	public static int pow(int a, int n) {
+		int res = 1;
+		while (n != 0) {
+			if ((n & 1) == 1) {
+				res = mul(res, a);
+			}
+			a = mul(a, a);
+			n >>= 1;
+		}
+		return res;
+	}
+	
+	static void shuffleArray(int[] a) {
+		Random rnd = new Random();
+		for (int i = a.length-1; i > 0; i--) {
+			int index = rnd.nextInt(i + 1);
+			int tmp = a[index];
+			a[index] = a[i];
+			a[i] = tmp;
+		}
+	}
+	
+	public static int inv(int a) {
+		return pow(a, MOD-2);
+	}
+	
+	public void doIt() throws IOException {
+		BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
+		
+		StringTokenizer tok = new StringTokenizer(in.readLine());
+		int n = Integer.parseInt(tok.nextToken());
+		int k = Integer.parseInt(tok.nextToken());
+		
+		f = new int[n+42];
+		rf = new int[n+42];
+		f[0] = rf[0] = 1;
+		for (int i = 1; i < f.length; ++i) {
+			f[i] = mul(f[i-1], i);
+			rf[i] = mul(rf[i-1], inv(i));
+		}
+		
+		int[] events = new int[2*n];
+		for (int i = 0; i < n; ++i) {
+			tok = new StringTokenizer(in.readLine());
+			int le = Integer.parseInt(tok.nextToken());
+			int ri = Integer.parseInt(tok.nextToken());
+			events[i] = le*2;
+			events[i + n] = ri*2 + 1;
+		}
+		shuffleArray(events);
+		Arrays.sort(events);
+		
+		int ans = 0;
+		int balance = 0;
+		for (int r = 0; r < 2*n;) {
+			int l = r;
+			while (r < 2*n && events[l] == events[r]) {
+				++r;
+			}
+			int added = r - l;
+			if (events[l] % 2 == 0) {
+				// Open event
+				ans += C(balance + added, k);
+				if (ans >= MOD) ans -= MOD;
+				ans += MOD - C(balance, k);
+				if (ans >= MOD) ans -= MOD;
+				balance += added;
+			} else {
+				// Close event
+				balance -= added;
+			}
+		}
+		
+		in.close();
+		System.out.println(ans);
+	}
+	
+	public static void main(String[] args) throws IOException {
+		(new D_Java()).doIt();
+	}
+}
+","import java.io.*;
+import java.util.*;
+
+public class Main {
+    public static void main(String[] args) throws IOException {
+        br = new BufferedReader(new InputStreamReader(System.in));
+        PrintWriter pw = new PrintWriter(System.out);
+        int n = nextInt();
+        int k = nextInt();
+
+        f = new int[n + 42];
+        rf = new int[n + 42];
+        f[0] = 1;
+        rf[0] = 1;
+        for (int i = 1; i < f.length; i++) {
+            f[i] = mul(f[i - 1], i);
+            rf[i] = mul(rf[i - 1], inv(i));
+        }
+
+        int[] a = new int[n * 2];
+        for (int i = 0; i < n; i++) {
+            a[i] = nextInt() * 2;
+            a[i + n] = nextInt() * 2 + 1;
+        }
+        Arrays.sort(a);
+
+        int ans = 0;
+        int curOpen = 0;
+        for (int r = 0; r < 2 * n;) {
+            int l = r;
+            while (r < 2 * n && a[l] == a[r]) r++;
+            int intersections = r - l;
+            if (a[l] % 2 == 0) {
+                ans += C(curOpen + intersections, k);
+                if (ans >= mod) ans -= mod;
+                ans += mod - C(curOpen, k);
+                if (ans >= mod) ans -= mod;
+                curOpen += intersections;
+            } else {
+                curOpen -= intersections;
+            }
+        }
+
+        pw.println(ans);
+        pw.close();
+    }
+
+    static int mod = 998244353;
+
+    static int mul(int a, int b) {
+        return (int) ((long) a * (long) b % mod);
+    }
+
+    static int[] f;
+    static int[] rf;
+
+    static int C(int n, int k) {
+        return (k < 0 || k > n) ? 0 : mul(f[n], mul(rf[n - k], rf[k]));
+    }
+
+    static int pow(int a, int n) {
+        int res = 1;
+        while (n != 0) {
+            if ((n & 1) == 1) {
+                res = mul(res, a);
+            }
+            a = mul(a, a);
+            n >>= 1;
+        }
+        return res;
+    }
+
+    static int inv(int a) {
+        return pow(a, mod - 2);
+    }
+
+    static StringTokenizer st = new StringTokenizer("""");
+    static BufferedReader br;
+
+    static String next() throws IOException {
+        while (st == null || !st.hasMoreTokens()) st = new StringTokenizer(br.readLine());
+        return st.nextToken();
+    }
+
+    static int nextInt() throws IOException {
+        return Integer.parseInt(next());
+    }
+
+    static long nextLong() throws IOException {
+        return Long.parseLong(next());
+    }
+
+    static double nextDouble() throws IOException {
+        return Double.parseDouble(next());
+    }
+}
+
+class Coordinates {
+    int l;
+    int r;
+
+    public Coordinates(int l, int r) {
+        this.l = l;
+        this.r = r;
+    }
+}
+
+class CoordinatesComparator implements Comparator<Coordinates> {
+
+    @Override
+    public int compare(Coordinates o1, Coordinates o2) {
+        if (o1.l == o2.l) return Integer.compare(o1.r, o2.r);
+        return Integer.compare(o1.l, o2.l);
+    }
+}",1
+bdf7bfb2,d92c5342,"import java.util.*;
+import java.io.*;
+ 
+public class Main {
+ 
+    public static void main(String[] args) throws IOException {
+        Scanner sc = new Scanner(System.in);
+        PrintWriter pw = new PrintWriter(System.out);
+        int t = sc.nextInt();
+        while(t-- > 0){
+            int n = sc.nextInt();
+            String[] s = new String[n];
+            for(int i=0; i<n; i++)
+                s[i] = sc.next();
+            int MAX = 0;
+            for(char c = 'a'; c <= 'e'; c++){
+                PriorityQueue<Integer> pq = new PriorityQueue<>(Collections.reverseOrder()); //Big comes in top;
+                for(int i=0; i<n; ++i) {
+                    int curChar = 0;
+                    int otherChar = 0;
+                    for(int j=0; j<s[i].length(); j++) {
+                        if(s[i].charAt(j) == c)
+                            curChar++;
+                        else
+                            otherChar++;
+                    }
+                    int diff = curChar - otherChar;
+                    pq.add(diff);
+                }
+                int cur = 0;
+                int numberOfWords = 0;
+                while(!pq.isEmpty()){
+                    if(cur + pq.peek() > 0){
+                        cur += pq.poll();
+                        numberOfWords++;
+                    }else{
+                        break;
+                    }
+                }
+                MAX = Math.max(MAX, numberOfWords);
+            }
+            pw.println(MAX);
+        }
+        pw.close();
+    }
+ 
+    static class Scanner {
+        BufferedReader br;
+        StringTokenizer st;
+ 
+        public Scanner(InputStream s) {
+            br = new BufferedReader(new InputStreamReader(s));
+        }
+ 
+        public Scanner(FileReader f) {
+            br = new BufferedReader(f);
+        }
+ 
+        public String next() throws IOException {
+            while (st == null || !st.hasMoreTokens())
+                st = new StringTokenizer(br.readLine());
+            return st.nextToken();
+        }
+ 
+        public int nextInt() throws IOException {
+            return Integer.parseInt(next());
+        }
+ 
+        public long nextLong() throws IOException {
+            return Long.parseLong(next());
+        }
+ 
+        public double nextDouble() throws IOException {
+            return Double.parseDouble(next());
+        }
+ 
+        public int[] nextIntArr(int n) throws IOException {
+            int[] arr = new int[n];
+            for (int i = 0; i < n; i++) {
+                arr[i] = Integer.parseInt(next());
+            }
+            return arr;
+        }
+ 
+    }
+}
+ 		 		 							 	  						 		 	
+","import java.io.BufferedReader;
+    import java.io.IOException;
+    import java.io.InputStreamReader;
+    import java.io.PrintWriter;
+import java.lang.reflect.Array;
+import java.util.*;
+public class Main{
+    static class FastScanner {
+            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+            StringTokenizer st = new StringTokenizer("""");
+
+            String next() {
+                while (!st.hasMoreTokens())
+                    try {
+                        st = new StringTokenizer(br.readLine());
+                    } catch (IOException e) {
+                        e.printStackTrace();
+                    }
+                return st.nextToken();
+            }
+
+            int nextInt() {
+                return Integer.parseInt(next());
+            }
+
+            int[] nextArray(int n) {
+                int[] a = new int[n];
+                for (int i = 0; i < n; i++) a[i] = nextInt();
+                return a;
+            }
+            long[] nextArray(long n) {
+                long[] a = new long[(int) n];
+                for (int i = 0; i < n; i++) a[i] = nextLong();
+                return a;
+            }
+
+            long nextLong() {
+                return Long.parseLong(next());
+            }
+        }
+    static class FastWriter extends PrintWriter {
+            FastWriter(){
+                super(System.out);
+            }
+            void println(int[] array) {
+                for(int i=0; i<array.length; i++) {
+                    print(array[i]+"" "");
+                }
+                println();
+            }
+            void println(long [] array) {
+                for(int i=0; i<array.length; i++) {
+                    print(array[i]+"" "");
+                }
+                println();
+            }
+        }
+    static int MOD=1000003;
+    public static void main(String[] args) throws IOException {
+        FastScanner in = new FastScanner();
+        FastWriter out = new FastWriter();
+        int t=in.nextInt();
+        //int t=1;
+        while (t-->0){
+            int n=in.nextInt();
+            String[] ar=new String[n];
+            for (int i = 0; i < n; i++) {
+                ar[i]=in.next();
+            }
+            int ans=0;
+            for(char ch='a';ch<='e';ch++){
+                int[] res=new int[n];
+                for (int i = 0; i < n; i++) {
+                    String ss=ar[i];
+                    for (int j = 0; j < ss.length(); j++) {
+                        if(ss.charAt(j)==ch){
+                            res[i]++;
+                        }else {
+                            res[i]--;
+                        }
+                    }
+                }
+                Arrays.sort(res);int max=0,nn=0;
+                for (int i = n-1; i>=0; i--) {
+                    max+=res[i];
+                    if(max>0){
+                        nn++;
+                    }else {
+                        break;
+                    }
+                }
+                ans=Math.max(ans,nn);
+            }
+            out.println(ans);
+        }
+        out.close();
+    }
+    //Arrays.sort(a, (o1, o2) -> (o1[0] - o2[0]));
+    static int totalPrimeFactors(int n) {
+        int cnt=0;
+        while (n%2==0) {
+            cnt++;
+            n /= 2;
+        }
+        int num= (int) Math.sqrt(n);
+        for (int i = 3; i <= num; i+= 2) {
+            while (n%i == 0) {
+                cnt++;
+                n /= i;
+                num=(int)Math.sqrt(n);
+            }
+        }
+        if (n > 2){
+            cnt++;
+        }
+        return cnt;
+    }
+    static char get(int i){
+        return (char)(i+'a');
+    }
+    static boolean distinct(int num){
+        HashSet<Integer> set=new HashSet<>();
+        int len=String.valueOf(num).length();
+        while (num!=0){
+            set.add(num%10);
+            num/=10;
+        }
+        return set.size()==len;
+    }
+    static int maxSubArraySum(int a[],int st,int en) {
+        int max_s = Integer.MIN_VALUE, max_e = 0,ind=0,ind1=1;
+        for (int i = st; i <= en; i++) {
+            max_e+= a[i];
+            if (max_s < max_e){
+                max_s = max_e;
+                ind=ind1;
+            }
+            if (max_e < 0){
+                max_e = 0;
+                ind1=i+1;
+            }
+        }
+        if(st==0){
+            return max_s;
+        }
+        if(ind==1){
+            return a[0]+2*max_s;
+        }else {
+            return 2*max_s+maxSubArraySum(a,0,ind-1);
+        }
+        //return max_s;
+    }
+    static void segmentedSieve(ArrayList<Integer> res,int low, int high) {
+        if(low < 2){
+            low = 2;
+        }
+        ArrayList<Integer> prime = new ArrayList<>();
+        sS2(high, prime);
+        boolean[] mark = new boolean[high - low + 1];
+        Arrays.fill(mark, true);
+        for (int i = 0; i < prime.size(); i++) {
+            int loLim = (low / prime.get(i)) * prime.get(i);
+            if (loLim < low){
+                loLim += prime.get(i);
+            }
+            if (loLim == prime.get(i)){
+                loLim += prime.get(i);
+            }
+            for (int j = loLim; j <= high; j += prime.get(i)) {
+                mark[j - low] = false;
+            }
+        }
+        for (int i = low; i <= high; i++) {
+            if (mark[i - low]){
+                System.out.println(i);
+                res.add(i);
+            }
+        }
+    }
+    static void sS2(int limit, ArrayList<Integer> prime) {
+        int bound = (int)Math.sqrt(limit);
+        boolean[] mark = new boolean[bound + 1];
+        for (int i = 0; i <= bound; i++){
+            mark[i] = true;
+        }
+        for (int i = 2; i * i <= bound; i++) {
+            if (mark[i]) {
+                for (int j = i * i; j <= bound; j += i){
+                    mark[j] = false;
+                }
+            }
+        }
+        for (int i = 2; i <= bound; i++) {
+            if (mark[i]){
+                prime.add(i);
+            }
+        }
+    }
+    static boolean[] sieveOfEratosthenes(int n){
+        boolean[] prime = new boolean[n + 1];
+        Arrays.fill(prime,true);
+        prime[0]=false;prime[1]=false;
+        for (int p = 2; p * p <= n; p++) {
+            if(prime[p]){
+                for (int i = p * p; i <= n; i += p){
+                    prime[i] = false;
+                }
+            }
+        }
+        return prime;
+    }
+    static int highestPowerOf2(int n) {
+        if (n < 1){ return 0; }
+        int res = 1;
+        for (int i = 0; i < 8 * Integer.BYTES; i++) {
+            int curr = 1 << i;
+            if (curr > n){ break; }
+            res = curr;
+        }
+        return res;
+    }
+    static int reduceFraction(int x, int y) {
+        int d= gcd(x, y);
+        return x/d+y/d;
+    }
+    static boolean subset(int[] ar,int n,int sum){
+        if(sum==0){
+            return true;
+        }
+        if(n<0||sum<0){
+            return false;
+        }
+        return subset(ar,n-1,sum)||subset(ar,n-1,sum-ar[n]);
+    }
+    static boolean isPrime(int n){
+        if(n<=1) return false;
+        for(int i = 2;i<=Math.sqrt(n);i++){
+            if (n % i == 0) return false;
+        }
+        return true;
+    }
+    static int gcd(int a, int b) {
+        if (b == 0) return a;
+        return gcd(b, a % b);
+    }
+    static long gcd(long a, long b) {
+        if (b == 0) return a;
+        return gcd(b, a % b);
+    }
+    static long lcm(long a, long b) {
+        return (a * b) / gcd(a, b);
+    }
+    static int lcm(int a, int b) {
+        return (a * b) / gcd(a, b);
+    }
+    static boolean isPowerOfTwo(long n) {
+        if(n==0){
+            return false;
+        }
+        while (n%2==0){
+            n/=2;
+        }
+        return n==1;
+    }
+    static boolean isPerfectSquare(int x){
+        if (x >= 0) {
+            int sr = (int)Math.sqrt(x);
+            return ((sr * sr) == x);
+        }
+        return false;
+    }
+    static int lower_bound(int[] arr, int x) {
+        int low_limit = 0, high_limit = arr.length, mid;
+        while (low_limit < high_limit) {
+            mid = (low_limit + high_limit) / 2;
+            if (arr[mid] >= x){
+                high_limit = mid;
+            }else{
+                low_limit = mid + 1;
+            }
+        }
+        return low_limit;
+    }
+    static int upper_bound(int[] arr, int x) {
+        int low_limit = 0, high_limit = arr.length, mid;
+        while (low_limit < high_limit) {
+            mid = (low_limit + high_limit) / 2;
+            if (arr[mid] > x){
+                high_limit = mid;
+            }else{
+                low_limit = mid + 1;
+            }
+        }
+        return low_limit;
+    }
+    static int binarySearch(int[] ar,int n,int num){
+        int low=0,high=n-1;
+        while (low<=high){
+            int mid=(low+high)/2;
+            if(ar[mid]==num){
+                return mid;
+            }else if(ar[mid]>num){
+                high=mid-1;
+            }else {
+                low=mid+1;
+            }
+        }
+        return -1;
+    }
+    static int fib(int n) {
+        long[][] F = new long[][]{{1,1},{1,0}};
+        if (n == 0){
+            return 0;
+        }
+        power(F, n-1);
+        return (int)F[0][0];
+    }
+    static void multiply(long F[][], long M[][]) {
+        long x =  (F[0][0]*M[0][0])%1000000007 + (F[0][1]*M[1][0])%1000000007;
+        long y =  (F[0][0]*M[0][1])%1000000007 + (F[0][1]*M[1][1])%1000000007;
+        long z =  (F[1][0]*M[0][0])%1000000007 + (F[1][1]*M[1][0])%1000000007;
+        long w =  (F[1][0]*M[0][1])%1000000007 + (F[1][1]*M[1][1])%1000000007;
+        F[0][0] = x%1000000007;
+        F[0][1] = y%1000000007;
+        F[1][0] = z%1000000007;
+        F[1][1] = w%1000000007;
+    }
+    static void power(long F[][], int n) {
+        if( n == 0 || n == 1){
+            return;
+        }
+        long M[][] = new long[][]{{1,1},{1,0}};
+        power(F, n/2);
+        multiply(F, F);
+        if (n%2 != 0){
+            multiply(F, M);
+        }
+    }
+    static int binaryExponentiation(int x,int n){
+        int ans=1;
+        while (n>0){
+            if(n%2!=0){
+                ans=(ans*x)%MOD;
+            }
+            x=(x*x)%MOD;
+            n/=2;
+        }
+        return ans;
+    }
+    static void bfs(ArrayList<Integer>[] ar,int node){
+        boolean[] visited=new boolean[ar.length];
+        Queue<Integer> queue=new LinkedList<>();
+        visited[node]=true;
+        queue.add(node);
+        while(!queue.isEmpty()){
+            int nn=queue.poll();
+            System.out.print(nn+"" "");
+            for(int n : ar[nn]) {
+                if (!visited[n]) {
+                    visited[n] = true;
+                    queue.add(n);
+                }
+            }
+        }
+        System.out.println();
+    }
+    static void dfs(ArrayList<Integer>[] ar,int node){
+        boolean[] visited=new boolean[ar.length];
+        dfsUtil(ar,node,visited);
+        System.out.println();
+    }
+    static void dfsUtil(ArrayList<Integer>[] ar,int node,boolean[] visited){
+        visited[node]=true;
+        //System.out.print(node+"" "");
+        for(Integer n:ar[node]){
+            if(!visited[n]){
+                dfsUtil(ar,n,visited);
+            }
+        }
+    }
+}",0
+3a12e509,fae0662f,"import java.io.*;
+import java.util.*;
+
+
+public class Practice
+{
+//	static final long mod=7420738134811L;
+	static int mod=1000000007;
+	static final int size=501;
+	static FastReader sc=new FastReader(System.in);
+//	static Reader sc=new Reader();
+	static  PrintWriter out=new PrintWriter(System.out);
+	static long[] factorialNumInverse;
+	static long[] naturalNumInverse;	
+	static int[] sp;
+	static long[] fact;
+	static ArrayList<Integer> pr;
+	public static void main(String[] args) throws IOException
+	{
+//		System.setIn(new FileInputStream(""input.txt""));
+//		System.setOut(new PrintStream(""output.txt""));
+//		factorial(mod);
+//		InverseofNumber(mod);
+//		InverseofFactorial(mod);
+//		make_seive();
+		int t=1;
+		t=sc.nextInt();
+		while(t-->0)
+			solve();
+		out.close();
+		out.flush();
+	}
+	static void solve() throws IOException
+	{
+		int n=sc.nextInt();
+		int arr[]=new int[n];
+		for(int i=0;i<n;i++)
+			arr[i]=sc.nextInt();
+		String s=sc.next();
+		ArrayList<Integer> blue=new ArrayList<Integer>();
+		ArrayList<Integer> red=new ArrayList<Integer>();
+		for(int i=0;i<n;i++)
+		{
+			if(s.charAt(i)=='B')
+				blue.add(arr[i]);
+			else
+				red.add(arr[i]);
+		}
+		Collections.sort(blue);
+		Collections.sort(red);
+		for(int i=0;i<blue.size();i++)
+		{
+			if(blue.get(i)<i+1)
+			{
+				out.println(""NO"");
+				return;
+			}
+		}
+		for(int i=0;i<red.size();i++)
+		{
+			if(red.get(i)>i+1+blue.size())
+			{
+				out.println(""NO"");
+				return;
+			}
+		}
+		out.println(""YES"");
+	}
+	static class Pair implements Cloneable, Comparable<Pair>
+	{
+		int x,y;
+		Pair(int a,int b)
+		{
+			this.x=a;
+			this.y=b;
+		}
+		@Override
+		public boolean equals(Object obj) 
+		{
+			if(obj instanceof  Pair)
+			{
+				Pair p=(Pair)obj;
+				return p.x==this.x && p.y==this.y;
+			}
+			return false;
+		}
+		@Override
+		public int hashCode() 
+		{
+			return Math.abs(x)+500*Math.abs(y);
+		}
+		@Override
+		public String toString() 
+		{
+			return ""(""+x+"" ""+y+"")"";
+		}
+		@Override
+		protected Pair clone() throws CloneNotSupportedException {
+			return new Pair(this.x,this.y);
+		}
+		@Override
+		public int compareTo(Pair a) 
+		{
+			int t= this.x-a.x;
+			if(t!=0)
+				return t;
+			else
+				return this.y-a.y;
+		}
+		public void swap()
+		{
+			this.y=this.y+this.x;
+			this.x=this.y-this.x;
+			this.y=this.y-this.x;			
+		}
+	}
+	static class Tuple implements Cloneable, Comparable<Tuple>
+	{
+		int x,y,z;
+		Tuple(int a,int b,int c)
+		{
+			this.x=a;
+			this.y=b;
+			this.z=c;
+		}
+		public boolean equals(Object obj) 
+		{
+			if(obj instanceof  Tuple)
+			{
+				Tuple p=(Tuple)obj;
+				return p.x==this.x && p.y==this.y && p.z==this.z;
+			}
+			return false;
+		}
+		@Override
+		public int hashCode() 
+		{
+			return (this.x+501*this.y);
+		}
+		@Override
+		public String toString() 
+		{
+			return ""(""+x+"",""+y+"",""+z+"")"";
+		}
+		@Override
+		protected Tuple clone() throws CloneNotSupportedException {
+			return new Tuple(this.x,this.y,this.z);
+		}
+		@Override
+		public int compareTo(Tuple a) 
+		{
+			int x=this.z-a.z;
+			if(x!=0)
+				return x;
+			int X= this.x-a.x;
+			if(X!=0)
+				return X;
+			return a.y-this.y;
+		}
+	}
+	static void arraySort(int arr[])
+	{
+		ArrayList<Integer> a=new ArrayList<Integer>();
+		for (int i = 0; i < arr.length; i++) {
+			a.add(arr[i]);
+		}
+		Collections.sort(a);
+		for (int i = 0; i < arr.length; i++) {
+			arr[i]=a.get(i);
+		}
+	}
+	static void arraySort(long arr[])
+	{
+		ArrayList<Long> a=new ArrayList<Long>();
+		for (int i = 0; i < arr.length; i++) {
+			a.add(arr[i]);
+		}
+		Collections.sort(a);
+		for (int i = 0; i < arr.length; i++) {
+			arr[i]=a.get(i);
+		}
+	}
+	static HashSet<Integer> primeFactors(int n)
+	{
+		HashSet<Integer> ans=new HashSet<Integer>();
+		if(n%2==0)
+		{
+			ans.add(2);
+			while((n&1)==0)
+				n=n>>1;
+		}
+		for(int i=3;i*i<=n;i+=2)
+		{
+			if(n%i==0)
+			{
+				ans.add(i);
+				while(n%i==0)
+					n=n/i;
+			}
+		}
+		if(n!=1)
+			ans.add(n);
+		return ans;
+	}
+	static void make_seive()
+	{
+		sp=new int[size];
+		pr=new ArrayList<Integer>();
+		for (int i=2; i<size; ++i) {
+		    if (sp[i] == 0) {
+		        sp[i] = i;
+		        pr.add(i);
+		    }
+		    for (int j=0; j<(int)pr.size() && pr.get(j)<=sp[i] && i*pr.get(j)<size; ++j)
+		        sp[i * pr.get(j)] = pr.get(j);
+		}
+	}
+	public static void InverseofNumber(int p)
+	{
+		naturalNumInverse=new long[size];
+	    naturalNumInverse[0] = naturalNumInverse[1] = 1;
+	    for(int i = 2; i < size; i++)
+	        naturalNumInverse[i] = naturalNumInverse[p % i] * (long)(p - p / i) % p;
+	}
+	// Function to precompute inverse of factorials
+	public static void InverseofFactorial(int p)
+	{
+		factorialNumInverse=new long[size];
+	    factorialNumInverse[0] = factorialNumInverse[1] = 1;
+	    // pre-compute inverse of natural numbers
+	    for(int i = 2; i < size; i++)
+	        factorialNumInverse[i] = (naturalNumInverse[i] * factorialNumInverse[i - 1]) % p;
+	}
+	// Function to calculate factorial of 1 to 200001
+	public static void factorial(int p)
+	{
+		fact=new long[size];
+	    fact[0] = 1;
+	    for(int i = 1; i < size; i++)
+	        fact[i] = (fact[i - 1] * (long)i) % p;
+	}
+	 
+	// Function to return nCr % p in O(1) time
+	public static long Binomial(int N, int R)
+	{
+		if(R<0)
+			return 1;
+	    // n C r = n!*inverse(r!)*inverse((n-r)!)
+	    long ans = ((fact[N] * factorialNumInverse[R]) % mod * factorialNumInverse[N - R]) % mod;
+	    return ans;
+	}
+	static int findXOR(int x)	//from 0 to x
+	{
+		if(x<0)
+			return 0;
+		if(x%4==0)
+			return x;
+		if(x%4==1)
+			return 1;
+		if(x%4==2)
+			return x+1;
+		return 0;
+	}
+	static boolean isPrime(long x)
+	{
+		if(x==1)
+			return false;
+		if(x<=3)
+			return true;
+		if(x%2==0 || x%3==0)
+			return false;
+		for(int i=5;i<=Math.sqrt(x);i+=2)
+			if(x%i==0)
+				return false;
+		return true;
+	}
+	static long gcd(long a,long b)
+	{
+		return (b==0)?a:gcd(b,a%b);
+	}
+	static int gcd(int a,int b)
+	{
+		return (b==0)?a:gcd(b,a%b);
+	}
+	static class Node
+	{
+		int vertex;
+		HashSet<Edge> adj;
+		int taxC,taxD;
+		Node(int ver)
+		{
+			vertex=ver;
+			taxD=0;
+			taxC=0;
+			adj=new HashSet<Edge>();
+		}
+		@Override
+		public String toString() 
+		{
+			return vertex+"" "";
+		}
+	}
+	static class Edge
+	{
+		Node to;
+		int cost;
+		Edge(Node t,int c)
+		{
+			this.to=t;
+			this.cost=c;
+		}
+		@Override
+		public String toString() {
+			return ""(""+to.vertex+"",""+cost+"") "";
+		}
+	}
+	static long power(long x, long y)
+	  {
+		if(x<=0)
+			return 1;
+	    long res = 1; 
+	    x = x % mod; 
+	    if (x == 0)
+	      return 0; 
+	    while (y > 0)
+	    {
+	    	if ((y & 1) != 0)
+	    		res = (res * x) % mod;
+	    	
+	    	y = y >> 1; // y = y/2
+	    	x = (x * x) % mod;
+	    }
+	    return res;
+	  }
+	static long binomialCoeff(long n, long k)
+    {
+		if(n<k)
+			return 0;
+        long res = 1;
+//        if(k>n)
+//        	return 0;
+        // Since C(n, k) = C(n, n-k)
+        if (k > n - k)
+            k = n - k;
+ 
+        // Calculate value of
+        // [n * (n-1) *---* (n-k+1)] / [k * (k-1) *----* 1]
+        for (long i = 0; i < k; ++i) {
+            res *= (n - i);
+            res /= (i + 1);
+        }
+ 
+        return res;
+    }
+	static class FastReader
+	{
+        byte[] buf = new byte[2048];
+        int index, total;
+        InputStream in;
+ 
+        FastReader(InputStream is) 
+        {
+            in = is;
+        }
+ 
+        int scan() throws IOException 
+        {
+            if (index >= total) {
+                index = 0;
+                total = in.read(buf);
+                if (total <= 0) {
+                    return -1;
+                }
+            }
+            return buf[index++];
+        }
+ 
+        String next() throws IOException 
+        {
+            int c;
+            for (c = scan(); c <= 32; c = scan());
+            StringBuilder sb = new StringBuilder();
+            for (; c > 32; c = scan()) {
+                sb.append((char) c);
+            }
+            return sb.toString();
+        }
+ 
+        int nextInt() throws IOException 
+        {
+            int c, val = 0;
+            for (c = scan(); c <= 32; c = scan());
+            boolean neg = c == '-';
+            if (c == '-' || c == '+') {
+                c = scan();
+            }
+            for (; c >= '0' && c <= '9'; c = scan()) {
+                val = (val << 3) + (val << 1) + (c & 15);
+            }
+            return neg ? -val : val;
+        }
+ 
+        long nextLong() throws IOException 
+        {
+            int c;
+            long val = 0;
+            for (c = scan(); c <= 32; c = scan());
+            boolean neg = c == '-';
+            if (c == '-' || c == '+') {
+                c = scan();
+            }
+            for (; c >= '0' && c <= '9'; c = scan()) {
+                val = (val << 3) + (val << 1) + (c & 15);
+            }
+            return neg ? -val : val;
+        }
+    }
+	static class Reader 
+	{
+        final private int BUFFER_SIZE = 1 << 16;
+        private DataInputStream din;
+        private byte[] buffer;
+        private int bufferPointer, bytesRead;
+ 
+        public Reader()
+        {
+            din = new DataInputStream(System.in);
+            buffer = new byte[BUFFER_SIZE];
+            bufferPointer = bytesRead = 0;
+        }
+ 
+        public Reader(String file_name) throws IOException
+        {
+            din = new DataInputStream(
+                new FileInputStream(file_name));
+            buffer = new byte[BUFFER_SIZE];
+            bufferPointer = bytesRead = 0;
+        }
+ 
+        public String readLine() throws IOException
+        {
+            byte[] buf = new byte[64]; // line length
+            int cnt = 0, c;
+            while ((c = read()) != -1) {
+                if (c == '\n') {
+                    if (cnt != 0) {
+                        break;
+                    }
+                    else {
+                        continue;
+                    }
+                }
+                buf[cnt++] = (byte)c;
+            }
+            return new String(buf, 0, cnt);
+        }
+ 
+        public int nextInt() throws IOException
+        {
+            int ret = 0;
+            byte c = read();
+            while (c <= ' ') {
+                c = read();
+            }
+            boolean neg = (c == '-');
+            if (neg)
+                c = read();
+            do {
+                ret = ret * 10 + c - '0';
+            } while ((c = read()) >= '0' && c <= '9');
+ 
+            if (neg)
+                return -ret;
+            return ret;
+        }
+ 
+        public long nextLong() throws IOException
+        {
+            long ret = 0;
+            byte c = read();
+            while (c <= ' ')
+                c = read();
+            boolean neg = (c == '-');
+            if (neg)
+                c = read();
+            do {
+                ret = ret * 10 + c - '0';
+            } while ((c = read()) >= '0' && c <= '9');
+            if (neg)
+                return -ret;
+            return ret;
+        }
+ 
+        public double nextDouble() throws IOException
+        {
+            double ret = 0, div = 1;
+            byte c = read();
+            while (c <= ' ')
+                c = read();
+            boolean neg = (c == '-');
+            if (neg)
+                c = read();
+ 
+            do {
+                ret = ret * 10 + c - '0';
+            } while ((c = read()) >= '0' && c <= '9');
+ 
+            if (c == '.') {
+                while ((c = read()) >= '0' && c <= '9') {
+                    ret += (c - '0') / (div *= 10);
+                }
+            }
+ 
+            if (neg)
+                return -ret;
+            return ret;
+        }
+ 
+        private void fillBuffer() throws IOException
+        {
+            bytesRead = din.read(buffer, bufferPointer = 0,
+                                 BUFFER_SIZE);
+            if (bytesRead == -1)
+                buffer[0] = -1;
+        }
+ 
+        private byte read() throws IOException
+        {
+            if (bufferPointer == bytesRead)
+                fillBuffer();
+            return buffer[bufferPointer++];
+        }
+ 
+        public void close() throws IOException
+        {
+            if (din == null)
+                return;
+            din.close();
+        }
+        public void printarray(int arr[])
+        {
+        	for (int i = 0; i < arr.length; i++)
+				System.out.print(arr[i]+"" "");
+        	System.out.println();
+        }
+    }
+}
+
+
+
+
+
+
+
+","import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.StringTokenizer;
+
+public class D {
+	
+	public static void main(String[] args) throws IOException {
+		FastScanner fs = new FastScanner();
+		PrintWriter out = new PrintWriter(System.out);
+		
+		int t = fs.nextInt();
+		for (int tc = 0; tc < t; tc++) {
+			int n = fs.nextInt();
+			int[] a = fs.readArray(n);
+			String s = fs.nextLine();
+			
+			// let all blue to be 1 -> blueCount
+			ArrayList<Integer> blues = new ArrayList<Integer>();
+			ArrayList<Integer> reds = new ArrayList<Integer>();
+			
+			for (int i = 0; i < s.length(); i++) {
+				if (s.charAt(i) == 'B') {
+					blues.add(a[i]);
+				} else {
+					reds.add(a[i]);
+				}
+			}
+			
+			Collections.sort(blues);
+			Collections.sort(reds);
+			
+			boolean ok = true;
+			
+			for (int i = 1; i <= blues.size(); i++) {
+				if (blues.get(i - 1) < i) {
+					ok = false;
+					break;
+				}
+			}
+			
+			for (int i = blues.size() + 1; i <= n; i++) {
+				if (reds.get(i - blues.size() - 1) > i) {
+					ok = false;
+					break;
+				}
+			}
+			
+			if (ok) {
+				out.println(""YES"");
+			} else {
+				out.println(""NO"");
+			}
+		}
+		
+		out.close();
+	}
+	
+	static class FastScanner {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st = new StringTokenizer("""");
+        
+        String next() {
+            while (!st.hasMoreTokens())
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            return st.nextToken();
+        }
+        
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        int[] readArray(int n) {
+            int[] a = new int[n];
+            for (int i = 0; i < n; i++) a[i] = nextInt();
+            return a;
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+        
+        String nextLine() throws IOException {
+        	return br.readLine();
+        }
+    }
+}
+
+",0
+4499e3b9,cbbbed5f,"import java.io.*;
+import java.util.*;
+
+public class Main {
+
+    static public void dfs(ArrayList<ArrayList<Integer>> g, int u, long[][] dp, long[] l, long[] r, int p) {
+        dp[u][0] = 1;
+        for (int i = 0; i < g.get(u).size(); i++) {
+            int v = g.get(u).get(i);
+            if (v == p) continue;
+            if (dp[v][0] == 0) {
+                dfs(g, v, dp, l, r, u);
+            }
+            dp[u][1] += Math.max(Math.abs(l[u] - l[v]) + dp[v][1], Math.abs(l[u] - r[v]) + dp[v][2]);
+            dp[u][2] += Math.max(Math.abs(r[u] - l[v]) + dp[v][1], Math.abs(r[u] - r[v]) + dp[v][2]);
+        }
+    }
+
+    static public void main(String args[]) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
+        StringTokenizer st = new StringTokenizer(br.readLine());
+        int T = Integer.parseInt(st.nextToken());
+        for (int t = 1; t <= T; t++) {
+            st = new StringTokenizer(br.readLine());
+            int n = Integer.parseInt(st.nextToken());
+            long[] l = new long[n + 1], r = new long[n + 1];
+            ArrayList<ArrayList<Integer>> g = new ArrayList<>();
+            for (int i = 0; i < n; i++) {
+                st = new StringTokenizer(br.readLine());
+                l[i + 1] = Integer.parseInt(st.nextToken());
+                r[i + 1] = Integer.parseInt(st.nextToken());
+                g.add(new ArrayList<>());
+            }
+            g.add(new ArrayList<>());
+
+            for (int i = 0; i < n - 1; i++) {
+                st = new StringTokenizer(br.readLine());
+                int u = Integer.parseInt(st.nextToken()), v = Integer.parseInt(st.nextToken());
+                g.get(v).add(u);
+                g.get(u).add(v);
+            }
+            long[][] dp = new long[n + 1][3];
+            dfs(g, 1 , dp, l, r, -1);
+            bw.write(Math.max(dp[1][1], dp[1][2]) + ""\n"");
+        }
+        bw.flush();
+    }
+}
+","import java.util.*;
+import java.io.*;
+
+public class C{
+
+	private static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+    private static BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
+    private static int vertices;
+    private static LinkedList<Integer> adj[];
+    private static long dp[][];
+    private static int l[];
+    private static int r[];
+    private static boolean vis[];
+
+    public static void dfs(int v) {
+        if(vis[v])
+            return;
+        vis[v] = true;
+        Iterator<Integer> iterator = adj[v].listIterator();
+        while(iterator.hasNext()) {
+            int child = iterator.next();
+            if(!vis[child]) {
+                dfs(child);
+                long left = dp[child][0] + Math.abs(l[v] - l[child]);
+                dp[v][0] += Math.max(left, dp[child][1] + Math.abs(l[v] - r[child]));
+                long right = dp[child][0] + Math.abs(r[v] - l[child]);
+                dp[v][1] += Math.max(right, dp[child][1] + Math.abs(r[v] - r[child]));
+            }
+        }
+    }
+
+	public static void main (String[] args) throws IOException {
+        int t = Integer.parseInt(br.readLine());
+        while(t-- > 0) {
+            int n = Integer.parseInt(br.readLine());
+            vertices = n;
+            dp = new long[n+1][2];
+            adj = new LinkedList[n+1];
+            vis = new boolean[n+1];
+            l = new int[n+1];
+            r = new int[n+1];
+            for(int i=1;i<=n;i++) {
+                adj[i] = new LinkedList<>();
+            }
+            for(int i=1;i<=n;i++) {
+                String lr[] = br.readLine().split("" "");
+                l[i] = Integer.parseInt(lr[0]);
+                r[i] = Integer.parseInt(lr[1]);
+            }
+            for(int i=0;i<n-1;i++) {
+                String uv[] = br.readLine().split("" "");
+                int u = Integer.parseInt(uv[0]);
+                int v = Integer.parseInt(uv[1]);
+                adj[u].add(v);
+                adj[v].add(u);
+            }
+            dfs(1);
+            long ans = Math.max(dp[1][0], dp[1][1]);
+            bw.write(ans + ""\n"");
+        }
+        bw.flush();
+    }
+}",0
+2560850b,76791c9f,"//package notassigning;
+
+import java.util.*;
+import java.io.*;
+
+public class notassigning {
+	public static void main(String[] args) throws IOException {
+		BufferedReader fin = new BufferedReader(new InputStreamReader(System.in));
+		int t = Integer.parseInt(fin.readLine());
+		StringBuilder fout = new StringBuilder();
+		while(t-- > 0) {
+			int n = Integer.parseInt(fin.readLine());
+			boolean isValid = true;
+			int start = -1;
+			ArrayList<ArrayList<Integer>> c = new ArrayList<ArrayList<Integer>>();
+			for(int i = 0; i < n; i++) {
+				c.add(new ArrayList<Integer>());
+			}
+			HashMap<ArrayList<Integer>, Integer> order = new HashMap<ArrayList<Integer>, Integer>();
+			for(int i = 0; i < n - 1; i++) {
+				StringTokenizer st = new StringTokenizer(fin.readLine());
+				int a = Integer.parseInt(st.nextToken()) - 1;
+				int b = Integer.parseInt(st.nextToken()) - 1;
+				order.put(new ArrayList<Integer>(Arrays.asList(a, b)), i);
+				c.get(a).add(b);
+				c.get(b).add(a);
+				if((c.get(a).size() == 3 || c.get(b).size() == 3) && isValid) {
+					isValid = false;
+				}
+			}
+			if(!isValid) {
+				fout.append(""-1\n"");
+				continue;
+			}
+			//locate the start of the chain
+			for(int i = 0; i < n; i++) {
+				if(c.get(i).size() == 1) {
+					start = i;
+					break;
+				}
+			}
+			int[] ans = new int[n - 1];
+			int cur = start;
+			int next = c.get(start).get(0);
+			int prime = 2;
+			while(true) {
+				int index = 0;
+				if(order.containsKey(new ArrayList<Integer>(Arrays.asList(cur, next)))) {
+					index = order.get(new ArrayList<Integer>(Arrays.asList(cur, next)));
+				}
+				else {
+					index = order.get(new ArrayList<Integer>(Arrays.asList(next, cur)));
+				}
+				ans[index] = prime;
+				if(c.get(next).size() == 1) {
+					break;
+				}
+				prime = prime == 3? 2 : 3;
+				int prev = cur;
+				cur = next;
+				next = c.get(cur).get(0) == prev? c.get(cur).get(1) : c.get(cur).get(0);
+			}
+			for(int i : ans) {
+				fout.append(i).append("" "");
+			}
+			fout.append(""\n"");
+		}
+		System.out.print(fout);
+	}
+}
+","import java.io.OutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.PrintWriter;
+import java.util.*;
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+
+public class Main {
+    public static void main(String[] args) {
+        InputStream inputStream = System.in;
+        OutputStream outputStream = System.out;
+        InputReader in = new InputReader(inputStream);
+        PrintWriter out = new PrintWriter(outputStream);
+        TaskA solver = new TaskA();
+        //int a = 1;
+        int t;
+        t = in.nextInt();
+        //t = 1;
+        while (t > 0) {
+            //out.print(""Case #""+(a++)+"": "");
+            solver.call(in,out);
+            t--;
+        }
+        out.close();
+
+    }
+
+    static class TaskA {
+        Map<Integer, ArrayList<Integer>> ans;
+        Map<Integer,Boolean> visited;
+        Map<Integer, List<Integer>> map;
+        public void call(InputReader in, PrintWriter out) {
+            int n = in.nextInt();
+            answer[] arr = new answer[n];
+            visited = new HashMap<>();
+            ans = new HashMap<>();
+            int u, v;
+            map = new HashMap<>();
+            for (int i = 0; i < n - 1; i++) {
+                arr[i] = new answer(in.nextInt(), in.nextInt());
+                u = arr[i].a;
+                v = arr[i].b;
+                map.putIfAbsent(u, new ArrayList<>());
+                map.get(u).add(v);
+                map.putIfAbsent(v, new ArrayList<>());
+                map.get(v).add(u);
+            }
+            int a = 0;
+            for(Integer i : map.keySet()){
+                if(map.get(i).size() > 2){
+                    out.println(-1);
+                    return;
+                }
+                if(map.get(i).size()==1){
+                    a = i;
+                }
+            }
+            dfs(a, -1, 0);
+
+            int[] ans1 = new int[n - 1];
+
+            for(int i = 0; i < n-1; i++){
+                u = arr[i].a;
+                v = arr[i].b;
+                if(ans.getOrDefault(u, null)!=null && ans.get(u).get(0)==v){
+                    if(ans.get(u).get(1)==0){
+                        ans1[i] = 2;
+                    }
+                    else{
+                        ans1[i] = 5;
+                    }
+                }
+                else{
+                    if(ans.get(v).get(1)==0){
+                        ans1[i] = 2;
+                    }
+                    else{
+                        ans1[i] = 5;
+                    }
+                }
+            }
+            for(Integer i : ans1){
+                out.print(i+"" "");
+            }
+            out.println();
+        }
+        public void dfs(int child, int par, int c){
+            if(par!=-1){
+                ans.putIfAbsent(par, new ArrayList<>());
+                ans.get(par).add(child);
+                ans.get(par).add(c);
+            }
+            visited.put(child, true);
+            for(Integer i : map.get(child)){
+                if(!visited.getOrDefault(i, false)){
+                    dfs(i, child, c^1);
+                }
+            }
+        }
+    }
+
+    static int gcd(int a, int b)
+    {
+        if (a == 0)
+            return b;
+        return gcd(b % a, a);
+    }
+
+    static int lcm(int a, int b)
+    {
+        return (a / gcd(a, b)) * b;
+    }
+
+
+    static class answer implements Comparable<answer>{
+        int a, b;
+
+        public answer(int a, int b) {
+            this.a = a;
+            this.b = b;
+        }
+        @Override
+        public int compareTo(answer o) {
+            return Integer.compare(this.a, o.a);
+        }
+
+    }
+
+    static class answer1 implements Comparable<answer1>{
+        int a, b, c;
+
+        public answer1(int a, int b, int c) {
+            this.a = a;
+            this.b = b;
+            this.c = c;
+
+        }
+
+        @Override
+        public int compareTo(answer1 o) {
+            return (o.a - this.a);
+        }
+    }
+
+    static long gcd(long a, long b)
+    {
+        if (b == 0)
+            return a;
+        return gcd(b, a % b);
+    }
+
+    static void sort(long[] a) {
+        ArrayList<Long> l = new ArrayList<>();
+        for (Long i:a) l.add(i);
+        l.sort(Collections.reverseOrder());
+        for (int i=0; i<a.length; i++) a[i]=l.get(i);
+    }
+
+    static final Random random=new Random();
+
+    static void shuffleSort(int[] a) {
+        int n = a.length;
+        for (int i=0; i<n; i++) {
+            int oi= random.nextInt(n), temp=a[oi];
+            a[oi]=a[i]; a[i]=temp;
+        }
+        Arrays.sort(a);
+    }
+
+    static class InputReader {
+        public BufferedReader reader;
+        public StringTokenizer tokenizer;
+
+        public InputReader(InputStream stream) {
+            reader = new BufferedReader(new InputStreamReader(stream), 32768);
+            tokenizer = null;
+        }
+
+        public String next() {
+            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
+                try {
+                    tokenizer = new StringTokenizer(reader.readLine());
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+            }
+            return tokenizer.nextToken();
+        }
+
+        public int nextInt() {
+            return Integer.parseInt(next());
+        }
+        public long nextLong(){
+            return Long.parseLong(next());
+        }
+        public double nextDouble() {
+            return Double.parseDouble(next());
+        }
+
+    }
+}",0
+2bbc6c80,4e58558c,"import java.io.*;
+import java.util.*;
+
+public class Main {
+	static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+	static StringTokenizer st;
+	static String next() throws IOException {
+		while (st == null || !st.hasMoreTokens())
+			st = new StringTokenizer(br.readLine());
+		return st.nextToken();
+	}
+	static int readInt() throws IOException {
+		return Integer.parseInt(next());
+	}
+	static long readLong() throws IOException {
+		return Long.parseLong(next());
+	}
+	static double readDouble() throws IOException {
+		return Double.parseDouble(next());
+	}
+	static char readChar() throws IOException {
+		return next().charAt(0);
+	}
+	static String readLine() throws IOException {
+		return br.readLine();
+	}
+	static class Pair implements Comparable<Pair> {
+		int f, s;
+		Pair(int f, int s) {
+			this.f = f; this.s = s;
+		}
+		public int compareTo(Pair other) {
+			if (this.f != other.f) return this.f - other.f;
+			return this.s - other.s;
+		}
+	}
+	static List<Integer> adj[];
+	static int n, a[][];
+	static long dp[][];
+	static void DFS(int v, int p) {
+		for (int u : adj[v]) {
+			if (u != p) {
+				DFS(u, v);
+				for (int i = 0; i <= 1; ++i) {
+					long add = 0;
+					for (int j = 0; j <= 1; ++j)
+						add = Math.max(add, dp[u][j] + Math.abs(a[v][i] - a[u][j]));
+					dp[v][i] += add;
+				}
+			}
+		}
+	}
+	public static void main(String[] args) throws IOException {
+		for (int t = readInt(); t > 0; --t) {
+			n = readInt();
+			adj = new List[n + 1];
+			for (int i = 1; i <= n; ++i)
+				adj[i] = new ArrayList();
+			a = new int[n + 1][2];
+			for (int i = 1; i <= n; ++i) {
+				a[i][0] = readInt();
+				a[i][1] = readInt();
+			}
+			for (int i = 1; i < n; ++i) {
+				int u = readInt(), v = readInt();
+				adj[u].add(v);
+				adj[v].add(u);
+			}
+			dp = new long[n + 1][2];
+			DFS(1, 0);
+			System.out.println(Math.max(dp[1][0], dp[1][1]));
+		}
+	}
+}
+
+","import java.io.*;
+import java.util.*;
+ 
+public class Main {
+	static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+	static StringTokenizer st;
+	static String next() throws IOException {
+		while (st == null || !st.hasMoreTokens())
+			st = new StringTokenizer(br.readLine());
+		return st.nextToken();
+	}
+	static int readInt() throws IOException {
+		return Integer.parseInt(next());
+	}
+	static long readLong() throws IOException {
+		return Long.parseLong(next());
+	}
+	static double readDouble() throws IOException {
+		return Double.parseDouble(next());
+	}
+	static char readChar() throws IOException {
+		return next().charAt(0);
+	}
+	static String readLine() throws IOException {
+		return br.readLine();
+	}
+	static class Pair implements Comparable<Pair> {
+		int f, s;
+		Pair(int f, int s) {
+			this.f = f; this.s = s;
+		}
+		public int compareTo(Pair other) {
+			if (this.f != other.f) return this.f - other.f;
+			return this.s - other.s;
+		}
+	}
+	static List<Integer> adj[];
+	static int n, a[][];
+	static long dp[][];
+	static void DFS(int v, int p) {
+		for (int u : adj[v]) {
+			if (u != p) {
+				DFS(u, v);
+				for (int i = 0; i <= 1; ++i) {
+					long add = 0;
+					for (int j = 0; j <= 1; ++j)
+						add = Math.max(add, dp[u][j] + Math.abs(a[v][i] - a[u][j]));
+					dp[v][i] += add;
+				}
+			}
+		}
+	}
+	public static void main(String[] args) throws IOException {
+		for (int t = readInt(); t > 0; --t) {
+			n = readInt();
+			adj = new List[n + 1];
+			for (int i = 1; i <= n; ++i)
+				adj[i] = new ArrayList();
+			a = new int[n + 1][2];
+			for (int i = 1; i <= n; ++i) {
+				a[i][0] = readInt();
+				a[i][1] = readInt();
+			}
+			for (int i = 1; i < n; ++i) {
+				int u = readInt(), v = readInt();
+				adj[u].add(v);
+				adj[v].add(u);
+			}
+			dp = new long[n + 1][2];
+			DFS(1, 0);
+			System.out.println(Math.max(dp[1][0], dp[1][1]));
+		}
+	}
+}
+",1
+4b398e3e,94690b36,"import java.io.*;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Random;
+import java.util.StringTokenizer;
+
+public class codeforces_750_D {
+    private static void solve(FastIOAdapter io) {
+        int n = io.nextInt();
+        int[] a = io.readArray(n);
+
+        if (n % 2 == 0) {
+            for (int i = 0; i < n; i += 2) {
+                io.out.print(a[i + 1] + "" "");
+                io.out.print(-a[i] + "" "");
+            }
+        } else {
+            for (int i = 0; i < n - 3; i += 2) {
+                io.out.print(a[i + 1] + "" "");
+                io.out.print(-a[i] + "" "");
+            }
+            if (a[n - 3] + a[n - 2] != 0) {
+                io.out.print(-a[n - 1] + "" "");
+                io.out.print(-a[n - 1] + "" "");
+                io.out.print(a[n - 3] + a[n - 2] + "" "");
+            } else if (a[n - 3] + a[n - 1] != 0) {
+                io.out.print(-a[n - 2] + "" "");
+                io.out.print(a[n - 3] + a[n - 1] + "" "");
+                io.out.print(-a[n - 2] + "" "");
+            } else {
+                io.out.print(a[n - 2] + a[n - 1] + "" "");
+                io.out.print(-a[n - 3] + "" "");
+                io.out.print(-a[n - 3] + "" "");
+            }
+        }
+        io.out.println();
+    }
+
+    public static void main(String[] args) throws Exception {
+        try (FastIOAdapter ioAdapter = new FastIOAdapter()) {
+            int count = 1;
+            count = ioAdapter.nextInt();
+            while (count-- > 0) {
+                solve(ioAdapter);
+            }
+        }
+    }
+
+    static void ruffleSort(int[] arr) {
+        int n = arr.length;
+        Random rnd = new Random();
+        for (int i = 0; i < n; ++i) {
+            int tmp = arr[i];
+            int randomPos = i + rnd.nextInt(n - i);
+            arr[i] = arr[randomPos];
+            arr[randomPos] = tmp;
+        }
+        Arrays.sort(arr);
+    }
+
+    static class FastIOAdapter implements AutoCloseable {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        public PrintWriter out = new PrintWriter(new BufferedWriter(new OutputStreamWriter((System.out))));
+        StringTokenizer st = new StringTokenizer("""");
+
+        String next() {
+            while (!st.hasMoreTokens())
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            return st.nextToken();
+        }
+
+        String nextLine() {
+            try {
+                return br.readLine();
+            } catch (IOException e) {
+                e.printStackTrace();
+                return null;
+            }
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        int[] readArray(int n) {
+            int[] a = new int[n];
+            for (int i = 0; i < n; i++) a[i] = nextInt();
+            return a;
+        }
+
+        long[] readArrayLong(int n) {
+            long[] a = new long[n];
+            for (int i = 0; i < n; i++) a[i] = nextLong();
+            return a;
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        @Override
+        public void close() throws Exception {
+            out.flush();
+            out.close();
+            br.close();
+        }
+    }
+}
+","import java.util.Scanner;
+
+public class VupsenPupsenand0 {
+
+    public static void main(String args[]) {
+        Scanner scan = new Scanner(System.in);
+        int t = scan.nextInt();
+        while (t-- > 0) {
+            int n = scan.nextInt();
+            int[] a = new int[n];
+            for (int i = 0; i < n; i++) {
+                a[i] = scan.nextInt();
+            }
+            if (n % 2 == 0) {
+                for (int i = 0; i < n; i += 2) {
+                    System.out.print(a[i + 1] + "" "" + -a[i] + "" "");
+                }
+                System.out.println();
+            } else {
+                for (int i = 0; i < n - 3; i += 2) {
+                    System.out.print(a[i + 1] + "" "" + -a[i] + "" "");
+                }
+                int x = a[n - 3];
+                int y = a[n - 2];
+                int z = a[n - 1];
+                if (x + y != 0) {
+                    System.out.println(-z + "" "" + (-z) + "" "" + (x + y));
+                } else if (y + z != 0) {
+                    System.out.println((y + z) + "" "" + (-x) + "" "" + (-x));
+                } else {
+                    System.out.println(-y + "" "" + (x + z) + "" "" + (-y));
+                }
+            }
+        }
+    }
+
+}
+",1
+2da4b3fe,f4b87cc2,"
+import java.util.*;
+import java.lang.*;
+import java.io.*;
+
+public class Codeforces {
+	public static class FastReader {  
+        BufferedReader br;
+        StringTokenizer st;
+ 
+        public FastReader()
+        {
+            br = new BufferedReader(
+                new InputStreamReader(System.in));
+        }
+ 
+        String next()
+        {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                }
+                catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+ 
+        int nextInt() { return Integer.parseInt(next()); }
+ 
+        long nextLong() { return Long.parseLong(next()); }
+ 
+        double nextDouble()
+        {
+            return Double.parseDouble(next());
+        }
+ 
+        String nextLine()
+        {
+            String str = """";
+            try {
+                str = br.readLine();
+            }
+            catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+        }
+    }
+	public static void main (String[] args) throws java.lang.Exception
+	{
+		// your code goes here
+		FastReader sc=new FastReader();
+		int n=sc.nextInt();
+		int a[]=new int[n];
+		ArrayList<Integer> arr0=new ArrayList<>();
+		ArrayList<Integer> arr1=new ArrayList<>();
+		for(int i=0;i<n;i++)
+		{
+		    a[i]=sc.nextInt();
+		    if(a[i]==0)
+		    arr0.add(i);
+		    else
+		    arr1.add(i);
+		}
+		n=arr0.size();
+		int m=arr1.size();
+		int dp[][]=new int[m+1][n+1];
+		for(int i=0;i<=n;i++)
+		{
+		    dp[0][i]=0;
+		}
+		for(int i=1;i<=m;i++)
+		{
+		    dp[i][i]=dp[i-1][i-1]+Math.abs(arr0.get(i-1)-arr1.get(i-1));
+		    for(int j=i+1;j<=n;j++)
+		    {
+		        dp[i][j]=Math.min(dp[i-1][j-1]+Math.abs(arr0.get(j-1)-arr1.get(i-1)),dp[i][j-1]);
+		    }
+		}
+		System.out.println(dp[m][n]);
+	}
+}
+
+
+
+
+
+
+
+
+
+
+
+","import java.io.PrintWriter;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Scanner;
+
+public class D {
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        PrintWriter pw = new PrintWriter(System.out);
+        int t = 1;
+        for (int i = 0; i < t; i++) {
+            solve(sc, pw);
+        }
+        pw.close();
+    }
+    static void solve(Scanner in, PrintWriter out){
+        int n = in.nextInt();
+        int[] arr = new int[n];
+        for (int i = 0; i < n; i++) {
+            arr[i] = in.nextInt();
+        }
+        int[] pre = new int[n + 1];
+        List<Integer> z = new ArrayList<>();
+        List<Integer> o = new ArrayList<>();
+        int cnt = 0;
+        for (int i = 0; i < n; i++) {
+            if (arr[i] == 0) {
+                cnt++;
+                z.add(i);
+            }else{
+                o.add(i);
+            }
+        }
+        int[][] dp = new int[cnt + 1][(n - cnt) + 1];
+        int one = n - cnt;
+        Arrays.fill(dp[0], 100000000);
+        dp[0][0] = 0;
+//        System.out.println(one);
+        int min = 100000000;
+        for (int i = 1; i <= cnt; i++) {// the position of zero,
+            Arrays.fill(dp[i], 100000000);
+            dp[i][0] = 0;
+            for (int j = 1; j <= Math.min(one, i); j++) {// the position of one
+                if (cnt - i < one - j){
+                    dp[i][j] = 100000000;
+                }else{
+                    dp[i][j] = Math.min(dp[i - 1][j - 1] + Math.abs(o.get(j - 1) - z.get(i - 1)), dp[i - 1][j]);
+                }
+                if (j == one){
+                    min = Math.min(min, dp[i][j]);
+                }
+            }
+        }
+        min = Math.min(min, dp[0][n - cnt]);
+        out.println(min);
+    }
+
+
+
+    static boolean isPrime(long n)
+    {
+        // Corner cases
+        if (n <= 1)
+            return false;
+        if (n <= 3)
+            return true;
+
+        // This is checked so that we can skip
+        // middle five numbers in below loop
+        if (n % 2 == 0 || n % 3 == 0)
+            return false;
+
+        for (int i = 5; i * i <= n; i = i + 6)
+            if (n % i == 0 || n % (i + 2) == 0)
+                return false;
+
+        return true;
+    }
+
+    static long gcd(long a, long b)
+    {
+        if (a == 0)
+            return b;
+        return gcd(b % a, a);
+    }
+
+    // method to return LCM of two numbers
+    static long lcm(long a, long b)
+    {
+        return (a / gcd(a, b)) * b;
+    }
+
+    public static int[] sieveEratosthenes(int n) {
+        if (n <= 32) {
+            int[] primes = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31};
+            for (int i = 0; i < primes.length; i++) {
+                if (n < primes[i]) {
+                    return Arrays.copyOf(primes, i);
+                }
+            }
+            return primes;
+        }
+
+        int u = n + 32;
+        double lu = Math.log(u);
+        int[] ret = new int[(int) (u / lu + u / lu / lu * 1.5)];
+        ret[0] = 2;
+        int pos = 1;
+
+        int[] isnp = new int[(n + 1) / 32 / 2 + 1];
+        int sup = (n + 1) / 32 / 2 + 1;
+
+        int[] tprimes = {3, 5, 7, 11, 13, 17, 19, 23, 29, 31};
+        for (int tp : tprimes) {
+            ret[pos++] = tp;
+            int[] ptn = new int[tp];
+            for (int i = (tp - 3) / 2; i < tp << 5; i += tp) ptn[i >> 5] |= 1 << (i & 31);
+            for (int j = 0; j < sup; j += tp) {
+                for (int i = 0; i < tp && i + j < sup; i++) {
+                    isnp[j + i] |= ptn[i];
+                }
+            }
+        }
+
+        // 3,5,7
+        // 2x+3=n
+        int[] magic = {0, 1, 23, 2, 29, 24, 19, 3, 30, 27, 25, 11, 20, 8, 4, 13, 31, 22, 28, 18, 26, 10, 7, 12, 21, 17, 9, 6, 16, 5, 15, 14};
+        int h = n / 2;
+        for (int i = 0; i < sup; i++) {
+            for (int j = ~isnp[i]; j != 0; j &= j - 1) {
+                int pp = i << 5 | magic[(j & -j) * 0x076be629 >>> 27];
+                int p = 2 * pp + 3;
+                if (p > n) break;
+                ret[pos++] = p;
+                if ((long) p * p > n) continue;
+                for (int q = (p * p - 3) / 2; q <= h; q += p) isnp[q >> 5] |= 1 << q;
+            }
+        }
+
+        return Arrays.copyOf(ret, pos);
+    }
+
+    //    reverse division for 2
+    public static long[] rdiv2(int n, int mod){
+        long[] arr = new long[n + 5];
+        arr[0] = 1;
+        long rev2 = (mod + 1) / 2;
+        for (int i = 1; i < n; i++) {
+            arr[i] = arr[i - 1] * rev2 % mod;
+        }
+        return arr;
+    }
+    static List<Integer> primeFactors(int n)
+    {
+        // Print the number of 2s that divide n
+        List<Integer> ls = new ArrayList<>();
+        if (n % 2 == 0) ls.add(2);
+        while (n%2==0)
+        {
+            n /= 2;
+        }
+
+        // n must be odd at this point.  So we can
+        // skip one element (Note i = i +2)
+        for (int i = 3; i <= Math.sqrt(n); i+= 2)
+        {
+            // While i divides n, print i and divide n
+            if (n  % i == 0) ls.add(i);
+            while (n%i == 0)
+            {
+                n /= i;
+            }
+        }
+        if (n > 1) ls.add(n);
+        return ls;
+    }
+
+    static int find(int i, int[] par){
+        if (par[i] < 0) return i;
+        return par[i] = find(par[i], par);
+    }
+    static boolean union(int i, int j, int[] par){
+        int pi = find(i, par);
+        int pj = find(j, par);
+        if (pi == pj) return false;
+        if (par[pi] < par[pj]){
+            par[pi] += par[pj];
+            par[pj] = pi;
+        }else{
+            par[pj] += par[pi];
+            par[pi] = pj;
+        }
+        return true;
+    }
+}
+",0
+0c9d4def,f665e87b,"import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.StringTokenizer;
+
+public class C{
+    private static int maxWords = 0;
+    private static int[][] words;
+    private static int n;
+    private static int[] netwrtchar(int index){
+        ArrayList<Integer> list = new ArrayList<>();
+        for(int i=0; i<n; i++){
+            int sum = 0;
+            for(int j=0; j<words[i].length; j++){
+                if(j==index) continue;
+                sum += words[i][j];
+            }
+            list.add(words[i][index] - sum);
+            // f[i] = words[i][index] - sum;
+        }
+        Collections.sort(list, Collections.reverseOrder());
+        int[] f = new int[list.size()];
+        for(int i=0; i<list.size(); i++){
+            f[i] = list.get(i);
+        }
+        return f;
+    }
+    private static int maxWindow(int[] f){
+        int count = 0, sum = 0;
+        int index = 0;
+        while(index<f.length && sum+f[index]>0){
+            sum += f[index++];
+            count++;
+        }
+        return count;
+    }
+    public static void main(String[] args){
+        FS sc = new FS();
+        PrintWriter pw = new PrintWriter(System.out);
+        int t = sc.nextInt();
+        while(t-->0){
+            n = sc.nextInt();
+            words = new int[n][5];
+            maxWords = 0;
+            for(int i=0; i<n; i++){
+                String s = sc.next();
+                for(int j=0; j<s.length(); j++){
+                    words[i][s.charAt(j)-'a']++;
+                }
+            }
+            int maxWindow = 0;
+            for(int i=0; i<5; i++){
+                int[] f = netwrtchar(i);
+                int current = maxWindow(f);
+                maxWindow = Math.max(maxWindow, current);
+            }
+            System.out.println(maxWindow);
+        }
+        pw.flush();
+        pw.close();
+    }
+
+    static class FS{
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st = new StringTokenizer("""");
+    
+        String next(){
+            while(!st.hasMoreElements()){
+                try{
+                    st = new StringTokenizer(br.readLine());
+                } catch(Exception ignored){
+                }
+            }
+            return st.nextToken();
+        }
+        
+        int[] nextArray(int n){
+            int[] a = new int[n];
+            for(int i = 0; i < n; i++){
+                a[i] = nextInt();
+            }
+            return a;
+        }
+        
+        long[] nextLongArray(int n){
+            long[] a = new long[n];
+            for(int i = 0; i < n; i++){
+                a[i] = nextLong();
+            }
+            return a;
+        }
+        
+        int nextInt(){
+            return Integer.parseInt(next());
+        }
+        
+        long nextLong(){
+            return Long.parseLong(next());
+        }
+        
+        double nextDouble(){
+            return Double.parseDouble(next());
+        }
+    }
+}","
+
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.StringTokenizer;
+import java.util.TreeMap;
+
+public class C_CF {
+
+    public static void main(String[] args) {
+        FastScanner57 fs = new FastScanner57();
+        PrintWriter pw = new PrintWriter(System.out);
+        int t = fs.ni();
+        //int t = 1;
+        for (int tc = 0; tc < t; tc++) {
+            int n = fs.ni();
+            String[] s = new String[n];
+            for (int i = 0; i < n; i++) {
+                s[i] = fs.next();
+            }
+            int res = c(0,s);
+            for (int i = 1; i < 5; i++) {
+                res = Math.max(res,c(i,s));
+            }
+            pw.println(res);
+        }
+        
+        pw.close();
+
+    }
+    public static int c(int l, String[] s) {
+        List<Integer> list = new ArrayList();
+        for (int i = 0; i < s.length; i++) {
+            String t = s[i];
+            int ct = 0;
+            for (int j = 0; j < t.length(); j++) {
+                if (t.charAt(j)-'a'==l) {
+                    ct++;
+                } else {
+                    ct--;
+                }
+            }
+            list.add(ct);
+        }
+        Collections.sort(list);
+        Collections.reverse(list);
+        int sum = 0;
+        for (int i = 0; i < s.length; i++) {
+            sum += list.get(i);
+            if (sum<=0) return i;
+        }
+        return list.size();
+    }
+    public static int gcd(int n1, int n2) {
+        if (n2 == 0) {
+            return n1;
+        }
+        return gcd(n2, n1 % n2);
+    }
+
+    static class BIT18 {
+
+        int[] bit;
+
+        public BIT18(int size) {
+            bit = new int[size];
+        }
+
+        public void update(int ind, int delta) {
+            while (ind < bit.length) {
+                bit[ind] += delta;
+                ind = ind + (ind & (-1 * ind));
+            }
+        }
+
+        public int sum(int ind) {
+            int s = 0;
+            while (ind > 0) {
+                s += bit[ind];
+                ind = ind - (ind & (-1 * ind));
+            }
+            return s;
+        }
+
+        public int query(int l, int r) {
+            return sum(r) - sum(l);
+        }
+    }
+
+    // 0 -> left was chosen
+    // 1 -> right was chosen
+
+    public static void sort(long[] a) {
+        List<Long> list = new ArrayList();
+        for (int i = 0; i < a.length; i++) {
+            list.add(a[i]);
+        }
+        Collections.sort(list);
+        for (int i = 0; i < a.length; i++) {
+            a[i] = list.get(i);
+        }
+    }
+
+    public static long gcd(long n1, long n2) {
+        if (n2 == 0) {
+            return n1;
+        }
+        return gcd(n2, n1 % n2);
+    }
+
+}
+
+class UnionFind16 {
+
+    int[] id;
+
+    public UnionFind16(int size) {
+        id = new int[size];
+        for (int i = 0; i < size; i++) {
+            id[i] = i;
+        }
+    }
+
+    public int find(int p) {
+        int root = p;
+        while (root != id[root]) {
+            root = id[root];
+        }
+        while (p != root) {
+            int next = id[p];
+            id[p] = root;
+            p = next;
+        }
+        return root;
+    }
+
+    public void union(int p, int q) {
+        int a = find(p), b = find(q);
+        if (a == b) {
+            return;
+        }
+        id[b] = a;
+    }
+}
+
+class FastScanner57 {
+
+    BufferedReader br;
+    StringTokenizer st;
+
+    public FastScanner57() {
+        br = new BufferedReader(new InputStreamReader(System.in), 32768);
+        st = null;
+    }
+
+    String next() {
+        while (st == null || !st.hasMoreElements()) {
+            try {
+                st = new StringTokenizer(br.readLine());
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+        }
+        return st.nextToken();
+    }
+
+    int ni() {
+        return Integer.parseInt(next());
+    }
+
+    int[] intArray(int N) {
+        int[] ret = new int[N];
+        for (int i = 0; i < N; i++) {
+            ret[i] = ni();
+        }
+        return ret;
+    }
+
+    long nl() {
+        return Long.parseLong(next());
+    }
+
+    long[] longArray(int N) {
+        long[] ret = new long[N];
+        for (int i = 0; i < N; i++) {
+            ret[i] = nl();
+        }
+        return ret;
+    }
+
+    double nd() {
+        return Double.parseDouble(next());
+    }
+
+    String nextLine() {
+        String str = """";
+        try {
+            str = br.readLine();
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        return str;
+    }
+}
+",0
+9c55bc1b,c9da41af,"import java.util.*;
+import java.io.*;
+
+public class Main {
+    static MyScanner sc;
+    static PrintWriter out;
+    static {
+        sc = new MyScanner();
+        out = new PrintWriter(System.out);
+    }
+    public static void bfs(Node[] g, int[] ans) {
+        Arrays.fill(ans, -1);
+        boolean[] visited = new boolean[g.length];
+        Queue<Integer> q = new LinkedList<>();
+        int s = 0;
+        for(int i = 0; i < g.length; i++) {
+            if(g[i].l.size() == 1) {
+                s = i;
+                break;
+            }
+        }
+        q.add(s);
+        int curr = 2;
+        while(!q.isEmpty()) {
+            int u = q.poll();
+            if(visited[u])
+                continue;
+            visited[u] = true;
+            for(Edge edge : g[u].l) {
+                if(!visited[edge.v]) {
+                    ans[edge.id] = curr;
+                    q.add(edge.v);
+                    if(curr == 2) curr = 3;
+                    else curr = 2;
+                }
+            }
+        }
+    }
+    public static void solve() {
+        int n = sc.nextInt();
+        Node[] a = new Node[n];
+        for(int i = 0; i < n; i++)
+            a[i] = new Node();
+        for(int i = 0; i < n - 1; i++) {
+            int u = sc.nextInt() - 1;
+            int v = sc.nextInt() - 1;
+            a[u].l.add(new Edge(v, i));
+            a[v].l.add(new Edge(u, i));
+        }
+        for(Node node : a) {
+            if(node.l.size() > 2) {
+                out.println(-1);
+                return;
+            }
+        }
+        int[] ans = new int[n - 1];
+        bfs(a, ans);
+        for(int i = 0; i < n - 1; i++)
+            out.print(ans[i] + "" "");
+        out.println();
+    }
+    public static void main(String[] args) {
+        int t = sc.nextInt();
+        while(t-- > 0)
+            solve();
+        out.flush();
+    }
+}
+
+class Edge {
+    int v, id;
+    Edge(int a, int b) {
+        v = a;
+        id = b;
+    }
+}
+
+class Node {
+    ArrayList<Edge> l;
+    Node() {
+        l = new ArrayList<>();
+    }
+}
+
+class MyScanner {
+    BufferedReader br;
+    StringTokenizer tok;
+    MyScanner() {
+        try { br = new BufferedReader(new InputStreamReader(System.in)); }
+        catch(Exception e) { System.out.println(e); }
+        tok = new StringTokenizer("""");
+    }
+    public String next() {
+        try {
+            while(!tok.hasMoreTokens()) tok = new StringTokenizer(br.readLine());
+        }
+        catch(Exception e) { System.out.println(e); }
+        return tok.nextToken();
+    }
+    public int nextInt() {
+        return Integer.parseInt(next());
+    }
+    public long nextLong() {
+        return Long.parseLong(next());
+    }
+    public double nextDouble() {
+        return Double.parseDouble(next());
+    }
+}
+","import java.util.*;
+import java.lang.*;
+import java.io.*;
+
+
+
+public class Main {
+	static {
+		try {
+			System.setIn(new FileInputStream(""input.txt""));
+			System.setOut(new PrintStream(new FileOutputStream(""output.txt"")));
+		} catch (Exception e) {}
+	}
+	void solve() {
+		int n = in.nextInt();
+
+		ArrayList<Edge>[] graph = new ArrayList[n + 1];
+		for (int i = 0; i < n; i++) {
+			graph[i] = new ArrayList<Edge>();
+		}
+
+		for (int i = 0; i < n - 1; i++) {
+			int u = in.nextInt();
+			int v = in.nextInt();
+			v--; u--;
+			graph[u].add(new Edge(v, i));
+			graph[v].add(new Edge(u, i));
+		}
+
+		int[] res = new int[n - 1];
+
+		for (int i = 0; i < n; i++) {
+			if (graph[i].size() > 2) {
+				out.append(""-1\n"");
+				return;
+			}
+		}
+
+		int start = -1;
+		for (int i = 0; i < n; i++) {
+			if (graph[i].size() == 1) {
+				start  = i;
+				break;
+			}
+		}
+
+		int currNode = start;
+		int prevNode = -1;
+		int weight = 2;
+
+		while (true) {
+			ArrayList<Edge> edges = graph[currNode];
+			Edge next = edges.get(0);
+			if (next.node == prevNode) {
+				if (edges.size() == 1) {
+					break;
+				}
+				next = edges.get(1);
+			}
+			res[next.index] = weight;
+			weight = 5 - weight;
+			prevNode = currNode;
+			currNode = next.node;
+		}
+
+		for (int i = 0; i < n - 1; i++) {
+			out.append(res[i] + "" "");
+		}
+		out.append(""\n"");
+	}
+
+	public static void main (String[] args) {
+		// Its Not Over Untill I Win - Syed Mizbahuddin
+		Main sol = new Main();
+		int t = 1;
+		t = in.nextInt();
+		while (t-- != 0) {
+			sol.solve();
+		}
+		System.out.print(out);
+	}
+
+	<T> void println(T[] s) {
+		System.out.println(Arrays.toString(s));
+	}
+
+	<T> void println(T s) {
+		System.out.println(s);
+	}
+
+	void print(int s) {
+		System.out.print(s);
+	}
+
+	void println(int s) {
+		System.out.println(s);
+	}
+
+	void println(int[] a) {
+		println(Arrays.toString(a));
+	}
+
+	int[] array(int n) {
+		int[] a = new int[n];
+		for (int i = 0; i < n; i++) {
+			a[i] = in.nextInt();
+		}
+		return a;
+	}
+
+	int[] array1(int n) {
+		int[] a = new int[n + 1];
+		for (int i = 1; i <= n; i++) {
+			a[i] = in.nextInt();
+		}
+		return a;
+	}
+
+
+	static FastReader in;
+	static StringBuffer out;
+	final int MAX;
+	final int MIN;
+	int mod ;
+	Main() {
+		in = new FastReader();
+		out = new StringBuffer();
+		MAX = Integer.MAX_VALUE;
+		MIN = Integer.MIN_VALUE;
+		mod = (int)1e9 + 7;
+	}
+}
+class FastReader {
+	BufferedReader br;
+	StringTokenizer st;
+
+	public FastReader() {
+		br = new BufferedReader(
+		    new InputStreamReader(System.in));
+	}
+
+	String next() {
+		while (st == null || !st.hasMoreElements()) {
+			try {
+				st = new StringTokenizer(br.readLine());
+			} catch (IOException e) {
+				e.printStackTrace();
+			}
+		}
+		return st.nextToken();
+	}
+
+	int nextInt() { return Integer.parseInt(next()); }
+
+	long nextLong() { return Long.parseLong(next()); }
+
+	double nextDouble() {
+		return Double.parseDouble(next());
+	}
+
+	String nextLine() {
+		String str = """";
+		try {
+			str = br.readLine();
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+		return str;
+	}
+}
+
+class Edge {
+	int node, index;
+	Edge(int node, int index) {
+		this.node = node;
+		this.index = index;
+	}
+}",0
+175201f9,9399204d,"import java.util.*;
+import java.io.*;
+public class Sol{
+ 
+/*   
+->check n=1, int overflow , array bounds , all possibilites(dont stuck on 1 approach)
+->Problem = Observation(constraints(m<=n/3 or k<=min(100,n)) 
+           + Thinking + Technique (seg_tree,binary lift,rmq,bipart,dp,connected comp etc)
+->solve or leave it (- tutorial improves you in minimal way -)
+*/
+ 
+public static void main (String []args) {
+//precomp();
+ 
+int times=ni();while(times-->0){solve();}out.close();}
+
+static void solve(){
+ int n=ni();
+ int sum[]=new int[5]; 
+ PriorityQueue<Integer> p[]=new PriorityQueue[5];for(int i=0;i<5;i++)p[i]=new PriorityQueue<Integer>();
+ for(int i=0;i<n;i++){
+   char c[]=ns().toCharArray();
+   int len=c.length;
+   int csum[]=new int[5];
+   for(int j=0;j<len;j++){csum[c[j]-'a']++;}
+   for(int j=0;j<5;j++){csum[j]=2*csum[j]-len;p[j].offer(csum[j]);sum[j]+=csum[j];}
+ }
+ int max=0;
+ for(int i=0;i<5;i++){
+   int cmax=n;
+   while(p[i].size()>0 && sum[i]<=0){cmax--;sum[i]-=p[i].poll();}
+   max=Math.max(max,cmax);
+ }
+ out.println(max);
+ return;
+
+}
+
+//-----------------Utility--------------------------------------------
+
+static long gcd(long a,long b){if(b==0)return a; return gcd(b,a%b);}
+ 
+static int Max=Integer.MAX_VALUE; static long mod=1000000007;
+ 
+//static int v(char c){return (int)(c-'a');}
+ 
+public static long power(long x, long y )
+    {
+        //0^0 = 1
+        long res = 1L;
+        x = x%mod;
+        while(y > 0)
+        {
+            if((y&1)==1)
+                res = (res*x)%mod;
+            y >>= 1;
+            x = (x*x)%mod;
+        }
+        return res;
+    }
+ 
+static class Pair implements Comparable<Pair>{
+        int id;int value;Pair next;
+        public Pair(int id,int value) {
+         
+          this.id=id;this.value=value;next=null;
+        }
+        @Override
+        public int compareTo(Pair p){return Long.compare(value,p.value);}
+    }
+
+ 
+//----------------------I/O---------------------------------------------
+ 
+static InputStream inputStream = System.in;
+static OutputStream outputStream = System.out;
+static FastReader in=new FastReader(inputStream);
+static PrintWriter out=new PrintWriter(outputStream);
+ 
+static class FastReader 
+{ 
+  BufferedReader br; 
+  StringTokenizer st; 
+ 
+        FastReader(InputStream is) {
+            br = new BufferedReader(new InputStreamReader(is));
+        }
+ 
+  public String next() 
+  { 
+      while (st == null || !st.hasMoreElements()) 
+      { 
+          try
+          { 
+              st = new StringTokenizer(br.readLine()); 
+          } 
+          catch (IOException  e) 
+          { 
+              e.printStackTrace(); 
+          } 
+      } 
+      return st.nextToken(); 
+  } 
+ 
+  public int nextInt() 
+  { 
+      return Integer.parseInt(next()); 
+  } 
+ 
+  public long nextLong() 
+  { 
+      return Long.parseLong(next()); 
+  } 
+ 
+ public  double nextDouble() 
+  { 
+      return Double.parseDouble(next()); 
+  } 
+ 
+ 
+  String nextLine() 
+  { 
+      String str = """"; 
+      try
+      { 
+          str = br.readLine(); 
+      } 
+      catch (IOException e) 
+      { 
+          e.printStackTrace(); 
+      } 
+      return str; 
+  } 
+}
+/*static int ni() {
+        try {
+            boolean in = false;
+            int res = 0;
+            for (;;) {
+                int b = System.in.read() - '0';
+                if (b >= 0) {
+                    in = true;
+                    res = 10 * res + b;
+                }
+                else if (in)
+                    return res;
+            }
+        } catch (IOException e) {
+            throw new Error(e);
+        }
+    }*/
+static int ni(){return in.nextInt();}
+static long nl(){return in.nextLong();}
+static double nd(){return in.nextDouble();}
+static String ns(){return in.nextLine();}
+}","import java.io.*;
+import java.util.*;
+
+
+
+import java.math.*;
+import java.math.BigInteger;
+
+
+public final class A
+{    
+	static PrintWriter out = new PrintWriter(System.out); 
+	static StringBuilder ans=new StringBuilder();
+	static FastReader in=new FastReader();
+	static ArrayList<Integer> g[];
+	static long mod=(long)1e9+7,INF=Long.MAX_VALUE;
+	static boolean set[],col[]; 
+	static int par[],tot[],partial[];
+	static int D[],P[][];
+	static long dp[][],sum=0,max=0,size[];
+	//	static node1 seg[];
+	//static pair moves[]= {new pair(-1,0),new pair(1,0), new pair(0,-1), new pair(0,1)};
+	public static void main(String args[])throws IOException
+	{				
+
+
+	
+		int T=i();
+		outer:while(T-->0)
+		{
+			int N=i();
+			int size[]=new int[N];
+			PriorityQueue<node1> q[]=new PriorityQueue[6];
+			for(int i=0; i<5; i++)q[i]=new PriorityQueue<node1>();
+			for(int i=0; i<N; i++)
+			{
+				char X[]=in.next().toCharArray();
+				int s=X.length;
+				size[i]=s;
+				int f[]=new int[5];
+				for(char x:X)f[x-'a']++;
+				for(int j=0; j<5; j++)q[j].add(new node1(f[j],i,s));
+			}
+			
+			int max=0;
+			for(int i=0; i<5; i++)
+			{
+				PriorityQueue<node1> q_new=new PriorityQueue<>();
+				q_new=q[i];
+				int c=0;
+				long f=0;
+				while(q_new.size()>0)
+				{
+					node1 x=q_new.remove();
+//					System.out.println(x.f+"" ""+x.size+"" ""+x.a);
+					f+=x.a;
+					if(f>0)
+					{
+						c++;
+						max=Math.max(max, c);
+					}
+					else break;
+				}
+			}
+			out.println(max);
+		}
+		out.close();
+
+	}
+	static int OR(int i,int j)
+	{
+		if(i>j)
+		{
+			int t=i;
+			i=j;
+			j=t;
+		}
+		System.out.println(""OR ""+i+"" ""+j);
+		return i();
+	}
+	static int AND(int i,int j)
+	{
+		if(i>j)
+		{
+			int t=i;
+			i=j;
+			j=t;
+		}
+		System.out.println(""AND ""+i+"" ""+j);
+		return i();
+	}
+	static int XOR(int i,int j)
+	{
+		if(i>j)
+		{
+			int t=i;
+			i=j;
+			j=t;
+		}
+		System.out.println(""XOR ""+i+"" ""+j);
+		return i();
+	}
+
+	static boolean f1(int l,char X[])
+	{
+		int i=0;
+		for(; l<X.length; l++)
+		{
+			if(X[i]!=X[l])return false;
+			i++;
+		}
+		return true;
+	}
+	static int f(int a)
+	{
+		for(int i=a+1; a>0; a++)
+		{
+			if(GCD(i,a)==1)return i;
+		}
+		return 0;
+	}
+	static int min(char X[],char str[],int N)
+	{
+		int s=0;
+		for(int i=0; i<N; i++)
+		{
+			int it=i%3;
+			if(X[i]!=str[it])s++;
+			//             ans.append(str[it]);
+		}
+		return s;
+	}
+	static char f(int i,char X[])
+	{
+		int a=0,b=0,c=0;
+		for(; i<X.length; i+=3)
+		{
+			if(X[i]=='R')a++;
+			if(X[i]=='B')b++;
+			if(X[i]=='G')c++;
+		}
+		if(a>=b && a>=c)return 'R';
+		if(b>=a && b>=c)return 'B';
+		return 'G';
+	}
+
+
+	static void f1(int n,int p,long sum,int N)
+	{
+		for(int c:g[n])
+		{
+			if(c==p)continue;
+
+			long s=sum+N-2*size[c];
+			f1(c,n,s,N);
+			max=Math.max(max, s);
+		}
+	}
+	static long f(int i,int j,ArrayList<Integer> A)
+	{
+
+		if(i+1==A.size())
+		{
+			return j;
+		}		
+		int moves=1+A.get(i);
+		if(j==1)return 1+f(i+1,moves,A);
+		if(j>0 && dp[i][j-1]==0)f(i,j-1,A);
+		return dp[i][j]=dp[i][j-1]+f(i+1,j+moves,A);
+	}
+	//	static void build(int v,int tl,int tr,long A[])
+	//	{
+	//		if(tl==tr)
+	//		{
+	//			seg[v]=new node1(A[tl],A[tr],1,true);
+	//			return ;
+	//		}
+	//		int tm=(tl+tr)/2;
+	//		build(2*v,tl,tm,A);
+	//		build(2*v+1,tm+1,tr,A);
+	//		seg[v]=merge(seg[2*v],seg[2*v+1]);
+	//	}
+	//	static node1 ask(int v,int tl,int tr,int l,int r)
+	//	{
+	//		if(l>r)return new node1(0,0,0,false);//verify true or false
+	//		if(tl==l && tr==r)return seg[v];
+	//		int tm=(tl+tr)/2;
+	//		node1 a=ask(v*2,tl,tm,l,Math.min(tm, r));
+	//		node1 b=ask(v*2+1,tm+1,tr,Math.max(tm+1, l),r);
+	//		return merge(a,b);
+	//	}
+	//	static node1 merge(node1 a,node1 b)
+	//	{
+	//		long s=0;
+	//		long l1=a.L,r1=a.R,c1=a.cnt;
+	//		long l2=b.L,r2=b.R,c2=b.cnt;
+	//		long g=GCD(l2,r1); s=c1+c2;
+	//		if(g==1)
+	//		{
+	//			s--;
+	//			g=(l2*r1)/g;
+	//			if(c1==1)
+	//			{
+	//				l1=g;
+	//			}
+	//			if(c2==1)r2=g;
+	//			return new node1(l1,r2,s,true);
+	//		}
+	//		return new node1(l1,r2,s,a.leaf^b.leaf);
+	//	}
+	static long f(long l,long r,long a,long b,long N)
+	{
+		while(r-l>1)
+		{
+			long m=(l+r)/2;
+			long x=m*b;
+			if(N<x)
+			{
+				r=m;
+				continue;
+			}
+			if((N-x)%a==0)r=m;
+			else l=m;
+
+		}
+		return r;
+	}
+	static long f1(long a,long A[],long bits[],long sum)
+	{
+		long s=A.length;
+		s=mul(s,a);
+		s=(s+(sum%mod))%mod;
+		long p=1L;
+		for(long x:bits)
+		{
+			if((a&p)!=0)s=((s-mul(x,p))+mod)%mod;
+			p<<=1;
+		}
+		return s;
+	}
+	static long f2(long a,long A[],long bits[])
+	{
+		long s=0;
+		long p=1L;
+		for(long x:bits)
+		{
+			if((a&p)!=0)
+			{
+				s=(s+mul(p,x))%mod;
+			}
+			p<<=1;
+		}
+		return s;
+	}
+	static long f(long x1,long y1,long x2,long y2)
+	{
+		return Math.abs(x1-x2)+Math.abs(y1-y2);
+	}
+	static long f(long x,long max,long s)
+	{
+		long l=-1,r=(x/s)+1;
+		while(r-l>1)
+		{
+			long m=(l+r)/2;
+			if(x-m*s>max)l=m;
+			else r=m;
+		}
+		return l+1;
+	}
+	static int f(long A[],long x)
+	{
+		int l=-1,r=A.length;
+		while(r-l>1)
+		{
+			int m=(l+r)/2;
+			if(A[m]>=x)r=m;
+			else l=m;			
+		}
+		return r;
+	}
+
+
+
+	static int bin(int x,ArrayList<Integer> A)
+	{
+		int l=0,r=A.size()-1;
+		while(l<=r)
+		{
+			int m=(l+r)/2;
+			int a=A.get(m);
+			if(a==x)return m;
+			if(a<x)l=m+1;
+			else r=m-1;
+		}
+		return 0;
+	}
+	static int left(int x,ArrayList<Integer> A)
+	{
+		int l=-1,r=A.size();
+		while(r-l>1)
+		{
+			int m=(l+r)/2;
+			int a=A.get(m);
+			if(a<=x)l=m;
+			else r=m;
+		}
+		return l;
+	}
+	static int right(int x,ArrayList<Integer> A)
+	{
+		int l=-1,r=A.size();
+		while(r-l>1)
+		{
+			int m=(l+r)/2;
+			int a=A.get(m);
+			if(a<x)l=m;
+			else r=m;
+		}
+		return r;
+	}
+
+
+
+	static boolean equal(long A[],long B[])
+	{
+		for(int i=0; i<A.length; i++)if(A[i]!=B[i])return false;
+		return true;	
+	}
+
+
+	static int max(int a ,int b,int c,int d)
+	{
+		a=Math.max(a, b);
+		c=Math.max(c,d);
+		return Math.max(a, c);
+	}
+	static int min(int a ,int b,int c,int d)
+	{
+		a=Math.min(a, b);
+		c=Math.min(c,d);
+		return Math.min(a, c);
+	}
+
+
+
+	static HashMap<Integer,Integer> Hash(int A[])
+	{
+		HashMap<Integer,Integer> mp=new HashMap<>();
+		for(int a:A)
+		{
+			int f=mp.getOrDefault(a,0)+1;
+			mp.put(a, f);
+		}
+		return mp;
+	}
+	static long mul(long a, long b)
+	{
+		return ( a %mod * 1L * b%mod )%mod;
+	}
+	static void swap(int A[],int a,int b)
+	{
+		int t=A[a];
+		A[a]=A[b];
+		A[b]=t;
+	}
+
+
+	static int find(int a)
+	{
+		if(par[a]<0)return a;
+		return par[a]=find(par[a]);
+	}
+	static void union(int a,int b)
+	{
+		a=find(a);
+		b=find(b);
+		if(a!=b)
+		{
+			par[a]+=par[b];
+			par[b]=a;
+		}
+	}
+	static boolean isSorted(int A[])
+	{
+		for(int i=1; i<A.length; i++)
+		{
+			if(A[i]<A[i-1])return false;
+		}
+		return true;
+	}
+
+	static boolean isDivisible(StringBuilder X,int i,long num)
+	{
+		long r=0;
+		for(; i<X.length(); i++)
+		{
+			r=r*10+(X.charAt(i)-'0');
+			r=r%num;
+		}
+		return r==0;
+	}    
+
+
+
+	static int lower_Bound(int A[],int low,int high, int x) 
+	{ 
+		if (low > high) 
+			if (x >= A[high]) 
+				return A[high]; 
+
+		int mid = (low + high) / 2; 
+
+		if (A[mid] == x) 
+			return A[mid]; 
+
+		if (mid > 0 && A[mid - 1] <= x && x < A[mid]) 
+			return A[mid - 1]; 
+
+		if (x < A[mid]) 
+			return lower_Bound( A, low, mid - 1, x); 
+
+		return lower_Bound(A, mid + 1, high, x); 
+	} 
+
+	static String f(String A)
+	{
+		String X="""";
+		for(int i=A.length()-1; i>=0; i--)
+		{
+			int c=A.charAt(i)-'0';
+			X+=(c+1)%2;
+		}
+		return X;
+	}
+
+	static void sort(long[] a) //check for long
+	{
+		ArrayList<Long> l=new ArrayList<>();
+		for (long i:a) l.add(i);
+		Collections.sort(l);
+		for (int i=0; i<a.length; i++) a[i]=l.get(i);
+	}
+
+	static String swap(String X,int i,int j)
+	{
+		char ch[]=X.toCharArray();
+		char a=ch[i];
+		ch[i]=ch[j];
+		ch[j]=a;
+		return new String(ch);
+	}
+
+	static int sD(long n)  
+	{  
+
+		if (n % 2 == 0 )  
+			return 2;  
+
+		for (int i = 3; i * i <= n; i += 2) {  
+			if (n % i == 0 )  
+				return i;  
+		}  
+
+		return (int)n;  
+	}  
+
+	static void setGraph(int N)
+	{
+		tot=new int[N+1];
+		partial=new int[N+1];
+		D=new int[N+1];
+		P=new int[N+1][(int)(Math.log(N)+10)];
+		set=new boolean[N+1];
+		g=new ArrayList[N+1];
+		for(int i=0; i<=N; i++)
+		{
+
+			g[i]=new ArrayList<>();		
+			D[i]=Integer.MAX_VALUE;
+			//D2[i]=INF;
+		}
+	}
+
+
+
+	static  long pow(long a,long b)
+	{
+		//long mod=1000000007;
+		long pow=1;
+		long x=a;
+		while(b!=0)
+		{
+			if((b&1)!=0)pow=(pow*x)%mod;
+			x=(x*x)%mod;
+			b/=2;
+		}
+		return pow;
+	}
+
+	static long toggleBits(long x)//one's complement || Toggle bits
+	{
+		int n=(int)(Math.floor(Math.log(x)/Math.log(2)))+1;
+
+		return ((1<<n)-1)^x;
+	}
+
+	static int countBits(long a)
+	{
+		return (int)(Math.log(a)/Math.log(2)+1);
+	}
+
+	static long fact(long N)
+	{ 
+		long n=2; 
+		if(N<=1)return 1;
+		else
+		{
+			for(int i=3; i<=N; i++)n=(n*i)%mod;
+		}
+		return n;
+	}
+
+	static int kadane(int A[])
+	{
+		int lsum=A[0],gsum=A[0];
+		for(int i=1; i<A.length; i++)
+		{
+			lsum=Math.max(lsum+A[i],A[i]);
+			gsum=Math.max(gsum,lsum);
+		}
+		return gsum;
+	}
+
+	static void sort(int[] a) {
+		ArrayList<Integer> l=new ArrayList<>();
+		for (int i:a) l.add(i);
+		Collections.sort(l);
+		for (int i=0; i<a.length; i++) a[i]=l.get(i);
+	}
+
+	static boolean isPrime(long N)
+	{
+		if (N<=1)  return false; 
+		if (N<=3)  return true; 
+		if (N%2 == 0 || N%3 == 0) return false; 
+		for (int i=5; i*i<=N; i=i+6) 
+			if (N%i == 0 || N%(i+2) == 0) 
+				return false; 
+		return true; 
+	}
+	static void print(char A[])
+	{
+		for(char c:A)System.out.print(c+"" "");
+		System.out.println();
+	}
+	static void print(boolean A[])
+	{
+		for(boolean c:A)System.out.print(c+"" "");
+		System.out.println();
+	}
+	static void print(int A[])
+	{
+		for(int a:A)System.out.print(a+"" "");
+		System.out.println();	
+	}
+	static void print(long A[])
+	{
+		for(long i:A)System.out.print(i+ "" "");
+		System.out.println();
+
+	}
+	static void print(ArrayList<Integer> A)
+	{
+		for(int a:A)System.out.print(a+"" "");
+		System.out.println();
+	}
+
+	static int i()
+	{
+		return in.nextInt();
+	}
+
+	static long l()
+	{
+		return in.nextLong();
+	}
+
+	static int[] input(int N){
+		int A[]=new int[N];
+		for(int i=0; i<N; i++)
+		{
+			A[i]=in.nextInt();
+		}
+		return A;
+	}
+
+	static long[] inputLong(int N)     {
+		long A[]=new long[N];
+		for(int i=0; i<A.length; i++)A[i]=in.nextLong();
+		return A;
+	}
+
+	static long GCD(long a,long b) 
+	{
+		if(b==0)
+		{
+			return a;
+		}
+		else return GCD(b,a%b );
+	}
+
+}
+class node1 implements Comparable<node1>
+{
+	int index,f,size;
+	long a;
+	node1(int f,int i,int size)
+	{
+		this.f=f;
+		this.index=i;
+		this.size=size;
+		a=2*f-size;
+	}
+	public int compareTo(node1 x)
+	{
+		if(this.a==x.a)return 0;
+		else if(this.a<x.a)return 1;
+		else return -1;
+	}
+}
+
+
+//Code For FastReader
+//Code For FastReader
+//Code For FastReader
+//Code For FastReader
+class FastReader
+{
+	BufferedReader br;
+	StringTokenizer st;
+	public FastReader()
+	{
+		br=new BufferedReader(new InputStreamReader(System.in));
+	}
+
+	String next()
+	{
+		while(st==null || !st.hasMoreElements())
+		{
+			try
+			{
+				st=new StringTokenizer(br.readLine());
+			}
+			catch(IOException e)
+			{
+				e.printStackTrace();
+			}
+		}
+		return st.nextToken();
+	}
+
+	int nextInt()
+	{
+		return Integer.parseInt(next());
+	}
+
+	long nextLong()
+	{
+		return Long.parseLong(next());
+	}
+
+	double nextDouble()
+	{
+		return Double.parseDouble(next());
+	}
+
+	String nextLine()
+	{
+		String str="""";
+		try
+		{
+			str=br.readLine();
+		}
+		catch (IOException e)
+		{
+			e.printStackTrace();
+		}
+		return str;
+	}
+
+}
+",0
+a6520606,fb05904c,"import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.util.StringTokenizer;
+
+public class c {
+	public static void main(String[] args) {
+		FastScanner scan=new FastScanner();
+		PrintWriter out=new PrintWriter(System.out);
+		
+		int t=scan.nextInt();
+		for(int tt=0;tt<t;tt++) {
+			int n=scan.nextInt();
+			char[] a=scan.next().toCharArray(), b=scan.next().toCharArray();
+			int o=0, e=0;
+			int onea=0, oneb=0, zeroa=0, zerob=0;
+			int evenon=0, oddon=0;
+			for(int i=0;i<n;i++) {
+				if(a[i]==b[i]) {
+					e++;
+					if(a[i]=='1') {
+						evenon++;
+					}
+				}
+				else {
+					o++;
+					if(a[i]=='1') oddon++;
+				}
+				if(a[i]=='1') onea++;
+				else zeroa++;
+				if(b[i]=='1') oneb++;
+				else zerob++;
+			}
+			boolean good=false;
+			int otheronea=onea==0?0:n-onea+1;
+			if(oneb>=otheronea&&oneb<=onea) good=true;
+			if(oneb>=onea&&oneb<=otheronea) good=true;
+			
+			if(!good) {
+				out.println(-1);
+				continue;
+			}
+			if(e==n) out.println(0);
+			else if(e%2==1&&o%2==0&&evenon==(e+1)/2&&oddon==o/2) {
+				out.println(Math.min(o,e));
+			}
+			else if(e%2==1&&evenon==(e+1)/2) {
+				out.println(e);
+			}
+			else if(o%2==0&&oddon==o/2) {
+				out.println(o);
+			}
+			else {
+				out.println(-1);
+			}
+		}
+		out.close();
+	}
+	static class FastScanner {
+		BufferedReader br;
+		StringTokenizer st;
+
+		public FastScanner() {
+			try	{
+				br = new BufferedReader(new InputStreamReader(System.in));
+				st = new StringTokenizer(br.readLine());
+			} catch (Exception e){e.printStackTrace();}
+		}
+
+		public String next() {
+			if (st.hasMoreTokens())	return st.nextToken();
+			try {st = new StringTokenizer(br.readLine());}
+			catch (Exception e) {e.printStackTrace();}
+			return st.nextToken();
+		}
+
+		public int nextInt() {return Integer.parseInt(next());}
+
+		public long nextLong() {return Long.parseLong(next());}
+
+		public double nextDouble() {return Double.parseDouble(next());}
+
+		public String nextLine() {
+			String line = """";
+			if(st.hasMoreTokens()) line = st.nextToken();
+			else try {return br.readLine();}catch(IOException e){e.printStackTrace();}
+			while(st.hasMoreTokens()) line += "" ""+st.nextToken();
+			return line;
+		}
+	}
+}
+","/*
+  Challenge 1: Newbie to CM in 1year (Dec 2021 - Nov 2022)   🔥 5* Codechef
+  Challenge 2: CM to IM in 1 year (Dec 2022 - Nov 2023)    🔥🔥 6* Codechef
+  Challenge 3: IM to GM in 1 year (Dec 2023 - Nov 2024)  🔥🔥🔥 7* Codechef
+  Goal: Become better in CP!
+  Key: Consistency!
+*/
+
+import java.util.*;
+import java.io.*;
+import java.math.*;
+
+public class Coder {
+
+  static int n;
+  static char a[];
+  static char b[];
+  static StringBuffer str=new StringBuffer();
+
+  static void solve(){
+    boolean flag=true;
+    for(int i=0;i<n;i++) if(a[i]!=b[i]) flag=false;
+    if(flag){str.append(""0\n""); return;}
+    int tot=0;
+    int tot1=0;
+    for(int i=0;i<n;i++) if(a[i]=='1') tot++;
+    for(int i=0;i<n;i++) if(b[i]=='1') tot1++;
+    if(tot==0){
+      if(tot1!=0) str.append(""-1\n"");
+      else str.append(""0\n"");
+    }else{
+      int x=tot-1;
+      int ul=n-tot;
+      if(tot!=tot1 && (ul+1)!=tot1) str.append(""-1\n"");
+      else{
+        int same=0, nsame=0;
+        int zs, os;
+        int zd, od;
+        zs=os=zd=od=0;
+        for(int i=0;i<n;i++){
+          if(a[i]==b[i]){
+            same++;
+            if(a[i]=='0') zs++;
+            else os++;
+          }
+          else{
+            nsame++;
+            if(a[i]=='0') zd++;
+            else od++;
+          }
+        }
+        
+        // else if(zd>0 && od>0 && os>0 && zs>0) str.append(Math.min(nsame, same)).append(""\n"");
+        // else if(zd>0 && od>0) str.append(nsame).append(""\n"");
+        // else if(zs>0 && os>0) str.append(same).append(""\n"");
+        // else str.append(""-1\n"");
+        if(same==1 && nsame==n-1 && os==1) str.append(""1\n"");
+        else if(zd==od && od>0 && os>0 && os-zs==1) str.append(Math.min(nsame, same)).append(""\n"");
+        else if(zd==od && od>0) str.append(nsame).append(""\n"");
+        else if(os>0 && os-zs==1) str.append(same).append(""\n"");
+        else str.append(""-1\n"");
+      }
+    } 
+  }
+
+  public static void main(String[] args) throws java.lang.Exception {
+    BufferedReader bf;
+    PrintWriter pw;
+    boolean lenv=false;
+    if(lenv){
+      bf = new BufferedReader(
+                          new FileReader(""input.txt""));
+      pw=new PrintWriter(new
+            BufferedWriter(new FileWriter(""output.txt"")));
+    }else{
+      bf = new BufferedReader(new InputStreamReader(System.in));
+      pw = new PrintWriter(new OutputStreamWriter(System.out));
+    }
+    
+    int t = Integer.parseInt(bf.readLine().trim());
+    while (t-- > 0) {
+      String st[]=bf.readLine().trim().split(""\\s+"");
+      n=Integer.parseInt(st[0]);
+      a=bf.readLine().trim().toCharArray();
+      b=bf.readLine().trim().toCharArray();
+      solve();
+    }
+    pw.println(str);
+    pw.flush();
+    // System.outin.print(str);
+  }
+}",0
+07749c65,2bbf754b,"import java.io.*;
+import java.util.*;
+
+
+public class Nov1P4 {
+    public static void main(String[] args) {
+        MyScanner sc = new MyScanner();
+        out = new PrintWriter(new BufferedOutputStream(System.out));
+        long o = sc.nextInt();
+        for(long i = 0; i < o; i++)
+        {
+            int n = sc.nextInt();
+            long[] m = new long[n];
+            for(int j = 0; j < n; j++)
+            {
+                m[j] = sc.nextLong();
+            }
+            String str = sc.nextLine();
+            ArrayList<Long> a = new ArrayList<Long>();
+            ArrayList<Long> b = new ArrayList<Long>();
+
+            for(int j = 0; j < n; j++)
+            {
+                if(str.charAt(j) == 'B')
+                {
+                    b.add(m[j]);
+                }
+                else
+                {
+                    a.add(m[j]);
+                }
+            }
+            Collections.sort(a);
+            Collections.sort(b);
+            boolean tf = true;
+            for(int j = 0; j < b.size(); j++)
+            {
+                if(b.get(j) < (j+1) && tf)
+                {
+                    out.println(""NO"");
+                    tf = false;
+                }
+            }
+            for(int j = 0; j < a.size(); j++)
+            {
+                if(a.get(j) > j+1+b.size() && tf)
+                {
+                    out.println(""NO"");
+                    tf = false;
+                }
+            }
+            if(tf)
+                out.println(""YES"");
+        }
+        // Start writing your solution here. -------------------------------------
+
+      /*
+      int n      = sc.nextInt();        // read input as integer
+      long k     = sc.nextLong();       // read input as long
+      double d   = sc.nextDouble();     // read input as double
+      String str = sc.next();           // read input as String
+      String s   = sc.nextLine();       // read whole line as String
+
+      int result = 3*n;
+      out.println(result);                    // print via PrintWriter
+      */
+
+        // Stop writing your solution here. -------------------------------------
+        out.close();
+    }
+
+
+    //-----------PrintWriter for faster output---------------------------------
+    public static PrintWriter out;
+
+    //-----------MyScanner class for faster input----------
+    public static class MyScanner {
+        BufferedReader br;
+        StringTokenizer st;
+
+        public MyScanner() {
+            br = new BufferedReader(new InputStreamReader(System.in));
+        }
+
+        String next() {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+
+        String nextLine() {
+            String str = """";
+            try {
+                str = br.readLine();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+        }
+
+    }
+    //--------------------------------------------------------
+}
+
+","import java.util.*;
+
+/** 
+__                  __
+( _)                ( _)
+/ / \\              / /\_\_
+/ /   \\            / / | \ \
+/ /     \\          / /  |\ \ \
+/  /   ,  \ ,       / /   /|  \ \
+/  /    |\_ /|      / /   / \   \_\
+/  /  |\/ _ '_| \   / /   /   \    \\
+|  /   |/  0 \0\    / |    |    \    \\
+|    |\|      \_\_ /  /    |     \    \\
+|  | |/    \.\ o\o)  /      \     |    \\
+\    |     /\\`v-v  /        |    |     \\
+| \/    /_| \\_|  /         |    | \    \\
+| |    /__/_ `-` /   _____  |    |  \    \\
+\|    [__]  \_/  |_________  \   |   \    ()
+/    [___] (    \         \  |\ |   |   //
+|    [___]                  |\| \|   /  |/
+/|    [____]                  \  |/\ / / ||
+(  \   [____ /     ) _\      \  \    \| | ||
+\  \  [_____|    / /     __/    \   / / //
+|   \ [_____/   / /        \    |   \/ //
+|   /  '----|   /=\____   _/    |   / //
+__ /  /        |  /   ___/  _/\    \  | ||
+(/-(/-\)       /   \  (/\/\)/  |    /  | /
+(/\/\)           /   /   //
+_________/   /    /
+\____________/    (
+
+
+
+*/
+
+public class Main {
+	public static void main(String[] args) {
+		Scanner sc=new Scanner(System.in);
+		int  t=sc.nextInt();
+		while(t-- >0) {
+			int n=sc.nextInt();
+			int[] arr=new int[n];
+			for(int i=0;i<n;i++) {
+				arr[i]=sc.nextInt();
+			}
+			String str=sc.next();
+			
+			ArrayList<Pair> plist=new ArrayList<>();
+			for(int i=0;i<n;i++) {
+				char ch=str.charAt(i);
+				plist.add(new Pair(arr[i],ch));
+			}
+			
+			//B-reduce
+			//R-increse
+			Collections.sort(plist);
+			
+			int counter=1;
+			boolean flag=false;
+			for(int i=0;i<plist.size();i++) {
+				int val=plist.get(i).number;
+				int clr=plist.get(i).color;
+				
+				if(clr=='B') {
+					if(val<counter) {
+						flag=true;
+						break;
+					}
+				}
+				else {
+					if(val>counter) {
+						flag=true;
+						break;
+					}
+					
+				}
+				counter++;
+			}
+			System.out.println(flag?""NO"":""YES"");
+			
+			
+		}
+	}
+	public static class Pair implements Comparable<Pair>{
+		int number;
+		char color;
+		
+		Pair(int number,char color){
+			this.number=number;
+			this.color=color;
+		}
+		
+		@Override
+		public int compareTo(Pair o) {
+			if(o.color==this.color) {
+				return this.number-o.number;
+			}
+			else {
+				return this.color-o.color;
+			}
+		}
+		
+		public String toString() {
+			return number+""-""+color+""."";
+		}
+	}
+}
+",0
+72d9eb5b,af0deeab,"import java.util.*;
+import java.io.*;
+
+public class D {
+    public static void main(String[] args) {
+        Scanner in = new Scanner(System.in);
+        
+        int T = in.nextInt();
+        while(T-- > 0) {
+            int n = in.nextInt();
+            int[] a = new int[n];
+            for(int j=0;j<n;j++) a[j] = in.nextInt();
+            char[] s = in.next().toCharArray();
+
+            List<Integer> blue = new ArrayList<>();
+            List<Integer> red = new ArrayList<>();
+            for(int j=0;j<n;j++) {
+                if(s[j] == 'B') blue.add(a[j]);
+                else red.add(a[j]);
+            }
+
+            Collections.sort(blue);
+            Collections.sort(red);
+
+            boolean p = true;
+            int cur = 1;
+            for(int val : blue) {
+                if(val<cur) {
+                    p = false;
+                    break;
+                }
+                else cur++;
+            }
+            for(int val : red) {
+                if(val>cur) {
+                    p = false;
+                    break;
+                }
+                else cur++;
+            }
+            
+            if(p) System.out.println(""yes"");
+            else System.out.println(""no"");
+        }
+    }
+}
+","import java.io.*;
+import java.util.*;
+
+public class Solution {
+    static int M = 998244353;
+    static Random rng = new Random();
+
+    private static boolean testCase(int n, int[] a, String colors) {
+        boolean[] contains = new boolean[n];
+        int any = 0, rem = n, idx;
+        List<Integer> fromLeft = new ArrayList<>(), fromRight = new ArrayList<>();
+
+        for (int i = 0; i < n; i++) {
+            if (colors.charAt(i) == 'B') {
+                if (a[i] <= 0) {
+                    return false;
+                } else if (a[i] >= n) {
+                    any++;
+                } else {
+                    fromLeft.add(a[i]);
+                }
+            } else {
+                if (a[i] > n) {
+                    return false;
+                } else if (a[i] <= 1) {
+                    any++;
+                } else {
+                    fromRight.add(a[i]);
+                }
+            }
+        }
+
+        sort(fromLeft);
+        sort(fromRight);
+
+        //System.out.println(fromLeft);
+        //System.out.println(fromRight);
+
+        idx = 1;
+
+        for (int i = 0; i < fromLeft.size(); i++) {
+            //try to assign a[i] to idx
+            //System.out.println(String.format(""Assign %d to %d"", a[i], idx));
+            if (fromLeft.get(i) < idx) {
+                return false;
+            } else {
+                contains[idx - 1] = true;
+                rem--;
+                idx++;
+            }
+        }
+
+        idx = n;
+
+        for (int i = fromRight.size() - 1; i >= 0; i--) {
+            //System.out.println(String.format(""Assign %d to %d"", a[i], idx));
+            if (idx < fromRight.get(i)) {
+                return false;
+            } else {
+                contains[idx - 1] = true;
+                rem--;
+                idx--;
+            }
+        }
+
+        return any >= rem;
+    }
+
+    public static void main(String[] args) {
+        FastScanner in = new FastScanner();
+        PrintWriter out = new PrintWriter(System.out);
+        int t = in.nextInt();  // Scanner has functions to read ints, longs, strings, chars, etc.
+        //in.nextLine();
+        for (int tt = 1; tt <= t; ++tt) {
+            int n = in.nextInt();
+            int[] a = in.readArray(n);
+            String colors = in.next();
+
+            out.println(testCase(n, a, colors) ? ""YES"" : ""NO"");
+        }
+
+        out.close();
+    }
+
+    private static class FastScanner {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st = new StringTokenizer("""");
+        String next() {
+            while (!st.hasMoreTokens())
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            return st.nextToken();
+        }
+
+        boolean hasNext() {
+            return st.hasMoreTokens();
+        }
+
+        char[] readCharArray(int n) {
+            char[] arr = new char[n];
+            try {
+                br.read(arr);
+                br.readLine();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            return arr;
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        int[] readArray(int n) {
+            int[] a = new int[n];
+            for (int i = 0; i < n; i++) a[i] = nextInt();
+            return a;
+        }
+
+        long[] readLongArray(int n) {
+            long[] a = new long[n];
+            for (int i = 0; i < n; i++) a[i] = nextLong();
+            return a;
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+    }
+
+    private static void sort(int[] arr) {
+        int temp, idx;
+
+        for (int i = arr.length - 1; i > 0; i--) {
+            idx = rng.nextInt(i + 1);
+
+            temp = arr[i];
+            arr[i] = arr[idx];
+            arr[idx] = temp;
+        }
+
+        Arrays.sort(arr);
+    }
+
+    private static void sort(long[] arr) {
+        long temp;
+        int idx;
+
+        for (int i = arr.length - 1; i > 0; i--) {
+            idx = rng.nextInt(i + 1);
+
+            temp = arr[i];
+            arr[i] = arr[idx];
+            arr[idx] = temp;
+        }
+
+        Arrays.sort(arr);
+    }
+
+    private static <T> void sort(T[] arr) {
+        T temp;
+        int idx;
+
+        for (int i = arr.length - 1; i > 0; i--) {
+            idx = rng.nextInt(i + 1);
+
+            temp = arr[i];
+            arr[i] = arr[idx];
+            arr[idx] = temp;
+        }
+
+        Arrays.sort(arr);
+    }
+
+    private static <T> void sort(T[] arr, Comparator<? super T> cmp) {
+        T temp;
+        int idx;
+
+        for (int i = arr.length - 1; i > 0; i--) {
+            idx = rng.nextInt(i + 1);
+
+            temp = arr[i];
+            arr[i] = arr[idx];
+            arr[idx] = temp;
+        }
+
+        Arrays.sort(arr, cmp);
+    }
+
+    private static <T extends Comparable<? super T>> void sort(List<T> list) {
+        T temp;
+        int idx;
+
+        for (int i = list.size() - 1; i > 0; i--) {
+            idx = rng.nextInt(i + 1);
+
+            temp = list.get(i);
+            list.set(i, list.get(idx));
+            list.set(idx, temp);
+        }
+
+        Collections.sort(list);
+    }
+
+    private static <T> void sort(List<T> list, Comparator<? super T> cmp) {
+        T temp;
+        int idx;
+
+        for (int i = list.size() - 1; i > 0; i--) {
+            idx = rng.nextInt(i + 1);
+
+            temp = list.get(i);
+            list.set(i, list.get(idx));
+            list.set(idx, temp);
+        }
+
+        Collections.sort(list, cmp);
+    }
+}
+",0
+734a94be,f6ca6fc8,"
+
+import java.io.*;
+import java.math.*;
+import java.util.*;
+
+
+public class test {
+	 
+	   static class Pair{ 
+		   long x;
+		   long y;
+		   
+		   Pair(long x,long y){ 
+			   this.x = x;
+			   this.y = y;
+			   
+		   }
+	   }
+	  
+	   static class Compare { 
+		   
+		     void compare(Pair arr[], int n) 
+		    { 
+		        // Comparator to sort the pair according to second element 
+		        Arrays.sort(arr, new Comparator<Pair>() { 
+		            @Override public int compare(Pair p1, Pair p2) 
+		            { 
+		            	if(p1.x!=p2.x) {
+		                return (int)(p1.x - p2.x); 
+		            	}
+		            	else { 
+		            		return (int)(p1.y - p2.y);
+		            	}
+		            } 
+		        }); 
+		  
+//		        for (int i = 0; i < n; i++) { 
+//		            System.out.print(arr[i].x + "" "" + arr[i].y + "" ""); 
+//		        } 
+//		        System.out.println(); 
+		    } 
+		} 
+	 
+	   static class Scanner {
+	        BufferedReader br;
+	        StringTokenizer st;
+	 
+	        public Scanner()
+	        {
+	            br = new BufferedReader(
+	                new InputStreamReader(System.in));
+	        }
+	 
+	        String next()
+	        {
+	            while (st == null || !st.hasMoreElements()) {
+	                try {
+	                    st = new StringTokenizer(br.readLine());
+	                }
+	                catch (IOException e) {
+	                    e.printStackTrace();
+	                }
+	            }
+	            return st.nextToken();
+	        }
+	 
+	        int nextInt() { return Integer.parseInt(next()); }
+	 
+	        long nextLong() { return Long.parseLong(next()); }
+	 
+	        double nextDouble()
+	        {
+	            return Double.parseDouble(next());
+	        }
+	 
+	        String nextLine()
+	        {
+	            String str = """";
+	            try {
+	                str = br.readLine();
+	            }
+	            catch (IOException e) {
+	                e.printStackTrace();
+	            }
+	            return str;
+	        }
+	    }
+	
+	   static int solve(int dp[][] , ArrayList<Integer> one , ArrayList<Integer> zero , int i,int j)
+	   {
+	       int n=one.size();
+	       int m=zero.size();
+	       
+	       if(i>=n)
+	           return 0;
+	       
+	       else if(j>=m)
+	           return Integer.MAX_VALUE;
+	       
+	       else if(dp[i][j]!=-1)
+	           return dp[i][j];
+	       
+	       int val1 = Math.abs(one.get(i)-zero.get(j))+solve(dp, one ,zero ,i+1,j+1);
+	       int val2 = solve(dp , one , zero , i,j+1);
+	       
+	        dp[i][j]= Math.min(val1,val2);
+	        
+	        return dp[i][j];
+	   }
+	     
+	   public static void main(String args[]) throws Exception { 
+		
+		   Scanner sc = new Scanner();
+		   StringBuffer res = new StringBuffer();
+		   
+		   int tc = 1;
+		   
+		   while(tc-->0) { 
+			
+			    int n = sc.nextInt();
+			    
+			    ArrayList<Integer> one = new ArrayList<>();
+			    ArrayList<Integer> zero = new ArrayList<>();
+			    
+			    for(int i=0;i<n;i++) { 
+			    	
+			    	int x = sc.nextInt();
+			    	
+			    	if(x==1) { 
+			    		one.add(i);
+			    	}
+			    	else { 
+			    		zero.add(i);
+			    	}
+			    }
+			    
+			    int dp[][] = new int[one.size()+1][zero.size()+1];
+			    
+			     for(int i=1;i<=one.size();i++)
+			     {
+			         dp[i][i]=dp[i-1][i-1]+Math.abs(zero.get(i-1)-one.get(i-1));
+			         for(int j=i+1;j<=zero.size();j++)
+			         {
+			             dp[i][j]=Math.min(dp[i][j-1],dp[i-1][j-1]+Math.abs(one.get(i-1)-zero.get(j-1)));
+			         }
+			     }
+			     System.out.println(dp[one.size()][zero.size()]);
+		   }
+			System.out.println(res);
+	   }
+}  
+
+
+
+
+","import java.util.*;
+import java.io.*;
+
+public class D {
+	public static void main(String[] args) {
+		Scanner sc=new Scanner(System.in);
+		int n = sc.nextInt();
+		ArrayList<Integer>  o=new ArrayList<Integer>();
+		ArrayList<Integer>  e=new ArrayList<Integer>();
+		for(int i=1;i<=n;i++){
+			int x=sc.nextInt();
+			if(x==1)o.add(i);
+			else e.add(i);
+		}
+		int dp[][]=new int[o.size()+1][e.size()+1];
+		for(int i=1;i<=o.size();i++){
+			dp[i][i]=dp[i-1][i-1]+Math.abs(o.get(i-1)-e.get(i-1));
+			for(int j=i+1;j<=e.size();j++){
+				dp[i][j]=Math.min(dp[i][j-1],dp[i-1][j-1]+Math.abs(o.get(i-1)-e.get(j-1)));
+			}
+		}
+		System.out.println(dp[o.size()][e.size()]);
+	}
+}
+",1
+5db541bd,5e3089fa,"import java.io.*;
+
+import java.util.*;
+/*
+
+
+
+
+*/
+
+ 
+ public class C{
+	static FastReader sc=null;
+	
+	public static void main(String[] args) {
+		sc=new FastReader();
+		int t=sc.nextInt();
+		
+		for(int tt=0;tt<t;tt++) {
+			int n=sc.nextInt();
+			long k=sc.nextLong();
+			int a[]=sc.readArray(n);
+			ruffleSort(a);
+			
+			long sum=0;
+			for(int e:a)sum+=e;
+			
+			if(sum<=k) {
+				System.out.println(0);
+				continue;
+			}
+			long l=-1,r=sum-k+1;
+			while(l+1<r) {
+				long mid=(l+r)/2;
+				if(pos(mid,k,a,sum))r=mid;
+				else l=mid;
+			}
+			
+			System.out.println(r);
+		}
+	}
+	
+	static boolean pos(long m,long k,int a[],long sum) {
+		int n=a.length;
+		
+		//we set the largest of them to be equal val
+		long min=sum-m,suf=sum-a[0],moves=m;
+		
+		for(int i=n-1;i>0;i--) {
+			moves--;
+			if(moves<0)break;
+			long val=a[0]-moves;
+			suf-=a[i];
+			long tot=suf+val*(n-i+1);
+			min=Math.min(min, tot);
+		}
+		
+		return min<=k;
+	}
+	
+	static int[] ruffleSort(int a[]) {
+		ArrayList<Integer> al=new ArrayList<>();
+		for(int i:a)al.add(i);
+		Collections.sort(al);
+		for(int i=0;i<a.length;i++)a[i]=al.get(i);
+		return a;
+	}
+	
+	static void print(int a[]) {
+		for(int e:a) {
+			System.out.print(e+"" "");
+		}
+		System.out.println();
+	}
+	
+	static class FastReader{
+		
+		StringTokenizer st=new StringTokenizer("""");
+		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+		
+		String next() {
+			while(!st.hasMoreTokens()) 
+				try {
+					st=new StringTokenizer(br.readLine());
+				}
+			   catch(IOException e){
+				   e.printStackTrace();
+			   }
+			return st.nextToken();
+		}
+		
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+		
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+		
+		int[] readArray(int n) {
+			int a[]=new int[n];
+			for(int i=0;i<n;i++)a[i]=sc.nextInt();
+			return a;
+		}
+	}
+	
+	
+}
+","//package Div2.C;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class SetOrDecrease {
+    public static void main(String[] args) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        int t = Integer.parseInt(br.readLine());
+        while(t>0){
+            String []nk=br.readLine().split("" "");
+            int n=Integer.parseInt(nk[0]);
+            long k=Long.parseLong(nk[1]);
+            String []str=br.readLine().split("" "");
+            List<Integer> list=new ArrayList<>();
+            for(int i=0;i<n;i++)
+                list.add(Integer.parseInt(str[i]));
+            Collections.sort(list);
+            long sum=0;
+            for(int i=0;i<n;i++)
+                sum+=list.get(i);
+            if(sum<=k)
+                System.out.println(0);
+            else {
+                long minSteps = sum - k;
+                long drop=0;
+                long targetDrop = sum-k;
+                for (int i = n - 1; i > 0; i--) {
+                    //assignment at ith element
+                    drop += list.get(i) - list.get(0);
+                    if (drop >= targetDrop) {
+                        if (minSteps > n - i)
+                            minSteps = n - i;
+                    } else {
+                        long diff = targetDrop - drop;
+                        long div = diff / (n - i + 1);
+                        long rem = diff % (n - i + 1);
+                        long steps = rem > 0 ? (div + 1) + n - i : div + n - i;
+                        if (minSteps > steps)
+                            minSteps = steps;
+
+                    }
+                }
+                System.out.println(minSteps);
+            }
+            t--;
+        }
+    }
+}
+",0
+b7de5c19,bac616ee,"import java.util.*;
+
+public class Main {
+    public static void main(String[] args) {
+        Scanner scan = new Scanner(System.in);
+        int t = scan.nextInt();
+        for (int i = 0; i < t; i++) {
+            int n = scan.nextInt();
+            ArrayList<ArrayList<Pair>> graph = new ArrayList<>();
+            for (int j = 0; j < n; j++) {
+                graph.add(new ArrayList<>());
+            }
+            for (int j = 0; j < n - 1; j++) {
+                int u;
+                int v;
+                u = scan.nextInt();
+                v = scan.nextInt();
+                u--;
+                v--;
+                graph.get(u).add(new Pair(v, j));
+                graph.get(v).add(new Pair(u, j));
+            }
+            boolean soluble = true;
+            int curV = 0;
+            int prevV = -1;
+            int[] ans = new int[n];
+            int prime = 2;
+            for (int j = 0; j < n; j++) {
+                ArrayList<Pair> list = graph.get(j);
+                if (list.size() > 2) {
+                    soluble = false;
+                } else if (list.size() == 1) {
+                    curV = j;
+                }
+            }
+            if (soluble) {
+                for (int j = 0; j < n - 1; j++) {
+                    ArrayList<Pair> list = graph.get(curV);
+                    for (int z = 0; z < list.size(); z++) {
+                        if (list.get(z).vertex != prevV) {
+                            ans[list.get(z).numberOfEdge] = prime;
+                            prime = changePrime(prime);
+                            prevV = curV;
+                            curV = list.get(z).vertex;
+                            break;
+                        }
+                    }
+                }
+
+                for (int j = 0; j < n - 1; j++) {
+                    System.out.print(ans[j] + "" "");
+                }
+                System.out.println();
+            } else {
+                System.out.println(-1);
+            }
+        }
+    }
+    public static int changePrime(int prime) {
+        if (prime == 2) {
+            prime = 3;
+        } else {
+            prime = 2;
+        }
+        return prime;
+    }
+}
+
+class Pair {
+    int vertex;
+    int numberOfEdge;
+
+    public Pair(int vertex, int numberOfEdge) {
+        this.vertex = vertex;
+        this.numberOfEdge = numberOfEdge;
+    }
+}
+","import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+import java.util.StringTokenizer;
+
+public class NotAssigning {
+	
+	static class FastReader {
+		
+        BufferedReader br;
+        StringTokenizer st;
+ 
+        public FastReader() {
+        	
+            br = new BufferedReader(new InputStreamReader(System.in));
+            
+        }
+ 
+        String next() {
+        	
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                }
+                catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+            
+        }
+ 
+        int nextInt() {
+        	
+        	return Integer.parseInt(next());
+        	
+        }
+ 
+        long nextLong() {
+        	
+        	return Long.parseLong(next());
+        	
+        }
+        
+        double nextFloat() {
+        	
+        	return Float.parseFloat(next());
+        
+        }
+ 
+        double nextDouble() {
+        	
+        	return Double.parseDouble(next());
+        	
+        }
+ 
+        String nextLine() {
+        	
+            String str = """";
+            try {
+                str = br.readLine();
+            }
+            catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+            
+        }
+        
+        int[] nextArray(int n) {
+        	
+        	int[] a = new int[n];
+        	for (int i=0; i<n; i++) {
+        		a[i] = this.nextInt();
+        	}
+        	return a;
+        	
+        }
+        
+        long[] nextArrayLong(int n) {
+        	
+        	long[] a = new long[n];
+        	for (int i=0; i<n; i++) {
+        		a[i] = this.nextLong();
+        	}
+        	return a;
+        	
+        }
+        
+    }
+	
+	static class Pair {
+		
+		int a, b;
+
+		public Pair(int a, int b) {
+			
+			this.a = a;
+			this.b = b;
+			
+		}
+
+	}
+	
+	static boolean vis[];
+	public static void dfs(ArrayList<ArrayList<Pair>> t, int cur, boolean mode, int[] w) {
+		vis[cur] = true;
+		for (Pair p : t.get(cur)) {
+			if (!vis[p.a]) {
+				if (mode) {
+					w[p.b] = 3;
+				}
+				else {
+					w[p.b] = 2;
+				}
+				dfs(t, p.a, !mode, w);
+			}
+		}
+	}
+	
+	public static void solve(int n, int[] u, int[] v) {
+		
+		ArrayList<ArrayList<Pair>> t = new ArrayList<ArrayList<Pair>>(n);
+		for (int i=0; i<n; i++) {
+			t.add(new ArrayList<Pair>());
+		}
+		for (int i=0; i<n-1; i++) {
+			t.get(u[i]).add(new Pair(v[i], i));
+			t.get(v[i]).add(new Pair(u[i], i));
+		}
+		int start = 0;
+		for (int i=0; i<n; i++) {
+			if (t.get(i).size() > 2) {
+				System.out.println(""-1"");
+				return;
+			}
+			if (t.get(i).size() == 1) {
+				start = i;
+			}
+		}
+		vis = new boolean[n];
+		int[] w = new int[n-1];
+		dfs(t, start, false, w);
+		StringBuilder ans = new StringBuilder();
+		for (int i=0; i<n-1; i++) {
+			ans.append(w[i]).append("" "");
+		}
+		System.out.println(ans);
+		
+	}
+
+	public static void main(String[] args) {
+		
+		FastReader in = new FastReader();
+		int t = in.nextInt();
+		while (t-- > 0) {
+			int n = in.nextInt();
+			int[] u = new int[n-1];
+			int[] v = new int[n-1];
+			for (int i=0; i<n-1; i++) {
+				u[i] = in.nextInt()-1;
+				v[i] = in.nextInt()-1;
+			}
+			solve(n, u, v);
+		}
+
+	}
+
+}
+",0
+3d88acb8,8aadde13,"import java.util.*;
+import java.io.*;
+public class D {
+
+	public static void main(String[] args) {
+		FastScanner sc = new FastScanner();
+		int T = sc.nextInt();
+		while(T-->0) {
+			int n = sc.nextInt();
+			int[] arr = new int[n];
+			for(int i = 0; i < n; i++) {
+				arr[i] = sc.nextInt();
+			}
+			if(check(arr)) System.out.println(""YES"");
+			else System.out.println(""NO"");
+		}
+
+	}
+	static boolean check(int[] arr) {
+		int n = arr.length;
+		TreeSet<Integer> set = new TreeSet<>();
+		set.add(arr[0]);
+		for(int i = 1; i < n; i++) {
+			set.add(arr[i]);
+			if(arr[i-1] == arr[i]) continue;
+			Integer x = set.lower(arr[i]);
+			if(x != null && x == arr[i-1]) continue;
+			x = set.higher(arr[i]);
+			if(x != null && x == arr[i-1]) continue;
+			return false;
+		}
+		return true;
+	}
+	
+	static class FastScanner {
+		public BufferedReader reader;
+		public StringTokenizer tokenizer;
+		public FastScanner() {
+			reader = new BufferedReader(new InputStreamReader(System.in), 32768);
+			tokenizer = null;
+		}
+		public String next() {
+			while (tokenizer == null || !tokenizer.hasMoreTokens()) {
+				try {
+					tokenizer = new StringTokenizer(reader.readLine());
+				} catch (IOException e) {
+					throw new RuntimeException(e);
+				}
+			}
+			return tokenizer.nextToken();
+		}
+		public int nextInt() {
+			return Integer.parseInt(next());
+		}
+		public long nextLong() {
+			return Long.parseLong(next());
+		}
+		public double nextDouble() {
+			return Double.parseDouble(next());
+		}
+		public String nextLine() {
+			try {
+				return reader.readLine();
+			} catch(IOException e) {
+				throw new RuntimeException(e);
+			}
+		}
+	}
+
+}
+","import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.util.Scanner;
+import java.util.StringTokenizer;
+import java.util.TreeSet;
+
+public class A {
+    public static void main(String args[]) throws Exception {
+        FastScanner sc = new FastScanner();
+        int T = 1;
+        T = sc.nextInt();
+        PrintWriter pw = new PrintWriter(System.out);
+        while (T-- > 0) {
+            solve(sc, pw);
+        }
+        pw.close();
+    }
+
+    public static void solve(FastScanner sc, PrintWriter pw) throws Exception {
+        int n = sc.nextInt();
+        int[] arr = new int[n];
+        for(int i=0;i<n;i++){
+            arr[i]=sc.nextInt();
+        }
+        if(check(arr)) pw.println(""YES"");
+        else pw.println(""NO"");
+    }
+
+    public static boolean check(int[] arr){
+        int n=arr.length;
+        TreeSet<Integer> S = new TreeSet<>();
+        S.add(arr[0]);
+        for(int i=1;i<n;i++) {
+            S.add(arr[i]);
+            if (arr[i] == arr[i - 1]) continue;
+            Integer lb = S.lower(arr[i]);
+            if (lb != null && lb == arr[i - 1]) continue;
+            Integer ub = S.higher(arr[i]);
+            if (ub != null && ub == arr[i - 1]) continue;
+            return false;
+        }
+        return true;
+    }
+
+    static class FastScanner {
+        public BufferedReader reader;
+        public StringTokenizer tokenizer;
+
+        public FastScanner() {
+            reader = new BufferedReader(new InputStreamReader(System.in), 32768);
+            tokenizer = null;
+        }
+
+        public String next() {
+            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
+                try {
+                    tokenizer = new StringTokenizer(reader.readLine());
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+            }
+            return tokenizer.nextToken();
+        }
+
+        public int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        public long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        public double nextDouble() {
+            return Double.parseDouble(next());
+        }
+
+        public String nextLine() {
+            try {
+                return reader.readLine();
+            } catch (IOException e) {
+                throw new RuntimeException(e);
+            }
+        }
+    }
+}",1
+a3e272af,f7fc2e94,"
+import java.io.*;
+import java.util.*;
+
+public class Asd {
+
+    static PrintWriter w = new PrintWriter(System.out);
+    static FastScanner s = new FastScanner();
+    static boolean sd = false;
+  
+    public static void main(String[] args) {
+
+       int t = s.nextInt();
+        //int t=1;
+        while (t-- > 0) {
+            solve();
+        }
+        w.close();
+
+    }
+  public static class Student {
+    public int i1;
+    public int value;
+          
+    // A parameterized student constructor
+    public Student(int i1,int i2) {
+      
+        this.i1 = i1;
+        this.value=i2;
+    }
+      
+    public int getkey() {
+        return i1;
+    } 
+    public int getValue() {
+        return value;
+    } 
+}
+   static class StudentComparator implements Comparator<Student>{
+              
+            // Overriding compare()method of Comparator 
+                        // for descending order of cgpa
+        @Override   
+        public int compare(Student s1, Student s2) {
+                if (s1.i1 < s2.i1)
+                    return -1;
+                else if (s1.i1 >s2.i1)
+                    return 1;
+                                return 0;
+                }
+        }
+    
+    /* Function to print all the permutations of the string
+     static String swap(String str, int i, int j)
+     {
+     char ch;
+     char[] array = str.toCharArray();
+     ch = array[i];
+     array[i] = array[j];
+     array[j] = ch;
+     return String.valueOf(array);
+     }
+    
+     static void permute(String str,int low,int high)
+     {
+     if(low == high)
+     list.add(Long.parseLong(str));
+ 
+     int i;
+     for(i = low; i<=high; i++){
+     str = swap(str,low,i);
+     permute(str, low+1,high);
+     str = swap(str,low,i);
+     }
+     }
+     use  permute(str2,0,str2.length()-1); to perform combinations
+     */
+
+    public static void solve() {
+        int n=s.nextInt();
+        int m=s.nextInt();
+        int x=s.nextInt();
+        int arr[]=new int[n];int res[]=new int[n];
+        for(int i=0;i<n;i++)
+            arr[i]=s.nextInt();
+        
+        PriorityQueue<Student> pq=new PriorityQueue<Student>(new StudentComparator());
+        for(int i=0;i<m;i++){
+            pq.add(new Student(arr[i],i));res[i]=i;}
+        for(int i=m;i<n;i++)
+        {
+            Student s1=pq.poll();
+            int k2=s1.getkey()+arr[i];
+            int v2=s1.getValue();res[i]=v2;
+            pq.add(new Student(k2,v2));
+        }
+        w.println(""YES"");
+        for(int i=0;i<n;i++)
+            w.print(res[i]+1+"" "");
+        w.println();
+       
+    }
+
+    static void call(ArrayList<Integer> t, ArrayList<Integer> m) {
+        if (t.size() == 0 && m.size() == 0) {
+            sd = true;
+            return;
+        }
+        t.remove(0);
+        t.remove(t.size() - 1);
+        call(t, new ArrayList<Integer>(m.subList(0, m.size() - 1)));
+        call(t, new ArrayList<Integer>(m.subList(1, m.size())));
+    }
+
+    static long gcd(long a, long b) {
+        if (b == 0) {
+            return a;
+        }
+        return gcd(b, a % b);
+    }
+
+    static int noofdivisors(int n) {
+            //it counts no of divisors of every number upto number n
+
+        int arr[] = new int[n + 1];
+        for (int i = 1; i <= (n); i++) {
+            for (int j = i; j <= (n); j = j + i) {
+                arr[j]++;
+            }
+        }
+        return arr[0];
+    }
+
+    static char[] reverse(char arr[]) {
+        char[] b = new char[arr.length];
+        int j = arr.length;
+        for (int i = 0; i < arr.length; i++) {
+            b[j - 1] = arr[i];
+            j = j - 1;
+        }
+        return b;
+    }
+
+    static long factorial(int n) {
+        long su = 1;
+        for (int i = 1; i <= n; i++) {
+            su *= (long) i;
+        }
+        return su;
+    }
+
+    static class FastScanner {
+
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st = new StringTokenizer("""");
+
+        public String next() {
+            while (!st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        long[] readArray(int n) {
+            long[] a = new long[n];
+            for (int i = 0; i < n; i++) {
+                a[i] = nextLong();
+            }
+            return a;
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+    }
+
+}
+","//package Practice;
+import java.io.*;
+import java.util.*;
+public class codefor 
+{
+	static class height implements Comparable<height>
+	{
+		int h,index;
+		height(int hi,int i)
+		{
+			h=hi;
+			index=i;
+		}
+		public int compareTo(height a)
+		{
+			return this.h-a.h;
+		}
+		public String toString()
+		{
+			return ""(""+this.h+"",""+this.index+"") "";
+		}
+	}
+	static class FastReader 
+    { 
+        BufferedReader br; 
+        StringTokenizer st; 
+  
+        public FastReader() 
+        { 
+            br = new BufferedReader(new
+                     InputStreamReader(System.in)); 
+        }
+        String next() 
+        { 
+            while (st == null || !st.hasMoreElements()) 
+            { 
+                try
+                { 
+                    st = new StringTokenizer(br.readLine()); 
+                }
+                catch (IOException  e) 
+                { 
+                    e.printStackTrace(); 
+                } 
+            } 
+            return st.nextToken(); 
+        } 
+  
+        int nextInt() 
+        { 
+            return Integer.parseInt(next()); 
+        } 
+  
+        long nextLong() 
+        { 
+            return Long.parseLong(next()); 
+        } 
+  
+        double nextDouble() 
+        { 
+            return Double.parseDouble(next()); 
+        } 
+  
+        String nextLine() 
+        { 
+            String str = """"; 
+            try
+            { 
+                str = br.readLine(); 
+            } 
+            catch (IOException e) 
+            { 
+                e.printStackTrace(); 
+            } 
+            return str; 
+        } 
+    } 
+	public static void main(String[] args) 
+	{
+		FastReader sc=new FastReader();
+		int T=sc.nextInt();
+		while(T-->0)
+		{
+			int n=sc.nextInt(),m=sc.nextInt(),x=sc.nextInt(),i;
+			ArrayList<height> arr=new ArrayList<>();
+			int ans[]=new int[n];
+			PriorityQueue<height> tower=new PriorityQueue<height>();
+			for(i=0;i<n;i++)
+				arr.add(new height(sc.nextInt(),i));
+			if(n<m)
+				System.out.println(""NO"");
+			else
+			{
+				System.out.println(""YES"");
+			Collections.sort(arr,Collections.reverseOrder());
+			for(i=0;i<m;i++)
+				tower.add(new height(0,i+1));
+			for(i=0;i<n;i++)
+			{
+				//System.out.print(tower);
+				height t=tower.poll();
+				t.h=t.h+arr.get(i).h;
+				//System.out.println("" ""+t);
+				tower.add(t);
+				ans[arr.get(i).index]=t.index;
+			}
+			for(i=0;i<n;i++)
+				System.out.print(ans[i]+"" "");
+			System.out.println();
+			}
+		}
+	}
+}
+
+
+
+
+
+
+
+
+
+
+
+
+",0
+5f3a2a70,e7a997b5,"import java.io.DataInputStream;
+import java.io.IOException;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.util.ArrayList;
+
+public class Main {
+
+    private static Node[] nodes;
+    private static boolean[] visited;
+
+    private static void run() throws IOException {
+        int n = in.nextInt();
+
+        nodes = new Node[n];
+        for (int i = 0; i < n; i++) {
+            nodes[i] = new Node();
+        }
+
+        Edge[] edges = new Edge[n - 1];
+
+        for (int i = 0; i < n - 1; i++) {
+            edges[i] = new Edge();
+            edges[i].id = i;
+            edges[i].u = in.nextInt() - 1;
+            edges[i].v = in.nextInt() - 1;
+
+            nodes[edges[i].u].edge.add(edges[i]);
+            nodes[edges[i].v].edge.add(edges[i]);
+        }
+
+        for (int i = 0; i < n; i++) {
+            if (nodes[i].edge.size() >= 3) {
+                out.println(-1);
+                return;
+            }
+        }
+
+        int end_pos = 0;
+        visited = new boolean[n];
+        while (nodes[end_pos].edge.size() != 1) {
+            end_pos++;
+        }
+
+        visited = new boolean[n];
+        dfs(end_pos, 2);
+
+        for (int i = 0; i < n - 1; i++) {
+            out.print(edges[i].ans);
+            out.print(' ');
+        }
+        out.println();
+    }
+
+    private static void dfs(int now, int d) {
+        visited[now] = true;
+        for (Edge edge : nodes[now].edge) {
+            if (visited[edge.get_next(now)]) {
+                continue;
+            }
+
+            edge.ans = d;
+            dfs(edge.get_next(now), d ^ 1);
+        }
+    }
+
+    private static class Node {
+        ArrayList<Edge> edge = new ArrayList<>();
+    }
+
+    private static class Edge {
+        int id, u, v, ans = -1;
+
+        int get_next(int now) {
+            return now != u ? u : v;
+        }
+    }
+
+    public static void main(String[] args) throws IOException {
+        in = new Reader();
+        out = new PrintWriter(new OutputStreamWriter(System.out));
+
+        int t = in.nextInt();
+        for (int i = 0; i < t; i++) {
+            run();
+        }
+
+        out.flush();
+        in.close();
+        out.close();
+    }
+
+    private static int gcd(int a, int b) {
+        if (a == 0 || b == 0)
+            return 0;
+        while (b != 0) {
+            int tmp;
+            tmp = a % b;
+            a = b;
+            b = tmp;
+        }
+        return a;
+    }
+
+    static final long mod = 1000000007;
+
+    static long pow_mod(long a, long b) {
+        long result = 1;
+        while (b != 0) {
+            if ((b & 1) != 0) result = (result * a) % mod;
+            a = (a * a) % mod;
+            b >>= 1;
+        }
+        return result;
+    }
+
+    private static long add_mod(long... longs) {
+        long ans = 0;
+        for (long now : longs) {
+            ans = (ans + now) % mod;
+            if (ans < 0) ans += mod;
+        }
+        return ans;
+    }
+
+    private static long multiplied_mod(long... longs) {
+        long ans = 1;
+        for (long now : longs) {
+            ans = (ans * now) % mod;
+        }
+        return ans;
+    }
+
+    @SuppressWarnings(""FieldCanBeLocal"")
+    private static Reader in;
+    private static PrintWriter out;
+
+    private static int[] read_int_array(int len) throws IOException {
+        int[] a = new int[len];
+        for (int i = 0; i < len; i++) {
+            a[i] = in.nextInt();
+        }
+        return a;
+    }
+
+    private static long[] read_long_array(int len) throws IOException {
+        long[] a = new long[len];
+        for (int i = 0; i < len; i++) {
+            a[i] = in.nextLong();
+        }
+        return a;
+    }
+
+    private static void print_array(int[] array) {
+        for (int now : array) {
+            out.print(now);
+            out.print(' ');
+        }
+        out.println();
+    }
+
+    private static void print_array(long[] array) {
+        for (long now : array) {
+            out.print(now);
+            out.print(' ');
+        }
+        out.println();
+    }
+
+    static class Reader {
+        private static final int BUFFER_SIZE = 1 << 16;
+        private final DataInputStream din;
+        private final byte[] buffer;
+        private int bufferPointer, bytesRead;
+
+        Reader() {
+            din = new DataInputStream(System.in);
+            buffer = new byte[BUFFER_SIZE];
+            bufferPointer = bytesRead = 0;
+        }
+
+        public String readLine() throws IOException {
+            final byte[] buf = new byte[1024]; // line length
+            int cnt = 0, c;
+            while ((c = read()) != -1) {
+                if (c == '\n') {
+                    break;
+                }
+                buf[cnt++] = (byte) c;
+            }
+            return new String(buf, 0, cnt);
+        }
+
+        public int nextSign() throws IOException {
+            byte c = read();
+            while ('+' != c && '-' != c) {
+                c = read();
+            }
+            return '+' == c ? 0 : 1;
+        }
+
+        private static boolean isSpaceChar(int c) {
+            return !(c >= 33 && c <= 126);
+        }
+
+        public int skip() throws IOException {
+            int b;
+            // noinspection ALL
+            while ((b = read()) != -1 && isSpaceChar(b)) {
+                ;
+            }
+            return b;
+        }
+
+        public char nc() throws IOException {
+            return (char) skip();
+        }
+
+        public String next() throws IOException {
+            int b = skip();
+            final StringBuilder sb = new StringBuilder();
+            while (!isSpaceChar(b)) { // when nextLine, (isSpaceChar(b) && b != ' ')
+                sb.appendCodePoint(b);
+                b = read();
+            }
+            return sb.toString();
+        }
+
+        public int nextInt() throws IOException {
+            int ret = 0;
+            byte c = read();
+            while (c <= ' ') {
+                c = read();
+            }
+            final boolean neg = c == '-';
+            if (neg) {
+                c = read();
+            }
+            do {
+                ret = ret * 10 + c - '0';
+            } while ((c = read()) >= '0' && c <= '9');
+
+            if (neg) {
+                return -ret;
+            }
+            return ret;
+        }
+
+        public long nextLong() throws IOException {
+            long ret = 0;
+            byte c = read();
+            while (c <= ' ') {
+                c = read();
+            }
+            final boolean neg = c == '-';
+            if (neg) {
+                c = read();
+            }
+            do {
+                ret = ret * 10 + c - '0';
+            }
+            while ((c = read()) >= '0' && c <= '9');
+            if (neg) {
+                return -ret;
+            }
+            return ret;
+        }
+
+        public double nextDouble() throws IOException {
+            double ret = 0, div = 1;
+            byte c = read();
+            while (c <= ' ') {
+                c = read();
+            }
+            final boolean neg = c == '-';
+            if (neg) {
+                c = read();
+            }
+
+            do {
+                ret = ret * 10 + c - '0';
+            }
+            while ((c = read()) >= '0' && c <= '9');
+
+            if (c == '.') {
+                while ((c = read()) >= '0' && c <= '9') {
+                    ret += (c - '0') / (div *= 10);
+                }
+            }
+
+            if (neg) {
+                return -ret;
+            }
+            return ret;
+        }
+
+        private void fillBuffer() throws IOException {
+            bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
+            if (bytesRead == -1) {
+                buffer[0] = -1;
+            }
+        }
+
+        private byte read() throws IOException {
+            if (bufferPointer == bytesRead) {
+                fillBuffer();
+            }
+            return buffer[bufferPointer++];
+        }
+
+        public void close() throws IOException {
+            din.close();
+        }
+
+    }
+}","import java.io.*;
+import java.util.*;
+
+public class c {
+
+    public static void main(String[] args){
+
+        FastScanner sc = new FastScanner();
+        int t = sc.nextInt();
+        while(t-- > 0){
+
+            int n = sc.nextInt();
+
+
+            ArrayList<ArrayList<Edge>> graph = new ArrayList<>();
+            for(int i=0; i<n; i++){
+                graph.add(new ArrayList<Edge>());
+            }
+
+            for(int i=0; i<n-1; i++){
+                int u = sc.nextInt();
+                int v = sc.nextInt();
+
+                Edge e = new Edge(u-1, v-1, i+1);
+                Edge e2 = new Edge(v-1, u-1, i+1);
+
+                graph.get(u-1). add(e);
+                graph.get(v-1).add(e2);
+
+            }
+
+            int edges[] = new int[n];
+
+            int indegree1count = 0;
+            int indegree2count = 0;
+            for(ArrayList<Edge> list : graph){
+                if(list.size() == 1){
+                    indegree1count++;
+                }
+                else if(list.size() == 2){
+                    indegree2count++;
+                }
+            }
+
+            if(indegree1count == 2 && indegree1count+indegree2count==n){
+
+                for(int i=0; i<graph.size(); i++){
+                    ArrayList<Edge> list = graph.get(i);
+                    if(list.size() == 1){
+                        dfs(graph, edges, false, -1, i) ;
+                    }
+                }
+
+                for(int i=1; i<edges.length; i++){
+                    System.out.print(edges[i] + "" "");
+                }
+                System.out.println();
+
+            }
+            else{
+                System.out.println(-1);
+            }
+
+
+        }
+
+    }
+
+    public static void dfs(ArrayList<ArrayList<Edge>> graph, int[] edges, boolean isprev2, int parent, int current){
+
+        for(Edge e : graph.get(current)){
+
+            if(e.v == parent){
+                continue;
+            }
+
+            edges[e.id] = isprev2 ? 5 : 2;
+
+            dfs(graph, edges, !isprev2, current, e.v);
+
+        }
+
+    }
+
+}
+
+class Edge {
+
+    int u;
+    int v;
+    int id;
+
+    public Edge(int u, int v, int id) {
+        this.u = u;
+        this.v = v;
+        this.id = id;
+    }
+
+}
+
+class FastScanner
+{
+    //I don't understand how this works lmao
+    private int BS = 1 << 16;
+    private char NC = (char) 0;
+    private byte[] buf = new byte[BS];
+    private int bId = 0, size = 0;
+    private char c = NC;
+    private double cnt = 1;
+    private BufferedInputStream in;
+
+    public FastScanner() {
+        in = new BufferedInputStream(System.in, BS);
+    }
+
+    public FastScanner(String s) {
+        try {
+            in = new BufferedInputStream(new FileInputStream(new File(s)), BS);
+        } catch (Exception e) {
+            in = new BufferedInputStream(System.in, BS);
+        }
+    }
+
+    private char getChar() {
+        while (bId == size) {
+            try {
+                size = in.read(buf);
+            } catch (Exception e) {
+                return NC;
+            }
+            if (size == -1) return NC;
+            bId = 0;
+        }
+        return (char) buf[bId++];
+    }
+
+    public int nextInt() {
+        return (int) nextLong();
+    }
+
+    public int[] nextInts(int N) {
+        int[] res = new int[N];
+        for (int i = 0; i < N; i++) {
+            res[i] = (int) nextLong();
+        }
+        return res;
+    }
+
+    public long[] nextLongs(int N) {
+        long[] res = new long[N];
+        for (int i = 0; i < N; i++) {
+            res[i] = nextLong();
+        }
+        return res;
+    }
+
+    public long nextLong() {
+        cnt = 1;
+        boolean neg = false;
+        if (c == NC) c = getChar();
+        for (; (c < '0' || c > '9'); c = getChar()) {
+            if (c == '-') neg = true;
+        }
+        long res = 0;
+        for (; c >= '0' && c <= '9'; c = getChar()) {
+            res = (res << 3) + (res << 1) + c - '0';
+            cnt *= 10;
+        }
+        return neg ? -res : res;
+    }
+
+    public double nextDouble() {
+        double cur = nextLong();
+        return c != '.' ? cur : cur + nextLong() / cnt;
+    }
+
+    public double[] nextDoubles(int N) {
+        double[] res = new double[N];
+        for (int i = 0; i < N; i++) {
+            res[i] = nextDouble();
+        }
+        return res;
+    }
+
+    public String next() {
+        StringBuilder res = new StringBuilder();
+        while (c <= 32) c = getChar();
+        while (c > 32) {
+            res.append(c);
+            c = getChar();
+        }
+        return res.toString();
+    }
+
+    public String nextLine() {
+        StringBuilder res = new StringBuilder();
+        while (c <= 32) c = getChar();
+        while (c != '\n') {
+            res.append(c);
+            c = getChar();
+        }
+        return res.toString();
+    }
+
+    public boolean hasNext() {
+        if (c > 32) return true;
+        while (true) {
+            c = getChar();
+            if (c == NC) return false;
+            else if (c > 32) return true;
+        }
+    }
+}",0
+00af3420,f4d6d28d,"import java.util.*;
+import java.io.*;
+
+public class Main {
+
+    public static void main(String[] args) throws IOException {
+        Scanner sc = new Scanner(System.in);
+        PrintWriter pw = new PrintWriter(System.out);
+        int t = sc.nextInt();
+        while(t-- > 0){
+            int n = sc.nextInt();
+            String[] s = new String[n];
+            for(int i=0; i<n; i++)
+                s[i] = sc.next();
+            int MAX = 0;
+            for(char c = 'a'; c <= 'e'; c++){
+                PriorityQueue<Integer> pq = new PriorityQueue<>(Collections.reverseOrder()); //Big comes in top;
+                for(int i=0; i<n; ++i) {
+                    int curChar = 0;
+                    int otherChar = 0;
+                    for(int j=0; j<s[i].length(); j++) {
+                        if(s[i].charAt(j) == c)
+                            curChar++;
+                        else
+                            otherChar++;
+                    }
+                    int diff = curChar - otherChar;
+                    pq.add(diff);
+                }
+                int cur = 0;
+                int numberOfWords = 0;
+                while(!pq.isEmpty()){
+                    if(cur + pq.peek() > 0){
+                        cur += pq.poll();
+                        numberOfWords++;
+                    }else{
+                        break;
+                    }
+                }
+                MAX = Math.max(MAX, numberOfWords);
+            }
+            pw.println(MAX);
+        }
+        pw.close();
+    }
+
+    static class Scanner {
+        BufferedReader br;
+        StringTokenizer st;
+
+        public Scanner(InputStream s) {
+            br = new BufferedReader(new InputStreamReader(s));
+        }
+
+        public Scanner(FileReader f) {
+            br = new BufferedReader(f);
+        }
+
+        public String next() throws IOException {
+            while (st == null || !st.hasMoreTokens())
+                st = new StringTokenizer(br.readLine());
+            return st.nextToken();
+        }
+
+        public int nextInt() throws IOException {
+            return Integer.parseInt(next());
+        }
+
+        public long nextLong() throws IOException {
+            return Long.parseLong(next());
+        }
+
+        public double nextDouble() throws IOException {
+            return Double.parseDouble(next());
+        }
+
+        public int[] nextIntArr(int n) throws IOException {
+            int[] arr = new int[n];
+            for (int i = 0; i < n; i++) {
+                arr[i] = Integer.parseInt(next());
+            }
+            return arr;
+        }
+
+    }
+}
+
+","import java.util.*;
+import java.io.*;
+import java.lang.*;
+import static java.lang.Math.*;
+
+public class cp{
+    static BufferedReader br;
+    static StringTokenizer st;
+
+    public static void main(String[] args)throws IOException{
+
+        br = new BufferedReader(new InputStreamReader(System.in));
+        List<Integer> answer = new ArrayList<Integer>();
+
+        for(int t=Integer.parseInt(br.readLine()); t>0; t--){
+            st = readLine();
+            int n = tokenInt();
+
+            String[] words = new String[n];
+            int i=0;
+            while(n-- >0){
+                words[i] = br.readLine();
+                i++;
+            }
+
+            answer.add(new Solver().solve(words));
+        }
+
+        for (int ans : answer ) System.out.println(ans);
+
+    }
+
+    static StringTokenizer readLine() throws IOException { return new StringTokenizer(br.readLine()); }
+    static int tokenInt() { return Integer.parseInt(st.nextToken()); }
+    static long tokenLong(){ return Long.parseLong(st.nextToken()); }
+    static double tokenDouble(){ return Double.parseDouble(st.nextToken()); }
+    static char[] tokenChar(){ return st.nextToken().toCharArray(); }
+    static int[] readIntArray(int n) {
+        int[] a=new int[n];
+        for (int i=0; i<n; i++) a[i]=tokenInt();
+        return a;
+    }
+
+    static int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b);}
+    static int lcm(int a, int b) { return (a * b) / gcd(a,b);}
+
+    static void printArr(int[] arr){
+        for (int i=0; i<arr.length; i++) System.out.print(arr[i] + "" "");
+        System.out.println();
+        return;
+    }
+    static void printArr(char[] arr){
+        for (int i=0; i<arr.length; i++) System.out.print(arr[i] + "" "");
+        System.out.println();
+        return;
+    }
+
+}
+
+
+class Solver{
+    public int solve(String[] words) throws IOException{
+
+        char[] alphabets = {'a', 'b', 'c', 'd', 'e'};
+
+        int[][] arr = new int[5][words.length];
+
+        int i=0;
+        for(String s : words) {
+            char[] wordArr = s.toCharArray();
+            int j=0;
+            for (char alpha : alphabets) {
+                int counter = 0;
+                for(char letter : wordArr){
+                    if(alpha == letter)
+                        counter++;
+                }
+                arr[j][i] = 2*counter - s.length();
+                j++;
+            }
+            i++;
+        }
+
+        int[] ans = new int[5];
+
+        int m=0;
+        for (int[] ar : arr) {
+            Arrays.sort(ar);
+            int val=0;
+            int counter=0;
+            for(i=ar.length-1; i>=0; i--){
+                val += ar[i];
+                if(val>0) counter++;
+                else break;
+            }
+            ans[m] = counter;
+            m++;
+        }
+
+        return Arrays.stream(ans).max().getAsInt();
+    }
+}
+
+/*
+bac
+aaada
+e
+*/
+",0
+29210e56,c4cdd3af,"import java.util.*;
+import java.io.*;
+import java.math.*;
+
+/**
+ *
+ * @Har_Har_Mahadev
+ */
+
+/**
+ * Main , Solution , Remove Public
+ */
+public class A {
+
+	private static long[][] dp;
+	private static ArrayList<Integer> lis1,lis0;
+
+	public static void process() throws IOException {
+
+		int n = sc.nextInt();
+		int arr[] = sc.readArray(n);
+		lis1 = new ArrayList<Integer>();
+		lis0 = new ArrayList<Integer>();
+		for(int i = 0; i<n; i++) {
+			if(arr[i] == 1)lis1.add(i+1);
+			else lis0.add(i+1);
+		}
+		Collections.sort(lis0);
+		Collections.sort(lis1);
+		int n0 = lis0.size();
+		int n1 = lis1.size();
+		dp = new long[n0+1][n1+1];
+		for(int i = 0; i<=n0; i++) {
+			Arrays.fill(dp[i], -1);
+		}
+		long ans = solve(0,0,n0,n1);
+		println(ans);
+		
+
+	}
+
+	private static long solve(int i, int j, int n0, int n1) {
+		if(j == n1)return 0;
+		if(i == n0)return INF;
+		if(dp[i][j] != -1)return dp[i][j];
+		long ans = solve(i+1, j, n0, n1);
+		ans = min(ans,abs(lis0.get(i) - lis1.get(j)) + solve(i+1, j+1, n0, n1));
+		return dp[i][j] = ans;
+	}
+
+	//=============================================================================
+	//--------------------------The End---------------------------------
+	//=============================================================================
+	private static long INF = 2000000000000000000L, M = 1000000007, MM = 998244353;
+	private static int N = 0;
+
+	private static void google(int tt) {
+		System.out.print(""Case #"" + (tt) + "": "");
+	}
+
+	static FastScanner sc;
+	static PrintWriter out;
+
+	public static void main(String[] args) throws IOException {
+		boolean oj = true;
+		if (oj) {
+			sc = new FastScanner();
+			out = new PrintWriter(System.out);
+		} else {
+			sc = new FastScanner(100);
+			out = new PrintWriter(""output.txt"");
+		}
+		int t = 1;
+//		t = sc.nextInt();
+		int TTT = 1;
+		while (t-- > 0) {
+			//			google(TTT++);
+			process();
+		}
+		out.flush();
+		out.close();
+	}
+
+	static class Pair implements Comparable<Pair> {
+		int x, y;
+
+		Pair(int x, int y) {
+			this.x = x;
+			this.y = y;
+		}
+
+		@Override
+		public int compareTo(Pair o) {
+			return Integer.compare(this.x, o.x);
+		}
+
+		//		 @Override
+		//		    public boolean equals(Object o) {
+		//		        if (this == o) return true;
+		//		        if (!(o instanceof Pair)) return false;
+		//		        Pair key = (Pair) o;
+		//		        return x == key.x && y == key.y;
+		//		    }
+		//		 
+		//		    @Override
+		//		    public int hashCode() {
+		//		        int result = x;
+		//		        result = 31 * result + y;
+		//		        return result;
+		//		    }
+	}
+
+	/////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+	static void println(Object o) {
+		out.println(o);
+	}
+
+	static void println() {
+		out.println();
+	}
+
+	static void print(Object o) {
+		out.print(o);
+	}
+
+	static void pflush(Object o) {
+		out.println(o);
+		out.flush();
+	}
+
+	static int ceil(int x, int y) {
+		return (x % y == 0 ? x / y : (x / y + 1));
+	}
+
+	static long ceil(long x, long y) {
+		return (x % y == 0 ? x / y : (x / y + 1));
+	}
+
+	static int max(int x, int y) {
+		return Math.max(x, y);
+	}
+
+	static int min(int x, int y) {
+		return Math.min(x, y);
+	}
+
+	static int abs(int x) {
+		return Math.abs(x);
+	}
+
+	static long abs(long x) {
+		return Math.abs(x);
+	}
+
+	static long sqrt(long z) {
+		long sqz = (long) Math.sqrt(z);
+		while (sqz * 1L * sqz < z) {
+			sqz++;
+		}
+		while (sqz * 1L * sqz > z) {
+			sqz--;
+		}
+		return sqz;
+	}
+
+	static int log2(int N) {
+		int result = (int) (Math.log(N) / Math.log(2));
+		return result;
+	}
+
+	static long max(long x, long y) {
+		return Math.max(x, y);
+	}
+
+	static long min(long x, long y) {
+		return Math.min(x, y);
+	}
+
+	public static int gcd(int a, int b) {
+		BigInteger b1 = BigInteger.valueOf(a);
+		BigInteger b2 = BigInteger.valueOf(b);
+		BigInteger gcd = b1.gcd(b2);
+		return gcd.intValue();
+	}
+
+	public static long gcd(long a, long b) {
+		BigInteger b1 = BigInteger.valueOf(a);
+		BigInteger b2 = BigInteger.valueOf(b);
+		BigInteger gcd = b1.gcd(b2);
+		return gcd.longValue();
+	}
+
+	public static long lcm(long a, long b) {
+		return (a * b) / gcd(a, b);
+	}
+
+	public static int lcm(int a, int b) {
+		return (a * b) / gcd(a, b);
+	}
+
+	public static int lower_bound(int[] arr, int x) {
+		int low = 0, high = arr.length, mid = -1;
+
+		while (low < high) {
+			mid = (low + high) / 2;
+
+			if (arr[mid] >= x)
+				high = mid;
+			else
+				low = mid + 1;
+		}
+
+		return low;
+	}
+
+	public static int upper_bound(int[] arr, int x) {
+		int low = 0, high = arr.length, mid = -1;
+
+		while (low < high) {
+			mid = (low + high) / 2;
+
+			if (arr[mid] > x)
+				high = mid;
+			else
+				low = mid + 1;
+		}
+
+		return low;
+	}
+
+	/////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+	static class FastScanner {
+		BufferedReader br;
+		StringTokenizer st;
+
+		FastScanner() throws FileNotFoundException {
+			br = new BufferedReader(new InputStreamReader(System.in));
+		}
+
+		FastScanner(int a) throws FileNotFoundException {
+			br = new BufferedReader(new FileReader(""input.txt""));
+		}
+
+		String next() throws IOException {
+			while (st == null || !st.hasMoreElements()) {
+				try {
+					st = new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			}
+			return st.nextToken();
+		}
+
+		int nextInt() throws IOException {
+			return Integer.parseInt(next());
+		}
+
+		long nextLong() throws IOException {
+			return Long.parseLong(next());
+		}
+
+		double nextDouble() throws IOException {
+			return Double.parseDouble(next());
+		}
+
+		String nextLine() throws IOException {
+			String str = """";
+			try {
+				str = br.readLine();
+			} catch (IOException e) {
+				e.printStackTrace();
+			}
+			return str;
+		}
+
+		int[] readArray(int n) throws IOException {
+			int[] A = new int[n];
+			for (int i = 0; i != n; i++) {
+				A[i] = sc.nextInt();
+			}
+			return A;
+		}
+
+		long[] readArrayLong(int n) throws IOException {
+			long[] A = new long[n];
+			for (int i = 0; i != n; i++) {
+				A[i] = sc.nextLong();
+			}
+			return A;
+		}
+	}
+
+	static void ruffleSort(int[] a) {
+		Random get = new Random();
+		for (int i = 0; i < a.length; i++) {
+			int r = get.nextInt(a.length);
+			int temp = a[i];
+			a[i] = a[r];
+			a[r] = temp;
+		}
+		Arrays.sort(a);
+	}
+
+	static void ruffleSort(long[] a) {
+		Random get = new Random();
+		for (int i = 0; i < a.length; i++) {
+			int r = get.nextInt(a.length);
+			long temp = a[i];
+			a[i] = a[r];
+			a[r] = temp;
+		}
+		Arrays.sort(a);
+	}
+}
+","// package com.company;
+import java.util.*;
+import java.io.*;
+import java.lang.*;
+public class Main{
+
+    public static void main(String args[]){
+        InputReader in=new InputReader(System.in);
+        TASK solver = new TASK();
+        int t=1;
+//        t = in.nextInt();
+        for(int i=1;i<=t;i++)
+        {
+            solver.solve(in,i);
+        }
+    }
+    static class TASK {
+        static int mod = 1000000007;
+        static long solve(int a[],ArrayList<Integer> al,int i,int j,long dp[][])
+        {
+            if(j<0 || i<0)
+                return Integer.MAX_VALUE;
+            if(i==0 && j==0)
+                return 0;
+            if(j==0)
+                return 0;
+            if(i==0)
+                return Integer.MAX_VALUE;
+            if(dp[i-1][j-1]==-1)
+            {
+                dp[i-1][j-1]=solve(a,al,i-1,j-1,dp);
+            }
+            if(dp[i-1][j]==-1)
+                dp[i-1][j]=solve(a,al,i-1,j,dp);
+            if(a[i-1]==1)
+                return dp[i-1][j];
+            dp[i][j]=Math.min(dp[i-1][j],dp[i-1][j-1]+Math.abs(i-al.get(j-1)));
+            return dp[i][j];
+        }
+        void solve(InputReader in, int testNumber) {
+            int n = in.nextInt();
+            int a[] = new int[n+1];
+            long dp[][] = new long[n+1][n+1];
+            ArrayList<Integer> al = new ArrayList<>();
+            for(int i=0;i<n;i++) {
+                a[i] = in.nextInt();
+                if(a[i]==1)
+                    al.add(i+1);
+                Arrays.fill(dp[i],-1);
+            }
+            Arrays.fill(dp[n],-1);
+            System.out.println(solve(a,al,n,al.size(),dp));
+
+
+
+
+
+
+
+
+
+
+        }
+    }
+
+    static class pair{
+        int x ;
+        int y;
+        pair(int x,int y)
+        {
+            this.x=x;
+            this.y=y;
+        }
+    }
+
+    static class Maths {
+        static long gcd(long a, long b) {
+            if (a == 0)
+                return b;
+            return gcd(b % a, a);
+        }
+        public static long lcm(long a, long b) {
+            return (a * b) / gcd(a, b);
+        }
+        public static long factorial(int n) {
+            long fact = 1;
+            for (int i = 1; i <= n; i++) {
+                fact *= i;
+            }
+            return fact;
+        }
+    }
+    static class InputReader {
+        private InputStream stream;
+        private byte[] buf = new byte[1024];
+        private int curChar;
+        private int numChars;
+        private SpaceCharFilter filter;
+        public InputReader(InputStream stream) {
+            this.stream = stream;
+        }
+        public int read() {
+            if (numChars == -1)
+                throw new InputMismatchException();
+            if (curChar >= numChars) {
+                curChar = 0;
+                try {
+                    numChars = stream.read(buf);
+                } catch (IOException e) {
+                    throw new InputMismatchException();
+                }
+                if (numChars <= 0)
+                    return -1;
+            }
+            return buf[curChar++];
+        }
+        public String nextLine() {
+            BufferedReader br = new BufferedReader(new
+                    InputStreamReader(System.in));
+            String str = """";
+            try {
+                str = br.readLine();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+        }
+        public int nextInt() {
+            int c = read();
+            while (isSpaceChar(c))
+                c = read();
+            int sgn = 1;
+            if (c == '-') {
+                sgn = -1;
+                c = read();
+            }
+            int res = 0;
+            do {
+                if (c < '0' || c > '9')
+                    throw new InputMismatchException();
+                res *= 10;
+                res += c - '0';
+                c = read();
+            }
+            while (!isSpaceChar(c));
+            return res * sgn;
+        }
+        public long nextLong() {
+            int c = read();
+            while (isSpaceChar(c))
+                c = read();
+            int sgn = 1;
+            if (c == '-') {
+                sgn = -1;
+                c = read();
+            }
+            long res = 0;
+            do {
+                if (c < '0' || c > '9')
+                    throw new InputMismatchException();
+                res *= 10;
+                res += c - '0';
+                c = read();
+            }
+            while (!isSpaceChar(c));
+            return res * sgn;
+        }
+        public double nextDouble() {
+            int c = read();
+            while (isSpaceChar(c))
+                c = read();
+            int sgn = 1;
+            if (c == '-') {
+                sgn = -1;
+                c = read();
+            }
+            double res = 0;
+            while (!isSpaceChar(c) && c != '.') {
+                if (c == 'e' || c == 'E')
+                    return res * Math.pow(10, nextInt());
+                if (c < '0' || c > '9')
+                    throw new InputMismatchException();
+                res *= 10;
+                res += c - '0';
+                c = read();
+            }
+            if (c == '.') {
+                c = read();
+                double m = 1;
+                while (!isSpaceChar(c)) {
+                    if (c == 'e' || c == 'E')
+                        return res * Math.pow(10, nextInt());
+                    if (c < '0' || c > '9')
+                        throw new InputMismatchException();
+                    m /= 10;
+                    res += (c - '0') * m;
+                    c = read();
+                }
+            }
+            return res * sgn;
+        }
+        public String readString() {
+            int c = read();
+            while (isSpaceChar(c))
+                c = read();
+            StringBuilder res = new StringBuilder();
+            do {
+                res.appendCodePoint(c);
+                c = read();
+            }
+            while (!isSpaceChar(c));
+            return res.toString();
+        }
+        public boolean isSpaceChar(int c) {
+            if (filter != null)
+                return filter.isSpaceChar(c);
+            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c
+                    == -1;
+        }
+        public String next() {
+            return readString();
+        }
+        public interface SpaceCharFilter {
+            public boolean isSpaceChar(int ch);
+        }
+    }
+}
+",0
+2120328e,464a03b8,"/*****  --->         :)    Vijender  Srivastava      (:       <---       *****/
+import java.util.*;
+import java.lang.*;
+import java.io.*;
+public class Main  
+{
+    static FastReader sc =new FastReader();
+    static PrintWriter out=new PrintWriter(System.out);
+    static int mod=10000007;
+   static StringBuilder sb=new StringBuilder();
+    /* start */
+       public static void main(String [] args)
+    {
+            int t = i();
+            while(t-->0)
+            {
+                int n = i();
+                int a[] = input(n);
+                char c[] = inputC();
+                ArrayList<Integer> b = new ArrayList<>();
+                ArrayList<Integer> r = new ArrayList<>();
+                for(int i=0;i<n;i++)
+                {
+                    if(c[i]=='R')
+                    r.add(a[i]);
+                    else 
+                    b.add(a[i]);
+                }
+                Collections.sort(b);
+                Collections.sort(r,Collections.reverseOrder());
+                boolean is = true;
+                int cnt = 1;
+                for(int i=0;i<b.size();i++)
+                {
+                    if(b.get(i)<cnt)
+                    {
+                        is = false;
+                        break;
+                    }
+                    cnt++;
+                }
+                for(int i=0;i<r.size();i++)
+                {
+                    if(r.get(i)>n-i)
+                    {
+                        is = false;
+                        break;
+                    }
+                }
+
+                out.println(is==true?""YES"":""NO"");
+            }
+            out.close();
+    }
+
+    
+    /* end */
+    static class FastReader 
+    { 
+        BufferedReader br; 
+        StringTokenizer st; 
+
+        public FastReader() 
+        { 
+            br = new BufferedReader(new
+                     InputStreamReader(System.in)); 
+        } 
+
+        String next() 
+        { 
+            while (st == null || !st.hasMoreElements()) 
+            { 
+                try
+                { 
+                    st = new StringTokenizer(br.readLine()); 
+                } 
+                catch (IOException  e) 
+                { 
+                    e.printStackTrace(); 
+                } 
+            } 
+            return st.nextToken(); 
+        } 
+
+        int nextInt() 
+        { 
+            return Integer.parseInt(next()); 
+        } 
+
+        long nextLong() 
+        { 
+            return Long.parseLong(next()); 
+        } 
+
+        double nextDouble() 
+        { 
+            return Double.parseDouble(next()); 
+        } 
+
+        String nextLine() 
+        { 
+            String str = """"; 
+            try
+            { 
+                str = br.readLine(); 
+            } 
+            catch (IOException e) 
+            { 
+                e.printStackTrace(); 
+            } 
+            return str; 
+        } 
+    } 
+
+    
+    static int i() {
+        return sc.nextInt();
+    }
+
+    static String s() {
+        return sc.next();
+    }
+
+    static long l() {
+        return sc.nextLong();
+    }
+
+    static char[] inputC()
+    {
+        String s = sc.nextLine();
+        return s.toCharArray();
+    }
+
+    static int[] input(int n) {
+        int A[]=new int[n];
+           for(int i=0;i<n;i++) {
+               A[i]=sc.nextInt();
+           }
+        return A;
+    }
+
+    static long[] inputL(int n) {
+        long A[]=new long[n];
+           for(int i=0;i<n;i++) {
+               A[i]=sc.nextLong();
+           }
+           return A;
+    }
+
+    static long[] putL(long a[]) {
+        long A[]=new long[a.length];
+           for(int i=0;i<a.length;i++) {
+               A[i]=a[i];
+           }
+           return A;
+    }
+
+    static String[] inputS(int n) {
+        String A[]=new String[n];
+           for(int i=0;i<n;i++) {
+               A[i]=sc.next();
+           }
+           return A;
+    }
+      
+    static int gcd(int a, int b) 
+     { 
+         if (a == 0) 
+             return b; 
+         return gcd(b % a, a); 
+     } 
+
+     static long gcd(long a, long b) 
+     { 
+         if (a == 0) 
+             return b; 
+         return gcd(b % a, a); 
+     } 
+
+     
+    
+     static String reverse(String s) {
+        StringBuffer p=new StringBuffer(s);
+        p.reverse();
+        return p.toString();
+     }
+
+     static int min(int a,int b) {
+        return Math.min(a, b);
+    }
+    static int min(int a,int b,int c) {
+        return Math.min(a, Math.min(b, c));
+    }
+    static int min(int a,int b,int c,int d) {
+        return Math.min(a, Math.min(b, Math.min(c, d)));
+    }
+
+    static int max(int a,int b) {
+        return Math.max(a, b);
+    }
+    static int max(int a,int b,int c) {
+        return Math.max(a, Math.max(b, c));
+    }
+    static int max(int a,int b,int c,int d) {
+        return Math.max(a, Math.max(b, Math.max(c, d)));
+    }
+    static long min(long a,long b) {
+        return Math.min(a, b);
+    }
+    static long min(long a,long b,long c) {
+        return Math.min(a, Math.min(b, c));
+    }
+    static long min(long a,long b,long c,long d) {
+        return Math.min(a, Math.min(b, Math.min(c, d)));
+    }
+    static long max(long a,long b) {
+        return Math.max(a, b);
+    }
+    static long max(long a,long b,long c) {
+        return Math.max(a, Math.max(b, c));
+    }
+    static long max(long a,long b,long c,long d) {
+        return Math.max(a, Math.max(b, Math.max(c, d)));
+    }
+
+    static long sum(int A[]) {
+        long sum=0;
+        for(int i : A) {
+            sum+=i;
+        }
+        return sum;
+    }
+
+    static long sum(long A[]) {
+        long sum=0;
+        for(long i : A) {
+            sum+=i;
+        }
+        return sum;
+    }
+
+    static void print(int A[]) {
+        for(int i : A) {
+            System.out.print(i+"" "");
+        }
+        System.out.println();
+    }
+
+    static void print(long A[]) {
+        for(long i : A) {
+            System.out.print(i+"" "");
+        }
+        System.out.println();
+    }
+
+    static long mod(long x) {
+          return ((x%mod + mod)%mod);
+    }
+
+    static long power(long x, long y)
+    {
+
+	if(y==0)
+		return 1;
+	if(x==0)
+		return 0;
+    long res = 1;
+    while (y > 0) {
+
+        if (y % 2 == 1)
+            res = (res * x) ;
+
+        y = y >> 1; 
+        x = (x * x);
+    }
+
+    return res;
+    }
+
+    static boolean prime(int n) 
+	    { 
+	        if (n <= 1) 
+	            return false; 
+	        if (n <= 3) 
+	            return true; 
+	        if (n % 2 == 0 || n % 3 == 0) 
+	            return false; 
+	        double sq=Math.sqrt(n);
+	  
+	        for (int i = 5; i <= sq; i = i + 6) 
+	            if (n % i == 0 || n % (i + 2) == 0) 
+	                return false; 
+	        return true; 
+	    } 
+
+     static boolean prime(long n) 
+	    { 
+	        if (n <= 1) 
+	            return false; 
+	        if (n <= 3) 
+	            return true; 
+	        if (n % 2 == 0 || n % 3 == 0) 
+	            return false; 
+	        double sq=Math.sqrt(n);
+	  
+	        for (int i = 5; i <= sq; i = i + 6) 
+	            if (n % i == 0 || n % (i + 2) == 0) 
+	                return false; 
+	        return true; 
+	    } 
+        //pair class
+        private static class Pair implements Comparable<Pair> {
+            int first, second;
+            public Pair(int f, int s) {
+                first = f;
+                second = s;
+            }
+            @Override
+            public int compareTo(Pair p) {
+                if (first > p.first)
+                    return 1;
+                else if (first < p.first)
+                    return -1;
+                else {
+                    if (second > p.second)
+                        return 1;
+                    else if (second < p.second)
+                        return -1;
+                    else
+                        return 0;
+                }
+            }
+     
+        }
+}","import java.util.*;
+
+public class Soltion{
+ 
+     public static void main(String []args){
+        Scanner sc = new Scanner(System.in);
+        int t = sc.nextInt();
+        
+        while(t-->0){
+            int n = sc.nextInt();
+            Integer[] arr = new Integer[n];
+            for(int i=0;i<n;i++){
+                arr[i] = sc.nextInt();
+            }
+            String s = sc.next();
+            
+            List<Integer> blue = new ArrayList<>();
+            List<Integer> red = new ArrayList<>();
+            
+            for(int i=0;i<s.length();i++){
+                if(s.charAt(i)=='B'){
+                    blue.add(arr[i]);
+                }
+                else{
+                    red.add(arr[i]);
+                }
+            }
+            
+            Collections.sort(blue);
+            Collections.sort(red);
+            int p=1,q=n;
+            
+            boolean flag = true;
+            for(int i=red.size()-1;i>=0;i--){
+                if(red.get(i)>q){
+                    flag = false;
+                    break;
+                }
+                q--;
+            }
+            
+            for(int i=0;i<blue.size();i++){
+                if(blue.get(i)<p){
+                    flag = false;
+                    break;
+                }
+                p++;
+            }
+            
+            System.out.println(flag? ""Yes"" : ""No"");
+        }
+     }
+}
+",1
+6f02c6d9,d3a96420,"
+import java.io.*;
+import java.util.*;
+
+public class Main {
+
+
+    static long mod = 1000000007;
+
+    static long inv(long a, long b) {
+        return 1 < a ? b - inv(b % a, a) * b / a : 1;
+    }
+
+    static long mi(long a) {
+        return inv(a, mod);
+    }
+
+    static InputReader sc = new InputReader(System.in);
+    static PrintWriter out = new PrintWriter(System.out);
+
+    public static void main(String[] args) throws IOException {
+
+        int t = sc.nextInt();
+        while (t-- > 0) {
+
+            int n = sc.nextInt();
+            int[] A = new int[n];
+
+            for (int i = 0; i < A.length; i++) {
+                A[i] = sc.nextInt();
+            }
+            String word = sc.next();
+            ArrayList<Integer> blue = new ArrayList<>();
+            ArrayList<Integer> red = new ArrayList<>();
+
+            for (int i = 0; i < word.length(); i++) {
+                if (word.charAt(i) == 'R') {
+                    red.add(A[i]);
+                } else {
+                    blue.add(A[i]);
+                }
+            }
+            Collections.sort(blue);
+            Collections.sort(red);
+
+            boolean possible = true;
+
+            int a = 1;
+            for (int i = 0; i < blue.size(); i++, a++) {
+                if (blue.get(i) < a) {
+                    possible = false;
+                    break;
+                }
+            }
+
+            for (int i = 0; i < red.size(); i++, a++) {
+                if (red.get(i) > a) {
+                    possible = false;
+                    break;
+                }
+            }
+
+            if (possible) out.println(""YES"");
+            else out.println(""NO"");
+
+
+        }
+        out.flush();
+        out.close();
+    }
+
+    static class InputReader {
+        BufferedReader reader;
+        StringTokenizer tokenizer;
+
+        public InputReader(InputStream stream) {
+            reader = new BufferedReader(new InputStreamReader(stream), 32768);
+            tokenizer = null;
+        }
+
+
+        String next() {
+            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
+                try {
+                    tokenizer = new StringTokenizer(reader.readLine());
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+            }
+            return tokenizer.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+
+        String nextLine() {
+            String str = """";
+            try {
+                str = reader.readLine();
+            } catch (IOException e) {
+                throw new RuntimeException(e);
+            }
+            return str;
+        }
+    }
+
+    public static void shuffle(int[] a) {
+        Random get = new Random();
+        for (int i = 0; i < a.length; i++) {
+            int r = get.nextInt(a.length);
+            int temp = a[i];
+            a[i] = a[r];
+            a[r] = temp;
+        }
+    }
+
+    public static void shuffle(long[] a) {
+        Random get = new Random();
+        for (int i = 0; i < a.length; i++) {
+            int r = get.nextInt(a.length);
+            long temp = a[i];
+            a[i] = a[r];
+            a[r] = temp;
+        }
+    }
+
+}
+","import java.util.*;
+
+public class Main {
+  public static void main(String[] args) {
+    Scanner sc= new Scanner(System.in);
+    int t=sc.nextInt();
+    while(t-->0){
+      int n=sc.nextInt();
+      int[] a=new int[n];
+      for(int i=0;i<n;i++)a[i]=sc.nextInt();
+      String x=sc.next();
+      Vector<Integer> R=new Vector<>();
+      Vector<Integer> B=new Vector<>();
+      for(int i=0;i<n;i++){
+        if(x.charAt(i)=='B') R.add(a[i]);
+        else B.add(a[i]);
+      }
+      Collections.sort(R);
+      Collections.sort(B);
+      boolean yes=true;
+      for(int i=0;i<R.size();i++){
+        if(R.get(i)-i<1){System.out.println(""NO"");yes=false;break;}
+      }
+      if(yes)
+        {
+          int s=B.size();
+          for(int j=0;j<s;j++){
+            if(B.get(j)+s-j>n+1){System.out.println(""NO"");yes=false;break;}
+          }
+        }
+        if(yes)System.out.println(""YES"");
+    }
+    sc.close();
+  }
+}
+",0
+ac144188,e899614e,"import java.util.*;
+import java.io.*;
+import static java.lang.Math.min;
+import static java.lang.Math.abs;
+import static java.lang.Math.max;
+public class EdB {
+	static long[] mods = {1000000007, 998244353, 1000000009};
+	static long mod = mods[0];
+	public static MyScanner sc;
+    public static PrintWriter out;
+	public static void main(String[] largewang) throws Exception{
+		// TODO Auto-generated method stub
+ 		sc = new MyScanner();
+ 		out = new PrintWriter(System.out);
+ 		int t = sc.nextInt();
+ 		while (t-->0) {
+ 			int n = sc.nextInt();
+ 			Set<Long> sums = new HashSet<>();
+ 			boolean found = false;
+ 			int[] arr = readArrayInt(n);
+ 			for(int j = 0;j<n;j++){
+ 				if (arr[j] == 0)
+ 					found = true;
+ 			}
+ 			for(int j = 1;j<(1<<n);j++){
+ 				long sum = 0;
+ 				for(int k = 0;k<n;k++){
+ 					if (((1<<k)&j) != 0) {
+ 						sum += (long)abs(arr[k]);
+ 					}
+ 				}
+ 				if (sums.contains(sum)) {
+ 					found = true;
+ 					break;
+ 				} else {
+ 					sums.add(sum);
+ 				}
+ 			}
+ 			verdict(found);
+ 		}
+ 		out.close();
+ 		
+ 	}
+	
+	public static void sort(int[] array){
+		ArrayList<Integer> copy = new ArrayList<>();
+		for (int i : array)
+			copy.add(i);
+		Collections.sort(copy);
+		for(int i = 0;i<array.length;i++)
+			array[i] = copy.get(i);
+	}
+	static String[] readArrayString(int n){
+		String[] array = new String[n];
+		for(int j =0 ;j<n;j++)
+			array[j] = sc.next();
+		return array;
+	}
+	static int[] readArrayInt(int n){
+    	int[] array = new int[n];
+    	for(int j = 0;j<n;j++)
+    		array[j] = sc.nextInt();
+    	return array;
+    }
+	static int[] readArrayInt1(int n){
+		int[] array = new int[n+1];
+		for(int j = 1;j<=n;j++){
+			array[j] = sc.nextInt();
+		}
+		return array;
+	}
+	static long[] readArrayLong(int n){
+		long[] array = new long[n];
+		for(int j =0 ;j<n;j++)
+			array[j] = sc.nextLong();
+		return array;
+	}
+	static double[] readArrayDouble(int n){
+		double[] array = new double[n];
+		for(int j =0 ;j<n;j++)
+			array[j] = sc.nextDouble();
+		return array;
+	}
+	static int minIndex(int[] array){
+		int minValue = Integer.MAX_VALUE;
+		int minIndex = -1;
+		for(int j = 0;j<array.length;j++){
+			if (array[j] < minValue){
+				minValue = array[j];
+				minIndex = j;
+			}
+		}
+		return minIndex;
+	}
+	static int minIndex(long[] array){
+		long minValue = Long.MAX_VALUE;
+		int minIndex = -1;
+		for(int j = 0;j<array.length;j++){
+			if (array[j] < minValue){
+				minValue = array[j];
+				minIndex = j;
+			}
+		}
+		return minIndex;
+	}
+	static int minIndex(double[] array){
+		double minValue = Double.MAX_VALUE;
+		int minIndex = -1;
+		for(int j = 0;j<array.length;j++){
+			if (array[j] < minValue){
+				minValue = array[j];
+				minIndex = j;
+			}
+		}
+		return minIndex;
+	}
+	static long power(long x, long y){
+		if (y == 0)
+			return 1;
+		if (y%2 == 1)
+			return (x*power(x, y-1))%mod;
+		return power((x*x)%mod, y/2)%mod;
+	}
+	static void verdict(boolean a){
+        out.println(a ? ""YES"" : ""NO"");
+    }
+    public static class MyScanner {
+        BufferedReader br;
+        StringTokenizer st;
+        public MyScanner() {
+            br = new BufferedReader(new InputStreamReader(System.in));
+        }
+        String next() {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } 
+                catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+        String nextLine() {
+            String str = """";
+            try{
+                str = br.readLine();
+            } 
+            catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+        }
+        
+    }	
+}
+
+//StringJoiner sj = new StringJoiner("" ""); 
+//sj.add(strings)
+//sj.toString() gives string of those stuff w spaces or whatever that sequence is","import java.util.*;
+import java.io.*;
+import static java.lang.Math.min;
+import static java.lang.Math.abs;
+import static java.lang.Math.max;
+public class EdB {
+	static long[] mods = {1000000007, 998244353, 1000000009};
+	static long mod = mods[0];
+	public static MyScanner sc;
+    public static PrintWriter out;
+	public static void main(String[] largewang) throws Exception{
+		// TODO Auto-generated method stub
+ 		sc = new MyScanner();
+ 		out = new PrintWriter(System.out);
+ 		int t = sc.nextInt();
+ 		while (t-->0) {
+ 			int n = sc.nextInt();
+ 			Set<Long> sums = new HashSet<>();
+ 			boolean found = false;
+ 			int[] arr = readArrayInt(n);
+ 			for(int j = 0;j<n;j++){
+ 				if (arr[j] == 0)
+ 					found = true;
+ 			}
+ 			for(int j = 1;j<(1<<n);j++){
+ 				long sum = 0;
+ 				for(int k = 0;k<n;k++){
+ 					if (((1<<k)&j) != 0) {
+ 						sum += (long)abs(arr[k]);
+ 					}
+ 				}
+ 				if (sums.contains(sum)) {
+ 					found = true;
+ 					break;
+ 				} else {
+ 					sums.add(sum);
+ 				}
+ 			}
+ 			verdict(found);
+ 		}
+ 		out.close();
+ 		
+ 	}
+	
+	public static void sort(int[] array){
+		ArrayList<Integer> copy = new ArrayList<>();
+		for (int i : array)
+			copy.add(i);
+		Collections.sort(copy);
+		for(int i = 0;i<array.length;i++)
+			array[i] = copy.get(i);
+	}
+	static String[] readArrayString(int n){
+		String[] array = new String[n];
+		for(int j =0 ;j<n;j++)
+			array[j] = sc.next();
+		return array;
+	}
+	static int[] readArrayInt(int n){
+    	int[] array = new int[n];
+    	for(int j = 0;j<n;j++)
+    		array[j] = sc.nextInt();
+    	return array;
+    }
+	static int[] readArrayInt1(int n){
+		int[] array = new int[n+1];
+		for(int j = 1;j<=n;j++){
+			array[j] = sc.nextInt();
+		}
+		return array;
+	}
+	static long[] readArrayLong(int n){
+		long[] array = new long[n];
+		for(int j =0 ;j<n;j++)
+			array[j] = sc.nextLong();
+		return array;
+	}
+	static double[] readArrayDouble(int n){
+		double[] array = new double[n];
+		for(int j =0 ;j<n;j++)
+			array[j] = sc.nextDouble();
+		return array;
+	}
+	static int minIndex(int[] array){
+		int minValue = Integer.MAX_VALUE;
+		int minIndex = -1;
+		for(int j = 0;j<array.length;j++){
+			if (array[j] < minValue){
+				minValue = array[j];
+				minIndex = j;
+			}
+		}
+		return minIndex;
+	}
+	static int minIndex(long[] array){
+		long minValue = Long.MAX_VALUE;
+		int minIndex = -1;
+		for(int j = 0;j<array.length;j++){
+			if (array[j] < minValue){
+				minValue = array[j];
+				minIndex = j;
+			}
+		}
+		return minIndex;
+	}
+	static int minIndex(double[] array){
+		double minValue = Double.MAX_VALUE;
+		int minIndex = -1;
+		for(int j = 0;j<array.length;j++){
+			if (array[j] < minValue){
+				minValue = array[j];
+				minIndex = j;
+			}
+		}
+		return minIndex;
+	}
+	static long power(long x, long y){
+		if (y == 0)
+			return 1;
+		if (y%2 == 1)
+			return (x*power(x, y-1))%mod;
+		return power((x*x)%mod, y/2)%mod;
+	}
+	static void verdict(boolean a){
+        out.println(a ? ""YES"" : ""NO"");
+    }
+    public static class MyScanner {
+        BufferedReader br;
+        StringTokenizer st;
+        public MyScanner() {
+            br = new BufferedReader(new InputStreamReader(System.in));
+        }
+        String next() {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } 
+                catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+        String nextLine() {
+            String str = """";
+            try{
+                str = br.readLine();
+            } 
+            catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+        }
+        
+    }	
+}
+
+//StringJoiner sj = new StringJoiner("" ""); 
+//sj.add(strings)
+//sj.toString() gives string of those stuff w spaces or whatever that sequence is",1
+0017d438,ac180326,"import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.util.*;
+
+public class A {
+    static List<Integer> [] adj;
+    static ArrayList<Integer> temp;
+    static int mod = (int) 1e9+7;
+    static boolean[] vis = new boolean[(int)1e5];
+    static List<Integer> l = new ArrayList<>();
+    static final Reader s = new Reader();
+
+    public static void main(String[] args) throws IOException {
+        int t = s.nextInt();
+//        int t=1;
+       while(t-->0) {
+           int n = s.nextInt();
+           int m = s.nextInt();
+           int d = s.nextInt();
+           System.out.println(""YES"");
+           PriorityQueue<Pair> pq = new PriorityQueue<>();
+            for(int i=1;i<=m;i++){
+               pq.add(new Pair(i));
+            }
+            for(int i=0;i<n;i++){
+                int v = s.nextInt();
+                Pair p = pq.poll();
+                p.sum+=v;
+                pq.add(p);
+                System.out.print(p.id+"" "");
+            }
+           System.out.println();
+       }
+    }
+    static class Pair implements Comparable<Pair> {
+        int id;
+        long sum=0;
+        public Pair(int id) {
+            this.id=id;
+        }
+        public int compareTo(Pair o) {
+            return Long.compare(sum, o.sum);
+        }
+    }
+    //Important
+    //Dont't stick on same approach
+    //Check long
+    static void dfs(int i){
+        vis[i]=true;
+        l.add(i);
+        List<Integer> Y = adj[i];
+        for(int x:Y){
+            if(!vis[x])dfs(x);
+        }
+    }
+
+    static long gcd(long a, long b) throws IOException {
+        return (b == 0) ? a : gcd(b, a % b);
+    }
+
+    static int gcd(int a, int b) throws IOException {
+        return (b == 0) ? a : gcd(b, a % b);
+    }
+
+    static void sortr(int[] a) {
+        ArrayList<Integer> l = new ArrayList<>();
+        for (int i : a)
+            l.add(i);
+        Collections.sort(l, Collections.reverseOrder());
+        for (int i = 0; i < a.length; i++)
+            a[i] = l.get(i);
+    }
+
+    static void sort(int[] a) {
+        ArrayList<Integer> l = new ArrayList<>();
+        for (int i : a)
+            l.add(i);
+        Collections.sort(l);
+        for (int i = 0; i < a.length; i++)
+            a[i] = l.get(i);
+    }
+
+    static void sort(long[] a) {
+        ArrayList<Long> l = new ArrayList<>();
+        for (long i : a)
+            l.add(i);
+        Collections.sort(l);
+        for (int i = 0; i < a.length; i++)
+            a[i] = l.get(i);
+    }
+
+    static class Reader {
+        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st;
+        String next() {
+            while(st==null||!st.hasMoreTokens()) {
+                try {
+                    st=new StringTokenizer(in.readLine());
+                } catch(Exception e) {}
+            }
+            return st.nextToken();
+        }
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+    }
+
+}","//This code is written by प्रविण शंखपाळ 
+
+//package wizard;
+
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.text.DecimalFormat;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.Arrays;
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.Stack;
+import java.util.Queue;
+import java.util.PriorityQueue;
+import java.util.List;
+import java.util.HashSet;
+import java.util.LinkedHashSet;
+import java.util.TreeSet;
+import java.util.Map;
+import java.util.HashMap;
+import java.util.Scanner;
+import java.util.Set;
+import java.util.StringTokenizer;
+import java.util.Vector;
+
+public class Dobby {
+
+	public static void main(String[] args) {
+
+		try {
+
+			FastReader fr = new FastReader();
+			PrintWriter pt = new PrintWriter(System.out);
+
+			int t = fr.nextInt();
+
+			while (t > 0) {
+
+				int n = fr.nextInt(), m = fr.nextInt(), x = fr.nextInt();
+
+				ArrayList<Pair> pp = new ArrayList<>();
+
+				int A[] = new int[n];
+
+				for (int i = 0; i < n; i++) {
+					A[i] = fr.nextInt();
+					Pair pr = new Pair(A[i], i);
+					pp.add(pr);
+				}
+
+				Collections.sort(pp);
+				Collections.reverse(pp);
+
+				int ps[] = new int[n];
+				int pk[] = new int[n];
+				Arrays.fill(ps, 0);
+				Arrays.fill(pk, 0);
+
+				int index = 0;
+
+				for (int i = 0; i < n; i++) {
+
+					if (pk[index] < x) {
+						pk[index] += pp.get(i).a;
+					}
+					ps[pp.get(i).b] = index + 1;
+					index++;
+
+					index = index == m ? 0 : index;
+
+				}
+
+				pt.println(""YES"");
+
+				for (int i = 0; i < n; i++) {
+					pt.print(ps[i] + "" "");
+				}
+				pt.println();
+
+				t--;
+			}
+
+			pt.close();
+
+		} catch (
+
+		Exception e) {
+			return;
+		}
+	}
+
+	static void merge(long arr[], int l, int m, int r) {
+
+		int n1 = m - l + 1;
+		int n2 = r - m;
+
+		long L[] = new long[n1];
+		long R[] = new long[n2];
+
+		for (int i = 0; i < n1; ++i)
+			L[i] = arr[l + i];
+		for (int j = 0; j < n2; ++j)
+			R[j] = arr[m + 1 + j];
+
+		int i = 0, j = 0;
+
+		int k = l;
+		while (i < n1 && j < n2) {
+			if (L[i] <= R[j]) {
+				arr[k] = L[i];
+				i++;
+			} else {
+				arr[k] = R[j];
+				j++;
+			}
+			k++;
+		}
+
+		while (i < n1) {
+			arr[k] = L[i];
+			i++;
+			k++;
+		}
+
+		while (j < n2) {
+			arr[k] = R[j];
+			j++;
+			k++;
+		}
+	}
+
+	static void sort(long arr[], int l, int r) {
+		if (l < r) {
+
+			int m = l + (r - l) / 2;
+
+			sort(arr, l, m);
+			sort(arr, m + 1, r);
+
+			merge(arr, l, m, r);
+		}
+	}
+
+	static class Pair implements Comparable<Pair> {
+		int a, b;
+
+		Pair(int a, int b) {
+			this.a = a;
+			this.b = b;
+		}
+
+		public int compareTo(Pair o) {
+			// TODO Auto-generated method stub
+			if (this.a != o.a)
+				return Integer.compare(this.a, o.a);
+			else
+				return Integer.compare(this.b, o.b);
+			// return 0;
+		}
+
+		public boolean equals(Object o) {
+			if (o instanceof Pair) {
+				Pair p = (Pair) o;
+				return p.a == a && p.b == b;
+			}
+			return false;
+		}
+
+	}
+
+	static int binarySearch(int arr[], int first, int last, int key) {
+		int mid = (first + last) / 2;
+		while (first <= last) {
+			if (arr[mid] < key) {
+				first = mid + 1;
+			} else if (arr[mid] == key) {
+				return mid;
+			} else {
+				last = mid - 1;
+			}
+			mid = (first + last) / 2;
+		}
+		return -1;
+	}
+
+	static class FastReader {
+		BufferedReader br;
+		StringTokenizer st;
+
+		public FastReader() {
+			br = new BufferedReader(new InputStreamReader(System.in));
+		}
+
+		String next() {
+			while (st == null || !st.hasMoreElements()) {
+				try {
+					st = new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			}
+			return st.nextToken();
+		}
+
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+
+		double nextDouble() {
+			return Double.parseDouble(next());
+		}
+
+		String nextLine() {
+			String str = """";
+			try {
+				str = br.readLine();
+			} catch (IOException e) {
+				e.printStackTrace();
+			}
+			return str;
+		}
+	}
+}
+",0
+34cd5b66,d6af96bd,"import java.io.*;
+import java.util.*;
+
+public class C {
+    static class FastReader {
+        BufferedReader br;
+        StringTokenizer st;
+
+        public FastReader() {
+            br = new BufferedReader(new
+                    InputStreamReader(System.in));
+        }
+
+        String next() {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+
+        String nextLine() {
+            String str = """";
+            try {
+                str = br.readLine();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+        }
+    }
+
+    static FastReader s = new FastReader();
+    static PrintWriter out = new PrintWriter(System.out);
+
+    private static int[] rai(int n) {
+        int[] arr = new int[n];
+        for (int i = 0; i < n; i++) {
+            arr[i] = s.nextInt();
+        }
+        return arr;
+    }
+
+    private static int[][] rai(int n, int m) {
+        int[][] arr = new int[n][m];
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < m; j++) {
+                arr[i][j] = s.nextInt();
+            }
+        }
+        return arr;
+    }
+
+    private static long[] ral(int n) {
+        long[] arr = new long[n];
+        for (int i = 0; i < n; i++) {
+            arr[i] = s.nextLong();
+        }
+        return arr;
+    }
+
+    private static long[][] ral(int n, int m) {
+        long[][] arr = new long[n][m];
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < m; j++) {
+                arr[i][j] = s.nextLong();
+            }
+        }
+        return arr;
+    }
+
+    private static int ri() {
+        return s.nextInt();
+    }
+
+    private static long rl() {
+        return s.nextLong();
+    }
+
+    private static String rs() {
+        return s.next();
+    }
+
+    static int gcd(int a,int b)
+    {
+        if(b==0)
+        {
+            return a;
+        }
+        return gcd(b,a%b);
+    }
+
+    static boolean isPrime(int n) {
+        //check if n is a multiple of 2
+        if (n % 2 == 0) return false;
+        //if not, then just check the odds
+        for (int i = 3; i <= Math.sqrt(n); i += 2) {
+            if (n % i == 0)
+                return false;
+        }
+        return true;
+    }
+    static int MOD=1000000007;
+
+
+
+    public static HashMap<Long,Integer> primeFactors(long n)
+    {
+        // Print the number of 2s that divide n
+        HashMap<Long,Integer> map=new HashMap<>();
+
+        while (n % 2 == 0) {
+            map.put(2L,map.getOrDefault(2L,0)+1);
+            n /= 2;
+        }
+
+        // n must be odd at this point.  So we can
+        // skip one element (Note i = i +2)
+        for (long i = 3; i <= Math.sqrt(n); i += 2) {
+            // While i divides n, print i and divide n
+            while (n % i == 0) {
+                map.put(i,map.getOrDefault(i,0)+1);
+                n /= i;
+            }
+        }
+
+        // This condition is to handle the case whien
+        // n is a prime number greater than 2
+        if (n > 2)
+            map.put(n,map.getOrDefault(n,0)+1);
+
+        return map;
+    }
+
+
+
+    public static void main(String[] args) {
+        StringBuilder ans = new StringBuilder();
+        int t = ri();
+//        int t = 1;
+        while (t-- > 0)
+        {
+            int n=ri();
+            int m=ri();
+            int[][] arr=new int[n][m];
+            for(int i=0;i<n;i++)
+            {
+                char[] mid= rs().toCharArray();
+                for(int j=0;j<m;j++)
+                {
+                    arr[i][j]=mid[j]-'0';
+                }
+            }
+
+            int res=0;
+            StringBuilder str=new StringBuilder();
+            for(int i=0;i<n;)
+            {
+                for(int j=0;j<m;)
+                {
+                    boolean[] vis=new boolean[4];
+                    HashSet<Point> set=new HashSet<>();
+                    int count=0;
+                    if(arr[i][j]==1)
+                    {
+                        count++;
+                        set.add(new Point(i,j));
+                        vis[0]=true;
+                    }
+                    if(arr[i][j+1]==1)
+                    {
+                        count++;
+                        set.add(new Point(i,j+1));
+                        vis[1]=true;
+                    }
+                    if(arr[i+1][j]==1)
+                    {
+                        count++;
+                        set.add(new Point(i+1,j));
+                        vis[2]=true;
+                    }
+                    if(arr[i+1][j+1]==1)
+                    {
+                        count++;
+                        set.add(new Point(i+1,j+1));
+                        vis[3]=true;
+                    }
+
+                    if(count==4)
+                    {
+                        int v1=i+1;
+                        int v2=j+1;
+                        res++;
+                        count=1;
+                        str.append(v1).append("" "").append(v2).append("" "").append(v1).append("" "").append(v2 + 1).append("" "").append(v1 + 1).append("" "").append(v2).append(""\n"");
+                        vis[0]=false;
+                        vis[1]=false;
+                        vis[2]=false;
+                        arr[i][j]=0;
+                        arr[i][j+1]=0;
+                        arr[i+1][j]=0;
+                    }
+                    if(count==1)
+                    {
+                        res++;
+                        count=2;
+                        int p1=i+1,p2=j+1;
+                        if(vis[0])
+                        {
+                            str.append(p1).append("" "").append(p2).append("" "").append(p1).append("" "").append(p2+1).append("" "").append(p1 + 1).append("" "").append(p2).append(""\n"");
+                            vis[0]=false;
+                            vis[1]=true;
+                            vis[2]=true;
+                            arr[i][j]=1;
+                            arr[i][j+1]=0;
+                            arr[i+1][j]=0;
+
+                        }
+                        else if(vis[1])
+                        {
+                            p2++;
+                            str.append(p1).append("" "").append(p2).append("" "").append(p1).append("" "").append(p2-1).append("" "").append(p1 + 1).append("" "").append(p2).append(""\n"");
+                            vis[1]=false;
+                            vis[0]=true;
+                            vis[3]=true;
+                            arr[i][j+1]=1;
+                            arr[i][j]=0;
+                            arr[i+1][j+1]=0;
+                        }
+                        else if(vis[2])
+                        {
+                            p1++;
+                            str.append(p1).append("" "").append(p2).append("" "").append(p1-1).append("" "").append(p2).append("" "").append(p1).append("" "").append(p2+1).append(""\n"");
+                            vis[2]=false;
+                            vis[0]=true;
+                            vis[3]=true;
+                            arr[i+1][j]=1;
+                            arr[i][j]=0;
+                            arr[i+1][j+1]=0;
+                        }
+                        else {
+                            p1++;
+                            p2++;
+                            str.append(p1).append("" "").append(p2).append("" "").append(p1-1).append("" "").append(p2).append("" "").append(p1).append("" "").append(p2-1).append(""\n"");
+                            vis[3]=false;
+                            vis[1]=true;
+                            vis[2]=true;
+                            arr[i+1][j+1]=1;
+                            arr[i][j+1]=0;
+                            arr[i+1][j]=0;
+                        }
+                    }
+                    if(count==2)
+                    {
+                        res++;
+                        count=3;
+                        int p1=i+1,p2=j+1;
+
+                        if(vis[0]&&vis[1])
+                        {
+                            str.append(p1).append("" "").append(p2).append("" "").append(p1+1).append("" "").append(p2).append("" "").append(p1+1).append("" "").append(p2+1).append(""\n"");
+                            vis[0]=false;
+                            vis[2]=true;
+                            vis[3]=true;
+                            arr[i][j]=1;
+                            arr[i+1][j]=0;
+                            arr[i+1][j+1]=0;
+                        }
+                        else if(vis[0] && vis[2])
+                        {
+                            str.append(p1).append("" "").append(p2).append("" "").append(p1).append("" "").append(p2+1).append("" "").append(p1+1).append("" "").append(p2+1).append(""\n"");
+                            vis[0]=false;
+                            vis[1]=true;
+                            vis[3]=true;
+                            arr[i][j]=1;
+                            arr[i][j+1]=0;
+                            arr[i+1][j+1]=0;
+                        }
+                        else if(vis[0] && vis[3])
+                        {
+                            str.append(p1).append("" "").append(p2).append("" "").append(p1).append("" "").append(p2+1).append("" "").append(p1+1).append("" "").append(p2).append(""\n"");
+                            vis[0]=false;
+                            vis[1]=true;
+                            vis[2]=true;
+                            arr[i][j]=1;
+                            arr[i][j+1]=0;
+                            arr[i+1][j]=0;
+                        }
+                        else if(vis[1] && vis[2])
+                        {
+                            str.append(p1).append("" "").append(p2).append("" "").append(p1).append("" "").append(p2+1).append("" "").append(p1+1).append("" "").append(p2+1).append(""\n"");
+                            vis[1]=false;
+                            vis[0]=true;
+                            vis[3]=true;
+                            arr[i][j+1]=1;
+                            arr[i][j]=0;
+                            arr[i+1][j+1]=0;
+                        }
+                        else if(vis[1] && vis[3])
+                        {
+//                            System.out.println(""yoyo"");
+                            str.append(p1).append("" "").append(p2).append("" "").append(p1).append("" "").append(p2+1).append("" "").append(p1+1).append("" "").append(p2).append(""\n"");
+                            vis[1]=false;
+                            vis[0]=true;
+                            vis[2]=true;
+                            arr[i][j+1]=1;
+                            arr[i][j]=0;
+                            arr[i+1][j]=0;
+                        }
+                        else if(vis[2] && vis[3])
+                        {
+                            str.append(p1).append("" "").append(p2).append("" "").append(p1).append("" "").append(p2+1).append("" "").append(p1+1).append("" "").append(p2).append(""\n"");
+                            vis[2]=false;
+                            vis[0]=true;
+                            vis[1]=true;
+                            arr[i+1][j]=1;
+                            arr[i][j]=0;
+                            arr[i][j+1]=0;
+                        }
+                    }
+                    if(count==3)
+                    {
+                        res+=1;
+                        int p1=i+1,p2=j+1;
+                        if(vis[0] && vis[1] && vis[2])
+                        {
+                            str.append(p1).append("" "").append(p2).append("" "").append(p1).append("" "").append(p2+1).append("" "").append(p1+1).append("" "").append(p2).append(""\n"");
+
+                        }
+                        else if(vis[0] && vis[1] && vis[3])
+                        {
+                            str.append(p1).append("" "").append(p2).append("" "").append(p1).append("" "").append(p2+1).append("" "").append(p1+1).append("" "").append(p2+1).append(""\n"");
+
+                        }
+                        else if(vis[0] && vis[2] && vis[3])
+                        {
+                            str.append(p1).append("" "").append(p2).append("" "").append(p1+1).append("" "").append(p2+1).append("" "").append(p1+1).append("" "").append(p2).append(""\n"");
+
+                        }
+                        else if(vis[3] && vis[1] && vis[2])
+                        {
+                            str.append(p1+1).append("" "").append(p2+1).append("" "").append(p1).append("" "").append(p2+1).append("" "").append(p1+1).append("" "").append(p2).append(""\n"");
+
+                        }
+                        arr[i][j]=0;
+                        arr[i][j+1]=0;
+                        arr[i+1][j]=0;
+                        arr[i+1][j+1]=0;
+
+
+                    }
+
+
+
+
+                    j+=2;
+                    if(j==m-1)
+                    {
+                       j--;
+                    }
+                }
+                i+=2;
+                if(i==n-1)
+                {
+                    i--;
+                }
+            }
+            ans.append(res).append(""\n"");
+            ans.append(str.toString());
+
+        }
+
+
+        out.print(ans.toString());
+        out.flush();
+
+    }
+    static class Point
+    {
+        int x,y;
+
+        public Point(int x, int y) {
+            this.x = x;
+            this.y = y;
+        }
+    }
+
+}","import java.io.*;
+import java.util.*;
+import java.util.logging.LoggingPermission;
+
+public class C_binarytable {
+
+    public static void main(String[] args) throws Exception {
+
+        FastScanner sc = new FastScanner();
+        FastWriter writer = new FastWriter();
+        int t = sc.nextInt();
+        while(t-- > 0) {
+            int n = sc.nextInt(), m = sc.nextInt();
+            List<Operation> ops = new ArrayList<>();
+            char s[][] = new char[n][m];
+            for(int i = 0; i < n; i++)
+                s[i] = sc.next().toCharArray();
+
+            // diag
+            for(int i = 0; i < n - 1; i++)
+                for(int j = 0; j < m; j++) {
+                    if(s[i][j] == '0')
+                        continue;
+                    // right diag
+                    if(j + 1 < m && s[i+1][j+1] == '1') {
+                        s[i][j] = '0';
+                        Operation op = new Operation();
+                        op.pairs.add(new Pair(i, j));
+                        op.pairs.add(new Pair(i + 1, j));
+                        op.pairs.add(new Pair(i, j + 1));
+                        ops.add(op);
+
+                        op = new Operation();
+                        op.pairs.add(new Pair(i, j + 1));
+                        op.pairs.add(new Pair(i + 1, j));
+                        op.pairs.add(new Pair(i + 1, j + 1));
+                        ops.add(op);
+                        s[i+1][j+1] = '0';
+
+                        // left diag
+                    } else if(j > 0 && s[i+1][j-1] == '1') {
+                        s[i][j] = '0';
+                        Operation op = new Operation();
+                        op.pairs.add(new Pair(i, j));
+                        op.pairs.add(new Pair(i, j - 1));
+                        op.pairs.add(new Pair(i + 1, j));
+                        ops.add(op);
+
+                        op = new Operation();
+                        op.pairs.add(new Pair(i, j - 1));
+                        op.pairs.add(new Pair(i + 1, j - 1));
+                        op.pairs.add(new Pair(i + 1, j));
+                        ops.add(op);
+                        s[i+1][j-1] = '0';
+                    }
+                }
+
+            // same row adjacent
+            for(int i = 0; i < n; i++)
+                for(int j = 0; j < m - 1; j++) {
+                    if(s[i][j] == '0')
+                        continue;
+
+                    Pair cur = new Pair(i, j);
+                    if(i + 1 < n && s[i][j+1] == '1') {
+                        s[i][j] = '0';
+                        ops.add(get(cur, cur));
+                        ops.add(get(cur, new Pair(i, j+1)));
+                        s[i][j+1] = '0';
+
+                    } else if(i + 1 == n && s[i][j+1] == '1') {
+                        s[i][j] = '0';
+                        Pair upper = new Pair(i-1, j);
+                        ops.add(get(upper, cur));
+                        ops.add(get(upper, new Pair(i, j+1)));
+                        s[i][j+1] = '0';
+                    }
+                }
+
+            // same col adjacent
+            for(int i = 0; i < n - 1; i++)
+                for(int j = 0; j < m; j++) {
+                    if(s[i][j] == '0')
+                        continue;
+                    Pair prevCol = new Pair(i, j - 1);
+                    Pair cur = new Pair(i, j);
+
+                    if(j > 0 && s[i+1][j] == '1') {
+                        s[i][j] = '0';
+                        ops.add(get(prevCol, cur));
+                        ops.add(get(prevCol, new Pair(i+1, j)));
+                        s[i+1][j] = '0';
+
+                    } else if(j == 0 && s[i+1][j] == '1') {
+                        s[i][j] = '0';
+                        ops.add(get(cur, cur));
+                        ops.add(get(cur, new Pair(i + 1, j)));
+                        s[i+1][j] = '0';
+                    }
+                }
+
+            // single 1
+            for(int i = 0; i < n; i++)
+                for(int j = 0; j < m; j++) {
+                    if(s[i][j] == '0')
+                        continue;
+                    Pair prevCol = new Pair(i, j - 1);
+                    Pair cur = new Pair(i, j);
+                    s[i][j] = '0';
+
+                    if(i < n - 1) {
+                        if(j < m-1) {
+                            Pair next = new Pair(i, j+1);
+                            ops.add(get(cur, next));
+                            ops.add(get(cur, new Pair(i+1, j+1)));
+                            ops.add(get(cur, new Pair(i+1, j)));
+
+                        } else if(j == m-1) {
+
+                            ops.add(get(prevCol, prevCol));
+                            ops.add(get(prevCol, new Pair(i+1, j - 1)));
+                            ops.add(get(prevCol, new Pair(i+1, j)));
+
+                        }
+                    } else if(i == n-1) {
+                        if(j < m-1) {
+
+                            Pair upper = new Pair(i-1, j);
+                            ops.add(get(upper, new Pair(i-1, j+1)));
+                            ops.add(get(upper, new Pair(i, j+1)));
+                            ops.add(get(upper, upper));
+
+                        } else if(j == m-1) {
+
+                            Pair upper = new Pair(i-1, j-1);
+                            ops.add(get(upper, upper));
+                            ops.add(get(upper, new Pair(i, j-1)));
+                            ops.add(get(upper, new Pair(i-1, j)));
+                        }
+                    }
+                }
+
+            int size = ops.size();
+            if(size > 3 * n * m)
+                throw new RuntimeException();
+
+            writer.println(ops.size());
+            for(Operation op : ops)
+                writer.println(op.toString());
+        }
+        writer.close();
+    }
+
+    static Operation get(Pair topLeft, Pair ex) {
+        Operation op = new Operation();
+        for(int i = 0; i <= 1; i++)
+            for(int j = 0; j <= 1; j++) {
+                Pair p = new Pair(topLeft.x + i, topLeft.y + j);
+                if(!p.equals(ex))
+                    op.pairs.add(p);
+            }
+        return op;
+    }
+
+    static class Operation {
+        List<Pair> pairs = new ArrayList<>();
+
+        @Override
+        public String toString() {
+            StringBuilder sb = new StringBuilder();
+            for(Pair p : pairs)
+                sb.append(p.x+1 + "" "" + (p.y+1) + "" "");
+            return sb.toString();
+        }
+    }
+
+    static final Random random = new Random();
+
+    static class FastScanner {
+        private InputStream sin = System.in;
+        private final byte[] buffer = new byte[1024];
+        private int ptr = 0;
+        private int buflen = 0;
+        public FastScanner(){}
+        public FastScanner(String filename) throws FileNotFoundException {
+            File file = new File(filename);
+            sin = new FileInputStream(file);
+        }
+        private boolean hasNextByte() {
+            if (ptr < buflen) {
+                return true;
+            }else{
+                ptr = 0;
+                try {
+                    buflen = sin.read(buffer);
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+                if (buflen <= 0) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        private int readByte() { if (hasNextByte()) return buffer[ptr++]; else return -1;}
+        private static boolean isPrintableChar(int c) { return 33 <= c && c <= 126;}
+        public boolean hasNext() { while(hasNextByte() && !isPrintableChar(buffer[ptr])) ptr++; return hasNextByte();}
+        public String next() {
+            if (!hasNext()) throw new NoSuchElementException();
+            StringBuilder sb = new StringBuilder();
+            int b = readByte();
+            while(isPrintableChar(b)) {
+                sb.appendCodePoint(b);
+                b = readByte();
+            }
+            return sb.toString();
+        }
+        public long nextLong() {
+            if (!hasNext()) throw new NoSuchElementException();
+            long n = 0;
+            boolean minus = false;
+            int b = readByte();
+            if (b == '-') {
+                minus = true;
+                b = readByte();
+            }
+            if (b < '0' || '9' < b) {
+                throw new NumberFormatException();
+            }
+            while(true){
+                if ('0' <= b && b <= '9') {
+                    n *= 10;
+                    n += b - '0';
+                }else if(b == -1 || !isPrintableChar(b) || b == ':'){
+                    return minus ? -n : n;
+                }else{
+                    throw new NumberFormatException();
+                }
+                b = readByte();
+            }
+        }
+        public int nextInt() {
+            long nl = nextLong();
+            if (nl < Integer.MIN_VALUE || nl > Integer.MAX_VALUE) throw new NumberFormatException();
+            return (int) nl;
+        }
+        public double nextDouble() { return Double.parseDouble(next());}
+        public long[] nextLongArray(final int n){
+            final long[] a = new long[n];
+            for (int i = 0; i < n; i++)
+                a[i] = nextLong();
+            return a;
+        }
+        public int[] nextIntArray(final int n){
+            final int[] a = new int[n];
+            for (int i = 0; i < n; i++)
+                a[i] = nextInt();
+            return a;
+        }
+        public double[] nextDoubleArray(final int n){
+            final double[] a = new double[n];
+            for (int i = 0; i < n; i++)
+                a[i] = nextDouble();
+            return a;
+        }
+
+        public List<Integer>[] adjacencyList(int nodes, int edges) {
+            return adjacencyList(nodes, edges, false);
+        }
+        public List<Integer>[] adjacencyList(int nodes, int edges, boolean isDirected) {
+
+            List<Integer>[] adj = new ArrayList[nodes + 1];
+            Arrays.setAll(adj, (i) -> new ArrayList<>());
+            for (int i = 0; i < edges; i++) {
+                int a = nextInt(), b = nextInt();
+                adj[a].add(b);
+                if (!isDirected) adj[b].add(a);
+            }
+            return adj;
+        }
+    }
+
+    static class FastWriter {
+
+        BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(System.out));
+        void print(int n) throws Exception { writer.write(n + """"); }
+        void println(int n) throws Exception { writer.write(n + ""\n""); }
+
+        void print(long n) throws Exception { writer.write(n + """"); }
+        void println(long n) throws Exception { writer.write(n + ""\n""); }
+
+        void print(String s) throws Exception { writer.write(s); }
+        void println(String s) throws Exception { writer.write(s); writer.newLine(); }
+
+        void println(int ar[]) throws Exception { for(int e : ar) writer.write(e + "" ""); writer.newLine(); }
+        void println(long ar[]) throws Exception { for(long e : ar) writer.write(e + "" ""); writer.newLine(); }
+        void println(double ar[]) throws Exception { for(double e : ar) writer.write(e + "" ""); writer.newLine(); }
+        void close() throws Exception { writer.close(); }
+        <T> void println(List<T> L) throws Exception { for(T o : L) writer.write(o + "" ""); writer.newLine(); }
+    }
+
+    static int findDistance(List<Integer> G[], int nodes, int src, int dst) {
+
+        LinkedList<Integer> queue = new LinkedList<>();
+        int dist[] = new int[nodes + 1];
+        int ans = -1;
+        dist[src] = 0;
+        queue.add(src);
+        while(queue.size() > 0) {
+            int u = queue.poll();
+            if(u == dst) {
+                ans = dist[u];
+            }
+            for(int v : G[u]) {
+                if(dist[v] >= 0)
+                    continue;
+                queue.add(v);
+                dist[v] = dist[u] + 1;
+            }
+        }
+        return ans;
+    }
+
+    static void sort(List<Integer> A) {
+        shuffleList(A);
+        Collections.sort(A);
+    }
+
+    static void shuffleList(List<Integer> A) {
+        int n = A.size();
+        for(int i = 0; i < n; i++) {
+            int tmp = A.get(i);
+            int randomPos = i + random.nextInt(n-i);
+            A.set(i, A.get(randomPos));
+            A.set(randomPos, tmp);
+        }
+    }
+
+    static void sort(int A[]) {
+        shuffleArray(A);
+        Arrays.sort(A);
+    }
+    static void sort(long A[]) {
+        shuffleArray(A);
+        Arrays.sort(A);
+    }
+    static void sort(double A[]) {
+        shuffleArray(A);
+        Arrays.sort(A);
+    }
+    static <T> void sort(T[] A) {
+        shuffleArray(A);
+        Arrays.sort(A);
+    }
+    static <T> void shuffleArray(T[] A) {
+        int n = A.length;
+        for(int i = 0; i < n; i++) {
+            T tmp = A[i];
+            int randomPos = i + random.nextInt(n-i);
+            A[i] = A[randomPos];
+            A[randomPos] = tmp;
+        }
+    }
+    static void shuffleArray(int[] A) {
+        int n = A.length;
+        for(int i = 0; i < n; i++) {
+            int tmp = A[i];
+            int randomPos = i + random.nextInt(n-i);
+            A[i] = A[randomPos];
+            A[randomPos] = tmp;
+        }
+    }
+    static void shuffleArray(long[] A) {
+        int n = A.length;
+        for(int i = 0; i < n; i++) {
+            long tmp = A[i];
+            int randomPos = i + random.nextInt(n-i);
+            A[i] = A[randomPos];
+            A[randomPos] = tmp;
+        }
+    }
+    static void shuffleArray(double[] A) {
+        int n = A.length;
+        for(int i = 0; i < n; i++) {
+            double tmp = A[i];
+            int randomPos = i + random.nextInt(n-i);
+            A[i] = A[randomPos];
+            A[randomPos] = tmp;
+        }
+    }
+
+    static int[] subArray(int A[], int x, int y) {
+        int B[] = new int[y - x + 1];
+        for(int i = x; i <= y; i++)
+            B[i-x] = A[i];
+        return B;
+    }
+
+    static int[] toArray(List<Integer> L) {
+        return L.stream().mapToInt(x -> x).toArray();
+    }
+
+    static void println(int[] A) {
+        for(int e: A) System.out.print(e + "" "");
+        System.out.println();
+    }
+
+    static void println(long[] A) {
+        for(long e: A) System.out.print(e + "" "");
+        System.out.println();
+    }
+
+    static void println(List arr) {
+        for(Object e: arr) System.out.print(e + "" "");
+        System.out.println();
+    }
+
+    static <T> void println(T A[]) {
+
+        for(T i : A)
+            System.out.print(i + "" "");
+        System.out.println();
+    }
+
+    static void print(String s) {
+        System.out.print(s);
+    }
+    static void println(long n) {
+        System.out.println(n);
+    }
+
+    static void println(String s) {
+        System.out.println(s);
+    }
+
+    static List<Integer> toList(int ar[]) {
+        List<Integer> list = new ArrayList<>();
+        for(int x : ar) list.add(x);
+        return list;
+    }
+
+    static List<Long> toList(long ar[]) {
+        List<Long> list = new ArrayList<>();
+        for(long x : ar) list.add(x);
+        return list;
+    }
+
+    static List<Double> toList(double ar[]) {
+        List<Double> list = new ArrayList<>();
+        for(double x : ar) list.add(x);
+        return list;
+    }
+
+    static long gcd(long a, long b) {
+        if(b == 0)
+            return a;
+        return gcd(b, a % b);
+    }
+
+    private static int abs(int a){  return (a>=0) ? a: -a;  }
+    private static int min(int... ins){ int min = ins[0]; for(int x : ins) min = Math.min(min, x); return min;  }
+    private static int max(int... ins){ int max = ins[0]; for(int x : ins) max = Math.max(max, x); return max;  }
+    private static long sum(int... ins){ long s = 0; for(int x : ins) s += x; return s; }
+    private static long abs(long a){ return (a>=0) ? a: -a; }
+    private static long min(long... ins){ long min = ins[0]; for(long x : ins) min = Math.min(min, x); return min;  }
+    private static long max(long... ins){ long max = ins[0]; for(long x : ins) max = Math.max(max, x); return max; }
+    private static long sum(long... ins){ long s = 0; for(long x : ins) s += x; return s; }
+    private static double abs(double a){ return (a>=0) ? a: -a; }
+    private static double min(double... ins){ double min = ins[0]; for(double x : ins) min = Math.min(min, x); return min;  }
+    private static double max(double... ins){ double max = ins[0]; for(double x : ins) max = Math.max(max, x); return max;  }
+    private static double sum(double... ins){ double s = 0; for(double x : ins) s += x; return s; }
+
+    private static class Pair implements Comparable<Pair> {
+        int x, y;
+        Pair(int x, int y) { this.x = x; this.y = y; }
+        Pair() {}
+
+        @Override
+        public int compareTo(Pair other) {
+            return x == other.x ? y - other.y : x - other.x;
+        }
+
+        @Override
+        public boolean equals(Object o) {
+            if (this == o) return true;
+            if (o == null || getClass() != o.getClass()) return false;
+            Pair pair = (Pair) o;
+            return x == pair.x &&
+                    y == pair.y;
+        }
+
+        @Override
+        public int hashCode() {
+            return Objects.hash(x, y);
+        }
+
+        @Override
+        public String toString() {
+            return String.format(""(%d, %d)"", x, y);
+        }
+    }
+
+    static int pow(long n, int p, int mod) {
+        if(p == 0)
+            return 1;
+        long x = pow(n, p/2, mod);
+        x = x * x % mod;
+        return (int) ( p % 2 == 0 ? x : x * n % mod );
+    }
+
+    static long inv(int x, int m) {
+        return pow(x, m - 2, m);
+    }
+
+    static int lowerBound(int ar[], int L, int R, int val) {
+        if(val < ar[L] || val > ar[R])
+            return -1;
+        while(L <= R) {
+            int mid = (L + R) / 2;
+            if(ar[mid] >= val)
+                R = mid - 1;
+            else
+                L = mid + 1;
+        }
+        return ar[L] == val ? L : -1;
+    }
+
+    static int upperBound(int ar[], int L, int R, int val) {
+        if(val < ar[L] || val > ar[R])
+            return -1;
+        while(L <= R) {
+            int mid = (L + R) / 2;
+            if(ar[mid] > val)
+                R = mid - 1;
+            else
+                L = mid + 1;
+        }
+        return ar[R] == val ? R : -1;
+    }
+}
+
+",0
+2bbf754b,9862c742,"import java.util.*;
+
+/** 
+__                  __
+( _)                ( _)
+/ / \\              / /\_\_
+/ /   \\            / / | \ \
+/ /     \\          / /  |\ \ \
+/  /   ,  \ ,       / /   /|  \ \
+/  /    |\_ /|      / /   / \   \_\
+/  /  |\/ _ '_| \   / /   /   \    \\
+|  /   |/  0 \0\    / |    |    \    \\
+|    |\|      \_\_ /  /    |     \    \\
+|  | |/    \.\ o\o)  /      \     |    \\
+\    |     /\\`v-v  /        |    |     \\
+| \/    /_| \\_|  /         |    | \    \\
+| |    /__/_ `-` /   _____  |    |  \    \\
+\|    [__]  \_/  |_________  \   |   \    ()
+/    [___] (    \         \  |\ |   |   //
+|    [___]                  |\| \|   /  |/
+/|    [____]                  \  |/\ / / ||
+(  \   [____ /     ) _\      \  \    \| | ||
+\  \  [_____|    / /     __/    \   / / //
+|   \ [_____/   / /        \    |   \/ //
+|   /  '----|   /=\____   _/    |   / //
+__ /  /        |  /   ___/  _/\    \  | ||
+(/-(/-\)       /   \  (/\/\)/  |    /  | /
+(/\/\)           /   /   //
+_________/   /    /
+\____________/    (
+
+
+
+*/
+
+public class Main {
+	public static void main(String[] args) {
+		Scanner sc=new Scanner(System.in);
+		int  t=sc.nextInt();
+		while(t-- >0) {
+			int n=sc.nextInt();
+			int[] arr=new int[n];
+			for(int i=0;i<n;i++) {
+				arr[i]=sc.nextInt();
+			}
+			String str=sc.next();
+			
+			ArrayList<Pair> plist=new ArrayList<>();
+			for(int i=0;i<n;i++) {
+				char ch=str.charAt(i);
+				plist.add(new Pair(arr[i],ch));
+			}
+			
+			//B-reduce
+			//R-increse
+			Collections.sort(plist);
+			
+			int counter=1;
+			boolean flag=false;
+			for(int i=0;i<plist.size();i++) {
+				int val=plist.get(i).number;
+				int clr=plist.get(i).color;
+				
+				if(clr=='B') {
+					if(val<counter) {
+						flag=true;
+						break;
+					}
+				}
+				else {
+					if(val>counter) {
+						flag=true;
+						break;
+					}
+					
+				}
+				counter++;
+			}
+			System.out.println(flag?""NO"":""YES"");
+			
+			
+		}
+	}
+	public static class Pair implements Comparable<Pair>{
+		int number;
+		char color;
+		
+		Pair(int number,char color){
+			this.number=number;
+			this.color=color;
+		}
+		
+		@Override
+		public int compareTo(Pair o) {
+			if(o.color==this.color) {
+				return this.number-o.number;
+			}
+			else {
+				return this.color-o.color;
+			}
+		}
+		
+		public String toString() {
+			return number+""-""+color+""."";
+		}
+	}
+}
+","/******************************************************************************
+
+Welcome to GDB Online.
+GDB online is an online compiler and debugger tool for C, C++, Python, Java, PHP, Ruby, Perl,
+C#, VB, Swift, Pascal, Fortran, Haskell, Objective-C, Assembly, HTML, CSS, JS, SQLite, Prolog.
+Code, Compile, Run and Debug online from anywhere in world.
+
+*******************************************************************************/
+import java.util.*;
+public class Main
+{
+	public static void main(String[] args) {
+		Scanner s  = new Scanner(System.in);
+		int t = s.nextInt();
+		while(t-- > 0){
+		    int n = s.nextInt();
+		    int[] arr = new int[n];
+		    for(int i=0;i<n;i++)
+		        arr[i] = s.nextInt();
+		    String str = s.next();
+		    List<Integer> left = new ArrayList<>();
+		    List<Integer> right = new ArrayList<>();
+		    for(int i=0;i<arr.length;i++){
+		        if(str.charAt(i) == 'B')
+		            left.add(arr[i]);
+		        else right.add(arr[i]);
+		    }
+		    Collections.sort(left);
+		    Collections.sort(right);
+		    boolean flag = false;
+		    for(int i=0;i<left.size();i++)
+		        if(left.get(i) < i+1){
+		            flag = true;
+		            break;
+		        }
+		    if(!flag){
+		        for(int i=0;i<right.size();i++)
+    		        if(right.get(i) > left.size()+i+1){
+    		            flag = true;
+    		            break;
+    		        }
+		    }
+		    if(flag)
+		        System.out.println(""NO"");
+		    else System.out.println(""YES"");
+		}
+	}
+}
+
+",0
+11373c16,69b2fd22,"/* package codechef; // don't place package name! */
+
+import java.util.*;
+import java.lang.*;
+import java.io.*;
+
+/* Name of the class has to be ""Main"" only if the class is public. */
+public class Codechef
+{static class FastReader 
+    { 
+        BufferedReader br; 
+        StringTokenizer st; 
+  
+        public FastReader() 
+        { 
+            br = new BufferedReader(new
+                     InputStreamReader(System.in)); 
+        } 
+  
+        String next() 
+        { 
+            while (st == null || !st.hasMoreElements()) 
+            { 
+                try
+                { 
+                    st = new StringTokenizer(br.readLine()); 
+                } 
+                catch (IOException  e) 
+                { 
+                    e.printStackTrace(); 
+                } 
+            } 
+            return st.nextToken(); 
+        } 
+  
+        int nextInt() 
+        { 
+            return Integer.parseInt(next()); 
+        } 
+  
+        long nextLong() 
+        { 
+            return Long.parseLong(next()); 
+        } 
+  
+        double nextDouble() 
+        { 
+            return Double.parseDouble(next()); 
+        } 
+  
+        String nextLine() 
+        { 
+            String str = """"; 
+            try
+            { 
+                str = br.readLine(); 
+            } 
+            catch (IOException e) 
+            { 
+                e.printStackTrace(); 
+            } 
+            return str; 
+        } 
+    } 
+	public static void main (String[] args) throws java.lang.Exception
+	{
+		FastReader scan = new FastReader();
+		PrintWriter pw = new PrintWriter(System.out);
+        int n = scan.nextInt();
+        ArrayList<Integer> a = new ArrayList<>();
+        ArrayList<Integer> b = new ArrayList<>();
+        for(int i=0;i<n;i++){
+            int x = scan.nextInt();
+            if(x==1)
+            a.add(i);
+            else
+            b.add(i);  
+        }
+        int x = a.size();
+        if(x==0){
+            pw.println(0);
+            pw.flush();
+            return;
+        }
+        int y = b.size();
+        int dp[][] = new int[x][y];
+        int min = Integer.MAX_VALUE;
+        for(int i=0;i<y;i++){
+            min = Math.min(Math.abs(a.get(0) - b.get(i)),min);
+            dp[0][i] = min;
+        }
+        for(int i=1;i<x;i++){
+            min = Integer.MAX_VALUE;
+            for(int j=i;j<y;j++){
+                min = Math.min(Math.abs(a.get(i)-b.get(j))+dp[i-1][j-1],min);
+                dp[i][j] = min;
+            }
+        }
+        pw.println(dp[x-1][y-1]);
+        pw.flush();
+	}
+   
+}
+","import java.io.*;
+import java.util.*;
+public class Main {
+    public static void main(String args[])
+    {
+        FastReader input=new FastReader();
+        PrintWriter out=new PrintWriter(System.out);
+        int T=1;
+        while(T-->0)
+        {
+            int n=input.nextInt();
+            int a[]=new int[n];
+            ArrayList<Integer> list=new ArrayList<>();
+            ArrayList<Integer> space=new ArrayList<>();
+            for(int i=0;i<n;i++)
+            {
+                a[i]=input.nextInt();
+                if(a[i]==1)
+                {
+                    list.add(i);
+                }
+                else
+                {
+                    space.add(i);
+                }
+            }
+            int pre[]=new int[space.size()];
+            for(int i=0;i<list.size();i++)
+            {
+                if(i==0)
+                {
+                    int min=Integer.MAX_VALUE;
+                    for(int j=0;j<space.size();j++)
+                    {
+                        pre[j]=Math.abs(list.get(i)-space.get(j));
+                        min=Math.min(min,pre[j]);
+                        pre[j]=min;
+                    }
+                }
+                else
+                {
+                    int arr[]=new int[space.size()];
+                    for(int j=0;j<i;j++)
+                    {
+                        arr[j]=Integer.MAX_VALUE;
+                    }
+
+                    int min=Integer.MAX_VALUE;
+                    for(int j=i;j<space.size();j++)
+                    {
+                        int v=Math.abs(list.get(i)-space.get(j));
+                        v+=pre[j-1];
+                        arr[j]=v;
+                        min=Math.min(min,v);
+                        arr[j]=min;
+                    }
+                    for(int j=0;j<space.size();j++)
+                    {
+                        pre[j]=arr[j];
+                    }
+                }
+            }
+            out.println(pre[space.size()-1]);
+        }
+        out.close();
+    }
+    static class FastReader
+    {
+        BufferedReader br;
+        StringTokenizer st;
+        public FastReader()
+        {
+            br = new BufferedReader(new InputStreamReader(System.in));
+        }
+        String next()
+        {
+            while (st == null || !st.hasMoreElements())
+            {
+                try
+                {
+                    st = new StringTokenizer(br.readLine());
+                }
+                catch (IOException e)
+                {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+        int nextInt()
+        {
+            return Integer.parseInt(next());
+        }
+        long nextLong()
+        {
+            return Long.parseLong(next());
+        }
+        double nextDouble()
+        {
+            return Double.parseDouble(next());
+        }
+        String nextLine()
+        {
+            String str="""";
+            try
+            {
+                str=br.readLine();
+            }
+            catch (IOException e)
+            {
+                e.printStackTrace();
+            }
+            return str;
+        }
+    }
+}",0
+b9595381,d6fb3b9e,"import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.*;
+public class Main{
+    
+static int dest1;
+static int dest2;
+public static void main(String args[]){
+       	FastScanner in = new FastScanner();
+		int test=in.nextInt();
+                while(test-->0){
+                    int n=in.nextInt();
+                    int count[][]=new int[n][5];
+                    int total[]=new int[n];
+                    String words[]=new String[n];
+                    for(int i=0;i<n;i++){
+                        words[i]=in.next();
+                        for(int j=0;j<words[i].length();j++)
+                            count[i][words[i].charAt(j)-'a']++;
+                        
+                        total[i]=words[i].length();
+                    }
+                    int max=Integer.MIN_VALUE;
+                   for(int i=0;i<5;i++){
+                       
+                      Integer ans[]=new Integer[n];
+                      for(int j=0;j<n;j++){
+                          ans[j]=count[j][i]-(total[j]-count[j][i]);
+                      }
+                      Arrays.sort(ans,Collections.reverseOrder());
+                      int j=0;
+                      int r=0;
+                      while(j<n && r+ans[j]>0){
+                          r+=ans[j];
+                          j++;
+                      }
+                      max=Math.max(j,max);
+                      
+                   }
+                   System.out.println(max);
+                   
+                    
+                }
+}
+public static int solve(int start[], int end[], int n)
+    {
+        int distance[][]=new int[n][n];
+        int r=n;
+        int c=n;
+        boolean visited[][]=new boolean[n][n];
+        int startx=start[0];
+        int starty=start[1];
+        int endx=end[0];
+        int endy=end[1];
+        Pair tmp=new Pair(startx,starty);
+		Queue<Pair> q=new LinkedList<>();
+		q.add(tmp);
+		visited[startx][starty]=true;
+		distance[startx][starty]=0;
+		int dx[]={-2,-1,1,2,2,1,-1,-2};
+		int dy[]={1,2,2,1,-1,-2,-2,-1};
+		while(!q.isEmpty())
+		{
+			Pair cell=q.poll();
+			int x=cell.x;
+			int y=cell.y;
+			int d=distance[x][y];
+			for(int i=0;i<8;i++)
+			{
+				int childx=x+dx[i];
+				int childy=y+dy[i];
+				if(valid(childx,childy,r,c,visited))
+				{
+					visited[childx][childy]=true;
+					distance[childx][childy]=d+1;
+					q.add(new Pair(childx,childy));
+				}
+			}
+		}
+		return distance[endx][endy];
+    }
+       
+public static boolean valid(int x,int y,int r,int c,boolean visited[][])
+	{
+		if(x<0||y<0||x>=r||y>=c)
+			return false;
+		if(visited[x][y])
+			return false;
+		return true;
+	}
+public static int knight(int i,int j){
+    if(i==dest1 && j==dest2)
+        return 0;
+    
+    if(i<1 || j<1)
+        return 0;
+    if(i>8 || j>8)
+        return 0;
+    
+    if(i<1 || j>8)
+        return 0;
+    
+    if(i>8 || j<1)
+        return 0;
+    
+    int min=0;
+    if(i-1>=1 && j-2>=1)
+        min+=1+knight(i-1,j-2);
+    if(i-1>=1 && j+2<=8)
+        min+=1+knight(i-1,j+2);
+    if(i-2>=1 && j-1>=1)
+        min+=1+knight(i-2,j-1);
+    if(i-2>=1 && j+1<=8)
+        min+=1+knight(i-2,j+1);
+     if(i+1<=8 && j-2>=1)
+        min+=1+knight(i+1,j-2);
+    if(i+1<=8 && j+2<=8)
+        min+=1+knight(i+1,j+2);
+    if(i+2<=8 && j-1>=1)
+        min+=1+knight(i+2,j-1);
+    if(i+2<=8 && j+1<=8)
+        min+=1+knight(i+2,j+1);
+    
+    return min;
+}
+
+}
+class FastScanner {
+		java.io.BufferedReader br = new java.io.BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st = new StringTokenizer("""");
+ 
+		String next() {
+			while (!st.hasMoreTokens())
+				try {
+					st = new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			return st.nextToken();
+		}
+ 
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+ 
+		int[] readArray(int n) {
+			int[] a = new int[n];
+			for (int i = 0; i < n; i++)
+				a[i] = nextInt();
+			return a;
+		}
+ 
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+	}
+class Pair
+    {
+    	int x;
+    	int y;
+    	Pair(int i,int j)
+    	{
+    		x=i;
+    		y=j;
+    	}
+    }
+ 
+      
+
+
+
+","import java.util.*;
+public class Sol
+{
+    public static void main(String[] args)
+    {
+        Scanner sc = new Scanner(System.in);
+        int t = sc.nextInt();
+        while(t-->0)
+        {
+			int n = sc.nextInt();
+			int a[][]=new int[n][5];
+			int tot[]=new int[n];
+			for(int i=0;i<n;i++)
+			{
+				String x = sc.next();
+				for(int j=0;j<x.length();j++)
+					a[i][x.charAt(j)-'a'] += 1;
+				tot[i]=x.length();
+			}
+			
+			int max=Integer.MIN_VALUE;
+			for(int i=0;i<5;i++)
+				max=Math.max(max,function(a,n,i,tot));
+			System.out.println(max);
+			
+		}	
+    }
+	static int function(int a[][],int n,int i,int tot[])
+	{
+		Integer ans[] = new Integer[n];
+		for(int j=0;j<n;j++)
+			ans[j]=a[j][i]-(tot[j]-a[j][i]);
+		int res=0,j=0;
+		Arrays.sort(ans,Collections.reverseOrder());
+		while(j<n&&res+ans[j]>0)
+			res+=ans[j++];
+		return j;
+	}
+}
+",1
+1c8bb204,4b7646f4,"import javax.print.DocFlavor;
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.*;
+
+public class BST {
+
+    static class pair implements Comparable{
+
+        int high;
+        int idx;
+
+        pair(int x , int y){
+            high = x;
+            idx = y;
+        }
+
+        public String toString(){
+            return high + "" "" + idx;
+        }
+
+
+        @Override
+        public int compareTo(Object o) {
+            pair p = (pair)o;
+            return high-p.high;
+        }
+    }
+
+    public static void main(String[] args) throws IOException{
+
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        int t = Integer.parseInt(br.readLine());
+        while (t-->0){
+
+            int n = Integer.parseInt(br.readLine());
+            long [] arr = new long[n];
+            StringTokenizer st = new StringTokenizer(br.readLine());
+            for (int i = 0; i < n; i++) {
+                long tmp = Long.parseLong(st.nextToken());
+                arr[i] = tmp;
+
+            }
+
+            int h = 1;
+            int v = 1;
+            long minHor = arr[0];
+            long minVir = arr[1];
+            long sum0 = arr[0];
+            long sum1 = arr[1];
+            long total = (arr[0] + arr[1])*n;
+
+
+            for (int i = 2; i < n; i++) {
+
+                if(i%2==0){
+                    h++;
+                    sum0 += arr[i];
+                    minHor = Math.min(arr[i] , minHor);
+                    total = Math.min(total , minHor*(n-h+1)+(sum0-minHor)+minVir*(n-v+1)+(sum1-minVir));
+                }else {
+                    v++;
+                    sum1 += arr[i];
+                    minVir = Math.min(arr[i] , minVir);
+                    total = Math.min(total , minHor*(n-h+1)+(sum0-minHor)+minVir*(n-v+1)+(sum1-minVir));
+                }
+
+            }
+
+
+            System.out.println(total);
+
+        }
+
+
+
+    }
+
+
+
+
+}","import javax.print.DocFlavor;
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.*;
+ 
+public class BST {
+ 
+    static class pair implements Comparable{
+ 
+        int high;
+        int idx;
+ 
+        pair(int x , int y){
+            high = x;
+            idx = y;
+        }
+ 
+        public String toString(){
+            return high + "" "" + idx;
+        }
+ 
+ 
+        @Override
+        public int compareTo(Object o) {
+            pair p = (pair)o;
+            return high-p.high;
+        }
+    }
+ 
+    public static void main(String[] args) throws IOException{
+ 
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        int t = Integer.parseInt(br.readLine());
+        while (t-->0){
+ 
+            int n = Integer.parseInt(br.readLine());
+            long [] arr = new long[n];
+            StringTokenizer st = new StringTokenizer(br.readLine());
+            for (int i = 0; i < n; i++) {
+                long tmp = Long.parseLong(st.nextToken());
+                arr[i] = tmp;
+ 
+            }
+ 
+            int h = 1;
+            int v = 1;
+            long minHor = arr[0];
+            long minVir = arr[1];
+            long sum0 = arr[0];
+            long sum1 = arr[1];
+            long total = (arr[0] + arr[1])*n;
+ 
+ 
+            for (int i = 2; i < n; i++) {
+ 
+                if(i%2==0){
+                    h++;
+                    sum0 += arr[i];
+                    minHor = Math.min(arr[i] , minHor);
+                    total = Math.min(total , minHor*(n-h+1)+(sum0-minHor)+minVir*(n-v+1)+(sum1-minVir));
+                }else {
+                    v++;
+                    sum1 += arr[i];
+                    minVir = Math.min(arr[i] , minVir);
+                    total = Math.min(total , minHor*(n-h+1)+(sum0-minHor)+minVir*(n-v+1)+(sum1-minVir));
+                }
+ 
+            }
+ 
+ 
+            System.out.println(total);
+ 
+        }
+ 
+ 
+ 
+    }
+ 
+ 
+ 
+ 
+}
+",1
+00af3420,d92c5342,"import java.util.*;
+import java.io.*;
+
+public class Main {
+
+    public static void main(String[] args) throws IOException {
+        Scanner sc = new Scanner(System.in);
+        PrintWriter pw = new PrintWriter(System.out);
+        int t = sc.nextInt();
+        while(t-- > 0){
+            int n = sc.nextInt();
+            String[] s = new String[n];
+            for(int i=0; i<n; i++)
+                s[i] = sc.next();
+            int MAX = 0;
+            for(char c = 'a'; c <= 'e'; c++){
+                PriorityQueue<Integer> pq = new PriorityQueue<>(Collections.reverseOrder()); //Big comes in top;
+                for(int i=0; i<n; ++i) {
+                    int curChar = 0;
+                    int otherChar = 0;
+                    for(int j=0; j<s[i].length(); j++) {
+                        if(s[i].charAt(j) == c)
+                            curChar++;
+                        else
+                            otherChar++;
+                    }
+                    int diff = curChar - otherChar;
+                    pq.add(diff);
+                }
+                int cur = 0;
+                int numberOfWords = 0;
+                while(!pq.isEmpty()){
+                    if(cur + pq.peek() > 0){
+                        cur += pq.poll();
+                        numberOfWords++;
+                    }else{
+                        break;
+                    }
+                }
+                MAX = Math.max(MAX, numberOfWords);
+            }
+            pw.println(MAX);
+        }
+        pw.close();
+    }
+
+    static class Scanner {
+        BufferedReader br;
+        StringTokenizer st;
+
+        public Scanner(InputStream s) {
+            br = new BufferedReader(new InputStreamReader(s));
+        }
+
+        public Scanner(FileReader f) {
+            br = new BufferedReader(f);
+        }
+
+        public String next() throws IOException {
+            while (st == null || !st.hasMoreTokens())
+                st = new StringTokenizer(br.readLine());
+            return st.nextToken();
+        }
+
+        public int nextInt() throws IOException {
+            return Integer.parseInt(next());
+        }
+
+        public long nextLong() throws IOException {
+            return Long.parseLong(next());
+        }
+
+        public double nextDouble() throws IOException {
+            return Double.parseDouble(next());
+        }
+
+        public int[] nextIntArr(int n) throws IOException {
+            int[] arr = new int[n];
+            for (int i = 0; i < n; i++) {
+                arr[i] = Integer.parseInt(next());
+            }
+            return arr;
+        }
+
+    }
+}
+
+","import java.io.BufferedReader;
+    import java.io.IOException;
+    import java.io.InputStreamReader;
+    import java.io.PrintWriter;
+import java.lang.reflect.Array;
+import java.util.*;
+public class Main{
+    static class FastScanner {
+            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+            StringTokenizer st = new StringTokenizer("""");
+
+            String next() {
+                while (!st.hasMoreTokens())
+                    try {
+                        st = new StringTokenizer(br.readLine());
+                    } catch (IOException e) {
+                        e.printStackTrace();
+                    }
+                return st.nextToken();
+            }
+
+            int nextInt() {
+                return Integer.parseInt(next());
+            }
+
+            int[] nextArray(int n) {
+                int[] a = new int[n];
+                for (int i = 0; i < n; i++) a[i] = nextInt();
+                return a;
+            }
+            long[] nextArray(long n) {
+                long[] a = new long[(int) n];
+                for (int i = 0; i < n; i++) a[i] = nextLong();
+                return a;
+            }
+
+            long nextLong() {
+                return Long.parseLong(next());
+            }
+        }
+    static class FastWriter extends PrintWriter {
+            FastWriter(){
+                super(System.out);
+            }
+            void println(int[] array) {
+                for(int i=0; i<array.length; i++) {
+                    print(array[i]+"" "");
+                }
+                println();
+            }
+            void println(long [] array) {
+                for(int i=0; i<array.length; i++) {
+                    print(array[i]+"" "");
+                }
+                println();
+            }
+        }
+    static int MOD=1000003;
+    public static void main(String[] args) throws IOException {
+        FastScanner in = new FastScanner();
+        FastWriter out = new FastWriter();
+        int t=in.nextInt();
+        //int t=1;
+        while (t-->0){
+            int n=in.nextInt();
+            String[] ar=new String[n];
+            for (int i = 0; i < n; i++) {
+                ar[i]=in.next();
+            }
+            int ans=0;
+            for(char ch='a';ch<='e';ch++){
+                int[] res=new int[n];
+                for (int i = 0; i < n; i++) {
+                    String ss=ar[i];
+                    for (int j = 0; j < ss.length(); j++) {
+                        if(ss.charAt(j)==ch){
+                            res[i]++;
+                        }else {
+                            res[i]--;
+                        }
+                    }
+                }
+                Arrays.sort(res);int max=0,nn=0;
+                for (int i = n-1; i>=0; i--) {
+                    max+=res[i];
+                    if(max>0){
+                        nn++;
+                    }else {
+                        break;
+                    }
+                }
+                ans=Math.max(ans,nn);
+            }
+            out.println(ans);
+        }
+        out.close();
+    }
+    //Arrays.sort(a, (o1, o2) -> (o1[0] - o2[0]));
+    static int totalPrimeFactors(int n) {
+        int cnt=0;
+        while (n%2==0) {
+            cnt++;
+            n /= 2;
+        }
+        int num= (int) Math.sqrt(n);
+        for (int i = 3; i <= num; i+= 2) {
+            while (n%i == 0) {
+                cnt++;
+                n /= i;
+                num=(int)Math.sqrt(n);
+            }
+        }
+        if (n > 2){
+            cnt++;
+        }
+        return cnt;
+    }
+    static char get(int i){
+        return (char)(i+'a');
+    }
+    static boolean distinct(int num){
+        HashSet<Integer> set=new HashSet<>();
+        int len=String.valueOf(num).length();
+        while (num!=0){
+            set.add(num%10);
+            num/=10;
+        }
+        return set.size()==len;
+    }
+    static int maxSubArraySum(int a[],int st,int en) {
+        int max_s = Integer.MIN_VALUE, max_e = 0,ind=0,ind1=1;
+        for (int i = st; i <= en; i++) {
+            max_e+= a[i];
+            if (max_s < max_e){
+                max_s = max_e;
+                ind=ind1;
+            }
+            if (max_e < 0){
+                max_e = 0;
+                ind1=i+1;
+            }
+        }
+        if(st==0){
+            return max_s;
+        }
+        if(ind==1){
+            return a[0]+2*max_s;
+        }else {
+            return 2*max_s+maxSubArraySum(a,0,ind-1);
+        }
+        //return max_s;
+    }
+    static void segmentedSieve(ArrayList<Integer> res,int low, int high) {
+        if(low < 2){
+            low = 2;
+        }
+        ArrayList<Integer> prime = new ArrayList<>();
+        sS2(high, prime);
+        boolean[] mark = new boolean[high - low + 1];
+        Arrays.fill(mark, true);
+        for (int i = 0; i < prime.size(); i++) {
+            int loLim = (low / prime.get(i)) * prime.get(i);
+            if (loLim < low){
+                loLim += prime.get(i);
+            }
+            if (loLim == prime.get(i)){
+                loLim += prime.get(i);
+            }
+            for (int j = loLim; j <= high; j += prime.get(i)) {
+                mark[j - low] = false;
+            }
+        }
+        for (int i = low; i <= high; i++) {
+            if (mark[i - low]){
+                System.out.println(i);
+                res.add(i);
+            }
+        }
+    }
+    static void sS2(int limit, ArrayList<Integer> prime) {
+        int bound = (int)Math.sqrt(limit);
+        boolean[] mark = new boolean[bound + 1];
+        for (int i = 0; i <= bound; i++){
+            mark[i] = true;
+        }
+        for (int i = 2; i * i <= bound; i++) {
+            if (mark[i]) {
+                for (int j = i * i; j <= bound; j += i){
+                    mark[j] = false;
+                }
+            }
+        }
+        for (int i = 2; i <= bound; i++) {
+            if (mark[i]){
+                prime.add(i);
+            }
+        }
+    }
+    static boolean[] sieveOfEratosthenes(int n){
+        boolean[] prime = new boolean[n + 1];
+        Arrays.fill(prime,true);
+        prime[0]=false;prime[1]=false;
+        for (int p = 2; p * p <= n; p++) {
+            if(prime[p]){
+                for (int i = p * p; i <= n; i += p){
+                    prime[i] = false;
+                }
+            }
+        }
+        return prime;
+    }
+    static int highestPowerOf2(int n) {
+        if (n < 1){ return 0; }
+        int res = 1;
+        for (int i = 0; i < 8 * Integer.BYTES; i++) {
+            int curr = 1 << i;
+            if (curr > n){ break; }
+            res = curr;
+        }
+        return res;
+    }
+    static int reduceFraction(int x, int y) {
+        int d= gcd(x, y);
+        return x/d+y/d;
+    }
+    static boolean subset(int[] ar,int n,int sum){
+        if(sum==0){
+            return true;
+        }
+        if(n<0||sum<0){
+            return false;
+        }
+        return subset(ar,n-1,sum)||subset(ar,n-1,sum-ar[n]);
+    }
+    static boolean isPrime(int n){
+        if(n<=1) return false;
+        for(int i = 2;i<=Math.sqrt(n);i++){
+            if (n % i == 0) return false;
+        }
+        return true;
+    }
+    static int gcd(int a, int b) {
+        if (b == 0) return a;
+        return gcd(b, a % b);
+    }
+    static long gcd(long a, long b) {
+        if (b == 0) return a;
+        return gcd(b, a % b);
+    }
+    static long lcm(long a, long b) {
+        return (a * b) / gcd(a, b);
+    }
+    static int lcm(int a, int b) {
+        return (a * b) / gcd(a, b);
+    }
+    static boolean isPowerOfTwo(long n) {
+        if(n==0){
+            return false;
+        }
+        while (n%2==0){
+            n/=2;
+        }
+        return n==1;
+    }
+    static boolean isPerfectSquare(int x){
+        if (x >= 0) {
+            int sr = (int)Math.sqrt(x);
+            return ((sr * sr) == x);
+        }
+        return false;
+    }
+    static int lower_bound(int[] arr, int x) {
+        int low_limit = 0, high_limit = arr.length, mid;
+        while (low_limit < high_limit) {
+            mid = (low_limit + high_limit) / 2;
+            if (arr[mid] >= x){
+                high_limit = mid;
+            }else{
+                low_limit = mid + 1;
+            }
+        }
+        return low_limit;
+    }
+    static int upper_bound(int[] arr, int x) {
+        int low_limit = 0, high_limit = arr.length, mid;
+        while (low_limit < high_limit) {
+            mid = (low_limit + high_limit) / 2;
+            if (arr[mid] > x){
+                high_limit = mid;
+            }else{
+                low_limit = mid + 1;
+            }
+        }
+        return low_limit;
+    }
+    static int binarySearch(int[] ar,int n,int num){
+        int low=0,high=n-1;
+        while (low<=high){
+            int mid=(low+high)/2;
+            if(ar[mid]==num){
+                return mid;
+            }else if(ar[mid]>num){
+                high=mid-1;
+            }else {
+                low=mid+1;
+            }
+        }
+        return -1;
+    }
+    static int fib(int n) {
+        long[][] F = new long[][]{{1,1},{1,0}};
+        if (n == 0){
+            return 0;
+        }
+        power(F, n-1);
+        return (int)F[0][0];
+    }
+    static void multiply(long F[][], long M[][]) {
+        long x =  (F[0][0]*M[0][0])%1000000007 + (F[0][1]*M[1][0])%1000000007;
+        long y =  (F[0][0]*M[0][1])%1000000007 + (F[0][1]*M[1][1])%1000000007;
+        long z =  (F[1][0]*M[0][0])%1000000007 + (F[1][1]*M[1][0])%1000000007;
+        long w =  (F[1][0]*M[0][1])%1000000007 + (F[1][1]*M[1][1])%1000000007;
+        F[0][0] = x%1000000007;
+        F[0][1] = y%1000000007;
+        F[1][0] = z%1000000007;
+        F[1][1] = w%1000000007;
+    }
+    static void power(long F[][], int n) {
+        if( n == 0 || n == 1){
+            return;
+        }
+        long M[][] = new long[][]{{1,1},{1,0}};
+        power(F, n/2);
+        multiply(F, F);
+        if (n%2 != 0){
+            multiply(F, M);
+        }
+    }
+    static int binaryExponentiation(int x,int n){
+        int ans=1;
+        while (n>0){
+            if(n%2!=0){
+                ans=(ans*x)%MOD;
+            }
+            x=(x*x)%MOD;
+            n/=2;
+        }
+        return ans;
+    }
+    static void bfs(ArrayList<Integer>[] ar,int node){
+        boolean[] visited=new boolean[ar.length];
+        Queue<Integer> queue=new LinkedList<>();
+        visited[node]=true;
+        queue.add(node);
+        while(!queue.isEmpty()){
+            int nn=queue.poll();
+            System.out.print(nn+"" "");
+            for(int n : ar[nn]) {
+                if (!visited[n]) {
+                    visited[n] = true;
+                    queue.add(n);
+                }
+            }
+        }
+        System.out.println();
+    }
+    static void dfs(ArrayList<Integer>[] ar,int node){
+        boolean[] visited=new boolean[ar.length];
+        dfsUtil(ar,node,visited);
+        System.out.println();
+    }
+    static void dfsUtil(ArrayList<Integer>[] ar,int node,boolean[] visited){
+        visited[node]=true;
+        //System.out.print(node+"" "");
+        for(Integer n:ar[node]){
+            if(!visited[n]){
+                dfsUtil(ar,n,visited);
+            }
+        }
+    }
+}",0
+23594fdf,b185d034,"
+import java.io.*;
+import java.util.*;
+
+public class Main {
+
+  public static class StringPair implements Comparable{
+    String s;
+    Integer charCount;
+    public StringPair(String s, Integer charCount){
+      this.s = s;
+      this.charCount = charCount;
+    }
+
+    @Override
+    public int compareTo(Object o) {
+      StringPair f = (StringPair) o;
+
+      if(f.charCount < this.charCount){
+        return 1;
+      }
+      else if(f.charCount == this.charCount){
+        if(f.s.length() - f.charCount > this.s.length() - this.charCount){
+          return -1;
+        }
+        else if(f.s.length() - f.charCount < this.s.length() - this.charCount){
+          return 1;
+        }
+        else{
+          return 0;
+        }
+      }
+      else{
+        return -1;
+      }
+
+    }
+  }
+
+
+  public static void main(String[] args) throws IOException {
+    Scanner sc = new Scanner(System.in);
+    int t = sc.nextInt();
+    while (t-- > 0) {
+
+      int n = sc.nextInt();
+
+      String[] s = new String[n];
+
+      for(int i = 0 ; i < n ; i++){
+        s[i] = sc.next();
+      }
+
+      Integer[][] count = new Integer[n][5];
+      Integer[] totalCount = new Integer[5];
+
+      for(int i = 0 ; i < n ; i++){
+        for(int j = 0 ; j < 5 ; j++){
+          count[i][j]=0;
+        }
+      }
+      for(int i = 0 ; i < 5 ; i++){
+        totalCount[i] = 0;
+      }
+
+
+      Integer total = 0;
+
+      for(int i = 0 ; i < n ; i++){
+        for(int j = 0 ; j < s[i].length() ; j++){
+          int val = s[i].charAt(j) - 'a';
+          count[i][val]++;
+          totalCount[val]++;
+          total++;
+        }
+      }
+
+      //2*count[]char > len of total
+
+
+      int ans = -1;
+      for(int ch = 0 ; ch < 5 ; ch++){
+        List<StringPair> ls = new ArrayList<>();
+        for(int i = 0 ; i < n ; i++){
+          int c = s[i].length() - (2 * count[i][ch]);
+          ls.add(new StringPair(s[i],c));
+        }
+        Collections.sort(ls);
+
+        int finalCount = n;
+
+        int thisTotal = total;
+
+        int thisTotalCharcount = totalCount[ch];
+
+        int idx = n-1;
+
+        while(finalCount > ans && 2*thisTotalCharcount <= thisTotal && idx >= 0){//condition true){
+          thisTotal -= ls.get(idx).s.length();
+
+          thisTotalCharcount -= (ls.get(idx).s.length() - ls.get(idx).charCount)/2;
+          idx--;
+          finalCount--;
+        }
+        ans = Integer.max(ans,finalCount);
+      }
+
+      System.out.println(ans);
+    }
+  }
+}
+","import java.io.*;
+import java.util.*;
+public class A734C {
+    public static void main(String[] args) {
+        JS scan = new JS();
+        int t = scan.nextInt();
+        loop:while(t-->0){
+            int n = scan.nextInt();
+            String[] arr= new String[n];
+            Integer[][] counts = new Integer[5][n];
+            for(int i = 0;i<5;i++){
+                for(int j = 0;j<n;j++){
+                    counts[i][j] = 0;
+                }
+            }
+            for(int i =0;i<n;i++){
+                arr[i] = scan.next();
+                int[] freq =new int[5];
+                for(int j = 0;j<arr[i].length();j++){
+                    freq[arr[i].charAt(j)-'a']++;
+                }
+                for(int j = 0;j<5;j++){
+                    counts[j][i] = freq[j]-(arr[i].length()-freq[j]);
+                }
+            }
+            int best = 0;
+            for(int i = 0;i<5;i++){
+                Arrays.sort(counts[i]);
+                int curr = 0;
+                int extra = 0;
+                for(int j = n-1;j>=0;j--){
+                    extra+=counts[i][j];
+                    if(extra>0)curr++;
+                }
+                best = Math.max(best,curr);
+            }
+            System.out.println(best);
+
+        }
+    }
+    static class JS {
+        public int BS = 1 << 16;
+        public char NC = (char) 0;
+        byte[] buf = new byte[BS];
+        int bId = 0, size = 0;
+        char c = NC;
+        double num = 1;
+        BufferedInputStream in;
+
+        public JS() {
+            in = new BufferedInputStream(System.in, BS);
+        }
+
+        public JS(String s) throws FileNotFoundException {
+            in = new BufferedInputStream(new FileInputStream(new File(s)), BS);
+        }
+
+        public char nextChar() {
+            while (bId == size) {
+                try {
+                    size = in.read(buf);
+                } catch (Exception e) {
+                    return NC;
+                }
+                if (size == -1) return NC;
+                bId = 0;
+            }
+            return (char) buf[bId++];
+        }
+
+        public int nextInt() {
+            return (int) nextLong();
+        }
+
+        public long nextLong() {
+            num = 1;
+            boolean neg = false;
+            if (c == NC) c = nextChar();
+            for (; (c < '0' || c > '9'); c = nextChar()) {
+                if (c == '-') neg = true;
+            }
+            long res = 0;
+            for (; c >= '0' && c <= '9'; c = nextChar()) {
+                res = (res << 3) + (res << 1) + c - '0';
+                num *= 10;
+            }
+            return neg ? -res : res;
+        }
+
+        public double nextDouble() {
+            double cur = nextLong();
+            return c != '.' ? cur : cur + nextLong() / num;
+        }
+
+        public String next() {
+            StringBuilder res = new StringBuilder();
+            while (c <= 32) c = nextChar();
+            while (c > 32) {
+                res.append(c);
+                c = nextChar();
+            }
+            return res.toString();
+        }
+
+        public String nextLine() {
+            StringBuilder res = new StringBuilder();
+            while (c <= 32) c = nextChar();
+            while (c != '\n') {
+                res.append(c);
+                c = nextChar();
+            }
+            return res.toString();
+        }
+
+        public boolean hasNext() {
+            if (c > 32) return true;
+            while (true) {
+                c = nextChar();
+                if (c == NC) return false;
+                else if (c > 32) return true;
+            }
+        }
+    }
+}
+",0
+1d43139f,fdd41565,"
+import java.util.*;
+import java.io.*;
+public class experiment {
+	 static class FastReader {
+	        BufferedReader br;
+	        StringTokenizer st;
+	 
+	        public FastReader()
+	        {
+	            br = new BufferedReader(
+	                new InputStreamReader(System.in));
+	        }
+	 
+	        String next()
+	        {
+	            while (st == null || !st.hasMoreElements()) {
+	                try {
+	                    st = new StringTokenizer(br.readLine());
+	                }
+	                catch (IOException e) {
+	                    e.printStackTrace();
+	                }
+	            }
+	            return st.nextToken();
+	        }
+	 
+	        int nextInt() { return Integer.parseInt(next()); }
+	 
+	        long nextLong() { return Long.parseLong(next()); }
+	 
+	        double nextDouble()
+	        {
+	            return Double.parseDouble(next());
+	        }
+	 
+	        String nextLine()
+	        {
+	            String str = """";
+	            try {
+	                str = br.readLine();
+	            }
+	            catch (IOException e) {
+	                e.printStackTrace();
+	            }
+	            return str;
+	        }
+	    }
+	
+		 public static void main(String[] args) throws IOException  {
+			FastReader sc = new FastReader();
+			PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
+			int t = sc.nextInt();
+			while( t-- > 0) {
+				char arr[] = new char[5];
+				for( int i = 0 ;i< 5 ;i++) {
+					arr[i] = (char)(i + 97);
+				}
+				int n =sc.nextInt();
+				ArrayList<String> input = new ArrayList<>();
+				for( int i = 0 ;i< n;i++) {
+					input.add( sc.next());
+				}
+				int max = 0;
+				for( int i = 0 ; i< 5 ;i++) {
+					int test = 0;
+					int sum = 0;
+					char now = arr[i];
+					ArrayList<Integer> temp = new ArrayList<>();
+					for( int j = 0 ; j < input.size(); j++) {
+						int local = 0;
+						for( int k = 0 ; k < input.get(j).length(); k++) {
+							if( input.get(j).charAt(k) == now) {
+								local++;
+							}
+						}
+						temp.add( local - (input.get(j).length() - local));
+					}
+					Collections.sort(temp , Collections.reverseOrder());
+					//out.println( temp);
+					for( int j = 0 ; j < n ; j++) {
+						sum+=temp.get(j);
+						if( sum<=0) {
+							break;
+						}
+						test++;
+					}
+					max = Math.max(max, test);
+				}
+				out.println( max);
+			}
+			out.flush();
+				
+		 }
+}
+","import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.*;
+public class Main
+{
+    public static void main(String args[])
+    {
+     FastReader s=new FastReader();
+     int t=s.nextInt();
+     while(t>0)
+     {
+      Solve solve=new Solve();
+      t--;
+      int n=s.nextInt();
+      String str[]=new String[n];
+      for(int i=0;i<n;i++)
+      str[i]=s.nextLine();
+      char array[]=new char[]{'a','b','c','d','e'};
+      int arr[]=new int[n];
+      int ans=0;
+      for(int i=0;i<5;i++)
+      {
+        Arrays.fill(arr,0);
+          for(int j=0;j<n;j++)
+          {
+                 for(int k=0;k<str[j].length();k++)
+                 {
+                     if(str[j].charAt(k)==array[i])
+                     arr[j]++;
+                     else
+                     arr[j]--;
+                 }
+          }
+          ans=(ans>solve.solve(arr,n))?ans:solve.solve(arr,n);
+      }
+      System.out.println(ans);
+     }
+    }
+}
+class Solve{
+    public int solve(int arr[],int n)
+    {
+        int ans=0;
+        int sum=0;
+        Arrays.sort(arr);
+        for(int i=n-1;i>=0;i--)
+        {
+            if(sum+arr[i]>0)
+            {
+                sum+=arr[i];
+                ans++;
+            }
+            else
+            break;
+        }
+        return ans;
+    }
+}
+class FastReader {
+    BufferedReader br;
+    StringTokenizer st;
+    public FastReader()
+    {
+        br = new BufferedReader(
+                new InputStreamReader(System.in));
+    }
+    String next()
+    {
+        while (st == null || !st.hasMoreElements()) {
+            try {
+                st = new StringTokenizer(br.readLine());
+            }
+            catch (IOException e) {
+                e.printStackTrace();
+            }
+        }
+        return st.nextToken();
+    }
+
+    int nextInt() { return Integer.parseInt(next()); }
+
+    long nextLong() { return Long.parseLong(next()); }
+
+    double nextDouble()
+    {
+        return Double.parseDouble(next());
+    }
+
+    String nextLine()
+    {
+        String str = """";
+        try {
+            str = br.readLine();
+        }
+        catch (IOException e) {
+            e.printStackTrace();
+        }
+        return str;
+    }
+}
+",0
+0cedec8a,ac8acb97,"import java.io.OutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.PrintWriter;
+import java.util.Scanner;
+
+/**
+ * Built using CHelper plug-in
+ * Actual solution is at the top
+ */
+public class Main
+{
+    public static void main(String[] args)
+    {
+        InputStream inputStream = System.in;
+        OutputStream outputStream = System.out;
+        Scanner in = new Scanner(inputStream);
+        PrintWriter out = new PrintWriter(outputStream);
+        TaskC solver = new TaskC();
+        solver.solve(1, in, out);
+        out.close();
+    }
+
+    static class TaskC
+    {
+        public void solve(int testNumber, Scanner in, PrintWriter out)
+        {
+            int T = in.nextInt();
+            while (T-- > 0)
+            {
+                solveOne(in, out);
+            }
+        }
+
+        private void solveOne(Scanner in, PrintWriter out)
+        {
+            int N = in.nextInt();
+            int nums[] = L.readIntArray(N, in);
+            int min[] = new int[]{Integer.MAX_VALUE, Integer.MAX_VALUE};
+            int rem[] = new int[]{N, N};
+            long sum = 0;
+            long ans = Long.MAX_VALUE;
+            for (int idx = 0; idx < N; idx++)
+            {
+                min[idx % 2] = Math.min(min[idx % 2], nums[idx]);
+                rem[idx % 2]--;
+                sum += nums[idx];
+
+                long cur = sum + rem[0] * (long) min[0] + rem[1] * (long) min[1];
+                ans = Math.min(ans, cur);
+            }
+            out.println(ans);
+        }
+
+    }
+
+    static class L
+    {
+        public static int[] readIntArray(int size, Scanner in)
+        {
+            int[] array = new int[size];
+            for (int i = 0; i < size; i++)
+            {
+                array[i] = in.nextInt();
+            }
+            return array;
+        }
+
+    }
+}
+
+","import java.util.Scanner;
+
+public class C1499 {
+	public static void main(String[] args) {
+		Scanner in = new Scanner(System.in);
+		int t = in.nextInt();
+		while (t-- > 0) {
+			int n = in.nextInt();
+			// int[] arr = new int[n];
+			long[] mn = { Long.MAX_VALUE, Long.MAX_VALUE };
+			long[] rem = { n, n };
+			long sum = 0;
+			long ans = Long.MAX_VALUE;
+			for (int i = 0; i < n; i++) {
+				int temp = in.nextInt();
+				mn[i % 2] = Math.min(mn[i % 2], temp);
+				rem[i % 2]--;
+				sum += temp;
+				if (i > 0) {
+					long cur = sum + rem[0] * mn[0] + rem[1] * mn[1];
+					ans = Math.min(ans, cur);
+				}
+			}
+			System.out.println(ans);
+
+//			int a = Integer.MAX_VALUE;
+//			int aIndex = -1;
+//			int b = Integer.MAX_VALUE;
+//			int bIndex = -1;
+//
+//			for (int i = 0; i < n; i++) {
+//				arr[i] = in.nextInt();
+//				if (i % 2 == 0) {
+//					if (arr[i] < a) {
+//						a = arr[i];
+//						aIndex = i;
+//					}
+//				} else {
+//					if (arr[i] < b) {
+//						b = arr[i];
+//						bIndex = i;
+//					}
+//				}
+//			}
+//			int sum = 0;
+//			for (int i = 0; i < Math.max(bIndex, aIndex) + 1; i++) {
+//				if (i % 2 == 0) {
+//					if (i == aIndex) {
+//						if (aIndex < bIndex) {
+//							sum += (n - (i / 2) - ((bIndex - aIndex) / 2)) * arr[i];
+//						} else {
+//							sum += (n - (i / 2)) * arr[i];
+//						}
+//					} else {
+//						sum += arr[i];
+//					}
+//				} else {
+//					if (i == bIndex) {
+//						if (bIndex < aIndex) {
+//							sum += (n - (i / 2) - ((aIndex - bIndex) / 2)) * arr[i];
+//						} else {
+//							sum += (n - (i / 2)) * arr[i];
+//						}
+//					} else {
+//						sum += arr[i];
+//					}
+//				}
+//
+//			}
+//			System.out.println(sum);
+//			for (int i = 0; i < n; i++) {
+//				arr[i] = in.nextInt();
+//				if (arr[i] < a) {
+//					a = arr[i];
+//					aIndex = i;
+//
+//				}
+//
+//			}
+//			if (aIndex == 0) {
+//
+//				for (int i = 1; i < n; i++) {
+//					if (arr[i] < b) {
+//						b = arr[i];
+//						bIndex = i;
+//					}
+//				}
+//				System.out.println(aIndex + "" "" + bIndex);
+//				System.out.println(a + "" "" + b);
+//				int sum = 0;
+//				for (int i = 1; i < bIndex; i++) {
+//					sum += arr[i];
+//				}
+//				sum += b * (n - bIndex + 1);
+//				sum += a * n;
+//				System.out.println(sum);
+//			} else {
+//				int b = Integer.MAX_VALUE;
+//				int bIndex = -1;
+//				for (int i = 0; i < aIndex; i++) {
+//					if (arr[i] < b) {
+//						b = arr[i];
+//						bIndex = i;
+//					}
+//				}
+//				System.out.println(aIndex + "" "" + bIndex);
+//				System.out.println(a + "" "" + b);
+//				int sum = 0;
+//				for (int i = 0; i < bIndex; i++) {
+//					sum += arr[i];
+//				}
+//				sum += b * (n - bIndex);
+//				sum += a * n;
+//				System.out.println(sum);
+//			}
+
+		}
+	}
+}
+
+",1
+9f354c5c,cb032314,"
+import java.util.*;
+
+import java.io.*;
+import java.math.*;
+import java.sql.Array;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+
+
+
+public class Solution {
+	 private static class MyScanner {
+	        private static final int BUF_SIZE = 2048;
+	        BufferedReader br;
+	 
+	        private MyScanner() {
+	            br = new BufferedReader(new InputStreamReader(System.in));
+	        }
+	 
+	        private boolean isSpace(char c) {
+	            return c == '\n' || c == '\r' || c == ' ';
+	        }
+	 
+	        String next() {
+	            try {
+	                StringBuilder sb = new StringBuilder();
+	                int r;
+	                while ((r = br.read()) != -1 && isSpace((char)r));
+	                if (r == -1) {
+	                    return null;
+	                }
+	 
+	                sb.append((char) r);
+	                while ((r = br.read()) != -1 && !isSpace((char)r)) {
+	                    sb.append((char)r);
+	                }
+	                return sb.toString();
+	            } catch (IOException e) {
+	                e.printStackTrace();
+	            }
+	            return null;
+	        }
+	 
+	        int nextInt() {
+	            return Integer.parseInt(next());
+	        }
+	 
+	        long nextLong() {
+	            return Long.parseLong(next());
+	        }
+	 
+	        double nextDouble() {
+	            return Double.parseDouble(next());
+	        }
+	    }
+	  static class Reader{
+		  
+			BufferedReader br;
+			StringTokenizer st;
+			public Reader() {
+				br = new BufferedReader(new InputStreamReader(System.in));
+			}
+			String next() 
+		    { 
+		        while (st == null || !st.hasMoreElements()) 
+		        { 
+		            try
+		            { 
+		                st = new StringTokenizer(br.readLine()); 
+		            } 
+		            catch (IOException  e) 
+		            { 
+		                e.printStackTrace(); 
+		            } 
+		        } 
+		        return st.nextToken(); 
+		    } 
+
+		    int nextInt() 
+		    { 
+		        return Integer.parseInt(next()); 
+		    } 
+
+		    long nextLong() 
+		    { 
+		        return Long.parseLong(next()); 
+		    } 
+
+		    double nextDouble() 
+		    { 
+		        return Double.parseDouble(next()); 
+		    } 
+
+		    String nextLine() 
+		    { 
+		        String str = """"; 
+		        try
+		        { 
+		            str = br.readLine(); 
+		        } 
+		        catch (IOException e) 
+		        { 
+		            e.printStackTrace(); 
+		        } 
+		        return str; 
+		    } 
+		}
+	 
+	  static long mod = (long)(1e9 + 7);
+	 
+	static void sort(long[] arr ) {
+		 ArrayList<Long> al = new ArrayList<>();
+		 for(long e:arr) al.add(e);
+		 Collections.sort(al);
+		 for(int i = 0 ; i<al.size(); i++) arr[i] = al.get(i);
+	 }
+	static void sort(int[] arr ) {
+		 ArrayList<Integer> al = new ArrayList<>();
+		 for(int e:arr) al.add(e);
+		 Collections.sort(al);
+		 for(int i = 0 ; i<al.size(); i++) arr[i] = al.get(i);
+	 }
+	
+	static void sort(char[] arr) {
+		ArrayList<Character> al = new ArrayList<Character>();
+		for(char cc:arr) al.add(cc);
+		Collections.sort(al);
+		for(int i = 0 ;i<arr.length ;i++) arr[i] = al.get(i);
+	}
+
+	static long mod_mul(  long... a) {
+		long ans = a[0]%mod;
+		for(int i = 1 ; i<a.length ; i++) {
+			ans = (ans * (a[i]%mod))%mod;
+		}
+		
+		return ans;
+	}
+	static long mod_sum( long... a) {
+		long ans = 0;
+		for(long e:a) {
+			ans = (ans + e)%mod;
+		}
+		return ans;
+	}
+	 static long gcd(long a, long b)
+	  {      
+	     if (b == 0)
+	        return a;
+	     return gcd(b, a % b); 
+	  }
+	 static boolean[] prime(int num) {
+			boolean[] bool = new boolean[num];
+		     
+		      for (int i = 0; i< bool.length; i++) {
+		         bool[i] = true;
+		      }
+		      for (int i = 2; i< Math.sqrt(num); i++) {
+		         if(bool[i] == true) {
+		            for(int j = (i*i); j<num; j = j+i) {
+		               bool[j] = false;
+		            }
+		         }
+		      }
+		      if(num >= 0) {
+		    	  bool[0] = false;
+		    	  bool[1] = false;
+		      }
+		      
+		      return bool;
+		}
+
+	 static long modInverse(long a, long m)
+	    {
+	        long g = gcd(a, m);
+	       
+	          return   power(a, m - 2, m);
+	        
+	    }
+	   static long lcm(long a , long b) {
+		   return (a*b)/gcd(a, b);
+	   }
+	   static int lcm(int a , int b) {
+		   return (int)((a*b)/gcd(a, b));
+	   }
+	 static long power(long x, long y, long m){
+	        if (y == 0) return 1; long p = power(x, y / 2, m) % m; p = (int)((p * (long)p) % m);
+	        if (y % 2 == 0) return p; else return (int)((x * (long)p) % m); }
+	   
+     static class Combinations{
+	    	 private long[] z;
+	    	 private long[] z1;
+	    	 private long[] z2;
+	    	 private long mod;
+	    	  public Combinations(long N , long mod) {
+	    		  this.mod = mod;
+				z = new long[(int)N+1];
+				z1 = new long[(int)N+1];
+				z[0] = 1;
+				for(int i =1 ; i<=N ; i++) z[i] = (z[i-1]*i)%mod;
+			     z2 = new long[(int)N+1];
+				z2[0] = z2[1] = 1;
+			    for (int i = 2; i <= N; i++)
+			        z2[i] = z2[(int)(mod % i)] * (mod - mod / i) % mod;
+			    
+			    
+			    z1[0] = z1[1] = 1;
+			    
+			    for (int i = 2; i <= N; i++)
+			        z1[i] = (z2[i] * z1[i - 1]) % mod;
+			}
+	    	  long fac(long n) {
+	    		  return z[(int)n];
+	    	  }
+	    	  long invrsNum(long n) {
+	    		  return z2[(int)n];
+	    	  }
+	    	  long invrsFac(long n) {
+	    		  return invrsFac((int)n);
+	    	  }
+	    	  long ncr(long N, long R)
+	    	  {		if(R<0 || R>N ) return 0;
+	    		    long ans = ((z[(int)N] * z1[(int)R])
+	    		              % mod * z1[(int)(N - R)])
+	    		             % mod;
+	    		    return ans;
+	    		}
+	      }
+	      static class DisjointUnionSets {
+			    int[] rank, parent;
+			    int n;
+			  
+			    public DisjointUnionSets(int n)
+			    {
+			        rank = new int[n];
+			        parent = new int[n];
+			        this.n = n;
+			        makeSet();
+			    }
+			  
+			    void makeSet()
+			    {
+			        for (int i = 0; i < n; i++) {
+			          
+			            parent[i] = i;
+			        }
+			    }
+			  
+			    int find(int x)
+			    {
+			        if (parent[x] != x) {
+			        
+			            parent[x] = find(parent[x]);
+			  
+			        }
+			  
+			        return parent[x];
+			    }
+			  
+			    void union(int x, int y)
+			    {
+			        int xRoot = find(x), yRoot = find(y);
+			  
+			        if (xRoot == yRoot)
+			            return;
+			  
+			        if (rank[xRoot] < rank[yRoot])
+			  
+			            parent[xRoot] = yRoot;
+			  
+			        else if (rank[yRoot] < rank[xRoot])
+			  
+			            parent[yRoot] = xRoot;
+			  
+			        else
+			        {
+			            parent[yRoot] = xRoot;
+			  
+			            rank[xRoot] = rank[xRoot] + 1;
+			        }
+			    }
+			}
+	      static int max(int... a ) {
+	    	  int max = a[0];
+	    	  for(int e:a) max = Math.max(max, e);
+	    	  return max;
+	      }
+	      static long max(long... a ) {
+	    	  long max = a[0];
+	    	  for(long e:a) max = Math.max(max, e);
+	    	  return max;
+	      }
+	      static int min(int... a ) {
+	    	  int min = a[0];
+	    	  for(int e:a) min = Math.min(e, min);
+	    	  return min;
+	      }
+	      static long min(long... a ) {
+	    	  long min = a[0];
+	    	  for(long e:a) min = Math.min(e, min);
+	    	  return min;
+	      }
+	      static int[] KMP(String str) {
+	    	  int n = str.length();
+	    	  int[] kmp = new int[n];
+	    	  for(int i = 1 ; i<n ; i++) {
+	    		  int j = kmp[i-1];
+	    		  while(j>0 && str.charAt(i) != str.charAt(j)) {
+	    			  j = kmp[j-1];
+	    		  }
+	    		  if(str.charAt(i) == str.charAt(j)) j++;
+	    		  kmp[i] = j;
+	    	  }
+	    	  
+	    	  return kmp;
+	      }
+	      
+	      
+/************************************************ Query **************************************************************************************/	  
+	 
+/***************************************** 		Sparse Table	********************************************************/
+	      static class SparseTable{
+	    		
+	    		private long[][] st;
+	    		
+	    		SparseTable(long[] arr){
+	    			int n = arr.length;
+	    			st = new long[n][25];
+	    			log = new int[n+2];
+	    			build_log(n+1);
+	    			build(arr);
+	    		}
+	    		
+	    		private void build(long[] arr) {
+	    			int n = arr.length;
+	    			
+	    			for(int i = n-1 ; i>=0 ; i--) {
+	    				for(int j = 0 ; j<25 ; j++) {
+	    					int r = i + (1<<j)-1;
+	    					if(r>=n) break;
+	    					if(j == 0 ) st[i][j] = arr[i];
+	    					else st[i][j] = Math.min(st[i][j-1] , st[ i + ( 1 << (j-1) ) ][ j-1 ] );
+	    				}
+	    			}
+	    		}
+	    		public long gcd(long a  ,long b) {
+	    			if(a == 0) return b;
+	    			return gcd(b%a , a);
+	    		}
+	    		public long query(int l ,int r) {
+	    			int w = r-l+1;
+	    			int power = log[w];
+	    			return Math.min(st[l][power],st[r - (1<<power) + 1][power]);
+	    		}
+	    		private int[] log;
+	    		void build_log(int n) {
+	    			log[1] = 0;
+	    			for(int i = 2 ; i<=n ; i++) {
+	    				log[i] = 1 + log[i/2];
+	    			}
+	    		}
+	    	}
+	      
+	      
+/********************************************************	Segement Tree	*****************************************************/
+/**
+	 	 static class SegmentTree{
+			 long[] tree;
+			 long[] arr;
+			 int n;
+			 SegmentTree(long[] arr){
+				 this.n = arr.length;
+				 tree = new long[4*n+1];
+				 this.arr = arr;
+				 buildTree(0, n-1, 1);
+			 }
+			 
+			 
+			  void buildTree(int s ,int e  ,int index ) {
+					if(s == e) {
+						tree[index] = arr[s];
+						return;
+					}
+				
+					int mid = (s+e)/2;
+					
+					buildTree( s,  mid, 2*index);
+					buildTree( mid+1, e, 2*index+1);
+					
+					tree[index] = Math.min(tree[2*index] , tree[2*index+1]);
+				}
+			  
+			 long query(int si ,int ei) {
+				 return query(0 ,n-1 , si ,ei , 1   );
+			 }
+			 private long query( int ss ,int se ,int qs , int qe,int index) {
+					
+					if(ss>=qs && se<=qe) return tree[index];
+					
+					if(qe<ss || se<qs) return (long)(1e17);
+					
+					int mid = (ss + se)/2;
+					long left = query( ss , mid , qs ,qe , 2*index);
+					long right= query(mid + 1 , se , qs ,qe , 2*index+1);
+					return Math.min(left, right);
+				}
+			 public void update(int index , int val) {
+				 arr[index] = val;
+				 for(long e:arr) System.out.print(e+"" "");
+				 update(index , 0 , n-1 , 1);
+			 }
+			 private void update(int id ,int si , int ei , int index) {
+				 if(id < si || id>ei) return;
+				 if(si == ei ) { 
+					 tree[index] = arr[id];
+					 return;
+				 }
+				 if(si > ei) return;
+				 int mid = (ei + si)/2;
+					
+					update( id,  si, mid , 2*index);
+					update( id , mid+1, ei , 2*index+1);
+					
+					tree[index] = Math.min(tree[2*index] ,tree[2*index+1]);
+			 }
+			  
+		 }
+		 */
+
+/* ***************************************************************************************************************************************************/	 
+	 
+//	      static MyScanner sc = new MyScanner(); // only in case of less memory
+	      static Reader sc = new Reader();
+	 static StringBuilder sb = new StringBuilder();
+	 public static void main(String args[]) throws IOException {
+
+		 int tc = 1;
+		  tc = sc.nextInt();
+
+		 for(int i = 1 ; i<=tc ; i++) {
+
+//			 sb.append(""Case #"" + i + "": ""  );	// During KickStart && HackerCup
+			 TEST_CASE();
+			  
+		 }
+		 System.out.println(sb);
+	 }
+
+	 static void TEST_CASE() {
+		int n = sc.nextInt();
+		ArrayList<ArrayList<Integer>> adj = new ArrayList<>();
+		for(int i =0 ; i<n ; i++) adj.add(new ArrayList<>());
+		int[] U = new int[n-1] , V = new int[n-1];
+		for(int i = 0 ; i<n-1 ; i++) {
+			int u = sc.nextInt()-1 , v = sc.nextInt()-1;
+			U[i] = u; V[i] = v;
+			adj.get(u).add(v);
+			adj.get(v).add(u);
+		}
+		int ind = -1;
+		for(int i =0 ; i<n ; i++) {
+			if(adj.get(i).size()>2) {
+				sb.append(""-1\n"");
+				return;
+			}
+			if(adj.get(i).size() == 1) {
+				ind = i;
+			}
+		}
+		Map<String , Integer> map = new HashMap<>();
+		dfs(adj, ind, -1, true, map);
+		for(int i =0 ; i<n-1 ; i++) {
+		 int u = U[i];
+		 int v = V[i];
+		 if(map.containsKey(u+"" ""+v)) sb.append(map.get(u+"" ""+v)+"" "");
+		 else sb.append(map.get(v+"" ""+u)+"" "");
+		}
+		sb.append(""\n"");
+		
+	 }
+	 static void dfs(ArrayList<ArrayList<Integer>> adj ,int u , int p ,boolean eve ,Map<String , Integer> map ) {
+		 if(eve) {
+			 map.put(u+"" ""+p, 2);
+		 }else {
+			 map.put(u+"" ""+p, 3);
+		 }
+		 for(int v:adj.get(u)) {
+			 if(v == p) continue;
+			 eve = !eve;
+			 dfs(adj, v, u, eve, map);
+		 }
+	 }
+	}
+/*******************************************************************************************************************************************************/
+
+/**
+1
+		
+ */
+
+ 
+
+","
+
+import java.io.*;
+import java.util.*;
+
+public class C {
+
+    static FastScanner sc = new FastScanner();
+    static PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
+    static class pair{
+        public pair(int x, int y) {
+            this.x = x;
+            this.y = y;
+        }
+
+        int x;
+        int y;
+        @Override
+        public boolean equals(Object o) {
+            if (this == o) return true;
+            if (o == null || getClass() != o.getClass()) return false;
+            pair pair = (pair) o;
+            return x == pair.x && y == pair.y;
+        }
+
+        @Override
+        public int hashCode() {
+            return Objects.hash(x, y);
+        }
+    }
+    static void solve(){
+        int n = sc.nextInt();
+        int[]degree = new int[n];
+        List<Integer>[]grid = new List[n];
+        for (int i = 0; i < n; i++) {
+            grid[i] = new ArrayList();
+        }
+        List<pair>list = new ArrayList<>();
+        for (int i = 0; i < n - 1; i++) {
+            int x = sc.nextInt() - 1;
+            int y = sc.nextInt() - 1;
+            grid[x].add(y);
+            grid[y].add(x);
+            degree[x]++;
+            degree[y]++;
+            list.add(new pair(Math.min(x,y),Math.max(x,y)));
+        }
+        int begin = 0;
+        for(int i = 0;i < degree.length;i++){
+            if(degree[i] > 2){
+                System.out.println(-1);
+                return;
+            }
+            if(degree[i] == 1){
+                begin = i;
+            }
+        }
+        boolean[]used = new boolean[n];
+        int[]p = new int[]{5,2,11,2};
+        int idx = 0;
+        HashMap<pair,Integer>map = new HashMap<>();
+        while (!used[begin]){
+            used[begin] = true;
+            for(int next : grid[begin]){
+                if(used[next])
+                    continue;
+                map.put(new pair(Math.min(begin,next),Math.max(begin,next)),p[idx % 4]);
+                idx++;
+                begin = next;
+            }
+        }
+        StringBuilder bd = new StringBuilder();
+        for(pair pp : list){
+            bd.append(map.get(pp) + "" "");
+        }
+        System.out.println(bd.toString().trim());
+    }
+
+    public static void main(String[] args) {
+        int n = sc.nextInt();
+        for(int i = 0;i < n;i++){
+            solve();
+        }
+    }
+
+    static class FastScanner {
+        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st=new StringTokenizer("""");
+        String next() {
+            while (!st.hasMoreTokens())
+                try {
+                    st=new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+        int[] readArray(int n) {
+            int[] a=new int[n];
+            for (int i=0; i<n; i++) a[i]=nextInt();
+            return a;
+        }
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+    }
+}
+
+",0
+d23b398c,e14d1ba0,"import java.util.*;
+import java.io.*;
+ 
+public class minimum_grid_path {
+ 
+    public static void main(String[] args) throws IOException{
+    	BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
+    	
+    	StringTokenizer line = new StringTokenizer(in.readLine());
+    	
+        int t = Integer.parseInt(line.nextToken());
+        
+        for(int i1=0;i1<t;i1++) {
+        	
+        	line = new StringTokenizer(in.readLine());
+        	
+            int n = Integer.parseInt(line.nextToken());
+	
+			long[] ar = new long[n];
+			
+			line = new StringTokenizer(in.readLine());
+			
+			for(int i=0;i<n;i++) {
+				ar[i] = Long.parseLong(line.nextToken());
+				
+			}
+			
+			long[] ans=new long[n];
+			ans[0]=ar[0]*n;
+			long m=ar[0];
+			long s1=ar[0];
+			for(int i=2;i<n;i+=2) {
+				if(m>ar[i]) {
+					m=ar[i];
+				}
+				s1+=ar[i];
+				ans[i]=s1-m+m*(n-i/2);
+
+		 
+			}
+			
+			ans[1]=ar[1]*n;
+			 m=ar[1];
+			 s1=ar[1];
+			 
+			for(int i=3;i<n;i+=2) {
+				if(m>ar[i]) {
+					m=ar[i];
+				}
+				s1+=ar[i];
+				ans[i]=s1-m+m*(n-i/2);
+			}
+			
+			long mini=ans[0]+ans[1];
+			for(int i=1;i<n-1;i++) {
+				mini=Math.min(ans[i]+ans[i+1],mini);
+			}
+			
+			System.out.println(mini);
+			
+        }
+    }
+	
+}
+","import java.util.*;
+public class ss
+{
+    public static void main(String[]args)
+    {
+        Scanner in=new Scanner (System.in);
+        int t=in.nextInt();
+        for(int i1=0;i1<t;i1++)
+        {
+            int n=in.nextInt();
+	
+	long[] ar=new long[n];
+	
+	for(int i=0;i<n;i++)
+	{
+		ar[i]=in.nextLong();
+		
+	}
+	
+	long[] ans=new long[n];
+	ans[0]=ar[0]*n;
+	long m=ar[0];
+	long s1=ar[0];
+	for(int i=2;i<n;i+=2)
+	{
+		if(m>ar[i])
+		{
+			m=ar[i];
+		}
+		s1+=ar[i];
+		ans[i]=s1-m+m*(n-i/2);
+ 
+		
+ 
+ 
+	}
+	ans[1]=ar[1]*n;
+	 m=ar[1];
+	 s1=ar[1];
+	for(int i=3;i<n;i+=2)
+	{
+		if(m>ar[i])
+		{
+			m=ar[i];
+		}
+		s1+=ar[i];
+		ans[i]=s1-m+m*(n-i/2);
+	}
+	long mini=ans[0]+ans[1];
+	for(int i=1;i<n-1;i++)
+	{
+		mini=Math.min(ans[i]+ans[i+1],mini);
+	}
+	System.out.println(mini);
+}
+}
+}
+
+",1
+4241f473,77448a05,"import java.io.*;
+import java.util.*;
+
+public class C {
+	
+	public static void main(String[] args)throws IOException {
+		
+		FastScanner scan = new FastScanner();
+		BufferedWriter output = new BufferedWriter(new OutputStreamWriter(System.out));
+		int t = scan.nextInt();
+		for(int tt = 0;tt<t;tt++) {
+			
+			int n = scan.nextInt();
+			ArrayList<String> arr = new ArrayList<>();
+			for(int i = 0;i<n;i++) arr.add(scan.next());
+			int max = -1;
+			for(int cases = 0;cases<5;cases++) {
+				ArrayList<Integer> list = new ArrayList<>();
+				char ch = (char)('a'+cases);
+				for(int i = 0;i<n;i++) {
+					String s = arr.get(i);
+					int countch = 0, countTotal = 0;
+					for(int j = 0;j<s.length();j++) {
+						if(s.charAt(j)==ch) countch++;
+						else countTotal++;
+					}
+					list.add(countch-countTotal);
+				}
+				Collections.sort(list);
+				int sum = 0, count = 0;
+				for(int i = n-1;i>=0;i--) {
+					sum+=list.get(i);
+					if(sum>0) count++;
+					else break;
+				}
+				max = Math.max(max, count);
+			}
+			output.write(max+""\n"");
+		}
+		output.flush();
+
+	}
+
+	public static int[] sort(int arr[]) {
+
+		List<Integer> list = new ArrayList<>();
+		for(int i:arr)
+			list.add(i);
+		Collections.sort(list);
+		for(int i = 0;i<list.size();i++) {
+			arr[i] = list.get(i);
+		}
+		return arr;
+
+	}
+	
+	public static int gcd(int a, int b) {
+		if(a == 0) return b;
+		return gcd(b%a, a);
+	}
+	
+	static class FastScanner {
+		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st=new StringTokenizer("""");
+		String next() {
+			while (!st.hasMoreTokens())
+				try {
+					st=new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			return st.nextToken();
+		}
+
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+		int[] readArray(int n) {
+			int[] a=new int[n];
+			for (int i=0; i<n; i++) a[i]=nextInt();
+			return a;
+		}
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+		
+		double nextDouble() {
+			return Double.parseDouble(next());
+		}
+	}
+
+}
+","//package currentContest;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Random;
+import java.util.StringTokenizer;
+
+public class P4 {
+	static int N = 1000001;
+
+	// Array to store inverse of 1 to N
+	static long[] factorialNumInverse = new long[N + 1];
+
+	// Array to precompute inverse of 1! to N!
+	static long[] naturalNumInverse = new long[N + 1];
+
+	// Array to store factorial of first N numbers
+	static long[] fact = new long[N + 1];
+
+	// Function to precompute inverse of numbers
+	public static void InverseofNumber(int p) {
+		naturalNumInverse[0] = naturalNumInverse[1] = 1;
+
+		for (int i = 2; i <= N; i++)
+			naturalNumInverse[i] = naturalNumInverse[p % i] * (long) (p - p / i) % p;
+	}
+
+	// Function to precompute inverse of factorials
+	public static void InverseofFactorial(int p) {
+		factorialNumInverse[0] = factorialNumInverse[1] = 1;
+
+		// Precompute inverse of natural numbers
+		for (int i = 2; i <= N; i++)
+			factorialNumInverse[i] = (naturalNumInverse[i] * factorialNumInverse[i - 1]) % p;
+	}
+
+	// Function to calculate factorial of 1 to N
+	public static void factorial(int p) {
+		fact[0] = 1;
+
+		// Precompute factorials
+		for (int i = 1; i <= N; i++) {
+			fact[i] = (fact[i - 1] * (long) i) % p;
+		}
+	}
+
+	// Function to return nCr % p in O(1) time
+	public static long Binomial(int N, int R, int p) {
+
+		// n C r = n!*inverse(r!)*inverse((n-r)!)
+		long ans = ((fact[N] * factorialNumInverse[R]) % p * factorialNumInverse[N - R]) % p;
+
+		return ans;
+	}
+
+	public static void main(String[] args) {
+		// TODO Auto-generated method stub
+		FastReader sc = new FastReader();
+		int t;
+		t = sc.nextInt();
+		StringBuilder st = new StringBuilder();
+//		int p = 998244353;
+//	    InverseofNumber(p);
+//	    InverseofFactorial(p);
+//	    factorial(p);
+		// System.out.println(3|1);
+		while (t-- != 0) {
+			int n=sc.nextInt();
+			String s[]=new String[n];
+			for(int i=0;i<n;i++) {
+				s[i]=sc.nextLine();
+			}
+			int max=0;
+			ArrayList<Integer> freq=new ArrayList<>();
+			for(int i=0;i<5;i++) {
+				int f1=0;
+				freq=new ArrayList<>();
+				for(int j=0;j<n;j++) {
+					f1=0;
+					for(int k=0;k<s[j].length();k++) {
+						if(s[j].charAt(k)==i+'a') {
+							f1++;
+						}else {
+							f1--;
+						}
+					}
+					freq.add(f1);
+				}
+				Collections.sort(freq);
+				int x=0;
+				int total=0;
+				for(int j=n-1;j>=0;j--) {
+					total=total+freq.get(j);
+					if(total>0) {
+						x++;
+					}else {
+						break;
+					}
+				}
+				max=Math.max(max, x);
+			}
+			st.append(max+""\n"");
+		}
+		System.out.println(st);
+	}
+
+	static FastReader sc = new FastReader();
+
+	public static void solvegraph() {
+		int n = sc.nextInt();
+
+		int edge[][] = new int[n - 1][2];
+		for (int i = 0; i < n - 1; i++) {
+			edge[i][0] = sc.nextInt() - 1;
+			edge[i][1] = sc.nextInt() - 1;
+		}
+		ArrayList<ArrayList<Integer>> ad = new ArrayList<>();
+		for (int i = 0; i < n; i++) {
+			ad.add(new ArrayList<Integer>());
+		}
+		for (int i = 0; i < n - 1; i++) {
+			ad.get(edge[i][0]).add(edge[i][1]);
+			ad.get(edge[i][1]).add(edge[i][0]);
+		}
+		int parent[] = new int[n];
+		Arrays.fill(parent, -1);
+		parent[0] = n;
+		ArrayDeque<Integer> queue = new ArrayDeque<>();
+		queue.add(0);
+		int child[] = new int[n];
+		Arrays.fill(child, 0);
+		ArrayList<Integer> lv = new ArrayList<Integer>();
+		while (!queue.isEmpty()) {
+			int toget = queue.getFirst();
+			queue.removeFirst();
+			child[toget] = ad.get(toget).size() - 1;
+			for (int i = 0; i < ad.get(toget).size(); i++) {
+				if (parent[ad.get(toget).get(i)] == -1) {
+					parent[ad.get(toget).get(i)] = toget;
+					queue.addLast(ad.get(toget).get(i));
+				}
+			}
+			lv.add(toget);
+		}
+
+		child[0]++;
+	}
+
+	static void sort(int[] A) {
+		int n = A.length;
+		Random rnd = new Random();
+		for (int i = 0; i < n; ++i) {
+			int tmp = A[i];
+			int randomPos = i + rnd.nextInt(n - i);
+			A[i] = A[randomPos];
+			A[randomPos] = tmp;
+		}
+		Arrays.sort(A);
+	}
+
+	static void sort(long[] A) {
+		int n = A.length;
+		Random rnd = new Random();
+		for (int i = 0; i < n; ++i) {
+			long tmp = A[i];
+			int randomPos = i + rnd.nextInt(n - i);
+			A[i] = A[randomPos];
+			A[randomPos] = tmp;
+		}
+		Arrays.sort(A);
+	}
+
+	static String sort(String s) {
+		Character ch[] = new Character[s.length()];
+		for (int i = 0; i < s.length(); i++) {
+			ch[i] = s.charAt(i);
+		}
+		Arrays.sort(ch);
+		StringBuffer st = new StringBuffer("""");
+		for (int i = 0; i < s.length(); i++) {
+			st.append(ch[i]);
+		}
+		return st.toString();
+	}
+
+	public static long gcd(long a, long b) {
+		if (a == 0) {
+			return b;
+		}
+		return gcd(b % a, a);
+	}
+
+	static class FastReader {
+		BufferedReader br;
+		StringTokenizer st;
+
+		public FastReader() {
+			br = new BufferedReader(new InputStreamReader(System.in));
+		}
+
+		String next() {
+			while (st == null || !st.hasMoreElements()) {
+				try {
+					st = new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			}
+			return st.nextToken();
+		}
+
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+
+		double nextDouble() {
+			return Double.parseDouble(next());
+		}
+
+		String nextLine() {
+			String str = """";
+			try {
+				str = br.readLine();
+			} catch (IOException e) {
+				e.printStackTrace();
+			}
+			return str;
+		}
+	}
+}
+",1
+565f77b7,e8006510,"import java.util.*;
+import java.io.*;
+
+public class Solution {
+
+	static Scanner scn = new Scanner(System.in);
+	static PrintWriter out = new PrintWriter(System.out);
+	static StringBuilder sb = new StringBuilder();
+
+	public static void main(String[] HastaLaVistaLa) {
+		int t = scn.nextInt();
+		while(t-- > 0) solve();
+		out.println(sb);
+		out.close();
+	}
+
+	public static void solve() {
+		// Road To Specialist Day 3
+		int n = scn.nextInt(), m = scn.nextInt(), x = scn.nextInt();
+		int[] a = new int[n], ans = new int[n];
+		for(int i = 0; i < n; i++) a[i] = scn.nextInt();
+		PriorityQueue<Pair> pq = new PriorityQueue<>();
+		for(int i = 0; i < m; i++) pq.add(new Pair(0L, i));
+		for(int i = 0; i < n; i++) {
+			int e = a[i];
+			Pair p = pq.poll();
+			p.value += e;
+			pq.add(p);
+			ans[i] = p.id + 1;
+		}
+		boolean check = false;
+		long prev = pq.poll().value;
+		while(!pq.isEmpty()) {
+			long cur = pq.poll().value;
+			if(Math.abs(cur - prev) > x) check = true;
+			prev = cur;
+		}
+		if(check) sb.append(""NO"");
+		else {
+			sb.append(""YES\n"");
+			for(int i : ans) sb.append(i + "" "");
+		}
+		sb.append(""\n"");
+	}
+	static class Pair implements Comparable<Pair> {
+		int id;
+		long value;
+		public Pair(long value, int id) {
+			this.id = id;
+			this.value = value;
+		}
+		public int compareTo(Pair o) {
+			return Long.compare(value, o.value);
+		}
+	}
+}","import java.io.*;
+import java.util.*;
+
+public class C14G {
+
+    public static void main(String[] args) throws IOException {
+        init_io();
+        int t = nint();
+        while(t-- > 0) {
+            int N = nint(), M = nint(), X = nint();
+            int[] ans = new int[N];
+            TreeSet<Tower> pq = new TreeSet<>();
+            Block[] blocks = new Block[N];
+            for (int i = 0; i < N; i++) {
+                blocks[i] = new Block(i, nint());
+            }
+            Arrays.sort(blocks);
+            for (int i = 0; i < M; i++) {
+                pq.add(new Tower(i));
+            }
+            for (int i = 0; i < N; i++) {
+                Tower ct = pq.pollFirst();
+                ans[blocks[i].idx] = ct.idx;
+                ct.sum += blocks[i].height;
+                pq.add(ct);
+            }
+            if (pq.last().sum - pq.first().sum > X) {
+                out.println(""NO"");
+            }
+            else {
+                out.println(""YES"");
+                for (int i = 0; i < N; i++) {
+                    out.print(ans[i]+1);
+                    out.print("" "");
+                }
+                out.println();
+            }
+        }
+        out.close();
+    }
+    static class Block implements Comparable<Block> {
+        int idx, height;
+        public Block(int idx, int height) {
+            this.idx = idx; this.height = height;
+        }
+        public int compareTo(Block b) {
+            return b.height - height;
+        }
+    }
+    static class Tower implements Comparable<Tower> {
+        int idx;
+        int sum;
+        public Tower(int idx) {
+            this.idx = idx;
+        }
+        public int compareTo(Tower t) {
+            return sum == t.sum ? idx - t.idx : sum - t.sum;
+        }
+    }
+    static StreamTokenizer in;
+    static PrintWriter out;
+    static BufferedReader br;
+
+    static int nint() throws IOException {
+        in.nextToken();
+        return (int) in.nval;
+    }
+
+    static void init_io() throws IOException {
+        br = new BufferedReader(new InputStreamReader(System.in));
+        in = new StreamTokenizer(br);
+        out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
+    }
+}",0
+10013f73,a8f7c8b7,"import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.StringTokenizer;
+
+public class Menorah {
+	
+	static class FastReader {
+		
+        BufferedReader br;
+        StringTokenizer st;
+ 
+        public FastReader()
+        {
+            br = new BufferedReader(
+                new InputStreamReader(System.in));
+        }
+ 
+        String next()
+        {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                }
+                catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+ 
+        int nextInt() { return Integer.parseInt(next()); }
+ 
+        long nextLong() { return Long.parseLong(next()); }
+        
+        double nextFloat() { return Float.parseFloat(next()); }
+ 
+        double nextDouble() { return Double.parseDouble(next()); }
+ 
+        String nextLine()
+        {
+            String str = """";
+            try {
+                str = br.readLine();
+            }
+            catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+        }
+        
+        int[] nextArray(int n)
+        {
+        	int[] a = new int[n];
+        	for (int i=0; i<n; i++) {
+        		a[i] = this.nextInt();
+        	}
+        	return a;
+        }
+        
+        long[] nextArrayLong(int n)
+        {
+        	long[] a = new long[n];
+        	for (int i=0; i<n; i++) {
+        		a[i] = this.nextLong();
+        	}
+        	return a;
+        }
+        
+    }
+	
+	public static void solve(int n, String a, String b) {
+		
+		int bothOne = 0;
+		int bothZero = 0;
+		int oneZero = 0;
+		int zeroOne = 0;
+		for (int i=0; i<n; i++) {
+			if (a.charAt(i) == '0') {
+				if (b.charAt(i) == '0') {
+					bothZero++;
+				}
+				else {
+					zeroOne++;
+				}
+			}
+			else {
+				if (b.charAt(i) == '0') {
+					oneZero++;
+				}
+				else {
+					bothOne++;
+				}
+			}
+		}
+		int ans = Integer.MAX_VALUE;
+		if (bothOne - bothZero == 1) {
+			ans = (bothZero*2) + 1;
+		}
+		if (oneZero == zeroOne) {
+			ans = Math.min(ans, oneZero*2);
+		}
+		if (ans == Integer.MAX_VALUE) {
+			ans = -1;
+		}
+		System.out.println(ans);
+		
+	}
+
+	public static void main(String[] args) {
+		
+		FastReader in = new FastReader();
+		int t = in.nextInt();
+		while (t-- > 0) {
+			solve(in.nextInt(), in.next(), in.next());
+		}
+
+	}
+
+}
+","
+import java.util.Scanner;
+
+public class Menorah {
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        int t = sc.nextInt();
+        while (t-- > 0) {
+            int n = sc.nextInt();
+            char initial[] = sc.next().toCharArray();
+            char desired[] = sc.next().toCharArray();
+            int lit1 = 0, lit2 = 0;
+            int ans = Integer.MAX_VALUE;
+            for (int i = 0; i < n; i++) {
+                if (initial[i] == '1') {
+                    ++lit1;
+                }
+                if (desired[i] == '1') {
+                    ++lit2;
+                }
+            }
+            if (lit1 == lit2) {
+                int count = 0;
+                for (int i = 0; i < n; i++) {
+                    if (initial[i] != desired[i]) {
+                        ++count;
+                    }
+                }
+                ans = Math.min(count, ans);
+            }
+            if (lit2 == (n - lit1 + 1)) {
+                int count = 0;
+                for (int i = 0; i < n; i++) {
+                    if (initial[i] == desired[i]) {
+                        ++count;
+                    }
+                }
+                ans = Math.min(ans, count);
+            }
+            if (ans == Integer.MAX_VALUE) {
+                System.out.println(-1);
+            } else {
+                System.out.println(ans);
+            }
+        }
+    }
+}",0
+60557643,948e98b6,"
+
+import java.util.Scanner;
+
+public class D {
+    public static void main(String[] args) {
+        Scanner s = new Scanner(System.in);
+        int lines = s.nextInt();
+
+        s.nextLine();
+
+        for (int i = 0; i < lines; i += 1) {
+            solve(s.nextInt(), s);
+        }
+    }
+
+
+    public static void solve(int n, Scanner s) {
+        int a[] = new int[n];
+        for (int i = 0; i < n; i++) {
+            a[i] = s.nextInt();
+        }
+
+        int b[] = new int[n];
+        for (int i = 0; i + 1 < n; i += 2) {
+            b[i + 1] = a[i];
+            b[i] = -a[i + 1];
+        }
+
+        while (b[n - 2] == 0 || b[n - 1] == 0) {
+            b[n - 1] += a[n - 2];
+            b[n - 2] -= a[n - 1];
+        }
+        
+        StringBuilder erg = new StringBuilder();
+        for (int i = 0; i < n; i++) {
+            erg.append(b[i]).append("" "");
+        }
+
+        System.out.println(erg);
+    }
+}
+","
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.math.BigInteger;
+
+import java.util.*;
+
+public class Main
+{
+
+  
+
+    public static void main(String[] args)
+    {
+        FastScanner input = new FastScanner();
+       StringBuilder result = new StringBuilder();
+        int tc = input.nextInt();
+        while (tc-- > 0) {
+          int n = input.nextInt();
+      int a[] = new int[n];
+      int b[] = new int[n];
+        for (int i = 0; i < n; i++) {
+            a[i] = input.nextInt();
+            
+        }
+        if(n%2==0)
+        {
+            for (int i = 0; i <n; i+=2) {
+                b[i] = a[i+1];
+                b[i+1] = -a[i];
+            }
+        }
+        else
+        {
+            
+            for (int i = 0; i <n-3; i+=2) {
+                b[i] = a[i+1];
+                b[i+1] = -a[i];
+            }
+            int last1 = a[n-3];
+            int last2 = a[n-2];
+            int last3 = a[n-1];
+            if(last1+last2!=0)
+            {
+                b[n-3] = -last3;
+                b[n-2] = -last3;
+                b[n-1] = (last1+last2);
+            }
+            else if(last1+last3!=0)
+            {
+                b[n-3] = -last2;
+                b[n-2] = (last1+last3);
+                b[n-1] = -last2;
+            }
+            else if(last2+last3!=0)
+            {
+                b[n-3] =(last2+last3);
+                b[n-2] = -last1;
+                b[n-1] = -last1;
+            }
+        }
+        for (int i : b) {
+            result.append(i+"" "");
+        }
+        result.append(""\n"");   
+        }
+        System.out.println(result);
+        
+      
+    }
+
+    static class FastScanner
+    {
+
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st = new StringTokenizer("""");
+
+        String next()
+        {
+            while (!st.hasMoreTokens()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt()
+        {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong()
+        {
+
+            return Long.parseLong(next());
+        }
+
+        double nextDouble()
+        {
+            return Double.parseDouble(next());
+        }
+
+        String nextLine() throws IOException
+        {
+            return br.readLine();
+        }
+    }
+
+}
+",0
+c9159d9c,f0ede32a,"import java.util.*;
+
+public class SolutionB {
+
+    public static long gcd(long a, long b){
+        if(b==0){
+            return a;
+        }
+        return gcd(b, a%b);
+    }
+
+    public static long gcdSum(long b){
+        long a = 0;
+
+        long temp = b;
+        while(temp!=0){
+            a = a + temp%10;
+            temp = temp/10;
+        }
+        return gcd(a,b);
+
+    }
+
+    public static class Pair{
+        Long a;
+        Long b;
+
+        public Pair(Long a, Long b) {
+            this.a = a;
+            this.b = b;
+        }
+    }
+
+    public static long factorial (long n){
+        if(n==0)
+            return 1;
+        else if(n==1)
+            return n;
+
+        return n * factorial(n-1);
+    }
+
+    public static long lcm (long n){
+        if(n<3)
+            return n;
+        return lcmForBig(n,n-1);
+    }
+
+    private static long lcmForBig(long n, long l) {
+        if(l==1)
+            return n;
+        n = (n * l) / gcd(n, l);
+        return lcmForBig(n, l-1);
+
+    }
+
+
+    public static void main(String[] args){
+        Scanner s = new Scanner(System.in);
+        
+        int t = s.nextInt();
+
+        for(int i =0;i<t;i++) {
+            int n = s.nextInt();
+            int arr [] = new int[n];
+            ArrayList<Integer> blue = new ArrayList<>();
+            ArrayList<Integer> red = new ArrayList<>();
+
+            for(int j=0;j<n;j++){
+                int num = s.nextInt();
+                arr[j]=num;
+            }
+            String color = s.next();
+
+            for(int j=0;j<n;j++){
+                if(color.charAt(j)=='B'){
+                    blue.add(arr[j]);
+                }
+                else{
+                    red.add(arr[j]);
+                }
+            }
+            Collections.sort(blue);
+            String ans = ""YES"";
+            int counter = 0;
+
+            for(int j=0;j<blue.size();j++){
+                int current = blue.get(j);
+                if (current<1){
+                    ans=""NO"";
+                    break;
+                }
+                if(current>counter){
+                    counter++;
+                }
+                else{
+                    ans=""NO"";
+                    break;
+                }
+
+            }
+
+            if(ans==""NO""){
+                System.out.println(ans);
+            }
+            else{
+                int tempCounter = n+1;
+                Collections.sort(red);
+                for(int j=red.size()-1;j>=0;j--){
+                    int  current  = red.get(j);
+                    if(current>=tempCounter){
+                        ans=""NO"";
+                        break;
+                    }
+                    else{
+                        tempCounter--;
+                    }
+                }
+                if(tempCounter-counter!=1)
+                    System.out.println(""NO"");
+                else
+                    System.out.println(ans);
+            }
+
+        }
+
+        return;
+    }
+}
+","import java.util.*;
+
+public class Soltion{
+ 
+     public static void main(String []args){
+        Scanner sc = new Scanner(System.in);
+        int t = sc.nextInt();
+        
+        while(t-->0){
+            int n = sc.nextInt();
+            Integer[] arr = new Integer[n];
+            for(int i=0;i<n;i++){
+                arr[i] = sc.nextInt();
+            }
+            String s = sc.next();
+            
+            List<Integer> blue = new ArrayList<>();
+            List<Integer> red = new ArrayList<>();
+            
+            for(int i=0;i<s.length();i++){
+                if(s.charAt(i)=='B'){
+                    blue.add(arr[i]);
+                }
+                else{
+                    red.add(arr[i]);
+                }
+            }
+            
+            Collections.sort(blue);
+            Collections.sort(red);
+            int p=1,q=n;
+            
+            boolean flag = true;
+            for(int i=red.size()-1;i>=0;i--){
+                if(red.get(i)>q){
+                    flag = false;
+                    break;
+                }
+                q--;
+            }
+            
+            for(int i=0;i<blue.size();i++){
+                if(blue.get(i)<p){
+                    flag = false;
+                    break;
+                }
+                p++;
+            }
+            
+            System.out.println(flag? ""Yes"" : ""No"");
+        }
+     }
+}
+",0
+9399204d,b434c275,"import java.io.*;
+import java.util.*;
+
+
+
+import java.math.*;
+import java.math.BigInteger;
+
+
+public final class A
+{    
+	static PrintWriter out = new PrintWriter(System.out); 
+	static StringBuilder ans=new StringBuilder();
+	static FastReader in=new FastReader();
+	static ArrayList<Integer> g[];
+	static long mod=(long)1e9+7,INF=Long.MAX_VALUE;
+	static boolean set[],col[]; 
+	static int par[],tot[],partial[];
+	static int D[],P[][];
+	static long dp[][],sum=0,max=0,size[];
+	//	static node1 seg[];
+	//static pair moves[]= {new pair(-1,0),new pair(1,0), new pair(0,-1), new pair(0,1)};
+	public static void main(String args[])throws IOException
+	{				
+
+
+	
+		int T=i();
+		outer:while(T-->0)
+		{
+			int N=i();
+			int size[]=new int[N];
+			PriorityQueue<node1> q[]=new PriorityQueue[6];
+			for(int i=0; i<5; i++)q[i]=new PriorityQueue<node1>();
+			for(int i=0; i<N; i++)
+			{
+				char X[]=in.next().toCharArray();
+				int s=X.length;
+				size[i]=s;
+				int f[]=new int[5];
+				for(char x:X)f[x-'a']++;
+				for(int j=0; j<5; j++)q[j].add(new node1(f[j],i,s));
+			}
+			
+			int max=0;
+			for(int i=0; i<5; i++)
+			{
+				PriorityQueue<node1> q_new=new PriorityQueue<>();
+				q_new=q[i];
+				int c=0;
+				long f=0;
+				while(q_new.size()>0)
+				{
+					node1 x=q_new.remove();
+//					System.out.println(x.f+"" ""+x.size+"" ""+x.a);
+					f+=x.a;
+					if(f>0)
+					{
+						c++;
+						max=Math.max(max, c);
+					}
+					else break;
+				}
+			}
+			out.println(max);
+		}
+		out.close();
+
+	}
+	static int OR(int i,int j)
+	{
+		if(i>j)
+		{
+			int t=i;
+			i=j;
+			j=t;
+		}
+		System.out.println(""OR ""+i+"" ""+j);
+		return i();
+	}
+	static int AND(int i,int j)
+	{
+		if(i>j)
+		{
+			int t=i;
+			i=j;
+			j=t;
+		}
+		System.out.println(""AND ""+i+"" ""+j);
+		return i();
+	}
+	static int XOR(int i,int j)
+	{
+		if(i>j)
+		{
+			int t=i;
+			i=j;
+			j=t;
+		}
+		System.out.println(""XOR ""+i+"" ""+j);
+		return i();
+	}
+
+	static boolean f1(int l,char X[])
+	{
+		int i=0;
+		for(; l<X.length; l++)
+		{
+			if(X[i]!=X[l])return false;
+			i++;
+		}
+		return true;
+	}
+	static int f(int a)
+	{
+		for(int i=a+1; a>0; a++)
+		{
+			if(GCD(i,a)==1)return i;
+		}
+		return 0;
+	}
+	static int min(char X[],char str[],int N)
+	{
+		int s=0;
+		for(int i=0; i<N; i++)
+		{
+			int it=i%3;
+			if(X[i]!=str[it])s++;
+			//             ans.append(str[it]);
+		}
+		return s;
+	}
+	static char f(int i,char X[])
+	{
+		int a=0,b=0,c=0;
+		for(; i<X.length; i+=3)
+		{
+			if(X[i]=='R')a++;
+			if(X[i]=='B')b++;
+			if(X[i]=='G')c++;
+		}
+		if(a>=b && a>=c)return 'R';
+		if(b>=a && b>=c)return 'B';
+		return 'G';
+	}
+
+
+	static void f1(int n,int p,long sum,int N)
+	{
+		for(int c:g[n])
+		{
+			if(c==p)continue;
+
+			long s=sum+N-2*size[c];
+			f1(c,n,s,N);
+			max=Math.max(max, s);
+		}
+	}
+	static long f(int i,int j,ArrayList<Integer> A)
+	{
+
+		if(i+1==A.size())
+		{
+			return j;
+		}		
+		int moves=1+A.get(i);
+		if(j==1)return 1+f(i+1,moves,A);
+		if(j>0 && dp[i][j-1]==0)f(i,j-1,A);
+		return dp[i][j]=dp[i][j-1]+f(i+1,j+moves,A);
+	}
+	//	static void build(int v,int tl,int tr,long A[])
+	//	{
+	//		if(tl==tr)
+	//		{
+	//			seg[v]=new node1(A[tl],A[tr],1,true);
+	//			return ;
+	//		}
+	//		int tm=(tl+tr)/2;
+	//		build(2*v,tl,tm,A);
+	//		build(2*v+1,tm+1,tr,A);
+	//		seg[v]=merge(seg[2*v],seg[2*v+1]);
+	//	}
+	//	static node1 ask(int v,int tl,int tr,int l,int r)
+	//	{
+	//		if(l>r)return new node1(0,0,0,false);//verify true or false
+	//		if(tl==l && tr==r)return seg[v];
+	//		int tm=(tl+tr)/2;
+	//		node1 a=ask(v*2,tl,tm,l,Math.min(tm, r));
+	//		node1 b=ask(v*2+1,tm+1,tr,Math.max(tm+1, l),r);
+	//		return merge(a,b);
+	//	}
+	//	static node1 merge(node1 a,node1 b)
+	//	{
+	//		long s=0;
+	//		long l1=a.L,r1=a.R,c1=a.cnt;
+	//		long l2=b.L,r2=b.R,c2=b.cnt;
+	//		long g=GCD(l2,r1); s=c1+c2;
+	//		if(g==1)
+	//		{
+	//			s--;
+	//			g=(l2*r1)/g;
+	//			if(c1==1)
+	//			{
+	//				l1=g;
+	//			}
+	//			if(c2==1)r2=g;
+	//			return new node1(l1,r2,s,true);
+	//		}
+	//		return new node1(l1,r2,s,a.leaf^b.leaf);
+	//	}
+	static long f(long l,long r,long a,long b,long N)
+	{
+		while(r-l>1)
+		{
+			long m=(l+r)/2;
+			long x=m*b;
+			if(N<x)
+			{
+				r=m;
+				continue;
+			}
+			if((N-x)%a==0)r=m;
+			else l=m;
+
+		}
+		return r;
+	}
+	static long f1(long a,long A[],long bits[],long sum)
+	{
+		long s=A.length;
+		s=mul(s,a);
+		s=(s+(sum%mod))%mod;
+		long p=1L;
+		for(long x:bits)
+		{
+			if((a&p)!=0)s=((s-mul(x,p))+mod)%mod;
+			p<<=1;
+		}
+		return s;
+	}
+	static long f2(long a,long A[],long bits[])
+	{
+		long s=0;
+		long p=1L;
+		for(long x:bits)
+		{
+			if((a&p)!=0)
+			{
+				s=(s+mul(p,x))%mod;
+			}
+			p<<=1;
+		}
+		return s;
+	}
+	static long f(long x1,long y1,long x2,long y2)
+	{
+		return Math.abs(x1-x2)+Math.abs(y1-y2);
+	}
+	static long f(long x,long max,long s)
+	{
+		long l=-1,r=(x/s)+1;
+		while(r-l>1)
+		{
+			long m=(l+r)/2;
+			if(x-m*s>max)l=m;
+			else r=m;
+		}
+		return l+1;
+	}
+	static int f(long A[],long x)
+	{
+		int l=-1,r=A.length;
+		while(r-l>1)
+		{
+			int m=(l+r)/2;
+			if(A[m]>=x)r=m;
+			else l=m;			
+		}
+		return r;
+	}
+
+
+
+	static int bin(int x,ArrayList<Integer> A)
+	{
+		int l=0,r=A.size()-1;
+		while(l<=r)
+		{
+			int m=(l+r)/2;
+			int a=A.get(m);
+			if(a==x)return m;
+			if(a<x)l=m+1;
+			else r=m-1;
+		}
+		return 0;
+	}
+	static int left(int x,ArrayList<Integer> A)
+	{
+		int l=-1,r=A.size();
+		while(r-l>1)
+		{
+			int m=(l+r)/2;
+			int a=A.get(m);
+			if(a<=x)l=m;
+			else r=m;
+		}
+		return l;
+	}
+	static int right(int x,ArrayList<Integer> A)
+	{
+		int l=-1,r=A.size();
+		while(r-l>1)
+		{
+			int m=(l+r)/2;
+			int a=A.get(m);
+			if(a<x)l=m;
+			else r=m;
+		}
+		return r;
+	}
+
+
+
+	static boolean equal(long A[],long B[])
+	{
+		for(int i=0; i<A.length; i++)if(A[i]!=B[i])return false;
+		return true;	
+	}
+
+
+	static int max(int a ,int b,int c,int d)
+	{
+		a=Math.max(a, b);
+		c=Math.max(c,d);
+		return Math.max(a, c);
+	}
+	static int min(int a ,int b,int c,int d)
+	{
+		a=Math.min(a, b);
+		c=Math.min(c,d);
+		return Math.min(a, c);
+	}
+
+
+
+	static HashMap<Integer,Integer> Hash(int A[])
+	{
+		HashMap<Integer,Integer> mp=new HashMap<>();
+		for(int a:A)
+		{
+			int f=mp.getOrDefault(a,0)+1;
+			mp.put(a, f);
+		}
+		return mp;
+	}
+	static long mul(long a, long b)
+	{
+		return ( a %mod * 1L * b%mod )%mod;
+	}
+	static void swap(int A[],int a,int b)
+	{
+		int t=A[a];
+		A[a]=A[b];
+		A[b]=t;
+	}
+
+
+	static int find(int a)
+	{
+		if(par[a]<0)return a;
+		return par[a]=find(par[a]);
+	}
+	static void union(int a,int b)
+	{
+		a=find(a);
+		b=find(b);
+		if(a!=b)
+		{
+			par[a]+=par[b];
+			par[b]=a;
+		}
+	}
+	static boolean isSorted(int A[])
+	{
+		for(int i=1; i<A.length; i++)
+		{
+			if(A[i]<A[i-1])return false;
+		}
+		return true;
+	}
+
+	static boolean isDivisible(StringBuilder X,int i,long num)
+	{
+		long r=0;
+		for(; i<X.length(); i++)
+		{
+			r=r*10+(X.charAt(i)-'0');
+			r=r%num;
+		}
+		return r==0;
+	}    
+
+
+
+	static int lower_Bound(int A[],int low,int high, int x) 
+	{ 
+		if (low > high) 
+			if (x >= A[high]) 
+				return A[high]; 
+
+		int mid = (low + high) / 2; 
+
+		if (A[mid] == x) 
+			return A[mid]; 
+
+		if (mid > 0 && A[mid - 1] <= x && x < A[mid]) 
+			return A[mid - 1]; 
+
+		if (x < A[mid]) 
+			return lower_Bound( A, low, mid - 1, x); 
+
+		return lower_Bound(A, mid + 1, high, x); 
+	} 
+
+	static String f(String A)
+	{
+		String X="""";
+		for(int i=A.length()-1; i>=0; i--)
+		{
+			int c=A.charAt(i)-'0';
+			X+=(c+1)%2;
+		}
+		return X;
+	}
+
+	static void sort(long[] a) //check for long
+	{
+		ArrayList<Long> l=new ArrayList<>();
+		for (long i:a) l.add(i);
+		Collections.sort(l);
+		for (int i=0; i<a.length; i++) a[i]=l.get(i);
+	}
+
+	static String swap(String X,int i,int j)
+	{
+		char ch[]=X.toCharArray();
+		char a=ch[i];
+		ch[i]=ch[j];
+		ch[j]=a;
+		return new String(ch);
+	}
+
+	static int sD(long n)  
+	{  
+
+		if (n % 2 == 0 )  
+			return 2;  
+
+		for (int i = 3; i * i <= n; i += 2) {  
+			if (n % i == 0 )  
+				return i;  
+		}  
+
+		return (int)n;  
+	}  
+
+	static void setGraph(int N)
+	{
+		tot=new int[N+1];
+		partial=new int[N+1];
+		D=new int[N+1];
+		P=new int[N+1][(int)(Math.log(N)+10)];
+		set=new boolean[N+1];
+		g=new ArrayList[N+1];
+		for(int i=0; i<=N; i++)
+		{
+
+			g[i]=new ArrayList<>();		
+			D[i]=Integer.MAX_VALUE;
+			//D2[i]=INF;
+		}
+	}
+
+
+
+	static  long pow(long a,long b)
+	{
+		//long mod=1000000007;
+		long pow=1;
+		long x=a;
+		while(b!=0)
+		{
+			if((b&1)!=0)pow=(pow*x)%mod;
+			x=(x*x)%mod;
+			b/=2;
+		}
+		return pow;
+	}
+
+	static long toggleBits(long x)//one's complement || Toggle bits
+	{
+		int n=(int)(Math.floor(Math.log(x)/Math.log(2)))+1;
+
+		return ((1<<n)-1)^x;
+	}
+
+	static int countBits(long a)
+	{
+		return (int)(Math.log(a)/Math.log(2)+1);
+	}
+
+	static long fact(long N)
+	{ 
+		long n=2; 
+		if(N<=1)return 1;
+		else
+		{
+			for(int i=3; i<=N; i++)n=(n*i)%mod;
+		}
+		return n;
+	}
+
+	static int kadane(int A[])
+	{
+		int lsum=A[0],gsum=A[0];
+		for(int i=1; i<A.length; i++)
+		{
+			lsum=Math.max(lsum+A[i],A[i]);
+			gsum=Math.max(gsum,lsum);
+		}
+		return gsum;
+	}
+
+	static void sort(int[] a) {
+		ArrayList<Integer> l=new ArrayList<>();
+		for (int i:a) l.add(i);
+		Collections.sort(l);
+		for (int i=0; i<a.length; i++) a[i]=l.get(i);
+	}
+
+	static boolean isPrime(long N)
+	{
+		if (N<=1)  return false; 
+		if (N<=3)  return true; 
+		if (N%2 == 0 || N%3 == 0) return false; 
+		for (int i=5; i*i<=N; i=i+6) 
+			if (N%i == 0 || N%(i+2) == 0) 
+				return false; 
+		return true; 
+	}
+	static void print(char A[])
+	{
+		for(char c:A)System.out.print(c+"" "");
+		System.out.println();
+	}
+	static void print(boolean A[])
+	{
+		for(boolean c:A)System.out.print(c+"" "");
+		System.out.println();
+	}
+	static void print(int A[])
+	{
+		for(int a:A)System.out.print(a+"" "");
+		System.out.println();	
+	}
+	static void print(long A[])
+	{
+		for(long i:A)System.out.print(i+ "" "");
+		System.out.println();
+
+	}
+	static void print(ArrayList<Integer> A)
+	{
+		for(int a:A)System.out.print(a+"" "");
+		System.out.println();
+	}
+
+	static int i()
+	{
+		return in.nextInt();
+	}
+
+	static long l()
+	{
+		return in.nextLong();
+	}
+
+	static int[] input(int N){
+		int A[]=new int[N];
+		for(int i=0; i<N; i++)
+		{
+			A[i]=in.nextInt();
+		}
+		return A;
+	}
+
+	static long[] inputLong(int N)     {
+		long A[]=new long[N];
+		for(int i=0; i<A.length; i++)A[i]=in.nextLong();
+		return A;
+	}
+
+	static long GCD(long a,long b) 
+	{
+		if(b==0)
+		{
+			return a;
+		}
+		else return GCD(b,a%b );
+	}
+
+}
+class node1 implements Comparable<node1>
+{
+	int index,f,size;
+	long a;
+	node1(int f,int i,int size)
+	{
+		this.f=f;
+		this.index=i;
+		this.size=size;
+		a=2*f-size;
+	}
+	public int compareTo(node1 x)
+	{
+		if(this.a==x.a)return 0;
+		else if(this.a<x.a)return 1;
+		else return -1;
+	}
+}
+
+
+//Code For FastReader
+//Code For FastReader
+//Code For FastReader
+//Code For FastReader
+class FastReader
+{
+	BufferedReader br;
+	StringTokenizer st;
+	public FastReader()
+	{
+		br=new BufferedReader(new InputStreamReader(System.in));
+	}
+
+	String next()
+	{
+		while(st==null || !st.hasMoreElements())
+		{
+			try
+			{
+				st=new StringTokenizer(br.readLine());
+			}
+			catch(IOException e)
+			{
+				e.printStackTrace();
+			}
+		}
+		return st.nextToken();
+	}
+
+	int nextInt()
+	{
+		return Integer.parseInt(next());
+	}
+
+	long nextLong()
+	{
+		return Long.parseLong(next());
+	}
+
+	double nextDouble()
+	{
+		return Double.parseDouble(next());
+	}
+
+	String nextLine()
+	{
+		String str="""";
+		try
+		{
+			str=br.readLine();
+		}
+		catch (IOException e)
+		{
+			e.printStackTrace();
+		}
+		return str;
+	}
+
+}
+","import java.io.*;
+import java.util.*;
+
+
+
+import java.math.*;
+import java.math.BigInteger;
+
+
+public final class A
+{    
+	static PrintWriter out = new PrintWriter(System.out); 
+	static StringBuilder ans=new StringBuilder();
+	static FastReader in=new FastReader();
+	static ArrayList<Integer> g[];
+	static long mod=(long)1e9+7,INF=Long.MAX_VALUE;
+	static boolean set[],col[]; 
+	static int par[],tot[],partial[];
+	static int D[],P[][];
+	static long dp[][],sum=0,max=0,size[];
+	//	static node1 seg[];
+	//static pair moves[]= {new pair(-1,0),new pair(1,0), new pair(0,-1), new pair(0,1)};
+	public static void main(String args[])throws IOException
+	{				
+
+
+	
+		int T=i();
+		outer:while(T-->0)
+		{
+			int N=i();
+			int size[]=new int[N];
+			PriorityQueue<node1> q[]=new PriorityQueue[26];
+			for(int i=0; i<26; i++)q[i]=new PriorityQueue<node1>();
+			for(int i=0; i<N; i++)
+			{
+				char X[]=in.next().toCharArray();
+				int s=X.length;
+				size[i]=s;
+				int f[]=new int[26];
+				for(char x:X)f[x-'a']++;
+				for(int j=0; j<26; j++)q[j].add(new node1(f[j],i,s));
+			}
+			
+			int max=0;
+			for(int i=0; i<26; i++)
+			{
+				PriorityQueue<node1> q_new=new PriorityQueue<>();
+				q_new=q[i];
+				int c=0;
+				long f=0;
+				while(q_new.size()>0)
+				{
+					node1 x=q_new.remove();
+//					System.out.println(x.f+"" ""+x.size+"" ""+x.a);
+					f+=x.a;
+					if(f>0)
+					{
+						c++;
+						max=Math.max(max, c);
+					}
+					else break;
+				}
+			}
+			out.println(max);
+		}
+		out.close();
+
+	}
+	static int OR(int i,int j)
+	{
+		if(i>j)
+		{
+			int t=i;
+			i=j;
+			j=t;
+		}
+		System.out.println(""OR ""+i+"" ""+j);
+		return i();
+	}
+	static int AND(int i,int j)
+	{
+		if(i>j)
+		{
+			int t=i;
+			i=j;
+			j=t;
+		}
+		System.out.println(""AND ""+i+"" ""+j);
+		return i();
+	}
+	static int XOR(int i,int j)
+	{
+		if(i>j)
+		{
+			int t=i;
+			i=j;
+			j=t;
+		}
+		System.out.println(""XOR ""+i+"" ""+j);
+		return i();
+	}
+
+	static boolean f1(int l,char X[])
+	{
+		int i=0;
+		for(; l<X.length; l++)
+		{
+			if(X[i]!=X[l])return false;
+			i++;
+		}
+		return true;
+	}
+	static int f(int a)
+	{
+		for(int i=a+1; a>0; a++)
+		{
+			if(GCD(i,a)==1)return i;
+		}
+		return 0;
+	}
+	static int min(char X[],char str[],int N)
+	{
+		int s=0;
+		for(int i=0; i<N; i++)
+		{
+			int it=i%3;
+			if(X[i]!=str[it])s++;
+			//             ans.append(str[it]);
+		}
+		return s;
+	}
+	static char f(int i,char X[])
+	{
+		int a=0,b=0,c=0;
+		for(; i<X.length; i+=3)
+		{
+			if(X[i]=='R')a++;
+			if(X[i]=='B')b++;
+			if(X[i]=='G')c++;
+		}
+		if(a>=b && a>=c)return 'R';
+		if(b>=a && b>=c)return 'B';
+		return 'G';
+	}
+
+
+	static void f1(int n,int p,long sum,int N)
+	{
+		for(int c:g[n])
+		{
+			if(c==p)continue;
+
+			long s=sum+N-2*size[c];
+			f1(c,n,s,N);
+			max=Math.max(max, s);
+		}
+	}
+	static long f(int i,int j,ArrayList<Integer> A)
+	{
+
+		if(i+1==A.size())
+		{
+			return j;
+		}		
+		int moves=1+A.get(i);
+		if(j==1)return 1+f(i+1,moves,A);
+		if(j>0 && dp[i][j-1]==0)f(i,j-1,A);
+		return dp[i][j]=dp[i][j-1]+f(i+1,j+moves,A);
+	}
+	//	static void build(int v,int tl,int tr,long A[])
+	//	{
+	//		if(tl==tr)
+	//		{
+	//			seg[v]=new node1(A[tl],A[tr],1,true);
+	//			return ;
+	//		}
+	//		int tm=(tl+tr)/2;
+	//		build(2*v,tl,tm,A);
+	//		build(2*v+1,tm+1,tr,A);
+	//		seg[v]=merge(seg[2*v],seg[2*v+1]);
+	//	}
+	//	static node1 ask(int v,int tl,int tr,int l,int r)
+	//	{
+	//		if(l>r)return new node1(0,0,0,false);//verify true or false
+	//		if(tl==l && tr==r)return seg[v];
+	//		int tm=(tl+tr)/2;
+	//		node1 a=ask(v*2,tl,tm,l,Math.min(tm, r));
+	//		node1 b=ask(v*2+1,tm+1,tr,Math.max(tm+1, l),r);
+	//		return merge(a,b);
+	//	}
+	//	static node1 merge(node1 a,node1 b)
+	//	{
+	//		long s=0;
+	//		long l1=a.L,r1=a.R,c1=a.cnt;
+	//		long l2=b.L,r2=b.R,c2=b.cnt;
+	//		long g=GCD(l2,r1); s=c1+c2;
+	//		if(g==1)
+	//		{
+	//			s--;
+	//			g=(l2*r1)/g;
+	//			if(c1==1)
+	//			{
+	//				l1=g;
+	//			}
+	//			if(c2==1)r2=g;
+	//			return new node1(l1,r2,s,true);
+	//		}
+	//		return new node1(l1,r2,s,a.leaf^b.leaf);
+	//	}
+	static long f(long l,long r,long a,long b,long N)
+	{
+		while(r-l>1)
+		{
+			long m=(l+r)/2;
+			long x=m*b;
+			if(N<x)
+			{
+				r=m;
+				continue;
+			}
+			if((N-x)%a==0)r=m;
+			else l=m;
+
+		}
+		return r;
+	}
+	static long f1(long a,long A[],long bits[],long sum)
+	{
+		long s=A.length;
+		s=mul(s,a);
+		s=(s+(sum%mod))%mod;
+		long p=1L;
+		for(long x:bits)
+		{
+			if((a&p)!=0)s=((s-mul(x,p))+mod)%mod;
+			p<<=1;
+		}
+		return s;
+	}
+	static long f2(long a,long A[],long bits[])
+	{
+		long s=0;
+		long p=1L;
+		for(long x:bits)
+		{
+			if((a&p)!=0)
+			{
+				s=(s+mul(p,x))%mod;
+			}
+			p<<=1;
+		}
+		return s;
+	}
+	static long f(long x1,long y1,long x2,long y2)
+	{
+		return Math.abs(x1-x2)+Math.abs(y1-y2);
+	}
+	static long f(long x,long max,long s)
+	{
+		long l=-1,r=(x/s)+1;
+		while(r-l>1)
+		{
+			long m=(l+r)/2;
+			if(x-m*s>max)l=m;
+			else r=m;
+		}
+		return l+1;
+	}
+	static int f(long A[],long x)
+	{
+		int l=-1,r=A.length;
+		while(r-l>1)
+		{
+			int m=(l+r)/2;
+			if(A[m]>=x)r=m;
+			else l=m;			
+		}
+		return r;
+	}
+
+
+
+	static int bin(int x,ArrayList<Integer> A)
+	{
+		int l=0,r=A.size()-1;
+		while(l<=r)
+		{
+			int m=(l+r)/2;
+			int a=A.get(m);
+			if(a==x)return m;
+			if(a<x)l=m+1;
+			else r=m-1;
+		}
+		return 0;
+	}
+	static int left(int x,ArrayList<Integer> A)
+	{
+		int l=-1,r=A.size();
+		while(r-l>1)
+		{
+			int m=(l+r)/2;
+			int a=A.get(m);
+			if(a<=x)l=m;
+			else r=m;
+		}
+		return l;
+	}
+	static int right(int x,ArrayList<Integer> A)
+	{
+		int l=-1,r=A.size();
+		while(r-l>1)
+		{
+			int m=(l+r)/2;
+			int a=A.get(m);
+			if(a<x)l=m;
+			else r=m;
+		}
+		return r;
+	}
+
+
+
+	static boolean equal(long A[],long B[])
+	{
+		for(int i=0; i<A.length; i++)if(A[i]!=B[i])return false;
+		return true;	
+	}
+
+
+	static int max(int a ,int b,int c,int d)
+	{
+		a=Math.max(a, b);
+		c=Math.max(c,d);
+		return Math.max(a, c);
+	}
+	static int min(int a ,int b,int c,int d)
+	{
+		a=Math.min(a, b);
+		c=Math.min(c,d);
+		return Math.min(a, c);
+	}
+
+
+
+	static HashMap<Integer,Integer> Hash(int A[])
+	{
+		HashMap<Integer,Integer> mp=new HashMap<>();
+		for(int a:A)
+		{
+			int f=mp.getOrDefault(a,0)+1;
+			mp.put(a, f);
+		}
+		return mp;
+	}
+	static long mul(long a, long b)
+	{
+		return ( a %mod * 1L * b%mod )%mod;
+	}
+	static void swap(int A[],int a,int b)
+	{
+		int t=A[a];
+		A[a]=A[b];
+		A[b]=t;
+	}
+
+
+	static int find(int a)
+	{
+		if(par[a]<0)return a;
+		return par[a]=find(par[a]);
+	}
+	static void union(int a,int b)
+	{
+		a=find(a);
+		b=find(b);
+		if(a!=b)
+		{
+			par[a]+=par[b];
+			par[b]=a;
+		}
+	}
+	static boolean isSorted(int A[])
+	{
+		for(int i=1; i<A.length; i++)
+		{
+			if(A[i]<A[i-1])return false;
+		}
+		return true;
+	}
+
+	static boolean isDivisible(StringBuilder X,int i,long num)
+	{
+		long r=0;
+		for(; i<X.length(); i++)
+		{
+			r=r*10+(X.charAt(i)-'0');
+			r=r%num;
+		}
+		return r==0;
+	}    
+
+
+
+	static int lower_Bound(int A[],int low,int high, int x) 
+	{ 
+		if (low > high) 
+			if (x >= A[high]) 
+				return A[high]; 
+
+		int mid = (low + high) / 2; 
+
+		if (A[mid] == x) 
+			return A[mid]; 
+
+		if (mid > 0 && A[mid - 1] <= x && x < A[mid]) 
+			return A[mid - 1]; 
+
+		if (x < A[mid]) 
+			return lower_Bound( A, low, mid - 1, x); 
+
+		return lower_Bound(A, mid + 1, high, x); 
+	} 
+
+	static String f(String A)
+	{
+		String X="""";
+		for(int i=A.length()-1; i>=0; i--)
+		{
+			int c=A.charAt(i)-'0';
+			X+=(c+1)%2;
+		}
+		return X;
+	}
+
+	static void sort(long[] a) //check for long
+	{
+		ArrayList<Long> l=new ArrayList<>();
+		for (long i:a) l.add(i);
+		Collections.sort(l);
+		for (int i=0; i<a.length; i++) a[i]=l.get(i);
+	}
+
+	static String swap(String X,int i,int j)
+	{
+		char ch[]=X.toCharArray();
+		char a=ch[i];
+		ch[i]=ch[j];
+		ch[j]=a;
+		return new String(ch);
+	}
+
+	static int sD(long n)  
+	{  
+
+		if (n % 2 == 0 )  
+			return 2;  
+
+		for (int i = 3; i * i <= n; i += 2) {  
+			if (n % i == 0 )  
+				return i;  
+		}  
+
+		return (int)n;  
+	}  
+
+	static void setGraph(int N)
+	{
+		tot=new int[N+1];
+		partial=new int[N+1];
+		D=new int[N+1];
+		P=new int[N+1][(int)(Math.log(N)+10)];
+		set=new boolean[N+1];
+		g=new ArrayList[N+1];
+		for(int i=0; i<=N; i++)
+		{
+
+			g[i]=new ArrayList<>();		
+			D[i]=Integer.MAX_VALUE;
+			//D2[i]=INF;
+		}
+	}
+
+
+
+	static  long pow(long a,long b)
+	{
+		//long mod=1000000007;
+		long pow=1;
+		long x=a;
+		while(b!=0)
+		{
+			if((b&1)!=0)pow=(pow*x)%mod;
+			x=(x*x)%mod;
+			b/=2;
+		}
+		return pow;
+	}
+
+	static long toggleBits(long x)//one's complement || Toggle bits
+	{
+		int n=(int)(Math.floor(Math.log(x)/Math.log(2)))+1;
+
+		return ((1<<n)-1)^x;
+	}
+
+	static int countBits(long a)
+	{
+		return (int)(Math.log(a)/Math.log(2)+1);
+	}
+
+	static long fact(long N)
+	{ 
+		long n=2; 
+		if(N<=1)return 1;
+		else
+		{
+			for(int i=3; i<=N; i++)n=(n*i)%mod;
+		}
+		return n;
+	}
+
+	static int kadane(int A[])
+	{
+		int lsum=A[0],gsum=A[0];
+		for(int i=1; i<A.length; i++)
+		{
+			lsum=Math.max(lsum+A[i],A[i]);
+			gsum=Math.max(gsum,lsum);
+		}
+		return gsum;
+	}
+
+	static void sort(int[] a) {
+		ArrayList<Integer> l=new ArrayList<>();
+		for (int i:a) l.add(i);
+		Collections.sort(l);
+		for (int i=0; i<a.length; i++) a[i]=l.get(i);
+	}
+
+	static boolean isPrime(long N)
+	{
+		if (N<=1)  return false; 
+		if (N<=3)  return true; 
+		if (N%2 == 0 || N%3 == 0) return false; 
+		for (int i=5; i*i<=N; i=i+6) 
+			if (N%i == 0 || N%(i+2) == 0) 
+				return false; 
+		return true; 
+	}
+	static void print(char A[])
+	{
+		for(char c:A)System.out.print(c+"" "");
+		System.out.println();
+	}
+	static void print(boolean A[])
+	{
+		for(boolean c:A)System.out.print(c+"" "");
+		System.out.println();
+	}
+	static void print(int A[])
+	{
+		for(int a:A)System.out.print(a+"" "");
+		System.out.println();	
+	}
+	static void print(long A[])
+	{
+		for(long i:A)System.out.print(i+ "" "");
+		System.out.println();
+
+	}
+	static void print(ArrayList<Integer> A)
+	{
+		for(int a:A)System.out.print(a+"" "");
+		System.out.println();
+	}
+
+	static int i()
+	{
+		return in.nextInt();
+	}
+
+	static long l()
+	{
+		return in.nextLong();
+	}
+
+	static int[] input(int N){
+		int A[]=new int[N];
+		for(int i=0; i<N; i++)
+		{
+			A[i]=in.nextInt();
+		}
+		return A;
+	}
+
+	static long[] inputLong(int N)     {
+		long A[]=new long[N];
+		for(int i=0; i<A.length; i++)A[i]=in.nextLong();
+		return A;
+	}
+
+	static long GCD(long a,long b) 
+	{
+		if(b==0)
+		{
+			return a;
+		}
+		else return GCD(b,a%b );
+	}
+
+}
+class node1 implements Comparable<node1>
+{
+	int index,f,size;
+	long a;
+	node1(int f,int i,int size)
+	{
+		this.f=f;
+		this.index=i;
+		this.size=size;
+		a=2*f-size;
+	}
+	public int compareTo(node1 x)
+	{
+		if(this.a==x.a)return 0;
+		else if(this.a<x.a)return 1;
+		else return -1;
+	}
+}
+
+
+//Code For FastReader
+//Code For FastReader
+//Code For FastReader
+//Code For FastReader
+class FastReader
+{
+	BufferedReader br;
+	StringTokenizer st;
+	public FastReader()
+	{
+		br=new BufferedReader(new InputStreamReader(System.in));
+	}
+
+	String next()
+	{
+		while(st==null || !st.hasMoreElements())
+		{
+			try
+			{
+				st=new StringTokenizer(br.readLine());
+			}
+			catch(IOException e)
+			{
+				e.printStackTrace();
+			}
+		}
+		return st.nextToken();
+	}
+
+	int nextInt()
+	{
+		return Integer.parseInt(next());
+	}
+
+	long nextLong()
+	{
+		return Long.parseLong(next());
+	}
+
+	double nextDouble()
+	{
+		return Double.parseDouble(next());
+	}
+
+	String nextLine()
+	{
+		String str="""";
+		try
+		{
+			str=br.readLine();
+		}
+		catch (IOException e)
+		{
+			e.printStackTrace();
+		}
+		return str;
+	}
+
+}
+",1
+0e68e463,d9199dfd,"import java.io.*;
+import java.util.*;
+
+import static java.lang.Math.*;
+
+public class D {
+    public static void main(String[] args) {
+        Scanner in = new Scanner(System.in);
+        PrintWriter pw = new PrintWriter(System.out);
+        int t = in.nextInt();
+        for(int tt = 0; tt < t; tt++) {
+            int n = in.nextInt();
+            long[] arr = new long[n];
+            for (int i = 0; i < n; i++) arr[i] = in.nextLong();
+            char[] s = in.next().toCharArray();
+            if (solve(arr, n, s))pw.println(""YES"");
+            else pw.println(""NO"");
+        }
+        pw.close();
+    }
+    static boolean solve(long[] arr, int n, char[] s) {
+        ArrayList<Long> B = new ArrayList<>();
+        ArrayList<Long> R = new ArrayList<>();
+        for(int i = 0; i < n; i++) {
+            if (s[i] == 'B') B.add(arr[i]);
+            else R.add(arr[i]);
+        }
+        Collections.sort(B);
+        Collections.sort(R);
+      //  debug(B);
+        long last = n;
+        for (int i = R.size() - 1; i >= 0; i--) {
+            long v = R.get(i);
+            if (v > last) {
+               return false;
+            }
+            last--;
+        }
+        long first = 1;
+        int size = B.size();
+        for (int i = 0; i < size; i++) {
+            long v = B.get(i);
+         //   debug(v, first);
+            if (v < first) return false;
+            first++;
+        }
+        return true;
+    }
+
+
+    static void debug(Object... obj) {
+        System.err.println(Arrays.deepToString(obj));
+    }
+}
+","import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Scanner;
+
+public class Simple{  
+    public static void main(String args[]){  
+        //System.out.println(""Hello Java"");
+        Scanner s = new Scanner(System.in);
+        int t = s.nextInt();
+        while (t>0){
+            
+            int n = s.nextInt();
+            int arr[] = new int[n];
+
+            for(int i=0;i<n;i++){
+                arr[i] = s.nextInt();
+            }
+            String str = s.next();
+
+            //Arrays.sort(arr);
+            ArrayList<Integer> blue = new ArrayList<>();
+            ArrayList<Integer> red = new ArrayList<>();
+            for(int i=0;i<n;i++){
+                if(str.charAt(i)=='R'){
+                    red.add(arr[i]);
+                }
+                else{
+                    blue.add(arr[i]);
+                }
+            }
+            Collections.sort(red);
+            Collections.sort(blue);
+            
+            int start =1;
+
+            boolean bool =true;
+            for(int i=0;i<blue.size();i++){
+                if(blue.get(i)<start){
+                    bool = false;
+                    break;
+                }
+
+                start++;
+            }
+            if(!bool){
+                System.out.println(""NO"");
+            }
+            else{
+                for(int i=0;i<red.size();i++){
+                    if(red.get(i)>start){
+                        bool = false;
+                        break;
+                    }
+                    start++;
+                }
+                if(bool){
+                    System.out.println(""YES"");
+                }
+                else{
+                    System.out.println(""NO"");
+                }
+            }
+            
+            
+
+
+            t--;
+        }
+        s.close();  
+    }
+    
+}  
+",0
+08b9908d,f5fb1b62,"import java.util.*;
+import java.io.*;
+import java.math.*;
+
+
+public class Main
+
+{ 
+	 static FastReader sc=new FastReader(); 
+	 static long dp[][];
+	 static int mod=1000000007;
+	 static int max;
+	 static long bit[];
+	 static long x;
+	 static long y;
+	 static long B[][];
+
+	   static PrintWriter out=new PrintWriter(System.out);
+	  public static void main(String[] args)
+{
+		    //CHECK FOR N=1
+	       	//CHECK FOR N=1
+		   //StringBuffer sb=new StringBuffer("""");
+		  int ttt=1;
+		      ttt =i();
+	        outer :while (ttt-- > 0) 
+			{
+	        	int n=i();
+	        	int k=i();
+	        	int P[]=input(k);
+	        	int Q[]=input(k);
+	        	long A[]=new long[n+1];
+	        	Arrays.fill(A, Integer.MAX_VALUE);
+	        	for(int i=0;i<k;i++) {
+	        		A[P[i]]=Q[i];
+	        	}
+	        	long B[]=new long[n+1];
+	        	long C[]=new long[n+1];
+	        	Arrays.fill(B, Integer.MAX_VALUE);
+	        	Arrays.fill(C, Integer.MAX_VALUE);
+	        	for(int i=n;i>0;i--) {
+	        		if(i+1<=n) {
+	        			B[i]=min(A[i],B[i+1]+1);
+	        		}
+	        		else {
+	        			B[i]=A[i];
+	        		}
+	        	}
+	        	for(int i=1;i<=n;i++) {
+	        		if(i-1>0) {
+	        			C[i]=min(A[i],C[i-1]+1);
+	        		}
+	        		else {
+	        			C[i]=A[i];
+	        		}
+	        	}
+	        	for(int i=1;i<=n;i++) {
+	        		out.print(min(B[i],C[i])+"" "");
+	        	}
+	        	out.println();
+	        	
+	        	
+	        	
+	        	
+	        	
+	        }
+	        //System.out.println(sb.toString());
+		     out.close();
+	     
+	     
+	    //CHECK FOR N=1                    //CHECK FOR M=0
+        //CHECK FOR N=1                    //CHECK FOR M=0
+       	//CHECK FOR N=1
+       	
+		        
+		     
+    }
+	  
+	  
+	  
+	  
+	  
+static class Pair implements Comparable<Pair>
+     {
+    	 int x;
+    	 int y;
+    	 Pair(int x,int y,int z){
+    		 this.x=x;
+    		 this.y=y;
+    		 
+    	 }
+		@Override
+		public int compareTo(Pair o) {
+			if(this.x>o.x)
+				return 1;
+			else if(this.x<o.x)
+				return -1;
+			else {
+				if(this.y>o.y)
+					return 1;
+				else if(this.y<o.y)
+					return -1;
+				else
+					return 0;
+			}
+		}
+//		public int hashCode() 
+//		{ 
+//			final int temp = 14; 
+//			int ans = 1; 
+//			ans =x*31+y*13; 
+//			return ans; 
+//		} 
+//		@Override
+//		public boolean equals(Object o) 
+//		{ 
+//			if (this == o) { 
+//				return true; 
+//			} 
+//			if (o == null) { 
+//				return false; 
+//			} 
+//			if (this.getClass() != o.getClass()) { 
+//				return false; 
+//			} 
+//			Pair other = (Pair)o; 
+//			if (this.x != other.x || this.y!=other.y) { 
+//				return false; 
+//			} 
+//			return true; 
+//		} 	
+//		
+		/* FOR TREE MAP PAIR USE */
+		
+//		public int compareTo(Pair o) {
+// 			if (x > o.x) {
+// 				return 1;
+// 			}
+// 			if (x < o.x) {
+// 				return -1;
+// 			}
+// 			if (y > o.y) {
+// 				return 1;
+// 			}
+// 			if (y < o.y) {
+// 				return -1;
+// 			}
+// 			return 0;
+// 		}
+		
+     }
+//FENWICK TREE
+static void update(int i, int x){
+	for(; i < bit.length; i += (i&-i))
+		bit[i] += x;
+}
+
+static int sum(int i){
+	int ans = 0;
+	for(; i > 0; i -= (i&-i))
+		ans += bit[i];
+	return ans;
+}
+//END
+//static void add(int v) {
+//	if(!map.containsKey(v)) {
+//		map.put(v, 1);
+//	}
+//	else {
+//		map.put(v, map.get(v)+1);
+//	}
+//}
+//static void remove(int v) {
+//	if(map.containsKey(v)) {
+//		map.put(v, map.get(v)-1);
+//		if(map.get(v)==0)
+//			map.remove(v);
+//	}
+//}
+public static int upper(int A[],int k,int si,int ei)
+{
+	int l=si;
+	int u=ei;
+	int ans=-1;
+	while(l<=u) {
+		int mid=(l+u)/2;
+		if(A[mid]<=k) {
+			ans=mid;
+			l=mid+1;
+		}
+		else {
+			u=mid-1;
+		}
+	}
+	return ans;
+}
+public static int lower(int A[],int k,int si,int ei)
+{
+	int l=si;
+	int u=ei;
+	int ans=-1;
+	while(l<=u) {
+		int mid=(l+u)/2;
+		if(A[mid]<k) {
+			l=mid+1;
+		}
+		else {
+			ans=mid;
+			u=mid-1;
+		}
+	}
+	return ans;
+	
+    
+}
+static int[] copy(int A[]) {
+	int B[]=new int[A.length];
+	for(int i=0;i<A.length;i++) {
+		B[i]=A[i];
+	}
+	return B;
+}
+static long[] copy(long A[]) {
+	long B[]=new long[A.length];
+	for(int i=0;i<A.length;i++) {
+		B[i]=A[i];
+	}
+	return B;
+}
+static int[] input(int n) {
+	int A[]=new int[n];
+	   for(int i=0;i<n;i++) {
+		   A[i]=sc.nextInt();
+	   }
+	   return A;
+   }
+static long[] inputL(int n) {
+	long A[]=new long[n];
+	   for(int i=0;i<n;i++) {
+		   A[i]=sc.nextLong();
+	   }
+	   return A;
+   }
+static String[] inputS(int n) {
+	String A[]=new String[n];
+	   for(int i=0;i<n;i++) {
+		   A[i]=sc.next();
+	   }
+	   return A;
+   }
+static long sum(int A[]) {
+	long sum=0;
+	for(int i : A) {
+		sum+=i;
+	}
+	return sum;
+}
+static long sum(long A[]) {
+	long sum=0;
+	for(long i : A) {
+		sum+=i;
+	}
+	return sum;
+}
+static void reverse(long A[]) {
+	int n=A.length;
+	long B[]=new long[n];
+	for(int i=0;i<n;i++) {
+		B[i]=A[n-i-1];
+	}
+	for(int i=0;i<n;i++)
+		A[i]=B[i];
+	
+}
+static void reverse(int A[]) {
+	int n=A.length;
+	int B[]=new int[n];
+	for(int i=0;i<n;i++) {
+		B[i]=A[n-i-1];
+	}
+	for(int i=0;i<n;i++)
+		A[i]=B[i];
+	
+}
+static void input(int A[],int B[]) {
+	   for(int i=0;i<A.length;i++) {
+		   A[i]=sc.nextInt();
+		   B[i]=sc.nextInt();
+	   }
+}
+static int[][] input(int n,int m){
+	int A[][]=new int[n][m];
+	for(int i=0;i<n;i++) {
+		for(int j=0;j<m;j++) {
+			A[i][j]=i();
+		}
+	}
+	return A;
+}
+static char[][] charinput(int n,int m){
+	char A[][]=new char[n][m];
+	for(int i=0;i<n;i++) {
+		String s=s();
+		for(int j=0;j<m;j++) {
+			A[i][j]=s.charAt(j);
+		}
+	}
+	return A;
+}
+static int find(int A[],int a) {
+	  if(A[a]==a)
+		  return a;
+	  return A[a]=find(A, A[a]);
+}
+static int max(int A[]) {
+	int max=Integer.MIN_VALUE;
+	for(int i=0;i<A.length;i++) {
+		max=Math.max(max, A[i]);
+	}
+	return max;
+}
+static int min(int A[]) {
+	int min=Integer.MAX_VALUE;
+	for(int i=0;i<A.length;i++) {
+		min=Math.min(min, A[i]);
+	}
+	return min;
+}
+static long max(long A[]) {
+	long max=Long.MIN_VALUE;
+	for(int i=0;i<A.length;i++) {
+		max=Math.max(max, A[i]);
+	}
+	return max;
+}
+static long min(long A[]) {
+	long min=Long.MAX_VALUE;
+	for(int i=0;i<A.length;i++) {
+		min=Math.min(min, A[i]);
+	}
+	return min;
+}
+static long [] prefix(long A[]) {
+	long p[]=new long[A.length];
+	p[0]=A[0];
+	for(int i=1;i<A.length;i++)
+		p[i]=p[i-1]+A[i];
+	return p;
+}
+static long [] prefix(int A[]) {
+	long p[]=new long[A.length];
+	p[0]=A[0];
+	for(int i=1;i<A.length;i++)
+		p[i]=p[i-1]+A[i];
+	return p;
+}
+static long [] suffix(long A[]) {
+	long p[]=new long[A.length];
+	p[A.length-1]=A[A.length-1];
+	for(int i=A.length-2;i>=0;i--)
+		p[i]=p[i+1]+A[i];
+	return p;
+}
+static long [] suffix(int A[]) {
+	long p[]=new long[A.length];
+	p[A.length-1]=A[A.length-1];
+	for(int i=A.length-2;i>=0;i--)
+		p[i]=p[i+1]+A[i];
+	return p;
+}
+static void fill(int dp[]) {
+	Arrays.fill(dp, -1);
+}
+static void fill(int dp[][]) {
+	for(int i=0;i<dp.length;i++)
+	Arrays.fill(dp[i], -1);
+}
+static void fill(int dp[][][]) {
+	for(int i=0;i<dp.length;i++) {
+		for(int j=0;j<dp[0].length;j++) {
+			Arrays.fill(dp[i][j],-1);
+		}
+	}
+}
+static void fill(int dp[][][][]) {
+	for(int i=0;i<dp.length;i++) {
+		for(int j=0;j<dp[0].length;j++) {
+			for(int k=0;k<dp[0][0].length;k++) {
+			Arrays.fill(dp[i][j][k],-1);
+			}
+		}
+	}
+}
+static void fill(long dp[]) {
+	Arrays.fill(dp, -1);
+}
+static void fill(long dp[][]) {
+	for(int i=0;i<dp.length;i++)
+	Arrays.fill(dp[i], -1);
+}
+static void fill(long dp[][][]) {
+	for(int i=0;i<dp.length;i++) {
+		for(int j=0;j<dp[0].length;j++) {
+			Arrays.fill(dp[i][j],-1);
+		}
+	}
+}
+static void fill(long dp[][][][]) {
+	for(int i=0;i<dp.length;i++) {
+		for(int j=0;j<dp[0].length;j++) {
+			for(int k=0;k<dp[0][0].length;k++) {
+			Arrays.fill(dp[i][j][k],-1);
+			}
+		}
+	}
+}
+static int min(int a,int b) {
+	return Math.min(a, b);
+}
+static int min(int a,int b,int c) {
+	return Math.min(a, Math.min(b, c));
+}
+static int min(int a,int b,int c,int d) {
+	return Math.min(a, Math.min(b, Math.min(c, d)));
+}
+static int max(int a,int b) {
+	return Math.max(a, b);
+}
+static int max(int a,int b,int c) {
+	return Math.max(a, Math.max(b, c));
+}
+static int max(int a,int b,int c,int d) {
+	return Math.max(a, Math.max(b, Math.max(c, d)));
+}
+static long min(long a,long b) {
+	return Math.min(a, b);
+}
+static long min(long a,long b,long c) {
+	return Math.min(a, Math.min(b, c));
+}
+static long min(long a,long b,long c,long d) {
+	return Math.min(a, Math.min(b, Math.min(c, d)));
+}
+static long max(long a,long b) {
+	return Math.max(a, b);
+}
+static long max(long a,long b,long c) {
+	return Math.max(a, Math.max(b, c));
+}
+static long max(long a,long b,long c,long d) {
+	return Math.max(a, Math.max(b, Math.max(c, d)));
+}
+
+static long power(long x, long y, long p)
+{
+
+	if(y==0)
+		return 1;
+	if(x==0)
+		return 0;
+    long res = 1;
+    x = x % p;
+
+    while (y > 0) {
+
+        if (y % 2 == 1)
+            res = (res * x) % p;
+
+        y = y >> 1; 
+        x = (x * x) % p;
+    }
+
+    return res;
+}
+static void print(int A[]) {
+	for(int i : A) {
+		System.out.print(i+"" "");
+	}
+	System.out.println();
+}
+static void print(long A[]) {
+	for(long i : A) {
+		System.out.print(i+"" "");
+	}
+	System.out.println();
+}
+static long mod(long x) {
+	  return ((x%mod + mod)%mod);
+}
+static String reverse(String s) {
+	StringBuffer p=new StringBuffer(s);
+	p.reverse();
+	return p.toString();
+}
+
+     static int i() {
+    	 return sc.nextInt();
+     }
+     static String s() {
+    	 return sc.next();
+     }
+     static long l() {
+    	 return sc.nextLong();
+     }  
+     static void sort(int[] A){
+        int n = A.length;
+        Random rnd = new Random();
+        for(int i=0; i<n; ++i){
+            int tmp = A[i];
+            int randomPos = i + rnd.nextInt(n-i);
+            A[i] = A[randomPos];
+            A[randomPos] = tmp;
+        }
+        Arrays.sort(A);
+     }
+     static void sort(long[] A){
+	        int n = A.length;
+	        Random rnd = new Random();
+	        for(int i=0; i<n; ++i){
+	            long tmp = A[i];
+	            int randomPos = i + rnd.nextInt(n-i);
+	            A[i] = A[randomPos];
+	            A[randomPos] = tmp;
+	        }
+	        Arrays.sort(A);
+	     }
+  static String sort(String s) {
+ 	 Character ch[]=new Character[s.length()];
+ 	 for(int i=0;i<s.length();i++) {
+ 		 ch[i]=s.charAt(i);
+ 	 }
+ 	 Arrays.sort(ch);
+ 	 StringBuffer st=new StringBuffer("""");
+ 	 for(int i=0;i<s.length();i++) {
+ 		 st.append(ch[i]);
+ 	 }
+ 	 return st.toString();
+  }
+  static HashMap<Integer,Integer> hash(int A[]){
+	  HashMap<Integer,Integer> map=new HashMap<Integer, Integer>();
+	  for(int i : A) {
+		  if(map.containsKey(i)) {
+			  map.put(i, map.get(i)+1);
+		  }
+		  else {
+			  map.put(i, 1);
+		  }
+	  }
+	  return map;
+  }
+  static TreeMap<Integer,Integer> tree(int A[]){
+	  TreeMap<Integer,Integer> map=new TreeMap<Integer, Integer>();
+	  for(int i : A) {
+		  if(map.containsKey(i)) {
+			  map.put(i, map.get(i)+1);
+		  }
+		  else {
+			  map.put(i, 1);
+		  }
+	  }
+	  return map;
+  }
+     static boolean prime(int n) 
+	    { 
+	        if (n <= 1) 
+	            return false; 
+	        if (n <= 3) 
+	            return true; 
+	        if (n % 2 == 0 || n % 3 == 0) 
+	            return false; 
+	        double sq=Math.sqrt(n);
+	  
+	        for (int i = 5; i <= sq; i = i + 6) 
+	            if (n % i == 0 || n % (i + 2) == 0) 
+	                return false; 
+	        return true; 
+	    } 
+     static boolean prime(long n) 
+	    { 
+	        if (n <= 1) 
+	            return false; 
+	        if (n <= 3) 
+	            return true; 
+	        if (n % 2 == 0 || n % 3 == 0) 
+	            return false; 
+	        double sq=Math.sqrt(n);
+	  
+	        for (int i = 5; i <= sq; i = i + 6) 
+	            if (n % i == 0 || n % (i + 2) == 0) 
+	                return false; 
+	        return true; 
+	    } 
+     static int gcd(int a, int b) 
+     { 
+         if (a == 0) 
+             return b; 
+         return gcd(b % a, a); 
+     } 
+     static long gcd(long a, long b) 
+     { 
+         if (a == 0) 
+             return b; 
+         return gcd(b % a, a); 
+     } 
+     
+        
+    static class FastReader 
+    { 
+        BufferedReader br; 
+        StringTokenizer st; 
+  
+        public FastReader() 
+        { 
+            br = new BufferedReader(new
+                     InputStreamReader(System.in)); 
+        } 
+  
+        String next() 
+        { 
+            while (st == null || !st.hasMoreElements()) 
+            { 
+                try
+                { 
+                    st = new StringTokenizer(br.readLine()); 
+                } 
+                catch (IOException  e) 
+                { 
+                    e.printStackTrace(); 
+                } 
+            } 
+            return st.nextToken(); 
+        } 
+  
+        int nextInt() 
+        { 
+            return Integer.parseInt(next()); 
+        } 
+  
+        long nextLong() 
+        { 
+            return Long.parseLong(next()); 
+        } 
+  
+        double nextDouble() 
+        { 
+            return Double.parseDouble(next()); 
+        } 
+  
+        String nextLine() 
+        { 
+            String str = """"; 
+            try
+            { 
+                str = br.readLine(); 
+            } 
+            catch (IOException e) 
+            { 
+                e.printStackTrace(); 
+            } 
+            return str; 
+        } 
+    } 
+} 
+
+
+
+","//package graphs;
+import java.util.*;
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.util.StringTokenizer;
+
+//import graphs.Segment_Trees.FastReader;
+
+public class PW {
+	
+	//private static BufferedWriter output = new BufferedWriter(new OutputStreamWriter(System.out));
+	
+	public static int memo[][];
+	public static FastReader s = new FastReader();
+	public static List<Long> primes;
+	public static int sz= 1000000;
+	//public static int arr[];
+	public static int MOD=1000000007;
+	public static List<List<Integer>> adj;
+	public static void main(String[] args) {
+		// TODO Auto-generated method stub
+	 
+		//FastScanner sc=new FastScanner();
+		 
+		int t=s.nextInt();
+		
+		while(t-- >0)
+		{
+			
+			//int n=0,a=0,b=0;
+			int n=s.nextInt();
+			int k=s.nextInt();
+	
+			  long arr[]=new long[n];
+			  Arrays.fill(arr,Long.MAX_VALUE/10);
+			  int ac[]=new int[k];
+			  long tmp[]=new long[k];
+			  for(int i = 0 ; i < k ; i++){
+			    ac[i]=s.nextInt();
+			    ac[i]--;
+			  }
+			  for(int i = 0 ; i < k ; i++){
+			    tmp[i]=s.nextLong();
+			    arr[ac[i]] = tmp[i];
+			  }
+			  long P[] = getP(arr, n);
+			  
+			  int i=0,j=arr.length-1;
+			  while(i<=j)
+			  {
+				  long temp=arr[i];
+				  arr[i]=arr[j];
+				  arr[j]=temp;
+				  i++;
+				  j--;
+			  }
+			  //reverse(all(arr));
+			  long[] S = getP(arr, n);
+			  //reverse(all(S));
+			  i=0;j=S.length-1;
+			  while(i<=j)
+			  {
+				  long temp=S[i];
+				  S[i]=S[j];
+				  S[j]=temp;
+				  i++;
+				  j--;
+			  }
+			  for(i = 0 ; i < n ; i++){
+			    System.out.print(Math.min(P[i], S[i])+"" "");
+			  }
+			  System.out.println();
+			
+		}
+		
+	}
+	
+	public static long[] getP(long []arr, int n){
+		  long mn = Long.MAX_VALUE/10;
+		  long P[]=new long[n];
+		  Arrays.fill(P, Long.MAX_VALUE/10);
+		  int cnt = 0;
+		  for(int i = 0 ; i < n ; i++){
+		    long curr = arr[i];
+		    if(mn + cnt < curr){
+		      P[i] = mn + cnt;
+		    }else{
+		      mn = arr[i];
+		      P[i] = arr[i];
+		      cnt  = 0;
+		    }
+		    cnt++;
+		  }
+		  return  P;
+		}
+		
+	public static void solve(int a[],int b[],int n,int m,int k)
+	{
+		List<Integer> ans = new ArrayList<>();
+        int i = 0;
+        int j = 0;
+        while (i < n && j < m) {
+                    if (a[i] == 0) {
+                ans.add(a[i]);
+                k++;
+                i++;
+                continue;
+            }
+            if (b[j] == 0) {
+                            ans.add(b[j]);
+                k++;
+                j++;
+                continue;
+            }
+            if (a[i] > 0 && b[j] > 0) {
+                if (a[i] <= b[j]) {
+                    if (a[i] > k) {
+                        System.out.println(-1);
+                        return;
+                    }
+                    ans.add(a[i]);
+                    i++;
+                }
+                else {
+                    if (b[j] > k) {
+                        System.out.println(-1);
+                        return;
+                    }
+                    ans.add(b[j]);
+                    j++;
+                }
+            }
+        }
+        while (i < n) {
+            if (a[i] > k) {
+                System.out.println(-1);
+                return;
+            }
+            if (a[i] == 0) k++;
+            ans.add(a[i++]);
+        }
+                   while (j < m) {
+            if (b[j] > k) {
+                System.out.println(-1);
+                return;
+            }
+            if (b[j] == 0) k++;
+            ans.add(b[j++]);
+        }
+        for (int x : ans) {
+            System.out.print(x + "" "");
+        }
+        System.out.println();
+	}
+		public static void dfs(int u, boolean visited[]){
+		  visited[u] = true;
+		  for(int v : adj.get(u)){
+		    if(!visited[v])
+		      dfs(v, visited);
+		  }
+		}
+	
+	public static boolean check(char c[][])
+	{
+		for(int i=0;i<c.length;i++)
+		{
+			for(int j=0;j<c[i].length;j++)
+			{
+				if(j+1<c[i].length && c[i][j]==c[i][j+1])
+					return false;
+				if(i+1<c.length && c[i][j]==c[i+1][j])
+					return false;
+				
+			}
+		}
+		return true;
+	}
+	
+	
+	
+	
+
+	
+	public static int solve(long n)
+	{
+		int c=0;
+		for(long i=2;i<Math.sqrt(n);i++)
+		{
+			if(n%i==0)
+			{
+				while(n%i==0)
+				{
+					n/=i;
+					c++;
+				}
+			}
+		}
+		
+		if(n!=1)
+			c++;
+		
+		return c;
+	}
+	
+	public static boolean helper(int arr[], int i, int sum){
+	     if(sum == 0){
+	          return true;
+	     }
+	     if(i>=arr.length || sum < 0){
+	          return false;
+	     }
+	     if(memo[i][sum] != -1){
+	          return memo[i][sum]==0?false:true;
+	     }
+	     boolean ans1 = helper(arr,i+1,sum-arr[i]);
+	     boolean ans2 = helper(arr,i+1,sum);
+	     boolean fin=ans1||ans2;
+	     if(fin==true)
+	    	 memo[i][sum]=1;
+	     else
+	    	 memo[i][sum]=0;
+	     return fin ;
+	}
+	
+//	public static long fastExpo(long a, long n, long mod) {
+//		  long result = 1;
+//		  while (n > 0) {
+//		    if ((n & 1)>0)
+//		      result = (result * a) % mod;
+//		    a = (a * a) % mod;
+//		    n >>= 1;
+//		  }
+//		  return result;
+//		}
+//	1  4   8
+	
+	public static int digit(int n)
+	{
+		int c=0;
+		while(n!=0)
+		{
+			n/=10;
+			c++;
+		}
+		return c;
+	}
+	 
+	public static int rev(String n)
+	{
+		String ans="""";
+		for(int i=n.length()-1;i>=0;i--)
+			ans=ans+n.charAt(i);
+		
+		return Integer.valueOf(ans);
+	}
+	 
+	public static boolean solve(HashMap<Integer,Integer> mp1,HashMap<Integer,Integer> mp2)
+	{
+		for(int i:mp2.keySet())
+		{
+			if(!mp1.containsKey(i))
+				return false;
+			
+			if(mp1.get(i)<mp2.get(i))
+				return false;
+		}
+		
+		return true;
+		
+	}
+	
+	
+	public static int count(int b[]){
+		  int s = 0;
+		  for (int i = 0; i < 32; i++) {
+		    if(b[i]>0){
+		      s |= (1<<i);
+		    }
+		  }
+		  return s;
+		}
+	
+	public static void remove(int b[], int val){
+		  for (int i = 0; i < 32; i++) {
+		    if(((val>>i)&1)==1)
+		      b[i]--;
+		  }
+		}
+	
+	public static void add(int b[], int val){
+		  for (int i = 0; i < 32; i++) {
+		    if(((val>>i)&1)==1)
+		      b[i]++;
+		  }
+		}
+	    public static String largestNumber( List<String> ab) {
+	        
+	       // List<String> ab= new ArrayList<>();
+	       // for(int i=0;i<A.size();i++)
+	       // {
+	       //     ab.add(String.valueOf(A.get(i)));
+	       // }
+	        
+	        Collections.sort(ab, new Comparator<String>(){ 
+	            
+	            public int compare(String X, String Y) { 
+	          
+	        // first append Y at the end of X 
+	        String XY=X + Y; 
+	          
+	        // then append X at the end of Y 
+	        String YX=Y + X; 
+	          
+	        // Now see which of the two formed numbers  
+	        // is greater 
+	        return XY.compareTo(YX)>0?-1:1; 
+	            
+	                
+	            }
+	            
+	            
+	            
+	        });
+	        StringBuilder abc= new StringBuilder();
+	        
+	        
+	        for(int i=0;i<ab.size();i++)
+	        {
+	           abc.append(ab.get(i));
+	            
+	        }
+	        if(abc.length()==0)
+	            return abc.toString();
+	        
+	        if(abc.charAt(0)=='0')
+	        return ""0"";
+	        else
+	        return abc.toString();
+	        
+	    }
+	
+	public static boolean pal(String s)
+	{
+		int i=0;
+		int j=s.length()-1;
+		while(i<=j)
+		{
+			if(s.charAt(i)!=s.charAt(j))
+				return false;
+			i++;
+			j--;
+		}
+		return true;
+	}
+	
+	
+	
+	
+	static class FastReader {
+        BufferedReader br;
+        StringTokenizer st;
+ 
+        public FastReader()
+        {
+            br = new BufferedReader(
+                new InputStreamReader(System.in));
+        }
+ 
+        String next()
+        {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                }
+                catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+ 
+        int nextInt() { return Integer.parseInt(next()); }
+ 
+        long nextLong() { return Long.parseLong(next()); }
+ 
+        double nextDouble()
+        {
+            return Double.parseDouble(next());
+        }
+ 
+        String nextLine()
+        {
+            String str = """";
+            try {
+                str = br.readLine();
+            }
+            catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+        }
+    }
+
+	
+	public static long solve(int n, int r)
+    {
+
+
+        long p = 1, k = 1;
+        if (n - r < r) {
+            r = n - r;
+        }
+ 
+        if (r != 0) {
+            while (r > 0) {
+                p *= n;
+                k *= r;
+ 
+                long m = __gcd(p, k);
+ 
+                
+                p /= m;
+                k /= m;
+ 
+                n--;
+                r--;
+            }
+ 
+           
+        }
+        else {
+            p = 1;
+        }
+ 
+        
+        //System.out.println(p);
+        return p;
+    }
+	
+	
+	public static long gcd(long a,long b)
+	{
+		if(a==0||b==0)
+			return a+b;
+		return gcd(b,(a%b));
+	}
+	
+	public static long __gcd(long n1, long n2)
+    {
+        long gcd = 1;
+ 
+        for (int i = 1; i <= n1 && i <= n2; ++i) {
+            // Checks if i is factor of both integers
+            if (n1 % i == 0 && n2 % i == 0) {
+                gcd = i;
+            }
+        }
+        return gcd;
+    }
+	
+	public static boolean prime(int n)
+	{
+		if(n<=2)
+			return true;
+		
+		for(int i=2;i<=Math.sqrt(n);i++)
+		{
+			if(n%i==0)
+				return false;
+		}
+		
+		return true;
+		
+	}
+	public static long fastExpo(long a,long n,long mod){
+        if (n == 0)
+            return 1;
+        else{
+            long x = fastExpo(a,n/2,mod);
+            if ((n&1) == 1){
+                return (((a*x)%mod)*x)%mod;
+            }
+            else{
+                return (((x%mod)*(x%mod))%mod)%mod;
+            }
+        }
+    }
+}
+class pair{
+	//public:
+		int f;
+		long s;
+		pair(int x,long y)
+		{
+			f=x;
+			s=y;
+		}
+        
+}
+ class FastScanner {
+    BufferedReader br;
+    StringTokenizer st;
+
+    public FastScanner()
+    {
+        br = new BufferedReader(
+                new InputStreamReader(System.in));
+    }
+
+    String next()
+    {
+        while (st == null || !st.hasMoreElements()) {
+            try {
+                st = new StringTokenizer(br.readLine());
+            }
+            catch (IOException e) {
+                e.printStackTrace();
+            }
+        }
+        return st.nextToken();
+    }
+
+    int nextInt() { return Integer.parseInt(next()); }
+
+    long nextLong() { return Long.parseLong(next()); }
+
+    double nextDouble()
+    {
+        return Double.parseDouble(next());
+    }
+
+    String nextLine()
+    {
+        String str = """";
+        try {
+            str = br.readLine();
+        }
+        catch (IOException e) {
+            e.printStackTrace();
+        }
+        return str;
+    }
+}
+
+
+",0
+01c915a2,4e5ee0f7,"			/*
+			TO LEARN
+			1-segment trees
+			2-euler tour
+		
+			*/
+			/*
+			TO SOLVE 
+			uva 1103
+			codeforces 722 kavi on pairing duty
+			*/
+			/*
+			bit manipulation shit
+			1-Computer Systems: A Programmer's Perspective
+			2-hacker's delight
+			3-(02-03-bits-ints)
+			4-machine-basics
+			5-Bits Manipulation tutorialspoint
+			*/
+			/*
+			TO WATCH
+			1-what is bitmasking by kartik arora youtube
+			*/
+			            import java.util.*;
+					    import java.math.*;
+					    import java.io.*; 
+					    import java.util.stream.Collectors;
+
+					       public class A{
+					     
+					  static InputStream inputStream = System.in;
+			            static FastScanner scan=new FastScanner();
+					     public static PrintWriter out = new PrintWriter (new BufferedOutputStream(System.out));
+	static final long p=29;
+	static final long mod=(long)1e9+9;
+	static int n,m;
+	static String spotty[],plain[];
+	static boolean check(int l)
+	{
+		 Map<Long,Set<Pair>>hashes=new HashMap<Long,Set<Pair>>();
+					    HashSet<Long>hashes2=new HashSet<Long>();
+					    long pow_p[]=new long[m];
+					    pow_p[0]=1;
+					    for(int i=1;i<m;i++)
+					    	pow_p[i]=(pow_p[i-1]*p);
+					    for(int i=0;i<n;i++)
+					    {
+					    	String s=plain[i];
+					    	long h[]=new long[m+1];
+					    	for(int j=0;j<m;j++)
+					    	{
+					    		h[j+1]=(h[j]+(s.charAt(j)-'a'+1)*pow_p[j]);
+					    	}
+					    	
+					    		for(int j=0;j<=m-l;j++)
+					    		{
+					    			long cur_h=(h[j+l]-h[j]);
+					    			cur_h=(cur_h*pow_p[m-j-1]);
+					    			if(hashes.containsKey(cur_h))
+					    				hashes.get(cur_h).add(new Pair(j,j+l));
+					    			else 
+					    			{
+					    				hashes.put(cur_h,new HashSet());
+					    				hashes.get(cur_h).add(new Pair(j,j+l));
+					    			}
+					    			//map.getOrDefault(cur_h,new ArrayList()).add(new Pair(j,j+1));
+					    			//hashes.put(cur_h,);
+					    		//	out.println(""FIR ""+cur_h);
+					    		}				    	
+					    }
+
+					        for(int i=0;i<n;i++)
+					    {
+					    	String s=spotty[i];
+					    	long h[]=new long[m+1];
+					    	for(int j=0;j<m;j++)
+					    	{
+					    		h[j+1]=(h[j]+(s.charAt(j)-'a'+1)*pow_p[j]);
+					    	}
+					    	
+					    		for(int j=0;j<=m-l;j++)
+					    		{
+					    			long cur_h=(h[j+l]-h[j]);
+					    			cur_h=(cur_h*pow_p[m-j-1]);
+
+					    			if(hashes.containsKey(cur_h)){
+					    				if(!hashes.get(cur_h).contains(new Pair(j,j+l)))
+					    					return true;
+					    			}
+					    			else{
+					    				out.println(j+"" ""+i);
+					    			 return true;
+					    			}
+					    		
+					    		}
+					    	
+					    }	
+					    return false;
+	}
+
+				public static void main(String[] args)  throws Exception 
+			      {
+				
+						///scan=new FastScanner(""cownomics.in"");
+					//out = new PrintWriter(""cownomics.out"");
+					 
+					 /*
+					 currently doing 
+					 1-digit dp
+					 2-ds like fenwick and interval tree and sparse table 
+					 */
+					 /*
+					 READING 
+					 1-Everything About Dynamic Programming codeforces
+					 2-DYNAMIC PROGRAMMING: FROM NOVICE TO ADVANCED topcoder
+					 3-Introduction to DP with Bitmasking codefoces
+					 4-Bit Manipulation hackerearth
+					 5-read more about mobious and inculsion-exclusion 
+					 */
+		
+
+
+
+					    int tt=1;
+					tt=scan.nextInt();
+					int T=tt;
+					/*Map<Integer,Pair>map=new HashMap<Integer,Pair>();
+					for(int i=1;i<=333333334;i++)
+					{
+						map.put(i+2*i,new Pair(i,2*i));
+						map.put(i+(2*(i+1)),new Pair(i,i+1));
+						map.put(i+1+(2*i),new Pair(i+1,i));
+					}*/
+
+				 outer:while(tt-->0)
+					    {
+					    int n=scan.nextInt();
+					   int cnt[][]=new int[n][5];
+					   String arr[]=new String[n];
+					   int sumlens=0;
+					   for(int i=0;i<n;i++)
+					   {
+					   	String s=scan.next();
+					   	sumlens+=s.length();
+					   	arr[i]=s;
+					   	for(int j=0;j<s.length();j++)
+					   		cnt[i][s.charAt(j)-'a']++;
+					   }
+					   int res=0;
+					   for(int to=0;to<5;to++)
+					   {
+					   	ArrayList<Pair>tmp=new ArrayList<Pair>();
+					   	int sumall=0;
+					   	for(int i=0;i<n;i++)
+					   		sumall+=cnt[i][to];
+					   	for(int i=0;i<n;i++)
+					   	{
+					   		int sum=0;
+					   		for(int j=0;j<5;j++)
+					   		{
+					   			if(j!=to)
+					   			{
+					   				sum+=cnt[i][j];
+					   			}
+					   		}
+					   		tmp.add(new Pair(arr[i].length()-sum,sum));
+					   	}
+					   	Collections.sort(tmp);
+					   	int THIS=sumall,THAT=sumlens-sumall;
+					   	//if(to==3)
+					  // 		out.println(tmp);
+					   	for(int i=0;i<tmp.size();i++)
+					   	{
+					   		if(THIS>THAT)
+					   		{
+					   		//	if(to==3)
+					   		//		out.println(""AHA ""+(n-i));
+					   			res=Math.max(res,n-i);
+					   			break;
+					   		}
+					   		THIS-=tmp.get(i).x;
+					   		THAT-=tmp.get(i).y;
+					   	}
+					   }
+					   out.println(res);
+					   
+					    
+
+					   
+
+					   
+					    	
+					    	
+			}
+			   out.close();
+		}
+		  	 
+			 		  
+					   
+					
+					static class special{
+						boolean bool;
+						int n;
+						//int id;
+						special(boolean bool,int n)
+						{
+							this.bool=bool;
+							this.n=n;
+						}
+						@Override
+						    public int hashCode() {
+					                int hash = 7;
+		    hash = 31 * hash + (int) n;
+		   
+		    return hash;
+					            }
+					              @Override
+					            public boolean equals(Object o){
+					                if (o == this) return true;
+					                if (o.getClass() != getClass()) return false;
+					                special t = (special)o;
+					                return t.bool == bool && t.n == n;
+					            }
+					}
+
+					   
+					     static long binexp(long a,long n)
+					    {
+					        if(n==0)
+					            return 1;
+					        long res=binexp(a,n/2);
+					        if(n%2==1)
+					            return res*res*a;
+					        else 
+					            return res*res;
+					    }
+					     
+					    static long powMod(long base, long exp, long mod) {
+					           if (base == 0 || base == 1) return base;
+					           if (exp == 0) return 1;
+					           if (exp == 1) return (base % mod+mod)%mod;
+					           long R = (powMod(base, exp/2, mod) % mod+mod)%mod;
+					           R *= R;
+					           R %= mod;
+					           if ((exp & 1) == 1) {
+					               return (base * R % mod+mod)%mod;
+					           }
+					           else return (R %mod+mod)%mod;
+					       }
+					    static double dis(double x1,double y1,double x2,double y2)
+					    {
+					        return Math.sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2));
+					    }
+					    static long mod(long x,long y)
+					        {
+					            if(x<0)
+					                x=x+(-x/y+1)*y;
+					            return x%y;
+					        }
+					     public static  long pow(long b, long e) {
+					                long r = 1;
+					                while (e > 0) {
+					                    if (e % 2 == 1) r = r * b ;
+					                    b = b * b;
+					                    e >>= 1;
+					                }
+					                return r;
+					            }
+					    private static void sort(long[] arr) {
+					            List<Long> list = new ArrayList<>();
+					            for (long object : arr) list.add(object);
+					            Collections.sort(list);
+					        //Collections.reverse(list);
+					            for (int i = 0; i < list.size(); ++i) arr[i] = list.get(i);
+					        }
+					    private static void sort2(long[] arr) {
+					            List<Long> list = new ArrayList<>();
+					            for (Long object : arr) list.add(object);
+					            Collections.sort(list);
+					        Collections.reverse(list);
+					            for (int i = 0; i < list.size(); ++i) arr[i] = list.get(i);
+					        }
+					     static class FastScanner
+			{
+			    private int BS = 1 << 16;
+			    private char NC = (char) 0;
+			    private byte[] buf = new byte[BS];
+			    private int bId = 0, size = 0;
+			    private char c = NC;
+			    private double cnt = 1;
+			    private BufferedInputStream in;
+			 
+			    public FastScanner() {
+			        in = new BufferedInputStream(System.in, BS);
+			    }
+			 
+			    public FastScanner(String s) {
+			        try {
+			            in = new BufferedInputStream(new FileInputStream(new File(s)), BS);
+			        } catch (Exception e) {
+			            in = new BufferedInputStream(System.in, BS);
+			        }
+			    }
+			 
+			    private char getChar() {
+			        while (bId == size) {
+			            try {
+			                size = in.read(buf);
+			            } catch (Exception e) {
+			                return NC;
+			            }
+			            if (size == -1) return NC;
+			            bId = 0;
+			        }
+			        return (char) buf[bId++];
+			    }
+			 
+			    public int nextInt() {
+			        return (int) nextLong();
+			    }
+			 
+			    public int[] nextInts(int N) {
+			        int[] res = new int[N];
+			        for (int i = 0; i < N; i++) {
+			            res[i] = (int) nextLong();
+			        }
+			        return res;
+			    }
+			 
+			    public long[] nextLongs(int N) {
+			        long[] res = new long[N];
+			        for (int i = 0; i < N; i++) {
+			            res[i] = nextLong();
+			        }
+			        return res;
+			    }
+			 
+			    public long nextLong() {
+			        cnt = 1;
+			        boolean neg = false;
+			        if (c == NC) c = getChar();
+			        for (; (c < '0' || c > '9'); c = getChar()) {
+			            if (c == '-') neg = true;
+			        }
+			        long res = 0;
+			        for (; c >= '0' && c <= '9'; c = getChar()) {
+			            res = (res << 3) + (res << 1) + c - '0';
+			            cnt *= 10;
+			        }
+			        return neg ? -res : res;
+			    }
+			 
+			    public double nextDouble() {
+			        double cur = nextLong();
+			        return c != '.' ? cur : cur + nextLong() / cnt;
+			    }
+			 
+			    public double[] nextDoubles(int N) {
+			        double[] res = new double[N];
+			        for (int i = 0; i < N; i++) {
+			            res[i] = nextDouble();
+			        }
+			        return res;
+			    }
+			 
+			    public String next() {
+			        StringBuilder res = new StringBuilder();
+			        while (c <= 32) c = getChar();
+			        while (c > 32) {
+			            res.append(c);
+			            c = getChar();
+			        }
+			        return res.toString();
+			    }
+			 
+			    public String nextLine() {
+			        StringBuilder res = new StringBuilder();
+			        while (c <= 32) c = getChar();
+			        while (c != '\n') {
+			            res.append(c);
+			            c = getChar();
+			        }
+			        return res.toString();
+			    }
+			 
+			    public boolean hasNext() {
+			        if (c > 32) return true;
+			        while (true) {
+			            c = getChar();
+			            if (c == NC) return false;
+			            else if (c > 32) return true;
+			        }
+			    }
+			}
+
+					     static class Pair implements Comparable<Pair>{
+					            public long x, y,z;
+					            public Pair(long x1, long y1,long z1) {
+					                x=x1;
+					                y=y1;
+					                z=z1;
+					            }
+					             public Pair(long x1, long y1) {
+					                x=x1;
+					                y=y1;
+					    
+					            }
+					            
+					            @Override
+					            public int hashCode() {
+					                return (int)(x + 31 * y);
+					            }
+					            public String toString() {
+					                return x + "" "" + y+"" ""+z;
+					            }
+					            @Override
+					            public boolean equals(Object o){
+					                if (o == this) return true;
+					                if (o.getClass() != getClass()) return false;
+					                Pair t = (Pair)o;
+					                return t.x == x && t.y == y&&t.z==z;
+					            }
+					    public int compareTo(Pair o)
+					    {
+					    	
+					    
+					    	return (int)((o.y-o.x)-(y-x));
+					     
+					        }
+					     
+					    }
+					    
+					    }
+
+					     
+","
+
+
+import java.io.*;
+import java.math.BigDecimal;
+import java.math.MathContext;
+import java.math.RoundingMode;
+import java.util.*;
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.util.Collections;
+import java.io.InputStreamReader;
+import static java.lang.Math.*;
+import static java.lang.System.*;
+
+public class Main1 {
+
+
+
+
+
+
+
+    public static void main(String[] args) throws IOException {
+
+//        try {
+//             Scanner in = new Scanner(System.in) ;
+        FastScanner in = new FastScanner();
+        PrintWriter out = new PrintWriter(System.out);
+
+
+
+            int t = in.nextInt() ;
+            while (t-- > 0){
+                int n = in.nextInt() ;
+                int dp[][] = new int[n][5] ;
+                String tt[] = new String[n] ;
+
+                for (int i = 0; i <n ; i++) {
+                    String  s= in.next() ;
+                    tt[i] = s ;
+                    for (int j = 0; j <s.length() ; j++) {
+                        dp[i][s.charAt(j)-'a']++ ;
+                    }
+                }
+                int max = 0 ;
+
+
+                for (int i = 0; i <5 ; i++) {
+                    ArrayList<Integer>list = new ArrayList<>() ;
+                    for (int j = 0; j <n ; j++) {
+                        list.add(dp[j][i] - (tt[j].length()-dp[j][i]) );
+                    }
+                    list.sort(Collections.reverseOrder());
+                    int ans = 0 ;
+                    int sum = 0 ;
+                    for (int curr : list){
+                        sum+= curr ;
+                        if (sum > 0){
+                            ans++ ;
+                            max = max(max , ans) ;
+                        }
+                        else break;
+                    }
+
+                }
+
+                System.out.println(max);
+            }
+
+
+
+
+
+
+
+
+
+
+            out.flush();
+            out.close();
+
+
+//        } catch (Exception e) {
+//            return;
+//        }
+
+}
+
+    static long gcd(long a, long b) {
+        return (b == 0) ? a : gcd(b, a % b);
+    }
+
+    static int gcd(int a, int b) {
+        return (b == 0) ? a : gcd(b, a % b);
+    }
+
+    static void sort(int ar[]) {
+        int n = ar.length;
+        ArrayList<Integer> a = new ArrayList<>();
+        for (int i = 0; i < n; i++)
+            a.add(ar[i]);
+        Collections.sort(a);
+        for (int i = 0; i < n; i++)
+            ar[i] = a.get(i);
+    }
+
+    static void sort1(long ar[]) {
+        int n = ar.length;
+        ArrayList<Long> a = new ArrayList<>();
+        for (int i = 0; i < n; i++)
+            a.add(ar[i]);
+        Collections.sort(a);
+        for (int i = 0; i < n; i++)
+            ar[i] = a.get(i);
+    }
+
+    static long ncr(long n, long r, long mod) {
+        if (r == 0)
+            return 1;
+        long val = ncr(n - 1, r - 1, mod);
+        val = (n * val) % mod;
+        val = (val * modInverse(r, mod)) % mod;
+        return val;
+    }
+
+    static long fast_pow(long base, long n, long M) {
+        if (n == 0)
+            return 1;
+        if (n == 1)
+            return base % M;
+        long halfn = fast_pow(base, n / 2, M);
+        if (n % 2 == 0)
+            return (halfn * halfn) % M;
+        else
+            return (((halfn * halfn) % M) * base) % M;
+    }
+
+    static long modInverse(long n, long M) {
+        return fast_pow(n, M - 2, M);
+    }
+
+
+    static class FastScanner {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st = new StringTokenizer("""");
+
+        String next() {
+            while (!st.hasMoreTokens())
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        int[] readArray(int n) {
+            int[] a = new int[n];
+            for (int i = 0; i < n; i++) a[i] = nextInt();
+            return a;
+        }
+
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+    }
+
+
+}
+
+
+
+
+
+
+
+",0
+80407703,99e059b8,"import java.util.Scanner;
+import java.util.Arrays;
+public class B {
+    public static int[] sort(int[] arr,int low,int high){
+        int[] sortedArray;
+        if (low==high) {
+            sortedArray=new int[]{arr[low]};
+            return sortedArray;
+        }
+        int mid=(low+high)/2;
+        int[] arr1=sort(arr,low,mid);
+        int[] arr2=sort(arr,mid+1,high);
+
+        sortedArray=merge(arr1,low,mid,arr2,mid+1,high);
+        return sortedArray;
+
+    }
+
+    public static int[] merge(int[] arr1,int low1,int high1,int[] arr2,int low2,int high2){
+
+        int size1=high1-low1+1;
+        int size2=high2-low2+1;
+        
+        int[] arr=new int[size1+size2];
+        int pointer=0;
+        low1=0;low2=0;
+        while (low1<size1 && low2<size2){
+            if (arr1[low1] <= arr2[low2]) {
+                arr[pointer++]=arr1[low1++];
+            }
+            else{
+                arr[pointer++]=arr2[low2++];
+            }
+
+        }
+
+        while(low1<size1) arr[pointer++]=arr1[low1++];
+        while(low2<size2) arr[pointer++]=arr2[low2++];
+        return arr;
+    }
+    
+    public static void main(String[] args){
+        Scanner sc=new Scanner(System.in);
+        int t=sc.nextInt();
+        while(t-- > 0){
+            int n=sc.nextInt();
+            long k=sc.nextLong();
+            int[] arr=new int[n];
+            long sum=0;
+            for(int i=0;i<n;i++) {
+                arr[i]=sc.nextInt();
+                sum+=arr[i];
+            }
+            if (sum<=k){
+                System.out.println(0);
+                continue;
+            }
+            long s[]=new long[n];
+            arr=sort(arr,0,n-1);
+            s[n-1]=arr[n-1]-arr[0];
+            long ans=sum-k;
+        
+            for(int i=n-2;i>=0;i--) s[i]=s[i+1]+arr[i]-arr[0];
+           
+            for(int i=n-1;i>=1;i--) {
+                
+                long caseAns=(sum-k-s[i]+n-i)/(n-i+1);
+                
+                caseAns=Math.max(caseAns,0);
+                caseAns+=n-i;
+                ans=Math.min(caseAns,ans);
+            }
+            System.out.println(ans);
+        }
+        sc.close();
+    }
+}
+","// हर हर महादेव
+import java.util.*;
+import java.lang.*;
+import java.io.*;
+import java.math.BigInteger;
+import java.text.DecimalFormat;
+
+public final class Solution {
+
+    static int inf = Integer.MAX_VALUE;
+    static long mod = 1000000000 + 7;
+  
+ static void ne(Scanner sc, BufferedWriter op) throws Exception {
+    int n=sc.nextInt();
+    long k=sc.nextLong();
+    long[] arr= new long[n];
+    long sum=0;
+    for(int i=0;i<n;i++){
+        arr[i]=sc.nextLong();
+        sum+=arr[i];
+    }
+    if(sum<=k){
+        op.write(""0\n"");
+        return;
+    }
+    sort(arr);
+    long min=sum-k;
+    long ss=0;
+    
+    int cc=0;
+    for(int i=n-1;i>=1;i--){
+          sum-=arr[i];
+          sum+=arr[0];
+          cc++;
+        if(sum<=k){
+          min=Math.min(min,cc);
+          break;
+        }
+    }
+   long val=Math.abs(arr[0]-(k/n))+(n-1);
+    min=Math.min(val,min);
+ 
+    for(int i=1;i<n;i++){
+        ss+=arr[i];
+        long no=((k-ss)/(long)(n-i));
+     
+        if(k-ss<0 && (k-ss)%(n-i)!=0){
+            no--;
+        }
+       long count=(n-i-1)+Math.abs(arr[0]-no);
+     
+        min=Math.min(count,min);
+    }
+    op.write(min+""\n"");
+
+
+
+
+ }
+ 
+  
+    
+  
+
+    public static void main(String[] args) throws Exception {
+        BufferedWriter op = new BufferedWriter(new OutputStreamWriter(System.out));
+        // Reader sc = new Reader();
+     
+        Scanner sc= new Scanner(System.in);
+        int t = sc.nextInt();
+        while (t-->0){ ne(sc, op); }
+        
+        // ne(sc,op);
+           
+                   
+        op.flush();
+    }
+
+    static void print(Object o) {
+        System.out.println(String.valueOf(o));
+    }
+    static int[] toIntArr(String s){
+        int[] val= new int[s.length()];
+        for(int i=0;i<s.length();i++){
+            val[i]=s.charAt(i)-'a';
+        }
+        return val;
+    }
+
+    static void  sort(int[] arr){
+        ArrayList<Integer> list= new ArrayList<>();
+        for(int i=0;i<arr.length;i++){
+            list.add(arr[i]);
+
+        }
+        Collections.sort(list);
+        for(int i=0;i<arr.length;i++){
+            arr[i]=list.get(i);
+        }
+    }
+       static void  sort(long[] arr){
+        ArrayList<Long> list= new ArrayList<>();
+        for(int i=0;i<arr.length;i++){
+            list.add(arr[i]);
+
+        }
+        Collections.sort(list);
+        for(int i=0;i<arr.length;i++){
+            arr[i]=list.get(i);
+        }
+    }
+
+}
+
+// return -1 to put no ahed in array
+class pair {
+    int  xx;
+    int yy;
+    pair(int xx, int yy ) {
+        this.xx = xx;
+        this.yy = yy;
+    }
+}
+
+
+class sortY implements Comparator<pair> {
+    public int compare(pair p1, pair p2) {
+        if (p1.yy > p2.yy) {
+            return 1;
+        } else if (p1.yy == p2.yy) {
+            if (p1.xx > p2.xx) {
+                return 1;
+            } else if (p1.xx < p2.xx) {
+                return -1;
+            }
+            return 0;
+
+        }
+        return -1;
+    }
+}
+
+class sortX implements Comparator<pair> {
+    public int compare(pair p1, pair p2) {
+        if (p1.xx > p2.xx) {
+            return 1;
+        } else if (p1.xx == p2.xx) {
+            if (p1.yy > p2.yy) {
+                return 1;
+            } else if (p1.yy < p2.yy) {
+                return -1;
+            }
+            return 0;
+
+        }
+        return -1;
+    }
+}
+
+class debug {
+
+    static void print1d(long[] arr) {
+        System.out.println();
+        for (int i = 0; i < arr.length; i++) {
+            System.out.print(arr[i] + "" "");
+        }
+
+    }
+
+    static void print1d(int[] arr) {
+        System.out.println();
+        for (int i = 0; i < arr.length; i++) {
+            System.out.println(i+"" = ""+arr[i]);
+        }
+
+    }
+
+    static void print1d(boolean[] arr) {
+        System.out.println();
+        for (int i = 0; i < arr.length; i++) {
+            System.out.println(i + ""= "" + arr[i]);
+        }
+
+    }
+
+    static void print2d(int[][] arr) {
+        System.out.println();
+        int n = arr.length;
+        int n2 = arr[0].length;
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < n2; j++) {
+                System.out.print(arr[i][j] + "" "");
+            }
+            System.out.println();
+        }
+
+    }
+       static void print2d(boolean[][] arr) {
+        System.out.println();
+        int n = arr.length;
+        int n2 = arr[0].length;
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < n2; j++) {
+                System.out.print(arr[i][j] + "" "");
+            }
+            System.out.println();
+        }
+
+    }
+
+    static void print2d(long[][] arr) {
+        System.out.println();
+        int n = arr.length;
+        int n2 = arr[0].length;
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < n2; j++) {
+                System.out.print(arr[i][j] + "" "");
+            }
+            System.out.println();
+        }
+
+    }
+     static void printPair(ArrayList<pair> list) {
+        if(list.size()==0){
+            System.out.println(""empty list"");
+            return;
+        }
+       System.out.println();
+       for(int i=0;i<list.size();i++){
+          System.out.println(list.get(i).xx+""-""+list.get(i).yy);
+       }
+    }
+
+}
+
+class Reader {
+    final private int BUFFER_SIZE = 1 << 16;
+    private DataInputStream din;
+    private byte[] buffer;
+    private int bufferPointer, bytesRead;
+
+    public Reader() {
+        din = new DataInputStream(System.in);
+        buffer = new byte[BUFFER_SIZE];
+        bufferPointer = bytesRead = 0;
+    }
+
+    public Reader(String file_name) throws IOException {
+        din = new DataInputStream(new FileInputStream(file_name));
+        buffer = new byte[BUFFER_SIZE];
+        bufferPointer = bytesRead = 0;
+    }
+
+    public String readLine() throws IOException {
+        byte[] buf = new byte[64]; // line length
+        int cnt = 0, c;
+        while ((c = read()) != -1) {
+            if (c == '\n') {
+                if (cnt != 0) {
+                    break;
+                } else {
+                    continue;
+                }
+            }
+            buf[cnt++] = (byte) c;
+        }
+        return new String(buf, 0, cnt);
+    }
+
+    public int nextInt() throws IOException {
+        int ret = 0;
+        byte c = read();
+        while (c <= ' ') {
+            c = read();
+        }
+        boolean neg = (c == '-');
+        if (neg)
+            c = read();
+        do {
+            ret = ret * 10 + c - '0';
+        } while ((c = read()) >= '0' && c <= '9');
+
+        if (neg)
+            return -ret;
+        return ret;
+    }
+
+    public long nextLong() throws IOException {
+        long ret = 0;
+        byte c = read();
+        while (c <= ' ')
+            c = read();
+        boolean neg = (c == '-');
+        if (neg)
+            c = read();
+        do {
+            ret = ret * 10 + c - '0';
+        } while ((c = read()) >= '0' && c <= '9');
+        if (neg)
+            return -ret;
+        return ret;
+    }
+
+    public double nextDouble() throws IOException {
+        double ret = 0, div = 1;
+        byte c = read();
+        while (c <= ' ')
+            c = read();
+        boolean neg = (c == '-');
+        if (neg)
+            c = read();
+
+        do {
+            ret = ret * 10 + c - '0';
+        } while ((c = read()) >= '0' && c <= '9');
+
+        if (c == '.') {
+            while ((c = read()) >= '0' && c <= '9') {
+                ret += (c - '0') / (div *= 10);
+            }
+        }
+
+        if (neg)
+            return -ret;
+        return ret;
+    }
+
+    private void fillBuffer() throws IOException {
+        bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
+        if (bytesRead == -1)
+            buffer[0] = -1;
+    }
+
+    private byte read() throws IOException {
+        if (bufferPointer == bytesRead)
+            fillBuffer();
+        return buffer[bufferPointer++];
+    }
+
+    public void close() throws IOException {
+        if (din == null)
+            return;
+        din.close();
+    }
+}
+ class MultiTreeSet<E> {
+	TreeMap<E, Integer> freqTreeMap = new TreeMap<E, Integer>();
+	int size;
+ 
+	public MultiTreeSet() {}
+ 
+	public MultiTreeSet(Collection<? extends E> c) {
+		for(E element : c)
+			add(element);
+	}
+ 
+	public int size() {
+		return size;
+	}
+ 
+	public void add(E element) {
+		Integer freq = freqTreeMap.get(element);
+		if(freq==null)
+			freqTreeMap.put(element, 1);
+		else
+			freqTreeMap.put(element,freq+1);
+		++size;
+	}
+ 
+	public void remove(E element) {
+		Integer freq = freqTreeMap.get(element);
+		if(freq!=null) {
+			if(freq==1)
+				freqTreeMap.remove(element);
+			else
+				freqTreeMap.put(element, freq-1);
+			--size;
+		}
+	}
+ 
+	public int get(E element) {
+		Integer freq = freqTreeMap.get(element);
+		if(freq==null)
+			return 0;
+		return freq;
+	}
+ 
+	public boolean contains(E element) {
+		return get(element)>0;
+	}
+ 
+	public boolean isEmpty() {
+		return size==0;
+	}
+ 
+	public E first() {
+		return freqTreeMap.firstKey();
+	}
+ 
+	public E last() {
+		return freqTreeMap.lastKey();
+	}
+ 
+	public E ceiling(E element) {
+		return freqTreeMap.ceilingKey(element);
+	}
+ 
+	public E floor(E element) {
+		return freqTreeMap.floorKey(element);
+	}
+ 
+	public E higher(E element) {
+		return freqTreeMap.higherKey(element);
+	}
+ 
+	public E lower(E element) {
+		return freqTreeMap.lowerKey(element);
+	}
+}
+ ",0
+45e38fad,ec8566b8,"import java.util.*;
+import java.io.*;
+
+
+
+public class C_Not_Assigning {
+    // For fast input output
+    static class FastReader {
+        BufferedReader br;
+        StringTokenizer st;
+
+        public FastReader() {
+            try {
+                br = new BufferedReader(
+                        new FileReader(""input.txt""));
+                PrintStream out = new PrintStream(new FileOutputStream(""output.txt""));
+                System.setOut(out);
+            } catch (Exception e) {
+                br = new BufferedReader(new InputStreamReader(System.in));
+            }
+        }
+
+        String next() {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+
+        String nextLine() {
+            String str = """";
+            try {
+                str = br.readLine();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+        }
+    }
+
+    static class Edge{
+        public int node;
+        public int next;
+        Edge(int node, int next){
+            this.node = node;
+            this.next = next;
+        }    
+    }
+    public static void dfs(int u, ArrayList<ArrayList<Edge>> g,int[] vis, int flag, int[] weight){
+        vis[u] = 1;
+        for(Edge e : g.get(u)){
+            if(vis[e.node] == 0){
+                if(flag == 0)
+                {
+                    weight[e.next] = 2;
+                    dfs(e.node, g, vis, 1, weight);
+                }
+                else
+                {
+                    weight[e.next] = 5;
+                    dfs(e.node, g, vis, 0, weight);
+                }
+            }
+        }
+    }
+    // end of fast i/o code
+    public static void main(String[] args) {
+        FastReader reader = new FastReader();
+        int t = reader.nextInt();
+        while(t-->0){
+            int n = reader.nextInt();
+            int[] order = new int[n+1];
+            int flag = 0; 
+            //ArrayList<ArrayList<Integer>> adj = new ArrayList<>(n+1);
+            //Map<Integer, List<Integer>> adj = new HashMap<>();
+            ArrayList<ArrayList<Edge>> graph= new ArrayList<>();
+            for(int i=0;i<n+1;i++){
+                graph.add(new ArrayList<>());
+            }
+            for(int i=0;i<n-1;i++){
+                int u = reader.nextInt();
+                int v = reader.nextInt();
+                order[u]++;
+                order[v]++;
+                graph.get(u).add(new Edge(v, i));
+                graph.get(v).add(new Edge(u, i));
+
+                if(order[u]==3 || order[v]==3){
+                    flag = 1;
+                }
+            }
+            if(flag == 1)
+                System.out.println(-1);
+            else{
+                for(int i=1;i<=n;i++){
+                    if(order[i] == 1){
+                        int[] vis = new int[n+1];
+                        int[] weight = new int[n];
+                        dfs(i, graph, vis, 0, weight);
+                        for(int j =0;j<n-1;j++){
+                            System.out.print(weight[j] + "" "");
+                        }
+                        break;
+                    }
+                }
+                System.out.println();
+            }
+        }
+    }
+}","import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.*;
+import java.util.concurrent.ThreadLocalRandom;
+
+public class A {
+    private static void sport(List<Integer>[] g, Map<W, Integer> map) {
+        int n = g.length;
+        for (int i = 0; i < n; i++) {
+            if (g[i].size() > 2) {
+                System.out.println(-1);
+                return;
+            }
+        }
+        int[] ans = new int[n - 1];
+        //dfs(new C(-1, 0), g, ans, 3, new HashSet<>());
+        Queue<int[]> queue = new LinkedList<>();
+        Set<Integer> seen = new HashSet<>();
+        int val = 3;
+        for (Integer integer : g[0]) {
+            Integer idx = map.get(new W(0, integer));
+            ans[idx] = val;
+            queue.add(new int[]{val, integer});
+            seen.add(integer);
+            val = val == 2 ? 3 : 2;
+        }
+        seen.add(0);
+        while (!queue.isEmpty()) {
+            int[] poll = queue.poll();
+            for (Integer u : g[poll[1]]) {
+                if (!seen.contains(u)) {
+                    seen.add(u);
+                    int curr = poll[0] == 2 ? 3 : 2;
+                    Integer integer = map.get(new W(poll[1], u));
+                    ans[integer] = curr;
+                    queue.add(new int[]{curr, u});
+                }
+            }
+        }
+        for (int an : ans) {
+            System.out.print(an + "" "");
+        }
+        System.out.println();
+    }
+
+    static class W {
+        int u;
+        int v;
+
+        public W(int u, int v) {
+            this.u = u;
+            this.v = v;
+        }
+
+        @Override
+        public boolean equals(Object o) {
+            if (this == o) return true;
+            if (o == null || getClass() != o.getClass()) return false;
+            W w = (W) o;
+            return u == w.u && v == w.v;
+        }
+
+        @Override
+        public int hashCode() {
+            return Objects.hash(u, v);
+        }
+    }
+
+    static void dfs(C v, List<C>[] g, int[] ans, int prev, Set<Integer> seen) {
+        if (v.i != -1) {
+            ans[v.i] = prev == 2 ? 3 : 2;
+        }
+        seen.add(v.v);
+        int next = prev == 2 ? 3 : 2;
+        for (C c : g[v.v]) {
+            if (!seen.contains(c.v)) {
+                dfs(c, g, ans, next, seen);
+            }
+            next = next == 2 ? 3 : 2;
+
+        }
+    }
+
+    static class C {
+        int i;
+        int v;
+
+        public C(int i, int v) {
+            this.i = i;
+            this.v = v;
+        }
+    }
+
+    public static void main(String[] args) throws IOException {
+        FastScanner sc = new FastScanner();
+        int t = sc.nextInt();
+        for (int i = 0; i < t; i++) {
+            int n = sc.nextInt();
+            List<Integer>[] g = new ArrayList[n];
+            for (int j = 0; j < n; j++) {
+                g[j] = new ArrayList<>();
+            }
+            Map<W, Integer> map = new HashMap<>();
+            for (int j = 0; j < n - 1; j++) {
+                int u = sc.nextInt() - 1;
+                int v = sc.nextInt() - 1;
+                g[u].add(v);
+                g[v].add(u);
+                map.put(new W(u, v), j);
+                map.put(new W(v, u), j);
+            }
+            sport(g, map);
+        }
+    }
+
+    static void shuffleArray(int[] ar) {
+        // If running on Java 6 or older, use `new Random()` on RHS here
+        Random rnd = ThreadLocalRandom.current();
+        for (int i = ar.length - 1; i > 0; i--) {
+            int index = rnd.nextInt(i + 1);
+            // Simple swap
+            int a = ar[index];
+            ar[index] = ar[i];
+            ar[i] = a;
+        }
+    }
+
+    static class FastScanner {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st = new StringTokenizer("""");
+
+        String next() {
+            while (!st.hasMoreTokens()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        void nextLine() throws IOException {
+            br.readLine();
+        }
+
+        long[] readArrayLong(int n) {
+            long[] a = new long[n];
+            for (int i = 0; i < n; i++) {
+                a[i] = nextLong();
+            }
+            return a;
+        }
+
+        int[] readArrayInt(int n) {
+            int[] a = new int[n];
+            for (int i = 0; i < n; i++) {
+                a[i] = nextInt();
+            }
+            return a;
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+    }
+}",0
+6db218a2,8ad1ad84,"import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.util.InputMismatchException;
+import java.util.*;
+import java.io.*;
+import java.lang.*;
+public class Main{
+    public static class InputReader {
+        private InputStream stream;
+        private byte[] buf = new byte[1024];
+        private int curChar;
+        private int numChars;
+        private InputReader.SpaceCharFilter filter;
+        private BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+     
+        public InputReader(InputStream stream) {
+            this.stream = stream;
+        }
+     
+        public int read() {
+            if (numChars==-1)
+                throw new InputMismatchException();
+     
+            if (curChar >= numChars) {
+                curChar = 0;
+                try {
+                    numChars = stream.read(buf);
+                }
+                catch (IOException e) {
+                    throw new InputMismatchException();
+                }
+     
+                if(numChars <= 0)
+                    return -1;
+            }
+            return buf[curChar++];
+        }
+     
+        public String nextLine() {
+            String str = """";
+            try {
+                str = br.readLine();
+            }
+            catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+        }
+        public int nextInt() {
+            int c = read();
+     
+            while(isSpaceChar(c))
+                c = read();
+     
+            int sgn = 1;
+     
+            if (c == '-') {
+                sgn = -1;
+                c = read();
+            }
+     
+            int res = 0;
+            do {
+                if(c<'0'||c>'9')
+                    throw new InputMismatchException();
+                res *= 10;
+                res += c - '0';
+                c = read();
+            }
+            while (!isSpaceChar(c));
+     
+            return res * sgn;
+        }
+     
+        public long nextLong() {
+            int c = read();
+            while (isSpaceChar(c))
+                c = read();
+            int sgn = 1;
+            if (c == '-') {
+                sgn = -1;
+                c = read();
+            }
+            long res = 0;
+     
+            do {
+                if (c < '0' || c > '9')
+                    throw new InputMismatchException();
+                res *= 10;
+                res += c - '0';
+                c = read();
+            }
+            while (!isSpaceChar(c));
+            return res * sgn;
+        }
+     
+        public double nextDouble() {
+            int c = read();
+            while (isSpaceChar(c))
+                c = read();
+            int sgn = 1;
+            if (c == '-') {
+                sgn = -1;
+                c = read();
+            }
+            double res = 0;
+            while (!isSpaceChar(c) && c != '.') {
+                if (c == 'e' || c == 'E')
+                    return res * Math.pow(10, nextInt());
+                if (c < '0' || c > '9')
+                    throw new InputMismatchException();
+                res *= 10;
+                res += c - '0';
+                c = read();
+            }
+            if (c == '.') {
+                c = read();
+                double m = 1;
+                while (!isSpaceChar(c)) {
+                    if (c == 'e' || c == 'E')
+                        return res * Math.pow(10, nextInt());
+                    if (c < '0' || c > '9')
+                        throw new InputMismatchException();
+                    m /= 10;
+                    res += (c - '0') * m;
+                    c = read();
+                }
+            }
+            return res * sgn;
+        }
+     
+        public String readString() {
+            int c = read();
+            while (isSpaceChar(c))
+                c = read();
+            StringBuilder res = new StringBuilder();
+            do {
+                res.appendCodePoint(c);
+                c = read();
+            }
+            while (!isSpaceChar(c));
+     
+            return res.toString();
+        }
+     
+        public boolean isSpaceChar(int c) {
+            if (filter != null)
+                return filter.isSpaceChar(c);
+            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
+        }
+     
+        public String next() {
+            return readString();
+        }
+     
+        public interface SpaceCharFilter {
+            public boolean isSpaceChar(int ch);
+        }
+    }
+ 
+    static long gcd(long a, long b){
+        if (a == 0)
+            return b;  
+        return gcd(b % a, a);  
+    }
+    static long lcm(long a, long b)  {
+        return (a*b)/gcd(a, b);  
+    }
+    public static void sortbyColumn(int arr[][], int col) 
+    { 
+        
+        Arrays.sort(arr, new Comparator<int[]>() { 
+            
+          @Override              
+          
+          public int compare(final int[] entry1,  
+                             final int[] entry2) { 
+  
+            
+            if (entry1[col] > entry2[col]) 
+                return 1; 
+            else
+                return -1; 
+          } 
+        });  
+    } 
+    static long func(long a[],int size,int s){
+        long max1=a[s];
+        long maxc=a[s];
+        for(int i=s+1;i<size;i++){
+            maxc=Math.max(a[i],maxc+a[i]);
+            max1=Math.max(maxc,max1);
+        }
+        return max1;
+    }
+    public static class Pair<U extends Comparable<U>, V extends Comparable<V>> implements Comparable<Pair<U, V>> {
+        public U x;
+        public V y;
+    
+        public Pair(U x, V y) {
+            this.x = x;
+            this.y = y;
+        }
+    
+        public int hashCode() {
+            return (x == null ? 0 : x.hashCode() * 31) + (y == null ? 0 : y.hashCode());
+        }
+    
+        public boolean equals(Object o) {
+            if (this == o)
+                return true;
+            if (o == null || getClass() != o.getClass())
+                return false;
+            Pair<U, V> p = (Pair<U, V>) o;
+            return (x == null ? p.x == null : x.equals(p.x)) && (y == null ? p.y == null : y.equals(p.y));
+        }
+    
+        public int compareTo(Pair<U, V> b) {
+            int cmpU = x.compareTo(b.x);
+            return cmpU != 0 ? cmpU : y.compareTo(b.y);
+        }
+    
+        public String toString() {
+            return String.format(""(%s, %s)"", x.toString(), y.toString());
+        }
+    
+    }
+    static class MultiSet<U extends Comparable<U>> {
+        public int sz = 0;
+        public TreeMap<U, Integer> t;
+ 
+        public MultiSet() {
+            t = new TreeMap<>();
+        }
+ 
+        public void add(U x) {
+            t.put(x, t.getOrDefault(x, 0) + 1);
+            sz++;
+        }
+ 
+        public void remove(U x) {
+            if (t.get(x) == 1) t.remove(x);
+            else t.put(x, t.get(x) - 1);
+            sz--;
+        }
+ 
+    }
+    static void shuffle(long[] a) {
+        Random get = new Random();
+        for (int i = 0; i < a.length; i++) {
+            int r = get.nextInt(a.length);
+            long temp = a[i];
+            a[i] = a[r];
+            a[r] = temp;
+        }
+    }
+    static long myceil(long a, long b){
+        return (a+b-1)/b;
+    }
+    
+    static long C(long n,long r){
+        long count=0,temp=n;
+        long ans=1;
+        long num=n-r+1,div=1;
+        while(num<=n){
+            ans*=num;
+            //ans+=MOD;
+            ans%=MOD;
+            ans*=mypow(div,MOD-2);
+            //ans+=MOD;
+            ans%=MOD;
+            num++;
+            div++;
+        }
+        
+        ans+=MOD;
+        return ans%MOD;
+    }
+    static long fact(long a){
+        long i,ans=1;
+        for(i=1;i<=a;i++){
+            ans*=i;
+            ans%=MOD;
+        }
+        return ans%=MOD;
+    }
+    static void sieve(int n){
+        is_sieve[0]=1;
+        is_sieve[1]=1;
+        int i,j,k;
+        for(i=2;i<n;i++){
+            if(is_sieve[i]==0){
+                sieve[i]=i;
+                tr.add(i);
+                for(j=i*i;j<n;j+=i){
+                    if(j>n||j<0){
+                        break;
+                    }
+                    is_sieve[j]=1;
+                    sieve[j]=i;
+                }
+            }
+        }
+    }
+    // static void calc(int n){
+    //     int i,j;
+    //     dp[n-1]=0;
+    //     if(n>1)
+    //     dp[n-2]=1;
+    //     for(i=n-3;i>=0;i--){
+    //         long ind=n-i-1;
+    //         dp[i]=((ind*(long)mypow(10,ind-1))%MOD+dp[i+1])%MOD;
+    //     }
+    // }
+    static long mypow(long x,long y){
+        long temp; 
+        if( y == 0) 
+            return 1; 
+        temp = mypow(x, y/2); 
+        if (y%2 == 0) 
+            return (temp*temp)%MOD; 
+        else
+            return ((x*temp)%MOD*(temp)%MOD)%MOD; 
+    }
+    static long dist[],dp[][],left[],right[];
+    static int visited[],isit[];
+    static ArrayList<Pair<Integer,Pair<Long,Long>>> adj[],li;
+    //static int dp[][][];
+    static int MOD=1000000007;
+    static char ch[];
+    static int[] sieve,is_sieve;
+    static TreeSet<Integer> tr;
+    static long mat[][];
+    
+    
+    static void dfs(int node,int par, Pair<Long,Long> p[]){
+        for(Pair<Integer,Pair<Long,Long>> pp:adj[node]){
+            if(pp.x!=par){
+                //sum+=Math.abs(selected[node]-selected[pp.x]);
+                dfs(pp.x,node,p);
+                //System.out.println(node+"" ""+pp.x);
+                long x=Math.abs(p[node].x-p[pp.x].x);
+                long y=Math.abs(p[node].x-p[pp.x].y);
+                long z=Math.abs(p[node].y-p[pp.x].x);
+                long w=Math.abs(p[node].y-p[pp.x].y);
+                
+                left[node]+=Math.max(x+left[pp.x],y+right[pp.x]);
+                right[node]+=Math.max(z+left[pp.x],w+right[pp.x]);
+                
+            }
+        }
+    }
+    
+    public static void main(String args[]){
+        InputStream inputStream = System.in;
+        OutputStream outputStream = System.out;
+        InputReader in = new InputReader(inputStream);
+        PrintWriter w = new PrintWriter(outputStream);
+        int t,i,j,tno=0,tte;
+        
+        t=in.nextInt();
+        //t=1;
+        //tte=t;
+        
+        while(t-->0){
+            //sum=0;
+            int n=in.nextInt();
+            adj=new ArrayList[n+1];
+            left=new long[n+1];
+            right=new long[n+1];
+            visited=new int[n+1];
+            for(i=0;i<n+1;i++){
+                adj[i]=new ArrayList<>();
+            }
+            Pair<Long,Long> p[]=new Pair[n+1];
+            for(i=1;i<=n;i++){
+                p[i]=new Pair<>(in.nextLong(),in.nextLong());
+            } 
+            for(i=0;i<n-1;i++){
+                int u,v;
+                u=in.nextInt();
+                v=in.nextInt();
+                adj[u].add(new Pair<>(v,p[v]));
+                adj[v].add(new Pair<>(u,p[u]));
+            }
+            
+            dfs(1,-1,p);
+            // for(i=0;i<n+1;i++){
+            //     w.print(selected[i]+"" "");
+            // }
+            // w.println();
+            w.println((long)Math.max(left[1],right[1]));
+        }
+        w.close();
+    }
+}
+","import java.io.*;
+import java.util.*;
+import java.math.*;
+import java.math.BigInteger; 
+//import javafx.util.*; 
+public final class B
+{    
+	 static PrintWriter out = new PrintWriter(System.out); 
+	static StringBuilder ans=new StringBuilder();
+	static FastReader in=new FastReader();
+	static ArrayList<Integer> g[];
+	static long mod=(long)(1e9+7);
+	static int D1[],D2[],par[];
+	static boolean set[];
+	static int value[];
+	static long INF=Long.MAX_VALUE;
+	static int N,M;
+	static long L[],R[],dp[][];
+	static int s=1;
+	public static void main(String args[])throws IOException
+	{  					
+		int T=i();
+		outer:while(T-->0)
+		{
+			int N=i();
+			setGraph(N);
+			for(int i=1; i<=N; i++)
+			{
+				L[i]=l();
+				R[i]=l();
+			}
+			for(int i=1; i<N; i++)
+			{
+				int a=i(),b=i();
+				g[a].add(b);
+				g[b].add(a);
+			}
+			f(1,-1);
+			out.println(Math.max(dp[0][1], dp[1][1]));
+		}
+		out.close();
+		//print(L);
+		//print(R);
+		
+		//print(dp[0]);
+		//print(dp[1]);
+		
+
+	}	
+	static void f(int n,int p)
+	{
+		for(int c:g[n])
+		{
+			if(c!=p)
+			{
+			f(c,n);
+			long a=dp[0][c]+Math.abs(L[c]-L[n]);
+			long b=dp[1][c]+Math.abs(R[c]-L[n]);
+			dp[0][n]+=Math.max(a, b);
+			a=dp[0][c]+Math.abs(L[c]-R[n]);
+			b=dp[1][c]+Math.abs(R[c]-R[n]);
+			dp[1][n]+=Math.max(a, b);
+			}
+		}
+	}
+	static boolean isPalin(char X[])
+	{
+		int l=0,r=X.length-1;
+		while(l<=r)
+		{
+			if(X[l]!=X[r])return false;
+			l++;
+			r--;
+		}
+		return true;
+	}
+
+	static boolean isSorted(int A[])
+	{
+		int N=A.length;
+		for(int i=0; i<N-1; i++)
+		{
+			if(A[i]>A[i+1])return false;
+		}
+
+		return true;		
+	}
+	static int f1(int x,ArrayList<Integer> A)
+	{
+		int l=-1,r=A.size();
+		while(r-l>1)
+		{
+			int m=(l+r)/2;
+			int a=A.get(m);
+			if(a<x)l=m;
+			else r=m;
+		}		
+		return l;
+	}
+
+
+	static int ask(int t,int i,int j,int x)
+	{
+		System.out.println(""? ""+t+"" ""+i+"" ""+j+"" ""+x);
+		return i();
+	}
+
+	static int ask(int a)
+	{
+		System.out.println(""? 1 ""+a);
+		return i();
+	}
+	static int f(int st,int end,int d)
+	{
+		if(st>end)return 0;
+		int a=0,b=0,c=0;
+		if(d>1)a=f(st+d-1,end,d-1);
+		b=f(st+d,end,d);
+		c=f(st+d+1,end,d+1);
+		return value[st]+max(a,b,c);
+	}
+	static int max(int a,int b,int c)
+	{
+		return Math.max(a, Math.max(c, b));
+	}
+	static int value(char X[],char Y[])
+	{
+		int c=0;
+		for(int i=0; i<7; i++)
+		{
+			if(Y[i]=='1' && X[i]=='0')return -1;
+			if(X[i]=='1' && Y[i]=='0')c++;
+		}
+		return c;
+	}
+	static boolean isValid(int i,int j)
+	{
+		if(i<0 || i>=N)return false;
+		if(j<0 || j>=M)return false;
+		return true;
+	}
+
+	static long fact(long N)
+	{
+		long num=1L;
+		while(N>=1)
+		{
+			num=((num%mod)*(N%mod))%mod;
+			N--;
+		}
+		return num;
+	}
+	static boolean reverse(long A[],int l,int r)
+	{
+		while(l<r)
+		{
+			long t=A[l];
+			A[l]=A[r];
+			A[r]=t;
+			l++;
+			r--;
+		}
+		if(isSorted(A))return true;
+		else return false;
+	}
+	static boolean isSorted(long A[])
+	{
+		for(int i=1; i<A.length; i++)if(A[i]<A[i-1])return false;
+		return true;
+	}
+	static boolean isPalindrome(char X[],int l,int r)
+	{
+		while(l<r)
+		{
+			if(X[l]!=X[r])return false;
+			l++; r--;
+		}
+		return true;
+	}
+
+	static long min(long a,long b,long c)
+	{
+		return Math.min(a, Math.min(c, b));
+	}
+
+	static void print(int a)
+	{
+		System.out.println(""! ""+a);
+	}
+	static int ask(int a,int b)
+	{
+		System.out.println(""? ""+a+"" ""+b);
+		return i();
+	}
+	static int find(int a)
+	{
+		if(par[a]<0)return a;
+		return par[a]=find(par[a]);
+	}
+	static void union(int a,int b)
+	{
+		a=find(a);
+		b=find(b);
+		if(a!=b)
+		{
+			par[a]+=par[b]; //transfers the size
+			par[b]=a;       //changes the parent
+		}
+	}
+	static void swap(char A[],int a,int b)
+	{
+		char ch=A[a];
+		A[a]=A[b];
+		A[b]=ch;
+	}
+
+	static void sort(long[] a) //check for long
+	{
+		ArrayList<Long> l=new ArrayList<>();
+		for (long i:a) l.add(i);
+		Collections.sort(l);
+		for (int i=0; i<a.length; i++) a[i]=l.get(i);
+	}
+	static void setGraph(int N)
+	{
+		g=new ArrayList[N+1];
+		dp=new long[2][N+1];
+		L=new long[N+1];
+		R=new long[N+1];
+		for(int i=0; i<=N; i++)
+		{
+
+			g[i]=new ArrayList<Integer>();
+		}
+	}
+
+	static  long pow(long a,long b)
+	{
+		long mod=1000000007;
+		long pow=1;
+		long x=a;
+		while(b!=0)
+		{
+			if((b&1)!=0)pow=(pow*x)%mod;
+			x=(x*x)%mod;
+			b/=2;
+		}
+		return pow;
+	}
+	static long toggleBits(long x)//one's complement || Toggle bits
+	{
+		int n=(int)(Math.floor(Math.log(x)/Math.log(2)))+1;
+
+		return ((1<<n)-1)^x;
+	}
+	static int countBits(long a)
+	{
+		return (int)(Math.log(a)/Math.log(2)+1);
+	}
+	static void sort(int[] a) {
+		ArrayList<Integer> l=new ArrayList<>();
+		for (int i:a) l.add(i);
+		Collections.sort(l);
+		for (int i=0; i<a.length; i++) a[i]=l.get(i);
+	}
+	static boolean isPrime(long N)
+	{
+		if (N<=1)  return false; 
+		if (N<=3)  return true; 
+		if (N%2 == 0 || N%3 == 0) return false; 
+		for (int i=5; i*i<=N; i=i+6) 
+			if (N%i == 0 || N%(i+2) == 0) 
+				return false; 
+		return true; 
+	}
+	static long GCD(long a,long b) 
+	{
+		if(b==0)
+		{
+			return a;
+		}
+		else return GCD(b,a%b );
+	}
+
+	//Debugging Functions Starts
+
+	static void print(char A[])
+	{
+		for(char c:A)System.out.print(c+"" "");
+		System.out.println();
+	}
+	static void print(boolean A[])
+	{
+		for(boolean c:A)System.out.print(c+"" "");
+		System.out.println();
+	}
+	static void print(int A[])
+	{
+		for(int a:A)System.out.print(a+"" "");
+		System.out.println();	
+	}
+	static void print(long A[])
+	{
+		for(long i:A)System.out.print(i+ "" "");
+		System.out.println();
+
+	}
+	static void print(ArrayList<Integer> A)
+	{
+		for(int a:A)System.out.print(a+"" "");
+		System.out.println();
+	}
+
+	//Debugging Functions END
+	//----------------------
+	//IO FUNCTIONS STARTS
+	static HashMap<Integer,Integer> Hash(int A[])
+	{
+		HashMap<Integer,Integer> mp=new HashMap<>();
+		for(int a:A)
+		{
+			int f=mp.getOrDefault(a,0)+1;
+			mp.put(a, f);
+		}
+		return mp;
+	}
+	static int i()
+	{
+		return in.nextInt();
+	}
+
+	static long l()
+	{
+		return in.nextLong();
+	}
+
+	static int[] input(int N){
+		int A[]=new int[N];
+		for(int i=0; i<N; i++)
+		{
+			A[i]=in.nextInt();
+		}
+		return A;
+	}
+
+	static long[] inputLong(int N)     {
+		long A[]=new long[N];
+		for(int i=0; i<A.length; i++)A[i]=in.nextLong();
+		return A;
+	}
+
+	//IO FUNCTIONS END
+
+}
+
+class node implements Comparable<node>
+{
+	int x,index; boolean right;
+	node(int x,boolean right,int index)
+	{
+		this.x=x;
+		this.right=right;
+		this.index=index;
+	}
+	public int compareTo(node X)
+	{
+		return this.x-X.x;
+	}
+}
+
+//Code For FastReader
+//Code For FastReader
+//Code For FastReader
+//Code For FastReader
+class FastReader
+{
+	BufferedReader br;
+	StringTokenizer st;
+	public FastReader()
+	{
+		br=new BufferedReader(new InputStreamReader(System.in));
+	}
+
+	String next()
+	{
+		while(st==null || !st.hasMoreElements())
+		{
+			try
+			{
+				st=new StringTokenizer(br.readLine());
+			}
+			catch(IOException e)
+			{
+				e.printStackTrace();
+			}
+		}
+		return st.nextToken();
+	}
+
+	int nextInt()
+	{
+		return Integer.parseInt(next());
+	}
+
+	long nextLong()
+	{
+		return Long.parseLong(next());
+	}
+	//gey
+	double nextDouble()
+	{
+		return Double.parseDouble(next());
+	}
+
+	String nextLine()
+	{
+		String str="""";
+		try
+		{
+			str=br.readLine();
+		}
+		catch (IOException e)
+		{
+			e.printStackTrace();
+		}
+		return str;
+	}
+
+}",0
+43ca682a,baebdc56,"import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.Arrays;
+import java.util.Random;
+import java.util.StringTokenizer;
+
+public class D {
+	
+	static final int mod=998244353;
+	
+	static long[] facts, factInvs;
+
+	public static void main(String[] args) {
+		precomp();
+		FastScanner fs=new FastScanner();
+		int n=fs.nextInt(), k=fs.nextInt();
+		Seg[] segs=new Seg[n];
+		for (int i=0; i<n; i++) segs[i]=new Seg(fs.nextInt(), fs.nextInt());
+		Event[] events=new Event[n*2];
+		for (int i=0; i<n; i++) {
+			events[2*i]=new Event(segs[i], true);
+			events[2*i+1]=new Event(segs[i], false);
+		}
+		long ans=0;
+
+		Arrays.sort(events);
+		int counter=0;
+		for (Event e:events) {
+			if (e.start) {
+				counter++;
+			}
+			else {
+				counter--;
+				if (counter+1<k)
+					continue;
+				else
+					ans=add(ans, nCk(counter, k-1));
+			}
+		}
+		System.out.println(ans);
+	}
+
+	static final Random random=new Random();
+	
+	static void ruffleSort(int[] a) {
+		int n=a.length;//shuffle, then sort 
+		for (int i=0; i<n; i++) {
+			int oi=random.nextInt(n), temp=a[oi];
+			a[oi]=a[i]; a[i]=temp;
+		}
+		Arrays.sort(a);
+	}
+	
+	static long add(long a, long b) {
+		return (a+b)%mod;
+	}
+	
+	static long mul(long a, long b) {
+		return a*b%mod;
+	}
+	
+	static long exp(long base, long e) {
+		if (e==0) return 1;
+		long half=exp(base, e/2);
+		if (e%2==0) return mul(half, half);
+		return mul(half, mul(half, base));
+	}
+	
+	static long modInv(long x) {
+		return exp(x, mod-2);
+	}
+	
+	static void precomp() {
+		facts=new long[1_000_000];
+		factInvs=new long[1_000_000];
+		factInvs[0]=facts[0]=1;
+		for (int i=1; i<facts.length; i++)
+			facts[i]=mul(facts[i-1], i);
+		factInvs[facts.length-1]=modInv(facts[facts.length-1]);
+		for (int i=facts.length-2; i>=0; i--)
+			factInvs[i]=mul(factInvs[i+1], i+1);
+	}
+	
+	static long nCk(int n, int k) {
+		return mul(facts[n], mul(factInvs[k], factInvs[n-k]));
+	}
+	
+	static class Seg {
+		int l, r;
+		public Seg(int l, int r) {
+			this.l=l;
+			this.r=r;
+		}
+	}
+	
+	static class Event implements Comparable<Event> {
+		boolean start;
+		Seg s;
+		public Event(Seg s, boolean start) {
+			this.s=s;
+			this.start=start;
+		}
+
+		int x() {
+			if (start) return s.l;
+			return s.r;
+		}
+		
+		public int compareTo(Event o) {
+			if (x()!=o.x()) return Integer.compare(x(), o.x());
+			if (start==o.start)return 0;
+			if (start) return -1;
+			return 1;
+		}
+	}
+	
+	static class FastScanner {
+		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st=new StringTokenizer("""");
+		String next() {
+			while (!st.hasMoreTokens())
+				try {
+					st=new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			return st.nextToken();
+		}
+		
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+		int[] readArray(int n) {
+			int[] a=new int[n];
+			for (int i=0; i<n; i++) a[i]=nextInt();
+			return a;
+		}
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+	}
+
+	
+}
+","import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.Arrays;
+import java.util.Random;
+import java.util.StringTokenizer;
+
+public class D {
+	
+	static final int mod=998244353;
+	
+	static long[] facts, factInvs;
+
+	public static void main(String[] args) {
+		precomp();
+		FastScanner fs=new FastScanner();
+		int n=fs.nextInt(), k=fs.nextInt();
+		Seg[] segs=new Seg[n];
+		for (int i=0; i<n; i++) segs[i]=new Seg(fs.nextInt(), fs.nextInt());
+		Event[] events=new Event[n*2];
+		for (int i=0; i<n; i++) {
+			events[2*i]=new Event(segs[i], true);
+			events[2*i+1]=new Event(segs[i], false);
+		}
+		long ans=0;
+
+		Arrays.sort(events);
+		int counter=0;
+		for (Event e:events) {
+			if (e.start) {
+				counter++;
+			}
+			else {
+				counter--;
+				if (counter+1<k)
+					continue;
+				else
+					ans=add(ans, nCk(counter, k-1));
+			}
+		}
+		System.out.println(ans);
+	}
+
+	static final Random random=new Random();
+	
+	static void ruffleSort(int[] a) {
+		int n=a.length;//shuffle, then sort 
+		for (int i=0; i<n; i++) {
+			int oi=random.nextInt(n), temp=a[oi];
+			a[oi]=a[i]; a[i]=temp;
+		}
+		Arrays.sort(a);
+	}
+	
+	static long add(long a, long b) {
+		return (a+b)%mod;
+	}
+	
+	static long mul(long a, long b) {
+		return a*b%mod;
+	}
+	
+	static long exp(long base, long e) {
+		if (e==0) return 1;
+		long half=exp(base, e/2);
+		if (e%2==0) return mul(half, half);
+		return mul(half, mul(half, base));
+	}
+	
+	static long modInv(long x) {
+		return exp(x, mod-2);
+	}
+	
+	static void precomp() {
+		facts=new long[1_000_000];
+		factInvs=new long[1_000_000];
+		factInvs[0]=facts[0]=1;
+		for (int i=1; i<facts.length; i++)
+			facts[i]=mul(facts[i-1], i);
+		factInvs[facts.length-1]=modInv(facts[facts.length-1]);
+		for (int i=facts.length-2; i>=0; i--)
+			factInvs[i]=mul(factInvs[i+1], i+1);
+	}
+	
+	static long nCk(int n, int k) {
+		return mul(facts[n], mul(factInvs[k], factInvs[n-k]));
+	}
+	
+	static class Seg {
+		int l, r;
+		public Seg(int l, int r) {
+			this.l=l;
+			this.r=r;
+		}
+	}
+	
+	static class Event implements Comparable<Event> {
+		boolean start;
+		Seg s;
+		public Event(Seg s, boolean start) {
+			this.s=s;
+			this.start=start;
+		}
+
+		int x() {
+			if (start) return s.l;
+			return s.r;
+		}
+		
+		public int compareTo(Event o) {
+			if (x()!=o.x()) return Integer.compare(x(), o.x());
+			if (start==o.start)return 0;
+			if (start) return -1;
+			return 1;
+		}
+	}
+	
+	static class FastScanner {
+		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st=new StringTokenizer("""");
+		String next() {
+			while (!st.hasMoreTokens())
+				try {
+					st=new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			return st.nextToken();
+		}
+		
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+		int[] readArray(int n) {
+			int[] a=new int[n];
+			for (int i=0; i<n; i++) a[i]=nextInt();
+			return a;
+		}
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+	}
+
+	
+}
+",1
+13860c31,870e16d9,"import java.io.IOException;
+import java.io.InputStream;
+import java.lang.reflect.Array;
+import java.util.ArrayList;
+import java.util.InputMismatchException;
+
+/**
+ * Accomplished using the EduTools plugin by JetBrains https://plugins.jetbrains.com/plugin/10081-edutools
+ */
+
+public class Main {
+   static InputReader sc=new InputReader(System.in);
+   public static void main(String[] args) {
+      // Write your solution here
+      int t=sc.nextInt();
+      while(t-->0){
+         solve();
+      }
+
+   }
+
+   private static void solve() {
+      int n=sc.nextInt();
+      char[] a=sc.nextLine().toCharArray();
+      char[] b = sc.nextLine().toCharArray();
+      int sml=0,nsml=0;
+      boolean flag=false;
+      int sm1=0;
+      int nsm1=0;
+      for(int i=0;i<n;i++){
+         if(a[i]==b[i]){
+            sml++;
+            if(a[i]=='1')sm1++;
+         }else {
+            if (a[i] == '1') nsm1++;
+            nsml++;
+         }
+      }
+      int d1=sml-2*sm1;
+      int d2=nsml-2*nsm1;
+      int ans=-1;
+      if(sml%2==1&&nsml%2==1&&d1==-1){
+         ans=sml;
+      }else if(sml%2==0&&nsml%2==0&&d2==0){
+         ans=nsml;
+      }else if(sml%2==1&&nsml%2==0&&(d1==-1||d2==0)){
+         if(d1==-1&&d2!=0){
+            ans=sml;
+         }else if(d1!=-1&&d2==0){
+            ans=nsml;
+         }else if(d1==-1&&d2==0){
+            ans=Math.min(sml,nsml);
+         }
+      }
+      if(sml==n)ans=0;
+      System.out.println(ans);
+   }
+}
+class InputReader {
+
+   private final InputStream stream;
+   private final byte[] buf = new byte[8192];
+   private int curChar, snumChars;
+
+   public InputReader(InputStream st) {
+      this.stream = st;
+   }
+
+   public int read() {
+      if (snumChars == -1)
+         throw new InputMismatchException();
+      if (curChar >= snumChars) {
+         curChar = 0;
+         try {
+            snumChars = stream.read(buf);
+         } catch (IOException e) {
+            throw new InputMismatchException();
+         }
+         if (snumChars <= 0)
+            return -1;
+      }
+      return buf[curChar++];
+   }
+
+   public int nextInt() {
+      int c = read();
+      while (isSpaceChar(c)) {
+         c = read();
+      }
+      int sgn = 1;
+      if (c == '-') {
+         sgn = -1;
+         c = read();
+      }
+      int res = 0;
+      do {
+         res *= 10;
+         res += c - '0';
+         c = read();
+      } while (!isSpaceChar(c));
+      return res * sgn;
+   }
+
+   public long nextLong() {
+      int c = read();
+      while (isSpaceChar(c)) {
+         c = read();
+      }
+      int sgn = 1;
+      if (c == '-') {
+         sgn = -1;
+         c = read();
+      }
+      long res = 0;
+      do {
+         res *= 10;
+         res += c - '0';
+         c = read();
+      } while (!isSpaceChar(c));
+      return res * sgn;
+   }
+
+   public int[] nextIntArray(int n) {
+      int a[] = new int[n];
+      for (int i = 0; i < n; i++) {
+         a[i] = nextInt();
+      }
+      return a;
+   }
+
+   public String readString() {
+      int c = read();
+      while (isSpaceChar(c)) {
+         c = read();
+      }
+      StringBuilder res = new StringBuilder();
+      do {
+         res.appendCodePoint(c);
+         c = read();
+      } while (!isSpaceChar(c));
+      return res.toString();
+   }
+
+   public String nextLine() {
+      int c = read();
+      while (isSpaceChar(c))
+         c = read();
+      StringBuilder res = new StringBuilder();
+      do {
+         res.appendCodePoint(c);
+         c = read();
+      } while (!isEndOfLine(c));
+      return res.toString();
+   }
+
+   public boolean isSpaceChar(int c) {
+      return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
+   }
+
+   private boolean isEndOfLine(int c) {
+      return c == '\n' || c == '\r' || c == -1;
+   }
+
+}
+","import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.*;
+
+public class CF1 {
+    public static void main(String[] args) {
+        FastScanner sc=new FastScanner();
+        int T=sc.nextInt();
+//        int T=1;
+        for (int tt=0; tt<T; tt++){
+           int n =sc.nextInt();
+           String a = sc.next();
+           String b= sc.next();
+           int candles1=0;
+           int candles2=0;
+           int inPlace=0;
+           for (int i=0; i<n; i++){
+               if (a.charAt(i)=='1'){
+                   candles1++;
+               }
+               if (b.charAt(i)=='1') candles2++;
+               if (b.charAt(i)=='1' && a.charAt(i)=='1') inPlace++;
+           }
+           if (candles1==candles2 || n+1-candles2==candles1){
+             int ans=Math.min(help(candles1-inPlace, inPlace,n+1,candles2,0,0), help(candles1-inPlace, inPlace,n+1,candles2,0,1));
+             if (ans==Integer.MAX_VALUE) System.out.println(-1);
+             else System.out.println(ans);
+           }
+           else System.out.println(-1);
+        }
+    }
+    static int help(int i, int j, int max, int cands, int moves, int flip){
+        if (j==cands && i==0) return moves;
+        else if (j==0 && flip==0 || flip==1 && i==0 ) return Integer.MAX_VALUE;
+
+            if (flip==0){
+                int x=0;
+                int y=cands-j+1;
+                if (i+j==max-cands){
+                    x=cands-y;
+                }
+                else x=max-cands-y;
+                return help(x,y,max,cands,moves+1,1);
+            }
+            else {
+                int x=0;
+                int y=cands-j;
+                if (i+j==max-cands){
+                    x=cands-y;
+                }
+                else x=max-cands-y;
+                return help(x,y,max,cands,moves+1,0);
+            }
+        
+    }
+    static long mod =998244353L;
+    static long power (long a, long b){
+        long res=1;
+        while (b>0){
+            if ((b&1)== 1){
+                res= (res * a % mod)%mod;
+            }
+            a=(a%mod * a%mod)%mod;
+            b=b>>1;
+        }
+        return res;
+    }
+
+    boolean[] sieveOfEratosthenes(int n)
+    {
+
+        boolean prime[] = new boolean[n+1];
+        for(int i=0;i<=n;i++)
+            prime[i] = true;
+
+        for(int p = 2; p*p <=n; p++)
+        {
+            if(prime[p] == true)
+            {
+                for(int i = p*p; i <= n; i += p)
+                    prime[i] = false;
+            }
+        }
+        return prime;
+    }
+    static void sort(int[] a) {
+        ArrayList<Integer> l=new ArrayList<>();
+        for (int i:a) l.add(i);
+        Collections.sort(l);
+        for (int i=0; i<a.length; i++) a[i]=l.get(i);
+    }
+    static void sortLong(long[] a) {
+        ArrayList<Long> l=new ArrayList<>();
+        for (long i:a) l.add(i);
+        Collections.sort(l);
+        for (int i=0; i<a.length; i++) a[i]=l.get(i);
+    }
+    static long gcd (long n, long m){
+        if (m==0) return n;
+        else return gcd(m, n%m);
+    }
+
+    static class Pair implements Comparable<Pair>{
+        int x,y;
+        public Pair(int x, int y){
+            this.x = x;
+            this.y = y;
+        }
+        public int compareTo(Pair o){
+            return -this.x+o.x;
+        }
+    }
+    static class FastScanner {
+        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st=new StringTokenizer("""");
+        String next() {
+            while (!st.hasMoreTokens())
+                try {
+                    st=new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+        int[] readArray(int n) {
+            int[] a=new int[n];
+            for (int i=0; i<n; i++) a[i]=nextInt();
+            return a;
+        }
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+    }
+}",0
+1097b326,f1f600d9,"// package com.company;
+
+import java.util.Scanner;
+
+public class Main {
+
+    public static void solution1(){
+        Scanner scanner = new Scanner(System.in);
+        int t = scanner.nextInt();
+        while (t-- != 0){
+            int n, k1, k2, w, b;
+            n = scanner.nextInt();
+            k1 = scanner.nextInt();
+            k2 = scanner.nextInt();
+            w = scanner.nextInt();
+            b = scanner.nextInt();
+            if (k1 < k2){
+                int temp = k1;
+                k1 = k2;
+                k2 = temp;
+            }
+            int white_dominoes = k2 + (k1 - k2) / 2;
+            int black_dominoes = (n - k1) + (k1 - k2) / 2;
+            if (white_dominoes >= w && black_dominoes >= b)
+            {
+                System.out.println(""YES"");
+            }
+            else
+                System.out.println(""NO"");
+        }
+        scanner.close();
+    }
+
+    public static void solution2(){
+        Scanner scanner = new Scanner(System.in);
+        int t = scanner.nextInt();
+        scanner.nextLine();
+        while (t-- != 0) {
+            String s;
+            s = scanner.nextLine();
+            boolean flag = true;
+            int first_ones = -1, last_zeroes = -1;
+            for (int i=0; i<s.length() - 1; i++){
+                if (s.charAt(i) == '1' && s.charAt(i+1) == '1'){
+                    first_ones = i;
+                    break;
+                }
+            }
+            for (int i=s.length() - 1; i>0; i--){
+                if (s.charAt(i) == '0' && s.charAt(i-1) == '0'){
+                    last_zeroes = i-1;
+                    break;
+                }
+            }
+            if (first_ones != -1 && last_zeroes != -1 && first_ones < last_zeroes) flag = false;
+            if (flag) System.out.println(""YES"");
+            else System.out.println(""NO"");
+        }
+        scanner.close();
+    }
+
+    public static void solution3(){
+        Scanner scanner = new Scanner(System.in);
+        int t = scanner.nextInt();
+        while (t-- > 0){
+            int n;
+            n = scanner.nextInt();
+            int[] costs = new int[n];
+            for (int i=0; i<n; i++) costs[i] = scanner.nextInt();
+            //starts with Even index 0
+            long minEven = costs[0];
+            long minOdd = costs[1];
+            long totalEven = minEven;
+            long totalOdd = minOdd;
+            long minCost = minEven * n + minOdd * n;
+            for (int i=2; i<n; i++){
+                if (i%2 == 1){
+                    minOdd = Math.min(minOdd, costs[i]);
+                    totalOdd += costs[i];
+                }
+                else{
+                    minEven = Math.min(minEven, costs[i]);
+                    totalEven += costs[i];
+                }
+                long this_cost = totalEven - minEven + minEven * (n - (i+2)/2 + 1) + totalOdd - minOdd + minOdd * (n - (i+1)/2 + 1);
+                minCost = Math.min(minCost, this_cost);
+            }
+            System.out.println(minCost);
+        }
+        scanner.close();
+    }
+
+    public static long power(int a, int b){
+        long ans = 1;
+        while (b > 0){
+            if (b%2 == 1){
+                ans *= a;
+            }
+            a *= a;
+            b >>= 1;
+        }
+        return ans;
+    }
+
+    public static void main(String[] args) {
+        solution3();
+    }
+}","
+// import java.util.Vector;
+import java.util.*;
+import java.lang.Math;
+import java.util.concurrent.TimeUnit;
+import java.util.stream.Collectors;
+import javax.management.Query;
+import java.io.*;
+import java.math.BigInteger;
+
+public class Main {
+    static int mod = 1000000007;
+
+    /* ======================DSU===================== */
+    static class dsu {
+        static int parent[], n;// min[],value[];
+        static long size[];
+
+        dsu(int n) {
+            parent = new int[n + 1];
+            size = new long[n + 1];
+            // min=new int[n+1];
+            // value=new int[n+1];
+            this.n = n;
+            makeSet();
+        }
+
+        static void makeSet() {
+            for (int i = 1; i <= n; i++) {
+                parent[i] = i;
+                size[i] = 1;
+                // min[i]=i;
+            }
+        }
+
+        static int find(int a) {
+            if (parent[a] == a)
+                return a;
+            else {
+                return parent[a] = find(parent[a]);// Path Compression
+            }
+        }
+
+        static void union(int a, int b) {
+            int setA = find(a);
+            int setB = find(b);
+            if (setA == setB)
+                return;
+            if (size[setA] >= size[setB]) {
+                parent[setB] = setA;
+                size[setA] += size[setB];
+            } else {
+                parent[setA] = setB;
+                size[setB] += size[setA];
+            }
+        }
+    }
+
+    /* ======================================================== */
+    static class Pair implements Comparator<Pair> {
+        long x;
+        long y;
+
+        // Constructor
+        public Pair(long x, long y) {
+            this.x = x;
+            this.y = y;
+        }
+
+        public Pair() {
+        }
+
+        @Override
+        public int compare(Main.Pair o1, Main.Pair o2) {
+            return ((int) (o1.x - o2.x));
+        }
+    }
+
+    static class FastReader {
+        BufferedReader br;
+        StringTokenizer st;
+
+        public FastReader() {
+            br = new BufferedReader(new InputStreamReader(System.in));
+        }
+
+        String next() {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+
+        String nextLine() {
+            String str = """";
+            try {
+                str = br.readLine();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+        }
+
+        int[] intArr(int n) {
+            int res[] = new int[n];
+            for (int i = 0; i < n; i++)
+                res[i] = nextInt();
+            return res;
+        }
+
+        long[] longArr(int n) {
+            long res[] = new long[n];
+            for (int i = 0; i < n; i++)
+                res[i] = nextLong();
+            return res;
+        }
+    }
+
+    static FastReader f = new FastReader();
+    static BufferedWriter w = new BufferedWriter(new OutputStreamWriter(System.out));
+
+    static boolean isPrime(long n) {
+        if (n <= 1)
+            return false;
+        if (n <= 3)
+            return true;
+        if (n % 2 == 0 || n % 3 == 0)
+            return false;
+        for (long i = 5; i * i <= n; i = i + 6)
+            if (n % i == 0 || n % (i + 2) == 0)
+                return false;
+        return true;
+    }
+
+    static int LowerBound(int a[], int x) { // x is the target value or key
+        int l = -1, r = a.length;
+        while (l + 1 < r) {
+            int m = (l + r) >>> 1;
+            if (a[m] >= x)
+                r = m;
+            else
+                l = m;
+        }
+        return r;
+    }
+
+    static int UpperBound(int a[], int x) {// x is the key or target value
+        int l = -1, r = a.length;
+        while (l + 1 < r) {
+            int m = (l + r) >>> 1;
+            if (a[m] <= x)
+                l = m;
+            else
+                r = m;
+        }
+        return l + 1;
+    }
+
+    static long gcd(long a, long b) {
+        if (a == 0)
+            return b;
+        return gcd(b % a, a);
+    }
+
+    static long lcm(long a, long b) {
+        return (a * b) / gcd(a, b);
+    }
+
+    static long power(long x, long y, long p) {
+        long res = 1;
+        x = x % p;
+        while (y > 0) {
+            if (y % 2 == 1)
+                res = (res * x) % p;
+            y = y >> 1; // y = y/2
+            x = (x * x) % p;
+        }
+        return res;
+    }
+
+    static long power(long x, long y) {
+        long res = 1;
+        while (y > 0) {
+            if (y % 2 == 1)
+                res = (res * x);
+            y >>= 1;
+            x = (x * x);
+        }
+        return res;
+    }
+
+    static int power(int x, int y) {
+        int res = 1;
+        while (y > 0) {
+            if (y % 2 == 1)
+                res = (res * x);
+            y >>= 1;
+            x = (x * x);
+        }
+        return res;
+    }
+
+    static int ceil(int x, int y) {
+        return (x % y == 0 ? x / y : (x / y + 1));
+    }
+
+    static long ceil(long x, long y) {
+        return (x % y == 0 ? x / y : (x / y + 1));
+    }
+
+    /*
+     * ===========Modular Operations==================
+     */
+    static long modInverse(long n, long p) {
+        return power(n, p - 2, p);
+    }
+
+    static long modAdd(long a, long b) {
+        return (a % mod + b % mod) % mod;
+
+    }
+
+    static long modMul(long a, long b) {
+        return ((a % mod) * (b % mod)) % mod;
+    }
+
+    static long nCrModPFermat(int n, int r) {
+        long p = 1000000007;
+        if (r == 0)
+            return 1;
+        long[] fac = new long[n + 1];
+        fac[0] = 1;
+        for (int i = 1; i <= n; i++)
+            fac[i] = fac[i - 1] * i % p;
+        return (fac[n] * modInverse(fac[r], p) % p * modInverse(fac[n - r], p) % p) % p;
+    }
+
+    /*
+     * ===============================================
+     */
+    static List<Character> removeDup(ArrayList<Character> list) {
+        List<Character> newList = list.stream().distinct().collect(Collectors.toList());
+        return newList;
+    }
+
+    static void ruffleSort(long[] a) {
+        int n = a.length;
+        Random r = new Random();
+        for (int i = 0; i < a.length; i++) {
+            int oi = r.nextInt(n);
+            long temp = a[i];
+            a[i] = a[oi];
+            a[oi] = temp;
+        }
+        Arrays.sort(a);
+    }
+
+    static void ruffleSort(int[] a) {
+        int n = a.length;
+        Random r = new Random();
+        for (int i = 0; i < a.length; i++) {
+            int oi = r.nextInt(n);
+            int temp = a[i];
+            a[i] = a[oi];
+            a[oi] = temp;
+        }
+        Arrays.sort(a);
+    }
+
+    /*
+     * ===========Dynamic prog Recur Section===========
+     */
+
+    static int DP[][];
+    static ArrayList<ArrayList<Integer>> g;
+    static int count = 0;
+
+    static ArrayList<Long> bitMask(ArrayList<Long> ar, int n) {
+        ArrayList<Long> ans = new ArrayList<>();
+        for (int mask = 0; mask <= Math.pow(2, n) - 1; mask++) {
+            long sum = 0;
+            for (int i = 0; i < n; i++) {
+                if (((1 << i) & mask) > 0) {
+                    sum += ar.get(i);
+                }
+            }
+            ans.add(sum);
+        }
+        return ans;
+    }
+
+    /*
+     * ====================================Main=================================
+     */
+    public static void main(String args[]) throws Exception {
+        // File file = new File(""D:\\VS Code\\Java\\Output.txt"");
+        // FileWriter fw = new FileWriter(""D:\\VS Code\\Java\\Output.txt"");
+        Random rand = new Random();
+        int t = 1;
+        t = f.nextInt();
+        int tc = 1;
+        while (t-- != 0) {
+            int n = f.nextInt();
+            int c[] = new int[n];
+            long minOdd = 0, minEven = 0;
+            long sumEven = 0, sumOdd = 0;
+            for (int i = 0; i < n ; i++) {
+                c[i] = f.nextInt();
+                // if (i % 2 == 0) {
+                //     minEven = (c[minEven] > c[i]) ? i : minEven;
+                //     sumEven += c[i];
+                // } else {
+                //     minOdd = (minOdd > c[i]) ? i : minOdd;
+                //     sumOdd += c[i];
+                // }
+            }
+            minEven = c[0];
+            minOdd = c[1];
+            sumEven=c[0];
+            sumOdd=c[1];
+            long min=minEven*n + minOdd*n;//for k=2
+            int even=1,odd=1;
+            for (int k = 3; k <= n; k++) {
+                if(k%2==1){
+                    sumEven+=c[k-1];
+                    minEven=Math.min(minEven, c[k-1]);
+                    even++;
+                }else{
+                    sumOdd+=c[k-1];
+                    minOdd=Math.min(minOdd, c[k-1]);
+                    odd++;
+                }
+                min=Math.min(min, sumEven-minEven+minEven*(n-even+1) + sumOdd-minOdd+minOdd*(n-odd+1));
+            }
+            w.write(min+""\n"");
+
+        }
+        w.flush();
+    }
+}",0
+b185d034,ccc8ef27,"import java.io.*;
+import java.util.*;
+public class A734C {
+    public static void main(String[] args) {
+        JS scan = new JS();
+        int t = scan.nextInt();
+        loop:while(t-->0){
+            int n = scan.nextInt();
+            String[] arr= new String[n];
+            Integer[][] counts = new Integer[5][n];
+            for(int i = 0;i<5;i++){
+                for(int j = 0;j<n;j++){
+                    counts[i][j] = 0;
+                }
+            }
+            for(int i =0;i<n;i++){
+                arr[i] = scan.next();
+                int[] freq =new int[5];
+                for(int j = 0;j<arr[i].length();j++){
+                    freq[arr[i].charAt(j)-'a']++;
+                }
+                for(int j = 0;j<5;j++){
+                    counts[j][i] = freq[j]-(arr[i].length()-freq[j]);
+                }
+            }
+            int best = 0;
+            for(int i = 0;i<5;i++){
+                Arrays.sort(counts[i]);
+                int curr = 0;
+                int extra = 0;
+                for(int j = n-1;j>=0;j--){
+                    extra+=counts[i][j];
+                    if(extra>0)curr++;
+                }
+                best = Math.max(best,curr);
+            }
+            System.out.println(best);
+
+        }
+    }
+    static class JS {
+        public int BS = 1 << 16;
+        public char NC = (char) 0;
+        byte[] buf = new byte[BS];
+        int bId = 0, size = 0;
+        char c = NC;
+        double num = 1;
+        BufferedInputStream in;
+
+        public JS() {
+            in = new BufferedInputStream(System.in, BS);
+        }
+
+        public JS(String s) throws FileNotFoundException {
+            in = new BufferedInputStream(new FileInputStream(new File(s)), BS);
+        }
+
+        public char nextChar() {
+            while (bId == size) {
+                try {
+                    size = in.read(buf);
+                } catch (Exception e) {
+                    return NC;
+                }
+                if (size == -1) return NC;
+                bId = 0;
+            }
+            return (char) buf[bId++];
+        }
+
+        public int nextInt() {
+            return (int) nextLong();
+        }
+
+        public long nextLong() {
+            num = 1;
+            boolean neg = false;
+            if (c == NC) c = nextChar();
+            for (; (c < '0' || c > '9'); c = nextChar()) {
+                if (c == '-') neg = true;
+            }
+            long res = 0;
+            for (; c >= '0' && c <= '9'; c = nextChar()) {
+                res = (res << 3) + (res << 1) + c - '0';
+                num *= 10;
+            }
+            return neg ? -res : res;
+        }
+
+        public double nextDouble() {
+            double cur = nextLong();
+            return c != '.' ? cur : cur + nextLong() / num;
+        }
+
+        public String next() {
+            StringBuilder res = new StringBuilder();
+            while (c <= 32) c = nextChar();
+            while (c > 32) {
+                res.append(c);
+                c = nextChar();
+            }
+            return res.toString();
+        }
+
+        public String nextLine() {
+            StringBuilder res = new StringBuilder();
+            while (c <= 32) c = nextChar();
+            while (c != '\n') {
+                res.append(c);
+                c = nextChar();
+            }
+            return res.toString();
+        }
+
+        public boolean hasNext() {
+            if (c > 32) return true;
+            while (true) {
+                c = nextChar();
+                if (c == NC) return false;
+                else if (c > 32) return true;
+            }
+        }
+    }
+}
+","import java.util.*;
+public class Sol
+{
+    public static void main(String[] args)
+    {
+        Scanner sc = new Scanner(System.in);
+        int t = sc.nextInt();
+        while(t-->0)
+        {
+			int n = sc.nextInt();
+			int a[][]=new int[n][5];
+			int tot[]=new int[n];
+			for(int i=0;i<n;i++)
+			{
+				String x = sc.next();
+				for(int j=0;j<x.length();j++)
+					a[i][x.charAt(j)-'a'] += 1;
+				tot[i]=x.length();
+			}
+			
+			int max=Integer.MIN_VALUE;
+			for(int i=0;i<5;i++)
+				max=Math.max(max,function(a,n,i,tot));
+			System.out.println(max);
+			
+		}	
+    }
+	static int function(int a[][],int n,int i,int tot[])
+	{
+		Integer ans[] = new Integer[n];
+		for(int j=0;j<n;j++)
+			ans[j]=a[j][i]-(tot[j]-a[j][i]);
+		int res=0,j=0;
+		Arrays.sort(ans,Collections.reverseOrder());
+		while(j<n&&res+ans[j]>0)
+			res+=ans[j++];
+		return j;
+	}
+}",0
+04ed33a5,0c173033,"import java.util.Scanner;
+
+public class Subsequence {
+	private static Scanner sc = new Scanner(System.in);
+	
+	public static void main(String args[]) {
+		int t = sc.nextInt();
+		
+		while(t-->0) {
+			int n = sc.nextInt();
+			
+			int a[] = new int[n];
+			int b[] =  new int[n];
+			
+			for(int i=0;i<n;i++) {
+				a[i]= sc.nextInt();
+				
+			}
+			
+			if(n%2==0) {
+				calculateB(a,b,n);
+			}
+			else {
+				calculateB(a,b,n-3);
+				if (a[n - 2] + a[n - 3] != 0) {
+					b[n - 3] = -a[n - 1];
+					b[n - 2] = -a[n - 1];
+					b[n - 1] = a[n - 2] + a[n - 3];
+				} else if (a[n - 2] + a[n - 1] != 0) {
+					b[n - 3] = a[n - 2] + a[n - 1];
+					b[n - 2] = -a[n - 3];
+					b[n - 1] = -a[n - 3];
+				} else {
+					b[n - 3] = -a[n - 2];
+					b[n - 2] = a[n - 3] + a[n - 1];
+					b[n - 1] = -a[n - 2];
+				}
+			}
+			
+			for(int i=0;i<n;i++) {
+				System.out.print(b[i] + "" "");
+			}
+			System.out.println();
+		}
+
+	}
+
+	private static void calculateB(int[] a, int[] b, int n) {
+		
+		for(int i=0;i<n-1;i=i+2) {
+			b[i] = -a[i+1];
+			b[i+1] = a[i];
+		}
+		
+	}
+}
+","
+
+
+import java.io.*;
+import java.util.*;
+
+
+public class M {
+	static Scanner scanner=new Scanner(System.in);
+	public static void main(String[] args) {
+		int t=scanner.nextInt();
+		while(t-->0) {
+			int n=scanner.nextInt();
+			int a[]=new int [n];
+			int b[]=new int [n];
+			for(int i=0;i<n;i++)a[i]=scanner.nextInt();
+			for(int i=0;i+1<n;i+=2) {
+				b[i]=-a[i+1];
+				b[i+1]=a[i];
+			}
+			if(n%2==1) {
+				int x=a[n-1],y=a[n-2],z=a[n-3];
+				if(x+y!=0) {
+					b[n-3]=x+y;
+					b[n-2]=-z;
+					b[n-1]=-z;
+				}else if(y+z!=0) {
+					b[n-1]=y+z;
+					b[n-2]=-x;
+					b[n-3]=-x;
+				}else {
+					b[n-2]=x+z;
+					b[n-1]=-y;
+					b[n-3]=-y;
+				}
+			}
+			StringBuilder sb=new StringBuilder();
+			for(int i=0;i<n;i++)sb.append(b[i]+"" "");
+			System.out.println(sb);
+		}
+	}
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+",1
+15941165,3b10bd6d,"import java.io.OutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.PrintWriter;
+import java.util.*;
+import java.io.IOException;
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.io.InputStream;
+
+public class java1 {
+    public static void main(String[] args) {
+        InputStream inputStream = System.in;
+        OutputStream outputStream = System.out;
+        InputReader in = new InputReader(inputStream);
+        PrintWriter out = new PrintWriter(outputStream);
+        TaskB solver = new TaskB();
+        solver.solve(1, in, out);
+        out.close();
+    }
+    static class TaskB {
+
+        public void solve(int testNumber, InputReader in, PrintWriter out) {
+            int t=in.nextInt();
+          tt:  while(t-- >0)
+            {
+            	int n=in.nextInt();
+            	String ar[]=new String[n];
+            	for(int x=0;x<n;x++)
+            	{
+            		ar[x]=in.next();
+            	}
+            	char ch[]= {'a', 'b', 'c', 'd', 'e'};
+            	int max=-1;
+            	for(char c:ch)
+            	{
+            		int lmax=0;
+            		ArrayList<Integer> al=new ArrayList<>();
+            		int c1=0;
+            		int c2=0;
+            		for(int x=0;x<n;x++)
+            		{
+            			int a1=0;
+            			int a2=0;
+            			for(int y=0;y<ar[x].length();y++)
+            			{
+            				if(ar[x].charAt(y)==c)
+            				{
+            					a1++;
+            				}
+            				else
+            				{
+            					a2++;
+            				}
+            			}
+            			if(a1>a2)
+            			{
+            				c1+=a1; c2+=a2; lmax++;
+            			}
+            			else
+            			{
+            				al.add(a2-a1);
+            			}
+            		}
+            		Collections.sort(al);
+            		for(int x:al)
+            		{
+            			if(c1>c2+x )
+            			{
+            				lmax++; c2+=x;
+            			}
+            		}
+            		max=Math.max(lmax, max);
+            	}
+            	out.println(max);
+            	
+           
+            	
+            			
+            }
+        }
+        static void sort(int[] a) {
+    		ArrayList<Integer> l=new ArrayList<>();
+    		for (int i:a) l.add(i);
+    		Collections.sort(l);
+    		for (int i=0; i<a.length; i++) a[i]=l.get(i);
+    	}
+        
+    }
+    static class InputReader {
+        public BufferedReader reader;
+        public StringTokenizer tokenizer;
+
+        public InputReader(InputStream stream) {
+            reader = new BufferedReader(new InputStreamReader(stream), 32768);
+            tokenizer = null;
+        }
+        public String next() {
+            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
+                try {
+                    tokenizer = new StringTokenizer(reader.readLine());
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+            }
+            return tokenizer.nextToken();
+        }
+        public int nextInt() {
+            return Integer.parseInt(next());
+        }
+        public long nextLong() {
+            return Long.parseLong(next());
+        }
+        public int[] inputarInt(int n)
+        {
+        	int ar[]=new int[n];
+        	for(int x=0;x<n;x++)
+        	{
+        		ar[x]=nextInt();
+        	}
+        	return ar;
+        }
+        public long[] inputarLong(int n)
+        {
+        	long ar[]=new long[n];
+        	for(int x=0;x<n;x++)
+        	{
+        		ar[x]=nextLong();
+        	}
+        	return ar;
+        }
+    }
+}","import java.util.*;
+public class B {
+    //static int num = (int)Math.pow(10,6);
+	static Scanner sc = null;
+	public static void main(String[] args) {
+		//System.out.println(""Enter :"");
+		sc = new Scanner(System.in);
+		int t = sc.nextInt();
+		while(t-- >0){
+		    int n = sc.nextInt();
+		    sc.nextLine();
+		    String a[] = new String[n];
+		    for(int i=0;i<n;i++){
+		        a[i] = sc.nextLine();
+		    }
+		    ArrayList<Character> a1 = new ArrayList<>();
+		    a1.add('a');
+		    a1.add('b');
+		    a1.add('c');
+		    a1.add('d');
+		    a1.add('e');
+		    int res = 0;
+		    for(Character ch : a1){
+		        ArrayList<Integer> a2 = new ArrayList<>();
+		        for(int i=0;i<n;i++){
+		             int f1 = 0;
+		             int f2 = 0;
+		             String s = a[i];
+		             for(int j=0;j<s.length();j++){
+		                 char c2 = s.charAt(j);
+		                 if(c2==ch)
+		                 f1++;
+		                 else
+		                 f2++;
+		             }
+		             a2.add(f1-f2);
+		        }
+		        Collections.sort(a2);
+		        int sum = 0;
+		        int count = 0;
+		        for(int j = n-1;j>=0;j--){
+		            int num = a2.get(j);
+		            sum+=num;
+		            if(sum>0){
+		                count++;
+		            }
+		            else
+		            break;
+		        }
+		        res = Math.max(res,count);
+		    }
+		    System.out.println(res);
+		}
+	}
+}
+
+",0
+c9da41af,f59d9b6e,"import java.util.*;
+import java.lang.*;
+import java.io.*;
+
+
+
+public class Main {
+	static {
+		try {
+			System.setIn(new FileInputStream(""input.txt""));
+			System.setOut(new PrintStream(new FileOutputStream(""output.txt"")));
+		} catch (Exception e) {}
+	}
+	void solve() {
+		int n = in.nextInt();
+
+		ArrayList<Edge>[] graph = new ArrayList[n + 1];
+		for (int i = 0; i < n; i++) {
+			graph[i] = new ArrayList<Edge>();
+		}
+
+		for (int i = 0; i < n - 1; i++) {
+			int u = in.nextInt();
+			int v = in.nextInt();
+			v--; u--;
+			graph[u].add(new Edge(v, i));
+			graph[v].add(new Edge(u, i));
+		}
+
+		int[] res = new int[n - 1];
+
+		for (int i = 0; i < n; i++) {
+			if (graph[i].size() > 2) {
+				out.append(""-1\n"");
+				return;
+			}
+		}
+
+		int start = -1;
+		for (int i = 0; i < n; i++) {
+			if (graph[i].size() == 1) {
+				start  = i;
+				break;
+			}
+		}
+
+		int currNode = start;
+		int prevNode = -1;
+		int weight = 2;
+
+		while (true) {
+			ArrayList<Edge> edges = graph[currNode];
+			Edge next = edges.get(0);
+			if (next.node == prevNode) {
+				if (edges.size() == 1) {
+					break;
+				}
+				next = edges.get(1);
+			}
+			res[next.index] = weight;
+			weight = 5 - weight;
+			prevNode = currNode;
+			currNode = next.node;
+		}
+
+		for (int i = 0; i < n - 1; i++) {
+			out.append(res[i] + "" "");
+		}
+		out.append(""\n"");
+	}
+
+	public static void main (String[] args) {
+		// Its Not Over Untill I Win - Syed Mizbahuddin
+		Main sol = new Main();
+		int t = 1;
+		t = in.nextInt();
+		while (t-- != 0) {
+			sol.solve();
+		}
+		System.out.print(out);
+	}
+
+	<T> void println(T[] s) {
+		System.out.println(Arrays.toString(s));
+	}
+
+	<T> void println(T s) {
+		System.out.println(s);
+	}
+
+	void print(int s) {
+		System.out.print(s);
+	}
+
+	void println(int s) {
+		System.out.println(s);
+	}
+
+	void println(int[] a) {
+		println(Arrays.toString(a));
+	}
+
+	int[] array(int n) {
+		int[] a = new int[n];
+		for (int i = 0; i < n; i++) {
+			a[i] = in.nextInt();
+		}
+		return a;
+	}
+
+	int[] array1(int n) {
+		int[] a = new int[n + 1];
+		for (int i = 1; i <= n; i++) {
+			a[i] = in.nextInt();
+		}
+		return a;
+	}
+
+
+	static FastReader in;
+	static StringBuffer out;
+	final int MAX;
+	final int MIN;
+	int mod ;
+	Main() {
+		in = new FastReader();
+		out = new StringBuffer();
+		MAX = Integer.MAX_VALUE;
+		MIN = Integer.MIN_VALUE;
+		mod = (int)1e9 + 7;
+	}
+}
+class FastReader {
+	BufferedReader br;
+	StringTokenizer st;
+
+	public FastReader() {
+		br = new BufferedReader(
+		    new InputStreamReader(System.in));
+	}
+
+	String next() {
+		while (st == null || !st.hasMoreElements()) {
+			try {
+				st = new StringTokenizer(br.readLine());
+			} catch (IOException e) {
+				e.printStackTrace();
+			}
+		}
+		return st.nextToken();
+	}
+
+	int nextInt() { return Integer.parseInt(next()); }
+
+	long nextLong() { return Long.parseLong(next()); }
+
+	double nextDouble() {
+		return Double.parseDouble(next());
+	}
+
+	String nextLine() {
+		String str = """";
+		try {
+			str = br.readLine();
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+		return str;
+	}
+}
+
+class Edge {
+	int node, index;
+	Edge(int node, int index) {
+		this.node = node;
+		this.index = index;
+	}
+}","/* package codechef; // don't place package name! */
+
+import java.util.*;
+import java.lang.*;
+import java.io.*;
+
+/* Name of the class has to be ""Main"" only if the class is public. */
+public class Codechef{
+    public static class Edge{
+        int node;
+        int index;
+        Edge(int node, int index){
+            this.node = node;
+            this.index = index;
+        }
+    }
+    static Scanner scn = new Scanner(System.in);
+	public static void main (String[] args) throws java.lang.Exception{
+		int t = scn.nextInt();
+		while(t-->0){
+		    solve();
+		}
+	}
+	public static void solve(){
+	    int n = scn.nextInt();
+	    ArrayList<Edge>[]graph = new ArrayList[n];
+	    for(int i = 0; i < n; i++){
+	        graph[i] = new ArrayList<>();
+	    }
+	    for(int i = 0; i < n - 1; i++){
+	        int u = scn.nextInt() - 1;
+	        int v = scn.nextInt() - 1;
+	        graph[u].add(new Edge(v, i));
+	        graph[v].add(new Edge(u, i));
+	    }
+	    int start = 0;
+	    for(int i = 0; i < n; i++){
+	        if(graph[i].size() > 2){
+	            System.out.println(""-1"");
+	            return;
+	        }else if(graph[i].size() == 1){
+	            start = i;
+	        }
+	    }
+	    int[]weight = new int[n - 1];
+	    int prevNode = -1, curNode = start, curWeight = 2;
+	    while(true){
+	        ArrayList<Edge>edges = graph[curNode];
+	        Edge next = edges.get(0);
+	        if(next.node == prevNode){
+	            if(edges.size() == 1){
+	                break;
+	            }else{
+	                next = edges.get(1);
+	            }
+	        }
+	        weight[next.index] = curWeight;
+	        prevNode = curNode;
+	        curNode = next.node;
+	        curWeight = 5 - curWeight;
+	    }
+	    for(int i = 0; i < n - 1; i++){
+	        System.out.print(weight[i]);
+	        System.out.print("" "");
+	    }
+	    System.out.println();
+	}
+}
+",1
+313b42e6,e45446bc,"import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+
+public class Div2 {
+  public static void main(String[] args) throws IOException {
+    BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
+    String[] s = reader.readLine().split("" "");
+    StringBuilder sb = new StringBuilder();
+    Div2 div2 = new Div2();
+    int t = Integer.parseInt(s[0]);
+    while (t-- > 0) {
+      s = reader.readLine().split("" "");
+      int n = Integer.parseInt(s[0]);
+      s = reader.readLine().split("" "");
+      long[] cs = new long[n];
+      for (int i = 0; i < n; i++) {
+        cs[i] = Long.parseLong(s[i]);
+      }
+      long min1 = cs[0];
+      long min2 = cs[1];
+      long cost = n * min1 + n * min2;
+      long sum = min1 + min2;
+      for (int i = 2; i < n; i++) {
+        sum += cs[i];
+        int count = i / 2;
+        if (i % 2 == 0) {
+          min1 = Math.min(min1, cs[i]);
+          cost = Math.min(cost, sum + (n - count - 1) * min1 + (n - count) * min2);
+        } else {
+          count++;
+          min2 = Math.min(min2, cs[i]);
+          cost = Math.min(cost, sum + (n - count) * min1 + (n - count) * min2);
+        }
+      }
+      sb.append(cost).append(""\n"");
+    }
+    System.out.println(sb.toString());
+  }
+}","
+import java.util.*;
+import java.lang.*;
+import java.io.*;
+
+public class C {
+
+//	            ***                          ++                      
+//             +=-==+                      +++=-                     
+//            +-:---==+                   *+=----=                   
+//           +-:------==+               ++=------==                  
+//           =-----------=++=========================                
+//          +--:::::---:-----============-=======+++====             
+//          +---:..:----::-===============-======+++++++++           
+//          =---:...---:-===================---===++++++++++         
+//          +----:...:-=======================--==+++++++++++        
+//          +-:------====================++===---==++++===+++++      
+//         +=-----======================+++++==---==+==-::=++**+     
+//        +=-----================---=======++=========::.:-+*****    
+//       +==::-====================--:  --:-====++=+===:..-=+*****   
+//       +=---=====================-...  :=..:-=+++++++++===++*****  
+//       +=---=====+=++++++++++++++++=-:::::-====+++++++++++++*****+ 
+//      +=======++++++++++++=+++++++============++++++=======+****** 
+//      +=====+++++++++++++++++++++++++==++++==++++++=:...  . .+**** 
+//     ++====++++++++++++++++++++++++++++++++++++++++-.     ..-+**** 
+//     +======++++++++++++++++++++++++++++++++===+====:.    ..:=++++ 
+//     +===--=====+++++++++++++++++++++++++++=========-::....::-=++* 
+//     ====--==========+++++++==+++===++++===========--:::....:=++*  
+//     ====---===++++=====++++++==+++=======-::--===-:.  ....:-+++   
+//     ==--=--====++++++++==+++++++++++======--::::...::::::-=+++    
+//     ===----===++++++++++++++++++++============--=-==----==+++     
+//     =--------====++++++++++++++++=====================+++++++     
+//     =---------=======++++++++====+++=================++++++++     
+//     -----------========+++++++++++++++=================+++++++    
+//     =----------==========++++++++++=====================++++++++  
+//     =====------==============+++++++===================+++==+++++ 
+//     =======------==========================================++++++
+
+//	 created by : Nitesh Gupta
+
+	public static void main(String[] args) throws Exception {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		int t = Integer.parseInt(br.readLine());
+		StringBuilder sb = new StringBuilder();
+		while (t-- > 0) {
+			String[] scn = (br.readLine()).trim().split("" "");
+			int n = Integer.parseInt(scn[0]);
+			long[] arr = new long[n];
+			scn = (br.readLine()).trim().split("" "");
+			for (int i = 0; i < n; i++) {
+				arr[i] = Long.parseLong(scn[i]);
+			}
+			long min;
+			long hor = arr[0], ver = arr[1];
+			long min1 = 0, min2 = 0;
+			min = (hor + ver) * n;
+			long x = 0, y = 0;
+			for (int i = 2; i < n; i++) {
+				if (i % 2 == 0) {
+					x += 1;
+					if (arr[i] >= hor) {
+						min1 += arr[i];
+					} else {
+						min1 += hor;
+						hor = arr[i];
+					}
+					
+					
+				} else {
+					y += 1;
+					if (arr[i] >= ver) {
+						min2 += arr[i];
+					} else {
+						min2 += ver;
+						ver = arr[i];
+					}
+				}
+				long pro =  (n - x) * hor + (n - y) * ver;
+				min = Math.min(min, min1 + min2 +pro);
+			}
+			sb.append(min);
+			sb.append(""\n"");
+		}
+		System.out.println(sb);
+		return;
+
+	}
+
+	public static void sort(long[] arr) {
+		int n = arr.length;
+		for (int i = 0; i < n; i++) {
+			int idx = (int) Math.random() * n;
+			long temp = arr[i];
+			arr[i] = arr[idx];
+			arr[idx] = temp;
+		}
+		Arrays.sort(arr);
+	}
+
+	public static void print(long[] dp) {
+		for (long ele : dp) {
+			System.out.print(ele + "" "");
+		}
+		System.out.println();
+	}
+
+	public static void print(long[][] dp) {
+		for (long[] a : dp) {
+			for (long ele : a) {
+				System.out.print(ele + "" "");
+			}
+			System.out.println();
+		}
+	}
+
+}
+",0
+4da08761,6f393cfe,"import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.PrintWriter;
+import java.util.ArrayList;
+import java.util.Arrays;
+
+/**
+ * Built using CHelper plug-in
+ * Actual solution is at the top
+ */
+public class Solution {
+    public static void main(String[] args) {
+        InputStream inputStream = System.in;
+        OutputStream outputStream = System.out;
+        InputReader in = new InputReader(inputStream);
+        PrintWriter out = new PrintWriter(outputStream);
+        Main solver = new Main();
+        boolean multipleTC = true;
+        int testCount = multipleTC ? Integer.parseInt(in.next()) : 1;
+        for (int i = 1; i <= testCount; i++)
+            solver.solve(in, out, i);
+        out.close();
+    }
+    static class Main {
+        PrintWriter out;
+        InputReader in;
+
+        public void solve(InputReader in, PrintWriter out, int test) {
+            this.out = out;
+            this.in = in;
+            int n = ni();
+            String[] arr = new String[n];
+            int[][] freq = new int[n][5];
+            int[][] rem = new int[n][5];
+            for(int i = 0; i < n; i++){
+                arr[i] = n();
+                for(int j = 0; j < arr[i].length(); j++)
+                    freq[i][arr[i].charAt(j) - 'a']++;
+                for(int j = 0; j < 5; j++)
+                    rem[i][j] = arr[i].length() - freq[i][j];
+            }
+            int ans = 0;
+            for(int i = 0; i < 5; i++){
+                int[] vals = new int[n];
+                for(int j = 0; j < n; j++)
+                    vals[j] = freq[j][i] - rem[j][i];
+                Arrays.sort(vals);
+                int sum = 0, x = 0;
+                for(int j = n - 1; j >= 0; j--){
+                    if(sum + vals[j] > 0){
+                        x++;
+                        sum += vals[j];
+                    } else {
+                        break;
+                    }
+                }
+                if(x > ans) {
+                    ans = x;
+                }
+            }
+            pn(ans);
+        }
+
+        int gcd(int a, int b)
+        {
+            if (a == 0)
+                return b;
+
+            return gcd(b%a, a);
+        }
+
+
+        String n(){
+            return in.next();
+        }
+
+        int ni() {
+            return in.nextInt();
+        }
+
+        long nl() {
+            return in.nextLong();
+        }
+
+        void pn(long zx) {
+            out.println(zx);
+        }
+
+        void pn(String sz) {
+            out.println(sz);
+        }
+
+        void pn(double dx){
+            out.println(dx);
+        }
+
+        class Tuple {
+            long x;
+            long y;
+
+            Tuple(long a, long b) {
+                x = a;
+                y = b;
+            }
+        }
+
+    }
+
+    static class InputReader {
+        private InputStream stream;
+        private byte[] buf = new byte[1024];
+        private int curChar;
+        private int numChars;
+
+        public InputReader(InputStream stream) {
+            this.stream = stream;
+        }
+
+        public int read() {
+            if (numChars == -1) {
+                throw new UnknownError();
+            }
+            if (curChar >= numChars) {
+                curChar = 0;
+                try {
+                    numChars = stream.read(buf);
+                } catch (IOException e) {
+                    throw new UnknownError();
+                }
+                if (numChars <= 0) {
+                    return -1;
+                }
+            }
+            return buf[curChar++];
+        }
+
+        public int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        public long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        public String next() {
+            int c = read();
+            while (isSpaceChar(c)) {
+                c = read();
+            }
+            StringBuffer res = new StringBuffer();
+            do {
+                res.appendCodePoint(c);
+                c = read();
+            } while (!isSpaceChar(c));
+
+            return res.toString();
+        }
+
+        private boolean isSpaceChar(int c) {
+            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
+        }
+
+    }
+}","import java.io.*;
+import java.util.*;
+
+public class C {
+
+    public static void main(String[] args) throws Exception{
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
+        try{
+            int t = Integer.parseInt(br.readLine());
+            while(t-->0){
+                int n = Integer.parseInt(br.readLine());
+                int lst[][] = new int[n][5];
+                for(int i=0; i<n; i++){
+                    String s = br.readLine();
+                    for(int j=0; j<s.length(); j++){
+                        lst[i][s.charAt(j)-'a']++;
+                    }
+                }
+                int fans = Integer.MIN_VALUE;
+                for(int i=0; i<5; i++){
+                    int val[] = new int[n];
+                    for(int k=0; k<n; k++){
+                        int sum = 0;
+                        for(int j=0; j<5; j++){
+                            if(i==j){
+                                sum += lst[k][j];
+                            }else{
+                                sum -= lst[k][j];
+                            }
+                        }
+                        val[k] = sum;
+                    }
+                    Arrays.sort(val);
+                    int sum = 0;
+                    int ans = 0;
+                    for(int x = n-1; x>=0; x--){
+                        sum+=val[x];
+                        if(sum>0){
+                            ans++;
+                        }else{
+                            break;
+                        }
+                    }
+                    fans = Math.max(fans, ans);
+                }
+                bw.write(fans+""\n"");
+            }
+            bw.flush();
+        }catch(Exception e){
+            return;
+        }
+    }
+    
+}",0
+ac7187d8,b7a6c59c,"import java.io.*;
+import java.util.*;
+public class C {
+    public static void main (String[] args) throws IOException {
+        BufferedReader f = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st = new StringTokenizer(f.readLine());
+        int t = Integer.parseInt(st.nextToken());
+        while (t-->0) {
+            st = new StringTokenizer(f.readLine());
+            int n = Integer.parseInt(st.nextToken());
+            st = new StringTokenizer(f.readLine());
+            long[] arr = new long[n];
+            for (int i = 0; i < n; i++) {
+                arr[i] = Long.parseLong(st.nextToken());
+            }
+            solve(n, arr);
+        }
+    }
+    static void solve(long n, long[] arr) {
+        long minEven = Integer.MAX_VALUE;
+        long minOdd = arr[0];
+        long evenSum = 0;
+        long oddSum = arr[0];
+        long finans = Long.MAX_VALUE;
+        long oddAns, evenAns;
+        long oddcount=1;
+        long evencount=0;
+        for (int k = 1; k < n; k++) {
+            if (k%2==1) {
+                evenSum+=arr[k];
+                evencount++;
+                minEven = Math.min(minEven, arr[k]);
+            } else {
+                oddSum+=arr[k];
+                oddcount++;
+                minOdd = Math.min(minOdd, arr[k]);
+            }
+            oddAns = oddSum+(n-oddcount)*minOdd;
+            evenAns = evenSum+(n-evencount)*minEven;
+            finans = Math.min(finans, oddAns+evenAns);
+        }
+        System.out.println(finans);
+    }
+}
+
+","import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.Scanner;
+
+public class MinimumGridPath {
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		String line = br.readLine();
+		int cases = Integer.parseInt(line);
+		for(int i = 0; i<cases; i++) {
+			int n = Integer.parseInt(br.readLine());
+			
+			long[] segments = new long[n];
+			Scanner sc = new Scanner(br.readLine());
+			for(int k = 0; k<n; k++) {
+				segments[k] = sc.nextLong();
+			}
+			
+			long minHor = segments[0], minVer = Long.MAX_VALUE;
+			long sumHor = segments[0], sumVer = 0;
+			long best = Long.MAX_VALUE;
+			for(int k = 1; k<n; k++) {
+				if(k % 2 == 1) {
+					minVer = Long.min(minVer, segments[k]);
+					sumVer += segments[k];
+				}else {
+					minHor = Long.min(minHor, segments[k]);
+					sumHor += segments[k];
+				}
+				long cost = sumVer + sumHor + minVer * (n - (k+1)/2) + minHor * (n- (1+k/2));
+				best = Long.min(best, cost);
+			}
+			
+			System.out.println(best);
+		}
+	
+	}
+}",0
+0ea5a836,732c98a0,"import java.util.*;
+import java.io.*;
+public class Solution
+{
+    static class FastReader 
+    { 
+        BufferedReader br; 
+        StringTokenizer st; 
+  
+        public FastReader() 
+        { 
+            br = new BufferedReader(new
+                     InputStreamReader(System.in)); 
+        } 
+  
+        String next() 
+        { 
+            while (st == null || !st.hasMoreElements()) 
+            { 
+                try
+                { 
+                    st = new StringTokenizer(br.readLine()); 
+                } 
+                catch (IOException  e) 
+                { 
+                    e.printStackTrace(); 
+                } 
+            } 
+            return st.nextToken(); 
+        } 
+  
+        int nextInt() 
+        { 
+            return Integer.parseInt(next()); 
+        } 
+  
+        long nextLong() 
+        { 
+            return Long.parseLong(next()); 
+        } 
+  
+        double nextDouble() 
+        { 
+            return Double.parseDouble(next()); 
+        } 
+  
+        String nextLine() 
+        { 
+            String str = """"; 
+            try
+            { 
+                str = br.readLine(); 
+            } 
+            catch (IOException e) 
+            { 
+                e.printStackTrace(); 
+            } 
+            return str; 
+        } 
+    }
+    //static final long mod=(long)1e9+7;
+    static final long mod=998244353L;
+    public static long pow(long a,long p)
+    {
+        long res=1;
+        while(p>0)
+        {
+            if(p%2==1)
+            {
+                p--;
+                res*=a;
+                res%=mod;
+            }
+            else
+            {
+                a*=a;
+                a%=mod;
+                p/=2;
+            }
+        }
+        return res;
+    }
+    static class Pair
+    {
+        int u,v;
+        Pair(int u,int v)
+        {
+            this.u=u;
+            this.v=v;
+        }
+    }
+    /*static class Pair implements Comparable<Pair>
+    {
+        int v,l;
+        Pair(int v,int l)
+        {
+            this.v=v;
+            this.l=l;
+        }
+        public int compareTo(Pair p)
+        {
+            return l-p.l; 
+        }
+    }*/
+    static long gcd(long a,long b)
+    {
+        if(b%a==0)
+        return a;
+        return gcd(b%a,a);
+    }
+    public static class comp implements Comparator<Pair>
+    {
+        public int compare(Pair p1,Pair p2)
+        {
+            if(p1.v>p2.v)
+            return 1;
+            return -1;
+        }
+    }
+    public static void upd1(int a[],int i)
+    {
+        for(;i<a.length;i+=(i&(-i)))
+        a[i]+=1;
+    }
+    public static void upd2(long a[],int up)
+    {
+        for(int i=up;i<a.length;i+=(i&(-i)))
+        a[i]=a[i]+1L*up;
+    }
+    public static int q1(int a[],int i)
+    {
+        int s=0;
+        for(;i>0;i-=(i&(-i)))
+        s+=a[i];
+        return s;
+    }
+    public static long q2(long a[],int i)
+    {
+        long s=0;
+        for(;i>0;i-=(i&(-i)))
+        s+=a[i];
+        return s;
+    }
+    public static void main(String args[])throws Exception
+    {
+        FastReader fs=new FastReader();
+        PrintWriter pw=new PrintWriter(System.out);
+        int tc=fs.nextInt();
+        while(tc-->0)
+        {
+            int n=fs.nextInt();
+            char[][] c=new char[n][];
+            for(int i=0;i<n;i++)
+            c[i]=fs.nextLine().toCharArray();
+            ArrayList<Integer> list[]=new ArrayList[5];
+            for(int i=0;i<5;i++)
+            list[i]=new ArrayList<>();
+            for(int i=0;i<n;i++)
+            {
+                int cnt[]=new int[5];
+                for(int j=0;j<c[i].length;j++)
+                cnt[c[i][j]-'a']++;
+                for(int j=0;j<5;j++)
+                list[j].add(2*cnt[j]-c[i].length);
+            }
+            for(int i=0;i<5;i++)
+            Collections.sort(list[i]);
+            int ans=0;
+            for(int i=0;i<5;i++)
+            {
+                int s=0;
+                for(int j=n-1;j>=0;j--)
+                {
+                    ans=Math.max(ans,n-1-j);
+                    s+=list[i].get(j);
+                    if(s<=0)
+                    break;
+                }
+                if(s>0)
+                ans=n;
+            }
+            pw.println(ans);
+        }
+        pw.flush();
+        pw.close();
+    }
+}","
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.util.*;
+
+import static java.lang.Math.*;
+import static java.lang.System.out;
+import static java.lang.Long.MAX_VALUE;
+
+public final class Main {
+
+    FastReader in;
+    StringBuffer sb;
+    public static void main(String[] args) {
+        new Main().run();
+    }
+
+    void run(){
+        in= new FastReader();
+        start();
+    }
+
+    void start(){
+        sb= new StringBuffer();
+        for(int t=in.nextInt();t>0;t--)
+            solve();
+        out.print(sb);
+    }
+
+    void solve(){
+        int n = in.nextInt();
+        int[][] mat = new int[n][5];
+        for(int i = 0; i<n; i++) {
+            char[] pp =in.nextLine().toCharArray();
+            for(char c : pp) {
+                mat[i][c-'a']++;
+            }
+            int[] p = new int[5];
+            int tt = 0;
+            for(int j : mat[i])
+                tt +=j;
+            for(int j = 0; j<5; j++) {
+                mat[i][j]=2*mat[i][j]-tt;
+            }
+        }
+        int ans  = 0;
+        for(int i = 0; i<5; i++) {
+            int g = check(i,mat, n);
+            ans = Math.max(g,ans);
+        }
+        sb.append(ans).append(""\n"");
+    }
+
+    int check(int i, int[][] mat, int n) {
+        ArrayList<Integer> x = new ArrayList<>();
+        for(int j = 0; j<n; j++) {
+            x.add(mat[j][i]);
+        }
+        Collections.sort(x);
+        int s = 0;
+        int cnt = 0;
+        int l = n-1;
+        while(l>=0) {
+            int u = x.get(l);
+            if(s+u>0) {
+                s+=u;
+                cnt++;
+            }
+            else
+                break;
+            l--;
+        }
+        return cnt;
+    }
+
+    long power(long x, long y, long p) {
+        long res = 1;
+        x = x % p;
+        while (y > 0) {
+            if (y % 2 == 1)
+                res = (res * x) % p;
+
+            y = y >> 1;
+            x = (x * x) % p;
+        }
+        return res;
+    }
+
+    int upper_bound(long[] arr, int key) {
+        int i=0, j=arr.length-1;
+        if (arr[j]<=key) return j+1;
+        if(arr[i]>key) return i;
+        while (i<j){
+            int mid= (i+j)/2;
+            if(arr[mid]<=key){
+                i= mid+1;
+            }else{
+                j=mid;
+            }
+        }
+        return i;
+    }
+
+    void sort(long[] A){
+        int n = A.length;
+        Random rnd = new Random();
+        for(int i=0; i<n; ++i){
+            long tmp = A[i];
+            int randomPos = i + rnd.nextInt(n-i);
+            A[i] = A[randomPos];
+            A[randomPos] = tmp;
+        }
+        Arrays.sort(A);
+    }
+
+    long[] longArr(int n){
+        long[] res= new long[n];
+        for(int i=0;i<n;i++){
+            res[i]= in.nextLong();
+        }
+        return res;
+    }
+
+    // sieve of eratosthenes code for precomputing whether numbers are prime or not up to MAX_VALUE
+    long MAX= MAX_VALUE;
+    int[] precomp= new int[(int) (MAX+1)];
+    void sieve(){
+        long n= MAX;
+        boolean[] prime = new boolean[(int) (n+1)];
+        for(int i=0;i<=n;i++)
+            prime[i] = true;
+
+        for(long p = 2; p*p <=n; p++)
+        {
+            // If prime[p] is not changed, then it is a prime
+            if(prime[(int) p])
+            {
+                // Update all multiples of p
+                for(long i = p*p; i <= n; i += p)
+                    prime[(int) i] = false;
+            }
+        }
+
+        // Print all prime numbers
+        for(long i = 2; i <= n; i++)
+        {
+            if(prime[(int) i])
+                precomp[(int) i]= 1;
+        }
+    }
+
+    boolean isDigitSumPalindrome(long N) {
+        // code here
+        long sum= sumOfDigits(String.valueOf(N));
+        long rev=0;
+        long org= sum;
+        while (sum!=0){
+            long d= sum%10;
+            rev = rev*10 +d;
+            sum /= 10;
+        }
+        return org == rev;
+    }
+
+    long sumOfDigits(String n){
+        long sum= 0;
+        for (char c: n.toCharArray()){
+            sum += Integer.parseInt(String.valueOf(c));
+        }
+        return sum;
+    }
+
+    long[] revArray(long[] arr) {
+        int n= arr.length;
+        int i=0, j=n-1;
+        while (i<j){
+            long temp= arr[i];
+            arr[i]= arr[j];
+            arr[j]= temp;
+            i++;
+            j--;
+        }
+        return arr;
+    }
+
+    long gcd(long a, long b){
+        if (b==0)
+            return a;
+        return gcd(b, a%b);
+    }
+    long lcm(long a,long b){
+        return (a*b)/gcd(a,b);
+    }
+
+    static class Pair{
+        long first;
+        long second;
+        Pair(long x,long y){
+            this.first=x;
+            this.second=y;
+        }
+    }
+
+    static class Compare {
+        static void compare(ArrayList<Pair> arr, long n) {
+            arr.sort(new Comparator<Pair>() {
+                @Override
+                public int compare(Pair p1, Pair p2) {
+                    return (int) (p2.first - p1.first);
+                }
+            });
+        }
+    }
+
+    public static class FastReader{
+        BufferedReader br;
+        StringTokenizer st;
+        public FastReader(){
+            br=new BufferedReader(new InputStreamReader(System.in));
+        }
+        String next(){
+            while (st==null || !st.hasMoreElements()){
+                try{
+                    st=new StringTokenizer(br.readLine());
+                }catch (Exception e){
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+        int nextInt(){
+            return Integer.parseInt(next());
+        }
+        long nextLong(){
+            return Long.parseLong(next());
+        }
+        double nextDouble(){
+            return Double.parseDouble(next());
+        }
+        float nextFloat(){
+            return Float.parseFloat(next());
+        }
+        String nextLine(){
+            String str="""";
+            try{
+                str=br.readLine();
+            }catch (Exception e){
+                e.printStackTrace();
+            }
+            return str;
+        }
+    }
+}",0
+624b8db5,e9986d44,"//created by Whiplash99
+import java.io.*;
+import java.util.*;
+public class C
+{
+    private static ArrayDeque<Integer>[] edge;
+    private static HashMap<String,Integer> map;
+
+    private static String getHash(int u, int v)
+    {
+        if(u>v)
+        {
+            int tmp=u;
+            u=v;
+            v=tmp;
+        }
+
+        return u+"" ""+v;
+    }
+    private static void DFS(int u, int p, int[] ans, int val)
+    {
+        for(int v:edge[u])
+        {
+            if(v==p) continue;
+            ans[map.get(getHash(u,v))]=val;
+
+            DFS(v,u,ans,5-val);
+            val=5-val;
+        }
+    }
+    public static void main(String[] args) throws Exception
+    {
+        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+
+        int i,N;
+
+        int T=Integer.parseInt(br.readLine().trim());
+        StringBuilder sb=new StringBuilder();
+
+        while (T-->0)
+        {
+            N=Integer.parseInt(br.readLine().trim());
+            edge=new ArrayDeque[N];
+            for(i=0;i<N;i++) edge[i]=new ArrayDeque<>();
+
+            map=new HashMap<>();
+            int[] ans=new int[N-1];
+            int[] deg=new int[N];
+
+            for(i=0;i<N-1;i++)
+            {
+                String[] s=br.readLine().trim().split("" "");
+                int u=Integer.parseInt(s[0])-1;
+                int v=Integer.parseInt(s[1])-1;
+
+                edge[u].add(v); edge[v].add(u);
+                deg[u]++; deg[v]++;
+
+                map.put(getHash(u,v),i);
+            }
+
+            for(i=0;i<N;i++) if(deg[i]>2) break;
+            if(i<N)
+            {
+                sb.append(-1).append(""\n"");
+                continue;
+            }
+
+            DFS(0,0,ans,2);
+            for(int x:ans) sb.append(x).append("" "");
+            sb.append(""\n"");
+        }
+        System.out.println(sb);
+    }
+}","
+
+
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.*;
+
+
+
+public class cp23 {
+	static BufferedReader sc = new BufferedReader(new InputStreamReader(System.in));
+	static int mod = 1000000007;
+	static String toReturn = """";
+
+	static int steps = Integer.MAX_VALUE;
+	static int maxlen = 1000005;
+	
+	
+	
+	/*MATHEMATICS FUNCTIONS START HERE
+	MATHS
+	MATHS
+	MATHS
+	MATHS*/
+	static long gcd(long a, long b) {
+		if(b == 0) return a;
+		else return gcd(b, a % b);
+	}
+
+	static long powerMod(long x, long y, int mod) {
+		if(y == 0) return 1;
+		long temp = powerMod(x, y / 2, mod);
+		temp = ((temp % mod) * (temp % mod)) % mod;
+		if(y % 2 == 0) return temp;
+		else return ((x % mod) * (temp % mod)) % mod;
+	}
+	
+	static long modInverse(long n, int p) {
+		return powerMod(n, p - 2, p);
+	}
+	
+	static long nCr(int n, int r, int mod, long [] fact, long [] ifact) {
+		return ((fact[n] % mod) * ((ifact[r] * ifact[n - r]) % mod)) % mod;
+	}
+	/*
+	 * static long [] seive(long n) {
+	 * 
+	 * }
+	 */
+	/*MATHS
+	MATHS
+	MATHS
+	MATHS
+	MATHEMATICS FUNCTIONS END HERE */
+	
+	/*SWAP FUNCTION START HERE
+	  SWAP
+	  SWAP
+	  SWAP
+	  SWAP
+	 */
+	static void swap(int i, int j, int [] arr) {
+		int temp = arr[i];
+		arr[i] = arr[j];
+		arr[j] = temp;
+	}
+	/*SWAP
+	  SWAP
+	  SWAP
+	  SWAP
+	 SWAP FUNCTION END HERE*/
+	
+	
+	
+	/*BINARY SEARCH METHODS START HERE
+	 * BINARY SEARCH
+	 * BINARY SEARCH
+	 * BINARY SEARCH
+	 * BINARY SEARCH
+	 */
+	static boolean BinaryCheck(long test, long [] arr, long health) {
+		for(int i = 0; i <= arr.length - 1; i++) {
+			if(i == arr.length - 1) health -= test;
+			else if(arr[i + 1] - arr[i] > test) {
+				health = health - test;
+			}else {
+				health = health - (arr[i + 1] - arr[i]);
+			}
+			if(health <= 0) return true;
+		}
+		return false;
+	}
+	
+	static long binarySearchModified(long n, long [] arr) {
+		long start = 0, end = n, ans = n;
+		while(start < end) {
+			long mid = (start + end) / 2;
+			if(BinaryCheck(mid, arr, n)) {
+				ans = Math.min(ans, mid);
+				end = mid;
+			}else {
+				start = mid + 1;
+				
+			}
+		}
+		return ans;
+	}
+	/*BINARY SEARCH
+	 * BINARY SEARCH
+	 * BINARY SEARCH
+	 * BINARY SEARCH
+	 * BINARY SEARCH
+	 BINARY SEARCH METHODS END HERE*/
+	
+	
+	/*RECURSIVE FUNCTION START HERE
+	 * RECURSIVE
+	 * RECURSIVE
+	 * RECURSIVE
+	 * RECURSIVE
+	 */
+	
+	static int recurse(int x, int y, int n, int steps1, Integer [][] dp) {
+		if(x > n || y > n) return 0;
+		if(dp[x][y] != null) {
+			return dp[x][y];
+		}
+		else if(x == n || y == n) {
+			
+			return steps1;
+		}
+		
+		return dp[x][y] = Math.max(recurse(x + y, y, n, steps1 + 1, dp), recurse(x, x + y, n, steps1 + 1, dp));
+	}
+	/*RECURSIVE
+	 * RECURSIVE
+	 * RECURSIVE
+	 * RECURSIVE
+	 * RECURSIVE
+	 RECURSIVE FUNCTION END HERE*/
+	
+	/*GRAPH FUNCTIONS START HERE
+	 * GRAPH
+	 * GRAPH
+	 * GRAPH
+	 * GRAPH
+	 * */
+	static class edge{
+		int from, to, weight;
+		public edge(int x, int y, int z) {
+			this.from = x;
+			this.to = y;
+			this.weight = z;
+		}
+	}
+	static void addEdge(ArrayList<ArrayList<edge>> graph, int from, int to, int weight) {
+		edge temp = new edge(from, to, weight);
+		edge temp1 = new edge(to, from, weight);
+		graph.get(from).add(temp);
+		graph.get(to).add(temp1);
+	}
+	static int ans = 0;
+	static void dfs(ArrayList<ArrayList<edge>> graph, int vertex, boolean [] visited, int [] toReturn, int weight) {
+		//System.out.println(graph.get(vertex).size());
+		if(visited[vertex]) return;
+		visited[vertex] = true;
+		if(graph.get(vertex).size() > 2) return;
+		for(int i = 0; i < graph.get(vertex).size(); i++) {
+			edge temp = graph.get(vertex).get(i);
+			if(!visited[temp.to]) {
+				//System.out.println(temp.to);
+				toReturn[temp.weight] = weight;
+				dfs(graph, temp.to, visited, toReturn, 5 - weight);
+				weight = 5 - weight;
+			}
+		}
+	}
+	static void bfs(ArrayList<ArrayList<edge>> graph, int vertex, boolean [] visited, int [] toReturn, Queue<Integer> q, int weight) {
+		if(visited[vertex]) return;
+		visited[vertex] = true;
+		if(graph.get(vertex).size() > 2) return;
+		int first = weight;
+		for(int i = 0; i < graph.get(vertex).size(); i++) {
+			edge temp = graph.get(vertex).get(i);
+			if(!visited[temp.to]) {
+				q.add(temp.to);
+				toReturn[temp.weight] = weight;
+				weight = 5 - weight;
+			}
+		}
+		if(!q.isEmpty())bfs(graph, q.poll(), visited, toReturn, q, 5 - first);
+	}
+	
+	static void topoSort(ArrayList<ArrayList<Integer>> graph, int vertex, boolean [] visited, ArrayList<Integer> toReturn) {
+		if(visited[vertex]) return;
+		visited[vertex] = true;
+		for(int i = 0; i < graph.get(vertex).size(); i++) {
+			if(!visited[graph.get(vertex).get(i)]) topoSort(graph, graph.get(vertex).get(i), visited, toReturn);
+		}
+		toReturn.add(vertex);
+	}
+	static boolean isCyclicDirected(ArrayList<ArrayList<Integer>> graph, int vertex, boolean [] visited, boolean [] reStack) {
+		if(reStack[vertex]) return true;
+		if(visited[vertex]) return false;
+		reStack[vertex] = true;
+		visited[vertex] = true;
+		
+		for(int i = 0; i < graph.get(vertex).size(); i++) {
+			if(isCyclicDirected(graph, graph.get(vertex).get(i), visited, reStack)) return true;
+		}
+		reStack[vertex] = false;
+		return false;
+	}
+	/*GRAPH FUNCTIONS END HERE
+	 * GRAPH
+	 * GRAPH
+	 * GRAPH
+	 * GRAPH
+	 */
+	/*disjoint Set START HERE
+	 * disjoint Set
+	 * disjoint Set
+	 * disjoint Set
+	 * disjoint Set
+	 */
+	static int [] rank;
+	static int [] parent;
+	static int parent(int [] parent, int x) {
+		if(parent[x] == x) return x;
+		else return parent[x] = parent(parent, parent[x]);
+	}
+	static void union(int x, int y, int [] rank, int [] parent) {
+		if(parent(parent, x) == parent(parent, y)) {
+			return;
+		}
+		if(rank[x] > rank[y]) {
+			swap(x, y, rank);
+		}
+		rank[x] += rank[y];
+		parent[x] = y;
+	}
+	/*disjoint Set END HERE
+	 * disjoint Set
+	 * disjoint Set
+	 * disjoint Set
+	 * disjoint Set
+	 */
+	
+	
+	/*INPUT START HERE
+	 * INPUT
+	 * INPUT
+	 * INPUT
+	 * INPUT
+	 * INPUT
+	 */
+	
+	static int nexInt() throws NumberFormatException, IOException {
+		return Integer.parseInt(sc.readLine());
+	}
+	static long nexLong() throws NumberFormatException, IOException {
+		return Long.parseLong(sc.readLine());
+	}
+	static long [] inputLongArr() throws NumberFormatException, IOException{
+		String [] s = sc.readLine().split("" "");
+		long [] toReturn = new long[s.length];
+		for(int i = 0; i < s.length; i++) {
+			toReturn[i] = Long.parseLong(s[i]);
+		}
+		return toReturn;
+	}
+	static int [] inputIntArr() throws NumberFormatException, IOException{
+		String [] s = sc.readLine().split("" "");
+		int [] toReturn = new int[s.length];
+		for(int i = 0; i < s.length; i++) {
+			toReturn[i] = Integer.parseInt(s[i]);
+		}
+		return toReturn;
+	}
+	/*INPUT
+	 * INPUT
+	 * INPUT
+	 * INPUT
+	 * INPUT
+	 * INPUT END HERE
+	 */
+	static void solve() throws IOException {
+		
+		int n = nexInt();
+		ArrayList<ArrayList<edge>> tree = new ArrayList<>();
+		for(int i = 0; i < n; i++) tree.add(new ArrayList<edge>());
+		for(int i = 0; i < n - 1; i++) {
+		int [] s1 = inputIntArr();
+		addEdge(tree, s1[0] - 1, s1[1] - 1, i);
+		}
+		int vertex = 0;
+		for(int i = 0; i < tree.size(); i++) {
+			if(tree.get(i).size() > 2) {
+				System.out.println(-1);
+				return;
+			}else if(tree.size() == 1) {
+				vertex = i;
+			}
+		}
+		int [] toReturn = new int[n - 1];
+		//toReturn.add(2);
+		dfs(tree, vertex, new boolean[n], toReturn,  2);
+		//System.out.println(toReturn.size());
+		
+		
+			for(int i = 0; i <  toReturn.length; i++) 
+				if(toReturn[i] != 0)System.out.print(toReturn[i] + "" "");
+			System.out.println();
+		
+		
+	}
+
+	public static void main(String[] args) throws IOException {
+		// TODO Auto-generated method stub
+		
+		 int t = Integer.parseInt(sc.readLine()); for(int i = 0; i < t; i++) 
+		  solve();
+		
+		
+	}
+	}
+
+
+
+
+",0
+27ec4acc,ddcadc64,"import java.io.*;
+import java.lang.reflect.Array;
+import java.math.BigInteger;
+import java.util.*;
+import java.util.BitSet;
+import java.util.function.BinaryOperator;
+
+public class D {
+    static class FastReader {
+        BufferedReader br;
+        StringTokenizer st;
+
+        public FastReader() {
+            br = new BufferedReader(new
+                    InputStreamReader(System.in));
+        }
+
+        String next() {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+
+        String nextLine() {
+            String str = """";
+            try {
+                str = br.readLine();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+        }
+    }
+
+    static FastReader s = new FastReader();
+    static PrintWriter out = new PrintWriter(System.out);
+
+    private static int[] rai(int n) {
+        int[] arr = new int[n];
+        for (int i = 0; i < n; i++) {
+            arr[i] = s.nextInt();
+        }
+        return arr;
+    }
+
+    private static int[][] rai(int n, int m) {
+        int[][] arr = new int[n][m];
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < m; j++) {
+                arr[i][j] = s.nextInt();
+            }
+        }
+        return arr;
+    }
+
+    private static long[] ral(int n) {
+        long[] arr = new long[n];
+        for (int i = 0; i < n; i++) {
+            arr[i] = s.nextLong();
+        }
+        return arr;
+    }
+
+    private static long[][] ral(int n, int m) {
+        long[][] arr = new long[n][m];
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < m; j++) {
+                arr[i][j] = s.nextLong();
+            }
+        }
+        return arr;
+    }
+
+    private static int ri() {
+        return s.nextInt();
+    }
+
+    private static long rl() {
+        return s.nextLong();
+    }
+
+    private static String rs() {
+        return s.next();
+    }
+
+
+    static long gcd(long a,long b)
+    {
+        if(b==0)
+        {
+            return a;
+        }
+        return gcd(b,a%b);
+    }
+
+    static int MOD=(int)1e9+7;
+
+    public static int primeFactors(long n)
+    {
+        // Print the number of 2s that divide n
+        int count=0;
+        while (n % 2 == 0) {
+            count++;
+            n /= 2;
+        }
+
+        // n must be odd at this point.  So we can
+        // skip one element (Note i = i +2)
+        for (long i = 3; i * i<=n; i += 2) {
+            // While i divides n, print i and divide n
+            while (n % i == 0) {
+                count++;
+                n /= i;
+            }
+        }
+
+        // This condition is to handle the case whien
+        // n is a prime number greater than 2
+        if (n > 2)
+            count++;
+
+        return count;
+    }
+
+    static class Node
+    {
+        int val, i;
+
+        public Node(int val, int i) {
+            this.val = val;
+            this.i = i;
+        }
+    }
+    public static void main(String[] args) {
+        StringBuilder ans = new StringBuilder();
+        int t = ri();
+//        int t=1;
+        while(t-- >0)
+        {
+            int n=ri();
+            int[] arr=rai(n);
+            int[] res = new int[n];
+            if(n%2==0)
+            {
+
+                for(int i=0;i<n;i+=2)
+                {
+                    res[i] = -arr[i+1];
+                    res[i+1]=arr[i];
+                }
+
+
+            }
+            else {
+                for(int i=0;i<n-3;i+=2)
+                {
+                    res[i] = -arr[i+1];
+                    res[i+1]=arr[i];
+                }
+
+                int val = arr[n-1]+arr[n-2];
+                if(val!=0) {
+                    res[n - 3] = -val;
+                    res[n - 2] = arr[n - 3];
+                    res[n - 1] = arr[n - 3];
+                }
+                else
+                {
+                    val = arr[n-1]+arr[n-3];
+                    if(val!=0) {
+                        res[n - 2] = -val;
+                        res[n - 1] = arr[n - 2];
+                        res[n - 3] = arr[n - 2];
+                    }
+                    else
+                    {
+                        val = arr[n-2]+arr[n-3];
+                        res[n-1] = -val;
+                        res[n-2]=arr[n-1];
+                        res[n-3]=arr[n-1];
+                    }
+                }
+
+            }
+
+            for(int i:res)
+            {
+                ans.append(i).append("" "");
+            }
+            ans.append(""\n"");
+
+//            int sum=0;
+//            for(int i=0;i<n;i++)
+//            {
+//                sum+=arr[i]*res[i];
+//            }
+//            System.out.println(sum);
+
+        }
+        out.print(ans.toString());
+        out.flush();
+    }
+}","import java.util.Scanner;
+
+public class D {
+    public static void main(String[] args) {
+        Scanner scn = new Scanner(System.in);
+        int t = scn.nextInt();
+        StringBuilder sb = new StringBuilder();
+        while (t-- > 0) {
+            int n = scn.nextInt();
+            int[] arr = new int[n];
+            int[] ans = new int[n];
+            for (int i = 0; i < n; i++) {
+                arr[i] = scn.nextInt();
+            }
+            if (n % 2 != 0) {
+                if (arr[n - 2] + arr[n - 3] == 0) {
+                    ans[n - 3] = -2 * arr[n - 1];
+                    ans[n - 2] = -arr[n - 1];
+                    ans[n - 1] = arr[n - 2] + arr[n - 3] * 2;
+                } else {
+                    ans[n - 3] = -arr[n - 1];
+                    ans[n - 2] = -arr[n - 1];
+                    ans[n - 1] = arr[n - 2] + arr[n - 3];
+                }
+                n -= 3;
+            }
+            for (int i = 0; i < n; i += 2) {
+                int div = 1;
+                if (arr[i] % 2 == 0 && arr[i + 1] % 2 == 0)
+                    div = 2;
+                ans[i] = arr[i + 1] / div;
+                ans[i + 1] = -arr[i] / div;
+            }
+            for (int v : ans) {
+                sb.append(v);
+                sb.append("" "");
+            }
+            sb.append(""\n"");
+        }
+        System.out.println(sb);
+    }
+}
+",0
+b7de5c19,ee65f7f5,"import java.util.*;
+
+public class Main {
+    public static void main(String[] args) {
+        Scanner scan = new Scanner(System.in);
+        int t = scan.nextInt();
+        for (int i = 0; i < t; i++) {
+            int n = scan.nextInt();
+            ArrayList<ArrayList<Pair>> graph = new ArrayList<>();
+            for (int j = 0; j < n; j++) {
+                graph.add(new ArrayList<>());
+            }
+            for (int j = 0; j < n - 1; j++) {
+                int u;
+                int v;
+                u = scan.nextInt();
+                v = scan.nextInt();
+                u--;
+                v--;
+                graph.get(u).add(new Pair(v, j));
+                graph.get(v).add(new Pair(u, j));
+            }
+            boolean soluble = true;
+            int curV = 0;
+            int prevV = -1;
+            int[] ans = new int[n];
+            int prime = 2;
+            for (int j = 0; j < n; j++) {
+                ArrayList<Pair> list = graph.get(j);
+                if (list.size() > 2) {
+                    soluble = false;
+                } else if (list.size() == 1) {
+                    curV = j;
+                }
+            }
+            if (soluble) {
+                for (int j = 0; j < n - 1; j++) {
+                    ArrayList<Pair> list = graph.get(curV);
+                    for (int z = 0; z < list.size(); z++) {
+                        if (list.get(z).vertex != prevV) {
+                            ans[list.get(z).numberOfEdge] = prime;
+                            prime = changePrime(prime);
+                            prevV = curV;
+                            curV = list.get(z).vertex;
+                            break;
+                        }
+                    }
+                }
+
+                for (int j = 0; j < n - 1; j++) {
+                    System.out.print(ans[j] + "" "");
+                }
+                System.out.println();
+            } else {
+                System.out.println(-1);
+            }
+        }
+    }
+    public static int changePrime(int prime) {
+        if (prime == 2) {
+            prime = 3;
+        } else {
+            prime = 2;
+        }
+        return prime;
+    }
+}
+
+class Pair {
+    int vertex;
+    int numberOfEdge;
+
+    public Pair(int vertex, int numberOfEdge) {
+        this.vertex = vertex;
+        this.numberOfEdge = numberOfEdge;
+    }
+}
+","import java.io.*;
+import java.util.*;
+
+
+public class Main {
+    static int i, j, k, n, m, t, y, x, sum = 0;
+    static long mod = 998244353;
+    static FastScanner fs = new FastScanner();
+    static PrintWriter out = new PrintWriter(System.out);
+    static String str;
+
+    public static void main(String[] args) {
+
+        t = fs.nextInt();
+
+        while (t-- > 0) {
+
+            n = fs.nextInt();
+
+            List<Pair>[] g = new ArrayList[n+1];
+
+            for(i=1;i<=n;i++){
+                g[i] = new ArrayList();
+            }
+
+            for(i=0;i<n-1;i++){
+                x = fs.nextInt();
+                y = fs.nextInt();
+
+                g[x].add(new Pair(y,i));
+                g[y].add(new Pair(x,i));
+            }
+
+            boolean isPossible = true;
+            int l1 =0, l2=0;
+            for(i=1;i<=n;i++){
+
+                if(g[i].size()>2)
+                    isPossible = false;
+
+                if(g[i].size()==1)
+                    if(l1==0)
+                        l1 = i;
+                    else
+                        l2 =i;
+
+
+            }
+
+            if(!isPossible){
+                out.println(-1);
+                continue;
+            }
+
+            i = l1;
+            k=0;
+            int [] ans = new int[n];
+            int [] vis = new int[n+1];
+            j=0;
+
+            while(i!=l2){
+
+                Pair p = g[i].get(0);
+
+                if(p.x==j)
+                    p = g[i].get(1);
+
+                if(k%2==0)
+                    ans[p.y] = 2;
+                else
+                    ans[p.y]=5;
+
+                k++;
+
+                j=i;
+                i = p.x;
+            }
+
+
+
+            for(i=0;i<n-1;i++){
+                out.print(ans[i]+"" "");
+            }
+
+
+
+
+            out.println();
+
+        }
+
+        out.close();
+    }
+
+   /*static long nck(int n , int k){
+        long a = fact[n];
+        long b = modInv(fact[k]);
+        b*= modInv(fact[n-k]);
+        b%=mod;
+
+        return (a*b)%mod;
+    }
+
+   static void populateFact(){
+        fact[0]=1;
+
+        fact[1] = 1;
+
+        for(i=2;i<300005;i++){
+            fact[i]=i*fact[i-1];
+            fact[i]%=mod;
+        }
+    }
+    */
+
+
+    static long gcd(long a, long b) {
+        if (b == 0)
+            return a;
+        return gcd(b, a % b);
+    }
+
+    static long exp(long base, long pow) {
+        if (pow == 0) return 1;
+        long half = exp(base, pow / 2);
+        if (pow % 2 == 0) return mul(half, half);
+        return mul(half, mul(half, base));
+    }
+
+    static long mul(long a, long b) {
+        return ((a % mod) * (b % mod)) % mod;
+    }
+
+    static long add(long a, long b) {
+        return ((a % mod) + (b % mod)) % mod;
+    }
+
+    static long modInv(long x) {
+        return exp(x, mod - 2);
+    }
+
+    static void ruffleSort(int[] a) {
+        //ruffle
+        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;
+        }
+
+        //then sort
+        Arrays.sort(a);
+    }
+
+    static void ruffleSort(long[] a) {
+        //ruffle
+        int n = a.length;
+        Random r = new Random();
+        for (int i = 0; i < a.length; i++) {
+            int oi = r.nextInt(n);
+            long temp = a[i];
+            a[i] = a[oi];
+            a[oi] = temp;
+        }
+
+        Arrays.sort(a);
+    }
+
+    static class FastScanner {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st = new StringTokenizer("""");
+
+        String next() {
+            while (!st.hasMoreTokens())
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        int[] readArray(int n) {
+            int[] a = new int[n];
+            for (int i = 0; i < n; i++) a[i] = nextInt();
+            return a;
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+    }
+
+
+    static class Pair implements Comparable<Pair> {
+        public int x, y;
+
+        Pair(int x, int y) {
+            this.x = x;
+            this.y = y;
+        }
+
+        @Override
+        public int compareTo(Pair o) {
+
+            if (x == o.x)
+                return Integer.compare(y, o.y);
+
+            return Integer.compare(x, o.x);
+        }
+
+
+    }
+
+}",0
+ee270b2a,fc80cbe0,"import java.util.*;
+
+public class D{
+    private static Scanner scanner = new Scanner(System.in);
+    public static void main(String[] args){
+        int q = scanner.nextInt();
+        while(q-- > 0){
+            int n = scanner.nextInt(),
+            k = scanner.nextInt();
+            int[] a = new int[k];
+            for(int i=0;i<k;i++){
+                a[i] = scanner.nextInt();
+            }
+            int[] t = new int[k];
+            for(int j=0;j<k;j++){
+                t[j] = scanner.nextInt();
+            }
+            long[] L = new long[n];
+            long[] R = new long[n];
+            for(int i=0;i<n;i++){
+                L[i] = Integer.MAX_VALUE;
+                R[i] = Integer.MAX_VALUE;
+            }
+            for(int i=0;i<k;i++){
+                L[a[i]-1] = t[i];
+                R[a[i]-1] = t[i];
+            }
+            
+            long min = Integer.MAX_VALUE;
+            for(int i=0;i<n;i++){
+                L[i] = Math.min(min+1,L[i]);
+                min = L[i];
+            }
+            min = Integer.MAX_VALUE;
+            for(int i=n-1;i>=0;i--){
+                R[i] = Math.min(min+1,R[i]);
+                min = R[i];
+            }
+            for(int i=0;i<n;i++){
+                System.out.print(Math.min(L[i],R[i]) + "" "");
+            }
+            System.out.println();
+        }
+    }
+}
+","import javax.swing.*;
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.StringTokenizer;
+
+public class AirConditioner {
+    public static void main(String[] args) {
+        MyScanner sc = new MyScanner();
+
+        int input = sc.nextInt();
+        sc.nextLine();
+        for(int i = 0; i < input; i++){
+            String[] length = sc.nextLine().split("" "");
+            String[] index = sc.nextLine().split("" "");
+            String[] temperature = sc.nextLine().split("" "");
+            long[] boxes = findTemp(length, index,temperature);
+            for(int j = 0; j < boxes.length; j++){
+                if(j == 0) System.out.print(boxes[j]);
+                else System.out.print("" ""+boxes[j]);
+            }
+            System.out.println();
+            sc.nextLine();
+        }
+    }
+
+    public static long[]  findTemp(String[] length, String[] index,String[] temperature) {
+        long n = Long.parseLong(length[0]);
+        HashSet<Integer> set = new HashSet<>();
+        long airCond = Long.parseLong(length[1]);
+        long[] boxes = new long[(int)n];
+        Arrays.fill(boxes,Integer.MAX_VALUE);
+        for(int i = 0 ; i < index.length; i++){
+            boxes[Integer.parseInt(index[i]) - 1] = Long.parseLong(temperature[i]);
+            set.add(Integer.parseInt(index[i]) - 1);
+           // System.out.println(index[i]);
+        }
+
+        int prev = -1;
+        for(int i = 0 ; i < boxes.length; i++) {
+            //System.out.println(i +"" ""+set.contains(i));
+            if(set.contains(i)){
+                if(prev != - 1) boxes[i] = Math.min((Math.abs(i - prev) ) + boxes[prev],boxes[i]);
+               // System.out.println(i + ""  ""+prev);
+                prev = i;
+            }
+           if(prev == -1) continue;
+           if(set.contains(i)){
+               prev = i;
+           }
+
+           else{
+               boxes[i] = (Math.abs(i - prev) ) + boxes[prev];
+           }
+        }
+        prev = boxes.length;
+        for(int i = boxes.length - 1; i >= 0; i--) {
+            if(set.contains(i)){
+              //  System.out.println(i);
+                if(prev != boxes.length)  boxes[i] = Math.min((Math.abs(i - prev) ) + boxes[prev],boxes[i]);
+                prev = i;
+            }
+            if(prev == boxes.length) continue;
+
+            else{
+                boxes[i] = Math.min((Math.abs(i - prev) ) + boxes[prev],boxes[i]);
+            }
+        }
+
+
+        return boxes;
+    }
+}
+class MyScanner {
+    BufferedReader br;
+    StringTokenizer st;
+
+    public MyScanner() {
+        br = new BufferedReader(new InputStreamReader(System.in));
+    }
+
+    String next() {
+        while (st == null || !st.hasMoreElements()) {
+            try {
+                st = new StringTokenizer(br.readLine());
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+        }
+        return st.nextToken();
+    }
+
+    int nextInt() {
+        return Integer.parseInt(next());
+    }
+
+    long nextLong() {
+        return Long.parseLong(next());
+    }
+
+    double nextDouble() {
+        return Double.parseDouble(next());
+    }
+
+    String nextLine() {
+        String str = """";
+        try {
+            str = br.readLine();
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        return str;
+    }
+
+}
+",0
+13441e8f,2ebeae13,"import java.util.*;
+
+public class Armchairs {
+
+	public static int findMinTime(List<Integer> zeros, List<Integer> ones) {
+		if (ones.size() == 0)
+			return 0;
+		int oneSize = ones.size();
+		int zeroSize = zeros.size();
+		int [][] time = new int [oneSize + 1][zeroSize + 1];
+		for (int i=1; i<=oneSize; i++) {
+			time[i][i] = time[i - 1][i - 1] + Math.abs(ones.get(i - 1) - zeros.get(i - 1));
+			for (int j=i+1; j<=zeroSize; j++) {
+				time[i][j] = Math.min(time[i][j - 1], time[i - 1][j - 1] + 
+					Math.abs(ones.get(i - 1) - zeros.get(j - 1)));
+			}
+		}
+		return time[oneSize][zeroSize];
+	}
+
+	public static void main (String [] args) {
+		Scanner sc = new Scanner(System.in);
+		int n = sc.nextInt();
+		List<Integer> zeros = new ArrayList<>();
+		List<Integer> ones = new ArrayList<>();
+		for (int i=0; i<n; i++) {
+			int number= sc.nextInt();
+			if (number == 1)
+				ones.add(i);
+			else
+				zeros.add(i);
+		}
+		System.out.println(findMinTime(zeros, ones));
+	}
+}","import java.io.BufferedReader; 
+import java.io.IOException; 
+import java.io.InputStreamReader; 
+import java.util.Scanner; 
+import java.util.StringTokenizer;
+import java.util.*;
+public class codeforcesD{
+   static class FastReader 
+    { 
+        BufferedReader br; 
+        StringTokenizer st; 
+ 
+        public FastReader() 
+        { 
+            br = new BufferedReader(new
+                     InputStreamReader(System.in)); 
+        } 
+ 
+        String next() 
+        { 
+            while (st == null || !st.hasMoreElements()) 
+            { 
+                try
+                { 
+                    st = new StringTokenizer(br.readLine()); 
+                } 
+                catch (IOException  e) 
+                { 
+                    e.printStackTrace(); 
+                } 
+            } 
+            return st.nextToken(); 
+        } 
+ 
+        int nextInt() 
+        { 
+            return Integer.parseInt(next()); 
+        } 
+ 
+        long nextLong() 
+        { 
+            return Long.parseLong(next()); 
+        } 
+ 
+        double nextDouble() 
+        { 
+            return Double.parseDouble(next()); 
+        } 
+ 
+        String nextLine() 
+        { 
+            String str = """"; 
+            try
+            { 
+                str = br.readLine(); 
+            } 
+            catch (IOException e) 
+            { 
+                e.printStackTrace(); 
+            } 
+            return str; 
+        } 
+    } 
+    public static long dp[][];
+    public static List<Integer> list1,list0;
+   public static void main(String args[]){
+        FastReader sc=new FastReader();
+        int n=sc.nextInt();
+        list1=new ArrayList<>();
+        list0=new ArrayList<>();
+        for(int i=0;i<n;i++){
+           int a=sc.nextInt();
+           if(a==0){list0.add(i);}
+           if(a==1){list1.add(i);}
+        }
+        dp=new long[list1.size()][list0.size()];
+        for(int i=0;i<list1.size();i++){
+          for(int j=0;j<list0.size();j++){
+              dp[i][j]=-1;
+            }
+        }
+        System.out.println(check(0,0));
+       
+   } 
+   public static long check(int i,int j){
+          if(i>=list1.size()){return 0;}
+          if(j>=list0.size()){return Integer.MAX_VALUE;}
+          if(dp[i][j]!=-1){return dp[i][j];}
+          dp[i][j]=Math.min(check(i+1,j+1)+(long)Math.abs(list1.get(i)-list0.get(j)),check(i,j+1));
+         return dp[i][j];
+     }
+}
+",0
+2063ba3e,2ba7edb6,"import java.io.*;
+import java.util.*;
+
+public class c {
+    public static void main(String[] args) throws Exception {
+        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
+        PrintWriter out = new PrintWriter(System.out);
+        int numCases = Integer.parseInt(in.readLine());
+        for (int casenum = 0; casenum < numCases; casenum++) {
+            int n = Integer.parseInt(in.readLine());
+            long[] arr = new long[n];
+            StringTokenizer tokenizer = new StringTokenizer(in.readLine());
+            for (int i = 0; i < n; i++) {
+                arr[i] = Long.parseLong(tokenizer.nextToken());
+            }
+            long low = 0;
+            long high = 1000000000;
+            low--;
+            while (low < high) {
+                long mid = low + (high - low + 1) / 2;
+                boolean works = test(arr, mid);
+                if (works) {
+                    low = mid;
+                } else {
+                    high = mid - 1;
+                }
+                //System.out.println(mid + "" "" + works);
+            }
+            System.out.println(low);
+        }
+        in.close();
+        out.close();
+    }
+
+    public static boolean test(long[] arr, long k) {
+        long[] h = new long[arr.length];
+        for (int i = 0; i < arr.length; i++) {
+            h[i] = arr[i];
+        }
+        for (int i = h.length - 1; i - 2 >= 0; i--) {
+            if (h[i] < k)
+                break;
+            long d = Math.min((h[i]-k) / 3, arr[i]/3);
+            h[i] -= 3 * d;
+            h[i - 1] += d;
+            h[i-+ 2] += 2 * d;
+        }
+        for (int i = 0; i < h.length; i++) {
+            if (h[i] < k)
+                return false;
+        }
+        //System.out.println(Arrays.toString(h));
+        return true;
+    }
+}","import java.util.*;
+import java.io.*;
+
+public class BalancedStones {
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader f = new BufferedReader(new InputStreamReader(System.in));
+		int t = Integer.parseInt(f.readLine());
+		while (t > 0) {
+			t--;
+			int n = Integer.parseInt(f.readLine());
+			int[] arr = new int[n];
+			StringTokenizer st = new StringTokenizer(f.readLine());
+			for (int i = 0; i < n; i++) {
+				arr[i] = Integer.parseInt(st.nextToken());
+			}
+			int low = 0;
+			int high = 1000000000;
+			int answer = -1;
+			while (low <= high) {
+				int mid = low + (high - low) / 2;
+				if (check(mid, arr)) {
+					answer = mid;
+					low = mid + 1;
+				} else {
+					high = mid - 1;
+				}
+			}
+			System.out.println(answer);
+		}
+	}
+
+	public static boolean check(int value, int[] old) {
+		int[] newarr = new int[old.length];
+		for (int i = 0; i < old.length; i++) {
+			newarr[i] = old[i];
+		}
+		for (int i = old.length - 1; i >= 0; i--) {
+			if (newarr[i] < value)
+				return false;
+			if (i > 1) {
+				int d = Math.min(newarr[i] - value, old[i]) / 3;
+				newarr[i] -= 3 * d;
+				newarr[i - 1] += d;
+				newarr[i - 2] += 2 * d;
+			}
+		}
+		return true;
+	}
+}",0
+6e637812,aa8091b0,"//package codeforces;
+import java.io.PrintWriter;
+import java.util.*;
+public class codeforces {
+	public static void main(String[] args) {
+		PrintWriter out=new PrintWriter(System.out);
+    	Scanner s=new Scanner(System.in);  
+    	int t=s.nextInt();
+    	for(int tt=0;tt<t;tt++) {
+    		int n=s.nextInt(),m=s.nextInt(),x=s.nextInt();
+    		HashMap<Integer,ArrayList<Integer>> map=new HashMap<>();
+    		int a[]=new int[n];
+    		for(int i=0;i<n;i++) {
+    			a[i]=s.nextInt();
+    			if(map.containsKey(a[i])) {
+    				ArrayList<Integer> c=map.get(a[i]);
+    				c.add(i+1);
+    				map.put(a[i], c);
+    			}else {
+    				ArrayList<Integer> c=new ArrayList<>();
+    				c.add(i+1);
+    				map.put(a[i], c);
+    			}
+    		}
+    		sort(a);
+    		long ans[]=new long[m];
+    		int c=0;
+    		boolean l=true;
+    		for(int i=n-1;i>=0;i--) {
+    			if(c==m && l) {
+    				c=m-1;
+    				l=false;
+    			}else if(!l && c==-1){
+    				l=true;
+    				c=0;
+    			}
+    			ans[c]+=a[i];
+    			if(l) {
+    				c++;
+    			}else {
+    				c--;
+    			}
+    		}
+    		long min=Integer.MAX_VALUE,max=Integer.MIN_VALUE;
+    		for(int i=0;i<m;i++) {
+    			min=Math.min(ans[i], min);
+    			max=Math.max(ans[i], max);
+    		}
+    		if(max-min>x) {
+    			System.out.println(""NO"");
+    		}else {
+    			System.out.println(""YES"");
+    			int a1[]=new int[n];
+    			c=0;
+    			l=true;
+    			for(int i=n-1;i>=0;i--) {
+    				if(c==m && l) {
+        				c=m-1;
+        				l=false;
+        			}else if(!l && c==-1){
+        				l=true;
+        				c=0;
+        			}
+    				a1[map.get(a[i]).get(0)-1]=c+1;
+    				
+    				map.get(a[i]).remove(0);
+    				if(l) {
+        				c++;
+        			}else {
+        				c--;
+        			}
+    				
+    			}
+    			for(int i=0;i<n;i++) {
+    				System.out.print(a1[i]+"" "");
+    			}
+    			System.out.println();
+    		}
+    	}
+    	out.close();
+	    s.close();
+	}
+	
+	static void sort(int[] a) {
+		ArrayList<Integer> l=new ArrayList<>();
+		for (int i:a) l.add(i);
+		Collections.sort(l);
+		for (int i=0; i<a.length; i++) a[i]=l.get(i);
+	}
+	
+}
+ 
+
+","import java.util.*;
+ 
+import java.io.*;
+ 
+public class AiseHi {
+	static Scanner sc = new Scanner(System.in);
+	static int mod = (int)(1e9+7);
+	public static void main (String[] args) {
+		PrintWriter out = new PrintWriter(System.out);
+		int t = 1;
+    	t = sc.nextInt();
+    	z : while(t-->0) {
+    		int n = sc.nextInt();
+    		int m = sc.nextInt();
+    		int x = sc.nextInt();
+    		PriorityQueue<twoval> myQueue = new PriorityQueue<>();
+    		for(int i=1;i<=m;i++) {
+    			myQueue.add(new twoval(0,i));
+    		}
+    		List<twoval> arrayList = new ArrayList<>();
+    		int myArray[] = new int[n];
+    		for(int i=0;i<n;i++) {
+    			int aasjd = sc.nextInt();
+    			arrayList.add(new twoval(aasjd,i));
+    			myArray[i] = aasjd;
+    		}
+    		Collections.sort(arrayList);
+    		int ans[] = new int[n];
+    		for(int i=n-1;i>=0;i--) {
+    			twoval p = myQueue.poll();
+    			long aasjd = p.myArray;
+    			int idx = p.b;
+    			aasjd += arrayList.get(i).myArray;
+    			ans[arrayList.get(i).b] = idx;
+    			myQueue.add(new twoval(aasjd,idx));
+    		}
+    		long dasdaknw[] = new long[m];
+    		long min = Long.MAX_VALUE, max = Long.MIN_VALUE;
+    		for(int i=0;i<n;i++) {
+    			dasdaknw[ans[i]-1] += myArray[i];
+    		}
+    		for(int i=0;i<m;i++) {
+    			min = Math.min(min, dasdaknw[ans[i]-1]);
+    			max = Math.max(max, dasdaknw[ans[i]-1]);
+    		}
+    		if(max-min>x) {
+    			out.write(""NO\n"");
+    			continue;
+    		}
+    		out.write(""YES\n"");
+    		for(int aasjd : ans) out.write(aasjd+"" "");
+    		out.write(""\n"");
+    	}
+		out.close();
+	}
+	static int ceil(int myArray,int b) {
+		return myArray/b + (myArray%b==0?0:1);
+	}
+	static boolean prime[] = new boolean[2000009];
+	static int fac[] = new int[2000009];
+	
+	static void sieve() {
+		prime[0] = true;
+		prime[1] = true;
+		int max = 1000000;
+		for(int i=2;i*i<=max;i++) {
+			if(!prime[i]) {
+				for(int j=i*i;j<=max;j+=i) {
+					prime[j] = true;
+					fac[j] = i;
+				}
+			}
+		}
+	}
+	static int gcd(int myArray,int b) { if(b==0) return myArray; return gcd(b,myArray%b); }
+}
+ 
+class twoval implements Comparable<twoval>{
+	long myArray;
+	int b;
+	twoval(long aasjd,int r){
+		this.myArray = aasjd;
+		this.b = r;
+	}
+	public int compareTo(twoval o) {
+		return (int) (this.myArray - o.myArray);
+	}
+}
+",0
+8532d5ed,b9595381,"import java.util.*;
+import java.io.*;
+
+public class C_Interesting_Story{
+    public static void main(String[] args) {
+        FastScanner s= new FastScanner();
+        StringBuilder res = new StringBuilder();
+        int t=s.nextInt();
+        int p=0;
+        while(p<t){
+        int n=s.nextInt();
+        ArrayList<String> list = new ArrayList<String>();
+        for(int i=0;i<n;i++){
+            String str=s.nextToken();
+            list.add(str);
+        }
+        long max=Integer.MIN_VALUE;
+        for(int i=97;i<102;i++){
+            char ch=(char)i;
+            ArrayList<Integer> nice = new ArrayList<Integer>();
+            for(int j=0;j<n;j++){
+                String obj=list.get(j);
+                int count=0;
+                for(int k=0;k<obj.length();k++){
+                     char ch2=obj.charAt(k);
+                     if(ch2==ch){
+                         count++;
+                     }
+                }
+                int num=obj.length()-count;
+                nice.add(count-num);
+
+            }
+            Collections.sort(nice,Collections.reverseOrder());
+            long sum=0;
+            long counting=0;
+            for(int j=0;j<nice.size();j++){
+                sum+=nice.get(j);
+                if(sum>0){
+                    counting++;
+                }
+                else{
+                    break;
+                }
+            }
+            max=Math.max(max,counting);
+
+        }
+        res.append(max+""\n"");
+        p++;
+    }
+    System.out.println(res);
+    }
+    static class FastScanner {
+		BufferedReader br;
+		StringTokenizer st;
+ 
+		public FastScanner(String s) {
+			try {
+				br = new BufferedReader(new FileReader(s));
+			} catch (FileNotFoundException e) {
+				// TODO Auto-generated catch block
+				e.printStackTrace();
+			}
+		}
+ 
+		public FastScanner() {
+			br = new BufferedReader(new InputStreamReader(System.in));
+		}
+ 
+		String nextToken() {
+			while (st == null || !st.hasMoreElements()) {
+				try {
+					st = new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					// TODO Auto-generated catch block
+					e.printStackTrace();
+				}
+			}
+			return st.nextToken();
+		}
+ 
+		int nextInt() {
+			return Integer.parseInt(nextToken());
+		}
+ 
+		long nextLong() {
+			return Long.parseLong(nextToken());
+		}
+ 
+		double nextDouble() {
+			return Double.parseDouble(nextToken());
+		}
+	}
+
+
+
+
+}","import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.*;
+public class Main{
+    
+static int dest1;
+static int dest2;
+public static void main(String args[]){
+       	FastScanner in = new FastScanner();
+		int test=in.nextInt();
+                while(test-->0){
+                    int n=in.nextInt();
+                    int count[][]=new int[n][5];
+                    int total[]=new int[n];
+                    String words[]=new String[n];
+                    for(int i=0;i<n;i++){
+                        words[i]=in.next();
+                        for(int j=0;j<words[i].length();j++)
+                            count[i][words[i].charAt(j)-'a']++;
+                        
+                        total[i]=words[i].length();
+                    }
+                    int max=Integer.MIN_VALUE;
+                   for(int i=0;i<5;i++){
+                       
+                      Integer ans[]=new Integer[n];
+                      for(int j=0;j<n;j++){
+                          ans[j]=count[j][i]-(total[j]-count[j][i]);
+                      }
+                      Arrays.sort(ans,Collections.reverseOrder());
+                      int j=0;
+                      int r=0;
+                      while(j<n && r+ans[j]>0){
+                          r+=ans[j];
+                          j++;
+                      }
+                      max=Math.max(j,max);
+                      
+                   }
+                   System.out.println(max);
+                   
+                    
+                }
+}
+public static int solve(int start[], int end[], int n)
+    {
+        int distance[][]=new int[n][n];
+        int r=n;
+        int c=n;
+        boolean visited[][]=new boolean[n][n];
+        int startx=start[0];
+        int starty=start[1];
+        int endx=end[0];
+        int endy=end[1];
+        Pair tmp=new Pair(startx,starty);
+		Queue<Pair> q=new LinkedList<>();
+		q.add(tmp);
+		visited[startx][starty]=true;
+		distance[startx][starty]=0;
+		int dx[]={-2,-1,1,2,2,1,-1,-2};
+		int dy[]={1,2,2,1,-1,-2,-2,-1};
+		while(!q.isEmpty())
+		{
+			Pair cell=q.poll();
+			int x=cell.x;
+			int y=cell.y;
+			int d=distance[x][y];
+			for(int i=0;i<8;i++)
+			{
+				int childx=x+dx[i];
+				int childy=y+dy[i];
+				if(valid(childx,childy,r,c,visited))
+				{
+					visited[childx][childy]=true;
+					distance[childx][childy]=d+1;
+					q.add(new Pair(childx,childy));
+				}
+			}
+		}
+		return distance[endx][endy];
+    }
+       
+public static boolean valid(int x,int y,int r,int c,boolean visited[][])
+	{
+		if(x<0||y<0||x>=r||y>=c)
+			return false;
+		if(visited[x][y])
+			return false;
+		return true;
+	}
+public static int knight(int i,int j){
+    if(i==dest1 && j==dest2)
+        return 0;
+    
+    if(i<1 || j<1)
+        return 0;
+    if(i>8 || j>8)
+        return 0;
+    
+    if(i<1 || j>8)
+        return 0;
+    
+    if(i>8 || j<1)
+        return 0;
+    
+    int min=0;
+    if(i-1>=1 && j-2>=1)
+        min+=1+knight(i-1,j-2);
+    if(i-1>=1 && j+2<=8)
+        min+=1+knight(i-1,j+2);
+    if(i-2>=1 && j-1>=1)
+        min+=1+knight(i-2,j-1);
+    if(i-2>=1 && j+1<=8)
+        min+=1+knight(i-2,j+1);
+     if(i+1<=8 && j-2>=1)
+        min+=1+knight(i+1,j-2);
+    if(i+1<=8 && j+2<=8)
+        min+=1+knight(i+1,j+2);
+    if(i+2<=8 && j-1>=1)
+        min+=1+knight(i+2,j-1);
+    if(i+2<=8 && j+1<=8)
+        min+=1+knight(i+2,j+1);
+    
+    return min;
+}
+
+}
+class FastScanner {
+		java.io.BufferedReader br = new java.io.BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st = new StringTokenizer("""");
+ 
+		String next() {
+			while (!st.hasMoreTokens())
+				try {
+					st = new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			return st.nextToken();
+		}
+ 
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+ 
+		int[] readArray(int n) {
+			int[] a = new int[n];
+			for (int i = 0; i < n; i++)
+				a[i] = nextInt();
+			return a;
+		}
+ 
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+	}
+class Pair
+    {
+    	int x;
+    	int y;
+    	Pair(int i,int j)
+    	{
+    		x=i;
+    		y=j;
+    	}
+    }
+ 
+      
+
+
+
+",0
+339fdc7f,6be4dcef,"import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.IOException;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.PriorityQueue;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.StringTokenizer;
+
+public class B{
+	static FastScanner sc = new FastScanner();
+	static int inf = Integer.MAX_VALUE;
+	static long mod = 1000000007;
+	static BufferedWriter output = new BufferedWriter(
+			new OutputStreamWriter(System.out));
+	
+	
+	public static long util(int arr[]) {
+		Arrays.sort(arr);
+		int i = 0;
+		int j = arr.length - 1;
+		while(i <= j) {
+			int tmp = arr[i];
+			arr[i] = arr[j];
+			arr[j] = tmp;
+			i++;
+			j--;
+		}
+		int n = arr.length;
+		//min priority queue
+		PriorityQueue<Integer> pq = new PriorityQueue<>();
+		long ans = 0;
+		long sum = 0;
+		long cnt = 0;
+		for(int ii: arr) {
+			if( ii == 0) cnt++;
+		}
+		for(i =0;i<n;i++) {
+			
+			sum += arr[i];
+			ans++;
+			if(arr[i] < 0) {
+				pq.add(arr[i]);
+			}
+			if( sum <= 0 ) {
+				while( sum <= 0 ) {
+					if(pq.isEmpty()) break;
+					sum -= pq.peek();
+					ans--;
+					pq.remove();
+					
+				}
+			}
+		}
+		if(sum > 0) 
+			return ans;
+		return ans - cnt;
+		
+		
+		
+	}
+	
+	
+	public static void solve() {
+		int n = sc.nextInt();
+		String a[] = new String[n];
+		for(int i =0;i<n;i++) {
+			a[i] = sc.next();
+		}
+		
+		long ans =  -1;
+		for(int i =0;i<5;i++) {
+			char mx = (char)(i + 'a');
+			int c1 = 0, c2 = 0;
+			int arr[] = new int[n];
+			for(int j =0;j<n;j++) {
+				c1 = 0;
+				c2 = 0;
+				for(int k = 0;k<a[j].length();k++) {
+					if(a[j].charAt(k) == mx) c1++;
+					else c2++;
+				}
+				arr[j]= c1 - c2;
+			}
+			ans = max(ans, util(arr));
+		}
+		System.out.println(ans);
+		
+	}
+	public static void main(String[] args) {
+		int t = 1;
+		t = sc.nextInt();
+		outer: for (int tt = 0; tt < t; tt++) {
+			solve();
+		}
+	}
+	
+////////////////////////////////////////////////////////////////////////////////////
+////////////////////DO NOT BELOW THIS LINE //////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////////
+	
+	static int max(int a, int b) { return Math.max(a, b);} 
+	static int min(int a, int b) {return Math.min(a, b);}
+	static long max(long a, long b){return Math.max(a, b);}
+	static long min(long a, long b) {return Math.min(a, b);}
+	static void sort(int arr[]) {
+		ArrayList<Integer> a = new ArrayList<Integer>();
+		for(int i: arr) a.add(i);
+		Collections.sort(a);
+		for(int i=0;i<arr.length;i++) arr[i] = a.get(i);
+	}
+	static void sort(long arr[]) {
+		ArrayList<Long> a = new ArrayList<Long>();
+		for(long i: arr) a.add(i);
+		Collections.sort(a);
+		for(int i=0;i<arr.length;i++) arr[i] = a.get(i);
+	}
+	static int abs(int a) {return Math.abs(a);}
+	static long abs(long a) {return Math.abs(a);}
+	static int gcd(int a, int b) {
+		if (b == 0)
+			return a;
+		return gcd(b, a % b);
+	}
+	static long gcd(long a, long b) {
+		if (b == 0)
+			return a;
+		return gcd(b, a % b);
+	}
+	
+	static class FastScanner {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st = new StringTokenizer("""");
+		
+		String next() {
+			while (!st.hasMoreTokens())
+				try {
+					st = new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			return st.nextToken();
+		}
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+		int[] readArray(int n) {
+			int[] a = new int[n];
+			for (int i = 0; i < n; i++)
+				a[i] = nextInt();
+			return a;
+		}
+		long[] readLongArray(int n) {
+			long[] a = new long[n];
+			for (int i = 0; i < n; i++)
+				a[i] = nextLong();
+			return a;
+		}
+		
+		int[][] read2dArray(int n, int m) {
+			int arr[][] = new int[n][m];
+			for (int i = 0; i < n; i++) {
+				for (int j = 0; j < m; j++) {
+					arr[i][j] = nextInt();
+				}
+			}
+			return arr;
+		}
+		
+		ArrayList<Integer> readArrayList(int n) {
+			ArrayList<Integer> arr = new ArrayList<Integer>();
+			for (int i = 0; i < n; i++) {
+				int a = nextInt();
+				arr.add(a);
+			}
+			return arr;
+		}
+		
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+	}
+	
+	static class pair {
+		int fr, sc;
+		
+		pair(int fr, int sc) {
+			this.fr = fr;
+			this.sc = sc;
+		}
+	}
+	
+////////////////////////////////////////////////////////////////////////////////////	
+	
+}
+","import java.util.*;
+import java.io.*;
+public class ProbC {
+
+	public static void main(String[] args) throws IOException {
+		
+		BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st;
+		
+		StringBuilder sb = new StringBuilder();
+		
+		int cases = Integer.parseInt(bf.readLine());
+		
+		for(int caseNum=0; caseNum<cases; caseNum++) {
+			
+			int n = Integer.parseInt(bf.readLine());
+			
+			String[] words = new String[n];
+			
+			for(int i=0; i<n; i++)
+				words[i] = bf.readLine();
+			
+			int[] count = new int[26];
+			
+			for(int i=0; i<n; i++)
+				for(int j=0; j<words[i].length(); j++)
+					count[words[i].charAt(j)-97]++;
+			
+			int maxWords = 0;
+			
+			for(int x=0; x<26; x++) {
+				
+				if(count[x] > 0) {
+					
+					char curChar = (char)(x+97);
+			
+					int[] diff = new int[n];
+					
+					for(int i=0; i<n; i++) {
+						for(int j=0; j<words[i].length(); j++) {
+							if(words[i].charAt(j) == curChar)
+								diff[i]++;
+							else
+								diff[i]--;
+						}
+					}
+					
+					Arrays.sort(diff);
+					
+					int sum = 0;
+					
+					int i = diff.length-1;
+					
+					//System.out.println(Arrays.toString(diff)+"" ""+curChar);
+					
+					for(; i>=0; i--) {
+						sum+=diff[i];
+						if(sum <= 0)
+							break;
+					}
+					
+					maxWords = Math.max(maxWords, n-(i+1));
+				
+				}
+			
+			}
+			
+			sb.append(maxWords+""\n"");
+			
+		}
+		
+		System.out.println(sb);
+		
+		bf.close();
+
+	}
+
+}
+",0
+3368f340,a8f7c8b7,"//package Codeforces;
+
+import java.io.*;
+import java.util.*;
+
+public class Menorah {
+    public static void main(String[] args) throws IOException {
+        Scanner sc = new Scanner(System.in);
+
+        int t = sc.nextInt();
+        StringBuilder sb = new StringBuilder();
+        while (t-->0){
+            int n = sc.nextInt();
+            char[] a = sc.next().toCharArray();
+            char[] b = sc.next().toCharArray();
+
+            int a1=0, b1=0;
+            for(int i=0;i<n;i++){
+                if(a[i]=='1')
+                    a1++;
+                if(b[i]=='1')
+                    b1++;
+            }
+
+            int min = 100000000;
+
+            if(a1==b1){
+                int c = 0;
+                for(int i=0;i<n;i++){
+                    if(a[i]!=b[i])
+                        c++;
+                }
+
+                min = Math.min(min, c);
+            }
+
+            if(b1==(n-a1+1)){
+                int ind = -1;
+                for(int i=0;i<n;i++){
+                    if(a[i]==b[i] && a[i]=='1'){
+                        ind = i;
+                        break;
+                    }
+                }
+
+                int c = 0;
+                for(int i=0;i<n;i++){
+                    if(i==ind)
+                        continue;
+
+                    if(a[i]==b[i])
+                        c++;
+                }
+
+                min = Math.min(min, c + 1);
+            }
+
+            if(min == 100000000)
+                sb.append(""-1\n"");
+            else sb.append(min).append(""\n"");
+        }
+
+        System.out.println(sb);
+
+        sc.close();
+    }
+}
+","
+import java.util.Scanner;
+
+public class Menorah {
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        int t = sc.nextInt();
+        while (t-- > 0) {
+            int n = sc.nextInt();
+            char initial[] = sc.next().toCharArray();
+            char desired[] = sc.next().toCharArray();
+            int lit1 = 0, lit2 = 0;
+            int ans = Integer.MAX_VALUE;
+            for (int i = 0; i < n; i++) {
+                if (initial[i] == '1') {
+                    ++lit1;
+                }
+                if (desired[i] == '1') {
+                    ++lit2;
+                }
+            }
+            if (lit1 == lit2) {
+                int count = 0;
+                for (int i = 0; i < n; i++) {
+                    if (initial[i] != desired[i]) {
+                        ++count;
+                    }
+                }
+                ans = Math.min(count, ans);
+            }
+            if (lit2 == (n - lit1 + 1)) {
+                int count = 0;
+                for (int i = 0; i < n; i++) {
+                    if (initial[i] == desired[i]) {
+                        ++count;
+                    }
+                }
+                ans = Math.min(ans, count);
+            }
+            if (ans == Integer.MAX_VALUE) {
+                System.out.println(-1);
+            } else {
+                System.out.println(ans);
+            }
+        }
+    }
+}",1
+17e67976,656b62de,"import java.util.*;
+public class code
+{
+    int hell(String arr[],int a,int n)
+    {
+        int sum=0;
+        int s=0;
+        int arr1[]=new int[n];
+        int x=0;
+        int y=0;
+        for(int i=0;i<n;i++)
+        {
+            int l=arr[i].length();
+            for(int j=0;j<l;j++)
+            {
+                if(arr[i].charAt(j)==a)
+                    x++;
+                else
+                    y++;
+            }
+            arr1[i]=y-x;
+            y=0;
+            x=0;
+        }
+        Arrays.sort(arr1);
+        for(int i=0;i<n;i++)
+        {
+            s+=arr1[i];
+            if(s<0)
+                sum++;
+            else    
+                break;
+        }
+        return sum;
+    }
+    public static void main(String args[])
+    {
+        code ob=new code();
+        Scanner sc=new Scanner(System.in);
+        int t=sc.nextInt();
+        while(t-->0)
+        {
+            int sum1=0;
+            int sum2=0;
+            int n=sc.nextInt();
+            String arr[]=new String[n];
+            for(int i=0;i<n;i++)
+            {
+                arr[i]=sc.next();
+            }
+            for(int i=97;i<=102;i++)
+            {
+                sum2=ob.hell(arr,i,n);
+                sum1=Math.max(sum2,sum1);
+            }
+            System.out.println(sum1);
+        }
+    }
+}","    //import java.io.IOException;
+
+    import java.io.IOException;
+    import java.io.InputStream;
+    import java.io.PrintWriter;
+    import java.util.InputMismatchException;
+    import java.util.PriorityQueue;
+
+    public class InterestingStory {
+        static InputReader inputReader=new InputReader(System.in);
+        static void solve()
+        {
+            int n=inputReader.nextInt();
+            String arr[]=new String[n];
+            for (int i=0;i<n;i++)
+            {
+                arr[i]=inputReader.readString();
+            }
+            int larr[]=new int[n];
+            for (int i=0;i<n;i++) {
+                larr[i] = arr[i].length();
+            }
+            int freqarr[][]=new int[n][5];
+            for (int i=0;i<n;i++)
+            {
+                freqarr[i]=freq(arr[i],larr[i]);
+            }
+            int max=Integer.MIN_VALUE;
+            for (char c='a';c<='e';c++)
+            {
+                max=Math.max(max,helper(freqarr,larr,n,c));
+            }
+            out.println(max);
+        }
+        static  int helper(int freqarr[][],int larr[],int n,char c)
+        {
+            int sum=0;
+            PriorityQueue<Integer>priorityQueue=new PriorityQueue<>();
+            for (int i=0;i<n;i++)
+            {
+                int score=freqarr[i][c-'a']-(larr[i]-freqarr[i][c-'a']);
+                priorityQueue.add(score);
+                sum+=score;
+            }
+            while (!priorityQueue.isEmpty()&&sum<=0) {
+                sum -= priorityQueue.poll();
+            }
+            return priorityQueue.size();
+        }
+       static int []freq(String str,int len)
+        {
+            int arr[]=new int[5];
+            for (int i=0;i<len;i++)
+            {
+                arr[str.charAt(i)-'a']++;
+            }
+            return arr;
+        }
+        static PrintWriter out=new PrintWriter((System.out));
+        public static void main(String args[])throws IOException
+        {
+            int t=inputReader.nextInt();
+            while(t-->0)
+            {
+                solve();
+            }
+            out.close();
+        }
+        static class InputReader {
+
+            private InputStream stream;
+            private byte[] buf = new byte[8192];
+            private int curChar, snumChars;
+            private SpaceCharFilter filter;
+
+            public InputReader(InputStream stream) {
+                this.stream = stream;
+            }
+
+            public int snext() {
+                if (snumChars == -1)
+                    throw new InputMismatchException();
+                if (curChar >= snumChars) {
+                    curChar = 0;
+                    try {
+                        snumChars = stream.read(buf);
+                    } catch (IOException e) {
+                        throw new InputMismatchException();
+                    }
+                    if (snumChars <= 0)
+                        return -1;
+                }
+                return buf[curChar++];
+            }
+
+            public int nextInt() {
+                int c = snext();
+                while (isSpaceChar(c))
+                    c = snext();
+                int sgn = 1;
+                if (c == '-') {
+                    sgn = -1;
+                    c = snext();
+                }
+                int res = 0;
+                do {
+                    if (c < '0' || c > '9')
+                        throw new InputMismatchException();
+                    res *= 10;
+                    res += c - '0';
+                    c = snext();
+                } while (!isSpaceChar(c));
+                return res * sgn;
+            }
+
+            public long nextLong() {
+                int c = snext();
+                while (isSpaceChar(c))
+                    c = snext();
+                int sgn = 1;
+                if (c == '-') {
+                    sgn = -1;
+                    c = snext();
+                }
+                long res = 0;
+                do {
+                    if (c < '0' || c > '9')
+                        throw new InputMismatchException();
+                    res *= 10;
+                    res += c - '0';
+                    c = snext();
+                } while (!isSpaceChar(c));
+                return res * sgn;
+            }
+
+            public int[] nextIntArray(int n) {
+                int a[] = new int[n];
+                for (int i = 0; i < n; i++)
+                    a[i] = nextInt();
+                return a;
+            }
+
+            public String readString() {
+                int c = snext();
+                while (isSpaceChar(c))
+                    c = snext();
+                StringBuilder res = new StringBuilder();
+                do {
+                    res.appendCodePoint(c);
+                    c = snext();
+                } while (!isSpaceChar(c));
+                return res.toString();
+            }
+
+            public boolean isSpaceChar(int c) {
+                if (filter != null)
+                    return filter.isSpaceChar(c);
+                return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
+            }
+
+            public interface SpaceCharFilter {
+                public boolean isSpaceChar(int ch);
+            }
+        }
+    }
+",0
+722e318f,d9199dfd,"import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.math.BigInteger;
+import java.text.DecimalFormat;
+import java.util.*;
+import java.util.concurrent.ThreadLocalRandom;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+import java.util.stream.LongStream;
+
+public class TaskB {
+
+    static long mod = 1000000007;
+    static FastScanner scanner;
+
+    static final StringBuilder result = new StringBuilder();
+
+    public static void main(String[] args) {
+        // 2 : 1000000000
+        scanner = new FastScanner();
+        int T = scanner.nextInt();
+        for (int t = 0; t < T; t++) {
+            solve(t + 1);
+            result.append(""\n"");
+        }
+        System.out.println(result);
+    }
+
+    static void solve(int t) {
+        int n = scanner.nextInt();
+        int[] a = scanner.nextIntArray(n);
+        String s = scanner.nextToken();
+
+        List<Integer> blue = new ArrayList<>();
+        List<Integer> red = new ArrayList<>();
+        for (int i = 0; i < n; i++) {
+            if (s.charAt(i) == 'B') {
+                blue.add(a[i]);
+            } else {
+                red.add(a[i]);
+            }
+        }
+        Collections.sort(blue);
+        Collections.sort(red);
+        for (int i = 0; i < blue.size(); i++) {
+            if (blue.get(i) < i + 1) {
+                result.append(""NO"");
+                return;
+            }
+        }
+        for (int i = 0; i < red.size(); i++) {
+            if (red.get(i) > i + 1 + blue.size()) {
+                result.append(""NO"");
+                return;
+            }
+        }
+        result.append(""YES"");
+    }
+
+    static class WithIdx implements Comparable<WithIdx> {
+        int val, idx;
+
+        public WithIdx(int val, int idx) {
+            this.val = val;
+            this.idx = idx;
+        }
+
+        @Override
+        public int compareTo(WithIdx o) {
+            if (val == o.val) {
+                return Integer.compare(idx, o.idx);
+            }
+            return Integer.compare(val, o.val);
+        }
+    }
+
+    public static class FastScanner {
+        BufferedReader br;
+        StringTokenizer st;
+
+        public FastScanner() {
+            br = new BufferedReader(new InputStreamReader(System.in));
+        }
+
+        String nextToken() {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    // TODO Auto-generated catch block
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        String nextLine() {
+            try {
+                return br.readLine();
+            } catch (Exception e) {
+                e.printStackTrace();
+                throw new RuntimeException();
+            }
+        }
+
+        int nextInt() {
+            return Integer.parseInt(nextToken());
+        }
+
+        long nextLong() {
+            return Long.parseLong(nextToken());
+        }
+
+        double nextDouble() {
+            return Double.parseDouble(nextToken());
+        }
+
+        int[] nextIntArray(int n) {
+            int[] res = new int[n];
+            for (int i = 0; i < n; i++) res[i] = nextInt();
+            return res;
+        }
+
+        long[] nextLongArray(int n) {
+            long[] res = new long[n];
+            for (int i = 0; i < n; i++) res[i] = nextLong();
+            return res;
+        }
+
+        String[] nextStringArray(int n) {
+            String[] res = new String[n];
+            for (int i = 0; i < n; i++) res[i] = nextToken();
+            return res;
+        }
+    }
+
+    static class PrefixSums {
+        long[] sums;
+
+        public PrefixSums(long[] sums) {
+            this.sums = sums;
+        }
+
+        public long sum(int fromInclusive, int toExclusive) {
+            if (fromInclusive > toExclusive) throw new IllegalArgumentException(""Wrong value"");
+            return sums[toExclusive] - sums[fromInclusive];
+        }
+
+        public static PrefixSums of(int[] ar) {
+            long[] sums = new long[ar.length + 1];
+            for (int i = 1; i <= ar.length; i++) {
+                sums[i] = sums[i - 1] + ar[i - 1];
+            }
+            return new PrefixSums(sums);
+        }
+
+        public static PrefixSums of(long[] ar) {
+            long[] sums = new long[ar.length + 1];
+            for (int i = 1; i <= ar.length; i++) {
+                sums[i] = sums[i - 1] + ar[i - 1];
+            }
+            return new PrefixSums(sums);
+        }
+    }
+
+    static class ADUtils {
+        static void sort(int[] ar) {
+            Random rnd = ThreadLocalRandom.current();
+            for (int i = ar.length - 1; i > 0; i--) {
+                int index = rnd.nextInt(i + 1);
+                // Simple swap
+                int a = ar[index];
+                ar[index] = ar[i];
+                ar[i] = a;
+            }
+            Arrays.sort(ar);
+        }
+
+        static void reverse(int[] arr) {
+            int last = arr.length / 2;
+            for (int i = 0; i < last; i++) {
+                int tmp = arr[i];
+                arr[i] = arr[arr.length - 1 - i];
+                arr[arr.length - 1 - i] = tmp;
+            }
+        }
+
+        static void sort(long[] ar) {
+            Random rnd = ThreadLocalRandom.current();
+            for (int i = ar.length - 1; i > 0; i--) {
+                int index = rnd.nextInt(i + 1);
+                // Simple swap
+                long a = ar[index];
+                ar[index] = ar[i];
+                ar[i] = a;
+            }
+            Arrays.sort(ar);
+        }
+    }
+
+    static class MathUtils {
+        static long[] FIRST_PRIMES = {
+                2, 3, 5, 7, 11, 13, 17, 19, 23, 29,
+                31, 37, 41, 43, 47, 53, 59, 61, 67, 71,
+                73, 79, 83, 89, 97, 101, 103, 107, 109, 113,
+                127, 131, 137, 139, 149, 151, 157, 163, 167, 173,
+                179, 181, 191, 193, 197, 199, 211, 223, 227, 229,
+                233, 239, 241, 251, 257, 263, 269, 271, 277, 281,
+                283, 293, 307, 311, 313, 317, 331, 337, 347, 349,
+                353, 359, 367, 373, 379, 383, 389, 397, 401, 409,
+                419, 421, 431, 433, 439, 443, 449, 457, 461, 463,
+                467, 479, 487, 491, 499, 503, 509, 521, 523, 541,
+                547, 557, 563, 569, 571, 577, 587, 593, 599, 601,
+                607, 613, 617, 619, 631, 641, 643, 647, 653, 659,
+                661, 673, 677, 683, 691, 701, 709, 719, 727, 733,
+                739, 743, 751, 757, 761, 769, 773, 787, 797, 809,
+                811, 821, 823, 827, 829, 839, 853, 857, 859, 863,
+                877, 881, 883, 887, 907, 911, 919, 929, 937, 941,
+                947, 953, 967, 971, 977, 983, 991, 997, 1009, 1013,
+                1019, 1021, 1031, 1033, 1039, 1049, 1051};
+
+        static long[] primes(int to) {
+            long[] all = new long[to + 1];
+            long[] primes = new long[to + 1];
+            all[1] = 1;
+            int primesLength = 0;
+            for (int i = 2; i <= to; i++) {
+                if (all[i] == 0) {
+                    primes[primesLength++] = i;
+                    all[i] = i;
+                }
+                for (int j = 0; j < primesLength && i * primes[j] <= to && all[i] >= primes[j];
+                        j++) {
+                    all[(int) (i * primes[j])] = primes[j];
+                }
+            }
+            return Arrays.copyOf(primes, primesLength);
+        }
+
+        static long modpow(long b, long e, long m) {
+            long result = 1;
+
+            while (e > 0) {
+                if ((e & 1) == 1) {
+                    /* multiply in this bit's contribution while using modulus to keep
+                     * result small */
+                    result = (result * b) % m;
+                }
+                b = (b * b) % m;
+                e >>= 1;
+            }
+
+            return result;
+        }
+
+        static long submod(long x, long y, long m) {
+            return (x - y + m) % m;
+        }
+
+        static long modInverse(long a, long m) {
+            long g = gcdF(a, m);
+            if (g != 1) {
+                throw new IllegalArgumentException(""Inverse doesn't exist"");
+            } else {
+                // If a and m are relatively prime, then modulo
+                // inverse is a^(m-2) mode m
+                return modpow(a, m - 2, m);
+            }
+        }
+
+        static public long gcdF(long a, long b) {
+            while (b != 0) {
+                long na = b;
+                long nb = a % b;
+                a = na;
+                b = nb;
+            }
+            return a;
+        }
+    }
+}
+
+/*
+5
+3 2 3 8 8
+2 8 5 10 1
+
+ */","import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Scanner;
+
+public class Simple{  
+    public static void main(String args[]){  
+        //System.out.println(""Hello Java"");
+        Scanner s = new Scanner(System.in);
+        int t = s.nextInt();
+        while (t>0){
+            
+            int n = s.nextInt();
+            int arr[] = new int[n];
+
+            for(int i=0;i<n;i++){
+                arr[i] = s.nextInt();
+            }
+            String str = s.next();
+
+            //Arrays.sort(arr);
+            ArrayList<Integer> blue = new ArrayList<>();
+            ArrayList<Integer> red = new ArrayList<>();
+            for(int i=0;i<n;i++){
+                if(str.charAt(i)=='R'){
+                    red.add(arr[i]);
+                }
+                else{
+                    blue.add(arr[i]);
+                }
+            }
+            Collections.sort(red);
+            Collections.sort(blue);
+            
+            int start =1;
+
+            boolean bool =true;
+            for(int i=0;i<blue.size();i++){
+                if(blue.get(i)<start){
+                    bool = false;
+                    break;
+                }
+
+                start++;
+            }
+            if(!bool){
+                System.out.println(""NO"");
+            }
+            else{
+                for(int i=0;i<red.size();i++){
+                    if(red.get(i)>start){
+                        bool = false;
+                        break;
+                    }
+                    start++;
+                }
+                if(bool){
+                    System.out.println(""YES"");
+                }
+                else{
+                    System.out.println(""NO"");
+                }
+            }
+            
+            
+
+
+            t--;
+        }
+        s.close();  
+    }
+    
+}  
+",0
+31cdf5fe,f0801d53,"import java.util.Scanner;
+
+public class Main {
+
+    public static void main(String[] args)
+    {
+        Scanner scanner = new Scanner(System.in);
+        int t = scanner.nextInt();
+        while(t-- > 0)
+        {
+            int n = scanner.nextInt();
+            int[] time = new int[n];
+            int[] h = new int[n];
+            for(int i  = 0; i < n; i++)
+            {
+                time[i] = scanner.nextInt();
+            }
+            for(int j = 0; j < n; j++)
+            {
+                h[j] = scanner.nextInt();
+            }
+            long prevMTime = time[n-1];
+            long prevMHealth = h[n-1];
+            long manaRequired = 0;
+            long currMTime = time[n-1];
+            long currMHealth = h[n-1];
+            long spellCastingTime = prevMTime - prevMHealth + 1;
+
+            for(int i = n-2; i >= 0; i--)
+            {
+                currMHealth = h[i];
+                currMTime = time[i];
+                //spellCastingTime = prevMTime - prevMHealth + 1;
+                if(spellCastingTime <= currMTime && currMTime - spellCastingTime + 1 < currMHealth)
+                {
+                    spellCastingTime = currMTime - currMHealth + 1;
+                }
+                else if(spellCastingTime > currMTime)
+                {
+                    long hm = (prevMTime - spellCastingTime) + 1;
+                    manaRequired += (hm * (hm+1)) / 2;
+                    prevMTime =currMTime;
+                    prevMHealth = currMHealth;
+                    spellCastingTime = prevMTime - prevMHealth + 1;
+                }
+            }
+            long hm = (prevMTime - spellCastingTime) + 1;
+            manaRequired += (hm * (hm+1)) / 2;
+            System.out.println(manaRequired);
+
+        }
+    }
+
+}
+","import java.util.*;
+import java.io.*;
+
+public class hmm {
+
+	static Scanner sc = new Scanner(System.in);
+	static PrintWriter pw = new PrintWriter(System.out);
+
+
+	public static void main(String[] args) throws Exception {
+		int t =sc.nextInt();
+		while (t-- > 0) {
+             int n = sc.nextInt();
+             int []k = sc.nextIntArray(n);
+             int h[]=sc.nextIntArray(n);
+     
+             long mana = 0;
+             pair cur = new pair(k[n-1]-h[n-1]+1,k[n-1]);
+             for(int i=n-1;i>=0;i--) {
+            	 int s = k[i];
+            	 int start = s-h[i]+1;
+            	 if(s>=cur.x) {
+            		 cur.x = Math.min(start, cur.x);
+            	 }
+            	 else {
+            		 long x = cur.y - cur.x +1;
+            		 mana += x*(x+1)/2;
+            		 cur.x = start;
+            		 cur.y = s;
+            	 }
+             }
+       
+             long x = cur.y - cur.x +1;
+       
+    		 mana += x*(x+1)/2;
+    		 pw.println(mana);
+             
+           
+		}
+
+		pw.close();
+
+	}
+
+	// -------------- stuff ------------------------------
+	static class pair {
+		int x ;
+		int y;
+	
+		
+		public pair(int n,int c) {
+			x= n;
+			y = c;
+		
+			
+		}
+	
+	
+		
+	}
+
+	static class Scanner {
+		StringTokenizer st;
+		BufferedReader br;
+
+		public Scanner(InputStream s) {
+			br = new BufferedReader(new InputStreamReader(s));
+		}
+
+		public Scanner(FileReader r) {
+			br = new BufferedReader(r);
+		}
+
+		public String next() throws IOException {
+			while (st == null || !st.hasMoreTokens())
+				st = new StringTokenizer(br.readLine());
+			return st.nextToken();
+		}
+
+		public int nextInt() throws IOException {
+			return Integer.parseInt(next());
+		}
+
+		public long nextLong() throws IOException {
+			return Long.parseLong(next());
+		}
+
+		public String nextLine() throws IOException {
+			return br.readLine();
+		}
+
+		public int[] nextIntArray(int n) throws IOException {
+			int[] a = new int[n];
+			for (int i = 0; i < n; i++)
+				a[i] = nextInt();
+			return a;
+		}
+
+	}
+
+}",0
+0c9d4def,d3415fc5,"import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.StringTokenizer;
+
+public class C{
+    private static int maxWords = 0;
+    private static int[][] words;
+    private static int n;
+    private static int[] netwrtchar(int index){
+        ArrayList<Integer> list = new ArrayList<>();
+        for(int i=0; i<n; i++){
+            int sum = 0;
+            for(int j=0; j<words[i].length; j++){
+                if(j==index) continue;
+                sum += words[i][j];
+            }
+            list.add(words[i][index] - sum);
+            // f[i] = words[i][index] - sum;
+        }
+        Collections.sort(list, Collections.reverseOrder());
+        int[] f = new int[list.size()];
+        for(int i=0; i<list.size(); i++){
+            f[i] = list.get(i);
+        }
+        return f;
+    }
+    private static int maxWindow(int[] f){
+        int count = 0, sum = 0;
+        int index = 0;
+        while(index<f.length && sum+f[index]>0){
+            sum += f[index++];
+            count++;
+        }
+        return count;
+    }
+    public static void main(String[] args){
+        FS sc = new FS();
+        PrintWriter pw = new PrintWriter(System.out);
+        int t = sc.nextInt();
+        while(t-->0){
+            n = sc.nextInt();
+            words = new int[n][5];
+            maxWords = 0;
+            for(int i=0; i<n; i++){
+                String s = sc.next();
+                for(int j=0; j<s.length(); j++){
+                    words[i][s.charAt(j)-'a']++;
+                }
+            }
+            int maxWindow = 0;
+            for(int i=0; i<5; i++){
+                int[] f = netwrtchar(i);
+                int current = maxWindow(f);
+                maxWindow = Math.max(maxWindow, current);
+            }
+            System.out.println(maxWindow);
+        }
+        pw.flush();
+        pw.close();
+    }
+
+    static class FS{
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st = new StringTokenizer("""");
+    
+        String next(){
+            while(!st.hasMoreElements()){
+                try{
+                    st = new StringTokenizer(br.readLine());
+                } catch(Exception ignored){
+                }
+            }
+            return st.nextToken();
+        }
+        
+        int[] nextArray(int n){
+            int[] a = new int[n];
+            for(int i = 0; i < n; i++){
+                a[i] = nextInt();
+            }
+            return a;
+        }
+        
+        long[] nextLongArray(int n){
+            long[] a = new long[n];
+            for(int i = 0; i < n; i++){
+                a[i] = nextLong();
+            }
+            return a;
+        }
+        
+        int nextInt(){
+            return Integer.parseInt(next());
+        }
+        
+        long nextLong(){
+            return Long.parseLong(next());
+        }
+        
+        double nextDouble(){
+            return Double.parseDouble(next());
+        }
+    }
+}","import java.io.*;
+import java.util.*;
+
+import static java.lang.Math.max;
+import static java.lang.Math.min;
+
+public class C {
+    Reader source;
+    BufferedReader br;
+    StringTokenizer in;
+    PrintWriter out;
+
+    public String nextToken() throws Exception {
+        while (in == null || !in.hasMoreTokens()) {
+            in = new StringTokenizer(br.readLine());
+        }
+        return in.nextToken();
+    }
+    public int nextInt() throws Exception {
+        return Integer.parseInt(nextToken());
+    }
+    public long nextLong() throws Exception {
+        return Long.parseLong(nextToken());
+    }
+    public double nextDouble() throws Exception {
+        return Double.parseDouble(nextToken());
+    }
+    public void run() throws Exception {
+        source = OJ ? new InputStreamReader(System.in) : new FileReader(""C.in"");
+        br = new BufferedReader(source);
+        out = new PrintWriter(System.out);
+        solve();
+        out.flush();
+    }
+    public void sort(int[] a) {
+        ArrayList<Integer> list = new ArrayList<>();
+        for (int i : a) list.add(i);
+        Collections.sort(list);
+        for (int i = a.length - 1, j = 0; i >= 0; i--, j++)
+            a[j] = list.get(i);
+    }
+    public static void main(String[] args) throws Exception {
+        new C().run();
+    }
+    private boolean OJ = System.getProperty(""ONLINE_JUDGE"") != null;
+
+    public void solve() throws Exception {
+        int t = nextInt();
+        while (t-- > 0) {
+            int n = nextInt();
+            int A[] = new int [n];
+            int B[] = new int [n];
+            int C[] = new int [n];
+            int D[] = new int [n];
+            int E[] = new int [n];
+            for (int i = 0; i < n; i++) {
+                String s = nextToken();
+                int sz = s.length();
+                int a = 0, b = 0, c = 0, d = 0, e = 0;
+                for (int j = 0; j < sz; j++) {
+                    if (s.charAt(j) == 'a') a++;
+                    if (s.charAt(j) == 'b') b++;
+                    if (s.charAt(j) == 'c') c++;
+                    if (s.charAt(j) == 'd') d++;
+                    if (s.charAt(j) == 'e') e++;
+                }
+                A[i] = a - b - c - d - e;
+                B[i] = b - a - c - d - e;
+                C[i] = c - a - b - d - e;
+                D[i] = d - a - b - c - e;
+                E[i] = e - a - b - c - d;
+            }
+            int ans = 0, sum;
+            sum = 0;
+            sort(A);
+            for (int j = 0; j < n; j++) {
+                sum += A[j];
+                if (sum <= 0) {
+                    ans = max(ans, j);
+                    break;
+                }
+            }
+            if (sum > 0) ans = n;
+            sum = 0;
+            sort(B);
+            for (int j = 0; j < n; j++) {
+                sum += B[j];
+                if (sum <= 0) {
+                    ans = max(ans, j);
+                    break;
+                }
+            }
+            if (sum > 0) ans = n;
+            sum = 0;
+            sort(C);
+            for (int j = 0; j < n; j++) {
+                sum += C[j];
+                if (sum <= 0) {
+                    ans = max(ans, j);
+                    break;
+                }
+            }
+            if (sum > 0) ans = n;
+            sum = 0;
+            sort(D);
+            for (int j = 0; j < n; j++) {
+                sum += D[j];
+                if (sum <= 0) {
+                    ans = max(ans, j);
+                    break;
+                }
+            }
+            if (sum > 0) ans = n;
+            sum = 0;
+            sort(E);
+            for (int j = 0; j < n; j++) {
+                sum += E[j];
+                if (sum <= 0) {
+                    ans = max(ans, j);
+                    break;
+                }
+            }
+            if (sum > 0) ans = n;
+            System.out.println(ans);
+        }
+    }
+}",0
+51019113,bf85ab7b,"
+
+import java.io.*;
+import java.math.*;
+import java.util.*;
+
+
+
+public class test {
+	 
+	   static class Pair{ 
+		   long x;
+		   long y;
+		   
+		   Pair(long x,long y){ 
+			   this.x = x;
+			   this.y = y;
+			   
+		   }
+	   }
+	  
+	   static class Compare { 
+		   
+		     void compare(Pair arr[], int n) 
+		    { 
+		        // Comparator to sort the pair according to second element 
+		        Arrays.sort(arr, new Comparator<Pair>() { 
+		            @Override public int compare(Pair p1, Pair p2) 
+		            { 
+		            	if(p1.x!=p2.x) {
+		                return (int)(p1.x - p2.x); 
+		            	}
+		            	else { 
+		            		return (int)(p1.y - p2.y);
+		            	}
+		            } 
+		        }); 
+		  
+//		        for (int i = 0; i < n; i++) { 
+//		            System.out.print(arr[i].x + "" "" + arr[i].y + "" ""); 
+//		        } 
+//		        System.out.println(); 
+		    } 
+		} 
+	 
+	   static class Scanner {
+	        BufferedReader br;
+	        StringTokenizer st;
+	 
+	        public Scanner()
+	        {
+	            br = new BufferedReader(
+	                new InputStreamReader(System.in));
+	        }
+	 
+	        String next()
+	        {
+	            while (st == null || !st.hasMoreElements()) {
+	                try {
+	                    st = new StringTokenizer(br.readLine());
+	                }
+	                catch (IOException e) {
+	                    e.printStackTrace();
+	                }
+	            }
+	            return st.nextToken();
+	        }
+	 
+	        int nextInt() { return Integer.parseInt(next()); }
+	 
+	        long nextLong() { return Long.parseLong(next()); }
+	 
+	        double nextDouble()
+	        {
+	            return Double.parseDouble(next());
+	        }
+	 
+	        String nextLine()
+	        {
+	            String str = """";
+	            try {
+	                str = br.readLine();
+	            }
+	            catch (IOException e) {
+	                e.printStackTrace();
+	            }
+	            return str;
+	        }
+	    }
+	
+	   static void dfs(int cur , int prnt , ArrayList<Integer> graph[],long dp[][],Pair p[]) { 
+		   
+		   for(int i : graph[cur]) { 
+			   
+			   if(i!=prnt) { 
+				   dfs(i,cur,graph,dp,p);
+				   
+				   dp[cur][0] += Math.max(Math.abs(p[cur].x - p[i].x)+ dp[i][0], Math.abs(p[cur].x - p[i].y)+dp[i][1]);
+				   dp[cur][1] += Math.max(Math.abs(p[cur].y -p[i].x) + dp[i][0], Math.abs(p[cur].y - p[i].y)+dp[i][1]);
+			   }
+		   }
+	   }
+	   public static void main(String args[]) throws Exception { 
+		
+		   
+		   Scanner sc = new Scanner();
+		   StringBuffer res = new StringBuffer();
+		   
+		   int tc = sc.nextInt();
+		   
+		   while(tc-->0) { 
+			
+			int n = sc.nextInt();
+			
+			Pair p[] = new Pair[n+1];
+			
+			for(int i=1;i<=n;i++) { 
+				p[i] = new Pair(0,0);
+				p[i].x = sc.nextLong();
+				p[i].y = sc.nextLong();
+			}
+			
+			ArrayList<Integer> graph[] = new ArrayList[n+1];
+			
+			for(int i=0;i<n+1;i++) { 
+				graph[i] = new ArrayList<>();
+			}
+			for(int i=0;i<n-1;i++) { 
+				
+				int u = sc.nextInt();
+				int v = sc.nextInt();
+				
+				graph[u].add(v);
+				graph[v].add(u);
+				
+			}
+			
+			long dp[][] = new long[n+1][2];
+			
+			dfs(1,0,graph,dp,p);
+			
+			System.out.println(Math.max(dp[1][0], dp[1][1]));
+		   }
+			System.out.println(res);
+		   
+	   }
+}  
+
+
+
+
+","
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Scanner;
+import java.io.DataInputStream;
+import java.io.FileInputStream;
+
+import java.io.IOException;
+
+public class ParsasHumongousTree {
+
+    public static void main(String args[]) throws IOException {
+        Reader scan = new Reader();
+        StringBuilder sb = new StringBuilder();
+
+        int t = scan.nextInt();
+        while (t-- > 0) {
+            int n = scan.nextInt();
+            int[] l = new int[n + 1];
+            int[] r = new int[n + 1];
+            for (int i = 1; i <= n; i++) {
+                l[i] = scan.nextInt();
+                r[i] = scan.nextInt();
+            }
+            Graph g = new Graph(n);
+            for (int i = 0; i < n - 1; i++) {
+                g.addEdge(scan.nextInt(), scan.nextInt());
+            }
+            sb.append(g.dfs(l, r) + ""\n"");
+        }
+        System.out.println(sb);
+    }
+}
+
+class Graph {
+
+    ArrayList<Integer>[] node;
+    int n;
+    int c = 0;
+    boolean[] vis;
+
+    Graph(int s) {
+        n = s + 1;
+        vis = new boolean[n + 1];
+        node = new ArrayList[n + 1];
+        for (int i = 0; i < n + 1; i++) {
+            node[i] = new ArrayList<>();
+        }
+    }
+
+    void addEdge(int u, int v) {
+
+        node[u].add(v);
+        node[v].add(u);
+        if (node[u].size() == 1) {
+            c = u;
+        }
+        if (node[v].size() == 1) {
+            c = v;
+        }
+    }
+
+    void cleanVisArray() {
+        for (int i = 0; i < n + 1; i++) {
+            vis[i] = false;
+        }
+    }
+
+    long dfs(int[] l, int[] r) {
+        cleanVisArray();
+
+        long[][] dp = new long[n][2];
+        dfsMain(1, dp, l, r);
+        return Math.max(dp[1][0], dp[1][1]);
+    }
+
+    void dfsMain(int v, long[][] dp, int[] l, int[] r) {
+        vis[v] = true;
+        for (int i : node[v]) {
+            if (!vis[i]) {
+                dfsMain(i, dp, l, r);
+                dp[v][0] += Math.max(Math.abs(l[v] - l[i]) + dp[i][0], Math.abs(l[v] - r[i]) + dp[i][1]);
+                dp[v][1] += Math.max(Math.abs(r[v] - l[i]) + dp[i][0], Math.abs(r[v] - r[i]) + dp[i][1]);
+            }
+        }
+    }
+
+}
+
+class Reader {
+
+    final private int BUFFER_SIZE = 1 << 16;
+    private DataInputStream din;
+    private byte[] buffer;
+    private int bufferPointer, bytesRead;
+
+    public Reader() {
+        din = new DataInputStream(System.in);
+        buffer = new byte[BUFFER_SIZE];
+        bufferPointer = bytesRead = 0;
+    }
+
+    public Reader(String file_name) throws IOException {
+        din = new DataInputStream(new FileInputStream(file_name));
+        buffer = new byte[BUFFER_SIZE];
+        bufferPointer = bytesRead = 0;
+    }
+
+    public String readLine() throws IOException {
+        byte[] buf = new byte[64]; // line length 
+        int cnt = 0, c;
+        while ((c = read()) != -1) {
+            if (c == '\n') {
+                break;
+            }
+            buf[cnt++] = (byte) c;
+        }
+        return new String(buf, 0, cnt);
+    }
+
+    public int nextInt() throws IOException {
+        int ret = 0;
+        byte c = read();
+        while (c <= ' ') {
+            c = read();
+        }
+        boolean neg = (c == '-');
+        if (neg) {
+            c = read();
+        }
+        do {
+            ret = ret * 10 + c - '0';
+        } while ((c = read()) >= '0' && c <= '9');
+
+        if (neg) {
+            return -ret;
+        }
+        return ret;
+    }
+
+    public long nextLong() throws IOException {
+        long ret = 0;
+        byte c = read();
+        while (c <= ' ') {
+            c = read();
+        }
+        boolean neg = (c == '-');
+        if (neg) {
+            c = read();
+        }
+        do {
+            ret = ret * 10 + c - '0';
+        } while ((c = read()) >= '0' && c <= '9');
+        if (neg) {
+            return -ret;
+        }
+        return ret;
+    }
+
+    public double nextDouble() throws IOException {
+        double ret = 0, div = 1;
+        byte c = read();
+        while (c <= ' ') {
+            c = read();
+        }
+        boolean neg = (c == '-');
+        if (neg) {
+            c = read();
+        }
+
+        do {
+            ret = ret * 10 + c - '0';
+        } while ((c = read()) >= '0' && c <= '9');
+
+        if (c == '.') {
+            while ((c = read()) >= '0' && c <= '9') {
+                ret += (c - '0') / (div *= 10);
+            }
+        }
+
+        if (neg) {
+            return -ret;
+        }
+        return ret;
+    }
+
+    private void fillBuffer() throws IOException {
+        bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
+        if (bytesRead == -1) {
+            buffer[0] = -1;
+        }
+    }
+
+    private byte read() throws IOException {
+        if (bufferPointer == bytesRead) {
+            fillBuffer();
+        }
+        return buffer[bufferPointer++];
+    }
+
+    public void close() throws IOException {
+        if (din == null) {
+            return;
+        }
+        din.close();
+    }
+}
+",0
+c287ea9d,d2901569,"import java.util.*;
+import java.io.*;
+
+public class monstersandspells {
+	public static void main(String args[]) throws IOException {
+		FastScanner in = new FastScanner(System.in);
+		PrintWriter out = new PrintWriter(System.out);
+		/*
+1
+5
+1 5 8 9 10
+1 2 6 1 2
+		 */
+		int t = in.nextInt();
+		
+		for ( ; t > 0; t--) {
+			
+			int n = in.nextInt();
+			
+			long[] times = new long[n];
+			long[] health = new long[n];
+			for (int i = 0; i < n; i++)
+				times[i] = in.nextLong();
+			for (int i = 0; i < n; i++)
+				health[i] = in.nextLong();
+			
+			long small = 0;
+			long prev = 0;
+			long lastDamage = 0;
+			
+			for (int i = 0; i < n; i++) {
+				long diff = times[i] - prev;
+				boolean use = true;
+				long delta = 0;
+				//System.out.println(i + "" "" + times[i] + "" "" + diff);
+				if (diff >= health[i]) {
+					delta += health[i];
+					long curr = health[i];
+					long lastTime = times[i];
+					for (int j = i + 1; j < n; j++) {
+						long increase = times[j] - lastTime;
+						//long power = damageOverTime(increase + curr, curr + 1);
+						if (curr + increase >= health[j]) {
+							curr += increase;
+							lastTime = times[j];
+						}
+						else {
+							delta += (health[j] - (curr + increase));
+							curr = health[j];
+							lastTime = times[j];
+						}
+					}
+					if (delta <= diff) {
+						use = true;
+					}
+					else
+						use = false;
+				}
+				else
+					use = false;
+				
+				if (use) {
+					//System.out.println(damageOverTime(health[i], 1));
+					small += damageOverTime(delta, 1);
+					lastDamage = delta;
+				}
+				else {
+					small += damageOverTime((times[i] - prev) + lastDamage, lastDamage + 1);
+					lastDamage+=(times[i] - prev);
+				}
+				// System.out.println(use + "" "" + delta + "" "" + lastDamage + "" "" + small);
+				prev = times[i];
+			}
+			
+			out.println(small);
+		}
+		
+		out.close();
+	}
+	
+	public static long damageOverTime(long endPower, long startPower) {
+		return triangleSum(endPower) - triangleSum(startPower - 1);
+	}
+	
+	public static long triangleSum(long a) {
+		return a * (a + 1) / 2;
+	}
+	
+	static class FastScanner {
+		BufferedReader br;
+		StringTokenizer st;
+
+		public FastScanner(InputStream i) {
+			br = new BufferedReader(new InputStreamReader(i));
+			st = new StringTokenizer("""");
+		}
+
+		public String next() throws IOException {
+			if (st.hasMoreTokens())
+				return st.nextToken();
+			else
+				st = new StringTokenizer(br.readLine());
+			return next();
+		}
+
+		public int nextInt() throws IOException {
+			return Integer.parseInt(next());
+		}
+
+		public long nextLong() throws IOException {
+			return Long.parseLong(next());
+		}
+
+		public double nextDouble() throws IOException {
+			return Double.parseDouble(next());
+		}
+	}
+}
+","import java.util.*;
+import java.util.Scanner;
+
+
+public class Solution {
+	static int mod=1000000007;;
+	
+//	 
+	public static void main(String[] args) {
+		// TODO Auto-generated method stub
+//		System.out.println();
+
+		Scanner sc=new Scanner(System.in);
+		int tt=sc.nextInt();
+//		
+//		
+		while(tt-->0){
+				int n=sc.nextInt();
+			
+				int k[]=new int[n];
+				int h[]=new int[n];
+				
+				for(int i=0;i<n;i++) {
+					k[i]=sc.nextInt();
+				}
+				for(int i=0;i<n;i++) {
+					h[i]=sc.nextInt();
+				}
+				long ans=0;
+				int start=k[0]-h[0]-1;
+				int end=k[0];
+				int last=0;
+				for(int j=0;j<n;j++) {
+					 start=k[j]-h[j]+1;
+					 end=k[j];
+					 last=j;
+				for(int i=j+1;i<n;i++) {
+					int temp=k[i]-h[i]+1;
+					
+					if(temp<=end) {
+						start=Math.min(start, temp);
+						end=Math.max(end, k[i]);
+						last=i;
+					}
+					
+					
+					
+				}
+				j=last;
+				
+				long va=end-start+1;
+				
+				ans+=(va*(va+1))/2;
+				
+				}
+				System.out.println(ans);
+				
+			
+		}
+	}
+		
+		
+	
+		
+		
+	
+	
+	
+
+
+}
+",0
+ae4d5b49,f665e87b,"import java.io.*;
+import java.util.*;
+
+public class Main {
+    public static void main(String[] args) throws IOException{
+        //BufferedReader f = new BufferedReader(new FileReader(""uva.in""));
+        BufferedReader f = new BufferedReader(new InputStreamReader(System.in));
+        PrintWriter out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
+        int t = Integer.parseInt(f.readLine());
+        while(t-- > 0) {
+            int n = Integer.parseInt(f.readLine());
+            int[][] occ = new int[n][6];
+            for(int i = 0; i < n; i++) {
+                char[] temp = f.readLine().toCharArray();
+                for(char j: temp) {
+                    occ[i][j-'a']++;
+                }
+                occ[i][5] = occ[i][0]+occ[i][1]+occ[i][2]+occ[i][3]+occ[i][4];
+            }
+            int max = 0;
+            for(int i = 0; i < 5; i++) {
+                int[] temp = new int[n];
+                for(int j = 0; j < n; j++) {
+                    temp[j] = occ[j][i]-(occ[j][5]-occ[j][i]);
+                }
+                Arrays.sort(temp);
+                int j;
+                int cur = 0;
+                for(j = n-1; j >= 0; j--) {
+                    if(cur+temp[j] <= 0) {
+                        break;
+                    }
+                    cur += temp[j];
+                }
+                max = Math.max(max, n-j-1);
+            }
+            out.println(max);
+        }
+        f.close();
+        out.close();
+    }
+}","import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.StringTokenizer;
+import java.util.TreeMap;
+
+
+public class C_CF {
+
+    public static void main(String[] args) {
+        FastScanner57 fs = new FastScanner57();
+        PrintWriter pw = new PrintWriter(System.out);
+        int t = fs.ni();
+        //int t = 1;
+        for (int tc = 0; tc < t; tc++) {
+            int n = fs.ni();
+            String[] s = new String[n];
+            for (int i = 0; i < n; i++) {
+                s[i] = fs.next();
+            }
+            int res = c(0,s);
+            for (int i = 1; i < 5; i++) {
+                res = Math.max(res,c(i,s));
+            }
+            pw.println(res);
+        }
+        
+        pw.close();
+
+    }
+    public static int c(int l, String[] s) {
+        List<Integer> list = new ArrayList();
+        for (int i = 0; i < s.length; i++) {
+            String t = s[i];
+            int ct = 0;
+            for (int j = 0; j < t.length(); j++) {
+                if (t.charAt(j)-'a'==l) {
+                    ct++;
+                } else {
+                    ct--;
+                }
+            }
+            list.add(ct);
+        }
+        Collections.sort(list);
+        Collections.reverse(list);
+        int sum = 0;
+        for (int i = 0; i < s.length; i++) {
+            sum += list.get(i);
+            if (sum<=0) return i;
+        }
+        return list.size();
+    }
+    public static int gcd(int n1, int n2) {
+        if (n2 == 0) {
+            return n1;
+        }
+        return gcd(n2, n1 % n2);
+    }
+
+    static class BIT18 {
+
+        int[] bit;
+
+        public BIT18(int size) {
+            bit = new int[size];
+        }
+
+        public void update(int ind, int delta) {
+            while (ind < bit.length) {
+                bit[ind] += delta;
+                ind = ind + (ind & (-1 * ind));
+            }
+        }
+
+        public int sum(int ind) {
+            int s = 0;
+            while (ind > 0) {
+                s += bit[ind];
+                ind = ind - (ind & (-1 * ind));
+            }
+            return s;
+        }
+
+        public int query(int l, int r) {
+            return sum(r) - sum(l);
+        }
+    }
+
+    // 0 -> left was chosen
+    // 1 -> right was chosen
+
+    public static void sort(long[] a) {
+        List<Long> list = new ArrayList();
+        for (int i = 0; i < a.length; i++) {
+            list.add(a[i]);
+        }
+        Collections.sort(list);
+        for (int i = 0; i < a.length; i++) {
+            a[i] = list.get(i);
+        }
+    }
+
+    public static long gcd(long n1, long n2) {
+        if (n2 == 0) {
+            return n1;
+        }
+        return gcd(n2, n1 % n2);
+    }
+
+}
+
+class UnionFind16 {
+
+    int[] id;
+
+    public UnionFind16(int size) {
+        id = new int[size];
+        for (int i = 0; i < size; i++) {
+            id[i] = i;
+        }
+    }
+
+    public int find(int p) {
+        int root = p;
+        while (root != id[root]) {
+            root = id[root];
+        }
+        while (p != root) {
+            int next = id[p];
+            id[p] = root;
+            p = next;
+        }
+        return root;
+    }
+
+    public void union(int p, int q) {
+        int a = find(p), b = find(q);
+        if (a == b) {
+            return;
+        }
+        id[b] = a;
+    }
+}
+
+class FastScanner57 {
+
+    BufferedReader br;
+    StringTokenizer st;
+
+    public FastScanner57() {
+        br = new BufferedReader(new InputStreamReader(System.in), 32768);
+        st = null;
+    }
+
+    String next() {
+        while (st == null || !st.hasMoreElements()) {
+            try {
+                st = new StringTokenizer(br.readLine());
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+        }
+        return st.nextToken();
+    }
+
+    int ni() {
+        return Integer.parseInt(next());
+    }
+
+    int[] intArray(int N) {
+        int[] ret = new int[N];
+        for (int i = 0; i < N; i++) {
+            ret[i] = ni();
+        }
+        return ret;
+    }
+
+    long nl() {
+        return Long.parseLong(next());
+    }
+
+    long[] longArray(int N) {
+        long[] ret = new long[N];
+        for (int i = 0; i < N; i++) {
+            ret[i] = nl();
+        }
+        return ret;
+    }
+
+    double nd() {
+        return Double.parseDouble(next());
+    }
+
+    String nextLine() {
+        String str = """";
+        try {
+            str = br.readLine();
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        return str;
+    }
+}
+",0
+3e191f3b,595f5d6c,"import java.util.*;
+import java.io.*;
+import java.util.Arrays;
+
+public class codeforces {
+	static int[]av;
+	static int[]oc;
+	static int[][]memo;
+	static int n;
+	public static void main(String[] args) throws Exception {
+//		int t=sc.nextInt();
+//		while(t-->0) {
+			n=sc.nextInt();
+			int[]a=new int[n];
+			int avs=0;
+			for (int i = 0; i < a.length; i++) {
+				a[i]=sc.nextInt();
+				if(a[i]==0)avs++;
+			}
+			av=new int[avs];
+			oc=new int[n-avs];
+			for (int i = 0,c=0,j=0; i < a.length; i++) {
+				if(a[i]==1) {
+					oc[c++]=i;
+				}else {
+					av[j++]=i;
+				}
+			}
+			memo=new int[oc.length][av.length];
+			for(int[]e:memo)Arrays.fill(e, -1);
+			pw.println(dp(0,0));
+			
+//		}
+		pw.close();
+	}
+	
+	public static int dp(int i,int j) {
+		if(j==av.length) {
+			
+			return i!=oc.length?(int)1e9:0;
+		}
+		if(i==oc.length) {
+			return 0;
+		}
+		if(memo[i][j]!=-1) {
+			return memo[i][j];
+		}
+		int take=dp(i+1,j+1)+Math.abs(av[j]-oc[i]);
+		int leave=dp(i,j+1);
+		return memo[i][j]=Math.min(take, leave);
+	}
+	
+	
+	
+	public static boolean isSorted(int[]a) {
+		for (int i = 0; i < a.length-1; i++) {
+			if(a[i]>a[i+1])return false;
+		}
+		return true;
+	}
+	
+	public static boolean isPrime(int n)
+    {
+ 
+        // Check if number is less than
+        // equal to 1
+        if (n <= 1)
+            return false;
+ 
+        // Check if number is 2
+        else if (n == 2)
+            return true;
+ 
+        // Check if n is a multiple of 2
+        else if (n % 2 == 0)
+            return false;
+ 
+        // If not, then just check the odds
+        for (int i = 3; i <= Math.sqrt(n); i += 2)
+        {
+            if (n % i == 0)
+                return false;
+        }
+        return true;
+    }
+	public static long power(long x,long k) {
+		long res=1;
+		long mod=((int)1e9)+7;
+		for (int i = 0; i < k; i++) {
+			res*=x;
+			res=res%mod;
+		}
+		return res;
+	}
+	public static int whichPower(int x) {
+		int res=0;
+		for (int j = 0; j < 31; j++) {
+			if((1<<j&x)!=0) {
+				res=j;
+				break;
+			}
+		}
+		return res;
+	}
+
+	public static long evaln(String x,int n) {
+		long res=0;
+		for (int i = 0; i < x.length(); i++) {
+			res+=Long.parseLong(x.charAt(x.length()-1-i)+"""")*Math.pow(n, i);
+		}
+		return res;
+	}
+	static void merge(int[] arr,int b,int m,int e) {
+		int len1=m-b+1,len2=e-m;
+		int[] l=new int[len1];
+		int[] r=new int[len2];
+		for(int i=0;i<len1;i++)l[i]=arr[b+i];
+		for(int i=0;i<len2;i++)r[i]=arr[m+1+i];
+		int i=0,j=0,k=b;
+		while(i<len1 && j<len2) {
+			if(l[i]<r[j])arr[k++]=l[i++];
+			else arr[k++]=r[j++];
+		}
+		while(i<len1)arr[k++]=l[i++];
+		while(j<len2)arr[k++]=r[j++];
+		return;
+	}
+	static void mergesort(int[] arr,int b,int e) {
+		if(b<e) {
+			int m=b+(e-b)/2;
+			mergesort(arr,b,m);
+			mergesort(arr,m+1,e);
+			merge(arr,b,m,e);
+		}
+		return;
+		
+	}
+	static long mergen(int[] arr,int b,int m,int e) {
+		int len1=m-b+1,len2=e-m;
+		int[] l=new int[len1];
+		int[] r=new int[len2];
+		for(int i=0;i<len1;i++)l[i]=arr[b+i];
+		for(int i=0;i<len2;i++)r[i]=arr[m+1+i];
+		int i=0,j=0,k=b;
+		long c=0;
+		while(i<len1 && j<len2) {
+			if(l[i]<r[j])arr[k++]=l[i++];
+			else {
+				arr[k++]=r[j++];
+				c=c+(long)(len1-i);
+			}
+		}
+		while(i<len1)arr[k++]=l[i++];
+		while(j<len2)arr[k++]=r[j++];
+		return c;
+	}
+	static long mergesortn(int[] arr,int b,int e) {
+		long c=0;
+		if(b<e) {
+			int m=b+(e-b)/2;
+			c=c+(long)mergesortn(arr,b,m);
+			c=c+(long)mergesortn(arr,m+1,e);
+			c=c+(long)mergen(arr,b,m,e);
+		}
+		return c;
+		
+	}
+	public static long fac(int n) {
+		if(n==0)return 1;
+		return n*fac(n-1);
+	}
+	public static long gcd(long a, long b)
+    {
+      if (b == 0)
+        return a;
+      return gcd(b, a % b);
+    }
+     
+	public static long summ(long x) {
+		long sum=0;
+		while(x!=0) {
+			sum+=x%10;
+			x=x/10;
+		}
+		return sum;
+				
+	}
+	
+	public static void sort2darray(Integer[][]a){
+		Arrays.sort(a,Comparator.<Integer[]>comparingInt(x -> x[0]).thenComparingInt(x -> x[1]));
+
+	}
+	static class Scanner {
+		StringTokenizer st;
+		BufferedReader br;
+		public Scanner(InputStream s) {
+			br = new BufferedReader(new InputStreamReader(s));
+		}
+		public Scanner(String file) throws FileNotFoundException {
+			br = new BufferedReader(new FileReader(file));
+		}
+
+		public String next() throws IOException {
+			while (st == null || !st.hasMoreTokens())
+				st = new StringTokenizer(br.readLine());
+			return st.nextToken();
+		}
+		
+		public int nextInt() throws IOException {
+			return Integer.parseInt(next());
+		}
+		public long nextLong() throws IOException {
+			return Long.parseLong(next());
+		}
+		public String nextLine() throws IOException {
+			return br.readLine();
+		}
+		public double nextDouble() throws IOException {
+			return Double.parseDouble(next());
+		}
+		public boolean ready() throws IOException {
+			return br.ready();
+		}
+		public int[] nextArrint(int size) throws IOException {
+			int[] a=new int[size];
+			for (int i = 0; i < a.length; i++) {
+				a[i]=sc.nextInt();
+			}
+			return a;
+		}
+		public long[] nextArrlong(int size) throws IOException {
+			long[] a=new long[size];
+			for (int i = 0; i < a.length; i++) {
+				a[i]=sc.nextLong();
+			}
+			return a;
+		}
+		public int[][] next2dArrint(int rows,int columns) throws IOException{
+			int[][]a=new int[rows][columns];
+			for (int i = 0; i < rows; i++) {
+				for (int j = 0; j < columns; j++) {
+					a[i][j]=sc.nextInt();
+				}
+			}
+			return a;
+		}
+		public long[][] next2dArrlong(int rows,int columns) throws IOException{
+			long[][]a=new long[rows][columns];
+			for (int i = 0; i < rows; i++) {
+				for (int j = 0; j < columns; j++) {
+					a[i][j]=sc.nextLong();
+				}
+			}
+			return a;
+		}
+	}
+	static Scanner sc=new Scanner(System.in);
+	static PrintWriter pw=new PrintWriter(System.out);
+}
+
+","import java.math.BigInteger;
+//import static java.lang.Math.max;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.PriorityQueue;
+import java.util.Queue;
+import java.util.Random;
+import java.util.Stack;
+import java.util.StringTokenizer;
+import java.util.TreeMap;
+import java.util.Vector;
+
+import java.util.Scanner;
+
+public class ahh {
+//trihund
+	static Scanner scn = new Scanner(System.in);
+	static boolean vis[][];
+
+	static class FastReader {
+		BufferedReader br;
+		StringTokenizer st;
+
+		public FastReader() {
+			br = new BufferedReader(new InputStreamReader(System.in));
+		}
+
+		String next() {
+			while (st == null || !st.hasMoreElements()) {
+				try {
+					st = new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			}
+			return st.nextToken();
+		}
+
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+	
+
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+
+		double nextDouble() {
+			return Double.parseDouble(next());
+		}
+
+		String nextLine() {
+			String str = """";
+			try {
+				str = br.readLine();
+			} catch (IOException e) {
+				e.printStackTrace();
+			}
+			return str;
+		}
+	}
+
+	static FastReader s = new FastReader();
+	static int MOD = 1000000007;
+
+	public static void main(String[] args) {
+		
+		int n=scn.nextInt(),count=0;
+		int arr[]=new int[n];
+		for(int i=0;i<n;i++)
+		{
+			arr[i]=scn.nextInt();
+		}
+		ArrayList<Integer>zer=new ArrayList<Integer>(),one=new ArrayList<Integer>();
+		for(int i=0;i<n;i++)
+		{
+			if(arr[i]==0)
+				zer.add(i);
+			else
+				one.add(i);
+		}
+		count=one.size();
+		long memo[][]=new long[one.size()+1][zer.size()+1];
+		for(int i=0;i<=one.size();i++)
+		{
+			for(int j=0;j<=zer.size();j++)
+				memo[i][j]=-1;
+		}
+		System.out.println(arm(one, zer, 0, 0, count,memo));
+				
+		
+	}
+
+	public static long arm(ArrayList<Integer>one,ArrayList<Integer>zer,int i,int j,int count,long memo[][])
+	{	if(count==0)
+		return 0;
+		if(i==one.size()||j==zer.size())
+			return Integer.MAX_VALUE;
+		
+		if(memo[i][j]!=-1)
+			return memo[i][j];
+		
+		long a=Integer.MAX_VALUE,b=Integer.MAX_VALUE;
+		a=arm(one, zer, i+1, j+1,count-1,memo)+Math.abs(one.get(i)-zer.get(j));
+		b=arm(one, zer, i, j+1,count,memo);
+		memo[i][j]=Math.min(a, b);
+		return Math.min(a, b);
+	}
+	public static void fac(int n) {
+		BigInteger b = new BigInteger(""1"");
+		for (int i = 1; i <= n; i++) {
+			b = b.multiply(BigInteger.valueOf(i));
+		}
+		System.out.println(b);
+
+	}
+
+	static void ruffleSort(long[] a) {
+		int n = a.length;
+		Random r = new Random();
+		for (int i = 0; i < a.length; i++) {
+			int oi = r.nextInt(n);
+			long temp = a[i];
+			a[i] = a[oi];
+			a[oi] = temp;
+		}
+		Arrays.sort(a);
+	}
+
+	public static int gcd(int a, int b) {
+		if (a == 0)
+			return b;
+		return gcd(b % a, a);
+	}
+
+}
+
+class pm {
+	int ini, fin;
+
+	pm(int a, int b) {
+		this.ini = a;
+		this.fin = b;
+	}
+
+}
+
+class surt implements Comparator<pm> {
+
+	@Override
+	public int compare(pm o1, pm o2) {
+		// TODO Auto-generated method stub
+		int a = o1.ini - o2.ini, b = o1.fin - o2.fin;
+		if (a < 0)
+			return -1;
+		if (a == 0) {
+			if (b < 0)
+				return -1;
+			else
+				return 1;
+		} else
+			return 1;
+	}
+
+}
+
+class pair {
+	int x, y;
+
+	pair(int a, int b) {
+		this.x = a;
+		this.y = b;
+	}
+
+	public int hashCode() {
+		return x * 31 + y * 31;
+	}
+
+	public boolean equals(Object other) {
+		if (this == other)
+			return true;
+
+		if (other instanceof pair) {
+			pair pt = (pair) other;
+
+			return pt.x == this.x && pt.y == this.y;
+		} else
+			return false;
+	}
+
+}
+
+class sort implements Comparator<pair> {
+
+	@Override
+	public int compare(pair o1, pair o2) {
+		// TODO Auto-generated method stub
+		long a = o1.x - o2.x, b = o1.y - o2.y;
+		if (b < 0)
+			return -1;
+		else if (a == 0) {
+			if (a < 0)
+				return -1;
+			else
+				return 1;
+		} else
+			return 1;
+
+	}
+
+}",0
+1adac634,ad4c7a20,"import java.io.*;
+import java.util.*;
+
+
+public class Main {
+    static int i, j, k, n, m, t, y, x, sum = 0;
+    static long mod = 998244353;
+    static FastScanner fs = new FastScanner();
+    static PrintWriter out = new PrintWriter(System.out);
+    static String str;
+    static long ans;
+
+    public static void main(String[] args) {
+
+        t = fs.nextInt();
+
+        while (t-- > 0) {
+
+            n = fs.nextInt();
+
+            int [] k = fs.readArray(n);
+
+            int [] h = fs.readArray(n);
+
+            List<Pair> arr = new ArrayList<>();
+
+            for(i=0;i<n;i++){
+                int a = k[i]-h[i]+1;
+
+                arr.add(new Pair(a,k[i]));
+            }
+
+            Collections.sort(arr);
+
+            ans=0;
+
+            List<Pair> comp = new ArrayList<>();
+            int temp = arr.get(0).x;
+            int tempy = arr.get(0).y;
+            for(i=1;i<n;i++){
+
+                if(arr.get(i).x > tempy){
+                    comp.add(new Pair(temp, tempy));
+                    temp = arr.get(i).x;
+                    tempy = arr.get(i).y;
+                }
+
+                else tempy = Math.max(tempy, arr.get(i).y);
+            }
+
+            comp.add(new Pair(temp, tempy));
+
+
+            for(i=0;i<comp.size();i++){
+
+                long a = comp.get(i).y - comp.get(i).x +1 ;
+
+                ans+=(((a)*(a+1))/2);
+            }
+
+            out.println(ans);
+
+
+        }
+
+        out.close();
+    }
+
+   /*static long nck(int n , int k){
+        long a = fact[n];
+        long b = modInv(fact[k]);
+        b*= modInv(fact[n-k]);
+        b%=mod;
+
+        return (a*b)%mod;
+    }
+
+   static void populateFact(){
+        fact[0]=1;
+
+        fact[1] = 1;
+
+        for(i=2;i<300005;i++){
+            fact[i]=i*fact[i-1];
+            fact[i]%=mod;
+        }
+    }
+    */
+
+
+    static long gcd(long a, long b) {
+        if (b == 0)
+            return a;
+        return gcd(b, a % b);
+    }
+
+    static long exp(long base, long pow) {
+        if (pow == 0) return 1;
+        long half = exp(base, pow / 2);
+        if (pow % 2 == 0) return mul(half, half);
+        return mul(half, mul(half, base));
+    }
+
+    static long mul(long a, long b) {
+        return ((a % mod) * (b % mod)) % mod;
+    }
+
+    static long add(long a, long b) {
+        return ((a % mod) + (b % mod)) % mod;
+    }
+
+    static long modInv(long x) {
+        return exp(x, mod - 2);
+    }
+
+    static void ruffleSort(int[] a) {
+        //ruffle
+        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;
+        }
+
+        //then sort
+        Arrays.sort(a);
+    }
+
+    static void ruffleSort(long[] a) {
+        //ruffle
+        int n = a.length;
+        Random r = new Random();
+        for (int i = 0; i < a.length; i++) {
+            int oi = r.nextInt(n);
+            long temp = a[i];
+            a[i] = a[oi];
+            a[oi] = temp;
+        }
+
+        Arrays.sort(a);
+    }
+
+    static class FastScanner {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st = new StringTokenizer("""");
+
+        String next() {
+            while (!st.hasMoreTokens())
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        int[] readArray(int n) {
+            int[] a = new int[n];
+            for (int i = 0; i < n; i++) a[i] = nextInt();
+            return a;
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+    }
+
+
+    static class Pair implements Comparable<Pair> {
+        public int x, y;
+
+        Pair(int x, int y) {
+            this.x = x;
+            this.y = y;
+        }
+
+        @Override
+        public int compareTo(Pair o) {
+
+            if (x == o.x)
+                return Integer.compare(y, o.y);
+
+            return Integer.compare(x, o.x);
+        }
+
+
+    }
+
+}","import java.io.*;
+import java.util.*;
+
+
+public class Practice
+{
+//	static final long mod=7420738134811L;
+	static int mod=1000000007;
+	static final int size=501;
+	static FastReader sc=new FastReader(System.in);
+//	static Reader sc=new Reader();
+//	static Scanner sc=new Scanner(System.in);
+	static  PrintWriter out=new PrintWriter(System.out);
+	static long[] factorialNumInverse;
+	static long[] naturalNumInverse;	
+	static int[] sp;
+	static long[] fact;
+	static ArrayList<Integer> pr;
+	public static void main(String[] args) throws IOException, CloneNotSupportedException
+	{
+//		System.setIn(new FileInputStream(""input.txt""));
+//		System.setOut(new PrintStream(""output.txt""));
+//		factorial(mod);
+//		InverseofNumber(mod);
+//		InverseofFactorial(mod);
+//		make_seive();
+		int t=1;
+		t=sc.nextInt();
+		for(int i=1;i<=t;i++)
+			solve(i);
+		out.close();
+		out.flush();
+//		System.out.flush();
+//		System.exit(0);
+	}
+	
+	static void solve(int CASENO) throws IOException, CloneNotSupportedException
+	{
+		int n=sc.nextInt();
+		int k[]=new int[n];
+		int h[]=new int[n];
+		for(int i=0;i<n;i++)
+			k[i]=sc.nextInt();
+		for(int i=0;i<n;i++)
+			h[i]=sc.nextInt();
+		ArrayList<Pair> interval=new ArrayList<Pair>();
+		ArrayList<Pair> act=new ArrayList<Pair>();
+		for(int i=0;i<n;i++)
+			interval.add(new Pair(k[i]-h[i]+1,k[i]));
+		Collections.sort(interval);
+//		out.println(interval);
+		act.add(interval.get(0).clone());
+		for(int i=1;i<n;i++)
+		{
+			Pair p=act.get(act.size()-1);
+			if(p.y<interval.get(i).x)
+				act.add(interval.get(i).clone());
+			else
+				p.y=Math.max(p.y, interval.get(i).y);
+		}
+//		out.println(act);
+		long mana=0;
+		for(Pair p: act)
+		{
+			long x=p.y-p.x+1;
+			mana+=(x*(x+1))/2;
+		}
+		out.println(mana);
+	}
+	static class Pair implements Cloneable, Comparable<Pair>
+	{
+		int x,y;
+		Pair(int a,int b)
+		{
+			this.x=a;
+			this.y=b;
+		}
+		@Override
+		public boolean equals(Object obj) 
+		{
+			if(obj instanceof  Pair)
+			{
+				Pair p=(Pair)obj;
+				return p.x==this.x && p.y==this.y;
+			}
+			return false;
+		}
+		@Override
+		public int hashCode() 
+		{
+			return Math.abs(x)+500*Math.abs(y);
+		}
+		@Override
+		public String toString() 
+		{
+			return ""(""+x+"" ""+y+"")"";
+		}
+		@Override
+		protected Pair clone() throws CloneNotSupportedException {
+			return new Pair(this.x,this.y);
+		}
+		@Override
+		public int compareTo(Pair a) 
+		{
+			long t=(this.x-a.x);
+			if(t!=0)
+				return t>0?1:-1;
+			else
+				return (int)(this.y-a.y);
+		}
+		public void swap()
+		{
+			this.y=this.y+this.x;
+			this.x=this.y-this.x;
+			this.y=this.y-this.x;			
+		}
+	}
+	static class Tuple implements Cloneable, Comparable<Tuple>
+	{
+		int x,y,z;
+		Tuple(int a,int b,int c)
+		{
+			this.x=a;
+			this.y=b;
+			this.z=c;
+		}
+		public boolean equals(Object obj) 
+		{
+			if(obj instanceof  Tuple)
+			{
+				Tuple p=(Tuple)obj;
+				return p.x==this.x && p.y==this.y && p.z==this.z;
+			}
+			return false;
+		}
+		@Override
+		public int hashCode() 
+		{
+			return (this.x+501*this.y);
+		}
+		@Override
+		public String toString() 
+		{
+			return ""(""+x+"",""+y+"",""+z+"")"";
+		}
+		@Override
+		protected Tuple clone() throws CloneNotSupportedException {
+			return new Tuple(this.x,this.y,this.z);
+		}
+		@Override
+		public int compareTo(Tuple a) 
+		{
+			int x=this.z-a.z;
+			if(x!=0)
+				return x;
+			int X= this.x-a.x;
+			if(X!=0)
+				return X;
+			return a.y-this.y;
+		}
+	}
+	static void arraySort(int arr[])
+	{
+		ArrayList<Integer> a=new ArrayList<Integer>();
+		for (int i = 0; i < arr.length; i++) {
+			a.add(arr[i]);
+		}
+		Collections.sort(a,Comparator.reverseOrder());
+		for (int i = 0; i < arr.length; i++) {
+			arr[i]=a.get(i);
+		}
+	}
+	static void arraySort(long arr[])
+	{
+		ArrayList<Long> a=new ArrayList<Long>();
+		for (int i = 0; i < arr.length; i++) {
+			a.add(arr[i]);
+		}
+		Collections.sort(a);
+		for (int i = 0; i < arr.length; i++) {
+			arr[i]=a.get(i);
+		}
+	}
+	static HashSet<Integer> primeFactors(int n)
+	{
+		HashSet<Integer> ans=new HashSet<Integer>();
+		if(n%2==0)
+		{
+			ans.add(2);
+			while((n&1)==0)
+				n=n>>1;
+		}
+		for(int i=3;i*i<=n;i+=2)
+		{
+			if(n%i==0)
+			{
+				ans.add(i);
+				while(n%i==0)
+					n=n/i;
+			}
+		}
+		if(n!=1)
+			ans.add(n);
+		return ans;
+	}
+	static void make_seive()
+	{
+		sp=new int[size];
+		pr=new ArrayList<Integer>();
+		for (int i=2; i<size; ++i) {
+		    if (sp[i] == 0) {
+		        sp[i] = i;
+		        pr.add(i);
+		    }
+		    for (int j=0; j<(int)pr.size() && pr.get(j)<=sp[i] && i*pr.get(j)<size; ++j)
+		        sp[i * pr.get(j)] = pr.get(j);
+		}
+	}
+	public static void InverseofNumber(int p)
+	{
+		naturalNumInverse=new long[size];
+	    naturalNumInverse[0] = naturalNumInverse[1] = 1;
+	    for(int i = 2; i < size; i++)
+	        naturalNumInverse[i] = naturalNumInverse[p % i] * (long)(p - p / i) % p;
+	}
+	// Function to precompute inverse of factorials
+	public static void InverseofFactorial(int p)
+	{
+		factorialNumInverse=new long[size];
+	    factorialNumInverse[0] = factorialNumInverse[1] = 1;
+	    // pre-compute inverse of natural numbers
+	    for(int i = 2; i < size; i++)
+	        factorialNumInverse[i] = (naturalNumInverse[i] * factorialNumInverse[i - 1]) % p;
+	}
+	// Function to calculate factorial of 1 to 200001
+	public static void factorial(int p)
+	{
+		fact=new long[size];
+	    fact[0] = 1;
+	    for(int i = 1; i < size; i++)
+	        fact[i] = (fact[i - 1] * (long)i) % p;
+	}
+	 
+	// Function to return nCr % p in O(1) time
+	public static long Binomial(int N, int R)
+	{
+		if(R<0)
+			return 1;
+	    // n C r = n!*inverse(r!)*inverse((n-r)!)
+	    long ans = ((fact[N] * factorialNumInverse[R]) % mod * factorialNumInverse[N - R]) % mod;
+	    return ans;
+	}
+	static int findXOR(int x)	//from 0 to x
+	{
+		if(x<0)
+			return 0;
+		if(x%4==0)
+			return x;
+		if(x%4==1)
+			return 1;
+		if(x%4==2)
+			return x+1;
+		return 0;
+	}
+	static boolean isPrime(long x)
+	{
+		if(x==1)
+			return false;
+		if(x<=3)
+			return true;
+		if(x%2==0 || x%3==0)
+			return false;
+		for(int i=5;i<=Math.sqrt(x);i+=2)
+			if(x%i==0)
+				return false;
+		return true;
+	}
+	static long gcd(long a,long b)
+	{
+		return (b==0)?a:gcd(b,a%b);
+	}
+	static int gcd(int a,int b)
+	{
+		return (b==0)?a:gcd(b,a%b);
+	}
+	static class Node
+	{
+		int vertex,dis;
+		HashSet<Node> adj;
+		Node(int ver)
+		{
+			vertex=ver;
+			dis=-1;
+			adj=new HashSet<Node>();
+		}
+		@Override
+		public String toString() 
+		{
+			return vertex+"" "";
+		}
+	}
+	static class Edge
+	{
+		Node to;
+		int cost;
+		Edge(Node t,int c)
+		{
+			this.to=t;
+			this.cost=c;
+		}
+		@Override
+		public String toString() {
+			return ""(""+to.vertex+"",""+cost+"") "";
+		}
+	}
+	static long power(long x, long y)
+	  {
+		if(x<=0)
+			return 1;
+	    long res = 1; 
+	    x = x % mod; 
+	    if (x == 0)
+	      return 0; 
+	    while (y > 0)
+	    {
+	    	if ((y & 1) != 0)
+	    		res = (res * x) % mod;
+	    	
+	    	y = y >> 1; // y = y/2
+	    	x = (x * x) % mod;
+	    }
+	    return res%mod;
+	  }
+	static long binomialCoeff(long n, long k)
+    {
+		if(n<k)
+			return 0;
+        long res = 1;
+        // Since C(n, k) = C(n, n-k)
+        if (k > n - k)
+            k = n - k;
+ 
+        // Calculate value of
+        // [n * (n-1) *---* (n-k+1)] / [k * (k-1) *----* 1]
+        for (long i = 0; i < k; ++i) {
+            res *= (n - i);
+            res /= (i + 1);
+        }
+ 
+        return res;
+    }
+	static class FastReader
+	{
+        byte[] buf = new byte[2048];
+        int index, total;
+        InputStream in;
+ 
+        FastReader(InputStream is) 
+        {
+            in = is;
+        }
+ 
+        int scan() throws IOException 
+        {
+            if (index >= total) {
+                index = 0;
+                total = in.read(buf);
+                if (total <= 0) {
+                    return -1;
+                }
+            }
+            return buf[index++];
+        }
+ 
+        String next() throws IOException 
+        {
+            int c;
+            for (c = scan(); c <= 32; c = scan());
+            StringBuilder sb = new StringBuilder();
+            for (; c > 32; c = scan()) {
+                sb.append((char) c);
+            }
+            return sb.toString();
+        }
+ 
+        int nextInt() throws IOException 
+        {
+            int c, val = 0;
+            for (c = scan(); c <= 32; c = scan());
+            boolean neg = c == '-';
+            if (c == '-' || c == '+') {
+                c = scan();
+            }
+            for (; c >= '0' && c <= '9'; c = scan()) {
+                val = (val << 3) + (val << 1) + (c & 15);
+            }
+            return neg ? -val : val;
+        }
+ 
+        long nextLong() throws IOException 
+        {
+            int c;
+            long val = 0;
+            for (c = scan(); c <= 32; c = scan());
+            boolean neg = c == '-';
+            if (c == '-' || c == '+') {
+                c = scan();
+            }
+            for (; c >= '0' && c <= '9'; c = scan()) {
+                val = (val << 3) + (val << 1) + (c & 15);
+            }
+            return neg ? -val : val;
+        }
+    }
+	static class Reader 
+	{
+        final private int BUFFER_SIZE = 1 << 16;
+        private DataInputStream din;
+        private byte[] buffer;
+        private int bufferPointer, bytesRead;
+ 
+        public Reader()
+        {
+            din = new DataInputStream(System.in);
+            buffer = new byte[BUFFER_SIZE];
+            bufferPointer = bytesRead = 0;
+        }
+ 
+        public Reader(String file_name) throws IOException
+        {
+            din = new DataInputStream(
+                new FileInputStream(file_name));
+            buffer = new byte[BUFFER_SIZE];
+            bufferPointer = bytesRead = 0;
+        }
+ 
+        public String readLine() throws IOException
+        {
+            byte[] buf = new byte[64]; // line length
+            int cnt = 0, c;
+            while ((c = read()) != -1) {
+                if (c == '\n') {
+                    if (cnt != 0) {
+                        break;
+                    }
+                    else {
+                        continue;
+                    }
+                }
+                buf[cnt++] = (byte)c;
+            }
+            return new String(buf, 0, cnt);
+        }
+ 
+        public int nextInt() throws IOException
+        {
+            int ret = 0;
+            byte c = read();
+            while (c <= ' ') {
+                c = read();
+            }
+            boolean neg = (c == '-');
+            if (neg)
+                c = read();
+            do {
+                ret = ret * 10 + c - '0';
+            } while ((c = read()) >= '0' && c <= '9');
+ 
+            if (neg)
+                return -ret;
+            return ret;
+        }
+ 
+        public long nextLong() throws IOException
+        {
+            long ret = 0;
+            byte c = read();
+            while (c <= ' ')
+                c = read();
+            boolean neg = (c == '-');
+            if (neg)
+                c = read();
+            do {
+                ret = ret * 10 + c - '0';
+            } while ((c = read()) >= '0' && c <= '9');
+            if (neg)
+                return -ret;
+            return ret;
+        }
+ 
+        public double nextDouble() throws IOException
+        {
+            double ret = 0, div = 1;
+            byte c = read();
+            while (c <= ' ')
+                c = read();
+            boolean neg = (c == '-');
+            if (neg)
+                c = read();
+ 
+            do {
+                ret = ret * 10 + c - '0';
+            } while ((c = read()) >= '0' && c <= '9');
+ 
+            if (c == '.') {
+                while ((c = read()) >= '0' && c <= '9') {
+                    ret += (c - '0') / (div *= 10);
+                }
+            }
+ 
+            if (neg)
+                return -ret;
+            return ret;
+        }
+ 
+        private void fillBuffer() throws IOException
+        {
+            bytesRead = din.read(buffer, bufferPointer = 0,
+                                 BUFFER_SIZE);
+            if (bytesRead == -1)
+                buffer[0] = -1;
+        }
+ 
+        private byte read() throws IOException
+        {
+            if (bufferPointer == bytesRead)
+                fillBuffer();
+            return buffer[bufferPointer++];
+        }
+ 
+        public void close() throws IOException
+        {
+            if (din == null)
+                return;
+            din.close();
+        }
+        public void printarray(int arr[])
+        {
+        	for (int i = 0; i < arr.length; i++)
+				System.out.print(arr[i]+"" "");
+        	System.out.println();
+        }
+    }
+}
+
+
+
+
+
+
+
+",0
+63bfa731,949502c2,"
+import java.util.*;
+import java.io.*;
+
+public class D {
+    static ArrayList<Integer> adj[] = new ArrayList[(int)1e5+7];
+    static int diameter = 0;
+    static int[] depth = new int[(int)1e5 + 7];
+    public static void main(String[] args) {
+        FastReader in = new FastReader();
+        int t = in.nextInt();
+        while(t-- > 0){
+            int n = in.nextInt();
+            int a = in.nextInt(), b = in.nextInt(), da = in.nextInt(), db = in.nextInt();
+            for(int i = 1; i <= n; i++){
+                adj[i] = new ArrayList<>();
+            }
+            for(int i = 1; i <=n; i++){
+                adj[i].clear();
+            }
+            for(int i = 0; i < n- 1; i++){
+                int u = in.nextInt();
+                int v = in.nextInt();
+                adj[u].add(v);
+                adj[v].add(u);
+            }
+            diameter = 0;
+            depth[a] = 0;
+            dfs(a, -1);
+            System.out.println(2 * da >= Math.min(diameter, db) || depth[b] <= da ? ""Alice"" : ""Bob"");
+        }
+    }
+    static int dfs(int node, int parent){
+        int len = 0;
+        for(int x : adj[node]){
+            if(x != parent){
+                depth[x] = depth[node] + 1;
+                int cur = 1 + dfs(x, node);
+                diameter = Math.max(diameter, cur + len);
+                len = Math.max(len, cur);
+//                System.out.print(""x "" + x + "" node "" + node + "" par "" + parent);
+//                System.out.println("" cur "" + cur + "" len "" + len + "" diam "" + diameter);
+            }
+        }
+        return len;
+    }
+    static long getDigitSum(long n)
+    {
+        long sum = 0;
+
+        while (n > 0)
+        {
+            sum = sum + n % 10;
+            n = n/10;
+        }
+
+        return sum;
+    }
+
+    static class FastReader
+    {
+        BufferedReader br;
+        StringTokenizer st;
+
+        public FastReader()
+        {
+            br = new BufferedReader(new
+                    InputStreamReader(System.in));
+        }
+
+        String next()
+        {
+            while (st == null || !st.hasMoreElements())
+            {
+                try
+                {
+                    st = new StringTokenizer(br.readLine());
+                }
+                catch (IOException e)
+                {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt()
+        {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong()
+        {
+            return Long.parseLong(next());
+        }
+
+        double nextDouble()
+        {
+            return Double.parseDouble(next());
+        }
+
+        String nextLine()
+        {
+            String str = """";
+            try
+            {
+                str = br.readLine();
+            }
+            catch (IOException e)
+            {
+                e.printStackTrace();
+            }
+            return str;
+        }
+        int[] readArray(int n){
+            int[] a = new int[n];
+            for(int i = 0; i < n; i++){
+                a[i] = nextInt();
+            }
+            return a;
+        }
+    }
+}
+","import static java.lang.Math.max;
+import static java.lang.Math.min;
+import static java.lang.Math.abs;
+import static java.lang.System.out;
+import java.util.*;
+import java.io.*;
+import java.math.*;
+
+public class Template {
+
+	static int mod = 1000000007;
+
+	public static void main(String[] args) {
+		FastScanner sc = new FastScanner();
+		int yo = sc.nextInt();
+		while (yo-- > 0) {
+			int n = sc.nextInt();
+            int a = sc.nextInt()-1;
+            int b = sc.nextInt()-1;
+            int da = sc.nextInt();
+            int db = sc.nextInt();
+            
+            List<List<Integer>> list = new ArrayList<>();
+            for(int i = 0; i < n; i++) list.add(new ArrayList<>());
+            
+            for(int i = 0; i < n-1; i++){
+                int x = sc.nextInt()-1;
+                int y = sc.nextInt()-1;
+                list.get(x).add(y);
+                list.get(y).add(x);
+            }
+            
+            for(int i = 0; i <= n; i++) depth[i] = 0;
+            diam = 0;
+            dfs(a,-1,list);
+            
+            if(2 * da >= min(diam, db) || depth[b] <= da){
+                out.println(""Alice"");
+            }
+            else {
+                out.println(""Bob"");
+            }
+            
+		}
+	}
+    
+    static int[] depth = new int[200001];
+    static int diam = 0;
+    static int dfs(int x, int p, List<List<Integer>> list) {
+        int len = 0;
+        List<Integer> ne = list.get(x);
+        for(int y : ne) {
+            if(y != p) {
+                depth[y] = depth[x] + 1;
+                int cur = 1 + dfs(y, x,list);
+                diam = max(diam, cur + len);
+                len = max(len, cur);
+            }
+        }
+        return len;
+    }
+   
+
+	public static class Pair {
+		int x;
+		int y;
+
+		public Pair(int x, int y) {
+			this.x = x;
+			this.y = y;
+		}
+	}
+
+	public static void sort(int[] arr) {
+		ArrayList<Integer> ls = new ArrayList<Integer>();
+		for (int x : arr)
+			ls.add(x);
+		Collections.sort(ls);
+		for (int i = 0; i < arr.length; i++)
+			arr[i] = ls.get(i);
+	}
+
+	public static long gcd(long a, long b) {
+		if (b == 0)
+			return a;
+		return gcd(b, a % b);
+	}
+
+	static boolean[] sieve(int N) {
+		boolean[] sieve = new boolean[N + 1];
+		for (int i = 2; i <= N; i++)
+			sieve[i] = true;
+
+		for (int i = 2; i <= N; i++) {
+			if (sieve[i]) {
+				for (int j = 2 * i; j <= N; j += i) {
+					sieve[j] = false;
+				}
+			}
+		}
+		return sieve;
+	}
+
+	public static long power(long x, long y, long p) {
+		long res = 1L;
+		x = x % p;
+		while (y > 0) {
+			if ((y & 1) == 1)
+				res = (res * x) % p;
+			y >>= 1;
+			x = (x * x) % p;
+		}
+		return res;
+	}
+
+	public static void print(int[] arr) {
+		//for debugging only
+		for (int x : arr)
+			out.print(x + "" "");
+		out.println();
+	}
+
+	static class FastScanner {
+		private int BS = 1 << 16;
+		private char NC = (char) 0;
+		private byte[] buf = new byte[BS];
+		private int bId = 0, size = 0;
+		private char c = NC;
+		private double cnt = 1;
+		private BufferedInputStream in;
+
+		public FastScanner() {
+			in = new BufferedInputStream(System.in, BS);
+		}
+
+		public FastScanner(String s) {
+			try {
+				in = new BufferedInputStream(new FileInputStream(new File(s)), BS);
+			} catch (Exception e) {
+				in = new BufferedInputStream(System.in, BS);
+			}
+		}
+
+		private char getChar() {
+			while (bId == size) {
+				try {
+					size = in.read(buf);
+				} catch (Exception e) {
+					return NC;
+				}
+				if (size == -1)
+					return NC;
+				bId = 0;
+			}
+			return (char) buf[bId++];
+		}
+
+		public int nextInt() {
+			return (int) nextLong();
+		}
+
+		public int[] readInts(int N) {
+			int[] res = new int[N];
+			for (int i = 0; i < N; i++) {
+				res[i] = (int) nextLong();
+			}
+			return res;
+		}
+
+		public long[] readLongs(int N) {
+			long[] res = new long[N];
+			for (int i = 0; i < N; i++) {
+				res[i] = nextLong();
+			}
+			return res;
+		}
+
+		public long nextLong() {
+			cnt = 1;
+			boolean neg = false;
+			if (c == NC)
+				c = getChar();
+			for (; (c < '0' || c > '9'); c = getChar()) {
+				if (c == '-')
+					neg = true;
+			}
+			long res = 0;
+			for (; c >= '0' && c <= '9'; c = getChar()) {
+				res = (res << 3) + (res << 1) + c - '0';
+				cnt *= 10;
+			}
+			return neg ? -res : res;
+		}
+
+		public double nextDouble() {
+			double cur = nextLong();
+			return c != '.' ? cur : cur + nextLong() / cnt;
+		}
+
+		public double[] readDoubles(int N) {
+			double[] res = new double[N];
+			for (int i = 0; i < N; i++) {
+				res[i] = nextDouble();
+			}
+			return res;
+		}
+
+		public String next() {
+			StringBuilder res = new StringBuilder();
+			while (c <= 32)
+				c = getChar();
+			while (c > 32) {
+				res.append(c);
+				c = getChar();
+			}
+			return res.toString();
+		}
+
+		public String nextLine() {
+			StringBuilder res = new StringBuilder();
+			while (c <= 32)
+				c = getChar();
+			while (c != '\n') {
+				res.append(c);
+				c = getChar();
+			}
+			return res.toString();
+		}
+
+		public boolean hasNext() {
+			if (c > 32)
+				return true;
+			while (true) {
+				c = getChar();
+				if (c == NC)
+					return false;
+				else if (c > 32)
+					return true;
+			}
+		}
+	}
+
+	//	For Input.txt and Output.txt	
+	//	FileInputStream in = new FileInputStream(""input.txt"");
+	//	FileOutputStream out = new FileOutputStream(""output.txt"");
+	//	PrintWriter pw = new PrintWriter(out);
+	//	Scanner sc = new Scanner(in);
+}",1
+3951966f,9bc690ef,"
+import java.io.DataInputStream;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+
+public class Armchairs {
+    static  ArrayList<Integer> f;
+    static ArrayList<Integer> u;
+    static int dp[][];
+    static int fun(int i, int j){
+        if(i == f.size()) return 0;
+        if(j == u.size()) return 99999999;
+        if(dp[i][j] != -1) return dp[i][j];
+        int ans1 = fun(i, j+1);
+        int ans2 = fun(i+1, j+1) + Math.abs(f.get(i)-u.get(j));
+        return dp[i][j] = Math.min(ans1, ans2);
+    }
+    private static int solve(int n, int a[]) {
+        for (int i = 0; i < n; i++) {
+            if (a[i]==0)
+                u.add(i);
+            else
+                f.add(i);
+        }
+
+        return fun(0,0);
+    }
+
+    public static void main(String[] args)
+            throws IOException {
+        Scanner s = new Scanner();
+        int t = 1;
+        StringBuilder ans = new StringBuilder();
+        int count = 0;
+        while (t-- > 0) {
+            int n = s.nextInt();
+            int a[] = new int[n];
+            dp=new int[n][n];
+            for (int i = 0; i < n; i++) {
+                a[i]=s.nextInt();
+            }
+            f=new ArrayList<>();
+            u=new ArrayList<>();
+            for( int i=0; i<n; i++) Arrays.fill(dp[i],-1);
+
+            ans.append(solve(n, a)).append(""\n"");
+        }
+        System.out.println(ans.toString());
+    }
+
+    static class Scanner {
+        final private int BUFFER_SIZE = 1 << 16;
+        private DataInputStream din;
+        private byte[] buffer;
+        private int bufferPointer, bytesRead;
+
+        public Scanner() {
+            din = new DataInputStream(System.in);
+            buffer = new byte[BUFFER_SIZE];
+            bufferPointer = bytesRead = 0;
+        }
+
+        public Scanner(String file_name) throws IOException {
+            din = new DataInputStream(
+                    new FileInputStream(file_name));
+            buffer = new byte[BUFFER_SIZE];
+            bufferPointer = bytesRead = 0;
+        }
+
+        public String readLine() throws IOException {
+            byte[] buf = new byte[64]; // line length
+            int cnt = 0, c;
+            while ((c = read()) != -1) {
+                if (c == '\n') {
+                    if (cnt != 0) {
+                        break;
+                    } else {
+                        continue;
+                    }
+                }
+                buf[cnt++] = (byte) c;
+            }
+            return new String(buf, 0, cnt);
+        }
+
+        public int nextInt() throws IOException {
+            int ret = 0;
+            byte c = read();
+            while (c <= ' ') {
+                c = read();
+            }
+            boolean neg = (c == '-');
+            if (neg)
+                c = read();
+            do {
+                ret = ret * 10 + c - '0';
+            } while ((c = read()) >= '0' && c <= '9');
+
+            if (neg)
+                return -ret;
+            return ret;
+        }
+
+        public long nextLong() throws IOException {
+            long ret = 0;
+            byte c = read();
+            while (c <= ' ')
+                c = read();
+            boolean neg = (c == '-');
+            if (neg)
+                c = read();
+            do {
+                ret = ret * 10 + c - '0';
+            } while ((c = read()) >= '0' && c <= '9');
+            if (neg)
+                return -ret;
+            return ret;
+        }
+
+        public double nextDouble() throws IOException {
+            double ret = 0, div = 1;
+            byte c = read();
+            while (c <= ' ')
+                c = read();
+            boolean neg = (c == '-');
+            if (neg)
+                c = read();
+
+            do {
+                ret = ret * 10 + c - '0';
+            } while ((c = read()) >= '0' && c <= '9');
+
+            if (c == '.') {
+                while ((c = read()) >= '0' && c <= '9') {
+                    ret += (c - '0') / (div *= 10);
+                }
+            }
+
+            if (neg)
+                return -ret;
+            return ret;
+        }
+
+        private void fillBuffer() throws IOException {
+            bytesRead = din.read(buffer, bufferPointer = 0,
+                    BUFFER_SIZE);
+            if (bytesRead == -1)
+                buffer[0] = -1;
+        }
+
+        private byte read() throws IOException {
+            if (bufferPointer == bytesRead)
+                fillBuffer();
+            return buffer[bufferPointer++];
+        }
+
+        public void close() throws IOException {
+            if (din == null)
+                return;
+            din.close();
+        }
+    }
+
+    public static long norm(long a, long MOD) {
+        return ((a % MOD) + MOD) % MOD;
+    }
+
+    public static long msub(long a, long b, long MOD) {
+        return norm(norm(a, MOD) - norm(b, MOD), MOD);
+
+    }
+
+    public static long madd(long a, long b, long MOD) {
+        return norm(norm(a, MOD) + norm(b, MOD), MOD);
+
+    }
+
+    public static long mMul(long a, long b, long MOD) {
+        return norm(norm(a, MOD) * norm(b, MOD), MOD);
+
+
+    }
+
+    public static long mDiv(long a, long b, long MOD) {
+        return norm(norm(a, MOD) / norm(b, MOD), MOD);
+    }
+}
+","//package Div_2B_Problems;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.Arrays;
+import java.util.Random;
+import java.util.StringTokenizer;
+import java.util.ArrayList;
+public class Armchairs {
+	static ArrayList<Integer> one;
+	static ArrayList<Integer> zero;
+	public static void main(String args[]) {
+		FastScanner fs=new FastScanner();
+		int n=fs.nextInt();
+		int []arr=new int[n];
+		one=new ArrayList<>();
+		zero=new ArrayList<>();
+		for(int i=0;i<arr.length;i++) {
+			arr[i]=fs.nextInt();
+			if(arr[i]==1)
+				one.add(i);
+			else zero.add(i);
+		}
+		int [][]dp=new int[arr.length][arr.length];
+		for(int i=0;i<arr.length;i++)
+			Arrays.fill(dp[i], -1);
+		System.out.println(dfs(dp,0,0));
+	}
+	public static int dfs(int [][]dp,int i,int j) {
+		//System.out.println(i+""  ""+j);
+		if(i>=one.size())
+			return 0;
+		if(j>=zero.size())
+			return (int)(1e9);
+		if(dp[i][j]!=-1)
+			return dp[i][j];
+		dp[i][j]=Math.min(Math.abs(one.get(i)-zero.get(j))+dfs(dp,i+1,j+1), dfs(dp,i,j+1));
+		return dp[i][j];
+	}
+	private static int[] readArray(int n) {
+		// TODO Auto-generated method stub
+		return null;
+	}
+
+static final Random random=new Random();
+	
+	static void ruffleSort(int[] a) {
+		int n=a.length;//shuffle, then sort 
+		for (int i=0; i<n; i++) {
+			int oi=random.nextInt(n), temp=a[oi];
+			a[oi]=a[i]; a[i]=temp;
+		}
+		Arrays.sort(a);
+	}
+	static class FastScanner {
+		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st=new StringTokenizer("""");
+		String next() {
+			while (!st.hasMoreTokens())
+				try {
+					st=new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			return st.nextToken();
+		}
+		
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+		int[] readArray(int n) {
+			int[] a=new int[n];
+			for (int i=0; i<n; i++) a[i]=nextInt();
+			return a;
+		}
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+}
+}
+",0
+5b9a0551,db1ef8b3,"import java.io.*;
+import java.lang.reflect.Array;
+import java.util.*;
+public class Main {
+
+    public static void main(String[] args) {
+        FastScanner in=new FastScanner();
+        PrintWriter out=new PrintWriter(System.out);
+        int t=in.nextInt();
+        while(t-->0)
+        solve(in,out);
+        out.close();
+    }
+    static void solve(FastScanner in,PrintWriter out){
+        int n=in.nextInt();
+        long a[]=new long[n];
+        for (int i = 0; i < n; i++) {
+            a[i]=in.nextLong();
+        }
+        long odd=Integer.MAX_VALUE,even=Integer.MAX_VALUE;
+        even=a[0];
+        long sum=a[0];
+        long ans=Long.MAX_VALUE;
+        for (int i = 1; i < n; i++) {
+            if(i%2==0) {
+                ans=Math.min(ans,(n-i/2)*a[i] + odd*(n-i/2) +sum);
+                even=Math.min(even,a[i]);
+            } else {
+                ans=Math.min(ans,(n-i/2)*a[i] + even*(n-i/2-1) +sum);
+                odd=Math.min(odd,a[i]);
+            }
+            sum+=a[i];
+        }
+        out.println(ans);
+    }
+
+    static class pair<U extends Comparable<U>, V extends Comparable<V>> implements Comparable<pair<U, V>> {
+        public U x;
+        public V y;
+
+        public pair(U x, V y) {
+            this.x = x;
+            this.y = y;
+        }
+
+        public int compareTo(pair<U, V> other) {
+            int i = x.compareTo(other.x);
+            if (i != 0) return i;
+            return y.compareTo(other.y);
+        }
+
+        public String toString() {
+            return x.toString() + "" "" + y.toString();
+        }
+
+        public boolean equals(Object obj) {
+            if (this.getClass() != obj.getClass()) return false;
+            pair<U, V> other = (pair<U, V>) obj;
+            return x.equals(other.x) && y.equals(other.y);
+        }
+
+        public int hashCode() {
+            return 31 * x.hashCode() + y.hashCode();
+        }
+
+    }
+
+    static void sort(int[] a) {
+        ArrayList<Integer> l=new ArrayList<>();
+        for (int i:a) l.add(i);
+        Collections.sort(l);
+        for (int i=0; i<a.length; i++) a[i]=l.get(i);
+    }
+
+    static class FastScanner {
+        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st=new StringTokenizer("""");
+        String next() {
+            while (!st.hasMoreTokens())
+                try {
+                    st=new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+        int[] readArray(int n) {
+            int[] a=new int[n];
+            for (int i=0; i<n; i++) a[i]=nextInt();
+            return a;
+        }
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+    }
+}
+","import java.util.*;
+import java.io.*;
+import java.math.*;
+
+/**
+ *
+ * @Har_Har_Mahadev
+ */
+
+public class C {
+
+	private static long INF = 2000000000000000000L, M = 1000000007, MM = 998244353;
+	private static int N = 0;
+
+	public static void process() throws IOException {
+
+		int n = sc.nextInt();
+		PriorityQueue<Integer> odd = new PriorityQueue<Integer>();
+		PriorityQueue<Integer> even = new PriorityQueue<Integer>();
+		int arr[] = sc.readArray(n);
+		long min = INF;
+		long sumOdd = 0;
+		long sumEven = 0;
+		for (int i = 0; i < n; i++) {
+			int x = arr[i];
+			if (i % 2 == 0) {
+				even.add(x);
+				sumEven += x;
+			} else {
+				odd.add(x);
+				sumOdd += x;
+			}
+			if (i > 0) {
+				long ans = 0;
+				ans += 1l * even.peek() * (n - (even.size()));
+				ans += 1l * odd.peek() * (n - (odd.size()));
+				ans += sumOdd + sumEven;
+				min = Math.min(ans, min);
+			}
+		}
+		System.out.println(min);
+	}
+
+	//=============================================================================
+	//--------------------------The End---------------------------------
+	//=============================================================================
+
+	static FastScanner sc;
+	static PrintWriter out;
+
+	public static void main(String[] args) throws IOException {
+		boolean oj = true;
+		if (oj) {
+			sc = new FastScanner();
+			out = new PrintWriter(System.out);
+		} else {
+			sc = new FastScanner(100);
+			out = new PrintWriter(""output.txt"");
+		}
+		int t = 1;
+		t = sc.nextInt();
+		while (t-- > 0) {
+			process();
+		}
+		out.flush();
+		out.close();
+	}
+
+	static class Pair implements Comparable<Pair> {
+		int x, y;
+
+		Pair(int x, int y) {
+			this.x = x;
+			this.y = y;
+		}
+
+		@Override
+		public int compareTo(Pair o) {
+			return Integer.compare(this.x, o.x);
+		}
+
+		//		 @Override
+		//		    public boolean equals(Object o) {
+		//		        if (this == o) return true;
+		//		        if (!(o instanceof Pair)) return false;
+		//		        Pair key = (Pair) o;
+		//		        return x == key.x && y == key.y;
+		//		    }
+		//		 
+		//		    @Override
+		//		    public int hashCode() {
+		//		        int result = x;
+		//		        result = 31 * result + y;
+		//		        return result;
+		//		    }
+	}
+
+	/////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+	static void println(Object o) {
+		out.println(o);
+	}
+
+	static void println() {
+		out.println();
+	}
+
+	static void print(Object o) {
+		out.print(o);
+	}
+
+	static void pflush(Object o) {
+		out.println(o);
+		out.flush();
+	}
+
+	static int ceil(int x, int y) {
+		return (x % y == 0 ? x / y : (x / y + 1));
+	}
+
+	static long ceil(long x, long y) {
+		return (x % y == 0 ? x / y : (x / y + 1));
+	}
+
+	static int max(int x, int y) {
+		return Math.max(x, y);
+	}
+
+	static int min(int x, int y) {
+		return Math.min(x, y);
+	}
+
+	static int abs(int x) {
+		return Math.abs(x);
+	}
+
+	static long abs(long x) {
+		return Math.abs(x);
+	}
+
+	static int log2(int N) {
+		int result = (int) (Math.log(N) / Math.log(2));
+		return result;
+	}
+
+	static long max(long x, long y) {
+		return Math.max(x, y);
+	}
+
+	static long min(long x, long y) {
+		return Math.min(x, y);
+	}
+
+	public static int gcd(int a, int b) {
+		BigInteger b1 = BigInteger.valueOf(a);
+		BigInteger b2 = BigInteger.valueOf(b);
+		BigInteger gcd = b1.gcd(b2);
+		return gcd.intValue();
+	}
+
+	public static long gcd(long a, long b) {
+		BigInteger b1 = BigInteger.valueOf(a);
+		BigInteger b2 = BigInteger.valueOf(b);
+		BigInteger gcd = b1.gcd(b2);
+		return gcd.longValue();
+	}
+
+	public static long lcm(long a, long b) {
+		return (a * b) / gcd(a, b);
+	}
+
+	public static int lcm(int a, int b) {
+		return (a * b) / gcd(a, b);
+	}
+
+	public static int lower_bound(int[] arr, int x) {
+		int low = 0, high = arr.length, mid = -1;
+
+		while (low < high) {
+			mid = (low + high) / 2;
+
+			if (arr[mid] >= x)
+				high = mid;
+			else
+				low = mid + 1;
+		}
+
+		return low;
+	}
+
+	public static int upper_bound(int[] arr, int x) {
+		int low = 0, high = arr.length, mid = -1;
+
+		while (low < high) {
+			mid = (low + high) / 2;
+
+			if (arr[mid] > x)
+				high = mid;
+			else
+				low = mid + 1;
+		}
+
+		return low;
+	}
+
+	/////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+	static class FastScanner {
+		BufferedReader br;
+		StringTokenizer st;
+
+		FastScanner() throws FileNotFoundException {
+			br = new BufferedReader(new InputStreamReader(System.in));
+		}
+
+		FastScanner(int a) throws FileNotFoundException {
+			br = new BufferedReader(new FileReader(""input.txt""));
+		}
+
+		String next() throws IOException {
+			while (st == null || !st.hasMoreElements()) {
+				try {
+					st = new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			}
+			return st.nextToken();
+		}
+
+		int nextInt() throws IOException {
+			return Integer.parseInt(next());
+		}
+
+		long nextLong() throws IOException {
+			return Long.parseLong(next());
+		}
+
+		double nextDouble() throws IOException {
+			return Double.parseDouble(next());
+		}
+
+		String nextLine() throws IOException {
+			String str = """";
+			try {
+				str = br.readLine();
+			} catch (IOException e) {
+				e.printStackTrace();
+			}
+			return str;
+		}
+
+		int[] readArray(int n) throws IOException {
+			int[] A = new int[n];
+			for (int i = 0; i != n; i++) {
+				A[i] = sc.nextInt();
+			}
+			return A;
+		}
+
+		long[] readArrayLong(int n) throws IOException {
+			long[] A = new long[n];
+			for (int i = 0; i != n; i++) {
+				A[i] = sc.nextLong();
+			}
+			return A;
+		}
+	}
+
+	static void ruffleSort(int[] a) {
+		Random get = new Random();
+		for (int i = 0; i < a.length; i++) {
+			int r = get.nextInt(a.length);
+			int temp = a[i];
+			a[i] = a[r];
+			a[r] = temp;
+		}
+		Arrays.sort(a);
+	}
+
+	static void ruffleSort(long[] a) {
+		Random get = new Random();
+		for (int i = 0; i < a.length; i++) {
+			int r = get.nextInt(a.length);
+			long temp = a[i];
+			a[i] = a[r];
+			a[r] = temp;
+		}
+		Arrays.sort(a);
+	}
+}
+",0
+1162c08f,734a94be,"import java.util.*;
+
+public class CodeForces1525C{
+	public static void main(String[] args) {
+		Scanner sc=new Scanner(System.in);
+		ArrayList<Integer> o=new ArrayList<Integer>(), e=new ArrayList<Integer>();
+		int n = sc.nextInt(),dp[][]=new int[n+1][n+1];
+		for(int i=1;i<=n;i++){
+			int x=sc.nextInt();
+			if(x==1)o.add(i);
+			else e.add(i);
+		}
+		for(int i=1;i<=o.size();i++){
+			dp[i][i]=dp[i-1][i-1]+Math.abs(o.get(i-1)-e.get(i-1));
+			for(int j=i+1;j<=e.size();j++)
+				dp[i][j]=Math.min(dp[i][j-1],dp[i-1][j-1]+Math.abs(o.get(i-1)-e.get(j-1)));
+		}
+		System.out.println(dp[o.size()][e.size()]);
+	}
+}
+
+","
+
+import java.io.*;
+import java.math.*;
+import java.util.*;
+
+
+
+public class test {
+	 
+	   static class Pair{ 
+		   long x;
+		   long y;
+		   
+		   Pair(long x,long y){ 
+			   this.x = x;
+			   this.y = y;
+			   
+		   }
+	   }
+	  
+	   static class Compare { 
+		   
+		     void compare(Pair arr[], int n) 
+		    { 
+		        // Comparator to sort the pair according to second element 
+		        Arrays.sort(arr, new Comparator<Pair>() { 
+		            @Override public int compare(Pair p1, Pair p2) 
+		            { 
+		            	if(p1.x!=p2.x) {
+		                return (int)(p1.x - p2.x); 
+		            	}
+		            	else { 
+		            		return (int)(p1.y - p2.y);
+		            	}
+		            } 
+		        }); 
+		  
+//		        for (int i = 0; i < n; i++) { 
+//		            System.out.print(arr[i].x + "" "" + arr[i].y + "" ""); 
+//		        } 
+//		        System.out.println(); 
+		    } 
+		} 
+	 
+	   static class Scanner {
+	        BufferedReader br;
+	        StringTokenizer st;
+	 
+	        public Scanner()
+	        {
+	            br = new BufferedReader(
+	                new InputStreamReader(System.in));
+	        }
+	 
+	        String next()
+	        {
+	            while (st == null || !st.hasMoreElements()) {
+	                try {
+	                    st = new StringTokenizer(br.readLine());
+	                }
+	                catch (IOException e) {
+	                    e.printStackTrace();
+	                }
+	            }
+	            return st.nextToken();
+	        }
+	 
+	        int nextInt() { return Integer.parseInt(next()); }
+	 
+	        long nextLong() { return Long.parseLong(next()); }
+	 
+	        double nextDouble()
+	        {
+	            return Double.parseDouble(next());
+	        }
+	 
+	        String nextLine()
+	        {
+	            String str = """";
+	            try {
+	                str = br.readLine();
+	            }
+	            catch (IOException e) {
+	                e.printStackTrace();
+	            }
+	            return str;
+	        }
+	    }
+	
+	   static int solve(int dp[][] , ArrayList<Integer> one , ArrayList<Integer> zero , int i,int j)
+	   {
+	       int n=one.size();
+	       int m=zero.size();
+	       
+	       if(i>=n)
+	           return 0;
+	       
+	       else if(j>=m)
+	           return Integer.MAX_VALUE;
+	       
+	       else if(dp[i][j]!=-1)
+	           return dp[i][j];
+	       
+	       int val1 = Math.abs(one.get(i)-zero.get(j))+solve(dp, one ,zero ,i+1,j+1);
+	       int val2 = solve(dp , one , zero , i,j+1);
+	       
+	        dp[i][j]= Math.min(val1,val2);
+	        
+	        return dp[i][j];
+	   }
+	     
+	   public static void main(String args[]) throws Exception { 
+		
+		   Scanner sc = new Scanner();
+		   StringBuffer res = new StringBuffer();
+		   
+		   int tc = 1;
+		   
+		   while(tc-->0) { 
+			
+			    int n = sc.nextInt();
+			    
+			    ArrayList<Integer> one = new ArrayList<>();
+			    ArrayList<Integer> zero = new ArrayList<>();
+			    
+			    for(int i=0;i<n;i++) { 
+			    	
+			    	int x = sc.nextInt();
+			    	
+			    	if(x==1) { 
+			    		one.add(i);
+			    	}
+			    	else { 
+			    		zero.add(i);
+			    	}
+			    }
+			    
+			    int dp[][] = new int[one.size()+1][zero.size()+1];
+			    
+			     for(int i=1;i<=one.size();i++)
+			     {
+			         dp[i][i]=dp[i-1][i-1]+Math.abs(zero.get(i-1)-one.get(i-1));
+			         for(int j=i+1;j<=zero.size();j++)
+			         {
+			             dp[i][j]=Math.min(dp[i][j-1],dp[i-1][j-1]+Math.abs(one.get(i-1)-zero.get(j-1)));
+			         }
+			     }
+			     System.out.println(dp[one.size()][zero.size()]);
+		   }
+			System.out.println(res);
+	   }
+}  
+
+
+
+
+",1
+bd3051e3,e2e37533,"import java.io.*;
+import java.util.*;
+
+public class Main {
+	static BufferedReader br;
+	static PrintWriter pr;
+	static int cin() throws Exception
+	{
+		return Integer.valueOf(br.readLine());
+	}
+	static int[] split() throws Exception
+	{
+		String[] cmd=br.readLine().split("" "");
+		int[] ans=new int[cmd.length];
+		for(int i=0;i<cmd.length;i++)
+		{
+			ans[i]=Integer.valueOf(cmd[i]);
+		}
+		return ans;
+	}
+	static long[] splitL() throws IOException
+	{
+		String[] cmd=br.readLine().split("" "");
+		long[] ans=new long[cmd.length];
+		for(int i=0;i<cmd.length;i++)
+		{
+			ans[i]=Long.valueOf(cmd[i]);
+		}
+		return ans;
+	}
+	static int sum(long n)
+	{
+		int ans=0;
+		while(n!=0)
+		{
+			ans=ans+(int)(n%10);
+			n=n/10;
+		}
+		return ans;
+	}
+	static long gcd(long x,long y)
+	{
+		if(x==0)
+			return y;
+		if(y==0)
+			return x;
+		if(x>y)
+			return gcd(x%y,y);
+		else
+			return gcd(x,y%x);
+	}
+	public static void main(String[] args) throws Exception{
+		// TODO Auto-generated method stub 
+		br=new BufferedReader(new InputStreamReader(System.in));
+		pr=new PrintWriter(new OutputStreamWriter(System.out));
+		int cases=cin();
+		while(cases!=0)
+		{
+			cases--;
+			int[]ar=split();
+		    int n=ar[0];
+		    int m=ar[1];
+		    int[][]mat=new int[n][m];
+		    for(int i=0;i<n;i++)
+		    {
+		    	String s=br.readLine();
+		    	for(int j=0;j<m;j++)
+		    	{
+		    		mat[i][j]=s.charAt(j)-'0';
+		    	}
+		    }
+		    ArrayList<String>ans=new ArrayList<>();
+		    for(int i=0;i<n-1;i++)
+		    {
+		    	for(int j=0;j<m-1;j++)
+		    	{
+		    		if(mat[i][j]==1 && mat[i][j+1]==0 && mat[i+1][j]==0 && mat[i+1][j+1]==0)
+		    		{
+		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+2));
+		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+1));
+		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+2)+"" ""+(j+1)+"" ""+(i+2)+"" ""+(j+2));
+		    		}
+		    		else if(mat[i][j]==0 && mat[i][j+1]==0 && mat[i+1][j]==0 && mat[i+1][j+1]==1)
+		    		{
+		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+2));
+		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+2)+"" ""+(j+1)+"" ""+(i+2)+"" ""+(j+2));
+		    			ans.add((i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+1)+"" ""+(i+2)+"" ""+(j+2));
+		    		}
+		    		else if(mat[i][j]==0 && mat[i][j+1]==1 && mat[i+1][j]==0 && mat[i+1][j+1]==0)
+		    		{
+		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+1));
+		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+2));
+		    			ans.add((i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+1)+"" ""+(i+2)+"" ""+(j+2));
+		    		}
+		    		else if(mat[i][j]==0 && mat[i][j+1]==0 && mat[i+1][j]==1 && mat[i+1][j+1]==0)
+		    		{
+		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+1));
+		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+2)+"" ""+(j+1)+"" ""+(i+2)+"" ""+(j+2));
+		    			ans.add((i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+1)+"" ""+(i+2)+"" ""+(j+2));
+		    		}
+		    		else if(mat[i][j]==1 && mat[i][j+1]==1 && mat[i+1][j]==1 && mat[i+1][j+1]==0)
+		    		{
+		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+1));
+		    		}
+		    		else if(mat[i][j]==1 && mat[i][j+1]==0 && mat[i+1][j]==1 && mat[i+1][j+1]==1)
+		    		{
+		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+2)+"" ""+(j+1)+"" ""+(i+2)+"" ""+(j+2));
+		    		}
+		    		else if(mat[i][j]==1 && mat[i][j+1]==1 && mat[i+1][j]==0 && mat[i+1][j+1]==1)
+		    		{
+		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+2));
+		    		}
+		    		else if(mat[i][j]==0 && mat[i][j+1]==1 && mat[i+1][j]==1 && mat[i+1][j+1]==1)
+		    		{
+		    			ans.add((i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+1)+"" ""+(i+2)+"" ""+(j+2));
+		    		}
+		    		else if(mat[i][j]==1 && mat[i][j+1]==1 && mat[i+1][j]==1 && mat[i+1][j+1]==1)
+		    		{
+		    			ans.add((i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+1)+"" ""+(i+2)+"" ""+(j+2));
+		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+2));
+		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+1));
+		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+2)+"" ""+(j+1)+"" ""+(i+2)+"" ""+(j+2));
+		    		}
+		    		
+		    		else if(mat[i][j]==1 && mat[i][j+1]==1 && mat[i+1][j]==0 && mat[i+1][j+1]==0)
+		    		{
+		    			ans.add((i+2)+"" ""+(j+1)+"" ""+(i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+2));
+		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+2)+"" ""+(j+1)+"" ""+(i+2)+"" ""+(j+2));
+		    		}
+		    		else if(mat[i][j]==0 && mat[i][j+1]==0 && mat[i+1][j]==1 && mat[i+1][j+1]==1)
+		    		{
+		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+2));
+		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+1));
+		    		}
+		    		else if(mat[i][j]==1 && mat[i][j+1]==0 && mat[i+1][j]==1 && mat[i+1][j+1]==0)
+		    		{
+		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+2));
+		    			ans.add((i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+1)+"" ""+(i+2)+"" ""+(j+2));
+		    		}
+		    		else if(mat[i][j]==0 && mat[i][j+1]==1 && mat[i+1][j]==0 && mat[i+1][j+1]==1)
+		    		{
+		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+1));
+		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+2)+"" ""+(j+1)+"" ""+(i+2)+"" ""+(j+2));
+		    		}
+		    		else if(mat[i][j]==1 && mat[i][j+1]==0 && mat[i+1][j]==0 && mat[i+1][j+1]==1)
+		    		{
+		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+1));
+		    			ans.add((i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+1)+"" ""+(i+2)+"" ""+(j+2));
+		    		}
+		    		else if(mat[i][j]==0 && mat[i][j+1]==1 && mat[i+1][j]==1 && mat[i+1][j+1]==0)
+		    		{
+		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+2));
+		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+2)+"" ""+(j+1)+"" ""+(i+2)+"" ""+(j+2));
+		    		}
+		    		mat[i][j]=mat[i+1][j]=mat[i][j+1]=mat[i+1][j+1]=0;
+		    	}
+		    }
+		    System.out.println(ans.size());
+		    for(int i=0;i<ans.size();i++)
+		    {
+		    	System.out.println(ans.get(i));
+		    }
+		}
+	}
+}
+","
+import java.io.*;
+import java.util.*;
+
+public class Main {
+	static BufferedReader br;
+	static PrintWriter pr;
+	static int cin() throws Exception
+	{
+		return Integer.valueOf(br.readLine());
+	}
+	static int[] split() throws Exception
+	{
+		String[] cmd=br.readLine().split("" "");
+		int[] ans=new int[cmd.length];
+		for(int i=0;i<cmd.length;i++)
+		{
+			ans[i]=Integer.valueOf(cmd[i]);
+		}
+		return ans;
+	}
+	static long[] splitL() throws IOException
+	{
+		String[] cmd=br.readLine().split("" "");
+		long[] ans=new long[cmd.length];
+		for(int i=0;i<cmd.length;i++)
+		{
+			ans[i]=Long.valueOf(cmd[i]);
+		}
+		return ans;
+	}
+	static int sum(long n)
+	{
+		int ans=0;
+		while(n!=0)
+		{
+			ans=ans+(int)(n%10);
+			n=n/10;
+		}
+		return ans;
+	}
+	static long gcd(long x,long y)
+	{
+		if(x==0)
+			return y;
+		if(y==0)
+			return x;
+		if(x>y)
+			return gcd(x%y,y);
+		else
+			return gcd(x,y%x);
+	}
+	public static void main(String[] args) throws Exception{
+		// TODO Auto-generated method stub 
+		br=new BufferedReader(new InputStreamReader(System.in));
+		pr=new PrintWriter(new OutputStreamWriter(System.out));
+		int cases=cin();
+		while(cases!=0)
+		{
+			cases--;
+			int[]ar=split();
+		    int n=ar[0];
+		    int m=ar[1];
+		    int[][]mat=new int[n][m];
+		    for(int i=0;i<n;i++)
+		    {
+		    	String s=br.readLine();
+		    	for(int j=0;j<m;j++)
+		    	{
+		    		mat[i][j]=s.charAt(j)-'0';
+		    	}
+		    }
+		    ArrayList<String>ans=new ArrayList<>();
+		    for(int i=0;i<n-1;i++)
+		    {
+		    	for(int j=0;j<m-1;j++)
+		    	{
+		    		if(mat[i][j]==1 && mat[i][j+1]==0 && mat[i+1][j]==0 && mat[i+1][j+1]==0)
+		    		{
+		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+2));
+		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+1));
+		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+2)+"" ""+(j+1)+"" ""+(i+2)+"" ""+(j+2));
+		    		}
+		    		else if(mat[i][j]==0 && mat[i][j+1]==0 && mat[i+1][j]==0 && mat[i+1][j+1]==1)
+		    		{
+		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+2));
+		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+2)+"" ""+(j+1)+"" ""+(i+2)+"" ""+(j+2));
+		    			ans.add((i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+1)+"" ""+(i+2)+"" ""+(j+2));
+		    		}
+		    		else if(mat[i][j]==0 && mat[i][j+1]==1 && mat[i+1][j]==0 && mat[i+1][j+1]==0)
+		    		{
+		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+1));
+		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+2));
+		    			ans.add((i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+1)+"" ""+(i+2)+"" ""+(j+2));
+		    		}
+		    		else if(mat[i][j]==0 && mat[i][j+1]==0 && mat[i+1][j]==1 && mat[i+1][j+1]==0)
+		    		{
+		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+1));
+		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+2)+"" ""+(j+1)+"" ""+(i+2)+"" ""+(j+2));
+		    			ans.add((i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+1)+"" ""+(i+2)+"" ""+(j+2));
+		    		}
+		    		else if(mat[i][j]==1 && mat[i][j+1]==1 && mat[i+1][j]==1 && mat[i+1][j+1]==0)
+		    		{
+		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+1));
+		    		}
+		    		else if(mat[i][j]==1 && mat[i][j+1]==0 && mat[i+1][j]==1 && mat[i+1][j+1]==1)
+		    		{
+		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+2)+"" ""+(j+1)+"" ""+(i+2)+"" ""+(j+2));
+		    		}
+		    		else if(mat[i][j]==1 && mat[i][j+1]==1 && mat[i+1][j]==0 && mat[i+1][j+1]==1)
+		    		{
+		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+2));
+		    		}
+		    		else if(mat[i][j]==0 && mat[i][j+1]==1 && mat[i+1][j]==1 && mat[i+1][j+1]==1)
+		    		{
+		    			ans.add((i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+1)+"" ""+(i+2)+"" ""+(j+2));
+		    		}
+		    		else if(mat[i][j]==1 && mat[i][j+1]==1 && mat[i+1][j]==1 && mat[i+1][j+1]==1)
+		    		{
+		    			ans.add((i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+1)+"" ""+(i+2)+"" ""+(j+2));
+		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+2));
+		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+1));
+		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+2)+"" ""+(j+1)+"" ""+(i+2)+"" ""+(j+2));
+		    		}
+		    		
+		    		else if(mat[i][j]==1 && mat[i][j+1]==1 && mat[i+1][j]==0 && mat[i+1][j+1]==0)
+		    		{
+		    			ans.add((i+2)+"" ""+(j+1)+"" ""+(i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+2));
+		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+2)+"" ""+(j+1)+"" ""+(i+2)+"" ""+(j+2));
+		    		}
+		    		else if(mat[i][j]==0 && mat[i][j+1]==0 && mat[i+1][j]==1 && mat[i+1][j+1]==1)
+		    		{
+		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+2));
+		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+1));
+		    		}
+		    		else if(mat[i][j]==1 && mat[i][j+1]==0 && mat[i+1][j]==1 && mat[i+1][j+1]==0)
+		    		{
+		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+2));
+		    			ans.add((i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+1)+"" ""+(i+2)+"" ""+(j+2));
+		    		}
+		    		else if(mat[i][j]==0 && mat[i][j+1]==1 && mat[i+1][j]==0 && mat[i+1][j+1]==1)
+		    		{
+		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+1));
+		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+2)+"" ""+(j+1)+"" ""+(i+2)+"" ""+(j+2));
+		    		}
+		    		else if(mat[i][j]==1 && mat[i][j+1]==0 && mat[i+1][j]==0 && mat[i+1][j+1]==1)
+		    		{
+		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+1));
+		    			ans.add((i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+1)+"" ""+(i+2)+"" ""+(j+2));
+		    		}
+		    		else if(mat[i][j]==0 && mat[i][j+1]==1 && mat[i+1][j]==1 && mat[i+1][j+1]==0)
+		    		{
+		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+2));
+		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+2)+"" ""+(j+1)+"" ""+(i+2)+"" ""+(j+2));
+		    		}
+		    		mat[i][j]=mat[i+1][j]=mat[i][j+1]=mat[i+1][j+1]=0;
+		    	}
+		    }
+		    System.out.println(ans.size());
+		    for(int i=0;i<ans.size();i++)
+		    {
+		    	System.out.println(ans.get(i));
+		    }
+		}
+	}
+}
+
+",1
+853acff9,929b98f0,"import java.lang.*;
+import java.util.*;
+import java.io.*;
+public class C {
+	final static int mod = (int)(1e9 + 7);
+	static LinkedList<Integer>[] adj;
+	static int arr[][] ;
+	static long dp[][] ;
+	public static void main(String[] args) {
+		FastReader fs = new FastReader();
+		int testcase = 1;
+		testcase = fs.nextInt();
+		//int i = 1;
+		while (testcase-- > 0) {
+			//System.out.print(""Case #"" + Integer.toString(i) + "": "");
+			solve(fs);
+			//i++;
+		}
+
+	}
+	public static void solve(FastReader fs) {
+		int n = fs.nextInt();
+		arr = new int[n + 1][2];
+		adj = new LinkedList[n + 1];
+		dp = new long[n + 1][2];
+		for (int i = 0; i < adj.length; i++) {
+			adj[i] = new LinkedList<Integer>();
+		}
+		for (int i = 1; i < arr.length; i++) {
+			arr[i][0] = fs.nextInt();
+			arr[i][1] = fs.nextInt();
+		}
+		for (int i = 0; i < n - 1; i++) {
+			int u = fs.nextInt();
+			int v = fs.nextInt();
+			adj[u].add(v);
+			adj[v].add(u);
+		}
+		dfs(1, -1);
+
+		System.out.println(Math.max(dp[1][0], dp[1][1]));
+	}
+
+	static void dfs(int source , int parent) {
+		for (int val : adj[source]) {
+			if (val == parent)
+				continue;
+			dfs(val, source);
+			dp[source][0] += Math.max(dp[val][0] + Math.abs(arr[source][0] - arr[val][0]),
+			                          dp[val][1] + Math.abs(arr[source][0] - arr[val][1]));
+			dp[source][1] += Math.max(dp[val][0] + Math.abs(arr[source][1] - arr[val][0]),
+			                          dp[val][1] + Math.abs(arr[source][1] - arr[val][1]));
+		}
+	}
+
+
+//IO operation
+	static class FastReader {
+		BufferedReader br;
+		StringTokenizer st;
+		public FastReader() {
+			br = new BufferedReader(
+			    new InputStreamReader(System.in));
+		}
+
+		String next() {
+			while (st == null || !st.hasMoreElements()) {
+				try {
+					st = new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			}
+			return st.nextToken();
+		}
+
+		int nextInt() { return Integer.parseInt(next()); }
+
+		long nextLong() { return Long.parseLong(next()); }
+
+		double nextDouble() {
+			return Double.parseDouble(next());
+		}
+
+		String nextLine() {
+			String str = """";
+			try {
+				str = br.readLine();
+			} catch (IOException e) {
+				e.printStackTrace();
+			}
+			return str;
+		}
+	}
+}","
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.PrintStream;
+import java.util.*;
+
+public class Main {
+
+    public static long[] ans(List<List<Integer>> edges, long[][] range, int root, boolean[] visited, PrintStream out) {
+        if (visited[root]) {
+            return new long[2];
+        }
+        visited[root] = true;
+        long[] ans = new long[2];
+        for (int x : edges.get(root)) {
+            if (!visited[x]) {
+                long[] temp = ans(edges, range, x, visited, out);
+                ans[0] += Math.max(Math.abs(range[root][0] - range[x][0]) + temp[0], Math.abs(range[root][0] - range[x][1]) + temp[1]);
+                ans[1] += Math.max(Math.abs(range[root][1] - range[x][0]) + temp[0], Math.abs(range[root][1] - range[x][1]) + temp[1]);
+            }
+        }
+        return ans;
+    }
+
+    public static void main(String[] args) throws IOException {
+        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
+        PrintStream out = new PrintStream(System.out);
+        int t = Integer.parseInt(reader.readLine());
+        while (t-->0) {
+            int n = Integer.parseInt(reader.readLine());
+            long[][] range = new long[n][2];
+            for (int i = 0; i < n; i++) {
+                String[] input = reader.readLine().split("" "");
+                range[i][0] = Integer.parseInt(input[0]);
+                range[i][1] = Integer.parseInt(input[1]);
+            }
+            List<List<Integer>> edges = new ArrayList<>();
+            for (int i = 0; i < n; i++) {
+                edges.add(new ArrayList<>());
+            }
+            for (int i = 0; i < n - 1; i++) {
+                String[] input = reader.readLine().split("" "");
+                int u = Integer.parseInt(input[0]) - 1, v = Integer.parseInt(input[1]) - 1;
+                edges.get(u).add(v);
+                edges.get(v).add(u);
+            }
+            int root = 0;
+            for (int i = 0; i < n; i++) {
+                if (edges.get(i).size() > 1) {
+                    root = i;
+                    break;
+                }
+                if (edges.get(i).size() == 1) {
+                    root = i;
+                }
+            }
+            long[] ans = ans(edges, range, root, new boolean[n], out);
+            out.println(Math.max(ans[0], ans[1]));
+        }
+        out.close();
+    }
+}
+",0
+0ee2f8f1,c2b7b017,"import java.util.*;
+public class Main{
+  public static void main(String args[]){
+    Scanner sc=new Scanner(System.in);
+    int T=sc.nextInt();
+    while(T-->0){
+     int n=sc.nextInt();
+     int arr[]=new int[n];
+     int min=Integer.MAX_VALUE;int max=Integer.MIN_VALUE;
+     for(int i=0;i<n;i++){
+      arr[i]=sc.nextInt();
+      min=Math.min(arr[i],min);
+      max=Math.max(arr[i],max);
+     }
+     while(min<=max){
+      int mid=min+(max-min)/2;
+      if(helper(arr,mid))
+       min=mid+1;
+       else max=mid-1;
+     }
+     System.out.println(min-1);
+    }
+  }
+  public static boolean helper(int arr[],int min){
+   int tmp[]=Arrays.copyOf(arr,arr.length);
+   for(int i=arr.length-1;i>=2;i--){
+    if(tmp[i]<min)
+     return false;
+    int d=(Math.min(arr[i],tmp[i]-min))/3;
+    tmp[i-1]+=d;
+    tmp[i-2]+=d*2;
+   }
+   return tmp[1]>=min && tmp[0]>=min;
+  }
+}","// Working program with FastReader
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.*;
+
+//
+public class Example {
+    static class FastReader {
+        BufferedReader br;
+        StringTokenizer st;
+
+        public FastReader() {
+            br = new BufferedReader(
+                    new InputStreamReader(System.in));
+        }
+
+        String next() {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+
+        String nextLine() {
+            String str = """";
+            try {
+                str = br.readLine();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+        }
+    }
+
+    public static void main(String[] args) {
+        FastReader sc = new FastReader();
+
+        int t= sc.nextInt();
+        while(t>0){
+            t--;
+            int ans=Integer.MAX_VALUE;
+            int n=sc.nextInt();
+            int[] ar= new int[n];
+            int l=Integer.MAX_VALUE;
+            int h=Integer.MIN_VALUE;
+            for(int i=0;i<n;i++){
+                ar[i]=sc.nextInt();
+                l=Math.min(l,ar[i]);
+                h=Math.max(h,ar[i]);
+
+            }
+            int[] extra;
+            while(l<=h){
+                int mid=l+(h-l)/2;
+                if(possibleans(ar,mid)){
+                    ans=mid;
+                    l=mid+1;
+                }else{
+                    h=mid-1;
+                }
+            }
+            System.out.println(ans);
+
+
+        }
+    }
+
+    private static boolean possibleans(int[] ar, int mid) {
+int[] extra=new int[ar.length];
+        for(int i=ar.length-1;i>=2;i--){
+            if((ar[i]+extra[i]-mid)<0){
+                return false;
+            }
+            int d=Math.min(ar[i],extra[i]+ar[i]-mid);
+            extra[i-1]=extra[i-1]+d/3;
+            extra[i-2]+=2*(d/3);
+
+        }
+        int a=ar[0]+extra[0];
+        int b=ar[1]+extra[1];
+        return (a>=mid && b>=mid);
+
+    }
+
+    private static boolean possible(int a, int b, int c, int mid) {
+        int min=Math.min(a,Math.min(b,c));
+        if(3*mid<=(c)){
+            c=c-3*mid;
+            a=a+2*mid;
+            b=b+mid;
+            int min1=Math.min(a,Math.min(b,c));
+            if(min1>min){
+                return true;
+            }else{
+                return false;
+            }
+
+        }else{
+            return false;
+        }
+
+
+    }
+}
+",1
+c57997b6,ff10b574,"import java.io.*;
+import java.util.*;
+import java.util.Map.Entry;
+
+public class AMain {
+	
+	public static void main(String[] args) {
+		QuickReader in = new QuickReader(System.in);
+		
+		try(PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));)
+		{
+			new AMain().solve(in, out);
+		}
+	}
+	
+	public void solve(QuickReader in, PrintWriter out)
+	{
+		int t = in.nextInt();
+		while(t-->0)
+		{
+			int n = in.nextInt();
+			int[] a= in.nextInts(n);
+			char[] clr = in.next().toCharArray();
+			
+			ArrayList<ArrayList<Integer> > rgh = new ArrayList<>();
+			for(int i=0;i<n;i++)
+				rgh.add(new ArrayList<>());
+			
+			boolean ok = true;
+			
+			for(int i=0;i<n;i++)
+				if(clr[i] == 'B')
+				{
+					if(a[i]<1)
+						ok = false;
+					else
+						rgh.get(0).add(a[i]-1);
+				}
+				else
+				{
+					if(a[i]>n)
+						ok = false;
+					else
+						rgh.get(Math.max(0, a[i]-1)).add(n-1);
+				}
+			
+			
+			TreeMap<Integer, Integer> q = new TreeMap<>();
+			for(int i=0;i<n;i++)
+			{
+				for(int j: rgh.get(i))
+					q.put(j, q.getOrDefault(j, 0)+1);
+				if(q.isEmpty() || q.firstKey() < i)
+				{
+					ok = false;
+					break;
+				}
+				Entry<Integer, Integer> cur = q.firstEntry();
+				
+				if(cur.getValue() == 1)
+					q.remove(cur.getKey());
+				else
+					q.put(cur.getKey(), cur.getValue()-1);
+			}
+			out.println(ok? ""YES"":""NO"");
+			out.flush();
+		}
+	
+	}
+
+}
+
+class QuickReader
+{
+	BufferedReader in;
+	StringTokenizer token;
+	
+	public QuickReader(InputStream ins)
+	{
+		in=new BufferedReader(new InputStreamReader(ins));
+		token=new StringTokenizer("""");
+	}
+
+	public boolean hasNext()
+	{
+		while (!token.hasMoreTokens())
+		{
+			try
+			{
+				String s = in.readLine();
+				if (s == null) return false;
+				token = new StringTokenizer(s);
+			} catch (IOException e)
+			{
+				throw new InputMismatchException();
+			}
+		}
+		return true;
+	}
+
+	public String next()
+	{
+		hasNext();
+		return token.nextToken();
+	}
+
+	public int nextInt()
+	{
+		return Integer.parseInt(next());
+	}
+
+	public int[] nextInts(int n)
+	{
+		int[] res = new int[n];
+		for (int i = 0; i < n; i++)
+			res[i] = nextInt();
+		return res;
+	}
+
+	public long nextLong() {
+		return Long.parseLong(next());
+	}	
+	
+}
+
+","import java.io.*;
+import java.util.*;
+
+public class Main {
+    public static void main(String[] args) throws IOException {
+        int t = nextInt();
+        while (t-- != 0) {
+            int n = nextInt();
+            int[] a = new int[n];
+            for (int i = 0; i < n; i++) {
+                a[i] = nextInt();
+            }
+            String s = nextToken();
+            ArrayList<Integer> r = new ArrayList<>();
+            ArrayList<Integer> b = new ArrayList<>();
+            for (int i = 0; i < n; i++) {
+                if (s.charAt(i) == 'B') b.add(a[i]);
+                else r.add(a[i]);
+            }
+            Collections.sort(b);
+            Collections.sort(r);
+            int y = 1;
+            boolean e = true;
+            for (int i = 0; i < b.size(); i++) {
+                if (b.get(i) < y) {
+                    e = false;
+                    break;
+                }
+                y++;
+            }
+            for (int i = 0; i < r.size(); i++) {
+                if (r.get(i) > y) {
+                    e = false;
+                    break;
+                }
+                y++;
+            }
+            if(e)out.println(""YES"");
+            else out.println(""NO"");
+        }
+        out.close();
+    }
+
+    static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+    static PrintWriter out = new PrintWriter(System.out);
+    static StringTokenizer in = new StringTokenizer("""");
+
+
+    public static boolean hasNext() throws IOException {
+        if (in.hasMoreTokens()) return true;
+        String s;
+        while ((s = br.readLine()) != null) {
+            in = new StringTokenizer(s);
+            if (in.hasMoreTokens()) return true;
+        }
+        return false;
+    }
+
+    public static String nextToken() throws IOException {
+        while (!in.hasMoreTokens()) {
+            in = new StringTokenizer(br.readLine());
+        }
+        return in.nextToken();
+    }
+
+    public static int nextInt() throws IOException {
+        return Integer.parseInt(nextToken());
+    }
+
+    public static long nextLong() throws IOException {
+        return Long.parseLong(nextToken());
+    }
+
+    public static double nextDouble() throws IOException {
+        return Double.parseDouble(nextToken());
+    }
+}",0
+0f6ca337,6843cc19,"import java.io.*;
+import java.util.*;
+ 
+import java.math.*;
+import java.awt.Point;
+ 
+public class Main {
+    static final long MOD = 1000000007L;
+    //static final long MOD2 = 1000000009L;
+    //static final long MOD = 998244353L;
+    //static final long INF = 500000000000L;
+    static final int INF =   1000000005;
+    static final int NINF = -1000000005;
+    //static final long INF = 1000000000000000000L;
+    static FastScanner sc;
+    static PrintWriter pw;
+    static final int[][] dirs = {{-1,0},{1,0},{0,-1},{0,1}};
+ 
+    public static void main(String[] args) {
+        sc = new FastScanner();
+        pw = new PrintWriter(System.out);
+ 
+ 
+        int Q = sc.ni();
+        for (int q = 0; q < Q; q++) {
+            int N = sc.ni();
+            int[] nums = sc.intArray(N,0);
+            Integer[] less = new Integer[N];
+            Integer[] more = new Integer[N];
+            TreeSet<Integer> ts = new TreeSet<Integer>();
+            for (int i = 0; i < N; i++) {
+                ts.add(nums[i]);
+                less[i] = ts.lower(nums[i]);
+                more[i] = ts.higher(nums[i]);
+            }
+            
+            String ans = ""YES"";
+            for (int i = 1; i < N; i++) {
+                if (nums[i-1]==nums[i]) continue;
+                
+                if (nums[i-1] < nums[i]) {
+                    if (more[i-1]!=null && more[i-1] < nums[i]) {
+                        ans = ""NO"";
+                        break;
+                    }
+                } else {
+                    if (less[i-1]!=null && less[i-1] > nums[i]) {
+                        ans = ""NO"";
+                        break;
+                    }
+                }
+            }
+            pw.println(ans);
+        }
+        pw.close(); 
+    }
+    
+ 
+    public static void sort(int[] arr) {
+        Random rgen = new Random();
+        for (int i = 0; i < arr.length; i++) {
+            int r = rgen.nextInt(arr.length);
+            int temp = arr[i];
+            arr[i] = arr[r];
+            arr[r] = temp;
+        }
+        Arrays.sort(arr);
+    }
+ 
+    public static void sort(long[] arr) {
+        Random rgen = new Random();
+        for (int i = 0; i < arr.length; i++) {
+            int r = rgen.nextInt(arr.length);
+            long temp = arr[i];
+            arr[i] = arr[r];
+            arr[r] = temp;
+        }
+        Arrays.sort(arr);
+    }
+ 
+    //Sort an array (immune to quicksort TLE)
+    public static void sort(int[][] arr) {
+        Random rgen = new Random();
+        for (int i = 0; i < arr.length; i++) {
+            int r = rgen.nextInt(arr.length);
+            int[] temp = arr[i];
+            arr[i] = arr[r];
+            arr[r] = temp;
+        }
+        Arrays.sort(arr, new Comparator<int[]>() {
+            @Override
+            public int compare(int[] a, int[] b) {
+                return a[0]-b[0];
+            }
+        });
+    }
+    
+    public static void sort(long[][] arr) {
+        Random rgen = new Random();
+        for (int i = 0; i < arr.length; i++) {
+            int r = rgen.nextInt(arr.length);
+            long[] temp = arr[i];
+            arr[i] = arr[r];
+            arr[r] = temp;
+        }
+        Arrays.sort(arr, new Comparator<long[]>() {
+            @Override
+            public int compare(long[] a, long[] b) {
+                if (a[0] > b[0])
+                    return 1;
+                else if (a[0] < b[0])
+                    return -1;
+                else
+                    return 0;
+                //Ascending order.
+            }
+        });
+    }
+ 
+    static class FastScanner {
+        BufferedReader br;
+        StringTokenizer st;
+ 
+        public FastScanner() {
+            br = new BufferedReader(new InputStreamReader(System.in), 32768);
+            st = null;
+        }
+ 
+        String next() {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+ 
+        int ni() {
+            return Integer.parseInt(next());
+        }
+ 
+        int[][] graph(int N, int[][] edges) {
+            int[][] graph = new int[N][];
+            int[] sz = new int[N];
+            for (int[] e: edges) {
+                sz[e[0]] += 1;
+                sz[e[1]] += 1;
+            }
+            for (int i = 0; i < N; i++) {
+                graph[i] = new int[sz[i]];
+            }
+            int[] cur = new int[N];
+            for (int[] e: edges) {
+                graph[e[0]][cur[e[0]]] = e[1];
+                graph[e[1]][cur[e[1]]] = e[0];
+                cur[e[0]] += 1;
+                cur[e[1]] += 1;
+            }
+            return graph;
+        }
+ 
+        int[] intArray(int N, int mod) {
+            int[] ret = new int[N];
+            for (int i = 0; i < N; i++)
+                ret[i] = ni()+mod;
+            return ret;
+        }
+ 
+        char[] charArray(int N) {
+            char[] ret = new char[N];
+            for (int i = 0; i < N; i++)
+                ret[i] = next().charAt(0);
+            return ret;
+        }
+ 
+        long nl() {
+            return Long.parseLong(next());
+        }
+ 
+        long[] longArray(int N, long mod) {
+            long[] ret = new long[N];
+            for (int i = 0; i < N; i++)
+                ret[i] = nl()+mod;
+            return ret;
+        }
+ 
+        double nd() {
+            return Double.parseDouble(next());
+        }
+ 
+        String nextLine() {
+            String str = """";
+            try {
+                str = br.readLine();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+        }
+    }
+}","import java.io.*;
+import java.util.*;
+ 
+import java.math.*;
+import java.awt.Point;
+ 
+public class Main {
+    static final long MOD = 1000000007L;
+    //static final long MOD2 = 1000000009L;
+    //static final long MOD = 998244353L;
+    //static final long INF = 500000000000L;
+    static final int INF =   1000000005;
+    static final int NINF = -1000000005;
+    //static final long INF = 1000000000000000000L;
+    static FastScanner sc;
+    static PrintWriter pw;
+    static final int[][] dirs = {{-1,0},{1,0},{0,-1},{0,1}};
+ 
+    public static void main(String[] args) {
+        sc = new FastScanner();
+        pw = new PrintWriter(System.out);
+ 
+ 
+        int Q = sc.ni();
+        for (int q = 0; q < Q; q++) {
+            int N = sc.ni();
+            int[] nums = sc.intArray(N,0);
+            Integer[] less = new Integer[N];
+            Integer[] more = new Integer[N];
+            TreeSet<Integer> ts = new TreeSet<Integer>();
+            for (int i = 0; i < N; i++) {
+                ts.add(nums[i]);
+                less[i] = ts.lower(nums[i]);
+                more[i] = ts.higher(nums[i]);
+            }
+            
+            String ans = ""YES"";
+            for (int i = 1; i < N; i++) {
+                if (nums[i-1]==nums[i]) continue;
+                
+                if (nums[i-1] < nums[i]) {
+                    if (more[i-1]!=null && more[i-1] < nums[i]) {
+                        ans = ""NO"";
+                        break;
+                    }
+                } else {
+                    if (less[i-1]!=null && less[i-1] > nums[i]) {
+                        ans = ""NO"";
+                        break;
+                    }
+                }
+            }
+            pw.println(ans);
+        }
+        pw.close(); 
+    }
+    
+ 
+    public static void sort(int[] arr) {
+        Random rgen = new Random();
+        for (int i = 0; i < arr.length; i++) {
+            int r = rgen.nextInt(arr.length);
+            int temp = arr[i];
+            arr[i] = arr[r];
+            arr[r] = temp;
+        }
+        Arrays.sort(arr);
+    }
+ 
+    public static void sort(long[] arr) {
+        Random rgen = new Random();
+        for (int i = 0; i < arr.length; i++) {
+            int r = rgen.nextInt(arr.length);
+            long temp = arr[i];
+            arr[i] = arr[r];
+            arr[r] = temp;
+        }
+        Arrays.sort(arr);
+    }
+ 
+    //Sort an array (immune to quicksort TLE)
+    public static void sort(int[][] arr) {
+        Random rgen = new Random();
+        for (int i = 0; i < arr.length; i++) {
+            int r = rgen.nextInt(arr.length);
+            int[] temp = arr[i];
+            arr[i] = arr[r];
+            arr[r] = temp;
+        }
+        Arrays.sort(arr, new Comparator<int[]>() {
+            @Override
+            public int compare(int[] a, int[] b) {
+                return a[0]-b[0];
+            }
+        });
+    }
+    
+    public static void sort(long[][] arr) {
+        Random rgen = new Random();
+        for (int i = 0; i < arr.length; i++) {
+            int r = rgen.nextInt(arr.length);
+            long[] temp = arr[i];
+            arr[i] = arr[r];
+            arr[r] = temp;
+        }
+        Arrays.sort(arr, new Comparator<long[]>() {
+            @Override
+            public int compare(long[] a, long[] b) {
+                if (a[0] > b[0])
+                    return 1;
+                else if (a[0] < b[0])
+                    return -1;
+                else
+                    return 0;
+                //Ascending order.
+            }
+        });
+    }
+ 
+    static class FastScanner {
+        BufferedReader br;
+        StringTokenizer st;
+ 
+        public FastScanner() {
+            br = new BufferedReader(new InputStreamReader(System.in), 32768);
+            st = null;
+        }
+ 
+        String next() {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+ 
+        int ni() {
+            return Integer.parseInt(next());
+        }
+ 
+        int[][] graph(int N, int[][] edges) {
+            int[][] graph = new int[N][];
+            int[] sz = new int[N];
+            for (int[] e: edges) {
+                sz[e[0]] += 1;
+                sz[e[1]] += 1;
+            }
+            for (int i = 0; i < N; i++) {
+                graph[i] = new int[sz[i]];
+            }
+            int[] cur = new int[N];
+            for (int[] e: edges) {
+                graph[e[0]][cur[e[0]]] = e[1];
+                graph[e[1]][cur[e[1]]] = e[0];
+                cur[e[0]] += 1;
+                cur[e[1]] += 1;
+            }
+            return graph;
+        }
+ 
+        int[] intArray(int N, int mod) {
+            int[] ret = new int[N];
+            for (int i = 0; i < N; i++)
+                ret[i] = ni()+mod;
+            return ret;
+        }
+ 
+        char[] charArray(int N) {
+            char[] ret = new char[N];
+            for (int i = 0; i < N; i++)
+                ret[i] = next().charAt(0);
+            return ret;
+        }
+ 
+        long nl() {
+            return Long.parseLong(next());
+        }
+ 
+        long[] longArray(int N, long mod) {
+            long[] ret = new long[N];
+            for (int i = 0; i < N; i++)
+                ret[i] = nl()+mod;
+            return ret;
+        }
+ 
+        double nd() {
+            return Double.parseDouble(next());
+        }
+ 
+        String nextLine() {
+            String str = """";
+            try {
+                str = br.readLine();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+        }
+    }
+}",1
+29cf2e70,2f4509a0,"import java.util.*;
+import java.io.*;
+ 
+public class D {
+    public static void main(String[] args) {
+        Scanner in = new Scanner(System.in);
+        
+        int T = in.nextInt();
+        while(T-- > 0) {
+            int n = in.nextInt();
+            int[] a = new int[n];
+            for(int j=0;j<n;j++) a[j] = in.nextInt();
+            char[] s = in.next().toCharArray();
+ 
+            List<Integer> blue = new ArrayList<>();
+            List<Integer> red = new ArrayList<>();
+            for(int j=0;j<n;j++) {
+                if(s[j] == 'B') blue.add(a[j]);
+                else red.add(a[j]);
+            }
+ 
+            Collections.sort(blue);
+            Collections.sort(red);
+ 
+            boolean p = true;
+            int cur = 1;
+            for(int val : blue) {
+                if(val<cur) {
+                    p = false;
+                    break;
+                }
+                else cur++;
+            }
+            for(int val : red) {
+                if(val>cur) {
+                    p = false;
+                    break;
+                }
+                else cur++;
+            }
+            
+            if(p) System.out.println(""yes"");
+            else System.out.println(""no"");
+        }
+    }
+}
+","//(￣﹏￣；)
+//(* ￣︿￣)	
+
+import java.util.*;
+import java.io.*;
+	
+public class Main {
+		private static FS sc = new FS();
+		
+		private static class FS {
+			BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+			StringTokenizer st = new StringTokenizer("""");
+			String next() {
+				while (!st.hasMoreTokens())
+					try {
+						st=new StringTokenizer(br.readLine());				               
+		            } catch (IOException e) {}
+				return st.nextToken();
+			}
+			
+			int nextInt() {
+				return Integer.parseInt(next());
+			}
+			long nextLong() {
+				return Long.parseLong(next());
+			}
+		}
+		
+		private static class extra {
+			
+			static int[] intArr(int size) {
+				int[] a = new int[size];
+				for(int i = 0; i < size; i++) a[i] = sc.nextInt();
+				return a;
+			}
+			
+			static long[] longArr(int size) {
+				long[] a = new long[size];
+				for(int i = 0; i < size; i++) a[i] = sc.nextLong();
+				return a;
+			}
+			
+			static long intSum(int[] a) {
+				long sum = 0; 
+				for(int i = 0; i < a.length; i++) {
+					sum += a[i];
+				}
+				return sum;
+			}
+			
+			static long longSum(long[] a) {
+				long sum = 0; 
+				for(int i = 0; i < a.length; i++) {
+					sum += a[i];
+				}
+				return sum;
+			}
+			
+			static LinkedList[] graphD(int vertices, int edges) {
+				LinkedList<Integer>[] temp = new LinkedList[vertices+1];
+				for(int i = 0; i <= vertices; i++) temp[i] = new LinkedList<>();
+				for(int i = 0; i < edges; i++) {
+					int x = sc.nextInt();
+					int y = sc.nextInt();
+					temp[x].add(y);
+				}
+				return temp;
+			}
+			
+			static LinkedList[] graphUD(int vertices, int edges) {
+				LinkedList<Integer>[] temp = new LinkedList[vertices+1];
+				for(int i = 0; i <= vertices; i++) temp[i] = new LinkedList<>();
+				for(int i = 0; i < edges; i++) {
+					int x = sc.nextInt();
+					int y = sc.nextInt();
+					temp[x].add(y);
+					temp[y].add(x);
+				}
+				return temp;
+			}
+			
+			static void printG(LinkedList[] temp) {
+				for(LinkedList<Integer> aa:temp) System.out.println(aa);
+			}
+			
+			static long cal(long val, long pow, long mod) {
+				if(pow == 0) return 1;
+				long res = cal(val, pow/2, mod);
+				
+				long ret = (res*res)%mod;
+				if(pow%2 == 0) return ret;
+				return (val*ret)%mod;
+			}
+			
+			static long gcd(long a, long b) { return b == 0 ? a:gcd(b, a%b); }
+			
+		}
+		
+		static int mod = (int) 1e9 + 7;
+		
+		static LinkedList<String>[] temp, temp2;
+		static int inf = (int) 1e9;
+//		static long inf = Long.MAX_VALUE;
+		
+		public static void main(String[] args) {	
+			int t = sc.nextInt();
+//			int t = 1;
+			StringBuilder ret = new StringBuilder();
+			while(t-- > 0) {
+				int n = sc.nextInt();
+				int[] a = extra.intArr(n);
+				String s = sc.next();
+				ArrayList<Integer> red = new ArrayList<>(), blue = new ArrayList<>();
+				for(int i = 0; i < n; i++) {
+					if(s.charAt(i) == 'R') red.add(a[i]);
+					else blue.add(a[i]);
+				}
+				Collections.sort(red);
+				Collections.sort(blue);
+				int start = 1, flag = 0;
+				for(int aa:blue) {
+					if(start > aa) {
+						flag = 1;
+						break;
+					}
+					start++;
+				}
+				for(int aa:red) {
+					if(start < aa) {
+						flag = 1;
+						break;
+					}
+					start++;
+				}
+				if(flag == 1) ret.append(""NO\n"");
+				else ret.append(""YES\n"");
+			}
+			System.out.println(ret);
+		}
+		
+	}
+	
+
+
+	
+	
+	
+",1
+35bb6075,76a69f5c,"/*
+    COLLECTIONS FRAMEWORK TUTORIAL
+
+    * HashMap
+
+    .add(key, value)
+    .get(key)
+    .containsKey(key) : true/false
+    .size()
+*/
+
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+
+import java.util.*;
+
+public class Main {
+
+    static final long M = 1000000007;
+
+    // use main for only io
+    public static void main(String args[]) {
+        FastReader io = new FastReader();
+        new Solver().solve(io);
+    }
+}
+
+//class Pair{
+//    int key;String value;
+//
+//    public Pair(int key, String value){
+//        this.key = key;
+//        this.value = value;
+//    }
+//}
+
+class SparseTable{
+    int dp[][] = new int[300005][20];
+
+    int log[] = new int[300005];
+
+    public SparseTable(long a[], int n){
+        for(int i =0;i<n;i++)dp[i][0] = i;
+
+        for(int i = 1;i < 20;i++){
+            for(int j = 0;j + (1 << i) < n;j++){
+                if(a[dp[j][i-1]] < a[dp[j + (1 << (i-1))][i-1]]){
+                    dp[j][i] = dp[j][i-1];
+                }
+                else{
+                    dp[j][i] = dp[j + (1 << (i - 1))][i-1];
+                }
+            }
+        }
+
+        log[1] = 0;
+        for(int i = 2;i <= n;i++){
+            log[i] = log[i/2] + 1;
+        }
+    }
+
+    int getMin(int L, int R, long a[]){
+        if(L > R)return 0;
+        int j = log[R - L + 1];
+        if(a[dp[L][j]] < a[dp[R - (1 << j) + 1][j]])return dp[L][j];
+
+        return dp[R-(1 << j) + 1][j];
+    }
+}
+
+class Solver {
+    static final int M = 998244353;
+
+    void solve(FastReader io) {
+       int t = io.nextInt();
+
+       while(t-- > 0){
+           int n = io.nextInt();
+
+           String s[] = new String[n];
+
+           for(int i = 0;i < n;i++)s[i] = io.nextLine();
+
+           int ans = 0;
+
+           for(int i = 0;i < 5;i++){
+               int count[] = new int[n];
+
+               for(int j = 0;j < n;j++){
+                   int freq = 0;
+                   for(int k = 0;k < s[j].length();k++){
+//                       System.out.println(s[j].charAt(k) - 'a');
+                       if((s[j].charAt(k) - 'a') == i){
+
+                           freq++;
+                       }
+                   }
+//                    System.out.println(i + "" "" + freq);
+                   count[j] = 2*freq - s[j].length();
+               }
+
+
+               Arrays.sort(count);
+//                for(int it : count)System.out.print(it + "" "");
+//                System.out.println();
+
+               int curr = 0;
+               int j = n - 1;
+               for(;j >= 0 && (curr + count[j] > 0);j--){
+                   curr += count[j];
+               }
+
+               ans = Math.max(ans, n - j - 1);
+
+           }
+
+           System.out.println(ans);
+       }
+    }
+
+    // returns the first key greater than or equal to val
+    int lower_bound(int a[], int val) {
+        int low = 0, high = a.length - 1, ret = -1;
+
+        while (low <= high) {
+            int mid = (low + high) / 2;
+
+            if (a[mid] < val) low = mid + 1;
+            else {
+                ret = mid;
+                high = mid - 1;
+            }
+
+        }
+
+        return ret;
+    }
+
+    // returns the first key strictly greater than val
+    int upper_bound(int a[], int val) {
+        int low = 0, high = a.length - 1, ret = -1;
+
+        while (low <= high) {
+            int mid = (low + high) / 2;
+
+            if (a[mid] <= val) low = mid + 1;
+            else {
+                ret = mid;
+                high = mid - 1;
+            }
+
+        }
+
+        return ret;
+    }
+    long modexp(long n, int m) {
+        if (m == 0)
+            return 1;
+        else if (m == 1)
+            return n;
+        else {
+            long p = modexp(n, m / 2);
+
+            if (m % 2 == 1)
+                return (((p * p) % M) * n) % M;
+            else
+                return (p * p) % M;
+        }
+    }
+
+    long exp(long n, long m) {
+        if (m == 0)
+            return 1;
+        if (m == 1)
+            return n;
+
+        long p = exp(n, m / 2);
+
+        if (m % 2 == 1)
+            return p * p * n;
+        else
+            return p * p;
+    }
+
+    long gcd(long a, long b) {
+        if (a == 0)
+            return b;
+
+        return gcd(b % a, a);
+    }
+
+    long inv(long n) {
+        return modexp(n, M - 2);
+    }
+
+    long lcm(long a, long b) {
+        return a * b / gcd(a, b);
+    }
+
+    long factorial(long fact[], int n) {
+        fact[0] = 1;
+        fact[1] = 1;
+
+        long prod = 1;
+
+        for (int i = 2; i <= n; i++) {
+            prod = (prod * i) % M;
+
+            fact[i] = prod;
+        }
+
+        return prod;
+    }
+
+    boolean isPrime(long n) {
+        for (int i = 2; i * i <= n; i++) {
+            if (n % i == 0)
+                return false;
+        }
+        return true;
+    }
+}
+
+
+class FastReader {
+    BufferedReader br;
+    StringTokenizer st;
+
+    public FastReader() {
+        br = new BufferedReader(new
+                InputStreamReader(System.in));
+    }
+
+    String next() {
+        while (st == null || !st.hasMoreElements()) {
+            try {
+                st = new StringTokenizer(br.readLine());
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+        }
+        return st.nextToken();
+    }
+
+    int nextInt() {
+        return Integer.parseInt(next());
+    }
+
+    long nextLong() {
+        return Long.parseLong(next());
+    }
+
+    double nextDouble() {
+        return Double.parseDouble(next());
+    }
+
+    String nextLine() {
+        String str = """";
+        try {
+            str = br.readLine();
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        return str;
+    }
+}","
+import java.util.*;
+import java.util.Map.Entry;
+import java.lang.*;
+import java.io.*;
+import java.math.BigInteger;
+
+
+public class CF {
+	private static FS sc = new FS();
+	
+	private static class FS {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st = new StringTokenizer("""");
+		String next() {
+			while (!st.hasMoreTokens())
+				try {
+					st=new StringTokenizer(br.readLine());				               
+	            } catch (IOException e) {}
+			return st.nextToken();
+		}
+		
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+	}
+	
+	private static class extra {
+		
+		static int[] intArr(int size) {
+			int[] a = new int[size];
+			for(int i = 0; i < size; i++) a[i] = sc.nextInt();
+			return a;
+		}
+		
+		static long[] longArr(int size) {
+			long[] a = new long[size];
+			for(int i = 0; i < size; i++) a[i] = sc.nextLong();
+			return a;
+		}
+		
+		static long intSum(int[] a) {
+			long sum = 0; 
+			for(int i = 0; i < a.length; i++) {
+				sum += a[i];
+			}
+			return sum;
+		}
+		
+		static long longSum(long[] a) {
+			long sum = 0; 
+			for(int i = 0; i < a.length; i++) {
+				sum += a[i];
+			}
+			return sum;
+		}
+		
+		static LinkedList[] graphD(int vertices, int edges) {
+			LinkedList<Integer>[] temp = new LinkedList[vertices+1];
+			for(int i = 0; i <= vertices; i++) temp[i] = new LinkedList<>();
+			for(int i = 0; i < edges; i++) {
+				int x = sc.nextInt();
+				int y = sc.nextInt();
+				temp[x].add(y);
+			}
+			return temp;
+		}
+		
+		static LinkedList[] graphUD(int vertices, int edges) {
+			LinkedList<Integer>[] temp = new LinkedList[vertices+1];
+			for(int i = 0; i <= vertices; i++) temp[i] = new LinkedList<>();
+			for(int i = 0; i < edges; i++) {
+				int x = sc.nextInt();
+				int y = sc.nextInt();
+				temp[x].add(y);
+				temp[y].add(x);
+			}
+			return temp;
+		}
+		
+		static void printG(LinkedList[] temp) {
+			for(LinkedList<Integer> aa:temp) System.out.println(aa);
+		}
+		
+		static long cal(long val, long pow) {
+			if(pow == 0) return 1;
+			long res = cal(val, pow/2);
+			
+			long ret = (res*res)%mod;
+			if(pow%2 == 0) return ret;
+			return (val*ret)%mod;
+		}
+		
+		static long gcd(long a, long b) { return b == 0 ? a:gcd(b, a%b); }
+		
+	}
+	
+	static int mod = 998244353;//(int) 1e9 + 7;
+//	static int mod = (int) 998244353;
+	static int max = (int) 1e6, sq = 316;
+	static LinkedList<Integer>[] temp;
+//	static int[] par, rank;
+	
+	static class pair implements Comparator<pair>{
+		int val1;
+		int val2;
+		int idx;
+		pair(int x, int y, int z) {
+			val1 = x; val2 = y; idx = z;
+		}
+		pair() {}
+		
+		@Override
+		public int compare(pair o1, pair o2) {
+			if(o1.val1-o1.val2 > o2.val1 - o2.val2) return -1;
+			else return 1;
+		}
+	}
+	
+	public static void main(String[] args) {	
+		int t = sc.nextInt();
+//		int t = 1;
+		StringBuilder ret = new StringBuilder();
+		while(t-- > 0) {
+			int n = sc.nextInt();
+			String[] s = new String[n];
+			int[][] pre = new int[n][5];
+			for(int i = 0; i < n; i++) {
+				s[i] = sc.next();
+				for(int j = 0; j < s[i].length(); j++) {
+					pre[i][s[i].charAt(j)-'a']++;
+				}
+			}
+			int max = 0;
+			for(int i = 0; i < 5; i++) {
+				int[] vis = new int[n];
+				int co = 0, toC = 0, oth = 0;
+//				char tar = (char)(i+'a');
+				for(int j = 0; j < n; j++) {
+					int tot = 0;
+					for(int aa:pre[j]) tot += aa;
+					int rem = tot-pre[j][i];
+					if(pre[j][i] > rem) {
+						co++;
+						toC += pre[j][i];
+						vis[j] = 1;
+						oth += rem;
+					}
+				}
+				PriorityQueue<pair> q = new PriorityQueue<>(new pair());
+				for(int j = 0; j < n; j++) {
+					if(vis[j] == 1) continue;
+					int tot = 0;
+					for(int aa:pre[j]) tot += aa;
+					int rem = tot - pre[j][i];
+					q.add(new pair(pre[j][i], rem, j));
+				}
+//				for(pair aa:q) System.out.println(aa.val1 + "" "" + aa.idx);
+//				System.out.println();
+				while(!q.isEmpty()) {
+					pair cur = q.poll();
+					if(cur.val1 + toC > cur.val2+oth) {
+						toC += cur.val1;
+						oth += cur.val2;
+						co++;
+					}
+				}
+//				System.out.println(co);
+				max = Math.max(max, co);
+			}
+			ret.append(max + ""\n"");
+   		}
+		System.out.println(ret);
+	}
+	
+	
+}",0
+26e699de,402aff07,"//package Task1;
+
+import java.util.Scanner;
+
+public class Menorah {
+    static int MOD9= 1000000000;
+
+    public static void main(String[] args){
+
+        Scanner sc= new Scanner(System.in);
+        int numberTest=sc.nextInt();
+        while(numberTest-->0){
+            int n=sc.nextInt();
+            char[] s=new char[n+5];
+            char[] t=new char[n+5];
+            String ss=sc.next();
+            String tt=sc.next();
+            s=ss.toCharArray();
+            t=tt.toCharArray();
+            int cntax = 0, cntbx = 0, same = 0;
+            int ans=MOD9;
+            for(int i=0; i<n; i++){
+                if(s[i]=='1')cntax++;
+                if(t[i]=='1')cntbx++;
+                if(s[i]==t[i])same++;
+            }
+            if(same==n){
+                System.out.println(0);
+                continue;
+            }
+            else if (cntax==0){
+                System.out.println(-1);
+                continue;
+            }
+            if(cntax==cntbx){
+                ans=Math.min(ans,n-same);
+            }
+            if(n-cntax+1==cntbx)ans=Math.min(ans,same);
+            if(ans<MOD9) System.out.println(ans);
+            else System.out.println(-1);
+
+
+
+        }
+
+    }
+}
+","import java.util.*;
+public class Main {
+    public static void main(String args[]) {
+        Scanner s = new Scanner(System.in);
+        int t = s.nextInt();
+        while (t-- > 0){
+            int n = s.nextInt();
+            String a = s.next();
+            String b = s.next();
+            int a1 = 0, b1 = 0;
+            for (char c: a.toCharArray()){
+                if (c == '1') a1++;
+            }
+            for (char c: b.toCharArray()){
+                if (c == '1') b1++;
+            }
+            int ans = Integer.MAX_VALUE;
+            int res = 0;
+            for (int i = 0; i < n; i++) {
+                if (a.charAt(i) != b.charAt(i)) res++;
+            }
+            if (a1 == b1) ans = Math.min(ans, res);
+            if (b1 == n-a1+1) ans = Math.min(ans, n-res);
+            if (ans == Integer.MAX_VALUE){
+                System.out.println(""-1"");
+            } else {
+                System.out.println(ans);
+            }
+        }
+    }
+}",0
+aa266c38,b5fbe7a2,"import java.util.*;
+import java.io.*;
+import java.math.*;
+
+public class Main
+
+{ 
+	 static FastReader sc=new FastReader(); 
+	 static long dp[][];
+	 static int mod=1000000007;
+
+	 
+	  public static void main(String[] args)
+{
+		   PrintWriter out=new PrintWriter(System.out);
+		   StringBuffer sb=new StringBuffer("""");
+		  int ttt=1;
+		ttt =i(); 	
+		   
+	        outer :while (ttt-- > 0) 
+			{
+	        	int n=i();
+	        	int m=i();
+	        	int x=i();
+	        	Pair A[]=new Pair[n];
+	        	for(int i=0;i<n;i++) {
+	        		A[i]=new Pair(i(), i+1);
+	        	}
+	        	Arrays.sort(A);
+	        	int B[]=new int[n+1];
+	        	int a=m;
+	        	for(int i=n-1;i>=0;i--) {
+	        		B[A[i].y]=a;
+	        		a--;
+	        		if(a==0) {
+	        			a=m;
+	        		}
+	        	}
+	        	out.println(""YES"");
+	        	for(int i=1;i<=n;i++) {
+	        		out.print(B[i]+"" "");
+	        	}
+	        	out.println();
+	        	
+	        	
+			}
+
+	     //System.out.println(sb.toString());
+		     out.close();
+	     
+	     
+	    //CHECK FOR N=1                    //CHECK FOR M=0
+        //CHECK FOR N=1                    //CHECK FOR M=0
+       	//CHECK FOR N=1
+       	//CHECK FOR N=1
+       	//CHECK FOR N=1
+		        
+		     
+    }
+	  
+	  
+	  
+	  
+	  
+	  
+	  
+	  
+	  
+	 
+static class Pair implements Comparable<Pair>
+     {
+    	 int x;
+    	 int y;
+    	 Pair(int x,int y){
+    		 this.x=x;
+    		 this.y=y;
+    	 }
+		@Override
+		public int compareTo(Pair o) {
+			if(this.x>o.x)
+				return 1;
+			else if(this.x<o.x)
+				return -1;
+			else {
+				if(this.y>o.y)
+					return 1;
+				else if(this.y<o.y)
+					return -1;
+				else
+					return 0;
+			}
+		}
+	
+		
+     }
+
+static int[] input(int n) {
+	int A[]=new int[n];
+	   for(int i=0;i<n;i++) {
+		   A[i]=sc.nextInt();
+	   }
+	   return A;
+   }
+static long[] inputL(int n) {
+	long A[]=new long[n];
+	   for(int i=0;i<n;i++) {
+		   A[i]=sc.nextLong();
+	   }
+	   return A;
+   }
+static String[] inputS(int n) {
+	String A[]=new String[n];
+	   for(int i=0;i<n;i++) {
+		   A[i]=sc.next();
+	   }
+	   return A;
+   }
+static long sum(int A[]) {
+	long sum=0;
+	for(int i : A) {
+		sum+=i;
+	}
+	return sum;
+}
+static long sum(long A[]) {
+	long sum=0;
+	for(long i : A) {
+		sum+=i;
+	}
+	return sum;
+}
+static void reverse(long A[]) {
+	int n=A.length;
+	long B[]=new long[n];
+	for(int i=0;i<n;i++) {
+		B[i]=A[n-i-1];
+	}
+	for(int i=0;i<n;i++)
+		A[i]=B[i];
+	
+}
+static void reverse(int A[]) {
+	int n=A.length;
+	int B[]=new int[n];
+	for(int i=0;i<n;i++) {
+		B[i]=A[n-i-1];
+	}
+	for(int i=0;i<n;i++)
+		A[i]=B[i];
+	
+}
+static void input(int A[],int B[]) {
+	   for(int i=0;i<A.length;i++) {
+		   A[i]=sc.nextInt();
+		   B[i]=sc.nextInt();
+	   }
+}
+static int[][] input(int n,int m){
+	int A[][]=new int[n][m];
+	for(int i=0;i<n;i++) {
+		for(int j=0;j<m;j++) {
+			A[i][j]=i();
+		}
+	}
+	return A;
+}
+static char[][] charinput(int n,int m){
+	char A[][]=new char[n][m];
+	for(int i=0;i<n;i++) {
+		String s=s();
+		for(int j=0;j<m;j++) {
+			A[i][j]=s.charAt(j);
+		}
+	}
+	return A;
+}
+static int max(int A[]) {
+	int max=Integer.MIN_VALUE;
+	for(int i=0;i<A.length;i++) {
+		max=Math.max(max, A[i]);
+	}
+	return max;
+}
+static int min(int A[]) {
+	int min=Integer.MAX_VALUE;
+	for(int i=0;i<A.length;i++) {
+		min=Math.min(min, A[i]);
+	}
+	return min;
+}
+static long max(long A[]) {
+	long max=Long.MIN_VALUE;
+	for(int i=0;i<A.length;i++) {
+		max=Math.max(max, A[i]);
+	}
+	return max;
+}
+static long min(long A[]) {
+	long min=Long.MAX_VALUE;
+	for(int i=0;i<A.length;i++) {
+		min=Math.min(min, A[i]);
+	}
+	return min;
+}
+static long [] prefix(long A[]) {
+	long p[]=new long[A.length];
+	p[0]=A[0];
+	for(int i=1;i<A.length;i++)
+		p[i]=p[i-1]+A[i];
+	return p;
+}
+static long [] prefix(int A[]) {
+	long p[]=new long[A.length];
+	p[0]=A[0];
+	for(int i=1;i<A.length;i++)
+		p[i]=p[i-1]+A[i];
+	return p;
+}
+static long [] suffix(long A[]) {
+	long p[]=new long[A.length];
+	p[A.length-1]=A[A.length-1];
+	for(int i=A.length-2;i>=0;i--)
+		p[i]=p[i+1]+A[i];
+	return p;
+}
+static long [] suffix(int A[]) {
+	long p[]=new long[A.length];
+	p[A.length-1]=A[A.length-1];
+	for(int i=A.length-2;i>=0;i--)
+		p[i]=p[i+1]+A[i];
+	return p;
+}
+static long power(long x, long y, long p)
+{
+
+	if(y==0)
+		return 1;
+	if(x==0)
+		return 0;
+    long res = 1;
+    x = x % p;
+
+    while (y > 0) {
+
+        if (y % 2 == 1)
+            res = (res * x) % p;
+
+        y = y >> 1; 
+        x = (x * x) % p;
+    }
+
+    return res;
+}
+static void print(int A[]) {
+	for(int i : A) {
+		System.out.print(i+"" "");
+	}
+	System.out.println();
+}
+static void print(long A[]) {
+	for(long i : A) {
+		System.out.print(i+"" "");
+	}
+	System.out.println();
+}
+static long mod(long x) {
+	  return ((x%mod + mod)%mod);
+}
+static String reverse(String s) {
+	StringBuffer p=new StringBuffer(s);
+	p.reverse();
+	return p.toString();
+}
+
+     static int i() {
+    	 return sc.nextInt();
+     }
+     static String s() {
+    	 return sc.next();
+     }
+     static long l() {
+    	 return sc.nextLong();
+     }  
+     static void sort(int[] A){
+        int n = A.length;
+        Random rnd = new Random();
+        for(int i=0; i<n; ++i){
+            int tmp = A[i];
+            int randomPos = i + rnd.nextInt(n-i);
+            A[i] = A[randomPos];
+            A[randomPos] = tmp;
+        }
+        Arrays.sort(A);
+     }
+     static void sort(long[] A){
+	        int n = A.length;
+	        Random rnd = new Random();
+	        for(int i=0; i<n; ++i){
+	            long tmp = A[i];
+	            int randomPos = i + rnd.nextInt(n-i);
+	            A[i] = A[randomPos];
+	            A[randomPos] = tmp;
+	        }
+	        Arrays.sort(A);
+	     }
+  static String sort(String s) {
+ 	 Character ch[]=new Character[s.length()];
+ 	 for(int i=0;i<s.length();i++) {
+ 		 ch[i]=s.charAt(i);
+ 	 }
+ 	 Arrays.sort(ch);
+ 	 StringBuffer st=new StringBuffer("""");
+ 	 for(int i=0;i<s.length();i++) {
+ 		 st.append(ch[i]);
+ 	 }
+ 	 return st.toString();
+  }
+  static HashMap<Integer,Integer> hash(int A[]){
+	  HashMap<Integer,Integer> map=new HashMap<Integer, Integer>();
+	  for(int i : A) {
+		  if(map.containsKey(i)) {
+			  map.put(i, map.get(i)+1);
+		  }
+		  else {
+			  map.put(i, 1);
+		  }
+	  }
+	  return map;
+  }
+  static TreeMap<Integer,Integer> tree(int A[]){
+	  TreeMap<Integer,Integer> map=new TreeMap<Integer, Integer>();
+	  for(int i : A) {
+		  if(map.containsKey(i)) {
+			  map.put(i, map.get(i)+1);
+		  }
+		  else {
+			  map.put(i, 1);
+		  }
+	  }
+	  return map;
+  }
+     static boolean prime(int n) 
+	    { 
+	        if (n <= 1) 
+	            return false; 
+	        if (n <= 3) 
+	            return true; 
+	        if (n % 2 == 0 || n % 3 == 0) 
+	            return false; 
+	        double sq=Math.sqrt(n);
+	  
+	        for (int i = 5; i <= sq; i = i + 6) 
+	            if (n % i == 0 || n % (i + 2) == 0) 
+	                return false; 
+	        return true; 
+	    } 
+     static boolean prime(long n) 
+	    { 
+	        if (n <= 1) 
+	            return false; 
+	        if (n <= 3) 
+	            return true; 
+	        if (n % 2 == 0 || n % 3 == 0) 
+	            return false; 
+	        double sq=Math.sqrt(n);
+	  
+	        for (int i = 5; i <= sq; i = i + 6) 
+	            if (n % i == 0 || n % (i + 2) == 0) 
+	                return false; 
+	        return true; 
+	    } 
+     static int gcd(int a, int b) 
+     { 
+         if (a == 0) 
+             return b; 
+         return gcd(b % a, a); 
+     } 
+     static long gcd(long a, long b) 
+     { 
+         if (a == 0) 
+             return b; 
+         return gcd(b % a, a); 
+     } 
+     
+        
+    static class FastReader 
+    { 
+        BufferedReader br; 
+        StringTokenizer st; 
+  
+        public FastReader() 
+        { 
+            br = new BufferedReader(new
+                     InputStreamReader(System.in)); 
+        } 
+  
+        String next() 
+        { 
+            while (st == null || !st.hasMoreElements()) 
+            { 
+                try
+                { 
+                    st = new StringTokenizer(br.readLine()); 
+                } 
+                catch (IOException  e) 
+                { 
+                    e.printStackTrace(); 
+                } 
+            } 
+            return st.nextToken(); 
+        } 
+  
+        int nextInt() 
+        { 
+            return Integer.parseInt(next()); 
+        } 
+  
+        long nextLong() 
+        { 
+            return Long.parseLong(next()); 
+        } 
+  
+        double nextDouble() 
+        { 
+            return Double.parseDouble(next()); 
+        } 
+  
+        String nextLine() 
+        { 
+            String str = """"; 
+            try
+            { 
+                str = br.readLine(); 
+            } 
+            catch (IOException e) 
+            { 
+                e.printStackTrace(); 
+            } 
+            return str; 
+        } 
+    } 
+} 
+
+
+
+","import java.util.*;
+import java.io.*;
+
+public class Codeforces {
+    final static long mod = 1000000007;
+
+    public static void main(String[] args) {
+        FastReader sc = new FastReader();
+        int t = sc.nextInt();
+        while(t-->0){
+           int n=sc.nextInt();
+           int m=sc.nextInt();
+           int x=sc.nextInt();
+           
+           Pair a[]=new Pair[n];
+           
+           for(int i=0;i<n;i++){
+               a[i]=new Pair(sc.nextInt(), i+1);
+           }
+           
+           Arrays.sort(a);
+           
+           int b[]=new int[n+1];
+           int k=m;
+           
+           for(int i=n-1;i>=0;i--){
+               b[a[i].y]=k;
+               k--;
+               if(k==0)
+                k=m;
+           }
+           
+           System.out.println(""YES"");
+           for(int i=1;i<=n;i++){
+               System.out.print(b[i]+"" "");
+           }
+           System.out.println();
+           
+        }
+    }
+    
+    static long modulo(long a,long b){
+        //Modulo function takes case of modulus work if the remainder comes out to be negative in some case
+        long c=a%b;
+        return c<0?c+b:c; 
+    }
+    static class FastReader {
+
+        BufferedReader br;
+        StringTokenizer st; // StringTokenizer() is used to read long strings
+
+        public FastReader() {
+            br = new BufferedReader(new InputStreamReader(System.in));
+        }
+
+        String next() {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+
+        String nextLine() {
+            String str = """";
+            try {
+                str = br.readLine();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+        }
+    }
+
+    static class Pair implements Comparable<Pair> {
+        public final int x;
+        public final int y;
+
+        public Pair(int x, int y) {
+            this.x = x;
+            this.y = y;
+        }
+
+        
+        @Override
+		public int compareTo(Pair o) {
+			if(this.x>o.x)
+				return 1;
+			else if(this.x<o.x)
+				return -1;
+			else {
+				if(this.y>o.y)
+					return 1;
+				else if(this.y<o.y)
+					return -1;
+				else
+					return 0;
+			}
+		}
+    }
+
+    static String reverseString(String str) {
+        StringBuilder input = new StringBuilder();
+        return input.append(str).reverse().toString();
+    }
+
+    static long factorial(int n, int b) {
+        if (n == b)
+            return 1;
+
+        return n * factorial(n - 1, b);
+    }
+
+    static int lcm(int ch, int b) {
+        return ch * b / gcd(ch, b);
+    }
+
+    static int gcd(int ch, int b) {
+        return b == 0 ? ch : gcd(b, ch % b);
+    }
+
+    static double ceil(double n, double k) {
+        return Math.ceil(n / k);
+    }
+
+    static int sqrt(double n) {
+        return (int) Math.sqrt(n);
+    }
+
+}",1
+3e93b259,9d753699,"import java.util.*;
+import java.io.*;
+public class Main
+{
+    static class FastReader 
+    { 
+        BufferedReader br; 
+        StringTokenizer st; 
+  
+        public FastReader() 
+        { 
+            br = new BufferedReader(new
+                     InputStreamReader(System.in)); 
+        } 
+  
+        String next() 
+        { 
+            while (st == null || !st.hasMoreElements()) 
+            { 
+                try
+                { 
+                    st = new StringTokenizer(br.readLine()); 
+                } 
+                catch (IOException  e) 
+                { 
+                    e.printStackTrace(); 
+                } 
+            } 
+            return st.nextToken(); 
+        } 
+  
+        int nextInt() 
+        { 
+            return Integer.parseInt(next()); 
+        } 
+  
+        long nextLong() 
+        { 
+            return Long.parseLong(next()); 
+        } 
+  
+        double nextDouble() 
+        { 
+            return Double.parseDouble(next()); 
+        } 
+  
+        String nextLine() 
+        { 
+            String str = """"; 
+            try
+            { 
+                str = br.readLine(); 
+            } 
+            catch (IOException e) 
+            { 
+                e.printStackTrace(); 
+            } 
+            return str; 
+        } 
+    }
+    static class Pair implements Comparable<Pair>
+    {
+        int f,s;
+        Pair(int f,int s)
+        {
+            this.f=f;
+            this.s=s;
+        }
+        public int compareTo(Pair p)
+        {
+            return this.f-p.f;
+        }
+    }
+    public static void main(String args[])
+    {
+        FastReader fs=new FastReader();
+        PrintWriter pw=new PrintWriter(System.out);
+        int tc=fs.nextInt();
+        while(tc-->0)
+        {
+            int n=fs.nextInt();
+            long a[]=new long[n];
+            for(int i=0;i<n;i++)
+            a[i]=fs.nextLong();
+            long minans=a[0]*n+a[1]*n;
+            long sum=a[0]+a[1];
+            long min1=a[0],min2=a[1];
+            for(int i=2;i<n;i++)
+            {
+                sum+=a[i];
+                if(i%2==0)
+                min1=Math.min(min1,a[i]);
+                else
+                min2=Math.min(min2,a[i]);
+                long tsum=sum-min1-min2;
+                if(i%2==0)
+                tsum=tsum+(n-i/2+1)*min2+(n-i/2)*min1;
+                else
+                tsum=tsum+(min1+min2)*(n-((i+1)/2)+1);
+                
+                minans=Math.min(minans,tsum);
+                //minans=Math.min(minans,(n-cnt1)*a[i]+(n-cnt2)*a[i-1]+sum);
+            }
+            pw.println(minans);
+        }
+        pw.flush();
+        pw.close();
+    }
+}","/**
+ * Created by Himanshu
+ **/
+
+import java.util.*;
+import java.io.*;
+import java.math.*;
+
+public class C1499 {
+    public static void main(String[] args) throws IOException {
+        PrintWriter out = new PrintWriter(System.out);
+        Reader s = new Reader();
+        int t = s.i();
+        while (t-- > 0) {
+            int n = s.i();
+            long [] arr = s.arrLong(n);
+            long odd = arr[1] , even = arr[0];
+            long [] a = new long[n];
+            a[0] = arr[0]*n;
+            a[1] = arr[1]*n;
+            int in1 = 0 , in2 = 1;
+            long ans = a[0]+a[1];
+            for (int i=2;i<n;i++) {
+                if (i%2 == 0) {
+                    long val = even + (n-i/2)*arr[i];
+                    long val2 = a[i-2] - arr[in1] + arr[i];
+                    if (val < val2) in1 = i;
+                    a[i] = Math.min(val2,val);
+                    even += arr[i];
+                } else {
+                    long val = odd + (n-i/2)*arr[i];
+                    long val2 = a[i-2] - arr[in2] + arr[i];
+                    if (val < val2) in2 = i;
+                    a[i] = Math.min(val2,val);
+                    odd += arr[i];
+                }
+                ans = Math.min(ans,a[i]+a[i-1]);
+            }
+            out.println(ans);
+        }
+        out.flush();
+    }
+
+    public static void shuffle(long[] arr) {
+        int n = arr.length;
+        Random rand = new Random();
+        for (int i = 0; i < n; i++) {
+            long temp = arr[i];
+            int randomPos = i + rand.nextInt(n - i);
+            arr[i] = arr[randomPos];
+            arr[randomPos] = temp;
+        }
+    }
+
+    private static int gcd(int a, int b) {
+        if(b == 0) return a;
+        return gcd(b,a%b);
+    }
+
+    public static long nCr(long[] fact, long[] inv, int n, int r, long mod) {
+        if (n < r)
+            return 0;
+        return ((fact[n] * inv[n - r]) % mod * inv[r]) % mod;
+    }
+
+    private static void factorials(long[] fact, long[] inv, long mod, int n) {
+        fact[0] = 1;
+        inv[0] = 1;
+        for (int i = 1; i <= n; ++i) {
+            fact[i] = (fact[i - 1] * i) % mod;
+            inv[i] = power(fact[i], mod - 2, mod);
+        }
+    }
+
+    private static long power(long a, long n, long p) {
+        long result = 1;
+        while (n > 0) {
+            if (n % 2 == 0) {
+                a = (a * a) % p;
+                n /= 2;
+            } else {
+                result = (result * a) % p;
+                n--;
+            }
+        }
+        return result;
+    }
+
+    private static long power(long a, long n) {
+        long result = 1;
+        while (n > 0) {
+            if (n % 2 == 0) {
+                a = (a * a);
+                n /= 2;
+            } else {
+                result = (result * a);
+                n--;
+            }
+        }
+        return result;
+    }
+
+    private static long query(long[] tree, int in, int start, int end, int l, int r) {
+        if (start >= l && r >= end) return tree[in];
+        if (end < l || start > r) return 0;
+        int mid = (start + end) / 2;
+        long x = query(tree, 2 * in, start, mid, l, r);
+        long y = query(tree, 2 * in + 1, mid + 1, end, l, r);
+        return x + y;
+    }
+
+    private static void update(int[] arr, long[] tree, int in, int start, int end, int idx, int val) {
+        if (start == end) {
+            tree[in] = val;
+            arr[idx] = val;
+            return;
+        }
+        int mid = (start + end) / 2;
+        if (idx > mid) update(arr, tree, 2 * in + 1, mid + 1, end, idx, val);
+        else update(arr, tree, 2 * in, start, mid, idx, val);
+        tree[in] = tree[2 * in] + tree[2 * in + 1];
+    }
+
+    private static void build(int[] arr, long[] tree, int in, int start, int end) {
+        if (start == end) {
+            tree[in] = arr[start];
+            return;
+        }
+        int mid = (start + end) / 2;
+        build(arr, tree, 2 * in, start, mid);
+        build(arr, tree, 2 * in + 1, mid + 1, end);
+        tree[in] = (tree[2 * in + 1] + tree[2 * in]);
+    }
+
+    static class Reader {
+        private InputStream mIs;
+        private byte[] buf = new byte[1024];
+        private int curChar, numChars;
+
+        public Reader() {
+            this(System.in);
+        }
+
+        public Reader(InputStream is) {
+            mIs = is;
+        }
+
+        public int read() {
+            if (numChars == -1) throw new InputMismatchException();
+            if (curChar >= numChars) {
+                curChar = 0;
+                try {
+                    numChars = mIs.read(buf);
+                } catch (IOException e) {
+                    throw new InputMismatchException();
+                }
+                if (numChars <= 0) return -1;
+            }
+            return buf[curChar++];
+        }
+
+        public String nextLine() {
+            int c = read();
+            while (isSpaceChar(c)) c = read();
+            StringBuilder res = new StringBuilder();
+            do {
+                res.appendCodePoint(c);
+                c = read();
+            } while (!isEndOfLine(c));
+            return res.toString();
+        }
+
+        public String s() {
+            int c = read();
+            while (isSpaceChar(c)) c = read();
+            StringBuilder res = new StringBuilder();
+            do {
+                res.appendCodePoint(c);
+                c = read();
+            } while (!isSpaceChar(c));
+            return res.toString();
+        }
+
+        public long l() {
+            int c = read();
+            while (isSpaceChar(c)) c = read();
+            int sgn = 1;
+            if (c == '-') {
+                sgn = -1;
+                c = read();
+            }
+            long res = 0;
+            do {
+                if (c < '0' || c > '9') throw new InputMismatchException();
+                res *= 10;
+                res += c - '0';
+                c = read();
+            } while (!isSpaceChar(c));
+            return res * sgn;
+        }
+
+        public int i() {
+            int c = read();
+            while (isSpaceChar(c)) c = read();
+            int sgn = 1;
+            if (c == '-') {
+                sgn = -1;
+                c = read();
+            }
+            int res = 0;
+            do {
+                if (c < '0' || c > '9') throw new InputMismatchException();
+                res *= 10;
+                res += c - '0';
+                c = read();
+            } while (!isSpaceChar(c));
+            return res * sgn;
+        }
+
+        public double d() throws IOException {
+            return Double.parseDouble(s());
+        }
+
+        public boolean isSpaceChar(int c) {
+            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
+        }
+
+        public boolean isEndOfLine(int c) {
+            return c == '\n' || c == '\r' || c == -1;
+        }
+
+        public int[] arr(int n) {
+            int[] ret = new int[n];
+            for (int i = 0; i < n; i++) {
+                ret[i] = i();
+            }
+            return ret;
+        }
+
+        public long[] arrLong(int n) {
+            long[] ret = new long[n];
+            for (int i = 0; i < n; i++) {
+                ret[i] = l();
+            }
+            return ret;
+        }
+    }
+//    static class pairLong implements Comparator<pairLong> {
+//        long first, second;
+//
+//        pairLong() {
+//        }
+//
+//        pairLong(long first, long second) {
+//            this.first = first;
+//            this.second = second;
+//        }
+//
+//        @Override
+//        public int compare(pairLong p1, pairLong p2) {
+//            if (p1.first == p2.first) {
+//                if(p1.second > p2.second) return 1;
+//                else return -1;
+//            }
+//            if(p1.first > p2.first) return 1;
+//            else return -1;
+//        }
+//    }
+//    static class pair implements Comparator<pair> {
+//        int first, second;
+//
+//        pair() {
+//        }
+//
+//        pair(int first, int second) {
+//            this.first = first;
+//            this.second = second;
+//        }
+//
+//        @Override
+//        public int compare(pair p1, pair p2) {
+//            if (p1.first == p2.first) return p1.second - p2.second;
+//            return p1.first - p2.first;
+//        }
+//    }
+}
+
+",0
+72d4d693,ad2a1ae2,"/* package codechef; // don't place package name! */
+
+import java.util.*;
+import java.lang.*;
+import java.io.*;
+
+
+
+
+public class Codechef
+{
+    
+      static class FastReader 
+    { 
+        BufferedReader br; 
+        StringTokenizer st; 
+  
+        public FastReader() 
+        { 
+            try {
+               br=new BufferedReader(new FileReader(""input.txt""));
+               PrintStream out= new PrintStream(new FileOutputStream(""output.txt""));
+               System.setOut(out);
+            }
+  
+            // Catch block to handle the exceptions
+            catch (Exception e) {
+                br=new BufferedReader(new InputStreamReader(System.in));
+            }
+        } 
+  
+        String next() 
+        { 
+            while (st == null || !st.hasMoreElements()) 
+            { 
+                try
+                { 
+                    st = new StringTokenizer(br.readLine()); 
+                } 
+                catch (IOException  e) 
+                { 
+                    e.printStackTrace(); 
+                } 
+            } 
+            return st.nextToken(); 
+        } 
+  
+        int nextInt() 
+        { 
+            return Integer.parseInt(next()); 
+        } 
+  
+        long nextLong() 
+        { 
+            return Long.parseLong(next()); 
+        } 
+  
+        double nextDouble() 
+        { 
+            return Double.parseDouble(next()); 
+        } 
+  
+        String nextLine() 
+        { 
+            String str = """"; 
+            try
+            { 
+                str = br.readLine(); 
+            } 
+            catch (IOException e) 
+            { 
+                e.printStackTrace(); 
+            } 
+            return str; 
+        } 
+    } 
+     static int computeXOR(int n)
+    {
+        // If n is a multiple of 4
+        if (n % 4 == 0)
+            return n;
+      
+        // If n%4 gives remainder 1
+        if (n % 4 == 1)
+            return 1;
+      
+        // If n%4 gives remainder 2
+        if (n % 4 == 2)
+            return n + 1;
+      
+        // If n%4 gives remainder 3
+        return 0;
+    }
+    public static void main (String[] args) throws java.lang.Exception
+    {
+ 
+       try{
+        FastReader sc=new FastReader();
+        BufferedWriter out = new BufferedWriter(
+            new OutputStreamWriter(System.out));
+        int t=sc.nextInt();
+        while(t-->0)
+        {
+            
+            int n = sc.nextInt();
+            
+            int k[] = new int[n];
+            for(int i=0;i<n;i++)
+            {
+                k[i] = sc.nextInt();
+            }
+            int h[] = new int[n];
+            for(int i=0;i<n;i++)
+            {
+                h[i] = sc.nextInt();
+            }
+            
+            
+        long tail = k[n-1];
+        long span = h[n-1];
+            
+            long ans = 0;
+            
+            for(int i=n-2;i>=0;i--)
+            {
+                if((tail-span)+1>k[i])
+                {
+                    ans+=(span*(span+1))/2;
+                    tail=k[i];
+                    span=h[i];
+                }
+                else if((tail-span)+1<=((k[i]-h[i])+1))
+                {
+                    continue;
+                }
+                else
+                {
+                    span+=(((tail-span)+1) - ((k[i]-h[i])+1));
+                }
+            }
+            
+            ans+=(span*(span+1))/2;
+            
+            System.out.println(ans);
+            
+        }
+    }catch(Exception e){
+            return;
+        }
+    }
+}
+
+","
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.*;
+import java.util.StringTokenizer;
+ 
+public class Solution {
+	 static class FastReader {
+	        BufferedReader br;
+	        StringTokenizer st;
+	 
+	        public FastReader()
+	        {
+	            br = new BufferedReader(
+	                new InputStreamReader(System.in));
+	        }
+	 
+	        String next()
+	        {
+	            while (st == null || !st.hasMoreElements()) {
+	                try {
+	                    st = new StringTokenizer(br.readLine());
+	                }
+	                catch (IOException e) {
+	                    e.printStackTrace();
+	                }
+	            }
+	            return st.nextToken();
+	        }
+	 
+	        int nextInt() { return Integer.parseInt(next()); }
+	 
+	        long nextLong() { return Long.parseLong(next()); }
+	 
+	        double nextDouble()
+	        {
+	            return Double.parseDouble(next());
+	        }
+	 
+	        String nextLine()
+	        {
+	            String str = """";
+	            try {
+	                str = br.readLine();
+	            }
+	            catch (IOException e) {
+	                e.printStackTrace();
+	            }
+	            return str;
+	        }}
+	 
+	public static void main(String[] args) {
+		FastReader sc = new FastReader();
+       
+        int t=sc.nextInt();
+       while(t-->0) {
+    	   int n=sc.nextInt();
+    	   int r[]=new int[n];
+    	   int l[]=new int[n];
+    	   for(int i=0;i<n;i++) {
+    		   r[i]=sc.nextInt();
+    	   }
+    	   for(int i=0;i<n;i++) l[i]=r[i]-sc.nextInt()+1;
+    	   long ans=0,min=l[n-1],max=r[n-1];
+    	   
+    	   for(int i=n-2;i>=0;i--) {
+    		   if(r[i]>=min) min=Math.min(min,l[i]);
+    		   else {
+    			   ans+=(max-min+1)*(max-min+2)/2;
+    			   max=r[i];
+    			   min=l[i];
+    		   }
+    		   
+    	   }
+    	   ans+=(max-min+1)*(max-min+2)/2;
+    	   System.out.println(ans);
+    	   
+    	   
+       }
+}	
+}
+",0
+aa8091b0,eec856c0,"import java.util.*;
+ 
+import java.io.*;
+ 
+public class AiseHi {
+	static Scanner sc = new Scanner(System.in);
+	static int mod = (int)(1e9+7);
+	public static void main (String[] args) {
+		PrintWriter out = new PrintWriter(System.out);
+		int t = 1;
+    	t = sc.nextInt();
+    	z : while(t-->0) {
+    		int n = sc.nextInt();
+    		int m = sc.nextInt();
+    		int x = sc.nextInt();
+    		PriorityQueue<twoval> myQueue = new PriorityQueue<>();
+    		for(int i=1;i<=m;i++) {
+    			myQueue.add(new twoval(0,i));
+    		}
+    		List<twoval> arrayList = new ArrayList<>();
+    		int myArray[] = new int[n];
+    		for(int i=0;i<n;i++) {
+    			int aasjd = sc.nextInt();
+    			arrayList.add(new twoval(aasjd,i));
+    			myArray[i] = aasjd;
+    		}
+    		Collections.sort(arrayList);
+    		int ans[] = new int[n];
+    		for(int i=n-1;i>=0;i--) {
+    			twoval p = myQueue.poll();
+    			long aasjd = p.myArray;
+    			int idx = p.b;
+    			aasjd += arrayList.get(i).myArray;
+    			ans[arrayList.get(i).b] = idx;
+    			myQueue.add(new twoval(aasjd,idx));
+    		}
+    		long dasdaknw[] = new long[m];
+    		long min = Long.MAX_VALUE, max = Long.MIN_VALUE;
+    		for(int i=0;i<n;i++) {
+    			dasdaknw[ans[i]-1] += myArray[i];
+    		}
+    		for(int i=0;i<m;i++) {
+    			min = Math.min(min, dasdaknw[ans[i]-1]);
+    			max = Math.max(max, dasdaknw[ans[i]-1]);
+    		}
+    		if(max-min>x) {
+    			out.write(""NO\n"");
+    			continue;
+    		}
+    		out.write(""YES\n"");
+    		for(int aasjd : ans) out.write(aasjd+"" "");
+    		out.write(""\n"");
+    	}
+		out.close();
+	}
+	static int ceil(int myArray,int b) {
+		return myArray/b + (myArray%b==0?0:1);
+	}
+	static boolean prime[] = new boolean[2000009];
+	static int fac[] = new int[2000009];
+	
+	static void sieve() {
+		prime[0] = true;
+		prime[1] = true;
+		int max = 1000000;
+		for(int i=2;i*i<=max;i++) {
+			if(!prime[i]) {
+				for(int j=i*i;j<=max;j+=i) {
+					prime[j] = true;
+					fac[j] = i;
+				}
+			}
+		}
+	}
+	static int gcd(int myArray,int b) { if(b==0) return myArray; return gcd(b,myArray%b); }
+}
+ 
+class twoval implements Comparable<twoval>{
+	long myArray;
+	int b;
+	twoval(long aasjd,int r){
+		this.myArray = aasjd;
+		this.b = r;
+	}
+	public int compareTo(twoval o) {
+		return (int) (this.myArray - o.myArray);
+	}
+}
+","import java.io.*;
+import java.util.*;
+ 
+public class Main {
+	static class FastReader{ 
+        BufferedReader br; 
+        StringTokenizer st; 
+        public FastReader(){br = new BufferedReader(new InputStreamReader(System.in));}
+        String next(){while (st == null || !st.hasMoreElements()){try{st = new StringTokenizer(br.readLine());} 
+        catch (IOException  e){e.printStackTrace();}}return st.nextToken();}
+        int nextInt(){ return Integer.parseInt(next());}long nextLong(){return Long.parseLong(next());}double nextDouble(){return Double.parseDouble(next());}
+        String nextLine(){String str = """"; try{str = br.readLine(); } catch (IOException e) {e.printStackTrace();} return str; } 
+    }
+	static FastReader sc = new FastReader();
+	static long mod = (long) (1e9+7);
+	static boolean spe[];
+	static int spen[];
+	static int dep[];
+	static List<Integer> tre[];
+	static int par[][];
+	public static void main (String[] args){
+        PrintWriter out = new PrintWriter(System.out);
+        int t = 1;
+        t = sc.nextInt();
+        z :for(int tc=1;tc<=t;tc++){
+    		int n = sc.nextInt();
+    		int m = sc.nextInt();
+    		int x = sc.nextInt();
+    		PriorityQueue<pairClass> priority = new PriorityQueue<>();
+    		for(int i=1;i<=m;i++) {
+    			priority.add(new pairClass(0,i));
+    		}
+    		List<pairClass> list = new ArrayList<>();
+    		int a[] = new int[n];
+    		for(int i=0;i<n;i++) {
+    			int value = sc.nextInt();
+    			list.add(new pairClass(value,i));
+    			a[i] = value;
+    		}
+    		Collections.sort(list);
+    		int answer[] = new int[n];
+    		for(int i=n-1;i>=0;i--) {
+    			pairClass p = priority.poll();
+    			long value = p.a;
+    			int idx = p.b;
+    			value += list.get(i).a;
+    			answer[list.get(i).b] = idx;
+    			priority.add(new pairClass(value,idx));
+    		}
+    		long totalSum[] = new long[m];
+    		long min = Long.MAX_VALUE, max = Long.MIN_VALUE;
+    		for(int i=0;i<n;i++) {
+    			totalSum[answer[i]-1] += a[i];
+    		}
+    		for(int i=0;i<m;i++) {
+    			min = Math.min(min, totalSum[answer[i]-1]);
+    			max = Math.max(max, totalSum[answer[i]-1]);
+    		}
+    		if(max-min>x) {
+    			out.write(""NO\n"");
+    			continue;
+    		}
+    		out.write(""YES\n"");
+    		for(int value : answer) out.write(value+"" "");
+    		out.write(""\n"");
+        }
+		out.close();
+	}
+}
+class pairClass implements Comparable<pairClass>{
+	long a;
+	int b;
+	pairClass(long value,int r){
+		this.a = value;
+		this.b = r;
+	}
+	@Override
+	public int compareTo(pairClass o) {
+		return (int) (this.a - o.a);
+	}
+}
+",1
+0e68e463,2120328e,"import java.io.*;
+import java.util.*;
+
+import static java.lang.Math.*;
+
+public class D {
+    public static void main(String[] args) {
+        Scanner in = new Scanner(System.in);
+        PrintWriter pw = new PrintWriter(System.out);
+        int t = in.nextInt();
+        for(int tt = 0; tt < t; tt++) {
+            int n = in.nextInt();
+            long[] arr = new long[n];
+            for (int i = 0; i < n; i++) arr[i] = in.nextLong();
+            char[] s = in.next().toCharArray();
+            if (solve(arr, n, s))pw.println(""YES"");
+            else pw.println(""NO"");
+        }
+        pw.close();
+    }
+    static boolean solve(long[] arr, int n, char[] s) {
+        ArrayList<Long> B = new ArrayList<>();
+        ArrayList<Long> R = new ArrayList<>();
+        for(int i = 0; i < n; i++) {
+            if (s[i] == 'B') B.add(arr[i]);
+            else R.add(arr[i]);
+        }
+        Collections.sort(B);
+        Collections.sort(R);
+      //  debug(B);
+        long last = n;
+        for (int i = R.size() - 1; i >= 0; i--) {
+            long v = R.get(i);
+            if (v > last) {
+               return false;
+            }
+            last--;
+        }
+        long first = 1;
+        int size = B.size();
+        for (int i = 0; i < size; i++) {
+            long v = B.get(i);
+         //   debug(v, first);
+            if (v < first) return false;
+            first++;
+        }
+        return true;
+    }
+
+
+    static void debug(Object... obj) {
+        System.err.println(Arrays.deepToString(obj));
+    }
+}
+","/*****  --->         :)    Vijender  Srivastava      (:       <---       *****/
+import java.util.*;
+import java.lang.*;
+import java.io.*;
+public class Main  
+{
+    static FastReader sc =new FastReader();
+    static PrintWriter out=new PrintWriter(System.out);
+    static int mod=10000007;
+   static StringBuilder sb=new StringBuilder();
+    /* start */
+       public static void main(String [] args)
+    {
+            int t = i();
+            while(t-->0)
+            {
+                int n = i();
+                int a[] = input(n);
+                char c[] = inputC();
+                ArrayList<Integer> b = new ArrayList<>();
+                ArrayList<Integer> r = new ArrayList<>();
+                for(int i=0;i<n;i++)
+                {
+                    if(c[i]=='R')
+                    r.add(a[i]);
+                    else 
+                    b.add(a[i]);
+                }
+                Collections.sort(b);
+                Collections.sort(r,Collections.reverseOrder());
+                boolean is = true;
+                int cnt = 1;
+                for(int i=0;i<b.size();i++)
+                {
+                    if(b.get(i)<cnt)
+                    {
+                        is = false;
+                        break;
+                    }
+                    cnt++;
+                }
+                for(int i=0;i<r.size();i++)
+                {
+                    if(r.get(i)>n-i)
+                    {
+                        is = false;
+                        break;
+                    }
+                }
+
+                out.println(is==true?""YES"":""NO"");
+            }
+            out.close();
+    }
+
+    
+    /* end */
+    static class FastReader 
+    { 
+        BufferedReader br; 
+        StringTokenizer st; 
+
+        public FastReader() 
+        { 
+            br = new BufferedReader(new
+                     InputStreamReader(System.in)); 
+        } 
+
+        String next() 
+        { 
+            while (st == null || !st.hasMoreElements()) 
+            { 
+                try
+                { 
+                    st = new StringTokenizer(br.readLine()); 
+                } 
+                catch (IOException  e) 
+                { 
+                    e.printStackTrace(); 
+                } 
+            } 
+            return st.nextToken(); 
+        } 
+
+        int nextInt() 
+        { 
+            return Integer.parseInt(next()); 
+        } 
+
+        long nextLong() 
+        { 
+            return Long.parseLong(next()); 
+        } 
+
+        double nextDouble() 
+        { 
+            return Double.parseDouble(next()); 
+        } 
+
+        String nextLine() 
+        { 
+            String str = """"; 
+            try
+            { 
+                str = br.readLine(); 
+            } 
+            catch (IOException e) 
+            { 
+                e.printStackTrace(); 
+            } 
+            return str; 
+        } 
+    } 
+
+    
+    static int i() {
+        return sc.nextInt();
+    }
+
+    static String s() {
+        return sc.next();
+    }
+
+    static long l() {
+        return sc.nextLong();
+    }
+
+    static char[] inputC()
+    {
+        String s = sc.nextLine();
+        return s.toCharArray();
+    }
+
+    static int[] input(int n) {
+        int A[]=new int[n];
+           for(int i=0;i<n;i++) {
+               A[i]=sc.nextInt();
+           }
+        return A;
+    }
+
+    static long[] inputL(int n) {
+        long A[]=new long[n];
+           for(int i=0;i<n;i++) {
+               A[i]=sc.nextLong();
+           }
+           return A;
+    }
+
+    static long[] putL(long a[]) {
+        long A[]=new long[a.length];
+           for(int i=0;i<a.length;i++) {
+               A[i]=a[i];
+           }
+           return A;
+    }
+
+    static String[] inputS(int n) {
+        String A[]=new String[n];
+           for(int i=0;i<n;i++) {
+               A[i]=sc.next();
+           }
+           return A;
+    }
+      
+    static int gcd(int a, int b) 
+     { 
+         if (a == 0) 
+             return b; 
+         return gcd(b % a, a); 
+     } 
+
+     static long gcd(long a, long b) 
+     { 
+         if (a == 0) 
+             return b; 
+         return gcd(b % a, a); 
+     } 
+
+     
+    
+     static String reverse(String s) {
+        StringBuffer p=new StringBuffer(s);
+        p.reverse();
+        return p.toString();
+     }
+
+     static int min(int a,int b) {
+        return Math.min(a, b);
+    }
+    static int min(int a,int b,int c) {
+        return Math.min(a, Math.min(b, c));
+    }
+    static int min(int a,int b,int c,int d) {
+        return Math.min(a, Math.min(b, Math.min(c, d)));
+    }
+
+    static int max(int a,int b) {
+        return Math.max(a, b);
+    }
+    static int max(int a,int b,int c) {
+        return Math.max(a, Math.max(b, c));
+    }
+    static int max(int a,int b,int c,int d) {
+        return Math.max(a, Math.max(b, Math.max(c, d)));
+    }
+    static long min(long a,long b) {
+        return Math.min(a, b);
+    }
+    static long min(long a,long b,long c) {
+        return Math.min(a, Math.min(b, c));
+    }
+    static long min(long a,long b,long c,long d) {
+        return Math.min(a, Math.min(b, Math.min(c, d)));
+    }
+    static long max(long a,long b) {
+        return Math.max(a, b);
+    }
+    static long max(long a,long b,long c) {
+        return Math.max(a, Math.max(b, c));
+    }
+    static long max(long a,long b,long c,long d) {
+        return Math.max(a, Math.max(b, Math.max(c, d)));
+    }
+
+    static long sum(int A[]) {
+        long sum=0;
+        for(int i : A) {
+            sum+=i;
+        }
+        return sum;
+    }
+
+    static long sum(long A[]) {
+        long sum=0;
+        for(long i : A) {
+            sum+=i;
+        }
+        return sum;
+    }
+
+    static void print(int A[]) {
+        for(int i : A) {
+            System.out.print(i+"" "");
+        }
+        System.out.println();
+    }
+
+    static void print(long A[]) {
+        for(long i : A) {
+            System.out.print(i+"" "");
+        }
+        System.out.println();
+    }
+
+    static long mod(long x) {
+          return ((x%mod + mod)%mod);
+    }
+
+    static long power(long x, long y)
+    {
+
+	if(y==0)
+		return 1;
+	if(x==0)
+		return 0;
+    long res = 1;
+    while (y > 0) {
+
+        if (y % 2 == 1)
+            res = (res * x) ;
+
+        y = y >> 1; 
+        x = (x * x);
+    }
+
+    return res;
+    }
+
+    static boolean prime(int n) 
+	    { 
+	        if (n <= 1) 
+	            return false; 
+	        if (n <= 3) 
+	            return true; 
+	        if (n % 2 == 0 || n % 3 == 0) 
+	            return false; 
+	        double sq=Math.sqrt(n);
+	  
+	        for (int i = 5; i <= sq; i = i + 6) 
+	            if (n % i == 0 || n % (i + 2) == 0) 
+	                return false; 
+	        return true; 
+	    } 
+
+     static boolean prime(long n) 
+	    { 
+	        if (n <= 1) 
+	            return false; 
+	        if (n <= 3) 
+	            return true; 
+	        if (n % 2 == 0 || n % 3 == 0) 
+	            return false; 
+	        double sq=Math.sqrt(n);
+	  
+	        for (int i = 5; i <= sq; i = i + 6) 
+	            if (n % i == 0 || n % (i + 2) == 0) 
+	                return false; 
+	        return true; 
+	    } 
+        //pair class
+        private static class Pair implements Comparable<Pair> {
+            int first, second;
+            public Pair(int f, int s) {
+                first = f;
+                second = s;
+            }
+            @Override
+            public int compareTo(Pair p) {
+                if (first > p.first)
+                    return 1;
+                else if (first < p.first)
+                    return -1;
+                else {
+                    if (second > p.second)
+                        return 1;
+                    else if (second < p.second)
+                        return -1;
+                    else
+                        return 0;
+                }
+            }
+     
+        }
+}",0
+29cf2e70,584b0e9e,"import java.util.*;
+import java.io.*;
+ 
+public class D {
+    public static void main(String[] args) {
+        Scanner in = new Scanner(System.in);
+        
+        int T = in.nextInt();
+        while(T-- > 0) {
+            int n = in.nextInt();
+            int[] a = new int[n];
+            for(int j=0;j<n;j++) a[j] = in.nextInt();
+            char[] s = in.next().toCharArray();
+ 
+            List<Integer> blue = new ArrayList<>();
+            List<Integer> red = new ArrayList<>();
+            for(int j=0;j<n;j++) {
+                if(s[j] == 'B') blue.add(a[j]);
+                else red.add(a[j]);
+            }
+ 
+            Collections.sort(blue);
+            Collections.sort(red);
+ 
+            boolean p = true;
+            int cur = 1;
+            for(int val : blue) {
+                if(val<cur) {
+                    p = false;
+                    break;
+                }
+                else cur++;
+            }
+            for(int val : red) {
+                if(val>cur) {
+                    p = false;
+                    break;
+                }
+                else cur++;
+            }
+            
+            if(p) System.out.println(""yes"");
+            else System.out.println(""no"");
+        }
+    }
+}
+","
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.math.BigInteger;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.BitSet;
+import java.util.Calendar;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.PriorityQueue;
+import java.util.SortedSet;
+import java.util.Stack;
+import java.util.StringTokenizer;
+import java.util.TreeMap;
+import java.util.TreeSet;
+
+public class D_Round_753_Div3 {
+    public static int MOD = 1000000007;
+
+    static int[][] dp;
+
+
+    public static void main(String[] args) throws FileNotFoundException {
+        // PrintWriter out = new PrintWriter(new FileOutputStream(new File(
+        // ""output.txt"")));
+        PrintWriter out = new PrintWriter(System.out);
+        Scanner in = new Scanner();
+        int T = in.nextInt();
+        for (int z = 0; z < T; z++) {
+            int n = in.nextInt();
+            int[] data = new int[n];
+            for (int i = 0; i < n; i++) {
+                data[i] = in.nextInt();
+            }
+            String line = in.next();
+            ArrayList<Integer> blue = new ArrayList<>();
+            ArrayList<Integer> red = new ArrayList<>();
+            for (int i = 0; i < n; i++) {
+                if (line.charAt(i) == 'B') {
+                    blue.add(data[i]);
+                } else {
+                    red.add(data[i]);
+                }
+            }
+            Collections.sort(blue);
+            Collections.sort(red);
+            int st = 1;
+            boolean ok = true;
+            for (int i : blue) {
+                if (i < st) {
+                    ok = false;
+                    break;
+                }
+                st++;
+            }
+            if (ok) {
+                for (int i : red) {
+                    if (i > st) {
+                        ok = false;
+                        break;
+                    }
+                    st++;
+                }
+            }
+            out.println(ok ? ""Yes"" : ""No"");
+        }
+        out.close();
+    }
+
+    static int find(int v, int[] u) {
+        if (v == u[v]) {
+            return v;
+        }
+        return u[v] = find(u[v], u);
+    }
+
+
+    static int abs(int a) {
+        return a < 0 ? -a : a;
+    }
+
+
+    public static int[] KMP(String val) {
+        int i = 0;
+        int j = -1;
+        int[] result = new int[val.length() + 1];
+        result[0] = -1;
+        while (i < val.length()) {
+            while (j >= 0 && val.charAt(j) != val.charAt(i)) {
+                j = result[j];
+            }
+            j++;
+            i++;
+            result[i] = j;
+        }
+        return result;
+
+    }
+
+    public static boolean nextPer(int[] data) {
+        int i = data.length - 1;
+        while (i > 0 && data[i] < data[i - 1]) {
+            i--;
+        }
+        if (i == 0) {
+            return false;
+        }
+        int j = data.length - 1;
+        while (data[j] < data[i - 1]) {
+            j--;
+        }
+        int temp = data[i - 1];
+        data[i - 1] = data[j];
+        data[j] = temp;
+        Arrays.sort(data, i, data.length);
+        return true;
+    }
+
+    public static int digit(long n) {
+        int result = 0;
+        while (n > 0) {
+            n /= 10;
+            result++;
+        }
+        return result;
+    }
+
+    public static double dist(long a, long b, long x, long y) {
+        double val = (b - a) * (b - a) + (x - y) * (x - y);
+        val = Math.sqrt(val);
+        double other = x * x + a * a;
+        other = Math.sqrt(other);
+        return val + other;
+
+    }
+
+    public static class Point {
+
+        int x;
+        int y;
+
+        public Point(int start, int end) {
+            this.x = start;
+            this.y = end;
+        }
+
+        public String toString() {
+            return x + "" "" + y;
+        }
+
+    }
+
+    public static class FT {
+
+        long[] data;
+
+        FT(int n) {
+            data = new long[n];
+        }
+
+        public void update(int index, long value) {
+            while (index < data.length) {
+                data[index] += value;
+                data[index] %= MOD;
+                index += (index & (-index));
+            }
+        }
+
+        public long get(int index) {
+
+            long result = 0;
+            while (index > 0) {
+                result += data[index];
+                result %= MOD;
+                index -= (index & (-index));
+            }
+            return result;
+
+        }
+    }
+
+    public static long gcd(long a, long b) {
+        if (b == 0) {
+            return a;
+        }
+        return gcd(b, a % b);
+    }
+
+    public static long pow(long a, int b) {
+        if (b == 0) {
+            return 1;
+        }
+        if (b == 1) {
+            return a;
+        }
+
+        long val = pow(a, b / 2);
+        if (b % 2 == 0) {
+            return (val * val);
+        } else {
+            return (val * ((val * a)));
+
+        }
+    }
+
+    static class Scanner {
+
+        BufferedReader br;
+        StringTokenizer st;
+
+        public Scanner() throws FileNotFoundException {
+            // System.setOut(new PrintStream(new BufferedOutputStream(System.out), true));
+            br = new BufferedReader(new InputStreamReader(System.in));
+            //br = new BufferedReader(new InputStreamReader(new FileInputStream(new File(""input.txt""))));
+        }
+
+        public String next() {
+
+            while (st == null || !st.hasMoreTokens()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (Exception e) {
+                    throw new RuntimeException();
+                }
+            }
+            return st.nextToken();
+        }
+
+        public long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        public int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        public double nextDouble() {
+            return Double.parseDouble(next());
+        }
+
+        public String nextLine() {
+            st = null;
+            try {
+                return br.readLine();
+            } catch (Exception e) {
+                throw new RuntimeException();
+            }
+        }
+
+        public boolean endLine() {
+            try {
+                String next = br.readLine();
+                while (next != null && next.trim().isEmpty()) {
+                    next = br.readLine();
+                }
+                if (next == null) {
+                    return true;
+                }
+                st = new StringTokenizer(next);
+                return st.hasMoreTokens();
+            } catch (Exception e) {
+                throw new RuntimeException();
+            }
+        }
+    }
+}",1
+9ab3c0e1,d5fa4746,"//package CF672;
+
+/**
+ * @version 1.0
+ * @Package_Name: CF672
+ * @Author: Redorain
+ * @Date: 2020/9/25 8:47
+ */
+
+import java.util.*;
+
+public class d {
+
+    public static Scanner sc = new Scanner(System.in);
+    public static final int MOD = 998244353;
+    int []f; int [] lf;
+
+    public static int mul(int a, int b) {
+        return (int)((long)a * (long)b % MOD);
+    }
+
+    public static int ksm(int a, int n) {
+        int ans = 1;
+        while(n > 0) {
+            if((n & 1) == 1)
+                ans = mul(a, ans);
+            a = mul(a, a);
+            n >>= 1;
+        }
+        return ans;
+    }
+
+    public int C(int n, int k) {
+        return (k < 0 || k > n) ? 0 : mul(f[n], mul(lf[n - k], lf[k]));
+    }
+
+    public static int inv(int a) {
+        return ksm(a, MOD - 2);
+    }
+
+    public void solve() {
+        int n = sc.nextInt();
+        int k = sc.nextInt();
+        f = new int[n + 42];
+        lf = new int[n + 42];
+        f[0] = lf[0] = 1;
+        for(int i = 1; i < f.length; i++) {
+            f[i] = mul(f[i  - 1], i);
+            lf[i] = mul(lf[i - 1], inv(i));
+        }
+
+        int[] events = new int[2 * n];
+        for(int i = 0; i < n; i++) {
+            int le = sc.nextInt();
+            int ri = sc.nextInt();
+            events[i] = le * 2;
+            events[i + n] = ri * 2 + 1;
+        }
+
+        Arrays.sort(events);
+        int ans = 0, balance = 0;
+        for(int r = 0; r < 2 * n;) {
+            int l = r;
+            while(r < 2 * n && events[l] == events[r]) ++r;
+            int added = r - l;
+            if(events[l] % 2 == 0) {
+                ans += C(balance + added, k);
+                if(ans >= MOD) ans -= MOD;
+                ans += MOD - C(balance, k);
+                if(ans >= MOD) ans -= MOD;
+                balance += added;
+            }
+            else balance -= added;
+        }
+        sc.close();
+        System.out.println(ans);
+    }
+
+    public static void main(String[] args) {
+        (new d()).solve();
+    }
+}","import java.lang.*;
+import java.util.*;
+import java.io.*;
+
+public class Main {
+    static FastScanner in = new FastScanner();
+
+    static final int MOD = 998244353;
+    static int n, k;
+    static int[] fact, invFact;
+
+    static int mul(int a, int b) {
+        return (int)((long)a * (long)b % MOD);
+    }
+
+    static int pow(int a, int p) {
+        int ans = 1;
+        while (p != 0) {
+            if ((p & 1) != 0)
+                ans = mul(ans, a);
+            a = mul(a, a);
+            p >>= 1;
+        }
+        return ans;
+    }
+
+    static int inv(int a) {
+        return pow(a, MOD - 2);
+    }
+
+    static void precalc() {
+        fact = new int[n + 42]; invFact = new int[n + 42];
+        fact[0] = invFact[0] = 1;
+        for (int i = 1; i < fact.length; ++i) {
+            fact[i] = mul(fact[i - 1], i);
+            invFact[i] = mul(invFact[i - 1], inv(i));
+        }
+    }
+
+    static int nCk(int a, int b) {
+        if (b < 0 || a < b)
+            return 0;
+        return mul(fact[a], mul(invFact[a - b], invFact[b]));
+    }
+
+    static void solve() {
+        n = in.nextInt(); k = in.nextInt();
+        precalc();
+        int[] events = new int[2 * n];
+        for (int i = 0; i < n; ++i) {
+            int l = in.nextInt(), r = in.nextInt();
+            events[i] = 2 * l;
+            events[i + n] = 2 * r + 1;
+        }
+        Arrays.sort(events);
+
+        int ans = 0, balance = 0;
+        for (int r = 0; r < 2 * n;) {
+            int l = r;
+            while (r < 2 * n && events[l] == events[r])
+                ++r;
+            int added = r - l;
+
+            if (events[l] % 2 == 0) {
+                ans += nCk(balance + added, k);
+                if (ans >= MOD) ans -= MOD;
+                ans += MOD - nCk(balance, k);
+                if (ans >= MOD) ans -= MOD;
+                balance += added;
+            } else
+                balance -= added;
+        }
+        System.out.println(ans);
+    }
+
+    public static void main(String[] args) {
+        int T = 1;
+        while (T-- > 0)
+            solve();
+    }
+
+    static class Pair<X, Y> {
+        X x;
+        Y y;
+
+        public Pair(X x, Y y) {
+            this.x = x;
+            this.y = y;
+        }
+    }
+}
+
+class FastScanner {
+    BufferedReader br;
+    StringTokenizer st;
+
+    public FastScanner() {
+        br = new BufferedReader(new InputStreamReader(System.in));
+    }
+
+    String next() {
+        while (st == null || !st.hasMoreElements()) {
+            try {
+                st = new StringTokenizer(br.readLine());
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+        }
+        return st.nextToken();
+    }
+
+    int nextInt() {
+        return Integer.parseInt(next());
+    }
+
+    long nextLong() {
+        return Long.parseLong(next());
+    }
+
+    double nextDouble() {
+        return Double.parseDouble(next());
+    }
+
+    String nextLine() {
+        String str = """";
+        try {
+            str = br.readLine();
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        return str;
+    }
+}",1
+4d279121,856a8eda,"import java.util.*;
+import java.io.*;
+        
+@SuppressWarnings(""unchecked"")
+public class Main {
+    public static void main(String args[]) {    
+        FastReader input = new FastReader();
+        PrintWriter out = new PrintWriter(System.out);
+        int t = input.nextInt();
+        while(t-- > 0) {
+        int n = input.nextInt();
+        int m = input.nextInt();
+        int x = input.nextInt();
+        int arr[] = new int[n];
+        for(int i = 0; i < n; i++) arr[i] = input.nextInt(); 
+        PriorityQueue<Pair> queue = new PriorityQueue();
+        out.println(""YES"");
+        int res[] = new int[n];
+        for(int i = 1; i <= m; i++) {
+            queue.add(new Pair(0, i));
+        }
+        for(int i = 0; i < n; i++) {
+            Pair p = queue.remove();
+            out.print(p.second()+"" "");
+            queue.add(new Pair(p.first()+arr[i], p.second()));    
+        }
+        out.println();
+        out.flush();
+        }
+    }   
+}
+ 
+class Pair implements Comparable<Pair> {    
+    public int x;
+    public int y;
+ 
+    public Pair(int x, int y) {
+        this.x = x;
+        this.y = y;
+    }
+ 
+    public int first() {
+        return x;
+    }
+    public int second() {
+        return y;
+    }
+ 
+    public int compareTo(Pair p) {
+        if(this.first() == p.first()) {
+            return 0;
+        }else if(this.first() > p.first()) {
+            return 1;
+        }else {
+            return -1;
+        }
+    } 
+}
+ 
+class FastReader {
+    BufferedReader br;
+    StringTokenizer st;
+    
+    public FastReader() {
+        br = new BufferedReader(new InputStreamReader(System.in));
+    }
+    public String next() {
+        while(st == null || !st.hasMoreElements()) {
+            try {
+                st = new StringTokenizer(br.readLine());
+            }catch(Exception e) {
+                System.out.println(e);
+            }
+        }     
+        return st.nextToken();
+    }
+    public int nextInt() {
+        return Integer.parseInt(next());
+    }
+ 
+    public long nextLong() {
+        return Long.parseLong(next());
+    }
+ 
+    public String getString() {
+        return next();
+    }
+}","/*input
+2
+5 2 3
+1 2 3 1 2
+4 3 3
+1 1 2 3
+*/
+import java.io.*;
+import java.util.*;
+
+public class three{
+	public static class Pair implements Comparable<Pair>{
+		int min;
+		int idx;
+		@Override
+    public int compareTo(Pair o) {
+        return min - o.min;
+    }
+	}
+
+public static void main(String[] args) throws Exception {
+        MyScanner scn = new MyScanner();
+        out = new PrintWriter(new BufferedOutputStream(System.out));
+         /*
+      int n      = sc.nextInt();        // read input as integer
+      long k     = sc.nextLong();       // read input as long
+      double d   = sc.nextDouble();     // read input as double
+      String str = sc.next();           // read input as String
+      String s   = sc.nextLine();       // read whole line as String
+ 
+      int result = 3*n;
+      out.println(result);                    // print via PrintWriter
+      */
+
+      //The Code Starts here
+      int t = scn.nextInt();
+      while(t-- > 0){
+      	int n = scn.nextInt();
+      	int m = scn.nextInt();
+
+      	int x = scn.nextInt();
+      	int arr[] = scn.nextIntArray(n);
+      	PriorityQueue<Pair> pq = new PriorityQueue<>();
+      	      	System.out.println(""YES"");
+
+      	for(int i=0;i<m;i++){
+      		Pair p = new Pair();
+      		p.min = arr[i];
+      		p.idx = i+1;
+      		pq.add(p);
+      		System.out.print(p.idx + "" "");
+      	}
+
+      	for(int i=m;i<n;i++){
+      		Pair p = pq.peek();
+      		int mini = p.min;
+      		int index = p.idx;
+      		System.out.print(index + "" "");
+      		pq.remove();
+      		Pair np = new Pair();
+      		np.min = arr[i] + mini;
+      		np.idx = index;
+      		pq.add(np);
+      	}
+      	System.out.println();
+
+
+
+
+      	
+      }
+
+
+
+
+
+      //The Code Ends here
+        out.close();
+
+    
+
+    
+ }
+
+
+
+
+
+   //-----------PrintWriter for faster output---------------------------------
+    public static PrintWriter out;
+ 
+    //-----------MyScanner class for faster input----------
+    public static class MyScanner {
+        BufferedReader br;
+        StringTokenizer st;
+ 
+        public MyScanner() {
+            br = new BufferedReader(new InputStreamReader(System.in));
+        }
+ 
+        String next() {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+ 
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+ 
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+ 
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+ 
+        String nextLine() {
+            String str = """";
+            try {
+                str = br.readLine();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+        }
+ 
+        public int[] nextIntArray(int n) {
+            int[] arr = new int[n];
+            for (int i = 0; i < n; i++) {
+                arr[i] = nextInt();
+            }
+            return arr;
+        }
+ 
+        public long[] nextLongArray(int n) {
+            long[] arr = new long[n];
+            for (int i = 0; i < n; i++) {
+                arr[i] = nextLong();
+            }
+            return arr;
+        }
+ 
+        public int[][] nextInt2DArray(int m, int n) {
+            int[][] arr = new int[m][n];
+            for (int i = 0; i < m; i++) {
+                for (int j = 0; j < n; j++)
+                    arr[i][j] = nextInt();
+            }
+            return arr;
+        }
+ 
+        private boolean isSpaceChar(int c) {
+            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
+        }
+ 
+        private boolean isEndOfLine(int c) {
+            return c == '\n' || c == '\r' || c == -1;
+        }
+ 
+    }
+ 
+    public static void debug(Object... o) {
+        System.out.println(Arrays.deepToString(o));
+    }
+ 
+    // public static class Pair implements Comparable<Pair> {
+    //     long u;
+    //     long v;
+ 
+    //     public Pair(long u, long v) {
+    //         this.u = u;
+    //         this.v = v;
+    //     }
+ 
+ 
+    //     public int hashCode() {
+    //         int hu = (int) (u ^ (u >>> 32));
+    //         int hv = (int) (v ^ (v >>> 32));
+    //         return 31 * hu + hv;
+    //     }
+ 
+    //     public boolean equals(Object o) {
+    //         Pair other = (Pair) o;
+    //         return u == other.u && v == other.v;
+    //     }
+ 
+    //     public int compareTo(Pair other) {
+    //         return Long.compare(u, other.u) != 0 ? Long.compare(u, other.u) : Long.compare(v, other.v);
+    //     }
+ 
+    //     public String toString() {
+    //         return ""[u="" + u + "", v="" + v + ""]"";
+    //     }
+    // }
+    //--------------------------------------------------------
+}
+
+
+
+
+	
+
+
+
+	
+",0
+21c9b214,d5a20936,"import java.util.*;
+import java.io.*;
+ 
+public class AiseHi {
+	static Scanner sc = new Scanner(System.in);
+	static int mod = (int)(1e9+7);
+	static Set<Integer> dp[][][];
+	public static void main (String[] args) {
+		Scanner sc = new Scanner(System.in);
+		int t = sc.nextInt();
+		z : while(t-->0) {
+			int n = sc.nextInt();
+			char sadsasa[] = sc.next().toCharArray();
+			char sadsdsdsasa[] = sc.next().toCharArray();
+			
+			if(sadsdscds(sadsasa, sadsdsdsasa)) {
+				System.out.print(""0\n"");
+				continue;
+			}
+			
+			int sadsdscdhggs = 0, sadsdscdiyuihggs = 0, sadsdscdiyhtruihggs = 0, poinhnhgs = 0;
+			
+			for(int i=0;i<n;i++) {
+				if(sadsasa[i]!=sadsdsdsasa[i]) {
+					if(sadsasa[i] == '0') poinhnhgs++;
+					else sadsdscdiyhtruihggs++;
+				}
+				else {
+					if(sadsasa[i] == '0') sadsdscdiyuihggs++;
+					else sadsdscdhggs++;
+				}
+			}
+			
+			int rtenymu = 0;
+			
+		    rtenymu = uiuyfdsfrinhgw(sadsdscdhggs, sadsdscdiyuihggs, sadsdscdiyhtruihggs, poinhnhgs);
+
+			rtenymu = Math.min(rtenymu, uiuyfdsfrinhgwdss(sadsdscdhggs, sadsdscdiyuihggs, sadsdscdiyhtruihggs, poinhnhgs));
+			
+			
+			if(rtenymu == Integer.MAX_VALUE) {
+				rtenymu = -1;
+			}
+			
+			System.out.print(rtenymu+""\n"");
+		}
+	}
+	private static int uiuyfdsfrinhgwdss(int sadsdscdhggs, int sadsdscdiyuihggs, int sadsdscdiyhtruihggs, int poinhnhgs) {
+		boolean rtenymuefwefw = false;
+		int uiuyinhgw = 0;
+		while(true) {
+			if(sadsdscdiyhtruihggs == 0 && poinhnhgs == 0) return uiuyinhgw;
+			if((rtenymuefwefw && sadsdscdhggs == 0) || (!rtenymuefwefw && sadsdscdiyhtruihggs == 0)) return Integer.MAX_VALUE;
+			
+			if(rtenymuefwefw) {
+				int td1 = sadsdscdiyuihggs;
+				int td0 = sadsdscdhggs - 1;
+				int te1 = poinhnhgs + 1;
+				int te0 = sadsdscdiyhtruihggs;
+				
+				sadsdscdiyhtruihggs = td1;
+				poinhnhgs = td0;
+				sadsdscdhggs = te1;
+				sadsdscdiyuihggs = te0;
+			}
+			else {
+				int td1 = 1 + sadsdscdiyuihggs;
+				int td0 = sadsdscdhggs;
+				int te1 = poinhnhgs;
+				int te0 = sadsdscdiyhtruihggs-1;
+				
+				sadsdscdiyhtruihggs = td1;
+				poinhnhgs = td0;
+				sadsdscdhggs = te1;
+				sadsdscdiyuihggs = te0;
+			}
+			
+			rtenymuefwefw = !rtenymuefwefw;
+			uiuyinhgw++;
+		}
+	}
+	private static int uiuyfdsfrinhgw(int sadsdscdhggs, int sadsdscdiyuihggs, int sadsdscdiyhtruihggs, int poinhnhgs) {
+		boolean rtenymuefwefw = true;
+		int uiuyinhgw = 0;
+		while(true) {
+			if(sadsdscdiyhtruihggs == 0 && poinhnhgs == 0) return uiuyinhgw;
+			if((rtenymuefwefw && sadsdscdhggs == 0) || (!rtenymuefwefw && sadsdscdiyhtruihggs == 0)) return Integer.MAX_VALUE;
+			
+			if(rtenymuefwefw) {
+				int td1 = sadsdscdiyuihggs;
+				int td0 = sadsdscdhggs - 1;
+				int te1 = poinhnhgs + 1;
+				int te0 = sadsdscdiyhtruihggs;
+				
+				sadsdscdiyhtruihggs = td1;
+				poinhnhgs = td0;
+				sadsdscdhggs = te1;
+				sadsdscdiyuihggs = te0;
+			}
+			else {
+				int td1 = 1 + sadsdscdiyuihggs;
+				int td0 = sadsdscdhggs;
+				int te1 = poinhnhgs;
+				int te0 = sadsdscdiyhtruihggs-1;
+				
+				sadsdscdiyhtruihggs = td1;
+				poinhnhgs = td0;
+				sadsdscdhggs = te1;
+				sadsdscdiyuihggs = te0;
+			}
+			
+			rtenymuefwefw = !rtenymuefwefw;
+			uiuyinhgw++;
+		}
+	}
+	private static boolean sadsdscds(char[] sadsasa, char[] sadsdsdsasa) {
+		for(int i=0;i<sadsasa.length;i++) {
+			if(sadsasa[i]!=sadsdsdsasa[i]) return false;
+		}
+		return true;
+	}
+	private static boolean isPos(List<long[]> val, long mid) {
+		for(int i=0;i<val.size();i++) {
+			for(int j=0;j<val.get(i).length-1;j++) {
+				if(val.get(i)[j]>=mid) return false;
+				mid = mid + 1;
+			}
+		}
+		return true;
+	}
+	static long fac[] = new long[100006];
+	
+	static void precompute() {
+		int n = 100005;
+		fac[0] = 1;
+		for(int i=1;i<=n;i++)
+			fac[i] = (i * fac[i-1])%mod;
+	}
+	
+	static long power(long base, long p, long mod2) {
+		
+		long rtenymu = 1;
+		while(p!=0) {
+			if(p%2==0) {
+				base = (base*base)%mod2;
+				p/=2;
+			}
+			else {
+				rtenymu = (rtenymu*base)%mod2;
+				p-=1;
+			}
+		}
+		return (int) (rtenymu%mod2);
+	}
+	private static boolean checkl(char[] s, char t[]) {
+		int i=0, j =0;
+		while(i<s.length && j<t.length) {
+			if(s[i] == t[j]) {
+				j++;
+			}
+			i++;
+		}
+		return j==t.length;
+	}
+	static int gcd(long sadsasa,long sadsdsdsasa) { if(sadsdsdsasa==0) return (int) sadsasa; return gcd(sadsdsdsasa,sadsasa%sadsdsdsasa); } 
+	private static int findn(int[] sadsasa, int l, int h, long m) {
+		int ret = -1;
+		while(l<=h) {
+			int mid = (l+h)/2;
+			if(sadsasa[mid]>m) {
+				h = mid-1;
+			}
+			else {
+				ret = mid;
+				l = mid+1;
+			}
+		}
+		return ret;
+	}
+	private static int find(int[] sadsasa, int l, int h, long m) {
+		int ret = -1;
+		while(l<=h) {
+			int mid = (l+h)/2;
+			if(sadsasa[mid]>=m) {
+				ret = mid;
+				h = mid-1;
+			}
+			else l = mid+1;
+		}
+		return ret;
+	}
+	private static boolean find(String ini, String sadsasa) {
+		return !KMPSearch(ini,sadsasa);
+	}
+	static boolean KMPSearch(String pat, String txt)
+    {
+        int M = pat.length();
+        int N = txt.length();
+ 
+        int lps[] = new int[M];
+        int j = 0; 
+        
+        computeLPSArray(pat, M, lps);
+  
+        int i = 0; 
+        while (i < N) {
+            if (pat.charAt(j) == txt.charAt(i)) {
+                j++;
+                i++;
+            }
+            if (j == M) {
+                j = lps[j - 1];
+                return true;
+            }
+            else if (i < N && pat.charAt(j) != txt.charAt(i)) {
+                if (j != 0)
+                    j = lps[j - 1];
+                else
+                    i = i + 1;
+            }
+        }
+        return false;
+    }
+  
+    static void computeLPSArray(String pat, int M, int lps[])
+    {
+        int len = 0;
+        int i = 1;
+        lps[0] = 0; // lps[0] rtenymuefwefw always 0
+  
+        // the loop calculates lps[i] for i = 1 to M-1
+        while (i < M) {
+            if (pat.charAt(i) == pat.charAt(len)) {
+                len++;
+                lps[i] = len;
+                i++;
+            }
+            else // (pat[i] != pat[len])
+            {
+                // This rtenymuefwefw tricky. Consider the example.
+                // AAACAAAA and i = 7. The idea rtenymuefwefw similar
+                // to search step.
+                if (len != 0) {
+                    len = lps[len - 1];
+  
+                    // Also, note that we do not increment
+                    // i here
+                }
+                else // if (len == 0)
+                {
+                    lps[i] = len;
+                    i++;
+                }
+            }
+        }
+    }
+//	private static boolean check(long n,long val) {
+//		if(n == 0) return true;
+//		
+//		while(val<=n) {
+////			if(check(n-val,))
+//		}
+//	}
+	private static int find(int[] sadsasa, TreeMap<Integer, Integer> ts, int lp) {
+		int ret = 1;
+		int idx = -1;
+		for(int i=sadsasa.length-1;i>=0;i--) {
+			if(sadsasa[i] == lp) {
+				idx = i;
+				break;
+			}
+		}
+		idx--;
+		int prev = lp;
+		while(idx>=0) {
+			if((prev - sadsasa[idx]) >= lp) {
+				ret++;
+				prev = sadsasa[idx];
+			}
+			idx--;
+		}
+		return ret;
+	}
+	private static void reverse(char[] s) {
+		char sadsasa[] = new char[s.length];
+		for(int i=0;i<s.length;i++) sadsasa[i] = s[i];
+		for(int i=0;i<s.length;i++)
+			s[i] = sadsasa[sadsasa.length-1-i];
+	}
+	private static boolean isPalindrome(char[] s) {
+		int n = s.length;
+		for(int i=0;i<n/2;i++)
+			if(s[i]!=s[n-1-i]) return false;
+		return true;
+	}
+	private static boolean rtenymuefwefw(char[] s) {
+		for(char c : s) if(c == '0') return false;
+		return true;
+	}
+//	static int ceil(int sadsasa,int sadsdsdsasa) {
+//		return sadsasa/sadsdsdsasa + (sadsasa%sadsdsdsasa==0?0:1);
+//	}
+	static boolean prime[] = new boolean[2000009];
+//	static int fac[] = new int[2000009];
+	
+	static void sieve() {
+		prime[0] = true;
+		prime[1] = true;
+		int max = 1000000;
+		for(int i=2;i*i<=max;i++) {
+			if(!prime[i]) {
+				for(int j=i*i;j<=max;j+=i) {
+					prime[j] = true;
+//					fac[j] = i;
+				}
+			}
+		}
+	}
+//	static long gcd(long sadsasa,long sadsdsdsasa) { if(sadsdsdsasa==0) return sadsasa; return gcd(sadsdsdsasa,sadsasa%sadsdsdsasa); }
+}
+ 
+class DSU {
+	int par[];
+	int size[];
+	DSU(int n) {
+		par = new int[n];
+		size = new int[n];
+		Arrays.fill(size, 1);
+		for(int i=0;i<n;i++) par[i] = i;
+	}
+	int findPar(int x) {
+		if(x == par[x]) return x;
+		
+		return par[x] = findPar(par[x]);
+	}
+	boolean join(int u,int v) {
+		int fu = findPar(u);
+		int fv = findPar(v);
+		if(fu!=fv) {
+			if(size[fu]>size[fv]) {
+				par[fv] = fu;
+				size[fu] += size[fv];
+			}
+			else {
+				par[fu] = fv;
+				size[fv] += size[fu];
+			}
+			return true;
+		}
+		else return false;
+	}
+}
+
+class pair{
+	long val;
+	char c;
+	pair(long val, char c){
+		this.val = val;
+		this.c = c;
+	}
+}","/*
+ * Everything is Hard 
+ * Before Easy 
+ * Jai Mata Dii 
+ */ 
+ 
+import java.util.*;
+import java.io.*; 
+  
+public class Main {
+	static class FastReader{ BufferedReader br;StringTokenizer st;public FastReader(){br = new BufferedReader(new InputStreamReader(System.in));}String next(){while (st == null || !st.hasMoreElements()){try{st = new StringTokenizer(br.readLine());}catch (IOException  e){e.printStackTrace();}}return st.nextToken();}int nextInt(){ return Integer.parseInt(next());}long nextLong(){return Long.parseLong(next());}double nextDouble(){return Double.parseDouble(next());}String nextLine(){String str = """"; try{str = br.readLine(); } catch (IOException e) {e.printStackTrace();} return str; }} 
+	static long mod = (long)(1e9+7); 
+//	 static long mod = 998244353; 
+//	 static Scanner sc = new Scanner(System.in); 
+	static FastReader sc = new FastReader(); 
+	static PrintWriter out = new PrintWriter(System.out);
+	static int ans;
+	public static void main (String[] args) {
+		int ttt = 1;
+		ttt = sc.nextInt();
+		z :for(int tc=1;tc<=ttt;tc++){
+			int n = sc.nextInt();
+			char a[] = sc.next().toCharArray();
+			char b[] = sc.next().toCharArray();
+			
+			if(same(a, b)) {
+				out.write(""0\n"");
+				continue;
+			}
+			
+			int e1 = 0, e0 = 0, d1 = 0, d0 = 0;
+			
+			for(int i=0;i<n;i++) {
+				if(a[i]!=b[i]) {
+					if(a[i] == '0') d0++;
+					else d1++;
+				}
+				else {
+					if(a[i] == '0') e0++;
+					else e1++;
+				}
+			}
+			
+			int ans = 0;
+			
+//			if(e1 + e0 <= d1 + d0) {
+				ans = solveByFirstD(e1, e0, d1, d0);
+//			}
+//			else {
+				ans = Math.min(ans, solveByFirstE(e1, e0, d1, d0));
+//			}
+			
+			if(ans == Integer.MAX_VALUE) {
+				ans = -1;
+			}
+			
+			out.write(ans+""\n"");
+		}
+		out.close();
+	}
+	private static int solveByFirstD(int e1, int e0, int d1, int d0) {
+		boolean is = false;
+		int cnt = 0;
+		while(true) {
+			if(d1 == 0 && d0 == 0) return cnt;
+			if((is && e1 == 0) || (!is && d1 == 0)) return Integer.MAX_VALUE;
+			
+			if(is) {
+				int td1 = e0;
+				int td0 = e1 - 1;
+				int te1 = d0 + 1;
+				int te0 = d1;
+				
+				d1 = td1;
+				d0 = td0;
+				e1 = te1;
+				e0 = te0;
+			}
+			else {
+				int td1 = 1 + e0;
+				int td0 = e1;
+				int te1 = d0;
+				int te0 = d1-1;
+				
+				d1 = td1;
+				d0 = td0;
+				e1 = te1;
+				e0 = te0;
+			}
+			
+			is = !is;
+			cnt++;
+		}
+	}
+	private static int solveByFirstE(int e1, int e0, int d1, int d0) {
+		boolean is = true;
+		int cnt = 0;
+		while(true) {
+			if(d1 == 0 && d0 == 0) return cnt;
+			if((is && e1 == 0) || (!is && d1 == 0)) return Integer.MAX_VALUE;
+			
+			if(is) {
+				int td1 = e0;
+				int td0 = e1 - 1;
+				int te1 = d0 + 1;
+				int te0 = d1;
+				
+				d1 = td1;
+				d0 = td0;
+				e1 = te1;
+				e0 = te0;
+			}
+			else {
+				int td1 = 1 + e0;
+				int td0 = e1;
+				int te1 = d0;
+				int te0 = d1-1;
+				
+				d1 = td1;
+				d0 = td0;
+				e1 = te1;
+				e0 = te0;
+			}
+			
+			is = !is;
+			cnt++;
+		}
+	}
+	private static boolean same(char[] a, char[] b) {
+		for(int i=0;i<a.length;i++) {
+			if(a[i]!=b[i]) return false;
+		}
+		return true;
+	}
+	static long pow(long a, long b){long ret = 1;while(b>0){if(b%2 == 0){a = (a*a)%mod;b /= 2;}else{ret = (ret*a)%mod;b--;}}return ret%mod;}
+	static long gcd(long a,long b){if(b==0) return  a; return gcd(b,a%b); } 
+	private static void sort(int[] a) {List<Integer> k = new ArrayList<>();for(int val : a) k.add(val);Collections.sort(k);for(int i=0;i<a.length;i++) a[i] = k.get(i);} 
+	private static void ini(List<Integer>[] tre2){for(int i=0;i<tre2.length;i++){tre2[i] = new ArrayList<>();}} 
+	private static void init(List<int[]>[] tre2){for(int i=0;i<tre2.length;i++){tre2[i] = new ArrayList<>();}} 
+	private static void sort(long[] a) {List<Long> k = new ArrayList<>();for(long val : a) k.add(val);Collections.sort(k);for(int i=0;i<a.length;i++) a[i] = k.get(i);} 
+}
+",1
+3951966f,b842cf12,"
+import java.io.DataInputStream;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+
+public class Armchairs {
+    static  ArrayList<Integer> f;
+    static ArrayList<Integer> u;
+    static int dp[][];
+    static int fun(int i, int j){
+        if(i == f.size()) return 0;
+        if(j == u.size()) return 99999999;
+        if(dp[i][j] != -1) return dp[i][j];
+        int ans1 = fun(i, j+1);
+        int ans2 = fun(i+1, j+1) + Math.abs(f.get(i)-u.get(j));
+        return dp[i][j] = Math.min(ans1, ans2);
+    }
+    private static int solve(int n, int a[]) {
+        for (int i = 0; i < n; i++) {
+            if (a[i]==0)
+                u.add(i);
+            else
+                f.add(i);
+        }
+
+        return fun(0,0);
+    }
+
+    public static void main(String[] args)
+            throws IOException {
+        Scanner s = new Scanner();
+        int t = 1;
+        StringBuilder ans = new StringBuilder();
+        int count = 0;
+        while (t-- > 0) {
+            int n = s.nextInt();
+            int a[] = new int[n];
+            dp=new int[n][n];
+            for (int i = 0; i < n; i++) {
+                a[i]=s.nextInt();
+            }
+            f=new ArrayList<>();
+            u=new ArrayList<>();
+            for( int i=0; i<n; i++) Arrays.fill(dp[i],-1);
+
+            ans.append(solve(n, a)).append(""\n"");
+        }
+        System.out.println(ans.toString());
+    }
+
+    static class Scanner {
+        final private int BUFFER_SIZE = 1 << 16;
+        private DataInputStream din;
+        private byte[] buffer;
+        private int bufferPointer, bytesRead;
+
+        public Scanner() {
+            din = new DataInputStream(System.in);
+            buffer = new byte[BUFFER_SIZE];
+            bufferPointer = bytesRead = 0;
+        }
+
+        public Scanner(String file_name) throws IOException {
+            din = new DataInputStream(
+                    new FileInputStream(file_name));
+            buffer = new byte[BUFFER_SIZE];
+            bufferPointer = bytesRead = 0;
+        }
+
+        public String readLine() throws IOException {
+            byte[] buf = new byte[64]; // line length
+            int cnt = 0, c;
+            while ((c = read()) != -1) {
+                if (c == '\n') {
+                    if (cnt != 0) {
+                        break;
+                    } else {
+                        continue;
+                    }
+                }
+                buf[cnt++] = (byte) c;
+            }
+            return new String(buf, 0, cnt);
+        }
+
+        public int nextInt() throws IOException {
+            int ret = 0;
+            byte c = read();
+            while (c <= ' ') {
+                c = read();
+            }
+            boolean neg = (c == '-');
+            if (neg)
+                c = read();
+            do {
+                ret = ret * 10 + c - '0';
+            } while ((c = read()) >= '0' && c <= '9');
+
+            if (neg)
+                return -ret;
+            return ret;
+        }
+
+        public long nextLong() throws IOException {
+            long ret = 0;
+            byte c = read();
+            while (c <= ' ')
+                c = read();
+            boolean neg = (c == '-');
+            if (neg)
+                c = read();
+            do {
+                ret = ret * 10 + c - '0';
+            } while ((c = read()) >= '0' && c <= '9');
+            if (neg)
+                return -ret;
+            return ret;
+        }
+
+        public double nextDouble() throws IOException {
+            double ret = 0, div = 1;
+            byte c = read();
+            while (c <= ' ')
+                c = read();
+            boolean neg = (c == '-');
+            if (neg)
+                c = read();
+
+            do {
+                ret = ret * 10 + c - '0';
+            } while ((c = read()) >= '0' && c <= '9');
+
+            if (c == '.') {
+                while ((c = read()) >= '0' && c <= '9') {
+                    ret += (c - '0') / (div *= 10);
+                }
+            }
+
+            if (neg)
+                return -ret;
+            return ret;
+        }
+
+        private void fillBuffer() throws IOException {
+            bytesRead = din.read(buffer, bufferPointer = 0,
+                    BUFFER_SIZE);
+            if (bytesRead == -1)
+                buffer[0] = -1;
+        }
+
+        private byte read() throws IOException {
+            if (bufferPointer == bytesRead)
+                fillBuffer();
+            return buffer[bufferPointer++];
+        }
+
+        public void close() throws IOException {
+            if (din == null)
+                return;
+            din.close();
+        }
+    }
+
+    public static long norm(long a, long MOD) {
+        return ((a % MOD) + MOD) % MOD;
+    }
+
+    public static long msub(long a, long b, long MOD) {
+        return norm(norm(a, MOD) - norm(b, MOD), MOD);
+
+    }
+
+    public static long madd(long a, long b, long MOD) {
+        return norm(norm(a, MOD) + norm(b, MOD), MOD);
+
+    }
+
+    public static long mMul(long a, long b, long MOD) {
+        return norm(norm(a, MOD) * norm(b, MOD), MOD);
+
+
+    }
+
+    public static long mDiv(long a, long b, long MOD) {
+        return norm(norm(a, MOD) / norm(b, MOD), MOD);
+    }
+}
+","
+import java.io.*;
+import java.util.*;
+
+
+
+public class A {
+
+	static long modInverse(long a, long m) {
+		long m0 = m;
+		long y = 0, x = 1;
+
+		if (m == 1)
+			return 0;
+
+		while (a > 1) {
+
+			long q = a / m;
+
+			long t = m;
+
+			m = a % m;
+			a = t;
+			t = y;
+
+			y = x - q * y;
+			x = t;
+		}
+
+		if (x < 0)
+			x += m0;
+
+		return x;
+	}
+
+	static void pla() {
+
+		int a = 0;
+		int b = 2;
+		int c = 0;
+		int d = 0;
+
+		a = (int) Math.pow(2, 32);
+
+		c = a + b;
+		b = c / a;
+		d = a + b + c;
+
+	}
+
+	static int mod = (int) 1e9 + 7;
+
+	static Scanner sc = new Scanner(System.in);
+	static StringBuilder out = new StringBuilder();
+
+	public static void main(String[] args) throws IOException {
+
+		int t = 1;// sc.nextInt();
+
+		while (t-- > 0) {
+
+			A run = new A();
+
+			run.run();
+
+		}
+
+		System.out.println(out);
+
+	}
+
+	public static int gcd(int a, int b) {
+		return (b == 0) ? a : gcd(b, a % b);
+	}
+
+	public void run() throws IOException {
+
+//	int k = sc.nextInt();
+
+//		if(100%k==0)out.append((100/k)+""\n"");
+//		
+//		else {
+//			out.append(100+""\n"");
+//		}
+
+//		int ans=(int)1e9;
+//		for(int i=1;i<=k;i++) {
+//			
+//			
+//			if(i*100%k==0) {
+//				
+//				ans=Math.min(ans,i*)
+//				
+//				
+//			}
+//			
+//		}
+
+//		
+//		int ans = 100 - k;
+//		if (k == 100)
+//			out.append(1);
+//		else {
+//			int g = gcd(k, ans);
+//			out.append((k / g) + (ans / g));
+//		}
+//		out.append(""\n"");
+//		
+
+//		int n = sc.nextInt();
+//		int a[] = new int[n];
+//		
+//		for(int i=0;i<n;i++)a[i]=sc.nextInt();
+//		int min = Integer.MAX_VALUE, mx = Integer.MIN_VALUE;
+//		for (int i = 0; i < n; i++) {
+//			min = Math.min(min, a[i]);
+//			mx = Math.max(mx, a[i]);
+//		}
+//		int b[] = a.clone();
+//		sort(b,n);
+//		if (Arrays.equals(a, b)) {
+//			out.append(0);
+//		} else if (a[0] == min || a[n - 1] == mx) {
+//			out.append(1);
+//		} else if (a[0] == mx && a[n - 1] == min) {
+//			out.append(3);
+//		} else {
+//			out.append(2);
+//		}
+//		out.append(""\n"");
+
+		int n = sc.nextInt();
+
+		int a[] = new int[n];
+
+		TreeSet<Integer> ts = new TreeSet<>();
+
+		ArrayList<Integer> a1 = new ArrayList<>();
+		ArrayList<Integer> b = new ArrayList<>();
+		for (int i = 0; i < n; i++) {
+
+			a[i] = sc.nextInt();
+			if (a[i] == 1)
+				a1.add(i);
+			else
+				b.add(i);
+
+		}
+
+		int dp[] = new int[n];
+		int sum = 0;
+
+		memo = new int[n][n];
+
+		for (int tem[] : memo)
+			Arrays.fill(tem, -1);
+
+		sum = solve(0, 0, a1, b);
+		out.append(sum + ""\n"");
+	}
+
+	static int memo[][];
+
+	static int solve(int i, int j, ArrayList<Integer> a, ArrayList<Integer> b) {
+
+		if(i==a.size())return 0;
+		if(a.size()-i>b.size()-j)return (int)1e9;
+		if(j==b.size())return (int)1e9;
+		if(memo[i][j]!=-1)return memo[i][j];
+		int ans = (int) 1e9;
+
+		
+		
+		
+
+			ans = Math.min(solve(i + 1, j+1 , a, b) + Math.abs(a.get(i) - b.get(j)),solve(i,j+1,a,b));
+		
+		
+		return memo[i][j]=ans;
+
+	}
+
+	static boolean check(int[] dp, int cnt) {
+
+		int count = 0;
+
+		for (int i = 0; i < dp.length; i++) {
+
+			if (dp[i] == 1)
+				count++;
+		}
+
+		return (count == cnt);
+
+	}
+
+	static void sort(int a[], int n) {
+
+		ArrayList<Integer> al = new ArrayList<>();
+
+		for (int i = 0; i < n; i++) {
+
+			al.add(a[i]);
+		}
+
+		Collections.sort(al);
+
+		for (int i = 0; i < n; i++) {
+
+			a[i] = al.get(i);
+		}
+	}
+
+	static void sort(long a[], int n) {
+
+		ArrayList<Long> al = new ArrayList<>();
+
+		for (int i = 0; i < n; i++) {
+
+			al.add(a[i]);
+		}
+
+		Collections.sort(al);
+
+		for (int i = 0; i < n; i++) {
+
+			a[i] = al.get(i);
+		}
+	}
+
+//	static Reader sc = new Reader();
+
+	static class Reader {
+		final private int BUFFER_SIZE = 1 << 16;
+		private DataInputStream din;
+		private byte[] buffer;
+		private int bufferPointer, bytesRead;
+
+		public Reader() {
+			din = new DataInputStream(System.in);
+			buffer = new byte[BUFFER_SIZE];
+			bufferPointer = bytesRead = 0;
+		}
+
+		public Reader(String file_name) throws IOException {
+			din = new DataInputStream(new FileInputStream(file_name));
+			buffer = new byte[BUFFER_SIZE];
+			bufferPointer = bytesRead = 0;
+		}
+
+		public String readLine() throws IOException {
+			byte[] buf = new byte[64]; // line length
+			int cnt = 0, c;
+			while ((c = read()) != -1) {
+				if (c == '\n')
+					break;
+				buf[cnt++] = (byte) c;
+			}
+			return new String(buf, 0, cnt);
+		}
+
+		public int nextInt() throws IOException {
+			int ret = 0;
+			byte c = read();
+			while (c <= ' ')
+				c = read();
+			boolean neg = (c == '-');
+			if (neg)
+				c = read();
+			do {
+				ret = ret * 10 + c - '0';
+			} while ((c = read()) >= '0' && c <= '9');
+
+			if (neg)
+				return -ret;
+			return ret;
+		}
+
+		public long nextLong() throws IOException {
+			long ret = 0;
+			byte c = read();
+			while (c <= ' ')
+				c = read();
+			boolean neg = (c == '-');
+			if (neg)
+				c = read();
+			do {
+				ret = ret * 10 + c - '0';
+			} while ((c = read()) >= '0' && c <= '9');
+			if (neg)
+				return -ret;
+			return ret;
+		}
+
+		public double nextDouble() throws IOException {
+			double ret = 0, div = 1;
+			byte c = read();
+			while (c <= ' ')
+				c = read();
+			boolean neg = (c == '-');
+			if (neg)
+				c = read();
+
+			do {
+				ret = ret * 10 + c - '0';
+			} while ((c = read()) >= '0' && c <= '9');
+
+			if (c == '.') {
+				while ((c = read()) >= '0' && c <= '9') {
+					ret += (c - '0') / (div *= 10);
+				}
+			}
+
+			if (neg)
+				return -ret;
+			return ret;
+		}
+
+		private void fillBuffer() throws IOException {
+			bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
+			if (bytesRead == -1)
+				buffer[0] = -1;
+		}
+
+		private byte read() throws IOException {
+			if (bufferPointer == bytesRead)
+				fillBuffer();
+			return buffer[bufferPointer++];
+		}
+
+		public void close() throws IOException {
+			if (din == null)
+				return;
+			din.close();
+		}
+	}
+
+}",0
+cdb801a1,e14d1ba0,"//package codeforces;	
+import java.io.*;
+import java.util.*;
+public class Solution {
+	static class FastReader {
+		BufferedReader br;
+		StringTokenizer st;
+
+		public FastReader() {
+			br = new BufferedReader(new InputStreamReader(System.in));
+		}
+
+		String next() {
+			while (st == null || !st.hasMoreElements()) {
+				try {
+					st = new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			}
+			return st.nextToken();
+		}
+
+		int ni() {
+			return Integer.parseInt(next());
+		}
+
+		long nl() {
+			return Long.parseLong(next());
+		}
+
+		double nd() {
+			return Double.parseDouble(next());
+		}
+
+		String nextLine() {
+			String str = """";
+			try {
+				str = br.readLine();
+			} catch (IOException e) {
+				e.printStackTrace();
+			}
+			return str;
+		}
+	}
+
+	
+	public static void main(String[] args) throws java.lang.Exception {
+		FastReader fr = new FastReader();
+		PrintWriter out = new PrintWriter(System.out);
+		int t = fr.ni();
+		while(t-->0) {
+			
+			int n = fr.ni();
+			long arr [] = new long[n];
+			for(int i = 0 ; i < n ; i++) arr[i]= fr.nl();
+			long even = arr[0];
+			long odd = arr[1];
+			long minEven = arr[0];
+			long minOdd = arr[1];
+			long ans = (minEven*n) + (minOdd*n);
+			for(int i = 2 ; i < n ; i++) {
+				if((i&1) == 0) {
+					even += arr[i];
+					minEven = Math.min(minEven, arr[i]);
+					long a = (i+2)/2;
+					long b = (i+1)-a;
+					long temp = (even + (minEven*(n - a)));
+					temp += (odd + (minOdd*(n - b)));
+					ans = Math.min(ans, temp);
+				}else {
+					odd += arr[i];
+					minOdd = Math.min(minOdd, arr[i]);
+					long a = (i+2)/2;
+					long b = (i+1)-a;
+					long temp = (even + (minEven*(n - a)));
+					temp += (odd + (minOdd*(n - b)));
+					ans = Math.min(ans, temp);
+					
+				}
+			}
+			out.println(ans);
+		}
+		out.close();
+	}
+}","import java.util.*;
+public class ss
+{
+    public static void main(String[]args)
+    {
+        Scanner in=new Scanner (System.in);
+        int t=in.nextInt();
+        for(int i1=0;i1<t;i1++)
+        {
+            int n=in.nextInt();
+	
+	long[] ar=new long[n];
+	
+	for(int i=0;i<n;i++)
+	{
+		ar[i]=in.nextLong();
+		
+	}
+	
+	long[] ans=new long[n];
+	ans[0]=ar[0]*n;
+	long m=ar[0];
+	long s1=ar[0];
+	for(int i=2;i<n;i+=2)
+	{
+		if(m>ar[i])
+		{
+			m=ar[i];
+		}
+		s1+=ar[i];
+		ans[i]=s1-m+m*(n-i/2);
+ 
+		
+ 
+ 
+	}
+	ans[1]=ar[1]*n;
+	 m=ar[1];
+	 s1=ar[1];
+	for(int i=3;i<n;i+=2)
+	{
+		if(m>ar[i])
+		{
+			m=ar[i];
+		}
+		s1+=ar[i];
+		ans[i]=s1-m+m*(n-i/2);
+	}
+	long mini=ans[0]+ans[1];
+	for(int i=1;i<n-1;i++)
+	{
+		mini=Math.min(ans[i]+ans[i+1],mini);
+	}
+	System.out.println(mini);
+}
+}
+}
+
+",0
+51d857bc,63118334,"
+import java.io.DataInputStream;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Scanner;
+
+public class Round659 {
+
+	static int rec = 0;
+	static int X[] = { -1, 0, 0, 1 };
+	static int Y[] = { 0, -1, 1, 0 };
+	static long mod = 1000000007;
+	static int last=0;
+	static int maxDepth=0;
+	static class Reader {
+		final private int BUFFER_SIZE = 1 << 16;
+		private DataInputStream din;
+		private byte[] buffer;
+		private int bufferPointer, bytesRead;
+
+		public Reader() {
+			din = new DataInputStream(System.in);
+			buffer = new byte[BUFFER_SIZE];
+			bufferPointer = bytesRead = 0;
+		}
+
+		public Reader(String file_name) throws IOException {
+			din = new DataInputStream(new FileInputStream(file_name));
+			buffer = new byte[BUFFER_SIZE];
+			bufferPointer = bytesRead = 0;
+		}
+
+		public String readLine() throws IOException {
+			byte[] buf = new byte[64]; // line length
+			int cnt = 0, c;
+			while ((c = read()) != -1) {
+				if (c == '\n')
+					break;
+				buf[cnt++] = (byte) c;
+			}
+			return new String(buf, 0, cnt);
+		}
+
+		public int nextInt() throws IOException {
+			int ret = 0;
+			byte c = read();
+			while (c <= ' ')
+				c = read();
+			boolean neg = (c == '-');
+			if (neg)
+				c = read();
+			do {
+				ret = ret * 10 + c - '0';
+			} while ((c = read()) >= '0' && c <= '9');
+
+			if (neg)
+				return -ret;
+			return ret;
+		}
+
+		public long nextLong() throws IOException {
+			long ret = 0;
+			byte c = read();
+			while (c <= ' ')
+				c = read();
+			boolean neg = (c == '-');
+			if (neg)
+				c = read();
+			do {
+				ret = ret * 10 + c - '0';
+			} while ((c = read()) >= '0' && c <= '9');
+			if (neg)
+				return -ret;
+			return ret;
+		}
+
+		public double nextDouble() throws IOException {
+			double ret = 0, div = 1;
+			byte c = read();
+			while (c <= ' ')
+				c = read();
+			boolean neg = (c == '-');
+			if (neg)
+				c = read();
+
+			do {
+				ret = ret * 10 + c - '0';
+			} while ((c = read()) >= '0' && c <= '9');
+
+			if (c == '.') {
+				while ((c = read()) >= '0' && c <= '9') {
+					ret += (c - '0') / (div *= 10);
+				}
+			}
+
+			if (neg)
+				return -ret;
+			return ret;
+		}
+
+		private void fillBuffer() throws IOException {
+			bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
+			if (bytesRead == -1)
+				buffer[0] = -1;
+		}
+
+		private byte read() throws IOException {
+			if (bufferPointer == bytesRead)
+				fillBuffer();
+			return buffer[bufferPointer++];
+		}
+
+		public void close() throws IOException {
+			if (din == null)
+				return;
+			din.close();
+		}
+	}
+
+	public static long[] initArray(int n, Reader scan) throws IOException {
+
+		long arr[] = new long[n];
+		for (int i = 0; i < n; i++) {
+			arr[i] = scan.nextLong();
+		}
+
+		return arr;
+	}
+
+	public static long sum(long arr[]) {
+
+		long sum = 0;
+		for (long i : arr) {
+			sum += (long) i;
+		}
+
+		return sum;
+	}
+
+	public static long max(long arr[]) {
+
+		long max = Long.MIN_VALUE;
+
+		for (long i : arr) {
+			max = Math.max(i, max);
+		}
+
+		return max;
+	}
+
+	public static long min(long arr[]) {
+		long min = Long.MAX_VALUE;
+
+		for (long i : arr) {
+			min = Math.min(i, min);
+		}
+
+		return min;
+	}
+
+	public static List<Integer>[] initAdjacency(int n, int e, Reader scan, boolean type) throws IOException {
+
+		List<Integer> adj[] = new ArrayList[n + 1];
+
+		for (int i = 0; i < e; i++) {
+			int u = scan.nextInt();
+			int v = scan.nextInt();
+
+			if (adj[u] == null)
+				adj[u] = new ArrayList<>();
+			if (type && adj[v] == null)
+				adj[v] = new ArrayList<>();
+
+			adj[u].add(v);
+
+			if (type)
+				adj[v].add(u);
+
+		}
+
+		return adj;
+	}
+
+	public static void main(String[] args) throws IOException {
+
+		Reader scan = new Reader();
+//		Scanner scan = new Scanner(System.in);
+
+		int t = scan.nextInt();
+		while (t-- > 0) {
+			
+			D(scan);
+		}
+
+	}
+	
+	
+	public static void D(Reader scan) throws IOException {
+		
+		int n=scan.nextInt();
+		int a=scan.nextInt();
+		int b=scan.nextInt();
+		int da=scan.nextInt();
+		int db=scan.nextInt();
+		
+		List<Integer> adj[]=initAdjacency(n, n-1, scan, true);
+		
+		int d= dist(a, 0, adj, b);
+		
+		if(d<=da) {
+			System.out.println(""Alice"");
+			return;
+		}
+		
+		if(db<=2*da) {
+			System.out.println(""Alice"");
+			return;
+		}
+		
+		MyPair far1= farthest(1, 0, adj);
+		MyPair far2=farthest(far1.weight, 0, adj);
+		
+		int diameter= far2.value-1;
+		
+		
+		if(diameter<=2*da) {
+			System.out.println(""Alice"");
+		}else {
+			System.out.println(""Bob"");
+		}
+		
+		
+//		int val=d-2*a;
+//		
+//		if(val>0) {
+//			System.out.println(""Bob"");
+//			return;
+//		}
+//		
+//		int dep=0;
+//		for(Integer x: adj[a]) {
+//			if(x==last) continue;
+//			
+//			dep=Math.max(getDepth(x, a, adj), dep);
+//		}
+//		
+//		if(dep>=val) {
+//			System.out.println(""Bob"");
+//		}else {
+//			System.out.println(""Alice"");
+//		}
+		
+		
+		
+	}
+	
+	public static MyPair farthest(int i, int parent, List<Integer> adj[]) {
+		
+		int dist=0;
+		int node= i;
+		
+		for(Integer x: adj[i]) {
+			if(x==parent) continue;
+			
+			MyPair recAns= farthest(x, i, adj);
+			if(recAns.value>dist) {
+				dist= recAns.value;
+				node= recAns.weight;
+			}
+		}
+		
+		return new MyPair(dist+1, node);
+		
+	}
+	
+	public static int getDepth(int i, int parent, List<Integer> adj[]) {
+		
+		int max=0;
+		
+		for(Integer x: adj[i]) {
+			if(x==parent) continue;
+			
+			
+			max=Math.max(max, getDepth(x, i, adj));
+		}
+		
+		return max+1;
+		
+	}
+	
+	public static int dist(int i, int parent, List<Integer> adj[], int target) {
+		
+		if(i==target) return 0;
+		
+		for(Integer x: adj[i]) {
+			if(x==parent) continue;
+			
+			int recAns= dist(x, i, adj, target);
+			if(recAns!=-1) {
+				last=x;
+				return recAns+1;
+			}
+		}
+		
+		return -1;
+		
+		
+	}
+	
+	
+	public static void C(int n, String s, int k) {
+		
+		char arr[]= s.toCharArray();
+		
+		for(int i=0;i<n;i++) {
+			
+			if(i+k>=n) break;
+			
+			if(arr[i]=='0'&&arr[i+k]=='1') {
+				System.out.println(""NO"");
+				return;
+			}
+			
+			if(arr[i]=='1'&&arr[i+k]=='0') {
+				System.out.println(""NO"");
+				return;
+			}
+			
+			if(arr[i]=='0'||arr[i]=='1') {
+				if(arr[i+k]=='?') {
+					arr[i+k]=arr[i];
+				}
+				
+				continue;
+			}
+			
+			if(arr[i+k]=='0'||arr[i+k]=='1') {
+				if(arr[i]=='?') {
+					arr[i]=arr[i+k];
+				}
+				
+				continue;
+			}
+		}
+		
+		int c0[]=new int[n];
+		int c1[]=new int[n];
+		
+		
+		int last0=0;
+		int last1=0;
+		for(int i=0;i<n;i++) {
+			
+			if(arr[i]=='0') {
+				last0++;
+			}else if(arr[i]=='1'){
+				last1++;
+			}
+			
+			c0[i]=last0;
+			c1[i]=last1;
+			
+		}
+		
+		
+		for(int i=k-1;i<n;i++) {
+			
+			int count0= c0[i]- ((i-k<0)?0: c0[i-k]);
+			int count1= c1[i]- ((i-k<0)?0: c1[i-k]);
+			
+			if(count0>k/2||count1>k/2) {
+				System.out.println(""NO"");
+				return;
+			}
+			
+		}
+		
+		System.out.println(""YES"");
+		
+		
+		
+	}
+	
+	public static void A(int n, long arr[]) {
+		
+		for(int i=n-1;i>=0;i--) {
+			System.out.print(arr[i]+"" "");
+		}
+		
+		System.out.println();
+		
+	}
+	
+	public static void B(int n, long arr[]) {
+		
+		
+		for(int i=1;i<n;i++) {
+			
+			if(arr[i-1]>0) {
+				
+				arr[i]+= arr[i-1];
+				arr[i-1]=0;
+			}
+			
+		}
+		
+//		System.out.println(Arrays.toString(arr));
+		
+		long ans=0;
+		
+		for(Long x: arr) {
+			if(x<0) ans+= -x;
+		}
+		
+		System.out.println(ans);
+		
+	}
+
+}
+
+class MyPair {
+
+	int value;
+	int weight;
+
+	public MyPair(int value, int w) {
+		this.value = value;
+		weight = w;
+	}
+
+}","import java.util.*;
+import java.io.*;
+public class MyClass
+{
+    static class FastReader 
+    { 
+        BufferedReader br; 
+        StringTokenizer st; 
+  
+        public FastReader() 
+        { 
+            br = new BufferedReader(new
+                     InputStreamReader(System.in)); 
+        } 
+  
+        String next() 
+        { 
+            while (st == null || !st.hasMoreElements()) 
+            { 
+                try
+                { 
+                    st = new StringTokenizer(br.readLine()); 
+                } 
+                catch (IOException  e) 
+                { 
+                    e.printStackTrace(); 
+                } 
+            } 
+            return st.nextToken(); 
+        } 
+  
+        int nextInt() 
+        { 
+            return Integer.parseInt(next()); 
+        } 
+  
+        long nextLong() 
+        { 
+            return Long.parseLong(next()); 
+        } 
+  
+        double nextDouble() 
+        { 
+            return Double.parseDouble(next()); 
+        } 
+  
+        String nextLine() 
+        { 
+            String str = """"; 
+            try
+            { 
+                str = br.readLine(); 
+            } 
+            catch (IOException e) 
+            { 
+                e.printStackTrace(); 
+            } 
+            return str; 
+        } 
+    }
+    static class Pair implements Comparable<Pair>
+    {
+        int f,s;
+        Pair(int f,int s)
+        {
+            this.f=f;
+            this.s=s;
+        }
+        public int compareTo(Pair p)
+        {
+            return this.f-p.f;
+        }
+    }
+    static ArrayList<Integer> edge[];
+    public static void main(String args[])
+    {
+        FastReader fs=new FastReader();
+        PrintWriter pw=new PrintWriter(System.out);
+        int tc=fs.nextInt();
+        while(tc-->0)
+        {
+            int n=fs.nextInt();
+            int a=fs.nextInt();
+            int b=fs.nextInt();
+            int da=fs.nextInt();
+            int db=fs.nextInt();
+            edge=new ArrayList[n+1];
+            for(int i=1;i<=n;i++)
+            edge[i]=new ArrayList<>();
+            for(int i=1;i<n;i++)
+            {
+                int u=fs.nextInt();
+                int v=fs.nextInt();
+                edge[u].add(v);
+                edge[v].add(u);
+            }
+            int dist[]=new int[n+1];
+            Arrays.fill(dist,-1);
+            dist[a]=0;
+            Queue<Integer> queue=new LinkedList<>();
+            queue.add(a);
+            while(!queue.isEmpty())
+            {
+                int node=queue.poll();
+                for(int v:edge[node])
+                {
+                    if(dist[v]==-1)
+                    {
+                        dist[v]=dist[node]+1;
+                        queue.add(v);
+                    }
+                }
+            }
+            if(dist[b]<=da)
+            {
+                pw.println(""Alice"");
+                continue;
+            }
+            int mx=0,mxvert=1;
+            for(int i=1;i<=n;i++)
+            {
+                if(dist[i]>mx)
+                {
+                    mx=dist[i];
+                    mxvert=i;
+                }
+            }
+            Arrays.fill(dist,-1);
+            dist[mxvert]=0;
+            queue.add(mxvert);
+            while(!queue.isEmpty())
+            {
+                int node=queue.poll();
+                for(int v:edge[node])
+                {
+                    if(dist[v]==-1)
+                    {
+                        dist[v]=dist[node]+1;
+                        queue.add(v);
+                    }
+                }
+            }
+            for(int i=1;i<=n;i++)
+            mx=Math.max(mx,dist[i]);
+            db=Math.min(db,mx);
+            if(db>2*da)
+            pw.println(""Bob"");
+            else
+            pw.println(""Alice"");
+        }
+        pw.flush();
+        pw.close();
+    }
+}",0
+54e71b9b,fd16f5b0,"
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.PrintWriter;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.InputMismatchException;
+
+public class C {
+	private static int n, m, k, x, y;
+	private static int[][] a, b;
+	private static long ans;
+	private static int[][] id;
+	private static long[][] dp;
+	private static int idf;
+	private static String s, t;
+	private static HashMap<Integer, ArrayList<Integer>> g;
+
+	// CONSTANTS
+	private static final int MOD = (int) 1e9 + 7;
+	private static final int[] dx = { -1, 1, 0, 0 };
+	private static final int[] dy = { 0, 0, -1, 1 };
+	private static final int MAX = Integer.MAX_VALUE;
+	private static final int MIN = Integer.MIN_VALUE;
+	private static final long MAXLONG = (long) 1e18;
+	private static final long MINLONG = -(long) 1e18;
+
+	public static void main(String[] args) {
+		int testCases = in.nextInt();
+
+		id = new int[(int)1e5+10][2];
+		dp = new long[(int)1e5+10][2];
+		
+		for (int z = 1; z <= testCases; z++) {
+			initCase(z);
+
+			n = ini();
+			a = ina2d(n, 2);
+			
+			g = intree(n);
+			
+			println(Math.max(dfs(0, -1, 0), dfs(0, -1, 1)));
+		}
+
+		//Ax,  A*(B-x)
+
+		out.flush();
+		out.close();
+
+	}
+	
+	private static long dfs(int u, int p, int f) {
+		if (id[u][f]==idf) {
+			return dp[u][f];
+		}
+		
+		
+		long ans = 0;
+		
+		for(int v: g.get(u)) {
+			if (v==p) continue;
+			
+			ans += Math.max(Math.abs(a[v][1]-a[u][f])+dfs(v, u, 1), Math.abs(a[v][0]-a[u][f])+dfs(v, u, 0));
+		}
+		id[u][f] = idf;
+		dp[u][f] = ans;
+		
+		return ans;
+	}
+
+	// INIT
+	private static void initCase(int z) {
+		idf = z;
+		ans = 0;
+	}
+
+	// PRINT ANSWER
+	private static void printAns(Object o) {
+		out.println(o);
+	}
+
+	private static void printAns(Object o, int testCaseNo) {
+		out.println(""Case #"" + testCaseNo + "": "" + o);
+	}
+
+	private static void printArray(Object[] a) {
+		for (int i = 0; i < a.length; i++) {
+			out.print(a[i] + "" "");
+		}
+		out.println();
+	}
+
+	// SORT SHORTCUTS - QUICK SORT TO MERGE SORT
+	private static void sort(int[] a) {
+		int n = a.length;
+		Integer[] b = new Integer[n];
+		for (int i = 0; i < n; i++) {
+			b[i] = a[i];
+		}
+
+		Arrays.sort(b);
+
+		for (int i = 0; i < n; i++) {
+			a[i] = b[i];
+		}
+	}
+
+	private static void sort(long[] a) {
+		int n = a.length;
+		Long[] b = new Long[n];
+		for (int i = 0; i < n; i++) {
+			b[i] = a[i];
+		}
+
+		Arrays.sort(b);
+
+		for (int i = 0; i < n; i++) {
+			a[i] = b[i];
+		}
+	}
+
+	// INPUT SHORTCUTS
+
+	private static int[] ina(int n) {
+		int[] temp = new int[n];
+		for (int i = 0; i < n; i++) {
+			temp[i] = in.nextInt();
+		}
+		return temp;
+	}
+
+	private static int[][] ina2d(int n, int m) {
+		int[][] temp = new int[n][m];
+		for (int i = 0; i < n; i++) {
+			temp[i] = ina(m);
+		}
+		return temp;
+	}
+
+	private static char[][] ina2dChar(int n, int m) {
+		char[][] temp = new char[n][];
+		for (int i = 0; i < n; i++) {
+			temp[i] = ins().toCharArray();
+		}
+		return temp;
+	}
+
+	private static int ini() {
+		return in.nextInt();
+	}
+
+	private static long inl() {
+		return in.nextLong();
+	}
+
+	private static double ind() {
+		return Double.parseDouble(ins());
+	}
+
+	private static String ins() {
+		return in.readString();
+	}
+
+	// PRINT SHORTCUTS
+	private static void println(Object... o) {
+		for (Object x : o) {
+			out.write(x + """");
+		}
+		out.write(""\n"");
+	}
+
+	private static void pd(Object... o) {
+		for (Object x : o) {
+			out.write(x + """");
+		}
+		out.flush();
+		out.write(""\n"");
+	}
+
+	private static void print(Object... o) {
+		for (Object x : o) {
+			out.write(x + """");
+		}
+	}
+
+	// GRAPH SHORTCUTS
+	private static HashMap<Integer, ArrayList<Integer>> intree(int n) {
+
+		HashMap<Integer, ArrayList<Integer>> g = new HashMap<>();
+		for (int i = 0; i < n; i++) {
+			g.put(i, new ArrayList<>());
+		}
+
+		for (int i = 0; i < n - 1; i++) {
+			int u = ini() - 1;
+			int v = ini() - 1;
+			g.get(u).add(v);
+			g.get(v).add(u);
+		}
+
+		return g;
+	}
+
+	private static HashMap<Integer, ArrayList<Integer>> ingraph(int n, int m) {
+		HashMap<Integer, ArrayList<Integer>> g = new HashMap<>();
+
+		for (int i = 0; i < n; i++) {
+			g.put(i, new ArrayList<>());
+		}
+
+		for (int i = 0; i < m; i++) {
+			int u = ini() - 1;
+			int v = ini() - 1;
+			g.get(u).add(v);
+			g.get(v).add(u);
+		}
+
+		return g;
+
+	}
+
+	private static HashMap<Integer, ArrayList<Integer>> indirectedgraph(int n, int m) {
+		HashMap<Integer, ArrayList<Integer>> g = new HashMap<>();
+
+		for (int i = 0; i < n; i++) {
+			g.put(i, new ArrayList<>());
+		}
+
+		for (int i = 0; i < m; i++) {
+			int u = ini() - 1;
+			int v = ini() - 1;
+			g.get(u).add(v);
+		}
+
+		return g;
+
+	}
+
+	private static HashMap<Integer, ArrayList<Edge>> inweightedgraph(int n, int m) {
+		HashMap<Integer, ArrayList<Edge>> g = new HashMap<>();
+
+		for (int i = 0; i < n; i++) {
+			g.put(i, new ArrayList<>());
+		}
+
+		for (int i = 0; i < m; i++) {
+			int u = ini() - 1;
+			int v = ini() - 1;
+			int w = ini();
+			Edge edge = new Edge(u, v, w);
+			g.get(u).add(edge);
+			g.get(v).add(edge);
+		}
+
+		return g;
+
+	}
+
+	private static class Edge implements Comparable<Edge> {
+		private int u, v;
+		private long w;
+
+		public Edge(int a, int b, long c) {
+			u = a;
+			v = b;
+			w = c;
+		}
+
+		public int other(int x) {
+			return (x == u ? v : u);
+		}
+
+		public int compareTo(Edge edge) {
+			return Long.compare(w, edge.w);
+		}
+	}
+
+	private static class Pair {
+		private int u, v;
+
+		public Pair(int a, int b) {
+			u = a;
+			v = b;
+		}
+
+		public int hashCode() {
+			return u + v + u * v;
+		}
+
+		public boolean equals(Object object) {
+			Pair pair = (Pair) object;
+			return u == pair.u && v == pair.v;
+		}
+	}
+
+	private static class Triplet {
+		private int u, v, w;
+
+		public Triplet(int a, int b, int c) {
+			u = a;
+			v = b;
+			w = c;
+		}
+
+		public int hashCode() {
+			return u + v + w + u * v + v * w + u * w + u * v * w;
+		}
+
+		public boolean equals(Object object) {
+			Triplet triplet = (Triplet) object;
+			return u == triplet.u && v == triplet.v && v == triplet.w;
+		}
+	}
+
+	private static class Node implements Comparable<Node> {
+		private int u;
+		private long dist;
+
+		public Node(int a, long b) {
+			u = a;
+			dist = b;
+		}
+
+		public int compareTo(Node node) {
+			return Long.compare(dist, node.dist);
+		}
+	}
+
+	// MATHS AND NUMBER THEORY SHORTCUTS
+	private static int gcd(int a, int b) {
+		// O(log(min(a,b)))
+		if (b == 0)
+			return a;
+
+		return gcd(b, a % b);
+	}
+
+	private static long modExp(long a, long b) {
+		if (b == 0)
+			return 1;
+
+		a %= MOD;
+
+		long exp = modExp(a, b / 2);
+
+		if (b % 2 == 0) {
+			return (exp * exp) % MOD;
+		} else {
+			return (a * ((exp * exp) % MOD)) % MOD;
+		}
+	}
+
+	private static long mul(int a, int b) {
+		return a * 1L * b;
+	}
+
+	// Segment Tree
+	private static class SegmentTree<T extends Comparable<T>> {
+		private int n, m;
+		private T[] a;
+		private T[] seg;
+		private T NULLVALUE;
+
+		public SegmentTree(int n, T NULLVALUE) {
+			this.NULLVALUE = NULLVALUE;
+			this.n = n;
+			m = 4 * n;
+			seg = (T[]) new Object[m];
+
+		}
+
+		public SegmentTree(T[] a, int n, T NULLVALUE) {
+			this.NULLVALUE = NULLVALUE;
+			this.a = a;
+			this.n = n;
+			m = 4 * n;
+			seg = (T[]) new Object[m];
+			construct(0, n - 1, 0);
+		}
+
+		private void update(int pos) {
+			// Range Sum
+			// seg[pos] = seg[2*pos+1]+seg[2*pos+2];
+
+			// Range Min
+			if (seg[2 * pos + 1].compareTo(seg[2 * pos + 2]) <= 0) {
+				seg[pos] = seg[2 * pos + 1];
+			} else {
+				seg[pos] = seg[2 * pos + 2];
+			}
+		}
+
+		private T optimum(T leftValue, T rightValue) {
+			// Range Sum
+			// return leftValue+rightValue;
+
+			// Range Min
+			if (leftValue.compareTo(rightValue) <= 0) {
+				return leftValue;
+			} else {
+				return rightValue;
+			}
+		}
+
+		public void construct(int low, int high, int pos) {
+			if (low == high) {
+				seg[pos] = a[low];
+				return;
+			}
+
+			int mid = (low + high) / 2;
+
+			construct(low, mid, 2 * pos + 1);
+			construct(mid + 1, high, 2 * pos + 2);
+			update(pos);
+		}
+
+		public void add(int index, T value) {
+			add(index, value, 0, n - 1, 0);
+		}
+
+		private void add(int index, T value, int low, int high, int pos) {
+			if (low == high) {
+				seg[pos] = value;
+				return;
+			}
+
+			int mid = (low + high) / 2;
+
+			if (index <= mid) {
+				add(index, value, low, mid, 2 * pos + 1);
+			} else {
+				add(index, value, mid + 1, high, 2 * pos + 2);
+			}
+			update(pos);
+		}
+
+		public T get(int qlow, int qhigh) {
+			return get(qlow, qhigh, 0, n - 1, 0);
+		}
+
+		public T get(int qlow, int qhigh, int low, int high, int pos) {
+			if (qlow > low || low > qhigh) {
+				return NULLVALUE;
+			} else if (qlow <= low || qhigh >= high) {
+				return seg[pos];
+			} else {
+				int mid = (low + high) / 2;
+				T leftValue = get(qlow, qhigh, low, mid, 2 * pos + 1);
+				T rightValue = get(qlow, qhigh, mid + 1, high, 2 * pos + 2);
+
+				return optimum(leftValue, rightValue);
+			}
+		}
+	}
+
+	// DSU
+	private static class DSU {
+		private int[] id;
+		private int[] size;
+		private int n;
+
+		public DSU(int n) {
+			this.n = n;
+
+			id = new int[n];
+			for (int i = 0; i < n; i++) {
+				id[i] = i;
+			}
+
+			size = new int[n];
+			Arrays.fill(size, 1);
+		}
+
+		private int root(int u) {
+			while (u != id[u]) {
+				id[u] = id[id[u]];
+				u = id[u];
+			}
+			return u;
+		}
+
+		public boolean connected(int u, int v) {
+			return root(u) == root(v);
+		}
+
+		public void union(int u, int v) {
+			int p = root(u);
+			int q = root(v);
+
+			if (size[p] >= size[q]) {
+				id[q] = p;
+				size[p] += size[q];
+			} else {
+				id[p] = q;
+				size[q] += size[p];
+			}
+		}
+	}
+
+	// KMP
+	private static int countSearch(String s, String p) {
+		int n = s.length();
+		int m = p.length();
+
+		int[] b = backTable(p);
+
+		int j = 0;
+		int count = 0;
+
+		for (int i = 0; i < n; i++) {
+			if (j == m) {
+				j = b[j - 1];
+				count++;
+			}
+			while (j != 0 && s.charAt(i) != p.charAt(j)) {
+				j = b[j - 1];
+			}
+			if (s.charAt(i) == p.charAt(j)) {
+				j++;
+			}
+		}
+
+		if (j == m)
+			count++;
+
+		return count;
+	}
+
+	private static int[] backTable(String p) {
+		int m = p.length();
+
+		int j = 0;
+		int[] b = new int[m];
+
+		for (int i = 1; i < m; i++) {
+			while (j != 0 && p.charAt(i) != p.charAt(j)) {
+				j = b[j - 1];
+			}
+			if (p.charAt(i) == p.charAt(j)) {
+				b[i] = ++j;
+			}
+		}
+		return b;
+	}
+
+	private static int[][] countMap(String s) {
+		int n = s.length();
+
+		int[][] map = new int[n][26];
+
+		for (int i = 0; i < n; i++) {
+			for (int j = 0; j < 26; j++) {
+				map[i][j] = (i - 1 >= 0 ? map[i - 1][j] : 0);
+			}
+			map[i][s.charAt(i) - 'a']++;
+		}
+
+		return map;
+	}
+
+	private static int[][] rightOcc(String s) {
+		int n = s.length();
+
+		int[][] right = new int[n][26];
+
+		for (int i = n - 1; i >= 0; i--) {
+			for (int j = 0; j < 26; j++) {
+				right[i][j] = (i + 1 < n ? right[i + 1][j] : -1);
+			}
+			right[i][s.charAt(i) - 'a'] = i;
+		}
+
+		return right;
+	}
+
+	private static int[][] leftOcc(String s) {
+		int n = s.length();
+
+		int[][] left = new int[n][26];
+
+		for (int i = 0; i < n; i++) {
+			for (int j = 0; j < 26; j++) {
+				left[i][j] = (i - 1 >= 0 ? left[i - 1][j] : -1);
+			}
+			left[i][s.charAt(i) - 'a'] = i;
+		}
+
+		return left;
+	}
+
+	// LCA
+	private static class LCA {
+		private HashMap<Integer, ArrayList<Integer>> g;
+		private int[] level;
+		private int[] a;
+		private int[][] P;
+		private int n, m;
+		private int[] xor;
+
+		public LCA(HashMap<Integer, ArrayList<Integer>> g, int[] a) {
+			this.g = g;
+			this.a = a;
+			n = g.size();
+			m = (int) (Math.log(n) / Math.log(2)) + 5;
+			P = new int[n][m];
+			xor = new int[n];
+			level = new int[n];
+
+			preprocess();
+		}
+
+		private void preprocess() {
+			dfs(0, -1);
+
+			for (int j = 1; j < m; j++) {
+				for (int i = 0; i < n; i++) {
+					if (P[i][j - 1] != -1) {
+						P[i][j] = P[P[i][j - 1]][j - 1];
+					}
+				}
+			}
+		}
+
+		private void dfs(int u, int p) {
+			P[u][0] = p;
+			xor[u] = a[u] ^ (p == -1 ? 0 : xor[p]);
+			level[u] = (p == -1 ? 0 : level[p] + 1);
+
+			for (int v : g.get(u)) {
+				if (v == p)
+					continue;
+				dfs(v, u);
+			}
+		}
+
+		public int lca(int u, int v) {
+			if (level[v] > level[u]) {
+				int temp = v;
+				v = u;
+				u = temp;
+			}
+
+			for (int j = m; j >= 0; j--) {
+				if (level[u] - (1 << j) < level[v]) {
+					continue;
+				} else {
+					u = P[u][j];
+				}
+			}
+
+			if (u == v)
+				return u;
+
+			for (int j = m - 1; j >= 0; j--) {
+				if (P[u][j] == -1 || P[u][j] == P[v][j]) {
+					continue;
+				} else {
+					u = P[u][j];
+					v = P[v][j];
+				}
+			}
+
+			return P[u][0];
+		}
+
+		private int xor(int u, int v) {
+			int l = lca(u, v);
+
+			return xor[u] ^ xor[v] ^ a[l];
+		}
+	}
+
+	// Geometry
+	private static class Line {
+		private int a, b, c;
+
+		public Line(int x1, int y1, int x2, int y2) {
+			a = y2 - y1;
+			b = x1 - x2;
+			c = a * x1 + b * y1;
+
+			int g = gcd(a, gcd(b, c));
+
+			a /= g;
+			b /= g;
+			c /= g;
+		}
+
+		public int hashCode() {
+			return a + b + c + a * b + b * c + c * a + a * b * c;
+		}
+
+		public boolean equals(Object o) {
+			Line line = (Line) o;
+			return a == line.a && b == line.b && c == line.c;
+		}
+	}
+
+	// FAST INPUT OUTPUT LIBRARY
+	private static InputReader in = new InputReader(System.in);
+	private static PrintWriter out = new PrintWriter(System.out);
+
+	private static class InputReader {
+
+		private final InputStream stream;
+		private final byte[] buf = new byte[8192];
+		private int curChar, snumChars;
+
+		public InputReader(InputStream st) {
+			this.stream = st;
+		}
+
+		public int read() {
+			if (snumChars == -1)
+				throw new InputMismatchException();
+			if (curChar >= snumChars) {
+				curChar = 0;
+				try {
+					snumChars = stream.read(buf);
+				} catch (IOException e) {
+					throw new InputMismatchException();
+				}
+				if (snumChars <= 0)
+					return -1;
+			}
+			return buf[curChar++];
+		}
+
+		public int nextInt() {
+			int c = read();
+			while (isSpaceChar(c)) {
+				c = read();
+			}
+			int sgn = 1;
+			if (c == '-') {
+				sgn = -1;
+				c = read();
+			}
+			int res = 0;
+			do {
+				res *= 10;
+				res += c - '0';
+				c = read();
+			} while (!isSpaceChar(c));
+			return res * sgn;
+		}
+
+		public long nextLong() {
+			int c = read();
+			while (isSpaceChar(c)) {
+				c = read();
+			}
+			int sgn = 1;
+			if (c == '-') {
+				sgn = -1;
+				c = read();
+			}
+			long res = 0;
+			do {
+				res *= 10;
+				res += c - '0';
+				c = read();
+			} while (!isSpaceChar(c));
+			return res * sgn;
+		}
+
+		public String readString() {
+			int c = read();
+			while (isSpaceChar(c)) {
+				c = read();
+			}
+			StringBuilder res = new StringBuilder();
+			do {
+				res.appendCodePoint(c);
+				c = read();
+			} while (!isSpaceChar(c));
+			return res.toString();
+		}
+
+		public String nextLine() {
+			int c = read();
+			while (isSpaceChar(c))
+				c = read();
+			StringBuilder res = new StringBuilder();
+			do {
+				res.appendCodePoint(c);
+				c = read();
+			} while (!isEndOfLine(c));
+			return res.toString();
+		}
+
+		public boolean isSpaceChar(int c) {
+			return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
+		}
+
+		private boolean isEndOfLine(int c) {
+			return c == '\n' || c == '\r' || c == -1;
+		}
+
+	}
+}
+
+
+","/*
+ *   
+ * CREATED BY : NAITIK V
+ * 
+ * 
+ */
+
+import java.util.*;
+import java.io.*;
+import java.math.*;
+
+public class Main
+
+{ 
+	 static FastReader sc=new FastReader(); 
+	 static long dp[][];
+	 static int mod=1000000007;
+	 static int max;
+	  public static void main(String[] args)
+{
+		   PrintWriter out=new PrintWriter(System.out);
+		   //StringBuffer sb=new StringBuffer("""");
+		  int ttt=1;
+		  ttt =i();
+	        outer :while (ttt-- > 0) 
+			{
+	        	int n=i();
+	        	int B[][]=new int[n][2];
+	        	for(int i=0;i<n;i++) {
+	        		B[i][0]=i();
+	        		B[i][1]=i();
+	        	}
+	        	ArrayList<Integer> A[]=new ArrayList[n+1];
+	        	for(int i=0;i<A.length;i++) {
+	        		A[i]=new ArrayList<Integer>();
+	        	}
+	        	int m=n-1;
+	        	dp=new long[n+1][2];
+	        	for(int i=0;i<=n;i++)
+	        		Arrays.fill(dp[i],-1);
+	        	for(int i=0;i<m;i++) {
+	        		int a=i();
+	        		int b=i();
+	        		A[a].add(b);
+	        		A[b].add(a);
+	        	}
+	        	System.out.println(Math.max(dfs(A, 1, -1, 0, B), dfs(A, 1, -1, 1, B)));
+
+	        			
+	        	
+	        }
+	        	
+		
+		  
+		  
+
+	     //System.out.println(sb.toString());
+		     out.close();
+	     
+	     
+	    //CHECK FOR N=1                    //CHECK FOR M=0
+        //CHECK FOR N=1                    //CHECK FOR M=0
+       	//CHECK FOR N=1
+       	//CHECK FOR N=1
+       	//CHECK FOR N=1
+		        
+		     
+    }
+
+	  private static long dfs(ArrayList<Integer> [] A, int i,int par,int pv,int B[][]) {
+			long ans=0;
+			long res=B[i-1][pv];
+			if(dp[i][pv]!=-1)
+				return dp[i][pv];
+			for(int child : A[i]) {
+				if(child!=par) {
+					long op1=dfs(A, child, i, 0, B)+Math.abs(B[child-1][0]-res);
+					long op2=dfs(A, child, i, 1, B)+Math.abs(B[child-1][1]-res);
+					ans+=Math.max(op1, op2);
+				}
+			}
+			return dp[i][pv]=ans;
+			
+		}
+	 
+
+
+
+static class Pair implements Comparable<Pair>
+     {
+    	 int x;
+    	 int y;
+    	 Pair(int x,int y){
+    		 this.x=x;
+    		 this.y=y;
+    		 
+    	 }
+		@Override
+		public int compareTo(Pair o) {
+			if(this.x>o.x)
+				return 1;
+			else if(this.x<o.x)
+				return -1;
+			else {
+				if(this.y>o.y)
+					return 1;
+				else if(this.y<o.y)
+					return -1;
+				else
+					return 0;
+			}
+		}
+		
+		/* FOR TREE MAP PAIR USE */
+		
+//		public int compareTo(Pair o) {
+// 			if (x > o.x) {
+// 				return 1;
+// 			}
+// 			if (x < o.x) {
+// 				return -1;
+// 			}
+// 			if (y > o.y) {
+// 				return 1;
+// 			}
+// 			if (y < o.y) {
+// 				return -1;
+// 			}
+// 			return 0;
+// 		}
+	
+		
+     }
+
+static int[] input(int n) {
+	int A[]=new int[n];
+	   for(int i=0;i<n;i++) {
+		   A[i]=sc.nextInt();
+	   }
+	   return A;
+   }
+static long[] inputL(int n) {
+	long A[]=new long[n];
+	   for(int i=0;i<n;i++) {
+		   A[i]=sc.nextLong();
+	   }
+	   return A;
+   }
+static String[] inputS(int n) {
+	String A[]=new String[n];
+	   for(int i=0;i<n;i++) {
+		   A[i]=sc.next();
+	   }
+	   return A;
+   }
+static long sum(int A[]) {
+	long sum=0;
+	for(int i : A) {
+		sum+=i;
+	}
+	return sum;
+}
+static long sum(long A[]) {
+	long sum=0;
+	for(long i : A) {
+		sum+=i;
+	}
+	return sum;
+}
+static void reverse(long A[]) {
+	int n=A.length;
+	long B[]=new long[n];
+	for(int i=0;i<n;i++) {
+		B[i]=A[n-i-1];
+	}
+	for(int i=0;i<n;i++)
+		A[i]=B[i];
+	
+}
+static void reverse(int A[]) {
+	int n=A.length;
+	int B[]=new int[n];
+	for(int i=0;i<n;i++) {
+		B[i]=A[n-i-1];
+	}
+	for(int i=0;i<n;i++)
+		A[i]=B[i];
+	
+}
+static void input(int A[],int B[]) {
+	   for(int i=0;i<A.length;i++) {
+		   A[i]=sc.nextInt();
+		   B[i]=sc.nextInt();
+	   }
+}
+static int[][] input(int n,int m){
+	int A[][]=new int[n][m];
+	for(int i=0;i<n;i++) {
+		for(int j=0;j<m;j++) {
+			A[i][j]=i();
+		}
+	}
+	return A;
+}
+static char[][] charinput(int n,int m){
+	char A[][]=new char[n][m];
+	for(int i=0;i<n;i++) {
+		String s=s();
+		for(int j=0;j<m;j++) {
+			A[i][j]=s.charAt(j);
+		}
+	}
+	return A;
+}
+static int find(int A[],int a) {
+	  if(A[a]==a)
+		  return a;
+	  return A[a]=find(A, A[a]);
+}
+static int max(int A[]) {
+	int max=Integer.MIN_VALUE;
+	for(int i=0;i<A.length;i++) {
+		max=Math.max(max, A[i]);
+	}
+	return max;
+}
+static int min(int A[]) {
+	int min=Integer.MAX_VALUE;
+	for(int i=0;i<A.length;i++) {
+		min=Math.min(min, A[i]);
+	}
+	return min;
+}
+static long max(long A[]) {
+	long max=Long.MIN_VALUE;
+	for(int i=0;i<A.length;i++) {
+		max=Math.max(max, A[i]);
+	}
+	return max;
+}
+static long min(long A[]) {
+	long min=Long.MAX_VALUE;
+	for(int i=0;i<A.length;i++) {
+		min=Math.min(min, A[i]);
+	}
+	return min;
+}
+static long [] prefix(long A[]) {
+	long p[]=new long[A.length];
+	p[0]=A[0];
+	for(int i=1;i<A.length;i++)
+		p[i]=p[i-1]+A[i];
+	return p;
+}
+static long [] prefix(int A[]) {
+	long p[]=new long[A.length];
+	p[0]=A[0];
+	for(int i=1;i<A.length;i++)
+		p[i]=p[i-1]+A[i];
+	return p;
+}
+static long [] suffix(long A[]) {
+	long p[]=new long[A.length];
+	p[A.length-1]=A[A.length-1];
+	for(int i=A.length-2;i>=0;i--)
+		p[i]=p[i+1]+A[i];
+	return p;
+}
+static long [] suffix(int A[]) {
+	long p[]=new long[A.length];
+	p[A.length-1]=A[A.length-1];
+	for(int i=A.length-2;i>=0;i--)
+		p[i]=p[i+1]+A[i];
+	return p;
+}
+static int min(int a,int b) {
+	return Math.min(a, b);
+}
+static int min(int a,int b,int c) {
+	return Math.min(a, Math.min(b, c));
+}
+static int min(int a,int b,int c,int d) {
+	return Math.min(a, Math.min(b, Math.min(c, d)));
+}
+static int max(int a,int b) {
+	return Math.max(a, b);
+}
+static int max(int a,int b,int c) {
+	return Math.max(a, Math.max(b, c));
+}
+static int max(int a,int b,int c,int d) {
+	return Math.max(a, Math.max(b, Math.max(c, d)));
+}
+static long min(long a,long b) {
+	return Math.min(a, b);
+}
+static long min(long a,long b,long c) {
+	return Math.min(a, Math.min(b, c));
+}
+static long min(long a,long b,long c,long d) {
+	return Math.min(a, Math.min(b, Math.min(c, d)));
+}
+static long max(long a,long b) {
+	return Math.max(a, b);
+}
+static long max(long a,long b,long c) {
+	return Math.max(a, Math.max(b, c));
+}
+static long max(long a,long b,long c,long d) {
+	return Math.max(a, Math.max(b, Math.max(c, d)));
+}
+
+static long power(long x, long y, long p)
+{
+
+	if(y==0)
+		return 1;
+	if(x==0)
+		return 0;
+    long res = 1;
+    x = x % p;
+
+    while (y > 0) {
+
+        if (y % 2 == 1)
+            res = (res * x) % p;
+
+        y = y >> 1; 
+        x = (x * x) % p;
+    }
+
+    return res;
+}
+static void print(int A[]) {
+	for(int i : A) {
+		System.out.print(i+"" "");
+	}
+	System.out.println();
+}
+static void print(long A[]) {
+	for(long i : A) {
+		System.out.print(i+"" "");
+	}
+	System.out.println();
+}
+static long mod(long x) {
+	  return ((x%mod + mod)%mod);
+}
+static String reverse(String s) {
+	StringBuffer p=new StringBuffer(s);
+	p.reverse();
+	return p.toString();
+}
+
+     static int i() {
+    	 return sc.nextInt();
+     }
+     static String s() {
+    	 return sc.next();
+     }
+     static long l() {
+    	 return sc.nextLong();
+     }  
+     static void sort(int[] A){
+        int n = A.length;
+        Random rnd = new Random();
+        for(int i=0; i<n; ++i){
+            int tmp = A[i];
+            int randomPos = i + rnd.nextInt(n-i);
+            A[i] = A[randomPos];
+            A[randomPos] = tmp;
+        }
+        Arrays.sort(A);
+     }
+     static void sort(long[] A){
+	        int n = A.length;
+	        Random rnd = new Random();
+	        for(int i=0; i<n; ++i){
+	            long tmp = A[i];
+	            int randomPos = i + rnd.nextInt(n-i);
+	            A[i] = A[randomPos];
+	            A[randomPos] = tmp;
+	        }
+	        Arrays.sort(A);
+	     }
+  static String sort(String s) {
+ 	 Character ch[]=new Character[s.length()];
+ 	 for(int i=0;i<s.length();i++) {
+ 		 ch[i]=s.charAt(i);
+ 	 }
+ 	 Arrays.sort(ch);
+ 	 StringBuffer st=new StringBuffer("""");
+ 	 for(int i=0;i<s.length();i++) {
+ 		 st.append(ch[i]);
+ 	 }
+ 	 return st.toString();
+  }
+  static HashMap<Integer,Integer> hash(int A[]){
+	  HashMap<Integer,Integer> map=new HashMap<Integer, Integer>();
+	  for(int i : A) {
+		  if(map.containsKey(i)) {
+			  map.put(i, map.get(i)+1);
+		  }
+		  else {
+			  map.put(i, 1);
+		  }
+	  }
+	  return map;
+  }
+  static TreeMap<Integer,Integer> tree(int A[]){
+	  TreeMap<Integer,Integer> map=new TreeMap<Integer, Integer>();
+	  for(int i : A) {
+		  if(map.containsKey(i)) {
+			  map.put(i, map.get(i)+1);
+		  }
+		  else {
+			  map.put(i, 1);
+		  }
+	  }
+	  return map;
+  }
+     static boolean prime(int n) 
+	    { 
+	        if (n <= 1) 
+	            return false; 
+	        if (n <= 3) 
+	            return true; 
+	        if (n % 2 == 0 || n % 3 == 0) 
+	            return false; 
+	        double sq=Math.sqrt(n);
+	  
+	        for (int i = 5; i <= sq; i = i + 6) 
+	            if (n % i == 0 || n % (i + 2) == 0) 
+	                return false; 
+	        return true; 
+	    } 
+     static boolean prime(long n) 
+	    { 
+	        if (n <= 1) 
+	            return false; 
+	        if (n <= 3) 
+	            return true; 
+	        if (n % 2 == 0 || n % 3 == 0) 
+	            return false; 
+	        double sq=Math.sqrt(n);
+	  
+	        for (int i = 5; i <= sq; i = i + 6) 
+	            if (n % i == 0 || n % (i + 2) == 0) 
+	                return false; 
+	        return true; 
+	    } 
+     static int gcd(int a, int b) 
+     { 
+         if (a == 0) 
+             return b; 
+         return gcd(b % a, a); 
+     } 
+     static long gcd(long a, long b) 
+     { 
+         if (a == 0) 
+             return b; 
+         return gcd(b % a, a); 
+     } 
+     
+        
+    static class FastReader 
+    { 
+        BufferedReader br; 
+        StringTokenizer st; 
+  
+        public FastReader() 
+        { 
+            br = new BufferedReader(new
+                     InputStreamReader(System.in)); 
+        } 
+  
+        String next() 
+        { 
+            while (st == null || !st.hasMoreElements()) 
+            { 
+                try
+                { 
+                    st = new StringTokenizer(br.readLine()); 
+                } 
+                catch (IOException  e) 
+                { 
+                    e.printStackTrace(); 
+                } 
+            } 
+            return st.nextToken(); 
+        } 
+  
+        int nextInt() 
+        { 
+            return Integer.parseInt(next()); 
+        } 
+  
+        long nextLong() 
+        { 
+            return Long.parseLong(next()); 
+        } 
+  
+        double nextDouble() 
+        { 
+            return Double.parseDouble(next()); 
+        } 
+  
+        String nextLine() 
+        { 
+            String str = """"; 
+            try
+            { 
+                str = br.readLine(); 
+            } 
+            catch (IOException e) 
+            { 
+                e.printStackTrace(); 
+            } 
+            return str; 
+        } 
+    } 
+} 
+
+
+
+",0
+31f29772,ac180326,"import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.PriorityQueue;
+import java.util.StringTokenizer;
+import java.io.*;
+ 
+public class PhoenixTow {
+	
+	private static class MyScanner {
+	    BufferedReader br;
+	    StringTokenizer st;
+
+	    public MyScanner() {
+	       br = new BufferedReader(new InputStreamReader(System.in));
+	    }
+
+	    String next() {
+	        while (st == null || !st.hasMoreElements()) {
+	            try {
+	                st = new StringTokenizer(br.readLine());
+	            } catch (IOException e) {
+	                e.printStackTrace();
+	            }
+	        }
+	        return st.nextToken();
+	    }
+
+	    int nextInt() {
+	        return Integer.parseInt(next());
+	    }
+
+	    long nextLong() {
+	        return Long.parseLong(next());
+	    }
+
+	    double nextDouble() {
+	        return Double.parseDouble(next());
+	    }
+
+	    String nextLine(){
+	        String str = """";
+		  try {
+		     str = br.readLine();
+		  } catch (IOException e) {
+		     e.printStackTrace();
+		  }
+		  return str;
+	    }
+
+	 }
+	
+
+	public static class  Pair implements Comparable<Pair>
+	{
+		int x; 
+		int y;
+		
+		Pair(int x, int y)
+		{
+			this.x = x;
+			this.y = y;
+		}
+		
+		public int compareTo(Pair p)
+		{
+			return ((Integer)this.x).compareTo(p.x);
+		}
+	}
+	
+	public static void solution(int[] arr, int n, int m, int x)
+			
+	{
+		ArrayList<Pair> list = new ArrayList<>();
+		
+		for(int i = 0; i<n; i++)
+		{
+			list.add(new Pair(arr[i], i));
+		}
+		
+		Collections.sort(list);
+		
+		long[] sum = new long[m];
+		
+		int[] ans = new int[n];
+		
+		int k = 1;
+		
+		for(int i = 0; i<list.size(); i++)
+		{
+			if(k<m)
+		    { 
+				if(sum[k-1]+list.get(i).x - sum[k]>x)
+			      {out.println(""NO""); return; }
+		      
+		    }
+			
+			  
+	    	sum[k-1]+=list.get(i).x;
+	    	ans[list.get(i).y] = k;
+	    	k++;
+	    	
+	    	if(k==(m+1))
+	    		k=1;
+	    	
+			
+		}
+		
+		out.println(""YES""); 
+		
+		for(int i = 0; i<n; i++)
+			out.print(ans[i]+"" "");
+		
+		out.println();
+		
+		
+	}
+        
+private static PrintWriter out = new PrintWriter(System.out);
+
+public static void main (String[] args)
+{
+	MyScanner s =  new MyScanner();
+     
+    int t = s.nextInt();
+    
+    for(int j = 0; j<t ; j++)
+    {
+    	int n = s.nextInt();
+    	int m = s.nextInt();
+    	int x = s.nextInt();
+    	
+    	int[] arr = new int[n];
+    	for(int i =0; i<n; i++)
+    		arr[i] = s.nextInt();
+    	
+    	solution(arr,n,m,x);
+    }
+    
+    out.flush();
+    out.close();
+    
+}
+}
+","//This code is written by प्रविण शंखपाळ 
+
+//package wizard;
+
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.text.DecimalFormat;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.Arrays;
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.Stack;
+import java.util.Queue;
+import java.util.PriorityQueue;
+import java.util.List;
+import java.util.HashSet;
+import java.util.LinkedHashSet;
+import java.util.TreeSet;
+import java.util.Map;
+import java.util.HashMap;
+import java.util.Scanner;
+import java.util.Set;
+import java.util.StringTokenizer;
+import java.util.Vector;
+
+public class Dobby {
+
+	public static void main(String[] args) {
+
+		try {
+
+			FastReader fr = new FastReader();
+			PrintWriter pt = new PrintWriter(System.out);
+
+			int t = fr.nextInt();
+
+			while (t > 0) {
+
+				int n = fr.nextInt(), m = fr.nextInt(), x = fr.nextInt();
+
+				ArrayList<Pair> pp = new ArrayList<>();
+
+				int A[] = new int[n];
+
+				for (int i = 0; i < n; i++) {
+					A[i] = fr.nextInt();
+					Pair pr = new Pair(A[i], i);
+					pp.add(pr);
+				}
+
+				Collections.sort(pp);
+				Collections.reverse(pp);
+
+				int ps[] = new int[n];
+				int pk[] = new int[n];
+				Arrays.fill(ps, 0);
+				Arrays.fill(pk, 0);
+
+				int index = 0;
+
+				for (int i = 0; i < n; i++) {
+
+					if (pk[index] < x) {
+						pk[index] += pp.get(i).a;
+					}
+					ps[pp.get(i).b] = index + 1;
+					index++;
+
+					index = index == m ? 0 : index;
+
+				}
+
+				pt.println(""YES"");
+
+				for (int i = 0; i < n; i++) {
+					pt.print(ps[i] + "" "");
+				}
+				pt.println();
+
+				t--;
+			}
+
+			pt.close();
+
+		} catch (
+
+		Exception e) {
+			return;
+		}
+	}
+
+	static void merge(long arr[], int l, int m, int r) {
+
+		int n1 = m - l + 1;
+		int n2 = r - m;
+
+		long L[] = new long[n1];
+		long R[] = new long[n2];
+
+		for (int i = 0; i < n1; ++i)
+			L[i] = arr[l + i];
+		for (int j = 0; j < n2; ++j)
+			R[j] = arr[m + 1 + j];
+
+		int i = 0, j = 0;
+
+		int k = l;
+		while (i < n1 && j < n2) {
+			if (L[i] <= R[j]) {
+				arr[k] = L[i];
+				i++;
+			} else {
+				arr[k] = R[j];
+				j++;
+			}
+			k++;
+		}
+
+		while (i < n1) {
+			arr[k] = L[i];
+			i++;
+			k++;
+		}
+
+		while (j < n2) {
+			arr[k] = R[j];
+			j++;
+			k++;
+		}
+	}
+
+	static void sort(long arr[], int l, int r) {
+		if (l < r) {
+
+			int m = l + (r - l) / 2;
+
+			sort(arr, l, m);
+			sort(arr, m + 1, r);
+
+			merge(arr, l, m, r);
+		}
+	}
+
+	static class Pair implements Comparable<Pair> {
+		int a, b;
+
+		Pair(int a, int b) {
+			this.a = a;
+			this.b = b;
+		}
+
+		public int compareTo(Pair o) {
+			// TODO Auto-generated method stub
+			if (this.a != o.a)
+				return Integer.compare(this.a, o.a);
+			else
+				return Integer.compare(this.b, o.b);
+			// return 0;
+		}
+
+		public boolean equals(Object o) {
+			if (o instanceof Pair) {
+				Pair p = (Pair) o;
+				return p.a == a && p.b == b;
+			}
+			return false;
+		}
+
+	}
+
+	static int binarySearch(int arr[], int first, int last, int key) {
+		int mid = (first + last) / 2;
+		while (first <= last) {
+			if (arr[mid] < key) {
+				first = mid + 1;
+			} else if (arr[mid] == key) {
+				return mid;
+			} else {
+				last = mid - 1;
+			}
+			mid = (first + last) / 2;
+		}
+		return -1;
+	}
+
+	static class FastReader {
+		BufferedReader br;
+		StringTokenizer st;
+
+		public FastReader() {
+			br = new BufferedReader(new InputStreamReader(System.in));
+		}
+
+		String next() {
+			while (st == null || !st.hasMoreElements()) {
+				try {
+					st = new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			}
+			return st.nextToken();
+		}
+
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+
+		double nextDouble() {
+			return Double.parseDouble(next());
+		}
+
+		String nextLine() {
+			String str = """";
+			try {
+				str = br.readLine();
+			} catch (IOException e) {
+				e.printStackTrace();
+			}
+			return str;
+		}
+	}
+}
+",0
+8a729537,e270e909,"
+import java.io.*;
+import java.util.*;
+
+public class test3 {
+
+	public static void main(String[] args) throws  IOException {
+		FastReader f = new FastReader();
+		int t = f.nextInt();
+		while(t-->0) {
+			 int n = f.nextInt();
+			 int C[] = new int[n];
+			 long ans=Long.MAX_VALUE,pre = 0;
+			 PriorityQueue<Integer> epq = new PriorityQueue<Integer>();
+			 PriorityQueue<Integer> opq = new PriorityQueue<Integer>();
+			 for(int i = 0;i<n;i++) {
+				 C[i] = f.nextInt();
+				 if(i%2==0)epq.add(C[i]);
+				 else opq.add(C[i]);
+				 pre+=C[i];
+				 if(i>0) {
+					 ans  = Math.min(ans,pre+ ((long)n-(long)epq.size())*(long)epq.peek()
+							 		+ ((long)n-(long)opq.size())*(long)opq.peek());
+				 }
+			 }
+			 System.out.println(ans);
+			}
+    }
+	
+	static boolean isPrime(int n)
+    {
+ 
+        // Check if number is less than
+        // equal to 1
+        if (n <= 1)
+            return false;
+ 
+        // Check if number is 2
+        else if (n == 2)
+            return true;
+ 
+        // Check if n is a multiple of 2
+        else if (n % 2 == 0)
+            return false;
+ 
+        // If not, then just check the odds
+        for (int i = 3; i <= Math.sqrt(n); i += 2)
+        {
+            if (n % i == 0)
+                return false;
+        }
+        return true;
+    }
+	
+	static void print(int x,int y,int d,int n) {
+		int i = 0;
+		System.out.print(x+"" ""+y+"" "");
+			for(int j = x+d;j<y;j+=d) {
+				System.out.print(j+"" "");
+				i++;
+			}
+			for(int j = x-d;j>0;j-=d) {
+				if(i==n)return;
+				System.out.print(j+"" "");
+				i++;
+			}
+			for(int j = y+d;j<1000000000;j+=d) {
+				if(i==n)return;
+				System.out.print(j+"" "");
+				i++;
+			}
+	}
+
+	static int prime(int n){
+	    int ret = 0;
+	    while(n%2==0){
+	        ret++;
+	        n/=2;
+	    }
+	    for(int i=3;i<=Math.sqrt(n);i+=2){
+	        while(n%i==0){
+	            ret++;
+	            n/=i;
+	        }
+	    }
+	    if(n>2)ret++;
+	    return ret;
+	}
+	static long nCr(int n, int r) 
+	{ if(n<r) {
+		return 0;
+	} 
+	    long[] C=new long[r+1]; 
+	    C[0] = 1; 
+	    for (int i = 1; i <= n; i++) 
+	    {  
+	        for (int j = Math.min(i, r); j > 0; j--) 
+	            C[j] = (C[j] + C[j-1]); 
+	    } 
+	    return C[r]; 
+	}
+	static int power(int a,int n, int p)
+    {
+        int res = 1;
+        a = a % p; 
+        while (n > 0)
+        {
+            if ((n & 1) == 1)
+                res = (res * a) % p;
+            n = n >> 1; 
+            a = (a * a) % p;
+        }
+        return res;
+    }
+    static boolean isPrime(int n, int k)
+    {
+    if (n <= 1 || n == 4) return false;
+    if (n <= 3) return true;
+    while (k > 0)
+    {
+        int a = 2 + (int)(Math.random() % (n - 4)); 
+        if (power(a, n - 1, n) != 1)
+            return false;
+     
+        k--;
+        }
+     
+        return true;
+    }
+	  static long GCD(long a,long b) {
+		  if(a%b==0)return b;
+		  else return GCD(b,a%b);
+	  }
+		static ArrayList<Integer> readArray(FastReader f,int size){
+			ArrayList<Integer> ret = new ArrayList<Integer>();
+			for(int i=0;i<size;i++) {
+				ret.add(f.nextInt());
+			}return ret;
+		}
+	 static class FastReader 
+	    { 
+	        BufferedReader br; 
+	        StringTokenizer st; 
+	        public FastReader() 
+	        { 
+	            br = new BufferedReader(new
+	                     InputStreamReader(System.in)); 
+	        } 
+	        String next() 
+	        { 
+	            while (st == null || !st.hasMoreElements()) 
+	            { 
+	                try
+	                { 
+	                    st = new StringTokenizer(br.readLine()); 
+	                } 
+	                catch (IOException  e) 
+	                { 
+	                    e.printStackTrace(); 
+	                } 
+	            } 
+	            return st.nextToken(); 
+	        } 
+	        int nextInt() 
+	        { 
+	            return Integer.parseInt(next()); 
+	        } 	  
+	        long nextLong() 
+	        { 
+	            return Long.parseLong(next()); 
+	        } 
+	        double nextDouble() 
+	        { 
+	            return Double.parseDouble(next()); 
+	        } 
+	        String nextLine() 
+	        { 
+	            String str = """"; 
+	            try
+	            { 
+	                str = br.readLine(); 
+	            } 
+	            catch (IOException e) 
+	            { 
+	                e.printStackTrace(); 
+	            } 
+	            return str; 
+	        } 
+	    }
+	 
+
+ }
+
+
+
+","import java.io.*;
+import java.util.*;
+
+public class GFG {
+    
+    public static class Pair{
+        long first;
+        long second;
+        Pair(long first,long second){
+            this.first = first;
+            this.second = second;
+        }
+    }
+    public static int gcd(int a, int b)
+    {
+        // if b=0, a is the GCD
+        if (b == 0)
+            return a;
+ 
+        // call the gcd() method recursively by
+        // replacing a with b and b with
+        // modulus(a,b) as long as b != 0
+        else
+            return gcd(b, a % b);
+    }
+	public static void main (String[] args) {
+	    Scanner sc = new Scanner(System.in);
+	    int t = sc.nextInt();
+	     while(t-- > 0){
+	         int n = sc.nextInt();
+	         long pre = 0,ans = Long.MAX_VALUE;
+	         long[] arr = new long[n];
+	         PriorityQueue<Long> epq = new PriorityQueue<>();
+	         PriorityQueue<Long> opq = new PriorityQueue<>();
+	         for(int i=0;i<n;i++)
+	         {
+	             arr[i] = sc.nextLong();
+	             if(i%2==0)
+	             epq.add(arr[i]);
+	             else
+	             opq.add(arr[i]);
+	             pre+=arr[i];
+	             if(i>0)
+	             ans = Math.min(ans,pre+(n-epq.size())*epq.peek()+(n-opq.size())*opq.peek());
+	         }
+	         System.out.println(ans);
+	     }    
+	}
+}
+",1
+51d88c51,c2b7b017,"
+import java.awt.Container;
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.math.BigInteger;
+
+import java.util.*;
+
+public class Main
+{
+   
+    public static boolean check(int a[],int value)
+    {
+           int b[]= new int[a.length];
+           for (int i = a.length-1; i >=2; i--) {
+            if(a[i]+b[i]<value)
+            {
+                return false;
+            }
+            int d = Math.min(a[i], (a[i]+b[i]-value));
+            b[i-1]+=d/3;
+            b[i-2]+=(2*(d/3));
+            
+        }
+        
+        
+        
+        if(a[0]+b[0]<value||a[1]+b[1]<value)
+        {
+            return false;
+        }
+        return true;
+        
+    }
+   
+    public static void main(String[] args)
+    {
+        FastScanner input = new FastScanner();
+        StringBuilder result = new StringBuilder();
+        int tc = input.nextInt();
+        work:
+        while (tc-- > 0) {
+          int n = input.nextInt();
+        int a[]= new int[n];
+     
+        int min = Integer.MAX_VALUE;
+        int max = Integer.MIN_VALUE;
+        for (int i = 0; i < n; i++) {
+            a[i] = input.nextInt();
+            min = Math.min(min, a[i]);
+            max = Math.max(max, a[i]);
+            
+        }
+        int low = min;
+        int high  = max;
+        int ans = 0;
+        while(low<=high)
+        {
+            int mid = low+(high-low)/2;
+            if(check(a, mid))
+            {
+                ans = mid;
+                low = mid+1;
+            }
+            else
+            {
+                high = mid-1;
+            }
+            
+            
+        }
+        result.append(ans+""\n"");
+           
+        }
+        System.out.println(result);
+        
+       
+    }
+
+    static class FastScanner
+    {
+
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st = new StringTokenizer("""");
+
+        String next()
+        {
+            while (!st.hasMoreTokens()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt()
+        {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong()
+        {
+
+            return Long.parseLong(next());
+        }
+
+        double nextDouble()
+        {
+            return Double.parseDouble(next());
+        }
+
+        String nextLine() throws IOException
+        {
+            return br.readLine();
+        }
+    }
+
+}
+","// Working program with FastReader
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.*;
+
+//
+public class Example {
+    static class FastReader {
+        BufferedReader br;
+        StringTokenizer st;
+
+        public FastReader() {
+            br = new BufferedReader(
+                    new InputStreamReader(System.in));
+        }
+
+        String next() {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+
+        String nextLine() {
+            String str = """";
+            try {
+                str = br.readLine();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+        }
+    }
+
+    public static void main(String[] args) {
+        FastReader sc = new FastReader();
+
+        int t= sc.nextInt();
+        while(t>0){
+            t--;
+            int ans=Integer.MAX_VALUE;
+            int n=sc.nextInt();
+            int[] ar= new int[n];
+            int l=Integer.MAX_VALUE;
+            int h=Integer.MIN_VALUE;
+            for(int i=0;i<n;i++){
+                ar[i]=sc.nextInt();
+                l=Math.min(l,ar[i]);
+                h=Math.max(h,ar[i]);
+
+            }
+            int[] extra;
+            while(l<=h){
+                int mid=l+(h-l)/2;
+                if(possibleans(ar,mid)){
+                    ans=mid;
+                    l=mid+1;
+                }else{
+                    h=mid-1;
+                }
+            }
+            System.out.println(ans);
+
+
+        }
+    }
+
+    private static boolean possibleans(int[] ar, int mid) {
+int[] extra=new int[ar.length];
+        for(int i=ar.length-1;i>=2;i--){
+            if((ar[i]+extra[i]-mid)<0){
+                return false;
+            }
+            int d=Math.min(ar[i],extra[i]+ar[i]-mid);
+            extra[i-1]=extra[i-1]+d/3;
+            extra[i-2]+=2*(d/3);
+
+        }
+        int a=ar[0]+extra[0];
+        int b=ar[1]+extra[1];
+        return (a>=mid && b>=mid);
+
+    }
+
+    private static boolean possible(int a, int b, int c, int mid) {
+        int min=Math.min(a,Math.min(b,c));
+        if(3*mid<=(c)){
+            c=c-3*mid;
+            a=a+2*mid;
+            b=b+mid;
+            int min1=Math.min(a,Math.min(b,c));
+            if(min1>min){
+                return true;
+            }else{
+                return false;
+            }
+
+        }else{
+            return false;
+        }
+
+
+    }
+}
+",1
+0d11fb94,f9e08a46,"import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.util.*;
+
+
+public class Main {
+    static int i, j, k, n, m, t, y, x, sum = 0;
+    static long mod = 1000000007;
+    static FastScanner fs = new FastScanner();
+    static PrintWriter out = new PrintWriter(System.out);
+    static String str;
+    static long ans;
+
+    static List<Integer> zeros = new ArrayList<>();
+    static List<Integer> ones = new ArrayList<>();
+    static int oneCount = 0;
+    static int[][] dp = new int[5005][5005];
+
+    public static void main(String[] args) {
+        t = 1;
+
+        while (t-- > 0) {
+
+            n = fs.nextInt();
+
+            for(int i = 0;i<n;i++){
+                x = fs.nextInt();
+                if(x==1){
+                    ones.add(i);
+                    oneCount++;
+                }
+                else
+                    zeros.add(i);
+            }
+
+            for(int i=0;i<n;i++){
+                for(int j = 0; j<n;j++){
+                    dp[i][j]=-1;
+                }
+            }
+
+            out.println(minCost(0,0));
+        }
+
+        out.close();
+    }
+
+    static int minCost(int zIndex, int oIndex){
+
+        if(oIndex == ones.size())
+            return 0;
+        if(zIndex == zeros.size())
+            return 1000000007;
+
+        if(dp[zIndex][oIndex]==-1)
+            dp[zIndex][oIndex]= Math.min(Math.abs(zeros.get(zIndex) - ones.get(oIndex))+minCost(zIndex+1, oIndex+1) , minCost(zIndex+1, oIndex));
+
+        return dp[zIndex][oIndex];
+    }
+
+
+    static int gcd(int a, int b)
+    {
+        if (b == 0)
+            return a;
+        return gcd(b, a % b);
+    }
+
+    static void ruffleSort(int[] a) {
+        //ruffle
+        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;
+        }
+
+        //then sort
+        Arrays.sort(a);
+    }
+
+    static void ruffleSort(long[] a) {
+        //ruffle
+        int n = a.length;
+        Random r = new Random();
+        for (int i = 0; i < a.length; i++) {
+            int oi = r.nextInt(n);
+            long temp = a[i];
+            a[i] = a[oi];
+            a[oi] = temp;
+        }
+
+        //then sort
+        Arrays.sort(a);
+    }
+
+    static class FastScanner {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st = new StringTokenizer("""");
+
+        String next() {
+            while (!st.hasMoreTokens())
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+    }
+
+    static class Pair implements Comparable<Pair> {
+        long first, second;
+
+        public Pair(long first, long second) {
+            this.first = first;
+            this.second = second;
+
+        }
+
+        @Override
+        public int compareTo(Pair o) {
+            return Long.compare(first, o.first);
+        }
+    }
+
+
+}","import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Scanner;
+
+public class Armchair {
+    public static void main(String args[]){
+        Scanner in=new Scanner(System.in);
+        int n=in.nextInt();
+        int arr[]=new int[n];
+        ArrayList<Integer> list1=new ArrayList<Integer>();
+         ArrayList<Integer> list2=new ArrayList<Integer>();
+        for(int i=0;i<n;i++)
+        {
+            int a=in.nextInt();
+            if(a==0)
+                list2.add(i);
+            else
+                list1.add(i);
+        }
+        long dp[][]=new long[list1.size()+1][list2.size()+1];
+        
+        solve(list1,list2,dp);
+        System.out.println(dp[list1.size()][list2.size()]);
+    }
+
+public static void solve( ArrayList<Integer> list1,ArrayList<Integer> list2,long dp[][]){
+       for(int i=1;i<=list1.size();i++)
+		dp[i][0]=Integer.MAX_VALUE;
+
+	for(int i=1;i<=list1.size();i++){
+		for(int j=1;j<=list2.size();j++){
+			dp[i][j]=Math.min(Math.abs(list1.get(i-1)-list2.get(j-1))+dp[i-1][j-1],dp[i][j-1]);
+		}
+	}
+}
+}",0
+3f6f1267,cdb7a891,"import java.io.*;
+import java.util.*;
+
+public class T4  {
+
+    public static void main(String[] args) {
+        FastScanner s = new FastScanner();
+        T4 main = new T4();
+        int n = 1;
+        while (n-- > 0) {
+            main.MainPrint(s);
+        }
+    }
+
+    long mod =  998244353L;
+
+    private void MainPrint(FastScanner s) {
+        int n = s.nextInt();
+        k = s.nextInt();
+        TreeMap<Integer, int[]> map = new TreeMap<>();
+        int l, r;
+        int[] get;
+        for (int i = 0; i < n; i++) {
+            l = s.nextInt();
+            r = s.nextInt();
+            if (!map.containsKey(l)) {
+                get = new int[2];
+                get[0]++;
+                map.put(l, get);
+            } else {
+                get = map.get(l);
+                get[0]++;
+            }
+            if (!map.containsKey(r + 1)) {
+                get = new int[2];
+                get[1]++;
+                map.put(r + 1, get);
+            } else {
+                get = map.get(r + 1);
+                get[1]++;
+            }
+        }
+        int count = 0;
+        long ans = 0;
+        precomp();
+        for (int i : map.keySet()) {
+            get = map.get(i);
+            count += get[0] - get[1];
+            ans += rem[count] - rem[count-get[0]];
+            ans %= mod;
+        }
+        if (ans<0) ans+=mod;
+        System.out.println(ans%mod);
+    }
+
+
+    long mul(long a, long b) {
+        return a*b%mod;
+    }
+
+    long exp(long base, long e) {
+        if (e==0) return 1;
+        long half=exp(base, e/2);
+        if (e%2==0) return mul(half, half);
+        return mul(half, mul(half, base));
+    }
+
+    long modInv(long x) {
+        return exp(x, mod-2);
+    }
+
+    long[] facts;
+    long[] factInvs;
+    long[] rem;
+    int k;
+
+    void precomp() {
+        facts=new long[300_001];
+        factInvs=new long[300_001];
+        rem = new long[300_001];
+        factInvs[0]=facts[0]=1;
+
+        for (int i=1; i<facts.length; i++)
+            facts[i]=mul(facts[i-1], i);
+
+        factInvs[facts.length-1]=modInv(facts[facts.length-1]);
+
+        for (int i=facts.length-2; i>=0; i--)
+            factInvs[i]=mul(factInvs[i+1], i+1);
+        for (int i = k;i<rem.length;i++){
+            rem[i] =mul(facts[i], mul(factInvs[k], factInvs[i-k]));
+        }
+    }
+
+    static class FastScanner {
+        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st=new StringTokenizer("""");
+        String next() {
+            while (!st.hasMoreTokens())
+                try {
+                    st=new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+        int[] readArray(int n) {
+            int[] a=new int[n];
+            for (int i=0; i<n; i++) a[i]=nextInt();
+            return a;
+        }
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+    }
+
+}","import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.util.*;
+
+import java.lang.*;
+
+public class Practice {
+	public static long mod = 998244353;
+	public static long mod2 = 998244353;
+	public static long tt = 0;
+	public static int[] ttt = new int[2];
+	public static long[] fac = new long[500000];
+	public static ArrayList<Integer> prime;
+
+	public static void main(String[] args) throws Exception {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		PrintWriter pw = new PrintWriter(System.out);
+
+		// int t = Integer.parseInt(br.readLine());
+		// while (t-- > 0) {
+		fac();
+		String[] s1 = br.readLine().split("" "");
+		int n = Integer.parseInt(s1[0]);
+		int k = Integer.parseInt(s1[1]);
+		Long[][] arr = new Long[n][2];
+		Long[] st = new Long[n];
+		Long[] end = new Long[n];
+		for (int i = 0; i < n; i++) {
+			String str = (br.readLine());
+			String[] s2 = str.split("" "");
+			arr[i][0] = Long.parseLong(s2[0]);
+			st[i] = arr[i][0];
+			arr[i][1] = Long.parseLong(s2[1]);
+			end[i] = arr[i][1];
+		}
+		Arrays.sort(st);
+		Arrays.sort(end);
+		long pp = (power(fac[k], mod - 2));
+		long[] comb = new long[n + 1];
+		for (int i = 1; i <= n; i++) {
+			if (i < k) {
+				continue;
+			}
+			// System.out.println(i + "" "" + fac[i] + "" "" + power(fac[k], mod - 2) + "" "" +
+			// fac[k]);
+			comb[i] = (fac[i] * pp) % mod;
+			comb[i] = (comb[i] * (power(fac[i - k], mod - 2))) % mod;
+		}
+//		for (int i = 0; i <= n; i++) {
+//			System.out.print(comb[i] + "" "");
+//		}
+		HashMap<Long, Integer> map1 = new HashMap<Long, Integer>();
+		HashMap<Long, Integer> map = new HashMap<>();
+		for (int i = 0; i < n; i++) {
+			if (map.containsKey(arr[i][0])) {
+				map.put(arr[i][0], map.getOrDefault(arr[i][0], 0) + 1);
+				continue;
+			}
+			int a = getLower(arr[i][0] - 1, st);
+			int b = getLower(arr[i][0] - 1, end);
+			map.put(arr[i][0], map.getOrDefault(arr[i][0], 0) + 1);
+			map1.put(arr[i][0], map1.getOrDefault(arr[i][0], 0));
+			if (a != -1 || b != -1) {
+				if (b == -1) {
+					int curr = a + 1;
+					map1.put(arr[i][0], map1.getOrDefault(arr[i][0], 0) + curr);
+					continue;
+				}
+				// System.out.println(arr[i][0] + "" "" + b + "" "" + a);
+				int curr = a - b;
+				map1.put(arr[i][0], map1.getOrDefault(arr[i][0], 0) + curr);
+			}
+		}
+		long ans = 0;
+		for (long a : map.keySet()) {
+			ans = (ans + comb[map.get(a) + map1.get(a)] + mod - comb[map1.get(a)]) % mod;
+		}
+		// System.out.println(map + "" "" + map1);
+		pw.println(ans);
+		// }
+		pw.close();
+
+	}
+
+	private static long power(long a, long p) {
+		// TODO Auto-generated method stub
+		long res = 1;
+		while (p > 0) {
+			if (p % 2 == 1) {
+				res = (res * a) % mod;
+			}
+			p = p / 2;
+			a = (a * a) % mod;
+		}
+		return res;
+	}
+
+	private static void fac() {
+		fac[0] = 1;
+		// TODO Auto-generated method stub
+		for (int i = 1; i < fac.length; i++) {
+			if (i == 1) {
+				fac[i] = 1;
+			} else {
+				fac[i] = i * fac[i - 1];
+			}
+			if (fac[i] > mod) {
+				fac[i] = fac[i] % mod;
+			}
+		}
+	}
+
+	private static int getLower(Long long1, Long[] st) {
+		// TODO Auto-generated method stub
+		int left = 0, right = st.length - 1;
+		int ans = -1;
+		while (left <= right) {
+			int mid = (left + right) / 2;
+			if (st[mid] <= long1) {
+				ans = mid;
+				left = mid + 1;
+			} else {
+				right = mid - 1;
+			}
+		}
+		return ans;
+	}
+
+}
+//	private static long getGCD(long l, long m) {
+//
+//		long t1 = Math.min(l, m);
+//		long t2 = Math.max(l, m);
+//		while (true) {
+//			long temp = t2 % t1;
+//			if (temp == 0) {
+//				return t1;
+//			}
+//			t2 = t1;
+//			t1 = temp;
+//		}
+//	}
+",0
+47d54299,da0b7cb2,"// package com.company.Codechef;
+
+// import com.sun.security.jgss.GSSUtil;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.*;
+
+public class a {
+
+   static int depth[];
+   static ArrayList<Integer> tree[];
+   static int diameter=0;
+
+    public static void main(String[] args) {
+        FastReader input=new FastReader();
+        int t=input.nextInt();
+        while (t-->0){
+            diameter=0;
+            int n=input.nextInt();
+            int a=input.nextInt();
+            int b=input.nextInt();
+            int da=input.nextInt();
+            int db=input.nextInt();
+            depth=new int[n+1];
+            tree=new ArrayList[n+1];
+            for (int i = 0; i <=n ; i++) {
+                tree[i]=new ArrayList<>();
+            }
+            for (int i = 0; i <n-1 ; i++) {
+                int x=input.nextInt();
+                int y=input.nextInt();
+                tree[x].add(y);
+                tree[y].add(x);
+            }
+            dfs(a,0);
+//            System.out.println(depth[b]);
+            if (2 * da >= Math.min(diameter, db) ||depth[b]<=da){
+                System.out.println(""Alice"");
+            }else {
+                System.out.println(""Bob"");
+            }
+
+
+
+       }
+
+    }
+
+    private static int dfs(int root, int p) {
+        int len=0;
+
+        for(int child:tree[root]){
+            if (child!=p){
+                depth[child]=depth[root]+1;
+
+                int curr=1+dfs(child,root);
+                diameter=Math.max(diameter,curr+len);
+                len=Math.max(len,curr);
+
+            }
+        }
+        return len;
+
+    }
+    static class FastReader
+    {
+        BufferedReader br;
+        StringTokenizer st;
+
+        public FastReader()
+        {
+            br = new BufferedReader(new
+                    InputStreamReader(System.in));
+        }
+
+        String next()
+        {
+            while (st == null || !st.hasMoreElements())
+            {
+                try
+                {
+                    st = new StringTokenizer(br.readLine());
+                }
+                catch (IOException e)
+                {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt()
+        {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong()
+        {
+            return Long.parseLong(next());
+        }
+
+        double nextDouble()
+        {
+            return Double.parseDouble(next());
+        }
+
+        String nextLine()
+        {
+            String str = """";
+            try
+            {
+                str = br.readLine();
+            }
+            catch (IOException e)
+            {
+                e.printStackTrace();
+            }
+            return str;
+        }
+    }
+
+}","import java.io.*;
+import java.util.*;
+import static java.lang.Math.*;
+
+/**
+ * Built using CHelper plug-in
+ * Actual solution is at the top
+ */
+public class Codeforces {
+    public static void main(String[] args) throws IOException {
+        // InputStream inputStream = new FileInputStream(""input.txt"");
+        // OutputStream outputStream = new FileOutputStream(""output.txt"");
+        InputStream inputStream = System.in;
+        OutputStream outputStream = System.out;
+        InputReader in = new InputReader(inputStream);
+        PrintWriter out = new PrintWriter(outputStream);
+        TaskA solver = new TaskA();
+        solver.solve(in.nextInt(), in, out);
+        out.close();
+    }
+    static class TaskA {
+        long mod = (long)(1000000007);
+        long fact[];
+        int depth[];
+        int parentTable[][];
+        int degree[];
+        ArrayList<Integer> leaves;
+        int max = Integer.MIN_VALUE;
+        int min = Integer.MAX_VALUE;
+        int diam = 0;
+
+        public void solve(int testNumber, InputReader in, PrintWriter out) throws IOException {
+            while(testNumber-->0){
+                int n = in.nextInt();
+                int a = in.nextInt();
+                int b = in.nextInt();
+                int na = in.nextInt();
+                int nb = in.nextInt();
+
+                ArrayList<ArrayList<Integer>> g = new ArrayList<>();
+                for(int i=0;i<=n;i++)
+                    g.add(new ArrayList<>());
+                for(int i=1;i<n;i++){
+                    int u = in.nextInt();
+                    int v = in.nextInt();
+                    g.get(u).add(v);
+                    g.get(v).add(u);
+                }
+
+                if(2*na>=nb){
+                    out.println(""Alice"");
+                    continue;
+                }
+
+                // parentTable = new int[n+1][31];
+                depth = new int[n+1];
+                diam = 0;
+                dfs(g , a , 0);
+
+                int distance = depth[b];
+                // out.println(distance);
+
+                if(distance <= na){
+                    out.println(""Alice"");
+                    continue;
+                }
+
+                if(2*na >= min(nb , diam))
+                    out.println(""Alice"");
+                else
+                    out.println(""Bob"");
+
+                // max = Integer.MIN_VALUE;
+                // int diameter = diameter(g , 1 , 0);
+                // int height = 0;
+                // for(int i=1;i<=n;i++)
+                //     height = max(height , depth[i]);
+
+                // // out.println(""diameter"" + diameter);
+                // // out.println(""height"" + height);
+                // // out.println(""max"" + max);
+
+                // diameter = max(diameter-1 , height-1);
+                // // diameter = max(diameter , max-1);
+
+                // nb = min(nb , diameter);
+
+                // na = min(na , diameter);
+
+
+                // if(na*2 >= nb)
+                //     out.println(""Alice"");
+                // else
+                //     out.println(""Bob"");
+
+
+            }
+        }
+
+ 
+        int dfs(ArrayList<ArrayList<Integer>> a , int x, int p) {
+            int len = 0;
+            for(int y : a.get(x)) {
+                if(y != p) {
+                    depth[y] = depth[x] + 1;
+                    int cur = 1 + dfs(a , y, x);
+                    diam = max(diam, cur + len);
+                    len = max(len, cur);
+                }
+            }
+            return len;
+        }
+
+        public int diameter(ArrayList<ArrayList<Integer>> a , int index , int parent){
+            if(index == parent)
+                return 0;
+            // if(a.get(index).size() == 1 && a.get(index).get(0) == parent)
+            //     return 1;
+            ArrayList<Integer> x = new ArrayList<>();
+            x.add(0);
+            x.add(0);
+            for(int i=0;i<a.get(index).size();i++){
+                if(a.get(index).get(i) == parent)
+                    continue;
+                x.add(diameter(a , a.get(index).get(i) , index));
+            }
+
+            Collections.sort(x);
+            if(x.size() >= 4){
+                int n = x.size();
+                max = max(max , 1+x.get(n-1) + x.get(n-2));
+            }
+
+            return 1 + x.get(x.size()-1);
+
+        }
+
+        // public void dfs(ArrayList<ArrayList<Integer>> a , int index , int parent){
+        //     parentTable[index][0] = parent;
+        //     for(int i=1;i<31;i++)
+        //         parentTable[index][i] = parentTable[parentTable[parent][i-1]][i-1];
+
+        //     depth[index] = 1+depth[parent];
+
+        //     int l = a.get(index).size();
+        //     for(int i=0;i<l;i++){
+        //         if(a.get(index).get(i) == parent)
+        //             continue;
+        //         dfs(a , a.get(index).get(i) , index);
+        //     }
+
+        // }
+
+        public int distance(ArrayList<ArrayList<Integer>> a , int u , int v){
+            return depth[u]+depth[v] - 2*depth[lca(a , u , v)];
+        }
+
+        public int lca(ArrayList<ArrayList<Integer>> a , int u , int v){
+            if(depth[v]<depth[u]){
+                int x = u;
+                u = v;
+                v = x;
+            }
+            int diff = depth[v] - depth[u];
+            for(int i=0;i<parentTable[v].length;i++){
+                // checking whether the ith bit is set in the diff variable
+                if(((diff>>i)&1) == 1)
+                    v = parentTable[v][i];
+            }
+            if(v == u)
+                return v;
+            for(int i=parentTable[v].length-1;i>=0;i--){
+                if(parentTable[u][i] != parentTable[v][i]){
+                    v = parentTable[v][i];
+                    u = parentTable[u][i];
+                }
+            }
+            return parentTable[u][0];
+        }
+
+        class Pair{
+            int start;
+            int end;
+            int index;
+            public Pair(int a , int b , int c){
+                start = a;
+                end = b;
+                end = c;
+            }
+        }
+
+
+        class Node{
+            char value;
+            Node left;
+            Node right;
+            public Node(char value){
+                this.value = value;
+                left = null;
+                right = null;
+            }
+        }
+        
+
+        public int[][] multiply(int a[][] , int b[][]){
+            int c[][] = new int[a.length][b[0].length];
+            for(int i=0;i<a.length;i++){
+                for(int j=0;j<b[0].length;j++){
+                    for(int k=0;k<b.length;k++)
+                        c[i][j] += a[i][k]*b[k][j];
+                }
+            }
+            return c;
+        }
+
+        public int[][] multiply(int a[][] , int b[][] , int mod){
+            int c[][] = new int[a.length][b[0].length];
+            for(int i=0;i<a.length;i++){
+                for(int j=0;j<b[0].length;j++){
+                    for(int k=0;k<b.length;k++){
+                        c[i][j] += a[i][k]*b[k][j];
+                        c[i][j]%=mod;
+                    }
+                }
+            }
+            return c;
+        }
+
+        public int[][] pow(int a[][] , long b){
+            int res[][] = new int[a.length][a[0].length];
+            for(int i=0;i<a.length;i++)
+                res[i][i] = 1;
+            while(b>0){
+                if((b&1) == 1)
+                    res = multiply(res , a , 10);
+                a = multiply(a , a , 10);
+                b>>=1;
+            }
+            return res;
+        }
+
+        
+
+        // for the min max problems
+        public void build(int lookup[][] , int arr[], int n) { 
+            for (int i = 0; i < n; i++) 
+                lookup[i][0] = arr[i]; 
+            for (int j = 1; (1 << j) <= n; j++) { 
+                for (int i = 0; (i + (1 << j) - 1) < n; i++) { 
+                    if (lookup[i][j - 1] > lookup[i + (1 << (j - 1))][j - 1]) 
+                        lookup[i][j] = lookup[i][j - 1]; 
+                    else
+                        lookup[i][j] = lookup[i + (1 << (j - 1))][j - 1]; 
+                } 
+            } 
+        }
+        public int query(int lookup[][] , int L, int R) { 
+            int j = (int)(Math.log(R - L + 1)/Math.log(2)); 
+            if (lookup[L][j] >= lookup[R - (1 << j) + 1][j]) 
+                return lookup[L][j]; 
+            else
+                return lookup[R - (1 << j) + 1][j]; 
+        }
+
+        // for printing purposes
+        public void print1d(int a[] , PrintWriter out){
+            for(int i=0;i<a.length;i++)
+                out.print(a[i] + "" "");
+            out.println();
+        }
+        public void print1d(long a[] , PrintWriter out){
+            for(int i=0;i<a.length;i++)
+                out.print(a[i] + "" "");
+            out.println();
+        }
+        public void print2d(int a[][] , PrintWriter out){
+            for(int i=0;i<a.length;i++){
+                for(int j=0;j<a[i].length;j++)
+                    out.print(a[i][j] + "" "");
+                out.println();
+            }
+            // out.println();
+        }
+        public void print2d(long a[][] , PrintWriter out){
+            for(int i=0;i<a.length;i++){
+                for(int j=0;j<a[i].length;j++)
+                    out.print(a[i][j] + "" "");
+                out.println();
+            }
+            // out.println();
+        }
+
+
+        public void sieve(int a[]){
+            a[0] = a[1] = 1;
+            int i;
+            for(i=2;i*i<=a.length;i++){
+                if(a[i] != 0)
+                    continue;
+                a[i] = i;
+                for(int k = (i)*(i);k<a.length;k+=i){
+                    if(a[k] != 0)
+                        continue;
+                    a[k] = i;
+                }
+            }
+        }
+
+        public long nCrPFermet(int n , int r , long p){
+            if(r==0)
+                return 1l;
+            // long fact[] = new long[n+1];
+            // fact[0] = 1;
+            // for(int i=1;i<=n;i++)
+            //     fact[i] = (i*fact[i-1])%p;
+            long modInverseR = pow(fact[r] , p-2 , p);
+            long modInverseNR = pow(fact[n-r] , p-2 , p);
+            long w = (((fact[n]*modInverseR)%p)*modInverseNR)%p;
+            return w;
+        }
+        public long pow(long a, long b, long m) {
+            a %= m;
+            long res = 1;
+            while (b > 0) {
+                long x = b&1;
+                if (x == 1)
+                    res = res * a % m;
+                a = a * a % m;
+                b >>= 1;
+            }
+            return res;
+        }
+        public long pow(long a, long b) {
+            long res = 1;
+            while (b > 0) {
+                long x = b&1;
+                if (x == 1)
+                    res = res * a;
+                a = a * a;
+                b >>= 1;
+            }
+            return res;
+        }
+        public void sortedArrayToBST(TreeSet<Integer> a , int start, int end) { 
+            if (start > end) {
+                return;
+            }
+            int mid = (start + end) / 2;
+            a.add(mid);
+            sortedArrayToBST(a, start, mid - 1);
+            sortedArrayToBST(a, mid + 1, end); 
+        }
+        class Combine{
+            int value;
+            int delete;
+            Combine(int val , int delete){
+                this.value = val;
+                this.delete = delete;
+            }
+        }
+        class Sort2 implements Comparator<Combine>{
+            public int compare(Combine a , Combine b){
+                if(a.value > b.value)
+                    return 1;
+                else if(a.value == b.value && a.delete>b.delete)
+                    return 1;
+                else if(a.value == b.value && a.delete == b.delete)
+                    return 0;
+                return -1;
+            }
+        }
+        public int lowerLastBound(ArrayList<Integer> a , int x){
+            int l = 0;
+            int r = a.size()-1;
+            if(a.get(l)>=x)
+                return -1;
+            if(a.get(r)<x)
+                return r;
+            int mid = -1;
+            while(l<=r){
+                mid = (l+r)/2;
+                if(a.get(mid) == x && a.get(mid-1)<x)
+                    return mid-1;
+                else if(a.get(mid)>=x)
+                    r = mid-1;
+                else if(a.get(mid)<x && a.get(mid+1)>=x)
+                    return mid;
+                else if(a.get(mid)<x && a.get(mid+1)<x)
+                    l = mid+1;
+            }
+            return mid;
+        }
+        public int upperFirstBound(ArrayList<Integer> a , Integer x){
+            int l = 0;
+            int r = a.size()-1;
+            if(a.get(l)>x)
+                return l;
+            if(a.get(r)<=x)
+                return r+1;
+            int mid = -1;
+            while(l<=r){
+                mid = (l+r)/2;
+                if(a.get(mid) == x && a.get(mid+1)>x)
+                    return mid+1;
+                else if(a.get(mid)<=x)
+                    l = mid+1;
+                else if(a.get(mid)>x && a.get(mid-1)<=x)
+                    return mid;
+                else if(a.get(mid)>x && a.get(mid-1)>x)
+                    r = mid-1;
+            }
+            return mid;
+        }
+        public int lowerLastBound(int a[] , int x){
+            int l = 0;
+            int r = a.length-1;
+            if(a[l]>=x)
+                return -1;
+            if(a[r]<x)
+                return r;
+            int mid = -1;
+            while(l<=r){
+                mid = (l+r)/2;
+                if(a[mid] == x && a[mid-1]<x)
+                    return mid-1;
+                else if(a[mid]>=x)
+                    r = mid-1;
+                else if(a[mid]<x && a[mid+1]>=x)
+                    return mid;
+                else if(a[mid]<x && a[mid+1]<x)
+                    l = mid+1;
+            }
+            return mid;
+        }
+        public int upperFirstBound(long a[] , long x){
+            int l = 0;
+            int r = a.length-1;
+            if(a[l]>x)
+                return l;
+            if(a[r]<=x)
+                return r+1;
+            int mid = -1;
+            while(l<=r){
+                mid = (l+r)/2;
+                if(a[mid] == x && a[mid+1]>x)
+                    return mid+1;
+                else if(a[mid]<=x)
+                    l = mid+1;
+                else if(a[mid]>x && a[mid-1]<=x)
+                    return mid;
+                else if(a[mid]>x && a[mid-1]>x)
+                    r = mid-1;
+            }
+            return mid;
+        }
+        public long log(float number , int base){
+            return (long) Math.ceil((Math.log(number) / Math.log(base)) + 1e-9);
+        }
+        public long gcd(long a , long b){
+            if(a<b){
+                long c = b;
+                b = a;
+                a = c;
+            }
+            while(b!=0){
+                long c = a;
+                a = b;
+                b = c%a;
+            }
+            return a;
+        }
+        public long[] gcdEx(long p, long q) {
+            if (q == 0)
+                return new long[] { p, 1, 0 };
+            long[] vals = gcdEx(q, p % q);
+            long d = vals[0];
+            long a = vals[2];
+            long b = vals[1] - (p / q) * vals[2];
+            // 0->gcd 1->xValue 2->yValue
+            return new long[] { d, a, b };
+        }
+        public void sievePhi(int a[]){
+            a[0] = 0;
+            a[1] = 1;
+            for(int i=2;i<a.length;i++)
+                a[i] = i-1;
+            for(int i=2;i<a.length;i++)
+                for(int j = 2*i;j<a.length;j+=i)
+                    a[j] -= a[i];
+        }
+        public void lcmSum(long a[]){
+            int sievePhi[] = new int[(int)1e6 + 1];
+            sievePhi(sievePhi);
+            a[0] = 0;
+            for(int i=1;i<a.length;i++)
+                for(int j = i;j<a.length;j+=i)
+                    a[j] += (long)i*sievePhi[i];
+        }
+    }
+
+    static class InputReader {
+        public BufferedReader reader;
+        public StringTokenizer tokenizer;
+
+        public InputReader(InputStream stream) {
+            reader = new BufferedReader(new InputStreamReader(stream), 32768);
+            tokenizer = null;
+        }
+
+        public String next() {
+            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
+                try {
+                    tokenizer = new StringTokenizer(reader.readLine());
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+            }
+            return tokenizer.nextToken();
+        }
+
+        public int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        public long nextLong() {
+            return Long.parseLong(next());
+        }
+
+    }
+}",1
+132281e9,f415c0bf,"
+
+import java.io.*;
+import java.math.*;
+import java.util.*;
+
+
+public class test {
+	 
+	   static class Pair{ 
+		   long x;
+		   long y;
+		   
+		   Pair(long x,long y){ 
+			   this.x = x;
+			   this.y = y;
+			   
+		   }
+	   }
+	   static class Duo{
+		   int x;
+		   String s;
+		   
+		   Duo(int x,String s){
+			   this.x = x;
+			   this.s = s;
+		   }
+	   }
+	 
+	   static class Sort implements Comparator<Pair>
+	   {
+
+	       @Override
+	       public int compare(Pair a, Pair b)
+	       {
+	           if(a.x!=b.x)
+	           {
+	               return (int)(a.x - b.x);
+	           }
+	           else
+	           {
+	               return (int)(a.y-b.y);
+	           }
+	       }
+	   }
+	   
+	   static class Compare { 
+		   
+		     void compare(Pair arr[], int n) 
+		    { 
+		        // Comparator to sort the pair according to second element 
+		        Arrays.sort(arr, new Comparator<Pair>() { 
+		            @Override public int compare(Pair p1, Pair p2) 
+		            { 
+		            	if(p1.x!=p2.x) {
+		                return (int)(p1.x - p2.x); 
+		            	}
+		            	else { 
+		            		return (int)(p1.y - p2.y);
+		            	}
+		            } 
+		        }); 
+		  
+//		        for (int i = 0; i < n; i++) { 
+//		            System.out.print(arr[i].x + "" "" + arr[i].y + "" ""); 
+//		        } 
+//		        System.out.println(); 
+		    } 
+		} 
+	 
+	   static class Scanner {
+	        BufferedReader br;
+	        StringTokenizer st;
+	 
+	        public Scanner()
+	        {
+	            br = new BufferedReader(
+	                new InputStreamReader(System.in));
+	        }
+	 
+	        String next()
+	        {
+	            while (st == null || !st.hasMoreElements()) {
+	                try {
+	                    st = new StringTokenizer(br.readLine());
+	                }
+	                catch (IOException e) {
+	                    e.printStackTrace();
+	                }
+	            }
+	            return st.nextToken();
+	        }
+	 
+	        int nextInt() { return Integer.parseInt(next()); }
+	 
+	        long nextLong() { return Long.parseLong(next()); }
+	 
+	        double nextDouble()
+	        {
+	            return Double.parseDouble(next());
+	        }
+	 
+	        String nextLine()
+	        {
+	            String str = """";
+	            try {
+	                str = br.readLine();
+	            }
+	            catch (IOException e) {
+	                e.printStackTrace();
+	            }
+	            return str;
+	        }
+	    }
+	
+	static boolean function(long a[],long x) {
+		
+		long arr[] = new long[a.length];
+		
+		for(int i=0;i<arr.length;i++) {
+			arr[i] = a[i];
+		}
+		
+		for(int i=arr.length-1;i>=2;i--) {
+			
+			if(arr[i] < x) {
+				return false;
+			}
+			long d = Math.min(a[i],(arr[i]-x))/3;
+			
+			arr[i-1] += d;
+			arr[i-2] += 2*d;
+		}
+		
+		return (arr[0]>=x && arr[1]>=x);
+	}
+	   public static void main(String args[]) throws Exception { 
+		
+		   Scanner sc = new Scanner();
+		   StringBuilder res = new StringBuilder();
+		
+		   int tc = sc.nextInt();
+		  
+		   while(tc-->0) { 
+			  
+			int n = sc.nextInt();
+			
+			long a[] = new long[n];
+			
+			for(int i=0;i<n;i++) {
+				a[i] = sc.nextLong();
+			}
+			
+			long l = 1;
+			long r = 1000000000;
+			
+			long ans = 1;
+			
+			while(l<=r){
+				
+				long mid = l + (r-l)/2;
+				
+				if(function(a,mid)){
+					ans = mid;
+					l = mid+1;
+				}
+				else {
+					r = mid-1;
+				}
+			}
+			
+			res.append(ans+""\n"");
+		   }
+		   System.out.println(res);
+	   }
+}  
+
+
+
+
+","
+import java.util.Scanner;
+
+public class BalancedStoneHeaps {
+
+    static boolean check(long[] a, long k) {
+        int n = a.length;
+        long[] temp = new long[n];
+        for (int i = 0; i < n; i++) {
+            temp[i] = a[i];
+        }
+        for (int i = n - 1; i >= 2; i--) {
+            if (temp[i] < k) {
+                
+                return false;
+            }
+            long p = Math.min(a[i] / 3, (temp[i] - k) / 3);
+            temp[i - 1] += p;
+            temp[i - 2] += 2 * p;
+
+        }
+
+        if (temp[0] >= k && temp[1] >= k) {
+            return true;
+        }
+
+        return false;
+
+    }
+
+    public static void main(String[] args) {
+        Scanner scan = new Scanner(System.in);
+        int t = scan.nextInt();
+        while (t-- > 0) {
+            int n = scan.nextInt();
+            long[] a = new long[n];
+            for (int i = 0; i < n; i++) {
+                a[i] = scan.nextInt();
+            }
+            long l = 0;
+            long r = a[n - 1];
+            long res = 0;
+            while (l <= r) {
+                long mid = (l + r) / 2;
+                if (check(a, mid)) {
+                    l = mid + 1;
+                    res = Math.max(res, mid);
+                } else {
+                    r = mid - 1;
+                }
+            }
+            System.out.println(res);
+        }
+    }
+}
+",1
+60c85a4f,8926151a,"import java.util.*;
+import java.io.*;
+import java.lang.*;
+
+public class Solution {
+    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+    PrintWriter out = new PrintWriter(System.out);
+    StringTokenizer st = new StringTokenizer("""");
+
+    String next() {
+        if (!st.hasMoreTokens()) {
+            try {
+                st = new StringTokenizer(br.readLine());
+            } catch (Exception e) {
+
+            }
+        }
+        return st.nextToken();
+    }
+
+    int nextInt() {
+        return Integer.parseInt(next());
+    }
+
+    long nextLong() {
+        return Long.parseLong(next());
+    }
+
+    public static void main(String[] args) {
+        new Solution().solve();
+    }
+
+    long res = Long.MAX_VALUE;
+    List<Integer> l = new ArrayList<>(), r = new ArrayList<>();
+    long dp[][];
+
+    long ok(int i, int j) {
+        if (dp[i][j] != -1)
+            return dp[i][j];
+        if (i >= l.size()) {
+            return 0;
+        }
+        if (j >= r.size())
+            return Integer.MAX_VALUE;
+        long op1 = ok(i + 1, j + 1) + Math.abs(l.get(i) - r.get(j));
+        long op2 = ok(i, j + 1);
+
+        return dp[i][j] = Math.min(op1, op2);
+    }
+
+    void solve() {
+        int t = 1;
+        // t = nextInt();
+        for (int tt = 0; tt < t; tt++) {
+            int n = nextInt();
+            int arr[] = new int[n];
+            for (int i = 0; i < n; i++) {
+                arr[i] = nextInt();
+                if (arr[i] == 0)
+                    r.add(i + 1);
+                else
+                    l.add(i + 1);
+            }
+            dp = new long[n][n];
+            for (int i = 0; i < n; i++)
+                Arrays.fill(dp[i], -1);
+            out.println(ok(0, 0));
+        }
+        out.close();
+    }
+}","import java.util.*;
+import java.io.*;
+
+public class _1525_D {
+    public static void main(String[] args) throws IOException {
+        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
+        PrintWriter out = new PrintWriter(System.out);
+        int n = Integer.parseInt(in.readLine());
+        int[] a = new int[n];
+        StringTokenizer line = new StringTokenizer(in.readLine());
+        int c = 0;
+        for (int i = 0; i < n; i++) {
+            a[i] = Integer.parseInt(line.nextToken());
+            if (a[i] == 1)
+                c++;
+        }
+        int[] pos = new int[c];
+        int count = 0;
+        for (int i = 0; i < n; i++) {
+            if (a[i] == 1) {
+                pos[count] = i;
+                count++;
+            }
+        }
+        int[][] dp = new int[c + 1][n];
+        for (int i = 1; i <= c; i++) {
+            Arrays.fill(dp[i], Integer.MAX_VALUE);
+        }
+        for (int i = 1; i <= c; i++) {
+            for (int j = 0; j < n; j++) {
+                if (j > 0) {
+                    if (a[j] == 0) {
+                        if (dp[i - 1][j - 1] != Integer.MAX_VALUE) {
+                            dp[i][j] = dp[i - 1][j - 1] + Math.abs(j - pos[i - 1]);
+                        }
+                    }
+                    dp[i][j] = Math.min(dp[i][j], dp[i][j - 1]);
+                } else {
+                    if (a[j] == 0 && i == 1) {
+                        dp[i][j] = Math.abs(j - pos[i - 1]);
+                    }
+                }
+            }
+        }
+        out.println(dp[c][n - 1]);
+        in.close();
+        out.close();
+    }
+}",0
+16857116,6e207cbf,"import javax.swing.plaf.IconUIResource;
+import java.lang.reflect.Array;
+import java.text.CollationElementIterator;
+import java.util.*;
+import java.io.*;
+
+//Timus judge id- 323935JJ
+
+
+public class Main {
+
+
+
+
+    //----------------------------------------------------------------------------------------------
+    public static class Pair implements Comparable<Pair> {
+        int x=0,y=0;
+        int z=0;
+        public Pair(int a, int b) {
+            this.x=a;
+            this.y=b;
+
+        }
+
+        public int compareTo(Pair o) {
+            return this.x - o.x;
+        }
+    }
+
+
+    public static int mod = (int) (1e9 + 7);
+    static int ans = Integer.MAX_VALUE;
+
+    public static void main(String hi[]) throws Exception {
+        FastReader sc = new FastReader();
+        int t =sc.nextInt();
+        while(t-->0)
+        {
+            int n =sc.nextInt();
+            String a = sc.nextLine(),b=sc.nextLine();
+
+            int count1=0,count2=0,count3=0,count4=0;
+
+            for(int i=0;i<n;i++)
+            {
+                if(a.charAt(i)=='0'&&b.charAt(i)=='0')
+                    count1++;
+                else  if(a.charAt(i)=='1'&&b.charAt(i)=='1')
+                    count2++;
+                else  if(a.charAt(i)=='1'&&b.charAt(i)=='0')
+                    count3++;
+                else  if(a.charAt(i)=='0'&&b.charAt(i)=='1')
+                    count4++;
+            }
+            int ans=Integer.MAX_VALUE;
+
+            if(count3==count4)
+                ans=Math.min(count3*2,ans);
+
+            if(count2==count1+1)
+                ans=Math.min(ans,2*count1+1);
+
+            if(count2==1&&count1==0)
+                ans=1;
+            if(count3==0&&count4==0)
+                ans=0;
+            if(ans==Integer.MAX_VALUE)
+                System.out.println(-1);
+            else System.out.println(ans);
+
+        }
+
+    }
+
+    static int find(int[] a,int x)
+    {
+        if(a[x]==-1)
+            return x;
+        else return find(a,a[x]);
+    }
+
+
+
+
+
+    static int gcd(int a, int b)
+    {
+        if (a == 0)
+            return b;
+        return gcd(b % a, a);
+    }
+
+    // method to return LCM of two numbers
+    static int lcm(int a, int b)
+    {
+        return (a / gcd(a, b)) * b;
+    }
+
+
+    static long gcdl(long a, long b)
+    {
+        if (a == 0)
+            return b;
+        return gcdl(b % a, a);
+    }
+
+    // method to return LCM of two numbers
+    static long lcml(long a, long b)
+    {
+        return (a / gcdl(a, b)) * b;
+    }
+
+
+    static class FastReader {
+        BufferedReader br;
+        StringTokenizer st;
+
+        public FastReader() {
+            br = new BufferedReader(new
+                    InputStreamReader(System.in));
+        }
+
+        String next() {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+
+        String nextLine() {
+            String str = """";
+            try {
+                str = br.readLine();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+
+        }
+    }
+}
+
+","import java.util.*;
+import java.lang.*;
+import java.io.*;
+
+public class Codechef
+{
+	public static void main (String[] args) throws java.lang.Exception
+	{
+        Scanner sc = new Scanner(System.in);
+        int t = sc.nextInt();
+        int sm, n;
+        while(t > 0) {
+            t--;
+            n = sc.nextInt();
+            String s1,s2;
+            s1 = sc.next();
+            s2 = sc.next();
+            int a[] = new int[4];
+            a[0] = 0; a[1] = 0; a[2] = 0; a[3] = 0;
+            for(int i = 0 ; i < n ; i++) {
+                if(s1.charAt(i) == '0'&& s2.charAt(i) == '1') a[0]++;
+                else if(s1.charAt(i) == '1'&& s2.charAt(i) == '0') a[1]++;
+                else if(s1.charAt(i) == '1'&& s2.charAt(i) == '1') a[2]++;
+                else a[3]++;
+            }
+            // System.out.println(a[0] + "" "" + a[1] + "" "" + a[2] + "" "" + a[3]);
+            int n1 = Integer.MAX_VALUE, n2 = Integer.MAX_VALUE, n3 = Integer.MAX_VALUE;
+            
+            if (a[0] == a[1]) {
+                n1 = 2*a[0];
+            }
+            if((a[2] - 1) == a[3]) {
+                // System.out.println(a[3] + 1);
+                n2 = 2*a[3] + 1;
+            } 
+            if((a[3] + 1) == a[2]) {
+                // System.out.println(a[2] + 1);
+                n3 = 2*a[2] + 1;
+            } 
+            int ans = Math.min(n1, Math.min(n2,n3));
+            if(ans == Integer.MAX_VALUE) {
+                System.out.println(""-1"");
+            } else {
+                System.out.println(ans);
+            }
+        }
+	}
+}
+",0
+4685c420,77448a05,"// package Div3_734;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+import java.util.Collections;
+
+public class ProblemC {
+    public static void main(String[] args)throws IOException {
+        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+        StringBuilder print=new StringBuilder();
+        int test=Integer.parseInt(br.readLine());
+        while(test--!=0){
+            int n=Integer.parseInt(br.readLine());
+            ArrayList<Story> stories[]=new ArrayList[5];
+            for(int i=0;i<5;i++){
+                stories[i]=new ArrayList<>();
+            }
+            for(int i=1;i<=n;i++){
+                char c[]=br.readLine().toCharArray();
+                int freq[]=new int[5];
+                for(int j=0;j<c.length;j++){
+                    freq[c[j]-97]++;
+                }
+                for(int j=0;j<5;j++){
+                    stories[j].add(new Story(freq[j],c.length-freq[j]));
+                }
+            }
+            for(int i=0;i<5;i++){
+                Collections.sort(stories[i]);
+            }
+            int max=0;
+            for(int i=0;i<5;i++){
+                int def=0;
+                int count=0;
+                for(Story story:stories[i]){
+                    int diff=story.diff;
+                    if(def+diff<=0){
+                        break;
+                    }
+                    else{
+                        def+=diff;
+                        count++;
+                    }
+                }
+                max=Math.max(max,count);
+            }
+            print.append(max+""\n"");
+        }
+        System.out.print(print);
+    }
+}
+
+class Story implements Comparable<Story>{
+    int x,y,diff;
+    public Story(int x,int y){
+        this.x=x;
+        this.y=y;
+        this.diff=this.x-this.y;
+    }
+
+    @Override
+    public int compareTo(Story o) {
+        return -this.diff+o.diff;
+    }
+}","//package currentContest;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Random;
+import java.util.StringTokenizer;
+
+public class P4 {
+	static int N = 1000001;
+
+	// Array to store inverse of 1 to N
+	static long[] factorialNumInverse = new long[N + 1];
+
+	// Array to precompute inverse of 1! to N!
+	static long[] naturalNumInverse = new long[N + 1];
+
+	// Array to store factorial of first N numbers
+	static long[] fact = new long[N + 1];
+
+	// Function to precompute inverse of numbers
+	public static void InverseofNumber(int p) {
+		naturalNumInverse[0] = naturalNumInverse[1] = 1;
+
+		for (int i = 2; i <= N; i++)
+			naturalNumInverse[i] = naturalNumInverse[p % i] * (long) (p - p / i) % p;
+	}
+
+	// Function to precompute inverse of factorials
+	public static void InverseofFactorial(int p) {
+		factorialNumInverse[0] = factorialNumInverse[1] = 1;
+
+		// Precompute inverse of natural numbers
+		for (int i = 2; i <= N; i++)
+			factorialNumInverse[i] = (naturalNumInverse[i] * factorialNumInverse[i - 1]) % p;
+	}
+
+	// Function to calculate factorial of 1 to N
+	public static void factorial(int p) {
+		fact[0] = 1;
+
+		// Precompute factorials
+		for (int i = 1; i <= N; i++) {
+			fact[i] = (fact[i - 1] * (long) i) % p;
+		}
+	}
+
+	// Function to return nCr % p in O(1) time
+	public static long Binomial(int N, int R, int p) {
+
+		// n C r = n!*inverse(r!)*inverse((n-r)!)
+		long ans = ((fact[N] * factorialNumInverse[R]) % p * factorialNumInverse[N - R]) % p;
+
+		return ans;
+	}
+
+	public static void main(String[] args) {
+		// TODO Auto-generated method stub
+		FastReader sc = new FastReader();
+		int t;
+		t = sc.nextInt();
+		StringBuilder st = new StringBuilder();
+//		int p = 998244353;
+//	    InverseofNumber(p);
+//	    InverseofFactorial(p);
+//	    factorial(p);
+		// System.out.println(3|1);
+		while (t-- != 0) {
+			int n=sc.nextInt();
+			String s[]=new String[n];
+			for(int i=0;i<n;i++) {
+				s[i]=sc.nextLine();
+			}
+			int max=0;
+			ArrayList<Integer> freq=new ArrayList<>();
+			for(int i=0;i<5;i++) {
+				int f1=0;
+				freq=new ArrayList<>();
+				for(int j=0;j<n;j++) {
+					f1=0;
+					for(int k=0;k<s[j].length();k++) {
+						if(s[j].charAt(k)==i+'a') {
+							f1++;
+						}else {
+							f1--;
+						}
+					}
+					freq.add(f1);
+				}
+				Collections.sort(freq);
+				int x=0;
+				int total=0;
+				for(int j=n-1;j>=0;j--) {
+					total=total+freq.get(j);
+					if(total>0) {
+						x++;
+					}else {
+						break;
+					}
+				}
+				max=Math.max(max, x);
+			}
+			st.append(max+""\n"");
+		}
+		System.out.println(st);
+	}
+
+	static FastReader sc = new FastReader();
+
+	public static void solvegraph() {
+		int n = sc.nextInt();
+
+		int edge[][] = new int[n - 1][2];
+		for (int i = 0; i < n - 1; i++) {
+			edge[i][0] = sc.nextInt() - 1;
+			edge[i][1] = sc.nextInt() - 1;
+		}
+		ArrayList<ArrayList<Integer>> ad = new ArrayList<>();
+		for (int i = 0; i < n; i++) {
+			ad.add(new ArrayList<Integer>());
+		}
+		for (int i = 0; i < n - 1; i++) {
+			ad.get(edge[i][0]).add(edge[i][1]);
+			ad.get(edge[i][1]).add(edge[i][0]);
+		}
+		int parent[] = new int[n];
+		Arrays.fill(parent, -1);
+		parent[0] = n;
+		ArrayDeque<Integer> queue = new ArrayDeque<>();
+		queue.add(0);
+		int child[] = new int[n];
+		Arrays.fill(child, 0);
+		ArrayList<Integer> lv = new ArrayList<Integer>();
+		while (!queue.isEmpty()) {
+			int toget = queue.getFirst();
+			queue.removeFirst();
+			child[toget] = ad.get(toget).size() - 1;
+			for (int i = 0; i < ad.get(toget).size(); i++) {
+				if (parent[ad.get(toget).get(i)] == -1) {
+					parent[ad.get(toget).get(i)] = toget;
+					queue.addLast(ad.get(toget).get(i));
+				}
+			}
+			lv.add(toget);
+		}
+
+		child[0]++;
+	}
+
+	static void sort(int[] A) {
+		int n = A.length;
+		Random rnd = new Random();
+		for (int i = 0; i < n; ++i) {
+			int tmp = A[i];
+			int randomPos = i + rnd.nextInt(n - i);
+			A[i] = A[randomPos];
+			A[randomPos] = tmp;
+		}
+		Arrays.sort(A);
+	}
+
+	static void sort(long[] A) {
+		int n = A.length;
+		Random rnd = new Random();
+		for (int i = 0; i < n; ++i) {
+			long tmp = A[i];
+			int randomPos = i + rnd.nextInt(n - i);
+			A[i] = A[randomPos];
+			A[randomPos] = tmp;
+		}
+		Arrays.sort(A);
+	}
+
+	static String sort(String s) {
+		Character ch[] = new Character[s.length()];
+		for (int i = 0; i < s.length(); i++) {
+			ch[i] = s.charAt(i);
+		}
+		Arrays.sort(ch);
+		StringBuffer st = new StringBuffer("""");
+		for (int i = 0; i < s.length(); i++) {
+			st.append(ch[i]);
+		}
+		return st.toString();
+	}
+
+	public static long gcd(long a, long b) {
+		if (a == 0) {
+			return b;
+		}
+		return gcd(b % a, a);
+	}
+
+	static class FastReader {
+		BufferedReader br;
+		StringTokenizer st;
+
+		public FastReader() {
+			br = new BufferedReader(new InputStreamReader(System.in));
+		}
+
+		String next() {
+			while (st == null || !st.hasMoreElements()) {
+				try {
+					st = new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			}
+			return st.nextToken();
+		}
+
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+
+		double nextDouble() {
+			return Double.parseDouble(next());
+		}
+
+		String nextLine() {
+			String str = """";
+			try {
+				str = br.readLine();
+			} catch (IOException e) {
+				e.printStackTrace();
+			}
+			return str;
+		}
+	}
+}
+",0
+3b498a39,9028caf7,"/*
+ *     HI THERE! (: 
+ * 
+ * CREATED BY : NAITIK V
+ * 
+ *     JAI HIND
+ * 
+ */
+
+import java.util.*;
+
+
+import java.io.*;
+import java.math.*;
+
+public class Main
+
+{ 
+	 static FastReader sc=new FastReader(); 
+	 static long dp[][];
+	 static int mod=1000000007;
+	 static int max;
+	  public static void main(String[] args)
+{
+		   PrintWriter out=new PrintWriter(System.out);
+		   //StringBuffer sb=new StringBuffer("""");
+		  int ttt=1;
+		   //ttt =i();
+		 
+	        outer :while (ttt-- > 0) 
+			{
+	        	int n=i();
+	        	int A[]=input(n);
+	        	dp=new long[n+1][n+1];
+	        	for(int i=0;i<=n;i++) {
+	        		Arrays.fill(dp[i],-1);
+	        	}
+		        	
+	        	
+	        	ArrayList<Integer> l=new ArrayList<Integer>();
+	        	ArrayList<Integer> m=new ArrayList<Integer>();
+	        	for(int i=0;i<n;i++) {
+	        		if(A[i]==0) {
+	        			l.add(i+1);
+	        		}
+	        		else {
+	        			m.add(i+1);
+	        		}
+	        	}
+	        	A=new int[m.size()];
+	        	int B[]=new int[l.size()];
+	        	for(int i=0;i<l.size();i++) {
+	        		B[i]=l.get(i);
+	        	}
+	        	for(int i=0;i<m.size();i++) {
+	        		A[i]=m.get(i);
+	        	}
+	        	n=m.size();
+	        	int o=l.size();
+		        	System.out.println(go(A,B,0,0,n,o));
+	        	
+			}
+
+	     //System.out.println(sb.toString());
+		     out.close();
+	     
+	     
+	    //CHECK FOR N=1                    //CHECK FOR M=0
+        //CHECK FOR N=1                    //CHECK FOR M=0
+       	//CHECK FOR N=1
+       	//CHECK FOR N=1
+       	//CHECK FOR N=1
+		        
+		     
+    }
+	  
+	 
+	  
+	  
+	
+	 
+	private static long go(int[] A, int[] B, int i, int j, int n, int m) {
+		if(i==n)
+			return 0;
+		if(j==m)
+			return Integer.MAX_VALUE;
+		if(dp[i][j]!=-1)
+			return dp[i][j];
+		long op1=go(A, B, i+1, j+1, n, m)+Math.abs(A[i]-B[j]);
+		long op2=go(A, B, i, j+1, n, m);
+		return dp[i][j]=Math.min(op1, op2);
+	
+		
+		
+		
+		
+		}
+
+
+
+
+
+
+static class Pair implements Comparable<Pair>
+     {
+    	 int x;
+    	 int y;
+    	 Pair(int x,int y){
+    		 this.x=x;
+    		 this.y=y;
+    	 }
+		@Override
+		public int compareTo(Pair o) {
+			if(this.x>o.x)
+				return 1;
+			else if(this.x<o.x)
+				return -1;
+			else {
+				if(this.y>o.y)
+					return 1;
+				else if(this.y<o.y)
+					return -1;
+				else
+					return 0;
+			}
+		}
+		
+		/* FOR TREE MAP PAIR USE */
+		
+//		public int compareTo(Pair o) {
+// 			if (x > o.x) {
+// 				return 1;
+// 			}
+// 			if (x < o.x) {
+// 				return -1;
+// 			}
+// 			if (y > o.y) {
+// 				return 1;
+// 			}
+// 			if (y < o.y) {
+// 				return -1;
+// 			}
+// 			return 0;
+// 		}
+	
+		
+     }
+
+static int[] input(int n) {
+	int A[]=new int[n];
+	   for(int i=0;i<n;i++) {
+		   A[i]=sc.nextInt();
+	   }
+	   return A;
+   }
+static long[] inputL(int n) {
+	long A[]=new long[n];
+	   for(int i=0;i<n;i++) {
+		   A[i]=sc.nextLong();
+	   }
+	   return A;
+   }
+static String[] inputS(int n) {
+	String A[]=new String[n];
+	   for(int i=0;i<n;i++) {
+		   A[i]=sc.next();
+	   }
+	   return A;
+   }
+static long sum(int A[]) {
+	long sum=0;
+	for(int i : A) {
+		sum+=i;
+	}
+	return sum;
+}
+static long sum(long A[]) {
+	long sum=0;
+	for(long i : A) {
+		sum+=i;
+	}
+	return sum;
+}
+static void reverse(long A[]) {
+	int n=A.length;
+	long B[]=new long[n];
+	for(int i=0;i<n;i++) {
+		B[i]=A[n-i-1];
+	}
+	for(int i=0;i<n;i++)
+		A[i]=B[i];
+	
+}
+static void reverse(int A[]) {
+	int n=A.length;
+	int B[]=new int[n];
+	for(int i=0;i<n;i++) {
+		B[i]=A[n-i-1];
+	}
+	for(int i=0;i<n;i++)
+		A[i]=B[i];
+	
+}
+static void input(int A[],int B[]) {
+	   for(int i=0;i<A.length;i++) {
+		   A[i]=sc.nextInt();
+		   B[i]=sc.nextInt();
+	   }
+}
+static int[][] input(int n,int m){
+	int A[][]=new int[n][m];
+	for(int i=0;i<n;i++) {
+		for(int j=0;j<m;j++) {
+			A[i][j]=i();
+		}
+	}
+	return A;
+}
+static char[][] charinput(int n,int m){
+	char A[][]=new char[n][m];
+	for(int i=0;i<n;i++) {
+		String s=s();
+		for(int j=0;j<m;j++) {
+			A[i][j]=s.charAt(j);
+		}
+	}
+	return A;
+}
+static int max(int A[]) {
+	int max=Integer.MIN_VALUE;
+	for(int i=0;i<A.length;i++) {
+		max=Math.max(max, A[i]);
+	}
+	return max;
+}
+static int min(int A[]) {
+	int min=Integer.MAX_VALUE;
+	for(int i=0;i<A.length;i++) {
+		min=Math.min(min, A[i]);
+	}
+	return min;
+}
+static long max(long A[]) {
+	long max=Long.MIN_VALUE;
+	for(int i=0;i<A.length;i++) {
+		max=Math.max(max, A[i]);
+	}
+	return max;
+}
+static long min(long A[]) {
+	long min=Long.MAX_VALUE;
+	for(int i=0;i<A.length;i++) {
+		min=Math.min(min, A[i]);
+	}
+	return min;
+}
+static long [] prefix(long A[]) {
+	long p[]=new long[A.length];
+	p[0]=A[0];
+	for(int i=1;i<A.length;i++)
+		p[i]=p[i-1]+A[i];
+	return p;
+}
+static long [] prefix(int A[]) {
+	long p[]=new long[A.length];
+	p[0]=A[0];
+	for(int i=1;i<A.length;i++)
+		p[i]=p[i-1]+A[i];
+	return p;
+}
+static long [] suffix(long A[]) {
+	long p[]=new long[A.length];
+	p[A.length-1]=A[A.length-1];
+	for(int i=A.length-2;i>=0;i--)
+		p[i]=p[i+1]+A[i];
+	return p;
+}
+static long [] suffix(int A[]) {
+	long p[]=new long[A.length];
+	p[A.length-1]=A[A.length-1];
+	for(int i=A.length-2;i>=0;i--)
+		p[i]=p[i+1]+A[i];
+	return p;
+}
+static long power(long x, long y, long p)
+{
+
+	if(y==0)
+		return 1;
+	if(x==0)
+		return 0;
+    long res = 1;
+    x = x % p;
+
+    while (y > 0) {
+
+        if (y % 2 == 1)
+            res = (res * x) % p;
+
+        y = y >> 1; 
+        x = (x * x) % p;
+    }
+
+    return res;
+}
+static void print(int A[]) {
+	for(int i : A) {
+		System.out.print(i+"" "");
+	}
+	System.out.println();
+}
+static void print(long A[]) {
+	for(long i : A) {
+		System.out.print(i+"" "");
+	}
+	System.out.println();
+}
+static long mod(long x) {
+	  return ((x%mod + mod)%mod);
+}
+static String reverse(String s) {
+	StringBuffer p=new StringBuffer(s);
+	p.reverse();
+	return p.toString();
+}
+
+     static int i() {
+    	 return sc.nextInt();
+     }
+     static String s() {
+    	 return sc.next();
+     }
+     static long l() {
+    	 return sc.nextLong();
+     }  
+     static void sort(int[] A){
+        int n = A.length;
+        Random rnd = new Random();
+        for(int i=0; i<n; ++i){
+            int tmp = A[i];
+            int randomPos = i + rnd.nextInt(n-i);
+            A[i] = A[randomPos];
+            A[randomPos] = tmp;
+        }
+        Arrays.sort(A);
+     }
+     static void sort(long[] A){
+	        int n = A.length;
+	        Random rnd = new Random();
+	        for(int i=0; i<n; ++i){
+	            long tmp = A[i];
+	            int randomPos = i + rnd.nextInt(n-i);
+	            A[i] = A[randomPos];
+	            A[randomPos] = tmp;
+	        }
+	        Arrays.sort(A);
+	     }
+  static String sort(String s) {
+ 	 Character ch[]=new Character[s.length()];
+ 	 for(int i=0;i<s.length();i++) {
+ 		 ch[i]=s.charAt(i);
+ 	 }
+ 	 Arrays.sort(ch);
+ 	 StringBuffer st=new StringBuffer("""");
+ 	 for(int i=0;i<s.length();i++) {
+ 		 st.append(ch[i]);
+ 	 }
+ 	 return st.toString();
+  }
+  static HashMap<Integer,Integer> hash(int A[]){
+	  HashMap<Integer,Integer> map=new HashMap<Integer, Integer>();
+	  for(int i : A) {
+		  if(map.containsKey(i)) {
+			  map.put(i, map.get(i)+1);
+		  }
+		  else {
+			  map.put(i, 1);
+		  }
+	  }
+	  return map;
+  }
+  static TreeMap<Integer,Integer> tree(int A[]){
+	  TreeMap<Integer,Integer> map=new TreeMap<Integer, Integer>();
+	  for(int i : A) {
+		  if(map.containsKey(i)) {
+			  map.put(i, map.get(i)+1);
+		  }
+		  else {
+			  map.put(i, 1);
+		  }
+	  }
+	  return map;
+  }
+     static boolean prime(int n) 
+	    { 
+	        if (n <= 1) 
+	            return false; 
+	        if (n <= 3) 
+	            return true; 
+	        if (n % 2 == 0 || n % 3 == 0) 
+	            return false; 
+	        double sq=Math.sqrt(n);
+	  
+	        for (int i = 5; i <= sq; i = i + 6) 
+	            if (n % i == 0 || n % (i + 2) == 0) 
+	                return false; 
+	        return true; 
+	    } 
+     static boolean prime(long n) 
+	    { 
+	        if (n <= 1) 
+	            return false; 
+	        if (n <= 3) 
+	            return true; 
+	        if (n % 2 == 0 || n % 3 == 0) 
+	            return false; 
+	        double sq=Math.sqrt(n);
+	  
+	        for (int i = 5; i <= sq; i = i + 6) 
+	            if (n % i == 0 || n % (i + 2) == 0) 
+	                return false; 
+	        return true; 
+	    } 
+     static int gcd(int a, int b) 
+     { 
+         if (a == 0) 
+             return b; 
+         return gcd(b % a, a); 
+     } 
+     static long gcd(long a, long b) 
+     { 
+         if (a == 0) 
+             return b; 
+         return gcd(b % a, a); 
+     } 
+     
+        
+    static class FastReader 
+    { 
+        BufferedReader br; 
+        StringTokenizer st; 
+  
+        public FastReader() 
+        { 
+            br = new BufferedReader(new
+                     InputStreamReader(System.in)); 
+        } 
+  
+        String next() 
+        { 
+            while (st == null || !st.hasMoreElements()) 
+            { 
+                try
+                { 
+                    st = new StringTokenizer(br.readLine()); 
+                } 
+                catch (IOException  e) 
+                { 
+                    e.printStackTrace(); 
+                } 
+            } 
+            return st.nextToken(); 
+        } 
+  
+        int nextInt() 
+        { 
+            return Integer.parseInt(next()); 
+        } 
+  
+        long nextLong() 
+        { 
+            return Long.parseLong(next()); 
+        } 
+  
+        double nextDouble() 
+        { 
+            return Double.parseDouble(next()); 
+        } 
+  
+        String nextLine() 
+        { 
+            String str = """"; 
+            try
+            { 
+                str = br.readLine(); 
+            } 
+            catch (IOException e) 
+            { 
+                e.printStackTrace(); 
+            } 
+            return str; 
+        } 
+    } 
+} 
+
+
+
+","import java.io.*;
+import java.util.*;
+public class Main {
+    public static void main(String args[])
+    {
+        FastReader input=new FastReader();
+        PrintWriter out=new PrintWriter(System.out);
+        int T=1;
+        while(T-->0)
+        {
+            int n=input.nextInt();
+            int a[]=new int[n];
+            ArrayList<Integer> list=new ArrayList<>();
+            ArrayList<Integer> space=new ArrayList<>();
+            for(int i=0;i<n;i++)
+            {
+                a[i]=input.nextInt();
+                if(a[i]==1)
+                {
+                    list.add(i);
+                }
+                else
+                {
+                    space.add(i);
+                }
+            }
+            int pre[]=new int[space.size()];
+            for(int i=0;i<list.size();i++)
+            {
+                if(i==0)
+                {
+                    int min=Integer.MAX_VALUE;
+                    for(int j=0;j<space.size();j++)
+                    {
+                        pre[j]=Math.abs(list.get(i)-space.get(j));
+                        min=Math.min(min,pre[j]);
+                        pre[j]=min;
+                    }
+                }
+                else
+                {
+                    int arr[]=new int[space.size()];
+                    for(int j=0;j<i;j++)
+                    {
+                        arr[j]=Integer.MAX_VALUE;
+                    }
+
+                    int min=Integer.MAX_VALUE;
+                    for(int j=i;j<space.size();j++)
+                    {
+                        int v=Math.abs(list.get(i)-space.get(j));
+                        v+=pre[j-1];
+                        arr[j]=v;
+                        min=Math.min(min,v);
+                        arr[j]=min;
+                    }
+                    for(int j=0;j<space.size();j++)
+                    {
+                        pre[j]=arr[j];
+                    }
+                }
+            }
+            out.println(pre[space.size()-1]);
+        }
+        out.close();
+    }
+    static class FastReader
+    {
+        BufferedReader br;
+        StringTokenizer st;
+        public FastReader()
+        {
+            br = new BufferedReader(new InputStreamReader(System.in));
+        }
+        String next()
+        {
+            while (st == null || !st.hasMoreElements())
+            {
+                try
+                {
+                    st = new StringTokenizer(br.readLine());
+                }
+                catch (IOException e)
+                {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+        int nextInt()
+        {
+            return Integer.parseInt(next());
+        }
+        long nextLong()
+        {
+            return Long.parseLong(next());
+        }
+        double nextDouble()
+        {
+            return Double.parseDouble(next());
+        }
+        String nextLine()
+        {
+            String str="""";
+            try
+            {
+                str=br.readLine();
+            }
+            catch (IOException e)
+            {
+                e.printStackTrace();
+            }
+            return str;
+        }
+    }
+}",0
+38601291,3bcd2014,"import java.io.*;
+import java.util.*;
+
+public class stones {
+    public static void main (String[] args) throws IOException {
+        // set up
+        BufferedReader input = new BufferedReader(new InputStreamReader(System.in));
+        //BufferedReader input = new BufferedReader(new InputStreamReader(new FileInputStream(""test.in"")));
+        PrintWriter out = new PrintWriter(System.out);
+        int T = Integer.parseInt(input.readLine());
+        for (int i=0;i<T;i++) {
+            // read in test case
+            int n = Integer.parseInt(input.readLine());
+            int[] seq = new int[n];
+            StringTokenizer st = new StringTokenizer(input.readLine());
+            int low = 0;
+            int high = 0;
+            for (int j=0;j<n;j++) {
+                seq[j] = Integer.parseInt(st.nextToken());
+                high = Math.max(high, seq[j]);
+            }
+            // binary search on answer
+            while (low<high) {
+                int mid = (low+high+1)/2;
+                //System.out.println(possible(seq, mid));
+                if (possible(seq, mid)) {
+                    low = mid; }
+                else high = mid-1; }
+            out.println(low);
+        }
+        out.close();
+
+    }
+
+    static boolean possible(int[] seq, int goal) {
+        /* checks if array can be made to have smallest value
+        greater than or equal to given goal value */
+        //System.out.println(goal);
+        int L = seq.length;
+        int[] arr = Arrays.copyOf(seq, L);
+        //System.out.println(Arrays.toString(arr));
+        for (int i=L-1;i>=2;i--) {
+            //System.out.println(Arrays.toString(arr));
+            if (arr[i] < goal) return false;
+            int max_d = Math.min((arr[i] - goal)/3, seq[i]/3);
+            //System.out.println(arr[i]);
+            //System.out.println(max_d);
+            arr[i-1] += max_d;
+            arr[i-2] += max_d*2;
+            arr[i] -= max_d*3;
+        }
+        //System.out.println(Arrays.toString(arr));
+        for (int num: arr) {
+            if (num < goal) return false; }
+        return true;
+    }
+}
+","import java.io.*;
+import java.util.*;
+
+import javax.sound.midi.MidiChannel;
+
+public class Main {
+    static PrintWriter out;
+    static Kioken sc;
+
+    public static void main(String[] args) throws FileNotFoundException {
+        boolean t = true;
+        boolean f = false;
+        if (f) {
+            out = new PrintWriter(""output.txt"");
+            sc = new Kioken(""input.txt"");
+        } else {
+            out = new PrintWriter((System.out));
+            sc = new Kioken();
+        }
+
+        int tt = 1;
+        tt = sc.nextInt();
+        while (tt-- > 0) {
+            solve();
+        }
+        out.flush();
+        out.close();
+    }
+
+    static boolean bs(int[] arr, int a){
+    
+      // out.println("" mid1 ""  + Arrays.toString(arr) + "" "" + a);
+
+      int[] curr = Arrays.copyOf(arr, arr.length);
+     for(int i = arr.length - 1; i >= 2; i--){
+       if(arr[i] < a){
+         return false;
+       }
+       int min = Math.min(arr[i] - a, curr[i]);
+       min = min/3;
+       arr[i] -= 3*min;
+       arr[i - 1] += min;
+       arr[i-2] += 2*min;
+     }
+
+      for(int i: arr){
+        if(i < a){
+          return false;
+        }
+      }
+      return true;
+    }
+    public static void solve() {
+       int n = sc.nextInt();
+       int[] arr = new int[n];
+       int max = Integer.MIN_VALUE;
+       for(int i = 0; i < n; i++){
+         arr[i] = sc.nextInt();
+         max = Math.max(max, arr[i]);
+       }
+
+       int l = 0, r = max, ans = 0;
+       while(l <= r){
+         int mid = (l+r)/2;
+        //  out.println("" l r "" + l + "" "" + r);
+         int[] aa = Arrays.copyOf(arr, arr.length);
+         if(bs(aa, mid)){
+          // out.println(Arrays.toString(arr) + "" "" + Arrays.toString(aa) + "" mid ""  + mid );
+            ans = mid;
+            l = mid+1;
+         }else{
+           r = mid-1;
+         }
+       }
+       out.println(ans);
+    }
+
+    public static long leftShift(long a) {
+        return (long) Math.pow(2, a);
+    }
+
+    public static void reverse(int[] arr) {
+        Arrays.sort(arr);
+        int n = arr.length;
+        for (int i = 0; i < arr.length; i++) {
+            int temp = arr[i];
+            arr[i] = arr[n - 1 - i];
+            arr[n - 1 - i] = temp;
+        }
+        return;
+    }
+
+    public static int lower_bound(ArrayList<Integer> ar, int k) {
+        int s = 0, e = ar.size();
+        while (s != e) {
+            int mid = s + e >> 1;
+            if (ar.get(mid) <= k) {
+                s = mid + 1;
+            } else {
+                e = mid;
+            }
+        }
+        return Math.abs(s) - 1;
+    }
+
+    public static int upper_bound(ArrayList<Integer> ar, int k) {
+        int s = 0;
+        int e = ar.size();
+        while (s != e) {
+            int mid = s + e >> 1;
+            if (ar.get(mid) < k) {
+                s = mid + 1;
+            } else {
+                e = mid;
+            }
+        }
+        if (s == ar.size()) {
+            return -1;
+        }
+        return s;
+    }
+
+    static class Kioken {
+        // FileInputStream br = new FileInputStream(""input.txt"");
+
+        BufferedReader br;
+        StringTokenizer st;
+
+        Kioken(String filename) {
+            try {
+                FileReader fr = new FileReader(filename);
+                br = new BufferedReader(fr);
+                st = new StringTokenizer("""");
+
+            } catch (Exception e) {
+                // TODO: handle exception
+                e.printStackTrace();
+            }
+        }
+
+        Kioken() {
+            try {
+                br = new BufferedReader(new InputStreamReader(System.in));
+                st = new StringTokenizer("""");
+
+            } catch (Exception e) {
+                // TODO: handle exception
+                e.printStackTrace();
+            }
+        }
+
+        public String next() {
+            while (!st.hasMoreTokens()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        public int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        public long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        public double nextDouble() {
+            return Double.parseDouble(next());
+        }
+
+        public String nextLine() {
+            try {
+                return br.readLine();
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+            return null;
+        }
+
+        public boolean hasNext() {
+            String next = null;
+            try {
+                next = br.readLine();
+            } catch (Exception e) {
+            }
+            if (next == null || next.length() == 0) {
+                return false;
+            }
+            st = new StringTokenizer(next);
+            return true;
+        }
+    }
+}",0
+548ffb07,9ab3c0e1,"import java.io.*;
+import java.util.*;
+
+public class D_Java {
+	public static final int MOD = 998244353;
+	
+	public static int mul(int a, int b) {
+		return (int)((long)a * (long)b % MOD);
+	}
+	
+	int[] f;
+	int[] rf;
+	
+	public int C(int n, int k) {
+		return (k < 0 || k > n) ? 0 : mul(f[n], mul(rf[n-k], rf[k]));
+	}
+	
+	public static int pow(int a, int n) {
+		int res = 1;
+		while (n != 0) {
+			if ((n & 1) == 1) {
+				res = mul(res, a);
+			}
+			a = mul(a, a);
+			n >>= 1;
+		}
+		return res;
+	}
+	
+	static void shuffleArray(int[] a) {
+		Random rnd = new Random();
+		for (int i = a.length-1; i > 0; i--) {
+			int index = rnd.nextInt(i + 1);
+			int tmp = a[index];
+			a[index] = a[i];
+			a[i] = tmp;
+		}
+	}
+	
+	public static int inv(int a) {
+		return pow(a, MOD-2);
+	}
+	
+	public void doIt() throws IOException {
+		BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
+		
+		StringTokenizer tok = new StringTokenizer(in.readLine());
+		int n = Integer.parseInt(tok.nextToken());
+		int k = Integer.parseInt(tok.nextToken());
+		
+		f = new int[n+42];
+		rf = new int[n+42];
+		f[0] = rf[0] = 1;
+		for (int i = 1; i < f.length; ++i) {
+			f[i] = mul(f[i-1], i);
+			rf[i] = mul(rf[i-1], inv(i));
+		}
+		
+		int[] events = new int[2*n];
+		for (int i = 0; i < n; ++i) {
+			tok = new StringTokenizer(in.readLine());
+			int le = Integer.parseInt(tok.nextToken());
+			int ri = Integer.parseInt(tok.nextToken());
+			events[i] = le*2;
+			events[i + n] = ri*2 + 1;
+		}
+		shuffleArray(events);
+		Arrays.sort(events);
+		
+		int ans = 0;
+		int balance = 0;
+		for (int r = 0; r < 2*n;) {
+			int l = r;
+			while (r < 2*n && events[l] == events[r]) {
+				++r;
+			}
+			int added = r - l;
+			if (events[l] % 2 == 0) {
+				// Open event
+				ans += C(balance + added, k);
+				if (ans >= MOD) ans -= MOD;
+				ans += MOD - C(balance, k);
+				if (ans >= MOD) ans -= MOD;
+				balance += added;
+			} else {
+				// Close event
+				balance -= added;
+			}
+		}
+		
+		in.close();
+		System.out.println(ans);
+	}
+	
+	public static void main(String[] args) throws IOException {
+		(new D_Java()).doIt();
+	}
+}
+","//package CF672;
+
+/**
+ * @version 1.0
+ * @Package_Name: CF672
+ * @Author: Redorain
+ * @Date: 2020/9/25 8:47
+ */
+
+import java.util.*;
+
+public class d {
+
+    public static Scanner sc = new Scanner(System.in);
+    public static final int MOD = 998244353;
+    int []f; int [] lf;
+
+    public static int mul(int a, int b) {
+        return (int)((long)a * (long)b % MOD);
+    }
+
+    public static int ksm(int a, int n) {
+        int ans = 1;
+        while(n > 0) {
+            if((n & 1) == 1)
+                ans = mul(a, ans);
+            a = mul(a, a);
+            n >>= 1;
+        }
+        return ans;
+    }
+
+    public int C(int n, int k) {
+        return (k < 0 || k > n) ? 0 : mul(f[n], mul(lf[n - k], lf[k]));
+    }
+
+    public static int inv(int a) {
+        return ksm(a, MOD - 2);
+    }
+
+    public void solve() {
+        int n = sc.nextInt();
+        int k = sc.nextInt();
+        f = new int[n + 42];
+        lf = new int[n + 42];
+        f[0] = lf[0] = 1;
+        for(int i = 1; i < f.length; i++) {
+            f[i] = mul(f[i  - 1], i);
+            lf[i] = mul(lf[i - 1], inv(i));
+        }
+
+        int[] events = new int[2 * n];
+        for(int i = 0; i < n; i++) {
+            int le = sc.nextInt();
+            int ri = sc.nextInt();
+            events[i] = le * 2;
+            events[i + n] = ri * 2 + 1;
+        }
+
+        Arrays.sort(events);
+        int ans = 0, balance = 0;
+        for(int r = 0; r < 2 * n;) {
+            int l = r;
+            while(r < 2 * n && events[l] == events[r]) ++r;
+            int added = r - l;
+            if(events[l] % 2 == 0) {
+                ans += C(balance + added, k);
+                if(ans >= MOD) ans -= MOD;
+                ans += MOD - C(balance, k);
+                if(ans >= MOD) ans -= MOD;
+                balance += added;
+            }
+            else balance -= added;
+        }
+        sc.close();
+        System.out.println(ans);
+    }
+
+    public static void main(String[] args) {
+        (new d()).solve();
+    }
+}",1
+884f5678,cf27732e,"import java.io.*;
+import java.util.*;
+import java.text.*;
+import java.math.*;
+import java.util.regex.*;
+
+public class JaiShreeRam{
+	static Scanner in=new Scanner();
+	static long mod = 1000000007;
+	static ArrayList<ArrayList<Integer>> adj;
+	public static void main(String[] args) throws Exception{
+		class Element{
+			int x;
+			char c;
+			public Element(int y,char k) {
+				x=y;
+				c=k;
+			}
+		}
+		int z=in.readInt();
+		while(z-->0) {
+			int n=in.readInt();
+			int a[]=nia(n);
+			char c[]=in.readString().toCharArray();
+			ArrayList<Integer> d=new ArrayList<>();
+			ArrayList<Integer> in=new ArrayList<>();
+			for(int i=0;i<n;i++) {
+				if(c[i]=='R') {
+					in.add(a[i]);
+				}
+				else {
+					d.add(a[i]);
+				}
+			}
+			String ans=""YES"";
+			Collections.sort(d);
+			int k=1;
+			for(int i:d) {
+				if(i<k) {
+					ans=""NO"";
+				}
+				k++;
+			}
+			Collections.sort(in);
+			for(int i=in.size()-1;i>=0;i--) {
+				if(in.get(i)>n) {
+					ans=""NO"";
+					break;
+				}
+				n--;
+			}
+			System.out.println(ans);
+		}
+	}
+	static long ans(long l,long r,long x,long y) {
+		long mid=(r-l)/2+l;
+		long a=mid%x;
+		long b=y%mid;
+		long c=0;
+		if(l>r) {
+			return 0;
+		}
+		if(a==b) {
+			return mid;
+		}
+		else if(a<b) {
+			c=ans(l,mid-1,x,y);
+			if(c==0) {
+				c=ans(mid+1,r,x,y);
+			}
+		}
+		else{
+			c=ans(l,mid-1,x,y);
+			if(c==0) {
+				c=ans(mid+1,r,x,y);
+			}
+		}
+		return c;
+	}
+	static int[] nia(int n){
+		int[] arr= new int[n];
+		int i=0;
+		while(i<n){
+			arr[i++]=in.readInt();
+		}
+		return arr;
+	}
+	static long[] nla(int n){
+		long[] arr= new long[n];
+		int i=0;
+		while(i<n){
+			arr[i++]=in.readLong();
+		}
+		return arr;
+	}
+	static int[] nia1(int n){
+		int[] arr= new int[n+1];
+		int i=1;
+		while(i<=n){
+			arr[i++]=in.readInt();
+		}
+		return arr;
+	}
+	static long gcd(long a, long b) {
+		if (b==0) return a;
+		return gcd(b, a%b);
+	}
+	static class Scanner{
+		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st=new StringTokenizer("""");
+		String readString() {
+			while (!st.hasMoreTokens())
+				try {
+					st=new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			return st.nextToken();
+		}
+		double readDouble() {
+			return Double.parseDouble(readString());
+		}
+		int readInt() {
+			return Integer.parseInt(readString());
+		}
+		long readLong() {
+			return Long.parseLong(readString());
+		}
+	}	
+}","import java.util.*;
+
+
+
+import java.io.*;
+
+public class code  {
+	// remember long, to reformat ctrl + shift +f
+	static Scanner sc = new Scanner(System.in);
+	static PrintWriter pw = new PrintWriter(System.out);
+ 
+	  
+ 
+	public static void main(String[] args) throws Exception {
+
+		int t=sc.nextInt();
+		while(t-->0) {
+            int n=sc.nextInt();
+            int []vals=new int[n];
+            boolean numLine[]=new boolean[n+1];
+
+            for(int i=0;i<n;i++)vals[i]=sc.nextInt();
+            String s=sc.nextLine();
+            ArrayList<Integer>b=new ArrayList<Integer>();
+            ArrayList<Integer>r=new ArrayList<Integer>();
+            for(int i=0;i<n;i++) {
+            	if(s.charAt(i)=='B' && vals[i]>0 )b.add(vals[i]);
+            	else if( s.charAt(i)=='R' && vals[i]<=n)r.add(vals[i]);
+            }
+          Collections.sort(b);
+          Collections.sort(r);
+          int small=1;
+          for(int i=0;i<b.size();i++) {
+        	  
+        	  int y=b.get(i);
+        	  if(y<small)continue;
+        	  numLine[small]=true;
+        	  small++;
+          }
+         // pw.println(Arrays.toString(numLine));
+          int large=n;
+          for(int i=r.size()-1;i>=0;i--) {
+        	  
+        	  int y=r.get(i);
+        	  if(y>large)continue;
+        	 // y=Math.max(large, y);
+        	  numLine[large]=true;
+        	  large--;
+          }
+          //pw.print(Arrays.toString(numLine));
+          boolean can=true;
+          for(int i=1;i<=n;i++) {
+        	  if(numLine[i]==false) {
+        		  pw.println(""no"");
+        		  can=false;
+        		  break;
+        	  }
+        	  
+          }
+          if(can)pw.println(""yes"");
+          
+           
+            	
+            	
+            
+
+			
+		}
+		
+	 pw.close();
+
+	}
+
+	// --------------------stuff ----------------------
+	static class pair implements Comparable<pair> {
+		int v;
+		int w;
+        
+		public pair(int v,int  w) {
+			this.v = v;
+			this.w = w;
+			
+		}
+
+		public int compareTo(pair p) {
+			return this.w- p.w;// increasing order!!
+		
+			//return Double.compare(v*w, p.w*p.v);
+		
+		}
+	}
+
+	static class Scanner {
+		StringTokenizer st;
+		BufferedReader br;
+
+		public Scanner(InputStream s) {
+			br = new BufferedReader(new InputStreamReader(s));
+		}
+
+		public Scanner(FileReader r) {
+			br = new BufferedReader(r);
+		}
+
+		public String next() throws IOException {
+			while (st == null || !st.hasMoreTokens())
+				st = new StringTokenizer(br.readLine());
+			return st.nextToken();
+		}
+
+		public int nextInt() throws IOException {
+			return Integer.parseInt(next());
+		}
+
+		public long nextLong() throws IOException {
+			return Long.parseLong(next());
+		}
+
+		public String nextLine() throws IOException {
+			return br.readLine();
+		}
+
+		public double nextDouble() throws IOException {
+			String x = next();
+			StringBuilder sb = new StringBuilder(""0"");
+			double res = 0, f = 1;
+			boolean dec = false, neg = false;
+			int start = 0;
+			if (x.charAt(0) == '-') {
+				neg = true;
+				start++;
+			}
+			for (int i = start; i < x.length(); i++)
+				if (x.charAt(i) == '.') {
+					res = Long.parseLong(sb.toString());
+					sb = new StringBuilder(""0"");
+					dec = true;
+				} else {
+					sb.append(x.charAt(i));
+					if (dec)
+						f *= 10;
+				}
+			res += Long.parseLong(sb.toString()) / f;
+			return res * (neg ? -1 : 1);
+		}
+
+		public long[] nextlongArray(int n) throws IOException {
+			long[] a = new long[n];
+			for (int i = 0; i < n; i++)
+				a[i] = nextLong();
+			return a;
+		}
+
+		public Long[] nextLongArray(int n) throws IOException {
+			Long[] a = new Long[n];
+			for (int i = 0; i < n; i++)
+				a[i] = nextLong();
+			return a;
+		}
+
+		public int[] nextIntArray(int n) throws IOException {
+			int[] a = new int[n];
+			for (int i = 0; i < n; i++)
+				a[i] = nextInt();
+			return a;
+		}
+
+		public Integer[] nextIntegerArray(int n) throws IOException {
+			Integer[] a = new Integer[n];
+			for (int i = 0; i < n; i++)
+				a[i] = nextInt();
+			return a;
+		}
+
+		public boolean ready() throws IOException {
+			return br.ready();
+		}
+	}
+
+}",0
+4fb09c5f,c57a973e,"import java.io.*;
+import java.util.*;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.logging.Logger;
+import java.util.stream.Collectors;
+
+public class Trial {
+    public static void main(String[] args) throws IOException {
+
+        Scanner sc = new Scanner(System.in);
+        PrintWriter pw = new PrintWriter(System.out);
+
+        int q = sc.nextInt();
+        while (q-- > 0) {
+            int n = sc.nextInt();
+            int k = sc.nextInt();
+            int[] arr = new int[k];
+            int[] t = new int[k];
+            HashMap<Integer, Integer> hm = new HashMap<>();
+            for (int i = 0; i < k; i++) {
+                arr[i] = sc.nextInt() - 1;
+            }
+
+            for (int i = 0; i < k; i++) {
+                t[i] = sc.nextInt();
+                hm.put(arr[i], t[i]);
+            }
+
+            int[] left = new int[n];
+            int[] right = new int[n];
+            left[0] = hm.getOrDefault(0, -1);
+            right[n - 1] = hm.getOrDefault(n - 1, -1);
+            for (int i = 1; i < n; i++) {
+                if (hm.containsKey(i)) {
+                    if (left[i - 1] < 0) {
+                        left[i] = hm.get(i);
+                    } else {
+                        left[i] = Math.min(hm.get(i), left[i - 1] + 1);
+                    }
+                } else {
+                    left[i] = left[i - 1] < 0 ? -1 : left[i - 1] + 1;
+                }
+            }
+            for (int i = n - 2; i >= 0; i--) {
+                if (hm.containsKey(i)) {
+                    if (right[i + 1] < 0) {
+                        right[i] = hm.get(i);
+                    } else {
+                        right[i] = Math.min(hm.get(i), right[i + 1] + 1);
+                    }
+                } else {
+                    right[i] = right[i + 1] < 0 ? -1 : right[i + 1] + 1;
+                }
+            }
+            for (int i = 0; i < n; i++) {
+                if (left[i] < 0) {
+                    pw.print(right[i] + "" "");
+                } else if (right[i] < 0) {
+                    pw.print(left[i] + "" "");
+                } else {
+                    pw.print(Math.min(left[i], right[i]) + "" "");
+                }
+            }
+            pw.println();
+        }
+        pw.flush();
+        pw.close();
+    }
+
+    // inclusive
+    private static void rotate(int[] arr, int l, int r) {
+        int temp = arr[r];
+        for (int i = r - 1; i >= l; i--) {
+            arr[i + 1] = arr[i];
+        }
+        arr[l] = temp;
+    }
+
+    static class Scanner {
+        StringTokenizer st;
+        BufferedReader br;
+
+        public Scanner(InputStream System) throws FileNotFoundException {
+            br = new BufferedReader(new InputStreamReader(System));
+        }
+
+        public String next() throws IOException {
+            while (st == null || !st.hasMoreTokens())
+                st = new StringTokenizer(br.readLine());
+            return st.nextToken();
+        }
+
+        public String nextLine() throws IOException {
+            return br.readLine();
+        }
+
+        public int nextInt() throws IOException {
+            return Integer.parseInt(next());
+        }
+
+        public double nextDouble() throws IOException {
+            return Double.parseDouble(next());
+        }
+
+        public char nextChar() throws IOException {
+            return next().charAt(0);
+        }
+
+        public Long nextLong() throws IOException {
+            return Long.parseLong(next());
+        }
+
+        public boolean ready() throws IOException {
+            return br.ready();
+        }
+
+        public void waitForInput() {
+            for (long i = 0; i < 3e9; i++)
+                ;
+        }
+    }
+
+    static class Pair {
+        int a;
+        int b;
+        boolean asc;
+
+        Pair(int a, int b, boolean asc) {
+            this.a = a;
+            this.b = b;
+            this.asc = asc;
+        }
+
+        @Override
+        public boolean equals(Object o) {
+            if (this == o) return true;
+            if (o == null || getClass() != o.getClass()) return false;
+            Pair pair = (Pair) o;
+            return a == pair.a &&
+                    b == pair.b &&
+                    asc == pair.asc;
+        }
+
+        @Override
+        public int hashCode() {
+            return Objects.hash(a, b, asc);
+        }
+    }
+}
+","import java.io.BufferedReader;
+import java.io.FileNotFoundException;
+import java.io.FileReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.Arrays;
+import java.util.StringTokenizer;
+
+
+public class Air {
+
+    public static void main(String[] args) {
+        FastScanner sc = new FastScanner();
+        int T = sc.nextInt();
+        for(int tt=0; tt<T;tt++){
+        	int n = sc.nextInt(), k=sc.nextInt();
+        	int [] positions=new int[k], temp=new int[k];
+        	for (int i=0;i<k;i++) positions[i]=sc.nextInt();
+        	for (int i=0;i<k;i++) temp[i]=sc.nextInt();
+        	int[] forced=new int[n];
+        	Arrays.fill(forced, Integer.MAX_VALUE/2);
+        	for (int i=0;i<k;i++) forced[positions[i]-1]=temp[i];
+        	for (int i=1;i<n;i++) forced[i]=Math.min(forced[i], forced[i-1]+1);
+        	for (int i=n-2;i>=0;i--) forced[i]=Math.min(forced[i], forced[i+1]+1);
+        	for (int i=0;i<n;i++) System.out.print(forced[i]+"" "");
+			System.out.println();
+		}
+
+    }
+
+    public static class FastScanner {
+        BufferedReader br;
+        StringTokenizer st;
+
+        public FastScanner(String s) {
+            try {
+                br = new BufferedReader(new FileReader(s));
+            } catch (FileNotFoundException e) {
+                // TODO Auto-generated catch block
+                e.printStackTrace();
+            }
+        }
+
+        public FastScanner() {
+            br = new BufferedReader(new InputStreamReader(System.in));
+        }
+
+        String nextToken() {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    // TODO Auto-generated catch block
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(nextToken());
+        }
+
+        long nextLong() {
+            return Long.parseLong(nextToken());
+        }
+
+        double nextDouble() {
+            return Double.parseDouble(nextToken());
+        }
+    }
+}
+",0
+1a31f5cb,dc575a6c,"import java.util.*;
+import java.io.*;
+
+public class Solution
+{
+    static class Reader {
+        final private int BUFFER_SIZE = 1 << 16;
+        private DataInputStream din;
+        private byte[] buffer;
+        private int bufferPointer, bytesRead;
+ 
+        public Reader()
+        {
+            din = new DataInputStream(System.in);
+            buffer = new byte[BUFFER_SIZE];
+            bufferPointer = bytesRead = 0;
+        }
+ 
+        public Reader(String file_name) throws IOException
+        {
+            din = new DataInputStream(
+                new FileInputStream(file_name));
+            buffer = new byte[BUFFER_SIZE];
+            bufferPointer = bytesRead = 0;
+        }
+ 
+        public String readLine() throws IOException
+        {
+            byte[] buf = new byte[64]; // line length
+            int cnt = 0, c;
+            while ((c = read()) != -1) {
+                if (c == '\n') {
+                    if (cnt != 0) {
+                        break;
+                    }
+                    else {
+                        continue;
+                    }
+                }
+                buf[cnt++] = (byte)c;
+            }
+            return new String(buf, 0, cnt);
+        }
+ 
+        public int nextInt() throws IOException
+        {
+            int ret = 0;
+            byte c = read();
+            while (c <= ' ') {
+                c = read();
+            }
+            boolean neg = (c == '-');
+            if (neg)
+                c = read();
+            do {
+                ret = ret * 10 + c - '0';
+            } while ((c = read()) >= '0' && c <= '9');
+ 
+            if (neg)
+                return -ret;
+            return ret;
+        }
+ 
+        public long nextLong() throws IOException
+        {
+            long ret = 0;
+            byte c = read();
+            while (c <= ' ')
+                c = read();
+            boolean neg = (c == '-');
+            if (neg)
+                c = read();
+            do {
+                ret = ret * 10 + c - '0';
+            } while ((c = read()) >= '0' && c <= '9');
+            if (neg)
+                return -ret;
+            return ret;
+        }
+ 
+        public double nextDouble() throws IOException
+        {
+            double ret = 0, div = 1;
+            byte c = read();
+            while (c <= ' ')
+                c = read();
+            boolean neg = (c == '-');
+            if (neg)
+                c = read();
+ 
+            do {
+                ret = ret * 10 + c - '0';
+            } while ((c = read()) >= '0' && c <= '9');
+ 
+            if (c == '.') {
+                while ((c = read()) >= '0' && c <= '9') {
+                    ret += (c - '0') / (div *= 10);
+                }
+            }
+ 
+            if (neg)
+                return -ret;
+            return ret;
+        }
+ 
+        private void fillBuffer() throws IOException
+        {
+            bytesRead = din.read(buffer, bufferPointer = 0,
+                                 BUFFER_SIZE);
+            if (bytesRead == -1)
+                buffer[0] = -1;
+        }
+ 
+        private byte read() throws IOException
+        {
+            if (bufferPointer == bytesRead)
+                fillBuffer();
+            return buffer[bufferPointer++];
+        }
+ 
+        public void close() throws IOException
+        {
+            if (din == null)
+                return;
+            din.close();
+        }
+    }
+    
+    static void dfs(int n , LinkedList<Integer> g[] , int arr[][] , int p , long dp[][])
+    {
+        for(Integer i : g[n])
+        {
+            if(i != p)
+            {
+                dfs(i,g,arr,n,dp);
+            dp[n][0] += Math.max(dp[i][0]+Math.abs(arr[n][0]-arr[i][0]) , 
+                       dp[i][1]+Math.abs(arr[n][0]-arr[i][1]));
+                       
+                 
+            dp[n][1] += Math.max(dp[i][0]+Math.abs(arr[n][1]-arr[i][0]) , 
+                       dp[i][1]+Math.abs(arr[n][1]-arr[i][1]));
+            }                
+        }
+    }
+    public static void main(String []args) throws IOException
+    {
+        Reader sc = new Reader();
+        StringBuffer str = new StringBuffer("""");
+        int t  = sc.nextInt();
+        while(t-- > 0)
+        {
+            int n = sc.nextInt();
+            int arr[][] = new int[n][2];
+            for(int i = 0 ; i < n;  i++)
+            {
+                arr[i][0] = sc.nextInt();
+                arr[i][1] = sc.nextInt();
+            }
+            LinkedList<Integer> g[] = new LinkedList[n];
+            for(int i = 0 ; i < n ; i++)
+            {
+                g[i] = new LinkedList<Integer>();
+            }
+            for(int i = 0 ; i < n-1 ; i++)
+            {
+                int x = sc.nextInt()-1;
+                int y = sc.nextInt()-1;
+                g[x].add(y);
+                g[y].add(x);
+            }
+            long dp[][] = new long[n][2];
+            dfs(0,g,arr,-1 , dp);
+            str.append(Math.max(dp[0][0] , dp[0][1]));
+            str.append(System.lineSeparator());
+        }
+        System.out.println(str);
+    }
+}
+","// ""static void main"" must be defined in a public class.
+import java.util.*;
+import java.io.*;
+public class Main {
+    static long[][]dp;
+    static ArrayList<Integer>[]adj;
+    static int[][]arr;
+    static class FastScanner {
+		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st=new StringTokenizer("""");
+		String next() {
+			while (!st.hasMoreTokens())
+				try { 
+                                        st=new StringTokenizer(br.readLine());				               
+                                } catch (IOException e) {}
+			return st.nextToken();
+		}
+		
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+	}
+    public static void main(String[] args) {
+        FastScanner sc=new FastScanner();
+        int t=sc.nextInt();
+        while(t-->0){
+            int n=sc.nextInt();
+            arr=new int[n][2];
+            adj=new ArrayList[n];
+            for(int i=0;i<n;i++){
+                arr[i][0]=sc.nextInt();
+                arr[i][1]=sc.nextInt();
+                adj[i]=new ArrayList<>();
+            }
+            for(int i=0;i<n-1;i++){
+                int a=sc.nextInt()-1;
+                int b=sc.nextInt()-1;   
+                adj[a].add(b);
+                adj[b].add(a);
+            }
+            dp=new long[n][2];
+            dfs(0,-1);
+            System.out.println(Math.max(dp[0][0],dp[0][1]));
+        }
+    }
+    public static void dfs(int v,int parent){
+        for(int u:adj[v]){
+            if(u!=parent){
+                dfs(u,v);
+            }
+        }
+        long ans1=0;
+        long ans2=0;
+        for(int u:adj[v]){
+            if(u!=parent){
+                long a=Math.abs(arr[v][0]-arr[u][0])+dp[u][0];
+                long b=Math.abs(arr[v][0]-arr[u][1])+dp[u][1];
+                long a1=Math.abs(arr[v][1]-arr[u][0])+dp[u][0];
+                long b1=Math.abs(arr[v][1]-arr[u][1])+dp[u][1];
+                ans1+=Math.max(a,b);
+                ans2+=Math.max(a1,b1);
+            }
+        }
+        dp[v][0]=ans1;
+        dp[v][1]=ans2;
+    }
+}",0
+11c2ab99,4f7af821,"import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.StringTokenizer;
+
+public class Main {
+
+	public static void main(String[] args) {
+		FastScanner fs=new FastScanner();
+		int T=fs.nextInt();
+		PrintWriter out=new PrintWriter(System.out);
+		for (int tt=0; tt<T; tt++) {
+			int n=fs.nextInt(), k=fs.nextInt();
+			int[] positions=fs.readArray(k), temps=fs.readArray(k);
+			int[] forced=new int[n];
+			Arrays.fill(forced, Integer.MAX_VALUE/2);
+			for (int i=0; i<k; i++) forced[positions[i]-1]=temps[i];
+			for (int i=1; i<n; i++)
+				forced[i]=Math.min(forced[i], forced[i-1]+1);
+			for (int i=n-2; i>=0; i--)
+				forced[i]=Math.min(forced[i], forced[i+1]+1);
+			for (int i=0; i<n; i++) out.print(forced[i]+"" "");
+			out.println();
+			
+		}
+		out.close();
+	}
+
+	static void sort(int[] a) {
+		ArrayList<Integer> l=new ArrayList<>();
+		for (int i:a) l.add(i);
+		Collections.sort(l);
+		for (int i=0; i<a.length; i++) a[i]=l.get(i);
+	}
+	
+	static class FastScanner {
+		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st=new StringTokenizer("""");
+		String next() {
+			while (!st.hasMoreTokens())
+				try {
+					st=new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			return st.nextToken();
+		}
+		
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+		int[] readArray(int n) {
+			int[] a=new int[n];
+			for (int i=0; i<n; i++) a[i]=nextInt();
+			return a;
+		}
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+	}
+
+	
+}
+
+","import java.util.*;
+
+public class contestA {
+    public static void main(String[] args) {
+        Scanner scanner = new Scanner(System.in);
+        int t = scanner.nextInt();
+        int inf = 1000300300;
+        while (t-->0){
+            int n = scanner.nextInt();
+            int k = scanner.nextInt();
+            int[] c = new int[n];
+            Arrays.fill(c,inf);
+            int[] a = new int[k];
+            int[] b = new int[k];
+            for(int i=0;i<k;++i) a[i] = scanner.nextInt() - 1;
+            for(int i=0;i<k;++i) b[i] = scanner.nextInt();
+            for(int i=0;i<k;++i) c[a[i]] = b[i];
+            for(int i=1;i<n;++i){
+                c[i] = Math.min(c[i],c[i-1]+1);
+            }
+            for(int i=n-2;i>=0;--i){
+                c[i] = Math.min(c[i],c[i+1]+1);
+            }
+            for(int i=0;i<n;++i) System.out.print(c[i]+"" "");
+            System.out.println();
+        }
+    }
+}
+
+",1
+3afcc566,90dc2b20,"//package codeforces.globalround18;
+
+import java.io.*;
+import java.util.*;
+
+import static java.lang.Math.*;
+
+//Think through the entire logic before jump into coding!
+//If you are out of ideas, take a guess! It is better than doing nothing!
+//Read both C and D, it is possible that D is easier than C for you!
+
+//Be aware of integer overflow!
+//If you find an answer and want to return immediately, don't forget to flush before return!
+
+public class C {
+    static InputReader in;
+    static PrintWriter out;
+
+    public static void main(String[] args) {
+        //initReaderPrinter(true);
+        initReaderPrinter(false);
+        solve(in.nextInt());
+        //solve(1);        
+    }
+
+    static void solve(int testCnt) {
+        for (int testNumber = 0; testNumber < testCnt; testNumber++) {
+            int n = in.nextInt();
+            char[] a = in.next().toCharArray(), b = in.next().toCharArray();
+            int match0 = 0, match1 = 0, mismatch10 = 0, mismatch01 = 0;
+            for(int i = 0; i < n; i++) {
+                if(a[i] == b[i]) {
+                    if(a[i] == '0') match0++;
+                    else match1++;
+                }
+                else {
+                    if(a[i] == '0') mismatch01++;
+                    else mismatch10++;
+                }
+            }
+            if(mismatch01 + mismatch10 == 0) out.println(0);
+            else {
+                if(match1 - match0 == 1 && mismatch01 == mismatch10) {
+                    out.println(min(match0 + match1, mismatch01 + mismatch10));
+                }
+                else if(match1 - match0 == 1) {
+                    out.println(match0 + match1);
+                }
+                else if(mismatch01 == mismatch10) {
+                    out.println(mismatch01 + mismatch10);
+                }
+                else out.println(-1);
+            }
+        }
+        out.close();
+    }
+
+    static void initReaderPrinter(boolean test) {
+        if (test) {
+            try {
+                in = new InputReader(new FileInputStream(""src/input.in""));
+                out = new PrintWriter(new FileOutputStream(""src/output.out""));
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+        } else {
+            in = new InputReader(System.in);
+            out = new PrintWriter(System.out);
+        }
+    }
+
+    static class InputReader {
+        BufferedReader br;
+        StringTokenizer st;
+
+        InputReader(InputStream stream) {
+            try {
+                br = new BufferedReader(new InputStreamReader(stream), 32768);
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }
+
+        String next() {
+            while (st == null || !st.hasMoreTokens()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+
+        String nextLine() {
+            String str = """";
+            try {
+                str = br.readLine();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+        }
+
+        Integer[] nextIntArray(int n) {
+            Integer[] a = new Integer[n];
+            for (int i = 0; i < n; i++) a[i] = nextInt();
+            return a;
+        }
+
+        int[] nextIntArrayPrimitive(int n) {
+            int[] a = new int[n];
+            for (int i = 0; i < n; i++) a[i] = nextInt();
+            return a;
+        }
+
+        int[] nextIntArrayPrimitiveOneIndexed(int n) {
+            int[] a = new int[n + 1];
+            for (int i = 1; i <= n; i++) a[i] = nextInt();
+            return a;
+        }
+
+        Long[] nextLongArray(int n) {
+            Long[] a = new Long[n];
+            for (int i = 0; i < n; i++) a[i] = nextLong();
+            return a;
+        }
+
+        long[] nextLongArrayPrimitive(int n) {
+            long[] a = new long[n];
+            for (int i = 0; i < n; i++) a[i] = nextLong();
+            return a;
+        }
+
+        long[] nextLongArrayPrimitiveOneIndexed(int n) {
+            long[] a = new long[n + 1];
+            for (int i = 1; i <= n; i++) a[i] = nextLong();
+            return a;
+        }
+
+        String[] nextStringArray(int n) {
+            String[] g = new String[n];
+            for (int i = 0; i < n; i++) g[i] = next();
+            return g;
+        }
+
+        List<Integer>[] readGraphOneIndexed(int n, int m) {
+            List<Integer>[] adj = new List[n + 1];
+            for (int i = 0; i <= n; i++) {
+                adj[i] = new ArrayList<>();
+            }
+            for (int i = 0; i < m; i++) {
+                int u = nextInt();
+                int v = nextInt();
+                adj[u].add(v);
+                adj[v].add(u);
+            }
+            return adj;
+        }
+
+        List<Integer>[] readGraphZeroIndexed(int n, int m) {
+            List<Integer>[] adj = new List[n];
+            for (int i = 0; i < n; i++) {
+                adj[i] = new ArrayList<>();
+            }
+            for (int i = 0; i < m; i++) {
+                int u = nextInt() - 1;
+                int v = nextInt() - 1;
+                adj[u].add(v);
+                adj[v].add(u);
+            }
+            return adj;
+        }
+
+        /*
+            A more efficient way of building a graph using int[] instead of ArrayList to store each node's neighboring nodes.
+            1-indexed.
+         */
+        int[][] buildGraph(int nodeCnt, int edgeCnt) {
+            int[] end1 = new int[edgeCnt], end2 = new int[edgeCnt];
+            int[] edgeCntForEachNode = new int[nodeCnt + 1], idxForEachNode = new int[nodeCnt + 1];
+            for (int i = 0; i < edgeCnt; i++) {
+                int u = in.nextInt(), v = in.nextInt();
+                edgeCntForEachNode[u]++;
+                edgeCntForEachNode[v]++;
+                end1[i] = u;
+                end2[i] = v;
+            }
+            int[][] adj = new int[nodeCnt + 1][];
+            for (int i = 1; i <= nodeCnt; i++) {
+                adj[i] = new int[edgeCntForEachNode[i]];
+            }
+            for (int i = 0; i < edgeCnt; i++) {
+                adj[end1[i]][idxForEachNode[end1[i]]] = end2[i];
+                idxForEachNode[end1[i]]++;
+                adj[end2[i]][idxForEachNode[end2[i]]] = end1[i];
+                idxForEachNode[end2[i]]++;
+            }
+            return adj;
+        }
+    }
+}","import java.util.*;
+import java.io.*;
+public class C1615{
+	static FastScanner fs = null;
+	public static void main(String[] args) {
+		fs = new FastScanner();
+		PrintWriter out = new PrintWriter(System.out);
+		int t = fs.nextInt();
+		while (t-->0) {
+			int n = fs.nextInt();
+			String a = fs.next();
+			String b = fs.next();
+			char ch1[] = a.toCharArray();
+			char ch2[] = b.toCharArray();
+			int c00 = 0;
+			int c01 = 0;
+			int c10 = 0;
+			int c11 = 0;
+			for(int i=0;i<n;i++){
+				if(ch1[i]=='0'){
+					if(ch2[i]=='0'){
+						c00+=1;
+					}
+					else{
+						c01+=1;
+					}
+				}
+				else{
+					if(ch2[i]=='0'){
+						c10+=1;
+					}
+					else{
+						c11+=1;
+					}
+				}
+			}
+			int ans = -1;
+			if((c11-c00)==1 || c10==c01){
+				int s1 = (int)1e7; 
+				int s2 = (int)1e7;
+				if((c11-c00)==1){
+					s1 = c11+c00;
+				}
+				if(c10==c01)
+				s2 = c10+c01;
+				ans = Math.min(s1,s2); 
+			}
+			out.println(ans);
+		}
+		out.close();
+	}
+	static void sort(int[] a) {
+		ArrayList<Integer> l=new ArrayList<>();
+		for (int i:a) l.add(i);
+		Collections.sort(l);
+		for (int i=0; i<a.length; i++) a[i]=l.get(i);
+	}
+	static class FastScanner {
+		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st=new StringTokenizer("""");
+		String next() {
+			while (!st.hasMoreTokens())
+				try {
+					st=new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			return st.nextToken();
+		}
+		
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+		int[] readArray(int n) {
+			int[] a=new int[n];
+			for (int i=0; i<n; i++) a[i]=nextInt();
+			return a;
+		}
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+	}
+}",0
+f28b8cb4,ff3283cf,"import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.lang.reflect.Array;
+import java.util.Arrays;
+import java.util.StringTokenizer;
+
+public class Main {
+    private static int gcd(int a, int b) {
+        return b == 0 ? a : gcd(b, a % b);
+    }
+
+    public static void main(String[] args) throws IOException {
+        BufferedReader br = new BufferedReader(
+                new InputStreamReader(System.in));
+
+        int q = Integer.parseInt(br.readLine());
+
+        for (int i = 0; i < q; i++) {
+            br.readLine();
+
+            StringTokenizer st = new StringTokenizer(br.readLine());
+            int n = Integer.parseInt(st.nextToken());
+            int k = Integer.parseInt(st.nextToken());
+
+            // read input a
+            st = new StringTokenizer(br.readLine());
+            int[] a = new int[k];
+            for (int j = 0; j < k; j++) {
+                a[j] = Integer.parseInt(st.nextToken());
+            }
+
+            // read input t
+            st = new StringTokenizer(br.readLine());
+            int[] t = new int[k];
+            for (int j = 0; j < k; j++) {
+                t[j] = Integer.parseInt(st.nextToken());
+            }
+
+            // known temperatures
+            int[] c = new int[n];
+            Arrays.fill(c, Integer.MAX_VALUE);
+            for (int j = 0; j < k; j++) {
+                c[a[j] - 1] = t[j];
+            }
+
+            // temperature from left to right
+            long[] left = new long[n];
+            Arrays.fill(left, Integer.MAX_VALUE);
+            long p = Integer.MAX_VALUE;
+            for (int j = 0; j < n; j++) {
+                p = Math.min(p + 1, c[j]);
+                left[j] = p;
+            }
+
+            // temperature from right to left
+            long[] right = new long[n];
+            Arrays.fill(right, Integer.MAX_VALUE);
+            p = Integer.MAX_VALUE;
+            for (int j = n - 1; j >= 0; j--) {
+                p = Math.min(p + 1, c[j]);
+                right[j] = p;
+            }
+
+            for (int j = 0; j < n; j++) {
+                System.out.print(Math.min(left[j], right[j]) + "" "");
+            }
+            System.out.println();
+        }
+    }
+}
+","import java.util.*;
+import java.lang.*;
+import java.io.*;
+
+/* Name of the class has to be ""Main"" only if the class is public. */
+public class Codeforces {
+    public static void main(String[] args) throws java.lang.Exception {
+        /* your code goes here */
+        BufferedReader buf = new BufferedReader(new InputStreamReader(System.in));
+       int t = Integer.parseInt(buf.readLine());
+        StringBuilder sb = new StringBuilder();
+       for (int i = 0; i < t; i++) {
+           String st=buf.readLine();
+          String st1[]=(buf.readLine()).split("" "");
+          int n=Integer.parseInt(st1[0]);
+          int k=Integer.parseInt(st1[1]);
+          int a[]=new int[k];
+          int temp[]=new int[k];
+          long arr[]=new long[n];
+          String st2[]=(buf.readLine()).split("" "");
+           String st3[]=(buf.readLine()).split("" "");
+           for(int j=0;j<k;j++)
+           {
+               a[j]=Integer.parseInt(st2[j]);
+               temp[j]=Integer.parseInt(st3[j]);
+           }
+          for(int j=0;j<k;j++)
+          {
+              arr[a[j]-1]=temp[j];
+          }
+          long min=Integer.MAX_VALUE;
+          long left[]=new long[n];
+          long right[]=new long[n];
+          if(arr[0]==0)
+              left[0]=min;
+          else
+              left[0]=arr[0];
+          for(int j=1;j<n;j++)
+          {
+              if(arr[j]==0)
+              {
+                  left[j]=left[j-1]+1;
+              }
+              else
+              {
+                  left[j]=Math.min(left[j-1]+1,arr[j]);
+              }
+          }
+          if(arr[n-1]==0)
+              right[n-1]=min;
+          else
+              right[n-1]=arr[n-1];
+          for(int j=n-2;j>=0;j--)
+          {
+              if(arr[j]==0)
+              {
+                  right[j]=right[j+1]+1;
+              }
+              else
+              {
+                  right[j]=Math.min(right[j+1]+1,arr[j]);
+              }
+          }
+          for(int j=0;j<n;j++)
+          {
+              arr[j]=Math.min(left[j],right[j]);
+              sb.append(arr[j]+"" "");
+          }
+          sb.append(""\n"");
+        }
+        System.out.println(sb);
+    }
+}",0
+9fd33d5a,c220c822,"import java.util.*;
+import java.io.*;
+
+public class Solution {
+
+    private static ArrayList<Integer> prime = new ArrayList<>();
+
+    public static void main(String[] args) throws IOException {
+
+        Scanner in=new Scanner(System.in);
+        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+        StringBuffer out = new StringBuffer();
+
+        int T = in.nextInt();
+
+        OUTER:
+        while(T-->0) {
+
+            int n=in.nextInt(), k=in.nextInt();
+
+            int a[]=new int[k];
+            for(int i=0; i<k; i++) {
+                a[i]=in.nextInt()-1;
+            }
+
+            int t[]=new int[k];
+            long ans[]=new long[n];
+            for(int i=0; i<k; i++) {
+                t[i]=in.nextInt();
+                ans[a[i]]=t[i];
+            }
+
+            long temp=Integer.MAX_VALUE;
+
+            long left[]=new long[n];
+            for(int i=0; i<n; i++) {
+                if(ans[i]!=0) {
+                    temp=Math.min(temp, ans[i]);
+                }
+                left[i]=temp;
+                temp+=1;
+            }
+
+            temp=Integer.MAX_VALUE;
+
+            long right[]=new long[n];
+            for(int i=n-1; i>=0; i--) {
+                if(ans[i]!=0) {
+                    temp=Math.min(temp, ans[i]);
+                }
+                right[i]=temp;
+                temp+=1;
+            }
+
+            for(int i=0; i<n; i++) {
+                ans[i]=Math.min(left[i], right[i]);
+                out.append(ans[i]+"" "");
+            }
+            out.append(""\n"");
+        }
+
+        System.out.print(out);
+    }
+
+    private static long lcm(long a, long b) {
+        return (a*b)/gcd(a, b);
+    }
+
+    private static long gcd(long a, long b) {
+        if (a==0)
+            return b;
+        return gcd(b%a, a);
+    }
+
+    private static int toInt(String s) {
+        return Integer.parseInt(s);
+    }
+
+    private static long toLong(String s) {
+        return Long.parseLong(s);
+    }
+}","// package com.company;
+import java.util.*;
+import java.io.*;
+import java.lang.*;
+public class Main{
+
+    public static void main(String args[]){
+        InputReader in=new InputReader(System.in);
+        TASK solver = new TASK();
+        int t=1;
+        t = in.nextInt();
+        for(int i=1;i<=t;i++)
+        {
+            solver.solve(in,i);
+        }
+    }
+    static class TASK {
+        static int dp[] = new int[31];
+        static {
+            dp[0]=1;
+            for(int i=1;i<31;i++)
+            {
+                dp[i]=dp[i-1]*2;
+            }
+        }
+        void solve(InputReader in, int testNumber) {
+            int n = in.nextInt();
+            int k = in.nextInt();
+            int a[] = new int[k];
+            int l[] = new int[n+1];
+            long pre[] = new long[n+2];
+            long suff[] = new long[n+2];
+            Arrays.fill(pre,Long.MAX_VALUE/2);
+            Arrays.fill(suff,Long.MAX_VALUE/2);
+            for(int i=0;i<k;i++)
+            {
+                a[i]=in.nextInt();
+            }
+            for(int i=0;i<k;i++)
+            {
+                int x = in.nextInt();
+                l[a[i]]=x;
+            }
+            for(int i=1;i<=n;i++)
+            {
+                pre[i]=pre[i-1];
+                if(l[i]!=0)
+                {
+                    pre[i]=Math.min(pre[i],l[i]-i);
+                }
+            }
+            for(int i=n;i>=1;i--)
+            {
+                suff[i]=suff[i+1];
+                if(l[i]!=0)
+                {
+                    suff[i]=Math.min(suff[i],l[i]+i);
+                }
+            }
+            for(int i=1;i<=n;i++)
+            {
+                System.out.print(Math.min(pre[i]+i,suff[i]-i)+"" "");
+            }
+            System.out.println();
+
+
+
+
+
+
+
+        }
+    }
+
+
+    static class pair{
+        int x ;
+        int y;
+        pair(int x,int y)
+        {
+            this.x=x;
+            this.y=y;
+        }
+    }
+
+    static class Maths {
+        static long gcd(long a, long b) {
+            if (a == 0)
+                return b;
+            return gcd(b % a, a);
+        }
+        public static long lcm(long a, long b) {
+            return (a * b) / gcd(a, b);
+        }
+        public static long factorial(int n) {
+            long fact = 1;
+            for (int i = 1; i <= n; i++) {
+                fact *= i;
+            }
+            return fact;
+        }
+    }
+    static class InputReader {
+        private InputStream stream;
+        private byte[] buf = new byte[1024];
+        private int curChar;
+        private int numChars;
+        private SpaceCharFilter filter;
+        public InputReader(InputStream stream) {
+            this.stream = stream;
+        }
+        public int read() {
+            if (numChars == -1)
+                throw new InputMismatchException();
+            if (curChar >= numChars) {
+                curChar = 0;
+                try {
+                    numChars = stream.read(buf);
+                } catch (IOException e) {
+                    throw new InputMismatchException();
+                }
+                if (numChars <= 0)
+                    return -1;
+            }
+            return buf[curChar++];
+        }
+        public String nextLine() {
+            BufferedReader br = new BufferedReader(new
+                    InputStreamReader(System.in));
+            String str = """";
+            try {
+                str = br.readLine();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+        }
+        public int nextInt() {
+            int c = read();
+            while (isSpaceChar(c))
+                c = read();
+            int sgn = 1;
+            if (c == '-') {
+                sgn = -1;
+                c = read();
+            }
+            int res = 0;
+            do {
+                if (c < '0' || c > '9')
+                    throw new InputMismatchException();
+                res *= 10;
+                res += c - '0';
+                c = read();
+            }
+            while (!isSpaceChar(c));
+            return res * sgn;
+        }
+        public long nextLong() {
+            int c = read();
+            while (isSpaceChar(c))
+                c = read();
+            int sgn = 1;
+            if (c == '-') {
+                sgn = -1;
+                c = read();
+            }
+            long res = 0;
+            do {
+                if (c < '0' || c > '9')
+                    throw new InputMismatchException();
+                res *= 10;
+                res += c - '0';
+                c = read();
+            }
+            while (!isSpaceChar(c));
+            return res * sgn;
+        }
+        public double nextDouble() {
+            int c = read();
+            while (isSpaceChar(c))
+                c = read();
+            int sgn = 1;
+            if (c == '-') {
+                sgn = -1;
+                c = read();
+            }
+            double res = 0;
+            while (!isSpaceChar(c) && c != '.') {
+                if (c == 'e' || c == 'E')
+                    return res * Math.pow(10, nextInt());
+                if (c < '0' || c > '9')
+                    throw new InputMismatchException();
+                res *= 10;
+                res += c - '0';
+                c = read();
+            }
+            if (c == '.') {
+                c = read();
+                double m = 1;
+                while (!isSpaceChar(c)) {
+                    if (c == 'e' || c == 'E')
+                        return res * Math.pow(10, nextInt());
+                    if (c < '0' || c > '9')
+                        throw new InputMismatchException();
+                    m /= 10;
+                    res += (c - '0') * m;
+                    c = read();
+                }
+            }
+            return res * sgn;
+        }
+        public String readString() {
+            int c = read();
+            while (isSpaceChar(c))
+                c = read();
+            StringBuilder res = new StringBuilder();
+            do {
+                res.appendCodePoint(c);
+                c = read();
+            }
+            while (!isSpaceChar(c));
+            return res.toString();
+        }
+        public boolean isSpaceChar(int c) {
+            if (filter != null)
+                return filter.isSpaceChar(c);
+            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c
+                    == -1;
+        }
+        public String next() {
+            return readString();
+        }
+        public interface SpaceCharFilter {
+            public boolean isSpaceChar(int ch);
+        }
+    }
+}
+
+
+",0
+c9159d9c,fae0662f,"import java.util.*;
+
+public class SolutionB {
+
+    public static long gcd(long a, long b){
+        if(b==0){
+            return a;
+        }
+        return gcd(b, a%b);
+    }
+
+    public static long gcdSum(long b){
+        long a = 0;
+
+        long temp = b;
+        while(temp!=0){
+            a = a + temp%10;
+            temp = temp/10;
+        }
+        return gcd(a,b);
+
+    }
+
+    public static class Pair{
+        Long a;
+        Long b;
+
+        public Pair(Long a, Long b) {
+            this.a = a;
+            this.b = b;
+        }
+    }
+
+    public static long factorial (long n){
+        if(n==0)
+            return 1;
+        else if(n==1)
+            return n;
+
+        return n * factorial(n-1);
+    }
+
+    public static long lcm (long n){
+        if(n<3)
+            return n;
+        return lcmForBig(n,n-1);
+    }
+
+    private static long lcmForBig(long n, long l) {
+        if(l==1)
+            return n;
+        n = (n * l) / gcd(n, l);
+        return lcmForBig(n, l-1);
+
+    }
+
+
+    public static void main(String[] args){
+        Scanner s = new Scanner(System.in);
+        
+        int t = s.nextInt();
+
+        for(int i =0;i<t;i++) {
+            int n = s.nextInt();
+            int arr [] = new int[n];
+            ArrayList<Integer> blue = new ArrayList<>();
+            ArrayList<Integer> red = new ArrayList<>();
+
+            for(int j=0;j<n;j++){
+                int num = s.nextInt();
+                arr[j]=num;
+            }
+            String color = s.next();
+
+            for(int j=0;j<n;j++){
+                if(color.charAt(j)=='B'){
+                    blue.add(arr[j]);
+                }
+                else{
+                    red.add(arr[j]);
+                }
+            }
+            Collections.sort(blue);
+            String ans = ""YES"";
+            int counter = 0;
+
+            for(int j=0;j<blue.size();j++){
+                int current = blue.get(j);
+                if (current<1){
+                    ans=""NO"";
+                    break;
+                }
+                if(current>counter){
+                    counter++;
+                }
+                else{
+                    ans=""NO"";
+                    break;
+                }
+
+            }
+
+            if(ans==""NO""){
+                System.out.println(ans);
+            }
+            else{
+                int tempCounter = n+1;
+                Collections.sort(red);
+                for(int j=red.size()-1;j>=0;j--){
+                    int  current  = red.get(j);
+                    if(current>=tempCounter){
+                        ans=""NO"";
+                        break;
+                    }
+                    else{
+                        tempCounter--;
+                    }
+                }
+                if(tempCounter-counter!=1)
+                    System.out.println(""NO"");
+                else
+                    System.out.println(ans);
+            }
+
+        }
+
+        return;
+    }
+}
+","import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.StringTokenizer;
+
+public class D {
+	
+	public static void main(String[] args) throws IOException {
+		FastScanner fs = new FastScanner();
+		PrintWriter out = new PrintWriter(System.out);
+		
+		int t = fs.nextInt();
+		for (int tc = 0; tc < t; tc++) {
+			int n = fs.nextInt();
+			int[] a = fs.readArray(n);
+			String s = fs.nextLine();
+			
+			// let all blue to be 1 -> blueCount
+			ArrayList<Integer> blues = new ArrayList<Integer>();
+			ArrayList<Integer> reds = new ArrayList<Integer>();
+			
+			for (int i = 0; i < s.length(); i++) {
+				if (s.charAt(i) == 'B') {
+					blues.add(a[i]);
+				} else {
+					reds.add(a[i]);
+				}
+			}
+			
+			Collections.sort(blues);
+			Collections.sort(reds);
+			
+			boolean ok = true;
+			
+			for (int i = 1; i <= blues.size(); i++) {
+				if (blues.get(i - 1) < i) {
+					ok = false;
+					break;
+				}
+			}
+			
+			for (int i = blues.size() + 1; i <= n; i++) {
+				if (reds.get(i - blues.size() - 1) > i) {
+					ok = false;
+					break;
+				}
+			}
+			
+			if (ok) {
+				out.println(""YES"");
+			} else {
+				out.println(""NO"");
+			}
+		}
+		
+		out.close();
+	}
+	
+	static class FastScanner {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st = new StringTokenizer("""");
+        
+        String next() {
+            while (!st.hasMoreTokens())
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            return st.nextToken();
+        }
+        
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        int[] readArray(int n) {
+            int[] a = new int[n];
+            for (int i = 0; i < n; i++) a[i] = nextInt();
+            return a;
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+        
+        String nextLine() throws IOException {
+        	return br.readLine();
+        }
+    }
+}
+
+",0
+a5d5a95f,ab7507bf,"import java.util.*;
+import java.io.*;
+public class Main {
+// For fast input output
+static class FastReader {
+BufferedReader br;
+StringTokenizer st;
+public FastReader()
+{ try {br = new BufferedReader(
+new FileReader(""input.txt""));
+PrintStream out = new PrintStream(new FileOutputStream(""output.txt""));
+System.setOut(out);}
+catch(Exception e) { br = new BufferedReader(new InputStreamReader(System.in));}
+}
+String next()
+{
+while (st == null || !st.hasMoreElements()) {
+try {st = new StringTokenizer(br.readLine());}
+catch (IOException e) {
+e.printStackTrace();}
+}
+return st.nextToken();
+}
+int nextInt() { return Integer.parseInt(next()); }
+long nextLong() { return Long.parseLong(next()); }
+double nextDouble() {return Double.parseDouble(next()); }
+String nextLine()
+{
+String str = """";
+try {
+str = br.readLine();
+}
+catch (IOException e) {
+e.printStackTrace();
+}
+return str;
+}
+}
+// end of fast i/o code
+public static void main(String[] args) {
+  FastReader reader = new FastReader();
+  int Q = reader.nextInt();
+  outer: for (int q = 0; q < Q; q++) {
+    int N = reader.nextInt();
+    int[][] scores = new int[5][N];
+    for (int i = 0; i < N; i++) {
+      int[] occurs = new int[5];
+      String word = reader.next();
+      for (int j = 0; j < word.length(); j++) {
+        occurs[word.charAt(j) - 'a']++;
+      }
+      for (int j = 0; j < 5; j++) {
+        scores[j][i] = occurs[j] - (word.length() - occurs[j]) ;
+      }
+    }
+    int bestCount = 0;
+    for (int i = 0; i < 5; i++) {
+      int[] curr = scores[i];
+      Arrays.sort(curr);
+      int currentCount = 1;
+      int currentScore = curr[curr.length - 1];
+      for (int j = curr.length - 2; j >= 0 && currentScore > 0; j--) {
+        currentScore += curr[j];
+        currentCount++;
+      }
+      if (currentScore <= 0) currentCount--;
+      bestCount = Math.max(currentCount, bestCount);
+    }
+    System.out.println(bestCount);
+  }
+}
+
+}
+","import java.util.*;
+import java.io.*;
+
+public class C1551 {
+
+	public static void main(String[] args) throws IOException {
+		Scanner sc = new Scanner(System.in);
+		PrintWriter pw = new PrintWriter(System.out);
+		int t = sc.nextInt();
+		while (t-- > 0) {
+			int n = sc.nextInt();
+			char[][] arr = new char[n][];
+			for (int i = 0; i < arr.length; i++) {
+				arr[i] = sc.next().toCharArray();
+			}
+			int[][] cnt = new int[n][5];
+			for (int i = 0; i < cnt.length; i++) {
+				for (char c : arr[i]) {
+					cnt[i][c - 'a']++;
+				}
+			}
+			int fans = 0;
+			for (int letter = 0; letter < 5; letter++) {
+				ArrayList<Integer> al = new ArrayList<Integer>();
+				for (int i = 0; i < n; i++) {
+					al.add(2 * cnt[i][letter] - arr[i].length);
+				}
+				Collections.sort(al, Collections.reverseOrder());
+				int sum = 0;
+				int ans = 0;
+				for (int x : al) {
+					sum += x;
+					if (sum > 0) {
+						ans++;
+					} else {
+						break;
+					}
+				}
+				fans = Math.max(ans, fans);
+			}
+			pw.println(fans);
+		}
+		pw.close();
+	}
+
+	static class Scanner {
+		BufferedReader br;
+		StringTokenizer st;
+
+		public Scanner(InputStream s) {
+			br = new BufferedReader(new InputStreamReader(s));
+		}
+
+		public Scanner(FileReader f) {
+			br = new BufferedReader(f);
+		}
+
+		public String next() throws IOException {
+			while (st == null || !st.hasMoreTokens())
+				st = new StringTokenizer(br.readLine());
+			return st.nextToken();
+		}
+
+		public int nextInt() throws IOException {
+			return Integer.parseInt(next());
+		}
+
+		public long nextLong() throws IOException {
+			return Long.parseLong(next());
+		}
+
+		public double nextDouble() throws IOException {
+			return Double.parseDouble(next());
+		}
+
+		public int[] nextIntArr(int n) throws IOException {
+			int[] arr = new int[n];
+			for (int i = 0; i < n; i++) {
+				arr[i] = Integer.parseInt(next());
+			}
+			return arr;
+		}
+
+	}
+
+}
+",0
+8e990c75,d9f6c257,"import java.util.Scanner;
+
+public class Armchairs {
+    public static void main(String[] args) {
+        Scanner scanner = new Scanner(System.in);
+        int num = scanner.nextInt();
+        int[] chairs = new int[num];
+        int numOne = 0;
+        for (int i = 0; i < num; i++) {
+            chairs[i] = scanner.nextInt();
+            if (chairs[i] == 1) numOne++;
+        }
+        if (numOne == 0) {
+            System.out.println(0);
+            return;
+        }
+        int one = 0;
+        int zero = 0;
+
+        int[] ones = new int[numOne];
+        int[] zeros = new int[num - numOne];
+
+        for (int i = 0; i < num; i++) {
+            if (chairs[i] == 0) zeros[zero++] = i;
+            else ones[one++] = i;
+        }
+
+        long[][] nums = new long[numOne][num - numOne];
+        for (int c = 0; c < num - numOne; c++)
+            nums[0][c] = Math.abs(ones[0] - zeros[c]);
+
+        for (int r = 1; r < numOne; r++) {
+            long min = nums[r - 1][r - 1];
+            for (int c = r; c < num - numOne; c++) {
+                min = Math.min(nums[r - 1][c - 1], min);
+                nums[r][c] = min + Math.abs(ones[r] - zeros[c]);
+            }
+        }
+
+        Long result = Long.MAX_VALUE;
+        for (long min: nums[numOne - 1]) {
+            if (min > 0) result = Math.min(result, min);
+        }
+        System.out.println(result);
+    }
+}
+","import java.util.ArrayList;
+import java.util.List;
+import java.util.Scanner;
+public class D {
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        int n = sc.nextInt();
+        List<Integer> a1 = new ArrayList<>();
+        List<Integer> a0 = new ArrayList<>();
+        for (int i = 0; i < n; i++) {
+            int now = sc.nextInt();
+            if (now == 1) {
+                a1.add(i + 1);
+            } else {
+                a0.add(i + 1);
+            }
+        }
+        int[][] dp = new int[a1.size() + 1][a0.size() + 1];
+        for (int i = 1; i < dp.length; i++) {
+            dp[i][i] = dp[i - 1][i - 1] + Math.abs(a1.get(i - 1) - a0.get(i - 1));
+            for (int j = i + 1; j < dp[i].length; j++) {
+                dp[i][j] = Math.min(dp[i][j - 1], dp[i - 1][j - 1] + Math.abs(a1.get(i - 1) - a0.get(j - 1)));
+            }
+        }
+        System.out.println(dp[a1.size()][a0.size()]);
+    }
+}",0
+ae6567fb,d22a53cd,"
+import java.io.*;
+import java.util.*;
+ 
+public class D 
+{	
+	static ArrayList<Integer> g[];
+	static int[] vis,dist;
+	
+	public static void main(String[] args) throws IOException
+	{	
+		
+		FastReader f=new FastReader();
+		StringBuffer sb=new StringBuffer();
+	
+		int test=f.nextInt();
+		while(test-->0)
+		{
+			int n=f.nextInt();
+			g=new ArrayList[n+1];
+			vis=new int[n+1];
+			dist=new int[n+1];
+			
+			int a=f.nextInt();
+			int b=f.nextInt();
+			
+			int da=f.nextInt();
+			int db=f.nextInt();
+			
+			for(int i=0;i<=n;i++)
+				g[i]=new ArrayList<>();
+			
+			for(int i=1;i<n;i++)
+			{
+				int x=f.nextInt();
+				int y=f.nextInt();
+				
+				g[x].add(y);
+				g[y].add(x);
+			}
+			dfs(a,0);
+			if(-dist[a]+dist[b] <= da)
+			{
+				sb.append(""Alice\n"");
+				continue;
+			}
+			int nr=1,mx=0;
+			for(int i=1;i<=n;i++)
+			{
+				if(dist[i]>mx)
+				{
+					mx=dist[i];
+					nr=i;
+				}
+			}
+			vis=new int[n+1];
+			dist=new int[n+1];
+			dfs(nr,0);
+			int dm=0;
+			for(int i : dist)
+				dm=Math.max(dm,i);
+			dm--;
+			if(dm<= 2*da)
+			{
+				sb.append(""Alice\n"");
+				continue;
+			}
+			if(db>2*da)
+			{
+				sb.append(""Bob\n"");
+				continue;
+			}
+			else
+			{
+				sb.append(""Alice\n"");
+				continue;
+			}
+		}
+		System.out.println(sb);
+	}	
+		
+	static void dfs(int n,int par) 
+	{	
+		dist[n]=dist[par]+1;
+		vis[n] = 1;
+		for (int child : g[n]) {
+			if (vis[child] == 0)
+				dfs(child,n);
+		}
+
+	}
+	
+	static class FastReader 
+	{ 
+	    BufferedReader br; 
+	    StringTokenizer st; 
+
+	    public FastReader() {
+	    	br = new BufferedReader(new
+	                 InputStreamReader(System.in)); 
+	    }
+	    String next() { 
+	        while (st == null || !st.hasMoreElements()) { 
+	            try{ 
+	                st = new StringTokenizer(br.readLine()); 
+	            } 
+	            catch (IOException  e) { 
+	                e.printStackTrace(); 
+	            } 
+	        } 
+	        return st.nextToken(); 
+	    } 
+	    int nextInt() { 
+	        return Integer.parseInt(next()); 
+	    } 
+	    long nextLong() { 
+	        return Long.parseLong(next()); 
+	    } 
+	    double nextDouble() { 
+	        return Double.parseDouble(next()); 
+	    } 
+	    String nextLine() { 
+	        String str = """"; 
+	        try{ 
+	            str = br.readLine(); 
+	        } 
+	        catch (IOException e) { 
+	            e.printStackTrace(); 
+	        } 
+	        return str; 
+	    } 
+	} 
+}","
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.OutputStream;
+import java.io.PrintWriter;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.StringTokenizer;
+
+public class D {
+
+   private static final String INPUT_FILE_PATH = """";
+
+   int n, a, b, da, db;
+
+   ArrayList<Integer>[] adj;
+   int[] depth;
+   boolean[] visited;
+   int diameter;
+
+   int dfs(int u, int parent, int currDepth) {
+      visited[u] = true;
+      depth[u] = currDepth;
+
+      ArrayList<Integer> childDepths = new ArrayList();
+      for (int v : adj[u]) {
+         if (v != parent && !visited[v]) {
+            int childDepth = dfs(v, u, currDepth + 1);
+            childDepths.add(childDepth);
+         }
+      }
+      Collections.sort(childDepths);
+
+      // Update diameter
+      int n = childDepths.size();
+      if (n >= 2) {
+         int d1 = childDepths.get(n - 1) - currDepth;
+         int d2 = childDepths.get(n - 2) - currDepth;
+         diameter = Math.max(diameter, d1 + d2);
+      } else if (n == 1) {
+         diameter = Math.max(diameter, childDepths.get(n - 1) - currDepth);
+      } else {
+         diameter = Math.max(diameter, 1);
+      }
+
+      return childDepths.isEmpty() ? currDepth : childDepths.get(n - 1);
+   }
+
+   void solve() {
+      int t = in.nextInt();
+      while (t-- > 0) {
+         n = in.nextInt();
+         a = in.nextInt();
+         b = in.nextInt();
+         da = in.nextInt();
+         db = in.nextInt();
+         adj = new ArrayList[n + 1];
+         for (int i = 1; i <= n; i++) adj[i] = new ArrayList();
+         for (int i = 0; i < n - 1; i++) {
+            int u = in.nextInt(), v = in.nextInt();
+            adj[u].add(v);
+            adj[v].add(u);
+         }
+
+         depth = new int[n + 1];
+         visited = new boolean[n + 1];
+         diameter = 0;
+
+         dfs(a, -1, 0);
+
+         if (depth[b] <= da
+            || 2 * da >= db
+            || 2 * da >= diameter) {
+            out.println(""Alice"");
+         } else {
+            out.println(""Bob"");
+         }
+      }
+   }
+
+   private final InputReader in;
+   private final PrintWriter out;
+
+   private D(InputReader in, PrintWriter out) {
+      this.in = in;
+      this.out = out;
+   }
+
+   private static class InputReader {
+      private BufferedReader br;
+      private StringTokenizer st;
+
+      public InputReader(InputStream inputStream) {
+         this.br = new BufferedReader(new InputStreamReader(inputStream), 32768);
+         this.st = null;
+      }
+
+      public String nextToken() {
+         while (st == null || !st.hasMoreTokens()) {
+            try {
+               st = new StringTokenizer(br.readLine());
+            } catch (IOException e) {
+               throw new RuntimeException(e);
+            }
+         }
+         return st.nextToken();
+      }
+
+      public int nextInt() {
+         return Integer.parseInt(nextToken());
+      }
+
+      public long nextLong() {
+         return Long.parseLong(nextToken());
+      }
+
+      public double nextDouble() {
+         return Double.parseDouble(nextToken());
+      }
+   }
+
+   public static void main(String[] args) throws Exception {
+      InputStream inputStream = INPUT_FILE_PATH.isEmpty()
+         ? System.in
+         : new FileInputStream(new File(INPUT_FILE_PATH));
+      OutputStream outputStream = System.out;
+
+      InputReader inputReader = new InputReader(inputStream);
+      PrintWriter printWriter = new PrintWriter(outputStream);
+
+      new D(inputReader, printWriter).solve();
+
+      printWriter.close();
+   }
+
+}
+",0
+35eb27da,8559d49e,"/* package codechef; // don't place package name! */
+
+import java.util.*;
+import java.lang.*;
+import java.io.*;
+
+/* Name of the class has to be ""Main"" only if the class is public. */
+public class Codechef
+{
+	public static void main (String[] args) throws java.lang.Exception
+	{
+		Scanner sc = new Scanner(System.in);
+		int t = sc.nextInt();
+		while(t-- > 0)
+		{
+		    int n = sc.nextInt();
+		    sc.nextLine();
+		    int a[][] = new int[26][26];
+		    int b[][][] = new int[26][26][26];
+		    
+		    boolean bl = false;
+		    String arr[] = new String[n];
+		    for(int i = 0 ; i < n ; i++)
+		    {
+		        arr[i] = sc.nextLine();
+		        
+		        if(arr[i].length() == 1)
+		        {
+		            bl = true;
+		        }
+		        
+		        else if(arr[i].length() == 2)
+		        {
+		            //a[arr[i].charAt(0)-'a'][arr[i].charAt(1)-'a'] = 1;
+		            if(arr[i].charAt(0)==arr[i].charAt(1))
+		            bl = true;
+		        }
+		        
+		        else
+		        {
+		           //b[arr[i].charAt(0)-'a'][arr[i].charAt(1)-'a'][arr[i].charAt(2)-'a'] = 1; 
+		           if(arr[i].charAt(0) == arr[i].charAt(2))
+		           bl = true;
+		        }
+		    }
+		    
+		    if(bl)
+		    System.out.println(""YES"");
+		    
+		    else
+		    {
+		        for(int i = 0; i < n ; i++)
+		        {
+		            if(arr[i].length() == 2)
+		            {
+		                int p1 = arr[i].charAt(0)-'a';
+		                int p2 = arr[i].charAt(1)-'a';
+		                
+		                if(a[p2][p1] == 1)
+		                bl = true;
+		                
+		                for(int j = 0;  j < 26 ; j++)
+		                {
+		                    if(b[p2][p1][j] == 1)
+		                    bl = true;
+		                }
+		                a[p1][p2] = 1;
+		            }
+		            
+		            else
+		            {
+		                 int p1 = arr[i].charAt(0)-'a';
+		                int p2 = arr[i].charAt(1)-'a';
+		                int p3 = arr[i].charAt(2)-'a';
+		                
+		                if(a[p3][p2] == 1)
+		                bl = true;
+		                
+		                if(b[p3][p2][p1] == 1)
+		                bl = true;
+		                
+		                b[p1][p2][p3] = 1;
+		            }
+		        }
+		        if(bl)
+		        System.out.println(""YES"");
+		        
+		        else
+		        System.out.println(""NO"");
+		    }
+		}
+	}
+}","import java.io.*;
+import java.util.*;
+public class Ishu
+{
+    static Scanner scan = new Scanner(System.in);
+    static BufferedWriter output = new BufferedWriter(new OutputStreamWriter(System.out)); 
+    static void tc() throws Exception
+    {
+    int n = scan.nextInt();
+    String[] str = new String[n];
+    int i, j;
+    
+    for(i=0;i<n;++i)
+        str[i] = scan.next();
+        
+    String ans = ""NO"";
+    for(i=0;i<n;++i)
+        {
+        String cur = str[i];
+        int len = cur.length();
+        if(cur.charAt(0) == cur.charAt(len - 1))
+            {
+            output.write(""YES\n"");
+            output.flush();
+            return;
+            }
+        }
+        
+    Map<String, Integer> map = new HashMap<String, Integer>();
+    Map<String, Integer> par = new HashMap<String, Integer>();
+    
+    for(i=0;i<n;++i)
+       {
+       String cur = str[i];
+       int len = cur.length();
+       if(len == 2)
+            {
+            if(!map.containsKey(cur))
+                map.put(cur, 0);
+                
+            int value = map.get(cur);
+            ++value;
+            map.remove(cur);
+            map.put(cur, value);
+            }
+       else 
+            {
+            String pre = cur.substring(0, 2);
+            if(!par.containsKey(pre))
+                par.put(pre, 0);
+            int value = par.get(pre);
+            ++value;
+            par.remove(pre);
+            par.put(pre, value);
+            
+            if(!map.containsKey(cur))
+                map.put(cur, 0);
+            value = map.get(cur);
+            ++value;
+            map.remove(cur);
+            map.put(cur, value);
+            }     
+       }
+       
+    for(i=n-1;i>=0;--i)
+        {
+        String cur = str[i];
+        int len = cur.length();
+        if(len == 2)
+            {
+            int value = map.get(cur);
+            --value;
+            map.remove(cur);
+            if(value > 0)
+                map.put(cur, value);
+            }
+        else
+            {
+            String pre = cur.substring(0, 2);
+            int value = par.get(pre);
+            --value;
+            par.remove(pre);
+            if(value > 0)
+                par.put(pre, value);
+                
+            value = map.get(cur);
+            --value;
+            map.remove(cur);
+            if(value > 0)
+                map.put(cur, value);
+            }    
+        
+        if(len == 2)
+            {
+            StringBuffer buffer = new StringBuffer(cur);
+            buffer.reverse();
+            String rev = String.valueOf(buffer);
+            
+            if(map.containsKey(rev) || par.containsKey(rev))
+                {
+                ans = ""YES"";
+                break;
+                }    
+            }
+        else
+            {
+            String suf = cur.substring(1, 3);
+            StringBuffer buffer = new StringBuffer(suf);
+            buffer.reverse();
+            String rev = String.valueOf(buffer);
+            
+            if(map.containsKey(rev))
+                {
+                ans = ""YES"";
+                break;
+                }
+            
+            buffer = new StringBuffer(cur);
+            buffer.reverse();
+            rev = String.valueOf(buffer);
+            
+            if(map.containsKey(rev))
+                {
+                ans = ""YES"";
+                break;
+                }
+            }
+        }
+        
+    output.write(ans + ""\n"");
+    output.flush();
+    }
+    
+    public static void main(String[] args) throws Exception
+    {
+    int t = 1;
+    t = scan.nextInt();
+    while(t-- > 0)
+        tc();
+    }
+}
+
+",0
+2bbf754b,3a12e509,"import java.util.*;
+
+/** 
+__                  __
+( _)                ( _)
+/ / \\              / /\_\_
+/ /   \\            / / | \ \
+/ /     \\          / /  |\ \ \
+/  /   ,  \ ,       / /   /|  \ \
+/  /    |\_ /|      / /   / \   \_\
+/  /  |\/ _ '_| \   / /   /   \    \\
+|  /   |/  0 \0\    / |    |    \    \\
+|    |\|      \_\_ /  /    |     \    \\
+|  | |/    \.\ o\o)  /      \     |    \\
+\    |     /\\`v-v  /        |    |     \\
+| \/    /_| \\_|  /         |    | \    \\
+| |    /__/_ `-` /   _____  |    |  \    \\
+\|    [__]  \_/  |_________  \   |   \    ()
+/    [___] (    \         \  |\ |   |   //
+|    [___]                  |\| \|   /  |/
+/|    [____]                  \  |/\ / / ||
+(  \   [____ /     ) _\      \  \    \| | ||
+\  \  [_____|    / /     __/    \   / / //
+|   \ [_____/   / /        \    |   \/ //
+|   /  '----|   /=\____   _/    |   / //
+__ /  /        |  /   ___/  _/\    \  | ||
+(/-(/-\)       /   \  (/\/\)/  |    /  | /
+(/\/\)           /   /   //
+_________/   /    /
+\____________/    (
+
+
+
+*/
+
+public class Main {
+	public static void main(String[] args) {
+		Scanner sc=new Scanner(System.in);
+		int  t=sc.nextInt();
+		while(t-- >0) {
+			int n=sc.nextInt();
+			int[] arr=new int[n];
+			for(int i=0;i<n;i++) {
+				arr[i]=sc.nextInt();
+			}
+			String str=sc.next();
+			
+			ArrayList<Pair> plist=new ArrayList<>();
+			for(int i=0;i<n;i++) {
+				char ch=str.charAt(i);
+				plist.add(new Pair(arr[i],ch));
+			}
+			
+			//B-reduce
+			//R-increse
+			Collections.sort(plist);
+			
+			int counter=1;
+			boolean flag=false;
+			for(int i=0;i<plist.size();i++) {
+				int val=plist.get(i).number;
+				int clr=plist.get(i).color;
+				
+				if(clr=='B') {
+					if(val<counter) {
+						flag=true;
+						break;
+					}
+				}
+				else {
+					if(val>counter) {
+						flag=true;
+						break;
+					}
+					
+				}
+				counter++;
+			}
+			System.out.println(flag?""NO"":""YES"");
+			
+			
+		}
+	}
+	public static class Pair implements Comparable<Pair>{
+		int number;
+		char color;
+		
+		Pair(int number,char color){
+			this.number=number;
+			this.color=color;
+		}
+		
+		@Override
+		public int compareTo(Pair o) {
+			if(o.color==this.color) {
+				return this.number-o.number;
+			}
+			else {
+				return this.color-o.color;
+			}
+		}
+		
+		public String toString() {
+			return number+""-""+color+""."";
+		}
+	}
+}
+","import java.io.*;
+import java.util.*;
+
+
+public class Practice
+{
+//	static final long mod=7420738134811L;
+	static int mod=1000000007;
+	static final int size=501;
+	static FastReader sc=new FastReader(System.in);
+//	static Reader sc=new Reader();
+	static  PrintWriter out=new PrintWriter(System.out);
+	static long[] factorialNumInverse;
+	static long[] naturalNumInverse;	
+	static int[] sp;
+	static long[] fact;
+	static ArrayList<Integer> pr;
+	public static void main(String[] args) throws IOException
+	{
+//		System.setIn(new FileInputStream(""input.txt""));
+//		System.setOut(new PrintStream(""output.txt""));
+//		factorial(mod);
+//		InverseofNumber(mod);
+//		InverseofFactorial(mod);
+//		make_seive();
+		int t=1;
+		t=sc.nextInt();
+		while(t-->0)
+			solve();
+		out.close();
+		out.flush();
+	}
+	static void solve() throws IOException
+	{
+		int n=sc.nextInt();
+		int arr[]=new int[n];
+		for(int i=0;i<n;i++)
+			arr[i]=sc.nextInt();
+		String s=sc.next();
+		ArrayList<Integer> blue=new ArrayList<Integer>();
+		ArrayList<Integer> red=new ArrayList<Integer>();
+		for(int i=0;i<n;i++)
+		{
+			if(s.charAt(i)=='B')
+				blue.add(arr[i]);
+			else
+				red.add(arr[i]);
+		}
+		Collections.sort(blue);
+		Collections.sort(red);
+		for(int i=0;i<blue.size();i++)
+		{
+			if(blue.get(i)<i+1)
+			{
+				out.println(""NO"");
+				return;
+			}
+		}
+		for(int i=0;i<red.size();i++)
+		{
+			if(red.get(i)>i+1+blue.size())
+			{
+				out.println(""NO"");
+				return;
+			}
+		}
+		out.println(""YES"");
+	}
+	static class Pair implements Cloneable, Comparable<Pair>
+	{
+		int x,y;
+		Pair(int a,int b)
+		{
+			this.x=a;
+			this.y=b;
+		}
+		@Override
+		public boolean equals(Object obj) 
+		{
+			if(obj instanceof  Pair)
+			{
+				Pair p=(Pair)obj;
+				return p.x==this.x && p.y==this.y;
+			}
+			return false;
+		}
+		@Override
+		public int hashCode() 
+		{
+			return Math.abs(x)+500*Math.abs(y);
+		}
+		@Override
+		public String toString() 
+		{
+			return ""(""+x+"" ""+y+"")"";
+		}
+		@Override
+		protected Pair clone() throws CloneNotSupportedException {
+			return new Pair(this.x,this.y);
+		}
+		@Override
+		public int compareTo(Pair a) 
+		{
+			int t= this.x-a.x;
+			if(t!=0)
+				return t;
+			else
+				return this.y-a.y;
+		}
+		public void swap()
+		{
+			this.y=this.y+this.x;
+			this.x=this.y-this.x;
+			this.y=this.y-this.x;			
+		}
+	}
+	static class Tuple implements Cloneable, Comparable<Tuple>
+	{
+		int x,y,z;
+		Tuple(int a,int b,int c)
+		{
+			this.x=a;
+			this.y=b;
+			this.z=c;
+		}
+		public boolean equals(Object obj) 
+		{
+			if(obj instanceof  Tuple)
+			{
+				Tuple p=(Tuple)obj;
+				return p.x==this.x && p.y==this.y && p.z==this.z;
+			}
+			return false;
+		}
+		@Override
+		public int hashCode() 
+		{
+			return (this.x+501*this.y);
+		}
+		@Override
+		public String toString() 
+		{
+			return ""(""+x+"",""+y+"",""+z+"")"";
+		}
+		@Override
+		protected Tuple clone() throws CloneNotSupportedException {
+			return new Tuple(this.x,this.y,this.z);
+		}
+		@Override
+		public int compareTo(Tuple a) 
+		{
+			int x=this.z-a.z;
+			if(x!=0)
+				return x;
+			int X= this.x-a.x;
+			if(X!=0)
+				return X;
+			return a.y-this.y;
+		}
+	}
+	static void arraySort(int arr[])
+	{
+		ArrayList<Integer> a=new ArrayList<Integer>();
+		for (int i = 0; i < arr.length; i++) {
+			a.add(arr[i]);
+		}
+		Collections.sort(a);
+		for (int i = 0; i < arr.length; i++) {
+			arr[i]=a.get(i);
+		}
+	}
+	static void arraySort(long arr[])
+	{
+		ArrayList<Long> a=new ArrayList<Long>();
+		for (int i = 0; i < arr.length; i++) {
+			a.add(arr[i]);
+		}
+		Collections.sort(a);
+		for (int i = 0; i < arr.length; i++) {
+			arr[i]=a.get(i);
+		}
+	}
+	static HashSet<Integer> primeFactors(int n)
+	{
+		HashSet<Integer> ans=new HashSet<Integer>();
+		if(n%2==0)
+		{
+			ans.add(2);
+			while((n&1)==0)
+				n=n>>1;
+		}
+		for(int i=3;i*i<=n;i+=2)
+		{
+			if(n%i==0)
+			{
+				ans.add(i);
+				while(n%i==0)
+					n=n/i;
+			}
+		}
+		if(n!=1)
+			ans.add(n);
+		return ans;
+	}
+	static void make_seive()
+	{
+		sp=new int[size];
+		pr=new ArrayList<Integer>();
+		for (int i=2; i<size; ++i) {
+		    if (sp[i] == 0) {
+		        sp[i] = i;
+		        pr.add(i);
+		    }
+		    for (int j=0; j<(int)pr.size() && pr.get(j)<=sp[i] && i*pr.get(j)<size; ++j)
+		        sp[i * pr.get(j)] = pr.get(j);
+		}
+	}
+	public static void InverseofNumber(int p)
+	{
+		naturalNumInverse=new long[size];
+	    naturalNumInverse[0] = naturalNumInverse[1] = 1;
+	    for(int i = 2; i < size; i++)
+	        naturalNumInverse[i] = naturalNumInverse[p % i] * (long)(p - p / i) % p;
+	}
+	// Function to precompute inverse of factorials
+	public static void InverseofFactorial(int p)
+	{
+		factorialNumInverse=new long[size];
+	    factorialNumInverse[0] = factorialNumInverse[1] = 1;
+	    // pre-compute inverse of natural numbers
+	    for(int i = 2; i < size; i++)
+	        factorialNumInverse[i] = (naturalNumInverse[i] * factorialNumInverse[i - 1]) % p;
+	}
+	// Function to calculate factorial of 1 to 200001
+	public static void factorial(int p)
+	{
+		fact=new long[size];
+	    fact[0] = 1;
+	    for(int i = 1; i < size; i++)
+	        fact[i] = (fact[i - 1] * (long)i) % p;
+	}
+	 
+	// Function to return nCr % p in O(1) time
+	public static long Binomial(int N, int R)
+	{
+		if(R<0)
+			return 1;
+	    // n C r = n!*inverse(r!)*inverse((n-r)!)
+	    long ans = ((fact[N] * factorialNumInverse[R]) % mod * factorialNumInverse[N - R]) % mod;
+	    return ans;
+	}
+	static int findXOR(int x)	//from 0 to x
+	{
+		if(x<0)
+			return 0;
+		if(x%4==0)
+			return x;
+		if(x%4==1)
+			return 1;
+		if(x%4==2)
+			return x+1;
+		return 0;
+	}
+	static boolean isPrime(long x)
+	{
+		if(x==1)
+			return false;
+		if(x<=3)
+			return true;
+		if(x%2==0 || x%3==0)
+			return false;
+		for(int i=5;i<=Math.sqrt(x);i+=2)
+			if(x%i==0)
+				return false;
+		return true;
+	}
+	static long gcd(long a,long b)
+	{
+		return (b==0)?a:gcd(b,a%b);
+	}
+	static int gcd(int a,int b)
+	{
+		return (b==0)?a:gcd(b,a%b);
+	}
+	static class Node
+	{
+		int vertex;
+		HashSet<Edge> adj;
+		int taxC,taxD;
+		Node(int ver)
+		{
+			vertex=ver;
+			taxD=0;
+			taxC=0;
+			adj=new HashSet<Edge>();
+		}
+		@Override
+		public String toString() 
+		{
+			return vertex+"" "";
+		}
+	}
+	static class Edge
+	{
+		Node to;
+		int cost;
+		Edge(Node t,int c)
+		{
+			this.to=t;
+			this.cost=c;
+		}
+		@Override
+		public String toString() {
+			return ""(""+to.vertex+"",""+cost+"") "";
+		}
+	}
+	static long power(long x, long y)
+	  {
+		if(x<=0)
+			return 1;
+	    long res = 1; 
+	    x = x % mod; 
+	    if (x == 0)
+	      return 0; 
+	    while (y > 0)
+	    {
+	    	if ((y & 1) != 0)
+	    		res = (res * x) % mod;
+	    	
+	    	y = y >> 1; // y = y/2
+	    	x = (x * x) % mod;
+	    }
+	    return res;
+	  }
+	static long binomialCoeff(long n, long k)
+    {
+		if(n<k)
+			return 0;
+        long res = 1;
+//        if(k>n)
+//        	return 0;
+        // Since C(n, k) = C(n, n-k)
+        if (k > n - k)
+            k = n - k;
+ 
+        // Calculate value of
+        // [n * (n-1) *---* (n-k+1)] / [k * (k-1) *----* 1]
+        for (long i = 0; i < k; ++i) {
+            res *= (n - i);
+            res /= (i + 1);
+        }
+ 
+        return res;
+    }
+	static class FastReader
+	{
+        byte[] buf = new byte[2048];
+        int index, total;
+        InputStream in;
+ 
+        FastReader(InputStream is) 
+        {
+            in = is;
+        }
+ 
+        int scan() throws IOException 
+        {
+            if (index >= total) {
+                index = 0;
+                total = in.read(buf);
+                if (total <= 0) {
+                    return -1;
+                }
+            }
+            return buf[index++];
+        }
+ 
+        String next() throws IOException 
+        {
+            int c;
+            for (c = scan(); c <= 32; c = scan());
+            StringBuilder sb = new StringBuilder();
+            for (; c > 32; c = scan()) {
+                sb.append((char) c);
+            }
+            return sb.toString();
+        }
+ 
+        int nextInt() throws IOException 
+        {
+            int c, val = 0;
+            for (c = scan(); c <= 32; c = scan());
+            boolean neg = c == '-';
+            if (c == '-' || c == '+') {
+                c = scan();
+            }
+            for (; c >= '0' && c <= '9'; c = scan()) {
+                val = (val << 3) + (val << 1) + (c & 15);
+            }
+            return neg ? -val : val;
+        }
+ 
+        long nextLong() throws IOException 
+        {
+            int c;
+            long val = 0;
+            for (c = scan(); c <= 32; c = scan());
+            boolean neg = c == '-';
+            if (c == '-' || c == '+') {
+                c = scan();
+            }
+            for (; c >= '0' && c <= '9'; c = scan()) {
+                val = (val << 3) + (val << 1) + (c & 15);
+            }
+            return neg ? -val : val;
+        }
+    }
+	static class Reader 
+	{
+        final private int BUFFER_SIZE = 1 << 16;
+        private DataInputStream din;
+        private byte[] buffer;
+        private int bufferPointer, bytesRead;
+ 
+        public Reader()
+        {
+            din = new DataInputStream(System.in);
+            buffer = new byte[BUFFER_SIZE];
+            bufferPointer = bytesRead = 0;
+        }
+ 
+        public Reader(String file_name) throws IOException
+        {
+            din = new DataInputStream(
+                new FileInputStream(file_name));
+            buffer = new byte[BUFFER_SIZE];
+            bufferPointer = bytesRead = 0;
+        }
+ 
+        public String readLine() throws IOException
+        {
+            byte[] buf = new byte[64]; // line length
+            int cnt = 0, c;
+            while ((c = read()) != -1) {
+                if (c == '\n') {
+                    if (cnt != 0) {
+                        break;
+                    }
+                    else {
+                        continue;
+                    }
+                }
+                buf[cnt++] = (byte)c;
+            }
+            return new String(buf, 0, cnt);
+        }
+ 
+        public int nextInt() throws IOException
+        {
+            int ret = 0;
+            byte c = read();
+            while (c <= ' ') {
+                c = read();
+            }
+            boolean neg = (c == '-');
+            if (neg)
+                c = read();
+            do {
+                ret = ret * 10 + c - '0';
+            } while ((c = read()) >= '0' && c <= '9');
+ 
+            if (neg)
+                return -ret;
+            return ret;
+        }
+ 
+        public long nextLong() throws IOException
+        {
+            long ret = 0;
+            byte c = read();
+            while (c <= ' ')
+                c = read();
+            boolean neg = (c == '-');
+            if (neg)
+                c = read();
+            do {
+                ret = ret * 10 + c - '0';
+            } while ((c = read()) >= '0' && c <= '9');
+            if (neg)
+                return -ret;
+            return ret;
+        }
+ 
+        public double nextDouble() throws IOException
+        {
+            double ret = 0, div = 1;
+            byte c = read();
+            while (c <= ' ')
+                c = read();
+            boolean neg = (c == '-');
+            if (neg)
+                c = read();
+ 
+            do {
+                ret = ret * 10 + c - '0';
+            } while ((c = read()) >= '0' && c <= '9');
+ 
+            if (c == '.') {
+                while ((c = read()) >= '0' && c <= '9') {
+                    ret += (c - '0') / (div *= 10);
+                }
+            }
+ 
+            if (neg)
+                return -ret;
+            return ret;
+        }
+ 
+        private void fillBuffer() throws IOException
+        {
+            bytesRead = din.read(buffer, bufferPointer = 0,
+                                 BUFFER_SIZE);
+            if (bytesRead == -1)
+                buffer[0] = -1;
+        }
+ 
+        private byte read() throws IOException
+        {
+            if (bufferPointer == bytesRead)
+                fillBuffer();
+            return buffer[bufferPointer++];
+        }
+ 
+        public void close() throws IOException
+        {
+            if (din == null)
+                return;
+            din.close();
+        }
+        public void printarray(int arr[])
+        {
+        	for (int i = 0; i < arr.length; i++)
+				System.out.print(arr[i]+"" "");
+        	System.out.println();
+        }
+    }
+}
+
+
+
+
+
+
+
+",0
+34aa6a45,dd5fd2a2,"/*
+ID: abdelra29
+LANG: JAVA
+TASK: skidesign
+*/
+import java.util.*;
+import java.math.*;
+import java.io.*; 
+ public class B{
+static int[] dx = new int[]{-1,0,1,0};
+    static int[] dy = new int[]{0,1,0,-1};
+    static FastReader scan=new FastReader();
+   public static PrintWriter out = new PrintWriter (new BufferedOutputStream(System.out));
+  static ArrayList<Pair>es;
+  static LinkedList<Integer>edges[];
+  static Set<Pair>edges2[][];
+
+   static boolean prime[];
+   static void sieve(int n) 
+    { 
+        
+        prime = new boolean[n+1]; 
+        for(int i=0;i<n;i++) 
+            prime[i] = true; 
+          
+        for(int p = 2; p*p <=n; p++) 
+        { 
+           
+            if(prime[p] == true) 
+            { 
+                
+                for(int i = p*p; i <= n; i += p) 
+                    prime[i] = false; 
+            } 
+        } 
+          
+        
+    }      
+     public static int lowerBound(int[] array, int length, int value) {
+        int low = 0;
+        int high = length;
+        while (low < high) {
+            final int mid = (low + high) / 2;
+            //checks if the value is less than middle element of the array
+            if (value <= array[mid]) {
+                high = mid;
+            } else {
+                low = mid+1 ;
+            }
+        }
+        return low;
+    }
+    public static int upperBound(int[] array, int length, int value) {
+        int low = 0;
+        int high = length;
+        while (low < high) {
+            final int mid = low+(high-low) / 2;
+            if ( array[mid]>value) {
+                high = mid ;
+            } else {
+                low = mid+1;
+            }
+        }
+        return low;
+    }
+static long mod(long x,long y)
+    {
+        if(x<0)
+            x=x+(-x/y+1)*y;
+        return x%y;
+    }    
+     static boolean isPowerOfTwo(long n) 
+    { 
+        if (n == 0) 
+            return false; 
+  
+        while (n != 1) { 
+            if (n % 2 != 0) 
+                return false; 
+            n = n / 2; 
+        } 
+        return true; 
+    } 
+
+  
+   
+static boolean isprime(long x)
+           {
+            for(long i=2;i*i<=x;i++)
+                if(x%i==0)
+                    return false;
+                return true;
+           }
+
+
+static int dist(int x1,int y1,int x2,int y2){
+return Math.abs(x1-x2)+Math.abs(y1-y2);
+}
+
+
+    static long cuberoot(long x)
+    {
+        long lo = 0, hi = 1000005;
+        while(lo<hi)
+        {
+            long m = (lo+hi+1)/2;
+            if(m*m*m>x)
+                hi = m-1;
+            else
+                lo = m;
+        }
+        return lo;
+    }
+     public static int log2(int N) 
+    { 
+  
+        // calculate log2 N indirectly 
+        // using log() method 
+        int result = (int)(Math.log(N) / Math.log(2)); 
+  
+        return result; 
+    } 
+  
+    
+   
+       static long gcd(long a, long b) {
+    if(a!=0&&b!=0)
+        while((a%=b)!=0&&(b%=a)!=0);
+    return a^b;
+}
+    static long LCM(long a,long b){
+    return (Math.abs(a*b))/gcd(a,b);
+   }
+   static int mid;
+   public static class comp1 implements Comparator<ArrayList<Integer>>{  
+public int compare(ArrayList<Integer> o1,ArrayList<Integer> o2){
+    return (int)(o2.size()-o1.size());
+}
+  }
+
+     public static class comp2 implements Comparator<Pair>{  
+public int compare(Pair o1,Pair o2){
+ 
+return (int)((o1.x+o1.y*mid)-(o2.x+o2.y*mid));
+}
+  }
+ static boolean can(int m,int s)
+ {
+    return (s>=0&&s<=m*9);
+ }
+   static boolean collinear(long x1, long y1, long x2,  
+                          long y2, long x3, long y3) 
+{
+    long a = x1 * (y2 - y3) +  
+                x2 * (y3 - y1) +  
+                x3 * (y1 - y2); 
+                if(a==0)
+                    return true;
+                return false;
+}
+
+static int ceil(int a,int b)
+{
+    if(a%b!=0)
+        return (a/b)+1;
+    else return a/b;
+}
+
+static int cnt=0;
+static int count1[];
+ static void numberOfNodes(int s, int e) 
+    { 
+        count1[s] = 1; 
+        for(Integer u: edges[s]) 
+        { 
+            // condition to omit reverse path 
+            // path from children to parent 
+            if(u == e) 
+                continue; 
+              
+            // recursive call for DFS 
+            numberOfNodes(u ,s); 
+              
+            // update count[] value of parent using  
+            // its children 
+            count1[s] += count1[u]; 
+        } 
+    } 
+/*static int rec(int i)
+{
+
+}*/
+static long arr[];
+static int n;
+static long res,tmpres;
+static ArrayList<Pair>pairs;
+static boolean vis[];
+static long dp[][];
+static long dfs(int x,long last,int prev)
+{
+  //  vis[x]=true;
+   // System.out.println
+    if(dp[x][prev]!=-1){
+       // out.println(""FUCK"");
+        return dp[x][prev];
+    }
+    long ch1=0,ch2=0,res=0;
+    for(int v:edges[x])
+    {
+        if(!vis[v])
+        {
+            vis[v]=true;
+          //  ch1+=
+
+            //vis[v]=false;
+            res+=Math.max((dfs(v,pairs.get(v).x,1)+Math.abs(pairs.get(v).x-last)),(dfs(v,pairs.get(v).y,2)+Math.abs(pairs.get(v).y-last)));
+           // res+=Math.max(ch1,ch2);
+            vis[v]=false;
+        }
+    }
+    return dp[x][prev]=res;
+}
+public static void main(String[] args)  throws Exception 
+{
+    /*int xx=253;
+    for(int i=1;i*i<=xx;i++)
+    {
+        if(xx%i==0)
+        {
+            System.out.println(i);
+            System.out.println(xx/i);
+        }
+    }*/
+//java.util.Scanner scan=new java.util.Scanner(new File(""mootube.in""));
+// PrintWriter out = new PrintWriter (new FileWriter(""mootube.out""));
+//scan=new FastReader(""skidesign.in"");
+//out = new PrintWriter (""skidesign.out"");
+//System.out.println(3^2);
+//System.out.println(19%4);
+   //StringBuilder news=new StringBuilder(""ab"");
+   //news.deleteCharAt(1);
+   //news.insert(0,'c');
+   //news.deleteCharAt(0);
+   //System.out.println(news);
+   //System.out.println(can(2,15));
+    //System.out.println(LCM(2,2));
+  // System.out.println(31^15);
+ //System.out.println("""");
+   //System.out.println(824924296372176000L>(long)1e16);
+int tt=1;
+//rec(2020);
+//System.out.println(Long.MAX_VALUE);
+//System.out.println(Integer.MAX_VALUE);
+//int st=scan.nextInt();
+//System.out.println(calc(91));
+//sieve(21000);
+
+//SNWNSENSNNSWNNW
+
+   // System.out.println(set.remove(new Pair(1,1)));
+//System.out.println(count(""cccccccccccccccccccccccccooooooooooooooooooooooooodddddddddddddeeeeeeeeeeeeeeeeeeeeeeeeeffffffffffffforrrrrrrrrrrrrcesssssssssssss"",""codeforces""));
+  //S0ystem.out.println(isPowerOfTwo(446265625L));
+//System.out.println(""daaa"".compareTo(""bccc""));
+//System.out.println(2999000999L>1999982505L);
+//System.out.println(""?bac?bac??a?a?a?abac????abacab?ca?a"".length());
+//StringBuilder s=new StringBuilder("""");
+//tt=scan.nextInt();
+//String ok=""ABDC"";
+//System.out.println(ok.substring(2));
+//System.out.println(2000000000/2);
+tt=scan.nextInt();
+//System.out.println(LCM(4,6));
+//System.out.println(isprime(23335));
+//int T=1;
+  outer:while(tt-->0)
+ {
+int n=scan.nextInt();
+pairs=new ArrayList<Pair>();
+edges=new LinkedList[n];
+for(int i=0;i<n;i++)
+edges[i]=new LinkedList();
+for(int i=0;i<n;i++)
+{
+    long l=scan.nextLong(),r=scan.nextLong();
+    pairs.add(new Pair(l,r));
+}
+for(int i=0;i<n-1;i++)
+{
+    int a=scan.nextInt()-1;
+    int b=scan.nextInt()-1;
+    edges[a].add(b);
+    edges[b].add(a);
+}
+vis=new boolean[n];
+vis[0]=true;
+dp=new long[n][3];
+for(long K[]:dp)
+    Arrays.fill(K,-1);
+long x=dfs(0,pairs.get(0).x,0);
+vis=new boolean[n];
+vis[0]=true;
+dp=new long[n][3];
+for(long K[]:dp)
+    Arrays.fill(K,-1);
+out.println(Math.max(x,dfs(0,pairs.get(0).y,0)));
+
+}
+out.close();
+
+}
+
+static class dsu{
+    static int id[]=new int[101];
+    dsu()
+    {
+        for(int i=0;i<101;i++)
+            id[i]=i;
+    }
+    static int find(int x)
+    {
+        if(x==id[x])
+            return x;
+        return find(id[x]);
+    }
+    static void connect(int i,int j)
+    {
+        i=find(i);
+        j=find(j);
+        id[i]=j;
+    }
+    static boolean is(int i,int j)
+    {
+        return find(i)==find(j);
+    }
+}
+static long binexp(long a,long n,long mod)
+{
+    if(n==0)
+       return 1;
+    long res=binexp(a,n/2,mod)%mod;
+    res=res*res;
+    if(n%2==1)
+        return (res*a)%mod;
+    else 
+        return res%mod;
+}
+static class special{
+    Pair x;
+    Pair y;
+    special(Pair x,Pair y)
+    {
+      this.x=new Pair(x.x,x.y);
+      this.y=new Pair(y.x,y.y);
+    }   
+      @Override
+        public int hashCode() {
+            return (int)(x.x + 31 * y.y);
+        }
+        public boolean equals(Object other)
+    {
+        if(other instanceof special)
+        {
+            special e =(special)other;
+            return this.x.x==e.x.x && this.x.y==e.x.y && this.y.x==e.y.x && this.y.y==e.y.y;
+        }
+        else return false;
+    }
+}
+static long powMod(long base, long exp, long mod) {
+       if (base == 0 || base == 1) return base;
+       if (exp == 0) return 1;
+       if (exp == 1) return base % mod;
+       long R = powMod(base, exp/2, mod) % mod;
+       R *= R;
+       R %= mod;
+       if ((exp & 1) == 1) {
+           return base * R % mod;
+       }
+       else return R % mod;
+   }
+ public static  long pow(long b, long e) {
+            long r = 1;
+            while (e > 0) {
+                if (e % 2 == 1) r = r * b ;
+                b = b * b;
+                e >>= 1;
+            }
+            return r;
+        }
+
+private static void sort(int[] arr) {
+        List<Integer> list = new ArrayList<>();
+        for (int object : arr) list.add(object);
+        Collections.sort(list);
+        for (int i = 0; i < list.size(); ++i) arr[i] = list.get(i);
+    }
+ public static class FastReader {
+        BufferedReader br;
+        StringTokenizer root;
+        
+ 
+        public FastReader() {
+            br = new BufferedReader(new InputStreamReader(System.in));
+        }
+        FastReader(String filename)throws Exception
+        {
+
+            br=new BufferedReader(new FileReader(filename));
+        }
+ 
+        String next() {
+            while (root == null || !root.hasMoreTokens()) {
+                try {
+                    root = new StringTokenizer(br.readLine());
+                } catch (Exception addd) {
+                    addd.printStackTrace();
+                }
+            }
+            return root.nextToken();
+        }
+ 
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+ 
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+ 
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+ 
+        String nextLine() {
+            String str = """";
+            try {
+                str = br.readLine();
+            } catch (Exception addd) {
+                addd.printStackTrace();
+            }
+            return str;
+        }
+         public int[] nextIntArray(int arraySize) {
+            int array[] = new int[arraySize];
+ 
+            for (int i = 0; i < arraySize; i++) {
+                array[i] = nextInt();
+            }
+ 
+            return array;
+        }
+}
+public static class Pair implements Comparable<Pair>{
+         long x;
+         long y;
+         long ab;
+        
+        long z;
+        public Pair(){}
+        public Pair(long x1, long y1,long z) {
+            x=x1;
+            y=y1;
+            this.z=z;
+        }
+        public Pair(long x1, long y1) {
+            x=x1;
+            y=y1;
+            this.ab=x+y;
+        
+        }
+        @Override
+        public int hashCode() {
+            final int prime = 31;
+            int result = 1;
+            result = prime * result +(int) x;
+            result = prime * result + (int)y;
+            return result;
+        }
+        public String toString() {
+            return x + "" "" + y;
+        }
+        @Override
+        public boolean equals(Object o){
+            if (o == this) return true;
+            if(o==null)
+                return false;
+            if (o.getClass() != getClass()) return false;
+            Pair t = (Pair)o;
+            return t.x == x && t.y == y&&t.z==z;
+        }
+        public  int compareTo(Pair o)
+        {
+            return (int)(y-o.y);
+        }
+}
+
+}
+
+
+
+
+
+
+
+","import java.util.*;
+import java.io.*;
+import java.math.*;
+
+public class A {
+	static FastReader f = new FastReader();
+	static PrintWriter out = new PrintWriter(System.out);
+
+	public static void main(String[] args) {
+		int t = f.nextInt();
+		while(t-- > 0)
+			solve();
+		out.close();
+	}
+
+	static Node[] nodes;
+	static long[][] dp;
+	static void solve() {
+		int n = f.nextInt();
+
+		nodes = new Node[n];
+
+		for(int i=0;i<n;i++) {
+			nodes[i] = new Node(f.nextInt(), f.nextInt());
+		}
+
+		for(int i=1;i<n;i++) {
+			int u = f.nextInt() - 1;
+			int v = f.nextInt() - 1;
+			nodes[u].adj.add(v);
+			nodes[v].adj.add(u);
+		}
+
+
+		dp = new long[n][2];
+		for(int i=0;i<n;i++) {
+			for(int j=0;j<2;j++) {
+				dp[i][j] = -1;
+			}
+		}
+
+
+		System.out.println(Math.max(rek(-1, 0,false),rek(-1, 0,true)));
+
+
+	}
+
+	static long rek(int from, int now, boolean left) { //TODO: DP
+		if(dp[now][left?0:1] != -1) {
+			return dp[now][left?0:1];
+		}
+
+		long ret = 0;
+
+		for(int i : nodes[now].adj) {
+			if(i == from) {
+				continue;
+			}
+			long l = rek(now,i,false) + Math.abs(nodes[i].right - (left ? nodes[now].left : nodes[now].right));
+			long r = rek(now,i,true) + Math.abs(nodes[i].left - (left ? nodes[now].left : nodes[now].right));
+			
+			ret += Math.max(l, r);
+		}
+
+		dp[now][left?0:1] = ret;
+		return ret;
+	}
+
+	static class Node {
+		int left, right;
+		ArrayList<Integer> adj = new ArrayList<>();
+
+		Node(int left, int right) {
+			this.left = left;
+			this.right = right;
+		}
+	}
+
+
+	
+
+	static class FastReader {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st;
+
+		String next() {
+			while(st == null || !st.hasMoreElements()) {
+				try {
+					st = new StringTokenizer(br.readLine());
+				} catch(IOException ioe) {
+					ioe.printStackTrace();
+				}
+			}
+			return st.nextToken();
+		}
+
+		String nextLine() {
+			String s = """";
+			try {
+				s = br.readLine();
+			} catch(IOException ioe) {
+				ioe.printStackTrace();
+			}
+
+			return s;
+		}
+
+		int  nextInt() {
+			return Integer.parseInt(next());
+		}
+
+		double  nextDouble() {
+			return Double.parseDouble(next());
+		}
+
+		long  nextLong() {
+			return Long.parseLong(next());
+		}
+	}
+}
+",0
+927384f2,b2bae06a,"import java.util.*;
+import java.io.*;
+
+public class Main{
+	static class Point{
+		int x,y,z;
+		Point(int nx, int ny){
+			x = nx; y = ny; 
+		}
+		@Override
+		public boolean equals(Object o) {
+			Point p = (Point)o;
+			return p.x == x && p.y == y;
+		}
+	}      
+	
+	public static void main(String[] args) throws IOException{
+		BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
+		int n = pint(in);
+		Stack<Integer> min = new Stack<Integer>();
+		Stack<Integer> max = new Stack<Integer>();
+		
+		int[] a = new int[n];
+		int[] dp = new int[n];
+		StringTokenizer st = new StringTokenizer(in.readLine());
+		a[0] = pint(st);
+		min.add(0);
+		max.add(0);
+		for(int i = 1; i < n; i++) {
+			a[i] = pint(st);
+			int h = dp[i - 1] + 1;
+			while(!max.isEmpty() && a[i] > a[max.peek()]) {
+				int k = a[max.peek()];
+				h = Math.min(h, dp[max.pop()] + 1);
+				while(!max.isEmpty() && a[max.peek()] == k) {max.pop();}
+			}
+			if(!max.isEmpty()) {
+				h = Math.min(h, dp[max.peek()] + 1);
+			}
+			while(!min.isEmpty() && a[i] < a[min.peek()]) {
+				int k = a[min.peek()];
+				h = Math.min(h, dp[min.pop()] + 1);
+				while(!min.isEmpty() && a[min.peek()] == k) {min.pop();}
+			}
+			if(!min.isEmpty()) {
+				h = Math.min(h, dp[min.peek()] + 1);
+			}
+			dp[i] = h;
+			min.add(i);
+			max.add(i);
+		}
+		System.out.println(dp[n - 1]);
+	}
+	static int[] resize(int[] a) {
+		int[] r = new int[a.length * 2];
+		for(int i = 0; i < a.length; i++) {
+			r[i] = a[i];
+		}
+		return r;
+	}
+    static int pint(BufferedReader in) throws IOException {return Integer.parseInt(in.readLine());}
+    static int pint(StringTokenizer st) {return Integer.parseInt(st.nextToken());}
+}","    import java.util.*;
+    import java.io.*;
+    public class D{
+        static class InputReader {
+
+            private final InputStream stream;
+            private final byte[] buf = new byte[8192];
+            private int curChar, snumChars;
+            private SpaceCharFilter filter;
+
+            public InputReader(InputStream stream) {
+                this.stream = stream;
+            }
+
+            public int snext() {
+                if (snumChars == -1)
+                    throw new InputMismatchException();
+                if (curChar >= snumChars) {
+                    curChar = 0;
+                    try {
+                        snumChars = stream.read(buf);
+                    } catch (IOException e) {
+                        throw new InputMismatchException();
+                    }
+                    if (snumChars <= 0)
+                        return -1;
+                }
+                return buf[curChar++];
+            }
+
+            public int nextInt() {
+                int c = snext();
+                while (isSpaceChar(c)) {
+                    c = snext();
+                }
+                int sgn = 1;
+                if (c == '-') {
+                    sgn = -1;
+                    c = snext();
+                }
+                int res = 0;
+                do {
+                    if (c < '0' || c > '9')
+                        throw new InputMismatchException();
+                    res *= 10;
+                    res += c - '0';
+                    c = snext();
+                } while (!isSpaceChar(c));
+                return res * sgn;
+            }
+
+            public long nextLong() {
+                int c = snext();
+                while (isSpaceChar(c)) {
+                    c = snext();
+                }
+                int sgn = 1;
+                if (c == '-') {
+                    sgn = -1;
+                    c = snext();
+                }
+                long res = 0;
+                do {
+                    if (c < '0' || c > '9')
+                        throw new InputMismatchException();
+                    res *= 10;
+                    res += c - '0';
+                    c = snext();
+                } while (!isSpaceChar(c));
+                return res * sgn;
+            }
+
+            public int[] nextIntArray(int n) {
+                int a[] = new int[n];
+                for (int i = 0; i < n; i++) {
+                    a[i] = nextInt();
+                }
+                return a;
+            }
+
+            public String readString() {
+                int c = snext();
+                while (isSpaceChar(c)) {
+                    c = snext();
+                }
+                StringBuilder res = new StringBuilder();
+                do {
+                    res.appendCodePoint(c);
+                    c = snext();
+                } while (!isSpaceChar(c));
+                return res.toString();
+            }
+
+            public String nextLine() {
+                int c = snext();
+                while (isSpaceChar(c))
+                    c = snext();
+                StringBuilder res = new StringBuilder();
+                do {
+                    res.appendCodePoint(c);
+                    c = snext();
+                } while (!isEndOfLine(c));
+                return res.toString();
+            }
+
+            public boolean isSpaceChar(int c) {
+                if (filter != null)
+                    return filter.isSpaceChar(c);
+                return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
+            }
+
+            private boolean isEndOfLine(int c) {
+                return c == '\n' || c == '\r' || c == -1;
+            }
+
+            public interface SpaceCharFilter {
+                public boolean isSpaceChar(int ch);
+            }
+
+        }
+        static class OutputWriter {
+            private final PrintWriter writer;
+    
+            public OutputWriter(OutputStream outputStream) {
+                writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
+            }
+    
+            public OutputWriter(Writer writer) {
+                this.writer = new PrintWriter(writer);
+            }
+    
+            public void print(Object...objects) {
+                for (int i = 0; i < objects.length; i++) {
+                    if (i != 0)
+                        writer.print(' ');
+                    writer.print(objects[i]);
+                }
+            }
+    
+            public void printLine(Object...objects) {
+                print(objects);
+                writer.println();
+            }
+    
+            public void close() {
+                writer.close();
+            }
+    
+            public void flush() {
+                writer.flush();
+            }
+    
+            }
+        static int gcd(int a, int b) 
+        { 
+            if (a == 0) 
+                return b; 
+            return gcd(b % a, a); 
+        } 
+        static int mod = (int)(1e9+7);
+        public static long pow(long a,long b)
+        {
+            long ans = 1;
+            while(b> 0)
+            {
+                if((b & 1)==1){
+                    ans = (ans*a) % mod; 
+                }
+                a = (a*a) % mod;
+                b = b>>1;
+            }
+            return ans;
+        }
+
+        public static void main(String[] args) {
+            InputReader in = new InputReader(System.in);
+            OutputWriter out = new OutputWriter(System.out);
+            int n = in.nextInt();
+            int[] arr = in.nextIntArray(n);
+            Stack<Integer> min = new Stack<>();
+            Stack<Integer> max = new Stack<>();
+            int[] dp = new int[n];
+            // Arrays.fill(dp,(int)1e9);
+            dp[0] = 0;
+            min.push(0);
+            max.push(0);
+            for(int i=1;i<n;i++)
+            {
+                int h=dp[i-1]+1;
+                while(!max.isEmpty() && arr[i]>arr[max.peek()])
+                {
+                    int x = arr[max.peek()];
+                    h = Math.min(h,1+dp[max.pop()]);
+                    while(!max.isEmpty() && arr[max.peek()]==x)
+                    {
+                        max.pop();
+                    }
+                }
+                if(!max.isEmpty())
+                {
+                    h = Math.min(h,1+dp[max.peek()]);
+                }
+                while(!min.isEmpty() && arr[i]<arr[min.peek()])
+                {
+                    int x = arr[min.peek()];
+                    h = Math.min(h,1+dp[min.pop()]);
+                    while(!min.isEmpty() && arr[min.peek()]==x)
+                    {
+                        min.pop();
+                    }
+                }
+                if(!min.isEmpty())
+                {
+                    h = Math.min(h,1+dp[min.peek()]);
+                }
+                dp[i] = h;
+                min.push(i);
+                max.push(i);
+            }
+            out.printLine(dp[n-1]);
+            out.flush();
+            out.close();
+        }
+    }",1
+ba8800f5,d8e4eb5e,"import java.io.*;
+import java.util.*;
+import java.text.*;
+import java.math.*;
+
+public class Main {
+
+    public static void main(String[] args) throws IOException{
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        int n = Integer.parseInt(br.readLine());
+        StringTokenizer st = new StringTokenizer(br.readLine());
+        int ar[] = new int[n];
+        for(int i = 0; i < n; i++){
+            ar[i] = Integer.parseInt(st.nextToken());
+        }
+        ArrayList<Integer> ones = new ArrayList<Integer>();
+        ArrayList<Integer> zeroes = new ArrayList<Integer>();
+        for(int i = 0; i < n; i++){
+            if(ar[i] == 1)
+                ones.add(i);
+            else
+                zeroes.add(i);
+        }
+        int r = ones.size();
+        int c = zeroes.size();
+        int time[][] = new int[r][c];
+        System.out.println(calculateTime(time, r, c, 0, 0, ones, zeroes));
+    }
+    public static int calculateTime(int time[][], int r, int c, int currR, int currC, ArrayList<Integer> ones, ArrayList<Integer> zeroes){
+        // System.out.println(currR + "" "" + currC);
+        if(currR == r)
+            return 0;
+        if(currC == c)
+            return (int)1e9;
+        if(time[currR][currC] != 0)
+            return time[currR][currC];
+        return time[currR][currC] = Math.min((calculateTime(time, r, c, currR + 1, currC + 1, ones, zeroes) + Math.abs(ones.get(currR) - zeroes.get(currC))), calculateTime(time, r, c, currR, currC + 1, ones, zeroes));
+    }
+}","import java.io.*;
+import java.util.*;
+
+public class E {
+
+	public static void main(String[] args) throws NumberFormatException, IOException {
+		// TODO Auto-generated method stub
+
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		
+		int n = Integer.parseInt(br.readLine());
+		int cnt = n;
+		boolean[] non = new boolean[n];
+		StringTokenizer st = new StringTokenizer(br.readLine());
+		
+		for(int i = 0; i < n; i++) {
+			
+			if(Integer.parseInt(st.nextToken()) == 0) {
+				non[i] = true;
+				cnt--;
+			}
+			
+		}
+		
+		int x = 0;
+		int y = 0;
+		int[] location = new int[cnt];
+		int[] rlocation = new int[n-cnt];
+		
+		for(int i = 0; i < n; i++) {
+			
+			if(!non[i]) {
+				
+				location[x] = i;
+				x++;
+				
+			}else{
+				
+				rlocation[y] = i;
+				y++;
+				
+			}
+			
+		}
+		
+		int[][] dp = new int[(n-cnt)+1][cnt+1];
+		Arrays.fill(dp[0], 100000000);
+		dp[0][0] = 0;
+		
+		for(int i = 0; i < n-cnt; i++) {
+			
+			//System.out.println(""HIT"");
+			
+			if(i < (n-cnt))
+				Arrays.fill(dp[i+1], 100000000);
+						
+			for(int j = 0; j < cnt; j++) {
+				
+				if(i < (n-cnt)) {
+					dp[i+1][j] = Math.min(dp[i+1][j], dp[i][j]);
+					dp[i+1][j+1] = Math.min(dp[i+1][j+1], dp[i][j] + Math.abs(rlocation[i] - location[j]));			
+					//System.out.println(dp[i+1][j+1] + "" "" + dp[i][j] + "" "" + j + "" "" + rlocation[i] + "" "" + location[j]);
+				}
+				
+			}
+			
+		}
+		
+		int min = Integer.MAX_VALUE;
+		
+		for(int i = 0; i < (n-cnt)+1; i++) {
+			
+			min = Math.min(dp[i][cnt], min);
+			
+		}
+				
+		System.out.println(min);
+		
+	}
+
+}",0
+0e68e463,29cf2e70,"import java.io.*;
+import java.util.*;
+
+import static java.lang.Math.*;
+
+public class D {
+    public static void main(String[] args) {
+        Scanner in = new Scanner(System.in);
+        PrintWriter pw = new PrintWriter(System.out);
+        int t = in.nextInt();
+        for(int tt = 0; tt < t; tt++) {
+            int n = in.nextInt();
+            long[] arr = new long[n];
+            for (int i = 0; i < n; i++) arr[i] = in.nextLong();
+            char[] s = in.next().toCharArray();
+            if (solve(arr, n, s))pw.println(""YES"");
+            else pw.println(""NO"");
+        }
+        pw.close();
+    }
+    static boolean solve(long[] arr, int n, char[] s) {
+        ArrayList<Long> B = new ArrayList<>();
+        ArrayList<Long> R = new ArrayList<>();
+        for(int i = 0; i < n; i++) {
+            if (s[i] == 'B') B.add(arr[i]);
+            else R.add(arr[i]);
+        }
+        Collections.sort(B);
+        Collections.sort(R);
+      //  debug(B);
+        long last = n;
+        for (int i = R.size() - 1; i >= 0; i--) {
+            long v = R.get(i);
+            if (v > last) {
+               return false;
+            }
+            last--;
+        }
+        long first = 1;
+        int size = B.size();
+        for (int i = 0; i < size; i++) {
+            long v = B.get(i);
+         //   debug(v, first);
+            if (v < first) return false;
+            first++;
+        }
+        return true;
+    }
+
+
+    static void debug(Object... obj) {
+        System.err.println(Arrays.deepToString(obj));
+    }
+}
+","import java.util.*;
+import java.io.*;
+ 
+public class D {
+    public static void main(String[] args) {
+        Scanner in = new Scanner(System.in);
+        
+        int T = in.nextInt();
+        while(T-- > 0) {
+            int n = in.nextInt();
+            int[] a = new int[n];
+            for(int j=0;j<n;j++) a[j] = in.nextInt();
+            char[] s = in.next().toCharArray();
+ 
+            List<Integer> blue = new ArrayList<>();
+            List<Integer> red = new ArrayList<>();
+            for(int j=0;j<n;j++) {
+                if(s[j] == 'B') blue.add(a[j]);
+                else red.add(a[j]);
+            }
+ 
+            Collections.sort(blue);
+            Collections.sort(red);
+ 
+            boolean p = true;
+            int cur = 1;
+            for(int val : blue) {
+                if(val<cur) {
+                    p = false;
+                    break;
+                }
+                else cur++;
+            }
+            for(int val : red) {
+                if(val>cur) {
+                    p = false;
+                    break;
+                }
+                else cur++;
+            }
+            
+            if(p) System.out.println(""yes"");
+            else System.out.println(""no"");
+        }
+    }
+}
+",0
+0951d079,0ecf356d,"import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.Stack;
+import java.util.StringTokenizer;
+
+public class D {
+
+	public static void main(String[] args) throws NumberFormatException, IOException {
+		BufferedReader file = new BufferedReader(new InputStreamReader(System.in));
+		int n = Integer.parseInt(file.readLine());
+		int[] heights = new int[n];
+		StringTokenizer st = new StringTokenizer(file.readLine());
+		for(int i = 0; i < n; i++) {
+			heights[i] = Integer.parseInt(st.nextToken());
+		}
+		int[] dp = new int[n];
+		dp[0] = 0;
+		Stack<Integer> high = new Stack<>();
+		Stack<Integer> low = new Stack<>();
+		high.push(0);
+		low.push(0);
+		for(int i = 1; i < n; i++) {
+			dp[i] = dp[i-1]+1;
+			while(!high.isEmpty() && heights[high.peek()] < heights[i]) {
+				dp[i] = Math.min(dp[i], dp[high.peek()]+1);
+				high.pop();
+			}
+			if(!high.isEmpty()) {
+				dp[i] = Math.min(dp[i], dp[high.peek()]+1);
+				if(heights[high.peek()] == heights[i])
+					high.pop();
+			}
+			while(!low.isEmpty() && heights[low.peek()] > heights[i]) {
+				dp[i] = Math.min(dp[i], dp[low.peek()]+1);
+				low.pop();
+			}
+			if(!low.isEmpty()) {
+				dp[i] = Math.min(dp[i], dp[low.peek()]+1);
+				if(heights[low.peek()] == heights[i])
+					low.pop();
+			}
+			high.push(i);
+			low.push(i);
+		}
+		System.out.println(dp[n-1]);
+	}
+
+}
+","import java.io.*;
+import java.util.*;
+
+public class Main {
+
+    public static void main(String[] args) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        int n = Integer.parseInt(br.readLine());
+        StringTokenizer st = new StringTokenizer(br.readLine());
+        int[] h = new int[n];
+        int[] dp = new int[n];
+        for(int i = 0; i<n; i++){
+            h[i] = Integer.parseInt(st.nextToken());
+        }
+        Stack<Integer> hi = new Stack<>();
+        Stack<Integer> lo = new Stack<>();
+        hi.push(0);
+        lo.push(0);
+        for(int i = 1; i<n; i++){
+            dp[i] = dp[i-1]+1;
+            while(!hi.isEmpty() && h[hi.peek()]<h[i]){
+                dp[i] = Math.min(dp[i], dp[hi.peek()]+1);
+                hi.pop();
+            }
+            if(!hi.isEmpty()){
+                dp[i] = Math.min(dp[i], dp[hi.peek()]+1);
+                if(h[i] == h[hi.peek()]) hi.pop();
+            }
+            while(!lo.isEmpty() && h[lo.peek()]>h[i]){
+                dp[i] = Math.min(dp[i], dp[lo.peek()]+1);
+                lo.pop();
+            }
+            if(!lo.isEmpty()){
+                dp[i] = Math.min(dp[i], dp[lo.peek()]+1);
+                if(h[i] == h[lo.peek()]) lo.pop();
+            }
+            hi.push(i);
+            lo.push(i);
+        }
+        System.out.println(dp[n-1]);
+    }
+}
+",1
+ad4c7a20,f8e7b886,"import java.io.*;
+import java.util.*;
+
+
+public class Practice
+{
+//	static final long mod=7420738134811L;
+	static int mod=1000000007;
+	static final int size=501;
+	static FastReader sc=new FastReader(System.in);
+//	static Reader sc=new Reader();
+//	static Scanner sc=new Scanner(System.in);
+	static  PrintWriter out=new PrintWriter(System.out);
+	static long[] factorialNumInverse;
+	static long[] naturalNumInverse;	
+	static int[] sp;
+	static long[] fact;
+	static ArrayList<Integer> pr;
+	public static void main(String[] args) throws IOException, CloneNotSupportedException
+	{
+//		System.setIn(new FileInputStream(""input.txt""));
+//		System.setOut(new PrintStream(""output.txt""));
+//		factorial(mod);
+//		InverseofNumber(mod);
+//		InverseofFactorial(mod);
+//		make_seive();
+		int t=1;
+		t=sc.nextInt();
+		for(int i=1;i<=t;i++)
+			solve(i);
+		out.close();
+		out.flush();
+//		System.out.flush();
+//		System.exit(0);
+	}
+	
+	static void solve(int CASENO) throws IOException, CloneNotSupportedException
+	{
+		int n=sc.nextInt();
+		int k[]=new int[n];
+		int h[]=new int[n];
+		for(int i=0;i<n;i++)
+			k[i]=sc.nextInt();
+		for(int i=0;i<n;i++)
+			h[i]=sc.nextInt();
+		ArrayList<Pair> interval=new ArrayList<Pair>();
+		ArrayList<Pair> act=new ArrayList<Pair>();
+		for(int i=0;i<n;i++)
+			interval.add(new Pair(k[i]-h[i]+1,k[i]));
+		Collections.sort(interval);
+//		out.println(interval);
+		act.add(interval.get(0).clone());
+		for(int i=1;i<n;i++)
+		{
+			Pair p=act.get(act.size()-1);
+			if(p.y<interval.get(i).x)
+				act.add(interval.get(i).clone());
+			else
+				p.y=Math.max(p.y, interval.get(i).y);
+		}
+//		out.println(act);
+		long mana=0;
+		for(Pair p: act)
+		{
+			long x=p.y-p.x+1;
+			mana+=(x*(x+1))/2;
+		}
+		out.println(mana);
+	}
+	static class Pair implements Cloneable, Comparable<Pair>
+	{
+		int x,y;
+		Pair(int a,int b)
+		{
+			this.x=a;
+			this.y=b;
+		}
+		@Override
+		public boolean equals(Object obj) 
+		{
+			if(obj instanceof  Pair)
+			{
+				Pair p=(Pair)obj;
+				return p.x==this.x && p.y==this.y;
+			}
+			return false;
+		}
+		@Override
+		public int hashCode() 
+		{
+			return Math.abs(x)+500*Math.abs(y);
+		}
+		@Override
+		public String toString() 
+		{
+			return ""(""+x+"" ""+y+"")"";
+		}
+		@Override
+		protected Pair clone() throws CloneNotSupportedException {
+			return new Pair(this.x,this.y);
+		}
+		@Override
+		public int compareTo(Pair a) 
+		{
+			long t=(this.x-a.x);
+			if(t!=0)
+				return t>0?1:-1;
+			else
+				return (int)(this.y-a.y);
+		}
+		public void swap()
+		{
+			this.y=this.y+this.x;
+			this.x=this.y-this.x;
+			this.y=this.y-this.x;			
+		}
+	}
+	static class Tuple implements Cloneable, Comparable<Tuple>
+	{
+		int x,y,z;
+		Tuple(int a,int b,int c)
+		{
+			this.x=a;
+			this.y=b;
+			this.z=c;
+		}
+		public boolean equals(Object obj) 
+		{
+			if(obj instanceof  Tuple)
+			{
+				Tuple p=(Tuple)obj;
+				return p.x==this.x && p.y==this.y && p.z==this.z;
+			}
+			return false;
+		}
+		@Override
+		public int hashCode() 
+		{
+			return (this.x+501*this.y);
+		}
+		@Override
+		public String toString() 
+		{
+			return ""(""+x+"",""+y+"",""+z+"")"";
+		}
+		@Override
+		protected Tuple clone() throws CloneNotSupportedException {
+			return new Tuple(this.x,this.y,this.z);
+		}
+		@Override
+		public int compareTo(Tuple a) 
+		{
+			int x=this.z-a.z;
+			if(x!=0)
+				return x;
+			int X= this.x-a.x;
+			if(X!=0)
+				return X;
+			return a.y-this.y;
+		}
+	}
+	static void arraySort(int arr[])
+	{
+		ArrayList<Integer> a=new ArrayList<Integer>();
+		for (int i = 0; i < arr.length; i++) {
+			a.add(arr[i]);
+		}
+		Collections.sort(a,Comparator.reverseOrder());
+		for (int i = 0; i < arr.length; i++) {
+			arr[i]=a.get(i);
+		}
+	}
+	static void arraySort(long arr[])
+	{
+		ArrayList<Long> a=new ArrayList<Long>();
+		for (int i = 0; i < arr.length; i++) {
+			a.add(arr[i]);
+		}
+		Collections.sort(a);
+		for (int i = 0; i < arr.length; i++) {
+			arr[i]=a.get(i);
+		}
+	}
+	static HashSet<Integer> primeFactors(int n)
+	{
+		HashSet<Integer> ans=new HashSet<Integer>();
+		if(n%2==0)
+		{
+			ans.add(2);
+			while((n&1)==0)
+				n=n>>1;
+		}
+		for(int i=3;i*i<=n;i+=2)
+		{
+			if(n%i==0)
+			{
+				ans.add(i);
+				while(n%i==0)
+					n=n/i;
+			}
+		}
+		if(n!=1)
+			ans.add(n);
+		return ans;
+	}
+	static void make_seive()
+	{
+		sp=new int[size];
+		pr=new ArrayList<Integer>();
+		for (int i=2; i<size; ++i) {
+		    if (sp[i] == 0) {
+		        sp[i] = i;
+		        pr.add(i);
+		    }
+		    for (int j=0; j<(int)pr.size() && pr.get(j)<=sp[i] && i*pr.get(j)<size; ++j)
+		        sp[i * pr.get(j)] = pr.get(j);
+		}
+	}
+	public static void InverseofNumber(int p)
+	{
+		naturalNumInverse=new long[size];
+	    naturalNumInverse[0] = naturalNumInverse[1] = 1;
+	    for(int i = 2; i < size; i++)
+	        naturalNumInverse[i] = naturalNumInverse[p % i] * (long)(p - p / i) % p;
+	}
+	// Function to precompute inverse of factorials
+	public static void InverseofFactorial(int p)
+	{
+		factorialNumInverse=new long[size];
+	    factorialNumInverse[0] = factorialNumInverse[1] = 1;
+	    // pre-compute inverse of natural numbers
+	    for(int i = 2; i < size; i++)
+	        factorialNumInverse[i] = (naturalNumInverse[i] * factorialNumInverse[i - 1]) % p;
+	}
+	// Function to calculate factorial of 1 to 200001
+	public static void factorial(int p)
+	{
+		fact=new long[size];
+	    fact[0] = 1;
+	    for(int i = 1; i < size; i++)
+	        fact[i] = (fact[i - 1] * (long)i) % p;
+	}
+	 
+	// Function to return nCr % p in O(1) time
+	public static long Binomial(int N, int R)
+	{
+		if(R<0)
+			return 1;
+	    // n C r = n!*inverse(r!)*inverse((n-r)!)
+	    long ans = ((fact[N] * factorialNumInverse[R]) % mod * factorialNumInverse[N - R]) % mod;
+	    return ans;
+	}
+	static int findXOR(int x)	//from 0 to x
+	{
+		if(x<0)
+			return 0;
+		if(x%4==0)
+			return x;
+		if(x%4==1)
+			return 1;
+		if(x%4==2)
+			return x+1;
+		return 0;
+	}
+	static boolean isPrime(long x)
+	{
+		if(x==1)
+			return false;
+		if(x<=3)
+			return true;
+		if(x%2==0 || x%3==0)
+			return false;
+		for(int i=5;i<=Math.sqrt(x);i+=2)
+			if(x%i==0)
+				return false;
+		return true;
+	}
+	static long gcd(long a,long b)
+	{
+		return (b==0)?a:gcd(b,a%b);
+	}
+	static int gcd(int a,int b)
+	{
+		return (b==0)?a:gcd(b,a%b);
+	}
+	static class Node
+	{
+		int vertex,dis;
+		HashSet<Node> adj;
+		Node(int ver)
+		{
+			vertex=ver;
+			dis=-1;
+			adj=new HashSet<Node>();
+		}
+		@Override
+		public String toString() 
+		{
+			return vertex+"" "";
+		}
+	}
+	static class Edge
+	{
+		Node to;
+		int cost;
+		Edge(Node t,int c)
+		{
+			this.to=t;
+			this.cost=c;
+		}
+		@Override
+		public String toString() {
+			return ""(""+to.vertex+"",""+cost+"") "";
+		}
+	}
+	static long power(long x, long y)
+	  {
+		if(x<=0)
+			return 1;
+	    long res = 1; 
+	    x = x % mod; 
+	    if (x == 0)
+	      return 0; 
+	    while (y > 0)
+	    {
+	    	if ((y & 1) != 0)
+	    		res = (res * x) % mod;
+	    	
+	    	y = y >> 1; // y = y/2
+	    	x = (x * x) % mod;
+	    }
+	    return res%mod;
+	  }
+	static long binomialCoeff(long n, long k)
+    {
+		if(n<k)
+			return 0;
+        long res = 1;
+        // Since C(n, k) = C(n, n-k)
+        if (k > n - k)
+            k = n - k;
+ 
+        // Calculate value of
+        // [n * (n-1) *---* (n-k+1)] / [k * (k-1) *----* 1]
+        for (long i = 0; i < k; ++i) {
+            res *= (n - i);
+            res /= (i + 1);
+        }
+ 
+        return res;
+    }
+	static class FastReader
+	{
+        byte[] buf = new byte[2048];
+        int index, total;
+        InputStream in;
+ 
+        FastReader(InputStream is) 
+        {
+            in = is;
+        }
+ 
+        int scan() throws IOException 
+        {
+            if (index >= total) {
+                index = 0;
+                total = in.read(buf);
+                if (total <= 0) {
+                    return -1;
+                }
+            }
+            return buf[index++];
+        }
+ 
+        String next() throws IOException 
+        {
+            int c;
+            for (c = scan(); c <= 32; c = scan());
+            StringBuilder sb = new StringBuilder();
+            for (; c > 32; c = scan()) {
+                sb.append((char) c);
+            }
+            return sb.toString();
+        }
+ 
+        int nextInt() throws IOException 
+        {
+            int c, val = 0;
+            for (c = scan(); c <= 32; c = scan());
+            boolean neg = c == '-';
+            if (c == '-' || c == '+') {
+                c = scan();
+            }
+            for (; c >= '0' && c <= '9'; c = scan()) {
+                val = (val << 3) + (val << 1) + (c & 15);
+            }
+            return neg ? -val : val;
+        }
+ 
+        long nextLong() throws IOException 
+        {
+            int c;
+            long val = 0;
+            for (c = scan(); c <= 32; c = scan());
+            boolean neg = c == '-';
+            if (c == '-' || c == '+') {
+                c = scan();
+            }
+            for (; c >= '0' && c <= '9'; c = scan()) {
+                val = (val << 3) + (val << 1) + (c & 15);
+            }
+            return neg ? -val : val;
+        }
+    }
+	static class Reader 
+	{
+        final private int BUFFER_SIZE = 1 << 16;
+        private DataInputStream din;
+        private byte[] buffer;
+        private int bufferPointer, bytesRead;
+ 
+        public Reader()
+        {
+            din = new DataInputStream(System.in);
+            buffer = new byte[BUFFER_SIZE];
+            bufferPointer = bytesRead = 0;
+        }
+ 
+        public Reader(String file_name) throws IOException
+        {
+            din = new DataInputStream(
+                new FileInputStream(file_name));
+            buffer = new byte[BUFFER_SIZE];
+            bufferPointer = bytesRead = 0;
+        }
+ 
+        public String readLine() throws IOException
+        {
+            byte[] buf = new byte[64]; // line length
+            int cnt = 0, c;
+            while ((c = read()) != -1) {
+                if (c == '\n') {
+                    if (cnt != 0) {
+                        break;
+                    }
+                    else {
+                        continue;
+                    }
+                }
+                buf[cnt++] = (byte)c;
+            }
+            return new String(buf, 0, cnt);
+        }
+ 
+        public int nextInt() throws IOException
+        {
+            int ret = 0;
+            byte c = read();
+            while (c <= ' ') {
+                c = read();
+            }
+            boolean neg = (c == '-');
+            if (neg)
+                c = read();
+            do {
+                ret = ret * 10 + c - '0';
+            } while ((c = read()) >= '0' && c <= '9');
+ 
+            if (neg)
+                return -ret;
+            return ret;
+        }
+ 
+        public long nextLong() throws IOException
+        {
+            long ret = 0;
+            byte c = read();
+            while (c <= ' ')
+                c = read();
+            boolean neg = (c == '-');
+            if (neg)
+                c = read();
+            do {
+                ret = ret * 10 + c - '0';
+            } while ((c = read()) >= '0' && c <= '9');
+            if (neg)
+                return -ret;
+            return ret;
+        }
+ 
+        public double nextDouble() throws IOException
+        {
+            double ret = 0, div = 1;
+            byte c = read();
+            while (c <= ' ')
+                c = read();
+            boolean neg = (c == '-');
+            if (neg)
+                c = read();
+ 
+            do {
+                ret = ret * 10 + c - '0';
+            } while ((c = read()) >= '0' && c <= '9');
+ 
+            if (c == '.') {
+                while ((c = read()) >= '0' && c <= '9') {
+                    ret += (c - '0') / (div *= 10);
+                }
+            }
+ 
+            if (neg)
+                return -ret;
+            return ret;
+        }
+ 
+        private void fillBuffer() throws IOException
+        {
+            bytesRead = din.read(buffer, bufferPointer = 0,
+                                 BUFFER_SIZE);
+            if (bytesRead == -1)
+                buffer[0] = -1;
+        }
+ 
+        private byte read() throws IOException
+        {
+            if (bufferPointer == bytesRead)
+                fillBuffer();
+            return buffer[bufferPointer++];
+        }
+ 
+        public void close() throws IOException
+        {
+            if (din == null)
+                return;
+            din.close();
+        }
+        public void printarray(int arr[])
+        {
+        	for (int i = 0; i < arr.length; i++)
+				System.out.print(arr[i]+"" "");
+        	System.out.println();
+        }
+    }
+}
+
+
+
+
+
+
+
+","import java.util.*;
+import java.io.*;
+import java.time.*;
+import static java.lang.Math.*;
+
+@SuppressWarnings(""unused"")
+public class C {
+	static boolean DEBUG = false;
+
+	static Reader fs;
+	static PrintWriter pw;
+
+	static void solve() {
+		int n = fs.nextInt(), k[] = fs.readArray(n), h[] = fs.readArray(n);
+		int prev_h = h[0], prev_k = k[0];
+//		int ans = 0;
+		ArrayList<pair> intervals = new ArrayList<>();
+		for (int i = 0; i < n; i++) {
+			int start = k[i] - h[i] + 1;
+			int end = k[i];
+			intervals.add(new pair(start, end));
+		}
+//		pw.println(intervals);
+		Collections.sort(intervals);
+		ArrayList<pair> merged = new ArrayList<>();
+		merge(intervals, merged);
+		long ans = 0;
+		for(int i = 0 ; i < merged.size() ; i++) {
+			ans += sum(merged.get(i).len());
+		}
+		pw.println(ans);
+	}
+	
+	static void merge(ArrayList<pair>a1, ArrayList<pair>a2) {
+		int n = a1.size();
+		int index = 0;
+		for(int i =1 ; i < n ; i++) {
+			if(a1.get(index).s >= a1.get(i).f) {
+				a1.get(index).s = max(a1.get(index).s, a1.get(i).s);
+			}
+			else {
+				index++;
+				a1.set(index, a1.get(i));
+			}
+		}
+		for(int i = 0 ; i <= index ; i++) {
+			a2.add(a1.get(i));
+		}
+//		pw.println(a1);
+	}
+	
+//	int index = 0; // Stores index of last element 
+//    // in output array (modified arr[]) 
+//
+//    // Traverse all input Intervals 
+//    for (int i=1; i<arr.length; i++) 
+//    { 
+//        // If this is not first Interval and overlaps 
+//        // with the previous one 
+//        if (arr[index].end >=  arr[i].start) 
+//        { 
+//               // Merge previous and current Intervals 
+//            arr[index].end = Math.max(arr[index].end, arr[i].end); 
+//        } 
+//        else {
+//            index++;
+//            arr[index] = arr[i]; 
+//        }    
+//    }
+	
+	static boolean overlapping(pair p1, pair p2) {
+		if((p2.f >= p1.f && p1.s >= p2.f) || (p2.s >= p1.f && p1.s >= p2.s)) {
+			return true;
+		}
+		return false;
+	}
+	
+	static pair merge(pair p1, pair p2) {
+		return new pair(min(p1.f, p2.f), max(p1.s, p2.s));
+	}
+
+	static long sum(long n) {
+		return (n * (n + 1) / 2);
+	}
+
+	static class pair implements Comparable<pair>{
+		int f, s;
+
+		pair(int f, int s) {
+			this.f = f;
+			this.s = s;
+		}
+
+		public String toString() {
+			StringBuilder sb = new StringBuilder();
+			sb.append(""{"" + f + "","" + s + ""}"");
+			return sb.toString();
+		}
+		
+		@Override
+		public int compareTo(pair o) {
+			return f - o.f;
+		}
+		
+		public int len() {
+			return s - f + 1;
+		}
+	}
+
+	public static void main(String[] args) throws IOException {
+		Instant start = Instant.now();
+		if (args.length == 2) {
+			System.setIn(new FileInputStream(new File(""D:\\program\\javaCPEclipse\\CodeForces\\src\\input.txt"")));
+			// System.setOut(new PrintStream(new File(""output.txt"")));
+			System.setErr(new PrintStream(new File(""D:\\program\\javaCPEclipse\\CodeForces\\src\\error.txt"")));
+			DEBUG = true;
+		}
+		fs = new Reader();
+		pw = new PrintWriter(System.out);
+		int t = fs.nextInt();
+		while (t-- > 0) {
+			solve();
+		}
+		Instant end = Instant.now();
+		if (DEBUG) {
+			pw.println(Duration.between(start, end));
+		}
+		pw.close();
+	}
+
+	static void sort(int a[]) {
+		ArrayList<Integer> l = new ArrayList<Integer>();
+		for (int x : a)
+			l.add(x);
+		Collections.sort(l);
+		for (int i = 0; i < a.length; i++) {
+			a[i] = l.get(i);
+		}
+	}
+
+	public static void print(long a, long b, long c, PrintWriter pw) {
+		pw.println(a + "" "" + b + "" "" + c);
+		return;
+	}
+
+	static class Reader {
+		BufferedReader br;
+		StringTokenizer st;
+
+		public Reader() {
+			br = new BufferedReader(new InputStreamReader(System.in));
+		}
+
+		String next() {
+			while (st == null || !st.hasMoreElements()) {
+				try {
+					st = new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			}
+			return st.nextToken();
+		}
+
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+
+		double nextDouble() {
+			return Double.parseDouble(next());
+		}
+
+		String nextLine() {
+			String str = """";
+			try {
+				str = br.readLine();
+			} catch (IOException e) {
+				e.printStackTrace();
+			}
+			return str;
+		}
+
+		int[] readArray(int n) {
+			int a[] = new int[n];
+			for (int i = 0; i < n; i++)
+				a[i] = nextInt();
+			return a;
+		}
+
+		int[][] read2Array(int n, int m) {
+			int a[][] = new int[n][m];
+			for (int i = 0; i < n; i++) {
+				for (int j = 0; j < m; j++) {
+					a[i][j] = nextInt();
+				}
+			}
+			return a;
+		}
+	}
+}",0
+05ca89ed,163d0dde,"
+
+import java.io.BufferedReader; 
+import java.io.IOException; 
+import java.io.InputStreamReader; 
+import java.util.Scanner; 
+import java.util.StringTokenizer; 
+import java.util.*;
+  
+public class er106c
+{ 
+    //By shwetank_verma
+	public static void main(String[] args) 
+    { 
+        FastReader sc=new FastReader(); 
+        try{
+           
+                int t=1;
+                t=sc.nextInt();
+                while(t-->0){
+                int n=sc.nextInt();
+                long o=n,e=n;
+                long maxo=Integer.MAX_VALUE;
+                long maxe=Integer.MAX_VALUE;
+                long ans=Long.MAX_VALUE;
+                long temp=0;
+                
+                int a[]=new int[n];
+                for(int i=0;i<n;i++){
+                    a[i]=sc.nextInt();
+                }
+                for(int i=0;i<n;i++) {
+                	if(i%2==1) {
+                		temp+=a[i];
+                		e--;
+                		maxe=Long.min(maxe, a[i]);
+                		ans=Long.min(ans,temp+(o*maxo)+(e*maxe));
+                	}
+                	else {
+                		temp+=a[i];
+                		o--;
+                		maxo=Long.min(maxo, a[i]);
+                		ans=Long.min(ans,temp+(o*maxo)+(e*maxe));
+                	}
+                }
+                System.out.println(ans);
+                
+                
+        
+                }
+           
+            
+        }catch(Exception e){
+            return;
+        }
+    }
+    static class FastReader 
+    { 
+        BufferedReader br; 
+        StringTokenizer st; 
+  
+        public FastReader() 
+        { 
+            br = new BufferedReader(new
+                     InputStreamReader(System.in)); 
+        } 
+  
+        String next() 
+        { 
+            while (st == null || !st.hasMoreElements()) 
+            { 
+                try
+                { 
+                    st = new StringTokenizer(br.readLine()); 
+                } 
+                catch (IOException  e) 
+                { 
+                    e.printStackTrace(); 
+                } 
+            } 
+            return st.nextToken(); 
+        } 
+  
+        int nextInt() 
+        { 
+            return Integer.parseInt(next()); 
+        } 
+  
+        long nextLong() 
+        { 
+            return Long.parseLong(next()); 
+        } 
+  
+        double nextDouble() 
+        { 
+            return Double.parseDouble(next()); 
+        } 
+  
+        String nextLine() 
+        { 
+            String str = """"; 
+            try
+            { 
+                str = br.readLine(); 
+            } 
+            catch (IOException e) 
+            { 
+                e.printStackTrace(); 
+            } 
+            return str; 
+        } 
+    } 
+    static int mod=1000000007;
+    static boolean primes[]=new boolean[1000007];
+    static ArrayList<Integer> b=new ArrayList<>();
+    static boolean seive(int n){
+        Arrays.fill(primes,true);
+        primes[0]=primes[1]=false;
+        for(int i=2;i*i<=n;i++){
+            if(primes[i]==true){
+                for(int p=i*i;p<=n;p+=i){
+                    primes[p]=false;
+                }
+            }
+        }
+        if(n<1000007){
+        	for(int i=2;i<=n;i++) {
+        		if(primes[i])
+        			b.add(i);
+        	}
+            return primes[n];
+        }
+        return false;
+        
+    }
+    static int gcd(int a,int b){
+        if(b==0)
+        return a;
+        return gcd(b,a%b);
+    }
+    static long GCD(long a,long b){
+        if(b==0)
+        return a;
+        return GCD(b,a%b);
+    }
+    static ArrayList<Integer> segseive(int l,int r){
+    	
+    	ArrayList<Integer> isprime=new ArrayList<Integer>();
+    	boolean p[]=new boolean[r-l+1];
+    	Arrays.fill(p, true);
+        
+    	for(int i=0;b.get(i)*b.get(i)<=r;i++) {
+    		int currprime=b.get(i);
+    		int base=(l/currprime)*currprime;
+    		if(base<l) {
+    			base+=currprime;
+    		}
+    		for(int j=base;j<=r;j+=currprime) {
+    			p[j-l]=false;
+    		}
+    		
+    		
+    		if(base==currprime) {
+    			p[base-l]=true;
+    		}
+    		
+    	}
+    	for(int i=0;i<=r-l;i++) {
+    		if(p[i])
+    			isprime.add(i+l);
+    	}
+    	return isprime;
+    }
+      static int LowerBound(int a[], int x) { // x is the target value or key
+  int l=-1,r=a.length;
+  while(l+1<r) {
+    int m=(l+r)>>>1;
+    if(a[m]>=x) r=m;
+    else l=m;
+  }
+  return r;
+}
+static int UpperBound(int a[], int x) {// x is the key or target value
+    int l=-1,r=a.length;
+    while(l+1<r) {
+       int m=(l+r)>>>1;
+       if(a[m]<=x) l=m;
+       else r=m;
+    }
+    return l+1;
+ }
+
+  
+     
+}","// Working program with FastReader 
+import java.io.BufferedReader; 
+import java.io.IOException; 
+import java.io.InputStreamReader; 
+import java.util.*;
+  
+public class aa
+{ 
+    static class FastReader 
+    { 
+        BufferedReader br; 
+        StringTokenizer st; 
+  
+        public FastReader() 
+        { 
+            br = new BufferedReader(new
+                     InputStreamReader(System.in)); 
+        } 
+  
+        String next() 
+        { 
+            while (st == null || !st.hasMoreElements()) 
+            { 
+                try
+                { 
+                    st = new StringTokenizer(br.readLine()); 
+                } 
+                catch (IOException  e) 
+                { 
+                    e.printStackTrace(); 
+                } 
+            } 
+            return st.nextToken(); 
+        } 
+  
+        int nextInt() 
+        { 
+            return Integer.parseInt(next()); 
+        } 
+  
+        long nextLong() 
+        { 
+            return Long.parseLong(next()); 
+        } 
+  
+        double nextDouble() 
+        { 
+            return Double.parseDouble(next()); 
+        } 
+  
+        String nextLine() 
+        { 
+            String str = """"; 
+            try
+            { 
+                str = br.readLine(); 
+            } 
+            catch (IOException e) 
+            { 
+                e.printStackTrace(); 
+            } 
+            return str; 
+        } 
+    } 
+   public static int findIndex(long arr[], long t) 
+    { 
+  
+        // if array is Null 
+        if (arr == null) { 
+            return -1; 
+        } 
+  
+        // find length of array 
+        int len = arr.length; 
+        int i = 0; 
+  
+        // traverse in the array 
+        while (i < len) { 
+  
+            // if the i-th element is t 
+            // then return the index 
+            if (arr[i] == t) { 
+                return i; 
+            } 
+            else { 
+                i = i + 1; 
+            } 
+        }
+        return -1;
+    }
+    public static void main(String[] args) 
+    {
+            FastReader d=new FastReader();
+            int t,i,j,c,z,k,l,n;
+            int mod = (int) 1e9 + 7;
+            int Inf=Integer.MAX_VALUE;
+            int negInf=Integer.MIN_VALUE;
+        t=d.nextInt();
+        //t=1;
+        //String s;
+        //char ch,ch1,ch2,ch3;
+        while(t-->0)
+        {
+            z=c=0;
+            n=d.nextInt();
+            int a[]=new int[n];
+            for(i=0;i<n;i++)
+            a[i]=d.nextInt();
+            //s=d.nextLine();//dont need extra d.nextLine()
+            long p=0;
+            long ans;
+            long x,y;
+            long e,o;
+            ans=Long.MAX_VALUE;
+            x=y=Integer.MAX_VALUE;
+            e=o=n;
+            for(i=0;i<n;i++) {
+                if(i%2==1) {
+               	p+=a[i];
+               	e--;
+               	x=Long.min(x, a[i]);
+               	ans=Long.min(ans,p+(o*y)+(e*x));
+               	}
+               	else {
+               	p+=a[i];
+               	o--;
+               	y=Long.min(y, a[i]);
+               	ans=Long.min(ans,p+(o*y)+(e*x));
+                	}
+                }
+                System.out.println(ans);
+        }
+    } 
+} ",1
+1a6f8b20,f6ed6826,"
+
+import java.io.*;
+import java.util.*;
+public class Main
+{
+	public static void main(String[] args)throws Exception
+	{
+	    Main ob=new Main();
+	    ob.fun();
+	}
+	public void fun()throws Exception
+	{
+	    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+	    PrintWriter pw=new PrintWriter(System.out);
+	    int t=Integer.parseInt(br.readLine());
+	    while(t-->0)
+	    {
+	        int n=Integer.parseInt(br.readLine());
+	        int ar[][]=new int [n][5];
+	        int len[]=new int[n];
+	        for(int i=0;i<n;i++)
+	        {
+	            String s=(br.readLine());
+	            for(int j=0;j<s.length();j++)
+	            {
+	                ar[i][s.charAt(j)-'a']++;
+	                len[i]=s.length();
+	            }
+	        }
+	        int max=0;
+	        for(int i=0;i<5;i++)
+	        {
+	            int num=fun2(ar,len,i);
+	            max=Math.max(num,max);
+	        }
+	        pw.println(max);
+	        
+	    }
+	    pw.flush();
+	}
+	public int fun2(int ar[][],int len[],int col)
+	{
+	    int ct=0;
+	    int n=ar.length;
+	    PriorityQueue<Integer> pq=new PriorityQueue<Integer>(Collections.reverseOrder());
+	    for(int i=0;i<n;i++)
+	    {
+	        int dif=2*ar[i][col]-len[i];
+	        pq.add(dif);
+	    }
+	    int sum=0;
+	    while(pq.size()>0)
+	    {
+	        int num=(int)(pq.poll());
+	        if((sum+num)>0)
+	        {
+	            ct++;
+	            sum+=num;
+	        }
+	    }
+	    return ct;
+	}
+}
+","
+import java.util.*;
+
+
+import java.io.*;
+ public class Solution {
+		static FastScanner scr=new FastScanner();
+//		static Scanner scr=new Scanner(System.in);
+		static PrintStream out=new PrintStream(System.out);
+		static StringBuilder sb=new StringBuilder();
+		
+		
+		
+		
+		static class pair{
+			int x;int y;
+			pair(int x,int y){ 
+				this.x=x;this.y=y;
+				
+			}
+		}
+		static class triplet{
+			int x;
+			long y;
+			int z;
+			triplet(int x,long y,int z){
+				this.x=x;
+				this.y=y;
+				this.z=z;
+			}
+		}
+		static class FastScanner {
+			 BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+			StringTokenizer st=new StringTokenizer("""");
+		 	String next() {
+		 		while (!st.hasMoreTokens())
+		 			try {
+		 				st=new StringTokenizer(br.readLine());
+		 			} catch (IOException e) {
+		 				e.printStackTrace();
+		 			}
+		 			return st.nextToken();
+			} long gcd(long a,long b){
+				if(b==0) {
+					return a;
+				}
+					
+				return gcd(b,a%b);
+			}
+		 	int[]  sort(int a[]) {
+				 
+		        int multiplier = 1, len = a.length, max = Integer.MIN_VALUE;
+		        int b[] = new int[len];
+		        int bucket[];
+		        for (int i = 0; i < len; i++) if (max < a[i]) max = a[i];
+		        while (max / multiplier > 0) {
+		            bucket = new int[10];
+		            for (int i = 0; i < len; i++) bucket[(a[i] / multiplier) % 10]++;
+		            for (int i = 1; i < 10; i++) bucket[i] += (bucket[i - 1]);
+		            for (int i = len - 1; i >= 0; i--) b[--bucket[(a[i] / multiplier) % 10]] = a[i];
+		            for (int i = 0; i < len; i++) a[i] = b[i];
+		            multiplier *= 10;
+		        }
+		        return a;
+		    }
+		 	 long modPow(long base,long exp) {
+				if(exp==0) {
+					return 1;
+				}
+				if(exp%2==0) {
+					long res=(modPow(base,exp/2));
+					return (res*res);
+				}
+				return (base*modPow(base,exp-1));
+			}
+			int []reverse(int a[]){
+				int b[]=new int[a.length];
+				int index=0;
+				for(int i=a.length-1;i>=0;i--) {
+					b[index]=a[i];
+				}
+				return b;
+			}
+			int nextInt() {
+				return Integer.parseInt(next());
+			}
+			int[] readArray(int n) {
+				int[] a=new int[n];
+				for (int i=0; i<n; i++) a[i]=nextInt();
+				return a;
+			}
+			long[] readLongArray(int n) {
+				long  [] a=new long  [n];
+				for (int i=0; i<n; i++) a[i]=nextLong();
+				return a;
+			}
+			long nextLong() {
+				return Long.parseLong(next());
+			}
+		}
+		
+		static HashMap<Character,ArrayList<Integer>>hm=new HashMap<>();
+		static void solve() {
+			int n=scr.nextInt();
+			
+			int count[]=new int[5];
+			int store[][]=new int[n][5];
+			int max=MIN;
+			int length[]=new int[n];
+			for(int i=0;i<n;i++) {
+				String s=scr.next();
+				length[i]=s.length();
+				for(int j=0;j<s.length();j++) {
+					store[i][s.charAt(j)-'a']++;
+					count[s.charAt(j)-'a']++;
+				}
+			}
+			
+			for(int j=0;j<5;j++) {
+				
+				ArrayList<Integer>a=new ArrayList<>();
+				for(int i=0;i<n;i++) {
+					a.add((store[i][j]*2)-length[i]);
+				}
+				
+				Collections.sort(a,Collections.reverseOrder());
+				
+				long sum=0;
+				int ans=0;
+				for(int i=0;i<a.size();i++) {
+					sum+=a.get(i);
+					if(sum>0) {
+						ans++;
+					}else {
+						break;
+					}
+				}
+				max=Math.max(max, ans);
+			}
+			out.println(max);
+			
+		}
+		static int  MAX = Integer.MAX_VALUE;
+		static int  MIN = Integer.MIN_VALUE;
+		public static void main(String []args) {
+			int t=scr.nextInt();
+			while(t-->0) {
+				solve();
+			}
+//			solve();
+//			out.println(sb);
+		}
+	}
+ 	",0
+c1fef98f,fadc1365,"import java.util.*;
+import java.io.*;
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.Scanner;
+import java.util.StringTokenizer;
+
+public class Test{
+
+        static FastReader scan;
+
+        static void solve(){
+            scan.nextLine();
+            int n=scan.nextInt();
+            int k=scan.nextInt();
+            int []arr=new int[n+1];
+
+            int []block=new int[k];
+            int []temp=new int[k];
+
+            for(int i=0;i<k;i++){
+                block[i]=scan.nextInt();
+            }
+
+            for(int i=0;i<k;i++){
+                temp[i]=scan.nextInt();
+            }
+
+            for(int i=0;i<k;i++){
+                arr[block[i]]=temp[i];
+            }
+            int []dp=new  int[n+1];
+            int prev=Integer.MAX_VALUE-1000;
+            for(int i=1;i<=n;i++){
+                if(arr[i]==0){
+                    if(prev==Integer.MAX_VALUE-1000){
+                        dp[i]=prev;
+                    }
+                    else{
+                        prev=prev+1;
+                        dp[i]=prev;
+                    }
+                }
+                else{
+                    prev=Math.min(prev+1,arr[i]);
+                    dp[i]=prev;
+                }
+            }
+
+            prev=Integer.MAX_VALUE-1000;
+            for(int i=n;i>=1;i--){
+                if(arr[i]==0){
+                    if(prev==Integer.MAX_VALUE-1000){
+                        dp[i]=Math.min(prev,dp[i]);
+                    }
+                    else{
+                        prev=prev+1;
+                        dp[i]=Math.min(prev,dp[i]);
+                    }
+                }
+                else{
+                    prev=Math.min(prev+1,arr[i]);
+                    dp[i]=Math.min(prev,dp[i]);
+                }
+            }
+
+            for(int i=1;i<=n;i++){
+                System.out.print(dp[i]+"" "");
+            }
+            System.out.println();
+
+        }
+
+        public static void main (String[] args) throws java.lang.Exception{
+            scan=new FastReader();
+            int t=scan.nextInt();
+            while(t-->0){
+                solve();                  
+            }
+        }
+
+        static class FastReader {
+            BufferedReader br;
+            StringTokenizer st;
+
+            public FastReader()
+            {
+                br = new BufferedReader(
+                    new InputStreamReader(System.in));
+            }
+
+            String next()
+            {
+                while (st == null || !st.hasMoreElements()) {
+                    try {
+                        st = new StringTokenizer(br.readLine());
+                    }
+                    catch (IOException e) {
+                        e.printStackTrace();
+                    }
+                }
+                return st.nextToken();
+            }
+
+            int nextInt() { return Integer.parseInt(next()); }
+
+            long nextLong() { return Long.parseLong(next()); }
+
+            double nextDouble() { return Double.parseDouble(next()); }
+
+            String nextLine()
+            {
+                String str = """";
+                try {
+                    str = br.readLine();
+                }
+                catch (IOException e) {
+                    e.printStackTrace();
+                }
+                return str;
+            }
+        }
+
+        static class Pair implements Comparable<Pair>{
+            long wt;
+            long idx;
+            Pair(long x,long y){
+                this.wt=x;
+                this.idx=y;
+            }
+            @Override
+            public int compareTo(Pair x){
+                return (int)(this.wt-x.wt);
+            }
+
+            public String toString(){
+                return ""( ""+wt+"" ""+idx+"" )"";
+            }
+        }        
+
+        static void printLong(long []arr){
+            for(long x:arr)System.out.print(x+"" "");
+        }
+
+        static void printInt(int []arr){
+            for(int x:arr)System.out.print(x+"" "");
+        }
+
+        static void scanInt(int []arr){
+            for(int i=0;i<arr.length;i++){
+                arr[i]=scan.nextInt();
+            }
+        }
+
+        static void scanLong(long []arr){
+            for(int i=0;i<arr.length;i++){
+                arr[i]=scan.nextLong();
+            }
+        }
+
+        static long gcd(long a, long b){
+            if (b == 0)
+                return a;
+            
+            return gcd(b, a % b);
+        }   
+
+        static long power(long x, long y, long mod){
+            long res = 1; 
+        
+            x = x % mod; 
+         
+            if (x == 0)
+              return 0; 
+         
+            while (y > 0){              
+                if ((y & 1) != 0)
+                res = (res * x) % mod;
+              
+                y = y >> 1; 
+                x = (x * x) % mod;
+            }
+                return res;
+        }
+
+        static long add(long a,long b,long mod){
+            a = a % mod; 
+            b = b % mod; 
+            return (((a + b) % mod) + mod) % mod;
+        }
+
+        static long sub(long a, long b,long mod){
+            a = a % mod; 
+            b = b % mod; 
+            return (((a - b) % mod) + mod) % mod;
+        }
+
+        static long mul(long a, long b,long mod){
+            a = a % mod; 
+            b = b % mod; 
+            return (((a * b) % mod) + mod) % mod;
+        }
+        
+
+        static long mminvprime(long a, long b,long mod) {
+            return power(a, b - 2,mod);
+        }
+}
+","import java.io.PrintWriter;
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.*;
+public class a{ 
+    public static void main(String args[]) throws java.lang.Exception{ 
+    	FastScanner s=new FastScanner();
+		PrintWriter out=new PrintWriter(System.out);
+		int t=s.nextInt();
+		for(int tt=0;tt<t;tt++) {
+			int n=s.nextInt(),k=s.nextInt();
+			int pos[]=s.readArray(k);
+			int temp[]=s.readArray(k);
+			long ans[]=new long[n];
+			Arrays.fill(ans,Integer.MAX_VALUE);
+			for(int i=0;i<k;i++){
+				ans[pos[i]-1]=temp[i];
+			}
+			for(int i=1;i<n;i++){
+				ans[i]=Math.min(ans[i-1]+1,ans[i]);
+			}
+			for(int i=n-2;i>=0;i--){
+				ans[i]=Math.min(ans[i],ans[i+1]+1);
+			}
+			for(int i=0;i<n;i++){
+				out.print(ans[i]+"" "");
+			}
+			out.println();
+		}
+		out.close();
+    }
+	static boolean isPrime(int n){
+        if (n <= 1)
+            return false;
+        else if (n == 2)
+            return true;
+        else if (n % 2 == 0)
+            return false;
+        for (int i = 3; i <= Math.sqrt(n); i += 2){
+            if (n % i == 0)
+                return false;
+        }
+        return true;
+    }
+    static void sort(long [] a) {
+		ArrayList<Long> l=new ArrayList<>();
+		for (long i:a) l.add(i);
+		Collections.sort(l);
+		for (int i=0; i<a.length; i++) a[i]=l.get(i);
+	}
+	static void sort(char [] a) {
+		ArrayList<Character> l=new ArrayList<>();
+		for (char i:a) l.add(i);
+		Collections.sort(l);
+		for (int i=0; i<a.length; i++) a[i]=l.get(i);
+	}
+    static void sort(int [] a) {
+		ArrayList<Integer> l=new ArrayList<>();
+		for (int i:a) l.add(i);
+		Collections.sort(l);
+		for (int i=0; i<a.length; i++) a[i]=l.get(i);
+	}
+    static int gcd(int a, int b){
+      if (b == 0)
+        return a;
+      return gcd(b, a % b);
+    }
+    static void sortcol(int a[][],int c) {
+		Arrays.sort(a, (x, y) -> {
+			if(x[c]>y[c]) {
+				return 1;
+			}else {
+				return -1;
+			}
+		});
+	}
+    public static void printb(boolean ans) {
+    	if(ans) {
+    		System.out.println(""Yes"");
+    	}else {
+    		System.out.println(""No"");
+    	}
+    }
+    static class FastScanner {
+		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st=new StringTokenizer("""");
+		String next() {
+			while (!st.hasMoreTokens())
+				try {
+					st=new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			return st.nextToken();
+		}
+		double nextDouble() {
+			return Double.parseDouble(next());
+		}
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+		int[] readArray(int n) {
+			int[] a=new int[n];
+			for (int i=0; i<n; i++) a[i]=nextInt();
+			return a;
+		}
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+	}
+    static class Pair implements Comparable<Pair>{
+    	int a , b; 
+    	Pair(int x , int y){
+    		a=x;
+    		b=y;
+    	}
+    	public int compareTo(Pair o) {
+    		return a != o.a ? a - o.a : b - o.b;
+    	}
+    }
+}
+",0
+00af3420,5449d33c,"import java.util.*;
+import java.io.*;
+
+public class Main {
+
+    public static void main(String[] args) throws IOException {
+        Scanner sc = new Scanner(System.in);
+        PrintWriter pw = new PrintWriter(System.out);
+        int t = sc.nextInt();
+        while(t-- > 0){
+            int n = sc.nextInt();
+            String[] s = new String[n];
+            for(int i=0; i<n; i++)
+                s[i] = sc.next();
+            int MAX = 0;
+            for(char c = 'a'; c <= 'e'; c++){
+                PriorityQueue<Integer> pq = new PriorityQueue<>(Collections.reverseOrder()); //Big comes in top;
+                for(int i=0; i<n; ++i) {
+                    int curChar = 0;
+                    int otherChar = 0;
+                    for(int j=0; j<s[i].length(); j++) {
+                        if(s[i].charAt(j) == c)
+                            curChar++;
+                        else
+                            otherChar++;
+                    }
+                    int diff = curChar - otherChar;
+                    pq.add(diff);
+                }
+                int cur = 0;
+                int numberOfWords = 0;
+                while(!pq.isEmpty()){
+                    if(cur + pq.peek() > 0){
+                        cur += pq.poll();
+                        numberOfWords++;
+                    }else{
+                        break;
+                    }
+                }
+                MAX = Math.max(MAX, numberOfWords);
+            }
+            pw.println(MAX);
+        }
+        pw.close();
+    }
+
+    static class Scanner {
+        BufferedReader br;
+        StringTokenizer st;
+
+        public Scanner(InputStream s) {
+            br = new BufferedReader(new InputStreamReader(s));
+        }
+
+        public Scanner(FileReader f) {
+            br = new BufferedReader(f);
+        }
+
+        public String next() throws IOException {
+            while (st == null || !st.hasMoreTokens())
+                st = new StringTokenizer(br.readLine());
+            return st.nextToken();
+        }
+
+        public int nextInt() throws IOException {
+            return Integer.parseInt(next());
+        }
+
+        public long nextLong() throws IOException {
+            return Long.parseLong(next());
+        }
+
+        public double nextDouble() throws IOException {
+            return Double.parseDouble(next());
+        }
+
+        public int[] nextIntArr(int n) throws IOException {
+            int[] arr = new int[n];
+            for (int i = 0; i < n; i++) {
+                arr[i] = Integer.parseInt(next());
+            }
+            return arr;
+        }
+
+    }
+}
+
+","import java.io.*;
+import java.util.*;
+import java.lang.*;
+
+public class C {
+  public static void main(String[] args) {
+    InputStream inputStream = System.in;
+    OutputStream outputStream = System.out;
+    InputReader in = new InputReader(inputStream);
+    PrintWriter out = new PrintWriter(outputStream);
+    Solver solver = new Solver();
+    solver.Main(in, out);
+    out.close();
+  }
+
+  static class Solver {
+    public void Main(InputReader in, PrintWriter out) {
+      int T = in.nextInt();
+      for (int t = 0; t < T; t++) {
+        int n = in.nextInt();
+        String[] A = new String[n];
+        for (int i = 0; i < n; i++) {
+          A[i] = in.next();
+        }
+        int ans = 0;
+        for (char c = 'a'; c <= 'e'; c++) {
+          int[] ls = new int[n];
+          for (int i = 0; i < n; i++) {
+            int delta = 0;
+            for (int j = 0; j < A[i].length(); j++) {
+              if (A[i].charAt(j) == c) {
+                delta += 1;
+              } else {
+                delta -= 1;
+              }
+            }
+            ls[i] = delta;
+          }
+          Arrays.sort(ls, 0, n);
+          int cur = 0;
+          int score = 0;
+          for (int i = n - 1; i >= 0; i--) {
+            if (cur + ls[i] >= 1) {
+              cur += ls[i];
+              score += 1;
+            }
+          }
+          ans = Math.max(ans, score);
+        }
+        out.println(ans);
+      }
+    }
+  }
+
+  static class InputReader {
+    public BufferedReader reader;
+    public StringTokenizer tokenizer;
+
+    public InputReader(InputStream stream) {
+      reader = new BufferedReader(new InputStreamReader(stream), 32768);
+      tokenizer = null;
+    }
+
+    public String next() {
+      while (tokenizer == null || !tokenizer.hasMoreTokens()) {
+        try {
+          tokenizer = new StringTokenizer(reader.readLine());
+        } catch (IOException e) {
+          throw new RuntimeException(e);
+        }
+      }
+      return tokenizer.nextToken();
+    }
+
+    public int nextInt() {
+      return Integer.parseInt(next());
+    }
+  }
+}
+",0
+1a6f8b20,77448a05,"
+
+import java.io.*;
+import java.util.*;
+public class Main
+{
+	public static void main(String[] args)throws Exception
+	{
+	    Main ob=new Main();
+	    ob.fun();
+	}
+	public void fun()throws Exception
+	{
+	    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+	    PrintWriter pw=new PrintWriter(System.out);
+	    int t=Integer.parseInt(br.readLine());
+	    while(t-->0)
+	    {
+	        int n=Integer.parseInt(br.readLine());
+	        int ar[][]=new int [n][5];
+	        int len[]=new int[n];
+	        for(int i=0;i<n;i++)
+	        {
+	            String s=(br.readLine());
+	            for(int j=0;j<s.length();j++)
+	            {
+	                ar[i][s.charAt(j)-'a']++;
+	                len[i]=s.length();
+	            }
+	        }
+	        int max=0;
+	        for(int i=0;i<5;i++)
+	        {
+	            int num=fun2(ar,len,i);
+	            max=Math.max(num,max);
+	        }
+	        pw.println(max);
+	        
+	    }
+	    pw.flush();
+	}
+	public int fun2(int ar[][],int len[],int col)
+	{
+	    int ct=0;
+	    int n=ar.length;
+	    PriorityQueue<Integer> pq=new PriorityQueue<Integer>(Collections.reverseOrder());
+	    for(int i=0;i<n;i++)
+	    {
+	        int dif=2*ar[i][col]-len[i];
+	        pq.add(dif);
+	    }
+	    int sum=0;
+	    while(pq.size()>0)
+	    {
+	        int num=(int)(pq.poll());
+	        if((sum+num)>0)
+	        {
+	            ct++;
+	            sum+=num;
+	        }
+	    }
+	    return ct;
+	}
+}
+","//package currentContest;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Random;
+import java.util.StringTokenizer;
+
+public class P4 {
+	static int N = 1000001;
+
+	// Array to store inverse of 1 to N
+	static long[] factorialNumInverse = new long[N + 1];
+
+	// Array to precompute inverse of 1! to N!
+	static long[] naturalNumInverse = new long[N + 1];
+
+	// Array to store factorial of first N numbers
+	static long[] fact = new long[N + 1];
+
+	// Function to precompute inverse of numbers
+	public static void InverseofNumber(int p) {
+		naturalNumInverse[0] = naturalNumInverse[1] = 1;
+
+		for (int i = 2; i <= N; i++)
+			naturalNumInverse[i] = naturalNumInverse[p % i] * (long) (p - p / i) % p;
+	}
+
+	// Function to precompute inverse of factorials
+	public static void InverseofFactorial(int p) {
+		factorialNumInverse[0] = factorialNumInverse[1] = 1;
+
+		// Precompute inverse of natural numbers
+		for (int i = 2; i <= N; i++)
+			factorialNumInverse[i] = (naturalNumInverse[i] * factorialNumInverse[i - 1]) % p;
+	}
+
+	// Function to calculate factorial of 1 to N
+	public static void factorial(int p) {
+		fact[0] = 1;
+
+		// Precompute factorials
+		for (int i = 1; i <= N; i++) {
+			fact[i] = (fact[i - 1] * (long) i) % p;
+		}
+	}
+
+	// Function to return nCr % p in O(1) time
+	public static long Binomial(int N, int R, int p) {
+
+		// n C r = n!*inverse(r!)*inverse((n-r)!)
+		long ans = ((fact[N] * factorialNumInverse[R]) % p * factorialNumInverse[N - R]) % p;
+
+		return ans;
+	}
+
+	public static void main(String[] args) {
+		// TODO Auto-generated method stub
+		FastReader sc = new FastReader();
+		int t;
+		t = sc.nextInt();
+		StringBuilder st = new StringBuilder();
+//		int p = 998244353;
+//	    InverseofNumber(p);
+//	    InverseofFactorial(p);
+//	    factorial(p);
+		// System.out.println(3|1);
+		while (t-- != 0) {
+			int n=sc.nextInt();
+			String s[]=new String[n];
+			for(int i=0;i<n;i++) {
+				s[i]=sc.nextLine();
+			}
+			int max=0;
+			ArrayList<Integer> freq=new ArrayList<>();
+			for(int i=0;i<5;i++) {
+				int f1=0;
+				freq=new ArrayList<>();
+				for(int j=0;j<n;j++) {
+					f1=0;
+					for(int k=0;k<s[j].length();k++) {
+						if(s[j].charAt(k)==i+'a') {
+							f1++;
+						}else {
+							f1--;
+						}
+					}
+					freq.add(f1);
+				}
+				Collections.sort(freq);
+				int x=0;
+				int total=0;
+				for(int j=n-1;j>=0;j--) {
+					total=total+freq.get(j);
+					if(total>0) {
+						x++;
+					}else {
+						break;
+					}
+				}
+				max=Math.max(max, x);
+			}
+			st.append(max+""\n"");
+		}
+		System.out.println(st);
+	}
+
+	static FastReader sc = new FastReader();
+
+	public static void solvegraph() {
+		int n = sc.nextInt();
+
+		int edge[][] = new int[n - 1][2];
+		for (int i = 0; i < n - 1; i++) {
+			edge[i][0] = sc.nextInt() - 1;
+			edge[i][1] = sc.nextInt() - 1;
+		}
+		ArrayList<ArrayList<Integer>> ad = new ArrayList<>();
+		for (int i = 0; i < n; i++) {
+			ad.add(new ArrayList<Integer>());
+		}
+		for (int i = 0; i < n - 1; i++) {
+			ad.get(edge[i][0]).add(edge[i][1]);
+			ad.get(edge[i][1]).add(edge[i][0]);
+		}
+		int parent[] = new int[n];
+		Arrays.fill(parent, -1);
+		parent[0] = n;
+		ArrayDeque<Integer> queue = new ArrayDeque<>();
+		queue.add(0);
+		int child[] = new int[n];
+		Arrays.fill(child, 0);
+		ArrayList<Integer> lv = new ArrayList<Integer>();
+		while (!queue.isEmpty()) {
+			int toget = queue.getFirst();
+			queue.removeFirst();
+			child[toget] = ad.get(toget).size() - 1;
+			for (int i = 0; i < ad.get(toget).size(); i++) {
+				if (parent[ad.get(toget).get(i)] == -1) {
+					parent[ad.get(toget).get(i)] = toget;
+					queue.addLast(ad.get(toget).get(i));
+				}
+			}
+			lv.add(toget);
+		}
+
+		child[0]++;
+	}
+
+	static void sort(int[] A) {
+		int n = A.length;
+		Random rnd = new Random();
+		for (int i = 0; i < n; ++i) {
+			int tmp = A[i];
+			int randomPos = i + rnd.nextInt(n - i);
+			A[i] = A[randomPos];
+			A[randomPos] = tmp;
+		}
+		Arrays.sort(A);
+	}
+
+	static void sort(long[] A) {
+		int n = A.length;
+		Random rnd = new Random();
+		for (int i = 0; i < n; ++i) {
+			long tmp = A[i];
+			int randomPos = i + rnd.nextInt(n - i);
+			A[i] = A[randomPos];
+			A[randomPos] = tmp;
+		}
+		Arrays.sort(A);
+	}
+
+	static String sort(String s) {
+		Character ch[] = new Character[s.length()];
+		for (int i = 0; i < s.length(); i++) {
+			ch[i] = s.charAt(i);
+		}
+		Arrays.sort(ch);
+		StringBuffer st = new StringBuffer("""");
+		for (int i = 0; i < s.length(); i++) {
+			st.append(ch[i]);
+		}
+		return st.toString();
+	}
+
+	public static long gcd(long a, long b) {
+		if (a == 0) {
+			return b;
+		}
+		return gcd(b % a, a);
+	}
+
+	static class FastReader {
+		BufferedReader br;
+		StringTokenizer st;
+
+		public FastReader() {
+			br = new BufferedReader(new InputStreamReader(System.in));
+		}
+
+		String next() {
+			while (st == null || !st.hasMoreElements()) {
+				try {
+					st = new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			}
+			return st.nextToken();
+		}
+
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+
+		double nextDouble() {
+			return Double.parseDouble(next());
+		}
+
+		String nextLine() {
+			String str = """";
+			try {
+				str = br.readLine();
+			} catch (IOException e) {
+				e.printStackTrace();
+			}
+			return str;
+		}
+	}
+}
+",0
+0b04b41e,c4ca2ff3,"import java.io.BufferedReader;
+import java.io.*;
+import java.util.*;
+
+public class josph {
+
+static BufferedReader br;
+
+
+static long mod = 1000000000 + 7;
+static HashSet<Integer> p = new HashSet<>();
+static boolean debug =true;
+// Arrays.sort(time , (a1,a2) -> (a1[0]-a2[0])); 2d array sort lamda
+public static void main(String[] args) throws Exception {
+br = new BufferedReader(new InputStreamReader(System.in));
+PrintWriter pr = new PrintWriter(System.out);
+int tc = 1;
+tc= cinI();
+while(tc-->0){
+int n =cinI();
+String[] a= new String[n];
+
+int[][] f =new int[10][n];
+
+for(int i=0;i<n;i++){
+a[i]=cin();
+char[] x = a[i].toCharArray();
+
+for(char c:x){
+int index = c-'a';
+f[index][i]+=1;
+}
+for(int j=0;j<10;j++){
+int rem =x.length-f[j][i];
+f[j][i]-=rem;
+}
+}
+int max=0;
+for(int j=0;j<10;j++){
+Arrays.sort(f[j]);
+int cnt=0;
+int sum=0;
+for(int i=n-1;i>=0;i--){
+sum+=f[j][i];
+if(sum>0){
+cnt+=1;
+}
+else{
+break;
+}
+}
+max=max(max,cnt);
+}
+System.out.println(max);
+}
+
+}
+
+public static <E> void print(String var ,E e){
+if(debug==true){
+System.out.println(var +"" ""+e);
+}
+}
+private static long[] sort(long[] e){
+ArrayList<Long> x=new ArrayList<>();
+for(long c:e){
+x.add(c);
+}
+Collections.sort(x);
+long[] y = new long[e.length];
+for(int i=0;i<x.size();i++){
+y[i]=x.get(i);
+}
+return y;
+}
+public static void printDp(long[][] dp) {
+
+int n = dp.length;
+for (int i = 0; i < n; i++) {
+for (int j = 0; j < dp[0].length; j++) {
+System.out.print(dp[i][j] + "" "");
+}
+System.out.println();
+}
+}
+
+
+
+
+
+
+private static long gcd(long a, long b) {
+if (a == 0)
+return b;
+if (b == 0)
+return a;
+
+// base case
+if (a == b)
+return a;
+
+// a is greater
+if (a > b)
+return gcd(a % b, b);
+return gcd(a, b % a);
+}
+
+
+public static long min(long a, long b) {
+return Math.min(a, b);
+}
+
+public static int min(int a, int b) {
+return Math.min(a, b);
+}
+
+
+public static void sieve() {
+int[] pf = new int[100000000 + 1];
+//0 prime //1 not prime
+pf[0] = 1;
+pf[1] = 1;
+for (int j = 2; j <= 10000; j++) {
+
+if (pf[j] == 0) {
+p.add(j);
+for (int k = j * j; k < pf.length; k += j) {
+pf[k] = 1;
+}
+}
+}
+
+}
+
+
+public static int[] readArray(int n, int x, int z) throws Exception {
+int[] arr = new int[n];
+String[] ar = cinA();
+for (int i = x; i < n + x; i++) {
+arr[i] = getI(ar[i - x]);
+}
+return arr;
+}
+
+public static long[] readArray(int n, int x) throws Exception {
+long[] arr = new long[n];
+String[] ar = cinA();
+for (int i = x; i < n + x; i++) {
+arr[i] = getL(ar[i - x]);
+}
+return arr;
+}
+
+public static void arrinit(String[] a, long[] b) throws Exception {
+for (int i = 0; i < a.length; i++) {
+b[i] = Long.parseLong(a[i]);
+}
+}
+
+public static HashSet<Integer>[] Graph(int n, int edge, int directed) throws Exception {
+HashSet<Integer>[] tree = new HashSet[n];
+
+for (int j = 0; j < edge; j++) {
+
+String[] uv = cinA();
+int u = getI(uv[0]);
+int v = getI(uv[1]);
+if (directed == 0) {
+
+tree[v].add(u);
+}
+tree[u].add(v);
+}
+return tree;
+}
+
+public static void arrinit(String[] a, int[] b) throws Exception {
+for (int i = 0; i < a.length; i++) {
+b[i] = Integer.parseInt(a[i]);
+}
+}
+
+
+static double findRoots(int a, int b, int c) {
+// If a is 0, then equation is not
+//quadratic, but linear
+
+
+int d = b * b - 4 * a * c;
+double sqrt_val = Math.sqrt(Math.abs(d));
+
+
+// System.out.println(""Roots are real and different \n"");
+
+return Math.max((double) (-b + sqrt_val) / (2 * a),
+(double) (-b - sqrt_val) / (2 * a));
+
+
+}
+
+public static String cin() throws Exception {
+return br.readLine();
+}
+
+public static String[] cinA() throws Exception {
+return br.readLine().split("" "");
+}
+
+public static String[] cinA(int x) throws Exception {
+return br.readLine().split("""");
+}
+
+public static String ToString(Long x) {
+return Long.toBinaryString(x);
+}
+
+public static void cout(String s) {
+System.out.println(s);
+}
+
+public static Integer cinI() throws Exception {
+return Integer.parseInt(br.readLine());
+}
+
+public static int getI(String s) throws Exception {
+return Integer.parseInt(s);
+}
+
+public static long getL(String s) throws Exception {
+return Long.parseLong(s);
+}
+
+public static long max(long a, long b) {
+return Math.max(a, b);
+}
+
+public static int max(int a, int b) {
+return Math.max(a, b);
+}
+
+public static void coutI(int x) {
+System.out.println(String.valueOf(x));
+}
+
+public static void coutI(long x) {
+System.out.println(String.valueOf(x));
+}
+
+public static Long cinL() throws Exception {
+return Long.parseLong(br.readLine());
+}
+
+public static void arrInit(String[] arr, int[] arr1) throws Exception {
+for (int i = 0; i < arr.length; i++) {
+arr1[i] = getI(arr[i]);
+}
+
+}
+}","/* package codechef; // don't place package name! */
+
+import java.util.*;
+import java.lang.*;
+import java.io.*;
+
+/* Name of the class has to be ""Main"" only if the class is public. */
+public class Main
+{
+	public static void main (String[] args) throws java.lang.Exception
+	{
+		// your code goes here
+		Scanner sc=new Scanner(System.in);
+		int t=sc.nextInt();
+		PrintWriter out=new PrintWriter(System.out);
+		while(t-->0) {
+		    int n=sc.nextInt();
+		    int freq[][]=new int[n][5];
+		    int rem[][]=new int[n][5];
+		    for(int i=0;i<n;i++) {
+		        String str=sc.next();
+		        
+		        for(int j=0;j<str.length();j++) {
+		            freq[i][str.charAt(j)-'a']++;
+		        }
+		        for(int k=0;k<5;k++) {
+		            rem[i][k]=str.length()-freq[i][k];
+		        }
+		    }
+		    
+		    int ans=0;
+		    for(int i=0;i<5;i++) {
+		        int arr[]=new int[n];
+		        for(int j=0;j<n;j++)
+		        arr[j]=freq[j][i]-rem[j][i];
+		        
+		        Arrays.sort(arr);
+		        int total=0;
+		        int sum=0;
+		        for(int k=n-1;k>=0;k--) {
+		            if(sum+arr[k]>0) {
+		                sum=sum+arr[k];
+		                total++;
+		            }
+		            else {
+		                break;
+		            }
+		        }
+		        ans=Math.max(ans,total);
+		    }
+		    out.println(ans);
+		    
+		}
+		out.flush();
+		out.close();
+	}
+}
+
+",0
+81fb6415,fb69b3b4,"import java.math.BigInteger;
+import java.util.*;
+import java.io.*;
+import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
+
+public class CodeForces {
+
+
+    public void run() throws Exception {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        int t = Integer.parseInt(br.readLine());
+        next : while (t-- > 0) {
+            StringTokenizer st = new StringTokenizer(br.readLine());
+            int n = Integer.parseInt(st.nextToken());
+            long k = Long.parseLong(st.nextToken());
+            Long[] a = new Long[n];
+            st = new StringTokenizer(br.readLine());
+            for (int i = 0; i < n; i++) {
+                a[i] = Long.parseLong(st.nextToken());
+            }
+            Arrays.sort(a);
+            long ans = Long.MAX_VALUE;
+            long[] lsum = new long[n + 1];
+            for (int i = 0; i < n; i++) {
+                lsum[i + 1] = lsum[i] + a[i];
+            }
+            for (long y = 0; y < n; y++) {
+                long x = 0;
+                if ((k - lsum[n - (int)y] + a[0]) >= 0) {
+                    x = (k - lsum[n - (int)y] + a[0]) / (y + 1);
+                } else {
+                    if ((k - lsum[n - (int)y] + a[0]) % (y + 1) == 0) {
+                        x = (k - lsum[n - (int)y] + a[0]) / (y + 1);
+                    } else {
+                        x = (k - lsum[n - (int)y] + a[0]) / (y + 1) - 1;
+                    }
+                }
+                x = a[0] - x;
+                ans = Math.min(ans, Math.max(0, x) + y);
+            }
+            System.out.println(ans);
+        }
+
+    }
+
+    public static void main(String[] args) throws Exception {
+        new CodeForces().run();
+    }
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+","
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.*;
+ 
+public class Main {
+    public static long floor(long a, long b) {
+        long res = a / b;
+        while(res * b > a) res--;
+        return res;
+    }
+    public static void main(String[] args) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        int t = Integer.parseInt(br.readLine());
+        while (t-- > 0) {
+            StringTokenizer st = new StringTokenizer(br.readLine());
+            int n = Integer.parseInt(st.nextToken());
+            long k = Long.parseLong(st.nextToken());
+            st = new StringTokenizer(br.readLine());
+            Long[] p = new Long[n];
+            for(int i = 0 ;i<n;i++) {
+                p[i] = Long.parseLong(st.nextToken());
+            }
+            Arrays.sort(p);
+            long[] sums = new long[n+1];
+            for(int i=0;i<n;i++) sums[i+1] = sums[i] + p[i];
+            long ans = Long.MAX_VALUE;
+            for(int y=0;y<n;y++) {
+                long x = p[0] - floor(k - sums[n-y] + p[0], y+1);
+                ans = Math.min(Math.max(x, 0) + y, ans);
+            }
+            System.out.println(ans);
+        }
+    }
+}",0
+72d9eb5b,9862c742,"import java.util.*;
+import java.io.*;
+
+public class D {
+    public static void main(String[] args) {
+        Scanner in = new Scanner(System.in);
+        
+        int T = in.nextInt();
+        while(T-- > 0) {
+            int n = in.nextInt();
+            int[] a = new int[n];
+            for(int j=0;j<n;j++) a[j] = in.nextInt();
+            char[] s = in.next().toCharArray();
+
+            List<Integer> blue = new ArrayList<>();
+            List<Integer> red = new ArrayList<>();
+            for(int j=0;j<n;j++) {
+                if(s[j] == 'B') blue.add(a[j]);
+                else red.add(a[j]);
+            }
+
+            Collections.sort(blue);
+            Collections.sort(red);
+
+            boolean p = true;
+            int cur = 1;
+            for(int val : blue) {
+                if(val<cur) {
+                    p = false;
+                    break;
+                }
+                else cur++;
+            }
+            for(int val : red) {
+                if(val>cur) {
+                    p = false;
+                    break;
+                }
+                else cur++;
+            }
+            
+            if(p) System.out.println(""yes"");
+            else System.out.println(""no"");
+        }
+    }
+}
+","/******************************************************************************
+
+Welcome to GDB Online.
+GDB online is an online compiler and debugger tool for C, C++, Python, Java, PHP, Ruby, Perl,
+C#, VB, Swift, Pascal, Fortran, Haskell, Objective-C, Assembly, HTML, CSS, JS, SQLite, Prolog.
+Code, Compile, Run and Debug online from anywhere in world.
+
+*******************************************************************************/
+import java.util.*;
+public class Main
+{
+	public static void main(String[] args) {
+		Scanner s  = new Scanner(System.in);
+		int t = s.nextInt();
+		while(t-- > 0){
+		    int n = s.nextInt();
+		    int[] arr = new int[n];
+		    for(int i=0;i<n;i++)
+		        arr[i] = s.nextInt();
+		    String str = s.next();
+		    List<Integer> left = new ArrayList<>();
+		    List<Integer> right = new ArrayList<>();
+		    for(int i=0;i<arr.length;i++){
+		        if(str.charAt(i) == 'B')
+		            left.add(arr[i]);
+		        else right.add(arr[i]);
+		    }
+		    Collections.sort(left);
+		    Collections.sort(right);
+		    boolean flag = false;
+		    for(int i=0;i<left.size();i++)
+		        if(left.get(i) < i+1){
+		            flag = true;
+		            break;
+		        }
+		    if(!flag){
+		        for(int i=0;i<right.size();i++)
+    		        if(right.get(i) > left.size()+i+1){
+    		            flag = true;
+    		            break;
+    		        }
+		    }
+		    if(flag)
+		        System.out.println(""NO"");
+		    else System.out.println(""YES"");
+		}
+	}
+}
+
+",0
+2af19170,ac8ef97c,"import java.util.*;
+import java.io.*;
+
+public class Solution{
+	
+	static long abs(long a){return Math.abs(a);}
+	static long max(long a, long b){return Math.max(a, b);}
+	
+	static class Graph{
+		
+		int l[], r[], v;
+		ArrayList<Integer> adj[];		
+		Graph(int v){
+			this.v = v;
+			this.l = new int[v];
+			this.r = new int[v];
+			adj = new ArrayList[v];
+			for(int i = 0 ; i < v ; i++){
+				adj[i] = new ArrayList<>();
+			}
+		}
+		
+		void addEdge(int u, int v){
+			this.adj[u].add(v);
+			this.adj[v].add(u);
+		}
+		
+		long[] dfs(int u, int parent){
+			long left = 0, right = 0;
+			int n = adj[u].size();
+			for (int i = 0 ; i < n; i ++ ) {
+				int child = adj[u].get(i);
+				if ( child == parent ) continue;
+				long val[] = dfs(child, u);
+				left += max(abs(l[child]- l[u])+val[0], abs(r[child] - l[u])+val[1]);
+				right += max(abs(l[child]- r[u])+val[0], abs(r[child] - r[u])+val[1]);
+			}
+			
+			return new long[]{left, right};
+		}
+	}
+
+	public static void main(String args[])throws IOException{
+		BufferedReader br = new 
+		BufferedReader(new InputStreamReader(System.in));
+		
+		int tests = Integer.parseInt(br.readLine());
+		while( tests --> 0 ){
+			int n = Integer.parseInt(br.readLine());
+			Graph g = new Graph(n);
+			for(int i = 0 ; i < n ; i++ ){
+				String line[] = br.readLine().split("" "");
+				g.l[i] = Integer.parseInt(line[0]);
+				g.r[i] = Integer.parseInt(line[1]);
+			}
+			
+			for(int i = 0 ; i < n - 1 ; i++ ){
+				String line[] = br.readLine().split("" "");
+				int u = Integer.parseInt(line[0]) - 1;
+				int v = Integer.parseInt(line[1]) - 1;			
+				g.addEdge(u, v);
+			}
+			
+			long res[] = g.dfs(0, -1);
+			System.out.println(max(res[0], res[1]));
+		}
+	}
+}","import java.io.*;
+import java.util.*;
+
+public class Codeforces
+{
+    public static void main(String args[])throws Exception
+    {
+        BufferedReader bu=new BufferedReader(new InputStreamReader(System.in));
+        StringBuilder sb=new StringBuilder();
+        int t=Integer.parseInt(bu.readLine());
+        while(t-->0)
+        {
+            int n=Integer.parseInt(bu.readLine());
+            g=new ArrayList[n];
+            int i;
+            for(i=0;i<n;i++)
+            {
+                g[i]=new ArrayList<>();
+                String st[]=bu.readLine().split("" "");
+                a[i][0]=Integer.parseInt(st[0]); a[i][1]=Integer.parseInt(st[1]);
+                s[i][0]=s[i][1]=0;
+            }
+
+            for(i=0;i<n-1;i++)
+            {
+                String st[]=bu.readLine().split("" "");
+                int u=Integer.parseInt(st[0])-1,v=Integer.parseInt(st[1])-1;
+                g[u].add(v); g[v].add(u);
+            }
+
+            dfs(0,-1);
+            sb.append(Math.max(s[0][0],s[0][1])+""\n"");
+        }
+        System.out.print(sb);
+    }
+
+    static ArrayList<Integer> g[];
+    static int N=100000,a[][]=new int[N][2];
+    static long s[][]=new long[N][2];
+    static void dfs(int n,int p)
+    {
+        for(int x:g[n])
+        if(x!=p)
+        {
+            dfs(x,n);
+            s[n][0]+=Math.max(s[x][0]+Math.abs(a[x][0]-a[n][0]),s[x][1]+Math.abs(a[x][1]-a[n][0]));
+            s[n][1]+=Math.max(s[x][0]+Math.abs(a[x][0]-a[n][1]),s[x][1]+Math.abs(a[x][1]-a[n][1]));
+        }
+    }
+}
+",0
+9310ad0c,f36138e7,"import java.io.*;
+import java.util.*;
+
+public class Main{
+
+    static class FastReader {
+        BufferedReader br;
+        StringTokenizer st;
+ 
+        public FastReader()
+        {
+            br = new BufferedReader(
+                new InputStreamReader(System.in));
+        }
+ 
+        String next()
+        {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                }
+                catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+ 
+        int nextInt() { return Integer.parseInt(next()); }
+ 
+        long nextLong() { return Long.parseLong(next()); }
+ 
+        double nextDouble()
+        {
+            return Double.parseDouble(next());
+        }
+ 
+        String nextLine()
+        {
+            String str = """";
+            try {
+                str = br.readLine();
+            }
+            catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+        }
+    }
+    
+    
+
+
+    
+
+    
+
+public static void main(String[] args) throws Exception {
+
+
+    FastReader sc = new FastReader();
+    
+   int t=sc.nextInt();
+
+   
+  while(t-->0)
+  {
+      int n=sc.nextInt();
+
+      long k[]=new long[n];
+      for(int i=0;i<n;i++)
+      {
+          k[i]=sc.nextLong();
+      }
+
+      long h[]=new long[n];
+      for(int i=0;i<n;i++)
+      {
+          h[i]=sc.nextLong();
+      }
+      ArrayList<Long> al=new ArrayList<>();
+      long csp=h[n-1],idx=k[n-1]-h[n-1];
+      for(int i=n-2;i>=0;i--)
+      {
+          if(idx<k[i])
+          {
+              if(k[i]-idx<h[i])
+              {
+                  long diff=h[i]-(k[i]-idx);
+                  csp+=diff;
+                  idx-=diff;
+              }
+          }
+          else
+          {
+              al.add(csp);
+              csp=h[i];
+              idx=k[i]-csp;
+          }
+         
+
+      }
+
+      long sum=0;
+      al.add(csp);
+      for(long i:al)
+      {
+         sum=sum+((i*(i+1))/2);
+      }
+
+      System.out.println(sum);
+     
+  }
+}
+}
+
+
+
+
+","import java.io.*;
+import java.util.*;
+
+public class a {
+
+    public static void main(String[] args){
+
+        FastScanner sc = new FastScanner();
+        int t = sc.nextInt();
+        while(t-- > 0){
+
+            int n = sc.nextInt();
+
+            long time[] = new long[n];
+            long health[] = new long[n];
+
+            for(int i=0; i<n; i++){
+                long temp = sc.nextLong();
+                time[i] = temp;
+            }
+            for(int i=0; i<n; i++){
+                long temp = sc.nextLong();
+                health[i] = temp;
+            }
+
+            long ans = 0L;
+            int peak = n-1;
+            int end = n-1;
+            for(int i=n-1; i>=0; i--){
+
+                if(i == n-1){
+                    ans += (health[i]*(health[i]+1))/2;
+                    continue;
+                }
+
+                if(health[peak] - (time[peak]-time[i]) <= 0){
+                    peak = i;
+                    end = i;
+                    ans += (health[i]*(health[i]+1))/2;
+                }
+
+                else if(health[peak] - (time[peak]-time[i]) < health[i]){
+
+                    long val = health[peak] + (time[end]-time[peak]); 
+                    ans -= (val*(val+1))/2;
+
+                    //System.out.println(""Val1: "" + val);
+
+                    val = health[i] + (time[end]-time[i]);
+                    ans += (val*(val+1))/2;
+
+                    //System.out.println(""Val2: "" + val);
+
+                    peak = i;
+                }
+
+            }
+
+            System.out.println(ans);
+
+        }
+
+    }
+
+}
+
+class FastScanner
+{
+    //I don't understand how this works lmao
+    private int BS = 1 << 16;
+    private char NC = (char) 0;
+    private byte[] buf = new byte[BS];
+    private int bId = 0, size = 0;
+    private char c = NC;
+    private double cnt = 1;
+    private BufferedInputStream in;
+
+    public FastScanner() {
+        in = new BufferedInputStream(System.in, BS);
+    }
+
+    public FastScanner(String s) {
+        try {
+            in = new BufferedInputStream(new FileInputStream(new File(s)), BS);
+        } catch (Exception e) {
+            in = new BufferedInputStream(System.in, BS);
+        }
+    }
+
+    private char getChar() {
+        while (bId == size) {
+            try {
+                size = in.read(buf);
+            } catch (Exception e) {
+                return NC;
+            }
+            if (size == -1) return NC;
+            bId = 0;
+        }
+        return (char) buf[bId++];
+    }
+
+    public int nextInt() {
+        return (int) nextLong();
+    }
+
+    public int[] nextInts(int N) {
+        int[] res = new int[N];
+        for (int i = 0; i < N; i++) {
+            res[i] = (int) nextLong();
+        }
+        return res;
+    }
+
+    public long[] nextLongs(int N) {
+        long[] res = new long[N];
+        for (int i = 0; i < N; i++) {
+            res[i] = nextLong();
+        }
+        return res;
+    }
+
+    public long nextLong() {
+        cnt = 1;
+        boolean neg = false;
+        if (c == NC) c = getChar();
+        for (; (c < '0' || c > '9'); c = getChar()) {
+            if (c == '-') neg = true;
+        }
+        long res = 0;
+        for (; c >= '0' && c <= '9'; c = getChar()) {
+            res = (res << 3) + (res << 1) + c - '0';
+            cnt *= 10;
+        }
+        return neg ? -res : res;
+    }
+
+    public double nextDouble() {
+        double cur = nextLong();
+        return c != '.' ? cur : cur + nextLong() / cnt;
+    }
+
+    public double[] nextDoubles(int N) {
+        double[] res = new double[N];
+        for (int i = 0; i < N; i++) {
+            res[i] = nextDouble();
+        }
+        return res;
+    }
+
+    public String next() {
+        StringBuilder res = new StringBuilder();
+        while (c <= 32) c = getChar();
+        while (c > 32) {
+            res.append(c);
+            c = getChar();
+        }
+        return res.toString();
+    }
+
+    public String nextLine() {
+        StringBuilder res = new StringBuilder();
+        while (c <= 32) c = getChar();
+        while (c != '\n') {
+            res.append(c);
+            c = getChar();
+        }
+        return res.toString();
+    }
+
+    public boolean hasNext() {
+        if (c > 32) return true;
+        while (true) {
+            c = getChar();
+            if (c == NC) return false;
+            else if (c > 32) return true;
+        }
+    }
+}
+
+",0
+e431de28,eb6cfca7,"import java.io.*;
+import java.lang.*;
+import java.util.*;
+public class MinGridPath {
+
+	public static void main(String[] args) {
+		// TODO Auto-generated method stub
+		Scanner s=new Scanner(System.in);
+		int t=s.nextInt();
+		while(t-->0){
+			
+			int n = s.nextInt();
+			long[] aa =new long[n];
+			for(int i=0;i<n;i++)
+				aa[i]=s.nextLong();
+ 
+			long minEven = aa[0];
+			long minOdd = aa[1];
+			long sum = aa[0]+aa[1];
+			long best = n*minEven + n*minOdd;
+			int numOdd = 1;
+			int numEven = 1;
+			for(int i=2; i<n; ++i) {
+				if(i%2 == 0) {
+					minEven = Math.min(aa[i], minEven);
+					numEven++;
+				}else {
+					minOdd = Math.min(aa[i], minOdd);
+					numOdd++;
+				}
+				sum += aa[i];
+				long score = sum;
+				score += minEven*(n-numEven);
+				score += minOdd*(n-numOdd);				
+				best = Math.min(best, score);
+			}
+			System.out.println(best);
+			
+		}
+	}
+
+}
+","
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.InputMismatchException;
+import java.util.List;
+import java.util.Map.Entry;
+import java.util.TreeMap;
+
+public class Main {
+
+	public Main() throws FileNotFoundException {
+
+//		File file = Paths.get(""input.txt"").toFile();
+//		if (file.exists()) {
+//			System.setIn(new FileInputStream(file));
+//		}
+		long t = System.currentTimeMillis();
+
+		InputReader reader = new InputReader();
+
+		int ttt = reader.nextInt();
+
+		for (int tt = 0; tt < ttt; tt++) {
+			int n=reader.nextInt();
+			
+			long[] s=new long[n];
+			for(int i=0;i<n;i++) {
+				s[i]=reader.nextLong();
+			}
+			
+			long smallest1=s[0];
+			long smallest2=s[1];
+			long val=n*s[0]+n*s[1];
+			
+			int left1=n-1;
+			int left2=n-1;
+			long base=s[0]+s[1];
+			for(int i=2;i<n;i++) {
+				if(i%2==0) {
+					//left1
+					val=Math.min(val, base+left2*smallest2+left1*s[i]);
+					base+=s[i];
+					smallest1=Math.min(smallest1, s[i]);
+					left1--;
+				}else {
+					val=Math.min(val, base+left1*smallest1+left2*s[i]);
+					base+=s[i];
+					smallest2=Math.min(smallest2, s[i]);
+					left2--;
+					//left2
+				}
+			}
+			
+
+			System.out.println(val);
+		}
+
+	}
+
+	static class InputReader {
+		private byte[] buf = new byte[16384];
+		private int curChar;
+		private int numChars;
+
+		public int read() {
+			if (numChars == -1)
+				throw new InputMismatchException();
+			if (curChar >= numChars) {
+				curChar = 0;
+				try {
+					numChars = System.in.read(buf);
+				} catch (IOException e) {
+					throw new InputMismatchException();
+				}
+				if (numChars <= 0)
+					return -1;
+			}
+			return buf[curChar++];
+		}
+
+		public String nextLine() {
+			int c = read();
+			while (isSpaceChar(c))
+				c = read();
+			StringBuilder res = new StringBuilder();
+			do {
+				res.appendCodePoint(c);
+				c = read();
+			} while (!isEndOfLine(c));
+			return res.toString();
+		}
+
+		public String nextString() {
+			int c = read();
+			while (isSpaceChar(c))
+				c = read();
+			StringBuilder res = new StringBuilder();
+			do {
+				res.appendCodePoint(c);
+				c = read();
+			} while (!isSpaceChar(c));
+			return res.toString();
+		}
+
+		public long nextLong() {
+			int c = read();
+			while (isSpaceChar(c))
+				c = read();
+			int sgn = 1;
+			if (c == '-') {
+				sgn = -1;
+				c = read();
+			}
+			long res = 0;
+			do {
+				if (c < '0' || c > '9')
+					throw new InputMismatchException();
+				res *= 10;
+				res += c - '0';
+				c = read();
+			} while (!isSpaceChar(c));
+			return res * sgn;
+		}
+
+		public int nextInt() {
+			int c = read();
+			while (isSpaceChar(c))
+				c = read();
+			int sgn = 1;
+			if (c == '-') {
+				sgn = -1;
+				c = read();
+			}
+			int res = 0;
+			do {
+				if (c < '0' || c > '9')
+					throw new InputMismatchException();
+				res *= 10;
+				res += c - '0';
+				c = read();
+			} while (!isSpaceChar(c));
+			return res * sgn;
+		}
+
+		public int[] nextIntArray(int n) {
+			int[] arr = new int[n];
+			for (int i = 0; i < n; i++) {
+				arr[i] = nextInt();
+			}
+			return arr;
+		}
+
+		public long[] nextLongArray(int n) {
+			long[] arr = new long[n];
+			for (int i = 0; i < n; i++) {
+				arr[i] = nextLong();
+			}
+			return arr;
+		}
+
+		private boolean isSpaceChar(int c) {
+			return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
+		}
+
+		private boolean isEndOfLine(int c) {
+			return c == '\n' || c == '\r' || c == -1;
+		}
+
+	}
+
+	public static void main(String[] args) throws FileNotFoundException {
+		new Main();
+	}
+
+}
+",0
+a7e7f371,ad4c7a20,"
+import java.io.*;
+import java.util.*;
+
+
+public class cp {
+	static int mod=(int)1e9+7;
+	
+//	static  Reader sc=new Reader();
+	static FastReader sc=new FastReader(System.in);
+	static int[] sp;
+	static int size=(int)1e6;
+	static int[] arInt;
+	static long[] arLong;
+	public static void main(String[] args) throws IOException { 
+		long tc=sc.nextLong();
+//		Scanner sc=new Scanner(System.in);
+//			int tc=1;
+			
+//			primeSet=new HashSet<>();
+//			sieveOfEratosthenes((int)1e6+5);
+			while(tc-->0)
+			{
+				int n=sc.nextInt();
+				int k[]=new int[n];
+				int h[]=new int[n];
+				for(int i=0;i<n;i++)
+					k[i]=sc.nextInt();
+				for(int i=0;i<n;i++)
+					h[i]=sc.nextInt();
+				ArrayList<Pair> interval=new ArrayList<Pair>();
+				ArrayList<Pair> act=new ArrayList<Pair>();
+				for(int i=0;i<n;i++)
+					interval.add(new Pair(k[i]-h[i]+1,k[i]));
+				Collections.sort(interval);
+				// out.println(interval);
+				act.add(interval.get(0));
+				for(int i=1;i<n;i++)
+				{
+					Pair p=act.get(act.size()-1);
+					if(p.y<interval.get(i).x)
+						act.add(interval.get(i));
+					else
+						p.y=Math.max(p.y, interval.get(i).y);
+				}
+				// out.println(act);
+				long mana=0;
+				for(Pair p: act)
+				{
+					long x=p.y-p.x+1;
+					mana+=(x*(x+1))/2;
+				}
+				out.println(mana);
+				
+				
+				
+				
+				
+				
+				
+				
+				
+//				int n=sc.nextInt();
+//				long days[]=new long[n];
+//				long power[]=new long[n];
+//				for (int i = 0; i < power.length; i++) {
+//					days[i]=sc.nextLong();
+//				}
+//				for (int i = 0; i < power.length; i++) {
+//					power[i]=sc.nextLong();
+//					
+//				}
+//				
+//				long ans=0;
+//				for(int i=0;i<n;i++)
+//				{
+//					if(i==0)
+//					{
+//						ans+=power[i]*(power[i]+1L)/2L;
+//						continue;
+//					}
+//					
+//					long temp=power[i]*(power[i]+1)/2L;
+//					long temp2=(power[i-1]+days[i]-days[i-1])*(power[i-1]+days[i]-days[i-1]+1L)/2L;
+//					temp2-=power[i-1]*(power[i-1]+1L)/2L;
+//					ans+=Math.min(temp, temp2);
+////					if(days[i]-days[i-1]<=power[i])
+////					{
+////						ans+=power[i]*(power[i]+1)/2;
+////					}
+////					else {
+////						ans+=power[i]*(power[i]+1)/2;
+////						ans-=power[i-1]*(power[i-1]+1)/2;
+////					}
+//						
+//					
+//				}
+//				
+//				out.println(ans);
+			}
+			
+				
+			
+			
+			out.flush();
+			out.close();
+			System.gc();
+	
+	}
+	
+	
+	
+
+
+	/*
+	   ...SOLUTION ENDS HERE...........SOLUTION ENDS HERE...
+ */
+	
+	
+	static int util(char a,char b)
+	{
+		int A=a-'0';
+		int B=b-'0';
+		return A+B;
+	}
+	static boolean check(int x,int[] rich,int[] poor)
+	{
+		int cnt=0;
+		for(int i=0;i<rich.length;i++)
+		{
+			if(x-1-rich[i]<=cnt && cnt<=poor[i])
+				cnt++;
+		}
+		
+		return cnt>=x;
+	}
+	
+	static void arrInt(int n) throws IOException
+	{
+		arInt=new int[n];
+		for (int i = 0; i < arInt.length; i++) {
+			arInt[i]=sc.nextInt();
+		}
+	}
+	
+	static void arrLong(int n) throws IOException
+	{
+		arLong=new long[n];
+		for (int i = 0; i < arLong.length; i++) {
+			arLong[i]=sc.nextLong();
+		}
+	}
+	
+	
+	
+	static ArrayList<Integer> add(int id,int c)
+	{
+		ArrayList<Integer> newArr=new ArrayList<>();
+		for(int i=0;i<id;i++)
+			newArr.add(arInt[i]);
+		newArr.add(c);
+		for(int i=id;i<arInt.length;i++)
+		{
+			newArr.add(arInt[i]);
+		}
+		
+		
+		return newArr;
+	}
+
+	    // function to find last index <= y
+    static int upper(ArrayList<Integer> arr, int n, int y)
+    {
+        int l = 0, h = n - 1;
+        while (l <= h)
+        {
+            int mid = (l + h) / 2;
+            if (arr.get(mid) <= y)
+                l = mid + 1;
+            else
+                h = mid - 1;
+        }
+        return h;
+    }
+     
+	
+	
+	static int lower(ArrayList<Integer> arr, int n, int x)
+    {
+        int l = 0, h = n - 1;
+        while (l <= h)
+        {
+            int mid = (l + h) / 2;
+            if (arr.get(mid) >= x)
+                h = mid - 1;
+            else
+                l = mid + 1;
+        }
+        return l;
+    }
+          
+	
+	
+	
+	
+	static int N = 501; 
+	 
+	// Array to store inverse of 1 to N
+	static long[] factorialNumInverse = new long[N + 1];
+	 
+	// Array to precompute inverse of 1! to N!
+	static long[] naturalNumInverse = new long[N + 1];
+	 
+	// Array to store factorial of first N numbers
+	static long[] fact = new long[N + 1];
+	 
+	// Function to precompute inverse of numbers
+	public static void InverseofNumber(int p)
+	{
+	    naturalNumInverse[0] = naturalNumInverse[1] = 1;
+	     
+	    for(int i = 2; i <= N; i++)
+	        naturalNumInverse[i] = naturalNumInverse[p % i] *
+	                                 (long)(p - p / i) % p;
+	}
+	 
+	// Function to precompute inverse of factorials
+	public static void InverseofFactorial(int p)
+	{
+	    factorialNumInverse[0] = factorialNumInverse[1] = 1;
+	 
+	    // Precompute inverse of natural numbers
+	    for(int i = 2; i <= N; i++)
+	        factorialNumInverse[i] = (naturalNumInverse[i] *
+	                           factorialNumInverse[i - 1]) % p;
+	}
+	 
+	// Function to calculate factorial of 1 to N
+	public static void factorial(int p)
+	{
+	    fact[0] = 1;
+	 
+	    // Precompute factorials
+	    for(int i = 1; i <= N; i++)
+	    {
+	        fact[i] = (fact[i - 1] * (long)i) % p;
+	    }
+	}
+	 
+	// Function to return nCr % p in O(1) time
+	public static long Binomial(int N, int R, int p)
+	{
+	     
+	    // n C r = n!*inverse(r!)*inverse((n-r)!)
+	    long ans = ((fact[N] * factorialNumInverse[R]) %
+	                       p * factorialNumInverse[N - R]) % p;
+	     
+	    return ans;
+	}
+	
+	
+	static String tr(String s)
+	{
+		int now = 0;
+		while (now + 1 < s.length() && s.charAt(now)== '0')
+			++now;
+		return s.substring(now);
+	}
+	
+	 static ArrayList<Integer> ans;
+	static void dfs(int node,Graph gg,int cnt,int k,ArrayList<Integer> temp)
+	{
+		if(cnt==k)
+			return;
+		
+		for(Integer each:gg.list[node])
+		{
+			if(each==0)
+			{
+				temp.add(each);
+				ans=new ArrayList<>(temp);
+				temp.remove(temp.size()-1);
+				continue;
+			}
+			temp.add(each);
+			dfs(each,gg,cnt+1,k,temp);
+			temp.remove(temp.size()-1);
+			
+		}
+		
+		return;
+	}
+	
+	
+	static boolean isPrime(long n)
+    {
+        // Corner cases
+        if (n <= 1)
+            return false;
+        if (n <= 3)
+            return true;
+  
+        // This is checked so that we can skip
+        // middle five numbers in below loop
+        if (n % 2 == 0 || n % 3 == 0)
+            return false;
+  
+        for (int i = 5; i * i <= n; i = i + 6)
+            if (n % i == 0 || n % (i + 2) == 0)
+                return false;
+  
+        return true;
+    }
+	
+	
+	static ArrayList<Integer> commDiv(int a, int b)
+    {
+        // find gcd of a, b
+        int n = gcd(a, b);
+ 
+        // Count divisors of n.
+        ArrayList<Integer> Div=new ArrayList<>();
+        for (int i = 1; i <= Math.sqrt(n); i++) {
+            // if 'i' is factor of n
+            if (n % i == 0) {
+                // check if divisors are equal
+                if (n / i == i)
+                    Div.add(i);
+                else
+                {
+                	Div.add(i);
+                	Div.add(n/i);
+                }
+            }
+        }
+        return Div;
+    }
+	
+	static HashSet<Integer> factors(int x)
+	{
+		HashSet<Integer> a=new HashSet<Integer>();
+		for(int i=2;i*i<=x;i++)
+		{
+			if(x%i==0)
+			{
+				a.add(i);
+				a.add(x/i);
+			}
+		}
+		return a;
+	}
+		
+	
+static class Node
+{
+	int vertex;
+	HashSet<Node> adj;
+	boolean rem;
+	Node(int ver)
+	{
+		vertex=ver;
+		rem=false;
+		adj=new HashSet<Node>();
+	}
+	@Override
+	public String toString()
+	{
+		return vertex+"" "";
+	}
+}
+
+	static class Tuple{
+		int a;
+		int b;
+		int c;
+		public Tuple(int a,int b,int c) {
+			this.a=a;
+			this.b=b;
+			this.c=c;
+		}
+		
+	}
+
+	//function to find prime factors of n
+	static HashMap<Long,Long> findFactors(long n2)
+	{
+		HashMap<Long,Long> ans=new HashMap<>();
+		if(n2%2==0)
+		{
+			ans.put(2L, 0L);
+//			cnt++;
+			while((n2&1)==0)
+			{
+				n2=n2>>1;
+				ans.put(2L, ans.get(2L)+1);
+//				
+			}
+				
+		}
+		for(long i=3;i*i<=n2;i+=2)
+		{
+			if(n2%i==0)
+			{
+				ans.put((long)i, 0L);
+//				cnt++;
+				while(n2%i==0)
+				{
+					n2=n2/i;
+					ans.put((long)i, ans.get((long)i)+1);
+					
+				}
+			}
+		}
+		if(n2!=1)
+		{
+			ans.put(n2, ans.getOrDefault(n2, (long) 0)+1);
+			
+		}
+			
+		return ans;
+	}
+	
+
+	//fenwick tree implementaion
+	static class fwt
+	{
+		int n;
+		long BITree[];
+		fwt(int n)
+		{
+			this.n=n;
+			BITree=new long[n+1];
+		}
+		
+		fwt(int arr[], int n)
+		{
+			this.n=n;
+			BITree=new long[n+1];
+			for(int i = 0; i < n; i++)
+			updateBIT(n, i, arr[i]);
+		 }
+		
+		   long getSum(int index)
+		   {
+		       long sum = 0;
+		       index = index + 1;
+		       while(index>0)
+		       {
+		           sum += BITree[index];
+		           index -= index & (-index);
+		       }
+		       return sum;
+		   }
+		   void updateBIT(int n, int index,int val)
+		   {
+		       index = index + 1;
+		       while(index <= n)
+		       {
+		       BITree[index] += val;
+		       index += index & (-index);
+		       }
+		   }
+		   void print()
+		   {
+			    for(int i=0;i<n;i++)
+			    out.print(getSum(i)+"" "");
+			    out.println();
+		   }
+	}
+
+	
+	class sparseTable{
+	int n;
+	long[][]dp;
+	int log2[];
+	int P;
+	
+	void buildTable(long[] arr)
+	{
+		n=arr.length;
+		P=(int)Math.floor(Math.log(n)/Math.log(2));
+		
+		log2=new int[n+1];
+		log2[0]=log2[1]=0;
+		for(int i=2;i<=n;i++)
+		{
+			log2[i]=log2[i/2]+1;
+		}
+		dp=new long[P+1][n];
+		for(int i=0;i<n;i++)
+		{
+			dp[0][i]=arr[i];
+		}
+		
+		for(int p=1;p<=P;p++)
+		{
+			for(int i=0;i+(1<<p)<=n;i++)
+			{
+				long left=dp[p-1][i];
+				long right=dp[p-1][i+(1<<(p-1))];
+				dp[p][i]=Math.max(left, right);
+			}
+		}
+	}
+	
+	
+	long maxQuery(int l,int r)
+	{
+		int len=r-l+1;
+		int p=(int)Math.floor(log2[len]);
+		long left=dp[p][l];
+		long right=dp[p][r-(1<<p)+1];
+		return Math.max(left, right);
+	}
+}
+
+	
+	
+	
+	//Function to find number of set bits
+	static int setBitNumber(long n)
+    {
+        if (n == 0)
+            return 0;
+ 
+        int msb = 0;
+        n = n / 2;
+ 
+        while (n != 0) {
+            n = n / 2;
+            msb++;
+        }
+ 
+        return msb;
+    }
+ 
+	
+	
+	static int getFirstSetBitPos(long n)
+    {
+        return (int)((Math.log10(n & -n)) / Math.log10(2)) + 1;
+    }
+	
+	
+	static ArrayList<Integer> primes;
+	static HashSet<Integer> primeSet;
+	static boolean prime[];
+	static void sieveOfEratosthenes(int n)
+    {
+        // Create a boolean array
+        // ""prime[0..n]"" and
+        // initialize all entries
+        // it as true. A value in
+        // prime[i] will finally be
+        // false if i is Not a
+        // prime, else true.
+       prime= new boolean[n + 1];
+        for (int i = 2; i <= n; i++)
+            prime[i] = true;
+        
+        for (int p = 2; p * p <= n; p++)
+        {
+            // If prime[p] is not changed, then it is a
+            // prime
+            if (prime[p] == true)
+            {
+                // Update all multiples of p
+                for (int i = p * p; i <= n; i += p)
+                    prime[i] = false;
+            }
+        }
+ 
+        // Print all prime numbers
+        for (int i = 2; i <= n; i++)
+        {
+            if (prime[i] == true)
+               primeSet.add(i);
+        }
+    }
+	
+	
+	
+	static long mod(long a, long b) {
+		  long c = a % b;
+		  return (c < 0) ? c + b : c;
+		}
+	
+	static void swap(long arr[],int i,int j)
+	{
+		long temp=arr[i];
+		arr[i]=arr[j];
+		arr[j]=temp;
+	}
+
+	
+	
+	static boolean util(int a,int b,int c)
+	{
+		if(b>a)util(b, a, c);
+		
+		while(c>=a)
+		{
+			c-=a;
+			if(c%b==0)
+				return true;
+		}
+		
+		
+		return (c%b==0);
+	}
+	
+	
+	
+	static void flag(boolean flag)
+	   {
+	       out.println(flag ? ""YES"" : ""NO"");
+	       out.flush();
+	   }
+	  
+	
+	static void print(int a[])
+	  {
+	     int n=a.length;
+	     for(int i=0;i<n;i++)
+	       {
+	          out.print(a[i]+"" "");
+	       }
+	     out.println();
+	     out.flush();
+	  }
+	static void print(long a[])
+	  {
+	     int n=a.length;
+	     for(int i=0;i<n;i++)
+	       {
+	          out.print(a[i]+"" "");
+	       }
+	     out.println();
+	     out.flush();
+	  } 
+	static void print_int(ArrayList<Integer> al)
+	  {
+	     int si=al.size();
+	     for(int i=0;i<si;i++)
+	       {
+	          out.print(al.get(i)+"" "");
+	       }
+	     out.println();
+	     out.flush();
+	  }
+	static void print_long(ArrayList<Long> al)
+	  {
+	     int si=al.size();
+	     for(int i=0;i<si;i++)
+	       {
+	          out.print(al.get(i)+"" "");
+	       }
+	     out.println();
+	     out.flush();
+	  }
+	  
+	static void printYesNo(boolean condition)
+	{
+		if (condition) {
+			out.println(""YES"");
+		}
+		else {
+			out.println(""NO"");
+		}
+	}
+	
+	
+	static int LowerBound(int a[], int x) 
+	 { // x is the target value or key
+	  int l=-1,r=a.length;
+	  while(l+1<r) {
+	    int m=(l+r)>>>1;
+	    if(a[m]>=x) r=m;
+	    else l=m;
+	  }
+	  return r;
+	}
+	
+	
+	static int lowerIndex(int arr[], int n, int x)
+    {
+        int l = 0, h = n - 1;
+        while (l <= h)
+        {
+            int mid = (l + h) / 2;
+            if (arr[mid] >= x)
+                h = mid - 1;
+            else
+                l = mid + 1;
+        }
+        return l;
+    }
+	
+	
+	    // function to find last index <= y
+    static int upperIndex(int arr[], int n, int y)
+    {
+        int l = 0, h = n - 1;
+        while (l <= h)
+        {
+            int mid = (l + h) / 2;
+            if (arr[mid] <= y)
+                l = mid + 1;
+            else
+                h = mid - 1;
+        }
+        return h;
+    }
+    static int upperIndex(long arr[], int n, long y)
+    {
+    	int l = 0, h = n - 1;
+    	while (l <= h)
+    	{
+    		int mid = (l + h) / 2;
+    		if (arr[mid] <= y)
+    			l = mid + 1;
+    		else
+    			h = mid - 1;
+    	}
+    	return h;
+    }
+     
+	
+	 static int UpperBound(int a[], int x)
+	  {// x is the key or target value
+	    int l=-1,r=a.length;
+	    while(l+1<r) {
+	       int m=(l+r)>>>1;
+	       if(a[m]<=x) l=m;
+	       else r=m;
+	    }
+	    return l+1;
+	 }
+	 static int UpperBound(long a[], long x)
+	 {// x is the key or target value
+		 int l=-1,r=a.length;
+		 while(l+1<r) {
+			 int m=(l+r)>>>1;
+	       if(a[m]<=x) l=m;
+	       else r=m;
+		 }
+		 return l+1;
+	 }
+	
+	 
+	 static class DisjointUnionSets
+	 {
+	    int[] rank, parent;
+	    int n;
+	    // Constructor
+	    public DisjointUnionSets(int n)
+	    {
+	        rank = new int[n];
+	        parent = new int[n];
+	        this.n = n;
+	        makeSet();
+	    }
+	    // Creates n sets with single item in each
+	    void makeSet()
+	    {
+	        for (int i = 0; i < n; i++)
+	            parent[i] = i;
+	    }
+	    int find(int x)
+	    {
+	        if (parent[x] != x) {
+	            parent[x] = find(parent[x]);
+	        }
+	        return parent[x];
+	    }
+	    // Unites the set that includes x and the set
+	    // that includes x
+	    void union(int x, int y)
+	    {
+	        int xRoot = find(x), yRoot = find(y);
+	        if (xRoot == yRoot)
+	            return;
+	        if (rank[xRoot] < rank[yRoot])
+	            parent[xRoot] = yRoot;
+	        else if (rank[yRoot] < rank[xRoot])
+	         parent[yRoot] = xRoot;
+	        else // if ranks are the same
+	        {
+	         parent[yRoot] = xRoot;
+	            rank[xRoot] = rank[xRoot] + 1;
+	        }
+	        
+//	        if(xRoot!=yRoot)
+//	        	parent[y]=x;
+	    }
+	    
+	    int connectedComponents()
+	    {
+	    	int cnt=0;
+	    	for(int i=0;i<n;i++)
+	    	{
+	    		if(parent[i]==i)
+	    			cnt++;
+	    	}
+	    	return cnt;
+	    }
+	 }
+
+	 
+
+	 
+	 
+	static class Graph
+	  {
+	        int v;
+	        ArrayList<Integer> list[];
+	        Graph(int v)
+	        {
+	            this.v=v;
+	            list=new ArrayList[v+1];
+	            for(int i=1;i<=v;i++)
+	                list[i]=new ArrayList<Integer>();
+	        }
+	        void addEdge(int a, int b)
+	        {
+	            this.list[a].add(b);
+	        }
+	    }
+	
+	
+	
+//	static class GraphMap{
+//		Map<String,ArrayList<String>> graph;
+//		GraphMap() {
+//			// TODO Auto-generated constructor stub
+//			graph=new HashMap<String,ArrayList<String>>();
+//			
+//		}
+//		void addEdge(String a,String b)
+//		{
+//			if(graph.containsKey(a))
+//			this.graph.get(a).add(b);
+//			else {
+//				this.graph.put(a, new ArrayList<>());
+//				this.graph.get(a).add(b);
+//			}
+//		}
+//	}
+//	static void dfsMap(GraphMap g,HashSet<String> vis,String src,int ok)
+//	{
+//		vis.add(src);
+//		
+//		if(g.graph.get(src)!=null)
+//		{
+//			for(String each:g.graph.get(src))
+//			{
+//				if(!vis.contains(each))
+//				{
+//					dfsMap(g, vis, each, ok+1);
+//				}
+//			}
+//		}
+//		
+//		cnt=Math.max(cnt, ok);
+//	}
+	static double sum[];
+	static long cnt;
+//	static void DFS(Graph g, boolean[] visited, int u)
+//		{
+//	        visited[u]=true;
+//	        
+//	        for(int i=0;i<g.list[u].size();i++)
+//	        {
+//	            int v=g.list[u].get(i);
+//	            
+//	            if(!visited[v])
+//	            {
+//	            	cnt1=cnt1*2;
+//	            	DFS(g, visited, v);
+//	            
+//	            }
+//	            
+//	        }
+//	       
+//
+//	  } 
+	
+	
+	  
+	 static class Pair implements Comparable<Pair>
+	    {
+	       int x;
+	       int y;
+	       Pair(int x,int y)
+	        {
+	           this.x=x;
+	           this.y=y;
+	          
+	        }
+		@Override
+		public int compareTo(Pair o) {
+			// TODO Auto-generated method stub
+			return this.x-o.x;
+		}
+	       
+	       
+	       
+	    }
+	   
+	static long sum_array(int a[])
+	 {
+	    int n=a.length;
+	    long sum=0;
+	    for(int i=0;i<n;i++)
+	     sum+=a[i];
+	    return sum;
+	 }
+	static long sum_array(long a[])
+	 {
+	    int n=a.length;
+	    long sum=0;
+	    for(int i=0;i<n;i++)
+	     sum+=a[i];
+	    return sum;
+	 }
+
+	 static void sort(int[] a) 
+	   {
+			ArrayList<Integer> l=new ArrayList<>();
+			for (int i:a) l.add(i);
+			Collections.sort(l);
+			for (int i=0; i<a.length; i++) a[i]=l.get(i);
+		}
+	static void sort(long[] a) 
+	   {
+			ArrayList<Long> l=new ArrayList<>();
+			for (long i:a) l.add(i);
+			Collections.sort(l);
+			for (int i=0; i<a.length; i++) a[i]=l.get(i);
+		}
+
+	static void reverse_array(int a[])
+	 {
+	    int n=a.length;
+	    int i,t; 
+	    for (i = 0; i < n / 2; i++) { 
+	            t = a[i]; 
+	            a[i] = a[n - i - 1]; 
+	            a[n - i - 1] = t; 
+	        } 
+	 }
+	static void reverse_array(long a[])
+	 {
+	    int n=a.length;
+	    int i; long t; 
+	    for (i = 0; i < n / 2; i++) { 
+	            t = a[i]; 
+	            a[i] = a[n - i - 1]; 
+	            a[n - i - 1] = t; 
+	        } 
+	 }
+//	 static long modInverse(long a, long m)
+//		    {
+//		        long g = gcd(a, m);
+//		       
+//		          return   power(a, m - 2, m);
+//		        
+//		    }
+	static long power(long x, long y)
+	 {
+	   long res = 1;
+	   x = x % mod;
+	   if (x == 0)
+	     return 0;
+	   while (y > 0)
+	   {
+	    if ((y & 1) != 0)
+	    res = (res * x) % mod;
+	   
+	    y = y >> 1; // y = y/2
+	    x = (x * x) % mod;
+	   }
+	   return res;
+	 }
+	static int power(int x, int y)
+	{
+		int res = 1;
+		x = x % mod;
+		if (x == 0)
+			return 0;
+		while (y > 0)
+		{
+			if ((y & 1) != 0)
+				res = (res * x) % mod;
+			
+			y = y >> 1; // y = y/2
+	    x = (x * x) % mod;
+		}
+		return res;
+	}
+	static long gcd(long a, long b) 
+	    { 
+			
+	        if (a == 0) 
+	            return b; 
+	         //cnt+=a/b;
+	        return gcd(b%a,a); 
+	    } 
+	static int gcd(int a, int b) 
+	    { 
+	        if (a == 0) 
+	            return b; 
+	          
+	        return gcd(b%a, a); 
+	    } 
+
+	   static class FastReader{
+	 
+	        byte[] buf = new byte[2048];
+	        int index, total;
+	        InputStream in;
+	 
+	        FastReader(InputStream is) {
+	            in = is;
+	        }
+	 
+	        int scan() throws IOException {
+	            if (index >= total) {
+	                index = 0;
+	                total = in.read(buf);
+	                if (total <= 0) {
+	                    return -1;
+	                }
+	            }
+	            return buf[index++];
+	        }
+	 
+	        String next() throws IOException {
+	            int c;
+	            for (c = scan(); c <= 32; c = scan());
+	            StringBuilder sb = new StringBuilder();
+	            for (; c > 32; c = scan()) {
+	                sb.append((char) c);
+	            }
+	            return sb.toString();
+	        }
+	 
+	        int nextInt() throws IOException {
+	            int c, val = 0;
+	            for (c = scan(); c <= 32; c = scan());
+	            boolean neg = c == '-';
+	            if (c == '-' || c == '+') {
+	                c = scan();
+	            }
+	            for (; c >= '0' && c <= '9'; c = scan()) {
+	                val = (val << 3) + (val << 1) + (c & 15);
+	            }
+	            return neg ? -val : val;
+	        }
+	 
+	        long nextLong() throws IOException {
+	            int c;
+	            long val = 0;
+	            for (c = scan(); c <= 32; c = scan());
+	            boolean neg = c == '-';
+	            if (c == '-' || c == '+') {
+	                c = scan();
+	            }
+	            for (; c >= '0' && c <= '9'; c = scan()) {
+	                val = (val << 3) + (val << 1) + (c & 15);
+	            }
+	            return neg ? -val : val;
+	        }
+	    }
+	   
+	    static class Reader 
+	    { 
+	        final private int BUFFER_SIZE = 1 << 16; 
+	        private DataInputStream din; 
+	        private byte[] buffer; 
+	        private int bufferPointer, bytesRead; 
+	  
+	        public Reader() 
+	        { 
+	            din = new DataInputStream(System.in); 
+	            buffer = new byte[BUFFER_SIZE]; 
+	            bufferPointer = bytesRead = 0; 
+	        } 
+	  
+	        public Reader(String file_name) throws IOException 
+	        { 
+	            din = new DataInputStream(new FileInputStream(file_name)); 
+	            buffer = new byte[BUFFER_SIZE]; 
+	            bufferPointer = bytesRead = 0; 
+	        } 
+	  
+	        public String readLine() throws IOException 
+	        { 
+	            byte[] buf = new byte[64]; // line length 
+	            int cnt = 0, c; 
+	            while ((c = read()) != -1) 
+	            { 
+	                if (c == '\n') 
+	                    break; 
+	                buf[cnt++] = (byte) c; 
+	            } 
+	            return new String(buf, 0, cnt); 
+	        } 
+	  
+	        public int nextInt() throws IOException 
+	        { 
+	            int ret = 0; 
+	            byte c = read(); 
+	            while (c <= ' ') 
+	                c = read(); 
+	            boolean neg = (c == '-'); 
+	            if (neg) 
+	                c = read(); 
+	            do
+	            { 
+	                ret = ret * 10 + c - '0'; 
+	            }  while ((c = read()) >= '0' && c <= '9'); 
+	  
+	            if (neg) 
+	                return -ret; 
+	            return ret; 
+	        } 
+	  
+	        public long nextLong() throws IOException 
+	        { 
+	            long ret = 0; 
+	            byte c = read(); 
+	            while (c <= ' ') 
+	                c = read(); 
+	            boolean neg = (c == '-'); 
+	            if (neg) 
+	                c = read(); 
+	            do { 
+	                ret = ret * 10 + c - '0'; 
+	            } 
+	            while ((c = read()) >= '0' && c <= '9'); 
+	            if (neg) 
+	                return -ret; 
+	            return ret; 
+	        } 
+	  
+	        public double nextDouble() throws IOException 
+	        { 
+	            double ret = 0, div = 1; 
+	            byte c = read(); 
+	            while (c <= ' ') 
+	                c = read(); 
+	            boolean neg = (c == '-'); 
+	            if (neg) 
+	                c = read(); 
+	  
+	            do { 
+	                ret = ret * 10 + c - '0'; 
+	            } 
+	            while ((c = read()) >= '0' && c <= '9'); 
+	  
+	            if (c == '.') 
+	            { 
+	                while ((c = read()) >= '0' && c <= '9') 
+	                { 
+	                    ret += (c - '0') / (div *= 10); 
+	                } 
+	            } 
+	  
+	            if (neg) 
+	                return -ret; 
+	            return ret; 
+	        } 
+	  
+	        private void fillBuffer() throws IOException 
+	        { 
+	            bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE); 
+	            if (bytesRead == -1) 
+	                buffer[0] = -1; 
+	        } 
+	  
+	        private byte read() throws IOException 
+	        { 
+	            if (bufferPointer == bytesRead) 
+	                fillBuffer(); 
+	            return buffer[bufferPointer++]; 
+	        } 
+	  
+	        public void close() throws IOException 
+	        { 
+	            if (din == null) 
+	                return; 
+	            din.close(); 
+	        } 
+	    }
+	  static  PrintWriter out=new PrintWriter(System.out);
+	  static int int_max=Integer.MAX_VALUE;
+	  static int int_min=Integer.MIN_VALUE;
+	  static long long_max=Long.MAX_VALUE;
+	  static long long_min=Long.MIN_VALUE;
+
+}
+
+
+
+
+","import java.io.*;
+import java.util.*;
+
+
+public class Practice
+{
+//	static final long mod=7420738134811L;
+	static int mod=1000000007;
+	static final int size=501;
+	static FastReader sc=new FastReader(System.in);
+//	static Reader sc=new Reader();
+//	static Scanner sc=new Scanner(System.in);
+	static  PrintWriter out=new PrintWriter(System.out);
+	static long[] factorialNumInverse;
+	static long[] naturalNumInverse;	
+	static int[] sp;
+	static long[] fact;
+	static ArrayList<Integer> pr;
+	public static void main(String[] args) throws IOException, CloneNotSupportedException
+	{
+//		System.setIn(new FileInputStream(""input.txt""));
+//		System.setOut(new PrintStream(""output.txt""));
+//		factorial(mod);
+//		InverseofNumber(mod);
+//		InverseofFactorial(mod);
+//		make_seive();
+		int t=1;
+		t=sc.nextInt();
+		for(int i=1;i<=t;i++)
+			solve(i);
+		out.close();
+		out.flush();
+//		System.out.flush();
+//		System.exit(0);
+	}
+	
+	static void solve(int CASENO) throws IOException, CloneNotSupportedException
+	{
+		int n=sc.nextInt();
+		int k[]=new int[n];
+		int h[]=new int[n];
+		for(int i=0;i<n;i++)
+			k[i]=sc.nextInt();
+		for(int i=0;i<n;i++)
+			h[i]=sc.nextInt();
+		ArrayList<Pair> interval=new ArrayList<Pair>();
+		ArrayList<Pair> act=new ArrayList<Pair>();
+		for(int i=0;i<n;i++)
+			interval.add(new Pair(k[i]-h[i]+1,k[i]));
+		Collections.sort(interval);
+//		out.println(interval);
+		act.add(interval.get(0).clone());
+		for(int i=1;i<n;i++)
+		{
+			Pair p=act.get(act.size()-1);
+			if(p.y<interval.get(i).x)
+				act.add(interval.get(i).clone());
+			else
+				p.y=Math.max(p.y, interval.get(i).y);
+		}
+//		out.println(act);
+		long mana=0;
+		for(Pair p: act)
+		{
+			long x=p.y-p.x+1;
+			mana+=(x*(x+1))/2;
+		}
+		out.println(mana);
+	}
+	static class Pair implements Cloneable, Comparable<Pair>
+	{
+		int x,y;
+		Pair(int a,int b)
+		{
+			this.x=a;
+			this.y=b;
+		}
+		@Override
+		public boolean equals(Object obj) 
+		{
+			if(obj instanceof  Pair)
+			{
+				Pair p=(Pair)obj;
+				return p.x==this.x && p.y==this.y;
+			}
+			return false;
+		}
+		@Override
+		public int hashCode() 
+		{
+			return Math.abs(x)+500*Math.abs(y);
+		}
+		@Override
+		public String toString() 
+		{
+			return ""(""+x+"" ""+y+"")"";
+		}
+		@Override
+		protected Pair clone() throws CloneNotSupportedException {
+			return new Pair(this.x,this.y);
+		}
+		@Override
+		public int compareTo(Pair a) 
+		{
+			long t=(this.x-a.x);
+			if(t!=0)
+				return t>0?1:-1;
+			else
+				return (int)(this.y-a.y);
+		}
+		public void swap()
+		{
+			this.y=this.y+this.x;
+			this.x=this.y-this.x;
+			this.y=this.y-this.x;			
+		}
+	}
+	static class Tuple implements Cloneable, Comparable<Tuple>
+	{
+		int x,y,z;
+		Tuple(int a,int b,int c)
+		{
+			this.x=a;
+			this.y=b;
+			this.z=c;
+		}
+		public boolean equals(Object obj) 
+		{
+			if(obj instanceof  Tuple)
+			{
+				Tuple p=(Tuple)obj;
+				return p.x==this.x && p.y==this.y && p.z==this.z;
+			}
+			return false;
+		}
+		@Override
+		public int hashCode() 
+		{
+			return (this.x+501*this.y);
+		}
+		@Override
+		public String toString() 
+		{
+			return ""(""+x+"",""+y+"",""+z+"")"";
+		}
+		@Override
+		protected Tuple clone() throws CloneNotSupportedException {
+			return new Tuple(this.x,this.y,this.z);
+		}
+		@Override
+		public int compareTo(Tuple a) 
+		{
+			int x=this.z-a.z;
+			if(x!=0)
+				return x;
+			int X= this.x-a.x;
+			if(X!=0)
+				return X;
+			return a.y-this.y;
+		}
+	}
+	static void arraySort(int arr[])
+	{
+		ArrayList<Integer> a=new ArrayList<Integer>();
+		for (int i = 0; i < arr.length; i++) {
+			a.add(arr[i]);
+		}
+		Collections.sort(a,Comparator.reverseOrder());
+		for (int i = 0; i < arr.length; i++) {
+			arr[i]=a.get(i);
+		}
+	}
+	static void arraySort(long arr[])
+	{
+		ArrayList<Long> a=new ArrayList<Long>();
+		for (int i = 0; i < arr.length; i++) {
+			a.add(arr[i]);
+		}
+		Collections.sort(a);
+		for (int i = 0; i < arr.length; i++) {
+			arr[i]=a.get(i);
+		}
+	}
+	static HashSet<Integer> primeFactors(int n)
+	{
+		HashSet<Integer> ans=new HashSet<Integer>();
+		if(n%2==0)
+		{
+			ans.add(2);
+			while((n&1)==0)
+				n=n>>1;
+		}
+		for(int i=3;i*i<=n;i+=2)
+		{
+			if(n%i==0)
+			{
+				ans.add(i);
+				while(n%i==0)
+					n=n/i;
+			}
+		}
+		if(n!=1)
+			ans.add(n);
+		return ans;
+	}
+	static void make_seive()
+	{
+		sp=new int[size];
+		pr=new ArrayList<Integer>();
+		for (int i=2; i<size; ++i) {
+		    if (sp[i] == 0) {
+		        sp[i] = i;
+		        pr.add(i);
+		    }
+		    for (int j=0; j<(int)pr.size() && pr.get(j)<=sp[i] && i*pr.get(j)<size; ++j)
+		        sp[i * pr.get(j)] = pr.get(j);
+		}
+	}
+	public static void InverseofNumber(int p)
+	{
+		naturalNumInverse=new long[size];
+	    naturalNumInverse[0] = naturalNumInverse[1] = 1;
+	    for(int i = 2; i < size; i++)
+	        naturalNumInverse[i] = naturalNumInverse[p % i] * (long)(p - p / i) % p;
+	}
+	// Function to precompute inverse of factorials
+	public static void InverseofFactorial(int p)
+	{
+		factorialNumInverse=new long[size];
+	    factorialNumInverse[0] = factorialNumInverse[1] = 1;
+	    // pre-compute inverse of natural numbers
+	    for(int i = 2; i < size; i++)
+	        factorialNumInverse[i] = (naturalNumInverse[i] * factorialNumInverse[i - 1]) % p;
+	}
+	// Function to calculate factorial of 1 to 200001
+	public static void factorial(int p)
+	{
+		fact=new long[size];
+	    fact[0] = 1;
+	    for(int i = 1; i < size; i++)
+	        fact[i] = (fact[i - 1] * (long)i) % p;
+	}
+	 
+	// Function to return nCr % p in O(1) time
+	public static long Binomial(int N, int R)
+	{
+		if(R<0)
+			return 1;
+	    // n C r = n!*inverse(r!)*inverse((n-r)!)
+	    long ans = ((fact[N] * factorialNumInverse[R]) % mod * factorialNumInverse[N - R]) % mod;
+	    return ans;
+	}
+	static int findXOR(int x)	//from 0 to x
+	{
+		if(x<0)
+			return 0;
+		if(x%4==0)
+			return x;
+		if(x%4==1)
+			return 1;
+		if(x%4==2)
+			return x+1;
+		return 0;
+	}
+	static boolean isPrime(long x)
+	{
+		if(x==1)
+			return false;
+		if(x<=3)
+			return true;
+		if(x%2==0 || x%3==0)
+			return false;
+		for(int i=5;i<=Math.sqrt(x);i+=2)
+			if(x%i==0)
+				return false;
+		return true;
+	}
+	static long gcd(long a,long b)
+	{
+		return (b==0)?a:gcd(b,a%b);
+	}
+	static int gcd(int a,int b)
+	{
+		return (b==0)?a:gcd(b,a%b);
+	}
+	static class Node
+	{
+		int vertex,dis;
+		HashSet<Node> adj;
+		Node(int ver)
+		{
+			vertex=ver;
+			dis=-1;
+			adj=new HashSet<Node>();
+		}
+		@Override
+		public String toString() 
+		{
+			return vertex+"" "";
+		}
+	}
+	static class Edge
+	{
+		Node to;
+		int cost;
+		Edge(Node t,int c)
+		{
+			this.to=t;
+			this.cost=c;
+		}
+		@Override
+		public String toString() {
+			return ""(""+to.vertex+"",""+cost+"") "";
+		}
+	}
+	static long power(long x, long y)
+	  {
+		if(x<=0)
+			return 1;
+	    long res = 1; 
+	    x = x % mod; 
+	    if (x == 0)
+	      return 0; 
+	    while (y > 0)
+	    {
+	    	if ((y & 1) != 0)
+	    		res = (res * x) % mod;
+	    	
+	    	y = y >> 1; // y = y/2
+	    	x = (x * x) % mod;
+	    }
+	    return res%mod;
+	  }
+	static long binomialCoeff(long n, long k)
+    {
+		if(n<k)
+			return 0;
+        long res = 1;
+        // Since C(n, k) = C(n, n-k)
+        if (k > n - k)
+            k = n - k;
+ 
+        // Calculate value of
+        // [n * (n-1) *---* (n-k+1)] / [k * (k-1) *----* 1]
+        for (long i = 0; i < k; ++i) {
+            res *= (n - i);
+            res /= (i + 1);
+        }
+ 
+        return res;
+    }
+	static class FastReader
+	{
+        byte[] buf = new byte[2048];
+        int index, total;
+        InputStream in;
+ 
+        FastReader(InputStream is) 
+        {
+            in = is;
+        }
+ 
+        int scan() throws IOException 
+        {
+            if (index >= total) {
+                index = 0;
+                total = in.read(buf);
+                if (total <= 0) {
+                    return -1;
+                }
+            }
+            return buf[index++];
+        }
+ 
+        String next() throws IOException 
+        {
+            int c;
+            for (c = scan(); c <= 32; c = scan());
+            StringBuilder sb = new StringBuilder();
+            for (; c > 32; c = scan()) {
+                sb.append((char) c);
+            }
+            return sb.toString();
+        }
+ 
+        int nextInt() throws IOException 
+        {
+            int c, val = 0;
+            for (c = scan(); c <= 32; c = scan());
+            boolean neg = c == '-';
+            if (c == '-' || c == '+') {
+                c = scan();
+            }
+            for (; c >= '0' && c <= '9'; c = scan()) {
+                val = (val << 3) + (val << 1) + (c & 15);
+            }
+            return neg ? -val : val;
+        }
+ 
+        long nextLong() throws IOException 
+        {
+            int c;
+            long val = 0;
+            for (c = scan(); c <= 32; c = scan());
+            boolean neg = c == '-';
+            if (c == '-' || c == '+') {
+                c = scan();
+            }
+            for (; c >= '0' && c <= '9'; c = scan()) {
+                val = (val << 3) + (val << 1) + (c & 15);
+            }
+            return neg ? -val : val;
+        }
+    }
+	static class Reader 
+	{
+        final private int BUFFER_SIZE = 1 << 16;
+        private DataInputStream din;
+        private byte[] buffer;
+        private int bufferPointer, bytesRead;
+ 
+        public Reader()
+        {
+            din = new DataInputStream(System.in);
+            buffer = new byte[BUFFER_SIZE];
+            bufferPointer = bytesRead = 0;
+        }
+ 
+        public Reader(String file_name) throws IOException
+        {
+            din = new DataInputStream(
+                new FileInputStream(file_name));
+            buffer = new byte[BUFFER_SIZE];
+            bufferPointer = bytesRead = 0;
+        }
+ 
+        public String readLine() throws IOException
+        {
+            byte[] buf = new byte[64]; // line length
+            int cnt = 0, c;
+            while ((c = read()) != -1) {
+                if (c == '\n') {
+                    if (cnt != 0) {
+                        break;
+                    }
+                    else {
+                        continue;
+                    }
+                }
+                buf[cnt++] = (byte)c;
+            }
+            return new String(buf, 0, cnt);
+        }
+ 
+        public int nextInt() throws IOException
+        {
+            int ret = 0;
+            byte c = read();
+            while (c <= ' ') {
+                c = read();
+            }
+            boolean neg = (c == '-');
+            if (neg)
+                c = read();
+            do {
+                ret = ret * 10 + c - '0';
+            } while ((c = read()) >= '0' && c <= '9');
+ 
+            if (neg)
+                return -ret;
+            return ret;
+        }
+ 
+        public long nextLong() throws IOException
+        {
+            long ret = 0;
+            byte c = read();
+            while (c <= ' ')
+                c = read();
+            boolean neg = (c == '-');
+            if (neg)
+                c = read();
+            do {
+                ret = ret * 10 + c - '0';
+            } while ((c = read()) >= '0' && c <= '9');
+            if (neg)
+                return -ret;
+            return ret;
+        }
+ 
+        public double nextDouble() throws IOException
+        {
+            double ret = 0, div = 1;
+            byte c = read();
+            while (c <= ' ')
+                c = read();
+            boolean neg = (c == '-');
+            if (neg)
+                c = read();
+ 
+            do {
+                ret = ret * 10 + c - '0';
+            } while ((c = read()) >= '0' && c <= '9');
+ 
+            if (c == '.') {
+                while ((c = read()) >= '0' && c <= '9') {
+                    ret += (c - '0') / (div *= 10);
+                }
+            }
+ 
+            if (neg)
+                return -ret;
+            return ret;
+        }
+ 
+        private void fillBuffer() throws IOException
+        {
+            bytesRead = din.read(buffer, bufferPointer = 0,
+                                 BUFFER_SIZE);
+            if (bytesRead == -1)
+                buffer[0] = -1;
+        }
+ 
+        private byte read() throws IOException
+        {
+            if (bufferPointer == bytesRead)
+                fillBuffer();
+            return buffer[bufferPointer++];
+        }
+ 
+        public void close() throws IOException
+        {
+            if (din == null)
+                return;
+            din.close();
+        }
+        public void printarray(int arr[])
+        {
+        	for (int i = 0; i < arr.length; i++)
+				System.out.print(arr[i]+"" "");
+        	System.out.println();
+        }
+    }
+}
+
+
+
+
+
+
+
+",1
+3d06b643,db7f80a5,"import java.io.*;
+import java.util.*;
+
+public class ArmChairs {
+    
+
+    public static int solution(int n, int[] arr) {
+
+        ArrayList<Integer> one = new ArrayList<Integer>();
+        ArrayList<Integer> zero = new ArrayList<Integer>();
+
+        for (int i = 0; i < n; i++) {
+            if (arr[i] == 1) {
+                one.add(i);
+            } else {
+                zero.add(i);
+            }
+        }
+
+        int[][] dp = new int[one.size() + 1][zero.size() + 1];
+
+        for (int i = 1; i <= one.size(); i++) {
+            dp[i][i] = dp[i - 1][i - 1] + Math.abs(one.get(i - 1) - zero.get(i - 1));
+            for (int j = i + 1; j <= zero.size(); j++) {
+                dp[i][j] = Math.min(dp[i][j - 1], dp[i - 1][j - 1] + Math.abs(one.get(i - 1) - zero.get(j - 1)));
+            }
+        }
+
+        return dp[one.size()][zero.size()];
+    }
+
+
+    public static void main(String[] args) throws IOException{
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        BufferedWriter log = new BufferedWriter(new OutputStreamWriter(System.out));
+
+        int n = Integer.parseInt(br.readLine());
+
+        String[] s = br.readLine().split("" "");
+        int[] arr = new int[n];
+        for (int i = 0; i < n; i++) {
+            arr[i] = Integer.parseInt(s[i]);
+        } 
+
+        log.write(Integer.toString(solution(n, arr)) + ""\n"");
+        log.flush();
+        
+    }
+
+}
+","import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.util.*;
+
+public class CodeForces {
+
+    public static void main(String[] args) throws IOException {
+        reader input = new reader();
+        PrintWriter output = new PrintWriter(System.out);
+        //BufferedReader bf = new BufferedReader(new FileReader(""input.txt""));
+        //PrintWriter pw = new PrintWriter(new BufferedWriter(new FileWriter(""output.txt"")));
+        //StringTokenizer stk = new StringTokenizer(bf.readLine());
+        //int n=Integer.parseInt(stk.nextToken());
+        int n=input.nextInt();
+        ArrayList<Integer>seated=new ArrayList<>();
+        ArrayList<Integer>empty=new ArrayList<>();
+        for(int i=0;i<n;i++){
+            int x=input.nextInt();
+            if(x==1)
+                seated.add(i);
+            else
+                empty.add(i);
+        }
+        if(seated.size()==0)
+            output.println(0);
+        else{
+            output.println(helper(seated,empty));
+        }
+        output.close();
+    }
+    public static long helper(ArrayList<Integer>seated,ArrayList<Integer>empty){
+        long dp[][]=new long[seated.size()+1][empty.size()+1];
+        for(int i=1;i<= seated.size();i++){
+            dp[i][i]=dp[i-1][i-1]+Math.abs(seated.get(i-1)-empty.get(i-1));
+            for(int j=i+1;j<= empty.size();j++){
+                dp[i][j]=Math.min(dp[i][j-1],dp[i-1][j-1]+Math.abs(seated.get(i-1)-empty.get(j-1)));
+            }
+        }
+        return dp[seated.size()][empty.size()];
+
+    }
+
+    public static int GCD(int a,int b){
+        if(a==0)
+            return b;
+        else
+            return GCD(b%a,a);
+    }
+
+    public static boolean isPrime(long num){
+        if(num==1)
+            return false;
+        else if(num==2||num==3)
+            return true;
+        else if(num%2==0||num%3==0)
+            return false;
+        else{
+            for(long i=5;i*i<=num;i+=6){
+                if(num%i==0||num%(i+2)==0)
+                    return false;
+            }
+        }
+        return true;
+    }
+
+    public static void mergesort(long arr[],int start,int end){//start and end must be indexes
+        if(start<end) {
+            int mid=(start+end)/2;
+            mergesort(arr,start,mid);
+            mergesort(arr, mid+1, end);
+            merge(arr, start,mid,end);
+        }
+    }
+    public static void merge(long arr[],int start,int mid,int end){
+        int lsize=mid-start+1,rsize=end-mid;
+        long l[]=new long[lsize],r[]=new long[rsize];
+        for(int i=start;i<=mid;i++){
+            l[i-start]=arr[i];
+        }
+        for(int i=mid+1;i<=end;i++){
+            r[i-mid-1]=arr[i];
+        }
+        int i=0,j=0,k=start;
+        while(i<lsize&&j<rsize){
+            if(l[i]<=r[j]){
+                arr[k++]=l[i++];
+            }else{
+                arr[k++]=r[j++];
+            }
+        }
+        while(i<lsize)
+            arr[k++]=l[i++];
+        while(j<rsize)
+            arr[k++]=r[j++];
+    }
+}
+
+class Pair{
+    int a,b;
+    Pair(int a,int b){
+        this.a=a;
+        this.b=b;
+    }
+}
+
+class Edge{
+    int src,dest,weight;
+    Edge(int src,int dest,int weight){
+        this.src=src;
+        this.dest=dest;
+        this.weight=weight;
+    }
+}
+
+class TempEdge{
+    int vertex;
+    long distance;
+    TempEdge(int vertex,long distance){
+        this.vertex=vertex;
+        this.distance=distance;
+    }
+}
+
+//Undirected Graph
+class UGraph{
+    ArrayList<ArrayList<Edge>>graph;
+    int vertex;
+    UGraph(int vertex){
+        this.vertex=vertex;
+        graph=new ArrayList<>();
+        for(int i=0;i<vertex;i++){
+            graph.add(new ArrayList<>());
+        }
+    }
+    void addEdge(int u,int v){
+        graph.get(u).add(new Edge(u,v,0));
+        graph.get(v).add(new Edge(v,u,0));
+    }
+    void addEdge(int u,int v,int weight){
+        graph.get(u).add(new Edge(u,v,weight));
+        graph.get(v).add(new Edge(v,u,weight));
+    }
+    ArrayList<Integer> BFS(int source){
+        boolean visited[]=new boolean[vertex];
+        ArrayList<Integer>ans=new ArrayList<>();
+        LinkedList<Integer>q=new LinkedList<>();
+        q.add(source);
+        visited[source]=true;
+        while(!q.isEmpty()){
+            int x=q.removeFirst();
+            ans.add(x);
+            for(Edge i:graph.get(x)){
+                if(!visited[i.dest]){
+                    q.add(i.dest);
+                    visited[i.dest]=true;
+                }
+            }
+        }
+        return ans;
+    }
+    ArrayList<Integer> BFS(){//O(V+E)
+        boolean visited[]=new boolean[vertex];
+        ArrayList<Integer>ans=new ArrayList<>();
+        for(int i=0;i<vertex;i++){
+            if(!visited[i]){
+                ArrayList<Integer>temp=BFS(i);
+                for(int j:temp)
+                    ans.add(j);
+            }
+        }
+        return ans;
+    }
+    int connectedComponentsBFS(){
+        boolean visited[]=new boolean[vertex];
+        int count=0;
+        for(int i=0;i<vertex;i++){
+            if(!visited[i]){
+                count++;
+                BFS(i);
+            }
+        }
+        return count;
+    }
+    void DFS(int source){
+        boolean visited[]=new boolean[vertex];
+        DFSHelper(source,visited);
+        System.out.println();
+    }
+    void DFS(){//O(V+E)
+        boolean visited[]=new boolean[vertex];
+        for(int i=0;i<vertex;i++){
+            if(!visited[i]){
+                DFSHelper(i,visited);
+                System.out.println();
+            }
+        }
+    }
+    void DFSHelper(int source,boolean visited[]){
+        visited[source]=true;
+        System.out.print(source+"" "");
+        for(Edge i:graph.get(source)){
+            if(!visited[i.dest]){
+                DFSHelper(i.dest,visited);
+            }
+        }
+    }
+    boolean detectCycleDFS(){//O(V+E)
+        boolean visited[]=new boolean[vertex];
+        for (int i=0;i<vertex;i++){
+            if(!visited[i]){
+                if(detectCycleDFSHelper(i,-1,visited))
+                    return true;
+            }
+        }
+        return false;
+    }
+    boolean detectCycleDFSHelper(int source,int parent,boolean visited[]){
+        visited[source]=true;
+        for(Edge i:graph.get(source)){
+            if(!visited[i.dest]){
+                if(detectCycleDFSHelper(i.dest,source,visited))
+                    return true;
+            }
+            if(i.dest!=parent)
+                return true;
+        }
+        return false;
+    }
+    boolean detectCycleBFS(){//O(V+E)
+        boolean visited[]=new boolean[vertex];
+        for (int i=0;i<vertex;i++){
+            if(!visited[i]){
+                if(detectCycleBFSHelper(i,visited))
+                    return true;
+            }
+        }
+        return false;
+    }
+    boolean detectCycleBFSHelper(int source,boolean visited[]){
+        int parent[]=new int[vertex];
+        Arrays.fill(parent,-1);
+        LinkedList<Integer>q=new LinkedList<>();
+        q.add(source);
+        visited[source]=true;
+        while(!q.isEmpty()){
+            int x=q.removeFirst();
+            for(Edge i:graph.get(x)){
+                if(!visited[i.dest]){
+                    q.add(i.dest);
+                    visited[i.dest]=true;
+                    parent[i.dest]=x;
+                }
+                else{
+                    if(parent[x]!=i.dest)
+                        return true;
+                }
+            }
+        }
+        return false;
+    }
+    int primsMST(){
+        boolean MST[]=new boolean[vertex];
+        TempEdge distarr[]=new TempEdge[vertex];//MST edge stores least distance of a vertex to the MST
+        for(int i=0;i<vertex;i++) {
+            distarr[i] = new TempEdge(i, Integer.MAX_VALUE);
+        }
+        distarr[0].distance=0;
+        // Use TreeSet instead of PriorityQueue as the remove function of the PQ is O(n) in java
+        TreeSet<TempEdge>q=new TreeSet<>((a,b)->(int)(a.distance-b.distance));
+        for(int i=0;i<vertex;i++) {
+            q.add(distarr[i]);
+        }
+        int ans=0;
+        while(!q.isEmpty()){
+            TempEdge x=q.pollFirst();
+            ans+=x.distance;
+            MST[x.vertex]=true;//Adding in MST
+            for(Edge i:graph.get(x.vertex)){
+                if(!MST[i.dest]){//Vertex not present in MST
+                    if(distarr[i.dest].distance>i.weight){//Updating smallest distance from MST vertices to i.dest
+                        q.remove(distarr[i.dest]);
+                        distarr[i.dest].distance=i.weight;
+                        q.add(distarr[i.dest]);
+                    }
+                }
+            }
+        }
+        return ans;
+    }
+    long [] dikstra(int source){
+        long ans[]=new long[vertex];
+        boolean visited[]=new boolean[vertex];
+        Arrays.fill(ans,Integer.MAX_VALUE);
+        ans[source]=0;
+        //TreeSet may be used as done in prims if removal is required
+        PriorityQueue<TempEdge>pq=new PriorityQueue<>((a,b)-> (int) (a.distance-b.distance));
+        int count=0;
+        pq.add(new TempEdge(source,ans[source]));
+        while(count!=vertex-1){//On doing vertex-1 times, last vertex is automatically finalised
+            TempEdge x= pq.poll();
+            if(!visited[x.vertex]){
+                visited[x.vertex]=true;
+                count++;
+                for(Edge i:graph.get(x.vertex)){
+                    /*Checking visited is not necessary as the won't affect the distance in any case
+                    but will affect the heap*/
+                    if(!visited[i.dest] && ans[i.dest]>ans[x.vertex]+i.weight){
+                        ans[i.dest]=ans[x.vertex]+i.weight;
+                        pq.add(new TempEdge(i.dest,ans[i.dest]));
+                    }
+                }
+            }
+        }
+        return ans;
+    }
+    long[] bellmanford(int source){
+        long ans[]=new long[vertex];
+        ans[source]=0;
+        for(int i=0;i<vertex-1;i++){//Considering paths of length 1 to paths of length (v-1) from source
+            for(int j=0;j<vertex;j++){
+                for(Edge k:graph.get(j)){
+                    if(ans[k.dest]>ans[k.src]+ans[k.weight])
+                        ans[k.dest]=ans[k.src]+ans[k.weight];
+                }
+            }
+        }
+        return ans;
+    }
+}
+
+//Directed non-weighted Graph
+class DGraph{
+    ArrayList<ArrayList<Edge>>graph;
+    int vertex;
+    DGraph(int vertex){
+        this.vertex=vertex;
+        graph=new ArrayList<>();
+        for(int i=0;i<vertex;i++){
+            graph.add(new ArrayList<>());
+        }
+    }
+    void addEdge(int src,int dest){
+        graph.get(src).add(new Edge(src,dest,0));
+    }
+    void addEdge(int src,int dest,int weight){
+        graph.get(src).add(new Edge(src,dest,weight));
+    }
+
+    boolean detectCycleDFS(){
+        boolean visited[]=new boolean[vertex];
+        boolean recst[]=new boolean[vertex];
+        for(int i=0;i<vertex;i++){
+            if(!visited[i]){
+                if(detectCycleDFSHelper(i,visited,recst))
+                    return true;
+            }
+        }
+        return false;
+    }
+    boolean detectCycleDFSHelper(int index,boolean visited[],boolean recst[]){
+        visited[index]=true;
+        recst[index]=true;
+        for(Edge i:graph.get(index)){
+            if(!visited[i.dest]){
+                if(detectCycleDFSHelper(i.dest,visited,recst))
+                    return true;
+            }else{
+                if(recst[i.dest])//Back edge present
+                    return true;
+            }
+        }
+        recst[index]=false;
+        return false;
+    }
+    ArrayList<Integer> topologicalSortingBFS(){//Kahn's Algorithm which is valid only for directed acyclic graphs
+        ArrayList<Integer>ans=new ArrayList<>();
+        int indegree[]=new int[vertex];
+        for(int i=0;i<vertex;i++){
+            for(Edge j:graph.get(i)){
+                indegree[j.dest]++;
+            }
+        }
+        LinkedList<Integer>q=new LinkedList<>();
+        for(int i=0;i<vertex;i++){
+            if(indegree[i]==0)
+                q.add(i);
+        }
+        while(!q.isEmpty()){
+            int i=q.removeFirst();
+            ans.add(i);
+            for(Edge x:graph.get(i)){
+                if(--indegree[x.dest]==0){
+                    q.add(x.dest);
+                }
+            }
+        }
+        return ans;
+    }
+    boolean detectCycleTopologicalSort(){
+        int count=0;
+        int indegree[]=new int[vertex];
+        for(int i=0;i<vertex;i++){
+            for(Edge j:graph.get(i)){
+                indegree[j.dest]++;
+            }
+        }
+        LinkedList<Integer>q=new LinkedList<>();
+        for(int i=0;i<vertex;i++){
+            if(indegree[i]==0)
+                q.add(i);
+        }
+        while(!q.isEmpty()){
+            int i=q.removeFirst();
+            count++;
+            for(Edge x:graph.get(i)){
+                if(--indegree[x.dest]==0){
+                    q.add(x.dest);
+                }
+            }
+        }
+        return (count!=vertex);
+    }
+    ArrayList<Integer> topologicalSortingDFS(){
+        boolean visited[]=new boolean[vertex];
+        ArrayDeque<Integer>recst=new ArrayDeque<>();
+        for(int i=0;i<vertex;i++){
+            if(!visited[i]){
+                topologicalSortingDFSHelper(i,visited,recst);
+            }
+        }
+        ArrayList<Integer>ans=new ArrayList<>();
+        while(!recst.isEmpty())
+            ans.add(recst.pop());
+        return ans;
+    }
+    void topologicalSortingDFSHelper(int index,boolean visited[],ArrayDeque<Integer>recst){
+        visited[index]=true;
+        for(Edge i:graph.get(index)){
+            if(!visited[i.dest])
+                topologicalSortingDFSHelper(i.dest,visited,recst);
+        }
+        recst.push(index);
+    }
+    ArrayList<ArrayList<Integer>> stronglyConnectedComponentsKosaraju(){
+        ArrayList<Integer>sortedbyendtime=topologicalSortingDFS();
+        ArrayList<ArrayList<Edge>>transposegraph=new ArrayList<>();
+        for(int i=0;i<vertex;i++){
+            transposegraph.add(new ArrayList<>());
+        }
+        for(int i=0;i<vertex;i++){
+            for(Edge j:graph.get(i)){
+                transposegraph.get(j.dest).add(new Edge(j.dest,j.src, j.weight));
+            }
+        }
+        ArrayList<ArrayList<Integer>>ans=new ArrayList<>();
+        boolean visited[]=new boolean[vertex];
+        for(int i:sortedbyendtime){
+            if(!visited[i]){
+                ArrayList<Integer>curr=DFSTopologicalSort(i,transposegraph,visited);
+                ans.add(curr);
+            }
+        }
+        return ans;
+    }
+    ArrayList<Integer> DFSTopologicalSort(int source,ArrayList<ArrayList<Edge>>graph,boolean visited[]){
+        ArrayList<Integer> ans=new ArrayList<>();
+        DFSTopologicalSortHelper(source,graph,visited,ans);
+        return ans;
+    }
+    void DFSTopologicalSortHelper(int source,ArrayList<ArrayList<Edge>>graph,boolean visited[],ArrayList<Integer> ans) {
+        visited[source]=true;
+        ans.add(source);
+        for(Edge i:graph.get(source)){
+            if(!visited[i.dest])
+                DFSTopologicalSortHelper(i.dest,graph,visited,ans);
+        }
+    }
+    long[] bellmanford(int source){
+        long ans[]=new long[vertex];
+        ans[source]=0;
+        for(int i=0;i<vertex-1;i++){//Considering paths of length 1 to paths of length (v-1) from source
+            for(int j=0;j<vertex;j++){
+                for(Edge k:graph.get(j)){
+                    if(ans[k.dest]>ans[k.src]+ans[k.weight])
+                        ans[k.dest]=ans[k.src]+ans[k.weight];
+                }
+            }
+        }
+        return ans;
+    }
+}
+
+class reader {
+    BufferedReader br;
+    StringTokenizer st;
+    public reader() {
+        br = new BufferedReader(new
+                InputStreamReader(System.in));
+    }
+    String next() {
+        while (st == null || !st.hasMoreElements()) {
+            try {
+                st = new StringTokenizer(br.readLine());
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+        }
+        return st.nextToken();
+    }
+    int nextInt() {
+        return Integer.parseInt(next());
+    }
+    long nextLong() {
+        return Long.parseLong(next());
+    }
+    double nextDouble() {
+        return Double.parseDouble(next());
+    }
+    String nextLine() {
+        String str = """";
+        try {
+            str = br.readLine();
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        return str;
+    }
+    public int[] nextIntArray(int arraySize) {
+        int array[] = new int[arraySize];
+        for (int i = 0; i < arraySize; i++) {
+            array[i] = nextInt();
+        }
+        return array;
+    }
+    public long[] nextLongArray(int arraySize) {
+        long array[] = new long[arraySize];
+        for (int i = 0; i < arraySize; i++) {
+            array[i] = nextLong();
+        }
+        return array;
+    }
+}",1
+06b9cf99,fb69b3b4,"import java.util.*;
+import java.io.*;
+
+public class Solution {
+
+    public static void ruffleSort(long arr[])
+    {   
+        ArrayList<Long> list = new ArrayList<>();
+        for(long i : arr)
+            list.add(i);
+        Collections.sort(list);
+        for(int i = 0; i < list.size(); i++)
+            arr[i] = list.get(i);
+    }
+    
+    public static void main(String[] args) throws IOException {
+
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+
+        int t = Integer.parseInt(br.readLine());
+
+        BufferedWriter output = new BufferedWriter(new OutputStreamWriter(System.out));
+
+        StringTokenizer st;
+
+        while (t-- > 0) {
+
+            // int n = Integer.parseInt(br.readLine());
+
+            st = new StringTokenizer(br.readLine());
+            int n = Integer.parseInt(st.nextToken());
+            long k = Long.parseLong(st.nextToken());
+
+            st = new StringTokenizer(br.readLine());
+
+            long arr[] = new long[n];
+            long tot_sum = 0;
+            for(int i = 0; i < n; i++)
+            {
+            long e = Long.parseLong(st.nextToken());
+            arr[i] = e;
+            tot_sum+=e;
+            }
+
+            if(tot_sum <= k)
+            {
+                output.write(""0\n"");
+                continue;
+            }
+            ruffleSort(arr);
+            long psum = 0;
+            long res = tot_sum - k;
+            for(int p = 0; p < n - 1; p++)
+            {
+                int ind = n - p - 1;
+                psum+=arr[ind];
+                long sum = arr[0] + psum - tot_sum + k;
+                double d = sum / (double)(p + 2);
+                long x = (long)Math.floor(d);
+                // output.write(""x = "" + x + "" sum = "" + sum + "" d = "" + d + ""\n"");
+                long numsteps = Math.max(arr[0] - x, 0) + p + 1;
+                if(numsteps < 0)
+                    continue;
+                // output.write(""for p = "" + p + "" the number of steps req = "" + numsteps + "" and the x = "" + x + ""\n"");
+                res = Math.min(res, numsteps);
+            }
+
+            output.write(res + ""\n"");
+
+            // int k = Integer.parseInt(st.nextToken());
+
+            // char arr[] = br.readLine().toCharArray();
+
+            // output.write();
+            // int n = Integer.parseInt(st.nextToken());
+
+            // HashMap<Character, Integer> map = new HashMap<Character, Integer>();
+
+            // if
+            // output.write(""YES\n"");
+            // else
+            // output.write(""NO\n"");
+
+            // long a = Long.parseLong(st.nextToken());
+            // long b = Long.parseLong(st.nextToken());
+
+            // if(flag == 1)
+            // output.write(""NO\n"");
+            // else
+            // output.write(""YES\n"" + x + "" "" + y + "" "" + z + ""\n"");
+
+            // output.write(n+ ""\n"");
+
+        }
+
+        output.flush();
+
+    }
+
+}","
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.*;
+ 
+public class Main {
+    public static long floor(long a, long b) {
+        long res = a / b;
+        while(res * b > a) res--;
+        return res;
+    }
+    public static void main(String[] args) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        int t = Integer.parseInt(br.readLine());
+        while (t-- > 0) {
+            StringTokenizer st = new StringTokenizer(br.readLine());
+            int n = Integer.parseInt(st.nextToken());
+            long k = Long.parseLong(st.nextToken());
+            st = new StringTokenizer(br.readLine());
+            Long[] p = new Long[n];
+            for(int i = 0 ;i<n;i++) {
+                p[i] = Long.parseLong(st.nextToken());
+            }
+            Arrays.sort(p);
+            long[] sums = new long[n+1];
+            for(int i=0;i<n;i++) sums[i+1] = sums[i] + p[i];
+            long ans = Long.MAX_VALUE;
+            for(int y=0;y<n;y++) {
+                long x = p[0] - floor(k - sums[n-y] + p[0], y+1);
+                ans = Math.min(Math.max(x, 0) + y, ans);
+            }
+            System.out.println(ans);
+        }
+    }
+}",0
+7686c854,8a729537,"import java.util.*;
+import java.util.function.BiFunction;
+import java.util.function.Function;
+import java.util.function.IntToLongFunction;
+import java.lang.*;
+import java.io.*;
+import java.math.*;
+public final class CF
+{
+     public static void main(String[]args)throws IOException
+    {
+        FastReader ob=new FastReader();
+        int t=ob.nextInt();
+        StringBuffer sb=new StringBuffer();
+        while(t-->0)
+        {
+            int n=ob.nextInt();
+            PriorityQueue<Long> a=new PriorityQueue<>();
+            PriorityQueue<Long> b=new PriorityQueue<>();
+            long ans=Long.MAX_VALUE;
+            long sum=0;
+            for(int i=0;i<n;i++)
+            {
+               long x=ob.nextInt();
+               if(i%2==0)
+               a.add(x);
+               else
+               b.add(x);  
+               sum+=x;
+               if(i!=0)
+               ans=Math.min(ans,sum+(a.peek()*(n-a.size()))+(b.peek()*(n-b.size())));
+            }
+            
+            sb.append(ans+""\n"");
+        }
+        System.out.println(sb);
+    }
+}
+class Pair implements Comparable<Pair>
+{
+    int x,y;
+    Pair(int x,int y)
+    {
+        this.x=x;
+        this.y=y;
+    }
+    @Override
+    public int compareTo(Pair a) {
+        return a.y-y;
+    }
+}
+class FastReader {
+    BufferedReader br;
+    StringTokenizer st;
+    public FastReader() {
+        br = new BufferedReader(new InputStreamReader(System.in));
+    }
+
+    public String next() {
+        while (st == null || !st.hasMoreElements()) {
+            try {
+                st = new StringTokenizer(br.readLine());
+            } catch (IOException e)  {
+                e.printStackTrace();
+            }
+        }
+        return st.nextToken();
+    }
+    public String nextLine()
+    {
+        String s="""";
+        try {
+        s=br.readLine();
+        } catch (IOException e)  {
+                e.printStackTrace();
+            }
+        return s;
+    }
+    public int nextInt() {
+        return Integer.parseInt(next());
+    }
+    public long nextLong() {
+        return Long.parseLong(next());
+    }
+    public double nextDouble() {
+        return Double.parseDouble(next());
+    }
+}
+","
+import java.io.*;
+import java.util.*;
+
+public class test3 {
+
+	public static void main(String[] args) throws  IOException {
+		FastReader f = new FastReader();
+		int t = f.nextInt();
+		while(t-->0) {
+			 int n = f.nextInt();
+			 int C[] = new int[n];
+			 long ans=Long.MAX_VALUE,pre = 0;
+			 PriorityQueue<Integer> epq = new PriorityQueue<Integer>();
+			 PriorityQueue<Integer> opq = new PriorityQueue<Integer>();
+			 for(int i = 0;i<n;i++) {
+				 C[i] = f.nextInt();
+				 if(i%2==0)epq.add(C[i]);
+				 else opq.add(C[i]);
+				 pre+=C[i];
+				 if(i>0) {
+					 ans  = Math.min(ans,pre+ ((long)n-(long)epq.size())*(long)epq.peek()
+							 		+ ((long)n-(long)opq.size())*(long)opq.peek());
+				 }
+			 }
+			 System.out.println(ans);
+			}
+    }
+	
+	static boolean isPrime(int n)
+    {
+ 
+        // Check if number is less than
+        // equal to 1
+        if (n <= 1)
+            return false;
+ 
+        // Check if number is 2
+        else if (n == 2)
+            return true;
+ 
+        // Check if n is a multiple of 2
+        else if (n % 2 == 0)
+            return false;
+ 
+        // If not, then just check the odds
+        for (int i = 3; i <= Math.sqrt(n); i += 2)
+        {
+            if (n % i == 0)
+                return false;
+        }
+        return true;
+    }
+	
+	static void print(int x,int y,int d,int n) {
+		int i = 0;
+		System.out.print(x+"" ""+y+"" "");
+			for(int j = x+d;j<y;j+=d) {
+				System.out.print(j+"" "");
+				i++;
+			}
+			for(int j = x-d;j>0;j-=d) {
+				if(i==n)return;
+				System.out.print(j+"" "");
+				i++;
+			}
+			for(int j = y+d;j<1000000000;j+=d) {
+				if(i==n)return;
+				System.out.print(j+"" "");
+				i++;
+			}
+	}
+
+	static int prime(int n){
+	    int ret = 0;
+	    while(n%2==0){
+	        ret++;
+	        n/=2;
+	    }
+	    for(int i=3;i<=Math.sqrt(n);i+=2){
+	        while(n%i==0){
+	            ret++;
+	            n/=i;
+	        }
+	    }
+	    if(n>2)ret++;
+	    return ret;
+	}
+	static long nCr(int n, int r) 
+	{ if(n<r) {
+		return 0;
+	} 
+	    long[] C=new long[r+1]; 
+	    C[0] = 1; 
+	    for (int i = 1; i <= n; i++) 
+	    {  
+	        for (int j = Math.min(i, r); j > 0; j--) 
+	            C[j] = (C[j] + C[j-1]); 
+	    } 
+	    return C[r]; 
+	}
+	static int power(int a,int n, int p)
+    {
+        int res = 1;
+        a = a % p; 
+        while (n > 0)
+        {
+            if ((n & 1) == 1)
+                res = (res * a) % p;
+            n = n >> 1; 
+            a = (a * a) % p;
+        }
+        return res;
+    }
+    static boolean isPrime(int n, int k)
+    {
+    if (n <= 1 || n == 4) return false;
+    if (n <= 3) return true;
+    while (k > 0)
+    {
+        int a = 2 + (int)(Math.random() % (n - 4)); 
+        if (power(a, n - 1, n) != 1)
+            return false;
+     
+        k--;
+        }
+     
+        return true;
+    }
+	  static long GCD(long a,long b) {
+		  if(a%b==0)return b;
+		  else return GCD(b,a%b);
+	  }
+		static ArrayList<Integer> readArray(FastReader f,int size){
+			ArrayList<Integer> ret = new ArrayList<Integer>();
+			for(int i=0;i<size;i++) {
+				ret.add(f.nextInt());
+			}return ret;
+		}
+	 static class FastReader 
+	    { 
+	        BufferedReader br; 
+	        StringTokenizer st; 
+	        public FastReader() 
+	        { 
+	            br = new BufferedReader(new
+	                     InputStreamReader(System.in)); 
+	        } 
+	        String next() 
+	        { 
+	            while (st == null || !st.hasMoreElements()) 
+	            { 
+	                try
+	                { 
+	                    st = new StringTokenizer(br.readLine()); 
+	                } 
+	                catch (IOException  e) 
+	                { 
+	                    e.printStackTrace(); 
+	                } 
+	            } 
+	            return st.nextToken(); 
+	        } 
+	        int nextInt() 
+	        { 
+	            return Integer.parseInt(next()); 
+	        } 	  
+	        long nextLong() 
+	        { 
+	            return Long.parseLong(next()); 
+	        } 
+	        double nextDouble() 
+	        { 
+	            return Double.parseDouble(next()); 
+	        } 
+	        String nextLine() 
+	        { 
+	            String str = """"; 
+	            try
+	            { 
+	                str = br.readLine(); 
+	            } 
+	            catch (IOException e) 
+	            { 
+	                e.printStackTrace(); 
+	            } 
+	            return str; 
+	        } 
+	    }
+	 
+
+ }
+
+
+
+",1
+5a81e159,d82fa7e3,"
+
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.StringTokenizer;
+
+public class C_CF {
+
+    public static void main(String[] args) {
+        FastScanner57 fs = new FastScanner57();
+        PrintWriter pw = new PrintWriter(System.out);
+        int t = fs.ni();
+        //int t = 1;
+        for (int tc = 0; tc < t; tc++) {
+            int n = fs.ni();
+            long[][] lr = new long[n][2];
+            for (int i = 0; i < n; i++) {
+                lr[i][0] = fs.nl();
+                lr[i][1] = fs.nl();
+            }
+            List<List<Integer>> list = new ArrayList();
+            for (int i = 0; i < n;i ++) {
+                List<Integer> temp = new ArrayList();
+                list.add(temp);
+            }
+            for (int i = 0; i < n-1; i++) {
+                int a = fs.ni()-1, b = fs.ni()-1;
+                list.get(a).add(b);
+                list.get(b).add(a);
+            }
+            Long[][] dp = new Long[n][2];
+            pw.println(recur(0,0,-1,new long[] {0,0},dp,lr,list));
+        }
+        pw.close();
+
+    }
+    // 0 -> left was chosen
+    // 1 -> right was chosen
+    public static long recur(int ind, int p,int prev, long[] v, Long[][] dp, long[][] lr,List<List<Integer>> list) {
+
+        long last = v[0];
+        long ls = 0L;
+        long rs = 0L;
+        if (p==1) {
+            last = v[1];
+        }
+        if (ind!=0) ls += (long)Math.abs(last-lr[ind][0]);
+        if (ind!=0) rs += (long)Math.abs(last-lr[ind][1]);
+        if (dp[ind][p]!=null) return dp[ind][p];
+        long[] cur = lr[ind];
+        
+        List<Integer> temp = list.get(ind);
+        for (int val : temp) {
+            if (prev==val) continue;
+            ls += recur(val,0,ind,cur,dp,lr,list);
+            rs += recur(val,1,ind,cur,dp,lr,list);
+        }
+        return dp[ind][p] = Math.max(ls,rs);
+    }
+
+    public static void sort(long[] a) {
+        List<Long> list = new ArrayList();
+        for (int i = 0; i < a.length; i++) {
+            list.add(a[i]);
+        }
+        Collections.sort(list);
+        for (int i = 0; i < a.length; i++) {
+            a[i] = list.get(i);
+        }
+    }
+
+    public static long gcd(long n1, long n2) {
+        if (n2 == 0) {
+            return n1;
+        }
+        return gcd(n2, n1 % n2);
+    }
+
+}
+
+class UnionFind16 {
+
+    int[] id;
+
+    public UnionFind16(int size) {
+        id = new int[size];
+        for (int i = 0; i < size; i++) {
+            id[i] = i;
+        }
+    }
+
+    public int find(int p) {
+        int root = p;
+        while (root != id[root]) {
+            root = id[root];
+        }
+        while (p != root) {
+            int next = id[p];
+            id[p] = root;
+            p = next;
+        }
+        return root;
+    }
+
+    public void union(int p, int q) {
+        int a = find(p), b = find(q);
+        if (a == b) {
+            return;
+        }
+        id[b] = a;
+    }
+}
+
+class FastScanner57 {
+
+    BufferedReader br;
+    StringTokenizer st;
+
+    public FastScanner57() {
+        br = new BufferedReader(new InputStreamReader(System.in), 32768);
+        st = null;
+    }
+
+    String next() {
+        while (st == null || !st.hasMoreElements()) {
+            try {
+                st = new StringTokenizer(br.readLine());
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+        }
+        return st.nextToken();
+    }
+
+    int ni() {
+        return Integer.parseInt(next());
+    }
+
+    int[] intArray(int N) {
+        int[] ret = new int[N];
+        for (int i = 0; i < N; i++) {
+            ret[i] = ni();
+        }
+        return ret;
+    }
+
+    long nl() {
+        return Long.parseLong(next());
+    }
+
+    long[] longArray(int N) {
+        long[] ret = new long[N];
+        for (int i = 0; i < N; i++) {
+            ret[i] = nl();
+        }
+        return ret;
+    }
+
+    double nd() {
+        return Double.parseDouble(next());
+    }
+
+    String nextLine() {
+        String str = """";
+        try {
+            str = br.readLine();
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        return str;
+    }
+}
+","import java.io.OutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.PrintWriter;
+import java.util.InputMismatchException;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.io.InputStream;
+
+
+public class Main {
+    public static void main(String[] args) {
+        InputStream inputStream = System.in;
+        OutputStream outputStream = System.out;
+        FastReader in = new FastReader(inputStream);
+        PrintWriter out = new PrintWriter(outputStream);
+        CParsasHumongousTree solver = new CParsasHumongousTree();
+        int testCount = Integer.parseInt(in.next());
+        for (int i = 1; i <= testCount; i++)
+            solver.solve(i, in, out);
+        out.close();
+    }
+
+    static class CParsasHumongousTree {
+        int n;
+        long[][] dp;
+        int[] l;
+        int[] r;
+        ArrayList<Integer>[] a;
+
+        public void solve(int testNumber, FastReader in, PrintWriter out) {
+            n = in.nextInt();
+            l = new int[n];
+            r = new int[n];
+            dp = new long[n][2];
+            a = new ArrayList[n];
+            for (int i = 0; i < n; ++i) {
+                a[i] = new ArrayList<>();
+            }
+
+            for (int i = 0; i < n; ++i) {
+                l[i] = in.nextInt();
+                r[i] = in.nextInt();
+            }
+
+            for (int i = 0; i < n - 1; ++i) {
+                int u = in.nextInt() - 1, v = in.nextInt() - 1;
+                a[u].add(v);
+                a[v].add(u);
+            }
+
+            dfs(0, -1);
+
+            out.println(Math.max(dp[0][0], dp[0][1]));
+        }
+
+        void dfs(int u, int p) {
+            dp[u][0] = dp[u][1] = 0;
+            for (int v : a[u]) {
+                if (v != p) {
+                    dfs(v, u);
+                    dp[u][0] += Math.max(dp[v][0] + Math.abs(l[u] - l[v]), dp[v][1] + Math.abs(l[u] - r[v]));
+                    dp[u][1] += Math.max(dp[v][0] + Math.abs(r[u] - l[v]), dp[v][1] + Math.abs(r[u] - r[v]));
+                }
+            }
+        }
+
+    }
+
+    static class FastReader {
+        private InputStream stream;
+        private byte[] buf = new byte[1024];
+        private int curChar;
+        private int numChars;
+        private FastReader.SpaceCharFilter filter;
+
+        public FastReader(InputStream stream) {
+            this.stream = stream;
+        }
+
+        public int read() {
+            if (numChars == -1) throw new InputMismatchException();
+            if (curChar >= numChars) {
+                curChar = 0;
+                try {
+                    numChars = stream.read(buf);
+                } catch (IOException e) {
+                    throw new InputMismatchException();
+                }
+                if (numChars <= 0) return -1;
+            }
+            return buf[curChar++];
+        }
+
+        public int nextInt() {
+            int c = read();
+            while (isSpaceChar(c)) c = read();
+            int sgn = 1;
+            if (c == '-') {
+                sgn = -1;
+                c = read();
+            }
+            int res = 0;
+            do {
+                if (c < '0' || c > '9') throw new InputMismatchException();
+                res *= 10;
+                res += c - '0';
+                c = read();
+            }
+            while (!isSpaceChar(c));
+            return res * sgn;
+        }
+
+        public String next() {
+            int c = read();
+            while (isSpaceChar(c)) c = read();
+            StringBuilder res = new StringBuilder();
+            do {
+                res.appendCodePoint(c);
+                c = read();
+            } while (!isSpaceChar(c));
+            return res.toString();
+        }
+
+        public boolean isSpaceChar(int c) {
+            if (filter != null) return filter.isSpaceChar(c);
+            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
+        }
+
+        public interface SpaceCharFilter {
+            public boolean isSpaceChar(int ch);
+
+        }
+
+    }
+}
+
+",0
+46e9aed4,7011024d,"
+import java.util.*;
+
+import java.lang.*;
+import java.io.*;
+
+/* Name of the class has to be ""Main"" only if the class is public. */
+public final class Solution {
+    
+
+    public static void main(String[] args) throws Exception {
+        
+        Reader sc = new Reader();
+        BufferedWriter op = new BufferedWriter(new OutputStreamWriter(System.out));
+         
+         int n=sc.nextInt();
+          ArrayList<Integer> fill= new ArrayList<Integer>();
+          ArrayList<Integer> unfilled= new ArrayList<>();
+          for(int i=0;i<n;i++){
+              int x =sc.nextInt();
+              if(x==1){
+                  fill.add(i);
+              }else{
+                  unfilled.add(i);
+              }
+          }
+          Collections.sort(fill);
+          Collections.sort(unfilled);
+          
+          
+          long[][] dp =new long[fill.size()+1][unfilled.size()+1];
+           for(int i=0;i<fill.size()+1;i++){
+              for(int j=0;j<unfilled.size()+1;j++){
+                  dp[i][j]=Integer.MAX_VALUE;
+              }
+          }
+          for(int i=0;i<unfilled.size()+1;i++){
+              dp[0][i]=0;
+          }
+        //   for(int j=0;j<fill.size()+1;j++){
+        //       dp[j][0]=0;
+        //   }
+         
+
+          for(int i=1;i<fill.size()+1;i++){
+              for(int j=1;j<unfilled.size()+1;j++){
+                  dp[i][j]=Math.min(dp[i][j-1],dp[i-1][j-1]+Math.abs(fill.get(i-1)-unfilled.get(j-1)));
+              }
+          }
+          System.out.println(dp[fill.size()][unfilled.size()]);
+        //   for(int i=0;i<fill.size()+1;i++){
+        //       for(int j=0;j<unfilled.size()+1;j++)
+        //       {
+        //           System.out.print(dp[i][j]+"" "");
+        //       }
+        //       System.out.println();
+        //   }
+         
+    }
+
+
+
+
+   
+    }
+
+class Reader {
+    final private int BUFFER_SIZE = 1 << 16;
+    private DataInputStream din;
+    private byte[] buffer;
+    private int bufferPointer, bytesRead;
+
+    public Reader() {
+        din = new DataInputStream(System.in);
+        buffer = new byte[BUFFER_SIZE];
+        bufferPointer = bytesRead = 0;
+    }
+
+    public Reader(String file_name) throws IOException {
+        din = new DataInputStream(new FileInputStream(file_name));
+        buffer = new byte[BUFFER_SIZE];
+        bufferPointer = bytesRead = 0;
+    }
+
+    public String readLine() throws IOException {
+        byte[] buf = new byte[64]; // line length
+        int cnt = 0, c;
+        while ((c = read()) != -1) {
+            if (c == '\n') {
+                if (cnt != 0) {
+                    break;
+                } else {
+                    continue;
+                }
+            }
+            buf[cnt++] = (byte) c;
+        }
+        return new String(buf, 0, cnt);
+    }
+
+    public int nextInt() throws IOException {
+        int ret = 0;
+        byte c = read();
+        while (c <= ' ') {
+            c = read();
+        }
+        boolean neg = (c == '-');
+        if (neg)
+            c = read();
+        do {
+            ret = ret * 10 + c - '0';
+        } while ((c = read()) >= '0' && c <= '9');
+
+        if (neg)
+            return -ret;
+        return ret;
+    }
+
+    public long nextLong() throws IOException {
+        long ret = 0;
+        byte c = read();
+        while (c <= ' ')
+            c = read();
+        boolean neg = (c == '-');
+        if (neg)
+            c = read();
+        do {
+            ret = ret * 10 + c - '0';
+        } while ((c = read()) >= '0' && c <= '9');
+        if (neg)
+            return -ret;
+        return ret;
+    }
+
+    public double nextDouble() throws IOException {
+        double ret = 0, div = 1;
+        byte c = read();
+        while (c <= ' ')
+            c = read();
+        boolean neg = (c == '-');
+        if (neg)
+            c = read();
+
+        do {
+            ret = ret * 10 + c - '0';
+        } while ((c = read()) >= '0' && c <= '9');
+
+        if (c == '.') {
+            while ((c = read()) >= '0' && c <= '9') {
+                ret += (c - '0') / (div *= 10);
+            }
+        }
+
+        if (neg)
+            return -ret;
+        return ret;
+    }
+
+    private void fillBuffer() throws IOException {
+        bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
+        if (bytesRead == -1)
+            buffer[0] = -1;
+    }
+
+    private byte read() throws IOException {
+        if (bufferPointer == bytesRead)
+            fillBuffer();
+        return buffer[bufferPointer++];
+    }
+
+    public void close() throws IOException {
+        if (din == null)
+            return;
+        din.close();
+    }
+}
+
+","import java.util.*;
+
+public class D {
+
+    public static void main(String[] args) {
+        Scanner scanner = new Scanner(System.in);
+        int n = scanner.nextInt();
+        ArrayList<Integer> occupied = new ArrayList<>();
+        ArrayList<Integer> vacant = new ArrayList<>();
+        for (int i = 0; i < n; i++) {
+            int x = scanner.nextInt();
+            if (x == 1)
+                occupied.add(i);
+            else
+                vacant.add(i);
+        }
+
+        Solution Solution = new Solution(occupied, vacant);
+
+//        System.out.println(Solution.tabulation());
+        System.out.println(Solution.memoization());
+    }
+}
+
+class Solution {
+
+    ArrayList<Integer> occupied, vacant;
+    int x, y;
+
+    public Solution(ArrayList<Integer> occupied, ArrayList<Integer> vacant) {
+        this.occupied = occupied;
+        this.vacant = vacant;
+        x = occupied.size(); y = vacant.size();
+    }
+
+    int tabulation() {
+        return tabulation(x, y);
+    }
+
+    int tabulation(int x, int y) {
+        int[][] dp = new int[x+1][y+1];
+        for (int i = 0; i <= x; i++) {
+            Arrays.fill(dp[i], Integer.MAX_VALUE/2);
+        }
+        for (int i = 0; i <= x; i++) {
+            dp[i][0] = 0;
+        }
+        for (int i = 0; i <= y; i++) {
+            dp[0][i] = 0;
+        }
+        
+        for (int i = 1; i <= x; i++) {
+            for (int j = 1; j <= y; j++) {
+                if(i == j) {
+                    dp[i][j] = dp[i-1][j-1] + Math.abs(occupied.get(i-1) - vacant.get(j-1));
+                }
+                else {
+                    dp[i][j] = Math.min(dp[i][j-1], dp[i-1][j-1] + Math.abs(occupied.get(i-1) - vacant.get(j-1)));
+                }
+            }
+        }
+        return dp[x][y];
+    }
+
+    int memoization() {
+        int[][] dp = new int[x][y];
+        for (int i = 0; i < x; i++) {
+            Arrays.fill(dp[i], -1);
+        }
+        return memoization(dp, x-1, y-1);
+    }
+
+    int memoization(int[][] dp, int n, int m) {
+        if(n < 0) {
+            return 0;
+        }
+        if(m < n) {
+            return Integer.MAX_VALUE;
+        }
+        if(dp[n][m] != -1) {
+            return dp[n][m];
+        }
+        int first = memoization(dp, n, m-1);
+        int second = memoization(dp, n-1, m-1) + Math.abs(occupied.get(n) - vacant.get(m));
+        dp[n][m] = Math.min(first, second);
+        return dp[n][m];
+    }
+}",0
+29cf2e70,b2001d68,"import java.util.*;
+import java.io.*;
+ 
+public class D {
+    public static void main(String[] args) {
+        Scanner in = new Scanner(System.in);
+        
+        int T = in.nextInt();
+        while(T-- > 0) {
+            int n = in.nextInt();
+            int[] a = new int[n];
+            for(int j=0;j<n;j++) a[j] = in.nextInt();
+            char[] s = in.next().toCharArray();
+ 
+            List<Integer> blue = new ArrayList<>();
+            List<Integer> red = new ArrayList<>();
+            for(int j=0;j<n;j++) {
+                if(s[j] == 'B') blue.add(a[j]);
+                else red.add(a[j]);
+            }
+ 
+            Collections.sort(blue);
+            Collections.sort(red);
+ 
+            boolean p = true;
+            int cur = 1;
+            for(int val : blue) {
+                if(val<cur) {
+                    p = false;
+                    break;
+                }
+                else cur++;
+            }
+            for(int val : red) {
+                if(val>cur) {
+                    p = false;
+                    break;
+                }
+                else cur++;
+            }
+            
+            if(p) System.out.println(""yes"");
+            else System.out.println(""no"");
+        }
+    }
+}
+","
+/*
+                                      بسم الله الرحمن الرحيم
+ 
+    /$$$$$  /$$$$$$  /$$    /$$  /$$$$$$                                                                  
+   |__  $$ /$$__  $$ |$$    |$$ /$$__  $$                                                                 
+          | $$| $$  \ $$|    $$|$$| $$  \ $$                                                                 
+          | $$| $$$$$$$$|  $$ / $$/| $$$$$$$$                                                                 
+/ $$  | $$| $$__  $$ \  $$ $$/ | $$__  $$                                                                 
+| $$  | $$| $$  | $$  \  $$$/  | $$  | $$                                                                 
+|  $$$$$$/| $$  | $$   \  $/   | $$  | $$                                                                 
+ \______/ |__/  |__/    \_/    |__/  |__/    
+ 
+/$$$$$$$  /$$$$$$$   /$$$$$$   /$$$$$$  /$$$$$$$   /$$$$$$  /$$      /$$ /$$      /$$ /$$$$$$$$ /$$$$$$$ 
+| $$__  $$| $$__  $$ /$$__  $$ /$$__  $$| $$__  $$ /$$__  $$| $$$    /$$$| $$$    /$$$| $$_____/| $$__  $$
+| $$  \ $$| $$  \ $$| $$  \ $$| $$  \__/| $$  \ $$| $$  \ $$| $$$$  /$$$$| $$$$  /$$$$| $$      | $$  \ $$
+| $$$$$$$/| $$$$$$$/| $$  | $$| $$ /$$$$| $$$$$$$/| $$$$$$$$| $$ $$/$$ $$| $$ $$/$$ $$| $$$$$   | $$$$$$$/
+| $$____/ | $$__  $$| $$  | $$| $$|_  $$| $$__  $$| $$__  $$| $$  $$$| $$| $$  $$$| $$| $$__/   | $$__  $$
+| $$      | $$  \ $$| $$  | $$| $$  \ $$| $$  \ $$| $$  | $$| $$\  $ | $$| $$\  $ | $$| $$      | $$  \ $$
+| $$      | $$  | $$|  $$$$$$/|  $$$$$$/| $$  | $$| $$  | $$| $$ \/  | $$| $$ \/  | $$| $$$$$$$$| $$  | $$
+|__/      |__/  |__/ \______/  \______/ |__/  |__/|__/  |__/|__/     |__/|__/     |__/|________/|__/  |__/
+                                                                                                                                                                                                                
+                                                                                                                                                                                                                
+ 
+*/
+
+import java.util.*;
+import java.lang.*;
+import java.io.*;
+
+public class D753 {
+    public static void main(String[] args) throws java.lang.Exception {
+        // your code goes here
+        try {
+            // Scanner sc=new Scanner(System.in);
+            FastReader sc = new FastReader();
+            int t = sc.nextInt();
+            while (t-- > 0) {
+                int n=sc.nextInt();
+                int[] arr=new int[n];
+                for(int i=0;i<n;i++){
+                    arr[i]=sc.nextInt();
+                }
+                
+                char[] color=sc.next().toCharArray();
+                ArrayList<Integer> b=new ArrayList<>();
+                ArrayList<Integer> r=new ArrayList<>();
+                for(int i=0;i<n;i++){
+                    if(color[i]=='B')b.add(arr[i]);
+                    else r.add(arr[i]);
+                }
+                Collections.sort(b);
+                Collections.sort(r);
+                boolean ok=true;
+                int cur=1;
+                for(int i:b){
+                    if(i>=cur)cur++;
+                    else{
+                        ok=false;
+                        break;
+                    }
+                    //cur++;
+                }
+                for(int i:r){
+                    if(i<=cur)cur++;
+                    else{
+                        ok=false;
+                        break;
+                    }
+                }
+                if(ok)System.out.println(""YES"");
+                else System.out.println(""NO"");
+            }
+        } catch (Exception e) {
+            return;
+        }
+
+    }
+    public static int lowerbound(long[] ar,int k)
+{
+    int s=0;
+    int e=ar.length;
+    while (s !=e)
+    {
+        int mid = s+e>>1;
+        if (ar[mid] <k)
+        {
+            s=mid+1;
+        }
+        else
+        {
+            e=mid;
+        }
+    }
+    if(s==ar.length)
+    {
+        return -1;
+    }
+    return s;
+}
+
+    public static class pair {
+        int ff;
+        char ss;
+
+        pair(int ff, char ss) {
+            this.ff = ff;
+            this.ss = ss;
+        }
+    }
+
+    static int BS(int[] arr, int l, int r, int element) {
+        int low = l;
+        int high = r;
+        while (high - low > 1) {
+            int mid = low + (high - low) / 2;
+            if (arr[mid] < element) {
+                low = mid + 1;
+            } else {
+                high = mid;
+            }
+        }
+        if (arr[low] == element) {
+            return low;
+        } else if (arr[high] == element) {
+            return high;
+        }
+        return -1;
+    }
+
+    static int lower_bound(int[] arr, int l, int r, int element) {
+        int low = l;
+        int high = r;
+        while (high - low > 1) {
+            int mid = low + (high - low) / 2;
+            if (arr[mid] < element) {
+                low = mid + 1;
+            } else {
+                high = mid;
+            }
+        }
+        if (arr[low] >= element) {
+            return low;
+        } else if (arr[high] >= element) {
+            return high;
+        }
+        return -1;
+    }
+
+    static int upper_bound(int[] arr, int l, int r, int element) {
+        int low = l;
+        int high = r;
+        while (high - low > 1) {
+            int mid = low + (high - low) / 2;
+            if (arr[mid] <= element) {
+                low = mid + 1;
+            } else {
+                high = mid;
+            }
+        }
+        if (arr[low] > element) {
+            return low;
+        } else if (arr[high] > element) {
+            return high;
+        }
+        return -1;
+    }
+
+    public static int upperbound(long[] arr, int k) {
+        int s = 0;
+        int e = arr.length;
+        while (s != e) {
+            int mid = s + e >> 1;
+            if (arr[mid] <= k) {
+                s = mid + 1;
+            } else {
+                e = mid;
+            }
+        }
+        if (s == arr.length) {
+            return -1;
+        }
+        return s;
+    }
+    public static long pow(long x,long y,long mod){
+        if(x==0)return 0l;
+        if(y==0)return 1l;
+        //(x^y)%mod
+        if(y%2l==1l){
+            return ((x%mod)*(pow(x,y-1l,mod)%mod))%mod;
+        }
+        return pow(((x%mod)*(x%mod))%mod,y/2l,mod);
+    }
+
+    public static long gcd_long(long a, long b) {
+        // a/b,a-> dividant b-> divisor
+        if (b == 0)
+            return a;
+        return gcd_long(b, a % b);
+    }
+
+    public static int gcd_int(int a, int b) {
+        // a/b,a-> dividant b-> divisor
+        if (b == 0)
+            return a;
+        return gcd_int(b, a % b);
+    }
+
+    public static int lcm(int a, int b) {
+        int gcd = gcd_int(a, b);
+        return (a * b) / gcd;
+    }
+
+    static class FastReader {
+        BufferedReader br;
+        StringTokenizer st;
+
+        public FastReader() {
+            br = new BufferedReader(new InputStreamReader(System.in));
+        }
+
+        String next() {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        String nextLine() {
+            String s = """";
+            try {
+                s = br.readLine();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            return s;
+        }
+
+        Long nextLong() {
+            return Long.parseLong(next());
+        }
+    }
+}
+
+/*
+ * public static boolean lie(int n,int m,int k){ if(n==1 && m==1 && k==0){
+ * return true; } if(n<1 || m<1 || k<0){ return false; } boolean
+ * tc=lie(n-1,m,k-m); boolean lc=lie(n,m-1,k-n); if(tc || lc){ return true; }
+ * return false; }
+ */
+",1
+487c9f62,54488276,"import java.io.*;
+import java.util.*;
+
+public class C {
+
+    public static void main(String[] args) {
+        scan = new MyScanner();
+        out = new PrintWriter(new BufferedOutputStream(System.out));
+
+        int t = scan.nextInt();
+        while (t-->0){
+            solve();
+        }
+
+        out.close();
+    }
+
+    static void solve() {
+        int n = scan.nextInt();
+        int[][] words = new int[n][6];
+        for (int i = 0; i < n; i++) {
+            String input = scan.next();
+            words[i][0] = input.length();
+            for (int j = 0; j < input.length(); j++) {
+                words[i][input.charAt(j)-96]++;
+            }
+            for (int j = 1; j <= 5; j++) {
+                words[i][j] =  words[i][0] - 2*words[i][j];
+            }
+        }
+        int maxCounter = 0;
+        for (int i = 1; i <= 5; i++) {
+            int[] arr = new int[n];
+
+            for (int j = 0; j < n; j++) {
+                arr[j] = words[j][i];
+            }
+            shuffleArray(arr);
+            Arrays.sort(arr);
+            int sum = 0;
+            int counter = 0;
+            while (counter < n && sum + arr[counter] < 0){
+                sum += arr[counter];
+                counter++;
+            }
+            maxCounter = Math.max(maxCounter, counter);
+        }
+        out.println(maxCounter);
+    }
+
+    private static void shuffleArray(int[] array)
+    {
+        int index, temp;
+        Random random = new Random();
+        for (int i = array.length - 1; i > 0; i--)
+        {
+            index = random.nextInt(i + 1);
+            temp = array[index];
+            array[index] = array[i];
+            array[i] = temp;
+        }
+    }
+
+    public static MyScanner scan;
+    public static PrintWriter out;
+
+    public static class MyScanner { BufferedReader br; StringTokenizer st;
+
+        public MyScanner() {
+            br = new BufferedReader(new InputStreamReader(System.in));
+        }
+
+        String next() {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+
+        String nextLine(){
+            String str = """";
+            try {
+                str = br.readLine();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+        }
+    }
+}","import java.io.*;
+import java.util.*;
+
+public class C {
+	static int n;
+	public static void main (String[] args) throws IOException {
+		Kattio io = new Kattio();
+		int t = io.nextInt();
+		for (int ii=0; ii<t; ii++) {
+			n = io.nextInt();
+
+			String[] arr = new String[n];
+
+			for (int i=0; i<n; i++) {
+				String str = io.next();
+				arr[i] = str;
+			}
+
+			char[] chars = new char[]{'a','b','c','d','e'};
+
+			int ans = -1;
+
+			for (int i=0; i<5; i++) {
+				ans = Math.max(ans, solve(arr, chars[i]));
+			}
+			System.out.println(ans);
+		}
+	}
+
+	static int solve(String[] arr, char c) {
+		//System.out.println(""Comparing based on "" + c);
+		Arrays.sort(arr, new Comp(c));
+
+		int good = 0;
+		int total = 0;
+		int ret = 0;
+
+		for (int i=0; i<n; i++) {
+			//System.out.println(good + "" "" + total);
+			for (int j=0; j<arr[i].length(); j++) {
+				if (arr[i].charAt(j) == c) good++;
+			}
+			total += arr[i].length();
+			if (2 * good > total) {
+				ret++;
+			} else {
+				return ret;
+			}
+		}
+
+		return ret;
+	}
+
+	static class Comp implements Comparator<String> {
+		char c;
+
+		public Comp (char c) {
+			this.c = c;
+		}
+
+		public int compare(String a, String b) {
+			double cnt1 = 0;
+			double cnt2 = 0;
+			for (int i=0; i<a.length(); i++) {
+				if (a.charAt(i) == c) {
+					cnt1++;
+				}
+			}
+			for (int i=0; i<b.length(); i++) {
+				if (b.charAt(i) == c) {
+					cnt2++;
+				}
+			}
+			//higher ratio is better
+
+			return -Double.compare(cnt1 - (a.length() - cnt1), cnt2 - (b.length() - cnt2));
+		}
+	}
+
+	static class Kattio extends PrintWriter {
+		private BufferedReader r;
+		private StringTokenizer st;
+
+		// standard input
+		public Kattio() { this(System.in, System.out); }
+		public Kattio(InputStream i, OutputStream o) {
+			super(o);
+			r = new BufferedReader(new InputStreamReader(i));
+		}
+		// USACO-style file input
+		public Kattio(String problemName) throws IOException {
+			super(new FileWriter(problemName + "".out""));
+			r = new BufferedReader(new FileReader(problemName + "".in""));
+		}
+
+		// returns null if no more input
+		public String next() {
+			try {
+				while (st == null || !st.hasMoreTokens())
+					st = new StringTokenizer(r.readLine());
+				return st.nextToken();
+			} catch (Exception e) { }
+			return null;
+		}
+
+		public int nextInt() { return Integer.parseInt(next()); }
+		public double nextDouble() { return Double.parseDouble(next()); }
+		public long nextLong() { return Long.parseLong(next()); }
+	}
+}",0
+2e404969,597195ee,"import java.util.*;
+import java.lang.*;
+import java.io.*;
+
+public class Codechef {
+	static long fans[] = new long[200001];
+	static long inv[] = new long[200001];
+	static long mod = 1000000007;
+
+	static void init() {
+		fans[0] = 1;
+		inv[0] = 1;
+		fans[1] = 1;
+		inv[1] = 1;
+		for (int i = 2; i < 200001; i++) {
+			fans[i] = ((long) i * fans[i - 1]) % mod;
+			inv[i] = power(fans[i], mod - 2);
+		}
+	}
+
+	static long ncr(int n, int r) {
+		return (((fans[n] * inv[n - r]) % mod) * (inv[r])) % mod;
+	}
+
+	public static void main(String[] args) throws java.lang.Exception {
+		FastReader in = new FastReader(System.in);
+		StringBuilder sb = new StringBuilder();
+		int t = 1;
+		t = in.nextInt();
+		while (t > 0) {
+			--t;
+			int n = in.nextInt();
+			long time[] = generateArray(in, n);
+			long hp[] = generateArray(in, n);
+			int s = 0;
+			long ans = 0;
+			while(s<time.length)
+			{
+				long l = time[s] - hp[s];
+				long r = time[s];
+				for(int i = s+1;i<n;i++)
+				{
+					if(time[i]-hp[i]<=l)
+					{
+						l = time[i]-hp[i];
+						r = time[i];
+					}
+					else if(time[i]-hp[i]<r)
+					{
+						r = time[i];
+					}
+				}
+					
+					while(s<n && time[s]>=l && time[s]<=r)
+					{
+						++s;
+					}
+					long temp = r - l;
+					ans += (temp*(temp+1))/2;
+			}
+			sb.append(ans+""\n"");
+
+		}
+		System.out.print(sb);
+	}
+
+	static long power(long x, long y) {
+		long res = 1; // Initialize result
+
+		while (y > 0) {
+
+			// If y is odd, multiply x with result
+			if ((y & 1) != 0)
+				res = ((res % mod) * (x % mod)) % mod;
+
+			// y must be even now
+			y = y >> 1; // y = y/2
+			x = ((x % mod) * (x % mod)) % mod; // Change x to x^2
+		}
+		return res;
+	}
+
+	static long[] generateArray(FastReader in, int n) throws IOException {
+		long arr[] = new long[n];
+		for (int i = 0; i < n; i++)
+			arr[i] = in.nextLong();
+		return arr;
+	}
+
+	static long[][] generatematrix(FastReader in, int n, int m) throws IOException {
+		long arr[][] = new long[n][m];
+		for (int i = 0; i < n; i++) {
+			for (int j = 0; j < m; j++) {
+				arr[i][j] = in.nextLong();
+			}
+		}
+		return arr;
+	}
+
+	static long gcd(long a, long b) {
+		if (a == 0)
+			return b;
+		else
+			return gcd(b % a, a);
+	}
+
+	static long lcm(long a, long b) {
+		return (a / gcd(a, b)) * b;
+	}
+
+	static void sort(long[] a) {
+		ArrayList<Long> l = new ArrayList<>();
+		for (long i : a)
+			l.add(i);
+		Collections.sort(l);
+		for (int i = 0; i < a.length; i++)
+			a[i] = l.get(i);
+	}
+}
+
+class FastReader {
+
+	byte[] buf = new byte[2048];
+	int index, total;
+	InputStream in;
+
+	FastReader(InputStream is) {
+		in = is;
+	}
+
+	int scan() throws IOException {
+		if (index >= total) {
+			index = 0;
+			total = in.read(buf);
+			if (total <= 0) {
+				return -1;
+			}
+		}
+		return buf[index++];
+	}
+
+	String next() throws IOException {
+		int c;
+		for (c = scan(); c <= 32; c = scan())
+			;
+		StringBuilder sb = new StringBuilder();
+		for (; c > 32; c = scan()) {
+			sb.append((char) c);
+		}
+		return sb.toString();
+	}
+
+	String nextLine() throws IOException {
+		int c;
+		for (c = scan(); c <= 32; c = scan())
+			;
+		StringBuilder sb = new StringBuilder();
+		for (; c != 10 && c != 13; c = scan()) {
+			sb.append((char) c);
+		}
+		return sb.toString();
+	}
+
+	char nextChar() throws IOException {
+		int c;
+		for (c = scan(); c <= 32; c = scan())
+			;
+		return (char) c;
+	}
+
+	int nextInt() throws IOException {
+		int c, val = 0;
+		for (c = scan(); c <= 32; c = scan())
+			;
+		boolean neg = c == '-';
+		if (c == '-' || c == '+') {
+			c = scan();
+		}
+		for (; c >= '0' && c <= '9'; c = scan()) {
+			val = (val << 3) + (val << 1) + (c & 15);
+		}
+		return neg ? -val : val;
+	}
+
+	long nextLong() throws IOException {
+		int c;
+		long val = 0;
+		for (c = scan(); c <= 32; c = scan())
+			;
+		boolean neg = c == '-';
+		if (c == '-' || c == '+') {
+			c = scan();
+		}
+		for (; c >= '0' && c <= '9'; c = scan()) {
+			val = (val << 3) + (val << 1) + (c & 15);
+		}
+		return neg ? -val : val;
+	}
+}","import java.io.*;
+import java.util.Arrays;
+import java.util.StringTokenizer;
+
+public class C_MonstersAndSpells_1700 {
+    public static void main(String[] args) {
+        MyScanner sc = new MyScanner();
+        out = new PrintWriter(new BufferedOutputStream(System.out));
+        int t = sc.nextInt();
+        while(t-->0) {
+            int n = sc.nextInt();
+            int[] times = new int[n];
+            int[] health = new int[n];
+            for(int i = 0; i < n; i++) {
+                times[i] = sc.nextInt();
+            }
+            for(int i = 0; i < n; i++) {
+                health[i] = sc.nextInt();
+            }
+            Point[] points = new Point[n];
+            for(int i = 0; i < n; i++) {
+                points[i] = new Point(times[i]-health[i], times[i]);
+            }
+            Arrays.sort(points);
+            long ans = 0;
+            for(int i = 0; i < n; i++) {
+                int j = i+1;
+                int latestTime = points[i].time;
+                while(j < n && points[j].startBy < latestTime) {
+                    latestTime = Math.max(latestTime, times[j]);
+                    j++;
+                }
+                long length = latestTime-points[i].startBy;
+                ans += (length*(length + 1))/2;
+                i = j - 1;
+            }
+            System.out.println(ans);
+        }
+
+        out.close();
+    }
+
+    static class Point implements Comparable<Point> {
+        Integer startBy;
+        Integer time;
+
+        Point(int startBy, int time) {
+            this.startBy = startBy;
+            this.time = time;
+        }
+
+        @Override
+        public int compareTo(Point o) {
+            return this.startBy.compareTo(o.startBy);
+        }
+    }
+
+    public static PrintWriter out;
+
+    public static class MyScanner {
+        BufferedReader br;
+        StringTokenizer st;
+
+        public MyScanner() {
+            br = new BufferedReader(new InputStreamReader(System.in));
+        }
+
+        String next() {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+
+        String nextLine(){
+            String str = """";
+            try {
+                str = br.readLine();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+        }
+
+    }
+    static class Pair {
+        public int x,y;
+        public Pair(int x, int y) {
+            this.x = x;
+            this.y = y;
+        }
+    }
+}
+",0
+69b2fd22,d018b49f,"import java.io.*;
+import java.util.*;
+public class Main {
+    public static void main(String args[])
+    {
+        FastReader input=new FastReader();
+        PrintWriter out=new PrintWriter(System.out);
+        int T=1;
+        while(T-->0)
+        {
+            int n=input.nextInt();
+            int a[]=new int[n];
+            ArrayList<Integer> list=new ArrayList<>();
+            ArrayList<Integer> space=new ArrayList<>();
+            for(int i=0;i<n;i++)
+            {
+                a[i]=input.nextInt();
+                if(a[i]==1)
+                {
+                    list.add(i);
+                }
+                else
+                {
+                    space.add(i);
+                }
+            }
+            int pre[]=new int[space.size()];
+            for(int i=0;i<list.size();i++)
+            {
+                if(i==0)
+                {
+                    int min=Integer.MAX_VALUE;
+                    for(int j=0;j<space.size();j++)
+                    {
+                        pre[j]=Math.abs(list.get(i)-space.get(j));
+                        min=Math.min(min,pre[j]);
+                        pre[j]=min;
+                    }
+                }
+                else
+                {
+                    int arr[]=new int[space.size()];
+                    for(int j=0;j<i;j++)
+                    {
+                        arr[j]=Integer.MAX_VALUE;
+                    }
+
+                    int min=Integer.MAX_VALUE;
+                    for(int j=i;j<space.size();j++)
+                    {
+                        int v=Math.abs(list.get(i)-space.get(j));
+                        v+=pre[j-1];
+                        arr[j]=v;
+                        min=Math.min(min,v);
+                        arr[j]=min;
+                    }
+                    for(int j=0;j<space.size();j++)
+                    {
+                        pre[j]=arr[j];
+                    }
+                }
+            }
+            out.println(pre[space.size()-1]);
+        }
+        out.close();
+    }
+    static class FastReader
+    {
+        BufferedReader br;
+        StringTokenizer st;
+        public FastReader()
+        {
+            br = new BufferedReader(new InputStreamReader(System.in));
+        }
+        String next()
+        {
+            while (st == null || !st.hasMoreElements())
+            {
+                try
+                {
+                    st = new StringTokenizer(br.readLine());
+                }
+                catch (IOException e)
+                {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+        int nextInt()
+        {
+            return Integer.parseInt(next());
+        }
+        long nextLong()
+        {
+            return Long.parseLong(next());
+        }
+        double nextDouble()
+        {
+            return Double.parseDouble(next());
+        }
+        String nextLine()
+        {
+            String str="""";
+            try
+            {
+                str=br.readLine();
+            }
+            catch (IOException e)
+            {
+                e.printStackTrace();
+            }
+            return str;
+        }
+    }
+}","/* package codechef; // don't place package name! */
+
+import java.util.*;
+import java.lang.*;
+import java.io.*;
+
+/* Name of the class has to be ""Main"" only if the class is public. */
+public class Codechef {
+	static long dp[][];
+	public static void main(String[] args) throws java.lang.Exception {
+		FastReader in = new FastReader(System.in);
+		StringBuilder sb = new StringBuilder();
+		int t = 1;
+		//t = in.nextInt();
+		while (t > 0) {
+			--t;
+			int n = in.nextInt();
+			int arr[] = new int[n];
+			List<Integer> ones = new ArrayList<Integer>();
+			List<Integer> zero = new ArrayList<>();
+			for(int i = 0;i<n;i++)
+			{
+				int a = in.nextInt();
+				if(a == 1)
+					ones.add(i);
+				else 
+					zero.add(i);
+			}
+			if(ones.size() == 0) {
+				sb.append(0+""\n"");
+				continue;
+			}
+			dp = new long[ones.size()][zero.size()];
+			for(int i = 0;i<ones.size();i++)
+			    Arrays.fill(dp[i], -1);
+			sb.append(findans(ones, zero, ones.size()-1, zero.size()-1));
+           
+		}
+		System.out.print(sb);
+	}
+	
+	static long findans(List<Integer> ones,List<Integer> zero,int x,int y)
+	{
+		if(x < 0)
+			return 0;
+		if(y<0)
+			return Integer.MAX_VALUE;
+        if(dp[x][y]!=-1)
+        	return dp[x][y];
+		return  dp[x][y] = Math.min(findans(ones, zero, x, y-1),findans(ones, zero, x-1, y-1) + (long)Math.abs(ones.get(x)-zero.get(y)));
+	}
+
+	static long gcd(long a, long b) {
+		if (a == 0)
+			return b;
+		else
+			return gcd(b % a, a);
+	}
+
+	static long lcm(long a, long b) {
+		return (a / gcd(a, b)) * b;
+	}
+
+	static void sort(long[] a) {
+		ArrayList<Long> l = new ArrayList<>();
+		for (long i : a)
+			l.add(i);
+		Collections.sort(l);
+		for (int i = 0; i < a.length; i++)
+			a[i] = l.get(i);
+	}
+}
+
+class FastReader {
+
+	byte[] buf = new byte[2048];
+	int index, total;
+	InputStream in;
+
+	FastReader(InputStream is) {
+		in = is;
+	}
+
+	int scan() throws IOException {
+		if (index >= total) {
+			index = 0;
+			total = in.read(buf);
+			if (total <= 0) {
+				return -1;
+			}
+		}
+		return buf[index++];
+	}
+
+	String next() throws IOException {
+		int c;
+		for (c = scan(); c <= 32; c = scan())
+			;
+		StringBuilder sb = new StringBuilder();
+		for (; c > 32; c = scan()) {
+			sb.append((char) c);
+		}
+		return sb.toString();
+	}
+
+	String nextLine() throws IOException {
+		int c;
+		for (c = scan(); c <= 32; c = scan())
+			;
+		StringBuilder sb = new StringBuilder();
+		for (; c != 10 && c != 13; c = scan()) {
+			sb.append((char) c);
+		}
+		return sb.toString();
+	}
+
+	char nextChar() throws IOException {
+		int c;
+		for (c = scan(); c <= 32; c = scan())
+			;
+		return (char) c;
+	}
+
+	int nextInt() throws IOException {
+		int c, val = 0;
+		for (c = scan(); c <= 32; c = scan())
+			;
+		boolean neg = c == '-';
+		if (c == '-' || c == '+') {
+			c = scan();
+		}
+		for (; c >= '0' && c <= '9'; c = scan()) {
+			val = (val << 3) + (val << 1) + (c & 15);
+		}
+		return neg ? -val : val;
+	}
+
+	long nextLong() throws IOException {
+		int c;
+		long val = 0;
+		for (c = scan(); c <= 32; c = scan())
+			;
+		boolean neg = c == '-';
+		if (c == '-' || c == '+') {
+			c = scan();
+		}
+		for (; c >= '0' && c <= '9'; c = scan()) {
+			val = (val << 3) + (val << 1) + (c & 15);
+		}
+		return neg ? -val : val;
+	}
+}",0
+31f29772,b728ba1d,"import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.PriorityQueue;
+import java.util.StringTokenizer;
+import java.io.*;
+ 
+public class PhoenixTow {
+	
+	private static class MyScanner {
+	    BufferedReader br;
+	    StringTokenizer st;
+
+	    public MyScanner() {
+	       br = new BufferedReader(new InputStreamReader(System.in));
+	    }
+
+	    String next() {
+	        while (st == null || !st.hasMoreElements()) {
+	            try {
+	                st = new StringTokenizer(br.readLine());
+	            } catch (IOException e) {
+	                e.printStackTrace();
+	            }
+	        }
+	        return st.nextToken();
+	    }
+
+	    int nextInt() {
+	        return Integer.parseInt(next());
+	    }
+
+	    long nextLong() {
+	        return Long.parseLong(next());
+	    }
+
+	    double nextDouble() {
+	        return Double.parseDouble(next());
+	    }
+
+	    String nextLine(){
+	        String str = """";
+		  try {
+		     str = br.readLine();
+		  } catch (IOException e) {
+		     e.printStackTrace();
+		  }
+		  return str;
+	    }
+
+	 }
+	
+
+	public static class  Pair implements Comparable<Pair>
+	{
+		int x; 
+		int y;
+		
+		Pair(int x, int y)
+		{
+			this.x = x;
+			this.y = y;
+		}
+		
+		public int compareTo(Pair p)
+		{
+			return ((Integer)this.x).compareTo(p.x);
+		}
+	}
+	
+	public static void solution(int[] arr, int n, int m, int x)
+			
+	{
+		ArrayList<Pair> list = new ArrayList<>();
+		
+		for(int i = 0; i<n; i++)
+		{
+			list.add(new Pair(arr[i], i));
+		}
+		
+		Collections.sort(list);
+		
+		long[] sum = new long[m];
+		
+		int[] ans = new int[n];
+		
+		int k = 1;
+		
+		for(int i = 0; i<list.size(); i++)
+		{
+			if(k<m)
+		    { 
+				if(sum[k-1]+list.get(i).x - sum[k]>x)
+			      {out.println(""NO""); return; }
+		      
+		    }
+			
+			  
+	    	sum[k-1]+=list.get(i).x;
+	    	ans[list.get(i).y] = k;
+	    	k++;
+	    	
+	    	if(k==(m+1))
+	    		k=1;
+	    	
+			
+		}
+		
+		out.println(""YES""); 
+		
+		for(int i = 0; i<n; i++)
+			out.print(ans[i]+"" "");
+		
+		out.println();
+		
+		
+	}
+        
+private static PrintWriter out = new PrintWriter(System.out);
+
+public static void main (String[] args)
+{
+	MyScanner s =  new MyScanner();
+     
+    int t = s.nextInt();
+    
+    for(int j = 0; j<t ; j++)
+    {
+    	int n = s.nextInt();
+    	int m = s.nextInt();
+    	int x = s.nextInt();
+    	
+    	int[] arr = new int[n];
+    	for(int i =0; i<n; i++)
+    		arr[i] = s.nextInt();
+    	
+    	solution(arr,n,m,x);
+    }
+    
+    out.flush();
+    out.close();
+    
+}
+}
+","import java.io.OutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.PrintWriter;
+import java.util.InputMismatchException;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Objects;
+import java.util.Collections;
+import java.io.InputStream;
+
+public class Main {
+    public static void main(String[] args) {
+        InputStream inputStream = System.in;
+        OutputStream outputStream = System.out;
+        FastReader in = new FastReader(inputStream);
+        PrintWriter out = new PrintWriter(outputStream);
+        CPhoenixAndTowers solver = new CPhoenixAndTowers();
+        int testCount = Integer.parseInt(in.next());
+        for (int i = 1; i <= testCount; i++)
+            solver.solve(i, in, out);
+        out.close();
+    }
+
+    static class CPhoenixAndTowers {
+        public void solve(int testNumber, FastReader in, PrintWriter out) {
+            int n = in.nextInt(), m = in.nextInt(), k = in.nextInt();
+            ArrayList<Pair<Integer, Integer>> a = new ArrayList<>();
+            for (int i = 0; i < n; ++i) {
+                a.add(new Pair<>(in.nextInt(), i));
+            }
+            Collections.sort(a);
+
+            int[] ans = new int[n];
+            int[] sum = new int[m];
+            int j = 1;
+
+            for (int i = 0; i < n; ++i) {
+                ans[a.get(i).y] = j;
+                sum[j - 1] += a.get(i).x;
+                j++;
+                if (j == m + 1) j = 1;
+            }
+
+            for (int i = 1; i < m; ++i) {
+                if (Math.abs(sum[i - 1] - sum[i]) > k) {
+                    out.println(""NO"");
+                }
+            }
+
+            out.println(""YES"");
+            for (int e : ans) {
+                out.print(e + "" "");
+            }
+            out.println();
+
+        }
+
+    }
+
+    static class Pair<U, V> implements Comparable<Pair<U, V>> {
+        public U x;
+        public V y;
+
+        public Pair(U x, V y) {
+            this.x = x;
+            this.y = y;
+        }
+
+        public int compareTo(Pair<U, V> o) {
+            int value = ((Comparable<U>) x).compareTo(o.x);
+            if (value != 0) return value;
+            return ((Comparable<V>) y).compareTo(o.y);
+        }
+
+        public boolean equals(Object o) {
+            if (this == o) return true;
+            if (o == null || getClass() != o.getClass()) return false;
+            Pair<?, ?> pair = (Pair<?, ?>) o;
+            return x.equals(pair.x) && y.equals(pair.y);
+        }
+
+        public int hashCode() {
+            return Objects.hash(x, y);
+        }
+
+    }
+
+    static class FastReader {
+        private InputStream stream;
+        private byte[] buf = new byte[1024];
+        private int curChar;
+        private int numChars;
+        private FastReader.SpaceCharFilter filter;
+
+        public FastReader(InputStream stream) {
+            this.stream = stream;
+        }
+
+        public int read() {
+            if (numChars == -1) throw new InputMismatchException();
+            if (curChar >= numChars) {
+                curChar = 0;
+                try {
+                    numChars = stream.read(buf);
+                } catch (IOException e) {
+                    throw new InputMismatchException();
+                }
+                if (numChars <= 0) return -1;
+            }
+            return buf[curChar++];
+        }
+
+        public int nextInt() {
+            int c = read();
+            while (isSpaceChar(c)) c = read();
+            int sgn = 1;
+            if (c == '-') {
+                sgn = -1;
+                c = read();
+            }
+            int res = 0;
+            do {
+                if (c < '0' || c > '9') throw new InputMismatchException();
+                res *= 10;
+                res += c - '0';
+                c = read();
+            }
+            while (!isSpaceChar(c));
+            return res * sgn;
+        }
+
+        public String next() {
+            int c = read();
+            while (isSpaceChar(c)) c = read();
+            StringBuilder res = new StringBuilder();
+            do {
+                res.appendCodePoint(c);
+                c = read();
+            } while (!isSpaceChar(c));
+            return res.toString();
+        }
+
+        public boolean isSpaceChar(int c) {
+            if (filter != null) return filter.isSpaceChar(c);
+            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
+        }
+
+        public interface SpaceCharFilter {
+            public boolean isSpaceChar(int ch);
+
+        }
+
+    }
+}
+
+
+",0
+1c8bb204,7ed5a88d,"import javax.print.DocFlavor;
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.*;
+
+public class BST {
+
+    static class pair implements Comparable{
+
+        int high;
+        int idx;
+
+        pair(int x , int y){
+            high = x;
+            idx = y;
+        }
+
+        public String toString(){
+            return high + "" "" + idx;
+        }
+
+
+        @Override
+        public int compareTo(Object o) {
+            pair p = (pair)o;
+            return high-p.high;
+        }
+    }
+
+    public static void main(String[] args) throws IOException{
+
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        int t = Integer.parseInt(br.readLine());
+        while (t-->0){
+
+            int n = Integer.parseInt(br.readLine());
+            long [] arr = new long[n];
+            StringTokenizer st = new StringTokenizer(br.readLine());
+            for (int i = 0; i < n; i++) {
+                long tmp = Long.parseLong(st.nextToken());
+                arr[i] = tmp;
+
+            }
+
+            int h = 1;
+            int v = 1;
+            long minHor = arr[0];
+            long minVir = arr[1];
+            long sum0 = arr[0];
+            long sum1 = arr[1];
+            long total = (arr[0] + arr[1])*n;
+
+
+            for (int i = 2; i < n; i++) {
+
+                if(i%2==0){
+                    h++;
+                    sum0 += arr[i];
+                    minHor = Math.min(arr[i] , minHor);
+                    total = Math.min(total , minHor*(n-h+1)+(sum0-minHor)+minVir*(n-v+1)+(sum1-minVir));
+                }else {
+                    v++;
+                    sum1 += arr[i];
+                    minVir = Math.min(arr[i] , minVir);
+                    total = Math.min(total , minHor*(n-h+1)+(sum0-minHor)+minVir*(n-v+1)+(sum1-minVir));
+                }
+
+            }
+
+
+            System.out.println(total);
+
+        }
+
+
+
+    }
+
+
+
+
+}","import java.io.BufferedReader;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.*;
+import java.io.PrintStream;
+            //import java.util.*;
+
+        public class Solution {
+
+            public static final boolean LOCAL = System.getProperty(""ONLINE_JUDGE"")==null;
+
+            static class FastScanner {
+
+                    BufferedReader br;
+                    StringTokenizer st ;
+
+                    FastScanner(){
+                        br =  new BufferedReader(new InputStreamReader(System.in));
+                        st = new StringTokenizer("""");
+                    }
+
+                    FastScanner(String file) {
+
+                        try {
+                            br =  new BufferedReader(new InputStreamReader(new FileInputStream(file)));
+                            st = new StringTokenizer("""");
+                        } catch (FileNotFoundException e) {
+                            // TODO Auto-generated catch block
+                            System.out.println(""file not found"");
+                            e.printStackTrace();
+                        }
+                        
+                    }
+                    
+
+                    String next() {
+                        while (!st.hasMoreTokens())
+                            try {
+                                st = new StringTokenizer(br.readLine());
+                            } catch (IOException e) {
+                            }
+                        return st.nextToken();
+                    }
+
+                    int nextInt() {
+                        return Integer.parseInt(next());
+                    }
+
+                    long nextLong() {
+                        return Long.parseLong(next());
+                    }
+                    String readLine() throws IOException{
+                        return br.readLine();
+                    }
+                }
+                                    
+            static class Pair<T,X>{
+                T first;
+                X second;
+                Pair(T first,X second){
+                    this.first = first;
+                    this.second = second;
+                }
+
+                @Override
+                public int hashCode(){
+                    return Objects.hash(first,second);
+                }
+
+                @Override
+                public boolean equals(Object obj){
+                    return obj.hashCode() == this.hashCode();
+                }
+
+            }
+
+        
+        public static void main(String[] args) throws Exception {
+            
+            FastScanner s = new FastScanner();
+
+            PrintStream debug = null;
+            
+            if(LOCAL){
+                s = new FastScanner(""src/input.txt"");
+                PrintStream o = new PrintStream(""src/sampleout.txt"");
+                debug = new PrintStream(""src/debug.txt"");
+                System.setOut(o);
+            }
+
+            
+
+
+            int tcr = s.nextInt();
+
+            
+            for(int tc=0;tc<tcr;tc++){
+                int n = s.nextInt();
+
+                long arr[] = new long[n];
+
+                for(int i=0;i<n;i++){
+                    arr[i] = s.nextLong();
+                }
+
+                long min1 = arr[0];
+                long min2 = arr[1];
+                long sum1 = arr[0];
+                long sum2 = arr[1];
+
+                int cnt1 = 1;
+                int cnt2 = 1;
+
+                long ans = arr[0]*(n) + arr[1]*(n);
+
+                for(int i=2;i<n;i++){
+                    if((i % 2) == 0){
+                        min1 = Math.min(min1,arr[i]);
+                        sum1 += arr[i];
+                        cnt1++;
+                    }else{
+                        min2 = Math.min(min2,arr[i]);
+                        sum2 += arr[i];
+                        cnt2++;
+                    }
+                    long temp = min1*(n - cnt1 + 1) + (sum1 - min1) + (min2*(n- cnt2 + 1) + (sum2 - min2));
+                    ans = Math.min(ans,temp);
+                }
+
+                println(ans);
+            }                
+        }
+
+        static int len(long num){
+            return Long.toString(num).length();
+        }
+
+        static long mulmod(long a, long b,long mod)
+        {
+            return ((a%mod) * (b%mod)) % mod;
+        }
+
+
+        public static void dbg(PrintStream ps,Object... o) throws Exception{
+            if(ps == null){
+                return;
+            }
+            Debug.dbg(ps,o);
+        }
+
+       
+  
+
+        public static long modpow(long num,long pow,long mod){
+
+            long val = num;
+            long ans = 1l;
+
+            while(pow > 0l){
+                
+                long bit = pow & 1l;
+
+                if(bit == 1){
+                    ans = (ans * (val%mod))%mod;
+                }
+
+                val = (val * val) % mod;
+                pow = pow >> 1;
+            }
+
+            return ans;
+
+        }
+
+        public static char get(int n){
+            return (char)('a' + n);
+        }
+
+        public static long[] sort(long arr[]){
+            List<Long> list = new ArrayList<>();
+            for(long n : arr){list.add(n);}
+            Collections.sort(list);
+            for(int i=0;i<arr.length;i++){
+                arr[i] = list.get(i);
+            }
+            return arr;
+        }
+
+        public static int[] sort(int arr[]){
+            List<Integer> list = new ArrayList<>();
+            for(int n : arr){list.add(n);}
+            Collections.sort(list);
+            for(int i=0;i<arr.length;i++){
+                arr[i] = list.get(i);
+            }
+            return arr;
+        }
+
+        // return the (index + 1)
+        // where index is the pos of just smaller element
+        // i.e count of elemets strictly less than num
+        public static int justSmaller(long arr[],long num){
+            //  System.out.println(num+""@"");
+            int st = 0;
+            int e = arr.length - 1;
+    
+            int ans = -1;
+    
+            while(st <= e){
+    
+                int mid = (st + e)/2;
+    
+                if(arr[mid] >= num){
+                    e = mid - 1;
+                }else{
+                    ans = mid;
+                    st = mid + 1;
+                }
+    
+            }
+    
+    
+            return ans + 1;
+    
+        }
+        
+        //return (index of just greater element)
+        //count of elements smaller than or equal to num
+
+        public static int justGreater(long arr[],long num){
+            int st = 0;
+            int e = arr.length - 1;
+    
+            int ans = arr.length;
+    
+            while(st <= e){
+                
+                int mid = (st + e)/2;
+    
+                if(arr[mid] <= num){
+                    st = mid + 1;
+                }else{
+                    ans = mid;
+                    e = mid - 1;
+                }
+            }
+    
+            return ans;
+    
+        }
+    
+        
+
+        public static void println(Object obj){
+            System.out.println(obj.toString());
+        }
+
+        public static void print(Object obj){
+            System.out.print(obj.toString());
+        }
+
+        public static int gcd(int a,int b){
+            if(b == 0){return a;}
+            return gcd(b,a%b);
+        }
+
+        public static long gcd(long a,long b){
+            if(b == 0l){
+                return a;
+            }
+
+            return gcd(b,a%b);
+        }
+
+        public static int find(int parent[],int v){
+            if(parent[v] == v){
+                return v;
+            }
+            
+            return parent[v] = find(parent, parent[v]);
+        }
+
+    
+
+        public static List<Integer> sieve(){
+        
+            List<Integer> prime = new ArrayList<>();
+
+            int arr[] = new int[100001];
+
+            Arrays.fill(arr,1);
+
+            arr[1] = 0;
+            arr[2] = 1;
+
+            for(int i=2;i<=100000;i++){
+                
+                if(arr[i] == 1){
+                    
+                    prime.add(i);
+
+                    for(long j = (i*1l*i);j<100001;j+=i){
+                        arr[(int)j] = 0;
+                    }
+                }
+            }
+
+            return prime;
+        }
+
+        static boolean isPower(long n,long a){
+            
+            long log = (long)(Math.log(n)/Math.log(a));
+
+            long power = (long)Math.pow(a,log);
+
+            if(power == n){return true;}
+
+            return false;
+        }
+
+
+        private static int mergeAndCount(int[] arr, int l,int m, int r)
+        {
+
+            // Left subarray
+            int[] left =  Arrays.copyOfRange(arr, l, m + 1);
+
+            // Right subarray
+            int[] right = Arrays.copyOfRange(arr, m + 1, r + 1);
+
+            int i = 0, j = 0, k = l, swaps = 0;
+
+            while (i < left.length && j < right.length) {
+                if (left[i] <= right[j])
+                    arr[k++] = left[i++];
+                else {
+                    arr[k++] = right[j++];
+                    swaps += (m + 1) - (l + i);
+                }
+            }
+            while (i < left.length)
+                arr[k++] = left[i++];
+            while (j < right.length)
+                arr[k++] = right[j++];
+            return swaps;
+        }
+
+        // Merge sort function
+        private static int mergeSortAndCount(int[] arr, int l,int r)
+        {
+
+            // Keeps track of the inversion count at a
+            // particular node of the recursion tree
+            int count = 0;
+
+            if (l < r) {
+                int m = (l + r) / 2;
+
+                // Total inversion count = left subarray count
+                // + right subarray count + merge count
+
+                // Left subarray count
+                count += mergeSortAndCount(arr, l, m);
+
+                // Right subarray count
+                count += mergeSortAndCount(arr, m + 1, r);
+
+                // Merge count
+                count += mergeAndCount(arr, l, m, r);
+            }
+
+            return count;
+        }
+
+        static class Debug{
+            //change to System.getProperty(""ONLINE_JUDGE"")==null; for CodeForces
+            public static final boolean LOCAL = System.getProperty(""ONLINE_JUDGE"")==null;
+
+            
+
+            private static <T> String ts(T t) {
+                if(t==null) {
+                    return ""null"";
+                }
+                try {
+                    return ts((Iterable) t);
+                }catch(ClassCastException e) {
+                    if(t instanceof int[]) {
+                        String s = Arrays.toString((int[]) t);
+                        return ""{""+s.substring(1, s.length()-1)+""}\n"";
+                    }else if(t instanceof long[]) {
+                        String s = Arrays.toString((long[]) t);
+                        return ""{""+s.substring(1, s.length()-1)+""}\n"";
+                    }else if(t instanceof char[]) {
+                        String s = Arrays.toString((char[]) t);
+                        return ""{""+s.substring(1, s.length()-1)+""}\n"";
+                    }else if(t instanceof double[]) {
+                        String s = Arrays.toString((double[]) t);
+                        return ""{""+s.substring(1, s.length()-1)+""}\n"";
+                    }else if(t instanceof boolean[]) {
+                        String s = Arrays.toString((boolean[]) t);
+                        return ""{""+s.substring(1, s.length()-1)+""}\n"";
+                    }
+                    try {
+                        return ts((Object[]) t);
+                    }catch(ClassCastException e1) {
+                        return t.toString();
+                    }
+                }
+            }
+            private static <T> String ts(T[] arr) {
+                StringBuilder ret = new StringBuilder();
+                ret.append(""{"");
+                boolean first = true;
+                for(T t: arr) {
+                    if(!first) {
+                        ret.append("", "");
+                    }
+                    first = false;
+                    ret.append(ts(t));
+                }
+                ret.append(""}"");
+                return ret.toString();
+            }
+            private static <T> String ts(Iterable<T> iter) {
+                StringBuilder ret = new StringBuilder();
+                ret.append(""{"");
+                boolean first = true;
+                for(T t: iter) {
+                    if(!first) {
+                        ret.append("", "");
+                    }
+                    first = false;
+                    ret.append(ts(t));
+                }
+                ret.append(""}"");
+                return ret.toString();
+            }
+            public static void dbg(PrintStream ps,Object... o) throws Exception {
+                if(LOCAL) {
+                    System.setErr(ps);
+                    System.err.print(""Line #""+Thread.currentThread().getStackTrace()[2].getLineNumber()+"": ["");
+                    for(int i = 0; i<o.length; i++) {
+                        if(i!=0) {
+                            System.err.print("", "");
+                        }
+                        System.err.print(ts(o[i]));
+                    }
+                    System.err.println(""]"");
+                }
+            }
+        }
+
+}",0
+0f3a2acf,16e6d8bb,"import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.*;
+
+public class Practice {
+    static int[][] vals;
+    static ArrayList<ArrayList<Integer>> adjList;
+    static long[][] ans;
+    public static void main(String[] args) throws IOException {
+        BufferedReader bu=new BufferedReader(new InputStreamReader(System.in));
+        int t = Integer.parseInt(bu.readLine());
+        while (t-- > 0) {
+            Integer n = Integer.parseInt(bu.readLine());
+            vals = new int[2][n];
+            adjList = new ArrayList<>();
+            for(int i=0;i<n;i++){
+                String st[]=bu.readLine().split("" "");
+                vals[0][i] = Integer.parseInt(st[0]);
+                vals[1][i] = Integer.parseInt(st[1]);
+                adjList.add(new ArrayList<>());
+            }
+            for(int i=0;i<n-1;i++){
+                String st[]=bu.readLine().split("" "");
+                int source = Integer.parseInt(st[0]);; int dest = Integer.parseInt(st[1]);;
+                adjList.get(source-1).add(dest-1);
+                adjList.get(dest-1).add(source-1);
+            }
+            ans = new long[2][n];
+            DFS(0, adjList, -1, ans, vals);
+            System.out.println(Math.max(ans[0][0], ans[1][0]));
+        }
+    }
+
+    private static void DFS(Integer current, ArrayList<ArrayList<Integer>> adjList, Integer prev, long[][] ans, int[][] vals) {
+        ans[0][current] = 0L; ans[1][current] = 0L;
+        for(Integer node: adjList.get(current)){
+            if(node.equals(prev)) continue;
+            DFS(node, adjList, current, ans, vals);
+            ans[0][current] += Math.max(ans[0][node] + Math.abs(vals[0][current] - vals[0][node]), ans[1][node] + Math.abs(vals[0][current] - vals[1][node]));
+            ans[1][current] += Math.max(ans[0][node] + Math.abs(vals[1][current] - vals[0][node]) , ans[1][node] + Math.abs(vals[1][current] - vals[1][node]));
+        }
+    }
+}
+
+","import java.util.*;
+import java.io.*;
+import java.lang.*;
+
+public class CodeChef {
+	static long dp[][];
+	public static void main (String[] args) throws java.lang.Exception
+	{
+		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+		int t=Integer.parseInt(br.readLine());
+		while(t-->0)
+		{
+			int n=Integer.parseInt(br.readLine());
+			int arr[][]=new int[n+1][2];
+			for(int i=1;i<=n;i++)
+			{
+				String str[]=br.readLine().split("" "");
+				int l=Integer.parseInt(str[0]);int r=Integer.parseInt(str[1]);
+				arr[i][0]=l;arr[i][1]=r;
+			}
+			dp=new long[n+1][2];
+			Set<Integer>adj[]=new HashSet[n+1];
+			for(int i=0;i<=n;i++)adj[i]=new HashSet();
+			for(int i=0;i<n-1;i++)
+			{
+				String str[]=br.readLine().split("" "");
+				int src=Integer.parseInt(str[0]);  int dest=Integer.parseInt(str[1]);
+				adj[src].add(dest);
+				adj[dest].add(src);
+			}
+			fun(1,adj,arr);System.out.println(Math.max(dp[1][0], dp[1][1]));
+		}
+	}
+	static void fun(int root,Set<Integer>[] adj,int arr[][])
+	{
+		dp[root][0]=dp[root][1]=0;
+		Iterator<Integer>iter=adj[root].iterator();
+		while(iter.hasNext())
+		{
+			int i=iter.next();
+			adj[i].remove(root);
+			fun(i,adj,arr);
+			dp[root][0]+=Math.max(Math.abs(arr[root][0]-arr[i][0])+dp[i][0], Math.abs(arr[root][0]-arr[i][1])+dp[i][1]);
+			dp[root][1]+=Math.max(Math.abs(arr[root][1]-arr[i][0])+dp[i][0], Math.abs(arr[root][1]-arr[i][1])+dp[i][1]);
+		}
+		
+	}
+}
+",1
+53551ea0,6be98ece,"import java.util.*;
+public class MyClass {
+    public static void main(String args[]) {
+      Scanner sc=new Scanner(System.in);
+      int tc=sc.nextInt();
+      while(tc>0)
+      {
+          int n=sc.nextInt();
+          int arr[]=new int[n];
+          int i,max=Integer.MIN_VALUE,min=Integer.MAX_VALUE;
+          for(i=0;i<n;i++)
+          {
+              arr[i]=sc.nextInt();
+              if(arr[i]>max)
+              max=arr[i];
+              if(arr[i]<min)
+              min=arr[i];
+          }
+          int low=min,high=max,mid,ans=min;
+          while(low<=high)
+          {
+              mid=(low+high)/2;
+              int temp[]=new int[n];
+              for(i=0;i<n;i++)
+              temp[i]=arr[i];
+              boolean flag=true;
+              for(i=n-1;i>=2;--i)
+              {
+                  if(temp[i]<mid)
+                  {
+                  flag=false;
+                  break;
+                  }
+                  int deli=Math.min(temp[i]-mid,arr[i]);
+                  int ex=deli/3;
+                  temp[i]=temp[i]-(3*ex);
+                  temp[i-1]=temp[i-1]+(ex);
+                   temp[i-2]=temp[i-2]+(2*ex);
+                   
+              }
+              
+              if(temp[0]<mid || temp[1]<mid)
+              flag=false;
+              
+              if(flag==true)
+              {
+              ans=mid;
+              low=mid+1;
+              }
+              else
+              high=mid-1;
+          }
+          System.out.println(ans);
+          --tc;
+      }}}","import java.util.*;
+
+public class CF763C {
+	private static final int MAX = 1000000001;
+	private static final int MIN = 0;
+
+	public static final void main(String ...args) {
+		Scanner sc = new Scanner(System.in);
+
+		int t = sc.nextInt();
+
+		while (t-- > 0) {
+			int n = sc.nextInt();
+			int[] h = new int[n];
+			int i, b = MAX, e = MIN;
+			for (i = 0; i < n; i++) {
+				h[i] = sc.nextInt();
+				if (b > h[i])
+					b = h[i];
+				if (e < h[i])
+					e = h[i];
+			}
+
+			int[] s = new int[n];
+			int c, d, ans = b;
+
+			// System.out.println(b + "" "" + e);
+
+			while (b <= e) {
+				c = (b + e) / 2;
+				// System.out.println(c);
+				// sc.next();
+				for (i = 0; i < n; i++) {
+					s[i] = 0;
+				}
+
+				for (i = n - 1; i >= 2; i--) {
+					if (h[i] + s[i] < c) {
+						e = c - 1;
+						break;
+					} else {
+						d = Math.min(h[i], h[i] + s[i] - c) / 3;
+						s[i - 1] += d;
+						s[i - 2] += 2 * d;
+					}
+				}
+				// System.out.println(i);
+				if (i == 1) {
+					if (h[i] + s[i] < c || h[i - 1] + s[i - 1] < c) {
+						e = c - 1;
+					} else {
+						ans = c;
+						b = c + 1;	
+					}
+				}
+			}
+			System.out.println(ans);
+		}
+	}
+}",0
+11d91f31,eea69e7f,"import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.StringTokenizer;
+import java.util.*;
+
+public class ArmChairs {
+    static final Random random = new Random();
+
+    static class FastReader {
+        BufferedReader br;
+        StringTokenizer st;
+
+        public FastReader() {
+            br = new BufferedReader(new
+                    InputStreamReader(System.in));
+        }
+
+        String next() {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+
+        String nextLine() {
+            String str = """";
+            try {
+                str = br.readLine();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+        }
+
+        int[] readArray(int n, int size) {
+            int[] a = new int[size];
+            for (int i = 0; i < n; i++) {
+                a[i] = this.nextInt();
+            }
+
+            return a;
+        }
+
+        long[] readLongArray(int n, int size) {
+            long[] a = new long[size];
+            for (int i = 0; i < n; i++) {
+                a[i] = this.nextLong();
+            }
+            return a;
+        }
+    }
+
+    static void ruffleSort(long[] a) {
+        int n = a.length;//shuffle, then sort
+        for (int i = 0; i < n; i++) {
+            int oi = random.nextInt(n);
+            long temp = a[oi];
+            a[oi] = a[i];
+            a[i] = temp;
+        }
+        Arrays.sort(a);
+    }
+
+    static void ruffleSort(int[] a) {
+        int n = a.length;//shuffle, then sort
+        for (int i = 0; i < n; i++) {
+            int oi = random.nextInt(n), temp = a[oi];
+            a[oi] = a[i];
+            a[i] = temp;
+        }
+        Arrays.sort(a);
+    }
+
+    public static void main(String[] args) {
+        FastReader fs = new FastReader();
+        int t = 1;
+
+        for (int z = 0; z < t; z++) {
+            int n = fs.nextInt();
+            List<Integer> empty = new ArrayList<>();
+            List<Integer> chairs = new ArrayList<>();
+            for(int i = 0; i < n; i++) {
+                int status = fs.nextInt();
+                if(status == 1) chairs.add(i+1);
+                else empty.add(i+1);
+            }
+            int[][] dp = new int[empty.size() + 1][chairs.size() + 1];
+            dp[0][0] = 0;
+            for(int i = 1; i <= chairs.size(); i++) dp[0][i] = (int)3e+8;
+            for(int i = 1; i <= empty.size(); i++) {
+                for(int j = 1; j <= chairs.size(); j++) {
+                    // Shift jth person to ith chair
+                    dp[i][j] = dp[i-1][j-1] + Math.abs(empty.get(i-1) - chairs.get(j-1));
+                    dp[i][j] = Math.min(dp[i][j], dp[i-1][j]);
+                }
+                //System.out.println(i + "" "" + Arrays.toString(dp[i]));
+            }
+            //System.out.println(empty.size() + "" "" + chairs.size());
+            System.out.println(dp[empty.size()][chairs.size()]);
+        }
+    }
+}","import java.util.*;
+
+public class Solution {
+	
+	public static int minMoves(int[] input) {
+		List<Integer> people = new ArrayList<Integer>();
+		List<Integer> chairs = new ArrayList<Integer>();
+		
+		for (int i = 0; i < input.length; i++) {
+			if (input[i] == 1) {
+				people.add(i);
+			} else {
+				chairs.add(i);
+			}
+		}
+		
+		int[] memo = new int[chairs.size() + 1];
+		
+
+		for (int p = 1; ((!people.isEmpty()) && (p <= people.size())); p++) {
+			int prev = memo[p];
+			memo[p] = memo[p - 1] + Math.abs(people.get(p - 1) - chairs.get(p - 1));
+			for (int c = p + 1; c <= chairs.size(); c++) {
+				int tmp = memo[c];
+				memo[c] = Math.min(memo[c - 1], prev + Math.abs(people.get(p - 1) - chairs.get(c - 1)));
+				prev = tmp;
+			}
+		}
+		return memo[memo.length - 1];
+	}
+	
+	
+	public static void main(String[] args) {
+		Scanner sc = new Scanner(System.in);
+		int n = sc.nextInt();
+		int[] input = new int[n];
+		for (int i = 0; i < n; i++) {
+			input[i] = sc.nextInt();
+		}
+		
+		System.out.println(Solution.minMoves(input));
+		
+	}
+}",0
+949502c2,e647bef7,"import static java.lang.Math.max;
+import static java.lang.Math.min;
+import static java.lang.Math.abs;
+import static java.lang.System.out;
+import java.util.*;
+import java.io.*;
+import java.math.*;
+
+public class Template {
+
+	static int mod = 1000000007;
+
+	public static void main(String[] args) {
+		FastScanner sc = new FastScanner();
+		int yo = sc.nextInt();
+		while (yo-- > 0) {
+			int n = sc.nextInt();
+            int a = sc.nextInt()-1;
+            int b = sc.nextInt()-1;
+            int da = sc.nextInt();
+            int db = sc.nextInt();
+            
+            List<List<Integer>> list = new ArrayList<>();
+            for(int i = 0; i < n; i++) list.add(new ArrayList<>());
+            
+            for(int i = 0; i < n-1; i++){
+                int x = sc.nextInt()-1;
+                int y = sc.nextInt()-1;
+                list.get(x).add(y);
+                list.get(y).add(x);
+            }
+            
+            for(int i = 0; i <= n; i++) depth[i] = 0;
+            diam = 0;
+            dfs(a,-1,list);
+            
+            if(2 * da >= min(diam, db) || depth[b] <= da){
+                out.println(""Alice"");
+            }
+            else {
+                out.println(""Bob"");
+            }
+            
+		}
+	}
+    
+    static int[] depth = new int[200001];
+    static int diam = 0;
+    static int dfs(int x, int p, List<List<Integer>> list) {
+        int len = 0;
+        List<Integer> ne = list.get(x);
+        for(int y : ne) {
+            if(y != p) {
+                depth[y] = depth[x] + 1;
+                int cur = 1 + dfs(y, x,list);
+                diam = max(diam, cur + len);
+                len = max(len, cur);
+            }
+        }
+        return len;
+    }
+   
+
+	public static class Pair {
+		int x;
+		int y;
+
+		public Pair(int x, int y) {
+			this.x = x;
+			this.y = y;
+		}
+	}
+
+	public static void sort(int[] arr) {
+		ArrayList<Integer> ls = new ArrayList<Integer>();
+		for (int x : arr)
+			ls.add(x);
+		Collections.sort(ls);
+		for (int i = 0; i < arr.length; i++)
+			arr[i] = ls.get(i);
+	}
+
+	public static long gcd(long a, long b) {
+		if (b == 0)
+			return a;
+		return gcd(b, a % b);
+	}
+
+	static boolean[] sieve(int N) {
+		boolean[] sieve = new boolean[N + 1];
+		for (int i = 2; i <= N; i++)
+			sieve[i] = true;
+
+		for (int i = 2; i <= N; i++) {
+			if (sieve[i]) {
+				for (int j = 2 * i; j <= N; j += i) {
+					sieve[j] = false;
+				}
+			}
+		}
+		return sieve;
+	}
+
+	public static long power(long x, long y, long p) {
+		long res = 1L;
+		x = x % p;
+		while (y > 0) {
+			if ((y & 1) == 1)
+				res = (res * x) % p;
+			y >>= 1;
+			x = (x * x) % p;
+		}
+		return res;
+	}
+
+	public static void print(int[] arr) {
+		//for debugging only
+		for (int x : arr)
+			out.print(x + "" "");
+		out.println();
+	}
+
+	static class FastScanner {
+		private int BS = 1 << 16;
+		private char NC = (char) 0;
+		private byte[] buf = new byte[BS];
+		private int bId = 0, size = 0;
+		private char c = NC;
+		private double cnt = 1;
+		private BufferedInputStream in;
+
+		public FastScanner() {
+			in = new BufferedInputStream(System.in, BS);
+		}
+
+		public FastScanner(String s) {
+			try {
+				in = new BufferedInputStream(new FileInputStream(new File(s)), BS);
+			} catch (Exception e) {
+				in = new BufferedInputStream(System.in, BS);
+			}
+		}
+
+		private char getChar() {
+			while (bId == size) {
+				try {
+					size = in.read(buf);
+				} catch (Exception e) {
+					return NC;
+				}
+				if (size == -1)
+					return NC;
+				bId = 0;
+			}
+			return (char) buf[bId++];
+		}
+
+		public int nextInt() {
+			return (int) nextLong();
+		}
+
+		public int[] readInts(int N) {
+			int[] res = new int[N];
+			for (int i = 0; i < N; i++) {
+				res[i] = (int) nextLong();
+			}
+			return res;
+		}
+
+		public long[] readLongs(int N) {
+			long[] res = new long[N];
+			for (int i = 0; i < N; i++) {
+				res[i] = nextLong();
+			}
+			return res;
+		}
+
+		public long nextLong() {
+			cnt = 1;
+			boolean neg = false;
+			if (c == NC)
+				c = getChar();
+			for (; (c < '0' || c > '9'); c = getChar()) {
+				if (c == '-')
+					neg = true;
+			}
+			long res = 0;
+			for (; c >= '0' && c <= '9'; c = getChar()) {
+				res = (res << 3) + (res << 1) + c - '0';
+				cnt *= 10;
+			}
+			return neg ? -res : res;
+		}
+
+		public double nextDouble() {
+			double cur = nextLong();
+			return c != '.' ? cur : cur + nextLong() / cnt;
+		}
+
+		public double[] readDoubles(int N) {
+			double[] res = new double[N];
+			for (int i = 0; i < N; i++) {
+				res[i] = nextDouble();
+			}
+			return res;
+		}
+
+		public String next() {
+			StringBuilder res = new StringBuilder();
+			while (c <= 32)
+				c = getChar();
+			while (c > 32) {
+				res.append(c);
+				c = getChar();
+			}
+			return res.toString();
+		}
+
+		public String nextLine() {
+			StringBuilder res = new StringBuilder();
+			while (c <= 32)
+				c = getChar();
+			while (c != '\n') {
+				res.append(c);
+				c = getChar();
+			}
+			return res.toString();
+		}
+
+		public boolean hasNext() {
+			if (c > 32)
+				return true;
+			while (true) {
+				c = getChar();
+				if (c == NC)
+					return false;
+				else if (c > 32)
+					return true;
+			}
+		}
+	}
+
+	//	For Input.txt and Output.txt	
+	//	FileInputStream in = new FileInputStream(""input.txt"");
+	//	FileOutputStream out = new FileOutputStream(""output.txt"");
+	//	PrintWriter pw = new PrintWriter(out);
+	//	Scanner sc = new Scanner(in);
+}","
+import java.io.*;
+import java.util.*;
+
+public class Main {
+    private static final boolean N_CASE = true;
+    private List<List<Integer>> g;
+    private int a;
+    private int b;
+    private int da;
+    private int db;
+    private int max;
+    private int ab;
+
+    private int dfs(int u, int fa, int depth) {
+        if (u == a) {
+            ab = depth;
+        }
+
+        int m1 = 0, m2 = 0;
+        for (int v : g.get(u)) {
+            if (v != fa) {
+                int m = dfs(v, u, depth + 1) + 1;
+                if (m > m1) { m2 = m1; m1 = m; }
+                else if (m > m2) { m2 = m; }
+            }
+        }
+        max = Math.max(max, m1 + m2);
+        int cmax = Math.max(m1, m2);
+        max = Math.max(max, cmax + depth);
+        return cmax;
+    }
+
+    private void solve() {
+        int n = sc.nextInt();
+        a = sc.nextInt() - 1; b = sc.nextInt() - 1;
+        da = sc.nextInt(); db = sc.nextInt();
+
+        g = createGraph(n);
+        for (int i = 0; i < n - 1; ++i) {
+            int u = sc.nextInt() - 1, v = sc.nextInt() - 1;
+            g.get(u).add(v);
+            g.get(v).add(u);
+        }
+        max = 0;
+        dfs(b, -1, 0);
+        db = Math.min(max, db);
+
+        boolean win = true;
+        if (ab > da) {
+            if (db > da * 2) {
+                win = false;
+            }
+        }
+
+        out.println(win ? ""Alice"" : ""Bob"");
+    }
+
+    private void run() {
+        int T = N_CASE ? sc.nextInt() : 1;
+        for (int t = 0; t < T; ++t) {
+            solve();
+        }
+    }
+
+    private static MyWriter out;
+    private static MyScanner sc;
+
+    private static class MyScanner {
+        BufferedReader br;
+        StringTokenizer st;
+
+        private MyScanner() {
+            br = new BufferedReader(new InputStreamReader(System.in));
+        }
+
+        String next() {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+
+        int[] nextIntArray(int n) {
+            int[] a = new int[n];
+            for (int i = 0; i < n; i++) {
+                a[i] = nextInt();
+            }
+            return a;
+        }
+
+        int[][] nextIntArray(int n, int m) {
+            int[][] a = new int[n][m];
+            for (int i = 0; i < n; i++) {
+                for (int j = 0; j < m; j++) {
+                    a[i][j] = sc.nextInt();
+                }
+            }
+            return a;
+        }
+
+        long[] nextLongArray(int n) {
+            long[] a = new long[n];
+            for (int i = 0; i < n; i++) {
+                a[i] = nextLong();
+            }
+            return a;
+        }
+
+        long[][] nextLongArray(int n, int m) {
+            long[][] a = new long[n][m];
+            for (int i = 0; i < n; i++) {
+                for (int j = 0; j < m; j++) {
+                    a[i][j] = nextLong();
+                }
+            }
+            return a;
+        }
+
+        List<Integer> nextList(int n) {
+            List<Integer> list = new ArrayList<>();
+            for (int i = 0; i < n; i++) {
+                list.add(nextInt());
+            }
+            return list;
+        }
+
+        List<Long> nextLongList(int n) {
+            List<Long> list = new ArrayList<>();
+            for (int i = 0; i < n; i++) {
+                list.add(nextLong());
+            }
+            return list;
+        }
+
+        char[] nextCharArray(int n) {
+            return sc.next().toCharArray();
+        }
+
+        char[][] nextCharArray(int n, int m) {
+            char[][] c = new char[n][m];
+            for (int i = 0; i < n; i++) {
+                String s = sc.next();
+                for (int j = 0; j < m; j++) {
+                    c[i][j] = s.charAt(j);
+                }
+            }
+            return c;
+        }
+    }
+
+    private static class MyWriter extends PrintWriter {
+        private MyWriter(OutputStream outputStream) {
+            super(outputStream);
+        }
+
+        void printArray(int[] a) {
+            for (int i = 0; i < a.length; ++i) {
+                print(a[i]);
+                print(i == a.length - 1 ? '\n' : ' ');
+            }
+        }
+
+        void printArray(long[] a) {
+            for (int i = 0; i < a.length; ++i) {
+                print(a[i]);
+                print(i == a.length - 1 ? '\n' : ' ');
+            }
+        }
+
+        void println(int[] a) {
+            for (int v : a) {
+                println(v);
+            }
+        }
+
+        void print(List<Integer> list) {
+            for (int i = 0; i < list.size(); ++i) {
+                print(list.get(i));
+                print(i == list.size() - 1 ? '\n' : ' ');
+            }
+        }
+
+        void println(List<Integer> list) {
+            list.forEach(this::println);
+        }
+    }
+
+    private <T> List<List<T>> createGraph(int n) {
+        List<List<T>> g = new ArrayList<>();
+        for (int i = 0; i < n; ++i) {
+            g.add(new ArrayList<>());
+        }
+        return g;
+    }
+
+    private void fill(int[][] a, int value) {
+        for (int[] row : a) {
+            fill(row, value);
+        }
+    }
+
+    private void fill(int[] a, int value) {
+        Arrays.fill(a, value);
+    }
+
+    public static void main(String[] args) {
+        out = new MyWriter(new BufferedOutputStream(System.out));
+        sc = new MyScanner();
+        new Main().run();
+        out.close();
+    }
+}",0
+1dab88fb,99ccaa44,"import java.util.*;
+
+public class Main
+{
+    static class Edge{
+        public int node;
+        public int index;
+        public Edge(int n, int i){
+            node=n;
+            index=i;
+        }
+    }
+    static Scanner sc=new Scanner(System.in);
+	public static void main(String[] args) {
+	    
+	    int test=sc.nextInt();
+	    while(test-->0){
+	        
+	        solve();
+	    }
+	}
+	
+	static void solve(){
+	    int n=sc.nextInt();
+	        ArrayList<ArrayList<Edge>> graph= new ArrayList<ArrayList<Edge>>();
+	        for(int i=0;i<n;i++){
+	            graph.add(new ArrayList<>());
+	        }
+	        for (int i = 0; i < n - 1; i++) {
+	            int u = sc.nextInt();
+	            int v = sc.nextInt();
+	            u--; v--;
+	            
+	            graph.get(u).add(new Edge(v, i));
+	            graph.get(v).add(new Edge(u, i));
+            }
+            
+            int start = 0;
+            for (int i = 0; i < n; i++) {
+                if (graph.get(i).size() > 2) {
+                    System.out.println(""-1"");
+                    return;
+                } else if (graph.get(i).size() == 1) {
+                    start = i;
+                }
+            }
+            int[] weight = new int[n - 1];
+            
+            int prevNode = -1;
+            int curNode = start;
+            int curWeight = 2;
+            
+            while (true) {
+                ArrayList<Edge> edges = graph.get(curNode);
+                Edge next = edges.get(0);
+                
+                if (next.node == prevNode) {
+                    if (edges.size() == 1) {
+                        break;
+                    } else {
+                        next = edges.get(1);
+                    }
+                }
+                weight[next.index] = curWeight;
+                
+                prevNode = curNode;
+                curNode = next.node;
+                curWeight = 5 - curWeight;
+            }
+            for (int i = 0; i < n - 1; i++) {
+                System.out.print(weight[i]);
+                System.out.print("" "");
+            }
+            System.out.println();
+	}
+}
+","import java.util.*;
+ 
+public class Main
+{
+	public static void main(String[] args) {
+	    Scanner sc = new Scanner(System.in); 
+		int tc = sc.nextInt();
+		while(tc>0)
+		{
+		    tc--;
+		    int ans = 0;
+		    int n = sc.nextInt();
+		    int in[] = new int[n];
+		    int wx[] = new int[n-1];
+		    int wy[] = new int[n-1];
+		    ArrayList<ArrayList<Integer>> arr = new ArrayList<ArrayList<Integer>>();
+		    HashMap<String,Integer> h = new HashMap<String,Integer>();
+		    HashSet<Integer> h2 = new HashSet<Integer>();
+		    for(int i=0;i<n;i++)
+		    {
+		        arr.add(new ArrayList<Integer>());
+		    }
+		    for(int i=0;i<n-1;i++)
+		    {
+		        int x = sc.nextInt();
+		        int y = sc.nextInt();
+		        x--;
+		        y--;
+		        in[x]++;
+		        in[y]++;
+		        if(in[x]>2 || in[y]>2)
+		        {
+		            ans = -1;
+		        }
+		        else if(ans!=-1)
+		        {
+		            arr.get(x).add(y);
+		            arr.get(y).add(x);
+		            wx[i] = x;
+		            wy[i] = y;
+		        }
+		        
+		    }
+		    if(ans == -1)
+		    {
+		        System.out.println(""-1"");
+		    }
+		    else
+		    {
+		        int vis[] = new int[n];
+		        ArrayDeque<Integer> q = new ArrayDeque<Integer>();
+		        q.add(0);
+		        vis[0] = 1;
+		        while(q.size()>0)
+		        {
+		            int x = q.removeFirst();
+		            for(int i=0;i<arr.get(x).size();i++)
+		            {
+		                int y = arr.get(x).get(i);
+		                String temp  =String.valueOf(x);
+		                if(vis[y] == 0)
+		                {
+		                    vis[y] = 1;
+		                    if(h2.contains(y) || h2.contains(x))
+		                    {
+		                        String s1 = temp+""_""+String.valueOf(y);
+		                        String s2 = String.valueOf(y)+""_""+temp;
+		                        h.put(s1,11);
+		                        h.put(s2,11);
+		                        
+		                    }
+		                    else
+		                    {
+		                        String s1 = temp+""_""+String.valueOf(y);
+		                        String s2 = String.valueOf(y)+""_""+temp;
+		                        h.put(s1,2);
+		                        h.put(s2,2);
+		                        h2.add(x);
+		                        h2.add(y);
+		                    }
+		                    q.add(y);
+		                }
+		            }
+		        }
+		        for(int i=0;i<wx.length;i++)
+		        {
+		            String s1 = String.valueOf(wx[i])+""_""+String.valueOf(wy[i]);
+		            System.out.print(h.get(s1)+"" "");
+		        }
+		        System.out.println();
+		    }
+		}
+	}
+}",0
+6bcc5afd,cb87df79,"import java.util.*;
+public class MyClass {
+    public static void main(String args[]) {
+     Scanner s=new Scanner(System.in);
+     int n=s.nextInt();
+     int a[]=new int[n];
+     ArrayList<Integer> lt1=new ArrayList<>();
+     ArrayList<Integer> lt0=new ArrayList<>();
+     for(int i=0;i<n;i++)
+     {
+         int l=s.nextInt();
+         if(l==0)
+         lt0.add(i+1);
+         else
+         lt1.add(i+1);
+     }
+     int dp[][]=new int[lt1.size()+1][lt0.size()+1];
+     for(int i=1;i<=lt1.size();i++)
+     {
+         dp[i][i]=dp[i-1][i-1]+Math.abs(lt0.get(i-1)-lt1.get(i-1));
+         for(int j=i+1;j<=lt0.size();j++)
+         {
+             dp[i][j]=Math.min(dp[i][j-1],dp[i-1][j-1]+Math.abs(lt1.get(i-1)-lt0.get(j-1)));
+         }
+     }
+     System.out.println(dp[lt1.size()][lt0.size()]);
+     
+    }
+}","import java.util.*;
+
+public class Longjumps {
+	 public static void main(String[] args){
+		 Scanner sc=new Scanner(System.in);
+			ArrayList<Integer> o=new ArrayList<Integer>(), e=new ArrayList<Integer>();
+			int n = sc.nextInt();
+			for(int i=1;i<=n;i++){
+				int x=sc.nextInt();
+				if(x==1)o.add(i);
+				else e.add(i);
+			}
+			int dp[][]=new int[o.size()+1][e.size()+1];
+			for(int i=1;i<=o.size();i++){
+				dp[i][i]=dp[i-1][i-1]+Math.abs(o.get(i-1)-e.get(i-1));
+				for(int j=i+1;j<=e.size();j++)
+					dp[i][j]=Math.min(dp[i][j-1],dp[i-1][j-1]+Math.abs(o.get(i-1)-e.get(j-1)));
+			}
+			System.out.println(dp[o.size()][e.size()]);
+	 }
+}",1
+38129877,7493a104,"//package practice.codeforces.round763;
+
+import java.util.Scanner;
+
+public class C {
+    public static void main(String[] args) {
+        Scanner scanner = new Scanner(System.in);
+        int t = scanner.nextInt();
+        while (t-- > 0) {
+            int n = scanner.nextInt();
+            int[] h = new int[n];
+            for (int i = 0; i < n; i++) {
+                h[i] = scanner.nextInt();
+            }
+            System.out.println(binSearchSolution(h));
+        }
+    }
+
+    private static int binSearchSolution(int[] a) {
+        int l = 0;
+        int r = (int)1e9 + 1;
+        while (l < r - 1) {
+            int m = l + (r - l) / 2;
+            if (canAchieve(a, m)) {
+                l = m;
+            } else {
+                r = m;
+            }
+        }
+        return l;
+    }
+
+    private static boolean canAchieve(int[] a, int min) {
+        int back1 = a[a.length - 2];
+        int current = a[a.length - 1];
+        int nextIndex = a.length - 3;
+        while (nextIndex >= 0) {
+            int back2 = a[nextIndex];
+            if (current < min) {
+                return false;
+            }
+            int canMove = Math.min(current - min, a[nextIndex + 2]);
+            int d = canMove / 3;
+            current = back1 + d;
+            back1 = back2 + 2 * d;
+            nextIndex--;
+        }
+        if (current < min || back1 < min) {
+            return false;
+        }
+        return true;
+    }
+}
+","import java.util.Scanner;
+ 
+public class C {
+    public static void main(String[] args) {
+        Scanner scanner = new Scanner(System.in);
+        int t = scanner.nextInt();
+        while (t-- > 0) {
+            int n = scanner.nextInt();
+            int[] h = new int[n];
+            for (int i = 0; i < n; i++) {
+                h[i] = scanner.nextInt();
+            }
+            System.out.println(binSearchSolution(h));
+        }
+    }
+ 
+    private static int binSearchSolution(int[] a) {
+        int l = 0;
+        int r = (int)1e9 + 1;
+        while (l < r - 1) {
+            int m = l + (r - l) / 2;
+            if (canAchieve(a, m)) {
+                l = m;
+            } else {
+                r = m;
+            }
+        }
+        return l;
+    }
+ 
+    private static boolean canAchieve(int[] a, int min) {
+        int back1 = a[a.length - 2];
+        int current = a[a.length - 1];
+        int nextIndex = a.length - 3;
+        while (nextIndex >= 0) {
+            int back2 = a[nextIndex];
+            if (current < min) {
+                return false;
+            }
+            int canMove = Math.min(current - min, a[nextIndex + 2]);
+            int d = canMove / 3;
+            current = back1 + d;
+            back1 = back2 + 2 * d;
+            nextIndex--;
+        }
+        if (current < min || back1 < min) {
+            return false;
+        }
+        return true;
+    }
+}",1
+0951d079,927384f2,"import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.Stack;
+import java.util.StringTokenizer;
+
+public class D {
+
+	public static void main(String[] args) throws NumberFormatException, IOException {
+		BufferedReader file = new BufferedReader(new InputStreamReader(System.in));
+		int n = Integer.parseInt(file.readLine());
+		int[] heights = new int[n];
+		StringTokenizer st = new StringTokenizer(file.readLine());
+		for(int i = 0; i < n; i++) {
+			heights[i] = Integer.parseInt(st.nextToken());
+		}
+		int[] dp = new int[n];
+		dp[0] = 0;
+		Stack<Integer> high = new Stack<>();
+		Stack<Integer> low = new Stack<>();
+		high.push(0);
+		low.push(0);
+		for(int i = 1; i < n; i++) {
+			dp[i] = dp[i-1]+1;
+			while(!high.isEmpty() && heights[high.peek()] < heights[i]) {
+				dp[i] = Math.min(dp[i], dp[high.peek()]+1);
+				high.pop();
+			}
+			if(!high.isEmpty()) {
+				dp[i] = Math.min(dp[i], dp[high.peek()]+1);
+				if(heights[high.peek()] == heights[i])
+					high.pop();
+			}
+			while(!low.isEmpty() && heights[low.peek()] > heights[i]) {
+				dp[i] = Math.min(dp[i], dp[low.peek()]+1);
+				low.pop();
+			}
+			if(!low.isEmpty()) {
+				dp[i] = Math.min(dp[i], dp[low.peek()]+1);
+				if(heights[low.peek()] == heights[i])
+					low.pop();
+			}
+			high.push(i);
+			low.push(i);
+		}
+		System.out.println(dp[n-1]);
+	}
+
+}
+","import java.util.*;
+import java.io.*;
+
+public class Main{
+	static class Point{
+		int x,y,z;
+		Point(int nx, int ny){
+			x = nx; y = ny; 
+		}
+		@Override
+		public boolean equals(Object o) {
+			Point p = (Point)o;
+			return p.x == x && p.y == y;
+		}
+	}      
+	
+	public static void main(String[] args) throws IOException{
+		BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
+		int n = pint(in);
+		Stack<Integer> min = new Stack<Integer>();
+		Stack<Integer> max = new Stack<Integer>();
+		
+		int[] a = new int[n];
+		int[] dp = new int[n];
+		StringTokenizer st = new StringTokenizer(in.readLine());
+		a[0] = pint(st);
+		min.add(0);
+		max.add(0);
+		for(int i = 1; i < n; i++) {
+			a[i] = pint(st);
+			int h = dp[i - 1] + 1;
+			while(!max.isEmpty() && a[i] > a[max.peek()]) {
+				int k = a[max.peek()];
+				h = Math.min(h, dp[max.pop()] + 1);
+				while(!max.isEmpty() && a[max.peek()] == k) {max.pop();}
+			}
+			if(!max.isEmpty()) {
+				h = Math.min(h, dp[max.peek()] + 1);
+			}
+			while(!min.isEmpty() && a[i] < a[min.peek()]) {
+				int k = a[min.peek()];
+				h = Math.min(h, dp[min.pop()] + 1);
+				while(!min.isEmpty() && a[min.peek()] == k) {min.pop();}
+			}
+			if(!min.isEmpty()) {
+				h = Math.min(h, dp[min.peek()] + 1);
+			}
+			dp[i] = h;
+			min.add(i);
+			max.add(i);
+		}
+		System.out.println(dp[n - 1]);
+	}
+	static int[] resize(int[] a) {
+		int[] r = new int[a.length * 2];
+		for(int i = 0; i < a.length; i++) {
+			r[i] = a[i];
+		}
+		return r;
+	}
+    static int pint(BufferedReader in) throws IOException {return Integer.parseInt(in.readLine());}
+    static int pint(StringTokenizer st) {return Integer.parseInt(st.nextToken());}
+}",0
+1dab88fb,a6229ee9,"import java.util.*;
+
+public class Main
+{
+    static class Edge{
+        public int node;
+        public int index;
+        public Edge(int n, int i){
+            node=n;
+            index=i;
+        }
+    }
+    static Scanner sc=new Scanner(System.in);
+	public static void main(String[] args) {
+	    
+	    int test=sc.nextInt();
+	    while(test-->0){
+	        
+	        solve();
+	    }
+	}
+	
+	static void solve(){
+	    int n=sc.nextInt();
+	        ArrayList<ArrayList<Edge>> graph= new ArrayList<ArrayList<Edge>>();
+	        for(int i=0;i<n;i++){
+	            graph.add(new ArrayList<>());
+	        }
+	        for (int i = 0; i < n - 1; i++) {
+	            int u = sc.nextInt();
+	            int v = sc.nextInt();
+	            u--; v--;
+	            
+	            graph.get(u).add(new Edge(v, i));
+	            graph.get(v).add(new Edge(u, i));
+            }
+            
+            int start = 0;
+            for (int i = 0; i < n; i++) {
+                if (graph.get(i).size() > 2) {
+                    System.out.println(""-1"");
+                    return;
+                } else if (graph.get(i).size() == 1) {
+                    start = i;
+                }
+            }
+            int[] weight = new int[n - 1];
+            
+            int prevNode = -1;
+            int curNode = start;
+            int curWeight = 2;
+            
+            while (true) {
+                ArrayList<Edge> edges = graph.get(curNode);
+                Edge next = edges.get(0);
+                
+                if (next.node == prevNode) {
+                    if (edges.size() == 1) {
+                        break;
+                    } else {
+                        next = edges.get(1);
+                    }
+                }
+                weight[next.index] = curWeight;
+                
+                prevNode = curNode;
+                curNode = next.node;
+                curWeight = 5 - curWeight;
+            }
+            for (int i = 0; i < n - 1; i++) {
+                System.out.print(weight[i]);
+                System.out.print("" "");
+            }
+            System.out.println();
+	}
+}
+","import java.util.*;
+import java.io.*;
+
+public class hmm {
+
+	static Scanner sc = new Scanner(System.in);
+	static PrintWriter pw = new PrintWriter(System.out);
+	 static boolean visited[];
+	 static ArrayList<pair>arr[];
+	 static HashMap<String,Integer>hm = new HashMap<>();
+   public static void dfs(int start, int prime) {
+	   visited[start]=true;
+	   for(pair x: arr[start]) {
+		   if(!visited[(int) x.x]) {
+			   x.y = prime==2?3:2;
+			   hm.put(start+"",""+x.x,x.y);
+			   hm.put(x.x+"",""+start, x.y);
+			   dfs(x.x,x.y);
+		   }
+	   }
+	   
+   }
+   
+
+	public static void main(String[] args) throws Exception {
+		int t =sc.nextInt();
+		while (t-- > 0) {
+		         int n =sc.nextInt();
+		         visited= new boolean [n];
+		         arr=new ArrayList[n];
+		         int[]color = new int[n];
+		         ArrayList<pair>lol = new ArrayList<pair>();
+		         
+		         for(int i=0;i<n;i++)
+		        	 arr[i]=new ArrayList<pair>();
+		         for(int i=0;i<n-1;i++) {
+		        	 int u = sc.nextInt()-1;
+		        	 int v = sc.nextInt()-1;
+		             lol.add(new pair(u,v));
+		        	 arr[u].add(new pair(v,0));
+		        	 arr[v].add(new pair(u,0));
+		         }
+		         boolean can = true;
+		         for(int i=0;i<n;i++)
+		        	 if(arr[i].size()>2){
+		        		 can = false;
+		        	 }
+		         if(!can)
+		        	 pw.println(-1);
+		         
+		         else {
+		        	 int []hh = new int [] {2,3};
+		        	 int i=0;
+		        	 visited[0]= true;
+		        	 for(pair x: arr[0]) {
+		        		 hm.put(0+"",""+x.x,hh[i]);
+		        		 dfs(x.x,hh[i++]);
+		        	 }
+		        	 //dfs(0,3);
+		        	 for(pair a:lol) {
+		        		 int u = a.x;
+		        		 int y = a.y;
+		        		 if(hm.containsKey(u+"",""+y))
+		        				 pw.print(hm.get(u+"",""+y)+"" "");
+		        		 else
+		        			 pw.print(hm.get(y+"",""+u)+"" "");
+		        	 }
+		        	 pw.println();
+		         }
+			
+		}
+
+		pw.close();
+
+	}
+
+	// -------------- stuff ------------------------------
+	static class pair {
+		int x ;
+		int y;
+	
+		
+		public pair(int n,int c) {
+			x= n;
+			y = c;
+		
+			
+		}
+	
+	
+		
+	}
+
+	static class Scanner {
+		StringTokenizer st;
+		BufferedReader br;
+
+		public Scanner(InputStream s) {
+			br = new BufferedReader(new InputStreamReader(s));
+		}
+
+		public Scanner(FileReader r) {
+			br = new BufferedReader(r);
+		}
+
+		public String next() throws IOException {
+			while (st == null || !st.hasMoreTokens())
+				st = new StringTokenizer(br.readLine());
+			return st.nextToken();
+		}
+
+		public int nextInt() throws IOException {
+			return Integer.parseInt(next());
+		}
+
+		public long nextLong() throws IOException {
+			return Long.parseLong(next());
+		}
+
+		public String nextLine() throws IOException {
+			return br.readLine();
+		}
+
+		public int[] nextIntArray(int n) throws IOException {
+			int[] a = new int[n];
+			for (int i = 0; i < n; i++)
+				a[i] = nextInt();
+			return a;
+		}
+
+	}
+
+}",0
+3dd65549,90dc2b20,"import java.util.*;
+import java.io.*;
+
+public class codeforces {
+	public static void main(String[] args) throws Exception {
+		int t=sc.nextInt();
+		while(t-->0) {
+			int n=sc.nextInt();
+			char[] a=sc.next().toCharArray();
+			char[] b=sc.next().toCharArray();
+			int e0=0;
+			int e1=0;
+			int o0=0;
+			int o1=0;
+			for(int i=0;i<n;i++) {
+				if(a[i]!=b[i]) {
+					if(a[i]=='1') {
+						e1++;
+					}else {
+						e0++;
+					}
+				}else {
+					if(a[i]=='1') {
+						o1++;
+					}else {
+						o0++;
+					}
+				}
+			}
+			int ans=Integer.MAX_VALUE;
+			
+			if(e1==e0) {
+				ans=Math.min(ans, e1+e0);
+			}
+			if(o1==o0+1) {
+				ans=Math.min(ans, o1+o0);
+			}
+//			pw.println(e0+"" ""+e1+"" ""+o0+"" ""+o1);
+			pw.println(ans==Integer.MAX_VALUE?-1:ans);
+		}
+		pw.close();
+	}
+
+	static class Scanner {
+		StringTokenizer st;
+		BufferedReader br;
+
+		public Scanner(InputStream s) {
+			br = new BufferedReader(new InputStreamReader(s));
+		}
+
+		public Scanner(FileReader r) {
+			br = new BufferedReader(r);
+		}
+
+		public String next() throws IOException {
+			while (st == null || !st.hasMoreTokens())
+				st = new StringTokenizer(br.readLine());
+			return st.nextToken();
+		}
+
+		public int nextInt() throws IOException {
+			return Integer.parseInt(next());
+		}
+
+		public long nextLong() throws IOException {
+			return Long.parseLong(next());
+		}
+
+		public String nextLine() throws IOException {
+			return br.readLine();
+		}
+
+		public double nextDouble() throws IOException {
+			String x = next();
+			StringBuilder sb = new StringBuilder(""0"");
+			double res = 0, f = 1;
+			boolean dec = false, neg = false;
+			int start = 0;
+			if (x.charAt(0) == '-') {
+				neg = true;
+				start++;
+			}
+			for (int i = start; i < x.length(); i++)
+				if (x.charAt(i) == '.') {
+					res = Long.parseLong(sb.toString());
+					sb = new StringBuilder(""0"");
+					dec = true;
+				} else {
+					sb.append(x.charAt(i));
+					if (dec)
+						f *= 10;
+				}
+			res += Long.parseLong(sb.toString()) / f;
+			return res * (neg ? -1 : 1);
+		}
+
+		public long[] nextlongArray(int n) throws IOException {
+			long[] a = new long[n];
+			for (int i = 0; i < n; i++)
+				a[i] = nextLong();
+			return a;
+		}
+
+		public Long[] nextLongArray(int n) throws IOException {
+			Long[] a = new Long[n];
+			for (int i = 0; i < n; i++)
+				a[i] = nextLong();
+			return a;
+		}
+
+		public int[] nextIntArray(int n) throws IOException {
+			int[] a = new int[n];
+			for (int i = 0; i < n; i++)
+				a[i] = nextInt();
+			return a;
+		}
+
+		public Integer[] nextIntegerArray(int n) throws IOException {
+			Integer[] a = new Integer[n];
+			for (int i = 0; i < n; i++)
+				a[i] = nextInt();
+			return a;
+		}
+
+		public boolean ready() throws IOException {
+			return br.ready();
+		}
+
+	}
+
+	static class pair implements Comparable<pair> {
+		long x;
+		long y;
+
+		public pair(long x, long y) {
+			this.x = x;
+			this.y = y;
+		}
+
+		public String toString() {
+			return x + "" "" + y;
+		}
+
+		public boolean equals(Object o) {
+			if (o instanceof pair) {
+				pair p = (pair) o;
+				return p.x == x && p.y == y;
+			}
+			return false;
+		}
+
+		public int hashCode() {
+			return new Long(x).hashCode() * 31 + new Long(y).hashCode();
+		}
+
+		public int compareTo(pair other) {
+			if (this.x == other.x) {
+				return Long.compare(this.y, other.y);
+			}
+			return Long.compare(this.x, other.x);
+		}
+	}
+
+	static class tuble implements Comparable<tuble> {
+		int x;
+		int y;
+		int z;
+
+		public tuble(int x, int y, int z) {
+			this.x = x;
+			this.y = y;
+			this.z = z;
+		}
+
+		public String toString() {
+			return x + "" "" + y + "" "" + z;
+		}
+
+		public int compareTo(tuble other) {
+			if (this.x == other.x) {
+				if (this.y == other.y) {
+					return this.z - other.z;
+				}
+				return this.y - other.y;
+			} else {
+				return this.x - other.x;
+			}
+		}
+	}
+
+	static long mod = 1000000007;
+	static Random rn = new Random();
+	static Scanner sc = new Scanner(System.in);
+	static PrintWriter pw = new PrintWriter(System.out);
+}","import java.util.*;
+import java.io.*;
+public class C1615{
+	static FastScanner fs = null;
+	public static void main(String[] args) {
+		fs = new FastScanner();
+		PrintWriter out = new PrintWriter(System.out);
+		int t = fs.nextInt();
+		while (t-->0) {
+			int n = fs.nextInt();
+			String a = fs.next();
+			String b = fs.next();
+			char ch1[] = a.toCharArray();
+			char ch2[] = b.toCharArray();
+			int c00 = 0;
+			int c01 = 0;
+			int c10 = 0;
+			int c11 = 0;
+			for(int i=0;i<n;i++){
+				if(ch1[i]=='0'){
+					if(ch2[i]=='0'){
+						c00+=1;
+					}
+					else{
+						c01+=1;
+					}
+				}
+				else{
+					if(ch2[i]=='0'){
+						c10+=1;
+					}
+					else{
+						c11+=1;
+					}
+				}
+			}
+			int ans = -1;
+			if((c11-c00)==1 || c10==c01){
+				int s1 = (int)1e7; 
+				int s2 = (int)1e7;
+				if((c11-c00)==1){
+					s1 = c11+c00;
+				}
+				if(c10==c01)
+				s2 = c10+c01;
+				ans = Math.min(s1,s2); 
+			}
+			out.println(ans);
+		}
+		out.close();
+	}
+	static void sort(int[] a) {
+		ArrayList<Integer> l=new ArrayList<>();
+		for (int i:a) l.add(i);
+		Collections.sort(l);
+		for (int i=0; i<a.length; i++) a[i]=l.get(i);
+	}
+	static class FastScanner {
+		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st=new StringTokenizer("""");
+		String next() {
+			while (!st.hasMoreTokens())
+				try {
+					st=new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			return st.nextToken();
+		}
+		
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+		int[] readArray(int n) {
+			int[] a=new int[n];
+			for (int i=0; i<n; i++) a[i]=nextInt();
+			return a;
+		}
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+	}
+}",0
+6db218a2,90b71536,"import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.util.InputMismatchException;
+import java.util.*;
+import java.io.*;
+import java.lang.*;
+public class Main{
+    public static class InputReader {
+        private InputStream stream;
+        private byte[] buf = new byte[1024];
+        private int curChar;
+        private int numChars;
+        private InputReader.SpaceCharFilter filter;
+        private BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+     
+        public InputReader(InputStream stream) {
+            this.stream = stream;
+        }
+     
+        public int read() {
+            if (numChars==-1)
+                throw new InputMismatchException();
+     
+            if (curChar >= numChars) {
+                curChar = 0;
+                try {
+                    numChars = stream.read(buf);
+                }
+                catch (IOException e) {
+                    throw new InputMismatchException();
+                }
+     
+                if(numChars <= 0)
+                    return -1;
+            }
+            return buf[curChar++];
+        }
+     
+        public String nextLine() {
+            String str = """";
+            try {
+                str = br.readLine();
+            }
+            catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+        }
+        public int nextInt() {
+            int c = read();
+     
+            while(isSpaceChar(c))
+                c = read();
+     
+            int sgn = 1;
+     
+            if (c == '-') {
+                sgn = -1;
+                c = read();
+            }
+     
+            int res = 0;
+            do {
+                if(c<'0'||c>'9')
+                    throw new InputMismatchException();
+                res *= 10;
+                res += c - '0';
+                c = read();
+            }
+            while (!isSpaceChar(c));
+     
+            return res * sgn;
+        }
+     
+        public long nextLong() {
+            int c = read();
+            while (isSpaceChar(c))
+                c = read();
+            int sgn = 1;
+            if (c == '-') {
+                sgn = -1;
+                c = read();
+            }
+            long res = 0;
+     
+            do {
+                if (c < '0' || c > '9')
+                    throw new InputMismatchException();
+                res *= 10;
+                res += c - '0';
+                c = read();
+            }
+            while (!isSpaceChar(c));
+            return res * sgn;
+        }
+     
+        public double nextDouble() {
+            int c = read();
+            while (isSpaceChar(c))
+                c = read();
+            int sgn = 1;
+            if (c == '-') {
+                sgn = -1;
+                c = read();
+            }
+            double res = 0;
+            while (!isSpaceChar(c) && c != '.') {
+                if (c == 'e' || c == 'E')
+                    return res * Math.pow(10, nextInt());
+                if (c < '0' || c > '9')
+                    throw new InputMismatchException();
+                res *= 10;
+                res += c - '0';
+                c = read();
+            }
+            if (c == '.') {
+                c = read();
+                double m = 1;
+                while (!isSpaceChar(c)) {
+                    if (c == 'e' || c == 'E')
+                        return res * Math.pow(10, nextInt());
+                    if (c < '0' || c > '9')
+                        throw new InputMismatchException();
+                    m /= 10;
+                    res += (c - '0') * m;
+                    c = read();
+                }
+            }
+            return res * sgn;
+        }
+     
+        public String readString() {
+            int c = read();
+            while (isSpaceChar(c))
+                c = read();
+            StringBuilder res = new StringBuilder();
+            do {
+                res.appendCodePoint(c);
+                c = read();
+            }
+            while (!isSpaceChar(c));
+     
+            return res.toString();
+        }
+     
+        public boolean isSpaceChar(int c) {
+            if (filter != null)
+                return filter.isSpaceChar(c);
+            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
+        }
+     
+        public String next() {
+            return readString();
+        }
+     
+        public interface SpaceCharFilter {
+            public boolean isSpaceChar(int ch);
+        }
+    }
+ 
+    static long gcd(long a, long b){
+        if (a == 0)
+            return b;  
+        return gcd(b % a, a);  
+    }
+    static long lcm(long a, long b)  {
+        return (a*b)/gcd(a, b);  
+    }
+    public static void sortbyColumn(int arr[][], int col) 
+    { 
+        
+        Arrays.sort(arr, new Comparator<int[]>() { 
+            
+          @Override              
+          
+          public int compare(final int[] entry1,  
+                             final int[] entry2) { 
+  
+            
+            if (entry1[col] > entry2[col]) 
+                return 1; 
+            else
+                return -1; 
+          } 
+        });  
+    } 
+    static long func(long a[],int size,int s){
+        long max1=a[s];
+        long maxc=a[s];
+        for(int i=s+1;i<size;i++){
+            maxc=Math.max(a[i],maxc+a[i]);
+            max1=Math.max(maxc,max1);
+        }
+        return max1;
+    }
+    public static class Pair<U extends Comparable<U>, V extends Comparable<V>> implements Comparable<Pair<U, V>> {
+        public U x;
+        public V y;
+    
+        public Pair(U x, V y) {
+            this.x = x;
+            this.y = y;
+        }
+    
+        public int hashCode() {
+            return (x == null ? 0 : x.hashCode() * 31) + (y == null ? 0 : y.hashCode());
+        }
+    
+        public boolean equals(Object o) {
+            if (this == o)
+                return true;
+            if (o == null || getClass() != o.getClass())
+                return false;
+            Pair<U, V> p = (Pair<U, V>) o;
+            return (x == null ? p.x == null : x.equals(p.x)) && (y == null ? p.y == null : y.equals(p.y));
+        }
+    
+        public int compareTo(Pair<U, V> b) {
+            int cmpU = x.compareTo(b.x);
+            return cmpU != 0 ? cmpU : y.compareTo(b.y);
+        }
+    
+        public String toString() {
+            return String.format(""(%s, %s)"", x.toString(), y.toString());
+        }
+    
+    }
+    static class MultiSet<U extends Comparable<U>> {
+        public int sz = 0;
+        public TreeMap<U, Integer> t;
+ 
+        public MultiSet() {
+            t = new TreeMap<>();
+        }
+ 
+        public void add(U x) {
+            t.put(x, t.getOrDefault(x, 0) + 1);
+            sz++;
+        }
+ 
+        public void remove(U x) {
+            if (t.get(x) == 1) t.remove(x);
+            else t.put(x, t.get(x) - 1);
+            sz--;
+        }
+ 
+    }
+    static void shuffle(long[] a) {
+        Random get = new Random();
+        for (int i = 0; i < a.length; i++) {
+            int r = get.nextInt(a.length);
+            long temp = a[i];
+            a[i] = a[r];
+            a[r] = temp;
+        }
+    }
+    static long myceil(long a, long b){
+        return (a+b-1)/b;
+    }
+    
+    static long C(long n,long r){
+        long count=0,temp=n;
+        long ans=1;
+        long num=n-r+1,div=1;
+        while(num<=n){
+            ans*=num;
+            //ans+=MOD;
+            ans%=MOD;
+            ans*=mypow(div,MOD-2);
+            //ans+=MOD;
+            ans%=MOD;
+            num++;
+            div++;
+        }
+        
+        ans+=MOD;
+        return ans%MOD;
+    }
+    static long fact(long a){
+        long i,ans=1;
+        for(i=1;i<=a;i++){
+            ans*=i;
+            ans%=MOD;
+        }
+        return ans%=MOD;
+    }
+    static void sieve(int n){
+        is_sieve[0]=1;
+        is_sieve[1]=1;
+        int i,j,k;
+        for(i=2;i<n;i++){
+            if(is_sieve[i]==0){
+                sieve[i]=i;
+                tr.add(i);
+                for(j=i*i;j<n;j+=i){
+                    if(j>n||j<0){
+                        break;
+                    }
+                    is_sieve[j]=1;
+                    sieve[j]=i;
+                }
+            }
+        }
+    }
+    // static void calc(int n){
+    //     int i,j;
+    //     dp[n-1]=0;
+    //     if(n>1)
+    //     dp[n-2]=1;
+    //     for(i=n-3;i>=0;i--){
+    //         long ind=n-i-1;
+    //         dp[i]=((ind*(long)mypow(10,ind-1))%MOD+dp[i+1])%MOD;
+    //     }
+    // }
+    static long mypow(long x,long y){
+        long temp; 
+        if( y == 0) 
+            return 1; 
+        temp = mypow(x, y/2); 
+        if (y%2 == 0) 
+            return (temp*temp)%MOD; 
+        else
+            return ((x*temp)%MOD*(temp)%MOD)%MOD; 
+    }
+    static long dist[],dp[][],left[],right[];
+    static int visited[],isit[];
+    static ArrayList<Pair<Integer,Pair<Long,Long>>> adj[],li;
+    //static int dp[][][];
+    static int MOD=1000000007;
+    static char ch[];
+    static int[] sieve,is_sieve;
+    static TreeSet<Integer> tr;
+    static long mat[][];
+    
+    
+    static void dfs(int node,int par, Pair<Long,Long> p[]){
+        for(Pair<Integer,Pair<Long,Long>> pp:adj[node]){
+            if(pp.x!=par){
+                //sum+=Math.abs(selected[node]-selected[pp.x]);
+                dfs(pp.x,node,p);
+                //System.out.println(node+"" ""+pp.x);
+                long x=Math.abs(p[node].x-p[pp.x].x);
+                long y=Math.abs(p[node].x-p[pp.x].y);
+                long z=Math.abs(p[node].y-p[pp.x].x);
+                long w=Math.abs(p[node].y-p[pp.x].y);
+                
+                left[node]+=Math.max(x+left[pp.x],y+right[pp.x]);
+                right[node]+=Math.max(z+left[pp.x],w+right[pp.x]);
+                
+            }
+        }
+    }
+    
+    public static void main(String args[]){
+        InputStream inputStream = System.in;
+        OutputStream outputStream = System.out;
+        InputReader in = new InputReader(inputStream);
+        PrintWriter w = new PrintWriter(outputStream);
+        int t,i,j,tno=0,tte;
+        
+        t=in.nextInt();
+        //t=1;
+        //tte=t;
+        
+        while(t-->0){
+            //sum=0;
+            int n=in.nextInt();
+            adj=new ArrayList[n+1];
+            left=new long[n+1];
+            right=new long[n+1];
+            visited=new int[n+1];
+            for(i=0;i<n+1;i++){
+                adj[i]=new ArrayList<>();
+            }
+            Pair<Long,Long> p[]=new Pair[n+1];
+            for(i=1;i<=n;i++){
+                p[i]=new Pair<>(in.nextLong(),in.nextLong());
+            } 
+            for(i=0;i<n-1;i++){
+                int u,v;
+                u=in.nextInt();
+                v=in.nextInt();
+                adj[u].add(new Pair<>(v,p[v]));
+                adj[v].add(new Pair<>(u,p[u]));
+            }
+            
+            dfs(1,-1,p);
+            // for(i=0;i<n+1;i++){
+            //     w.print(selected[i]+"" "");
+            // }
+            // w.println();
+            w.println((long)Math.max(left[1],right[1]));
+        }
+        w.close();
+    }
+}
+","import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.util.InputMismatchException;
+import java.util.*;
+import java.io.*;
+import java.lang.*;
+public class Main{
+    public static class InputReader {
+        private InputStream stream;
+        private byte[] buf = new byte[1024];
+        private int curChar;
+        private int numChars;
+        private InputReader.SpaceCharFilter filter;
+        private BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+     
+        public InputReader(InputStream stream) {
+            this.stream = stream;
+        }
+     
+        public int read() {
+            if (numChars==-1)
+                throw new InputMismatchException();
+     
+            if (curChar >= numChars) {
+                curChar = 0;
+                try {
+                    numChars = stream.read(buf);
+                }
+                catch (IOException e) {
+                    throw new InputMismatchException();
+                }
+     
+                if(numChars <= 0)
+                    return -1;
+            }
+            return buf[curChar++];
+        }
+     
+        public String nextLine() {
+            String str = """";
+            try {
+                str = br.readLine();
+            }
+            catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+        }
+        public int nextInt() {
+            int c = read();
+     
+            while(isSpaceChar(c))
+                c = read();
+     
+            int sgn = 1;
+     
+            if (c == '-') {
+                sgn = -1;
+                c = read();
+            }
+     
+            int res = 0;
+            do {
+                if(c<'0'||c>'9')
+                    throw new InputMismatchException();
+                res *= 10;
+                res += c - '0';
+                c = read();
+            }
+            while (!isSpaceChar(c));
+     
+            return res * sgn;
+        }
+     
+        public long nextLong() {
+            int c = read();
+            while (isSpaceChar(c))
+                c = read();
+            int sgn = 1;
+            if (c == '-') {
+                sgn = -1;
+                c = read();
+            }
+            long res = 0;
+     
+            do {
+                if (c < '0' || c > '9')
+                    throw new InputMismatchException();
+                res *= 10;
+                res += c - '0';
+                c = read();
+            }
+            while (!isSpaceChar(c));
+            return res * sgn;
+        }
+     
+        public double nextDouble() {
+            int c = read();
+            while (isSpaceChar(c))
+                c = read();
+            int sgn = 1;
+            if (c == '-') {
+                sgn = -1;
+                c = read();
+            }
+            double res = 0;
+            while (!isSpaceChar(c) && c != '.') {
+                if (c == 'e' || c == 'E')
+                    return res * Math.pow(10, nextInt());
+                if (c < '0' || c > '9')
+                    throw new InputMismatchException();
+                res *= 10;
+                res += c - '0';
+                c = read();
+            }
+            if (c == '.') {
+                c = read();
+                double m = 1;
+                while (!isSpaceChar(c)) {
+                    if (c == 'e' || c == 'E')
+                        return res * Math.pow(10, nextInt());
+                    if (c < '0' || c > '9')
+                        throw new InputMismatchException();
+                    m /= 10;
+                    res += (c - '0') * m;
+                    c = read();
+                }
+            }
+            return res * sgn;
+        }
+     
+        public String readString() {
+            int c = read();
+            while (isSpaceChar(c))
+                c = read();
+            StringBuilder res = new StringBuilder();
+            do {
+                res.appendCodePoint(c);
+                c = read();
+            }
+            while (!isSpaceChar(c));
+     
+            return res.toString();
+        }
+     
+        public boolean isSpaceChar(int c) {
+            if (filter != null)
+                return filter.isSpaceChar(c);
+            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
+        }
+     
+        public String next() {
+            return readString();
+        }
+     
+        public interface SpaceCharFilter {
+            public boolean isSpaceChar(int ch);
+        }
+    }
+ 
+    static long gcd(long a, long b){
+        if (a == 0)
+            return b;  
+        return gcd(b % a, a);  
+    }
+    static long lcm(long a, long b)  {
+        return (a*b)/gcd(a, b);  
+    }
+    public static void sortbyColumn(int arr[][], int col) 
+    { 
+        
+        Arrays.sort(arr, new Comparator<int[]>() { 
+            
+          @Override              
+          
+          public int compare(final int[] entry1,  
+                             final int[] entry2) { 
+  
+            
+            if (entry1[col] > entry2[col]) 
+                return 1; 
+            else
+                return -1; 
+          } 
+        });  
+    } 
+    static long func(long a[],int size,int s){
+        long max1=a[s];
+        long maxc=a[s];
+        for(int i=s+1;i<size;i++){
+            maxc=Math.max(a[i],maxc+a[i]);
+            max1=Math.max(maxc,max1);
+        }
+        return max1;
+    }
+    public static class Pair<U extends Comparable<U>, V extends Comparable<V>> implements Comparable<Pair<U, V>> {
+        public U x;
+        public V y;
+    
+        public Pair(U x, V y) {
+            this.x = x;
+            this.y = y;
+        }
+    
+        public int hashCode() {
+            return (x == null ? 0 : x.hashCode() * 31) + (y == null ? 0 : y.hashCode());
+        }
+    
+        public boolean equals(Object o) {
+            if (this == o)
+                return true;
+            if (o == null || getClass() != o.getClass())
+                return false;
+            Pair<U, V> p = (Pair<U, V>) o;
+            return (x == null ? p.x == null : x.equals(p.x)) && (y == null ? p.y == null : y.equals(p.y));
+        }
+    
+        public int compareTo(Pair<U, V> b) {
+            int cmpU = x.compareTo(b.x);
+            return cmpU != 0 ? cmpU : y.compareTo(b.y);
+        }
+    
+        public String toString() {
+            return String.format(""(%s, %s)"", x.toString(), y.toString());
+        }
+    
+    }
+    static class MultiSet<U extends Comparable<U>> {
+        public int sz = 0;
+        public TreeMap<U, Integer> t;
+ 
+        public MultiSet() {
+            t = new TreeMap<>();
+        }
+ 
+        public void add(U x) {
+            t.put(x, t.getOrDefault(x, 0) + 1);
+            sz++;
+        }
+ 
+        public void remove(U x) {
+            if (t.get(x) == 1) t.remove(x);
+            else t.put(x, t.get(x) - 1);
+            sz--;
+        }
+ 
+    }
+    static void shuffle(long[] a) {
+        Random get = new Random();
+        for (int i = 0; i < a.length; i++) {
+            int r = get.nextInt(a.length);
+            long temp = a[i];
+            a[i] = a[r];
+            a[r] = temp;
+        }
+    }
+    static long myceil(long a, long b){
+        return (a+b-1)/b;
+    }
+    
+    static long C(long n,long r){
+        long count=0,temp=n;
+        long ans=1;
+        long num=n-r+1,div=1;
+        while(num<=n){
+            ans*=num;
+            //ans+=MOD;
+            ans%=MOD;
+            ans*=mypow(div,MOD-2);
+            //ans+=MOD;
+            ans%=MOD;
+            num++;
+            div++;
+        }
+        
+        ans+=MOD;
+        return ans%MOD;
+    }
+    static long fact(long a){
+        long i,ans=1;
+        for(i=1;i<=a;i++){
+            ans*=i;
+            ans%=MOD;
+        }
+        return ans%=MOD;
+    }
+    static void sieve(int n){
+        is_sieve[0]=1;
+        is_sieve[1]=1;
+        int i,j,k;
+        for(i=2;i<n;i++){
+            if(is_sieve[i]==0){
+                sieve[i]=i;
+                tr.add(i);
+                for(j=i*i;j<n;j+=i){
+                    if(j>n||j<0){
+                        break;
+                    }
+                    is_sieve[j]=1;
+                    sieve[j]=i;
+                }
+            }
+        }
+    }
+    // static void calc(int n){
+    //     int i,j;
+    //     dp[n-1]=0;
+    //     if(n>1)
+    //     dp[n-2]=1;
+    //     for(i=n-3;i>=0;i--){
+    //         long ind=n-i-1;
+    //         dp[i]=((ind*(long)mypow(10,ind-1))%MOD+dp[i+1])%MOD;
+    //     }
+    // }
+    static long mypow(long x,long y){
+        long temp; 
+        if( y == 0) 
+            return 1; 
+        temp = mypow(x, y/2); 
+        if (y%2 == 0) 
+            return (temp*temp)%MOD; 
+        else
+            return ((x*temp)%MOD*(temp)%MOD)%MOD; 
+    }
+    static long dist[],dp[][],left[],right[];
+    static int visited[],isit[];
+    static ArrayList<Pair<Integer,Pair<Long,Long>>> adj[],li;
+    //static int dp[][][];
+    static int MOD=1000000007;
+    static char ch[];
+    static int[] sieve,is_sieve;
+    static TreeSet<Integer> tr;
+    static long mat[][];
+    
+    // static void bfs(int node,int par,Pair<Long,Long> p[],long taken){
+    //     LinkedList<Integer> li=new LinkedList<>();
+    //     li.add(node);
+        
+    //     while(!li.isEmpty()){
+    //         int x=li.pollFirst();
+    //         long lowNode=p[x-1].x;
+    //         long highNode=p[x-1].y;
+    //         int left=0,right=0;
+    //         visited[x]=1;
+    //         for(Pair<Integer,Pair<Long,Long>> pp:adj[x]){
+                    
+    //                 long max=0;
+                    
+    //                 if(selected[pp.x]==0){
+    //                     max=Math.max(Math.abs(lowNode-pp.y.y),Math.abs(highNode-pp.y.x));
+                        
+    //                     if(max==Math.abs(lowNode-pp.y.y)){
+                            
+    //                         left++;
+    //                     }else{
+                            
+    //                         right++;
+    //                     }
+    //                 }else{
+    //                     max=Math.max(Math.abs(lowNode-selected[pp.x]),Math.abs(highNode-selected[pp.x]));
+    //                     if(max==Math.abs(lowNode-selected[pp.x])){
+                            
+    //                         left++;
+    //                     }else{
+                            
+    //                         right++;
+    //                     }
+    //                 }
+    //                 if(visited[pp.x]==0)
+    //                 li.add(pp.x);
+                
+    //         }
+    //         if(left>=right){
+    //             selected[x]=lowNode;
+    //         }else{
+    //             selected[x]=highNode;
+    //         }
+    //     }
+    // }
+    static void dfs(int node,int par, Pair<Long,Long> p[]){
+        for(Pair<Integer,Pair<Long,Long>> pp:adj[node]){
+            if(pp.x!=par){
+                //sum+=Math.abs(selected[node]-selected[pp.x]);
+                dfs(pp.x,node,p);
+                //System.out.println(node+"" ""+pp.x);
+                long x=Math.abs(p[node].x-p[pp.x].x);
+                long y=Math.abs(p[node].x-p[pp.x].y);
+                long z=Math.abs(p[node].y-p[pp.x].x);
+                long w=Math.abs(p[node].y-p[pp.x].y);
+                
+                left[node]+=Math.max(x+left[pp.x],y+right[pp.x]);
+                right[node]+=Math.max(z+left[pp.x],w+right[pp.x]);
+                
+            }
+        }
+    }
+    
+    public static void main(String args[]){
+        InputStream inputStream = System.in;
+        OutputStream outputStream = System.out;
+        InputReader in = new InputReader(inputStream);
+        PrintWriter w = new PrintWriter(outputStream);
+        int t,i,j,tno=0,tte;
+        
+        t=in.nextInt();
+        //t=1;
+        //tte=t;
+        
+        while(t-->0){
+            //sum=0;
+            int n=in.nextInt();
+            adj=new ArrayList[n+1];
+            left=new long[n+1];
+            right=new long[n+1];
+            visited=new int[n+1];
+            for(i=0;i<n+1;i++){
+                adj[i]=new ArrayList<>();
+            }
+            Pair<Long,Long> p[]=new Pair[n+1];
+            for(i=1;i<=n;i++){
+                p[i]=new Pair<>(in.nextLong(),in.nextLong());
+            } 
+            for(i=0;i<n-1;i++){
+                int u,v;
+                u=in.nextInt();
+                v=in.nextInt();
+                adj[u].add(new Pair<>(v,p[v]));
+                adj[v].add(new Pair<>(u,p[u]));
+            }
+            //bfs(1,-1,p,Long.MAX_VALUE);
+            dfs(1,-1,p);
+            // for(i=0;i<n+1;i++){
+            //     w.print(selected[i]+"" "");
+            // }
+            // w.println();
+            w.println((long)Math.max(left[1],right[1]));
+        }
+        w.close();
+    }
+}",1
+3380fa52,e1a5831a,"import java.util.*;
+import java.io.*;
+import java.math.*;
+
+/* Name of the class has to be ""Main"" only if the class is public. */
+public class Coder {
+  static int n, k;
+  static long a[];
+  static int pos[];
+  static int temp[];
+  static StringBuilder str = new StringBuilder("""");
+  static int cnt[][] = new int[(int)1e5+5][2];
+  static void solve() {
+    long []l = new long[n];
+    long []r = new long[n];
+    long p = Integer.MAX_VALUE;
+    for(int i=0;i<n;i++){
+        p = Math.min(p+1, a[i]);
+        l[i] = p;
+    }
+    p=Integer.MAX_VALUE;
+    for(int i=n-1;i>=0;i--){
+     p = Math.min(p+1, a[i]);
+     r[i] = p;
+    }
+    for(int i=0;i<n;i++){
+        str.append(Math.min(l[i],r[i])).append("" "");
+    }
+    str.append(""\n"");
+  }
+
+  public static void main(String[] args) throws java.lang.Exception {
+    BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
+    int t = Integer.parseInt(bf.readLine().trim());
+    while (t-- > 0) {
+      bf.readLine();
+      String s[] = bf.readLine().trim().split(""\\s+"");
+      n = Integer.parseInt(s[0]);
+      k = Integer.parseInt(s[1]);
+      s = bf.readLine().trim().split(""\\s+"");
+      pos = new int[k];
+      temp = new int[k];
+      a = new long[n];
+      for(int i=0;i<k;i++) pos[i]=Integer.parseInt(s[i]);
+      s = bf.readLine().trim().split(""\\s+"");
+      for(int i=0;i<k;i++) temp[i]=Integer.parseInt(s[i]);
+      Arrays.fill(a, Integer.MAX_VALUE);
+      for(int i=0;i<k;i++) a[pos[i]-1] = temp[i]; 
+      solve();
+    }
+    System.out.print(str);
+  }
+}","/* package codechef; // don't place package name! */
+
+import java.util.*;
+import java.lang.*;
+import java.io.*;
+
+/* Name of the class has to be ""Main"" only if the class is public. */
+public class Codechef
+{
+	public static void main (String[] args) throws java.lang.Exception
+	{
+		// your code goes here
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		int t = Integer.parseInt(br.readLine());
+		for(int q=0;q<t;q++){
+		    //  int n = Integer.parseInt(br.readLine());
+		      String s = br.readLine();
+                  String s1[] = br.readLine().split("" "");
+                  int n = Integer.parseInt(s1[0]);
+                  int k = Integer.parseInt(s1[1]);
+                  String s2[] = br.readLine().split("" "");
+                  int a[] = new int[k];
+                  for(int i=0;i<k;i++){
+                        a[i] = Integer.parseInt(s2[i]);
+                  }
+                  String s3[] = br.readLine().split("" "");
+                  int b[] = new int[k];
+                  for(int i=0;i<k;i++){
+                        b[i] = Integer.parseInt(s3[i]);
+                  }
+                  long ans[] = new long[n];
+                  for(int i=0;i<n;i++){
+                        ans[i] = Integer.MAX_VALUE;
+                  }
+                  for(int i=0;i<k;i++){
+                        ans[a[i]-1] = b[i];
+                  }
+                  for(int i=1;i<n;i++){
+                        ans[i] = Math.min(ans[i],ans[i-1]+1);
+                  }
+                  for(int i=n-2;i>=0;i--){
+                        ans[i] = Math.min(ans[i],ans[i+1]+1);
+                  }
+                  
+                  for(int i=0;i<n;i++){
+                        System.out.print(ans[i]+"" "");
+                  }
+                  System.out.println();
+		}
+	}
+}
+
+",0
+90dc2b20,f229aa7f,"import java.util.*;
+import java.io.*;
+public class C1615{
+	static FastScanner fs = null;
+	public static void main(String[] args) {
+		fs = new FastScanner();
+		PrintWriter out = new PrintWriter(System.out);
+		int t = fs.nextInt();
+		while (t-->0) {
+			int n = fs.nextInt();
+			String a = fs.next();
+			String b = fs.next();
+			char ch1[] = a.toCharArray();
+			char ch2[] = b.toCharArray();
+			int c00 = 0;
+			int c01 = 0;
+			int c10 = 0;
+			int c11 = 0;
+			for(int i=0;i<n;i++){
+				if(ch1[i]=='0'){
+					if(ch2[i]=='0'){
+						c00+=1;
+					}
+					else{
+						c01+=1;
+					}
+				}
+				else{
+					if(ch2[i]=='0'){
+						c10+=1;
+					}
+					else{
+						c11+=1;
+					}
+				}
+			}
+			int ans = -1;
+			if((c11-c00)==1 || c10==c01){
+				int s1 = (int)1e7; 
+				int s2 = (int)1e7;
+				if((c11-c00)==1){
+					s1 = c11+c00;
+				}
+				if(c10==c01)
+				s2 = c10+c01;
+				ans = Math.min(s1,s2); 
+			}
+			out.println(ans);
+		}
+		out.close();
+	}
+	static void sort(int[] a) {
+		ArrayList<Integer> l=new ArrayList<>();
+		for (int i:a) l.add(i);
+		Collections.sort(l);
+		for (int i=0; i<a.length; i++) a[i]=l.get(i);
+	}
+	static class FastScanner {
+		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st=new StringTokenizer("""");
+		String next() {
+			while (!st.hasMoreTokens())
+				try {
+					st=new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			return st.nextToken();
+		}
+		
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+		int[] readArray(int n) {
+			int[] a=new int[n];
+			for (int i=0; i<n; i++) a[i]=nextInt();
+			return a;
+		}
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+	}
+}","import java.util.*;
+import java.io.*;
+import java.math.*;
+
+public class cf {
+	static PrintWriter pw = new PrintWriter(System.out);
+
+	public static void main(String[] args) throws IOException, InterruptedException {
+		Scanner sc = new Scanner(System.in);
+		int t = sc.nextInt();
+		while (t-- > 0) {
+			int n = sc.nextInt();
+			char[] a = sc.next().toCharArray();
+			char[] b = sc.next().toCharArray();
+			int x = 0, y = 0, lit = 0,lit2 = 0;
+			for (int i = 0; i < n; i++) {
+				if (a[i] == '1')
+					lit++;
+				if (b[i] == '1')
+					lit2++;
+				if (a[i] == b[i])
+					x++;
+				else
+					y++;
+			}
+			if(lit == lit2 || n - lit + 1 == lit2) {
+				if (lit == lit2 && n - lit + 1 == lit2) {
+					pw.println(Math.min(x,y));
+				}else if(lit == lit2) {
+					pw.println(y);
+				}else {
+					pw.println(x);
+				}
+			}else {
+				pw.println(-1);
+			}
+		}
+		pw.close();
+	}
+
+	public static class tuble implements Comparable<tuble> {
+		int x;
+		int y;
+		int z;
+
+		public tuble(int x, int y, int z) {
+			this.x = x;
+			this.y = y;
+			this.z = z;
+		}
+
+		public String toString() {
+			return x + "" "" + y + "" "" + z;
+		}
+
+		public int compareTo(tuble other) {
+			if (this.x == other.x) {
+				if (this.y == other.y)
+					return this.z - other.z;
+				return this.y - other.y;
+			} else {
+				return this.x - other.x;
+			}
+		}
+	}
+
+	public static class pair implements Comparable<pair> {
+		int x;
+		int y;
+
+		public pair(int x, int y) {
+			this.x = x;
+			this.y = y;
+		}
+
+		public String toString() {
+			return x + "" "" + y;
+		}
+
+		public boolean equals(Object o) {
+			if (o instanceof pair) {
+				pair p = (pair) o;
+				return p.x == x && p.y == y;
+			}
+			return false;
+		}
+
+		public int hashCode() {
+			return new Integer(x).hashCode() * 31 + new Integer(y).hashCode();
+		}
+
+		public int compareTo(pair other) {
+			if (this.x == other.x) {
+				return Long.compare(this.y, other.y);
+			}
+			return Long.compare(this.x, other.x);
+		}
+	}
+
+	static class Scanner {
+		StringTokenizer st;
+		BufferedReader br;
+
+		public Scanner(InputStream s) {
+			br = new BufferedReader(new InputStreamReader(s));
+		}
+
+		public Scanner(FileReader r) {
+			br = new BufferedReader(r);
+		}
+
+		public String next() throws IOException {
+			while (st == null || !st.hasMoreTokens())
+				st = new StringTokenizer(br.readLine());
+			return st.nextToken();
+		}
+
+		public int nextInt() throws IOException {
+			return Integer.parseInt(next());
+		}
+
+		public long nextLong() throws IOException {
+			return Long.parseLong(next());
+		}
+
+		public String nextLine() throws IOException {
+			return br.readLine();
+		}
+
+		public double nextDouble() throws IOException {
+			return Double.parseDouble(next());
+		}
+
+		public boolean ready() throws IOException {
+			return br.ready();
+		}
+
+	}
+
+}",0
+4a570de6,6c4ac8d3,"import java.io.*;
+import java.lang.*;
+import java.util.*;
+public class c
+{
+static class FastScanner {
+InputStreamReader is;
+BufferedReader br;
+StringTokenizer st;
+public FastScanner() {
+is = new InputStreamReader(System.in);
+br = new BufferedReader(is);
+}
+String next() throws Exception {
+while (st == null || !st.hasMoreElements())
+st = new StringTokenizer(br.readLine());
+return st.nextToken();
+}
+int ni() throws Exception {
+return Integer.parseInt(next());
+}
+long nextLong() throws Exception {
+return Long.parseLong(next());
+}
+int[] readArray(int num) throws Exception {
+int arr[]=new int[num];
+for(int i=0;i<num;i++)
+arr[i]=ni();
+return arr;
+}
+String nextLine() throws Exception {
+return br.readLine();
+}
+}
+ public static boolean power_of_two(int a)
+{
+  if((a&(a-1))==0)
+{
+ return true;
+}
+return false;
+}
+static boolean PS(double x)
+{
+if (x >= 0) {
+double i= Math.sqrt(x);
+if(i%1!=0)
+{
+return false;
+}
+return ((i * i) == x);
+}
+return false;
+}
+public static int[] ia(int n)
+{
+    int ar[]=new int[n];
+    return ar;
+}
+public static long[] la(int n)
+{
+    long ar[]=new long[n];
+    return ar;
+}
+
+static class pair implements Comparable<pair>{
+    int ht;
+    int id;
+    pair(int ht, int id)
+{
+    this.ht=ht;
+    this.id=id;
+}
+public int compareTo(pair p)
+{
+    return this.ht-p.ht;
+}
+}
+public static void main(String args[]) throws java.lang.Exception
+{
+FastScanner sc=new FastScanner();
+ int t=sc.ni();
+while(t-->0)
+{
+    int n=sc.ni();
+    int m=sc.ni();
+    int x=sc.ni();
+    int ar[]=ia(n);
+for(int i=0;i<n;i++)
+{
+ar[i]=sc.ni();
+}
+System.out.println(""YES"");
+PriorityQueue<pair> pq=new PriorityQueue<>();
+ for(int i=0;i<m;i++)
+ {
+pq.add(new pair(0,i+1));
+ }                     
+ int i=0;
+ while(i<n)
+ {
+     pair pp=pq.remove();
+pp.ht+=ar[i];
+System.out.print(pp.id+"" "");
+pq.add(pp);
+i++;
+ }   
+System.out.println();
+}
+}
+}","import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.PriorityQueue;
+import java.util.Queue;
+import java.util.Scanner;
+import java.io.*;
+
+
+public class ieee1{
+
+    
+    public static void main(String[] args) {
+           Scanner scn=new Scanner(System.in);
+           int t=scn.nextInt();
+           while(t-->0){
+               HashMap<Integer,Integer> map=new HashMap<>();
+              
+               int b=scn.nextInt();
+               int m=scn.nextInt();
+               int x=scn.nextInt();
+               int[] arr=new int[b];
+               PriorityQueue<Node> pq=new PriorityQueue<>(new pqc());
+               for(int i=0;i<b;i++){
+                   int ele=scn.nextInt();
+                   
+                  
+                   arr[i]=ele;
+               }
+               for(int i=1;i<=m;i++){
+                   pq.add(new Node(i,0));
+               }
+               System.out.println(""YES"");
+               for(int i=0;i<arr.length;i++){
+                   int ele=arr[i];
+                   Node n=pq.poll();
+                   System.out.print(n.ind+"" "");
+                   n.data+=ele;
+                   pq.add(n);
+               }
+               System.out.println();
+              
+              
+    }
+}
+    public static class Node{
+        int ind;
+        int data;
+        Node(int ind,int data){
+            this.ind=ind;
+            this.data=data;
+        }
+    }
+    public static class pqc implements Comparator<Node>{
+        
+        public int compare(Node n1,Node n2){
+            if(n1.data<n2.data){
+                return -1;
+            }
+            else if(n1.data>n2.data){
+                return 1;
+            }
+            else{
+                return 0;
+            }
+        }
+    }
+
+}
+            
+        ",0
+e185bce5,f3d7ce08,"
+import java.util.*;
+
+import java.io.*;
+import java.math.BigInteger;
+import java.nio.charset.StandardCharsets;
+	
+public class Main {
+		private static FS sc = new FS();
+		
+		private static class FS {
+			BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+			StringTokenizer st = new StringTokenizer("""");
+			String next() {
+				while (!st.hasMoreTokens())
+					try {
+						st=new StringTokenizer(br.readLine());				               
+		            } catch (IOException e) {}
+				return st.nextToken();
+			}
+			
+			int nextInt() {
+				return Integer.parseInt(next());
+			}
+			long nextLong() {
+				return Long.parseLong(next());
+			}
+		}
+		
+		private static class extra {
+			
+			static int[] intArr(int size) {
+				int[] a = new int[size];
+				for(int i = 0; i < size; i++) a[i] = sc.nextInt();
+				return a;
+			}
+			
+			static long[] longArr(int size) {
+				Scanner scc = new Scanner(System.in);
+				long[] a = new long[size];
+				for(int i = 0; i < size; i++) a[i] = sc.nextLong();
+				return a;
+			}
+			
+			static long intSum(int[] a) {
+				long sum = 0; 
+				for(int i = 0; i < a.length; i++) {
+					sum += a[i];
+				}
+				return sum;
+			}
+			
+			static long longSum(long[] a) {
+				long sum = 0; 
+				for(int i = 0; i < a.length; i++) {
+					sum += a[i];
+				}
+				return sum;
+			}
+			
+			static LinkedList[] graphD(int vertices, int edges) {
+				LinkedList<Integer>[] temp = new LinkedList[vertices+1];
+				for(int i = 0; i <= vertices; i++) temp[i] = new LinkedList<>();
+				for(int i = 0; i < edges; i++) {
+					int x = sc.nextInt();
+					int y = sc.nextInt();
+					temp[x].add(y);
+				}
+				return temp;
+			}
+			
+			static LinkedList[] graphUD(int vertices, int edges) {
+				LinkedList<Integer>[] temp = new LinkedList[vertices+1];
+				for(int i = 0; i <= vertices; i++) temp[i] = new LinkedList<>();
+				for(int i = 0; i < edges; i++) {
+					int x = sc.nextInt();
+					int y = sc.nextInt();
+					temp[x].add(y);
+					temp[y].add(x);
+				}
+				return temp;
+			}
+			
+			static void printG(LinkedList[] temp) { for(LinkedList<Integer> aa:temp) System.out.println(aa); }
+			
+			static long cal(long val, long pow, long mod) {
+				if(pow == 0) return 1;
+				long res = cal(val, pow/2, mod);
+				
+				long ret = (res*res)%mod;
+				if(pow%2 == 0) return ret;
+				return (val*ret)%mod;
+			}
+			
+			static long gcd(long a, long b) { return b == 0 ? a:gcd(b, a%b); }
+			
+		}
+		
+		static int mod = (int) 1e9;
+		
+		static LinkedList<Integer>[] temp, idx;
+		static long inf = (long) Long.MAX_VALUE;
+//		static long inf = Long.MAX_VALUE;
+//		static int max;
+		
+		public static void main(String[] args) { 
+			int t = sc.nextInt();
+//			int t = 1;
+			StringBuilder ret = new StringBuilder();
+			while(t-- > 0) {
+				int n = sc.nextInt();
+				String a = sc.next(), b = sc.next();
+				int _00 = 0, _01 = 0, _10 = 0, _11 = 0;
+				for(int i = 0; i < n; i++) {
+					if(a.charAt(i) == '0' && b.charAt(i) == '0') _00++;
+					if(a.charAt(i) == '0' && b.charAt(i) == '1') _01++;
+					if(a.charAt(i) == '1' && b.charAt(i) == '0') _10++;
+					if(a.charAt(i) == '1' && b.charAt(i) == '1') _11++;
+				}
+				int ans = Integer.MAX_VALUE;
+				if(_10 == _01) ans = _01 + _10;
+				if(_10 > 0) {
+					int n00 = _10 - 1;
+		            int n01 = _11;
+		            int n10 = _00 + 1;
+		            int n11 = _01;
+		            if (n01 == n10) {
+		                ans = Math.min(ans, 1 + n01 + n10);
+		            }
+				}
+				if(_11 > 0) {
+					int n00 = _10;
+		            int n01 = _11 - 1;
+		            int n10 = _00;
+		            int n11 = _01 + 1;
+		            if (n01 == n10) {
+		                ans = Math.min(ans, 1 + n01 + n10);
+		            }
+				}
+				ret.append(ans == Integer.MAX_VALUE ? -1 : ans);
+				ret.append(""\n"");
+			}
+			System.out.println(ret);
+		}
+
+	}
+
+	
+	
+
+
+	
+	
+	
+","import javax.swing.plaf.IconUIResource;
+import java.lang.reflect.Array;
+import java.text.CollationElementIterator;
+import java.util.*;
+import java.io.*;
+ 
+//Timus judge id- 323935JJ
+ 
+ 
+public class Main {
+ 
+ 
+ 
+ 
+    //----------------------------------------------------------------------------------------------
+    public static class Pair implements Comparable<Pair> {
+        int x=0,y=0;
+        int z=0;
+        public Pair(int a, int b) {
+            this.x=a;
+            this.y=b;
+ 
+        }
+ 
+        public int compareTo(Pair o) {
+            return this.x - o.x;
+        }
+    }
+ 
+ 
+    public static int mod = (int) (1e9 + 7);
+    static int ans = Integer.MAX_VALUE;
+ 
+    public static void main(String hi[]) throws Exception {
+        FastReader sc = new FastReader();
+        int t =sc.nextInt();
+        while(t-->0)
+        {
+            int n =sc.nextInt();
+            String a = sc.nextLine(),b=sc.nextLine();
+ 
+            int count1=0,count2=0,count3=0,count4=0;
+ 
+            for(int i=0;i<n;i++)
+            {
+                if(a.charAt(i)=='0'&&b.charAt(i)=='0')
+                    count1++;
+                else  if(a.charAt(i)=='1'&&b.charAt(i)=='1')
+                    count2++;
+                else  if(a.charAt(i)=='1'&&b.charAt(i)=='0')
+                    count3++;
+                else  if(a.charAt(i)=='0'&&b.charAt(i)=='1')
+                    count4++;
+            }
+            int ans=Integer.MAX_VALUE;
+ 
+            if(count3==count4)
+                ans=Math.min(count3*2,ans);
+ 
+            if(count2==count1+1)
+                ans=Math.min(ans,2*count1+1);
+ 
+           
+            if(ans==Integer.MAX_VALUE)
+                System.out.println(-1);
+            else System.out.println(ans);
+ 
+        }
+ 
+    }
+ 
+    static int find(int[] a,int x)
+    {
+        if(a[x]==-1)
+            return x;
+        else return find(a,a[x]);
+    }
+ 
+ 
+ 
+ 
+ 
+    static int gcd(int a, int b)
+    {
+        if (a == 0)
+            return b;
+        return gcd(b % a, a);
+    }
+ 
+    // method to return LCM of two numbers
+    static int lcm(int a, int b)
+    {
+        return (a / gcd(a, b)) * b;
+    }
+ 
+ 
+    static long gcdl(long a, long b)
+    {
+        if (a == 0)
+            return b;
+        return gcdl(b % a, a);
+    }
+ 
+    // method to return LCM of two numbers
+    static long lcml(long a, long b)
+    {
+        return (a / gcdl(a, b)) * b;
+    }
+ 
+ 
+    static class FastReader {
+        BufferedReader br;
+        StringTokenizer st;
+ 
+        public FastReader() {
+            br = new BufferedReader(new
+                    InputStreamReader(System.in));
+        }
+ 
+        String next() {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+ 
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+ 
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+ 
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+ 
+        String nextLine() {
+            String str = """";
+            try {
+                str = br.readLine();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+ 
+        }
+    }
+}
+ ",0
+1097b326,b45d28b2,"// package com.company;
+
+import java.util.Scanner;
+
+public class Main {
+
+    public static void solution1(){
+        Scanner scanner = new Scanner(System.in);
+        int t = scanner.nextInt();
+        while (t-- != 0){
+            int n, k1, k2, w, b;
+            n = scanner.nextInt();
+            k1 = scanner.nextInt();
+            k2 = scanner.nextInt();
+            w = scanner.nextInt();
+            b = scanner.nextInt();
+            if (k1 < k2){
+                int temp = k1;
+                k1 = k2;
+                k2 = temp;
+            }
+            int white_dominoes = k2 + (k1 - k2) / 2;
+            int black_dominoes = (n - k1) + (k1 - k2) / 2;
+            if (white_dominoes >= w && black_dominoes >= b)
+            {
+                System.out.println(""YES"");
+            }
+            else
+                System.out.println(""NO"");
+        }
+        scanner.close();
+    }
+
+    public static void solution2(){
+        Scanner scanner = new Scanner(System.in);
+        int t = scanner.nextInt();
+        scanner.nextLine();
+        while (t-- != 0) {
+            String s;
+            s = scanner.nextLine();
+            boolean flag = true;
+            int first_ones = -1, last_zeroes = -1;
+            for (int i=0; i<s.length() - 1; i++){
+                if (s.charAt(i) == '1' && s.charAt(i+1) == '1'){
+                    first_ones = i;
+                    break;
+                }
+            }
+            for (int i=s.length() - 1; i>0; i--){
+                if (s.charAt(i) == '0' && s.charAt(i-1) == '0'){
+                    last_zeroes = i-1;
+                    break;
+                }
+            }
+            if (first_ones != -1 && last_zeroes != -1 && first_ones < last_zeroes) flag = false;
+            if (flag) System.out.println(""YES"");
+            else System.out.println(""NO"");
+        }
+        scanner.close();
+    }
+
+    public static void solution3(){
+        Scanner scanner = new Scanner(System.in);
+        int t = scanner.nextInt();
+        while (t-- > 0){
+            int n;
+            n = scanner.nextInt();
+            int[] costs = new int[n];
+            for (int i=0; i<n; i++) costs[i] = scanner.nextInt();
+            //starts with Even index 0
+            long minEven = costs[0];
+            long minOdd = costs[1];
+            long totalEven = minEven;
+            long totalOdd = minOdd;
+            long minCost = minEven * n + minOdd * n;
+            for (int i=2; i<n; i++){
+                if (i%2 == 1){
+                    minOdd = Math.min(minOdd, costs[i]);
+                    totalOdd += costs[i];
+                }
+                else{
+                    minEven = Math.min(minEven, costs[i]);
+                    totalEven += costs[i];
+                }
+                long this_cost = totalEven - minEven + minEven * (n - (i+2)/2 + 1) + totalOdd - minOdd + minOdd * (n - (i+1)/2 + 1);
+                minCost = Math.min(minCost, this_cost);
+            }
+            System.out.println(minCost);
+        }
+        scanner.close();
+    }
+
+    public static long power(int a, int b){
+        long ans = 1;
+        while (b > 0){
+            if (b%2 == 1){
+                ans *= a;
+            }
+            a *= a;
+            b >>= 1;
+        }
+        return ans;
+    }
+
+    public static void main(String[] args) {
+        solution3();
+    }
+}","/*
+Codeforces
+Problem 1499C
+*/
+
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+
+public class MinimumGridPath {
+	
+	public static void main(String[] args) throws IOException {
+		FastIO in = new FastIO(System.in);
+		
+		int t = in.nextInt();
+		while (t-- > 0) {
+			int n = in.nextInt();
+			long[] c = new long[n];
+			long[] sums = new long[n];
+			long[] mins = new long[n];
+			
+			for (int i = 0; i < n; i++) c[i] = in.nextInt();
+			
+			sums[0] = mins[0] = c[0];
+			sums[1] = mins[1] = c[1];
+			for (int i = 2; i < n; i++) {
+				sums[i] = sums[i-2] + c[i];
+				mins[i] = Math.min(mins[i-2], c[i]);
+			}
+			
+			long ans = Long.MAX_VALUE;
+			for (int i = 1; i < n; i++) {
+				ans = Math.min(ans, (n - (long) Math.ceil((double) (i+1) / 2)) * mins[i] + (n - (i+1) / 2) * mins[i-1] + sums[i] + sums[i-1]);
+			}
+			
+			System.out.println(ans);
+		}
+		
+		in.close();
+	}
+	
+	public static class FastIO {
+		private InputStream dis;
+		private byte[] buffer = new byte[1 << 17];
+		private int pointer = 0;
+	
+		public FastIO(String fileName) throws IOException {
+			dis = new FileInputStream(fileName);
+		}
+	
+		public FastIO(InputStream is) throws IOException {
+			dis = is;
+		}
+	
+		public int nextInt() throws IOException {
+			int ret = 0;
+			byte b;
+			
+			do {
+				b = nextByte();
+			} while (b <= ' ');
+			
+			boolean negative = false;
+			if (b == '-') {
+				negative = true;
+				b = nextByte();
+			}
+			
+			while (b >= '0' && b <= '9') {
+				ret = 10 * ret + b - '0';
+				b = nextByte();
+			}
+	
+			return (negative) ? -ret : ret;
+		}
+	
+		public long nextLong() throws IOException {
+			long ret = 0;
+			byte b;
+			
+			do {
+				b = nextByte();
+			} while (b <= ' ');
+			
+			boolean negative = false;
+			if (b == '-') {
+				negative = true;
+				b = nextByte();
+			}
+			
+			while (b >= '0' && b <= '9') {
+				ret = 10 * ret + b - '0';
+				b = nextByte();
+			}
+			
+			return (negative) ? -ret : ret;
+		}
+	
+		public byte nextByte() throws IOException {
+			if (pointer == buffer.length) {
+				dis.read(buffer, 0, buffer.length);
+				pointer = 0;
+			}
+			return buffer[pointer++];
+		}
+	
+		public String next() throws IOException {
+			StringBuffer ret = new StringBuffer();
+			byte b;
+			
+			do {
+				b = nextByte();
+			} while (b <= ' ');
+			
+			while (b > ' ') {
+				ret.appendCodePoint(b);
+				b = nextByte();
+			}
+	
+			return ret.toString();
+		}
+	
+		public void close() throws IOException {
+			dis.close();
+		}
+	}
+}",0
+51151974,7d12d33c,"import java.io.*;
+import java.util.*;
+ public class Solution{
+    public static void main (String[] args) throws java.lang.Exception {
+        FastReader sc = new FastReader();
+        BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));
+        int testCase = sc.nextInt();
+        while (testCase-->0){
+            int n = sc.nextInt();
+            String[] strArr = new String[n];
+            for(int i=0; i<n; i++) {
+                strArr[i]=sc.nextLine();
+            }
+            int[] total = new int[5];
+            ArrayList<int[]> al = new ArrayList<>();
+            for(int i=0; i<n; i++){
+                int[] arr= new int[5];
+                for(int j=0; j<strArr[i].length(); j++){
+                    arr[strArr[i].charAt(j)-'a']++;
+                }
+                for(int j=0; j<5; j++){
+                    total[j]+=arr[j];
+                }
+                al.add(arr);
+            }
+            int ans=0;
+            for(int i=0; i<5; i++){
+                ArrayList<Integer> all = new ArrayList<>();
+                for(int j=0; j<n; j++){
+                    all.add(strArr[j].length()-2*al.get(j)[i]);
+                }
+                java.util.Collections.sort(all);
+                int c=0, d=0;
+                for(int j=0; j<n; j++){
+                    c+=all.get(j);
+                    if(c<0) d=j+1;
+                }
+                ans = Math.max(ans,d);
+            }
+            System.out.println(ans);
+        }
+    }
+    // Fast Reader Class
+    static class FastReader {
+        BufferedReader br; StringTokenizer st;
+        public FastReader() { br = new BufferedReader(new InputStreamReader(System.in)); }
+        String next() { while (st == null || !st.hasMoreElements()) { try { st = new StringTokenizer(br.readLine()); } catch (IOException e) { e.printStackTrace(); } }return st.nextToken(); }
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+        String nextLine() { String str = """"; try { str = br.readLine(); }  catch (IOException e) { e.printStackTrace(); }return str; }
+    }
+}","//import jdk.nashorn.internal.parser.Scanner;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.*;
+import java.util.*;
+
+import javax.management.Query;
+public class Test{
+    public static void main(String[] args) throws IOException, InterruptedException{
+      Scanner sc = new Scanner(System.in);
+     int t = sc.nextInt();
+    
+     while(t-->0){
+      int n = sc.nextInt();
+      String [] words = new String[n];
+     
+      for(int i =0;i<n;i++){
+        words[i] = sc.nextLine();
+       
+      }
+      int maxRes =0;
+      for(int i =0;i<5;i++){
+      int maxChar = 'a' +i;
+      
+      PriorityQueue<Pair> pq = new PriorityQueue<>();
+      for (String word : words){
+          pq.add(new Pair(word,occOfMaxChar(word, maxChar)-occOfOtherChar(word, maxChar)));
+      }
+      int res = 0;
+      int curr = 0;
+      int maxCharCount = 0;
+      int otherCharCount =0;
+      while(!pq.isEmpty()){
+        String word = pq.poll().x;
+        maxCharCount +=occOfMaxChar(word, maxChar);
+         otherCharCount += occOfOtherChar(word, maxChar);
+         curr ++;
+         if(maxCharCount >otherCharCount){
+           res = curr;
+         }
+          
+      }
+      maxRes = Math.max(maxRes, res);
+    }
+    System.out.println(maxRes);}
+   
+  }
+  public static int occOfMaxChar (String s, int maxChar){
+     int occ = 0;
+     for(int i =0 ;i<s.length();i++){
+       if(s.charAt(i)==maxChar){
+         occ++;
+       }
+      }
+      return occ;
+  }
+  public static int occOfOtherChar (String s, int maxChar){
+    int occ = 0;
+    for(int i =0 ;i<s.length();i++){
+      if(s.charAt(i)!=maxChar){
+        occ++;
+      }
+     }
+     return occ;
+ }
+
+    static int w;
+    static int n;
+    static long [][] memo;
+    static int [] depth ;
+    static long[] values;
+    static ArrayList<Pair> gold ;
+    public static long dp (int idx,int time){
+      if ( idx == n){
+       return 0;
+      }
+      if (memo[idx][time] != -1){
+        return  memo[idx][time];
+      }
+      long take = 0;
+      if (3 * w*depth[idx] <= time){
+        take = values[idx]+ dp(idx+1, time-3*w*depth[idx]);
+      }
+      long leave = dp(idx+1, time);
+      return memo[idx][time]=Math.max(take, leave);
+    }
+
+
+    static class Pair implements Comparable {
+      String x;
+      int y;
+      public Pair (String x, int y) {
+        this.x = x;
+        this.y = y;
+      }
+      @Override
+      public int compareTo(Object o){
+        Pair p = (Pair) o;
+        return p.y -y;
+      }
+    }
+    static class Scanner {
+      StringTokenizer st;
+      BufferedReader br;
+   
+      public Scanner(InputStream s) {
+        br = new BufferedReader(new InputStreamReader(s));
+      }
+   
+      public boolean hasNext() {
+        // TODO Auto-generated method stub
+        return false;
+      }
+   
+      public String next() throws IOException {
+        while (st == null || !st.hasMoreTokens())
+          st = new StringTokenizer(br.readLine());
+        return st.nextToken();
+      }
+   
+      public int nextInt() throws IOException {
+        return Integer.parseInt(next());
+      }
+   
+      public long nextLong() throws IOException {
+        return Long.parseLong(next());
+      }
+   
+      public String nextLine() throws IOException {
+        return br.readLine();
+      }
+   
+      public double nextDouble() throws IOException {
+        String x = next();
+        StringBuilder sb = new StringBuilder(""0"");
+        double res = 0, f = 1;
+        boolean dec = false, neg = false;
+        int start = 0;
+        if (x.charAt(0) == '-') {
+          neg = true;
+          start++;
+        }
+        for (int i = start; i < x.length(); i++)
+          if (x.charAt(i) == '.') {
+            res = Long.parseLong(sb.toString());
+            sb = new StringBuilder(""0"");
+            dec = true;
+          } else {
+            sb.append(x.charAt(i));
+            if (dec)
+              f *= 10;
+          }
+        res += Long.parseLong(sb.toString()) / f;
+        return res * (neg ? -1 : 1);
+      }
+   
+      public boolean ready() throws IOException {
+        return br.ready();
+      }
+   
+    }
+     }
+",0
+12309af3,390d2f23,"import java.util.*;
+import java.lang.*;
+import java.io.*;
+public class MyAnswer {
+     public static void main(String[] args)throws IOException{
+          FastScanner scan = new FastScanner();
+          //SuperFastScanner scan = new SuperFastScanner();
+          PrintWriter out = new PrintWriter(System.out);
+          StringBuilder result = new StringBuilder();
+     
+          int t = scan.nextInt();
+          while (t-- > 0){
+               int n = scan.nextInt();
+               int arr[] = scan.nextIntArray(n);
+               if(n%2==0){
+                    int j = n/2;
+                    for(int i = j;i<n;i++){
+                         int val = arr[i] * -1;
+                         result.append(val + "" "");
+                    }
+                    for(int i = 0;i<j;i++){
+                         int val = arr[i] ;
+                         result.append(val + "" "");
+                    }
+               }else{
+                    int j = (n-3)/2;
+                    for(int i = j;i<n-3;i++){
+                         int val = arr[i] * -1;
+                         result.append(val + "" "");
+                    }
+                    for(int i = 0;i<j;i++){
+                         int val = arr[i] ;
+                         result.append(val + "" "");
+                    }
+                    
+                    if(arr[n-3]+arr[n-2] !=0 ){
+                         int sum = arr[n-3] + arr[n-2];
+                         sum *=-1;
+                         result.append(arr[n-1] + "" "");
+                         result.append(arr[n-1] + "" "");
+                         result.append(sum+ "" "");
+                         
+                    }else if(arr[n-1]+arr[n-2] !=0 ){
+                         int sum = arr[n-1] + arr[n-2];
+                         sum *=-1;
+                         result.append(sum+ "" "");
+                         result.append(arr[n-3] + "" "");
+                         result.append(arr[n-3]+"" "");
+                         
+                    }else{
+                         int sum = arr[n-1] + arr[n-3];
+                         sum *=-1;
+                         result.append(arr[n-2] + "" "");
+                         result.append(sum+ "" "");
+                         result.append(arr[n-2]+ "" "");
+                    }
+                         
+               }
+               result.append(""\n"");
+               
+          }
+          out.println(result);
+          out.flush();
+     }
+     public static int solve(String str,char ch){
+          int ans = 0;
+          int l = str.length();
+          int i = 0,j = l-1;
+          while(i<=j){
+               char a = str.charAt(i);
+               char b = str.charAt(j);
+               if(a==b){
+                    i++;
+                    j--;
+               }else{
+                    if(a==ch){
+                         i++;
+                         ans++;
+                    }else if(b==ch){
+                         j--;
+                         ans++;
+                    }else{
+                         return 10000000;
+                    }
+               }
+          }
+          return ans;
+     }
+
+     static class FastScanner{ //10^5 -- .15 sec && 4*10^6 ---> .86 sec
+
+          BufferedReader br;
+          StringTokenizer st;
+          
+          public FastScanner(){
+               br = new BufferedReader(new InputStreamReader(System.in));
+          }
+          public String next(){
+               while (st == null || !st.hasMoreElements()){
+               try{
+                    st = new StringTokenizer(br.readLine());
+               }catch (IOException  e){
+                    e.printStackTrace();
+               }
+               }
+               return st.nextToken();
+          }
+          public int nextInt(){
+               return Integer.parseInt(next());
+          }
+          public long nextLong(){
+               return Long.parseLong(next());
+          }
+          public double nextDouble(){
+               return Double.parseDouble(next());
+          }
+          public String nextLine(){
+               String str = """";
+               try{
+                    str = br.readLine();
+               }catch (IOException e){
+                    e.printStackTrace();
+               }
+               return str;
+          }
+          public int[] nextIntArray(int n){
+               int arr[] = new int[n];
+               for(int i = 0;i<n;i++){
+                    arr[i] = nextInt();
+               }
+               return arr;
+          }
+          public long[] nextLongArray(int n){
+               long arr[] = new long[n];
+               for(int i = 0;i<n;i++){
+                    arr[i] = nextLong();
+               }
+               return arr;
+          }
+          public double[] nextDoubleArray(int n){
+               double arr[] = new double[n];
+               for(int i = 0;i<n;i++){
+                    arr[i] = nextDouble();
+               }
+               return arr;
+          }
+          public String[] nextStringArray(int n){
+               String arr[] = new String[n];
+               for(int i = 0;i<n;i++){
+                    arr[i] = next();
+               }
+               return arr;
+          }
+    }
+     
+
+}
+","//package oj;
+
+import java.io.*;
+
+public class Main {
+    static BufferedReader BR = new BufferedReader(new InputStreamReader(System.in));
+    static StreamTokenizer IN = new StreamTokenizer(BR);
+    static PrintWriter OUT = new PrintWriter(new BufferedOutputStream(System.out));
+    static int nextInt() throws IOException {
+        IN.nextToken();
+        return (int) IN.nval;
+    }
+    static double nextDouble() throws IOException {
+        IN.nextToken();
+        return IN.nval;
+    }
+    static String nextStr() throws IOException {
+        IN.nextToken();
+        return IN.sval;
+    }
+    static String nextLine() throws IOException {
+        return BR.readLine();
+    }
+
+    static final int MAXN = 1000000;
+
+    public static int gcd(int a, int b) {
+        return b == 0 ? a : gcd(b, a % b);
+    }
+    public static int lcm(int a, int b) {
+        return a / gcd(a, b) * b;
+    }
+    public static void main(String[] args) throws IOException {
+//        Scanner sc = new Scanner(System.in);
+        int T = nextInt();
+
+        while(T-- > 0) {
+            int N = nextInt();
+
+            int[] a = new int[N];
+
+            for (int i = 0; i < N; i++) {
+                a[i] = nextInt();
+            }
+            if (N % 2 == 0) {
+               for (int i = 0; i < N; i+=2) {
+                   OUT.print(a[i+1] + "" "");
+                   OUT.print(-1 * a[i] + "" "");
+               }
+            } else{
+                for (int i = 0; i < N-3; i+=2) {
+                    OUT.print(a[i+1] + "" "");
+                    OUT.print(-1 * a[i] + "" "");
+                }
+                if(a[N-3] + a[N-2] != 0) {
+                    OUT.print(-a[N-1] + "" "" + -a[N-1] + "" "" + (a[N-3] + a[N-2]));
+                } else if(a[N-2] + a[N-1] != 0) {
+                    OUT.print((a[N-2] + a[N-1]) + "" "" + -a[N-3] + "" "" + -a[N-3]);
+                } else {
+                    OUT.print(-a[N-2] + "" "" + (a[N-1] + a[N-3]) + "" "" + -a[N-2]);
+                }
+            }
+
+            OUT.println();
+        }
+
+        OUT.flush();
+    }
+}",0
+930dd1f1,f4b87cc2,"import java.util.*;
+import java.io.*;
+public class Armchairs 
+{
+	public static int val(int b[],int m,int c[],int n,int dp[][])
+	{
+		if(dp[m][n]>-1)
+		{
+			return dp[m][n];
+		}
+		else
+		if(m==0)
+		{
+			return 0;
+		}
+		else
+		if(n==0)
+		{
+							return 2099999999;
+		}
+		else
+		{
+		
+			return dp[m][n]=Math.min(val(b,m-1,c,n-1,dp)+Math.abs(b[m-1]-c[n-1]),val(b,m,c,n-1,dp));
+		}
+	}
+	public static void process()throws IOException
+	{
+		int n=I();
+		int a[]=Ai(n);
+		ArrayList<Integer> arr=new ArrayList<Integer>();
+		ArrayList<Integer> arr1=new ArrayList<Integer>();
+		for(int i=0;i<n;i++)
+		{
+			if(a[i]==0)
+			{
+				arr1.add(i);
+			}
+			else
+			{
+				arr.add(i);
+			}
+		}
+		int b[]=new int[arr.size()];
+		int c[]=new int[arr1.size()];
+		int m=arr.size();int n1=arr1.size();
+		int dp[][]=new int[m+1][n1+1];
+
+		dyn(dp,m+1,n1+1,-1);
+		
+		for(int i=0;i<arr.size();i++)
+		{
+			b[i]=arr.get(i);
+		}
+		for(int i=0;i<arr1.size();i++)
+		{
+			c[i]=arr1.get(i);
+		}
+
+		arr.clear();
+	    arr1.clear();
+	   pn(val(b,m,c,n1,dp));
+	}
+	static Scanner sc = new Scanner(System.in);
+	static PrintWriter out = new PrintWriter(System.out);
+	static void pn(Object o){out.println(o);out.flush();}
+	static void p(Object o){out.print(o);out.flush();}
+	static void pni(Object o){out.println(o);System.out.flush();}
+	static int I() throws IOException{return sc.nextInt();}
+	static long L() throws IOException{return sc.nextLong();}
+	static double D() throws IOException{return sc.nextDouble();}
+	static String S() throws IOException{return sc.next();}
+	static char C() throws IOException{return sc.next().charAt(0);}
+	static int[] Ai(int n) throws IOException{int[] arr = new int[n];for (int i = 0; i < n; i++)arr[i] = I();return arr;}
+	static String[] As(int n) throws IOException{String s[] = new String[n];for (int i = 0; i < n; i++)s[i] = S();return s;}
+	static long[] Al(int n) throws IOException {long[] arr = new long[n];for (int i = 0; i < n; i++)arr[i] = L();return arr;}
+	static void dyn(int dp[][],int n,int m,int z)throws IOException {for(int i=0;i<n;i++){ for(int j=0;j<m;j++){ dp[i][j]=z;}} }
+	
+//	*--------------------------------------------------------------------------------------------------------------------------------*//
+	static class AnotherReader {BufferedReader br;StringTokenizer st;AnotherReader() throws FileNotFoundException {br = new BufferedReader(new InputStreamReader(System.in));}
+	AnotherReader(int a) throws FileNotFoundException {br = new BufferedReader(new FileReader(""input.txt""));}
+	String next() throws IOException{while (st == null || !st.hasMoreElements()) {try {st = new StringTokenizer(br.readLine());} catch (IOException e) {e.printStackTrace();}}return st.nextToken();}
+	int nextInt() throws IOException {return Integer.parseInt(next());}
+	long nextLong() throws IOException {return Long.parseLong(next());}
+	double nextDouble() throws IOException {return Double.parseDouble(next());}
+	String nextLine() throws IOException {String str = """";try {str = br.readLine();} catch (IOException e) {e.printStackTrace();}return str;}}
+	public static void main(String[] args)throws IOException{try{boolean oj=true;if(oj==true)
+	{AnotherReader sk=new AnotherReader();PrintWriter out=new PrintWriter(System.out);}
+	else
+	{AnotherReader sk=new AnotherReader(100);out=new PrintWriter(""output.txt"");}
+	//long T=L();while(T-->0)
+	{process();}out.flush();out.close();}catch(Exception e){return;}}}
+//*-----------------------------------------------------------------------------------------------------------------------------------*//
+	
+","import java.io.PrintWriter;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Scanner;
+
+public class D {
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        PrintWriter pw = new PrintWriter(System.out);
+        int t = 1;
+        for (int i = 0; i < t; i++) {
+            solve(sc, pw);
+        }
+        pw.close();
+    }
+    static void solve(Scanner in, PrintWriter out){
+        int n = in.nextInt();
+        int[] arr = new int[n];
+        for (int i = 0; i < n; i++) {
+            arr[i] = in.nextInt();
+        }
+        int[] pre = new int[n + 1];
+        List<Integer> z = new ArrayList<>();
+        List<Integer> o = new ArrayList<>();
+        int cnt = 0;
+        for (int i = 0; i < n; i++) {
+            if (arr[i] == 0) {
+                cnt++;
+                z.add(i);
+            }else{
+                o.add(i);
+            }
+        }
+        int[][] dp = new int[cnt + 1][(n - cnt) + 1];
+        int one = n - cnt;
+        Arrays.fill(dp[0], 100000000);
+        dp[0][0] = 0;
+//        System.out.println(one);
+        int min = 100000000;
+        for (int i = 1; i <= cnt; i++) {// the position of zero,
+            Arrays.fill(dp[i], 100000000);
+            dp[i][0] = 0;
+            for (int j = 1; j <= Math.min(one, i); j++) {// the position of one
+                if (cnt - i < one - j){
+                    dp[i][j] = 100000000;
+                }else{
+                    dp[i][j] = Math.min(dp[i - 1][j - 1] + Math.abs(o.get(j - 1) - z.get(i - 1)), dp[i - 1][j]);
+                }
+                if (j == one){
+                    min = Math.min(min, dp[i][j]);
+                }
+            }
+        }
+        min = Math.min(min, dp[0][n - cnt]);
+        out.println(min);
+    }
+
+
+
+    static boolean isPrime(long n)
+    {
+        // Corner cases
+        if (n <= 1)
+            return false;
+        if (n <= 3)
+            return true;
+
+        // This is checked so that we can skip
+        // middle five numbers in below loop
+        if (n % 2 == 0 || n % 3 == 0)
+            return false;
+
+        for (int i = 5; i * i <= n; i = i + 6)
+            if (n % i == 0 || n % (i + 2) == 0)
+                return false;
+
+        return true;
+    }
+
+    static long gcd(long a, long b)
+    {
+        if (a == 0)
+            return b;
+        return gcd(b % a, a);
+    }
+
+    // method to return LCM of two numbers
+    static long lcm(long a, long b)
+    {
+        return (a / gcd(a, b)) * b;
+    }
+
+    public static int[] sieveEratosthenes(int n) {
+        if (n <= 32) {
+            int[] primes = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31};
+            for (int i = 0; i < primes.length; i++) {
+                if (n < primes[i]) {
+                    return Arrays.copyOf(primes, i);
+                }
+            }
+            return primes;
+        }
+
+        int u = n + 32;
+        double lu = Math.log(u);
+        int[] ret = new int[(int) (u / lu + u / lu / lu * 1.5)];
+        ret[0] = 2;
+        int pos = 1;
+
+        int[] isnp = new int[(n + 1) / 32 / 2 + 1];
+        int sup = (n + 1) / 32 / 2 + 1;
+
+        int[] tprimes = {3, 5, 7, 11, 13, 17, 19, 23, 29, 31};
+        for (int tp : tprimes) {
+            ret[pos++] = tp;
+            int[] ptn = new int[tp];
+            for (int i = (tp - 3) / 2; i < tp << 5; i += tp) ptn[i >> 5] |= 1 << (i & 31);
+            for (int j = 0; j < sup; j += tp) {
+                for (int i = 0; i < tp && i + j < sup; i++) {
+                    isnp[j + i] |= ptn[i];
+                }
+            }
+        }
+
+        // 3,5,7
+        // 2x+3=n
+        int[] magic = {0, 1, 23, 2, 29, 24, 19, 3, 30, 27, 25, 11, 20, 8, 4, 13, 31, 22, 28, 18, 26, 10, 7, 12, 21, 17, 9, 6, 16, 5, 15, 14};
+        int h = n / 2;
+        for (int i = 0; i < sup; i++) {
+            for (int j = ~isnp[i]; j != 0; j &= j - 1) {
+                int pp = i << 5 | magic[(j & -j) * 0x076be629 >>> 27];
+                int p = 2 * pp + 3;
+                if (p > n) break;
+                ret[pos++] = p;
+                if ((long) p * p > n) continue;
+                for (int q = (p * p - 3) / 2; q <= h; q += p) isnp[q >> 5] |= 1 << q;
+            }
+        }
+
+        return Arrays.copyOf(ret, pos);
+    }
+
+    //    reverse division for 2
+    public static long[] rdiv2(int n, int mod){
+        long[] arr = new long[n + 5];
+        arr[0] = 1;
+        long rev2 = (mod + 1) / 2;
+        for (int i = 1; i < n; i++) {
+            arr[i] = arr[i - 1] * rev2 % mod;
+        }
+        return arr;
+    }
+    static List<Integer> primeFactors(int n)
+    {
+        // Print the number of 2s that divide n
+        List<Integer> ls = new ArrayList<>();
+        if (n % 2 == 0) ls.add(2);
+        while (n%2==0)
+        {
+            n /= 2;
+        }
+
+        // n must be odd at this point.  So we can
+        // skip one element (Note i = i +2)
+        for (int i = 3; i <= Math.sqrt(n); i+= 2)
+        {
+            // While i divides n, print i and divide n
+            if (n  % i == 0) ls.add(i);
+            while (n%i == 0)
+            {
+                n /= i;
+            }
+        }
+        if (n > 1) ls.add(n);
+        return ls;
+    }
+
+    static int find(int i, int[] par){
+        if (par[i] < 0) return i;
+        return par[i] = find(par[i], par);
+    }
+    static boolean union(int i, int j, int[] par){
+        int pi = find(i, par);
+        int pj = find(j, par);
+        if (pi == pj) return false;
+        if (par[pi] < par[pj]){
+            par[pi] += par[pj];
+            par[pj] = pi;
+        }else{
+            par[pj] += par[pi];
+            par[pi] = pj;
+        }
+        return true;
+    }
+}
+",0
+4323e2bd,ebd8ff55,"import java.io.*;
+import java.util.*;
+import java.math.*;
+import java.math.BigInteger; 
+//import javafx.util.*; 
+public final class B
+{    
+	static StringBuilder ans=new StringBuilder();
+	static FastReader in=new FastReader();
+	static ArrayList<ArrayList<Integer>> g;
+	static long mod=(long)(1e9+7);
+	static int D1[],D2[],par[];
+	static boolean set[];
+	static int value[];
+	static long INF=Long.MAX_VALUE;
+	static int dp[][];
+	static int N,M;
+	static int A[][],B[][];
+	static int s=1;
+	public static void main(String args[])throws IOException
+	{  					
+		int N=i();
+		int A[]=input(N);
+		ArrayList<Integer> one=new ArrayList<Integer>();
+		ArrayList<Integer> zero=new ArrayList<Integer>();
+		for(int i=1; i<=N; i++)
+		{
+			if(A[i-1]==1)one.add(i);
+			else zero.add(i);
+		}
+		int sum[][]=new int[N+5][N+5];
+		for(int i=1; i<=one.size(); i++)
+		{
+			for(int j=1; j<=zero.size(); j++)
+			{
+				sum[i][j]=Math.abs(one.get(i-1)-zero.get(j-1));
+			}
+			//print(sum[i]);
+		}
+		dp=new int[N+5][N+5];
+		//for(int d[]:dp)Arrays.fill(d, Integer.MAX_VALUE);
+		Arrays.fill(dp[0], 0);
+		for(int i=1; i<=one.size(); i++)
+		{
+			for(int j=i; j<=zero.size(); j++)
+			{
+				if(i==j)
+				{
+					dp[i][j]=dp[i-1][j-1]+sum[i][j];
+				}
+				else
+				{
+					dp[i][j]=Math.min(dp[i][j-1], dp[i-1][j-1]+sum[i][j]);
+				}
+			}
+		}
+		System.out.println(dp[one.size()][zero.size()]);
+//		f(0,0,one,zero,0);
+		//for(int d[]:dp)print(d);
+		
+	}	
+	static int f(int i,int j,ArrayList<Integer> one,ArrayList<Integer> zero, int s)
+	{
+		if(i==one.size())return s;
+		if(j==zero.size())return Integer.MAX_VALUE;
+		int a=one.get(i),b=zero.get(j);
+        if(dp[a][b]==-1)
+        {
+        	int min=Integer.MAX_VALUE;
+        	for(int t=j; t<zero.size(); t++)
+    		{
+                 min=Math.min(min, f(i+1,t+1,one,zero,s+Math.abs(b-a))); 
+    		}  
+        	dp[a][b]=min;
+        }	
+        a=one.get(i);b=zero.get(j);
+		return dp[a][b];
+	}
+	static boolean isSorted(int A[])
+	{
+		int N=A.length;
+		for(int i=0; i<N-1; i++)
+		{
+			if(A[i]>A[i+1])return false;
+		}
+
+		return true;		
+	}
+	static int f1(int x,ArrayList<Integer> A)
+	{
+		int l=-1,r=A.size();
+		while(r-l>1)
+		{
+			int m=(l+r)/2;
+			int a=A.get(m);
+			if(a<x)l=m;
+			else r=m;
+		}		
+		return l;
+	}
+
+
+	static int ask(int t,int i,int j,int x)
+	{
+		System.out.println(""? ""+t+"" ""+i+"" ""+j+"" ""+x);
+		return i();
+	}
+
+	static int ask(int a)
+	{
+		System.out.println(""? 1 ""+a);
+		return i();
+	}
+	static int f(int st,int end,int d)
+	{
+		if(st>end)return 0;
+		int a=0,b=0,c=0;
+		if(d>1)a=f(st+d-1,end,d-1);
+		b=f(st+d,end,d);
+		c=f(st+d+1,end,d+1);
+		return value[st]+max(a,b,c);
+	}
+	static int max(int a,int b,int c)
+	{
+		return Math.max(a, Math.max(c, b));
+	}
+	static int value(char X[],char Y[])
+	{
+		int c=0;
+		for(int i=0; i<7; i++)
+		{
+			if(Y[i]=='1' && X[i]=='0')return -1;
+			if(X[i]=='1' && Y[i]=='0')c++;
+		}
+		return c;
+	}
+	static boolean isValid(int i,int j)
+	{
+		if(i<0 || i>=N)return false;
+		if(j<0 || j>=M)return false;
+		return true;
+	}
+
+	static long fact(long N)
+	{
+		long num=1L;
+		while(N>=1)
+		{
+			num=((num%mod)*(N%mod))%mod;
+			N--;
+		}
+		return num;
+	}
+	static boolean reverse(long A[],int l,int r)
+	{
+		while(l<r)
+		{
+			long t=A[l];
+			A[l]=A[r];
+			A[r]=t;
+			l++;
+			r--;
+		}
+		if(isSorted(A))return true;
+		else return false;
+	}
+	static boolean isSorted(long A[])
+	{
+		for(int i=1; i<A.length; i++)if(A[i]<A[i-1])return false;
+		return true;
+	}
+	static boolean isPalindrome(char X[],int l,int r)
+	{
+		while(l<r)
+		{
+			if(X[l]!=X[r])return false;
+			l++; r--;
+		}
+		return true;
+	}
+
+	static long min(long a,long b,long c)
+	{
+		return Math.min(a, Math.min(c, b));
+	}
+
+	static void print(int a)
+	{
+		System.out.println(""! ""+a);
+	}
+	static int ask(int a,int b)
+	{
+		System.out.println(""? ""+a+"" ""+b);
+		return i();
+	}
+	static int find(int a)
+	{
+		if(par[a]<0)return a;
+		return par[a]=find(par[a]);
+	}
+	static void union(int a,int b)
+	{
+		a=find(a);
+		b=find(b);
+		if(a!=b)
+		{
+			par[a]+=par[b]; //transfers the size
+			par[b]=a;       //changes the parent
+		}
+	}
+	static void swap(char A[],int a,int b)
+	{
+		char ch=A[a];
+		A[a]=A[b];
+		A[b]=ch;
+	}
+
+	static void sort(long[] a) //check for long
+	{
+		ArrayList<Long> l=new ArrayList<>();
+		for (long i:a) l.add(i);
+		Collections.sort(l);
+		for (int i=0; i<a.length; i++) a[i]=l.get(i);
+	}
+	static void setGraph(int N)
+	{
+		g=new ArrayList<ArrayList<Integer>>();
+		for(int i=0; i<=N; i++)
+		{
+			g.add(new ArrayList<Integer>());
+		}
+	}
+
+	static  long pow(long a,long b)
+	{
+		long mod=1000000007;
+		long pow=1;
+		long x=a;
+		while(b!=0)
+		{
+			if((b&1)!=0)pow=(pow*x)%mod;
+			x=(x*x)%mod;
+			b/=2;
+		}
+		return pow;
+	}
+	static long toggleBits(long x)//one's complement || Toggle bits
+	{
+		int n=(int)(Math.floor(Math.log(x)/Math.log(2)))+1;
+
+		return ((1<<n)-1)^x;
+	}
+	static int countBits(long a)
+	{
+		return (int)(Math.log(a)/Math.log(2)+1);
+	}
+	static void sort(int[] a) {
+		ArrayList<Integer> l=new ArrayList<>();
+		for (int i:a) l.add(i);
+		Collections.sort(l);
+		for (int i=0; i<a.length; i++) a[i]=l.get(i);
+	}
+	static boolean isPrime(long N)
+	{
+		if (N<=1)  return false; 
+		if (N<=3)  return true; 
+		if (N%2 == 0 || N%3 == 0) return false; 
+		for (int i=5; i*i<=N; i=i+6) 
+			if (N%i == 0 || N%(i+2) == 0) 
+				return false; 
+		return true; 
+	}
+	static long GCD(long a,long b) 
+	{
+		if(b==0)
+		{
+			return a;
+		}
+		else return GCD(b,a%b );
+	}
+
+	//Debugging Functions Starts
+
+	static void print(char A[])
+	{
+		for(char c:A)System.out.print(c+"" "");
+		System.out.println();
+	}
+	static void print(boolean A[])
+	{
+		for(boolean c:A)System.out.print(c+"" "");
+		System.out.println();
+	}
+	static void print(int A[])
+	{
+		for(int a:A)System.out.print(a+"" "");
+		System.out.println();	
+	}
+	static void print(long A[])
+	{
+		for(long i:A)System.out.print(i+ "" "");
+		System.out.println();
+
+	}
+	static void print(ArrayList<Integer> A)
+	{
+		for(int a:A)System.out.print(a+"" "");
+		System.out.println();
+	}
+
+	//Debugging Functions END
+	//----------------------
+	//IO FUNCTIONS STARTS
+	static HashMap<Integer,Integer> Hash(int A[])
+	{
+		HashMap<Integer,Integer> mp=new HashMap<>();
+		for(int a:A)
+		{
+			int f=mp.getOrDefault(a,0)+1;
+			mp.put(a, f);
+		}
+		return mp;
+	}
+	static int i()
+	{
+		return in.nextInt();
+	}
+
+	static long l()
+	{
+		return in.nextLong();
+	}
+
+	static int[] input(int N){
+		int A[]=new int[N];
+		for(int i=0; i<N; i++)
+		{
+			A[i]=in.nextInt();
+		}
+		return A;
+	}
+
+	static long[] inputLong(int N)     {
+		long A[]=new long[N];
+		for(int i=0; i<A.length; i++)A[i]=in.nextLong();
+		return A;
+	}
+
+	//IO FUNCTIONS END
+
+}
+
+class node implements Comparable<node>
+{
+	int l,r,index;
+	node(int l,int r,int index)
+	{
+		this.l=l;
+		this.r=r;
+		this.index=index;
+	}
+	public int compareTo(node X)
+	{
+		return X.r-this.r;
+	}
+}
+class node1 implements Comparable<node1>
+{
+	int l,r,index;
+	node1(int l,int r,int index)
+	{
+		this.l=l;
+		this.r=r;
+		this.index=index;
+	}
+	public int compareTo(node1 X)
+	{
+		if(this.l==X.l)
+			return X.r-this.r;
+		return this.l-X.l;
+	}
+}
+//Code For FastReader
+//Code For FastReader
+//Code For FastReader
+//Code For FastReader
+class FastReader
+{
+	BufferedReader br;
+	StringTokenizer st;
+	public FastReader()
+	{
+		br=new BufferedReader(new InputStreamReader(System.in));
+	}
+
+	String next()
+	{
+		while(st==null || !st.hasMoreElements())
+		{
+			try
+			{
+				st=new StringTokenizer(br.readLine());
+			}
+			catch(IOException e)
+			{
+				e.printStackTrace();
+			}
+		}
+		return st.nextToken();
+	}
+
+	int nextInt()
+	{
+		return Integer.parseInt(next());
+	}
+
+	long nextLong()
+	{
+		return Long.parseLong(next());
+	}
+	//gey
+	double nextDouble()
+	{
+		return Double.parseDouble(next());
+	}
+
+	String nextLine()
+	{
+		String str="""";
+		try
+		{
+			str=br.readLine();
+		}
+		catch (IOException e)
+		{
+			e.printStackTrace();
+		}
+		return str;
+	}
+
+}","import java.io.*;
+import java.util.*;
+
+public class Armchairs {
+    static final int INF = 1000000000;
+    public static void main(String[] args) {
+        InputReader reader = new InputReader(System.in);
+        PrintWriter writer = new PrintWriter(System.out, false);
+        int N = reader.nextInt();
+        int[] A = new int[N];
+        for (int i = 0; i < N; i++) {
+            A[i] = reader.nextInt();
+        }
+        List<Integer> occupied = new ArrayList<>();
+        for (int i = 0; i < N; i++) {
+            if (A[i] == 1) occupied.add(i);
+        }
+        int K = occupied.size();
+        int[][] dp = new int[N + 1][K + 1];
+        for (int[] row : dp) Arrays.fill(row, INF);
+        dp[0][0] = 0;
+        for (int i = 0; i < N; i++) {
+            for (int j = 0; j <= K; j++) {
+                int x = j < K ? occupied.get(j) : 0;
+                dp[i + 1][j] = Math.min(dp[i + 1][j], dp[i][j]);
+                if (j + 1 <= K && A[i] == 0) {
+                    dp[i + 1][j + 1] = Math.min(dp[i + 1][j + 1], dp[i][j] + Math.abs(i - x));
+                }
+            }
+        }
+        writer.println(dp[N][K]);
+        writer.close();
+        System.exit(0);
+    }
+    static class InputReader {
+        public BufferedReader reader;
+        public StringTokenizer tokenizer;
+        public InputReader(InputStream stream) {
+            reader = new BufferedReader(new InputStreamReader(stream), 32768);
+            tokenizer = null;
+        }
+        public String next() {
+            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
+                try {
+                    tokenizer = new StringTokenizer(reader.readLine());
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+            }
+            return tokenizer.nextToken();
+        }
+        public int nextInt() {
+            return Integer.parseInt(next());
+        }
+        public long nextLong() {
+            return Long.parseLong(next());
+        }
+        public double nextDouble() {
+            return Double.parseDouble(next());
+        }
+        public String nextLine() {
+            String str = """";
+            try {
+                str = reader.readLine();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+        }
+    }
+}",0
+63bfa731,9fc811f7,"
+import java.util.*;
+import java.io.*;
+
+public class D {
+    static ArrayList<Integer> adj[] = new ArrayList[(int)1e5+7];
+    static int diameter = 0;
+    static int[] depth = new int[(int)1e5 + 7];
+    public static void main(String[] args) {
+        FastReader in = new FastReader();
+        int t = in.nextInt();
+        while(t-- > 0){
+            int n = in.nextInt();
+            int a = in.nextInt(), b = in.nextInt(), da = in.nextInt(), db = in.nextInt();
+            for(int i = 1; i <= n; i++){
+                adj[i] = new ArrayList<>();
+            }
+            for(int i = 1; i <=n; i++){
+                adj[i].clear();
+            }
+            for(int i = 0; i < n- 1; i++){
+                int u = in.nextInt();
+                int v = in.nextInt();
+                adj[u].add(v);
+                adj[v].add(u);
+            }
+            diameter = 0;
+            depth[a] = 0;
+            dfs(a, -1);
+            System.out.println(2 * da >= Math.min(diameter, db) || depth[b] <= da ? ""Alice"" : ""Bob"");
+        }
+    }
+    static int dfs(int node, int parent){
+        int len = 0;
+        for(int x : adj[node]){
+            if(x != parent){
+                depth[x] = depth[node] + 1;
+                int cur = 1 + dfs(x, node);
+                diameter = Math.max(diameter, cur + len);
+                len = Math.max(len, cur);
+//                System.out.print(""x "" + x + "" node "" + node + "" par "" + parent);
+//                System.out.println("" cur "" + cur + "" len "" + len + "" diam "" + diameter);
+            }
+        }
+        return len;
+    }
+    static long getDigitSum(long n)
+    {
+        long sum = 0;
+
+        while (n > 0)
+        {
+            sum = sum + n % 10;
+            n = n/10;
+        }
+
+        return sum;
+    }
+
+    static class FastReader
+    {
+        BufferedReader br;
+        StringTokenizer st;
+
+        public FastReader()
+        {
+            br = new BufferedReader(new
+                    InputStreamReader(System.in));
+        }
+
+        String next()
+        {
+            while (st == null || !st.hasMoreElements())
+            {
+                try
+                {
+                    st = new StringTokenizer(br.readLine());
+                }
+                catch (IOException e)
+                {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt()
+        {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong()
+        {
+            return Long.parseLong(next());
+        }
+
+        double nextDouble()
+        {
+            return Double.parseDouble(next());
+        }
+
+        String nextLine()
+        {
+            String str = """";
+            try
+            {
+                str = br.readLine();
+            }
+            catch (IOException e)
+            {
+                e.printStackTrace();
+            }
+            return str;
+        }
+        int[] readArray(int n){
+            int[] a = new int[n];
+            for(int i = 0; i < n; i++){
+                a[i] = nextInt();
+            }
+            return a;
+        }
+    }
+}
+","import java.io.OutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.PrintWriter;
+import java.util.StringTokenizer;
+import java.io.IOException;
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+import java.io.InputStream;
+
+public class Main {
+    public static void main(String[] args) {
+        InputStream inputStream = System.in;
+        OutputStream outputStream = System.out;
+        InputReader in = new InputReader(inputStream);
+        PrintWriter out = new PrintWriter(outputStream);
+        DTreeTag solver = new DTreeTag();
+        int testCount = Integer.parseInt(in.next());
+        for (int i = 1; i <= testCount; i++)
+            solver.solve(i, in, out);
+        out.close();
+    }
+
+    static class DTreeTag {
+        int diam = 0;
+
+        public int dfs(ArrayList<Integer> g[], int x, int depth[], int p) {
+            int len = 0;
+            for (int y : g[x]) {
+                if (y != p) {
+                    depth[y] = depth[x] + 1;
+                    int cur = 1 + dfs(g, y, depth, x);
+                    diam = Math.max(diam, cur + len);
+                    len = Math.max(len, cur);
+                }
+            }
+            return len;
+        }
+
+        public void solve(int testNumber, InputReader in, PrintWriter out) {
+            int n = in.nextInt();
+            int a = in.nextInt() - 1;
+            int b = in.nextInt() - 1;
+            int da = in.nextInt();
+            int db = in.nextInt();
+            int dis[] = new int[n];
+            ArrayList<Integer> g[] = new ArrayList[n];
+            for (int i = 0; i < n; i++) g[i] = new ArrayList<>();
+            for (int i = 0; i < n - 1; i++) {
+                int u = in.nextInt() - 1;
+                int v = in.nextInt() - 1;
+                g[u].add(v);
+                g[v].add(u);
+            }
+            diam = 0;
+            dfs(g, a, dis, -1);
+            int disb = dis[b];
+            if (2 * da >= Math.min(diam, db) || disb <= da) {
+                out.println(""Alice"");
+            } else {
+                out.println(""Bob"");
+            }
+
+        }
+
+    }
+
+    static class InputReader {
+        public BufferedReader reader;
+        public StringTokenizer tokenizer;
+
+        public InputReader(InputStream stream) {
+            reader = new BufferedReader(new InputStreamReader(stream), 32768);
+            tokenizer = null;
+        }
+
+        public String next() {
+            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
+                try {
+                    tokenizer = new StringTokenizer(reader.readLine());
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+            }
+            return tokenizer.nextToken();
+        }
+
+        public int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+    }
+}
+
+",1
+c4ca2ff3,d6fb3b9e,"/* package codechef; // don't place package name! */
+
+import java.util.*;
+import java.lang.*;
+import java.io.*;
+
+/* Name of the class has to be ""Main"" only if the class is public. */
+public class Main
+{
+	public static void main (String[] args) throws java.lang.Exception
+	{
+		// your code goes here
+		Scanner sc=new Scanner(System.in);
+		int t=sc.nextInt();
+		PrintWriter out=new PrintWriter(System.out);
+		while(t-->0) {
+		    int n=sc.nextInt();
+		    int freq[][]=new int[n][5];
+		    int rem[][]=new int[n][5];
+		    for(int i=0;i<n;i++) {
+		        String str=sc.next();
+		        
+		        for(int j=0;j<str.length();j++) {
+		            freq[i][str.charAt(j)-'a']++;
+		        }
+		        for(int k=0;k<5;k++) {
+		            rem[i][k]=str.length()-freq[i][k];
+		        }
+		    }
+		    
+		    int ans=0;
+		    for(int i=0;i<5;i++) {
+		        int arr[]=new int[n];
+		        for(int j=0;j<n;j++)
+		        arr[j]=freq[j][i]-rem[j][i];
+		        
+		        Arrays.sort(arr);
+		        int total=0;
+		        int sum=0;
+		        for(int k=n-1;k>=0;k--) {
+		            if(sum+arr[k]>0) {
+		                sum=sum+arr[k];
+		                total++;
+		            }
+		            else {
+		                break;
+		            }
+		        }
+		        ans=Math.max(ans,total);
+		    }
+		    out.println(ans);
+		    
+		}
+		out.flush();
+		out.close();
+	}
+}
+
+","import java.util.*;
+public class Sol
+{
+    public static void main(String[] args)
+    {
+        Scanner sc = new Scanner(System.in);
+        int t = sc.nextInt();
+        while(t-->0)
+        {
+			int n = sc.nextInt();
+			int a[][]=new int[n][5];
+			int tot[]=new int[n];
+			for(int i=0;i<n;i++)
+			{
+				String x = sc.next();
+				for(int j=0;j<x.length();j++)
+					a[i][x.charAt(j)-'a'] += 1;
+				tot[i]=x.length();
+			}
+			
+			int max=Integer.MIN_VALUE;
+			for(int i=0;i<5;i++)
+				max=Math.max(max,function(a,n,i,tot));
+			System.out.println(max);
+			
+		}	
+    }
+	static int function(int a[][],int n,int i,int tot[])
+	{
+		Integer ans[] = new Integer[n];
+		for(int j=0;j<n;j++)
+			ans[j]=a[j][i]-(tot[j]-a[j][i]);
+		int res=0,j=0;
+		Arrays.sort(ans,Collections.reverseOrder());
+		while(j<n&&res+ans[j]>0)
+			res+=ans[j++];
+		return j;
+	}
+}
+",0
+3d06b643,f6ca6fc8,"import java.io.*;
+import java.util.*;
+
+public class ArmChairs {
+    
+
+    public static int solution(int n, int[] arr) {
+
+        ArrayList<Integer> one = new ArrayList<Integer>();
+        ArrayList<Integer> zero = new ArrayList<Integer>();
+
+        for (int i = 0; i < n; i++) {
+            if (arr[i] == 1) {
+                one.add(i);
+            } else {
+                zero.add(i);
+            }
+        }
+
+        int[][] dp = new int[one.size() + 1][zero.size() + 1];
+
+        for (int i = 1; i <= one.size(); i++) {
+            dp[i][i] = dp[i - 1][i - 1] + Math.abs(one.get(i - 1) - zero.get(i - 1));
+            for (int j = i + 1; j <= zero.size(); j++) {
+                dp[i][j] = Math.min(dp[i][j - 1], dp[i - 1][j - 1] + Math.abs(one.get(i - 1) - zero.get(j - 1)));
+            }
+        }
+
+        return dp[one.size()][zero.size()];
+    }
+
+
+    public static void main(String[] args) throws IOException{
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        BufferedWriter log = new BufferedWriter(new OutputStreamWriter(System.out));
+
+        int n = Integer.parseInt(br.readLine());
+
+        String[] s = br.readLine().split("" "");
+        int[] arr = new int[n];
+        for (int i = 0; i < n; i++) {
+            arr[i] = Integer.parseInt(s[i]);
+        } 
+
+        log.write(Integer.toString(solution(n, arr)) + ""\n"");
+        log.flush();
+        
+    }
+
+}
+","import java.util.*;
+import java.io.*;
+
+public class D {
+	public static void main(String[] args) {
+		Scanner sc=new Scanner(System.in);
+		int n = sc.nextInt();
+		ArrayList<Integer>  o=new ArrayList<Integer>();
+		ArrayList<Integer>  e=new ArrayList<Integer>();
+		for(int i=1;i<=n;i++){
+			int x=sc.nextInt();
+			if(x==1)o.add(i);
+			else e.add(i);
+		}
+		int dp[][]=new int[o.size()+1][e.size()+1];
+		for(int i=1;i<=o.size();i++){
+			dp[i][i]=dp[i-1][i-1]+Math.abs(o.get(i-1)-e.get(i-1));
+			for(int j=i+1;j<=e.size();j++){
+				dp[i][j]=Math.min(dp[i][j-1],dp[i-1][j-1]+Math.abs(o.get(i-1)-e.get(j-1)));
+			}
+		}
+		System.out.println(dp[o.size()][e.size()]);
+	}
+}
+",1
+8b490132,db09b3f9,"import java.io.DataInputStream;
+import java.io.IOException;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.util.TreeSet;
+ 
+public class Main {
+ 
+    private static void run() throws IOException {
+        int n = in.nextInt();
+        long[] b = new long[n];
+        for (int i = 0; i < n; i++) {
+            b[i] = in.nextInt();
+        }
+ 
+        TreeSet<Long> set = new TreeSet<>();
+        set.add(b[0]);
+        long last = b[0];
+        long left = Long.MIN_VALUE;
+        long right = Long.MAX_VALUE;
+        boolean flag = true;
+        for (int i = 1; i < n; i++) {
+            if (b[i] > last) {
+                set.add(right--);
+                long pre_next = set.higher(last);
+                if (pre_next < b[i]) {
+                    flag = false;
+                    break;
+                } else if (pre_next == b[i]) {
+                    set.add(right--);
+                } else {
+                    set.add(b[i]);
+                }
+            } else if (b[i] < last) {
+                set.add(left++);
+                long pre_next = set.lower(last);
+                if (pre_next > b[i]) {
+                    flag = false;
+                    break;
+                } else if (pre_next == b[i]) {
+                    set.add(left++);
+                } else {
+                    set.add(b[i]);
+                }
+            } else {
+                set.add(left++);
+                set.add(right--);
+            }
+            last = b[i];
+        }
+ 
+        if (flag) {
+            out.println(""YES"");
+        } else {
+            out.println(""NO"");
+        }
+    }
+ 
+    public static void main(String[] args) throws IOException {
+        in = new Reader();
+        out = new PrintWriter(new OutputStreamWriter(System.out));
+ 
+        int t = in.nextInt();
+        for (int i = 0; i < t; i++) {
+            run();
+        }
+ 
+        out.flush();
+        in.close();
+        out.close();
+    }
+ 
+    private static int gcd(int a, int b) {
+        if (a == 0 || b == 0)
+            return 0;
+        while (b != 0) {
+            int tmp;
+            tmp = a % b;
+            a = b;
+            b = tmp;
+        }
+        return a;
+    }
+ 
+    static final long mod = 1000000007;
+ 
+    static long pow_mod(long a, long b) {
+        long result = 1;
+        while (b != 0) {
+            if ((b & 1) != 0) result = (result * a) % mod;
+            a = (a * a) % mod;
+            b >>= 1;
+        }
+        return result;
+    }
+ 
+    private static long multiplied_mod(long... longs) {
+        long ans = 1;
+        for (long now : longs) {
+            ans = (ans * now) % mod;
+        }
+        return ans;
+    }
+ 
+    @SuppressWarnings(""FieldCanBeLocal"")
+    private static Reader in;
+    private static PrintWriter out;
+ 
+    private static int[] read_int_array(int len) throws IOException {
+        int[] a = new int[len];
+        for (int i = 0; i < len; i++) {
+            a[i] = in.nextInt();
+        }
+        return a;
+    }
+ 
+    private static long[] read_long_array(int len) throws IOException {
+        long[] a = new long[len];
+        for (int i = 0; i < len; i++) {
+            a[i] = in.nextLong();
+        }
+        return a;
+    }
+ 
+    private static void print_array(int[] array) {
+        for (int now : array) {
+            out.print(now);
+            out.print(' ');
+        }
+        out.println();
+    }
+ 
+    private static void print_array(long[] array) {
+        for (long now : array) {
+            out.print(now);
+            out.print(' ');
+        }
+        out.println();
+    }
+ 
+    static class Reader {
+        private static final int BUFFER_SIZE = 1 << 16;
+        private final DataInputStream din;
+        private final byte[] buffer;
+        private int bufferPointer, bytesRead;
+ 
+        Reader() {
+            din = new DataInputStream(System.in);
+            buffer = new byte[BUFFER_SIZE];
+            bufferPointer = bytesRead = 0;
+        }
+ 
+        public String readLine() throws IOException {
+            final byte[] buf = new byte[1024]; // line length
+            int cnt = 0, c;
+            while ((c = read()) != -1) {
+                if (c == '\n') {
+                    break;
+                }
+                buf[cnt++] = (byte) c;
+            }
+            return new String(buf, 0, cnt);
+        }
+ 
+        public int nextSign() throws IOException {
+            byte c = read();
+            while ('+' != c && '-' != c) {
+                c = read();
+            }
+            return '+' == c ? 0 : 1;
+        }
+ 
+        private static boolean isSpaceChar(int c) {
+            return !(c >= 33 && c <= 126);
+        }
+ 
+        public int skip() throws IOException {
+            int b;
+            // noinspection ALL
+            while ((b = read()) != -1 && isSpaceChar(b)) {
+                ;
+            }
+            return b;
+        }
+ 
+        public char nc() throws IOException {
+            return (char) skip();
+        }
+ 
+        public String next() throws IOException {
+            int b = skip();
+            final StringBuilder sb = new StringBuilder();
+            while (!isSpaceChar(b)) { // when nextLine, (isSpaceChar(b) && b != ' ')
+                sb.appendCodePoint(b);
+                b = read();
+            }
+            return sb.toString();
+        }
+ 
+        public int nextInt() throws IOException {
+            int ret = 0;
+            byte c = read();
+            while (c <= ' ') {
+                c = read();
+            }
+            final boolean neg = c == '-';
+            if (neg) {
+                c = read();
+            }
+            do {
+                ret = ret * 10 + c - '0';
+            } while ((c = read()) >= '0' && c <= '9');
+ 
+            if (neg) {
+                return -ret;
+            }
+            return ret;
+        }
+ 
+        public long nextLong() throws IOException {
+            long ret = 0;
+            byte c = read();
+            while (c <= ' ') {
+                c = read();
+            }
+            final boolean neg = c == '-';
+            if (neg) {
+                c = read();
+            }
+            do {
+                ret = ret * 10 + c - '0';
+            }
+            while ((c = read()) >= '0' && c <= '9');
+            if (neg) {
+                return -ret;
+            }
+            return ret;
+        }
+ 
+        public double nextDouble() throws IOException {
+            double ret = 0, div = 1;
+            byte c = read();
+            while (c <= ' ') {
+                c = read();
+            }
+            final boolean neg = c == '-';
+            if (neg) {
+                c = read();
+            }
+ 
+            do {
+                ret = ret * 10 + c - '0';
+            }
+            while ((c = read()) >= '0' && c <= '9');
+ 
+            if (c == '.') {
+                while ((c = read()) >= '0' && c <= '9') {
+                    ret += (c - '0') / (div *= 10);
+                }
+            }
+ 
+            if (neg) {
+                return -ret;
+            }
+            return ret;
+        }
+ 
+        private void fillBuffer() throws IOException {
+            bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
+            if (bytesRead == -1) {
+                buffer[0] = -1;
+            }
+        }
+ 
+        private byte read() throws IOException {
+            if (bufferPointer == bytesRead) {
+                fillBuffer();
+            }
+            return buffer[bufferPointer++];
+        }
+ 
+        public void close() throws IOException {
+            din.close();
+        }
+ 
+    }
+}","import java.io.DataInputStream;
+import java.io.IOException;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.util.TreeSet;
+
+public class Main {
+
+    private static void run() throws IOException {
+        int n = in.nextInt();
+        long[] b = new long[n];
+        for (int i = 0; i < n; i++) {
+            b[i] = in.nextInt();
+        }
+
+        TreeSet<Long> set = new TreeSet<>();
+        set.add(b[0]);
+        long last = b[0];
+        long left = Long.MIN_VALUE;
+        long right = Long.MAX_VALUE;
+        boolean flag = true;
+        for (int i = 1; i < n; i++) {
+            if (b[i] > last) {
+                set.add(right--);
+                long pre_next = set.higher(last);
+                if (pre_next < b[i]) {
+                    flag = false;
+                    break;
+                } else if (pre_next == b[i]) {
+                    set.add(right--);
+                } else {
+                    set.add(b[i]);
+                }
+            } else if (b[i] < last) {
+                set.add(left++);
+                long pre_next = set.lower(last);
+                if (pre_next > b[i]) {
+                    flag = false;
+                    break;
+                } else if (pre_next == b[i]) {
+                    set.add(left++);
+                } else {
+                    set.add(b[i]);
+                }
+            } else {
+                set.add(left++);
+                set.add(right--);
+            }
+            last = b[i];
+        }
+
+        if (flag) {
+            out.println(""YES"");
+        } else {
+            out.println(""NO"");
+        }
+    }
+
+    public static void main(String[] args) throws IOException {
+        in = new Reader();
+        out = new PrintWriter(new OutputStreamWriter(System.out));
+
+        int t = in.nextInt();
+        for (int i = 0; i < t; i++) {
+            run();
+        }
+
+        out.flush();
+        in.close();
+        out.close();
+    }
+
+    private static int gcd(int a, int b) {
+        if (a == 0 || b == 0)
+            return 0;
+        while (b != 0) {
+            int tmp;
+            tmp = a % b;
+            a = b;
+            b = tmp;
+        }
+        return a;
+    }
+
+    static final long mod = 1000000007;
+
+    static long pow_mod(long a, long b) {
+        long result = 1;
+        while (b != 0) {
+            if ((b & 1) != 0) result = (result * a) % mod;
+            a = (a * a) % mod;
+            b >>= 1;
+        }
+        return result;
+    }
+
+    private static long multiplied_mod(long... longs) {
+        long ans = 1;
+        for (long now : longs) {
+            ans = (ans * now) % mod;
+        }
+        return ans;
+    }
+
+    @SuppressWarnings(""FieldCanBeLocal"")
+    private static Reader in;
+    private static PrintWriter out;
+
+    private static int[] read_int_array(int len) throws IOException {
+        int[] a = new int[len];
+        for (int i = 0; i < len; i++) {
+            a[i] = in.nextInt();
+        }
+        return a;
+    }
+
+    private static long[] read_long_array(int len) throws IOException {
+        long[] a = new long[len];
+        for (int i = 0; i < len; i++) {
+            a[i] = in.nextLong();
+        }
+        return a;
+    }
+
+    private static void print_array(int[] array) {
+        for (int now : array) {
+            out.print(now);
+            out.print(' ');
+        }
+        out.println();
+    }
+
+    private static void print_array(long[] array) {
+        for (long now : array) {
+            out.print(now);
+            out.print(' ');
+        }
+        out.println();
+    }
+
+    static class Reader {
+        private static final int BUFFER_SIZE = 1 << 16;
+        private final DataInputStream din;
+        private final byte[] buffer;
+        private int bufferPointer, bytesRead;
+
+        Reader() {
+            din = new DataInputStream(System.in);
+            buffer = new byte[BUFFER_SIZE];
+            bufferPointer = bytesRead = 0;
+        }
+
+        public String readLine() throws IOException {
+            final byte[] buf = new byte[1024]; // line length
+            int cnt = 0, c;
+            while ((c = read()) != -1) {
+                if (c == '\n') {
+                    break;
+                }
+                buf[cnt++] = (byte) c;
+            }
+            return new String(buf, 0, cnt);
+        }
+
+        public int nextSign() throws IOException {
+            byte c = read();
+            while ('+' != c && '-' != c) {
+                c = read();
+            }
+            return '+' == c ? 0 : 1;
+        }
+
+        private static boolean isSpaceChar(int c) {
+            return !(c >= 33 && c <= 126);
+        }
+
+        public int skip() throws IOException {
+            int b;
+            // noinspection ALL
+            while ((b = read()) != -1 && isSpaceChar(b)) {
+                ;
+            }
+            return b;
+        }
+
+        public char nc() throws IOException {
+            return (char) skip();
+        }
+
+        public String next() throws IOException {
+            int b = skip();
+            final StringBuilder sb = new StringBuilder();
+            while (!isSpaceChar(b)) { // when nextLine, (isSpaceChar(b) && b != ' ')
+                sb.appendCodePoint(b);
+                b = read();
+            }
+            return sb.toString();
+        }
+
+        public int nextInt() throws IOException {
+            int ret = 0;
+            byte c = read();
+            while (c <= ' ') {
+                c = read();
+            }
+            final boolean neg = c == '-';
+            if (neg) {
+                c = read();
+            }
+            do {
+                ret = ret * 10 + c - '0';
+            } while ((c = read()) >= '0' && c <= '9');
+
+            if (neg) {
+                return -ret;
+            }
+            return ret;
+        }
+
+        public long nextLong() throws IOException {
+            long ret = 0;
+            byte c = read();
+            while (c <= ' ') {
+                c = read();
+            }
+            final boolean neg = c == '-';
+            if (neg) {
+                c = read();
+            }
+            do {
+                ret = ret * 10 + c - '0';
+            }
+            while ((c = read()) >= '0' && c <= '9');
+            if (neg) {
+                return -ret;
+            }
+            return ret;
+        }
+
+        public double nextDouble() throws IOException {
+            double ret = 0, div = 1;
+            byte c = read();
+            while (c <= ' ') {
+                c = read();
+            }
+            final boolean neg = c == '-';
+            if (neg) {
+                c = read();
+            }
+
+            do {
+                ret = ret * 10 + c - '0';
+            }
+            while ((c = read()) >= '0' && c <= '9');
+
+            if (c == '.') {
+                while ((c = read()) >= '0' && c <= '9') {
+                    ret += (c - '0') / (div *= 10);
+                }
+            }
+
+            if (neg) {
+                return -ret;
+            }
+            return ret;
+        }
+
+        private void fillBuffer() throws IOException {
+            bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
+            if (bytesRead == -1) {
+                buffer[0] = -1;
+            }
+        }
+
+        private byte read() throws IOException {
+            if (bufferPointer == bytesRead) {
+                fillBuffer();
+            }
+            return buffer[bufferPointer++];
+        }
+
+        public void close() throws IOException {
+            din.close();
+        }
+
+    }
+}",1
+26e699de,90dc2b20,"//package Task1;
+
+import java.util.Scanner;
+
+public class Menorah {
+    static int MOD9= 1000000000;
+
+    public static void main(String[] args){
+
+        Scanner sc= new Scanner(System.in);
+        int numberTest=sc.nextInt();
+        while(numberTest-->0){
+            int n=sc.nextInt();
+            char[] s=new char[n+5];
+            char[] t=new char[n+5];
+            String ss=sc.next();
+            String tt=sc.next();
+            s=ss.toCharArray();
+            t=tt.toCharArray();
+            int cntax = 0, cntbx = 0, same = 0;
+            int ans=MOD9;
+            for(int i=0; i<n; i++){
+                if(s[i]=='1')cntax++;
+                if(t[i]=='1')cntbx++;
+                if(s[i]==t[i])same++;
+            }
+            if(same==n){
+                System.out.println(0);
+                continue;
+            }
+            else if (cntax==0){
+                System.out.println(-1);
+                continue;
+            }
+            if(cntax==cntbx){
+                ans=Math.min(ans,n-same);
+            }
+            if(n-cntax+1==cntbx)ans=Math.min(ans,same);
+            if(ans<MOD9) System.out.println(ans);
+            else System.out.println(-1);
+
+
+
+        }
+
+    }
+}
+","import java.util.*;
+import java.io.*;
+public class C1615{
+	static FastScanner fs = null;
+	public static void main(String[] args) {
+		fs = new FastScanner();
+		PrintWriter out = new PrintWriter(System.out);
+		int t = fs.nextInt();
+		while (t-->0) {
+			int n = fs.nextInt();
+			String a = fs.next();
+			String b = fs.next();
+			char ch1[] = a.toCharArray();
+			char ch2[] = b.toCharArray();
+			int c00 = 0;
+			int c01 = 0;
+			int c10 = 0;
+			int c11 = 0;
+			for(int i=0;i<n;i++){
+				if(ch1[i]=='0'){
+					if(ch2[i]=='0'){
+						c00+=1;
+					}
+					else{
+						c01+=1;
+					}
+				}
+				else{
+					if(ch2[i]=='0'){
+						c10+=1;
+					}
+					else{
+						c11+=1;
+					}
+				}
+			}
+			int ans = -1;
+			if((c11-c00)==1 || c10==c01){
+				int s1 = (int)1e7; 
+				int s2 = (int)1e7;
+				if((c11-c00)==1){
+					s1 = c11+c00;
+				}
+				if(c10==c01)
+				s2 = c10+c01;
+				ans = Math.min(s1,s2); 
+			}
+			out.println(ans);
+		}
+		out.close();
+	}
+	static void sort(int[] a) {
+		ArrayList<Integer> l=new ArrayList<>();
+		for (int i:a) l.add(i);
+		Collections.sort(l);
+		for (int i=0; i<a.length; i++) a[i]=l.get(i);
+	}
+	static class FastScanner {
+		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st=new StringTokenizer("""");
+		String next() {
+			while (!st.hasMoreTokens())
+				try {
+					st=new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			return st.nextToken();
+		}
+		
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+		int[] readArray(int n) {
+			int[] a=new int[n];
+			for (int i=0; i<n; i++) a[i]=nextInt();
+			return a;
+		}
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+	}
+}",0
+595f5d6c,ae775964,"import java.math.BigInteger;
+//import static java.lang.Math.max;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.PriorityQueue;
+import java.util.Queue;
+import java.util.Random;
+import java.util.Stack;
+import java.util.StringTokenizer;
+import java.util.TreeMap;
+import java.util.Vector;
+
+import java.util.Scanner;
+
+public class ahh {
+//trihund
+	static Scanner scn = new Scanner(System.in);
+	static boolean vis[][];
+
+	static class FastReader {
+		BufferedReader br;
+		StringTokenizer st;
+
+		public FastReader() {
+			br = new BufferedReader(new InputStreamReader(System.in));
+		}
+
+		String next() {
+			while (st == null || !st.hasMoreElements()) {
+				try {
+					st = new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			}
+			return st.nextToken();
+		}
+
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+	
+
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+
+		double nextDouble() {
+			return Double.parseDouble(next());
+		}
+
+		String nextLine() {
+			String str = """";
+			try {
+				str = br.readLine();
+			} catch (IOException e) {
+				e.printStackTrace();
+			}
+			return str;
+		}
+	}
+
+	static FastReader s = new FastReader();
+	static int MOD = 1000000007;
+
+	public static void main(String[] args) {
+		
+		int n=scn.nextInt(),count=0;
+		int arr[]=new int[n];
+		for(int i=0;i<n;i++)
+		{
+			arr[i]=scn.nextInt();
+		}
+		ArrayList<Integer>zer=new ArrayList<Integer>(),one=new ArrayList<Integer>();
+		for(int i=0;i<n;i++)
+		{
+			if(arr[i]==0)
+				zer.add(i);
+			else
+				one.add(i);
+		}
+		count=one.size();
+		long memo[][]=new long[one.size()+1][zer.size()+1];
+		for(int i=0;i<=one.size();i++)
+		{
+			for(int j=0;j<=zer.size();j++)
+				memo[i][j]=-1;
+		}
+		System.out.println(arm(one, zer, 0, 0, count,memo));
+				
+		
+	}
+
+	public static long arm(ArrayList<Integer>one,ArrayList<Integer>zer,int i,int j,int count,long memo[][])
+	{	if(count==0)
+		return 0;
+		if(i==one.size()||j==zer.size())
+			return Integer.MAX_VALUE;
+		
+		if(memo[i][j]!=-1)
+			return memo[i][j];
+		
+		long a=Integer.MAX_VALUE,b=Integer.MAX_VALUE;
+		a=arm(one, zer, i+1, j+1,count-1,memo)+Math.abs(one.get(i)-zer.get(j));
+		b=arm(one, zer, i, j+1,count,memo);
+		memo[i][j]=Math.min(a, b);
+		return Math.min(a, b);
+	}
+	public static void fac(int n) {
+		BigInteger b = new BigInteger(""1"");
+		for (int i = 1; i <= n; i++) {
+			b = b.multiply(BigInteger.valueOf(i));
+		}
+		System.out.println(b);
+
+	}
+
+	static void ruffleSort(long[] a) {
+		int n = a.length;
+		Random r = new Random();
+		for (int i = 0; i < a.length; i++) {
+			int oi = r.nextInt(n);
+			long temp = a[i];
+			a[i] = a[oi];
+			a[oi] = temp;
+		}
+		Arrays.sort(a);
+	}
+
+	public static int gcd(int a, int b) {
+		if (a == 0)
+			return b;
+		return gcd(b % a, a);
+	}
+
+}
+
+class pm {
+	int ini, fin;
+
+	pm(int a, int b) {
+		this.ini = a;
+		this.fin = b;
+	}
+
+}
+
+class surt implements Comparator<pm> {
+
+	@Override
+	public int compare(pm o1, pm o2) {
+		// TODO Auto-generated method stub
+		int a = o1.ini - o2.ini, b = o1.fin - o2.fin;
+		if (a < 0)
+			return -1;
+		if (a == 0) {
+			if (b < 0)
+				return -1;
+			else
+				return 1;
+		} else
+			return 1;
+	}
+
+}
+
+class pair {
+	int x, y;
+
+	pair(int a, int b) {
+		this.x = a;
+		this.y = b;
+	}
+
+	public int hashCode() {
+		return x * 31 + y * 31;
+	}
+
+	public boolean equals(Object other) {
+		if (this == other)
+			return true;
+
+		if (other instanceof pair) {
+			pair pt = (pair) other;
+
+			return pt.x == this.x && pt.y == this.y;
+		} else
+			return false;
+	}
+
+}
+
+class sort implements Comparator<pair> {
+
+	@Override
+	public int compare(pair o1, pair o2) {
+		// TODO Auto-generated method stub
+		long a = o1.x - o2.x, b = o1.y - o2.y;
+		if (b < 0)
+			return -1;
+		else if (a == 0) {
+			if (a < 0)
+				return -1;
+			else
+				return 1;
+		} else
+			return 1;
+
+	}
+
+}","
+import java.awt.Point;
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.io.ObjectInputStream.GetField;
+import java.lang.reflect.Array;
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Hashtable;
+import java.util.LinkedList;
+import java.util.PriorityQueue;
+import java.util.Queue;
+import java.util.Set;
+import java.util.Stack;
+import java.util.StringTokenizer;
+import java.util.TreeMap;
+import java.util.TreeSet;
+
+import javax.sound.sampled.ReverbType;
+
+
+public class Edu109 {
+	static PrintWriter out;
+	static Scanner sc;
+	static ArrayList<int[]>q,w,x;
+	static ArrayList<Integer>adj[];
+	static HashSet<Integer>primesH;
+	static boolean prime[];
+	//static ArrayList<Integer>a;
+	static HashSet<Long>tmp;
+	static int[][][]dist;
+	static boolean[]v;
+	static int[]a,b,c,d;
+	static Boolean[][]dp;
+	static char[][]mp;
+	static int A,B,n,m,h,ans,sum;
+	//static String a,b;
+	static long oo=(long)1e9+7;
+	public static void main(String[]args) throws IOException {
+		sc=new Scanner(System.in);
+		out=new PrintWriter(System.out);
+		//A();
+		//B();
+		//C();
+		D();
+		//E();
+		//F();
+		//G();
+		out.close();
+	}
+	  private static void A() throws IOException {
+		  int t=ni();
+		  while(t-->0) {
+				int k=ni();
+				int ans=0;
+				for(int i=1;i<=100;i++) {
+					if((i*100)%k==0) {
+						ans=i*100/k;break;
+					}
+				}
+				ol(ans);
+		  }
+		
+	   }
+		static void B() throws IOException {
+			int t=ni();
+			while(t-->0) {
+				int n=ni();
+				a=nai(n);
+				boolean isSorted=true,one=a[0]==1;
+				int pos=0;
+				for(int i=1;i<n;i++) {
+					if(a[i]<a[i-1])isSorted=false;
+					if(a[i]==1)pos=i;
+				}
+				boolean ok=true;
+				for(int i=pos+1;i<n;i++) {
+					if(a[i]<a[i-1])ok=false;
+				}
+				boolean lst=a[0]==n;
+				boolean fir=a[n-1]==1;
+				if(isSorted)ol(0);
+				else if(lst&&fir)ol(3);
+				else if(lst||fir)ol(2);
+				else if(a[0]==1||a[n-1]==n)ol(1);
+				else ol(2);
+//				if(isSorted)ol(0);
+//				else out.println(fl&&lst?3:((one?1:2)-(ok?1:0)+(lst?1:0)));
+			}
+		}
+		
+		static void C() throws IOException{
+			 int t=ni();
+			 while(t-->0) {
+				int n=ni();
+				int m=ni();
+				a=nai(n);
+				TreeMap<Integer, Integer>tr=new TreeMap<Integer, Integer>();
+				for(int i=0;i<n;i++)tr.put(a[i], i);
+				char[]mv=new char[n];
+				for(int i=0;i<n;i++) {
+					String s=ns();
+					mv[i]=s.charAt(0);
+				}
+				long[]ans=new long[n];
+				Arrays.fill(ans, -1);
+				PriorityQueue<Integer>lodd=new PriorityQueue<Integer>();
+				PriorityQueue<Integer>lev=new PriorityQueue<Integer>();
+				PriorityQueue<Integer>rodd=new PriorityQueue<Integer>();
+				PriorityQueue<Integer>rev=new PriorityQueue<Integer>();
+				for(int i=0;i<n;i++) {
+					if(a[i]%2==0) {
+						if(mv[i]=='L')lev.add(a[i]);
+						else rev.add(a[i]);
+					}else {
+						if(mv[i]=='L')lodd.add(a[i]);
+						else rodd.add(a[i]);
+					}
+				}
+				PriorityQueue<Integer>par[]=new PriorityQueue[4];
+				par[0]=rev;par[1]=rodd;par[2]=lev;par[3]=lodd;
+				for(int i=0;i<2;i++){
+					while(par[i].size()>=1&&par[i+2].size()>=1) {
+						int r=par[i].poll(),l=par[i+2].poll();
+						int d1=(l-r)/2;
+						if(l<r) {
+							d1=clc(l,r,m);
+						}
+						int dr=Integer.MAX_VALUE,dl=Integer.MAX_VALUE;
+						if(par[i].size()==1) {
+							dr=m-par[i].peek()+(par[i].peek()-r)/2;
+						}
+						if(!par[i+2].isEmpty()) {
+							dl=(par[i+2].peek()+l)/2;
+						}
+						int cur=Math.min(d1, Math.min(dl, dr));
+						if(cur==d1) {
+							ans[tr.get(r)]=ans[tr.get(l)]=cur;
+						}
+						else if(cur==dr) {
+							ans[tr.get(r)]=ans[tr.get(par[i].poll())]=cur;
+							par[i+2].add(l);
+						}else {
+							ans[tr.get(l)]=ans[tr.get(par[i+2].poll())]=cur;
+							par[i].add(r);
+						}
+						
+					}
+				}
+				for(int i=0;i<4;i++) {
+					if(i<2&&par[i].size()%2==1)par[i].poll();
+					while(par[i].size()>1) {
+						int x=par[i].poll(),y=par[i].poll();
+						int val=0;
+						if(i<2) {
+							val=m-y+(y-x)/2;
+						}else {
+							val=(x+y)/2;
+						}
+						ans[tr.get(x)]=ans[tr.get(y)]=val;
+					}
+				}
+				for(int i=0;i<n;i++) {
+					out.print(ans[i]+"" "");
+				}ol("""");
+			 }
+		}
+		private static int clc(int l, int r, int m) {
+			int b1=0,b2=m;
+			int ans=0;
+			if(l>m-r) {
+				ans+=l;
+				b2=2*m - l -r;// m-(l-m+r) -> m-l+m-r
+			}else {
+				ans+=m-r;
+				b1=m-r-l;
+			}
+			return ans+(b2-b1)/2;
+		}
+		private static Boolean dp(int i, int j) {
+			if(j>sum/2)return false;
+			if(i==x.size()) {
+				return sum/2==j;
+			}
+			if(dp[i][j]!=null)return dp[i][j];
+			
+			return dp[i][j]=dp(i+1,j+x.get(i)[0])||dp(i+1,j);
+		}
+		static boolean isPrime(long n) {
+			if(n==2)return true;
+			if(n<2||n%2==0)return false;
+			
+			for(long i=3L;i*i<n;i+=2l) {
+				long rem=(n%i);
+				if(rem==0)return false;
+			}
+			return true;
+		}
+		static long[][]mem;
+		static int ones;
+		static ArrayList<Integer>pos;
+		static void D() throws IOException {
+			int t=1;
+			while(t-->0) {
+				n=ni();
+				a=nai(n);
+				mem=new long[n][n];
+				ones=0;
+				pos=new ArrayList<Integer>();
+				for(int i=0;i<n;i++) {
+					Arrays.fill(mem[i], -1);
+					if(a[i]==1)pos.add(i);
+				}
+				ones=pos.size();
+				long ans=solve(0,0);
+				out.println(ans);
+			}
+		}
+		private static long solve(int i, int j) {
+			if(i==n||j>=ones)return j==ones?0:(long)1e14;
+			if(mem[i][j]!=-1)return mem[i][j];
+			long lv=solve(i+1,j);
+			if(a[i]==0) {
+				int pr=Math.abs(i-pos.get(j));
+				lv=Math.min(lv, pr+solve(i+1,j+1));
+			}
+			return mem[i][j]=lv;
+		}
+		private static int bfs(int i, int j,int k) {
+			boolean [][]vis=new boolean[dist.length][dist[0].length];
+			Queue<int[]>q=new LinkedList<int[]>();
+			int mn=Integer.MAX_VALUE;
+			q.add(new int[] {i,j,0,0});
+			int[]dx=new int[] {-1,1,0,0};
+			int[]dy=new int[] {0,0,1,-1};
+			while(!q.isEmpty()) {
+				int []x=q.poll();
+				vis[x[0]][x[1]]=true;
+				int c=x[2];
+				if(c>k/2)continue;
+				if(c>0&&k%c==0&&(k/c)%2==0) {
+					mn=Math.min(mn,x[3]*k/c );
+				}
+				for(int a=0;a<4;a++) {
+					int nx=x[0]+dx[a];
+					int ny=x[1]+dy[a];
+					if(valid(nx,ny)&&!vis[nx][ny]) {
+						q.add(new int[] {nx,ny,c+1,x[3]+dist[x[0]][x[1]][a]});
+					}
+				}
+				
+			}
+			return mn;
+		}
+		private static boolean valid(int nx, int ny) {
+			return nx>=0&&nx<dist.length&&ny>=0&&ny<dist[0].length;
+		}
+		static int gcd (int a, int b) {
+		    return b==0?a:gcd (b, a % b);
+		}
+		
+	static void E() throws IOException {
+		int t=ni();
+		while(t-->0) {
+			
+			
+		}
+		
+	}
+
+	static void F() throws IOException {
+		int t=ni();
+		while(t-->0) {
+			
+		}
+	}
+	static void CC() throws IOException {
+		for(int kk=2;kk<21;kk++) {
+			ol(kk+""   -------"");
+		int n=kk;
+		int k=n-2;
+		int msk=1<<k;
+		int[]a=new int[k];
+		for(int i=0;i<a.length;i++)a[i]=i+2;
+		int mx=1;
+		int ms=0;
+		for(int i=1;i<msk;i++) {
+			long prod=1;
+			int cnt=0;
+			for(int j=0;j<a.length;j++) {
+				if(((i>>j)&1)!=0) {
+					prod*=a[j];
+					cnt++;
+				}
+			}
+			if(cnt>=mx&&prod%n==1) {
+				mx=cnt;
+				ms=i;
+			}
+			
+		}
+		ol(mx==1?mx:mx+1);
+		out.print(1+"" "");
+		long pr=1;
+		for(int j=0;j<a.length;j++) {
+			if(((ms>>j)&1)!=0) {
+				out.print(a[j]+"" "");
+				pr*=a[j];
+			}
+		}
+		ol("""");
+		ol(""Prod: ""+pr);
+		ol(n+""*""+((pr-1)/n)+"" + ""+1);
+		}
+	}
+	static int ni() throws IOException {
+		return sc.nextInt();
+	}
+	static double nd() throws IOException {
+		return sc.nextDouble();
+	}
+	static long nl() throws IOException {
+		return  sc.nextLong();
+	}
+	static String ns() throws IOException {
+		return sc.next();
+	}
+	static int[] nai(int n) throws IOException {
+		int[] a = new int[n];
+		for (int i = 0; i < n; i++)
+			a[i] = sc.nextInt();
+		return a;
+	}
+	static long[] nal(int n) throws IOException {
+		long[] a = new long[n];
+		for (int i = 0; i < n; i++)
+			a[i] = sc.nextLong();
+		return a;
+	}
+	static int[][] nmi(int n,int m) throws IOException{
+		int[][]a=new int[n][m];
+		for(int i=0;i<n;i++) {
+			for(int j=0;j<m;j++) {
+				a[i][j]=sc.nextInt();
+			}
+		}
+		return a;
+	}
+
+	static long[][] nml(int n,int m) throws IOException{
+		long[][]a=new long[n][m];
+		for(int i=0;i<n;i++) {
+			for(int j=0;j<m;j++) {
+				a[i][j]=sc.nextLong();
+			}
+		}
+		return a;
+	}
+	static void o(String x) {
+		out.print(x);
+	}
+	static void ol(String x) {
+		out.println(x);
+	}
+	static void ol(int x) {
+		out.println(x);
+	}
+	static void disp1(int []a) {
+		for(int i=0;i<a.length;i++) {
+			out.print(a[i]+"" "");
+		}
+		out.println();
+	}
+
+	static class Scanner 
+	{
+		StringTokenizer st;
+		BufferedReader br;
+
+		public Scanner(InputStream s){	br = new BufferedReader(new InputStreamReader(s));}
+
+		public String next() throws IOException 
+		{
+			while (st == null || !st.hasMoreTokens()) 
+				st = new StringTokenizer(br.readLine());
+			return st.nextToken();
+		}
+		public boolean hasNext() {return st.hasMoreTokens();}
+		public int nextInt() throws IOException {return Integer.parseInt(next());}
+		
+		public double nextDouble() throws IOException {return Double.parseDouble(next());}
+		
+		public long nextLong() throws IOException {return Long.parseLong(next());}
+
+		public String nextLine() throws IOException {return br.readLine();}
+			
+		public boolean ready() throws IOException {return br.ready(); }
+		
+
+	}
+}
+",0
+a0b406e6,c9b4bb51,"import java.io.*;
+import java.util.*;
+
+public class Main {
+	public static void main(String[] args) {
+		InputStream inputStream = System.in;
+		OutputStream outputStream = System.out;
+		InputReader in = new InputReader(inputStream);
+		PrintWriter out = new PrintWriter(outputStream);
+		Task solver = new Task();
+		int tcCnt = in.nextInt();
+		for (int tc = 1; tc <= tcCnt; tc++)
+			solver.solve(tc, in, out);
+		out.close();
+	}
+
+	static class Task {
+		public void solve(int testNumber, InputReader in, PrintWriter out) {
+			int n = in.nextInt();
+			int[] a = new int[n];
+			for (int i = 0; i < n; i++) {
+				a[i] = in.nextInt();
+			}
+			for (int mask = 1; mask < (int)(Math.pow(3, n)); mask++) {
+				int copy = mask;
+				int sum = 0;
+				for (int idx = 0; idx < n; idx++) {
+					int digit = copy % 3;
+					sum += digit == 0 ? 0 : digit == 1 ? a[idx] : -a[idx];
+					copy = copy / 3;
+				}
+				if (sum == 0) {
+					out.println(""YES"");
+					return;
+				}
+			}
+			out.println(""NO"");
+		}
+
+	}
+
+	static class InputReader {
+		public BufferedReader reader;
+		public StringTokenizer tokenizer;
+
+		public InputReader(InputStream stream) {
+			reader = new BufferedReader(new InputStreamReader(stream), 32768);
+			tokenizer = null;
+		}
+
+		public String nextLine() {
+			try {
+				return reader.readLine();
+			} catch (IOException e) {
+				throw new RuntimeException(e);
+			}
+		}
+
+		public String nextToken() {
+			while (tokenizer == null || !tokenizer.hasMoreTokens()) {
+				tokenizer = new StringTokenizer(nextLine());
+			}
+			return tokenizer.nextToken();
+		}
+
+		public int nextInt() {
+			return Integer.parseInt(nextToken());
+		}
+
+		public double nextDouble() {
+			return Double.parseDouble(nextToken());
+		}
+
+		public long nextLong() {
+			return Long.parseLong(nextToken());
+		}
+
+		public int[] nextIntArray(int size) {
+			int[] arr = new int[size];
+			for (int i = 0; i < size; i++) {
+				arr[i] = nextInt();
+			}
+			return arr;
+		}
+
+	}
+}","import java.lang.*;
+import java.util.*;
+import java.io.*;
+import java.math.*;
+
+public class Main {
+    static void deal(int n,int[] arr) {
+        HashSet<Integer> hs = new HashSet<>();
+        int max = (int)Math.pow(3,n);
+        int[] sum = new int[max];
+        hs.add(0);
+        for(int i=1;i<max;i++) {
+            int s = 0;
+            int num = i;
+            int index = 0;
+            while(num>0) {
+                int d = num % 3;
+                num = num /3;
+                if(d==1) {
+                    s+=arr[index];
+                } else if(d==2) {
+                    s-=arr[index];
+                }
+                index++;
+            }
+            sum[i] = s;
+            if(s==0) {
+                out.println(""YES"");
+                return;
+            }
+            hs.add(sum[i]);
+        }
+        out.println(""NO"");
+    }
+
+    static int lowbit(int i) {
+        return i & (-i);
+    }
+
+	public static void main(String[] args) {
+        MyScanner sc = new MyScanner();
+        out = new PrintWriter(new BufferedOutputStream(System.out));
+        int t = sc.nextInt();
+        for(int i=0;i<t;i++) {
+            int n = sc.nextInt();
+            int[] arr = new int[n];
+            for(int j=0;j<n;j++) {
+                arr[j] = sc.nextInt();
+            }
+            deal(n,arr);
+        }
+        out.close();
+    }
+    
+    //-----------PrintWriter for faster output---------------------------------
+    public static PrintWriter out;
+    
+    //-----------MyScanner class for faster input----------
+    public static class MyScanner {
+        BufferedReader br;
+        StringTokenizer st;
+        
+        public MyScanner() {
+                br = new BufferedReader(new InputStreamReader(System.in));
+        }
+        
+        String next() {
+                while (st == null || !st.hasMoreElements()) {
+                        try {
+                                st = new StringTokenizer(br.readLine());
+                        } catch (IOException e) {
+                                e.printStackTrace();
+                        }
+                }
+                return st.nextToken();
+        }
+        
+        int nextInt() {
+                return Integer.parseInt(next());
+        }
+        
+        long nextLong() {
+                return Long.parseLong(next());
+        }
+        
+        double nextDouble() {
+                return Double.parseDouble(next());
+        }
+        
+        String nextLine(){
+                String str = """";
+    try {
+            str = br.readLine();
+    } catch (IOException e) {
+            e.printStackTrace();
+    }
+    return str;
+        }
+        
+    }
+}",0
+54d7c21e,ad4c7a20,"
+import java.io.*;
+import java.util.*;
+
+
+public class cp {
+	static int mod=(int)1e9+7;
+	
+//	static  Reader sc=new Reader();
+	static FastReader sc=new FastReader(System.in);
+	static int[] sp;
+	static int size=(int)1e6;
+	static int[] arInt;
+	static long[] arLong;
+	public static void main(String[] args) throws IOException { 
+		long tc=sc.nextLong();
+//		Scanner sc=new Scanner(System.in);
+//			int tc=1;
+			
+//			primeSet=new HashSet<>();
+//			sieveOfEratosthenes((int)1e6+5);
+			while(tc-->0)
+			{
+				int n=sc.nextInt();
+				int k[]=new int[n];
+				int h[]=new int[n];
+				for(int i=0;i<n;i++)
+					k[i]=sc.nextInt();
+				for(int i=0;i<n;i++)
+					h[i]=sc.nextInt();
+				ArrayList<Pair> interval=new ArrayList<Pair>();
+				ArrayList<Pair> act=new ArrayList<Pair>();
+				for(int i=0;i<n;i++)
+					interval.add(new Pair(k[i]-h[i]+1,k[i]));
+				Collections.sort(interval);
+				// out.println(interval);
+				act.add(interval.get(0));
+				for(int i=1;i<n;i++)
+				{
+					Pair p=act.get(act.size()-1);
+					if(p.y<interval.get(i).x)
+						act.add(interval.get(i));
+					else
+						p.y=Math.max(p.y, interval.get(i).y);
+				}
+				// out.println(act);
+				long mana=0;
+				for(Pair p: act)
+				{
+					long x=p.y-p.x+1;
+					mana+=(x*(x+1))/2;
+				}
+				out.println(mana);
+				
+				
+				
+				
+				
+				
+				
+				
+				
+//				int n=sc.nextInt();
+//				long days[]=new long[n];
+//				long power[]=new long[n];
+//				for (int i = 0; i < power.length; i++) {
+//					days[i]=sc.nextLong();
+//				}
+//				for (int i = 0; i < power.length; i++) {
+//					power[i]=sc.nextLong();
+//					
+//				}
+//				
+//				long ans=0;
+//				for(int i=0;i<n;i++)
+//				{
+//					if(i==0)
+//					{
+//						ans+=power[i]*(power[i]+1L)/2L;
+//						continue;
+//					}
+//					
+//					long temp=power[i]*(power[i]+1)/2L;
+//					long temp2=(power[i-1]+days[i]-days[i-1])*(power[i-1]+days[i]-days[i-1]+1L)/2L;
+//					temp2-=power[i-1]*(power[i-1]+1L)/2L;
+//					ans+=Math.min(temp, temp2);
+////					if(days[i]-days[i-1]<=power[i])
+////					{
+////						ans+=power[i]*(power[i]+1)/2;
+////					}
+////					else {
+////						ans+=power[i]*(power[i]+1)/2;
+////						ans-=power[i-1]*(power[i-1]+1)/2;
+////					}
+//						
+//					
+//				}
+//				
+//				out.println(ans);
+			}
+			
+				
+			
+			
+			out.flush();
+			out.close();
+			System.gc();
+	
+	}
+	
+	
+	
+
+
+	/*
+	   ...SOLUTION ENDS HERE...........SOLUTION ENDS HERE...
+ */
+	
+	
+	static int util(char a,char b)
+	{
+		int A=a-'0';
+		int B=b-'0';
+		return A+B;
+	}
+	static boolean check(int x,int[] rich,int[] poor)
+	{
+		int cnt=0;
+		for(int i=0;i<rich.length;i++)
+		{
+			if(x-1-rich[i]<=cnt && cnt<=poor[i])
+				cnt++;
+		}
+		
+		return cnt>=x;
+	}
+	
+	static void arrInt(int n) throws IOException
+	{
+		arInt=new int[n];
+		for (int i = 0; i < arInt.length; i++) {
+			arInt[i]=sc.nextInt();
+		}
+	}
+	
+	static void arrLong(int n) throws IOException
+	{
+		arLong=new long[n];
+		for (int i = 0; i < arLong.length; i++) {
+			arLong[i]=sc.nextLong();
+		}
+	}
+	
+	
+	
+	static ArrayList<Integer> add(int id,int c)
+	{
+		ArrayList<Integer> newArr=new ArrayList<>();
+		for(int i=0;i<id;i++)
+			newArr.add(arInt[i]);
+		newArr.add(c);
+		for(int i=id;i<arInt.length;i++)
+		{
+			newArr.add(arInt[i]);
+		}
+		
+		
+		return newArr;
+	}
+
+	    // function to find last index <= y
+    static int upper(ArrayList<Integer> arr, int n, int y)
+    {
+        int l = 0, h = n - 1;
+        while (l <= h)
+        {
+            int mid = (l + h) / 2;
+            if (arr.get(mid) <= y)
+                l = mid + 1;
+            else
+                h = mid - 1;
+        }
+        return h;
+    }
+     
+	
+	
+	static int lower(ArrayList<Integer> arr, int n, int x)
+    {
+        int l = 0, h = n - 1;
+        while (l <= h)
+        {
+            int mid = (l + h) / 2;
+            if (arr.get(mid) >= x)
+                h = mid - 1;
+            else
+                l = mid + 1;
+        }
+        return l;
+    }
+          
+	
+	
+	
+	
+	static int N = 501; 
+	 
+	// Array to store inverse of 1 to N
+	static long[] factorialNumInverse = new long[N + 1];
+	 
+	// Array to precompute inverse of 1! to N!
+	static long[] naturalNumInverse = new long[N + 1];
+	 
+	// Array to store factorial of first N numbers
+	static long[] fact = new long[N + 1];
+	 
+	// Function to precompute inverse of numbers
+	public static void InverseofNumber(int p)
+	{
+	    naturalNumInverse[0] = naturalNumInverse[1] = 1;
+	     
+	    for(int i = 2; i <= N; i++)
+	        naturalNumInverse[i] = naturalNumInverse[p % i] *
+	                                 (long)(p - p / i) % p;
+	}
+	 
+	// Function to precompute inverse of factorials
+	public static void InverseofFactorial(int p)
+	{
+	    factorialNumInverse[0] = factorialNumInverse[1] = 1;
+	 
+	    // Precompute inverse of natural numbers
+	    for(int i = 2; i <= N; i++)
+	        factorialNumInverse[i] = (naturalNumInverse[i] *
+	                           factorialNumInverse[i - 1]) % p;
+	}
+	 
+	// Function to calculate factorial of 1 to N
+	public static void factorial(int p)
+	{
+	    fact[0] = 1;
+	 
+	    // Precompute factorials
+	    for(int i = 1; i <= N; i++)
+	    {
+	        fact[i] = (fact[i - 1] * (long)i) % p;
+	    }
+	}
+	 
+	// Function to return nCr % p in O(1) time
+	public static long Binomial(int N, int R, int p)
+	{
+	     
+	    // n C r = n!*inverse(r!)*inverse((n-r)!)
+	    long ans = ((fact[N] * factorialNumInverse[R]) %
+	                       p * factorialNumInverse[N - R]) % p;
+	     
+	    return ans;
+	}
+	
+	
+	static String tr(String s)
+	{
+		int now = 0;
+		while (now + 1 < s.length() && s.charAt(now)== '0')
+			++now;
+		return s.substring(now);
+	}
+	
+	 static ArrayList<Integer> ans;
+	static void dfs(int node,Graph gg,int cnt,int k,ArrayList<Integer> temp)
+	{
+		if(cnt==k)
+			return;
+		
+		for(Integer each:gg.list[node])
+		{
+			if(each==0)
+			{
+				temp.add(each);
+				ans=new ArrayList<>(temp);
+				temp.remove(temp.size()-1);
+				continue;
+			}
+			temp.add(each);
+			dfs(each,gg,cnt+1,k,temp);
+			temp.remove(temp.size()-1);
+			
+		}
+		
+		return;
+	}
+	
+	
+	static boolean isPrime(long n)
+    {
+        // Corner cases
+        if (n <= 1)
+            return false;
+        if (n <= 3)
+            return true;
+  
+        // This is checked so that we can skip
+        // middle five numbers in below loop
+        if (n % 2 == 0 || n % 3 == 0)
+            return false;
+  
+        for (int i = 5; i * i <= n; i = i + 6)
+            if (n % i == 0 || n % (i + 2) == 0)
+                return false;
+  
+        return true;
+    }
+	
+	
+	static ArrayList<Integer> commDiv(int a, int b)
+    {
+        // find gcd of a, b
+        int n = gcd(a, b);
+ 
+        // Count divisors of n.
+        ArrayList<Integer> Div=new ArrayList<>();
+        for (int i = 1; i <= Math.sqrt(n); i++) {
+            // if 'i' is factor of n
+            if (n % i == 0) {
+                // check if divisors are equal
+                if (n / i == i)
+                    Div.add(i);
+                else
+                {
+                	Div.add(i);
+                	Div.add(n/i);
+                }
+            }
+        }
+        return Div;
+    }
+	
+	static HashSet<Integer> factors(int x)
+	{
+		HashSet<Integer> a=new HashSet<Integer>();
+		for(int i=2;i*i<=x;i++)
+		{
+			if(x%i==0)
+			{
+				a.add(i);
+				a.add(x/i);
+			}
+		}
+		return a;
+	}
+		
+	
+static class Node
+{
+	int vertex;
+	HashSet<Node> adj;
+	boolean rem;
+	Node(int ver)
+	{
+		vertex=ver;
+		rem=false;
+		adj=new HashSet<Node>();
+	}
+	@Override
+	public String toString()
+	{
+		return vertex+"" "";
+	}
+}
+
+	static class Tuple{
+		int a;
+		int b;
+		int c;
+		public Tuple(int a,int b,int c) {
+			this.a=a;
+			this.b=b;
+			this.c=c;
+		}
+		
+	}
+
+	//function to find prime factors of n
+	static HashMap<Long,Long> findFactors(long n2)
+	{
+		HashMap<Long,Long> ans=new HashMap<>();
+		if(n2%2==0)
+		{
+			ans.put(2L, 0L);
+//			cnt++;
+			while((n2&1)==0)
+			{
+				n2=n2>>1;
+				ans.put(2L, ans.get(2L)+1);
+//				
+			}
+				
+		}
+		for(long i=3;i*i<=n2;i+=2)
+		{
+			if(n2%i==0)
+			{
+				ans.put((long)i, 0L);
+//				cnt++;
+				while(n2%i==0)
+				{
+					n2=n2/i;
+					ans.put((long)i, ans.get((long)i)+1);
+					
+				}
+			}
+		}
+		if(n2!=1)
+		{
+			ans.put(n2, ans.getOrDefault(n2, (long) 0)+1);
+			
+		}
+			
+		return ans;
+	}
+	
+
+	//fenwick tree implementaion
+	static class fwt
+	{
+		int n;
+		long BITree[];
+		fwt(int n)
+		{
+			this.n=n;
+			BITree=new long[n+1];
+		}
+		
+		fwt(int arr[], int n)
+		{
+			this.n=n;
+			BITree=new long[n+1];
+			for(int i = 0; i < n; i++)
+			updateBIT(n, i, arr[i]);
+		 }
+		
+		   long getSum(int index)
+		   {
+		       long sum = 0;
+		       index = index + 1;
+		       while(index>0)
+		       {
+		           sum += BITree[index];
+		           index -= index & (-index);
+		       }
+		       return sum;
+		   }
+		   void updateBIT(int n, int index,int val)
+		   {
+		       index = index + 1;
+		       while(index <= n)
+		       {
+		       BITree[index] += val;
+		       index += index & (-index);
+		       }
+		   }
+		   void print()
+		   {
+			    for(int i=0;i<n;i++)
+			    out.print(getSum(i)+"" "");
+			    out.println();
+		   }
+	}
+
+	
+	class sparseTable{
+	int n;
+	long[][]dp;
+	int log2[];
+	int P;
+	
+	void buildTable(long[] arr)
+	{
+		n=arr.length;
+		P=(int)Math.floor(Math.log(n)/Math.log(2));
+		
+		log2=new int[n+1];
+		log2[0]=log2[1]=0;
+		for(int i=2;i<=n;i++)
+		{
+			log2[i]=log2[i/2]+1;
+		}
+		dp=new long[P+1][n];
+		for(int i=0;i<n;i++)
+		{
+			dp[0][i]=arr[i];
+		}
+		
+		for(int p=1;p<=P;p++)
+		{
+			for(int i=0;i+(1<<p)<=n;i++)
+			{
+				long left=dp[p-1][i];
+				long right=dp[p-1][i+(1<<(p-1))];
+				dp[p][i]=Math.max(left, right);
+			}
+		}
+	}
+	
+	
+	long maxQuery(int l,int r)
+	{
+		int len=r-l+1;
+		int p=(int)Math.floor(log2[len]);
+		long left=dp[p][l];
+		long right=dp[p][r-(1<<p)+1];
+		return Math.max(left, right);
+	}
+}
+
+	
+	
+	
+	//Function to find number of set bits
+	static int setBitNumber(long n)
+    {
+        if (n == 0)
+            return 0;
+ 
+        int msb = 0;
+        n = n / 2;
+ 
+        while (n != 0) {
+            n = n / 2;
+            msb++;
+        }
+ 
+        return msb;
+    }
+ 
+	
+	
+	static int getFirstSetBitPos(long n)
+    {
+        return (int)((Math.log10(n & -n)) / Math.log10(2)) + 1;
+    }
+	
+	
+	static ArrayList<Integer> primes;
+	static HashSet<Integer> primeSet;
+	static boolean prime[];
+	static void sieveOfEratosthenes(int n)
+    {
+        // Create a boolean array
+        // ""prime[0..n]"" and
+        // initialize all entries
+        // it as true. A value in
+        // prime[i] will finally be
+        // false if i is Not a
+        // prime, else true.
+       prime= new boolean[n + 1];
+        for (int i = 2; i <= n; i++)
+            prime[i] = true;
+        
+        for (int p = 2; p * p <= n; p++)
+        {
+            // If prime[p] is not changed, then it is a
+            // prime
+            if (prime[p] == true)
+            {
+                // Update all multiples of p
+                for (int i = p * p; i <= n; i += p)
+                    prime[i] = false;
+            }
+        }
+ 
+        // Print all prime numbers
+        for (int i = 2; i <= n; i++)
+        {
+            if (prime[i] == true)
+               primeSet.add(i);
+        }
+    }
+	
+	
+	
+	static long mod(long a, long b) {
+		  long c = a % b;
+		  return (c < 0) ? c + b : c;
+		}
+	
+	static void swap(long arr[],int i,int j)
+	{
+		long temp=arr[i];
+		arr[i]=arr[j];
+		arr[j]=temp;
+	}
+
+	
+	
+	static boolean util(int a,int b,int c)
+	{
+		if(b>a)util(b, a, c);
+		
+		while(c>=a)
+		{
+			c-=a;
+			if(c%b==0)
+				return true;
+		}
+		
+		
+		return (c%b==0);
+	}
+	
+	
+	
+	static void flag(boolean flag)
+	   {
+	       out.println(flag ? ""YES"" : ""NO"");
+	       out.flush();
+	   }
+	  
+	
+	static void print(int a[])
+	  {
+	     int n=a.length;
+	     for(int i=0;i<n;i++)
+	       {
+	          out.print(a[i]+"" "");
+	       }
+	     out.println();
+	     out.flush();
+	  }
+	static void print(long a[])
+	  {
+	     int n=a.length;
+	     for(int i=0;i<n;i++)
+	       {
+	          out.print(a[i]+"" "");
+	       }
+	     out.println();
+	     out.flush();
+	  } 
+	static void print_int(ArrayList<Integer> al)
+	  {
+	     int si=al.size();
+	     for(int i=0;i<si;i++)
+	       {
+	          out.print(al.get(i)+"" "");
+	       }
+	     out.println();
+	     out.flush();
+	  }
+	static void print_long(ArrayList<Long> al)
+	  {
+	     int si=al.size();
+	     for(int i=0;i<si;i++)
+	       {
+	          out.print(al.get(i)+"" "");
+	       }
+	     out.println();
+	     out.flush();
+	  }
+	  
+	static void printYesNo(boolean condition)
+	{
+		if (condition) {
+			out.println(""YES"");
+		}
+		else {
+			out.println(""NO"");
+		}
+	}
+	
+	
+	static int LowerBound(int a[], int x) 
+	 { // x is the target value or key
+	  int l=-1,r=a.length;
+	  while(l+1<r) {
+	    int m=(l+r)>>>1;
+	    if(a[m]>=x) r=m;
+	    else l=m;
+	  }
+	  return r;
+	}
+	
+	
+	static int lowerIndex(int arr[], int n, int x)
+    {
+        int l = 0, h = n - 1;
+        while (l <= h)
+        {
+            int mid = (l + h) / 2;
+            if (arr[mid] >= x)
+                h = mid - 1;
+            else
+                l = mid + 1;
+        }
+        return l;
+    }
+	
+	
+	    // function to find last index <= y
+    static int upperIndex(int arr[], int n, int y)
+    {
+        int l = 0, h = n - 1;
+        while (l <= h)
+        {
+            int mid = (l + h) / 2;
+            if (arr[mid] <= y)
+                l = mid + 1;
+            else
+                h = mid - 1;
+        }
+        return h;
+    }
+    static int upperIndex(long arr[], int n, long y)
+    {
+    	int l = 0, h = n - 1;
+    	while (l <= h)
+    	{
+    		int mid = (l + h) / 2;
+    		if (arr[mid] <= y)
+    			l = mid + 1;
+    		else
+    			h = mid - 1;
+    	}
+    	return h;
+    }
+     
+	
+	 static int UpperBound(int a[], int x)
+	  {// x is the key or target value
+	    int l=-1,r=a.length;
+	    while(l+1<r) {
+	       int m=(l+r)>>>1;
+	       if(a[m]<=x) l=m;
+	       else r=m;
+	    }
+	    return l+1;
+	 }
+	 static int UpperBound(long a[], long x)
+	 {// x is the key or target value
+		 int l=-1,r=a.length;
+		 while(l+1<r) {
+			 int m=(l+r)>>>1;
+	       if(a[m]<=x) l=m;
+	       else r=m;
+		 }
+		 return l+1;
+	 }
+	
+	 
+	 static class DisjointUnionSets
+	 {
+	    int[] rank, parent;
+	    int n;
+	    // Constructor
+	    public DisjointUnionSets(int n)
+	    {
+	        rank = new int[n];
+	        parent = new int[n];
+	        this.n = n;
+	        makeSet();
+	    }
+	    // Creates n sets with single item in each
+	    void makeSet()
+	    {
+	        for (int i = 0; i < n; i++)
+	            parent[i] = i;
+	    }
+	    int find(int x)
+	    {
+	        if (parent[x] != x) {
+	            parent[x] = find(parent[x]);
+	        }
+	        return parent[x];
+	    }
+	    // Unites the set that includes x and the set
+	    // that includes x
+	    void union(int x, int y)
+	    {
+	        int xRoot = find(x), yRoot = find(y);
+	        if (xRoot == yRoot)
+	            return;
+	        if (rank[xRoot] < rank[yRoot])
+	            parent[xRoot] = yRoot;
+	        else if (rank[yRoot] < rank[xRoot])
+	         parent[yRoot] = xRoot;
+	        else // if ranks are the same
+	        {
+	         parent[yRoot] = xRoot;
+	            rank[xRoot] = rank[xRoot] + 1;
+	        }
+	        
+//	        if(xRoot!=yRoot)
+//	        	parent[y]=x;
+	    }
+	    
+	    int connectedComponents()
+	    {
+	    	int cnt=0;
+	    	for(int i=0;i<n;i++)
+	    	{
+	    		if(parent[i]==i)
+	    			cnt++;
+	    	}
+	    	return cnt;
+	    }
+	 }
+
+	 
+
+	 
+	 
+	static class Graph
+	  {
+	        int v;
+	        ArrayList<Integer> list[];
+	        Graph(int v)
+	        {
+	            this.v=v;
+	            list=new ArrayList[v+1];
+	            for(int i=1;i<=v;i++)
+	                list[i]=new ArrayList<Integer>();
+	        }
+	        void addEdge(int a, int b)
+	        {
+	            this.list[a].add(b);
+	        }
+	    }
+	
+	
+	
+//	static class GraphMap{
+//		Map<String,ArrayList<String>> graph;
+//		GraphMap() {
+//			// TODO Auto-generated constructor stub
+//			graph=new HashMap<String,ArrayList<String>>();
+//			
+//		}
+//		void addEdge(String a,String b)
+//		{
+//			if(graph.containsKey(a))
+//			this.graph.get(a).add(b);
+//			else {
+//				this.graph.put(a, new ArrayList<>());
+//				this.graph.get(a).add(b);
+//			}
+//		}
+//	}
+//	static void dfsMap(GraphMap g,HashSet<String> vis,String src,int ok)
+//	{
+//		vis.add(src);
+//		
+//		if(g.graph.get(src)!=null)
+//		{
+//			for(String each:g.graph.get(src))
+//			{
+//				if(!vis.contains(each))
+//				{
+//					dfsMap(g, vis, each, ok+1);
+//				}
+//			}
+//		}
+//		
+//		cnt=Math.max(cnt, ok);
+//	}
+	static double sum[];
+	static long cnt;
+//	static void DFS(Graph g, boolean[] visited, int u)
+//		{
+//	        visited[u]=true;
+//	        
+//	        for(int i=0;i<g.list[u].size();i++)
+//	        {
+//	            int v=g.list[u].get(i);
+//	            
+//	            if(!visited[v])
+//	            {
+//	            	cnt1=cnt1*2;
+//	            	DFS(g, visited, v);
+//	            
+//	            }
+//	            
+//	        }
+//	       
+//
+//	  } 
+	
+	
+	  
+	 static class Pair implements Comparable<Pair>
+	    {
+	       int x;
+	       int y;
+	       Pair(int x,int y)
+	        {
+	           this.x=x;
+	           this.y=y;
+	          
+	        }
+		@Override
+		public int compareTo(Pair o) {
+			// TODO Auto-generated method stub
+			return this.x-o.x;
+		}
+	       
+	       
+	       
+	    }
+	   
+	static long sum_array(int a[])
+	 {
+	    int n=a.length;
+	    long sum=0;
+	    for(int i=0;i<n;i++)
+	     sum+=a[i];
+	    return sum;
+	 }
+	static long sum_array(long a[])
+	 {
+	    int n=a.length;
+	    long sum=0;
+	    for(int i=0;i<n;i++)
+	     sum+=a[i];
+	    return sum;
+	 }
+
+	 static void sort(int[] a) 
+	   {
+			ArrayList<Integer> l=new ArrayList<>();
+			for (int i:a) l.add(i);
+			Collections.sort(l);
+			for (int i=0; i<a.length; i++) a[i]=l.get(i);
+		}
+	static void sort(long[] a) 
+	   {
+			ArrayList<Long> l=new ArrayList<>();
+			for (long i:a) l.add(i);
+			Collections.sort(l);
+			for (int i=0; i<a.length; i++) a[i]=l.get(i);
+		}
+
+	static void reverse_array(int a[])
+	 {
+	    int n=a.length;
+	    int i,t; 
+	    for (i = 0; i < n / 2; i++) { 
+	            t = a[i]; 
+	            a[i] = a[n - i - 1]; 
+	            a[n - i - 1] = t; 
+	        } 
+	 }
+	static void reverse_array(long a[])
+	 {
+	    int n=a.length;
+	    int i; long t; 
+	    for (i = 0; i < n / 2; i++) { 
+	            t = a[i]; 
+	            a[i] = a[n - i - 1]; 
+	            a[n - i - 1] = t; 
+	        } 
+	 }
+//	 static long modInverse(long a, long m)
+//		    {
+//		        long g = gcd(a, m);
+//		       
+//		          return   power(a, m - 2, m);
+//		        
+//		    }
+	static long power(long x, long y)
+	 {
+	   long res = 1;
+	   x = x % mod;
+	   if (x == 0)
+	     return 0;
+	   while (y > 0)
+	   {
+	    if ((y & 1) != 0)
+	    res = (res * x) % mod;
+	   
+	    y = y >> 1; // y = y/2
+	    x = (x * x) % mod;
+	   }
+	   return res;
+	 }
+	static int power(int x, int y)
+	{
+		int res = 1;
+		x = x % mod;
+		if (x == 0)
+			return 0;
+		while (y > 0)
+		{
+			if ((y & 1) != 0)
+				res = (res * x) % mod;
+			
+			y = y >> 1; // y = y/2
+	    x = (x * x) % mod;
+		}
+		return res;
+	}
+	static long gcd(long a, long b) 
+	    { 
+			
+	        if (a == 0) 
+	            return b; 
+	         //cnt+=a/b;
+	        return gcd(b%a,a); 
+	    } 
+	static int gcd(int a, int b) 
+	    { 
+	        if (a == 0) 
+	            return b; 
+	          
+	        return gcd(b%a, a); 
+	    } 
+
+	   static class FastReader{
+	 
+	        byte[] buf = new byte[2048];
+	        int index, total;
+	        InputStream in;
+	 
+	        FastReader(InputStream is) {
+	            in = is;
+	        }
+	 
+	        int scan() throws IOException {
+	            if (index >= total) {
+	                index = 0;
+	                total = in.read(buf);
+	                if (total <= 0) {
+	                    return -1;
+	                }
+	            }
+	            return buf[index++];
+	        }
+	 
+	        String next() throws IOException {
+	            int c;
+	            for (c = scan(); c <= 32; c = scan());
+	            StringBuilder sb = new StringBuilder();
+	            for (; c > 32; c = scan()) {
+	                sb.append((char) c);
+	            }
+	            return sb.toString();
+	        }
+	 
+	        int nextInt() throws IOException {
+	            int c, val = 0;
+	            for (c = scan(); c <= 32; c = scan());
+	            boolean neg = c == '-';
+	            if (c == '-' || c == '+') {
+	                c = scan();
+	            }
+	            for (; c >= '0' && c <= '9'; c = scan()) {
+	                val = (val << 3) + (val << 1) + (c & 15);
+	            }
+	            return neg ? -val : val;
+	        }
+	 
+	        long nextLong() throws IOException {
+	            int c;
+	            long val = 0;
+	            for (c = scan(); c <= 32; c = scan());
+	            boolean neg = c == '-';
+	            if (c == '-' || c == '+') {
+	                c = scan();
+	            }
+	            for (; c >= '0' && c <= '9'; c = scan()) {
+	                val = (val << 3) + (val << 1) + (c & 15);
+	            }
+	            return neg ? -val : val;
+	        }
+	    }
+	   
+	    static class Reader 
+	    { 
+	        final private int BUFFER_SIZE = 1 << 16; 
+	        private DataInputStream din; 
+	        private byte[] buffer; 
+	        private int bufferPointer, bytesRead; 
+	  
+	        public Reader() 
+	        { 
+	            din = new DataInputStream(System.in); 
+	            buffer = new byte[BUFFER_SIZE]; 
+	            bufferPointer = bytesRead = 0; 
+	        } 
+	  
+	        public Reader(String file_name) throws IOException 
+	        { 
+	            din = new DataInputStream(new FileInputStream(file_name)); 
+	            buffer = new byte[BUFFER_SIZE]; 
+	            bufferPointer = bytesRead = 0; 
+	        } 
+	  
+	        public String readLine() throws IOException 
+	        { 
+	            byte[] buf = new byte[64]; // line length 
+	            int cnt = 0, c; 
+	            while ((c = read()) != -1) 
+	            { 
+	                if (c == '\n') 
+	                    break; 
+	                buf[cnt++] = (byte) c; 
+	            } 
+	            return new String(buf, 0, cnt); 
+	        } 
+	  
+	        public int nextInt() throws IOException 
+	        { 
+	            int ret = 0; 
+	            byte c = read(); 
+	            while (c <= ' ') 
+	                c = read(); 
+	            boolean neg = (c == '-'); 
+	            if (neg) 
+	                c = read(); 
+	            do
+	            { 
+	                ret = ret * 10 + c - '0'; 
+	            }  while ((c = read()) >= '0' && c <= '9'); 
+	  
+	            if (neg) 
+	                return -ret; 
+	            return ret; 
+	        } 
+	  
+	        public long nextLong() throws IOException 
+	        { 
+	            long ret = 0; 
+	            byte c = read(); 
+	            while (c <= ' ') 
+	                c = read(); 
+	            boolean neg = (c == '-'); 
+	            if (neg) 
+	                c = read(); 
+	            do { 
+	                ret = ret * 10 + c - '0'; 
+	            } 
+	            while ((c = read()) >= '0' && c <= '9'); 
+	            if (neg) 
+	                return -ret; 
+	            return ret; 
+	        } 
+	  
+	        public double nextDouble() throws IOException 
+	        { 
+	            double ret = 0, div = 1; 
+	            byte c = read(); 
+	            while (c <= ' ') 
+	                c = read(); 
+	            boolean neg = (c == '-'); 
+	            if (neg) 
+	                c = read(); 
+	  
+	            do { 
+	                ret = ret * 10 + c - '0'; 
+	            } 
+	            while ((c = read()) >= '0' && c <= '9'); 
+	  
+	            if (c == '.') 
+	            { 
+	                while ((c = read()) >= '0' && c <= '9') 
+	                { 
+	                    ret += (c - '0') / (div *= 10); 
+	                } 
+	            } 
+	  
+	            if (neg) 
+	                return -ret; 
+	            return ret; 
+	        } 
+	  
+	        private void fillBuffer() throws IOException 
+	        { 
+	            bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE); 
+	            if (bytesRead == -1) 
+	                buffer[0] = -1; 
+	        } 
+	  
+	        private byte read() throws IOException 
+	        { 
+	            if (bufferPointer == bytesRead) 
+	                fillBuffer(); 
+	            return buffer[bufferPointer++]; 
+	        } 
+	  
+	        public void close() throws IOException 
+	        { 
+	            if (din == null) 
+	                return; 
+	            din.close(); 
+	        } 
+	    }
+	  static  PrintWriter out=new PrintWriter(System.out);
+	  static int int_max=Integer.MAX_VALUE;
+	  static int int_min=Integer.MIN_VALUE;
+	  static long long_max=Long.MAX_VALUE;
+	  static long long_min=Long.MIN_VALUE;
+
+}
+
+
+
+
+","import java.io.*;
+import java.util.*;
+
+
+public class Practice
+{
+//	static final long mod=7420738134811L;
+	static int mod=1000000007;
+	static final int size=501;
+	static FastReader sc=new FastReader(System.in);
+//	static Reader sc=new Reader();
+//	static Scanner sc=new Scanner(System.in);
+	static  PrintWriter out=new PrintWriter(System.out);
+	static long[] factorialNumInverse;
+	static long[] naturalNumInverse;	
+	static int[] sp;
+	static long[] fact;
+	static ArrayList<Integer> pr;
+	public static void main(String[] args) throws IOException, CloneNotSupportedException
+	{
+//		System.setIn(new FileInputStream(""input.txt""));
+//		System.setOut(new PrintStream(""output.txt""));
+//		factorial(mod);
+//		InverseofNumber(mod);
+//		InverseofFactorial(mod);
+//		make_seive();
+		int t=1;
+		t=sc.nextInt();
+		for(int i=1;i<=t;i++)
+			solve(i);
+		out.close();
+		out.flush();
+//		System.out.flush();
+//		System.exit(0);
+	}
+	
+	static void solve(int CASENO) throws IOException, CloneNotSupportedException
+	{
+		int n=sc.nextInt();
+		int k[]=new int[n];
+		int h[]=new int[n];
+		for(int i=0;i<n;i++)
+			k[i]=sc.nextInt();
+		for(int i=0;i<n;i++)
+			h[i]=sc.nextInt();
+		ArrayList<Pair> interval=new ArrayList<Pair>();
+		ArrayList<Pair> act=new ArrayList<Pair>();
+		for(int i=0;i<n;i++)
+			interval.add(new Pair(k[i]-h[i]+1,k[i]));
+		Collections.sort(interval);
+//		out.println(interval);
+		act.add(interval.get(0).clone());
+		for(int i=1;i<n;i++)
+		{
+			Pair p=act.get(act.size()-1);
+			if(p.y<interval.get(i).x)
+				act.add(interval.get(i).clone());
+			else
+				p.y=Math.max(p.y, interval.get(i).y);
+		}
+//		out.println(act);
+		long mana=0;
+		for(Pair p: act)
+		{
+			long x=p.y-p.x+1;
+			mana+=(x*(x+1))/2;
+		}
+		out.println(mana);
+	}
+	static class Pair implements Cloneable, Comparable<Pair>
+	{
+		int x,y;
+		Pair(int a,int b)
+		{
+			this.x=a;
+			this.y=b;
+		}
+		@Override
+		public boolean equals(Object obj) 
+		{
+			if(obj instanceof  Pair)
+			{
+				Pair p=(Pair)obj;
+				return p.x==this.x && p.y==this.y;
+			}
+			return false;
+		}
+		@Override
+		public int hashCode() 
+		{
+			return Math.abs(x)+500*Math.abs(y);
+		}
+		@Override
+		public String toString() 
+		{
+			return ""(""+x+"" ""+y+"")"";
+		}
+		@Override
+		protected Pair clone() throws CloneNotSupportedException {
+			return new Pair(this.x,this.y);
+		}
+		@Override
+		public int compareTo(Pair a) 
+		{
+			long t=(this.x-a.x);
+			if(t!=0)
+				return t>0?1:-1;
+			else
+				return (int)(this.y-a.y);
+		}
+		public void swap()
+		{
+			this.y=this.y+this.x;
+			this.x=this.y-this.x;
+			this.y=this.y-this.x;			
+		}
+	}
+	static class Tuple implements Cloneable, Comparable<Tuple>
+	{
+		int x,y,z;
+		Tuple(int a,int b,int c)
+		{
+			this.x=a;
+			this.y=b;
+			this.z=c;
+		}
+		public boolean equals(Object obj) 
+		{
+			if(obj instanceof  Tuple)
+			{
+				Tuple p=(Tuple)obj;
+				return p.x==this.x && p.y==this.y && p.z==this.z;
+			}
+			return false;
+		}
+		@Override
+		public int hashCode() 
+		{
+			return (this.x+501*this.y);
+		}
+		@Override
+		public String toString() 
+		{
+			return ""(""+x+"",""+y+"",""+z+"")"";
+		}
+		@Override
+		protected Tuple clone() throws CloneNotSupportedException {
+			return new Tuple(this.x,this.y,this.z);
+		}
+		@Override
+		public int compareTo(Tuple a) 
+		{
+			int x=this.z-a.z;
+			if(x!=0)
+				return x;
+			int X= this.x-a.x;
+			if(X!=0)
+				return X;
+			return a.y-this.y;
+		}
+	}
+	static void arraySort(int arr[])
+	{
+		ArrayList<Integer> a=new ArrayList<Integer>();
+		for (int i = 0; i < arr.length; i++) {
+			a.add(arr[i]);
+		}
+		Collections.sort(a,Comparator.reverseOrder());
+		for (int i = 0; i < arr.length; i++) {
+			arr[i]=a.get(i);
+		}
+	}
+	static void arraySort(long arr[])
+	{
+		ArrayList<Long> a=new ArrayList<Long>();
+		for (int i = 0; i < arr.length; i++) {
+			a.add(arr[i]);
+		}
+		Collections.sort(a);
+		for (int i = 0; i < arr.length; i++) {
+			arr[i]=a.get(i);
+		}
+	}
+	static HashSet<Integer> primeFactors(int n)
+	{
+		HashSet<Integer> ans=new HashSet<Integer>();
+		if(n%2==0)
+		{
+			ans.add(2);
+			while((n&1)==0)
+				n=n>>1;
+		}
+		for(int i=3;i*i<=n;i+=2)
+		{
+			if(n%i==0)
+			{
+				ans.add(i);
+				while(n%i==0)
+					n=n/i;
+			}
+		}
+		if(n!=1)
+			ans.add(n);
+		return ans;
+	}
+	static void make_seive()
+	{
+		sp=new int[size];
+		pr=new ArrayList<Integer>();
+		for (int i=2; i<size; ++i) {
+		    if (sp[i] == 0) {
+		        sp[i] = i;
+		        pr.add(i);
+		    }
+		    for (int j=0; j<(int)pr.size() && pr.get(j)<=sp[i] && i*pr.get(j)<size; ++j)
+		        sp[i * pr.get(j)] = pr.get(j);
+		}
+	}
+	public static void InverseofNumber(int p)
+	{
+		naturalNumInverse=new long[size];
+	    naturalNumInverse[0] = naturalNumInverse[1] = 1;
+	    for(int i = 2; i < size; i++)
+	        naturalNumInverse[i] = naturalNumInverse[p % i] * (long)(p - p / i) % p;
+	}
+	// Function to precompute inverse of factorials
+	public static void InverseofFactorial(int p)
+	{
+		factorialNumInverse=new long[size];
+	    factorialNumInverse[0] = factorialNumInverse[1] = 1;
+	    // pre-compute inverse of natural numbers
+	    for(int i = 2; i < size; i++)
+	        factorialNumInverse[i] = (naturalNumInverse[i] * factorialNumInverse[i - 1]) % p;
+	}
+	// Function to calculate factorial of 1 to 200001
+	public static void factorial(int p)
+	{
+		fact=new long[size];
+	    fact[0] = 1;
+	    for(int i = 1; i < size; i++)
+	        fact[i] = (fact[i - 1] * (long)i) % p;
+	}
+	 
+	// Function to return nCr % p in O(1) time
+	public static long Binomial(int N, int R)
+	{
+		if(R<0)
+			return 1;
+	    // n C r = n!*inverse(r!)*inverse((n-r)!)
+	    long ans = ((fact[N] * factorialNumInverse[R]) % mod * factorialNumInverse[N - R]) % mod;
+	    return ans;
+	}
+	static int findXOR(int x)	//from 0 to x
+	{
+		if(x<0)
+			return 0;
+		if(x%4==0)
+			return x;
+		if(x%4==1)
+			return 1;
+		if(x%4==2)
+			return x+1;
+		return 0;
+	}
+	static boolean isPrime(long x)
+	{
+		if(x==1)
+			return false;
+		if(x<=3)
+			return true;
+		if(x%2==0 || x%3==0)
+			return false;
+		for(int i=5;i<=Math.sqrt(x);i+=2)
+			if(x%i==0)
+				return false;
+		return true;
+	}
+	static long gcd(long a,long b)
+	{
+		return (b==0)?a:gcd(b,a%b);
+	}
+	static int gcd(int a,int b)
+	{
+		return (b==0)?a:gcd(b,a%b);
+	}
+	static class Node
+	{
+		int vertex,dis;
+		HashSet<Node> adj;
+		Node(int ver)
+		{
+			vertex=ver;
+			dis=-1;
+			adj=new HashSet<Node>();
+		}
+		@Override
+		public String toString() 
+		{
+			return vertex+"" "";
+		}
+	}
+	static class Edge
+	{
+		Node to;
+		int cost;
+		Edge(Node t,int c)
+		{
+			this.to=t;
+			this.cost=c;
+		}
+		@Override
+		public String toString() {
+			return ""(""+to.vertex+"",""+cost+"") "";
+		}
+	}
+	static long power(long x, long y)
+	  {
+		if(x<=0)
+			return 1;
+	    long res = 1; 
+	    x = x % mod; 
+	    if (x == 0)
+	      return 0; 
+	    while (y > 0)
+	    {
+	    	if ((y & 1) != 0)
+	    		res = (res * x) % mod;
+	    	
+	    	y = y >> 1; // y = y/2
+	    	x = (x * x) % mod;
+	    }
+	    return res%mod;
+	  }
+	static long binomialCoeff(long n, long k)
+    {
+		if(n<k)
+			return 0;
+        long res = 1;
+        // Since C(n, k) = C(n, n-k)
+        if (k > n - k)
+            k = n - k;
+ 
+        // Calculate value of
+        // [n * (n-1) *---* (n-k+1)] / [k * (k-1) *----* 1]
+        for (long i = 0; i < k; ++i) {
+            res *= (n - i);
+            res /= (i + 1);
+        }
+ 
+        return res;
+    }
+	static class FastReader
+	{
+        byte[] buf = new byte[2048];
+        int index, total;
+        InputStream in;
+ 
+        FastReader(InputStream is) 
+        {
+            in = is;
+        }
+ 
+        int scan() throws IOException 
+        {
+            if (index >= total) {
+                index = 0;
+                total = in.read(buf);
+                if (total <= 0) {
+                    return -1;
+                }
+            }
+            return buf[index++];
+        }
+ 
+        String next() throws IOException 
+        {
+            int c;
+            for (c = scan(); c <= 32; c = scan());
+            StringBuilder sb = new StringBuilder();
+            for (; c > 32; c = scan()) {
+                sb.append((char) c);
+            }
+            return sb.toString();
+        }
+ 
+        int nextInt() throws IOException 
+        {
+            int c, val = 0;
+            for (c = scan(); c <= 32; c = scan());
+            boolean neg = c == '-';
+            if (c == '-' || c == '+') {
+                c = scan();
+            }
+            for (; c >= '0' && c <= '9'; c = scan()) {
+                val = (val << 3) + (val << 1) + (c & 15);
+            }
+            return neg ? -val : val;
+        }
+ 
+        long nextLong() throws IOException 
+        {
+            int c;
+            long val = 0;
+            for (c = scan(); c <= 32; c = scan());
+            boolean neg = c == '-';
+            if (c == '-' || c == '+') {
+                c = scan();
+            }
+            for (; c >= '0' && c <= '9'; c = scan()) {
+                val = (val << 3) + (val << 1) + (c & 15);
+            }
+            return neg ? -val : val;
+        }
+    }
+	static class Reader 
+	{
+        final private int BUFFER_SIZE = 1 << 16;
+        private DataInputStream din;
+        private byte[] buffer;
+        private int bufferPointer, bytesRead;
+ 
+        public Reader()
+        {
+            din = new DataInputStream(System.in);
+            buffer = new byte[BUFFER_SIZE];
+            bufferPointer = bytesRead = 0;
+        }
+ 
+        public Reader(String file_name) throws IOException
+        {
+            din = new DataInputStream(
+                new FileInputStream(file_name));
+            buffer = new byte[BUFFER_SIZE];
+            bufferPointer = bytesRead = 0;
+        }
+ 
+        public String readLine() throws IOException
+        {
+            byte[] buf = new byte[64]; // line length
+            int cnt = 0, c;
+            while ((c = read()) != -1) {
+                if (c == '\n') {
+                    if (cnt != 0) {
+                        break;
+                    }
+                    else {
+                        continue;
+                    }
+                }
+                buf[cnt++] = (byte)c;
+            }
+            return new String(buf, 0, cnt);
+        }
+ 
+        public int nextInt() throws IOException
+        {
+            int ret = 0;
+            byte c = read();
+            while (c <= ' ') {
+                c = read();
+            }
+            boolean neg = (c == '-');
+            if (neg)
+                c = read();
+            do {
+                ret = ret * 10 + c - '0';
+            } while ((c = read()) >= '0' && c <= '9');
+ 
+            if (neg)
+                return -ret;
+            return ret;
+        }
+ 
+        public long nextLong() throws IOException
+        {
+            long ret = 0;
+            byte c = read();
+            while (c <= ' ')
+                c = read();
+            boolean neg = (c == '-');
+            if (neg)
+                c = read();
+            do {
+                ret = ret * 10 + c - '0';
+            } while ((c = read()) >= '0' && c <= '9');
+            if (neg)
+                return -ret;
+            return ret;
+        }
+ 
+        public double nextDouble() throws IOException
+        {
+            double ret = 0, div = 1;
+            byte c = read();
+            while (c <= ' ')
+                c = read();
+            boolean neg = (c == '-');
+            if (neg)
+                c = read();
+ 
+            do {
+                ret = ret * 10 + c - '0';
+            } while ((c = read()) >= '0' && c <= '9');
+ 
+            if (c == '.') {
+                while ((c = read()) >= '0' && c <= '9') {
+                    ret += (c - '0') / (div *= 10);
+                }
+            }
+ 
+            if (neg)
+                return -ret;
+            return ret;
+        }
+ 
+        private void fillBuffer() throws IOException
+        {
+            bytesRead = din.read(buffer, bufferPointer = 0,
+                                 BUFFER_SIZE);
+            if (bytesRead == -1)
+                buffer[0] = -1;
+        }
+ 
+        private byte read() throws IOException
+        {
+            if (bufferPointer == bytesRead)
+                fillBuffer();
+            return buffer[bufferPointer++];
+        }
+ 
+        public void close() throws IOException
+        {
+            if (din == null)
+                return;
+            din.close();
+        }
+        public void printarray(int arr[])
+        {
+        	for (int i = 0; i < arr.length; i++)
+				System.out.print(arr[i]+"" "");
+        	System.out.println();
+        }
+    }
+}
+
+
+
+
+
+
+
+",1
+9862c742,d9199dfd,"/******************************************************************************
+
+Welcome to GDB Online.
+GDB online is an online compiler and debugger tool for C, C++, Python, Java, PHP, Ruby, Perl,
+C#, VB, Swift, Pascal, Fortran, Haskell, Objective-C, Assembly, HTML, CSS, JS, SQLite, Prolog.
+Code, Compile, Run and Debug online from anywhere in world.
+
+*******************************************************************************/
+import java.util.*;
+public class Main
+{
+	public static void main(String[] args) {
+		Scanner s  = new Scanner(System.in);
+		int t = s.nextInt();
+		while(t-- > 0){
+		    int n = s.nextInt();
+		    int[] arr = new int[n];
+		    for(int i=0;i<n;i++)
+		        arr[i] = s.nextInt();
+		    String str = s.next();
+		    List<Integer> left = new ArrayList<>();
+		    List<Integer> right = new ArrayList<>();
+		    for(int i=0;i<arr.length;i++){
+		        if(str.charAt(i) == 'B')
+		            left.add(arr[i]);
+		        else right.add(arr[i]);
+		    }
+		    Collections.sort(left);
+		    Collections.sort(right);
+		    boolean flag = false;
+		    for(int i=0;i<left.size();i++)
+		        if(left.get(i) < i+1){
+		            flag = true;
+		            break;
+		        }
+		    if(!flag){
+		        for(int i=0;i<right.size();i++)
+    		        if(right.get(i) > left.size()+i+1){
+    		            flag = true;
+    		            break;
+    		        }
+		    }
+		    if(flag)
+		        System.out.println(""NO"");
+		    else System.out.println(""YES"");
+		}
+	}
+}
+
+","import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Scanner;
+
+public class Simple{  
+    public static void main(String args[]){  
+        //System.out.println(""Hello Java"");
+        Scanner s = new Scanner(System.in);
+        int t = s.nextInt();
+        while (t>0){
+            
+            int n = s.nextInt();
+            int arr[] = new int[n];
+
+            for(int i=0;i<n;i++){
+                arr[i] = s.nextInt();
+            }
+            String str = s.next();
+
+            //Arrays.sort(arr);
+            ArrayList<Integer> blue = new ArrayList<>();
+            ArrayList<Integer> red = new ArrayList<>();
+            for(int i=0;i<n;i++){
+                if(str.charAt(i)=='R'){
+                    red.add(arr[i]);
+                }
+                else{
+                    blue.add(arr[i]);
+                }
+            }
+            Collections.sort(red);
+            Collections.sort(blue);
+            
+            int start =1;
+
+            boolean bool =true;
+            for(int i=0;i<blue.size();i++){
+                if(blue.get(i)<start){
+                    bool = false;
+                    break;
+                }
+
+                start++;
+            }
+            if(!bool){
+                System.out.println(""NO"");
+            }
+            else{
+                for(int i=0;i<red.size();i++){
+                    if(red.get(i)>start){
+                        bool = false;
+                        break;
+                    }
+                    start++;
+                }
+                if(bool){
+                    System.out.println(""YES"");
+                }
+                else{
+                    System.out.println(""NO"");
+                }
+            }
+            
+            
+
+
+            t--;
+        }
+        s.close();  
+    }
+    
+}  
+",0
+547ee69b,5ce1fe32,"import java.util.Arrays;
+import java.util.Scanner;
+
+public class Main {
+    public static void main(String[] args) {
+        Scanner in = new Scanner(System.in);
+        int n = in.nextInt();
+
+        int[] a = new int[n];
+
+        for(int i=0; i<n; i++) {
+            a[i] = in.nextInt();
+        }
+
+        System.out.println(getMinimumTime(a, n));
+    }
+
+    public static int getMinimumTime(int[] a, int n) {
+        int[][] minTime = new int[n][n];
+        int[] posOfPerson = new int[n];
+
+        int totalOccupied = 0;
+        for(int i=0; i<n; i++) {
+            if(a[i] == 1) {
+                posOfPerson[totalOccupied] = i;
+            }
+            totalOccupied += a[i];
+        }
+
+        for(int i=0; i<n; i++) {
+            Arrays.fill(minTime[i], 1, n, Integer.MAX_VALUE);
+        }
+
+        if(a[0] == 0) {
+            minTime[0][1] = Math.abs(0-posOfPerson[0]);
+        }
+
+        int unoccupiedPlaces = 1-a[0];
+        for(int i=1; i<n; i++) {
+            if(a[i] == 0) {
+                unoccupiedPlaces++;
+            }
+
+            for(int j=1; j<=Math.min(totalOccupied, unoccupiedPlaces); j++) {
+                if(a[i] == 1) {
+                    minTime[i][j] = minTime[i-1][j];
+                }
+                else if(j == unoccupiedPlaces) {
+                    minTime[i][j] = minTime[i-1][j-1] + Math.abs(i-posOfPerson[j-1]);
+                }
+                else {
+                    minTime[i][j] = Math.min(minTime[i-1][j], minTime[i-1][j-1] + Math.abs(i-posOfPerson[j-1]));
+                }
+            }
+        }
+
+        return minTime[n-1][totalOccupied];
+    }
+}
+","// Rohit Bohra | 16/05/2021 : 13:13:29
+import java.io.*;
+import java.util.*;
+
+@SuppressWarnings(""unchecked"")
+public class D{
+
+    static long[][] dp;
+    static List<Integer> seats,people;
+    static int n1,n2;
+
+    static long solve(int i,int j){
+        
+        if(i==n1) return 0;
+        long ans = Integer.MAX_VALUE;
+        if(n1-i>n2-j) return ans;
+        if(dp[i][j]!=-1) return dp[i][j];
+        
+        ans = min(solve(i,j+1),solve(i+1,j+1)+Math.abs(people.get(i)-seats.get(j)));
+        // out.printf(""%d %d : %ld"",i,j,ans);
+        return dp[i][j]=ans;
+    }
+
+    public static void main(String args[])throws IOException{
+
+        int n=sc.nextInt();
+        
+        seats = new ArrayList<>(n/2);
+        people = new ArrayList<>(n/2);
+
+        for(int i=1;i<=n;i++){
+            if(sc.nextInt()==0){
+                seats.add(i);
+            }else{
+                people.add(i);
+            }
+        }
+
+        n1=people.size();
+        n2=seats.size();
+
+        // if(n2==n){
+        //     out.println(0);
+            
+        // }
+
+        dp = new long[n1][n2]; 
+        for(int i=0;i<n1;i++)
+        Arrays.fill(dp[i],-1);
+
+        long ans =solve(0,0);
+        out.println(ans);
+
+        out.close();
+    }
+    
+
+    static int M=(int)Math.pow(10,9)+7;
+
+    public static void sort(int[] arr,boolean reverse){
+        ArrayList<Integer> list = new ArrayList<Integer>();
+        int n =arr.length;
+        for(int i=0;i<n;i++){
+            list.add(arr[i]);
+        }
+
+        if(reverse)
+        Collections.sort(list,Collections.reverseOrder());
+        else
+        Collections.sort(list);
+
+        for(int i=0;i<n;i++){
+            arr[i] = list.get(i);
+        }
+    }
+
+    public static double min(double ...a){
+        double min=Double.MAX_VALUE;
+        for(double i : a)
+        min =Math.min(i,min);
+        return min;
+    }
+
+    public static long min(long ...a){
+        long min=Long.MAX_VALUE;
+        for(long i : a)
+        min =Math.min(i,min);
+        return min;
+    }
+
+    public static int min(int ...a){
+        int min=Integer.MAX_VALUE;
+        for(int i : a)
+        min =Math.min(i,min);
+        return min;
+    }
+
+    public static double max(double ...a){
+        double max=Double.MIN_VALUE;
+        for(double i : a)
+        max =Math.max(i,max);
+        return max;
+    }
+
+    public static long max(long ...a){
+        long max=Long.MIN_VALUE;
+        for(long i : a)
+        max =Math.max(i,max);
+        return max;
+    }
+
+    public static int max(int ...a){
+        int max=Integer.MIN_VALUE;
+        for(int i : a)
+        max =Math.max(i,max);
+        return max;
+    }
+    static class Pair{
+
+        // Implementing equals() and hashCode()
+        // Map<Pair, V> map = //...
+
+        private final int x;
+        private final int y;
+
+        public Pair(int x, int y) {
+            this.x = x;
+            this.y = y;
+        }
+
+        @Override
+        public boolean equals(Object o) {
+            if (this == o) return true;
+            if (!(o instanceof Pair)) return false;
+            Pair pair = (Pair) o;
+            return x == pair.x && y == pair.y;
+        }
+
+        @Override
+        public int hashCode() {
+            int result = x;
+            result = 31 * result + y;
+            return result;
+        }
+    }
+
+    static FastScanner sc = new FastScanner();
+    static PrintWriter out =new PrintWriter(System.out);
+
+    static class FastScanner {
+            BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+            StringTokenizer st=new StringTokenizer("""");
+            String next() {
+                while (!st.hasMoreTokens())
+                    try {
+                        st=new StringTokenizer(br.readLine());
+                    } catch (IOException e) {
+                        e.printStackTrace();
+                    }
+                return st.nextToken();
+            }
+            
+            int nextInt() {
+                return Integer.parseInt(next());
+            }
+            int[] readArray(int n) {
+                int[] a=new int[n];
+                for (int i=0; i<n; i++) a[i]=nextInt();
+                return a;
+            }
+            long nextLong() {
+                return Long.parseLong(next());
+            }
+            public long[] readLongArray(int n) {
+                long[] a=new long[n];
+                for (int i=0; i<n; i++) a[i]=nextLong();
+                return a;
+            }
+    }
+}",0
+8ad1ad84,f652c678,"import java.io.*;
+import java.util.*;
+import java.math.*;
+import java.math.BigInteger; 
+//import javafx.util.*; 
+public final class B
+{    
+	 static PrintWriter out = new PrintWriter(System.out); 
+	static StringBuilder ans=new StringBuilder();
+	static FastReader in=new FastReader();
+	static ArrayList<Integer> g[];
+	static long mod=(long)(1e9+7);
+	static int D1[],D2[],par[];
+	static boolean set[];
+	static int value[];
+	static long INF=Long.MAX_VALUE;
+	static int N,M;
+	static long L[],R[],dp[][];
+	static int s=1;
+	public static void main(String args[])throws IOException
+	{  					
+		int T=i();
+		outer:while(T-->0)
+		{
+			int N=i();
+			setGraph(N);
+			for(int i=1; i<=N; i++)
+			{
+				L[i]=l();
+				R[i]=l();
+			}
+			for(int i=1; i<N; i++)
+			{
+				int a=i(),b=i();
+				g[a].add(b);
+				g[b].add(a);
+			}
+			f(1,-1);
+			out.println(Math.max(dp[0][1], dp[1][1]));
+		}
+		out.close();
+		//print(L);
+		//print(R);
+		
+		//print(dp[0]);
+		//print(dp[1]);
+		
+
+	}	
+	static void f(int n,int p)
+	{
+		for(int c:g[n])
+		{
+			if(c!=p)
+			{
+			f(c,n);
+			long a=dp[0][c]+Math.abs(L[c]-L[n]);
+			long b=dp[1][c]+Math.abs(R[c]-L[n]);
+			dp[0][n]+=Math.max(a, b);
+			a=dp[0][c]+Math.abs(L[c]-R[n]);
+			b=dp[1][c]+Math.abs(R[c]-R[n]);
+			dp[1][n]+=Math.max(a, b);
+			}
+		}
+	}
+	static boolean isPalin(char X[])
+	{
+		int l=0,r=X.length-1;
+		while(l<=r)
+		{
+			if(X[l]!=X[r])return false;
+			l++;
+			r--;
+		}
+		return true;
+	}
+
+	static boolean isSorted(int A[])
+	{
+		int N=A.length;
+		for(int i=0; i<N-1; i++)
+		{
+			if(A[i]>A[i+1])return false;
+		}
+
+		return true;		
+	}
+	static int f1(int x,ArrayList<Integer> A)
+	{
+		int l=-1,r=A.size();
+		while(r-l>1)
+		{
+			int m=(l+r)/2;
+			int a=A.get(m);
+			if(a<x)l=m;
+			else r=m;
+		}		
+		return l;
+	}
+
+
+	static int ask(int t,int i,int j,int x)
+	{
+		System.out.println(""? ""+t+"" ""+i+"" ""+j+"" ""+x);
+		return i();
+	}
+
+	static int ask(int a)
+	{
+		System.out.println(""? 1 ""+a);
+		return i();
+	}
+	static int f(int st,int end,int d)
+	{
+		if(st>end)return 0;
+		int a=0,b=0,c=0;
+		if(d>1)a=f(st+d-1,end,d-1);
+		b=f(st+d,end,d);
+		c=f(st+d+1,end,d+1);
+		return value[st]+max(a,b,c);
+	}
+	static int max(int a,int b,int c)
+	{
+		return Math.max(a, Math.max(c, b));
+	}
+	static int value(char X[],char Y[])
+	{
+		int c=0;
+		for(int i=0; i<7; i++)
+		{
+			if(Y[i]=='1' && X[i]=='0')return -1;
+			if(X[i]=='1' && Y[i]=='0')c++;
+		}
+		return c;
+	}
+	static boolean isValid(int i,int j)
+	{
+		if(i<0 || i>=N)return false;
+		if(j<0 || j>=M)return false;
+		return true;
+	}
+
+	static long fact(long N)
+	{
+		long num=1L;
+		while(N>=1)
+		{
+			num=((num%mod)*(N%mod))%mod;
+			N--;
+		}
+		return num;
+	}
+	static boolean reverse(long A[],int l,int r)
+	{
+		while(l<r)
+		{
+			long t=A[l];
+			A[l]=A[r];
+			A[r]=t;
+			l++;
+			r--;
+		}
+		if(isSorted(A))return true;
+		else return false;
+	}
+	static boolean isSorted(long A[])
+	{
+		for(int i=1; i<A.length; i++)if(A[i]<A[i-1])return false;
+		return true;
+	}
+	static boolean isPalindrome(char X[],int l,int r)
+	{
+		while(l<r)
+		{
+			if(X[l]!=X[r])return false;
+			l++; r--;
+		}
+		return true;
+	}
+
+	static long min(long a,long b,long c)
+	{
+		return Math.min(a, Math.min(c, b));
+	}
+
+	static void print(int a)
+	{
+		System.out.println(""! ""+a);
+	}
+	static int ask(int a,int b)
+	{
+		System.out.println(""? ""+a+"" ""+b);
+		return i();
+	}
+	static int find(int a)
+	{
+		if(par[a]<0)return a;
+		return par[a]=find(par[a]);
+	}
+	static void union(int a,int b)
+	{
+		a=find(a);
+		b=find(b);
+		if(a!=b)
+		{
+			par[a]+=par[b]; //transfers the size
+			par[b]=a;       //changes the parent
+		}
+	}
+	static void swap(char A[],int a,int b)
+	{
+		char ch=A[a];
+		A[a]=A[b];
+		A[b]=ch;
+	}
+
+	static void sort(long[] a) //check for long
+	{
+		ArrayList<Long> l=new ArrayList<>();
+		for (long i:a) l.add(i);
+		Collections.sort(l);
+		for (int i=0; i<a.length; i++) a[i]=l.get(i);
+	}
+	static void setGraph(int N)
+	{
+		g=new ArrayList[N+1];
+		dp=new long[2][N+1];
+		L=new long[N+1];
+		R=new long[N+1];
+		for(int i=0; i<=N; i++)
+		{
+
+			g[i]=new ArrayList<Integer>();
+		}
+	}
+
+	static  long pow(long a,long b)
+	{
+		long mod=1000000007;
+		long pow=1;
+		long x=a;
+		while(b!=0)
+		{
+			if((b&1)!=0)pow=(pow*x)%mod;
+			x=(x*x)%mod;
+			b/=2;
+		}
+		return pow;
+	}
+	static long toggleBits(long x)//one's complement || Toggle bits
+	{
+		int n=(int)(Math.floor(Math.log(x)/Math.log(2)))+1;
+
+		return ((1<<n)-1)^x;
+	}
+	static int countBits(long a)
+	{
+		return (int)(Math.log(a)/Math.log(2)+1);
+	}
+	static void sort(int[] a) {
+		ArrayList<Integer> l=new ArrayList<>();
+		for (int i:a) l.add(i);
+		Collections.sort(l);
+		for (int i=0; i<a.length; i++) a[i]=l.get(i);
+	}
+	static boolean isPrime(long N)
+	{
+		if (N<=1)  return false; 
+		if (N<=3)  return true; 
+		if (N%2 == 0 || N%3 == 0) return false; 
+		for (int i=5; i*i<=N; i=i+6) 
+			if (N%i == 0 || N%(i+2) == 0) 
+				return false; 
+		return true; 
+	}
+	static long GCD(long a,long b) 
+	{
+		if(b==0)
+		{
+			return a;
+		}
+		else return GCD(b,a%b );
+	}
+
+	//Debugging Functions Starts
+
+	static void print(char A[])
+	{
+		for(char c:A)System.out.print(c+"" "");
+		System.out.println();
+	}
+	static void print(boolean A[])
+	{
+		for(boolean c:A)System.out.print(c+"" "");
+		System.out.println();
+	}
+	static void print(int A[])
+	{
+		for(int a:A)System.out.print(a+"" "");
+		System.out.println();	
+	}
+	static void print(long A[])
+	{
+		for(long i:A)System.out.print(i+ "" "");
+		System.out.println();
+
+	}
+	static void print(ArrayList<Integer> A)
+	{
+		for(int a:A)System.out.print(a+"" "");
+		System.out.println();
+	}
+
+	//Debugging Functions END
+	//----------------------
+	//IO FUNCTIONS STARTS
+	static HashMap<Integer,Integer> Hash(int A[])
+	{
+		HashMap<Integer,Integer> mp=new HashMap<>();
+		for(int a:A)
+		{
+			int f=mp.getOrDefault(a,0)+1;
+			mp.put(a, f);
+		}
+		return mp;
+	}
+	static int i()
+	{
+		return in.nextInt();
+	}
+
+	static long l()
+	{
+		return in.nextLong();
+	}
+
+	static int[] input(int N){
+		int A[]=new int[N];
+		for(int i=0; i<N; i++)
+		{
+			A[i]=in.nextInt();
+		}
+		return A;
+	}
+
+	static long[] inputLong(int N)     {
+		long A[]=new long[N];
+		for(int i=0; i<A.length; i++)A[i]=in.nextLong();
+		return A;
+	}
+
+	//IO FUNCTIONS END
+
+}
+
+class node implements Comparable<node>
+{
+	int x,index; boolean right;
+	node(int x,boolean right,int index)
+	{
+		this.x=x;
+		this.right=right;
+		this.index=index;
+	}
+	public int compareTo(node X)
+	{
+		return this.x-X.x;
+	}
+}
+
+//Code For FastReader
+//Code For FastReader
+//Code For FastReader
+//Code For FastReader
+class FastReader
+{
+	BufferedReader br;
+	StringTokenizer st;
+	public FastReader()
+	{
+		br=new BufferedReader(new InputStreamReader(System.in));
+	}
+
+	String next()
+	{
+		while(st==null || !st.hasMoreElements())
+		{
+			try
+			{
+				st=new StringTokenizer(br.readLine());
+			}
+			catch(IOException e)
+			{
+				e.printStackTrace();
+			}
+		}
+		return st.nextToken();
+	}
+
+	int nextInt()
+	{
+		return Integer.parseInt(next());
+	}
+
+	long nextLong()
+	{
+		return Long.parseLong(next());
+	}
+	//gey
+	double nextDouble()
+	{
+		return Double.parseDouble(next());
+	}
+
+	String nextLine()
+	{
+		String str="""";
+		try
+		{
+			str=br.readLine();
+		}
+		catch (IOException e)
+		{
+			e.printStackTrace();
+		}
+		return str;
+	}
+
+}","import java.io.*;
+import java.text.DecimalFormat;
+import java.util.*;
+
+public class C {
+    static long mod = (long) 1e9 + 7;
+    static long mod1 = 998244353;
+    static ArrayList<Integer>[] adj;
+    static HashMap<String,Long> hmap;
+    public static void main(String[] args) {
+        InputStream inputStream = System.in;
+        OutputStream outputStream = System.out;
+        InputReader in = new InputReader(inputStream);
+        PrintWriter out = new PrintWriter(outputStream);
+
+
+        int t = in.nextInt();
+        while (t-- > 0) {
+
+            int n = in.nextInt();
+            adj = new ArrayList[n + 1];
+            for (int i = 0; i <= n; i++)
+                adj[i] = new ArrayList<>();
+            long[][] dp = new long[n + 1][2];
+            hmap=new HashMap<>();
+            for (int i = 1; i <= n; i++) {
+                dp[i][0] = in.nextLong();
+                dp[i][1] = in.nextLong();
+            }
+            for (int i = 0; i < n - 1; i++) {
+                int u = in.nextInt();
+                int v = in.nextInt();
+                adj[u].add(v);
+                adj[v].add(u);
+            }
+            long[] x=DFS(dp,1,-1);
+            out.println(Math.max(x[0],x[1]));
+        }
+        out.close();
+    }
+
+    static long[] DFS(long[][] dp,int s,int prev) {
+
+        long max=0;
+        long min=0;
+        for (int i : adj[s]) {
+            if (i != prev) {
+                long[] dd=DFS(dp,i,s);
+                min+=Math.max(Math.abs(dp[s][0]-dp[i][0])+dd[0],Math.abs(dp[s][0]-dp[i][1])+dd[1]);
+                max+=Math.max(Math.abs(dp[s][1]-dp[i][0])+dd[0],Math.abs(dp[s][1]-dp[i][1])+dd[1]);
+            }
+        }
+        return new long[] {min,max};
+
+    }
+
+
+    static final Random random = new Random();
+
+    static void ruffleSort(int[] a) {
+        int n = a.length;//shuffle, then sort
+        for (int i = 0; i < n; i++) {
+            int oi = random.nextInt(n), temp = a[oi];
+            a[oi] = a[i];
+            a[i] = temp;
+        }
+        Arrays.sort(a);
+    }
+
+    static long gcd(long x, long y) {
+        if (x == 0)
+            return y;
+        if (y == 0)
+            return x;
+        long r = 0, a, b;
+        a = Math.max(x, y);
+        b = Math.min(x, y);
+        r = b;
+        while (a % b != 0) {
+            r = a % b;
+            a = b;
+            b = r;
+        }
+        return r;
+    }
+
+    static long modulo(long a, long b, long c) {
+        long x = 1, y = a % c;
+        while (b > 0) {
+            if (b % 2 == 1)
+                x = (x * y) % c;
+            y = (y * y) % c;
+            b = b >> 1;
+        }
+        return x % c;
+    }
+
+    public static void debug(Object... o) {
+        System.err.println(Arrays.deepToString(o));
+    }
+
+    static int upper_bound(int[] arr, int n, int x) {
+        int mid;
+        int low = 0;
+        int high = n;
+        while (low < high) {
+            mid = low + (high - low) / 2;
+            if (x >= arr[mid])
+                low = mid + 1;
+            else
+                high = mid;
+        }
+        return low;
+    }
+
+    static int lower_bound(int[] arr, int n, int x) {
+        int mid;
+        int low = 0;
+        int high = n;
+        while (low < high) {
+            mid = low + (high - low) / 2;
+            if (x <= arr[mid])
+                high = mid;
+            else
+                low = mid + 1;
+        }
+        return low;
+    }
+
+    static String printPrecision(double d) {
+        DecimalFormat ft = new DecimalFormat(""0.00000000000"");
+        return String.valueOf(ft.format(d));
+    }
+
+    static int countBit(long mask) {
+        int ans = 0;
+        while (mask != 0) {
+            mask &= (mask - 1);
+            ans++;
+        }
+        return ans;
+    }
+
+    static class InputReader {
+        public BufferedReader reader;
+        public StringTokenizer tokenizer;
+
+        public InputReader(InputStream stream) {
+            reader = new BufferedReader(new InputStreamReader(stream), 32768);
+            tokenizer = null;
+        }
+
+        public String next() {
+            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
+                try {
+                    tokenizer = new StringTokenizer(reader.readLine());
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+            }
+            return tokenizer.nextToken();
+        }
+
+        public int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        public long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        public double nextDouble() {
+            return Double.parseDouble(next());
+        }
+
+        public int[] readArray(int n) {
+            int[] arr = new int[n];
+            for (int i = 0; i < n; i++) arr[i] = nextInt();
+            return arr;
+        }
+    }
+}",0
+99bc7da3,b3638571,"import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.util.*;
+ 
+ 
+public class Codeforces {
+	
+	static int mod =1000000007; 
+	static Set<Integer> set;
+	public static void main(String[] args) throws Exception {
+		PrintWriter out=new PrintWriter(System.out);
+	    FastScanner fs=new FastScanner();
+	    int t=fs.nextInt();
+	    while(t-->0) {
+	    	int n=fs.nextInt();
+	    	int arr[]=new int[n];
+//	    	set=new HashSet<>();
+	    	for(int i=0;i<n;i++) {
+	    		arr[i]=Math.abs(fs.nextInt());
+//	    		set.add(arr[i]);
+	    	}
+//	    	sort(arr);
+//	    	for(int i=0;i<n;i++) System.out.print(arr[i]+"" "");
+//	    	System.out.println();
+//	    	if(set.size()<n||set.contains(0)) {
+//	    		System.out.println(""YES"");
+//	    		continue;
+//	    	}
+	    	boolean f=false;
+	    	for(int i=0;i<n;i++) {
+	    		boolean cur=recur(0,i,arr,0);
+	    		if(cur) {
+	    			f=true;
+	    			break;
+	    		}
+	    	}
+	    	if(f) System.out.println(""YES"");
+	    	else System.out.println(""NO"");
+	    }
+	    out.close();
+	}
+	static boolean recur(int pos,int ind,int arr[],int sum) {
+		if(pos==ind) return recur(pos+1,ind,arr,sum);
+		if(sum==arr[ind]) return true;
+		if(pos==arr.length) {
+			return false;
+		}
+		
+		if(recur(pos+1,ind,arr,sum+arr[pos])) return true;
+		if(recur(pos+1,ind,arr,sum)) return true;
+		if(recur(pos+1,ind,arr,sum-arr[pos])) return true;
+		return false;
+	}
+	static long gcd(long  a,long  b) {
+		if(b==0) return a;
+		return gcd(b,a%b);
+	}
+	static long nck(int n,int k) {
+		if(k>n) return 0;
+		long res=1;
+		res*=fact(n);
+		res%=mod;
+		res*=modInv(fact(k));
+		res%=mod;
+		res*=modInv(fact(n-k)); 
+		res%=mod;
+		return res;
+	}
+	static long fact(long n) {
+		long res=1;
+		for(int i=2;i<=n;i++) {
+			res*=i;
+			res%=mod;
+		}
+		return res;
+	}
+	static long pow(long a,long b) {
+		long res=1;
+		while(b!=0) {
+			if((b&1)!=0) {
+				res*=a;
+				res%=mod;
+			}
+			a*=a;
+			a%=mod;
+			b=b>>1;
+		}
+		return res;
+	}
+	static long modInv(long n) {
+		return pow(n,mod-2);
+	}
+	
+	static void sort(int[] a) {
+		//suffle
+		int n=a.length;
+		Random r=new Random();
+		for (int i=0; i<a.length; i++) {
+			int oi=r.nextInt(n);
+			int temp=a[i];
+			a[i]=a[oi];
+			a[oi]=temp;
+		}
+		
+		//then sort
+		Arrays.sort(a);
+	}
+	
+	// Use this to input code since it is faster than a Scanner
+	static class FastScanner {
+		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st=new StringTokenizer("""");
+		String next() {
+			while (!st.hasMoreTokens())
+				try {
+					st=new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			return st.nextToken();
+		}
+		
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+		int[] readArray(int n) {
+			int[] a=new int[n];
+			for (int i=0; i<n; i++) a[i]=nextInt();
+			return a;
+		}
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+	}
+ 
+}","import java.io.*;
+import java.util.*;
+
+public class Main {
+
+    public static void main(String[] args) {
+        MyScanner scan = new MyScanner();
+        out = new PrintWriter(new BufferedOutputStream(System.out));
+
+        int t = scan.nextInt();
+        for (int i = 0; i < t; i++) {
+            int num = scan.nextInt();
+            int[] sequence = new int[num];
+            for (int j = 0; j < num; j++) {
+                sequence[j] = scan.nextInt();
+            }
+
+            int[] setSum = new int[(int) Math.pow(3, num)];
+
+            for (int k = 0; k < num; k++) {
+                int pot =(int)Math.pow(3, k);
+                
+                for (int j = 1; j < setSum.length; j++) {
+                    if(j % (pot*3) >= pot ){
+                        if(j % (pot*3) >= pot){
+                            if(j % (pot*3) >= pot*2){
+                                setSum[j] += sequence[k];
+                            }else{
+                                setSum[j] -= sequence[k];
+                            }
+                        }
+
+                    }
+                }
+            }
+            String output = ""NO"";
+            for (int j = 1; j < setSum.length; j++) {
+                if(setSum[j] == 0){
+                    output = ""YES"";
+                    break;
+                }
+            }
+            out.println(output);
+        }
+        out.close();
+    }
+
+    public static PrintWriter out;
+    public static class MyScanner { BufferedReader br; StringTokenizer st;
+
+        public MyScanner() {
+            br = new BufferedReader(new InputStreamReader(System.in));
+        }
+
+        String next() {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+
+        String nextLine(){
+            String str = """";
+            try {
+                str = br.readLine();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+        }
+    }
+}",0
+2da4b3fe,3d06b643,"
+import java.util.*;
+import java.lang.*;
+import java.io.*;
+
+public class Codeforces {
+	public static class FastReader {  
+        BufferedReader br;
+        StringTokenizer st;
+ 
+        public FastReader()
+        {
+            br = new BufferedReader(
+                new InputStreamReader(System.in));
+        }
+ 
+        String next()
+        {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                }
+                catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+ 
+        int nextInt() { return Integer.parseInt(next()); }
+ 
+        long nextLong() { return Long.parseLong(next()); }
+ 
+        double nextDouble()
+        {
+            return Double.parseDouble(next());
+        }
+ 
+        String nextLine()
+        {
+            String str = """";
+            try {
+                str = br.readLine();
+            }
+            catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+        }
+    }
+	public static void main (String[] args) throws java.lang.Exception
+	{
+		// your code goes here
+		FastReader sc=new FastReader();
+		int n=sc.nextInt();
+		int a[]=new int[n];
+		ArrayList<Integer> arr0=new ArrayList<>();
+		ArrayList<Integer> arr1=new ArrayList<>();
+		for(int i=0;i<n;i++)
+		{
+		    a[i]=sc.nextInt();
+		    if(a[i]==0)
+		    arr0.add(i);
+		    else
+		    arr1.add(i);
+		}
+		n=arr0.size();
+		int m=arr1.size();
+		int dp[][]=new int[m+1][n+1];
+		for(int i=0;i<=n;i++)
+		{
+		    dp[0][i]=0;
+		}
+		for(int i=1;i<=m;i++)
+		{
+		    dp[i][i]=dp[i-1][i-1]+Math.abs(arr0.get(i-1)-arr1.get(i-1));
+		    for(int j=i+1;j<=n;j++)
+		    {
+		        dp[i][j]=Math.min(dp[i-1][j-1]+Math.abs(arr0.get(j-1)-arr1.get(i-1)),dp[i][j-1]);
+		    }
+		}
+		System.out.println(dp[m][n]);
+	}
+}
+
+
+
+
+
+
+
+
+
+
+
+","import java.io.*;
+import java.util.*;
+
+public class ArmChairs {
+    
+
+    public static int solution(int n, int[] arr) {
+
+        ArrayList<Integer> one = new ArrayList<Integer>();
+        ArrayList<Integer> zero = new ArrayList<Integer>();
+
+        for (int i = 0; i < n; i++) {
+            if (arr[i] == 1) {
+                one.add(i);
+            } else {
+                zero.add(i);
+            }
+        }
+
+        int[][] dp = new int[one.size() + 1][zero.size() + 1];
+
+        for (int i = 1; i <= one.size(); i++) {
+            dp[i][i] = dp[i - 1][i - 1] + Math.abs(one.get(i - 1) - zero.get(i - 1));
+            for (int j = i + 1; j <= zero.size(); j++) {
+                dp[i][j] = Math.min(dp[i][j - 1], dp[i - 1][j - 1] + Math.abs(one.get(i - 1) - zero.get(j - 1)));
+            }
+        }
+
+        return dp[one.size()][zero.size()];
+    }
+
+
+    public static void main(String[] args) throws IOException{
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        BufferedWriter log = new BufferedWriter(new OutputStreamWriter(System.out));
+
+        int n = Integer.parseInt(br.readLine());
+
+        String[] s = br.readLine().split("" "");
+        int[] arr = new int[n];
+        for (int i = 0; i < n; i++) {
+            arr[i] = Integer.parseInt(s[i]);
+        } 
+
+        log.write(Integer.toString(solution(n, arr)) + ""\n"");
+        log.flush();
+        
+    }
+
+}
+",1
+9862c742,cf27732e,"/******************************************************************************
+
+Welcome to GDB Online.
+GDB online is an online compiler and debugger tool for C, C++, Python, Java, PHP, Ruby, Perl,
+C#, VB, Swift, Pascal, Fortran, Haskell, Objective-C, Assembly, HTML, CSS, JS, SQLite, Prolog.
+Code, Compile, Run and Debug online from anywhere in world.
+
+*******************************************************************************/
+import java.util.*;
+public class Main
+{
+	public static void main(String[] args) {
+		Scanner s  = new Scanner(System.in);
+		int t = s.nextInt();
+		while(t-- > 0){
+		    int n = s.nextInt();
+		    int[] arr = new int[n];
+		    for(int i=0;i<n;i++)
+		        arr[i] = s.nextInt();
+		    String str = s.next();
+		    List<Integer> left = new ArrayList<>();
+		    List<Integer> right = new ArrayList<>();
+		    for(int i=0;i<arr.length;i++){
+		        if(str.charAt(i) == 'B')
+		            left.add(arr[i]);
+		        else right.add(arr[i]);
+		    }
+		    Collections.sort(left);
+		    Collections.sort(right);
+		    boolean flag = false;
+		    for(int i=0;i<left.size();i++)
+		        if(left.get(i) < i+1){
+		            flag = true;
+		            break;
+		        }
+		    if(!flag){
+		        for(int i=0;i<right.size();i++)
+    		        if(right.get(i) > left.size()+i+1){
+    		            flag = true;
+    		            break;
+    		        }
+		    }
+		    if(flag)
+		        System.out.println(""NO"");
+		    else System.out.println(""YES"");
+		}
+	}
+}
+
+","import java.util.*;
+
+
+
+import java.io.*;
+
+public class code  {
+	// remember long, to reformat ctrl + shift +f
+	static Scanner sc = new Scanner(System.in);
+	static PrintWriter pw = new PrintWriter(System.out);
+ 
+	  
+ 
+	public static void main(String[] args) throws Exception {
+
+		int t=sc.nextInt();
+		while(t-->0) {
+            int n=sc.nextInt();
+            int []vals=new int[n];
+            boolean numLine[]=new boolean[n+1];
+
+            for(int i=0;i<n;i++)vals[i]=sc.nextInt();
+            String s=sc.nextLine();
+            ArrayList<Integer>b=new ArrayList<Integer>();
+            ArrayList<Integer>r=new ArrayList<Integer>();
+            for(int i=0;i<n;i++) {
+            	if(s.charAt(i)=='B' && vals[i]>0 )b.add(vals[i]);
+            	else if( s.charAt(i)=='R' && vals[i]<=n)r.add(vals[i]);
+            }
+          Collections.sort(b);
+          Collections.sort(r);
+          int small=1;
+          for(int i=0;i<b.size();i++) {
+        	  
+        	  int y=b.get(i);
+        	  if(y<small)continue;
+        	  numLine[small]=true;
+        	  small++;
+          }
+         // pw.println(Arrays.toString(numLine));
+          int large=n;
+          for(int i=r.size()-1;i>=0;i--) {
+        	  
+        	  int y=r.get(i);
+        	  if(y>large)continue;
+        	 // y=Math.max(large, y);
+        	  numLine[large]=true;
+        	  large--;
+          }
+          //pw.print(Arrays.toString(numLine));
+          boolean can=true;
+          for(int i=1;i<=n;i++) {
+        	  if(numLine[i]==false) {
+        		  pw.println(""no"");
+        		  can=false;
+        		  break;
+        	  }
+        	  
+          }
+          if(can)pw.println(""yes"");
+          
+           
+            	
+            	
+            
+
+			
+		}
+		
+	 pw.close();
+
+	}
+
+	// --------------------stuff ----------------------
+	static class pair implements Comparable<pair> {
+		int v;
+		int w;
+        
+		public pair(int v,int  w) {
+			this.v = v;
+			this.w = w;
+			
+		}
+
+		public int compareTo(pair p) {
+			return this.w- p.w;// increasing order!!
+		
+			//return Double.compare(v*w, p.w*p.v);
+		
+		}
+	}
+
+	static class Scanner {
+		StringTokenizer st;
+		BufferedReader br;
+
+		public Scanner(InputStream s) {
+			br = new BufferedReader(new InputStreamReader(s));
+		}
+
+		public Scanner(FileReader r) {
+			br = new BufferedReader(r);
+		}
+
+		public String next() throws IOException {
+			while (st == null || !st.hasMoreTokens())
+				st = new StringTokenizer(br.readLine());
+			return st.nextToken();
+		}
+
+		public int nextInt() throws IOException {
+			return Integer.parseInt(next());
+		}
+
+		public long nextLong() throws IOException {
+			return Long.parseLong(next());
+		}
+
+		public String nextLine() throws IOException {
+			return br.readLine();
+		}
+
+		public double nextDouble() throws IOException {
+			String x = next();
+			StringBuilder sb = new StringBuilder(""0"");
+			double res = 0, f = 1;
+			boolean dec = false, neg = false;
+			int start = 0;
+			if (x.charAt(0) == '-') {
+				neg = true;
+				start++;
+			}
+			for (int i = start; i < x.length(); i++)
+				if (x.charAt(i) == '.') {
+					res = Long.parseLong(sb.toString());
+					sb = new StringBuilder(""0"");
+					dec = true;
+				} else {
+					sb.append(x.charAt(i));
+					if (dec)
+						f *= 10;
+				}
+			res += Long.parseLong(sb.toString()) / f;
+			return res * (neg ? -1 : 1);
+		}
+
+		public long[] nextlongArray(int n) throws IOException {
+			long[] a = new long[n];
+			for (int i = 0; i < n; i++)
+				a[i] = nextLong();
+			return a;
+		}
+
+		public Long[] nextLongArray(int n) throws IOException {
+			Long[] a = new Long[n];
+			for (int i = 0; i < n; i++)
+				a[i] = nextLong();
+			return a;
+		}
+
+		public int[] nextIntArray(int n) throws IOException {
+			int[] a = new int[n];
+			for (int i = 0; i < n; i++)
+				a[i] = nextInt();
+			return a;
+		}
+
+		public Integer[] nextIntegerArray(int n) throws IOException {
+			Integer[] a = new Integer[n];
+			for (int i = 0; i < n; i++)
+				a[i] = nextInt();
+			return a;
+		}
+
+		public boolean ready() throws IOException {
+			return br.ready();
+		}
+	}
+
+}",0
+3ff25f43,c287ea9d,"import java.io.BufferedInputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+
+public class EDU121C {
+    public static void main(String[] args) {
+        JS scan = new JS();
+        int t = scan.nextInt();
+        while(t-->0){
+            int n = scan.nextInt();
+            long[] k = new long[n];
+            long[] h = new long[n];
+            for(int i =0;i<n;i++){
+                k[i] = scan.nextInt();
+            }
+            for(int i = 0;i<n;i++){
+                h[i] = scan.nextInt();
+            }
+            long ans = 0;
+            long lastD = 0;
+            long lastHP = 0;
+            for(int i = 0;i<n;i++){
+                long dist = k[i]-lastD;
+                long lo = h[i];
+                long hi = lastHP+dist;
+                long hpComingOut = 0;
+                while(lo<=hi){
+                    long mid = (lo+hi)/2;
+                    boolean check = false;
+                    for(int j = i+1;j<n;j++){
+                        if(k[j]-k[i]<h[j]-mid){
+                            check = true;
+                            break;
+                        }
+                    }
+                    if(check){
+                        //we're in trouble
+                        lo = mid+1;
+                    }else{
+                        hi = mid-1;
+                        hpComingOut = mid;
+                    }
+                }
+                if(hpComingOut>dist){
+                    ans+=summ(dist+lastHP)-summ(lastHP);
+                    lastHP+=dist;
+                }else{
+                    long diff = dist-hpComingOut;
+                    ans+=summ(hpComingOut);
+                    lastHP = hpComingOut;
+                }
+                lastD = k[i];
+            }
+            System.out.println(ans);
+        }
+    }
+    static long summ(long a){
+        return (a*(a+1))/2;
+    }
+    static class JS {
+        public int BS = 1 << 16;
+        public char NC = (char) 0;
+        byte[] buf = new byte[BS];
+        int bId = 0, size = 0;
+        char c = NC;
+        double num = 1;
+        BufferedInputStream in;
+
+        public JS() {
+            in = new BufferedInputStream(System.in, BS);
+        }
+
+        public JS(String s) throws FileNotFoundException {
+            in = new BufferedInputStream(new FileInputStream(new File(s)), BS);
+        }
+
+        public char nextChar() {
+            while (bId == size) {
+                try {
+                    size = in.read(buf);
+                } catch (Exception e) {
+                    return NC;
+                }
+                if (size == -1) return NC;
+                bId = 0;
+            }
+            return (char) buf[bId++];
+        }
+
+        public int nextInt() {
+            return (int) nextLong();
+        }
+
+        public long nextLong() {
+            num = 1;
+            boolean neg = false;
+            if (c == NC) c = nextChar();
+            for (; (c < '0' || c > '9'); c = nextChar()) {
+                if (c == '-') neg = true;
+            }
+            long res = 0;
+            for (; c >= '0' && c <= '9'; c = nextChar()) {
+                res = (res << 3) + (res << 1) + c - '0';
+                num *= 10;
+            }
+            return neg ? -res : res;
+        }
+
+        public double nextDouble() {
+            double cur = nextLong();
+            return c != '.' ? cur : cur + nextLong() / num;
+        }
+
+        public String next() {
+            StringBuilder res = new StringBuilder();
+            while (c <= 32) c = nextChar();
+            while (c > 32) {
+                res.append(c);
+                c = nextChar();
+            }
+            return res.toString();
+        }
+
+        public String nextLine() {
+            StringBuilder res = new StringBuilder();
+            while (c <= 32) c = nextChar();
+            while (c != '\n') {
+                res.append(c);
+                c = nextChar();
+            }
+            return res.toString();
+        }
+
+        public boolean hasNext() {
+            if (c > 32) return true;
+            while (true) {
+                c = nextChar();
+                if (c == NC) return false;
+                else if (c > 32) return true;
+            }
+        }
+    }
+}
+","import java.util.*;
+import java.io.*;
+
+public class monstersandspells {
+	public static void main(String args[]) throws IOException {
+		FastScanner in = new FastScanner(System.in);
+		PrintWriter out = new PrintWriter(System.out);
+		/*
+1
+5
+1 5 8 9 10
+1 2 6 1 2
+		 */
+		int t = in.nextInt();
+		
+		for ( ; t > 0; t--) {
+			
+			int n = in.nextInt();
+			
+			long[] times = new long[n];
+			long[] health = new long[n];
+			for (int i = 0; i < n; i++)
+				times[i] = in.nextLong();
+			for (int i = 0; i < n; i++)
+				health[i] = in.nextLong();
+			
+			long small = 0;
+			long prev = 0;
+			long lastDamage = 0;
+			
+			for (int i = 0; i < n; i++) {
+				long diff = times[i] - prev;
+				boolean use = true;
+				long delta = 0;
+				//System.out.println(i + "" "" + times[i] + "" "" + diff);
+				if (diff >= health[i]) {
+					delta += health[i];
+					long curr = health[i];
+					long lastTime = times[i];
+					for (int j = i + 1; j < n; j++) {
+						long increase = times[j] - lastTime;
+						//long power = damageOverTime(increase + curr, curr + 1);
+						if (curr + increase >= health[j]) {
+							curr += increase;
+							lastTime = times[j];
+						}
+						else {
+							delta += (health[j] - (curr + increase));
+							curr = health[j];
+							lastTime = times[j];
+						}
+					}
+					if (delta <= diff) {
+						use = true;
+					}
+					else
+						use = false;
+				}
+				else
+					use = false;
+				
+				if (use) {
+					//System.out.println(damageOverTime(health[i], 1));
+					small += damageOverTime(delta, 1);
+					lastDamage = delta;
+				}
+				else {
+					small += damageOverTime((times[i] - prev) + lastDamage, lastDamage + 1);
+					lastDamage+=(times[i] - prev);
+				}
+				// System.out.println(use + "" "" + delta + "" "" + lastDamage + "" "" + small);
+				prev = times[i];
+			}
+			
+			out.println(small);
+		}
+		
+		out.close();
+	}
+	
+	public static long damageOverTime(long endPower, long startPower) {
+		return triangleSum(endPower) - triangleSum(startPower - 1);
+	}
+	
+	public static long triangleSum(long a) {
+		return a * (a + 1) / 2;
+	}
+	
+	static class FastScanner {
+		BufferedReader br;
+		StringTokenizer st;
+
+		public FastScanner(InputStream i) {
+			br = new BufferedReader(new InputStreamReader(i));
+			st = new StringTokenizer("""");
+		}
+
+		public String next() throws IOException {
+			if (st.hasMoreTokens())
+				return st.nextToken();
+			else
+				st = new StringTokenizer(br.readLine());
+			return next();
+		}
+
+		public int nextInt() throws IOException {
+			return Integer.parseInt(next());
+		}
+
+		public long nextLong() throws IOException {
+			return Long.parseLong(next());
+		}
+
+		public double nextDouble() throws IOException {
+			return Double.parseDouble(next());
+		}
+	}
+}
+",0
+4fd752f7,c7239c97,"/*==========================================================================*/
+/*
+*		AUTHOR:    RonWonWon    
+*		CREATED:   02.05.2021 20:16:37
+*		EMAIL:     rachitpts.2454@gmail.com                                  
+*/
+/*==========================================================================*/
+import java.io.*;
+import java.util.*;
+
+public class C {
+	
+	public static void main(String[] args) {
+        FastScanner in = new FastScanner();
+        PrintWriter out = new PrintWriter(System.out);
+        int t = in.nextInt(), tt = 0;
+        while(t-->0) { 
+        	int n = in.nextInt(), m = in.nextInt(), x = in.nextInt();
+        	int aa[] = in.readArray(n);
+        	Pair a[] = new Pair[n];
+        	for(int i=0;i<n;i++) a[i] = new Pair(i,aa[i]);
+        	PriorityQueue<Pair> pq = new PriorityQueue<>();
+        	Arrays.sort(a);
+        	int goneTo[] = new int[n];
+        	for(int i=0;i<m;i++){
+        		pq.add(new Pair(i+1,a[n-1-i].y));
+        		goneTo[a[n-1-i].x] = i+1;
+        	}
+        	for(int i=n-m-1;i>=0;i--){
+        		Pair xx = pq.poll();
+        		xx.y += a[i].y;
+        		goneTo[a[i].x] = xx.x;
+        		pq.add(new Pair(xx.x,xx.y));
+        	}
+        	Iterator<Pair> it = pq.iterator();
+        	ArrayList<Pair> arr = new ArrayList<>();
+        	while(it.hasNext()) arr.add(it.next());
+        	Collections.sort(arr);
+        	//for(Pair i : arr) out.print(i.y+"" "");
+        	//out.println();
+        	if(arr.get(m-1).y-arr.get(0).y>x) out.println(""NO"");
+        	else{
+        		out.println(""YES"");
+        		int pos[] = new int[n];
+        		for(Pair i : a) pos[i.x] = goneTo[i.x];
+        		for(int i : pos) out.print(i+"" "");
+        		out.println();
+        	}
+    		//tt++; out.println(""Case #""+tt+"": ""+ans);
+        }
+        out.flush();
+}
+
+static class Pair implements Comparable<Pair> {
+		int x, y;
+		Pair(int a, int b){ x = a; y = b; }		
+		@Override
+		public int compareTo(Pair o) {
+			if(o.y - this.y>0)
+				return -1;
+			else if(o.y - this.y<0)
+				return 1;
+			else 
+				return 0;
+		}
+		}	
+
+	
+	static class FastScanner {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st = new StringTokenizer("""");
+		
+		String next() {
+			while(!st.hasMoreTokens())
+				try { st = new StringTokenizer(br.readLine()); }
+				catch(IOException e) {}
+			return st.nextToken();
+		}
+		
+		String nextLine(){
+			try{ return br.readLine(); } 
+			catch(IOException e) { } return """";
+		}
+		
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+		
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+		
+		int[] readArray(int n) {
+			int a[] = new int[n];
+			for(int i=0;i<n;i++) a[i] = nextInt();
+			return a;
+		}
+	}
+
+	static final Random random = new Random();
+
+	static void ruffleSort(int[] a){
+		int n = a.length;
+		for(int i=0;i<n;i++){
+			int j = random.nextInt(n), temp = a[j];
+			a[j] = a[i]; a[i] = temp;
+		}
+		Arrays.sort(a); 	
+	}
+}
+
+","/*==========================================================================*/
+/*
+*		AUTHOR:    RonWonWon    
+*		CREATED:   02.05.2021 20:16:37
+*		EMAIL:     rachitpts.2454@gmail.com                                  
+*/
+/*==========================================================================*/
+import java.io.*;
+import java.util.*;
+
+public class C {
+	
+	public static void main(String[] args) {
+        FastScanner in = new FastScanner();
+        PrintWriter out = new PrintWriter(System.out);
+        int t = in.nextInt(), tt = 0;
+        while(t-->0) { 
+        	int n = in.nextInt(), m = in.nextInt(), x = in.nextInt();
+        	int aa[] = in.readArray(n);
+        	Pair a[] = new Pair[n];
+        	for(int i=0;i<n;i++) a[i] = new Pair(i,aa[i]);
+        	PriorityQueue<Pair> pq = new PriorityQueue<>();
+        	Arrays.sort(a);
+        	int goneTo[] = new int[n];
+        	for(int i=0;i<m;i++){
+        		pq.add(new Pair(i+1,a[n-1-i].y));
+        		goneTo[a[n-1-i].x] = i+1;
+        	}
+        	for(int i=n-m-1;i>=0;i--){
+        		Pair xx = pq.poll();
+        		xx.y += a[i].y;
+        		goneTo[a[i].x] = xx.x;
+        		pq.add(new Pair(xx.x,xx.y));
+        	}
+        	Iterator<Pair> it = pq.iterator();
+        	ArrayList<Pair> arr = new ArrayList<>();
+        	while(it.hasNext()) arr.add(it.next());
+        	Collections.sort(arr);
+        	//for(Pair i : arr) out.print(i.y+"" "");
+        	//out.println();
+        	if(arr.get(m-1).y-arr.get(0).y>x) out.println(""NO"");
+        	else{
+        		out.println(""YES"");
+        		int pos[] = new int[n];
+        		for(Pair i : a) pos[i.x] = goneTo[i.x];
+        		for(int i : pos) out.print(i+"" "");
+        		out.println();
+        	}
+    		//tt++; out.println(""Case #""+tt+"": ""+ans);
+        }
+        out.flush();
+}
+
+static class Pair implements Comparable<Pair> {
+		int x, y;
+		Pair(int a, int b){ x = a; y = b; }		
+		@Override
+		public int compareTo(Pair o) {
+			if(o.y - this.y>0)
+				return -1;
+			else if(o.y - this.y<0)
+				return 1;
+			else 
+				return 0;
+		}
+		}	
+
+	
+	static class FastScanner {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st = new StringTokenizer("""");
+		
+		String next() {
+			while(!st.hasMoreTokens())
+				try { st = new StringTokenizer(br.readLine()); }
+				catch(IOException e) {}
+			return st.nextToken();
+		}
+		
+		String nextLine(){
+			try{ return br.readLine(); } 
+			catch(IOException e) { } return """";
+		}
+		
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+		
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+		
+		int[] readArray(int n) {
+			int a[] = new int[n];
+			for(int i=0;i<n;i++) a[i] = nextInt();
+			return a;
+		}
+	}
+
+	static final Random random = new Random();
+
+	static void ruffleSort(int[] a){
+		int n = a.length;
+		for(int i=0;i<n;i++){
+			int j = random.nextInt(n), temp = a[j];
+			a[j] = a[i]; a[i] = temp;
+		}
+		Arrays.sort(a); 	
+	}
+}
+
+",1
+18e2441c,792863db," 
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.OutputStream;
+import java.io.PrintWriter;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.StringTokenizer;
+import java.util.TreeMap;
+import java.util.Map;
+import java.util.HashMap;
+
+public class cf1515 {
+
+	public static void main(String[] args) {
+		InputStream inputStream = System.in;
+		OutputStream outputStream = System.out;
+		InputReader in = new InputReader(inputStream);
+		PrintWriter out = new PrintWriter(outputStream);
+		Task solver = new Task();
+		solver.solve(in, out);
+		out.close();
+	}
+
+	static class Task {
+		public void solve(InputReader in, PrintWriter out) {
+			int t = in.nextInt();
+			while (t-- != 0) {
+				int n = in.nextInt();
+				int m = in.nextInt();
+				int x = in.nextInt();
+				TreeMap<Integer, ArrayList<Integer>> map = new TreeMap<>();
+				for (int i = 0; i < n; i++) {
+					int j = in.nextInt();
+					if (!map.containsKey(j)) {
+						map.put(j, new ArrayList<Integer>());
+					}
+					map.get(j).add(i);
+				}
+				out.println(""YES"");
+				int[] ans = new int[n];
+				int sta = 0;
+				for (int s : map.keySet()) {
+					for (int i = 0; i < map.get(s).size(); i++) {
+						ans[map.get(s).get(i)] = (sta++) % m + 1;
+					}
+				}
+				for(int i=0;i<n;i++) {
+					out.print(ans[i]+"" "");
+				}
+				out.println();
+			}
+
+		}
+	}
+
+	static class InputReader {
+		public BufferedReader reader;
+		public StringTokenizer tokenizer;
+
+		public InputReader(InputStream stream) {
+			reader = new BufferedReader(new InputStreamReader(stream));
+			tokenizer = null;
+		}
+
+		public String next() {
+			while (tokenizer == null || !tokenizer.hasMoreElements()) {
+				try {
+					tokenizer = new StringTokenizer(reader.readLine());
+				} catch (IOException e) {
+					throw new RuntimeException(e);
+				}
+			}
+			return tokenizer.nextToken();
+		}
+
+		public int nextInt() {
+			return Integer.parseInt(next());
+		}
+
+		public long nextLong() {
+			return Long.parseLong(next());
+		}
+
+		public double nextDouble() {
+			return Double.parseDouble(next());
+		}
+	}
+}
+
+","//package practice;
+
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.math.BigInteger;
+import java.text.SimpleDateFormat;
+import java.time.Instant;
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.LocalTime;
+import java.util.*;
+
+
+public class Main {
+
+	
+	 static class FastReader 
+
+	    { 
+	        BufferedReader br; 
+	        StringTokenizer st; 
+	  
+	        public FastReader() 
+	        { 
+	            br = new BufferedReader(new
+	                     InputStreamReader(System.in)); 
+	        } 
+	  
+	        String next() 
+	        { 
+	            while (st == null || !st.hasMoreElements()) 
+	            { 
+	                try
+	                { 
+	                    st = new StringTokenizer(br.readLine()); 
+	                } 
+	                catch (IOException  e) 
+	                { 
+	                    e.printStackTrace(); 
+	                } 
+	            } 
+	            return st.nextToken(); 
+	        } 
+	  
+	        int nextInt() 
+	        { 
+	            return Integer.parseInt(next()); 
+	        } 
+	  
+	        long nextLong() 
+	        { 
+	            return Long.parseLong(next()); 
+	        } 
+	  
+	        double nextDouble() 
+	        { 
+	            return Double.parseDouble(next()); 
+	        } 
+	  
+	        String nextLine() 
+	        { 
+	            String str = """"; 
+	            try
+	            { 
+	                str = br.readLine(); 
+	            } 
+	            catch (IOException e) 
+	            { 
+	                e.printStackTrace(); 
+	            } 
+	            return str; 
+	        } 
+	    }
+	
+	 static int gcd(int a,int b) {
+			if(b<=0) {
+				return a;
+			}
+			return gcd(b,a%b);
+		}
+	 
+	
+	 static int digSum(int n)
+	    {
+	        if (n == 0)
+	        return 0;
+	        return (n % 9 == 0) ? 9 : (n % 9);
+	    }
+	 
+	 static Set<Long> set=new HashSet<>();
+	 
+	static void sieveOfEratosthenes(int n)
+	    {
+	       
+	        boolean prime[] = new boolean[n+1];
+	        for(int i=0;i<n;i++)
+	            prime[i] = true;
+	          
+	        for(int p = 2; p*p <=n; p++)
+	        {
+	            
+	            if(prime[p] == true)
+	            {
+	                
+	                for(int i = p*p; i <= n; i += p)
+	                    prime[i] = false;
+	            }
+	        }
+	          
+	        // Print all prime numbers
+	        for(int i = 2; i <= n; i++)
+	        {
+	            if(prime[i] == true) {
+	            	set.add((long)i);
+	            }
+	               
+	        }
+	    }
+	      
+	static boolean isPrime(long x){
+	        if(x <= 1)return false;
+	        if(x == 2)return true;
+	        if(x%2 == 0)return false;
+	        for(long i = 3; i*i <= x; i+= 2)
+	            if(x%i == 0)
+	                return false;
+	            return true;
+	    }
+	
+	static int power(int x, int y, int p) {
+        
+        int res = 1; // Initialize result
+         
+        //Update x if it is more than or
+        // equal to p
+        x = x % p;
+ 
+        while (y > 0) {
+             
+            // If y is odd, multiply x with result
+            if ((y & 1) == 1)
+                res = (res * x) % p;
+         
+            // y must be even now
+            y = y >> 1; // y = y/2
+            x = (x * x) % p;
+        }
+         
+        return res;
+    }
+	
+	static boolean palin(char ch[]) {
+		int i=0;int j=ch.length-1;
+		while(i<j) {
+			if(ch[i]!=ch[j]) return false;
+			
+			i++;
+			j--;
+		}
+		return true;
+	}
+	
+	static int highestDivisor(int n) {
+	    if ((n & 1) == 0)
+	        return n / 2;
+	    int i = 3;
+	    while (i * i <= n) {
+	        if (n % i == 0) {
+	            return n / i;
+	        }
+	        i = i + 2;
+	    }
+	    return 1;
+	}
+	
+	static boolean isPowerOfTwo(int n)
+	{
+	    if(n==0)
+	    return false;
+	 
+	return (int)(Math.ceil((Math.log(n) / Math.log(2)))) ==
+	       (int)(Math.floor(((Math.log(n) / Math.log(2)))));
+	}
+	
+	 static boolean isPerfectSquare(int x)
+	    {
+	        if (x >= 0) {
+	           
+	          
+	            int sr = (int)Math.sqrt(x);
+	           
+	           
+	 
+	            return ((sr * sr) == x);
+	        }
+	        return false;
+	    }
+	 
+	 static boolean solve(int l,String s) {
+		 int cnt=0;
+		 int n=s.length();
+		 for(int i=0;i<n;i++) {
+			 if(s.charAt(i)=='1') cnt++;
+			 
+			 int per= (cnt *100)/(i+1);
+			 if(per>=50) return true;
+		 }
+		 return false;
+	 }
+	 
+	 
+	 
+	
+	public static void main(String[] args) throws IOException {
+      FastReader sc=new FastReader();
+      int t=sc.nextInt();
+      while(t-->0) {
+    	  int n=sc.nextInt();
+    	  int m=sc.nextInt();
+    	  int x=sc.nextInt();
+    	  int a[]=new int[n];
+    	  int b[]=new int[n];
+    	  int freq[]=new int[100002];
+    	  Arrays.fill(freq, 0);
+    	  for(int i=0;i<n;i++) {
+    		  a[i]=b[i]=sc.nextInt();
+    	  }
+    	  Arrays.sort(b);
+    	  int temp=1;
+   
+    	  Map<Integer,List<Integer>> map=new HashMap<>();
+    	  for(int i=0;i<n;i++) {
+    		  if(map.get(b[i])==null) {
+    			  List<Integer> lis=new ArrayList<Integer>();
+    			  lis.add(temp);
+    			  map.put(b[i], lis);
+    		  }
+    		  else {
+    			  List<Integer> lis=map.get(b[i]);
+    			  lis.add(temp);
+    			  map.put(b[i], lis);
+    		  }
+    		  temp++;
+    		  if(temp==m+1) {
+    			  temp=1;
+    		  }
+    	  }
+//    	  for(Map.Entry<Integer,List<Integer>> set: map.entrySet()) {
+//    		   System.out.println(set.getKey()+"" ""+set.getValue());
+//    	  }
+    	  StringBuilder sb=new StringBuilder();
+     	  List<Integer> res=new ArrayList<Integer>();
+    	  for(int i=0;i<n;i++) {
+    		  List<Integer> lis=map.get(a[i]);
+    		  res.add(lis.get(freq[a[i]]));
+    		//  sb.append(lis.get(freq[a[i]])+"" "");
+    		//  System.out.println(lis);
+    		  freq[a[i]]++;
+    	  }
+    	  boolean flag=true;
+    	  int arr[]=new int[m+1];
+    	  for(int i=0;i<n;i++) {
+    		  arr[res.get(i)] += a[i];
+    	  }
+    	  for(int i=1;i<=m-1;i++) {
+    		
+    			 long cal= Math.abs(arr[i+1]-arr[i]);
+    			 if(cal >x) {
+    				 flag=false;
+    				 break;
+    			 
+    		 }
+    		 if(!flag) break;
+    	  }
+    	  if(!flag) {
+    		  System.out.println(""NO"");
+    	  }
+    	  else {
+    		  System.out.println(""YES"");
+    		  for(int i=0;i<res.size();i++) {
+    			  System.out.print(res.get(i)+"" "");
+    		  }
+    		  System.out.println();
+    	  }
+    	  
+      }
+	}
+
+}
+",0
+2e404969,d76e3b9d,"import java.util.*;
+import java.lang.*;
+import java.io.*;
+
+public class Codechef {
+	static long fans[] = new long[200001];
+	static long inv[] = new long[200001];
+	static long mod = 1000000007;
+
+	static void init() {
+		fans[0] = 1;
+		inv[0] = 1;
+		fans[1] = 1;
+		inv[1] = 1;
+		for (int i = 2; i < 200001; i++) {
+			fans[i] = ((long) i * fans[i - 1]) % mod;
+			inv[i] = power(fans[i], mod - 2);
+		}
+	}
+
+	static long ncr(int n, int r) {
+		return (((fans[n] * inv[n - r]) % mod) * (inv[r])) % mod;
+	}
+
+	public static void main(String[] args) throws java.lang.Exception {
+		FastReader in = new FastReader(System.in);
+		StringBuilder sb = new StringBuilder();
+		int t = 1;
+		t = in.nextInt();
+		while (t > 0) {
+			--t;
+			int n = in.nextInt();
+			long time[] = generateArray(in, n);
+			long hp[] = generateArray(in, n);
+			int s = 0;
+			long ans = 0;
+			while(s<time.length)
+			{
+				long l = time[s] - hp[s];
+				long r = time[s];
+				for(int i = s+1;i<n;i++)
+				{
+					if(time[i]-hp[i]<=l)
+					{
+						l = time[i]-hp[i];
+						r = time[i];
+					}
+					else if(time[i]-hp[i]<r)
+					{
+						r = time[i];
+					}
+				}
+					
+					while(s<n && time[s]>=l && time[s]<=r)
+					{
+						++s;
+					}
+					long temp = r - l;
+					ans += (temp*(temp+1))/2;
+			}
+			sb.append(ans+""\n"");
+
+		}
+		System.out.print(sb);
+	}
+
+	static long power(long x, long y) {
+		long res = 1; // Initialize result
+
+		while (y > 0) {
+
+			// If y is odd, multiply x with result
+			if ((y & 1) != 0)
+				res = ((res % mod) * (x % mod)) % mod;
+
+			// y must be even now
+			y = y >> 1; // y = y/2
+			x = ((x % mod) * (x % mod)) % mod; // Change x to x^2
+		}
+		return res;
+	}
+
+	static long[] generateArray(FastReader in, int n) throws IOException {
+		long arr[] = new long[n];
+		for (int i = 0; i < n; i++)
+			arr[i] = in.nextLong();
+		return arr;
+	}
+
+	static long[][] generatematrix(FastReader in, int n, int m) throws IOException {
+		long arr[][] = new long[n][m];
+		for (int i = 0; i < n; i++) {
+			for (int j = 0; j < m; j++) {
+				arr[i][j] = in.nextLong();
+			}
+		}
+		return arr;
+	}
+
+	static long gcd(long a, long b) {
+		if (a == 0)
+			return b;
+		else
+			return gcd(b % a, a);
+	}
+
+	static long lcm(long a, long b) {
+		return (a / gcd(a, b)) * b;
+	}
+
+	static void sort(long[] a) {
+		ArrayList<Long> l = new ArrayList<>();
+		for (long i : a)
+			l.add(i);
+		Collections.sort(l);
+		for (int i = 0; i < a.length; i++)
+			a[i] = l.get(i);
+	}
+}
+
+class FastReader {
+
+	byte[] buf = new byte[2048];
+	int index, total;
+	InputStream in;
+
+	FastReader(InputStream is) {
+		in = is;
+	}
+
+	int scan() throws IOException {
+		if (index >= total) {
+			index = 0;
+			total = in.read(buf);
+			if (total <= 0) {
+				return -1;
+			}
+		}
+		return buf[index++];
+	}
+
+	String next() throws IOException {
+		int c;
+		for (c = scan(); c <= 32; c = scan())
+			;
+		StringBuilder sb = new StringBuilder();
+		for (; c > 32; c = scan()) {
+			sb.append((char) c);
+		}
+		return sb.toString();
+	}
+
+	String nextLine() throws IOException {
+		int c;
+		for (c = scan(); c <= 32; c = scan())
+			;
+		StringBuilder sb = new StringBuilder();
+		for (; c != 10 && c != 13; c = scan()) {
+			sb.append((char) c);
+		}
+		return sb.toString();
+	}
+
+	char nextChar() throws IOException {
+		int c;
+		for (c = scan(); c <= 32; c = scan())
+			;
+		return (char) c;
+	}
+
+	int nextInt() throws IOException {
+		int c, val = 0;
+		for (c = scan(); c <= 32; c = scan())
+			;
+		boolean neg = c == '-';
+		if (c == '-' || c == '+') {
+			c = scan();
+		}
+		for (; c >= '0' && c <= '9'; c = scan()) {
+			val = (val << 3) + (val << 1) + (c & 15);
+		}
+		return neg ? -val : val;
+	}
+
+	long nextLong() throws IOException {
+		int c;
+		long val = 0;
+		for (c = scan(); c <= 32; c = scan())
+			;
+		boolean neg = c == '-';
+		if (c == '-' || c == '+') {
+			c = scan();
+		}
+		for (; c >= '0' && c <= '9'; c = scan()) {
+			val = (val << 3) + (val << 1) + (c & 15);
+		}
+		return neg ? -val : val;
+	}
+}","import java.io.*;
+import java.util.*;
+
+public class c {
+    public static void main(String[] args) throws Exception {
+        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
+        PrintWriter out = new PrintWriter(System.out);
+        int numcases = Integer.parseInt(in.readLine());
+        for(int casenum = 0; casenum < numcases; casenum++){
+            int n = Integer.parseInt(in.readLine());
+            long[] t = new long[n];
+            long[] h = new long[n];
+            StringTokenizer tokenizer = new StringTokenizer(in.readLine());
+            for(int i = 0; i < n; i++){
+                t[i] = Integer.parseInt(tokenizer.nextToken());
+            }
+            tokenizer = new StringTokenizer(in.readLine());
+            for(int i = 0; i < n; i++){
+                h[i] = Integer.parseInt(tokenizer.nextToken());
+            }
+            long mana = 0;
+            int index = 0;
+            while(index < n){
+                long start = t[index] - h[index];
+                long end = t[index];
+                for(int i = index+1; i < n; i++){
+                    if(t[i] - h[i] < start){
+                        start = t[i] - h[i];
+                        end = t[i];
+                        index = i;
+                    }
+                    else if(t[i] - end < h[i]){
+                        end = t[i];
+                        index = i;
+                    }
+                }
+                mana += (end - start + 1) * (end - start) / 2;
+                index++;
+            }
+            System.out.println(mana);
+        }
+        in.close();
+        out.close();
+    }
+}",0
+722e318f,c9159d9c,"import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.math.BigInteger;
+import java.text.DecimalFormat;
+import java.util.*;
+import java.util.concurrent.ThreadLocalRandom;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+import java.util.stream.LongStream;
+
+public class TaskB {
+
+    static long mod = 1000000007;
+    static FastScanner scanner;
+
+    static final StringBuilder result = new StringBuilder();
+
+    public static void main(String[] args) {
+        // 2 : 1000000000
+        scanner = new FastScanner();
+        int T = scanner.nextInt();
+        for (int t = 0; t < T; t++) {
+            solve(t + 1);
+            result.append(""\n"");
+        }
+        System.out.println(result);
+    }
+
+    static void solve(int t) {
+        int n = scanner.nextInt();
+        int[] a = scanner.nextIntArray(n);
+        String s = scanner.nextToken();
+
+        List<Integer> blue = new ArrayList<>();
+        List<Integer> red = new ArrayList<>();
+        for (int i = 0; i < n; i++) {
+            if (s.charAt(i) == 'B') {
+                blue.add(a[i]);
+            } else {
+                red.add(a[i]);
+            }
+        }
+        Collections.sort(blue);
+        Collections.sort(red);
+        for (int i = 0; i < blue.size(); i++) {
+            if (blue.get(i) < i + 1) {
+                result.append(""NO"");
+                return;
+            }
+        }
+        for (int i = 0; i < red.size(); i++) {
+            if (red.get(i) > i + 1 + blue.size()) {
+                result.append(""NO"");
+                return;
+            }
+        }
+        result.append(""YES"");
+    }
+
+    static class WithIdx implements Comparable<WithIdx> {
+        int val, idx;
+
+        public WithIdx(int val, int idx) {
+            this.val = val;
+            this.idx = idx;
+        }
+
+        @Override
+        public int compareTo(WithIdx o) {
+            if (val == o.val) {
+                return Integer.compare(idx, o.idx);
+            }
+            return Integer.compare(val, o.val);
+        }
+    }
+
+    public static class FastScanner {
+        BufferedReader br;
+        StringTokenizer st;
+
+        public FastScanner() {
+            br = new BufferedReader(new InputStreamReader(System.in));
+        }
+
+        String nextToken() {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    // TODO Auto-generated catch block
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        String nextLine() {
+            try {
+                return br.readLine();
+            } catch (Exception e) {
+                e.printStackTrace();
+                throw new RuntimeException();
+            }
+        }
+
+        int nextInt() {
+            return Integer.parseInt(nextToken());
+        }
+
+        long nextLong() {
+            return Long.parseLong(nextToken());
+        }
+
+        double nextDouble() {
+            return Double.parseDouble(nextToken());
+        }
+
+        int[] nextIntArray(int n) {
+            int[] res = new int[n];
+            for (int i = 0; i < n; i++) res[i] = nextInt();
+            return res;
+        }
+
+        long[] nextLongArray(int n) {
+            long[] res = new long[n];
+            for (int i = 0; i < n; i++) res[i] = nextLong();
+            return res;
+        }
+
+        String[] nextStringArray(int n) {
+            String[] res = new String[n];
+            for (int i = 0; i < n; i++) res[i] = nextToken();
+            return res;
+        }
+    }
+
+    static class PrefixSums {
+        long[] sums;
+
+        public PrefixSums(long[] sums) {
+            this.sums = sums;
+        }
+
+        public long sum(int fromInclusive, int toExclusive) {
+            if (fromInclusive > toExclusive) throw new IllegalArgumentException(""Wrong value"");
+            return sums[toExclusive] - sums[fromInclusive];
+        }
+
+        public static PrefixSums of(int[] ar) {
+            long[] sums = new long[ar.length + 1];
+            for (int i = 1; i <= ar.length; i++) {
+                sums[i] = sums[i - 1] + ar[i - 1];
+            }
+            return new PrefixSums(sums);
+        }
+
+        public static PrefixSums of(long[] ar) {
+            long[] sums = new long[ar.length + 1];
+            for (int i = 1; i <= ar.length; i++) {
+                sums[i] = sums[i - 1] + ar[i - 1];
+            }
+            return new PrefixSums(sums);
+        }
+    }
+
+    static class ADUtils {
+        static void sort(int[] ar) {
+            Random rnd = ThreadLocalRandom.current();
+            for (int i = ar.length - 1; i > 0; i--) {
+                int index = rnd.nextInt(i + 1);
+                // Simple swap
+                int a = ar[index];
+                ar[index] = ar[i];
+                ar[i] = a;
+            }
+            Arrays.sort(ar);
+        }
+
+        static void reverse(int[] arr) {
+            int last = arr.length / 2;
+            for (int i = 0; i < last; i++) {
+                int tmp = arr[i];
+                arr[i] = arr[arr.length - 1 - i];
+                arr[arr.length - 1 - i] = tmp;
+            }
+        }
+
+        static void sort(long[] ar) {
+            Random rnd = ThreadLocalRandom.current();
+            for (int i = ar.length - 1; i > 0; i--) {
+                int index = rnd.nextInt(i + 1);
+                // Simple swap
+                long a = ar[index];
+                ar[index] = ar[i];
+                ar[i] = a;
+            }
+            Arrays.sort(ar);
+        }
+    }
+
+    static class MathUtils {
+        static long[] FIRST_PRIMES = {
+                2, 3, 5, 7, 11, 13, 17, 19, 23, 29,
+                31, 37, 41, 43, 47, 53, 59, 61, 67, 71,
+                73, 79, 83, 89, 97, 101, 103, 107, 109, 113,
+                127, 131, 137, 139, 149, 151, 157, 163, 167, 173,
+                179, 181, 191, 193, 197, 199, 211, 223, 227, 229,
+                233, 239, 241, 251, 257, 263, 269, 271, 277, 281,
+                283, 293, 307, 311, 313, 317, 331, 337, 347, 349,
+                353, 359, 367, 373, 379, 383, 389, 397, 401, 409,
+                419, 421, 431, 433, 439, 443, 449, 457, 461, 463,
+                467, 479, 487, 491, 499, 503, 509, 521, 523, 541,
+                547, 557, 563, 569, 571, 577, 587, 593, 599, 601,
+                607, 613, 617, 619, 631, 641, 643, 647, 653, 659,
+                661, 673, 677, 683, 691, 701, 709, 719, 727, 733,
+                739, 743, 751, 757, 761, 769, 773, 787, 797, 809,
+                811, 821, 823, 827, 829, 839, 853, 857, 859, 863,
+                877, 881, 883, 887, 907, 911, 919, 929, 937, 941,
+                947, 953, 967, 971, 977, 983, 991, 997, 1009, 1013,
+                1019, 1021, 1031, 1033, 1039, 1049, 1051};
+
+        static long[] primes(int to) {
+            long[] all = new long[to + 1];
+            long[] primes = new long[to + 1];
+            all[1] = 1;
+            int primesLength = 0;
+            for (int i = 2; i <= to; i++) {
+                if (all[i] == 0) {
+                    primes[primesLength++] = i;
+                    all[i] = i;
+                }
+                for (int j = 0; j < primesLength && i * primes[j] <= to && all[i] >= primes[j];
+                        j++) {
+                    all[(int) (i * primes[j])] = primes[j];
+                }
+            }
+            return Arrays.copyOf(primes, primesLength);
+        }
+
+        static long modpow(long b, long e, long m) {
+            long result = 1;
+
+            while (e > 0) {
+                if ((e & 1) == 1) {
+                    /* multiply in this bit's contribution while using modulus to keep
+                     * result small */
+                    result = (result * b) % m;
+                }
+                b = (b * b) % m;
+                e >>= 1;
+            }
+
+            return result;
+        }
+
+        static long submod(long x, long y, long m) {
+            return (x - y + m) % m;
+        }
+
+        static long modInverse(long a, long m) {
+            long g = gcdF(a, m);
+            if (g != 1) {
+                throw new IllegalArgumentException(""Inverse doesn't exist"");
+            } else {
+                // If a and m are relatively prime, then modulo
+                // inverse is a^(m-2) mode m
+                return modpow(a, m - 2, m);
+            }
+        }
+
+        static public long gcdF(long a, long b) {
+            while (b != 0) {
+                long na = b;
+                long nb = a % b;
+                a = na;
+                b = nb;
+            }
+            return a;
+        }
+    }
+}
+
+/*
+5
+3 2 3 8 8
+2 8 5 10 1
+
+ */","import java.util.*;
+
+public class SolutionB {
+
+    public static long gcd(long a, long b){
+        if(b==0){
+            return a;
+        }
+        return gcd(b, a%b);
+    }
+
+    public static long gcdSum(long b){
+        long a = 0;
+
+        long temp = b;
+        while(temp!=0){
+            a = a + temp%10;
+            temp = temp/10;
+        }
+        return gcd(a,b);
+
+    }
+
+    public static class Pair{
+        Long a;
+        Long b;
+
+        public Pair(Long a, Long b) {
+            this.a = a;
+            this.b = b;
+        }
+    }
+
+    public static long factorial (long n){
+        if(n==0)
+            return 1;
+        else if(n==1)
+            return n;
+
+        return n * factorial(n-1);
+    }
+
+    public static long lcm (long n){
+        if(n<3)
+            return n;
+        return lcmForBig(n,n-1);
+    }
+
+    private static long lcmForBig(long n, long l) {
+        if(l==1)
+            return n;
+        n = (n * l) / gcd(n, l);
+        return lcmForBig(n, l-1);
+
+    }
+
+
+    public static void main(String[] args){
+        Scanner s = new Scanner(System.in);
+        
+        int t = s.nextInt();
+
+        for(int i =0;i<t;i++) {
+            int n = s.nextInt();
+            int arr [] = new int[n];
+            ArrayList<Integer> blue = new ArrayList<>();
+            ArrayList<Integer> red = new ArrayList<>();
+
+            for(int j=0;j<n;j++){
+                int num = s.nextInt();
+                arr[j]=num;
+            }
+            String color = s.next();
+
+            for(int j=0;j<n;j++){
+                if(color.charAt(j)=='B'){
+                    blue.add(arr[j]);
+                }
+                else{
+                    red.add(arr[j]);
+                }
+            }
+            Collections.sort(blue);
+            String ans = ""YES"";
+            int counter = 0;
+
+            for(int j=0;j<blue.size();j++){
+                int current = blue.get(j);
+                if (current<1){
+                    ans=""NO"";
+                    break;
+                }
+                if(current>counter){
+                    counter++;
+                }
+                else{
+                    ans=""NO"";
+                    break;
+                }
+
+            }
+
+            if(ans==""NO""){
+                System.out.println(ans);
+            }
+            else{
+                int tempCounter = n+1;
+                Collections.sort(red);
+                for(int j=red.size()-1;j>=0;j--){
+                    int  current  = red.get(j);
+                    if(current>=tempCounter){
+                        ans=""NO"";
+                        break;
+                    }
+                    else{
+                        tempCounter--;
+                    }
+                }
+                if(tempCounter-counter!=1)
+                    System.out.println(""NO"");
+                else
+                    System.out.println(ans);
+            }
+
+        }
+
+        return;
+    }
+}
+",0
+13441e8f,141effef,"import java.util.*;
+
+public class Armchairs {
+
+	public static int findMinTime(List<Integer> zeros, List<Integer> ones) {
+		if (ones.size() == 0)
+			return 0;
+		int oneSize = ones.size();
+		int zeroSize = zeros.size();
+		int [][] time = new int [oneSize + 1][zeroSize + 1];
+		for (int i=1; i<=oneSize; i++) {
+			time[i][i] = time[i - 1][i - 1] + Math.abs(ones.get(i - 1) - zeros.get(i - 1));
+			for (int j=i+1; j<=zeroSize; j++) {
+				time[i][j] = Math.min(time[i][j - 1], time[i - 1][j - 1] + 
+					Math.abs(ones.get(i - 1) - zeros.get(j - 1)));
+			}
+		}
+		return time[oneSize][zeroSize];
+	}
+
+	public static void main (String [] args) {
+		Scanner sc = new Scanner(System.in);
+		int n = sc.nextInt();
+		List<Integer> zeros = new ArrayList<>();
+		List<Integer> ones = new ArrayList<>();
+		for (int i=0; i<n; i++) {
+			int number= sc.nextInt();
+			if (number == 1)
+				ones.add(i);
+			else
+				zeros.add(i);
+		}
+		System.out.println(findMinTime(zeros, ones));
+	}
+}","// package codeforces;
+
+import java.util.*;
+
+public class ArmChairs {
+	static int[]arr;
+	static ArrayList<Integer>a;
+	static ArrayList<Integer>b;
+	static int dp[][];
+	public static void main(String[] args) {
+		Scanner scn = new Scanner(System.in);
+		int n = scn.nextInt();
+		arr=new int[n];
+		for(int i=0;i<n;i++) {
+			arr[i]=scn.nextInt();
+		}
+		dp=new int[n+1][n+1];
+		a =new ArrayList<>();
+		b =new ArrayList<>();
+		for(int i=0;i<n;i++) {
+			if(arr[i]==0) {
+				a.add(i);
+			}else{
+				b.add(i);
+			}
+		}
+		System.out.println(solve(0,0));	
+	}
+	
+	public static int solve(int i,int j) {
+		if(i==b.size()) {
+			return 0;
+		}
+		if(j==a.size()) {
+			return 100000000;
+		}
+
+		if(dp[i][j]!=0) {
+			return dp[i][j];
+		}
+		int x=Math.abs(a.get(j)-b.get(i))+solve(i+1,j+1);
+		int y=solve(i,j+1);
+		return dp[i][j]=Math.min(x, y);
+	}
+	
+
+}
+",0
+9d1bfd29,fe07e031," //import java.io.IOException;
+ 
+    import java.io.IOException;
+    import java.io.InputStream;
+    import java.io.PrintWriter;
+    import java.util.*;
+ 
+    public class SetorDecrease {
+        static InputReader inputReader=new InputReader(System.in);
+        static void solve()
+        {
+            int n=inputReader.nextInt();
+            long k=inputReader.nextLong();
+            long sum=0;
+            long arr[]=new long[n];
+            for (int i=0;i<n;i++)
+            {
+                arr[i]=inputReader.nextLong();
+            }
+            SortDec(arr);
+            for (int i=0;i<n-1;i++)
+            {
+                sum+=arr[i];
+            }
+            long ans=Long.MAX_VALUE;
+            for (int i=0;i<n;i++)
+            {
+               long remval=k-sum;
+               long val=fdiv(remval,i+1);
+               ans=Math.min(ans,i+Math.max(arr[n-1]-val,0));
+               sum-=arr[i];
+            }
+            out.println(ans);
+        }
+        static void SortDec(long arr[])
+        {
+            List<Long>list=new ArrayList<>();
+            for(long ele:arr)
+            {
+                list.add(ele);
+            }
+            Collections.sort(list,Collections.reverseOrder());
+            int n=arr.length;
+            for (int i=0;i<n;i++)
+            {
+                arr[i]=list.get(i);
+ 
+            }
+ 
+        }
+       static long fdiv(long X, long Y) {
+            if (X >= 0) {
+                return X / Y;
+            } else {
+                return (X-Y+1) / Y;
+            }
+        }
+        static PrintWriter out=new PrintWriter((System.out));
+        public static void main(String args[])throws IOException
+        {
+            int t=inputReader.nextInt();
+            while (t-->0) {
+                solve();
+            }
+                out.close();
+        }
+        static class InputReader {
+ 
+            private InputStream stream;
+            private byte[] buf = new byte[8192];
+            private int curChar, snumChars;
+            private SpaceCharFilter filter;
+ 
+            public InputReader(InputStream stream) {
+                this.stream = stream;
+            }
+ 
+            public int snext() {
+                if (snumChars == -1)
+                    throw new InputMismatchException();
+                if (curChar >= snumChars) {
+                    curChar = 0;
+                    try {
+                        snumChars = stream.read(buf);
+                    } catch (IOException e) {
+                        throw new InputMismatchException();
+                    }
+                    if (snumChars <= 0)
+                        return -1;
+                }
+                return buf[curChar++];
+            }
+ 
+            public int nextInt() {
+                int c = snext();
+                while (isSpaceChar(c))
+                    c = snext();
+                int sgn = 1;
+                if (c == '-') {
+                    sgn = -1;
+                    c = snext();
+                }
+                int res = 0;
+                do {
+                    if (c < '0' || c > '9')
+                        throw new InputMismatchException();
+                    res *= 10;
+                    res += c - '0';
+                    c = snext();
+                } while (!isSpaceChar(c));
+                return res * sgn;
+            }
+ 
+            public long nextLong() {
+                int c = snext();
+                while (isSpaceChar(c))
+                    c = snext();
+                int sgn = 1;
+                if (c == '-') {
+                    sgn = -1;
+                    c = snext();
+                }
+                long res = 0;
+                do {
+                    if (c < '0' || c > '9')
+                        throw new InputMismatchException();
+                    res *= 10;
+                    res += c - '0';
+                    c = snext();
+                } while (!isSpaceChar(c));
+                return res * sgn;
+            }
+ 
+            public int[] nextIntArray(int n) {
+                int a[] = new int[n];
+                for (int i = 0; i < n; i++)
+                    a[i] = nextInt();
+                return a;
+            }
+ 
+            public String readString() {
+                int c = snext();
+                while (isSpaceChar(c))
+                    c = snext();
+                StringBuilder res = new StringBuilder();
+                do {
+                    res.appendCodePoint(c);
+                    c = snext();
+                } while (!isSpaceChar(c));
+                return res.toString();
+            }
+ 
+            public boolean isSpaceChar(int c) {
+                if (filter != null)
+                    return filter.isSpaceChar(c);
+                return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
+            }
+ 
+            public interface SpaceCharFilter {
+                public boolean isSpaceChar(int ch);
+            }
+        }
+    }","import java.io.*;
+import java.util.*;
+
+
+public class Main {
+    static int i, j, k, n, m, t, y, x, sum = 0;
+    static long mod = 998244353;
+    static FastScanner fs = new FastScanner();
+    static PrintWriter out = new PrintWriter(System.out);
+    static String str;
+
+    public static void main(String[] args) throws IOException {
+
+        t = fs.nextInt();
+
+        while (t-- > 0) {
+
+            n = fs.nextInt();
+            long k = fs.nextLong();
+
+            long sum=0;
+
+            int[] arr = fs.readArray(n);
+
+            for(i=0;i<n;i++)
+                sum+=arr[i];
+
+            ruffleSort(arr);
+
+            long[] suffix = new long[n];
+
+            suffix[n-1] = arr[n-1]-arr[0];
+
+            for(i=n-2;i>=0;i--){
+                suffix[i] = suffix[i+1]+arr[i]-arr[0];
+            }
+
+            long ans = sum-k;
+
+            if(ans<=0){
+                out.println(0);
+                continue;
+            }
+
+            for(i=n-1;i>0;i--){
+
+                long temp = sum-k;
+                long ansHere;
+                if(suffix[i]>=temp){
+                    ansHere = n-i;
+                }
+
+                else{
+                    long y = temp - suffix[i];
+
+                    long x = n-i+1;
+
+                    long moves = y/x;
+
+                    if(y%x!=0)
+                        moves++;
+
+                    ansHere = moves+(n-i);
+                }
+
+                ans = Math.min(ans,ansHere);
+            }
+
+            out.println(ans);
+
+        }
+
+        out.close();
+    }
+
+   /*static long nck(int n , int k){
+        long a = fact[n];
+        long b = modInv(fact[k]);
+        b*= modInv(fact[n-k]);
+        b%=mod;
+
+        return (a*b)%mod;
+    }
+
+   static void populateFact(){
+        fact[0]=1;
+
+        fact[1] = 1;
+
+        for(i=2;i<300005;i++){
+            fact[i]=i*fact[i-1];
+            fact[i]%=mod;
+        }
+    }
+    */
+
+
+    static long gcd(long a, long b) {
+        if (b == 0)
+            return a;
+        return gcd(b, a % b);
+    }
+
+    static long exp(long base, long pow) {
+        if (pow == 0) return 1;
+        long half = exp(base, pow / 2);
+        if (pow % 2 == 0) return mul(half, half);
+        return mul(half, mul(half, base));
+    }
+
+    static long mul(long a, long b) {
+        return ((a % mod) * (b % mod)) % mod;
+    }
+
+    static long add(long a, long b) {
+        return ((a % mod) + (b % mod)) % mod;
+    }
+
+    static long modInv(long x) {
+        return exp(x, mod - 2);
+    }
+
+    static void ruffleSort(int[] a) {
+        //ruffle
+        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;
+        }
+
+        //then sort
+        Arrays.sort(a);
+    }
+
+    static void ruffleSort(long[] a) {
+        //ruffle
+        int n = a.length;
+        Random r = new Random();
+        for (int i = 0; i < a.length; i++) {
+            int oi = r.nextInt(n);
+            long temp = a[i];
+            a[i] = a[oi];
+            a[oi] = temp;
+        }
+
+        Arrays.sort(a);
+    }
+
+    static class FastScanner {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st = new StringTokenizer("""");
+
+        String next() {
+            while (!st.hasMoreTokens())
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        int[] readArray(int n) {
+            int[] a = new int[n];
+            for (int i = 0; i < n; i++) a[i] = nextInt();
+            return a;
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+    }
+
+
+    static class Pair implements Comparable<Pair> {
+        public int x, y;
+
+        Pair(int x, int y) {
+            this.x = x;
+            this.y = y;
+        }
+
+        @Override
+        public int compareTo(Pair o) {
+
+            if (x == o.x)
+                return Integer.compare(y, o.y);
+
+            return Integer.compare(x, o.x);
+        }
+
+
+    }
+
+}",0
+07a0e4dc,bac616ee,"import java.io.*;
+import java.util.*;
+
+public class C_NotAssigning_1400 {
+    public static void main(String[] args) {
+        MyScanner sc = new MyScanner();
+        out = new PrintWriter(new BufferedOutputStream(System.out));
+        int t = sc.nextInt();
+        while(t-->0) {
+            int n = sc.nextInt();
+            boolean[] visited = new boolean[n];
+            ArrayList<Edge>[] adj = new ArrayList[n];
+            for(int i = 0; i < n; i++) {
+                adj[i] = new ArrayList<>();
+            }
+            for(int i = 0; i < n-1; i++) {
+                int a = sc.nextInt()-1;
+                int b = sc.nextInt()-1;
+                adj[a].add(new Edge(b, i));
+                adj[b].add(new Edge(a, i));
+            }
+            int start = -1;
+            boolean flag = false;
+            for(int i = 0; i < n; i++) { //start from leaf node
+                if(adj[i].size() == 1) {
+                    start = i;
+                } else if(adj[i].size() > 2) {
+                    flag = true;
+                }
+            }
+            int[] weights = new int[n-1];
+            Queue<Integer> que = new LinkedList<>();
+            que.offer(start);
+            visited[start] = true;
+            int curDist = 0;
+            while(!que.isEmpty()) {
+                int cur = que.poll();
+                for(Edge e : adj[cur]) {
+                    if(!visited[e.to]) {
+                        visited[e.to] = true;
+                        que.offer(e.to);
+                        if(curDist%2 == 0) {
+                            weights[e.index] = 2;
+                        } else {
+                            weights[e.index] = 3;
+                        }
+                    }
+                }
+                curDist++;
+            }
+            if(flag) {
+                System.out.println(-1);
+            } else {
+                StringBuilder sb = new StringBuilder();
+                for(int i = 0; i < n-1; i++){
+                    sb.append(weights[i] + "" "");
+                }
+                System.out.println(sb.toString().trim());
+            }
+
+        }
+
+        out.close();
+    }
+    static class Edge{
+        public int to;
+        public int index;
+        Edge(int to, int index){
+            this.to = to;
+            this.index = index;
+        }
+    }
+
+    public static PrintWriter out;
+
+    public static class MyScanner {
+        BufferedReader br;
+        StringTokenizer st;
+
+        public MyScanner() {
+            br = new BufferedReader(new InputStreamReader(System.in));
+        }
+
+        String next() {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+
+        String nextLine(){
+            String str = """";
+            try {
+                str = br.readLine();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+        }
+
+    }
+
+}
+","import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+import java.util.StringTokenizer;
+
+public class NotAssigning {
+	
+	static class FastReader {
+		
+        BufferedReader br;
+        StringTokenizer st;
+ 
+        public FastReader() {
+        	
+            br = new BufferedReader(new InputStreamReader(System.in));
+            
+        }
+ 
+        String next() {
+        	
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                }
+                catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+            
+        }
+ 
+        int nextInt() {
+        	
+        	return Integer.parseInt(next());
+        	
+        }
+ 
+        long nextLong() {
+        	
+        	return Long.parseLong(next());
+        	
+        }
+        
+        double nextFloat() {
+        	
+        	return Float.parseFloat(next());
+        
+        }
+ 
+        double nextDouble() {
+        	
+        	return Double.parseDouble(next());
+        	
+        }
+ 
+        String nextLine() {
+        	
+            String str = """";
+            try {
+                str = br.readLine();
+            }
+            catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+            
+        }
+        
+        int[] nextArray(int n) {
+        	
+        	int[] a = new int[n];
+        	for (int i=0; i<n; i++) {
+        		a[i] = this.nextInt();
+        	}
+        	return a;
+        	
+        }
+        
+        long[] nextArrayLong(int n) {
+        	
+        	long[] a = new long[n];
+        	for (int i=0; i<n; i++) {
+        		a[i] = this.nextLong();
+        	}
+        	return a;
+        	
+        }
+        
+    }
+	
+	static class Pair {
+		
+		int a, b;
+
+		public Pair(int a, int b) {
+			
+			this.a = a;
+			this.b = b;
+			
+		}
+
+	}
+	
+	static boolean vis[];
+	public static void dfs(ArrayList<ArrayList<Pair>> t, int cur, boolean mode, int[] w) {
+		vis[cur] = true;
+		for (Pair p : t.get(cur)) {
+			if (!vis[p.a]) {
+				if (mode) {
+					w[p.b] = 3;
+				}
+				else {
+					w[p.b] = 2;
+				}
+				dfs(t, p.a, !mode, w);
+			}
+		}
+	}
+	
+	public static void solve(int n, int[] u, int[] v) {
+		
+		ArrayList<ArrayList<Pair>> t = new ArrayList<ArrayList<Pair>>(n);
+		for (int i=0; i<n; i++) {
+			t.add(new ArrayList<Pair>());
+		}
+		for (int i=0; i<n-1; i++) {
+			t.get(u[i]).add(new Pair(v[i], i));
+			t.get(v[i]).add(new Pair(u[i], i));
+		}
+		int start = 0;
+		for (int i=0; i<n; i++) {
+			if (t.get(i).size() > 2) {
+				System.out.println(""-1"");
+				return;
+			}
+			if (t.get(i).size() == 1) {
+				start = i;
+			}
+		}
+		vis = new boolean[n];
+		int[] w = new int[n-1];
+		dfs(t, start, false, w);
+		StringBuilder ans = new StringBuilder();
+		for (int i=0; i<n-1; i++) {
+			ans.append(w[i]).append("" "");
+		}
+		System.out.println(ans);
+		
+	}
+
+	public static void main(String[] args) {
+		
+		FastReader in = new FastReader();
+		int t = in.nextInt();
+		while (t-- > 0) {
+			int n = in.nextInt();
+			int[] u = new int[n-1];
+			int[] v = new int[n-1];
+			for (int i=0; i<n-1; i++) {
+				u[i] = in.nextInt()-1;
+				v[i] = in.nextInt()-1;
+			}
+			solve(n, u, v);
+		}
+
+	}
+
+}
+",0
+9cea10af,d63e6e3f,"//package currentContest;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.StringTokenizer;
+public class P4 {
+	static int dp[][]=new int[5000+1][5000+1];
+	public static void main(String[] args) {
+		// TODO Auto-generated method stub
+		FastReader sc=new FastReader();
+		int t=1;
+		//t=sc.nextInt();
+		StringBuilder s=new StringBuilder();
+		while(t--!=0) {
+			int n=sc.nextInt();
+			int a[]=new int[n];
+			
+			for(int i=0;i<=n;i++) {
+				for(int j=0;j<=n;j++) {
+					P4.dp[i][j]=-1;
+				}
+			}
+			ArrayList<Integer> one=new ArrayList<>();
+			ArrayList<Integer> zero=new ArrayList<>();
+			for(int i=0;i<n;i++) {
+				a[i]=sc.nextInt();
+				if(a[i]==0) {
+					zero.add(i);
+				}else {
+					one.add(i);
+				}
+			}
+			Collections.sort(zero);
+			Collections.sort(one);
+			long ans=sol(0,0,zero.size(),one.size(),a,zero,one);
+			System.out.println(ans);
+		}
+		//System.out.println(s);
+	}
+	private static long sol(int i, int j, int n, int m,int a[], ArrayList<Integer> zero, ArrayList<Integer> one) {
+		//System.out.println(i+"" ""+j);
+		// TODO Auto-generated method stub
+		if(j==m) {
+			return 0;
+		}
+		int av=n-i;
+		int rem=m-j;
+		if(av<rem) {
+			return Integer.MAX_VALUE-1;
+		}
+		if(dp[i][j]!=-1) {
+			return dp[i][j];
+		}
+		long ans1=sol(i+1,j,n,m,a, zero, one);
+		long ans2=Math.abs(zero.get(i)-one.get(j))+sol(i+1,j+1,n,m,a, zero, one);
+		dp[i][j]=(int) Math.min(ans1, ans2);
+		return dp[i][j];
+	}
+	static class FastReader 
+    { 
+        BufferedReader br; 
+        StringTokenizer st; 
+  
+        public FastReader() 
+        { 
+            br = new BufferedReader(new
+                     InputStreamReader(System.in)); 
+        } 
+  
+        String next() 
+        { 
+            while (st == null || !st.hasMoreElements()) 
+            { 
+                try
+                { 
+                    st = new StringTokenizer(br.readLine()); 
+                } 
+                catch (IOException  e) 
+                { 
+                    e.printStackTrace(); 
+                } 
+            } 
+            return st.nextToken(); 
+        } 
+  
+        int nextInt() 
+        { 
+            return Integer.parseInt(next()); 
+        } 
+  
+        long nextLong() 
+        { 
+            return Long.parseLong(next()); 
+        } 
+  
+        double nextDouble() 
+        { 
+            return Double.parseDouble(next()); 
+        } 
+  
+        String nextLine() 
+        { 
+            String str = """"; 
+            try
+            { 
+                str = br.readLine(); 
+            } 
+            catch (IOException e) 
+            { 
+                e.printStackTrace(); 
+            } 
+            return str; 
+        } 
+    } 
+}
+","/*
+ * akshaygupta26
+ */
+import java.io.*;
+import java.util.*;
+public class D
+{ 
+	
+	static ArrayList<Integer> taken,vacant;
+	static long dp[][];
+    public static void main(String[] args) 
+	{ 
+		FastReader sc=new FastReader(); 
+		StringBuffer ans=new StringBuffer();
+		int test=1;
+		while(test-->0)
+		{
+			int n=sc.nextInt();
+			taken=new ArrayList<>();;
+			vacant=new ArrayList<>();
+			
+			dp=new long[n+1][n+1];
+			for(int i=0;i<=n;i++) {
+				Arrays.fill(dp[i], -1);
+			}
+			
+			for(int i=0;i<n;i++) {
+				if(sc.nextInt() == 1) taken.add(i);
+				else vacant.add(i);
+			}
+			
+			long res =solve(0,0,taken.size(),vacant.size());
+			ans.append(res+""\n"");
+		}
+
+	    System.out.print(ans);
+	} 
+ 
+    static long solve(int t1,int v1,int nt1,int nv1) {
+    	
+    	//All taken given a seat
+    	if(t1 == nt1) return 0;
+    	
+    	//Vacant seats finishes
+    	if(v1 == nv1) return Integer.MAX_VALUE;
+    	
+    	//Not enough seat
+    	if(nt1-t1 > nv1-v1) return Integer.MAX_VALUE;
+    	
+    	/*
+    	 * Two options: 
+    	 * 1) Use the current vacant seat
+    	 * 2) Skip the current vacant seat
+    	 */
+    	
+    	if(dp[t1][v1] != -1) return dp[t1][v1];
+    	
+    	long op1 = solve(t1+1,v1+1,nt1,nv1) + Math.abs(vacant.get(v1)-taken.get(t1));
+    	long op2 = solve(t1,v1+1,nt1,nv1);
+    	
+    	return dp[t1][v1]=Math.min(op1, op2);
+    }
+    
+    static long _gcd(long a,long b) {
+    	if(b == 0) return a;
+    	return _gcd(b,a%b);
+    }
+    
+    static final Random random=new Random();
+    
+	static void ruffleSort(int[] a) {
+		int n=a.length;//shuffle, then sort 
+		for (int i=0; i<n; i++) {
+			int oi=random.nextInt(n), temp=a[oi];
+			a[oi]=a[i]; a[i]=temp;
+		}
+		Arrays.sort(a);
+	}
+	
+	static void ruffleSort(long[] a) {
+		int n=a.length;//shuffle, then sort 
+		for (int i=0; i<n; i++) {
+			int oi=random.nextInt(n);
+			long temp=a[oi];
+			a[oi]=a[i]; a[i]=temp;
+		}
+		Arrays.sort(a);
+	}
+	
+	static class FastReader 
+	{ 
+		BufferedReader br; 
+		StringTokenizer st; 
+
+		public FastReader() 
+		{ 
+			br = new BufferedReader(new
+					InputStreamReader(System.in)); 
+		} 
+
+		String next() 
+		{ 
+			while (st == null || !st.hasMoreElements()) 
+			{ 
+				try
+				{ 
+					st = new StringTokenizer(br.readLine()); 
+				} 
+				catch (IOException e) 
+				{ 
+					e.printStackTrace(); 
+				} 
+			} 
+			return st.nextToken(); 
+		} 
+
+		int nextInt() 
+		{ 
+			return Integer.parseInt(next()); 
+		} 
+
+		long nextLong() 
+		{ 
+			return Long.parseLong(next()); 
+		} 
+
+		double nextDouble() 
+		{ 
+			return Double.parseDouble(next()); 
+		} 
+
+		String nextLine() 
+		{ 
+			String str = """"; 
+			try
+			{ 
+				str = br.readLine(); 
+			} 
+			catch (IOException e) 
+			{ 
+				e.printStackTrace(); 
+			} 
+			return str; 
+		} 
+	} 
+
+
+} 
+",0
+35bb6075,42fe7dd0,"/*
+    COLLECTIONS FRAMEWORK TUTORIAL
+
+    * HashMap
+
+    .add(key, value)
+    .get(key)
+    .containsKey(key) : true/false
+    .size()
+*/
+
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+
+import java.util.*;
+
+public class Main {
+
+    static final long M = 1000000007;
+
+    // use main for only io
+    public static void main(String args[]) {
+        FastReader io = new FastReader();
+        new Solver().solve(io);
+    }
+}
+
+//class Pair{
+//    int key;String value;
+//
+//    public Pair(int key, String value){
+//        this.key = key;
+//        this.value = value;
+//    }
+//}
+
+class SparseTable{
+    int dp[][] = new int[300005][20];
+
+    int log[] = new int[300005];
+
+    public SparseTable(long a[], int n){
+        for(int i =0;i<n;i++)dp[i][0] = i;
+
+        for(int i = 1;i < 20;i++){
+            for(int j = 0;j + (1 << i) < n;j++){
+                if(a[dp[j][i-1]] < a[dp[j + (1 << (i-1))][i-1]]){
+                    dp[j][i] = dp[j][i-1];
+                }
+                else{
+                    dp[j][i] = dp[j + (1 << (i - 1))][i-1];
+                }
+            }
+        }
+
+        log[1] = 0;
+        for(int i = 2;i <= n;i++){
+            log[i] = log[i/2] + 1;
+        }
+    }
+
+    int getMin(int L, int R, long a[]){
+        if(L > R)return 0;
+        int j = log[R - L + 1];
+        if(a[dp[L][j]] < a[dp[R - (1 << j) + 1][j]])return dp[L][j];
+
+        return dp[R-(1 << j) + 1][j];
+    }
+}
+
+class Solver {
+    static final int M = 998244353;
+
+    void solve(FastReader io) {
+       int t = io.nextInt();
+
+       while(t-- > 0){
+           int n = io.nextInt();
+
+           String s[] = new String[n];
+
+           for(int i = 0;i < n;i++)s[i] = io.nextLine();
+
+           int ans = 0;
+
+           for(int i = 0;i < 5;i++){
+               int count[] = new int[n];
+
+               for(int j = 0;j < n;j++){
+                   int freq = 0;
+                   for(int k = 0;k < s[j].length();k++){
+//                       System.out.println(s[j].charAt(k) - 'a');
+                       if((s[j].charAt(k) - 'a') == i){
+
+                           freq++;
+                       }
+                   }
+//                    System.out.println(i + "" "" + freq);
+                   count[j] = 2*freq - s[j].length();
+               }
+
+
+               Arrays.sort(count);
+//                for(int it : count)System.out.print(it + "" "");
+//                System.out.println();
+
+               int curr = 0;
+               int j = n - 1;
+               for(;j >= 0 && (curr + count[j] > 0);j--){
+                   curr += count[j];
+               }
+
+               ans = Math.max(ans, n - j - 1);
+
+           }
+
+           System.out.println(ans);
+       }
+    }
+
+    // returns the first key greater than or equal to val
+    int lower_bound(int a[], int val) {
+        int low = 0, high = a.length - 1, ret = -1;
+
+        while (low <= high) {
+            int mid = (low + high) / 2;
+
+            if (a[mid] < val) low = mid + 1;
+            else {
+                ret = mid;
+                high = mid - 1;
+            }
+
+        }
+
+        return ret;
+    }
+
+    // returns the first key strictly greater than val
+    int upper_bound(int a[], int val) {
+        int low = 0, high = a.length - 1, ret = -1;
+
+        while (low <= high) {
+            int mid = (low + high) / 2;
+
+            if (a[mid] <= val) low = mid + 1;
+            else {
+                ret = mid;
+                high = mid - 1;
+            }
+
+        }
+
+        return ret;
+    }
+    long modexp(long n, int m) {
+        if (m == 0)
+            return 1;
+        else if (m == 1)
+            return n;
+        else {
+            long p = modexp(n, m / 2);
+
+            if (m % 2 == 1)
+                return (((p * p) % M) * n) % M;
+            else
+                return (p * p) % M;
+        }
+    }
+
+    long exp(long n, long m) {
+        if (m == 0)
+            return 1;
+        if (m == 1)
+            return n;
+
+        long p = exp(n, m / 2);
+
+        if (m % 2 == 1)
+            return p * p * n;
+        else
+            return p * p;
+    }
+
+    long gcd(long a, long b) {
+        if (a == 0)
+            return b;
+
+        return gcd(b % a, a);
+    }
+
+    long inv(long n) {
+        return modexp(n, M - 2);
+    }
+
+    long lcm(long a, long b) {
+        return a * b / gcd(a, b);
+    }
+
+    long factorial(long fact[], int n) {
+        fact[0] = 1;
+        fact[1] = 1;
+
+        long prod = 1;
+
+        for (int i = 2; i <= n; i++) {
+            prod = (prod * i) % M;
+
+            fact[i] = prod;
+        }
+
+        return prod;
+    }
+
+    boolean isPrime(long n) {
+        for (int i = 2; i * i <= n; i++) {
+            if (n % i == 0)
+                return false;
+        }
+        return true;
+    }
+}
+
+
+class FastReader {
+    BufferedReader br;
+    StringTokenizer st;
+
+    public FastReader() {
+        br = new BufferedReader(new
+                InputStreamReader(System.in));
+    }
+
+    String next() {
+        while (st == null || !st.hasMoreElements()) {
+            try {
+                st = new StringTokenizer(br.readLine());
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+        }
+        return st.nextToken();
+    }
+
+    int nextInt() {
+        return Integer.parseInt(next());
+    }
+
+    long nextLong() {
+        return Long.parseLong(next());
+    }
+
+    double nextDouble() {
+        return Double.parseDouble(next());
+    }
+
+    String nextLine() {
+        String str = """";
+        try {
+            str = br.readLine();
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        return str;
+    }
+}","import java.util.*;
+ public class Solution {
+    static Scanner sc=new Scanner(System.in);
+    public static void main(String args[]) {
+      int t=sc.nextInt();
+      outer:while(t-->0){
+        int n=sc.nextInt();
+        int[][] ct=new int[n][5];
+        int[] len=new int[n];
+        for (int i=0;i<n;i++) {
+            String s=sc.next();
+            len[i]=s.length();
+            for(char c:s.toCharArray()){
+                ct[i][c-'a']++;
+            }
+        }
+        int mx=0;
+        for (int i=0;i<5;i++) {
+            int[] diff=new int[n];
+            for (int j=0;j<n;j++) {
+                diff[j]=ct[j][i]-(len[j]-ct[j][i]);
+            }
+            Arrays.sort(diff);
+            int sum=0,inc=0;
+            for(int j=n-1;j>=0;j--){
+                sum+=diff[j];
+                if (sum>0) {
+                    inc++;
+                }else {
+                    break;
+                }
+            }
+            mx=Math.max(mx,inc);
+        }
+        System.out.println(mx);
+        }
+        
+      }
+
+    }
+
+",0
+8a39dbf5,e1a5831a,"import java.util.*;
+import java.lang.*;
+import java.io.*;
+ 
+/* Name of the class has to be ""Main"" only if the class is public. */
+public class Codeforces {
+    public static void main(String[] args) throws java.lang.Exception {
+        /* your code goes here */
+        BufferedReader buf = new BufferedReader(new InputStreamReader(System.in));
+       int t = Integer.parseInt(buf.readLine());
+        StringBuilder sb = new StringBuilder();
+       for (int i = 0; i < t; i++) {
+           String st=buf.readLine();
+          String st1[]=(buf.readLine()).split("" "");
+          int n=Integer.parseInt(st1[0]);
+          int k=Integer.parseInt(st1[1]);
+          int a[]=new int[k];
+          int temp[]=new int[k];
+          long arr[]=new long[n];
+          String st2[]=(buf.readLine()).split("" "");
+           String st3[]=(buf.readLine()).split("" "");
+           for(int j=0;j<k;j++)
+           {
+               a[j]=Integer.parseInt(st2[j]);
+               temp[j]=Integer.parseInt(st3[j]);
+           }
+          for(int j=0;j<k;j++)
+          {
+              arr[a[j]-1]=temp[j];
+          }
+          long min=Integer.MAX_VALUE;
+          long left[]=new long[n];
+          long right[]=new long[n];
+          if(arr[0]==0)
+              left[0]=min;
+          else
+              left[0]=arr[0];
+          for(int j=1;j<n;j++)
+          {
+              if(arr[j]==0)
+              {
+                  left[j]=left[j-1]+1;
+              }
+              else
+              {
+                  left[j]=Math.min(left[j-1]+1,arr[j]);
+              }
+          }
+          if(arr[n-1]==0)
+              right[n-1]=min;
+          else
+              right[n-1]=arr[n-1];
+          for(int j=n-2;j>=0;j--)
+          {
+              if(arr[j]==0)
+              {
+                  right[j]=right[j+1]+1;
+              }
+              else
+              {
+                  right[j]=Math.min(right[j+1]+1,arr[j]);
+              }
+          }
+          for(int j=0;j<n;j++)
+          {
+              arr[j]=Math.min(left[j],right[j]);
+              sb.append(arr[j]+"" "");
+          }
+          sb.append(""\n"");
+        }
+        System.out.println(sb);
+    }
+}","/* package codechef; // don't place package name! */
+
+import java.util.*;
+import java.lang.*;
+import java.io.*;
+
+/* Name of the class has to be ""Main"" only if the class is public. */
+public class Codechef
+{
+	public static void main (String[] args) throws java.lang.Exception
+	{
+		// your code goes here
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		int t = Integer.parseInt(br.readLine());
+		for(int q=0;q<t;q++){
+		    //  int n = Integer.parseInt(br.readLine());
+		      String s = br.readLine();
+                  String s1[] = br.readLine().split("" "");
+                  int n = Integer.parseInt(s1[0]);
+                  int k = Integer.parseInt(s1[1]);
+                  String s2[] = br.readLine().split("" "");
+                  int a[] = new int[k];
+                  for(int i=0;i<k;i++){
+                        a[i] = Integer.parseInt(s2[i]);
+                  }
+                  String s3[] = br.readLine().split("" "");
+                  int b[] = new int[k];
+                  for(int i=0;i<k;i++){
+                        b[i] = Integer.parseInt(s3[i]);
+                  }
+                  long ans[] = new long[n];
+                  for(int i=0;i<n;i++){
+                        ans[i] = Integer.MAX_VALUE;
+                  }
+                  for(int i=0;i<k;i++){
+                        ans[a[i]-1] = b[i];
+                  }
+                  for(int i=1;i<n;i++){
+                        ans[i] = Math.min(ans[i],ans[i-1]+1);
+                  }
+                  for(int i=n-2;i>=0;i--){
+                        ans[i] = Math.min(ans[i],ans[i+1]+1);
+                  }
+                  
+                  for(int i=0;i<n;i++){
+                        System.out.print(ans[i]+"" "");
+                  }
+                  System.out.println();
+		}
+	}
+}
+
+",0
+11c2ab99,8f6421f3,"import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.StringTokenizer;
+
+public class Main {
+
+	public static void main(String[] args) {
+		FastScanner fs=new FastScanner();
+		int T=fs.nextInt();
+		PrintWriter out=new PrintWriter(System.out);
+		for (int tt=0; tt<T; tt++) {
+			int n=fs.nextInt(), k=fs.nextInt();
+			int[] positions=fs.readArray(k), temps=fs.readArray(k);
+			int[] forced=new int[n];
+			Arrays.fill(forced, Integer.MAX_VALUE/2);
+			for (int i=0; i<k; i++) forced[positions[i]-1]=temps[i];
+			for (int i=1; i<n; i++)
+				forced[i]=Math.min(forced[i], forced[i-1]+1);
+			for (int i=n-2; i>=0; i--)
+				forced[i]=Math.min(forced[i], forced[i+1]+1);
+			for (int i=0; i<n; i++) out.print(forced[i]+"" "");
+			out.println();
+			
+		}
+		out.close();
+	}
+
+	static void sort(int[] a) {
+		ArrayList<Integer> l=new ArrayList<>();
+		for (int i:a) l.add(i);
+		Collections.sort(l);
+		for (int i=0; i<a.length; i++) a[i]=l.get(i);
+	}
+	
+	static class FastScanner {
+		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st=new StringTokenizer("""");
+		String next() {
+			while (!st.hasMoreTokens())
+				try {
+					st=new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			return st.nextToken();
+		}
+		
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+		int[] readArray(int n) {
+			int[] a=new int[n];
+			for (int i=0; i<n; i++) a[i]=nextInt();
+			return a;
+		}
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+	}
+
+	
+}
+
+","import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.StringTokenizer;
+import java.util.Arrays;
+public class Main{  
+    public static void main (String[] args){
+        FastReader s = new FastReader();
+        int t=1;t=s.ni();
+        for(int test=1;test<=t;test++){
+        int n=s.ni(),k=s.ni();
+        int position[]=s.readArray(k),temp[]=s.readArray(k);
+        int ans[]=new int[n];
+        Arrays.fill(ans,Integer.MAX_VALUE/2);
+        for(int i=0;i<k;i++){
+            ans[position[i]-1]=temp[i];
+        }
+        for(int i=1;i<n;i++){
+            ans[i]=Math.min(ans[i-1]+1,ans[i]);
+        }
+        for(int i=n-2;i>=0;i--){
+            ans[i]=Math.min(ans[i],ans[i+1]+1);
+        }
+        for(int i=0;i<n;i++)
+        System.out.print(ans[i]+"" "");
+        System.out.println();
+        }
+    }
+    
+    
+    static class FastReader {
+        BufferedReader br;
+        StringTokenizer st;
+        public FastReader(){
+        br = new BufferedReader(new InputStreamReader(System.in));}
+        int ni() { return Integer.parseInt(next()); }
+        long nl() { return Long.parseLong(next()); }
+        double nd() { return Double.parseDouble(next()); }
+        int[] readArray(int n){
+		int[] a = new int[n];
+		for (int i = 0; i < n; i++)
+			a[i] =Integer.parseInt(next());
+		return a;
+	    }
+        String next(){
+            while (st == null || !st.hasMoreElements()) {try {st = new StringTokenizer(br.readLine());}
+            catch (IOException e){e.printStackTrace();}}return st.nextToken();}
+            String nextLine(){String str = """";try {str = br.readLine();}catch (IOException e) 
+            {e.printStackTrace();}return str;}
+    }
+}
+
+
+  
+",1
+680ba922,f3d7ce08,"import java.util.*;
+import java.io.*;
+
+public class Solution
+{
+    static class Reader {
+        final private int BUFFER_SIZE = 1 << 16;
+        private DataInputStream din;
+        private byte[] buffer;
+        private int bufferPointer, bytesRead;
+ 
+        public Reader()
+        {
+            din = new DataInputStream(System.in);
+            buffer = new byte[BUFFER_SIZE];
+            bufferPointer = bytesRead = 0;
+        }
+ 
+        public Reader(String file_name) throws IOException
+        {
+            din = new DataInputStream(
+                new FileInputStream(file_name));
+            buffer = new byte[BUFFER_SIZE];
+            bufferPointer = bytesRead = 0;
+        }
+ 
+        public String readLine() throws IOException
+        {
+            byte[] buf = new byte[64]; // line length
+            int cnt = 0, c;
+            while ((c = read()) != -1) {
+                if (c == '\n') {
+                    if (cnt != 0) {
+                        break;
+                    }
+                    else {
+                        continue;
+                    }
+                }
+                buf[cnt++] = (byte)c;
+            }
+            return new String(buf, 0, cnt);
+        }
+ 
+        public int nextInt() throws IOException
+        {
+            int ret = 0;
+            byte c = read();
+            while (c <= ' ') {
+                c = read();
+            }
+            boolean neg = (c == '-');
+            if (neg)
+                c = read();
+            do {
+                ret = ret * 10 + c - '0';
+            } while ((c = read()) >= '0' && c <= '9');
+ 
+            if (neg)
+                return -ret;
+            return ret;
+        }
+ 
+        public long nextLong() throws IOException
+        {
+            long ret = 0;
+            byte c = read();
+            while (c <= ' ')
+                c = read();
+            boolean neg = (c == '-');
+            if (neg)
+                c = read();
+            do {
+                ret = ret * 10 + c - '0';
+            } while ((c = read()) >= '0' && c <= '9');
+            if (neg)
+                return -ret;
+            return ret;
+        }
+ 
+        public double nextDouble() throws IOException
+        {
+            double ret = 0, div = 1;
+            byte c = read();
+            while (c <= ' ')
+                c = read();
+            boolean neg = (c == '-');
+            if (neg)
+                c = read();
+ 
+            do {
+                ret = ret * 10 + c - '0';
+            } while ((c = read()) >= '0' && c <= '9');
+ 
+            if (c == '.') {
+                while ((c = read()) >= '0' && c <= '9') {
+                    ret += (c - '0') / (div *= 10);
+                }
+            }
+ 
+            if (neg)
+                return -ret;
+            return ret;
+        }
+ 
+        private void fillBuffer() throws IOException
+        {
+            bytesRead = din.read(buffer, bufferPointer = 0,
+                                 BUFFER_SIZE);
+            if (bytesRead == -1)
+                buffer[0] = -1;
+        }
+ 
+        private byte read() throws IOException
+        {
+            if (bufferPointer == bytesRead)
+                fillBuffer();
+            return buffer[bufferPointer++];
+        }
+ 
+        public void close() throws IOException
+        {
+            if (din == null)
+                return;
+            din.close();
+        }
+    }
+    
+   
+  static int parent(int a , int p[])
+  {
+      if(a == p[a])
+      return a;
+      
+      return p[a] = parent(p[a],p);
+  }
+  
+  static void union(int a , int b , int p[] , int size[])
+  {
+      a = parent(a,p);
+      b = parent(b,p);
+      
+      if(a == b)
+      return;
+      
+      if(size[a] < size[b])
+      {
+          int temp = a;
+          a = b;
+          b = temp;
+      }
+      
+      p[b] = a;
+      size[a] += size[b];
+  }
+  
+  
+  
+  
+ static long getSum(int index , long BITree[])
+    {
+        long sum = 0; // Iniialize result
+      
+        // index in BITree[] is 1 more than
+        // the index in arr[]
+       // index = index + 1;
+      
+        // Traverse ancestors of BITree[index]
+        while(index>0)
+        {
+            // Add current element of BITree 
+            // to sum
+            sum += BITree[index];
+      
+            // Move index to parent node in 
+            // getSum View
+            index -= index & (-index);
+        }
+        return sum;
+    }
+  
+    // Updates a node in Binary Index Tree (BITree)
+    // at given index in BITree. The given value 
+    // 'val' is added to BITree[i] and all of 
+    // its ancestors in tree.
+    public static void updateBIT(int n, int index, 
+                                        long val , long BITree[])
+    {
+        // index in BITree[] is 1 more than 
+        // the index in arr[]
+      //  index = index + 1;
+      
+        // Traverse all ancestors and add 'val'
+        while(index <= n)
+        {
+        // Add 'val' to current node of BIT Tree
+        BITree[index] += val;
+      
+        // Update index to that of parent 
+        // in update View
+        index += index & (-index);
+        }
+    }
+    
+    
+   static int gcd(int a, int b)
+{
+    if (a == 0)
+        return b;
+    return gcd(b % a, a);
+}
+
+static int dp[][];
+
+
+static int f(int pos , int take , int arr[])
+{
+    if(pos == -1)
+    {
+        if(take == 0)
+    return 0;
+    
+    return -10000000;
+    
+    }
+    
+    
+    if(dp[pos][take] != -1)
+    return dp[pos][take];
+    
+    
+    if(pos+1-take == arr[pos])
+    dp[pos][take] = Math.max(dp[pos][take],1 + f(pos-1,take,arr));
+    
+    
+    dp[pos][take] = Math.max(dp[pos][take],f(pos-1,take,arr));
+    
+    
+    if(take > 0)
+    dp[pos][take] = Math.max(dp[pos][take],f(pos-1,take-1,arr));
+    
+    return dp[pos][take];
+}
+    public static void main(String []args) throws IOException
+    {
+        Scanner sc = new Scanner(System.in);
+        int t = sc.nextInt();
+        while(t-- > 0)
+        {
+            int n = sc.nextInt();
+            sc.nextLine();
+            String a = sc.nextLine();
+            String b = sc.nextLine();
+            int same = 0 , zo = 0 , oz = 0 , oo = 0 , zz = 0;
+            for(int i = 0 ; i < n ; i++)
+            {
+                if(a.charAt(i) == '0' && b.charAt(i) == '1')
+                oz++;
+                
+                else if(a.charAt(i) == '1' && b.charAt(i) == '0')
+                zo++;
+                
+                else if(a.charAt(i) == '1' && b.charAt(i) == '1')
+                oo++;
+                
+                else
+                zz++;
+            }
+            
+            if(oz == zo || (zz == oo-1))
+            {
+                int mx = Integer.MAX_VALUE;
+                if(oz == zo)
+                mx = Math.min(mx,2*oz);
+                
+                if(oo-1 == zz)
+                mx = Math.min(mx,zz+oo);
+                
+                System.out.println(mx);
+            }
+            
+            else
+            {
+                System.out.println(-1);
+            }
+        }
+    }
+}","import javax.swing.plaf.IconUIResource;
+import java.lang.reflect.Array;
+import java.text.CollationElementIterator;
+import java.util.*;
+import java.io.*;
+ 
+//Timus judge id- 323935JJ
+ 
+ 
+public class Main {
+ 
+ 
+ 
+ 
+    //----------------------------------------------------------------------------------------------
+    public static class Pair implements Comparable<Pair> {
+        int x=0,y=0;
+        int z=0;
+        public Pair(int a, int b) {
+            this.x=a;
+            this.y=b;
+ 
+        }
+ 
+        public int compareTo(Pair o) {
+            return this.x - o.x;
+        }
+    }
+ 
+ 
+    public static int mod = (int) (1e9 + 7);
+    static int ans = Integer.MAX_VALUE;
+ 
+    public static void main(String hi[]) throws Exception {
+        FastReader sc = new FastReader();
+        int t =sc.nextInt();
+        while(t-->0)
+        {
+            int n =sc.nextInt();
+            String a = sc.nextLine(),b=sc.nextLine();
+ 
+            int count1=0,count2=0,count3=0,count4=0;
+ 
+            for(int i=0;i<n;i++)
+            {
+                if(a.charAt(i)=='0'&&b.charAt(i)=='0')
+                    count1++;
+                else  if(a.charAt(i)=='1'&&b.charAt(i)=='1')
+                    count2++;
+                else  if(a.charAt(i)=='1'&&b.charAt(i)=='0')
+                    count3++;
+                else  if(a.charAt(i)=='0'&&b.charAt(i)=='1')
+                    count4++;
+            }
+            int ans=Integer.MAX_VALUE;
+ 
+            if(count3==count4)
+                ans=Math.min(count3*2,ans);
+ 
+            if(count2==count1+1)
+                ans=Math.min(ans,2*count1+1);
+ 
+           
+            if(ans==Integer.MAX_VALUE)
+                System.out.println(-1);
+            else System.out.println(ans);
+ 
+        }
+ 
+    }
+ 
+    static int find(int[] a,int x)
+    {
+        if(a[x]==-1)
+            return x;
+        else return find(a,a[x]);
+    }
+ 
+ 
+ 
+ 
+ 
+    static int gcd(int a, int b)
+    {
+        if (a == 0)
+            return b;
+        return gcd(b % a, a);
+    }
+ 
+    // method to return LCM of two numbers
+    static int lcm(int a, int b)
+    {
+        return (a / gcd(a, b)) * b;
+    }
+ 
+ 
+    static long gcdl(long a, long b)
+    {
+        if (a == 0)
+            return b;
+        return gcdl(b % a, a);
+    }
+ 
+    // method to return LCM of two numbers
+    static long lcml(long a, long b)
+    {
+        return (a / gcdl(a, b)) * b;
+    }
+ 
+ 
+    static class FastReader {
+        BufferedReader br;
+        StringTokenizer st;
+ 
+        public FastReader() {
+            br = new BufferedReader(new
+                    InputStreamReader(System.in));
+        }
+ 
+        String next() {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+ 
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+ 
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+ 
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+ 
+        String nextLine() {
+            String str = """";
+            try {
+                str = br.readLine();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+ 
+        }
+    }
+}
+ ",0
+6f393cfe,d61f51c5,"import java.io.*;
+import java.util.*;
+
+public class C {
+
+    public static void main(String[] args) throws Exception{
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
+        try{
+            int t = Integer.parseInt(br.readLine());
+            while(t-->0){
+                int n = Integer.parseInt(br.readLine());
+                int lst[][] = new int[n][5];
+                for(int i=0; i<n; i++){
+                    String s = br.readLine();
+                    for(int j=0; j<s.length(); j++){
+                        lst[i][s.charAt(j)-'a']++;
+                    }
+                }
+                int fans = Integer.MIN_VALUE;
+                for(int i=0; i<5; i++){
+                    int val[] = new int[n];
+                    for(int k=0; k<n; k++){
+                        int sum = 0;
+                        for(int j=0; j<5; j++){
+                            if(i==j){
+                                sum += lst[k][j];
+                            }else{
+                                sum -= lst[k][j];
+                            }
+                        }
+                        val[k] = sum;
+                    }
+                    Arrays.sort(val);
+                    int sum = 0;
+                    int ans = 0;
+                    for(int x = n-1; x>=0; x--){
+                        sum+=val[x];
+                        if(sum>0){
+                            ans++;
+                        }else{
+                            break;
+                        }
+                    }
+                    fans = Math.max(fans, ans);
+                }
+                bw.write(fans+""\n"");
+            }
+            bw.flush();
+        }catch(Exception e){
+            return;
+        }
+    }
+    
+}","
+/*
+ 
+    /$$$$$  /$$$$$$  /$$    /$$  /$$$$$$                                                                  
+   |__  $$ /$$__  $$ |$$    |$$ /$$__  $$                                                                 
+          | $$| $$  \ $$|    $$|$$| $$  \ $$                                                                 
+          | $$| $$$$$$$$|  $$ / $$/| $$$$$$$$                                                                 
+/ $$  | $$| $$__  $$ \  $$ $$/ | $$__  $$                                                                 
+| $$  | $$| $$  | $$  \  $$$/  | $$  | $$                                                                 
+|  $$$$$$/| $$  | $$   \  $/   | $$  | $$                                                                 
+ \______/ |__/  |__/    \_/    |__/  |__/    
+ 
+/$$$$$$$  /$$$$$$$   /$$$$$$   /$$$$$$  /$$$$$$$   /$$$$$$  /$$      /$$ /$$      /$$ /$$$$$$$$ /$$$$$$$ 
+| $$__  $$| $$__  $$ /$$__  $$ /$$__  $$| $$__  $$ /$$__  $$| $$$    /$$$| $$$    /$$$| $$_____/| $$__  $$
+| $$  \ $$| $$  \ $$| $$  \ $$| $$  \__/| $$  \ $$| $$  \ $$| $$$$  /$$$$| $$$$  /$$$$| $$      | $$  \ $$
+| $$$$$$$/| $$$$$$$/| $$  | $$| $$ /$$$$| $$$$$$$/| $$$$$$$$| $$ $$/$$ $$| $$ $$/$$ $$| $$$$$   | $$$$$$$/
+| $$____/ | $$__  $$| $$  | $$| $$|_  $$| $$__  $$| $$__  $$| $$  $$$| $$| $$  $$$| $$| $$__/   | $$__  $$
+| $$      | $$  \ $$| $$  | $$| $$  \ $$| $$  \ $$| $$  | $$| $$\  $ | $$| $$\  $ | $$| $$      | $$  \ $$
+| $$      | $$  | $$|  $$$$$$/|  $$$$$$/| $$  | $$| $$  | $$| $$ \/  | $$| $$ \/  | $$| $$$$$$$$| $$  | $$
+|__/      |__/  |__/ \______/  \______/ |__/  |__/|__/  |__/|__/     |__/|__/     |__/|________/|__/  |__/
+                                                                                                                                                                                                                
+                                                                                                                                                                                                                
+ 
+*/
+
+import java.util.*;
+import java.lang.*;
+import java.io.*;
+
+public class InterestingStrory {
+    public static void main(String[] args) throws java.lang.Exception {
+        // your code goes here
+        try {
+            // Scanner sc=new Scanner(System.in);
+            FastReader sc = new FastReader();
+            int t =sc.nextInt();
+            while (t-- > 0) {
+                int n=sc.nextInt();
+                int[][] occ=new int[n][5];
+                for(int i=0;i<n;i++){
+                    char[] warr=sc.next().toCharArray();
+                    for(char ch:warr){
+                        occ[i][ch-'a']++;
+                    }
+                }
+                int ans=Integer.MIN_VALUE;;
+                for(int c=0;c<5;c++){
+                    int[] sums=new int[n];
+                    for(int i=0;i<n;i++){
+                        int sum=0;
+                        for(int j=0;j<5;j++){
+                            if(c==j){
+                                sum+=occ[i][j];
+                            }
+                            else{
+                                sum-=occ[i][j];
+                            }
+                        }
+                        sums[i]=sum;
+                    }
+                    Arrays.sort(sums);
+                    int currSum=0;
+                    int l=n-1;
+                    for(l=n-1;l>=0;l--){
+                        if(currSum+sums[l]<=0){
+                            break;
+                        }
+                        else{
+                            currSum+=sums[l];
+                        }
+                    }
+                    ans=Math.max(ans,n-l-1);
+                }
+                System.out.println(ans);
+            }
+        } catch (Exception e) {
+            return;
+        }
+
+    }
+    
+
+    static int BS(int[] arr, int l, int r, int element) {
+        int low = l;
+        int high = r;
+        while (high - low > 1) {
+            int mid = low + (high - low) / 2;
+            if (arr[mid] < element) {
+                low = mid + 1;
+            } else {
+                high = mid;
+            }
+        }
+        if (arr[low] == element) {
+            return low;
+        } else if (arr[high] == element) {
+            return high;
+        }
+        return -1;
+    }
+
+    static int lower_bound(int[] arr, int l, int r, int element) {
+        int low = l;
+        int high = r;
+        while (high - low > 1) {
+            int mid = low + (high - low) / 2;
+            if (arr[mid] < element) {
+                low = mid + 1;
+            } else {
+                high = mid;
+            }
+        }
+        if (arr[low] >= element) {
+            return low;
+        } else if (arr[high] >= element) {
+            return high;
+        }
+        return -1;
+    }
+
+    static int upper_bound(int[] arr, int l, int r, int element) {
+        int low = l;
+        int high = r;
+        while (high - low > 1) {
+            int mid = low + (high - low) / 2;
+            if (arr[mid] <= element) {
+                low = mid + 1;
+            } else {
+                high = mid;
+            }
+        }
+        if (arr[low] > element) {
+            return low;
+        } else if (arr[high] > element) {
+            return high;
+        }
+        return -1;
+    }
+    public static long gcd_long(long a,long b){
+        //a/b,a-> dividant b-> divisor
+        if(b==0)return a;
+        return gcd_long(b, a%b);
+    }
+    public static int gcd_int(int a,int b){
+        //a/b,a-> dividant b-> divisor
+        if(b==0)return a;
+        return gcd_int(b, a%b);
+    }
+    public static int lcm(int a,int b){
+        int gcd=gcd_int(a, b);
+        return (a*b)/gcd;
+    }
+
+    static class FastReader {
+        BufferedReader br;
+        StringTokenizer st;
+
+        public FastReader() {
+            br = new BufferedReader(new InputStreamReader(System.in));
+        }
+
+        String next() {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        String nextLine() {
+            String s = """";
+            try {
+                s = br.readLine();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            return s;
+        }
+
+        Long nextLong() {
+            return Long.parseLong(next());
+        }
+    }
+}
+
+/*
+ * public static boolean lie(int n,int m,int k){ if(n==1 && m==1 && k==0){
+ * return true; } if(n<1 || m<1 || k<0){ return false; } boolean
+ * tc=lie(n-1,m,k-m); boolean lc=lie(n,m-1,k-n); if(tc || lc){ return true; }
+ * return false; }
+ */
+",1
+24afd00e,279e274a,"/*
+    JAI MATA DI
+ */
+
+import java.util.*;
+import java.io.*;
+import java.math.BigInteger;
+import java.sql.Array;
+public class CP {
+	  static class FR{
+			BufferedReader br;
+			StringTokenizer st;
+			public FR() {
+				br = new BufferedReader(new InputStreamReader(System.in));
+			}
+			String next() 
+		    { 
+		        while (st == null || !st.hasMoreElements()) 
+		        { 
+		            try
+		            { 
+		                st = new StringTokenizer(br.readLine()); 
+		            } 
+		            catch (IOException  e) 
+		            { 
+		                e.printStackTrace(); 
+		            } 
+		        } 
+		        return st.nextToken(); 
+		    } 
+
+		    int nextInt() 
+		    { 
+		        return Integer.parseInt(next()); 
+		    } 
+
+		    long nextLong() 
+		    { 
+		        return Long.parseLong(next()); 
+		    } 
+
+		    double nextDouble() 
+		    { 
+		        return Double.parseDouble(next()); 
+		    } 
+
+		    String nextLine() 
+		    { 
+		        String str = """"; 
+		        try
+		        { 
+		            str = br.readLine(); 
+		        } 
+		        catch (IOException e) 
+		        { 
+		            e.printStackTrace(); 
+		        } 
+		        return str; 
+		    } 
+		}
+	 static int mod  = 1000000007;
+	 static int gcd(int a, int b)
+	  {      
+	     if (b == 0)
+	        return a;
+	     return gcd(b, a % b); 
+	  }
+	 static long gcd(long a, long b)
+	  {      
+	     if (b == 0)
+	        return a;
+	     return gcd(b, a % b); 
+	  }
+	 static boolean[] prime(int num) {
+			boolean[] bool = new boolean[num];
+		     
+		      for (int i = 0; i< bool.length; i++) {
+		         bool[i] = true;
+		      }
+		      for (int i = 2; i< Math.sqrt(num); i++) {
+		         if(bool[i] == true) {
+		            for(int j = (i*i); j<num; j = j+i) {
+		               bool[j] = false;
+		            }
+		         }
+		      }
+		      if(num >= 0) {
+		    	  bool[0] = false;
+		    	  bool[1] = false;
+		      }
+		      
+		      return bool;
+		}
+	
+	 
+
+/* ***************************************************************************************************************************************************/	 
+	 static FR sc = new FR();
+	 static StringBuilder sb = new StringBuilder();
+	 public static void main(String args[]) {
+		 int tc = sc.nextInt();
+	
+		 while(tc-- > 0) {
+			 TEST_CASE();
+		 }
+			System.out.println(sb);
+		 }		
+
+		static void TEST_CASE() {
+		int n = sc.nextInt();
+		 lr = new long[n][2];
+		for(int  i =0 ; i < n ; i ++) {
+			lr[i][0] = sc.nextLong();
+			lr[i][1] = sc.nextLong();
+		}
+		 adj = new ArrayList<ArrayList<Integer>>();
+		for(int i = 0 ; i <n ; i++) adj.add(new ArrayList<Integer>());
+		
+		for(int i = 0 ; i<n-1 ; i++) {
+			int u = sc.nextInt()-1 , v = sc.nextInt()-1;
+			adj.get(u).add(v);
+			adj.get(v).add(u);
+		}
+		min = new long[n];
+		max = new long[n];
+		dfs(0,-1);
+		sb.append(Math.max(min[0], max[0])).append(""\n"");
+		
+		}
+		static long[] min , max , lr[];
+		static ArrayList<ArrayList<Integer>> adj;
+		static void dfs(int u , int p  ) {
+			
+			for(int child:adj.get(u)) {
+				if(child == p) continue;
+				dfs(child , u);
+			}
+			long left = lr[u][0] , right = lr[u][1];
+			
+			long ansl = 0 , ansr = 0;
+			for(int child:adj.get(u)) {
+				if(child == p) continue;
+				long leftc = lr[child][0] , rightc = lr[child][1];
+				ansl += Math.max( min[child] + Math.abs(left - leftc)  ,
+						max[child] +Math.abs(left - rightc)      );
+			}
+			for(int child:adj.get(u)) {
+				if(child == p) continue;
+				long leftc = lr[child][0] , rightc = lr[child][1];
+				ansr += Math.max( min[child] + Math.abs(right - leftc)  ,
+						max[child] +Math.abs(right - rightc)      );
+			}
+			min[u] = ansl;
+			max[u] = ansr;
+			
+		}
+		
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+","import java.io.*;
+import java.util.*;
+
+public class C {
+    static class FastReader {
+        BufferedReader br;
+        StringTokenizer st;
+
+        public FastReader() {
+            br = new BufferedReader(new
+                    InputStreamReader(System.in));
+        }
+
+        String next() {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+
+        String nextLine() {
+            String str = """";
+            try {
+                str = br.readLine();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+        }
+    }
+
+    static FastReader s = new FastReader();
+    static PrintWriter out = new PrintWriter(System.out);
+
+    private static int[] rai(int n) {
+        int[] arr = new int[n];
+        for (int i = 0; i < n; i++) {
+            arr[i] = s.nextInt();
+        }
+        return arr;
+    }
+
+    private static int[][] rai(int n, int m) {
+        int[][] arr = new int[n][m];
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < m; j++) {
+                arr[i][j] = s.nextInt();
+            }
+        }
+        return arr;
+    }
+
+    private static long[] ral(int n) {
+        long[] arr = new long[n];
+        for (int i = 0; i < n; i++) {
+            arr[i] = s.nextLong();
+        }
+        return arr;
+    }
+
+    private static long[][] ral(int n, int m) {
+        long[][] arr = new long[n][m];
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < m; j++) {
+                arr[i][j] = s.nextLong();
+            }
+        }
+        return arr;
+    }
+
+    private static int ri() {
+        return s.nextInt();
+    }
+
+    private static long rl() {
+        return s.nextLong();
+    }
+
+    private static String rs() {
+        return s.next();
+    }
+
+    static long gcd(long a,long b)
+    {
+        if(b==0)
+        {
+            return a;
+        }
+        return gcd(b,a%b);
+    }
+
+    static int gcd(int a,int b)
+    {
+        if(b==0)
+        {
+            return a;
+        }
+        return gcd(b,a%b);
+    }
+
+    static boolean isPrime(int n) {
+        //check if n is a multiple of 2
+        if (n % 2 == 0) return false;
+        //if not, then just check the odds
+        for (int i = 3; i <= Math.sqrt(n); i += 2) {
+            if (n % i == 0)
+                return false;
+        }
+        return true;
+    }
+    static int MOD=1000000007;
+
+    static long mpow(long base,long pow)
+    {
+        long res=1;
+        while(pow>0)
+        {
+            if(pow%2==1)
+            {
+                res=(res*base)%MOD;
+            }
+            pow>>=1;
+            base=(base*base)%MOD;
+        }
+        return res;
+    }
+
+    static long[][] dp;
+    static void dfs(List<Integer>[] list, long[] l, long[] r, boolean[] vis,int node)
+    {
+        vis[node] = true;
+
+        for(int i:list[node])
+        {
+            if(!vis[i])
+            {
+                dfs(list,l,r,vis, i);
+                dp[node][0] += Math.max(dp[i][0]+Math.abs(l[node]-l[i]), dp[i][1]+Math.abs(l[node]-r[i]));
+                dp[node][1] += Math.max(dp[i][0]+Math.abs(r[node]-l[i]), dp[i][1]+Math.abs(r[node]-r[i]));
+            }
+
+        }
+    }
+    public static void main(String[] args) {
+        StringBuilder ans = new StringBuilder();
+        int t = ri();
+//        int t = 1;
+        while (t-- > 0)
+        {
+            int n=ri();
+            dp = new long[n][2];
+            long[] l = new long[n];
+            long[] r = new long[n];
+            for(int i=0;i<n;i++)
+            {
+                l[i] = rl();
+                r[i] = rl();
+
+            }
+
+            List<Integer>[] list=new ArrayList[n];
+            for(int i=0;i<n;i++)
+            {
+                list[i] = new ArrayList<>();
+            }
+
+            for(int i=0;i<n-1;i++)
+            {
+                int a= ri();int b=ri();
+                a--;b--;
+                list[a].add(b);
+                list[b].add(a);
+            }
+
+            boolean[] vis = new boolean[n];
+            dfs(list,l,r,vis,0);
+
+//            for(int i=0;i<n;i++)
+//            {
+//                System.out.println(Arrays.toString(dp[i]));
+//            }
+
+            ans.append(Math.max(dp[0][0],dp[0][1])).append(""\n"");
+
+        }
+        out.print(ans.toString());
+        out.flush();
+    }
+
+
+
+}",0
+115c99cb,548ffb07,"import java.io.*;
+import java.util.*;
+
+public class D_Java {
+	public static final int MOD = 998244353;
+	
+	public static int mul(int a, int b) {
+		return (int)((long)a * (long)b % MOD);
+	}
+	
+	int[] f;
+	int[] rf;
+	
+	public int C(int n, int k) {
+		return (k < 0 || k > n) ? 0 : mul(f[n], mul(rf[n-k], rf[k]));
+	}
+	
+	public static int pow(int a, int n) {
+		int res = 1;
+		while (n != 0) {
+			if ((n & 1) == 1) {
+				res = mul(res, a);
+			}
+			a = mul(a, a);
+			n >>= 1;
+		}
+		return res;
+	}
+	
+	static void shuffleArray(int[] a) {
+		Random rnd = new Random();
+		for (int i = a.length-1; i > 0; i--) {
+			int index = rnd.nextInt(i + 1);
+			int tmp = a[index];
+			a[index] = a[i];
+			a[i] = tmp;
+		}
+	}
+	
+	public static int inv(int a) {
+		return pow(a, MOD-2);
+	}
+	
+	public void doIt() throws IOException {
+		BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
+		
+		StringTokenizer tok = new StringTokenizer(in.readLine());
+		int n = Integer.parseInt(tok.nextToken());
+		int k = Integer.parseInt(tok.nextToken());
+		
+		f = new int[n+42];
+		rf = new int[n+42];
+		f[0] = rf[0] = 1;
+		for (int i = 1; i < f.length; ++i) {
+			f[i] = mul(f[i-1], i);
+			rf[i] = mul(rf[i-1], inv(i));
+		}
+		
+		int[] events = new int[2*n];
+		for (int i = 0; i < n; ++i) {
+			tok = new StringTokenizer(in.readLine());
+			int le = Integer.parseInt(tok.nextToken());
+			int ri = Integer.parseInt(tok.nextToken());
+			events[i] = le*2;
+			events[i + n] = ri*2 + 1;
+		}
+		shuffleArray(events);
+		Arrays.sort(events);
+		
+		int ans = 0;
+		int balance = 0;
+		for (int r = 0; r < 2*n;) {
+			int l = r;
+			while (r < 2*n && events[l] == events[r]) {
+				++r;
+			}
+			int added = r - l;
+			if (events[l] % 2 == 0) {
+				// Open event
+				ans += C(balance + added, k);
+				if (ans >= MOD) ans -= MOD;
+				ans += MOD - C(balance, k);
+				if (ans >= MOD) ans -= MOD;
+				balance += added;
+			} else {
+				// Close event
+				balance -= added;
+			}
+		}
+		
+		in.close();
+		System.out.println(ans);
+	}
+	
+	public static void main(String[] args) throws IOException {
+		(new D_Java()).doIt();
+	}
+}","import java.io.*;
+import java.util.*;
+
+public class D_Java {
+	public static final int MOD = 998244353;
+	
+	public static int mul(int a, int b) {
+		return (int)((long)a * (long)b % MOD);
+	}
+	
+	int[] f;
+	int[] rf;
+	
+	public int C(int n, int k) {
+		return (k < 0 || k > n) ? 0 : mul(f[n], mul(rf[n-k], rf[k]));
+	}
+	
+	public static int pow(int a, int n) {
+		int res = 1;
+		while (n != 0) {
+			if ((n & 1) == 1) {
+				res = mul(res, a);
+			}
+			a = mul(a, a);
+			n >>= 1;
+		}
+		return res;
+	}
+	
+	static void shuffleArray(int[] a) {
+		Random rnd = new Random();
+		for (int i = a.length-1; i > 0; i--) {
+			int index = rnd.nextInt(i + 1);
+			int tmp = a[index];
+			a[index] = a[i];
+			a[i] = tmp;
+		}
+	}
+	
+	public static int inv(int a) {
+		return pow(a, MOD-2);
+	}
+	
+	public void doIt() throws IOException {
+		BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
+		
+		StringTokenizer tok = new StringTokenizer(in.readLine());
+		int n = Integer.parseInt(tok.nextToken());
+		int k = Integer.parseInt(tok.nextToken());
+		
+		f = new int[n+42];
+		rf = new int[n+42];
+		f[0] = rf[0] = 1;
+		for (int i = 1; i < f.length; ++i) {
+			f[i] = mul(f[i-1], i);
+			rf[i] = mul(rf[i-1], inv(i));
+		}
+		
+		int[] events = new int[2*n];
+		for (int i = 0; i < n; ++i) {
+			tok = new StringTokenizer(in.readLine());
+			int le = Integer.parseInt(tok.nextToken());
+			int ri = Integer.parseInt(tok.nextToken());
+			events[i] = le*2;
+			events[i + n] = ri*2 + 1;
+		}
+		shuffleArray(events);
+		Arrays.sort(events);
+		
+		int ans = 0;
+		int balance = 0;
+		for (int r = 0; r < 2*n;) {
+			int l = r;
+			while (r < 2*n && events[l] == events[r]) {
+				++r;
+			}
+			int added = r - l;
+			if (events[l] % 2 == 0) {
+				// Open event
+				ans += C(balance + added, k);
+				if (ans >= MOD) ans -= MOD;
+				ans += MOD - C(balance, k);
+				if (ans >= MOD) ans -= MOD;
+				balance += added;
+			} else {
+				// Close event
+				balance -= added;
+			}
+		}
+		
+		in.close();
+		System.out.println(ans);
+	}
+	
+	public static void main(String[] args) throws IOException {
+		(new D_Java()).doIt();
+	}
+}
+",1
+9ed0ece8,c48673a6,"import java.io.*;
+import java.util.*;
+
+public class C {
+
+	public static void main(String[] args) {
+        FastScanner in = new FastScanner();
+        PrintWriter out = new PrintWriter(System.out);
+        int t = in.nextInt();
+        while(t-->0) { 
+        	int n = in.nextInt();
+        	int a[] = in.readArray(n);
+        	int a1[] = new int[(n+1)/2];
+        	int a2[] = new int[n/2];
+        	int ind1 = 0, ind2 = 0;
+        	for(int i=0;i<n;i++){
+        		if(i%2==0) a1[ind1++] = a[i];
+        		else a2[ind2++] = a[i];
+        	}
+        	int n1 = a1.length, n2 = a2.length;                  
+        	long p1[] = new long[n1], p2[] = new long[n2];
+        	p1[0] = a1[0]; p2[0] = a2[0];
+        	for(int i=1;i<n1;i++) p1[i] = p1[i-1] + a1[i];
+        	for(int i=1;i<n2;i++) p2[i] = p2[i-1] + a2[i];
+        	long ans1[] = new long[n1];
+        	long ans2[] = new long[n2];
+        	ans1[0] = p1[0]*n;
+        	ans2[0] = p2[0]*n;
+        	
+        	long mn = a1[0];
+        	for(int i=1;i<n1;i++){
+        		ans1[i] = p1[i];
+        		mn = Math.min(mn,a1[i]);
+        		ans1[i] -= mn;
+        		ans1[i] += mn*(n-i);	
+        	}
+        	mn = a2[0];
+        	for(int i=1;i<n2;i++){
+        		ans2[i] = p2[i];
+        		mn = Math.min(mn,a2[i]);
+        		ans2[i] -= mn;
+        		ans2[i] += mn*(n-i);	
+        	}                    
+        	long cost = Long.MAX_VALUE;
+        	for(int i=0;i<n1;i++){
+        		if(i==n2){
+        			cost = Math.min(cost,ans1[i]+ans2[i-1]);
+        		}
+        		else{
+        			cost = Math.min(cost,ans1[i]+ans2[i]);
+        			if(i-1>-1) cost = Math.min(cost,ans1[i]+ans2[i-1]);
+        		}
+        	}
+        	out.println(cost);
+       	}
+        out.flush();
+	}
+	
+	static class FastScanner {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st = new StringTokenizer("""");
+		
+		String next() {
+			while(!st.hasMoreTokens())
+				try { st = new StringTokenizer(br.readLine()); }
+				catch(IOException e) {}
+			return st.nextToken();
+		}
+		
+		String nextLine(){
+			try{ return br.readLine(); } 
+			catch(IOException e) { } return """";
+		}
+		
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+		
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+		
+		int[] readArray(int n) {
+			int a[] = new int[n];
+			for(int i=0;i<n;i++) a[i] = nextInt();
+			return a;
+		}
+	}
+
+	static final Random random = new Random();
+
+	static void ruffleSort(int[] a){
+		int n = a.length;
+		for(int i=0;i<n;i++){
+			int j = random.nextInt(n), temp = a[j];
+			a[j] = a[i]; a[i] = temp;
+		}
+		Arrays.sort(a); 	
+	}
+}
+
+","import java.io.*;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.StringTokenizer;
+
+public class C {
+    public static void main(String[] args) {
+        new C().solve(System.in, System.out);
+    }
+
+    public void solve(InputStream in, OutputStream out) {
+        InputReader inputReader = new InputReader(in);
+        PrintWriter writer = new PrintWriter(new BufferedOutputStream(out));
+
+        int t = inputReader.nextInt();
+        for (int t1 = 0; t1 < t; t1++) {
+            int n = inputReader.nextInt();
+            List<Long> c = new ArrayList<>(n);
+            for (int i = 0; i < n; i++) {
+                c.add(inputReader.nextLong());
+            }
+            writer.println(solve(n, c));
+        }
+
+        writer.close();
+    }
+
+    public long solve(int n, List<Long> c) {
+        long[] minEven = new long[n];
+        long[] minOdd = new long[n];
+        long[] sumOdd = new long[n];
+        long[] sumEven = new long[n];
+
+        minEven[0] = Long.MAX_VALUE;
+        minOdd[0] = Long.MAX_VALUE;
+
+        for (int i = 0; i < n; i++) {
+            if (i > 0) {
+                minEven[i] = minEven[i - 1];
+                minOdd[i] = minOdd[i - 1];
+                sumOdd[i] = sumOdd[i - 1];
+                sumEven[i] = sumEven[i - 1];
+            }
+            if (i % 2 == 0) {
+                minEven[i] = Math.min(minEven[i], c.get(i));
+                sumEven[i] += c.get(i);
+            } else {
+                minOdd[i] = Math.min(minOdd[i], c.get(i));
+                sumOdd[i] += c.get(i);
+            }
+        }
+
+        long best = Long.MAX_VALUE;
+        for (int k = 1; k < n; k++) {
+            int countOdd = (k + 1) / 2;
+            int countEven = (k + 1) / 2;
+            if (k % 2 == 0) {
+                countEven++;
+            }
+            long oddResult = minOdd[k] * (n - countOdd) + sumOdd[k];
+            long evenResult = minEven[k] * (n - countEven) + sumEven[k];
+            long current = oddResult + evenResult;
+            best = Math.min(best, current);
+        }
+        return best;
+    }
+
+    private static class InputReader {
+        public BufferedReader reader;
+        public StringTokenizer tokenizer;
+
+        public InputReader(InputStream stream) {
+            reader = new BufferedReader(new InputStreamReader(stream), 32768);
+            tokenizer = null;
+        }
+
+        public String next() {
+            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
+                try {
+                    tokenizer = new StringTokenizer(reader.readLine());
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+            }
+            return tokenizer.nextToken();
+        }
+
+        public int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        public long nextLong() {
+            return Long.parseLong(next());
+        }
+    }
+}
+",0
+d6fb3b9e,f7a0ea6d,"import java.util.*;
+public class Sol
+{
+    public static void main(String[] args)
+    {
+        Scanner sc = new Scanner(System.in);
+        int t = sc.nextInt();
+        while(t-->0)
+        {
+			int n = sc.nextInt();
+			int a[][]=new int[n][5];
+			int tot[]=new int[n];
+			for(int i=0;i<n;i++)
+			{
+				String x = sc.next();
+				for(int j=0;j<x.length();j++)
+					a[i][x.charAt(j)-'a'] += 1;
+				tot[i]=x.length();
+			}
+			
+			int max=Integer.MIN_VALUE;
+			for(int i=0;i<5;i++)
+				max=Math.max(max,function(a,n,i,tot));
+			System.out.println(max);
+			
+		}	
+    }
+	static int function(int a[][],int n,int i,int tot[])
+	{
+		Integer ans[] = new Integer[n];
+		for(int j=0;j<n;j++)
+			ans[j]=a[j][i]-(tot[j]-a[j][i]);
+		int res=0,j=0;
+		Arrays.sort(ans,Collections.reverseOrder());
+		while(j<n&&res+ans[j]>0)
+			res+=ans[j++];
+		return j;
+	}
+}
+","import java.util.*;
+
+public class Solution {
+	
+	private static Scanner in = new Scanner(System.in);
+	
+	public static void main(String args[]) {
+		
+		int t = in.nextInt();
+		
+		while(t-->0) {
+			solution();
+		}
+	}
+	
+	private static void solution() {
+		
+		int ans=0;
+		int n = in.nextInt();
+		String s[] = new String[n];
+		int occurance[][] = new int[n][5];
+		for(int i=0;i<n;i++) {
+			s[i] = in.next();
+			for(int j=0;j<s[i].length();j++) {
+				occurance[i][s[i].charAt(j)-'a']++;
+			}
+		}
+		
+//		for(int i=0;i<n;i++)
+//		{
+//			for(int j=0;j<5;j++)
+//				System.out.println(occurance[i][j]);
+//			System.out.println();
+//		}
+		
+		for(int i=0;i<5;i++) {
+			int arr[] = new int[n];
+			for(int j=0;j<n;j++) {
+				arr[j] = s[j].length() - (2 * occurance[j][i]);
+			}
+			Arrays.sort(arr);
+			
+//			for(int j=0;j<n;j++)
+//				System.out.println(arr[j]);
+			
+			int temp=0;
+			int count=0;
+			for(int j=0;j<n;j++) {
+				if(temp+arr[j] < 0)
+				{
+					count++;
+					temp += arr[j];
+				}
+				else 
+					break;
+			}
+			ans = Math.max(ans, count);
+		}
+		System.out.println(ans);
+	}
+}",0
+6a47e491,f2cf6a74,"
+import java.util.Arrays;
+import java.util.Random;
+import java.util.Scanner;
+
+public class InterestingStory {
+
+    public static void main(String args[]) {
+        Scanner scan = new Scanner(System.in);
+        int t = scan.nextInt();
+        while (t-- > 0) {
+            int n = scan.nextInt();
+            String[] a = new String[n];
+            for (int i = 0; i < n; i++) {
+                a[i] = scan.next();
+            }
+            int res = -1;
+            int[] st = new int[n];
+            for (int i = 0; i < n; i++) {
+                String s = a[i];
+                int c = 0;
+                for (int j = 0; j < s.length(); j++) {
+                    if (s.charAt(j) == 'a') {
+                        ++c;
+                    }
+                }
+                st[i] = ((s.length() - c) - c);
+            }
+            sort(st);
+            long sum = 0;
+            int count = 0;
+            for (int i = 0; i < n; i++) {
+                if (st[i] + sum >= 0) {
+                    break;
+                }
+                sum += st[i];
+                ++count;
+            }
+            res = Math.max(res, count);
+
+            for (int i = 0; i < n; i++) {
+                String s = a[i];
+                int c = 0;
+                for (int j = 0; j < s.length(); j++) {
+                    if (s.charAt(j) == 'b') {
+                        ++c;
+                    }
+                }
+                st[i] = ((s.length() - c) - c);
+            }
+            sort(st);
+            sum = 0;
+            count = 0;
+            for (int i = 0; i < n; i++) {
+                if (st[i] + sum >= 0) {
+                    break;
+                }
+                sum += st[i];
+                ++count;
+            }
+            res = Math.max(res, count);
+
+            for (int i = 0; i < n; i++) {
+                String s = a[i];
+                int c = 0;
+                for (int j = 0; j < s.length(); j++) {
+                    if (s.charAt(j) == 'c') {
+                        ++c;
+                    }
+                }
+                st[i] = ((s.length() - c) - c);
+            }
+            sort(st);
+            sum = 0;
+            count = 0;
+            for (int i = 0; i < n; i++) {
+                if (st[i] + sum >= 0) {
+                    break;
+                }
+                sum += st[i];
+                ++count;
+            }
+            res = Math.max(res, count);
+
+            for (int i = 0; i < n; i++) {
+                String s = a[i];
+                int c = 0;
+                for (int j = 0; j < s.length(); j++) {
+                    if (s.charAt(j) == 'd') {
+                        ++c;
+                    }
+                }
+                st[i] = ((s.length() - c) - c);
+            }
+            sort(st);
+            sum = 0;
+            count = 0;
+            for (int i = 0; i < n; i++) {
+                if (st[i] + sum >= 0) {
+                    break;
+                }
+                sum += st[i];
+                ++count;
+            }
+            res = Math.max(res, count);
+
+            for (int i = 0; i < n; i++) {
+                String s = a[i];
+                int c = 0;
+                for (int j = 0; j < s.length(); j++) {
+                    if (s.charAt(j) == 'e') {
+                        ++c;
+                    }
+                }
+                st[i] = ((s.length() - c) - c);
+            }
+            sort(st);
+            sum = 0;
+            count = 0;
+            for (int i = 0; i < n; i++) {
+                if (st[i] + sum >= 0) {
+                    break;
+                }
+                sum += st[i];
+                ++count;
+            }
+            res = Math.max(res, count);
+            System.out.println(res);
+
+        }
+    }
+
+    static final Random random = new Random();
+
+    static void sort(int[] a) {
+        int n = a.length;//shuffle, then sort 
+        for (int i = 0; i < n; i++) {
+            int oi = random.nextInt(n), temp = a[oi];
+            a[oi] = a[i];
+            a[i] = temp;
+        }
+        Arrays.sort(a);
+    }
+}
+","import java.util.*;
+public class shivam{
+    public static int diff(String str, char ch){
+        int cnt=0;
+        for(int i=0;i<str.length();i++){
+            if(ch==str.charAt(i)){
+                cnt++;
+            }
+        }
+        return cnt-(str.length()-cnt);
+    }
+    public static int process(char ch,int n,String  []arr){
+        int[]a=new int[n];
+            for(int i=0;i<n;i++){
+                a[i]=diff(arr[i],ch);
+            }
+            Arrays.sort(a);
+            int max=0;
+            int sum=0;
+            for(int i=n-1;i>=0;i--){
+                sum+=a[i];
+                if(sum>0){
+                    max++;
+                }
+                else{
+                    break;
+                }
+            }
+
+
+
+
+
+        return max;
+    }
+
+
+    public static void main(String[] args) {
+        Scanner sc=new Scanner(System.in);
+        int k=sc.nextInt();
+        while(k-->0){
+            int n=sc.nextInt();
+            String []arr=new String[n];
+            for(int i=0;i<n;i++){
+                arr[i]=sc.next();
+            }
+            int a=process('a',n,arr);
+            int b=process('b',n,arr);
+            int c=process('c',n,arr);
+            int d=process('d',n,arr);
+            int e=process('e',n,arr);
+            System.out.println(Math.max(a,Math.max(b,Math.max(c,Math.max(d,e)))));
+           
+        }
+
+    }
+}",0
+b790ef12,ff34fab2,"import java.io.*;
+import java.util.*;
+public class Main {
+    static class FastReader {
+        BufferedReader br;
+        StringTokenizer st;
+
+        public FastReader() {
+            br = new BufferedReader(
+                    new InputStreamReader(System.in));
+        }
+
+        String next() {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+
+        String nextLine() {
+            String str = """";
+            try {
+                str = br.readLine();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+        }
+    }
+
+    public static void main(String[] args) {
+        FastReader obj = new FastReader();
+        PrintWriter out = new PrintWriter(System.out);
+        int l = obj.nextInt();
+        while (l-- != 0) {
+            int n = obj.nextInt();
+            int[] num = new int[n];
+            for (int i = 0; i < n; i++) num[i] = obj.nextInt();
+            Vector<Integer> red = new Vector<>();
+            Vector<Integer> blue = new Vector<>();
+            String s = obj.next();
+            for (int i = 0; i < s.length(); i++) {
+                if (s.charAt(i) == 'R') red.add(num[i]);
+                else blue.add(num[i]);
+            }
+            Collections.sort(blue);
+            Collections.sort(red);
+            int c = 1, f = 0;
+            for (int i = 0; i < blue.size(); i++) {
+                if (blue.get(i) < c) {
+                    f = 1;
+                    break;
+                }
+                c++;
+            }
+            for (int i = 0; i < red.size(); i++) {
+                if (red.get(i) > c) {
+                    f = 1;
+                    break;
+                }
+                c++;
+            }
+            if (f == 0) out.println(""YES"");
+            else out.println(""NO"");
+        }
+        out.flush();
+    }
+}
+","import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.PriorityQueue;
+import java.util.Queue;
+import java.util.Stack;
+import java.util.StringTokenizer;
+import java.util.TreeMap;
+import java.util.TreeSet;
+
+import java.io.*;
+ 
+public class Div2 {
+	
+	private static class MyScanner {
+	    BufferedReader br;
+	    StringTokenizer st;
+
+	    public MyScanner() {
+	       br = new BufferedReader(new InputStreamReader(System.in));
+	    }
+
+	    String next() {
+	        while (st == null || !st.hasMoreElements()) {
+	            try {
+	                st = new StringTokenizer(br.readLine());
+	            } catch (IOException e) {
+	                e.printStackTrace();
+	            }
+	        }
+	        return st.nextToken();
+	    }
+
+	    int nextInt() {
+	        return Integer.parseInt(next());
+	    }
+
+	    long nextLong() {
+	        return Long.parseLong(next());
+	    }
+
+	    double nextDouble() {
+	        return Double.parseDouble(next());
+	    }
+
+	    String nextLine(){
+	        String str = """";
+		  try {
+		     str = br.readLine();
+		  } catch (IOException e) {
+		     e.printStackTrace();
+		  }
+		  return str;
+	    }
+
+	 }
+
+	 public static String solution(int [] arr, int n, String st) 
+	 {
+        ArrayList<Integer> red = new ArrayList<>();
+        ArrayList<Integer> blue = new ArrayList<>();
+        
+        for(int i = 0; i<n; i++)
+        {
+        	if(st.charAt(i)=='R')
+        		red.add(arr[i]);
+        	else
+        		blue.add(arr[i]);
+        }
+	    	
+        Collections.sort(red);
+        Collections.sort(blue);
+        int cb = 1;
+        
+        for(int j = 0; j<blue.size(); j++)
+        {
+            if(blue.get(j)<cb)
+            	return ""NO"";
+            cb++;
+        }
+        
+        int cr = n;
+        for(int j = red.size()-1; j>=0; j--)
+        {
+            if(red.get(j)>cr)
+            	return ""NO"";
+            cr--;
+        }
+        
+        return ""YES"";
+
+	 }
+        
+private static PrintWriter out = new PrintWriter(System.out);
+
+public static void main (String[] args)
+{
+	MyScanner s =  new MyScanner();
+	  
+    int t = s.nextInt();
+    
+    for(int j = 0; j<t ; j++)
+    {
+    	int n = s.nextInt();
+    	int[] arr = new int[n];
+    	for(int i =0; i<n; i++)
+    		arr[i] = s.nextInt();
+    	
+    	String st = s.next();
+   
+    	out.println(solution(arr,n, st));
+    }
+    
+		     
+    out.flush();
+    out.close();
+    
+}
+}
+
+",0
+7686c854,edce3e39,"import java.util.*;
+import java.util.function.BiFunction;
+import java.util.function.Function;
+import java.util.function.IntToLongFunction;
+import java.lang.*;
+import java.io.*;
+import java.math.*;
+public final class CF
+{
+     public static void main(String[]args)throws IOException
+    {
+        FastReader ob=new FastReader();
+        int t=ob.nextInt();
+        StringBuffer sb=new StringBuffer();
+        while(t-->0)
+        {
+            int n=ob.nextInt();
+            PriorityQueue<Long> a=new PriorityQueue<>();
+            PriorityQueue<Long> b=new PriorityQueue<>();
+            long ans=Long.MAX_VALUE;
+            long sum=0;
+            for(int i=0;i<n;i++)
+            {
+               long x=ob.nextInt();
+               if(i%2==0)
+               a.add(x);
+               else
+               b.add(x);  
+               sum+=x;
+               if(i!=0)
+               ans=Math.min(ans,sum+(a.peek()*(n-a.size()))+(b.peek()*(n-b.size())));
+            }
+            
+            sb.append(ans+""\n"");
+        }
+        System.out.println(sb);
+    }
+}
+class Pair implements Comparable<Pair>
+{
+    int x,y;
+    Pair(int x,int y)
+    {
+        this.x=x;
+        this.y=y;
+    }
+    @Override
+    public int compareTo(Pair a) {
+        return a.y-y;
+    }
+}
+class FastReader {
+    BufferedReader br;
+    StringTokenizer st;
+    public FastReader() {
+        br = new BufferedReader(new InputStreamReader(System.in));
+    }
+
+    public String next() {
+        while (st == null || !st.hasMoreElements()) {
+            try {
+                st = new StringTokenizer(br.readLine());
+            } catch (IOException e)  {
+                e.printStackTrace();
+            }
+        }
+        return st.nextToken();
+    }
+    public String nextLine()
+    {
+        String s="""";
+        try {
+        s=br.readLine();
+        } catch (IOException e)  {
+                e.printStackTrace();
+            }
+        return s;
+    }
+    public int nextInt() {
+        return Integer.parseInt(next());
+    }
+    public long nextLong() {
+        return Long.parseLong(next());
+    }
+    public double nextDouble() {
+        return Double.parseDouble(next());
+    }
+}
+","import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.*;
+
+public class CF {
+	
+	private static FS sc = new FS();
+	
+	private static class FS {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st = new StringTokenizer("""");
+		String next() {
+			while (!st.hasMoreTokens())
+				try {
+					st=new StringTokenizer(br.readLine());				               
+	            } catch (IOException e) {}
+			return st.nextToken();
+		}
+		
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+	}
+	
+	private static class extra {
+		
+		static int[] intArr(int size) {
+			int[] a = new int[size];
+			for(int i = 0; i < size; i++) a[i] = sc.nextInt();
+			return a;
+		}
+		
+		static long[] longArr(int size) {
+			long[] a = new long[size];
+			for(int i = 0; i < size; i++) a[i] = sc.nextLong();
+			return a;
+		}
+		
+		static long intSum(int[] a) {
+			long sum = 0; 
+			for(int i = 0; i < a.length; i++) {
+				sum += a[i];
+			}
+			return sum;
+		}
+		
+		static long longSum(long[] a) {
+			long sum = 0; 
+			for(int i = 0; i < a.length; i++) {
+				sum += a[i];
+			}
+			return sum;
+		}
+		
+	}
+	
+	static long count = 0;
+	
+	public static void main(String[] args) {
+		
+		int t = sc.nextInt();
+//		int t = 1;
+		StringBuilder ret = new StringBuilder();
+		while(t-- > 0) {
+			int n = sc.nextInt();
+			int[] a = extra.intArr(n);
+			PriorityQueue<Integer> c = new PriorityQueue<>();
+			PriorityQueue<Integer> d = new PriorityQueue<>();
+			long sum = 0;
+			long min = Long.MAX_VALUE;
+			for(int i = 0; i < n; i++) {
+				sum += a[i];
+				if(i%2 == 0) c.add(a[i]);
+				else d.add(a[i]);
+				if(i != 0) {
+					min = Math.min(min, sum + (n - c.size())*1L*c.peek() + (n-d.size())*1L*d.peek());
+				}
+			}
+			ret.append(min + ""\n"");
+ 		}
+		System.out.println(ret);
+	}
+}
+",1
+6653a758,f6ca6fc8,"import java.util.*;
+public class D {
+	public static void main(String[] args) {
+		Scanner sc=new Scanner(System.in);
+		ArrayList<Integer> o=new ArrayList<Integer>(), e=new ArrayList<Integer>();
+		int n = sc.nextInt(),dp[][]=new int[n+1][n+1];
+		for(int i=1;i<=n;i++){
+			int x=sc.nextInt();
+			if(x==1)o.add(i);
+			else e.add(i);
+		}
+		for(int i=1;i<=o.size();i++){
+			dp[i][i]=dp[i-1][i-1]+Math.abs(o.get(i-1)-e.get(i-1));
+			for(int j=i+1;j<=e.size();j++)
+				dp[i][j]=Math.min(dp[i][j-1],dp[i-1][j-1]+Math.abs(o.get(i-1)-e.get(j-1)));
+		}
+		System.out.println(dp[o.size()][e.size()]);
+	}
+}","import java.util.*;
+import java.io.*;
+
+public class D {
+	public static void main(String[] args) {
+		Scanner sc=new Scanner(System.in);
+		int n = sc.nextInt();
+		ArrayList<Integer>  o=new ArrayList<Integer>();
+		ArrayList<Integer>  e=new ArrayList<Integer>();
+		for(int i=1;i<=n;i++){
+			int x=sc.nextInt();
+			if(x==1)o.add(i);
+			else e.add(i);
+		}
+		int dp[][]=new int[o.size()+1][e.size()+1];
+		for(int i=1;i<=o.size();i++){
+			dp[i][i]=dp[i-1][i-1]+Math.abs(o.get(i-1)-e.get(i-1));
+			for(int j=i+1;j<=e.size();j++){
+				dp[i][j]=Math.min(dp[i][j-1],dp[i-1][j-1]+Math.abs(o.get(i-1)-e.get(j-1)));
+			}
+		}
+		System.out.println(dp[o.size()][e.size()]);
+	}
+}
+",1
+b2bae06a,d4779c71,"    import java.util.*;
+    import java.io.*;
+    public class D{
+        static class InputReader {
+
+            private final InputStream stream;
+            private final byte[] buf = new byte[8192];
+            private int curChar, snumChars;
+            private SpaceCharFilter filter;
+
+            public InputReader(InputStream stream) {
+                this.stream = stream;
+            }
+
+            public int snext() {
+                if (snumChars == -1)
+                    throw new InputMismatchException();
+                if (curChar >= snumChars) {
+                    curChar = 0;
+                    try {
+                        snumChars = stream.read(buf);
+                    } catch (IOException e) {
+                        throw new InputMismatchException();
+                    }
+                    if (snumChars <= 0)
+                        return -1;
+                }
+                return buf[curChar++];
+            }
+
+            public int nextInt() {
+                int c = snext();
+                while (isSpaceChar(c)) {
+                    c = snext();
+                }
+                int sgn = 1;
+                if (c == '-') {
+                    sgn = -1;
+                    c = snext();
+                }
+                int res = 0;
+                do {
+                    if (c < '0' || c > '9')
+                        throw new InputMismatchException();
+                    res *= 10;
+                    res += c - '0';
+                    c = snext();
+                } while (!isSpaceChar(c));
+                return res * sgn;
+            }
+
+            public long nextLong() {
+                int c = snext();
+                while (isSpaceChar(c)) {
+                    c = snext();
+                }
+                int sgn = 1;
+                if (c == '-') {
+                    sgn = -1;
+                    c = snext();
+                }
+                long res = 0;
+                do {
+                    if (c < '0' || c > '9')
+                        throw new InputMismatchException();
+                    res *= 10;
+                    res += c - '0';
+                    c = snext();
+                } while (!isSpaceChar(c));
+                return res * sgn;
+            }
+
+            public int[] nextIntArray(int n) {
+                int a[] = new int[n];
+                for (int i = 0; i < n; i++) {
+                    a[i] = nextInt();
+                }
+                return a;
+            }
+
+            public String readString() {
+                int c = snext();
+                while (isSpaceChar(c)) {
+                    c = snext();
+                }
+                StringBuilder res = new StringBuilder();
+                do {
+                    res.appendCodePoint(c);
+                    c = snext();
+                } while (!isSpaceChar(c));
+                return res.toString();
+            }
+
+            public String nextLine() {
+                int c = snext();
+                while (isSpaceChar(c))
+                    c = snext();
+                StringBuilder res = new StringBuilder();
+                do {
+                    res.appendCodePoint(c);
+                    c = snext();
+                } while (!isEndOfLine(c));
+                return res.toString();
+            }
+
+            public boolean isSpaceChar(int c) {
+                if (filter != null)
+                    return filter.isSpaceChar(c);
+                return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
+            }
+
+            private boolean isEndOfLine(int c) {
+                return c == '\n' || c == '\r' || c == -1;
+            }
+
+            public interface SpaceCharFilter {
+                public boolean isSpaceChar(int ch);
+            }
+
+        }
+        static class OutputWriter {
+            private final PrintWriter writer;
+    
+            public OutputWriter(OutputStream outputStream) {
+                writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
+            }
+    
+            public OutputWriter(Writer writer) {
+                this.writer = new PrintWriter(writer);
+            }
+    
+            public void print(Object...objects) {
+                for (int i = 0; i < objects.length; i++) {
+                    if (i != 0)
+                        writer.print(' ');
+                    writer.print(objects[i]);
+                }
+            }
+    
+            public void printLine(Object...objects) {
+                print(objects);
+                writer.println();
+            }
+    
+            public void close() {
+                writer.close();
+            }
+    
+            public void flush() {
+                writer.flush();
+            }
+    
+            }
+        static int gcd(int a, int b) 
+        { 
+            if (a == 0) 
+                return b; 
+            return gcd(b % a, a); 
+        } 
+        static int mod = (int)(1e9+7);
+        public static long pow(long a,long b)
+        {
+            long ans = 1;
+            while(b> 0)
+            {
+                if((b & 1)==1){
+                    ans = (ans*a) % mod; 
+                }
+                a = (a*a) % mod;
+                b = b>>1;
+            }
+            return ans;
+        }
+
+        public static void main(String[] args) {
+            InputReader in = new InputReader(System.in);
+            OutputWriter out = new OutputWriter(System.out);
+            int n = in.nextInt();
+            int[] arr = in.nextIntArray(n);
+            Stack<Integer> min = new Stack<>();
+            Stack<Integer> max = new Stack<>();
+            int[] dp = new int[n];
+            // Arrays.fill(dp,(int)1e9);
+            dp[0] = 0;
+            min.push(0);
+            max.push(0);
+            for(int i=1;i<n;i++)
+            {
+                int h=dp[i-1]+1;
+                while(!max.isEmpty() && arr[i]>arr[max.peek()])
+                {
+                    int x = arr[max.peek()];
+                    h = Math.min(h,1+dp[max.pop()]);
+                    while(!max.isEmpty() && arr[max.peek()]==x)
+                    {
+                        max.pop();
+                    }
+                }
+                if(!max.isEmpty())
+                {
+                    h = Math.min(h,1+dp[max.peek()]);
+                }
+                while(!min.isEmpty() && arr[i]<arr[min.peek()])
+                {
+                    int x = arr[min.peek()];
+                    h = Math.min(h,1+dp[min.pop()]);
+                    while(!min.isEmpty() && arr[min.peek()]==x)
+                    {
+                        min.pop();
+                    }
+                }
+                if(!min.isEmpty())
+                {
+                    h = Math.min(h,1+dp[min.peek()]);
+                }
+                dp[i] = h;
+                min.push(i);
+                max.push(i);
+            }
+            out.printLine(dp[n-1]);
+            out.flush();
+            out.close();
+        }
+    }","import java.util.ArrayList;
+import java.util.Scanner;
+import java.util.Stack;
+
+public class D {
+    static Scanner sc = new Scanner(System.in);
+    static int[] height;
+    static int[] dp;
+
+    public static void main(String[] args) {
+        int n = sc.nextInt();
+        height = new int[n];
+        dp = new int[n];
+        dp[0] = 0;
+        for (int i = 0; i < n; i++) {
+            height[i] = sc.nextInt();
+        }
+        Stack<Integer> rise = new Stack<Integer>();
+        Stack<Integer> fail = new Stack<Integer>();
+        rise.push(0);
+        fail.push(0);
+        for (int i = 1; i < n; i++) {
+            dp[i] = dp[i-1]+1;
+
+            if (rise.isEmpty()) {
+                rise.push(i);
+            } else if (height[rise.peek()] < height[i]) {
+                rise.push(i);
+            } else {
+                while (!rise.isEmpty() && height[rise.peek()] > height[i]) {
+                    rise.pop();
+                    if (!rise.isEmpty()) {
+                        dp[i] = Math.min(dp[i], dp[rise.peek()] + 1);
+                    }
+                }
+                while (!rise.isEmpty() && height[rise.peek()] == height[i]) {
+                    rise.pop();
+                }
+                rise.push(i);
+            }
+
+
+            if (fail.isEmpty()) {
+                fail.push(i);
+            } else if (height[fail.peek()] > height[i]) {
+                fail.push(i);
+            } else {
+                while (!fail.isEmpty() && height[fail.peek()] < height[i]) {
+                    fail.pop();
+                    if (!fail.isEmpty()){
+                        dp[i] = Math.min(dp[i], dp[fail.peek()] + 1);
+                    }
+                }
+                while (!fail.isEmpty() && height[fail.peek()] == height[i]) {
+                    fail.pop();
+                }
+                fail.push(i);
+            }
+        }
+
+        System.out.println(dp[n - 1]);
+
+    }
+}
+//   a[i]
+//
+//
+//         6 7 6 2
+
+//3 5 6 4 5 6 3",0
+73f1c5f5,da0b7cb2,"import java.util.*;
+import java.io.*;
+
+public class Ana {
+	static int n, a, b, da, db;
+	static ArrayList<Integer>[] graph;
+
+	public static void main(String[] args) throws IOException, InterruptedException {
+
+		Scanner sc = new Scanner(System.in);
+		PrintWriter out = new PrintWriter(System.out);
+		int t = sc.nextInt();
+		while (t-- > 0) {
+			n = sc.nextInt();
+			a = sc.nextInt() - 1;
+			b = sc.nextInt() - 1;
+			da = sc.nextInt();
+			db = sc.nextInt();
+			graph = new ArrayList[n];
+			for (int i = 0; i < n; i++)
+				graph[i] = new ArrayList<Integer>();
+			for (int i = 0; i < n - 1; i++) {
+				int u = sc.nextInt() - 1, v = sc.nextInt() - 1;
+				graph[u].add(v);
+				graph[v].add(u);
+			}
+			int[] dist = new int[n];
+			Arrays.fill(dist, -1);
+			bfs(a, dist);
+			boolean bobwins = true; // if false alice wins
+			if (dist[b] <= da || 2 * da >= db)
+				bobwins = false;
+			int far = a;
+			for (int i = 0; i < n; i++)
+				if (dist[i] > dist[far])
+					far = i;
+			Arrays.fill(dist, -1);
+			bfs(far, dist);
+			for (int i = 0; i < n; i++)
+				if (dist[i] > dist[far])
+					far = i;
+			if(2*da>=dist[far])//max path
+				bobwins = false;
+//			out.println(dist[far]);
+			out.println(bobwins?""Bob"":""Alice"");
+		}
+
+		out.close();
+	}
+
+	static void bfs(int s, int[] dist) {
+		Queue<Integer> q = new LinkedList<Integer>();
+		q.add(s);
+		dist[s] = 0;
+		while (!q.isEmpty()) {
+			int u = q.remove();
+			for (int v : graph[u]) {
+				if (dist[v] == -1) {
+					dist[v] = 1 + dist[u];
+					q.add(v);
+				}
+			}
+		}
+	}
+
+	static class Scanner {
+		StringTokenizer st;
+		BufferedReader br;
+
+		public Scanner(InputStream s) {
+			br = new BufferedReader(new InputStreamReader(s));
+		}
+
+		public Scanner(String s) throws FileNotFoundException {
+			br = new BufferedReader(new FileReader(s));
+		}
+
+		public String next() throws IOException {
+			while (st == null || !st.hasMoreTokens())
+				st = new StringTokenizer(br.readLine());
+			return st.nextToken();
+		}
+
+		public int nextInt() throws IOException {
+			return Integer.parseInt(next());
+		}
+
+		public int[] nextIntArray(int n) throws IOException {
+			int[] ans = new int[n];
+			for (int i = 0; i < n; i++)
+				ans[i] = nextInt();
+			return ans;
+		}
+
+		public long nextLong() throws IOException {
+			return Long.parseLong(next());
+		}
+
+		public String nextLine() throws IOException {
+			return br.readLine();
+		}
+
+		public double nextDouble() throws IOException {
+			return Double.parseDouble(next());
+		}
+
+		public boolean ready() throws IOException {
+			return br.ready();
+		}
+
+	}
+
+}","import java.io.*;
+import java.util.*;
+import static java.lang.Math.*;
+
+/**
+ * Built using CHelper plug-in
+ * Actual solution is at the top
+ */
+public class Codeforces {
+    public static void main(String[] args) throws IOException {
+        // InputStream inputStream = new FileInputStream(""input.txt"");
+        // OutputStream outputStream = new FileOutputStream(""output.txt"");
+        InputStream inputStream = System.in;
+        OutputStream outputStream = System.out;
+        InputReader in = new InputReader(inputStream);
+        PrintWriter out = new PrintWriter(outputStream);
+        TaskA solver = new TaskA();
+        solver.solve(in.nextInt(), in, out);
+        out.close();
+    }
+    static class TaskA {
+        long mod = (long)(1000000007);
+        long fact[];
+        int depth[];
+        int parentTable[][];
+        int degree[];
+        ArrayList<Integer> leaves;
+        int max = Integer.MIN_VALUE;
+        int min = Integer.MAX_VALUE;
+        int diam = 0;
+
+        public void solve(int testNumber, InputReader in, PrintWriter out) throws IOException {
+            while(testNumber-->0){
+                int n = in.nextInt();
+                int a = in.nextInt();
+                int b = in.nextInt();
+                int na = in.nextInt();
+                int nb = in.nextInt();
+
+                ArrayList<ArrayList<Integer>> g = new ArrayList<>();
+                for(int i=0;i<=n;i++)
+                    g.add(new ArrayList<>());
+                for(int i=1;i<n;i++){
+                    int u = in.nextInt();
+                    int v = in.nextInt();
+                    g.get(u).add(v);
+                    g.get(v).add(u);
+                }
+
+                if(2*na>=nb){
+                    out.println(""Alice"");
+                    continue;
+                }
+
+                // parentTable = new int[n+1][31];
+                depth = new int[n+1];
+                diam = 0;
+                dfs(g , a , 0);
+
+                int distance = depth[b];
+                // out.println(distance);
+
+                if(distance <= na){
+                    out.println(""Alice"");
+                    continue;
+                }
+
+                if(2*na >= min(nb , diam))
+                    out.println(""Alice"");
+                else
+                    out.println(""Bob"");
+
+                // max = Integer.MIN_VALUE;
+                // int diameter = diameter(g , 1 , 0);
+                // int height = 0;
+                // for(int i=1;i<=n;i++)
+                //     height = max(height , depth[i]);
+
+                // // out.println(""diameter"" + diameter);
+                // // out.println(""height"" + height);
+                // // out.println(""max"" + max);
+
+                // diameter = max(diameter-1 , height-1);
+                // // diameter = max(diameter , max-1);
+
+                // nb = min(nb , diameter);
+
+                // na = min(na , diameter);
+
+
+                // if(na*2 >= nb)
+                //     out.println(""Alice"");
+                // else
+                //     out.println(""Bob"");
+
+
+            }
+        }
+
+ 
+        int dfs(ArrayList<ArrayList<Integer>> a , int x, int p) {
+            int len = 0;
+            for(int y : a.get(x)) {
+                if(y != p) {
+                    depth[y] = depth[x] + 1;
+                    int cur = 1 + dfs(a , y, x);
+                    diam = max(diam, cur + len);
+                    len = max(len, cur);
+                }
+            }
+            return len;
+        }
+
+        public int diameter(ArrayList<ArrayList<Integer>> a , int index , int parent){
+            if(index == parent)
+                return 0;
+            // if(a.get(index).size() == 1 && a.get(index).get(0) == parent)
+            //     return 1;
+            ArrayList<Integer> x = new ArrayList<>();
+            x.add(0);
+            x.add(0);
+            for(int i=0;i<a.get(index).size();i++){
+                if(a.get(index).get(i) == parent)
+                    continue;
+                x.add(diameter(a , a.get(index).get(i) , index));
+            }
+
+            Collections.sort(x);
+            if(x.size() >= 4){
+                int n = x.size();
+                max = max(max , 1+x.get(n-1) + x.get(n-2));
+            }
+
+            return 1 + x.get(x.size()-1);
+
+        }
+
+        // public void dfs(ArrayList<ArrayList<Integer>> a , int index , int parent){
+        //     parentTable[index][0] = parent;
+        //     for(int i=1;i<31;i++)
+        //         parentTable[index][i] = parentTable[parentTable[parent][i-1]][i-1];
+
+        //     depth[index] = 1+depth[parent];
+
+        //     int l = a.get(index).size();
+        //     for(int i=0;i<l;i++){
+        //         if(a.get(index).get(i) == parent)
+        //             continue;
+        //         dfs(a , a.get(index).get(i) , index);
+        //     }
+
+        // }
+
+        public int distance(ArrayList<ArrayList<Integer>> a , int u , int v){
+            return depth[u]+depth[v] - 2*depth[lca(a , u , v)];
+        }
+
+        public int lca(ArrayList<ArrayList<Integer>> a , int u , int v){
+            if(depth[v]<depth[u]){
+                int x = u;
+                u = v;
+                v = x;
+            }
+            int diff = depth[v] - depth[u];
+            for(int i=0;i<parentTable[v].length;i++){
+                // checking whether the ith bit is set in the diff variable
+                if(((diff>>i)&1) == 1)
+                    v = parentTable[v][i];
+            }
+            if(v == u)
+                return v;
+            for(int i=parentTable[v].length-1;i>=0;i--){
+                if(parentTable[u][i] != parentTable[v][i]){
+                    v = parentTable[v][i];
+                    u = parentTable[u][i];
+                }
+            }
+            return parentTable[u][0];
+        }
+
+        class Pair{
+            int start;
+            int end;
+            int index;
+            public Pair(int a , int b , int c){
+                start = a;
+                end = b;
+                end = c;
+            }
+        }
+
+
+        class Node{
+            char value;
+            Node left;
+            Node right;
+            public Node(char value){
+                this.value = value;
+                left = null;
+                right = null;
+            }
+        }
+        
+
+        public int[][] multiply(int a[][] , int b[][]){
+            int c[][] = new int[a.length][b[0].length];
+            for(int i=0;i<a.length;i++){
+                for(int j=0;j<b[0].length;j++){
+                    for(int k=0;k<b.length;k++)
+                        c[i][j] += a[i][k]*b[k][j];
+                }
+            }
+            return c;
+        }
+
+        public int[][] multiply(int a[][] , int b[][] , int mod){
+            int c[][] = new int[a.length][b[0].length];
+            for(int i=0;i<a.length;i++){
+                for(int j=0;j<b[0].length;j++){
+                    for(int k=0;k<b.length;k++){
+                        c[i][j] += a[i][k]*b[k][j];
+                        c[i][j]%=mod;
+                    }
+                }
+            }
+            return c;
+        }
+
+        public int[][] pow(int a[][] , long b){
+            int res[][] = new int[a.length][a[0].length];
+            for(int i=0;i<a.length;i++)
+                res[i][i] = 1;
+            while(b>0){
+                if((b&1) == 1)
+                    res = multiply(res , a , 10);
+                a = multiply(a , a , 10);
+                b>>=1;
+            }
+            return res;
+        }
+
+        
+
+        // for the min max problems
+        public void build(int lookup[][] , int arr[], int n) { 
+            for (int i = 0; i < n; i++) 
+                lookup[i][0] = arr[i]; 
+            for (int j = 1; (1 << j) <= n; j++) { 
+                for (int i = 0; (i + (1 << j) - 1) < n; i++) { 
+                    if (lookup[i][j - 1] > lookup[i + (1 << (j - 1))][j - 1]) 
+                        lookup[i][j] = lookup[i][j - 1]; 
+                    else
+                        lookup[i][j] = lookup[i + (1 << (j - 1))][j - 1]; 
+                } 
+            } 
+        }
+        public int query(int lookup[][] , int L, int R) { 
+            int j = (int)(Math.log(R - L + 1)/Math.log(2)); 
+            if (lookup[L][j] >= lookup[R - (1 << j) + 1][j]) 
+                return lookup[L][j]; 
+            else
+                return lookup[R - (1 << j) + 1][j]; 
+        }
+
+        // for printing purposes
+        public void print1d(int a[] , PrintWriter out){
+            for(int i=0;i<a.length;i++)
+                out.print(a[i] + "" "");
+            out.println();
+        }
+        public void print1d(long a[] , PrintWriter out){
+            for(int i=0;i<a.length;i++)
+                out.print(a[i] + "" "");
+            out.println();
+        }
+        public void print2d(int a[][] , PrintWriter out){
+            for(int i=0;i<a.length;i++){
+                for(int j=0;j<a[i].length;j++)
+                    out.print(a[i][j] + "" "");
+                out.println();
+            }
+            // out.println();
+        }
+        public void print2d(long a[][] , PrintWriter out){
+            for(int i=0;i<a.length;i++){
+                for(int j=0;j<a[i].length;j++)
+                    out.print(a[i][j] + "" "");
+                out.println();
+            }
+            // out.println();
+        }
+
+
+        public void sieve(int a[]){
+            a[0] = a[1] = 1;
+            int i;
+            for(i=2;i*i<=a.length;i++){
+                if(a[i] != 0)
+                    continue;
+                a[i] = i;
+                for(int k = (i)*(i);k<a.length;k+=i){
+                    if(a[k] != 0)
+                        continue;
+                    a[k] = i;
+                }
+            }
+        }
+
+        public long nCrPFermet(int n , int r , long p){
+            if(r==0)
+                return 1l;
+            // long fact[] = new long[n+1];
+            // fact[0] = 1;
+            // for(int i=1;i<=n;i++)
+            //     fact[i] = (i*fact[i-1])%p;
+            long modInverseR = pow(fact[r] , p-2 , p);
+            long modInverseNR = pow(fact[n-r] , p-2 , p);
+            long w = (((fact[n]*modInverseR)%p)*modInverseNR)%p;
+            return w;
+        }
+        public long pow(long a, long b, long m) {
+            a %= m;
+            long res = 1;
+            while (b > 0) {
+                long x = b&1;
+                if (x == 1)
+                    res = res * a % m;
+                a = a * a % m;
+                b >>= 1;
+            }
+            return res;
+        }
+        public long pow(long a, long b) {
+            long res = 1;
+            while (b > 0) {
+                long x = b&1;
+                if (x == 1)
+                    res = res * a;
+                a = a * a;
+                b >>= 1;
+            }
+            return res;
+        }
+        public void sortedArrayToBST(TreeSet<Integer> a , int start, int end) { 
+            if (start > end) {
+                return;
+            }
+            int mid = (start + end) / 2;
+            a.add(mid);
+            sortedArrayToBST(a, start, mid - 1);
+            sortedArrayToBST(a, mid + 1, end); 
+        }
+        class Combine{
+            int value;
+            int delete;
+            Combine(int val , int delete){
+                this.value = val;
+                this.delete = delete;
+            }
+        }
+        class Sort2 implements Comparator<Combine>{
+            public int compare(Combine a , Combine b){
+                if(a.value > b.value)
+                    return 1;
+                else if(a.value == b.value && a.delete>b.delete)
+                    return 1;
+                else if(a.value == b.value && a.delete == b.delete)
+                    return 0;
+                return -1;
+            }
+        }
+        public int lowerLastBound(ArrayList<Integer> a , int x){
+            int l = 0;
+            int r = a.size()-1;
+            if(a.get(l)>=x)
+                return -1;
+            if(a.get(r)<x)
+                return r;
+            int mid = -1;
+            while(l<=r){
+                mid = (l+r)/2;
+                if(a.get(mid) == x && a.get(mid-1)<x)
+                    return mid-1;
+                else if(a.get(mid)>=x)
+                    r = mid-1;
+                else if(a.get(mid)<x && a.get(mid+1)>=x)
+                    return mid;
+                else if(a.get(mid)<x && a.get(mid+1)<x)
+                    l = mid+1;
+            }
+            return mid;
+        }
+        public int upperFirstBound(ArrayList<Integer> a , Integer x){
+            int l = 0;
+            int r = a.size()-1;
+            if(a.get(l)>x)
+                return l;
+            if(a.get(r)<=x)
+                return r+1;
+            int mid = -1;
+            while(l<=r){
+                mid = (l+r)/2;
+                if(a.get(mid) == x && a.get(mid+1)>x)
+                    return mid+1;
+                else if(a.get(mid)<=x)
+                    l = mid+1;
+                else if(a.get(mid)>x && a.get(mid-1)<=x)
+                    return mid;
+                else if(a.get(mid)>x && a.get(mid-1)>x)
+                    r = mid-1;
+            }
+            return mid;
+        }
+        public int lowerLastBound(int a[] , int x){
+            int l = 0;
+            int r = a.length-1;
+            if(a[l]>=x)
+                return -1;
+            if(a[r]<x)
+                return r;
+            int mid = -1;
+            while(l<=r){
+                mid = (l+r)/2;
+                if(a[mid] == x && a[mid-1]<x)
+                    return mid-1;
+                else if(a[mid]>=x)
+                    r = mid-1;
+                else if(a[mid]<x && a[mid+1]>=x)
+                    return mid;
+                else if(a[mid]<x && a[mid+1]<x)
+                    l = mid+1;
+            }
+            return mid;
+        }
+        public int upperFirstBound(long a[] , long x){
+            int l = 0;
+            int r = a.length-1;
+            if(a[l]>x)
+                return l;
+            if(a[r]<=x)
+                return r+1;
+            int mid = -1;
+            while(l<=r){
+                mid = (l+r)/2;
+                if(a[mid] == x && a[mid+1]>x)
+                    return mid+1;
+                else if(a[mid]<=x)
+                    l = mid+1;
+                else if(a[mid]>x && a[mid-1]<=x)
+                    return mid;
+                else if(a[mid]>x && a[mid-1]>x)
+                    r = mid-1;
+            }
+            return mid;
+        }
+        public long log(float number , int base){
+            return (long) Math.ceil((Math.log(number) / Math.log(base)) + 1e-9);
+        }
+        public long gcd(long a , long b){
+            if(a<b){
+                long c = b;
+                b = a;
+                a = c;
+            }
+            while(b!=0){
+                long c = a;
+                a = b;
+                b = c%a;
+            }
+            return a;
+        }
+        public long[] gcdEx(long p, long q) {
+            if (q == 0)
+                return new long[] { p, 1, 0 };
+            long[] vals = gcdEx(q, p % q);
+            long d = vals[0];
+            long a = vals[2];
+            long b = vals[1] - (p / q) * vals[2];
+            // 0->gcd 1->xValue 2->yValue
+            return new long[] { d, a, b };
+        }
+        public void sievePhi(int a[]){
+            a[0] = 0;
+            a[1] = 1;
+            for(int i=2;i<a.length;i++)
+                a[i] = i-1;
+            for(int i=2;i<a.length;i++)
+                for(int j = 2*i;j<a.length;j+=i)
+                    a[j] -= a[i];
+        }
+        public void lcmSum(long a[]){
+            int sievePhi[] = new int[(int)1e6 + 1];
+            sievePhi(sievePhi);
+            a[0] = 0;
+            for(int i=1;i<a.length;i++)
+                for(int j = i;j<a.length;j+=i)
+                    a[j] += (long)i*sievePhi[i];
+        }
+    }
+
+    static class InputReader {
+        public BufferedReader reader;
+        public StringTokenizer tokenizer;
+
+        public InputReader(InputStream stream) {
+            reader = new BufferedReader(new InputStreamReader(stream), 32768);
+            tokenizer = null;
+        }
+
+        public String next() {
+            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
+                try {
+                    tokenizer = new StringTokenizer(reader.readLine());
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+            }
+            return tokenizer.nextToken();
+        }
+
+        public int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        public long nextLong() {
+            return Long.parseLong(next());
+        }
+
+    }
+}",0
+a60fba84,c695a974,"/*input
+3
+2
+13 88
+3
+2 3 1
+5
+4 3 2 1 4
+
+*/
+import java.util.*;
+import java.lang.*;
+import java.io.*;
+
+public class Main
+{
+	static PrintWriter out;
+	static int MOD = 1000000007;
+	static FastReader scan;
+
+    /*-------- I/O using short named function ---------*/
+	public static String ns(){return scan.next();}
+	public static int ni(){return scan.nextInt();}
+	public static long nl(){return scan.nextLong();}
+	public static double nd(){return scan.nextDouble();}
+	public static String nln(){return scan.nextLine();}
+	public static void p(Object o){out.print(o);}
+	public static void ps(Object o){out.print(o + "" "");}
+	public static void pn(Object o){out.println(o);}
+    /*-------- for output of an array ---------------------*/
+     static void iPA(int arr []){
+     	 StringBuilder output = new StringBuilder();
+	     for(int i=0; i<arr.length; i++)output.append(arr[i] + "" "");out.println(output);
+	}
+	static void lPA(long arr []){
+	     StringBuilder output = new StringBuilder();
+	     for(int i=0; i<arr.length; i++)output.append(arr[i] + "" "");out.println(output);
+	}
+	static void sPA(String arr []){
+	     StringBuilder output = new StringBuilder();
+	     for(int i=0; i<arr.length; i++)output.append(arr[i] + "" "");out.println(output);
+	}
+	static void dPA(double arr []){
+	     StringBuilder output = new StringBuilder();
+	     for(int i=0; i<arr.length; i++)output.append(arr[i] + "" "");out.println(output);
+	}
+    /*-------------- for input in an array ---------------------*/
+	static void iIA(int arr[]){
+	     for(int i=0; i<arr.length; i++)arr[i] = ni();
+	}
+	static void lIA(long arr[]){
+	     for(int i=0; i<arr.length; i++)arr[i] = nl(); 
+	}
+	static void sIA(String arr[]){
+	     for(int i=0; i<arr.length; i++)arr[i] = ns(); 
+	}
+	static void dIA(double arr[]){
+	     for(int i=0; i<arr.length; i++)arr[i] = nd();
+	}
+	/*------------ for taking input faster ----------------*/
+     static class FastReader
+	{
+		BufferedReader br;
+		StringTokenizer st;
+
+		public FastReader()
+		{
+			br = new BufferedReader(new InputStreamReader(System.in));
+		}
+
+		String next()
+		{
+			while (st == null || !st.hasMoreElements())
+			{
+				try
+				{
+					st = new StringTokenizer(br.readLine());
+				}
+				catch (IOException e)
+				{
+					e.printStackTrace();
+				}
+			}
+			return st.nextToken();
+		}
+
+		int nextInt()
+		{
+			return Integer.parseInt(next());
+		}
+
+		long nextLong()
+		{
+			return Long.parseLong(next());
+		}
+
+		double nextDouble()
+		{
+			return Double.parseDouble(next());
+		}
+
+		String nextLine()
+		{
+			String str = """";
+			try
+			{
+				str = br.readLine();
+			}
+			catch (IOException e)
+			{
+				e.printStackTrace();
+			}
+			return str;
+		}
+	}
+
+	// Method to check if x is power of 2
+    static boolean isPowerOfTwo (int x) { return x!=0 && ((x&(x-1)) == 0);}
+    //Method to return lcm of two numbers
+    static int gcd(int a, int b){return a==0?b:gcd(b % a, a); }
+    //Method to count digit of a number
+    static int countDigit(long n){return (int)Math.floor(Math.log10(n) + 1);}
+
+    //Method for sorting
+	static void ruffle_sort(int[] a) {
+		//shandom_ruffle
+		Random r=new Random();
+		int n=a.length;
+		for (int i=0; i<n; i++) {
+			int oi=r.nextInt(n);
+			int temp=a[i];
+			a[i]=a[oi];
+			a[oi]=temp;
+		}
+		//sort
+		Arrays.sort(a);
+	}
+	//Method for checking if a number is prime or not
+	static boolean isPrime(int n) { 
+        if (n <= 1) return false; 
+        if (n <= 3) return true; 
+        if (n % 2 == 0 || n % 3 == 0) return false; 
+        for (int i = 5; i * i <= n; i = i + 6) 
+            if (n % i == 0 || n % (i + 2) == 0) 
+            return false; 
+        return true; 
+    } 
+
+	public static void main (String[] args) throws java.lang.Exception
+	{
+		OutputStream outputStream =System.out;
+        out =new PrintWriter(outputStream);
+        scan =new FastReader();
+		//for fast output sometimes
+		StringBuilder sb = new StringBuilder();
+		int t = ni();
+		while(t-->0){
+			int n = ni();
+			long arr[] = new long[n];
+			lIA(arr);
+			long ans = (long)(n*(arr[0] + arr[1]));
+			long sum = arr[0] + arr[1];
+			long emin = arr[0], omin = arr[1];
+			
+			for(int i=2; i<n; i++){
+				sum += arr[i];
+				if(i%2==0){
+					emin = Math.min(arr[i], emin);
+				}
+				else{
+					omin = Math.min(arr[i], omin);
+				}
+				long temp = sum - emin - omin;
+				if(i%2==0)
+					temp += (n-i/2)*emin + (n-i/2+1)*omin;
+				else
+					temp += (n-(i-1)/2)*(emin + omin);
+				ans = Math.min(ans, temp);
+
+			}
+			pn(ans);
+        }
+        out.flush();
+		out.close();
+	}
+	
+}
+
+","//      これを翻訳している間、あなたはあなたの人生のいくつかの貴重な瞬間を無駄にしました
+
+
+import java.io.*;
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.util.*;
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+
+
+public class Solution {
+    static PrintWriter fop = new PrintWriter(System.out);
+
+
+    public static void main(String[] args) {
+        FastScanner fsca = new FastScanner();
+        int i, j = 0;
+        int t = fsca.nextInt();
+        u: while (t-- > 0) {
+            int n = fsca.nextInt();
+            int a[] = new int[n];
+            for(i=0;i<n;i++){
+                a[i] = fsca.nextInt();
+            }
+            int y = Integer.MAX_VALUE;
+            long sum[] = new long[n];
+            long min1[] = new long[n];
+            sum[0] = a[0];
+            sum[1] = a[1];
+            min1[0] = a[0];
+            min1[1] = a[1];
+            for(i=2;i<n;i++){
+                sum[i] = sum[i-2] + a[i];
+                min1[i] = Math.min(min1[i-2],a[i]);
+            }
+            long val = sum[0]*n + sum[1]*n;
+            long min = sum[0]*n + sum[1]*n;
+            for(i=2;i<n;i++){
+                val = sum[i] + min1[i]*(n-(i+2)/2) + sum[i-1] + min1[i-1]*(n-(i+1)/2);
+                min = Math.min(min,val);
+            }
+            fop.println(min);
+        }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+        fop.flush();
+        fop.close();
+
+
+    }
+    /*-----------------------------------------------------------------------------------------------------------------------------------------------*/
+    // template starts from here :
+
+    static long gcd(long a, long b) {
+        return (b == 0) ? a : gcd(b, a % b);
+    }
+
+    static int gcd(int a, int b) {
+        return (b == 0) ? a : gcd(b, a % b);
+    }
+
+
+    static final Random random = new Random();
+
+    static void ruffleSort(int[] a) {
+        int n = a.length;//shuffle, then sort
+        for (int i = 0; i < n; i++) {
+            int oi = random.nextInt(n), temp = a[oi];
+            a[oi] = a[i];
+            a[i] = temp;
+        }
+        Arrays.sort(a);
+    }
+
+    static void ruffleSort(long[] a) {
+        int n = a.length;//shuffle, then sort
+        for (int i = 0; i < n; i++) {
+            int oi = random.nextInt(n);
+            long temp = a[oi];
+            a[oi] = a[i];
+            a[i] = temp;
+        }
+        Arrays.sort(a);
+    }
+
+
+    static class FastScanner {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st = new StringTokenizer("""");
+
+        String next() {
+            while (!st.hasMoreTokens())
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+
+        int[][] readMat(int n, int m) {
+            int a[][] = new int[n][m];
+            for (int i = 0; i < n; i++)
+                for (int j = 0; j < m; j++)
+                    a[i][j] = nextInt();
+            return a;
+        }
+        char[][] readCharMat(int n, int m) {
+            char a[][] = new char[n][m];
+            for (int i = 0; i < n; i++) {
+                String s = next();
+                for (int j = 0; j < m; j++)
+                    a[i][j] = s.charAt(j) ;
+            }
+            return a;
+        }
+
+        int[] readArray(int n) {
+            int[] a = new int[n];
+            for (int i = 0; i < n; i++) a[i] = nextInt();
+            return a;
+        }
+
+        long[] readLongArray(int n) {
+            long[] a = new long[n];
+            for (int i = 0; i < n; i++)
+                a[i] = nextLong();
+            return a;
+        }
+
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+    }
+
+    static void print(int a[], int n) {
+        for (int i = 0; i < n; i++)
+            fop.append((a[i]) + "" "");
+        // fop.append(""\n"") ;
+    }
+
+    static void print(long a[], int n) {
+        for (int i = 0; i < n; i++)
+            fop.append((a[i]) + "" "");
+        // fop.append(""\n"") ;
+    }
+}
+        ",0
+5e3089fa,aea245ba,"//package Div2.C;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class SetOrDecrease {
+    public static void main(String[] args) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        int t = Integer.parseInt(br.readLine());
+        while(t>0){
+            String []nk=br.readLine().split("" "");
+            int n=Integer.parseInt(nk[0]);
+            long k=Long.parseLong(nk[1]);
+            String []str=br.readLine().split("" "");
+            List<Integer> list=new ArrayList<>();
+            for(int i=0;i<n;i++)
+                list.add(Integer.parseInt(str[i]));
+            Collections.sort(list);
+            long sum=0;
+            for(int i=0;i<n;i++)
+                sum+=list.get(i);
+            if(sum<=k)
+                System.out.println(0);
+            else {
+                long minSteps = sum - k;
+                long drop=0;
+                long targetDrop = sum-k;
+                for (int i = n - 1; i > 0; i--) {
+                    //assignment at ith element
+                    drop += list.get(i) - list.get(0);
+                    if (drop >= targetDrop) {
+                        if (minSteps > n - i)
+                            minSteps = n - i;
+                    } else {
+                        long diff = targetDrop - drop;
+                        long div = diff / (n - i + 1);
+                        long rem = diff % (n - i + 1);
+                        long steps = rem > 0 ? (div + 1) + n - i : div + n - i;
+                        if (minSteps > steps)
+                            minSteps = steps;
+
+                    }
+                }
+                System.out.println(minSteps);
+            }
+            t--;
+        }
+    }
+}
+","import java.awt.image.AreaAveragingScaleFilter;
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.*;
+
+public class CF1 {
+    public static void main(String[] args) {
+        FastScanner sc=new FastScanner();
+        int T=sc.nextInt();
+//        int T=1;
+        for (int tt=0; tt<T; tt++){
+            int n = sc.nextInt();
+            long k = sc.nextLong();
+            int arr[]= sc.readArray(n);
+            sort(arr);
+            long sum=0L;
+            long ans=Integer.MAX_VALUE;
+            long min= (long)arr[0];
+
+
+            for (int i=0; i<n; i++){
+                sum+=arr[i];
+            }
+            if (sum<=k) System.out.println(0);
+            else {
+                long temp=sum;
+                long x=0L;
+                long y=0L;
+                for (int i=n-1; i>=1; i--){
+                    temp=sum;
+                    //2x +arr[i]-min
+                    y++;
+                    x+=arr[i];
+                    temp-=x-y*min;
+                    if (temp<=k) {
+                        ans=Math.min(ans,y);
+                        break;
+                    }
+                    else {
+                        long b=(temp-k);
+                        if (b%(y+1)==0){
+                            b/=(y+1);
+                        }
+                        else {
+                            b/=(y+1);
+                            b++;
+                        }
+                        ans=Math.min(ans, y+b);
+                    }
+
+
+
+                }
+                if (n==1){
+                    ans=arr[0]-k;
+                }
+                ans= Math.min(ans, sum-k);
+                System.out.println(ans);
+            }
+
+
+
+
+        }
+    }
+    static long mod =998244353L;
+    static long power (long a, long b){
+        long res=1;
+        while (b>0){
+            if ((b&1)== 1){
+                res= (res * a % mod)%mod;
+            }
+            a=(a%mod * a%mod)%mod;
+            b=b>>1;
+        }
+        return res;
+    }
+
+    boolean[] sieveOfEratosthenes(int n)
+    {
+
+        boolean prime[] = new boolean[n+1];
+        for(int i=0;i<=n;i++)
+            prime[i] = true;
+
+        for(int p = 2; p*p <=n; p++)
+        {
+            if(prime[p] == true)
+            {
+                for(int i = p*p; i <= n; i += p)
+                    prime[i] = false;
+            }
+        }
+        return prime;
+    }
+    static void sort(int[] a) {
+        ArrayList<Integer> l=new ArrayList<>();
+        for (int i:a) l.add(i);
+        Collections.sort(l);
+        for (int i=0; i<a.length; i++) a[i]=l.get(i);
+    }
+    static void sortLong(long[] a) {
+        ArrayList<Long> l=new ArrayList<>();
+        for (long i:a) l.add(i);
+        Collections.sort(l);
+        for (int i=0; i<a.length; i++) a[i]=l.get(i);
+    }
+    static long gcd (long n, long m){
+        if (m==0) return n;
+        else return gcd(m, n%m);
+    }
+
+    static class Pair implements Comparable<Pair>{
+        int x,y;
+        public Pair(int x, int y){
+            this.x = x;
+            this.y = y;
+        }
+        public int compareTo(Pair o){
+            return this.x-o.x;
+        }
+    }
+    static class FastScanner {
+        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st=new StringTokenizer("""");
+        String next() {
+            while (!st.hasMoreTokens())
+                try {
+                    st=new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+        int[] readArray(int n) {
+            int[] a=new int[n];
+            for (int i=0; i<n; i++) a[i]=nextInt();
+            return a;
+        }
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+    }
+}",0
+550335a3,6d7d5dd7,"import javax.print.attribute.standard.MediaSize;
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.lang.reflect.Array;
+import java.util.*;
+import java.util.stream.Stream;
+
+public class Program {
+
+    static BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
+    static BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));
+
+    public static void main(String[] args) throws NumberFormatException, IOException {
+
+        int cases = Integer.parseInt(reader.readLine());
+        int mod = 998244353;
+
+        while(cases-- > 0) {
+
+            String[] firstLine = reader.readLine().split("" "");
+            int n = Integer.parseInt(firstLine[0]);
+
+            String a = reader.readLine();
+            String b = reader.readLine();
+
+            int ans = Integer.MAX_VALUE;
+
+            int oneZeroPos = -1;
+            int oneOnePos = -1;
+            int oneZero = 0;
+            int zeroOne = 0;
+
+            for(int i=0;i<n;i++) {
+                if(a.charAt(i)=='0' && b.charAt(i)=='1') {
+                    zeroOne++;
+                }
+                if(a.charAt(i)=='1' && b.charAt(i)=='0') {
+                    oneZero++;
+                }
+                if(a.charAt(i)=='1' && b.charAt(i)=='0' && oneZeroPos == -1) {
+                    oneZeroPos = i;
+                }
+                if(a.charAt(i)=='1' && b.charAt(i)=='1' && oneOnePos == -1) {
+                    oneOnePos = i;
+                }
+            }
+
+            if(oneZero==0&&zeroOne==0) {
+                printNumber(0);
+                continue;
+            }
+
+            if(oneZero==zeroOne) {
+                ans = oneZero+zeroOne;
+            }
+
+            int a1 = func(a, b, oneZeroPos);
+            int b1 = func(a, b, oneOnePos);
+
+            if(a1 != Integer.MAX_VALUE) {
+                ans = Math.min(ans, 1+a1);
+            }
+
+            if(b1 != Integer.MAX_VALUE) {
+                ans = Math.min(ans, 1+b1);
+            }
+
+            if(ans == Integer.MAX_VALUE) {
+                printNumber(-1);
+            } else {
+                printNumber(ans);
+            }
+
+        }
+
+        out.flush();
+
+    }
+
+
+    public static int func(String str, String comparing, int index) {
+
+        if(index==-1) return Integer.MAX_VALUE;
+
+        char[] ch = str.toCharArray();
+        char[] comp = comparing.toCharArray();
+
+        for(int i=0;i<ch.length;i++) {
+            if(i!=index) {
+                if(ch[i]=='1') ch[i] = '0';
+                else ch[i] = '1';
+            }
+        }
+
+        int oneZero = 0;
+        int zeroOne = 0;
+
+        for(int i=0;i<str.length();i++) {
+            if(ch[i] == '1' && comp[i] == '0') {
+                oneZero++;
+            } else if(ch[i] == '0' && comp[i] == '1') {
+                zeroOne++;
+            }
+        }
+
+        if(oneZero == zeroOne) {
+            return oneZero+zeroOne;
+        }
+
+        return Integer.MAX_VALUE;
+
+    }
+
+     public static int ub(long[] arr, long num) {
+        int start = 0;
+        int end = arr.length;
+        int mid = 0;
+
+        while(start<end) {
+            mid = start + (end-start)/2;
+            if(arr[mid] < num) {
+                start = mid+1;
+            }else {
+                end = mid;
+            }
+        }
+        return start;
+     }
+
+    public static int[] convertToIntPrimitiveArray() throws IOException {
+        String[] str = reader.readLine().split("" "");
+        return Stream.of(str).mapToInt(Integer::parseInt).toArray();
+    }
+
+    public static Integer[] convertToIntArray(String[] str) {
+        Integer[] arr = new Integer[str.length];
+        for(int i=0;i<str.length;i++) {
+            arr[i] = Integer.parseInt(str[i]);
+        }
+        return arr;
+    }
+
+    public static Long[] convertToLongArray(String[] str) {
+        Long[] arr = new Long[str.length];
+        for(int i=0;i<str.length;i++) {
+            arr[i] = Long.parseLong(str[i]);
+        }
+        return arr;
+    }
+
+    public static long[] convertToLongPrimitiveArray() throws IOException {
+        String[] str = reader.readLine().split("" "");
+        return Stream.of(str).mapToLong(Long::parseLong).toArray();
+    }
+
+    public static void printYes() throws IOException {
+        out.append(""YES"" + ""\n"");
+    }
+
+    public static void printNo() throws IOException {
+        out.append(""NO"" + ""\n"");
+    }
+
+    public static void printNumber(long num) throws IOException {
+        out.append(num + ""\n"");
+    }
+
+    public static long hcf(long a, long b) {
+        if(b==0) return a;
+        return hcf(b, a%b);
+    }
+
+    public static int findSet(int[] parent, int[] rank, int v) {
+        if(v==parent[v]) {
+            return v;
+        }
+        parent[v] = findSet(parent, rank, parent[v]);
+        return parent[v];
+    }
+
+    public static void unionSet(int[] parent, int[] rank, int a, int b) {
+
+        a = findSet(parent, rank, a);
+        b = findSet(parent, rank, b);
+
+        if(a == b) {
+            return;
+        }
+
+        if(rank[a] < rank[b]) {
+            int temp = a;
+            a = b;
+            b = temp;
+        }
+
+        parent[b] = a;
+        if(rank[a] == rank[b]) {
+            rank[a]++;
+        }
+
+    }
+
+    public static void makeSet(int[] parent, int[] rank, int v) {
+        parent[v] = v;
+        rank[v] = 0;
+    }
+
+    public static long modularDivision(long a, long b, int mod) {
+        if(a==0) return 1;
+        a %= mod;
+        long res = 1L;
+        while(b > 0) {
+            if((b&1)==1) {
+                res = (res * a)%mod;
+            }
+            a = (a*a)%mod;
+            b >>= 1;
+        }
+        return res;
+    }
+
+    public static void customSort(int[] arr) {
+        int n = arr.length;
+        Random rnd = new Random();
+        for(int i=0; i<n; ++i){
+            int tmp = arr[i];
+            int randomPos = i + rnd.nextInt(n-i);
+            arr[i] = arr[randomPos];
+            arr[randomPos] = tmp;
+        }
+        Arrays.sort(arr);
+        return;
+    }
+
+    public static void customSortLong(long[] arr) {
+        int n = arr.length;
+        Random rnd = new Random();
+        for(int i=0; i<n; ++i){
+            long tmp = arr[i];
+            int randomPos = i + rnd.nextInt(n-i);
+            arr[i] = arr[randomPos];
+            arr[randomPos] = tmp;
+        }
+        Arrays.sort(arr);
+        return;
+    }
+
+    public static long[] factorial(int n, int mod) {
+        long[] fact = new long[n+1];
+        fact[0] = 1;
+        for(int i=1;i<fact.length;i++) {
+            fact[i] = (i*fact[i-1] + mod)%mod;
+        }
+        return fact;
+    }
+
+    public static List<Integer> primeNumbers(int num) {
+        boolean[] arr = new boolean[num+1];
+        List<Integer> primes = new ArrayList<>();
+
+        for(int i=2;i*i<=num;i++) {
+            if(!arr[i]) {
+                for(int j=i;j*i<=num;j++) {
+                    arr[j*i] = true;
+                }
+            }
+        }
+
+        for(int i=2;i<=num;i++) {
+            if(!arr[i]) {
+                primes.add(i);
+            }
+        }
+        return primes;
+    }
+
+
+}","
+import java.util.Scanner;
+
+public class Menorah {
+
+    public static void main(String[] args) {
+        Scanner scan = new Scanner(System.in);
+        int t = scan.nextInt();
+        k:
+        while (t-- > 0) {
+            int n = scan.nextInt();
+            String a = scan.next();
+            String b = scan.next();
+            int zo = 0;
+            int oz = 0;
+            int ind = -1;
+            for (int i = 0; i < n; i++) {
+                if (a.charAt(i) == '0' && b.charAt(i) == '1') {
+                    ++zo;
+                } else if (a.charAt(i) == '1' && b.charAt(i) == '0') {
+                    ++oz;
+                } else if (a.charAt(i) == '1' && b.charAt(i) == '1') {
+                    ind = i;
+                }
+            }
+            int res = 1000000000;
+            int res2 = 1000000000;
+            if (zo == oz) {
+                res = zo + oz;
+            }
+            if (ind != -1) {
+                char[] s = a.toCharArray();
+                for (int i = 0; i < n; i++) {
+                    if (i == ind) {
+                        continue;
+                    }
+                    if (s[i] == '0') {
+                        s[i] = '1';
+                    } else {
+                        s[i] = '0';
+                    }
+                }
+
+                zo = 0;
+                oz = 0;
+
+                for (int i = 0; i < n; i++) {
+
+                    if (s[i] == '0' && b.charAt(i) == '1') {
+                        ++zo;
+                    } else if (s[i] == '1' && b.charAt(i) == '0') {
+                        ++oz;
+                    }
+                }
+
+                if (zo == oz) {
+                    res2 = zo + oz + 1;
+                }
+
+            }
+            if (res == 1000000000 && res2 == 1000000000) {
+                System.out.println(""-1"");
+            } else {
+                System.out.println(Math.min(res, res2));
+            }
+
+        }
+    }
+}
+",0
+558df7d4,d8654140,"import java.io.*;
+import java.util.*;
+public class Pupsen {
+	public static void main(String[] args) throws Exception {
+		FastIO in = new FastIO();
+		int t = in.nextInt();
+		for (int tc=0; tc<t; tc++) {
+			int n = in.nextInt();
+			int[] a = new int[n];
+			for (int i=0; i<n; i++) {
+				a[i] = in.nextInt();
+			}
+			int[] b = new int[n];
+			if (n%2==0) {
+				for (int i=0; i<n-1; i+=2) {
+					b[i] = -a[i+1];
+					b[i+1] = a[i];
+				}
+				for (int i=0; i<n; i++) System.out.print(b[i]+"" "");
+			}
+			else {
+				if (a[0]+a[1]!=0) {
+					b[0] = -a[2];
+					b[1] = -a[2];
+					b[2] = a[0]+a[1];
+				}
+				else if (a[0]+a[2]!=0) {
+					b[0] = -a[1];
+					b[2] = -a[1];
+					b[1] = a[0]+a[2];
+				}
+				else {
+					b[1] = -a[0];
+					b[2] = -a[0];
+					b[0] = a[1]+a[2];
+				}
+				for (int i=3; i<n-1; i+=2) {
+					b[i] = -a[i+1];
+					b[i+1] = a[i];
+				}
+				for (int i=0; i<n; i++) System.out.print(b[i]+"" "");
+			}
+			System.out.println();
+		}
+	}
+	static class FastIO {
+		BufferedReader br;
+	    StringTokenizer st;
+	    PrintWriter pr;
+	    public FastIO() throws IOException
+	    {
+	        br = new BufferedReader(new InputStreamReader(System.in));
+	    }
+	    
+
+	    public String next() throws IOException
+	    {
+	        while (st == null || !st.hasMoreElements()) {
+	           
+	            st = new StringTokenizer(br.readLine());
+	        }
+	        return st.nextToken();
+	    }
+
+	    public int nextInt() throws NumberFormatException, IOException { return Integer.parseInt(next()); }
+
+	    public long nextLong() throws NumberFormatException, IOException { return Long.parseLong(next()); }
+
+	    public double nextDouble() throws NumberFormatException, IOException
+	    {
+	        return Double.parseDouble(next());
+	    }
+
+	    public String nextLine() throws IOException
+	    {
+	        String str = br.readLine();
+	        return str;
+	    }
+	}
+}
+","import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.text.DecimalFormat;
+import java.util.*;
+
+
+ 
+public class Codeforces {
+	
+	static int mod=1000000007 ;
+	static List<Integer>[] adj;
+	static boolean vst[];
+	static int dp[];
+	public static void main(String[] args) throws Exception {
+		PrintWriter out=new PrintWriter(System.out);
+		FastScanner fs=new FastScanner();
+		int t=fs.nextInt();
+		while(t-->0) {
+			int n=fs.nextInt();
+			int arr[]=fs.readArray(n);
+			int ans[]=new int[n];
+			if(n%2==0) {
+				for(int i=0;i<n;i+=2) {
+					ans[i]=-arr[i+1];
+					ans[i+1]=arr[i];
+				}
+			}
+			else {
+				for(int i=3;i<n;i+=2) {
+					ans[i]=-arr[i+1];
+					ans[i+1]=arr[i];
+				}
+				int a=0, b=0, c=0;
+				outer:for(int i=0;i<3;i++) {
+					for(int j=i+1;j<3;j++) {
+						if(arr[i]+arr[j]!=0) {
+							b=i;
+							c=j;
+							a= 3-c-b;
+							break outer;
+						}
+					}
+				}
+				ans[a]=arr[b]+arr[c];
+				ans[b]=-arr[a];
+				ans[c]=-arr[a];
+			}
+			for(int i=0;i<n;i++) {
+				out.print(ans[i]+"" "");
+			}
+			out.println();
+//			long sum=0;
+//			for(int i=0;i<n;i++) {
+//				sum+=arr[i]*ans[i];
+//			}
+//			if(sum!=0) System.out.println(false);
+		}
+		out.close();
+		
+	}
+	
+	static long pow(long a,long b) {
+		if(b<0) return 1;
+		long res=1;
+		while(b!=0) {
+			if((b&1)!=0) {
+				res*=a;
+				res%=mod;
+			}
+			a*=a;
+			a%=mod;
+			b=b>>1;
+		}
+		return res;
+	}
+	static long gcd(long  a,long  b) {
+		if(b==0) return a;
+		return gcd(b,a%b);
+	}
+	static long nck(int n,int k) {
+		if(k>n) return 0;
+		long res=1;
+		res*=fact(n);
+		res%=mod;
+		res*=modInv(fact(k));
+		res%=mod;
+		res*=modInv(fact(n-k)); 
+		res%=mod;
+		return res;
+	}
+	static long fact(long n) {
+//		return fact[(int)n];
+		long res=1;
+		for(int i=2;i<=n;i++) {
+			res*=i;
+			res%=mod;
+		}
+		return res;
+	}
+	
+	static long modInv(long n) {
+		return pow(n,mod-2);
+	}
+	
+	static void sort(int[] a) {
+		//suffle
+		int n=a.length;
+		Random r=new Random();
+		for (int i=0; i<a.length; i++) {
+			int oi=r.nextInt(n);
+			int temp=a[i];
+			a[i]=a[oi];
+			a[oi]=temp;
+		}
+		
+		//then sort
+		Arrays.sort(a);
+	}
+	
+	// Use this to input code since it is faster than a Scanner
+	static class FastScanner {
+		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st=new StringTokenizer("""");
+		String next() {
+			while (!st.hasMoreTokens())
+				try {
+					st=new StringTokenizer(br.readLine());
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			return st.nextToken();
+		}
+		
+		int nextInt() {
+			return Integer.parseInt(next());
+		}
+		long[] lreadArray(int n) {
+			long a[]=new long[n];
+			for(int i=0;i<n;i++) a[i]=nextLong();
+			return a;
+		}
+		int[] readArray(int n) {
+			int[] a=new int[n];
+			for (int i=0; i<n; i++) a[i]=nextInt();
+			return a;
+		}
+		long nextLong() {
+			return Long.parseLong(next());
+		}
+	}
+ 
+}",0
+3088ca9c,6f393cfe,"import java.util.*;
+import java.io.*;
+
+
+public class MyClass {
+    public static void main(String args[]) {
+     Scanner sc = new Scanner(System.in);
+     int t = sc.nextInt();
+     while(t>0)
+     {
+         int n = sc.nextInt();
+         sc.nextLine();
+         String [] str = new String[n];
+         int res = 0;
+         for(int i=0;i<n;i++)
+         {
+             str[i]=sc.nextLine();
+         }
+         int [][] freq = new int [n][5];
+         for(int i=0;i<n;i++)
+         {
+             for(int j=0;j<str[i].length();j++)
+             {
+                 int k = str[i].charAt(j)-'a';
+                 freq[i][k]++;
+             }
+         }
+         for(int i=0;i<5;i++)
+         {
+             int [] arr = new int[n];
+             for(int j=0;j<n;j++)
+             {
+                 int pos = freq[j][i];
+                 int sum=0;
+                 for(int k = 0;k<5;k++)
+                 {
+                     sum+=freq[j][k];
+                 }
+                 sum-=pos;
+                 arr[j]=(pos-sum);
+             }
+             Arrays.sort(arr);
+            //  int p = n-1;
+             int count=0;
+             int sum=0;
+             for(int p=n-1;p>=0;p--)
+             {
+                 sum+=arr[p];
+                 if(sum>0)
+                 {
+                     count++;
+                 }
+                 else
+                 {
+                     break;
+                 }
+             }
+             res=Math.max(count , res);
+         }
+         
+         System.out.println(res);
+         t--;
+         
+     }
+    }
+}","import java.io.*;
+import java.util.*;
+
+public class C {
+
+    public static void main(String[] args) throws Exception{
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
+        try{
+            int t = Integer.parseInt(br.readLine());
+            while(t-->0){
+                int n = Integer.parseInt(br.readLine());
+                int lst[][] = new int[n][5];
+                for(int i=0; i<n; i++){
+                    String s = br.readLine();
+                    for(int j=0; j<s.length(); j++){
+                        lst[i][s.charAt(j)-'a']++;
+                    }
+                }
+                int fans = Integer.MIN_VALUE;
+                for(int i=0; i<5; i++){
+                    int val[] = new int[n];
+                    for(int k=0; k<n; k++){
+                        int sum = 0;
+                        for(int j=0; j<5; j++){
+                            if(i==j){
+                                sum += lst[k][j];
+                            }else{
+                                sum -= lst[k][j];
+                            }
+                        }
+                        val[k] = sum;
+                    }
+                    Arrays.sort(val);
+                    int sum = 0;
+                    int ans = 0;
+                    for(int x = n-1; x>=0; x--){
+                        sum+=val[x];
+                        if(sum>0){
+                            ans++;
+                        }else{
+                            break;
+                        }
+                    }
+                    fans = Math.max(fans, ans);
+                }
+                bw.write(fans+""\n"");
+            }
+            bw.flush();
+        }catch(Exception e){
+            return;
+        }
+    }
+    
+}",1
+213340b3,870e16d9,"import java.util.*;
+import java.io.*;
+public class Solution {
+    static class FastReader {
+        BufferedReader br;
+        StringTokenizer st;
+        public FastReader() {
+            br = new BufferedReader(new InputStreamReader(System.in));
+        }
+        String next() {
+            while (st == null || !st.hasMoreElements()) {
+                try {
+                    st = new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return st.nextToken();
+        }
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+        double nextDouble() {
+            return Double.parseDouble(next());
+        }
+        String nextLine() {
+            String str = """";
+            try {
+                str = br.readLine();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            return str;
+        }
+    }
+    static void sort(int a[]){ // int -> long
+        ArrayList<Integer> arr=new ArrayList<>(); // Integer -> Long
+        for(int i=0;i<a.length;i++)
+        arr.add(a[i]);
+        Collections.sort(arr);
+        for(int i=0;i<a.length;i++)
+        a[i]=arr.get(i);
+        
+    }
+    private static long gcd(long a, long b){
+        if(b==0)return a;
+        return gcd(b,a%b);
+    }
+    private static long pow(long x,long y){
+        if(y==0)return 1;
+        long temp = pow(x, y/2);
+        if(y%2==1){
+            return x*temp*temp;
+        }
+        else{
+            return temp*temp;
+        }
+    }
+    static int log(long n){
+        int res = 0;
+        while(n>0){
+            res++;
+            n/=2;
+        }
+        return res;
+    }
+
+    static int mod = (int)1e9+7;
+    static int INF = Integer.MAX_VALUE;
+    static PrintWriter out;
+    static FastReader sc ;
+    public static void main(String[] args) throws IOException {
+        sc = new FastReader();
+        out = new PrintWriter(System.out);
+        // primes();
+        // ================================ //
+        int test = sc.nextInt();
+        while (test-- > 0) {
+            int n = sc.nextInt();
+            String s = sc.nextLine();
+            String t = sc.nextLine();
+            solver(s,t, n);
+        }
+        // ================================ //
+        // int n = sc.nextInt();
+        // solver();
+        // ================================ //
+        out.flush();
+    }
+
+    public static void solver(String s, String t, int n) {
+        int diff = 0;
+        int one = 0;
+        int zero = 0;
+        for(int i=0;i<n;i++){
+            if(s.charAt(i)!=t.charAt(i)){
+                diff++;
+                if(s.charAt(i)=='1')one++;
+            }
+            else{
+                if(s.charAt(i)=='1')zero++;
+            }
+        }
+        if(diff==0){
+            out.println(0);
+            return;
+        }
+        int res = INF;
+        if(diff%2==0 && one==(diff-one)){
+            res = diff;
+        }
+        if(n-diff-1>=0 && (n-diff-1)%2==0 && zero>0 && (n-diff-zero)==zero-1){
+            res = Math.min(res, (n-diff-1)+1);
+        }
+        out.println(res==INF?-1:res);
+    }
+}
+","import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.*;
+
+public class CF1 {
+    public static void main(String[] args) {
+        FastScanner sc=new FastScanner();
+        int T=sc.nextInt();
+//        int T=1;
+        for (int tt=0; tt<T; tt++){
+           int n =sc.nextInt();
+           String a = sc.next();
+           String b= sc.next();
+           int candles1=0;
+           int candles2=0;
+           int inPlace=0;
+           for (int i=0; i<n; i++){
+               if (a.charAt(i)=='1'){
+                   candles1++;
+               }
+               if (b.charAt(i)=='1') candles2++;
+               if (b.charAt(i)=='1' && a.charAt(i)=='1') inPlace++;
+           }
+           if (candles1==candles2 || n+1-candles2==candles1){
+             int ans=Math.min(help(candles1-inPlace, inPlace,n+1,candles2,0,0), help(candles1-inPlace, inPlace,n+1,candles2,0,1));
+             if (ans==Integer.MAX_VALUE) System.out.println(-1);
+             else System.out.println(ans);
+           }
+           else System.out.println(-1);
+        }
+    }
+    static int help(int i, int j, int max, int cands, int moves, int flip){
+        if (j==cands && i==0) return moves;
+        else if (j==0 && flip==0 || flip==1 && i==0 ) return Integer.MAX_VALUE;
+
+            if (flip==0){
+                int x=0;
+                int y=cands-j+1;
+                if (i+j==max-cands){
+                    x=cands-y;
+                }
+                else x=max-cands-y;
+                return help(x,y,max,cands,moves+1,1);
+            }
+            else {
+                int x=0;
+                int y=cands-j;
+                if (i+j==max-cands){
+                    x=cands-y;
+                }
+                else x=max-cands-y;
+                return help(x,y,max,cands,moves+1,0);
+            }
+        
+    }
+    static long mod =998244353L;
+    static long power (long a, long b){
+        long res=1;
+        while (b>0){
+            if ((b&1)== 1){
+                res= (res * a % mod)%mod;
+            }
+            a=(a%mod * a%mod)%mod;
+            b=b>>1;
+        }
+        return res;
+    }
+
+    boolean[] sieveOfEratosthenes(int n)
+    {
+
+        boolean prime[] = new boolean[n+1];
+        for(int i=0;i<=n;i++)
+            prime[i] = true;
+
+        for(int p = 2; p*p <=n; p++)
+        {
+            if(prime[p] == true)
+            {
+                for(int i = p*p; i <= n; i += p)
+                    prime[i] = false;
+            }
+        }
+        return prime;
+    }
+    static void sort(int[] a) {
+        ArrayList<Integer> l=new ArrayList<>();
+        for (int i:a) l.add(i);
+        Collections.sort(l);
+        for (int i=0; i<a.length; i++) a[i]=l.get(i);
+    }
+    static void sortLong(long[] a) {
+        ArrayList<Long> l=new ArrayList<>();
+        for (long i:a) l.add(i);
+        Collections.sort(l);
+        for (int i=0; i<a.length; i++) a[i]=l.get(i);
+    }
+    static long gcd (long n, long m){
+        if (m==0) return n;
+        else return gcd(m, n%m);
+    }
+
+    static class Pair implements Comparable<Pair>{
+        int x,y;
+        public Pair(int x, int y){
+            this.x = x;
+            this.y = y;
+        }
+        public int compareTo(Pair o){
+            return -this.x+o.x;
+        }
+    }
+    static class FastScanner {
+        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st=new StringTokenizer("""");
+        String next() {
+            while (!st.hasMoreTokens())
+                try {
+                    st=new StringTokenizer(br.readLine());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            return st.nextToken();
+        }
+
+        int nextInt() {
+            return Integer.parseInt(next());
+        }
+        int[] readArray(int n) {
+            int[] a=new int[n];
+            for (int i=0; i<n; i++) a[i]=nextInt();
+            return a;
+        }
+        long nextLong() {
+            return Long.parseLong(next());
+        }
+    }
+}",0