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